From 113803cf8147c1b5332cc7d9ac43febcc197e4f0 Mon Sep 17 00:00:00 2001 From: Coccinelle Date: Sun, 3 Oct 2010 13:57:38 +0200 Subject: [PATCH] Release coccinelle-0.1.5 ** Language: - added initialiser metavariable - added sequences of designators in structures ** Features: - improved printing of the C code corresponding to metavariables - improved printing when code (eg declarations) is removed at the beginning of a block, and then is followed by a blank line - slightly less verbose error reporting in parsing_hacks ** Bugfix: - fixed some problems with parsing SmPL code where a nest appears after a | - better treatment of { }, form in macros wrt unparse_c - less quiet for -parse_c - improve parsing heuristics regarding macro statement --- .#Makefile.1.121 | 461 ++ .#main.ml.1.242 | 839 +++ Makefile | 3 +- changes.txt | 18 + commitmsg | 52 +- commons/common.ml | 37 +- commons/common.mli | 13 +- commons/copyright.txt | 2 +- commons/oassoc.ml | 6 + commons/oassoc.mli | 2 + engine/.#cocci_vs_c.ml.1.26 | 3745 ++++++++++ engine/.#pattern_c.ml.1.3 | 494 ++ engine/.#pretty_print_engine.ml.1.43 | 161 + engine/cocci_vs_c.ml | 126 +- engine/pattern_c.ml | 6 + engine/pretty_print_engine.ml | 2 + globals/config.ml | 2 +- main.ml | 14 +- parsing_c/ast_c.ml | 6 + parsing_c/cpp_ast_c.mli | 9 +- parsing_c/lib_parsing_c.ml | 2 + parsing_c/parse_c.ml | 14 +- parsing_c/parser_c.mly | 2 +- parsing_c/parsing_hacks.ml | 87 +- parsing_c/parsing_stat.ml | 6 +- parsing_c/pretty_print_c.ml | 2547 +++---- parsing_c/pretty_print_c.mli | 97 +- parsing_c/unparse_c.ml | 53 +- parsing_c/unparse_cocci.ml | 64 +- parsing_c/unparse_hrule.ml | 5 + parsing_c/visitor_c.ml | 84 +- parsing_cocci/.#arity.ml.1.87 | 1070 +++ parsing_cocci/.#ast0_cocci.ml.1.113 | 670 ++ parsing_cocci/.#ast0toast.ml.1.139 | 934 +++ parsing_cocci/.#ast_cocci.ml.1.149 | 678 ++ parsing_cocci/.#check_meta.ml.1.86 | 535 ++ parsing_cocci/.#compute_lines.ml.1.90 | 769 ++ parsing_cocci/.#context_neg.ml.1.103 | 1013 +++ parsing_cocci/.#data.ml.1.37 | 148 + parsing_cocci/.#disjdistr.ml.1.27 | 395 + parsing_cocci/.#free_vars.ml.1.83 | 787 ++ parsing_cocci/.#index.ml.1.59 | 222 + parsing_cocci/.#iso_pattern.ml.1.150 | 2342 ++++++ parsing_cocci/.#lexer_cocci.mll.1.84 | 704 ++ parsing_cocci/.#parse_aux.ml.1.26 | 475 ++ parsing_cocci/.#parse_cocci.ml.1.178 | 1598 ++++ parsing_cocci/.#parser_cocci_menhir.mly.1.166 | 1847 +++++ parsing_cocci/.#pretty_print_cocci.ml.1.134 | 864 +++ parsing_cocci/.#unify_ast.ml.1.75 | 574 ++ parsing_cocci/.#unparse_ast0.ml.1.116 | 667 ++ parsing_cocci/.#visitor_ast.ml.1.95 | 1056 +++ parsing_cocci/.#visitor_ast0.ml.1.87 | 1041 +++ parsing_cocci/arity.ml | 64 +- parsing_cocci/ast0_cocci.ml | 20 +- parsing_cocci/ast0_cocci.mli | 20 +- parsing_cocci/ast0toast.ml | 22 +- parsing_cocci/ast_cocci.ml | 22 +- parsing_cocci/ast_cocci.mli | 21 +- parsing_cocci/check_meta.ml | 24 +- parsing_cocci/compute_lines.ml | 30 +- parsing_cocci/context_neg.ml | 30 +- parsing_cocci/data.ml | 3 + parsing_cocci/data.mli | 2 + parsing_cocci/disjdistr.ml | 30 +- parsing_cocci/free_vars.ml | 26 +- parsing_cocci/index.ml | 9 +- parsing_cocci/iso_pattern.ml | 139 +- parsing_cocci/lexer_cocci.mll | 8 + parsing_cocci/parse_aux.ml | 7 + parsing_cocci/parse_cocci.ml | 44 +- parsing_cocci/parser_cocci_menhir.ml | 6452 +++++++++-------- parsing_cocci/parser_cocci_menhir.mli | 2 + parsing_cocci/parser_cocci_menhir.mly | 32 +- parsing_cocci/pretty_print_cocci.ml | 25 +- parsing_cocci/unify_ast.ml | 32 +- parsing_cocci/unparse_ast0.ml | 24 +- parsing_cocci/visitor_ast.ml | 53 +- parsing_cocci/visitor_ast0.ml | 57 +- python/.#yes_pycocci_aux.ml.1.1 | 79 + python/yes_pycocci_aux.ml | 1 + tests/ac.c | 17 + tests/ben.c | 24 + tests/ben.cocci | 16 + tests/ben.res | 24 + tests/hil1.c | 6 + tests/hil1.cocci | 5 + tests/hil1.res | 6 + tests/pdbgg.c | 74 + tests/structfoo.c | 4 + tests/structfoo.cocci | 9 + tests/structfoo.res | 1 + 91 files changed, 29924 insertions(+), 4888 deletions(-) create mode 100644 .#Makefile.1.121 create mode 100644 .#main.ml.1.242 rewrite commitmsg (97%) create mode 100644 engine/.#cocci_vs_c.ml.1.26 create mode 100644 engine/.#pattern_c.ml.1.3 create mode 100644 engine/.#pretty_print_engine.ml.1.43 rewrite parsing_c/pretty_print_c.ml (69%) rewrite parsing_c/pretty_print_c.mli (81%) create mode 100644 parsing_cocci/.#arity.ml.1.87 create mode 100644 parsing_cocci/.#ast0_cocci.ml.1.113 create mode 100644 parsing_cocci/.#ast0toast.ml.1.139 create mode 100644 parsing_cocci/.#ast_cocci.ml.1.149 create mode 100644 parsing_cocci/.#check_meta.ml.1.86 create mode 100644 parsing_cocci/.#compute_lines.ml.1.90 create mode 100644 parsing_cocci/.#context_neg.ml.1.103 create mode 100644 parsing_cocci/.#data.ml.1.37 create mode 100644 parsing_cocci/.#disjdistr.ml.1.27 create mode 100644 parsing_cocci/.#free_vars.ml.1.83 create mode 100644 parsing_cocci/.#index.ml.1.59 create mode 100644 parsing_cocci/.#iso_pattern.ml.1.150 create mode 100644 parsing_cocci/.#lexer_cocci.mll.1.84 create mode 100644 parsing_cocci/.#parse_aux.ml.1.26 create mode 100644 parsing_cocci/.#parse_cocci.ml.1.178 create mode 100644 parsing_cocci/.#parser_cocci_menhir.mly.1.166 create mode 100644 parsing_cocci/.#pretty_print_cocci.ml.1.134 create mode 100644 parsing_cocci/.#unify_ast.ml.1.75 create mode 100644 parsing_cocci/.#unparse_ast0.ml.1.116 create mode 100644 parsing_cocci/.#visitor_ast.ml.1.95 create mode 100644 parsing_cocci/.#visitor_ast0.ml.1.87 create mode 100644 python/.#yes_pycocci_aux.ml.1.1 create mode 100644 tests/ac.c create mode 100644 tests/ben.c create mode 100644 tests/ben.cocci create mode 100644 tests/ben.res create mode 100644 tests/hil1.c create mode 100644 tests/hil1.cocci create mode 100644 tests/hil1.res create mode 100644 tests/pdbgg.c create mode 100644 tests/structfoo.c create mode 100644 tests/structfoo.cocci create mode 100644 tests/structfoo.res diff --git a/.#Makefile.1.121 b/.#Makefile.1.121 new file mode 100644 index 0000000..c20c3cf --- /dev/null +++ b/.#Makefile.1.121 @@ -0,0 +1,461 @@ +# Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +# Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +# 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 . +# +# The authors reserve the right to distribute this or future versions of +# Coccinelle under other licenses. + + +############################################################################# +# Configuration section +############################################################################# + +-include Makefile.config + +VERSION=$(shell cat globals/config.ml |grep version |perl -p -e 's/.*"(.*)".*/$$1/;') + +############################################################################## +# Variables +############################################################################## +TARGET=spatch + +SRC=flag_cocci.ml cocci.ml testing.ml test.ml main.ml + + +ifeq ($(FEATURE_PYTHON),1) +PYCMA=pycaml/pycaml.cma +PYDIR=pycaml +PYLIB=dllpycaml_stubs.so +# the following is essential for Coccinelle to compile under gentoo (wierd) +OPTLIBFLAGS=-cclib dllpycaml_stubs.so +else +PYCMA= +PYDIR= +PYLIB= +OPTLIBFLAGS= +endif + + +SYSLIBS=str.cma unix.cma +LIBS=commons/commons.cma globals/globals.cma\ + ctl/ctl.cma \ + parsing_cocci/cocci_parser.cma parsing_c/parsing_c.cma \ + engine/cocciengine.cma popl09/popl.cma \ + extra/extra.cma $(PYCMA) python/coccipython.cma + +MAKESUBDIRS=commons globals menhirlib $(PYDIR) ctl parsing_cocci parsing_c \ + engine popl09 extra python +INCLUDEDIRS=commons commons/ocamlextra globals menhirlib $(PYDIR) ctl \ + parsing_cocci parsing_c engine popl09 extra python + +############################################################################## +# Generic variables +############################################################################## + +INCLUDES=$(INCLUDEDIRS:%=-I %) + +OBJS= $(SRC:.ml=.cmo) +OPTOBJS= $(SRC:.ml=.cmx) + +EXEC=$(TARGET) + +############################################################################## +# Generic ocaml variables +############################################################################## + +OCAMLCFLAGS= #-g -dtypes # -w A + +# for profiling add -p -inline 0 +# but 'make forprofiling' below does that for you. +# This flag is also used in subdirectories so don't change its name here. +OPTFLAGS= +# the following is essential for Coccinelle to compile under gentoo +# but is now defined above in this file +#OPTLIBFLAGS=-cclib dllpycaml_stubs.so + +# the OPTBIN variable is here to allow to use ocamlc.opt instead of +# ocaml, when it is available, which speeds up compilation. So +# if you want the fast version of the ocaml chain tools, set this var +# or setenv it to ".opt" in your startup script. +OPTBIN= #.opt + +OCAMLC=ocamlc$(OPTBIN) $(OCAMLCFLAGS) $(INCLUDES) +OCAMLOPT=ocamlopt$(OPTBIN) $(OPTFLAGS) $(INCLUDES) +OCAMLLEX=ocamllex #-ml # -ml for debugging lexer, but slightly slower +OCAMLYACC=ocamlyacc -v +OCAMLDEP=ocamldep #$(INCLUDES) +OCAMLMKTOP=ocamlmktop -g -custom $(INCLUDES) + +# can also be set via 'make static' +STATIC= #-ccopt -static + +# can also be unset via 'make purebytecode' +BYTECODE_STATIC=-custom + +############################################################################## +# Top rules +############################################################################## +.PHONY: all all.opt opt top clean configure +.PHONY: $(MAKESUBDIRS) $(MAKESUBDIRS:%=%.opt) + +all: + $(MAKE) subdirs + $(MAKE) $(EXEC) + +opt: + $(MAKE) subdirs.opt + $(MAKE) $(EXEC).opt + +all.opt: opt +top: $(EXEC).top + +subdirs: $(MAKESUBDIRS) +subdirs.opt: $(MAKESUBDIRS:%=%.opt) + +$(MAKESUBDIRS): + $(MAKE) -C $@ OCAMLCFLAGS="$(OCAMLCFLAGS)" all + +$(MAKESUBDIRS:%=%.opt): + $(MAKE) -C $(@:%.opt=%) OCAMLCFLAGS="$(OCAMLCFLAGS)" all.opt + +commons: +globals: +menhirlib: +parsing_cocci:globals menhirlib +parsing_c:parsing_cocci +ctl:globals commons +engine: parsing_cocci parsing_c ctl +popl09:engine +extra: parsing_cocci parsing_c ctl +pycaml: +python:pycaml parsing_cocci parsing_c + +commons.opt: +globals.opt: +menhirlib.opt: +parsing_cocci.opt:globals.opt menhirlib.opt +parsing_c.opt:parsing_cocci.opt +ctl.opt:globals.opt commons.opt +engine.opt: parsing_cocci.opt parsing_c.opt ctl.opt +popl09.opt:engine.opt +extra.opt: parsing_cocci.opt parsing_c.opt ctl.opt +pycaml.opt: +python.opt:pycaml.opt parsing_cocci.opt parsing_c.opt + +clean:: + set -e; for i in $(MAKESUBDIRS); do $(MAKE) -C $$i clean; done + +configure: + ./configure + +$(LIBS): #$(MAKESUBDIRS) +$(LIBS:.cma=.cmxa): #$(MAKESUBDIRS:%=%.opt) + +$(OBJS):$(LIBS) +$(OPTOBJS):$(LIBS:.cma=.cmxa) + +$(EXEC): $(LIBS) $(OBJS) + $(OCAMLC) $(BYTECODE_STATIC) -o $@ $(SYSLIBS) $^ + +$(EXEC).opt: $(LIBS:.cma=.cmxa) $(OPTOBJS) + $(OCAMLOPT) $(STATIC) -o $@ $(SYSLIBS:.cma=.cmxa) $(OPTLIBFLAGS) $^ + +$(EXEC).top: $(LIBS) $(OBJS) + $(OCAMLMKTOP) -custom -o $@ $(SYSLIBS) $^ + +clean:: + rm -f $(TARGET) $(TARGET).opt $(TARGET).top + +clean:: + rm -f dllpycaml_stubs.so + + +.PHONY: tools all configure + +tools: + $(MAKE) -C tools +clean:: + $(MAKE) -C tools clean + + +static: + rm -f spatch.opt spatch + $(MAKE) STATIC="-ccopt -static" spatch.opt + cp spatch.opt spatch + +purebytecode: + rm -f spatch.opt spatch + $(MAKE) BYTECODE_STATIC="" spatch + + +############################################################################## +# Install +############################################################################## + +# don't remove DESTDIR, it can be set by package build system like ebuild +install: all + mkdir -p $(DESTDIR)$(BINDIR) + mkdir -p $(DESTDIR)$(LIBDIR) + mkdir -p $(DESTDIR)$(SHAREDIR) + mkdir -p $(DESTDIR)$(MANDIR)/man1 + cp spatch $(DESTDIR)$(BINDIR) + cp standard.h $(DESTDIR)$(SHAREDIR) + cp standard.iso $(DESTDIR)$(SHAREDIR) + cp docs/spatch.1 $(DESTDIR)$(MANDIR)/man1/ + mkdir -p $(DESTDIR)$(SHAREDIR)/python + cp -a python/coccilib $(DESTDIR)$(SHAREDIR)/python + cp -f dllpycaml_stubs.so $(DESTDIR)$(LIBDIR) + @echo "" + @echo "You can also install spatch by copying the program spatch" + @echo "(available in this directory) anywhere you want and" + @echo "give it the right options to find its configuration files." + +uninstall: + rm -f $(DESTDIR)$(BINDIR)/spatch + rm -f $(DESTDIR)$(LIBDIR)/dllpycaml_stubs.so + rm -f $(DESTDIR)$(SHAREDIR)/standard.h + rm -f $(DESTDIR)$(SHAREDIR)/standard.iso + rm -rf $(DESTDIR)$(SHAREDIR)/python/coccilib + rm -f $(DESTDIR)$(MANDIR)/man1/spatch.1 + + + +version: + @echo $(VERSION) + + +############################################################################## +# Package rules +############################################################################## + +PACKAGE=coccinelle-$(VERSION) + +BINSRC=spatch env.sh env.csh standard.h standard.iso \ + *.txt docs/* \ + demos/foo.* demos/simple.* +# $(PYLIB) python/coccilib/ demos/printloc.* +BINSRC2=$(BINSRC:%=$(PACKAGE)/%) + +TMP=/tmp +OCAMLVERSION=$(shell ocaml -version |perl -p -e 's/.*version (.*)/$$1/;') + +# Procedure to do first time: +# cd ~/release +# cvs checkout coccinelle +# cd coccinelle +# cvs update -d -P +# touch **/* +# make licensify +# remember to comment the -g -dtypes in this Makefile + +# Procedure to do each time: +# cvs update +# modify globals/config.ml +# cd globals/; cvs commit -m"new version" (do not commit from the root!) +# ./configure --without-python +# make package +# make website +# Check also that run an ocaml in /usr/bin + +# To test you can try compile and run spatch from different instances +# like my ~/coccinelle, ~/release/coccinelle, and the /tmp/coccinelle-0.X +# downloaded from the website. + +# For 'make srctar' it must done from a clean +# repo such as ~/release/coccinelle. It must also be a repo where +# the scripts/licensify has been run at least once. +# For the 'make bintar' I can do it from my original repo. + + +package: + make srctar + make bintar + make staticbintar + make bytecodetar + +# I currently pre-generate the parser so the user does not have to +# install menhir on his machine. I also do a few cleanups like 'rm todo_pos'. +# You may have first to do a 'make licensify'. +srctar: + make clean + cp -a . $(TMP)/$(PACKAGE) + cd $(TMP)/$(PACKAGE); cd parsing_cocci/; make parser_cocci_menhir.ml + cd $(TMP)/$(PACKAGE); rm todo_pos + cd $(TMP); tar cvfz $(PACKAGE).tgz --exclude-vcs $(PACKAGE) + rm -rf $(TMP)/$(PACKAGE) + + +bintar: all + rm -f $(TMP)/$(PACKAGE) + ln -s `pwd` $(TMP)/$(PACKAGE) + cd $(TMP); tar cvfz $(PACKAGE)-bin-x86.tgz --exclude-vcs $(BINSRC2) + rm -f $(TMP)/$(PACKAGE) + +staticbintar: all.opt + rm -f $(TMP)/$(PACKAGE) + ln -s `pwd` $(TMP)/$(PACKAGE) + make static + cd $(TMP); tar cvfz $(PACKAGE)-bin-x86-static.tgz --exclude-vcs $(BINSRC2) + rm -f $(TMP)/$(PACKAGE) + +# add ocaml version in name ? +bytecodetar: all + rm -f $(TMP)/$(PACKAGE) + ln -s `pwd` $(TMP)/$(PACKAGE) + make purebytecode + cd $(TMP); tar cvfz $(PACKAGE)-bin-bytecode-$(OCAMLVERSION).tgz --exclude-vcs $(BINSRC2) + rm -f $(TMP)/$(PACKAGE) + +clean:: + rm -f $(PACKAGE) + rm -f $(PACKAGE)-bin-x86.tgz + rm -f $(PACKAGE)-bin-x86-static.tgz + rm -f $(PACKAGE)-bin-bytecode-$(OCAMLVERSION).tgz + + + +TOLICENSIFY=ctl engine parsing_cocci popl popl09 python +licensify: + ocaml tools/licensify.ml + set -e; for i in $(TOLICENSIFY); do cd $$i; ocaml ../tools/licensify.ml; cd ..; done + +# When checking out the source from diku sometimes I have some "X in the future" +# error messages. +fixdates: + echo do 'touch **/*.*' + +#fixCVS: +# cvs update -d -P +# echo do 'rm -rf **/CVS' + +ocamlversion: + @echo $(OCAMLVERSION) + + +############################################################################## +# Pad specific rules +############################################################################## + +#TOP=/home/pad/mobile/project-coccinelle +WEBSITE=/home/pad/mobile/homepage/software/project-coccinelle + +website: + cp $(TMP)/$(PACKAGE).tgz $(WEBSITE) + cp $(TMP)/$(PACKAGE)-bin-x86.tgz $(WEBSITE) + cp $(TMP)/$(PACKAGE)-bin-x86-static.tgz $(WEBSITE) + cp $(TMP)/$(PACKAGE)-bin-bytecode-$(OCAMLVERSION).tgz $(WEBSITE) + + +#TXT=$(wildcard *.txt) +syncwiki: +# unison ~/public_html/wiki/wiki-LFS/data/pages/ docs/wiki/ +# set -e; for i in $(TXT); do unison $$i docs/wiki/$$i; done + +darcsweb: +# @echo pull from ~/public_html/darcs/c-coccinelle and c-commons and lib-xxx + +DARCSFORESTS=commons \ + parsing_c parsing_cocci engine + +update_darcs: + darcs pull + set -e; for i in $(DARCSFORESTS); do cd $$i; darcs pull; cd ..; done + +#darcs diff -u +diff_darcs: + set -e; for i in $(DARCSFORESTS); do cd $$i; darcs diff -u; cd ..; done + + +############################################################################## +# Developer rules +############################################################################## + +test: $(TARGET) + ./$(TARGET) -testall + +testparsing: + ./$(TARGET) -D standard.h -parse_c -dir tests/ + + + +# -inline 0 to see all the functions in the profile. +# Can also use the profile framework in commons/ and run your program +# with -profile. +forprofiling: + $(MAKE) OPTFLAGS="-p -inline 0 " opt + +clean:: + rm -f gmon.out + +tags: + otags -no-mli-tags -r . + +dependencygraph: + find -name "*.ml" |grep -v "scripts" | xargs ocamldep -I commons -I globals -I ctl -I parsing_cocci -I parsing_c -I engine -I popl09 -I extra > /tmp/dependfull.depend + ocamldot -lr /tmp/dependfull.depend > /tmp/dependfull.dot + dot -Tps /tmp/dependfull.dot > /tmp/dependfull.ps + ps2pdf /tmp/dependfull.ps /tmp/dependfull.pdf + +############################################################################## +# Misc rules +############################################################################## + +# each member of the project can have its own test.ml. this file is +# not under CVS. +test.ml: + echo "let foo_ctl () = failwith \"there is no foo_ctl formula\"" \ + > test.ml + +beforedepend:: test.ml + + +#INC=$(dir $(shell which ocaml)) +#INCX=$(INC:/=) +#INCY=$(dir $(INCX)) +#INCZ=$(INCY:/=)/lib/ocaml +# +#prim.o: prim.c +# gcc -c -o prim.o -I $(INCZ) prim.c + + +############################################################################## +# Generic ocaml rules +############################################################################## + +.SUFFIXES: .ml .mli .cmo .cmi .cmx + +.ml.cmo: + $(OCAMLC) -c $< +.mli.cmi: + $(OCAMLC) -c $< +.ml.cmx: + $(OCAMLOPT) -c $< + +.ml.mldepend: + $(OCAMLC) -i $< + +clean:: + rm -f *.cm[iox] *.o *.annot + +clean:: + rm -f *~ .*~ *.exe #*# + +beforedepend:: + +depend:: beforedepend + $(OCAMLDEP) *.mli *.ml > .depend + set -e; for i in $(MAKESUBDIRS); do $(MAKE) -C $$i depend; done + +-include .depend diff --git a/.#main.ml.1.242 b/.#main.ml.1.242 new file mode 100644 index 0000000..393cc31 --- /dev/null +++ b/.#main.ml.1.242 @@ -0,0 +1,839 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +open Common +module FC = Flag_cocci + +(*****************************************************************************) +(* Flags *) +(*****************************************************************************) + +(* In addition to flags that can be tweaked via -xxx options (cf the + * full list of options in "the spatch options" section below), the + * spatch program also depends on external files, described in + * globals/config.ml, mainly a standard.h and standard.iso file *) + +let cocci_file = ref "" + +let output_file = ref "" +let inplace_modif = ref false (* but keeps a .cocci_orig *) +let outplace_modif = ref false (* generates a .cocci_res *) + +(* could be avoided by using Common.files_of_dir_or_files instead *) +let dir = ref false + +let include_headers = ref false +let kbuild_info = ref "" + +(* test mode *) +let test_mode = ref false +let test_all = ref false +let test_okfailed = ref false +let test_regression_okfailed = ref false + + +(* action mode *) +let action = ref "" + +(* works with -test but also in "normal" spatch mode *) +let compare_with_expected = ref false + + +let distrib_index = ref (None : int option) +let distrib_max = ref (None : int option) +let mod_distrib = ref false + + +(*****************************************************************************) +(* Profiles *) +(*****************************************************************************) + +(* pair of (list of flags to set true, list of flags to set false *) +let quiet_profile = ( + [ + ], + [ + (* FC.show_diff; just leave this as it is *) + + Flag.show_misc; + Flag.show_trying; + Flag.show_transinfo; + + FC.show_c; + FC.show_cocci; + FC.show_flow; + FC.show_before_fixed_flow; + FC.show_ctl_tex; + FC.show_ctl_text; + FC.show_binding_in_out; + + Flag_parsing_cocci.show_SP; + Flag_parsing_cocci.show_iso_failures; + Flag_ctl.verbose_ctl_engine; + Flag_ctl.verbose_match; + Flag_matcher.debug_engine; + Flag_parsing_c.debug_unparsing; + Flag_parsing_c.verbose_type; + Flag_parsing_c.verbose_parsing; + ]) + +(* some information that is useful in seeing why a semantic patch doesn't +work properly *) +let debug_profile = ( + [ + Flag.show_misc; + FC.show_diff; + FC.show_cocci; + FC.show_binding_in_out; + FC.show_dependencies; + Flag.show_transinfo; + Flag_parsing_cocci.show_iso_failures; + ], + [ + + Flag.show_misc; + + FC.show_c; + FC.show_flow; + FC.show_before_fixed_flow; + FC.show_ctl_tex; + FC.show_ctl_text; + + Flag_parsing_cocci.show_SP; + Flag_ctl.verbose_ctl_engine; + Flag_ctl.verbose_match; + Flag_matcher.debug_engine; + Flag_parsing_c.debug_unparsing; + Flag_parsing_c.verbose_type; + Flag_parsing_c.verbose_parsing; + ]) + +let pad_profile = ( + [ + FC.show_diff; + ], + [ + + Flag.show_misc; + Flag.show_transinfo; + + FC.show_c; + FC.show_cocci; + FC.show_flow; + FC.show_before_fixed_flow; + FC.show_ctl_tex; + FC.show_ctl_text; + FC.show_binding_in_out; + + Flag_parsing_cocci.show_SP; + Flag_parsing_cocci.show_iso_failures; + Flag_ctl.verbose_ctl_engine; + Flag_ctl.verbose_match; + Flag_matcher.debug_engine; + Flag_parsing_c.debug_unparsing; + Flag_parsing_c.verbose_type; + Flag_parsing_c.verbose_parsing; + ]) + +let run_profile p = + let (set_to_true, set_to_false) = p in + List.iter (fun x -> x := false) set_to_false; + List.iter (fun x -> x := true) set_to_true + +(*****************************************************************************) +(* The spatch options *) +(*****************************************************************************) + +let usage_msg = + "Usage: " ^ basename Sys.argv.(0) ^ + " -sp_file [-o ] [-iso_file ] [options]" ^ + "\n" ^ "Options are:" + +(* forward reference trick *) +let short_usage_func = ref (fun () -> ()) +let long_usage_func = ref (fun () -> ()) + + +(* The short_options are user-oriented. The other options are for + * the developers of coccinelle or advanced-users that know + * quite well the underlying semantics of coccinelle. + *) + + +(* will be printed when use only ./spatch. For the rest you have to + * use -longhelp to see them. + *) +let short_options = [ + "-sp_file", Arg.Set_string cocci_file, + " the semantic patch file"; + + "-o", Arg.Set_string output_file, + " the output file"; + "-inplace", Arg.Set inplace_modif, + " do the modification on the file directly"; + "-outplace", Arg.Set outplace_modif, + " store modifications in a .cocci_res file"; + + "-U", Arg.Int (fun n -> Flag_parsing_c.diff_lines := Some (i_to_s n)), + " set number of diff context lines"; + "-partial_match", Arg.Set Flag_ctl.partial_match, + " report partial matches of the SP on the C file"; + + "-iso_file", Arg.Set_string Config.std_iso, + " (default=" ^ !Config.std_iso ^")"; + "-macro_file", Arg.Set_string Config.std_h, + " (default=" ^ !Config.std_h ^ ")"; + + "-all_includes", + Arg.Unit (function _ -> FC.include_options := FC.I_ALL_INCLUDES), + " causes all available include files to be used"; + "-no_includes", + Arg.Unit (function _ -> FC.include_options := FC.I_NO_INCLUDES), + " causes not even local include files to be used"; + "-local_includes", + Arg.Unit (function _ -> FC.include_options := FC.I_NORMAL_INCLUDES), + " causes local include files to be used"; + "-include_headers", Arg.Set include_headers, + " process header files independently"; + "-I", Arg.Set_string FC.include_path, + " containing the Linux headers (optional)"; + + + "-dir", Arg.Set dir, + " process all files in directory recursively"; + + "-use_glimpse", Arg.Set Flag.use_glimpse, + " works with -dir, use info generated by glimpseindex"; + "-patch", Arg.String (function s -> Flag.patch := Some s), + (" path name with respect to which a patch should be created\n"^ + " \"\" for a file in the current directory"); + "-kbuild_info", Arg.Set_string kbuild_info, + " improve -dir by grouping related c files"; + "-pyoutput", Arg.Set_string Flag.pyoutput, + " Sets output routine: Standard values: "; + + + "-version", Arg.Unit (fun () -> + pr2 (spf "spatch version: %s" Config.version); + exit 0; + ), + " guess what"; + + "-date", Arg.Unit (fun () -> + pr2 "version: $Date: 2009/01/02 10:28:28 $"; + raise (Common.UnixExit 0) + ), + " guess what"; + + "-shorthelp", Arg.Unit (fun () -> + !short_usage_func(); + raise (Common.UnixExit 0) + ), + " see short list of options"; + "-longhelp", Arg.Unit (fun () -> + !long_usage_func(); + raise (Common.UnixExit 0) + ), + " see all the available options in different categories"; + "-help", Arg.Unit (fun () -> + !long_usage_func(); + raise (Common.UnixExit 0) + ), + " "; + "--help", Arg.Unit (fun () -> + !long_usage_func(); + raise (Common.UnixExit 0) + ), + " "; + +] + +(* the format is a list of triples: + * (title of section * (optional) explanation of sections * option list) + *) +let other_options = [ + "aliases and obsolete options", + "", + [ + "-cocci_file", Arg.Set_string cocci_file, + " the semantic patch file"; + "-c", Arg.Set_string cocci_file, " short option of -cocci_file"; + "-iso", Arg.Set_string Config.std_iso, " short option of -iso_file"; + "-D", Arg.Set_string Config.std_h, " short option of -macro_file"; + ]; + + "most useful show options", + "", + [ + "-show_diff" , Arg.Set FC.show_diff, " "; + "-no_show_diff" , Arg.Clear FC.show_diff, " "; + "-show_flow" , Arg.Set FC.show_flow, " "; + (* works in conjunction with -show_ctl_text *) + "-ctl_inline_let", + Arg.Unit + (function _ -> FC.show_ctl_text := true; FC.inline_let_ctl := true), " "; + "-ctl_show_mcodekind", + Arg.Unit + (function _ -> FC.show_ctl_text := true; FC.show_mcodekind_in_ctl := true), + " "; + "-show_bindings", Arg.Set FC.show_binding_in_out, " "; + "-show_transinfo", Arg.Set Flag.show_transinfo, " "; + "-show_misc", Arg.Set Flag.show_misc, " "; + "-show_trying", Arg.Set Flag.show_trying, + " show the name of each function being processed"; + "-show_dependencies", + Arg.Unit (function _ -> FC.show_dependencies := true; + FC.show_binding_in_out := true), + " show the dependencies related to each rule"; + ]; + + "verbose subsystems options", + "", + [ + "-verbose_ctl_engine", + Arg.Unit (function _ -> + Flag_ctl.verbose_ctl_engine := true; FC.show_ctl_text := true) , " "; + "-verbose_match", Arg.Set Flag_ctl.verbose_match, " "; + "-verbose_engine", Arg.Set Flag_matcher.debug_engine, " "; + "-graphical_trace", Arg.Set Flag_ctl.graphical_trace, " generate a pdf file representing the matching process"; + "-gt_without_label", + Arg.Unit (function _ -> + Flag_ctl.graphical_trace := true; Flag_ctl.gt_without_label := true), + " remove graph label (requires option -graphical_trace)"; + + "-parse_error_msg", Arg.Set Flag_parsing_c.verbose_parsing, " "; + "-type_error_msg", Arg.Set Flag_parsing_c.verbose_type, " "; + (* could also use Flag_parsing_c.options_verbose *) + ]; + + "other show options", + "", + [ + "-show_c" , Arg.Set FC.show_c, " "; + "-show_cocci" , Arg.Set FC.show_cocci, " "; + "-show_before_fixed_flow" , Arg.Set FC.show_before_fixed_flow, " "; + "-show_ctl_tex" , Arg.Set FC.show_ctl_tex, " "; + "-show_ctl_text" , Arg.Set FC.show_ctl_text, " "; + "-show_SP" , Arg.Set Flag_parsing_cocci.show_SP, " "; + ]; + + + "debug C parsing/unparsing", + "", + [ + "-debug_cpp", Arg.Set Flag_parsing_c.debug_cpp, " "; + "-debug_lexer", Arg.Set Flag_parsing_c.debug_lexer , " "; + "-debug_etdt", Arg.Set Flag_parsing_c.debug_etdt , " "; + "-debug_typedef", Arg.Set Flag_parsing_c.debug_typedef, " "; + + "-filter_msg", Arg.Set Flag_parsing_c.filter_msg , + " filter some cpp message when the macro is a \"known\" cpp construct"; + "-filter_define_error",Arg.Set Flag_parsing_c.filter_define_error," "; + "-filter_passed_level", Arg.Set_int Flag_parsing_c.filter_passed_level," "; +(* debug cfg doesn't seem to have any effect, so drop it as an option *) +(* "-debug_cfg", Arg.Set Flag_parsing_c.debug_cfg , " "; *) + "-debug_unparsing", Arg.Set Flag_parsing_c.debug_unparsing, " "; + + ]; + (* could use Flag_parsing_c.options_debug_with_title instead *) + + + "shortcut for enabling/disabling a set of debugging options at once", + "", + [ + (* todo: other profile ? *) + "-quiet", Arg.Unit (fun () -> run_profile quiet_profile), " "; + "-debug", Arg.Unit (fun () -> run_profile debug_profile), " "; + "-pad", Arg.Unit (fun () -> run_profile pad_profile), " "; + + ]; + + "bench options", + "", + [ + "-profile", Arg.Unit (function () -> Common.profile := Common.PALL) , + " gather timing information about the main coccinelle functions"; + "-bench", Arg.Int (function x -> Flag_ctl.bench := x), + " for profiling the CTL engine"; + "-timeout", Arg.Int (fun x -> FC.timeout := Some x), + " timeout in seconds"; + "-steps", Arg.Int (fun x -> Flag_ctl.steps := Some x), + " max number of model checking steps per code unit"; + "-track_iso", Arg.Set Flag.track_iso_usage, + " gather information about isomorphism usage"; + "-profile_iso", + Arg.Unit + (function () -> + Common.profile:=PSOME ["parse cocci";"mysat";"asttoctl2";"full_engine"]), + " gather information about the cost of isomorphism usage" + ]; + + + + "change of algorithm options", + "", + [ + "-popl", Arg.Set FC.popl, + " simplified SmPL, for the popl paper"; + + "-popl_mark_all", + Arg.Unit + (function _ -> FC.popl := true; Flag_popl.mark_all := true), + " simplified SmPL, for the popl paper"; + + "-popl_keep_all_wits", + Arg.Unit + (function _ -> FC.popl := true; Flag_popl.keep_all_wits := true), + " simplified SmPL, for the popl paper"; + + "-hrule", Arg.String + (function s -> + Flag.make_hrule := Some s; FC.include_options := FC.I_NO_INCLUDES), + " semantic patch generation"; + + "-loop", Arg.Set Flag_ctl.loop_in_src_code, " "; + + "-l1", Arg.Clear Flag_parsing_c.label_strategy_2, " "; + "-ifdef_to_if", Arg.Set FC.ifdef_to_if, + " convert ifdef to if (experimental)"; + + "-noif0_passing", Arg.Clear Flag_parsing_c.if0_passing, + " "; + "-noadd_typedef_root", Arg.Clear Flag_parsing_c.add_typedef_root, " "; + (* could use Flag_parsing_c.options_algo instead *) + + + "-disallow_nested_exps", Arg.Set Flag_matcher.disallow_nested_exps, + "disallow an expresion pattern from matching a term and its subterm"; + "-disable_worth_trying_opt", Arg.Clear FC.worth_trying_opt, + " "; + "-only_return_is_error_exit", + Arg.Set Flag_matcher.only_return_is_error_exit, + "if this flag is not set, then break and continue are also error exits"; + (* the following is a hack to make it easier to add code in sgrep-like + code, essentially to compensate for the fact that we don't have + any way of printing things out *) + "-allow_inconsistent_paths", + Arg.Set Flag_matcher.allow_inconsistent_paths, + "if this flag is set don't check for inconsistent paths; dangerous"; + ]; + + "misc options", + "", + [ + "-debugger", Arg.Set Common.debugger , + " option to set if launch spatch in ocamldebug"; + "-disable_once", Arg.Set Common.disable_pr2_once, + " to print more messages"; + "-save_tmp_files", Arg.Set Common.save_tmp_files, " "; + ]; + + "concurrency", + "", + [ + "-index", Arg.Int (function x -> distrib_index := Some x) , + " the processor to use for this run of spatch"; + "-max", Arg.Int (function x -> distrib_max := Some x) , + " the number of processors available"; + "-mod_distrib", Arg.Set mod_distrib, + " use mod to distribute files among the processors"; + ]; + + "pad options", + "", + [ + "-use_cache", Arg.Set Flag_parsing_c.use_cache, + " use .ast_raw pre-parsed cached C file"; + (* could use Flag_parsing_c.options_pad instead *) + ]; + + + + "test mode and test options (works with tests/ or .ok files)", + "The test options don't work with the -sp_file and so on.", + [ + "-test", Arg.Set test_mode, + " launch spatch on tests/file.[c,cocci]"; + "-testall", Arg.Set test_all, + " launch spatch on all files in tests/ having a .res"; + "-test_okfailed", Arg.Set test_okfailed, + " generates .{ok,failed,spatch_ok} files using .res files"; + "-test_regression_okfailed", Arg.Set test_regression_okfailed, + " process the .{ok,failed,spatch_ok} files in current dir"; + + "-compare_with_expected", Arg.Set compare_with_expected, + " use also file.res"; + "-relax_include_path", Arg.Set FC.relax_include_path, + " "; + + ]; + + "action mode", + ("The action options don't work with the -sp_file and so on." ^ "\n" ^ + "It's for the other (internal) uses of the spatch program." + ), + + (* -token_c, -parse_c, etc *) + ((Common.options_of_actions action (Test_parsing_c.actions())) ++ + [ + (let s = "-parse_cocci" in s, Arg.Unit (fun () -> action := s), + " "); + (let s = "-compare_c" in s, Arg.Unit (fun () -> action := s), + " "); + ]); +] + + +let all_options = + short_options ++ List.concat (List.map Common.thd3 other_options) + + + +(* I don't want the -help and --help that are appended by Arg.align *) +let arg_align2 xs = + Arg.align xs +> List.rev +> Common.drop 2 +> List.rev + +(* copy paste of Arg.parse. Don't want the default -help msg *) +let arg_parse2 l f msg = + (try + Arg.parse_argv Sys.argv l f msg; + with + | Arg.Bad msg -> (* eprintf "%s" msg; exit 2; *) + let xs = Common.lines msg in + (* take only head, it's where the error msg is *) + pr2 (List.hd xs); + !short_usage_func(); + raise (Common.UnixExit (2)) + | Arg.Help msg -> (* printf "%s" msg; exit 0; *) + raise Impossible (* -help is specified in speclist *) + ) + + +let short_usage () = + begin + Common.short_usage usage_msg short_options; + pr2 ""; + pr2 "Example of use:"; + pr2 " ./spatch -sp_file foo.cocci foo.c -o /tmp/newfoo.c"; + pr2 ""; + end + + +let long_usage () = + Common.long_usage usage_msg short_options other_options + +let _ = short_usage_func := short_usage +let _ = long_usage_func := long_usage + +(*****************************************************************************) +(* Helpers *) +(*****************************************************************************) + +let adjust_stdin cfile k = + if !dir + then k() + else + let newin = + try + let (dir, base, ext) = Common.dbe_of_filename cfile in + let varfile = Common.filename_of_dbe (dir, base, "var") in + if ext = "c" && Common.lfile_exists varfile + then Some varfile + else None + with Invalid_argument("Filename.chop_extension") -> None + in + Common.redirect_stdin_opt newin k + +let glimpse_filter (coccifile, isofile) dir = + let (_metavars,astcocci,_free_var_lists,_negated_positions, + _used_after_lists,_positions_lists,_,query) = + Cocci.sp_of_file coccifile (Some isofile) in + match query with + None -> pr2 "no glimpse keyword inferred from snippet"; None + | Some query -> + let suffixes = if !include_headers then ["c";"h"] else ["c"] in + pr2 ("glimpse request = " ^ query); + let command = spf "glimpse -y -H %s -N -W -w '%s'" dir query in + let (glimpse_res,stat) = Common.cmd_to_list_and_status command in + match stat with + Unix.WEXITED(0) | Unix.WEXITED(1) -> + Some + (glimpse_res +> + List.filter + (fun file -> List.mem (Common.filesuffix file) suffixes)) + | _ -> None (* error, eg due to pattern too big *) + + + + +(*****************************************************************************) +(* The coccinelle main entry point *) +(*****************************************************************************) +let main () = + begin + let args = ref [] in + + arg_parse2 (Arg.align all_options) (fun x -> args := x::!args) usage_msg; + + (if !dir && List.length !args > 1 + then + begin + let chosen = List.hd !args in + pr2 ("ignoring all but the last specified directory: "^chosen); + args := [chosen] + end); + args := List.rev !args; + + if !cocci_file <> "" && (not (!cocci_file =~ ".*\\.\\(sgrep\\|spatch\\)$")) + then cocci_file := Common.adjust_ext_if_needed !cocci_file ".cocci"; + + if !Config.std_iso <> "" + then Config.std_iso := Common.adjust_ext_if_needed !Config.std_iso ".iso"; + if !Config.std_h <> "" + then Config.std_h := Common.adjust_ext_if_needed !Config.std_h ".h"; + + if !Config.std_h <> "" + then Parse_c.init_defs !Config.std_h; + + + (* must be done after Arg.parse, because Common.profile is set by it *) + Common.profile_code "Main total" (fun () -> + + + let all_actions = Test_parsing_c.actions() in + + (match (!args) with + + (* --------------------------------------------------------- *) + (* The test framework. Works with tests/ or .ok and .failed *) + (* --------------------------------------------------------- *) + | [x] when !test_mode -> + FC.include_path := "tests/include"; + Testing.testone x !compare_with_expected + + | [] when !test_all -> + FC.include_path := "tests/include"; + Testing.testall () + + | [] when !test_regression_okfailed -> + Testing.test_regression_okfailed () + + | x::xs when !test_okfailed -> + (* do its own timeout on FC.timeout internally *) + FC.relax_include_path := true; + adjust_stdin x (fun () -> + Testing.test_okfailed !cocci_file (x::xs) + ) + + (* --------------------------------------------------------- *) + (* Actions, useful to debug subpart of coccinelle *) + (* --------------------------------------------------------- *) + + | xs when List.mem !action (Common.action_list all_actions) -> + Common.do_action !action xs all_actions + + | [file] when !action = "-parse_cocci" -> + Testing.test_parse_cocci file + + (* I think this is used by some scripts in some Makefile for our + * big-tests. So dont remove. + *) + | [file1;file2] when !action = "-compare_c" -> + Test_parsing_c.test_compare_c file1 file2 (* result = unix code *) + + (* could add the Test_parsing_c.test_actions such as -parse_c & co *) + + + (* --------------------------------------------------------- *) + (* This is the main entry *) + (* --------------------------------------------------------- *) + | x::xs -> + adjust_stdin x (fun () -> + if !cocci_file = "" + then failwith "I need a cocci file, use -sp_file "; + + if !dir && !Flag.patch = None + then + (match xs with + | [] -> Flag.patch := Some x + | _ -> + pr2 + ("warning: patch output can only be created when only one\n"^ + "directory is specified or when the -patch flag is used") + ); + + let infiles = + Common.profile_code "Main.infiles computation" (fun () -> + match !dir, !kbuild_info, !Flag.use_glimpse with + (* glimpse *) + | false, _, true -> + failwith "-use_glimpse works only with -dir" + | true, s, true when s <> "" -> + failwith "-use_glimpse does not work with -kbuild" + | true, "", true -> + 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 -> + Common.cmd_to_list (* same as "true, "", _" case *) + (if !include_headers + then ("find "^(join " " (x::xs))^" -name \"*.[ch]\"") + else ("find "^(join " " (x::xs))^" -name \"*.c\"")) + | Some files -> files in + files +> List.map (fun x -> [x]) + (* normal *) + | false, _, _ -> [x::xs] + | true, "", _ -> + Common.cmd_to_list + (if !include_headers + then ("find "^(join " " (x::xs))^" -name \"*.[ch]\"") + else ("find "^(join " " (x::xs))^" -name \"*.c\"")) + +> List.map (fun x -> [x]) + + (* kbuild *) + | true, kbuild_info_file,_ -> + let dirs = + Common.cmd_to_list ("find "^(join " " (x::xs))^" -type d") + in + let info = Kbuild.parse_kbuild_info kbuild_info_file in + let groups = Kbuild.files_in_dirs dirs info in + + groups +> List.map (function Kbuild.Group xs -> xs) + ) + in + + let infiles = + match (!distrib_index,!distrib_max) with + (None,None) -> infiles + | (Some index,Some max) -> + (if index >= max + then + failwith "index starts at 0, and so must be less than max"); + if !mod_distrib + then + let rec loop ct = function + [] -> [] + | x::xs -> + if (ct mod max) = index + then x::(loop (ct+1) xs) + else loop (ct+1) xs in + loop 0 infiles + else + begin + let all_files = List.length infiles in + let regions = (all_files + (max - 1)) / max in + let this_min = index * regions in + let this_max = (index+1) * regions in + let rec loop ct = function + [] -> [] + | x::xs -> + if this_min <= ct && ct < this_max + then x::(loop (ct+1) xs) + else loop (ct+1) xs in + loop 0 infiles + end + | _ -> failwith "inconsistent distribution information" in + + let outfiles = + Common.profile_code "Main.outfiles computation" (fun () -> + infiles +> List.map (fun cfiles -> + pr2 ("HANDLING: " ^ (join " " cfiles)); + Common.timeout_function_opt !FC.timeout (fun () -> + Common.report_if_take_time 10 (join " " cfiles) (fun () -> + (* Unix.sleep 1; *) + try + (* this is the main call *) + Cocci.full_engine (!cocci_file, !Config.std_iso) cfiles + with + | Common.UnixExit x -> raise (Common.UnixExit x) + | e -> + if !dir + then begin + pr2 ("EXN:" ^ Printexc.to_string e); + [] (* *) + end + else raise e))) + ) +> List.concat + in + + Common.profile_code "Main.result analysis" (fun () -> + + Ctlcocci_integration.print_bench(); + + let outfiles = Cocci.check_duplicate_modif outfiles in + + outfiles +> List.iter (fun (infile, outopt) -> + outopt +> Common.do_option (fun outfile -> + if !inplace_modif + then begin + Common.command2 ("cp "^infile^" "^infile^".cocci_orig"); + Common.command2 ("cp "^outfile^" "^infile); + end; + + if !outplace_modif + then Common.command2 ("cp "^outfile^" "^infile^".cocci_res"); + + if !output_file = "" + then begin + let tmpfile = "/tmp/"^Common.basename infile in + pr2 (spf "One file modified. Result is here: %s" tmpfile); + Common.command2 ("cp "^outfile^" "^tmpfile); + end + )); + if !output_file <> "" then + (match outfiles with + | [infile, Some outfile] when infile = x && null xs -> + Common.command2 ("cp " ^outfile^ " " ^ !output_file); + | [infile, None] when infile = x && null xs -> + Common.command2 ("cp " ^infile^ " " ^ !output_file); + | _ -> + failwith + ("-o can not be applied because there is multiple " ^ + "modified files"); + ); + + if !compare_with_expected + then Testing.compare_with_expected outfiles)) + + (* --------------------------------------------------------- *) + (* empty entry *) + (* --------------------------------------------------------- *) + | [] -> short_usage() + + )); + if !Pycocci.initialised && (Pycocci.py_isinitialized ()) != 0 then begin + ignore(Pycocci.pyrun_simplestring "cocci.finalise()"); + if !Flag.show_misc + then Common.pr2 "Finalizing python\n"; + Pycocci.py_finalize (); + end + end + +(*****************************************************************************) +let _ = + Common.main_boilerplate (fun () -> + run_profile quiet_profile; + main (); + Ctlcocci_integration.print_bench(); + ) diff --git a/Makefile b/Makefile index c20c3cf..1168f58 100644 --- a/Makefile +++ b/Makefile @@ -262,12 +262,13 @@ OCAMLVERSION=$(shell ocaml -version |perl -p -e 's/.*version (.*)/$$1/;') # Procedure to do each time: # cvs update +# make sure that ocaml is the distribution ocaml of /usr/bin, not ~pad/... # modify globals/config.ml # cd globals/; cvs commit -m"new version" (do not commit from the root!) # ./configure --without-python # make package # make website -# Check also that run an ocaml in /usr/bin +# Check that run an ocaml in /usr/bin # To test you can try compile and run spatch from different instances # like my ~/coccinelle, ~/release/coccinelle, and the /tmp/coccinelle-0.X diff --git a/changes.txt b/changes.txt index 168e038..9364c31 100644 --- a/changes.txt +++ b/changes.txt @@ -1,5 +1,23 @@ -*- org -*- +* 0.1.5 + +** Features: +- added initialiser metavariable +- added sequences of designators in structures +- improved printing of the C code corresponding to metavariables +- improved printing when code (eg declarations) is removed at the beginning + of a block, and then is followed by a blank line +- slightly less verbose error reporting in parsing_hacks + +** Bugfix: +- fixed some problems with parsing SmPL code where a nest appears after a | +- better treatment of { }, form in macros wrt unparse_c +- less quiet for -parse_c +- improve parsing heuristics regarding macro statement + +** Internals: + * 0.1.4 ** Features: diff --git a/commitmsg b/commitmsg dissimilarity index 97% index 93c8ac9..c7d1f4f 100644 --- a/commitmsg +++ b/commitmsg @@ -1,35 +1,17 @@ -Release coccinelle-0.1.4 - -** Language: - - long long added to SmPL - -** Documentation: - - add grammar reference and spatch command line options reference - -** Features: - - can match patterns of the form unsigned T or signed T, where T is a - metavariable - - dropped the sizeof_parens isomorphism, which was made redundant by the - paren isomorphism - - simple rule generation - -** Bugfix: - - trailing , ; and ) no longer left on a line by themselves - - better treatment of error exit when the searched for code matches the - error exit condition. - - fix incorrect treatment of parentheses in test_exps that could allow + - code to be added twice - - don't ask whether iterator names and declarer names should be declared as - metavariables. - - slightly better support for expression list metavariables. - - short and long allowed for array index types in SmPL - - more restrictions on type inference for pointer arithmetic in SmPL - - allow isomorphisms to apply when + code is anywhere within all - terms - - changed order of printing const and volatile - - allow eg ... <... in plus code - - better formatting of generated if/while/etc. code - - better parse error reporting when the problem is at the end of the file - -** Internals: - - isomorphisms don't apply under signed/unsigned, to prevent the creation - of things like unsigned signed int. Need a better solution for this. +Release coccinelle-0.1.5 + +** Language: + - added initialiser metavariable + - added sequences of designators in structures + +** Features: + - improved printing of the C code corresponding to metavariables + - improved printing when code (eg declarations) is removed at the beginning + of a block, and then is followed by a blank line + - slightly less verbose error reporting in parsing_hacks + +** Bugfix: + - fixed some problems with parsing SmPL code where a nest appears after a | + - better treatment of { }, form in macros wrt unparse_c + - less quiet for -parse_c + - improve parsing heuristics regarding macro statement diff --git a/commons/common.ml b/commons/common.ml index d8055a2..36d29b1 100644 --- a/commons/common.ml +++ b/commons/common.ml @@ -1,4 +1,4 @@ -(* Copyright (C) 1998-2008 Yoann Padioleau +(* Copyright (C) 1998-2009 Yoann Padioleau * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License @@ -3436,6 +3436,9 @@ let rec unzip zs = (fst e::xs), (snd e::ys)) zs ([],[]) +let map_withkeep f xs = + xs +> List.map (fun x -> f x, x) + (* now in prelude * let rec take n xs = * match (n,xs) with @@ -3777,6 +3780,19 @@ let rec uniq = function | [] -> [] | e::l -> if List.mem e l then uniq l else e :: uniq l +let has_no_duplicate xs = + List.length xs = List.length (uniq xs) +let is_set_as_list = has_no_duplicate + + +let rec get_duplicates xs = + match xs with + | [] -> [] + | x::xs -> + if List.mem x xs + then x::get_duplicates xs (* todo? could x from xs to avoid double dups?*) + else get_duplicates xs + let rec all_assoc e = function | [] -> [] | (e',v) :: l when e=e' -> v :: all_assoc e l @@ -4013,9 +4029,21 @@ let _ = assert_equal (cartesian_product [1;2] ["3";"4";"5"]) [1,"3";1,"4";1,"5"; 2,"3";2,"4";2,"5"] +let sort_prof a b = + profile_code "Common.sort_by_xxx" (fun () -> List.sort a b) + +let sort_by_val_highfirst xs = + sort_prof (fun (k1,v1) (k2,v2) -> compare v2 v1) xs +let sort_by_val_lowfirst xs = + sort_prof (fun (k1,v1) (k2,v2) -> compare v1 v2) xs -let sort_by_val_descending xs = - List.sort (fun (k1,v1) (k2,v2) -> compare v2 v1) xs +let sort_by_key_highfirst xs = + sort_prof (fun (k1,v1) (k2,v2) -> compare k2 k1) xs +let sort_by_key_lowfirst xs = + sort_prof (fun (k1,v1) (k2,v2) -> compare k1 k2) xs + +let _ = example (sort_by_key_lowfirst [4, (); 7,()] = [4,(); 7,()]) +let _ = example (sort_by_key_highfirst [4,(); 7,()] = [7,(); 4,()]) (*----------------------------------*) @@ -4202,6 +4230,9 @@ let (insert_set: 'a -> 'a set -> 'a set) = fun x xs -> xs else x::xs +let is_set xs = + has_no_duplicate xs + let (single_set: 'a -> 'a set) = fun x -> insert_set x empty_set let (set: 'a list -> 'a set) = fun xs -> xs +> List.fold_left (flip insert_set) empty_set diff --git a/commons/common.mli b/commons/common.mli index 7932331..21a05da 100644 --- a/commons/common.mli +++ b/commons/common.mli @@ -1222,6 +1222,7 @@ val join_gen : 'a -> 'a list -> 'a list val do_withenv : (('a -> 'b) -> 'c -> 'd) -> ('e -> 'a -> 'b * 'e) -> 'e -> 'c -> 'd * 'e val map_withenv : ('a -> 'b -> 'c * 'a) -> 'a -> 'b list -> 'c list * 'a +val map_withkeep: ('a -> 'b) -> 'a list -> ('b * 'a) list val collect_accu : ('a -> 'b list) -> 'b list -> 'a list -> 'b list val collect : ('a -> 'b list) -> 'a list -> 'b list @@ -1236,6 +1237,10 @@ val exclude : ('a -> bool) -> 'a list -> 'a list val uniq : 'a list -> 'a list val uniq_eff: 'a list -> 'a list +val has_no_duplicate: 'a list -> bool +val is_set_as_list: 'a list -> bool +val get_duplicates: 'a list -> 'a list + val doublon : 'a list -> bool val reverse : 'a list -> 'a list (* alias *) @@ -1345,6 +1350,8 @@ val insert_set : 'a -> 'a set -> 'a set val single_set : 'a -> 'a set val set : 'a list -> 'a set +val is_set: 'a list -> bool + val exists_set : ('a -> bool) -> 'a set -> bool val forall_set : ('a -> bool) -> 'a set -> bool @@ -1450,7 +1457,11 @@ val lookup_list2 : 'a -> ('a, 'b) assoc list -> 'b * int val assoc_option : 'a -> ('a, 'b) assoc -> 'b option val assoc_with_err_msg : 'a -> ('a, 'b) assoc -> 'b -val sort_by_val_descending: ('a,'b) assoc -> ('a * 'b) list +val sort_by_val_lowfirst: ('a,'b) assoc -> ('a * 'b) list +val sort_by_val_highfirst: ('a,'b) assoc -> ('a * 'b) list + +val sort_by_key_lowfirst: (int,'b) assoc -> (int * 'b) list +val sort_by_key_highfirst: (int,'b) assoc -> (int * 'b) list (*****************************************************************************) (* Assoc, specialized. *) diff --git a/commons/copyright.txt b/commons/copyright.txt index f3bd2d8..87f67b9 100644 --- a/commons/copyright.txt +++ b/commons/copyright.txt @@ -1,4 +1,4 @@ -Copyright (C) 1998-2008 Yoann Padioleau +Copyright (C) 1998-2009 Yoann Padioleau This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License (LGPL) diff --git a/commons/oassoc.ml b/commons/oassoc.ml index d6638ba..7aa9f13 100644 --- a/commons/oassoc.ml +++ b/commons/oassoc.ml @@ -26,6 +26,12 @@ object(o: 'o) method find: 'a -> 'b = fun k -> o#assoc k + method find_opt: 'a -> 'b option = fun k -> + try + let res = o#assoc k in + Some res + with Not_found -> None + method haskey: 'a -> bool = fun k -> try (ignore(o#assoc k); true) with Not_found -> false diff --git a/commons/oassoc.mli b/commons/oassoc.mli index c257e14..0961e87 100644 --- a/commons/oassoc.mli +++ b/commons/oassoc.mli @@ -6,7 +6,9 @@ object ('o) method virtual assoc : 'a -> 'b method virtual delkey : 'a -> 'o + (* may raise NotFound *) method find : 'a -> 'b + method find_opt: 'a -> 'b option method haskey : 'a -> bool method replkey : 'a * 'b -> 'o diff --git a/engine/.#cocci_vs_c.ml.1.26 b/engine/.#cocci_vs_c.ml.1.26 new file mode 100644 index 0000000..181e174 --- /dev/null +++ b/engine/.#cocci_vs_c.ml.1.26 @@ -0,0 +1,3745 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +open Common + +module A = Ast_cocci +module B = Ast_c + +module F = Control_flow_c + +module Flag = Flag_matcher + +(*****************************************************************************) +(* Wrappers *) +(*****************************************************************************) + +(*****************************************************************************) +(* Helpers *) +(*****************************************************************************) + +type sequence = Ordered | Unordered + +let seqstyle eas = + match A.unwrap eas with + | A.DOTS _ -> Ordered + | A.CIRCLES _ -> Unordered + | A.STARS _ -> failwith "not handling stars" + +let (redots : 'a A.dots -> 'a list -> 'a A.dots)=fun eas easundots -> + A.rewrap eas ( + match A.unwrap eas with + | A.DOTS _ -> A.DOTS easundots + | A.CIRCLES _ -> A.CIRCLES easundots + | A.STARS _ -> A.STARS easundots + ) + + +let (need_unordered_initialisers : B.initialiser B.wrap2 list -> bool) = + fun ibs -> + ibs +> List.exists (fun (ib, icomma) -> + match B.unwrap ib with + | B.InitDesignators _ + | B.InitFieldOld _ + | B.InitIndexOld _ + -> true + | B.InitExpr _ + | B.InitList _ + -> false + ) + +(* For the #include in the .cocci, need to find where is + * the '+' attached to this element, to later find the first concrete + * #include or last one in the serie of #includes in the + * .c. + *) +type include_requirement = + | IncludeMcodeBefore + | IncludeMcodeAfter + | IncludeNothing + + + +(* todo? put in semantic_c.ml *) +type info_ident = + | Function + | LocalFunction (* entails Function *) + | DontKnow + + +let term mc = A.unwrap_mcode mc +let mcodekind mc = A.get_mcodekind mc + + +let mcode_contain_plus = function + | A.CONTEXT (_,A.NOTHING) -> false + | A.CONTEXT _ -> true + | A.MINUS (_,[]) -> false + | A.MINUS (_,x::xs) -> true + | A.PLUS -> raise Impossible + +let mcode_simple_minus = function + | A.MINUS (_,[]) -> true + | _ -> false + + +(* In transformation.ml sometime I build some mcodekind myself and + * julia has put None for the pos. But there is no possible raise + * NoMatch in those cases because it is for the minusall trick or for + * the distribute, so either have to build those pos, in fact a range, + * because for the distribute have to erase a fullType with one + * mcodekind, or add an argument to tag_with_mck such as "safe" that + * don't do the check_pos. Hence this DontCarePos constructor. *) + +let minusizer = + ("fake","fake"), + {A.line = 0; column =0; A.strbef=[]; A.straft=[];}, + (A.MINUS(A.DontCarePos, [])), + A.NoMetaPos + +let generalize_mcode ia = + let (s1, i, mck, pos) = ia in + let new_mck = + match mck with + | A.PLUS -> raise Impossible + | A.CONTEXT (A.NoPos,x) -> + A.CONTEXT (A.DontCarePos,x) + | A.MINUS (A.NoPos,x) -> + A.MINUS (A.DontCarePos,x) + + | A.CONTEXT ((A.FixPos _|A.DontCarePos), _) + | A.MINUS ((A.FixPos _|A.DontCarePos), _) + -> + raise Impossible + in + (s1, i, new_mck, pos) + + + +(*---------------------------------------------------------------------------*) + +(* 0x0 is equivalent to 0, value format isomorphism *) +let equal_c_int s1 s2 = + try + int_of_string s1 = int_of_string s2 + with Failure("int_of_string") -> + s1 =$= s2 + + + +(*---------------------------------------------------------------------------*) +(* Normally A should reuse some types of Ast_c, so those + * functions should not exist. + * + * update: but now Ast_c depends on A, so can't make too + * A depends on Ast_c, so have to stay with those equal_xxx + * functions. + *) + +let equal_unaryOp a b = + match a, b with + | A.GetRef , B.GetRef -> true + | A.DeRef , B.DeRef -> true + | A.UnPlus , B.UnPlus -> true + | A.UnMinus , B.UnMinus -> true + | A.Tilde , B.Tilde -> true + | A.Not , B.Not -> true + | _, B.GetRefLabel -> false (* todo cocci? *) + | _, (B.Not|B.Tilde|B.UnMinus|B.UnPlus|B.DeRef|B.GetRef) -> false + + + +let equal_arithOp a b = + match a, b with + | A.Plus , B.Plus -> true + | A.Minus , B.Minus -> true + | A.Mul , B.Mul -> true + | A.Div , B.Div -> true + | A.Mod , B.Mod -> true + | A.DecLeft , B.DecLeft -> true + | A.DecRight , B.DecRight -> true + | A.And , B.And -> true + | A.Or , B.Or -> true + | A.Xor , B.Xor -> true + | _, (B.Xor|B.Or|B.And|B.DecRight|B.DecLeft|B.Mod|B.Div|B.Mul|B.Minus|B.Plus) + -> false + +let equal_logicalOp a b = + match a, b with + | A.Inf , B.Inf -> true + | A.Sup , B.Sup -> true + | A.InfEq , B.InfEq -> true + | A.SupEq , B.SupEq -> true + | A.Eq , B.Eq -> true + | A.NotEq , B.NotEq -> true + | A.AndLog , B.AndLog -> true + | A.OrLog , B.OrLog -> true + | _, (B.OrLog|B.AndLog|B.NotEq|B.Eq|B.SupEq|B.InfEq|B.Sup|B.Inf) + -> false + +let equal_assignOp a b = + match a, b with + | A.SimpleAssign, B.SimpleAssign -> true + | A.OpAssign a, B.OpAssign b -> equal_arithOp a b + | _, (B.OpAssign _|B.SimpleAssign) -> false + +let equal_fixOp a b = + match a, b with + | A.Dec, B.Dec -> true + | A.Inc, B.Inc -> true + | _, (B.Inc|B.Dec) -> false + +let equal_binaryOp a b = + match a, b with + | A.Arith a, B.Arith b -> equal_arithOp a b + | A.Logical a, B.Logical b -> equal_logicalOp a b + | _, (B.Logical _ | B.Arith _) -> false + +let equal_structUnion a b = + match a, b with + | A.Struct, B.Struct -> true + | A.Union, B.Union -> true + | _, (B.Struct|B.Union) -> false + +let equal_sign a b = + match a, b with + | A.Signed, B.Signed -> true + | A.Unsigned, B.UnSigned -> true + | _, (B.UnSigned|B.Signed) -> false + +let equal_storage a b = + match a, b with + | A.Static , B.Sto B.Static + | A.Auto , B.Sto B.Auto + | A.Register , B.Sto B.Register + | A.Extern , B.Sto B.Extern + -> true + | _, (B.NoSto | B.StoTypedef) -> false + | _, (B.Sto (B.Register|B.Static|B.Auto|B.Extern)) -> false + + +(*---------------------------------------------------------------------------*) + +let equal_metavarval valu valu' = + match valu, valu' with + | Ast_c.MetaIdVal a, Ast_c.MetaIdVal b -> a =$= b + | Ast_c.MetaFuncVal a, Ast_c.MetaFuncVal b -> a =$= b + | Ast_c.MetaLocalFuncVal a, Ast_c.MetaLocalFuncVal b -> + (* do something more ? *) + a =$= b + + (* al_expr before comparing !!! and accept when they match. + * Note that here we have Astc._expression, so it is a match + * modulo isomorphism (there is no metavariable involved here, + * just isomorphisms). => TODO call isomorphism_c_c instead of + * =*=. Maybe would be easier to transform ast_c in ast_cocci + * and call the iso engine of julia. *) + | Ast_c.MetaExprVal a, Ast_c.MetaExprVal b -> + Lib_parsing_c.al_expr a =*= Lib_parsing_c.al_expr b + | Ast_c.MetaExprListVal a, Ast_c.MetaExprListVal b -> + Lib_parsing_c.al_arguments a =*= Lib_parsing_c.al_arguments b + + | Ast_c.MetaStmtVal a, Ast_c.MetaStmtVal b -> + Lib_parsing_c.al_statement a =*= Lib_parsing_c.al_statement b + | Ast_c.MetaTypeVal a, Ast_c.MetaTypeVal b -> + (* old: Lib_parsing_c.al_type a =*= Lib_parsing_c.al_type b *) + C_vs_c.eq_type a b + + | Ast_c.MetaListlenVal a, Ast_c.MetaListlenVal b -> a =|= b + + | Ast_c.MetaParamVal a, Ast_c.MetaParamVal b -> + Lib_parsing_c.al_param a =*= Lib_parsing_c.al_param b + | Ast_c.MetaParamListVal a, Ast_c.MetaParamListVal b -> + Lib_parsing_c.al_params a =*= Lib_parsing_c.al_params b + + | Ast_c.MetaPosVal (posa1,posa2), Ast_c.MetaPosVal (posb1,posb2) -> + Ast_cocci.equal_pos posa1 posb1 && Ast_cocci.equal_pos posa2 posb2 + + | Ast_c.MetaPosValList l1, Ast_c.MetaPosValList l2 -> + List.exists + (function (fla,cea,posa1,posa2) -> + List.exists + (function (flb,ceb,posb1,posb2) -> + fla = flb && cea = ceb && + Ast_c.equal_posl posa1 posb1 && Ast_c.equal_posl posa2 posb2) + l2) + l1 + + | (B.MetaPosValList _|B.MetaListlenVal _|B.MetaPosVal _|B.MetaStmtVal _ + |B.MetaTypeVal _ + |B.MetaParamListVal _|B.MetaParamVal _|B.MetaExprListVal _ + |B.MetaExprVal _|B.MetaLocalFuncVal _|B.MetaFuncVal _|B.MetaIdVal _ + ), _ + -> raise Impossible + + +(*---------------------------------------------------------------------------*) +(* could put in ast_c.ml, next to the split/unsplit_comma *) +let split_signb_baseb_ii (baseb, ii) = + let iis = ii +> List.map (fun info -> (B.str_of_info info), info) in + match baseb, iis with + + | B.Void, ["void",i1] -> None, [i1] + + | B.FloatType (B.CFloat),["float",i1] -> None, [i1] + | B.FloatType (B.CDouble),["double",i1] -> None, [i1] + | B.FloatType (B.CLongDouble),["long",i1;"double",i2] -> None,[i1;i2] + + | B.IntType (B.CChar), ["char",i1] -> None, [i1] + + + | B.IntType (B.Si (sign, base)), xs -> + (match sign, base, xs with + | B.Signed, B.CChar2, ["signed",i1;"char",i2] -> + Some (B.Signed, i1), [i2] + | B.UnSigned, B.CChar2, ["unsigned",i1;"char",i2] -> + Some (B.UnSigned, i1), [i2] + + | B.Signed, B.CShort, ["short",i1] -> + None, [i1] + | B.Signed, B.CShort, ["signed",i1;"short",i2] -> + Some (B.Signed, i1), [i2] + | B.UnSigned, B.CShort, ["unsigned",i1;"short",i2] -> + Some (B.UnSigned, i1), [i2] + | B.Signed, B.CShort, ["short",i1;"int",i2] -> + None, [i1;i2] + + | B.Signed, B.CInt, ["int",i1] -> + None, [i1] + | B.Signed, B.CInt, ["signed",i1;"int",i2] -> + Some (B.Signed, i1), [i2] + | B.UnSigned, B.CInt, ["unsigned",i1;"int",i2] -> + Some (B.UnSigned, i1), [i2] + + | B.Signed, B.CInt, ["signed",i1;] -> + Some (B.Signed, i1), [] + | B.UnSigned, B.CInt, ["unsigned",i1;] -> + Some (B.UnSigned, i1), [] + + | B.Signed, B.CLong, ["long",i1] -> + None, [i1] + | B.Signed, B.CLong, ["long",i1;"int",i2] -> + None, [i1;i2] + | B.Signed, B.CLong, ["signed",i1;"long",i2] -> + Some (B.Signed, i1), [i2] + | B.UnSigned, B.CLong, ["unsigned",i1;"long",i2] -> + Some (B.UnSigned, i1), [i2] + + | B.Signed, B.CLongLong, ["long",i1;"long",i2] -> None, [i1;i2] + | B.Signed, B.CLongLong, ["signed",i1;"long",i2;"long",i3] -> + Some (B.Signed, i1), [i2;i3] + | B.UnSigned, B.CLongLong, ["unsigned",i1;"long",i2;"long",i3] -> + Some (B.UnSigned, i1), [i2;i3] + + + | B.UnSigned, B.CShort, ["unsigned",i1;"short",i2; "int", i3] -> + Some (B.UnSigned, i1), [i2;i3] + + + + | _ -> failwith "strange type1, maybe because of weird order" + ) + | _ -> failwith "strange type2, maybe because of weird order" + +(*---------------------------------------------------------------------------*) + +let rec unsplit_icomma xs = + match xs with + | [] -> [] + | x::y::xs -> + (match A.unwrap y with + | A.IComma mcode -> + (x, y)::unsplit_icomma xs + | _ -> failwith "wrong ast_cocci in initializer" + ) + | _ -> + failwith ("wrong ast_cocci in initializer, should have pair " ^ + "number of Icomma") + + + +let resplit_initialiser ibs iicomma = + match iicomma, ibs with + | [], [] -> [] + | [], _ -> + failwith "should have a iicomma, do you generate fakeInfo in parser?" + | _, [] -> + failwith "shouldn't have a iicomma" + | [iicomma], x::xs -> + let elems = List.map fst (x::xs) in + let commas = List.map snd (x::xs) +> List.flatten in + let commas = commas @ [iicomma] in + zip elems commas + | _ -> raise Impossible + + + +let rec split_icomma xs = + match xs with + | [] -> [] + | (x,y)::xs -> x::y::split_icomma xs + +let rec unsplit_initialiser ibs_unsplit = + match ibs_unsplit with + | [] -> [], [] (* empty iicomma *) + | (x, commax)::xs -> + let (xs, lastcomma) = unsplit_initialiser_bis commax xs in + (x, [])::xs, lastcomma + +and unsplit_initialiser_bis comma_before = function + | [] -> [], [comma_before] + | (x, commax)::xs -> + let (xs, lastcomma) = unsplit_initialiser_bis commax xs in + (x, [comma_before])::xs, lastcomma + + + + +(*---------------------------------------------------------------------------*) +(* coupling: same in type_annotater_c.ml *) +let structdef_to_struct_name ty = + match ty with + | qu, (B.StructUnion (su, sopt, fields), iis) -> + (match sopt,iis with + | Some s , [i1;i2;i3;i4] -> + qu, (B.StructUnionName (su, s), [i1;i2]) + | None, _ -> + ty + + | x -> raise Impossible + ) + | _ -> raise Impossible + +(*---------------------------------------------------------------------------*) +let initialisation_to_affectation decl = + match decl with + | B.MacroDecl _ -> F.Decl decl + | B.DeclList (xs, iis) -> + + (* todo?: should not do that if the variable is an array cos + * will have x[] = , mais de toute facon ca sera pas un InitExp + *) + (match xs with + | [] -> raise Impossible + | [x] -> + let ({B.v_namei = var; + B.v_type = returnType; + B.v_storage = storage; + B.v_local = local}, + iisep) = x in + + (match var with + | Some ((s, ini), iis::iini) -> + (match ini with + | Some (B.InitExpr e, ii_empty2) -> + let local = + match local with + Ast_c.NotLocalDecl -> Ast_c.NotLocalVar + | Ast_c.LocalDecl -> Ast_c.LocalVar (iis.Ast_c.pinfo) in + + let typ = + ref (Some ((Lib_parsing_c.al_type returnType),local), + Ast_c.NotTest) in + let id = (B.Ident s, typ),[iis] in + F.DefineExpr + ((B.Assignment (id, B.SimpleAssign, e), + Ast_c.noType()), iini) + | _ -> F.Decl decl + ) + | _ -> F.Decl decl + ) + | x::xs -> + pr2_once "TODO: initialisation_to_affectation for multi vars"; + (* todo? do a fold_left and generate 'x = a, y = b' etc, use + * the Sequence expression operator of C and make an + * ExprStatement from that. + *) + F.Decl decl + ) + + + + + +(*****************************************************************************) +(* Functor parameter combinators *) +(*****************************************************************************) +(* monad like stuff + * src: papers on parser combinators in haskell (cf a pearl by meijer in ICFP) + * + * version0: was not tagging the SP, so just tag the C + * val (>>=): + * (tin -> 'c tout) -> ('c -> (tin -> 'b tout)) -> (tin -> 'b tout) + * val return : 'b -> tin -> 'b tout + * val fail : tin -> 'b tout + * + * version1: now also tag the SP so return a ('a * 'b) + *) + +type mode = PatternMode | TransformMode + +module type PARAM = + sig + type tin + type 'x tout + + + type ('a, 'b) matcher = 'a -> 'b -> tin -> ('a * 'b) tout + + val mode : mode + + val (>>=): + (tin -> ('a * 'b) tout) -> + ('a -> 'b -> (tin -> ('c * 'd) tout)) -> + (tin -> ('c * 'd) tout) + + val return : ('a * 'b) -> tin -> ('a *'b) tout + val fail : tin -> ('a * 'b) tout + + val (>||>) : + (tin -> 'x tout) -> + (tin -> 'x tout) -> + (tin -> 'x tout) + + val (>|+|>) : + (tin -> 'x tout) -> + (tin -> 'x tout) -> + (tin -> 'x tout) + + val (>&&>) : (tin -> bool) -> (tin -> 'x tout) -> (tin -> 'x tout) + + val tokenf : ('a A.mcode, B.info) matcher + val tokenf_mck : (A.mcodekind, B.info) matcher + + val distrf_e : + (A.meta_name A.mcode, B.expression) matcher + val distrf_args : + (A.meta_name A.mcode, (Ast_c.argument, Ast_c.il) either list) matcher + val distrf_type : + (A.meta_name A.mcode, Ast_c.fullType) matcher + val distrf_params : + (A.meta_name A.mcode, + (Ast_c.parameterType, Ast_c.il) either list) matcher + val distrf_param : + (A.meta_name A.mcode, Ast_c.parameterType) matcher + val distrf_ini : + (A.meta_name A.mcode, Ast_c.initialiser) matcher + val distrf_node : + (A.meta_name A.mcode, Control_flow_c.node) matcher + + val distrf_define_params : + (A.meta_name A.mcode, (string Ast_c.wrap, Ast_c.il) either list) + matcher + + val distrf_struct_fields : + (A.meta_name A.mcode, B.field list) matcher + + val distrf_cst : + (A.meta_name A.mcode, (B.constant, string) either B.wrap) matcher + + val cocciExp : + (A.expression, B.expression) matcher -> (A.expression, F.node) matcher + + val cocciExpExp : + (A.expression, B.expression) matcher -> + (A.expression, B.expression) matcher + + val cocciTy : + (A.fullType, B.fullType) matcher -> (A.fullType, F.node) matcher + + val cocciInit : + (A.initialiser, B.initialiser) matcher -> (A.initialiser, F.node) matcher + + val envf : + A.keep_binding -> A.inherited -> + A.meta_name A.mcode * Ast_c.metavar_binding_kind * + (unit -> Common.filename * string * Ast_c.posl * Ast_c.posl) -> + (unit -> tin -> 'x tout) -> (tin -> 'x tout) + + val check_constraints : + ('a, 'b) matcher -> 'a list -> 'b -> + (unit -> tin -> 'x tout) -> (tin -> 'x tout) + + val all_bound : A.meta_name list -> (tin -> bool) + + val optional_storage_flag : (bool -> tin -> 'x tout) -> (tin -> 'x tout) + val optional_qualifier_flag : (bool -> tin -> 'x tout) -> (tin -> 'x tout) + val value_format_flag: (bool -> tin -> 'x tout) -> (tin -> 'x tout) + + + end + +(*****************************************************************************) +(* Functor code, "Cocci vs C" *) +(*****************************************************************************) + +module COCCI_VS_C = + functor (X : PARAM) -> +struct + +type ('a, 'b) matcher = 'a -> 'b -> X.tin -> ('a * 'b) X.tout + +let (>>=) = X.(>>=) +let return = X.return +let fail = X.fail + +let (>||>) = X.(>||>) +let (>|+|>) = X.(>|+|>) +let (>&&>) = X.(>&&>) + +let tokenf = X.tokenf + +(* should be raise Impossible when called from transformation.ml *) +let fail2 () = + match X.mode with + | PatternMode -> fail + | TransformMode -> raise Impossible + + +let (option: ('a,'b) matcher -> ('a option,'b option) matcher)= fun f t1 t2 -> + match (t1,t2) with + | (Some t1, Some t2) -> + f t1 t2 >>= (fun t1 t2 -> + return (Some t1, Some t2) + ) + | (None, None) -> return (None, None) + | _ -> fail + +(* Dots are sometimes used as metavariables, since like metavariables they +can match other things. But they no longer have the same type. Perhaps these +functions could be avoided by introducing an appropriate level of polymorphism, +but I don't know how to declare polymorphism across functors *) +let dots2metavar (_,info,mcodekind,pos) = (("","..."),info,mcodekind,pos) +let metavar2dots (_,info,mcodekind,pos) = ("...",info,mcodekind,pos) + +(*---------------------------------------------------------------------------*) +(* toc: + * - expression + * - ident + * - arguments + * - parameters + * - declaration + * - initialisers + * - type + * - node + *) + +(*---------------------------------------------------------------------------*) +let rec (expression: (A.expression, Ast_c.expression) matcher) = + fun ea eb -> + X.all_bound (A.get_inherited ea) >&&> + let wa x = A.rewrap ea x in + match A.unwrap ea, eb with + + (* general case: a MetaExpr can match everything *) + | A.MetaExpr (ida,constraints,keep,opttypa,form,inherited), + (((expr, opttypb), ii) as expb) -> + + (* old: before have a MetaConst. Now we factorize and use 'form' to + * differentiate between different cases *) + let rec matches_id = function + B.Ident(c) -> true + | B.Cast(ty,e) -> matches_id (B.unwrap_expr e) + | _ -> false in + let form_ok = + match (form,expr) with + (A.ANY,_) -> true + | (A.CONST,e) -> + let rec matches = function + B.Constant(c) -> true + | B.Ident idb when idb =~ "^[A-Z_][A-Z_0-9]*$" -> + pr2_once ("warning: I consider " ^ idb ^ " as a constant"); + true + | B.Cast(ty,e) -> matches (B.unwrap_expr e) + | B.Unary(e,B.UnMinus) -> matches (B.unwrap_expr e) + | B.SizeOfExpr(exp) -> true + | B.SizeOfType(ty) -> true + | _ -> false in + matches e + | (A.LocalID,e) -> + (matches_id e) && + (match !opttypb with + (Some (_,Ast_c.LocalVar _),_) -> true + | _ -> false) + | (A.ID,e) -> matches_id e in + + if form_ok + then + (let (opttypb,_testb) = !opttypb in + match opttypa, opttypb with + | None, _ -> return ((),()) + | Some _, None -> + pr2_once ("Missing type information. Certainly a pb in " ^ + "annotate_typer.ml"); + fail + + | Some tas, Some tb -> + tas +> List.fold_left (fun acc ta -> + acc >|+|> compatible_type ta tb) fail + ) >>= + (fun () () -> + X.check_constraints expression constraints eb + (fun () -> + let max_min _ = + Lib_parsing_c.lin_col_by_pos (Lib_parsing_c.ii_of_expr expb) in + X.envf keep inherited (ida, Ast_c.MetaExprVal expb, max_min) + (fun () -> + X.distrf_e ida expb >>= (fun ida expb -> + return ( + A.MetaExpr (ida,constraints,keep,opttypa,form,inherited)+> + A.rewrap ea, + expb + )) + ))) + else fail + + (* old: + * | A.MetaExpr(ida,false,opttypa,_inherited), expb -> + * D.distribute_mck (mcodekind ida) D.distribute_mck_e expb binding + * + * but bug! because if have not tagged SP, then transform without doing + * any checks. Hopefully now have tagged SP technique. + *) + + + (* old: + * | A.Edots _, _ -> raise Impossible. + * + * In fact now can also have the Edots inside normal expression, not + * just in arg lists. in 'x[...];' less: in if(<... x ... y ...>) + *) + | A.Edots (mcode, None), expb -> + X.distrf_e (dots2metavar mcode) expb >>= (fun mcode expb -> + return ( + A.Edots (metavar2dots mcode, None) +> A.rewrap ea , + expb + )) + + + | A.Edots (_, Some expr), _ -> failwith "not handling when on Edots" + + + | A.Ident ida, ((B.Ident idb, typ),ii) -> + let ib1 = tuple_of_list1 ii in + ident DontKnow ida (idb, ib1) >>= (fun ida (idb, ib1) -> + return ( + ((A.Ident ida)) +> wa, + ((B.Ident idb, typ),[ib1]) + )) + + + + + | A.MetaErr _, _ -> failwith "not handling MetaErr" + + (* todo?: handle some isomorphisms in int/float ? can have different + * format : 1l can match a 1. + * + * todo: normally string can contain some metavar too, so should + * recurse on the string + *) + | A.Constant (ia1), ((B.Constant (ib) , typ),ii) -> + (* for everything except the String case where can have multi elems *) + let do1 () = + let ib1 = tuple_of_list1 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + return ( + ((A.Constant ia1)) +> wa, + ((B.Constant (ib), typ),[ib1]) + )) + in + (match term ia1, ib with + | A.Int x, B.Int y -> + X.value_format_flag (fun use_value_equivalence -> + if use_value_equivalence + then + if equal_c_int x y + then do1() + else fail + else + if x =$= y + then do1() + else fail + ) + | A.Char x, B.Char (y,_) when x =$= y (* todo: use kind ? *) + -> do1() + | A.Float x, B.Float (y,_) when x =$= y (* todo: use floatType ? *) + -> do1() + + | A.String sa, B.String (sb,_kind) when sa =$= sb -> + (match ii with + | [ib1] -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + return ( + ((A.Constant ia1)) +> wa, + ((B.Constant (ib), typ),[ib1]) + )) + | _ -> fail (* multi string, not handled *) + ) + + | _, B.MultiString -> (* todo cocci? *) fail + | _, (B.String _ | B.Float _ | B.Char _ | B.Int _) -> fail + ) + + + | A.FunCall (ea, ia1, eas, ia2), ((B.FunCall (eb, ebs), typ),ii) -> + (* todo: do special case to allow IdMetaFunc, cos doing the + * recursive call will be too late, match_ident will not have the + * info whether it was a function. todo: but how detect when do + * x.field = f; how know that f is a Func ? By having computed + * some information before the matching! + * + * Allow match with FunCall containing types. Now ast_cocci allow + * type in parameter, and morover ast_cocci allow f(...) and those + * ... could match type. + *) + let (ib1, ib2) = tuple_of_list2 ii in + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + arguments (seqstyle eas) (A.undots eas) ebs >>= (fun easundots ebs -> + let eas = redots eas easundots in + return ( + ((A.FunCall (ea, ia1, eas, ia2)) +> wa, + ((B.FunCall (eb, ebs),typ), [ib1;ib2]) + )))))) + + + + + | A.Assignment (ea1, opa, ea2, simple), + ((B.Assignment (eb1, opb, eb2), typ),ii) -> + let (opbi) = tuple_of_list1 ii in + if equal_assignOp (term opa) opb + then + expression ea1 eb1 >>= (fun ea1 eb1 -> + expression ea2 eb2 >>= (fun ea2 eb2 -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Assignment (ea1, opa, ea2, simple))) +> wa, + ((B.Assignment (eb1, opb, eb2), typ), [opbi]) + )))) + else fail + + | A.CondExpr(ea1,ia1,ea2opt,ia2,ea3),((B.CondExpr(eb1,eb2opt,eb3),typ),ii) -> + let (ib1, ib2) = tuple_of_list2 ii in + expression ea1 eb1 >>= (fun ea1 eb1 -> + option expression ea2opt eb2opt >>= (fun ea2opt eb2opt -> + expression ea3 eb3 >>= (fun ea3 eb3 -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + ((A.CondExpr(ea1,ia1,ea2opt,ia2,ea3))) +> wa, + ((B.CondExpr (eb1, eb2opt, eb3),typ), [ib1;ib2]) + )))))) + + (* todo?: handle some isomorphisms here ? *) + | A.Postfix (ea, opa), ((B.Postfix (eb, opb), typ),ii) -> + let opbi = tuple_of_list1 ii in + if equal_fixOp (term opa) opb + then + expression ea eb >>= (fun ea eb -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Postfix (ea, opa))) +> wa, + ((B.Postfix (eb, opb), typ),[opbi]) + ))) + else fail + + + | A.Infix (ea, opa), ((B.Infix (eb, opb), typ),ii) -> + let opbi = tuple_of_list1 ii in + if equal_fixOp (term opa) opb + then + expression ea eb >>= (fun ea eb -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Infix (ea, opa))) +> wa, + ((B.Infix (eb, opb), typ),[opbi]) + ))) + else fail + + | A.Unary (ea, opa), ((B.Unary (eb, opb), typ),ii) -> + let opbi = tuple_of_list1 ii in + if equal_unaryOp (term opa) opb + then + expression ea eb >>= (fun ea eb -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Unary (ea, opa))) +> wa, + ((B.Unary (eb, opb), typ),[opbi]) + ))) + else fail + + | A.Binary (ea1, opa, ea2), ((B.Binary (eb1, opb, eb2), typ),ii) -> + let opbi = tuple_of_list1 ii in + if equal_binaryOp (term opa) opb + then + expression ea1 eb1 >>= (fun ea1 eb1 -> + expression ea2 eb2 >>= (fun ea2 eb2 -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Binary (ea1, opa, ea2))) +> wa, + ((B.Binary (eb1, opb, eb2), typ),[opbi] + ))))) + else fail + + | A.Nested (ea1, opa, ea2), eb -> + let rec loop eb = + (if A.get_test_exp ea1 && not (Ast_c.is_test eb) then fail + else expression ea1 eb) >|+|> + (match eb with + ((B.Binary (eb1, opb, eb2), typ),ii) + when equal_binaryOp (term opa) opb -> + let opbi = tuple_of_list1 ii in + let left_to_right = + (expression ea1 eb1 >>= (fun ea1 eb1 -> + expression ea2 eb2 >>= (fun ea2 eb2 -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Nested (ea1, opa, ea2))) +> wa, + ((B.Binary (eb1, opb, eb2), typ),[opbi] + )))))) in + let right_to_left = + (expression ea2 eb1 >>= (fun ea2 eb1 -> + expression ea1 eb2 >>= (fun ea1 eb2 -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Nested (ea1, opa, ea2))) +> wa, + ((B.Binary (eb1, opb, eb2), typ),[opbi] + )))))) in + let in_left = + (loop eb1 >>= (fun ea1 eb1 -> + expression ea2 eb2 >>= (fun ea2 eb2 -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Nested (ea1, opa, ea2))) +> wa, + ((B.Binary (eb1, opb, eb2), typ),[opbi] + )))))) in + let in_right = + (expression ea2 eb1 >>= (fun ea2 eb1 -> + loop eb2 >>= (fun ea1 eb2 -> + tokenf opa opbi >>= (fun opa opbi -> + return ( + ((A.Nested (ea1, opa, ea2))) +> wa, + ((B.Binary (eb1, opb, eb2), typ),[opbi] + )))))) in + left_to_right >|+|> right_to_left >|+|> in_left >|+|> in_right + | _ -> fail) in + loop eb + + (* todo?: handle some isomorphisms here ? (with pointers = Unary Deref) *) + | A.ArrayAccess (ea1, ia1, ea2, ia2),((B.ArrayAccess (eb1, eb2), typ),ii) -> + let (ib1, ib2) = tuple_of_list2 ii in + expression ea1 eb1 >>= (fun ea1 eb1 -> + expression ea2 eb2 >>= (fun ea2 eb2 -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + ((A.ArrayAccess (ea1, ia1, ea2, ia2))) +> wa, + ((B.ArrayAccess (eb1, eb2),typ), [ib1;ib2]) + ))))) + + (* todo?: handle some isomorphisms here ? *) + | A.RecordAccess (ea, ia1, ida), ((B.RecordAccess (eb, idb), typ),ii) -> + let (ib1, ib2) = tuple_of_list2 ii in + ident DontKnow ida (idb, ib2) >>= (fun ida (idb, ib2) -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + expression ea eb >>= (fun ea eb -> + return ( + ((A.RecordAccess (ea, ia1, ida))) +> wa, + ((B.RecordAccess (eb, idb), typ), [ib1;ib2]) + )))) + + + + | A.RecordPtAccess (ea,ia1,ida),((B.RecordPtAccess (eb, idb), typ), ii) -> + let (ib1, ib2) = tuple_of_list2 ii in + ident DontKnow ida (idb, ib2) >>= (fun ida (idb, ib2) -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + expression ea eb >>= (fun ea eb -> + return ( + ((A.RecordPtAccess (ea, ia1, ida))) +> wa, + ((B.RecordPtAccess (eb, idb), typ), [ib1;ib2]) + )))) + + + (* todo?: handle some isomorphisms here ? + * todo?: do some iso-by-absence on cast ? + * by trying | ea, B.Case (typb, eb) -> match_e_e ea eb ? + *) + + | A.Cast (ia1, typa, ia2, ea), ((B.Cast (typb, eb), typ),ii) -> + let (ib1, ib2) = tuple_of_list2 ii in + fullType typa typb >>= (fun typa typb -> + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + ((A.Cast (ia1, typa, ia2, ea))) +> wa, + ((B.Cast (typb, eb),typ),[ib1;ib2]) + ))))) + + | A.SizeOfExpr (ia1, ea), ((B.SizeOfExpr (eb), typ),ii) -> + let ib1 = tuple_of_list1 ii in + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + return ( + ((A.SizeOfExpr (ia1, ea))) +> wa, + ((B.SizeOfExpr (eb), typ),[ib1]) + ))) + + | A.SizeOfType (ia1, ia2, typa, ia3), ((B.SizeOfType typb, typ),ii) -> + let (ib1,ib2,ib3) = tuple_of_list3 ii in + fullType typa typb >>= (fun typa typb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + return ( + ((A.SizeOfType (ia1, ia2, typa, ia3))) +> wa, + ((B.SizeOfType (typb),typ),[ib1;ib2;ib3]) + ))))) + + + (* todo? iso ? allow all the combinations ? *) + | A.Paren (ia1, ea, ia2), ((B.ParenExpr (eb), typ),ii) -> + let (ib1, ib2) = tuple_of_list2 ii in + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + ((A.Paren (ia1, ea, ia2))) +> wa, + ((B.ParenExpr (eb), typ), [ib1;ib2]) + )))) + + | A.NestExpr(exps,None,true), eb -> + (match A.unwrap exps with + A.DOTS [exp] -> + X.cocciExpExp expression exp eb >>= (fun exp eb -> + return ( + (A.NestExpr(A.rewrap exps (A.DOTS [exp]),None,true)) +> wa, + eb + ) + ) + | _ -> + failwith + "for nestexpr, only handling the case with dots and only one exp") + + | A.NestExpr _, _ -> + failwith "only handling multi and no when code in a nest expr" + + (* only in arg lists or in define body *) + | A.TypeExp _, _ -> fail + + (* only in arg lists *) + | A.MetaExprList _, _ + | A.EComma _, _ + | A.Ecircles _, _ + | A.Estars _, _ + -> + raise Impossible + + | A.DisjExpr eas, eb -> + eas +> List.fold_left (fun acc ea -> acc >|+|> (expression ea eb)) fail + + | A.UniqueExp _,_ | A.OptExp _,_ -> + failwith "not handling Opt/Unique/Multi on expr" + + (* Because of Exp cant put a raise Impossible; have to put a fail *) + + (* have not a counter part in coccinelle, for the moment *) + | _, ((B.Sequence _,_),_) + | _, ((B.StatementExpr _,_),_) + | _, ((B.Constructor _,_),_) + -> fail + + + | _, + (((B.Cast (_, _)|B.ParenExpr _|B.SizeOfType _|B.SizeOfExpr _| + B.RecordPtAccess (_, _)| + B.RecordAccess (_, _)|B.ArrayAccess (_, _)| + B.Binary (_, _, _)|B.Unary (_, _)| + B.Infix (_, _)|B.Postfix (_, _)| + B.Assignment (_, _, _)|B.CondExpr (_, _, _)| + B.FunCall (_, _)|B.Constant _|B.Ident _), + _),_) + -> fail + + + + + + +(* ------------------------------------------------------------------------- *) +and (ident: info_ident -> (A.ident, string * Ast_c.info) matcher) = + fun infoidb ida ((idb, iib) as ib) -> + X.all_bound (A.get_inherited ida) >&&> + match A.unwrap ida with + | A.Id sa -> + if (term sa) =$= idb then + tokenf sa iib >>= (fun sa iib -> + return ( + ((A.Id sa)) +> A.rewrap ida, + (idb, iib) + )) + else fail + + + | A.MetaId(mida,constraints,keep,inherited) -> + X.check_constraints (ident infoidb) constraints ib + (fun () -> + let max_min _ = Lib_parsing_c.lin_col_by_pos [iib] in + (* use drop_pos for ids so that the pos is not added a second time in + the call to tokenf *) + X.envf keep inherited (A.drop_pos mida, Ast_c.MetaIdVal (idb), max_min) + (fun () -> + tokenf mida iib >>= (fun mida iib -> + return ( + ((A.MetaId (mida, constraints, keep, inherited)) +> A.rewrap ida, + (idb, iib) + ))) + )) + + | A.MetaFunc(mida,constraints,keep,inherited) -> + let is_function _ = + X.check_constraints (ident infoidb) constraints ib + (fun () -> + let max_min _ = Lib_parsing_c.lin_col_by_pos [iib] in + X.envf keep inherited (A.drop_pos mida,Ast_c.MetaFuncVal idb,max_min) + (fun () -> + tokenf mida iib >>= (fun mida iib -> + return ( + ((A.MetaFunc(mida,constraints,keep,inherited)))+>A.rewrap ida, + (idb, iib) + )) + )) in + (match infoidb with + | LocalFunction | Function -> is_function() + | DontKnow -> + failwith "MetaFunc, need more semantic info about id" + (* the following implementation could possibly be useful, if one + follows the convention that a macro is always in capital letters + and that a macro is not a function. + (if idb =~ "^[A-Z_][A-Z_0-9]*$" then fail else is_function())*) + ) + + | A.MetaLocalFunc(mida,constraints,keep,inherited) -> + (match infoidb with + | LocalFunction -> + X.check_constraints (ident infoidb) constraints ib + (fun () -> + let max_min _ = Lib_parsing_c.lin_col_by_pos [iib] in + X.envf keep inherited + (A.drop_pos mida,Ast_c.MetaLocalFuncVal idb, max_min) + (fun () -> + tokenf mida iib >>= (fun mida iib -> + return ( + ((A.MetaLocalFunc(mida,constraints,keep,inherited))) + +> A.rewrap ida, + (idb, iib) + )) + )) + | Function -> fail + | DontKnow -> failwith "MetaLocalFunc, need more semantic info about id" + ) + + | A.OptIdent _ | A.UniqueIdent _ -> + failwith "not handling Opt/Unique for ident" + + + +(* ------------------------------------------------------------------------- *) +and (arguments: sequence -> + (A.expression list, Ast_c.argument Ast_c.wrap2 list) matcher) = + fun seqstyle eas ebs -> + match seqstyle with + | Unordered -> failwith "not handling ooo" + | Ordered -> + arguments_bis eas (Ast_c.split_comma ebs) >>= (fun eas ebs_splitted -> + return (eas, (Ast_c.unsplit_comma ebs_splitted)) + ) +(* because '...' can match nothing, need to take care when have + * ', ...' or '...,' as in f(..., X, Y, ...). It must match + * f(1,2) for instance. + * So I have added special cases such as (if startxs = []) and code + * in the Ecomma matching rule. + * + * old: Must do some try, for instance when f(...,X,Y,...) have to + * test the transfo for all the combinaitions and if multiple transfo + * possible ? pb ? => the type is to return a expression option ? use + * some combinators to help ? + * update: with the tag-SP approach, no more a problem. + *) + +and arguments_bis = fun eas ebs -> + match eas, ebs with + | [], [] -> return ([], []) + | [], eb::ebs -> fail + | ea::eas, ebs -> + X.all_bound (A.get_inherited ea) >&&> + (match A.unwrap ea, ebs with + | A.Edots (mcode, optexpr), ys -> + (* todo: if optexpr, then a WHEN and so may have to filter yys *) + if optexpr <> None then failwith "not handling when in argument"; + + (* '...' can take more or less the beginnings of the arguments *) + let startendxs = Common.zip (Common.inits ys) (Common.tails ys) in + startendxs +> List.fold_left (fun acc (startxs, endxs) -> + acc >||> ( + + (* allow '...', and maybe its associated ',' to match nothing. + * for the associated ',' see below how we handle the EComma + * to match nothing. + *) + (if startxs = [] + then + if mcode_contain_plus (mcodekind mcode) + then fail + (* failwith "I have no token that I could accroche myself on" *) + else return (dots2metavar mcode, []) + else + (* subtil: we dont want the '...' to match until the + * comma. cf -test pb_params_iso. We would get at + * "already tagged" error. + * this is because both f (... x, ...) and f (..., x, ...) + * would match a f(x,3) with our "optional-comma" strategy. + *) + (match Common.last startxs with + | Right _ -> fail + | Left _ -> + X.distrf_args (dots2metavar mcode) startxs + ) + ) + >>= (fun mcode startxs -> + let mcode = metavar2dots mcode in + arguments_bis eas endxs >>= (fun eas endxs -> + return ( + (A.Edots (mcode, optexpr) +> A.rewrap ea) ::eas, + startxs ++ endxs + ))) + ) + ) fail + + | A.EComma ia1, Right ii::ebs -> + let ib1 = tuple_of_list1 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + arguments_bis eas ebs >>= (fun eas ebs -> + return ( + (A.EComma ia1 +> A.rewrap ea)::eas, + (Right [ib1])::ebs + ) + )) + | A.EComma ia1, ebs -> + (* allow ',' to maching nothing. optional comma trick *) + if mcode_contain_plus (mcodekind ia1) + then fail + else arguments_bis eas ebs + + | A.MetaExprList(ida,leninfo,keep,inherited),ys -> + let startendxs = Common.zip (Common.inits ys) (Common.tails ys) in + startendxs +> List.fold_left (fun acc (startxs, endxs) -> + acc >||> ( + let ok = + if startxs = [] + then + if mcode_contain_plus (mcodekind ida) + then false + (* failwith "no token that I could accroche myself on" *) + else true + else + (match Common.last startxs with + | Right _ -> false + | Left _ -> true + ) + in + if not ok + then fail + else + let startxs' = Ast_c.unsplit_comma startxs in + let len = List.length startxs' in + + (match leninfo with + | Some (lenname,lenkeep,leninherited) -> + let max_min _ = failwith "no pos" in + X.envf lenkeep leninherited + (lenname, Ast_c.MetaListlenVal (len), max_min) + | None -> function f -> f() + ) + (fun () -> + let max_min _ = + Lib_parsing_c.lin_col_by_pos + (Lib_parsing_c.ii_of_args startxs) in + X.envf keep inherited + (ida, Ast_c.MetaExprListVal startxs', max_min) + (fun () -> + if startxs = [] + then return (ida, []) + else X.distrf_args ida (Ast_c.split_comma startxs') + ) + >>= (fun ida startxs -> + arguments_bis eas endxs >>= (fun eas endxs -> + return ( + (A.MetaExprList(ida,leninfo,keep,inherited)) + +> A.rewrap ea::eas, + startxs ++ endxs + )) + ) + ) + )) fail + + + | _unwrapx, (Left eb)::ebs -> + argument ea eb >>= (fun ea eb -> + arguments_bis eas ebs >>= (fun eas ebs -> + return (ea::eas, Left eb::ebs) + )) + | _unwrapx, (Right y)::ys -> raise Impossible + | _unwrapx, [] -> fail + ) + + +and argument arga argb = + X.all_bound (A.get_inherited arga) >&&> + match A.unwrap arga, argb with + | A.TypeExp tya, Right (B.ArgType (((b, sopt, tyb), ii_b_s))) -> + + if b || sopt <> None + then + (* failwith "the argument have a storage and ast_cocci does not have"*) + fail + else + fullType tya tyb >>= (fun tya tyb -> + return ( + (A.TypeExp tya) +> A.rewrap arga, + (Right (B.ArgType (((b, sopt, tyb), ii_b_s)))) + )) + + | A.TypeExp tya, _ -> fail + | _, Right (B.ArgType (tyb, sto_iisto)) -> fail + | _, Left argb -> + expression arga argb >>= (fun arga argb -> + return (arga, Left argb) + ) + | _, Right (B.ArgAction y) -> fail + + +(* ------------------------------------------------------------------------- *) +(* todo? facto code with argument ? *) +and (parameters: sequence -> + (A.parameterTypeDef list, Ast_c.parameterType Ast_c.wrap2 list) + matcher) = + fun seqstyle eas ebs -> + match seqstyle with + | Unordered -> failwith "not handling ooo" + | Ordered -> + parameters_bis eas (Ast_c.split_comma ebs) >>= (fun eas ebs_splitted -> + return (eas, (Ast_c.unsplit_comma ebs_splitted)) + ) + + +and parameters_bis eas ebs = + match eas, ebs with + | [], [] -> return ([], []) + | [], eb::ebs -> fail + | ea::eas, ebs -> + (* the management of positions is inlined into each case, because + sometimes there is a Param and sometimes a ParamList *) + X.all_bound (A.get_inherited ea) >&&> + (match A.unwrap ea, ebs with + | A.Pdots (mcode), ys -> + + (* '...' can take more or less the beginnings of the arguments *) + let startendxs = Common.zip (Common.inits ys) (Common.tails ys) in + startendxs +> List.fold_left (fun acc (startxs, endxs) -> + acc >||> ( + + (if startxs = [] + then + if mcode_contain_plus (mcodekind mcode) + then fail + (* failwith "I have no token that I could accroche myself on"*) + else return (dots2metavar mcode, []) + else + (match Common.last startxs with + | Right _ -> fail + | Left _ -> + X.distrf_params (dots2metavar mcode) startxs + ) + ) >>= (fun mcode startxs -> + let mcode = metavar2dots mcode in + parameters_bis eas endxs >>= (fun eas endxs -> + return ( + (A.Pdots (mcode) +> A.rewrap ea) ::eas, + startxs ++ endxs + ))) + ) + ) fail + + | A.PComma ia1, Right ii::ebs -> + let ib1 = tuple_of_list1 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + parameters_bis eas ebs >>= (fun eas ebs -> + return ( + (A.PComma ia1 +> A.rewrap ea)::eas, + (Right [ib1])::ebs + ) + )) + + | A.PComma ia1, ebs -> + (* try optional comma trick *) + if mcode_contain_plus (mcodekind ia1) + then fail + else parameters_bis eas ebs + + + | A.MetaParamList(ida,leninfo,keep,inherited),ys-> + let startendxs = Common.zip (Common.inits ys) (Common.tails ys) in + startendxs +> List.fold_left (fun acc (startxs, endxs) -> + acc >||> ( + let ok = + if startxs = [] + then + if mcode_contain_plus (mcodekind ida) + then false + (* failwith "I have no token that I could accroche myself on" *) + else true + else + (match Common.last startxs with + | Right _ -> false + | Left _ -> true + ) + in + if not ok + then fail + else + let startxs' = Ast_c.unsplit_comma startxs in + let len = List.length startxs' in + + (match leninfo with + Some (lenname,lenkeep,leninherited) -> + let max_min _ = failwith "no pos" in + X.envf lenkeep leninherited + (lenname, Ast_c.MetaListlenVal (len), max_min) + | None -> function f -> f() + ) + (fun () -> + let max_min _ = + Lib_parsing_c.lin_col_by_pos + (Lib_parsing_c.ii_of_params startxs) in + X.envf keep inherited + (ida, Ast_c.MetaParamListVal startxs', max_min) + (fun () -> + if startxs = [] + then return (ida, []) + else X.distrf_params ida (Ast_c.split_comma startxs') + ) >>= (fun ida startxs -> + parameters_bis eas endxs >>= (fun eas endxs -> + return ( + (A.MetaParamList(ida,leninfo,keep,inherited)) + +> A.rewrap ea::eas, + startxs ++ endxs + )) + ) + )) + ) fail + + + | A.VoidParam ta, ys -> + (match eas, ebs with + | [], [Left eb] -> + let ((hasreg, idbopt, tb), ii_b_s) = eb in + if idbopt = None && null ii_b_s + then + match tb with + | (qub, (B.BaseType B.Void,_)) -> + fullType ta tb >>= (fun ta tb -> + return ( + [(A.VoidParam ta) +> A.rewrap ea], + [Left ((hasreg, idbopt, tb), ii_b_s)] + )) + | _ -> fail + else fail + | _ -> fail + ) + + | (A.OptParam _ | A.UniqueParam _), _ -> + failwith "handling Opt/Unique for Param" + + | A.Pcircles (_), ys -> raise Impossible (* in Ordered mode *) + + + | A.MetaParam (ida,keep,inherited), (Left eb)::ebs -> + (* todo: use quaopt, hasreg ? *) + let max_min _ = + Lib_parsing_c.lin_col_by_pos (Lib_parsing_c.ii_of_param eb) in + X.envf keep inherited (ida,Ast_c.MetaParamVal eb,max_min) (fun () -> + X.distrf_param ida eb + ) >>= (fun ida eb -> + parameters_bis eas ebs >>= (fun eas ebs -> + return ( + (A.MetaParam(ida,keep,inherited))+> A.rewrap ea::eas, + (Left eb)::ebs + ))) + + + | A.Param (typa, idaopt), (Left eb)::ebs -> + (*this should succeed if the C code has a name, and fail otherwise*) + parameter (idaopt, typa) eb >>= (fun (idaopt, typa) eb -> + parameters_bis eas ebs >>= (fun eas ebs -> + return ( + (A.Param (typa, idaopt))+> A.rewrap ea :: eas, + (Left eb)::ebs + ))) + + | _unwrapx, (Right y)::ys -> raise Impossible + | _unwrapx, [] -> fail + ) + + + + + +and parameter = fun (idaopt, typa) ((hasreg, idbopt, typb), ii_b_s) -> + fullType typa typb >>= (fun typa typb -> + match idaopt, Ast_c.split_register_param (hasreg, idbopt, ii_b_s) with + | Some ida, Left (idb, iihasreg, iidb) -> + (* todo: if minus on ida, should also minus the iihasreg ? *) + ident DontKnow ida (idb,iidb) >>= (fun ida (idb,iidb) -> + return ( + (Some ida, typa), + ((hasreg, Some idb, typb), iihasreg++[iidb]) + )) + + | None, Right iihasreg -> + return ( + (None, typa), + ((hasreg, None, typb), iihasreg) + ) + + + (* why handle this case ? because of transform_proto ? we may not + * have an ident in the proto. + * If have some plus on ida ? do nothing about ida ? + *) + (* not anymore !!! now that julia is handling the proto. + | _, Right iihasreg -> + return ( + (idaopt, typa), + ((hasreg, None, typb), iihasreg) + ) + *) + + | Some _, Right _ -> fail + | None, Left _ -> fail + ) + + + + +(* ------------------------------------------------------------------------- *) +and (declaration: (A.mcodekind * bool * A.declaration,B.declaration) matcher) = + fun (mckstart, allminus, decla) declb -> + X.all_bound (A.get_inherited decla) >&&> + match A.unwrap decla, declb with + + (* Un MetaDecl est introduit dans l'asttoctl pour sauter au dessus + * de toutes les declarations qui sont au debut d'un fonction et + * commencer le reste du match au premier statement. Alors, ca matche + * n'importe quelle declaration. On n'a pas besoin d'ajouter + * quoi que ce soit dans l'environnement. C'est une sorte de DDots. + * + * When the SP want to remove the whole function, the minus is not + * on the MetaDecl but on the MetaRuleElem. So there should + * be no transform of MetaDecl, just matching are allowed. + *) + + | A.MetaDecl(ida,_keep,_inherited), _ -> (* keep ? inherited ? *) + (* todo: should not happen in transform mode *) + return ((mckstart, allminus, decla), declb) + + + + | _, (B.DeclList ([var], iiptvirgb::iifakestart::iisto)) -> + onedecl allminus decla (var,iiptvirgb,iisto) >>= + (fun decla (var,iiptvirgb,iisto)-> + X.tokenf_mck mckstart iifakestart >>= (fun mckstart iifakestart -> + return ( + (mckstart, allminus, decla), + (B.DeclList ([var], iiptvirgb::iifakestart::iisto)) + ))) + + | _, (B.DeclList (xs, iiptvirgb::iifakestart::iisto)) -> + if X.mode = PatternMode + then + xs +> List.fold_left (fun acc var -> + acc >||> ( + X.tokenf_mck mckstart iifakestart >>= (fun mckstart iifakestart -> + onedecl allminus decla (var, iiptvirgb, iisto) >>= + (fun decla (var, iiptvirgb, iisto) -> + return ( + (mckstart, allminus, decla), + (B.DeclList ([var], iiptvirgb::iifakestart::iisto)) + ))))) + fail + else + failwith "More that one variable in decl. Have to split to transform." + + | A.MacroDecl (sa,lpa,eas,rpa,enda), B.MacroDecl ((sb,ebs),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 + ) in + (if allminus + then minusize_list iistob + else return ((), iistob) + ) >>= (fun () iistob -> + + X.tokenf_mck mckstart iifakestart >>= (fun mckstart iifakestart -> + ident DontKnow sa (sb, iisb) >>= (fun sa (sb, iisb) -> + tokenf lpa lpb >>= (fun lpa lpb -> + tokenf rpa rpb >>= (fun rpa rpb -> + tokenf enda iiendb >>= (fun enda iiendb -> + arguments (seqstyle eas) (A.undots eas) ebs >>= (fun easundots ebs -> + let eas = redots eas easundots in + + return ( + (mckstart, allminus, + (A.MacroDecl (sa,lpa,eas,rpa,enda)) +> A.rewrap decla), + (B.MacroDecl ((sb,ebs), + [iisb;lpb;rpb;iiendb;iifakestart] ++ iistob)) + )))))))) + + | _, (B.MacroDecl _ |B.DeclList _) -> fail + + + +and onedecl = fun allminus decla (declb, iiptvirgb, iistob) -> + X.all_bound (A.get_inherited decla) >&&> + match A.unwrap decla, declb with + + (* kind of typedef iso, we must unfold, it's for the case + * T { }; that we want to match against typedef struct { } xx_t; + *) + | A.TyDecl (tya0, ptvirga), + ({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb0; + B.v_storage = (B.StoTypedef, inl); + B.v_local = local; + B.v_attr = attrs; + }, iivirg) -> + + (match A.unwrap tya0, typb0 with + | A.Type(cv1,tya1), ((qu,il),typb1) -> + + (match A.unwrap tya1, typb1 with + | A.StructUnionDef(tya2, lba, declsa, rba), + (B.StructUnion (sub, sbopt, declsb), ii) -> + + let (iisub, iisbopt, lbb, rbb) = + match sbopt with + | None -> + let (iisub, lbb, rbb) = tuple_of_list3 ii in + (iisub, [], lbb, rbb) + | Some s -> + pr2 (sprintf + "warning: both a typedef (%s) and struct name introduction (%s)" + idb s + ); + pr2 "warning: I will consider only the typedef"; + let (iisub, iisb, lbb, rbb) = tuple_of_list4 ii in + (iisub, [iisb], lbb, rbb) + in + let structnameb = + structdef_to_struct_name + (Ast_c.nQ, (B.StructUnion (sub, sbopt, declsb), ii)) + in + let fake_typeb = + Ast_c.nQ,((B.TypeName (idb, Some + (Lib_parsing_c.al_type structnameb))), [iidb]) + in + + tokenf ptvirga iiptvirgb >>= (fun ptvirga iiptvirgb -> + tokenf lba lbb >>= (fun lba lbb -> + tokenf rba rbb >>= (fun rba rbb -> + struct_fields (A.undots declsa) declsb >>=(fun undeclsa declsb -> + let declsa = redots declsa undeclsa in + + (match A.unwrap tya2 with + | A.Type(cv3, tya3) -> + (match A.unwrap tya3 with + | A.MetaType(ida,keep, inherited) -> + + fullType tya2 fake_typeb >>= (fun tya2 fake_typeb -> + let tya1 = + A.StructUnionDef(tya2,lba,declsa,rba)+> A.rewrap tya1 in + let tya0 = A.Type(cv1, tya1) +> A.rewrap tya0 in + + + let typb1 = B.StructUnion (sub,sbopt, declsb), + [iisub] @ iisbopt @ [lbb;rbb] in + let typb0 = ((qu, il), typb1) in + + match fake_typeb with + | _nQ, ((B.TypeName (idb,_typ)), [iidb]) -> + + return ( + (A.TyDecl (tya0, ptvirga)) +> A.rewrap decla, + (({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb0; + B.v_storage = (B.StoTypedef, inl); + B.v_local = local; + B.v_attr = attrs; + }, + iivirg),iiptvirgb,iistob) + ) + | _ -> raise Impossible + ) + + | A.StructUnionName(sua, sa) -> + + fullType tya2 structnameb >>= (fun tya2 structnameb -> + + let tya1 = A.StructUnionDef(tya2,lba,declsa,rba)+> A.rewrap tya1 + in + let tya0 = A.Type(cv1, tya1) +> A.rewrap tya0 in + + match structnameb with + | _nQ, (B.StructUnionName (sub, s), [iisub;iisbopt]) -> + + let typb1 = B.StructUnion (sub,sbopt, declsb), + [iisub;iisbopt;lbb;rbb] in + let typb0 = ((qu, il), typb1) in + + return ( + (A.TyDecl (tya0, ptvirga)) +> A.rewrap decla, + (({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb0; + B.v_storage = (B.StoTypedef, inl); + B.v_local = local; + B.v_attr = attrs; + }, + iivirg),iiptvirgb,iistob) + ) + | _ -> raise Impossible + ) + | _ -> raise Impossible + ) + | _ -> fail + ))))) + | _ -> fail + ) + | _ -> fail + ) + + | A.UnInit (stoa, typa, ida, ptvirga), + ({B.v_namei = Some ((idb, _),[iidb]); + B.v_storage = (B.StoTypedef,_); + }, iivirg) -> + fail + + | A.Init (stoa, typa, ida, eqa, inia, ptvirga), + ({B.v_namei = Some ((idb, _),[iidb]); + B.v_storage = (B.StoTypedef,_); + }, iivirg) -> + fail + + + + (* could handle iso here but handled in standard.iso *) + | A.UnInit (stoa, typa, ida, ptvirga), + ({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb; + B.v_storage = stob; + B.v_local = local; + B.v_attr = attrs; + }, iivirg) -> + + tokenf ptvirga iiptvirgb >>= (fun ptvirga iiptvirgb -> + fullType typa typb >>= (fun typa typb -> + ident DontKnow ida (idb, iidb) >>= (fun ida (idb, iidb) -> + storage_optional_allminus allminus stoa (stob, iistob) >>= + (fun stoa (stob, iistob) -> + return ( + (A.UnInit (stoa, typa, ida, ptvirga)) +> A.rewrap decla, + (({B.v_namei = Some ((idb,None),[iidb]); + B.v_type = typb; + B.v_storage = stob; + B.v_local = local; + B.v_attr = attrs; + },iivirg), + iiptvirgb,iistob) + ))))) + + | A.Init (stoa, typa, ida, eqa, inia, ptvirga), + ({B.v_namei = Some((idb,Some inib),[iidb;iieqb]); + B.v_type = typb; + B.v_storage = stob; + B.v_local = local; + B.v_attr = attrs; + },iivirg) + -> + tokenf ptvirga iiptvirgb >>= (fun ptvirga iiptvirgb -> + tokenf eqa iieqb >>= (fun eqa iieqb -> + fullType typa typb >>= (fun typa typb -> + ident DontKnow ida (idb, iidb) >>= (fun ida (idb, iidb) -> + storage_optional_allminus allminus stoa (stob, iistob) >>= + (fun stoa (stob, iistob) -> + initialiser inia inib >>= (fun inia inib -> + return ( + (A.Init (stoa, typa, ida, eqa, inia, ptvirga)) +> A.rewrap decla, + (({B.v_namei = Some((idb,Some inib),[iidb;iieqb]); + B.v_type = typb; + B.v_storage = stob; + B.v_local = local; + B.v_attr = attrs; + },iivirg), + iiptvirgb,iistob) + ))))))) + + (* do iso-by-absence here ? allow typedecl and var ? *) + | A.TyDecl (typa, ptvirga), + ({B.v_namei = None; B.v_type = typb; + B.v_storage = stob; + B.v_local = local; + B.v_attr = attrs; + }, iivirg) -> + + if stob = (B.NoSto, false) + then + tokenf ptvirga iiptvirgb >>= (fun ptvirga iiptvirgb -> + fullType typa typb >>= (fun typa typb -> + return ( + (A.TyDecl (typa, ptvirga)) +> A.rewrap decla, + (({B.v_namei = None; + B.v_type = typb; + B.v_storage = stob; + B.v_local = local; + B.v_attr = attrs; + }, iivirg), iiptvirgb, iistob) + ))) + else fail + + + | A.Typedef (stoa, typa, ida, ptvirga), + ({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb; + B.v_storage = (B.StoTypedef,inline); + B.v_local = local; + B.v_attr = attrs; + },iivirg) -> + + tokenf ptvirga iiptvirgb >>= (fun ptvirga iiptvirgb -> + fullType typa typb >>= (fun typa typb -> + (match iistob with + | [iitypedef] -> + tokenf stoa iitypedef >>= (fun stoa iitypedef -> + return (stoa, [iitypedef]) + ) + | _ -> failwith "wierd, have both typedef and inline or nothing"; + ) >>= (fun stoa iistob -> + (match A.unwrap ida with + | A.MetaType(_,_,_) -> + + let fake_typeb = + Ast_c.nQ, ((B.TypeName (idb, Ast_c.noTypedefDef())), [iidb]) + in + fullTypebis ida fake_typeb >>= (fun ida fake_typeb -> + match fake_typeb with + | _nQ, ((B.TypeName (idb,_typ)), [iidb]) -> + return (ida, (idb, iidb)) + | _ -> raise Impossible + ) + + | A.TypeName sa -> + if (term sa) =$= idb + then + tokenf sa iidb >>= (fun sa iidb -> + return ( + (A.TypeName sa) +> A.rewrap ida, + (idb, iidb) + )) + else fail + | _ -> raise Impossible + + ) >>= (fun ida (idb, iidb) -> + return ( + (A.Typedef (stoa, typa, ida, ptvirga)) +> A.rewrap decla, + (({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb; + B.v_storage = (B.StoTypedef,inline); + B.v_local = local; + B.v_attr = attrs; + }, + iivirg), + iiptvirgb, iistob) + ) + )))) + + + | _, ({B.v_namei = None;}, _) -> + (* old: failwith "no variable in this declaration, wierd" *) + fail + + + + | A.DisjDecl declas, declb -> + declas +> List.fold_left (fun acc decla -> + acc >|+|> + (* (declaration (mckstart, allminus, decla) declb) *) + (onedecl allminus decla (declb,iiptvirgb, iistob)) + ) fail + + + + (* only in struct type decls *) + | A.Ddots(dots,whencode), _ -> + raise Impossible + + | A.OptDecl _, _ | A.UniqueDecl _, _ -> + failwith "not handling Opt/Unique Decl" + + | _, ({B.v_namei=Some _}, _) + -> fail + + + + +(* ------------------------------------------------------------------------- *) + +and (initialiser: (A.initialiser, Ast_c.initialiser) matcher) = fun ia ib -> + X.all_bound (A.get_inherited ia) >&&> + match (A.unwrap ia,ib) with + + | (A.InitExpr expa, ib) -> + (match A.unwrap expa, ib with + | A.Edots (mcode, None), ib -> + X.distrf_ini (dots2metavar mcode) ib >>= (fun mcode ib -> + return ( + A.InitExpr + (A.Edots (metavar2dots mcode, None) +> A.rewrap expa) + +> A.rewrap ia, + ib + )) + + | A.Edots (_, Some expr), _ -> failwith "not handling when on Edots" + + | _, (B.InitExpr expb, ii) -> + assert (null ii); + expression expa expb >>= (fun expa expb -> + return ( + (A.InitExpr expa) +> A.rewrap ia, + (B.InitExpr expb, ii) + )) + | _ -> fail + ) + + | (A.InitList (ia1, ias, ia2, []), (B.InitList ibs, ii)) -> + (match ii with + | ib1::ib2::iicommaopt -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + initialisers ias (ibs, iicommaopt) >>= (fun ias (ibs,iicommaopt) -> + return ( + (A.InitList (ia1, ias, ia2, [])) +> A.rewrap ia, + (B.InitList ibs, ib1::ib2::iicommaopt) + )))) + + | _ -> raise Impossible + ) + + | (A.InitList (i1, ias, i2, whencode),(B.InitList ibs, _ii)) -> + failwith "TODO: not handling whencode in initialisers" + + + | (A.InitGccDotName (ia1, ida, ia2, inia), + (B.InitDesignators ([B.DesignatorField idb,ii1], inib), ii2))-> + + let (iidot, iidb) = tuple_of_list2 ii1 in + let iieq = tuple_of_list1 ii2 in + + tokenf ia1 iidot >>= (fun ia1 iidot -> + tokenf ia2 iieq >>= (fun ia2 iieq -> + ident DontKnow ida (idb, iidb) >>= (fun ida (idb, iidb) -> + initialiser inia inib >>= (fun inia inib -> + return ( + (A.InitGccDotName (ia1, ida, ia2, inia)) +> A.rewrap ia, + (B.InitDesignators + ([B.DesignatorField idb, [iidot;iidb]], inib), [iieq]) + ))))) + + + | (A.InitGccIndex (ia1,ea,ia2,ia3,inia), + (B.InitDesignators ([B.DesignatorIndex eb, ii1], inib), ii2)) -> + + let (ib1, ib2) = tuple_of_list2 ii1 in + let ib3 = tuple_of_list1 ii2 in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + expression ea eb >>= (fun ea eb -> + initialiser inia inib >>= (fun inia inib -> + return ( + (A.InitGccIndex (ia1,ea,ia2,ia3,inia)) +> A.rewrap ia, + (B.InitDesignators + ([B.DesignatorIndex eb, [ib1;ib2]], inib), [ib3]) + )))))) + + + | (A.InitGccRange (ia1,e1a,ia2,e2a,ia3,ia4,inia), + (B.InitDesignators ([B.DesignatorRange (e1b, e2b), ii1], inib), ii2)) -> + + let (ib1, ib2, ib3) = tuple_of_list3 ii1 in + let (ib4) = tuple_of_list1 ii2 in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + tokenf ia4 ib4 >>= (fun ia4 ib4 -> + expression e1a e1b >>= (fun e1a e1b -> + expression e2a e2b >>= (fun e2a e2b -> + initialiser inia inib >>= (fun inia inib -> + return ( + (A.InitGccRange (ia1,e1a,ia2,e2a,ia3,ia4,inia)) +> A.rewrap ia, + (B.InitDesignators + ([B.DesignatorRange (e1b, e2b),[ib1;ib2;ib3]], inib), [ib4]) + )))))))) + + + + + | (A.InitGccName (ida, ia1, inia), (B.InitFieldOld (idb, inib), ii)) -> + (match ii with + | [iidb;iicolon] -> + ident DontKnow ida (idb, iidb) >>= (fun ida (idb, iidb) -> + initialiser inia inib >>= (fun inia inib -> + tokenf ia1 iicolon >>= (fun ia1 iicolon -> + return ( + (A.InitGccName (ida, ia1, inia)) +> A.rewrap ia, + (B.InitFieldOld (idb, inib), [iidb;iicolon]) + )))) + | _ -> fail + ) + + + + | A.IComma(comma), _ -> + raise Impossible + + | A.UniqueIni _,_ | A.OptIni _,_ -> + failwith "not handling Opt/Unique on initialisers" + + | _, (B.InitIndexOld (_, _), _) -> fail + | _, (B.InitFieldOld (_, _), _) -> fail + + | _, ((B.InitDesignators (_, _)|B.InitList _|B.InitExpr _), _) + -> fail + + + + + + +and initialisers = fun ias (ibs, iicomma) -> + let ias_unsplit = unsplit_icomma ias in + let ibs_split = resplit_initialiser ibs iicomma in + + let f = + if need_unordered_initialisers ibs + then initialisers_unordered2 + else initialisers_ordered2 + in + f ias_unsplit ibs_split >>= + (fun ias_unsplit ibs_split -> + return ( + split_icomma ias_unsplit, + unsplit_initialiser ibs_split + ) + ) + +(* todo: one day julia will reput a IDots *) +and initialisers_ordered2 = fun ias ibs -> + match ias, ibs with + | [], [] -> return ([], []) + | (x, xcomma)::xs, (y, commay)::ys -> + (match A.unwrap xcomma with + | A.IComma commax -> + tokenf commax commay >>= (fun commax commay -> + initialiser x y >>= (fun x y -> + initialisers_ordered2 xs ys >>= (fun xs ys -> + return ( + (x, (A.IComma commax) +> A.rewrap xcomma)::xs, + (y, commay)::ys + ) + ))) + | _ -> raise Impossible (* unsplit_iicomma wrong *) + ) + | _ -> fail + + + +and initialisers_unordered2 = fun ias ibs -> + + match ias, ibs with + | [], ys -> return ([], ys) + | (x,xcomma)::xs, ys -> + + let permut = Common.uncons_permut_lazy ys in + permut +> List.fold_left (fun acc ((e, pos), rest) -> + acc >||> + ( + (match A.unwrap xcomma, e with + | A.IComma commax, (y, commay) -> + tokenf commax commay >>= (fun commax commay -> + initialiser x y >>= (fun x y -> + return ( + (x, (A.IComma commax) +> A.rewrap xcomma), + (y, commay)) + ) + ) + | _ -> raise Impossible (* unsplit_iicomma wrong *) + ) + >>= (fun x e -> + let rest = Lazy.force rest in + initialisers_unordered2 xs rest >>= (fun xs rest -> + return ( + x::xs, + Common.insert_elem_pos (e, pos) rest + )))) + ) fail + + +(* ------------------------------------------------------------------------- *) +and (struct_fields: (A.declaration list, B.field list) matcher) = + fun eas ebs -> + match eas, ebs with + | [], [] -> return ([], []) + | [], eb::ebs -> fail + | ea::eas, ebs -> + X.all_bound (A.get_inherited ea) >&&> + (match A.unwrap ea, ebs with + | A.Ddots (mcode, optwhen), ys -> + if optwhen <> None then failwith "not handling when in argument"; + + (* '...' can take more or less the beginnings of the arguments *) + let startendxs = Common.zip (Common.inits ys) (Common.tails ys) in + startendxs +> List.fold_left (fun acc (startxs, endxs) -> + acc >||> ( + + (if startxs = [] + then + if mcode_contain_plus (mcodekind mcode) + then fail + (* failwith "I have no token that I could accroche myself on" *) + else return (dots2metavar mcode, []) + else + + X.distrf_struct_fields (dots2metavar mcode) startxs + ) >>= (fun mcode startxs -> + let mcode = metavar2dots mcode in + struct_fields eas endxs >>= (fun eas endxs -> + return ( + (A.Ddots (mcode, optwhen) +> A.rewrap ea) ::eas, + startxs ++ endxs + ))) + ) + ) fail + | _unwrapx, eb::ebs -> + struct_field ea eb >>= (fun ea eb -> + struct_fields eas ebs >>= (fun eas ebs -> + return (ea::eas, eb::ebs) + )) + + | _unwrapx, [] -> fail + ) + +and (struct_field: (A.declaration, B.field) matcher) = fun fa fb -> + let (xfield, iifield) = fb in + + match xfield with + | B.DeclarationField (B.FieldDeclList (onefield_multivars,iiptvirg)) -> + + let iiptvirgb = tuple_of_list1 iiptvirg in + + (match onefield_multivars with + | [] -> raise Impossible + | [onevar,iivirg] -> + assert (null iivirg); + (match onevar with + | B.BitField (sopt, typb, expr), ii -> + pr2_once "warning: bitfield not handled by ast_cocci"; + fail + | B.Simple (None, typb), ii -> + pr2_once "warning: unamed struct field not handled by ast_cocci"; + fail + | B.Simple (Some idb, typb), ii -> + let (iidb) = tuple_of_list1 ii in + + (* build a declaration from a struct field *) + let allminus = false in + let iisto = [] in + let stob = B.NoSto, false in + let fake_var = + ({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb; + B.v_storage = stob; + B.v_local = Ast_c.NotLocalDecl; + B.v_attr = Ast_c.noattr; + }, + iivirg) + in + onedecl allminus fa (fake_var,iiptvirgb,iisto) >>= + (fun fa (var,iiptvirgb,iisto) -> + + match fake_var with + | ({B.v_namei = Some ((idb, None),[iidb]); + B.v_type = typb; + B.v_storage = stob; + }, iivirg) -> + let onevar = B.Simple (Some idb, typb), [iidb] in + + return ( + (fa), + ((B.DeclarationField + (B.FieldDeclList ([onevar, iivirg], [iiptvirgb]))), + iifield) + ) + | _ -> raise Impossible + ) + ) + + | x::y::xs -> + pr2_once "PB: More that one variable in decl. Have to split"; + fail + ) + | B.EmptyField -> + let _iiptvirgb = tuple_of_list1 iifield in + fail + + | B.MacroStructDeclTodo -> fail + | B.CppDirectiveStruct directive -> fail + | B.IfdefStruct directive -> fail + + + +(* ------------------------------------------------------------------------- *) +and (fullType: (A.fullType, Ast_c.fullType) matcher) = + fun typa typb -> + X.optional_qualifier_flag (fun optional_qualifier -> + X.all_bound (A.get_inherited typa) >&&> + match A.unwrap typa, typb with + | A.Type(cv,ty1), ((qu,il),ty2) -> + + if qu.B.const && qu.B.volatile + then + pr2_once + ("warning: the type is both const & volatile but cocci " ^ + "does not handle that"); + + (* Drop out the const/volatile part that has been matched. + * This is because a SP can contain const T v; in which case + * later in match_t_t when we encounter a T, we must not add in + * the environment the whole type. + *) + + + (match cv with + (* "iso-by-absence" *) + | None -> + let do_stuff () = + fullTypebis ty1 ((qu,il), ty2) >>= (fun ty1 fullty2 -> + return ( + (A.Type(None, ty1)) +> A.rewrap typa, + fullty2 + )) + in + (match optional_qualifier, qu.B.const || qu.B.volatile with + | false, false -> do_stuff () + | false, true -> fail + | true, false -> do_stuff () + | true, true -> + if !Flag.show_misc + then pr2_once "USING optional_qualifier builtin isomorphism"; + do_stuff() + ) + + + | Some x -> + (* todo: can be __const__ ? can be const & volatile so + * should filter instead ? + *) + (match term x, il with + | A.Const, [i1] when qu.B.const -> + + tokenf x i1 >>= (fun x i1 -> + fullTypebis ty1 (Ast_c.nQ,ty2) >>= (fun ty1 (_, ty2) -> + return ( + (A.Type(Some x, ty1)) +> A.rewrap typa, + ((qu, [i1]), ty2) + ))) + + | A.Volatile, [i1] when qu.B.volatile -> + tokenf x i1 >>= (fun x i1 -> + fullTypebis ty1 (Ast_c.nQ,ty2) >>= (fun ty1 (_, ty2) -> + return ( + (A.Type(Some x, ty1)) +> A.rewrap typa, + ((qu, [i1]), ty2) + ))) + + | _ -> fail + ) + ) + + | A.DisjType typas, typb -> + typas +> + List.fold_left (fun acc typa -> acc >|+|> (fullType typa typb)) fail + + | A.OptType(_), _ | A.UniqueType(_), _ + -> failwith "not handling Opt/Unique on type" + ) + + +(* + * Why not (A.typeC, Ast_c.typeC) matcher ? + * because when there is MetaType, we want that T record the whole type, + * including the qualifier, and so this type (and the new_il function in + * preceding function). +*) + +and (fullTypebis: (A.typeC, Ast_c.fullType) matcher) = + fun ta tb -> + X.all_bound (A.get_inherited ta) >&&> + match A.unwrap ta, tb with + + (* cas general *) + | A.MetaType(ida,keep, inherited), typb -> + let max_min _ = + Lib_parsing_c.lin_col_by_pos (Lib_parsing_c.ii_of_type typb) in + X.envf keep inherited (ida, B.MetaTypeVal typb, max_min) (fun () -> + X.distrf_type ida typb >>= (fun ida typb -> + return ( + A.MetaType(ida,keep, inherited) +> A.rewrap ta, + typb + )) + ) + | unwrap, (qub, typb) -> + typeC ta typb >>= (fun ta typb -> + return (ta, (qub, typb)) + ) + +and simulate_signed ta basea stringsa signaopt tb baseb ii rebuilda = + (* In ii there is a list, sometimes of length 1 or 2 or 3. + * And even if in baseb we have a Signed Int, that does not mean + * that ii is of length 2, cos Signed is the default, so if in signa + * we have Signed explicitely ? we cant "accrocher" this mcode to + * something :( So for the moment when there is signed in cocci, + * we force that there is a signed in c too (done in pattern.ml). + *) + let signbopt, iibaseb = split_signb_baseb_ii (baseb, ii) in + + + (* handle some iso on type ? (cf complex C rule for possible implicit + casting) *) + match basea, baseb with + | A.VoidType, B.Void + | A.FloatType, B.FloatType (B.CFloat) + | A.DoubleType, B.FloatType (B.CDouble) -> + assert (signaopt = None); + let stringa = tuple_of_list1 stringsa in + let (ibaseb) = tuple_of_list1 ii in + tokenf stringa ibaseb >>= (fun stringa ibaseb -> + return ( + (rebuilda ([stringa], signaopt)) +> A.rewrap ta, + (B.BaseType baseb, [ibaseb]) + )) + + | A.CharType, B.IntType B.CChar when signaopt = None -> + let stringa = tuple_of_list1 stringsa in + let ibaseb = tuple_of_list1 ii in + tokenf stringa ibaseb >>= (fun stringa ibaseb -> + return ( + (rebuilda ([stringa], signaopt)) +> A.rewrap ta, + (B.BaseType (B.IntType B.CChar), [ibaseb]) + )) + + | A.CharType,B.IntType (B.Si (_sign, B.CChar2)) when signaopt <> None -> + let stringa = tuple_of_list1 stringsa in + let ibaseb = tuple_of_list1 iibaseb in + sign signaopt signbopt >>= (fun signaopt iisignbopt -> + tokenf stringa ibaseb >>= (fun stringa ibaseb -> + return ( + (rebuilda ([stringa], signaopt)) +> A.rewrap ta, + (B.BaseType (baseb), iisignbopt ++ [ibaseb]) + ))) + + | A.ShortType, B.IntType (B.Si (_, B.CShort)) + | A.IntType, B.IntType (B.Si (_, B.CInt)) + | A.LongType, B.IntType (B.Si (_, B.CLong)) -> + let stringa = tuple_of_list1 stringsa in + (match iibaseb with + | [] -> + (* iso-by-presence ? *) + (* when unsigned int in SP, allow have just unsigned in C ? *) + if mcode_contain_plus (mcodekind stringa) + then fail + else + + sign signaopt signbopt >>= (fun signaopt iisignbopt -> + return ( + (rebuilda ([stringa], signaopt)) +> A.rewrap ta, + (B.BaseType (baseb), iisignbopt ++ []) + )) + + + | [x;y] -> + pr2_once + "warning: long int or short int not handled by ast_cocci"; + fail + + | [ibaseb] -> + sign signaopt signbopt >>= (fun signaopt iisignbopt -> + tokenf stringa ibaseb >>= (fun stringa ibaseb -> + return ( + (rebuilda ([stringa], signaopt)) +> A.rewrap ta, + (B.BaseType (baseb), iisignbopt ++ [ibaseb]) + ))) + | _ -> raise Impossible + + ) + + + | A.LongLongType, B.IntType (B.Si (_, B.CLongLong)) -> + let (string1a,string2a) = tuple_of_list2 stringsa in + (match iibaseb with + [ibase1b;ibase2b] -> + sign signaopt signbopt >>= (fun signaopt iisignbopt -> + tokenf string1a ibase1b >>= (fun base1a ibase1b -> + tokenf string2a ibase2b >>= (fun base2a ibase2b -> + return ( + (rebuilda ([base1a;base2a], signaopt)) +> A.rewrap ta, + (B.BaseType (baseb), iisignbopt ++ [ibase1b;ibase2b]) + )))) + | [] -> fail (* should something be done in this case? *) + | _ -> raise Impossible) + + + | _, B.FloatType B.CLongDouble + -> + pr2_once + "warning: long double not handled by ast_cocci"; + fail + + | _, (B.Void|B.FloatType _|B.IntType _) -> fail + +and simulate_signed_meta ta basea signaopt tb baseb ii rebuilda = + (* In ii there is a list, sometimes of length 1 or 2 or 3. + * And even if in baseb we have a Signed Int, that does not mean + * that ii is of length 2, cos Signed is the default, so if in signa + * we have Signed explicitely ? we cant "accrocher" this mcode to + * something :( So for the moment when there is signed in cocci, + * we force that there is a signed in c too (done in pattern.ml). + *) + let signbopt, iibaseb = split_signb_baseb_ii (baseb, ii) in + + let match_to_type rebaseb = + sign signaopt signbopt >>= (fun signaopt iisignbopt -> + let ibaseb = tuple_of_list1 iibaseb in + let fta = A.rewrap basea (A.Type(None,basea)) in + let ftb = Ast_c.nQ,(B.BaseType (rebaseb), [ibaseb]) in + fullType fta ftb >>= (fun fta (_,tb) -> + (match A.unwrap fta,tb with + A.Type(_,basea), (B.BaseType baseb, ii) -> + let ibaseb = tuple_of_list1 ii in + return ( + (rebuilda (basea, signaopt)) +> A.rewrap ta, + (B.BaseType (baseb), iisignbopt ++ [ibaseb]) + ) + | _ -> failwith "not possible"))) in + + (* handle some iso on type ? (cf complex C rule for possible implicit + casting) *) + match baseb with + | B.IntType (B.Si (_sign, B.CChar2)) -> + match_to_type (B.IntType B.CChar) + + | B.IntType (B.Si (_, ty)) -> + (match iibaseb with + | [] -> fail (* metavariable has to match something *) + + | [x;y] -> + pr2_once + "warning: long int or short int not handled by ast_cocci"; + fail + + | [ibaseb] -> match_to_type (B.IntType (B.Si (B.Signed, ty))) + | _ -> raise Impossible + + ) + + | (B.Void|B.FloatType _|B.IntType _) -> fail + +and (typeC: (A.typeC, Ast_c.typeC) matcher) = + fun ta tb -> + match A.unwrap ta, tb with + | A.BaseType (basea,stringsa), (B.BaseType baseb, ii) -> + simulate_signed ta basea stringsa None tb baseb ii + (function (stringsa, signaopt) -> A.BaseType (basea,stringsa)) + | A.SignedT (signaopt, Some basea), (B.BaseType baseb, ii) -> + (match A.unwrap basea with + A.BaseType (basea1,strings1) -> + simulate_signed ta basea1 strings1 (Some signaopt) tb baseb ii + (function (strings1, Some signaopt) -> + A.SignedT + (signaopt, + Some (A.rewrap basea (A.BaseType (basea1,strings1)))) + | _ -> failwith "not possible") + | A.MetaType(ida,keep,inherited) -> + simulate_signed_meta ta basea (Some signaopt) tb baseb ii + (function (basea, Some signaopt) -> + A.SignedT(signaopt,Some basea) + | _ -> failwith "not possible") + | _ -> failwith "not possible") + | A.SignedT (signa,None), (B.BaseType baseb, ii) -> + let signbopt, iibaseb = split_signb_baseb_ii (baseb, ii) in + (match iibaseb, baseb with + | [], B.IntType (B.Si (_sign, B.CInt)) -> + sign (Some signa) signbopt >>= (fun signaopt iisignbopt -> + match signaopt with + | None -> raise Impossible + | Some signa -> + return ( + (A.SignedT (signa,None)) +> A.rewrap ta, + (B.BaseType baseb, iisignbopt) + ) + ) + | _ -> fail + ) + + + + (* todo? iso with array *) + | A.Pointer (typa, iamult), (B.Pointer typb, ii) -> + let (ibmult) = tuple_of_list1 ii in + fullType typa typb >>= (fun typa typb -> + tokenf iamult ibmult >>= (fun iamult ibmult -> + return ( + (A.Pointer (typa, iamult)) +> A.rewrap ta, + (B.Pointer typb, [ibmult]) + ))) + + | A.FunctionType(allminus,tyaopt,lpa,paramsa,rpa), + (B.FunctionType(tyb, (paramsb, (isvaargs, iidotsb))), ii) -> + + let (lpb, rpb) = tuple_of_list2 ii in + if isvaargs + then + pr2_once + ("Not handling well variable length arguments func. "^ + "You have been warned"); + tokenf lpa lpb >>= (fun lpa lpb -> + tokenf rpa rpb >>= (fun rpa rpb -> + fullType_optional_allminus allminus tyaopt tyb >>= (fun tyaopt tyb -> + parameters (seqstyle paramsa) (A.undots paramsa) paramsb >>= + (fun paramsaundots paramsb -> + let paramsa = redots paramsa paramsaundots in + return ( + (A.FunctionType(allminus,tyaopt,lpa,paramsa,rpa) +> A.rewrap ta, + (B.FunctionType(tyb, (paramsb, (isvaargs, iidotsb))), [lpb;rpb]) + ) + ))))) + + + + + + | A.FunctionPointer(tya,lp1a,stara,rp1a,lp2a,paramsa,rp2a), + (B.ParenType t1, ii) -> + let (lp1b, rp1b) = tuple_of_list2 ii in + let (qu1b, t1b) = t1 in + (match t1b with + | B.Pointer t2, ii -> + let (starb) = tuple_of_list1 ii in + let (qu2b, t2b) = t2 in + (match t2b with + | B.FunctionType (tyb, (paramsb, (isvaargs, iidotsb))), ii -> + let (lp2b, rp2b) = tuple_of_list2 ii in + + if isvaargs + then + pr2_once + ("Not handling well variable length arguments func. "^ + "You have been warned"); + + fullType tya tyb >>= (fun tya tyb -> + tokenf lp1a lp1b >>= (fun lp1a lp1b -> + tokenf rp1a rp1b >>= (fun rp1a rp1b -> + tokenf lp2a lp2b >>= (fun lp2a lp2b -> + tokenf rp2a rp2b >>= (fun rp2a rp2b -> + tokenf stara starb >>= (fun stara starb -> + parameters (seqstyle paramsa) (A.undots paramsa) paramsb >>= + (fun paramsaundots paramsb -> + let paramsa = redots paramsa paramsaundots in + + let t2 = + (qu2b, + (B.FunctionType (tyb, (paramsb, (isvaargs, iidotsb))), + [lp2b;rp2b])) + in + let t1 = + (qu1b, + (B.Pointer t2, [starb])) + in + + return ( + (A.FunctionPointer(tya,lp1a,stara,rp1a,lp2a,paramsa,rp2a)) + +> A.rewrap ta, + (B.ParenType t1, [lp1b;rp1b]) + ) + ))))))) + + + + | _ -> fail + ) + | _ -> fail + ) + + + + (* todo: handle the iso on optionnal size specifification ? *) + | A.Array (typa, ia1, eaopt, ia2), (B.Array (ebopt, typb), ii) -> + let (ib1, ib2) = tuple_of_list2 ii in + fullType typa typb >>= (fun typa typb -> + option expression eaopt ebopt >>= (fun eaopt ebopt -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + (A.Array (typa, ia1, eaopt, ia2)) +> A.rewrap ta, + (B.Array (ebopt, typb), [ib1;ib2]) + ))))) + + + (* todo: could also match a Struct that has provided a name *) + (* This is for the case where the SmPL code contains "struct x", without + a definition. In this case, the name field is always present. + This case is also called from the case for A.StructUnionDef when + a name is present in the C code. *) + | A.StructUnionName(sua, Some sa), (B.StructUnionName (sub, sb), ii) -> + (* sa is now an ident, not an mcode, old: ... && (term sa) =$= sb *) + let (ib1, ib2) = tuple_of_list2 ii in + if equal_structUnion (term sua) sub + then + ident DontKnow sa (sb, ib2) >>= (fun sa (sb, ib2) -> + tokenf sua ib1 >>= (fun sua ib1 -> + return ( + (A.StructUnionName (sua, Some sa)) +> A.rewrap ta, + (B.StructUnionName (sub, sb), [ib1;ib2]) + ))) + else fail + + + | A.StructUnionDef(ty, lba, declsa, rba), + (B.StructUnion (sub, sbopt, declsb), ii) -> + + let (ii_sub_sb, lbb, rbb) = + match ii with + [iisub; lbb; rbb] -> (Common.Left iisub,lbb,rbb) + | [iisub; iisb; lbb; rbb] -> (Common.Right (iisub,iisb),lbb,rbb) + | _ -> failwith "list of length 3 or 4 expected" in + + let process_type = + match (sbopt,ii_sub_sb) with + (None,Common.Left iisub) -> + (* the following doesn't reconstruct the complete SP code, just + the part that matched *) + let rec loop s = + match A.unwrap s with + A.Type(None,ty) -> + (match A.unwrap ty with + A.StructUnionName(sua, None) -> + tokenf sua iisub >>= (fun sua iisub -> + let ty = + A.Type(None, + A.StructUnionName(sua, None) +> A.rewrap ty) + +> A.rewrap s in + return (ty,[iisub])) + | _ -> fail) + | A.DisjType(disjs) -> + disjs +> + List.fold_left (fun acc disj -> acc >|+|> (loop disj)) fail + | _ -> fail in + loop ty + + | (Some sb,Common.Right (iisub,iisb)) -> + + (* build a StructUnionName from a StructUnion *) + let fake_su = B.nQ, (B.StructUnionName (sub, sb), [iisub;iisb]) in + + fullType ty fake_su >>= (fun ty fake_su -> + match fake_su with + | _nQ, (B.StructUnionName (sub, sb), [iisub;iisb]) -> + return (ty, [iisub; iisb]) + | _ -> raise Impossible) + | _ -> fail in + + process_type + >>= (fun ty ii_sub_sb -> + + tokenf lba lbb >>= (fun lba lbb -> + tokenf rba rbb >>= (fun rba rbb -> + struct_fields (A.undots declsa) declsb >>=(fun undeclsa declsb -> + let declsa = redots declsa undeclsa in + + return ( + (A.StructUnionDef(ty, lba, declsa, rba)) +> A.rewrap ta, + (B.StructUnion (sub, sbopt, declsb),ii_sub_sb@[lbb;rbb]) + ))))) + + + (* todo? handle isomorphisms ? because Unsigned Int can be match on a + * uint in the C code. But some CEs consists in renaming some types, + * so we don't want apply isomorphisms every time. + *) + | A.TypeName sa, (B.TypeName (sb,typb), ii) -> + let (isb) = tuple_of_list1 ii in + if (term sa) =$= sb + then + tokenf sa isb >>= (fun sa isb -> + return ( + (A.TypeName sa) +> A.rewrap ta, + (B.TypeName (sb,typb), [isb]) + )) + else fail + + | _, (B.TypeOfExpr e, ii) -> fail + | _, (B.TypeOfType e, ii) -> fail + + | _, (B.ParenType e, ii) -> fail (* todo ?*) + | A.EnumName(en,namea), (B.EnumName nameb, ii) -> + let (ib1,ib2) = tuple_of_list2 ii in + ident DontKnow namea (nameb, ib2) >>= (fun namea (nameb, ib2) -> + tokenf en ib1 >>= (fun en ib1 -> + return ( + (A.EnumName (en, namea)) +> A.rewrap ta, + (B.EnumName nameb, [ib1;ib2]) + ))) + + | _, (B.Enum _, _) -> fail (* todo cocci ?*) + + | _, + ((B.TypeName (_, _) | B.StructUnionName (_, _) | B.EnumName _ | + B.StructUnion (_, _, _) | + B.FunctionType _ | B.Array (_, _) | B.Pointer _ | + B.BaseType _), + _) + -> fail + + +(* todo: iso on sign, if not mentioned then free. tochange? + * but that require to know if signed int because explicit + * signed int, or because implicit signed int. + *) + +and sign signa signb = + match signa, signb with + | None, None -> return (None, []) + | Some signa, Some (signb, ib) -> + if equal_sign (term signa) signb + then tokenf signa ib >>= (fun signa ib -> + return (Some signa, [ib]) + ) + else fail + | _, _ -> fail + + +and minusize_list iixs = + iixs +> List.fold_left (fun acc ii -> + acc >>= (fun xs ys -> + tokenf minusizer ii >>= (fun minus ii -> + return (minus::xs, ii::ys) + ))) (return ([],[])) + >>= (fun _xsminys ys -> + return ((), List.rev ys) + ) + +and storage_optional_allminus allminus stoa (stob, iistob) = + (* "iso-by-absence" for storage, and return type. *) + X.optional_storage_flag (fun optional_storage -> + match stoa, stob with + | None, (stobis, inline) -> + let do_minus () = + if allminus + then + minusize_list iistob >>= (fun () iistob -> + return (None, (stob, iistob)) + ) + else return (None, (stob, iistob)) + in + + (match optional_storage, stobis with + | false, B.NoSto -> do_minus () + | false, _ -> fail + | true, B.NoSto -> do_minus () + | true, _ -> + if !Flag.show_misc + then pr2_once "USING optional_storage builtin isomorphism"; + do_minus() + ) + + | Some x, ((stobis, inline)) -> + if equal_storage (term x) stobis + then + match iistob with + | [i1] -> + tokenf x i1 >>= (fun x i1 -> + return (Some x, ((stobis, inline), [i1])) + ) + (* or if have inline ? have to do a split_storage_inline a la + * split_signb_baseb_ii *) + | _ -> raise Impossible + else fail + ) + + + + + +and fullType_optional_allminus allminus tya retb = + match tya with + | None -> + if allminus + then + X.distrf_type minusizer retb >>= (fun _x retb -> + return (None, retb) + ) + + else return (None, retb) + | Some tya -> + fullType tya retb >>= (fun tya retb -> + return (Some tya, retb) + ) + + + +(*---------------------------------------------------------------------------*) + +and compatible_base_type a signa b = + let ok = return ((),()) in + + match a, b with + | Type_cocci.VoidType, B.Void -> + assert (signa = None); + ok + | Type_cocci.CharType, B.IntType B.CChar when signa = None -> + ok + | Type_cocci.CharType, B.IntType (B.Si (signb, B.CChar2)) -> + compatible_sign signa signb + | Type_cocci.ShortType, B.IntType (B.Si (signb, B.CShort)) -> + compatible_sign signa signb + | Type_cocci.IntType, B.IntType (B.Si (signb, B.CInt)) -> + compatible_sign signa signb + | Type_cocci.LongType, B.IntType (B.Si (signb, B.CLong)) -> + compatible_sign signa signb + | _, B.IntType (B.Si (signb, B.CLongLong)) -> + pr2_once "no longlong in cocci"; + fail + | Type_cocci.FloatType, B.FloatType B.CFloat -> + assert (signa = None); + ok + | Type_cocci.DoubleType, B.FloatType B.CDouble -> + assert (signa = None); + ok + | _, B.FloatType B.CLongDouble -> + pr2_once "no longdouble in cocci"; + fail + | Type_cocci.BoolType, _ -> failwith "no booltype in C" + + | _, (B.Void|B.FloatType _|B.IntType _) -> fail + +and compatible_base_type_meta a signa qua b ii local = + match a, b with + | Type_cocci.MetaType(ida,keep,inherited), + B.IntType (B.Si (signb, B.CChar2)) -> + compatible_sign signa signb >>= fun _ _ -> + let newb = ((qua, (B.BaseType (B.IntType B.CChar),ii)),local) in + compatible_type a newb + | Type_cocci.MetaType(ida,keep,inherited), B.IntType (B.Si (signb, ty)) -> + compatible_sign signa signb >>= fun _ _ -> + let newb = + ((qua, (B.BaseType (B.IntType (B.Si (B.Signed, ty))),ii)),local) in + compatible_type a newb + | _, B.FloatType B.CLongDouble -> + pr2_once "no longdouble in cocci"; + fail + + | _, (B.Void|B.FloatType _|B.IntType _) -> fail + + +and compatible_type a (b,local) = + let ok = return ((),()) in + + let rec loop = function + | Type_cocci.BaseType a, (qua, (B.BaseType b,ii)) -> + compatible_base_type a None b + + | Type_cocci.SignedT (signa,None), (qua, (B.BaseType b,ii)) -> + compatible_base_type Type_cocci.IntType (Some signa) b + + | Type_cocci.SignedT (signa,Some ty), (qua, (B.BaseType b,ii)) -> + (match ty with + Type_cocci.BaseType ty -> + compatible_base_type ty (Some signa) b + | Type_cocci.MetaType(ida,keep,inherited) -> + compatible_base_type_meta ty (Some signa) qua b ii local + | _ -> failwith "not possible") + + | Type_cocci.Pointer a, (qub, (B.Pointer b, ii)) -> + loop (a,b) + | Type_cocci.FunctionPointer a, _ -> + failwith + "TODO: function pointer type doesn't store enough information to determine compatability" + | Type_cocci.Array a, (qub, (B.Array (eopt, b),ii)) -> + (* no size info for cocci *) + loop (a,b) + | Type_cocci.StructUnionName (sua, _, sa), + (qub, (B.StructUnionName (sub, sb),ii)) -> + if equal_structUnion_type_cocci sua sub && sa = sb + then ok + else fail + | Type_cocci.EnumName (_, sa), + (qub, (B.EnumName (sb),ii)) -> + if sa = sb + then ok + else fail + | Type_cocci.TypeName sa, (qub, (B.TypeName (sb,_typb), ii)) -> + if sa = sb + then ok + else fail + + | Type_cocci.ConstVol (qua, a), (qub, b) -> + if (fst qub).B.const && (fst qub).B.volatile + then + begin + pr2_once ("warning: the type is both const & volatile but cocci " ^ + "does not handle that"); + fail + end + else + if + (match qua with + | Type_cocci.Const -> (fst qub).B.const + | Type_cocci.Volatile -> (fst qub).B.volatile + ) + then loop (a,(Ast_c.nQ, b)) + else fail + + | Type_cocci.MetaType (ida,keep,inherited), typb -> + let max_min _ = + Lib_parsing_c.lin_col_by_pos (Lib_parsing_c.ii_of_type typb) in + X.envf keep inherited (A.make_mcode ida, B.MetaTypeVal typb, max_min) + (fun () -> ok + ) + + (* subtil: must be after the MetaType case *) + | a, (qub, (B.TypeName (sb,Some b), ii)) -> + (* kind of typedef iso *) + loop (a,b) + + + + + + (* for metavariables of type expression *^* *) + | Type_cocci.Unknown , _ -> ok + + | (_, + (_, + (( + B.TypeOfType _|B.TypeOfExpr _|B.ParenType _| + B.EnumName _|B.StructUnion (_, _, _)|B.Enum (_, _) + ), + _))) -> fail + + | (_, + (_, + (( + B.StructUnionName (_, _)| + B.FunctionType _| + B.Array (_, _)|B.Pointer _|B.TypeName _| + B.BaseType _ + ), + _))) -> fail + + + in + loop (a,b) + +and compatible_sign signa signb = + let ok = return ((),()) in + match signa, signb with + | None, B.Signed + | Some Type_cocci.Signed, B.Signed + | Some Type_cocci.Unsigned, B.UnSigned + -> ok + | _ -> fail + + +and equal_structUnion_type_cocci a b = + match a, b with + | Type_cocci.Struct, B.Struct -> true + | Type_cocci.Union, B.Union -> true + | _, (B.Struct | B.Union) -> false + + + +(*---------------------------------------------------------------------------*) +and inc_file (a, before_after) (b, h_rel_pos) = + + let rec aux_inc (ass, bss) passed = + match ass, bss with + | [], [] -> true + | [A.IncDots], _ -> + let passed = List.rev passed in + + (match before_after, !h_rel_pos with + | IncludeNothing, _ -> true + | IncludeMcodeBefore, Some x -> + List.mem passed (x.Ast_c.first_of) + + | IncludeMcodeAfter, Some x -> + List.mem passed (x.Ast_c.last_of) + + (* no info, maybe cos of a #include that was already in a .h *) + | _, None -> false + ) + + | (A.IncPath x)::xs, y::ys -> x = y && aux_inc (xs, ys) (x::passed) + | _ -> failwith "IncDots not in last place or other pb" + + in + + match a, b with + | A.Local ass, B.Local bss -> + aux_inc (ass, bss) [] + | A.NonLocal ass, B.NonLocal bss -> + aux_inc (ass, bss) [] + | _ -> false + + + +(*---------------------------------------------------------------------------*) + +and (define_params: sequence -> + (A.define_param list, (string B.wrap) B.wrap2 list) matcher) = + fun seqstyle eas ebs -> + match seqstyle with + | Unordered -> failwith "not handling ooo" + | Ordered -> + define_paramsbis eas (Ast_c.split_comma ebs) >>= (fun eas ebs_splitted -> + return (eas, (Ast_c.unsplit_comma ebs_splitted)) + ) + +(* todo? facto code with argument and parameters ? *) +and define_paramsbis = fun eas ebs -> + match eas, ebs with + | [], [] -> return ([], []) + | [], eb::ebs -> fail + | ea::eas, ebs -> + X.all_bound (A.get_inherited ea) >&&> + (match A.unwrap ea, ebs with + | A.DPdots (mcode), ys -> + + (* '...' can take more or less the beginnings of the arguments *) + let startendxs = Common.zip (Common.inits ys) (Common.tails ys) in + startendxs +> List.fold_left (fun acc (startxs, endxs) -> + acc >||> ( + + (if startxs = [] + then + if mcode_contain_plus (mcodekind mcode) + then fail + (* failwith "I have no token that I could accroche myself on" *) + else return (dots2metavar mcode, []) + else + (match Common.last startxs with + | Right _ -> fail + | Left _ -> + X.distrf_define_params (dots2metavar mcode) startxs + ) + ) >>= (fun mcode startxs -> + let mcode = metavar2dots mcode in + define_paramsbis eas endxs >>= (fun eas endxs -> + return ( + (A.DPdots (mcode) +> A.rewrap ea) ::eas, + startxs ++ endxs + ))) + ) + ) fail + + | A.DPComma ia1, Right ii::ebs -> + let ib1 = tuple_of_list1 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + define_paramsbis eas ebs >>= (fun eas ebs -> + return ( + (A.DPComma ia1 +> A.rewrap ea)::eas, + (Right [ib1])::ebs + ) + )) + + | A.DPComma ia1, ebs -> + if mcode_contain_plus (mcodekind ia1) + then fail + else + (define_paramsbis eas ebs) (* try optional comma trick *) + + | (A.OptDParam _ | A.UniqueDParam _), _ -> + failwith "handling Opt/Unique for define parameters" + + | A.DPcircles (_), ys -> raise Impossible (* in Ordered mode *) + + | A.DParam ida, (Left (idb, ii))::ebs -> + let ib1 = tuple_of_list1 ii in + ident DontKnow ida (idb, ib1) >>= (fun ida (idb, ib1) -> + define_paramsbis eas ebs >>= (fun eas ebs -> + return ( + (A.DParam ida)+> A.rewrap ea :: eas, + (Left (idb, [ib1]))::ebs + ))) + + | _unwrapx, (Right y)::ys -> raise Impossible + | _unwrapx, [] -> fail + ) + + + +(*****************************************************************************) +(* Entry points *) +(*****************************************************************************) + +(* no global solution for positions here, because for a statement metavariable +we want a MetaStmtVal, and for the others, it's not clear what we want *) + +let rec (rule_elem_node: (A.rule_elem, Control_flow_c.node) matcher) = + fun re node -> + let rewrap x = + x >>= (fun a b -> return (A.rewrap re a, F.rewrap node b)) + in + X.all_bound (A.get_inherited re) >&&> + + rewrap ( + match A.unwrap re, F.unwrap node with + + (* note: the order of the clauses is important. *) + + | _, F.Enter | _, F.Exit | _, F.ErrorExit -> fail2() + + (* the metaRuleElem contains just '-' information. We dont need to add + * stuff in the environment. If we need stuff in environment, because + * there is a + S somewhere, then this will be done via MetaStmt, not + * via MetaRuleElem. + * Can match TrueNode/FalseNode/... so must be placed before those cases. + *) + + | A.MetaRuleElem(mcode,keep,inherited), unwrap_node -> + let default = A.MetaRuleElem(mcode,keep,inherited), unwrap_node in + (match unwrap_node with + | F.CaseNode _ + | F.TrueNode | F.FalseNode | F.AfterNode | F.FallThroughNode + | F.InLoopNode -> + if X.mode = PatternMode + then return default + else + if mcode_contain_plus (mcodekind mcode) + then failwith "try add stuff on fake node" + (* minusize or contextize a fake node is ok *) + else return default + + | F.EndStatement None -> + if X.mode = PatternMode then return default + else + (* DEAD CODE NOW ? only useful in -no_cocci_vs_c_3 ? + if mcode_contain_plus (mcodekind mcode) + then + let fake_info = Ast_c.fakeInfo() in + distrf distrf_node (mcodekind mcode) + (F.EndStatement (Some fake_info)) + else return unwrap_node + *) + raise Todo + + | F.EndStatement (Some i1) -> + tokenf mcode i1 >>= (fun mcode i1 -> + return ( + A.MetaRuleElem (mcode,keep, inherited), + F.EndStatement (Some i1) + )) + + | F.FunHeader _ -> + if X.mode = PatternMode then return default + else failwith "a MetaRuleElem can't transform a headfunc" + | _n -> + if X.mode = PatternMode then return default + else + X.distrf_node (generalize_mcode mcode) node >>= (fun mcode node -> + return ( + A.MetaRuleElem(mcode,keep, inherited), + F.unwrap node + )) + ) + + + (* rene cant have found that a state containing a fake/exit/... should be + * transformed + * TODO: and F.Fake ? + *) + | _, F.EndStatement _ | _, F.CaseNode _ + | _, F.TrueNode | _, F.FalseNode | _, F.AfterNode | _, F.FallThroughNode + | _, F.InLoopNode + -> fail2() + + (* really ? diff between pattern.ml and transformation.ml *) + | _, F.Fake -> fail2() + + + (* cas general: a Meta can match everything. It matches only + * "header"-statement. We transform only MetaRuleElem, not MetaStmt. + * So can't have been called in transform. + *) + | A.MetaStmt (ida,keep,metainfoMaybeTodo,inherited), F.Decl(_) -> fail + + | A.MetaStmt (ida,keep,metainfoMaybeTodo,inherited), unwrap_node -> + (* todo: should not happen in transform mode *) + + (match Control_flow_c.extract_fullstatement node with + | Some stb -> + let max_min _ = + Lib_parsing_c.lin_col_by_pos (Lib_parsing_c.ii_of_stmt stb) in + X.envf keep inherited (ida, Ast_c.MetaStmtVal stb, max_min) + (fun () -> + (* no need tag ida, we can't be called in transform-mode *) + return ( + A.MetaStmt (ida, keep, metainfoMaybeTodo, inherited), + unwrap_node + ) + ) + | None -> fail + ) + + (* not me?: *) + | A.MetaStmtList _, _ -> + failwith "not handling MetaStmtList" + + | A.TopExp ea, F.DefineExpr eb -> + expression ea eb >>= (fun ea eb -> + return ( + A.TopExp ea, + F.DefineExpr eb + )) + + | A.TopExp ea, F.DefineType eb -> + (match A.unwrap ea with + A.TypeExp(ft) -> + fullType ft eb >>= (fun ft eb -> + return ( + A.TopExp (A.rewrap ea (A.TypeExp(ft))), + F.DefineType eb + )) + | _ -> fail) + + + + (* It is important to put this case before the one that fails because + * of the lack of the counter part of a C construct in SmPL (for instance + * there is not yet a CaseRange in SmPL). Even if SmPL don't handle + * yet certain constructs, those constructs may contain expression + * that we still want and can transform. + *) + + | A.Exp exp, nodeb -> + + (* kind of iso, initialisation vs affectation *) + let node = + match A.unwrap exp, nodeb with + | A.Assignment (ea, op, eb, true), F.Decl decl -> + initialisation_to_affectation decl +> F.rewrap node + | _ -> node + in + + + (* Now keep fullstatement inside the control flow node, + * so that can then get in a MetaStmtVar the fullstatement to later + * pp back when the S is in a +. But that means that + * Exp will match an Ifnode even if there is no such exp + * inside the condition of the Ifnode (because the exp may + * be deeper, in the then branch). So have to not visit + * all inside a node anymore. + * + * update: j'ai choisi d'accrocher au noeud du CFG à la + * fois le fullstatement et le partialstatement et appeler le + * visiteur que sur le partialstatement. + *) + let expfn = + match Ast_cocci.get_pos re with + | None -> expression + | Some pos -> + (fun ea eb -> + let (max,min) = + Lib_parsing_c.max_min_by_pos (Lib_parsing_c.ii_of_expr eb) in + let keep = Type_cocci.Unitary in + let inherited = false in + let max_min _ = failwith "no pos" in + X.envf keep inherited (pos, B.MetaPosVal (min,max), max_min) + (fun () -> + expression ea eb + ) + ) + in + X.cocciExp expfn exp node >>= (fun exp node -> + return ( + A.Exp exp, + F.unwrap node + ) + ) + + | A.Ty ty, nodeb -> + X.cocciTy fullType ty node >>= (fun ty node -> + return ( + A.Ty ty, + F.unwrap node + ) + ) + + | A.TopInit init, nodeb -> + X.cocciInit initialiser init node >>= (fun init node -> + return ( + A.TopInit init, + F.unwrap node + ) + ) + + + | A.FunHeader (mckstart, allminus, fninfoa, ida, oparen, paramsa, cparen), + F.FunHeader ({B.f_name = idb; + f_type = (retb, (paramsb, (isvaargs, iidotsb))); + f_storage = stob; + f_attr = attrs; + f_body = body; + f_old_c_style = oldstyle; + }, ii) -> + assert (null body); + + if oldstyle <> None + then pr2 "OLD STYLE DECL NOT WELL SUPPORTED"; + + + (* fninfoa records the order in which the SP specified the various + information, but this isn't taken into account in the matching. + Could this be a problem for transformation? *) + let stoa = + match + List.filter (function A.FStorage(s) -> true | _ -> false) fninfoa + with [A.FStorage(s)] -> Some s | _ -> None in + let tya = + match List.filter (function A.FType(s) -> true | _ -> false) fninfoa + with [A.FType(t)] -> Some t | _ -> None in + + (match List.filter (function A.FInline(i) -> true | _ -> false) fninfoa + with [A.FInline(i)] -> failwith "not checking inline" | _ -> ()); + + (match List.filter (function A.FAttr(a) -> true | _ -> false) fninfoa + with [A.FAttr(a)] -> failwith "not checking attributes" | _ -> ()); + + (match ii with + | iidb::ioparenb::icparenb::iifakestart::iistob -> + + (* maybe important to put ident as the first tokens to transform. + * It's related to transform_proto. So don't change order + * between the >>=. + *) + ident LocalFunction ida (idb, iidb) >>= (fun ida (idb, iidb) -> + X.tokenf_mck mckstart iifakestart >>= (fun mckstart iifakestart -> + tokenf oparen ioparenb >>= (fun oparen ioparenb -> + tokenf cparen icparenb >>= (fun cparen icparenb -> + parameters (seqstyle paramsa) + (A.undots paramsa) paramsb >>= + (fun paramsaundots paramsb -> + let paramsa = redots paramsa paramsaundots in + storage_optional_allminus allminus + stoa (stob, iistob) >>= (fun stoa (stob, iistob) -> + ( + if isvaargs + then + pr2_once + ("Not handling well variable length arguments func. "^ + "You have been warned"); + if allminus + then minusize_list iidotsb + else return ((),iidotsb) + ) >>= (fun () iidotsb -> + + fullType_optional_allminus allminus tya retb >>= (fun tya retb -> + + let fninfoa = + (match stoa with Some st -> [A.FStorage st] | None -> []) ++ + (match tya with Some t -> [A.FType t] | None -> []) + + in + + return ( + A.FunHeader(mckstart,allminus,fninfoa,ida,oparen, + paramsa,cparen), + F.FunHeader ({B.f_name = idb; + f_type = (retb, (paramsb, (isvaargs, iidotsb))); + f_storage = stob; + f_attr = attrs; + f_body = body; + f_old_c_style = oldstyle; (* TODO *) + }, + iidb::ioparenb::icparenb::iifakestart::iistob) + ) + )))))))) + | _ -> raise Impossible + ) + + + + + + + | A.Decl (mckstart,allminus,decla), F.Decl declb -> + declaration (mckstart,allminus,decla) declb >>= + (fun (mckstart,allminus,decla) declb -> + return ( + A.Decl (mckstart,allminus,decla), + F.Decl declb + )) + + + | A.SeqStart mcode, F.SeqStart (st, level, i1) -> + tokenf mcode i1 >>= (fun mcode i1 -> + return ( + A.SeqStart mcode, + F.SeqStart (st, level, i1) + )) + + | A.SeqEnd mcode, F.SeqEnd (level, i1) -> + tokenf mcode i1 >>= (fun mcode i1 -> + return ( + A.SeqEnd mcode, + F.SeqEnd (level, i1) + )) + + | A.ExprStatement (ea, ia1), F.ExprStatement (st, (Some eb, ii)) -> + let ib1 = tuple_of_list1 ii in + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + return ( + A.ExprStatement (ea, ia1), + F.ExprStatement (st, (Some eb, [ib1])) + ) + )) + + + | A.IfHeader (ia1,ia2, ea, ia3), F.IfHeader (st, (eb,ii)) -> + let (ib1, ib2, ib3) = tuple_of_list3 ii in + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + return ( + A.IfHeader (ia1, ia2, ea, ia3), + F.IfHeader (st, (eb,[ib1;ib2;ib3])) + ))))) + + | A.Else ia, F.Else ib -> + tokenf ia ib >>= (fun ia ib -> + return (A.Else ia, F.Else ib) + ) + + | A.WhileHeader (ia1, ia2, ea, ia3), F.WhileHeader (st, (eb, ii)) -> + let (ib1, ib2, ib3) = tuple_of_list3 ii in + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + return ( + A.WhileHeader (ia1, ia2, ea, ia3), + F.WhileHeader (st, (eb, [ib1;ib2;ib3])) + ))))) + + | A.DoHeader ia, F.DoHeader (st, ib) -> + tokenf ia ib >>= (fun ia ib -> + return ( + A.DoHeader ia, + F.DoHeader (st, ib) + )) + | A.WhileTail (ia1,ia2,ea,ia3,ia4), F.DoWhileTail (eb, ii) -> + let (ib1, ib2, ib3, ib4) = tuple_of_list4 ii in + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + tokenf ia4 ib4 >>= (fun ia4 ib4 -> + return ( + A.WhileTail (ia1,ia2,ea,ia3,ia4), + F.DoWhileTail (eb, [ib1;ib2;ib3;ib4]) + )))))) + | A.IteratorHeader (ia1, ia2, eas, ia3), F.MacroIterHeader (st, ((s,ebs),ii)) + -> + let (ib1, ib2, ib3) = tuple_of_list3 ii in + + ident DontKnow ia1 (s, ib1) >>= (fun ia1 (s, ib1) -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + arguments (seqstyle eas) (A.undots eas) ebs >>= (fun easundots ebs -> + let eas = redots eas easundots in + return ( + A.IteratorHeader (ia1, ia2, eas, ia3), + F.MacroIterHeader (st, ((s,ebs), [ib1;ib2;ib3])) + ))))) + + + + | A.ForHeader (ia1, ia2, ea1opt, ia3, ea2opt, ia4, ea3opt, ia5), + F.ForHeader (st, (((eb1opt,ib3s), (eb2opt,ib4s), (eb3opt,ib4vide)), ii)) + -> + assert (null ib4vide); + let (ib1, ib2, ib5) = tuple_of_list3 ii in + let ib3 = tuple_of_list1 ib3s in + let ib4 = tuple_of_list1 ib4s in + + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + tokenf ia4 ib4 >>= (fun ia4 ib4 -> + tokenf ia5 ib5 >>= (fun ia5 ib5 -> + option expression ea1opt eb1opt >>= (fun ea1opt eb1opt -> + option expression ea2opt eb2opt >>= (fun ea2opt eb2opt -> + option expression ea3opt eb3opt >>= (fun ea3opt eb3opt -> + return ( + A.ForHeader (ia1, ia2, ea1opt, ia3, ea2opt, ia4, ea3opt, ia5), + F.ForHeader (st, (((eb1opt,[ib3]), (eb2opt,[ib4]), (eb3opt,[])), + [ib1;ib2;ib5])) + + ))))))))) + + + | A.SwitchHeader(ia1,ia2,ea,ia3), F.SwitchHeader (st, (eb,ii)) -> + let (ib1, ib2, ib3) = tuple_of_list3 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + expression ea eb >>= (fun ea eb -> + return ( + A.SwitchHeader(ia1,ia2,ea,ia3), + F.SwitchHeader (st, (eb,[ib1;ib2;ib3])) + ))))) + + | A.Break (ia1, ia2), F.Break (st, ((),ii)) -> + let (ib1, ib2) = tuple_of_list2 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + A.Break (ia1, ia2), + F.Break (st, ((),[ib1;ib2])) + ))) + + | A.Continue (ia1, ia2), F.Continue (st, ((),ii)) -> + let (ib1, ib2) = tuple_of_list2 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + A.Continue (ia1, ia2), + F.Continue (st, ((),[ib1;ib2])) + ))) + + | A.Return (ia1, ia2), F.Return (st, ((),ii)) -> + let (ib1, ib2) = tuple_of_list2 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + return ( + A.Return (ia1, ia2), + F.Return (st, ((),[ib1;ib2])) + ))) + + | A.ReturnExpr (ia1, ea, ia2), F.ReturnExpr (st, (eb, ii)) -> + let (ib1, ib2) = tuple_of_list2 ii in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + expression ea eb >>= (fun ea eb -> + return ( + A.ReturnExpr (ia1, ea, ia2), + F.ReturnExpr (st, (eb, [ib1;ib2])) + )))) + + + + | A.Include(incla,filea), + F.Include {B.i_include = (fileb, ii); + B.i_rel_pos = h_rel_pos; + B.i_is_in_ifdef = inifdef; + B.i_content = copt; + } -> + assert (copt = None); + + let include_requirment = + match mcodekind incla, mcodekind filea with + | A.CONTEXT (_, A.BEFORE _), _ -> + IncludeMcodeBefore + | _, A.CONTEXT (_, A.AFTER _) -> + IncludeMcodeAfter + | _ -> + IncludeNothing + in + + let (inclb, iifileb) = tuple_of_list2 ii in + if inc_file (term filea, include_requirment) (fileb, h_rel_pos) + then + tokenf incla inclb >>= (fun incla inclb -> + tokenf filea iifileb >>= (fun filea iifileb -> + return ( + A.Include(incla, filea), + F.Include {B.i_include = (fileb, [inclb;iifileb]); + B.i_rel_pos = h_rel_pos; + B.i_is_in_ifdef = inifdef; + B.i_content = copt; + } + ))) + else fail + + + + | A.DefineHeader(definea,ida,params), F.DefineHeader ((idb, ii), defkind) -> + let (defineb, iidb, ieol) = tuple_of_list3 ii in + ident DontKnow ida (idb, iidb) >>= (fun ida (idb, iidb) -> + tokenf definea defineb >>= (fun definea defineb -> + (match A.unwrap params, defkind with + | A.NoParams, B.DefineVar -> + return ( + A.NoParams +> A.rewrap params, + B.DefineVar + ) + | A.DParams(lpa,eas,rpa), (B.DefineFunc (ebs, ii)) -> + let (lpb, rpb) = tuple_of_list2 ii in + tokenf lpa lpb >>= (fun lpa lpb -> + tokenf rpa rpb >>= (fun rpa rpb -> + + define_params (seqstyle eas) (A.undots eas) ebs >>= + (fun easundots ebs -> + let eas = redots eas easundots in + return ( + A.DParams (lpa,eas,rpa) +> A.rewrap params, + B.DefineFunc (ebs,[lpb;rpb]) + ) + ))) + | _ -> fail + ) >>= (fun params defkind -> + return ( + A.DefineHeader (definea, ida, params), + F.DefineHeader ((idb,[defineb;iidb;ieol]),defkind) + )) + )) + + + | A.Default(def,colon), F.Default (st, ((),ii)) -> + let (ib1, ib2) = tuple_of_list2 ii in + tokenf def ib1 >>= (fun def ib1 -> + tokenf colon ib2 >>= (fun colon ib2 -> + return ( + A.Default(def,colon), + F.Default (st, ((),[ib1;ib2])) + ))) + + + + | A.Case(case,ea,colon), F.Case (st, (eb,ii)) -> + let (ib1, ib2) = tuple_of_list2 ii in + tokenf case ib1 >>= (fun case ib1 -> + expression ea eb >>= (fun ea eb -> + tokenf colon ib2 >>= (fun colon ib2 -> + return ( + A.Case(case,ea,colon), + F.Case (st, (eb,[ib1;ib2])) + )))) + + (* only occurs in the predicates generated by asttomember *) + | A.DisjRuleElem eas, _ -> + (eas +> + List.fold_left (fun acc ea -> acc >|+|> (rule_elem_node ea node)) fail) + >>= (fun ea eb -> return (A.unwrap ea,F.unwrap eb)) + + | _, F.ExprStatement (_, (None, ii)) -> fail (* happen ? *) + + | A.Label(id,dd), F.Label (st,(s,ii)) -> + let (ib1,ib2) = tuple_of_list2 ii in + let (string_of_id,rebuild) = + match A.unwrap id with + A.Id(s) -> (s,function s -> A.rewrap id (A.Id(s))) + | _ -> failwith "labels with metavariables not supported" in + if (term string_of_id) =$= s + then + tokenf string_of_id ib1 >>= (fun string_of_id ib1 -> + tokenf dd ib2 >>= (fun dd ib2 -> + return ( + A.Label(rebuild string_of_id,dd), + F.Label (st,(s,[ib1;ib2])) + ))) + else fail + + | A.Goto(goto,id,sem), F.Goto (st,(s,ii)) -> + let (ib1,ib2,ib3) = tuple_of_list3 ii in + tokenf goto ib1 >>= (fun goto ib1 -> + ident DontKnow id (s, ib2) >>= (fun id (s, ib2) -> + tokenf sem ib3 >>= (fun sem ib3 -> + return( + A.Goto(goto,id,sem), + F.Goto (st,(s,[ib1;ib2;ib3])) + )))) + + (* have not a counter part in coccinelle, for the moment *) + (* todo?: print a warning at least ? *) + | _, F.CaseRange _ + | _, F.Asm _ + | _, F.MacroTop _ + -> fail2() + + | _, (F.IfdefEndif _|F.IfdefElse _|F.IfdefHeader _) + -> fail2 () + + | _, + (F.MacroStmt (_, _)| F.DefineDoWhileZeroHeader _| F.EndNode|F.TopNode) + -> fail + | _, + (F.Label (_, _)|F.Break (_, _)|F.Continue (_, _)|F.Default (_, _)| + F.Case (_, _)|F.Include _|F.Goto _|F.ExprStatement _| + F.DefineType _|F.DefineExpr _|F.DefineTodo| + F.DefineHeader (_, _)|F.ReturnExpr (_, _)|F.Return (_, _)|F.MacroIterHeader (_, _)| + F.SwitchHeader (_, _)|F.ForHeader (_, _)|F.DoWhileTail _|F.DoHeader (_, _)| + F.WhileHeader (_, _)|F.Else _|F.IfHeader (_, _)| + F.SeqEnd (_, _)|F.SeqStart (_, _, _)| + F.Decl _|F.FunHeader _) + -> fail + + + ) +end + diff --git a/engine/.#pattern_c.ml.1.3 b/engine/.#pattern_c.ml.1.3 new file mode 100644 index 0000000..142893f --- /dev/null +++ b/engine/.#pattern_c.ml.1.3 @@ -0,0 +1,494 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +open Common + +module Flag_engine = Flag_matcher +(*****************************************************************************) +(* The functor argument *) +(*****************************************************************************) + +(* info passed recursively in monad in addition to binding *) +type xinfo = { + optional_storage_iso : bool; + optional_qualifier_iso : bool; + value_format_iso : bool; +} + +module XMATCH = struct + + (* ------------------------------------------------------------------------*) + (* Combinators history *) + (* ------------------------------------------------------------------------*) + (* + * version0: + * type ('a, 'b) matcher = 'a -> 'b -> bool + * + * version1: same but with a global variable holding the current binding + * BUT bug + * - can have multiple possibilities + * - globals sux + * - sometimes have to undo, cos if start match, then it binds, + * and if later it does not match, then must undo the first binds. + * ex: when match parameters, can try to match, but then we found far + * later that the last argument of a function does not match + * => have to uando the binding !!! + * (can handle that too with a global, by saving the + * global, ... but sux) + * => better not use global + * + * version2: + * type ('a, 'b) matcher = binding -> 'a -> 'b -> binding list + * + * Empty list mean failure (let matchfailure = []). + * To be able to have pretty code, have to use partial application + * powa, and so the type is in fact + * + * version3: + * type ('a, 'b) matcher = 'a -> 'b -> binding -> binding list + * + * Then by defining the correct combinators, can have quite pretty code (that + * looks like the clean code of version0). + * + * opti: return a lazy list of possible matchs ? + * + * version4: type tin = Lib_engine.metavars_binding + *) + + (* ------------------------------------------------------------------------*) + (* Standard type and operators *) + (* ------------------------------------------------------------------------*) + + type tin = { + extra: xinfo; + binding: Lib_engine.metavars_binding; + binding0: Lib_engine.metavars_binding; (* inherited bindings *) + } + (* 'x is a ('a * 'b) but in fact dont care about 'b, we just tag the SP *) + (* opti? use set instead of list *) + type 'x tout = ('x * Lib_engine.metavars_binding) list + + type ('a, 'b) matcher = 'a -> 'b -> tin -> ('a * 'b) tout + + (* was >&&> *) + let (>>=) m1 m2 = fun tin -> + let xs = m1 tin in + let xxs = xs +> List.map (fun ((a,b), binding) -> + m2 a b {tin with binding = binding} + ) in + List.flatten xxs + + (* Je compare les bindings retournés par les differentes branches. + * Si la deuxieme branche amene a des bindings qui sont deja presents + * dans la premiere branche, alors je ne les accepte pas. + * + * update: still useful now that julia better handle Exp directly via + * ctl tricks using positions ? + *) + let (>|+|>) m1 m2 = fun tin -> +(* CHOICE + let xs = m1 tin in + if null xs + then m2 tin + else xs +*) + let res1 = m1 tin in + let res2 = m2 tin in + let list_bindings_already = List.map snd res1 in + res1 ++ + (res2 +> List.filter (fun (x, binding) -> + not + (list_bindings_already +> List.exists (fun already -> + Lib_engine.equal_binding binding already)) + )) + + + + + let (>||>) m1 m2 = fun tin -> +(* CHOICE + let xs = m1 tin in + if null xs + then m2 tin + else xs +*) + (* opti? use set instead of list *) + m1 tin ++ m2 tin + + + let return res = fun tin -> + [res, tin.binding] + + let fail = fun tin -> + [] + + let (>&&>) f m = fun tin -> + if f tin + then m tin + else fail tin + + + let mode = Cocci_vs_c.PatternMode + + (* ------------------------------------------------------------------------*) + (* Exp *) + (* ------------------------------------------------------------------------*) + let cocciExp = fun expf expa node -> fun tin -> + + let globals = ref [] in + let bigf = { + (* julia's style *) + Visitor_c.default_visitor_c with + Visitor_c.kexpr = (fun (k, bigf) expb -> + match expf expa expb tin with + | [] -> (* failed *) k expb + | xs -> + globals := xs @ !globals; + if not !Flag_engine.disallow_nested_exps then k expb (* CHOICE *) + ); + (* pad's style. + * push2 expr globals; k expr + * ... + * !globals +> List.fold_left (fun acc e -> acc >||> match_e_e expr e) + * (return false) + * + *) + } + in + Visitor_c.vk_node bigf node; + !globals +> List.map (fun ((a, _exp), binding) -> + (a, node), binding + ) + + (* same as cocciExp, but for expressions in an expression, not expressions + in a node *) + let cocciExpExp = fun expf expa expb -> fun tin -> + + let globals = ref [] in + let bigf = { + (* julia's style *) + Visitor_c.default_visitor_c with + Visitor_c.kexpr = (fun (k, bigf) expb -> + match expf expa expb tin with + | [] -> (* failed *) k expb + | xs -> + globals := xs @ !globals; + if not !Flag_engine.disallow_nested_exps then k expb (* CHOICE *) + ); + (* pad's style. + * push2 expr globals; k expr + * ... + * !globals +> List.fold_left (fun acc e -> acc >||> match_e_e expr e) + * (return false) + * + *) + } + in + Visitor_c.vk_expr bigf expb; + !globals +> List.map (fun ((a, _exp), binding) -> + (a, expb), binding + ) + + let cocciTy = fun expf expa node -> fun tin -> + + let globals = ref [] in + let bigf = { + Visitor_c.default_visitor_c with + Visitor_c.ktype = (fun (k, bigf) expb -> + match expf expa expb tin with + | [] -> (* failed *) k expb + | xs -> globals := xs @ !globals); + + } + in + Visitor_c.vk_node bigf node; + !globals +> List.map (fun ((a, _exp), binding) -> + (a, node), binding + ) + + let cocciInit = fun expf expa node -> fun tin -> + + let globals = ref [] in + let bigf = { + Visitor_c.default_visitor_c with + Visitor_c.kini = (fun (k, bigf) expb -> + match expf expa expb tin with + | [] -> (* failed *) k expb + | xs -> globals := xs @ !globals); + + } + in + Visitor_c.vk_node bigf node; + !globals +> List.map (fun ((a, _exp), binding) -> + (a, node), binding + ) + + + (* ------------------------------------------------------------------------*) + (* Distribute mcode *) + (* ------------------------------------------------------------------------*) + let tag_mck_pos mck posmck = + match mck with + | Ast_cocci.PLUS -> Ast_cocci.PLUS + | Ast_cocci.CONTEXT (pos, xs) -> + assert (pos = Ast_cocci.NoPos || pos = Ast_cocci.DontCarePos); + Ast_cocci.CONTEXT (posmck, xs) + | Ast_cocci.MINUS (pos, xs) -> + assert (pos = Ast_cocci.NoPos || pos = Ast_cocci.DontCarePos); + Ast_cocci.MINUS (posmck, xs) + + + let tag_mck_pos_mcode (x,info,mck,pos) posmck stuff = fun tin -> + [((x, info, tag_mck_pos mck posmck, pos),stuff), tin.binding] + + + let distrf (ii_of_x_f) = + fun mcode x -> fun tin -> + let (max, min) = Lib_parsing_c.max_min_by_pos (ii_of_x_f x) + in + let posmck = Ast_cocci.FixPos (min, max) (* subtil: and not max, min !!*) + in + tag_mck_pos_mcode mcode posmck x tin + + let distrf_e = distrf (Lib_parsing_c.ii_of_expr) + let distrf_args = distrf (Lib_parsing_c.ii_of_args) + let distrf_type = distrf (Lib_parsing_c.ii_of_type) + let distrf_param = distrf (Lib_parsing_c.ii_of_param) + let distrf_params = distrf (Lib_parsing_c.ii_of_params) + let distrf_ini = distrf (Lib_parsing_c.ii_of_ini) + let distrf_node = distrf (Lib_parsing_c.ii_of_node) + let distrf_struct_fields = distrf (Lib_parsing_c.ii_of_struct_fields) + let distrf_cst = distrf (Lib_parsing_c.ii_of_cst) + let distrf_define_params = distrf (Lib_parsing_c.ii_of_define_params) + + + (* ------------------------------------------------------------------------*) + (* Constraints on metavariable values *) + (* ------------------------------------------------------------------------*) + let check_constraints matcher constraints exp = fun f tin -> + let rec loop = function + [] -> f () tin (* success *) + | c::cs -> + match matcher c exp tin with + [] (* failure *) -> loop cs + | _ (* success *) -> fail tin in + loop constraints + + let check_pos_constraints constraints pvalu f tin = + check_constraints + (fun c exp tin -> + let success = [[]] in + let failure = [] in + (* relies on the fact that constraints on pos variables must refer to + inherited variables *) + (match Common.optionise (fun () -> tin.binding0 +> List.assoc c) with + Some valu' -> + if Cocci_vs_c.equal_metavarval exp valu' + then success else failure + | None -> + (* if the variable is not there, it puts no constraints *) + (* not sure this is still useful *) + failure)) + constraints pvalu f tin + + (* ------------------------------------------------------------------------*) + (* Environment *) + (* ------------------------------------------------------------------------*) + (* pre: if have declared a new metavar that hide another one, then + * must be passed with a binding that deleted this metavar + * + * Here we dont use the keep argument of julia. cf f(X,X), J'ai + * besoin de garder le X en interne, meme si julia s'en fout elle du + * X et qu'elle a mis X a DontSaved. + *) + let check_add_metavars_binding strip _keep inherited = fun (k, valu) tin -> + if inherited + then + match Common.optionise (fun () -> tin.binding0 +> List.assoc k) with + | Some (valu') -> + if Cocci_vs_c.equal_metavarval valu valu' + then Some tin.binding + else None + | None -> None + else + match Common.optionise (fun () -> tin.binding +> List.assoc k) with + | Some (valu') -> + if Cocci_vs_c.equal_metavarval valu valu' + then Some tin.binding + else None + + | None -> + let valu' = + match valu with + Ast_c.MetaIdVal a -> Ast_c.MetaIdVal a + | Ast_c.MetaFuncVal a -> Ast_c.MetaFuncVal a + | Ast_c.MetaLocalFuncVal a -> Ast_c.MetaLocalFuncVal a (*more?*) + | Ast_c.MetaExprVal a -> + Ast_c.MetaExprVal + (if strip + then Lib_parsing_c.al_expr a + else Lib_parsing_c.semi_al_expr a) + | Ast_c.MetaExprListVal a -> + Ast_c.MetaExprListVal + (if strip + then Lib_parsing_c.al_arguments a + else Lib_parsing_c.semi_al_arguments a) + + | Ast_c.MetaStmtVal a -> + Ast_c.MetaStmtVal + (if strip + then Lib_parsing_c.al_statement a + else Lib_parsing_c.semi_al_statement a) + | Ast_c.MetaTypeVal a -> + Ast_c.MetaTypeVal + (if strip + then Lib_parsing_c.al_type a + else Lib_parsing_c.semi_al_type a) + + | Ast_c.MetaListlenVal a -> Ast_c.MetaListlenVal a + + | Ast_c.MetaParamVal a -> failwith "not handling MetaParamVal" + | Ast_c.MetaParamListVal a -> + Ast_c.MetaParamListVal + (if strip + then Lib_parsing_c.al_params a + else Lib_parsing_c.semi_al_params a) + + | Ast_c.MetaPosVal (pos1,pos2) -> Ast_c.MetaPosVal (pos1,pos2) + | Ast_c.MetaPosValList l -> Ast_c.MetaPosValList l + in Some (tin.binding +> Common.insert_assoc (k, valu')) + + let envf keep inherited = fun (k, valu, get_max_min) f tin -> + let x = Ast_cocci.unwrap_mcode k in + match check_add_metavars_binding true keep inherited (x, valu) tin with + | Some binding -> + let new_tin = {tin with binding = binding} in + (match Ast_cocci.get_pos_var k with + Ast_cocci.MetaPos(name,constraints,per,keep,inherited) -> + let pvalu = + let (file,current_element,min,max) = get_max_min() in + Ast_c.MetaPosValList[(file,current_element,min,max)] in + (* check constraints. success means that there is a match with + one of the constraints, which will ultimately result in + failure. *) + check_pos_constraints constraints pvalu + (function () -> + (* constraints are satisfied, now see if we are compatible + with existing bindings *) + function new_tin -> + let x = Ast_cocci.unwrap_mcode name in + (match + check_add_metavars_binding false keep inherited (x, pvalu) + new_tin with + | Some binding -> + f () {new_tin with binding = binding} + | None -> fail tin)) + new_tin + | Ast_cocci.NoMetaPos -> f () new_tin) + | None -> fail tin + + (* ------------------------------------------------------------------------*) + (* Environment, allbounds *) + (* ------------------------------------------------------------------------*) + (* all referenced inherited variables have to be bound. This would + * be naturally checked for the minus or context ones in the + * matching process, but have to check the plus ones as well. The + * result of get_inherited contains all of these, but the potential + * redundant checking for the minus and context ones is probably not + * a big deal. If it's a problem, could fix free_vars to distinguish + * between + variables and the other ones. *) + + let (all_bound : Ast_cocci.meta_name list -> tin -> bool) = fun l tin -> + l +> List.for_all (fun inhvar -> + match Common.optionise (fun () -> tin.binding0 +> List.assoc inhvar) with + | Some _ -> true + | None -> false + ) + + let optional_storage_flag f = fun tin -> + f (tin.extra.optional_storage_iso) tin + + let optional_qualifier_flag f = fun tin -> + f (tin.extra.optional_qualifier_iso) tin + + let value_format_flag f = fun tin -> + f (tin.extra.value_format_iso) tin + + + (* ------------------------------------------------------------------------*) + (* Tokens *) + (* ------------------------------------------------------------------------*) + let tokenf ia ib = fun tin -> + let pos = Ast_c.info_to_fixpos ib in + let posmck = Ast_cocci.FixPos (pos, pos) in + let finish tin = tag_mck_pos_mcode ia posmck ib tin in + match Ast_cocci.get_pos_var ia with + Ast_cocci.MetaPos(name,constraints,per,keep,inherited) -> + let mpos = Lib_parsing_c.lin_col_by_pos [ib] in + let pvalu = Ast_c.MetaPosValList [mpos] in + check_pos_constraints constraints pvalu + (function () -> + (* constraints are satisfied, now see if we are compatible + with existing bindings *) + function new_tin -> + let x = Ast_cocci.unwrap_mcode name in + (match + check_add_metavars_binding false keep inherited (x, pvalu) tin + with + Some binding -> finish {tin with binding = binding} + | None -> fail tin)) + tin + | _ -> finish tin + + let tokenf_mck mck ib = fun tin -> + let pos = Ast_c.info_to_fixpos ib in + let posmck = Ast_cocci.FixPos (pos, pos) in + [(tag_mck_pos mck posmck, ib), tin.binding] + +end + +(*****************************************************************************) +(* Entry point *) +(*****************************************************************************) +module MATCH = Cocci_vs_c.COCCI_VS_C (XMATCH) + + +let match_re_node2 dropped_isos a b binding0 = + + let tin = { + XMATCH.extra = { + optional_storage_iso = not(List.mem "optional_storage" dropped_isos); + optional_qualifier_iso = not(List.mem "optional_qualifier" dropped_isos); + value_format_iso = not(List.mem "value_format" dropped_isos); + }; + XMATCH.binding = []; + XMATCH.binding0 = binding0; + } in + + MATCH.rule_elem_node a b tin + (* take only the tagged-SP, the 'a' *) + +> List.map (fun ((a,_b), binding) -> a, binding) + + +let match_re_node a b c d = + Common.profile_code "Pattern3.match_re_node" + (fun () -> match_re_node2 a b c d) diff --git a/engine/.#pretty_print_engine.ml.1.43 b/engine/.#pretty_print_engine.ml.1.43 new file mode 100644 index 0000000..03fafd2 --- /dev/null +++ b/engine/.#pretty_print_engine.ml.1.43 @@ -0,0 +1,161 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +open Common.Infix + +open Lib_engine + + +let pp = Common.pp + +let pp_meta (_,x) = pp x + +let rec pp_binding_kind = function + | Ast_c.MetaIdVal s -> pp ("id " ^ s) + | Ast_c.MetaFuncVal s -> pp ("func " ^ s) + | Ast_c.MetaLocalFuncVal s -> pp ("localfunc " ^ s) + | Ast_c.MetaExprVal expr -> + Pretty_print_c.pp_expression_simple expr + | Ast_c.MetaExprListVal expr_list -> pp "<>" + | Ast_c.MetaTypeVal typ -> + Pretty_print_c.pp_type_simple typ + | Ast_c.MetaStmtVal statement -> + Pretty_print_c.pp_statement_simple statement + | Ast_c.MetaParamVal params -> pp "<>" + | Ast_c.MetaParamListVal params -> pp "<>" + | Ast_c.MetaListlenVal n -> pp (string_of_int n) + | Ast_c.MetaPosVal (pos1, pos2) -> + let print_pos = function + Ast_cocci.Real x -> string_of_int x + | Ast_cocci.Virt(x,off) -> Printf.sprintf "%d+%d" x off in + pp (Common.sprintf ("pos(%s,%s)") (print_pos pos1) (print_pos pos2)) + | Ast_c.MetaPosValList l -> + pp (Common.sprintf ("poss[%s]") + (String.concat ", " + (List.map + (function (fl,ce,(minl,minc),(maxl,maxc)) -> + Printf.sprintf "(%s,%s,(%d,%d),(%d,%d))" + fl ce minl minc maxl maxc) + l))) + +and pp_binding subst = + begin + pp "["; + Common.print_between (fun () -> pp ";"; Format.print_cut() ) + (fun ((_,s), kind) -> pp s; pp " --> "; pp_binding_kind kind) + subst; + pp "]"; + end + + +let pp_binding_kind2 = function + | ParenVal s -> pp "pv("; pp_meta s; pp ")" + | NormalMetaVal x -> pp_binding_kind x + | LabelVal xs -> + begin + pp "labelval"; + pp "("; + Common.print_between (fun () -> pp ",") Format.print_int xs; + pp ")"; + end + | GoodVal -> pp "goodval" + | BadVal -> pp "badval" + + +let rec pp_predicate = function + | InLoop -> pp "InLoop" + | TrueBranch -> pp "TrueBranch" + | FalseBranch -> pp "FalseBranch" + | After -> pp "After" + | FallThrough -> pp "FallThrough" + | Return -> pp "Return" + | FunHeader -> pp "FunHeader" + | Top -> pp "Top" + | ErrorExit -> pp "ErrorExit" + | Exit -> pp "Exit" + | Goto -> pp "Goto" + | Paren s -> pp "Paren("; pp_meta s; pp ")" + | Match (re) -> Pretty_print_cocci.print_rule_elem re + | Label s -> pp "Label("; pp_meta s; pp ")" + | BCLabel s -> pp "BreakContinueLabel("; pp_meta s; pp ")" + | PrefixLabel s -> pp "PrefixLabel("; pp_meta s; pp ")" + | BindGood s -> pp "BindGood("; pp_meta s; pp ")" + | BindBad s -> pp "BindBad("; pp_meta s; pp ")" + | FakeBrace -> pp "FakeBrace" + +and pp_binding2 subst = + begin + pp "["; + Common.print_between (fun () -> pp ";";Format.print_cut(); ) + (fun (s, kind) -> pp s; pp " --> "; pp_binding_kind2 kind) + subst; + pp "]"; + end + +and pp_binding2_ctlsubst subst = + begin + pp "["; + Common.print_between (fun () -> pp ";"; Format.print_cut(); ) + (function + Ast_ctl.Subst (s, kind) -> + pp_meta s; pp " --> "; pp_binding_kind2 kind; + | Ast_ctl.NegSubst (s, kind) -> + pp_meta s; pp " -/-> "; pp_binding_kind2 kind; + ) + subst; + pp "]"; + end + +let predicate_to_string pred = + Common.format_to_string (function _ -> pp_predicate pred) + + +let pp_pred_smodif = fun (pred, smodif) -> + begin + pp_predicate pred; +(* + (match smodif with + | Ast_ctl.Modif x | Ast_ctl.UnModif x -> pp " with " + | Ast_ctl.Control -> () + ) +*) + end + + +let pp_ctlcocci show_plus inline_let_def ctl = + begin + if show_plus + then begin + Pretty_print_cocci.print_plus_flag := true; + Pretty_print_cocci.print_minus_flag := true; + end + else begin + Pretty_print_cocci.print_plus_flag := false; + Pretty_print_cocci.print_minus_flag := false; + end; + Common.pp_do_in_box (fun () -> + Pretty_print_ctl.pp_ctl (pp_pred_smodif,(fun s -> pp_meta s)) + inline_let_def ctl; + ); + end + + diff --git a/engine/cocci_vs_c.ml b/engine/cocci_vs_c.ml index 181e174..4b4bee4 100644 --- a/engine/cocci_vs_c.ml +++ b/engine/cocci_vs_c.ml @@ -260,6 +260,8 @@ let equal_metavarval valu valu' = | Ast_c.MetaStmtVal a, Ast_c.MetaStmtVal b -> Lib_parsing_c.al_statement a =*= Lib_parsing_c.al_statement b + | Ast_c.MetaInitVal a, Ast_c.MetaInitVal b -> + Lib_parsing_c.al_init a =*= Lib_parsing_c.al_init b | Ast_c.MetaTypeVal a, Ast_c.MetaTypeVal b -> (* old: Lib_parsing_c.al_type a =*= Lib_parsing_c.al_type b *) C_vs_c.eq_type a b @@ -285,7 +287,7 @@ let equal_metavarval valu valu' = l1 | (B.MetaPosValList _|B.MetaListlenVal _|B.MetaPosVal _|B.MetaStmtVal _ - |B.MetaTypeVal _ + |B.MetaTypeVal _ |B.MetaInitVal _ |B.MetaParamListVal _|B.MetaParamVal _|B.MetaExprListVal _ |B.MetaExprVal _|B.MetaLocalFuncVal _|B.MetaFuncVal _|B.MetaIdVal _ ), _ @@ -813,10 +815,10 @@ let rec (expression: (A.expression, Ast_c.expression) matcher) = * ... could match type. *) let (ib1, ib2) = tuple_of_list2 ii in - expression ea eb >>= (fun ea eb -> - tokenf ia1 ib1 >>= (fun ia1 ib1 -> - tokenf ia2 ib2 >>= (fun ia2 ib2 -> - arguments (seqstyle eas) (A.undots eas) ebs >>= (fun easundots ebs -> + expression ea eb >>= (fun ea eb -> + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + arguments (seqstyle eas) (A.undots eas) ebs >>= (fun easundots ebs -> let eas = redots eas easundots in return ( ((A.FunCall (ea, ia1, eas, ia2)) +> wa, @@ -1317,7 +1319,7 @@ and arguments_bis = fun eas ebs -> ) -and argument arga argb = +and argument arga argb = X.all_bound (A.get_inherited arga) >&&> match A.unwrap arga, argb with | A.TypeExp tya, Right (B.ArgType (((b, sopt, tyb), ii_b_s))) -> @@ -1335,8 +1337,8 @@ and argument arga argb = | A.TypeExp tya, _ -> fail | _, Right (B.ArgType (tyb, sto_iisto)) -> fail - | _, Left argb -> - expression arga argb >>= (fun arga argb -> + | _, Left argb -> + expression arga argb >>= (fun arga argb -> return (arga, Left argb) ) | _, Right (B.ArgAction y) -> fail @@ -1931,6 +1933,18 @@ and (initialiser: (A.initialiser, Ast_c.initialiser) matcher) = fun ia ib -> X.all_bound (A.get_inherited ia) >&&> match (A.unwrap ia,ib) with + | (A.MetaInit(ida,keep,inherited), ib) -> + let max_min _ = + Lib_parsing_c.lin_col_by_pos (Lib_parsing_c.ii_of_ini ib) in + X.envf keep inherited (ida, Ast_c.MetaInitVal ib, max_min) + (fun () -> + X.distrf_ini ida ib >>= (fun ida ib -> + return ( + A.MetaInit (ida,keep,inherited) +> A.rewrap ia, + ib + )) + ) + | (A.InitExpr expa, ib) -> (match A.unwrap expa, ib with | A.Edots (mcode, None), ib -> @@ -1972,57 +1986,19 @@ and (initialiser: (A.initialiser, Ast_c.initialiser) matcher) = fun ia ib -> failwith "TODO: not handling whencode in initialisers" - | (A.InitGccDotName (ia1, ida, ia2, inia), - (B.InitDesignators ([B.DesignatorField idb,ii1], inib), ii2))-> + | (A.InitGccExt (designatorsa, ia2, inia), + (B.InitDesignators (designatorsb, inib), ii2))-> - let (iidot, iidb) = tuple_of_list2 ii1 in let iieq = tuple_of_list1 ii2 in - tokenf ia1 iidot >>= (fun ia1 iidot -> tokenf ia2 iieq >>= (fun ia2 iieq -> - ident DontKnow ida (idb, iidb) >>= (fun ida (idb, iidb) -> - initialiser inia inib >>= (fun inia inib -> - return ( - (A.InitGccDotName (ia1, ida, ia2, inia)) +> A.rewrap ia, - (B.InitDesignators - ([B.DesignatorField idb, [iidot;iidb]], inib), [iieq]) - ))))) - - - | (A.InitGccIndex (ia1,ea,ia2,ia3,inia), - (B.InitDesignators ([B.DesignatorIndex eb, ii1], inib), ii2)) -> - - let (ib1, ib2) = tuple_of_list2 ii1 in - let ib3 = tuple_of_list1 ii2 in - tokenf ia1 ib1 >>= (fun ia1 ib1 -> - tokenf ia2 ib2 >>= (fun ia2 ib2 -> - tokenf ia3 ib3 >>= (fun ia3 ib3 -> - expression ea eb >>= (fun ea eb -> - initialiser inia inib >>= (fun inia inib -> - return ( - (A.InitGccIndex (ia1,ea,ia2,ia3,inia)) +> A.rewrap ia, - (B.InitDesignators - ([B.DesignatorIndex eb, [ib1;ib2]], inib), [ib3]) - )))))) - - - | (A.InitGccRange (ia1,e1a,ia2,e2a,ia3,ia4,inia), - (B.InitDesignators ([B.DesignatorRange (e1b, e2b), ii1], inib), ii2)) -> - - let (ib1, ib2, ib3) = tuple_of_list3 ii1 in - let (ib4) = tuple_of_list1 ii2 in - tokenf ia1 ib1 >>= (fun ia1 ib1 -> - tokenf ia2 ib2 >>= (fun ia2 ib2 -> - tokenf ia3 ib3 >>= (fun ia3 ib3 -> - tokenf ia4 ib4 >>= (fun ia4 ib4 -> - expression e1a e1b >>= (fun e1a e1b -> - expression e2a e2b >>= (fun e2a e2b -> + designators designatorsa designatorsb >>= + (fun designatorsa designatorsb -> initialiser inia inib >>= (fun inia inib -> return ( - (A.InitGccRange (ia1,e1a,ia2,e2a,ia3,ia4,inia)) +> A.rewrap ia, - (B.InitDesignators - ([B.DesignatorRange (e1b, e2b),[ib1;ib2;ib3]], inib), [ib4]) - )))))))) + (A.InitGccExt (designatorsa, ia2, inia)) +> A.rewrap ia, + (B.InitDesignators (designatorsb, inib), [iieq]) + )))) @@ -2054,9 +2030,53 @@ and (initialiser: (A.initialiser, Ast_c.initialiser) matcher) = fun ia ib -> | _, ((B.InitDesignators (_, _)|B.InitList _|B.InitExpr _), _) -> fail +and designators dla dlb = + match (dla,dlb) with + ([],[]) -> return ([], []) + | ([],_) | (_,[]) -> fail + | (da::dla,db::dlb) -> + designator da db >>= (fun da db -> + designators dla dlb >>= (fun dla dlb -> + return (da::dla, db::dlb))) +and designator da db = + match (da,db) with + (A.DesignatorField (ia1, ida), (B.DesignatorField idb,ii1)) -> + + let (iidot, iidb) = tuple_of_list2 ii1 in + tokenf ia1 iidot >>= (fun ia1 iidot -> + ident DontKnow ida (idb, iidb) >>= (fun ida (idb, iidb) -> + return ( + A.DesignatorField (ia1, ida), + (B.DesignatorField idb, [iidot;iidb]) + ))) + + | (A.DesignatorIndex (ia1,ea,ia2), (B.DesignatorIndex eb, ii1)) -> + + let (ib1, ib2) = tuple_of_list2 ii1 in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + expression ea eb >>= (fun ea eb -> + return ( + A.DesignatorIndex (ia1,ea,ia2), + (B.DesignatorIndex eb, [ib1;ib2]) + )))) + | (A.DesignatorRange (ia1,e1a,ia2,e2a,ia3), + (B.DesignatorRange (e1b, e2b), ii1)) -> + let (ib1, ib2, ib3) = tuple_of_list3 ii1 in + tokenf ia1 ib1 >>= (fun ia1 ib1 -> + tokenf ia2 ib2 >>= (fun ia2 ib2 -> + tokenf ia3 ib3 >>= (fun ia3 ib3 -> + expression e1a e1b >>= (fun e1a e1b -> + expression e2a e2b >>= (fun e2a e2b -> + return ( + A.DesignatorRange (ia1,e1a,ia2,e2a,ia3), + (B.DesignatorRange (e1b, e2b), [ib1;ib2;ib3]) + )))))) + | (_, ((B.DesignatorField _|B.DesignatorIndex _|B.DesignatorRange _), _)) -> + fail and initialisers = fun ias (ibs, iicomma) -> diff --git a/engine/pattern_c.ml b/engine/pattern_c.ml index 142893f..445c8d6 100644 --- a/engine/pattern_c.ml +++ b/engine/pattern_c.ml @@ -364,6 +364,12 @@ module XMATCH = struct then Lib_parsing_c.al_type a else Lib_parsing_c.semi_al_type a) + | Ast_c.MetaInitVal a -> + Ast_c.MetaInitVal + (if strip + then Lib_parsing_c.al_init a + else Lib_parsing_c.semi_al_init a) + | Ast_c.MetaListlenVal a -> Ast_c.MetaListlenVal a | Ast_c.MetaParamVal a -> failwith "not handling MetaParamVal" diff --git a/engine/pretty_print_engine.ml b/engine/pretty_print_engine.ml index 03fafd2..d405cb3 100644 --- a/engine/pretty_print_engine.ml +++ b/engine/pretty_print_engine.ml @@ -36,6 +36,8 @@ let rec pp_binding_kind = function | Ast_c.MetaExprVal expr -> Pretty_print_c.pp_expression_simple expr | Ast_c.MetaExprListVal expr_list -> pp "<>" + | Ast_c.MetaInitVal ini -> + Pretty_print_c.pp_init_simple ini | Ast_c.MetaTypeVal typ -> Pretty_print_c.pp_type_simple typ | Ast_c.MetaStmtVal statement -> diff --git a/globals/config.ml b/globals/config.ml index 755de16..48a98ce 100644 --- a/globals/config.ml +++ b/globals/config.ml @@ -1,4 +1,4 @@ -let version = "0.1.4" +let version = "0.1.5" let path = try (Sys.getenv "COCCINELLE_HOME") diff --git a/main.ml b/main.ml index 393cc31..992b6ae 100644 --- a/main.ml +++ b/main.ml @@ -239,7 +239,7 @@ let short_options = [ " guess what"; "-date", Arg.Unit (fun () -> - pr2 "version: $Date: 2009/01/02 10:28:28 $"; + pr2 "version: $Date: 2009/02/03 17:17:04 $"; raise (Common.UnixExit 0) ), " guess what"; @@ -590,8 +590,16 @@ let glimpse_filter (coccifile, isofile) dir = (*****************************************************************************) let main () = begin + let arglist = Array.to_list Sys.argv in + + if not (null (Common.inter_set arglist + ["-cocci_file";"-sp_file";"-test";"-testall"; + "-test_okfailed";"-test_regression_okfailed"])) + then run_profile quiet_profile; + let args = ref [] in + (* this call can set up many global flag variables via the cmd line *) arg_parse2 (Arg.align all_options) (fun x -> args := x::!args) usage_msg; (if !dir && List.length !args > 1 @@ -648,7 +656,7 @@ let main () = (* Actions, useful to debug subpart of coccinelle *) (* --------------------------------------------------------- *) - | xs when List.mem !action (Common.action_list all_actions) -> + | xs when List.mem !action (Common.action_list all_actions) -> Common.do_action !action xs all_actions | [file] when !action = "-parse_cocci" -> @@ -667,6 +675,7 @@ let main () = (* This is the main entry *) (* --------------------------------------------------------- *) | x::xs -> + adjust_stdin x (fun () -> if !cocci_file = "" then failwith "I need a cocci file, use -sp_file "; @@ -833,7 +842,6 @@ let main () = (*****************************************************************************) let _ = Common.main_boilerplate (fun () -> - run_profile quiet_profile; main (); Ctlcocci_integration.print_bench(); ) diff --git a/parsing_c/ast_c.ml b/parsing_c/ast_c.ml index bd90312..0c4e864 100644 --- a/parsing_c/ast_c.ml +++ b/parsing_c/ast_c.ml @@ -626,6 +626,7 @@ and metavars_binding = (Ast_cocci.meta_name, metavar_binding_kind) assoc | MetaParamListVal of parameterType wrap2 list | MetaTypeVal of fullType + | MetaInitVal of initialiser | MetaStmtVal of statement (* Could also be in Lib_engine.metavars_binding2 with the ParenVal, @@ -744,6 +745,7 @@ let noi_content = (None: ((Common.filename * program) option)) (*****************************************************************************) let unwrap = fst +let unwrap2 = fst let unwrap_expr ((unwrap_e, typ), iie) = unwrap_e let rewrap_expr ((_old_unwrap_e, typ), iie) newe = ((newe, typ), iie) @@ -1015,3 +1017,7 @@ let s_of_attr attr = +> List.map (fun (Attribute s, ii) -> s) +> Common.join "," + +let type_of_parameter param = + let ((b, sopt, typ), ii) = param in + typ diff --git a/parsing_c/cpp_ast_c.mli b/parsing_c/cpp_ast_c.mli index 713bd5e..838e191 100644 --- a/parsing_c/cpp_ast_c.mli +++ b/parsing_c/cpp_ast_c.mli @@ -9,11 +9,12 @@ val show_cpp_d_opts: string list -> unit (* ---------------------------------------------------------------------- *) -(* cpp_expand_include below internally use cache of header file to - * speedup as reinclude very often the same basic header file. But that - * means that the asts of those headers are then shared so take +(* cpp_expand_include below must internally use a cache of header files to + * speedup as programs very often reinclude the same basic set of + * header files. + * note: that also means that the asts of those headers are then shared so take * care. -*) + *) val _headers_hash: (Common.filename, Parse_c.program2 * Parsing_stat.parsing_stat) Hashtbl.t val threshold_cache_nb_files: int ref diff --git a/parsing_c/lib_parsing_c.ml b/parsing_c/lib_parsing_c.ml index bddf492..9e81a6d 100644 --- a/parsing_c/lib_parsing_c.ml +++ b/parsing_c/lib_parsing_c.ml @@ -50,6 +50,7 @@ let strip_info_visitor _ = let al_expr x = Visitor_c.vk_expr_s (strip_info_visitor()) x let al_statement x = Visitor_c.vk_statement_s (strip_info_visitor()) x let al_type x = Visitor_c.vk_type_s (strip_info_visitor()) x +let al_init x = Visitor_c.vk_ini_s (strip_info_visitor()) x let al_param x = Visitor_c.vk_param_s (strip_info_visitor()) x let al_params x = Visitor_c.vk_params_s (strip_info_visitor()) x let al_arguments x = Visitor_c.vk_arguments_s (strip_info_visitor()) x @@ -79,6 +80,7 @@ let semi_strip_info_visitor = (* keep position information *) let semi_al_expr = Visitor_c.vk_expr_s semi_strip_info_visitor let semi_al_statement = Visitor_c.vk_statement_s semi_strip_info_visitor let semi_al_type = Visitor_c.vk_type_s semi_strip_info_visitor +let semi_al_init = Visitor_c.vk_ini_s semi_strip_info_visitor let semi_al_param = Visitor_c.vk_param_s semi_strip_info_visitor let semi_al_params = Visitor_c.vk_params_s semi_strip_info_visitor let semi_al_arguments = Visitor_c.vk_arguments_s semi_strip_info_visitor diff --git a/parsing_c/parse_c.ml b/parsing_c/parse_c.ml index c00b746..a290261 100644 --- a/parsing_c/parse_c.ml +++ b/parsing_c/parse_c.ml @@ -353,6 +353,12 @@ let expression_of_string = parse_gen Parser_c.expr (* Consistency checking *) (*****************************************************************************) +(* todo: + * could check that an ident has always the same class, be it a typedef + * (but sometimes do 'acpi_val acpi_val;'), an ident, a TMacroStatement, + * etc. + *) + type class_ident = | CIdent (* can be var, func, field, tag, enum constant *) | CTypedef @@ -844,9 +850,13 @@ let rec lexer_function ~pass tr = fun lexbuf -> assert (x = v); (match v with - (* fix_define1. Why not in parsing_hacks lookahead and do passing like + + (* fix_define1. + * + * Why not in parsing_hacks lookahead and do passing like * I do for some ifdef directives ? Because here I also need to - * generate some tokens sometimes. + * generate some tokens sometimes and so I need access to the + * tr.passed, tr.rest, etc. *) | Parser_c.TDefine (tok) -> if not (LP.current_context () = LP.InTopLevel) && diff --git a/parsing_c/parser_c.mly b/parsing_c/parser_c.mly index 4ab8457..b586513 100644 --- a/parsing_c/parser_c.mly +++ b/parsing_c/parser_c.mly @@ -1274,7 +1274,7 @@ initialize2: -/*(* they can be nested, can have a .x.[3].y *)*/ +/*(* they can be nested, can have a .x[3].y *)*/ designator: | TDot ident { DesignatorField (fst $2), [$1;snd $2] } diff --git a/parsing_c/parsing_hacks.ml b/parsing_c/parsing_hacks.ml index b69da55..4c2c111 100644 --- a/parsing_c/parsing_hacks.ml +++ b/parsing_c/parsing_hacks.ml @@ -27,6 +27,10 @@ let pr2 s = if !Flag_parsing_c.verbose_parsing then Common.pr2 s +let pr2_once s = + if !Flag_parsing_c.verbose_parsing + then Common.pr2_once s + let pr2_cpp s = if !Flag_parsing_c.debug_cpp then Common.pr2_once ("CPP-" ^ s) @@ -89,7 +93,8 @@ let msg_typedef s = let msg_maybe_dangereous_typedef s = if not (is_known_typdef s) then - pr2 ("PB MAYBE: dangerous typedef inference, maybe not a typedef: " ^ s) + pr2 + ("PB MAYBE: dangerous typedef inference, maybe not a typedef: " ^ s) @@ -1131,15 +1136,21 @@ let rec apply_macro_defs xs = id.tok <- token_from_parsinghack_hint (s,i1) hint; ) | Params params -> - if List.length params != List.length xxs - then begin - pr2 ("WIERD: macro with wrong number of arguments: " ^ s); - (* old: id.new_tokens_before <- bodymacro; *) - () - end - else - (match body with - | DefineBody bodymacro -> + (match body with + | 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 ("WIERD: macro with wrong number of arguments: " ^ s); + (* old: id.new_tokens_before <- bodymacro; *) + () + 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 @@ -1160,11 +1171,33 @@ let rec apply_macro_defs xs = (* important to do that after have apply the macro, otherwise * will pass as argument to the macro some tokens that * are all TCommentCpp + * + * note: such macrostatement can have a variable number of + * arguments but here we don't care, we just pass all the + * parameters. *) - msg_apply_known_macro_hint s; - id.tok <- token_from_parsinghack_hint (s,i1) hint; - [Parenthised (xxs, info_parens)] +> - iter_token_paren (set_as_comment Ast_c.CppMacro); + + (match xs with + | PToken ({tok = TPtVirg _} as id2)::_ -> + pr2_once + ("macro stmt with trailing ';', passing also ';' for: "^ + s); + (* sometimes still want pass its params ... as in + * DEBUGPOLL(static unsigned int prev_mask = 0); + *) + + msg_apply_known_macro_hint s; + id.tok <- token_from_parsinghack_hint (s,i1) hint; + [Parenthised (xxs, info_parens)] +> + iter_token_paren (set_as_comment Ast_c.CppMacro); + set_as_comment Ast_c.CppMacro id2; + + | _ -> + msg_apply_known_macro_hint s; + id.tok <- token_from_parsinghack_hint (s,i1) hint; + [Parenthised (xxs, info_parens)] +> + iter_token_paren (set_as_comment Ast_c.CppMacro); + ) | DefineHint hint -> @@ -1566,11 +1599,16 @@ let rec find_macro_lineparen xs = ) || (col2 <= col1 && - (match other.tok with - | TCBrace _ when ctx = InFunction -> true - | Treturn _ -> true - | Tif _ -> true - | Telse _ -> true + (match other.tok, restline2 with + | TCBrace _, _ when ctx = InFunction -> true + | Treturn _, _ -> true + | Tif _, _ -> true + | Telse _, _ -> true + + (* case of label, usually put in first line *) + | TIdent _, (PToken ({tok = TDotDot _}))::_ -> + true + | _ -> false ) @@ -1594,6 +1632,8 @@ let rec find_macro_lineparen xs = * ex: LOCK * foo(); * UNLOCK + * + * todo: factorize code with previous rule ? *) | (Line ([PToken ({tok = TIdent (s,ii); col = col1; where = ctx} as macro); @@ -2511,6 +2551,15 @@ let lookahead2 ~pass next before = end else x + | (TCppDirectiveOther (ii) as x)::_, _ + -> + if (pass = 2) + then begin + pr2_once ("CPP-OTHER: I treat it as comment"); + TCommentCpp (Ast_c.CppDirective, ii) + end + else x + (* If ident contain a for_each, then certainly a macro. But to be * sure should look if there is a '{' after the ')', but it requires * to count the '('. Because this can be expensive, we do that only diff --git a/parsing_c/parsing_stat.ml b/parsing_c/parsing_stat.ml index c7224ca..e365cff 100644 --- a/parsing_c/parsing_stat.ml +++ b/parsing_c/parsing_stat.ml @@ -104,11 +104,11 @@ let print_parsing_stat_list ?(verbose=false) = fun statxs -> let passedf = float_of_int passed in pr ( (sprintf "nb good = %d, nb passed = %d " good passed) ^ - (sprintf "=========> %f" (100.0 *. (passedf /. gf)) ^ "%") + (sprintf "=========> %f" (100.0 *. (passedf /. gf)) ^ "% passed") ); pr ( (sprintf "nb good = %d, nb bad = %d " good bad) ^ - (sprintf "=========> %f" (100.0 *. (gf /. (gf +. badf))) ^ "%" + (sprintf "=========> %f" (100.0 *. (gf /. (gf +. badf))) ^ "% good" ) ) @@ -124,7 +124,7 @@ let lines_around_error_line ~context (file, line) = let endl = min (Array.length arr) (line + context) in let res = ref [] in - for i = startl to endl do + for i = startl to endl -1 do Common.push2 arr.(i) res done; List.rev !res diff --git a/parsing_c/pretty_print_c.ml b/parsing_c/pretty_print_c.ml dissimilarity index 69% index 40607a2..f6cd8d6 100644 --- a/parsing_c/pretty_print_c.ml +++ b/parsing_c/pretty_print_c.ml @@ -1,1266 +1,1281 @@ -(* Copyright (C) 2006, 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 - -open Ast_c - -type pr_elem_func = Ast_c.info -> unit -type pr_space_func = unit -> unit - -module F = Control_flow_c - -(*****************************************************************************) - -(* This module is used by unparse_c, but because unparse_c have also - * the list of tokens, pretty_print_c could be useless in the futur - * (except that the ast_c have some fake tokens not present in the list - * of tokens so it's still useful). But this module is also useful to - * unparse C when you don't have the ordered list of tokens separately, - * or tokens without position information, for instance when you want - * to pretty print some piece of C that was generated, or some - * abstract-lined piece of code, etc. *) - -let rec pp_expression_gen pr_elem pr_space = - (* subtil: dont try to shorten the def of pp_statement by omitting e, - otherwise get infinite funcall and huge memory consumption *) - let _pp_statement e = pp_statement_gen pr_elem pr_space e in - - let rec pp_expression = fun ((exp, typ), ii) -> - (match exp, ii with - | Ident (c), [i] -> pr_elem i - (* only a MultiString can have multiple ii *) - | Constant (MultiString), is -> is +> List.iter pr_elem - | Constant (c), [i] -> pr_elem i - | FunCall (e, es), [i1;i2] -> - pp_expression e; pr_elem i1; - pp_arg_list_gen pr_elem pr_space es; - pr_elem i2; - - | CondExpr (e1, e2, e3), [i1;i2] -> - pp_expression e1; pr_space(); pr_elem i1; pr_space(); - do_option (function x -> pp_expression x; pr_space()) e2; pr_elem i2; - pp_expression e3 - | Sequence (e1, e2), [i] -> - pp_expression e1; pr_elem i; pr_space(); pp_expression e2 - | Assignment (e1, op, e2), [i] -> - pp_expression e1; pr_space(); pr_elem i; pr_space(); pp_expression e2 - - | Postfix (e, op), [i] -> pp_expression e; pr_elem i; - | Infix (e, op), [i] -> pr_elem i; pp_expression e; - | Unary (e, op), [i] -> pr_elem i; pp_expression e - | Binary (e1, op, e2), [i] -> - pp_expression e1; pr_space(); pr_elem i; pr_space(); pp_expression e2 - - | ArrayAccess (e1, e2), [i1;i2] -> - pp_expression e1; pr_elem i1; pp_expression e2; pr_elem i2 - | RecordAccess (e, s), [i1;i2] -> - pp_expression e; pr_elem i1; pr_elem i2 - | RecordPtAccess (e, s), [i1;i2] -> - pp_expression e; pr_elem i1; pr_elem i2 - - | SizeOfExpr (e), [i] -> pr_elem i; pp_expression e - | SizeOfType (t), [i1;i2;i3] -> - pr_elem i1; pr_elem i2; pp_type_gen pr_elem pr_space t; - pr_elem i3 - | Cast (t, e), [i1;i2] -> - pr_elem i1; pp_type_gen pr_elem pr_space t; pr_elem i2; - pp_expression e - - | StatementExpr (statxs, [ii1;ii2]), [i1;i2] -> - pr_elem i1; - pr_elem ii1; - statxs +> List.iter (pp_statement_seq_gen pr_elem pr_space); - pr_elem ii2; - pr_elem i2; - | Constructor (t, xs), lp::rp::i1::i2::iicommaopt -> - pr_elem lp; - pp_type_gen pr_elem pr_space t; - pr_elem rp; - pr_elem i1; - xs +> List.iter (fun (x, ii) -> - assert (List.length ii <= 1); - ii +> List.iter (function x -> pr_elem x; pr_space()); - pp_init_gen pr_elem pr_space x - ); - iicommaopt +> List.iter pr_elem; - pr_elem i2; - - - - | ParenExpr (e), [i1;i2] -> pr_elem i1; pp_expression e; pr_elem i2; - - | (Ident (_) | Constant _ | FunCall (_,_) | CondExpr (_,_,_) - | Sequence (_,_) - | Assignment (_,_,_) - | Postfix (_,_) | Infix (_,_) | Unary (_,_) | Binary (_,_,_) - | ArrayAccess (_,_) | RecordAccess (_,_) | RecordPtAccess (_,_) - | SizeOfExpr (_) | SizeOfType (_) | Cast (_,_) - | StatementExpr (_) | Constructor _ - | ParenExpr (_) - ),_ -> raise Impossible - ); - - if !Flag_parsing_c.pretty_print_type_info - then begin - pr_elem (Ast_c.fakeInfo() +> Ast_c.rewrap_str "/*"); - !typ +> - (fun (ty,_test) -> ty +> - Common.do_option - (fun (x,l) -> pp_type_gen pr_elem pr_space x; - let s = match l with - Ast_c.LocalVar _ -> ", local" - | _ -> "" in - pr_elem (Ast_c.fakeInfo() +> Ast_c.rewrap_str s))); - pr_elem (Ast_c.fakeInfo() +> Ast_c.rewrap_str "*/"); - end - - in - pp_expression - -and pp_arg_list_gen pr_elem pr_space es = - es +> List.iter (fun (e, opt) -> - assert (List.length opt <= 1); (* opt must be a comma? *) - opt +> List.iter (function x -> pr_elem x; pr_space()); - pp_argument_gen pr_elem pr_space e) - -and pp_argument_gen pr_elem pr_space argument = - let rec pp_action = function - | (ActMisc ii) -> ii +> List.iter pr_elem - in - match argument with - | Left e -> pp_expression_gen pr_elem pr_space e - | Right wierd -> - (match wierd with - | ArgType param -> pp_param_gen pr_elem pr_space param - | ArgAction action -> pp_action action - ) - - - - - -(* ---------------------- *) -and pp_statement_gen pr_elem pr_space = - let pp_expression e = pp_expression_gen pr_elem pr_space e in - let rec pp_statement = function - | Labeled (Label (s, st)), [i1;i2] -> - pr_elem i1; pr_elem i2; pp_statement st - | Labeled (Case (e, st)), [i1;i2] -> - pr_elem i1; pp_expression e; pr_elem i2; pp_statement st - | Labeled (CaseRange (e, e2, st)), [i1;i2;i3] -> - pr_elem i1; pp_expression e; pr_elem i2; pp_expression e2; pr_elem i3; - pp_statement st - | Labeled (Default st), [i1;i2] -> pr_elem i1; pr_elem i2; pp_statement st - | Compound statxs, [i1;i2] -> - pr_elem i1; - statxs +> List.iter (pp_statement_seq_gen pr_elem pr_space); - pr_elem i2; - - | ExprStatement (None), [i] -> pr_elem i; - | ExprStatement (None), [] -> () - | ExprStatement (Some e), [i] -> pp_expression e; pr_elem i - (* the last ExprStatement of a for does not have a trailing - ';' hence the [] for ii *) - | ExprStatement (Some e), [] -> pp_expression e; - | Selection (If (e, st1, st2)), i1::i2::i3::is -> - pr_elem i1; pr_elem i2; pp_expression e; pr_elem i3; pp_statement st1; - (match (st2, is) with - | ((ExprStatement None, []), []) -> () - | ((ExprStatement None, []), [iifakend]) -> pr_elem iifakend - | st2, [i4;iifakend] -> pr_elem i4; pp_statement st2; pr_elem iifakend - | x -> raise Impossible - ) - | Selection (Switch (e, st)), [i1;i2;i3;iifakend] -> - pr_elem i1; pr_elem i2; pp_expression e; pr_elem i3; pp_statement st; - pr_elem iifakend - | Iteration (While (e, st)), [i1;i2;i3;iifakend] -> - pr_elem i1; pr_elem i2; pp_expression e; pr_elem i3; pp_statement st; - pr_elem iifakend - | Iteration (DoWhile (st, e)), [i1;i2;i3;i4;i5;iifakend] -> - pr_elem i1; pp_statement st; pr_elem i2; pr_elem i3; pp_expression e; - pr_elem i4; pr_elem i5; - pr_elem iifakend - - - | Iteration (For ((e1opt,il1),(e2opt,il2),(e3opt, il3),st)), - [i1;i2;i3;iifakend] -> - - pr_elem i1; - pr_elem i2; - pp_statement (ExprStatement e1opt, il1); - pp_statement (ExprStatement e2opt, il2); - assert (null il3); - pp_statement (ExprStatement e3opt, il3); - pr_elem i3; - pp_statement st; - pr_elem iifakend - - | Iteration (MacroIteration (s,es,st)), [i1;i2;i3;iifakend] -> - pr_elem i1; - pr_elem i2; - - es +> List.iter (fun (e, opt) -> - assert (List.length opt <= 1); - opt +> List.iter pr_elem; - pp_argument_gen pr_elem pr_space e; - ); - - pr_elem i3; - pp_statement st; - pr_elem iifakend - - | Jump (Goto s), [i1;i2;i3] -> - pr_elem i1; pr_space(); pr_elem i2; pr_elem i3; - | Jump ((Continue|Break|Return)), [i1;i2] -> pr_elem i1; pr_elem i2; - | Jump (ReturnExpr e), [i1;i2] -> - pr_elem i1; pr_space(); pp_expression e; pr_elem i2 - | Jump (GotoComputed e), [i1;i2;i3] -> - pr_elem i1; pr_elem i2; pp_expression e; pr_elem i3 - - | Decl decl, [] -> pp_decl_gen pr_elem pr_space decl - | Asm asmbody, ii -> - (match ii with - | [iasm;iopar;icpar;iptvirg] -> - pr_elem iasm; pr_elem iopar; - pp_asmbody_gen pr_elem pr_space asmbody; - pr_elem icpar; pr_elem iptvirg - | [iasm;ivolatile;iopar;icpar;iptvirg] -> - pr_elem iasm; pr_elem ivolatile; pr_elem iopar; - pp_asmbody_gen pr_elem pr_space asmbody; - pr_elem icpar; pr_elem iptvirg - | _ -> raise Impossible - ) - - | NestedFunc def, ii -> - assert (null ii); - pp_def_gen pr_elem pr_space def - | MacroStmt, ii -> - ii +> List.iter pr_elem ; - - | ( Labeled (Label (_,_)) | Labeled (Case (_,_)) - | Labeled (CaseRange (_,_,_)) | Labeled (Default _) - | Compound _ | ExprStatement _ - | Selection (If (_, _, _)) | Selection (Switch (_, _)) - | Iteration (While (_, _)) | Iteration (DoWhile (_, _)) - | Iteration (For ((_,_), (_,_), (_, _), _)) - | Iteration (MacroIteration (_,_,_)) - | Jump (Goto _) | Jump ((Continue|Break|Return)) | Jump (ReturnExpr _) - | Jump (GotoComputed _) - | Decl _ - ), _ -> raise Impossible - - in - pp_statement - -and pp_statement_seq_gen pr_elem pr_space stseq = - match stseq with - | StmtElem st -> - pp_statement_gen pr_elem pr_space st - | IfdefStmt ifdef -> pp_ifdef_gen pr_elem pr_space ifdef - | CppDirectiveStmt cpp -> pp_directive_gen pr_elem pr_space cpp - | IfdefStmt2 (ifdef, xxs) -> - pp_ifdef_tree_sequence pr_elem pr_space ifdef xxs - -(* ifdef XXX elsif YYY elsif ZZZ endif *) -and pp_ifdef_tree_sequence pr_elem pr_space ifdef xxs = - match ifdef with - | if1::ifxs -> - pp_ifdef_gen pr_elem pr_space if1; - pp_ifdef_tree_sequence_aux pr_elem pr_space ifxs xxs - | _ -> raise Impossible - -(* XXX elsif YYY elsif ZZZ endif *) -and pp_ifdef_tree_sequence_aux pr_elem pr_space ifdefs xxs = - Common.zip ifdefs xxs +> List.iter (fun (ifdef, xs) -> - xs +> List.iter (pp_statement_seq_gen pr_elem pr_space); - pp_ifdef_gen pr_elem pr_space ifdef; - ) - - - - - -(* ---------------------- *) -and pp_asmbody_gen pr_elem pr_space (string_list, colon_list) = - string_list +> List.iter pr_elem ; - colon_list +> List.iter (fun (Colon xs, ii) -> - ii +> List.iter pr_elem; - xs +> List.iter (fun (x,iicomma) -> - assert ((List.length iicomma) <= 1); - iicomma +> List.iter (function x -> pr_elem x; pr_space()); - (match x with - | ColonMisc, ii -> ii +> List.iter pr_elem; - | ColonExpr e, [istring;iopar;icpar] -> - pr_elem istring; - pr_elem iopar; - pp_expression_gen pr_elem pr_space e; - pr_elem icpar - | (ColonExpr _), _ -> raise Impossible - ) - )) - - -(* ---------------------- *) - -(* -pp_type_with_ident_gen -pp_base_type_gen -pp_type_with_ident_rest_gen -pp_type_left_gen -pp_type_right_gen -pp_type_gen - -pp_decl_gen -*) -and (pp_type_with_ident_gen: - pr_elem_func -> pr_space_func -> - (string * info) option -> (storage * il) option -> - fullType -> attribute list -> - unit) = - fun pr_elem pr_space -> - fun ident sto ((qu, iiqu), (ty, iity)) attrs -> - pp_base_type_gen pr_elem pr_space ((qu, iiqu), (ty, iity)) sto; - (match ident with None -> () | Some _ -> pr_space()); - pp_type_with_ident_rest_gen pr_elem pr_space ident - ((qu, iiqu), (ty, iity)) attrs - - -and (pp_base_type_gen: - pr_elem_func -> pr_space_func -> fullType -> - (storage * il) option -> unit) = - fun pr_elem pr_space -> - let pp_expression e = pp_expression_gen pr_elem pr_space e in - - let rec pp_base_type = - fun (qu, (ty, iity)) sto -> - let get_sto sto = - match sto with - | None -> [] | Some (s, iis) -> (*assert (List.length iis = 1);*) iis - in - let print_sto_qu (sto, (qu, iiqu)) = - let all_ii = get_sto sto ++ iiqu in - all_ii - +> List.sort Ast_c.compare_pos - +> Common.print_between pr_space pr_elem(*List.iter pr_elem*); - - in - let print_sto_qu_ty (sto, (qu, iiqu), iity) = - let all_ii = get_sto sto ++ iiqu ++ iity in - let all_ii2 = all_ii +> List.sort Ast_c.compare_pos in - - if all_ii <> all_ii2 - then begin - (* TODO in fact for pointer, the qualifier is after the type - * cf -test strangeorder - *) - pr2 "STRANGEORDER"; - all_ii2 +> Common.print_between pr_space pr_elem(*List.iter pr_elem*) - end - else all_ii2 +> Common.print_between pr_space pr_elem(*List.iter pr_elem*) - in - - match ty, iity with - | (Pointer t, [i]) -> pp_base_type t sto - | (ParenType t, _) -> pp_base_type t sto - | (Array (eopt, t), [i1;i2]) -> pp_base_type t sto - | (FunctionType (returnt, paramst), [i1;i2]) -> - pp_base_type returnt sto - - - | (StructUnion (su, sopt, fields),iis) -> - print_sto_qu (sto, qu); - - (match sopt,iis with - | Some s , [i1;i2;i3;i4] -> - pr_elem i1; pr_elem i2; pr_elem i3; - | None, [i1;i2;i3] -> - pr_elem i1; pr_elem i2; - | x -> raise Impossible - ); - - fields +> List.iter - (fun (xfield, iipttvirg_when_emptyfield) -> - - match xfield with - | DeclarationField (FieldDeclList (onefield_multivars, iiptvirg)) -> - (match onefield_multivars with - | x::xs -> - (* handling the first var. Special case, with the - first var, we print the whole type *) - - (match x with - | (Simple (sopt, typ), iis), iivirg -> - (* first var cant have a preceding ',' *) - assert (List.length iivirg = 0); - let identinfo = - (match sopt, iis with - None,_ -> None - | (Some s, [iis]) -> Some (s, iis) - | x -> raise Impossible) - in - pp_type_with_ident_gen pr_elem pr_space - identinfo None typ Ast_c.noattr; - - | (BitField (sopt, typ, expr), ii), iivirg -> - (* first var cant have a preceding ',' *) - assert (List.length iivirg = 0); - (match sopt, ii with - | (None , [idot]) -> - pp_type_gen pr_elem pr_space typ; - pr_elem idot; - pp_expression expr - | (Some s, [is;idot]) -> - pp_type_with_ident_gen - pr_elem pr_space - (Some (s, is)) None typ Ast_c.noattr; - pr_elem idot; - pp_expression expr - | x -> raise Impossible - ) - ); (* match x, first onefield_multivars *) - - (* for other vars *) - xs +> List.iter (function - | (Simple (sopt, typ), iis), iivirg -> - iivirg +> List.iter pr_elem; - let identinfo = - (match sopt, iis with - | None,_ -> None - | (Some s, [iis]) -> Some (s, iis) - | x -> raise Impossible) - in - pp_type_with_ident_rest_gen pr_elem pr_space - identinfo typ Ast_c.noattr; - - | (BitField (sopt, typ, expr), ii), iivirg -> - iivirg +> List.iter pr_elem; - (match sopt, ii with - | (Some s, [is;idot]) -> - pp_type_with_ident_rest_gen - pr_elem pr_space - (Some (s, is)) typ Ast_c.noattr; - pr_elem idot; - pp_expression expr - | x -> raise Impossible - ); - - ); (* iter other vars *) - - | [] -> raise Impossible - ); (* onefield_multivars *) - assert (List.length iiptvirg = 1); - iiptvirg +> List.iter pr_elem; - - - | MacroStructDeclTodo -> pr2 "MacroTodo" - - - | EmptyField -> - iipttvirg_when_emptyfield +> List.iter pr_elem - - | CppDirectiveStruct cpp -> pp_directive_gen pr_elem pr_space cpp - | IfdefStruct ifdef -> pp_ifdef_gen pr_elem pr_space ifdef - ); - - (match sopt,iis with - | Some s , [i1;i2;i3;i4] -> pr_elem i4 - | None, [i1;i2;i3] -> pr_elem i3; - | x -> raise Impossible - ); - - - - | (Enum (sopt, enumt), iis) -> - print_sto_qu (sto, qu); - - (match sopt, iis with - | (Some s, ([i1;i2;i3;i4]|[i1;i2;i3;i4;_])) -> - 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 - ); - - enumt +> List.iter (fun (((s, eopt),ii_s_eq), iicomma) -> - assert (List.length iicomma <= 1); - iicomma +> List.iter (function x -> pr_elem x; pr_space()); - (match eopt, ii_s_eq with - | None, [is] -> pr_elem is; - | Some e, [is;ieq] -> pr_elem is; pr_elem ieq; pp_expression e - | _ -> raise Impossible - ) - - ); - - (match sopt, iis with - | (Some s, [i1;i2;i3;i4]) -> pr_elem i4 - | (Some s, [i1;i2;i3;i4;i5]) -> - pr_elem i5; pr_elem i4 (* trailing comma *) - | (None, [i1;i2;i3]) -> pr_elem i3 - | (None, [i1;i2;i3;i4]) -> - pr_elem i4; pr_elem i3 (* trailing comma *) - - - | x -> raise Impossible - ); - - - | (BaseType _, iis) -> - print_sto_qu_ty (sto, qu, iis); - - | (StructUnionName (s, structunion), iis) -> - assert (List.length iis = 2); - print_sto_qu_ty (sto, qu, iis); - - | (EnumName s, iis) -> - assert (List.length iis = 2); - print_sto_qu_ty (sto, qu, iis); - - | (TypeName (s,_typ), iis) -> - assert (List.length iis = 1); - print_sto_qu_ty (sto, qu, iis); - - | (TypeOfExpr (e), iis) -> - print_sto_qu (sto, qu); - (match iis with - | [itypeof;iopar;icpar] -> - pr_elem itypeof; pr_elem iopar; - pp_expression_gen pr_elem pr_space e; - pr_elem icpar; - | _ -> raise Impossible - ) - - | (TypeOfType (t), iis) -> - print_sto_qu (sto, qu); - (match iis with - | [itypeof;iopar;icpar] -> - pr_elem itypeof; pr_elem iopar; - pp_type_gen pr_elem pr_space t; - pr_elem icpar; - | _ -> raise Impossible - ) - - | (Pointer _ | (*ParenType _ |*) Array _ | FunctionType _ - (* | StructUnion _ | Enum _ | BaseType _ *) - (* | StructUnionName _ | EnumName _ | TypeName _ *) - (* | TypeOfExpr _ | TypeOfType _ *) - ), _ -> raise Impossible - - - - in - pp_base_type - - -(* used because of DeclList, in int i,*j[23]; we dont print anymore the - int before *j *) -and (pp_type_with_ident_rest_gen: - pr_elem_func -> pr_space_func -> - (string * info) option -> - fullType -> attribute list -> - unit) = - fun pr_elem pr_space -> - - fun ident (((qu, iiqu), (ty, iity)) as fullt) attrs -> - let print_ident ident = Common.do_option (fun (s, iis) -> - (* XXX attrs +> pp_attributes pr_elem pr_space; *) - pr_elem iis - ) ident - in - - match ty, iity with - (* the work is to do in base_type !! *) - | (BaseType _, iis) -> print_ident ident - | (Enum (sopt, enumt), iis) -> print_ident ident - | (StructUnion (_, sopt, fields),iis) -> print_ident ident - | (StructUnionName (s, structunion), iis) -> print_ident ident - | (EnumName s, iis) -> print_ident ident - | (TypeName (s,_typ), iis) -> print_ident ident - | (TypeOfExpr (e), iis) -> print_ident ident - | (TypeOfType (e), iis) -> print_ident ident - - - - | (Pointer t, [i]) -> - (* subtil: void ( *done)(int i) is a Pointer - (FunctionType (return=void, params=int i) *) - (*WRONG I THINK, use left & right function *) - (* bug: pp_type_with_ident_rest None t; print_ident ident *) - pr_elem i; - iiqu +> List.iter pr_elem; (* le const est forcement apres le '*' *) - pp_type_with_ident_rest_gen pr_elem pr_space ident t attrs; - - (* ugly special case ... todo? maybe sufficient in practice *) - | (ParenType (q1, (Pointer (q2, (FunctionType t, ii3)) , - [ipointer]) ), [i1;i2]) -> - pp_type_left_gen pr_elem pr_space (q2, (FunctionType t, ii3)); - pr_elem i1; - pr_elem ipointer; - print_ident ident; - pr_elem i2; - pp_type_right_gen pr_elem pr_space (q2, (FunctionType t, ii3)); - - (* another ugly special case *) - | (ParenType - (q1, (Array (eopt, - (q2, (Pointer - (q3, (FunctionType t, iifunc)), - [ipointer]))), - [iarray1;iarray2])), [i1;i2]) -> - pp_type_left_gen pr_elem pr_space (q3, (FunctionType t, iifunc)); - pr_elem i1; - pr_elem ipointer; - print_ident ident; - pr_elem iarray1; - do_option (pp_expression_gen pr_elem pr_space) eopt; - pr_elem iarray2; - pr_elem i2; - pp_type_right_gen pr_elem pr_space (q3, (FunctionType t, iifunc)) - - - - | (ParenType t, [i1;i2]) -> - pr2 "PB PARENTYPE ZARB, I forget about the ()"; - pp_type_with_ident_rest_gen pr_elem pr_space ident t attrs; - - - | (Array (eopt, t), [i1;i2]) -> - pp_type_left_gen pr_elem pr_space fullt; - - iiqu +> List.iter pr_elem; - print_ident ident; - - pp_type_right_gen pr_elem pr_space fullt; - - - | (FunctionType (returnt, paramst), [i1;i2]) -> - pp_type_left_gen pr_elem pr_space fullt; - - iiqu +> List.iter pr_elem; - print_ident ident; - - pp_type_right_gen pr_elem pr_space fullt; - - - | (FunctionType _ | Array _ | ParenType _ | Pointer _ - ), _ -> raise Impossible - - -and (pp_type_left_gen: pr_elem_func -> pr_space_func -> fullType -> unit) = - fun pr_elem pr_space -> - let rec pp_type_left = fun ((qu, iiqu), (ty, iity)) -> - match ty, iity with - | (Pointer t, [i]) -> - pr_elem i; - iiqu +> List.iter pr_elem; (* le const est forcement apres le '*' *) - pp_type_left t - - | (Array (eopt, t), [i1;i2]) -> pp_type_left t - | (FunctionType (returnt, paramst), [i1;i2]) -> pp_type_left returnt - - | (ParenType t, _) -> failwith "parenType" - - - | (BaseType _, iis) -> () - | (Enum (sopt, enumt), iis) -> () - | (StructUnion (_, sopt, fields),iis) -> () - | (StructUnionName (s, structunion), iis) -> () - | (EnumName s, iis) -> () - | (TypeName (s,_typ), iis) -> () - - | TypeOfType _, _ -> () - | TypeOfExpr _, _ -> () - - | (FunctionType _ | Array _ | Pointer _ - ), _ -> raise Impossible - in - pp_type_left - - -and pp_param_gen pr_elem pr_space = fun ((b, sopt, t), ii_b_s) -> - match b, sopt, ii_b_s with - | false, None, [] -> - pp_type_gen pr_elem pr_space t - | true, None, [i1] -> - pr_elem i1; - pp_type_gen pr_elem pr_space t - - | false, Some s, [i1] -> - pp_type_with_ident_gen pr_elem pr_space - (Some (s, i1)) None t Ast_c.noattr; - | true, Some s, [i1;i2] -> - pr_elem i1; - pp_type_with_ident_gen pr_elem pr_space - (Some (s, i2)) None t Ast_c.noattr; - | _ -> raise Impossible - - -and (pp_type_right_gen: pr_elem_func -> pr_space_func -> fullType -> unit) = - fun pr_elem pr_space -> - let rec pp_type_right = fun ((qu, iiqu), (ty, iity)) -> - match ty, iity with - | (Pointer t, [i]) -> pp_type_right t - - | (Array (eopt, t), [i1;i2]) -> - pr_elem i1; - eopt +> do_option (fun e -> pp_expression_gen pr_elem pr_space e); - pr_elem i2; - pp_type_right t - - | (ParenType t, _) -> failwith "parenType" - | (FunctionType (returnt, paramst), [i1;i2]) -> - pr_elem i1; - (match paramst with - | (ts, (b, iib)) -> - ts +> List.iter (fun (param,iicomma) -> - assert ((List.length iicomma) <= 1); - iicomma +> List.iter (function x -> pr_elem x; pr_space()); - - pp_param_gen pr_elem pr_space param; - ); - iib +> List.iter pr_elem; - ); - pr_elem i2; - - - - - | (BaseType _, iis) -> () - | (Enum (sopt, enumt), iis) -> () - | (StructUnion (_, sopt, fields),iis)-> () - | (StructUnionName (s, structunion), iis) -> () - | (EnumName s, iis) -> () - | (TypeName (s,_typ), iis) -> () - - | TypeOfType _, _ -> () - | TypeOfExpr _, _ -> () - - | (FunctionType _ | Array _ | Pointer _ - ), _ -> raise Impossible - - in - pp_type_right - -and pp_type_gen pr_elem pr_space t = - pp_type_with_ident_gen pr_elem pr_space - None None t Ast_c.noattr - -(* ---------------------- *) -and pp_decl_gen pr_elem pr_space = function - | DeclList ((({v_namei = var; v_type = returnType; - v_storage = storage; v_attr = attrs; - },[])::xs), - iivirg::ifakestart::iisto) -> - - pr_elem ifakestart; - - (* old: iisto +> List.iter pr_elem; *) - - - (* handling the first var. Special case, we print the whole type *) - (match var with - | Some ((s, ini), iis::iini) -> - pp_type_with_ident_gen pr_elem pr_space - (Some (s, iis)) (Some (storage, iisto)) - returnType attrs; - ini +> do_option (fun init -> - List.iter pr_elem iini; pp_init_gen pr_elem pr_space init); - | None -> pp_type_gen pr_elem pr_space returnType - | _ -> raise Impossible - ); - - (* for other vars, we just call pp_type_with_ident_rest. *) - xs +> List.iter (function - | ({v_namei = Some ((s, ini), iis::iini); - v_type = returnType; - v_storage = storage2; - v_attr = attrs; - }, iivirg) -> - - assert (storage2 = storage); - iivirg +> List.iter pr_elem; - pp_type_with_ident_rest_gen pr_elem pr_space - (Some (s, iis)) returnType attrs; - ini +> do_option (fun (init) -> - List.iter pr_elem iini; pp_init_gen pr_elem pr_space init); - - - | x -> raise Impossible - ); - - pr_elem iivirg; - - | MacroDecl ((s, es), iis::lp::rp::iiend::ifakestart::iisto) -> - pr_elem ifakestart; - iisto +> List.iter pr_elem; (* static and const *) - pr_elem iis; - pr_elem lp; - es +> List.iter (fun (e, opt) -> - assert (List.length opt <= 1); - opt +> List.iter pr_elem; - pp_argument_gen pr_elem pr_space e; - ); - - pr_elem rp; - pr_elem iiend; - - | (DeclList (_, _) | (MacroDecl _)) -> raise Impossible - - -(* ---------------------- *) -and pp_init_gen = fun pr_elem pr_space -> - let pp_expression e = pp_expression_gen pr_elem pr_space e in - let rec pp_init = fun (init, iinit) -> - match init, iinit with - | InitExpr e, [] -> pp_expression e; - | InitList xs, i1::i2::iicommaopt -> - pr_elem i1; - xs +> List.iter (fun (x, ii) -> - assert (List.length ii <= 1); - ii +> List.iter pr_elem; - pp_init x - ); - iicommaopt +> List.iter pr_elem; - pr_elem i2; - - | InitDesignators (xs, initialiser), [i1] -> (* : *) - xs +> List.iter (pp_designator pr_elem pr_space); - pr_elem i1; - pp_init initialiser - - (* no use of '=' in the "Old" style *) - | InitFieldOld (string, initialiser), [i1;i2] -> (* label: in oldgcc *) - pr_elem i1; pr_elem i2; pp_init initialiser - | InitIndexOld (expression, initialiser), [i1;i2] -> (* [1] in oldgcc *) - pr_elem i1; pp_expression expression; pr_elem i2; - pp_init initialiser - - | (InitIndexOld _ | InitFieldOld _ | InitDesignators _ - | InitList _ | InitExpr _ - ), _ -> raise Impossible - in - pp_init - - - -and pp_designator pr_elem pr_space design = - let pp_expression e = pp_expression_gen pr_elem pr_space e in - match design with - | DesignatorField (s), [i1; i2] -> - pr_elem i1; pr_elem i2; - | DesignatorIndex (expression), [i1;i2] -> - pr_elem i1; pp_expression expression; pr_elem i2; - - | DesignatorRange (e1, e2), [iocro;iellipsis;iccro] -> - pr_elem iocro; pp_expression e1; pr_elem iellipsis; - pp_expression e2; pr_elem iccro; - - | (DesignatorField _ | DesignatorIndex _ | DesignatorRange _ - ), _ -> raise Impossible - - -(* ---------------------- *) -and pp_attributes pr_elem pr_space attrs = - attrs +> List.iter (fun (attr, ii) -> - ii +> List.iter pr_elem; - ); - -(* ---------------------- *) -and pp_def_gen pr_elem pr_space def = - let defbis, ii = def in - match ii with - | is::iifunc1::iifunc2::i1::i2::ifakestart::isto -> - - let {f_name = s; - f_type = (returnt, (paramst, (b, iib))); - f_storage = sto; - f_body = statxs; - f_attr = attrs; - } = defbis - in - - pr_elem ifakestart; - - pp_type_with_ident_gen pr_elem pr_space None (Some (sto, isto)) - returnt Ast_c.noattr; - - pp_attributes pr_elem pr_space attrs; - pr_elem is; - - - pr_elem iifunc1; - - (* not anymore, cf tests/optional_name_parameter and - macro_parameter_shortcut.c - (match paramst with - | [(((bool, None, t), ii_b_s), iicomma)] -> - assert - (match t with - | qu, (BaseType Void, ii) -> true - | _ -> true - ); - assert (null iicomma); - assert (null ii_b_s); - pp_type_with_ident_gen pr_elem pr_space None None t - - | paramst -> - paramst +> List.iter (fun (((bool, s, t), ii_b_s), iicomma) -> - iicomma +> List.iter pr_elem; - - (match b, s, ii_b_s with - | false, Some s, [i1] -> - pp_type_with_ident_gen - pr_elem pr_space (Some (s, i1)) None t; - | true, Some s, [i1;i2] -> - pr_elem i1; - pp_type_with_ident_gen - pr_elem pr_space (Some (s, i2)) None t; - - (* in definition we have name for params, except when f(void) *) - | _, None, _ -> raise Impossible - | false, None, [] -> - - | _ -> raise Impossible - ) - ); - ); - - (* normally ii represent the ",..." but it is also abused - with the f(void) case *) - (* assert (List.length iib <= 2);*) - iib +> List.iter pr_elem; - - *) - paramst +> List.iter (fun (param,iicomma) -> - assert ((List.length iicomma) <= 1); - iicomma +> List.iter (function x -> pr_elem x; pr_space()); - - pp_param_gen pr_elem pr_space param; - ); - iib +> List.iter pr_elem; - - - pr_elem iifunc2; - pr_elem i1; - statxs +> List.iter (pp_statement_seq_gen pr_elem pr_space); - pr_elem i2; - | _ -> raise Impossible - - - -(* ---------------------- *) - -and pp_ifdef_gen pr_elem pr_space ifdef = - match ifdef with - | IfdefDirective (ifdef, ii) -> - List.iter pr_elem ii - - -and pp_directive_gen pr_elem pr_space directive = - match directive with - | Include {i_include = (s, ii);} -> - let (i1,i2) = Common.tuple_of_list2 ii in - pr_elem i1; pr_elem i2 - | Define ((s,ii), (defkind, defval)) -> - let (idefine,iident,ieol) = Common.tuple_of_list3 ii in - pr_elem idefine; - pr_elem iident; - - let define_val = function - | DefineExpr e -> pp_expression_gen pr_elem pr_space e - | DefineStmt st -> pp_statement_gen pr_elem pr_space st - | DefineDoWhileZero ((st,e), ii) -> - (match ii with - | [ido;iwhile;iopar;icpar] -> - pr_elem ido; - pp_statement_gen pr_elem pr_space st; - pr_elem iwhile; pr_elem iopar; - pp_expression_gen pr_elem pr_space e; - pr_elem icpar - | _ -> raise Impossible - ) - | DefineFunction def -> pp_def_gen pr_elem pr_space def - - | DefineType ty -> pp_type_gen pr_elem pr_space ty - | DefineText (s, ii) -> List.iter pr_elem ii - | DefineEmpty -> () - | DefineInit ini -> - pp_init_gen pr_elem pr_space ini - - | DefineTodo -> pr2 "DefineTodo" - in - (match defkind with - | DefineVar -> () - | DefineFunc (params, ii) -> - let (i1,i2) = tuple_of_list2 ii in - pr_elem i1; - params +> List.iter (fun ((s,iis), iicomma) -> - assert (List.length iicomma <= 1); - iicomma +> List.iter pr_elem; - iis +> List.iter pr_elem; - ); - pr_elem i2; - ); - define_val defval; - pr_elem ieol - - | Undef (s, ii) -> - List.iter pr_elem ii - | PragmaAndCo (ii) -> - List.iter pr_elem ii - - - - -let pp_program_gen pr_elem pr_space progelem = - match progelem with - | Declaration decl -> pp_decl_gen pr_elem pr_space decl - | Definition def -> pp_def_gen pr_elem pr_space def - - | CppTop directive -> pp_directive_gen pr_elem pr_space directive - - - | MacroTop (s, es, [i1;i2;i3;i4]) -> - pr_elem i1; - pr_elem i2; - es +> List.iter (fun (e, opt) -> - assert (List.length opt <= 1); - opt +> List.iter pr_elem; - pp_argument_gen pr_elem pr_space e; - ); - pr_elem i3; - pr_elem i4; - - - | EmptyDef ii -> ii +> List.iter pr_elem - | NotParsedCorrectly ii -> - assert (List.length ii >= 1); - ii +> List.iter pr_elem - | FinalDef info -> pr_elem (Ast_c.rewrap_str "" info) - - | IfdefTop ifdefdir -> - pp_ifdef_gen pr_elem pr_space ifdefdir - - | (MacroTop _) - -> raise Impossible - - - - -let pp_flow_gen pr_elem pr_space n = - match F.unwrap n with - | F.FunHeader ({f_name =idb; - f_type = (rett, (paramst,(isvaargs,iidotsb))); - f_storage = stob; - f_body = body; - f_attr = attrs},ii) -> - - assert(null body); - (* - iif ii; - iif iidotsb; - attrs +> List.iter (vk_attribute bigf); - vk_type bigf rett; - paramst +> List.iter (fun (param, iicomma) -> - vk_param bigf param; - iif iicomma; - ); - *) - pr2 "Def"; - - - | F.Decl decl -> - (* vk_decl bigf decl *) - pr2 "Decl" - - | F.ExprStatement (st, (eopt, ii)) -> - pp_statement_gen pr_elem pr_space (ExprStatement eopt, ii) - - | F.IfHeader (_, (e,ii)) - | F.SwitchHeader (_, (e,ii)) - | F.WhileHeader (_, (e,ii)) - | F.DoWhileTail (e,ii) -> - (* - iif ii; - vk_expr bigf e - *) - pr2 "XXX"; - - - | F.ForHeader (_st, (((e1opt,i1), (e2opt,i2), (e3opt,i3)), ii)) -> - (* - iif i1; iif i2; iif i3; - iif ii; - e1opt +> do_option (vk_expr bigf); - e2opt +> do_option (vk_expr bigf); - e3opt +> do_option (vk_expr bigf); - *) - pr2 "XXX"; - - | F.MacroIterHeader (_s, ((s,es), ii)) -> - (* - iif ii; - vk_argument_list bigf es; - *) - pr2 "XXX"; - - - | F.ReturnExpr (_st, (e,ii)) -> - (* iif ii; vk_expr bigf e*) - pr2 "XXX"; - - - | F.Case (_st, (e,ii)) -> - (* iif ii; vk_expr bigf e *) - pr2 "XXX"; - - | F.CaseRange (_st, ((e1, e2),ii)) -> - (* iif ii; vk_expr bigf e1; vk_expr bigf e2 *) - pr2 "XXX"; - - - - | F.CaseNode i -> () - - | F.DefineExpr e -> - (* vk_expr bigf e *) - pr2 "XXX"; - - | F.DefineType ft -> - (* vk_type bigf ft *) - pr2 "XXX"; - - | F.DefineHeader ((s,ii), (defkind)) -> - (* - iif ii; - vk_define_kind bigf defkind; - *) - pr2 "XXX"; - - - | F.DefineDoWhileZeroHeader (((),ii)) -> - (* iif ii *) - pr2 "XXX"; - - - | F.Include {i_include = (s, ii);} -> - (* iif ii; *) - pr2 "XXX"; - - - | F.MacroTop (s, args, ii) -> - (* iif ii; - vk_argument_list bigf args *) - pr2 "XXX"; - - - | F.Break (st,((),ii)) -> - (* iif ii *) - pr2 "XXX"; - | F.Continue (st,((),ii)) -> - (* iif ii *) - pr2 "XXX"; - | F.Default (st,((),ii)) -> - (* iif ii *) - pr2 "XXX"; - | F.Return (st,((),ii)) -> - (* iif ii *) - pr2 "XXX"; - | F.Goto (st, (s,ii)) -> - (* iif ii *) - pr2 "XXX"; - | F.Label (st, (s,ii)) -> - (* iif ii *) - pr2 "XXX"; - | F.EndStatement iopt -> - (* do_option infof iopt *) - pr2 "XXX"; - | F.DoHeader (st, info) -> - (* infof info *) - pr2 "XXX"; - | F.Else info -> - (* infof info *) - pr2 "XXX"; - | F.SeqEnd (i, info) -> - (* infof info *) - pr2 "XXX"; - | F.SeqStart (st, i, info) -> - (* infof info *) - pr2 "XXX"; - - | F.MacroStmt (st, ((),ii)) -> - (* iif ii *) - pr2 "XXX"; - | F.Asm (st, (asmbody,ii)) -> - (* - iif ii; - vk_asmbody bigf asmbody - *) - pr2 "XXX"; - - - | F.IfdefHeader (info) -> - pp_ifdef_gen pr_elem pr_space info - | F.IfdefElse (info) -> - pp_ifdef_gen pr_elem pr_space info - | F.IfdefEndif (info) -> - pp_ifdef_gen pr_elem pr_space info - - | F.DefineTodo -> - pr2 "XXX"; - - - | ( - F.TopNode|F.EndNode| - F.ErrorExit|F.Exit|F.Enter| - F.FallThroughNode|F.AfterNode|F.FalseNode|F.TrueNode|F.InLoopNode| - F.Fake - ) -> - pr2 "YYY" - - - - - - - - -(*****************************************************************************) - -(* Here we do not use (mcode, env). It is a simple C pretty printer. *) -let pr_elem info = - let s = Ast_c.str_of_info info in - pp s - -let pr_space _ = Format.print_space() - -let pp_expression_simple = pp_expression_gen pr_elem pr_space -let pp_statement_simple = pp_statement_gen pr_elem pr_space -let pp_type_simple = pp_type_gen pr_elem pr_space -let pp_toplevel_simple = pp_program_gen pr_elem pr_space -let pp_flow_simple = pp_flow_gen pr_elem pr_space - - - -let string_of_expression e = - Common.format_to_string (fun () -> - pp_expression_simple e - ) - -let (debug_info_of_node: Ograph_extended.nodei -> Control_flow_c.cflow -> string) = - fun nodei flow -> - let node = flow#nodes#assoc nodei in - let s = Common.format_to_string (fun () -> - pp_flow_simple node - ) in - let pos = Lib_parsing_c.min_pinfo_of_node node in - (spf "%s(n%d)--> %s" (Common.string_of_parse_info_bis pos) nodei s) +(* 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. + *) +open Common + +open Ast_c + + +type pr_elem_func = Ast_c.info -> unit +type pr_space_func = unit -> unit +type pr_nl_func = unit -> unit +type pr_indent_func = unit -> unit +type pr_outdent_func = unit -> unit +type pr_unindent_func = unit -> unit + +type expression_printer = Ast_c.expression -> unit +type arg_list_printer = Ast_c.argument Ast_c.wrap2 list -> unit +type statement_printer = Ast_c.statement -> unit +type declaration_printer = Ast_c.declaration -> unit +type initialiser_printer = Ast_c.initialiser -> unit +type param_printer = Ast_c.parameterType -> unit +type type_printer = Ast_c.fullType -> unit +type type_with_ident_printer = + (string * Ast_c.info) option -> + (Ast_c.storage * Ast_c.il) option -> Ast_c.fullType -> + Ast_c.attribute list -> unit +type toplevel_printer = Ast_c.toplevel -> unit +type flow_printer = Control_flow_c.node -> unit + +(* result type *) +type pretty_printers = + {expression : expression_printer; + arg_list : arg_list_printer; + statement : statement_printer; + decl : declaration_printer; + init : initialiser_printer; + param : param_printer; + ty : type_printer; + type_with_ident : type_with_ident_printer; + toplevel : toplevel_printer; + flow : flow_printer} + +module F = Control_flow_c + +(*****************************************************************************) + +(* This module is used by unparse_c, but because unparse_c have also + * the list of tokens, pretty_print_c could be useless in the future + * (except that the ast_c have some fake tokens not present in the list + * of tokens so it's still useful). But this module is also useful to + * unparse C when you don't have the ordered list of tokens separately, + * or tokens without position information, for instance when you want + * to pretty print some piece of C that was generated, or some + * abstract-lined piece of code, etc. *) + +let pretty_print_c pr_elem pr_space pr_nl pr_indent pr_outdent pr_unindent = + let start_block () = pr_nl(); pr_indent() in + let end_block () = pr_unindent(); pr_nl() in + + let indent_if_needed (s,_) f = + match s with + Compound _ -> pr_space(); f() + | _ -> + (*no newline at the end - someone else will do that*) + start_block(); f(); pr_unindent() in + + let rec pp_expression = fun ((exp, typ), ii) -> + (match exp, ii with + | Ident (c), [i] -> pr_elem i + (* only a MultiString can have multiple ii *) + | Constant (MultiString), is -> is +> List.iter pr_elem + | Constant (c), [i] -> pr_elem i + | FunCall (e, es), [i1;i2] -> + pp_expression e; pr_elem i1; + pp_arg_list es; + pr_elem i2; + + | CondExpr (e1, e2, e3), [i1;i2] -> + pp_expression e1; pr_space(); pr_elem i1; pr_space(); + do_option (function x -> pp_expression x; pr_space()) e2; pr_elem i2; + pp_expression e3 + | Sequence (e1, e2), [i] -> + pp_expression e1; pr_elem i; pr_space(); pp_expression e2 + | Assignment (e1, op, e2), [i] -> + pp_expression e1; pr_space(); pr_elem i; pr_space(); pp_expression e2 + + | Postfix (e, op), [i] -> pp_expression e; pr_elem i; + | Infix (e, op), [i] -> pr_elem i; pp_expression e; + | Unary (e, op), [i] -> pr_elem i; pp_expression e + | Binary (e1, op, e2), [i] -> + pp_expression e1; pr_space(); pr_elem i; pr_space(); pp_expression e2 + + | ArrayAccess (e1, e2), [i1;i2] -> + pp_expression e1; pr_elem i1; pp_expression e2; pr_elem i2 + | RecordAccess (e, s), [i1;i2] -> + pp_expression e; pr_elem i1; pr_elem i2 + | RecordPtAccess (e, s), [i1;i2] -> + pp_expression e; pr_elem i1; pr_elem i2 + + | SizeOfExpr (e), [i] -> pr_elem i; pp_expression e + | SizeOfType (t), [i1;i2;i3] -> + pr_elem i1; pr_elem i2; pp_type t; pr_elem i3 + | Cast (t, e), [i1;i2] -> + pr_elem i1; pp_type t; pr_elem i2; pp_expression e + + | StatementExpr (statxs, [ii1;ii2]), [i1;i2] -> + pr_elem i1; + pr_elem ii1; + statxs +> List.iter pp_statement_seq; + pr_elem ii2; + pr_elem i2; + | Constructor (t, xs), lp::rp::i1::i2::iicommaopt -> + pr_elem lp; + pp_type t; + pr_elem rp; + pr_elem i1; + xs +> List.iter (fun (x, ii) -> + assert (List.length ii <= 1); + ii +> List.iter (function x -> pr_elem x; pr_space()); + pp_init x + ); + iicommaopt +> List.iter pr_elem; + pr_elem i2; + + | ParenExpr (e), [i1;i2] -> pr_elem i1; pp_expression e; pr_elem i2; + + | (Ident (_) | Constant _ | FunCall (_,_) | CondExpr (_,_,_) + | Sequence (_,_) + | Assignment (_,_,_) + | Postfix (_,_) | Infix (_,_) | Unary (_,_) | Binary (_,_,_) + | ArrayAccess (_,_) | RecordAccess (_,_) | RecordPtAccess (_,_) + | SizeOfExpr (_) | SizeOfType (_) | Cast (_,_) + | StatementExpr (_) | Constructor _ + | ParenExpr (_)),_ -> raise Impossible + ); + + if !Flag_parsing_c.pretty_print_type_info + then begin + pr_elem (Ast_c.fakeInfo() +> Ast_c.rewrap_str "/*"); + !typ +> + (fun (ty,_test) -> ty +> + Common.do_option + (fun (x,l) -> pp_type x; + let s = match l with + Ast_c.LocalVar _ -> ", local" + | _ -> "" in + pr_elem (Ast_c.fakeInfo() +> Ast_c.rewrap_str s))); + pr_elem (Ast_c.fakeInfo() +> Ast_c.rewrap_str "*/"); + end + + and pp_arg_list es = + es +> List.iter (fun (e, opt) -> + assert (List.length opt <= 1); (* opt must be a comma? *) + opt +> List.iter (function x -> pr_elem x; pr_space()); + pp_argument e) + + and pp_argument argument = + let rec pp_action (ActMisc ii) = ii +> List.iter pr_elem in + match argument with + | Left e -> pp_expression e + | Right wierd -> + (match wierd with + | ArgType param -> pp_param param + | ArgAction action -> pp_action action) + +(* ---------------------- *) + and pp_statement = function + | Labeled (Label (s, st)), [i1;i2] -> + pr_outdent(); pr_elem i1; pr_elem i2; pr_nl(); pp_statement st + | Labeled (Case (e, st)), [i1;i2] -> + pr_unindent(); + pr_elem i1; pp_expression e; pr_elem i2; pr_nl(); pr_indent(); + pp_statement st + | Labeled (CaseRange (e, e2, st)), [i1;i2;i3] -> + pr_unindent(); + pr_elem i1; pp_expression e; pr_elem i2; pp_expression e2; pr_elem i3; + pr_nl(); pr_indent(); + pp_statement st + | Labeled (Default st), [i1;i2] -> + pr_unindent(); pr_elem i1; pr_elem i2; pr_nl(); pr_indent(); + pp_statement st + | Compound statxs, [i1;i2] -> + pr_elem i1; start_block(); + statxs +> Common.print_between pr_nl pp_statement_seq; + end_block(); pr_elem i2; + + | ExprStatement (None), [i] -> pr_elem i; + | ExprStatement (None), [] -> () + | ExprStatement (Some e), [i] -> pp_expression e; pr_elem i + (* the last ExprStatement of a for does not have a trailing + ';' hence the [] for ii *) + | ExprStatement (Some e), [] -> pp_expression e; + | Selection (If (e, st1, st2)), i1::i2::i3::is -> + pr_elem i1; pr_space(); pr_elem i2; pp_expression e; pr_elem i3; + indent_if_needed st1 (function _ -> pp_statement st1); + (match (st2, is) with + | ((ExprStatement None, []), []) -> () + | ((ExprStatement None, []), [iifakend]) -> pr_elem iifakend + | st2, [i4;iifakend] -> pr_elem i4; + indent_if_needed st2 (function _ -> pp_statement st2); + pr_elem iifakend + | x -> raise Impossible + ) + | Selection (Switch (e, st)), [i1;i2;i3;iifakend] -> + pr_elem i1; pr_space(); pr_elem i2; pp_expression e; pr_elem i3; + indent_if_needed st (function _-> pp_statement st); pr_elem iifakend + | Iteration (While (e, st)), [i1;i2;i3;iifakend] -> + pr_elem i1; pr_space(); pr_elem i2; pp_expression e; pr_elem i3; + indent_if_needed st (function _-> pp_statement st); pr_elem iifakend + | Iteration (DoWhile (st, e)), [i1;i2;i3;i4;i5;iifakend] -> + pr_elem i1; + indent_if_needed st (function _ -> pp_statement st); + pr_elem i2; pr_elem i3; pp_expression e; + pr_elem i4; pr_elem i5; + pr_elem iifakend + + + | Iteration (For ((e1opt,il1),(e2opt,il2),(e3opt, il3),st)), + [i1;i2;i3;iifakend] -> + + pr_elem i1; pr_space(); + pr_elem i2; + pp_statement (ExprStatement e1opt, il1); + pp_statement (ExprStatement e2opt, il2); + assert (null il3); + pp_statement (ExprStatement e3opt, il3); + pr_elem i3; + indent_if_needed st (function _ -> pp_statement st); + pr_elem iifakend + + | Iteration (MacroIteration (s,es,st)), [i1;i2;i3;iifakend] -> + pr_elem i1; pr_space(); + pr_elem i2; + + es +> List.iter (fun (e, opt) -> + assert (List.length opt <= 1); + opt +> List.iter pr_elem; + pp_argument e; + ); + + pr_elem i3; + indent_if_needed st (function _ -> pp_statement st); + pr_elem iifakend + + | Jump (Goto s), [i1;i2;i3] -> + pr_elem i1; pr_space(); pr_elem i2; pr_elem i3; + | Jump ((Continue|Break|Return)), [i1;i2] -> pr_elem i1; pr_elem i2; + | Jump (ReturnExpr e), [i1;i2] -> + pr_elem i1; pr_space(); pp_expression e; pr_elem i2 + | Jump (GotoComputed e), [i1;i2;i3] -> + pr_elem i1; pr_elem i2; pp_expression e; pr_elem i3 + + | Decl decl, [] -> pp_decl decl + | Asm asmbody, ii -> + (match ii with + | [iasm;iopar;icpar;iptvirg] -> + pr_elem iasm; pr_elem iopar; + pp_asmbody asmbody; + pr_elem icpar; pr_elem iptvirg + | [iasm;ivolatile;iopar;icpar;iptvirg] -> + pr_elem iasm; pr_elem ivolatile; pr_elem iopar; + pp_asmbody asmbody; + pr_elem icpar; pr_elem iptvirg + | _ -> raise Impossible + ) + + | NestedFunc def, ii -> + assert (null ii); + pp_def def + | MacroStmt, ii -> + ii +> List.iter pr_elem ; + + | ( Labeled (Label (_,_)) | Labeled (Case (_,_)) + | Labeled (CaseRange (_,_,_)) | Labeled (Default _) + | Compound _ | ExprStatement _ + | Selection (If (_, _, _)) | Selection (Switch (_, _)) + | Iteration (While (_, _)) | Iteration (DoWhile (_, _)) + | Iteration (For ((_,_), (_,_), (_, _), _)) + | Iteration (MacroIteration (_,_,_)) + | Jump (Goto _) | Jump ((Continue|Break|Return)) | Jump (ReturnExpr _) + | Jump (GotoComputed _) + | Decl _ + ), _ -> raise Impossible + + and pp_statement_seq = function + | StmtElem st -> pp_statement st + | IfdefStmt ifdef -> pp_ifdef ifdef + | CppDirectiveStmt cpp -> pp_directive cpp + | IfdefStmt2 (ifdef, xxs) -> pp_ifdef_tree_sequence ifdef xxs + +(* ifdef XXX elsif YYY elsif ZZZ endif *) + and pp_ifdef_tree_sequence ifdef xxs = + match ifdef with + | if1::ifxs -> + pp_ifdef if1; + pp_ifdef_tree_sequence_aux ifxs xxs + | _ -> raise Impossible + +(* XXX elsif YYY elsif ZZZ endif *) + and pp_ifdef_tree_sequence_aux ifdefs xxs = + Common.zip ifdefs xxs +> List.iter (fun (ifdef, xs) -> + xs +> List.iter pp_statement_seq; + pp_ifdef ifdef + ) + + + + + +(* ---------------------- *) + and pp_asmbody (string_list, colon_list) = + string_list +> List.iter pr_elem ; + colon_list +> List.iter (fun (Colon xs, ii) -> + ii +> List.iter pr_elem; + xs +> List.iter (fun (x,iicomma) -> + assert ((List.length iicomma) <= 1); + iicomma +> List.iter (function x -> pr_elem x; pr_space()); + (match x with + | ColonMisc, ii -> ii +> List.iter pr_elem; + | ColonExpr e, [istring;iopar;icpar] -> + pr_elem istring; + pr_elem iopar; + pp_expression e; + pr_elem icpar + | (ColonExpr _), _ -> raise Impossible) + )) + + +(* ---------------------- *) + +(* + pp_type_with_ident + pp_base_type + pp_type_with_ident_rest + pp_type_left + pp_type_right + pp_type + + pp_decl +*) + and (pp_type_with_ident: + (string * info) option -> (storage * il) option -> + fullType -> attribute list -> + unit) = + fun ident sto ((qu, iiqu), (ty, iity)) attrs -> + pp_base_type ((qu, iiqu), (ty, iity)) sto; + (match (ident,ty) with + (Some _,_) | (_,Pointer _) -> pr_space() + | _ -> ()); + pp_type_with_ident_rest ident ((qu, iiqu), (ty, iity)) attrs + + + and (pp_base_type: fullType -> (storage * il) option -> unit) = + fun (qu, (ty, iity)) sto -> + let get_sto sto = + match sto with + | None -> [] | Some (s, iis) -> (*assert (List.length iis = 1);*) iis + in + let print_sto_qu (sto, (qu, iiqu)) = + let all_ii = get_sto sto ++ iiqu in + all_ii + +> List.sort Ast_c.compare_pos + +> Common.print_between pr_space pr_elem + + in + let print_sto_qu_ty (sto, (qu, iiqu), iity) = + let all_ii = get_sto sto ++ iiqu ++ iity in + let all_ii2 = all_ii +> List.sort Ast_c.compare_pos in + + if all_ii <> all_ii2 + then begin + (* TODO in fact for pointer, the qualifier is after the type + * cf -test strangeorder + *) + pr2 "STRANGEORDER"; + all_ii2 +> Common.print_between pr_space pr_elem + end + else all_ii2 +> Common.print_between pr_space pr_elem + in + + match ty, iity with + | (Pointer t, [i]) -> pp_base_type t sto + | (ParenType t, _) -> pp_base_type t sto + | (Array (eopt, t), [i1;i2]) -> pp_base_type t sto + | (FunctionType (returnt, paramst), [i1;i2]) -> + pp_base_type returnt sto + + + | (StructUnion (su, sopt, fields),iis) -> + print_sto_qu (sto, qu); + + (match sopt,iis with + | Some s , [i1;i2;i3;i4] -> + pr_elem i1; pr_elem i2; pr_elem i3; + | None, [i1;i2;i3] -> + pr_elem i1; pr_elem i2; + | x -> raise Impossible + ); + + fields +> List.iter + (fun (xfield, iipttvirg_when_emptyfield) -> + + match xfield with + | DeclarationField(FieldDeclList(onefield_multivars,iiptvirg))-> + (match onefield_multivars with + | x::xs -> + (* handling the first var. Special case, with the + first var, we print the whole type *) + + (match x with + | (Simple (sopt, typ), iis), iivirg -> + (* first var cant have a preceding ',' *) + assert (List.length iivirg = 0); + let identinfo = + (match sopt, iis with + None,_ -> None + | (Some s, [iis]) -> Some (s, iis) + | x -> raise Impossible) in + pp_type_with_ident identinfo None typ Ast_c.noattr; + + | (BitField (sopt, typ, expr), ii), iivirg -> + (* first var cant have a preceding ',' *) + assert (List.length iivirg = 0); + (match sopt, ii with + | (None , [idot]) -> + pp_type typ; + pr_elem idot; + pp_expression expr + | (Some s, [is;idot]) -> + pp_type_with_ident + (Some (s, is)) None typ Ast_c.noattr; + pr_elem idot; + pp_expression expr + | x -> raise Impossible + )); (* match x, first onefield_multivars *) + + (* for other vars *) + xs +> List.iter (function + | (Simple (sopt, typ), iis), iivirg -> + iivirg +> List.iter pr_elem; + let identinfo = + (match sopt, iis with + | None,_ -> None + | (Some s, [iis]) -> Some (s, iis) + | x -> raise Impossible) + in + pp_type_with_ident_rest identinfo typ Ast_c.noattr + + | (BitField (sopt, typ, expr), ii), iivirg -> + iivirg +> List.iter pr_elem; + (match sopt, ii with + | (Some s, [is;idot]) -> + pp_type_with_ident_rest + (Some (s, is)) typ Ast_c.noattr; + pr_elem idot; + pp_expression expr + | x -> raise Impossible + )); (* iter other vars *) + + | [] -> raise Impossible + ); (* onefield_multivars *) + assert (List.length iiptvirg = 1); + iiptvirg +> List.iter pr_elem; + + + | MacroStructDeclTodo -> pr2 "MacroTodo" + + + | EmptyField -> iipttvirg_when_emptyfield +> List.iter pr_elem + + | CppDirectiveStruct cpp -> pp_directive cpp + | IfdefStruct ifdef -> pp_ifdef ifdef + ); + + (match sopt,iis with + | Some s , [i1;i2;i3;i4] -> pr_elem i4 + | None, [i1;i2;i3] -> pr_elem i3; + | x -> raise Impossible + ); + + + + | (Enum (sopt, enumt), iis) -> + print_sto_qu (sto, qu); + + (match sopt, iis with + | (Some s, ([i1;i2;i3;i4]|[i1;i2;i3;i4;_])) -> + 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 + ); + + enumt +> List.iter (fun (((s, eopt),ii_s_eq), iicomma) -> + assert (List.length iicomma <= 1); + iicomma +> List.iter (function x -> pr_elem x; pr_space()); + (match eopt, ii_s_eq with + | None, [is] -> pr_elem is; + | Some e, [is;ieq] -> pr_elem is; pr_elem ieq; pp_expression e + | _ -> raise Impossible + )); + + (match sopt, iis with + | (Some s, [i1;i2;i3;i4]) -> pr_elem i4 + | (Some s, [i1;i2;i3;i4;i5]) -> + pr_elem i5; pr_elem i4 (* trailing comma *) + | (None, [i1;i2;i3]) -> pr_elem i3 + | (None, [i1;i2;i3;i4]) -> + pr_elem i4; pr_elem i3 (* trailing comma *) + + + | x -> raise Impossible + ); + + + | (BaseType _, iis) -> + print_sto_qu_ty (sto, qu, iis); + + | (StructUnionName (s, structunion), iis) -> + assert (List.length iis = 2); + print_sto_qu_ty (sto, qu, iis); + + | (EnumName s, iis) -> + assert (List.length iis = 2); + print_sto_qu_ty (sto, qu, iis); + + | (TypeName (s,_typ), iis) -> + assert (List.length iis = 1); + print_sto_qu_ty (sto, qu, iis); + + | (TypeOfExpr (e), iis) -> + print_sto_qu (sto, qu); + (match iis with + | [itypeof;iopar;icpar] -> + pr_elem itypeof; pr_elem iopar; + pp_expression e; + pr_elem icpar; + | _ -> raise Impossible + ) + + | (TypeOfType (t), iis) -> + print_sto_qu (sto, qu); + (match iis with + | [itypeof;iopar;icpar] -> + pr_elem itypeof; pr_elem iopar; + pp_type t; + pr_elem icpar; + | _ -> raise Impossible + ) + + | (Pointer _ | (*ParenType _ |*) Array _ | FunctionType _ + (* | StructUnion _ | Enum _ | BaseType _ *) + (* | StructUnionName _ | EnumName _ | TypeName _ *) + (* | TypeOfExpr _ | TypeOfType _ *) + ), _ -> raise Impossible + + + +(* used because of DeclList, in int i,*j[23]; we dont print anymore the + int before *j *) + and (pp_type_with_ident_rest: (string * info) option -> + fullType -> attribute list -> unit) = + + fun ident (((qu, iiqu), (ty, iity)) as fullt) attrs -> + let print_ident ident = Common.do_option (fun (s, iis) -> + (* XXX attrs +> pp_attributes pr_elem pr_space; *) + pr_elem iis + ) ident + in + + match ty, iity with + (* the work is to do in base_type !! *) + | (BaseType _, iis) -> print_ident ident + | (Enum (sopt, enumt), iis) -> print_ident ident + | (StructUnion (_, sopt, fields),iis) -> print_ident ident + | (StructUnionName (s, structunion), iis) -> print_ident ident + | (EnumName s, iis) -> print_ident ident + | (TypeName (s,_typ), iis) -> print_ident ident + | (TypeOfExpr (e), iis) -> print_ident ident + | (TypeOfType (e), iis) -> print_ident ident + + + + | (Pointer t, [i]) -> + (* subtil: void ( *done)(int i) is a Pointer + (FunctionType (return=void, params=int i) *) + (*WRONG I THINK, use left & right function *) + (* bug: pp_type_with_ident_rest None t; print_ident ident *) + pr_elem i; + iiqu +> List.iter pr_elem; (* le const est forcement apres le '*' *) + pp_type_with_ident_rest ident t attrs; + + (* ugly special case ... todo? maybe sufficient in practice *) + | (ParenType (q1, (Pointer (q2, (FunctionType t, ii3)) , + [ipointer]) ), [i1;i2]) -> + pp_type_left (q2, (FunctionType t, ii3)); + pr_elem i1; + pr_elem ipointer; + print_ident ident; + pr_elem i2; + pp_type_right (q2, (FunctionType t, ii3)); + + (* another ugly special case *) + | (ParenType + (q1, (Array (eopt, + (q2, (Pointer + (q3, (FunctionType t, iifunc)), + [ipointer]))), + [iarray1;iarray2])), [i1;i2]) -> + pp_type_left (q3, (FunctionType t, iifunc)); + pr_elem i1; + pr_elem ipointer; + print_ident ident; + pr_elem iarray1; + do_option pp_expression eopt; + pr_elem iarray2; + pr_elem i2; + pp_type_right (q3, (FunctionType t, iifunc)) + + + + | (ParenType t, [i1;i2]) -> + pr2 "PB PARENTYPE ZARB, I forget about the ()"; + pp_type_with_ident_rest ident t attrs; + + + | (Array (eopt, t), [i1;i2]) -> + pp_type_left fullt; + + iiqu +> List.iter pr_elem; + print_ident ident; + + pp_type_right fullt; + + + | (FunctionType (returnt, paramst), [i1;i2]) -> + pp_type_left fullt; + + iiqu +> List.iter pr_elem; + print_ident ident; + + pp_type_right fullt; + + + | (FunctionType _ | Array _ | ParenType _ | Pointer _), _ -> + raise Impossible + + + and (pp_type_left: fullType -> unit) = + fun ((qu, iiqu), (ty, iity)) -> + match ty, iity with + | (Pointer t, [i]) -> + pr_elem i; + iiqu +> List.iter pr_elem; (* le const est forcement apres le '*' *) + pp_type_left t + + | (Array (eopt, t), [i1;i2]) -> pp_type_left t + | (FunctionType (returnt, paramst), [i1;i2]) -> pp_type_left returnt + + | (ParenType t, _) -> failwith "parenType" + + + | (BaseType _, iis) -> () + | (Enum (sopt, enumt), iis) -> () + | (StructUnion (_, sopt, fields),iis) -> () + | (StructUnionName (s, structunion), iis) -> () + | (EnumName s, iis) -> () + | (TypeName (s,_typ), iis) -> () + + | TypeOfType _, _ -> () + | TypeOfExpr _, _ -> () + + | (FunctionType _ | Array _ | Pointer _), _ -> raise Impossible + + + and pp_param ((b, sopt, t), ii_b_s) = + match b, sopt, ii_b_s with + | false, None, [] -> + pp_type t + | true, None, [i1] -> + pr_elem i1; + pp_type t + + | false, Some s, [i1] -> + pp_type_with_ident + (Some (s, i1)) None t Ast_c.noattr; + | true, Some s, [i1;i2] -> + pr_elem i1; + pp_type_with_ident + (Some (s, i2)) None t Ast_c.noattr; + | _ -> raise Impossible + + + and pp_type_right (((qu, iiqu), (ty, iity)) : fullType) = + match ty, iity with + | (Pointer t, [i]) -> pp_type_right t + + | (Array (eopt, t), [i1;i2]) -> + pr_elem i1; + eopt +> do_option pp_expression; + pr_elem i2; + pp_type_right t + + | (ParenType t, _) -> failwith "parenType" + | (FunctionType (returnt, paramst), [i1;i2]) -> + pr_elem i1; + (match paramst with + | (ts, (b, iib)) -> + ts +> List.iter (fun (param,iicomma) -> + assert ((List.length iicomma) <= 1); + iicomma +> List.iter (function x -> pr_elem x; pr_space()); + + pp_param param; + ); + iib +> List.iter pr_elem; + ); + pr_elem i2 + + | (BaseType _, iis) -> () + | (Enum (sopt, enumt), iis) -> () + | (StructUnion (_, sopt, fields),iis)-> () + | (StructUnionName (s, structunion), iis) -> () + | (EnumName s, iis) -> () + | (TypeName (s,_typ), iis) -> () + + | TypeOfType _, _ -> () + | TypeOfExpr _, _ -> () + + | (FunctionType _ | Array _ | Pointer _), _ -> raise Impossible + + and pp_type t = + pp_type_with_ident None None t Ast_c.noattr + +(* ---------------------- *) + and pp_decl = function + | DeclList ((({v_namei = var; v_type = returnType; + v_storage = storage; v_attr = attrs; + },[])::xs), + iivirg::ifakestart::iisto) -> + + pr_elem ifakestart; + + (* old: iisto +> List.iter pr_elem; *) + + + (* handling the first var. Special case, we print the whole type *) + (match var with + | Some ((s, ini), iis::iini) -> + pp_type_with_ident + (Some (s, iis)) (Some (storage, iisto)) + returnType attrs; + ini +> do_option (fun init -> + List.iter pr_elem iini; pp_init init); + | None -> pp_type returnType + | _ -> raise Impossible + ); + + (* for other vars, we just call pp_type_with_ident_rest. *) + xs +> List.iter (function + | ({v_namei = Some ((s, ini), iis::iini); + v_type = returnType; + v_storage = storage2; + v_attr = attrs; + }, iivirg) -> + + assert (storage2 = storage); + iivirg +> List.iter pr_elem; + pp_type_with_ident_rest + (Some (s, iis)) returnType attrs; + ini +> do_option (fun (init) -> + List.iter pr_elem iini; pp_init init); + + + | x -> raise Impossible + ); + + pr_elem iivirg; + + | MacroDecl ((s, es), iis::lp::rp::iiend::ifakestart::iisto) -> + pr_elem ifakestart; + iisto +> List.iter pr_elem; (* static and const *) + pr_elem iis; + pr_elem lp; + es +> List.iter (fun (e, opt) -> + assert (List.length opt <= 1); + opt +> List.iter pr_elem; + pp_argument e; + ); + + pr_elem rp; + pr_elem iiend; + + | (DeclList (_, _) | (MacroDecl _)) -> raise Impossible + + +(* ---------------------- *) +and pp_init (init, iinit) = + match init, iinit with + | InitExpr e, [] -> pp_expression e; + | InitList xs, i1::i2::iicommaopt -> + pr_elem i1; start_block(); + xs +> List.iter (fun (x, ii) -> + assert (List.length ii <= 1); + ii +> List.iter (function e -> pr_elem e; pr_nl()); + pp_init x + ); + iicommaopt +> List.iter pr_elem; + end_block(); + pr_elem i2; + + | InitDesignators (xs, initialiser), [i1] -> (* : *) + xs +> List.iter pp_designator; + pr_elem i1; + pp_init initialiser + + (* no use of '=' in the "Old" style *) + | InitFieldOld (string, initialiser), [i1;i2] -> (* label: in oldgcc *) + pr_elem i1; pr_elem i2; pp_init initialiser + | InitIndexOld (expression, initialiser), [i1;i2] -> (* [1] in oldgcc *) + pr_elem i1; pp_expression expression; pr_elem i2; + pp_init initialiser + + | (InitIndexOld _ | InitFieldOld _ | InitDesignators _ + | InitList _ | InitExpr _ + ), _ -> raise Impossible + + + + and pp_designator = function + | DesignatorField (s), [i1; i2] -> + pr_elem i1; pr_elem i2; + | DesignatorIndex (expression), [i1;i2] -> + pr_elem i1; pp_expression expression; pr_elem i2; + + | DesignatorRange (e1, e2), [iocro;iellipsis;iccro] -> + pr_elem iocro; pp_expression e1; pr_elem iellipsis; + pp_expression e2; pr_elem iccro; + + | (DesignatorField _ | DesignatorIndex _ | DesignatorRange _ + ), _ -> raise Impossible + + +(* ---------------------- *) + and pp_attributes pr_elem pr_space attrs = + attrs +> List.iter (fun (attr, ii) -> + ii +> List.iter pr_elem; + ); + +(* ---------------------- *) + and pp_def def = + let defbis, ii = def in + match ii with + | is::iifunc1::iifunc2::i1::i2::ifakestart::isto -> + + let {f_name = s; + f_type = (returnt, (paramst, (b, iib))); + f_storage = sto; + f_body = statxs; + f_attr = attrs; + } = defbis + in + + pr_elem ifakestart; + + pp_type_with_ident None (Some (sto, isto)) + returnt Ast_c.noattr; + + pp_attributes pr_elem pr_space attrs; + pr_elem is; + + + pr_elem iifunc1; + + (* not anymore, cf tests/optional_name_parameter and + macro_parameter_shortcut.c + (match paramst with + | [(((bool, None, t), ii_b_s), iicomma)] -> + assert + (match t with + | qu, (BaseType Void, ii) -> true + | _ -> true + ); + assert (null iicomma); + assert (null ii_b_s); + pp_type_with_ident None None t + + | paramst -> + paramst +> List.iter (fun (((bool, s, t), ii_b_s), iicomma) -> + iicomma +> List.iter pr_elem; + + (match b, s, ii_b_s with + | false, Some s, [i1] -> + pp_type_with_ident (Some (s, i1)) None t; + | true, Some s, [i1;i2] -> + pr_elem i1; + pp_type_with_ident (Some (s, i2)) None t; + + (* in definition we have name for params, except when f(void) *) + | _, None, _ -> raise Impossible + | false, None, [] -> + + | _ -> raise Impossible + ))); + + (* normally ii represent the ",..." but it is also abused + with the f(void) case *) + (* assert (List.length iib <= 2);*) + iib +> List.iter pr_elem; + + *) + paramst +> List.iter (fun (param,iicomma) -> + assert ((List.length iicomma) <= 1); + iicomma +> List.iter (function x -> pr_elem x; pr_space()); + + pp_param param; + ); + iib +> List.iter pr_elem; + + + pr_elem iifunc2; + pr_elem i1; + statxs +> List.iter pp_statement_seq; + pr_elem i2; + | _ -> raise Impossible + + + +(* ---------------------- *) + + and pp_ifdef ifdef = + match ifdef with + | IfdefDirective (ifdef, ii) -> + List.iter pr_elem ii + + + and pp_directive = function + | Include {i_include = (s, ii);} -> + let (i1,i2) = Common.tuple_of_list2 ii in + pr_elem i1; pr_elem i2 + | Define ((s,ii), (defkind, defval)) -> + let (idefine,iident,ieol) = Common.tuple_of_list3 ii in + pr_elem idefine; + pr_elem iident; + + let define_val = function + | DefineExpr e -> pp_expression e + | DefineStmt st -> pp_statement st + | DefineDoWhileZero ((st,e), ii) -> + (match ii with + | [ido;iwhile;iopar;icpar] -> + pr_elem ido; + pp_statement st; + pr_elem iwhile; pr_elem iopar; + pp_expression e; + pr_elem icpar + | _ -> raise Impossible + ) + | DefineFunction def -> pp_def def + + | DefineType ty -> pp_type ty + | DefineText (s, ii) -> List.iter pr_elem ii + | DefineEmpty -> () + | DefineInit ini -> pp_init ini + + | DefineTodo -> pr2 "DefineTodo" + in + (match defkind with + | DefineVar -> () + | DefineFunc (params, ii) -> + let (i1,i2) = tuple_of_list2 ii in + pr_elem i1; + params +> List.iter (fun ((s,iis), iicomma) -> + assert (List.length iicomma <= 1); + iicomma +> List.iter pr_elem; + iis +> List.iter pr_elem; + ); + pr_elem i2; + ); + define_val defval; + pr_elem ieol + + | Undef (s, ii) -> + List.iter pr_elem ii + | PragmaAndCo (ii) -> + List.iter pr_elem ii in + + + + + let pp_toplevel = function + | Declaration decl -> pp_decl decl + | Definition def -> pp_def def + + | CppTop directive -> pp_directive directive + + + | MacroTop (s, es, [i1;i2;i3;i4]) -> + pr_elem i1; + pr_elem i2; + es +> List.iter (fun (e, opt) -> + assert (List.length opt <= 1); + opt +> List.iter pr_elem; + pp_argument e; + ); + pr_elem i3; + pr_elem i4; + + + | EmptyDef ii -> ii +> List.iter pr_elem + | NotParsedCorrectly ii -> + assert (List.length ii >= 1); + ii +> List.iter pr_elem + | FinalDef info -> pr_elem (Ast_c.rewrap_str "" info) + + | IfdefTop ifdefdir -> pp_ifdef ifdefdir + + | (MacroTop _) -> raise Impossible in + + + + + let pp_flow n = + match F.unwrap n with + | F.FunHeader ({f_name =idb; + f_type = (rett, (paramst,(isvaargs,iidotsb))); + f_storage = stob; + f_body = body; + f_attr = attrs},ii) -> + + assert(null body); + (* + iif ii; + iif iidotsb; + attrs +> List.iter (vk_attribute bigf); + vk_type bigf rett; + paramst +> List.iter (fun (param, iicomma) -> + vk_param bigf param; + iif iicomma; + ); + *) + pr2 "Def"; + + + | F.Decl decl -> + (* vk_decl bigf decl *) + pr2 "Decl" + + | F.ExprStatement (st, (eopt, ii)) -> + pp_statement (ExprStatement eopt, ii) + + | F.IfHeader (_, (e,ii)) + | F.SwitchHeader (_, (e,ii)) + | F.WhileHeader (_, (e,ii)) + | F.DoWhileTail (e,ii) -> + (* + iif ii; + vk_expr bigf e + *) + pr2 "XXX"; + + + | F.ForHeader (_st, (((e1opt,i1), (e2opt,i2), (e3opt,i3)), ii)) -> + (* + iif i1; iif i2; iif i3; + iif ii; + e1opt +> do_option (vk_expr bigf); + e2opt +> do_option (vk_expr bigf); + e3opt +> do_option (vk_expr bigf); + *) + pr2 "XXX" + + | F.MacroIterHeader (_s, ((s,es), ii)) -> + (* + iif ii; + vk_argument_list bigf es; + *) + pr2 "XXX" + + + | F.ReturnExpr (_st, (e,ii)) -> + (* iif ii; vk_expr bigf e*) + pr2 "XXX" + + + | F.Case (_st, (e,ii)) -> + (* iif ii; vk_expr bigf e *) + pr2 "XXX" + + | F.CaseRange (_st, ((e1, e2),ii)) -> + (* iif ii; vk_expr bigf e1; vk_expr bigf e2 *) + pr2 "XXX" + + + + | F.CaseNode i -> () + + | F.DefineExpr e -> + (* vk_expr bigf e *) + pr2 "XXX" + + | F.DefineType ft -> + (* vk_type bigf ft *) + pr2 "XXX" + + | F.DefineHeader ((s,ii), (defkind)) -> + (* + iif ii; + vk_define_kind bigf defkind; + *) + pr2 "XXX" + + + | F.DefineDoWhileZeroHeader (((),ii)) -> + (* iif ii *) + pr2 "XXX" + + + | F.Include {i_include = (s, ii);} -> + (* iif ii; *) + pr2 "XXX" + + + | F.MacroTop (s, args, ii) -> + (* iif ii; + vk_argument_list bigf args *) + pr2 "XXX" + + + | F.Break (st,((),ii)) -> + (* iif ii *) + pr2 "XXX" + | F.Continue (st,((),ii)) -> + (* iif ii *) + pr2 "XXX" + | F.Default (st,((),ii)) -> + (* iif ii *) + pr2 "XXX" + | F.Return (st,((),ii)) -> + (* iif ii *) + pr2 "XXX" + | F.Goto (st, (s,ii)) -> + (* iif ii *) + pr2 "XXX" + | F.Label (st, (s,ii)) -> + (* iif ii *) + pr2 "XXX" + | F.EndStatement iopt -> + (* do_option infof iopt *) + pr2 "XXX" + | F.DoHeader (st, info) -> + (* infof info *) + pr2 "XXX" + | F.Else info -> + (* infof info *) + pr2 "XXX" + | F.SeqEnd (i, info) -> + (* infof info *) + pr2 "XXX" + | F.SeqStart (st, i, info) -> + (* infof info *) + pr2 "XXX" + + | F.MacroStmt (st, ((),ii)) -> + (* iif ii *) + pr2 "XXX" + | F.Asm (st, (asmbody,ii)) -> + (* + iif ii; + vk_asmbody bigf asmbody + *) + pr2 "XXX" + + + | F.IfdefHeader (info) -> + pp_ifdef info + | F.IfdefElse (info) -> + pp_ifdef info + | F.IfdefEndif (info) -> + pp_ifdef info + + | F.DefineTodo -> + pr2 "XXX" + + + | (F.TopNode|F.EndNode| + F.ErrorExit|F.Exit|F.Enter| + F.FallThroughNode|F.AfterNode|F.FalseNode|F.TrueNode|F.InLoopNode| + F.Fake) -> + pr2 "YYY" in + + + {expression = pp_expression; + arg_list = pp_arg_list; + statement = pp_statement; + decl = pp_decl; + init = pp_init; + param = pp_param; + ty = pp_type; + type_with_ident = pp_type_with_ident; + toplevel = pp_toplevel; + flow = pp_flow} + +(*****************************************************************************) + +(* Here we do not use (mcode, env). It is a simple C pretty printer. *) +let pr_elem info = + let s = Ast_c.str_of_info info in + pp s + +let pr_space _ = Format.print_space() + +let pr_nl _ = () +let pr_indent _ = () +let pr_outdent _ = () +let pr_unindent _ = () + +let ppc = + pretty_print_c pr_elem pr_space pr_nl pr_outdent pr_indent pr_unindent + +let pp_expression_simple = ppc.expression +let pp_statement_simple = ppc.statement +let pp_type_simple = ppc.ty +let pp_init_simple = ppc.init +let pp_toplevel_simple = ppc.toplevel +let pp_flow_simple = ppc.flow + +let pp_elem_sp pr_elem pr_space = + pretty_print_c pr_elem pr_space pr_nl pr_outdent pr_indent pr_unindent + +let pp_expression_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).expression + +let pp_arg_list_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).arg_list + +let pp_statement_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).statement + +let pp_decl_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).decl + +let pp_init_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).init + +let pp_param_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).param + +let pp_type_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).ty + +let pp_type_with_ident_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).type_with_ident + +let pp_program_gen pr_elem pr_space = + (pp_elem_sp pr_elem pr_space).toplevel + + + +let string_of_expression e = + Common.format_to_string (fun () -> + pp_expression_simple e + ) + +let (debug_info_of_node: + Ograph_extended.nodei -> Control_flow_c.cflow -> string) = + fun nodei flow -> + let node = flow#nodes#assoc nodei in + let s = Common.format_to_string (fun () -> + pp_flow_simple node + ) in + let pos = Lib_parsing_c.min_pinfo_of_node node in + (spf "%s(n%d)--> %s" (Common.string_of_parse_info_bis pos) nodei s) + diff --git a/parsing_c/pretty_print_c.mli b/parsing_c/pretty_print_c.mli dissimilarity index 81% index 2a2c94b..9e8e475 100644 --- a/parsing_c/pretty_print_c.mli +++ b/parsing_c/pretty_print_c.mli @@ -1,33 +1,64 @@ - -type pr_elem_func = Ast_c.info -> unit -type pr_space_func = unit -> unit - -val pp_expression_gen : - pr_elem_func -> pr_space_func -> Ast_c.expression -> unit -val pp_arg_list_gen : - pr_elem_func -> pr_space_func -> Ast_c.argument Ast_c.wrap2 list -> unit -val pp_statement_gen : pr_elem_func -> pr_space_func -> Ast_c.statement -> unit -val pp_decl_gen : pr_elem_func -> pr_space_func -> Ast_c.declaration -> unit -val pp_init_gen : pr_elem_func -> pr_space_func -> Ast_c.initialiser -> unit -val pp_param_gen : pr_elem_func -> pr_space_func -> Ast_c.parameterType -> unit - -val pp_type_gen : pr_elem_func -> pr_space_func -> Ast_c.fullType -> unit -val pp_type_with_ident_gen : - pr_elem_func -> pr_space_func -> - (string * Ast_c.info) option -> - (Ast_c.storage * Ast_c.il) option -> Ast_c.fullType -> Ast_c.attribute list -> - unit - - -val pp_program_gen : pr_elem_func -> pr_space_func -> Ast_c.toplevel -> unit - -val pp_expression_simple : Ast_c.expression -> unit -val pp_statement_simple : Ast_c.statement -> unit -val pp_type_simple : Ast_c.fullType -> unit -val pp_toplevel_simple : Ast_c.toplevel -> unit -val pp_flow_simple: Control_flow_c.node -> unit - - -val debug_info_of_node: Ograph_extended.nodei -> Control_flow_c.cflow -> string - -val string_of_expression: Ast_c.expression -> string + +type pr_elem_func = Ast_c.info -> unit +type pr_space_func = unit -> unit +type pr_nl_func = unit -> unit +type pr_indent_func = unit -> unit +type pr_outdent_func = unit -> unit +type pr_unindent_func = unit -> unit + +type expression_printer = Ast_c.expression -> unit +type arg_list_printer = Ast_c.argument Ast_c.wrap2 list -> unit +type statement_printer = Ast_c.statement -> unit +type declaration_printer = Ast_c.declaration -> unit +type initialiser_printer = Ast_c.initialiser -> unit +type param_printer = Ast_c.parameterType -> unit +type type_printer = Ast_c.fullType -> unit +type type_with_ident_printer = + (string * Ast_c.info) option -> + (Ast_c.storage * Ast_c.il) option -> Ast_c.fullType -> + Ast_c.attribute list -> unit +type toplevel_printer = Ast_c.toplevel -> unit +type flow_printer = Control_flow_c.node -> unit + +type pretty_printers = + {expression : expression_printer; + arg_list : arg_list_printer; + statement : statement_printer; + decl : declaration_printer; + init : initialiser_printer; + param : param_printer; + ty : type_printer; + type_with_ident : type_with_ident_printer; + toplevel : toplevel_printer; + flow : flow_printer} + +val pretty_print_c : + pr_elem_func -> pr_space_func -> pr_nl_func -> pr_indent_func -> + pr_outdent_func -> pr_unindent_func -> pretty_printers + + +val pp_expression_gen : pr_elem_func -> pr_space_func -> expression_printer +val pp_arg_list_gen : pr_elem_func -> pr_space_func -> arg_list_printer +val pp_statement_gen : pr_elem_func -> pr_space_func -> statement_printer +val pp_decl_gen : pr_elem_func -> pr_space_func -> declaration_printer +val pp_init_gen : pr_elem_func -> pr_space_func -> initialiser_printer +val pp_param_gen : pr_elem_func -> pr_space_func -> param_printer + +val pp_type_gen : pr_elem_func -> pr_space_func -> type_printer +val pp_type_with_ident_gen : + pr_elem_func -> pr_space_func -> type_with_ident_printer + +val pp_program_gen : pr_elem_func -> pr_space_func -> toplevel_printer + + +val pp_expression_simple : expression_printer +val pp_statement_simple : statement_printer +val pp_type_simple : type_printer +val pp_init_simple : initialiser_printer +val pp_toplevel_simple : toplevel_printer +val pp_flow_simple: flow_printer + + +val debug_info_of_node: Ograph_extended.nodei -> Control_flow_c.cflow -> string + +val string_of_expression: Ast_c.expression -> string diff --git a/parsing_c/unparse_c.ml b/parsing_c/unparse_c.ml index 5243a23..045c098 100644 --- a/parsing_c/unparse_c.ml +++ b/parsing_c/unparse_c.ml @@ -1,4 +1,4 @@ -(* Copyright (C) 2006, 2007, 2008 Ecole des Mines de Nantes +(* 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) @@ -147,16 +147,24 @@ 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 -> + | InitList args, ii -> (match ii with | [_i1;_i2] -> ini - | [i1;i2;iicommaopt] -> + | [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 @@ -416,14 +424,15 @@ let remove_minus_and_between_and_expanded_and_fake xs = in (*This drops the space before each completely minused block (no plus code).*) + let minus_or_comment = function + T2(_,true,_) -> true + | T2(Parser_c.TCommentNewline _,_b,_i) -> false + | x -> is_minusable_comment x in + let rec adjust_before_minus = function [] -> [] (* patch: coccinelle *) | (T2(Parser_c.TCommentNewline c,_b,_i) as x)::((T2(_,true,_)::_) as xs) -> - let minus_or_comment = function - T2(_,true,_) -> true - | T2(Parser_c.TCommentNewline _,_b,_i) -> false - | x -> is_minusable_comment x in let (between_minus,rest) = Common.span minus_or_comment xs in (match rest with [] -> (set_minus_comment x) :: between_minus @@ -435,6 +444,34 @@ let remove_minus_and_between_and_expanded_and_fake xs = let xs = adjust_before_minus xs in + (* this drops blank lines after a brace introduced by removing code *) + let rec adjust_after_brace = function + [] -> [] + | ((T2(_,false,_)) as x)::((T2(_,true,_)::_) as xs) + when str_of_token2 x = "{" -> + let (between_minus,rest) = Common.span minus_or_comment 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 drop_newlines)@ + last_newline@ + adjust_after_brace rest + | x::xs -> x::adjust_after_brace xs in + + let xs = adjust_after_brace xs in + (* this deals with any stuff that is between the minused code, eg spaces, comments, attributes, etc. *) (* The use of is_minusable_comment_or_plus and set_minus_comment_or_plus diff --git a/parsing_c/unparse_cocci.ml b/parsing_c/unparse_cocci.ml index b53e58c..aaa631c 100644 --- a/parsing_c/unparse_cocci.ml +++ b/parsing_c/unparse_cocci.ml @@ -35,6 +35,12 @@ let print_string_box s = print_string s in let print_option = Common.do_option in let print_between = Common.print_between in +let outdent _ = () (* should go to leftmost col, does nothing now *) in + +let pretty_print_c = + Pretty_print_c.pretty_print_c pr_elem pr_space + force_newline indent outdent unindent in + (* --------------------------------------------------------------------- *) (* Only for make_hrule, print plus code, unbound metavariables *) @@ -249,14 +255,14 @@ let rec expression e = | Ast.MetaExpr (name,_,_,_typedontcare,_formdontcare,_) -> handle_metavar name (function | Ast_c.MetaExprVal exp -> - Pretty_print_c.pp_expression_gen pr_elem pr_space exp + pretty_print_c.Pretty_print_c.expression exp | _ -> raise Impossible ) | Ast.MetaExprList (name,_,_,_) -> handle_metavar name (function | Ast_c.MetaExprListVal args -> - Pretty_print_c.pp_arg_list_gen pr_elem pr_space args + pretty_print_c.Pretty_print_c.arg_list args | _ -> raise Impossible ) @@ -347,7 +353,7 @@ and constant = function and fullType ft = match Ast.unwrap ft with Ast.Type(cv,ty) -> - print_option (function x -> mcode const_vol x; print_string " ") cv; + print_option (mcode const_vol) cv; typeC ty | Ast.DisjType _ -> failwith "can't be in plus" | Ast.OptType(_) | Ast.UniqueType(_) -> @@ -391,7 +397,7 @@ and typeC ty = | Ast.MetaType(name,_,_) -> handle_metavar name (function Ast_c.MetaTypeVal exp -> - Pretty_print_c.pp_type_gen pr_elem pr_space exp + pretty_print_c.Pretty_print_c.ty exp | _ -> raise Impossible) and baseType = function @@ -507,7 +513,12 @@ and declaration d = and initialiser nlcomma i = match Ast.unwrap i with - Ast.InitExpr(exp) -> expression exp + Ast.MetaInit(name,_,_) -> + handle_metavar name (function + Ast_c.MetaInitVal ini -> + pretty_print_c.Pretty_print_c.init ini + | _ -> raise Impossible) + | Ast.InitExpr(exp) -> expression exp | Ast.InitList(lb,initlist,rb,[]) -> mcode print_string lb; start_block(); (* awkward, because the comma is separate from the initialiser *) @@ -518,26 +529,25 @@ and initialiser nlcomma i = loop initlist; end_block(); mcode print_string rb | Ast.InitList(lb,initlist,rb,_) -> failwith "unexpected whencode in plus" - | Ast.InitGccDotName(dot,name,eq,ini) -> - mcode print_string dot; ident name; print_string " "; + | Ast.InitGccExt(designators,eq,ini) -> + List.iter designator designators; print_string " "; mcode print_string eq; print_string " "; initialiser nlcomma ini | Ast.InitGccName(name,eq,ini) -> ident name; mcode print_string eq; initialiser nlcomma ini - | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> - mcode print_string lb; expression exp; mcode print_string rb; - print_string " "; mcode print_string eq; print_string " "; - initialiser nlcomma ini - | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - mcode print_string lb; expression exp1; mcode print_string dots; - expression exp2; mcode print_string rb; - print_string " "; mcode print_string eq; print_string " "; - initialiser nlcomma ini | Ast.IComma(comma) -> mcode print_string comma; if nlcomma then force_newline() | Ast.OptIni(ini) | Ast.UniqueIni(ini) -> raise CantBeInPlus +and designator = function + Ast.DesignatorField(dot,id) -> mcode print_string dot; ident id + | Ast.DesignatorIndex(lb,exp,rb) -> + mcode print_string lb; expression exp; mcode print_string rb + | Ast.DesignatorRange(lb,min,dots,max,rb) -> + mcode print_string lb; expression min; mcode print_string dots; + expression max; mcode print_string rb + (* --------------------------------------------------------------------- *) (* Parameter *) @@ -602,16 +612,16 @@ and rule_elem arity re = | Ast.IfHeader(iff,lp,exp,rp) -> print_string arity; mcode print_string iff; print_string " "; mcode print_string_box lp; - expression exp; close_box(); mcode print_string rp; print_string " " + expression exp; close_box(); mcode print_string rp | Ast.Else(els) -> - print_string arity; mcode print_string els; print_string " " + print_string arity; mcode print_string els | Ast.WhileHeader(whl,lp,exp,rp) -> print_string arity; mcode print_string whl; print_string " "; mcode print_string_box lp; - expression exp; close_box(); mcode print_string rp; print_string " " + expression exp; close_box(); mcode print_string rp | Ast.DoHeader(d) -> - print_string arity; mcode print_string d; print_string " " + print_string arity; mcode print_string d | Ast.WhileTail(whl,lp,exp,rp,sem) -> print_string arity; mcode print_string whl; print_string " "; mcode print_string_box lp; @@ -623,17 +633,17 @@ and rule_elem arity re = print_option expression e1; mcode print_string sem1; print_option expression e2; mcode print_string sem2; print_option expression e3; close_box(); - mcode print_string rp; print_string " " + mcode print_string rp | Ast.IteratorHeader(nm,lp,args,rp) -> print_string arity; ident nm; print_string " "; mcode print_string_box lp; dots (function _ -> ()) expression args; close_box(); - mcode print_string rp; print_string " " + mcode print_string rp | Ast.SwitchHeader(switch,lp,exp,rp) -> print_string arity; mcode print_string switch; print_string " "; mcode print_string_box lp; - expression exp; close_box(); mcode print_string rp; print_string " " + expression exp; close_box(); mcode print_string rp | Ast.Break(br,sem) -> print_string arity; mcode print_string br; mcode print_string sem @@ -680,8 +690,8 @@ and rule_elem arity re = | Ast.MetaStmt(name,_,_,_) -> handle_metavar name (function - | Ast_c.MetaStmtVal exp -> - Pretty_print_c.pp_statement_gen pr_elem pr_space exp + | Ast_c.MetaStmtVal stm -> + pretty_print_c.Pretty_print_c.statement stm | _ -> raise Impossible ) | Ast.MetaStmtList(name,_,_) -> @@ -712,7 +722,7 @@ and print_fninfo = function let indent_if_needed s f = match Ast.unwrap s with - Ast.Seq(lbrace,decls,body,rbrace) -> f() + Ast.Seq(lbrace,decls,body,rbrace) -> pr_space(); f() | _ -> (*no newline at the end - someone else will do that*) start_block(); f(); unindent() in @@ -751,7 +761,7 @@ let rec statement arity s = mcode (function _ -> ()) ((),Ast.no_info,aft,Ast.NoMetaPos) | Ast.Switch(header,lb,cases,rb) -> - rule_elem arity header; rule_elem arity lb; + rule_elem arity header; print_string " "; rule_elem arity lb; List.iter (function x -> case_line arity x; force_newline()) cases; rule_elem arity rb diff --git a/parsing_c/unparse_hrule.ml b/parsing_c/unparse_hrule.ml index 4eee1e1..847fe45 100644 --- a/parsing_c/unparse_hrule.ml +++ b/parsing_c/unparse_hrule.ml @@ -186,6 +186,7 @@ let print_extra_typedefs pr typedefs env = | Ast_c.MetaParamListVal(params) -> Visitor_c.vk_param_list bigf params | Ast_c.MetaTypeVal(ty) -> Visitor_c.vk_type bigf ty + | Ast_c.MetaInitVal(ty) -> Visitor_c.vk_ini bigf ty | Ast_c.MetaStmtVal(stm) -> Visitor_c.vk_statement bigf stm | Ast_c.MetaPosVal _ | Ast_c.MetaPosValList _ | Ast_c.MetaListlenVal _ -> ()) @@ -219,6 +220,8 @@ let rename argids env = | Ast_c.MetaTypeVal(ty) -> Ast_c.MetaTypeVal(Visitor_c.vk_type_s bigf ty) + | Ast_c.MetaInitVal(ini) -> + Ast_c.MetaInitVal(Visitor_c.vk_ini_s bigf ini) | Ast_c.MetaStmtVal(stm) -> Ast_c.MetaStmtVal(Visitor_c.vk_statement_s bigf stm) | Ast_c.MetaPosVal _ | Ast_c.MetaPosValList _ @@ -244,6 +247,8 @@ let pp_meta_decl pr decl = no_arity ar; pr "fresh identifier "; pp_name name; pr ";\n" | Ast.MetaTypeDecl(ar, name) -> no_arity ar; pr "type "; pp_name name; pr ";\n" + | Ast.MetaInitDecl(ar, name) -> + no_arity ar; pr "initialiser "; pp_name name; pr ";\n" | Ast.MetaListlenDecl(name) -> () | Ast.MetaParamDecl(ar, name) -> no_arity ar; pr "parameter "; pp_name name; pr ";\n" diff --git a/parsing_c/visitor_c.ml b/parsing_c/visitor_c.ml index 152985e..5d87d0c 100644 --- a/parsing_c/visitor_c.ml +++ b/parsing_c/visitor_c.ml @@ -1,4 +1,4 @@ -(* Copyright (C) 2006, 2007, 2008 Ecole des Mines de Nantes +(* Copyright (C) 2006, 2007, 2008, 2009 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) @@ -27,6 +27,88 @@ module F = Control_flow_c (* Functions to visit the Ast, and now also the CFG nodes *) (*****************************************************************************) +(* Why this module ? + * + * The problem is that we manipulate the AST of C programs + * and some of our analysis need only to specify an action for + * specific cases, such as the function call case, and recurse + * for the other cases. + * Here is an simplification of our AST: + * + * type ctype = + * | Basetype of ... + * | Pointer of ctype + * | Array of expression option * ctype + * | ... + * and expression = + * | Ident of string + * | FunCall of expression * expression list + * | Postfix of ... + * | RecordAccess of .. + * | ... + * and statement = + * ... + * and declaration = + * ... + * and program = + * ... + * + * What we want is really write code like + * + * let my_analysis program = + * analyze_all_expressions program (fun expr -> + * match expr with + * | FunCall (e, es) -> do_something() + * | _ -> + * ) + * + * The problem is how to write analyze_all_expressions + * and find_a_way_to_recurse_for_all_the_other_cases. + * + * Our solution is to mix the ideas of visitor, pattern matching, + * and continuation. Here is how it looks like + * using our hybrid-visitor API: + * + * let my_analysis program = + * Visitor.visit_iter program { + * Visitor.kexpr = (fun k e -> + * match e with + * | FunCall (e, es) -> do_something() + * | _ -> k e + * ); + * } + * + * You can of course also give action "hooks" for + * kstatement, ktype, or kdeclaration. But we don't overuse + * visitors and so it would be stupid to provide + * kfunction_call, kident, kpostfix hooks as one can just + * use pattern matching with kexpr to achieve the same effect. + * + * + * + * + * Alternatives: from the caml mailing list: + * "You should have a look at the Camlp4 metaprogramming facilities : + * http://brion.inria.fr/gallium/index.php/Camlp4MapGenerator + * You would write something like" : + * let my_analysis program = + * let analysis = object (self) + * inherit fold as super + * method expr = function + * | FunCall (e, es) -> do_something (); self + * | other -> super#expr other + * end in analysis#expr + * + * Problem is that you don't have control about what is generated + * and in our case we sometimes dont want to visit too much. For instance + * our visitor don't recuse on the type annotation of expressions + * Ok, this could be worked around, but the pb remain, you + * don't have control and at some point you may want. In the same + * way we want to enforce a certain order in the visit (ok this is not good, + * but it's convenient) of ast elements. For instance first + * processing the left part 'e' of a Funcall(e,es), then the arguments 'es'. + * + *) (* Visitor based on continuation. Cleaner than the one based on mutable * pointer functions that I had before. diff --git a/parsing_cocci/.#arity.ml.1.87 b/parsing_cocci/.#arity.ml.1.87 new file mode 100644 index 0000000..3fb1665 --- /dev/null +++ b/parsing_cocci/.#arity.ml.1.87 @@ -0,0 +1,1070 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* Arities matter for the minus slice, but not for the plus slice. *) + +(* ? only allowed on rule_elems, and on subterms if the context is ? also. *) + +module Ast0 = Ast0_cocci +module Ast = Ast_cocci + +(* --------------------------------------------------------------------- *) + +let warning s = Printf.printf "warning: %s\n" s + +let fail w str = + failwith + (Printf.sprintf "cocci line %d: %s" ((Ast0.get_info w).Ast0.line_start) + str) + +let make_opt_unique optfn uniquefn info tgt arity term = + let term = Ast0.rewrap info term in + if tgt = arity + then term + else (* tgt must be NONE *) + match arity with + Ast0.OPT -> Ast0.copywrap info (optfn term) + | Ast0.UNIQUE -> Ast0.copywrap info (uniquefn term) + | Ast0.NONE -> failwith "tgt must be NONE" + +let all_same opt_allowed tgt line arities = + let tgt = + match tgt with + Ast0.NONE -> + (match List.hd arities with + Ast0.OPT when not opt_allowed -> + failwith "opt only allowed for the elements of a statement list" + | x -> x) + | _ -> tgt in + if not(List.for_all (function x -> x = tgt) arities) + then warning (Printf.sprintf "incompatible arity found on line %d" line); + tgt + +let get_option fn = function + None -> None + | Some x -> Some (fn x) + +let anyopt l fn = List.exists (function w -> fn(Ast0.unwrap w)) l + +let allopt l fn = + let rec loop = function + [] -> [] + | x::xs -> + match fn (Ast0.unwrap x) with + Some x -> x :: (loop xs) + | None -> [] in + let res = loop l in + if List.length res = List.length l then Some res else None + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) +(* Mcode *) + +let mcode2line (_,_,info,_,_) = info.Ast0.line_start +let mcode2arity (_,arity,_,_,_) = arity + +let mcode x = x (* nothing to do ... *) + +(* --------------------------------------------------------------------- *) +(* Dots *) + +let dots fn d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(x) -> Ast0.DOTS(List.map fn x) + | Ast0.CIRCLES(x) -> Ast0.CIRCLES(List.map fn x) + | Ast0.STARS(x) -> Ast0.STARS(List.map fn x)) + +let only_dots l = + not + (List.exists + (function x -> + match Ast0.unwrap x with + Ast0.Circles(_,_) | Ast0.Stars(_,_) -> true + | _ -> false) + l) + +let only_circles l = + not (List.exists + (function x -> + match Ast0.unwrap x with + Ast0.Dots(_,_) | Ast0.Stars(_,_) -> true + | _ -> false) + l) + +let only_stars l = + not (List.exists + (function x -> + match Ast0.unwrap x with + Ast0.Dots(_,_) | Ast0.Circles(_,_) -> true + | _ -> false) + l) + +let concat_dots fn d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(x) -> + let l = List.map fn x in + if only_dots l + then Ast0.DOTS(l) + else fail d "inconsistent dots usage" + | Ast0.CIRCLES(x) -> + let l = List.map fn x in + if only_circles l + then Ast0.CIRCLES(l) + else fail d "inconsistent dots usage" + | Ast0.STARS(x) -> + let l = List.map fn x in + if only_stars l + then Ast0.STARS(l) + else fail d "inconsistent dots usage") + +let flat_concat_dots fn d = + match Ast0.unwrap d with + Ast0.DOTS(x) -> List.map fn x + | Ast0.CIRCLES(x) -> List.map fn x + | Ast0.STARS(x) -> List.map fn x + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +let make_id = + make_opt_unique + (function x -> Ast0.OptIdent x) + (function x -> Ast0.UniqueIdent x) + +let ident opt_allowed tgt i = + match Ast0.unwrap i with + Ast0.Id(name) -> + let arity = + all_same opt_allowed tgt (mcode2line name) + [mcode2arity name] in + let name = mcode name in + make_id i tgt arity (Ast0.Id(name)) + | Ast0.MetaId(name,constraints,pure) -> + let arity = + all_same opt_allowed tgt (mcode2line name) + [mcode2arity name] in + let name = mcode name in + make_id i tgt arity (Ast0.MetaId(name,constraints,pure)) + | Ast0.MetaFunc(name,constraints,pure) -> + let arity = + all_same opt_allowed tgt (mcode2line name) + [mcode2arity name] in + let name = mcode name in + make_id i tgt arity (Ast0.MetaFunc(name,constraints,pure)) + | Ast0.MetaLocalFunc(name,constraints,pure) -> + let arity = + all_same opt_allowed tgt (mcode2line name) + [mcode2arity name] in + let name = mcode name in + make_id i tgt arity (Ast0.MetaLocalFunc(name,constraints,pure)) + | Ast0.OptIdent(_) | Ast0.UniqueIdent(_) -> + failwith "unexpected code" + +(* --------------------------------------------------------------------- *) +(* Expression *) + +let make_exp = + make_opt_unique + (function x -> Ast0.OptExp x) + (function x -> Ast0.UniqueExp x) + +let rec top_expression opt_allowed tgt expr = + let exp_same = all_same opt_allowed tgt in + match Ast0.unwrap expr with + Ast0.Ident(id) -> + let new_id = ident opt_allowed tgt id in + Ast0.rewrap expr + (match Ast0.unwrap new_id with + Ast0.OptIdent(id) -> + Ast0.OptExp(Ast0.rewrap expr (Ast0.Ident(id))) + | Ast0.UniqueIdent(id) -> + Ast0.UniqueExp(Ast0.rewrap expr (Ast0.Ident(id))) + | _ -> Ast0.Ident(new_id)) + | Ast0.Constant(const) -> + let arity = exp_same (mcode2line const) [mcode2arity const] in + let const = mcode const in + make_exp expr tgt arity (Ast0.Constant(const)) + | Ast0.FunCall(fn,lp,args,rp) -> + let arity = exp_same (mcode2line lp) [mcode2arity lp;mcode2arity rp] in + let fn = expression arity fn in + let lp = mcode lp in + let args = dots (expression arity) args in + let rp = mcode rp in + make_exp expr tgt arity (Ast0.FunCall(fn,lp,args,rp)) + | Ast0.Assignment(left,op,right,simple) -> + let arity = exp_same (mcode2line op) [mcode2arity op] in + let left = expression arity left in + let op = mcode op in + let right = expression arity right in + make_exp expr tgt arity (Ast0.Assignment(left,op,right,simple)) + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> + let arity = + exp_same (mcode2line why) [mcode2arity why; mcode2arity colon] in + let exp1 = expression arity exp1 in + let why = mcode why in + let exp2 = get_option (expression arity) exp2 in + let colon = mcode colon in + let exp3 = expression arity exp3 in + make_exp expr tgt arity (Ast0.CondExpr(exp1,why,exp2,colon,exp3)) + | Ast0.Postfix(exp,op) -> + let arity = exp_same (mcode2line op) [mcode2arity op] in + let exp = expression arity exp in + let op = mcode op in + make_exp expr tgt arity (Ast0.Postfix(exp,op)) + | Ast0.Infix(exp,op) -> + let arity = exp_same (mcode2line op) [mcode2arity op] in + let exp = expression arity exp in + let op = mcode op in + make_exp expr tgt arity (Ast0.Infix(exp,op)) + | Ast0.Unary(exp,op) -> + let arity = exp_same (mcode2line op) [mcode2arity op] in + let exp = expression arity exp in + let op = mcode op in + make_exp expr tgt arity (Ast0.Unary(exp,op)) + | Ast0.Binary(left,op,right) -> + let arity = exp_same (mcode2line op) [mcode2arity op] in + let left = expression arity left in + let op = mcode op in + let right = expression arity right in + make_exp expr tgt arity (Ast0.Binary(left,op,right)) + | Ast0.Nested(left,op,right) -> failwith "nested in arity not possible" + | Ast0.Paren(lp,exp,rp) -> + let arity = exp_same (mcode2line lp) [mcode2arity lp;mcode2arity rp] in + let lp = mcode lp in + let exp = expression arity exp in + let rp = mcode rp in + make_exp expr tgt arity (Ast0.Paren(lp,exp,rp)) + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> + let arity = exp_same (mcode2line lb) [mcode2arity lb; mcode2arity rb] in + let exp1 = expression arity exp1 in + let lb = mcode lb in + let exp2 = expression arity exp2 in + let rb = mcode rb in + make_exp expr tgt arity (Ast0.ArrayAccess(exp1,lb,exp2,rb)) + | Ast0.RecordAccess(exp,pt,field) -> + let arity = exp_same (mcode2line pt) [mcode2arity pt] in + let exp = expression arity exp in + let pt = mcode pt in + let field = ident false arity field in + make_exp expr tgt arity (Ast0.RecordAccess(exp,pt,field)) + | Ast0.RecordPtAccess(exp,ar,field) -> + let arity = exp_same (mcode2line ar) [mcode2arity ar] in + let exp = expression arity exp in + let ar = mcode ar in + let field = ident false arity field in + make_exp expr tgt arity (Ast0.RecordPtAccess(exp,ar,field)) + | Ast0.Cast(lp,ty,rp,exp) -> + let arity = exp_same (mcode2line lp) [mcode2arity lp;mcode2arity rp] in + let lp = mcode lp in + let ty = typeC arity ty in + let rp = mcode rp in + let exp = expression arity exp in + make_exp expr tgt arity (Ast0.Cast(lp,ty,rp,exp)) + | Ast0.SizeOfExpr(szf,exp) -> + let arity = exp_same (mcode2line szf) [mcode2arity szf] in + let szf = mcode szf in + let exp = expression arity exp in + make_exp expr tgt arity (Ast0.SizeOfExpr(szf,exp)) + | Ast0.SizeOfType(szf,lp,ty,rp) -> + let arity = + exp_same (mcode2line szf) (List.map mcode2arity [szf;lp;rp]) in + let szf = mcode szf in + let lp = mcode lp in + let ty = typeC arity ty in + let rp = mcode rp in + make_exp expr tgt arity (Ast0.SizeOfType(szf,lp,ty,rp)) + | Ast0.TypeExp(ty) -> Ast0.rewrap expr (Ast0.TypeExp(typeC tgt ty)) + | Ast0.MetaErr(name,constraints,pure) -> + let arity = exp_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_exp expr tgt arity (Ast0.MetaErr(name,constraints,pure)) + | Ast0.MetaExpr(name,constraints,ty,form,pure) -> + let arity = exp_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_exp expr tgt arity (Ast0.MetaExpr(name,constraints,ty,form,pure)) + | Ast0.MetaExprList(name,lenname,pure) -> + let arity = exp_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_exp expr tgt arity (Ast0.MetaExprList(name,lenname,pure)) + | Ast0.EComma(cm) -> + let arity = exp_same (mcode2line cm) [mcode2arity cm] in + let cm = mcode cm in + make_exp expr tgt arity (Ast0.EComma(cm)) + | Ast0.DisjExpr(starter,exps,mids,ender) -> + let exps = List.map (top_expression opt_allowed tgt) exps in + (match List.rev exps with + _::xs -> + if anyopt xs (function Ast0.OptExp(_) -> true | _ -> false) + 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) -> + let res = + Ast0.NestExpr(starter, + dots (top_expression true Ast0.NONE) exp_dots, + ender,whencode,multi) in + Ast0.rewrap expr res + | 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 + make_exp expr tgt arity (Ast0.Edots(dots,whencode)) + | Ast0.Ecircles(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 + make_exp expr tgt arity (Ast0.Ecircles(dots,whencode)) + | Ast0.Estars(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 + make_exp expr tgt arity (Ast0.Estars(dots,whencode)) + | Ast0.OptExp(_) | Ast0.UniqueExp(_) -> + failwith "unexpected code" + +and expression tgt exp = top_expression false tgt exp + +(* --------------------------------------------------------------------- *) +(* Types *) + +and make_typeC = + make_opt_unique + (function x -> Ast0.OptType x) + (function x -> Ast0.UniqueType x) + +and top_typeC tgt opt_allowed typ = + match Ast0.unwrap typ with + Ast0.ConstVol(cv,ty) -> + let arity = all_same opt_allowed tgt (mcode2line cv) + [mcode2arity cv] in + let cv = mcode cv in + let ty = typeC arity ty in + make_typeC typ tgt arity (Ast0.ConstVol(cv,ty)) + | Ast0.BaseType(ty,strings) -> + let arity = + all_same opt_allowed tgt (mcode2line (List.hd strings)) + (List.map mcode2arity strings) in + let strings = List.map mcode strings in + make_typeC typ tgt arity (Ast0.BaseType(ty,strings)) + | Ast0.Signed(sign,ty) -> + let arity = + all_same opt_allowed tgt (mcode2line sign) [mcode2arity sign] in + let sign = mcode sign in + let ty = get_option (typeC arity) ty in + make_typeC typ tgt arity (Ast0.Signed(sign,ty)) + | Ast0.Pointer(ty,star) -> + let arity = + all_same opt_allowed tgt (mcode2line star) [mcode2arity star] in + let ty = typeC arity ty in + let star = mcode star in + make_typeC typ tgt arity (Ast0.Pointer(ty,star)) + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + let arity = + all_same opt_allowed tgt (mcode2line lp1) + (List.map mcode2arity [lp1;star;rp1;lp2;rp2]) in + let ty = typeC arity ty in + let params = parameter_list tgt params in + make_typeC typ tgt arity + (Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2)) + | Ast0.FunctionType(ty,lp1,params,rp1) -> + let arity = + all_same opt_allowed tgt (mcode2line lp1) + (List.map mcode2arity [lp1;rp1]) in + let ty = get_option (typeC arity) ty in + let params = parameter_list tgt params in + make_typeC typ tgt arity (Ast0.FunctionType(ty,lp1,params,rp1)) + | Ast0.Array(ty,lb,size,rb) -> + let arity = + all_same opt_allowed tgt (mcode2line lb) + [mcode2arity lb;mcode2arity rb] in + let ty = typeC arity ty in + let lb = mcode lb in + let size = get_option (expression arity) size in + let rb = mcode rb in + make_typeC typ tgt arity (Ast0.Array(ty,lb,size,rb)) + | Ast0.EnumName(kind,name) -> + let arity = + all_same opt_allowed tgt (mcode2line kind) [mcode2arity kind] in + let kind = mcode kind in + let name = ident false arity name in + make_typeC typ tgt arity (Ast0.EnumName(kind,name)) + | Ast0.StructUnionName(kind,name) -> + let arity = + all_same opt_allowed tgt (mcode2line kind) + [mcode2arity kind] in + let kind = mcode kind in + let name = get_option (ident false arity) name in + make_typeC typ tgt arity (Ast0.StructUnionName(kind,name)) + | Ast0.StructUnionDef(ty,lb,decls,rb) -> + let arity = + all_same opt_allowed tgt (mcode2line lb) + (List.map mcode2arity [lb;rb]) in + let ty = typeC arity ty in + let lb = mcode lb in + let decls = dots (declaration tgt) decls in + let rb = mcode rb in + make_typeC typ tgt arity (Ast0.StructUnionDef(ty,lb,decls,rb)) + | Ast0.TypeName(name) -> + let arity = + all_same opt_allowed tgt (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_typeC typ tgt arity (Ast0.TypeName(name)) + | Ast0.MetaType(name,pure) -> + let arity = + all_same opt_allowed tgt (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_typeC typ tgt arity (Ast0.MetaType(name,pure)) + | Ast0.DisjType(starter,types,mids,ender) -> + let types = List.map (typeC tgt) types in + (match List.rev types with + _::xs -> + if anyopt xs (function Ast0.OptType(_) -> true | _ -> false) + then fail typ "opt only allowed in the last disjunct" + | _ -> ()); + let res = Ast0.DisjType(starter,types,mids,ender) in + Ast0.rewrap typ res + | Ast0.OptType(_) | Ast0.UniqueType(_) -> + failwith "unexpected code" + +and typeC tgt ty = top_typeC tgt false ty + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and make_decl = + make_opt_unique + (function x -> Ast0.OptDecl x) + (function x -> Ast0.UniqueDecl x) + +and declaration tgt decl = + match Ast0.unwrap decl with + Ast0.Init(stg,ty,id,eq,exp,sem) -> + let arity = + all_same true tgt (mcode2line eq) + ((match stg with None -> [] | Some x -> [mcode2arity x]) @ + (List.map mcode2arity [eq;sem])) in + let stg = get_option mcode stg in + let ty = typeC arity ty in + let id = ident false arity id in + let eq = mcode eq in + let exp = initialiser arity exp in + let sem = mcode sem in + make_decl decl tgt arity (Ast0.Init(stg,ty,id,eq,exp,sem)) + | Ast0.UnInit(stg,ty,id,sem) -> + let arity = + all_same true tgt (mcode2line sem) + ((match stg with None -> [] | Some x -> [mcode2arity x]) @ + [mcode2arity sem]) in + let stg = get_option mcode stg in + let ty = typeC arity ty in + let id = ident false arity id in + let sem = mcode sem in + make_decl decl tgt arity (Ast0.UnInit(stg,ty,id,sem)) + | Ast0.MacroDecl(name,lp,args,rp,sem) -> + let arity = + all_same true tgt (mcode2line lp) (List.map mcode2arity [lp;rp;sem]) in + let name = ident false arity name in + let lp = mcode lp in + let args = dots (expression arity) args in + let rp = mcode rp in + let sem = mcode sem in + make_decl decl tgt arity (Ast0.MacroDecl(name,lp,args,rp,sem)) + | Ast0.TyDecl(ty,sem) -> + let arity = + all_same true tgt (mcode2line sem) [mcode2arity sem] in + let ty = typeC arity ty in + let sem = mcode sem in + make_decl decl tgt arity (Ast0.TyDecl(ty,sem)) + | Ast0.Typedef(stg,ty,id,sem) -> + let arity = + all_same true tgt (mcode2line sem) + [mcode2arity stg;mcode2arity sem] in + let stg = mcode stg in + let ty = typeC arity ty in + let id = typeC arity id in + let sem = mcode sem in + make_decl decl tgt arity (Ast0.Typedef(stg,ty,id,sem)) + | Ast0.DisjDecl(starter,decls,mids,ender) -> + let decls = List.map (declaration tgt) decls in + (match List.rev decls with + _::xs -> + if anyopt xs (function Ast0.OptDecl(_) -> true | _ -> false) + then fail decl "opt only allowed in the last disjunct" + | _ -> ()); + let res = Ast0.DisjDecl(starter,decls,mids,ender) in + Ast0.rewrap decl res + | Ast0.Ddots(dots,whencode) -> + let arity = all_same true tgt (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + let whencode = get_option (declaration Ast0.NONE) whencode in + make_decl decl tgt arity (Ast0.Ddots(dots,whencode)) + | Ast0.OptDecl(_) | Ast0.UniqueDecl(_) -> + failwith "unexpected code" + +(* --------------------------------------------------------------------- *) +(* Initializer *) + +and make_init = + make_opt_unique + (function x -> Ast0.OptIni x) + (function x -> Ast0.UniqueIni x) + +and initialiser tgt i = + let init_same = all_same true tgt in + match Ast0.unwrap i with + Ast0.InitExpr(exp) -> + Ast0.rewrap i (Ast0.InitExpr(expression tgt exp)) + | Ast0.InitList(lb,initlist,rb) -> + let arity = init_same (mcode2line lb) [mcode2arity lb; mcode2arity rb] in + let lb = mcode lb in + let initlist = dots (initialiser arity) initlist in + let rb = mcode rb in + make_init i tgt arity (Ast0.InitList(lb,initlist,rb)) + | Ast0.InitGccDotName(dot,name,eq,ini) -> + let arity = + init_same (mcode2line dot) [mcode2arity dot; mcode2arity eq] in + let dot = mcode dot in + let name = ident true arity name in + let eq = mcode eq in + let ini = initialiser arity ini in + make_init i tgt arity (Ast0.InitGccDotName(dot,name,eq,ini)) + | Ast0.InitGccName(name,eq,ini) -> + let arity = init_same (mcode2line eq) [mcode2arity eq] in + let name = ident true arity name in + let eq = mcode eq in + let ini = initialiser arity ini in + make_init i tgt arity (Ast0.InitGccName(name,eq,ini)) + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> + let arity = + init_same (mcode2line lb) + [mcode2arity lb; mcode2arity rb; mcode2arity eq] in + let lb = mcode lb in + let exp = expression arity exp in + let rb = mcode rb in + let eq = mcode eq in + let ini = initialiser arity ini in + make_init i tgt arity (Ast0.InitGccIndex(lb,exp,rb,eq,ini)) + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + let arity = + init_same (mcode2line lb) + [mcode2arity lb; mcode2arity dots; mcode2arity rb; mcode2arity eq] in + let lb = mcode lb in + let exp1 = expression arity exp1 in + let dots = mcode dots in + let exp2 = expression arity exp2 in + let rb = mcode rb in + let eq = mcode eq in + let ini = initialiser arity ini in + make_init i tgt arity + (Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini)) + | Ast0.IComma(cm) -> + let arity = init_same (mcode2line cm) [mcode2arity cm] in + let cm = mcode cm in + make_init i tgt arity (Ast0.IComma(cm)) + | Ast0.Idots(dots,whencode) -> + let arity = init_same (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + let whencode = get_option (initialiser Ast0.NONE) whencode in + make_init i tgt arity (Ast0.Idots(dots,whencode)) + | Ast0.OptIni(_) | Ast0.UniqueIni(_) -> + failwith "unexpected code" + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and make_param = + make_opt_unique + (function x -> Ast0.OptParam x) + (function x -> Ast0.UniqueParam x) + +and parameterTypeDef tgt param = + let param_same = all_same true tgt in + match Ast0.unwrap param with + Ast0.VoidParam(ty) -> Ast0.rewrap param (Ast0.VoidParam(typeC tgt ty)) + | Ast0.Param(ty,Some id) -> + let ty = top_typeC tgt true ty in + let id = ident true tgt id in + Ast0.rewrap param + (match (Ast0.unwrap ty,Ast0.unwrap id) with + (Ast0.OptType(ty),Ast0.OptIdent(id)) -> + Ast0.OptParam(Ast0.rewrap param (Ast0.Param(ty,Some id))) + | (Ast0.UniqueType(ty),Ast0.UniqueIdent(id)) -> + Ast0.UniqueParam(Ast0.rewrap param (Ast0.Param(ty,Some id))) + | (Ast0.OptType(ty),_) -> + fail param "arity mismatch in param declaration" + | (_,Ast0.OptIdent(id)) -> + fail param "arity mismatch in param declaration" + | _ -> Ast0.Param(ty,Some id)) + | Ast0.Param(ty,None) -> + let ty = top_typeC tgt true ty in + Ast0.rewrap param + (match Ast0.unwrap ty with + Ast0.OptType(ty) -> + Ast0.OptParam(Ast0.rewrap param (Ast0.Param(ty,None))) + | Ast0.UniqueType(ty) -> + Ast0.UniqueParam(Ast0.rewrap param (Ast0.Param(ty,None))) + | _ -> Ast0.Param(ty,None)) + | Ast0.MetaParam(name,pure) -> + let arity = param_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_param param tgt arity (Ast0.MetaParam(name,pure)) + | Ast0.MetaParamList(name,lenname,pure) -> + let arity = param_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_param param tgt arity (Ast0.MetaParamList(name,lenname,pure)) + | Ast0.PComma(cm) -> + let arity = param_same (mcode2line cm) [mcode2arity cm] in + let cm = mcode cm in + make_param param tgt arity (Ast0.PComma(cm)) + | Ast0.Pdots(dots) -> + let arity = param_same (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + make_param param tgt arity (Ast0.Pdots(dots)) + | Ast0.Pcircles(dots) -> + let arity = param_same (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + make_param param tgt arity (Ast0.Pcircles(dots)) + | Ast0.OptParam(_) | Ast0.UniqueParam(_) -> + failwith "unexpected code" + +and parameter_list tgt = dots (parameterTypeDef tgt) + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +and make_rule_elem x = + make_opt_unique + (function x -> Ast0.OptStm x) + (function x -> Ast0.UniqueStm x) + x + +and statement tgt stm = + let stm_same = all_same true tgt in + match Ast0.unwrap stm with + Ast0.Decl(bef,decl) -> + let new_decl = declaration tgt decl in + Ast0.rewrap stm + (match Ast0.unwrap new_decl with + Ast0.OptDecl(decl) -> + Ast0.OptStm(Ast0.rewrap stm (Ast0.Decl(bef,decl))) + | Ast0.UniqueDecl(decl) -> + Ast0.UniqueStm(Ast0.rewrap stm (Ast0.Decl(bef,decl))) + | _ -> Ast0.Decl(bef,new_decl)) + | Ast0.Seq(lbrace,body,rbrace) -> + let arity = + stm_same (mcode2line lbrace) + [mcode2arity lbrace; mcode2arity rbrace] in + let lbrace = mcode lbrace in + let body = dots (statement arity) body in + let rbrace = mcode rbrace in + make_rule_elem stm tgt arity (Ast0.Seq(lbrace,body,rbrace)) + | Ast0.ExprStatement(exp,sem) -> + let arity = stm_same (mcode2line sem) [mcode2arity sem] in + let exp = expression arity exp in + let sem = mcode sem in + make_rule_elem stm tgt arity (Ast0.ExprStatement(exp,sem)) + | Ast0.IfThen(iff,lp,exp,rp,branch,aft) -> + let arity = + stm_same (mcode2line iff) (List.map mcode2arity [iff;lp;rp]) in + let iff = mcode iff in + let lp = mcode lp in + let exp = expression arity exp in + let rp = mcode rp in + let branch = statement arity branch in + make_rule_elem stm tgt arity (Ast0.IfThen(iff,lp,exp,rp,branch,aft)) + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) -> + let arity = + stm_same (mcode2line iff) (List.map mcode2arity [iff;lp;rp;els]) in + let iff = mcode iff in + let lp = mcode lp in + let exp = expression arity exp in + let rp = mcode rp in + let branch1 = statement arity branch1 in + let els = mcode els in + let branch2 = statement arity branch2 in + make_rule_elem stm tgt arity + (Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft)) + | Ast0.While(wh,lp,exp,rp,body,aft) -> + let arity = + stm_same (mcode2line wh) + (List.map mcode2arity [wh;lp;rp]) in + let wh = mcode wh in + let lp = mcode lp in + let exp = expression arity exp in + let rp = mcode rp in + let body = statement arity body in + make_rule_elem stm tgt arity (Ast0.While(wh,lp,exp,rp,body,aft)) + | Ast0.Do(d,body,wh,lp,exp,rp,sem) -> + let arity = + stm_same (mcode2line wh) (List.map mcode2arity [d;wh;lp;rp;sem]) in + let d = mcode d in + let body = statement arity body in + let wh = mcode wh in + let lp = mcode lp in + let exp = expression arity exp in + let rp = mcode rp in + let sem = mcode sem in + make_rule_elem stm tgt arity (Ast0.Do(d,body,wh,lp,exp,rp,sem)) + | Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,aft) -> + let arity = + stm_same (mcode2line fr) (List.map mcode2arity [fr;lp;sem1;sem2;rp]) in + let fr = mcode fr in + let lp = mcode lp in + let exp1 = get_option (expression arity) exp1 in + let sem1 = mcode sem1 in + let exp2 = get_option (expression arity) exp2 in + let sem2= mcode sem2 in + let exp3 = get_option (expression arity) exp3 in + let rp = mcode rp in + let body = statement arity body in + make_rule_elem stm tgt arity + (Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,aft)) + | Ast0.Iterator(nm,lp,args,rp,body,aft) -> + let arity = stm_same (mcode2line lp) (List.map mcode2arity [lp;rp]) in + let nm = ident false arity nm in + let lp = mcode lp in + let args = dots (expression arity) args in + let rp = mcode rp in + let body = statement arity body in + make_rule_elem stm tgt arity (Ast0.Iterator(nm,lp,args,rp,body,aft)) + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> + let arity = + stm_same (mcode2line switch) + (List.map mcode2arity [switch;lp;rp;lb;rb]) in + let switch = mcode switch in + let lp = mcode lp in + let exp = expression arity exp in + let rp = mcode rp in + let lb = mcode lb in + let cases = dots (case_line arity) cases in + let rb = mcode rb in + make_rule_elem stm tgt arity + (Ast0.Switch(switch,lp,exp,rp,lb,cases,rb)) + | Ast0.Break(br,sem) -> + let arity = stm_same (mcode2line br) (List.map mcode2arity [br;sem]) in + let br = mcode br in + let sem = mcode sem in + make_rule_elem stm tgt arity (Ast0.Break(br,sem)) + | Ast0.Continue(cont,sem) -> + let arity = + stm_same (mcode2line cont) (List.map mcode2arity [cont;sem]) in + let cont = mcode cont in + let sem = mcode sem in + make_rule_elem stm tgt arity (Ast0.Continue(cont,sem)) + | Ast0.Label(l,dd) -> + let arity = mcode2arity dd in + let l = ident false tgt l in + let dd = mcode dd in + make_rule_elem stm tgt arity (Ast0.Label(l,dd)) + | Ast0.Goto(goto,l,sem) -> + let arity = + stm_same (mcode2line goto) (List.map mcode2arity [goto;sem]) in + let goto = mcode goto in + let l = ident false tgt l in + let sem = mcode sem in + make_rule_elem stm tgt arity (Ast0.Goto(goto,l,sem)) + | Ast0.Return(ret,sem) -> + let arity = stm_same (mcode2line ret) (List.map mcode2arity [ret;sem]) in + let ret = mcode ret in + let sem = mcode sem in + make_rule_elem stm tgt arity (Ast0.Return(ret,sem)) + | Ast0.ReturnExpr(ret,exp,sem) -> + let arity = stm_same (mcode2line ret) (List.map mcode2arity [ret;sem]) in + let ret = mcode ret in + let exp = expression arity exp in + let sem = mcode sem in + make_rule_elem stm tgt arity (Ast0.ReturnExpr(ret,exp,sem)) + | Ast0.MetaStmt(name,pure) -> + let arity = stm_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_rule_elem stm tgt arity (Ast0.MetaStmt(name,pure)) + | Ast0.MetaStmtList(name,pure) -> + let arity = stm_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_rule_elem stm tgt arity (Ast0.MetaStmtList(name,pure)) + | Ast0.Exp(exp) -> + let new_exp = top_expression true tgt exp in + Ast0.rewrap stm + (match Ast0.unwrap new_exp with + Ast0.OptExp(exp) -> + Ast0.OptStm(Ast0.rewrap stm (Ast0.Exp(exp))) + | Ast0.UniqueExp(exp) -> + Ast0.UniqueStm(Ast0.rewrap stm (Ast0.Exp(exp))) + | _ -> Ast0.Exp(new_exp)) + | Ast0.TopExp(exp) -> + let new_exp = top_expression true tgt exp in + Ast0.rewrap stm + (match Ast0.unwrap new_exp with + Ast0.OptExp(exp) -> + Ast0.OptStm(Ast0.rewrap stm (Ast0.TopExp(exp))) + | Ast0.UniqueExp(exp) -> + Ast0.UniqueStm(Ast0.rewrap stm (Ast0.TopExp(exp))) + | _ -> Ast0.TopExp(new_exp)) + | Ast0.Ty(ty) -> + let new_ty = typeC tgt ty in (* opt makes no sense alone at top level *) + Ast0.rewrap stm + (match Ast0.unwrap new_ty with + Ast0.OptType(ty) -> + Ast0.OptStm(Ast0.rewrap stm (Ast0.Ty(ty))) + | Ast0.UniqueType(ty) -> + Ast0.UniqueStm(Ast0.rewrap stm (Ast0.Ty(ty))) + | _ -> Ast0.Ty(new_ty)) + | Ast0.TopInit(init) -> + let new_init = initialiser tgt init in + Ast0.rewrap stm + (match Ast0.unwrap new_init with + Ast0.OptIni(init) -> + Ast0.OptStm(Ast0.rewrap stm (Ast0.TopInit(init))) + | Ast0.UniqueIni(init) -> + Ast0.UniqueStm(Ast0.rewrap stm (Ast0.TopInit(init))) + | _ -> Ast0.TopInit(new_init)) + | Ast0.Disj(starter,rule_elem_dots_list,mids,ender) -> + let stms = + List.map (function x -> concat_dots (statement tgt) x) + rule_elem_dots_list in + let (found_opt,unopt) = + List.fold_left + (function (found_opt,lines) -> + function x -> + let rebuild l = + (* previously just checked the last thing in the list, + but everything should be optional for the whole thing to + be optional *) + let is_opt x = + match Ast0.unwrap x with + Ast0.OptStm(x) -> true + | _ -> false in + let unopt x = + match Ast0.unwrap x with + Ast0.OptStm(x) -> x + | _ -> x in + if List.for_all is_opt l + then (true,List.map unopt l) + else (false, l) in + let (l,k) = + match Ast0.unwrap x with + Ast0.DOTS(l) -> + (l,function l -> Ast0.rewrap x (Ast0.DOTS l)) + | Ast0.CIRCLES(l) -> + (l,function l -> Ast0.rewrap x (Ast0.CIRCLES l)) + | Ast0.STARS(l) -> + (l,function l -> Ast0.rewrap x (Ast0.STARS l)) in + let (found_opt,l) = rebuild l in + (found_opt,(k l)::lines)) + (false,[]) stms in + let unopt = List.rev unopt in + if found_opt + then + make_rule_elem stm tgt Ast0.OPT (Ast0.Disj(starter,unopt,mids,ender)) + else Ast0.rewrap stm (Ast0.Disj(starter,stms,mids,ender)) + | Ast0.Nest(starter,rule_elem_dots,ender,whn,multi) -> + let new_rule_elem_dots = + concat_dots (statement Ast0.NONE) rule_elem_dots in + let whn = + List.map + (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE) + (expression Ast0.NONE)) + whn in + Ast0.rewrap stm + (Ast0.Nest(starter,new_rule_elem_dots,ender,whn,multi)) + | Ast0.Dots(dots,whn) -> + let arity = stm_same (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + let whn = + List.map + (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE) + (expression Ast0.NONE)) + whn in + make_rule_elem stm tgt arity (Ast0.Dots(dots,whn)) + | Ast0.Circles(dots,whn) -> + let arity = stm_same (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + let whn = + List.map + (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE) + (expression Ast0.NONE)) + whn in + make_rule_elem stm tgt arity (Ast0.Circles(dots,whn)) + | Ast0.Stars(dots,whn) -> + let arity = stm_same (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + let whn = + List.map + (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE) + (expression Ast0.NONE)) + whn in + make_rule_elem stm tgt arity (Ast0.Stars(dots,whn)) + | Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace) -> + let arity = + all_same true tgt (mcode2line lp) + ((List.map mcode2arity [lp;rp;lbrace;rbrace]) @ (fninfo2arity fi)) in + let fi = List.map (fninfo arity) fi in + let name = ident false arity name in + let lp = mcode lp in + let params = parameter_list arity params in + let rp = mcode rp in + let lbrace = mcode lbrace in + let body = dots (statement arity) body in + let rbrace = mcode rbrace in + make_rule_elem stm tgt arity + (Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace)) + | Ast0.Include(inc,s) -> + let arity = + all_same true tgt (mcode2line inc) [mcode2arity inc; mcode2arity s] in + let inc = mcode inc in + let s = mcode s in + make_rule_elem stm tgt arity (Ast0.Include(inc,s)) + | Ast0.Define(def,id,params,body) -> + let arity = all_same true tgt (mcode2line def) [mcode2arity def] in + let def = mcode def in + let id = ident false arity id in + let params = define_parameters arity params in + let body = dots (statement arity) body in + make_rule_elem stm tgt arity (Ast0.Define(def,id,params,body)) + | Ast0.OptStm(_) | Ast0.UniqueStm(_) -> + failwith "unexpected code" + +and define_parameters tgt params = + match Ast0.unwrap params with + Ast0.NoParams -> params + | Ast0.DParams(lp,params,rp) -> + let arity = + all_same true tgt (mcode2line lp) [mcode2arity lp;mcode2arity rp] in + let lp = mcode lp in + let params = dots (define_param arity) params in + let rp = mcode rp in + Ast0.rewrap params (Ast0.DParams(lp,params,rp)) + +and make_define_param x = + make_opt_unique + (function x -> Ast0.OptDParam x) + (function x -> Ast0.UniqueDParam x) + x + +and define_param tgt param = + match Ast0.unwrap param with + Ast0.DParam(id) -> + let new_id = ident true tgt id in + Ast0.rewrap param + (match Ast0.unwrap new_id with + Ast0.OptIdent(id) -> + Ast0.OptDParam(Ast0.rewrap param (Ast0.DParam(id))) + | Ast0.UniqueIdent(decl) -> + Ast0.UniqueDParam(Ast0.rewrap param (Ast0.DParam(id))) + | _ -> Ast0.DParam(new_id)) + | Ast0.DPComma(cm) -> + let arity = + all_same true tgt (mcode2line cm) [mcode2arity cm] in + let cm = mcode cm in + make_define_param param tgt arity (Ast0.DPComma(cm)) + | Ast0.DPdots(dots) -> + let arity = + all_same true tgt (mcode2line dots) [mcode2arity dots] in + let dots = mcode dots in + make_define_param param tgt arity (Ast0.DPdots(dots)) + | Ast0.DPcircles(circles) -> + let arity = + all_same true tgt (mcode2line circles) [mcode2arity circles] in + let circles = mcode circles in + make_define_param param tgt arity (Ast0.DPcircles(circles)) + | Ast0.OptDParam(dp) | Ast0.UniqueDParam(dp) -> + failwith "unexpected code" + +and fninfo arity = function + Ast0.FStorage(stg) -> Ast0.FStorage(mcode stg) + | Ast0.FType(ty) -> Ast0.FType(typeC arity ty) + | Ast0.FInline(inline) -> Ast0.FInline(mcode inline) + | Ast0.FAttr(attr) -> Ast0.FAttr(mcode attr) + +and fninfo2arity fninfo = + List.concat + (List.map + (function + Ast0.FStorage(stg) -> [mcode2arity stg] + | Ast0.FType(ty) -> [] + | Ast0.FInline(inline) -> [mcode2arity inline] + | Ast0.FAttr(attr) -> [mcode2arity attr]) + fninfo) + +and whencode notfn alwaysfn expression = function + Ast0.WhenNot a -> Ast0.WhenNot (notfn a) + | Ast0.WhenAlways a -> Ast0.WhenAlways (alwaysfn a) + | Ast0.WhenModifier(x) -> Ast0.WhenModifier(x) + | Ast0.WhenNotTrue a -> Ast0.WhenNotTrue (expression a) + | Ast0.WhenNotFalse a -> Ast0.WhenNotFalse (expression a) + +and make_case_line = + make_opt_unique + (function x -> Ast0.OptCase x) + (function x -> failwith "unique not allowed for case_line") + +and case_line tgt c = + match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> + let arity = + all_same true tgt (mcode2line def) + [mcode2arity def; mcode2arity colon] in + let def = mcode def in + let colon = mcode colon in + let code = dots (statement arity) code in + make_case_line c tgt arity (Ast0.Default(def,colon,code)) + | Ast0.Case(case,exp,colon,code) -> + let arity = + all_same true tgt (mcode2line case) + [mcode2arity case; mcode2arity colon] in + let case = mcode case in + let exp = expression arity exp in + let colon = mcode colon in + let code = dots (statement arity) code in + make_case_line c tgt arity (Ast0.Case(case,exp,colon,code)) + | Ast0.OptCase(_) -> failwith "unexpected OptCase" + +(* --------------------------------------------------------------------- *) +(* Function declaration *) +(* Haven't thought much about arity here... *) + +let top_level tgt t = + Ast0.rewrap t + (match Ast0.unwrap t with + Ast0.FILEINFO(old_file,new_file) -> + if mcode2arity old_file = Ast0.NONE && mcode2arity new_file = Ast0.NONE + then Ast0.FILEINFO(mcode old_file,mcode new_file) + else fail t "unexpected arity for file info" + | Ast0.DECL(stmt) -> + Ast0.DECL(statement tgt stmt) + | Ast0.CODE(rule_elem_dots) -> + Ast0.CODE(concat_dots (statement tgt) rule_elem_dots) + | Ast0.ERRORWORDS(exps) -> + Ast0.ERRORWORDS(List.map (top_expression false Ast0.NONE) exps) + | Ast0.OTHER(_) -> fail t "eliminated by top_level") + +let rule tgt = List.map (top_level tgt) + +(* --------------------------------------------------------------------- *) +(* Entry points *) + +let minus_arity code = + rule Ast0.NONE code diff --git a/parsing_cocci/.#ast0_cocci.ml.1.113 b/parsing_cocci/.#ast0_cocci.ml.1.113 new file mode 100644 index 0000000..b40bb6e --- /dev/null +++ b/parsing_cocci/.#ast0_cocci.ml.1.113 @@ -0,0 +1,670 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +module Ast = Ast_cocci + +(* --------------------------------------------------------------------- *) +(* Modified code *) + +type arity = OPT | UNIQUE | NONE + +type token_info = + { tline_start : int; tline_end : int; + left_offset : int; right_offset : int } +let default_token_info = + { tline_start = -1; tline_end = -1; left_offset = -1; right_offset = -1 } + +(* MIXED is like CONTEXT, since sometimes MIXED things have to revert to +CONTEXT - see insert_plus.ml *) +type mcodekind = + MINUS of (Ast.anything list list * token_info) ref + | PLUS + | CONTEXT of (Ast.anything Ast.befaft * token_info * token_info) ref + | MIXED of (Ast.anything Ast.befaft * token_info * token_info) ref + +type info = { line_start : int; line_end : int; + logical_start : int; logical_end : int; + attachable_start : bool; attachable_end : bool; + mcode_start : mcodekind list; mcode_end : mcodekind list; + column : int; offset : int; + (* the following are only for + code *) + strings_before : string list; strings_after : string list } + +type 'a mcode = 'a * arity * info * mcodekind * meta_pos ref (* pos, - only *) +(* int ref is an index *) +and 'a wrap = + { node : 'a; + info : info; + index : int ref; + mcodekind : mcodekind ref; + exp_ty : Type_cocci.typeC option ref; (* only for expressions *) + bef_aft : dots_bef_aft; (* only for statements *) + true_if_arg : bool; (* true if "arg_exp", only for exprs *) + true_if_test : bool; (* true if "test position", only for exprs *) + true_if_test_exp : bool;(* true if "test_exp from iso", only for exprs *) + (*nonempty if this represents the use of an iso*) + iso_info : (string*anything) list } + +and dots_bef_aft = + NoDots | AddingBetweenDots of statement | DroppingBetweenDots of statement + +(* for iso metavariables, true if they can only match nonmodified terms with + all metavariables unitary + for SP metavariables, true if the metavariable is unitary (valid up to + isomorphism phase only) + In SP, the only options are impure and context +*) +and pure = Impure | Pure | Context | PureContext (* pure and only context *) + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) +(* Dots *) + +and 'a base_dots = + DOTS of 'a list + | CIRCLES of 'a list + | STARS of 'a list + +and 'a dots = 'a base_dots wrap + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +and base_ident = + Id of string mcode + | MetaId of Ast.meta_name mcode * ident list * pure + | MetaFunc of Ast.meta_name mcode * ident list * pure + | MetaLocalFunc of Ast.meta_name mcode * ident list * pure + | OptIdent of ident + | UniqueIdent of ident + +and ident = base_ident wrap + +(* --------------------------------------------------------------------- *) +(* Expression *) + +and base_expression = + Ident of ident + | Constant of Ast.constant mcode + | FunCall of expression * string mcode (* ( *) * + expression dots * string mcode (* ) *) + | Assignment of expression * Ast.assignOp mcode * expression * + bool (* true if it can match an initialization *) + | CondExpr of expression * string mcode (* ? *) * expression option * + string mcode (* : *) * expression + | Postfix of expression * Ast.fixOp mcode + | Infix of expression * Ast.fixOp mcode + | Unary of expression * Ast.unaryOp mcode + | Binary of expression * Ast.binaryOp mcode * expression + | Nested of expression * Ast.binaryOp mcode * expression + | Paren of string mcode (* ( *) * expression * + string mcode (* ) *) + | ArrayAccess of expression * string mcode (* [ *) * expression * + string mcode (* ] *) + | RecordAccess of expression * string mcode (* . *) * ident + | RecordPtAccess of expression * string mcode (* -> *) * ident + | Cast of string mcode (* ( *) * typeC * string mcode (* ) *) * + expression + | SizeOfExpr of string mcode (* sizeof *) * expression + | SizeOfType of string mcode (* sizeof *) * string mcode (* ( *) * + typeC * string mcode (* ) *) + | TypeExp of typeC (* type name used as an expression, only in args *) + | MetaErr of Ast.meta_name mcode * expression list * pure + | MetaExpr of Ast.meta_name mcode * expression list * + Type_cocci.typeC list option * Ast.form * pure + | MetaExprList of Ast.meta_name mcode (* only in arg lists *) * + listlen * pure + | EComma of string mcode (* only in arg lists *) + | DisjExpr of string mcode * expression list * + string mcode list (* the |s *) * string mcode + | NestExpr of string mcode * expression dots * string mcode * + expression option * Ast.multi + | Edots of string mcode (* ... *) * expression option + | Ecircles of string mcode (* ooo *) * expression option + | Estars of string mcode (* *** *) * expression option + | OptExp of expression + | UniqueExp of expression + +and expression = base_expression wrap + +and listlen = Ast.meta_name mcode option + +(* --------------------------------------------------------------------- *) +(* Types *) + +and base_typeC = + ConstVol of Ast.const_vol mcode * typeC + | BaseType of Ast.baseType * string mcode list + | Signed of Ast.sign mcode * typeC option + | Pointer of typeC * string mcode (* * *) + | FunctionPointer of typeC * + string mcode(* ( *)*string mcode(* * *)*string mcode(* ) *)* + string mcode (* ( *)*parameter_list*string mcode(* ) *) + | FunctionType of typeC option * + string mcode (* ( *) * parameter_list * + string mcode (* ) *) + | Array of typeC * string mcode (* [ *) * + expression option * string mcode (* ] *) + | EnumName of string mcode (*enum*) * ident (* name *) + | StructUnionName of Ast.structUnion mcode * ident option (* name *) + | StructUnionDef of typeC (* either StructUnionName or metavar *) * + string mcode (* { *) * declaration dots * string mcode (* } *) + | TypeName of string mcode + | MetaType of Ast.meta_name mcode * pure + | DisjType of string mcode * typeC list * (* only after iso *) + string mcode list (* the |s *) * string mcode + | OptType of typeC + | UniqueType of typeC + +and typeC = base_typeC wrap + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and base_declaration = + Init of Ast.storage mcode option * typeC * ident * string mcode (*=*) * + initialiser * string mcode (*;*) + | UnInit of Ast.storage mcode option * typeC * ident * string mcode (* ; *) + | TyDecl of typeC * string mcode (* ; *) + | MacroDecl of ident (* name *) * string mcode (* ( *) * + expression dots * string mcode (* ) *) * string mcode (* ; *) + | Typedef of string mcode (* typedef *) * typeC * typeC * string mcode (*;*) + | DisjDecl of string mcode * declaration list * + string mcode list (* the |s *) * string mcode + (* Ddots is for a structure declaration *) + | Ddots of string mcode (* ... *) * declaration option (* whencode *) + | OptDecl of declaration + | UniqueDecl of declaration + +and declaration = base_declaration wrap + +(* --------------------------------------------------------------------- *) +(* Initializers *) + +and base_initialiser = + InitExpr of expression + | InitList of string mcode (*{*) * initialiser_list * string mcode (*}*) + | InitGccDotName of + string mcode (*.*) * ident (* name *) * string mcode (*=*) * + initialiser (* gccext: *) + | InitGccName of ident (* name *) * string mcode (*:*) * + initialiser + | InitGccIndex of + string mcode (*[*) * expression * string mcode (*]*) * + string mcode (*=*) * initialiser + | InitGccRange of + string mcode (*[*) * expression * string mcode (*...*) * + expression * string mcode (*]*) * string mcode (*=*) * initialiser + | IComma of string mcode (* , *) + | Idots of string mcode (* ... *) * initialiser option (* whencode *) + | OptIni of initialiser + | UniqueIni of initialiser + +and initialiser = base_initialiser wrap + +and initialiser_list = initialiser dots + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and base_parameterTypeDef = + VoidParam of typeC + | Param of typeC * ident option + | MetaParam of Ast.meta_name mcode * pure + | MetaParamList of Ast.meta_name mcode * listlen * pure + | PComma of string mcode + | Pdots of string mcode (* ... *) + | Pcircles of string mcode (* ooo *) + | OptParam of parameterTypeDef + | UniqueParam of parameterTypeDef + +and parameterTypeDef = base_parameterTypeDef wrap + +and parameter_list = parameterTypeDef dots + +(* --------------------------------------------------------------------- *) +(* #define Parameters *) + +and base_define_param = + DParam of ident + | DPComma of string mcode + | DPdots of string mcode (* ... *) + | DPcircles of string mcode (* ooo *) + | OptDParam of define_param + | UniqueDParam of define_param + +and define_param = base_define_param wrap + +and base_define_parameters = + NoParams + | DParams of string mcode(*( *) * define_param dots * string mcode(* )*) + +and define_parameters = base_define_parameters wrap + +(* --------------------------------------------------------------------- *) +(* Statement*) + +and base_statement = + Decl of (info * mcodekind) (* before the decl *) * declaration + | Seq of string mcode (* { *) * statement dots * + string mcode (* } *) + | ExprStatement of expression * string mcode (*;*) + | IfThen of string mcode (* if *) * string mcode (* ( *) * + expression * string mcode (* ) *) * + statement * (info * mcodekind) (* after info *) + | IfThenElse of string mcode (* if *) * string mcode (* ( *) * + expression * string mcode (* ) *) * + statement * string mcode (* else *) * statement * + (info * mcodekind) + | While of string mcode (* while *) * string mcode (* ( *) * + expression * string mcode (* ) *) * + statement * (info * mcodekind) (* after info *) + | Do of string mcode (* do *) * statement * + string mcode (* while *) * string mcode (* ( *) * + expression * string mcode (* ) *) * + string mcode (* ; *) + | For of string mcode (* for *) * string mcode (* ( *) * + expression option * string mcode (*;*) * + expression option * string mcode (*;*) * + expression option * string mcode (* ) *) * statement * + (info * mcodekind) (* after info *) + | Iterator of ident (* name *) * string mcode (* ( *) * + expression dots * string mcode (* ) *) * + statement * (info * mcodekind) (* after info *) + | Switch of string mcode (* switch *) * string mcode (* ( *) * + expression * string mcode (* ) *) * string mcode (* { *) * + case_line dots * string mcode (* } *) + | Break of string mcode (* break *) * string mcode (* ; *) + | Continue of string mcode (* continue *) * string mcode (* ; *) + | Label of ident * string mcode (* : *) + | Goto of string mcode (* goto *) * ident * string mcode (* ; *) + | Return of string mcode (* return *) * string mcode (* ; *) + | ReturnExpr of string mcode (* return *) * expression * + string mcode (* ; *) + | MetaStmt of Ast.meta_name mcode * pure + | MetaStmtList of Ast.meta_name mcode(*only in statement lists*) * pure + | Exp of expression (* only in dotted statement lists *) + | TopExp of expression (* for macros body *) + | Ty of typeC (* only at top level *) + | TopInit of initialiser (* only at top level *) + | Disj of string mcode * statement dots list * + string mcode list (* the |s *) * string mcode + | Nest of string mcode * statement dots * string mcode * + (statement dots,statement) whencode list * Ast.multi + | Dots of string mcode (* ... *) * + (statement dots,statement) whencode list + | Circles of string mcode (* ooo *) * + (statement dots,statement) whencode list + | Stars of string mcode (* *** *) * + (statement dots,statement) whencode list + | FunDecl of (info * mcodekind) (* before the function decl *) * + fninfo list * ident (* name *) * + string mcode (* ( *) * parameter_list * string mcode (* ) *) * + string mcode (* { *) * statement dots * + string mcode (* } *) + | Include of string mcode (* #include *) * Ast.inc_file mcode (* file *) + | Define of string mcode (* #define *) * ident (* name *) * + define_parameters (*params*) * statement dots + | OptStm of statement + | UniqueStm of statement + +and fninfo = + FStorage of Ast.storage mcode + | FType of typeC + | FInline of string mcode + | FAttr of string mcode + +and ('a,'b) whencode = + WhenNot of 'a + | WhenAlways of 'b + | WhenModifier of Ast.when_modifier + | WhenNotTrue of expression + | WhenNotFalse of expression + +and statement = base_statement wrap + +and base_case_line = + Default of string mcode (* default *) * string mcode (*:*) * statement dots + | Case of string mcode (* case *) * expression * string mcode (*:*) * + statement dots + | OptCase of case_line + +and case_line = base_case_line wrap + +(* --------------------------------------------------------------------- *) +(* Positions *) + +and meta_pos = + MetaPos of Ast.meta_name mcode * Ast.meta_name list * Ast.meta_collect + | NoMetaPos + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +and base_top_level = + DECL of statement + | CODE of statement dots + | FILEINFO of string mcode (* old file *) * string mcode (* new file *) + | ERRORWORDS of expression list + | OTHER of statement (* temporary, disappears after top_level.ml *) + +and top_level = base_top_level wrap +and rule = top_level list + +and parsed_rule = + CocciRule of + (rule * Ast.metavar list * + (string list * string list * Ast.dependency * string * Ast.exists)) * + (rule * Ast.metavar list) * Ast.ruletype + | ScriptRule of + string * Ast.dependency * (string * Ast.meta_name) list * string + +(* --------------------------------------------------------------------- *) + +and anything = + DotsExprTag of expression dots + | DotsInitTag of initialiser dots + | DotsParamTag of parameterTypeDef dots + | DotsStmtTag of statement dots + | DotsDeclTag of declaration dots + | DotsCaseTag of case_line dots + | IdentTag of ident + | ExprTag of expression + | ArgExprTag of expression (* for isos *) + | TestExprTag of expression (* for isos *) + | TypeCTag of typeC + | ParamTag of parameterTypeDef + | InitTag of initialiser + | DeclTag of declaration + | StmtTag of statement + | CaseLineTag of case_line + | TopTag of top_level + | IsoWhenTag of Ast.when_modifier + | IsoWhenTTag of expression + | IsoWhenFTag of expression + | MetaPosTag of meta_pos + +let dotsExpr x = DotsExprTag x +let dotsParam x = DotsParamTag x +let dotsInit x = DotsInitTag x +let dotsStmt x = DotsStmtTag x +let dotsDecl x = DotsDeclTag x +let dotsCase x = DotsCaseTag x +let ident x = IdentTag x +let expr x = ExprTag x +let typeC x = TypeCTag x +let param x = ParamTag x +let ini x = InitTag x +let decl x = DeclTag x +let stmt x = StmtTag x +let case_line x = CaseLineTag x +let top x = TopTag x + +(* --------------------------------------------------------------------- *) +(* Avoid cluttering the parser. Calculated in compute_lines.ml. *) + +let default_info _ = (* why is this a function? *) + { line_start = -1; line_end = -1; + logical_start = -1; logical_end = -1; + attachable_start = true; attachable_end = true; + mcode_start = []; mcode_end = []; + column = -1; offset = -1; strings_before = []; strings_after = [] } + +let default_befaft _ = + MIXED(ref (Ast.NOTHING,default_token_info,default_token_info)) +let context_befaft _ = + CONTEXT(ref (Ast.NOTHING,default_token_info,default_token_info)) + +let wrap x = + { node = x; + info = default_info(); + index = ref (-1); + mcodekind = ref (default_befaft()); + exp_ty = ref None; + bef_aft = NoDots; + true_if_arg = false; + true_if_test = false; + true_if_test_exp = false; + iso_info = [] } +let context_wrap x = + { node = x; + info = default_info(); + index = ref (-1); + mcodekind = ref (context_befaft()); + exp_ty = ref None; + bef_aft = NoDots; + true_if_arg = false; + true_if_test = false; + true_if_test_exp = false; + iso_info = [] } +let unwrap x = x.node +let unwrap_mcode (x,_,_,_,_) = x +let rewrap model x = { model with node = x } +let rewrap_mcode (_,arity,info,mcodekind,pos) x = (x,arity,info,mcodekind,pos) +let copywrap model x = + { model with node = x; index = ref !(model.index); + mcodekind = ref !(model.mcodekind); exp_ty = ref !(model.exp_ty)} +let get_pos (_,_,_,_,x) = !x +let get_pos_ref (_,_,_,_,x) = x +let set_pos pos (m,arity,info,mcodekind,_) = (m,arity,info,mcodekind,ref pos) +let get_info x = x.info +let set_info x info = {x with info = info} +let get_line x = x.info.line_start +let get_line_end x = x.info.line_end +let get_index x = !(x.index) +let set_index x i = x.index := i +let get_mcodekind x = !(x.mcodekind) +let get_mcode_mcodekind (_,_,_,mcodekind,_) = mcodekind +let get_mcodekind_ref x = x.mcodekind +let set_mcodekind x mk = x.mcodekind := mk +let set_type x t = x.exp_ty := t +let get_type x = !(x.exp_ty) +let get_dots_bef_aft x = x.bef_aft +let set_dots_bef_aft x dots_bef_aft = {x with bef_aft = dots_bef_aft} +let get_arg_exp x = x.true_if_arg +let set_arg_exp x = {x with true_if_arg = true} +let get_test_pos x = x.true_if_test +let set_test_pos x = {x with true_if_test = true} +let get_test_exp x = x.true_if_test_exp +let set_test_exp x = {x with true_if_test_exp = true} +let get_iso x = x.iso_info +let set_iso x i = if !Flag.track_iso_usage then {x with iso_info = i} else x +let set_mcode_data data (_,ar,info,mc,pos) = (data,ar,info,mc,pos) + +(* --------------------------------------------------------------------- *) + +(* unique indices, for mcode and tree nodes *) +let index_counter = ref 0 +let fresh_index _ = let cur = !index_counter in index_counter := cur + 1; cur + +(* --------------------------------------------------------------------- *) + +let undots d = + match unwrap d with + | DOTS e -> e + | CIRCLES e -> e + | STARS e -> e + +(* --------------------------------------------------------------------- *) + +let rec ast0_type_to_type ty = + match unwrap ty with + ConstVol(cv,ty) -> Type_cocci.ConstVol(const_vol cv,ast0_type_to_type ty) + | BaseType(bty,strings) -> + Type_cocci.BaseType(baseType bty) + | Signed(sgn,None) -> + Type_cocci.SignedT(sign sgn,None) + | Signed(sgn,Some ty) -> + let bty = ast0_type_to_type ty in + Type_cocci.SignedT(sign sgn,Some bty) + | Pointer(ty,_) -> Type_cocci.Pointer(ast0_type_to_type ty) + | FunctionPointer(ty,_,_,_,_,params,_) -> + Type_cocci.FunctionPointer(ast0_type_to_type ty) + | FunctionType _ -> failwith "not supported" + | Array(ety,_,_,_) -> Type_cocci.Array(ast0_type_to_type ety) + | EnumName(su,tag) -> + (match unwrap tag with + Id(tag) -> + Type_cocci.EnumName(false,unwrap_mcode tag) + | MetaId(tag,_,_) -> + (Printf.printf + "warning: enum with a metavariable name detected.\n"; + Printf.printf + "For type checking assuming the name of the metavariable is the name of the type\n"; + let (rule,tag) = unwrap_mcode tag in + Type_cocci.EnumName(true,rule^tag)) + | _ -> failwith "unexpected enum type name") + | StructUnionName(su,Some tag) -> + (match unwrap tag with + Id(tag) -> + Type_cocci.StructUnionName(structUnion su,false,unwrap_mcode tag) + | MetaId(tag,_,_) -> + (Printf.printf + "warning: struct/union with a metavariable name detected.\n"; + Printf.printf + "For type checking assuming the name of the metavariable is the name of the type\n"; + let (rule,tag) = unwrap_mcode tag in + Type_cocci.StructUnionName(structUnion su,true,rule^tag)) + | _ -> failwith "unexpected struct/union type name") + | StructUnionName(su,None) -> failwith "nameless structure - what to do???" + | StructUnionDef(ty,_,_,_) -> ast0_type_to_type ty + | TypeName(name) -> Type_cocci.TypeName(unwrap_mcode name) + | MetaType(name,_) -> + Type_cocci.MetaType(unwrap_mcode name,Type_cocci.Unitary,false) + | DisjType(_,types,_,_) -> failwith "unexpected DisjType" + | OptType(ty) | UniqueType(ty) -> + ast0_type_to_type ty + +and baseType = function + Ast.VoidType -> Type_cocci.VoidType + | Ast.CharType -> Type_cocci.CharType + | Ast.ShortType -> Type_cocci.ShortType + | Ast.IntType -> Type_cocci.IntType + | Ast.DoubleType -> Type_cocci.DoubleType + | Ast.FloatType -> Type_cocci.FloatType + | Ast.LongType -> Type_cocci.LongType + | Ast.LongLongType -> Type_cocci.LongLongType + +and structUnion t = + match unwrap_mcode t with + Ast.Struct -> Type_cocci.Struct + | Ast.Union -> Type_cocci.Union + +and sign t = + match unwrap_mcode t with + Ast.Signed -> Type_cocci.Signed + | Ast.Unsigned -> Type_cocci.Unsigned + +and const_vol t = + match unwrap_mcode t with + Ast.Const -> Type_cocci.Const + | Ast.Volatile -> Type_cocci.Volatile + +(* --------------------------------------------------------------------- *) +(* this function is a rather minimal attempt. the problem is that information +has been lost. but since it is only used for metavariable types in the isos, +perhaps it doesn't matter *) +and make_mcode x = (x,NONE,default_info(),context_befaft(),ref NoMetaPos) +let make_mcode_info x info = (x,NONE,info,context_befaft(),ref NoMetaPos) + +exception TyConv + +let rec reverse_type ty = + match ty with + Type_cocci.ConstVol(cv,ty) -> + ConstVol(reverse_const_vol cv,context_wrap(reverse_type ty)) + | Type_cocci.BaseType(bty) -> + BaseType(reverse_baseType bty,[(* not used *)]) + | Type_cocci.SignedT(sgn,None) -> Signed(reverse_sign sgn,None) + | Type_cocci.SignedT(sgn,Some bty) -> + Signed(reverse_sign sgn,Some (context_wrap(reverse_type ty))) + | Type_cocci.Pointer(ty) -> + Pointer(context_wrap(reverse_type ty),make_mcode "*") + | Type_cocci.EnumName(mv,tag) -> + if mv + then + (* not right... *) + EnumName + (make_mcode "enum", + context_wrap(MetaId(make_mcode ("",tag),[],Impure))) + else + EnumName(make_mcode "enum",context_wrap(Id(make_mcode tag))) + | Type_cocci.StructUnionName(su,mv,tag) -> + if mv + then + (* not right... *) + StructUnionName + (reverse_structUnion su, + Some(context_wrap(MetaId(make_mcode ("",tag),[],Impure)))) + else + StructUnionName + (reverse_structUnion su, + Some (context_wrap(Id(make_mcode tag)))) + | Type_cocci.TypeName(name) -> TypeName(make_mcode name) + | Type_cocci.MetaType(name,_,_) -> + MetaType(make_mcode name,Impure(*not really right*)) + | _ -> raise TyConv + +and reverse_baseType = function + Type_cocci.VoidType -> Ast.VoidType + | Type_cocci.CharType -> Ast.CharType + | Type_cocci.BoolType -> Ast.IntType + | Type_cocci.ShortType -> Ast.ShortType + | Type_cocci.IntType -> Ast.IntType + | Type_cocci.DoubleType -> Ast.DoubleType + | Type_cocci.FloatType -> Ast.FloatType + | Type_cocci.LongType -> Ast.LongType + | Type_cocci.LongLongType -> Ast.LongLongType + +and reverse_structUnion t = + make_mcode + (match t with + Type_cocci.Struct -> Ast.Struct + | Type_cocci.Union -> Ast.Union) + +and reverse_sign t = + make_mcode + (match t with + Type_cocci.Signed -> Ast.Signed + | Type_cocci.Unsigned -> Ast.Unsigned) + +and reverse_const_vol t = + make_mcode + (match t with + Type_cocci.Const -> Ast.Const + | Type_cocci.Volatile -> Ast.Volatile) + +(* --------------------------------------------------------------------- *) + +let lub_pure x y = + match (x,y) with + (Impure,_) | (_,Impure) -> Impure + | (Pure,Context) | (Context,Pure) -> Impure + | (Pure,_) | (_,Pure) -> Pure + | (_,Context) | (Context,_) -> Context + | _ -> PureContext + +(* --------------------------------------------------------------------- *) + +let rule_name = ref "" (* for the convenience of the parser *) diff --git a/parsing_cocci/.#ast0toast.ml.1.139 b/parsing_cocci/.#ast0toast.ml.1.139 new file mode 100644 index 0000000..91da782 --- /dev/null +++ b/parsing_cocci/.#ast0toast.ml.1.139 @@ -0,0 +1,934 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* Arities matter for the minus slice, but not for the plus slice. *) + +(* + only allowed on code in a nest (in_nest = true). ? only allowed on +rule_elems, and on subterms if the context is ? also. *) + +module Ast0 = Ast0_cocci +module Ast = Ast_cocci +module V0 = Visitor_ast0 +module V = Visitor_ast + +let unitary = Type_cocci.Unitary + +let ctr = ref 0 +let get_ctr _ = + let c = !ctr in + ctr := !ctr + 1; + c + +(* --------------------------------------------------------------------- *) +(* Move plus tokens from the MINUS and CONTEXT structured nodes to the +corresponding leftmost and rightmost mcodes *) + +let inline_mcodes = + let bind x y = () in + let option_default = () in + let mcode _ = () in + let do_nothing r k e = + k e; + let einfo = Ast0.get_info e in + match (Ast0.get_mcodekind e) with + Ast0.MINUS(replacements) -> + (match !replacements with + ([],_) -> () + | replacements -> + let minus_try = function + (true,mc) -> + if List.for_all + (function + Ast0.MINUS(mreplacements) -> true | _ -> false) + mc + then + (List.iter + (function + Ast0.MINUS(mreplacements) -> + mreplacements := replacements + | _ -> ()) + mc; + true) + else false + | _ -> false in + if not (minus_try(einfo.Ast0.attachable_start, + einfo.Ast0.mcode_start) + or + minus_try(einfo.Ast0.attachable_end, + einfo.Ast0.mcode_end)) + then + failwith "minus tree should not have bad code on both sides") + | Ast0.CONTEXT(befaft) + | Ast0.MIXED(befaft) -> + let concat starter startinfo ender endinfo = + let lst = + match (starter,ender) with + ([],_) -> ender + | (_,[]) -> starter + | _ -> + if startinfo.Ast0.tline_end = endinfo.Ast0.tline_start + then (* put them in the same inner list *) + let last = List.hd (List.rev starter) in + let butlast = List.rev(List.tl(List.rev starter)) in + butlast @ (last@(List.hd ender)) :: (List.tl ender) + else starter @ ender in + (lst, + {endinfo with Ast0.tline_start = startinfo.Ast0.tline_start}) in + let attach_bef bef beforeinfo = function + (true,mcl) -> + List.iter + (function + Ast0.MINUS(mreplacements) -> + let (mrepl,tokeninfo) = !mreplacements in + mreplacements := concat bef beforeinfo mrepl tokeninfo + | Ast0.CONTEXT(mbefaft) -> + (match !mbefaft with + (Ast.BEFORE(mbef),mbeforeinfo,a) -> + let (newbef,newinfo) = + concat bef beforeinfo mbef mbeforeinfo in + mbefaft := (Ast.BEFORE(newbef),newinfo,a) + | (Ast.AFTER(maft),_,a) -> + mbefaft := + (Ast.BEFOREAFTER(bef,maft),beforeinfo,a) + | (Ast.BEFOREAFTER(mbef,maft),mbeforeinfo,a) -> + let (newbef,newinfo) = + concat bef beforeinfo mbef mbeforeinfo in + mbefaft := + (Ast.BEFOREAFTER(newbef,maft),newinfo,a) + | (Ast.NOTHING,_,a) -> + mbefaft := (Ast.BEFORE(bef),beforeinfo,a)) + | _ -> failwith "unexpected annotation") + mcl + | _ -> + failwith + "context tree should not have bad code on both sides" in + let attach_aft aft afterinfo = function + (true,mcl) -> + List.iter + (function + Ast0.MINUS(mreplacements) -> + let (mrepl,tokeninfo) = !mreplacements in + mreplacements := concat mrepl tokeninfo aft afterinfo + | Ast0.CONTEXT(mbefaft) -> + (match !mbefaft with + (Ast.BEFORE(mbef),b,_) -> + mbefaft := + (Ast.BEFOREAFTER(mbef,aft),b,afterinfo) + | (Ast.AFTER(maft),b,mafterinfo) -> + let (newaft,newinfo) = + concat maft mafterinfo aft afterinfo in + mbefaft := (Ast.AFTER(newaft),b,newinfo) + | (Ast.BEFOREAFTER(mbef,maft),b,mafterinfo) -> + let (newaft,newinfo) = + concat maft mafterinfo aft afterinfo in + mbefaft := + (Ast.BEFOREAFTER(mbef,newaft),b,newinfo) + | (Ast.NOTHING,b,_) -> + mbefaft := (Ast.AFTER(aft),b,afterinfo)) + | _ -> failwith "unexpected annotation") + mcl + | _ -> + failwith + "context tree should not have bad code on both sides" in + (match !befaft with + (Ast.BEFORE(bef),beforeinfo,_) -> + attach_bef bef beforeinfo + (einfo.Ast0.attachable_start,einfo.Ast0.mcode_start) + | (Ast.AFTER(aft),_,afterinfo) -> + attach_aft aft afterinfo + (einfo.Ast0.attachable_end,einfo.Ast0.mcode_end) + | (Ast.BEFOREAFTER(bef,aft),beforeinfo,afterinfo) -> + attach_bef bef beforeinfo + (einfo.Ast0.attachable_start,einfo.Ast0.mcode_start); + attach_aft aft afterinfo + (einfo.Ast0.attachable_end,einfo.Ast0.mcode_end) + | (Ast.NOTHING,_,_) -> ()) + | Ast0.PLUS -> () in + V0.combiner bind option_default + 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 + do_nothing do_nothing do_nothing + +(* --------------------------------------------------------------------- *) +(* For function declarations. Can't use the mcode at the root, because that +might be mixed when the function contains ()s, where agglomeration of -s is +not possible. *) + +let check_allminus = + let donothing r k e = k e in + let bind x y = x && y in + let option_default = true in + let mcode (_,_,_,mc,_) = + match mc with + Ast0.MINUS(r) -> let (plusses,_) = !r in plusses = [] + | _ -> false in + + (* special case for disj *) + let expression r k e = + match Ast0.unwrap e with + Ast0.DisjExpr(starter,expr_list,mids,ender) -> + List.for_all r.V0.combiner_expression expr_list + | _ -> k e in + + let declaration r k e = + match Ast0.unwrap e with + Ast0.DisjDecl(starter,decls,mids,ender) -> + List.for_all r.V0.combiner_declaration decls + | _ -> k e in + + let typeC r k e = + match Ast0.unwrap e with + Ast0.DisjType(starter,decls,mids,ender) -> + List.for_all r.V0.combiner_typeC decls + | _ -> k e in + + let statement r k e = + match Ast0.unwrap e with + Ast0.Disj(starter,statement_dots_list,mids,ender) -> + List.for_all r.V0.combiner_statement_dots statement_dots_list + | _ -> k e in + + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + mcode mcode + donothing donothing donothing donothing donothing donothing + donothing expression typeC donothing donothing declaration + statement donothing donothing + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) + +let get_option fn = function + None -> None + | Some x -> Some (fn x) + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) +(* Mcode *) + +let convert_info info = + { Ast.line = info.Ast0.line_start; Ast.column = info.Ast0.column; + Ast.strbef = info.Ast0.strings_before; + Ast.straft = info.Ast0.strings_after; } + +let convert_mcodekind = function + Ast0.MINUS(replacements) -> + let (replacements,_) = !replacements in + Ast.MINUS(Ast.NoPos,replacements) + | Ast0.PLUS -> Ast.PLUS + | Ast0.CONTEXT(befaft) -> + let (befaft,_,_) = !befaft in Ast.CONTEXT(Ast.NoPos,befaft) + | Ast0.MIXED(_) -> failwith "not possible for mcode" + +let pos_mcode(term,_,info,mcodekind,pos) = + (* avoids a recursion problem *) + (term,convert_info info,convert_mcodekind mcodekind,Ast.NoMetaPos) + +let mcode(term,_,info,mcodekind,pos) = + let pos = + match !pos with + Ast0.MetaPos(pos,constraints,per) -> + Ast.MetaPos(pos_mcode pos,constraints,per,unitary,false) + | _ -> Ast.NoMetaPos in + (term,convert_info info,convert_mcodekind mcodekind,pos) + +(* --------------------------------------------------------------------- *) +(* Dots *) +let wrap ast line isos = + {(Ast.make_term ast) with Ast.node_line = line; + Ast.iso_info = isos} + +let rewrap ast0 isos ast = + wrap ast ((Ast0.get_info ast0).Ast0.line_start) isos + +let no_isos = [] + +(* no isos on tokens *) +let tokenwrap (_,info,_,_) s ast = wrap ast info.Ast.line no_isos +let iso_tokenwrap (_,info,_,_) s ast iso = wrap ast info.Ast.line iso + +let dots fn d = + rewrap d no_isos + (match Ast0.unwrap d with + Ast0.DOTS(x) -> Ast.DOTS(List.map fn x) + | Ast0.CIRCLES(x) -> Ast.CIRCLES(List.map fn x) + | Ast0.STARS(x) -> Ast.STARS(List.map fn x)) + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +let rec do_isos l = List.map (function (nm,x) -> (nm,anything x)) l + +and ident i = + rewrap i (do_isos (Ast0.get_iso i)) + (match Ast0.unwrap i with + Ast0.Id(name) -> Ast.Id(mcode name) + | Ast0.MetaId(name,constraints,_) -> + let constraints = List.map ident constraints in + Ast.MetaId(mcode name,constraints,unitary,false) + | Ast0.MetaFunc(name,constraints,_) -> + let constraints = List.map ident constraints in + Ast.MetaFunc(mcode name,constraints,unitary,false) + | Ast0.MetaLocalFunc(name,constraints,_) -> + let constraints = List.map ident constraints in + Ast.MetaLocalFunc(mcode name,constraints,unitary,false) + | Ast0.OptIdent(id) -> Ast.OptIdent(ident id) + | Ast0.UniqueIdent(id) -> Ast.UniqueIdent(ident id)) + +(* --------------------------------------------------------------------- *) +(* Expression *) + +and expression e = + let e1 = + rewrap e (do_isos (Ast0.get_iso e)) + (match Ast0.unwrap e with + Ast0.Ident(id) -> Ast.Ident(ident id) + | Ast0.Constant(const) -> + Ast.Constant(mcode const) + | Ast0.FunCall(fn,lp,args,rp) -> + let fn = expression fn in + let lp = mcode lp in + let args = dots expression args in + let rp = mcode rp in + Ast.FunCall(fn,lp,args,rp) + | Ast0.Assignment(left,op,right,simple) -> + Ast.Assignment(expression left,mcode op,expression right,simple) + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> + let exp1 = expression exp1 in + let why = mcode why in + let exp2 = get_option expression exp2 in + let colon = mcode colon in + let exp3 = expression exp3 in + Ast.CondExpr(exp1,why,exp2,colon,exp3) + | Ast0.Postfix(exp,op) -> + Ast.Postfix(expression exp,mcode op) + | Ast0.Infix(exp,op) -> + Ast.Infix(expression exp,mcode op) + | Ast0.Unary(exp,op) -> + Ast.Unary(expression exp,mcode op) + | Ast0.Binary(left,op,right) -> + Ast.Binary(expression left,mcode op,expression right) + | Ast0.Nested(left,op,right) -> + Ast.Nested(expression left,mcode op,expression right) + | Ast0.Paren(lp,exp,rp) -> + Ast.Paren(mcode lp,expression exp,mcode rp) + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> + Ast.ArrayAccess(expression exp1,mcode lb,expression exp2,mcode rb) + | Ast0.RecordAccess(exp,pt,field) -> + Ast.RecordAccess(expression exp,mcode pt,ident field) + | Ast0.RecordPtAccess(exp,ar,field) -> + Ast.RecordPtAccess(expression exp,mcode ar,ident field) + | Ast0.Cast(lp,ty,rp,exp) -> + Ast.Cast(mcode lp,typeC ty,mcode rp,expression exp) + | Ast0.SizeOfExpr(szf,exp) -> + Ast.SizeOfExpr(mcode szf,expression exp) + | Ast0.SizeOfType(szf,lp,ty,rp) -> + Ast.SizeOfType(mcode szf, mcode lp,typeC ty,mcode rp) + | Ast0.TypeExp(ty) -> Ast.TypeExp(typeC ty) + | Ast0.MetaErr(name,constraints,_) -> + let constraints = List.map expression constraints in + Ast.MetaErr(mcode name,constraints,unitary,false) + | Ast0.MetaExpr(name,constraints,ty,form,_) -> + let constraints = List.map expression constraints in + Ast.MetaExpr(mcode name,constraints,unitary,ty,form,false) + | Ast0.MetaExprList(name,Some lenname,_) -> + Ast.MetaExprList(mcode name,Some (mcode lenname,unitary,false), + unitary,false) + | Ast0.MetaExprList(name,None,_) -> + Ast.MetaExprList(mcode name,None,unitary,false) + | Ast0.EComma(cm) -> Ast.EComma(mcode cm) + | Ast0.DisjExpr(_,exps,_,_) -> Ast.DisjExpr(List.map expression exps) + | Ast0.NestExpr(_,exp_dots,_,whencode,multi) -> + let whencode = get_option expression whencode in + Ast.NestExpr(dots expression exp_dots,whencode,multi) + | Ast0.Edots(dots,whencode) -> + let dots = mcode dots in + let whencode = get_option expression whencode in + Ast.Edots(dots,whencode) + | Ast0.Ecircles(dots,whencode) -> + let dots = mcode dots in + let whencode = get_option expression whencode in + Ast.Ecircles(dots,whencode) + | Ast0.Estars(dots,whencode) -> + let dots = mcode dots in + let whencode = get_option expression whencode in + Ast.Estars(dots,whencode) + | Ast0.OptExp(exp) -> Ast.OptExp(expression exp) + | Ast0.UniqueExp(exp) -> Ast.UniqueExp(expression exp)) in + if Ast0.get_test_exp e then Ast.set_test_exp e1 else e1 + +and expression_dots ed = dots expression ed + +(* --------------------------------------------------------------------- *) +(* Types *) + +and rewrap_iso t t1 = rewrap t (do_isos (Ast0.get_iso t)) t1 + +and typeC t = + rewrap t (do_isos (Ast0.get_iso t)) + (match Ast0.unwrap t with + Ast0.ConstVol(cv,ty) -> + let rec collect_disjs t = + match Ast0.unwrap t with + Ast0.DisjType(_,types,_,_) -> + if Ast0.get_iso t = [] + then List.concat (List.map collect_disjs types) + else failwith "unexpected iso on a disjtype" + | _ -> [t] in + let res = + List.map + (function ty -> + Ast.Type + (Some (mcode cv),rewrap_iso ty (base_typeC ty))) + (collect_disjs ty) in + (* one could worry that isos are lost because we flatten the + disjunctions. but there should not be isos on the disjunctions + themselves. *) + (match res with + [ty] -> ty + | types -> Ast.DisjType(List.map (rewrap t no_isos) types)) + | Ast0.BaseType(_) | Ast0.Signed(_,_) | Ast0.Pointer(_,_) + | Ast0.FunctionPointer(_,_,_,_,_,_,_) | Ast0.FunctionType(_,_,_,_) + | Ast0.Array(_,_,_,_) | Ast0.EnumName(_,_) | Ast0.StructUnionName(_,_) + | Ast0.StructUnionDef(_,_,_,_) | Ast0.TypeName(_) | Ast0.MetaType(_,_) -> + Ast.Type(None,rewrap t no_isos (base_typeC t)) + | Ast0.DisjType(_,types,_,_) -> Ast.DisjType(List.map typeC types) + | Ast0.OptType(ty) -> Ast.OptType(typeC ty) + | Ast0.UniqueType(ty) -> Ast.UniqueType(typeC ty)) + +and base_typeC t = + match Ast0.unwrap t with + Ast0.BaseType(ty,strings) -> Ast.BaseType(ty,List.map mcode strings) + | Ast0.Signed(sgn,ty) -> + Ast.SignedT(mcode sgn, + get_option (function x -> rewrap_iso x (base_typeC x)) ty) + | Ast0.Pointer(ty,star) -> Ast.Pointer(typeC ty,mcode star) + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + Ast.FunctionPointer + (typeC ty,mcode lp1,mcode star,mcode rp1, + mcode lp2,parameter_list params,mcode rp2) + | Ast0.FunctionType(ret,lp,params,rp) -> + let allminus = check_allminus.V0.combiner_typeC t in + Ast.FunctionType + (allminus,get_option typeC ret,mcode lp, + parameter_list params,mcode rp) + | Ast0.Array(ty,lb,size,rb) -> + Ast.Array(typeC ty,mcode lb,get_option expression size,mcode rb) + | Ast0.EnumName(kind,name) -> + Ast.EnumName(mcode kind,ident name) + | Ast0.StructUnionName(kind,name) -> + Ast.StructUnionName(mcode kind,get_option ident name) + | Ast0.StructUnionDef(ty,lb,decls,rb) -> + Ast.StructUnionDef(typeC ty,mcode lb, + dots declaration decls, + mcode rb) + | Ast0.TypeName(name) -> Ast.TypeName(mcode name) + | Ast0.MetaType(name,_) -> + Ast.MetaType(mcode name,unitary,false) + | _ -> failwith "ast0toast: unexpected type" + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and declaration d = + rewrap d (do_isos (Ast0.get_iso d)) + (match Ast0.unwrap d with + Ast0.Init(stg,ty,id,eq,ini,sem) -> + let stg = get_option mcode stg in + let ty = typeC ty in + let id = ident id in + let eq = mcode eq in + let ini = initialiser ini in + let sem = mcode sem in + Ast.Init(stg,ty,id,eq,ini,sem) + | Ast0.UnInit(stg,ty,id,sem) -> + (match Ast0.unwrap ty with + Ast0.FunctionType(tyx,lp1,params,rp1) -> + let allminus = check_allminus.V0.combiner_declaration d in + Ast.UnInit(get_option mcode stg, + rewrap ty (do_isos (Ast0.get_iso ty)) + (Ast.Type + (None, + rewrap ty no_isos + (Ast.FunctionType + (allminus,get_option typeC tyx,mcode lp1, + parameter_list params,mcode rp1)))), + ident id,mcode sem) + | _ -> Ast.UnInit(get_option mcode stg,typeC ty,ident id,mcode sem)) + | Ast0.MacroDecl(name,lp,args,rp,sem) -> + let name = ident name in + let lp = mcode lp in + let args = dots expression args in + let rp = mcode rp in + let sem = mcode sem in + Ast.MacroDecl(name,lp,args,rp,sem) + | Ast0.TyDecl(ty,sem) -> Ast.TyDecl(typeC ty,mcode sem) + | Ast0.Typedef(stg,ty,id,sem) -> + let id = typeC id in + (match Ast.unwrap id with + Ast.Type(None,id) -> (* only MetaType or Id *) + Ast.Typedef(mcode stg,typeC ty,id,mcode sem) + | _ -> failwith "bad typedef") + | Ast0.DisjDecl(_,decls,_,_) -> Ast.DisjDecl(List.map declaration decls) + | Ast0.Ddots(dots,whencode) -> + let dots = mcode dots in + let whencode = get_option declaration whencode in + Ast.Ddots(dots,whencode) + | Ast0.OptDecl(decl) -> Ast.OptDecl(declaration decl) + | Ast0.UniqueDecl(decl) -> Ast.UniqueDecl(declaration decl)) + +and declaration_dots l = dots declaration l + +(* --------------------------------------------------------------------- *) +(* Initialiser *) + +and strip_idots initlist = + match Ast0.unwrap initlist with + Ast0.DOTS(x) -> + let (whencode,init) = + List.fold_left + (function (prevwhen,previnit) -> + function cur -> + match Ast0.unwrap cur with + Ast0.Idots(dots,Some whencode) -> + (whencode :: prevwhen, previnit) + | Ast0.Idots(dots,None) -> (prevwhen,previnit) + | _ -> (prevwhen, cur :: previnit)) + ([],[]) x in + (List.rev whencode, List.rev init) + | Ast0.CIRCLES(x) | Ast0.STARS(x) -> failwith "not possible for an initlist" + +and initialiser i = + rewrap i no_isos + (match Ast0.unwrap i with + Ast0.InitExpr(exp) -> Ast.InitExpr(expression exp) + | Ast0.InitList(lb,initlist,rb) -> + let (whencode,initlist) = strip_idots initlist in + Ast.InitList(mcode lb,List.map initialiser initlist,mcode rb, + List.map initialiser whencode) + | Ast0.InitGccDotName(dot,name,eq,ini) -> + Ast.InitGccDotName(mcode dot,ident name,mcode eq,initialiser ini) + | Ast0.InitGccName(name,eq,ini) -> + Ast.InitGccName(ident name,mcode eq,initialiser ini) + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> + Ast.InitGccIndex(mcode lb,expression exp,mcode rb,mcode eq, + initialiser ini) + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + Ast.InitGccRange(mcode lb,expression exp1,mcode dots, + expression exp2,mcode rb,mcode eq,initialiser ini) + | Ast0.IComma(comma) -> Ast.IComma(mcode comma) + | Ast0.Idots(_,_) -> failwith "Idots should have been removed" + | Ast0.OptIni(ini) -> Ast.OptIni(initialiser ini) + | Ast0.UniqueIni(ini) -> Ast.UniqueIni(initialiser ini)) + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and parameterTypeDef p = + rewrap p no_isos + (match Ast0.unwrap p with + Ast0.VoidParam(ty) -> Ast.VoidParam(typeC ty) + | Ast0.Param(ty,id) -> Ast.Param(typeC ty,get_option ident id) + | Ast0.MetaParam(name,_) -> + Ast.MetaParam(mcode name,unitary,false) + | Ast0.MetaParamList(name,Some lenname,_) -> + Ast.MetaParamList(mcode name,Some(mcode lenname,unitary,false), + unitary,false) + | Ast0.MetaParamList(name,None,_) -> + Ast.MetaParamList(mcode name,None,unitary,false) + | Ast0.PComma(cm) -> Ast.PComma(mcode cm) + | Ast0.Pdots(dots) -> Ast.Pdots(mcode dots) + | Ast0.Pcircles(dots) -> Ast.Pcircles(mcode dots) + | Ast0.OptParam(param) -> Ast.OptParam(parameterTypeDef param) + | Ast0.UniqueParam(param) -> Ast.UniqueParam(parameterTypeDef param)) + +and parameter_list l = dots parameterTypeDef l + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +and statement s = + let rec statement seqible s = + let rewrap_stmt ast0 ast = + let befaft = + match Ast0.get_dots_bef_aft s with + Ast0.NoDots -> Ast.NoDots + | Ast0.DroppingBetweenDots s -> + Ast.DroppingBetweenDots (statement seqible s,get_ctr()) + | Ast0.AddingBetweenDots s -> + Ast.AddingBetweenDots (statement seqible s,get_ctr()) in + Ast.set_dots_bef_aft befaft (rewrap ast0 no_isos ast) in + let rewrap_rule_elem ast0 ast = + rewrap ast0 (do_isos (Ast0.get_iso ast0)) ast in + rewrap_stmt s + (match Ast0.unwrap s with + Ast0.Decl((_,bef),decl) -> + Ast.Atomic(rewrap_rule_elem s + (Ast.Decl(convert_mcodekind bef, + check_allminus.V0.combiner_statement s, + declaration decl))) + | Ast0.Seq(lbrace,body,rbrace) -> + let lbrace = mcode lbrace in + let (decls,body) = separate_decls seqible body in + let rbrace = mcode rbrace in + Ast.Seq(iso_tokenwrap lbrace s (Ast.SeqStart(lbrace)) + (do_isos (Ast0.get_iso s)), + decls,body, + tokenwrap rbrace s (Ast.SeqEnd(rbrace))) + | Ast0.ExprStatement(exp,sem) -> + Ast.Atomic(rewrap_rule_elem s + (Ast.ExprStatement(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 aft)) + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(_,aft)) -> + let els = mcode els in + Ast.IfThenElse + (rewrap_rule_elem s + (Ast.IfHeader(mcode iff,mcode lp,expression exp,mcode rp)), + statement Ast.NotSequencible branch1, + tokenwrap els s (Ast.Else(els)), + statement Ast.NotSequencible branch2, + ([],[],[],convert_mcodekind 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 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)), + statement Ast.NotSequencible body, + tokenwrap wh s + (Ast.WhileTail(wh,mcode lp,expression exp,mcode rp, + mcode sem))) + | Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,(_,aft)) -> + let fr = mcode fr in + let lp = mcode lp in + let exp1 = get_option expression exp1 in + let sem1 = mcode sem1 in + let exp2 = get_option expression exp2 in + let sem2= mcode sem2 in + let exp3 = get_option expression exp3 in + let rp = mcode rp in + let body = statement Ast.NotSequencible body in + Ast.For(rewrap_rule_elem s + (Ast.ForHeader(fr,lp,exp1,sem1,exp2,sem2,exp3,rp)), + body,([],[],[],convert_mcodekind 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 aft)) + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> + let switch = mcode switch in + let lp = mcode lp in + let exp = expression exp in + let rp = mcode rp in + let lb = mcode lb in + let cases = List.map case_line (Ast0.undots cases) in + let rb = mcode rb in + Ast.Switch(rewrap_rule_elem s (Ast.SwitchHeader(switch,lp,exp,rp)), + tokenwrap lb s (Ast.SeqStart(lb)), + cases, + tokenwrap rb s (Ast.SeqEnd(rb))) + | Ast0.Break(br,sem) -> + Ast.Atomic(rewrap_rule_elem s (Ast.Break(mcode br,mcode sem))) + | Ast0.Continue(cont,sem) -> + Ast.Atomic(rewrap_rule_elem s (Ast.Continue(mcode cont,mcode sem))) + | Ast0.Label(l,dd) -> + Ast.Atomic(rewrap_rule_elem s (Ast.Label(ident l,mcode dd))) + | Ast0.Goto(goto,l,sem) -> + Ast.Atomic + (rewrap_rule_elem s (Ast.Goto(mcode goto,ident l,mcode sem))) + | Ast0.Return(ret,sem) -> + Ast.Atomic(rewrap_rule_elem s (Ast.Return(mcode ret,mcode sem))) + | Ast0.ReturnExpr(ret,exp,sem) -> + Ast.Atomic + (rewrap_rule_elem s + (Ast.ReturnExpr(mcode ret,expression exp,mcode sem))) + | Ast0.MetaStmt(name,_) -> + Ast.Atomic(rewrap_rule_elem s + (Ast.MetaStmt(mcode name,unitary,seqible,false))) + | Ast0.MetaStmtList(name,_) -> + Ast.Atomic(rewrap_rule_elem s + (Ast.MetaStmtList(mcode name,unitary,false))) + | Ast0.TopExp(exp) -> + Ast.Atomic(rewrap_rule_elem s (Ast.TopExp(expression exp))) + | Ast0.Exp(exp) -> + Ast.Atomic(rewrap_rule_elem s (Ast.Exp(expression exp))) + | Ast0.TopInit(init) -> + Ast.Atomic(rewrap_rule_elem s (Ast.TopInit(initialiser init))) + | Ast0.Ty(ty) -> + Ast.Atomic(rewrap_rule_elem s (Ast.Ty(typeC ty))) + | Ast0.Disj(_,rule_elem_dots_list,_,_) -> + Ast.Disj(List.map (function x -> statement_dots seqible x) + rule_elem_dots_list) + | Ast0.Nest(_,rule_elem_dots,_,whn,multi) -> + Ast.Nest + (statement_dots Ast.Sequencible rule_elem_dots, + List.map + (whencode (statement_dots Ast.Sequencible) + (statement Ast.NotSequencible)) + whn, + multi,[],[]) + | Ast0.Dots(d,whn) -> + let d = mcode d in + let whn = + List.map + (whencode (statement_dots Ast.Sequencible) + (statement Ast.NotSequencible)) + whn in + Ast.Dots(d,whn,[],[]) + | Ast0.Circles(d,whn) -> + let d = mcode d in + let whn = + List.map + (whencode (statement_dots Ast.Sequencible) + (statement Ast.NotSequencible)) + whn in + Ast.Circles(d,whn,[],[]) + | Ast0.Stars(d,whn) -> + let d = mcode d in + let whn = + List.map + (whencode (statement_dots Ast.Sequencible) + (statement Ast.NotSequencible)) + whn in + Ast.Stars(d,whn,[],[]) + | Ast0.FunDecl((_,bef),fi,name,lp,params,rp,lbrace,body,rbrace) -> + let fi = List.map fninfo fi in + let name = ident name in + let lp = mcode lp in + let params = parameter_list params in + let rp = mcode rp in + let lbrace = mcode lbrace in + let (decls,body) = separate_decls seqible body in + let rbrace = mcode rbrace in + let allminus = check_allminus.V0.combiner_statement s in + Ast.FunDecl(rewrap_rule_elem s + (Ast.FunHeader(convert_mcodekind bef, + allminus,fi,name,lp,params,rp)), + tokenwrap lbrace s (Ast.SeqStart(lbrace)), + decls,body, + tokenwrap rbrace s (Ast.SeqEnd(rbrace))) + | Ast0.Include(inc,str) -> + Ast.Atomic(rewrap_rule_elem s (Ast.Include(mcode inc,mcode str))) + | Ast0.Define(def,id,params,body) -> + Ast.Define + (rewrap_rule_elem s + (Ast.DefineHeader + (mcode def,ident id, define_parameters params)), + statement_dots Ast.NotSequencible (*not sure*) body) + | Ast0.OptStm(stm) -> Ast.OptStm(statement seqible stm) + | Ast0.UniqueStm(stm) -> Ast.UniqueStm(statement seqible stm)) + + and define_parameters p = + rewrap p no_isos + (match Ast0.unwrap p with + Ast0.NoParams -> Ast.NoParams + | Ast0.DParams(lp,params,rp) -> + Ast.DParams(mcode lp, + dots define_param params, + mcode rp)) + + and define_param p = + rewrap p no_isos + (match Ast0.unwrap p with + Ast0.DParam(id) -> Ast.DParam(ident id) + | Ast0.DPComma(comma) -> Ast.DPComma(mcode comma) + | Ast0.DPdots(d) -> Ast.DPdots(mcode d) + | Ast0.DPcircles(c) -> Ast.DPcircles(mcode c) + | Ast0.OptDParam(dp) -> Ast.OptDParam(define_param dp) + | Ast0.UniqueDParam(dp) -> Ast.UniqueDParam(define_param dp)) + + and whencode notfn alwaysfn = function + Ast0.WhenNot a -> Ast.WhenNot (notfn a) + | Ast0.WhenAlways a -> Ast.WhenAlways (alwaysfn a) + | Ast0.WhenModifier(x) -> Ast.WhenModifier(x) + | x -> + let rewrap_rule_elem ast0 ast = + rewrap ast0 (do_isos (Ast0.get_iso ast0)) ast in + match x with + Ast0.WhenNotTrue(e) -> + Ast.WhenNotTrue(rewrap_rule_elem e (Ast.Exp(expression e))) + | Ast0.WhenNotFalse(e) -> + Ast.WhenNotFalse(rewrap_rule_elem e (Ast.Exp(expression e))) + | _ -> failwith "not possible" + + and process_list seqible isos = function + [] -> [] + | x::rest -> + let first = statement seqible x in + let first = + if !Flag.track_iso_usage + then Ast.set_isos first (isos@(Ast.get_isos first)) + else first in + (match Ast0.unwrap x with + Ast0.Dots(_,_) | Ast0.Nest(_) -> + first::(process_list (Ast.SequencibleAfterDots []) no_isos rest) + | _ -> + first::(process_list Ast.Sequencible no_isos rest)) + + and statement_dots seqible d = + let isos = do_isos (Ast0.get_iso d) in + rewrap d no_isos + (match Ast0.unwrap d with + Ast0.DOTS(x) -> Ast.DOTS(process_list seqible isos x) + | Ast0.CIRCLES(x) -> Ast.CIRCLES(process_list seqible isos x) + | Ast0.STARS(x) -> Ast.STARS(process_list seqible isos x)) + + and separate_decls seqible d = + let rec collect_decls = function + [] -> ([],[]) + | (x::xs) as l -> + (match Ast0.unwrap x with + Ast0.Decl(_) -> + let (decls,other) = collect_decls xs in + (x :: decls,other) + | Ast0.Dots(_,_) | Ast0.Nest(_,_,_,_,_) -> + let (decls,other) = collect_decls xs in + (match decls with + [] -> ([],x::other) + | _ -> (x :: decls,other)) + | Ast0.Disj(starter,stmt_dots_list,mids,ender) -> + let disjs = List.map collect_dot_decls stmt_dots_list in + let all_decls = List.for_all (function (_,s) -> s=[]) disjs in + if all_decls + then + let (decls,other) = collect_decls xs in + (x :: decls,other) + else ([],l) + | _ -> ([],l)) + + and collect_dot_decls d = + match Ast0.unwrap d with + Ast0.DOTS(x) -> collect_decls x + | Ast0.CIRCLES(x) -> collect_decls x + | Ast0.STARS(x) -> collect_decls x in + + let process l d fn = + let (decls,other) = collect_decls l in + (rewrap d no_isos (fn (List.map (statement seqible) decls)), + rewrap d no_isos + (fn (process_list seqible (do_isos (Ast0.get_iso d)) other))) in + match Ast0.unwrap d with + Ast0.DOTS(x) -> process x d (function x -> Ast.DOTS x) + | Ast0.CIRCLES(x) -> process x d (function x -> Ast.CIRCLES x) + | Ast0.STARS(x) -> process x d (function x -> Ast.STARS x) in + + statement Ast.Sequencible s + +and fninfo = function + Ast0.FStorage(stg) -> Ast.FStorage(mcode stg) + | Ast0.FType(ty) -> Ast.FType(typeC ty) + | Ast0.FInline(inline) -> Ast.FInline(mcode inline) + | Ast0.FAttr(attr) -> Ast.FAttr(mcode attr) + +and option_to_list = function + Some x -> [x] + | None -> [] + +and case_line c = + rewrap c no_isos + (match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> + let def = mcode def in + let colon = mcode colon in + let code = dots statement code in + Ast.CaseLine(rewrap c no_isos (Ast.Default(def,colon)),code) + | Ast0.Case(case,exp,colon,code) -> + let case = mcode case in + let exp = expression exp in + let colon = mcode colon in + let code = dots statement code in + Ast.CaseLine(rewrap c no_isos (Ast.Case(case,exp,colon)),code) + | Ast0.OptCase(case) -> Ast.OptCase(case_line case)) + +and statement_dots l = dots statement l + +(* --------------------------------------------------------------------- *) + +(* what is possible is only what is at the top level in an iso *) +and anything = function + Ast0.DotsExprTag(d) -> Ast.ExprDotsTag(expression_dots d) + | Ast0.DotsParamTag(d) -> Ast.ParamDotsTag(parameter_list d) + | Ast0.DotsInitTag(d) -> failwith "not possible" + | Ast0.DotsStmtTag(d) -> Ast.StmtDotsTag(statement_dots d) + | Ast0.DotsDeclTag(d) -> Ast.DeclDotsTag(declaration_dots d) + | Ast0.DotsCaseTag(d) -> failwith "not possible" + | Ast0.IdentTag(d) -> Ast.IdentTag(ident d) + | Ast0.ExprTag(d) -> Ast.ExpressionTag(expression d) + | Ast0.ArgExprTag(d) | Ast0.TestExprTag(d) -> + failwith "only in isos, not converted to ast" + | Ast0.TypeCTag(d) -> Ast.FullTypeTag(typeC d) + | Ast0.ParamTag(d) -> Ast.ParamTag(parameterTypeDef d) + | Ast0.InitTag(d) -> Ast.InitTag(initialiser d) + | Ast0.DeclTag(d) -> Ast.DeclarationTag(declaration d) + | Ast0.StmtTag(d) -> Ast.StatementTag(statement d) + | Ast0.CaseLineTag(d) -> Ast.CaseLineTag(case_line d) + | Ast0.TopTag(d) -> Ast.Code(top_level d) + | Ast0.IsoWhenTag(_) -> failwith "not possible" + | Ast0.IsoWhenTTag(_) -> failwith "not possible" + | Ast0.IsoWhenFTag(_) -> failwith "not possible" + | Ast0.MetaPosTag _ -> failwith "not possible" + +(* --------------------------------------------------------------------- *) +(* Function declaration *) +(* top level isos are probably lost to tracking *) + +and top_level t = + rewrap t no_isos + (match Ast0.unwrap t with + Ast0.FILEINFO(old_file,new_file) -> + Ast.FILEINFO(mcode old_file,mcode new_file) + | Ast0.DECL(stmt) -> Ast.DECL(statement stmt) + | Ast0.CODE(rule_elem_dots) -> + Ast.CODE(statement_dots rule_elem_dots) + | Ast0.ERRORWORDS(exps) -> Ast.ERRORWORDS(List.map expression exps) + | Ast0.OTHER(_) -> failwith "eliminated by top_level") + +(* --------------------------------------------------------------------- *) +(* Entry point for minus code *) + +(* Inline_mcodes is very important - sends + code attached to the - code +down to the mcodes. The functions above can only be used when there is no +attached + code, eg in + code itself. *) +let ast0toast_toplevel x = + inline_mcodes.V0.combiner_top_level x; + top_level x + +let ast0toast name deps dropped exists x is_exp ruletype = + List.iter inline_mcodes.V0.combiner_top_level x; + Ast.CocciRule + (name,(deps,dropped,exists),List.map top_level x,is_exp,ruletype) diff --git a/parsing_cocci/.#ast_cocci.ml.1.149 b/parsing_cocci/.#ast_cocci.ml.1.149 new file mode 100644 index 0000000..4521d24 --- /dev/null +++ b/parsing_cocci/.#ast_cocci.ml.1.149 @@ -0,0 +1,678 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* --------------------------------------------------------------------- *) +(* Modified code *) + +type info = { line : int; column : int; + strbef : string list; straft : string list } +type line = int +type meta_name = string * string +(* need to be careful about rewrapping, to avoid duplicating pos info +currently, the pos info is always None until asttoctl2. *) +type 'a wrap = + {node : 'a; + node_line : line; + free_vars : meta_name list; (*free vars*) + minus_free_vars : meta_name list; (*minus free vars*) + fresh_vars : meta_name list; (*fresh vars*) + inherited : meta_name list; (*inherited vars*) + saved_witness : meta_name list; (*witness vars*) + bef_aft : dots_bef_aft; + (* the following is for or expressions *) + pos_info : meta_name mcode option; (* pos info, try not to duplicate *) + true_if_test_exp : bool;(* true if "test_exp from iso", only for exprs *) + (* isos relevant to the term; ultimately only used for rule_elems *) + iso_info : (string*anything) list } + +and 'a befaft = + BEFORE of 'a list list + | AFTER of 'a list list + | BEFOREAFTER of 'a list list * 'a list list + | NOTHING + +and 'a mcode = 'a * info * mcodekind * meta_pos (* pos variable *) + (* pos is an offset indicating where in the C code the mcodekind has an + effect *) + and mcodekind = + MINUS of pos * anything list list + | CONTEXT of pos * anything befaft + | PLUS + and fixpos = + Real of int (* charpos *) | Virt of int * int (* charpos + offset *) + and pos = NoPos | DontCarePos | FixPos of (fixpos * fixpos) + +and dots_bef_aft = + NoDots + | AddingBetweenDots of statement * int (*index of let var*) + | DroppingBetweenDots of statement * int (*index of let var*) + +and inherited = Type_cocci.inherited +and keep_binding = Type_cocci.keep_binding +and multi = bool (*true if a nest is one or more, false if it is zero or more*) + +and end_info = + meta_name list (*free vars*) * meta_name list (*inherited vars*) * + meta_name list (*witness vars*) * mcodekind + +(* --------------------------------------------------------------------- *) +(* Metavariables *) + +and arity = UNIQUE | OPT | MULTI | NONE + +and metavar = + MetaIdDecl of arity * meta_name (* name *) + | MetaFreshIdDecl of arity * meta_name (* name *) + | MetaTypeDecl of arity * meta_name (* name *) + | MetaListlenDecl of meta_name (* name *) + | MetaParamDecl of arity * meta_name (* name *) + | MetaParamListDecl of arity * meta_name (*name*) * meta_name option (*len*) + | MetaConstDecl of + arity * meta_name (* name *) * Type_cocci.typeC list option + | MetaErrDecl of arity * meta_name (* name *) + | MetaExpDecl of + arity * meta_name (* name *) * Type_cocci.typeC list option + | MetaIdExpDecl of + arity * meta_name (* name *) * Type_cocci.typeC list option + | MetaLocalIdExpDecl of + arity * meta_name (* name *) * Type_cocci.typeC list option + | MetaExpListDecl of arity * meta_name (*name*) * meta_name option (*len*) + | MetaStmDecl of arity * meta_name (* name *) + | MetaStmListDecl of arity * meta_name (* name *) + | MetaFuncDecl of arity * meta_name (* name *) + | MetaLocalFuncDecl of arity * meta_name (* name *) + | MetaPosDecl of arity * meta_name (* name *) + | MetaDeclarerDecl of arity * meta_name (* name *) + | MetaIteratorDecl of arity * meta_name (* name *) + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) +(* Dots *) + +and 'a base_dots = + DOTS of 'a list + | CIRCLES of 'a list + | STARS of 'a list + +and 'a dots = 'a base_dots wrap + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +and base_ident = + Id of string mcode + + | MetaId of meta_name mcode * ident list * keep_binding * inherited + | MetaFunc of meta_name mcode * ident list * keep_binding * inherited + | MetaLocalFunc of meta_name mcode * ident list * keep_binding * inherited + + | OptIdent of ident + | UniqueIdent of ident + +and ident = base_ident wrap + +(* --------------------------------------------------------------------- *) +(* Expression *) + +and base_expression = + Ident of ident + | Constant of constant mcode + | FunCall of expression * string mcode (* ( *) * + expression dots * string mcode (* ) *) + | Assignment of expression * assignOp mcode * expression * + bool (* true if it can match an initialization *) + | CondExpr of expression * string mcode (* ? *) * expression option * + string mcode (* : *) * expression + | Postfix of expression * fixOp mcode + | Infix of expression * fixOp mcode + | Unary of expression * unaryOp mcode + | Binary of expression * binaryOp mcode * expression + | Nested of expression * binaryOp mcode * expression + | ArrayAccess of expression * string mcode (* [ *) * expression * + string mcode (* ] *) + | RecordAccess of expression * string mcode (* . *) * ident + | RecordPtAccess of expression * string mcode (* -> *) * ident + | Cast of string mcode (* ( *) * fullType * string mcode (* ) *) * + expression + | SizeOfExpr of string mcode (* sizeof *) * expression + | SizeOfType of string mcode (* sizeof *) * string mcode (* ( *) * + fullType * string mcode (* ) *) + | TypeExp of fullType (*type name used as an expression, only in + arg or #define*) + + | Paren of string mcode (* ( *) * expression * + string mcode (* ) *) + + | MetaErr of meta_name mcode * expression list * keep_binding * + inherited + | MetaExpr of meta_name mcode * expression list * keep_binding * + Type_cocci.typeC list option * form * inherited + | MetaExprList of meta_name mcode * listlen option * keep_binding * + inherited (* only in arg lists *) + + | EComma of string mcode (* only in arg lists *) + + | DisjExpr of expression list + | NestExpr of expression dots * expression option * multi + + (* can appear in arg lists, and also inside Nest, as in: + if(< ... X ... Y ...>) + In the following, the expression option is the WHEN *) + | Edots of string mcode (* ... *) * expression option + | Ecircles of string mcode (* ooo *) * expression option + | Estars of string mcode (* *** *) * expression option + + | OptExp of expression + | UniqueExp of expression + +(* ANY = int E; ID = idexpression int X; CONST = constant int X; *) +and form = ANY | ID | LocalID | CONST (* form for MetaExp *) + +and expression = base_expression wrap + +and listlen = meta_name mcode * keep_binding * inherited + +and unaryOp = GetRef | DeRef | UnPlus | UnMinus | Tilde | Not +and assignOp = SimpleAssign | OpAssign of arithOp +and fixOp = Dec | Inc + +and binaryOp = Arith of arithOp | Logical of logicalOp +and arithOp = + Plus | Minus | Mul | Div | Mod | DecLeft | DecRight | And | Or | Xor +and logicalOp = Inf | Sup | InfEq | SupEq | Eq | NotEq | AndLog | OrLog + +and constant = + String of string + | Char of string + | Int of string + | Float of string + +(* --------------------------------------------------------------------- *) +(* Types *) + +and base_fullType = + Type of const_vol mcode option * typeC + | DisjType of fullType list (* only after iso *) + | OptType of fullType + | UniqueType of fullType + +and base_typeC = + BaseType of baseType * string mcode list (* Yoann style *) + | SignedT of sign mcode * typeC option + | Pointer of fullType * string mcode (* * *) + | FunctionPointer of fullType * + string mcode(* ( *)*string mcode(* * *)*string mcode(* ) *)* + string mcode (* ( *)*parameter_list*string mcode(* ) *) + + (* used for the automatic managment of prototypes *) + | FunctionType of bool (* true if all minus for dropping return type *) * + fullType option * + string mcode (* ( *) * parameter_list * + string mcode (* ) *) + + | Array of fullType * string mcode (* [ *) * + expression option * string mcode (* ] *) + | EnumName of string mcode (*enum*) * ident (* name *) + | StructUnionName of structUnion mcode * ident option (* name *) + | StructUnionDef of fullType (* either StructUnionName or metavar *) * + string mcode (* { *) * declaration dots * string mcode (* } *) + | TypeName of string mcode + + | MetaType of meta_name mcode * keep_binding * inherited + +and fullType = base_fullType wrap +and typeC = base_typeC wrap + +and baseType = VoidType | CharType | ShortType | IntType | DoubleType + | FloatType | LongType | LongLongType + +and structUnion = Struct | Union + +and sign = Signed | Unsigned + +and const_vol = Const | Volatile + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and base_declaration = + Init of storage mcode option * fullType * ident * string mcode (*=*) * + initialiser * string mcode (*;*) + | UnInit of storage mcode option * fullType * ident * string mcode (* ; *) + | TyDecl of fullType * string mcode (* ; *) + | MacroDecl of ident (* name *) * string mcode (* ( *) * + expression dots * string mcode (* ) *) * string mcode (* ; *) + | Typedef of string mcode (*typedef*) * fullType * + typeC (* either TypeName or metavar *) * string mcode (*;*) + | DisjDecl of declaration list + (* Ddots is for a structure declaration *) + | Ddots of string mcode (* ... *) * declaration option (* whencode *) + + | MetaDecl of meta_name mcode * keep_binding * inherited + + | OptDecl of declaration + | UniqueDecl of declaration + +and declaration = base_declaration wrap + +(* --------------------------------------------------------------------- *) +(* Initializers *) + +and base_initialiser = + InitExpr of expression + | InitList of string mcode (*{*) * initialiser list * string mcode (*}*) * + initialiser list (* whencode: elements that shouldn't appear in init *) + | InitGccDotName of + string mcode (*.*) * ident (* name *) * string mcode (*=*) * + initialiser (* gccext: *) + | InitGccName of ident (* name *) * string mcode (*:*) * + initialiser + | InitGccIndex of + string mcode (*[*) * expression * string mcode (*]*) * + string mcode (*=*) * initialiser + | InitGccRange of + string mcode (*[*) * expression * string mcode (*...*) * + expression * string mcode (*]*) * string mcode (*=*) * initialiser + | IComma of string mcode (* , *) + + | OptIni of initialiser + | UniqueIni of initialiser + +and initialiser = base_initialiser wrap + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and base_parameterTypeDef = + VoidParam of fullType + | Param of fullType * ident option + + | MetaParam of meta_name mcode * keep_binding * inherited + | MetaParamList of meta_name mcode * listlen option * keep_binding * + inherited + + | PComma of string mcode + + | Pdots of string mcode (* ... *) + | Pcircles of string mcode (* ooo *) + + | OptParam of parameterTypeDef + | UniqueParam of parameterTypeDef + +and parameterTypeDef = base_parameterTypeDef wrap + +and parameter_list = parameterTypeDef dots + +(* --------------------------------------------------------------------- *) +(* #define Parameters *) + +and base_define_param = + DParam of ident + | DPComma of string mcode + | DPdots of string mcode (* ... *) + | DPcircles of string mcode (* ooo *) + | OptDParam of define_param + | UniqueDParam of define_param + +and define_param = base_define_param wrap + +and base_define_parameters = + NoParams (* not parameter list, not an empty one *) + | DParams of string mcode(*( *) * define_param dots * string mcode(* )*) + +and define_parameters = base_define_parameters wrap + +(* --------------------------------------------------------------------- *) +(* positions *) + +(* PER = keep bindings separate, ALL = collect them *) +and meta_collect = PER | ALL + +and meta_pos = + MetaPos of meta_name mcode * meta_name list * + meta_collect * keep_binding * inherited + | NoMetaPos + +(* --------------------------------------------------------------------- *) +(* Function declaration *) + +and storage = Static | Auto | Register | Extern + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +and base_rule_elem = + FunHeader of mcodekind (* before the function header *) * + bool (* true if all minus, for dropping static, etc *) * + fninfo list * ident (* name *) * + string mcode (* ( *) * parameter_list * + string mcode (* ) *) + | Decl of mcodekind (* before the decl *) * + bool (* true if all minus *) * declaration + + | SeqStart of string mcode (* { *) + | SeqEnd of string mcode (* } *) + + | ExprStatement of expression * string mcode (*;*) + | IfHeader of string mcode (* if *) * string mcode (* ( *) * + expression * string mcode (* ) *) + | Else of string mcode (* else *) + | WhileHeader of string mcode (* while *) * string mcode (* ( *) * + expression * string mcode (* ) *) + | DoHeader of string mcode (* do *) + | WhileTail of string mcode (* while *) * string mcode (* ( *) * + expression * string mcode (* ) *) * + string mcode (* ; *) + | ForHeader of string mcode (* for *) * string mcode (* ( *) * + expression option * string mcode (*;*) * + expression option * string mcode (*;*) * + expression option * string mcode (* ) *) + | IteratorHeader of ident (* name *) * string mcode (* ( *) * + expression dots * string mcode (* ) *) + | SwitchHeader of string mcode (* switch *) * string mcode (* ( *) * + expression * string mcode (* ) *) + | Break of string mcode (* break *) * string mcode (* ; *) + | Continue of string mcode (* continue *) * string mcode (* ; *) + | Label of ident * string mcode (* : *) + | Goto of string mcode (* goto *) * ident * string mcode (* ; *) + | Return of string mcode (* return *) * string mcode (* ; *) + | ReturnExpr of string mcode (* return *) * expression * + string mcode (* ; *) + + | MetaRuleElem of meta_name mcode * keep_binding * inherited + | MetaStmt of meta_name mcode * keep_binding * metaStmtInfo * + inherited + | MetaStmtList of meta_name mcode * keep_binding * inherited + + | Exp of expression (* matches a subterm *) + | TopExp of expression (* for macros body, exp at top level, + not subexp *) + | Ty of fullType (* only at SP top level, matches a subterm *) + | TopInit of initialiser (* only at top level *) + | Include of string mcode (*#include*) * inc_file mcode (*file *) + | DefineHeader of string mcode (* #define *) * ident (* name *) * + define_parameters (*params*) + | Case of string mcode (* case *) * expression * string mcode (*:*) + | Default of string mcode (* default *) * string mcode (*:*) + | DisjRuleElem of rule_elem list + +and fninfo = + FStorage of storage mcode + | FType of fullType + | FInline of string mcode + | FAttr of string mcode + +and metaStmtInfo = + NotSequencible | SequencibleAfterDots of dots_whencode list | Sequencible + +and rule_elem = base_rule_elem wrap + +and base_statement = + Seq of rule_elem (* { *) * statement dots * + statement dots * rule_elem (* } *) + | IfThen of rule_elem (* header *) * statement * end_info (* endif *) + | IfThenElse of rule_elem (* header *) * statement * + rule_elem (* else *) * statement * end_info (* endif *) + | While of rule_elem (* header *) * statement * end_info (*endwhile*) + | Do of rule_elem (* do *) * statement * rule_elem (* tail *) + | For of rule_elem (* header *) * statement * end_info (*endfor*) + | Iterator of rule_elem (* header *) * statement * end_info (*enditer*) + | Switch of rule_elem (* header *) * rule_elem (* { *) * + case_line list * rule_elem (* } *) + | Atomic of rule_elem + | Disj of statement dots list + | Nest of statement dots * + (statement dots,statement) whencode list * multi * + dots_whencode list * dots_whencode list + | FunDecl of rule_elem (* header *) * rule_elem (* { *) * + statement dots * statement dots * rule_elem (* } *) + | Define of rule_elem (* header *) * statement dots + | Dots of string mcode (* ... *) * + (statement dots,statement) whencode list * + dots_whencode list * dots_whencode list + | Circles of string mcode (* ooo *) * + (statement dots,statement) whencode list * + dots_whencode list * dots_whencode list + | Stars of string mcode (* *** *) * + (statement dots,statement) whencode list * + dots_whencode list * dots_whencode list + | OptStm of statement + | UniqueStm of statement + +and ('a,'b) whencode = + WhenNot of 'a + | WhenAlways of 'b + | WhenModifier of when_modifier + | WhenNotTrue of rule_elem (* useful for fvs *) + | WhenNotFalse of rule_elem + +and when_modifier = + (* The following removes the shortest path constraint. It can be used + with other when modifiers *) + WhenAny + (* The following removes the special consideration of error paths. It + can be used with other when modifiers *) + | WhenStrict + | WhenForall + | WhenExists + +(* only used with asttoctl *) +and dots_whencode = + WParen of rule_elem * meta_name (*pren_var*) + | Other of statement + | Other_dots of statement dots + +and statement = base_statement wrap + +and base_case_line = + CaseLine of rule_elem (* case/default header *) * statement dots + | OptCase of case_line + +and case_line = base_case_line wrap + +and inc_file = + Local of inc_elem list + | NonLocal of inc_elem list + +and inc_elem = + IncPath of string + | IncDots + +and base_top_level = + DECL of statement + | CODE of statement dots + | FILEINFO of string mcode (* old file *) * string mcode (* new file *) + | ERRORWORDS of expression list + +and top_level = base_top_level wrap + +and rulename = + CocciRulename of string option * dependency * + string list * string list * exists * bool + | GeneratedRulename of string option * dependency * + string list * string list * exists * bool + | ScriptRulename of string * dependency + +and ruletype = Normal | Generated + +and rule = + CocciRule of string (* name *) * + (dependency * string list (* dropped isos *) * exists) * top_level list + * bool list * ruletype + | ScriptRule of string * dependency * (string * meta_name) list * string + +and dependency = + Dep of string (* rule applies for the current binding *) + | AntiDep of string (* rule doesn't apply for the current binding *) + | EverDep of string (* rule applies for some binding *) + | NeverDep of string (* rule never applies for any binding *) + | AndDep of dependency * dependency + | OrDep of dependency * dependency + | NoDep + +and rule_with_metavars = metavar list * rule + +and anything = + FullTypeTag of fullType + | BaseTypeTag of baseType + | StructUnionTag of structUnion + | SignTag of sign + | IdentTag of ident + | ExpressionTag of expression + | ConstantTag of constant + | UnaryOpTag of unaryOp + | AssignOpTag of assignOp + | FixOpTag of fixOp + | BinaryOpTag of binaryOp + | ArithOpTag of arithOp + | LogicalOpTag of logicalOp + | DeclarationTag of declaration + | InitTag of initialiser + | StorageTag of storage + | IncFileTag of inc_file + | Rule_elemTag of rule_elem + | StatementTag of statement + | CaseLineTag of case_line + | ConstVolTag of const_vol + | Token of string * info option + | Code of top_level + | ExprDotsTag of expression dots + | ParamDotsTag of parameterTypeDef dots + | StmtDotsTag of statement dots + | DeclDotsTag of declaration dots + | TypeCTag of typeC + | ParamTag of parameterTypeDef + | SgrepStartTag of string + | SgrepEndTag of string + +(* --------------------------------------------------------------------- *) + +and exists = Exists | Forall | ReverseForall | Undetermined + +(* --------------------------------------------------------------------- *) + +let mkToken x = Token (x,None) + +(* --------------------------------------------------------------------- *) + +let rewrap model x = {model with node = x} +let rewrap_mcode (_,a,b,c) x = (x,a,b,c) +let unwrap x = x.node +let unwrap_mcode (x,_,_,_) = x +let get_mcodekind (_,_,x,_) = x +let get_line x = x.node_line +let get_mcode_line (_,l,_,_) = l.line +let get_fvs x = x.free_vars +let set_fvs fvs x = {x with free_vars = fvs} +let get_mfvs x = x.minus_free_vars +let set_mfvs mfvs x = {x with minus_free_vars = mfvs} +let get_fresh x = x.fresh_vars +let get_inherited x = x.inherited +let get_saved x = x.saved_witness +let get_dots_bef_aft x = x.bef_aft +let set_dots_bef_aft d x = {x with bef_aft = d} +let get_pos x = x.pos_info +let set_pos x pos = {x with pos_info = pos} +let get_test_exp x = x.true_if_test_exp +let set_test_exp x = {x with true_if_test_exp = true} +let get_isos x = x.iso_info +let set_isos x isos = {x with iso_info = isos} +let get_pos_var (_,_,_,p) = p +let set_pos_var vr (a,b,c,_) = (a,b,c,vr) +let drop_pos (a,b,c,_) = (a,b,c,NoMetaPos) + +let get_wcfvs (whencode : ('a wrap, 'b wrap) whencode list) = + Common.union_all + (List.map + (function + WhenNot(a) -> get_fvs a + | WhenAlways(a) -> get_fvs a + | WhenModifier(_) -> [] + | WhenNotTrue(e) -> get_fvs e + | WhenNotFalse(e) -> get_fvs e) + whencode) + +(* --------------------------------------------------------------------- *) + +let get_meta_name = function + MetaIdDecl(ar,nm) -> nm + | MetaFreshIdDecl(ar,nm) -> nm + | MetaTypeDecl(ar,nm) -> nm + | MetaListlenDecl(nm) -> nm + | MetaParamDecl(ar,nm) -> nm + | MetaParamListDecl(ar,nm,nm1) -> nm + | MetaConstDecl(ar,nm,ty) -> nm + | MetaErrDecl(ar,nm) -> nm + | MetaExpDecl(ar,nm,ty) -> nm + | MetaIdExpDecl(ar,nm,ty) -> nm + | MetaLocalIdExpDecl(ar,nm,ty) -> nm + | MetaExpListDecl(ar,nm,nm1) -> nm + | MetaStmDecl(ar,nm) -> nm + | MetaStmListDecl(ar,nm) -> nm + | MetaFuncDecl(ar,nm) -> nm + | MetaLocalFuncDecl(ar,nm) -> nm + | MetaPosDecl(ar,nm) -> nm + | MetaDeclarerDecl(ar,nm) -> nm + | MetaIteratorDecl(ar,nm) -> nm + +(* --------------------------------------------------------------------- *) + +let no_info = { line = 0; column = 0; strbef = []; straft = [] } + +let make_term x = + {node = x; + node_line = 0; + free_vars = []; + minus_free_vars = []; + fresh_vars = []; + inherited = []; + saved_witness = []; + bef_aft = NoDots; + pos_info = None; + true_if_test_exp = false; + iso_info = [] } + +let make_meta_rule_elem s d (fvs,fresh,inh) = + {(make_term + (MetaRuleElem((("",s),no_info,d,NoMetaPos),Type_cocci.Unitary,false))) + with free_vars = fvs; fresh_vars = fresh; inherited = inh} + +let make_meta_decl s d (fvs,fresh,inh) = + {(make_term + (MetaDecl((("",s),no_info,d,NoMetaPos),Type_cocci.Unitary,false))) with + free_vars = fvs; fresh_vars = fresh; inherited = inh} + +let make_mcode x = (x,no_info,CONTEXT(NoPos,NOTHING),NoMetaPos) + +(* --------------------------------------------------------------------- *) + +let equal_pos x y = x = y + +(* --------------------------------------------------------------------- *) + +let undots x = + match unwrap x with + DOTS e -> e + | CIRCLES e -> e + | STARS e -> e diff --git a/parsing_cocci/.#check_meta.ml.1.86 b/parsing_cocci/.#check_meta.ml.1.86 new file mode 100644 index 0000000..9c8fcd2 --- /dev/null +++ b/parsing_cocci/.#check_meta.ml.1.86 @@ -0,0 +1,535 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* For minus fragment, checks that all of the identifier metavariables that +are used are not declared as fresh, and check that all declared variables +are used. For plus fragment, just check that the variables declared as +fresh are used. What is the issue about error variables? (don't remember) *) + +module Ast0 = Ast0_cocci +module Ast = Ast_cocci +module V0 = Visitor_ast0 + +(* all fresh identifiers *) +let fresh_table = (Hashtbl.create(50) : ((string * string), unit) Hashtbl.t) + +let warning s = Printf.fprintf stderr "warning: %s\n" s + +let promote name = (name,(),Ast0.default_info(),(),None) + +(* --------------------------------------------------------------------- *) + +let find_loop table name = + let rec loop = function + [] -> raise Not_found + | x::xs -> (try Hashtbl.find x name with Not_found -> loop xs) in + loop table + +let check_table table minus (name,_,info,_,_) = + let rl = info.Ast0.line_start in + if minus + then + (try (find_loop table name) := true + with + Not_found -> + (try + Hashtbl.find fresh_table name; + let (_,name) = name in + failwith + (Printf.sprintf + "%d: unexpected use of a fresh identifier %s" rl name) + with Not_found -> ())) + else (try (find_loop table name) := true with Not_found -> ()) + +let get_opt fn = Common.do_option fn + +(* --------------------------------------------------------------------- *) +(* Dots *) + +let dots fn d = + match Ast0.unwrap d with + Ast0.DOTS(x) -> List.iter fn x + | Ast0.CIRCLES(x) -> List.iter fn x + | Ast0.STARS(x) -> List.iter fn x + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +type context = ID | FIELD | FN | GLOBAL + +(* heuristic for distinguishing ifdef variables from undeclared metavariables*) +let is_ifdef name = + String.length name > 2 && String.uppercase name = name + +let ident context old_metas table minus i = + match Ast0.unwrap i with + Ast0.Id((name,_,info,_,_) : string Ast0.mcode) -> + let rl = info.Ast0.line_start in + let err = + if List.exists (function x -> x = name) old_metas + && (minus || Ast0.get_mcodekind i = Ast0.PLUS) + then + begin + warning + (Printf.sprintf + "line %d: %s, previously declared as a metavariable, is used as an identifier" rl name); + true + end + else false in + (match context with + ID -> + if not (is_ifdef name) && minus && not err(* warn only once per id *) + then + warning + (Printf.sprintf "line %d: should %s be a metavariable?" rl name) + | _ -> ()) + | Ast0.MetaId(name,_,_) -> check_table table minus name + | Ast0.MetaFunc(name,_,_) -> check_table table minus name + | Ast0.MetaLocalFunc(name,_,_) -> check_table table minus name + | Ast0.OptIdent(_) | Ast0.UniqueIdent(_) -> + failwith "unexpected code" + +(* --------------------------------------------------------------------- *) +(* Expression *) + +let rec expression context old_metas table minus e = + match Ast0.unwrap e with + Ast0.Ident(id) -> + ident context old_metas table minus id + | Ast0.FunCall(fn,lp,args,rp) -> + expression FN old_metas table minus fn; + dots (expression ID old_metas table minus) args + | Ast0.Assignment(left,op,right,_) -> + expression context old_metas table minus left; + expression ID old_metas table minus right + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> + expression ID old_metas table minus exp1; + get_opt (expression ID old_metas table minus) exp2; + expression ID old_metas table minus exp3 + | Ast0.Postfix(exp,op) -> + expression ID old_metas table minus exp + | Ast0.Infix(exp,op) -> + expression ID old_metas table minus exp + | Ast0.Unary(exp,op) -> + expression ID old_metas table minus exp + | Ast0.Binary(left,op,right) -> + expression ID old_metas table minus left; + expression ID old_metas table minus right + | Ast0.Paren(lp,exp,rp) -> + expression ID old_metas table minus exp + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> + expression ID old_metas table minus exp1; + expression ID old_metas table minus exp2 + | Ast0.RecordAccess(exp,pt,field) -> + expression ID old_metas table minus exp; + ident FIELD old_metas table minus field + | Ast0.RecordPtAccess(exp,ar,field) -> + expression ID old_metas table minus exp; + ident FIELD old_metas table minus field + | Ast0.Cast(lp,ty,rp,exp) -> + typeC old_metas table minus ty; expression ID old_metas table minus exp + | Ast0.SizeOfExpr(szf,exp) -> expression ID old_metas table minus exp + | Ast0.SizeOfType(szf,lp,ty,rp) -> typeC old_metas table minus ty + | Ast0.TypeExp(ty) -> typeC old_metas table minus ty + | Ast0.MetaExpr(name,_,Some tys,_,_) -> + List.iter + (function x -> + match get_type_name x with + Some(ty) -> check_table table minus (promote ty) + | None -> ()) + tys; + check_table table minus name + | Ast0.MetaExpr(name,_,_,_,_) | Ast0.MetaErr(name,_,_) -> + check_table table minus name + | Ast0.MetaExprList(name,None,_) -> + check_table table minus name + | Ast0.MetaExprList(name,Some lenname,_) -> + check_table table minus name; + check_table table minus lenname + | Ast0.DisjExpr(_,exps,_,_) -> + List.iter (expression ID old_metas table minus) exps + | Ast0.NestExpr(_,exp_dots,_,w,_) -> + dots (expression ID old_metas table minus) exp_dots; + get_opt (expression ID old_metas table minus) w + | Ast0.Edots(_,Some x) | Ast0.Ecircles(_,Some x) | Ast0.Estars(_,Some x) -> + expression ID old_metas table minus x + | _ -> () (* no metavariable subterms *) + +and get_type_name = function + Type_cocci.ConstVol(_,ty) | Type_cocci.SignedT(_,Some ty) + | Type_cocci.Pointer(ty) + | Type_cocci.FunctionPointer(ty) | Type_cocci.Array(ty) -> get_type_name ty + | Type_cocci.MetaType(nm,_,_) -> Some nm + | _ -> None + +(* --------------------------------------------------------------------- *) +(* Types *) + +and typeC old_metas table minus t = + match Ast0.unwrap t with + Ast0.ConstVol(cv,ty) -> typeC old_metas table minus ty + | Ast0.Signed(sgn,ty) -> + get_opt (typeC old_metas table minus) ty + | Ast0.Pointer(ty,star) -> typeC old_metas table minus ty + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + typeC old_metas table minus ty; + parameter_list old_metas table minus params + | Ast0.FunctionType(ty,lp1,params,rp1) -> + get_opt (typeC old_metas table minus) ty; + parameter_list old_metas table minus params + | Ast0.Array(ty,lb,size,rb) -> + typeC old_metas table minus ty; + get_opt (expression ID old_metas table minus) size + | Ast0.MetaType(name,_) -> + check_table table minus name + | Ast0.DisjType(_,types,_,_) -> + List.iter (typeC old_metas table minus) types + | Ast0.EnumName(en,id) -> ident GLOBAL old_metas table minus id + | Ast0.StructUnionName(su,Some id) -> ident GLOBAL old_metas table minus id + | Ast0.StructUnionDef(ty,lb,decls,rb) -> + typeC old_metas table minus ty; + dots (declaration GLOBAL old_metas table minus) decls + | Ast0.OptType(ty) | Ast0.UniqueType(ty) -> + failwith "unexpected code" + | _ -> () (* no metavariable subterms *) + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and declaration context old_metas table minus d = + match Ast0.unwrap d with + Ast0.Init(stg,ty,id,eq,ini,sem) -> + (match Ast0.unwrap ini with + Ast0.InitExpr exp -> + typeC old_metas table minus ty; + ident context old_metas table minus id; + expression ID old_metas table minus exp + | _ -> + (* + if minus + then + failwith "complex initializer specification not allowed in - code" + else*) + (typeC old_metas table minus ty; + ident context old_metas table minus id; + initialiser old_metas table minus ini)) + | Ast0.UnInit(stg,ty,id,sem) -> + typeC old_metas table minus ty; ident context old_metas table minus id + | Ast0.MacroDecl(name,lp,args,rp,sem) -> + ident GLOBAL old_metas table minus name; + dots (expression ID old_metas table minus) args + | Ast0.TyDecl(ty,sem) -> typeC old_metas table minus ty + | Ast0.Typedef(stg,ty,id,sem) -> + typeC old_metas table minus ty; + typeC old_metas table minus id + | Ast0.DisjDecl(_,decls,_,_) -> + List.iter (declaration ID old_metas table minus) decls + | Ast0.Ddots(_,Some x) -> declaration ID old_metas table minus x + | Ast0.Ddots(_,None) -> () + | Ast0.OptDecl(_) | Ast0.UniqueDecl(_) -> + failwith "unexpected code" + +(* --------------------------------------------------------------------- *) +(* Initialiser *) + +and initialiser old_metas table minus ini = + match Ast0.unwrap ini with + Ast0.InitExpr(exp) -> expression ID old_metas table minus exp + | Ast0.InitList(lb,initlist,rb) -> + dots (initialiser old_metas table minus) initlist + | Ast0.InitGccDotName(dot,name,eq,ini) -> + ident FIELD old_metas table minus name; + initialiser old_metas table minus ini + | Ast0.InitGccName(name,eq,ini) -> + ident FIELD old_metas table minus name; + initialiser old_metas table minus ini + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> + expression ID old_metas table minus exp; + initialiser old_metas table minus ini + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + expression ID old_metas table minus exp1; + expression ID old_metas table minus exp2; + initialiser old_metas table minus ini + | Ast0.Idots(_,Some x) -> initialiser old_metas table minus x + | Ast0.OptIni(_) | Ast0.UniqueIni(_) -> + failwith "unexpected code" + | _ -> () (* no metavariable subterms *) + +and initialiser_list old_metas table minus = + dots (initialiser old_metas table minus) + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and parameterTypeDef old_metas table minus param = + match Ast0.unwrap param with + Ast0.Param(ty,id) -> + get_opt (ident ID old_metas table minus) id; + typeC old_metas table minus ty + | Ast0.MetaParam(name,_) -> + check_table table minus name + | Ast0.MetaParamList(name,None,_) -> + check_table table minus name + | Ast0.MetaParamList(name,Some lenname,_) -> + check_table table minus name; + check_table table minus lenname + | _ -> () (* no metavariable subterms *) + +and parameter_list old_metas table minus = + dots (parameterTypeDef old_metas table minus) + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +and statement old_metas table minus s = + match Ast0.unwrap s with + Ast0.Decl(_,decl) -> declaration ID old_metas table minus decl + | Ast0.Seq(lbrace,body,rbrace) -> dots (statement old_metas table minus) body + | Ast0.ExprStatement(exp,sem) -> expression ID old_metas table minus exp + | Ast0.IfThen(iff,lp,exp,rp,branch,_) -> + expression ID old_metas table minus exp; + statement old_metas table minus branch + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,_) -> + expression ID old_metas table minus exp; + statement old_metas table minus branch1; + statement old_metas table minus branch2 + | Ast0.While(wh,lp,exp,rp,body,_) -> + expression ID old_metas table minus exp; + statement old_metas table minus body + | Ast0.Do(d,body,wh,lp,exp,rp,sem) -> + statement old_metas table minus body; + expression ID old_metas table minus exp + | Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,_) -> + get_opt (expression ID old_metas table minus) exp1; + get_opt (expression ID old_metas table minus) exp2; + get_opt (expression ID old_metas table minus) exp3; + statement old_metas table minus body + | Ast0.Iterator(nm,lp,args,rp,body,_) -> + ident GLOBAL old_metas table minus nm; + dots (expression ID old_metas table minus) args; + statement old_metas table minus body + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> + expression ID old_metas table minus exp; + dots (case_line old_metas table minus) cases + | Ast0.ReturnExpr(ret,exp,sem) -> expression ID old_metas table minus exp + | Ast0.MetaStmt(name,_) -> check_table table minus name + | Ast0.MetaStmtList(name,_) -> check_table table minus name + | Ast0.Exp(exp) -> expression ID old_metas table minus exp + | Ast0.TopExp(exp) -> expression ID old_metas table minus exp + | Ast0.Ty(ty) -> typeC old_metas table minus ty + | Ast0.TopInit(init) -> initialiser old_metas table minus init + | Ast0.Disj(_,rule_elem_dots_list,_,_) -> + List.iter (dots (statement old_metas table minus)) rule_elem_dots_list + | Ast0.Nest(_,rule_elem_dots,_,w,_) -> + dots (statement old_metas table minus) rule_elem_dots; + List.iter (whencode (dots (statement old_metas table minus)) + (statement old_metas table minus) + (expression ID old_metas table minus)) + w + | Ast0.Dots(_,x) | Ast0.Circles(_,x) | Ast0.Stars(_,x) -> + List.iter + (whencode (dots (statement old_metas table minus)) + (statement old_metas table minus) + (expression ID old_metas table minus)) x + | Ast0.FunDecl(_,fi,name,lp,params,rp,lbrace,body,rbrace) -> + ident FN old_metas table minus name; + List.iter (fninfo old_metas table minus) fi; + parameter_list old_metas table minus params; + dots (statement old_metas table minus) body + | Ast0.Include(inc,s) -> () (* no metavariables possible *) + | Ast0.Define(def,id,_,body) -> + ident GLOBAL old_metas table minus id; + dots (statement old_metas table minus) body + | Ast0.Goto(_,i,_) -> ident ID old_metas table minus i + | _ -> () (* no metavariable subterms *) + +and fninfo old_metas table minus = function + Ast0.FStorage(stg) -> () + | Ast0.FType(ty) -> typeC old_metas table minus ty + | Ast0.FInline(inline) -> () + | Ast0.FAttr(attr) -> () + +and whencode notfn alwaysfn expression = function + Ast0.WhenNot a -> notfn a + | Ast0.WhenAlways a -> alwaysfn a + | Ast0.WhenModifier(_) -> () + | Ast0.WhenNotTrue a -> expression a + | Ast0.WhenNotFalse a -> expression a + +and case_line old_metas table minus c = + match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> + dots (statement old_metas table minus) code + | Ast0.Case(case,exp,colon,code) -> + dots (statement old_metas table minus) code + | Ast0.OptCase(case) -> failwith "unexpected code" + +(* --------------------------------------------------------------------- *) +(* Rules *) + +let top_level old_metas table minus t = + match Ast0.unwrap t with + Ast0.DECL(stmt) -> statement old_metas table minus stmt + | Ast0.CODE(stmt_dots) -> dots (statement old_metas table minus) stmt_dots + | Ast0.ERRORWORDS(exps) -> + List.iter (expression FN old_metas table minus) exps + | _ -> () (* no metavariables possible *) + +let rule old_metas table minus rules = + List.iter (top_level old_metas table minus) rules + +(* --------------------------------------------------------------------- *) + +let positions table rules = + let mcode x = + match Ast0.get_pos x with + Ast0.MetaPos(name,constraints,_) -> + let pos = Ast0.unwrap_mcode name in + (find_loop table pos) := true + | _ -> () in + let option_default = () in + let bind x y = () in + let donothing r k e = k e in + let fn = + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing donothing + donothing donothing in + + List.iter fn.V0.combiner_top_level rules + +let dup_positions rules = + let mcode x = + match Ast0.get_pos x with + Ast0.MetaPos(name,constraints,_) -> + let pos = Ast0.unwrap_mcode name in [pos] + | _ -> [] in + let option_default = [] in + let bind x y = x@y in + + (* Case for everything that has a disj. + Note, no positions on ( | ) of a disjunction, so no need to recurse on + these. *) + + let expression r k e = + match Ast0.unwrap e with + Ast0.DisjExpr(_,explist,_,_) -> + List.fold_left Common.union_set option_default + (List.map r.V0.combiner_expression explist) + | _ -> k e in + + let typeC r k e = (* not sure relevent because "only after iso" *) + match Ast0.unwrap e with + Ast0.DisjType(_,types,_,_) -> + List.fold_left Common.union_set option_default + (List.map r.V0.combiner_typeC types) + | _ -> k e in + + let declaration r k e = + match Ast0.unwrap e with + Ast0.DisjDecl(_,decls,_,_) -> + List.fold_left Common.union_set option_default + (List.map r.V0.combiner_declaration decls) + | _ -> k e in + + let statement r k e = + match Ast0.unwrap e with + Ast0.Disj(_,stmts,_,_) -> + List.fold_left Common.union_set option_default + (List.map r.V0.combiner_statement_dots stmts) + | _ -> k e in + + let donothing r k e = k e in + let fn = + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing expression typeC donothing donothing declaration statement + donothing donothing in + + let res = + List.sort compare + (List.fold_left Common.union_set option_default + (List.map fn.V0.combiner_top_level rules)) in + let rec loop = function + [] | [_] -> () + | ((rule,name) as x)::y::_ when x = y -> + failwith (Printf.sprintf "duplicate use of %s.%s" rule name) + | _::xs -> loop xs in + loop res + +(* --------------------------------------------------------------------- *) + +let make_table l = + let table = + (Hashtbl.create(List.length l) : + ((string * string), bool ref) Hashtbl.t) in + List.iter + (function x -> Hashtbl.add table (Ast.get_meta_name x) (ref false)) l; + table + +let add_to_fresh_table l = + List.iter + (function x -> + let name = Ast.get_meta_name x in Hashtbl.replace fresh_table name ()) + l + +let check_all_marked rname err table after_err = + Hashtbl.iter + (function name -> + function (cell) -> + if not (!cell) + then + let (_,name) = name in + warning + (Printf.sprintf "%s: %s %s not used %s" rname err name after_err)) + table + +let check_meta rname old_metas inherited_metavars metavars minus plus = + let old_metas = + List.map (function (_,x) -> x) (List.map Ast.get_meta_name old_metas) in + let (fresh,other) = + List.partition (function Ast.MetaFreshIdDecl(_,_) -> true | _ -> false) + metavars in + let (err,other) = + List.partition (function Ast.MetaErrDecl(_,_) -> true | _ -> false) + other in + let (ierr,iother) = + List.partition (function Ast.MetaErrDecl(_,_) -> true | _ -> false) + inherited_metavars in + let fresh_table = make_table fresh in + let err_table = make_table (err@ierr) in + let other_table = make_table other in + let iother_table = make_table iother in + add_to_fresh_table fresh; + rule old_metas [iother_table;other_table;err_table] true minus; + positions [iother_table;other_table] minus; + dup_positions minus; + check_all_marked rname "metavariable" other_table "in the - or context code"; + rule old_metas [iother_table;fresh_table;err_table] false plus; + check_all_marked rname "inherited metavariable" iother_table + "in the -, +, or context code"; + check_all_marked rname "metavariable" fresh_table "in the + code"; + check_all_marked rname "error metavariable" err_table "" diff --git a/parsing_cocci/.#compute_lines.ml.1.90 b/parsing_cocci/.#compute_lines.ml.1.90 new file mode 100644 index 0000000..67ec35d --- /dev/null +++ b/parsing_cocci/.#compute_lines.ml.1.90 @@ -0,0 +1,769 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* Computes starting and ending logical lines for statements and +expressions. every node gets an index as well. *) + +module Ast0 = Ast0_cocci +module Ast = Ast_cocci + +(* --------------------------------------------------------------------- *) +(* Result *) + +let mkres x e left right = + let lstart = Ast0.get_info left in + let lend = Ast0.get_info right in + let info = + { Ast0.line_start = lstart.Ast0.line_start; + Ast0.line_end = lend.Ast0.line_end; + Ast0.logical_start = lstart.Ast0.logical_start; + Ast0.logical_end = lend.Ast0.logical_end; + Ast0.attachable_start = lstart.Ast0.attachable_start; + Ast0.attachable_end = lend.Ast0.attachable_end; + Ast0.mcode_start = lstart.Ast0.mcode_start; + Ast0.mcode_end = lend.Ast0.mcode_end; + Ast0.column = lstart.Ast0.column; + Ast0.offset = lstart.Ast0.offset; + (* only for tokens, not inherited upwards *) + Ast0.strings_before = []; Ast0.strings_after = []} in + {x with Ast0.node = e; Ast0.info = info} + +let mkmultires x e left right (astart,start_mcodes) (aend,end_mcodes) = + let lstart = Ast0.get_info left in + let lend = Ast0.get_info right in + let info = + { Ast0.line_start = lstart.Ast0.line_start; + Ast0.line_end = lend.Ast0.line_end; + Ast0.logical_start = lstart.Ast0.logical_start; + Ast0.logical_end = lend.Ast0.logical_end; + Ast0.attachable_start = astart; + Ast0.attachable_end = aend; + Ast0.mcode_start = start_mcodes; + Ast0.mcode_end = end_mcodes; + Ast0.column = lstart.Ast0.column; + Ast0.offset = lstart.Ast0.offset; + (* only for tokens, not inherited upwards *) + Ast0.strings_before = []; Ast0.strings_after = [] } in + {x with Ast0.node = e; Ast0.info = info} + +(* --------------------------------------------------------------------- *) + +let get_option fn = function + None -> None + | Some x -> Some (fn x) + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) +(* Mcode *) + +let promote_mcode (_,_,info,mcodekind,_) = + let new_info = + {info with + Ast0.mcode_start = [mcodekind]; Ast0.mcode_end = [mcodekind]} in + {(Ast0.wrap ()) with Ast0.info = new_info; Ast0.mcodekind = ref mcodekind} + +let promote_mcode_plus_one (_,_,info,mcodekind,_) = + let new_info = + {info with + Ast0.line_start = info.Ast0.line_start + 1; + Ast0.logical_start = info.Ast0.logical_start + 1; + Ast0.line_end = info.Ast0.line_end + 1; + Ast0.logical_end = info.Ast0.logical_end + 1; + Ast0.mcode_start = [mcodekind]; Ast0.mcode_end = [mcodekind]} in + {(Ast0.wrap ()) with Ast0.info = new_info; Ast0.mcodekind = ref mcodekind} + +let promote_to_statement stm mcodekind = + let info = Ast0.get_info stm in + let new_info = + {info with + Ast0.logical_start = info.Ast0.logical_end; + Ast0.line_start = info.Ast0.line_end; + Ast0.mcode_start = [mcodekind]; Ast0.mcode_end = [mcodekind]; + Ast0.attachable_start = true; Ast0.attachable_end = true} in + {(Ast0.wrap ()) with Ast0.info = new_info; Ast0.mcodekind = ref mcodekind} + +let promote_to_statement_start stm mcodekind = + let info = Ast0.get_info stm in + let new_info = + {info with + Ast0.logical_end = info.Ast0.logical_start; + Ast0.line_end = info.Ast0.line_start; + Ast0.mcode_start = [mcodekind]; Ast0.mcode_end = [mcodekind]; + Ast0.attachable_start = true; Ast0.attachable_end = true} in + {(Ast0.wrap ()) with Ast0.info = new_info; Ast0.mcodekind = ref mcodekind} + +(* mcode is good by default *) +let bad_mcode (t,a,info,mcodekind,pos) = + let new_info = + {info with Ast0.attachable_start = false; Ast0.attachable_end = false} in + (t,a,new_info,mcodekind,pos) + +let get_all_start_info l = + (List.for_all (function x -> (Ast0.get_info x).Ast0.attachable_start) l, + List.concat (List.map (function x -> (Ast0.get_info x).Ast0.mcode_start) l)) + +let get_all_end_info l = + (List.for_all (function x -> (Ast0.get_info x).Ast0.attachable_end) l, + List.concat (List.map (function x -> (Ast0.get_info x).Ast0.mcode_end) l)) + +(* --------------------------------------------------------------------- *) +(* Dots *) + +(* for the logline classification and the mcode field, on both sides, skip +over initial minus dots, as they don't contribute anything *) +let dot_list is_dots fn = function + [] -> failwith "dots should not be empty" + | l -> + let get_node l fn = + let first = List.hd l in + let chosen = + match (is_dots first, l) with (true,_::x::_) -> x | _ -> first in + (* get the logline decorator and the mcodekind of the chosen node *) + fn (Ast0.get_info chosen) in + let forward = List.map fn l in + let backward = List.rev forward in + let (first_attachable,first_mcode) = + get_node forward + (function x -> (x.Ast0.attachable_start,x.Ast0.mcode_start)) in + let (last_attachable,last_mcode) = + get_node backward + (function x -> (x.Ast0.attachable_end,x.Ast0.mcode_end)) in + let first = List.hd forward in + let last = List.hd backward in + let first_info = + { (Ast0.get_info first) with + Ast0.attachable_start = first_attachable; + Ast0.mcode_start = first_mcode } in + let last_info = + { (Ast0.get_info last) with + Ast0.attachable_end = last_attachable; + Ast0.mcode_end = last_mcode } in + let first = Ast0.set_info first first_info in + let last = Ast0.set_info last last_info in + (forward,first,last) + +let dots is_dots prev fn d = + match (prev,Ast0.unwrap d) with + (Some prev,Ast0.DOTS([])) -> + mkres d (Ast0.DOTS []) prev prev + | (None,Ast0.DOTS([])) -> + Ast0.set_info d + {(Ast0.get_info d) + with Ast0.attachable_start = false; Ast0.attachable_end = false} + | (_,Ast0.DOTS(x)) -> + let (l,lstart,lend) = dot_list is_dots fn x in + mkres d (Ast0.DOTS l) lstart lend + | (_,Ast0.CIRCLES(x)) -> + let (l,lstart,lend) = dot_list is_dots fn x in + mkres d (Ast0.CIRCLES l) lstart lend + | (_,Ast0.STARS(x)) -> + let (l,lstart,lend) = dot_list is_dots fn x in + mkres d (Ast0.STARS l) lstart lend + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +let rec ident i = + match Ast0.unwrap i with + Ast0.Id(name) as ui -> + let name = promote_mcode name in mkres i ui name name + | Ast0.MetaId(name,_,_) + | Ast0.MetaFunc(name,_,_) | Ast0.MetaLocalFunc(name,_,_) as ui -> + let name = promote_mcode name in mkres i ui name name + | Ast0.OptIdent(id) -> + let id = ident id in mkres i (Ast0.OptIdent(id)) id id + | Ast0.UniqueIdent(id) -> + let id = ident id in mkres i (Ast0.UniqueIdent(id)) id id + +(* --------------------------------------------------------------------- *) +(* Expression *) + +let is_exp_dots e = + match Ast0.unwrap e with + Ast0.Edots(_,_) | Ast0.Ecircles(_,_) | Ast0.Estars(_,_) -> true + | _ -> false + +let rec expression e = + match Ast0.unwrap e with + Ast0.Ident(id) -> + let id = ident id in + mkres e (Ast0.Ident(id)) id id + | Ast0.Constant(const) as ue -> + let ln = promote_mcode const in + mkres e ue ln ln + | Ast0.FunCall(fn,lp,args,rp) -> + let fn = expression fn in + let args = dots is_exp_dots (Some(promote_mcode lp)) expression args in + mkres e (Ast0.FunCall(fn,lp,args,rp)) fn (promote_mcode rp) + | Ast0.Assignment(left,op,right,simple) -> + let left = expression left in + let right = expression right in + mkres e (Ast0.Assignment(left,op,right,simple)) left right + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> + let exp1 = expression exp1 in + let exp2 = get_option expression exp2 in + let exp3 = expression exp3 in + mkres e (Ast0.CondExpr(exp1,why,exp2,colon,exp3)) exp1 exp3 + | Ast0.Postfix(exp,op) -> + let exp = expression exp in + mkres e (Ast0.Postfix(exp,op)) exp (promote_mcode op) + | Ast0.Infix(exp,op) -> + let exp = expression exp in + mkres e (Ast0.Infix(exp,op)) (promote_mcode op) exp + | Ast0.Unary(exp,op) -> + let exp = expression exp in + mkres e (Ast0.Unary(exp,op)) (promote_mcode op) exp + | Ast0.Binary(left,op,right) -> + let left = expression left in + let right = expression right in + mkres e (Ast0.Binary(left,op,right)) left right + | Ast0.Nested(left,op,right) -> + let left = expression left in + let right = expression right in + mkres e (Ast0.Nested(left,op,right)) left right + | Ast0.Paren(lp,exp,rp) -> + mkres e (Ast0.Paren(lp,expression exp,rp)) + (promote_mcode lp) (promote_mcode rp) + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> + let exp1 = expression exp1 in + let exp2 = expression exp2 in + mkres e (Ast0.ArrayAccess(exp1,lb,exp2,rb)) exp1 (promote_mcode rb) + | Ast0.RecordAccess(exp,pt,field) -> + let exp = expression exp in + let field = ident field in + mkres e (Ast0.RecordAccess(exp,pt,field)) exp field + | Ast0.RecordPtAccess(exp,ar,field) -> + let exp = expression exp in + let field = ident field in + mkres e (Ast0.RecordPtAccess(exp,ar,field)) exp field + | Ast0.Cast(lp,ty,rp,exp) -> + let exp = expression exp in + mkres e (Ast0.Cast(lp,typeC ty,rp,exp)) (promote_mcode lp) exp + | Ast0.SizeOfExpr(szf,exp) -> + let exp = expression exp in + mkres e (Ast0.SizeOfExpr(szf,exp)) (promote_mcode szf) exp + | Ast0.SizeOfType(szf,lp,ty,rp) -> + mkres e (Ast0.SizeOfType(szf,lp,typeC ty,rp)) + (promote_mcode szf) (promote_mcode rp) + | Ast0.TypeExp(ty) -> + let ty = typeC ty in mkres e (Ast0.TypeExp(ty)) ty ty + | Ast0.MetaErr(name,_,_) | Ast0.MetaExpr(name,_,_,_,_) + | Ast0.MetaExprList(name,_,_) as ue -> + let ln = promote_mcode name in mkres e ue ln ln + | Ast0.EComma(cm) -> + let cm = bad_mcode cm in + let ln = promote_mcode cm in + mkres e (Ast0.EComma(cm)) ln ln + | Ast0.DisjExpr(starter,exps,mids,ender) -> + let starter = bad_mcode starter in + let exps = List.map expression exps in + let mids = List.map bad_mcode mids in + let ender = bad_mcode ender in + mkmultires e (Ast0.DisjExpr(starter,exps,mids,ender)) + (promote_mcode starter) (promote_mcode ender) + (get_all_start_info exps) (get_all_end_info exps) + | Ast0.NestExpr(starter,exp_dots,ender,whencode,multi) -> + let exp_dots = dots is_exp_dots None expression exp_dots in + let starter = bad_mcode starter in + let ender = bad_mcode ender in + mkres e (Ast0.NestExpr(starter,exp_dots,ender,whencode,multi)) + (promote_mcode starter) (promote_mcode ender) + | Ast0.Edots(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres e (Ast0.Edots(dots,whencode)) ln ln + | Ast0.Ecircles(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres e (Ast0.Ecircles(dots,whencode)) ln ln + | Ast0.Estars(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres e (Ast0.Estars(dots,whencode)) ln ln + | Ast0.OptExp(exp) -> + let exp = expression exp in + mkres e (Ast0.OptExp(exp)) exp exp + | Ast0.UniqueExp(exp) -> + let exp = expression exp in + mkres e (Ast0.UniqueExp(exp)) exp exp + +and expression_dots x = dots is_exp_dots None expression x + +(* --------------------------------------------------------------------- *) +(* Types *) + +and typeC t = + match Ast0.unwrap t with + Ast0.ConstVol(cv,ty) -> + let ty = typeC ty in + mkres t (Ast0.ConstVol(cv,ty)) (promote_mcode cv) ty + | Ast0.BaseType(ty,strings) as ut -> + let first = List.hd strings in + let last = List.hd (List.rev strings) in + mkres t ut (promote_mcode first) (promote_mcode last) + | Ast0.Signed(sgn,None) as ut -> + mkres t ut (promote_mcode sgn) (promote_mcode sgn) + | Ast0.Signed(sgn,Some ty) -> + let ty = typeC ty in + mkres t (Ast0.Signed(sgn,Some ty)) (promote_mcode sgn) ty + | Ast0.Pointer(ty,star) -> + let ty = typeC ty in + mkres t (Ast0.Pointer(ty,star)) ty (promote_mcode star) + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + let ty = typeC ty in + let params = parameter_list (Some(promote_mcode lp2)) params in + mkres t (Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2)) + ty (promote_mcode rp2) + | Ast0.FunctionType(Some ty,lp1,params,rp1) -> + let ty = typeC ty in + let params = parameter_list (Some(promote_mcode lp1)) params in + let res = Ast0.FunctionType(Some ty,lp1,params,rp1) in + mkres t res ty (promote_mcode rp1) + | Ast0.FunctionType(None,lp1,params,rp1) -> + let params = parameter_list (Some(promote_mcode lp1)) params in + let res = Ast0.FunctionType(None,lp1,params,rp1) in + mkres t res (promote_mcode lp1) (promote_mcode rp1) + | Ast0.Array(ty,lb,size,rb) -> + let ty = typeC ty in + mkres t (Ast0.Array(ty,lb,get_option expression size,rb)) + ty (promote_mcode rb) + | Ast0.EnumName(kind,name) -> + let name = ident name in + mkres t (Ast0.EnumName(kind,name)) (promote_mcode kind) name + | Ast0.StructUnionName(kind,Some name) -> + let name = ident name in + mkres t (Ast0.StructUnionName(kind,Some name)) (promote_mcode kind) name + | Ast0.StructUnionName(kind,None) -> + let mc = promote_mcode kind in + mkres t (Ast0.StructUnionName(kind,None)) mc mc + | Ast0.StructUnionDef(ty,lb,decls,rb) -> + let ty = typeC ty in + let decls = + dots is_decl_dots (Some(promote_mcode lb)) declaration decls in + mkres t (Ast0.StructUnionDef(ty,lb,decls,rb)) ty (promote_mcode rb) + | Ast0.TypeName(name) as ut -> + let ln = promote_mcode name in mkres t ut ln ln + | Ast0.MetaType(name,_) as ut -> + let ln = promote_mcode name in mkres t ut ln ln + | Ast0.DisjType(starter,types,mids,ender) -> + let starter = bad_mcode starter in + let types = List.map typeC types in + let mids = List.map bad_mcode mids in + let ender = bad_mcode ender in + mkmultires t (Ast0.DisjType(starter,types,mids,ender)) + (promote_mcode starter) (promote_mcode ender) + (get_all_start_info types) (get_all_end_info types) + | Ast0.OptType(ty) -> + let ty = typeC ty in mkres t (Ast0.OptType(ty)) ty ty + | Ast0.UniqueType(ty) -> + let ty = typeC ty in mkres t (Ast0.UniqueType(ty)) ty ty + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and is_decl_dots s = + match Ast0.unwrap s with + Ast0.Ddots(_,_) -> true + | _ -> false + +and declaration d = + match Ast0.unwrap d with + Ast0.Init(stg,ty,id,eq,exp,sem) -> + let ty = typeC ty in + let id = ident id in + let exp = initialiser exp in + (match stg with + None -> + mkres d (Ast0.Init(stg,ty,id,eq,exp,sem)) ty (promote_mcode sem) + | Some x -> + mkres d (Ast0.Init(stg,ty,id,eq,exp,sem)) + (promote_mcode x) (promote_mcode sem)) + | Ast0.UnInit(stg,ty,id,sem) -> + let ty = typeC ty in + let id = ident id in + (match stg with + None -> + mkres d (Ast0.UnInit(stg,ty,id,sem)) ty (promote_mcode sem) + | Some x -> + mkres d (Ast0.UnInit(stg,ty,id,sem)) + (promote_mcode x) (promote_mcode sem)) + | Ast0.MacroDecl(name,lp,args,rp,sem) -> + let name = ident name in + let args = dots is_exp_dots (Some(promote_mcode lp)) expression args in + mkres d (Ast0.MacroDecl(name,lp,args,rp,sem)) name (promote_mcode sem) + | Ast0.TyDecl(ty,sem) -> + let ty = typeC ty in + mkres d (Ast0.TyDecl(ty,sem)) ty (promote_mcode sem) + | Ast0.Typedef(stg,ty,id,sem) -> + let ty = typeC ty in + let id = typeC id in + mkres d (Ast0.Typedef(stg,ty,id,sem)) + (promote_mcode stg) (promote_mcode sem) + | Ast0.DisjDecl(starter,decls,mids,ender) -> + let starter = bad_mcode starter in + let decls = List.map declaration decls in + let mids = List.map bad_mcode mids in + let ender = bad_mcode ender in + mkmultires d (Ast0.DisjDecl(starter,decls,mids,ender)) + (promote_mcode starter) (promote_mcode ender) + (get_all_start_info decls) (get_all_end_info decls) + | Ast0.Ddots(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres d (Ast0.Ddots(dots,whencode)) ln ln + | Ast0.OptDecl(decl) -> + let decl = declaration decl in + mkres d (Ast0.OptDecl(declaration decl)) decl decl + | Ast0.UniqueDecl(decl) -> + let decl = declaration decl in + mkres d (Ast0.UniqueDecl(declaration decl)) decl decl + +(* --------------------------------------------------------------------- *) +(* Initializer *) + +and is_init_dots i = + match Ast0.unwrap i with + Ast0.Idots(_,_) -> true + | _ -> false + +and initialiser i = + match Ast0.unwrap i with + Ast0.InitExpr(exp) -> + let exp = expression exp in + mkres i (Ast0.InitExpr(exp)) exp exp + | Ast0.InitList(lb,initlist,rb) -> + let initlist = + dots is_init_dots (Some(promote_mcode lb)) initialiser initlist in + mkres i (Ast0.InitList(lb,initlist,rb)) + (promote_mcode lb) (promote_mcode rb) + | Ast0.InitGccDotName(dot,name,eq,ini) -> + let name = ident name in + let ini = initialiser ini in + mkres i (Ast0.InitGccDotName(dot,name,eq,ini)) (promote_mcode dot) ini + | Ast0.InitGccName(name,eq,ini) -> + let name = ident name in + let ini = initialiser ini in + mkres i (Ast0.InitGccName(name,eq,ini)) name ini + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> + let exp = expression exp in + let ini = initialiser ini in + mkres i (Ast0.InitGccIndex(lb,exp,rb,eq,ini)) (promote_mcode lb) ini + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + let exp1 = expression exp1 in + let exp2 = expression exp2 in + let ini = initialiser ini in + mkres i (Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini)) + (promote_mcode lb) ini + | Ast0.IComma(cm) as up -> + let ln = promote_mcode cm in mkres i up ln ln + | Ast0.Idots(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres i (Ast0.Idots(dots,whencode)) ln ln + | Ast0.OptIni(ini) -> + let ini = initialiser ini in + mkres i (Ast0.OptIni(ini)) ini ini + | Ast0.UniqueIni(ini) -> + let ini = initialiser ini in + mkres i (Ast0.UniqueIni(ini)) ini ini + +and initialiser_list prev = dots is_init_dots prev initialiser + +(* for export *) +and initialiser_dots x = dots is_init_dots None initialiser x + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and is_param_dots p = + match Ast0.unwrap p with + Ast0.Pdots(_) | Ast0.Pcircles(_) -> true + | _ -> false + +and parameterTypeDef p = + match Ast0.unwrap p with + Ast0.VoidParam(ty) -> + let ty = typeC ty in mkres p (Ast0.VoidParam(ty)) ty ty + | Ast0.Param(ty,Some id) -> + let id = ident id in + let ty = typeC ty in mkres p (Ast0.Param(ty,Some id)) ty id + | Ast0.Param(ty,None) -> + let ty = typeC ty in mkres p (Ast0.Param(ty,None)) ty ty + | Ast0.MetaParam(name,_) as up -> + let ln = promote_mcode name in mkres p up ln ln + | Ast0.MetaParamList(name,_,_) as up -> + let ln = promote_mcode name in mkres p up ln ln + | Ast0.PComma(cm) -> + let cm = bad_mcode cm in + let ln = promote_mcode cm in + mkres p (Ast0.PComma(cm)) ln ln + | Ast0.Pdots(dots) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres p (Ast0.Pdots(dots)) ln ln + | Ast0.Pcircles(dots) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres p (Ast0.Pcircles(dots)) ln ln + | Ast0.OptParam(param) -> + let res = parameterTypeDef param in + mkres p (Ast0.OptParam(res)) res res + | Ast0.UniqueParam(param) -> + let res = parameterTypeDef param in + mkres p (Ast0.UniqueParam(res)) res res + +and parameter_list prev = dots is_param_dots prev parameterTypeDef + +(* for export *) +let parameter_dots x = dots is_param_dots None parameterTypeDef x + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +let is_stm_dots s = + match Ast0.unwrap s with + Ast0.Dots(_,_) | Ast0.Circles(_,_) | Ast0.Stars(_,_) -> true + | _ -> false + +let rec statement s = + let res = + match Ast0.unwrap s with + Ast0.Decl((_,bef),decl) -> + let decl = declaration decl in + let left = promote_to_statement_start decl bef in + mkres s (Ast0.Decl((Ast0.get_info left,bef),decl)) decl decl + | Ast0.Seq(lbrace,body,rbrace) -> + let body = + dots is_stm_dots (Some(promote_mcode lbrace)) statement body in + mkres s (Ast0.Seq(lbrace,body,rbrace)) + (promote_mcode lbrace) (promote_mcode rbrace) + | Ast0.ExprStatement(exp,sem) -> + let exp = expression exp in + mkres s (Ast0.ExprStatement(exp,sem)) exp (promote_mcode sem) + | Ast0.IfThen(iff,lp,exp,rp,branch,(_,aft)) -> + let exp = expression exp 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))) + (promote_mcode iff) right + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(_,aft)) -> + let exp = expression exp in + let branch1 = statement branch1 in + let branch2 = statement branch2 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))) + (promote_mcode iff) right + | Ast0.While(wh,lp,exp,rp,body,(_,aft)) -> + let exp = expression exp 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))) + (promote_mcode wh) right + | Ast0.Do(d,body,wh,lp,exp,rp,sem) -> + let body = statement body in + let exp = expression exp in + mkres s (Ast0.Do(d,body,wh,lp,exp,rp,sem)) + (promote_mcode d) (promote_mcode sem) + | Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,(_,aft)) -> + let exp1 = get_option expression exp1 in + let exp2 = get_option expression exp2 in + let exp3 = get_option expression exp3 in + let body = statement body in + let right = promote_to_statement body aft in + mkres s (Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body, + (Ast0.get_info right,aft))) + (promote_mcode fr) right + | Ast0.Iterator(nm,lp,args,rp,body,(_,aft)) -> + let nm = ident nm in + let args = dots is_exp_dots (Some(promote_mcode lp)) expression args 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))) + nm right + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> + let exp = expression exp in + let cases = + dots (function _ -> false) (Some(promote_mcode lb)) case_line cases in + mkres s + (Ast0.Switch(switch,lp,exp,rp,lb,cases,rb)) + (promote_mcode switch) (promote_mcode rb) + | Ast0.Break(br,sem) as us -> + mkres s us (promote_mcode br) (promote_mcode sem) + | Ast0.Continue(cont,sem) as us -> + mkres s us (promote_mcode cont) (promote_mcode sem) + | Ast0.Label(l,dd) -> + let l = ident l in + mkres s (Ast0.Label(l,dd)) l (promote_mcode dd) + | Ast0.Goto(goto,id,sem) -> + let id = ident id in + mkres s (Ast0.Goto(goto,id,sem)) + (promote_mcode goto) (promote_mcode sem) + | Ast0.Return(ret,sem) as us -> + mkres s us (promote_mcode ret) (promote_mcode sem) + | Ast0.ReturnExpr(ret,exp,sem) -> + let exp = expression exp in + mkres s (Ast0.ReturnExpr(ret,exp,sem)) + (promote_mcode ret) (promote_mcode sem) + | Ast0.MetaStmt(name,_) + | Ast0.MetaStmtList(name,_) as us -> + let ln = promote_mcode name in mkres s us ln ln + | Ast0.Exp(exp) -> + let exp = expression exp in + mkres s (Ast0.Exp(exp)) exp exp + | Ast0.TopExp(exp) -> + let exp = expression exp in + mkres s (Ast0.TopExp(exp)) exp exp + | Ast0.Ty(ty) -> + let ty = typeC ty in + mkres s (Ast0.Ty(ty)) ty ty + | Ast0.TopInit(init) -> + let init = initialiser init in + mkres s (Ast0.TopInit(init)) init init + | Ast0.Disj(starter,rule_elem_dots_list,mids,ender) -> + let starter = bad_mcode starter in + let mids = List.map bad_mcode mids in + let ender = bad_mcode ender in + let rec loop prevs = function + [] -> [] + | stm::stms -> + (dots is_stm_dots (Some(promote_mcode_plus_one(List.hd prevs))) + statement stm):: + (loop (List.tl prevs) stms) in + let elems = loop (starter::mids) rule_elem_dots_list in + mkmultires s (Ast0.Disj(starter,elems,mids,ender)) + (promote_mcode starter) (promote_mcode ender) + (get_all_start_info elems) (get_all_end_info elems) + | Ast0.Nest(starter,rule_elem_dots,ender,whencode,multi) -> + let starter = bad_mcode starter in + let ender = bad_mcode ender in + let rule_elem_dots = dots is_stm_dots None statement rule_elem_dots in + mkres s (Ast0.Nest(starter,rule_elem_dots,ender,whencode,multi)) + (promote_mcode starter) (promote_mcode ender) + | Ast0.Dots(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres s (Ast0.Dots(dots,whencode)) ln ln + | Ast0.Circles(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres s (Ast0.Circles(dots,whencode)) ln ln + | Ast0.Stars(dots,whencode) -> + let dots = bad_mcode dots in + let ln = promote_mcode dots in + mkres s (Ast0.Stars(dots,whencode)) ln ln + | Ast0.FunDecl((_,bef),fninfo,name,lp,params,rp,lbrace,body,rbrace) -> + let fninfo = + List.map + (function Ast0.FType(ty) -> Ast0.FType(typeC ty) | x -> x) + fninfo in + let name = ident name in + let params = parameter_list (Some(promote_mcode lp)) params in + let body = + dots is_stm_dots (Some(promote_mcode lbrace)) statement body in + let left = + (* cases on what is leftmost *) + match fninfo with + [] -> promote_to_statement_start name bef + | Ast0.FStorage(stg)::_ -> + promote_to_statement_start (promote_mcode stg) bef + | Ast0.FType(ty)::_ -> + promote_to_statement_start ty bef + | Ast0.FInline(inline)::_ -> + promote_to_statement_start (promote_mcode inline) bef + | Ast0.FAttr(attr)::_ -> + promote_to_statement_start (promote_mcode attr) bef in + (* pretend it is one line before the start of the function, so that it + will catch things defined at top level. We assume that these will not + be defined on the same line as the function. This is a HACK. + A better approach would be to attach top_level things to this node, + and other things to the node after, but that would complicate + insert_plus, which doesn't distinguish between different mcodekinds *) + let res = + Ast0.FunDecl((Ast0.get_info left,bef),fninfo,name,lp,params,rp,lbrace, + body,rbrace) in + (* have to do this test again, because of typing problems - can't save + the result, only use it *) + (match fninfo with + [] -> mkres s res name (promote_mcode rbrace) + | Ast0.FStorage(stg)::_ -> + mkres s res (promote_mcode stg) (promote_mcode rbrace) + | Ast0.FType(ty)::_ -> mkres s res ty (promote_mcode rbrace) + | Ast0.FInline(inline)::_ -> + mkres s res (promote_mcode inline) (promote_mcode rbrace) + | Ast0.FAttr(attr)::_ -> + mkres s res (promote_mcode attr) (promote_mcode rbrace)) + + | Ast0.Include(inc,stm) -> + mkres s (Ast0.Include(inc,stm)) (promote_mcode inc) (promote_mcode stm) + | Ast0.Define(def,id,params,body) -> + let id = ident id in + let body = dots is_stm_dots None statement body in + mkres s (Ast0.Define(def,id,params,body)) (promote_mcode def) body + | Ast0.OptStm(stm) -> + let stm = statement stm in mkres s (Ast0.OptStm(stm)) stm stm + | Ast0.UniqueStm(stm) -> + let stm = statement stm in mkres s (Ast0.UniqueStm(stm)) stm stm in + Ast0.set_dots_bef_aft res + (match Ast0.get_dots_bef_aft res with + Ast0.NoDots -> Ast0.NoDots + | Ast0.AddingBetweenDots s -> + Ast0.AddingBetweenDots(statement s) + | Ast0.DroppingBetweenDots s -> + Ast0.DroppingBetweenDots(statement s)) + +and case_line c = + match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> + let code = dots is_stm_dots (Some(promote_mcode colon)) statement code in + mkres c (Ast0.Default(def,colon,code)) (promote_mcode def) code + | Ast0.Case(case,exp,colon,code) -> + let exp = expression exp in + let code = dots is_stm_dots (Some(promote_mcode colon)) statement code in + mkres c (Ast0.Case(case,exp,colon,code)) (promote_mcode case) code + | Ast0.OptCase(case) -> + let case = case_line case in mkres c (Ast0.OptCase(case)) case case + +and statement_dots x = dots is_stm_dots None statement x + +(* --------------------------------------------------------------------- *) +(* Function declaration *) + +let top_level t = + match Ast0.unwrap t with + Ast0.FILEINFO(old_file,new_file) -> t + | Ast0.DECL(stmt) -> + let stmt = statement stmt in mkres t (Ast0.DECL(stmt)) stmt stmt + | Ast0.CODE(rule_elem_dots) -> + let rule_elem_dots = dots is_stm_dots None statement rule_elem_dots in + mkres t (Ast0.CODE(rule_elem_dots)) rule_elem_dots rule_elem_dots + | Ast0.ERRORWORDS(exps) -> t + | Ast0.OTHER(_) -> failwith "eliminated by top_level" + +(* --------------------------------------------------------------------- *) +(* Entry points *) + +let compute_lines = List.map top_level + diff --git a/parsing_cocci/.#context_neg.ml.1.103 b/parsing_cocci/.#context_neg.ml.1.103 new file mode 100644 index 0000000..84eaabe --- /dev/null +++ b/parsing_cocci/.#context_neg.ml.1.103 @@ -0,0 +1,1013 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* Detects subtrees that are all minus/plus and nodes that are "binding +context nodes". The latter is a node whose structure and immediate tokens +are the same in the minus and plus trees, and such that for every child, +the set of context nodes in the child subtree is the same in the minus and +plus subtrees. *) + +module Ast = Ast_cocci +module Ast0 = Ast0_cocci +module V0 = Visitor_ast0 +module U = Unparse_ast0 + +(* --------------------------------------------------------------------- *) +(* Generic access to code *) + +let set_mcodekind x mcodekind = + match x with + Ast0.DotsExprTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.DotsInitTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.DotsParamTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.DotsStmtTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.DotsDeclTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.DotsCaseTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.IdentTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.ExprTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.ArgExprTag(d) | Ast0.TestExprTag(d) -> + failwith "not possible - iso only" + | Ast0.TypeCTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.ParamTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.DeclTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.InitTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.StmtTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.CaseLineTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.TopTag(d) -> Ast0.set_mcodekind d mcodekind + | Ast0.IsoWhenTag(_) -> failwith "only within iso phase" + | Ast0.IsoWhenTTag(_) -> failwith "only within iso phase" + | Ast0.IsoWhenFTag(_) -> failwith "only within iso phase" + | Ast0.MetaPosTag(p) -> failwith "metapostag only within iso phase" + +let set_index x index = + match x with + Ast0.DotsExprTag(d) -> Ast0.set_index d index + | Ast0.DotsInitTag(d) -> Ast0.set_index d index + | Ast0.DotsParamTag(d) -> Ast0.set_index d index + | Ast0.DotsStmtTag(d) -> Ast0.set_index d index + | Ast0.DotsDeclTag(d) -> Ast0.set_index d index + | Ast0.DotsCaseTag(d) -> Ast0.set_index d index + | Ast0.IdentTag(d) -> Ast0.set_index d index + | Ast0.ExprTag(d) -> Ast0.set_index d index + | Ast0.ArgExprTag(d) | Ast0.TestExprTag(d) -> + failwith "not possible - iso only" + | Ast0.TypeCTag(d) -> Ast0.set_index d index + | Ast0.ParamTag(d) -> Ast0.set_index d index + | Ast0.InitTag(d) -> Ast0.set_index d index + | Ast0.DeclTag(d) -> Ast0.set_index d index + | Ast0.StmtTag(d) -> Ast0.set_index d index + | Ast0.CaseLineTag(d) -> Ast0.set_index d index + | Ast0.TopTag(d) -> Ast0.set_index d index + | Ast0.IsoWhenTag(_) -> failwith "only within iso phase" + | Ast0.IsoWhenTTag(_) -> failwith "only within iso phase" + | Ast0.IsoWhenFTag(_) -> failwith "only within iso phase" + | Ast0.MetaPosTag(p) -> failwith "metapostag only within iso phase" + +let get_index = function + Ast0.DotsExprTag(d) -> Index.expression_dots d + | Ast0.DotsInitTag(d) -> Index.initialiser_dots d + | Ast0.DotsParamTag(d) -> Index.parameter_dots d + | Ast0.DotsStmtTag(d) -> Index.statement_dots d + | Ast0.DotsDeclTag(d) -> Index.declaration_dots d + | Ast0.DotsCaseTag(d) -> Index.case_line_dots d + | Ast0.IdentTag(d) -> Index.ident d + | Ast0.ExprTag(d) -> Index.expression d + | Ast0.ArgExprTag(d) | Ast0.TestExprTag(d) -> + failwith "not possible - iso only" + | Ast0.TypeCTag(d) -> Index.typeC d + | Ast0.ParamTag(d) -> Index.parameterTypeDef d + | Ast0.InitTag(d) -> Index.initialiser d + | Ast0.DeclTag(d) -> Index.declaration d + | Ast0.StmtTag(d) -> Index.statement d + | Ast0.CaseLineTag(d) -> Index.case_line d + | Ast0.TopTag(d) -> Index.top_level d + | Ast0.IsoWhenTag(_) -> failwith "only within iso phase" + | Ast0.IsoWhenTTag(_) -> failwith "only within iso phase" + | Ast0.IsoWhenFTag(_) -> failwith "only within iso phase" + | Ast0.MetaPosTag(p) -> failwith "metapostag only within iso phase" + +(* --------------------------------------------------------------------- *) +(* Collect the line numbers of the plus code. This is used for disjunctions. +It is not completely clear why this is necessary, but it seems like an easy +fix for whatever is the problem that is discussed in disj_cases *) + +let plus_lines = ref ([] : int list) + +let insert n = + let rec loop = function + [] -> [n] + | x::xs -> + match compare n x with + 1 -> x::(loop xs) + | 0 -> x::xs + | -1 -> n::x::xs + | _ -> failwith "not possible" in + plus_lines := loop !plus_lines + +let find n min max = + let rec loop = function + [] -> (min,max) + | [x] -> if n < x then (min,x) else (x,max) + | x1::x2::rest -> + if n < x1 + then (min,x1) + else if n > x1 && n < x2 then (x1,x2) else loop (x2::rest) in + loop !plus_lines + +let collect_plus_lines top = + plus_lines := []; + let bind x y = () in + let option_default = () in + let donothing r k e = k e in + let mcode (_,_,info,mcodekind,_) = + match mcodekind with + Ast0.PLUS -> insert info.Ast0.line_start + | _ -> () in + let fn = + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing donothing + donothing donothing in + fn.V0.combiner_top_level top + +(* --------------------------------------------------------------------- *) + +type kind = Neutral | AllMarked | NotAllMarked (* marked means + or - *) + +(* --------------------------------------------------------------------- *) +(* The first part analyzes each of the minus tree and the plus tree +separately *) + +(* ints are unique token indices (offset field) *) +type node = + Token (* tokens *) of kind * int (* unique index *) * Ast0.mcodekind * + int list (* context tokens *) + | Recursor (* children *) of kind * + int list (* indices of all tokens at the level below *) * + Ast0.mcodekind list (* tokens at the level below *) * + int list + | Bind (* neighbors *) of kind * + int list (* indices of all tokens at current level *) * + Ast0.mcodekind list (* tokens at current level *) * + int list (* indices of all tokens at the level below *) * + Ast0.mcodekind list (* tokens at the level below *) + * int list list + +let kind2c = function + Neutral -> "neutral" + | AllMarked -> "allmarked" + | NotAllMarked -> "notallmarked" + +let node2c = function + Token(k,_,_,_) -> Printf.sprintf "token %s\n" (kind2c k) + | Recursor(k,_,_,_) -> Printf.sprintf "recursor %s\n" (kind2c k) + | Bind(k,_,_,_,_,_) -> Printf.sprintf "bind %s\n" (kind2c k) + +(* goal: detect negative in both tokens and recursors, or context only in +tokens *) +let bind c1 c2 = + let lub = function + (k1,k2) when k1 = k2 -> k1 + | (Neutral,AllMarked) -> AllMarked + | (AllMarked,Neutral) -> AllMarked + | _ -> NotAllMarked in + match (c1,c2) with + (* token/token *) + (* there are tokens at this level, so ignore the level below *) + (Token(k1,i1,t1,l1),Token(k2,i2,t2,l2)) -> + Bind(lub(k1,k2),[i1;i2],[t1;t2],[],[],[l1;l2]) + + (* token/recursor *) + (* there are tokens at this level, so ignore the level below *) + | (Token(k1,i1,t1,l1),Recursor(k2,_,_,l2)) -> + Bind(lub(k1,k2),[i1],[t1],[],[],[l1;l2]) + | (Recursor(k1,_,_,l1),Token(k2,i2,t2,l2)) -> + Bind(lub(k1,k2),[i2],[t2],[],[],[l1;l2]) + + (* token/bind *) + (* there are tokens at this level, so ignore the level below *) + | (Token(k1,i1,t1,l1),Bind(k2,i2,t2,_,_,l2)) -> + Bind(lub(k1,k2),i1::i2,t1::t2,[],[],l1::l2) + | (Bind(k1,i1,t1,_,_,l1),Token(k2,i2,t2,l2)) -> + Bind(lub(k1,k2),i1@[i2],t1@[t2],[],[],l1@[l2]) + + (* recursor/bind *) + | (Recursor(k1,bi1,bt1,l1),Bind(k2,i2,t2,bi2,bt2,l2)) -> + Bind(lub(k1,k2),i2,t2,bi1@bi2,bt1@bt2,l1::l2) + | (Bind(k1,i1,t1,bi1,bt1,l1),Recursor(k2,bi2,bt2,l2)) -> + Bind(lub(k1,k2),i1,t1,bi1@bi2,bt1@bt2,l1@[l2]) + + (* recursor/recursor and bind/bind - not likely to ever occur *) + | (Recursor(k1,bi1,bt1,l1),Recursor(k2,bi2,bt2,l2)) -> + Bind(lub(k1,k2),[],[],bi1@bi2,bt1@bt2,[l1;l2]) + | (Bind(k1,i1,t1,bi1,bt1,l1),Bind(k2,i2,t2,bi2,bt2,l2)) -> + Bind(lub(k1,k2),i1@i2,t1@t2,bi1@bi2,bt1@bt2,l1@l2) + + +let option_default = (*Bind(Neutral,[],[],[],[],[])*) + Recursor(Neutral,[],[],[]) + +let mcode (_,_,info,mcodekind,pos) = + let offset = info.Ast0.offset in + match mcodekind with + Ast0.MINUS(_) -> Token(AllMarked,offset,mcodekind,[]) + | Ast0.PLUS -> Token(AllMarked,offset,mcodekind,[]) + | Ast0.CONTEXT(_) -> Token(NotAllMarked,offset,mcodekind,[offset]) + | _ -> failwith "not possible" + +let neutral_mcode (_,_,info,mcodekind,pos) = + let offset = info.Ast0.offset in + match mcodekind with + Ast0.MINUS(_) -> Token(Neutral,offset,mcodekind,[]) + | Ast0.PLUS -> Token(Neutral,offset,mcodekind,[]) + | Ast0.CONTEXT(_) -> Token(Neutral,offset,mcodekind,[offset]) + | _ -> failwith "not possible" + +let is_context = function Ast0.CONTEXT(_) -> true | _ -> false + +let union_all l = List.fold_left Common.union_set [] l + +(* is minus is true when we are processing minus code that might be +intermingled with plus code. it is used in disj_cases *) +let classify is_minus all_marked table code = + let mkres builder k il tl bil btl l e = + (if k = AllMarked + then Ast0.set_mcodekind e (all_marked()) (* definitive *) + else + let check_index il tl = + if List.for_all is_context tl + then + (let e1 = builder e in + let index = (get_index e1)@il in + try + let _ = Hashtbl.find table index in + failwith + (Printf.sprintf "line %d: index %s already used\n" + (Ast0.get_info e).Ast0.line_start + (String.concat " " (List.map string_of_int index))) + with Not_found -> Hashtbl.add table index (e1,l)) in + if il = [] then check_index bil btl else check_index il tl); + if il = [] + then Recursor(k, bil, btl, union_all l) + else Recursor(k, il, tl, union_all l) in + + let compute_result builder e = function + Bind(k,il,tl,bil,btl,l) -> mkres builder k il tl bil btl l e + | Token(k,il,tl,l) -> mkres builder k [il] [tl] [] [] [l] e + | Recursor(k,bil,btl,l) -> mkres builder k [] [] bil btl [l] e in + + let make_not_marked = function + Bind(k,il,tl,bil,btl,l) -> Bind(NotAllMarked,il,tl,bil,btl,l) + | Token(k,il,tl,l) -> Token(NotAllMarked,il,tl,l) + | Recursor(k,bil,btl,l) -> Recursor(NotAllMarked,bil,btl,l) in + + let do_nothing builder r k e = compute_result builder e (k e) in + + let disj_cases disj starter code fn ender = + (* neutral_mcode used so starter and ender don't have an affect on + whether the code is considered all plus/minus, but so that they are + consider in the index list, which is needed to make a disj with + something in one branch and nothing in the other different from code + that just has the something (starter/ender enough, mids not needed + for this). Cannot agglomerate + code over | boundaries, because two - + cases might have different + code, and don't want to put the + code + together into one unit. *) + let make_not_marked = + if is_minus + then + (let min = Ast0.get_line disj in + let max = Ast0.get_line_end disj in + let (plus_min,plus_max) = find min (min-1) (max+1) in + if max > plus_max then make_not_marked else (function x -> x)) + else make_not_marked in + bind (neutral_mcode starter) + (bind (List.fold_right bind + (List.map make_not_marked (List.map fn code)) + option_default) + (neutral_mcode ender)) in + + (* no whencode in plus tree so have to drop it *) + (* need special cases for dots, nests, and disjs *) + let expression r k e = + compute_result Ast0.expr e + (match Ast0.unwrap e with + Ast0.NestExpr(starter,exp,ender,whencode,multi) -> + k (Ast0.rewrap e (Ast0.NestExpr(starter,exp,ender,None,multi))) + | Ast0.Edots(dots,whencode) -> + k (Ast0.rewrap e (Ast0.Edots(dots,None))) + | Ast0.Ecircles(dots,whencode) -> + k (Ast0.rewrap e (Ast0.Ecircles(dots,None))) + | Ast0.Estars(dots,whencode) -> + k (Ast0.rewrap e (Ast0.Estars(dots,None))) + | Ast0.DisjExpr(starter,expr_list,_,ender) -> + disj_cases e starter expr_list r.V0.combiner_expression ender + | _ -> k e) in + + (* not clear why we have the next two cases, since DisjDecl and + DisjType shouldn't have been constructed yet, as they only come from isos *) + let declaration r k e = + compute_result Ast0.decl e + (match Ast0.unwrap e with + Ast0.DisjDecl(starter,decls,_,ender) -> + disj_cases e starter decls r.V0.combiner_declaration ender + | Ast0.Ddots(dots,whencode) -> + k (Ast0.rewrap e (Ast0.Ddots(dots,None))) + (* Need special cases for the following so that the type will be + considered as a unit, rather than distributed around the + declared variable. This needs to be done because of the call to + compute_result, ie the processing of each term should make a + side-effect on the complete term structure as well as collecting + some information about it. So we have to visit each complete + term structure. In (all?) other such cases, we visit the terms + using rebuilder, which just visits the subterms, rather than + reordering their components. *) + | Ast0.Init(stg,ty,id,eq,ini,sem) -> + bind (match stg with Some stg -> mcode stg | _ -> option_default) + (bind (r.V0.combiner_typeC ty) + (bind (r.V0.combiner_ident id) + (bind (mcode eq) + (bind (r.V0.combiner_initialiser ini) (mcode sem))))) + | Ast0.UnInit(stg,ty,id,sem) -> + bind (match stg with Some stg -> mcode stg | _ -> option_default) + (bind (r.V0.combiner_typeC ty) + (bind (r.V0.combiner_ident id) (mcode sem))) + | _ -> k e) in + + let param r k e = + compute_result Ast0.param e + (match Ast0.unwrap e with + Ast0.Param(ty,Some id) -> + (* needed for the same reason as in the Init and UnInit cases *) + bind (r.V0.combiner_typeC ty) (r.V0.combiner_ident id) + | _ -> k e) in + + let typeC r k e = + compute_result Ast0.typeC e + (match Ast0.unwrap e with + Ast0.DisjType(starter,types,_,ender) -> + disj_cases e starter types r.V0.combiner_typeC ender + | _ -> k e) in + + let initialiser r k i = + compute_result Ast0.ini i + (match Ast0.unwrap i with + Ast0.Idots(dots,whencode) -> + k (Ast0.rewrap i (Ast0.Idots(dots,None))) + | _ -> k i) in + + let statement r k s = + compute_result Ast0.stmt s + (match Ast0.unwrap s with + Ast0.Nest(started,stm_dots,ender,whencode,multi) -> + k (Ast0.rewrap s (Ast0.Nest(started,stm_dots,ender,[],multi))) + | Ast0.Dots(dots,whencode) -> + k (Ast0.rewrap s (Ast0.Dots(dots,[]))) + | Ast0.Circles(dots,whencode) -> + k (Ast0.rewrap s (Ast0.Circles(dots,[]))) + | Ast0.Stars(dots,whencode) -> + k (Ast0.rewrap s (Ast0.Stars(dots,[]))) + | Ast0.Disj(starter,statement_dots_list,_,ender) -> + disj_cases s starter statement_dots_list r.V0.combiner_statement_dots + ender +(* Why? There is nothing there + (* cases for everything with extra mcode *) + | Ast0.FunDecl((info,bef),_,_,_,_,_,_,_,_) + | Ast0.Decl((info,bef),_) -> + bind (mcode ((),(),info,bef)) (k s) + | Ast0.IfThen(_,_,_,_,_,(info,aft)) + | Ast0.IfThenElse(_,_,_,_,_,_,_,(info,aft)) + | Ast0.While(_,_,_,_,_,(info,aft)) -> + | Ast0.For(_,_,_,_,_,_,_,_,_,(info,aft)) -> + bind (k s) (mcode ((),(),info,aft)) + | Ast0.Iterator(_,_,_,_,_,(info,aft)) +*) + | _ -> k s + +) in + + let do_top builder r k e = compute_result builder e (k e) in + + let combiner = + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + (do_nothing Ast0.dotsExpr) (do_nothing Ast0.dotsInit) + (do_nothing Ast0.dotsParam) (do_nothing Ast0.dotsStmt) + (do_nothing Ast0.dotsDecl) (do_nothing Ast0.dotsCase) + (do_nothing Ast0.ident) expression typeC initialiser param declaration + statement (do_nothing Ast0.case_line) (do_top Ast0.top) in + combiner.V0.combiner_top_level code + +(* --------------------------------------------------------------------- *) +(* Traverse the hash tables and find corresponding context nodes that have +the same context children *) + +(* this is just a sanity check - really only need to look at the top-level + structure *) +let equal_mcode (_,_,info1,_,_) (_,_,info2,_,_) = + info1.Ast0.offset = info2.Ast0.offset + +let equal_option e1 e2 = + match (e1,e2) with + (Some x, Some y) -> equal_mcode x y + | (None, None) -> true + | _ -> false + +let dots fn d1 d2 = + match (Ast0.unwrap d1,Ast0.unwrap d2) with + (Ast0.DOTS(l1),Ast0.DOTS(l2)) -> List.length l1 = List.length l2 + | (Ast0.CIRCLES(l1),Ast0.CIRCLES(l2)) -> List.length l1 = List.length l2 + | (Ast0.STARS(l1),Ast0.STARS(l2)) -> List.length l1 = List.length l2 + | _ -> false + +let rec equal_ident i1 i2 = + match (Ast0.unwrap i1,Ast0.unwrap i2) with + (Ast0.Id(name1),Ast0.Id(name2)) -> equal_mcode name1 name2 + | (Ast0.MetaId(name1,_,_),Ast0.MetaId(name2,_,_)) -> + equal_mcode name1 name2 + | (Ast0.MetaFunc(name1,_,_),Ast0.MetaFunc(name2,_,_)) -> + equal_mcode name1 name2 + | (Ast0.MetaLocalFunc(name1,_,_),Ast0.MetaLocalFunc(name2,_,_)) -> + equal_mcode name1 name2 + | (Ast0.OptIdent(_),Ast0.OptIdent(_)) -> true + | (Ast0.UniqueIdent(_),Ast0.UniqueIdent(_)) -> true + | _ -> false + +let rec equal_expression e1 e2 = + match (Ast0.unwrap e1,Ast0.unwrap e2) with + (Ast0.Ident(_),Ast0.Ident(_)) -> true + | (Ast0.Constant(const1),Ast0.Constant(const2)) -> equal_mcode const1 const2 + | (Ast0.FunCall(_,lp1,_,rp1),Ast0.FunCall(_,lp2,_,rp2)) -> + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.Assignment(_,op1,_,_),Ast0.Assignment(_,op2,_,_)) -> + equal_mcode op1 op2 + | (Ast0.CondExpr(_,why1,_,colon1,_),Ast0.CondExpr(_,why2,_,colon2,_)) -> + equal_mcode why1 why2 && equal_mcode colon1 colon2 + | (Ast0.Postfix(_,op1),Ast0.Postfix(_,op2)) -> equal_mcode op1 op2 + | (Ast0.Infix(_,op1),Ast0.Infix(_,op2)) -> equal_mcode op1 op2 + | (Ast0.Unary(_,op1),Ast0.Unary(_,op2)) -> equal_mcode op1 op2 + | (Ast0.Binary(_,op1,_),Ast0.Binary(_,op2,_)) -> equal_mcode op1 op2 + | (Ast0.Paren(lp1,_,rp1),Ast0.Paren(lp2,_,rp2)) -> + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.ArrayAccess(_,lb1,_,rb1),Ast0.ArrayAccess(_,lb2,_,rb2)) -> + equal_mcode lb1 lb2 && equal_mcode rb1 rb2 + | (Ast0.RecordAccess(_,pt1,_),Ast0.RecordAccess(_,pt2,_)) -> + equal_mcode pt1 pt2 + | (Ast0.RecordPtAccess(_,ar1,_),Ast0.RecordPtAccess(_,ar2,_)) -> + equal_mcode ar1 ar2 + | (Ast0.Cast(lp1,_,rp1,_),Ast0.Cast(lp2,_,rp2,_)) -> + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.SizeOfExpr(szf1,_),Ast0.SizeOfExpr(szf2,_)) -> + equal_mcode szf1 szf2 + | (Ast0.SizeOfType(szf1,lp1,_,rp1),Ast0.SizeOfType(szf2,lp2,_,rp2)) -> + equal_mcode szf1 szf2 && equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.TypeExp(_),Ast0.TypeExp(_)) -> true + | (Ast0.MetaErr(name1,_,_),Ast0.MetaErr(name2,_,_)) + | (Ast0.MetaExpr(name1,_,_,_,_),Ast0.MetaExpr(name2,_,_,_,_)) + | (Ast0.MetaExprList(name1,_,_),Ast0.MetaExprList(name2,_,_)) -> + equal_mcode name1 name2 + | (Ast0.EComma(cm1),Ast0.EComma(cm2)) -> equal_mcode cm1 cm2 + | (Ast0.DisjExpr(starter1,_,mids1,ender1), + Ast0.DisjExpr(starter2,_,mids2,ender2)) -> + equal_mcode starter1 starter2 && + List.for_all2 equal_mcode mids1 mids2 && + equal_mcode ender1 ender2 + | (Ast0.NestExpr(starter1,_,ender1,_,m1), + Ast0.NestExpr(starter2,_,ender2,_,m2)) -> + equal_mcode starter1 starter2 && equal_mcode ender1 ender2 && m1 = m2 + | (Ast0.Edots(dots1,_),Ast0.Edots(dots2,_)) + | (Ast0.Ecircles(dots1,_),Ast0.Ecircles(dots2,_)) + | (Ast0.Estars(dots1,_),Ast0.Estars(dots2,_)) -> equal_mcode dots1 dots2 + | (Ast0.OptExp(_),Ast0.OptExp(_)) -> true + | (Ast0.UniqueExp(_),Ast0.UniqueExp(_)) -> true + | _ -> false + +let rec equal_typeC t1 t2 = + match (Ast0.unwrap t1,Ast0.unwrap t2) with + (Ast0.ConstVol(cv1,_),Ast0.ConstVol(cv2,_)) -> equal_mcode cv1 cv2 + | (Ast0.BaseType(ty1,stringsa),Ast0.BaseType(ty2,stringsb)) -> + List.for_all2 equal_mcode stringsa stringsb + | (Ast0.Signed(sign1,_),Ast0.Signed(sign2,_)) -> + equal_mcode sign1 sign2 + | (Ast0.Pointer(_,star1),Ast0.Pointer(_,star2)) -> + equal_mcode star1 star2 + | (Ast0.Array(_,lb1,_,rb1),Ast0.Array(_,lb2,_,rb2)) -> + equal_mcode lb1 lb2 && equal_mcode rb1 rb2 + | (Ast0.EnumName(kind1,_),Ast0.EnumName(kind2,_)) -> + equal_mcode kind1 kind2 + | (Ast0.StructUnionName(kind1,_),Ast0.StructUnionName(kind2,_)) -> + equal_mcode kind1 kind2 + | (Ast0.FunctionType(ty1,lp1,p1,rp1),Ast0.FunctionType(ty2,lp2,p2,rp2)) -> + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.StructUnionDef(_,lb1,_,rb1), + Ast0.StructUnionDef(_,lb2,_,rb2)) -> + equal_mcode lb1 lb2 && equal_mcode rb1 rb2 + | (Ast0.TypeName(name1),Ast0.TypeName(name2)) -> equal_mcode name1 name2 + | (Ast0.MetaType(name1,_),Ast0.MetaType(name2,_)) -> + equal_mcode name1 name2 + | (Ast0.DisjType(starter1,_,mids1,ender1), + Ast0.DisjType(starter2,_,mids2,ender2)) -> + equal_mcode starter1 starter2 && + List.for_all2 equal_mcode mids1 mids2 && + equal_mcode ender1 ender2 + | (Ast0.OptType(_),Ast0.OptType(_)) -> true + | (Ast0.UniqueType(_),Ast0.UniqueType(_)) -> true + | _ -> false + +let equal_declaration d1 d2 = + match (Ast0.unwrap d1,Ast0.unwrap d2) with + (Ast0.Init(stg1,_,_,eq1,_,sem1),Ast0.Init(stg2,_,_,eq2,_,sem2)) -> + equal_option stg1 stg2 && equal_mcode eq1 eq2 && equal_mcode sem1 sem2 + | (Ast0.UnInit(stg1,_,_,sem1),Ast0.UnInit(stg2,_,_,sem2)) -> + equal_option stg1 stg2 && equal_mcode sem1 sem2 + | (Ast0.MacroDecl(nm1,lp1,_,rp1,sem1),Ast0.MacroDecl(nm2,lp2,_,rp2,sem2)) -> + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 && equal_mcode sem1 sem2 + | (Ast0.TyDecl(_,sem1),Ast0.TyDecl(_,sem2)) -> equal_mcode sem1 sem2 + | (Ast0.Ddots(dots1,_),Ast0.Ddots(dots2,_)) -> equal_mcode dots1 dots2 + | (Ast0.OptDecl(_),Ast0.OptDecl(_)) -> true + | (Ast0.UniqueDecl(_),Ast0.UniqueDecl(_)) -> true + | (Ast0.DisjDecl _,_) | (_,Ast0.DisjDecl _) -> + failwith "DisjDecl not expected here" + | _ -> false + +let equal_initialiser i1 i2 = + match (Ast0.unwrap i1,Ast0.unwrap i2) with + (Ast0.InitExpr(_),Ast0.InitExpr(_)) -> true + | (Ast0.InitList(lb1,_,rb1),Ast0.InitList(lb2,_,rb2)) -> + (equal_mcode lb1 lb2) && (equal_mcode rb1 rb2) + | (Ast0.InitGccDotName(dot1,_,eq1,_),Ast0.InitGccDotName(dot2,_,eq2,_)) -> + (equal_mcode dot1 dot2) && (equal_mcode eq1 eq2) + | (Ast0.InitGccName(_,eq1,_),Ast0.InitGccName(_,eq2,_)) -> + equal_mcode eq1 eq2 + | (Ast0.InitGccIndex(lb1,_,rb1,eq1,_),Ast0.InitGccIndex(lb2,_,rb2,eq2,_)) -> + (equal_mcode lb1 lb2) && (equal_mcode rb1 rb2) && (equal_mcode eq1 eq2) + | (Ast0.InitGccRange(lb1,_,dots1,_,rb1,eq1,_), + Ast0.InitGccRange(lb2,_,dots2,_,rb2,eq2,_)) -> + (equal_mcode lb1 lb2) && (equal_mcode dots1 dots2) && + (equal_mcode rb1 rb2) && (equal_mcode eq1 eq2) + | (Ast0.IComma(cm1),Ast0.IComma(cm2)) -> equal_mcode cm1 cm2 + | (Ast0.Idots(d1,_),Ast0.Idots(d2,_)) -> equal_mcode d1 d2 + | (Ast0.OptIni(_),Ast0.OptIni(_)) -> true + | (Ast0.UniqueIni(_),Ast0.UniqueIni(_)) -> true + | _ -> false + +let equal_parameterTypeDef p1 p2 = + match (Ast0.unwrap p1,Ast0.unwrap p2) with + (Ast0.VoidParam(_),Ast0.VoidParam(_)) -> true + | (Ast0.Param(_,_),Ast0.Param(_,_)) -> true + | (Ast0.MetaParam(name1,_),Ast0.MetaParam(name2,_)) + | (Ast0.MetaParamList(name1,_,_),Ast0.MetaParamList(name2,_,_)) -> + equal_mcode name1 name2 + | (Ast0.PComma(cm1),Ast0.PComma(cm2)) -> equal_mcode cm1 cm2 + | (Ast0.Pdots(dots1),Ast0.Pdots(dots2)) + | (Ast0.Pcircles(dots1),Ast0.Pcircles(dots2)) -> equal_mcode dots1 dots2 + | (Ast0.OptParam(_),Ast0.OptParam(_)) -> true + | (Ast0.UniqueParam(_),Ast0.UniqueParam(_)) -> true + | _ -> false + +let rec equal_statement s1 s2 = + match (Ast0.unwrap s1,Ast0.unwrap s2) with + (Ast0.FunDecl(_,fninfo1,_,lp1,_,rp1,lbrace1,_,rbrace1), + Ast0.FunDecl(_,fninfo2,_,lp2,_,rp2,lbrace2,_,rbrace2)) -> + (List.length fninfo1) = (List.length fninfo2) && + List.for_all2 equal_fninfo fninfo1 fninfo2 && + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 && + equal_mcode lbrace1 lbrace2 && equal_mcode rbrace1 rbrace2 + | (Ast0.Decl(_,_),Ast0.Decl(_,_)) -> true + | (Ast0.Seq(lbrace1,_,rbrace1),Ast0.Seq(lbrace2,_,rbrace2)) -> + equal_mcode lbrace1 lbrace2 && equal_mcode rbrace1 rbrace2 + | (Ast0.ExprStatement(_,sem1),Ast0.ExprStatement(_,sem2)) -> + equal_mcode sem1 sem2 + | (Ast0.IfThen(iff1,lp1,_,rp1,_,_),Ast0.IfThen(iff2,lp2,_,rp2,_,_)) -> + equal_mcode iff1 iff2 && equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.IfThenElse(iff1,lp1,_,rp1,_,els1,_,_), + Ast0.IfThenElse(iff2,lp2,_,rp2,_,els2,_,_)) -> + equal_mcode iff1 iff2 && + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 && equal_mcode els1 els2 + | (Ast0.While(whl1,lp1,_,rp1,_,_),Ast0.While(whl2,lp2,_,rp2,_,_)) -> + equal_mcode whl1 whl2 && equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.Do(d1,_,whl1,lp1,_,rp1,sem1),Ast0.Do(d2,_,whl2,lp2,_,rp2,sem2)) -> + equal_mcode whl1 whl2 && equal_mcode d1 d2 && + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 && equal_mcode sem1 sem2 + | (Ast0.For(fr1,lp1,_,sem11,_,sem21,_,rp1,_,_), + Ast0.For(fr2,lp2,_,sem12,_,sem22,_,rp2,_,_)) -> + equal_mcode fr1 fr2 && equal_mcode lp1 lp2 && + equal_mcode sem11 sem12 && equal_mcode sem21 sem22 && + equal_mcode rp1 rp2 + | (Ast0.Iterator(nm1,lp1,_,rp1,_,_),Ast0.Iterator(nm2,lp2,_,rp2,_,_)) -> + equal_mcode lp1 lp2 && equal_mcode rp1 rp2 + | (Ast0.Switch(switch1,lp1,_,rp1,lb1,case1,rb1), + Ast0.Switch(switch2,lp2,_,rp2,lb2,case2,rb2)) -> + equal_mcode switch1 switch2 && equal_mcode lp1 lp2 && + equal_mcode rp1 rp2 && equal_mcode lb1 lb2 && + equal_mcode rb1 rb2 + | (Ast0.Break(br1,sem1),Ast0.Break(br2,sem2)) -> + equal_mcode br1 br2 && equal_mcode sem1 sem2 + | (Ast0.Continue(cont1,sem1),Ast0.Continue(cont2,sem2)) -> + equal_mcode cont1 cont2 && equal_mcode sem1 sem2 + | (Ast0.Label(_,dd1),Ast0.Label(_,dd2)) -> + equal_mcode dd1 dd2 + | (Ast0.Goto(g1,_,sem1),Ast0.Goto(g2,_,sem2)) -> + equal_mcode g1 g2 && equal_mcode sem1 sem2 + | (Ast0.Return(ret1,sem1),Ast0.Return(ret2,sem2)) -> + equal_mcode ret1 ret2 && equal_mcode sem1 sem2 + | (Ast0.ReturnExpr(ret1,_,sem1),Ast0.ReturnExpr(ret2,_,sem2)) -> + equal_mcode ret1 ret2 && equal_mcode sem1 sem2 + | (Ast0.MetaStmt(name1,_),Ast0.MetaStmt(name2,_)) + | (Ast0.MetaStmtList(name1,_),Ast0.MetaStmtList(name2,_)) -> + equal_mcode name1 name2 + | (Ast0.Disj(starter1,_,mids1,ender1),Ast0.Disj(starter2,_,mids2,ender2)) -> + equal_mcode starter1 starter2 && + List.for_all2 equal_mcode mids1 mids2 && + equal_mcode ender1 ender2 + | (Ast0.Nest(starter1,_,ender1,_,m1),Ast0.Nest(starter2,_,ender2,_,m2)) -> + equal_mcode starter1 starter2 && equal_mcode ender1 ender2 && m1 = m2 + | (Ast0.Exp(_),Ast0.Exp(_)) -> true + | (Ast0.TopExp(_),Ast0.TopExp(_)) -> true + | (Ast0.Ty(_),Ast0.Ty(_)) -> true + | (Ast0.TopInit(_),Ast0.TopInit(_)) -> true + | (Ast0.Dots(d1,_),Ast0.Dots(d2,_)) + | (Ast0.Circles(d1,_),Ast0.Circles(d2,_)) + | (Ast0.Stars(d1,_),Ast0.Stars(d2,_)) -> equal_mcode d1 d2 + | (Ast0.Include(inc1,name1),Ast0.Include(inc2,name2)) -> + equal_mcode inc1 inc2 && equal_mcode name1 name2 + | (Ast0.Define(def1,_,_,_),Ast0.Define(def2,_,_,_)) -> + equal_mcode def1 def2 + | (Ast0.OptStm(_),Ast0.OptStm(_)) -> true + | (Ast0.UniqueStm(_),Ast0.UniqueStm(_)) -> true + | _ -> false + +and equal_fninfo x y = + match (x,y) with + (Ast0.FStorage(s1),Ast0.FStorage(s2)) -> equal_mcode s1 s2 + | (Ast0.FType(_),Ast0.FType(_)) -> true + | (Ast0.FInline(i1),Ast0.FInline(i2)) -> equal_mcode i1 i2 + | (Ast0.FAttr(i1),Ast0.FAttr(i2)) -> equal_mcode i1 i2 + | _ -> false + +let equal_case_line c1 c2 = + match (Ast0.unwrap c1,Ast0.unwrap c2) with + (Ast0.Default(def1,colon1,_),Ast0.Default(def2,colon2,_)) -> + equal_mcode def1 def2 && equal_mcode colon1 colon2 + | (Ast0.Case(case1,_,colon1,_),Ast0.Case(case2,_,colon2,_)) -> + equal_mcode case1 case2 && equal_mcode colon1 colon2 + | (Ast0.OptCase(_),Ast0.OptCase(_)) -> true + | _ -> false + +let rec equal_top_level t1 t2 = + match (Ast0.unwrap t1,Ast0.unwrap t2) with + (Ast0.DECL(_),Ast0.DECL(_)) -> true + | (Ast0.FILEINFO(old_file1,new_file1),Ast0.FILEINFO(old_file2,new_file2)) -> + equal_mcode old_file1 old_file2 && equal_mcode new_file1 new_file2 + | (Ast0.CODE(_),Ast0.CODE(_)) -> true + | (Ast0.ERRORWORDS(_),Ast0.ERRORWORDS(_)) -> true + | _ -> false + +let root_equal e1 e2 = + match (e1,e2) with + (Ast0.DotsExprTag(d1),Ast0.DotsExprTag(d2)) -> dots equal_expression d1 d2 + | (Ast0.DotsParamTag(d1),Ast0.DotsParamTag(d2)) -> + dots equal_parameterTypeDef d1 d2 + | (Ast0.DotsStmtTag(d1),Ast0.DotsStmtTag(d2)) -> dots equal_statement d1 d2 + | (Ast0.DotsDeclTag(d1),Ast0.DotsDeclTag(d2)) -> dots equal_declaration d1 d2 + | (Ast0.DotsCaseTag(d1),Ast0.DotsCaseTag(d2)) -> dots equal_case_line d1 d2 + | (Ast0.IdentTag(i1),Ast0.IdentTag(i2)) -> equal_ident i1 i2 + | (Ast0.ExprTag(e1),Ast0.ExprTag(e2)) -> equal_expression e1 e2 + | (Ast0.ArgExprTag(d),_) -> failwith "not possible - iso only" + | (Ast0.TypeCTag(t1),Ast0.TypeCTag(t2)) -> equal_typeC t1 t2 + | (Ast0.ParamTag(p1),Ast0.ParamTag(p2)) -> equal_parameterTypeDef p1 p2 + | (Ast0.InitTag(d1),Ast0.InitTag(d2)) -> equal_initialiser d1 d2 + | (Ast0.DeclTag(d1),Ast0.DeclTag(d2)) -> equal_declaration d1 d2 + | (Ast0.StmtTag(s1),Ast0.StmtTag(s2)) -> equal_statement s1 s2 + | (Ast0.TopTag(t1),Ast0.TopTag(t2)) -> equal_top_level t1 t2 + | (Ast0.IsoWhenTag(_),_) | (_,Ast0.IsoWhenTag(_)) + | (Ast0.IsoWhenTTag(_),_) | (_,Ast0.IsoWhenTTag(_)) + | (Ast0.IsoWhenFTag(_),_) | (_,Ast0.IsoWhenFTag(_)) -> + failwith "only within iso phase" + | _ -> false + +let default_context _ = + Ast0.CONTEXT(ref(Ast.NOTHING, + Ast0.default_token_info,Ast0.default_token_info)) + +let traverse minus_table plus_table = + Hashtbl.iter + (function key -> + function (e,l) -> + try + let (plus_e,plus_l) = Hashtbl.find plus_table key in + if root_equal e plus_e && + List.for_all (function x -> x) + (List.map2 Common.equal_set l plus_l) + then + let i = Ast0.fresh_index() in + (set_index e i; set_index plus_e i; + set_mcodekind e (default_context()); + set_mcodekind plus_e (default_context())) + with Not_found -> ()) + minus_table + +(* --------------------------------------------------------------------- *) +(* contextify the whencode *) + +let contextify_all = + let bind x y = () in + let option_default = () in + let mcode x = () in + let do_nothing r k e = Ast0.set_mcodekind e (default_context()); k e in + + V0.combiner bind option_default + 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 + do_nothing do_nothing do_nothing + +let contextify_whencode = + let bind x y = () in + let option_default = () in + let mcode x = () in + let do_nothing r k e = k e in + + let expression r k e = + k e; + match Ast0.unwrap e with + Ast0.NestExpr(_,_,_,Some whencode,_) + | Ast0.Edots(_,Some whencode) + | Ast0.Ecircles(_,Some whencode) + | Ast0.Estars(_,Some whencode) -> + contextify_all.V0.combiner_expression whencode + | _ -> () in + + let initialiser r k i = + match Ast0.unwrap i with + Ast0.Idots(dots,Some whencode) -> + contextify_all.V0.combiner_initialiser whencode + | _ -> k i in + + let whencode = function + Ast0.WhenNot sd -> contextify_all.V0.combiner_statement_dots sd + | Ast0.WhenAlways s -> contextify_all.V0.combiner_statement s + | Ast0.WhenModifier(_) -> () + | Ast0.WhenNotTrue(e) -> contextify_all.V0.combiner_expression e + | Ast0.WhenNotFalse(e) -> contextify_all.V0.combiner_expression e in + + let statement r k (s : Ast0.statement) = + k s; + match Ast0.unwrap s with + Ast0.Nest(_,_,_,whn,_) + | Ast0.Dots(_,whn) | Ast0.Circles(_,whn) | Ast0.Stars(_,whn) -> + List.iter whencode whn + | _ -> () in + + let combiner = + V0.combiner bind option_default + 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 + expression + do_nothing initialiser do_nothing do_nothing statement do_nothing + do_nothing in + combiner.V0.combiner_top_level + +(* --------------------------------------------------------------------- *) + +(* the first int list is the tokens in the node, the second is the tokens +in the descendents *) +let minus_table = + (Hashtbl.create(50) : (int list, Ast0.anything * int list list) Hashtbl.t) +let plus_table = + (Hashtbl.create(50) : (int list, Ast0.anything * int list list) Hashtbl.t) + +let iscode t = + match Ast0.unwrap t with + Ast0.DECL(_) -> true + | Ast0.FILEINFO(_) -> true + | Ast0.ERRORWORDS(_) -> false + | Ast0.CODE(_) -> true + | Ast0.OTHER(_) -> failwith "unexpected top level code" + +(* ------------------------------------------------------------------- *) +(* alignment of minus and plus *) + +let concat = function + [] -> [] + | [s] -> [s] + | l -> + let rec loop = function + [] -> [] + | x::rest -> + (match Ast0.unwrap x with + Ast0.DECL(s) -> let stms = loop rest in s::stms + | Ast0.CODE(ss) -> + let stms = loop rest in + (match Ast0.unwrap ss with + Ast0.DOTS(d) -> d@stms + | _ -> failwith "no dots allowed in pure plus code") + | _ -> failwith "plus code is being discarded") in + let res = + Compute_lines.statement_dots + (Ast0.rewrap (List.hd l) (Ast0.DOTS (loop l))) in + [Ast0.rewrap res (Ast0.CODE res)] + +let collect_up_to m plus = + let minfo = Ast0.get_info m in + let mend = minfo.Ast0.logical_end in + let rec loop = function + [] -> ([],[]) + | p::plus -> + let pinfo = Ast0.get_info p in + let pstart = pinfo.Ast0.logical_start in + if pstart > mend + then ([],p::plus) + else let (plus,rest) = loop plus in (p::plus,rest) in + let (plus,rest) = loop plus in + (concat plus,rest) + +let realign minus plus = + let rec loop = function + ([],_) -> failwith "not possible, some context required" + | ([m],p) -> ([m],concat p) + | (m::minus,plus) -> + let (p,plus) = collect_up_to m plus in + let (minus,plus) = loop (minus,plus) in + (m::minus,p@plus) in + loop (minus,plus) + +(* ------------------------------------------------------------------- *) +(* check compatible: check that at the top level the minus and plus code is +of the same kind. Could go further and make the correspondence between the +code between ...s. *) + +let isonly f l = match Ast0.undots l with [s] -> f s | _ -> false + +let isall f l = List.for_all (isonly f) l + +let rec is_exp s = + match Ast0.unwrap s with + Ast0.Exp(e) -> true + | Ast0.Disj(_,stmts,_,_) -> isall is_exp stmts + | _ -> false + +let rec is_ty s = + match Ast0.unwrap s with + Ast0.Ty(e) -> true + | Ast0.Disj(_,stmts,_,_) -> isall is_ty stmts + | _ -> false + +let rec is_init s = + match Ast0.unwrap s with + Ast0.TopInit(e) -> true + | Ast0.Disj(_,stmts,_,_) -> isall is_init stmts + | _ -> false + +let rec is_decl s = + match Ast0.unwrap s with + Ast0.Decl(_,e) -> true + | Ast0.FunDecl(_,_,_,_,_,_,_,_,_) -> true + | Ast0.Disj(_,stmts,_,_) -> isall is_decl stmts + | _ -> false + +let rec is_fndecl s = + match Ast0.unwrap s with + Ast0.FunDecl(_,_,_,_,_,_,_,_,_) -> true + | Ast0.Disj(_,stmts,_,_) -> isall is_fndecl stmts + | _ -> false + +let rec is_toplevel s = + match Ast0.unwrap s with + Ast0.Decl(_,e) -> true + | Ast0.FunDecl(_,_,_,_,_,_,_,_,_) -> true + | Ast0.Disj(_,stmts,_,_) -> isall is_toplevel stmts + | Ast0.ExprStatement(fc,_) -> + (match Ast0.unwrap fc with + Ast0.FunCall(_,_,_,_) -> true + | _ -> false) + | Ast0.Include(_,_) -> true + | Ast0.Define(_,_,_,_) -> true + | _ -> false + +let check_compatible m p = + let fail _ = + failwith + (Printf.sprintf + "incompatible minus and plus code starting on lines %d and %d" + (Ast0.get_line m) (Ast0.get_line p)) in + match (Ast0.unwrap m, Ast0.unwrap p) with + (Ast0.DECL(decl1),Ast0.DECL(decl2)) -> + if not (is_decl decl1 && is_decl decl2) + then fail() + | (Ast0.DECL(decl1),Ast0.CODE(code2)) -> + let v1 = is_decl decl1 in + let v2 = List.for_all is_toplevel (Ast0.undots code2) in + if !Flag.make_hrule = None && v1 && not v2 then fail() + | (Ast0.CODE(code1),Ast0.DECL(decl2)) -> + let v1 = List.for_all is_toplevel (Ast0.undots code1) in + let v2 = is_decl decl2 in + if v1 && not v2 then fail() + | (Ast0.CODE(code1),Ast0.CODE(code2)) -> + let v1 = isonly is_init code1 in + let v2a = isonly is_init code2 in + let v2b = isonly is_exp code2 in + if v1 + then (if not (v2a || v2b) then fail()) + else + let testers = [is_exp;is_ty] in + List.iter + (function tester -> + let v1 = isonly tester code1 in + let v2 = isonly tester code2 in + if (v1 && not v2) or (!Flag.make_hrule = None && v2 && not v1) + then fail()) + testers; + let v1 = isonly is_fndecl code1 in + let v2 = List.for_all is_toplevel (Ast0.undots code2) in + if !Flag.make_hrule = None && v1 && not v2 then fail() + | (Ast0.FILEINFO(_,_),Ast0.FILEINFO(_,_)) -> () + | (Ast0.OTHER(_),Ast0.OTHER(_)) -> () + | _ -> fail() + +(* ------------------------------------------------------------------- *) + +(* returns a list of corresponding minus and plus trees *) +let context_neg minus plus = + Hashtbl.clear minus_table; + Hashtbl.clear plus_table; + List.iter contextify_whencode minus; + let (minus,plus) = realign minus plus in + let rec loop = function + ([],[]) -> [] + | ([],l) -> + failwith (Printf.sprintf "%d plus things remaining" (List.length l)) + | (minus,[]) -> + plus_lines := []; + let _ = + List.map + (function m -> + classify true + (function _ -> Ast0.MINUS(ref([],Ast0.default_token_info))) + minus_table m) + minus in + [] + | (((m::minus) as mall),((p::plus) as pall)) -> + let minfo = Ast0.get_info m in + let pinfo = Ast0.get_info p in + let mstart = minfo.Ast0.logical_start in + let mend = minfo.Ast0.logical_end in + let pstart = pinfo.Ast0.logical_start in + let pend = pinfo.Ast0.logical_end in + if (iscode m or iscode p) && + (mend + 1 = pstart or pend + 1 = mstart or (* adjacent *) + (mstart <= pstart && mend >= pstart) or + (pstart <= mstart && pend >= mstart)) (* overlapping or nested *) + then + begin + (* ensure that the root of each tree has a unique index, + although it might get overwritten if the node is a context + node *) + let i = Ast0.fresh_index() in + Ast0.set_index m i; Ast0.set_index p i; + check_compatible m p; + collect_plus_lines p; + let _ = + classify true + (function _ -> Ast0.MINUS(ref([],Ast0.default_token_info))) + minus_table m in + let _ = classify false (function _ -> Ast0.PLUS) plus_table p in + traverse minus_table plus_table; + (m,p)::loop(minus,plus) + end + else + if not(iscode m or iscode p) + then loop(minus,plus) + else + if mstart < pstart + then + begin + plus_lines := []; + let _ = + classify true + (function _ -> Ast0.MINUS(ref([],Ast0.default_token_info))) + minus_table m in + loop(minus,pall) + end + else loop(mall,plus) in + loop(minus,plus) diff --git a/parsing_cocci/.#data.ml.1.37 b/parsing_cocci/.#data.ml.1.37 new file mode 100644 index 0000000..fe7c28d --- /dev/null +++ b/parsing_cocci/.#data.ml.1.37 @@ -0,0 +1,148 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +module Ast0 = Ast0_cocci +module Ast = Ast_cocci + +(* types that clutter the .mly file *) +(* for iso metavariables, true if they can only match nonmodified, unitary + metavariables *) +type fresh = bool + +type clt = + line_type * int * int * int * int (* starting spaces *) * + string list (* code before *) * string list (* code after *) * + Ast0.meta_pos (* position variable, minus only *) + +(* ---------------------------------------------------------------------- *) + +(* Things that need to be seen by the lexer and parser. *) + +and line_type = + MINUS | OPTMINUS | UNIQUEMINUS + | PLUS + | CONTEXT | UNIQUE | OPT + +type iconstraints = Ast0.ident list +type econstraints = Ast0.expression list +type pconstraints = Ast.meta_name list + +let in_rule_name = ref false +let in_meta = ref false +let in_iso = ref false +let in_generating = ref false +let in_prolog = ref false +let inheritable_positions = + ref ([] : string list) (* rules from which posns can be inherited *) + +let all_metadecls = + (Hashtbl.create(100) : (string, Ast.metavar list) Hashtbl.t) + +let clear_meta: (unit -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_id_meta: + (Ast.meta_name -> iconstraints -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_type_meta: (Ast.meta_name -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_param_meta: (Ast.meta_name -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_paramlist_meta: + (Ast.meta_name -> Ast.meta_name option -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_const_meta: + (Type_cocci.typeC list option -> Ast.meta_name -> econstraints -> + Ast0.pure -> unit) + ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_err_meta: + (Ast.meta_name -> econstraints -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_exp_meta: + (Type_cocci.typeC list option -> Ast.meta_name -> econstraints -> + Ast0.pure -> unit) + ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_idexp_meta: + (Type_cocci.typeC list option -> Ast.meta_name -> econstraints -> + Ast0.pure -> unit) + ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_local_idexp_meta: + (Type_cocci.typeC list option -> Ast.meta_name -> econstraints -> + Ast0.pure -> unit) + ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_explist_meta: + (Ast.meta_name -> Ast.meta_name option -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_stm_meta: (Ast.meta_name -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_stmlist_meta: (Ast.meta_name -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_func_meta: + (Ast.meta_name -> iconstraints -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_local_func_meta: + (Ast.meta_name -> iconstraints -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_declarer_meta: + (Ast.meta_name -> iconstraints -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_decl") + +let add_iterator_meta: + (Ast.meta_name -> iconstraints -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_iter") + +let add_pos_meta: + (Ast.meta_name -> pconstraints -> Ast.meta_collect -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + +let add_type_name: (string -> unit) ref = + ref (fun _ -> failwith "uninitialized add_type") + +let add_declarer_name: (string -> unit) ref = + ref (fun _ -> failwith "uninitialized add_decl") + +let add_iterator_name: (string -> unit) ref = + ref (fun _ -> failwith "uninitialized add_iter") + +let init_rule: (unit -> unit) ref = + ref (fun _ -> failwith "uninitialized install_bindings") + +let install_bindings: (string -> unit) ref = + ref (fun _ -> failwith "uninitialized install_bindings") diff --git a/parsing_cocci/.#disjdistr.ml.1.27 b/parsing_cocci/.#disjdistr.ml.1.27 new file mode 100644 index 0000000..ae7679f --- /dev/null +++ b/parsing_cocci/.#disjdistr.ml.1.27 @@ -0,0 +1,395 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +module Ast = Ast_cocci +module V = Visitor_ast + +let disjmult2 e1 e2 k = + List.concat + (List.map (function e1 -> List.map (function e2 -> k e1 e2) e2) e1) + +let disjmult3 e1 e2 e3 k = + List.concat + (List.map + (function e1 -> + List.concat + (List.map + (function e2 -> List.map (function e3 -> k e1 e2 e3) e3) + e2)) + e1) + +let rec disjmult f = function + [] -> [[]] + | x::xs -> + let cur = f x in + let rest = disjmult f xs in + disjmult2 cur rest (function cur -> function rest -> cur :: rest) + +let disjoption f = function + None -> [None] + | Some x -> List.map (function x -> Some x) (f x) + +let disjdots f d = + match Ast.unwrap d with + Ast.DOTS(l) -> + List.map (function l -> Ast.rewrap d (Ast.DOTS(l))) (disjmult f l) + | Ast.CIRCLES(l) -> + List.map (function l -> Ast.rewrap d (Ast.CIRCLES(l))) (disjmult f l) + | Ast.STARS(l) -> + List.map (function l -> Ast.rewrap d (Ast.STARS(l))) (disjmult f l) + +let rec disjty ft = + match Ast.unwrap ft with + Ast.Type(cv,ty) -> + let ty = disjtypeC ty in + List.map (function ty -> Ast.rewrap ft (Ast.Type(cv,ty))) ty + | Ast.DisjType(types) -> List.concat (List.map disjty types) + | Ast.OptType(ty) -> + let ty = disjty ty in + List.map (function ty -> Ast.rewrap ft (Ast.OptType(ty))) ty + | Ast.UniqueType(ty) -> + let ty = disjty ty in + List.map (function ty -> Ast.rewrap ft (Ast.UniqueType(ty))) ty + +and disjtypeC bty = + match Ast.unwrap bty with + Ast.BaseType(_) | Ast.SignedT(_,_) -> [bty] + | Ast.Pointer(ty,star) -> + let ty = disjty ty in + List.map (function ty -> Ast.rewrap bty (Ast.Pointer(ty,star))) ty + | Ast.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + let ty = disjty ty in + List.map + (function ty -> + Ast.rewrap bty (Ast.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2))) + ty + | Ast.FunctionType (s,ty,lp1,params,rp1) -> + let ty = disjoption disjty ty in + List.map + (function ty -> + Ast.rewrap bty (Ast.FunctionType (s,ty,lp1,params,rp1))) + ty + | Ast.Array(ty,lb,size,rb) -> + disjmult2 (disjty ty) (disjoption disjexp size) + (function ty -> function size -> + Ast.rewrap bty (Ast.Array(ty,lb,size,rb))) + | Ast.EnumName(_,_) | Ast.StructUnionName(_,_) -> [bty] + | Ast.StructUnionDef(ty,lb,decls,rb) -> + disjmult2 (disjty ty) (disjdots disjdecl decls) + (function ty -> function decls -> + Ast.rewrap bty (Ast.StructUnionDef(ty,lb,decls,rb))) + | Ast.TypeName(_) | Ast.MetaType(_,_,_) -> [bty] + +and disjexp e = + match Ast.unwrap e with + Ast.Ident(_) | Ast.Constant(_) -> [e] + | Ast.FunCall(fn,lp,args,rp) -> + disjmult2 (disjexp fn) (disjdots disjexp args) + (function fn -> function args -> + Ast.rewrap e (Ast.FunCall(fn,lp,args,rp))) + | Ast.Assignment(left,op,right,simple) -> + disjmult2 (disjexp left) (disjexp right) + (function left -> function right -> + Ast.rewrap e (Ast.Assignment(left,op,right,simple))) + | Ast.CondExpr(exp1,why,Some exp2,colon,exp3) -> + let res = disjmult disjexp [exp1;exp2;exp3] in + List.map + (function + [exp1;exp2;exp3] -> + Ast.rewrap e (Ast.CondExpr(exp1,why,Some exp2,colon,exp3)) + | _ -> failwith "not possible") + res + | Ast.CondExpr(exp1,why,None,colon,exp3) -> + disjmult2 (disjexp exp1) (disjexp exp3) + (function exp1 -> function exp3 -> + Ast.rewrap e (Ast.CondExpr(exp1,why,None,colon,exp3))) + | Ast.Postfix(exp,op) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.Postfix(exp,op))) exp + | Ast.Infix(exp,op) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.Infix(exp,op))) exp + | Ast.Unary(exp,op) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.Unary(exp,op))) exp + | Ast.Binary(left,op,right) -> + disjmult2 (disjexp left) (disjexp right) + (function left -> function right -> + Ast.rewrap e (Ast.Binary(left,op,right))) + | Ast.Nested(exp,op,right) -> + (* disj not possible in right *) + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.Nested(exp,op,right))) exp + | Ast.Paren(lp,exp,rp) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.Paren(lp,exp,rp))) exp + | Ast.ArrayAccess(exp1,lb,exp2,rb) -> + disjmult2 (disjexp exp1) (disjexp exp2) + (function exp1 -> function exp2 -> + Ast.rewrap e (Ast.ArrayAccess(exp1,lb,exp2,rb))) + | Ast.RecordAccess(exp,pt,field) -> + let exp = disjexp exp in + List.map + (function exp -> Ast.rewrap e (Ast.RecordAccess(exp,pt,field))) exp + | Ast.RecordPtAccess(exp,ar,field) -> + let exp = disjexp exp in + List.map + (function exp -> Ast.rewrap e (Ast.RecordPtAccess(exp,ar,field))) exp + | Ast.Cast(lp,ty,rp,exp) -> + disjmult2 (disjty ty) (disjexp exp) + (function ty -> function exp -> Ast.rewrap e (Ast.Cast(lp,ty,rp,exp))) + | Ast.SizeOfExpr(szf,exp) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.SizeOfExpr(szf,exp))) exp + | Ast.SizeOfType(szf,lp,ty,rp) -> + let ty = disjty ty in + List.map + (function ty -> Ast.rewrap e (Ast.SizeOfType(szf,lp,ty,rp))) ty + | Ast.TypeExp(ty) -> + let ty = disjty ty in + List.map (function ty -> Ast.rewrap e (Ast.TypeExp(ty))) ty + | Ast.MetaErr(_,_,_,_) | Ast.MetaExpr(_,_,_,_,_,_) + | Ast.MetaExprList(_,_,_,_) | Ast.EComma(_) -> [e] + | Ast.DisjExpr(exp_list) -> + List.concat (List.map disjexp exp_list) + | Ast.NestExpr(expr_dots,whencode,multi) -> + (* not sure what to do here, so ambiguities still possible *) + [e] + | Ast.Edots(dots,_) | Ast.Ecircles(dots,_) | Ast.Estars(dots,_) -> [e] + | Ast.OptExp(exp) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.OptExp(exp))) exp + | Ast.UniqueExp(exp) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap e (Ast.UniqueExp(exp))) exp + +and disjparam p = + match Ast.unwrap p with + Ast.VoidParam(ty) -> [p] (* void is the only possible value *) + | Ast.Param(ty,id) -> + let ty = disjty ty in + List.map (function ty -> Ast.rewrap p (Ast.Param(ty,id))) ty + | Ast.MetaParam(_,_,_) | Ast.MetaParamList(_,_,_,_) | Ast.PComma(_) -> [p] + | Ast.Pdots(dots) | Ast.Pcircles(dots) -> [p] + | Ast.OptParam(param) -> + let param = disjparam param in + List.map (function param -> Ast.rewrap p (Ast.OptParam(param))) param + | Ast.UniqueParam(param) -> + let param = disjparam param in + List.map (function param -> Ast.rewrap p (Ast.UniqueParam(param))) param + +and disjini i = + match Ast.unwrap i with + Ast.InitExpr(exp) -> + let exp = disjexp exp in + List.map (function exp -> Ast.rewrap i (Ast.InitExpr(exp))) exp + | Ast.InitList(lb,initlist,rb,whencode) -> + List.map + (function initlist -> + Ast.rewrap i (Ast.InitList(lb,initlist,rb,whencode))) + (disjmult disjini initlist) + | Ast.InitGccDotName(dot,name,eq,ini) -> + let ini = disjini ini in + List.map + (function ini -> Ast.rewrap i (Ast.InitGccDotName(dot,name,eq,ini))) + ini + | Ast.InitGccName(name,eq,ini) -> + let ini = disjini ini in + List.map + (function ini -> Ast.rewrap i (Ast.InitGccName(name,eq,ini))) + ini + | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> + disjmult2 (disjexp exp) (disjini ini) + (function exp -> function ini -> + Ast.rewrap i (Ast.InitGccIndex(lb,exp,rb,eq,ini))) + | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + disjmult3 (disjexp exp1) (disjexp exp2) (disjini ini) + (function exp1 -> function exp2 -> function ini -> + Ast.rewrap i (Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini))) + | Ast.IComma(comma) -> [i] + | Ast.OptIni(ini) -> + let ini = disjini ini in + List.map (function ini -> Ast.rewrap i (Ast.OptIni(ini))) ini + | Ast.UniqueIni(ini) -> + let ini = disjini ini in + List.map (function ini -> Ast.rewrap i (Ast.UniqueIni(ini))) ini + +and disjdecl d = + match Ast.unwrap d with + Ast.Init(stg,ty,id,eq,ini,sem) -> + disjmult2 (disjty ty) (disjini ini) + (function ty -> function ini -> + Ast.rewrap d (Ast.Init(stg,ty,id,eq,ini,sem))) + | Ast.UnInit(stg,ty,id,sem) -> + let ty = disjty ty in + List.map (function ty -> Ast.rewrap d (Ast.UnInit(stg,ty,id,sem))) ty + | Ast.MacroDecl(name,lp,args,rp,sem) -> + List.map + (function args -> Ast.rewrap d (Ast.MacroDecl(name,lp,args,rp,sem))) + (disjdots disjexp args) + | Ast.TyDecl(ty,sem) -> + let ty = disjty ty in + List.map (function ty -> Ast.rewrap d (Ast.TyDecl(ty,sem))) ty + | Ast.Typedef(stg,ty,id,sem) -> + let ty = disjty ty in (* disj not allowed in id *) + List.map (function ty -> Ast.rewrap d (Ast.Typedef(stg,ty,id,sem))) ty + | Ast.DisjDecl(decls) -> List.concat (List.map disjdecl decls) + | Ast.Ddots(_,_) | Ast.MetaDecl(_,_,_) -> [d] + | Ast.OptDecl(decl) -> + let decl = disjdecl decl in + List.map (function decl -> Ast.rewrap d (Ast.OptDecl(decl))) decl + | Ast.UniqueDecl(decl) -> + let decl = disjdecl decl in + List.map (function decl -> Ast.rewrap d (Ast.UniqueDecl(decl))) decl + +let generic_orify_rule_elem f re exp rebuild = + match f exp with + [exp] -> re + | orexps -> Ast.rewrap re (Ast.DisjRuleElem (List.map rebuild orexps)) + +let orify_rule_elem re exp rebuild = + generic_orify_rule_elem disjexp re exp rebuild + +let orify_rule_elem_ty = generic_orify_rule_elem disjty +let orify_rule_elem_param = generic_orify_rule_elem disjparam +let orify_rule_elem_decl = generic_orify_rule_elem disjdecl +let orify_rule_elem_ini = generic_orify_rule_elem disjini + +let disj_rule_elem r k re = + match Ast.unwrap re with + Ast.FunHeader(bef,allminus,fninfo,name,lp,params,rp) -> + generic_orify_rule_elem (disjdots disjparam) re params + (function params -> + Ast.rewrap re + (Ast.FunHeader(bef,allminus,fninfo,name,lp,params,rp))) + | Ast.Decl(bef,allminus,decl) -> + orify_rule_elem_decl re decl + (function decl -> Ast.rewrap re (Ast.Decl(bef,allminus,decl))) + | Ast.SeqStart(brace) -> re + | Ast.SeqEnd(brace) -> re + | Ast.ExprStatement(exp,sem) -> + orify_rule_elem re exp + (function exp -> Ast.rewrap re (Ast.ExprStatement(exp,sem))) + | Ast.IfHeader(iff,lp,exp,rp) -> + orify_rule_elem re exp + (function exp -> Ast.rewrap re (Ast.IfHeader(iff,lp,exp,rp))) + | Ast.Else(els) -> re + | Ast.WhileHeader(whl,lp,exp,rp) -> + orify_rule_elem re exp + (function exp -> Ast.rewrap re (Ast.WhileHeader(whl,lp,exp,rp))) + | Ast.DoHeader(d) -> re + | Ast.WhileTail(whl,lp,exp,rp,sem) -> + orify_rule_elem re exp + (function exp -> Ast.rewrap re (Ast.WhileTail(whl,lp,exp,rp,sem))) + | Ast.ForHeader(fr,lp,e1,sem1,e2,sem2,e3,rp) -> + generic_orify_rule_elem (disjmult (disjoption disjexp)) re [e1;e2;e3] + (function + [exp1;exp2;exp3] -> + Ast.rewrap re (Ast.ForHeader(fr,lp,exp1,sem1,exp2,sem2,exp3,rp)) + | _ -> failwith "not possible") + | Ast.IteratorHeader(whl,lp,args,rp) -> + generic_orify_rule_elem (disjdots disjexp) re args + (function args -> Ast.rewrap re (Ast.IteratorHeader(whl,lp,args,rp))) + | Ast.SwitchHeader(switch,lp,exp,rp) -> + orify_rule_elem re exp + (function exp -> Ast.rewrap re (Ast.SwitchHeader(switch,lp,exp,rp))) + | Ast.Break(_,_) | Ast.Continue(_,_) | Ast.Label(_,_) | Ast.Goto(_,_,_) + | Ast.Return(_,_) -> re + | Ast.ReturnExpr(ret,exp,sem) -> + orify_rule_elem re exp + (function exp -> Ast.rewrap re (Ast.ReturnExpr(ret,exp,sem))) + | Ast.MetaRuleElem(_,_,_) | Ast.MetaStmt(_,_,_,_) + | Ast.MetaStmtList(_,_,_) -> re + | Ast.Exp(exp) -> + orify_rule_elem re exp (function exp -> Ast.rewrap exp (Ast.Exp(exp))) + | Ast.TopExp(exp) -> + orify_rule_elem re exp (function exp -> Ast.rewrap exp (Ast.TopExp(exp))) + | Ast.Ty(ty) -> + orify_rule_elem_ty re ty (function ty -> Ast.rewrap ty (Ast.Ty(ty))) + | Ast.TopInit(init) -> + orify_rule_elem_ini re init + (function init -> Ast.rewrap init (Ast.TopInit(init))) + | Ast.Include(inc,s) -> re + | Ast.DefineHeader(def,id,params) -> re + | Ast.Default(def,colon) -> re + | Ast.Case(case,exp,colon) -> + orify_rule_elem re exp + (function exp -> Ast.rewrap re (Ast.Case(case,exp,colon))) + | Ast.DisjRuleElem(_) -> failwith "not possible" + +let disj_all = + let mcode x = x in + let donothing r k e = k e in + V.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing donothing + disj_rule_elem donothing donothing donothing donothing + +(* ----------------------------------------------------------------------- *) +(* collect iso information at the rule_elem level *) + +let collect_all_isos = + let bind = (@) in + let option_default = [] in + let mcode r x = [] in + let donothing r k e = Common.union_set (Ast.get_isos e) (k e) in + let doanything r k e = k e in + V.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing donothing + donothing doanything + +let collect_iso_info = + let mcode x = x in + let donothing r k e = k e in + let rule_elem r k e = + match Ast.unwrap e with + Ast.DisjRuleElem(l) -> k e + | _ -> + let isos = collect_all_isos.V.combiner_rule_elem e in + Ast.set_isos e isos in + V.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing rule_elem donothing donothing + donothing donothing + +(* ----------------------------------------------------------------------- *) + +let disj rules = + List.map + (function (mv,r) -> + match r with + Ast.ScriptRule _ -> (mv, r) + | Ast.CocciRule (nm, rule_info, r, isexp, ruletype) -> + let res = + List.map + (function x -> + let res = disj_all.V.rebuilder_top_level x in + if !Flag.track_iso_usage + then collect_iso_info.V.rebuilder_top_level res + else res) + r in + (mv, Ast.CocciRule (nm,rule_info,res,isexp,ruletype))) + rules diff --git a/parsing_cocci/.#free_vars.ml.1.83 b/parsing_cocci/.#free_vars.ml.1.83 new file mode 100644 index 0000000..dabf51c --- /dev/null +++ b/parsing_cocci/.#free_vars.ml.1.83 @@ -0,0 +1,787 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* For each rule return the list of variables that are used after it. +Also augment various parts of each rule with unitary, inherited, and freshness +informations *) + +module Ast = Ast_cocci +module V = Visitor_ast +module TC = Type_cocci + +let rec nub = function + [] -> [] + | (x::xs) when (List.mem x xs) -> nub xs + | (x::xs) -> x::(nub xs) + +(* Collect all variable references in a minirule. For a disj, we collect +the maximum number (2 is enough) of references in any branch. *) + +let collect_unitary_nonunitary free_usage = + let free_usage = List.sort compare free_usage in + let rec loop1 todrop = function (* skips multiple occurrences *) + [] -> [] + | (x::xs) as all -> if x = todrop then loop1 todrop xs else all in + let rec loop2 = function + [] -> ([],[]) + | [x] -> ([x],[]) + | x::y::xs -> + if x = y (* occurs more than once in free_usage *) + then + let (unitary,non_unitary) = loop2(loop1 x xs) in + (unitary,x::non_unitary) + else (* occurs only once in free_usage *) + let (unitary,non_unitary) = loop2 (y::xs) in + (x::unitary,non_unitary) in + loop2 free_usage + +let collect_refs include_constraints = + let bind x y = x @ y in + let option_default = [] in + + let donothing recursor k e = k e in (* just combine in the normal way *) + + let donothing_a recursor k e = (* anything is not wrapped *) + k e in (* just combine in the normal way *) + + (* the following considers that anything that occurs non-unitarily in one + branch occurs nonunitarily in all branches. This is not optimal, but + doing better seems to require a breadth-first traversal, which is + perhaps better to avoid. Also, unitarily is represented as occuring once, + while nonunitarily is represented as twice - more is irrelevant *) + (* cases for disjs and metavars *) + let bind_disj refs_branches = + let (unitary,nonunitary) = + List.split (List.map collect_unitary_nonunitary refs_branches) in + let unitary = nub (List.concat unitary) in + let nonunitary = nub (List.concat nonunitary) in + let unitary = + List.filter (function x -> not (List.mem x nonunitary)) unitary in + unitary@nonunitary@nonunitary in + + let metaid (x,_,_,_) = x in + + let astfvident recursor k i = + bind (k i) + (match Ast.unwrap i with + Ast.MetaId(name,_,_,_) | Ast.MetaFunc(name,_,_,_) + | Ast.MetaLocalFunc(name,_,_,_) -> [metaid name] + | _ -> option_default) in + + let rec type_collect res = function + TC.ConstVol(_,ty) | TC.Pointer(ty) | TC.FunctionPointer(ty) + | TC.Array(ty) -> type_collect res ty + | TC.MetaType(tyname,_,_) -> bind [tyname] res + | TC.SignedT(_,Some ty) -> type_collect res ty + | ty -> res in + + let astfvexpr recursor k e = + bind (k e) + (match Ast.unwrap e with + Ast.MetaExpr(name,_,_,Some type_list,_,_) -> + let types = List.fold_left type_collect option_default type_list in + bind [metaid name] types + | Ast.MetaErr(name,_,_,_) | Ast.MetaExpr(name,_,_,_,_,_) -> [metaid name] + | Ast.MetaExprList(name,None,_,_) -> [metaid name] + | Ast.MetaExprList(name,Some (lenname,_,_),_,_) -> + [metaid name;metaid lenname] + | Ast.DisjExpr(exps) -> bind_disj (List.map k exps) + | _ -> option_default) in + + let astfvdecls recursor k d = + bind (k d) + (match Ast.unwrap d with + Ast.DisjDecl(decls) -> bind_disj (List.map k decls) + | _ -> option_default) in + + let astfvfullType recursor k ty = + bind (k ty) + (match Ast.unwrap ty with + Ast.DisjType(types) -> bind_disj (List.map k types) + | _ -> option_default) in + + let astfvtypeC recursor k ty = + bind (k ty) + (match Ast.unwrap ty with + Ast.MetaType(name,_,_) -> [metaid name] + | _ -> option_default) in + + let astfvparam recursor k p = + bind (k p) + (match Ast.unwrap p with + Ast.MetaParam(name,_,_) -> [metaid name] + | Ast.MetaParamList(name,None,_,_) -> [metaid name] + | Ast.MetaParamList(name,Some(lenname,_,_),_,_) -> + [metaid name;metaid lenname] + | _ -> option_default) in + + let astfvrule_elem recursor k re = + (*within a rule_elem, pattern3 manages the coherence of the bindings*) + bind (k re) + (nub + (match Ast.unwrap re with + Ast.MetaRuleElem(name,_,_) | Ast.MetaStmt(name,_,_,_) + | Ast.MetaStmtList(name,_,_) -> [metaid name] + | _ -> option_default)) in + + let astfvstatement recursor k s = + bind (k s) + (match Ast.unwrap s with + Ast.Disj(stms) -> + bind_disj (List.map recursor.V.combiner_statement_dots stms) + | _ -> option_default) in + + let mcode r mc = + if include_constraints + then + match Ast.get_pos_var mc with + Ast.MetaPos(name,constraints,_,_,_) -> (metaid name)::constraints + | _ -> option_default + else option_default in + + V.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + astfvident astfvexpr astfvfullType astfvtypeC donothing astfvparam + astfvdecls astfvrule_elem astfvstatement donothing donothing donothing_a + +let collect_all_refs = collect_refs true +let collect_non_constraint_refs = collect_refs false + +let collect_all_rule_refs minirules = + List.fold_left (@) [] + (List.map collect_all_refs.V.combiner_top_level minirules) + +let collect_all_minirule_refs = collect_all_refs.V.combiner_top_level + +(* ---------------------------------------------------------------- *) + +let collect_saved = + let bind = Common.union_set in + let option_default = [] in + + let donothing recursor k e = k e in (* just combine in the normal way *) + + let metaid (x,_,_,_) = x in + + (* cases for metavariables *) + let astfvident recursor k i = + bind (k i) + (match Ast.unwrap i with + Ast.MetaId(name,_,TC.Saved,_) | Ast.MetaFunc(name,_,TC.Saved,_) + | Ast.MetaLocalFunc(name,_,TC.Saved,_) -> [metaid name] + | _ -> option_default) in + + let rec type_collect res = function + TC.ConstVol(_,ty) | TC.Pointer(ty) | TC.FunctionPointer(ty) + | TC.Array(ty) -> type_collect res ty + | TC.MetaType(tyname,TC.Saved,_) -> bind [tyname] res + | TC.SignedT(_,Some ty) -> type_collect res ty + | ty -> res in + + let astfvexpr recursor k e = + let tymetas = + match Ast.unwrap e with + Ast.MetaExpr(name,_,_,Some type_list,_,_) -> + List.fold_left type_collect option_default type_list + | _ -> [] in + let vars = + bind (k e) + (match Ast.unwrap e with + Ast.MetaErr(name,_,TC.Saved,_) | Ast.MetaExpr(name,_,TC.Saved,_,_,_) + | Ast.MetaExprList(name,None,TC.Saved,_) -> [metaid name] + | Ast.MetaExprList(name,Some (lenname,ls,_),ns,_) -> + let namesaved = + match ns with TC.Saved -> [metaid name] | _ -> [] in + let lensaved = + match ls with TC.Saved -> [metaid lenname] | _ -> [] in + lensaved @ namesaved + | _ -> option_default) in + bind tymetas vars in + + let astfvtypeC recursor k ty = + bind (k ty) + (match Ast.unwrap ty with + Ast.MetaType(name,TC.Saved,_) -> [metaid name] + | _ -> option_default) in + + let astfvparam recursor k p = + bind (k p) + (match Ast.unwrap p with + Ast.MetaParam(name,TC.Saved,_) + | Ast.MetaParamList(name,None,_,_) -> [metaid name] + | Ast.MetaParamList(name,Some (lenname,ls,_),ns,_) -> + let namesaved = + match ns with TC.Saved -> [metaid name] | _ -> [] in + let lensaved = + match ls with TC.Saved -> [metaid lenname] | _ -> [] in + lensaved @ namesaved + | _ -> option_default) in + + let astfvrule_elem recursor k re = + (*within a rule_elem, pattern3 manages the coherence of the bindings*) + bind (k re) + (nub + (match Ast.unwrap re with + Ast.MetaRuleElem(name,TC.Saved,_) | Ast.MetaStmt(name,TC.Saved,_,_) + | Ast.MetaStmtList(name,TC.Saved,_) -> [metaid name] + | _ -> option_default)) in + + let mcode r e = + match Ast.get_pos_var e with + Ast.MetaPos(name,_,_,TC.Saved,_) -> [metaid name] + | _ -> option_default in + + V.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + astfvident astfvexpr donothing astfvtypeC donothing astfvparam + donothing astfvrule_elem donothing donothing donothing donothing + +(* ---------------------------------------------------------------- *) + +(* For the rules under a given metavariable declaration, collect all of the +variables that occur in the plus code *) + +let cip_mcodekind r mck = + let process_anything_list_list anythings = + let astfvs = collect_all_refs.V.combiner_anything in + List.fold_left (@) [] + (List.map (function l -> List.fold_left (@) [] (List.map astfvs l)) + anythings) in + match mck with + Ast.MINUS(_,anythings) -> process_anything_list_list anythings + | Ast.CONTEXT(_,befaft) -> + (match befaft with + Ast.BEFORE(ll) -> process_anything_list_list ll + | Ast.AFTER(ll) -> process_anything_list_list ll + | Ast.BEFOREAFTER(llb,lla) -> + (process_anything_list_list lla) @ + (process_anything_list_list llb) + | Ast.NOTHING -> []) + | Ast.PLUS -> [] + +let collect_in_plus_term = + let bind x y = x @ y in + let option_default = [] in + let donothing r k e = k e in + + (* no positions in the + code *) + let mcode r (_,_,mck,_) = cip_mcodekind r mck in + + (* case for things with bef/aft mcode *) + + let astfvrule_elem recursor k re = + match Ast.unwrap re with + Ast.FunHeader(bef,_,fi,nm,_,params,_) -> + let fi_metas = + List.concat + (List.map + (function + Ast.FType(ty) -> collect_all_refs.V.combiner_fullType ty + | _ -> []) + fi) in + let nm_metas = collect_all_refs.V.combiner_ident nm in + let param_metas = + match Ast.unwrap params with + Ast.DOTS(params) | Ast.CIRCLES(params) -> + List.concat + (List.map + (function p -> + match Ast.unwrap p with + Ast.VoidParam(t) | Ast.Param(t,_) -> + collect_all_refs.V.combiner_fullType t + | _ -> []) + params) + | _ -> failwith "not allowed for params" in + bind fi_metas + (bind nm_metas + (bind param_metas + (bind (cip_mcodekind recursor bef) (k re)))) + | Ast.Decl(bef,_,_) -> + bind (cip_mcodekind recursor bef) (k re) + | _ -> k re in + + let astfvstatement recursor k s = + match Ast.unwrap s with + Ast.IfThen(_,_,(_,_,_,aft)) | Ast.IfThenElse(_,_,_,_,(_,_,_,aft)) + | Ast.While(_,_,(_,_,_,aft)) | Ast.For(_,_,(_,_,_,aft)) + | Ast.Iterator(_,_,(_,_,_,aft)) -> + bind (k s) (cip_mcodekind recursor aft) + | _ -> k s in + + V.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing + donothing astfvrule_elem astfvstatement donothing donothing donothing + +let collect_in_plus minirules = + nub + (List.concat + (List.map collect_in_plus_term.V.combiner_top_level minirules)) + +(* ---------------------------------------------------------------- *) + +(* For the rules under a given metavariable declaration, collect all of the +variables that occur only once and more than once in the minus code *) + +let collect_all_multirefs minirules = + let refs = List.map collect_all_refs.V.combiner_top_level minirules in + collect_unitary_nonunitary (List.concat refs) + +(* ---------------------------------------------------------------- *) + +(* classify as unitary (no binding) or nonunitary (env binding) or saved +(witness binding) *) + +let classify_variables metavars minirules used_after = + let metavars = List.map Ast.get_meta_name metavars in + let (unitary,nonunitary) = collect_all_multirefs minirules in + let inplus = collect_in_plus minirules in + + let donothing r k e = k e in + let check_unitary name inherited = + if List.mem name inplus or List.mem name used_after + then TC.Saved + else if not inherited && List.mem name unitary + then TC.Unitary + else TC.Nonunitary in + + let get_option f = function Some x -> Some (f x) | None -> None in + + let classify (name,_,_,_) = + let inherited = not (List.mem name metavars) in + (check_unitary name inherited,inherited) in + + let mcode mc = + match Ast.get_pos_var mc with + Ast.MetaPos(name,constraints,per,unitary,inherited) -> + let (unitary,inherited) = classify name in + Ast.set_pos_var (Ast.MetaPos(name,constraints,per,unitary,inherited)) + mc + | _ -> mc in + + let ident r k e = + let e = k e in + match Ast.unwrap e with + Ast.MetaId(name,constraints,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaId(name,constraints,unitary,inherited)) + | Ast.MetaFunc(name,constraints,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaFunc(name,constraints,unitary,inherited)) + | Ast.MetaLocalFunc(name,constraints,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaLocalFunc(name,constraints,unitary,inherited)) + | _ -> e in + + let rec type_infos = function + TC.ConstVol(cv,ty) -> TC.ConstVol(cv,type_infos ty) + | TC.Pointer(ty) -> TC.Pointer(type_infos ty) + | TC.FunctionPointer(ty) -> TC.FunctionPointer(type_infos ty) + | TC.Array(ty) -> TC.Array(type_infos ty) + | TC.MetaType(name,_,_) -> + let (unitary,inherited) = classify (name,(),(),Ast.NoMetaPos) in + Type_cocci.MetaType(name,unitary,inherited) + | TC.SignedT(sgn,Some ty) -> TC.SignedT(sgn,Some (type_infos ty)) + | ty -> ty in + + let expression r k e = + let e = k e in + match Ast.unwrap e with + Ast.MetaErr(name,constraints,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaErr(name,constraints,unitary,inherited)) + | Ast.MetaExpr(name,constraints,_,ty,form,_) -> + let (unitary,inherited) = classify name in + let ty = get_option (List.map type_infos) ty in + Ast.rewrap e (Ast.MetaExpr(name,constraints,unitary,ty,form,inherited)) + | Ast.MetaExprList(name,None,_,_) -> + (* lenname should have the same properties of being unitary or + inherited as name *) + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaExprList(name,None,unitary,inherited)) + | Ast.MetaExprList(name,Some(lenname,_,_),_,_) -> + (* lenname should have the same properties of being unitary or + inherited as name *) + let (unitary,inherited) = classify name in + let (lenunitary,leninherited) = classify lenname in + Ast.rewrap e + (Ast.MetaExprList + (name,Some(lenname,lenunitary,leninherited),unitary,inherited)) + | _ -> e in + + let typeC r k e = + let e = k e in + match Ast.unwrap e with + Ast.MetaType(name,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaType(name,unitary,inherited)) + | _ -> e in + + let param r k e = + let e = k e in + match Ast.unwrap e with + Ast.MetaParam(name,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaParam(name,unitary,inherited)) + | Ast.MetaParamList(name,None,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaParamList(name,None,unitary,inherited)) + | Ast.MetaParamList(name,Some (lenname,_,_),_,_) -> + let (unitary,inherited) = classify name in + let (lenunitary,leninherited) = classify lenname in + Ast.rewrap e + (Ast.MetaParamList + (name,Some (lenname,lenunitary,leninherited),unitary,inherited)) + | _ -> e in + + let rule_elem r k e = + let e = k e in + match Ast.unwrap e with + Ast.MetaStmt(name,_,msi,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaStmt(name,unitary,msi,inherited)) + | Ast.MetaStmtList(name,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaStmtList(name,unitary,inherited)) + | _ -> e in + + let fn = V.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + ident expression donothing typeC donothing param donothing rule_elem + donothing donothing donothing donothing in + + List.map fn.V.rebuilder_top_level minirules + +(* ---------------------------------------------------------------- *) + +(* For a minirule, collect the set of non-local (not in "bound") variables that +are referenced. Store them in a hash table. *) + +(* bound means the metavariable was declared previously, not locally *) + +(* Highly inefficient, because we call collect_all_refs on nested code +multiple times. But we get the advantage of not having too many variants +of the same functions. *) + +(* Inherited doesn't include position constraints. If they are not bound +then there is no constraint. *) + +let astfvs metavars bound = + let fresh = + List.fold_left + (function prev -> + function + Ast.MetaFreshIdDecl(_,_) as x -> (Ast.get_meta_name x)::prev + | _ -> prev) + [] metavars in + + let collect_fresh = List.filter (function x -> List.mem x fresh) in + + (* cases for the elements of anything *) + let astfvrule_elem recursor k re = + let minus_free = nub (collect_all_refs.V.combiner_rule_elem re) in + let minus_nc_free = + nub (collect_non_constraint_refs.V.combiner_rule_elem re) in + let plus_free = collect_in_plus_term.V.combiner_rule_elem re in + let free = Common.union_set minus_free plus_free in + let nc_free = Common.union_set minus_nc_free plus_free in + let unbound = + List.filter (function x -> not(List.mem x bound)) free in + let inherited = + List.filter (function x -> List.mem x bound) nc_free in + let munbound = + List.filter (function x -> not(List.mem x bound)) minus_free in + {(k re) with + Ast.free_vars = unbound; + Ast.minus_free_vars = munbound; + Ast.fresh_vars = collect_fresh unbound; + Ast.inherited = inherited; + Ast.saved_witness = []} in + + let astfvstatement recursor k s = + let minus_free = nub (collect_all_refs.V.combiner_statement s) in + let minus_nc_free = + nub (collect_non_constraint_refs.V.combiner_statement s) in + let plus_free = collect_in_plus_term.V.combiner_statement s in + let free = Common.union_set minus_free plus_free in + let nc_free = Common.union_set minus_nc_free plus_free in + let classify free minus_free = + let (unbound,inherited) = + List.partition (function x -> not(List.mem x bound)) free in + let munbound = + List.filter (function x -> not(List.mem x bound)) minus_free in + (unbound,munbound,collect_fresh unbound,inherited) in + let res = k s in + let s = + match Ast.unwrap res with + Ast.IfThen(header,branch,(_,_,_,aft)) -> + let (unbound,_,fresh,inherited) = + classify (cip_mcodekind collect_in_plus_term aft) [] in + Ast.IfThen(header,branch,(unbound,fresh,inherited,aft)) + | Ast.IfThenElse(header,branch1,els,branch2,(_,_,_,aft)) -> + let (unbound,_,fresh,inherited) = + classify (cip_mcodekind collect_in_plus_term aft) [] in + Ast.IfThenElse(header,branch1,els,branch2, + (unbound,fresh,inherited,aft)) + | Ast.While(header,body,(_,_,_,aft)) -> + let (unbound,_,fresh,inherited) = + classify (cip_mcodekind collect_in_plus_term aft) [] in + Ast.While(header,body,(unbound,fresh,inherited,aft)) + | Ast.For(header,body,(_,_,_,aft)) -> + let (unbound,_,fresh,inherited) = + classify (cip_mcodekind collect_in_plus_term aft) [] in + Ast.For(header,body,(unbound,fresh,inherited,aft)) + | Ast.Iterator(header,body,(_,_,_,aft)) -> + let (unbound,_,fresh,inherited) = + classify (cip_mcodekind collect_in_plus_term aft) [] in + Ast.Iterator(header,body,(unbound,fresh,inherited,aft)) + | s -> s in + + let (unbound,munbound,fresh,_) = classify free minus_free in + let inherited = + List.filter (function x -> List.mem x bound) nc_free in + {res with + Ast.node = s; + Ast.free_vars = unbound; + Ast.minus_free_vars = munbound; + Ast.fresh_vars = collect_fresh unbound; + Ast.inherited = inherited; + Ast.saved_witness = []} in + + let astfvstatement_dots recursor k sd = + let minus_free = nub (collect_all_refs.V.combiner_statement_dots sd) in + let minus_nc_free = + nub (collect_non_constraint_refs.V.combiner_statement_dots sd) in + let plus_free = collect_in_plus_term.V.combiner_statement_dots sd in + let free = Common.union_set minus_free plus_free in + let nc_free = Common.union_set minus_nc_free plus_free in + let unbound = + List.filter (function x -> not(List.mem x bound)) free in + let inherited = + List.filter (function x -> List.mem x bound) nc_free in + let munbound = + List.filter (function x -> not(List.mem x bound)) minus_free in + {(k sd) with + Ast.free_vars = unbound; + Ast.minus_free_vars = munbound; + Ast.fresh_vars = collect_fresh unbound; + Ast.inherited = inherited; + Ast.saved_witness = []} in + + let astfvtoplevel recursor k tl = + let saved = collect_saved.V.combiner_top_level tl in + {(k tl) with Ast.saved_witness = saved} in + + let mcode x = x in + let donothing r k e = k e in + + V.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing astfvstatement_dots donothing + donothing donothing donothing donothing donothing donothing donothing + astfvrule_elem astfvstatement donothing astfvtoplevel donothing + +(* +let collect_astfvs rules = + let rec loop bound = function + [] -> [] + | (metavars,(nm,rule_info,minirules))::rules -> + let bound = + Common.minus_set bound (List.map Ast.get_meta_name metavars) in + (nm,rule_info, + (List.map (astfvs metavars bound).V.rebuilder_top_level minirules)):: + (loop ((List.map Ast.get_meta_name metavars)@bound) rules) in + loop [] rules +*) + +let collect_astfvs rules = + let rec loop bound = function + [] -> [] + | (metavars, rule)::rules -> + match rule with + Ast.ScriptRule (_,_,_,_) -> + (* bound stays as is because script rules have no names, so no + inheritance is possible *) + rule::(loop bound rules) + | Ast.CocciRule (nm, rule_info, minirules, isexp, ruletype) -> + let bound = + Common.minus_set bound (List.map Ast.get_meta_name metavars) in + (Ast.CocciRule + (nm, rule_info, + (List.map (astfvs metavars bound).V.rebuilder_top_level + minirules), + isexp, ruletype)):: + (loop ((List.map Ast.get_meta_name metavars)@bound) rules) in + loop [] rules + +(* ---------------------------------------------------------------- *) +(* position variables that appear as a constraint on another position variable. +a position variable also cannot appear both positively and negatively in a +single rule. *) + +let get_neg_pos_list (_,rule) used_after_list = + let donothing r k e = k e in + let bind (p1,np1) (p2,np2) = + (Common.union_set p1 p2, Common.union_set np1 np2) in + let option_default = ([],[]) in + let metaid (x,_,_,_) = x in + let mcode r mc = + match Ast.get_pos_var mc with + Ast.MetaPos(name,constraints,Ast.PER,_,_) -> + ([metaid name],constraints) + | Ast.MetaPos(name,constraints,Ast.ALL,_,_) -> + ([],(metaid name)::constraints) + | _ -> option_default in + let v = + V.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing in + match rule with + Ast.CocciRule(_,_,minirules,_,_) -> + List.map + (function toplevel -> + let (positions,neg_positions) = v.V.combiner_top_level toplevel in + (if List.exists (function p -> List.mem p neg_positions) positions + then + failwith + "a variable cannot be used both as a position and a constraint"); + neg_positions) + minirules + | Ast.ScriptRule _ -> [] (*no negated positions*) + +(* ---------------------------------------------------------------- *) + +(* collect used after lists, per minirule *) + +(* defined is a list of variables that were declared in a previous metavar +declaration *) + +(* Top-level used after: For each rule collect the set of variables that +are inherited, ie used but not defined. These are accumulated back to +their point of definition. *) + + +let collect_top_level_used_after metavar_rule_list = + let (used_after,used_after_lists) = + List.fold_right + (function (metavar_list,r) -> + function (used_after,used_after_lists) -> + let locally_defined = List.map Ast.get_meta_name metavar_list in + let continue_propagation = + List.filter (function x -> not(List.mem x locally_defined)) + used_after in + let free_vars = + match r with + Ast.ScriptRule (_,_,mv,_) -> + List.map (function (_,(r,v)) -> (r,v)) mv + | Ast.CocciRule (_,_,rule,_,_) -> + Common.union_set (nub (collect_all_rule_refs rule)) + (collect_in_plus rule) in + let inherited = + List.filter (function x -> not (List.mem x locally_defined)) + free_vars in + (Common.union_set inherited continue_propagation, + used_after::used_after_lists)) + metavar_rule_list ([],[]) in + match used_after with + [] -> used_after_lists + | _ -> + failwith + (Printf.sprintf "collect_top_level_used_after: unbound variables %s" + (String.concat " " (List.map (function (_,x) -> x) used_after))) + +let collect_local_used_after metavars minirules used_after = + let locally_defined = List.map Ast.get_meta_name metavars in + let rec loop defined = function + [] -> (used_after,[],[]) + | minirule::rest -> + let free_vars = + Common.union_set + (nub (collect_all_minirule_refs minirule)) + (collect_in_plus_term.V.combiner_top_level minirule) in + let local_free_vars = + List.filter (function x -> List.mem x locally_defined) free_vars in + let new_defined = Common.union_set local_free_vars defined in + let (mini_used_after,fvs_lists,mini_used_after_lists) = + loop new_defined rest in + let local_used = Common.union_set local_free_vars mini_used_after in + let (new_used_after,new_list) = + List.partition (function x -> List.mem x defined) mini_used_after in + let new_used_after = Common.union_set local_used new_used_after in + (new_used_after,free_vars::fvs_lists, + new_list::mini_used_after_lists) in + let (_,fvs_lists,used_after_lists) = loop [] minirules in + (fvs_lists,used_after_lists) + + +let collect_used_after metavar_rule_list = + let used_after_lists = collect_top_level_used_after metavar_rule_list in + List.map2 + (function (metavars,r) -> + function used_after -> + match r with + Ast.ScriptRule (_,_,mv,_) -> ([], [used_after]) + | Ast.CocciRule (name, rule_info, minirules, _,_) -> + collect_local_used_after metavars minirules used_after + ) + metavar_rule_list used_after_lists + +(* ---------------------------------------------------------------- *) +(* entry point *) + +let free_vars rules = + let metavars = List.map (function (mv,rule) -> mv) rules in + let (fvs_lists,used_after_lists) = List.split (collect_used_after rules) in + let neg_pos_lists = List.map2 get_neg_pos_list rules used_after_lists in + let positions_list = (* for all rules, assume all positions are used after *) + List.map + (function (mv, r) -> + match r with + Ast.ScriptRule _ -> [] + | Ast.CocciRule (_,_,rule,_,_) -> + let positions = + List.fold_left + (function prev -> + function Ast.MetaPosDecl(_,nm) -> nm::prev | _ -> prev) + [] mv in + List.map (function _ -> positions) rule) + rules in + let new_rules = + List.map2 + (function (mv,r) -> + function ua -> + match r with + Ast.ScriptRule _ -> r + | Ast.CocciRule (nm, rule_info, r, is_exp,ruletype) -> + Ast.CocciRule + (nm, rule_info, classify_variables mv r (List.concat ua), + is_exp,ruletype)) + rules used_after_lists in + let new_rules = collect_astfvs (List.combine metavars new_rules) in + (metavars,new_rules, + fvs_lists,neg_pos_lists,used_after_lists,positions_list) diff --git a/parsing_cocci/.#index.ml.1.59 b/parsing_cocci/.#index.ml.1.59 new file mode 100644 index 0000000..2f3752c --- /dev/null +++ b/parsing_cocci/.#index.ml.1.59 @@ -0,0 +1,222 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* create an index for each constructor *) +(* current max is 147 *) + +(* doesn't really work - requires that identical terms with no token +subterms (eg dots) not appear on the same line *) + +module Ast = Ast_cocci +module Ast0 = Ast0_cocci + +(* if a dot list is empty, add the starting line of the dot list to the +address. Otherwise add 0. An empty dot list should only match with another +empty one. *) +let expression_dots d = + let ln = (Ast0.get_info d).Ast0.line_start in + match Ast0.unwrap d with + Ast0.DOTS(l) -> 1::(if l = [] then [ln] else [0]) + | Ast0.CIRCLES(l) -> 2::(if l = [] then [ln] else [0]) + | Ast0.STARS(l) -> 3::(if l = [] then [ln] else [0]) + +let initialiser_dots d = + let ln = (Ast0.get_info d).Ast0.line_start in + match Ast0.unwrap d with + Ast0.DOTS(l) -> 113::(if l = [] then [ln] else [0]) + | Ast0.CIRCLES(l) -> 114::(if l = [] then [ln] else [0]) + | Ast0.STARS(l) -> 115::(if l = [] then [ln] else [0]) + +let parameter_dots d = + let ln = (Ast0.get_info d).Ast0.line_start in + match Ast0.unwrap d with + Ast0.DOTS(l) -> 4::(if l = [] then [ln] else [0]) + | Ast0.CIRCLES(l) -> 5::(if l = [] then [ln] else [0]) + | Ast0.STARS(l) -> 6::(if l = [] then [ln] else [0]) + +let statement_dots d = + let ln = (Ast0.get_info d).Ast0.line_start in + match Ast0.unwrap d with + Ast0.DOTS(l) -> 7::(if l = [] then [ln] else [0]) + | Ast0.CIRCLES(l) -> 8::(if l = [] then [ln] else [0]) + | Ast0.STARS(l) -> 9::(if l = [] then [ln] else [0]) + +let declaration_dots d = + let ln = (Ast0.get_info d).Ast0.line_start in + match Ast0.unwrap d with + Ast0.DOTS(l) -> 134::(if l = [] then [ln] else [0]) + | Ast0.CIRCLES(l) -> 135::(if l = [] then [ln] else [0]) + | Ast0.STARS(l) -> 136::(if l = [] then [ln] else [0]) + +let case_line_dots d = + let ln = (Ast0.get_info d).Ast0.line_start in + match Ast0.unwrap d with + Ast0.DOTS(l) -> 138::(if l = [] then [ln] else [0]) + | Ast0.CIRCLES(l) -> 139::(if l = [] then [ln] else [0]) + | Ast0.STARS(l) -> 140::(if l = [] then [ln] else [0]) + +let ident i = + match Ast0.unwrap i with + Ast0.Id(name) -> [10] + | Ast0.MetaId(name,_,_) -> [11] + | Ast0.MetaFunc(name,_,_) -> [12] + | Ast0.MetaLocalFunc(name,_,_) -> [13] + | Ast0.OptIdent(id) -> [14] + | Ast0.UniqueIdent(id) -> [15] + +let expression e = + match Ast0.unwrap e with + Ast0.Ident(id) -> [17] + | Ast0.Constant(const) -> [18] + | Ast0.FunCall(fn,lp,args,rp) -> [19] + | Ast0.Assignment(left,op,right,simple) -> [20] + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> [21] + | Ast0.Postfix(exp,op) -> [22] + | Ast0.Infix(exp,op) -> [23] + | Ast0.Unary(exp,op) -> [24] + | Ast0.Binary(left,op,right) -> [25] + | Ast0.Nested(left,op,right) -> failwith "nested in index not possible" + | Ast0.Paren(lp,exp,rp) -> [26] + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> [27] + | Ast0.RecordAccess(exp,pt,field) -> [28] + | Ast0.RecordPtAccess(exp,ar,field) -> [29] + | Ast0.Cast(lp,ty,rp,exp) -> [30] + | Ast0.SizeOfExpr(szf,exp) -> [98] (* added after *) + | Ast0.SizeOfType(szf,lp,ty,rp) -> [99] (* added after *) + | Ast0.TypeExp(ty) -> [123] (* added after *) + | Ast0.MetaErr(name,_,_) -> [32] + | Ast0.MetaExpr(name,_,ty,_,_) -> [33] + | Ast0.MetaExprList(name,_,_) -> [34] + | Ast0.EComma(cm) -> [35] + | Ast0.DisjExpr(_,expr_list,_,_) -> [36] + | Ast0.NestExpr(_,expr_dots,_,_,_) -> [37] + | Ast0.Edots(dots,whencode) -> [38] + | Ast0.Ecircles(dots,whencode) -> [39] + | Ast0.Estars(dots,whencode) -> [40] + | Ast0.OptExp(exp) -> [41] + | Ast0.UniqueExp(exp) -> [42] + +let typeC t = + match Ast0.unwrap t with + Ast0.ConstVol(cv,ty) -> [44] + | Ast0.BaseType(ty,strings) -> [48] + | Ast0.Signed(sign,ty) -> [129] + | Ast0.Pointer(ty,star) -> [49] + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> [131] + | Ast0.FunctionType(ty,lp1,params,rp1) -> [132] + | Ast0.Array(ty,lb,size,rb) -> [50] + | Ast0.EnumName(kind,name) -> [146] + | Ast0.StructUnionName(kind,name) -> [51] + | Ast0.StructUnionDef(ty,lb,decls,rb) -> [117] + | Ast0.TypeName(name) -> [52] + | Ast0.MetaType(name,_) -> [53] + | Ast0.DisjType(_,type_list,_,_) -> [130] + | Ast0.OptType(ty) -> [45] + | Ast0.UniqueType(ty) -> [46] + +let declaration d = + match Ast0.unwrap d with + Ast0.Init(stg,ty,id,eq,exp,sem) -> [54] + | Ast0.UnInit(stg,ty,id,sem) -> [55] + | Ast0.MacroDecl(name,lp,args,rp,sem) -> [137] + | Ast0.TyDecl(ty,sem) -> [116] + | Ast0.Typedef(stg,ty,id,sem) -> [143] + | Ast0.DisjDecl(_,decls,_,_) -> [97] (* added after *) + | Ast0.Ddots(dots,whencode) -> [133] + | Ast0.OptDecl(decl) -> [56] + | Ast0.UniqueDecl(decl) -> [57] + +let initialiser i = + match Ast0.unwrap i with + Ast0.InitExpr(exp) -> [102] (* added after *) + | Ast0.InitList(lb,initlist,rb) -> [103] + | Ast0.InitGccDotName(dot,name,eq,ini) -> [104] + | Ast0.InitGccName(name,eq,ini) -> [105] + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> [106] + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> [107] + | Ast0.IComma(cm) -> [108] + | Ast0.Idots(d,whencode) -> [109] + | Ast0.OptIni(id) -> [110] + | Ast0.UniqueIni(id) -> [111] + +let parameterTypeDef p = + match Ast0.unwrap p with + Ast0.VoidParam(ty) -> [59] + | Ast0.Param(ty,id) -> [60] + | Ast0.MetaParam(name,_) -> [61] + | Ast0.MetaParamList(name,_,_) -> [62] + | Ast0.PComma(cm) -> [63] + | Ast0.Pdots(dots) -> [64] + | Ast0.Pcircles(dots) -> [65] + | Ast0.OptParam(param) -> [66] + | Ast0.UniqueParam(param) -> [67] + +let statement s = + match Ast0.unwrap s with + Ast0.FunDecl(bef,fninfo,name,lp,params,rp,lbrace,body,rbrace) -> [68] + | Ast0.Decl(bef,decl) -> [69] + | Ast0.Seq(lbrace,body,rbrace) -> [70] + | Ast0.ExprStatement(exp,sem) -> [71] + | Ast0.IfThen(iff,lp,exp,rp,branch1,aft) -> [72] + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) -> [73] + | Ast0.While(whl,lp,exp,rp,body,_) -> [74] + | Ast0.Do(d,body,whl,lp,exp,rp,sem) -> [75] + | Ast0.For(fr,lp,e1,sem1,e2,sem2,e3,rp,body,_) -> [76] + | Ast0.Iterator(nm,lp,args,rp,body,_) -> [142] + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> [125] + | Ast0.Break(br,sem) -> [100] + | Ast0.Continue(cont,sem) -> [101] + | Ast0.Label(l,dd) -> [144] + | Ast0.Goto(goto,l,sem) -> [145] + | Ast0.Return(ret,sem) -> [77] + | Ast0.ReturnExpr(ret,exp,sem) -> [78] + | Ast0.MetaStmt(name,_) -> [79] + | Ast0.MetaStmtList(name,_) -> [80] + | Ast0.Disj(_,statement_dots_list,_,_) -> [81] + | Ast0.Nest(_,stmt_dots,_,_,_) -> [82] + | Ast0.Exp(exp) -> [83] + | Ast0.TopExp(exp) -> [141] + | Ast0.Ty(ty) -> [124] + | Ast0.TopInit(init) -> [146] + | Ast0.Dots(d,whencode) -> [84] + | Ast0.Circles(d,whencode) -> [85] + | Ast0.Stars(d,whencode) -> [86] + | Ast0.Include(inc,name) -> [118] + | Ast0.Define(def,id,params,body) -> [119] + | Ast0.OptStm(re) -> [87] + | Ast0.UniqueStm(re) -> [88] + +let case_line c = + match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> [126] + | Ast0.Case(case,exp,colon,code) -> [127] + | Ast0.OptCase(case) -> [128] + +let top_level t = + match Ast0.unwrap t with + Ast0.DECL(stmt) -> [90] + | Ast0.FILEINFO(old_file,new_file) -> [92] + | Ast0.CODE(stmt_dots) -> [94] + | Ast0.ERRORWORDS(exps) -> [95] + | Ast0.OTHER(_) -> [96] + +(* 99-101 already used *) diff --git a/parsing_cocci/.#iso_pattern.ml.1.150 b/parsing_cocci/.#iso_pattern.ml.1.150 new file mode 100644 index 0000000..0afc05b --- /dev/null +++ b/parsing_cocci/.#iso_pattern.ml.1.150 @@ -0,0 +1,2342 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* Potential problem: offset of mcode is not updated when an iso is +instantiated, implying that a term may end up with many mcodes with the +same offset. On the other hand, at the moment offset only seems to be used +before this phase. Furthermore add_dot_binding relies on the offset to +remain the same between matching an iso and instantiating it with bindings. *) + +(* --------------------------------------------------------------------- *) +(* match a SmPL expression against a SmPL abstract syntax tree, +either - or + *) + +module Ast = Ast_cocci +module Ast0 = Ast0_cocci +module V0 = Visitor_ast0 + +let current_rule = ref "" + +(* --------------------------------------------------------------------- *) + +type isomorphism = + Ast_cocci.metavar list * Ast0_cocci.anything list list * string (* name *) + +let strip_info = + let mcode (term,_,_,_,_) = + (term,Ast0.NONE,Ast0.default_info(),Ast0.PLUS,ref Ast0.NoMetaPos) in + let donothing r k e = + let x = k e in + {(Ast0.wrap (Ast0.unwrap x)) with + Ast0.mcodekind = ref Ast0.PLUS; + Ast0.true_if_test = x.Ast0.true_if_test} in + V0.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing donothing + donothing donothing + +let anything_equal = function + (Ast0.DotsExprTag(d1),Ast0.DotsExprTag(d2)) -> + failwith "not a possible variable binding" (*not sure why these are pbs*) + | (Ast0.DotsInitTag(d1),Ast0.DotsInitTag(d2)) -> + failwith "not a possible variable binding" + | (Ast0.DotsParamTag(d1),Ast0.DotsParamTag(d2)) -> + failwith "not a possible variable binding" + | (Ast0.DotsStmtTag(d1),Ast0.DotsStmtTag(d2)) -> + (strip_info.V0.rebuilder_statement_dots d1) = + (strip_info.V0.rebuilder_statement_dots d2) + | (Ast0.DotsDeclTag(d1),Ast0.DotsDeclTag(d2)) -> + failwith "not a possible variable binding" + | (Ast0.DotsCaseTag(d1),Ast0.DotsCaseTag(d2)) -> + failwith "not a possible variable binding" + | (Ast0.IdentTag(d1),Ast0.IdentTag(d2)) -> + (strip_info.V0.rebuilder_ident d1) = (strip_info.V0.rebuilder_ident d2) + | (Ast0.ExprTag(d1),Ast0.ExprTag(d2)) -> + (strip_info.V0.rebuilder_expression d1) = + (strip_info.V0.rebuilder_expression d2) + | (Ast0.ArgExprTag(_),_) | (_,Ast0.ArgExprTag(_)) -> + failwith "not possible - only in isos1" + | (Ast0.TestExprTag(_),_) | (_,Ast0.TestExprTag(_)) -> + failwith "not possible - only in isos1" + | (Ast0.TypeCTag(d1),Ast0.TypeCTag(d2)) -> + (strip_info.V0.rebuilder_typeC d1) = + (strip_info.V0.rebuilder_typeC d2) + | (Ast0.InitTag(d1),Ast0.InitTag(d2)) -> + (strip_info.V0.rebuilder_initialiser d1) = + (strip_info.V0.rebuilder_initialiser d2) + | (Ast0.ParamTag(d1),Ast0.ParamTag(d2)) -> + (strip_info.V0.rebuilder_parameter d1) = + (strip_info.V0.rebuilder_parameter d2) + | (Ast0.DeclTag(d1),Ast0.DeclTag(d2)) -> + (strip_info.V0.rebuilder_declaration d1) = + (strip_info.V0.rebuilder_declaration d2) + | (Ast0.StmtTag(d1),Ast0.StmtTag(d2)) -> + (strip_info.V0.rebuilder_statement d1) = + (strip_info.V0.rebuilder_statement d2) + | (Ast0.CaseLineTag(d1),Ast0.CaseLineTag(d2)) -> + (strip_info.V0.rebuilder_case_line d1) = + (strip_info.V0.rebuilder_case_line d2) + | (Ast0.TopTag(d1),Ast0.TopTag(d2)) -> + (strip_info.V0.rebuilder_top_level d1) = + (strip_info.V0.rebuilder_top_level d2) + | (Ast0.IsoWhenTTag(_),_) | (_,Ast0.IsoWhenTTag(_)) -> + failwith "only for isos within iso phase" + | (Ast0.IsoWhenFTag(_),_) | (_,Ast0.IsoWhenFTag(_)) -> + failwith "only for isos within iso phase" + | (Ast0.IsoWhenTag(_),_) | (_,Ast0.IsoWhenTag(_)) -> + failwith "only for isos within iso phase" + | _ -> false + +let term (var1,_,_,_,_) = var1 +let dot_term (var1,_,info,_,_) = ("", var1 ^ (string_of_int info.Ast0.offset)) + + +type reason = + NotPure of Ast0.pure * (string * string) * Ast0.anything + | NotPureLength of (string * string) + | ContextRequired of Ast0.anything + | NonMatch + | Braces of Ast0.statement + | Position of string * string + | TypeMatch of reason list + +let rec interpret_reason name line reason printer = + Printf.printf + "warning: iso %s does not match the code below on line %d\n" name line; + printer(); Format.print_newline(); + match reason with + NotPure(Ast0.Pure,(_,var),nonpure) -> + Printf.printf + "pure metavariable %s is matched against the following nonpure code:\n" + var; + Unparse_ast0.unparse_anything nonpure + | NotPure(Ast0.Context,(_,var),nonpure) -> + Printf.printf + "context metavariable %s is matched against the following\nnoncontext code:\n" + var; + Unparse_ast0.unparse_anything nonpure + | NotPure(Ast0.PureContext,(_,var),nonpure) -> + Printf.printf + "pure context metavariable %s is matched against the following\nnonpure or noncontext code:\n" + var; + Unparse_ast0.unparse_anything nonpure + | NotPureLength((_,var)) -> + Printf.printf + "pure metavariable %s is matched against too much or too little code\n" + var; + | ContextRequired(term) -> + Printf.printf + "the following code matched is not uniformly minus or context,\nor contains a disjunction:\n"; + Unparse_ast0.unparse_anything term + | Braces(s) -> + Printf.printf "braces must be all minus (plus code allowed) or all\ncontext (plus code not allowed in the body) to match:\n"; + Unparse_ast0.statement "" s; + Format.print_newline() + | Position(rule,name) -> + Printf.printf "position variable %s.%s conflicts with an isomorphism\n" + rule name; + | TypeMatch reason_list -> + List.iter (function r -> interpret_reason name line r printer) + reason_list + | _ -> failwith "not possible" + +type 'a either = OK of 'a | Fail of reason + +let add_binding var exp bindings = + let var = term var in + let attempt bindings = + try + let cur = List.assoc var bindings in + if anything_equal(exp,cur) then [bindings] else [] + with Not_found -> [((var,exp)::bindings)] in + match List.concat(List.map attempt bindings) with + [] -> Fail NonMatch + | x -> OK x + +let add_dot_binding var exp bindings = + let var = dot_term var in + let attempt bindings = + try + let cur = List.assoc var bindings in + if anything_equal(exp,cur) then [bindings] else [] + with Not_found -> [((var,exp)::bindings)] in + match List.concat(List.map attempt bindings) with + [] -> Fail NonMatch + | x -> OK x + +(* multi-valued *) +let add_multi_dot_binding var exp bindings = + let var = dot_term var in + let attempt bindings = [((var,exp)::bindings)] in + match List.concat(List.map attempt bindings) with + [] -> Fail NonMatch + | x -> OK x + +let rec nub ls = + match ls with + [] -> [] + | (x::xs) when (List.mem x xs) -> nub xs + | (x::xs) -> x::(nub xs) + +(* --------------------------------------------------------------------- *) + +let init_env = [[]] + +let debug str m binding = + let res = m binding in + (match res with + None -> Printf.printf "%s: failed\n" str + | Some binding -> + List.iter + (function binding -> + Printf.printf "%s: %s\n" str + (String.concat " " (List.map (function (x,_) -> x) binding))) + binding); + res + +let conjunct_bindings + (m1 : 'binding -> 'binding either) + (m2 : 'binding -> 'binding either) + (binding : 'binding) : 'binding either = + match m1 binding with Fail(reason) -> Fail(reason) | OK binding -> m2 binding + +let rec conjunct_many_bindings = function + [] -> failwith "not possible" + | [x] -> x + | x::xs -> conjunct_bindings x (conjunct_many_bindings xs) + +let mcode_equal (x,_,_,_,_) (y,_,_,_,_) = x = y + +let return b binding = if b then OK binding else Fail NonMatch +let return_false reason binding = Fail reason + +let match_option f t1 t2 = + match (t1,t2) with + (Some t1, Some t2) -> f t1 t2 + | (None, None) -> return true + | _ -> return false + +let bool_match_option f t1 t2 = + match (t1,t2) with + (Some t1, Some t2) -> f t1 t2 + | (None, None) -> true + | _ -> false + +(* context_required is for the example + if ( ++ (int * ) + x == NULL) + where we can't change x == NULL to eg NULL == x. So there can either be + nothing attached to the root or the term has to be all removed. + if would be nice if we knew more about the relationship between the - and + + code, because in the case where the + code is a separate statement in a + sequence, this is not a problem. Perhaps something could be done in + insert_plus + + The example seems strange. Why isn't the cast attached to x? + *) +let is_context e = + !Flag.sgrep_mode2 or (* everything is context for sgrep *) + (match Ast0.get_mcodekind e with + Ast0.CONTEXT(cell) -> true + | _ -> false) + +(* needs a special case when there is a Disj or an empty DOTS + the following stops at the statement level, and gives true if one + statement is replaced by another *) +let rec is_pure_context s = + !Flag.sgrep_mode2 or (* everything is context for sgrep *) + (match Ast0.unwrap s with + Ast0.Disj(starter,statement_dots_list,mids,ender) -> + List.for_all + (function x -> + match Ast0.undots x with + [s] -> is_pure_context s + | _ -> false (* could we do better? *)) + statement_dots_list + | _ -> + (match Ast0.get_mcodekind s with + Ast0.CONTEXT(mc) -> + (match !mc with + (Ast.NOTHING,_,_) -> true + | _ -> false) + | Ast0.MINUS(mc) -> + (match !mc with + (* do better for the common case of replacing a stmt by another one *) + ([[Ast.StatementTag(s)]],_) -> + (match Ast.unwrap s with + Ast.IfThen(_,_,_) -> false (* potentially dangerous *) + | _ -> true) + | (_,_) -> false) + | _ -> false)) + +let is_minus e = + match Ast0.get_mcodekind e with Ast0.MINUS(cell) -> true | _ -> false + +let match_list matcher is_list_matcher do_list_match la lb = + let rec loop = function + ([],[]) -> return true + | ([x],lb) when is_list_matcher x -> do_list_match x lb + | (x::xs,y::ys) -> conjunct_bindings (matcher x y) (loop (xs,ys)) + | _ -> return false in + loop (la,lb) + +let match_maker checks_needed context_required whencode_allowed = + + let check_mcode pmc cmc binding = + if checks_needed + then + match Ast0.get_pos cmc with + (Ast0.MetaPos (name,_,_)) as x -> + (match Ast0.get_pos pmc with + Ast0.MetaPos (name1,_,_) -> + add_binding name1 (Ast0.MetaPosTag x) binding + | Ast0.NoMetaPos -> + let (rule,name) = Ast0.unwrap_mcode name in + Fail (Position(rule,name))) + | Ast0.NoMetaPos -> OK binding + else OK binding in + + let match_dots matcher is_list_matcher do_list_match d1 d2 = + match (Ast0.unwrap d1, Ast0.unwrap d2) with + (Ast0.DOTS(la),Ast0.DOTS(lb)) + | (Ast0.CIRCLES(la),Ast0.CIRCLES(lb)) + | (Ast0.STARS(la),Ast0.STARS(lb)) -> + match_list matcher is_list_matcher (do_list_match d2) la lb + | _ -> return false in + + let is_elist_matcher el = + match Ast0.unwrap el with Ast0.MetaExprList(_,_,_) -> true | _ -> false in + + let is_plist_matcher pl = + match Ast0.unwrap pl with Ast0.MetaParamList(_,_,_) -> true | _ -> false in + + let is_slist_matcher pl = + match Ast0.unwrap pl with Ast0.MetaStmtList(_,_) -> true | _ -> false in + + let no_list _ = false in + + let build_dots pattern data = + match Ast0.unwrap pattern with + Ast0.DOTS(_) -> Ast0.rewrap pattern (Ast0.DOTS(data)) + | Ast0.CIRCLES(_) -> Ast0.rewrap pattern (Ast0.CIRCLES(data)) + | Ast0.STARS(_) -> Ast0.rewrap pattern (Ast0.STARS(data)) in + + let pure_sp_code = + let bind = Ast0.lub_pure in + let option_default = Ast0.Context in + let pure_mcodekind mc = + if !Flag.sgrep_mode2 + then Ast0.PureContext + else + match mc with + Ast0.CONTEXT(mc) -> + (match !mc with + (Ast.NOTHING,_,_) -> Ast0.PureContext + | _ -> Ast0.Context) + | Ast0.MINUS(mc) -> + (match !mc with ([],_) -> Ast0.Pure | _ -> Ast0.Impure) + | _ -> Ast0.Impure in + let donothing r k e = + bind (pure_mcodekind (Ast0.get_mcodekind e)) (k e) in + + let mcode m = pure_mcodekind (Ast0.get_mcode_mcodekind m) in + + (* a case for everything that has a metavariable *) + (* pure is supposed to match only unitary metavars, not anything that + contains only unitary metavars *) + let ident r k i = + bind (bind (pure_mcodekind (Ast0.get_mcodekind i)) (k i)) + (match Ast0.unwrap i with + Ast0.MetaId(name,_,pure) | Ast0.MetaFunc(name,_,pure) + | Ast0.MetaLocalFunc(name,_,pure) -> pure + | _ -> Ast0.Impure) in + + let expression r k e = + bind (bind (pure_mcodekind (Ast0.get_mcodekind e)) (k e)) + (match Ast0.unwrap e with + Ast0.MetaErr(name,_,pure) + | Ast0.MetaExpr(name,_,_,_,pure) | Ast0.MetaExprList(name,_,pure) -> + pure + | _ -> Ast0.Impure) in + + let typeC r k t = + bind (bind (pure_mcodekind (Ast0.get_mcodekind t)) (k t)) + (match Ast0.unwrap t with + Ast0.MetaType(name,pure) -> pure + | _ -> Ast0.Impure) in + + let param r k p = + bind (bind (pure_mcodekind (Ast0.get_mcodekind p)) (k p)) + (match Ast0.unwrap p with + Ast0.MetaParam(name,pure) | Ast0.MetaParamList(name,_,pure) -> pure + | _ -> Ast0.Impure) in + + let stmt r k s = + bind (bind (pure_mcodekind (Ast0.get_mcodekind s)) (k s)) + (match Ast0.unwrap s with + Ast0.MetaStmt(name,pure) | Ast0.MetaStmtList(name,pure) -> pure + | _ -> Ast0.Impure) in + + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + ident expression typeC donothing param donothing stmt donothing + donothing in + + let add_pure_list_binding name pure is_pure builder1 builder2 lst = + match (checks_needed,pure) with + (true,Ast0.Pure) | (true,Ast0.Context) | (true,Ast0.PureContext) -> + (match lst with + [x] -> + if (Ast0.lub_pure (is_pure x) pure) = pure + then add_binding name (builder1 lst) + else return_false (NotPure (pure,term name,builder1 lst)) + | _ -> return_false (NotPureLength (term name))) + | (false,_) | (_,Ast0.Impure) -> add_binding name (builder2 lst) in + + let add_pure_binding name pure is_pure builder x = + match (checks_needed,pure) with + (true,Ast0.Pure) | (true,Ast0.Context) | (true,Ast0.PureContext) -> + if (Ast0.lub_pure (is_pure x) pure) = pure + then add_binding name (builder x) + else return_false (NotPure (pure,term name, builder x)) + | (false,_) | (_,Ast0.Impure) -> add_binding name (builder x) in + + let do_elist_match builder el lst = + match Ast0.unwrap el with + Ast0.MetaExprList(name,lenname,pure) -> + (*how to handle lenname? should it be an option type and always None?*) + failwith "expr list pattern not supported in iso" + (*add_pure_list_binding name pure + pure_sp_code.V0.combiner_expression + (function lst -> Ast0.ExprTag(List.hd lst)) + (function lst -> Ast0.DotsExprTag(build_dots builder lst)) + lst*) + | _ -> failwith "not possible" in + + let do_plist_match builder pl lst = + match Ast0.unwrap pl with + Ast0.MetaParamList(name,lename,pure) -> + failwith "param list pattern not supported in iso" + (*add_pure_list_binding name pure + pure_sp_code.V0.combiner_parameter + (function lst -> Ast0.ParamTag(List.hd lst)) + (function lst -> Ast0.DotsParamTag(build_dots builder lst)) + lst*) + | _ -> failwith "not possible" in + + let do_slist_match builder sl lst = + match Ast0.unwrap sl with + Ast0.MetaStmtList(name,pure) -> + add_pure_list_binding name pure + pure_sp_code.V0.combiner_statement + (function lst -> Ast0.StmtTag(List.hd lst)) + (function lst -> Ast0.DotsStmtTag(build_dots builder lst)) + lst + | _ -> failwith "not possible" in + + let do_nolist_match _ _ = failwith "not possible" in + + let rec match_ident pattern id = + match Ast0.unwrap pattern with + Ast0.MetaId(name,_,pure) -> + (add_pure_binding name pure pure_sp_code.V0.combiner_ident + (function id -> Ast0.IdentTag id) id) + | Ast0.MetaFunc(name,_,pure) -> failwith "metafunc not supported" + | Ast0.MetaLocalFunc(name,_,pure) -> failwith "metalocalfunc not supported" + | up -> + if not(checks_needed) or not(context_required) or is_context id + then + match (up,Ast0.unwrap id) with + (Ast0.Id(namea),Ast0.Id(nameb)) -> + if mcode_equal namea nameb + then check_mcode namea nameb + else return false + | (Ast0.OptIdent(ida),Ast0.OptIdent(idb)) + | (Ast0.UniqueIdent(ida),Ast0.UniqueIdent(idb)) -> + match_ident ida idb + | (_,Ast0.OptIdent(idb)) + | (_,Ast0.UniqueIdent(idb)) -> match_ident pattern idb + | _ -> return false + else return_false (ContextRequired (Ast0.IdentTag id)) in + + (* should we do something about matching metavars against ...? *) + let rec match_expr pattern expr = + match Ast0.unwrap pattern with + Ast0.MetaExpr(name,_,ty,form,pure) -> + let form_ok = + match (form,expr) with + (Ast.ANY,_) -> true + | (Ast.CONST,e) -> + let rec matches e = + match Ast0.unwrap e with + Ast0.Constant(c) -> true + | Ast0.Cast(lp,ty,rp,e) -> matches e + | Ast0.SizeOfExpr(se,exp) -> true + | Ast0.SizeOfType(se,lp,ty,rp) -> true + | Ast0.MetaExpr(nm,_,_,Ast.CONST,p) -> + (Ast0.lub_pure p pure) = pure + | _ -> false in + matches e + | (Ast.ID,e) | (Ast.LocalID,e) -> + let rec matches e = + match Ast0.unwrap e with + Ast0.Ident(c) -> true + | Ast0.Cast(lp,ty,rp,e) -> matches e + | Ast0.MetaExpr(nm,_,_,Ast.ID,p) -> + (Ast0.lub_pure p pure) = pure + | _ -> false in + matches e in + if form_ok + then + match ty with + Some ts -> + if List.exists + (function Type_cocci.MetaType(_,_,_) -> true | _ -> false) + ts + then + (match ts with + [Type_cocci.MetaType(tyname,_,_)] -> + let expty = + match (Ast0.unwrap expr,Ast0.get_type expr) with + (* easier than updating type inferencer to manage multiple + types *) + (Ast0.MetaExpr(_,_,Some tts,_,_),_) -> Some tts + | (_,Some ty) -> Some [ty] + | _ -> None in + (match expty with + Some expty -> + let tyname = Ast0.rewrap_mcode name tyname in + conjunct_bindings + (add_pure_binding name pure + pure_sp_code.V0.combiner_expression + (function expr -> Ast0.ExprTag expr) + expr) + (function bindings -> + let attempts = + List.map + (function expty -> + (try + add_pure_binding tyname Ast0.Impure + (function _ -> Ast0.Impure) + (function ty -> Ast0.TypeCTag ty) + (Ast0.rewrap expr + (Ast0.reverse_type expty)) + bindings + with Ast0.TyConv -> + Printf.printf + "warning: unconvertible type"; + return false bindings)) + expty in + if List.exists + (function Fail _ -> false | OK x -> true) + attempts + then + (* not sure why this is ok. can there be more + than one OK? *) + OK (List.concat + (List.map + (function Fail _ -> [] | OK x -> x) + attempts)) + else + Fail + (TypeMatch + (List.map + (function + Fail r -> r + | OK x -> failwith "not possible") + attempts))) + | _ -> + (*Printf.printf + "warning: type metavar can only match one type";*) + return false) + | _ -> + failwith + "mixture of metatype and other types not supported") + else + let expty = Ast0.get_type expr in + if List.exists (function t -> Type_cocci.compatible t expty) ts + then + add_pure_binding name pure + pure_sp_code.V0.combiner_expression + (function expr -> Ast0.ExprTag expr) + expr + else return false + | None -> + add_pure_binding name pure pure_sp_code.V0.combiner_expression + (function expr -> Ast0.ExprTag expr) + expr + else return false + | Ast0.MetaErr(namea,_,pure) -> failwith "metaerr not supported" + | Ast0.MetaExprList(_,_,_) -> failwith "metaexprlist not supported" + | up -> + if not(checks_needed) or not(context_required) or is_context expr + then + match (up,Ast0.unwrap expr) with + (Ast0.Ident(ida),Ast0.Ident(idb)) -> + match_ident ida idb + | (Ast0.Constant(consta),Ast0.Constant(constb)) -> + if mcode_equal consta constb + then check_mcode consta constb + else return false + | (Ast0.FunCall(fna,lp1,argsa,rp1),Ast0.FunCall(fnb,lp,argsb,rp)) -> + conjunct_many_bindings + [check_mcode lp1 lp; check_mcode rp1 rp; match_expr fna fnb; + match_dots match_expr is_elist_matcher do_elist_match + argsa argsb] + | (Ast0.Assignment(lefta,opa,righta,_), + Ast0.Assignment(leftb,opb,rightb,_)) -> + if mcode_equal opa opb + then + conjunct_many_bindings + [check_mcode opa opb; match_expr lefta leftb; + match_expr righta rightb] + else return false + | (Ast0.CondExpr(exp1a,lp1,exp2a,rp1,exp3a), + Ast0.CondExpr(exp1b,lp,exp2b,rp,exp3b)) -> + conjunct_many_bindings + [check_mcode lp1 lp; check_mcode rp1 rp; + match_expr exp1a exp1b; match_option match_expr exp2a exp2b; + match_expr exp3a exp3b] + | (Ast0.Postfix(expa,opa),Ast0.Postfix(expb,opb)) -> + if mcode_equal opa opb + then + conjunct_bindings (check_mcode opa opb) (match_expr expa expb) + else return false + | (Ast0.Infix(expa,opa),Ast0.Infix(expb,opb)) -> + if mcode_equal opa opb + then + conjunct_bindings (check_mcode opa opb) (match_expr expa expb) + else return false + | (Ast0.Unary(expa,opa),Ast0.Unary(expb,opb)) -> + if mcode_equal opa opb + then + conjunct_bindings (check_mcode opa opb) (match_expr expa expb) + else return false + | (Ast0.Binary(lefta,opa,righta),Ast0.Binary(leftb,opb,rightb)) -> + if mcode_equal opa opb + then + conjunct_many_bindings + [check_mcode opa opb; match_expr lefta leftb; + match_expr righta rightb] + else return false + | (Ast0.Paren(lp1,expa,rp1),Ast0.Paren(lp,expb,rp)) -> + conjunct_many_bindings + [check_mcode lp1 lp; check_mcode rp1 rp; match_expr expa expb] + | (Ast0.ArrayAccess(exp1a,lb1,exp2a,rb1), + Ast0.ArrayAccess(exp1b,lb,exp2b,rb)) -> + conjunct_many_bindings + [check_mcode lb1 lb; check_mcode rb1 rb; + match_expr exp1a exp1b; match_expr exp2a exp2b] + | (Ast0.RecordAccess(expa,opa,fielda), + Ast0.RecordAccess(expb,op,fieldb)) + | (Ast0.RecordPtAccess(expa,opa,fielda), + Ast0.RecordPtAccess(expb,op,fieldb)) -> + conjunct_many_bindings + [check_mcode opa op; match_expr expa expb; + match_ident fielda fieldb] + | (Ast0.Cast(lp1,tya,rp1,expa),Ast0.Cast(lp,tyb,rp,expb)) -> + conjunct_many_bindings + [check_mcode lp1 lp; check_mcode rp1 rp; + match_typeC tya tyb; match_expr expa expb] + | (Ast0.SizeOfExpr(szf1,expa),Ast0.SizeOfExpr(szf,expb)) -> + conjunct_bindings (check_mcode szf1 szf) (match_expr expa expb) + | (Ast0.SizeOfType(szf1,lp1,tya,rp1), + Ast0.SizeOfType(szf,lp,tyb,rp)) -> + conjunct_many_bindings + [check_mcode lp1 lp; check_mcode rp1 rp; + check_mcode szf1 szf; match_typeC tya tyb] + | (Ast0.TypeExp(tya),Ast0.TypeExp(tyb)) -> + match_typeC tya tyb + | (Ast0.EComma(cm1),Ast0.EComma(cm)) -> check_mcode cm1 cm + | (Ast0.DisjExpr(_,expsa,_,_),_) -> + failwith "not allowed in the pattern of an isomorphism" + | (Ast0.NestExpr(_,exp_dotsa,_,_,_),_) -> + failwith "not allowed in the pattern of an isomorphism" + | (Ast0.Edots(d,None),Ast0.Edots(d1,None)) + | (Ast0.Ecircles(d,None),Ast0.Ecircles(d1,None)) + | (Ast0.Estars(d,None),Ast0.Estars(d1,None)) -> check_mcode d d1 + | (Ast0.Edots(ed,None),Ast0.Edots(ed1,Some wc)) + | (Ast0.Ecircles(ed,None),Ast0.Ecircles(ed1,Some wc)) + | (Ast0.Estars(ed,None),Ast0.Estars(ed1,Some wc)) -> + (* hope that mcode of edots is unique somehow *) + conjunct_bindings (check_mcode ed ed1) + (let (edots_whencode_allowed,_,_) = whencode_allowed in + if edots_whencode_allowed + then add_dot_binding ed (Ast0.ExprTag wc) + else + (Printf.printf + "warning: not applying iso because of whencode"; + return false)) + | (Ast0.Edots(_,Some _),_) | (Ast0.Ecircles(_,Some _),_) + | (Ast0.Estars(_,Some _),_) -> + failwith "whencode not allowed in a pattern1" + | (Ast0.OptExp(expa),Ast0.OptExp(expb)) + | (Ast0.UniqueExp(expa),Ast0.UniqueExp(expb)) -> match_expr expa expb + | (_,Ast0.OptExp(expb)) + | (_,Ast0.UniqueExp(expb)) -> match_expr pattern expb + | _ -> return false + else return_false (ContextRequired (Ast0.ExprTag expr)) + +(* the special case for function types prevents the eg T X; -> T X = E; iso + from applying, which doesn't seem very relevant, but it also avoids a + mysterious bug that is obtained with eg int attach(...); *) + and match_typeC pattern t = + match Ast0.unwrap pattern with + Ast0.MetaType(name,pure) -> + (match Ast0.unwrap t with + Ast0.FunctionType(tya,lp1a,paramsa,rp1a) -> return false + | _ -> + add_pure_binding name pure pure_sp_code.V0.combiner_typeC + (function ty -> Ast0.TypeCTag ty) + t) + | up -> + if not(checks_needed) or not(context_required) or is_context t + then + match (up,Ast0.unwrap t) with + (Ast0.ConstVol(cva,tya),Ast0.ConstVol(cvb,tyb)) -> + if mcode_equal cva cvb + then + conjunct_bindings (check_mcode cva cvb) (match_typeC tya tyb) + else return false + | (Ast0.BaseType(tya,stringsa),Ast0.BaseType(tyb,stringsb)) -> + if tya = tyb + then + match_list check_mcode + (function _ -> false) (function _ -> failwith "") + stringsa stringsb + else return false + | (Ast0.Signed(signa,tya),Ast0.Signed(signb,tyb)) -> + if mcode_equal signa signb + then + conjunct_bindings (check_mcode signa signb) + (match_option match_typeC tya tyb) + else return false + | (Ast0.Pointer(tya,star1),Ast0.Pointer(tyb,star)) -> + conjunct_bindings (check_mcode star1 star) (match_typeC tya tyb) + | (Ast0.FunctionPointer(tya,lp1a,stara,rp1a,lp2a,paramsa,rp2a), + Ast0.FunctionPointer(tyb,lp1b,starb,rp1b,lp2b,paramsb,rp2b)) -> + conjunct_many_bindings + [check_mcode stara starb; check_mcode lp1a lp1b; + check_mcode rp1a rp1b; check_mcode lp2a lp2b; + check_mcode rp2a rp2b; match_typeC tya tyb; + match_dots match_param is_plist_matcher + do_plist_match paramsa paramsb] + | (Ast0.FunctionType(tya,lp1a,paramsa,rp1a), + Ast0.FunctionType(tyb,lp1b,paramsb,rp1b)) -> + conjunct_many_bindings + [check_mcode lp1a lp1b; check_mcode rp1a rp1b; + match_option match_typeC tya tyb; + match_dots match_param is_plist_matcher do_plist_match + paramsa paramsb] + | (Ast0.Array(tya,lb1,sizea,rb1),Ast0.Array(tyb,lb,sizeb,rb)) -> + conjunct_many_bindings + [check_mcode lb1 lb; check_mcode rb1 rb; + match_typeC tya tyb; match_option match_expr sizea sizeb] + | (Ast0.EnumName(kinda,namea),Ast0.EnumName(kindb,nameb)) -> + conjunct_bindings (check_mcode kinda kindb) + (match_ident namea nameb) + | (Ast0.StructUnionName(kinda,Some namea), + Ast0.StructUnionName(kindb,Some nameb)) -> + if mcode_equal kinda kindb + then + conjunct_bindings (check_mcode kinda kindb) + (match_ident namea nameb) + else return false + | (Ast0.StructUnionDef(tya,lb1,declsa,rb1), + Ast0.StructUnionDef(tyb,lb,declsb,rb)) -> + conjunct_many_bindings + [check_mcode lb1 lb; check_mcode rb1 rb; + match_typeC tya tyb; + match_dots match_decl no_list do_nolist_match declsa declsb] + | (Ast0.TypeName(namea),Ast0.TypeName(nameb)) -> + if mcode_equal namea nameb + then check_mcode namea nameb + else return false + | (Ast0.DisjType(_,typesa,_,_),Ast0.DisjType(_,typesb,_,_)) -> + failwith "not allowed in the pattern of an isomorphism" + | (Ast0.OptType(tya),Ast0.OptType(tyb)) + | (Ast0.UniqueType(tya),Ast0.UniqueType(tyb)) -> match_typeC tya tyb + | (_,Ast0.OptType(tyb)) + | (_,Ast0.UniqueType(tyb)) -> match_typeC pattern tyb + | _ -> return false + else return_false (ContextRequired (Ast0.TypeCTag t)) + + and match_decl pattern d = + if not(checks_needed) or not(context_required) or is_context d + then + match (Ast0.unwrap pattern,Ast0.unwrap d) with + (Ast0.Init(stga,tya,ida,eq1,inia,sc1), + Ast0.Init(stgb,tyb,idb,eq,inib,sc)) -> + if bool_match_option mcode_equal stga stgb + then + conjunct_many_bindings + [check_mcode eq1 eq; check_mcode sc1 sc; + match_option check_mcode stga stgb; + match_typeC tya tyb; match_ident ida idb; + match_init inia inib] + else return false + | (Ast0.UnInit(stga,tya,ida,sc1),Ast0.UnInit(stgb,tyb,idb,sc)) -> + if bool_match_option mcode_equal stga stgb + then + conjunct_many_bindings + [check_mcode sc1 sc; match_option check_mcode stga stgb; + match_typeC tya tyb; match_ident ida idb] + else return false + | (Ast0.MacroDecl(namea,lp1,argsa,rp1,sc1), + Ast0.MacroDecl(nameb,lp,argsb,rp,sc)) -> + conjunct_many_bindings + [match_ident namea nameb; + check_mcode lp1 lp; check_mcode rp1 rp; + check_mcode sc1 sc; + match_dots match_expr is_elist_matcher do_elist_match + argsa argsb] + | (Ast0.TyDecl(tya,sc1),Ast0.TyDecl(tyb,sc)) -> + conjunct_bindings (check_mcode sc1 sc) (match_typeC tya tyb) + | (Ast0.Typedef(stga,tya,ida,sc1),Ast0.Typedef(stgb,tyb,idb,sc)) -> + conjunct_bindings (check_mcode sc1 sc) + (conjunct_bindings (match_typeC tya tyb) (match_typeC ida idb)) + | (Ast0.DisjDecl(_,declsa,_,_),Ast0.DisjDecl(_,declsb,_,_)) -> + failwith "not allowed in the pattern of an isomorphism" + | (Ast0.Ddots(d1,None),Ast0.Ddots(d,None)) -> check_mcode d1 d + | (Ast0.Ddots(dd,None),Ast0.Ddots(d,Some wc)) -> + conjunct_bindings (check_mcode dd d) + (* hope that mcode of ddots is unique somehow *) + (let (ddots_whencode_allowed,_,_) = whencode_allowed in + if ddots_whencode_allowed + then add_dot_binding dd (Ast0.DeclTag wc) + else + (Printf.printf "warning: not applying iso because of whencode"; + return false)) + | (Ast0.Ddots(_,Some _),_) -> + failwith "whencode not allowed in a pattern1" + + | (Ast0.OptDecl(decla),Ast0.OptDecl(declb)) + | (Ast0.UniqueDecl(decla),Ast0.UniqueDecl(declb)) -> + match_decl decla declb + | (_,Ast0.OptDecl(declb)) + | (_,Ast0.UniqueDecl(declb)) -> + match_decl pattern declb + | _ -> return false + else return_false (ContextRequired (Ast0.DeclTag d)) + + and match_init pattern i = + if not(checks_needed) or not(context_required) or is_context i + then + match (Ast0.unwrap pattern,Ast0.unwrap i) with + (Ast0.InitExpr(expa),Ast0.InitExpr(expb)) -> + match_expr expa expb + | (Ast0.InitList(lb1,initlista,rb1),Ast0.InitList(lb,initlistb,rb)) -> + conjunct_many_bindings + [check_mcode lb1 lb; check_mcode rb1 rb; + match_dots match_init no_list do_nolist_match + initlista initlistb] + | (Ast0.InitGccDotName(d1,namea,e1,inia), + Ast0.InitGccDotName(d,nameb,e,inib)) -> + conjunct_many_bindings + [check_mcode d1 d; check_mcode e1 e; + match_ident namea nameb; match_init inia inib] + | (Ast0.InitGccName(namea,c1,inia),Ast0.InitGccName(nameb,c,inib)) -> + conjunct_many_bindings + [check_mcode c1 c; match_ident namea nameb; + match_init inia inib] + | (Ast0.InitGccIndex(lb1,expa,rb1,e1,inia), + Ast0.InitGccIndex(lb2,expb,rb2,e2,inib)) -> + conjunct_many_bindings + [check_mcode lb1 lb2; check_mcode rb1 rb2; check_mcode e1 e2; + match_expr expa expb; match_init inia inib] + | (Ast0.InitGccRange(lb1,exp1a,d1,exp2a,rb1,e1,inia), + Ast0.InitGccRange(lb2,exp1b,d2,exp2b,rb2,e2,inib)) -> + conjunct_many_bindings + [check_mcode lb1 lb2; check_mcode d1 d2; + check_mcode rb1 rb2; check_mcode e1 e2; + match_expr exp1a exp1b; match_expr exp2a exp2b; + match_init inia inib] + | (Ast0.IComma(c1),Ast0.IComma(c)) -> check_mcode c1 c + | (Ast0.Idots(d1,None),Ast0.Idots(d,None)) -> check_mcode d1 d + | (Ast0.Idots(id,None),Ast0.Idots(d,Some wc)) -> + conjunct_bindings (check_mcode id d) + (* hope that mcode of edots is unique somehow *) + (let (_,idots_whencode_allowed,_) = whencode_allowed in + if idots_whencode_allowed + then add_dot_binding id (Ast0.InitTag wc) + else + (Printf.printf "warning: not applying iso because of whencode"; + return false)) + | (Ast0.Idots(_,Some _),_) -> + failwith "whencode not allowed in a pattern2" + | (Ast0.OptIni(ia),Ast0.OptIni(ib)) + | (Ast0.UniqueIni(ia),Ast0.UniqueIni(ib)) -> match_init ia ib + | (_,Ast0.OptIni(ib)) + | (_,Ast0.UniqueIni(ib)) -> match_init pattern ib + | _ -> return false + else return_false (ContextRequired (Ast0.InitTag i)) + + and match_param pattern p = + match Ast0.unwrap pattern with + Ast0.MetaParam(name,pure) -> + add_pure_binding name pure pure_sp_code.V0.combiner_parameter + (function p -> Ast0.ParamTag p) + p + | Ast0.MetaParamList(name,_,pure) -> failwith "metaparamlist not supported" + | up -> + if not(checks_needed) or not(context_required) or is_context p + then + match (up,Ast0.unwrap p) with + (Ast0.VoidParam(tya),Ast0.VoidParam(tyb)) -> match_typeC tya tyb + | (Ast0.Param(tya,ida),Ast0.Param(tyb,idb)) -> + conjunct_bindings (match_typeC tya tyb) + (match_option match_ident ida idb) + | (Ast0.PComma(c1),Ast0.PComma(c)) -> check_mcode c1 c + | (Ast0.Pdots(d1),Ast0.Pdots(d)) + | (Ast0.Pcircles(d1),Ast0.Pcircles(d)) -> check_mcode d1 d + | (Ast0.OptParam(parama),Ast0.OptParam(paramb)) + | (Ast0.UniqueParam(parama),Ast0.UniqueParam(paramb)) -> + match_param parama paramb + | (_,Ast0.OptParam(paramb)) + | (_,Ast0.UniqueParam(paramb)) -> match_param pattern paramb + | _ -> return false + else return_false (ContextRequired (Ast0.ParamTag p)) + + and match_statement pattern s = + match Ast0.unwrap pattern with + Ast0.MetaStmt(name,pure) -> + (match Ast0.unwrap s with + Ast0.Dots(_,_) | Ast0.Circles(_,_) | Ast0.Stars(_,_) -> + return false (* ... is not a single statement *) + | _ -> + add_pure_binding name pure pure_sp_code.V0.combiner_statement + (function ty -> Ast0.StmtTag ty) + s) + | Ast0.MetaStmtList(name,pure) -> failwith "metastmtlist not supported" + | up -> + if not(checks_needed) or not(context_required) or is_context s + then + match (up,Ast0.unwrap s) with + (Ast0.FunDecl(_,fninfoa,namea,lp1,paramsa,rp1,lb1,bodya,rb1), + Ast0.FunDecl(_,fninfob,nameb,lp,paramsb,rp,lb,bodyb,rb)) -> + conjunct_many_bindings + [check_mcode lp1 lp; check_mcode rp1 rp; + check_mcode lb1 lb; check_mcode rb1 rb; + match_fninfo fninfoa fninfob; match_ident namea nameb; + match_dots match_param is_plist_matcher do_plist_match + paramsa paramsb; + match_dots match_statement is_slist_matcher do_slist_match + bodya bodyb] + | (Ast0.Decl(_,decla),Ast0.Decl(_,declb)) -> + match_decl decla declb + | (Ast0.Seq(lb1,bodya,rb1),Ast0.Seq(lb,bodyb,rb)) -> + (* seqs can only match if they are all minus (plus code + allowed) or all context (plus code not allowed in the body). + we could be more permissive if the expansions of the isos are + also all seqs, but this would be hard to check except at top + level, and perhaps not worth checking even in that case. + Overall, the issue is that braces are used where single + statements are required, and something not satisfying these + conditions can cause a single statement to become a + non-single statement after the transformation. + + example: if { ... -foo(); ... } + if we let the sequence convert to just -foo(); + then we produce invalid code. For some reason, + single_statement can't deal with this case, perhaps because + it starts introducing too many braces? don't remember the + exact problem... + *) + conjunct_bindings (check_mcode lb1 lb) + (conjunct_bindings (check_mcode rb1 rb) + (if not(checks_needed) or is_minus s or + (is_context s && + List.for_all is_pure_context (Ast0.undots bodyb)) + then + match_dots match_statement is_slist_matcher do_slist_match + bodya bodyb + else return_false (Braces(s)))) + | (Ast0.ExprStatement(expa,sc1),Ast0.ExprStatement(expb,sc)) -> + conjunct_bindings (check_mcode sc1 sc) (match_expr expa expb) + | (Ast0.IfThen(if1,lp1,expa,rp1,branch1a,_), + Ast0.IfThen(if2,lp2,expb,rp2,branch1b,_)) -> + conjunct_many_bindings + [check_mcode if1 if2; check_mcode lp1 lp2; + check_mcode rp1 rp2; + match_expr expa expb; + match_statement branch1a branch1b] + | (Ast0.IfThenElse(if1,lp1,expa,rp1,branch1a,e1,branch2a,_), + Ast0.IfThenElse(if2,lp2,expb,rp2,branch1b,e2,branch2b,_)) -> + conjunct_many_bindings + [check_mcode if1 if2; check_mcode lp1 lp2; + check_mcode rp1 rp2; check_mcode e1 e2; + match_expr expa expb; + match_statement branch1a branch1b; + match_statement branch2a branch2b] + | (Ast0.While(w1,lp1,expa,rp1,bodya,_), + Ast0.While(w,lp,expb,rp,bodyb,_)) -> + conjunct_many_bindings + [check_mcode w1 w; check_mcode lp1 lp; + check_mcode rp1 rp; match_expr expa expb; + match_statement bodya bodyb] + | (Ast0.Do(d1,bodya,w1,lp1,expa,rp1,_), + Ast0.Do(d,bodyb,w,lp,expb,rp,_)) -> + conjunct_many_bindings + [check_mcode d1 d; check_mcode w1 w; check_mcode lp1 lp; + check_mcode rp1 rp; match_statement bodya bodyb; + match_expr expa expb] + | (Ast0.For(f1,lp1,e1a,sc1a,e2a,sc2a,e3a,rp1,bodya,_), + Ast0.For(f,lp,e1b,sc1b,e2b,sc2b,e3b,rp,bodyb,_)) -> + conjunct_many_bindings + [check_mcode f1 f; check_mcode lp1 lp; check_mcode sc1a sc1b; + check_mcode sc2a sc2b; check_mcode rp1 rp; + match_option match_expr e1a e1b; + match_option match_expr e2a e2b; + match_option match_expr e3a e3b; + match_statement bodya bodyb] + | (Ast0.Iterator(nma,lp1,argsa,rp1,bodya,_), + Ast0.Iterator(nmb,lp,argsb,rp,bodyb,_)) -> + conjunct_many_bindings + [match_ident nma nmb; + check_mcode lp1 lp; check_mcode rp1 rp; + match_dots match_expr is_elist_matcher do_elist_match + argsa argsb; + match_statement bodya bodyb] + | (Ast0.Switch(s1,lp1,expa,rp1,lb1,casesa,rb1), + Ast0.Switch(s,lp,expb,rp,lb,casesb,rb)) -> + conjunct_many_bindings + [check_mcode s1 s; check_mcode lp1 lp; check_mcode rp1 rp; + check_mcode lb1 lb; check_mcode rb1 rb; + match_expr expa expb; + match_dots match_case_line no_list do_nolist_match + casesa casesb] + | (Ast0.Break(b1,sc1),Ast0.Break(b,sc)) + | (Ast0.Continue(b1,sc1),Ast0.Continue(b,sc)) -> + conjunct_bindings (check_mcode b1 b) (check_mcode sc1 sc) + | (Ast0.Label(l1,c1),Ast0.Label(l2,c)) -> + conjunct_bindings (match_ident l1 l2) (check_mcode c1 c) + | (Ast0.Goto(g1,l1,sc1),Ast0.Goto(g,l2,sc)) -> + conjunct_many_bindings + [check_mcode g1 g; check_mcode sc1 sc; match_ident l1 l2] + | (Ast0.Return(r1,sc1),Ast0.Return(r,sc)) -> + conjunct_bindings (check_mcode r1 r) (check_mcode sc1 sc) + | (Ast0.ReturnExpr(r1,expa,sc1),Ast0.ReturnExpr(r,expb,sc)) -> + conjunct_many_bindings + [check_mcode r1 r; check_mcode sc1 sc; match_expr expa expb] + | (Ast0.Disj(_,statement_dots_lista,_,_),_) -> + failwith "disj not supported in patterns" + | (Ast0.Nest(_,stmt_dotsa,_,_,_),_) -> + failwith "nest not supported in patterns" + | (Ast0.Exp(expa),Ast0.Exp(expb)) -> match_expr expa expb + | (Ast0.TopExp(expa),Ast0.TopExp(expb)) -> match_expr expa expb + | (Ast0.Exp(expa),Ast0.TopExp(expb)) -> match_expr expa expb + | (Ast0.TopInit(inita),Ast0.TopInit(initb)) -> match_init inita initb + | (Ast0.Ty(tya),Ast0.Ty(tyb)) -> match_typeC tya tyb + | (Ast0.Dots(d,[]),Ast0.Dots(d1,wc)) + | (Ast0.Circles(d,[]),Ast0.Circles(d1,wc)) + | (Ast0.Stars(d,[]),Ast0.Stars(d1,wc)) -> + (match wc with + [] -> check_mcode d d1 + | _ -> + let (_,_,dots_whencode_allowed) = whencode_allowed in + if dots_whencode_allowed + then + conjunct_bindings (check_mcode d d1) + (List.fold_left + (function prev -> + function + | Ast0.WhenNot wc -> + conjunct_bindings prev + (add_multi_dot_binding d + (Ast0.DotsStmtTag wc)) + | Ast0.WhenAlways wc -> + conjunct_bindings prev + (add_multi_dot_binding d (Ast0.StmtTag wc)) + | Ast0.WhenNotTrue wc -> + conjunct_bindings prev + (add_multi_dot_binding d + (Ast0.IsoWhenTTag wc)) + | Ast0.WhenNotFalse wc -> + conjunct_bindings prev + (add_multi_dot_binding d + (Ast0.IsoWhenFTag wc)) + | Ast0.WhenModifier(x) -> + conjunct_bindings prev + (add_multi_dot_binding d + (Ast0.IsoWhenTag x))) + (return true) wc) + else + (Printf.printf + "warning: not applying iso because of whencode"; + return false)) + | (Ast0.Dots(_,_::_),_) | (Ast0.Circles(_,_::_),_) + | (Ast0.Stars(_,_::_),_) -> + failwith "whencode not allowed in a pattern3" + | (Ast0.OptStm(rea),Ast0.OptStm(reb)) + | (Ast0.UniqueStm(rea),Ast0.UniqueStm(reb)) -> + match_statement rea reb + | (_,Ast0.OptStm(reb)) + | (_,Ast0.UniqueStm(reb)) -> match_statement pattern reb + | _ -> return false + else return_false (ContextRequired (Ast0.StmtTag s)) + + (* first should provide a subset of the information in the second *) + and match_fninfo patterninfo cinfo = + let patterninfo = List.sort compare patterninfo in + let cinfo = List.sort compare cinfo in + let rec loop = function + (Ast0.FStorage(sta)::resta,Ast0.FStorage(stb)::restb) -> + if mcode_equal sta stb + then conjunct_bindings (check_mcode sta stb) (loop (resta,restb)) + else return false + | (Ast0.FType(tya)::resta,Ast0.FType(tyb)::restb) -> + conjunct_bindings (match_typeC tya tyb) (loop (resta,restb)) + | (Ast0.FInline(ia)::resta,Ast0.FInline(ib)::restb) -> + if mcode_equal ia ib + then conjunct_bindings (check_mcode ia ib) (loop (resta,restb)) + else return false + | (Ast0.FAttr(ia)::resta,Ast0.FAttr(ib)::restb) -> + if mcode_equal ia ib + then conjunct_bindings (check_mcode ia ib) (loop (resta,restb)) + else return false + | (x::resta,((y::_) as restb)) -> + (match compare x y with + -1 -> return false + | 1 -> loop (resta,restb) + | _ -> failwith "not possible") + | _ -> return false in + loop (patterninfo,cinfo) + + and match_case_line pattern c = + if not(checks_needed) or not(context_required) or is_context c + then + match (Ast0.unwrap pattern,Ast0.unwrap c) with + (Ast0.Default(d1,c1,codea),Ast0.Default(d,c,codeb)) -> + conjunct_many_bindings + [check_mcode d1 d; check_mcode c1 c; + match_dots match_statement is_slist_matcher do_slist_match + codea codeb] + | (Ast0.Case(ca1,expa,c1,codea),Ast0.Case(ca,expb,c,codeb)) -> + conjunct_many_bindings + [check_mcode ca1 ca; check_mcode c1 c; match_expr expa expb; + match_dots match_statement is_slist_matcher do_slist_match + codea codeb] + | (Ast0.OptCase(ca),Ast0.OptCase(cb)) -> match_case_line ca cb + | (_,Ast0.OptCase(cb)) -> match_case_line pattern cb + | _ -> return false + else return_false (ContextRequired (Ast0.CaseLineTag c)) in + + let match_statement_dots x y = + match_dots match_statement is_slist_matcher do_slist_match x y in + + (match_expr, match_decl, match_statement, match_typeC, + match_statement_dots) + +let match_expr dochecks context_required whencode_allowed = + let (fn,_,_,_,_) = match_maker dochecks context_required whencode_allowed in + fn + +let match_decl dochecks context_required whencode_allowed = + let (_,fn,_,_,_) = match_maker dochecks context_required whencode_allowed in + fn + +let match_statement dochecks context_required whencode_allowed = + let (_,_,fn,_,_) = match_maker dochecks context_required whencode_allowed in + fn + +let match_typeC dochecks context_required whencode_allowed = + let (_,_,_,fn,_) = match_maker dochecks context_required whencode_allowed in + fn + +let match_statement_dots dochecks context_required whencode_allowed = + let (_,_,_,_,fn) = match_maker dochecks context_required whencode_allowed in + fn + +(* --------------------------------------------------------------------- *) +(* make an entire tree MINUS *) + +let make_minus = + let mcode (term,arity,info,mcodekind,pos) = + let new_mcodekind = + match mcodekind with + Ast0.CONTEXT(mc) -> + (match !mc with + (Ast.NOTHING,_,_) -> Ast0.MINUS(ref([],Ast0.default_token_info)) + | _ -> failwith "make_minus: unexpected befaft") + | Ast0.MINUS(mc) -> mcodekind (* in the part copied from the src term *) + | _ -> failwith "make_minus mcode: unexpected mcodekind" in + (term,arity,info,new_mcodekind,pos) in + + let update_mc mcodekind e = + match !mcodekind with + Ast0.CONTEXT(mc) -> + (match !mc with + (Ast.NOTHING,_,_) -> + mcodekind := Ast0.MINUS(ref([],Ast0.default_token_info)) + | _ -> failwith "make_minus: unexpected befaft") + | Ast0.MINUS(_mc) -> () (* in the part copied from the src term *) + | Ast0.PLUS -> failwith "make_minus donothing: unexpected plus mcodekind" + | _ -> failwith "make_minus donothing: unexpected mcodekind" in + + let donothing r k e = + let mcodekind = Ast0.get_mcodekind_ref e in + let e = k e in update_mc mcodekind e; e in + + (* special case for whencode, because it isn't processed by contextneg, + since it doesn't appear in the + code *) + (* cases for dots and nests *) + let expression r k e = + let mcodekind = Ast0.get_mcodekind_ref e in + match Ast0.unwrap e with + Ast0.Edots(d,whencode) -> + (*don't recurse because whencode hasn't been processed by context_neg*) + update_mc mcodekind e; Ast0.rewrap e (Ast0.Edots(mcode d,whencode)) + | Ast0.Ecircles(d,whencode) -> + (*don't recurse because whencode hasn't been processed by context_neg*) + update_mc mcodekind e; Ast0.rewrap e (Ast0.Ecircles(mcode d,whencode)) + | Ast0.Estars(d,whencode) -> + (*don't recurse because whencode hasn't been processed by context_neg*) + update_mc mcodekind e; Ast0.rewrap e (Ast0.Estars(mcode d,whencode)) + | Ast0.NestExpr(starter,expr_dots,ender,whencode,multi) -> + update_mc mcodekind e; + Ast0.rewrap e + (Ast0.NestExpr(mcode starter, + r.V0.rebuilder_expression_dots expr_dots, + mcode ender,whencode,multi)) + | _ -> donothing r k e in + + let declaration r k e = + let mcodekind = Ast0.get_mcodekind_ref e in + match Ast0.unwrap e with + Ast0.Ddots(d,whencode) -> + (*don't recurse because whencode hasn't been processed by context_neg*) + update_mc mcodekind e; Ast0.rewrap e (Ast0.Ddots(mcode d,whencode)) + | _ -> donothing r k e in + + let statement r k e = + let mcodekind = Ast0.get_mcodekind_ref e in + match Ast0.unwrap e with + Ast0.Dots(d,whencode) -> + (*don't recurse because whencode hasn't been processed by context_neg*) + update_mc mcodekind e; Ast0.rewrap e (Ast0.Dots(mcode d,whencode)) + | Ast0.Circles(d,whencode) -> + update_mc mcodekind e; Ast0.rewrap e (Ast0.Circles(mcode d,whencode)) + | Ast0.Stars(d,whencode) -> + update_mc mcodekind e; Ast0.rewrap e (Ast0.Stars(mcode d,whencode)) + | Ast0.Nest(starter,stmt_dots,ender,whencode,multi) -> + update_mc mcodekind e; + Ast0.rewrap e + (Ast0.Nest(mcode starter,r.V0.rebuilder_statement_dots stmt_dots, + mcode ender,whencode,multi)) + | _ -> donothing r k e in + + let initialiser r k e = + let mcodekind = Ast0.get_mcodekind_ref e in + match Ast0.unwrap e with + Ast0.Idots(d,whencode) -> + (*don't recurse because whencode hasn't been processed by context_neg*) + update_mc mcodekind e; Ast0.rewrap e (Ast0.Idots(mcode d,whencode)) + | _ -> donothing r k e in + + let dots r k e = + let info = Ast0.get_info e in + let mcodekind = Ast0.get_mcodekind_ref e in + match Ast0.unwrap e with + Ast0.DOTS([]) -> + (* if context is - this should be - as well. There are no tokens + here though, so the bottom-up minusifier in context_neg leaves it + as mixed (or context for sgrep2). It would be better to fix + context_neg, but that would + require a special case for each term with a dots subterm. *) + (match !mcodekind with + Ast0.MIXED(mc) | Ast0.CONTEXT(mc) -> + (match !mc with + (Ast.NOTHING,_,_) -> + mcodekind := Ast0.MINUS(ref([],Ast0.default_token_info)); + e + | _ -> failwith "make_minus: unexpected befaft") + (* code already processed by an enclosing iso *) + | Ast0.MINUS(mc) -> e + | _ -> + failwith + (Printf.sprintf + "%d: make_minus donothingxxx: unexpected mcodekind: %s" + info.Ast0.line_start (Dumper.dump e))) + | _ -> donothing r k e in + + V0.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + dots dots dots dots dots dots + donothing expression donothing initialiser donothing declaration + statement donothing donothing + +(* --------------------------------------------------------------------- *) +(* rebuild mcode cells in an instantiated alt *) + +(* mcodes will be side effected later with plus code, so we have to copy + them on instantiating an isomorphism. One could wonder whether it would + be better not to use side-effects, but they are convenient for insert_plus + where is it useful to manipulate a list of the mcodes but side-effect a + tree *) +(* hmm... Insert_plus is called before Iso_pattern... *) +let rebuild_mcode start_line = + let copy_mcodekind = function + Ast0.CONTEXT(mc) -> Ast0.CONTEXT(ref (!mc)) + | Ast0.MINUS(mc) -> Ast0.MINUS(ref (!mc)) + | Ast0.MIXED(mc) -> Ast0.MIXED(ref (!mc)) + | Ast0.PLUS -> + (* this function is used elsewhere where we need to rebuild the + indices, and so we allow PLUS code as well *) + Ast0.PLUS in + + let mcode (term,arity,info,mcodekind,pos) = + let info = + match start_line with + Some x -> {info with Ast0.line_start = x; Ast0.line_end = x} + | None -> info in + (term,arity,info,copy_mcodekind mcodekind,pos) in + + let copy_one x = + let old_info = Ast0.get_info x in + let info = + match start_line with + Some x -> {old_info with Ast0.line_start = x; Ast0.line_end = x} + | None -> old_info in + {x with Ast0.info = info; Ast0.index = ref(Ast0.get_index x); + Ast0.mcodekind = ref (copy_mcodekind (Ast0.get_mcodekind x))} in + + let donothing r k e = copy_one (k e) in + + (* case for control operators (if, etc) *) + let statement r k e = + let s = k e in + let res = + copy_one + (Ast0.rewrap s + (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.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,e1,sem1,e2,sem2,e3,rp,body,(info,mc)) -> + Ast0.For(fr,lp,e1,sem1,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)) + | Ast0.FunDecl + ((info,mc),fninfo,name,lp,params,rp,lbrace,body,rbrace) -> + Ast0.FunDecl + ((info,copy_mcodekind mc), + fninfo,name,lp,params,rp,lbrace,body,rbrace) + | s -> s)) in + Ast0.set_dots_bef_aft res + (match Ast0.get_dots_bef_aft res with + Ast0.NoDots -> Ast0.NoDots + | Ast0.AddingBetweenDots s -> + Ast0.AddingBetweenDots(r.V0.rebuilder_statement s) + | Ast0.DroppingBetweenDots s -> + Ast0.DroppingBetweenDots(r.V0.rebuilder_statement s)) in + + V0.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing + donothing statement donothing donothing + +(* --------------------------------------------------------------------- *) +(* The problem of whencode. If an isomorphism contains dots in multiple + rules, then the code that is matched cannot contain whencode, because we + won't know which dots it goes with. Should worry about nests, but they + aren't allowed in isomorphisms for the moment. *) + +let count_edots = + let mcode x = 0 in + let option_default = 0 in + let bind x y = x + y in + let donothing r k e = k e in + let exprfn r k e = + match Ast0.unwrap e with + Ast0.Edots(_,_) | Ast0.Ecircles(_,_) | Ast0.Estars(_,_) -> 1 + | _ -> 0 in + + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing exprfn donothing donothing donothing donothing donothing + donothing donothing + +let count_idots = + let mcode x = 0 in + let option_default = 0 in + let bind x y = x + y in + let donothing r k e = k e in + let initfn r k e = + match Ast0.unwrap e with Ast0.Idots(_,_) -> 1 | _ -> 0 in + + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing initfn donothing donothing donothing + donothing donothing + +let count_dots = + let mcode x = 0 in + let option_default = 0 in + let bind x y = x + y in + let donothing r k e = k e in + let stmtfn r k e = + match Ast0.unwrap e with + Ast0.Dots(_,_) | Ast0.Circles(_,_) | Ast0.Stars(_,_) -> 1 + | _ -> 0 in + + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing stmtfn + donothing donothing + +(* --------------------------------------------------------------------- *) + +let lookup name bindings mv_bindings = + try Common.Left (List.assoc (term name) bindings) + with + Not_found -> + (* failure is not possible anymore *) + Common.Right (List.assoc (term name) mv_bindings) + +(* mv_bindings is for the fresh metavariables that are introduced by the +isomorphism *) +let instantiate bindings mv_bindings = + let mcode x = + match Ast0.get_pos x with + Ast0.MetaPos(name,_,_) -> + (try + match lookup name bindings mv_bindings with + Common.Left(Ast0.MetaPosTag(id)) -> Ast0.set_pos id x + | _ -> failwith "not possible" + with Not_found -> Ast0.set_pos Ast0.NoMetaPos x) + | _ -> x in + let donothing r k e = k e in + + (* cases where metavariables can occur *) + let identfn r k e = + let e = k e in + match Ast0.unwrap e with + Ast0.MetaId(name,constraints,pure) -> + (rebuild_mcode None).V0.rebuilder_ident + (match lookup name bindings mv_bindings with + Common.Left(Ast0.IdentTag(id)) -> id + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + Ast0.rewrap e + (Ast0.MetaId + (Ast0.set_mcode_data new_mv name,constraints,pure))) + | Ast0.MetaFunc(name,_,pure) -> failwith "metafunc not supported" + | Ast0.MetaLocalFunc(name,_,pure) -> failwith "metalocalfunc not supported" + | _ -> e in + + (* case for list metavariables *) + let rec elist r same_dots = function + [] -> [] + | [x] -> + (match Ast0.unwrap x with + Ast0.MetaExprList(name,lenname,pure) -> + failwith "meta_expr_list in iso not supported" + (*match lookup name bindings mv_bindings with + Common.Left(Ast0.DotsExprTag(exp)) -> + (match same_dots exp with + Some l -> l + | None -> failwith "dots put in incompatible context") + | Common.Left(Ast0.ExprTag(exp)) -> [exp] + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + failwith "MetaExprList in SP not supported"*) + | _ -> [r.V0.rebuilder_expression x]) + | x::xs -> (r.V0.rebuilder_expression x)::(elist r same_dots xs) in + + let rec plist r same_dots = function + [] -> [] + | [x] -> + (match Ast0.unwrap x with + Ast0.MetaParamList(name,lenname,pure) -> + failwith "meta_param_list in iso not supported" + (*match lookup name bindings mv_bindings with + Common.Left(Ast0.DotsParamTag(param)) -> + (match same_dots param with + Some l -> l + | None -> failwith "dots put in incompatible context") + | Common.Left(Ast0.ParamTag(param)) -> [param] + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + failwith "MetaExprList in SP not supported"*) + | _ -> [r.V0.rebuilder_parameter x]) + | x::xs -> (r.V0.rebuilder_parameter x)::(plist r same_dots xs) in + + let rec slist r same_dots = function + [] -> [] + | [x] -> + (match Ast0.unwrap x with + Ast0.MetaStmtList(name,pure) -> + (match lookup name bindings mv_bindings with + Common.Left(Ast0.DotsStmtTag(stm)) -> + (match same_dots stm with + Some l -> l + | None -> failwith "dots put in incompatible context") + | Common.Left(Ast0.StmtTag(stm)) -> [stm] + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + failwith "MetaExprList in SP not supported") + | _ -> [r.V0.rebuilder_statement x]) + | x::xs -> (r.V0.rebuilder_statement x)::(slist r same_dots xs) in + + let same_dots d = + match Ast0.unwrap d with Ast0.DOTS(l) -> Some l |_ -> None in + let same_circles d = + match Ast0.unwrap d with Ast0.CIRCLES(l) -> Some l |_ -> None in + let same_stars d = + match Ast0.unwrap d with Ast0.STARS(l) -> Some l |_ -> None in + + let dots list_fn r k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(l) -> Ast0.DOTS(list_fn r same_dots l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(list_fn r same_circles l) + | Ast0.STARS(l) -> Ast0.STARS(list_fn r same_stars l)) in + + let exprfn r k old_e = (* need to keep the original code for ! optim *) + let e = k old_e in + let e1 = + match Ast0.unwrap e with + Ast0.MetaExpr(name,constraints,x,form,pure) -> + (rebuild_mcode None).V0.rebuilder_expression + (match lookup name bindings mv_bindings with + Common.Left(Ast0.ExprTag(exp)) -> exp + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + let new_types = + match x with + None -> None + | Some types -> + let rec renamer = function + Type_cocci.MetaType(name,keep,inherited) -> + (match + lookup (name,(),(),(),None) bindings mv_bindings + with + Common.Left(Ast0.TypeCTag(t)) -> + Ast0.ast0_type_to_type t + | Common.Left(_) -> + failwith "iso pattern: unexpected type" + | Common.Right(new_mv) -> + Type_cocci.MetaType(new_mv,keep,inherited)) + | Type_cocci.ConstVol(cv,ty) -> + Type_cocci.ConstVol(cv,renamer ty) + | Type_cocci.Pointer(ty) -> + Type_cocci.Pointer(renamer ty) + | Type_cocci.FunctionPointer(ty) -> + Type_cocci.FunctionPointer(renamer ty) + | Type_cocci.Array(ty) -> + Type_cocci.Array(renamer ty) + | t -> t in + Some(List.map renamer types) in + Ast0.rewrap e + (Ast0.MetaExpr + (Ast0.set_mcode_data new_mv name,constraints, + new_types,form,pure))) + | Ast0.MetaErr(namea,_,pure) -> failwith "metaerr not supported" + | Ast0.MetaExprList(namea,lenname,pure) -> + failwith "metaexprlist not supported" + | Ast0.Unary(exp,unop) -> + (match Ast0.unwrap_mcode unop with + Ast.Not -> + let was_meta = + (* k e doesn't change the outer structure of the term, + only the metavars *) + match Ast0.unwrap old_e with + Ast0.Unary(exp,_) -> + (match Ast0.unwrap exp with + Ast0.MetaExpr(name,constraints,x,form,pure) -> true + | _ -> false) + | _ -> failwith "not possible" in + let nomodif e = + let mc = Ast0.get_mcodekind exp in + match mc with + Ast0.MINUS(x) -> + (match !x with + ([],_) -> true + | _ -> false) + | Ast0.CONTEXT(x) | Ast0.MIXED(x) -> + (match !x with + (Ast.NOTHING,_,_) -> true + | _ -> false) + | _ -> failwith "plus not possible" in + if was_meta && nomodif exp && nomodif e + then + let idcont x = x in + let rec negate e (*for rewrapping*) res (*code to process*) k = + (* k accumulates parens, to keep negation outside if no + propagation is possible *) + match Ast0.unwrap res with + Ast0.Unary(e1,op) when Ast0.unwrap_mcode op = Ast.Not -> + k (Ast0.rewrap e (Ast0.unwrap e1)) + | Ast0.Edots(_,_) -> k (Ast0.rewrap e (Ast0.unwrap res)) + | Ast0.Paren(lp,e,rp) -> + negate e e + (function x -> + k (Ast0.rewrap res (Ast0.Paren(lp,x,rp)))) + | Ast0.Binary(e1,op,e2) -> + let reb nop = Ast0.rewrap_mcode op (Ast.Logical(nop)) in + let k1 x = k (Ast0.rewrap e x) in + (match Ast0.unwrap_mcode op with + Ast.Logical(Ast.Inf) -> + k1 (Ast0.Binary(e1,reb Ast.SupEq,e2)) + | Ast.Logical(Ast.Sup) -> + k1 (Ast0.Binary(e1,reb Ast.InfEq,e2)) + | Ast.Logical(Ast.InfEq) -> + k1 (Ast0.Binary(e1,reb Ast.Sup,e2)) + | Ast.Logical(Ast.SupEq) -> + k1 (Ast0.Binary(e1,reb Ast.Inf,e2)) + | Ast.Logical(Ast.Eq) -> + k1 (Ast0.Binary(e1,reb Ast.NotEq,e2)) + | Ast.Logical(Ast.NotEq) -> + k1 (Ast0.Binary(e1,reb Ast.Eq,e2)) + | Ast.Logical(Ast.AndLog) -> + k1 (Ast0.Binary(negate e1 e1 idcont,reb Ast.OrLog, + negate e2 e2 idcont)) + | Ast.Logical(Ast.OrLog) -> + k1 (Ast0.Binary(negate e1 e1 idcont,reb Ast.AndLog, + negate e2 e2 idcont)) + | _ -> + Ast0.rewrap e + (Ast0.Unary(k res,Ast0.rewrap_mcode op Ast.Not))) + | Ast0.DisjExpr(lp,exps,mids,rp) -> + (* use res because it is the transformed argument *) + let exps = List.map (function e -> negate e e k) exps in + Ast0.rewrap res (Ast0.DisjExpr(lp,exps,mids,rp)) + | _ -> + (*use e, because this might be the toplevel expression*) + Ast0.rewrap e + (Ast0.Unary(k res,Ast0.rewrap_mcode unop Ast.Not)) in + negate e exp idcont + else e + | _ -> e) + | Ast0.Edots(d,_) -> + (try + (match List.assoc (dot_term d) bindings with + Ast0.ExprTag(exp) -> Ast0.rewrap e (Ast0.Edots(d,Some exp)) + | _ -> failwith "unexpected binding") + with Not_found -> e) + | Ast0.Ecircles(d,_) -> + (try + (match List.assoc (dot_term d) bindings with + Ast0.ExprTag(exp) -> Ast0.rewrap e (Ast0.Ecircles(d,Some exp)) + | _ -> failwith "unexpected binding") + with Not_found -> e) + | Ast0.Estars(d,_) -> + (try + (match List.assoc (dot_term d) bindings with + Ast0.ExprTag(exp) -> Ast0.rewrap e (Ast0.Estars(d,Some exp)) + | _ -> failwith "unexpected binding") + with Not_found -> e) + | _ -> e in + if Ast0.get_test_exp old_e then Ast0.set_test_exp e1 else e1 in + + let tyfn r k e = + let e = k e in + match Ast0.unwrap e with + Ast0.MetaType(name,pure) -> + (rebuild_mcode None).V0.rebuilder_typeC + (match lookup name bindings mv_bindings with + Common.Left(Ast0.TypeCTag(ty)) -> ty + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + Ast0.rewrap e + (Ast0.MetaType(Ast0.set_mcode_data new_mv name,pure))) + | _ -> e in + + let declfn r k e = + let e = k e in + match Ast0.unwrap e with + Ast0.Ddots(d,_) -> + (try + (match List.assoc (dot_term d) bindings with + Ast0.DeclTag(exp) -> Ast0.rewrap e (Ast0.Ddots(d,Some exp)) + | _ -> failwith "unexpected binding") + with Not_found -> e) + | _ -> e in + + let paramfn r k e = + let e = k e in + match Ast0.unwrap e with + Ast0.MetaParam(name,pure) -> + (rebuild_mcode None).V0.rebuilder_parameter + (match lookup name bindings mv_bindings with + Common.Left(Ast0.ParamTag(param)) -> param + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + Ast0.rewrap e + (Ast0.MetaParam(Ast0.set_mcode_data new_mv name, pure))) + | Ast0.MetaParamList(name,lenname,pure) -> + failwith "metaparamlist not supported" + | _ -> e in + + let whenfn (_,v) = + match v with + Ast0.DotsStmtTag(stms) -> Ast0.WhenNot stms + | Ast0.StmtTag(stm) -> Ast0.WhenAlways stm + | Ast0.IsoWhenTTag(stm) -> Ast0.WhenNotTrue stm + | Ast0.IsoWhenFTag(stm) -> Ast0.WhenNotFalse stm + | Ast0.IsoWhenTag(x) -> Ast0.WhenModifier(x) + | _ -> failwith "unexpected binding" in + + let stmtfn r k e = + let e = k e in + match Ast0.unwrap e with + Ast0.MetaStmt(name,pure) -> + (rebuild_mcode None).V0.rebuilder_statement + (match lookup name bindings mv_bindings with + Common.Left(Ast0.StmtTag(stm)) -> stm + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + Ast0.rewrap e + (Ast0.MetaStmt(Ast0.set_mcode_data new_mv name,pure))) + | Ast0.MetaStmtList(name,pure) -> failwith "metastmtlist not supported" + | Ast0.Dots(d,_) -> + Ast0.rewrap e + (Ast0.Dots + (d, + List.map whenfn + (List.filter (function (x,v) -> x = (dot_term d)) bindings))) + | Ast0.Circles(d,_) -> + Ast0.rewrap e + (Ast0.Circles + (d, + List.map whenfn + (List.filter (function (x,v) -> x = (dot_term d)) bindings))) + | Ast0.Stars(d,_) -> + Ast0.rewrap e + (Ast0.Stars + (d, + List.map whenfn + (List.filter (function (x,v) -> x = (dot_term d)) bindings))) + | _ -> e in + + V0.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + (dots elist) donothing (dots plist) (dots slist) donothing donothing + identfn exprfn tyfn donothing paramfn declfn stmtfn donothing donothing + +(* --------------------------------------------------------------------- *) + +let is_minus e = + match Ast0.get_mcodekind e with Ast0.MINUS(cell) -> true | _ -> false + +let context_required e = not(is_minus e) && not !Flag.sgrep_mode2 + +let disj_fail bindings e = + match bindings with + Some x -> Printf.fprintf stderr "no disj available at this type"; e + | None -> e + +(* isomorphism code is by default CONTEXT *) +let merge_plus model_mcode e_mcode = + match model_mcode with + Ast0.MINUS(mc) -> + (* add the replacement information at the root *) + (match e_mcode with + Ast0.MINUS(emc) -> + emc := + (match (!mc,!emc) with + (([],_),(x,t)) | ((x,_),([],t)) -> (x,t) + | _ -> failwith "how can we combine minuses?") + | _ -> failwith "not possible 6") + | Ast0.CONTEXT(mc) -> + (match e_mcode with + Ast0.CONTEXT(emc) -> + (* keep the logical line info as in the model *) + let (mba,tb,ta) = !mc in + let (eba,_,_) = !emc in + (* merging may be required when a term is replaced by a subterm *) + let merged = + match (mba,eba) with + (x,Ast.NOTHING) | (Ast.NOTHING,x) -> x + | (Ast.BEFORE(b1),Ast.BEFORE(b2)) -> Ast.BEFORE(b1@b2) + | (Ast.BEFORE(b),Ast.AFTER(a)) -> Ast.BEFOREAFTER(b,a) + | (Ast.BEFORE(b1),Ast.BEFOREAFTER(b2,a)) -> + Ast.BEFOREAFTER(b1@b2,a) + | (Ast.AFTER(a),Ast.BEFORE(b)) -> Ast.BEFOREAFTER(b,a) + | (Ast.AFTER(a1),Ast.AFTER(a2)) ->Ast.AFTER(a2@a1) + | (Ast.AFTER(a1),Ast.BEFOREAFTER(b,a2)) -> Ast.BEFOREAFTER(b,a2@a1) + | (Ast.BEFOREAFTER(b1,a),Ast.BEFORE(b2)) -> + Ast.BEFOREAFTER(b1@b2,a) + | (Ast.BEFOREAFTER(b,a1),Ast.AFTER(a2)) -> + Ast.BEFOREAFTER(b,a2@a1) + | (Ast.BEFOREAFTER(b1,a1),Ast.BEFOREAFTER(b2,a2)) -> + Ast.BEFOREAFTER(b1@b2,a2@a1) in + emc := (merged,tb,ta) + | Ast0.MINUS(emc) -> + let (anything_bef_aft,_,_) = !mc in + let (anythings,t) = !emc in + emc := + (match anything_bef_aft with + Ast.BEFORE(b) -> (b@anythings,t) + | Ast.AFTER(a) -> (anythings@a,t) + | Ast.BEFOREAFTER(b,a) -> (b@anythings@a,t) + | Ast.NOTHING -> (anythings,t)) + | _ -> failwith "not possible 7") + | Ast0.MIXED(_) -> failwith "not possible 8" + | Ast0.PLUS -> failwith "not possible 9" + +let copy_plus printer minusify model e = + if !Flag.sgrep_mode2 + then e (* no plus code, can cause a "not possible" error, so just avoid it *) + else + let e = + match Ast0.get_mcodekind model with + Ast0.MINUS(mc) -> minusify e + | Ast0.CONTEXT(mc) -> e + | _ -> failwith "not possible: copy_plus\n" in + merge_plus (Ast0.get_mcodekind model) (Ast0.get_mcodekind e); + e + +let copy_minus printer minusify model e = + match Ast0.get_mcodekind model with + Ast0.MINUS(mc) -> minusify e + | Ast0.CONTEXT(mc) -> e + | Ast0.MIXED(_) -> + if !Flag.sgrep_mode2 + then e + else failwith "not possible 8" + | Ast0.PLUS -> failwith "not possible 9" + +let whencode_allowed prev_ecount prev_icount prev_dcount + ecount icount dcount rest = + (* actually, if ecount or dcount is 0, the flag doesn't matter, because it + won't be tested *) + let other_ecount = (* number of edots *) + List.fold_left (function rest -> function (_,ec,ic,dc) -> ec + rest) + prev_ecount rest in + let other_icount = (* number of dots *) + List.fold_left (function rest -> function (_,ec,ic,dc) -> ic + rest) + prev_icount rest in + let other_dcount = (* number of dots *) + List.fold_left (function rest -> function (_,ec,ic,dc) -> dc + rest) + prev_dcount rest in + (ecount = 0 or other_ecount = 0, icount = 0 or other_icount = 0, + dcount = 0 or other_dcount = 0) + +(* copy the befores and afters to the instantiated code *) +let extra_copy_stmt_plus model e = + (if not !Flag.sgrep_mode2 (* sgrep has no plus code, so nothing to do *) + then + (match Ast0.unwrap model with + Ast0.FunDecl((info,bef),_,_,_,_,_,_,_,_) + | Ast0.Decl((info,bef),_) -> + (match Ast0.unwrap e with + Ast0.FunDecl((info,bef1),_,_,_,_,_,_,_,_) + | 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)) -> + (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)) -> + merge_plus aft aft1 + | _ -> merge_plus aft (Ast0.get_mcodekind e)) + | _ -> ())); + e + +let extra_copy_other_plus model e = e + +(* --------------------------------------------------------------------- *) + +let mv_count = ref 0 +let new_mv (_,s) = + let ct = !mv_count in + mv_count := !mv_count + 1; + "_"^s^"_"^(string_of_int ct) + +let get_name = function + Ast.MetaIdDecl(ar,nm) -> + (nm,function nm -> Ast.MetaIdDecl(ar,nm)) + | Ast.MetaFreshIdDecl(ar,nm) -> + (nm,function nm -> Ast.MetaFreshIdDecl(ar,nm)) + | Ast.MetaTypeDecl(ar,nm) -> + (nm,function nm -> Ast.MetaTypeDecl(ar,nm)) + | Ast.MetaListlenDecl(nm) -> + failwith "should not be rebuilt" + | Ast.MetaParamDecl(ar,nm) -> + (nm,function nm -> Ast.MetaParamDecl(ar,nm)) + | Ast.MetaParamListDecl(ar,nm,nm1) -> + (nm,function nm -> Ast.MetaParamListDecl(ar,nm,nm1)) + | Ast.MetaConstDecl(ar,nm,ty) -> + (nm,function nm -> Ast.MetaConstDecl(ar,nm,ty)) + | Ast.MetaErrDecl(ar,nm) -> + (nm,function nm -> Ast.MetaErrDecl(ar,nm)) + | Ast.MetaExpDecl(ar,nm,ty) -> + (nm,function nm -> Ast.MetaExpDecl(ar,nm,ty)) + | Ast.MetaIdExpDecl(ar,nm,ty) -> + (nm,function nm -> Ast.MetaIdExpDecl(ar,nm,ty)) + | Ast.MetaLocalIdExpDecl(ar,nm,ty) -> + (nm,function nm -> Ast.MetaLocalIdExpDecl(ar,nm,ty)) + | Ast.MetaExpListDecl(ar,nm,nm1) -> + (nm,function nm -> Ast.MetaExpListDecl(ar,nm,nm1)) + | Ast.MetaStmDecl(ar,nm) -> + (nm,function nm -> Ast.MetaStmDecl(ar,nm)) + | Ast.MetaStmListDecl(ar,nm) -> + (nm,function nm -> Ast.MetaStmListDecl(ar,nm)) + | Ast.MetaFuncDecl(ar,nm) -> + (nm,function nm -> Ast.MetaFuncDecl(ar,nm)) + | Ast.MetaLocalFuncDecl(ar,nm) -> + (nm,function nm -> Ast.MetaLocalFuncDecl(ar,nm)) + | Ast.MetaPosDecl(ar,nm) -> + (nm,function nm -> Ast.MetaPosDecl(ar,nm)) + | Ast.MetaDeclarerDecl(ar,nm) -> + (nm,function nm -> Ast.MetaDeclarerDecl(ar,nm)) + | Ast.MetaIteratorDecl(ar,nm) -> + (nm,function nm -> Ast.MetaIteratorDecl(ar,nm)) + +let make_new_metavars metavars bindings = + let new_metavars = + List.filter + (function mv -> + let (s,_) = get_name mv in + try let _ = List.assoc s bindings in false with Not_found -> true) + metavars in + List.split + (List.map + (function mv -> + let (s,rebuild) = get_name mv in + let new_s = (!current_rule,new_mv s) in + (rebuild new_s, (s,new_s))) + new_metavars) + +(* --------------------------------------------------------------------- *) + +let do_nothing x = x + +let mkdisj matcher metavars alts e instantiater mkiso disj_maker minusify + rebuild_mcodes name printer extra_plus update_others = + let call_instantiate bindings mv_bindings alts = + List.concat + (List.map + (function (a,_,_,_) -> + nub + (* no need to create duplicates when the bindings have no effect *) + (List.map + (function bindings -> + Ast0.set_iso + (copy_plus printer minusify e + (extra_plus e + (instantiater bindings mv_bindings + (rebuild_mcodes a)))) + (Common.union_set [(name,mkiso a)] (Ast0.get_iso e))) + bindings)) + alts) in + let rec inner_loop all_alts prev_ecount prev_icount prev_dcount = function + [] -> Common.Left (prev_ecount, prev_icount, prev_dcount) + | ((pattern,ecount,icount,dcount)::rest) -> + let wc = + whencode_allowed prev_ecount prev_icount prev_dcount + ecount dcount icount rest in + (match matcher true (context_required e) wc pattern e init_env with + Fail(reason) -> + if reason = NonMatch || not !Flag_parsing_cocci.show_iso_failures + then () + else + (match matcher false false wc pattern e init_env with + OK _ -> + interpret_reason name (Ast0.get_line e) reason + (function () -> printer e) + | _ -> ()); + inner_loop all_alts (prev_ecount + ecount) (prev_icount + icount) + (prev_dcount + dcount) rest + | OK (bindings : (((string * string) * 'a) list list)) -> + let all_alts = + (* apply update_others to all patterns other than the matched + one. This is used to desigate the others as test + expressions in the TestExpression case *) + (List.map + (function (x,e,i,d) as all -> + if x = pattern + then all + else (update_others x,e,i,d)) + (List.hd all_alts)) :: + (List.map + (List.map (function (x,e,i,d) -> (update_others x,e,i,d))) + (List.tl all_alts)) in + (match List.concat all_alts with + [x] -> Common.Left (prev_ecount, prev_icount, prev_dcount) + | all_alts -> + let (new_metavars,mv_bindings) = + make_new_metavars metavars (nub(List.concat bindings)) in + Common.Right + (new_metavars, + call_instantiate bindings mv_bindings all_alts))) in + let rec outer_loop prev_ecount prev_icount prev_dcount = function + [] | [[_]] (*only one alternative*) -> ([],e) (* nothing matched *) + | (alts::rest) as all_alts -> + match inner_loop all_alts prev_ecount prev_icount prev_dcount alts with + Common.Left(prev_ecount, prev_icount, prev_dcount) -> + outer_loop prev_ecount prev_icount prev_dcount rest + | Common.Right (new_metavars,res) -> + (new_metavars, + copy_minus printer minusify e (disj_maker res)) in + outer_loop 0 0 0 alts + +(* no one should ever look at the information stored in these mcodes *) +let disj_starter lst = + let old_info = Ast0.get_info(List.hd lst) in + let info = + { old_info with + Ast0.line_end = old_info.Ast0.line_start; + Ast0.logical_end = old_info.Ast0.logical_start; + Ast0.attachable_start = false; Ast0.attachable_end = false; + Ast0.mcode_start = []; Ast0.mcode_end = []; + Ast0.strings_before = []; Ast0.strings_after = [] } in + Ast0.make_mcode_info "(" info + +let disj_ender lst = + let old_info = Ast0.get_info(List.hd lst) in + let info = + { old_info with + Ast0.line_start = old_info.Ast0.line_end; + Ast0.logical_start = old_info.Ast0.logical_end; + Ast0.attachable_start = false; Ast0.attachable_end = false; + Ast0.mcode_start = []; Ast0.mcode_end = []; + Ast0.strings_before = []; Ast0.strings_after = [] } in + Ast0.make_mcode_info ")" info + +let disj_mid _ = Ast0.make_mcode "|" + +let make_disj_type tl = + let mids = + match tl with + [] -> failwith "bad disjunction" + | x::xs -> List.map disj_mid xs in + Ast0.context_wrap (Ast0.DisjType(disj_starter tl,tl,mids,disj_ender tl)) +let make_disj_stmt_list tl = + let mids = + match tl with + [] -> failwith "bad disjunction" + | x::xs -> List.map disj_mid xs in + Ast0.context_wrap (Ast0.Disj(disj_starter tl,tl,mids,disj_ender tl)) +let make_disj_expr model el = + let mids = + match el with + [] -> failwith "bad disjunction" + | x::xs -> List.map disj_mid xs in + let update_arg x = + if Ast0.get_arg_exp model then Ast0.set_arg_exp x else x in + let update_test x = + let x = if Ast0.get_test_pos model then Ast0.set_test_pos x else x in + if Ast0.get_test_exp model then Ast0.set_test_exp x else x in + let el = List.map update_arg (List.map update_test el) in + Ast0.context_wrap (Ast0.DisjExpr(disj_starter el,el,mids,disj_ender el)) +let make_disj_decl dl = + let mids = + match dl with + [] -> failwith "bad disjunction" + | x::xs -> List.map disj_mid xs in + Ast0.context_wrap (Ast0.DisjDecl(disj_starter dl,dl,mids,disj_ender dl)) +let make_disj_stmt sl = + let dotify x = Ast0.context_wrap (Ast0.DOTS[x]) in + let mids = + match sl with + [] -> failwith "bad disjunction" + | x::xs -> List.map disj_mid xs in + Ast0.context_wrap + (Ast0.Disj(disj_starter sl,List.map dotify sl,mids,disj_ender sl)) + +let transform_type (metavars,alts,name) e = + match alts with + (Ast0.TypeCTag(_)::_)::_ -> + (* start line is given to any leaves in the iso code *) + let start_line = Some ((Ast0.get_info e).Ast0.line_start) in + let alts = + List.map + (List.map + (function + Ast0.TypeCTag(p) -> + (p,count_edots.V0.combiner_typeC p, + count_idots.V0.combiner_typeC p, + count_dots.V0.combiner_typeC p) + | _ -> failwith "invalid alt")) + alts in + mkdisj match_typeC metavars alts e + (function b -> function mv_b -> + (instantiate b mv_b).V0.rebuilder_typeC) + (function t -> Ast0.TypeCTag t) + make_disj_type make_minus.V0.rebuilder_typeC + (rebuild_mcode start_line).V0.rebuilder_typeC + name Unparse_ast0.typeC extra_copy_other_plus do_nothing + | _ -> ([],e) + + +let transform_expr (metavars,alts,name) e = + let process update_others = + (* start line is given to any leaves in the iso code *) + let start_line = Some ((Ast0.get_info e).Ast0.line_start) in + let alts = + List.map + (List.map + (function + Ast0.ExprTag(p) | Ast0.ArgExprTag(p) | Ast0.TestExprTag(p) -> + (p,count_edots.V0.combiner_expression p, + count_idots.V0.combiner_expression p, + count_dots.V0.combiner_expression p) + | _ -> failwith "invalid alt")) + alts in + mkdisj match_expr metavars alts e + (function b -> function mv_b -> + (instantiate b mv_b).V0.rebuilder_expression) + (function e -> Ast0.ExprTag e) + (make_disj_expr e) + make_minus.V0.rebuilder_expression + (rebuild_mcode start_line).V0.rebuilder_expression + name Unparse_ast0.expression extra_copy_other_plus update_others in + match alts with + (Ast0.ExprTag(_)::_)::_ -> process do_nothing + | (Ast0.ArgExprTag(_)::_)::_ when Ast0.get_arg_exp e -> process do_nothing + | (Ast0.TestExprTag(_)::_)::_ when Ast0.get_test_pos e -> + process Ast0.set_test_exp + | _ -> ([],e) + +let transform_decl (metavars,alts,name) e = + match alts with + (Ast0.DeclTag(_)::_)::_ -> + (* start line is given to any leaves in the iso code *) + let start_line = Some (Ast0.get_info e).Ast0.line_start in + let alts = + List.map + (List.map + (function + Ast0.DeclTag(p) -> + (p,count_edots.V0.combiner_declaration p, + count_idots.V0.combiner_declaration p, + count_dots.V0.combiner_declaration p) + | _ -> failwith "invalid alt")) + alts in + mkdisj match_decl metavars alts e + (function b -> function mv_b -> + (instantiate b mv_b).V0.rebuilder_declaration) + (function d -> Ast0.DeclTag d) + make_disj_decl + make_minus.V0.rebuilder_declaration + (rebuild_mcode start_line).V0.rebuilder_declaration + name Unparse_ast0.declaration extra_copy_other_plus do_nothing + | _ -> ([],e) + +let transform_stmt (metavars,alts,name) e = + match alts with + (Ast0.StmtTag(_)::_)::_ -> + (* start line is given to any leaves in the iso code *) + let start_line = Some (Ast0.get_info e).Ast0.line_start in + let alts = + List.map + (List.map + (function + Ast0.StmtTag(p) -> + (p,count_edots.V0.combiner_statement p, + count_idots.V0.combiner_statement p, + count_dots.V0.combiner_statement p) + | _ -> failwith "invalid alt")) + alts in + mkdisj match_statement metavars alts e + (function b -> function mv_b -> + (instantiate b mv_b).V0.rebuilder_statement) + (function s -> Ast0.StmtTag s) + make_disj_stmt make_minus.V0.rebuilder_statement + (rebuild_mcode start_line).V0.rebuilder_statement + name (Unparse_ast0.statement "") extra_copy_stmt_plus do_nothing + | _ -> ([],e) + +(* sort of a hack, because there is no disj at top level *) +let transform_top (metavars,alts,name) e = + match Ast0.unwrap e with + Ast0.DECL(declstm) -> + (try + let strip alts = + List.map + (List.map + (function + Ast0.DotsStmtTag(d) -> + (match Ast0.unwrap d with + Ast0.DOTS([s]) -> Ast0.StmtTag(s) + | _ -> raise (Failure "")) + | _ -> raise (Failure ""))) + alts in + let (mv,s) = transform_stmt (metavars,strip alts,name) declstm in + (mv,Ast0.rewrap e (Ast0.DECL(s))) + with Failure _ -> ([],e)) + | Ast0.CODE(stmts) -> + let (mv,res) = + match alts with + (Ast0.DotsStmtTag(_)::_)::_ -> + (* start line is given to any leaves in the iso code *) + let start_line = Some ((Ast0.get_info e).Ast0.line_start) in + let alts = + List.map + (List.map + (function + Ast0.DotsStmtTag(p) -> + (p,count_edots.V0.combiner_statement_dots p, + count_idots.V0.combiner_statement_dots p, + count_dots.V0.combiner_statement_dots p) + | _ -> failwith "invalid alt")) + alts in + mkdisj match_statement_dots metavars alts stmts + (function b -> function mv_b -> + (instantiate b mv_b).V0.rebuilder_statement_dots) + (function s -> Ast0.DotsStmtTag s) + (function x -> + Ast0.rewrap e (Ast0.DOTS([make_disj_stmt_list x]))) + (function x -> + make_minus.V0.rebuilder_statement_dots x) + (rebuild_mcode start_line).V0.rebuilder_statement_dots + name Unparse_ast0.statement_dots extra_copy_other_plus do_nothing + | _ -> ([],stmts) in + (mv,Ast0.rewrap e (Ast0.CODE res)) + | _ -> ([],e) + +(* --------------------------------------------------------------------- *) + +let transform (alts : isomorphism) t = + (* the following ugliness is because rebuilder only returns a new term *) + let extra_meta_decls = ref ([] : Ast_cocci.metavar list) in + let mcode x = x in + let donothing r k e = k e in + let exprfn r k e = + let (extra_meta,exp) = transform_expr alts (k e) in + extra_meta_decls := extra_meta @ !extra_meta_decls; + exp in + + let declfn r k e = + let (extra_meta,dec) = transform_decl alts (k e) in + extra_meta_decls := extra_meta @ !extra_meta_decls; + dec in + + let stmtfn r k e = + let (extra_meta,stm) = transform_stmt alts (k e) in + extra_meta_decls := extra_meta @ !extra_meta_decls; + stm in + + let typefn r k e = + let continue = + match Ast0.unwrap e with + Ast0.Signed(signb,tyb) -> + (* Hack! How else to prevent iso from applying under an + unsigned??? *) + e + | _ -> k e in + let (extra_meta,ty) = transform_type alts continue in + extra_meta_decls := extra_meta @ !extra_meta_decls; + ty in + + let topfn r k e = + let (extra_meta,ty) = transform_top alts (k e) in + extra_meta_decls := extra_meta @ !extra_meta_decls; + ty in + + let res = + V0.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing exprfn typefn donothing donothing declfn stmtfn + donothing topfn in + let res = res.V0.rebuilder_top_level t in + (!extra_meta_decls,res) + +(* --------------------------------------------------------------------- *) + +(* should be done by functorizing the parser to use wrap or context_wrap *) +let rewrap = + let mcode (x,a,i,mc,pos) = (x,a,i,Ast0.context_befaft(),pos) in + let donothing r k e = Ast0.context_wrap(Ast0.unwrap(k e)) in + V0.rebuilder + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing donothing + donothing donothing + +let rewrap_anything = function + Ast0.DotsExprTag(d) -> + Ast0.DotsExprTag(rewrap.V0.rebuilder_expression_dots d) + | Ast0.DotsInitTag(d) -> + Ast0.DotsInitTag(rewrap.V0.rebuilder_initialiser_list d) + | Ast0.DotsParamTag(d) -> + Ast0.DotsParamTag(rewrap.V0.rebuilder_parameter_list d) + | Ast0.DotsStmtTag(d) -> + Ast0.DotsStmtTag(rewrap.V0.rebuilder_statement_dots d) + | Ast0.DotsDeclTag(d) -> + Ast0.DotsDeclTag(rewrap.V0.rebuilder_declaration_dots d) + | Ast0.DotsCaseTag(d) -> + Ast0.DotsCaseTag(rewrap.V0.rebuilder_case_line_dots d) + | Ast0.IdentTag(d) -> Ast0.IdentTag(rewrap.V0.rebuilder_ident d) + | Ast0.ExprTag(d) -> Ast0.ExprTag(rewrap.V0.rebuilder_expression d) + | Ast0.ArgExprTag(d) -> Ast0.ArgExprTag(rewrap.V0.rebuilder_expression d) + | Ast0.TestExprTag(d) -> Ast0.TestExprTag(rewrap.V0.rebuilder_expression d) + | Ast0.TypeCTag(d) -> Ast0.TypeCTag(rewrap.V0.rebuilder_typeC d) + | Ast0.InitTag(d) -> Ast0.InitTag(rewrap.V0.rebuilder_initialiser d) + | Ast0.ParamTag(d) -> Ast0.ParamTag(rewrap.V0.rebuilder_parameter d) + | Ast0.DeclTag(d) -> Ast0.DeclTag(rewrap.V0.rebuilder_declaration d) + | Ast0.StmtTag(d) -> Ast0.StmtTag(rewrap.V0.rebuilder_statement d) + | Ast0.CaseLineTag(d) -> Ast0.CaseLineTag(rewrap.V0.rebuilder_case_line d) + | Ast0.TopTag(d) -> Ast0.TopTag(rewrap.V0.rebuilder_top_level d) + | Ast0.IsoWhenTag(_) | Ast0.IsoWhenTTag(_) | Ast0.IsoWhenFTag(_) -> + failwith "only for isos within iso phase" + | Ast0.MetaPosTag(p) -> Ast0.MetaPosTag(p) + +(* --------------------------------------------------------------------- *) + +let apply_isos isos rule rule_name = + if isos = [] + then ([],rule) + else + begin + current_rule := rule_name; + let isos = + List.map + (function (metavars,iso,name) -> + (metavars,List.map (List.map rewrap_anything) iso,name)) + isos in + let (extra_meta,rule) = + List.split + (List.map + (function t -> + List.fold_left + (function (extra_meta,t) -> function iso -> + let (new_extra_meta,t) = transform iso t in + (new_extra_meta@extra_meta,t)) + ([],t) isos) + rule) in + (List.concat extra_meta, Compute_lines.compute_lines rule) + end diff --git a/parsing_cocci/.#lexer_cocci.mll.1.84 b/parsing_cocci/.#lexer_cocci.mll.1.84 new file mode 100644 index 0000000..28e7093 --- /dev/null +++ b/parsing_cocci/.#lexer_cocci.mll.1.84 @@ -0,0 +1,704 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +{ +open Parser_cocci_menhir +module D = Data +module Ast = Ast_cocci +module Ast0 = Ast0_cocci +module P = Parse_aux +exception Lexical of string +let tok = Lexing.lexeme + +let line = ref 1 +let logical_line = ref 0 + +(* ---------------------------------------------------------------------- *) +(* control codes *) + +(* Defined in data.ml +type line_type = MINUS | OPTMINUS | UNIQUEMINUS | PLUS | CONTEXT | UNIQUE | OPT +*) + +let current_line_type = ref (D.CONTEXT,!line,!logical_line) + +let prev_plus = ref false +let line_start = ref 0 (* offset of the beginning of the line *) +let get_current_line_type lexbuf = + let (c,l,ll) = !current_line_type in + let lex_start = Lexing.lexeme_start lexbuf in + let preceeding_spaces = + if !line_start < 0 then 0 else lex_start - !line_start in + line_start := -1; + prev_plus := (c = D.PLUS); + (c,l,ll,lex_start,preceeding_spaces,[],[],Ast0.NoMetaPos) +let current_line_started = ref false +let col_zero = ref true + +let reset_line lexbuf = + line := !line + 1; + current_line_type := (D.CONTEXT,!line,!logical_line); + current_line_started := false; + col_zero := true; + line_start := Lexing.lexeme_start lexbuf + 1 + +let started_line = ref (-1) + +let start_line seen_char = + current_line_started := true; + col_zero := false; + (if seen_char && not(!line = !started_line) + then + begin + started_line := !line; + logical_line := !logical_line + 1 + end) + +let pass_zero _ = col_zero := false + +let lexerr s1 s2 = raise (Lexical (Printf.sprintf "%s%s" s1 s2)) + +let add_current_line_type x = + match (x,!current_line_type) with + (D.MINUS,(D.CONTEXT,ln,lln)) -> + current_line_type := (D.MINUS,ln,lln) + | (D.MINUS,(D.UNIQUE,ln,lln)) -> + current_line_type := (D.UNIQUEMINUS,ln,lln) + | (D.MINUS,(D.OPT,ln,lln)) -> + current_line_type := (D.OPTMINUS,ln,lln) + | (D.PLUS,(D.CONTEXT,ln,lln)) -> + current_line_type := (D.PLUS,ln,lln) + | (D.UNIQUE,(D.CONTEXT,ln,lln)) -> + current_line_type := (D.UNIQUE,ln,lln) + | (D.OPT,(D.CONTEXT,ln,lln)) -> + current_line_type := (D.OPT,ln,lln) + | _ -> lexerr "invalid control character combination" "" + +let check_minus_context_linetype s = + match !current_line_type with + (D.PLUS,_,_) -> lexerr "invalid in a + context: " s + | _ -> () + +let check_context_linetype s = + match !current_line_type with + (D.CONTEXT,_,_) -> () + | _ -> lexerr "invalid in a nonempty context: " s + +let check_plus_linetype s = + match !current_line_type with + (D.PLUS,_,_) -> () + | _ -> lexerr "invalid in a non + context: " s + +let check_arity_context_linetype s = + match !current_line_type with + (D.CONTEXT,_,_) | (D.PLUS,_,_) | (D.UNIQUE,_,_) | (D.OPT,_,_) -> () + | _ -> lexerr "invalid in a nonempty context: " s + +let process_include start finish str = + (match !current_line_type with + (D.PLUS,_,_) -> + (try + let _ = Str.search_forward (Str.regexp "\\.\\.\\.") str start in + lexerr "... not allowed in + include" "" + with Not_found -> ()) + | _ -> ()); + String.sub str (start + 1) (finish - start - 1) + +(* ---------------------------------------------------------------------- *) +type pm = PATCH | MATCH | UNKNOWN + +let pm = ref UNKNOWN + +let patch_or_match = function + PATCH -> + (match !pm with + MATCH -> lexerr "- or + not allowed in the first column for a match" "" + | PATCH -> () + | UNKNOWN -> Flag.sgrep_mode2 := false; pm := PATCH) + | MATCH -> + (match !pm with + PATCH -> lexerr "* not allowed in the first column for a patch" "" + | MATCH -> () + | UNKNOWN -> Flag.sgrep_mode2 := true; pm := MATCH) + | _ -> failwith "unexpected argument" + +(* ---------------------------------------------------------------------- *) +(* identifiers, including metavariables *) + +let metavariables = (Hashtbl.create(100) : (string, D.clt -> token) Hashtbl.t) + +let all_metavariables = + (Hashtbl.create(100) : (string,(string * (D.clt -> token)) list) Hashtbl.t) + +let type_names = (Hashtbl.create(100) : (string, D.clt -> token) Hashtbl.t) + +let declarer_names = (Hashtbl.create(100) : (string, D.clt -> token) Hashtbl.t) + +let iterator_names = (Hashtbl.create(100) : (string, D.clt -> token) Hashtbl.t) + +let rule_names = (Hashtbl.create(100) : (string, unit) Hashtbl.t) + +let check_var s linetype = + let fail _ = + if (!Data.in_prolog || !Data.in_rule_name) && + Str.string_match (Str.regexp "<.*>") s 0 + then TPathIsoFile s + else + try (Hashtbl.find metavariables s) linetype + with Not_found -> + (try (Hashtbl.find type_names s) linetype + with Not_found -> + (try (Hashtbl.find declarer_names s) linetype + with Not_found -> + (try (Hashtbl.find iterator_names s) linetype + with Not_found -> TIdent (s,linetype)))) in + if !Data.in_meta or !Data.in_rule_name + then (try Hashtbl.find rule_names s; TRuleName s with Not_found -> fail()) + else fail() + +let id_tokens lexbuf = + let s = tok lexbuf in + let linetype = get_current_line_type lexbuf in + let in_rule_name = !Data.in_rule_name in + let in_meta = !Data.in_meta in + let in_iso = !Data.in_iso in + let in_prolog = !Data.in_prolog in + match s with + "identifier" when in_meta -> check_arity_context_linetype s; TIdentifier + | "type" when in_meta -> check_arity_context_linetype s; TType + | "parameter" when in_meta -> check_arity_context_linetype s; TParameter + | "constant" when in_meta -> check_arity_context_linetype s; TConstant + | "generated" when in_rule_name && not (!Flag.make_hrule = None) -> + check_arity_context_linetype s; TGenerated + | "expression" when in_meta || in_rule_name -> + check_arity_context_linetype s; TExpression + | "idexpression" when in_meta -> + check_arity_context_linetype s; TIdExpression + | "statement" when in_meta -> check_arity_context_linetype s; TStatement + | "function" when in_meta -> check_arity_context_linetype s; TFunction + | "local" when in_meta -> check_arity_context_linetype s; TLocal + | "list" when in_meta -> check_arity_context_linetype s; Tlist + | "fresh" when in_meta -> check_arity_context_linetype s; TFresh + | "typedef" when in_meta -> check_arity_context_linetype s; TTypedef + | "declarer" when in_meta -> check_arity_context_linetype s; TDeclarer + | "iterator" when in_meta -> check_arity_context_linetype s; TIterator + | "name" when in_meta -> check_arity_context_linetype s; TName + | "position" when in_meta -> check_arity_context_linetype s; TPosition + | "any" when in_meta -> check_arity_context_linetype s; TPosAny + | "pure" when in_meta && in_iso -> + check_arity_context_linetype s; TPure + | "context" when in_meta && in_iso -> + check_arity_context_linetype s; TContext + | "error" when in_meta -> check_arity_context_linetype s; TError + | "words" when in_meta -> check_context_linetype s; TWords + + | "using" when in_rule_name || in_prolog -> check_context_linetype s; TUsing + | "disable" when in_rule_name -> check_context_linetype s; TDisable + | "extends" when in_rule_name -> check_context_linetype s; TExtends + | "depends" when in_rule_name -> check_context_linetype s; TDepends + | "on" when in_rule_name -> check_context_linetype s; TOn + | "ever" when in_rule_name -> check_context_linetype s; TEver + | "never" when in_rule_name -> check_context_linetype s; TNever + | "exists" when in_rule_name -> check_context_linetype s; TExists + | "forall" when in_rule_name -> check_context_linetype s; TForall + | "reverse" when in_rule_name -> check_context_linetype s; TReverse + | "script" when in_rule_name -> check_context_linetype s; TScript + + | "char" -> Tchar linetype + | "short" -> Tshort linetype + | "int" -> Tint linetype + | "double" -> Tdouble linetype + | "float" -> Tfloat linetype + | "long" -> Tlong linetype + | "void" -> Tvoid linetype + | "struct" -> Tstruct linetype + | "union" -> Tunion linetype + | "enum" -> Tenum linetype + | "unsigned" -> Tunsigned linetype + | "signed" -> Tsigned linetype + + | "auto" -> Tauto linetype + | "register" -> Tregister linetype + | "extern" -> Textern linetype + | "static" -> Tstatic linetype + | "inline" -> Tinline linetype + | "typedef" -> Ttypedef linetype + + | "const" -> Tconst linetype + | "volatile" -> Tvolatile linetype + + | "if" -> TIf linetype + | "else" -> TElse linetype + | "while" -> TWhile linetype + | "do" -> TDo linetype + | "for" -> TFor linetype + | "switch" -> TSwitch linetype + | "case" -> TCase linetype + | "default" -> TDefault linetype + | "return" -> TReturn linetype + | "break" -> TBreak linetype + | "continue" -> TContinue linetype + | "goto" -> TGoto linetype + + | "sizeof" -> TSizeof linetype + + | "Expression" -> TIsoExpression + | "ArgExpression" -> TIsoArgExpression + | "TestExpression" -> TIsoTestExpression + | "Statement" -> TIsoStatement + | "Declaration" -> TIsoDeclaration + | "Type" -> TIsoType + | "TopLevel" -> TIsoTopLevel + + | s -> check_var s linetype + +let mkassign op lexbuf = + TAssign (Ast.OpAssign op, (get_current_line_type lexbuf)) + +let init _ = + line := 1; + logical_line := 0; + prev_plus := false; + line_start := 0; + current_line_started := false; + col_zero := true; + pm := UNKNOWN; + Data.in_rule_name := false; + Data.in_meta := false; + Data.in_prolog := false; + Data.inheritable_positions := []; + Hashtbl.clear all_metavariables; + Hashtbl.clear Data.all_metadecls; + Hashtbl.clear metavariables; + Hashtbl.clear type_names; + Hashtbl.clear rule_names; + let get_name (_,x) = x in + Data.add_id_meta := + (fun name constraints pure -> + let fn clt = TMetaId(name,constraints,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_type_meta := + (fun name pure -> + let fn clt = TMetaType(name,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_param_meta := + (function name -> function pure -> + let fn clt = TMetaParam(name,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_paramlist_meta := + (function name -> function lenname -> function pure -> + let fn clt = TMetaParamList(name,lenname,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_const_meta := + (fun tyopt name constraints pure -> + let fn clt = TMetaConst(name,constraints,pure,tyopt,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_err_meta := + (fun name constraints pure -> + let fn clt = TMetaErr(name,constraints,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_exp_meta := + (fun tyopt name constraints pure -> + let fn clt = TMetaExp(name,constraints,pure,tyopt,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_idexp_meta := + (fun tyopt name constraints pure -> + let fn clt = TMetaIdExp(name,constraints,pure,tyopt,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_local_idexp_meta := + (fun tyopt name constraints pure -> + let fn clt = TMetaLocalIdExp(name,constraints,pure,tyopt,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_explist_meta := + (function name -> function lenname -> function pure -> + let fn clt = TMetaExpList(name,lenname,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_stm_meta := + (function name -> function pure -> + let fn clt = TMetaStm(name,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_stmlist_meta := + (function name -> function pure -> + let fn clt = TMetaStmList(name,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_func_meta := + (fun name constraints pure -> + let fn clt = TMetaFunc(name,constraints,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_local_func_meta := + (fun name constraints pure -> + let fn clt = TMetaLocalFunc(name,constraints,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_iterator_meta := + (fun name constraints pure -> + let fn clt = TMetaIterator(name,constraints,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_declarer_meta := + (fun name constraints pure -> + let fn clt = TMetaDeclarer(name,constraints,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_pos_meta := + (fun name constraints any -> + let fn ((d,ln,_,_,_,_,_,_) as clt) = + (if d = Data.PLUS + then + failwith + (Printf.sprintf "%d: positions only allowed in minus code" ln)); + TMetaPos(name,constraints,any,clt) in + Hashtbl.replace metavariables (get_name name) fn); + Data.add_type_name := + (function name -> + let fn clt = TTypeId(name,clt) in + Hashtbl.replace type_names name fn); + Data.add_declarer_name := + (function name -> + let fn clt = TDeclarerId(name,clt) in + Hashtbl.replace declarer_names name fn); + Data.add_iterator_name := + (function name -> + let fn clt = TIteratorId(name,clt) in + Hashtbl.replace iterator_names name fn); + Data.init_rule := (function _ -> Hashtbl.clear metavariables); + Data.install_bindings := + (function parent -> + List.iter (function (name,fn) -> Hashtbl.add metavariables name fn) + (Hashtbl.find all_metavariables parent)) + +let drop_spaces s = + let len = String.length s in + let rec loop n = + if n = len + then n + else + if List.mem (String.get s n) [' ';'\t'] + then loop (n+1) + else n in + let start = loop 0 in + String.sub s start (len - start) +} + +(* ---------------------------------------------------------------------- *) +(* tokens *) + +let letter = ['A'-'Z' 'a'-'z' '_'] +let digit = ['0'-'9'] + +let dec = ['0'-'9'] +let oct = ['0'-'7'] +let hex = ['0'-'9' 'a'-'f' 'A'-'F'] + +let decimal = ('0' | (['1'-'9'] dec*)) +let octal = ['0'] oct+ +let hexa = ("0x" |"0X") hex+ + +let pent = dec+ +let pfract = dec+ +let sign = ['-' '+'] +let exp = ['e''E'] sign? dec+ +let real = pent exp | ((pent? '.' pfract | pent '.' pfract? ) exp?) + + +rule token = parse + | [' ' '\t' ]+ { start_line false; token lexbuf } + | ['\n' '\r' '\011' '\012'] { reset_line lexbuf; token lexbuf } + + | "//" [^ '\n']* { start_line false; token lexbuf } + + | "@@" { start_line true; TArobArob } + | "@" { pass_zero(); + if !Data.in_rule_name or not !current_line_started + then (start_line true; TArob) + else (check_minus_context_linetype "@"; TPArob) } + + | "WHEN" | "when" + { start_line true; check_minus_context_linetype (tok lexbuf); + TWhen (get_current_line_type lexbuf) } + + | "..." + { start_line true; check_minus_context_linetype (tok lexbuf); + TEllipsis (get_current_line_type lexbuf) } +(* + | "ooo" + { start_line true; check_minus_context_linetype (tok lexbuf); + TCircles (get_current_line_type lexbuf) } + + | "***" + { start_line true; check_minus_context_linetype (tok lexbuf); + TStars (get_current_line_type lexbuf) } +*) + | "<..." { start_line true; check_context_linetype (tok lexbuf); + TOEllipsis (get_current_line_type lexbuf) } + | "...>" { start_line true; check_context_linetype (tok lexbuf); + TCEllipsis (get_current_line_type lexbuf) } + | "<+..." { start_line true; check_context_linetype (tok lexbuf); + TPOEllipsis (get_current_line_type lexbuf) } + | "...+>" { start_line true; check_context_linetype (tok lexbuf); + TPCEllipsis (get_current_line_type lexbuf) } +(* + | "" { start_line true; check_context_linetype (tok lexbuf); + TCCircles (get_current_line_type lexbuf) } + + | "<***" { start_line true; check_context_linetype (tok lexbuf); + TOStars (get_current_line_type lexbuf) } + | "***>" { start_line true; check_context_linetype (tok lexbuf); + TCStars (get_current_line_type lexbuf) } +*) + | "-" { pass_zero(); + if !current_line_started + then (start_line true; TMinus (get_current_line_type lexbuf)) + else (patch_or_match PATCH; + add_current_line_type D.MINUS; token lexbuf) } + | "+" { pass_zero(); + if !current_line_started + then (start_line true; TPlus (get_current_line_type lexbuf)) + else if !Data.in_meta + then TPlus0 + else (patch_or_match PATCH; + add_current_line_type D.PLUS; token lexbuf) } + | "?" { pass_zero(); + if !current_line_started + then (start_line true; TWhy (get_current_line_type lexbuf)) + else if !Data.in_meta + then TWhy0 + else (add_current_line_type D.OPT; token lexbuf) } + | "!" { pass_zero(); + if !current_line_started + then (start_line true; TBang (get_current_line_type lexbuf)) + else if !Data.in_meta + then TBang0 + else (add_current_line_type D.UNIQUE; token lexbuf) } + | "(" { if not !col_zero + then (start_line true; TOPar (get_current_line_type lexbuf)) + else + (start_line true; check_context_linetype (tok lexbuf); + TOPar0 (get_current_line_type lexbuf))} + | "\\(" { start_line true; TOPar0 (get_current_line_type lexbuf) } + | "|" { if not (!col_zero) + then (start_line true; TOr(get_current_line_type lexbuf)) + else (start_line true; + check_context_linetype (tok lexbuf); + TMid0 (get_current_line_type lexbuf))} + | "\\|" { start_line true; TMid0 (get_current_line_type lexbuf) } + | ")" { if not !col_zero + then (start_line true; TCPar (get_current_line_type lexbuf)) + else + (start_line true; check_context_linetype (tok lexbuf); + TCPar0 (get_current_line_type lexbuf))} + | "\\)" { start_line true; TCPar0 (get_current_line_type lexbuf) } + + | '[' { start_line true; TOCro (get_current_line_type lexbuf) } + | ']' { start_line true; TCCro (get_current_line_type lexbuf) } + | '{' { start_line true; TOBrace (get_current_line_type lexbuf) } + | '}' { start_line true; TCBrace (get_current_line_type lexbuf) } + + | "->" { start_line true; TPtrOp (get_current_line_type lexbuf) } + | '.' { start_line true; TDot (get_current_line_type lexbuf) } + | ',' { start_line true; TComma (get_current_line_type lexbuf) } + | ";" { start_line true; + if !Data.in_meta + then TMPtVirg (* works better with tokens_all *) + else TPtVirg (get_current_line_type lexbuf) } + + + | '*' { pass_zero(); + if !current_line_started + then + (start_line true; TMul (get_current_line_type lexbuf)) + else + (patch_or_match MATCH; + add_current_line_type D.MINUS; token lexbuf) } + | '/' { start_line true; + TDmOp (Ast.Div,get_current_line_type lexbuf) } + | '%' { start_line true; + TDmOp (Ast.Mod,get_current_line_type lexbuf) } + | '~' { start_line true; TTilde (get_current_line_type lexbuf) } + + | "++" { start_line true; TInc (get_current_line_type lexbuf) } + | "--" { start_line true; TDec (get_current_line_type lexbuf) } + + | "=" { start_line true; TEq (get_current_line_type lexbuf) } + + | "-=" { start_line true; mkassign Ast.Minus lexbuf } + | "+=" { start_line true; mkassign Ast.Plus lexbuf } + + | "*=" { start_line true; mkassign Ast.Mul lexbuf } + | "/=" { start_line true; mkassign Ast.Div lexbuf } + | "%=" { start_line true; mkassign Ast.Mod lexbuf } + + | "&=" { start_line true; mkassign Ast.And lexbuf } + | "|=" { start_line true; mkassign Ast.Or lexbuf } + | "^=" { start_line true; mkassign Ast.Xor lexbuf } + + | "<<=" { start_line true; mkassign Ast.DecLeft lexbuf } + | ">>=" { start_line true; mkassign Ast.DecRight lexbuf } + + | ":" { start_line true; TDotDot (get_current_line_type lexbuf) } + + | "==" { start_line true; TEqEq (get_current_line_type lexbuf) } + | "!=" { start_line true; TNotEq (get_current_line_type lexbuf) } + | ">=" { start_line true; + TLogOp(Ast.SupEq,get_current_line_type lexbuf) } + | "<=" { start_line true; + TLogOp(Ast.InfEq,get_current_line_type lexbuf) } + | "<" { start_line true; + TLogOp(Ast.Inf,get_current_line_type lexbuf) } + | ">" { start_line true; + TLogOp(Ast.Sup,get_current_line_type lexbuf) } + + | "&&" { start_line true; TAndLog (get_current_line_type lexbuf) } + | "||" { start_line true; TOrLog (get_current_line_type lexbuf) } + + | ">>" { start_line true; + TShOp(Ast.DecRight,get_current_line_type lexbuf) } + | "<<" { start_line true; + TShOp(Ast.DecLeft,get_current_line_type lexbuf) } + + | "&" { start_line true; TAnd (get_current_line_type lexbuf) } + | "^" { start_line true; TXor(get_current_line_type lexbuf) } + + | ( ("#" [' ' '\t']* "define" [' ' '\t']+)) + ( (letter (letter |digit)*) as ident) + { start_line true; + let (arity,line,lline,offset,col,strbef,straft,pos) as lt = + get_current_line_type lexbuf in + let off = String.length "#define " in + (* -1 in the code below because the ident is not at the line start *) + TDefine + (lt, + check_var ident + (arity,line,lline,offset+off,(-1),[],[],Ast0.NoMetaPos)) } + | ( ("#" [' ' '\t']* "define" [' ' '\t']+)) + ( (letter (letter | digit)*) as ident) + '(' + { start_line true; + let (arity,line,lline,offset,col,strbef,straft,pos) as lt = + get_current_line_type lexbuf in + let off = String.length "#define " in + TDefineParam + (lt, + check_var ident + (* why pos here but not above? *) + (arity,line,lline,offset+off,(-1),strbef,straft,pos), + offset + off + (String.length ident)) } + | "#" [' ' '\t']* "include" [' ' '\t']* '"' [^ '"']+ '"' + { TIncludeL + (let str = tok lexbuf 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']* '<' [^ '>']+ '>' + { TIncludeNL + (let str = tok lexbuf 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']* "if" [^'\n']* + | "#" [' ' '\t']* "ifdef" [^'\n']* + | "#" [' ' '\t']* "ifndef" [^'\n']* + | "#" [' ' '\t']* "else" [^'\n']* + | "#" [' ' '\t']* "elif" [^'\n']* + | "#" [' ' '\t']* "endif" [^'\n']* + | "#" [' ' '\t']* "error" [^'\n']* + { start_line true; check_plus_linetype (tok lexbuf); + TPragma (tok lexbuf) } + | "---" [^'\n']* + { (if !current_line_started + then lexerr "--- must be at the beginning of the line" ""); + start_line true; + TMinusFile + (let str = tok lexbuf in + (drop_spaces(String.sub str 3 (String.length str - 3)), + (get_current_line_type lexbuf))) } + | "+++" [^'\n']* + { (if !current_line_started + then lexerr "+++ must be at the beginning of the line" ""); + start_line true; + TPlusFile + (let str = tok lexbuf in + (drop_spaces(String.sub str 3 (String.length str - 3)), + (get_current_line_type lexbuf))) } + + | letter (letter | digit)* + { start_line true; id_tokens lexbuf } + + | "'" { start_line true; + TChar(char lexbuf,get_current_line_type lexbuf) } + | '"' { start_line true; + TString(string lexbuf,(get_current_line_type lexbuf)) } + | (real as x) { start_line true; + TFloat(x,(get_current_line_type lexbuf)) } + | ((( decimal | hexa | octal) + ( ['u' 'U'] + | ['l' 'L'] + | (['l' 'L'] ['u' 'U']) + | (['u' 'U'] ['l' 'L']) + | (['u' 'U'] ['l' 'L'] ['l' 'L']) + | (['l' 'L'] ['l' 'L']) + )? + ) as x) { start_line true; TInt(x,(get_current_line_type lexbuf)) } + + | "<=>" { TIso } + | "=>" { TRightIso } + + | eof { EOF } + + | _ { lexerr "unrecognised symbol, in token rule: " (tok lexbuf) } + + +and char = parse + | (_ as x) "'" { String.make 1 x } + | (("\\" (oct | oct oct | oct oct oct)) as x "'") { x } + | (("\\x" (hex | hex hex)) as x "'") { x } + | (("\\" (_ as v)) as x "'") + { (match v with + | 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () + | 'r' -> () | 'f' -> () | 'a' -> () + | '\\' -> () | '?' -> () | '\'' -> () | '"' -> () + | 'e' -> () + | _ -> lexerr "unrecognised symbol: " (tok lexbuf) + ); + x + } + | _ { lexerr "unrecognised symbol: " (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 } + | ("\\" (_ as v)) as x + { + (match v with + | 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> () + | 'f' -> () | 'a' -> () + | '\\' -> () | '?' -> () | '\'' -> () | '"' -> () + | 'e' -> () + | '\n' -> () + | _ -> lexerr "unrecognised symbol:" (tok lexbuf) + ); + x ^ string lexbuf + } + | _ { lexerr "unrecognised symbol: " (tok lexbuf) } diff --git a/parsing_cocci/.#parse_aux.ml.1.26 b/parsing_cocci/.#parse_aux.ml.1.26 new file mode 100644 index 0000000..1190521 --- /dev/null +++ b/parsing_cocci/.#parse_aux.ml.1.26 @@ -0,0 +1,475 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* exports everything, used only by parser_cocci_menhir.mly *) +module Ast0 = Ast0_cocci +module Ast = Ast_cocci + +(* types for metavariable tokens *) +type info = Ast.meta_name * Ast0.pure * Data.clt +type idinfo = Ast.meta_name * Data.iconstraints * Ast0.pure * Data.clt +type expinfo = Ast.meta_name * Data.econstraints * Ast0.pure * Data.clt +type tyinfo = Ast.meta_name * Ast0.typeC list * Ast0.pure * Data.clt +type list_info = Ast.meta_name * Ast.meta_name option * Ast0.pure * Data.clt +type typed_info = + Ast.meta_name * Data.econstraints * Ast0.pure * + Type_cocci.typeC list option * Data.clt +type pos_info = Ast.meta_name * Data.pconstraints * Ast.meta_collect * Data.clt + + +let get_option fn = function + None -> None + | Some x -> Some (fn x) + +let make_info line logical_line offset col strbef straft = + { Ast0.line_start = line; Ast0.line_end = line; + Ast0.logical_start = logical_line; Ast0.logical_end = logical_line; + Ast0.attachable_start = true; Ast0.attachable_end = true; + Ast0.mcode_start = []; Ast0.mcode_end = []; + Ast0.column = col; Ast0.offset = offset; + Ast0.strings_before = strbef; Ast0.strings_after = straft; } + +let clt2info (_,line,logical_line,offset,col,strbef,straft,pos) = + make_info line logical_line offset col strbef straft + +let drop_bef (arity,line,lline,offset,col,strbef,straft,pos) = + (arity,line,lline,offset,col,[],straft,pos) + +let drop_aft (arity,line,lline,offset,col,strbef,straft,pos) = + (arity,line,lline,offset,col,strbef,[],pos) + +let clt2mcode str = function + (Data.MINUS,line,lline,offset,col,strbef,straft,pos) -> + (str,Ast0.NONE,make_info line lline offset col strbef straft, + Ast0.MINUS(ref([],Ast0.default_token_info)),ref pos) + | (Data.OPTMINUS,line,lline,offset,col,strbef,straft,pos) -> + (str,Ast0.OPT,make_info line lline offset col strbef straft, + Ast0.MINUS(ref([],Ast0.default_token_info)),ref pos) + | (Data.UNIQUEMINUS,line,lline,offset,col,strbef,straft,pos) -> + (str,Ast0.UNIQUE,make_info line lline offset col strbef straft, + Ast0.MINUS(ref([],Ast0.default_token_info)),ref pos) + | (Data.PLUS,line,lline,offset,col,strbef,straft,pos) -> + (str,Ast0.NONE,make_info line lline offset col strbef straft,Ast0.PLUS, + ref pos) + | (Data.CONTEXT,line,lline,offset,col,strbef,straft,pos) -> + (str,Ast0.NONE,make_info line lline offset col strbef straft, + Ast0.CONTEXT(ref(Ast.NOTHING, + Ast0.default_token_info,Ast0.default_token_info)), + ref pos) + | (Data.OPT,line,lline,offset,col,strbef,straft,pos) -> + (str,Ast0.OPT,make_info line lline offset col strbef straft, + Ast0.CONTEXT(ref(Ast.NOTHING, + Ast0.default_token_info,Ast0.default_token_info)), + ref pos) + | (Data.UNIQUE,line,lline,offset,col,strbef,straft,pos) -> + (str,Ast0.UNIQUE,make_info line lline offset col strbef straft, + Ast0.CONTEXT(ref(Ast.NOTHING, + Ast0.default_token_info,Ast0.default_token_info)), + ref pos) + +let id2name (name, clt) = name +let id2clt (name, clt) = clt +let id2mcode (name, clt) = clt2mcode name clt + +let mkdots str (dot,whencode) = + match str with + "..." -> Ast0.wrap(Ast0.Dots(clt2mcode str dot, whencode)) + | "ooo" -> Ast0.wrap(Ast0.Circles(clt2mcode str dot, whencode)) + | "***" -> Ast0.wrap(Ast0.Stars(clt2mcode str dot, whencode)) + | _ -> failwith "cannot happen" + +let mkedots str (dot,whencode) = + match str with + "..." -> Ast0.wrap(Ast0.Edots(clt2mcode str dot, whencode)) + | "ooo" -> Ast0.wrap(Ast0.Ecircles(clt2mcode str dot, whencode)) + | "***" -> Ast0.wrap(Ast0.Estars(clt2mcode str dot, whencode)) + | _ -> failwith "cannot happen" + +let mkdpdots str dot = + match str with + "..." -> Ast0.wrap(Ast0.DPdots(clt2mcode str dot)) + | "ooo" -> Ast0.wrap(Ast0.DPcircles(clt2mcode str dot)) + | _ -> failwith "cannot happen" + +let mkidots str (dot,whencode) = + match str with + "..." -> Ast0.wrap(Ast0.Idots(clt2mcode str dot, whencode)) + | _ -> failwith "cannot happen" + +let mkddots str (dot,whencode) = + match (str,whencode) with + ("...",None) -> Ast0.wrap(Ast0.Ddots(clt2mcode str dot, None)) + | ("...",Some [w]) -> Ast0.wrap(Ast0.Ddots(clt2mcode str dot, Some w)) + | _ -> failwith "cannot happen" + +let mkpdots str dot = + match str with + "..." -> Ast0.wrap(Ast0.Pdots(clt2mcode str dot)) + | "ooo" -> Ast0.wrap(Ast0.Pcircles(clt2mcode str dot)) + | _ -> failwith "cannot happen" + +let arith_op ast_op left op right = + Ast0.wrap + (Ast0.Binary(left, clt2mcode (Ast.Arith ast_op) op, right)) + +let logic_op ast_op left op right = + Ast0.wrap + (Ast0.Binary(left, clt2mcode (Ast.Logical ast_op) op, right)) + +let make_cv cv ty = + match cv with None -> ty | Some x -> Ast0.wrap (Ast0.ConstVol(x,ty)) + +let top_dots l = + let circle x = + match Ast0.unwrap x with Ast0.Circles(_) -> true | _ -> false in + let star x = + match Ast0.unwrap x with Ast0.Stars(_) -> true | _ -> false in + if List.exists circle l + then Ast0.wrap(Ast0.CIRCLES(l)) + else + if List.exists star l + then Ast0.wrap(Ast0.STARS(l)) + else Ast0.wrap(Ast0.DOTS(l)) + +(* here the offset is that of the first in the sequence of *s, not that of +each * individually *) +let pointerify ty m = + List.fold_left + (function inner -> + function cur -> + Ast0.wrap(Ast0.Pointer(inner,clt2mcode "*" cur))) + ty m + +let ty_pointerify ty m = + List.fold_left + (function inner -> function cur -> Type_cocci.Pointer(inner)) + ty m + +(* Left is <=>, Right is =>. Collect <=>s. *) +(* The parser should have done this, with precedences. But whatever... *) +let iso_adjust fn first rest = + let rec loop = function + [] -> [[]] + | (Common.Left x)::rest -> + (match loop rest with + front::after -> (fn x::front)::after + | _ -> failwith "not possible") + | (Common.Right x)::rest -> + (match loop rest with + front::after -> []::(fn x::front)::after + | _ -> failwith "not possible") in + match loop rest with + front::after -> (fn first::front)::after + | _ -> failwith "not possible" + +let check_meta tok = + let lookup rule name = + try + let info = Hashtbl.find Data.all_metadecls rule in + List.find (function mv -> Ast.get_meta_name mv = (rule,name)) info + with + Not_found -> + raise + (Semantic_cocci.Semantic + ("bad rule "^rule^" or bad variable "^name)) in + match tok with + Ast.MetaIdDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaIdDecl(_,_) | Ast.MetaFreshIdDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaFreshIdDecl(Ast.NONE,(rule,name)) -> + raise + (Semantic_cocci.Semantic + "can't inherit the freshness of an identifier") + | Ast.MetaListlenDecl((rule,name)) -> + (match lookup rule name with + Ast.MetaListlenDecl(_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaTypeDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaTypeDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaParamDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaParamDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaParamListDecl(Ast.NONE,(rule,name),len_name) -> + (match lookup rule name with + Ast.MetaParamListDecl(_,_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaErrDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaErrDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaExpDecl(Ast.NONE,(rule,name),ty) -> + (match lookup rule name with + Ast.MetaExpDecl(_,_,ty1) when ty = ty1 -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaIdExpDecl(Ast.NONE,(rule,name),ty) -> + (match lookup rule name with + Ast.MetaIdExpDecl(_,_,ty1) when ty = ty1 -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaLocalIdExpDecl(Ast.NONE,(rule,name),ty) -> + (match lookup rule name with + Ast.MetaLocalIdExpDecl(_,_,ty1) when ty = ty1 -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaExpListDecl(Ast.NONE,(rule,name),len_name) -> + (match lookup rule name with + Ast.MetaExpListDecl(_,_,_) -> () + | Ast.MetaParamListDecl(_,_,_) when not (!Flag.make_hrule = None) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaStmDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaStmDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaStmListDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaStmListDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaFuncDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaFuncDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaLocalFuncDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaLocalFuncDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaConstDecl(Ast.NONE,(rule,name),ty) -> + (match lookup rule name with + Ast.MetaConstDecl(_,_,ty1) when ty = ty1 -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | Ast.MetaPosDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaPosDecl(_,_) -> + if not (List.mem rule !Data.inheritable_positions) + then + raise + (Semantic_cocci.Semantic + ("position cannot be inherited over modifications: "^name)) + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) + | _ -> + raise + (Semantic_cocci.Semantic ("arity not allowed on imported declaration")) + +let create_metadec ar ispure kindfn ids current_rule = + List.concat + (List.map + (function (rule,nm) -> + let (rule,checker) = + match rule with + None -> ((current_rule,nm),function x -> [Common.Left x]) + | Some rule -> + ((rule,nm), + function x -> check_meta x; [Common.Right x]) in + kindfn ar rule ispure checker) + ids) + +let create_metadec_ne ar ispure kindfn ids current_rule = + List.concat + (List.map + (function ((rule,nm),constraints) -> + let (rule,checker) = + match rule with + None -> ((current_rule,nm),function x -> [Common.Left x]) + | Some rule -> + ((rule,nm), + function x -> check_meta x; [Common.Right x]) in + kindfn ar rule ispure checker constraints) + ids) + +let create_metadec_ty ar ispure kindfn ids current_rule = + List.concat + (List.map + (function ((rule,nm),constraints) -> + let (rule,checker) = + match rule with + None -> ((current_rule,nm),function x -> [Common.Left x]) + | Some rule -> + ((rule,nm), + function x -> check_meta x; [Common.Right x]) in + kindfn ar rule ispure checker constraints) + ids) + +let create_len_metadec ar ispure kindfn lenid ids current_rule = + let lendec = + create_metadec Ast.NONE Ast0.Impure + (fun _ name _ check_meta -> check_meta(Ast.MetaListlenDecl(name))) + [lenid] current_rule in + let lenname = + match lendec with + [Common.Left (Ast.MetaListlenDecl(x))] -> x + | [Common.Right (Ast.MetaListlenDecl(x))] -> x + | _ -> failwith "unexpected length declaration" in + lendec@(create_metadec ar ispure (kindfn lenname) ids current_rule) + +(* ---------------------------------------------------------------------- *) + +let str2inc s = + let elements = Str.split (Str.regexp "/") s in + List.map (function "..." -> Ast.IncDots | s -> Ast.IncPath s) elements + +(* ---------------------------------------------------------------------- *) +(* statements *) + +let meta_stm name = + let (nm,pure,clt) = name in + Ast0.wrap(Ast0.MetaStmt(clt2mcode nm clt,pure)) + +let exp_stm exp pv = + Ast0.wrap(Ast0.ExprStatement (exp, clt2mcode ";" pv)) + +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()))) + +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()))) + +let forloop fr lp e1 sc1 e2 sc2 e3 rp s = + Ast0.wrap(Ast0.For(clt2mcode "for" fr,clt2mcode "(" lp,e1, + clt2mcode ";" sc1,e2, + clt2mcode ";" sc2,e3,clt2mcode ")" rp,s, + (Ast0.default_info(),Ast0.context_befaft()))) + +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()))) + +let doloop d s w lp e rp pv = + Ast0.wrap(Ast0.Do(clt2mcode "do" d,s,clt2mcode "while" w, + clt2mcode "(" lp,e,clt2mcode ")" rp, + clt2mcode ";" pv)) + +let iterator i lp e rp s = + Ast0.wrap(Ast0.Iterator(i,clt2mcode "(" lp,e,clt2mcode ")" rp,s, + (Ast0.default_info(),Ast0.context_befaft()))) + +let switch s lp e rp lb c rb = + Ast0.wrap(Ast0.Switch(clt2mcode "switch" s,clt2mcode "(" lp,e, + clt2mcode ")" rp,clt2mcode "{" lb, + Ast0.wrap(Ast0.DOTS(c)),clt2mcode "}" rb)) + +let ret_exp r e pv = + Ast0.wrap(Ast0.ReturnExpr(clt2mcode "return" r,e,clt2mcode ";" pv)) + +let ret r pv = + Ast0.wrap(Ast0.Return(clt2mcode "return" r,clt2mcode ";" pv)) + +let break b pv = + Ast0.wrap(Ast0.Break(clt2mcode "break" b,clt2mcode ";" pv)) + +let cont c pv = + Ast0.wrap(Ast0.Continue(clt2mcode "continue" c,clt2mcode ";" pv)) + +let label i dd = + Ast0.wrap(Ast0.Label(i,clt2mcode ":" dd)) + +let goto g i pv = + Ast0.wrap(Ast0.Goto(clt2mcode "goto" g,i,clt2mcode ";" pv)) + +let seq lb s rb = + Ast0.wrap(Ast0.Seq(clt2mcode "{" lb,s,clt2mcode "}" rb)) + +(* ---------------------------------------------------------------------- *) + +let make_iso_rule_name_result n = + (try let _ = Hashtbl.find Data.all_metadecls n in + raise (Semantic_cocci.Semantic ("repeated rule name")) + with Not_found -> ()); + Ast.CocciRulename (Some n,Ast.NoDep,[],[],Ast.Undetermined,false (*discarded*)) + +let make_cocci_rule_name_result nm d i a e ee = + match nm with + Some nm -> + let n = id2name nm in + (try let _ = Hashtbl.find Data.all_metadecls n in + raise (Semantic_cocci.Semantic ("repeated rule name")) + with Not_found -> ()); + Ast.CocciRulename (Some n,d,i,a,e,ee) + | None -> Ast.CocciRulename (None,d,i,a,e,ee) + +let make_generated_rule_name_result nm d i a e ee = + match nm with + Some nm -> + let n = id2name nm in + (try let _ = Hashtbl.find Data.all_metadecls n in + raise (Semantic_cocci.Semantic ("repeated rule name")) + with Not_found -> ()); + Ast.GeneratedRulename (Some n,d,i,a,e,ee) + | None -> Ast.GeneratedRulename (None,d,i,a,e,ee) + +let make_script_rule_name_result lang deps = + let l = id2name lang in + Ast.ScriptRulename (l,deps) diff --git a/parsing_cocci/.#parse_cocci.ml.1.178 b/parsing_cocci/.#parse_cocci.ml.1.178 new file mode 100644 index 0000000..bd217cc --- /dev/null +++ b/parsing_cocci/.#parse_cocci.ml.1.178 @@ -0,0 +1,1598 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* splits the entire file into minus and plus fragments, and parses each +separately (thus duplicating work for the parsing of the context elements) *) + +module D = Data +module PC = Parser_cocci_menhir +module V0 = Visitor_ast0 +module Ast = Ast_cocci +module Ast0 = Ast0_cocci +let pr = Printf.sprintf +(*let pr2 s = prerr_string s; prerr_string "\n"; flush stderr*) +let pr2 s = Printf.printf "%s\n" s + +(* for isomorphisms. all should be at the front!!! *) +let reserved_names = + ["all";"optional_storage";"optional_qualifier";"value_format";"comm_assoc"] + +(* ----------------------------------------------------------------------- *) +(* Debugging... *) + +let line_type (d,_,_,_,_,_,_,_) = d + +let line_type2c tok = + match line_type tok with + D.MINUS | D.OPTMINUS | D.UNIQUEMINUS -> ":-" + | D.PLUS -> ":+" + | D.CONTEXT | D.UNIQUE | D.OPT -> "" + +let token2c (tok,_) = + match tok with + PC.TIdentifier -> "identifier" + | PC.TType -> "type" + | PC.TParameter -> "parameter" + | PC.TConstant -> "constant" + | PC.TExpression -> "expression" + | PC.TIdExpression -> "idexpression" + | PC.TStatement -> "statement" + | PC.TPosition -> "position" + | PC.TPosAny -> "any" + | PC.TFunction -> "function" + | PC.TLocal -> "local" + | PC.Tlist -> "list" + | PC.TFresh -> "fresh" + | PC.TPure -> "pure" + | PC.TContext -> "context" + | PC.TTypedef -> "typedef" + | PC.TDeclarer -> "declarer" + | PC.TIterator -> "iterator" + | PC.TName -> "name" + | PC.TRuleName str -> "rule_name-"^str + | PC.TUsing -> "using" + | PC.TPathIsoFile str -> "path_iso_file-"^str + | PC.TDisable -> "disable" + | PC.TExtends -> "extends" + | PC.TDepends -> "depends" + | PC.TOn -> "on" + | PC.TEver -> "ever" + | PC.TNever -> "never" + | PC.TExists -> "exists" + | PC.TForall -> "forall" + | PC.TReverse -> "reverse" + | PC.TError -> "error" + | PC.TWords -> "words" + | PC.TGenerated -> "generated" + + | PC.TNothing -> "nothing" + + | PC.Tchar(clt) -> "char"^(line_type2c clt) + | PC.Tshort(clt) -> "short"^(line_type2c clt) + | PC.Tint(clt) -> "int"^(line_type2c clt) + | PC.Tdouble(clt) -> "double"^(line_type2c clt) + | PC.Tfloat(clt) -> "float"^(line_type2c clt) + | PC.Tlong(clt) -> "long"^(line_type2c clt) + | PC.Tvoid(clt) -> "void"^(line_type2c clt) + | PC.Tstruct(clt) -> "struct"^(line_type2c clt) + | PC.Tunion(clt) -> "union"^(line_type2c clt) + | PC.Tenum(clt) -> "enum"^(line_type2c clt) + | PC.Tunsigned(clt) -> "unsigned"^(line_type2c clt) + | PC.Tsigned(clt) -> "signed"^(line_type2c clt) + | PC.Tstatic(clt) -> "static"^(line_type2c clt) + | PC.Tinline(clt) -> "inline"^(line_type2c clt) + | PC.Ttypedef(clt) -> "typedef"^(line_type2c clt) + | PC.Tattr(s,clt) -> s^(line_type2c clt) + | PC.Tauto(clt) -> "auto"^(line_type2c clt) + | PC.Tregister(clt) -> "register"^(line_type2c clt) + | PC.Textern(clt) -> "extern"^(line_type2c clt) + | PC.Tconst(clt) -> "const"^(line_type2c clt) + | PC.Tvolatile(clt) -> "volatile"^(line_type2c clt) + + | PC.TPragma(s) -> s + | PC.TIncludeL(s,clt) -> (pr "#include \"%s\"" s)^(line_type2c clt) + | PC.TIncludeNL(s,clt) -> (pr "#include <%s>" s)^(line_type2c clt) + | PC.TDefine(clt,_) -> "#define"^(line_type2c clt) + | PC.TDefineParam(clt,_,_) -> "#define_param"^(line_type2c clt) + | PC.TMinusFile(s,clt) -> (pr "--- %s" s)^(line_type2c clt) + | PC.TPlusFile(s,clt) -> (pr "+++ %s" s)^(line_type2c clt) + + | PC.TInc(clt) -> "++"^(line_type2c clt) + | PC.TDec(clt) -> "--"^(line_type2c clt) + + | PC.TIf(clt) -> "if"^(line_type2c clt) + | PC.TElse(clt) -> "else"^(line_type2c clt) + | PC.TWhile(clt) -> "while"^(line_type2c clt) + | PC.TFor(clt) -> "for"^(line_type2c clt) + | PC.TDo(clt) -> "do"^(line_type2c clt) + | PC.TSwitch(clt) -> "switch"^(line_type2c clt) + | PC.TCase(clt) -> "case"^(line_type2c clt) + | PC.TDefault(clt) -> "default"^(line_type2c clt) + | PC.TReturn(clt) -> "return"^(line_type2c clt) + | PC.TBreak(clt) -> "break"^(line_type2c clt) + | PC.TContinue(clt) -> "continue"^(line_type2c clt) + | PC.TGoto(clt) -> "goto"^(line_type2c clt) + | PC.TIdent(s,clt) -> (pr "ident-%s" s)^(line_type2c clt) + | PC.TTypeId(s,clt) -> (pr "typename-%s" s)^(line_type2c clt) + | PC.TDeclarerId(s,clt) -> (pr "declarername-%s" s)^(line_type2c clt) + | PC.TIteratorId(s,clt) -> (pr "iteratorname-%s" s)^(line_type2c clt) + | PC.TMetaDeclarer(_,_,_,clt) -> "declmeta"^(line_type2c clt) + | PC.TMetaIterator(_,_,_,clt) -> "itermeta"^(line_type2c clt) + + | PC.TSizeof(clt) -> "sizeof"^(line_type2c clt) + + | PC.TString(x,clt) -> x^(line_type2c clt) + | PC.TChar(x,clt) -> x^(line_type2c clt) + | PC.TFloat(x,clt) -> x^(line_type2c clt) + | PC.TInt(x,clt) -> x^(line_type2c clt) + + | PC.TOrLog(clt) -> "||"^(line_type2c clt) + | PC.TAndLog(clt) -> "&&"^(line_type2c clt) + | PC.TOr(clt) -> "|"^(line_type2c clt) + | PC.TXor(clt) -> "^"^(line_type2c clt) + | PC.TAnd (clt) -> "&"^(line_type2c clt) + | PC.TEqEq(clt) -> "=="^(line_type2c clt) + | PC.TNotEq(clt) -> "!="^(line_type2c clt) + | PC.TLogOp(op,clt) -> + (match op with + Ast.Inf -> "<" + | Ast.InfEq -> "<=" + | Ast.Sup -> ">" + | Ast.SupEq -> ">=" + | _ -> failwith "not possible") + ^(line_type2c clt) + | PC.TShOp(op,clt) -> + (match op with + Ast.DecLeft -> "<<" + | Ast.DecRight -> ">>" + | _ -> failwith "not possible") + ^(line_type2c clt) + | PC.TPlus(clt) -> "+"^(line_type2c clt) + | PC.TMinus(clt) -> "-"^(line_type2c clt) + | PC.TMul(clt) -> "*"^(line_type2c clt) + | PC.TDmOp(op,clt) -> + (match op with + Ast.Div -> "/" + | Ast.Mod -> "%" + | _ -> failwith "not possible") + ^(line_type2c clt) + | PC.TTilde (clt) -> "~"^(line_type2c clt) + + | PC.TMetaParam(_,_,clt) -> "parammeta"^(line_type2c clt) + | PC.TMetaParamList(_,_,_,clt) -> "paramlistmeta"^(line_type2c clt) + | PC.TMetaConst(_,_,_,_,clt) -> "constmeta"^(line_type2c clt) + | PC.TMetaErr(_,_,_,clt) -> "errmeta"^(line_type2c clt) + | PC.TMetaExp(_,_,_,_,clt) -> "expmeta"^(line_type2c clt) + | PC.TMetaIdExp(_,_,_,_,clt) -> "idexpmeta"^(line_type2c clt) + | PC.TMetaLocalIdExp(_,_,_,_,clt) -> "localidexpmeta"^(line_type2c clt) + | PC.TMetaExpList(_,_,_,clt) -> "explistmeta"^(line_type2c clt) + | PC.TMetaId(_,_,_,clt) -> "idmeta"^(line_type2c clt) + | PC.TMetaType(_,_,clt) -> "typemeta"^(line_type2c clt) + | PC.TMetaStm(_,_,clt) -> "stmmeta"^(line_type2c clt) + | PC.TMetaStmList(_,_,clt) -> "stmlistmeta"^(line_type2c clt) + | PC.TMetaFunc(_,_,_,clt) -> "funcmeta"^(line_type2c clt) + | PC.TMetaLocalFunc(_,_,_,clt) -> "funcmeta"^(line_type2c clt) + | PC.TMetaPos(_,_,_,clt) -> "posmeta" + | PC.TMPtVirg -> ";" + | PC.TArobArob -> "@@" + | PC.TArob -> "@" + | PC.TPArob -> "P@" + | PC.TScript -> "script" + + | PC.TWhen(clt) -> "WHEN"^(line_type2c clt) + | PC.TWhenTrue(clt) -> "WHEN TRUE"^(line_type2c clt) + | PC.TWhenFalse(clt) -> "WHEN FALSE"^(line_type2c clt) + | PC.TAny(clt) -> "ANY"^(line_type2c clt) + | PC.TStrict(clt) -> "STRICT"^(line_type2c clt) + | PC.TEllipsis(clt) -> "..."^(line_type2c clt) +(* + | PC.TCircles(clt) -> "ooo"^(line_type2c clt) + | PC.TStars(clt) -> "***"^(line_type2c clt) +*) + + | PC.TOEllipsis(clt) -> "<..."^(line_type2c clt) + | PC.TCEllipsis(clt) -> "...>"^(line_type2c clt) + | PC.TPOEllipsis(clt) -> "<+..."^(line_type2c clt) + | PC.TPCEllipsis(clt) -> "...+>"^(line_type2c clt) +(* + | PC.TOCircles(clt) -> " "ooo>"^(line_type2c clt) + | PC.TOStars(clt) -> "<***"^(line_type2c clt) + | PC.TCStars(clt) -> "***>"^(line_type2c clt) +*) + | PC.TBang0 -> "!" + | PC.TPlus0 -> "+" + | PC.TWhy0 -> "?" + + | PC.TWhy(clt) -> "?"^(line_type2c clt) + | PC.TDotDot(clt) -> ":"^(line_type2c clt) + | PC.TBang(clt) -> "!"^(line_type2c clt) + | PC.TOPar(clt) -> "("^(line_type2c clt) + | PC.TOPar0(clt) -> "("^(line_type2c clt) + | PC.TMid0(clt) -> "|"^(line_type2c clt) + | PC.TCPar(clt) -> ")"^(line_type2c clt) + | PC.TCPar0(clt) -> ")"^(line_type2c clt) + + | PC.TOBrace(clt) -> "{"^(line_type2c clt) + | PC.TCBrace(clt) -> "}"^(line_type2c clt) + | PC.TOCro(clt) -> "["^(line_type2c clt) + | PC.TCCro(clt) -> "]"^(line_type2c clt) + | PC.TOInit(clt) -> "{"^(line_type2c clt) + + | PC.TPtrOp(clt) -> "->"^(line_type2c clt) + + | PC.TEq(clt) -> "="^(line_type2c clt) + | PC.TAssign(_,clt) -> "=op"^(line_type2c clt) + | PC.TDot(clt) -> "."^(line_type2c clt) + | PC.TComma(clt) -> ","^(line_type2c clt) + | PC.TPtVirg(clt) -> ";"^(line_type2c clt) + + | PC.EOF -> "eof" + | PC.TLineEnd(clt) -> "line end" + | PC.TInvalid -> "invalid" + | PC.TFunDecl(clt) -> "fundecl" + + | PC.TIso -> "<=>" + | PC.TRightIso -> "=>" + | PC.TIsoTopLevel -> "TopLevel" + | PC.TIsoExpression -> "Expression" + | PC.TIsoArgExpression -> "ArgExpression" + | PC.TIsoTestExpression -> "TestExpression" + | PC.TIsoStatement -> "Statement" + | PC.TIsoDeclaration -> "Declaration" + | PC.TIsoType -> "Type" + | PC.TScriptData s -> s + +let print_tokens s tokens = + Printf.printf "%s\n" s; + List.iter (function x -> Printf.printf "%s " (token2c x)) tokens; + Printf.printf "\n\n"; + flush stdout + +type plus = PLUS | NOTPLUS | SKIP + +let plus_attachable (tok,_) = + match tok with + PC.Tchar(clt) | PC.Tshort(clt) | PC.Tint(clt) | PC.Tdouble(clt) + | PC.Tfloat(clt) | PC.Tlong(clt) | PC.Tvoid(clt) | PC.Tstruct(clt) + | PC.Tunion(clt) | PC.Tenum(clt) | PC.Tunsigned(clt) | PC.Tsigned(clt) + | PC.Tstatic(clt) + | PC.Tinline(clt) | PC.Ttypedef(clt) | PC.Tattr(_,clt) + | PC.Tauto(clt) | PC.Tregister(clt) + | PC.Textern(clt) | PC.Tconst(clt) | PC.Tvolatile(clt) + + | PC.TIncludeL(_,clt) | PC.TIncludeNL(_,clt) | PC.TDefine(clt,_) + | PC.TDefineParam(clt,_,_) | PC.TMinusFile(_,clt) | PC.TPlusFile(_,clt) + + | PC.TInc(clt) | PC.TDec(clt) + + | PC.TIf(clt) | PC.TElse(clt) | PC.TWhile(clt) | PC.TFor(clt) | PC.TDo(clt) + | PC.TSwitch(clt) | PC.TCase(clt) | PC.TDefault(clt) | PC.TReturn(clt) + | PC.TBreak(clt) | PC.TContinue(clt) | PC.TGoto(clt) | PC.TIdent(_,clt) + | PC.TTypeId(_,clt) | PC.TDeclarerId(_,clt) | PC.TIteratorId(_,clt) + + | PC.TSizeof(clt) + + | PC.TString(_,clt) | PC.TChar(_,clt) | PC.TFloat(_,clt) | PC.TInt(_,clt) + + | PC.TOrLog(clt) | PC.TAndLog(clt) | PC.TOr(clt) | PC.TXor(clt) + | PC.TAnd (clt) | PC.TEqEq(clt) | PC.TNotEq(clt) | PC.TLogOp(_,clt) + | PC.TShOp(_,clt) | PC.TPlus(clt) | PC.TMinus(clt) | PC.TMul(clt) + | PC.TDmOp(_,clt) | PC.TTilde (clt) + + | PC.TMetaParam(_,_,clt) | PC.TMetaParamList(_,_,_,clt) + | PC.TMetaConst(_,_,_,_,clt) | PC.TMetaErr(_,_,_,clt) + | PC.TMetaExp(_,_,_,_,clt) | PC.TMetaIdExp(_,_,_,_,clt) + | PC.TMetaLocalIdExp(_,_,_,_,clt) + | PC.TMetaExpList(_,_,_,clt) + | PC.TMetaId(_,_,_,clt) + | PC.TMetaType(_,_,clt) | PC.TMetaStm(_,_,clt) + | PC.TMetaStmList(_,_,clt) | PC.TMetaFunc(_,_,_,clt) + | PC.TMetaLocalFunc(_,_,_,clt) + + | PC.TWhen(clt) | PC.TWhenTrue(clt) | PC.TWhenFalse(clt) + | PC.TAny(clt) | PC.TStrict(clt) | PC.TEllipsis(clt) + (* | PC.TCircles(clt) | PC.TStars(clt) *) + + | PC.TWhy(clt) | PC.TDotDot(clt) | PC.TBang(clt) | PC.TOPar(clt) + | PC.TCPar(clt) + + | PC.TOBrace(clt) | PC.TCBrace(clt) | PC.TOCro(clt) | PC.TCCro(clt) + | PC.TOInit(clt) + + | PC.TPtrOp(clt) + + | PC.TEq(clt) | PC.TAssign(_,clt) | PC.TDot(clt) | PC.TComma(clt) + | PC.TPtVirg(clt) -> + if line_type clt = D.PLUS then PLUS else NOTPLUS + + | PC.TOPar0(clt) | PC.TMid0(clt) | PC.TCPar0(clt) + | PC.TOEllipsis(clt) | PC.TCEllipsis(clt) + | PC.TPOEllipsis(clt) | PC.TPCEllipsis(clt) (* | PC.TOCircles(clt) + | PC.TCCircles(clt) | PC.TOStars(clt) | PC.TCStars(clt) *) -> NOTPLUS + | PC.TMetaPos(nm,_,_,_) -> NOTPLUS + + | _ -> SKIP + +let get_clt (tok,_) = + match tok with + PC.Tchar(clt) | PC.Tshort(clt) | PC.Tint(clt) | PC.Tdouble(clt) + | PC.Tfloat(clt) | PC.Tlong(clt) | PC.Tvoid(clt) | PC.Tstruct(clt) + | PC.Tunion(clt) | PC.Tenum(clt) | PC.Tunsigned(clt) | PC.Tsigned(clt) + | PC.Tstatic(clt) + | PC.Tinline(clt) | PC.Tattr(_,clt) | PC.Tauto(clt) | PC.Tregister(clt) + | PC.Textern(clt) | PC.Tconst(clt) | PC.Tvolatile(clt) + + | PC.TIncludeL(_,clt) | PC.TIncludeNL(_,clt) | PC.TDefine(clt,_) + | PC.TDefineParam(clt,_,_) | PC.TMinusFile(_,clt) | PC.TPlusFile(_,clt) + + | PC.TInc(clt) | PC.TDec(clt) + + | PC.TIf(clt) | PC.TElse(clt) | PC.TWhile(clt) | PC.TFor(clt) | PC.TDo(clt) + | PC.TSwitch(clt) | PC.TCase(clt) | PC.TDefault(clt) | PC.TReturn(clt) + | PC.TBreak(clt) | PC.TContinue(clt) | PC.TGoto(clt) | PC.TIdent(_,clt) + | PC.TTypeId(_,clt) | PC.TDeclarerId(_,clt) | PC.TIteratorId(_,clt) + + | PC.TSizeof(clt) + + | PC.TString(_,clt) | PC.TChar(_,clt) | PC.TFloat(_,clt) | PC.TInt(_,clt) + + | PC.TOrLog(clt) | PC.TAndLog(clt) | PC.TOr(clt) | PC.TXor(clt) + | PC.TAnd (clt) | PC.TEqEq(clt) | PC.TNotEq(clt) | PC.TLogOp(_,clt) + | PC.TShOp(_,clt) | PC.TPlus(clt) | PC.TMinus(clt) | PC.TMul(clt) + | PC.TDmOp(_,clt) | PC.TTilde (clt) + + | PC.TMetaParam(_,_,clt) | PC.TMetaParamList(_,_,_,clt) + | PC.TMetaConst(_,_,_,_,clt) | PC.TMetaErr(_,_,_,clt) + | PC.TMetaExp(_,_,_,_,clt) | PC.TMetaIdExp(_,_,_,_,clt) + | PC.TMetaLocalIdExp(_,_,_,_,clt) + | PC.TMetaExpList(_,_,_,clt) + | PC.TMetaId(_,_,_,clt) + | PC.TMetaType(_,_,clt) | PC.TMetaStm(_,_,clt) + | PC.TMetaStmList(_,_,clt) | PC.TMetaFunc(_,_,_,clt) + | PC.TMetaLocalFunc(_,_,_,clt) | PC.TMetaPos(_,_,_,clt) + + | PC.TWhen(clt) | PC.TWhenTrue(clt) | PC.TWhenFalse(clt) | + PC.TAny(clt) | PC.TStrict(clt) | PC.TEllipsis(clt) + (* | PC.TCircles(clt) | PC.TStars(clt) *) + + | PC.TWhy(clt) | PC.TDotDot(clt) | PC.TBang(clt) | PC.TOPar(clt) + | PC.TCPar(clt) + + | PC.TOBrace(clt) | PC.TCBrace(clt) | PC.TOCro(clt) | PC.TCCro(clt) + | PC.TOInit(clt) + + | PC.TPtrOp(clt) + + | PC.TEq(clt) | PC.TAssign(_,clt) | PC.TDot(clt) | PC.TComma(clt) + | PC.TPtVirg(clt) + + | PC.TOPar0(clt) | PC.TMid0(clt) | PC.TCPar0(clt) + | PC.TOEllipsis(clt) | PC.TCEllipsis(clt) + | PC.TPOEllipsis(clt) | PC.TPCEllipsis(clt) (* | PC.TOCircles(clt) + | PC.TCCircles(clt) | PC.TOStars(clt) | PC.TCStars(clt) *) -> clt + + | _ -> failwith "no clt" + +let update_clt (tok,x) clt = + match tok with + PC.Tchar(_) -> (PC.Tchar(clt),x) + | PC.Tshort(_) -> (PC.Tshort(clt),x) + | PC.Tint(_) -> (PC.Tint(clt),x) + | PC.Tdouble(_) -> (PC.Tdouble(clt),x) + | PC.Tfloat(_) -> (PC.Tfloat(clt),x) + | PC.Tlong(_) -> (PC.Tlong(clt),x) + | PC.Tvoid(_) -> (PC.Tvoid(clt),x) + | PC.Tstruct(_) -> (PC.Tstruct(clt),x) + | PC.Tunion(_) -> (PC.Tunion(clt),x) + | PC.Tenum(_) -> (PC.Tenum(clt),x) + | PC.Tunsigned(_) -> (PC.Tunsigned(clt),x) + | PC.Tsigned(_) -> (PC.Tsigned(clt),x) + | PC.Tstatic(_) -> (PC.Tstatic(clt),x) + | PC.Tinline(_) -> (PC.Tinline(clt),x) + | PC.Ttypedef(_) -> (PC.Ttypedef(clt),x) + | PC.Tattr(s,_) -> (PC.Tattr(s,clt),x) + | PC.Tauto(_) -> (PC.Tauto(clt),x) + | PC.Tregister(_) -> (PC.Tregister(clt),x) + | PC.Textern(_) -> (PC.Textern(clt),x) + | PC.Tconst(_) -> (PC.Tconst(clt),x) + | PC.Tvolatile(_) -> (PC.Tvolatile(clt),x) + + | PC.TIncludeL(s,_) -> (PC.TIncludeL(s,clt),x) + | PC.TIncludeNL(s,_) -> (PC.TIncludeNL(s,clt),x) + | PC.TDefine(_,a) -> (PC.TDefine(clt,a),x) + | PC.TDefineParam(_,a,b) -> (PC.TDefineParam(clt,a,b),x) + | PC.TMinusFile(s,_) -> (PC.TMinusFile(s,clt),x) + | PC.TPlusFile(s,_) -> (PC.TPlusFile(s,clt),x) + + | PC.TInc(_) -> (PC.TInc(clt),x) + | PC.TDec(_) -> (PC.TDec(clt),x) + + | PC.TIf(_) -> (PC.TIf(clt),x) + | PC.TElse(_) -> (PC.TElse(clt),x) + | PC.TWhile(_) -> (PC.TWhile(clt),x) + | PC.TFor(_) -> (PC.TFor(clt),x) + | PC.TDo(_) -> (PC.TDo(clt),x) + | PC.TSwitch(_) -> (PC.TSwitch(clt),x) + | PC.TCase(_) -> (PC.TCase(clt),x) + | PC.TDefault(_) -> (PC.TDefault(clt),x) + | PC.TReturn(_) -> (PC.TReturn(clt),x) + | PC.TBreak(_) -> (PC.TBreak(clt),x) + | PC.TContinue(_) -> (PC.TContinue(clt),x) + | PC.TGoto(_) -> (PC.TGoto(clt),x) + | PC.TIdent(s,_) -> (PC.TIdent(s,clt),x) + | PC.TTypeId(s,_) -> (PC.TTypeId(s,clt),x) + | PC.TDeclarerId(s,_) -> (PC.TDeclarerId(s,clt),x) + | PC.TIteratorId(s,_) -> (PC.TIteratorId(s,clt),x) + + | PC.TSizeof(_) -> (PC.TSizeof(clt),x) + + | PC.TString(s,_) -> (PC.TString(s,clt),x) + | PC.TChar(s,_) -> (PC.TChar(s,clt),x) + | PC.TFloat(s,_) -> (PC.TFloat(s,clt),x) + | PC.TInt(s,_) -> (PC.TInt(s,clt),x) + + | PC.TOrLog(_) -> (PC.TOrLog(clt),x) + | PC.TAndLog(_) -> (PC.TAndLog(clt),x) + | PC.TOr(_) -> (PC.TOr(clt),x) + | PC.TXor(_) -> (PC.TXor(clt),x) + | PC.TAnd (_) -> (PC.TAnd (clt),x) + | PC.TEqEq(_) -> (PC.TEqEq(clt),x) + | PC.TNotEq(_) -> (PC.TNotEq(clt),x) + | PC.TLogOp(op,_) -> (PC.TLogOp(op,clt),x) + | PC.TShOp(op,_) -> (PC.TShOp(op,clt),x) + | PC.TPlus(_) -> (PC.TPlus(clt),x) + | PC.TMinus(_) -> (PC.TMinus(clt),x) + | PC.TMul(_) -> (PC.TMul(clt),x) + | PC.TDmOp(op,_) -> (PC.TDmOp(op,clt),x) + | PC.TTilde (_) -> (PC.TTilde (clt),x) + + | PC.TMetaParam(a,b,_) -> (PC.TMetaParam(a,b,clt),x) + | PC.TMetaParamList(a,b,c,_) -> (PC.TMetaParamList(a,b,c,clt),x) + | PC.TMetaConst(a,b,c,d,_) -> (PC.TMetaConst(a,b,c,d,clt),x) + | PC.TMetaErr(a,b,c,_) -> (PC.TMetaErr(a,b,c,clt),x) + | PC.TMetaExp(a,b,c,d,_) -> (PC.TMetaExp(a,b,c,d,clt),x) + | PC.TMetaIdExp(a,b,c,d,_) -> (PC.TMetaIdExp(a,b,c,d,clt),x) + | PC.TMetaLocalIdExp(a,b,c,d,_) -> (PC.TMetaLocalIdExp(a,b,c,d,clt),x) + | PC.TMetaExpList(a,b,c,_) -> (PC.TMetaExpList(a,b,c,clt),x) + | PC.TMetaId(a,b,c,_) -> (PC.TMetaId(a,b,c,clt),x) + | PC.TMetaType(a,b,_) -> (PC.TMetaType(a,b,clt),x) + | PC.TMetaStm(a,b,_) -> (PC.TMetaStm(a,b,clt),x) + | PC.TMetaStmList(a,b,_) -> (PC.TMetaStmList(a,b,clt),x) + | PC.TMetaFunc(a,b,c,_) -> (PC.TMetaFunc(a,b,c,clt),x) + | PC.TMetaLocalFunc(a,b,c,_) -> (PC.TMetaLocalFunc(a,b,c,clt),x) + + | PC.TWhen(_) -> (PC.TWhen(clt),x) + | PC.TWhenTrue(_) -> (PC.TWhenTrue(clt),x) + | PC.TWhenFalse(_) -> (PC.TWhenFalse(clt),x) + | PC.TAny(_) -> (PC.TAny(clt),x) + | PC.TStrict(_) -> (PC.TStrict(clt),x) + | PC.TEllipsis(_) -> (PC.TEllipsis(clt),x) +(* + | PC.TCircles(_) -> (PC.TCircles(clt),x) + | PC.TStars(_) -> (PC.TStars(clt),x) +*) + + | PC.TOEllipsis(_) -> (PC.TOEllipsis(clt),x) + | PC.TCEllipsis(_) -> (PC.TCEllipsis(clt),x) + | PC.TPOEllipsis(_) -> (PC.TPOEllipsis(clt),x) + | PC.TPCEllipsis(_) -> (PC.TPCEllipsis(clt),x) +(* + | PC.TOCircles(_) -> (PC.TOCircles(clt),x) + | PC.TCCircles(_) -> (PC.TCCircles(clt),x) + | PC.TOStars(_) -> (PC.TOStars(clt),x) + | PC.TCStars(_) -> (PC.TCStars(clt),x) +*) + + | PC.TWhy(_) -> (PC.TWhy(clt),x) + | PC.TDotDot(_) -> (PC.TDotDot(clt),x) + | PC.TBang(_) -> (PC.TBang(clt),x) + | PC.TOPar(_) -> (PC.TOPar(clt),x) + | PC.TOPar0(_) -> (PC.TOPar0(clt),x) + | PC.TMid0(_) -> (PC.TMid0(clt),x) + | PC.TCPar(_) -> (PC.TCPar(clt),x) + | PC.TCPar0(_) -> (PC.TCPar0(clt),x) + + | PC.TOBrace(_) -> (PC.TOBrace(clt),x) + | PC.TCBrace(_) -> (PC.TCBrace(clt),x) + | PC.TOCro(_) -> (PC.TOCro(clt),x) + | PC.TCCro(_) -> (PC.TCCro(clt),x) + | PC.TOInit(_) -> (PC.TOInit(clt),x) + + | PC.TPtrOp(_) -> (PC.TPtrOp(clt),x) + + | PC.TEq(_) -> (PC.TEq(clt),x) + | PC.TAssign(s,_) -> (PC.TAssign(s,clt),x) + | PC.TDot(_) -> (PC.TDot(clt),x) + | PC.TComma(_) -> (PC.TComma(clt),x) + | PC.TPtVirg(_) -> (PC.TPtVirg(clt),x) + + | PC.TLineEnd(_) -> (PC.TLineEnd(clt),x) + | PC.TFunDecl(_) -> (PC.TFunDecl(clt),x) + + | _ -> failwith "no clt" + + +(* ----------------------------------------------------------------------- *) + +let make_name prefix ln = Printf.sprintf "%s starting on line %d" prefix ln + +(* ----------------------------------------------------------------------- *) +(* Read tokens *) + +let wrap_lexbuf_info lexbuf = + (Lexing.lexeme lexbuf, Lexing.lexeme_start lexbuf) + +let tokens_all_full token table file get_ats lexbuf end_markers : + (bool * ((PC.token * (string * (int * int) * (int * int))) list)) = + try + let rec aux () = + let result = token lexbuf in + let info = (Lexing.lexeme lexbuf, + (table.(Lexing.lexeme_start lexbuf)), + (Lexing.lexeme_start lexbuf, Lexing.lexeme_end lexbuf)) in + if result = PC.EOF + then + if get_ats + then failwith "unexpected end of file in a metavariable declaration" + else (false,[(result,info)]) + else if List.mem result end_markers + then (true,[(result,info)]) + else + let (more,rest) = aux() in + (more,(result, info)::rest) + in aux () + with + e -> pr2 (Common.error_message file (wrap_lexbuf_info lexbuf) ); raise e + +let tokens_all table file get_ats lexbuf end_markers : + (bool * ((PC.token * (string * (int * int) * (int * int))) list)) = + tokens_all_full Lexer_cocci.token table file get_ats lexbuf end_markers + +let tokens_script_all table file get_ats lexbuf end_markers : + (bool * ((PC.token * (string * (int * int) * (int * int))) list)) = + tokens_all_full Lexer_script.token table file get_ats lexbuf end_markers + +(* ----------------------------------------------------------------------- *) +(* Split tokens into minus and plus fragments *) + +let split t clt = + let (d,_,_,_,_,_,_,_) = clt in + match d with + D.MINUS | D.OPTMINUS | D.UNIQUEMINUS -> ([t],[]) + | D.PLUS -> ([],[t]) + | D.CONTEXT | D.UNIQUE | D.OPT -> ([t],[t]) + +let split_token ((tok,_) as t) = + match tok with + PC.TIdentifier | PC.TConstant | PC.TExpression | PC.TIdExpression + | PC.TStatement | PC.TPosition | PC.TPosAny + | PC.TFunction | PC.TTypedef | PC.TDeclarer | PC.TIterator | PC.TName + | PC.TType | PC.TParameter | PC.TLocal | PC.Tlist | PC.TFresh | PC.TPure + | PC.TContext | PC.TRuleName(_) | PC.TUsing | PC.TDisable | PC.TExtends + | PC.TPathIsoFile(_) + | PC.TDepends | PC.TOn | PC.TEver | PC.TNever | PC.TExists | PC.TForall + | PC.TReverse + | PC.TError | PC.TWords | PC.TGenerated | PC.TNothing -> ([t],[t]) + + | PC.Tchar(clt) | PC.Tshort(clt) | PC.Tint(clt) | PC.Tdouble(clt) + | PC.Tfloat(clt) | PC.Tlong(clt) | PC.Tvoid(clt) | PC.Tstruct(clt) + | PC.Tunion(clt) | PC.Tenum(clt) | PC.Tunsigned(clt) | PC.Tsigned(clt) + | PC.Tstatic(clt) | PC.Tauto(clt) | PC.Tregister(clt) | PC.Textern(clt) + | PC.Tinline(clt) | PC.Ttypedef(clt) | PC.Tattr(_,clt) + | PC.Tconst(clt) | PC.Tvolatile(clt) -> split t clt + + | PC.TPragma(s) -> ([],[t]) (* only allowed in + *) + | PC.TPlusFile(s,clt) | PC.TMinusFile(s,clt) + | PC.TIncludeL(s,clt) | PC.TIncludeNL(s,clt) -> + split t clt + | PC.TDefine(clt,_) | PC.TDefineParam(clt,_,_) -> split t clt + + | PC.TIf(clt) | PC.TElse(clt) | PC.TWhile(clt) | PC.TFor(clt) | PC.TDo(clt) + | PC.TSwitch(clt) | PC.TCase(clt) | PC.TDefault(clt) + | PC.TSizeof(clt) + | PC.TReturn(clt) | PC.TBreak(clt) | PC.TContinue(clt) | PC.TGoto(clt) + | PC.TIdent(_,clt) + | PC.TTypeId(_,clt) | PC.TDeclarerId(_,clt) | PC.TIteratorId(_,clt) + | PC.TMetaConst(_,_,_,_,clt) | PC.TMetaExp(_,_,_,_,clt) + | PC.TMetaIdExp(_,_,_,_,clt) | PC.TMetaLocalIdExp(_,_,_,_,clt) + | PC.TMetaExpList(_,_,_,clt) + | PC.TMetaParam(_,_,clt) | PC.TMetaParamList(_,_,_,clt) + | PC.TMetaId(_,_,_,clt) | PC.TMetaType(_,_,clt) + | PC.TMetaStm(_,_,clt) | PC.TMetaStmList(_,_,clt) | PC.TMetaErr(_,_,_,clt) + | PC.TMetaFunc(_,_,_,clt) | PC.TMetaLocalFunc(_,_,_,clt) + | PC.TMetaDeclarer(_,_,_,clt) | PC.TMetaIterator(_,_,_,clt) -> split t clt + | PC.TMPtVirg | PC.TArob | PC.TArobArob | PC.TScript -> ([t],[t]) + | PC.TPArob | PC.TMetaPos(_,_,_,_) -> ([t],[]) + + | PC.TFunDecl(clt) + | PC.TWhen(clt) | PC.TWhenTrue(clt) | PC.TWhenFalse(clt) + | PC.TAny(clt) | PC.TStrict(clt) | PC.TLineEnd(clt) + | PC.TEllipsis(clt) (* | PC.TCircles(clt) | PC.TStars(clt) *) -> split t clt + + | PC.TOEllipsis(_) | PC.TCEllipsis(_) (* clt must be context *) + | PC.TPOEllipsis(_) | PC.TPCEllipsis(_) (* clt must be context *) +(* + | PC.TOCircles(_) | PC.TCCircles(_) (* clt must be context *) + | PC.TOStars(_) | PC.TCStars(_) (* clt must be context *) +*) + | PC.TBang0 | PC.TPlus0 | PC.TWhy0 -> + ([t],[t]) + + | PC.TWhy(clt) | PC.TDotDot(clt) + | PC.TBang(clt) | PC.TOPar(clt) | PC.TOPar0(clt) + | PC.TMid0(clt) | PC.TCPar(clt) | PC.TCPar0(clt) -> split t clt + + | PC.TInc(clt) | PC.TDec(clt) -> split t clt + + | PC.TString(_,clt) | PC.TChar(_,clt) | PC.TFloat(_,clt) | PC.TInt(_,clt) -> + split t clt + + | PC.TOrLog(clt) | PC.TAndLog(clt) | PC.TOr(clt) | PC.TXor(clt) + | PC.TAnd (clt) | PC.TEqEq(clt) | PC.TNotEq(clt) | PC.TLogOp(_,clt) + | PC.TShOp(_,clt) | PC.TPlus(clt) | PC.TMinus(clt) | PC.TMul(clt) + | PC.TDmOp(_,clt) | PC.TTilde (clt) -> split t clt + + | PC.TOBrace(clt) | PC.TCBrace(clt) | PC.TOInit(clt) -> split t clt + | PC.TOCro(clt) | PC.TCCro(clt) -> split t clt + + | PC.TPtrOp(clt) -> split t clt + + | PC.TEq(clt) | PC.TAssign(_,clt) | PC.TDot(clt) | PC.TComma(clt) + | PC.TPtVirg(clt) -> split t clt + + | PC.EOF | PC.TInvalid -> ([t],[t]) + + | PC.TIso | PC.TRightIso + | PC.TIsoExpression | PC.TIsoStatement | PC.TIsoDeclaration | PC.TIsoType + | PC.TIsoTopLevel | PC.TIsoArgExpression | PC.TIsoTestExpression -> + failwith "unexpected tokens" + | PC.TScriptData s -> ([t],[t]) + +let split_token_stream tokens = + let rec loop = function + [] -> ([],[]) + | token::tokens -> + let (minus,plus) = split_token token in + let (minus_stream,plus_stream) = loop tokens in + (minus@minus_stream,plus@plus_stream) in + loop tokens + +(* ----------------------------------------------------------------------- *) +(* Find function names *) +(* This addresses a shift-reduce problem in the parser, allowing us to +distinguish a function declaration from a function call even if the latter +has no return type. Undoubtedly, this is not very nice, but it doesn't +seem very convenient to refactor the grammar to get around the problem. *) + +let rec find_function_names = function + [] -> [] + | ((PC.TIdent(_,clt),info) as t1) :: ((PC.TOPar(_),_) as t2) :: rest + | ((PC.TMetaId(_,_,_,clt),info) as t1) :: ((PC.TOPar(_),_) as t2) :: rest + | ((PC.TMetaFunc(_,_,_,clt),info) as t1) :: ((PC.TOPar(_),_) as t2) :: rest + | ((PC.TMetaLocalFunc(_,_,_,clt),info) as t1)::((PC.TOPar(_),_) as t2)::rest + -> + let rec skip level = function + [] -> ([],false,[]) + | ((PC.TCPar(_),_) as t)::rest -> + let level = level - 1 in + if level = 0 + then ([t],true,rest) + else let (pre,found,post) = skip level rest in (t::pre,found,post) + | ((PC.TOPar(_),_) as t)::rest -> + let level = level + 1 in + let (pre,found,post) = skip level rest in (t::pre,found,post) + | ((PC.TArobArob,_) as t)::rest + | ((PC.TArob,_) as t)::rest + | ((PC.EOF,_) as t)::rest -> ([t],false,rest) + | t::rest -> + let (pre,found,post) = skip level rest in (t::pre,found,post) in + let (pre,found,post) = skip 1 rest in + (match (found,post) with + (true,((PC.TOBrace(_),_) as t3)::rest) -> + (PC.TFunDecl(clt),info) :: t1 :: t2 :: pre @ + t3 :: (find_function_names rest) + | _ -> t1 :: t2 :: pre @ find_function_names post) + | t :: rest -> t :: find_function_names rest + +(* ----------------------------------------------------------------------- *) +(* an attribute is an identifier that preceeds another identifier and + begins with __ *) + +let rec detect_attr l = + let is_id = function + (PC.TIdent(_,_),_) | (PC.TMetaId(_,_,_,_),_) | (PC.TMetaFunc(_,_,_,_),_) + | (PC.TMetaLocalFunc(_,_,_,_),_) -> true + | _ -> false in + let rec loop = function + [] -> [] + | [x] -> [x] + | ((PC.TIdent(nm,clt),info) as t1)::id::rest when is_id id -> + if String.length nm > 2 && String.sub nm 0 2 = "__" + then (PC.Tattr(nm,clt),info)::(loop (id::rest)) + else t1::(loop (id::rest)) + | x::xs -> x::(loop xs) in + loop l + +(* ----------------------------------------------------------------------- *) +(* Look for variable declarations where the name is a typedef name. +We assume that C code does not contain a multiplication as a top-level +statement. *) + +(* bug: once a type, always a type, even if the same name is later intended + to be used as a real identifier *) +let detect_types in_meta_decls l = + let is_delim infn = function + (PC.TOEllipsis(_),_) (* | (PC.TOCircles(_),_) | (PC.TOStars(_),_) *) + | (PC.TPOEllipsis(_),_) (* | (PC.TOCircles(_),_) | (PC.TOStars(_),_) *) + | (PC.TEllipsis(_),_) (* | (PC.TCircles(_),_) | (PC.TStars(_),_) *) + | (PC.TPtVirg(_),_) | (PC.TOBrace(_),_) | (PC.TOInit(_),_) + | (PC.TCBrace(_),_) + | (PC.TPure,_) | (PC.TContext,_) + | (PC.Tstatic(_),_) | (PC.Textern(_),_) + | (PC.Tinline(_),_) | (PC.Ttypedef(_),_) | (PC.Tattr(_),_) -> true + | (PC.TComma(_),_) when infn > 0 or in_meta_decls -> true + | (PC.TDotDot(_),_) when in_meta_decls -> true + | _ -> false in + let is_choices_delim = function + (PC.TOBrace(_),_) | (PC.TComma(_),_) -> true | _ -> false in + let is_id = function + (PC.TIdent(_,_),_) | (PC.TMetaId(_,_,_,_),_) | (PC.TMetaFunc(_,_,_,_),_) + | (PC.TMetaLocalFunc(_,_,_,_),_) -> true + | (PC.TMetaParam(_,_,_),_) + | (PC.TMetaParamList(_,_,_,_),_) + | (PC.TMetaConst(_,_,_,_,_),_) + | (PC.TMetaErr(_,_,_,_),_) + | (PC.TMetaExp(_,_,_,_,_),_) + | (PC.TMetaIdExp(_,_,_,_,_),_) + | (PC.TMetaLocalIdExp(_,_,_,_,_),_) + | (PC.TMetaExpList(_,_,_,_),_) + | (PC.TMetaType(_,_,_),_) + | (PC.TMetaStm(_,_,_),_) + | (PC.TMetaStmList(_,_,_),_) + | (PC.TMetaPos(_,_,_,_),_) -> in_meta_decls + | _ -> false in + let redo_id ident clt v = + !Data.add_type_name ident; + (PC.TTypeId(ident,clt),v) in + let rec loop start infn type_names = function + (* infn: 0 means not in a function header + > 0 means in a function header, after infn - 1 unmatched open parens*) + [] -> [] + | ((PC.TOBrace(clt),v)::_) as all when in_meta_decls -> + collect_choices type_names all (* never a function header *) + | delim::(PC.TIdent(ident,clt),v)::((PC.TMul(_),_) as x)::rest + when is_delim infn delim -> + let newid = redo_id ident clt v in + delim::newid::x::(loop false infn (ident::type_names) rest) + | delim::(PC.TIdent(ident,clt),v)::id::rest + when is_delim infn delim && is_id id -> + let newid = redo_id ident clt v in + delim::newid::id::(loop false infn (ident::type_names) rest) + | ((PC.TFunDecl(_),_) as fn)::rest -> + fn::(loop false 1 type_names rest) + | ((PC.TOPar(_),_) as lp)::rest when infn > 0 -> + lp::(loop false (infn + 1) type_names rest) + | ((PC.TCPar(_),_) as rp)::rest when infn > 0 -> + if infn - 1 = 1 + then rp::(loop false 0 type_names rest) (* 0 means not in fn header *) + else rp::(loop false (infn - 1) type_names rest) + | (PC.TIdent(ident,clt),v)::((PC.TMul(_),_) as x)::rest when start -> + let newid = redo_id ident clt v in + newid::x::(loop false infn (ident::type_names) rest) + | (PC.TIdent(ident,clt),v)::id::rest when start && is_id id -> + let newid = redo_id ident clt v in + newid::id::(loop false infn (ident::type_names) rest) + | (PC.TIdent(ident,clt),v)::rest when List.mem ident type_names -> + (PC.TTypeId(ident,clt),v)::(loop false infn type_names rest) + | ((PC.TIdent(ident,clt),v) as x)::rest -> + x::(loop false infn type_names rest) + | x::rest -> x::(loop false infn type_names rest) + and collect_choices type_names = function + [] -> [] (* should happen, but let the parser detect that *) + | (PC.TCBrace(clt),v)::rest -> + (PC.TCBrace(clt),v)::(loop false 0 type_names rest) + | delim::(PC.TIdent(ident,clt),v)::rest + when is_choices_delim delim -> + let newid = redo_id ident clt v in + delim::newid::(collect_choices (ident::type_names) rest) + | x::rest -> x::(collect_choices type_names rest) in + loop true 0 [] l + + +(* ----------------------------------------------------------------------- *) +(* Insert TLineEnd tokens at the end of a line that contains a WHEN. + WHEN is restricted to a single line, to avoid ambiguity in eg: + ... WHEN != x + +3 *) + +let token2line (tok,_) = + match tok with + PC.Tchar(clt) | PC.Tshort(clt) | PC.Tint(clt) | PC.Tdouble(clt) + | PC.Tfloat(clt) | PC.Tlong(clt) | PC.Tvoid(clt) | PC.Tstruct(clt) + | PC.Tunion(clt) | PC.Tenum(clt) | PC.Tunsigned(clt) | PC.Tsigned(clt) + | PC.Tstatic(clt) | PC.Tauto(clt) | PC.Tregister(clt) | PC.Textern(clt) + | PC.Tinline(clt) | PC.Ttypedef(clt) | PC.Tattr(_,clt) | PC.Tconst(clt) + | PC.Tvolatile(clt) + + | PC.TInc(clt) | PC.TDec(clt) + + | PC.TIf(clt) | PC.TElse(clt) | PC.TWhile(clt) | PC.TFor(clt) | PC.TDo(clt) + | PC.TSwitch (clt) | PC.TCase (clt) | PC.TDefault (clt) | PC.TSizeof (clt) + | PC.TReturn(clt) | PC.TBreak(clt) | PC.TContinue(clt) | PC.TGoto(clt) + | PC.TIdent(_,clt) + | PC.TTypeId(_,clt) | PC.TDeclarerId(_,clt) | PC.TIteratorId(_,clt) + | PC.TMetaDeclarer(_,_,_,clt) | PC.TMetaIterator(_,_,_,clt) + + | PC.TString(_,clt) | PC.TChar(_,clt) | PC.TFloat(_,clt) | PC.TInt(_,clt) + + | PC.TOrLog(clt) | PC.TAndLog(clt) | PC.TOr(clt) | PC.TXor(clt) + | PC.TAnd (clt) | PC.TEqEq(clt) | PC.TNotEq(clt) | PC.TLogOp(_,clt) + | PC.TShOp(_,clt) | PC.TPlus(clt) | PC.TMinus(clt) | PC.TMul(clt) + | PC.TDmOp(_,clt) | PC.TTilde (clt) + + | PC.TMetaParam(_,_,clt) | PC.TMetaParamList(_,_,_,clt) + | PC.TMetaConst(_,_,_,_,clt) | PC.TMetaExp(_,_,_,_,clt) + | PC.TMetaIdExp(_,_,_,_,clt) | PC.TMetaLocalIdExp(_,_,_,_,clt) + | PC.TMetaExpList(_,_,_,clt) + | PC.TMetaId(_,_,_,clt) | PC.TMetaType(_,_,clt) + | PC.TMetaStm(_,_,clt) | PC.TMetaStmList(_,_,clt) | PC.TMetaFunc(_,_,_,clt) + | PC.TMetaLocalFunc(_,_,_,clt) | PC.TMetaPos(_,_,_,clt) + + | PC.TFunDecl(clt) + | PC.TWhen(clt) | PC.TWhenTrue(clt) | PC.TWhenFalse(clt) + | PC.TAny(clt) | PC.TStrict(clt) | PC.TEllipsis(clt) + (* | PC.TCircles(clt) | PC.TStars(clt) *) + + | PC.TOEllipsis(clt) | PC.TCEllipsis(clt) + | PC.TPOEllipsis(clt) | PC.TPCEllipsis(clt) (*| PC.TOCircles(clt) + | PC.TCCircles(clt) | PC.TOStars(clt) | PC.TCStars(clt) *) + + | PC.TWhy(clt) | PC.TDotDot(clt) | PC.TBang(clt) | PC.TOPar(clt) + | PC.TOPar0(clt) | PC.TMid0(clt) | PC.TCPar(clt) + | PC.TCPar0(clt) + + | PC.TOBrace(clt) | PC.TCBrace(clt) | PC.TOCro(clt) | PC.TCCro(clt) + | PC.TOInit(clt) + + | PC.TPtrOp(clt) + + | PC.TDefine(clt,_) | PC.TDefineParam(clt,_,_) + | PC.TIncludeL(_,clt) | PC.TIncludeNL(_,clt) + + | PC.TEq(clt) | PC.TAssign(_,clt) | PC.TDot(clt) | PC.TComma(clt) + | PC.TPtVirg(clt) -> + let (_,line,_,_,_,_,_,_) = clt in Some line + + | _ -> None + +let rec insert_line_end = function + [] -> [] + | (((PC.TWhen(clt),q) as x)::xs) -> + x::(find_line_end true (token2line x) clt q xs) + | (((PC.TDefine(clt,_),q) as x)::xs) + | (((PC.TDefineParam(clt,_,_),q) as x)::xs) -> + x::(find_line_end false (token2line x) clt q xs) + | x::xs -> x::(insert_line_end xs) + +and find_line_end inwhen line clt q = function + (* don't know what 2nd component should be so just use the info of + the When. Also inherit - of when, if any *) + [] -> [(PC.TLineEnd(clt),q)] + | ((PC.TIdent("strict",clt),a) as x)::xs when token2line x = line -> + (PC.TStrict(clt),a) :: (find_line_end inwhen line clt q xs) + | ((PC.TIdent("STRICT",clt),a) as x)::xs when token2line x = line -> + (PC.TStrict(clt),a) :: (find_line_end inwhen line clt q xs) + | ((PC.TIdent("any",clt),a) as x)::xs when token2line x = line -> + (PC.TAny(clt),a) :: (find_line_end inwhen line clt q xs) + | ((PC.TIdent("ANY",clt),a) as x)::xs when token2line x = line -> + (PC.TAny(clt),a) :: (find_line_end inwhen line clt q xs) + | ((PC.TIdent("forall",clt),a) as x)::xs when token2line x = line -> + (PC.TForall,a) :: (find_line_end inwhen line clt q xs) + | ((PC.TIdent("exists",clt),a) as x)::xs when token2line x = line -> + (PC.TExists,a) :: (find_line_end inwhen line clt q xs) + | ((PC.TComma(clt),a) as x)::xs when token2line x = line -> + (PC.TComma(clt),a) :: (find_line_end inwhen line clt q xs) + | ((PC.TPArob,a) as x)::xs -> (* no line #, just assume on the same line *) + x :: (find_line_end inwhen line clt q xs) + | x::xs when token2line x = line -> x :: (find_line_end inwhen line clt q xs) + | xs -> (PC.TLineEnd(clt),q)::(insert_line_end xs) + +let rec translate_when_true_false = function + [] -> [] + | (PC.TWhen(clt),q)::((PC.TNotEq(_),_) as x)::(PC.TIdent("true",_),_)::xs -> + (PC.TWhenTrue(clt),q)::x::(translate_when_true_false xs) + | (PC.TWhen(clt),q)::((PC.TNotEq(_),_) as x)::(PC.TIdent("false",_),_)::xs -> + (PC.TWhenFalse(clt),q)::x::(translate_when_true_false xs) + | x::xs -> x :: (translate_when_true_false xs) + +(* ----------------------------------------------------------------------- *) +(* top level initializers: a sequence of braces followed by a dot *) + +let find_top_init tokens = + match tokens with + (PC.TOBrace(clt),q) :: rest -> + let rec dot_start acc = function + ((PC.TOBrace(_),_) as x) :: rest -> + dot_start (x::acc) rest + | ((PC.TDot(_),_) :: rest) as x -> + Some ((PC.TOInit(clt),q) :: (List.rev acc) @ x) + | l -> None in + let rec comma_end acc = function + ((PC.TCBrace(_),_) as x) :: rest -> + comma_end (x::acc) rest + | ((PC.TComma(_),_) :: rest) as x -> + Some ((PC.TOInit(clt),q) :: (List.rev x) @ acc) + | l -> None in + (match dot_start [] rest with + Some x -> x + | None -> + (match List.rev rest with + (* not super sure what this does, but EOF, @, and @@ should be + the same, markind the end of a rule *) + ((PC.EOF,_) as x)::rest | ((PC.TArob,_) as x)::rest + | ((PC.TArobArob,_) as x)::rest -> + (match comma_end [x] rest with + Some x -> x + | None -> tokens) + | _ -> + failwith "unexpected empty token list")) + | _ -> tokens + +(* ----------------------------------------------------------------------- *) +(* process pragmas: they can only be used in + code, and adjacent to +another + token. They are concatenated to the string representation of +that other token. *) + +let rec collect_all_pragmas collected = function + (PC.TPragma(s),_)::rest -> collect_all_pragmas (s::collected) rest + | l -> (List.rev collected,l) + +let rec collect_up_to_pragmas skipped = function + [] -> None (* didn't reach a pragma, so nothing to do *) + | ((PC.TPragma(s),_) as t)::rest -> + let (pragmas,rest) = collect_all_pragmas [] (t::rest) in + Some (List.rev skipped,pragmas,rest) + | x::xs -> + match plus_attachable x with + PLUS -> None + | NOTPLUS -> None + | SKIP -> collect_up_to_pragmas (x::skipped) xs + +let rec collect_up_to_plus skipped = function + [] -> failwith "nothing to attach a pragma to (empty)" + | x::xs -> + match plus_attachable x with + PLUS -> (List.rev skipped,x,xs) + | NOTPLUS -> failwith "nothing to attach a pragma to" + | SKIP -> collect_up_to_plus (x::skipped) xs + +let rec process_pragmas = function + [] -> [] + | ((PC.TPragma(s),_)::_) as l -> + let (pragmas,rest) = collect_all_pragmas [] l in + let (skipped,aft,rest) = collect_up_to_plus [] rest in + let (a,b,c,d,e,strbef,straft,pos) = get_clt aft in + skipped@ + (process_pragmas ((update_clt aft (a,b,c,d,e,pragmas,straft,pos))::rest)) + | bef::xs -> + (match plus_attachable bef with + PLUS -> + (match collect_up_to_pragmas [] xs with + Some(skipped,pragmas,rest) -> + let (a,b,c,d,e,strbef,straft,pos) = get_clt bef in + (update_clt bef (a,b,c,d,e,strbef,pragmas,pos)):: + skipped@(process_pragmas rest) + | None -> bef::(process_pragmas xs)) + | _ -> bef::(process_pragmas xs)) + +(* ----------------------------------------------------------------------- *) +(* Drop ... ... . This is only allowed in + code, and arises when there is +some - code between the ... *) +(* drop whens as well - they serve no purpose in + code and they cause +problems for drop_double_dots *) + +let rec drop_when = function + [] -> [] + | (PC.TWhen(clt),info)::xs -> + let rec loop = function + [] -> [] + | (PC.TLineEnd(_),info)::xs -> drop_when xs + | x::xs -> loop xs in + loop xs + | x::xs -> x::drop_when xs + +(* instead of dropping the double dots, we put TNothing in between them. +these vanish after the parser, but keeping all the ...s in the + code makes +it easier to align the + and - code in context_neg and in preparation for the +isomorphisms. This shouldn't matter because the context code of the + +slice is mostly ignored anyway *) +let rec drop_double_dots l = + let start = function + (PC.TOEllipsis(_),_) | (PC.TPOEllipsis(_),_) + (* | (PC.TOCircles(_),_) | (PC.TOStars(_),_) *) -> + true + | _ -> false in + let middle = function + (PC.TEllipsis(_),_) (* | (PC.TCircles(_),_) | (PC.TStars(_),_) *) -> true + | _ -> false in + let whenline = function + (PC.TLineEnd(_),_) -> true + | (PC.TMid0(_),_) -> true + | _ -> false in + let final = function + (PC.TCEllipsis(_),_) | (PC.TPCEllipsis(_),_) + (* | (PC.TCCircles(_),_) | (PC.TCStars(_),_) *) -> + true + | _ -> false in + let any_before x = start x or middle x or final x or whenline x in + let any_after x = start x or middle x or final x in + let rec loop ((_,i) as prev) = function + [] -> [] + | x::rest when any_before prev && any_after x -> + (PC.TNothing,i)::x::(loop x rest) + | x::rest -> x :: (loop x rest) in + match l with + [] -> [] + | (x::xs) -> x :: loop x xs + +let rec fix f l = + let cur = f l in + if l = cur then l else fix f cur + +(* ( | ... | ) also causes parsing problems *) + +exception Not_empty + +let rec drop_empty_thing starter middle ender = function + [] -> [] + | hd::rest when starter hd -> + let rec loop = function + x::rest when middle x -> loop rest + | x::rest when ender x -> rest + | _ -> raise Not_empty in + (match try Some(loop rest) with Not_empty -> None with + Some x -> drop_empty_thing starter middle ender x + | None -> hd :: drop_empty_thing starter middle ender rest) + | x::rest -> x :: drop_empty_thing starter middle ender rest + +let drop_empty_or = + drop_empty_thing + (function (PC.TOPar0(_),_) -> true | _ -> false) + (function (PC.TMid0(_),_) -> true | _ -> false) + (function (PC.TCPar0(_),_) -> true | _ -> false) + +let drop_empty_nest = drop_empty_thing + +(* ----------------------------------------------------------------------- *) +(* Read tokens *) + +let get_s_starts (_, (s,_,(starts, ends))) = + Printf.printf "%d %d\n" starts ends; (s, starts) + +let pop2 l = + let v = List.hd !l in + l := List.tl !l; + v + +let reinit _ = + PC.reinit (function _ -> PC.TArobArob (* a handy token *)) + (Lexing.from_function + (function buf -> function n -> raise Common.Impossible)) + +let parse_one str parsefn file toks = + let all_tokens = ref toks in + let cur_tok = ref (List.hd !all_tokens) in + + let lexer_function _ = + let (v, info) = pop2 all_tokens in + cur_tok := (v, info); + v in + + let lexbuf_fake = + Lexing.from_function + (function buf -> function n -> raise Common.Impossible) + in + + reinit(); + + try parsefn lexer_function lexbuf_fake + with + Lexer_cocci.Lexical s -> + failwith + (Printf.sprintf "%s: lexical error: %s\n =%s\n" str s + (Common.error_message file (get_s_starts !cur_tok) )) + | Parser_cocci_menhir.Error -> + failwith + (Printf.sprintf "%s: parse error: \n = %s\n" str + (Common.error_message file (get_s_starts !cur_tok) )) + | Semantic_cocci.Semantic s -> + failwith + (Printf.sprintf "%s: semantic error: %s\n =%s\n" str s + (Common.error_message file (get_s_starts !cur_tok) )) + + | e -> raise e + +let prepare_tokens tokens = + find_top_init + (translate_when_true_false (* after insert_line_end *) + (insert_line_end + (detect_types false (find_function_names (detect_attr tokens))))) + +let prepare_mv_tokens tokens = + detect_types false (detect_attr tokens) + +let rec consume_minus_positions = function + [] -> [] + | ((PC.TOPar0(_),_) as x)::xs | ((PC.TCPar0(_),_) as x)::xs + | ((PC.TMid0(_),_) as x)::xs -> x::consume_minus_positions xs + | x::(PC.TPArob,_)::(PC.TMetaPos(name,constraints,per,clt),_)::xs -> + let (arity,ln,lln,offset,col,strbef,straft,_) = get_clt x in + let name = Parse_aux.clt2mcode name clt in + let x = + update_clt x + (arity,ln,lln,offset,col,strbef,straft, + Ast0.MetaPos(name,constraints,per)) in + x::(consume_minus_positions xs) + | x::xs -> x::consume_minus_positions xs + +let any_modif rule = + let mcode x = + match Ast0.get_mcode_mcodekind x with + Ast0.MINUS _ | Ast0.PLUS -> true + | _ -> false in + let donothing r k e = k e in + let bind x y = x or y in + let option_default = false in + let fn = + V0.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing donothing donothing + donothing donothing in + List.exists fn.V0.combiner_top_level rule + +let drop_last extra l = List.rev(extra@(List.tl(List.rev l))) + +let partition_either l = + let rec part_either left right = function + | [] -> (List.rev left, List.rev right) + | x :: l -> + (match x with + | Common.Left e -> part_either (e :: left) right l + | Common.Right e -> part_either left (e :: right) l) in + part_either [] [] l + +let get_metavars parse_fn table file lexbuf = + let rec meta_loop acc (* read one decl at a time *) = + let (_,tokens) = + tokens_all table file true lexbuf [PC.TArobArob;PC.TMPtVirg] in + let tokens = prepare_mv_tokens tokens in + match tokens with + [(PC.TArobArob,_)] -> List.rev acc + | _ -> + let metavars = parse_one "meta" parse_fn file tokens in + meta_loop (metavars@acc) in + partition_either (meta_loop []) + +let get_script_metavars parse_fn table file lexbuf = + let rec meta_loop acc = + let (_, tokens) = + tokens_all table file true lexbuf [PC.TArobArob; PC.TMPtVirg] in + let tokens = prepare_tokens tokens in + match tokens with + [(PC.TArobArob, _)] -> List.rev acc + | _ -> + let metavar = parse_one "scriptmeta" parse_fn file tokens in + meta_loop (metavar :: acc) + in + meta_loop [] + +let get_rule_name parse_fn starts_with_name get_tokens file prefix = + Data.in_rule_name := true; + let mknm _ = make_name prefix (!Lexer_cocci.line) in + let name_res = + if starts_with_name + then + let (_,tokens) = get_tokens [PC.TArob] in + let check_name = function + None -> Some (mknm()) + | Some nm -> + (if List.mem nm reserved_names + then failwith (Printf.sprintf "invalid name %s\n" nm)); + Some nm in + match parse_one "rule name" parse_fn file tokens with + Ast.CocciRulename (nm,a,b,c,d,e) -> + Ast.CocciRulename (check_name nm,a,b,c,d,e) + | Ast.GeneratedRulename (nm,a,b,c,d,e) -> + Ast.GeneratedRulename (check_name nm,a,b,c,d,e) + | Ast.ScriptRulename(s,deps) -> Ast.ScriptRulename(s,deps) + else + Ast.CocciRulename(Some(mknm()),Ast.NoDep,[],[],Ast.Undetermined,false) in + Data.in_rule_name := false; + name_res + +let parse_iso file = + let table = Common.full_charpos_to_pos file in + Common.with_open_infile file (fun channel -> + let lexbuf = Lexing.from_channel channel in + let get_tokens = tokens_all table file false lexbuf in + let res = + match get_tokens [PC.TArobArob;PC.TArob] with + (true,start) -> + let parse_start start = + let rev = List.rev start in + let (arob,_) = List.hd rev in + (arob = PC.TArob,List.rev(List.tl rev)) in + let (starts_with_name,start) = parse_start start in + let rec loop starts_with_name start = + (!Data.init_rule)(); + (* get metavariable declarations - have to be read before the + rest *) + let (rule_name,_,_,_,_,_) = + match get_rule_name PC.iso_rule_name starts_with_name get_tokens + file ("iso file "^file) with + Ast.CocciRulename (Some n,a,b,c,d,e) -> (n,a,b,c,d,e) + | _ -> failwith "Script rules cannot appear in isomorphism rules" + in + Ast0.rule_name := rule_name; + Data.in_meta := true; + let iso_metavars = + match get_metavars PC.iso_meta_main table file lexbuf with + (iso_metavars,[]) -> iso_metavars + | _ -> failwith "unexpected inheritance in iso" in + Data.in_meta := false; + (* get the rule *) + let (more,tokens) = + get_tokens + [PC.TIsoStatement;PC.TIsoExpression;PC.TIsoArgExpression; + PC.TIsoTestExpression; + PC.TIsoDeclaration;PC.TIsoType;PC.TIsoTopLevel] in + let next_start = List.hd(List.rev tokens) in + let dummy_info = ("",(-1,-1),(-1,-1)) in + let tokens = drop_last [(PC.EOF,dummy_info)] tokens in + let tokens = prepare_tokens (start@tokens) in + (* + print_tokens "iso tokens" tokens; + *) + let entry = parse_one "iso main" PC.iso_main file tokens in + let entry = List.map (List.map Test_exps.process_anything) entry in + if more + then (* The code below allows a header like Statement list, + which is more than one word. We don't have that any more, + but the code is left here in case it is put back. *) + match get_tokens [PC.TArobArob;PC.TArob] with + (true,start) -> + let (starts_with_name,start) = parse_start start in + (iso_metavars,entry,rule_name) :: + (loop starts_with_name (next_start::start)) + | _ -> failwith "isomorphism ends early" + else [(iso_metavars,entry,rule_name)] in + loop starts_with_name start + | (false,_) -> [] in + res) + +let parse_iso_files existing_isos iso_files extra_path = + let get_names = List.map (function (_,_,nm) -> nm) in + let old_names = get_names existing_isos in + Data.in_iso := true; + let (res,_) = + List.fold_left + (function (prev,names) -> + function file -> + Lexer_cocci.init (); + let file = + match file with + Common.Left(fl) -> Filename.concat extra_path fl + | Common.Right(fl) -> Filename.concat Config.path fl in + let current = parse_iso file in + let new_names = get_names current in + if List.exists (function x -> List.mem x names) new_names + then failwith (Printf.sprintf "repeated iso name found in %s" file); + (current::prev,new_names @ names)) + ([],old_names) iso_files in + Data.in_iso := false; + existing_isos@(List.concat (List.rev res)) + +let parse file = + let table = Common.full_charpos_to_pos file in + Common.with_open_infile file (fun channel -> + let lexbuf = Lexing.from_channel channel in + let get_tokens = tokens_all table file false lexbuf in + Data.in_prolog := true; + let initial_tokens = get_tokens [PC.TArobArob;PC.TArob] in + Data.in_prolog := false; + let res = + match initial_tokens with + (true,data) -> + (match List.rev data with + ((PC.TArobArob as x),_)::_ | ((PC.TArob as x),_)::_ -> + let iso_files = + parse_one "iso file names" PC.include_main file data in + + let parse_cocci_rule ruletype old_metas + (rule_name, dependencies, iso, dropiso, exists, is_expression) = + Ast0.rule_name := rule_name; + Data.inheritable_positions := + rule_name :: !Data.inheritable_positions; + + (* get metavariable declarations *) + Data.in_meta := true; + let (metavars, inherited_metavars) = + get_metavars PC.meta_main table file lexbuf in + Data.in_meta := false; + Hashtbl.add Data.all_metadecls rule_name metavars; + Hashtbl.add Lexer_cocci.rule_names rule_name (); + Hashtbl.add Lexer_cocci.all_metavariables rule_name + (Hashtbl.fold + (fun key v rest -> (key,v)::rest) + Lexer_cocci.metavariables []); + + (* get transformation rules *) + let (more, tokens) = get_tokens [PC.TArobArob; PC.TArob] in + let (minus_tokens, plus_tokens) = split_token_stream tokens in + + let minus_tokens = consume_minus_positions minus_tokens in + let minus_tokens = prepare_tokens minus_tokens in + let plus_tokens = prepare_tokens plus_tokens in + + (* + print_tokens "minus tokens" minus_tokens; + print_tokens "plus tokens" plus_tokens; + *) + + let plus_tokens = + process_pragmas + (fix (function x -> drop_double_dots (drop_empty_or x)) + (drop_when plus_tokens)) in + (* + print_tokens "plus tokens" plus_tokens; + Printf.printf "before minus parse\n"; + *) + let minus_res = + if is_expression + then parse_one "minus" PC.minus_exp_main file minus_tokens + else parse_one "minus" PC.minus_main file minus_tokens in + (* + Unparse_ast0.unparse minus_res; + Printf.printf "before plus parse\n"; + *) + let plus_res = + if !Flag.sgrep_mode2 + then (* not actually used for anything, except context_neg *) + List.map + (Iso_pattern.rebuild_mcode None).V0.rebuilder_top_level + minus_res + else + if is_expression + then parse_one "plus" PC.plus_exp_main file plus_tokens + else parse_one "plus" PC.plus_main file plus_tokens in + (* + Printf.printf "after plus parse\n"; + *) + + (if not !Flag.sgrep_mode2 && + (any_modif minus_res or any_modif plus_res) + then Data.inheritable_positions := []); + + Check_meta.check_meta rule_name old_metas inherited_metavars + metavars minus_res plus_res; + + (more, Ast0.CocciRule ((minus_res, metavars, + (iso, dropiso, dependencies, rule_name, exists)), + (plus_res, metavars), ruletype), metavars, tokens) in + + let parse_script_rule language old_metas deps = + let get_tokens = tokens_script_all table file false lexbuf in + + (* meta-variables *) + Data.in_meta := true; + let metavars = + get_script_metavars PC.script_meta_main table file lexbuf in + Data.in_meta := false; + + let exists_in old_metas (py,(r,m)) = + let test (rr,mr) x = + let (ro,vo) = Ast.get_meta_name x in + ro = rr && vo = mr in + List.exists (test (r,m)) old_metas in + + List.iter + (function x -> + let meta2c (r,n) = Printf.sprintf "%s.%s" r n in + if not (exists_in old_metas x) then + failwith + (Printf.sprintf + "Script references unknown meta-variable: %s" + (meta2c(snd x)))) + metavars; + + (* script code *) + let (more, tokens) = get_tokens [PC.TArobArob; PC.TArob] in + let data = + match List.hd tokens with + (PC.TScriptData(s),_) -> s + | (PC.TArobArob,_) | (PC.TArob,_) -> "" + | _ -> failwith "Malformed script rule" in + (more,Ast0.ScriptRule(language, deps, metavars, data),[],tokens) in + + let parse_rule old_metas starts_with_name = + let rulename = + get_rule_name PC.rule_name starts_with_name get_tokens file + "rule" in + match rulename with + Ast.CocciRulename (Some s, a, b, c, d, e) -> + parse_cocci_rule Ast.Normal old_metas (s, a, b, c, d, e) + | Ast.GeneratedRulename (Some s, a, b, c, d, e) -> + Data.in_generating := true; + let res = + parse_cocci_rule Ast.Generated old_metas (s,a,b,c,d,e) in + Data.in_generating := false; + res + | Ast.ScriptRulename (l,deps) -> parse_script_rule l old_metas deps + | _ -> failwith "Malformed rule name" + in + + let rec loop old_metas starts_with_name = + (!Data.init_rule)(); + + let gen_starts_with_name more tokens = + more && + (match List.hd (List.rev tokens) with + (PC.TArobArob,_) -> false + | (PC.TArob,_) -> true + | _ -> failwith "unexpected token") + in + + let (more, rule, metavars, tokens) = + parse_rule old_metas starts_with_name in + if more then + rule:: + (loop (metavars @ old_metas) (gen_starts_with_name more tokens)) + else [rule]; + + in + + (iso_files, loop [] (x = PC.TArob)) + | _ -> failwith "unexpected code before the first rule\n") + | (false,[(PC.TArobArob,_)]) | (false,[(PC.TArob,_)]) -> + ([],([] : Ast0.parsed_rule list)) + | _ -> failwith "unexpected code before the first rule\n" in + res) + +(* parse to ast0 and then convert to ast *) +let process file isofile verbose = + let extra_path = Filename.dirname file in + Lexer_cocci.init(); + let (iso_files, rules) = parse file in + let std_isos = + match isofile with + None -> [] + | Some iso_file -> parse_iso_files [] [Common.Left iso_file] "" in + let global_isos = parse_iso_files std_isos iso_files extra_path in + let rules = Unitary_ast0.do_unitary rules in + let parsed = + List.map + (function + Ast0.ScriptRule (a,b,c,d) -> [([],Ast.ScriptRule (a,b,c,d))] + | Ast0.CocciRule + ((minus, metavarsm, + (iso, dropiso, dependencies, rule_name, exists)), + (plus, metavars),ruletype) -> + let chosen_isos = + parse_iso_files global_isos + (List.map (function x -> Common.Left x) iso) + extra_path in + let chosen_isos = + (* check that dropped isos are actually available *) + (try + let iso_names = + List.map (function (_,_,nm) -> nm) chosen_isos in + let local_iso_names = reserved_names @ iso_names in + let bad_dropped = + List.find + (function dropped -> + not (List.mem dropped local_iso_names)) + dropiso in + failwith + ("invalid iso name " ^ bad_dropped ^ " in " ^ rule_name) + with Not_found -> ()); + if List.mem "all" dropiso + then + if List.length dropiso = 1 + then [] + else failwith "disable all should only be by itself" + else (* drop those isos *) + List.filter + (function (_,_,nm) -> not (List.mem nm dropiso)) + chosen_isos in + List.iter Iso_compile.process chosen_isos; + let dropped_isos = + match reserved_names with + "all"::others -> + (match dropiso with + ["all"] -> others + | _ -> + List.filter (function x -> List.mem x dropiso) others) + | _ -> + failwith + "bad list of reserved names - all must be at start" in + let minus = Test_exps.process minus in + let minus = Compute_lines.compute_lines minus in + let plus = Compute_lines.compute_lines plus in + let is_exp = + (* only relevant to Flag.make_hrule *) + (* doesn't handle multiple minirules properly, but since + we don't really handle them in lots of other ways, it + doesn't seem very important *) + match plus with + [] -> [false] + | p::_ -> + [match Ast0.unwrap p with + Ast0.CODE c -> + (match List.map Ast0.unwrap (Ast0.undots c) with + [Ast0.Exp e] -> true | _ -> false) + | _ -> false] in + let minus = Arity.minus_arity minus in + let ((metavars,minus),function_prototypes) = + Function_prototypes.process + rule_name metavars dropped_isos minus plus ruletype in + (* warning! context_neg side-effects its arguments *) + let (m,p) = List.split (Context_neg.context_neg minus plus) in + Type_infer.type_infer p; + (if not !Flag.sgrep_mode2 + then Insert_plus.insert_plus m p (chosen_isos = [])); + Type_infer.type_infer minus; + let (extra_meta, minus) = + match (chosen_isos,ruletype) with + (* separate case for [] because applying isos puts + some restrictions on the -+ code *) + ([],_) | (_,Ast.Generated) -> ([],minus) + | _ -> Iso_pattern.apply_isos chosen_isos minus rule_name in + let minus = Comm_assoc.comm_assoc minus rule_name dropiso in + let minus = + if !Flag.sgrep_mode2 then minus + else Single_statement.single_statement minus in + let minus = Simple_assignments.simple_assignments minus in + let minus_ast = + Ast0toast.ast0toast rule_name dependencies dropped_isos + exists minus is_exp ruletype in + match function_prototypes with + None -> [(extra_meta @ metavars, minus_ast)] + | Some mv_fp -> + [(extra_meta @ metavars, minus_ast); mv_fp]) +(* Ast0.CocciRule ((minus, metavarsm, (iso, dropiso, dependencies, rule_name, exists)), (plus, metavars))*) + rules in + let parsed = List.concat parsed in + let disjd = Disjdistr.disj parsed in + + let (metavars,code,fvs,neg_pos,ua,pos) = Free_vars.free_vars disjd in + if !Flag_parsing_cocci.show_SP + then List.iter Pretty_print_cocci.unparse code; + + let grep_tokens = + Common.profile_code "get_constants" + (fun () -> Get_constants.get_constants code) in (* for grep *) + let glimpse_tokens2 = + Common.profile_code "get_glimpse_constants" + (fun () -> Get_constants2.get_constants code neg_pos) in(* for glimpse *) + (metavars,code,fvs,neg_pos,ua,pos,grep_tokens,glimpse_tokens2) diff --git a/parsing_cocci/.#parser_cocci_menhir.mly.1.166 b/parsing_cocci/.#parser_cocci_menhir.mly.1.166 new file mode 100644 index 0000000..8172b30 --- /dev/null +++ b/parsing_cocci/.#parser_cocci_menhir.mly.1.166 @@ -0,0 +1,1847 @@ +/* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*/ + + +%{ + +(* Not clear how to allow function declarations to specify a return type +and how to allow both to be specified as static, because they are in +different rules. The rules seem to have to be combined, which would allow +functions to be declared as local variables *) + +(* Not clear how to let a function have a parameter of type void. At the +moment, void is allowed to be the type of a variable, which is wrong, and a +parameter needs both a type and an identifier *) +module Ast0 = Ast0_cocci +module Ast = Ast_cocci +module P = Parse_aux +%} + +%token EOF + +%token TIdentifier TExpression TStatement TFunction TLocal TType TParameter +%token TIdExpression +%token Tlist TFresh TConstant TError TWords TWhy0 TPlus0 TBang0 +%token TPure TContext TGenerated +%token TTypedef TDeclarer TIterator TName TPosition TPosAny +%token TUsing TDisable TExtends TDepends TOn TEver TNever TExists TForall +%token TScript TReverse TNothing +%token TRuleName + +%token Tchar Tshort Tint Tdouble Tfloat Tlong +%token Tvoid Tstruct Tunion Tenum +%token Tunsigned Tsigned + +%token Tstatic Tauto Tregister Textern Tinline Ttypedef +%token Tconst Tvolatile +%token Tattr + +%token TIf TElse TWhile TFor TDo TSwitch TCase TDefault TReturn +%token TBreak TContinue TGoto TSizeof TFunDecl +%token TIdent TTypeId TDeclarerId TIteratorId + +%token TMetaId TMetaFunc TMetaLocalFunc +%token TMetaIterator TMetaDeclarer +%token TMetaErr +%token TMetaParam TMetaStm TMetaStmList TMetaType +%token TMetaParamList TMetaExpList +%token TMetaExp TMetaIdExp TMetaLocalIdExp TMetaConst +%token TMetaPos + +%token TArob TArobArob TPArob +%token TScriptData + +%token TEllipsis TOEllipsis TCEllipsis TPOEllipsis TPCEllipsis +%token TWhen TWhenTrue TWhenFalse TAny TStrict TLineEnd + +%token TWhy TDotDot TBang TOPar TOPar0 +%token TMid0 TCPar TCPar0 + +%token TPragma TPathIsoFile +%token TIncludeL TIncludeNL +%token TDefine +%token TDefineParam +%token TMinusFile TPlusFile + +%token TInc TDec + +%token TString TChar TFloat TInt + +%token TOrLog +%token TAndLog +%token TOr +%token TXor +%token TAnd +%token TEqEq TNotEq +%token TLogOp /* TInf TSup TInfEq TSupEq */ +%token TShOp /* TShl TShr */ +%token TDmOp /* TDiv TMod */ +%token TPlus TMinus +%token TMul TTilde + +%token TOBrace TCBrace TOInit +%token TOCro TCCro + +%token TPtrOp + +%token TMPtVirg +%token TEq TDot TComma TPtVirg +%token TAssign + +%token TIso TRightIso TIsoExpression TIsoStatement TIsoDeclaration TIsoType +%token TIsoTopLevel TIsoArgExpression TIsoTestExpression + +%token TInvalid + +/* operator precedence */ +%nonassoc TIf +%nonassoc TElse + +%left TOrLog +%left TAndLog +%left TOr +%left TXor +%left TAnd +%left TEqEq TNotEq +%left TLogOp /* TInf TSup TInfEq TSupEq */ +%left TShOp /* TShl TShr */ +%left TPlus TMinus +%left TMul TDmOp /* TDiv TMod */ + +%start reinit +%type reinit + +%start minus_main +%type minus_main + +%start minus_exp_main +%type minus_exp_main + +%start plus_main +%type plus_main + +%start plus_exp_main +%type plus_exp_main + +%start include_main +%type <(string,string) Common.either list> include_main + +%start iso_rule_name +%type +iso_rule_name + +%start rule_name +%type +rule_name + +%start meta_main +%type <(Ast_cocci.metavar,Ast_cocci.metavar) Common.either list> meta_main + +%start script_meta_main + +%start iso_main +%type iso_main + +%start iso_meta_main +%type <(Ast_cocci.metavar,Ast_cocci.metavar) Common.either list> iso_meta_main + +%start never_used +%type never_used + +%% + +reinit: { } +minus_main: minus_body EOF { $1 } | m=minus_body TArobArob { m } +| m=minus_body TArob { m } +plus_main: plus_body EOF { $1 } | p=plus_body TArobArob { p } +| p=plus_body TArob { p } +minus_exp_main: minus_exp_body EOF { $1 } | m=minus_exp_body TArobArob { m } +| m=minus_exp_body TArob { m } +plus_exp_main: plus_exp_body EOF { $1 } | p=plus_exp_body TArobArob { p } +| p=plus_exp_body TArob { p } +meta_main: m=metadec { m (!Ast0.rule_name) } +iso_meta_main: m=metadec { m "" } + +/***************************************************************************** +* +* +*****************************************************************************/ + +pure: + TPure { Ast0.Pure } +| TContext { Ast0.Context } +| TPure TContext { Ast0.PureContext } +| TContext TPure { Ast0.PureContext } +| /* empty */ { Ast0.Impure } + +iso_rule_name: + nm=pure_ident TArob { P.make_iso_rule_name_result (P.id2name nm) } + +rule_name: + nm=ioption(pure_ident) extends d=depends i=loption(choose_iso) + a=loption(disable) e=exists ee=is_expression TArob + { P.make_cocci_rule_name_result nm d i a e ee } + | TGenerated extends d=depends i=loption(choose_iso) + a=loption(disable) e=exists ee=is_expression TArob + /* these rules have no name as a cheap way to ensure that no normal + rule inherits their metavariables or depends on them */ + { P.make_generated_rule_name_result None d i a e ee } + | TScript TDotDot lang=pure_ident d=depends TArob + { P.make_script_rule_name_result lang d } + +extends: + /* empty */ { () } +| TExtends parent=TRuleName + { !Data.install_bindings (parent) } + +depends: + /* empty */ { Ast.NoDep } +| TDepends TOn parents=dep { parents } + +dep: + pnrule { $1 } +| dep TAndLog dep { Ast.AndDep($1, $3) } +| dep TOrLog dep { Ast.OrDep ($1, $3) } + +pnrule: + TRuleName { Ast.Dep $1 } +| TBang TRuleName { Ast.AntiDep $2 } +| TEver TRuleName { Ast.EverDep $2 } +| TNever TRuleName { Ast.NeverDep $2 } +| TOPar dep TCPar { $2 } + +choose_iso: + TUsing separated_nonempty_list(TComma,TString) { List.map P.id2name $2 } + +disable: + TDisable separated_nonempty_list(TComma,pure_ident) { List.map P.id2name $2 } + +exists: + TExists { Ast.Exists } +| TForall { Ast.Forall } +| TReverse TForall { Ast.ReverseForall } +| { Ast.Undetermined } + +is_expression: // for more flexible parsing of top level expressions + { false } +| TExpression { true } + +include_main: + list(incl) TArob { $1 } +| list(incl) TArobArob { $1 } + +incl: + TUsing TString { Common.Left(P.id2name $2) } +| TUsing TPathIsoFile { Common.Right $2 } + +metadec: + ar=arity ispure=pure + kindfn=metakind ids=comma_list(pure_ident_or_meta_ident) TMPtVirg + { P.create_metadec ar ispure kindfn ids } +| ar=arity ispure=pure + kindfn=metakind_atomic + ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_eq)) TMPtVirg + { P.create_metadec_ne ar ispure kindfn ids } +| ar=arity ispure=pure + kindfn=metakind_atomic_expi + ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_eqe)) TMPtVirg + { P.create_metadec_ne ar ispure kindfn ids } +| ar=arity ispure=pure + kindfn=metakind_atomic_expe + ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_ceq)) TMPtVirg + { P.create_metadec_ne ar ispure kindfn ids } +| ar=arity TPosition a=option(TPosAny) + ids=comma_list(pure_ident_or_meta_ident_with_not_eq(not_pos)) TMPtVirg + (* pb: position variables can't be inherited from normal rules, and then + there is no way to inherit from a generated rule, so there is no point + to have a position variable *) + { (if !Data.in_generating + then failwith "position variables not allowed in a generated rule file"); + let kindfn arity name pure check_meta constraints = + let tok = check_meta(Ast.MetaPosDecl(arity,name)) in + let any = match a with None -> Ast.PER | Some _ -> Ast.ALL in + !Data.add_pos_meta name constraints any; tok in + P.create_metadec_ne ar false kindfn ids } +| ar=arity ispure=pure + TParameter Tlist TOCro id=pure_ident_or_meta_ident TCCro + ids=comma_list(pure_ident_or_meta_ident) TMPtVirg + { P.create_len_metadec ar ispure + (fun lenname arity name pure check_meta -> + let tok = + check_meta(Ast.MetaParamListDecl(arity,name,Some lenname)) in + !Data.add_paramlist_meta name (Some lenname) pure; tok) + id ids } +| ar=arity ispure=pure + TExpression Tlist TOCro id=pure_ident_or_meta_ident TCCro + ids=comma_list(pure_ident_or_meta_ident) TMPtVirg + { P.create_len_metadec ar ispure + (fun lenname arity name pure check_meta -> + let tok = + check_meta(Ast.MetaExpListDecl(arity,name,Some lenname)) in + !Data.add_explist_meta name (Some lenname) pure; tok) + id ids } + +%inline metakind: + TFresh TIdentifier + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaFreshIdDecl(arity,name)) in + !Data.add_id_meta name [] pure; tok) } +| TParameter + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaParamDecl(arity,name)) in + !Data.add_param_meta name pure; tok) } +| TParameter Tlist + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaParamListDecl(arity,name,None)) in + !Data.add_paramlist_meta name None pure; tok) } +| TExpression Tlist + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaExpListDecl(arity,name,None)) in + !Data.add_explist_meta name None pure; tok) } +| TType + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaTypeDecl(arity,name)) in + !Data.add_type_meta name pure; tok) } +| TStatement + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaStmDecl(arity,name)) in + !Data.add_stm_meta name pure; tok) } +| TStatement Tlist + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaStmListDecl(arity,name)) in + !Data.add_stmlist_meta name pure; tok) } +| TTypedef + { (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")) } +| TDeclarer TName + { (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")) } +| TIterator TName + { (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")) } + + +%inline metakind_atomic: + TIdentifier + { (fun arity name pure check_meta constraints -> + let tok = check_meta(Ast.MetaIdDecl(arity,name)) in + !Data.add_id_meta name constraints pure; tok) } +| TFunction + { (fun arity name pure check_meta constraints -> + let tok = check_meta(Ast.MetaFuncDecl(arity,name)) in + !Data.add_func_meta name constraints pure; tok) } +| TLocal TFunction + { (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) } +| TDeclarer + { (fun arity name pure check_meta constraints -> + let tok = check_meta(Ast.MetaDeclarerDecl(arity,name)) in + !Data.add_declarer_meta name constraints pure; tok) } +| TIterator + { (fun arity name pure check_meta constraints -> + let tok = check_meta(Ast.MetaIteratorDecl(arity,name)) in + !Data.add_iterator_meta name constraints pure; tok) } + +%inline metakind_atomic_expi: + TError + { (fun arity name pure check_meta constraints -> + let tok = check_meta(Ast.MetaErrDecl(arity,name)) in + !Data.add_err_meta name constraints pure; tok) } +| l=option(TLocal) TIdExpression ty=ioption(meta_exp_type) + { (fun arity name pure check_meta constraints -> + match l with + None -> + !Data.add_idexp_meta ty name constraints pure; + check_meta(Ast.MetaIdExpDecl(arity,name,ty)) + | Some _ -> + !Data.add_local_idexp_meta ty name constraints pure; + check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) } +| l=option(TLocal) TIdExpression m=nonempty_list(TMul) + { (fun arity name pure check_meta constraints -> + let ty = Some [P.ty_pointerify Type_cocci.Unknown m] in + match l with + None -> + !Data.add_idexp_meta ty name constraints pure; + check_meta(Ast.MetaIdExpDecl(arity,name,ty)) + | Some _ -> + !Data.add_local_idexp_meta ty name constraints pure; + check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) } +| TExpression m=nonempty_list(TMul) + { (fun arity name pure check_meta constraints -> + let ty = Some [P.ty_pointerify Type_cocci.Unknown m] in + let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in + !Data.add_exp_meta ty name constraints pure; tok) } +| vl=meta_exp_type TOCro TCCro + { (fun arity name pure check_meta constraints -> + let ty = Some (List.map (function x -> Type_cocci.Array x) vl) in + let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in + !Data.add_exp_meta ty name constraints pure; tok) } +| TConstant ty=ioption(meta_exp_type) + { (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) } + +%inline metakind_atomic_expe: + TExpression + { (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) } +| vl=meta_exp_type // no error if use $1 but doesn't type check + { (fun arity name pure check_meta constraints -> + let ty = Some vl in + List.iter + (function c -> + match Ast0.unwrap c with + Ast0.Constant(_) -> + if not + (List.exists + (function + Type_cocci.BaseType(Type_cocci.IntType) -> true + | Type_cocci.BaseType(Type_cocci.ShortType) -> true + | Type_cocci.BaseType(Type_cocci.LongType) -> true + | _ -> false) + vl) + then failwith "metavariable with int constraint must be an int" + | _ -> ()) + constraints; + let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in + !Data.add_exp_meta ty name constraints pure; tok) } + + +meta_exp_type: + t=ctype + { [Ast0_cocci.ast0_type_to_type t] } +| TOBrace t=comma_list(ctype) TCBrace m=list(TMul) + { List.map + (function x -> P.ty_pointerify (Ast0_cocci.ast0_type_to_type x) m) + t } + +arity: TBang0 { Ast.UNIQUE } + | TWhy0 { Ast.OPT } + | TPlus0 { Ast.MULTI } + | /* empty */ { Ast.NONE } + +generic_ctype_full: + q=ctype_qualif_opt ty=Tchar + { q (Ast0.wrap(Ast0.BaseType(Ast.CharType,[P.clt2mcode "char" ty]))) } + | q=ctype_qualif_opt ty=Tshort + { q (Ast0.wrap(Ast0.BaseType(Ast.ShortType,[P.clt2mcode "short" ty])))} + | q=ctype_qualif_opt ty=Tint + { q (Ast0.wrap(Ast0.BaseType(Ast.IntType,[P.clt2mcode "int" ty]))) } + | t=Tdouble + { Ast0.wrap(Ast0.BaseType(Ast.DoubleType,[P.clt2mcode "double" t])) } + | t=Tfloat + { Ast0.wrap(Ast0.BaseType(Ast.FloatType,[P.clt2mcode "float" t])) } + | q=ctype_qualif_opt ty=Tlong + { q (Ast0.wrap(Ast0.BaseType(Ast.LongType,[P.clt2mcode "long" ty]))) } + | q=ctype_qualif_opt ty=Tlong ty1=Tlong + { q (Ast0.wrap + (Ast0.BaseType + (Ast.LongLongType, + [P.clt2mcode "long" ty;P.clt2mcode "long" ty1]))) } + | s=Tenum i=ident + { Ast0.wrap(Ast0.EnumName(P.clt2mcode "enum" s, i)) } + | s=struct_or_union i=ident + { Ast0.wrap(Ast0.StructUnionName(s, Some i)) } + | s=struct_or_union i=ioption(ident) + l=TOBrace d=struct_decl_list r=TCBrace + { (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)) } + | s=TMetaType l=TOBrace d=struct_decl_list r=TCBrace + { 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)) } + | r=TRuleName TDot p=TIdent + { 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*))) } + | p=TTypeId + { Ast0.wrap(Ast0.TypeName(P.id2mcode p)) } + | q=ctype_qualif_opt p=TMetaType + { let (nm,pure,clt) = p in + q (Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure))) } + +generic_ctype: + q=ctype_qualif { q None } + | generic_ctype_full { $1 } + +struct_or_union: + s=Tstruct { P.clt2mcode Ast.Struct s } + | u=Tunion { P.clt2mcode Ast.Union u } + +struct_decl: + TNothing { [] } + | t=ctype d=d_ident pv=TPtVirg + { let (id,fn) = d in + [Ast0.wrap(Ast0.UnInit(None,fn t,id,P.clt2mcode ";" pv))] } + | t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar + lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar pv=TPtVirg + { let (id,fn) = d in + let t = + Ast0.wrap + (Ast0.FunctionPointer + (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))] } + | cv=ioption(const_vol) i=pure_ident d=d_ident pv=TPtVirg + { 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))] } + +struct_decl_list: + struct_decl_list_start { Ast0.wrap(Ast0.DOTS($1)) } + +struct_decl_list_start: + struct_decl { $1 } +| struct_decl struct_decl_list_start { $1@$2 } +| d=edots_when(TEllipsis,struct_decl) r=continue_struct_decl_list + { (P.mkddots "..." d)::r } + +continue_struct_decl_list: + /* empty */ { [] } +| struct_decl struct_decl_list_start { $1@$2 } +| struct_decl { $1 } + +ctype: + cv=ioption(const_vol) ty=generic_ctype m=list(TMul) + { P.pointerify (P.make_cv cv ty) m } + | cv=ioption(const_vol) t=Tvoid m=nonempty_list(TMul) + { let ty = + Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in + P.pointerify (P.make_cv cv ty) m } + | lp=TOPar0 t=midzero_list(ctype,ctype) rp=TCPar0 + /* more hacks */ + { let (mids,code) = t in + Ast0.wrap + (Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) } + +ctype_full: + cv=ioption(const_vol) ty=generic_ctype_full m=list(TMul) + { P.pointerify (P.make_cv cv ty) m } + | cv=ioption(const_vol) t=Tvoid m=nonempty_list(TMul) + { let ty = + Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in + P.pointerify (P.make_cv cv ty) m } + | lp=TOPar0 t=midzero_list(ctype,ctype) rp=TCPar0 + /* more hacks */ + { let (mids,code) = t in + Ast0.wrap + (Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) } + + +fn_ctype: // allows metavariables + ty=generic_ctype m=list(TMul) { P.pointerify ty m } + | t=Tvoid m=list(TMul) + { P.pointerify + (Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t]))) + m } + +%inline ctype_qualif: + r=Tunsigned + { function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) } +| r=Tsigned + { function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) } + +%inline ctype_qualif_opt: + s=ctype_qualif { function x -> s (Some x) } +| /* empty */ { function x -> x } + +/*****************************************************************************/ + +/* have to inline everything to avoid conflicts? switch to proper +declarations, statements, and expressions for the subterms */ + +minus_body: + f=loption(filespec) + b=loption(minus_start) + ew=loption(error_words) + { match f@b@ew with + [] -> raise (Semantic_cocci.Semantic "minus slice can't be empty") + | code -> Top_level.top_level code } + +plus_body: + f=loption(filespec) + b=loption(plus_start) + ew=loption(error_words) + { Top_level.top_level (f@b@ew) } + +minus_exp_body: + f=loption(filespec) + b=top_eexpr + ew=loption(error_words) + { match f@[b]@ew with + [] -> raise (Semantic_cocci.Semantic "minus slice can't be empty") + | code -> Top_level.top_level code } + +plus_exp_body: + f=loption(filespec) + b=top_eexpr + ew=loption(error_words) + { Top_level.top_level (f@[b]@ew) } + +filespec: + TMinusFile TPlusFile + { [Ast0.wrap + (Ast0.FILEINFO(P.id2mcode $1, + P.id2mcode $2))] } + +includes: + TIncludeL + { Ast0.wrap + (Ast0.Include(P.clt2mcode "#include" (P.drop_aft (P.id2clt $1)), + let (arity,ln,lln,offset,col,strbef,straft,pos) = + P.id2clt $1 in + let clt = + (arity,ln,lln,offset,0,strbef,straft,pos) in + P.clt2mcode + (Ast.Local (Parse_aux.str2inc (P.id2name $1))) + (P.drop_bef clt))) } +| TIncludeNL + { Ast0.wrap + (Ast0.Include(P.clt2mcode "#include" (P.drop_aft (P.id2clt $1)), + let (arity,ln,lln,offset,col,strbef,straft,pos) = + P.id2clt $1 in + let clt = + (arity,ln,lln,offset,0,strbef,straft,pos) in + P.clt2mcode + (Ast.NonLocal (Parse_aux.str2inc (P.id2name $1))) + (P.drop_bef clt))) } +| d=defineop t=ctype TLineEnd + { let ty = Ast0.wrap(Ast0.TopExp(Ast0.wrap(Ast0.TypeExp(t)))) in + d (Ast0.wrap(Ast0.DOTS([ty]))) } +| defineop b=toplevel_seq_start(toplevel_after_dots) TLineEnd + { let body = + match b with + [e] -> + (match Ast0.unwrap e with + Ast0.Exp(e1) -> + [Ast0.rewrap e (Ast0.TopExp(Ast0.set_arg_exp (e1)))] + | _ -> b) + | _ -> b in + $1 (Ast0.wrap(Ast0.DOTS(body))) } + +defineop: + TDefine + { let (clt,ident) = $1 in + function body -> + Ast0.wrap + (Ast0.Define + (P.clt2mcode "#define" clt, + (match ident with + TMetaId((nm,constraints,pure,clt)) -> + Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) + | TIdent(nm_pure) -> + Ast0.wrap(Ast0.Id(P.id2mcode nm_pure)) + | _ -> + raise + (Semantic_cocci.Semantic + "unexpected name for a #define")), + Ast0.wrap Ast0.NoParams, + body)) } +| TDefineParam define_param_list_option TCPar + { let (clt,ident,parenoff) = $1 in + let (arity,line,lline,offset,col,strbef,straft,pos) = clt in + let lp = + P.clt2mcode "(" (arity,line,lline,parenoff,0,[],[],Ast0.NoMetaPos) in + function body -> + Ast0.wrap + (Ast0.Define + (P.clt2mcode "#define" clt, + (match ident with + TMetaId((nm,constraints,pure,clt)) -> + Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) + | TIdent(nm_pure) -> + Ast0.wrap(Ast0.Id(P.id2mcode nm_pure)) + | _ -> + raise + (Semantic_cocci.Semantic + "unexpected name for a #define")), + Ast0.wrap (Ast0.DParams (lp,$2,P.clt2mcode ")" $3)),body)) } + +/* ---------------------------------------------------------------------- */ + +define_param_list: define_param_list_start + {let circle x = + match Ast0.unwrap x with Ast0.DPcircles(_) -> true | _ -> false in + if List.exists circle $1 + then Ast0.wrap(Ast0.CIRCLES($1)) + else Ast0.wrap(Ast0.DOTS($1)) } + +define_param_list_start: + ident { [Ast0.wrap(Ast0.DParam $1)] } + | ident TComma define_param_list_start + { Ast0.wrap(Ast0.DParam $1):: + Ast0.wrap(Ast0.DPComma(P.clt2mcode "," $2))::$3 } + | d=TEllipsis r=list(dp_comma_args(TEllipsis)) + { (P.mkdpdots "..." d):: + (List.concat (List.map (function x -> x (P.mkdpdots "...")) r)) } + +dp_comma_args(dotter): + c=TComma d=dotter + { function dot_builder -> + [Ast0.wrap(Ast0.DPComma(P.clt2mcode "," c)); dot_builder d] } +| TComma ident + { function dot_builder -> + [Ast0.wrap(Ast0.DPComma(P.clt2mcode "," $1)); + Ast0.wrap(Ast0.DParam $2)] } + +define_param_list_option: define_param_list { $1 } + | /* empty */ { Ast0.wrap(Ast0.DOTS([])) } + +/*****************************************************************************/ + +funproto: + s=ioption(storage) t=ctype + id=func_ident lp=TOPar d=decl_list(name_opt_decl) rp=TCPar pt=TPtVirg + { Ast0.wrap + (Ast0.UnInit + (s, + Ast0.wrap + (Ast0.FunctionType(Some t, + P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)), + id, P.clt2mcode ";" pt)) } +| s=ioption(storage) t=Tvoid + id=func_ident lp=TOPar d=decl_list(name_opt_decl) rp=TCPar pt=TPtVirg + { let t = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in + Ast0.wrap + (Ast0.UnInit + (s, + Ast0.wrap + (Ast0.FunctionType(Some t, + P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)), + id, P.clt2mcode ";" pt)) } + + +fundecl: + f=fninfo + TFunDecl i=func_ident lp=TOPar d=decl_list(decl) rp=TCPar + lb=TOBrace b=fun_start rb=TCBrace + { Ast0.wrap(Ast0.FunDecl((Ast0.default_info(),Ast0.context_befaft()), + f, i, + P.clt2mcode "(" lp, d, + P.clt2mcode ")" rp, + P.clt2mcode "{" lb, b, + P.clt2mcode "}" rb)) } + +fninfo: + /* empty */ { [] } + | storage fninfo + { try + let _ = + List.find (function Ast0.FStorage(_) -> true | _ -> false) $2 in + raise (Semantic_cocci.Semantic "duplicate storage") + with Not_found -> (Ast0.FStorage($1))::$2 } + | t=fn_ctype r=fninfo_nt { (Ast0.FType(t))::r } + | Tinline fninfo + { try + let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) $2 in + raise (Semantic_cocci.Semantic "duplicate inline") + with Not_found -> (Ast0.FInline(P.clt2mcode "inline" $1))::$2 } + | Tattr fninfo + { try + let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) $2 in + raise (Semantic_cocci.Semantic "multiple attributes") + with Not_found -> (Ast0.FAttr(P.id2mcode $1))::$2 } + +fninfo_nt: + /* empty */ { [] } + | storage fninfo_nt + { try + let _ = + List.find (function Ast0.FStorage(_) -> true | _ -> false) $2 in + raise (Semantic_cocci.Semantic "duplicate storage") + with Not_found -> (Ast0.FStorage($1))::$2 } + | Tinline fninfo_nt + { try + let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) $2 in + raise (Semantic_cocci.Semantic "duplicate inline") + with Not_found -> (Ast0.FInline(P.clt2mcode "inline" $1))::$2 } + | Tattr fninfo_nt + { try + let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) $2 in + raise (Semantic_cocci.Semantic "duplicate init") + with Not_found -> (Ast0.FAttr(P.id2mcode $1))::$2 } + +storage: + s=Tstatic { P.clt2mcode Ast.Static s } + | s=Tauto { P.clt2mcode Ast.Auto s } + | s=Tregister { P.clt2mcode Ast.Register s } + | s=Textern { P.clt2mcode Ast.Extern s } + +decl: t=ctype i=ident + { Ast0.wrap(Ast0.Param(t, Some i)) } + | t=fn_ctype lp=TOPar s=TMul i=ident rp=TCPar + lp1=TOPar d=decl_list(name_opt_decl) rp1=TCPar + { 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, Some i)) } + | t=Tvoid + { let ty = + Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in + Ast0.wrap(Ast0.VoidParam(ty)) } + | TMetaParam + { let (nm,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaParam(P.clt2mcode nm clt,pure)) } + +name_opt_decl: + decl { $1 } + | t=ctype { Ast0.wrap(Ast0.Param(t, None)) } + | t=fn_ctype lp=TOPar s=TMul rp=TCPar + lp1=TOPar d=decl_list(name_opt_decl) rp1=TCPar + { 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)) } + +const_vol: + Tconst { P.clt2mcode Ast.Const $1 } + | Tvolatile { P.clt2mcode Ast.Volatile $1 } + +/*****************************************************************************/ + +statement: + includes { $1 } /* shouldn't be allowed to be a single_statement... */ +| TMetaStm + { P.meta_stm $1 } +| expr TPtVirg + { P.exp_stm $1 $2 } +| TIf TOPar eexpr TCPar single_statement %prec TIf + { P.ifthen $1 $2 $3 $4 $5 } +| TIf TOPar eexpr TCPar single_statement TElse single_statement + { P.ifthenelse $1 $2 $3 $4 $5 $6 $7 } +| TFor TOPar option(eexpr) TPtVirg option(eexpr) TPtVirg + option(eexpr) TCPar single_statement + { P.forloop $1 $2 $3 $4 $5 $6 $7 $8 $9 } +| TWhile TOPar eexpr TCPar single_statement + { P.whileloop $1 $2 $3 $4 $5 } +| TDo single_statement TWhile TOPar eexpr TCPar TPtVirg + { P.doloop $1 $2 $3 $4 $5 $6 $7 } +| iter_ident TOPar eexpr_list_option TCPar single_statement + { P.iterator $1 $2 $3 $4 $5 } +| TSwitch TOPar eexpr TCPar TOBrace list(case_line) TCBrace + { P.switch $1 $2 $3 $4 $5 $6 $7 } +| TReturn eexpr TPtVirg { P.ret_exp $1 $2 $3 } +| TReturn TPtVirg { P.ret $1 $2 } +| TBreak TPtVirg { P.break $1 $2 } +| TContinue TPtVirg { P.cont $1 $2 } +| ident TDotDot { P.label $1 $2 } +| TGoto ident TPtVirg { P.goto $1 $2 $3 } +| TOBrace fun_start TCBrace + { P.seq $1 $2 $3 } + +stm_dots: + TEllipsis w=list(whenppdecs) + { Ast0.wrap(Ast0.Dots(P.clt2mcode "..." $1, List.concat w)) } +| TOEllipsis w=list(whenppdecs) b=nest_start c=TCEllipsis + { Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." $1, b, + P.clt2mcode "...>" c, List.concat w, false)) } +| TPOEllipsis w=list(whenppdecs) b=nest_start c=TPCEllipsis + { Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." $1, b, + P.clt2mcode "...+>" c, List.concat w, true)) } + +%inline stm_dots_ell: + a=TEllipsis w=list(whenppdecs) + { Ast0.wrap(Ast0.Dots(P.clt2mcode "..." a, List.concat w)) } + +%inline stm_dots_nest: + a=TOEllipsis w=list(whenppdecs) b=nest_start c=TCEllipsis + { Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." a, b, + P.clt2mcode "...>" c, List.concat w, false)) } +| a=TPOEllipsis w=list(whenppdecs) b=nest_start c=TPCEllipsis + { Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." a, b, + P.clt2mcode "...+>" c, List.concat w, true)) } + +whenppdecs: w=whens(when_start,rule_elem_statement) + { w } + +/* a statement that fits into a single rule_elem. should nests be included? +what about statement metavariables? */ +rule_elem_statement: + one_decl_var + { Ast0.wrap(Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),$1)) } +| expr TPtVirg { P.exp_stm $1 $2 } +| TReturn eexpr TPtVirg { P.ret_exp $1 $2 $3 } +| TReturn TPtVirg { P.ret $1 $2 } +| TBreak TPtVirg { P.break $1 $2 } +| TContinue TPtVirg { P.cont $1 $2 } +| TOPar0 midzero_list(rule_elem_statement,rule_elem_statement) TCPar0 + { 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)) } + +/* a statement on its own */ +single_statement: + statement { $1 } + | TOPar0 midzero_list(statement,statement) TCPar0 + /* degenerate case, elements are single statements and thus don't + contain dots */ + { 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)) } + +case_line: + TDefault TDotDot fun_start + { Ast0.wrap(Ast0.Default(P.clt2mcode "default" $1,P.clt2mcode ":" $2,$3)) } + | TCase eexpr TDotDot fun_start + { Ast0.wrap(Ast0.Case(P.clt2mcode "case" $1,$2,P.clt2mcode ":" $3,$4)) } + +/* In the following, an identifier as a type is not fully supported. Indeed, +the language is ambiguous: what is foo * bar; */ +/* The AST DisjDecl cannot be generated because it would be ambiguous with +a disjunction on a statement with a declaration in each branch */ +decl_var: + t=ctype pv=TPtVirg + { [Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv))] } + | s=ioption(storage) t=ctype d=comma_list(d_ident) pv=TPtVirg + { List.map + (function (id,fn) -> + Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv))) + d } + | f=funproto { [f] } + | s=ioption(storage) t=ctype d=d_ident q=TEq e=initialize pv=TPtVirg + {let (id,fn) = d in + [Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))]} + /* type is a typedef name */ + | s=ioption(storage) cv=ioption(const_vol) i=pure_ident + d=comma_list(d_ident) pv=TPtVirg + { List.map + (function (id,fn) -> + 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))) + d } + | s=ioption(storage) cv=ioption(const_vol) i=pure_ident d=d_ident q=TEq + e=initialize pv=TPtVirg + { 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))] } + /* function pointer type */ + | s=ioption(storage) + t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar + lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar + pv=TPtVirg + { let (id,fn) = d in + let t = + Ast0.wrap + (Ast0.FunctionPointer + (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))] } + | decl_ident TOPar eexpr_list_option TCPar TPtVirg + { [Ast0.wrap(Ast0.MacroDecl($1,P.clt2mcode "(" $2,$3, + P.clt2mcode ")" $4,P.clt2mcode ";" $5))] } + | s=ioption(storage) + t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar + lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar + q=TEq e=initialize pv=TPtVirg + { let (id,fn) = d in + let t = + Ast0.wrap + (Ast0.FunctionPointer + (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))]} + | s=Ttypedef t=ctype_full id=typedef_ident pv=TPtVirg + { let s = P.clt2mcode "typedef" s in + [Ast0.wrap(Ast0.Typedef(s,t,id,P.clt2mcode ";" pv))] } + +one_decl_var: + t=ctype pv=TPtVirg + { Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv)) } + | s=ioption(storage) t=ctype d=d_ident pv=TPtVirg + { let (id,fn) = d in + Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) } + | f=funproto { f } + | s=ioption(storage) t=ctype d=d_ident q=TEq e=initialize pv=TPtVirg + { let (id,fn) = d in + Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)) } + /* type is a typedef name */ + | s=ioption(storage) cv=ioption(const_vol) i=pure_ident + d=d_ident pv=TPtVirg + { 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)) } + | s=ioption(storage) cv=ioption(const_vol) i=pure_ident d=d_ident q=TEq + e=initialize pv=TPtVirg + { 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)) } + /* function pointer type */ + | s=ioption(storage) + t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar + lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar + pv=TPtVirg + { let (id,fn) = d in + let t = + Ast0.wrap + (Ast0.FunctionPointer + (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)) } + | decl_ident TOPar eexpr_list_option TCPar TPtVirg + { Ast0.wrap(Ast0.MacroDecl($1,P.clt2mcode "(" $2,$3, + P.clt2mcode ")" $4,P.clt2mcode ";" $5)) } + | s=ioption(storage) + t=fn_ctype lp1=TOPar st=TMul d=d_ident rp1=TCPar + lp2=TOPar p=decl_list(name_opt_decl) rp2=TCPar + q=TEq e=initialize pv=TPtVirg + { let (id,fn) = d in + let t = + Ast0.wrap + (Ast0.FunctionPointer + (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))} + + +d_ident: + ident list(array_dec) + { ($1, + function t -> + List.fold_right + (function (l,i,r) -> + function rest -> + Ast0.wrap + (Ast0.Array(rest,P.clt2mcode "[" l,i,P.clt2mcode "]" r))) + $2 t) } + +array_dec: l=TOCro i=option(eexpr) r=TCCro { (l,i,r) } + +initialize: + eexpr + { Ast0.wrap(Ast0.InitExpr($1)) } + | TOBrace initialize_list TCBrace + { Ast0.wrap(Ast0.InitList(P.clt2mcode "{" $1,$2,P.clt2mcode "}" $3)) } + | TOBrace TCBrace + { Ast0.wrap + (Ast0.InitList(P.clt2mcode "{" $1,Ast0.wrap(Ast0.DOTS []), + P.clt2mcode "}" $2)) } + +initialize2: + /*arithexpr and not eexpr because can have ambiguity with comma*/ + /*dots and nests probably not allowed at top level, haven't looked into why*/ + arith_expr(eexpr,invalid) { Ast0.wrap(Ast0.InitExpr($1)) } +| TOBrace initialize_list TCBrace + { Ast0.wrap(Ast0.InitList(P.clt2mcode "{" $1,$2,P.clt2mcode "}" $3)) } +| TOBrace TCBrace + { Ast0.wrap + (Ast0.InitList(P.clt2mcode "{" $1,Ast0.wrap(Ast0.DOTS []), + P.clt2mcode "}" $2)) } + /* gccext:, labeled elements */ +| TDot ident TEq initialize2 + { Ast0.wrap(Ast0.InitGccDotName(P.clt2mcode "." $1,$2,P.clt2mcode "=" $3,$4)) } +| ident TDotDot initialize2 + { Ast0.wrap(Ast0.InitGccName($1,P.clt2mcode ":" $2,$3)) } /* in old kernel */ +| TOCro eexpr TCCro TEq initialize2 + { Ast0.wrap(Ast0.InitGccIndex(P.clt2mcode "[" $1,$2,P.clt2mcode "]" $3, + P.clt2mcode "=" $4,$5)) } +| TOCro eexpr TEllipsis eexpr TCCro TEq initialize2 + { Ast0.wrap(Ast0.InitGccRange(P.clt2mcode "[" $1,$2,P.clt2mcode "..." $3, + $4,P.clt2mcode "]" $5,P.clt2mcode "=" $6,$7)) } + +initialize_list: + initialize_list_start { Ast0.wrap(Ast0.DOTS($1)) } + +initialize_list_start: + initialize2 TComma { [$1;Ast0.wrap(Ast0.IComma(P.clt2mcode "," $2))] } +| initialize2 TComma initialize_list_start + { $1::Ast0.wrap(Ast0.IComma(P.clt2mcode "," $2))::$3 } +| d=edots_when(TEllipsis,initialize) + r=comma_initializers(edots_when(TEllipsis,initialize)) + { (P.mkidots "..." d):: + (List.concat(List.map (function x -> x (P.mkidots "...")) r)) } + +comma_initializers(dotter): + /* empty */ { [] } +| d=dotter r=comma_initializers2(dotter) + { (function dot_builder -> [dot_builder d])::r } +| i=initialize2 c=TComma r=comma_initializers(dotter) + { (function dot_builder -> [i; Ast0.wrap(Ast0.IComma(P.clt2mcode "," c))]):: + r } + +comma_initializers2(dotter): + /* empty */ { [] } +| i=initialize2 c=TComma r=comma_initializers(dotter) + { (function dot_builder -> [i; Ast0.wrap(Ast0.IComma(P.clt2mcode "," c))]):: + r } + +/* a statement that is part of a list */ +decl_statement: + TMetaStmList + { let (nm,pure,clt) = $1 in + [Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] } + | decl_var + { List.map + (function x -> + Ast0.wrap + (Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),x))) + $1 } + | statement { [$1] } + /* this doesn't allow expressions at top level, because the parser doesn't + know whether there is one. If there is one, this is not sequencible. + If there is not one, then it is. It seems complicated to get around + this at the parser level. We would have to have a check afterwards to + allow this. One case where this would be useful is for a when. Now + we allow a sequence of whens, so one can be on only statements and + one can be on only expressions. */ + | TOPar0 t=midzero_list(fun_start,fun_start) TCPar0 + { let (mids,code) = t in + if List.for_all + (function x -> + match Ast0.unwrap x with Ast0.DOTS([]) -> true | _ -> false) + code + then [] + else + [Ast0.wrap(Ast0.Disj(P.clt2mcode "(" $1, code, mids, + P.clt2mcode ")" $3))] } + +/* a statement that is part of a list */ +decl_statement_expr: + TMetaStmList + { let (nm,pure,clt) = $1 in + [Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] } + | decl_var + { List.map + (function x -> + Ast0.wrap + (Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),x))) + $1 } + | statement { [$1] } + /* this doesn't allow expressions at top level, because the parser doesn't + know whether there is one. If there is one, this is not sequencible. + If there is not one, then it is. It seems complicated to get around + this at the parser level. We would have to have a check afterwards to + allow this. One case where this would be useful is for a when. Now + we allow a sequence of whens, so one can be on only statements and + one can be on only expressions. */ + | TOPar0 t=midzero_list(fun_after_stm,fun_after_dots_or) TCPar0 + { let (mids,code) = t in + if List.for_all (function [] -> true | _ -> false) code + then [] + else + let dot_code = + List.map (function x -> Ast0.wrap(Ast0.DOTS x)) code in + [Ast0.wrap(Ast0.Disj(P.clt2mcode "(" $1, dot_code, mids, + P.clt2mcode ")" $3))] } + +/*****************************************************************************/ + +/* The following cannot contain <... ...> at the top level. This can only +be allowed as an expression when the expression is delimited on both sides +by expression-specific markers. In that case, the rule eexpr is used, which +allows <... ...> anywhere. Hopefully, this will not be too much of a problem +in practice. */ +expr: basic_expr(expr,invalid) { $1 } +/* allows ... and nests */ +eexpr: basic_expr(eexpr,dot_expressions) { $1 } +/* allows nests but not .... */ +dexpr: basic_expr(eexpr,nest_expressions) { $1 } + +top_eexpr: + eexpr { Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp($1)))) } + +invalid: + TInvalid { raise (Semantic_cocci.Semantic "not matchable") } + +dot_expressions: + TEllipsis { Ast0.wrap(Ast0.Edots(P.clt2mcode "..." $1,None)) } +| nest_expressions { $1 } + +/* not clear what whencode would mean, so just drop it */ +nest_expressions: + TOEllipsis e=expr_dots(TEllipsis) c=TCEllipsis + { Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<..." $1, + Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))), + P.clt2mcode "...>" c, None, false)) } +| TPOEllipsis e=expr_dots(TEllipsis) c=TPCEllipsis + { Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<+..." $1, + Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))), + P.clt2mcode "...+>" c, None, true)) } + +//whenexp: TWhen TNotEq w=eexpr TLineEnd { w } + +basic_expr(recurser,primary_extra): + assign_expr(recurser,primary_extra) { $1 } + +assign_expr(r,pe): + cond_expr(r,pe) { $1 } + | unary_expr(r,pe) TAssign assign_expr_bis + { let (op,clt) = $2 in + Ast0.wrap(Ast0.Assignment($1,P.clt2mcode op clt, + Ast0.set_arg_exp $3,false)) } + | unary_expr(r,pe) TEq assign_expr_bis + { Ast0.wrap + (Ast0.Assignment + ($1,P.clt2mcode Ast.SimpleAssign $2,Ast0.set_arg_exp $3,false)) } + +assign_expr_bis: + cond_expr(eexpr,dot_expressions) { $1 } + | unary_expr(eexpr,dot_expressions) TAssign assign_expr_bis + { let (op,clt) = $2 in + Ast0.wrap(Ast0.Assignment($1,P.clt2mcode op clt, + Ast0.set_arg_exp $3,false)) } + | unary_expr(eexpr,dot_expressions) TEq assign_expr_bis + { Ast0.wrap + (Ast0.Assignment + ($1,P.clt2mcode Ast.SimpleAssign $2,Ast0.set_arg_exp $3,false)) } + +cond_expr(r,pe): + arith_expr(r,pe) { $1 } + | l=arith_expr(r,pe) w=TWhy t=option(eexpr) dd=TDotDot r=cond_expr(r,pe) + { Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t, + P.clt2mcode ":" dd, r)) } + +arith_expr(r,pe): + cast_expr(r,pe) { $1 } + | arith_expr(r,pe) TMul arith_expr(r,pe) + { P.arith_op Ast.Mul $1 $2 $3 } + | arith_expr(r,pe) TDmOp arith_expr(r,pe) + { let (op,clt) = $2 in P.arith_op op $1 clt $3 } + | arith_expr(r,pe) TPlus arith_expr(r,pe) + { P.arith_op Ast.Plus $1 $2 $3 } + | arith_expr(r,pe) TMinus arith_expr(r,pe) + { P.arith_op Ast.Minus $1 $2 $3 } + | arith_expr(r,pe) TShOp arith_expr(r,pe) + { let (op,clt) = $2 in P.arith_op op $1 clt $3 } + | arith_expr(r,pe) TLogOp arith_expr(r,pe) + { let (op,clt) = $2 in P.logic_op op $1 clt $3 } + | arith_expr(r,pe) TEqEq arith_expr(r,pe) + { P.logic_op Ast.Eq $1 $2 $3 } + | arith_expr(r,pe) TNotEq arith_expr(r,pe) + { P.logic_op Ast.NotEq $1 $2 $3 } + | arith_expr(r,pe) TAnd arith_expr(r,pe) + { P.arith_op Ast.And $1 $2 $3 } + | arith_expr(r,pe) TOr arith_expr(r,pe) + { P.arith_op Ast.Or $1 $2 $3 } + | arith_expr(r,pe) TXor arith_expr(r,pe) + { P.arith_op Ast.Xor $1 $2 $3 } + | arith_expr(r,pe) TAndLog arith_expr(r,pe) + { P.logic_op Ast.AndLog $1 $2 $3 } + | arith_expr(r,pe) TOrLog arith_expr(r,pe) + { P.logic_op Ast.OrLog $1 $2 $3 } + +cast_expr(r,pe): + unary_expr(r,pe) { $1 } + | lp=TOPar t=ctype rp=TCPar e=cast_expr(r,pe) + { Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t, + P.clt2mcode ")" rp, e)) } + +unary_expr(r,pe): + postfix_expr(r,pe) { $1 } + | TInc unary_expr(r,pe) + { Ast0.wrap(Ast0.Infix ($2, P.clt2mcode Ast.Inc $1)) } + | TDec unary_expr(r,pe) + { Ast0.wrap(Ast0.Infix ($2, P.clt2mcode Ast.Dec $1)) } + | unary_op unary_expr(r,pe) + { let mcode = $1 in Ast0.wrap(Ast0.Unary($2, mcode)) } + | TBang unary_expr(r,pe) + { let mcode = P.clt2mcode Ast.Not $1 in + Ast0.wrap(Ast0.Unary($2, mcode)) } + | TSizeof unary_expr(r,pe) + { Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" $1, $2)) } + | s=TSizeof lp=TOPar t=ctype rp=TCPar + { Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s, + P.clt2mcode "(" lp,t, + P.clt2mcode ")" rp)) } + +unary_op: TAnd { P.clt2mcode Ast.GetRef $1 } + | TMul { P.clt2mcode Ast.DeRef $1 } + | TPlus { P.clt2mcode Ast.UnPlus $1 } + | TMinus { P.clt2mcode Ast.UnMinus $1 } + | TTilde { P.clt2mcode Ast.Tilde $1 } + +postfix_expr(r,pe): + primary_expr(r,pe) { $1 } + | postfix_expr(r,pe) TOCro eexpr TCCro + { Ast0.wrap(Ast0.ArrayAccess ($1,P.clt2mcode "[" $2,$3, + P.clt2mcode "]" $4)) } + | postfix_expr(r,pe) TDot ident + { Ast0.wrap(Ast0.RecordAccess($1, P.clt2mcode "." $2, $3)) } + | postfix_expr(r,pe) TPtrOp ident + { Ast0.wrap(Ast0.RecordPtAccess($1, P.clt2mcode "->" $2, + $3)) } + | postfix_expr(r,pe) TInc + { Ast0.wrap(Ast0.Postfix ($1, P.clt2mcode Ast.Inc $2)) } + | postfix_expr(r,pe) TDec + { Ast0.wrap(Ast0.Postfix ($1, P.clt2mcode Ast.Dec $2)) } + | postfix_expr(r,pe) TOPar eexpr_list_option TCPar + { Ast0.wrap(Ast0.FunCall($1,P.clt2mcode "(" $2, + $3, + P.clt2mcode ")" $4)) } + +primary_expr(recurser,primary_extra): + func_ident { Ast0.wrap(Ast0.Ident($1)) } + | TInt + { let (x,clt) = $1 in + Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) } + | TFloat + { let (x,clt) = $1 in + Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) } + | TString + { let (x,clt) = $1 in + Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) } + | TChar + { let (x,clt) = $1 in + Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) } + | TMetaConst + { let (nm,constraints,pure,ty,clt) = $1 in + Ast0.wrap + (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.CONST,pure)) } + | TMetaErr + { let (nm,constraints,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) } + | TMetaExp + { let (nm,constraints,pure,ty,clt) = $1 in + Ast0.wrap + (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ANY,pure)) } + | TMetaIdExp + { let (nm,constraints,pure,ty,clt) = $1 in + Ast0.wrap + (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ID,pure)) } + | TMetaLocalIdExp + { let (nm,constraints,pure,ty,clt) = $1 in + Ast0.wrap + (Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.LocalID,pure)) } + | TOPar eexpr TCPar + { Ast0.wrap(Ast0.Paren(P.clt2mcode "(" $1,$2, + P.clt2mcode ")" $3)) } + | TOPar0 midzero_list(recurser,eexpr) TCPar0 + { let (mids,code) = $2 in + Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" $1, + code, mids, + P.clt2mcode ")" $3)) } + | primary_extra { $1 } + +expr_dots(dotter): + r=no_dot_start_end(dexpr,edots_when(dotter,eexpr)) { r } + +// used in NEST +no_dot_start_end(grammar,dotter): + g=grammar dg=list(pair(dotter,grammar)) + { function dot_builder -> + g :: (List.concat(List.map (function (d,g) -> [dot_builder d;g]) dg)) } + +/*****************************************************************************/ + +pure_ident: + TIdent { $1 } + +meta_ident: + TRuleName TDot pure_ident { (Some $1,P.id2name $3) } + +pure_ident_or_meta_ident: + pure_ident { (None,P.id2name $1) } + | meta_ident { $1 } + | Tlist { (None,"list") } + | TError { (None,"error") } + | TType { (None,"type") } + | TName { (None,"name") } + +pure_ident_or_meta_ident_with_not_eq(not_eq): + i=pure_ident_or_meta_ident l=loption(not_eq) { (i,l) } + +not_eq: + TNotEq i=pure_ident + { (if !Data.in_iso + then failwith "constraints not allowed in iso file"); + (if !Data.in_generating + (* pb: constraints not stored with metavars; too lazy to search for + them in the pattern *) + then failwith "constraints not allowed in a generated rule file"); + [Ast0.wrap(Ast0.Id(P.id2mcode i))] } + | TNotEq TOBrace l=comma_list(pure_ident) TCBrace + { (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"); + List.map (function i -> Ast0.wrap(Ast0.Id(P.id2mcode i))) l } + +not_eqe: + TNotEq i=pure_ident + { (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))))] } + | TNotEq TOBrace l=comma_list(pure_ident) TCBrace + { (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"); + List.map + (function i -> + Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i))))) + l } + +not_ceq: + TNotEq i=ident_or_const + { (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] } + | TNotEq TOBrace l=comma_list(ident_or_const) TCBrace + { (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 } + +ident_or_const: + i=pure_ident { Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i)))) } + | TInt + { let (x,clt) = $1 in + Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) } + +not_pos: + TNotEq i=meta_ident + { (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"); + match i with + (None,_) -> failwith "constraint must be an inherited variable" + | (Some rule,name) -> + let i = (rule,name) in + P.check_meta(Ast.MetaPosDecl(Ast.NONE,i)); + [i] } + | TNotEq TOBrace l=comma_list(meta_ident) TCBrace + { (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"); + List.map + (function + (None,_) -> + failwith "constraint must be an inherited variable" + | (Some rule,name) -> + let i = (rule,name) in + P.check_meta(Ast.MetaPosDecl(Ast.NONE,i)); + i) + l } + +func_ident: pure_ident + { Ast0.wrap(Ast0.Id(P.id2mcode $1)) } + | TMetaId + { let (nm,constraints,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) } + | TMetaFunc + { let (nm,constraints,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaFunc(P.clt2mcode nm clt,constraints,pure)) } + | TMetaLocalFunc + { let (nm,constraints,pure,clt) = $1 in + Ast0.wrap + (Ast0.MetaLocalFunc(P.clt2mcode nm clt,constraints,pure)) } + +ident: pure_ident + { Ast0.wrap(Ast0.Id(P.id2mcode $1)) } + | TMetaId + { let (nm,constraints,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) } + +decl_ident: + TDeclarerId + { Ast0.wrap(Ast0.Id(P.id2mcode $1)) } + | TMetaDeclarer + { let (nm,constraints,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) } + +iter_ident: + TIteratorId + { Ast0.wrap(Ast0.Id(P.id2mcode $1)) } + | TMetaIterator + { let (nm,constraints,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) } + +typedef_ident: + pure_ident + { Ast0.wrap(Ast0.TypeName(P.id2mcode $1)) } + | TMetaType + { let (nm,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure)) } + +/*****************************************************************************/ + +decl_list(decl): + decl_list_start(decl) + {let circle x = + match Ast0.unwrap x with Ast0.Pcircles(_) -> true | _ -> false in + if List.exists circle $1 + then Ast0.wrap(Ast0.CIRCLES($1)) + else Ast0.wrap(Ast0.DOTS($1)) } + +decl_list_start(decl): + one_dec(decl) { [$1] } +| one_dec(decl) TComma decl_list_start(decl) + { $1::Ast0.wrap(Ast0.PComma(P.clt2mcode "," $2))::$3 } +| TEllipsis list(comma_decls(TEllipsis,decl)) + { Ast0.wrap(Ast0.Pdots(P.clt2mcode "..." $1)):: + (List.concat(List.map (function x -> x (P.mkpdots "...")) $2)) } + +one_dec(decl): + decl { $1 } +| TMetaParamList + { let (nm,lenname,pure,clt) = $1 in + let nm = P.clt2mcode nm clt in + let lenname = + match lenname with + Some nm -> Some(P.clt2mcode nm clt) + | None -> None in + Ast0.wrap(Ast0.MetaParamList(nm,lenname,pure)) } + +comma_decls(dotter,decl): + TComma dotter + { function dot_builder -> + [Ast0.wrap(Ast0.PComma(P.clt2mcode "," $1)); + dot_builder $2] } +| TComma one_dec(decl) + { function dot_builder -> + [Ast0.wrap(Ast0.PComma(P.clt2mcode "," $1)); $2] } + +/* ---------------------------------------------------------------------- */ + +error_words: + TError TWords TEq TOCro cl=comma_list(dexpr) TCCro + { [Ast0.wrap(Ast0.ERRORWORDS(cl))] } + +/* ---------------------------------------------------------------------- */ +/* sequences of statements and expressions */ + +/* There are number of cases that must be considered: + +1. Top level: + Dots and nests allowed at the beginning or end + Expressions allowed at the beginning or end + One function allowed, by itself +2. A function body: + Dots and nests allowed at the beginning or end + Expressions not allowed at the beginning or end + Functions not allowed +3. The body of a nest: + Dots and nests not allowed at the beginning or end + Expressions allowed at the beginning or end + Functions not allowed +4. Whencode: + Dots and nests not allowed at the beginning but allowed at the end + Expressions allowed at the beginning or end + Functions not allowed + +These are implemented by the rules minus_toplevel_sequence, +plus_toplevel_sequence, function_body_sequence, nest_body_sequence, and +when_body_sequence. +*/ +/* ------------------------------------------------------------------------ */ +/* Minus top level */ + +/* doesn't allow only ... */ +minus_start: + fundecl { [Ast0.wrap(Ast0.DECL($1))] } +| ctype { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty($1))))] } +| top_init { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit($1))))] } +| toplevel_seq_startne(toplevel_after_dots_init) + { List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1 } + +toplevel_seq_startne(after_dots_init): + a=stm_dots_ell b=after_dots_init { a::b } +| a=stm_dots_nest b=after_dots_init { a::b } +| a=stm_dots_nest { [a] } +| expr toplevel_after_exp { (Ast0.wrap(Ast0.Exp($1)))::$2 } +| decl_statement_expr toplevel_after_stm { $1@$2 } + +toplevel_seq_start(after_dots_init): + stm_dots after_dots_init { $1::$2 } +| expr toplevel_after_exp { (Ast0.wrap(Ast0.Exp($1)))::$2 } +| decl_statement_expr toplevel_after_stm { $1@$2 } + +toplevel_after_dots_init: + TNothing toplevel_after_exp {$2} +| expr toplevel_after_exp {(Ast0.wrap(Ast0.Exp($1)))::$2} +| decl_statement_expr toplevel_after_stm {$1@$2} + +toplevel_after_exp: + /* empty */ {[]} +| stm_dots toplevel_after_dots {$1::$2} + +toplevel_after_dots: + /* empty */ {[]} +| TNothing toplevel_after_exp {$2} +| expr toplevel_after_exp {(Ast0.wrap(Ast0.Exp($1)))::$2} +| decl_statement_expr toplevel_after_stm {$1@$2} + +toplevel_after_stm: + /* empty */ {[]} +| stm_dots toplevel_after_dots {$1::$2} +| decl_statement toplevel_after_stm {$1@$2} + +top_init: + TOInit initialize_list TCBrace + { Ast0.wrap(Ast0.InitList(P.clt2mcode "{" $1,$2,P.clt2mcode "}" $3)) } + +/* ------------------------------------------------------------------------ */ +/* Plus top level */ + +/* does allow only ... also allows multiple top-level functions */ +plus_start: + ctype { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty($1))))] } +| top_init { [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit($1))))] } +| stm_dots plus_after_dots + { (Ast0.wrap(Ast0.OTHER($1)))::$2 } +| expr plus_after_exp + { (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp($1)))))::$2 } +| fundecl plus_after_stm { Ast0.wrap(Ast0.DECL($1))::$2 } +| decl_statement_expr plus_after_stm + { (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1)@$2 } + +plus_after_exp: + /* empty */ {[]} +| stm_dots plus_after_dots { (Ast0.wrap(Ast0.OTHER($1)))::$2 } + +plus_after_dots: + /* empty */ {[]} +| TNothing plus_after_exp {$2} +| expr plus_after_exp + { (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp($1)))))::$2 } +| fundecl plus_after_stm { Ast0.wrap(Ast0.DECL($1))::$2 } +| decl_statement_expr plus_after_stm + { (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1)@$2 } + +plus_after_stm: + /* empty */ {[]} +| stm_dots plus_after_dots { (Ast0.wrap(Ast0.OTHER($1)))::$2 } +| fundecl plus_after_stm { Ast0.wrap(Ast0.DECL($1))::$2 } +| decl_statement plus_after_stm + { (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) $1)@$2 } + +/* ------------------------------------------------------------------------ */ +/* Function body */ + +fun_start: + fun_after_stm { Ast0.wrap(Ast0.DOTS($1)) } + +fun_after_stm: + /* empty */ {[]} +| stm_dots fun_after_dots {$1::$2} +| decl_statement fun_after_stm {$1@$2} + +fun_after_dots: + /* empty */ {[]} +| TNothing fun_after_exp {$2} +| expr fun_after_exp {Ast0.wrap(Ast0.Exp($1))::$2} +| decl_statement_expr fun_after_stm {$1@$2} + +fun_after_exp: + stm_dots fun_after_dots {$1::$2} + +/* hack to allow mixing statements and expressions in an or */ +fun_after_dots_or: + /* empty */ {[]} +| TNothing fun_after_exp_or {$2} +| expr fun_after_exp_or {Ast0.wrap(Ast0.Exp($1))::$2} +| decl_statement_expr fun_after_stm {$1@$2} + +fun_after_exp_or: + /* empty */ {[]} +| stm_dots fun_after_dots {$1::$2} + +/* ------------------------------------------------------------------------ */ +/* Nest body */ + +nest_start: + nest_after_dots { Ast0.wrap(Ast0.DOTS($1)) } + +nest_after_dots: + decl_statement_expr nest_after_stm {$1@$2} +| TNothing nest_after_exp {$2} +| expr nest_after_exp {(Ast0.wrap(Ast0.Exp($1)))::$2} + +nest_after_stm: + /* empty */ {[]} +| stm_dots nest_after_dots {$1::$2} +| decl_statement nest_after_stm {$1@$2} + +nest_after_exp: + /* empty */ {[]} +| stm_dots nest_after_dots {$1::$2} + +/* ------------------------------------------------------------------------ */ +/*Whencode*/ + +when_start: + expr toplevel_after_exp + { Ast0.wrap(Ast0.DOTS((Ast0.wrap(Ast0.Exp($1)))::$2)) } +| decl_statement toplevel_after_stm + { Ast0.wrap(Ast0.DOTS($1@$2)) } + +/* ---------------------------------------------------------------------- */ + +eexpr_list: + eexpr_list_start + {let circle x = + match Ast0.unwrap x with Ast0.Ecircles(_) -> true | _ -> false in + let star x = + match Ast0.unwrap x with Ast0.Estars(_) -> true | _ -> false in + if List.exists circle $1 + then Ast0.wrap(Ast0.CIRCLES($1)) + else + if List.exists star $1 + then Ast0.wrap(Ast0.STARS($1)) + else Ast0.wrap(Ast0.DOTS($1)) } + +/* arg expr. may contain a type or a explist metavariable */ +aexpr: + eexpr + { Ast0.set_arg_exp $1 } + | TMetaExpList + { let (nm,lenname,pure,clt) = $1 in + let nm = P.clt2mcode nm clt in + let lenname = + match lenname with + Some nm -> Some(P.clt2mcode nm clt) + | None -> None in + Ast0.wrap(Ast0.MetaExprList(nm,lenname,pure)) } + | ctype + { Ast0.set_arg_exp(Ast0.wrap(Ast0.TypeExp($1))) } + +eexpr_list_start: + aexpr { [$1] } + | aexpr TComma eexpr_list_start + { $1::Ast0.wrap(Ast0.EComma(P.clt2mcode "," $2))::$3 } + +comma_args(dotter): + c=TComma d=dotter + { function dot_builder -> + [Ast0.wrap(Ast0.EComma(P.clt2mcode "," c)); dot_builder d] } +| TComma aexpr + { function dot_builder -> + [Ast0.wrap(Ast0.EComma(P.clt2mcode "," $1)); $2] } + +eexpr_list_option: eexpr_list { $1 } + | /* empty */ { Ast0.wrap(Ast0.DOTS([])) } + +/****************************************************************************/ + +// non-empty lists - drop separator +comma_list(elem): + separated_nonempty_list(TComma,elem) { $1 } + +midzero_list(elem,aft): + a=elem b=list(mzl(aft)) + { let (mids,code) = List.split b in (mids,(a::code)) } + +mzl(elem): + a=TMid0 b=elem { (P.clt2mcode "|" a, b) } + +edots_when(dotter,when_grammar): + d=dotter { (d,None) } + | d=dotter TWhen TNotEq w=when_grammar TLineEnd { (d,Some w) } + +whens(when_grammar,simple_when_grammar): + TWhen TNotEq w=when_grammar TLineEnd { [Ast0.WhenNot w] } + | TWhen TEq w=simple_when_grammar TLineEnd { [Ast0.WhenAlways w] } + | TWhen comma_list(any_strict) TLineEnd + { List.map (function x -> Ast0.WhenModifier(x)) $2 } + | TWhenTrue TNotEq e = eexpr TLineEnd { [Ast0.WhenNotTrue e] } + | TWhenFalse TNotEq e = eexpr TLineEnd { [Ast0.WhenNotFalse e] } + +any_strict: + TAny { Ast.WhenAny } + | TStrict { Ast.WhenStrict } + | TForall { Ast.WhenForall } + | TExists { Ast.WhenExists } + +/***************************************************************************** +* +* +*****************************************************************************/ + +iso_main: + TIsoExpression e1=dexpr el=list(iso(dexpr)) EOF + { P.iso_adjust (function x -> Ast0.ExprTag x) e1 el } +| TIsoArgExpression e1=dexpr el=list(iso(dexpr)) EOF + { P.iso_adjust (function x -> Ast0.ArgExprTag x) e1 el } +| TIsoTestExpression e1=dexpr el=list(iso(dexpr)) EOF + { P.iso_adjust (function x -> Ast0.TestExprTag x) e1 el } +| TIsoStatement s1=single_statement sl=list(iso(single_statement)) EOF + { P.iso_adjust (function x -> Ast0.StmtTag x) s1 sl } +| TIsoType t1=ctype tl=list(iso(ctype)) EOF + { P.iso_adjust (function x -> Ast0.TypeCTag x) t1 tl } +| TIsoTopLevel e1=nest_start el=list(iso(nest_start)) EOF + { P.iso_adjust (function x -> Ast0.DotsStmtTag x) e1 el } +| TIsoDeclaration d1=decl_var dl=list(iso(decl_var)) EOF + { let check_one = function + [x] -> x + | _ -> + raise + (Semantic_cocci.Semantic + "only one variable per declaration in an isomorphism rule") in + let d1 = check_one d1 in + let dl = + List.map + (function + Common.Left x -> Common.Left(check_one x) + | Common.Right x -> Common.Right(check_one x)) + dl in + P.iso_adjust (function x -> Ast0.DeclTag x) d1 dl } + +iso(term): + TIso t=term { Common.Left t } + | TRightIso t=term { Common.Right t } + +/***************************************************************************** +* +* +*****************************************************************************/ + +never_used: TPragma { () } + | TPArob TMetaPos { () } + | TScriptData { () } + +script_meta_main: py=pure_ident TShOp TRuleName TDot cocci=pure_ident TMPtVirg + { (P.id2name py, ($3, P.id2name cocci)) } diff --git a/parsing_cocci/.#pretty_print_cocci.ml.1.134 b/parsing_cocci/.#pretty_print_cocci.ml.1.134 new file mode 100644 index 0000000..0928872 --- /dev/null +++ b/parsing_cocci/.#pretty_print_cocci.ml.1.134 @@ -0,0 +1,864 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +open Format +module Ast = Ast_cocci + +let print_plus_flag = ref true +let print_minus_flag = ref true +let print_newlines_disj = ref true + +let start_block str = + force_newline(); print_string " "; open_box 0 + +let end_block str = + close_box(); force_newline () + +let print_string_box s = print_string s; open_box 0 + + +let print_option = Common.do_option +let print_between = Common.print_between + +(* --------------------------------------------------------------------- *) +(* Modified code *) + +(* avoid polyvariance problems *) +let anything : (Ast.anything -> unit) ref = ref (function _ -> ()) + +let rec print_anything str = function + [] -> () + | stream -> + start_block(); + print_between force_newline + (function x -> + print_string str; open_box 0; print_anything_list x; close_box()) + stream; + end_block() + +and print_anything_list = function + [] -> () + | [x] -> !anything x + | bef::((aft::_) as rest) -> + !anything bef; + let space = + (match bef with + Ast.Rule_elemTag(_) | Ast.AssignOpTag(_) | Ast.BinaryOpTag(_) + | Ast.ArithOpTag(_) | Ast.LogicalOpTag(_) + | Ast.Token("if",_) | Ast.Token("while",_) -> true | _ -> false) or + (match aft with + Ast.Rule_elemTag(_) | Ast.AssignOpTag(_) | Ast.BinaryOpTag(_) + | Ast.ArithOpTag(_) | Ast.LogicalOpTag(_) | Ast.Token("{",_) -> true + | _ -> false) in + if space then print_string " "; + print_anything_list rest + +let print_around printer term = function + Ast.NOTHING -> printer term + | Ast.BEFORE(bef) -> print_anything "<<< " bef; printer term + | Ast.AFTER(aft) -> printer term; print_anything ">>> " aft + | Ast.BEFOREAFTER(bef,aft) -> + print_anything "<<< " bef; printer term; print_anything ">>> " aft + +let print_string_befaft fn x info = + List.iter (function s -> print_string s; force_newline()) + info.Ast.strbef; + fn x; + List.iter (function s -> force_newline(); print_string s) + info.Ast.straft + +let print_meta (r,x) = print_string r; print_string ":"; print_string x + +let print_pos = function + Ast.MetaPos(name,_,_,_,_) -> + let name = Ast.unwrap_mcode name in + print_string "@"; print_meta name + | _ -> () + +let mcode fn = function + (x, _, Ast.MINUS(_,plus_stream), pos) -> + if !print_minus_flag + then print_string (if !Flag.sgrep_mode2 then "*" else "-"); + fn x; print_pos pos; + if !print_plus_flag + then print_anything ">>> " plus_stream + | (x, _, Ast.CONTEXT(_,plus_streams), pos) -> + if !print_plus_flag + then + let fn x = fn x; print_pos pos in + print_around fn x plus_streams + else (fn x; print_pos pos) + | (x, info, Ast.PLUS, pos) -> + let fn x = fn x; print_pos pos in + print_string_befaft fn x info + +let print_mcodekind = function + Ast.MINUS(_,plus_stream) -> + print_string "MINUS"; + print_anything ">>> " plus_stream + | Ast.CONTEXT(_,plus_streams) -> + print_around (function _ -> print_string "CONTEXT") () plus_streams + | Ast.PLUS -> print_string "PLUS" + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) +(* Dots *) + +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 + +let nest_dots multi fn f d = + let mo s = if multi then "<+"^s else "<"^s in + let mc s = if multi then s^"+>" else s^">" in + match Ast.unwrap d with + Ast.DOTS(l) -> + print_string (mo "..."); f(); start_block(); + print_between force_newline fn l; + end_block(); print_string (mc "...") + | Ast.CIRCLES(l) -> + print_string (mo "ooo"); f(); start_block(); + print_between force_newline fn l; + end_block(); print_string (mc "ooo") + | Ast.STARS(l) -> + print_string (mo "***"); f(); start_block(); + print_between force_newline fn l; + end_block(); print_string (mc "***") + +(* --------------------------------------------------------------------- *) + +let print_type keep info = function + None -> () + (* print_string "/* "; + print_string "keep:"; print_unitary keep; + print_string " inherited:"; print_bool inherited; + print_string " */"*) + | Some ty -> () + (*; + print_string "/* "; + print_between (function _ -> print_string ", ") Type_cocci.typeC ty;(* + print_string "keep:"; print_unitary keep; + print_string " inherited:"; print_bool inherited;*) + print_string " */"*) + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +let rec ident i = + match Ast.unwrap i with + Ast.Id(name) -> mcode print_string name + | Ast.MetaId(name,_,keep,inherited) -> mcode print_meta name + | Ast.MetaFunc(name,_,_,_) -> mcode print_meta name + | Ast.MetaLocalFunc(name,_,_,_) -> mcode print_meta name + | Ast.OptIdent(id) -> print_string "?"; ident id + | Ast.UniqueIdent(id) -> print_string "!"; ident id + +and print_unitary = function + Type_cocci.Unitary -> print_string "unitary" + | Type_cocci.Nonunitary -> print_string "nonunitary" + | Type_cocci.Saved -> print_string "saved" + +(* --------------------------------------------------------------------- *) +(* Expression *) + +let print_disj_list fn l = + if !print_newlines_disj + then (force_newline(); print_string "("; force_newline()) + else print_string "("; + print_between + (function _ -> + if !print_newlines_disj + then (force_newline(); print_string "|"; force_newline()) + else print_string " | ") + fn l; + if !print_newlines_disj + then (force_newline(); print_string ")"; force_newline()) + else print_string ")" + +let rec expression e = + match Ast.unwrap e with + Ast.Ident(id) -> ident id + | Ast.Constant(const) -> mcode constant const + | Ast.FunCall(fn,lp,args,rp) -> + expression fn; mcode print_string_box lp; + dots (function _ -> ()) expression args; + close_box(); mcode print_string rp + | Ast.Assignment(left,op,right,simple) -> + expression left; print_string " "; mcode assignOp op; + print_string " "; expression right + | Ast.CondExpr(exp1,why,exp2,colon,exp3) -> + expression exp1; print_string " "; mcode print_string why; + print_option (function e -> print_string " "; expression e) exp2; + print_string " "; mcode print_string colon; expression exp3 + | Ast.Postfix(exp,op) -> expression exp; mcode fixOp op + | Ast.Infix(exp,op) -> mcode fixOp op; expression exp + | Ast.Unary(exp,op) -> mcode unaryOp op; expression exp + | Ast.Binary(left,op,right) -> + expression left; print_string " "; mcode binaryOp op; print_string " "; + expression right + | Ast.Nested(left,op,right) -> + expression left; print_string " "; mcode binaryOp op; print_string " "; + expression right + | Ast.Paren(lp,exp,rp) -> + mcode print_string_box lp; expression exp; close_box(); + mcode print_string rp + | Ast.ArrayAccess(exp1,lb,exp2,rb) -> + expression exp1; mcode print_string_box lb; expression exp2; close_box(); + mcode print_string rb + | Ast.RecordAccess(exp,pt,field) -> + expression exp; mcode print_string pt; ident field + | Ast.RecordPtAccess(exp,ar,field) -> + expression exp; mcode print_string ar; ident field + | Ast.Cast(lp,ty,rp,exp) -> + mcode print_string_box lp; fullType ty; close_box(); + mcode print_string rp; expression exp + | Ast.SizeOfExpr(sizeof,exp) -> + mcode print_string sizeof; expression exp + | Ast.SizeOfType(sizeof,lp,ty,rp) -> + mcode print_string sizeof; + mcode print_string_box lp; fullType ty; close_box(); + mcode print_string rp + | Ast.TypeExp(ty) -> fullType ty + + | Ast.MetaErr(name,_,_,_) -> mcode print_meta name + | Ast.MetaExpr(name,_,keep,ty,form,inherited) -> + mcode print_meta name; print_type keep inherited ty + | Ast.MetaExprList(name,_,_,_) -> mcode print_meta name + | Ast.EComma(cm) -> mcode print_string cm; print_space() + | Ast.DisjExpr(exp_list) -> print_disj_list expression exp_list + | Ast.NestExpr(expr_dots,Some whencode,multi) -> + nest_dots multi expression + (function _ -> print_string " when != "; expression whencode) + expr_dots + | Ast.NestExpr(expr_dots,None,multi) -> + nest_dots multi expression (function _ -> ()) expr_dots + | Ast.Edots(dots,Some whencode) + | Ast.Ecircles(dots,Some whencode) + | Ast.Estars(dots,Some whencode) -> + mcode print_string dots; print_string " when != "; expression whencode + | Ast.Edots(dots,None) + | Ast.Ecircles(dots,None) + | Ast.Estars(dots,None) -> mcode print_string dots + | Ast.OptExp(exp) -> print_string "?"; expression exp + | Ast.UniqueExp(exp) -> print_string "!"; expression exp + +and unaryOp = function + Ast.GetRef -> print_string "&" + | Ast.DeRef -> print_string "*" + | Ast.UnPlus -> print_string "+" + | Ast.UnMinus -> print_string "-" + | Ast.Tilde -> print_string "~" + | Ast.Not -> print_string "!" + +and assignOp = function + Ast.SimpleAssign -> print_string "=" + | Ast.OpAssign(aop) -> arithOp aop; print_string "=" + +and fixOp = function + Ast.Dec -> print_string "--" + | Ast.Inc -> print_string "++" + +and binaryOp = function + Ast.Arith(aop) -> arithOp aop + | Ast.Logical(lop) -> logicalOp lop + +and arithOp = function + Ast.Plus -> print_string "+" + | Ast.Minus -> print_string "-" + | Ast.Mul -> print_string "*" + | Ast.Div -> print_string "/" + | Ast.Mod -> print_string "%" + | Ast.DecLeft -> print_string "<<" + | Ast.DecRight -> print_string ">>" + | Ast.And -> print_string "&" + | Ast.Or -> print_string "|" + | Ast.Xor -> print_string "^" + +and logicalOp = function + Ast.Inf -> print_string "<" + | Ast.Sup -> print_string ">" + | Ast.InfEq -> print_string "<=" + | Ast.SupEq -> print_string ">=" + | Ast.Eq -> print_string "==" + | Ast.NotEq -> print_string "!=" + | Ast.AndLog -> print_string "&&" + | Ast.OrLog -> print_string "||" + +and constant = function + Ast.String(s) -> print_string "\""; print_string s; print_string "\"" + | Ast.Char(s) -> print_string "'"; print_string s; print_string "'" + | Ast.Int(s) -> print_string s + | Ast.Float(s) -> print_string s + +(* --------------------------------------------------------------------- *) +(* Declarations *) + +and storage = function + Ast.Static -> print_string "static " + | Ast.Auto -> print_string "auto " + | Ast.Register -> print_string "register " + | Ast.Extern -> print_string "extern " + +(* --------------------------------------------------------------------- *) +(* Types *) + +and fullType ft = + match Ast.unwrap ft with + Ast.Type(cv,ty) -> + print_option (function x -> mcode const_vol x; print_string " ") cv; + typeC ty + | Ast.DisjType(decls) -> print_disj_list fullType decls + | Ast.OptType(ty) -> print_string "?"; fullType ty + | Ast.UniqueType(ty) -> print_string "!"; fullType ty + +and print_function_pointer (ty,lp1,star,rp1,lp2,params,rp2) fn = + fullType ty; mcode print_string lp1; mcode print_string star; fn(); + mcode print_string rp1; mcode print_string lp1; + parameter_list params; mcode print_string rp2 + +and print_function_type (ty,lp1,params,rp1) fn = + print_option fullType ty; fn(); mcode print_string lp1; + parameter_list params; mcode print_string rp1 + +and print_fninfo = function + Ast.FStorage(stg) -> mcode storage stg + | Ast.FType(ty) -> fullType ty + | Ast.FInline(inline) -> mcode print_string inline; print_string " " + | Ast.FAttr(attr) -> mcode print_string attr; print_string " " + +and typeC ty = + match Ast.unwrap ty with + Ast.BaseType(ty,strings) -> + List.iter (function s -> mcode print_string s; print_string " ") strings + | Ast.SignedT(sgn,ty) -> mcode sign sgn; print_option typeC ty + | Ast.Pointer(ty,star) -> fullType ty; mcode print_string star + | Ast.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + print_function_pointer (ty,lp1,star,rp1,lp2,params,rp2) + (function _ -> ()) + | Ast.FunctionType (_,ty,lp1,params,rp1) -> + print_function_type (ty,lp1,params,rp1) (function _ -> ()) + | Ast.Array(ty,lb,size,rb) -> + fullType ty; mcode print_string lb; print_option expression size; + mcode print_string rb + | Ast.EnumName(kind,name) -> mcode print_string kind; print_string " "; + ident name + | Ast.StructUnionName(kind,name) -> + mcode structUnion kind; + print_option (function x -> ident x; print_string " ") name + | Ast.StructUnionDef(ty,lb,decls,rb) -> + fullType ty; mcode print_string lb; + dots force_newline declaration decls; + mcode print_string rb + | Ast.TypeName(name) -> mcode print_string name; print_string " " + | Ast.MetaType(name,_,_) -> + mcode print_meta name; print_string " " + +and baseType = function + Ast.VoidType -> print_string "void " + | Ast.CharType -> print_string "char " + | Ast.ShortType -> print_string "short " + | Ast.IntType -> print_string "int " + | Ast.DoubleType -> print_string "double " + | Ast.FloatType -> print_string "float " + | Ast.LongType -> print_string "long " + | Ast.LongLongType -> print_string "long long " + +and structUnion = function + Ast.Struct -> print_string "struct " + | Ast.Union -> print_string "union " + +and sign = function + Ast.Signed -> print_string "signed " + | Ast.Unsigned -> print_string "unsigned " + +and const_vol = function + Ast.Const -> print_string "const" + | Ast.Volatile -> print_string "volatile" + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and print_named_type ty id = + match Ast.unwrap ty with + Ast.Type(None,ty1) -> + (match Ast.unwrap ty1 with + Ast.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + print_function_pointer (ty,lp1,star,rp1,lp2,params,rp2) + (function _ -> print_string " "; ident id) + | Ast.FunctionType(_,ty,lp1,params,rp1) -> + print_function_type (ty,lp1,params,rp1) + (function _ -> print_string " "; ident id) + | Ast.Array(ty,lb,size,rb) -> + let rec loop ty k = + match Ast.unwrap ty with + Ast.Array(ty,lb,size,rb) -> + (match Ast.unwrap ty with + Ast.Type(None,ty) -> + loop ty + (function _ -> + k (); + mcode print_string lb; + print_option expression size; + mcode print_string rb) + | _ -> failwith "complex array types not supported") + | _ -> typeC ty; ident id; k () in + loop ty1 (function _ -> ()) + | _ -> fullType ty; ident id) + | _ -> fullType ty; ident id + +and declaration d = + match Ast.unwrap d with + Ast.Init(stg,ty,id,eq,ini,sem) -> + print_option (mcode storage) stg; print_named_type ty id; + print_string " "; mcode print_string eq; + print_string " "; initialiser ini; mcode print_string sem + | Ast.UnInit(stg,ty,id,sem) -> + print_option (mcode storage) stg; print_named_type ty id; + mcode print_string sem + | Ast.MacroDecl(name,lp,args,rp,sem) -> + ident name; mcode print_string_box lp; + dots (function _ -> ()) expression args; + close_box(); mcode print_string rp; mcode print_string sem + | Ast.TyDecl(ty,sem) -> fullType ty; mcode print_string sem + | Ast.Typedef(stg,ty,id,sem) -> + mcode print_string stg; print_string " "; fullType ty; typeC id; + mcode print_string sem + | Ast.DisjDecl(decls) -> print_disj_list declaration decls + | Ast.Ddots(dots,Some whencode) -> + mcode print_string dots; print_string " when != "; declaration whencode + | Ast.Ddots(dots,None) -> mcode print_string dots + | Ast.MetaDecl(name,_,_) -> mcode print_meta name + | Ast.OptDecl(decl) -> print_string "?"; declaration decl + | Ast.UniqueDecl(decl) -> print_string "!"; declaration decl + +(* --------------------------------------------------------------------- *) +(* Initialiser *) + +and initialiser i = + match Ast.unwrap i with + Ast.InitExpr(exp) -> expression exp + | Ast.InitList(lb,initlist,rb,whencode) -> + mcode print_string lb; open_box 0; + if not (whencode = []) + then + (print_string " WHEN != "; + print_between (function _ -> print_string " v ") + initialiser whencode; + force_newline()); + List.iter initialiser initlist; close_box(); + mcode print_string rb + | Ast.InitGccDotName(dot,name,eq,ini) -> + mcode print_string dot; ident name; print_string " "; + mcode print_string eq; print_string " "; initialiser ini + | Ast.InitGccName(name,eq,ini) -> + ident name; mcode print_string eq; initialiser ini + | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> + mcode print_string lb; expression exp; mcode print_string rb; + print_string " "; mcode print_string eq; print_string " "; + initialiser ini + | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + mcode print_string lb; expression exp1; mcode print_string dots; + expression exp2; mcode print_string rb; + print_string " "; mcode print_string eq; print_string " "; + initialiser ini + | Ast.IComma(comma) -> mcode print_string comma; force_newline() + | Ast.OptIni(ini) -> print_string "?"; initialiser ini + | Ast.UniqueIni(ini) -> print_string "!"; initialiser ini + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and parameterTypeDef p = + match Ast.unwrap p with + Ast.VoidParam(ty) -> fullType ty + | Ast.Param(ty,Some id) -> print_named_type ty id + | Ast.Param(ty,None) -> fullType ty + | Ast.MetaParam(name,_,_) -> mcode print_meta name + | Ast.MetaParamList(name,_,_,_) -> mcode print_meta name + | Ast.PComma(cm) -> mcode print_string cm; print_space() + | Ast.Pdots(dots) -> mcode print_string dots + | Ast.Pcircles(dots) -> mcode print_string dots + | Ast.OptParam(param) -> print_string "?"; parameterTypeDef param + | Ast.UniqueParam(param) -> print_string "!"; parameterTypeDef param + +and parameter_list l = dots (function _ -> ()) parameterTypeDef l + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +let rec rule_elem arity re = + match Ast.unwrap re with + Ast.FunHeader(bef,allminus,fninfo,name,lp,params,rp) -> + mcode (function _ -> ()) ((),Ast.no_info,bef,Ast.NoMetaPos); + print_string arity; List.iter print_fninfo fninfo; + ident name; mcode print_string_box lp; + parameter_list params; close_box(); mcode print_string rp; + print_string " " + | Ast.Decl(bef,allminus,decl) -> + mcode (function _ -> ()) ((),Ast.no_info,bef,Ast.NoMetaPos); + print_string arity; + declaration decl + | Ast.SeqStart(brace) -> + print_string arity; mcode print_string brace; + if !print_newlines_disj then start_block() + | Ast.SeqEnd(brace) -> + if !print_newlines_disj then end_block(); + print_string arity; mcode print_string brace + | Ast.ExprStatement(exp,sem) -> + print_string arity; expression exp; mcode print_string sem + | Ast.IfHeader(iff,lp,exp,rp) -> + print_string arity; + mcode print_string iff; print_string " "; mcode print_string_box lp; + expression exp; close_box(); mcode print_string rp; print_string " " + | Ast.Else(els) -> + print_string arity; mcode print_string els; print_string " " + | Ast.WhileHeader(whl,lp,exp,rp) -> + print_string arity; + mcode print_string whl; print_string " "; mcode print_string_box lp; + expression exp; close_box(); mcode print_string rp; print_string " " + | Ast.DoHeader(d) -> + print_string arity; mcode print_string d; print_string " " + | Ast.WhileTail(whl,lp,exp,rp,sem) -> + print_string arity; + mcode print_string whl; print_string " "; mcode print_string_box lp; + expression exp; close_box(); mcode print_string rp; + mcode print_string sem + | Ast.ForHeader(fr,lp,e1,sem1,e2,sem2,e3,rp) -> + print_string arity; + mcode print_string fr; mcode print_string_box lp; + print_option expression e1; mcode print_string sem1; + print_option expression e2; mcode print_string sem2; + print_option expression e3; close_box(); + mcode print_string rp; print_string " " + | Ast.IteratorHeader(nm,lp,args,rp) -> + print_string arity; + ident nm; print_string " "; mcode print_string_box lp; + dots (function _ -> ()) expression args; close_box(); + mcode print_string rp; print_string " " + | Ast.SwitchHeader(switch,lp,exp,rp) -> + print_string arity; + mcode print_string switch; print_string " "; mcode print_string_box lp; + expression exp; close_box(); mcode print_string rp; print_string " " + | Ast.Break(br,sem) -> + print_string arity; mcode print_string br; mcode print_string sem + | Ast.Continue(cont,sem) -> + print_string arity; mcode print_string cont; mcode print_string sem + | Ast.Label(l,dd) -> ident l; mcode print_string dd + | Ast.Goto(goto,l,sem) -> + mcode print_string goto; ident l; mcode print_string sem + | Ast.Return(ret,sem) -> + print_string arity; mcode print_string ret; mcode print_string sem + | Ast.ReturnExpr(ret,exp,sem) -> + print_string arity; mcode print_string ret; print_string " "; + expression exp; mcode print_string sem + | Ast.MetaRuleElem(name,_,_) -> + print_string arity; mcode print_meta name + | Ast.MetaStmt(name,_,_,_) -> + print_string arity; mcode print_meta name + | Ast.MetaStmtList(name,_,_) -> + print_string arity; mcode print_meta name + | Ast.Exp(exp) -> print_string arity; expression exp + | Ast.TopExp(exp) -> print_string arity; expression exp + | Ast.Ty(ty) -> print_string arity; fullType ty + | Ast.TopInit(init) -> initialiser init + | Ast.Include(inc,s) -> + mcode print_string inc; print_string " "; mcode inc_file s + | Ast.DefineHeader(def,id,params) -> + mcode print_string def; print_string " "; ident id; + print_define_parameters params + | Ast.Default(def,colon) -> + mcode print_string def; mcode print_string colon; print_string " " + | Ast.Case(case,exp,colon) -> + mcode print_string case; print_string " "; expression exp; + mcode print_string colon; print_string " " + | Ast.DisjRuleElem(res) -> + print_string arity; + force_newline(); print_string "("; force_newline(); + print_between + (function _ -> force_newline();print_string "|"; force_newline()) + (rule_elem arity) + res; + force_newline(); print_string ")" + + +and print_define_parameters params = + match Ast.unwrap params with + Ast.NoParams -> () + | Ast.DParams(lp,params,rp) -> + mcode print_string lp; + dots (function _ -> ()) print_define_param params; mcode print_string rp + +and print_define_param param = + match Ast.unwrap param with + Ast.DParam(id) -> ident id + | Ast.DPComma(comma) -> mcode print_string comma + | Ast.DPdots(dots) -> mcode print_string dots + | Ast.DPcircles(circles) -> mcode print_string circles + | Ast.OptDParam(dp) -> print_string "?"; print_define_param dp + | Ast.UniqueDParam(dp) -> print_string "!"; print_define_param dp + +and statement arity s = + match Ast.unwrap s with + Ast.Seq(lbrace,decls,body,rbrace) -> + rule_elem arity lbrace; + dots force_newline (statement arity) decls; + dots force_newline (statement arity) body; + rule_elem arity rbrace + | Ast.IfThen(header,branch,(_,_,_,aft)) -> + rule_elem arity header; statement arity branch; + mcode (function _ -> ()) ((),Ast.no_info,aft,Ast.NoMetaPos) + | Ast.IfThenElse(header,branch1,els,branch2,(_,_,_,aft)) -> + rule_elem arity header; statement arity branch1; print_string " "; + rule_elem arity els; statement arity branch2; + mcode (function _ -> ()) ((),Ast.no_info,aft,Ast.NoMetaPos) + | Ast.While(header,body,(_,_,_,aft)) -> + rule_elem arity header; statement arity body; + mcode (function _ -> ()) ((),Ast.no_info,aft,Ast.NoMetaPos) + | Ast.Do(header,body,tail) -> + rule_elem arity header; statement arity body; + rule_elem arity tail + | Ast.For(header,body,(_,_,_,aft)) -> + rule_elem arity header; statement arity body; + mcode (function _ -> ()) ((),Ast.no_info,aft,Ast.NoMetaPos) + | Ast.Iterator(header,body,(_,_,_,aft)) -> + rule_elem arity header; statement arity body; + mcode (function _ -> ()) ((),Ast.no_info,aft,Ast.NoMetaPos) + | Ast.Switch(header,lb,cases,rb) -> + rule_elem arity header; rule_elem arity lb; + List.iter (function x -> case_line arity x; force_newline()) cases; + rule_elem arity rb + | Ast.Atomic(re) -> rule_elem arity re + | Ast.FunDecl(header,lbrace,decls,body,rbrace) -> + rule_elem arity header; rule_elem arity lbrace; + dots force_newline (statement arity) decls; + dots force_newline (statement arity) body; + rule_elem arity rbrace + | Ast.Disj([stmt_dots]) -> + print_string arity; + dots (function _ -> if !print_newlines_disj then force_newline()) + (statement arity) stmt_dots + | Ast.Disj(stmt_dots_list) -> (* ignores newline directive for readability *) + print_string arity; + force_newline(); print_string "("; force_newline(); + print_between + (function _ -> force_newline();print_string "|"; force_newline()) + (dots force_newline (statement arity)) + stmt_dots_list; + force_newline(); print_string ")" + | Ast.Define(header,body) -> + rule_elem arity header; print_string " "; + dots force_newline (statement arity) body + | Ast.Nest(stmt_dots,whn,multi,_,_) -> + print_string arity; + nest_dots multi (statement arity) + (function _ -> + open_box 0; + print_between force_newline + (whencode (dots force_newline (statement "")) (statement "")) whn; + close_box(); force_newline()) + stmt_dots + | Ast.Dots(d,whn,_,_) | Ast.Circles(d,whn,_,_) | Ast.Stars(d,whn,_,_) -> + print_string arity; mcode print_string d; + open_box 0; + print_between force_newline + (whencode (dots force_newline (statement "")) (statement "")) whn; + close_box(); force_newline() + | Ast.OptStm(s) -> statement "?" s + | Ast.UniqueStm(s) -> statement "!" s + +and print_statement_when whencode = + print_string " WHEN != "; + open_box 0; + print_between (function _ -> print_string " &"; force_newline()) + (dots force_newline (statement "")) whencode; + close_box() + + +and whencode notfn alwaysfn = function + Ast.WhenNot a -> + print_string " WHEN != "; open_box 0; notfn a; close_box() + | Ast.WhenAlways a -> + print_string " WHEN = "; open_box 0; alwaysfn a; close_box() + | Ast.WhenModifier x -> print_string " WHEN "; print_when_modif x + | Ast.WhenNotTrue a -> + print_string " WHEN != TRUE "; open_box 0; rule_elem "" a; close_box() + | Ast.WhenNotFalse a -> + print_string " WHEN != FALSE "; open_box 0; rule_elem "" a; close_box() + +and print_when_modif = function + | Ast.WhenAny -> print_string "ANY" + | Ast.WhenStrict -> print_string "STRICT" + | Ast.WhenForall -> print_string "FORALL" + | Ast.WhenExists -> print_string "EXISTS" + +and case_line arity c = + match Ast.unwrap c with + Ast.CaseLine(header,code) -> + rule_elem arity header; print_string " "; + dots force_newline (statement arity) code + | Ast.OptCase(case) -> case_line "?" case + +(* --------------------------------------------------------------------- *) +(* CPP code *) + +and inc_file = function + Ast.Local(elems) -> + print_string "\""; + print_between (function _ -> print_string "/") inc_elem elems; + print_string "\"" + | Ast.NonLocal(elems) -> + print_string "<"; + print_between (function _ -> print_string "/") inc_elem elems; + print_string ">" + +and inc_elem = function + Ast.IncPath s -> print_string s + | Ast.IncDots -> print_string "..." + +(* for export only *) +let statement_dots l = dots force_newline (statement "") l + +let top_level t = + match Ast.unwrap t with + Ast.FILEINFO(old_file,new_file) -> + print_string "--- "; mcode print_string old_file; force_newline(); + print_string "+++ "; mcode print_string new_file + | Ast.DECL(stmt) -> statement "" stmt + | Ast.CODE(stmt_dots) -> + dots force_newline (statement "") stmt_dots + | Ast.ERRORWORDS(exps) -> + print_string "error words = ["; + print_between (function _ -> print_string ", ") expression exps; + print_string "]" + +let rule = + print_between (function _ -> force_newline(); force_newline()) top_level + +let pp_print_anything x = !anything x + +let _ = + anything := function + Ast.FullTypeTag(x) -> fullType x + | Ast.BaseTypeTag(x) -> baseType x + | Ast.StructUnionTag(x) -> structUnion x + | Ast.SignTag(x) -> sign x + | Ast.IdentTag(x) -> ident x + | Ast.ExpressionTag(x) -> expression x + | Ast.ConstantTag(x) -> constant x + | Ast.UnaryOpTag(x) -> unaryOp x + | Ast.AssignOpTag(x) -> assignOp x + | Ast.FixOpTag(x) -> fixOp x + | Ast.BinaryOpTag(x) -> binaryOp x + | Ast.ArithOpTag(x) -> arithOp x + | Ast.LogicalOpTag(x) -> logicalOp x + | Ast.InitTag(x) -> initialiser x + | Ast.DeclarationTag(x) -> declaration x + | Ast.StorageTag(x) -> storage x + | Ast.IncFileTag(x) -> inc_file x + | Ast.Rule_elemTag(x) -> rule_elem "" x + | Ast.StatementTag(x) -> statement "" x + | Ast.CaseLineTag(x) -> case_line "" x + | Ast.ConstVolTag(x) -> const_vol x + | Ast.Token(x,Some info) -> print_string_befaft print_string x info + | Ast.Token(x,None) -> print_string x + | Ast.Code(x) -> let _ = top_level x in () + | Ast.ExprDotsTag(x) -> dots (function _ -> ()) expression x + | Ast.ParamDotsTag(x) -> parameter_list x + | Ast.StmtDotsTag(x) -> dots (function _ -> ()) (statement "") x + | Ast.DeclDotsTag(x) -> dots (function _ -> ()) declaration x + | Ast.TypeCTag(x) -> typeC x + | Ast.ParamTag(x) -> parameterTypeDef x + | Ast.SgrepStartTag(x) -> print_string x + | Ast.SgrepEndTag(x) -> print_string x + +let rec dep in_and = function + Ast.Dep(s) -> print_string s + | Ast.AntiDep(s) -> print_string "!"; print_string s + | Ast.EverDep(s) -> print_string "ever "; print_string s + | Ast.NeverDep(s) -> print_string "never "; print_string s + | Ast.AndDep(s1,s2) -> + let print_and _ = dep true s1; print_string " && "; dep true s2 in + if in_and + then print_and () + else (print_string "("; print_and(); print_string ")") + | Ast.OrDep(s1,s2) -> + let print_or _ = dep false s1; print_string " || "; dep false s2 in + if not in_and + then print_or () + else (print_string "("; print_or(); print_string ")") + | Ast.NoDep -> failwith "not possible" + +let unparse z = + match z with + Ast.ScriptRule (lang,deps,bindings,code) -> + print_string "@@"; + force_newline(); + print_string ("script:" ^ lang); + (match deps with + Ast.NoDep -> () + | _ -> print_string " depends on "; dep true deps); + force_newline(); + print_string "@@"; + force_newline(); + print_string code; + force_newline() + | Ast.CocciRule (nm, (deps, drops, exists), x, _, _) -> + print_string "@@"; + force_newline(); + print_string nm; + (match deps with + Ast.NoDep -> () + | _ -> print_string " depends on "; dep true deps); + (* + print_string "line "; + print_int (Ast.get_line (List.hd x)); + *) + force_newline(); + print_string "@@"; + print_newlines_disj := true; + force_newline(); + force_newline(); + rule x; + force_newline() + +let rule_elem_to_string x = + print_newlines_disj := true; + Common.format_to_string (function _ -> rule_elem "" x) + +let ident_to_string x = + print_newlines_disj := true; + Common.format_to_string (function _ -> ident x) + +let unparse_to_string x = + print_newlines_disj := true; + Common.format_to_string (function _ -> unparse x) + +let print_rule_elem re = + let nl = !print_newlines_disj in + print_newlines_disj := false; + rule_elem "" re; + print_newlines_disj := nl + diff --git a/parsing_cocci/.#unify_ast.ml.1.75 b/parsing_cocci/.#unify_ast.ml.1.75 new file mode 100644 index 0000000..6d14682 --- /dev/null +++ b/parsing_cocci/.#unify_ast.ml.1.75 @@ -0,0 +1,574 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +(* --------------------------------------------------------------------- *) +(* Given two patterns, A and B, determine whether B can match any matched +subterms of A. For simplicity, this doesn't maintain an environment; it +just assume metavariables match. Thus the result is either NO or MAYBE. *) + +module Ast = Ast_cocci +module V = Visitor_ast + +(* --------------------------------------------------------------------- *) + +type res = NO | MAYBE + +let return b = if b then MAYBE else NO + +let unify_mcode (x,_,_,_) (y,_,_,_) = x = y + +let ret_unify_mcode a b = return (unify_mcode a b) + +let unify_option f t1 t2 = + match (t1,t2) with + (Some t1, Some t2) -> f t1 t2 + | (None, None) -> return true + | _ -> return false + +let unify_true_option f t1 t2 = + match (t1,t2) with + (Some t1, Some t2) -> f t1 t2 + | (None, None) -> return true + | _ -> return true + +let bool_unify_option f t1 t2 = + match (t1,t2) with + (Some t1, Some t2) -> f t1 t2 + | (None, None) -> true + | _ -> false + +let conjunct_bindings b1 b2 = + match b1 with NO -> b1 | MAYBE -> b2 + +let disjunct_bindings b1 b2 = + match b1 with MAYBE -> b1 | NO -> b2 + +let disjunct_all_bindings = List.fold_left disjunct_bindings NO + +(* --------------------------------------------------------------------- *) + +(* compute the common prefix. if in at least one case, this ends with the +end of the pattern or a ..., then return true. *) + +let unify_lists fn dfn la lb = + let rec loop = function + ([],_) | (_,[]) -> return true + | (cura::resta,curb::restb) -> + (match fn cura curb with + MAYBE -> loop (resta,restb) + | NO -> if dfn cura or dfn curb then MAYBE else NO) in + loop (la,lb) + +let unify_dots fn dfn d1 d2 = + match (Ast.unwrap d1,Ast.unwrap d2) with + (Ast.DOTS(l1),Ast.DOTS(l2)) + | (Ast.CIRCLES(l1),Ast.CIRCLES(l2)) + | (Ast.STARS(l1),Ast.STARS(l2)) -> unify_lists fn dfn l1 l2 + | _ -> return false + +let edots e = + match Ast.unwrap e with + Ast.Edots(_,_) | Ast.Ecircles(_,_) | Ast.Estars(_,_) -> true + | _ -> false + +let ddots e = + match Ast.unwrap e with + Ast.Ddots(_,_) -> true + | _ -> false + +let pdots p = + match Ast.unwrap p with + Ast.Pdots(_) | Ast.Pcircles(_) -> true + | _ -> false + +let dpdots e = + match Ast.unwrap e with + Ast.DPdots(_) | Ast.DPcircles(_) -> true + | _ -> false + +let sdots s = + match Ast.unwrap s with + Ast.Dots(_,_,_,_) | Ast.Circles(_,_,_,_) | Ast.Stars(_,_,_,_) -> true + | _ -> false + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +and unify_ident i1 i2 = + match (Ast.unwrap i1,Ast.unwrap i2) with + (Ast.Id(i1),Ast.Id(i2)) -> return (unify_mcode i1 i2) + + | (Ast.MetaId(_,_,_,_),_) + | (Ast.MetaFunc(_,_,_,_),_) + | (Ast.MetaLocalFunc(_,_,_,_),_) + | (_,Ast.MetaId(_,_,_,_)) + | (_,Ast.MetaFunc(_,_,_,_)) + | (_,Ast.MetaLocalFunc(_,_,_,_)) -> return true + + | (Ast.OptIdent(_),_) + | (Ast.UniqueIdent(_),_) + | (_,Ast.OptIdent(_)) + | (_,Ast.UniqueIdent(_)) -> failwith "unsupported ident" + +(* --------------------------------------------------------------------- *) +(* Expression *) + +let rec unify_expression e1 e2 = + match (Ast.unwrap e1,Ast.unwrap e2) with + (Ast.Ident(i1),Ast.Ident(i2)) -> unify_ident i1 i2 + | (Ast.Constant(c1),Ast.Constant(c2))-> return (unify_mcode c1 c2) + | (Ast.FunCall(f1,lp1,args1,rp1),Ast.FunCall(f2,lp2,args2,rp2)) -> + conjunct_bindings + (unify_expression f1 f2) + (unify_dots unify_expression edots args1 args2) + | (Ast.Assignment(l1,op1,r1,_),Ast.Assignment(l2,op2,r2,_)) -> + if unify_mcode op1 op2 + then conjunct_bindings (unify_expression l1 l2) (unify_expression r1 r2) + else return false + | (Ast.CondExpr(tst1,q1,thn1,c1,els1),Ast.CondExpr(tst2,q2,thn2,c2,els2)) -> + conjunct_bindings (unify_expression tst1 tst2) + (conjunct_bindings (unify_option unify_expression thn1 thn2) + (unify_expression els1 els2)) + | (Ast.Postfix(e1,op1),Ast.Postfix(e2,op2)) -> + if unify_mcode op1 op2 then unify_expression e1 e2 else return false + | (Ast.Infix(e1,op1),Ast.Infix(e2,op2)) -> + if unify_mcode op1 op2 then unify_expression e1 e2 else return false + | (Ast.Unary(e1,op1),Ast.Unary(e2,op2)) -> + if unify_mcode op1 op2 then unify_expression e1 e2 else return false + | (Ast.Binary(l1,op1,r1),Ast.Binary(l2,op2,r2)) -> + if unify_mcode op1 op2 + then conjunct_bindings (unify_expression l1 l2) (unify_expression r1 r2) + else return false + | (Ast.ArrayAccess(ar1,lb1,e1,rb1),Ast.ArrayAccess(ar2,lb2,e2,rb2)) -> + conjunct_bindings (unify_expression ar1 ar2) (unify_expression e1 e2) + | (Ast.RecordAccess(e1,d1,fld1),Ast.RecordAccess(e2,d2,fld2)) -> + conjunct_bindings (unify_expression e1 e2) (unify_ident fld1 fld2) + | (Ast.RecordPtAccess(e1,pt1,fld1),Ast.RecordPtAccess(e2,pt2,fld2)) -> + conjunct_bindings (unify_expression e1 e2) (unify_ident fld1 fld2) + | (Ast.Cast(lp1,ty1,rp1,e1),Ast.Cast(lp2,ty2,rp2,e2)) -> + conjunct_bindings (unify_fullType ty1 ty2) (unify_expression e1 e2) + | (Ast.SizeOfExpr(szf1,e1),Ast.SizeOfExpr(szf2,e2)) -> + unify_expression e1 e2 + | (Ast.SizeOfType(szf1,lp1,ty1,rp1),Ast.SizeOfType(szf2,lp2,ty2,rp2)) -> + unify_fullType ty1 ty2 + | (Ast.TypeExp(ty1),Ast.TypeExp(ty2)) -> unify_fullType ty1 ty2 + | (Ast.Paren(lp1,e1,rp1),Ast.Paren(lp2,e2,rp2)) -> + unify_expression e1 e2 + + | (Ast.MetaErr(_,_,_,_),_) + | (Ast.MetaExpr(_,_,_,_,_,_),_) + | (Ast.MetaExprList(_,_,_,_),_) + | (_,Ast.MetaErr(_,_,_,_)) + | (_,Ast.MetaExpr(_,_,_,_,_,_)) + | (_,Ast.MetaExprList(_,_,_,_)) -> return true + + | (Ast.EComma(cm1),Ast.EComma(cm2)) -> return true + + | (Ast.DisjExpr(e1),_) -> + disjunct_all_bindings (List.map (function x -> unify_expression x e2) e1) + | (_,Ast.DisjExpr(e2)) -> + disjunct_all_bindings (List.map (function x -> unify_expression e1 x) e2) + | (Ast.NestExpr(e1,_,_),Ast.NestExpr(e2,_,_)) -> + unify_dots unify_expression edots e1 e2 + + (* dots can match against anything. return true to be safe. *) + | (Ast.Edots(_,_),_) | (_,Ast.Edots(_,_)) + | (Ast.Ecircles(_,_),_) | (_,Ast.Ecircles(_,_)) + | (Ast.Estars(_,_),_) | (_,Ast.Estars(_,_)) -> return true + + | (Ast.OptExp(_),_) + | (Ast.UniqueExp(_),_) + | (_,Ast.OptExp(_)) + | (_,Ast.UniqueExp(_)) -> failwith "unsupported expression" + | _ -> return false + +(* --------------------------------------------------------------------- *) +(* Types *) + +and unify_fullType ft1 ft2 = + match (Ast.unwrap ft1,Ast.unwrap ft2) with + (Ast.Type(cv1,ty1),Ast.Type(cv2,ty2)) -> + if bool_unify_option unify_mcode cv1 cv2 + then unify_typeC ty1 ty2 + else return false + | (Ast.DisjType(ft1),_) -> + disjunct_all_bindings (List.map (function x -> unify_fullType x ft2) ft1) + | (_,Ast.DisjType(ft2)) -> + disjunct_all_bindings (List.map (function x -> unify_fullType ft1 x) ft2) + + | (Ast.OptType(_),_) + | (Ast.UniqueType(_),_) + | (_,Ast.OptType(_)) + | (_,Ast.UniqueType(_)) -> failwith "unsupported type" + +and unify_typeC t1 t2 = + match (Ast.unwrap t1,Ast.unwrap t2) with + (Ast.BaseType(ty1,stringsa),Ast.BaseType(ty2,stringsb)) -> + if ty1 = ty2 + then + unify_lists ret_unify_mcode (function _ -> false (* not dots*)) + stringsa stringsb + else return false + | (Ast.SignedT(sgn1,ty1),Ast.SignedT(sgn2,ty2)) -> + if unify_mcode sgn1 sgn2 + then unify_option unify_typeC ty1 ty2 + else return false + | (Ast.Pointer(ty1,s1),Ast.Pointer(ty2,s2)) -> unify_fullType ty1 ty2 + | (Ast.FunctionPointer(tya,lp1a,stara,rp1a,lp2a,paramsa,rp2a), + Ast.FunctionPointer(tyb,lp1b,starb,rp1b,lp2b,paramsb,rp2b)) -> + if List.for_all2 unify_mcode + [lp1a;stara;rp1a;lp2a;rp2a] [lp1b;starb;rp1b;lp2b;rp2b] + then + conjunct_bindings (unify_fullType tya tyb) + (unify_dots unify_parameterTypeDef pdots paramsa paramsb) + else return false + | (Ast.FunctionType(_,tya,lp1a,paramsa,rp1a), + Ast.FunctionType(_,tyb,lp1b,paramsb,rp1b)) -> + if List.for_all2 unify_mcode [lp1a;rp1a] [lp1b;rp1b] + then + conjunct_bindings (unify_option unify_fullType tya tyb) + (unify_dots unify_parameterTypeDef pdots paramsa paramsb) + else return false + | (Ast.FunctionType _ , _) -> failwith "not supported" + | (Ast.Array(ty1,lb1,e1,rb1),Ast.Array(ty2,lb2,e2,rb2)) -> + conjunct_bindings + (unify_fullType ty1 ty2) (unify_option unify_expression e1 e2) + | (Ast.EnumName(s1,ts1),Ast.EnumName(s2,ts2)) -> + if unify_mcode s1 s2 then unify_ident ts1 ts2 else return false + | (Ast.StructUnionName(s1,Some ts1),Ast.StructUnionName(s2,Some ts2)) -> + if unify_mcode s1 s2 then unify_ident ts1 ts2 else return false + | (Ast.StructUnionName(s1,None),Ast.StructUnionName(s2,None)) -> + return true + | (Ast.StructUnionDef(ty1,lb1,decls1,rb1), + Ast.StructUnionDef(ty2,lb2,decls2,rb2)) -> + conjunct_bindings (unify_fullType ty1 ty2) + (unify_dots unify_declaration ddots decls1 decls2) + | (Ast.TypeName(t1),Ast.TypeName(t2)) -> return (unify_mcode t1 t2) + + | (Ast.MetaType(_,_,_),_) + | (_,Ast.MetaType(_,_,_)) -> return true + | _ -> return false + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and unify_declaration d1 d2 = + match (Ast.unwrap d1,Ast.unwrap d2) with + (Ast.Init(stg1,ft1,id1,eq1,i1,s1),Ast.Init(stg2,ft2,id2,eq2,i2,s2)) -> + if bool_unify_option unify_mcode stg1 stg2 + then + conjunct_bindings (unify_fullType ft1 ft2) + (conjunct_bindings (unify_ident id1 id2) (unify_initialiser i1 i2)) + else return false + | (Ast.UnInit(stg1,ft1,id1,s1),Ast.UnInit(stg2,ft2,id2,s2)) -> + if bool_unify_option unify_mcode stg1 stg2 + then conjunct_bindings (unify_fullType ft1 ft2) (unify_ident id1 id2) + else return false + | (Ast.MacroDecl(n1,lp1,args1,rp1,sem1), + Ast.MacroDecl(n2,lp2,args2,rp2,sem2)) -> + conjunct_bindings (unify_ident n1 n2) + (unify_dots unify_expression edots args1 args2) + | (Ast.TyDecl(ft1,s1),Ast.TyDecl(ft2,s2)) -> unify_fullType ft1 ft2 + | (Ast.Typedef(stg1,ft1,id1,s1),Ast.Typedef(stg2,ft2,id2,s2)) -> + conjunct_bindings (unify_fullType ft1 ft2) (unify_typeC id1 id2) + | (Ast.DisjDecl(d1),_) -> + disjunct_all_bindings + (List.map (function x -> unify_declaration x d2) d1) + | (_,Ast.DisjDecl(d2)) -> + disjunct_all_bindings + (List.map (function x -> unify_declaration d1 x) d2) + (* dots can match against anything. return true to be safe. *) + | (Ast.Ddots(_,_),_) | (_,Ast.Ddots(_,_)) -> return true + + | (Ast.OptDecl(_),_) + | (Ast.UniqueDecl(_),_) + | (_,Ast.OptDecl(_)) + | (_,Ast.UniqueDecl(_)) -> failwith "unsupported decl" + | _ -> return false + +(* --------------------------------------------------------------------- *) +(* Initializer *) + +and unify_initialiser i1 i2 = + match (Ast.unwrap i1,Ast.unwrap i2) with + (Ast.InitExpr(expa),Ast.InitExpr(expb)) -> + unify_expression expa expb + | (Ast.InitList(_,initlista,_,whena), + Ast.InitList(_,initlistb,_,whenb)) -> + (* ignore whencode - returns true safely *) + unify_lists unify_initialiser (function _ -> false) initlista initlistb + | (Ast.InitGccDotName(_,namea,_,inia), + Ast.InitGccDotName(_,nameb,_,inib)) -> + conjunct_bindings + (unify_ident namea nameb) (unify_initialiser inia inib) + | (Ast.InitGccName(namea,_,inia),Ast.InitGccName(nameb,_,inib)) -> + conjunct_bindings (unify_ident namea nameb) (unify_initialiser inia inib) + | (Ast.InitGccIndex(_,expa,_,_,inia), + Ast.InitGccIndex(_,expb,_,_,inib)) -> + conjunct_bindings + (unify_expression expa expb) (unify_initialiser inia inib) + | (Ast.InitGccRange(_,exp1a,_,exp2a,_,_,inia), + Ast.InitGccRange(_,exp1b,_,exp2b,_,_,inib)) -> + conjunct_bindings (unify_expression exp1a exp1b) + (conjunct_bindings (unify_expression exp2a exp2b) + (unify_initialiser inia inib)) + + | (Ast.OptIni(_),_) + | (Ast.UniqueIni(_),_) + | (_,Ast.OptIni(_)) + | (_,Ast.UniqueIni(_)) -> failwith "unsupported decl" + | _ -> return false + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and unify_parameterTypeDef p1 p2 = + match (Ast.unwrap p1,Ast.unwrap p2) with + (Ast.VoidParam(ft1),Ast.VoidParam(ft2)) -> unify_fullType ft1 ft2 + | (Ast.Param(ft1,i1),Ast.Param(ft2,i2)) -> + conjunct_bindings (unify_fullType ft1 ft2) + (unify_option unify_ident i1 i2) + + | (Ast.MetaParam(_,_,_),_) + | (Ast.MetaParamList(_,_,_,_),_) + | (_,Ast.MetaParam(_,_,_)) + | (_,Ast.MetaParamList(_,_,_,_)) -> return true + + | (Ast.PComma(_),Ast.PComma(_)) -> return true + + (* dots can match against anything. return true to be safe. *) + | (Ast.Pdots(_),_) | (_,Ast.Pdots(_)) + | (Ast.Pcircles(_),_) | (_,Ast.Pcircles(_)) -> return true + + | (Ast.OptParam(_),_) + | (Ast.UniqueParam(_),_) + | (_,Ast.OptParam(_)) + | (_,Ast.UniqueParam(_)) -> failwith "unsupported parameter" + | _ -> return false + +(* --------------------------------------------------------------------- *) +(* Define parameter *) + +and unify_define_parameters p1 p2 = + match (Ast.unwrap p1,Ast.unwrap p2) with + (Ast.NoParams,Ast.NoParams) -> return true + | (Ast.DParams(lp1,params1,rp1),Ast.DParams(lp2,params2,rp2)) -> + unify_dots unify_define_param dpdots params1 params2 + | _ -> return false + +and unify_define_param p1 p2 = + match (Ast.unwrap p1,Ast.unwrap p2) with + (Ast.DParam(i1),Ast.DParam(i2)) -> + (unify_ident i1 i2) + | (Ast.DPComma(_),Ast.DPComma(_)) -> return true + + (* dots can match against anything. return true to be safe. *) + | (Ast.DPdots(_),_) | (_,Ast.DPdots(_)) + | (Ast.DPcircles(_),_) | (_,Ast.DPcircles(_)) -> return true + + | (Ast.OptDParam(_),_) + | (Ast.UniqueDParam(_),_) + | (_,Ast.OptDParam(_)) + | (_,Ast.UniqueDParam(_)) -> failwith "unsupported parameter" + | _ -> return false + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +and unify_rule_elem re1 re2 = + match (Ast.unwrap re1,Ast.unwrap re2) with + (Ast.FunHeader(_,_,fi1,nm1,lp1,params1,rp1), + Ast.FunHeader(_,_,fi2,nm2,lp2,params2,rp2)) -> + conjunct_bindings (unify_fninfo fi1 fi2) + (conjunct_bindings (unify_ident nm1 nm2) + (unify_dots unify_parameterTypeDef pdots params1 params2)) + | (Ast.Decl(_,_,d1),Ast.Decl(_,_,d2)) -> unify_declaration d1 d2 + + | (Ast.SeqStart(lb1),Ast.SeqStart(lb2)) -> return true + | (Ast.SeqEnd(rb1),Ast.SeqEnd(rb2)) -> return true + + | (Ast.ExprStatement(e1,s1),Ast.ExprStatement(e2,s2)) -> + unify_expression e1 e2 + | (Ast.IfHeader(if1,lp1,e1,rp1),Ast.IfHeader(if2,lp2,e2,rp2)) -> + unify_expression e1 e2 + | (Ast.Else(e1),Ast.Else(e2)) -> return true + | (Ast.WhileHeader(wh1,lp1,e1,rp1),Ast.WhileHeader(wh2,lp2,e2,rp2)) -> + unify_expression e1 e2 + | (Ast.DoHeader(d1),Ast.DoHeader(d2)) -> return true + | (Ast.WhileTail(wh1,lp1,e1,rp1,s1),Ast.WhileTail(wh2,lp2,e2,rp2,s2)) -> + unify_expression e1 e2 + | (Ast.ForHeader(fr1,lp1,e11,s11,e21,s21,e31,rp1), + Ast.ForHeader(fr2,lp2,e12,s12,e22,s22,e32,rp2)) -> + conjunct_bindings + (unify_option unify_expression e11 e12) + (conjunct_bindings + (unify_option unify_expression e21 e22) + (unify_option unify_expression e31 e32)) + | (Ast.IteratorHeader(nm1,lp1,args1,rp1), + Ast.IteratorHeader(nm2,lp2,args2,rp2)) -> + conjunct_bindings (unify_ident nm1 nm2) + (unify_dots unify_expression edots args1 args2) + | (Ast.DefineHeader(_,n1,p1),Ast.DefineHeader(_,n2,p2)) -> + conjunct_bindings (unify_ident n1 n2) + (unify_define_parameters p1 p2) + | (Ast.Break(r1,s1),Ast.Break(r2,s2)) -> return true + | (Ast.Continue(r1,s1),Ast.Continue(r2,s2)) -> return true + | (Ast.Label(l1,dd1),Ast.Label(l2,dd2)) -> unify_ident l1 l2 + | (Ast.Goto(g1,l1,dd1),Ast.Goto(g2,l2,dd2)) -> unify_ident l1 l2 + | (Ast.Return(r1,s1),Ast.Return(r2,s2)) -> return true + | (Ast.ReturnExpr(r1,e1,s1),Ast.ReturnExpr(r2,e2,s2)) -> + unify_expression e1 e2 + + | (Ast.DisjRuleElem(res1),_) -> + disjunct_all_bindings + (List.map (function x -> unify_rule_elem x re2) res1) + | (_,Ast.DisjRuleElem(res2)) -> + disjunct_all_bindings + (List.map (function x -> unify_rule_elem re1 x) res2) + + | (Ast.MetaRuleElem(_,_,_),_) + | (Ast.MetaStmt(_,_,_,_),_) + | (Ast.MetaStmtList(_,_,_),_) + | (_,Ast.MetaRuleElem(_,_,_)) + | (_,Ast.MetaStmt(_,_,_,_)) + | (_,Ast.MetaStmtList(_,_,_)) -> return true + + (* can match a rule_elem in different parts *) + | (Ast.Exp(e1),Ast.Exp(e2)) -> return true + | (Ast.Exp(e1),_) -> subexp (unify_expression e1) re2 + | (_,Ast.Exp(e2)) -> subexp (unify_expression e2) re1 + + | (Ast.TopExp(e1),Ast.TopExp(e2)) -> unify_expression e1 e2 + | (Ast.TopInit(i1),Ast.TopInit(i2)) -> unify_initialiser i1 i2 + + (* can match a rule_elem in different parts *) + | (Ast.Ty(t1),Ast.Ty(t2)) -> return true + | (Ast.Ty(t1),_) -> subtype (unify_fullType t1) re2 + | (_,Ast.Ty(t2)) -> subtype (unify_fullType t2) re1 + | _ -> return false + +and unify_fninfo patterninfo cinfo = + let patterninfo = List.sort compare patterninfo in + let cinfo = List.sort compare cinfo in + let rec loop = function + (Ast.FStorage(sta)::resta,Ast.FStorage(stb)::restb) -> + if unify_mcode sta stb then loop (resta,restb) else return false + | (Ast.FType(tya)::resta,Ast.FType(tyb)::restb) -> + conjunct_bindings (unify_fullType tya tyb) (loop (resta,restb)) + | (Ast.FInline(ia)::resta,Ast.FInline(ib)::restb) -> + if unify_mcode ia ib then loop (resta,restb) else return false + | (Ast.FAttr(ia)::resta,Ast.FAttr(ib)::restb) -> + if unify_mcode ia ib then loop (resta,restb) else return false + | (x::resta,((y::_) as restb)) -> + (match compare x y with + -1 -> return false + | 1 -> loop (resta,restb) + | _ -> failwith "not possible") + | _ -> return false in + loop (patterninfo,cinfo) + +and subexp f = + let bind = conjunct_bindings in + let option_default = return false in + let mcode r e = option_default in + let expr r k e = conjunct_bindings (f e) (k e) in + let donothing r k e = k e in + let recursor = V.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + donothing expr donothing donothing donothing donothing donothing + donothing donothing donothing donothing donothing in + recursor.V.combiner_rule_elem + +and subtype f = + let bind = conjunct_bindings in + let option_default = return false in + let mcode r e = option_default in + let fullType r k e = conjunct_bindings (f e) (k e) in + let donothing r k e = k e in + let recursor = V.combiner bind option_default + mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode + donothing donothing donothing donothing + donothing donothing fullType donothing donothing donothing donothing + donothing donothing donothing donothing donothing in + recursor.V.combiner_rule_elem + +let rec unify_statement s1 s2 = + match (Ast.unwrap s1,Ast.unwrap s2) with + (Ast.Seq(lb1,d1,s1,rb1),Ast.Seq(lb2,d2,s2,rb2)) -> + conjunct_bindings (unify_rule_elem lb1 lb2) + (conjunct_bindings + (unify_dots unify_statement sdots s1 s2) + (conjunct_bindings + (unify_dots unify_statement sdots d1 d2) + (unify_rule_elem rb1 rb2))) + | (Ast.IfThen(h1,thn1,_),Ast.IfThen(h2,thn2,_)) -> + conjunct_bindings (unify_rule_elem h1 h2) (unify_statement thn1 thn2) + | (Ast.IfThenElse(h1,thn1,e1,els1,_),Ast.IfThenElse(h2,thn2,e2,els2,_)) -> + conjunct_bindings (unify_rule_elem h1 h2) + (conjunct_bindings (unify_statement thn1 thn2) + (conjunct_bindings (unify_rule_elem e1 e2) + (unify_statement els1 els2))) + | (Ast.While(h1,s1,_),Ast.While(h2,s2,_)) -> + conjunct_bindings (unify_rule_elem h1 h2) (unify_statement s1 s2) + | (Ast.Do(h1,s1,t1),Ast.Do(h2,s2,t2)) -> + conjunct_bindings (unify_rule_elem h1 h2) + (conjunct_bindings (unify_statement s1 s2) (unify_rule_elem t1 t2)) + | (Ast.For(h1,s1,_),Ast.For(h2,s2,_)) -> + conjunct_bindings (unify_rule_elem h1 h2) (unify_statement s1 s2) + | (Ast.Atomic(re1),Ast.Atomic(re2)) -> unify_rule_elem re1 re2 + | (Ast.Disj(s1),_) -> + let s2 = Ast.rewrap s2 (Ast.DOTS[s2]) in + disjunct_all_bindings + (List.map + (function x -> unify_dots unify_statement sdots x s2) + s1) + | (_,Ast.Disj(s2)) -> + let s1 = Ast.rewrap s1 (Ast.DOTS[s1]) in + disjunct_all_bindings + (List.map + (function x -> unify_dots unify_statement sdots s1 x) + s2) + | (Ast.Nest(s1,_,_,_,_),Ast.Nest(s2,_,_,_,_)) -> + unify_dots unify_statement sdots s1 s2 + | (Ast.FunDecl(h1,lb1,d1,s1,rb1),Ast.FunDecl(h2,lb2,d2,s2,rb2)) -> + conjunct_bindings (unify_rule_elem h1 h2) + (conjunct_bindings (unify_rule_elem lb1 lb2) + (conjunct_bindings (unify_dots unify_statement sdots d1 d2) + (conjunct_bindings (unify_dots unify_statement sdots s1 s2) + (unify_rule_elem rb1 rb2)))) + | (Ast.Define(h1,s1),Ast.Define(h2,s2)) -> + conjunct_bindings (unify_rule_elem h1 h2) + (unify_dots unify_statement sdots s1 s2) + (* dots can match against anything. return true to be safe. *) + | (Ast.Dots(_,_,_,_),_) | (_,Ast.Dots(_,_,_,_)) + | (Ast.Circles(_,_,_,_),_) | (_,Ast.Circles(_,_,_,_)) + | (Ast.Stars(_,_,_,_),_) | (_,Ast.Stars(_,_,_,_)) -> return true + | (Ast.OptStm(_),_) + | (Ast.UniqueStm(_),_) + | (_,Ast.OptStm(_)) + | (_,Ast.UniqueStm(_)) -> failwith "unsupported statement" + | _ -> return false + +let unify_statement_dots = unify_dots unify_statement sdots diff --git a/parsing_cocci/.#unparse_ast0.ml.1.116 b/parsing_cocci/.#unparse_ast0.ml.1.116 new file mode 100644 index 0000000..fe3dd11 --- /dev/null +++ b/parsing_cocci/.#unparse_ast0.ml.1.116 @@ -0,0 +1,667 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +open Format +module Ast0 = Ast0_cocci +module U = Pretty_print_cocci + +let quiet = ref true (* true = no decoration on - context, etc *) + +let start_block str = + force_newline(); print_string " "; open_box 0 + +let end_block str = + close_box(); force_newline () + +let print_option = Common.do_option +let print_between = Common.print_between + +(* --------------------------------------------------------------------- *) +(* Positions *) + +let meta_pos = function + Ast0.MetaPos(name,_,_) -> + print_string "@"; + let (_,name) = Ast0.unwrap_mcode name in + print_string name + | Ast0.NoMetaPos -> () + +(* --------------------------------------------------------------------- *) +(* Modified code *) + +let mcodekind brackets fn x info = function + Ast0.MINUS(plus_stream) -> + let (lb,rb) = + if !quiet + then ("","") + else + match brackets with + Some x -> ("[","]^"^(string_of_int x)) + | None -> ("","") in + let (plus_stream,_) = !plus_stream in + if !quiet + then fn x + else (print_string "-"; + print_string lb; fn x; print_string rb); + U.print_anything ">>> " plus_stream + | Ast0.CONTEXT(plus_streams) -> + let (lb,rb) = + if !quiet + then ("","") + else + match brackets with + Some x -> ("[",("]^"^(string_of_int x))) | None -> ("","") in + let (plus_streams,t1,t2) = !plus_streams in + U.print_around + (function x -> + print_string lb; fn x; print_string rb) + x plus_streams + | Ast0.PLUS -> + List.iter (function s -> print_string s; force_newline()) + info.Ast0.strings_before; + fn x; + List.iter (function s -> force_newline(); print_string s) + info.Ast0.strings_after + | Ast0.MIXED(plus_streams) -> + let (lb,rb) = + if !quiet + then ("","") + else + let n = + match brackets with Some x -> "^"^(string_of_int x) | None -> "" in + ("§","½"^n) in + let (plus_streams,_,_) = !plus_streams in + U.print_around (function x -> print_string lb; fn x; print_string rb) + x plus_streams + +let mcode fn (x,_,info,mc,pos) = + let fn x = fn x; meta_pos !pos in + mcodekind (Some info.Ast0.line_start)(*None*) fn x info mc + +let print_context x fn = + mcodekind (Some (Ast0.get_line x)) fn () (Ast0.get_info x) + (Ast0.get_mcodekind x) + +let print_meta (_,name) = print_string name + +(* --------------------------------------------------------------------- *) +(* --------------------------------------------------------------------- *) +(* Dots *) + +let dots between fn d = + print_context d + (function _ -> + match Ast0.unwrap d with + Ast0.DOTS(l) -> print_between between fn l + | Ast0.CIRCLES(l) -> print_between between fn l + | Ast0.STARS(l) -> print_between between fn l) + +(* --------------------------------------------------------------------- *) + +let print_types = function + None -> () + | Some ty -> + print_string "/* "; + Format.print_flush(); + print_between (function _ -> print_string ", ") Type_cocci.typeC ty; + Format.print_flush(); + print_string " */" + +(* --------------------------------------------------------------------- *) +(* Identifier *) + +let rec ident i = + print_context i + (function _ -> + match Ast0.unwrap i with + Ast0.Id(name) -> mcode print_string name + | Ast0.MetaId(name,_,_) -> mcode print_meta name + | Ast0.MetaFunc(name,_,_) -> mcode print_meta name + | Ast0.MetaLocalFunc(name,_,_) -> mcode print_meta name + | Ast0.OptIdent(id) -> print_string "?"; ident id + | Ast0.UniqueIdent(id) -> print_string "!"; ident id) + +(* --------------------------------------------------------------------- *) +(* Expression *) + +let print_string_box s = print_string s; open_box 0 + +let rec expression e = + print_option Type_cocci.typeC (Ast0.get_type e); + print_context e + (function _ -> + match Ast0.unwrap e with + Ast0.Ident(id) -> ident id + | Ast0.Constant(const) -> mcode U.constant const + | Ast0.FunCall(fn,lp,args,rp) -> + expression fn; mcode print_string_box lp; + let _ = dots (function _ -> ()) expression args in + close_box(); mcode print_string rp + | Ast0.Assignment(left,op,right,_) -> + expression left; print_string " "; mcode U.assignOp op; + print_string " "; expression right + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> + expression exp1; print_string " "; mcode print_string why; + print_option (function e -> print_string " "; expression e) exp2; + print_string " "; mcode print_string colon; expression exp3 + | Ast0.Postfix(exp,op) -> expression exp; mcode U.fixOp op + | Ast0.Infix(exp,op) -> mcode U.fixOp op; expression exp + | Ast0.Unary(exp,op) -> mcode U.unaryOp op; expression exp + | Ast0.Binary(left,op,right) -> + print_string "("; + expression left; print_string " "; mcode U.binaryOp op; + print_string " "; expression right; + print_string ")" + | Ast0.Nested(left,op,right) -> + print_string "("; + expression left; print_string " "; mcode U.binaryOp op; + print_string " "; expression right; + print_string ")" + | Ast0.Paren(lp,exp,rp) -> + mcode print_string_box lp; expression exp; close_box(); + mcode print_string rp + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> + expression exp1; mcode print_string_box lb; expression exp2; + close_box(); mcode print_string rb + | Ast0.RecordAccess(exp,pt,field) -> + expression exp; mcode print_string pt; ident field + | Ast0.RecordPtAccess(exp,ar,field) -> + expression exp; mcode print_string ar; ident field + | Ast0.Cast(lp,ty,rp,exp) -> + mcode print_string_box lp; typeC ty; close_box(); + mcode print_string rp; expression exp + | Ast0.SizeOfExpr(szf,exp) -> + mcode print_string szf; expression exp + | Ast0.SizeOfType(szf,lp,ty,rp) -> + mcode print_string szf; + mcode print_string_box lp; typeC ty; close_box(); + mcode print_string rp + | Ast0.TypeExp(ty) -> typeC ty + | Ast0.MetaErr(name,_,_) -> mcode print_meta name + | Ast0.MetaExpr(name,_,ty,_,pure) -> + mcode print_meta name; print_types ty(*; + print_string "^"; + (match pure with + Ast0.Pure -> print_string "pure" + | Ast0.Impure -> print_string "impure" + | Ast0.Context -> print_string "context" + | Ast0.PureContext -> print_string "pure_context")*) + | Ast0.MetaExprList(name,_,_) -> mcode print_meta name + | Ast0.EComma(cm) -> mcode print_string cm; print_space() + | Ast0.DisjExpr(_,exp_list,_,_) -> + print_string "\n("; force_newline(); + print_between + (function _ -> print_string "\n|"; force_newline()) + expression exp_list; + print_string "\n)" + | Ast0.NestExpr(starter,expr_dots,ender,None,multi) -> + mcode print_string starter; + start_block(); dots force_newline expression expr_dots; end_block(); + mcode print_string ender + | Ast0.NestExpr(starter,expr_dots,ender,Some whencode,multi) -> + mcode print_string starter; print_string " WHEN != "; + expression whencode; + start_block(); dots force_newline expression expr_dots; end_block(); + mcode print_string ender + | Ast0.Edots(dots,Some whencode) + | Ast0.Ecircles(dots,Some whencode) + | Ast0.Estars(dots,Some whencode) -> + mcode print_string dots; print_string " WHEN != "; + expression whencode + | Ast0.Edots(dots,None) + | Ast0.Ecircles(dots,None) + | Ast0.Estars(dots,None) -> mcode print_string dots + | Ast0.OptExp(exp) -> print_string "?"; expression exp + | Ast0.UniqueExp(exp) -> print_string "!"; expression exp) + +and expression_dots x = dots (function _ -> ()) expression x + +(* --------------------------------------------------------------------- *) +(* Types *) + +and print_function_pointer (ty,lp1,star,rp1,lp2,params,rp2) fn = + typeC ty; mcode print_string lp1; mcode print_string star; fn(); + mcode print_string rp1; mcode print_string lp2; + parameter_list params; mcode print_string rp2 + +and print_function_type (ty,lp1,params,rp1) fn = + print_option typeC ty; fn(); mcode print_string lp1; + parameter_list params; mcode print_string rp1 + +and typeC t = + print_context t + (function _ -> + match Ast0.unwrap t with + Ast0.ConstVol(cv,ty) -> + mcode U.const_vol cv; print_string " "; typeC ty + | Ast0.BaseType(ty,strings) -> + List.iter (function s -> mcode print_string s; print_string " ") + strings + | Ast0.Signed(sgn,ty) -> mcode U.sign sgn; print_option typeC ty + | Ast0.Pointer(ty,star) -> typeC ty; mcode print_string star + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + print_function_pointer (ty,lp1,star,rp1,lp2,params,rp2) + (function _ -> ()) + | Ast0.FunctionType(ty,lp1,params,rp1) -> + print_function_type (ty,lp1,params,rp1) (function _ -> ()) + | Ast0.Array(ty,lb,size,rb) -> + typeC ty; mcode print_string lb; print_option expression size; + mcode print_string rb + | Ast0.EnumName(kind,name) -> mcode print_string kind; print_string " "; + ident name + | Ast0.StructUnionName(kind,name) -> + mcode U.structUnion kind; + print_option (function x -> ident x; print_string " ") name + | Ast0.StructUnionDef(ty,lb,decls,rb) -> + typeC ty; mcode print_string lb; + dots force_newline declaration decls; + mcode print_string rb + | Ast0.TypeName(name)-> mcode print_string name; print_string " " + | Ast0.MetaType(name,_)-> mcode print_meta name; print_string " " + | Ast0.DisjType(lp,types,mids,rp) -> + print_string "\n"; mcode print_string lp; force_newline(); + print_between + (function _ -> print_string "\n|"; force_newline()) + typeC types; + print_string "\n"; mcode print_string rp + | Ast0.OptType(ty) -> print_string "?"; typeC ty + | Ast0.UniqueType(ty) -> print_string "!"; typeC ty) + +(* --------------------------------------------------------------------- *) +(* Variable declaration *) +(* Even if the Cocci program specifies a list of declarations, they are + split out into multiple declarations of a single variable each. *) + +and print_named_type ty id = + match Ast0.unwrap ty with + Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + print_function_pointer (ty,lp1,star,rp1,lp2,params,rp2) + (function _ -> print_string " "; ident id) + | Ast0.FunctionType(ty,lp1,params,rp1) -> + print_function_type (ty,lp1,params,rp1) + (function _ -> print_string " "; ident id) + | Ast0.Array(ty,lb,size,rb) -> + let rec loop ty k = + match Ast0.unwrap ty with + Ast0.Array(ty,lb,size,rb) -> + loop ty + (function _ -> + k (); + mcode print_string lb; + print_option expression size; + mcode print_string rb) + | _ -> typeC ty; ident id; k () in + loop ty (function _ -> ()) + | _ -> typeC ty; ident id + +and declaration d = + print_context d + (function _ -> + match Ast0.unwrap d with + Ast0.Init(stg,ty,id,eq,ini,sem) -> + print_option (mcode U.storage) stg; + print_named_type ty id; + print_string " "; + mcode print_string eq; print_string " "; initialiser ini; + mcode print_string sem + | Ast0.UnInit(stg,ty,id,sem) -> + print_option (mcode U.storage) stg; print_named_type ty id; + mcode print_string sem + | Ast0.MacroDecl(name,lp,args,rp,sem) -> + ident name; mcode print_string_box lp; + let _ = dots (function _ -> ()) expression args in + close_box(); mcode print_string rp; mcode print_string sem + | Ast0.TyDecl(ty,sem) -> typeC ty; mcode print_string sem + | Ast0.Typedef(stg,ty,id,sem) -> + mcode print_string stg; typeC ty; typeC id; + mcode print_string sem + | Ast0.DisjDecl(_,decls,_,_) -> + print_string "\n("; force_newline(); + print_between + (function _ -> print_string "\n|"; force_newline()) + declaration decls; + print_string "\n)" + | Ast0.Ddots(dots,Some whencode) -> + mcode print_string dots; print_string " when != "; + declaration whencode + | Ast0.Ddots(dots,None) -> mcode print_string dots + | Ast0.OptDecl(decl) -> print_string "?"; declaration decl + | Ast0.UniqueDecl(decl) -> print_string "!"; declaration decl) + +and declaration_dots l = dots (function _ -> ()) declaration l + +(* --------------------------------------------------------------------- *) +(* Initialiser *) + +and initialiser i = + print_context i + (function _ -> + match Ast0.unwrap i with + Ast0.InitExpr(exp) -> expression exp + | Ast0.InitList(lb,initlist,rb) -> + mcode print_string lb; open_box 0; + let _ = dots (function _ -> ()) initialiser initlist in + close_box(); mcode print_string rb + | Ast0.InitGccDotName(dot,name,eq,ini) -> + mcode print_string dot; ident name; print_string " "; + mcode print_string eq; print_string " "; initialiser ini + | Ast0.InitGccName(name,eq,ini) -> + ident name; mcode print_string eq; initialiser ini + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> + mcode print_string lb; expression exp; mcode print_string rb; + print_string " "; mcode print_string eq; print_string " "; + initialiser ini + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + mcode print_string lb; expression exp1; mcode print_string dots; + expression exp2; mcode print_string rb; + print_string " "; mcode print_string eq; print_string " "; + initialiser ini + | Ast0.IComma(cm) -> mcode print_string cm; force_newline() + | Ast0.Idots(d,Some whencode) -> + mcode print_string d; print_string " WHEN != "; + initialiser whencode + | Ast0.Idots(d,None) -> mcode print_string d + | Ast0.OptIni(ini) -> print_string "?"; initialiser ini + | Ast0.UniqueIni(ini) -> print_string "!"; initialiser ini) + +and initialiser_list l = dots (function _ -> ()) initialiser l + +(* --------------------------------------------------------------------- *) +(* Parameter *) + +and parameterTypeDef p = + print_context p + (function _ -> + match Ast0.unwrap p with + Ast0.VoidParam(ty) -> typeC ty + | Ast0.Param(ty,Some id) -> print_named_type ty id + | Ast0.Param(ty,None) -> typeC ty + | Ast0.MetaParam(name,_) -> mcode print_meta name + | Ast0.MetaParamList(name,_,_) -> mcode print_meta name + | Ast0.PComma(cm) -> mcode print_string cm; print_space() + | Ast0.Pdots(dots) -> mcode print_string dots + | Ast0.Pcircles(dots) -> mcode print_string dots + | Ast0.OptParam(param) -> print_string "?"; parameterTypeDef param + | Ast0.UniqueParam(param) -> print_string "!"; parameterTypeDef param) + +and parameter_list l = dots (function _ -> ()) parameterTypeDef l + +(* --------------------------------------------------------------------- *) +(* Top-level code *) + +and statement arity s = + print_context s + (function _ -> + match Ast0.unwrap s with + Ast0.FunDecl(_,fninfo,name,lp,params,rp,lbrace,body,rbrace) -> + print_string arity; + List.iter print_fninfo fninfo; + ident name; mcode print_string_box lp; + parameter_list params; close_box(); mcode print_string rp; + print_string " "; + print_string arity; mcode print_string lbrace; start_block(); + dots force_newline (statement arity) body; + end_block(); print_string arity; mcode print_string rbrace + | Ast0.Decl(_,decl) -> print_string arity; declaration decl + | Ast0.Seq(lbrace,body,rbrace) -> + print_string arity; mcode print_string lbrace; start_block(); + dots force_newline (statement arity) body; + end_block(); print_string arity; mcode print_string rbrace + | Ast0.ExprStatement(exp,sem) -> + print_string arity; expression exp; mcode print_string sem + | Ast0.IfThen(iff,lp,exp,rp,branch1,(info,aft)) -> + 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 Ast0.NoMetaPos) + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(info,aft)) -> + 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 Ast0.NoMetaPos) + | Ast0.While(whl,lp,exp,rp,body,(info,aft)) -> + 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 Ast0.NoMetaPos) + | Ast0.Do(d,body,whl,lp,exp,rp,sem) -> + print_string arity; mcode print_string d; print_string " "; + statement arity body; + print_string arity; + 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,e1,sem1,e2,sem2,e3,rp,body,(info,aft)) -> + print_string arity; + mcode print_string fr; mcode print_string_box lp; + print_option expression e1; mcode print_string sem1; + 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 Ast0.NoMetaPos) + | Ast0.Iterator(nm,lp,args,rp,body,(info,aft)) -> + 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 Ast0.NoMetaPos) + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> + print_string arity; + mcode print_string switch; print_string " "; + mcode print_string_box lp; expression exp; close_box(); + mcode print_string rp; print_string " "; mcode print_string lb; + dots force_newline (case_line arity) cases; + mcode print_string rb + | Ast0.Break(br,sem) -> + print_string arity; mcode print_string br; mcode print_string sem + | Ast0.Continue(cont,sem) -> + print_string arity; mcode print_string cont; mcode print_string sem + | Ast0.Label(l,dd) -> ident l; print_string ":" + | Ast0.Goto(goto,l,sem) -> + mcode print_string goto; ident l; mcode print_string sem + | Ast0.Return(ret,sem) -> + print_string arity; mcode print_string ret; mcode print_string sem + | Ast0.ReturnExpr(ret,exp,sem) -> + print_string arity; mcode print_string ret; print_string " "; + expression exp; mcode print_string sem + | Ast0.MetaStmt(name,pure) -> + print_string arity; mcode print_meta name;(* + print_string "^"; + (match pure with + Ast0.Pure -> print_string "pure" + | Ast0.Impure -> print_string "impure" + | Ast0.Context -> print_string "context" + | Ast0.PureContext -> print_string "pure_context")*) + | Ast0.MetaStmtList(name,_) -> + print_string arity; mcode print_meta name + | Ast0.Disj(_,statement_dots_list,_,_) -> + print_string arity; + print_string "\n("; force_newline(); + print_between + (function _ -> print_string "\n|"; force_newline()) + (dots force_newline (statement arity)) + statement_dots_list; + print_string "\n)" + | Ast0.Nest(starter,stmt_dots,ender,whn,multi) -> + print_string arity; + mcode print_string starter; + open_box 0; + List.iter + (whencode (dots force_newline (statement "")) (statement "")) + whn; + close_box(); + start_block(); + dots force_newline (statement arity) stmt_dots; + end_block(); + mcode print_string ender + | Ast0.Exp(exp) -> print_string arity; expression exp + | Ast0.TopExp(exp) -> print_string arity; expression exp + | Ast0.Ty(ty) -> print_string arity; typeC ty + | Ast0.TopInit(init) -> initialiser init + | Ast0.Dots(d,whn) | Ast0.Circles(d,whn) | Ast0.Stars(d,whn) -> + print_string arity; mcode print_string d; + List.iter + (whencode (dots force_newline (statement "")) (statement "")) + whn + | Ast0.Include(inc,s) -> + mcode print_string inc; print_string " "; mcode U.inc_file s + | Ast0.Define(def,id,params,body) -> + mcode print_string def; print_string " "; ident id; + print_define_parameters params; + print_string " "; + dots force_newline (statement arity) body + | Ast0.OptStm(re) -> statement "?" re + | Ast0.UniqueStm(re) -> statement "!" re) + +and print_define_parameters params = + match Ast0.unwrap params with + Ast0.NoParams -> () + | Ast0.DParams(lp,params,rp) -> + mcode print_string lp; + dots (function _ -> ()) print_define_param params; mcode print_string rp + +and print_define_param param = + match Ast0.unwrap param with + Ast0.DParam(id) -> ident id + | Ast0.DPComma(comma) -> mcode print_string comma + | Ast0.DPdots(dots) -> mcode print_string dots + | Ast0.DPcircles(circles) -> mcode print_string circles + | Ast0.OptDParam(dp) -> print_string "?"; print_define_param dp + | Ast0.UniqueDParam(dp) -> print_string "!"; print_define_param dp + +and print_fninfo = function + Ast0.FStorage(stg) -> mcode U.storage stg + | Ast0.FType(ty) -> typeC ty + | Ast0.FInline(inline) -> mcode print_string inline + | Ast0.FAttr(attr) -> mcode print_string attr + +and whencode notfn alwaysfn = function + Ast0.WhenNot a -> + print_string " WHEN != "; open_box 0; notfn a; close_box() + | Ast0.WhenAlways a -> + print_string " WHEN = "; open_box 0; alwaysfn a; close_box() + | Ast0.WhenModifier x -> print_string " WHEN "; U.print_when_modif x + | Ast0.WhenNotTrue a -> + print_string " WHEN != TRUE "; open_box 0; expression a; close_box() + | Ast0.WhenNotFalse a -> + print_string " WHEN != FALSE "; open_box 0; expression a; close_box() + +and case_line arity c = + print_context c + (function _ -> + match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> + print_string arity; + mcode print_string def; mcode print_string colon; print_string " "; + dots force_newline (statement arity) code + | Ast0.Case(case,exp,colon,code) -> + print_string arity; + mcode print_string case; print_string " "; expression exp; + mcode print_string colon; print_string " "; + dots force_newline (statement arity) code + | Ast0.OptCase(case) -> case_line "?" case) + +and statement_dots l = dots (function _ -> ()) (statement "") l +and case_dots l = dots (function _ -> ()) (case_line "") l + +(* --------------------------------------------------------------------- *) +(* Top level code *) + +let top_level t = + print_context t + (function _ -> + match Ast0.unwrap t with + Ast0.FILEINFO(old_file,new_file) -> + print_string "--- "; mcode print_string old_file; force_newline(); + print_string "+++ "; mcode print_string new_file + | Ast0.DECL(stmt) -> statement "" stmt + | Ast0.CODE(stmt_dots) -> + dots force_newline (statement "") stmt_dots + | Ast0.ERRORWORDS(exps) -> + print_string "error words = ["; + print_between (function _ -> print_string ", ") expression exps; + print_string "]" + | Ast0.OTHER(s) -> + print_string "OTHER("; statement "" s; print_string ")") + +let rule = + print_between (function _ -> force_newline(); force_newline()) top_level + +let unparse_anything x = + let q = !quiet in + quiet := true; + (match x with + Ast0.DotsExprTag(d) -> + print_string "ExpDots:"; force_newline(); + expression_dots d + | Ast0.DotsParamTag(d) -> + parameter_list d + | Ast0.DotsInitTag(d) -> + initialiser_list d + | Ast0.DotsStmtTag(d) -> + print_string "StmDots:"; force_newline(); + statement_dots d + | Ast0.DotsDeclTag(d) -> + declaration_dots d + | Ast0.DotsCaseTag(d) -> + case_dots d + | Ast0.IdentTag(d) -> + ident d + | Ast0.ExprTag(d) | Ast0.ArgExprTag(d) | Ast0.TestExprTag(d) -> + print_string "Exp:"; force_newline(); + expression d + | Ast0.TypeCTag(d) -> + typeC d + | Ast0.ParamTag(d) -> + parameterTypeDef d + | Ast0.InitTag(d) -> + initialiser d + | Ast0.DeclTag(d) -> + declaration d + | Ast0.StmtTag(d) -> + print_string "Stm:"; force_newline(); + statement "" d + | Ast0.CaseLineTag(d) -> + case_line "" d + | Ast0.TopTag(d) -> + top_level d + | Ast0.IsoWhenTag(x) -> U.print_when_modif x + | Ast0.IsoWhenTTag(e) -> expression e + | Ast0.IsoWhenFTag(e) -> expression e + | Ast0.MetaPosTag(var) -> meta_pos var); + quiet := q; + print_newline() + +let unparse x = + print_string "\n@@\n@@"; + force_newline(); + force_newline(); + rule x; + print_newline() + +let unparse_to_string x = Common.format_to_string (function _ -> unparse x) diff --git a/parsing_cocci/.#visitor_ast.ml.1.95 b/parsing_cocci/.#visitor_ast.ml.1.95 new file mode 100644 index 0000000..6541953 --- /dev/null +++ b/parsing_cocci/.#visitor_ast.ml.1.95 @@ -0,0 +1,1056 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +module Ast = Ast_cocci + +(* --------------------------------------------------------------------- *) +(* Generic traversal: combiner *) +(* parameters: + combining function + treatment of: mcode, identifiers, expressions, fullTypes, types, + declarations, statements, toplevels + default value for options *) + +type 'a combiner = + {combiner_ident : Ast.ident -> 'a; + combiner_expression : Ast.expression -> 'a; + combiner_fullType : Ast.fullType -> 'a; + combiner_typeC : Ast.typeC -> 'a; + combiner_declaration : Ast.declaration -> 'a; + combiner_initialiser : Ast.initialiser -> 'a; + combiner_parameter : Ast.parameterTypeDef -> 'a; + combiner_parameter_list : Ast.parameter_list -> 'a; + combiner_rule_elem : Ast.rule_elem -> 'a; + combiner_statement : Ast.statement -> 'a; + combiner_case_line : Ast.case_line -> 'a; + combiner_top_level : Ast.top_level -> 'a; + combiner_anything : Ast.anything -> 'a; + combiner_expression_dots : Ast.expression Ast.dots -> 'a; + combiner_statement_dots : Ast.statement Ast.dots -> 'a; + combiner_declaration_dots : Ast.declaration Ast.dots -> 'a} + +type ('mc,'a) cmcode = 'a combiner -> 'mc Ast_cocci.mcode -> 'a +type ('cd,'a) ccode = 'a combiner -> ('cd -> 'a) -> 'cd -> 'a + + +let combiner bind option_default + meta_mcodefn string_mcodefn const_mcodefn assign_mcodefn fix_mcodefn + unary_mcodefn binary_mcodefn + cv_mcodefn sign_mcodefn struct_mcodefn storage_mcodefn + inc_file_mcodefn + expdotsfn paramdotsfn stmtdotsfn decldotsfn + identfn exprfn ftfn tyfn initfn paramfn declfn rulefn stmtfn casefn + topfn anyfn = + let multibind l = + let rec loop = function + [] -> option_default + | [x] -> x + | x::xs -> bind x (loop xs) in + loop l in + let get_option f = function + Some x -> f x + | None -> option_default in + + let rec meta_mcode x = meta_mcodefn all_functions x + and string_mcode x = string_mcodefn all_functions x + and const_mcode x = const_mcodefn all_functions x + and assign_mcode x = assign_mcodefn all_functions x + and fix_mcode x = fix_mcodefn all_functions x + and unary_mcode x = unary_mcodefn all_functions x + and binary_mcode x = binary_mcodefn all_functions x + and cv_mcode x = cv_mcodefn all_functions x + and sign_mcode x = sign_mcodefn all_functions x + and struct_mcode x = struct_mcodefn all_functions x + and storage_mcode x = storage_mcodefn all_functions x + and inc_file_mcode x = inc_file_mcodefn all_functions x + + and expression_dots d = + let k d = + match Ast.unwrap d with + Ast.DOTS(l) | Ast.CIRCLES(l) | Ast.STARS(l) -> + multibind (List.map expression l) in + expdotsfn all_functions k d + + and parameter_dots d = + let k d = + match Ast.unwrap d with + Ast.DOTS(l) | Ast.CIRCLES(l) | Ast.STARS(l) -> + multibind (List.map parameterTypeDef l) in + paramdotsfn all_functions k d + + and statement_dots d = + let k d = + match Ast.unwrap d with + Ast.DOTS(l) | Ast.CIRCLES(l) | Ast.STARS(l) -> + multibind (List.map statement l) in + stmtdotsfn all_functions k d + + and declaration_dots d = + let k d = + match Ast.unwrap d with + Ast.DOTS(l) | Ast.CIRCLES(l) | Ast.STARS(l) -> + multibind (List.map declaration l) in + decldotsfn all_functions k d + + and ident i = + let k i = + match Ast.unwrap i with + Ast.Id(name) -> string_mcode name + | Ast.MetaId(name,_,_,_) -> meta_mcode name + | Ast.MetaFunc(name,_,_,_) -> meta_mcode name + | Ast.MetaLocalFunc(name,_,_,_) -> meta_mcode name + | Ast.OptIdent(id) -> ident id + | Ast.UniqueIdent(id) -> ident id in + identfn all_functions k i + + and expression e = + let k e = + match Ast.unwrap e with + Ast.Ident(id) -> ident id + | Ast.Constant(const) -> const_mcode const + | Ast.FunCall(fn,lp,args,rp) -> + multibind [expression fn; string_mcode lp; expression_dots args; + string_mcode rp] + | Ast.Assignment(left,op,right,simple) -> + multibind [expression left; assign_mcode op; expression right] + | Ast.CondExpr(exp1,why,exp2,colon,exp3) -> + multibind [expression exp1; string_mcode why; + get_option expression exp2; string_mcode colon; + expression exp3] + | Ast.Postfix(exp,op) -> bind (expression exp) (fix_mcode op) + | Ast.Infix(exp,op) -> bind (fix_mcode op) (expression exp) + | Ast.Unary(exp,op) -> bind (unary_mcode op) (expression exp) + | Ast.Binary(left,op,right) -> + multibind [expression left; binary_mcode op; expression right] + | Ast.Nested(left,op,right) -> + multibind [expression left; binary_mcode op; expression right] + | Ast.Paren(lp,exp,rp) -> + multibind [string_mcode lp; expression exp; string_mcode rp] + | Ast.ArrayAccess(exp1,lb,exp2,rb) -> + multibind + [expression exp1; string_mcode lb; expression exp2; + string_mcode rb] + | Ast.RecordAccess(exp,pt,field) -> + multibind [expression exp; string_mcode pt; ident field] + | Ast.RecordPtAccess(exp,ar,field) -> + multibind [expression exp; string_mcode ar; ident field] + | Ast.Cast(lp,ty,rp,exp) -> + multibind + [string_mcode lp; fullType ty; string_mcode rp; expression exp] + | Ast.SizeOfExpr(szf,exp) -> + multibind [string_mcode szf; expression exp] + | Ast.SizeOfType(szf,lp,ty,rp) -> + multibind + [string_mcode szf; string_mcode lp; fullType ty; string_mcode rp] + | Ast.TypeExp(ty) -> fullType ty + | Ast.MetaErr(name,_,_,_) + | Ast.MetaExpr(name,_,_,_,_,_) + | Ast.MetaExprList(name,_,_,_) -> meta_mcode name + | Ast.EComma(cm) -> string_mcode cm + | Ast.DisjExpr(exp_list) -> multibind (List.map expression exp_list) + | Ast.NestExpr(expr_dots,whencode,multi) -> + bind (expression_dots expr_dots) (get_option expression whencode) + | Ast.Edots(dots,whencode) | Ast.Ecircles(dots,whencode) + | Ast.Estars(dots,whencode) -> + bind (string_mcode dots) (get_option expression whencode) + | Ast.OptExp(exp) | Ast.UniqueExp(exp) -> + expression exp in + exprfn all_functions k e + + and fullType ft = + let k ft = + match Ast.unwrap ft with + Ast.Type(cv,ty) -> bind (get_option cv_mcode cv) (typeC ty) + | Ast.DisjType(types) -> multibind (List.map fullType types) + | Ast.OptType(ty) -> fullType ty + | Ast.UniqueType(ty) -> fullType ty in + ftfn all_functions k ft + + and function_pointer (ty,lp1,star,rp1,lp2,params,rp2) extra = + (* have to put the treatment of the identifier into the right position *) + multibind + ([fullType ty; string_mcode lp1; string_mcode star] @ extra @ + [string_mcode rp1; + string_mcode lp2; parameter_dots params; string_mcode rp2]) + + and function_type (ty,lp1,params,rp1) extra = + (* have to put the treatment of the identifier into the right position *) + multibind + ([get_option fullType ty] @ extra @ + [string_mcode lp1; parameter_dots params; string_mcode rp1]) + + and array_type (ty,lb,size,rb) extra = + multibind + ([fullType ty] @ extra @ + [string_mcode lb; get_option expression size; string_mcode rb]) + + and typeC ty = + let k ty = + match Ast.unwrap ty with + Ast.BaseType(ty,strings) -> multibind (List.map string_mcode strings) + | Ast.SignedT(sgn,ty) -> bind (sign_mcode sgn) (get_option typeC ty) + | Ast.Pointer(ty,star) -> + bind (fullType ty) (string_mcode star) + | Ast.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + function_pointer (ty,lp1,star,rp1,lp2,params,rp2) [] + | Ast.FunctionType (_,ty,lp1,params,rp1) -> + function_type (ty,lp1,params,rp1) [] + | Ast.Array(ty,lb,size,rb) -> array_type (ty,lb,size,rb) [] + | Ast.EnumName(kind,name) -> bind (string_mcode kind) (ident name) + | Ast.StructUnionName(kind,name) -> + bind (struct_mcode kind) (get_option ident name) + | Ast.StructUnionDef(ty,lb,decls,rb) -> + multibind + [fullType ty; string_mcode lb; declaration_dots decls; + string_mcode rb] + | Ast.TypeName(name) -> string_mcode name + | Ast.MetaType(name,_,_) -> meta_mcode name in + tyfn all_functions k ty + + and named_type ty id = + match Ast.unwrap ty with + Ast.Type(None,ty1) -> + (match Ast.unwrap ty1 with + Ast.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + function_pointer (ty,lp1,star,rp1,lp2,params,rp2) [ident id] + | Ast.FunctionType(_,ty,lp1,params,rp1) -> + function_type (ty,lp1,params,rp1) [ident id] + | Ast.Array(ty,lb,size,rb) -> array_type (ty,lb,size,rb) [ident id] + | _ -> bind (fullType ty) (ident id)) + | _ -> bind (fullType ty) (ident id) + + and declaration d = + let k d = + match Ast.unwrap d with + Ast.Init(stg,ty,id,eq,ini,sem) -> + bind (get_option storage_mcode stg) + (bind (named_type ty id) + (multibind + [string_mcode eq; initialiser ini; string_mcode sem])) + | Ast.UnInit(stg,ty,id,sem) -> + bind (get_option storage_mcode stg) + (bind (named_type ty id) (string_mcode sem)) + | Ast.MacroDecl(name,lp,args,rp,sem) -> + multibind + [ident name; string_mcode lp; expression_dots args; + string_mcode rp; string_mcode sem] + | Ast.TyDecl(ty,sem) -> bind (fullType ty) (string_mcode sem) + | Ast.Typedef(stg,ty,id,sem) -> + bind (string_mcode stg) + (bind (fullType ty) (bind (typeC id) (string_mcode sem))) + | Ast.DisjDecl(decls) -> multibind (List.map declaration decls) + | Ast.Ddots(dots,whencode) -> + bind (string_mcode dots) (get_option declaration whencode) + | Ast.MetaDecl(name,_,_) -> meta_mcode name + | Ast.OptDecl(decl) -> declaration decl + | Ast.UniqueDecl(decl) -> declaration decl in + declfn all_functions k d + + and initialiser i = + let k i = + match Ast.unwrap i with + Ast.InitExpr(exp) -> expression exp + | Ast.InitList(lb,initlist,rb,whencode) -> + multibind + [string_mcode lb; + multibind (List.map initialiser initlist); + string_mcode rb; + multibind (List.map initialiser whencode)] + | Ast.InitGccDotName(dot,name,eq,ini) -> + multibind + [string_mcode dot; ident name; string_mcode eq; initialiser ini] + | Ast.InitGccName(name,eq,ini) -> + multibind [ident name; string_mcode eq; initialiser ini] + | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> + multibind + [string_mcode lb; expression exp; string_mcode rb; + string_mcode eq; initialiser ini] + | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + multibind + [string_mcode lb; expression exp1; string_mcode dots; + expression exp2; string_mcode rb; string_mcode eq; + initialiser ini] + | Ast.IComma(cm) -> string_mcode cm + | Ast.OptIni(i) -> initialiser i + | Ast.UniqueIni(i) -> initialiser i in + initfn all_functions k i + + and parameterTypeDef p = + let k p = + match Ast.unwrap p with + Ast.VoidParam(ty) -> fullType ty + | Ast.Param(ty,Some id) -> named_type ty id + | Ast.Param(ty,None) -> fullType ty + | Ast.MetaParam(name,_,_) -> meta_mcode name + | Ast.MetaParamList(name,_,_,_) -> meta_mcode name + | Ast.PComma(cm) -> string_mcode cm + | Ast.Pdots(dots) -> string_mcode dots + | Ast.Pcircles(dots) -> string_mcode dots + | Ast.OptParam(param) -> parameterTypeDef param + | Ast.UniqueParam(param) -> parameterTypeDef param in + paramfn all_functions k p + + and rule_elem re = + let k re = + match Ast.unwrap re with + Ast.FunHeader(_,_,fi,name,lp,params,rp) -> + multibind + ((List.map fninfo fi) @ + [ident name;string_mcode lp;parameter_dots params; + string_mcode rp]) + | Ast.Decl(_,_,decl) -> declaration decl + | Ast.SeqStart(brace) -> string_mcode brace + | Ast.SeqEnd(brace) -> string_mcode brace + | Ast.ExprStatement(exp,sem) -> + bind (expression exp) (string_mcode sem) + | Ast.IfHeader(iff,lp,exp,rp) -> + multibind [string_mcode iff; string_mcode lp; expression exp; + string_mcode rp] + | Ast.Else(els) -> string_mcode els + | Ast.WhileHeader(whl,lp,exp,rp) -> + multibind [string_mcode whl; string_mcode lp; expression exp; + string_mcode rp] + | Ast.DoHeader(d) -> string_mcode d + | Ast.WhileTail(whl,lp,exp,rp,sem) -> + multibind [string_mcode whl; string_mcode lp; expression exp; + string_mcode rp; string_mcode sem] + | Ast.ForHeader(fr,lp,e1,sem1,e2,sem2,e3,rp) -> + multibind [string_mcode fr; string_mcode lp; + get_option expression e1; string_mcode sem1; + get_option expression e2; string_mcode sem2; + get_option expression e3; string_mcode rp] + | Ast.IteratorHeader(nm,lp,args,rp) -> + multibind [ident nm; string_mcode lp; + expression_dots args; string_mcode rp] + | Ast.SwitchHeader(switch,lp,exp,rp) -> + multibind [string_mcode switch; string_mcode lp; expression exp; + string_mcode rp] + | Ast.Break(br,sem) -> bind (string_mcode br) (string_mcode sem) + | Ast.Continue(cont,sem) -> bind (string_mcode cont) (string_mcode sem) + | Ast.Label(l,dd) -> bind (ident l) (string_mcode dd) + | Ast.Goto(goto,l,sem) -> + bind (string_mcode goto) (bind (ident l) (string_mcode sem)) + | Ast.Return(ret,sem) -> bind (string_mcode ret) (string_mcode sem) + | Ast.ReturnExpr(ret,exp,sem) -> + multibind [string_mcode ret; expression exp; string_mcode sem] + | Ast.MetaStmt(name,_,_,_) -> meta_mcode name + | Ast.MetaStmtList(name,_,_) -> meta_mcode name + | Ast.MetaRuleElem(name,_,_) -> meta_mcode name + | Ast.Exp(exp) -> expression exp + | Ast.TopExp(exp) -> expression exp + | Ast.Ty(ty) -> fullType ty + | Ast.TopInit(init) -> initialiser init + | Ast.Include(inc,name) -> bind (string_mcode inc) (inc_file_mcode name) + | Ast.DefineHeader(def,id,params) -> + multibind [string_mcode def; ident id; define_parameters params] + | Ast.Default(def,colon) -> bind (string_mcode def) (string_mcode colon) + | Ast.Case(case,exp,colon) -> + multibind [string_mcode case; expression exp; string_mcode colon] + | Ast.DisjRuleElem(res) -> multibind (List.map rule_elem res) in + rulefn all_functions k re + + (* not parameterizable for now... *) + and define_parameters p = + let k p = + match Ast.unwrap p with + Ast.NoParams -> option_default + | Ast.DParams(lp,params,rp) -> + multibind + [string_mcode lp; define_param_dots params; string_mcode rp] in + k p + + and define_param_dots d = + let k d = + match Ast.unwrap d with + Ast.DOTS(l) | Ast.CIRCLES(l) | Ast.STARS(l) -> + multibind (List.map define_param l) in + k d + + and define_param p = + let k p = + match Ast.unwrap p with + Ast.DParam(id) -> ident id + | Ast.DPComma(comma) -> string_mcode comma + | Ast.DPdots(d) -> string_mcode d + | Ast.DPcircles(c) -> string_mcode c + | Ast.OptDParam(dp) -> define_param dp + | Ast.UniqueDParam(dp) -> define_param dp in + k p + + (* discard the result, because the statement is assumed to be already + represented elsewhere in the code *) + and process_bef_aft s = + match Ast.get_dots_bef_aft s with + Ast.NoDots -> () + | Ast.DroppingBetweenDots(stm,ind) -> let _ = statement stm in () + | Ast.AddingBetweenDots(stm,ind) -> let _ = statement stm in () + + and statement s = + process_bef_aft s; + let k s = + match Ast.unwrap s with + Ast.Seq(lbrace,decls,body,rbrace) -> + multibind [rule_elem lbrace; statement_dots decls; + statement_dots body; rule_elem rbrace] + | Ast.IfThen(header,branch,_) -> + multibind [rule_elem header; statement branch] + | Ast.IfThenElse(header,branch1,els,branch2,_) -> + multibind [rule_elem header; statement branch1; rule_elem els; + statement branch2] + | Ast.While(header,body,_) -> + multibind [rule_elem header; statement body] + | Ast.Do(header,body,tail) -> + multibind [rule_elem header; statement body; rule_elem tail] + | Ast.For(header,body,_) -> multibind [rule_elem header; statement body] + | Ast.Iterator(header,body,_) -> + multibind [rule_elem header; statement body] + | Ast.Switch(header,lb,cases,rb) -> + multibind [rule_elem header;rule_elem lb; + multibind (List.map case_line cases); + rule_elem rb] + | Ast.Atomic(re) -> rule_elem re + | Ast.Disj(stmt_dots_list) -> + multibind (List.map statement_dots stmt_dots_list) + | Ast.Nest(stmt_dots,whn,_,_,_) -> + bind (statement_dots stmt_dots) + (multibind (List.map (whencode statement_dots statement) whn)) + | Ast.FunDecl(header,lbrace,decls,body,rbrace) -> + multibind [rule_elem header; rule_elem lbrace; + statement_dots decls; statement_dots body; + rule_elem rbrace] + | Ast.Define(header,body) -> + bind (rule_elem header) (statement_dots body) + | Ast.Dots(d,whn,_,_) | Ast.Circles(d,whn,_,_) | Ast.Stars(d,whn,_,_) -> + bind (string_mcode d) + (multibind (List.map (whencode statement_dots statement) whn)) + | Ast.OptStm(stmt) | Ast.UniqueStm(stmt) -> + statement stmt in + stmtfn all_functions k s + + and fninfo = function + Ast.FStorage(stg) -> storage_mcode stg + | Ast.FType(ty) -> fullType ty + | Ast.FInline(inline) -> string_mcode inline + | Ast.FAttr(attr) -> string_mcode attr + + and whencode notfn alwaysfn = function + Ast.WhenNot a -> notfn a + | Ast.WhenAlways a -> alwaysfn a + | Ast.WhenModifier(_) -> option_default + | Ast.WhenNotTrue(e) -> rule_elem e + | Ast.WhenNotFalse(e) -> rule_elem e + + and case_line c = + let k c = + match Ast.unwrap c with + Ast.CaseLine(header,code) -> + bind (rule_elem header) (statement_dots code) + | Ast.OptCase(case) -> case_line case in + casefn all_functions k c + + and top_level t = + let k t = + match Ast.unwrap t with + Ast.FILEINFO(old_file,new_file) -> + bind (string_mcode old_file) (string_mcode new_file) + | Ast.DECL(stmt) -> statement stmt + | Ast.CODE(stmt_dots) -> statement_dots stmt_dots + | Ast.ERRORWORDS(exps) -> multibind (List.map expression exps) in + topfn all_functions k t + + and anything a = + let k = function + (*in many cases below, the thing is not even mcode, so we do nothing*) + Ast.FullTypeTag(ft) -> fullType ft + | Ast.BaseTypeTag(bt) -> option_default + | Ast.StructUnionTag(su) -> option_default + | Ast.SignTag(sgn) -> option_default + | Ast.IdentTag(id) -> ident id + | Ast.ExpressionTag(exp) -> expression exp + | Ast.ConstantTag(cst) -> option_default + | Ast.UnaryOpTag(unop) -> option_default + | Ast.AssignOpTag(asgnop) -> option_default + | Ast.FixOpTag(fixop) -> option_default + | Ast.BinaryOpTag(binop) -> option_default + | Ast.ArithOpTag(arithop) -> option_default + | Ast.LogicalOpTag(logop) -> option_default + | Ast.DeclarationTag(decl) -> declaration decl + | Ast.InitTag(ini) -> initialiser ini + | Ast.StorageTag(stg) -> option_default + | Ast.IncFileTag(stg) -> option_default + | Ast.Rule_elemTag(rule) -> rule_elem rule + | Ast.StatementTag(rule) -> statement rule + | Ast.CaseLineTag(case) -> case_line case + | Ast.ConstVolTag(cv) -> option_default + | Ast.Token(tok,info) -> option_default + | Ast.Code(cd) -> top_level cd + | Ast.ExprDotsTag(ed) -> expression_dots ed + | Ast.ParamDotsTag(pd) -> parameter_dots pd + | Ast.StmtDotsTag(sd) -> statement_dots sd + | Ast.DeclDotsTag(sd) -> declaration_dots sd + | Ast.TypeCTag(ty) -> typeC ty + | Ast.ParamTag(param) -> parameterTypeDef param + | Ast.SgrepStartTag(tok) -> option_default + | Ast.SgrepEndTag(tok) -> option_default in + anyfn all_functions k a + + and all_functions = + {combiner_ident = ident; + combiner_expression = expression; + combiner_fullType = fullType; + combiner_typeC = typeC; + combiner_declaration = declaration; + combiner_initialiser = initialiser; + combiner_parameter = parameterTypeDef; + combiner_parameter_list = parameter_dots; + combiner_rule_elem = rule_elem; + combiner_statement = statement; + combiner_case_line = case_line; + combiner_top_level = top_level; + combiner_anything = anything; + combiner_expression_dots = expression_dots; + combiner_statement_dots = statement_dots; + combiner_declaration_dots = declaration_dots} in + all_functions + +(* ---------------------------------------------------------------------- *) + +type 'a inout = 'a -> 'a (* for specifying the type of rebuilder *) + +type rebuilder = + {rebuilder_ident : Ast.ident inout; + rebuilder_expression : Ast.expression inout; + rebuilder_fullType : Ast.fullType inout; + rebuilder_typeC : Ast.typeC inout; + rebuilder_declaration : Ast.declaration inout; + rebuilder_initialiser : Ast.initialiser inout; + rebuilder_parameter : Ast.parameterTypeDef inout; + rebuilder_parameter_list : Ast.parameter_list inout; + rebuilder_statement : Ast.statement inout; + rebuilder_case_line : Ast.case_line inout; + rebuilder_rule_elem : Ast.rule_elem inout; + rebuilder_top_level : Ast.top_level inout; + rebuilder_expression_dots : Ast.expression Ast.dots inout; + rebuilder_statement_dots : Ast.statement Ast.dots inout; + rebuilder_declaration_dots : Ast.declaration Ast.dots inout; + rebuilder_define_param_dots : Ast.define_param Ast.dots inout; + rebuilder_define_param : Ast.define_param inout; + rebuilder_define_parameters : Ast.define_parameters inout; + rebuilder_anything : Ast.anything inout} + +type 'mc rmcode = 'mc Ast.mcode inout +type 'cd rcode = rebuilder -> ('cd inout) -> 'cd inout + + +let rebuilder + meta_mcode string_mcode const_mcode assign_mcode fix_mcode unary_mcode + binary_mcode cv_mcode sign_mcode struct_mcode storage_mcode + inc_file_mcode + expdotsfn paramdotsfn stmtdotsfn decldotsfn + identfn exprfn ftfn tyfn initfn paramfn declfn rulefn stmtfn casefn + topfn anyfn = + let get_option f = function + Some x -> Some (f x) + | None -> None in + let rec expression_dots d = + let k d = + Ast.rewrap d + (match Ast.unwrap d with + Ast.DOTS(l) -> Ast.DOTS(List.map expression l) + | Ast.CIRCLES(l) -> Ast.CIRCLES(List.map expression l) + | Ast.STARS(l) -> Ast.STARS(List.map expression l)) in + expdotsfn all_functions k d + + and parameter_dots d = + let k d = + Ast.rewrap d + (match Ast.unwrap d with + Ast.DOTS(l) -> Ast.DOTS(List.map parameterTypeDef l) + | Ast.CIRCLES(l) -> Ast.CIRCLES(List.map parameterTypeDef l) + | Ast.STARS(l) -> Ast.STARS(List.map parameterTypeDef l)) in + paramdotsfn all_functions k d + + and statement_dots d = + let k d = + Ast.rewrap d + (match Ast.unwrap d with + Ast.DOTS(l) -> Ast.DOTS(List.map statement l) + | Ast.CIRCLES(l) -> Ast.CIRCLES(List.map statement l) + | Ast.STARS(l) -> Ast.STARS(List.map statement l)) in + stmtdotsfn all_functions k d + + and declaration_dots d = + let k d = + Ast.rewrap d + (match Ast.unwrap d with + Ast.DOTS(l) -> Ast.DOTS(List.map declaration l) + | Ast.CIRCLES(l) -> Ast.CIRCLES(List.map declaration l) + | Ast.STARS(l) -> Ast.STARS(List.map declaration l)) in + decldotsfn all_functions k d + + and ident i = + let k i = + Ast.rewrap i + (match Ast.unwrap i with + Ast.Id(name) -> Ast.Id(string_mcode name) + | Ast.MetaId(name,constraints,keep,inherited) -> + Ast.MetaId(meta_mcode name,constraints,keep,inherited) + | Ast.MetaFunc(name,constraints,keep,inherited) -> + Ast.MetaFunc(meta_mcode name,constraints,keep,inherited) + | Ast.MetaLocalFunc(name,constraints,keep,inherited) -> + Ast.MetaLocalFunc(meta_mcode name,constraints,keep,inherited) + | Ast.OptIdent(id) -> Ast.OptIdent(ident id) + | Ast.UniqueIdent(id) -> Ast.UniqueIdent(ident id)) in + identfn all_functions k i + + and expression e = + let k e = + Ast.rewrap e + (match Ast.unwrap e with + Ast.Ident(id) -> Ast.Ident(ident id) + | Ast.Constant(const) -> Ast.Constant(const_mcode const) + | Ast.FunCall(fn,lp,args,rp) -> + Ast.FunCall(expression fn, string_mcode lp, expression_dots args, + string_mcode rp) + | Ast.Assignment(left,op,right,simple) -> + Ast.Assignment(expression left, assign_mcode op, expression right, + simple) + | Ast.CondExpr(exp1,why,exp2,colon,exp3) -> + Ast.CondExpr(expression exp1, string_mcode why, + get_option expression exp2, string_mcode colon, + expression exp3) + | Ast.Postfix(exp,op) -> Ast.Postfix(expression exp,fix_mcode op) + | Ast.Infix(exp,op) -> Ast.Infix(expression exp,fix_mcode op) + | Ast.Unary(exp,op) -> Ast.Unary(expression exp,unary_mcode op) + | Ast.Binary(left,op,right) -> + Ast.Binary(expression left, binary_mcode op, expression right) + | Ast.Nested(left,op,right) -> + Ast.Nested(expression left, binary_mcode op, expression right) + | Ast.Paren(lp,exp,rp) -> + Ast.Paren(string_mcode lp, expression exp, string_mcode rp) + | Ast.ArrayAccess(exp1,lb,exp2,rb) -> + Ast.ArrayAccess(expression exp1, string_mcode lb, expression exp2, + string_mcode rb) + | Ast.RecordAccess(exp,pt,field) -> + Ast.RecordAccess(expression exp, string_mcode pt, ident field) + | Ast.RecordPtAccess(exp,ar,field) -> + Ast.RecordPtAccess(expression exp, string_mcode ar, ident field) + | Ast.Cast(lp,ty,rp,exp) -> + Ast.Cast(string_mcode lp, fullType ty, string_mcode rp, + expression exp) + | Ast.SizeOfExpr(szf,exp) -> + Ast.SizeOfExpr(string_mcode szf, expression exp) + | Ast.SizeOfType(szf,lp,ty,rp) -> + Ast.SizeOfType(string_mcode szf,string_mcode lp, fullType ty, + string_mcode rp) + | Ast.TypeExp(ty) -> Ast.TypeExp(fullType ty) + | Ast.MetaErr(name,constraints,keep,inherited) -> + Ast.MetaErr(meta_mcode name,constraints,keep,inherited) + | Ast.MetaExpr(name,constraints,keep,ty,form,inherited) -> + Ast.MetaExpr(meta_mcode name,constraints,keep,ty,form,inherited) + | Ast.MetaExprList(name,lenname_inh,keep,inherited) -> + Ast.MetaExprList(meta_mcode name,lenname_inh,keep,inherited) + | Ast.EComma(cm) -> Ast.EComma(string_mcode cm) + | Ast.DisjExpr(exp_list) -> Ast.DisjExpr(List.map expression exp_list) + | Ast.NestExpr(expr_dots,whencode,multi) -> + Ast.NestExpr(expression_dots expr_dots, + get_option expression whencode,multi) + | Ast.Edots(dots,whencode) -> + Ast.Edots(string_mcode dots,get_option expression whencode) + | Ast.Ecircles(dots,whencode) -> + Ast.Ecircles(string_mcode dots,get_option expression whencode) + | Ast.Estars(dots,whencode) -> + Ast.Estars(string_mcode dots,get_option expression whencode) + | Ast.OptExp(exp) -> Ast.OptExp(expression exp) + | Ast.UniqueExp(exp) -> Ast.UniqueExp(expression exp)) in + exprfn all_functions k e + + and fullType ft = + let k ft = + Ast.rewrap ft + (match Ast.unwrap ft with + Ast.Type(cv,ty) -> Ast.Type (get_option cv_mcode cv, typeC ty) + | Ast.DisjType(types) -> Ast.DisjType(List.map fullType types) + | Ast.OptType(ty) -> Ast.OptType(fullType ty) + | Ast.UniqueType(ty) -> Ast.UniqueType(fullType ty)) in + ftfn all_functions k ft + + and typeC ty = + let k ty = + Ast.rewrap ty + (match Ast.unwrap ty with + Ast.BaseType(ty,strings) -> + Ast.BaseType (ty, List.map string_mcode strings) + | Ast.SignedT(sgn,ty) -> + Ast.SignedT(sign_mcode sgn,get_option typeC ty) + | Ast.Pointer(ty,star) -> + Ast.Pointer (fullType ty, string_mcode star) + | Ast.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + Ast.FunctionPointer(fullType ty,string_mcode lp1,string_mcode star, + string_mcode rp1,string_mcode lp2, + parameter_dots params, + string_mcode rp2) + | Ast.FunctionType(allminus,ty,lp,params,rp) -> + Ast.FunctionType(allminus,get_option fullType ty,string_mcode lp, + parameter_dots params,string_mcode rp) + | Ast.Array(ty,lb,size,rb) -> + Ast.Array(fullType ty, string_mcode lb, + get_option expression size, string_mcode rb) + | Ast.EnumName(kind,name) -> + Ast.EnumName(string_mcode kind, ident name) + | Ast.StructUnionName(kind,name) -> + Ast.StructUnionName (struct_mcode kind, get_option ident name) + | Ast.StructUnionDef(ty,lb,decls,rb) -> + Ast.StructUnionDef (fullType ty, + string_mcode lb, declaration_dots decls, + string_mcode rb) + | Ast.TypeName(name) -> Ast.TypeName(string_mcode name) + | Ast.MetaType(name,keep,inherited) -> + Ast.MetaType(meta_mcode name,keep,inherited)) in + tyfn all_functions k ty + + and declaration d = + let k d = + Ast.rewrap d + (match Ast.unwrap d with + Ast.Init(stg,ty,id,eq,ini,sem) -> + Ast.Init(get_option storage_mcode stg, fullType ty, ident id, + string_mcode eq, initialiser ini, string_mcode sem) + | Ast.UnInit(stg,ty,id,sem) -> + Ast.UnInit(get_option storage_mcode stg, fullType ty, ident id, + string_mcode sem) + | Ast.MacroDecl(name,lp,args,rp,sem) -> + Ast.MacroDecl(ident name, string_mcode lp, expression_dots args, + string_mcode rp,string_mcode sem) + | Ast.TyDecl(ty,sem) -> Ast.TyDecl(fullType ty, string_mcode sem) + | Ast.Typedef(stg,ty,id,sem) -> + Ast.Typedef(string_mcode stg, fullType ty, typeC id, + string_mcode sem) + | Ast.DisjDecl(decls) -> Ast.DisjDecl(List.map declaration decls) + | Ast.Ddots(dots,whencode) -> + Ast.Ddots(string_mcode dots, get_option declaration whencode) + | Ast.MetaDecl(name,keep,inherited) -> + Ast.MetaDecl(meta_mcode name,keep,inherited) + | Ast.OptDecl(decl) -> Ast.OptDecl(declaration decl) + | Ast.UniqueDecl(decl) -> Ast.UniqueDecl(declaration decl)) in + declfn all_functions k d + + and initialiser i = + let k i = + Ast.rewrap i + (match Ast.unwrap i with + Ast.InitExpr(exp) -> Ast.InitExpr(expression exp) + | Ast.InitList(lb,initlist,rb,whencode) -> + Ast.InitList(string_mcode lb, List.map initialiser initlist, + string_mcode rb, List.map initialiser whencode) + | Ast.InitGccDotName(dot,name,eq,ini) -> + Ast.InitGccDotName + (string_mcode dot, ident name, string_mcode eq, initialiser ini) + | Ast.InitGccName(name,eq,ini) -> + Ast.InitGccName(ident name, string_mcode eq, initialiser ini) + | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> + Ast.InitGccIndex + (string_mcode lb, expression exp, string_mcode rb, + string_mcode eq, initialiser ini) + | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + Ast.InitGccRange + (string_mcode lb, expression exp1, string_mcode dots, + expression exp2, string_mcode rb, string_mcode eq, + initialiser ini) + | Ast.IComma(cm) -> Ast.IComma(string_mcode cm) + | Ast.OptIni(i) -> Ast.OptIni(initialiser i) + | Ast.UniqueIni(i) -> Ast.UniqueIni(initialiser i)) in + initfn all_functions k i + + and parameterTypeDef p = + let k p = + Ast.rewrap p + (match Ast.unwrap p with + Ast.VoidParam(ty) -> Ast.VoidParam(fullType ty) + | Ast.Param(ty,id) -> Ast.Param(fullType ty, get_option ident id) + | Ast.MetaParam(name,keep,inherited) -> + Ast.MetaParam(meta_mcode name,keep,inherited) + | Ast.MetaParamList(name,lenname_inh,keep,inherited) -> + Ast.MetaParamList(meta_mcode name,lenname_inh,keep,inherited) + | Ast.PComma(cm) -> Ast.PComma(string_mcode cm) + | Ast.Pdots(dots) -> Ast.Pdots(string_mcode dots) + | Ast.Pcircles(dots) -> Ast.Pcircles(string_mcode dots) + | Ast.OptParam(param) -> Ast.OptParam(parameterTypeDef param) + | Ast.UniqueParam(param) -> Ast.UniqueParam(parameterTypeDef param)) in + paramfn all_functions k p + + and rule_elem re = + let k re = + Ast.rewrap re + (match Ast.unwrap re with + Ast.FunHeader(bef,allminus,fi,name,lp,params,rp) -> + Ast.FunHeader(bef,allminus,List.map fninfo fi,ident name, + string_mcode lp, parameter_dots params, + string_mcode rp) + | Ast.Decl(bef,allminus,decl) -> + Ast.Decl(bef,allminus,declaration decl) + | Ast.SeqStart(brace) -> Ast.SeqStart(string_mcode brace) + | Ast.SeqEnd(brace) -> Ast.SeqEnd(string_mcode brace) + | Ast.ExprStatement(exp,sem) -> + Ast.ExprStatement (expression exp, string_mcode sem) + | Ast.IfHeader(iff,lp,exp,rp) -> + Ast.IfHeader(string_mcode iff, string_mcode lp, expression exp, + string_mcode rp) + | Ast.Else(els) -> Ast.Else(string_mcode els) + | Ast.WhileHeader(whl,lp,exp,rp) -> + Ast.WhileHeader(string_mcode whl, string_mcode lp, expression exp, + string_mcode rp) + | Ast.DoHeader(d) -> Ast.DoHeader(string_mcode d) + | Ast.WhileTail(whl,lp,exp,rp,sem) -> + Ast.WhileTail(string_mcode whl, string_mcode lp, expression exp, + string_mcode rp, string_mcode sem) + | Ast.ForHeader(fr,lp,e1,sem1,e2,sem2,e3,rp) -> + Ast.ForHeader(string_mcode fr, string_mcode lp, + get_option expression e1, string_mcode sem1, + get_option expression e2, string_mcode sem2, + get_option expression e3, string_mcode rp) + | Ast.IteratorHeader(whl,lp,args,rp) -> + Ast.IteratorHeader(ident whl, string_mcode lp, + expression_dots args, string_mcode rp) + | Ast.SwitchHeader(switch,lp,exp,rp) -> + Ast.SwitchHeader(string_mcode switch, string_mcode lp, + expression exp, string_mcode rp) + | Ast.Break(br,sem) -> + Ast.Break(string_mcode br, string_mcode sem) + | Ast.Continue(cont,sem) -> + Ast.Continue(string_mcode cont, string_mcode sem) + | Ast.Label(l,dd) -> Ast.Label(ident l, string_mcode dd) + | Ast.Goto(goto,l,sem) -> + Ast.Goto(string_mcode goto,ident l,string_mcode sem) + | Ast.Return(ret,sem) -> + Ast.Return(string_mcode ret, string_mcode sem) + | Ast.ReturnExpr(ret,exp,sem) -> + Ast.ReturnExpr(string_mcode ret, expression exp, string_mcode sem) + | Ast.MetaStmt(name,keep,seqible,inherited) -> + Ast.MetaStmt(meta_mcode name,keep,seqible,inherited) + | Ast.MetaStmtList(name,keep,inherited) -> + Ast.MetaStmtList(meta_mcode name,keep,inherited) + | Ast.MetaRuleElem(name,keep,inherited) -> + Ast.MetaRuleElem(meta_mcode name,keep,inherited) + | Ast.Exp(exp) -> Ast.Exp(expression exp) + | Ast.TopExp(exp) -> Ast.TopExp(expression exp) + | Ast.Ty(ty) -> Ast.Ty(fullType ty) + | Ast.TopInit(init) -> Ast.TopInit(initialiser init) + | Ast.Include(inc,name) -> + Ast.Include(string_mcode inc,inc_file_mcode name) + | Ast.DefineHeader(def,id,params) -> + Ast.DefineHeader(string_mcode def,ident id, + define_parameters params) + | Ast.Default(def,colon) -> + Ast.Default(string_mcode def,string_mcode colon) + | Ast.Case(case,exp,colon) -> + Ast.Case(string_mcode case,expression exp,string_mcode colon) + | Ast.DisjRuleElem(res) -> Ast.DisjRuleElem(List.map rule_elem res)) in + rulefn all_functions k re + + (* not parameterizable for now... *) + and define_parameters p = + let k p = + Ast.rewrap p + (match Ast.unwrap p with + Ast.NoParams -> Ast.NoParams + | Ast.DParams(lp,params,rp) -> + Ast.DParams(string_mcode lp,define_param_dots params, + string_mcode rp)) in + k p + + and define_param_dots d = + let k d = + Ast.rewrap d + (match Ast.unwrap d with + Ast.DOTS(l) -> Ast.DOTS(List.map define_param l) + | Ast.CIRCLES(l) -> Ast.CIRCLES(List.map define_param l) + | Ast.STARS(l) -> Ast.STARS(List.map define_param l)) in + k d + + and define_param p = + let k p = + Ast.rewrap p + (match Ast.unwrap p with + Ast.DParam(id) -> Ast.DParam(ident id) + | Ast.DPComma(comma) -> Ast.DPComma(string_mcode comma) + | Ast.DPdots(d) -> Ast.DPdots(string_mcode d) + | Ast.DPcircles(c) -> Ast.DPcircles(string_mcode c) + | Ast.OptDParam(dp) -> Ast.OptDParam(define_param dp) + | Ast.UniqueDParam(dp) -> Ast.UniqueDParam(define_param dp)) in + k p + + and process_bef_aft s = + Ast.set_dots_bef_aft + (match Ast.get_dots_bef_aft s with + Ast.NoDots -> Ast.NoDots + | Ast.DroppingBetweenDots(stm,ind) -> + Ast.DroppingBetweenDots(statement stm,ind) + | Ast.AddingBetweenDots(stm,ind) -> + Ast.AddingBetweenDots(statement stm,ind)) + s + + and statement s = + let k s = + Ast.rewrap s + (match Ast.unwrap s with + Ast.Seq(lbrace,decls,body,rbrace) -> + Ast.Seq(rule_elem lbrace, statement_dots decls, + statement_dots body, rule_elem rbrace) + | Ast.IfThen(header,branch,aft) -> + Ast.IfThen(rule_elem header, statement branch,aft) + | Ast.IfThenElse(header,branch1,els,branch2,aft) -> + Ast.IfThenElse(rule_elem header, statement branch1, rule_elem els, + statement branch2, aft) + | Ast.While(header,body,aft) -> + Ast.While(rule_elem header, statement body, aft) + | Ast.Do(header,body,tail) -> + Ast.Do(rule_elem header, statement body, rule_elem tail) + | Ast.For(header,body,aft) -> + Ast.For(rule_elem header, statement body, aft) + | Ast.Iterator(header,body,aft) -> + Ast.Iterator(rule_elem header, statement body, aft) + | Ast.Switch(header,lb,cases,rb) -> + Ast.Switch(rule_elem header,rule_elem lb, + List.map case_line cases,rule_elem rb) + | Ast.Atomic(re) -> Ast.Atomic(rule_elem re) + | Ast.Disj(stmt_dots_list) -> + Ast.Disj (List.map statement_dots stmt_dots_list) + | Ast.Nest(stmt_dots,whn,multi,bef,aft) -> + Ast.Nest(statement_dots stmt_dots, + List.map (whencode statement_dots statement) whn, + multi,bef,aft) + | Ast.FunDecl(header,lbrace,decls,body,rbrace) -> + Ast.FunDecl(rule_elem header,rule_elem lbrace, + statement_dots decls, + statement_dots body, rule_elem rbrace) + | Ast.Define(header,body) -> + Ast.Define(rule_elem header,statement_dots body) + | Ast.Dots(d,whn,bef,aft) -> + Ast.Dots(string_mcode d, + List.map (whencode statement_dots statement) whn,bef,aft) + | Ast.Circles(d,whn,bef,aft) -> + Ast.Circles(string_mcode d, + List.map (whencode statement_dots statement) whn, + bef,aft) + | Ast.Stars(d,whn,bef,aft) -> + Ast.Stars(string_mcode d, + List.map (whencode statement_dots statement) whn,bef,aft) + | Ast.OptStm(stmt) -> Ast.OptStm(statement stmt) + | Ast.UniqueStm(stmt) -> Ast.UniqueStm(statement stmt)) in + let s = stmtfn all_functions k s in + (* better to do this after, in case there is an equality test on the whole + statement, eg in free_vars. equality test would require that this + subterm not already be changed *) + process_bef_aft s + + and fninfo = function + Ast.FStorage(stg) -> Ast.FStorage(storage_mcode stg) + | Ast.FType(ty) -> Ast.FType(fullType ty) + | Ast.FInline(inline) -> Ast.FInline(string_mcode inline) + | Ast.FAttr(attr) -> Ast.FAttr(string_mcode attr) + + and whencode notfn alwaysfn = function + Ast.WhenNot a -> Ast.WhenNot (notfn a) + | Ast.WhenAlways a -> Ast.WhenAlways (alwaysfn a) + | Ast.WhenModifier(x) -> Ast.WhenModifier(x) + | Ast.WhenNotTrue(e) -> Ast.WhenNotTrue(rule_elem e) + | Ast.WhenNotFalse(e) -> Ast.WhenNotFalse(rule_elem e) + + and case_line c = + let k c = + Ast.rewrap c + (match Ast.unwrap c with + Ast.CaseLine(header,code) -> + Ast.CaseLine(rule_elem header,statement_dots code) + | Ast.OptCase(case) -> Ast.OptCase(case_line case)) in + casefn all_functions k c + + and top_level t = + let k t = + Ast.rewrap t + (match Ast.unwrap t with + Ast.FILEINFO(old_file,new_file) -> + Ast.FILEINFO (string_mcode old_file, string_mcode new_file) + | Ast.DECL(stmt) -> Ast.DECL(statement stmt) + | Ast.CODE(stmt_dots) -> Ast.CODE(statement_dots stmt_dots) + | Ast.ERRORWORDS(exps) -> Ast.ERRORWORDS (List.map expression exps)) in + topfn all_functions k t + + and anything a = + let k = function + (*in many cases below, the thing is not even mcode, so we do nothing*) + Ast.FullTypeTag(ft) -> Ast.FullTypeTag(fullType ft) + | Ast.BaseTypeTag(bt) as x -> x + | Ast.StructUnionTag(su) as x -> x + | Ast.SignTag(sgn) as x -> x + | Ast.IdentTag(id) -> Ast.IdentTag(ident id) + | Ast.ExpressionTag(exp) -> Ast.ExpressionTag(expression exp) + | Ast.ConstantTag(cst) as x -> x + | Ast.UnaryOpTag(unop) as x -> x + | Ast.AssignOpTag(asgnop) as x -> x + | Ast.FixOpTag(fixop) as x -> x + | Ast.BinaryOpTag(binop) as x -> x + | Ast.ArithOpTag(arithop) as x -> x + | Ast.LogicalOpTag(logop) as x -> x + | Ast.InitTag(decl) -> Ast.InitTag(initialiser decl) + | Ast.DeclarationTag(decl) -> Ast.DeclarationTag(declaration decl) + | Ast.StorageTag(stg) as x -> x + | Ast.IncFileTag(stg) as x -> x + | Ast.Rule_elemTag(rule) -> Ast.Rule_elemTag(rule_elem rule) + | Ast.StatementTag(rule) -> Ast.StatementTag(statement rule) + | Ast.CaseLineTag(case) -> Ast.CaseLineTag(case_line case) + | Ast.ConstVolTag(cv) as x -> x + | Ast.Token(tok,info) as x -> x + | Ast.Code(cd) -> Ast.Code(top_level cd) + | Ast.ExprDotsTag(ed) -> Ast.ExprDotsTag(expression_dots ed) + | Ast.ParamDotsTag(pd) -> Ast.ParamDotsTag(parameter_dots pd) + | Ast.StmtDotsTag(sd) -> Ast.StmtDotsTag(statement_dots sd) + | Ast.DeclDotsTag(sd) -> Ast.DeclDotsTag(declaration_dots sd) + | Ast.TypeCTag(ty) -> Ast.TypeCTag(typeC ty) + | Ast.ParamTag(param) -> Ast.ParamTag(parameterTypeDef param) + | Ast.SgrepStartTag(tok) as x -> x + | Ast.SgrepEndTag(tok) as x -> x in + anyfn all_functions k a + + and all_functions = + {rebuilder_ident = ident; + rebuilder_expression = expression; + rebuilder_fullType= fullType; + rebuilder_typeC = typeC; + rebuilder_declaration = declaration; + rebuilder_initialiser = initialiser; + rebuilder_parameter = parameterTypeDef; + rebuilder_parameter_list = parameter_dots; + rebuilder_rule_elem = rule_elem; + rebuilder_statement = statement; + rebuilder_case_line = case_line; + rebuilder_top_level = top_level; + rebuilder_expression_dots = expression_dots; + rebuilder_statement_dots = statement_dots; + rebuilder_declaration_dots = declaration_dots; + rebuilder_define_param_dots = define_param_dots; + rebuilder_define_param = define_param; + rebuilder_define_parameters = define_parameters; + rebuilder_anything = anything} in + all_functions + diff --git a/parsing_cocci/.#visitor_ast0.ml.1.87 b/parsing_cocci/.#visitor_ast0.ml.1.87 new file mode 100644 index 0000000..8a5bd6e --- /dev/null +++ b/parsing_cocci/.#visitor_ast0.ml.1.87 @@ -0,0 +1,1041 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +module Ast = Ast_cocci +module Ast0 = Ast0_cocci + +(* --------------------------------------------------------------------- *) +(* Generic traversal: combiner *) +(* parameters: + combining function + treatment of: mcode, identifiers, expressions, typeCs, types, + declarations, statements, toplevels + default value for options *) + +type 'a combiner = + {combiner_ident : Ast0.ident -> 'a; + combiner_expression : Ast0.expression -> 'a; + combiner_typeC : Ast0.typeC -> 'a; + combiner_declaration : Ast0.declaration -> 'a; + combiner_initialiser : Ast0.initialiser -> 'a; + combiner_initialiser_list : Ast0.initialiser_list -> 'a; + combiner_parameter : Ast0.parameterTypeDef -> 'a; + combiner_parameter_list : Ast0.parameter_list -> 'a; + combiner_statement : Ast0.statement -> 'a; + combiner_case_line : Ast0.case_line -> 'a; + combiner_top_level : Ast0.top_level -> 'a; + combiner_expression_dots : + Ast0.expression Ast0.dots -> 'a; + combiner_statement_dots : + Ast0.statement Ast0.dots -> 'a; + combiner_declaration_dots : + Ast0.declaration Ast0.dots -> 'a; + combiner_case_line_dots : + Ast0.case_line Ast0.dots -> 'a; + combiner_anything : Ast0.anything -> 'a} + + +type ('mc,'a) cmcode = 'mc Ast0.mcode -> 'a +type ('cd,'a) ccode = 'a combiner -> ('cd -> 'a) -> 'cd -> 'a + +let combiner bind option_default + meta_mcode string_mcode const_mcode assign_mcode fix_mcode unary_mcode + binary_mcode cv_mcode sign_mcode struct_mcode storage_mcode + inc_mcode + dotsexprfn dotsinitfn dotsparamfn dotsstmtfn dotsdeclfn dotscasefn + identfn exprfn + tyfn initfn paramfn declfn stmtfn casefn topfn = + let multibind l = + let rec loop = function + [] -> option_default + | [x] -> x + | x::xs -> bind x (loop xs) in + loop l in + let get_option f = function + Some x -> f x + | None -> option_default in + let rec expression_dots d = + let k d = + match Ast0.unwrap d with + Ast0.DOTS(l) | Ast0.CIRCLES(l) | Ast0.STARS(l) -> + multibind (List.map expression l) in + dotsexprfn all_functions k d + and initialiser_dots d = + let k d = + match Ast0.unwrap d with + Ast0.DOTS(l) | Ast0.CIRCLES(l) | Ast0.STARS(l) -> + multibind (List.map initialiser l) in + dotsinitfn all_functions k d + and parameter_dots d = + let k d = + match Ast0.unwrap d with + Ast0.DOTS(l) | Ast0.CIRCLES(l) | Ast0.STARS(l) -> + multibind (List.map parameterTypeDef l) in + dotsparamfn all_functions k d + and statement_dots d = + let k d = + match Ast0.unwrap d with + Ast0.DOTS(l) | Ast0.CIRCLES(l) | Ast0.STARS(l) -> + multibind (List.map statement l) in + dotsstmtfn all_functions k d + and declaration_dots d = + let k d = + match Ast0.unwrap d with + Ast0.DOTS(l) | Ast0.CIRCLES(l) | Ast0.STARS(l) -> + multibind (List.map declaration l) in + dotsdeclfn all_functions k d + and case_line_dots d = + let k d = + match Ast0.unwrap d with + Ast0.DOTS(l) | Ast0.CIRCLES(l) | Ast0.STARS(l) -> + multibind (List.map case_line l) in + dotscasefn all_functions k d + and ident i = + let k i = + match Ast0.unwrap i with + Ast0.Id(name) -> string_mcode name + | Ast0.MetaId(name,_,_) -> meta_mcode name + | Ast0.MetaFunc(name,_,_) -> meta_mcode name + | Ast0.MetaLocalFunc(name,_,_) -> meta_mcode name + | Ast0.OptIdent(id) -> ident id + | Ast0.UniqueIdent(id) -> ident id in + identfn all_functions k i + and expression e = + let k e = + match Ast0.unwrap e with + Ast0.Ident(id) -> ident id + | Ast0.Constant(const) -> const_mcode const + | Ast0.FunCall(fn,lp,args,rp) -> + multibind + [expression fn; string_mcode lp; expression_dots args; + string_mcode rp] + | Ast0.Assignment(left,op,right,_) -> + multibind [expression left; assign_mcode op; expression right] + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> + multibind + [expression exp1; string_mcode why; get_option expression exp2; + string_mcode colon; expression exp3] + | Ast0.Postfix(exp,op) -> bind (expression exp) (fix_mcode op) + | Ast0.Infix(exp,op) -> bind (fix_mcode op) (expression exp) + | Ast0.Unary(exp,op) -> bind (unary_mcode op) (expression exp) + | Ast0.Binary(left,op,right) -> + multibind [expression left; binary_mcode op; expression right] + | Ast0.Nested(left,op,right) -> + multibind [expression left; binary_mcode op; expression right] + | Ast0.Paren(lp,exp,rp) -> + multibind [string_mcode lp; expression exp; string_mcode rp] + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> + multibind + [expression exp1; string_mcode lb; expression exp2; + string_mcode rb] + | Ast0.RecordAccess(exp,pt,field) -> + multibind [expression exp; string_mcode pt; ident field] + | Ast0.RecordPtAccess(exp,ar,field) -> + multibind [expression exp; string_mcode ar; ident field] + | Ast0.Cast(lp,ty,rp,exp) -> + multibind + [string_mcode lp; typeC ty; string_mcode rp; expression exp] + | Ast0.SizeOfExpr(szf,exp) -> + multibind [string_mcode szf; expression exp] + | Ast0.SizeOfType(szf,lp,ty,rp) -> + multibind + [string_mcode szf; string_mcode lp; typeC ty; string_mcode rp] + | Ast0.TypeExp(ty) -> typeC ty + | Ast0.MetaErr(name,_,_) + | Ast0.MetaExpr(name,_,_,_,_) + | Ast0.MetaExprList(name,_,_) -> meta_mcode name + | Ast0.EComma(cm) -> string_mcode cm + | Ast0.DisjExpr(starter,expr_list,mids,ender) -> + (match expr_list with + [] -> failwith "bad disjunction" + | x::xs -> + bind (string_mcode starter) + (bind (expression x) + (bind + (multibind + (List.map2 + (function mid -> + function x -> + bind (string_mcode mid) (expression x)) + mids xs)) + (string_mcode ender)))) + | Ast0.NestExpr(starter,expr_dots,ender,whencode,multi) -> + bind (string_mcode starter) + (bind (expression_dots expr_dots) + (bind (string_mcode ender) (get_option expression whencode))) + | Ast0.Edots(dots,whencode) | Ast0.Ecircles(dots,whencode) + | Ast0.Estars(dots,whencode) -> + bind (string_mcode dots) (get_option expression whencode) + | Ast0.OptExp(exp) -> expression exp + | Ast0.UniqueExp(exp) -> expression exp in + exprfn all_functions k e + and function_pointer (ty,lp1,star,rp1,lp2,params,rp2) extra = + (* have to put the treatment of the identifier into the right position *) + multibind + ([typeC ty; string_mcode lp1; string_mcode star] @ extra @ + [string_mcode rp1; + string_mcode lp2; parameter_dots params; string_mcode rp2]) + and function_type (ty,lp1,params,rp1) extra = + (* have to put the treatment of the identifier into the right position *) + multibind ([get_option typeC ty] @ extra @ + [string_mcode lp1; parameter_dots params; string_mcode rp1]) + and array_type (ty,lb,size,rb) extra = + multibind + ([typeC ty] @ extra @ + [string_mcode lb; get_option expression size; string_mcode rb]) + and typeC t = + let k t = + match Ast0.unwrap t with + Ast0.ConstVol(cv,ty) -> bind (cv_mcode cv) (typeC ty) + | Ast0.BaseType(ty,strings) -> multibind (List.map string_mcode strings) + | Ast0.Signed(sign,ty) -> bind (sign_mcode sign) (get_option typeC ty) + | Ast0.Pointer(ty,star) -> bind (typeC ty) (string_mcode star) + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + function_pointer (ty,lp1,star,rp1,lp2,params,rp2) [] + | Ast0.FunctionType(ty,lp1,params,rp1) -> + function_type (ty,lp1,params,rp1) [] + | Ast0.Array(ty,lb,size,rb) -> + array_type (ty,lb,size,rb) [] + | Ast0.EnumName(kind,name) -> bind (string_mcode kind) (ident name) + | Ast0.StructUnionName(kind,name) -> + bind (struct_mcode kind) (get_option ident name) + | Ast0.StructUnionDef(ty,lb,decls,rb) -> + multibind + [typeC ty;string_mcode lb;declaration_dots decls;string_mcode rb] + | Ast0.TypeName(name) -> string_mcode name + | Ast0.MetaType(name,_) -> meta_mcode name + | Ast0.DisjType(starter,types,mids,ender) -> + (match types with + [] -> failwith "bad disjunction" + | x::xs -> + bind (string_mcode starter) + (bind (typeC x) + (bind + (multibind + (List.map2 + (function mid -> + function x -> + bind (string_mcode mid) (typeC x)) + mids xs)) + (string_mcode ender)))) + | Ast0.OptType(ty) -> typeC ty + | Ast0.UniqueType(ty) -> typeC ty in + tyfn all_functions k t + and named_type ty id = + match Ast0.unwrap ty with + Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + function_pointer (ty,lp1,star,rp1,lp2,params,rp2) [ident id] + | Ast0.FunctionType(ty,lp1,params,rp1) -> + function_type (ty,lp1,params,rp1) [ident id] + | Ast0.Array(ty,lb,size,rb) -> + array_type (ty,lb,size,rb) [ident id] + | _ -> bind (typeC ty) (ident id) + and declaration d = + let k d = + match Ast0.unwrap d with + Ast0.Init(stg,ty,id,eq,ini,sem) -> + bind (get_option storage_mcode stg) + (bind (named_type ty id) + (multibind + [string_mcode eq; initialiser ini; string_mcode sem])) + | Ast0.UnInit(stg,ty,id,sem) -> + bind (get_option storage_mcode stg) + (bind (named_type ty id) (string_mcode sem)) + | Ast0.MacroDecl(name,lp,args,rp,sem) -> + multibind + [ident name; string_mcode lp; expression_dots args; + string_mcode rp; string_mcode sem] + | Ast0.TyDecl(ty,sem) -> bind (typeC ty) (string_mcode sem) + | Ast0.Typedef(stg,ty,id,sem) -> + bind (string_mcode stg) + (bind (typeC ty) (bind (typeC id) (string_mcode sem))) + | Ast0.DisjDecl(starter,decls,mids,ender) -> + (match decls with + [] -> failwith "bad disjunction" + | x::xs -> + bind (string_mcode starter) + (bind (declaration x) + (bind + (multibind + (List.map2 + (function mid -> + function x -> + bind (string_mcode mid) (declaration x)) + mids xs)) + (string_mcode ender)))) + | Ast0.Ddots(dots,whencode) -> + bind (string_mcode dots) (get_option declaration whencode) + | Ast0.OptDecl(decl) -> declaration decl + | Ast0.UniqueDecl(decl) -> declaration decl in + declfn all_functions k d + and initialiser i = + let k i = + match Ast0.unwrap i with + Ast0.InitExpr(exp) -> expression exp + | Ast0.InitList(lb,initlist,rb) -> + multibind + [string_mcode lb; initialiser_dots initlist; string_mcode rb] + | Ast0.InitGccDotName(dot,name,eq,ini) -> + multibind + [string_mcode dot; ident name; string_mcode eq; initialiser ini] + | Ast0.InitGccName(name,eq,ini) -> + multibind [ident name; string_mcode eq; initialiser ini] + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> + multibind + [string_mcode lb; expression exp; string_mcode rb; + string_mcode eq; initialiser ini] + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + multibind + [string_mcode lb; expression exp1; string_mcode dots; + expression exp2; string_mcode rb; string_mcode eq; + initialiser ini] + | Ast0.IComma(cm) -> string_mcode cm + | Ast0.Idots(dots,whencode) -> + bind (string_mcode dots) (get_option initialiser whencode) + | Ast0.OptIni(i) -> initialiser i + | Ast0.UniqueIni(i) -> initialiser i in + initfn all_functions k i + and parameterTypeDef p = + let k p = + match Ast0.unwrap p with + Ast0.VoidParam(ty) -> typeC ty + | Ast0.Param(ty,Some id) -> named_type ty id + | Ast0.Param(ty,None) -> typeC ty + | Ast0.MetaParam(name,_) -> meta_mcode name + | Ast0.MetaParamList(name,_,_) -> meta_mcode name + | Ast0.PComma(cm) -> string_mcode cm + | Ast0.Pdots(dots) -> string_mcode dots + | Ast0.Pcircles(dots) -> string_mcode dots + | Ast0.OptParam(param) -> parameterTypeDef param + | Ast0.UniqueParam(param) -> parameterTypeDef param in + paramfn all_functions k p + + (* discard the result, because the statement is assumed to be already + represented elsewhere in the code *) + and process_bef_aft s = + match Ast0.get_dots_bef_aft s with + Ast0.NoDots -> () + | Ast0.DroppingBetweenDots(stm) -> let _ = statement stm in () + | Ast0.AddingBetweenDots(stm) -> let _ = statement stm in () + + and statement s = + process_bef_aft s; + let k s = + match Ast0.unwrap s with + Ast0.FunDecl(_,fi,name,lp,params,rp,lbrace,body,rbrace) -> + multibind + ((List.map fninfo fi) @ + [ident name; string_mcode lp; + parameter_dots params; string_mcode rp; string_mcode lbrace; + statement_dots body; string_mcode rbrace]) + | Ast0.Decl(_,decl) -> declaration decl + | Ast0.Seq(lbrace,body,rbrace) -> + multibind + [string_mcode lbrace; statement_dots body; string_mcode rbrace] + | Ast0.ExprStatement(exp,sem) -> + bind (expression exp) (string_mcode sem) + | Ast0.IfThen(iff,lp,exp,rp,branch1,_) -> + multibind + [string_mcode iff; string_mcode lp; expression exp; + string_mcode rp; statement branch1] + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,_) -> + multibind + [string_mcode iff; string_mcode lp; expression exp; + string_mcode rp; statement branch1; string_mcode els; + statement branch2] + | Ast0.While(whl,lp,exp,rp,body,_) -> + multibind + [string_mcode whl; string_mcode lp; expression exp; + string_mcode rp; statement body] + | Ast0.Do(d,body,whl,lp,exp,rp,sem) -> + multibind + [string_mcode d; statement body; string_mcode whl; + string_mcode lp; expression exp; string_mcode rp; + string_mcode sem] + | Ast0.For(fr,lp,e1,sem1,e2,sem2,e3,rp,body,_) -> + multibind + [string_mcode fr; string_mcode lp; get_option expression e1; + string_mcode sem1; get_option expression e2; string_mcode sem2; + get_option expression e3; + string_mcode rp; statement body] + | Ast0.Iterator(nm,lp,args,rp,body,_) -> + multibind + [ident nm; string_mcode lp; expression_dots args; + string_mcode rp; statement body] + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> + multibind + [string_mcode switch; string_mcode lp; expression exp; + string_mcode rp; string_mcode lb; case_line_dots cases; + string_mcode rb] + | Ast0.Break(br,sem) -> bind (string_mcode br) (string_mcode sem) + | Ast0.Continue(cont,sem) -> bind (string_mcode cont) (string_mcode sem) + | Ast0.Label(l,dd) -> bind (ident l) (string_mcode dd) + | Ast0.Goto(goto,l,sem) -> + bind (string_mcode goto) (bind (ident l) (string_mcode sem)) + | Ast0.Return(ret,sem) -> bind (string_mcode ret) (string_mcode sem) + | Ast0.ReturnExpr(ret,exp,sem) -> + multibind [string_mcode ret; expression exp; string_mcode sem] + | Ast0.MetaStmt(name,_) -> meta_mcode name + | Ast0.MetaStmtList(name,_) -> meta_mcode name + | Ast0.Disj(starter,statement_dots_list,mids,ender) -> + (match statement_dots_list with + [] -> failwith "bad disjunction" + | x::xs -> + bind (string_mcode starter) + (bind (statement_dots x) + (bind + (multibind + (List.map2 + (function mid -> + function x -> + bind (string_mcode mid) (statement_dots x)) + mids xs)) + (string_mcode ender)))) + | Ast0.Nest(starter,stmt_dots,ender,whn,multi) -> + bind (string_mcode starter) + (bind (statement_dots stmt_dots) + (bind (string_mcode ender) + (multibind + (List.map (whencode statement_dots statement) whn)))) + | Ast0.Exp(exp) -> expression exp + | Ast0.TopExp(exp) -> expression exp + | Ast0.Ty(ty) -> typeC ty + | Ast0.TopInit(init) -> initialiser init + | Ast0.Dots(d,whn) | Ast0.Circles(d,whn) | Ast0.Stars(d,whn) -> + bind (string_mcode d) + (multibind (List.map (whencode statement_dots statement) whn)) + | Ast0.Include(inc,name) -> bind (string_mcode inc) (inc_mcode name) + | Ast0.Define(def,id,params,body) -> + multibind [string_mcode def; ident id; define_parameters params; + statement_dots body] + | Ast0.OptStm(re) -> statement re + | Ast0.UniqueStm(re) -> statement re in + stmtfn all_functions k s + + (* not parameterizable for now... *) + and define_parameters p = + let k p = + match Ast0.unwrap p with + Ast0.NoParams -> option_default + | Ast0.DParams(lp,params,rp) -> + multibind + [string_mcode lp; define_param_dots params; string_mcode rp] in + k p + + and define_param_dots d = + let k d = + match Ast0.unwrap d with + Ast0.DOTS(l) | Ast0.CIRCLES(l) | Ast0.STARS(l) -> + multibind (List.map define_param l) in + k d + + and define_param p = + let k p = + match Ast0.unwrap p with + Ast0.DParam(id) -> ident id + | Ast0.DPComma(comma) -> string_mcode comma + | Ast0.DPdots(d) -> string_mcode d + | Ast0.DPcircles(c) -> string_mcode c + | Ast0.OptDParam(dp) -> define_param dp + | Ast0.UniqueDParam(dp) -> define_param dp in + k p + + and fninfo = function + Ast0.FStorage(stg) -> storage_mcode stg + | Ast0.FType(ty) -> typeC ty + | Ast0.FInline(inline) -> string_mcode inline + | Ast0.FAttr(init) -> string_mcode init + + and whencode notfn alwaysfn = function + Ast0.WhenNot a -> notfn a + | Ast0.WhenAlways a -> alwaysfn a + | Ast0.WhenModifier(_) -> option_default + | Ast0.WhenNotTrue(e) -> expression e + | Ast0.WhenNotFalse(e) -> expression e + + and case_line c = + let k c = + match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> + multibind [string_mcode def;string_mcode colon;statement_dots code] + | Ast0.Case(case,exp,colon,code) -> + multibind [string_mcode case;expression exp;string_mcode colon; + statement_dots code] + | Ast0.OptCase(case) -> case_line case in + casefn all_functions k c + + and anything a = (* for compile_iso, not parameterisable *) + let k = function + Ast0.DotsExprTag(exprs) -> expression_dots exprs + | Ast0.DotsInitTag(inits) -> initialiser_dots inits + | Ast0.DotsParamTag(params) -> parameter_dots params + | Ast0.DotsStmtTag(stmts) -> statement_dots stmts + | Ast0.DotsDeclTag(decls) -> declaration_dots decls + | Ast0.DotsCaseTag(cases) -> case_line_dots cases + | Ast0.IdentTag(id) -> ident id + | Ast0.ExprTag(exp) -> expression exp + | Ast0.ArgExprTag(exp) -> expression exp + | Ast0.TestExprTag(exp) -> expression exp + | Ast0.TypeCTag(ty) -> typeC ty + | Ast0.ParamTag(param) -> parameterTypeDef param + | Ast0.InitTag(init) -> initialiser init + | Ast0.DeclTag(decl) -> declaration decl + | Ast0.StmtTag(stmt) -> statement stmt + | Ast0.CaseLineTag(c) -> case_line c + | Ast0.TopTag(top) -> top_level top + | Ast0.IsoWhenTag(_) -> option_default + | Ast0.IsoWhenTTag(e) -> expression e + | Ast0.IsoWhenFTag(e) -> expression e + | Ast0.MetaPosTag(var) -> failwith "not supported" in + k a + + and top_level t = + let k t = + match Ast0.unwrap t with + Ast0.FILEINFO(old_file,new_file) -> + bind (string_mcode old_file) (string_mcode new_file) + | Ast0.DECL(stmt_dots) -> statement stmt_dots + | Ast0.CODE(stmt_dots) -> statement_dots stmt_dots + | Ast0.ERRORWORDS(exps) -> multibind (List.map expression exps) + | Ast0.OTHER(_) -> failwith "unexpected code" in + topfn all_functions k t + and all_functions = + {combiner_ident = ident; + combiner_expression = expression; + combiner_typeC = typeC; + combiner_declaration = declaration; + combiner_initialiser = initialiser; + combiner_initialiser_list = initialiser_dots; + combiner_parameter = parameterTypeDef; + combiner_parameter_list = parameter_dots; + combiner_statement = statement; + combiner_case_line = case_line; + combiner_top_level = top_level; + combiner_expression_dots = expression_dots; + combiner_statement_dots = statement_dots; + combiner_declaration_dots = declaration_dots; + combiner_case_line_dots = case_line_dots; + combiner_anything = anything} in + all_functions + +(* --------------------------------------------------------------------- *) +(* Generic traversal: rebuilder *) + +type 'a inout = 'a -> 'a (* for specifying the type of rebuilder *) + +type rebuilder = + {rebuilder_ident : Ast0.ident inout; + rebuilder_expression : Ast0.expression inout; + rebuilder_typeC : Ast0.typeC inout; + rebuilder_declaration : Ast0.declaration inout; + rebuilder_initialiser : Ast0.initialiser inout; + rebuilder_initialiser_list : Ast0.initialiser_list inout; + rebuilder_parameter : Ast0.parameterTypeDef inout; + rebuilder_parameter_list : Ast0.parameter_list inout; + rebuilder_statement : Ast0.statement inout; + rebuilder_case_line : Ast0.case_line inout; + rebuilder_top_level : Ast0.top_level inout; + rebuilder_expression_dots : + Ast0.expression Ast0.dots -> + Ast0.expression Ast0.dots; + rebuilder_statement_dots : + Ast0.statement Ast0.dots -> + Ast0.statement Ast0.dots; + rebuilder_declaration_dots : + Ast0.declaration Ast0.dots -> + Ast0.declaration Ast0.dots; + rebuilder_case_line_dots : + Ast0.case_line Ast0.dots -> + Ast0.case_line Ast0.dots; + rebuilder_anything : + Ast0.anything -> Ast0.anything} + +type 'mc rmcode = 'mc Ast0.mcode inout +type 'cd rcode = rebuilder -> ('cd inout) -> 'cd inout + +let rebuilder = fun + meta_mcode string_mcode const_mcode assign_mcode fix_mcode unary_mcode + binary_mcode cv_mcode sign_mcode struct_mcode storage_mcode + inc_mcode + dotsexprfn dotsinitfn dotsparamfn dotsstmtfn dotsdeclfn dotscasefn + identfn exprfn tyfn initfn paramfn declfn stmtfn casefn topfn -> + let get_option f = function + Some x -> Some (f x) + | None -> None in + let rec expression_dots d = + let k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(l) -> Ast0.DOTS(List.map expression l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(List.map expression l) + | Ast0.STARS(l) -> Ast0.STARS(List.map expression l)) in + dotsexprfn all_functions k d + and initialiser_list i = + let k i = + Ast0.rewrap i + (match Ast0.unwrap i with + Ast0.DOTS(l) -> Ast0.DOTS(List.map initialiser l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(List.map initialiser l) + | Ast0.STARS(l) -> Ast0.STARS(List.map initialiser l)) in + dotsinitfn all_functions k i + and parameter_list d = + let k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(l) -> Ast0.DOTS(List.map parameterTypeDef l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(List.map parameterTypeDef l) + | Ast0.STARS(l) -> Ast0.STARS(List.map parameterTypeDef l)) in + dotsparamfn all_functions k d + and statement_dots d = + let k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(l) -> Ast0.DOTS(List.map statement l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(List.map statement l) + | Ast0.STARS(l) -> Ast0.STARS(List.map statement l)) in + dotsstmtfn all_functions k d + and declaration_dots d = + let k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(l) -> Ast0.DOTS(List.map declaration l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(List.map declaration l) + | Ast0.STARS(l) -> Ast0.STARS(List.map declaration l)) in + dotsdeclfn all_functions k d + and case_line_dots d = + let k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(l) -> Ast0.DOTS(List.map case_line l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(List.map case_line l) + | Ast0.STARS(l) -> Ast0.STARS(List.map case_line l)) in + dotscasefn all_functions k d + and ident i = + let k i = + Ast0.rewrap i + (match Ast0.unwrap i with + Ast0.Id(name) -> Ast0.Id(string_mcode name) + | Ast0.MetaId(name,constraints,pure) -> + Ast0.MetaId(meta_mcode name,constraints,pure) + | Ast0.MetaFunc(name,constraints,pure) -> + Ast0.MetaFunc(meta_mcode name,constraints,pure) + | Ast0.MetaLocalFunc(name,constraints,pure) -> + Ast0.MetaLocalFunc(meta_mcode name,constraints,pure) + | Ast0.OptIdent(id) -> Ast0.OptIdent(ident id) + | Ast0.UniqueIdent(id) -> Ast0.UniqueIdent(ident id)) in + identfn all_functions k i + and expression e = + let k e = + Ast0.rewrap e + (match Ast0.unwrap e with + Ast0.Ident(id) -> Ast0.Ident(ident id) + | Ast0.Constant(const) -> Ast0.Constant(const_mcode const) + | Ast0.FunCall(fn,lp,args,rp) -> + Ast0.FunCall(expression fn,string_mcode lp,expression_dots args, + string_mcode rp) + | Ast0.Assignment(left,op,right,simple) -> + Ast0.Assignment(expression left,assign_mcode op,expression right, + simple) + | Ast0.CondExpr(exp1,why,exp2,colon,exp3) -> + Ast0.CondExpr(expression exp1, string_mcode why, + get_option expression exp2, string_mcode colon, + expression exp3) + | Ast0.Postfix(exp,op) -> Ast0.Postfix(expression exp, fix_mcode op) + | Ast0.Infix(exp,op) -> Ast0.Infix(expression exp, fix_mcode op) + | Ast0.Unary(exp,op) -> Ast0.Unary(expression exp, unary_mcode op) + | Ast0.Binary(left,op,right) -> + Ast0.Binary(expression left, binary_mcode op, expression right) + | Ast0.Nested(left,op,right) -> + Ast0.Nested(expression left, binary_mcode op, expression right) + | Ast0.Paren(lp,exp,rp) -> + Ast0.Paren(string_mcode lp, expression exp, string_mcode rp) + | Ast0.ArrayAccess(exp1,lb,exp2,rb) -> + Ast0.ArrayAccess(expression exp1,string_mcode lb,expression exp2, + string_mcode rb) + | Ast0.RecordAccess(exp,pt,field) -> + Ast0.RecordAccess(expression exp, string_mcode pt, ident field) + | Ast0.RecordPtAccess(exp,ar,field) -> + Ast0.RecordPtAccess(expression exp, string_mcode ar, ident field) + | Ast0.Cast(lp,ty,rp,exp) -> + Ast0.Cast(string_mcode lp, typeC ty, string_mcode rp, + expression exp) + | Ast0.SizeOfExpr(szf,exp) -> + Ast0.SizeOfExpr(string_mcode szf, expression exp) + | Ast0.SizeOfType(szf,lp,ty,rp) -> + Ast0.SizeOfType(string_mcode szf,string_mcode lp, typeC ty, + string_mcode rp) + | Ast0.TypeExp(ty) -> Ast0.TypeExp(typeC ty) + | Ast0.MetaErr(name,constraints,pure) -> + Ast0.MetaErr(meta_mcode name,constraints,pure) + | Ast0.MetaExpr(name,constraints,ty,form,pure) -> + Ast0.MetaExpr(meta_mcode name,constraints,ty,form,pure) + | Ast0.MetaExprList(name,lenname,pure) -> + Ast0.MetaExprList(meta_mcode name,lenname,pure) + | Ast0.EComma(cm) -> Ast0.EComma(string_mcode cm) + | Ast0.DisjExpr(starter,expr_list,mids,ender) -> + Ast0.DisjExpr(string_mcode starter,List.map expression expr_list, + List.map string_mcode mids,string_mcode ender) + | Ast0.NestExpr(starter,expr_dots,ender,whencode,multi) -> + Ast0.NestExpr(string_mcode starter,expression_dots expr_dots, + string_mcode ender, get_option expression whencode, + multi) + | Ast0.Edots(dots,whencode) -> + Ast0.Edots(string_mcode dots, get_option expression whencode) + | Ast0.Ecircles(dots,whencode) -> + Ast0.Ecircles(string_mcode dots, get_option expression whencode) + | Ast0.Estars(dots,whencode) -> + Ast0.Estars(string_mcode dots, get_option expression whencode) + | Ast0.OptExp(exp) -> Ast0.OptExp(expression exp) + | Ast0.UniqueExp(exp) -> Ast0.UniqueExp(expression exp)) in + exprfn all_functions k e + and typeC t = + let k t = + Ast0.rewrap t + (match Ast0.unwrap t with + Ast0.ConstVol(cv,ty) -> Ast0.ConstVol(cv_mcode cv,typeC ty) + | Ast0.BaseType(ty,strings) -> + Ast0.BaseType(ty, List.map string_mcode strings) + | Ast0.Signed(sign,ty) -> + Ast0.Signed(sign_mcode sign,get_option typeC ty) + | Ast0.Pointer(ty,star) -> + Ast0.Pointer(typeC ty, string_mcode star) + | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) -> + Ast0.FunctionPointer(typeC ty,string_mcode lp1,string_mcode star, + string_mcode rp1,string_mcode lp2, + parameter_list params, + string_mcode rp2) + | Ast0.FunctionType(ty,lp1,params,rp1) -> + Ast0.FunctionType(get_option typeC ty, + string_mcode lp1,parameter_list params, + string_mcode rp1) + | Ast0.Array(ty,lb,size,rb) -> + Ast0.Array(typeC ty, string_mcode lb, + get_option expression size, string_mcode rb) + | Ast0.EnumName(kind,name) -> + Ast0.EnumName(string_mcode kind, ident name) + | Ast0.StructUnionName(kind,name) -> + Ast0.StructUnionName (struct_mcode kind, get_option ident name) + | Ast0.StructUnionDef(ty,lb,decls,rb) -> + Ast0.StructUnionDef (typeC ty, + string_mcode lb, declaration_dots decls, + string_mcode rb) + | Ast0.TypeName(name) -> Ast0.TypeName(string_mcode name) + | Ast0.MetaType(name,pure) -> + Ast0.MetaType(meta_mcode name,pure) + | Ast0.DisjType(starter,types,mids,ender) -> + Ast0.DisjType(string_mcode starter,List.map typeC types, + List.map string_mcode mids,string_mcode ender) + | Ast0.OptType(ty) -> Ast0.OptType(typeC ty) + | Ast0.UniqueType(ty) -> Ast0.UniqueType(typeC ty)) in + tyfn all_functions k t + and declaration d = + let k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.Init(stg,ty,id,eq,ini,sem) -> + Ast0.Init(get_option storage_mcode stg, + typeC ty, ident id, string_mcode eq, initialiser ini, + string_mcode sem) + | Ast0.UnInit(stg,ty,id,sem) -> + Ast0.UnInit(get_option storage_mcode stg, + typeC ty, ident id, string_mcode sem) + | Ast0.MacroDecl(name,lp,args,rp,sem) -> + Ast0.MacroDecl(ident name,string_mcode lp, + expression_dots args, + string_mcode rp,string_mcode sem) + | Ast0.TyDecl(ty,sem) -> Ast0.TyDecl(typeC ty, string_mcode sem) + | Ast0.Typedef(stg,ty,id,sem) -> + Ast0.Typedef(string_mcode stg, typeC ty, typeC id, + string_mcode sem) + | Ast0.DisjDecl(starter,decls,mids,ender) -> + Ast0.DisjDecl(string_mcode starter,List.map declaration decls, + List.map string_mcode mids,string_mcode ender) + | Ast0.Ddots(dots,whencode) -> + Ast0.Ddots(string_mcode dots, get_option declaration whencode) + | Ast0.OptDecl(decl) -> Ast0.OptDecl(declaration decl) + | Ast0.UniqueDecl(decl) -> Ast0.UniqueDecl(declaration decl)) in + declfn all_functions k d + and initialiser i = + let k i = + Ast0.rewrap i + (match Ast0.unwrap i with + Ast0.InitExpr(exp) -> Ast0.InitExpr(expression exp) + | Ast0.InitList(lb,initlist,rb) -> + Ast0.InitList(string_mcode lb, initialiser_list initlist, + string_mcode rb) + | Ast0.InitGccDotName(dot,name,eq,ini) -> + Ast0.InitGccDotName + (string_mcode dot, ident name, string_mcode eq, initialiser ini) + | Ast0.InitGccName(name,eq,ini) -> + Ast0.InitGccName(ident name, string_mcode eq, initialiser ini) + | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> + Ast0.InitGccIndex + (string_mcode lb, expression exp, string_mcode rb, + string_mcode eq, initialiser ini) + | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + Ast0.InitGccRange + (string_mcode lb, expression exp1, string_mcode dots, + expression exp2, string_mcode rb, string_mcode eq, + initialiser ini) + | Ast0.IComma(cm) -> Ast0.IComma(string_mcode cm) + | Ast0.Idots(d,whencode) -> + Ast0.Idots(string_mcode d, get_option initialiser whencode) + | Ast0.OptIni(i) -> Ast0.OptIni(initialiser i) + | Ast0.UniqueIni(i) -> Ast0.UniqueIni(initialiser i)) in + initfn all_functions k i + and parameterTypeDef p = + let k p = + Ast0.rewrap p + (match Ast0.unwrap p with + Ast0.VoidParam(ty) -> Ast0.VoidParam(typeC ty) + | Ast0.Param(ty,id) -> Ast0.Param(typeC ty, get_option ident id) + | Ast0.MetaParam(name,pure) -> + Ast0.MetaParam(meta_mcode name,pure) + | Ast0.MetaParamList(name,lenname,pure) -> + Ast0.MetaParamList(meta_mcode name,lenname,pure) + | Ast0.PComma(cm) -> Ast0.PComma(string_mcode cm) + | Ast0.Pdots(dots) -> Ast0.Pdots(string_mcode dots) + | Ast0.Pcircles(dots) -> Ast0.Pcircles(string_mcode dots) + | Ast0.OptParam(param) -> Ast0.OptParam(parameterTypeDef param) + | Ast0.UniqueParam(param) -> + Ast0.UniqueParam(parameterTypeDef param)) in + paramfn all_functions k p + (* not done for combiner, because the statement is assumed to be already + represented elsewhere in the code *) + and process_bef_aft s = + Ast0.set_dots_bef_aft s + (match Ast0.get_dots_bef_aft s with + Ast0.NoDots -> Ast0.NoDots + | Ast0.DroppingBetweenDots(stm) -> + Ast0.DroppingBetweenDots(statement stm) + | Ast0.AddingBetweenDots(stm) -> + Ast0.AddingBetweenDots(statement stm)) + + and statement s = + let k s = + Ast0.rewrap s + (match Ast0.unwrap s with + Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace) -> + Ast0.FunDecl(bef,List.map fninfo fi, ident name, + string_mcode lp, parameter_list params, + string_mcode rp, string_mcode lbrace, + statement_dots body, string_mcode rbrace) + | Ast0.Decl(bef,decl) -> Ast0.Decl(bef,declaration decl) + | Ast0.Seq(lbrace,body,rbrace) -> + Ast0.Seq(string_mcode lbrace, statement_dots body, + string_mcode rbrace) + | Ast0.ExprStatement(exp,sem) -> + Ast0.ExprStatement(expression exp, string_mcode sem) + | Ast0.IfThen(iff,lp,exp,rp,branch1,aft) -> + Ast0.IfThen(string_mcode iff, string_mcode lp, expression exp, + string_mcode rp, statement branch1,aft) + | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) -> + Ast0.IfThenElse(string_mcode iff,string_mcode lp,expression exp, + string_mcode rp, statement branch1, string_mcode els, + statement branch2,aft) + | Ast0.While(whl,lp,exp,rp,body,aft) -> + Ast0.While(string_mcode whl, string_mcode lp, expression exp, + string_mcode rp, statement body, aft) + | Ast0.Do(d,body,whl,lp,exp,rp,sem) -> + Ast0.Do(string_mcode d, statement body, string_mcode whl, + string_mcode lp, expression exp, string_mcode rp, + string_mcode sem) + | Ast0.For(fr,lp,e1,sem1,e2,sem2,e3,rp,body,aft) -> + Ast0.For(string_mcode fr, string_mcode lp, + get_option expression e1, string_mcode sem1, + get_option expression e2, string_mcode sem2, + get_option expression e3, + string_mcode rp, statement body, aft) + | Ast0.Iterator(nm,lp,args,rp,body,aft) -> + Ast0.Iterator(ident nm, string_mcode lp, + expression_dots args, + string_mcode rp, statement body, aft) + | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) -> + Ast0.Switch(string_mcode switch,string_mcode lp,expression exp, + string_mcode rp,string_mcode lb, + case_line_dots cases, string_mcode rb) + | Ast0.Break(br,sem) -> + Ast0.Break(string_mcode br,string_mcode sem) + | Ast0.Continue(cont,sem) -> + Ast0.Continue(string_mcode cont,string_mcode sem) + | Ast0.Label(l,dd) -> Ast0.Label(ident l,string_mcode dd) + | Ast0.Goto(goto,l,sem) -> + Ast0.Goto(string_mcode goto,ident l,string_mcode sem) + | Ast0.Return(ret,sem) -> + Ast0.Return(string_mcode ret,string_mcode sem) + | Ast0.ReturnExpr(ret,exp,sem) -> + Ast0.ReturnExpr(string_mcode ret,expression exp,string_mcode sem) + | Ast0.MetaStmt(name,pure) -> + Ast0.MetaStmt(meta_mcode name,pure) + | Ast0.MetaStmtList(name,pure) -> + Ast0.MetaStmtList(meta_mcode name,pure) + | Ast0.Disj(starter,statement_dots_list,mids,ender) -> + Ast0.Disj(string_mcode starter, + List.map statement_dots statement_dots_list, + List.map string_mcode mids, + string_mcode ender) + | Ast0.Nest(starter,stmt_dots,ender,whn,multi) -> + Ast0.Nest(string_mcode starter,statement_dots stmt_dots, + string_mcode ender, + List.map (whencode statement_dots statement) whn, + multi) + | Ast0.Exp(exp) -> Ast0.Exp(expression exp) + | Ast0.TopExp(exp) -> Ast0.TopExp(expression exp) + | Ast0.Ty(ty) -> Ast0.Ty(typeC ty) + | Ast0.TopInit(init) -> Ast0.TopInit(initialiser init) + | Ast0.Dots(d,whn) -> + Ast0.Dots(string_mcode d, + List.map (whencode statement_dots statement) whn) + | Ast0.Circles(d,whn) -> + Ast0.Circles(string_mcode d, + List.map (whencode statement_dots statement) whn) + | Ast0.Stars(d,whn) -> + Ast0.Stars(string_mcode d, + List.map (whencode statement_dots statement) whn) + | Ast0.Include(inc,name) -> + Ast0.Include(string_mcode inc,inc_mcode name) + | Ast0.Define(def,id,params,body) -> + Ast0.Define(string_mcode def,ident id, + define_parameters params, + statement_dots body) + | Ast0.OptStm(re) -> Ast0.OptStm(statement re) + | Ast0.UniqueStm(re) -> Ast0.UniqueStm(statement re)) in + let s = stmtfn all_functions k s in + process_bef_aft s + + (* not parameterizable for now... *) + and define_parameters p = + let k p = + Ast0.rewrap p + (match Ast0.unwrap p with + Ast0.NoParams -> Ast0.NoParams + | Ast0.DParams(lp,params,rp) -> + Ast0.DParams(string_mcode lp,define_param_dots params, + string_mcode rp))in + k p + + and define_param_dots d = + let k d = + Ast0.rewrap d + (match Ast0.unwrap d with + Ast0.DOTS(l) -> Ast0.DOTS(List.map define_param l) + | Ast0.CIRCLES(l) -> Ast0.CIRCLES(List.map define_param l) + | Ast0.STARS(l) -> Ast0.STARS(List.map define_param l)) in + k d + + and define_param p = + let k p = + Ast0.rewrap p + (match Ast0.unwrap p with + Ast0.DParam(id) -> Ast0.DParam(ident id) + | Ast0.DPComma(comma) -> Ast0.DPComma(string_mcode comma) + | Ast0.DPdots(d) -> Ast0.DPdots(string_mcode d) + | Ast0.DPcircles(c) -> Ast0.DPcircles(string_mcode c) + | Ast0.OptDParam(dp) -> Ast0.OptDParam(define_param dp) + | Ast0.UniqueDParam(dp) -> Ast0.UniqueDParam(define_param dp)) in + k p + + and fninfo = function + Ast0.FStorage(stg) -> Ast0.FStorage(storage_mcode stg) + | Ast0.FType(ty) -> Ast0.FType(typeC ty) + | Ast0.FInline(inline) -> Ast0.FInline(string_mcode inline) + | Ast0.FAttr(init) -> Ast0.FAttr(string_mcode init) + + and whencode notfn alwaysfn = function + Ast0.WhenNot a -> Ast0.WhenNot (notfn a) + | Ast0.WhenAlways a -> Ast0.WhenAlways (alwaysfn a) + | Ast0.WhenModifier(x) -> Ast0.WhenModifier(x) + | Ast0.WhenNotTrue(e) -> Ast0.WhenNotTrue(expression e) + | Ast0.WhenNotFalse(e) -> Ast0.WhenNotFalse(expression e) + + and case_line c = + let k c = + Ast0.rewrap c + (match Ast0.unwrap c with + Ast0.Default(def,colon,code) -> + Ast0.Default(string_mcode def,string_mcode colon, + statement_dots code) + | Ast0.Case(case,exp,colon,code) -> + Ast0.Case(string_mcode case,expression exp,string_mcode colon, + statement_dots code) + | Ast0.OptCase(case) -> Ast0.OptCase(case_line case)) in + casefn all_functions k c + + and top_level t = + let k t = + Ast0.rewrap t + (match Ast0.unwrap t with + Ast0.FILEINFO(old_file,new_file) -> + Ast0.FILEINFO(string_mcode old_file, string_mcode new_file) + | Ast0.DECL(statement_dots) -> + Ast0.DECL(statement statement_dots) + | Ast0.CODE(stmt_dots) -> Ast0.CODE(statement_dots stmt_dots) + | Ast0.ERRORWORDS(exps) -> Ast0.ERRORWORDS(List.map expression exps) + | Ast0.OTHER(_) -> failwith "unexpected code") in + topfn all_functions k t + + and anything a = (* for compile_iso, not parameterisable *) + let k = function + Ast0.DotsExprTag(exprs) -> Ast0.DotsExprTag(expression_dots exprs) + | Ast0.DotsInitTag(inits) -> Ast0.DotsInitTag(initialiser_list inits) + | Ast0.DotsParamTag(params) -> Ast0.DotsParamTag(parameter_list params) + | Ast0.DotsStmtTag(stmts) -> Ast0.DotsStmtTag(statement_dots stmts) + | Ast0.DotsDeclTag(decls) -> Ast0.DotsDeclTag(declaration_dots decls) + | Ast0.DotsCaseTag(cases) -> Ast0.DotsCaseTag(case_line_dots cases) + | Ast0.IdentTag(id) -> Ast0.IdentTag(ident id) + | Ast0.ExprTag(exp) -> Ast0.ExprTag(expression exp) + | Ast0.ArgExprTag(exp) -> Ast0.ArgExprTag(expression exp) + | Ast0.TestExprTag(exp) -> Ast0.TestExprTag(expression exp) + | Ast0.TypeCTag(ty) -> Ast0.TypeCTag(typeC ty) + | Ast0.ParamTag(param) -> Ast0.ParamTag(parameterTypeDef param) + | Ast0.InitTag(init) -> Ast0.InitTag(initialiser init) + | Ast0.DeclTag(decl) -> Ast0.DeclTag(declaration decl) + | Ast0.StmtTag(stmt) -> Ast0.StmtTag(statement stmt) + | Ast0.CaseLineTag(c) -> Ast0.CaseLineTag(case_line c) + | Ast0.TopTag(top) -> Ast0.TopTag(top_level top) + | Ast0.IsoWhenTag(x) -> Ast0.IsoWhenTag(x) + | Ast0.IsoWhenTTag(e) -> Ast0.IsoWhenTTag(expression e) + | Ast0.IsoWhenFTag(e) -> Ast0.IsoWhenFTag(expression e) + | Ast0.MetaPosTag(var) -> failwith "not supported" in + k a + + (* not done for combiner, because the statement is assumed to be already + represented elsewhere in the code *) + + and all_functions = + {rebuilder_ident = ident; + rebuilder_expression = expression; + rebuilder_typeC = typeC; + rebuilder_declaration = declaration; + rebuilder_initialiser = initialiser; + rebuilder_initialiser_list = initialiser_list; + rebuilder_parameter = parameterTypeDef; + rebuilder_parameter_list = parameter_list; + rebuilder_statement = statement; + rebuilder_case_line = case_line; + rebuilder_top_level = top_level; + rebuilder_expression_dots = expression_dots; + rebuilder_statement_dots = statement_dots; + rebuilder_declaration_dots = declaration_dots; + rebuilder_case_line_dots = case_line_dots; + rebuilder_anything = anything} in + all_functions diff --git a/parsing_cocci/arity.ml b/parsing_cocci/arity.ml index 3fb1665..56213c8 100644 --- a/parsing_cocci/arity.ml +++ b/parsing_cocci/arity.ml @@ -535,7 +535,11 @@ and make_init = and initialiser tgt i = let init_same = all_same true tgt in match Ast0.unwrap i with - Ast0.InitExpr(exp) -> + Ast0.MetaInit(name,pure) -> + let arity = init_same (mcode2line name) [mcode2arity name] in + let name = mcode name in + make_init i tgt arity (Ast0.MetaInit(name,pure)) + | Ast0.InitExpr(exp) -> Ast0.rewrap i (Ast0.InitExpr(expression tgt exp)) | Ast0.InitList(lb,initlist,rb) -> let arity = init_same (mcode2line lb) [mcode2arity lb; mcode2arity rb] in @@ -543,43 +547,18 @@ and initialiser tgt i = let initlist = dots (initialiser arity) initlist in let rb = mcode rb in make_init i tgt arity (Ast0.InitList(lb,initlist,rb)) - | Ast0.InitGccDotName(dot,name,eq,ini) -> - let arity = - init_same (mcode2line dot) [mcode2arity dot; mcode2arity eq] in - let dot = mcode dot in - let name = ident true arity name in + | Ast0.InitGccExt(designators,eq,ini) -> + let arity = init_same (mcode2line eq) [mcode2arity eq] in + let designators = List.map (designator arity) designators in let eq = mcode eq in let ini = initialiser arity ini in - make_init i tgt arity (Ast0.InitGccDotName(dot,name,eq,ini)) + make_init i tgt arity (Ast0.InitGccExt(designators,eq,ini)) | Ast0.InitGccName(name,eq,ini) -> let arity = init_same (mcode2line eq) [mcode2arity eq] in let name = ident true arity name in let eq = mcode eq in let ini = initialiser arity ini in make_init i tgt arity (Ast0.InitGccName(name,eq,ini)) - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> - let arity = - init_same (mcode2line lb) - [mcode2arity lb; mcode2arity rb; mcode2arity eq] in - let lb = mcode lb in - let exp = expression arity exp in - let rb = mcode rb in - let eq = mcode eq in - let ini = initialiser arity ini in - make_init i tgt arity (Ast0.InitGccIndex(lb,exp,rb,eq,ini)) - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - let arity = - init_same (mcode2line lb) - [mcode2arity lb; mcode2arity dots; mcode2arity rb; mcode2arity eq] in - let lb = mcode lb in - let exp1 = expression arity exp1 in - let dots = mcode dots in - let exp2 = expression arity exp2 in - let rb = mcode rb in - let eq = mcode eq in - let ini = initialiser arity ini in - make_init i tgt arity - (Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini)) | Ast0.IComma(cm) -> let arity = init_same (mcode2line cm) [mcode2arity cm] in let cm = mcode cm in @@ -592,6 +571,31 @@ and initialiser tgt i = | Ast0.OptIni(_) | Ast0.UniqueIni(_) -> failwith "unexpected code" +and designator tgt d = + let dsame = all_same false tgt in + match d with + Ast0.DesignatorField(dot,id) -> + let arity = dsame (mcode2line dot) [mcode2arity dot] in + let dot = mcode dot in + let id = ident false arity id in + Ast0.DesignatorField(dot,id) + | Ast0.DesignatorIndex(lb,exp,rb) -> + let arity = dsame (mcode2line lb) [mcode2arity lb;mcode2arity rb] in + let lb = mcode lb in + let exp = top_expression false arity exp in + let rb = mcode rb in + Ast0.DesignatorIndex(lb,exp,rb) + | Ast0.DesignatorRange(lb,min,dots,max,rb) -> + let arity = + dsame (mcode2line lb) + [mcode2arity lb;mcode2arity dots;mcode2arity rb] in + let lb = mcode lb in + let min = top_expression false arity min in + let dots = mcode dots in + let max = top_expression false arity max in + let rb = mcode rb in + Ast0.DesignatorRange(lb,min,dots,max,rb) + (* --------------------------------------------------------------------- *) (* Parameter *) diff --git a/parsing_cocci/ast0_cocci.ml b/parsing_cocci/ast0_cocci.ml index b40bb6e..fe3ba6a 100644 --- a/parsing_cocci/ast0_cocci.ml +++ b/parsing_cocci/ast0_cocci.ml @@ -203,24 +203,26 @@ and declaration = base_declaration wrap (* Initializers *) and base_initialiser = - InitExpr of expression + MetaInit of Ast.meta_name mcode * pure + | InitExpr of expression | InitList of string mcode (*{*) * initialiser_list * string mcode (*}*) - | InitGccDotName of - string mcode (*.*) * ident (* name *) * string mcode (*=*) * + | InitGccExt of + designator list (* name *) * string mcode (*=*) * initialiser (* gccext: *) | InitGccName of ident (* name *) * string mcode (*:*) * initialiser - | InitGccIndex of - string mcode (*[*) * expression * string mcode (*]*) * - string mcode (*=*) * initialiser - | InitGccRange of - string mcode (*[*) * expression * string mcode (*...*) * - expression * string mcode (*]*) * string mcode (*=*) * initialiser | IComma of string mcode (* , *) | Idots of string mcode (* ... *) * initialiser option (* whencode *) | OptIni of initialiser | UniqueIni of initialiser +and designator = + DesignatorField of string mcode (* . *) * ident + | DesignatorIndex of string mcode (* [ *) * expression * string mcode (* ] *) + | DesignatorRange of + string mcode (* [ *) * expression * string mcode (* ... *) * + expression * string mcode (* ] *) + and initialiser = base_initialiser wrap and initialiser_list = initialiser dots diff --git a/parsing_cocci/ast0_cocci.mli b/parsing_cocci/ast0_cocci.mli index ae6ea09..2eca940 100644 --- a/parsing_cocci/ast0_cocci.mli +++ b/parsing_cocci/ast0_cocci.mli @@ -175,24 +175,26 @@ and declaration = base_declaration wrap (* Initializers *) and base_initialiser = - InitExpr of expression + MetaInit of Ast_cocci.meta_name mcode * pure + | InitExpr of expression | InitList of string mcode (*{*) * initialiser_list * string mcode (*}*) - | InitGccDotName of - string mcode (*.*) * ident (* name *) * string mcode (*=*) * + | InitGccExt of + designator list (* name *) * string mcode (*=*) * initialiser (* gccext: *) | InitGccName of ident (* name *) * string mcode (*:*) * initialiser - | InitGccIndex of - string mcode (*[*) * expression * string mcode (*]*) * - string mcode (*=*) * initialiser - | InitGccRange of - string mcode (*[*) * expression * string mcode (*...*) * - expression * string mcode (*]*) * string mcode (*=*) * initialiser | IComma of string mcode | Idots of string mcode (* ... *) * initialiser option (* whencode *) | OptIni of initialiser | UniqueIni of initialiser +and designator = + DesignatorField of string mcode (* . *) * ident + | DesignatorIndex of string mcode (* [ *) * expression * string mcode (* ] *) + | DesignatorRange of + string mcode (* [ *) * expression * string mcode (* ... *) * + expression * string mcode (* ] *) + and initialiser = base_initialiser wrap and initialiser_list = initialiser dots diff --git a/parsing_cocci/ast0toast.ml b/parsing_cocci/ast0toast.ml index 91da782..274f7f9 100644 --- a/parsing_cocci/ast0toast.ml +++ b/parsing_cocci/ast0toast.ml @@ -524,26 +524,30 @@ and strip_idots initlist = and initialiser i = rewrap i no_isos (match Ast0.unwrap i with - Ast0.InitExpr(exp) -> Ast.InitExpr(expression exp) + Ast0.MetaInit(name,_) -> Ast.MetaInit(mcode name,unitary,false) + | Ast0.InitExpr(exp) -> Ast.InitExpr(expression exp) | Ast0.InitList(lb,initlist,rb) -> let (whencode,initlist) = strip_idots initlist in Ast.InitList(mcode lb,List.map initialiser initlist,mcode rb, List.map initialiser whencode) - | Ast0.InitGccDotName(dot,name,eq,ini) -> - Ast.InitGccDotName(mcode dot,ident name,mcode eq,initialiser ini) + | Ast0.InitGccExt(designators,eq,ini) -> + Ast.InitGccExt(List.map designator designators,mcode eq, + initialiser ini) | Ast0.InitGccName(name,eq,ini) -> Ast.InitGccName(ident name,mcode eq,initialiser ini) - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> - Ast.InitGccIndex(mcode lb,expression exp,mcode rb,mcode eq, - initialiser ini) - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - Ast.InitGccRange(mcode lb,expression exp1,mcode dots, - expression exp2,mcode rb,mcode eq,initialiser ini) | Ast0.IComma(comma) -> Ast.IComma(mcode comma) | Ast0.Idots(_,_) -> failwith "Idots should have been removed" | Ast0.OptIni(ini) -> Ast.OptIni(initialiser ini) | Ast0.UniqueIni(ini) -> Ast.UniqueIni(initialiser ini)) +and designator = function + Ast0.DesignatorField(dot,id) -> Ast.DesignatorField(mcode dot,ident id) + | Ast0.DesignatorIndex(lb,exp,rb) -> + Ast.DesignatorIndex(mcode lb, expression exp, mcode rb) + | Ast0.DesignatorRange(lb,min,dots,max,rb) -> + Ast.DesignatorRange(mcode lb,expression min,mcode dots,expression max, + mcode rb) + (* --------------------------------------------------------------------- *) (* Parameter *) diff --git a/parsing_cocci/ast_cocci.ml b/parsing_cocci/ast_cocci.ml index 4521d24..ee0a43a 100644 --- a/parsing_cocci/ast_cocci.ml +++ b/parsing_cocci/ast_cocci.ml @@ -83,6 +83,7 @@ and metavar = MetaIdDecl of arity * meta_name (* name *) | MetaFreshIdDecl of arity * meta_name (* name *) | MetaTypeDecl of arity * meta_name (* name *) + | MetaInitDecl of arity * meta_name (* name *) | MetaListlenDecl of meta_name (* name *) | MetaParamDecl of arity * meta_name (* name *) | MetaParamListDecl of arity * meta_name (*name*) * meta_name option (*len*) @@ -280,25 +281,27 @@ and declaration = base_declaration wrap (* Initializers *) and base_initialiser = - InitExpr of expression + MetaInit of meta_name mcode * keep_binding * inherited + | InitExpr of expression | InitList of string mcode (*{*) * initialiser list * string mcode (*}*) * initialiser list (* whencode: elements that shouldn't appear in init *) - | InitGccDotName of - string mcode (*.*) * ident (* name *) * string mcode (*=*) * + | InitGccExt of + designator list (* name *) * string mcode (*=*) * initialiser (* gccext: *) | InitGccName of ident (* name *) * string mcode (*:*) * initialiser - | InitGccIndex of - string mcode (*[*) * expression * string mcode (*]*) * - string mcode (*=*) * initialiser - | InitGccRange of - string mcode (*[*) * expression * string mcode (*...*) * - expression * string mcode (*]*) * string mcode (*=*) * initialiser | IComma of string mcode (* , *) | OptIni of initialiser | UniqueIni of initialiser +and designator = + DesignatorField of string mcode (* . *) * ident + | DesignatorIndex of string mcode (* [ *) * expression * string mcode (* ] *) + | DesignatorRange of + string mcode (* [ *) * expression * string mcode (* ... *) * + expression * string mcode (* ] *) + and initialiser = base_initialiser wrap (* --------------------------------------------------------------------- *) @@ -619,6 +622,7 @@ let get_meta_name = function MetaIdDecl(ar,nm) -> nm | MetaFreshIdDecl(ar,nm) -> nm | MetaTypeDecl(ar,nm) -> nm + | MetaInitDecl(ar,nm) -> nm | MetaListlenDecl(nm) -> nm | MetaParamDecl(ar,nm) -> nm | MetaParamListDecl(ar,nm,nm1) -> nm diff --git a/parsing_cocci/ast_cocci.mli b/parsing_cocci/ast_cocci.mli index cb24dcf..a207334 100644 --- a/parsing_cocci/ast_cocci.mli +++ b/parsing_cocci/ast_cocci.mli @@ -58,6 +58,7 @@ and metavar = MetaIdDecl of arity * meta_name (* name *) | MetaFreshIdDecl of arity * meta_name (* name *) | MetaTypeDecl of arity * meta_name (* name *) + | MetaInitDecl of arity * meta_name (* name *) | MetaListlenDecl of meta_name (* name *) | MetaParamDecl of arity * meta_name (* name *) | MetaParamListDecl of arity * meta_name (*name*) * meta_name option (*len*) @@ -248,24 +249,26 @@ and declaration = base_declaration wrap (* Initializers *) and base_initialiser = - InitExpr of expression + MetaInit of meta_name mcode * keep_binding * inherited + | InitExpr of expression | InitList of string mcode (*{*) * initialiser list * string mcode (*}*) * initialiser list (* whencode: elements that shouldn't appear in init *) - | InitGccDotName of - string mcode (*.*) * ident (* name *) * string mcode (*=*) * + | InitGccExt of + designator list (* name *) * string mcode (*=*) * initialiser (* gccext: *) | InitGccName of ident (* name *) * string mcode (*:*) * initialiser - | InitGccIndex of - string mcode (*[*) * expression * string mcode (*]*) * - string mcode (*=*) * initialiser - | InitGccRange of - string mcode (*[*) * expression * string mcode (*...*) * - expression * string mcode (*]*) * string mcode (*=*) * initialiser | IComma of string mcode (* , *) | OptIni of initialiser | UniqueIni of initialiser +and designator = + DesignatorField of string mcode (* . *) * ident + | DesignatorIndex of string mcode (* [ *) * expression * string mcode (* ] *) + | DesignatorRange of + string mcode (* [ *) * expression * string mcode (* ... *) * + expression * string mcode (* ] *) + and initialiser = base_initialiser wrap (* --------------------------------------------------------------------- *) diff --git a/parsing_cocci/check_meta.ml b/parsing_cocci/check_meta.ml index 9c8fcd2..ff7d88e 100644 --- a/parsing_cocci/check_meta.ml +++ b/parsing_cocci/check_meta.ml @@ -255,27 +255,31 @@ and declaration context old_metas table minus d = and initialiser old_metas table minus ini = match Ast0.unwrap ini with - Ast0.InitExpr(exp) -> expression ID old_metas table minus exp + Ast0.MetaInit(name,_) -> + check_table table minus name + | Ast0.InitExpr(exp) -> expression ID old_metas table minus exp | Ast0.InitList(lb,initlist,rb) -> dots (initialiser old_metas table minus) initlist - | Ast0.InitGccDotName(dot,name,eq,ini) -> - ident FIELD old_metas table minus name; + | Ast0.InitGccExt(designators,eq,ini) -> + List.iter (designator old_metas table minus) designators; initialiser old_metas table minus ini | Ast0.InitGccName(name,eq,ini) -> ident FIELD old_metas table minus name; initialiser old_metas table minus ini - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> - expression ID old_metas table minus exp; - initialiser old_metas table minus ini - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - expression ID old_metas table minus exp1; - expression ID old_metas table minus exp2; - initialiser old_metas table minus ini | Ast0.Idots(_,Some x) -> initialiser old_metas table minus x | Ast0.OptIni(_) | Ast0.UniqueIni(_) -> failwith "unexpected code" | _ -> () (* no metavariable subterms *) +and designator old_metas table minus = function + Ast0.DesignatorField(dot,id) -> + ident FIELD old_metas table minus id + | Ast0.DesignatorIndex(lb,exp,rb) -> + expression ID old_metas table minus exp + | Ast0.DesignatorRange(lb,min,dots,max,rb) -> + expression ID old_metas table minus min; + expression ID old_metas table minus max + and initialiser_list old_metas table minus = dots (initialiser old_metas table minus) diff --git a/parsing_cocci/compute_lines.ml b/parsing_cocci/compute_lines.ml index 67ec35d..d93ed9e 100644 --- a/parsing_cocci/compute_lines.ml +++ b/parsing_cocci/compute_lines.ml @@ -449,7 +449,9 @@ and is_init_dots i = and initialiser i = match Ast0.unwrap i with - Ast0.InitExpr(exp) -> + Ast0.MetaInit(name,_) as ut -> + let ln = promote_mcode name in mkres i ut ln ln + | Ast0.InitExpr(exp) -> let exp = expression exp in mkres i (Ast0.InitExpr(exp)) exp exp | Ast0.InitList(lb,initlist,rb) -> @@ -457,24 +459,16 @@ and initialiser i = dots is_init_dots (Some(promote_mcode lb)) initialiser initlist in mkres i (Ast0.InitList(lb,initlist,rb)) (promote_mcode lb) (promote_mcode rb) - | Ast0.InitGccDotName(dot,name,eq,ini) -> - let name = ident name in + | Ast0.InitGccExt(designators,eq,ini) -> + let (delims,designators) = (* non empty due to parsing *) + List.split (List.map designator designators) in let ini = initialiser ini in - mkres i (Ast0.InitGccDotName(dot,name,eq,ini)) (promote_mcode dot) ini + mkres i (Ast0.InitGccExt(designators,eq,ini)) + (promote_mcode (List.hd delims)) ini | Ast0.InitGccName(name,eq,ini) -> let name = ident name in let ini = initialiser ini in mkres i (Ast0.InitGccName(name,eq,ini)) name ini - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> - let exp = expression exp in - let ini = initialiser ini in - mkres i (Ast0.InitGccIndex(lb,exp,rb,eq,ini)) (promote_mcode lb) ini - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - let exp1 = expression exp1 in - let exp2 = expression exp2 in - let ini = initialiser ini in - mkres i (Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini)) - (promote_mcode lb) ini | Ast0.IComma(cm) as up -> let ln = promote_mcode cm in mkres i up ln ln | Ast0.Idots(dots,whencode) -> @@ -488,6 +482,14 @@ and initialiser i = let ini = initialiser ini in mkres i (Ast0.UniqueIni(ini)) ini ini +and designator = function + Ast0.DesignatorField(dot,id) -> + (dot,Ast0.DesignatorField(dot,ident id)) + | Ast0.DesignatorIndex(lb,exp,rb) -> + (lb,Ast0.DesignatorIndex(lb,expression exp,rb)) + | Ast0.DesignatorRange(lb,min,dots,max,rb) -> + (lb,Ast0.DesignatorRange(lb,expression min,dots,expression max,rb)) + and initialiser_list prev = dots is_init_dots prev initialiser (* for export *) diff --git a/parsing_cocci/context_neg.ml b/parsing_cocci/context_neg.ml index 84eaabe..67b3317 100644 --- a/parsing_cocci/context_neg.ml +++ b/parsing_cocci/context_neg.ml @@ -549,22 +549,32 @@ let equal_declaration d1 d2 = failwith "DisjDecl not expected here" | _ -> false +let equal_designator d1 d2 = + match (d1,d2) with + (Ast0.DesignatorField(dot1,_),Ast0.DesignatorField(dot2,_)) -> + equal_mcode dot1 dot2 + | (Ast0.DesignatorIndex(lb1,_,rb1),Ast0.DesignatorIndex(lb2,_,rb2)) -> + (equal_mcode lb1 lb2) && (equal_mcode rb1 rb2) + | (Ast0.DesignatorRange(lb1,_,dots1,_,rb1), + Ast0.DesignatorRange(lb2,_,dots2,_,rb2)) -> + (equal_mcode lb1 lb2) && (equal_mcode dots1 dots2) && + (equal_mcode rb1 rb2) + | _ -> false + let equal_initialiser i1 i2 = match (Ast0.unwrap i1,Ast0.unwrap i2) with - (Ast0.InitExpr(_),Ast0.InitExpr(_)) -> true + (Ast0.MetaInit(name1,_),Ast0.MetaInit(name2,_)) -> + equal_mcode name1 name2 + | (Ast0.InitExpr(_),Ast0.InitExpr(_)) -> true | (Ast0.InitList(lb1,_,rb1),Ast0.InitList(lb2,_,rb2)) -> (equal_mcode lb1 lb2) && (equal_mcode rb1 rb2) - | (Ast0.InitGccDotName(dot1,_,eq1,_),Ast0.InitGccDotName(dot2,_,eq2,_)) -> - (equal_mcode dot1 dot2) && (equal_mcode eq1 eq2) + | (Ast0.InitGccExt(designators1,eq1,_), + Ast0.InitGccExt(designators2,eq2,_)) -> + (List.for_all2 equal_designator designators1 designators2) && + (equal_mcode eq1 eq2) | (Ast0.InitGccName(_,eq1,_),Ast0.InitGccName(_,eq2,_)) -> equal_mcode eq1 eq2 - | (Ast0.InitGccIndex(lb1,_,rb1,eq1,_),Ast0.InitGccIndex(lb2,_,rb2,eq2,_)) -> - (equal_mcode lb1 lb2) && (equal_mcode rb1 rb2) && (equal_mcode eq1 eq2) - | (Ast0.InitGccRange(lb1,_,dots1,_,rb1,eq1,_), - Ast0.InitGccRange(lb2,_,dots2,_,rb2,eq2,_)) -> - (equal_mcode lb1 lb2) && (equal_mcode dots1 dots2) && - (equal_mcode rb1 rb2) && (equal_mcode eq1 eq2) - | (Ast0.IComma(cm1),Ast0.IComma(cm2)) -> equal_mcode cm1 cm2 + | (Ast0.IComma(cm1),Ast0.IComma(cm2)) -> equal_mcode cm1 cm2 | (Ast0.Idots(d1,_),Ast0.Idots(d2,_)) -> equal_mcode d1 d2 | (Ast0.OptIni(_),Ast0.OptIni(_)) -> true | (Ast0.UniqueIni(_),Ast0.UniqueIni(_)) -> true diff --git a/parsing_cocci/data.ml b/parsing_cocci/data.ml index fe7c28d..f6fe909 100644 --- a/parsing_cocci/data.ml +++ b/parsing_cocci/data.ml @@ -67,6 +67,9 @@ let add_id_meta: let add_type_meta: (Ast.meta_name -> Ast0.pure -> unit) ref = ref (fun _ -> failwith "uninitialized add_meta") +let add_init_meta: (Ast.meta_name -> Ast0.pure -> unit) ref = + ref (fun _ -> failwith "uninitialized add_meta") + let add_param_meta: (Ast.meta_name -> Ast0.pure -> unit) ref = ref (fun _ -> failwith "uninitialized add_meta") diff --git a/parsing_cocci/data.mli b/parsing_cocci/data.mli index 3bd3998..65c15d9 100644 --- a/parsing_cocci/data.mli +++ b/parsing_cocci/data.mli @@ -35,6 +35,8 @@ val add_id_meta: val add_type_meta: (Ast_cocci.meta_name -> Ast0_cocci.pure -> unit) ref +val add_init_meta: (Ast_cocci.meta_name -> Ast0_cocci.pure -> unit) ref + val add_param_meta: (Ast_cocci.meta_name -> Ast0_cocci.pure -> unit) ref val add_paramlist_meta: diff --git a/parsing_cocci/disjdistr.ml b/parsing_cocci/disjdistr.ml index ae7679f..1b693e7 100644 --- a/parsing_cocci/disjdistr.ml +++ b/parsing_cocci/disjdistr.ml @@ -199,7 +199,8 @@ and disjparam p = and disjini i = match Ast.unwrap i with - Ast.InitExpr(exp) -> + Ast.MetaInit(_,_,_) -> [i] + | Ast.InitExpr(exp) -> let exp = disjexp exp in List.map (function exp -> Ast.rewrap i (Ast.InitExpr(exp))) exp | Ast.InitList(lb,initlist,rb,whencode) -> @@ -207,24 +208,17 @@ and disjini i = (function initlist -> Ast.rewrap i (Ast.InitList(lb,initlist,rb,whencode))) (disjmult disjini initlist) - | Ast.InitGccDotName(dot,name,eq,ini) -> + | Ast.InitGccExt(designators,eq,ini) -> + let designators = disjmult designator designators in let ini = disjini ini in - List.map - (function ini -> Ast.rewrap i (Ast.InitGccDotName(dot,name,eq,ini))) - ini + disjmult2 designators ini + (function designators -> function ini -> + Ast.rewrap i (Ast.InitGccExt(designators,eq,ini))) | Ast.InitGccName(name,eq,ini) -> let ini = disjini ini in List.map (function ini -> Ast.rewrap i (Ast.InitGccName(name,eq,ini))) ini - | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> - disjmult2 (disjexp exp) (disjini ini) - (function exp -> function ini -> - Ast.rewrap i (Ast.InitGccIndex(lb,exp,rb,eq,ini))) - | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - disjmult3 (disjexp exp1) (disjexp exp2) (disjini ini) - (function exp1 -> function exp2 -> function ini -> - Ast.rewrap i (Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini))) | Ast.IComma(comma) -> [i] | Ast.OptIni(ini) -> let ini = disjini ini in @@ -233,6 +227,16 @@ and disjini i = let ini = disjini ini in List.map (function ini -> Ast.rewrap i (Ast.UniqueIni(ini))) ini +and designator = function + Ast.DesignatorField(dot,id) -> [Ast.DesignatorField(dot,id)] + | Ast.DesignatorIndex(lb,exp,rb) -> + let exp = disjexp exp in + List.map (function exp -> Ast.DesignatorIndex(lb,exp,rb)) exp + | Ast.DesignatorRange(lb,min,dots,max,rb) -> + disjmult2 (disjexp min) (disjexp max) + (function min -> function max -> + Ast.DesignatorRange(lb,min,dots,max,rb)) + and disjdecl d = match Ast.unwrap d with Ast.Init(stg,ty,id,eq,ini,sem) -> diff --git a/parsing_cocci/free_vars.ml b/parsing_cocci/free_vars.ml index dabf51c..f3fbd5f 100644 --- a/parsing_cocci/free_vars.ml +++ b/parsing_cocci/free_vars.ml @@ -125,6 +125,12 @@ let collect_refs include_constraints = Ast.MetaType(name,_,_) -> [metaid name] | _ -> option_default) in + let astfvinit recursor k ty = + bind (k ty) + (match Ast.unwrap ty with + Ast.MetaInit(name,_,_) -> [metaid name] + | _ -> option_default) in + let astfvparam recursor k p = bind (k p) (match Ast.unwrap p with @@ -161,7 +167,7 @@ let collect_refs include_constraints = V.combiner bind option_default mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode donothing donothing donothing donothing - astfvident astfvexpr astfvfullType astfvtypeC donothing astfvparam + astfvident astfvexpr astfvfullType astfvtypeC astfvinit astfvparam astfvdecls astfvrule_elem astfvstatement donothing donothing donothing_a let collect_all_refs = collect_refs true @@ -224,6 +230,12 @@ let collect_saved = Ast.MetaType(name,TC.Saved,_) -> [metaid name] | _ -> option_default) in + let astfvinit recursor k ty = + bind (k ty) + (match Ast.unwrap ty with + Ast.MetaInit(name,TC.Saved,_) -> [metaid name] + | _ -> option_default) in + let astfvparam recursor k p = bind (k p) (match Ast.unwrap p with @@ -254,7 +266,7 @@ let collect_saved = V.combiner bind option_default mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode donothing donothing donothing donothing - astfvident astfvexpr donothing astfvtypeC donothing astfvparam + astfvident astfvexpr donothing astfvtypeC astfvinit astfvparam donothing astfvrule_elem donothing donothing donothing donothing (* ---------------------------------------------------------------- *) @@ -439,6 +451,14 @@ let classify_variables metavars minirules used_after = Ast.rewrap e (Ast.MetaType(name,unitary,inherited)) | _ -> e in + let init r k e = + let e = k e in + match Ast.unwrap e with + Ast.MetaInit(name,_,_) -> + let (unitary,inherited) = classify name in + Ast.rewrap e (Ast.MetaInit(name,unitary,inherited)) + | _ -> e in + let param r k e = let e = k e in match Ast.unwrap e with @@ -470,7 +490,7 @@ let classify_variables metavars minirules used_after = let fn = V.rebuilder mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode donothing donothing donothing donothing - ident expression donothing typeC donothing param donothing rule_elem + ident expression donothing typeC init param donothing rule_elem donothing donothing donothing donothing in List.map fn.V.rebuilder_top_level minirules diff --git a/parsing_cocci/index.ml b/parsing_cocci/index.ml index 2f3752c..a28bb8d 100644 --- a/parsing_cocci/index.ml +++ b/parsing_cocci/index.ml @@ -21,7 +21,7 @@ (* create an index for each constructor *) -(* current max is 147 *) +(* current max is 147, but 107 is free *) (* doesn't really work - requires that identical terms with no token subterms (eg dots) not appear on the same line *) @@ -147,12 +147,11 @@ let declaration d = let initialiser i = match Ast0.unwrap i with - Ast0.InitExpr(exp) -> [102] (* added after *) + Ast0.MetaInit(nm,_) -> [106] (* added after *) + | Ast0.InitExpr(exp) -> [102] | Ast0.InitList(lb,initlist,rb) -> [103] - | Ast0.InitGccDotName(dot,name,eq,ini) -> [104] + | Ast0.InitGccExt(designators,eq,ini) -> [104] | Ast0.InitGccName(name,eq,ini) -> [105] - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> [106] - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> [107] | Ast0.IComma(cm) -> [108] | Ast0.Idots(d,whencode) -> [109] | Ast0.OptIni(id) -> [110] diff --git a/parsing_cocci/iso_pattern.ml b/parsing_cocci/iso_pattern.ml index 0afc05b..2a3bb2e 100644 --- a/parsing_cocci/iso_pattern.ml +++ b/parsing_cocci/iso_pattern.ml @@ -386,6 +386,12 @@ let match_maker checks_needed context_required whencode_allowed = Ast0.MetaType(name,pure) -> pure | _ -> Ast0.Impure) in + let init r k t = + bind (bind (pure_mcodekind (Ast0.get_mcodekind t)) (k t)) + (match Ast0.unwrap t with + Ast0.MetaInit(name,pure) -> pure + | _ -> Ast0.Impure) in + let param r k p = bind (bind (pure_mcodekind (Ast0.get_mcodekind p)) (k p)) (match Ast0.unwrap p with @@ -401,7 +407,7 @@ let match_maker checks_needed context_required whencode_allowed = V0.combiner bind option_default mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode donothing donothing donothing donothing donothing donothing - ident expression typeC donothing param donothing stmt donothing + ident expression typeC init param donothing stmt donothing donothing in let add_pure_list_binding name pure is_pure builder1 builder2 lst = @@ -842,56 +848,72 @@ let match_maker checks_needed context_required whencode_allowed = else return_false (ContextRequired (Ast0.DeclTag d)) and match_init pattern i = - if not(checks_needed) or not(context_required) or is_context i - then - match (Ast0.unwrap pattern,Ast0.unwrap i) with - (Ast0.InitExpr(expa),Ast0.InitExpr(expb)) -> - match_expr expa expb - | (Ast0.InitList(lb1,initlista,rb1),Ast0.InitList(lb,initlistb,rb)) -> - conjunct_many_bindings - [check_mcode lb1 lb; check_mcode rb1 rb; - match_dots match_init no_list do_nolist_match - initlista initlistb] - | (Ast0.InitGccDotName(d1,namea,e1,inia), - Ast0.InitGccDotName(d,nameb,e,inib)) -> - conjunct_many_bindings - [check_mcode d1 d; check_mcode e1 e; - match_ident namea nameb; match_init inia inib] - | (Ast0.InitGccName(namea,c1,inia),Ast0.InitGccName(nameb,c,inib)) -> - conjunct_many_bindings - [check_mcode c1 c; match_ident namea nameb; - match_init inia inib] - | (Ast0.InitGccIndex(lb1,expa,rb1,e1,inia), - Ast0.InitGccIndex(lb2,expb,rb2,e2,inib)) -> - conjunct_many_bindings - [check_mcode lb1 lb2; check_mcode rb1 rb2; check_mcode e1 e2; - match_expr expa expb; match_init inia inib] - | (Ast0.InitGccRange(lb1,exp1a,d1,exp2a,rb1,e1,inia), - Ast0.InitGccRange(lb2,exp1b,d2,exp2b,rb2,e2,inib)) -> - conjunct_many_bindings - [check_mcode lb1 lb2; check_mcode d1 d2; - check_mcode rb1 rb2; check_mcode e1 e2; - match_expr exp1a exp1b; match_expr exp2a exp2b; - match_init inia inib] - | (Ast0.IComma(c1),Ast0.IComma(c)) -> check_mcode c1 c - | (Ast0.Idots(d1,None),Ast0.Idots(d,None)) -> check_mcode d1 d - | (Ast0.Idots(id,None),Ast0.Idots(d,Some wc)) -> - conjunct_bindings (check_mcode id d) + match Ast0.unwrap pattern with + Ast0.MetaInit(name,pure) -> + add_pure_binding name pure pure_sp_code.V0.combiner_initialiser + (function ini -> Ast0.InitTag ini) + i + | up -> + if not(checks_needed) or not(context_required) or is_context i + then + match (up,Ast0.unwrap i) with + (Ast0.InitExpr(expa),Ast0.InitExpr(expb)) -> + match_expr expa expb + | (Ast0.InitList(lb1,initlista,rb1),Ast0.InitList(lb,initlistb,rb)) + -> + conjunct_many_bindings + [check_mcode lb1 lb; check_mcode rb1 rb; + match_dots match_init no_list do_nolist_match + initlista initlistb] + | (Ast0.InitGccExt(designators1,e1,inia), + Ast0.InitGccExt(designators2,e2,inib)) -> + conjunct_many_bindings + [match_list match_designator + (function _ -> false) (function _ -> failwith "") + designators1 designators2; + check_mcode e1 e2; + match_init inia inib] + | (Ast0.InitGccName(namea,c1,inia),Ast0.InitGccName(nameb,c,inib)) -> + conjunct_many_bindings + [check_mcode c1 c; match_ident namea nameb; + match_init inia inib] + | (Ast0.IComma(c1),Ast0.IComma(c)) -> check_mcode c1 c + | (Ast0.Idots(d1,None),Ast0.Idots(d,None)) -> check_mcode d1 d + | (Ast0.Idots(id,None),Ast0.Idots(d,Some wc)) -> + conjunct_bindings (check_mcode id d) (* hope that mcode of edots is unique somehow *) - (let (_,idots_whencode_allowed,_) = whencode_allowed in - if idots_whencode_allowed - then add_dot_binding id (Ast0.InitTag wc) - else - (Printf.printf "warning: not applying iso because of whencode"; - return false)) - | (Ast0.Idots(_,Some _),_) -> - failwith "whencode not allowed in a pattern2" - | (Ast0.OptIni(ia),Ast0.OptIni(ib)) - | (Ast0.UniqueIni(ia),Ast0.UniqueIni(ib)) -> match_init ia ib - | (_,Ast0.OptIni(ib)) - | (_,Ast0.UniqueIni(ib)) -> match_init pattern ib - | _ -> return false - else return_false (ContextRequired (Ast0.InitTag i)) + (let (_,idots_whencode_allowed,_) = whencode_allowed in + if idots_whencode_allowed + then add_dot_binding id (Ast0.InitTag wc) + else + (Printf.printf + "warning: not applying iso because of whencode"; + return false)) + | (Ast0.Idots(_,Some _),_) -> + failwith "whencode not allowed in a pattern2" + | (Ast0.OptIni(ia),Ast0.OptIni(ib)) + | (Ast0.UniqueIni(ia),Ast0.UniqueIni(ib)) -> match_init ia ib + | (_,Ast0.OptIni(ib)) + | (_,Ast0.UniqueIni(ib)) -> match_init pattern ib + | _ -> return false + else return_false (ContextRequired (Ast0.InitTag i)) + + and match_designator pattern d = + match (pattern,d) with + (Ast0.DesignatorField(dota,ida),Ast0.DesignatorField(dotb,idb)) -> + conjunct_bindings (check_mcode dota dotb) (match_ident ida idb) + | (Ast0.DesignatorIndex(lba,expa,rba), + Ast0.DesignatorIndex(lbb,expb,rbb)) -> + conjunct_many_bindings + [check_mcode lba lbb; match_expr expa expb; + check_mcode rba rbb] + | (Ast0.DesignatorRange(lba,mina,dotsa,maxa,rba), + Ast0.DesignatorRange(lbb,minb,dotsb,maxb,rbb)) -> + conjunct_many_bindings + [check_mcode lba lbb; match_expr mina minb; + check_mcode dotsa dotsb; match_expr maxa maxb; + check_mcode rba rbb] + | _ -> return false and match_param pattern p = match Ast0.unwrap pattern with @@ -1675,6 +1697,19 @@ let instantiate bindings mv_bindings = (Ast0.MetaType(Ast0.set_mcode_data new_mv name,pure))) | _ -> e in + let initfn r k e = + let e = k e in + match Ast0.unwrap e with + Ast0.MetaInit(name,pure) -> + (rebuild_mcode None).V0.rebuilder_initialiser + (match lookup name bindings mv_bindings with + Common.Left(Ast0.InitTag(ty)) -> ty + | Common.Left(_) -> failwith "not possible 1" + | Common.Right(new_mv) -> + Ast0.rewrap e + (Ast0.MetaInit(Ast0.set_mcode_data new_mv name,pure))) + | _ -> e in + let declfn r k e = let e = k e in match Ast0.unwrap e with @@ -1745,7 +1780,7 @@ let instantiate bindings mv_bindings = V0.rebuilder mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode (dots elist) donothing (dots plist) (dots slist) donothing donothing - identfn exprfn tyfn donothing paramfn declfn stmtfn donothing donothing + identfn exprfn tyfn initfn paramfn declfn stmtfn donothing donothing (* --------------------------------------------------------------------- *) @@ -1891,6 +1926,8 @@ let get_name = function (nm,function nm -> Ast.MetaFreshIdDecl(ar,nm)) | Ast.MetaTypeDecl(ar,nm) -> (nm,function nm -> Ast.MetaTypeDecl(ar,nm)) + | Ast.MetaInitDecl(ar,nm) -> + (nm,function nm -> Ast.MetaInitDecl(ar,nm)) | Ast.MetaListlenDecl(nm) -> failwith "should not be rebuilt" | Ast.MetaParamDecl(ar,nm) -> diff --git a/parsing_cocci/lexer_cocci.mll b/parsing_cocci/lexer_cocci.mll index 28e7093..f02c923 100644 --- a/parsing_cocci/lexer_cocci.mll +++ b/parsing_cocci/lexer_cocci.mll @@ -191,6 +191,10 @@ let id_tokens lexbuf = check_arity_context_linetype s; TGenerated | "expression" when in_meta || in_rule_name -> check_arity_context_linetype s; TExpression + | "initialiser" when in_meta || in_rule_name -> + check_arity_context_linetype s; TInitialiser + | "initializer" when in_meta || in_rule_name -> + check_arity_context_linetype s; TInitialiser | "idexpression" when in_meta -> check_arity_context_linetype s; TIdExpression | "statement" when in_meta -> check_arity_context_linetype s; TStatement @@ -300,6 +304,10 @@ let init _ = (fun name pure -> let fn clt = TMetaType(name,pure,clt) in Hashtbl.replace metavariables (get_name name) fn); + Data.add_init_meta := + (fun name pure -> + let fn clt = TMetaInit(name,pure,clt) in + Hashtbl.replace metavariables (get_name name) fn); Data.add_param_meta := (function name -> function pure -> let fn clt = TMetaParam(name,pure,clt) in diff --git a/parsing_cocci/parse_aux.ml b/parsing_cocci/parse_aux.ml index 1190521..91df7e7 100644 --- a/parsing_cocci/parse_aux.ml +++ b/parsing_cocci/parse_aux.ml @@ -217,6 +217,13 @@ let check_meta tok = raise (Semantic_cocci.Semantic ("incompatible inheritance declaration "^name))) + | Ast.MetaInitDecl(Ast.NONE,(rule,name)) -> + (match lookup rule name with + Ast.MetaInitDecl(_,_) -> () + | _ -> + raise + (Semantic_cocci.Semantic + ("incompatible inheritance declaration "^name))) | Ast.MetaParamDecl(Ast.NONE,(rule,name)) -> (match lookup rule name with Ast.MetaParamDecl(_,_) -> () diff --git a/parsing_cocci/parse_cocci.ml b/parsing_cocci/parse_cocci.ml index bd217cc..91c0768 100644 --- a/parsing_cocci/parse_cocci.ml +++ b/parsing_cocci/parse_cocci.ml @@ -55,6 +55,7 @@ let token2c (tok,_) = | PC.TConstant -> "constant" | PC.TExpression -> "expression" | PC.TIdExpression -> "idexpression" + | PC.TInitialiser -> "initialiser" | PC.TStatement -> "statement" | PC.TPosition -> "position" | PC.TPosAny -> "any" @@ -187,6 +188,7 @@ let token2c (tok,_) = | PC.TMetaExpList(_,_,_,clt) -> "explistmeta"^(line_type2c clt) | PC.TMetaId(_,_,_,clt) -> "idmeta"^(line_type2c clt) | PC.TMetaType(_,_,clt) -> "typemeta"^(line_type2c clt) + | PC.TMetaInit(_,_,clt) -> "initmeta"^(line_type2c clt) | PC.TMetaStm(_,_,clt) -> "stmmeta"^(line_type2c clt) | PC.TMetaStmList(_,_,clt) -> "stmlistmeta"^(line_type2c clt) | PC.TMetaFunc(_,_,_,clt) -> "funcmeta"^(line_type2c clt) @@ -305,7 +307,7 @@ let plus_attachable (tok,_) = | PC.TMetaLocalIdExp(_,_,_,_,clt) | PC.TMetaExpList(_,_,_,clt) | PC.TMetaId(_,_,_,clt) - | PC.TMetaType(_,_,clt) | PC.TMetaStm(_,_,clt) + | PC.TMetaType(_,_,clt) | PC.TMetaInit(_,_,clt) | PC.TMetaStm(_,_,clt) | PC.TMetaStmList(_,_,clt) | PC.TMetaFunc(_,_,_,clt) | PC.TMetaLocalFunc(_,_,_,clt) @@ -367,7 +369,7 @@ let get_clt (tok,_) = | PC.TMetaLocalIdExp(_,_,_,_,clt) | PC.TMetaExpList(_,_,_,clt) | PC.TMetaId(_,_,_,clt) - | PC.TMetaType(_,_,clt) | PC.TMetaStm(_,_,clt) + | PC.TMetaType(_,_,clt) | PC.TMetaInit(_,_,clt) | PC.TMetaStm(_,_,clt) | PC.TMetaStmList(_,_,clt) | PC.TMetaFunc(_,_,_,clt) | PC.TMetaLocalFunc(_,_,_,clt) | PC.TMetaPos(_,_,_,clt) @@ -476,6 +478,7 @@ let update_clt (tok,x) clt = | PC.TMetaExpList(a,b,c,_) -> (PC.TMetaExpList(a,b,c,clt),x) | PC.TMetaId(a,b,c,_) -> (PC.TMetaId(a,b,c,clt),x) | PC.TMetaType(a,b,_) -> (PC.TMetaType(a,b,clt),x) + | PC.TMetaInit(a,b,_) -> (PC.TMetaInit(a,b,clt),x) | PC.TMetaStm(a,b,_) -> (PC.TMetaStm(a,b,clt),x) | PC.TMetaStmList(a,b,_) -> (PC.TMetaStmList(a,b,clt),x) | PC.TMetaFunc(a,b,c,_) -> (PC.TMetaFunc(a,b,c,clt),x) @@ -585,7 +588,7 @@ let split t clt = let split_token ((tok,_) as t) = match tok with PC.TIdentifier | PC.TConstant | PC.TExpression | PC.TIdExpression - | PC.TStatement | PC.TPosition | PC.TPosAny + | PC.TStatement | PC.TPosition | PC.TPosAny | PC.TInitialiser | PC.TFunction | PC.TTypedef | PC.TDeclarer | PC.TIterator | PC.TName | PC.TType | PC.TParameter | PC.TLocal | PC.Tlist | PC.TFresh | PC.TPure | PC.TContext | PC.TRuleName(_) | PC.TUsing | PC.TDisable | PC.TExtends @@ -617,7 +620,7 @@ let split_token ((tok,_) as t) = | PC.TMetaIdExp(_,_,_,_,clt) | PC.TMetaLocalIdExp(_,_,_,_,clt) | PC.TMetaExpList(_,_,_,clt) | PC.TMetaParam(_,_,clt) | PC.TMetaParamList(_,_,_,clt) - | PC.TMetaId(_,_,_,clt) | PC.TMetaType(_,_,clt) + | PC.TMetaId(_,_,_,clt) | PC.TMetaType(_,_,clt) | PC.TMetaInit(_,_,clt) | PC.TMetaStm(_,_,clt) | PC.TMetaStmList(_,_,clt) | PC.TMetaErr(_,_,_,clt) | PC.TMetaFunc(_,_,_,clt) | PC.TMetaLocalFunc(_,_,_,clt) | PC.TMetaDeclarer(_,_,_,clt) | PC.TMetaIterator(_,_,_,clt) -> split t clt @@ -767,6 +770,7 @@ let detect_types in_meta_decls l = | (PC.TMetaLocalIdExp(_,_,_,_,_),_) | (PC.TMetaExpList(_,_,_,_),_) | (PC.TMetaType(_,_,_),_) + | (PC.TMetaInit(_,_,_),_) | (PC.TMetaStm(_,_,_),_) | (PC.TMetaStmList(_,_,_),_) | (PC.TMetaPos(_,_,_,_),_) -> in_meta_decls @@ -854,7 +858,7 @@ let token2line (tok,_) = | PC.TMetaConst(_,_,_,_,clt) | PC.TMetaExp(_,_,_,_,clt) | PC.TMetaIdExp(_,_,_,_,clt) | PC.TMetaLocalIdExp(_,_,_,_,clt) | PC.TMetaExpList(_,_,_,clt) - | PC.TMetaId(_,_,_,clt) | PC.TMetaType(_,_,clt) + | PC.TMetaId(_,_,_,clt) | PC.TMetaType(_,_,clt) | PC.TMetaInit(_,_,clt) | PC.TMetaStm(_,_,clt) | PC.TMetaStmList(_,_,clt) | PC.TMetaFunc(_,_,_,clt) | PC.TMetaLocalFunc(_,_,_,clt) | PC.TMetaPos(_,_,_,clt) @@ -1026,6 +1030,30 @@ these vanish after the parser, but keeping all the ...s in the + code makes it easier to align the + and - code in context_neg and in preparation for the isomorphisms. This shouldn't matter because the context code of the + slice is mostly ignored anyway *) +let minus_to_nothing l = + (* for cases like | <..., which may or may not arise from removing minus + code, depending on whether <... is a statement or expression *) + let is_minus tok = + try + let (d,_,_,_,_,_,_,_) = get_clt tok in + (match d with + D.MINUS | D.OPTMINUS | D.UNIQUEMINUS -> true + | D.PLUS -> false + | D.CONTEXT | D.UNIQUE | D.OPT -> false) + with _ -> false in + let rec minus_loop = function + [] -> [] + | (d::ds) as l -> if is_minus d then minus_loop ds else l in + let rec loop = function + [] -> [] + | ((PC.TMid0(clt),i) as x)::t1::ts when is_minus t1 -> + (match minus_loop ts with + ((PC.TOEllipsis(_),_)::_) | ((PC.TPOEllipsis(_),_)::_) + | ((PC.TEllipsis(_),_)::_) as l -> x::(PC.TNothing,i)::(loop l) + | l -> x::(loop l)) + | t::ts -> t::(loop ts) in + loop l + let rec drop_double_dots l = let start = function (PC.TOEllipsis(_),_) | (PC.TPOEllipsis(_),_) @@ -1037,7 +1065,7 @@ let rec drop_double_dots l = | _ -> false in let whenline = function (PC.TLineEnd(_),_) -> true - | (PC.TMid0(_),_) -> true + (*| (PC.TMid0(_),_) -> true*) | _ -> false in let final = function (PC.TCEllipsis(_),_) | (PC.TPCEllipsis(_),_) @@ -1349,7 +1377,9 @@ let parse file = (* get transformation rules *) let (more, tokens) = get_tokens [PC.TArobArob; PC.TArob] in - let (minus_tokens, plus_tokens) = split_token_stream tokens in + let (minus_tokens, _) = split_token_stream tokens in + let (_, plus_tokens) = + split_token_stream (minus_to_nothing tokens) in let minus_tokens = consume_minus_positions minus_tokens in let minus_tokens = prepare_tokens minus_tokens in diff --git a/parsing_cocci/parser_cocci_menhir.ml b/parsing_cocci/parser_cocci_menhir.ml index 17852c9..803d8b3 100644 --- a/parsing_cocci/parser_cocci_menhir.ml +++ b/parsing_cocci/parser_cocci_menhir.ml @@ -125,14 +125,14 @@ type token = # 126 "parser_cocci_menhir.ml" ) | TXor of ( -# 91 "parser_cocci_menhir.mly" +# 92 "parser_cocci_menhir.mly" (Data.clt) # 131 "parser_cocci_menhir.ml" ) | TWords | TWhy0 | TWhy of ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) # 138 "parser_cocci_menhir.ml" ) @@ -142,17 +142,17 @@ type token = # 143 "parser_cocci_menhir.ml" ) | TWhenTrue of ( -# 73 "parser_cocci_menhir.mly" +# 74 "parser_cocci_menhir.mly" (Data.clt) # 148 "parser_cocci_menhir.ml" ) | TWhenFalse of ( -# 73 "parser_cocci_menhir.mly" +# 74 "parser_cocci_menhir.mly" (Data.clt) # 153 "parser_cocci_menhir.ml" ) | TWhen of ( -# 73 "parser_cocci_menhir.mly" +# 74 "parser_cocci_menhir.mly" (Data.clt) # 158 "parser_cocci_menhir.ml" ) @@ -165,7 +165,7 @@ type token = ) | TType | TTilde of ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) # 171 "parser_cocci_menhir.ml" ) @@ -175,12 +175,12 @@ type token = # 176 "parser_cocci_menhir.ml" ) | TString of ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) # 181 "parser_cocci_menhir.ml" ) | TStrict of ( -# 73 "parser_cocci_menhir.mly" +# 74 "parser_cocci_menhir.mly" (Data.clt) # 186 "parser_cocci_menhir.ml" ) @@ -191,12 +191,12 @@ type token = # 192 "parser_cocci_menhir.ml" ) | TShOp of ( -# 95 "parser_cocci_menhir.mly" +# 96 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) # 197 "parser_cocci_menhir.ml" ) | TScriptData of ( -# 70 "parser_cocci_menhir.mly" +# 71 "parser_cocci_menhir.mly" (string) # 202 "parser_cocci_menhir.ml" ) @@ -215,116 +215,116 @@ type token = ) | TPure | TPtrOp of ( -# 103 "parser_cocci_menhir.mly" +# 104 "parser_cocci_menhir.mly" (Data.clt) # 221 "parser_cocci_menhir.ml" ) | TPtVirg of ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) # 226 "parser_cocci_menhir.ml" ) | TPragma of ( -# 78 "parser_cocci_menhir.mly" +# 79 "parser_cocci_menhir.mly" (string) # 231 "parser_cocci_menhir.ml" ) | TPosition | TPosAny | TPlusFile of ( -# 82 "parser_cocci_menhir.mly" +# 83 "parser_cocci_menhir.mly" (string * Data.clt) # 238 "parser_cocci_menhir.ml" ) | TPlus0 | TPlus of ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) # 244 "parser_cocci_menhir.ml" ) | TPathIsoFile of ( -# 78 "parser_cocci_menhir.mly" +# 79 "parser_cocci_menhir.mly" (string) # 249 "parser_cocci_menhir.ml" ) | TParameter | TPOEllipsis of ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) # 255 "parser_cocci_menhir.ml" ) | TPCEllipsis of ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) # 260 "parser_cocci_menhir.ml" ) | TPArob | TOrLog of ( -# 88 "parser_cocci_menhir.mly" +# 89 "parser_cocci_menhir.mly" (Data.clt) # 266 "parser_cocci_menhir.ml" ) | TOr of ( -# 90 "parser_cocci_menhir.mly" +# 91 "parser_cocci_menhir.mly" (Data.clt) # 271 "parser_cocci_menhir.ml" ) | TOn | TOPar0 of ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) # 277 "parser_cocci_menhir.ml" ) | TOPar of ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) # 282 "parser_cocci_menhir.ml" ) | TOInit of ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) # 287 "parser_cocci_menhir.ml" ) | TOEllipsis of ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) # 292 "parser_cocci_menhir.ml" ) | TOCro of ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) # 297 "parser_cocci_menhir.ml" ) | TOBrace of ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) # 302 "parser_cocci_menhir.ml" ) | TNothing | TNotEq of ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) # 308 "parser_cocci_menhir.ml" ) | TNever | TName | TMul of ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) # 315 "parser_cocci_menhir.ml" ) | TMinusFile of ( -# 82 "parser_cocci_menhir.mly" +# 83 "parser_cocci_menhir.mly" (string * Data.clt) # 320 "parser_cocci_menhir.ml" ) | TMinus of ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) # 325 "parser_cocci_menhir.ml" ) | TMid0 of ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) # 330 "parser_cocci_menhir.ml" ) @@ -344,12 +344,12 @@ type token = # 345 "parser_cocci_menhir.ml" ) | TMetaPos of ( -# 67 "parser_cocci_menhir.mly" +# 68 "parser_cocci_menhir.mly" (Parse_aux.pos_info) # 350 "parser_cocci_menhir.ml" ) | TMetaParamList of ( -# 65 "parser_cocci_menhir.mly" +# 66 "parser_cocci_menhir.mly" (Parse_aux.list_info) # 355 "parser_cocci_menhir.ml" ) @@ -359,7 +359,7 @@ type token = # 360 "parser_cocci_menhir.ml" ) | TMetaLocalIdExp of ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) # 365 "parser_cocci_menhir.ml" ) @@ -372,63 +372,68 @@ type token = # 62 "parser_cocci_menhir.mly" (Parse_aux.idinfo) # 375 "parser_cocci_menhir.ml" +) + | TMetaInit of ( +# 65 "parser_cocci_menhir.mly" + (Parse_aux.info) +# 380 "parser_cocci_menhir.ml" ) | TMetaIdExp of ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 380 "parser_cocci_menhir.ml" +# 385 "parser_cocci_menhir.ml" ) | TMetaId of ( # 61 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 385 "parser_cocci_menhir.ml" +# 390 "parser_cocci_menhir.ml" ) | TMetaFunc of ( # 61 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 390 "parser_cocci_menhir.ml" +# 395 "parser_cocci_menhir.ml" ) | TMetaExpList of ( -# 65 "parser_cocci_menhir.mly" +# 66 "parser_cocci_menhir.mly" (Parse_aux.list_info) -# 395 "parser_cocci_menhir.ml" +# 400 "parser_cocci_menhir.ml" ) | TMetaExp of ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 400 "parser_cocci_menhir.ml" +# 405 "parser_cocci_menhir.ml" ) | TMetaErr of ( # 63 "parser_cocci_menhir.mly" (Parse_aux.expinfo) -# 405 "parser_cocci_menhir.ml" +# 410 "parser_cocci_menhir.ml" ) | TMetaDeclarer of ( # 62 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 410 "parser_cocci_menhir.ml" +# 415 "parser_cocci_menhir.ml" ) | TMetaConst of ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 415 "parser_cocci_menhir.ml" +# 420 "parser_cocci_menhir.ml" ) | TMPtVirg | TLogOp of ( -# 94 "parser_cocci_menhir.mly" +# 95 "parser_cocci_menhir.mly" (Ast_cocci.logicalOp * Data.clt) -# 421 "parser_cocci_menhir.ml" +# 426 "parser_cocci_menhir.ml" ) | TLocal | TLineEnd of ( -# 73 "parser_cocci_menhir.mly" +# 74 "parser_cocci_menhir.mly" (Data.clt) -# 427 "parser_cocci_menhir.ml" +# 432 "parser_cocci_menhir.ml" ) | TIteratorId of ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 432 "parser_cocci_menhir.ml" +# 437 "parser_cocci_menhir.ml" ) | TIterator | TIsoType @@ -441,60 +446,61 @@ type token = | TIso | TInvalid | TInt of ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 447 "parser_cocci_menhir.ml" +# 452 "parser_cocci_menhir.ml" ) + | TInitialiser | TIncludeNL of ( -# 79 "parser_cocci_menhir.mly" +# 80 "parser_cocci_menhir.mly" (string * Data.clt) -# 452 "parser_cocci_menhir.ml" +# 458 "parser_cocci_menhir.ml" ) | TIncludeL of ( -# 79 "parser_cocci_menhir.mly" +# 80 "parser_cocci_menhir.mly" (string * Data.clt) -# 457 "parser_cocci_menhir.ml" +# 463 "parser_cocci_menhir.ml" ) | TInc of ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 462 "parser_cocci_menhir.ml" +# 468 "parser_cocci_menhir.ml" ) | TIf of ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 467 "parser_cocci_menhir.ml" +# 473 "parser_cocci_menhir.ml" ) | TIdentifier | TIdent of ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 473 "parser_cocci_menhir.ml" +# 479 "parser_cocci_menhir.ml" ) | TIdExpression | TGoto of ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 479 "parser_cocci_menhir.ml" +# 485 "parser_cocci_menhir.ml" ) | TGenerated | TFunction | TFunDecl of ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 486 "parser_cocci_menhir.ml" +# 492 "parser_cocci_menhir.ml" ) | TFresh | TForall | TFor of ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 493 "parser_cocci_menhir.ml" +# 499 "parser_cocci_menhir.ml" ) | TFloat of ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 498 "parser_cocci_menhir.ml" +# 504 "parser_cocci_menhir.ml" ) | TExtends | TExpression @@ -502,152 +508,152 @@ type token = | TEver | TError | TEqEq of ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 508 "parser_cocci_menhir.ml" +# 514 "parser_cocci_menhir.ml" ) | TEq of ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 513 "parser_cocci_menhir.ml" +# 519 "parser_cocci_menhir.ml" ) | TElse of ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 518 "parser_cocci_menhir.ml" +# 524 "parser_cocci_menhir.ml" ) | TEllipsis of ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 523 "parser_cocci_menhir.ml" +# 529 "parser_cocci_menhir.ml" ) | TDotDot of ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 528 "parser_cocci_menhir.ml" +# 534 "parser_cocci_menhir.ml" ) | TDot of ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 533 "parser_cocci_menhir.ml" +# 539 "parser_cocci_menhir.ml" ) | TDo of ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 538 "parser_cocci_menhir.ml" +# 544 "parser_cocci_menhir.ml" ) | TDmOp of ( -# 96 "parser_cocci_menhir.mly" +# 97 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 543 "parser_cocci_menhir.ml" +# 549 "parser_cocci_menhir.ml" ) | TDisable | TDepends | TDefineParam of ( -# 81 "parser_cocci_menhir.mly" +# 82 "parser_cocci_menhir.mly" (Data.clt * token * int) -# 550 "parser_cocci_menhir.ml" +# 556 "parser_cocci_menhir.ml" ) | TDefine of ( -# 80 "parser_cocci_menhir.mly" +# 81 "parser_cocci_menhir.mly" (Data.clt * token) -# 555 "parser_cocci_menhir.ml" +# 561 "parser_cocci_menhir.ml" ) | TDefault of ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 560 "parser_cocci_menhir.ml" +# 566 "parser_cocci_menhir.ml" ) | TDeclarerId of ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 565 "parser_cocci_menhir.ml" +# 571 "parser_cocci_menhir.ml" ) | TDeclarer | TDec of ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 571 "parser_cocci_menhir.ml" +# 577 "parser_cocci_menhir.ml" ) | TContinue of ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 576 "parser_cocci_menhir.ml" +# 582 "parser_cocci_menhir.ml" ) | TContext | TConstant | TComma of ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 583 "parser_cocci_menhir.ml" +# 589 "parser_cocci_menhir.ml" ) | TChar of ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 588 "parser_cocci_menhir.ml" +# 594 "parser_cocci_menhir.ml" ) | TCase of ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 593 "parser_cocci_menhir.ml" +# 599 "parser_cocci_menhir.ml" ) | TCPar0 of ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 598 "parser_cocci_menhir.ml" +# 604 "parser_cocci_menhir.ml" ) | TCPar of ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 603 "parser_cocci_menhir.ml" +# 609 "parser_cocci_menhir.ml" ) | TCEllipsis of ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 608 "parser_cocci_menhir.ml" +# 614 "parser_cocci_menhir.ml" ) | TCCro of ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 613 "parser_cocci_menhir.ml" +# 619 "parser_cocci_menhir.ml" ) | TCBrace of ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 618 "parser_cocci_menhir.ml" +# 624 "parser_cocci_menhir.ml" ) | TBreak of ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 623 "parser_cocci_menhir.ml" +# 629 "parser_cocci_menhir.ml" ) | TBang0 | TBang of ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 629 "parser_cocci_menhir.ml" +# 635 "parser_cocci_menhir.ml" ) | TAssign of ( -# 107 "parser_cocci_menhir.mly" +# 108 "parser_cocci_menhir.mly" (Ast_cocci.assignOp * Data.clt) -# 634 "parser_cocci_menhir.ml" +# 640 "parser_cocci_menhir.ml" ) | TArobArob | TArob | TAny of ( -# 73 "parser_cocci_menhir.mly" +# 74 "parser_cocci_menhir.mly" (Data.clt) -# 641 "parser_cocci_menhir.ml" +# 647 "parser_cocci_menhir.ml" ) | TAndLog of ( -# 89 "parser_cocci_menhir.mly" +# 90 "parser_cocci_menhir.mly" (Data.clt) -# 646 "parser_cocci_menhir.ml" +# 652 "parser_cocci_menhir.ml" ) | TAnd of ( -# 92 "parser_cocci_menhir.mly" +# 93 "parser_cocci_menhir.mly" (Data.clt) -# 651 "parser_cocci_menhir.ml" +# 657 "parser_cocci_menhir.ml" ) | EOF @@ -666,166 +672,170 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct fun _tok -> match _tok with | EOF -> - 168 + 170 | TAnd _ -> - 167 + 169 | TAndLog _ -> - 166 + 168 | TAny _ -> - 165 + 167 | TArob -> - 164 + 166 | TArobArob -> - 163 + 165 | TAssign _ -> - 162 + 164 | TBang _ -> - 161 + 163 | TBang0 -> - 160 + 162 | TBreak _ -> - 159 + 161 | TCBrace _ -> - 158 + 160 | TCCro _ -> - 157 + 159 | TCEllipsis _ -> - 156 + 158 | TCPar _ -> - 155 + 157 | TCPar0 _ -> - 154 + 156 | TCase _ -> - 153 + 155 | TChar _ -> - 152 + 154 | TComma _ -> - 151 + 153 | TConstant -> - 150 + 152 | TContext -> - 149 + 151 | TContinue _ -> - 148 + 150 | TDec _ -> - 147 + 149 | TDeclarer -> - 146 + 148 | TDeclarerId _ -> - 145 + 147 | TDefault _ -> - 144 + 146 | TDefine _ -> - 143 + 145 | TDefineParam _ -> - 142 + 144 | TDepends -> - 141 + 143 | TDisable -> - 140 + 142 | TDmOp _ -> - 139 + 141 | TDo _ -> - 138 + 140 | TDot _ -> - 137 + 139 | TDotDot _ -> - 136 + 138 | TEllipsis _ -> - 135 + 137 | TElse _ -> - 134 + 136 | TEq _ -> - 133 + 135 | TEqEq _ -> - 132 + 134 | TError -> - 131 + 133 | TEver -> - 130 + 132 | TExists -> - 129 + 131 | TExpression -> - 128 + 130 | TExtends -> - 127 + 129 | TFloat _ -> - 126 + 128 | TFor _ -> - 125 + 127 | TForall -> - 124 + 126 | TFresh -> - 123 + 125 | TFunDecl _ -> - 122 + 124 | TFunction -> - 121 + 123 | TGenerated -> - 120 + 122 | TGoto _ -> - 119 + 121 | TIdExpression -> - 118 + 120 | TIdent _ -> - 117 + 119 | TIdentifier -> - 116 + 118 | TIf _ -> - 115 + 117 | TInc _ -> - 114 + 116 | TIncludeL _ -> - 113 + 115 | TIncludeNL _ -> - 112 + 114 + | TInitialiser -> + 113 | TInt _ -> - 111 + 112 | TInvalid -> - 110 + 111 | TIso -> - 109 + 110 | TIsoArgExpression -> - 108 + 109 | TIsoDeclaration -> - 107 + 108 | TIsoExpression -> - 106 + 107 | TIsoStatement -> - 105 + 106 | TIsoTestExpression -> - 104 + 105 | TIsoTopLevel -> - 103 + 104 | TIsoType -> - 102 + 103 | TIterator -> - 101 + 102 | TIteratorId _ -> - 100 + 101 | TLineEnd _ -> - 99 + 100 | TLocal -> - 98 + 99 | TLogOp _ -> - 97 + 98 | TMPtVirg -> - 96 + 97 | TMetaConst _ -> - 95 + 96 | TMetaDeclarer _ -> - 94 + 95 | TMetaErr _ -> - 93 + 94 | TMetaExp _ -> - 92 + 93 | TMetaExpList _ -> - 91 + 92 | TMetaFunc _ -> - 90 + 91 | TMetaId _ -> - 89 + 90 | TMetaIdExp _ -> + 89 + | TMetaInit _ -> 88 | TMetaIterator _ -> 87 @@ -1122,6 +1132,8 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct Obj.repr _v | TIncludeNL _v -> Obj.repr _v + | TInitialiser -> + Obj.repr () | TInt _v -> Obj.repr _v | TInvalid -> @@ -1170,6 +1182,8 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct Obj.repr _v | TMetaIdExp _v -> Obj.repr _v + | TMetaInit _v -> + Obj.repr _v | TMetaIterator _v -> Obj.repr _v | TMetaLocalFunc _v -> @@ -1346,19 +1360,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct Obj.repr _v let default_reduction = - (16, "\000\000\000\000\001/\0010\000\000\0012\0011\000\001\000\000\001j\000\000\000\000\000\136\000\000\000\000\001\229\000\142\000\000\001\019\000\000\001\030\001\022\001\016\001(\002\212\002\211\000\000\001\020\000\000\001\031\001\023\001\017\001)\001\021\000\000\001 \001\024\001\026\000\000\001,\002~\001+\001!\001\025\000\135\001\018\001'\000\000\000\000\001&\000\000\000\000\000\000\000\000\000\000\001^\000\235\002\202\000\000\000\000\000\000\000\000\000\000\002\207\000\000\001#\000\000\002\209\000\000\000\000\000\000\003\015\002H\000\000\003\013\000\000\002b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\012\003\014\002N\001\007\002M\001\005\001\006\002L\002K\002J\002F\000\000\000\000\002G\000\208\000\000\002I\000\000\003\011\000\000\002\242\001\004\002)\000\000\000\000\002,\000\000\000\015\000\000\000\000\000\000\000\000\000\209\002E\002Q\000[\000\021\000]\000\000\000\000\000c\000\000\000\000\000\000\000\000\000\000\000\000\000\022\000\000\000\023\000\000\000\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\002\n\000R\000\218\000^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\\\000T\000\000\000S\001\015\000\000\000\000\000\140\000\219\000\000\002/\000\220\000\014\000\016\000\000\000\000\000\143\000\000\000\141\000\000\000\000\000\223\000\000\000\000\002*\002-\000\000\002+\002.\002\243\002\241\000\000\002O\002\240\000\000\002i\000\000\000\000\002h\002g\002f\002e\002d\002`\000\000\000\000\002a\000\000\002c\000\000\000\000\003\000\0027\000\000\000\000\002:\000\000\000\000\002=\000\000\000\000\0028\002;\000\000\0029\002<\002k\002_\003\001\002\255\002\254\000g\000h\000\000\000\000\000W\000\000\000V\000\230\000\000\001\221\000\000\000\000\000\000\000\000\000\000\000\213\001\227\000\000\000\000\001\130\000U\0001\000\206\000_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\000\000\0003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002P\000\000\000\144\000\000\000\000\001\205\000\000\001x\001\186\000\000\000\000\001\204\000\000\001v\001\185\000\000\000\000\000d\000\000\002j\000\000\000\000\003\003\003\002\000\000\001\222\000\000\000\000\002\245\002\244\000\000\000Q\000\150\000\000\001`\000\000\002\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\154\000\000\000\000\000n\000o\001\240\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\163\001\210\000\000\000\151\000\158\000\000\001\212\000\000\000\000\000\000\000\000\000\152\000\164\000\000\001f\000\000\000\000\002\204\000\000\000\000\000\138\000\000\000\000\002\203\000\000\000\000\000\000\002\206\002\210\000\000\000\000\000\000\001$\000\000\000\217\000\000\001%\000\000\000\000\001I\000\000\001H\000\000\001V\000\000\001l\000\000\000\000\000\000\000\000\000\000\000\000\001\011\000\000\000\000\000\147\000\000\000\000\000\000\000\000\000\149\000\000\000\145\000\000\002\238\000\000\000\192\002\237\000\000\000\000\000\148\000\000\000\146\002\198\002\200\002\201\002\199\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002o\000\000\000\000\000\000\000\000\002v\000\000\000\000\002u\002t\002s\002r\002q\001E\002m\000\000\000\000\002n\000\000\002p\000\000\000\000\003\007\002>\000\000\000\000\002A\000\000\000\000\002D\000\000\000\000\002?\002B\000\000\002@\002C\002x\002l\003\008\003\006\003\005\000i\000j\000\000\000\000\000Z\000\000\000Y\000\000\002w\000\000\001\187\000X\000?\000\229\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\n\003\t\000\000\002\189\000\000\002\188\000\000\000\000\000\000\000\000\003\022\000\000\000\000\000\000\003\023\000\000\000\018\000\000\000\000\000\000\003\018\000\000\001\132\000\000\000\000\000\000\000\165\002\179\001\\\000\000\000\156\001[\0014\0013\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\210\000\211\000\198\000\000\001h\000\000\000\000\000\197\000\193\000\000\000\200\000\194\000\199\000\000\002\191\000\000\002\190\002\176\000\000\000\000\000\000\000\000\000\000\002\185\000\000\000\000\000\000\000\000\000\000\002\186\002\178\000\000\002\192\000\000\002\180\000\000\000\169\000\000\002\195\000\155\000\000\0016\000\000\000\000\000\000\000\000\000\000\000\000\001\012\000\000\000w\000\000\000\000\000\000\002U\000\000\000\000\000\000\002]\000\000\000\000\002\\\000\000\002\252\002[\002Z\002Y\002X\002W\002S\000\000\000\000\002T\000\000\002V\000\000\000\000\002\249\0020\000\000\000\000\0023\000\000\000\000\0026\000\000\000\000\0021\0024\000\000\0022\0025\002^\002R\002\250\002\248\002\247\002\251\000\000\000\000\000\000\000e\000f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\215\0017\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\000\000\000\000$\000\000\000%\000\000\000\000\000\000\000\000\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<\001A\000\000\001;\000\000\000\000\001C\000\000\000\000\000\000\000\000\000\000\000\000\000t\000q\000r\001D\001@\000\000\000\000\001?\0019\000\000\0018\000\000\000\185\000\000\002\157\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\188\000\000\000\000\000\191\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\n\000\000\000\000\000\000\000\178\000\000\000\175\000\000\000\000\000\000\000\000\000\000\000\186\000\000\000\182\000\000\000\000\002\216\000\000\002\223\000\171\000\000\000\000\000\000\000\000\000\183\000\000\000\179\000\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\190\000\000\002\217\000\170\000\000\002\218\000\000\002\225\000\000\000\000\000\000\000\000\000\189\000\000\000\173\000\000\000\000\000\000\000\000\001\t\000\000\000\000\000\000\000\177\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\184\000\000\000\180\000\167\000\166\000\000\002\226\002\227\000\000\002\228\000\000\002\229\000\000\0015\002\183\000\000\000\000\001\209\000\000\001\128\001\191\000\000\002\177\000\000\000\000\000\000\002\182\000\000\000\000\000\000\000\253\000\000\000\247\000\000\000\248\000\000\001\002\000\246\001\001\000\000\002\194\001\003\000\000\000\172\000\000\000\000\000\000\000\000\000\255\000\250\001\206\000\000\000\251\000\000\000\252\000\000\001z\001\188\000\000\000\000\000\000\001\217\000\000\001\215\000\000\000\000\001\219\001\213\000\000\001\220\001\214\000\000\002\196\001\223\000\000\000\168\000\000\000\000\001\207\000\000\001|\001\189\000\000\003\019\000\000\003\016\000\000\003\017\000\019\000\020\000\000\000\000\002\141\000\000\002\140\000\000\000\000\002\143\000\000\002\142\000\000\000\000\000\000\001\250\000\000\000\000\001\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\001\000\000\000\000\002\004\000\000\000\000\001\244\000\000\000\000\001\247\000\000\000\000\000\000\001\251\000\000\000\000\001\255\000\000\000\000\001\208\000\000\000\000\001\248\000\000\000\000\001\252\002\138\001\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\002\003\000\000\002\139\000\000\000\000\000\000\000\000\002\002\000\000\001\242\000\000\001\243\000\000\000\000\001\246\000\000\000\000\000\000\001\249\000\000\000\000\001\253\000\000\001~\001\190\000\000\002\144\000\000\000\000\000\000\003\020\000\017\000u\000\000\003\021\000\000\000\000\002\153\000\000\000\000\002\197\000a\000\000\000\000\000\000\000b\000\000\002\187\000\000\001b\002\184\000\000\000\000\001O\000\000\001N\000\000\001W\000\000\001r\000\000\000\000\000\000\001M\000\000\001L\000\000\001T\000\000\001p\000\000\000\000\000\000\001Q\000\000\001P\000\000\001U\000\000\001t\000\000\000\000\000\000\001R\000\000\000\000\000\000\000\000\001K\000\000\001J\000\000\001X\000\000\001n\000\000\000\000\000\000\001S\000\002\000\000\000N\000O\000M\001Y\000\003\000\000\000\000\002{\000\000\002\008\000\000\002\129\002\131\000\000\000\000\001\155\002\132\002\130\000\128\000\000\000\000\002\175\000\000\000\000\000\000\000z\000\000\000\000\002\163\000\000\001\237\001\236\001\150\002\136\002\127\002\128\000\000\001\182\000\000\002|\000\000\000\000\000|\000\000\000\000\002\167\000\000\001\164\000\000\000\000\001\161\000\000\000\000\000\000\001\163\000\000\001\162\000\000\000\000\000\000\000\000\000\000\000\000\001\183\000\000\001\159\000\000\001\158\000\000\000v\000\000\000\000\002\155\000\000\000\000\001\154\000\000\000\000\000~\000\000\000\000\002\171\000\000\000\000\000\000\000{\000\000\000\000\002\165\000\000\001\233\001\232\001\146\002\134\000\000\001\169\000\000\000\000\000\000\001\166\000\000\001\171\000\000\000\000\001\167\000\000\000\000\001\168\000\000\000\000\000\000\001\157\000\000\000\000\000\000\000\000\000\000\000\000\001\184\000\000\001\160\000}\000\000\000\000\002\169\000\000\000\000\000\000\001.\000y\001-\000\000\000\000\002\161\000\000\001\231\001\230\001\144\002\133\000\000\000\127\000\000\000\000\002\173\000\000\000\000\000\000\000\000\001\235\001\234\001\148\002\135\000\000\001\176\000\000\001\180\000\000\000\000\001\172\000\000\000\000\000\000\001\165\000\000\001\170\000\000\000\000\000\000\000\000\000\000\000\000\001\179\001\153\000\000\001\178\000\000\000\000\000\000\000\000\001\175\000\000\000\000\001\174\000\000\001\173\000\000\000\000\000\000\000\000\001\177\000\000\001\181\000\000\000\000\001Z\000\004\000\000\001\156\000\005\000\000\000\000\000\233\000\006\000\000\001\195\001\196\001\194\000\000\000\000\000\000\000\000\000\000\000\000\000x\000\000\000\000\002\159\000\000\000\224\001\193\001\138\002\213\001\140\000\000\000\007\000\000\001\198\001\199\001\197\000\000\000\000\000\000\000\000\000\000\000\000\000\234\000\237\000\000\000\000\000\000\000\000\000\242\000\244\000\243\000\238\000\240\000\239\000\000\000\000\000\000\000\000\000\000\002\219\002\232\000\000\002\220\000\000\002\221\000\000\000\000\002\214\000\000\000\000\000\000\000\000\002\231\000\000\000\000\002\230\001\203\001\202\000\000\000\000\001\142\000\000\001\192\001\200\000\000\000\000\000\000\000\000\001\239\000\000\000\000\000l\000m\000\000\000\000\000\000\001\238\000\000\000\161\000\000\001d\000\000\000\000\000\160\000\157\000\000\000\000\000\000\000\000\001\008\000\000\000\000\002\235\000\000\002\236\000\000\000\000\001\226\001\224\000\000\001\225\000\008\000\000\000\t\000\000\002\025\002\026\002\024\000\000\000\000\002\023\000\000\000\n\000\000\002\028\002\029\002\027\000\000\002\031\000\000\000\000\000\000\002\017\000\000\000\000\002\019\000\000\002\013\000\000\002\015\000\000\002\020\000\000\002\021\002\014\002\012\002 \001\152\000\000\002\022\000\000\002\"\000\000\002!\000\000\002#\000\000\002\137\000\011\000\000\000\000\000\000\000\000\000\000\000\000\002$\000\000\000\000\002'\000\000\002&\000\000\002%\000\201\000\000\000\000\000\000\000\000\000\202\002(\000\000\000\000\002\148\000\000\000\000\000\232\000\000\000\000\000\000\000\000\000\000\002\151\000k\000\000\000\000\000\207\000\000\000\000\000\227\000\226\000\225\000\000\001G\000\000\002\147\001\136\001\134\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\146\000\000\000\000\000\000\000\000\000\000\000\000\002\145\000\000\000\013\000\000\000\000\000\000\000\000\000\000\002\149") + (16, "\000\000\000\000\0014\0015\000\000\0017\0016\000\001\000\000\001p\000\000\000\000\000\136\000\000\000\000\001\236\000\142\000\000\001\024\000\000\001#\001\027\001\021\001-\002\219\002\218\000\000\001\025\000\000\001$\001\028\001\022\001.\001\026\000\000\001%\001\029\001\031\000\000\0011\002\133\0010\001&\001\030\000\135\001\023\001,\000\000\000\000\001+\000\000\000\000\000\000\000\000\000\000\001b\000\240\002\209\000\000\000\000\000\000\000\000\000\000\002\214\000\000\001(\000\000\002\216\000\000\000\000\000\000\003\022\002O\000\000\003\020\000\000\002i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\019\003\021\002U\001\012\002T\001\n\001\011\002S\002R\002Q\002M\000\000\000\000\002N\000\213\000\000\002P\000\000\003\018\000\000\002\249\001\t\0020\000\000\000\000\0023\000\000\000\015\000\000\000\000\000\000\000\000\000\214\002L\002X\000[\000\021\000]\000\000\000\000\000c\000\000\000\000\000\000\000\000\000\000\000\000\000\022\000\000\000\023\000\000\000\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\002\017\000R\000\223\000^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\\\000T\000\000\000S\001\020\000\000\000\000\000\140\000\224\000\000\0026\000\225\000\014\000\016\000\000\000\000\000\143\000\000\000\141\000\000\000\000\000\228\000\000\000\000\0021\0024\000\000\0022\0025\002\250\002\248\000\000\002V\002\247\000\000\002p\000\000\000\000\002o\002n\002m\002l\002k\002g\000\000\000\000\002h\000\000\002j\000\000\000\000\003\007\002>\000\000\000\000\002A\000\000\000\000\002D\000\000\000\000\002?\002B\000\000\002@\002C\002r\002f\003\008\003\006\003\005\000g\000h\000\000\000\000\000W\000\000\000V\000\235\000\000\001\228\000\000\000\000\000\000\000\000\000\000\000\218\001\234\000\000\000\000\001\136\000U\0001\000\211\000_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\000\000\0003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002W\000\000\000\144\000\000\000\000\001\212\000\000\001~\001\193\000\000\000\000\001\211\000\000\001|\001\192\000\000\000\000\000d\000\000\002q\000\000\000\000\003\n\003\t\000\000\001\229\000\000\000\000\002\252\002\251\000\000\000Q\000\150\000\000\001d\000\000\002\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\248\000\154\000\000\000\000\000n\000o\001\247\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\165\001\217\000\000\000\151\000\160\000\000\001\219\000\000\000\000\000\000\000\000\000\152\000\166\000\000\001j\000\000\000\000\002\211\000\000\000\000\000\138\000\000\000\000\002\210\000\000\000\000\000\000\002\213\002\217\000\000\000\000\000\000\001)\000\000\000\222\000\000\001*\000\000\000\000\001M\000\000\001L\000\000\001Z\000\000\001r\000\000\000\000\000\000\000\000\000\000\000\000\001\016\000\000\000\000\000\147\000\000\000\000\000\000\000\000\000\149\000\000\000\145\000\000\002\245\000\000\000\194\002\244\000\000\000\000\000\148\000\000\000\146\002\205\002\207\002\208\002\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002v\000\000\000\000\000\000\000\000\002}\000\000\000\000\002|\002{\002z\002y\002x\001I\002t\000\000\000\000\002u\000\000\002w\000\000\000\000\003\014\002E\000\000\000\000\002H\000\000\000\000\002K\000\000\000\000\002F\002I\000\000\002G\002J\002\127\002s\003\015\003\013\003\012\000i\000j\000\000\000\000\000Z\000\000\000Y\000\000\002~\000\000\001\194\000X\000?\000\234\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\017\003\016\000\000\002\196\000\000\002\195\000\000\000\000\000\000\000\000\003\029\000\000\000\000\000\000\003\030\000\000\000\018\000\000\000\000\000\000\003\025\000\000\001\138\000\000\000\000\000\000\000\167\002\186\001`\000\000\000\156\001_\0019\0018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\215\000\216\000\200\000\000\001n\000\000\000\000\000\199\000\195\000\000\000\202\000\196\000\201\000\000\002\198\000\000\002\197\002\183\000\000\000\000\000\000\000\000\000\000\002\192\000\000\000\000\000\000\000\000\000\000\002\193\002\185\000\000\002\199\000\000\002\187\000\000\000\171\000\000\002\202\000\155\000\000\001;\000\000\000\000\000\000\000\000\000\000\000\000\001\017\000\000\000w\000\000\000\000\000\000\002\\\000\000\000\000\000\000\002d\000\000\000\000\002c\000\000\003\003\002b\002a\002`\002_\002^\002Z\000\000\000\000\002[\000\000\002]\000\000\000\000\003\000\0027\000\000\000\000\002:\000\000\000\000\002=\000\000\000\000\0028\002;\000\000\0029\002<\002e\002Y\003\001\002\255\002\254\003\002\000\000\000\000\000\000\000e\000f\000\000\000\000\000\000\000\000\000\210\000\209\000\000\000\000\000\000\000\000\001?\000\000\000\220\001<\000\000\000\208\001B\000\000\000\000\001C\000\000\000\000\001D\000\000\001l\000#\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\000\000%\000\000\000\000\000\000\000\000\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\001A\000\000\000\000\001G\000\000\000\000\000\000\000\000\000\000\000\000\000t\000q\000r\001H\001>\000\000\001=\000\000\000\187\000\000\002\164\000\000\000\000\000\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\190\000\000\000\000\000\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\015\000\000\000\000\000\000\000\180\000\000\000\177\000\000\000\000\000\000\000\000\000\000\000\188\000\000\000\184\000\000\000\000\002\223\000\000\002\230\000\173\000\000\000\000\000\000\000\000\000\185\000\000\000\181\000\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\192\000\000\002\224\000\172\000\000\002\225\000\000\002\232\000\000\000\000\000\000\000\000\000\191\000\000\000\175\000\000\000\000\000\000\000\000\001\014\000\000\000\000\000\000\000\179\000\000\000\176\000\000\000\000\000\000\000\000\000\000\000\186\000\000\000\182\000\169\000\168\000\000\002\233\002\234\000\000\002\235\000\000\002\236\000\000\001:\002\190\000\000\000\000\001\216\000\000\001\134\001\198\000\000\002\184\000\000\000\000\000\000\002\189\000\000\000\000\000\000\001\002\000\000\000\252\000\000\000\253\000\000\001\007\000\251\001\006\000\000\002\201\001\008\000\000\000\174\000\000\000\000\000\000\000\000\001\004\000\255\001\213\000\000\001\000\000\000\001\001\000\000\001\128\001\195\000\000\000\000\000\000\001\224\000\000\001\222\000\000\000\000\001\226\001\220\000\000\001\227\001\221\000\000\002\203\001\230\000\000\000\170\000\000\000\000\001\214\000\000\001\130\001\196\000\000\003\026\000\000\003\023\000\000\003\024\000\019\000\020\000\000\000\000\002\148\000\000\002\147\000\000\000\000\002\150\000\000\002\149\000\000\000\000\000\000\002\001\000\000\000\000\002\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\008\000\000\000\000\002\011\000\000\000\000\001\251\000\000\000\000\001\254\000\000\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\001\215\000\000\000\000\001\255\000\000\000\000\002\003\002\145\001\252\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\007\000\000\000\000\002\n\000\000\002\146\000\000\000\000\000\000\000\000\002\t\000\000\001\249\000\000\001\250\000\000\000\000\001\253\000\000\000\000\000\000\002\000\000\000\000\000\002\004\000\000\001\132\001\197\000\000\002\151\000\000\000\000\000\000\003\027\000\017\000u\000\000\003\028\000\000\000\000\002\160\000\000\000\000\002\204\000a\000\000\000\000\000\000\000b\000\000\002\194\000\000\001f\002\191\000\000\000\000\001S\000\000\001R\000\000\001[\000\000\001x\000\000\000\000\000\000\001Q\000\000\001P\000\000\001X\000\000\001v\000\000\000\000\000\000\001U\000\000\001T\000\000\001Y\000\000\001z\000\000\000\000\000\000\001V\000\000\000\000\000\000\000\000\001O\000\000\001N\000\000\001\\\000\000\001t\000\000\000\000\000\000\001W\000\002\000\000\000N\000O\000M\001]\000\003\000\000\000\000\002\130\000\000\002\015\000\000\002\136\002\138\000\000\000\000\001\161\002\139\002\137\000\128\000\000\000\000\002\182\000\000\000\000\000\000\000z\000\000\000\000\002\170\000\000\001\244\001\243\001\156\002\143\002\134\002\135\000\000\001\189\000\000\002\131\000\000\000\000\000|\000\000\000\000\002\174\000\000\001\171\000\000\000\000\001\167\000\000\000\000\000\000\001\170\000\000\001\169\000\000\000\000\000\000\000\000\000\000\000\000\001\190\000\000\001\165\000\000\001\164\000\000\000v\000\000\000\000\002\162\000\000\000\000\001\160\000\000\000\000\000~\000\000\000\000\002\178\000\000\000\000\000\000\000{\000\000\000\000\002\172\000\000\001\240\001\239\001\152\002\141\000\000\001\176\000\000\000\000\000\000\001\173\000\000\001\178\000\000\000\000\001\168\000\000\000\000\001\174\000\000\000\000\001\175\000\000\000\000\000\000\001\163\000\000\000\000\000\000\000\000\000\000\000\000\001\191\000\000\001\166\000}\000\000\000\000\002\176\000\000\000\000\000\000\0013\000y\0012\000\000\000\000\002\168\000\000\001\238\001\237\001\150\002\140\000\000\000\127\000\000\000\000\002\180\000\000\000\000\000\000\000\000\001\242\001\241\001\154\002\142\000\000\001\183\000\000\001\187\000\000\000\000\001\179\000\000\000\000\000\000\001\172\000\000\001\177\000\000\000\000\000\000\000\000\000\000\000\000\001\186\001\159\000\000\001\185\000\000\000\000\000\000\000\000\001\182\000\000\000\000\001\181\000\000\001\180\000\000\000\000\000\000\000\000\001\184\000\000\001\188\000\000\000\000\001^\000\004\000\000\001\162\000\005\000\000\000\000\000\238\000\006\000\000\001\202\001\203\001\201\000\000\000\000\000\000\000\000\000\000\000\000\000x\000\000\000\000\002\166\000\000\000\229\001\200\001\144\002\220\001\146\000\000\000\007\000\000\001\205\001\206\001\204\000\000\000\000\000\000\000\000\000\000\000\000\000\239\000\242\000\000\000\000\000\000\000\000\000\247\000\249\000\248\000\243\000\245\000\244\000\000\000\000\000\000\000\000\000\000\002\226\002\239\000\000\002\227\000\000\002\228\000\000\000\000\002\221\000\000\000\000\000\000\000\000\002\238\000\000\000\000\002\237\001\210\001\209\000\000\000\000\001\148\000\000\001\199\001\207\000\000\000\000\000\000\000\000\001\246\000\000\000\000\000l\000m\000\000\000\000\000\000\001\245\000\000\000\163\000\000\001h\000\000\000\000\000\162\000\158\000\000\000\000\000\000\000\000\001\013\000\000\000\000\002\242\000\000\002\243\000\000\000\000\001\233\001\231\000\000\001\232\000\008\000\000\000\t\000\000\002 \002!\002\031\000\000\000\000\002\030\000\000\000\n\000\000\002#\002$\002\"\000\000\002&\000\000\000\000\000\000\002\024\000\000\000\000\002\026\000\000\002\020\000\000\002\022\000\000\002\027\000\000\002\028\002\021\002\019\002'\001\158\000\000\002\029\000\000\002)\000\000\002(\000\000\002*\000\000\002\144\000\011\000\000\000\000\000\000\000\000\000\000\000\000\002+\000\000\000\000\002.\000\000\002-\000\000\002,\000\203\000\000\000\000\000\000\000\000\000\204\002/\000\000\000\000\002\155\000\000\000\000\000\237\000\000\000\000\000\000\000\000\000\000\002\158\000k\000\000\000\000\000\212\000\000\000\000\000\232\000\231\000\230\000\000\001K\000\000\002\154\001\142\001\140\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\153\000\000\000\000\000\000\000\000\000\000\000\000\002\152\000\000\000\013\000\000\000\000\000\000\000\000\000\000\002\156") let error = - (169, "\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\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\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\254\000\000\000\000\000\000\000\015Z\175\000\008\001\000\000\008\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\1280\128\000\016\204\t\128@\016\016\000@\000\004\200b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\191G\000\016\006\016\000\018\025\1290\008\002\002\016\008\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'P\192\004\001\132\000\004\134`L\002\000\128\132\002\000\000&C\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_\163\128\008\003\008\000\t\012\192\152\004\001\001\008\004\000\000L\134 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019\168`\002\000\194\000\002C0&\001\000@B\001\000\000\019!\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000N\161\128\008\003\008\000\t\012\192\152\004\001\001\008\004\000\000L\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\001\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\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\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\030\181^\000\016\002\000\000\016\000@\000\000\000\000\000\000\000\000\000\000\000%P\192\004\001\132\000\004\198`L\002\000\128\132\002\000\000&C\023\173W\128\004\000\128\000\004\016\016\000\000\000\000@\000\016\000\000\000\000\000\000\000\000\000\000\000\001\000\128\000\000\000\000\000\000\000\000\000\000\000\004\138\024\000\000\000\128\000\128H\t\128@\000\016\128@\000\004\192b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\181^\000\144\002\000\000\016@@\000\000\000\001\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\007\173W\128\004\000\128\000\004\016\016\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\002\000\000\000 \000\000\000\000\000\001\235U\224\001\000 \000\001\004\004\000\000\000\000\016\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\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\181^\000\016\002\000\000\016@@\000\000\000\001\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\004\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\008\128\000\000\000\000\000R\000\002A\160P\027\180\000\004\144\008\004\000B\017\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\n@\000H4\n\003v\128\000\146\001\000\128\008@ \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\002\144\000\018\013\002\128\221\160\000$\128@\000\002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\000\004\131@\1607h\000\t \016\000\000\132\002\008\000\000\000\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\004\000\000\000\000)\000\001 \208(\013\218\000\002H\004\002\000!\000\130z\213x\000T\136\000\144h\021\006\237\000\001$\002\001\000\016\128A=j\188\000*D\000H4\n\131v\128\000\146\001\000\128\008@ \128\000\000\000\005 \000$\026\005\001\187@\000I\000\128\000\004 \016OZ\175\000\n\145\000\018\013\002\160\221\160\000$\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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 \208(\013\218\000\002H\004\002\000!\000\130\000\000\000\000\020\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\144\000\018\013\002\128\221\160\000$\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\000\004\131@\1607h\000\t \016\008\000\132\002\008\000\000\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 \208(\013\218\000\002H\004\002\000!\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\008\140\019e\146\192\000\n\000\132\000\003\186\002'\135p\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\001\235U\224\001R \002A\160T\027\244\000\004\144\008\004\000BA\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@ \131\000\150\000\000P\000\000\000\029\144\0014;\128\000\000\000\n@\000H4\n\003v\128\000\146\001\000\128\008@ \128\000\000H\000\017\008&\194%\128\000\020\001\000\000\007d\000O\014\224\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\017\008&\194%\128\000\020\001\000\000\006d\000O\006\224\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@ \002\016\008 \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\002!\004\216D\176\000\002\128 \000\000\204\128\t\224\220\000\000\000\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\004\000\000\002@\000\136A6\017,\000\000\160\008\000\0003 \002x7\000\000\000\000\020\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\000\000\000\144\000\"\016M\132K\000\000(\002\000\000\012\200\000\158\013\192\000\000\000\005 \000$\026\005\001\187@\000I\000\128@\004 \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\001H\000\t\006\129@n\208\000\018@ \016\001\008\004\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\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\004\000\000\002@\000\136A6\017,\000\000\160\008\000\0003 \002x7\000\000\000\000\020\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\000\000\000\144\000\"\016M\132K\000\000(\002\000\000\012\200\000\158\013\192\000\000\000\005 \000$\026\005\001\187@\000I\000\128@\004 \016@\000\000$\000\008\132\019a\018\192\000\n\000\128\000\0032\000'\131p\000\000\000\001H\000\t\006\129@n\208\000\018@ \016\001\008\004\016\000\000\t\000\002!\004\216D\176\000\002\128 \000\000\204\128\t\224\220\000\000\000\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\004\000\000\002@\000\136A6\017,\000\000\160\008\000\0003 \002x7\000\000\000\000\020\128\000\144h\020\006\237\000\001$\002\001\128\016\128A\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$\026\005\001\187@\000I\000\128@\004 \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\020\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\000\000\000\144\000\"\016M\132K\000\000(\002\000\000\012\200\000\158\013\192\000\000\000\005 \000$\026\005\001\187@\000I\000\128@\004 \016@\000\000$\000\008\132\019a\018\192\000\n\000\128\000\0032\000'\131p\000\000\000\001H\000\t\006\129@n\208\000\018@ \016\001\008\004\016\000\000\t\000\002!\004\216D\176\000\002\128 \000\000\204\128\t\224\220\000\000\000\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\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\n@\000H4\n\003v\128\000\146\001\000\128\008@ \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\128\000\002\000\192\000\000C \000\000\000@@\001\000\000\019 \008\tT0\001\000a\000\001!\152\019\000\128 !\000\128\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\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\214\171@\002\000@\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\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\000 \012 \000\0042\002`\016\004\004\000\016\000\0012\024\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\000D\000\015Z\175\000\n\145\000\018\013\002\160\223\160\000$\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\000\004\131@\1607h\000\t \016\008\000\132\002\008\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\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001H\000\t\006\129@n\208\000\018@ \000\001\008\004\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\002\144\000\018\013\002\128\221\160\000$\128@\000\002\016\008 \000\000\000\001H\000\t\006\129@n\208\000\018@ \016\001\008\004\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\000R\000\002A\160P\027\180\000\004\144\008\000\000B\001\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\020\128\000\144h\020\006\237\000\001$\002\000\000\016\128A\000\000\000\000\n@\000H4\n\003v\128\000\146\001\000\000\008@ \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\018\000\004D\008\178I@\000\004\000B\000\000\213\001\016\1948\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\245\170\240\000\169\016\001 \208*\013\250\000\002H\004\002\000! \130\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\005 \000$\026\005\001\187@\000I\000\128@\004 \016@\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\001\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000D\000\139\000\148\000\000@\004\000\000\013\016\001\012#\128\000\000\000\n@\000H4\n\003v\128\000\146\001\000\128\008@ \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\002\144\000\018\013\002\128\221\160\000$\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\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\000\000\000\000\000\000\000\001\000\000\008\000\000\000\000\001\n@\000H4\n\003v\128\000\146\001\000\000\008@ \128\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@ \002\016\008 \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\001 \208(\013\218\000\002H\004\000\000!\000\130\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\001\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\016\002,\002P\000\001\000\016\000\000$@\0040\014\000\000\000\000)\000\001 \208(\013\218\000\002H\004\000\000!\000\130\000\000\001 \000D\000\139\000\148\000\000@\004\000\000\t\016\001\012\003\128\000\000\000\n@\000H4\n\003v\128\000\146\001\000\000\008@ \128\000\000H\000\017\000\"\192%\000\000\016\001\000\000\002D\000C\000\224\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@\000\002\016\008 \000\000\018\000\004@\008\176\t@\000\004\000@\000\000\145\000\016\1928\000\000\000\000\164\000\004\131@\1607h\000\t \016\000\000\132\002\008\000\000\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 \208(\013\218\000\002H\004\000\000!\000\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\n@\000H4\n\003v\128\000\146\001\000\000\008@ \128\000\000H\000\017\000\"\192%\000\000\016\001\000\000\002D\000C\000\224\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@\000\002\016\008 \000\000\018\000\004@\008\176\t@\000\004\000@\000\000\145\000\016\1928\000\000\000\000\164\000\004\131@\1607h\000\t \016\000\000\132\002\008\000\000\004\128\001\016\002,\002P\000\001\000\016\000\000$@\0040\014\000\000\000\000)\000\001 \208(\013\218\000\002H\004\000\000!\000\130\000\000\001 \000D\000\139\000\148\000\000@\004\000\000\t\016\001\012\003\128\000\000\000\n@\000H4\n\003v\128\000\146\001\000\000\008@ \128\000\000H\000\017\000\"\192%\000\000\016\001\000\000\002D\000C\000\224\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@0\002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\164\000\004\131@\1607h\000\t \016\000\000\132\002\008\000\000\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 \208(\013\218\000\002H\004\000\000!\000\130\000\000\001 \000D\000\139\000\148\000\000@\004\000\000\t\016\001\012\003\128\000\000\000\n@\000H4\n\003v\128\000\146\001\000\000\008@ \128\000\000H\000\017\000\"\192%\000\000\016\001\000\000\002D\000C\000\224\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@\000\002\016\008 \000\000\018\000\004@\008\176\t@\000\004\000@\000\000\145\000\016\1928\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\001\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\005 \000$\026\005\001\187@\000I\000\128@\004 \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\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\004\000\000\000\000\000\000\000\000\000@\000z\213x\000@\008\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\128\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\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\030\181^\000\021\"\000$\026\005A\187@\000I\000\128@\004 \016@\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\000z\213x\000T\136\000\144h\021\006\237\000\001$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\008\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\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$P\192\000\000\004\000\004\002@L\002\000\000\132\002\000\000&\003\016\018(`\000\000\002\000\002\000 &\001\000\000B\001\000\000\019\001\136\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\128\000\000\008\000\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\016\000\000\000\000\000\000\000\000\000\000\000\000\030\181^\000\016\002\000\000\016\000F\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\004\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\004@\000\245\170\240\000\128\016\000\000\128\0020\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\004\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\002\000\000\000 \000\000\000\000\128\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\245\170\240\000\128\016\000\000\128\0020\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\001\016\000=j\188\000 \004\000\000 \000\140\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\004\000\000\000@\000\000\000\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\015Z\175\000\008\001\000\000\008\000#\000\000\000\000\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\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\008\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\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\173W\128\004\000\128\000\004\016\016\000\000\000\000@\000\000\000\000 \003\214\171\192\002\000@\000\002\008\008\000\000\000\000 \000\008\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\128\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\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\181Z\000\016\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\008\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002U\012\000@\024@\000Lf\004\192 \008\008@ \000\002d1z\213x\000@\008\000\000A\001\000\000\000\000\004\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\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\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\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\008\000\000\000\000\000\000\000\008\000\000\000\000\000\000\001z\213x\000@\008\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\030\181^\000\016\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\000\000\000\000\000\000\000\008\000\000\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\016\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\127\245\252\016\\\137\000\128c\021\199\239\008\003\245\006\000#X\129A\000\145C\000\000\000\000\000\016\008\0010\000\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\015Z\175\000\008\001\000\000\008\000#\000\000\000\000\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\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\245\170\240\000\128\016\000\000\128\002\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\021\002\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\n\129\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\007\173W\128\004\000\128\000\004\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\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\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\235U\160\001\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\008\128\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\020\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\004\007 @ \024\133\017\251B\000\253A\128\008\198 P@\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\t\006\129@n\208\000\018@ \016\001\008\004\016\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\008\000\000\000\000\000\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\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000?\250\254\008.D\128H5\n\227\247\132\001\250\131\000\145\236a\160\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\002\144\000\016\012\002\128\221\160\000d\128@\000\002\016\008 \000\000\000\001H\000\008\006\001@n\208\0002@ \000\001\008\004\019\214\171\192\002\164@\004\131@\1687h\000\t \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\n@\000@0\n\003v\128\001\146\001\000\000\008@ \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\n@\000@0\n\003v\128\001\146\001\000\000\008@ \128\000\000\000\005 \000$\026\005\001\187@\000I\000\128@\004 \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\001H\000\008\006\001@n\208\0002@ \000\001\008\004\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\000R\000\002\001\128P\027\180\000\012\144\008\000\000B\001\004\000\000\000\000)\000\001\000\192(\013\218\000\006H\004\000\000!\000\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\000\000\000H\000\017\024&\203%\128\000\020\001\008\000\007T\004\n\014\224\000\000\000\000\000\000\000\000\000\000\008\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\003\214\171\192\002\164@\004\131@\1687\232\000\t \016\008\000\132\130\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\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\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\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\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\004\128\001\016\130l\"X\000\001@\016\000\000t@\000\160\238\000\000\000\000)\000\001 \208(\013\218\000\002H\004\002\000!\000\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\n@\000H4\n\003v\128\000\146\001\000\128\008@ \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\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\016\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\008\132\019a\018\192\000\n\000\128\000\003\"\000\005\003p\000\000\000\001H\000\008\006\001@n\208\0002@ \000\001\008\004\016\000\000\t\000\002!\004\216D\176\000\002\128 \000\000\200\128\001@\220\000\000\000\000R\000\002\001\128P\027\180\000\012\144\008\000\000B\001\004\000\000\002@\000\136A6\017,\000\000\160\008\000\0002 \000P7\000\000\000\000\020\128\000\128`\020\006\237\000\003$\002\000\000\016\128A\000\000\000\144\000\"\016M\132K\000\000(\002\000\000\012\136\000\020\013\192\000\000\000\005 \000 \024\005\001\187@\000\201\000\128\000\004 \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\001H\000\008\006\001@n\208\0002@ \000\001\008\004\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\000R\000\002\001\128P\027\180\000\012\144\008\000\000B\001\004\000\000\002@\000\136A6\017,\000\000\160\008\000\0002 \000P7\000\000\000\000\020\128\000\128`\020\006\237\000\003$\002\000\000\016\128A\000\000\000\144\000\"\016M\132K\000\000(\002\000\000\012\136\000\020\013\192\000\000\000\005 \000 \024\005\001\187@\000\201\000\128\000\004 \016@\000\000$\000\008\132\019a\018\192\000\n\000\128\000\003\"\000\005\003p\000\000\000\001H\000\008\006\001@n\208\0002@ \000\001\008\004\016\000\000\t\000\002!\004\216D\176\000\002\128 \000\000\200\128\001@\220\000\000\000\000R\000\002\001\128P\027\180\000\012\144\008\000\000B\001\004\000\000\002@\000\136A6\017,\000\000\160\008\000\0002 \000P7\000\000\000\000\020\128\000\144h\020\006\237\000\001$\002\001\128\016\128A\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 \024\005\001\187@\000\201\000\128\000\004 \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\001H\000\008\006\001@n\208\0002@ \000\001\008\004\016\000\000\t\000\002!\004\216D\176\000\002\128 \000\000\200\128\001@\220\000\000\000\000R\000\002\001\128P\027\180\000\012\144\008\000\000B\001\004\000\000\002@\000\136A6\017,\000\000\160\008\000\0002 \000P7\000\000\000\000\020\128\000\128`\020\006\237\000\003$\002\000\000\016\128A\000\000\000\144\000\"\016M\132K\000\000(\002\000\000\012\136\000\020\013\222\181^\000\021\"\000$\026\005A\187@\000I\000\128@\004 \016@\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\000R\000\130A\160P\027\180\000\004\144\008\004\000B\001\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\031\253\127\007\151\"@ \024\197q\251\194\000\253A\128\008\214 P@\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\t\006\129@n\208\000\018@ \016\001\008\004\016\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\008\128\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\175\224\130\228H\004\003\016\174?x@\031\1680\001\026\196\n\t\255\215\240Ar$\002A\168_\031\188 \015\212\024\004\141b\133\004\255\235\248<\185\018\001\000\198+\143\222\016\007\234\012\000F\177\002\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\251\255\015.D\128@1\139\227\247\140\001\250\147\008\017\236q\172\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\254\191\130\011\145 \016\012b\184\253\225\000~\160\192\004k\016('\255_\193\005\200\144\t\006\161|~\240\128?P`\0185\138\020\019\255\175\224\130\228H\004\131P\174?x@\031\1680\t\026\196\026\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\"0M\150K\000\000(\002\016\000\014\232\008\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001 \208(\013\218\000\002H\004\002\000!\000\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\008\014@\128@1\n#\246\132\001\250\131\000\017\140@\160\128\000\000\004\007 @ \024\133\017\251B\000\253A\128\008\198 P@\000\000\000\000\000\000\000\000\000\000\008\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\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)\000A \208(\013\218\000\002H\004\002\000!\000\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\n@\016H4\n\003v\128\000\146\001\000\128\008@ \128\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@ \002\018\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\128\228\008\004\003\016\162?h@\031\1680\001\024\196\n\008\000\000\000@r\004\002\001\136Q\031\180 \015\212\024\000\140b\005\004\000\000\000\000\000\000\000\000\000\000\000\128\000\000\008\000\002\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\016\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\002\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\008\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\002 \000\000\000\000\000\000\000\000\000\000\000\000@\000\000\004\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\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\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\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\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\000H\000\016\024 \201%\128\000\016\000\008\000\0034\004H\008\192\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\007\173W\128\005H\128\t\006\129Po\208\000\018@ \016\001\t\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000@r\004\002\001\136Q\031\180 \015\212\024\000\140b\005\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\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\003\255\175\224\130\228H\004\131P\174?x@\031\1680\t\026\196\n\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\255\239\252<\185\018\001\000\198/\143\2220\007\234L G\177\198\179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\007\173W\128\004\000\128\000\004\000\016\000\000\000\000@\000\000\000\000\000\000\t\0200\000\000\000\000\001\000\128\019\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\245\170\240\000\128\016\000\000\128\0020\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\016\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\008\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\001\000\000\000\000\000\000\000\000\000\000 \000\008\000\000\000\000\000\000R\000\002A\168P\027\180\000\004\144\008\004\000B\001\004\000\000\000\000)\000\001\000\204(\013\218\000\006H\004\002\128!\004\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\n@\000@0\n\003v\128\001\146\001\000\000\008@ \128\000\000\000\005 \000$\026\005\001\187@\000I\000\128@\004 \016@\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\003\214\171\192\002\164@\004\131@\1687h\000\t \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\020\128\000\128`\020\006\237\000\003$\002\000\000\016\128A\000\000\000\000\n@\000H4\n\003v\128\000\146\001\000\128\008@ \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\002\144\000\016\012\002\128\221\160\000d\128@\000\002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\000\004\003\000\1607h\000\025 \016\000\000\132\002\008\000\000\000\000R\000\002\001\128P\027\180\000\012\144\008\000\000B\001\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\128\000 A\146J\000\000 \000\016\000\004(\008\128\001\128\000\000\000\000\000\000\000\000\000\000\016\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\007\173W\128\005H\128\t\006\129Po\208\000\018@ \016\001\t\004\016\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\001 \208(\013\218\000\002H\004\002\000!\000\130\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\008\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\000\000\000\000\000\000\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\173W\128\005H\128\t\006\129Pn\208\000\018@ \016\001\008\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000R\000\002\001\128P\027\180\000\012\144\008\000\000B\001\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\n@\000H4\n\003v\128\000\146\001\000\128\008@ \128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\001\000\000\000\000\000\002\144\000\018\013\002\128\221\160\000$\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\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\002\001\152P\027\180\000\012\144\008\001\000B\001\004\000\000\000\000)\000\001\000\204(\013\218\000\006H\004\002\128!\004\130\000\000\000\002\020\128\000\128f\020\006\237\000\003$\002\001@\016\130A\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$\026\133\001\187@\000I\000\128@\004 \016@\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\001\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\008\000\000\000\000\000\000\000\000\020\128\000\128f\020\006\237\000\003$\002\000@\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\144\000\016\012\194\128\221\160\000d\128@\008\002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\002\012\002P\000\001\000\000\000\000 @\004\000\012\000\000\000\000)\000\001\000\192(\013\218\000\006H\004\000\000!\000\130\000\000\001\000\000@\000\131\000\148\000\000@\000\000\000\008\016\001\000\003\000\000\000\000\n@\000@0\n\003v\128\001\146\001\000\000\008@ \128\000\000@\000\016\000 \192%\000\000\016\000\000\000\002\004\000@\000\192\000\000\000\002\144\000\016\012\002\128\221\160\000d\128@\000\002\016\008 \000\000\016\000\004\000\0080\t@\000\004\000\000\000\000\129\000\016\0000\000\000\000\000\164\000\004\003\000\1607h\000\025 \016\000\000\132\002\008\000\000\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\192(\013\218\000\006H\004\000\000!\000\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\n@\000@0\n\003v\128\001\146\001\000\000\008@ \128\000\000@\000\016\000 \192%\000\000\016\000\000\000\002\004\000@\000\192\000\000\000\002\144\000\016\012\002\128\221\160\000d\128@\000\002\016\008 \000\000\016\000\004\000\0080\t@\000\004\000\000\000\000\129\000\016\0000\000\000\000\000\164\000\004\003\000\1607h\000\025 \016\000\000\132\002\008\000\000\004\000\001\000\002\012\002P\000\001\000\000\000\000 @\004\000\012\000\000\000\000)\000\001\000\192(\013\218\000\006H\004\000\000!\000\130\000\000\001\000\000@\000\131\000\148\000\000@\000\000\000\008\016\001\000\003\000\000\000\000\n@\000@0\n\003v\128\001\146\001\000\000\008@ \128\000\000@\000\016\000 \192%\000\000\016\000\000\000\002\004\000@\000\192\000\000\000\002\144\000\016\012\002\128\221\160\000d\128@\000\002\016\008 \000\000\016\000\004\000\0080\t@\000\004\000\000\000\000\129\000\016\0000\000\000\000\000\164\000\004\003\000\1607h\000\025 \016\000\000\132\002\008\000\000\004\000\001\000\002\012\002P\000\001\000\000\000\000 @\004\000\012\000\000\000\000)\000\001\000\192(\013\218\000\006H\004\000\000!\000\130\000\000\001\000\000@\000\131\000\148\000\000@\000\000\000\008\016\001\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000R\000\002\001\152P\027\180\000\012\144\008\005\000B\t\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\020\128\000\128f\020\006\237\000\003$\002\001@\016\130A\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\005 \000 \025\133\001\187@\000\201\000\128P\004 \144@\000\000\000\002\144\000\016\012\194\128\221\160\000d\128@\008\002\016H \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\164\000\004\0030\1607h\000\025 \016\n\000\132\018\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001H\000\008\006a@n\208\0002@ \004\001\008\004\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\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\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\008\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\001\000\000\000\000\000\000\000\000\000\000\000\000\008\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\008\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\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\002\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\003\214\171\192\002\000@\000\002\000\008\192\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n@\000H5\n\003v\128\000\146\001\000\128\008@ \128\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000 \000\008\000\000\000\000\000\000\000\000\128\000\144\000\000\000\000\000\000\000\016\000\004\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000z\213x\000@\008\000\000@\001\024\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\008\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\000\000\164\000\004\131P\1607h\000\t \016\008\000\132\002\008\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\014\181Z\000\016\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\008\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\016\000\000\000\000\000\000\164\000\004\131P\1607h\000\t \016\008\000\132\002\008\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\031\253\127\004\023\"@ \024\197q\251\198\000\253A\128\008\214 P@\000\000\000\000\000\000\002\001\000\000\000\002\000\000\000\002 \000\000\003\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\175\224\130\228H\004\003\024\174?x\192\031\1680\129\026\196\n\204\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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 \000D`\155,\150\000@P\004$\000\029\208\016(;\128\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\002\000\000\128\000\000\000\000\000\005 \000$\026\133\001\187@\000I\000\128@\004 \016@\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\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\008\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\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\002\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\003\214\171\192\002\000@\000\002\000\008\192\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n@\000H5\n\003v\128\000\146\001\000\128\008@ \128\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\128\000\000\001\000\000\000\001\016\000\000\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\235\248 \185\018\001 \212+\143\2220\007\234\012\"F\177\002\179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\250\254\008.D\128@1\138\227\247\140\001\250\131\008\017\172@\172\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\004\000\000\000\000\000\000\000\000\000\000\000\000\007\173W\128\005H\128\t\006\129Po\208\000\018@ \016\001\t\004\016\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\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\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\008\000\000\000\000\000\000\000\000\000\000\000\000\015Z\175\000\008\001\000\000\008\000#\000\000\000\000\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\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\008\000\002\000\000\000\000\000\000\020\128\000\144j\020\006\237\000\001$\002\001\000\016\128A\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\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\001\214\171@\002\000@\000\000\000\008\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\000\000@\000\000\000\000\000\000\000\000\000\008\000\002\000\000\000\000\000\000\020\128\000\144j\020\006\237\000\001$\002\001\000\016\128A\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\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\255\235\248 \185\018\001 \212+\143\2220\007\234\012\"F\177\002\179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\004\002\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\007\255_\193\005\200\144\t\006\161\\~\241\128?P`\0185\136\020\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\128\000\000\000\t\128@\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\001\000\000\000\000\000\000\000\000\000\016\000\000\000\000\004\007 @ \024\133\017\251B\000\253A\128\008\198 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\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\016\000\000\001\000\000\000\000\000\000\000\000\000\016\000\031\253\255\132\023#@&\026\133\241\251\198\001\253I\132\200\246:\214`\000\000\002\003\144 \016\012B\136\253\161\000~\160\192\004c\016( \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\175\224\130\228H\004\003\024\190?x@\031\1680\001\030\199\026\008\000\000\000\000\000\000\000@ \000\000\000\000\000\000\000\004\000\000\000\000\255\235\248 \185\018\001\000\198/\143\222\016\007\234\012\000G\177\198\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\016\008\004\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\015\254\191\130\011\145 \018\013B\248\253\225\000~\160\192${\028h \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\175\224\130\228H\004\131P\190?x@\031\1680\t\030\199\026\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\008\000\000\000\000\000\000\000\000\000\128\000\255\235\248 \185\018\001\000\198/\143\222\016\007\234\012\000F\177B\130\000\000\000\000\000\000\000\016\008\002\000\000\000\000\000\000\001\000\000 \000?\250\254\008.D\128@1\139\227\247\132\001\250\131\000\017\172P\160\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\001\000\128@\016\000\000\000\000\000\000\008\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\255\235\248 \185\018\001 \212/\143\222\016\007\234\012\002F\177B\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\001\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\002\000\000\000 &\000\000\000@\000\000\000\002\000\000\000\000\000\000\000 \000\192@\000\000\000\000 \000\000\008\000\000@\005\255\215\240Ar$\002\001\140W\031\188 \015\212\024\000\141b\005\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\004 \024\008\000\000\000\000\004\000\000\001\000\000\008\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\253\127\004\023#@&\026\133q\251\194\001\253A\128H\214\"Po\254\191\130\011\145 \016\012b\184\253\225\000~\160\192\004k\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\001\255\215\240Ar4\002a\168W\031\188 \031\212\024\004\141b%\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\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\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\008\000\000\000\000\000\000\000\000\000\128\000\255\235\248 \185\018\001 \212/\143\222\016\007\234\012\002F\177B\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\001\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\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\128@ \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\127\245\252\016\\\137\000\144j\021\199\239\024\003\245\006\001#X\129A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\191_\192\005H\144\008\006\001Pn\240\0002@ \000\005\136\020\016\000\000\000\000\164\001\004\131@\1607h\000\t \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=\250\254\000*D\128@0\n\131w\128\001\146\001\000\000,@\160\128\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\235U\224\001\000 \000\001\000\004\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\008\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\005 \000$\026\133\001\187@\000I\000\128@\004 \016@\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\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\128\000\000\008\000\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\016\000\000\000\000\000\000\000\000\000\000\000\000\030\181^\000\016\002\000\000\016\000F\000\000\000\000\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\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\000R\000\002A\168P\027\180\000\004\144\008\004\000B\001\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\0010\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\008\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\001H\000\t\006\161@n\208\000\018@ \016\001\008\004\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\000\000\000\000\000u\170\208\000\128\016\000\000\000\002\000\000\000\000\008\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\016\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\002\144\000\018\013B\128\221\160\000$\128@ \002\016\008 \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\008\000\000\000\000\000\000\000\000\000\128\000\247\235\248\000\169\018\001\000\192*\013\222\000\006H\004\000\000\177\002\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\144\000 0A\146K\000 \000\018\000\006(\008\016\017\128\000\000\000\000\000\008\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\001H\000\t\006\161@n\208\000\018@ \016\001\008\004\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\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\001\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\001\235U\224\001\000 \000\001\000\004`\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\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\005 \000$\026\133\001\187@\000I\000\128@\004 \016@\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\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\000z\213x\000T\136\000\144h\021\006\253\000\001$\002\001\000\016\144A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\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\020\128\000\144j\020\006\237\000\001$\002\001\000\016\128A\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\007Z\173\000\008\001\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\004\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 \212(\013\218\000\002H\004\002\000!\000\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\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000 \000\000\002\002`\000\000\004\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\008@\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\031\253\127\004\023\"@ \024\197q\251\194\000\253A\128\008\214 P@\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\000R\000\002A\160P\027\180\000\004\144\008\004\000B\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\127\245\252\016\\\137\000\144j\021\199\239\008\003\245\006\001#\216\195A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\008\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\008\000\000\000\000\000\000\000\008\000\000\000\000\000\000\001\127\245\252\016\\\137\000\128c\021\199\239\008\003\245\006\000#X\129A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\253\127\004\023\"@ \024\197q\251\194\000\253A\128\008\214 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\008\000\000\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\016\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\020\128\000\144h\020\006\237\000\001$\002\000\000\016\128A\000\000\000\000\000\002\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000@\000\000\000\005 \000$\026\005\001\187@\000I\000\128\000\004 \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\001H\000\t\006\129@n\208\000\018@ \000\001\008\004\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\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\004\000\000\000\000\000\000\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\004\007 @ \024\133\017\251B\000\253A\128\008\198 P@\000\000\000\000\000\128\000\000\000\000\000\000\000\128\000\000\000\000\000\000\016\000\000\001\001\200\016\008\006!D~\208\128?P`\0021\136\020\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@r\004\002\001\136Q\031\180 \015\212\024\000\140b\005\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\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\001\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\001H\000\t\006\129@n\208\000\018@ \000\001\008\004\016\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\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\245\252\000@\008\000\000@\001\000\002\000\000\004\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\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000/\254\191\128\008\001\000\000\008\000 \000@\000\000\128\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\175\224\002\000@\000\002\000\008\000\016\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\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\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\002\144\000\018\013\002\128\221\160\000$\128@\000\002\016\008 \000\000\000\000\000@\000\000\000\000\000\000\000@\000\000\000\000\000\000\008\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\000z\213x@\225\008\137 B\001\000\000$\000\nP\144\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\001\235U\224\003\132\" \129\008\004\000\000\144\000)B@\000\152\000\000\245\170\240\001\194\016\000@\132\002\000\000H\000\020\161 \000L\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\004\002\000\000\016\000\000\000\000\002\000\008\000\000\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\004\001\000\000\000\004\000\000\000\000\000\128\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\016\000\000\000@\000\001\000@\000\000\001\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\001\000\000\001\000\000\000\000\000\000\002\000\000\000\000\000\000\000\008\000\000\002\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\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\245\170\240\001\194\017\000@\132\002\000\000H\000\020\161 \000D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=j\188\000p\132\000\016!\000\128\000\018\000\005(H\000\017\000\000\000\002\000\000\008\002\000\000\000\008\000\000\000\000\001\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\008\000\000\000\000\000\000\016\000\000\000@\000\001\000@\000\000\001\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\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\004\000\000\016\004\000\000\000\016\000\000\000\000\002\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\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\128\000\000\002\000\000\000\000\000@\001\000\000\000\000\000\000@\000\001\000@\000\000\001\000\000\004\000\000 \000\128\000\008\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\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\002\000\000\008\002\000\000\000\008\000\000\000\000\001\000\004\000\000\000\000\000\001\000\000\004\001\000\000\000\132\000\000\016\000\000\128\002\000\000 \000\000\000\128\000\002\000\128\000\000\002\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\128 \000\000\000\128\000\000\000\000\016\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\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\003\214\171\192\002\000@\000\002\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000z\213x\000@\008\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\128\000\001\000\000\004\001\000\000\000\134\000\000\000\000\000\128\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\018\000\000\000\000\000\000\000 \000\000\128 \000\000\000\128\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\128\000\000\000\000\000\001\000\000\000\004\000\000\016\004\000\000\000\016\000\000\000\000\002\000\008\000\000\000\000\000\000\000\000\000\000\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\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\004\000\000\000\000\000\000\000\000\000\017\128\000\002\004\016\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\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\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\004\000\000\016\004\000\000\000\016\000\000\000\000\002\000\008\000\000\000\000\000\002\000\000\008\002\000\000\000(\000\000 \000\001\000\004\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\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@\016\000\000\000@\000\000\000\000\008\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\002\000\000\008\002\000\000\000\008\000\000\000\000\001\000\004\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\128 \000\000\000\128\000\000\000\000\016\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\004\000\000\016\004\000\000\000\024\000\000\000\000\002\000\008\000\000\000\000\000\002\000\000\008\002\000\000\001(\000\000 \000\001\000\004\000\000@\000\000\001\000\000\004\001\000\000\000\004\000\000\000\000\000\128\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\001\000@\000\000\001\000\000\000\000\000 \000\128\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\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\016\000\000\000\000\000\000 \000\000\000\128\000\002\000\128\000\000\002\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\002\000\000\002\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\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\016 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\000\002\000\128\000\000\002\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\002\000\000\000\000\000\000\004\000\000\000\016\000\000@\016\000\000\000@\000\000\000\000\008\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\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\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\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\001\000@\000\000\001\000\000\000\000\000 \000\128\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\008\000\000 \008\000\000\000 \000\000\000\000\004\000\016\000\000\000\000\000\004\000\000\016\004\000\000\000P\000\000@\000\002\000\008\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\008\000\000\000\000\000\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\235u\224\001\128 \000\001\008\132\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\128\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\004\000\000\016\004\000\000\000X\000\000@\000\002\000\008\000\000\128\000\000\002\000\000\008\002\000\000\000\008\000\000\000\000\001\000\004\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\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\002\000\000\000\000\000\000=n\188\0000\004\000\000!\024\128\000\000\000\002\000\008\000\000\000\000\000\002\000\000\008\002\000\000\000\008\000\000\000\000\001\000\004\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\001\000@\000\000\001\000\000\000\000\000 \000\128\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\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\002\000\000\008\002\000\000\001\008\000\000\000\000\001\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\128\000\000\128\000\002\000\128\000\000\002\000\000\000\000\000@\001\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\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\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\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\003\214\171\194\007\008DI\002\016\008\000\001 \000R\132\128\0010\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\020\128\000\144h\028\006\237\000\001$\002\001\000\016\128A\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\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\000\144h\020\006\237\000\001$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\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\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\164\000\004\131@\1607h\000\t \016\000\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\008\000\000\000\000\000\020\128\000\144h\020\006\237\000\001$\002\000\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\127\247\254\016\\\137\000\144z\029\199\239\008\003\245&\017#X\129Y\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\223\248Ar$\002A\232W\031\188 \015\212\152D\141b\005fw\239\220\000\128\016\000\000\000\002\000\000\000\000\000@\000\000\000\000\000\001\"\134\000\000\000\000\000\000\016\000\000\000\000\000 \000\000\000\000\000\029\251\247\000 \004\000\000\000\000\128\000\000\000\000\016\000\000\000\000\000\014\253\251\128\016\002\000\000\000\000@\000\000\000\000\008\000\000\000\000\000\000$P\192\000\000\000\000\000\002\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\004\138\024\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\002E\012\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\001\"\134\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\145C\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\127\245\252\030\\\137\000\128c\021\199\239\008\003\245\006\000#X\129A?\250\254\008.D\128@1\138\227\247\132\001\250\131\000\017\172@\160\128\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\015\254\191\130\011\145 \016\012b\184\253\225\000~\160\194\004k\016+0\000\000\000\000\000\000\001\000\128\000\000\000\000\000\000\001\016\000\000\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\250\254\008.D\128H5\n\227\247\132\001\250\131\008\145\172@\172\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\002\144\000\016\012\194\128\221\160\000d\128@(\002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\215\240yr$\002\001\140W\031\188 \015\212\024\000\141b\005\004\255\235\248 \185\018\001\000\198+\143\222\016\007\234\012\000F\177\002\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000?\250\254\008.D\128@1\138\227\247\132\001\250\131\008\017\172@\172\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\254\191\131\203\145 \016\012b\184\253\225\000~\160\192\004k\016('\255_\193\005\200\144\008\0061\\~\240\128?P`\0025\136\020\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{\247\254\000@\008\000\000@\001\000\000\000\000\004 \000\000\000\000\000\000\145C\000\000\000\000\000\016\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\002\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\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\192\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000=j\188\000 \004\000\000 \000\140\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\007\173W\128\004\000\128\000\004\000\017\128\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\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\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\008\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\008\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\002 \000z\213x\000@\008\000\000@\001\024\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\002\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\003\255\175\224\130\228H\004\131P\174?x@\031\1680\t\026\196\026\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\"\134\000\000\000\000\000 \000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\016\008\004\000\000\000\000\000\000\000\008\128\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\254\191\130\011\145 \018\013B\184\253\225\000~\160\194$k\016+0\000\000\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\019\000\000\000 \000\128\000\000\000\196\000\000\000\000\000\128@\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\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\001H\000\t\006\129\192n\208\000\018@ \016\001\008\004\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\000b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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$\026\005\001\187@\000I\000\128@\004 \016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\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\003\255\191\240\130\228H\004\131\208\238?x@\031\1690\137\026\196\n\204\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\015\254\255\194\011\145 \018\015B\184\253\225\000~\164\194$k\016+0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\191\240\130\228H\004\003\024\174?x@\031\1690\129\026\196\n\204\000\000\000\000\000\000\000@ \000\000\000\000\000\000\000D\000\000\000b\255\239\252 \185\018\001\000\198+\143\222\016\007\234L F\177\002\179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\251\255\008.D\128H5\n\227\247\132\001\250\147\008\145\172@\172\223\253\255\132\023\"@ \024\197q\251\194\000\253I\132\008\214 V`\000\000\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\001\000\128\000\000\000\000\000\000\001\016\000\000\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\223\248Ar$\002A\168W\031\188 \015\212\152D\141b\005f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\247\254\016\\\137\000\144j\021\199\239\008\003\245&\017#X\129Y\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\253\255\132\023\"@$\026\133q\251\194\000\253I\132H\214 V`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\024\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\253\255\132\023\"@$\026\133q\251\194\000\253I\132H\214 V`\000\000\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\001\000\128\000\000\000\000\000\000\001\016\000\000\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\223\248Ar$\002A\168W\031\188 \015\212\152D\141b\005f\000\000\000\000\000\000\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\004\000\016\000\000\000\024\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 \002@\000\000\000\000\000\000\000\000\1458\001\128\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000 @\000\000\000\000\000\000 \000\000\000@\000\000\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\008\016\000\000\000\000\000\000\008\000\000\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\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\000\000\000\000\000\000\000\000\000\000\004\000\128\000\000\000\000\001\000\000\004\008\000\000\000\000\000\000\004\000\000\000\008\000\000\000\000\016\000 \000 \000\000\000\000\000\000\000\140\000\128\001\000\160\000\000\000\000\000@\000\001\002\000\000\000\000\000\000\001\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\001\000\002\000\002\000\000\000\000\000\000\000\008\192\008\000\000\n\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\0018\001\128\000\001\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\004\000\008\000\000\000\000\000\000\000\000\000#\0000\000\000 \000\000\000\002\000\004\000\000\000\000\000\000\000\000\000\017\128\016\000\000\016\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\001\000\000\000\000\000\000\000\000\000\004`\004\000\128\004\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\016\000\000\000\000\000\000\000\000\000F\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\002\000\000\000\000\000\000\000\000\000\008\192\000\000\000\008\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\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\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\016\000 \000\000\000\000\000\000\000\000\000\156\000\192\000\000\128\000\000\000\008\000\016\000\000\000\000\000\000\000\000\000F\000`\000\000@\000\000\000\004\000\008\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\017\128\016\000\000\016\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\008\192\000\000\000\008\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\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\016\000 \000\000\000\000\000\000\000\000\000\140\000\192\000\000\128\000\000\000\008\000\016\000\000\000\000\000\000\000\000\000F\000@\000\000@\000\000\000\000\000\008\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\017\128\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\008\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\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\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\128\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") + (171, "\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\000\000\000\000\000\128\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\007\240\000\000\000\000\000\000\000=j\188\000 \004\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\002\000\000\008\003\008\000\001\012\192\140\002\000\128@\001\000\000\019!\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000/\209\192\004\001\132\000\004\134`F\001\000@!\000\128\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\157C\000\016\006\016\000\018\025\129\024\004\001\000\132\002\000\000&C\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\005\2508\000\1280\128\000\144\204\008\192 \008\004 \016\000\0012\024\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019\168`\002\000\194\000\002C0#\000\128 \016\128@\000\004\200b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\234\024\000\1280\128\000\144\204\008\192 \008\004 \016\000\0012\024\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\008\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\001\235U\224\001\000 \000\001\000\004\000\000\000\000\000\000\000\000\000\000\000\000\149C\000\016\006\016\000\019\025\129\024\004\001\000\132\002\000\000&C\023\173W\128\004\000\128\000\004\016\016\000\000\000\000\016\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\000H\161\128\000\000\008\000\008\004\128\140\002\000\000B\001\000\000\019\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\235U\224\t\000 \000\001\004\004\000\000\000\000\004\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\007\173W\128\004\000\128\000\004\016\016\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000@\000\000\002\000\000\000\000\000\000\030\181^\000\016\002\000\000\016@@\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\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235U\224\001\000 \000\001\004\004\000\000\000\000\004\000\001\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\002\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000@\000\008\000\000\000\000\000\000\000\002\000\000\136\000\000\000\000\000\005 \000$\026\005\001\157\160\000\"@ \016\001\008D\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\002\144\000\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n@\000H4\n\003;@\000D\128@\000\002\016\008 \000\000\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 \208(\012\237\000\001\018\001\000\000\008@ \128\000\000\000\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\016\000\000\000\000\164\000\004\131@\1603\180\000\004H\004\002\000!\000\130z\213x\000T\136\000\144h\021\006v\128\000\137\000\128@\004 \016OZ\175\000\n\145\000\018\013\002\160\206\208\000\017 \016\008\000\132\002\008\000\000\000\000R\000\002A\160P\025\218\000\002$\002\000\000\016\128A=j\188\000*D\000H4\n\131;@\000D\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\000\004\131@\1603\180\000\004H\004\002\000!\000\130\000\000\000\000\020\128\000\144h\020\006v\128\000\137\000\128@\004 \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\n@\000H4\n\003;@\000D\128@ \002\016\008 \000\000\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 \208(\012\237\000\001\018\001\000\128\008@ \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\164\000\004\131@\1603\180\000\004H\004\002\000!\000\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\000\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\"0M\150K\000\000\020\001\004\000\003\186\002'\135p\000\000\000\000\000\000\000\000\000\000\002\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\030\181^\000\021\"\000$\026\005A\159\160\000\"@ \016\001\t\004\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 \000@ \131\000\150\000\000(\000\000\000\007d\000M\014\224\000\000\000\002\144\000\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\000\000\004\128\001\016\130l\"X\000\000\160\008\000\000\029\144\001<;\128\000\000\000\n@\000H4\n\003;@\000D\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\016\130l\"X\000\000\160\008\000\000\025\144\001<\027\128\000\000\000\n@\000H4\n\003;@\000D\128@ \002\016\008 \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\136A6\017,\000\000P\004\000\000\012\200\000\158\013\192\000\000\000\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\016\000\000\t\000\002!\004\216D\176\000\001@\016\000\0003 \002x7\000\000\000\000\020\128\000\144h\020\006v\128\000\137\000\128@\004 \016@\000\000$\000\008\132\019a\018\192\000\005\000@\000\000\204\128\t\224\220\000\000\000\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\t\006\129@gh\000\008\144\008\004\000B\001\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\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\016\000\000\t\000\002!\004\216D\176\000\001@\016\000\0003 \002x7\000\000\000\000\020\128\000\144h\020\006v\128\000\137\000\128@\004 \016@\000\000$\000\008\132\019a\018\192\000\005\000@\000\000\204\128\t\224\220\000\000\000\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\000\000\000\144\000\"\016M\132K\000\000\020\001\000\000\0032\000'\131p\000\000\000\001H\000\t\006\129@gh\000\008\144\008\004\000B\001\004\000\000\002@\000\136A6\017,\000\000P\004\000\000\012\200\000\158\013\192\000\000\000\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\016\000\000\t\000\002!\004\216D\176\000\001@\016\000\0003 \002x7\000\000\000\000\020\128\000\144h\020\006v\128\000\137\000\128`\004 \016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\000\144h\020\006v\128\000\137\000\128@\004 \016@\000\000$\000\008\132\019a\018\192\000\005\000@\000\000\204\128\t\224\220\000\000\000\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\000\000\000\144\000\"\016M\132K\000\000\020\001\000\000\0032\000'\131p\000\000\000\001H\000\t\006\129@gh\000\008\144\008\004\000B\001\004\000\000\002@\000\136A6\017,\000\000P\004\000\000\012\200\000\158\013\192\000\000\000\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\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\002\144\000\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\192\000\000C \000\000\000 \016\000@\000\004\200\002\002U\012\000@\024@\000Hf\004`\016\004\002\016\008\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\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\000u\170\208\000\128\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\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\008\000\000 \012 \000\0042\0020\008\002\001\000\004\000\000L\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\001\016\000=j\188\000*D\000H4\n\131?@\000D\128@ \002\016\008 \000\000\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 \208(\012\237\000\001\018\001\000\128\008@ \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\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\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\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\002\000\000\000\000\000\001H\000\t\006\129@gh\000\008\144\008\000\000B\001\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\n@\000H4\n\003;@\000D\128@\000\002\016\008 \000\000\000\001H\000\t\006\129@gh\000\008\144\008\004\000B\001\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\005 \000$\026\005\001\157\160\000\"@ \000\001\008\004\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\020\128\000\144h\020\006v\128\000\137\000\128\000\004 \016@\000\000\000\002\144\000\018\013\002\128\206\208\000\017 \016\000\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018\000\004D\008\178I@\000\002\000 \128\0005@D0\142\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\003\214\171\192\002\164@\004\131@\1683\244\000\004H\004\002\000! \130\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\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\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\008\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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 \000D\000\139\000\148\000\000 \002\000\000\003D\000C\008\224\000\000\000\002\144\000\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n@\000H4\n\003;@\000D\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\008\000\000\000\000\000\000\000\000\000@\000\002\000\000\000\000\000B\144\000\018\013\002\128\206\208\000\017 \016\000\000\132\002\008\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\n@\000H4\n\003;@\000D\128@ \002\016\008 \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\164\000\004\131@\1603\180\000\004H\004\000\000!\000\130\000\000\000\000\000\000\000\008\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\000H\000\017\000\"\192%\000\000\008\000\128\000\000\145\000\016\1928\000\000\000\000\164\000\004\131@\1603\180\000\004H\004\000\000!\000\130\000\000\001 \000D\000\139\000\148\000\000 \002\000\000\002D\000C\000\224\000\000\000\002\144\000\018\013\002\128\206\208\000\017 \016\000\000\132\002\008\000\000\004\128\001\016\002,\002P\000\000\128\008\000\000\t\016\001\012\003\128\000\000\000\n@\000H4\n\003;@\000D\128@\000\002\016\008 \000\000\018\000\004@\008\176\t@\000\002\000 \000\000$@\0040\014\000\000\000\000)\000\001 \208(\012\237\000\001\018\001\000\000\008@ \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\164\000\004\131@\1603\180\000\004H\004\000\000!\000\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\002\144\000\018\013\002\128\206\208\000\017 \016\000\000\132\002\008\000\000\004\128\001\016\002,\002P\000\000\128\008\000\000\t\016\001\012\003\128\000\000\000\n@\000H4\n\003;@\000D\128@\000\002\016\008 \000\000\018\000\004@\008\176\t@\000\002\000 \000\000$@\0040\014\000\000\000\000)\000\001 \208(\012\237\000\001\018\001\000\000\008@ \128\000\000H\000\017\000\"\192%\000\000\008\000\128\000\000\145\000\016\1928\000\000\000\000\164\000\004\131@\1603\180\000\004H\004\000\000!\000\130\000\000\001 \000D\000\139\000\148\000\000 \002\000\000\002D\000C\000\224\000\000\000\002\144\000\018\013\002\128\206\208\000\017 \016\000\000\132\002\008\000\000\004\128\001\016\002,\002P\000\000\128\008\000\000\t\016\001\012\003\128\000\000\000\n@\000H4\n\003;@\000D\128@0\002\016\008 \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\001 \208(\012\237\000\001\018\001\000\000\008@ \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\164\000\004\131@\1603\180\000\004H\004\000\000!\000\130\000\000\001 \000D\000\139\000\148\000\000 \002\000\000\002D\000C\000\224\000\000\000\002\144\000\018\013\002\128\206\208\000\017 \016\000\000\132\002\008\000\000\004\128\001\016\002,\002P\000\000\128\008\000\000\t\016\001\012\003\128\000\000\000\n@\000H4\n\003;@\000D\128@\000\002\016\008 \000\000\018\000\004@\008\176\t@\000\002\000 \000\000$@\0040\014\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\001\000\000\000\000\000\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\000\000\000\000\000@\000z\213x\000@\008\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\008\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235U\224\001R \002A\160T\025\218\000\002$\002\001\000\016\128A\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\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\000z\213x\000T\136\000\144h\021\006v\128\000\137\000\128@\004 \016@\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\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\008\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\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\145C\000\000\000\016\000\016\t\001\024\004\000\000\132\002\000\000&\003\016\018(`\000\000\002\000\002\000 #\000\128\000\016\128@\000\004\192b\000\000\000\000\000\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\001\000\000\000\008\000\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\004\000\000\000\000\000\000\000\000\000\000\000\000\001\235U\224\001\000 \000\001\000\004`\000\000\000\000\000\001\000\000\016\000\000\000\000\000\000\000\000\000\016\008\000\000\000\000\000\000\000\000\000\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\003\214\171\192\002\000@\000\002\000\008\192\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\016\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\002\000\000\000\000\008\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\003\214\171\192\002\000@\000\002\000\008\192\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\000D\000\015Z\175\000\008\001\000\000\008\000#\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\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\128\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000=j\188\000 \004\000\000 \000\140\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\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\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\007\173W\128\004\000\128\000\004\016\016\000\000\000\000\016\000\000\000\000\008\000\245\170\240\000\128\016\000\000\130\002\000\000\000\000\002\000\000\128\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\001\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\235U\160\001\000 \000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tT0\001\000a\000\0011\152\017\128@\016\008@ \000\002d1z\213x\000@\008\000\000A\001\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\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\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\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\016\000\000\000\000\000\000\001z\213x\000@\008\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\001\235U\224\001\000 \000\001\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\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\001\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\245\252\016\\\137\000\128c\021\199w\132\001\189A\128\008\214 P@$P\192\000\000\000\000\004\002\000F\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=j\188\000 \004\000\000 \000\140\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\003\214\171\192\002\000@\000\002\000\008\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\001P \000\000\000\000\000\000\004\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\000\000\000\007\173W\128\004\000\128\000\004\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\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\136\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000 \000\000\000\000\000\000\000\000\000\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\014\181Z\000\016\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\000\000\000\000\000\000\000\000\000\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\128\000\144h\020\006v\128\000\137\000\128@\004 \016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000@r\004\002\001\136Q\029\218\016\006\245\006\000#\024\129A\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\001H\000\t\006\129@gh\000\008\144\008\004\000B\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\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\001\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\015\254\191\130\011\145 \018\013B\184\238\240\1287\1680\t\030\198\026\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n@\000@0\n\003;@\000\196\128@\000\002\016\008 \000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\004\245\170\240\000\169\016\001 \208*\012\237\000\001\018\001\000\128\008@ \128\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\004\000\000\000\000\000\002\144\000\016\012\002\128\206\208\0001 \016\000\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\144\000\016\012\002\128\206\208\0001 \016\000\000\132\002\008\000\000\000\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\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\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\000\000\164\000\004\003\000\1603\180\000\012H\004\000\000!\000\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\000\000\000\004\128\001\017\130l\178X\000\000\160\008 \000\029P\016(;\128\000\000\000\000\000\000\000\000\000\000\016\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\245\170\240\000\169\016\001 \208*\012\253\000\001\018\001\000\128\008H \128\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\020\128\000\144h\020\006v\128\000\137\000\128@\004 \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\002\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\000\017\008&\194%\128\000\n\000\128\000\001\209\000\002\131\184\000\000\000\000\164\000\004\131@\1603\180\000\004H\004\002\000!\000\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\002\144\000\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\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\144\000\"\016M\132K\000\000\020\001\000\000\003\"\000\005\003p\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\004\000\000\002@\000\136A6\017,\000\000P\004\000\000\012\136\000\020\013\192\000\000\000\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\t\000\002!\004\216D\176\000\001@\016\000\0002 \000P7\000\000\000\000\020\128\000\128`\020\006v\128\001\137\000\128\000\004 \016@\000\000$\000\008\132\019a\018\192\000\005\000@\000\000\200\128\001@\220\000\000\000\000R\000\002\001\128P\025\218\000\006$\002\000\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\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\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\t\000\002!\004\216D\176\000\001@\016\000\0002 \000P7\000\000\000\000\020\128\000\128`\020\006v\128\001\137\000\128\000\004 \016@\000\000$\000\008\132\019a\018\192\000\005\000@\000\000\200\128\001@\220\000\000\000\000R\000\002\001\128P\025\218\000\006$\002\000\000\016\128A\000\000\000\144\000\"\016M\132K\000\000\020\001\000\000\003\"\000\005\003p\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\004\000\000\002@\000\136A6\017,\000\000P\004\000\000\012\136\000\020\013\192\000\000\000\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\t\000\002!\004\216D\176\000\001@\016\000\0002 \000P7\000\000\000\000\020\128\000\144h\020\006v\128\000\137\000\128`\004 \016@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000R\000\002\001\128P\025\218\000\006$\002\000\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\004\000\000\002@\000\136A6\017,\000\000P\004\000\000\012\136\000\020\013\192\000\000\000\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\t\000\002!\004\216D\176\000\001@\016\000\0002 \000P7\000\000\000\000\020\128\000\128`\020\006v\128\001\137\000\128\000\004 \016@\000\000$\000\008\132\019a\018\192\000\005\000@\000\000\200\128\001@\221\235U\224\001R \002A\160T\025\218\000\002$\002\001\000\016\128A\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\005 \008$\026\005\001\157\160\000\"@ \016\001\008\004\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\001\255\215\240yr$\002\001\140W\029\222\016\006\245\006\000#X\129A\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\t\006\129@gh\000\008\144\008\004\000B\001\004\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\128\000\144h\020\006v\128\000\137\000\128@\004 \016@\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\001\000\000\000\000@\000\000\000\000\000\001\008\128\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\255\235\248 \185\018\001\000\196+\142\239\008\003z\131\000\017\172@\160\159\253\127\004\023\"@$\026\133\241\221\225\000oP`\0185\138\020\019\255\175\224\242\228H\004\003\024\174;\188 \013\234\012\000F\177\002\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\254\255\195\203\145 \016\012b\248\238\241\1287\1690\129\030\199\026\204\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\250\254\008.D\128@1\138\227\187\194\000\222\160\192\004k\016('\255_\193\005\200\144\t\006\161|wx@\027\212\024\004\141b\133\004\255\235\248 \185\018\001 \212+\142\239\008\003z\131\000\145\172A\160\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\008\140\019e\146\192\000\005\000A\000\000\238\128\137A\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\000\004\131@\1603\180\000\004H\004\002\000!\000\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\002\003\144 \016\012B\136\238\208\1287\1680\001\024\196\n\008\000\000\000@r\004\002\001\136Q\029\218\016\006\245\006\000#\024\129A\000\000\000\000\000\000\000\000\000\000\000\016\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\001\004\131@\1603\180\000\004H\004\002\000!\000\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\002\144\004\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\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\n@\000H4\n\003;@\000D\128@ \002\018\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000 9\002\001\000\196(\142\237\008\003z\131\000\017\140@\160\128\000\000\004\007 @ \024\133\017\221\161\000oP`\0021\136\020\016\000\000\000\000\000\000\000\000\000\000\001\000\000\000\008\000\002\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000D\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000 \000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\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\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\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\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\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\000\000\000\000\000\000\000\000\000\000\000\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\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\004\128\001\001\130\012\146X\000\000\128\000 \000\012\208\017 #\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\007\173W\128\005H\128\t\006\129Pg\232\000\008\144\008\004\000BA\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\004\007 @ \024\133\017\221\161\000oP`\0021\136\020\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\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\000\000\000\000\000\000\000\000\000\000\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\235\248 \185\018\001 \212+\142\239\008\003z\131\000\145\172@\160\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\191\240\242\228H\004\003\024\190;\188`\013\234L G\177\198\179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\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\173W\128\004\000\128\000\004\000\016\000\000\000\000\016\000\000\000\000\000\000\002E\012\000\000\000\000\000@ \004`\000\000\002\016\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\003\214\171\192\002\000@\000\002\000\008\192\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\004\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\016\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\002\000\000\128\000\000\000\000\000\005 \000$\026\133\001\189\160\000\"@ \016\001\008\004\016\000\000\000\000\164\000\004\0030\1603\180\000\012H\004\n\128!\004\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\002\144\000\016\012\002\128\206\208\0001 \016\000\000\132\002\008\000\000\000\000R\000\002A\160P\025\218\000\002$\002\001\000\016\128A\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\245\170\240\000\169\016\001 \208*\012\237\000\001\018\001\000\128\008@ \128\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\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\020\128\000\128`\020\006v\128\001\137\000\128\000\004 \016@\000\000\000\002\144\000\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n@\000@0\n\003;@\000\196\128@\000\002\016\008 \000\000\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\192(\012\237\000\003\018\001\000\000\008@ \128\000\000\000\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\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\008\008\016d\146\128\000\004\000\001\000\000B\128\136\000\024\000\000\000\000\000\000\000\000\000\000\000\128\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\007\173W\128\005H\128\t\006\129Pg\232\000\008\144\008\004\000BA\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\164\000\004\131@\1603\180\000\004H\004\002\000!\000\130\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\016\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\000\000\000\000\000\000\000\000\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\173W\128\005H\128\t\006\129Pgh\000\008\144\008\004\000B\001\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\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\002\144\000\018\013\002\128\206\208\000\017 \016\008\000\132\002\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\004\000\000\000\000\000\n@\000H4\n\003;@\000D\128@ \002\016\008 \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\164\000\004\0030\1603\180\000\012H\004\n\128!\004\130\000\000\000\002\020\128\000\128f\020\006v\128\001\137\000\129P\004 \144@\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R\000\002A\168P\027\218\000\002$\002\001\000\016\128A\000\000\000\000\000\000\000\000\000\000\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\001\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\n@\000@3\n\003;@\000\196\128@\136\002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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 \025\133\001\157\160\000b@ D\001\008\004\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\004\000\000\000\000\000\000\000\001\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\128\000 \000A\128J\000\000\016\000\000\000\001\002\000 \000`\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\004\000\000\002\000\000\128\001\006\001(\000\000@\000\000\000\004\008\000\128\001\128\000\000\000\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\008\000\002\000\004\024\004\160\000\001\000\000\000\000\016 \002\000\006\000\000\000\000\020\128\000\128`\020\006v\128\001\137\000\128\000\004 \016@\000\000 \000\008\000\016`\018\128\000\004\000\000\000\000@\128\008\000\024\000\000\000\000R\000\002\001\128P\025\218\000\006$\002\000\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\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\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\008\000\002\000\004\024\004\160\000\001\000\000\000\000\016 \002\000\006\000\000\000\000\020\128\000\128`\020\006v\128\001\137\000\128\000\004 \016@\000\000 \000\008\000\016`\018\128\000\004\000\000\000\000@\128\008\000\024\000\000\000\000R\000\002\001\128P\025\218\000\006$\002\000\000\016\128A\000\000\000\128\000 \000A\128J\000\000\016\000\000\000\001\002\000 \000`\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\004\000\000\002\000\000\128\001\006\001(\000\000@\000\000\000\004\008\000\128\001\128\000\000\000\005 \000 \024\005\001\157\160\000b@ \000\001\008\004\016\000\000\008\000\002\000\004\024\004\160\000\001\000\000\000\000\016 \002\000\006\000\000\000\000\020\128\000\128`\020\006v\128\001\137\000\128\000\004 \016@\000\000 \000\008\000\016`\018\128\000\004\000\000\000\000@\128\008\000\024\000\000\000\000R\000\002\001\128P\025\218\000\006$\002\000\000\016\128A\000\000\000\128\000 \000A\128J\000\000\016\000\000\000\001\002\000 \000`\000\000\000\001H\000\008\006\001@gh\000\024\144\008\000\000B\001\004\000\000\002\000\000\128\001\006\001(\000\000@\000\000\000\004\008\000\128\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\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\008\000\000\000\000\000\000R\000\002\001\152P\025\218\000\006$\002\005@\016\130A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\008\006a@gh\000\024\144\008\021\000B\t\004\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\005 \000 \025\133\001\157\160\000b@ T\001\008$\016\000\000\000\000\164\000\004\0030\1603\180\000\012H\004\008\128!\004\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\002\144\000\016\012\194\128\206\208\0001 \016*\000\132\018\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\016\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\128\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\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\002\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\245\170\240\000\128\016\000\000\128\0020\000\000\000\000\000\000\128\000\008\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\001\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\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\144\000\018\013B\128\222\208\000\017 \016\008\000\132\002\008\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\016\000\000\000\000\000\000\000\000\000\000\000\000@\000H\000\000\000\000\000\000\000\002\000\000\128\000\000\000\000\000\000\000\008\000\t\000\000\000\000\000\000\000\000@\000\016\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000z\213x\000@\008\000\000@\001\024\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\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\002\000\000\000\000\000\000\000\000\000\000\016\000\004\000\000\000\000\000\000)\000\001 \212(\013\237\000\001\018\001\000\128\008@ \128\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\235U\160\001\000 \000\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\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\016\000\004\000\000\000\000\000\000)\000\001 \212(\013\237\000\001\018\001\000\128\008@ \128\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\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\215\240Ar$\002\001\140W\029\2220\006\245\006\000#X\129A\000\000\000\000\000\000\000\008\004\000\000\000\004\000\000\000\002 \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\255\235\248 \185\018\001\000\198+\142\239\024\003z\131\008\017\172@\172\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\001 \000D`\155,\150\000 (\002\t\000\007t\004\n\014\224\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000 \000\008\000\000\000\000\000\000R\000\002A\168P\027\218\000\002$\002\001\000\016\128A\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\002\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\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\002\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\245\170\240\000\128\016\000\000\128\0020\000\000\000\000\000\000\128\000\008\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\001\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\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\144\000\018\013B\128\222\208\000\017 \016\008\000\132\002\008\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\002\001\000\128\000\000\000\128\000\000\000D\000\000\000b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\255\175\224\130\228H\004\131P\174;\188`\013\234\012\"F\177\002\179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\254\191\130\011\145 \016\012b\184\238\241\1287\1680\129\026\196\n\204\000\000\000\000\000\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\007\173W\128\005H\128\t\006\129Pg\232\000\008\144\008\004\000BA\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\0020\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\128\000\000\000\000\000\000\000\000\000\000\000\000=j\188\000 \004\000\000 \000\140\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\001\000\000\000\000\000\000\000\000\000\000\008\000\002\000\000\000\000\000\000\020\128\000\144j\020\006\246\128\000\137\000\128@\004 \016@\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\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\000u\170\208\000\128\016\000\000\000\002\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\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\008\000\002\000\000\000\000\000\000\020\128\000\144j\020\006\246\128\000\137\000\128@\004 \016@\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\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\003\255\175\224\130\228H\004\131P\174;\188`\013\234\012\"F\177\002\179\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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_\193\005\200\144\t\006\161\\wx\192\027\212\024\004\141b\005\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\008\000\000\000\000\140\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\001\000\000\000\000\000@r\004\002\001\136Q\029\218\016\006\245\006\000#\024\129A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\000\000@\000\000\000\000\000\000\000\000\001\000\001\255\223\248Ar4\002a\168_\029\2220\014\245&\019#\216\235Y\128\000\000\008\014@\128@1\n#\187B\000\222\160\192\004c\016( \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\255\235\248 \185\018\001\000\198/\142\239\008\003z\131\000\017\236q\160\128\000\000\000\000\000\000\004\002\000\000\000\000\000\000\000\000\016\000\000\000\003\255\175\224\130\228H\004\003\024\190;\188 \013\234\012\000G\177\198\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\004\002\001\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\250\254\008.D\128H5\011\227\187\194\000\222\160\192${\028h \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\255\235\248 \185\018\001 \212/\142\239\008\003z\131\000\145\236q\160\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\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\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\000\000\000\000\000\000\000\002\000\003\255\175\224\130\228H\004\003\024\190;\188 \013\234\012\000F\177B\130\000\000\000\000\000\000\000\016\008\002\000\000\000\000\000\000\000@\000\008\000\015\254\191\130\011\145 \016\012b\248\238\240\1287\1680\001\026\197\n\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\000\000\000\000\000\000\128\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\255\175\224\130\228H\004\131P\190;\188 \013\234\012\002F\177B\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\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\002\000\000\000 #\000\000\000\016\000\000\000\000\128\000\000\000\000\000\000\008\0000\016\000\000\000\000\004\000\000\000\128\000\004\000_\253\127\004\023\"@ \024\197q\221\225\000oP`\0025\136\020\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\004 \024\008\000\000\000\000\002\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\001\255\215\240Ar4\002a\168W\029\222\016\014\245\006\001#X\137A\191\250\254\008.D\128@1\138\227\187\194\000\222\160\192\004k\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\031\253\127\004\023#@&\026\133q\221\225\000\239P`\0185\136\148\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\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\000\000\000\000\000\000\000\002\000\003\255\175\224\130\228H\004\131P\190;\188 \013\234\012\002F\177B\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\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\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\008\004\002\000\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\127\245\252\016\\\137\000\144j\021\199w\140\001\189A\128H\214 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\000\000\000\000\000\000\000\000\000\000\000\007\191_\192\005H\144\008\006\001Pgx\000\024\144\008\000\001b\005\004\000\000\000\000)\000A \208(\012\237\000\001\018\001\000\128\008@ \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\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\015~\191\128\n\145 \016\012\002\160\206\240\0001 \016\000\002\196\n\008\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\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\030\181^\000\016\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\001\000\000\000\008\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\000R\000\002A\168P\027\218\000\002$\002\001\000\016\128A\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\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\008\000\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\004\000\000\000\000\000\000\000\000\000\000\000\000\001\235U\224\001\000 \000\001\000\004`\000\000\000\000\000\001\000\000\016\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\002\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\005 \000$\026\133\001\189\160\000\"@ \016\001\008\004\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000F\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\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\001H\000\t\006\161@oh\000\008\144\008\004\000B\001\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\001\214\171@\002\000@\000\000\000\008\000\000\000\000\008\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\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\n@\000H5\n\003{@\000D\128@ \002\016\008 \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\128\000\000\000\000\000\000\000\000\002\000\003\223\175\224\002\164H\004\003\000\1683\188\000\012H\004\000\000\177\002\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\008\012\016d\146\192\004\004\000\001 \000b\128\129\001\024\000\000\000\000\000\000\128\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\001H\000\t\006\161@oh\000\008\144\008\004\000B\001\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\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\016\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\030\181^\000\016\002\000\000\016\000F\000\000\000\000\000\000\016\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\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\000R\000\002A\168P\027\218\000\002$\002\001\000\016\128A\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\001\000\000\000\000\000\000\000\000\000\000\000\000\000z\213x\000T\136\000\144h\021\006~\128\000\137\000\128@\004$\016@\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\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\002\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\008\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\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\128\000\144j\020\006\246\128\000\137\000\128@\004 \016@\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\029j\180\000 \004\000\000\000\000\128\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\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\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\164\000\004\131P\1607\180\000\004H\004\002\000!\000\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\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\000\000\016\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000 \000\000\002\0020\000\000\001\000\000\000\000\008\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\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\002\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\002\016\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\001\255\215\240Ar$\002\001\140W\029\222\016\006\245\006\000#X\129A\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\005 \000$\026\005\001\157\160\000\"@ \016\001\008\004\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\127\245\252\016\\\137\000\144j\021\199w\132\001\189A\128H\2460\208@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\002\001\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\127\245\252\016\\\137\000\128c\021\199w\132\001\189A\128\008\214 P@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\215\240Ar$\002\001\140W\029\222\016\006\245\006\000#X\129A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\008\000\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\128\000\144h\020\006v\128\000\137\000\128\000\004 \016@\000\000\000\000\000\128\000\000\000\000\000\000\000@\000\000\000\000\000\000\004\000\000\000\000R\000\002A\160P\025\218\000\002$\002\000\000\016\128A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001H\000\t\006\129@gh\000\008\144\008\000\000B\001\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\008\000\000\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\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@r\004\002\001\136Q\029\218\016\006\245\006\000#\024\129A\000\000\000\000\000\002\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\016\000\000\001\001\200\016\008\006!Dwh@\027\212\024\000\140b\005\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\004\007 @ \024\133\017\221\161\000oP`\0021\136\020\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\016\000\000\000\000\000\000\000\008\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\001H\000\t\006\129@gh\000\008\144\008\000\000B\001\004\000\000\000\000\000\008\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\245\252\000@\008\000\000@\001\000\001\000\000\001\000\000\000\016\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\016\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\191\250\254\000 \004\000\000 \000\128\000\128\000\000\128\000\000\008\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\235\248\000\128\016\000\000\128\002\000\002\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\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n@\000H4\n\003;@\000D\128@\000\002\016\008 \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\000z\213x@\225\008\137 B\001\000\000\018\000B\148$\000\t\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\030\181^\0008B\"\008\016\128@\000\004\128\016\165\t\000\002`\000\003\214\171\192\007\008@\001\002\016\008\000\000\144\002\020\161 \000L\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\004\001\000\128\000\004\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\004\000\000\016\004\000\000\000\016\000\000\000\000\000\128\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\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\004\000\000\000\016\000\000@\016\000\000\000@\000\000\000\000\002\000\008\000\000\000\000\000\000\000\000\000\000\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\002\000\000\000\000\000\000\002\000\000\000\000\000\000\000\008\000\000\002\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\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\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\003\214\171\192\007\008D\001\002\016\008\000\000\144\002\020\161 \000D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015Z\175\000\028!\000\004\008@ \000\002@\008R\132\128\001\016\000\000\000 \000\000\128 \000\000\000\128\000\000\000\000\004\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\004\000\000\000\016\000\000@\016\000\000\000@\000\000\000\000\002\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000\000\004\001\000\000\000\004\000\000\000\000\000 \000\128\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\128\000\002\000\128\000\000\002\000\000\000\000\000\016\000@\000\000\000\000\000\016\000\000@\016\000\000\000@\000\000\128\000\002\000\008\000\000\128\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\128 \000\000\000\128\000\000\000\000\004\000\016\000\000\000\000\000\004\000\000\016\004\000\000\002\016\000\000 \000\000\128\002\000\000 \000\000\000\128\000\002\000\128\000\000\002\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\002\000\000\002\000\000\008\002\000\000\000\008\000\000\000\000\000@\001\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\245\170\240\000\128\016\000\000\128\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\002\004\000z\213x\000@\008\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\002\000\000\004\000\000\016\004\000\000\002\024\000\000\000\000\000\128\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\001 \000\000\000\000\000\000\002\000\000\008\002\000\000\000\008\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\001\000\000\004\001\000\000\000\004\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\016\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\016\000\000\000\000\000\000\000\000\000\017\128\000\002\004\016\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\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\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\001\000\000\004\001\000\000\000\004\000\000\000\000\000 \000\128\000\000\000\000\000 \000\000\128 \000\000\002\128\000\001\000\000\004\000\016\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\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\001\000@\000\000\001\000\000\000\000\000\008\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\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\128\000\000\000\000\004\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\016\000\000@\016\000\000\000@\000\000\000\000\002\000\008\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\002\000\000\000\000\000\000\000\001\000\000\004\001\000\000\000\004\000\000\000\000\000 \000\128\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\128\000\002\000\128\000\000\003\000\000\000\000\000\016\000@\000\000\000\000\000\016\000\000@\016\000\000\t@\000\000\128\000\002\000\008\000\000\128\000\000\002\000\000\008\002\000\000\000\008\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\008\000\000\008\000\000 \008\000\000\000 \000\000\000\000\001\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000@\000\001\000@\000\000\001\000\000\000\000\000\008\000 \000\000\000\000\000\000\000\000\000\000\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\008\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\002\004\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\002\004\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\000\000\000\000\000\000\000\000\000\000\000\000\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\001\000@\000\000\001\000\000\000\000\000\008\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\008\000\000\000 \000\000\128 \000\000\000\128\000\000\000\000\004\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\008\000\000\004\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\004\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\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\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\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\008\000\000 \008\000\000\000 \000\000\000\000\001\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\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\004\000\000\000\016\000\000\000\000\000\128\002\000\000\000\000\000\000\128\000\002\000\128\000\000\n\000\000\004\000\000\016\000@\000\004\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\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\015[\175\000\012\001\000\000\008D \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\128\000\000\000\000\000\000\000\128\000\002\000\128\000\000\011\000\000\004\000\000\016\000@\000\004\000\000\000\016\000\000@\016\000\000\000@\000\000\000\000\002\000\008\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\173\215\128\006\000\128\000\004#\016\000\000\000\000\016\000@\000\000\000\000\000\016\000\000@\016\000\000\000@\000\000\000\000\002\000\008\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\008\000\000 \008\000\000\000 \000\000\000\000\001\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\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@\016\000\000\008@\000\000\000\000\002\000\008\000\000\000\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\001\000\000\000\000\000\008\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\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\000z\213x@\225\008\137 B\001\000\000\018\000B\148$\000\t\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\n@\000H4\014\003;@\000D\128@ \002\016\008 \000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\n@\000H4\n\003;@\000D\128@ \002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000b\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\020\128\000\144h\020\006v\128\000\137\000\128\000\004 \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\001\004\000\000\000\000\000\n@\000H4\n\003;@\000D\128@\000\002\016\008 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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?\251\255\008.D\128H=\014\227\187\194\000\222\164\194$k\016+0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\015\254\255\194\011\145 \018\015B\184\238\240\1287\1690\137\026\196\n\204\239\223\184\001\000 \000\000\000\004\000\000\000\000\000 \000\000\000\000\000\000\145C\000\000\000\000\000\000\008\000\000\000\000\000\004\000\000\000\000\000\003\191~\224\004\000\128\000\000\000\016\000\000\000\000\000\128\000\000\000\000\000w\239\220\000\128\016\000\000\000\002\000\000\000\000\000\016\000\000\000\000\000\000H\161\128\000\000\000\000\000\004\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$P\192\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\004\138\024\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\145C\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\018(`\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\000\000\000\000\000\000\000\000\000\000?\250\254\015.D\128@1\138\227\187\194\000\222\160\192\004k\016('\255_\193\005\200\144\008\0061\\wx@\027\212\024\000\141b\005\004\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\031\253\127\004\023\"@ \024\197q\221\225\000oPa\0025\136\021\152\000\000\000\000\000\000\000\128@\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\128@ \000\000\000\000\000\000\000\017\000\000\000\024\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255_\193\005\200\144\t\006\161\\wx@\027\212\024D\141b\005f\000\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 \025\133\001\157\160\000b@ T\001\008\004\016\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\015\254\191\131\203\145 \016\012b\184\238\240\1287\1680\001\026\196\n\t\255\215\240Ar$\002\001\140W\029\222\016\006\245\006\000#X\129A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\007\255_\193\005\200\144\008\0061\\wx@\027\212\024@\141b\005f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\253\127\007\151\"@ \024\197q\221\225\000oP`\0025\136\020\019\255\175\224\130\228H\004\003\024\174;\188 \013\234\012\000F\177\002\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=\251\255\000 \004\000\000 \000\128\000\000\000\000\132\000\000\000\000\000\000\018(`\000\000\000\000\002\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\001\000\000\000\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\008\192\000\000\004\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\007\173W\128\004\000\128\000\004\000\017\128\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\017\000\003\214\171\192\002\000@\000\002\000\008\192\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\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\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\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\008\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000=j\188\000 \004\000\000 \000\140\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\000\000\000\000\000\000\000\000\127\245\252\016\\\137\000\144j\021\199w\132\001\189A\128H\214 \208@\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\145C\000\000\000\000\000\016\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\002\001\000\128\000\000\000\000\000\000\000D\000\000\000b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\253\127\004\023\"@$\026\133q\221\225\000oPa\0185\136\021\152\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\0020\000\000\001\000\004\000\000\000\006 \000\000\000\000\004\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\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\164\000\004\131@\2243\180\000\004H\004\002\000!\000\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\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\001 \208(\012\237\000\001\018\001\000\128\008@ \128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\001\136\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\247\254\016\\\137\000\144z\029\199w\132\001\189I\132H\214 V`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\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\031\253\255\132\023\"@$\030\133q\221\225\000oRa\0185\136\021\152\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\247\254\016\\\137\000\128c\021\199w\132\001\189I\132\008\214 V`\000\000\000\000\000\000\002\001\000\000\000\000\000\000\000\000\136\000\000\000\197\255\223\248Ar$\002\001\140W\029\222\016\006\245&\016#X\129Y\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\127\225\005\200\144\t\006\161\\wx@\027\212\152D\141b\005f\255\239\252 \185\018\001\000\198+\142\239\008\003z\147\008\017\172@\172\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\001\000\128@\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\015\254\255\194\011\145 \018\013B\184\238\240\1287\1690\137\026\196\n\204\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\251\255\008.D\128H5\n\227\187\194\000\222\164\194$k\016+0\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\255\239\252 \185\018\001 \212+\142\239\008\003z\147\008\145\172@\172\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\003\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\255\239\252 \185\018\001 \212+\142\239\008\003z\147\008\145\172@\172\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\001\000\128@\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\015\254\255\194\011\145 \018\013B\184\238\240\1287\1690\137\026\196\n\204\000\000\000\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\001\024\000\000\000\128\002\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@\004\128\000\000\000\000\000\000\000\000H\156\000\192\000\000\128\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\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\002\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\000\000\000\004\000\000\000\008\000\000\000\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@\128\000\000\000\000\000\000\016\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\008\001\000\000\000\000\000\002\000\000\008\016\000\000\000\000\000\000\002\000\000\000\004\000\000\000\000\008\000\016\000\016\000\000\000\000\000\000\000\017\128\016\000 \020\000\000\000\000\000\008\000\000 @\000\000\000\000\000\000\008\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\128\001\000\001\000\000\000\000\000\000\000\001\024\001\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\128\000\000\000\000\000\000\000\000\000\156\000\192\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\000F\000`\000\000@\000\000\000\004\000\008\000\000\000\000\000\000\000\000\000\008\192\008\000\000\008\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 \004\000 \000\000\000\000\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\0020\002\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\001\000\000\000\000\000\000\000\000\000\001\024\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\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\008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\016\000\000\000\000\000\000\000\000\000\019\128\024\000\000\016\000\000\000\001\000\002\000\000\000\000\000\000\000\000\000\0020\003\000\000\002\000\000\000\000 \000@\000\000\000\000\000\000\000\000\000F\000@\000\000@\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\008\192\008\000\000\008\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\001\024\000\000\000\001\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\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\008\000\016\000\000\000\000\000\000\000\000\000\017\128\024\000\000\016\000\000\000\001\000\002\000\000\000\000\000\000\000\000\000\0020\002\000\000\002\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000F\000@\000\000@\000\000\000\000\000\008\000\000\000\000\000\000\000\000\000\008\192\000\000\000\008\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\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\128\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") let action = - ((16, "\000\172\000\025\000\000\000\000\000\233\000\000\000\000\000\000\000\172\000\000\000\226)\238\000\000\000\129A\002\000\000\000\000\0252\000\000\030v\000\000\000\000\000\000\000\000\000\000\000\000\025\232\000\000\031,\000\000\000\000\000\000\000\000\000\000\031\226\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\215\000o\000\000)\238 \152CJ\000MA\182\000\000\000\000\000\000C\006\000\005*\152\000!CJ\000\000\000\151\000\000CJ\000\000\000y\000\0038.\000\000\000\0009\252\000\000;$\000\000;\1668.8.\018F\018F;$\018F\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000:~8.\000\000\000\000:~\000\000:~\000\000:~\000\000\000\000\000\000\020\158\000y\000\000\018F\000\000\027P8.\027n8.\000\000\000\000\000\000\000\000\000\000\000\000 \2228.\000\000!\2068.\"&8.#\0228.\000\0008.\000\0008.#n8.$^8.$\1828.%\1668.%\2548.\000?8.\000\000\000\000\000\000\000\000\000\0008.&\2388.'F8.(68.\000\000\000\0008.\000\000\000\000\031\002*\224\000\000\000\000\0005\000\000\000\000\000\000\000\000\023\026\000\129\000\000*\224\000\000\001\001\018F\000\0008.\000\140\000\000\000\000\000y\000\000\000\000\000\000\000\000\001\"\000\000\000\000\001&\000\000\001\206;$\000\000\000\000\000\000\000\000\000\000\000\0008.\005\144\006<\000M\005\186\006\142\000\000=\226>d\018F\005\150\000\000\005\152>d\000\000\000\000\000\000\000\000\000\000\000\000\000\000>\1868.\000\000>\186\000\000>\186>\186\000\000\000\000\024Z\000y\000\000\018F\005\172\000\0008.\005\170\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000+l8.\000\0008.\000\000\005\180\000\000\000\013\000\000\000\000\000\000\000\000\000\000/\242>d0J>d1:>d1\146>d\000\000>d\000\000>d2\130>d2\218>d3\202>d4\">d5\0188.\005\218>d\000\000>d5j>d6Z>d6\178\018F\005\184\000\000\000\0008.\000\000\006\140\000\000\001N\006f8.\0062\000\000\006j8.\006:\000\000\000\214\000\000\006\142\006\142\001N\000\000\001N\000\000\015\190\006\142\006\142\000\000\000\000\000\000\022~\000\000\000\000\000\000\000\000\006~8.\005\208\018\236\019\188\000y\006\164\000\000\006\1348\212\006\1708\212\006\1948.\006\000\018\236\018\236\000y\001D\000!\000\000\000\000\000\000\001D\000\000\002r\000y\000\000\000\000\006\014\000\000\000\000\000\000\006\234\000\000\006\236\000\000\000\000\007\028\006\2148.\006(\007\002\000\000\021\142\006\228\018F\006@\018\236\000\000\000\000\006n\000\000\0009\000\000\005>\000\000\001N\000\000\000\000\006\186\000\000\026\210\008\030\007\000K\222\006P\007(\000\000\000y\000\000\002\0028.-f\000\000?<8.\006Z\000\000\018F\006Z\000\000\006\\\000\000\000\000\000\000\000\000\000\000\000\000\000\000?\1468.\000\000?\146\000\000?\146?\146\000\000\000\000M,\000y\000\000\018F\006`\000\0008.\006^\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\018F\006d@\020\000\000\000\0008.\000k8.\006d\006\150-f.\016,N\007\0208.\006\242\000\000\000\000\000y\006\178-f\000\000\006\180-f\000\000\000\000\012F@\020\013\150@\020\014\230@\020\017t@\020\000\000@\020\000\000@\020+8@\020<\016@\020M\186@\020M\238@\020N.@\020Nb@\020N\132@\020N\220\000\000\000\000\006\138\000\000\006\154.\186\000\000/d\006\164/d7\132\006\170/d\000\000\000\000\000\000\000\000\000\000\006\208-f\000\000\000\000\006\190\000\000\007\166\000\000\000y\000\000\001X\007\168\000\000\007\138\007z\000y\006\220\007\146K\222\006\226\002h\000\0008.\007\182\000\000\001f\001\030\003\190\007\152K\222\006\232\007\190\000\000\002\0208.\007\198\000\000\007\204\000\000\023\026\000y\002\1648.\007\208\000\000\007\212\000\000\011\206\0009\000\000\011\206\000\000\000\000\021\142\002\1668.\007\220\000\000\007\222\000\000\000\000\007\192\007\176\000y\007\026\007\206K\222\007 \002\156\000\0008.\007\244\000\000\0009\000\000\000\000\007\222\000\000\011\206\000\000\007\214\018F\007&\007\250\000\000\001f\000\000\007\224K\222\0076\008\n\000\000\003:8.\008\012\000\000\008\014\000\000\023\026\000y\003\2148.\008\018\000\000\008\022\000\000\000\000\000\000\007\222\000\000\000\000\0009\000\000\006\142\000\000\001p\000\000\000\000\001\158\019\188\000\000\001\158\000\000\000\000\007N\000\000\004\\\000\003\018\236\000\000\003\238\0009\003\238\000\000\0009\000\000\006\142\000\000\006\142\000\000\000\000\000\000\007H\000\000\000\000\007R\000\000\002B\005>\0009\003\238\000\000\000\000\000\000\0009\000\000\006\142\000\000\002B\000\000\000\000\003\186\000\015\015\190\000\000\018\224\000\000\t.\015\190\000\000\000\000\t.\000\000\000\000\007\\\000\000\000\000\007j\000\000\003\138\006\142\000\000\003\138\000\000\000\000\007\218\000\000\0009\000\000\006\142\000\000\000\000\000\000\017\0029V\000\000\008D\000\000\017\002\008F\000\000\008H\000\000\026\210\000y\002\174\000\0008.\008J\000\000\008,\008\028\000y\007\128\008BK\222\007\152\004\026\000\0008.\008p\000\000\001f\004r\000\0008.\008x\000\000\023\026\000y\005@\000\0008.\008z\000\000\003\228\017\002\000\000\021\142\005D\000\0008.\008|\000\000\000\000\000\000\008^\008P\000y\007\178\008fK\222\007\184\005N\000\0008.\008\140\000\000\004^\000\000\008p\018F\007\192\008\148\000\000\001\146\000\000\005T\000\0008.\008\154\000\000\023\026\000y\005j\000\0008.\008\158\000\000\003\228\000\000\000\000\007\214\000\000\004^\005\n\008J\000\000\000\000\000\000\008N\000\000\002\022\000\214\000\000\015\190\008\158\000\000\000\0008.\008\008\006\142\000\000\007\230\000\000\000M\000\000\000\000\001f\015\190\000\000\015\190\000\000\007\246\000\000\001f\000\000;$\002\136;$\000\000;$\000\000\008\012\000\000\002\136\000\000\018\236\002\154\018\236\000\000\018\236\000\000\008\014\000\000\002\154\000\000;$\002\136\008\016\000\000=\154\000y\003v=\154\000\000=\154\000\000\008\018\000\000\003v\000\000;$\002\136\008\022\000\000\000\000\023\206\000\000\000\000\000\000\000\000\000\000\0278\028\190\000\000\006\200\000\000\003r\000\000\000\000\008V\000y\000\000\000\000\000\000\000\000\000o\003r\000\000\003\194\000\242\000\242\000\000\002\134\000\242\000\000\008.\000\000\000\000\000\000\000\000\000\000\000\000\008\174\000\000\029\234\000\000*T\003r\000\000\004\182\003r\000\000\008\192\000\000\003r\008\194\000\000\004\194\0178\008\206\000\000\008\208\000\000\006\018\018\190\003r\008\\\003r\008\216\000\000\008\218\000\000\008\220\000\000)\238\000\000\002\154)\238\000\000\008d\002\212\000\000\000\184\003r\000\000\004\222\003r\000\000\004\004\002\166\000y\000\000\000\154\000y\000\000\008f\000\000\000\000\000\000\000\000\008\232\000\000\007b\020L\008\234\000\000\008\236\000\000\003r\008\238\000\000\003r\008\244\000\000\008\208\003r\008\252\000\000\n\028\0178\003r\008\132\003r\t\000\000\000\t\006\000\000\000\000\005\018\003r\000\000\004f\002\142\001&\000\000\000\000\000\000\003\000\001&\000\000\008\142\000\000\000\000\000\000\000\000\003r\000\000\005\"\003r\000\000\004\224\003V\000y\008\150\000\000\000\000\000\000\000\000\t\020\000\000\t\022\000\000\003r\t$\000\000\n\184\020L\t.\000\000\t0\000\000A\006\008\226\t\014\0160\003r\t:\000\000\000\000\t<\000\000\t\018A\006\003r\t@\000\000\003r\tB\000\000\tD\000\000\012\008\008\204\003r\tV\000\000\tZ\000\000\000y\008\216\000\000\000\000\023\206\000\000\000\000\002>\t\184\000\000\000\000\003h\000\000\000\000\000\0008.\003\026\n\002\t,\t\174;$\000\000\002&;$\000\000\t\000\000\000\000\000\000\000\000\000\000\000\002\158\000\000\003l\000\000\000\000\000\000\003\238K\134\008\254K\134K\134\008\254\000\000\000\000\t.\t.\t.\t.\000\000\000\000\000\000\000\000\000\000\000\000\001N\015\190\t\198\013\030\0009\000\000\000\000\0009\000\000\007\222\000\000-f\t\004\000\000\001N\015\190\t\012\014n\000\000\001N\013\030\000\000\000\000\000\000=\232\nN\000\000\003\026\000\000\000\000\tZ\001\230\t\206L\250\000\000\004\210M>\000\000\000\000\t\212\t\196\000y\000\000\000y\000\000\004\210\000\000\004\212L\250\000\000\000\000\t.\t\220\006\142\t6\000\000\n\198\0009\000\000\007\222\000\000\002\226\000N\000\000\000\000\t\242\000\000\000\000\002>\000\000\003\184\000\000\000\000\000\0008.\003\026\000\000\002\158\000\000\004R\000\000\000\000\000\000\005>\000\000\n~\001\024\n~\000\000\006\142\n~\000\000\001\024\000\000\006\142\000\000\006\142\000\000\006\142\000\000\000\000\000\000\000\000\000\000\003\026\000\000\006\142\000\000\001\024\000\000\006\142\000\000\0042\000\000\000\000\t.\t\156\000y\004r\n.\003\024\000\000\003\024\n^\000\000\n`\000\000\nb\000\000\000\000\003\220\003\024\017\154\003\024\000\000\000\000\005.\tt\000\000\t.\nf\000\000\005\218\008z\nx\011\026\nx\000\000\000\000\006\028\000y\000\000\006`\t\210\000\000\000\000\000\000\001\206\000\000\t\132\000\000\000\000\000\000\000\000\t.\005\218\008z\006\028\006`\001\206\t\144\000\000\005\218\008z\006\028\006`\001\206\t\150\000\000\000y\000\000\n\142\n\140\t\214\000y\n*\000\000"), (16, "\n\209\n\209\n\209\n\209\n\209\n\209\n\209\n\209\n\209\n\209\n\209\000:\n\209\n\209\n\209\n\209\n\209\n\209\n\209\n\209\n\209\n\209\t\146\002\206\002\150\000\n\n\209\003u\005q\000\158\000\194\008J\n\209\006\002\n\209\n\209\n\209\000\218\007]\n\209\008~\n\181\005q\n\209\n\209\000\014\n\209\000\023\000\027\005y\003\245\000\218\008J\007]\000\250\n\209\005>\000\162\n\209\n\209\005\145\008~\000\198\006\001\n\209\n\209\005q\n\209\001\026\n\209\000\242\011u\004\138\000\158\n\209\t\002\n\209\n\209\n\209\n\209\n\209\022\031\n\174\001\006\n\209\n\209\n\209\n\209\n\209\n\209\022#\n\209\n\209\n\209\n\209\003\t\017\150\006\n\n\209\n\209\022&\000\162\007]\011u\011\174\002J\006\194\t\158\n\209\n\209\n\209\n\209\n\209\n\209\n\209\016Z\n\209\000\006\n\209\t\n\005\129\n\209\004\162\n\141\n\209\n\209\003\245\002a\t\158\002\166\n\209\002a\005y\013\174\n\209\011u\011u\n\209\003\198\005Z\011u\n\209\n\209\n\209\n\209\008r\n\209\n\209\005\217\007]\005y\n\209\n\209\n\209\005y\n\209\005\169\n\209\n\209\006\001\n\209\007]\n\209\n\209\000\158\017z\n\209\n\209\006\t\006\t\006\t\006\t\006\t\006\t\006\t\006\t\006\t\006\t\006\t\008v\006\t\006\t\006\t\006\t\006\t\006\t\006\t\006\t\006\t\006\t\t\146\017\166\000\162\004\173\006\t\008N\008^\008n\005\209\008J\006\t\n\141\006\t\006\t\006\t\n\141\n\141\006\t\008~\004\017\008\021\006\t\004\173\018z\006\t\000.\006\"\016\162\016\202\016\242\017\002\017.\nm\006\t\016\130\006j\007I\002\222\018\162\013\006\007I\014\170\006\t\006\t\013\006\n\141\014\174\006\t\006\t\005f\014\178\n\141\006\t\002\133\006\t\006\t\006\t\006\t\006\t\005\161\005\161\015\214\006\t\006\t\006\t\006\t\006\t\006\t\019F\006\t\006\t\006\t\006\t\000\162\000\162\001^\006\t\006\t\012\022\001j\001^\008=\016.\012\022\001j\t\158\004\173\006\t\006\t\006\t\006\t\006\t\006\t\013~\006\t\013\138\006\t\001^\016\138\006\t\012\022\001j\006\t\006\t\004\173\000J\000\162\000N\006\t\000V\002\254\000\162\003\n\008=\008=\006\t\000Z\nm\008=\006\t\006\t\006\t\006\t\t\006\006\t\006\t\nm\005\153\000\162\006\t\006\t\006\t\006)\011\206\006)\006\t\006\t\006)\006\t\001^\006\t\006\t\001f\001j\006\t\006\t\006)\006)\006)\006)\006)\006)\006)\006)\006)\006)\006)\005\193\006)\006)\006)\006)\006)\006)\006)\006)\006)\006)\012\002\023\154\000\162\005\249\006)\020f\006)\000^\n]\013\254\006)\016\170\006)\006)\006)\006)\005q\006)\006)\006)\016\210\006)\006)\000n\006)\000r\012\194\000z\003\018\003f\nm\nm\t\218\006)\000~\014\230\006)\005\021\005q\019B\006)\0126\006)\006)\006)\006)\006)\006)\005q\003r\011\206\018\150\006)\020f\006)\006)\006)\006)\006)\011\206\016B\013\006\006)\006)\006)\006)\006)\006)\020\162\006)\006)\006)\006)\005q\nu\016\178\006)\006)\005q\002\150\019F\006)\023\006\012\006\016\218\005\225\000\162\006)\006)\006)\006)\006)\006)\000\130\006)\017r\006)\001^\000\162\006)\012\022\001j\006)\006)\023\n\nm\t\"\003\190\006)\012\198\003\013\023\014\006)\012V\012\138\006)\017\178\017v\014\234\006)\006)\005q\006)\n\133\006)\006)\018b\017z\000\162\006)\017\014\011\206\011\206\ne\005\185\005q\006)\003\206\006)\019\142\006)\006)\007!\005\201\006)\006)\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\017\134\000\146\020\222\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\230\023\022\013\006\020\138\004\169\006\158\014~\007!\007!\003\214\019V\000\186\007!\001\030\006\174\006\202\nm\n}\006\206\000\162\004\013\013\"\000\190\004\169\004V\008:\004z\017\022\017\162\004\130\004\162\023.\023\030\000\162\001*\006!\006!\021\"\001^\011\206\006!\012\022\001j\008\146\006\214\021N\021Z\017\138\008\150\013\186\015\022\015^\006Q\001R\004\186\001V\003\209\000\206\t\154\008\158\004\198\018\146\013\006\006\234\001^\008\162\006\238\008\166\001j\000\162\006\242\006\246\008\170\006\250\020w\020{\020\207\020\211\008\174\020\127\004\210\020\215\005\233\t\146\015\186\006A\005\177\004\169\006\254\007\002\008\178\008\182\007\006\008\186\015.\000\162\018\022\008\206\001^\013B\003\173\012\022\001j\008\218\007\014\004\169\005\209\006Q\004\222\0061\019>\004\138\004\138\021n\022?\022C\008\250\011\206\017v\022G\008\254\t:\003\209\t\166\023>\007\018\t>\005\241\017z\000\162\007\022\003\209\003\209\015\026\0069\0236\003\209\tF\004\234\007\026\006A\0061\0061\008u\004\246\001\154\0061\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\017\134\000\146\020\222\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\230\0031\015\214\019\138\005\n\006\158\n\149\008u\008u\0152\005\026\000\186\008u\001\030\006\174\006\202\0031\022\254\006\206\005\217\005\217\0069\000\190\022c\022g\008:\n\165\006I\022k\015J\004\162\015n\023.\000\162\001*\005\030\015\166\008J\001^\015\222\003-\012\022\001j\008\146\006\214\021N\008~\017\138\008\150\014\002\015\250\005&\n\157\001R\005*\001V\003\225\000\206\t\154\008\158\n\173\017\246\005R\006\234\001^\008\162\006\238\008\166\001j\000\162\006\242\006\246\008\170\006\250\005V\021\178\021\226\005^\008\174\005\137\002y\018\134\006I\005\130\005\138\005\142\005\150\003-\006\254\007\002\008\178\008\182\007\006\008\186\0031\000\162\018.\008\206\0031\0031\003\173\005\170\003-\008\218\007\014\005\174\005\209\0192\005\198\006Y\0031\005\214\015N\t\158\015r\019~\008\250\005\234\017v\015\170\008\254\t:\015\226\t\166\005\242\007\018\t>\005\250\017z\006\023\007\022\006.\003\225\015\254\0031\006\025\0236\tF\0066\007\026\006:\006Y\006Y\006Z\006r\001\154\006Y\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\017\134\000\146\020\222\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\230\023\134\006\162\006\170\006\178\006\158\006\186\006\190\006\198\006\222\006\230\000\186\003-\001\030\006\174\006\202\003-\003-\006\206\008\025\007>\007J\000\190\007\146\008\n\008:\0082\008F\003-\022\254\008R\008Z\008b\000\162\001*\008j\008\190\008J\008\198\008\214\008\222\008\025\008\230\008z\006\214\006\025\008~\017\138\008\150\006\025\006\025\008\025\003-\001R\008\238\001V\003\253\000\206\008\154\008\158\017j\023z\008\246\006\234\001^\008\162\006\238\008\166\001j\t2\006\242\006\246\008\170\006\250\tB\tJ\tV\011}\008\174\023\142\tZ\008\025\tb\003\141\023\146\006\025\tf\tr\006\254\007\002\008\178\008\182\007\006\008\186\tz\000\162\017r\008\206\t\138\t\174\003\173\t\190\t\198\008\218\007\014\t\202\t\242\t\254\n\006\008E\nZ\nf\n\154\t\158\n\182\n\186\008\250\n\202\017v\003\141\008\254\t:\003\253\t\166\008\025\007\018\t>\n\210\017z\n\226\007\022\003\253\003\253\n\238\011r\011z\003\253\tF\008\025\007\026\011\138\008E\008E\011\150\011\178\001\154\008E\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\018\202\000\146\011\194\000\150\006\150\000\154\000\174\000\178\000\182\006\154\011\202\011\222\011\230\011\234\011\242\006\158\011\246\011\254\012\014\012\"\012*\000\186\012.\001\030\006\174\006\202\012>\005q\006\206\012F\005q\012^\000\190\012f\005q\008:\005q\012\146\012\154\012\166\012\170\005q\005q\000\162\001*\012\178\012\182\008J\012\190\012\206\012\242\012\250\012\254\008z\006\214\013\014\008~\017\138\008\150\013\022\013\026\013*\0132\001R\013J\001V\013R\000\206\008\154\008\158\013\162\013\234\013\246\006\234\001^\008\162\006\238\008\166\001j\014j\006\242\006\246\008\170\006\250\014v\014\150\005q\011}\008\174\014\194\014\206\014\214\014\242\014\250\014\254\000\218\015\006\023b\006\254\007\002\008\178\008\182\007\006\008\186\015\n\000\162\001^\008\206\015\018\001f\001j\015\"\006\017\008\218\007\014\015:\015V\015z\015\138\011}\015\142\015\150\015\154\t\158\015\162\015\178\008\250\015\194\015\202\015\206\008\254\t:\015\234\t\166\016\006\007\018\t>\000\162\016\026\005q\007\022\016*\005q\016:\016R\016b\005q\tF\005q\007\026\016n\011}\011}\005q\005q\001\154\011}\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\016\151\000\146\020\254\000\150\006\150\000\154\000\174\000\178\000\182\006\154\021\002\016\191\016\231\016\255\017#\006\158\017;\017~\017\190\003\153\017\219\000\186\006\017\001\030\006\174\006\202\006\017\006\017\006\206\018\003\018\015\022\242\000\190\007e\003\153\008:\018\031\018'\006\017\002\150\018:\018C\018K\018S\001*\018n\018\174\008J\007e\018\195\018\211\018\219\018\231\008z\006\214\018\243\008~\018\250\008\150\019\003\019\022\019\031\006\017\001R\019'\001V\019b\000\206\008\154\008\158\019\150\019\171\019\179\006\234\001^\008\162\006\238\008\166\001j\019\191\006\242\006\246\008\170\006\250\019\207\019\215\005q\019\226\008\174\019\230\019\243\019\255\020\006\020\019\020\031\020'\0202\007e\006\254\007\002\008\178\008\182\007\006\008\186\020;\000\162\020C\008\206\023N\020O\003\193\020j\003\153\008\218\007\014\023R\003\153\003\153\020\142\019\n\020\146\020\150\020\174\t\158\021.\021V\008\250\021f\003\153\003\153\008\254\t:\021\158\t\166\021\166\007\018\t>\021\194\021\198\006\142\007\022\017v\006\146\021\242\007e\021\246\020\254\tF\006\150\007\026\021\254\017z\003\153\006\154\021\002\001\154\007e\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\022+\000\146\020\222\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\230\022\246\023\002\017\134\000:\006\158\023\018\023\026\023\"\023K\023V\000\186\023f\001\030\006\174\006\202\023\138\023\163\006\206\017r\011\230\006\142\000\190\023\207\006\146\008:\023\235\023\250\020\254\023\254\006\150\024\002\024\011\000\000\001*\006\154\021\002\000\000\000\000\000\000\000\000\017v\000\000\008\146\006\214\000\000\000\162\000\000\008\150\022z\000\000\017z\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\017\138\000\000\000\000\006\234\001^\008\162\006\238\008\166\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\003\193\000\000\008\174\000\000\012\166\019\198\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\003\173\000\000\nU\008\218\007\014\000\000\000\000\000\000\000\000\008)\000\000\000\000\000\000\000\000\000\000\000\000\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\162\007\018\t>\000\000\000\000\000\000\007\022\000\000\000\000\000\000\000\000\000\000\003\193\tF\017\138\007\026\000\000\008)\008)\000\000\000\000\001\154\008)\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\000\000\000\000\000\000\006\158\000\000\000\000\000\000\000\000\000\000\000\186\nU\001\030\006\174\006\202\nU\nU\006\206\017r\000\000\000\000\000\190\000\000\000\000\008:\000\000\000\000\nU\000\000\000\000\000\000\000\000\000\000\001*\000\000\000\000\000\000\000\000\023j\000\000\017v\000\000\008\146\006\214\000\000\000\000\000\000\008\150\012n\000\000\017z\nU\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\n\254\000\000\006\234\001^\008\162\006\238\008\166\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\020.\011Y\008\174\011\006\000\000\017\134\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\008\178\008\182\007\006\008\186\011\014\000\162\000\000\008\206\000\000\000\000\011N\011V\000\000\008\218\007\014\000\000\000\000\000\000\000\000\011Y\011.\000\000\000\000\011\022\000\000\011&\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\162\007\018\t>\000\000\000\000\000\000\007\022\000\000\000\000\000\000\000\000\0116\000\000\tF\017\138\007\026\000\000\011Y\011Y\000\000\000\000\001\154\011Y\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\011>\000\000\000\000\006\158\000\000\000\000\000\000\011\030\000\000\000\186\000\000\001\030\006\174\006\202\000\000\000\000\006\206\000\000\000\000\004\229\000\190\000\000\000\000\008:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001*\000\000\011^\011F\000\000\000\000\000\000\000\000\000\000\008\146\006\214\000\000\000\000\000\000\008\150\0212\000\000\000\000\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\181\000\000\006\234\001^\008\162\006\238\008\166\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\000\000\000\000\008\174\011\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\008\178\008\182\007\006\008\186\011\014\000\162\000\000\008\206\000\000\000\000\000\181\000\181\000\000\008\218\007\014\000\000\000\000\000\000\000\000\011\165\011.\000\000\000\000\011\022\000\000\011&\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\000\007\018\t>\000\000\000\000\000\000\007\022\000\000\000\000\000\000\000\000\0116\000\000\tF\000\000\007\026\000\000\011\165\011\165\000\000\000\000\001\154\011\165\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\011>\000\000\000\000\006\158\000\000\000\000\000\000\011\030\000\000\000\186\000\000\001\030\006\174\006\202\000\000\000\000\006\206\000\000\000\000\000\181\000\190\000\000\000\000\008:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001*\000\000\000\181\011F\000\000\000\000\000\000\000\000\000\000\008\146\006\214\000\000\000\000\000\000\008\150\0212\000\000\000\000\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\157\000\000\006\234\001^\008\162\006\238\008\166\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\000\000\000\000\008\174\000\157\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\008\178\008\182\007\006\008\186\011\014\000\162\000\000\008\206\000\000\000\000\000\157\000\157\000\000\008\218\007\014\000\000\000\000\000\000\000\000\011\161\000\157\000\000\000\000\011\022\000\000\011&\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\000\007\018\t>\000\000\000\000\000\000\007\022\000\000\000\000\000\000\000\000\000\157\000\000\tF\000\000\007\026\000\000\011\161\011\161\000\000\000\000\001\154\011\161\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\000\157\000\000\000\000\006\158\000\000\000\000\000\000\011\030\000\000\000\186\000\000\001\030\006\174\006\202\000\000\000\000\006\206\000\000\000\000\000\157\000\190\000\000\000\000\008:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001*\000\000\000\157\000\157\000\000\000\000\000\000\000\000\000\000\008\146\006\214\000\000\000\000\004\149\008\150\0146\000\000\000\000\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\000\000\000\006\234\001^\008\162\006\238\008\166\001j\004\149\006\242\006\246\008\170\006\250\000\000\000\000\000\000\000\000\008\174\004\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\000\000\000\000\000\000\008\218\007\014\000\000\000\000\t\245\000\000\004\149\004\149\000\000\000\000\000\000\000\000\000\000\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\000\007\018\t>\000\000\000\000\000\000\007\022\t\245\000\000\000\000\000\000\000\000\000\000\tF\000\000\007\026\000\000\0002\006&\000F\000b\001\154\000f\006\142\000j\000\134\006\146\000\138\004\149\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\000\000\000\000\004\149\000\000\000\000\000\000\000\000\000\000\000\000\000\186\000\000\001\030\000\000\006\202\000\000\017r\006\206\000\000\000\000\000\000\000\190\000\000\t\245\014\182\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\017v\000\000\000\000\000\000\014\198\006\214\000\000\000\000\000\000\000\000\017z\000\000\000\000\000\000\001R\000\000\001V\000\000\000\206\000\149\000\000\000\000\000\000\000\000\006\234\001^\000\000\006\238\001f\001j\000\000\006\242\006\246\008\170\006\250\019\014\000\000\000\149\n\001\000\000\017\134\000\000\000\000\000\000\000\000\000\000\003)\000\000\000\000\006\254\007\002\000\000\000\149\007\006\000\000\000\000\000\162\000\000\000\149\000\149\000\000\003)\n\001\000\000\000\000\007\014\000\000\000\000\000\149\000\000\000\000\011\022\000\000\000\149\000\000\000\000\000\000\003)\000\000\000\000\000\000\000\000\000\000\000\162\t\166\000\000\007\018\014\202\000\000\000\000\000\000\007\022\000\000\000\149\000\000\000\000\000\000\017\138\014\210\000\000\007\026\000\000\0002\0006\000F\000b\001\154\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\000\000\150\n\001\000\154\000\174\000\178\000\182\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\186\011\030\001\030\000\000\001\"\003)\000\000\001&\000\000\003)\003)\000\190\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003)\000\000\001*\000\000\000\000\001.\000\000\000\149\000\149\000\000\000\000\001F\001B\000\000\001J\003)\000\000\000\000\017r\000\000\000\000\001R\000\000\001V\003)\000\206\0236\000\000\000\000\000\000\000\000\001Z\001^\000\000\001b\001f\001j\001\190\001n\001r\017v\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017z\000\000\000\000\000\000\000\000\000\000\006\158\001z\000\000\000\000\001~\000\000\000\000\000\162\001\030\006\174\006\202\000\000\007]\006\206\000\000\000\000\001\134\t\146\000\000\0182\008:\000\000\000\000\000\000\017\134\001\138\008J\007]\000\000\001*\000\000\000\000\000\000\000\000\000\000\008~\000\000\001\142\008\202\006\214\000\000\000\000\001\146\008\150\000\000\003q\n\001\000\000\001R\000\000\001V\001\150\000\000\000\000\008\158\000\000\000\000\001\154\006\234\001^\008\162\006\238\008\166\001j\000\000\006\242\006\246\000\162\006\250\000\000\000\000\000\000\000\000\008\174\000\000\000\000\007]\000\000\000\000\000\000\000\000\017\138\000\000\006\254\007\002\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\000\000\000\000\000\000\008\218\007\014\000\000\n\001\t\158\000\000\006\158\000\000\000\000\000\000\000\000\000\000\000\000\008\250\001\030\006\174\006\202\008\254\t:\006\206\000\000\000\000\007\018\t>\000\000\007]\008:\007\022\000\000\000\000\000\000\000\000\000\000\000\000\tF\001*\007\026\007]\000\000\000\000\000\000\000\000\001\154\000\000\006\210\006\214\000\000\000\000\000\000\008\150\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\008\158\000\000\000\000\017r\006\234\001^\008\162\006\238\008\166\001j\000\000\006\242\006\246\000\000\006\250\000\000\000\000\000\000\000\000\008\174\000\000\000\000\000\000\000\000\000\000\017v\000\000\000\000\000\000\006\254\007\002\008\178\008\182\007\006\008\186\017z\000\162\000\000\008\206\000\000\000\000\000\000\000\000\000\000\008\218\007\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\185\000\000\008\250\011\185\000\000\000\000\008\254\t:\n\013\000\000\017\134\007\018\t>\000\000\000\000\000\000\007\022\000\000\011\185\000\000\000\000\000\000\011\185\tF\000\000\007\026\001\178\011\185\000\000\000\000\000\000\001\154\n\013\011\185\000\000\000\000\011\185\011\185\000\000\011\185\011\185\000\000\000\000\001\186\000\000\011\185\002\214\000\000\000\000\011\185\000\000\000\000\011\185\000\162\011\185\011\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\138\000\000\000\000\000\000\000\000\000\000\000\000\011\185\000\000\011\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\185\n\013\000\000\000\000\000\000\002\226\000\000\000\000\000\000\000\000\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\185\011\185\011\185\000\000\011\185\011\185\002\230\000\000\011\185\000\000\000\000\000\000\004\013\000\000\000\000\004\013\002\238\000\000\000\000\000\000\011\185\000\000\000\000\011\185\011\185\011\185\011\185\000\000\000\000\000\000\004\013\011\185\011\185\011\185\004\013\011\185\011\185\011\185\004\013\004\013\000\000\000\000\000\000\000\000\000\000\004\013\000\000\000\000\004\013\004\013\000\000\004\013\004\013\000\000\000\000\004\013\000\000\004\013\004\013\000\000\000\000\004\013\000\000\000\000\004\013\000\000\004\013\004\013\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\013\000\000\004\013\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\013\000\000\000\000\000\000\000\000\004\013\000\000\000\000\000\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\004\013\004\013\004\013\000\000\004\013\004\169\004\013\000\000\004\013\000\000\000\000\000\000\004\017\000\000\000\000\004\017\004\013\000\000\000\000\000\000\004\013\000\000\000\000\004\013\000\000\004\013\000\000\000\000\000\000\000\000\004\017\004\013\004\013\004\013\004\017\004\013\004\013\004\013\004\017\004\017\000\000\000\000\000\000\000\000\000\000\004\017\000\000\000\000\004\017\004\017\000\000\004\017\004\017\000\000\000\000\004\017\000\000\004\017\004\017\000\000\000\000\004\017\000\000\000\000\004\017\000\000\004\017\004\017\000\000\002\186\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\004\017\000\182\004\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\017\000\000\000\186\000\000\000\000\004\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\017\004\017\004\017\000\000\004\017\004\173\004\017\000\000\004\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\017\000\000\000\000\000\000\004\017\000\000\000\000\004\017\000\000\004\017\000\206\000\000\000\000\000\000\000\000\004\017\004\017\004\017\000\000\004\017\004\017\004\017\001=\001=\001=\001=\000\000\001=\000\000\001=\001=\000\000\001=\000\000\001=\000\000\001=\000\000\001=\001=\001=\001=\000\000\000\000\000\000\000\000\017F\000\000\000\162\000\000\000\000\000\000\000\000\001=\001=\001=\000\000\000\000\000\000\000\000\001=\000\000\000\000\000\000\000\000\001=\000\000\000\000\000\000\001=\000\000\000\000\000\000\001=\000\000\000\000\017J\000\000\000\000\001=\000\000\006~\006J\000b\000\000\000f\001=\006N\000\134\000\000\000\138\001=\000\146\000\000\000\150\000\000\000\154\000\174\000\000\000\182\001=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\000\000\012\013\000\000\000\000\012\013\000\000\001=\000\000\000\000\001=\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\013\000\000\000\000\000\000\012\013\001=\000\000\001=\007.\012\013\001=\000\000\001=\000\000\000\000\012\013\000\000\001=\012\013\012\013\001=\012\013\012\013\000\000\000\000\0076\000\206\012\013\007B\000\000\000\000\012\013\000\000\000\000\012\013\001=\012\013\012\013\001=\001=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017N\000\000\000\000\000\000\000\000\000\000\000\000\012\013\000\000\012\013\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\013\000\000\000\000\000\000\000\000\007N\0041\000\000\000J\0041\000N\0041\000V\0041\000\000\0041\000\000\000\000\000\000\000Z\0041\0041\012\013\012\013\012\013\000\000\012\013\000\000\007R\000\000\012\013\000\000\000\000\0041\000\000\000\000\000\000\000\000\007Z\000\000\000\000\000\000\000\000\0041\0041\012\013\000\000\012\013\000\000\0041\000\000\000\000\000\000\012\013\012\013\012\013\000\000\012\013\012\013\012\013\000\000\000\000\000\000\000\000\000\000\0041\000\000\000\000\0041\000\000\000\000\000\000\000\000\0041\0041\000\000\000\000\0041\000^\000\000\000\000\000\000\000\000\000\000\000\000\0041\000\000\000\000\0041\0041\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0045\0041\000n\0045\000r\0045\000z\0045\000\000\0045\000\000\0041\000\000\000~\0045\0045\000\000\000\000\000\000\0041\000\000\000\000\000\000\000\000\0041\000\000\000\000\0045\000\000\000\000\000\000\000\000\000\000\0041\000\000\000\000\000\000\0045\0045\000\000\000\000\000\000\000\000\0045\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0041\000\000\000\000\0041\0041\000\000\0045\0041\000\000\0045\000\000\000\000\0041\0041\0045\0045\000\000\0041\0045\000\130\000\000\000\000\000\000\000\000\000\000\000\000\0045\000\000\000\000\0045\0045\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0045\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0045\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0045\0002\t\182\000F\000b\0045\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\0045\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\0045\000\000\000\000\0045\0045\000\000\000\000\0045\000\000\000\000\000\190\000\000\0045\0045\000\000\000\000\000\000\0045\t\241\t\241\t\241\t\241\000\000\t\241\000\000\t\241\t\241\000\000\t\241\000\000\t\241\000\202\t\241\000\000\t\241\t\241\t\241\t\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\t\241\t\241\t\241\001\137\000\000\000\000\001\137\t\241\000\000\000\000\000\000\000\000\t\241\000\000\000\000\000\000\017^\000\000\001\137\000\000\017f\001\137\000\000\000\000\000\000\000\000\t\241\000\000\000\000\000\000\001\137\000\000\000\000\t\241\000\162\000\000\001\137\000\000\t\241\000\000\001\137\000\000\001\137\001\137\000\000\001\137\000\000\t\241\000\000\000\000\000\000\001\137\001\137\000\000\001\137\001\137\000\000\001\137\001\137\000\000\000\000\000\000\000\000\001\137\000\000\000\000\t\241\001\137\000\000\t\241\001\137\000\000\001\137\001\137\000\000\000\000\000\000\001\137\000\000\001\137\000\000\000\000\000\000\000\000\t\241\000\000\t\241\000\000\000\000\t\241\000\000\t\241\001\137\000\000\001\137\000\000\t\241\000\000\000\000\t\241\000\000\000\000\000\000\000\000\001\137\000\000\000\000\000\000\000\000\000\000\000\000\001\137\001\137\001\198\t\241\001\137\001\137\017\222\t\241\001\137\000\000\000\000\000\000\000\000\000\000\000\000\001\137\001\137\001\206\000\000\001\137\001\137\000\000\000\000\001\137\001\137\000\000\001\137\000\000\000\000\000\000\000\000\002\134\001\137\001\137\000\000\001\137\001\137\001\137\001\137\001\137\001\137\001\137\000\000\000\000\000\000\000\000\002z\001\137\001\137\000\000\001\137\001\137\001\137\t\225\t\225\t\225\t\225\000\000\t\225\000\000\t\225\t\225\000\000\t\225\000\000\t\225\000\000\t\225\000\000\t\225\t\225\t\225\t\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\225\t\225\t\225\000\000\000\000\000\000\000\000\t\225\000\000\000\000\000\000\000\000\t\225\000\000\000\000\000\000\000\000\003\202\000\000\000\000\000\000\000\000\003M\000\000\003M\000\000\t\225\003M\000\000\000\000\000\000\000\000\000\000\t\225\000\000\000\000\000\000\000\000\t\225\000\000\000\000\000\000\000\000\003M\000\000\000\000\003M\t\225\000\000\000\000\000\000\000\000\003M\003M\000\000\003M\000\000\000\000\000\000\000\000\000\000\000\000\003M\000\000\003M\000\000\t\225\000\000\000\000\t\225\000\000\000\000\003M\003M\000\000\003M\003M\003M\000\000\003M\003M\000\000\003M\000\000\t\225\000\000\t\225\000\000\000\000\t\225\000\000\t\225\000\000\000\000\000\000\000\000\t\225\000\000\003M\t\225\000\000\003M\000\000\000\000\003M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003M\t\225\000\000\000\000\017b\t\225\t\229\t\229\t\229\t\229\000\000\t\229\000\000\t\229\t\229\000\000\t\229\000\000\t\229\000\000\t\229\003M\t\229\t\229\t\229\t\229\003M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003M\000\000\t\229\t\229\t\229\000\000\003M\000\000\000\000\t\229\000\000\000\000\000\000\000\000\t\229\000\000\000\000\000\000\017\226\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\229\000\000\000\000\000\000\000\000\000\000\000\000\t\229\000\000\000\000\000\000\000\000\t\229\000\000\000\000\000\000\000\000\000\000\000\000\004i\000\000\t\229\004i\000R\004i\000\000\004i\000\000\004i\000\000\000\000\000\000\000\000\004i\004i\000\000\000\000\000\000\000\000\000\000\t\229\000\000\000\000\t\229\000\000\000\000\004i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004i\004i\t\229\000\000\t\229\000\000\004i\t\229\000\000\t\229\000\000\000\000\000\000\000\000\t\229\000\000\000\000\t\229\000\000\000\000\000\000\000\000\004i\000\000\000\000\004i\000\000\000\000\000\000\000\000\004i\004i\t\229\000\000\004i\004i\t\229\000\000\005q\000\000\000\000\000\000\004i\000\000\000\000\004i\004i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004m\004i\000\000\004m\000v\004m\005q\004m\000\000\004m\000\000\004i\000\000\000\000\004m\004m\005q\005q\000\000\004i\000\000\000\000\000\000\000\000\004i\000\000\000\000\004m\000\000\000\000\000\000\000\000\000\000\004i\000\000\000\000\000\000\004m\004m\000\000\000\000\005q\000\000\004m\000\000\000\000\005q\002\150\000\000\000\000\005q\000\000\000\000\004i\000\000\000\000\004i\004i\000\000\004m\004i\000\000\004m\000\000\000\000\004i\004i\004m\004m\000\000\004i\004m\004m\000\000\000\000\000\000\000\000\000\000\000\000\004m\000\000\005q\004m\004m\000\000\000\000\000\000\000\000\000\000\005q\000\000\004q\004m\000\000\004q\000\142\004q\000\000\004q\000\000\004q\000\000\004m\005q\000\000\004q\004q\000\000\000\000\000\000\004m\000\000\000\000\000\000\000\000\004m\000\000\000\000\004q\000\000\000\000\000\000\000\000\005q\004m\000\000\005q\005q\004q\004q\005q\000\000\000\000\000\000\004q\000\000\000\000\000\000\000\000\000\000\005q\000\000\000\000\000\000\004m\000\000\000\000\004m\004m\000\000\004q\004m\000\000\004q\000\000\000\000\004m\004m\004q\004q\000\000\004m\004q\004q\000\000\000\000\000\000\000\000\000\000\000\000\004q\000\000\000\000\004q\004q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\165\004q\000\000\004\165\000\000\004\165\000\000\004\165\000\000\004\165\000\000\004q\000\000\000\000\004\165\004\165\000\000\000\000\000\000\004q\000\000\000\000\000\000\000\000\004q\000\000\000\000\004\165\000\000\000\000\000\000\000\000\000\000\004q\000\000\000\000\000\000\004\165\004\165\000\000\000\000\000\000\000\000\004\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\238\000\000\004q\002B\000\000\004q\004q\000\000\004\165\004q\000\000\004\165\000\210\000\000\004q\004q\004\165\004\165\001\250\004q\004\165\004\165\002\001\000\000\000\000\000\000\000\000\002\001\004\165\000\000\000\000\004\165\004\165\002\002\000\000\000\000\002\001\002\001\000\000\002b\002j\004\165\000\000\000\000\000\000\002\001\000\000\000\000\000\000\002\"\000\000\004\165\002\n\000\000\002\026\002\001\000\000\000\000\000\000\004\165\000\000\000\000\000\000\000\000\004\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\165\002*\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\004\165\000\000\000\000\004\165\004\165\000\000\000\000\004\165\000\000\000\000\000\000\000\000\004\165\004\165\000\000\002\001\0022\004\165\000\000\002\001\002\001\000\000\000\000\002\018\000\000\000\000\000\000\000}\000\000\000\000\000}\000\000\000\000\000\000\000\000\002\001\000\000\000\000\002\001\002\001\002\001\002\001\000\000\000\000\000\000\001\250\000\000\002\001\002\001\000}\002r\002:\002\001\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\000e\000}\000\000\000e\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000}\000\000\000\000\000\000\000\000\000\000\000\000\000e\000\000\000\000\000\000\000e\000\000\000\000\000\000\000\000\000e\000\000\000\000\002*\000\000\000}\002\002\000\000\000\000\000e\000e\000\000\000e\000e\000\000\000}\000\000\000\000\000e\000\000\000\000\000\000\000e\000\000\000\000\002\n\000\000\002\026\000e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\0022\000\000\000\000\000}\000}\000\000\000\000\002\018\000\000\000e\000\000\000e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\000\000\000e\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\000e\000e\000\000\000\000\000e\000e\000\000\000\000\002\018\000\000\000\000\000\000\000]\000\000\000\000\000]\000\000\000\000\000\000\000\000\000e\000\000\000\000\000e\000e\000e\000e\000\000\000\000\000\000\000]\000\000\000e\000e\000]\000e\000e\000e\000\000\000]\000\000\000\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\000a\000\000\000]\000\000\000\000\002\n\000\000\000]\000]\000\000\000\000\000\000\000\000\000\000\000\000\000a\000\000\000\000\000\000\000a\000\000\000\000\000\000\000\000\000a\000\000\000\000\000]\000\000\000]\000a\000\000\000\000\000a\000a\000\000\000a\000a\000\000\000]\000\000\000\000\000a\000\000\000\000\000\000\000a\000\000\000\000\002\n\000\000\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\000\000\000\002\018\000\000\000a\000\000\000a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000]\000\000\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\000\000\000\000\000\000\000\000\000a\000a\000\000\000\000\000a\000a\000\000\000\000\002\018\000\000\000\000\000\000\000q\000\000\000\000\000q\000\000\000\000\000\000\000\000\000a\000\000\000\000\000a\000a\000a\000a\000\000\000\000\000\000\001\250\000\000\000a\000a\000q\000a\000a\000a\000\000\000q\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000q\000q\000\000\000q\000q\000\000\000\000\000\000\000i\000q\000\000\000i\000\000\000q\000\000\000\000\002\n\000\000\002\026\000q\000\000\000\000\000\000\000\000\000\000\000\000\001\250\000\000\000\000\000\000\000i\000\000\000\000\000\000\000\000\000i\000\000\000\000\002*\000\000\000q\002\002\000\000\000\000\000i\000i\000\000\000i\000i\000\000\000q\000\000\000\000\000i\000\000\000\000\000\000\000i\000\000\000\000\002\n\000\000\002\026\000i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000q\000q\000\000\000\000\000q\000q\000\000\000\000\002\018\000\000\000i\000\000\000i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000q\000\000\000i\000q\000q\000q\000q\000\000\000\000\000\000\000\000\000\000\000q\000q\000\000\000q\000q\000q\000\000\000\000\000\000\000\000\000\000\000\000\000i\000i\000\000\000\000\000i\000i\000\000\000\000\002\018\000\000\000\000\000\000\000m\000\000\000\000\000m\000\000\000\000\000\000\000\000\000i\000\000\000\000\000i\000i\000i\000i\000\000\000\000\000\000\001\250\000\000\000i\000i\000m\000i\000i\000i\000\000\000m\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000m\000m\000\000\000m\000m\000\000\000\000\000\000\000u\000m\000\000\000u\000\000\000m\000\000\000\000\002\n\000\000\002\026\000m\000\000\000\000\000\000\000\000\000\000\000\000\001\250\000\000\000\000\000\000\000u\000\000\000\000\000\000\000\000\000u\000\000\000\000\002*\000\000\000m\002\002\000\000\000\000\000u\000u\000\000\000u\000u\000\000\000m\000\000\000\000\000u\000\000\000\000\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000m\000m\000\000\000\000\000m\000m\000\000\000\000\002\018\000\000\002*\000\000\000u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000m\000\000\000u\000m\000m\000m\000m\000\000\000\000\000\000\000\000\000\000\000m\000m\000\000\000m\000m\000m\000\000\000\000\000\000\000\000\000\000\000\000\000u\0022\000\000\000\000\000u\000u\000\000\000\000\002\018\000\000\000\000\000\000\001\238\000\000\000\000\000\133\000\000\000\000\000\000\000\000\000u\000\000\000\000\000u\000u\000u\000u\000\000\000\000\000\000\001\250\000\000\000u\000u\000\133\000u\000u\000u\000\000\000\133\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\133\000\133\000\000\000\133\002j\000\000\000\000\000\000\001\238\000\133\000\000\000y\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000\133\000\000\000\000\000\000\000\000\000\000\000\000\001\250\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\000\000y\000\000\000\000\002*\000\000\000\133\002\002\000\000\000\000\000y\000y\000\000\000y\000y\000\000\000\133\000\000\000\000\000y\000\000\000\000\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\0022\000\000\000\000\000\133\000\133\000\000\000\000\002\018\000\000\002*\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\000\000\000y\000\133\000\133\000\133\000\133\000\000\000\000\000\000\000\000\000\000\000\133\000\133\000\000\002r\002:\000\133\000\000\000\000\000\000\000\000\000\000\000\000\000y\0022\000\000\000\000\000y\000y\000\000\000\000\002\018\000\000\000\000\000\000\001\238\000\000\000\000\000\129\000\000\000\000\000\000\000\000\000y\000\000\000\000\000y\000y\000y\000y\000\000\000\000\000\000\001\250\000\000\000y\000y\000\129\000y\002:\000y\000\000\000\129\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\129\000\129\000\000\000\129\002j\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000\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\002*\000\000\000\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\004\133\000\000\000\000\004\133\000\000\004\133\000\000\004\133\000\000\004\133\000\000\000\000\000\000\000\000\004\133\004\133\000\000\000\000\000\000\000\000\000\000\000\129\0022\000\000\000\000\000\129\000\129\004\133\000\000\002\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\133\004\133\000\000\000\000\000\129\000\000\004\133\000\129\000\129\000\129\000\129\000\000\000\000\000\000\000\000\000\000\000\129\000\129\000\000\000\129\002:\000\129\004\133\000\000\000\000\004\133\005\226\000\000\000\000\000\000\004\133\004\133\000\000\000\000\004\133\004\133\000\000\000\000\000\000\000\000\000\000\000\000\004\133\000\000\000\000\004\133\004\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\133\0002\0006\000F\000b\004\133\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\004\133\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\004\133\000\000\000\000\004\133\004\133\000\000\000\000\004\133\000\000\000\000\000\190\000\000\004\133\004\133\000\000\000\000\000\000\004\133\0002\0006\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\202\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\017\234\000\186\018\006\0002\000\214\000F\000b\018\018\000f\000\000\000j\000\134\000\190\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\018*\000\000\000\000\000\000\000\000\000\000\000\000\000\202\000\000\000\186\000\000\000\000\018V\000\000\000\000\000\000\000\000\000\000\000\000\005q\000\190\000\206\005q\000\000\005q\000\000\005q\000\000\005q\000\000\000\000\000\000\000\000\005q\005q\000\000\000\000\000\000\000\000\000\000\018v\000\202\000\000\018\198\000\000\000\000\005q\000\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\005q\005q\018\222\000\000\008\017\000\000\005q\018\234\000\000\018\246\000\000\000\000\000\000\000\000\019\006\000\000\000\000\019\182\000\000\000\000\000\000\000\000\005q\000\153\000\000\005q\000\000\000\000\000\000\000\000\005q\002\150\019\194\000\000\005q\005q\019\218\000\162\000\000\000\000\000\000\000\153\005q\000\000\000\000\005q\005q\000\000\000\000\001\161\000\000\000\000\001\161\000\000\000\000\005q\000\153\000\000\000\000\000\000\000\000\000\000\000\153\000\153\000\000\005q\000\000\001\161\000\000\000\000\000\000\001\161\000\153\005q\000\000\011\022\001\161\000\153\005q\000\000\000\000\000\000\001\161\000\000\000\000\001\161\001\161\005q\001\161\001\161\000\000\000\000\000\000\000\000\001\161\000\000\000\000\000\153\001\161\000\000\000\000\001\161\000\000\001\161\001\161\000\000\000\000\005q\000\000\000\000\005q\005q\000\000\000\000\005q\000\000\000\000\000\000\000\000\005q\005q\000\000\000\000\001\161\005q\001\161\000\000\000\000\000\000\000\000\000\000\000\000\000\153\000\000\000\000\001\161\000\000\000\000\000\000\011\030\000\000\000\000\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\000\000\000\000\000\001\161\001\161\007~\000\000\001\161\000\000\000\000\000\000\001\161\000\153\000\153\000\000\n\198\000\000\000\000\000\000\000\000\003U\000\000\003U\000\000\000\000\003U\001\161\000\000\001\161\000\000\000\000\000\000\000\000\000\000\007\134\001\161\001\161\000\000\001\161\001\161\001\161\003U\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003U\003U\000\000\000\000\003U\003U\000\000\000\000\000\000\000\000\003U\000\000\003U\000\000\011\241\000\000\000\000\011\241\000\000\000\000\003U\003U\000\000\003U\003U\003U\000\000\003U\003U\000\000\003U\000\000\011\241\000\000\000\000\000\000\011\241\000\000\000\000\000\000\003V\000\000\000\000\000\000\000\000\003U\003U\011\241\000\000\003U\000\000\011\241\003U\011\241\011\241\000\000\000\000\003^\000\000\000\000\003j\003U\000\000\011\241\000\000\000\000\011\241\000\000\011\241\000\000\003U\000\000\003U\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003U\000\000\000\000\000\000\000\000\003U\011\241\000\000\000\000\000\000\000\000\003U\000\000\000\000\003U\000\000\000\000\000\000\011\241\000\000\003U\000\000\000\000\003v\000\000\000\000\000\000\000\000\001\030\000\000\t\226\000\000\000\000\t\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\241\011\241\000\000\011\241\000\000\003z\000\000\011\241\001*\000\000\000\000\000\000\000\000\000\000\000\000\003\130\000\000\t\234\n\146\011\241\000\000\n\166\n\190\000\000\011\241\011\241\000\000\001R\000\000\001V\011\241\000\000\000\000\000\000\011\241\011\241\011\241\n\n\001^\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\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\000\000\006\254\n\030\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001\030\000\000\t\226\000\000\000\000\t\230\n*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\194\000\000\n\218\000\000\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\t\234\n\146\n2\000\000\n\166\n\190\000\000\000\000\011\186\000\000\001R\n6\001V\000\000\000\000\000\000\000\000\001\154\000\000\000\000\n\n\001^\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\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\000\000\006\254\n\030\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001\030\000\000\t\226\000\000\000\000\t\230\n*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\194\000\000\n\218\000\000\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\t\234\n\146\n2\000\000\n\166\n\190\000\000\000\000\011f\000\000\001R\n6\001V\000\000\000\000\000\000\000\000\001\154\000\000\000\000\n\n\001^\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\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\000\000\006\254\n\030\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001\030\000\000\t\226\000\000\000\000\t\230\n*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\194\000\000\n\218\000\000\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\t\234\n\146\n2\000\000\n\166\n\190\000\000\000\000\005\005\000\000\001R\n6\001V\000\000\000\000\000\000\000\000\001\154\000\000\000\000\n\n\001^\000\000\n\014\008\166\001j\000\000\n\018\n\022\007\178\n\026\000\000\008\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\006\254\n\030\007\186\000\000\n\"\000\000\002\017\000\162\000\000\000\000\000\000\002\017\000\000\000\000\000\000\000\000\n*\007\194\000\000\000\000\002\017\002\017\000\000\008\018\008\026\n\194\000\000\n\218\001%\002\017\000\000\001%\000\000\007\226\000\000\000\000\007\202\n.\007\218\002\017\000\000\000\000\n2\000\000\000\000\000\000\007\186\000\000\001\189\000\000\001%\n6\000\000\000\000\000\000\001%\000\000\001\154\007\234\000\000\002\017\007\194\000\000\000\000\001%\001%\000\000\001%\001%\000\000\002\017\000\000\000\000\001%\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\007\242\000\000\000\000\002\017\000\000\000\000\000\000\007\210\000\000\007\234\000\000\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001%\002\017\000\000\002\017\000\000\000\000\000\000\000\000\000\000\000\000\002\017\002\017\000\000\008\"\007\250\002\017\000\000\000\000\000\000\000\000\000\000\000\000\001%\007\242\000\000\000\000\001%\000\000\000\000\000\000\007\210\000\000\000\000\000\000\001\013\000\000\000\000\001\013\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\001\013\000\000\001%\001%\001\013\001%\007\250\001%\000\000\001\013\000\000\000\000\000\000\000\000\000\000\007\194\000\000\000\000\001\013\001\013\000\000\001\013\001\013\000\000\000\000\000\000\001\005\001\013\000\000\001\005\000\000\001\013\000\000\000\000\007\202\000\000\007\218\001\013\000\000\000\000\000\000\000\000\000\000\000\000\001\005\000\000\000\000\000\000\001\005\000\000\000\000\000\000\000\000\001\005\000\000\000\000\001\013\000\000\001\013\001\005\000\000\000\000\001\005\001\005\000\000\001\005\001\005\000\000\001\013\000\000\000\000\001\005\000\000\000\000\000\000\001\005\000\000\000\000\007\202\000\000\001\005\001\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\013\001\013\000\000\000\000\001\013\000\000\000\000\000\000\007\210\000\000\001\005\000\000\001\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\005\001\013\000\000\001\013\000\000\000\000\000\000\000\000\000\000\000\000\001\013\001\013\000\000\001\013\001\013\001\013\000\000\000\000\000\000\000\000\000\000\000\000\001\005\001\005\000\000\000\000\001\005\000\000\000\000\000\000\007\210\000\000\000\000\000\000\001\t\000\000\000\000\001\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\005\000\000\001\005\000\000\000\000\000\000\000\000\001\t\000\000\001\005\001\005\001\t\001\005\001\005\001\005\000\000\001\t\000\000\000\000\000\000\000\000\000\000\001\t\000\000\000\000\001\t\001\t\000\000\001\t\001\t\000\000\000\000\000\000\001\025\001\t\000\000\001\025\000\000\001\t\000\000\000\000\007\202\000\000\001\t\001\t\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001\025\000\000\000\000\000\000\000\000\001\025\000\000\000\000\001\t\000\000\001\t\007\194\000\000\000\000\001\025\001\025\000\000\001\025\001\025\000\000\001\t\000\000\000\000\001\025\000\000\000\000\000\000\001\025\000\000\000\000\007\202\000\000\007\218\001\025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\t\001\t\000\000\000\000\001\t\000\000\000\000\000\000\007\210\000\000\007\234\000\000\001\025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\025\001\t\000\000\001\t\000\000\000\000\000\000\000\000\000\000\000\000\001\t\001\t\000\000\001\t\001\t\001\t\000\000\000\000\000\000\000\000\000\000\000\000\001\025\001\025\000\000\000\000\001\025\000\000\000\000\000\000\007\210\000\000\000\000\000\000\001\017\000\000\000\000\001\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\025\000\000\001\025\000\000\000\000\000\000\000\000\007\186\000\000\001\025\001\025\001\017\001\025\001\025\001\025\000\000\001\017\000\000\000\000\000\000\000\000\000\000\007\194\000\000\000\000\001\017\001\017\000\000\001\017\001\017\000\000\000\000\000\000\001\021\001\017\000\000\001\021\000\000\001\017\000\000\000\000\007\202\000\000\007\218\001\017\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001\021\000\000\000\000\000\000\000\000\001\021\000\000\000\000\001\017\000\000\001\017\007\194\000\000\000\000\001\021\001\021\000\000\001\021\001\021\000\000\001\017\000\000\000\000\001\021\000\000\000\000\000\000\001\021\000\000\000\000\007\202\000\000\007\218\001\021\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\017\001\017\000\000\000\000\001\017\000\000\000\000\000\000\007\210\000\000\007\234\000\000\001\021\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\021\001\017\000\000\001\017\000\000\000\000\000\000\000\000\000\000\000\000\001\017\001\017\000\000\001\017\001\017\001\017\000\000\000\000\000\000\000\000\000\000\000\000\001\021\001\021\000\000\000\000\001\021\000\000\000\000\000\000\007\210\000\000\000\000\000\000\001\029\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\021\000\000\001\021\000\000\000\000\000\000\000\000\007\186\000\000\001\021\001\021\001\029\001\021\001\021\001\021\000\000\001\029\000\000\000\000\000\000\000\000\000\000\007\194\000\000\000\000\001\029\001\029\000\000\001\029\001\029\000\000\000\000\000\000\007\178\001\029\000\000\001-\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001\029\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001-\000\000\000\000\000\000\000\000\001-\000\000\000\000\007\234\000\000\001\029\007\194\000\000\000\000\001-\001-\000\000\001-\008\026\000\000\001\029\000\000\000\000\001-\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\029\007\242\000\000\000\000\001\029\000\000\000\000\000\000\007\210\000\000\007\234\000\000\001-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001-\001\029\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\001\029\001\029\000\000\001\029\001\029\001\029\000\000\000\000\000\000\000\000\000\000\000\000\001-\007\242\000\000\000\000\001-\000\000\000\000\000\000\007\210\000\000\000\000\000\000\007\178\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\007\186\000\000\001-\001-\001!\008\"\007\250\001-\000\000\001!\000\000\000\000\000\000\000\000\000\000\007\194\000\000\000\000\001!\001!\000\000\001!\001!\000\000\000\000\000\000\007\178\001!\000\000\001)\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001!\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001)\000\000\000\000\000\000\000\000\001)\000\000\000\000\007\234\000\000\001!\007\194\000\000\000\000\001)\001)\000\000\001)\008\026\000\000\001!\000\000\000\000\001)\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\007\242\000\000\000\000\001!\000\000\000\000\000\000\007\210\000\000\007\234\000\000\001)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001)\001!\000\000\001!\000\000\000\000\000\000\000\000\000\000\000\000\001!\001!\000\000\001!\007\250\001!\000\000\000\000\000\000\000\000\000\000\000\000\001)\007\242\000\000\000\000\001)\000\000\000\000\000\000\007\210\001\030\000\000\t\226\000\000\000\000\t\230\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\001*\000\000\001)\001)\000\000\001)\007\250\001)\000\000\t\234\n\146\000\000\000\000\n\166\n\190\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\n\001^\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\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\000\000\006\254\n\030\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001\030\000\000\001\"\000\000\000\000\001&\n*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008>\000\000\n\218\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\n.\000\000\000\000\001>\001B\n2\001J\000\000\t\222\000\000\000\000\001\201\000\000\001R\n6\001V\000\000\000\000\000\000\000\000\001\154\000\000\000\000\001Z\001^\000\000\001b\001f\001j\000\000\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\001~\000\000\000\000\000\162\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\001\134\000\000\000\000\000\000\000\000\000\000\000\000\008!\000\000\001\138\008!\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\001\142\001>\001B\000\000\001J\001\146\000\000\000\000\008!\000\000\008!\001R\000\000\001V\001\150\000\000\000\000\000\000\000\000\000\000\001\154\001Z\001^\000\000\001b\001f\001j\000\000\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\001~\014\186\000\000\000\162\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\001\134\000\000\000\000\000\000\001>\001B\000\000\001J\000\000\001\138\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\001\142\000\000\000\000\001Z\001^\001\146\001b\001f\001j\000\000\001n\001r\000\000\001v\001\150\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\001~\000\000\000\000\000\162\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\001\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\138\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\001\142\001>\004\226\000\000\001J\001\146\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\001\150\000\000\000\000\000\000\000\000\000\000\001\154\001Z\001^\000\000\001b\001f\001j\000\000\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\001~\000\000\000\000\000\162\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\001\134\000\000\000\000\000\000\001>\001\130\000\000\001J\000\000\001\138\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\001\142\000\000\000\000\001Z\001^\001\146\001b\001f\001j\000\000\001n\001r\000\000\001v\001\150\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\001~\000\000\000\000\000\162\001\030\000\000\0012\000\000\000\000\0016\000\000\000\000\001\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\138\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\001\142\001:\001N\000\000\001J\001\146\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\001\150\000\000\000\000\000\000\000\000\000\000\001\154\003\022\001^\000\000\003\026\001f\001j\000\000\003\030\003\"\000\000\003&\000\000\000\000\000\000\000\000\001\030\000\000\0012\000\000\000\000\0016\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\000\003.\000\000\000\000\000\162\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\0036\000\000\000\000\000\000\001:\004\202\000\000\001J\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\169\001V\000\000\000\000\000\000\000\000\003:\000\000\000\000\003\022\001^\003>\003\026\001f\001j\000\000\003\030\003\"\011\006\003&\003B\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\000\000\011\014\000\000\003*\000\000\000\000\003.\000\169\000\169\000\162\001\030\000\000\0012\000\000\000\000\0016\000\000\000\169\0036\000\000\011\022\000\000\011&\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\000\000\003:\001:\0032\0116\001J\003>\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\003B\000\000\000\000\000\000\000\000\000\000\001\154\003\022\001^\000\000\003\026\001f\001j\000\000\003\030\003\"\000\000\003&\000\000\000\000\000\000\000\000\000\000\000\000\000\169\000\000\000\000\000\000\000\000\000\000\000\000\011\030\000\000\003*\000\000\000\000\003.\000\000\000\000\000\162\000\000\000\000\000\000\000\169\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\000\169\000\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003:\000\000\000\000\000\000\000\000\003>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003B\000\000\000\000\000\000\000\000\000\000\001\154\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\000\000\000\000\000\000\000\000\000\000\000\000\0002\t\182\000F\000b\000\190\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\020\222\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\230\000\000\000\000\000\000\000\202\000\000\000\000\000\000\000\000\000\000\001\030\000\186\006\202\000\000\000\000\006\206\000\000\000\000\000\206\000\000\000\000\000\000\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001*\000\000\008\170\000\000\000\000\000\000\000\000\000\000\000\000\006\210\008*\000\000\000\202\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\162\000\206\000\000\000\000\006\234\001^\000\000\006\238\001f\001j\000\000\006\242\006\246\000\000\006\250\000\000\000\000\000\000\000\000\001\030\000\000\006\202\000\000\000\000\006\206\000\000\000\000\000\000\t\166\006\254\007\002\000\000\000\000\007\006\000\000\000\000\000\162\000\000\000\000\000\162\001*\000\000\000\000\000\000\003\173\007\014\000\000\000\000\000\000\006\210\006\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\001\030\000\000\006\202\000\000\007\018\006\206\000\000\006\234\001^\007\022\006\238\001f\001j\000\000\006\242\006\246\000\000\006\250\007\026\000\000\000\000\001*\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\006\210\007\n\006\254\007\002\000\000\000\000\007\006\000\000\000\000\000\162\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\007\014\000\000\006\234\001^\000\000\006\238\001f\001j\000\000\006\242\006\246\000\000\006\250\000\000\000\000\000\000\000\000\001\030\000\000\t\226\000\000\007\018\t\230\000\000\000\000\000\000\007\022\006\254\007\002\000\000\000\000\007\006\000\000\000\000\000\162\007\026\000\000\000\000\001*\000\000\000\000\001\154\000\000\007\014\000\000\000\000\000\000\t\234\t\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\001\030\000\000\t\226\000\000\007\018\t\230\000\000\n\n\001^\007\022\n\014\001f\001j\000\000\n\018\n\022\000\000\n\026\007\026\000\000\000\000\001*\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\t\234\n&\006\254\n\030\000\000\000\000\n\"\000\000\000\000\000\162\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\n*\000\000\n\n\001^\000\000\n\014\001f\001j\000\000\n\018\n\022\000\000\n\026\000\000\000\000\000\000\000\000\001\030\000\000\t\226\000\000\n.\t\230\000\000\000\000\000\000\n2\006\254\n\030\000\000\000\000\n\"\000\000\000\000\000\162\n6\000\000\000\000\001*\000\000\000\000\001\154\000\000\n*\000\000\000\000\000\000\t\234\n\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\n.\000\000\000\000\n\n\001^\n2\n\014\001f\001j\000\000\n\018\n\022\000\000\n\026\n6\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\n\030\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\000\000\000\000\0002\0006\000F\000b\n*\000f\000\000\000j\000\134\007\141\000\138\017r\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\000\000\000\000\n2\007\141\000\186\017v\000\000\000\000\000\000\000\000\000\000\n6\000\000\007\141\007\141\019\222\000\000\001\154\000\000\007\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\202\000\000\007\141\000\000\000\000\018V\000\000\007\141\000:\017\134\000:\007\141\007\141\000\000\000\206\000\000\000\000\000\000\001\153\007\141\000\000\001\153\007\141\007\141\000\000\000\000\000\000\000\000\000\000\000\000\005q\000\000\007\141\005q\000\000\000\000\001\153\005q\000\000\005q\001\153\000\000\007\141\000\000\005q\005q\000\000\000\000\000\000\000\000\007\141\001\153\000\162\000\000\000\000\001\153\000\000\001\153\001\153\000\000\000\000\000\000\000\000\000\000\007\141\000\000\017\138\001\153\000\000\000\000\001\153\000\000\001\153\007\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\141\000\000\000\000\007\141\007\141\005q\000\000\007\141\001\153\000\000\000\000\000\000\007\141\007\141\000\218\000\000\000\000\007\141\000\000\000\000\001\153\000\000\000\000\000\000\000\000\007\141\000\000\000\000\007\141\007\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\141\000\000\000\000\000\000\000\000\001\153\003\166\000\000\001\153\000\000\000\000\000\000\001\153\000\000\000\000\000\000\000\000\000\000\007\141\000\000\000\000\000\000\000\000\005q\001\153\000\000\000\000\000\000\000\000\001\153\001\153\000\000\007\141\000\000\000\000\003\174\000\000\000\000\000\000\001\153\001\153\001\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\141\000\000\000\000\007\141\007\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\141\007\141\000\000\000\000\000\000\007\141\003]\003]\003]\003]\000\000\003]\000\000\003]\003]\000\000\003]\000\000\003]\000\000\003]\000\000\003]\003]\003]\003]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\238\000\000\000\000\003]\000\000\0002\000\214\000F\000b\000\000\000f\000\000\000j\000\134\003]\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\003\254\000\000\000\000\004N\000\000\000\000\000\000\000\000\000\000\000\000\003]\000\000\000\186\000\000\000\000\000\000\003]\000\000\004\006\000\000\000\000\000\000\002\t\000\190\003]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\014\000\000\000\000\000\000\002\t\000\000\004^\004f\000\000\000\000\000\237\000\202\000\000\000\237\000\000\000\000\004.\000\230\000\000\004\022\000\000\004&\000\000\000\000\000\000\000\206\000\000\000\000\004\006\003]\000\000\000\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0046\000\000\004\014\000\000\000\000\000\000\000\237\000\000\000\237\000\237\000\000\000\000\002\t\000\000\000\000\000\000\000\000\000\000\004.\000\000\000\000\004\022\000\162\004&\000\000\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\000\000\000\000\004>\000\000\000\000\002\t\000\000\000\234\000\000\004\030\0046\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\t\000\237\000\000\000\000\000\000\002\t\002\t\000\000\000\000\011=\000\000\000\000\000\000\000\000\000\000\004n\004F\002\t\000\000\000\000\000\000\000\000\000\000\000\000\004>\000\000\000\000\000\237\000\000\000\213\000\000\004\030\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\000\000\000\000\000\000\213\000\237\000\237\000\000\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\237\004F\000\237\000\000\004\014\000\000\000\000\000\000\000\213\000\000\000\213\000\213\000\000\000\000\000\205\000\000\000\000\000\205\000\000\000\000\000\213\000\000\000\000\004\022\000\000\004&\000\000\000\000\000\000\000\000\000\000\000\000\000\205\000\000\000\000\000\000\000\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\213\000\000\000\205\000\000\000\000\000\000\000\205\000\000\000\205\000\205\000\000\000\000\000\213\000\000\000\000\000\000\000\000\000\000\000\205\000\000\000\000\004\022\000\000\000\205\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\213\000\000\000\000\000\000\004\030\000\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\213\000\205\000\000\000\000\000\000\000\213\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\213\000\213\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\205\000\000\000\000\000\205\000\000\000\209\000\000\004\030\000\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\205\000\000\000\000\000\000\000\209\000\205\000\205\000\000\000\209\000\000\000\000\000\000\000\000\000\000\000\000\000\205\000\205\000\205\000\000\000\209\000\000\000\000\000\000\000\209\000\000\000\209\000\209\000\000\000\000\000\225\000\000\000\000\000\225\000\000\000\000\000\209\000\000\000\000\004\022\000\000\000\209\000\000\000\000\000\000\000\000\000\000\000\000\004\006\000\000\000\000\000\000\000\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\209\000\000\004\014\000\000\000\000\000\000\000\225\000\000\000\225\000\225\000\000\000\000\000\209\000\000\000\000\000\000\000\000\000\000\000\225\000\000\000\000\004\022\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\209\000\000\000\000\000\209\000\000\000\000\000\000\004\030\0046\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\209\000\225\000\000\000\000\000\000\000\209\000\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\209\000\209\000\209\000\000\000\000\000\000\000\000\000\000\000\000\000\225\000\000\000\000\000\225\000\000\000\217\000\000\004\030\000\217\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\225\000\000\000\000\000\000\004\006\000\225\000\225\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000\000\000\225\000\225\000\225\000\000\004\014\000\000\000\000\000\000\000\217\000\000\000\217\000\217\000\000\000\000\000\221\000\000\000\000\000\221\000\000\000\000\000\217\000\000\000\000\004\022\000\000\004&\000\000\000\000\000\000\000\000\000\000\000\000\004\006\000\000\000\000\000\000\000\221\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\217\000\000\004\014\000\000\000\000\000\000\000\221\000\000\000\221\000\221\000\000\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000\221\000\000\000\000\004\022\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\217\000\000\000\000\000\217\000\000\000\000\000\000\004\030\0046\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\217\000\221\000\000\000\000\000\000\000\217\000\217\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\217\000\217\000\217\000\000\000\000\000\000\000\000\000\000\000\000\000\221\000\000\000\000\000\221\000\000\000\229\000\000\004\030\000\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\221\000\000\000\000\000\000\004\006\000\221\000\221\000\000\000\229\000\000\000\000\000\000\000\000\000\000\000\000\000\221\000\221\000\221\000\000\004\014\000\000\000\000\000\000\000\229\000\000\000\229\000\229\000\000\000\000\003\254\000\000\000\000\000\245\000\000\000\000\004.\000\000\000\000\004\022\000\000\004&\000\000\000\000\000\000\000\000\000\000\000\000\004\006\000\000\000\000\000\000\000\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0046\000\000\004\014\000\000\000\000\000\000\000\245\000\000\000\245\004f\000\000\000\000\000\229\000\000\000\000\000\000\000\000\000\000\004.\000\000\000\000\004\022\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\004>\000\000\000\000\000\229\000\000\000\000\000\000\004\030\0046\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\229\000\245\000\000\000\000\000\000\000\229\000\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\229\000\229\000\229\000\000\000\000\000\000\000\000\000\000\000\000\004>\000\000\000\000\000\245\000\000\003\254\000\000\004\030\000\233\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\245\000\000\000\000\000\000\004\006\000\245\000\245\000\000\000\233\000\000\000\000\000\000\000\000\000\000\000\000\004n\004F\000\245\000\000\004\014\000\000\000\000\000\000\000\233\000\000\000\233\000\233\000\000\000\000\003\254\000\000\000\000\000\241\000\000\003\165\004.\000\000\003\165\004\022\000\000\004&\003\165\000\000\003\165\000\000\000\000\000\000\004\006\003\165\003\165\000\000\000\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0046\000\000\004\014\000\000\000\000\000\000\000\241\000\000\000\241\004f\000\000\000\000\000\233\000\000\000\000\000\000\000\000\002-\004.\000\000\000\000\004\022\000\000\004&\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\165\000\000\004>\000\000\000\000\000\233\000\000\000\000\000\000\004\030\0046\000\000\002-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002-\000\233\000\241\002-\002-\000\000\000\233\000\233\000\000\000\000\000\000\000\000\000\000\002-\000\000\000\000\000\233\004F\000\233\000\000\000\000\000\000\000\000\000\000\000\000\004>\000\000\000\000\000\241\000\000\000\000\002-\004\030\000\000\000\000\000\000\003\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\002-\000\000\000\000\000\000\000\241\000\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\004F\000\241\000\000\000\000\000\000\002-\000\000\000\000\002-\002-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002-\002-\000\000\000\000\000\000\002-\0002\000\214\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\226\000F\000b\000\190\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\020\222\000\150\006\150\000\154\000\174\000\000\000\182\006\154\020\230\000\000\000\000\000\000\000\202\000\000\000\000\000\000\000\000\000\000\000\230\000\186\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\000\190\0002\005.\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\000\162\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\234\000\000\0002\005.\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\202\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\002)\000\000\000\000\003\173\000\206\000\000\000\000\000\000\0052\0056\000\000\000\186\000\000\0002\000\214\000F\000b\000\000\000f\000\000\000j\000\134\000\190\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\202\000\000\000\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\190\000\206\000\000\000\000\005:\0052\0056\000\000\000\000\000\000\000\000\000\000\0002\005.\000F\000b\000\000\000f\000\000\000j\000\134\000\202\000\138\000\000\000\146\000\000\000\150\000\230\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\000\000\0002\005.\000F\000b\000\000\000f\000\000\000j\000\134\000\190\000\138\005B\000\146\011\213\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\162\000\000\000\000\000\202\011\213\000\186\000\000\000\000\000\000\000\000\000\000\000\000\nJ\000\000\000\000\000\000\000\190\000\206\000\000\011\213\000\000\021\170\0056\000\000\000\000\011\213\011\213\000\000\000\000\nR\000\000\000\000\n^\000\000\000\000\011\213\000\000\000\202\011\213\000\000\011\213\002!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\021\170\0056\000\161\000\000\000\000\011\213\000\000\0002\006B\006J\000b\000\000\000f\000\000\006N\000\134\000\000\000\138\021\174\000\146\011\006\000\150\nj\000\154\000\174\000\178\000\182\000\000\000\165\000\000\000\000\000\000\000\000\000\000\000\000\011\014\000\000\000\000\000\000\000\186\011\213\000\161\000\161\000\000\000\000\nn\011\006\011\213\000\000\000\000\000\190\000\161\021\182\000\000\011\022\nv\011&\000\000\000\000\011\213\000\173\011\014\000\000\000\000\000\000\000\000\000\000\000\165\000\165\000\000\000\000\006R\000\000\000\000\011\213\011\213\000\161\000\165\011\006\000\000\011\022\000\000\011&\000\000\000\000\000\206\n\254\000\000\000\000\000\000\000\000\000\000\000\000\011\014\000\000\000\000\000\000\000\000\000\000\000\173\000\173\000\000\0116\n\254\011\006\000\000\000\000\000\000\000\000\011.\000\000\000\161\011\022\000\000\011&\000\000\000\000\000\000\011\030\011\014\000\000\011\006\000\000\000\000\000\000\000\189\011V\000\000\000\000\000\000\000\161\000\000\000\000\000\000\0116\011.\011\014\000\165\011\022\000\000\011&\000\000\000\177\000\177\011\030\000\161\000\161\n\254\000\000\000\000\000\000\000\000\011.\000\000\000\000\011\022\000\165\011&\000\000\000\000\0116\000\000\000\000\000\000\000\000\011\006\000\000\000\000\000\000\011>\000\000\000\165\000\165\000\000\000\000\000\000\011\030\0116\000\000\000\000\011\014\000\000\000\000\000\000\000\000\000\000\000\185\011V\000\173\000\000\000\000\000\000\000\000\000\000\000\000\011>\011.\000\000\000\000\011\022\000\000\011&\011\030\000\173\000\173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011>\000\000\000\189\000\000\000\000\000\000\000\000\011\030\000\000\0116\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011^\011F\000\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\177\011F\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\011\030\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\185\011F")) + ((16, "\000\212\000\031\000\000\000\000\000\235\000\000\000\000\000\000\000\212\000\000\000\228\031D\000\000\000\129F\002\000\000\000\000\026v\000\000\031\210\000\000\000\000\000\000\000\000\000\000\000\000\027b\000\000 d\000\000\000\000\000\000\000\000\000\000!P\000\000\000\000\000\000\000k\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\165\000c\000\000\031D!\158G\168\000+GD\000\000\000\000\000\0000h\000rG\168\000\015G\168\000\000\000\156\000\000G\168\000\000\000k\003\250\144\000\000@\182\000\000AdE\016H\"E\016O\240\000\000\006\178\000\000\006\2241\234\000\0002\152\006\2402\1523\190\006\2442\152\000\000\000\000\000\000\000\000\000\000\006\232\000\000\007\198\000\000\000k\000\000\002p\007\204\000\000\007\174\007\158\000k\007\000\007\190N\012\007\018\000\232\000\000\000\000\008\"N\012\007t\008T\000\000\003\248\000\000\000\000\001\254\020\016\000\000\001\254\000\000\000\000\007\150\000\000\003\024\000\003\019<\000\000\003\250\000%\003\250\000\000\000\148\000\000\006\162\000\000\006\162\000\000\000\000\000\000\007\144\000\000\000\000\007\154\000\000\003:\005N\000%\003\250\000\000\000\000\000\000\000\148\000\000\006\162\000\000\003:\000\000\000\000\000\234\000\015\015\238\000\000\020\016\000\000\tJ\015\238\000\000\000\000\tJ\000\000\000\000\007\156\000\000\000\000\007\174\000\000\004z\006\162\000\000\004z\000\000\000\000\008&\000\000\001\028\000\000\006\162\000\000\000\000\000\000\0176>H\000\000\008\140\000\000\0176\008\142\000\000\008\148\000\000$4\000k\002*\000\000\t\180\000\000\tJ\n\170\000\000\006,\003^\n\186\011\194\n\186\000\000\000\000\002\030\000\127\000\000\002F\n\012\000\000\000\000\000\000\005\206\000\000\t\190\000\000\000\000\000\000\000\000\tJ\006,\003^\002\030\002F\005\206\t\192\000\000\006,\003^\002\030\002F\005\206\t\196\000\000\000\127\000\000\n\192\n\188\n\000\000\127\n\\\000\000"), (16, "\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\000:\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\n\237\000\n\001^\020\131\020\135\n\237\012\022\001j\020\139\006\025\006\002\n\237\016\130\n\237\n\237\n\237\000\158\007y\n\237\017r\008J\000\014\n\237\n\237\005\129\n\237\002\150\000\023\000\027\008~\005\129\008J\007y\000\218\n\237\000\162\000\194\n\237\n\237\004\t\008~\017v\000\250\n\237\n\237\000\162\n\237\006j\n\237\000\198\000J\017z\000N\n\237\000V\n\237\n\237\n\237\n\237\n\237\013\006\000Z\000\158\n\237\n\237\n\237\ny\n\237\n\237\n\237\005\129\n\237\n\237\n\237\n\237\006\n\0182\016\138\n\237\n\237\001^\017\134\007y\005Z\001f\001j\003\198\000\162\n\237\n\237\n\237\000\162\n\237\n\237\n\237\n\237\001^\n\237\t\158\n\237\012\022\001j\n\237\t\146\n\029\n\237\n\237\006\025\000\242\t\158\013~\n\237\008J\000\162\013\174\n\237\000\006\004\t\n\237\016B\000^\008~\n\237\n\237\n\237\n\237\000\162\n\237\n\237\000\162\007y\004\t\n\237\n\237\n\237\005\193\n\237\005\217\n\237\n\237\017\138\n\237\007y\n\237\n\237\012\002\013\006\n\237\n\237\006!\006!\006!\006!\006!\006!\006!\006!\006!\006!\006!\n\029\006!\006!\006!\006!\006!\006!\006!\006!\006!\006!\t\146\017\178\020\150\004\162\006!\008N\008^\008n\n\161\008J\006!\001^\006!\006!\006!\012\022\001j\006!\008~\t\158\n\209\006!\004\138\006\194\006!\000.\006\"\016\162\016\202\016\242\017\002\017.\016Z\006!\0069\0069\018\150\005\145\004\t\0069\000\158\002\206\006!\006!\000\162\003\137\001\006\006!\006!\000n\011\145\000r\006!\000z\006!\006!\006!\006!\006!\012\006\000~\002J\006!\006!\006!\022+\006!\006!\006!\000\162\006!\006!\006!\006!\022/\n\174\017\150\006!\006!\005\185\005\185\005\233\000\158\011\145\0222\000\162\005\129\t\158\006!\006!\002\166\006!\006!\006!\006!\000\218\006!\n\186\006!\006\142\005\241\006!\006\146\007e\006!\006!\021\n\007e\006\150\002\222\006!\000\162\012\194\006\154\021\014\011\145\011\145\006!\017z\000\130\011\145\006!\006!\006!\006!\0061\006!\006!\002\254\t\n\n\166\006!\006!\006!\006A\014\230\006A\006!\006!\006A\006!\013\138\006!\006!\017\166\023\146\006!\006!\006A\006A\006A\006A\006A\006A\006A\006A\006A\006A\006A\008r\006A\006A\006A\006A\006A\006A\006A\006A\006A\006A\n\137\018b\008J\002a\006A\020r\006A\002a\n\129\023\018\006A\008~\006A\006A\006A\006A\016\170\006A\006A\006A\006A\006A\006A\006A\006A\006A\005\169\012\198\003\n\003\018\n\222\023\022\000\158\006A\015\022\0061\006A\003f\023\026\0061\0061\006A\006A\006A\006A\006A\003\213\006A\006A\006\017\014\234\023\134\006A\020r\006A\023\154\006A\006A\006A\003\161\023\158\000\162\006A\006A\006A\005>\006A\006A\006A\005\161\006A\006A\006A\006A\019N\0061\008Y\014\170\006A\t\002\t\158\016\178\014\174\006A\t\146\t\218\n\137\003r\006A\006A\n\137\006A\006A\006A\006A\003\161\006A\023\"\006A\003\017\023n\006A\005f\011\206\006A\006A\002\141\n\137\008Y\008Y\006A\023\n\004\138\008Y\006A\006)\019R\006A\016.\015\026\003\190\006A\006A\000\162\006A\023:\006A\006A\023*\013\254\005\129\006A\0081\005\129\0035\018z\013\006\005\129\006A\005\129\006A\005\209\006A\006A\005\129\005\129\006A\006A\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\015.\000\146\020\234\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\242\t\146\0126\001^\003\206\006\158\012V\012\022\001j\003\214\008J\000\186\004V\001\030\006\174\006\202\004\193\004z\006\206\008~\011\206\005\241\000\190\012\138\011\206\008:\006)\n\137\005\137\002\150\006)\006)\004%\020\174\001*\004\193\000\162\021.\005\249\n\145\015\214\011\206\006)\008\146\006\214\021Z\021f\001\026\008\150\013\186\007=\023J\004\130\001R\004\186\001V\003\229\000\206\t\154\008\158\015J\017\162\023B\006\234\001^\008\162\006)\006\238\008\166\001j\n\177\006\242\006\246\008\170\006\250\0152\001^\004\198\005\129\008\174\012\022\001j\007=\007=\008Y\004\210\006i\007=\t\158\006\254\007\002\004\189\008\178\008\182\007\006\008\186\t\006\000\162\004\222\008\206\005\177\004\193\003\193\020\219\020\223\008\218\007\014\004!\020\227\000\162\004\189\006I\013\"\005\137\n\137\021z\008Y\008Y\008\250\004\193\014~\008Y\008\254\t:\003\229\t\166\017\246\007\018\t>\004\234\011\206\005\137\007\022\003\229\003\229\005\137\016\210\013\006\003\229\tF\n\193\007\026\006i\006I\006I\015N\015^\001\154\006I\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\004\246\000\146\020\234\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\242\0039\015\186\001^\005\n\006\158\004\189\012\022\001j\005\026\n\185\000\186\017\014\001\030\006\174\006\202\0039\018\146\006\206\0085\005\030\019\154\000\190\t\"\004\189\008:\018\134\003\021\006\001\013B\004\138\016\218\023:\019b\001*\005&\000\162\008J\005*\015n\n\153\0085\006Y\008\146\006\214\021Z\008~\011\206\008\150\014\002\008\145\0085\005R\001R\006\t\001V\003\245\000\206\t\154\008\158\017j\019J\005V\006\234\001^\008\162\019>\006\238\008\166\001j\000\162\006\242\006\246\008\170\006\250\022K\022O\017\022\005^\008\174\022S\0085\008\145\008\145\005\130\005\138\006Q\008\145\015\166\006\254\007\002\005\225\008\178\008\182\007\006\008\186\0039\000\162\006Y\008\206\0039\0039\003\193\021\190\n\201\008\218\007\014\005\153\005\241\022o\022s\006q\0039\015\222\022w\t\158\015\250\005\142\008\250\005\150\0035\019\150\008\254\t:\015r\t\166\0085\007\018\t>\021\238\005\170\005\174\007\022\002\129\003\245\0035\0039\005\201\023B\tF\0085\007\026\006Q\006q\006q\005\198\006a\001\154\006q\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\019\138\000\146\020\234\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\242\005\214\023\166\015\170\005\234\006\158\005\242\005\250\006\023\006.\0066\000\186\006:\001\030\006\174\006\202\006Z\006r\006\206\005\129\006\162\006\170\000\190\006\178\006\186\008:\006\190\006\198\015\226\006\222\006\230\015\254\006a\007>\001*\007J\007\146\008J\005%\008\n\0082\005\129\008F\008z\006\214\0035\008~\008R\008\150\0035\0035\005\129\008Z\001R\008b\001V\004\017\000\206\008\154\008\158\008j\0035\023\n\006\234\001^\008\162\008\190\006\238\008\166\001j\008\198\006\242\006\246\008\170\006\250\008\214\005\129\008\222\011\153\008\174\008\230\005\129\002\150\008r\008\238\0035\008\246\t2\tB\006\254\007\002\tJ\008\178\008\182\007\006\008\186\tV\000\162\018\022\008\206\tZ\tb\003\193\tf\tr\008\218\007\014\tz\t\138\t\174\t\190\008a\t\198\t\202\t\242\t\158\t\254\008v\008\250\n\006\017v\nZ\008\254\t:\004\017\t\166\005\129\007\018\t>\nf\017z\n\154\007\022\004\017\004\017\n\182\n\202\n\214\004\017\tF\005\129\007\026\n\238\008a\008a\n\250\011\130\001\154\008a\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\017\134\000\146\011\138\000\150\006\150\000\154\000\174\000\178\000\182\006\154\011\154\014\170\011\166\011\194\011\202\006\158\014\174\011\222\011\230\011\234\014\178\000\186\011\242\001\030\006\174\006\202\011\246\005\129\006\206\019\022\005\129\011\254\000\190\012\014\005\129\008:\005\129\012\"\012*\012.\012>\005\129\005\129\012F\001*\000\162\012^\008J\012f\012\146\012\154\017v\016.\008z\006\214\012\166\008~\012\170\008\150\017\138\012\178\017z\012\182\001R\012\190\001V\012\206\000\206\008\154\008\158\012\242\012\250\012\254\006\234\001^\008\162\013\014\006\238\008\166\001j\013\022\006\242\006\246\008\170\006\250\013\026\005\129\013*\011\153\008\174\0132\017\134\000:\013J\013R\000\218\013\162\013\234\013\246\006\254\007\002\014j\008\178\008\182\007\006\008\186\001^\000\162\014v\008\206\001f\001j\014\150\014\194\014\206\008\218\007\014\014\214\014\242\014\250\014\254\011\153\015\006\015\n\015\018\t\158\015\"\015:\008\250\015V\015z\015\138\008\254\t:\015\142\t\166\000\162\007\018\t>\000\162\015\150\015\154\007\022\015\162\005\129\015\178\015\194\015\202\015\206\tF\017\138\007\026\015\234\011\153\011\153\016\006\015\214\001\154\011\153\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\016\026\000\146\016*\000\150\006\150\000\154\000\174\000\178\000\182\006\154\016:\016R\016b\016n\004\162\006\158\016\151\016\191\016\231\003\173\016\255\000\186\001^\001\030\006\174\006\202\012\022\001j\006\206\017#\017;\022\254\000\190\007\129\003\173\008:\006\142\017~\017\190\006\146\017\219\018\003\018\015\021\n\001*\006\150\018\031\008J\007\129\018'\006\154\021\014\018:\008z\006\214\000\162\008~\018C\008\150\018K\018S\018n\018\174\001R\018\195\001V\018\211\000\206\008\154\008\158\018\219\018\231\018\243\006\234\001^\008\162\018\255\006\238\008\166\001j\019\006\006\242\006\246\008\170\006\250\019\015\019\"\019+\0193\008\174\019n\019\162\005\233\019\183\019\191\011\230\019\203\019\219\007\129\006\254\007\002\019\227\008\178\008\182\007\006\008\186\019\238\000\162\019\242\008\206\023Z\019\255\n\169\020\011\003\173\008\218\007\014\023^\003\173\003\173\020\018\020\031\020+\0203\020>\t\158\020G\020O\008\250\020[\003\173\003\173\008\254\t:\020v\t\166\020\154\007\018\t>\020\158\020\162\006\142\007\022\020\186\006\146\021:\007\129\021b\021\n\tF\006\150\007\026\021r\003\213\003\173\006\154\021\014\001\154\007\129\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\021\170\000\146\020\234\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\242\021\178\021\206\021\210\021\254\006\158\022\002\022\n\018.\0227\023\002\000\186\n\169\001\030\006\174\006\202\n\169\n\169\006\206\017r\012\166\023\014\000\190\023\030\023&\008:\023.\023W\023b\023r\017v\023\150\023\175\023\219\001*\023\247\024\006\024\n\024\014\018\162\017z\017v\024\023\008\146\006\214\000\000\n\169\000\000\008\150\022\134\000\000\017z\n\169\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\000\000\000\006\234\001^\008\162\000\000\006\238\008\166\001j\017\134\006\242\006\246\008\170\006\250\000\000\020:\000\000\003\213\008\174\000\000\017\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\003\193\000\000\000\000\008\218\007\014\000\000\000\000\000\000\000\000\008E\000\000\000\000\000\000\000\162\000\000\000\000\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\162\007\018\t>\017\138\000\000\000\000\007\022\000\000\000\000\000\000\000\000\000\000\000\000\tF\017\138\007\026\000\000\008E\008E\000\000\000\000\001\154\008E\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\nq\000\000\000\000\000\000\000\000\006\158\000\000\000\000\017r\000\000\000\000\000\186\000\000\001\030\006\174\006\202\000\000\000\000\006\206\017r\000\000\000\000\000\190\000\000\000\000\008:\000\000\000\000\000\000\000\000\017v\000\000\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\017z\017v\000\000\008\146\006\214\000\000\000\000\000\000\008\150\012n\000\000\017z\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\000\000\000\006\234\001^\008\162\000\000\006\238\008\166\001j\018\202\006\242\006\246\008\170\006\250\000\000\000\000\000\000\011u\008\174\nq\019\210\000\000\000\000\nq\nq\000\000\000\000\000\000\006\254\007\002\000\000\008\178\008\182\007\006\008\186\nq\000\162\000\000\008\206\000\000\000\000\000\000\000\000\000\000\008\218\007\014\023v\000\000\000\000\000\000\011u\000\000\000\000\000\000\000\162\000\000\000\000\008\250\000\000\nq\000\000\008\254\t:\000\000\t\166\000\162\007\018\t>\017\138\000\000\000\000\007\022\000\000\000\000\000\000\000\000\000\000\000\000\tF\017\138\007\026\000\000\011u\011u\000\000\000\000\001\154\011u\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\000\000\000\000\000\000\006\158\000\000\000\000\000\000\000\000\000\000\000\186\000\000\001\030\006\174\006\202\000\000\000\000\006\206\000\000\000\000\000\000\000\190\000\000\000\000\008:\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\008\146\006\214\000\000\000\000\000\000\008\150\021>\000\000\000\000\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\000\000\000\006\234\001^\008\162\000\000\006\238\008\166\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\000\000\000\000\008\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\000\000\000\000\000\000\008\218\007\014\000\000\000\000\000\000\000\000\011\193\000\000\000\000\000\000\000\000\000\000\000\000\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\000\007\018\t>\000\000\000\000\000\000\007\022\000\000\000\000\000\000\000\000\000\000\000\000\tF\000\000\007\026\000\000\011\193\011\193\000\000\000\000\001\154\011\193\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\000\000\000\000\000\000\006\158\000\000\000\000\000\000\000\000\000\000\000\186\000\000\001\030\006\174\006\202\000\000\000\000\006\206\000\000\000\000\000\000\000\190\000\000\000\000\008:\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\008\146\006\214\000\000\000\000\000\000\008\150\021>\000\000\000\000\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\000\000\000\006\234\001^\008\162\000\000\006\238\008\166\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\000\000\000\000\008\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\000\000\000\000\000\000\008\218\007\014\000\000\000\000\000\000\000\000\011\189\000\000\000\000\000\000\000\000\000\000\000\000\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\000\007\018\t>\000\000\000\000\000\000\007\022\000\000\000\000\000\000\000\000\000\000\000\000\tF\000\000\007\026\000\000\011\189\011\189\000\000\000\000\001\154\011\189\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\000\000\000\000\000\000\000\000\006\158\000\000\000\000\000\000\000\000\000\000\000\186\000\000\001\030\006\174\006\202\000\000\000\000\006\206\000\000\000\000\000\000\000\190\000\000\000\000\008:\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\008\146\006\214\000\000\000\000\000\000\008\150\0146\000\000\000\000\000\000\001R\000\000\001V\000\000\000\206\t\154\008\158\000\000\000\000\000\000\006\234\001^\008\162\000\000\006\238\008\166\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\000\000\000\000\008\174\000\000\000\000\000\000\000\000\000\000\0031\000\000\000\000\000\000\006\254\007\002\000\000\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\0031\000\000\000\000\000\000\000\000\008\218\007\014\000\000\017r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0031\000\000\008\250\000\000\000\000\000\000\008\254\t:\000\000\t\166\000\000\007\018\t>\000\000\017v\000\000\007\022\000\000\000\000\000\000\000\000\000\000\000\000\tF\017z\007\026\000\000\0002\006&\000F\000b\001\154\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\019\026\000\000\000\000\n\029\000\000\017\134\000\000\000\000\000\000\000\000\000\186\000\000\001\030\000\000\006\202\0031\004\169\006\206\000\000\0031\0031\000\190\000\000\000\000\014\182\000\000\000\000\000\000\n\029\000\000\000\000\0031\000\000\001*\000\000\000\000\000\000\000\000\004\169\000\000\000\000\000\000\014\198\006\214\000\000\000\000\0031\000\000\004\169\000\000\000\162\000\000\001R\000\000\001V\0031\000\206\023B\000\000\011\018\000\000\000\000\006\234\001^\017\138\000\000\006\238\001f\001j\000\000\006\242\006\246\008\170\006\250\000\000\000\000\n\017\011\026\004\169\004\169\000\000\000\000\000\000\000\000\n\029\000\000\000\000\000\000\006\254\007\002\000\000\000\000\011\"\007\006\000\000\000\000\000\162\000\000\011b\011j\000\000\n\017\000\000\000\000\000\000\007\014\000\000\017r\011B\000\000\000\000\011*\000\000\011:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\169\t\166\000\000\007\018\014\202\000\000\017v\000\000\007\022\000\000\000\000\011J\000\000\000\000\004\169\014\210\017z\007\026\000\000\0002\0006\000F\000b\001\154\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\000\000\150\n\017\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\n)\000\000\017\134\011R\000\000\000\000\000\000\000\186\000\000\001\030\0112\001\"\000\000\000\000\001&\000\000\000\000\000\000\000\190\000\000\000\000\000\000\004\253\000\000\000\000\n)\000\000\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\011r\011Z\001F\001B\000\000\001J\000\000\000\000\000\000\000\000\000\162\000\000\001R\000\000\001V\000\000\000\206\000\000\000\000\000\000\000\000\000\000\001Z\001^\017\138\000\000\001b\001f\001j\001\190\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\000\000\002\186\000F\000b\000\000\000f\n)\000j\000\134\000\000\000\138\001z\000\146\000\000\000\150\001~\000\154\000\174\000\162\000\182\000\000\006\158\000\000\000\000\000\000\000\000\000\000\001\134\000\000\001\030\006\174\006\202\000\186\000\000\006\206\000\000\001\138\000\000\000\000\000\000\000\000\008:\000\000\000\190\000\000\000\000\000\000\000\000\001\142\000\000\001*\000\000\000\000\001\146\000\000\000\000\003\133\000\000\000\000\008\202\006\214\000\000\001\150\000\000\008\150\000\000\000\000\000\000\001\154\001R\000\000\001V\000\000\000\000\000\000\008\158\000\000\000\000\000\206\006\234\001^\008\162\000\000\006\238\008\166\001j\000\000\006\242\006\246\000\000\006\250\000\000\000\000\000\000\000\000\008\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\000\162\000\000\000\000\008\218\007\014\000\000\000\000\000\000\000\000\006\158\000\000\000\000\000\000\000\000\000\000\000\000\008\250\001\030\006\174\006\202\008\254\t:\006\206\000\000\000\000\007\018\t>\007y\000\000\008:\007\022\000\000\t\146\000\000\000\000\000\000\000\000\tF\001*\007\026\000\000\008J\007y\000\000\000\000\001\154\000\000\006\210\006\214\000\000\008~\000\000\008\150\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\008\158\000\000\000\000\000\000\006\234\001^\008\162\000\000\006\238\008\166\001j\000\000\006\242\006\246\000\000\006\250\000\000\000\000\000\000\000\000\008\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007y\006\254\007\002\000\000\008\178\008\182\007\006\008\186\000\000\000\162\000\000\008\206\000\000\000\000\000\000\000\000\000\000\008\218\007\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\158\011\213\000\000\008\250\011\213\000\000\000\000\008\254\t:\000\000\000\000\000\000\007\018\t>\000\000\000\000\000\000\007\022\000\000\011\213\000\000\007y\000\000\011\213\tF\000\000\007\026\001\178\011\213\000\000\000\000\000\000\001\154\007y\011\213\000\000\000\000\011\213\011\213\000\000\011\213\011\213\000\000\000\000\001\186\000\000\011\213\002\214\000\000\000\000\011\213\000\000\000\000\011\213\000\000\011\213\011\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\213\000\000\011\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\213\005\129\000\000\000\000\000\000\000\000\002\226\000\000\000\000\000\000\000\000\005\129\005\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\213\011\213\011\213\000\000\011\213\011\213\002\230\000\000\011\213\000\000\000\000\000\000\004!\005\129\000\000\004!\002\238\000\000\005\129\002\150\011\213\000\000\005\129\011\213\011\213\011\213\011\213\000\000\000\000\000\000\004!\011\213\011\213\011\213\004!\011\213\011\213\011\213\004!\004!\000\000\000\000\000\000\000\000\000\000\004!\000\000\000\000\004!\004!\000\000\004!\004!\000\000\005\129\004!\000\000\004!\004!\000\000\000\000\004!\000\000\005\129\004!\000\000\004!\004!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\129\000\000\000\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004!\000\000\004!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\129\000\000\004!\005\129\005\129\000\000\000\000\005\129\004!\000\000\000\000\000\162\000\000\000\000\000\000\000\000\000\000\005\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004!\004!\004!\000\000\004!\004\189\004!\000\000\004!\000\000\001=\001=\001=\001=\000\000\001=\004!\001=\001=\000\000\001=\000\000\001=\004!\001=\004!\001=\001=\001=\001=\000\000\004!\004!\004!\017F\004!\004!\004!\000\000\000\000\000\000\001=\001=\001=\000\000\000\000\000\000\000\000\001=\000\000\000\000\000\000\000\000\001=\000\000\000\000\000\000\001=\000\000\000\000\000\000\001=\000\000\000\000\017J\000\000\000\000\001=\000\000\000\000\000\000\006~\006J\000b\001=\000f\000\181\006N\000\134\001=\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\001=\000\182\000\000\000\000\000\000\000\000\011\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\000\000\000\000\000\000\000\000\000\000\001=\011\"\000\000\001=\000\000\000\190\000\000\000\181\000\181\000\000\000\000\000\000\000\000\000\000\001=\000\000\000\000\011B\000\000\001=\011*\001=\011:\000\000\001=\000\000\001=\000\000\000\000\004%\000\000\001=\004%\000\000\001=\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\011J\000\000\000\000\000\000\004%\000\000\001=\000\000\004%\001=\001=\000\000\004%\004%\000\000\000\000\000\000\000\000\000\000\004%\017N\000\000\004%\004%\000\000\004%\004%\000\000\000\000\004%\000\000\004%\004%\000\000\000\000\004%\011R\000\000\004%\000\000\004%\004%\000\000\0112\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\000\004%\000\000\004%\000\000\000\000\000\000\000\000\000\000\000\000\000\181\011Z\000\000\004%\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\004%\004%\004%\000\000\004%\004\193\004%\000\000\004%\000\000\000\000\000\000\012)\000\000\000\000\012)\004%\000\000\000\000\000\000\004%\000\000\000\000\004%\000\000\004%\000\000\000\000\000\000\000\000\012)\004%\004%\004%\012)\004%\004%\004%\007.\012)\000\000\000\000\000\000\000\000\000\000\012)\000\000\000\000\012)\012)\000\000\012)\012)\000\000\000\000\0076\000\000\012)\007B\000\000\000\000\012)\000\000\000\000\012)\000\000\012)\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\012)\000\000\012)\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\007N\000\000\000\000\000\000\000\000\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)\012)\012)\000\000\012)\000\000\007R\000\000\012)\000\000\n\013\n\013\n\013\n\013\000\000\n\013\007Z\n\013\n\013\000\000\n\013\000\000\n\013\012)\n\013\012)\n\013\n\013\n\013\n\013\000\000\012)\012)\012)\000\000\012)\012)\012)\000\000\000\000\000\000\n\013\n\013\n\013\000\000\000\000\000\000\000\000\n\013\000\000\000\000\000\000\000\000\n\013\000\000\000\000\000\000\017^\000\000\000\000\000\000\017f\000\000\000\000\000\000\000\000\000\000\n\013\000\000\000\000\000\000\000\000\000\000\000\000\n\013\000\000\000\000\000\000\000\000\n\013\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004E\n\013\000J\004E\000N\004E\000V\004E\000\000\004E\000\000\000\000\000\000\000Z\004E\004E\000\000\000\000\000\000\000\000\000\000\n\013\000\000\000\000\n\013\000\000\000\000\004E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\013\000\157\004E\004E\000\000\n\013\000\000\n\013\004E\000\000\n\013\000\000\n\013\000\000\000\000\000\000\000\000\n\013\000\000\000\157\n\013\000\000\000\000\000\000\004E\000\000\000\000\004E\000\000\000\000\000\000\000\000\004E\004E\011\"\n\013\004E\000^\017\222\n\013\000\157\000\157\000\000\000\000\004E\000\000\000\000\000\000\004E\004E\000\157\000\000\000\000\011*\000\000\011:\000\000\000\000\004E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\157\004E\000\000\000\000\000\000\000\000\004E\004I\000\000\000n\004I\000r\004I\000z\004I\004E\004I\000\000\000\000\000\000\000~\004I\004I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004I\004E\000\157\000\000\004E\004E\000\000\000\000\004E\0112\004I\004I\000\000\004E\004E\000\000\004I\000\000\004E\000\000\000\000\000\157\000\000\000\000\000\000\000\000\000\000\000\000\001\137\000\000\000\000\001\137\004I\000\000\000\000\004I\000\157\000\157\000\000\000\000\004I\004I\000\000\000\000\004I\000\130\001\137\000\000\000\000\000\000\001\137\000\000\004I\000\000\000\000\001\137\004I\004I\000\000\000\000\000\000\001\137\000\000\000\000\001\137\001\137\004I\001\137\001\137\000\000\000\000\000\000\000\000\001\137\000\000\000\000\004I\001\137\000\000\000\000\001\137\000\000\001\137\001\137\000\000\004I\000\000\000\000\000\000\000\000\004I\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004I\000\000\000\000\000\000\001\137\000\000\001\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\137\000\000\000\000\000\000\004I\000\000\000\000\004I\004I\000\000\000\000\004I\000\000\000\000\000\000\000\000\004I\004I\000\000\000\000\000\000\004I\000\000\001\137\001\137\001\206\000\000\001\137\001\137\000\000\000\000\001\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\137\000\000\000\000\001\137\001\137\001\137\001\137\000\000\000\000\000\000\000\000\002z\001\137\001\137\000\000\001\137\001\137\001\137\t\253\t\253\t\253\t\253\000\000\t\253\000\000\t\253\t\253\000\000\t\253\000\000\t\253\000\000\t\253\000\000\t\253\t\253\t\253\t\253\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\253\t\253\t\253\000\000\000\000\000\000\000\000\t\253\000\000\000\000\000\000\000\000\t\253\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\t\253\000\000\000\000\000\000\000\000\000\000\000\000\t\253\000\000\000\000\000\000\000\000\t\253\000\000\000\000\000\000\000\000\011\241\000\000\000\000\000\000\t\253\000\000\000\000\000\000\nJ\000\000\000\000\000\000\000\000\000\000\000\000\011\241\000\000\000\000\000\000\000\000\000\000\011\241\011\241\000\000\t\253\nR\000\000\t\253\n^\000\000\000\000\011\241\000\000\000\000\011\241\000\000\011\241\000\000\t\253\000\000\000\000\000\000\000\000\t\253\000\000\t\253\000\000\000\000\t\253\000\000\t\253\000\000\000\000\000\000\000\000\t\253\000\000\011\241\t\253\000\000\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\t\253\000\000\nj\017b\t\253\n\001\n\001\n\001\n\001\000\000\n\001\000\149\n\001\n\001\000\000\n\001\000\000\n\001\000\000\n\001\011\241\n\001\n\001\n\001\n\001\nn\000\149\011\241\000\000\000\000\000\000\000\000\000\149\000\149\000\000\nv\n\001\n\001\n\001\011\241\000\000\000\000\000\149\n\001\000\000\011*\000\000\000\149\n\001\000\000\000\000\000\000\017\226\000\000\011\241\011\241\000\000\000\000\000\153\000\000\000\000\000\000\n\001\000\000\000\000\000\000\000\000\000\000\000\149\n\001\000\000\000\000\000\000\000\000\n\001\000\000\000\153\000\000\000\000\000\000\000\000\000\000\000\000\n\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\153\000\000\000\000\000\000\000\000\000\000\000\153\000\153\000\000\000\000\000\000\000\000\n\001\000\149\000\000\n\001\000\153\000\000\000\000\011*\0112\000\153\000\000\000\000\000\000\000\000\n\001\000\000\000\000\000\000\000\000\n\001\000\149\n\001\000\000\000\000\n\001\000\000\n\001\000\000\000\000\000\000\000\153\n\001\000\000\000\000\n\001\000\149\000\149\000\000\0002\0006\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\n\001\000\146\000\000\000\150\n\001\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\153\000\000\000\000\017\234\000\186\018\006\000\000\0112\000\000\000\000\018\018\000\000\000\000\000\000\000\000\000\190\000\000\000\000\000\000\000\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\169\018*\000\000\000\000\000\000\000\000\000\153\000\153\000\202\000\000\000\000\000\000\000\000\018V\000\000\000\000\000\000\000\000\011\026\000\000\000\000\004}\000\206\000\000\004}\000R\004}\000\000\004}\000\000\004}\000\000\000\000\011\"\000\000\004}\004}\000\000\000\000\000\169\000\169\000\000\018v\000\000\000\000\018\198\000\000\000\000\004}\000\169\000\000\000\000\011*\000\000\011:\000\000\018\222\000\000\004}\004}\000\000\018\234\000\000\008-\004}\000\000\018\246\000\000\019\002\000\000\000\000\000\000\000\000\019\018\000\000\011J\019\194\000\000\000\000\000\000\004}\000\000\000\000\004}\000\000\000\000\000\000\000\000\004}\004}\000\000\019\206\004}\004}\004\129\019\230\000\000\004\129\000v\004\129\004}\004\129\000\000\004\129\004}\004}\000\000\000\000\004\129\004\129\000\000\000\169\000\000\000\000\004}\000\000\000\000\000\000\0112\000\000\000\000\004\129\000\000\000\000\004}\000\000\000\000\000\000\000\000\000\000\000\169\004\129\004\129\004}\000\000\000\000\000\000\004\129\004}\000\000\000\000\000\000\000\000\000\000\000\000\000\169\000\169\004}\000\000\000\000\000\000\000\000\000\000\004\129\000\000\000\000\004\129\000\000\000\000\000\000\000\000\004\129\004\129\000\000\000\000\004\129\004\129\004}\000\000\000\000\004}\004}\000\000\004\129\004}\000\000\000\000\004\129\004\129\004}\004}\000\000\000\000\000\000\004}\000\000\000\000\004\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\129\000\000\000\000\000\000\000\000\004\129\004\133\000\000\000\000\004\133\000\142\004\133\000\000\004\133\004\129\004\133\000\000\000\000\000\000\000\000\004\133\004\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\133\004\129\000\000\000\000\004\129\004\129\000\000\000\000\004\129\000\000\004\133\004\133\004\185\004\129\004\129\004\185\004\133\004\185\004\129\004\185\000\000\004\185\000\000\000\000\000\000\000\000\004\185\004\185\000\000\000\000\000\000\000\000\004\133\000\000\000\000\004\133\000\000\000\000\000\000\004\185\004\133\004\133\000\000\000\000\004\133\004\133\000\000\000\000\000\000\004\185\004\185\000\000\004\133\000\000\000\000\004\185\004\133\004\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\133\000\000\000\000\000\000\000\000\004\185\000\000\000\000\004\185\000\210\004\133\000\000\000\000\004\185\004\185\000\000\000\000\004\185\004\185\004\133\000\000\000\000\000\000\000\000\004\133\004\185\000\000\000\000\000\000\004\185\004\185\000\000\000\000\004\133\000\000\000\000\000\000\000\000\000\000\004\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\185\000\000\000\000\000\000\004\133\000\000\000\000\004\133\004\133\004\185\000\000\004\133\001\238\000\000\004\185\002B\004\133\004\133\000\000\000\000\000\000\004\133\000\000\004\185\000\000\000\000\000\000\000\000\000\000\000\000\001\250\000\000\000\000\000\000\002\001\000\000\000\000\000\000\000\000\002\001\000\000\000\000\000\000\004\185\000\000\002\002\004\185\004\185\002\001\002\001\004\185\002b\002j\000\000\000\000\004\185\004\185\002\001\000\000\000\000\004\185\002\"\000\000\000\000\002\n\000\000\002\026\002\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\002*\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\001\0002\006&\000F\000b\006>\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\000\000\000\150\006\150\000\154\000\174\000\178\000\182\006\154\000\000\002\001\0022\000\000\000\000\002\001\002\001\000\000\000\000\002\018\000\000\000\186\000\000\000}\000\000\000\000\000}\000\000\000\000\000\000\000\000\002\001\000\190\000\000\002\001\002\001\002\001\002\001\000\000\000\000\000\000\001\250\000\000\002\001\002\001\000}\002r\002:\002\001\000\000\000}\000\000\000\000\000\202\000\000\000\000\002\002\000\000\000\000\000}\000}\000\000\000}\000}\000\000\000\000\000\000\000\206\000}\000\000\000\000\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000}\000\000\000\000\000\000\000\000\008\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\002*\000\000\000}\000\000\000\000\000\000\000\000\000\000\000\000\000\162\000\000\000\000\000}\0002\t\182\000F\000b\000\000\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\020\234\000\150\006\150\000\154\000\174\000\178\000\182\006\154\020\242\000}\0022\t\166\000\000\000}\000}\000\000\000\000\002\018\000\000\000\186\000\000\000e\000\000\000\000\000e\000\000\000\000\000\000\000\000\000}\000\190\000\000\000}\000}\000}\000}\000\000\000\000\000\000\000e\000\000\000}\000}\000e\000}\002:\000}\000\000\000e\000\000\000\000\000\202\000\000\000\000\002\002\000\000\000\000\000e\000e\000\000\000e\000e\000\000\000\000\000\000\000\206\000e\000\000\000\000\000\000\000e\000\000\000\000\002\n\000\000\002\026\000e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000e\000\000\000e\000\000\000\000\000\000\000\000\000\000\000\000\000\162\000\000\000\000\000e\000\000\003\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\000\000e\000e\000\000\000\000\000e\000e\000\000\000\000\002\018\000\000\000\000\000\000\000]\000\000\000\000\000]\000\000\000\000\000\000\000\000\000e\000\000\000\000\000e\000e\000e\000e\000\000\000\000\000\000\000]\000\000\000e\000e\000]\000e\000e\000e\000\000\000]\000\000\000\000\000\000\000\000\000\000\000]\000\000\000\000\000]\000]\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000]\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\238\000F\000b\000\000\000f\006\142\000j\000\134\006\146\000\138\000\000\000\146\020\234\000\150\006\150\000\154\000\174\000\000\000\182\006\154\020\242\000]\000]\000\000\000\000\000]\000]\000\000\000\000\002\018\000\000\000\186\000\000\000a\000\000\000\000\000a\000\000\000\000\000\000\000\000\000]\000\190\000\000\000]\000]\000]\000]\000\000\000\000\000\000\000a\000\000\000]\000]\000a\000]\000]\000]\000\000\000a\000\000\000\000\000\000\000\000\000\000\000a\000\000\000\000\000a\000a\000\000\000a\000a\000\000\000\000\000\000\000\206\000a\000\000\000\000\000\000\000a\000\000\000\000\002\n\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000a\000\000\000a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000a\000\000\003\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\000\000a\000a\000\000\000\000\000a\000a\000\000\000\000\002\018\000\000\000\000\000\000\000q\000\000\000\000\000q\000\000\000\000\000\000\000\000\000a\000\000\000\000\000a\000a\000a\000a\000\000\000\000\000\000\001\250\000\000\000a\000a\000q\000a\000a\000a\000\000\000q\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000q\000q\000\000\000q\000q\000\000\000\000\000\000\000\000\000q\000\000\000\000\000\000\000q\000\000\000\000\002\n\000\000\002\026\000q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000q\0002\006B\006J\000b\000\000\000f\000\000\006N\000\134\000\000\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000q\000q\000\000\000\000\000q\000q\000\000\000\000\002\018\000\000\000\186\000\000\000i\000\000\000\000\000i\000\000\000\000\000\000\000\000\000q\000\190\000\000\000q\000q\000q\000q\000\000\000\000\000\000\001\250\000\000\000q\000q\000i\000q\000q\000q\000\000\000i\000\000\000\000\006R\000\000\000\000\002\002\000\000\000\000\000i\000i\000\000\000i\000i\000\000\000\000\000\000\000\206\000i\000\000\000\000\000\000\000i\000\000\000\000\002\n\000\000\002\026\000i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000i\000\000\000i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000i\000i\000\000\000\000\000i\000i\000\000\000\000\002\018\000\000\000\000\000\000\000m\000\000\000\000\000m\000\000\000\000\000\000\000\000\000i\000\000\000\000\000i\000i\000i\000i\000\000\000\000\000\000\001\250\000\000\000i\000i\000m\000i\000i\000i\000\000\000m\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000m\000m\000\000\000m\000m\000\000\000\000\000\000\000\000\000m\000\000\000\000\000\000\000m\000\000\000\000\002\n\000\000\002\026\000m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000m\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000m\000m\000\000\000\000\000m\000m\000\000\000\000\002\018\000\000\000\000\000\000\000u\000\000\000\000\000u\000\000\000\000\000\000\000\000\000m\000\000\000\000\000m\000m\000m\000m\000\000\000\000\000\000\001\250\000\000\000m\000m\000u\000m\000m\000m\000\000\000u\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000u\000u\000\000\000u\000u\000\000\000\000\000\000\000\000\000u\000\000\000\000\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\0022\000\000\000\000\000u\000u\000\000\000\000\002\018\000\000\000\000\000\000\001\238\000\000\000\000\000\133\000\000\000\000\000\000\000\000\000u\000\000\000\000\000u\000u\000u\000u\000\000\000\000\000\000\001\250\000\000\000u\000u\000\133\000u\000u\000u\000\000\000\133\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\133\000\133\000\000\000\133\002j\000\000\000\000\000\000\000\000\000\133\000\000\000\000\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\133\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\0022\000\000\000\000\000\133\000\133\000\000\000\000\002\018\000\000\000\000\000\000\001\238\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\133\000\000\000\000\000\133\000\133\000\133\000\133\000\000\000\000\000\000\001\250\000\000\000\133\000\133\000y\002r\002:\000\133\000\000\000y\000\000\000\000\000\000\000\000\000\000\002\002\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\002\"\000\000\000\000\002\n\000\000\002\026\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\000\000\000\000\002*\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000y\0022\000\000\000\000\000y\000y\000\000\000\000\002\018\000\000\000\000\000\000\001\238\000\000\000\000\000\129\000\000\000\000\000\000\000\000\000y\000\000\000\000\000y\000y\000y\000y\000\000\000\000\000\000\001\250\000\000\000y\000y\000\129\000y\002:\000y\000\000\000\129\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\129\000\129\000\000\000\129\002j\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\002\"\000\000\000\000\002\n\000\000\002\026\000\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\002*\000\000\000\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\004\153\000\000\000\000\004\153\000\000\004\153\000\000\004\153\000\000\004\153\000\000\000\000\000\000\000\000\004\153\004\153\000\000\000\000\000\000\000\000\000\000\000\129\0022\000\000\000\000\000\129\000\129\004\153\000\000\002\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\153\004\153\000\000\000\000\000\129\000\000\004\153\000\129\000\129\000\129\000\129\000\000\000\000\000\000\000\000\000\000\000\129\000\129\000\000\000\129\002:\000\129\004\153\000\000\000\000\004\153\005\226\000\000\000\000\000\000\004\153\004\153\000\000\000\000\004\153\004\153\005\129\000\000\000\000\005\129\000\000\005\129\004\153\005\129\000\000\005\129\004\153\004\153\000\000\000\000\005\129\005\129\000\000\000\000\000\000\000\000\004\153\000\000\005\129\000\000\000\000\000\000\000\000\005\129\000\000\000\000\004\153\000\000\005\129\005\129\000\000\000\000\000\000\005\129\005\129\004\153\000\000\000\000\000\000\005\129\004\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\153\000\000\000\000\000\000\005\129\000\000\005\129\000\000\000\000\005\129\002\150\000\000\000\000\005\129\005\129\002\150\000\000\000\000\005\129\005\129\004\153\005\129\000\000\004\153\004\153\005\129\005\129\004\153\000\000\000\000\005\129\005\129\004\153\004\153\000\000\005\129\000\000\004\153\000\000\000\000\005\129\000\000\000\000\000\000\000\000\005\129\000\000\000\000\000\000\000\000\005\129\000\000\000\000\000\000\005\129\000\000\000\000\000\000\000\000\005\129\000\000\000\000\000\000\000\000\005\129\000\000\000\000\000\000\005\129\000\000\000\000\000\000\n\198\005\129\000\000\000\000\000\000\003i\000\000\003i\000\000\000\000\003i\000\000\000\000\000\000\000\000\000\000\005\129\000\000\000\000\005\129\005\129\005\129\000\000\005\129\005\129\005\129\003i\000\000\005\129\005\129\000\000\000\000\000\000\005\129\005\129\003i\003i\000\000\005\129\003i\003i\000\000\000\000\000\000\000\000\003i\000\000\003i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003i\003i\000\000\000\000\003i\003i\003i\000\000\003i\003i\000\000\003i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\161\000\000\000\000\001\161\003i\003i\000\000\000\000\000\000\003i\000\000\000\000\003i\000\000\000\000\000\000\000\000\000\000\001\161\000\000\000\000\003i\001\161\000\000\000\000\000\000\000\000\001\161\003i\000\000\003i\000\000\003i\001\161\000\000\000\000\001\161\001\161\000\000\001\161\001\161\000\000\003i\000\000\000\000\001\161\000\000\003i\000\000\001\161\000\000\000\000\001\161\003i\001\161\001\161\003i\000\000\000\000\000\000\000\000\000\000\003i\000\000\000\000\000\000\003q\003q\003q\003q\000\000\003q\000\000\003q\003q\001\161\003q\001\161\003q\000\000\003q\000\000\003q\003q\003q\003q\000\000\001\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\238\000\000\000\000\003q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003q\001\161\001\161\007~\000\000\001\161\000\000\000\000\000\000\001\161\001\030\000\000\t\226\000\000\000\000\t\230\000\000\000\000\000\000\000\000\000\000\003q\000\000\000\000\001\161\000\000\001\161\003q\000\000\000\000\000\000\001*\007\134\001\161\001\161\003q\001\161\001\161\001\161\000\000\t\234\n\146\000\000\000\000\n\166\n\190\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\n\001^\000\000\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\026\000\000\000\000\000\000\003q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\n\030\000\000\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001\030\000\000\t\226\000\000\000\000\t\230\n*\000\000\000\000\000\000\000\000\000\000\000\000\005\169\000\000\n\194\000\000\n\222\000\000\003q\000\000\001*\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\t\234\n\146\n2\000\000\n\166\n\190\000\000\000\000\011\186\000\000\001R\n6\001V\000\000\000\000\000\000\000\000\001\154\000\000\000\000\n\n\001^\000\000\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\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\000\000\006\254\n\030\000\000\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001\030\000\000\t\226\000\000\000\000\t\230\n*\000\000\000\000\000\000\000\000\000\000\000\000\005\169\000\000\n\194\000\000\n\222\000\000\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\t\234\n\146\n2\000\000\n\166\n\190\000\000\000\000\n\230\000\000\001R\n6\001V\000\000\000\000\000\000\000\000\001\154\000\000\000\000\n\n\001^\000\000\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\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\000\000\006\254\n\030\000\000\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001\030\000\000\t\226\000\000\000\000\t\230\n*\000\000\000\000\000\000\000\000\000\000\000\000\005\169\000\000\n\194\000\000\n\222\000\000\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\t\234\n\146\n2\000\000\n\166\n\190\000\000\000\000\005\021\000\000\001R\n6\001V\000\000\000\000\000\000\000\000\001\154\000\000\012\013\n\n\001^\012\013\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\026\000\000\000\000\000\000\000\000\000\000\012\013\000\000\000\000\000\000\012\013\000\000\000\000\000\000\003V\006\254\n\030\000\000\000\000\000\000\n\"\012\013\000\000\000\162\000\000\012\013\000\000\012\013\012\013\000\000\000\000\003^\n*\000\000\003j\000\000\000\000\012\013\000\161\005\169\012\013\n\194\012\013\n\222\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\011\026\000\000\n2\000\000\000\000\000\000\000\000\012\013\001\189\000\000\000\000\n6\000\000\000\000\000\000\011\"\000\000\001\154\000\000\012\013\000\000\000\161\000\161\000\000\000\000\003v\000\000\000\000\000\000\000\000\001\030\000\161\t\226\000\000\011*\t\230\011:\000\000\000\000\000\000\000\000\000\000\000\000\012\013\012\013\000\000\012\013\000\000\003z\000\000\012\013\001*\000\000\000\000\000\000\000\000\000\000\000\161\003\130\000\000\t\234\n\146\012\013\000\000\n\166\n\190\000\000\012\013\012\013\000\000\001R\000\000\001V\012\013\000\000\000\000\000\000\012\013\012\013\012\013\n\n\001^\000\000\000\000\n\014\008\166\001j\000\000\n\018\n\022\000\000\n\026\000\000\000\161\000\000\000\000\000\000\000\000\001\137\000\000\0112\001\137\000\000\000\000\000\000\000\000\006\254\n\030\000\000\000\000\000\000\n\"\000\161\000\000\000\162\000\000\001\137\000\000\000\000\000\000\000\000\000\000\000\000\n*\000\000\001\137\000\000\000\161\000\161\000\000\005\169\001\137\000\000\000\000\n\222\000\000\000\000\001\137\001\137\000\000\000\000\000\000\000\000\007\178\n.\000\000\008\002\001\137\000\000\n2\001\137\000\165\001\137\001\137\000\000\001\201\000\000\000\000\n6\000\000\000\000\007\186\000\000\000\000\001\154\002\017\000\000\000\000\000\000\011\026\002\017\000\000\000\000\001\137\000\000\001\137\007\194\000\000\000\000\002\017\002\017\000\000\008\018\008\026\011\"\000\000\000\000\000\000\002\017\000\000\000\165\000\165\007\226\000\000\000\000\007\202\000\000\007\218\002\017\000\000\000\165\000\000\000\000\011*\000\000\011:\000\000\000\000\001\137\001\137\001\198\000\000\001\137\001\137\000\000\000\000\001\137\000\000\007\234\000\000\002\017\000\000\000\000\000\000\000\000\000\000\011J\000\000\001\137\000\000\002\017\001\137\001\137\000\000\001\137\000\000\000\000\000\000\000\000\002\134\001\137\001\137\000\000\001\137\001\137\001\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\017\007\242\000\000\000\000\002\017\000\000\000\000\000\000\007\210\000\165\000\000\000\000\001%\000\000\000\000\001%\0112\000\000\000\000\000\000\000\000\000\000\000\000\002\017\000\000\002\017\000\000\000\000\000\165\000\000\007\186\000\000\002\017\002\017\001%\008\"\007\250\002\017\000\000\001%\000\000\000\000\000\000\000\165\000\165\007\194\000\000\000\000\001%\001%\000\000\001%\001%\000\000\000\000\000\000\000\000\001%\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\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\007\234\001\013\001%\000\000\001\013\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\001\013\000\000\000\000\000\000\001\013\000\000\000\000\000\000\000\000\001\013\000\000\000\000\000\000\000\000\000\000\007\194\001%\007\242\001\013\001\013\001%\001\013\001\013\000\000\007\210\000\000\000\000\001\013\000\000\000\000\000\000\001\013\000\000\000\000\007\202\000\000\007\218\001\013\000\000\001%\000\000\001%\000\000\000\000\000\000\000\000\000\000\000\000\001%\001%\000\000\001%\007\250\001%\000\000\000\000\000\000\001\013\001\005\001\013\000\000\001\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\013\000\000\000\000\000\000\000\000\000\000\000\000\001\005\000\000\000\000\000\000\001\005\000\000\000\000\000\000\000\000\001\005\000\000\000\000\000\000\000\000\000\000\001\005\001\013\001\013\001\005\001\005\001\013\001\005\001\005\000\000\007\210\000\000\000\000\001\005\000\000\000\000\000\000\001\005\000\000\000\000\007\202\000\000\001\005\001\005\000\000\001\013\000\000\001\013\000\000\000\000\000\000\000\000\000\000\000\000\001\013\001\013\000\000\001\013\001\013\001\013\000\000\000\000\000\000\001\005\001\t\001\005\000\000\001\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\005\000\000\000\000\000\000\000\000\000\000\000\000\001\t\000\000\000\000\000\000\001\t\000\000\000\000\000\000\000\000\001\t\000\000\000\000\000\000\000\000\000\000\001\t\001\005\001\005\001\t\001\t\001\005\001\t\001\t\000\000\007\210\000\000\000\000\001\t\000\000\000\000\000\000\001\t\000\000\000\000\007\202\000\000\001\t\001\t\000\000\001\005\000\000\001\005\000\000\000\000\000\000\000\000\000\000\000\000\001\005\001\005\000\000\001\005\001\005\001\005\000\000\000\000\000\000\001\t\001\025\001\t\000\000\001\025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\t\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001\025\000\000\000\000\000\000\000\000\001\025\000\000\000\000\000\000\000\000\000\000\007\194\001\t\001\t\001\025\001\025\001\t\001\025\001\025\000\000\007\210\000\000\000\000\001\025\000\000\000\000\000\000\001\025\000\000\000\000\007\202\000\000\007\218\001\025\000\000\001\t\000\000\001\t\000\000\000\000\000\000\000\000\000\000\000\000\001\t\001\t\000\000\001\t\001\t\001\t\000\000\000\000\000\000\007\234\001\017\001\025\000\000\001\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\025\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001\017\000\000\000\000\000\000\000\000\001\017\000\000\000\000\000\000\000\000\000\000\007\194\001\025\001\025\001\017\001\017\001\025\001\017\001\017\000\000\007\210\000\000\000\000\001\017\000\000\000\000\000\000\001\017\000\000\000\000\007\202\000\000\007\218\001\017\000\000\001\025\000\000\001\025\000\000\000\000\000\000\000\000\000\000\000\000\001\025\001\025\000\000\001\025\001\025\001\025\000\000\000\000\000\000\001\017\001\021\001\017\000\000\001\021\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\017\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001\021\000\000\000\000\000\000\000\000\001\021\000\000\000\000\000\000\000\000\000\000\007\194\001\017\001\017\001\021\001\021\001\017\001\021\001\021\000\000\007\210\000\000\000\000\001\021\000\000\000\000\000\000\001\021\000\000\000\000\007\202\000\000\007\218\001\021\000\000\001\017\000\000\001\017\000\000\000\000\000\000\000\000\000\000\000\000\001\017\001\017\000\000\001\017\001\017\001\017\000\000\000\000\000\000\007\234\001\029\001\021\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\021\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\007\194\001\021\001\021\001\029\001\029\001\021\001\029\001\029\000\000\007\210\000\000\000\000\001\029\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001\029\000\000\001\021\000\000\001\021\000\000\000\000\000\000\000\000\000\000\000\000\001\021\001\021\000\000\001\021\001\021\001\021\000\000\000\000\000\000\007\234\007\178\001\029\000\000\001-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\007\186\000\000\000\000\000\000\001-\000\000\000\000\000\000\000\000\001-\000\000\000\000\000\000\000\000\000\000\007\194\001\029\007\242\001-\001-\001\029\001-\008\026\000\000\007\210\000\000\000\000\001-\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001-\000\000\001\029\000\000\001\029\000\000\000\000\000\000\000\000\000\000\000\000\001\029\001\029\000\000\001\029\001\029\001\029\000\000\000\000\000\000\007\234\007\178\001-\000\000\001!\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\007\186\000\000\000\000\000\000\001!\000\000\000\000\000\000\000\000\001!\000\000\000\000\000\000\000\000\000\000\007\194\001-\007\242\001!\001!\001-\001!\001!\000\000\007\210\000\000\000\000\001!\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001!\000\000\001-\000\000\001-\000\000\000\000\000\000\000\000\000\000\000\000\001-\001-\000\000\008\"\007\250\001-\000\000\000\000\000\000\007\234\007\178\001!\000\000\001)\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\007\186\000\000\000\000\000\000\001)\000\000\000\000\000\000\000\000\001)\000\000\000\000\000\000\000\000\000\000\007\194\001!\007\242\001)\001)\001!\001)\008\026\000\000\007\210\000\000\000\000\001)\000\000\000\000\000\000\007\226\000\000\000\000\007\202\000\000\007\218\001)\000\000\001!\000\000\001!\000\000\000\000\000\000\000\000\000\000\000\000\001!\001!\000\000\001!\007\250\001!\000\000\000\000\000\000\007\234\000\000\001)\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\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\000\000\000\000\000\000\001)\007\242\000\000\000\000\001)\000\000\000\000\000\000\007\210\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\000\000\001>\001B\000\000\001J\001)\t\222\001)\000\000\000\000\000\000\001R\000\000\001V\001)\001)\000\000\001)\007\250\001)\000\000\001Z\001^\000\000\n\206\001b\001f\001j\000\000\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\000\000\001~\000\000\000\000\000\162\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\001\134\000\000\000\000\000\000\000\000\000\000\000\000\008>\000\000\001\138\008=\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\001\142\001>\001B\000\000\001J\001\146\000\000\000\000\008=\000\000\008=\001R\000\000\001V\001\150\000\000\000\000\000\000\000\000\000\000\001\154\001Z\001^\000\000\000\000\001b\001f\001j\000\000\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\000\000\001~\000\000\000\000\000\162\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\001\134\000\000\000\000\000\000\000\000\000\000\000\000\008=\000\000\001\138\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\001\142\001>\001B\000\000\001J\001\146\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\001\150\000\000\000\000\000\000\000\000\000\000\001\154\001Z\001^\000\000\000\000\001b\001f\001j\000\000\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\000\000\001~\000\000\000\000\000\162\001\030\000\000\001\"\000\000\000\000\001&\000\000\000\000\001\134\000\000\000\000\000\000\000\000\000\000\000\000\014\186\000\000\001\138\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\001\142\001>\001B\000\000\001J\001\146\000\000\001\030\000\000\001\"\000\000\001R\001&\001V\001\150\000\000\000\000\000\000\000\000\000\000\001\154\001Z\001^\000\000\000\000\001b\001f\001j\001*\001n\001r\001.\001v\000\000\000\000\000\000\000\000\001>\004\226\000\000\001J\000\000\000\000\000\000\000\000\000\000\000\000\001R\001z\001V\000\000\000\000\001~\000\000\000\000\000\162\000\000\001Z\001^\000\000\000\000\001b\001f\001j\001\134\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\001\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\001\142\000\000\000\000\001~\000\000\001\146\000\162\001\030\000\000\001\"\000\000\000\000\001&\000\000\001\150\001\134\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\001\138\000\000\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\000\000\000\000\001\142\001>\001\130\000\000\001J\001\146\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\001\150\000\000\000\000\000\000\000\000\000\000\001\154\001Z\001^\000\000\000\000\001b\001f\001j\000\000\001n\001r\000\000\001v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001z\000\000\000\000\003\202\001~\000\000\000\000\000\162\003a\000\000\003a\000\000\000\000\003a\000\000\000\000\001\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\138\000\000\000\000\000\000\003a\000\000\000\000\003a\000\000\000\000\000\000\000\000\001\142\003a\003a\000\000\003a\001\146\000\000\000\000\000\000\000\000\000\000\003a\000\000\003a\001\150\000\000\000\000\000\000\000\000\000\000\001\154\003a\003a\000\000\000\000\003a\003a\003a\000\000\003a\003a\000\000\003a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004!\000\000\000\000\004!\000\000\000\000\000\000\000\000\003a\000\000\000\000\000\000\003a\000\000\000\000\003a\000\000\000\000\004!\000\000\000\000\000\000\000\000\000\000\003a\000\000\004!\004!\000\000\000\000\000\000\000\000\000\000\004!\000\000\000\000\001\030\000\000\0012\004!\004!\0016\000\000\004!\000\000\003a\004!\000\000\000\000\004!\003a\000\000\004!\000\000\004!\004!\000\000\001*\000\000\003a\001.\000\000\000\000\000\000\000\000\003a\001:\001N\000\000\001J\000\000\000\000\000\000\000\000\000\000\004!\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\022\001^\000\000\000\000\003\026\001f\001j\004!\003\030\003\"\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\000\000\000\000\004!\004!\003*\000\000\004\189\004!\003.\004!\000\000\000\162\000\000\000\000\001\030\000\000\0012\004!\000\000\0016\0036\004!\000\000\000\000\004!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004!\000\000\000\000\001*\004!\004!\001.\000\000\000\000\003:\000\000\000\000\001:\004\202\003>\001J\000\000\000\000\000\000\000\000\000\000\000\000\001R\003B\001V\000\000\000\000\000\000\000\000\001\154\000\000\000\000\003\022\001^\000\000\000\000\003\026\001f\001j\000\000\003\030\003\"\000\000\003&\000\000\000\000\000\000\000\000\001\030\000\000\0012\000\000\000\000\0016\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\000\000\000\003.\000\000\000\000\000\162\000\000\000\000\001*\000\000\000\000\001.\000\000\000\000\0036\000\000\000\000\001:\0032\000\000\001J\000\000\000\000\001\030\000\000\006\202\000\000\001R\006\206\001V\000\000\000\000\000\000\000\000\000\000\003:\000\000\003\022\001^\000\000\003>\003\026\001f\001j\001*\003\030\003\"\000\000\003&\003B\000\000\000\000\000\000\006\210\008*\001\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\003*\001V\000\000\000\000\003.\000\000\000\000\000\162\000\000\006\234\001^\000\000\000\000\006\238\001f\001j\0036\006\242\006\246\000\000\006\250\000\000\000\000\000\000\000\000\001\030\000\000\006\202\000\000\000\000\006\206\000\000\000\000\000\000\000\000\006\254\007\002\003:\000\000\000\000\007\006\000\000\003>\000\162\000\000\000\000\001*\000\000\000\000\000\000\000\000\003B\007\014\000\000\000\000\006\210\006\214\001\154\000\000\000\173\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\007\018\000\000\006\234\001^\011\026\007\022\006\238\001f\001j\000\000\006\242\006\246\000\000\006\250\007\026\000\000\000\000\000\000\000\000\011\"\001\154\000\000\000\000\000\000\000\000\000\173\000\173\000\000\006\254\007\002\000\000\000\000\000\000\007\006\000\000\011B\000\162\001\030\011*\006\202\011:\000\000\006\206\000\000\000\000\007\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\001*\000\000\000\000\011J\000\000\000\000\000\000\000\000\007\018\006\210\007\n\000\000\000\000\007\022\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\007\026\000\000\000\000\000\000\000\000\000\000\001\154\006\234\001^\000\000\000\000\006\238\001f\001j\000\000\006\242\006\246\011R\006\250\000\000\000\000\000\000\000\000\001\030\0112\t\226\000\000\000\000\t\230\000\000\000\000\000\000\000\000\006\254\007\002\000\000\000\173\000\000\007\006\000\000\000\000\000\162\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\007\014\000\173\000\173\t\234\t\246\000\000\000\000\011\018\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\007\018\000\000\n\n\001^\011\026\007\022\n\014\001f\001j\000\000\n\018\n\022\000\000\n\026\007\026\000\000\000\000\000\000\000\000\011\"\001\154\000\000\000\000\000\000\000\000\000\189\011j\000\000\006\254\n\030\000\000\000\000\000\000\n\"\000\000\011B\000\162\001\030\011*\t\226\011:\000\000\t\230\000\000\000\000\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\001*\000\000\000\000\011J\000\000\000\000\000\000\000\000\n.\t\234\n&\000\000\000\000\n2\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\n6\000\000\000\000\000\000\000\000\000\000\001\154\n\n\001^\000\000\000\000\n\014\001f\001j\000\000\n\018\n\022\011R\n\026\000\000\000\000\000\000\000\000\001\030\0112\t\226\000\000\000\000\t\230\000\000\000\000\000\000\000\000\006\254\n\030\000\000\000\189\000\000\n\"\000\000\000\000\000\162\000\000\000\000\001*\000\000\000\000\000\000\000\000\000\000\n*\011r\011Z\t\234\n\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001R\000\000\001V\000\000\000\000\000\000\000\000\000\000\n.\000\000\n\n\001^\000\000\n2\n\014\001f\001j\000\000\n\018\n\022\000\000\n\026\n6\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\n\030\000\000\000\000\000\000\n\"\000\000\000\000\000\162\000\000\000\000\000\000\000\000\0002\0006\000F\000b\n*\000f\000\000\000j\000\134\007\169\000\138\017r\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\n.\000\000\000\000\000\000\000\000\n2\007\169\000\186\017v\000\000\000\000\000\000\000\000\000\000\n6\000\000\007\169\007\169\019\234\000\000\001\154\000\000\007\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\153\000\000\000\000\001\153\000\000\000\202\000\000\007\169\000\000\000\000\018V\000\000\007\169\000:\017\134\000:\007\169\007\169\001\153\000\206\000\000\000\000\001\153\000\000\007\169\000\000\000\000\000\000\007\169\007\169\000\000\000\000\000\000\001\153\000\000\000\000\000\000\001\153\007\169\001\153\001\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\169\001\153\000\000\000\000\001\153\000\000\001\153\000\000\000\000\007\169\000\000\000\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\169\000\000\017\138\000\000\001\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\153\000\000\000\000\000\000\007\169\000\000\000\000\007\169\007\169\000\000\000\000\007\169\000\000\000\000\000\000\000\000\007\169\007\169\000\000\005\129\000\000\007\169\005\129\000\000\001\153\003\166\005\129\001\153\005\129\000\000\000\000\001\153\000\000\005\129\005\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\153\000\000\000\000\000\000\000\000\001\153\001\153\000\000\000\000\000\000\000\000\003\174\000\000\000\000\000\000\001\153\001\153\001\153\000\000\007\169\0002\000\214\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\000\000\150\005\129\000\154\000\174\000\178\000\182\003\254\000\000\000\000\004N\000\218\000\000\000\000\007\169\000\000\000\000\000\000\000\000\000\186\000\000\000\000\007\169\000\000\000\000\004\006\007\169\007\169\000\000\002\t\000\190\000\000\000\000\000\000\000\000\000\000\007\169\000\000\000\000\000\000\004\014\000\000\000\000\000\000\002\t\000\000\004^\004f\000\000\000\000\000\000\000\202\000\000\000\000\000\000\007\169\004.\000\230\000\000\004\022\005\129\004&\000\000\000\000\000\000\000\206\000\000\000\000\000\000\007\169\011\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0046\000\000\000\000\000\000\000\000\000\000\011\026\007\169\000\000\000\000\007\169\007\169\002\t\000\237\000\000\000\000\000\237\000\000\000\000\007\169\007\169\011\"\000\000\000\162\007\169\000\000\000\000\000\177\000\177\000\000\000\000\004\006\000\000\000\000\000\000\000\237\004>\011B\000\000\002\t\011*\000\234\011:\004\030\000\000\000\000\004\014\000\000\000\000\000\000\000\237\000\000\000\237\000\237\000\000\002\t\000\000\000\000\000\000\000\000\002\t\002\t\004.\011J\011Y\004\022\000\000\004&\000\000\000\000\004n\004F\002\t\000\000\000\000\000\000\000\213\000\000\000\000\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0046\000\000\000\000\000\000\000\000\000\000\000\213\000\000\000\000\000\000\000\213\011R\000\237\000\000\000\000\000\000\000\000\000\000\0112\000\000\000\000\004\014\000\000\000\000\000\000\000\213\000\000\000\213\000\213\000\205\000\177\000\000\000\205\000\000\000\000\000\000\004>\000\213\000\000\000\237\004\022\000\000\004&\004\030\000\000\000\177\011Z\000\205\000\000\000\000\000\000\000\205\000\000\000\000\000\000\000\237\000\000\000\000\000\000\000\000\000\237\000\237\000\205\000\213\000\000\000\000\000\205\000\000\000\205\000\205\000\237\004F\000\237\000\000\000\000\000\213\000\000\000\000\000\205\000\000\000\000\004\022\000\000\000\205\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\209\000\000\000\000\000\209\000\000\000\000\000\000\000\213\000\000\000\000\000\213\000\000\000\205\000\000\004\030\000\000\000\000\000\000\000\209\000\000\000\000\000\000\000\209\000\000\000\205\000\000\000\213\000\000\000\000\000\000\000\000\000\213\000\213\000\209\000\000\000\000\000\000\000\209\000\000\000\209\000\209\000\213\000\213\000\213\000\000\000\000\000\000\000\000\000\205\000\209\000\000\000\205\004\022\000\000\000\209\004\030\000\225\000\000\000\000\000\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\205\000\000\000\000\000\000\000\000\000\205\000\205\004\006\000\209\000\000\000\000\000\225\000\000\000\000\000\000\000\205\000\205\000\205\000\000\000\000\000\209\000\000\004\014\000\000\000\000\000\000\000\225\000\000\000\225\000\225\000\000\000\000\000\000\000\000\000\217\000\000\000\000\000\217\000\225\000\000\000\000\004\022\000\000\004&\000\209\000\000\000\000\000\209\000\000\000\000\000\000\004\030\004\006\000\000\000\000\000\000\000\217\000\000\000\000\000\000\000\000\000\000\000\000\000\209\0046\000\000\000\000\004\014\000\209\000\209\000\000\000\217\000\000\000\217\000\217\000\000\000\225\000\000\000\209\000\209\000\209\000\000\000\000\000\217\000\000\000\000\004\022\000\000\004&\000\000\000\221\000\000\000\000\000\221\000\000\000\000\000\000\000\000\000\000\000\000\000\225\000\000\000\000\000\225\000\000\000\000\000\000\004\030\004\006\000\217\000\000\000\000\000\221\000\000\000\000\000\000\000\000\000\000\000\000\000\225\000\000\000\217\000\000\004\014\000\225\000\225\000\000\000\221\000\000\000\221\000\221\000\000\000\000\000\000\000\225\000\225\000\225\000\000\000\000\000\221\000\000\000\000\004\022\000\000\004&\000\217\000\000\000\000\000\217\000\000\000\000\000\000\004\030\000\229\000\000\000\000\000\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\217\0046\000\000\000\000\000\000\000\217\000\217\004\006\000\000\000\000\000\000\000\229\000\000\000\221\000\000\000\217\000\217\000\217\000\000\000\000\000\000\000\000\004\014\000\000\000\000\000\000\000\229\000\000\000\229\000\229\003\254\000\000\000\000\000\245\000\000\000\000\000\000\000\221\004.\000\000\000\221\004\022\000\000\004&\004\030\000\000\000\000\000\000\004\006\000\000\000\000\000\000\000\245\000\000\000\000\000\000\000\221\000\000\000\000\000\000\000\000\000\221\000\221\004\014\0046\000\000\000\000\000\245\000\000\000\245\004f\000\221\000\221\000\221\000\000\000\000\000\229\000\000\000\000\004.\000\000\000\000\004\022\000\000\004&\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\254\000\000\000\000\000\233\000\000\000\000\000\000\004>\000\000\000\000\000\229\000\000\0046\000\000\004\030\000\000\000\000\000\000\004\006\000\000\000\000\000\000\000\233\000\000\000\245\000\000\000\229\000\000\000\000\000\000\000\000\000\229\000\229\004\014\000\000\000\000\000\000\000\233\000\000\000\233\000\233\000\229\000\229\000\229\000\000\000\000\000\000\000\000\004>\004.\000\000\000\245\004\022\000\000\004&\004\030\003\254\000\000\000\000\000\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\245\000\000\000\000\000\000\000\000\000\245\000\245\004\006\0046\000\000\000\000\000\241\000\000\000\000\000\000\004n\004F\000\245\000\000\000\000\000\233\000\000\004\014\000\000\000\000\000\000\000\241\000\000\000\241\004f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004.\003\185\000\000\004\022\003\185\004&\004>\000\000\003\185\000\233\003\185\000\000\000\000\004\030\000\000\003\185\003\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\233\0046\000\000\000\000\000\000\000\233\000\233\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\000\000\233\004F\000\233\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\003\185\000\000\004>\000\000\000\000\000\241\000\000\000\000\000\000\004\030\000\000\000\000\002-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002-\000\241\000\000\000\000\002-\002-\000\241\000\241\000\000\000\000\000\000\000\000\000\000\000\000\002-\000\000\000\241\004F\000\241\000\000\000\000\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-\0002\005.\000F\000b\003\185\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\002-\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\186\002-\000\000\000\000\002-\002-\000\000\000\000\000\000\000\000\000\000\000\190\000\000\002-\002-\000\000\000\000\000\000\002-\000\000\000\000\0002\000\214\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\202\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\0052\0056\000\000\000\186\000\000\0002\005.\000F\000b\000\000\000f\000\000\000j\000\134\000\190\000\138\000\000\000\146\000\000\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\202\000\000\000\186\000\000\000\000\000\000\000\230\000\000\000\000\000\000\000\000\000\000\000\000\000\190\000\206\000\000\000\000\000\000\000\000\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\202\000\000\000\000\000\000\000\000\002y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\021\182\0056\000\162\000\000\000\000\0002\005.\000F\000b\000\000\000f\000\000\000j\000\134\000\000\000\138\000\000\000\146\000\000\000\150\000\234\000\154\000\174\000\178\000\182\000\000\000\000\000\000\0002\000\214\000F\000b\000\000\000f\000\000\000j\000\134\000\186\000\138\000\000\000\146\000\000\000\150\002)\000\154\000\174\000\178\000\182\000\190\000\000\000\000\000\000\000\000\000\000\021\186\000\000\000\000\000\000\000\000\000\000\000\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\202\000\000\000\190\000\000\000\000\002q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\0052\0056\000\000\000\000\000\000\000\202\000\000\000\000\011\018\000\000\000\000\000\230\000\000\0002\005.\000F\000b\000\000\000f\000\206\000j\000\134\000\000\000\138\000\000\000\146\011\026\000\150\000\000\000\154\000\174\000\178\000\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\"\000\000\000\000\000\000\000\186\000\000\000\185\011j\000\000\000\000\000\000\000\000\000\000\005B\000\000\000\190\011B\000\000\000\162\011*\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\202\000\000\000\000\000\000\000\000\000\000\011J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\021\182\0056\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\011R\000\000\000\000\000\000\000\000\000\000\000\000\0112\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\021\194\000\000\000\000\000\000\000\185\011Z")) let lhs = - (16, "\000\012\000\011\000\n\000\t\000\008\000\007\000\006\000\005\000\004\000\003\000\002\000\001\000\000\001\004\001\004\001\004\001\003\001\003\001\003\001\003\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\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\000\001\000\001\000\001\000\001\000\001\000\001\000\001\000\001\000\001\000\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\254\000\254\000\254\000\254\000\253\000\252\000\252\000\252\000\251\000\251\000\251\000\250\000\250\000\250\000\249\000\249\000\249\000\248\000\247\000\246\000\245\000\245\000\244\000\244\000\243\000\243\000\242\000\242\000\241\000\241\000\240\000\239\000\239\000\238\000\238\000\237\000\237\000\237\000\236\000\236\000\235\000\234\000\233\000\232\000\231\000\230\000\229\000\228\000\227\000\226\000\225\000\224\000\223\000\223\000\222\000\222\000\221\000\221\000\220\000\220\000\219\000\219\000\219\000\218\000\218\000\218\000\218\000\218\000\217\000\217\000\217\000\217\000\217\000\216\000\215\000\215\000\215\000\215\000\214\000\214\000\213\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\208\000\208\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\206\000\205\000\205\000\204\000\204\000\204\000\203\000\203\000\202\000\202\000\202\000\201\000\201\000\200\000\199\000\198\000\198\000\197\000\197\000\196\000\196\000\195\000\195\000\194\000\194\000\193\000\192\000\191\000\191\000\190\000\190\000\189\000\188\000\188\000\188\000\188\000\187\000\186\000\185\000\185\000\184\000\183\000\183\000\182\000\182\000\182\000\182\000\182\000\181\000\181\000\181\000\181\000\180\000\180\000\180\000\180\000\179\000\179\000\179\000\179\000\178\000\177\000\177\000\176\000\176\000\176\000\175\000\174\000\174\000\174\000\174\000\173\000\172\000\172\000\172\000\172\000\171\000\171\000\171\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\000\170\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\165\000\165\000\164\000\164\000\164\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\162\000\161\000\161\000\161\000\160\000\159\000\159\000\158\000\158\000\157\000\157\000\156\000\156\000\155\000\155\000\154\000\154\000\153\000\153\000\153\000\153\000\153\000\153\000\153\000\152\000\151\000\150\000\150\000\149\000\149\000\148\000\148\000\147\000\147\000\146\000\146\000\145\000\145\000\144\000\144\000\143\000\143\000\142\000\142\000\141\000\141\000\140\000\140\000\139\000\139\000\138\000\138\000\137\000\137\000\136\000\136\000\135\000\135\000\134\000\134\000\133\000\133\000\132\000\132\000\131\000\131\000\130\000\130\000\129\000\129\000\128\000\128\000\127\000\127\000~\000~\000}\000}\000|\000|\000{\000{\000z\000z\000y\000y\000x\000x\000w\000w\000v\000u\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000s\000r\000q\000p\000o\000n\000m\000l\000k\000j\000j\000j\000i\000i\000i\000h\000h\000h\000h\000g\000f\000e\000d\000c\000b\000a\000a\000a\000`\000`\000`\000_\000_\000^\000^\000^\000]\000]\000\\\000[\000[\000[\000Z\000Y\000Y\000X\000X\000W\000W\000V\000V\000U\000U\000T\000T\000S\000S\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000Q\000Q\000P\000P\000O\000O\000N\000N\000N\000N\000N\000M\000M\000L\000L\000L\000L\000K\000J\000I\000I\000I\000H\000H\000H\000G\000G\000G\000G\000G\000G\000F\000F\000F\000F\000F\000E\000E\000E\000E\000E\000E\000E\000D\000D\000D\000D\000D\000D\000D\000C\000C\000C\000C\000C\000C\000C\000B\000B\000B\000B\000B\000B\000B\000A\000A\000A\000A\000A\000A\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?\000?\000>\000>\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\0008\0007\0006\0005\0005\0005\0005\0005\0005\0005\0004\0004\0004\0004\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\031\000\031\000\031\000\030\000\030\000\029\000\028\000\027\000\027\000\027\000\027\000\026\000\026\000\026\000\025\000\025\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\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\017\000\017\000\016\000\016\000\016\000\016\000\016\000\015\000\015\000\014\000\013\000\013\000\013\000\013\000\013") + (16, "\000\012\000\011\000\n\000\t\000\008\000\007\000\006\000\005\000\004\000\003\000\002\000\001\000\000\001\006\001\006\001\006\001\005\001\005\001\005\001\005\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\004\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\003\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\001\002\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\000\001\000\001\000\001\000\000\255\000\254\000\254\000\254\000\253\000\253\000\253\000\252\000\252\000\252\000\251\000\251\000\251\000\250\000\249\000\248\000\247\000\247\000\246\000\246\000\245\000\245\000\244\000\244\000\243\000\243\000\242\000\241\000\241\000\240\000\240\000\239\000\239\000\239\000\238\000\238\000\237\000\236\000\235\000\234\000\233\000\232\000\231\000\230\000\229\000\228\000\227\000\226\000\225\000\225\000\224\000\224\000\223\000\223\000\222\000\222\000\221\000\221\000\221\000\220\000\220\000\220\000\220\000\220\000\219\000\219\000\219\000\219\000\219\000\218\000\217\000\217\000\217\000\217\000\216\000\216\000\215\000\215\000\214\000\214\000\213\000\213\000\213\000\212\000\212\000\212\000\211\000\211\000\211\000\211\000\210\000\210\000\210\000\210\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\209\000\208\000\207\000\207\000\206\000\206\000\206\000\205\000\205\000\204\000\204\000\204\000\203\000\203\000\202\000\202\000\202\000\201\000\200\000\199\000\199\000\198\000\198\000\197\000\197\000\196\000\196\000\195\000\195\000\194\000\193\000\192\000\192\000\191\000\191\000\190\000\189\000\189\000\189\000\189\000\188\000\187\000\186\000\186\000\185\000\184\000\184\000\183\000\183\000\183\000\183\000\183\000\182\000\182\000\182\000\182\000\181\000\181\000\181\000\181\000\180\000\180\000\180\000\180\000\179\000\178\000\178\000\177\000\177\000\177\000\176\000\175\000\175\000\175\000\175\000\174\000\173\000\173\000\173\000\173\000\172\000\172\000\172\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\000\171\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\166\000\166\000\165\000\165\000\165\000\165\000\164\000\164\000\164\000\164\000\164\000\163\000\162\000\162\000\162\000\161\000\160\000\160\000\159\000\159\000\158\000\158\000\157\000\157\000\156\000\156\000\155\000\155\000\154\000\154\000\154\000\154\000\154\000\154\000\154\000\153\000\152\000\151\000\151\000\150\000\150\000\149\000\149\000\148\000\148\000\147\000\147\000\146\000\146\000\145\000\145\000\144\000\144\000\143\000\143\000\142\000\142\000\141\000\141\000\140\000\140\000\139\000\139\000\138\000\138\000\137\000\137\000\136\000\136\000\135\000\135\000\134\000\134\000\133\000\133\000\132\000\132\000\131\000\131\000\130\000\130\000\129\000\129\000\128\000\128\000\127\000\127\000~\000~\000}\000}\000|\000|\000{\000{\000z\000z\000y\000y\000x\000x\000w\000w\000v\000u\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000t\000s\000r\000q\000p\000o\000n\000m\000l\000k\000j\000j\000j\000i\000i\000i\000h\000h\000h\000h\000g\000f\000e\000d\000c\000b\000a\000a\000a\000`\000`\000`\000_\000_\000^\000^\000^\000]\000]\000\\\000[\000[\000[\000Z\000Y\000Y\000X\000X\000W\000W\000V\000V\000U\000U\000T\000T\000S\000S\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000Q\000Q\000P\000P\000O\000O\000N\000N\000N\000N\000N\000M\000M\000L\000L\000L\000L\000K\000J\000I\000I\000I\000H\000H\000H\000G\000G\000G\000G\000G\000G\000F\000F\000F\000F\000F\000E\000E\000E\000E\000E\000E\000E\000D\000D\000D\000D\000D\000D\000D\000C\000C\000C\000C\000C\000C\000C\000B\000B\000B\000B\000B\000B\000B\000A\000A\000A\000A\000A\000A\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?\000?\000>\000>\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\0008\0007\0006\0005\0005\0005\0005\0005\0005\0005\0004\0004\0004\0004\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\031\000\031\000\031\000\030\000\030\000\029\000\028\000\027\000\027\000\027\000\027\000\026\000\026\000\026\000\025\000\025\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\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\017\000\017\000\016\000\016\000\016\000\016\000\016\000\015\000\015\000\014\000\013\000\013\000\013\000\013\000\013") let goto = - ((16, "\000\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\255\000\000\001!\012\230\000\000\000}\000_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\025\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000t\000\000\008\180\000}\000\236\000\000\000\000\000\000\000\000\000\000\007\228\000\n\022\238\000\000\000\000\000\000\024\132\000\000\002L\000\203\000\242\000\000\000\000\000\002\000\000\001\002\000\000\000\016'\n\000t%\188\000t\004\238%\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007n%\188\000\000\000\000\014\014\000\000\017\022\000\000\017\192\000\000\000\000\000\000\000\000\000\136\000\000!\234\000\000\000\000\002\130\000\000 \206\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \212\000\000\000\000,\030\000\0006\232\000\0007\012\000\00076\000\0007l\000\0007\182\000\0007\212\000\0007\224\000\0008\030\000\000\007\206\000\0005t\000\000\000\000\000\000\000\000\000\0008*\000\0008D\000\0008R\000\000'\218\000\000\000\000*J\000\000\000\000\000\173\000S\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\000v\000\000\000(\000\000\000\000%\028\000\0000\148\000\000\000\000\000\000\002\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\005\208%\218\000\000\005\242\000\000\015N\019\128\000\000\000\000\000\000\003\158\000\000\"j\000\000\000\0001\024\000\000\000\000\000\000\005.\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000/\252\000\0001\142\000\000\000\000\000\000\000\000\000\003\000\000\000\0001X\000\000\000\000\000\000\000\202\000`\000\000\000\000\000\000\000\000\000\000\000\000\006\016\000\000\025\230\000\000\026\254\000\000\027\186\000\000\029\192\000\000\031\166\000\000,J\000\000-H\000\0000h\000\00036\000\000\011\210\000\000\003j\000\0008b\000\0008\224\000\0008\246\000\000\000\000\000\000\000\000\000\000\000\1751\220\000\000\000s\000\000\000\000\002\008\012\250\000\000\002\026\000\000\000\000\000\000\000T\000\000\000\000\000\000&T\000\000\000\000\000\000\000\000\000\000&\170\000\000\000\000\000\000\000\000\000\000\000\000\000\158\000\000\000\000\000\000\0006\000\000\000\000\000\000\003n\000\000\000\000 B\000}\000\000\000\000\000\146\006\176\000\000\000\000\000\000\000\000\000\000\005\170\000\000-&\000\0000\136\000\000\000\000\005\236\000\000\000\000\000\000\000\000\000\000\000\000-\208\000\000\000\000\000\000\001\190\000\000\000\000\000\000\000\000\001\248#\018\000\000\003\222\000\000\000\000\000\014\004\018\000\000\000\000\000\000\000\000\025v\000\000\000\000\000\000\000\000\000\000\000\000\001~\013\146\000\000\015n\000\000\000\000\000\000\002\002\000\000\012&\001\164\000\000/\172\000\000\000\000\000\000\000\220\001\214\000\000\000\000\000\000\002\014\000\000\000\000\001\140\000\000\003\170\000\000\000\000\000\000\000\000\0001\002\n\000\000\002\214\000\000\000\000\000\000\000\000\000\000\000\0001\226\000\000&\222\000\0002&\000\000\000\000\002\164\000\000\005\228\000\000\000V\012\144'`\000\000\000\000\000\000\020\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\146'`\000\000\006\212\000\000\t6\011\152\000\000\000\000\000\000\006\012\000\000\"\192\000\000\000\0002f\000\000\000\000\000\000\006V\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0005\020\000\0005*\000\000\000\000\000\000\004\138\000\000\000\000\000\000\000\000\000\000\000\000\014\130\000\000\014\150\000\000\028L\000\000\0292\000\000\030v\000\000 P\000\000(.\000\000,6\000\0001P\000\0002\128\000\000\014Z\000\000\n\196\000\0008\206\000\0009\012\000\0009H\000\000'z\000\000\000\000\000\0002\166\000\000\000\000\000\000\000\021\000\0002\234\000\000\000\000\000\0003\004\000\000\000\000\001\228\000\000\024\014\000!\000\013\000\000\003\014\000\000\012\168\002`\006\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0003t\000\000'\174\028\026\006b\000\000\000\000\000\000\018(\000\000\019l\000\000\020\176\000\000(\000)`\000\166\004`\006x\000\000\000\000\000\000\004r\000\000\000\000\000\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0003\130\000\000\000\000\000\000\000\000\000\000#x\000\000)\158\000\000\000\000\000\000\000\000\000\000\000\000\013j\000\000\003B\000\000\000\000\000\000\000\000\0166\0048\000\0004\174\000\000\000\000\000\000\005v\000\000\000\000\021\244\006z\000\000\000z+n\000\000\000\000)\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005R)\026\000\000\019B\000\000\022\218&*\000\000\000\000\000\000\006\128\000\000#\142\000\000\000\0003\194\000\000\000\000\000\000\006\140\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000)\206\000\000%\152\000\000\000\0004\"\000\0004\146\000\000\000\000\025\242\t\214\000\000\000\000\0238\000\000\000\000\000\000\006\232\000\000$\n\000\000\000\0005b\000\000\000\000\000\000\007\146\000\000\023\230\000\0002\188\000\0008\028\000\0009n\000\0009r\000\0009|\000\0009\216\000\0009\246\000\0009\250\000\000:\030\000\000:d\000\000:r\000\000\000\000\000\000\000\000\000\000\000\000\np\000\000\016\250\000\000\"\218\001\130\000\000$h\000\000\000\000\000\000\000\000\000\000\000\0005\152\000\000\000\000\000\000\000\000\000\000\000\000\002\142\000\000\000\000\000\000\000\000\000\000\000\000\004n\000\000\000\00058\000\000\000\000\000\000\030N\000\000\000\000\002\242\000\000\000\000\000\0005\210\000\000\000\000\000\000\000\000+\226\000\000\000\000\000\000\000\000\004\164\007L\000\000,\"\000\000\000\000\000\000\000\000\024\208\0042\000\000\025R\000\000\000\000\n*\000\000-*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004v\000\000\000\0005\248\000\000\000\000\000\000-0\000\000\000\000\004R\000\000\000\000\013\236\000\000\026\020\000\000\000\000$4\000\000\000\000\000\000\003\026\000\000\000\0006^\000\000\000\000\000\000\000\000-\176\000\000\000\000\000\000\000\000\006*\015\178\000\000-\180\000\000\000\000\000\000\000\000\000\000\000\000\014\174\000\000\000\000\005\214\000\000\0150\000\000\003\026\000\000\000\000\005n+\154\000\000\005\226\000\000\000\000\000\000\000\000\004\138\000\000*\018\000\000\026\150\005(\027X\000\000\005P\000\000\015\242\000\000\016v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\152\027\218\0038\028\156\000\000\000\000\000\000\005~\000\000\0178\000\000\006\186\000\000\000\000\019\254\004L\029^\000\000\006(\000\000\017\186\029\224\000\000\000\000\018|\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\238\007h\000\000\007\"\000\000\000\000\000\000\000\000\007F\000\000\018\254\000\000\000\000\000\000 \2324\160\000\000\000\000\000\000 h\000\000\000\000\000\000\000\000\025 \004\188\000\000\000\000-\206\000\000\000\000\000\000\000\000\005\006\000\000\000\0006t\000\000\000\000\000\000-\212\000\000\000\000\003\130\000\000\000\000.\194\000\000\000\000\008*\005f\000\000\000\000.\218\000\000\000\000\007v!X\000\000\005z\000\000\000\000.\224\000\000\000\000\000\000\000\000\000\000\000\000\005\204\000\000\000\0006|\000\000\000\000\000\000/\134\000\000\000\000\000\000\000\000\000\000%\002\000\000\000\000\000\000\002\254\000\000\000\000\000\000/\174\000\000\000\000\008\198\006\136\000\000\000\000/\188\000\000\000\000\007\174\000\000\000\000\000\000\000\000\004\138\002\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\000\000\019\192\000\000\000\000\000\0004\222\000\000\0082\000\000\000\000\000\000\004 \000\000\000\000\006^\020B\000\000\021\004\000\000\000\000\000\000\006\140\000\000\011\160\006\196\012\136\000\000\015\024\000\000\000\000\000\000\006\208\000\000*\164\007x+(\000\000+\160\000\000\000\000\000\000\007\156\000\000\017\162\007\156\000\000\000\000!\218\n*\007\168#\192\000\000(\230\000\000\000\000\000\000\007\202\000\000\020*\008\140\000\000\000\000\000\000\003\012\000\000\000\000\000\000\000\000\000\000\003\164\000\000\000\000\004H\000\000\008$\000\000\000\000\000\000\004z\000\000\000\000\000\000\000\000\000\000\0007\000\000\000\167\004\152\000@\000\000\000\000\000h\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\238\002\154\000\000\000\000\000K\000\000\000\000\000\000\011\240\000\000\000\000\0134\014x\000\000\000\000\000\000\000\000\015H\016>\001.\000\000\016\138\000\000\000\000\000\000\000\000\000\000\000\000\007\194\000\000\000\000\011>\000\000\000\000\004\178\000\000\000\000\011x\000\000\000\000\004\210\000\000\003D\005n\002\156\000\000\000\000\001\144\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\008\018T\000\000\000\000\000\000\000\000\017\146\000\000\000\000\020\026\000\000\000\000\000\000\018f\000\000\000\000\n\194\018\210\005\252\000\000\021\176\000\000\000\000\000\000\000\000\000\000\000\000\000;\000\000\007\030\004&\000P\000\000\000\000\000\000\000\000\003\146\000\000\000\000\000\000\000\000\000\000\000\000\004\132\000\000\000\000\000\007\000\000\007(\006\004\003L\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\174\000\000\000\000\023\226\022\018\000\000\000\000\000\000\000\000\000\026\000\000\004z\000\000\0206\000\000\000\000\000\000\000\000\000\000\000\000\000\011\021\\\000\000\000\000\022\160\000\000\000\000\000\000\000\000\008\246\000\000\022\212\000\000\000\000\000\000\000\000\0003\000\000\000\000\000\000\000\214\000\000\000\000\001\202\000\000\000\000\000\000\000\000\000\000\000\000\000\00006\006x\000\000\000\000\000\000\026\212\000\000\000\000\008\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\160\000\000\000\000\000\000\000\000\000\000\000\152\008\188\000}\017\024\030$\005z\000\000\000\000\004~\008\n\008@\008B\000\000\000\000\000\000\000\000\000\000\000\000\003T\021\134\000\000\030\162\008$\000\000\000\000\008\224\000\000\022H\000\000\nJ\000\000\000\000\004T\022\202\000\000\031$\000\000\006\254\031\230\000\000\000\000\000\000\015t\004~\000\000\006\148\000\000\000\000\000\000\007\"\000\000\t&\000\000\005\140\030h\000\000\000\000\000\000\000\000\005\170\000\000\005\236\000\000\007\228\000\000\000\000\014t\000\000\000\000\000\000\000\000\008\236\000\000\000\000\004~\008\232\000\000\023\140\000\000\003\026\006R\000\000\000\000\000\000\000\000\000\000\001\212\000\000\000\000\000\000\000\000\000\0000\212\008>\000\000\000}\000\000\000\000\000\000\000\000\000\000\001\220\000\000\t\182\004f\n\226\000\000\002\220\011d\000\000\t\026\000\000\003`\000\000\003\228\000\000\004`\000\000\000\000\000\000\000\000\000\000\008\156\000\000\004\228\000\000\tj\000\000\005h\000\000\003\026\007\002\000\000\001\250\000\000\007\148\006\160\000\000\002\004\000\000\008\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\008Z\000\000\008\192\000\000\000\000\000\000\000\000\000\000\006\194\000\000\000\000\006\224\006D\008h\000\000\008v\000\000\000\000\006\018\0024\000\000\007\190\000\000\000\000\000\000\000\000\008\142\000\000\000\000\000\000\000\000\000\000\000\000\008h\008V\008\186\008\224\008|\008\186\000\000\000\000\008n\008\190\008\240\008\138\008\200\000\000\000\000\td\000\000\000\000\000\000\000\000\t\148\000\000\000\000"), (16, "\001\200\001\223\004r\002!\002\"\004\127\000>\002!\002\"\004P\005\151\004g\004\206\005\152\000>\001%\000\n\000h\002m\003n\003V\001<\004}\004t\000\210\000>\0016\000\017\004e\004\204\004\207\004t\004h\004t\004\222\005\019\004\225\000>\004s\000\210\000\t\000\231\000\016\000>\003!\001%\001\202\001?\000*\001'\001\203\004\223\004\222\004\223\004\226\004t\004\226\004t\000h\001\200\002\014\000j\000}\000\167\005\156\000*\000k\001t\000j\004\223\000l\000\212\004\226\004t\000h\000\213\004k\002\143\000q\001&\002\164\004u\004\018\000j\005\003\004\211\000\212\0009\000>\004u\000\213\004u\001\200\001\223\000u\003\157\004n\001\228\005_\001 \004\212\000\226\000j\000j\005`\001\202\000>\000k\0008\001\203\005a\000l\003 \004u\005\006\004u\000\226\000\210\000j\000\233\004\019\000j\0050\000k\002$\002\145\005\021\000l\000*\002\146\000\247\004u\004\251\000*\002\\\000u\003!\000h\001\202\000\005\000>\000q\001\203\000*\001\216\000\210\001\162\000\233\000\176\002a\004l\000u\001@\002b\000\164\001D\003(\000+\001\217\003\159\003|\000j\000\008\000\t\000\212\000\164\000\165\003)\000\213\000\178\004l\003j\001\030\001 \001x\000v\001E\000\164\000\177\000\250\005c\000j\000\227\000\164\000\165\0052\000k\002f\0053\000j\000l\003W\000\212\003v\000\226\000\248\000\213\000\227\003<\000w\001=\005d\003\141\001\216\003N\001\232\0057\000\016\004\213\002\143\004\142\004t\002\168\004\254\000u\000\174\000v\001\217\001g\000\238\005\t\002\159\000\226\005\023\005\024\001\233\002\\\001A\000\164\000\165\001\234\004\254\000v\000\174\001\235\002\160\001\216\000n\004\255\001\236\000w\002a\002H\004\170\000\248\002b\000\164\001D\003(\005f\001\217\001\"\002H\002[\001\200\001\223\000w\002\145\005g\005\129\004\168\002\146\004o\005\130\0050\000\232\005\157\0008\000>\004u\000j\004\216\005a\005\158\003 \000\227\001(\002J\000\174\002f\001\152\000\150\000>\0037\005\132\001n\0010\002K\002L\002N\003<\004\013\004\016\000>\005\134\000v\003N\001\232\003!\000\017\001\202\000\249\000y\000\227\001\203\005\236\000\151\005\142\005\143\005\176\000\152\001h\000E\005\237\000\149\0017\000{\001\233\000*\000w\001\200\001\223\001\234\000\251\001\146\005\224\001\235\001\154\005\202\000\241\001\159\001\236\001@\001\133\000>\005\028\005\029\000h\002m\003n\003V\000s\004\168\000\252\000\150\001\200\001\220\001\153\000\253\001\135\001\161\000\251\000\254\002\159\000*\005!\002\229\000\255\005\177\0009\005\147\004W\002\187\001+\003!\000y\001\202\002\160\001i\000\151\001\203\000\252\001+\000\152\002\245\004|\000\253\004\167\001\150\000{\000\254\000j\001\200\001\223\001\139\000\255\000k\000*\002\\\000j\000l\001\202\004}\004t\004\168\001\203\000>\001-\001\216\001\136\005a\005\163\003V\002a\002!\002\"\001,\002b\000\164\001D\003(\005\179\001\217\0050\000u\001\135\003}\001\228\0050\001 \005g\005\129\000\164\001D\002u\005\181\003!\000\187\001\202\002\232\002!\002\"\001\203\000\164\000\165\001F\002\190\003\007\005\245\002!\002\"\002f\005\173\003\007\002u\0037\005\183\003\130\001\200\001\223\002\191\004u\003<\000\210\002\\\000\231\005\185\003\007\003N\001\232\005\209\001h\000>\000F\001\216\004\167\005a\005\163\003V\002a\001p\001w\001s\002b\000\164\001D\003(\004\014\001\217\001\233\003\127\001(\004\168\000\174\001\234\004\027\001+\003)\001\235\001\216\001\156\003j\003!\001\236\001\202\000v\000F\000j\001\203\000*\000\212\004\016\004\215\001\217\000\213\004\174\004U\002f\005\168\003\007\001B\003W\001\163\003v\001\200\001\223\002\\\004\212\003<\000w\001-\002#\003\141\000*\003N\001\232\001\216\004z\000>\001\158\000\226\002a\005a\005\163\003V\002b\000\164\001D\003(\005\169\001\217\004\175\004V\002\246\000x\001\233\000F\002i\005g\005\129\001\234\003\008\000F\002d\001\235\000*\005J\003C\003!\001\236\001\202\004\128\003\029\004\171\001\203\000y\000F\002!\002\"\002f\000\161\003C\003\030\003W\005\170\005\171\001\200\001\223\0036\000{\003<\000*\002\\\004\029\003A\003\143\003N\001\232\003\030\003\132\000>\004\212\001\216\003\013\005a\005\163\003V\002a\005\160\003\247\000j\002b\000\164\001D\003(\005\169\001\217\001\233\000F\005B\003\017\000\227\001\234\003H\005g\005\129\001\235\004\222\000F\002d\003!\001\236\001\202\003\008\000>\004\213\001\203\000*\004\\\000\017\003L\000*\000\215\004a\004\223\002f\005\172\004\226\004t\003W\005\174\005\171\001\200\001\223\004W\003\153\003<\000\210\002\\\000\233\003A\004\229\003N\001\232\003\020\001I\000>\004\163\001\216\001\023\005a\005\163\003V\002a\000F\003\203\000*\002b\000\164\001D\003(\005\169\001\217\001\233\004\161\004\030\004\164\004t\001\234\000\252\005g\005\129\001\235\001%\005X\002d\003!\001\236\001\202\0009\000F\000j\001\203\000\255\000\212\003p\004u\002\143\000\213\004\218\002\163\002f\005\180\000*\002E\003W\004q\005\171\001\200\001\223\002\\\001q\003<\002G\002o\003p\003A\001\231\003N\001\232\001\216\000\238\000>\000*\000\226\002a\005a\005\163\003V\002b\000\164\001D\003(\005\169\001\217\004u\000F\001u\003\130\001\233\000F\000j\005g\005\129\001\234\002\145\002u\002d\001\235\002\146\004\157\000*\003!\001\236\001\202\004\173\005F\002F\001\203\000*\000\210\000*\000\230\002f\000\164\000\177\002F\003W\005\184\005\171\001\200\001\223\003\\\004\029\003<\000F\002\\\000\210\003A\000\229\003N\001\232\003\030\002\252\000>\000*\001\216\003,\002m\003n\003V\002a\000\210\003e\000\231\002b\000\164\001D\003(\005\169\001\217\001\233\000*\004\234\000j\000\227\001\234\000\212\005g\005\129\001\235\000\213\000F\002d\003!\001\236\001\202\000\239\000*\000>\001\203\000j\003\185\003\143\000\212\004\197\004t\003g\000\213\002f\004\231\000\241\000\224\003W\000*\005\171\000j\000\226\003x\000\212\003<\002\159\002\\\000\213\003A\002\143\003N\001\232\002\168\003O\005=\003e\001\216\000\251\000\226\002\160\005u\002a\003s\003\193\000F\002b\000\164\001D\003(\005\169\001\217\001\233\000F\000\226\000F\000*\001\234\000\252\005g\005\129\001\235\000*\000\253\002d\003\135\001\236\000\254\003\146\004u\003f\000>\000\255\000*\002[\001\200\001\219\000*\002\145\001b\002f\000*\002\146\000*\003W\005\140\005\171\001\200\001\223\002\\\005\225\003<\003\210\002!\002\"\003A\000F\003N\001\232\001\216\002v\000>\003\219\000\227\002a\002m\003n\003V\002b\000\164\001D\003(\001^\001\217\004\022\003|\005\222\002\247\001\233\000j\000\227\001\202\003)\001\234\001R\001\203\002d\001\235\001\205\000*\003\138\003!\001\236\001\202\005v\000\227\005\187\001\203\001S\004%\005-\003\168\002f\003\229\000\164\000\177\003W\003\138\003v\001\200\001\223\003\030\000h\003<\005e\004'\000\193\003A\000j\003N\001\232\005\234\004(\000>\003\140\001\214\002u\002m\003n\003V\002\143\0025\003\162\002\168\002\159\002\219\002\240\002\222\004'\000*\001\233\003\139\002D\002\187\004\219\001\234\002\148\004\232\002\160\001\235\000F\004/\002\157\003!\001\236\001\202\000j\0042\003\162\001\203\000h\000k\005.\000\252\000q\000l\003\164\0041\000>\002\225\005]\000\164\001D\0041\000j\005\191\005.\001\001\002\145\001\216\004\220\002\\\002\146\004\233\001T\000>\004\151\005\235\001|\000u\000>\001\216\003\163\001\217\005\210\005\215\002a\003\254\002\184\004\003\002b\000\164\001D\003(\000j\001\217\003z\003|\005B\000k\001\200\001\223\005N\000l\003)\000E\001\\\002\190\002d\001]\000>\000\174\003\030\000\146\000>\004d\005\216\004\003\002m\003n\003V\002\191\005i\004\005\002f\005B\005B\000u\003W\0049\003v\005\001\004e\002\\\005\202\003<\004h\004t\000F\003A\003\209\003N\001\232\001\216\003!\004;\001\202\004<\002a\004?\001\203\004\004\002b\000\164\001D\003(\004H\001\217\003\161\003|\000v\005\221\001\233\004;\002\159\0041\003)\001\234\005\220\005\011\002d\001\235\004J\004K\005\202\000\210\001\236\000\233\002\160\000>\000@\001~\000C\000>\000w\003\021\002f\005;\000>\004J\003W\005w\003v\001\200\001\223\004u\005Q\003<\000\164\000\165\005\131\003A\003\025\003N\001\232\005*\003\030\000>\000v\000E\003\030\002m\003n\003V\005\230\000\164\001D\005\149\003\253\000j\000\164\000\165\000\212\004\203\001\233\005\202\000\213\000\149\001F\001\234\001\200\001\218\000w\001\235\002\\\005\160\000>\003!\001\236\001\202\004\204\004\207\004t\001\203\001\216\005E\004\152\002\190\000\174\002a\000\164\000\177\000\226\002b\000\164\001D\003(\000\150\001\217\004\026\003|\002\193\004\155\001p\005\178\001s\005\203\003)\004\254\004N\000\174\002d\005D\005C\000j\005\160\001\202\005\166\000y\005.\001\203\005\240\000\151\005\247\005v\0041\000\152\002f\005\253\005\232\005x\003W\000{\003v\001\200\001\223\005\238\005\254\003<\005\241\004u\004v\003A\005\239\003N\001\232\005\205\005\248\000>\005\242\002\143\005\243\005a\002\168\003 \005\246\005\249\005\182\005\250\000\164\001D\006\002\000\000\000\164\005<\001\233\005.\002\\\000\164\000\177\001\234\000\000\001F\000\227\001\235\005H\005?\001\216\003!\001\236\001\202\000\000\002a\001m\001\203\000\000\002b\000\164\001D\003(\000\000\001\217\005\127\003|\002[\000\000\005\175\005\207\002\145\005(\003)\000\000\002\146\000\000\002d\000\000\000\000\001p\002\143\001s\005\234\002\168\000\000\000\000\001\216\000\000\000\164\001D\005\234\000\000\002f\000\251\000\000\002u\003W\000\000\003v\002\143\001\217\005p\002\168\003<\005\235\000\000\005\235\003A\000*\003N\001\232\000\000\000\000\000\252\000\000\000\000\000\000\000\000\000\253\000\000\000\000\005\016\000\254\000\000\002[\000\000\000\000\000\255\002\145\005{\001\233\005|\002\146\005s\000\000\001\234\005t\000\000\000\174\001\235\002\\\001\200\001\221\002[\001\236\000\000\000\000\002\145\000\000\000\000\001\216\002\146\000\000\000\000\000\000\002a\001\200\001\223\000\000\002b\000\164\001D\003(\005\162\001\217\004\203\002\159\002\219\002\220\002\222\000>\000\000\005g\005\129\005a\002\187\003 \005\165\000\000\000\000\002\160\000\000\004\204\004\207\004t\000j\000\000\001\202\000\000\000\000\000\000\001\203\000\000\002f\000\000\000\000\000\000\0037\005\167\000\000\003!\002\225\001\202\000\000\003<\000\000\001\203\000\000\003A\000\000\003N\001\232\000\000\004\221\000\000\000\000\000>\000F\005\161\000\000\000\000\001\200\001\223\000\000\002\159\002\219\005U\002\222\000\000\000\000\000\000\001\233\000\000\002\187\004\154\000>\001\234\000\000\002\160\005a\001\235\003 \004u\002\159\002\224\001\236\002\222\001\200\001\201\002\190\000\000\000\210\002\187\000\233\000\000\004\160\000\000\002\160\000\000\002\225\000\000\000\000\000\000\002\191\003\"\003!\000\000\001\202\000\000\000\000\000\000\001\203\004\161\000\000\004\164\004t\000h\000\000\002\225\000\000\000q\003&\000\000\005\164\000\000\001\216\000\000\000\000\000\000\000\000\002\\\000j\000\000\001\202\000\000\000j\000\000\001\203\000\212\001\217\001\216\000\000\000\213\000\000\000\000\002a\000\000\002\190\000\000\002b\000\164\001D\003(\005\162\001\217\000\000\000\000\004|\001\200\001\223\000j\002\191\005g\005\129\000\000\000k\002\190\005\165\000\226\000l\000\000\000\000\000>\004u\004}\004t\002m\000\000\003 \001\021\002\191\000\000\000\000\002f\000\000\000\000\002\004\0037\005\167\000\000\000\000\004\236\000\000\000u\003<\002\\\000\164\000\165\003A\000\000\003N\001\232\003!\000\000\001\202\001\216\001\233\000\210\001\203\000\233\002a\001\200\001\223\000\000\002b\000\164\001D\003(\005\162\001\217\001\236\001\233\000\000\001\200\001\223\000\000\001\234\005g\005\129\000\000\001\235\001\216\005\165\004u\004 \001\236\000\000\000>\003\156\000\000\000\000\002m\000\000\003 \004\152\001\217\000\174\000\000\002f\000\227\000\000\000j\0037\005\167\000\212\000j\000\000\001\202\000\213\003<\000\000\001\203\000\000\003A\000\000\003N\001\232\003!\000>\001\202\000\000\000\000\000\000\001\203\000v\004*\000\000\000\000\000>\000\000\000\000\004\176\000\000\000\000\000\226\000\000\001\233\000\000\000\000\000\000\000\000\001\234\002\\\000\149\000\000\001\235\000\000\000\251\000w\003\154\001\236\000\000\001\216\003\156\000\000\000\000\000\000\002a\001\228\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\252\000\000\004|\001\200\001\223\000\253\000\150\000\000\003)\000\254\002k\000\000\003\145\000\000\000\255\000\000\000\000\000>\000\000\004}\004t\002m\003\027\003 \000\000\000\000\004\131\000y\002f\000\000\000\000\000\151\0037\003\147\000\000\000\152\000\000\000>\001\216\003<\002\\\000{\000\000\003A\000\000\003N\001\232\003!\000\227\001\202\001\216\000\000\001\217\001\203\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\001\230\001\233\000\000\001\200\001\223\000\000\001\234\000\000\003)\004,\001\235\0039\003\145\004u\000\000\001\236\000\000\000>\000\000\000\000\000h\002m\003:\003V\000\190\000\000\000\164\000\165\002f\000\000\000\000\000\251\0037\003\147\001\232\000\000\000\164\000\165\000\000\003<\000\000\000\000\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\000\000\000\252\000\000\001\203\001\233\000\000\000\253\000\000\000h\001\234\000\254\000\000\000q\001\235\000j\000\255\001\233\000\000\001\236\000k\000\000\001\234\002\\\000l\001\128\001\235\000\174\000\000\001\200\001\221\001\236\000\000\001\216\000\000\001*\000>\000\174\002a\001\200\001\221\000\000\002b\000\164\001D\003(\000\000\001\217\000u\000\000\004|\001\200\001\223\000j\000\000\000\000\003)\000\000\000k\003Y\003[\000\000\000l\000\164\000\165\000>\000\000\004}\004t\002m\003:\003V\002\002\000j\004\137\001\202\002f\000\000\000\000\001\203\0037\003]\000\000\000j\000\000\001\202\000u\003<\002\\\001\203\005x\003_\000\000\003N\001\232\003!\000\000\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\210\000\000\000\233\002b\000\164\001D\003(\001\130\001\217\000\174\001\233\000\000\001\200\001\223\000\000\001\234\004\160\003)\000\000\001\235\003^\002d\004u\000\000\001\236\000v\000>\000\210\000\000\000\228\002m\003:\003V\004\161\000\000\004\164\004t\002f\000\000\000\000\000\000\003W\000\000\003X\000j\000\000\000\000\000\212\003<\000w\004|\000\213\003A\000\000\003N\001\232\003!\000>\001\202\000\000\000>\000\000\001\203\000v\005;\000\000\000\000\004}\004t\001\216\000\000\000j\000\164\001D\000\212\001\233\000\000\000\226\000\213\001\216\001\234\002\\\000\149\001\217\001\235\005p\000\000\000w\000\000\001\236\002t\001\216\000\000\001\217\004u\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\226\001\217\000\000\000\000\002u\001\200\001\223\000\000\000\150\005z\003)\000\000\000\000\005s\002d\000\000\005t\000*\000\174\000>\000\000\000\000\004u\002m\003n\003V\000\000\000\000\004\135\000y\002f\000\000\000\000\000\151\003W\000\000\003X\000\152\000\000\000\000\000\000\003<\002\\\000{\000\000\003A\001\233\003N\001\232\003!\000\000\001\202\001\216\000>\000\227\001\203\001\233\002a\000\000\000\000\001\238\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\004|\001\240\001\200\001\223\001\234\000\000\003)\000\000\001\235\000\000\002d\004.\000\227\001\236\002t\000\000\000>\004}\004t\000\000\002m\003n\003V\000\000\000\164\000\165\002f\000\164\001D\004\182\003W\000\000\003X\000\251\000\000\000\000\000\000\003<\004|\005>\005b\003A\000\000\003N\001\232\000\000\003!\000\000\001\202\000\000\000\000\000\000\001\203\000\252\000\000\004}\004t\000F\000\253\000\000\000\000\000\000\000\254\004\148\001\233\000\000\000\000\000\255\002\143\001\234\002\\\002\168\001\132\001\235\000\174\003\005\004u\003\019\001\236\000\000\001\216\000\000\000h\000\000\000\000\002a\000\189\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\003u\000>\000\000\001\200\001\223\005;\000\000\003)\003P\000\000\000\000\002d\000\000\000\000\000\000\000\000\002[\000>\004u\000\000\002\145\002m\003n\003V\002\146\003T\000\000\002f\000\164\001D\000j\003W\000\000\003v\000\000\000k\000\000\000\000\003<\000l\002\\\002\249\003A\000\000\003N\001\232\000\000\003!\000\000\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\210\000\000\000\233\002b\000\164\001D\003(\000u\001\217\001\233\003w\000\000\001\200\001\223\001\234\000h\004\160\003)\001\235\000i\003\005\002d\003\019\001\236\000\000\000\000\000>\000\000\000\000\004\222\002m\003\148\003V\004\161\004\146\004\164\004t\002f\000\000\000\000\000\000\003W\000\000\003v\000j\000\000\004\223\000\212\003<\004\226\004t\000\213\003A\000\000\003N\001\232\003!\000\000\001\202\000j\002\159\000\000\001\203\002\226\000k\000\000\000\000\000h\000l\002\187\000\000\000q\004\144\000\000\002\160\001\233\000\000\000\226\000\000\000\000\001\234\002\\\000\000\000\000\001\235\000\164\005<\000\000\000v\001\236\003\150\001\216\000u\000\000\004u\002\228\002a\005G\005?\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\003\137\004u\001\200\001\223\000j\000w\000\000\003)\004|\000k\000\000\002d\000\000\000l\000\000\000\000\000>\004|\000\000\000\000\002m\003\148\003V\0029\000\000\004}\004t\002f\000\000\000\000\002\234\003W\000\000\003v\004}\004t\002\190\000u\003<\002\\\000\000\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\001\216\002\191\000\227\001\203\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000v\001\200\001\223\000\000\001\234\004|\003)\000\000\001\235\003\170\002d\004>\000\000\001\236\003\152\000>\000\000\000\000\004u\002m\003:\003V\004}\004t\000w\000\000\002f\004u\000\000\004\185\003W\000\000\003\151\000\251\000\000\002\143\000\000\003<\002\162\000\000\000\000\003A\004\239\003N\001\232\003!\000\000\001\202\000\000\000\000\000\000\001\203\000v\000\252\000\000\000\000\000h\000\000\000\253\000\000\000q\000\000\000\254\000\000\001\233\000\000\000\210\000\255\000\211\001\234\002\\\000\149\000\000\001\235\000\000\000\000\000w\000\000\001\236\000j\001\216\004u\000\000\002\145\000\000\002a\000\000\002\146\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\001\200\001\223\000j\000\150\000\000\003)\000\000\000k\000\000\002d\000\000\000l\000j\000\000\000>\000\212\000\000\000\000\002m\000\213\003 \002;\000\000\000\000\000y\002f\000\000\000\000\000\151\003W\004\180\003\151\000\152\000\000\000\000\000u\003<\002\\\000{\004\192\003A\000\000\003N\001\232\003!\000\226\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\210\000\000\000\233\002b\000\164\001D\003(\000\000\001\217\002u\001\233\000\000\001\200\001\223\000\000\001\234\004\160\003)\000\000\001\235\000\000\002d\003\007\004\020\001\236\000\000\000>\003\156\002\159\004\222\002m\000\000\003 \004\161\000\000\004\164\004t\002f\000\000\000\000\004\201\003W\002\160\003X\000j\000\000\004\223\000\212\003<\004\226\004t\000\213\003A\000\000\003N\001\232\003!\000\000\001\202\000\000\000\000\000\000\001\203\000v\000\000\001+\000\000\000h\000\000\001\200\001\221\000q\000\000\000\227\000\000\001\233\000\000\000\226\000\000\000\000\001\234\002\\\000\149\000\000\001\235\000\000\000\000\000w\004\"\001\236\000\000\001\216\003\156\000\000\004u\000\000\002a\000\000\000\000\001-\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\004u\001\200\001\223\000j\000\150\000j\003)\001\202\000k\000\000\003\145\001\203\000l\000\000\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \002=\000F\000\000\000y\002f\000\000\003C\000\151\0037\003\147\000\000\000\152\000\000\000\000\000u\003<\002\\\000{\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\001\216\000\000\000\227\001\203\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000\000\001\200\001\223\004\222\001\234\003H\003)\000\000\001\235\000\000\003\145\004M\004$\001\236\000\000\000>\003\156\000\000\000\000\002m\004\223\003 \003L\004\226\004t\000\000\002f\000\000\000\000\004\188\0037\003\147\000\000\000\251\000\000\000\000\000\000\003<\000\000\000\000\001\216\003A\004\252\003N\001\232\003!\000\000\001\202\004|\000\000\000\000\001\203\000v\000\252\001\217\000\000\000h\000\000\000\253\000\000\000q\000\000\000\254\000\000\001\233\004}\004t\000\255\000\000\001\234\002\\\000\149\000\000\001\235\000\000\000\000\000w\005K\001\236\000\000\001\216\003\156\004u\000\000\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\004|\001\200\001\223\000j\000\150\000\000\003)\000\000\000k\005S\003\145\000\000\000l\000\000\000\000\000>\000\000\004}\004t\002m\003:\003V\000\000\000\000\001\222\000y\002f\004u\000\000\000\151\0037\003\147\000\000\000\152\000\000\000\000\000u\003<\002\\\000{\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000\000\001\200\001\223\004\222\001\234\000\000\003)\000\000\001\235\002\143\003\145\004u\002\161\001\236\000\000\000>\000\000\000\000\000\000\002m\004\223\003 \000\000\004\226\004t\000\000\002f\005\004\000\000\004\222\0037\003\147\000\000\000>\000@\000A\000C\003<\000\000\000\000\000\000\003A\002\242\003N\001\232\003!\004\223\001\202\000\000\004\226\004t\001\203\000v\000j\000\000\000\000\000h\002\145\000\000\000\000\000q\002\146\000\000\000E\001\233\000\000\000\000\000\000\000\000\001\234\002\\\002\182\004\199\001\235\000\000\000\000\000w\005Y\001\236\000\000\001\216\003\156\004u\000\000\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\001\200\001\223\000j\000\150\000\000\003)\000\000\000k\005\133\002d\004u\000l\000\000\000\000\000>\000\000\000\000\000\000\002m\003:\003V\000\000\000\000\004\243\000y\002f\000\000\000\000\000\151\003W\000\000\003X\000\152\000\000\000\000\000u\003<\002\\\000{\000\000\003A\000\000\003N\001\232\003!\002\143\001\202\001\216\002\168\000\000\001\203\000\000\002a\000\000\000\000\002\159\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\003\165\001\200\001\223\004\160\001\234\002\160\003)\000\000\001\235\000\000\003\145\000\164\001D\001\236\000\000\000>\000\000\000\000\000\000\002m\004\161\003V\004\164\004t\001F\000j\002f\005\007\000\000\002\145\0037\003\147\000\000\002\146\000\000\001m\000\000\003<\000\000\000\000\000\000\003A\002\180\003N\001\232\003!\000\000\001\202\000\000\000\000\000\000\001\203\000v\005\014\000\000\000\000\000\000\000\000\000\000\001p\000\000\001s\000\000\000\000\001\233\000\000\000\000\000\000\000\000\001\234\002\\\002\182\000\000\001\235\000>\000D\000w\000C\001\236\000\000\001\216\004u\000\000\000\000\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\001\200\001\223\000\000\000\150\000\000\003)\000E\000\000\000\000\002d\000\000\003Z\000\000\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \000\000\000\000\000\000\000y\002f\000\000\002\159\000\151\003W\000\000\003X\000\152\000\000\000\000\000\000\003<\002\\\000{\000\000\003A\002\160\003N\001\232\003!\000\000\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\000\000>\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000\000\001\200\001\223\000\000\001\234\000\000\003)\000\000\001\235\000\000\003\167\000\000\003\031\001\236\000\000\000>\000\000\000\000\000\000\002m\003\184\003 \000\000\000\000\000\000\000\000\002f\004\245\000\000\000\000\003W\000\000\003\169\000>\000@\001z\000C\003<\000\000\000\000\000\000\003A\000\000\003N\001\232\003!\002\190\001\202\000\000\000\000\000\000\001\203\000\164\001D\000\000\000\000\000\000\000\000\000\000\000\000\002\195\000\000\000\000\000E\001\233\001F\000\000\000\000\000\000\001\234\002\\\000\000\000\000\001\235\000\000\000\210\001m\000\231\001\236\000\000\001\216\002\143\000\000\000\000\002\168\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\001\200\001\223\001p\000\000\001s\003)\000\000\000\000\000\000\0035\000\000\003;\000\000\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \000j\000\000\000\000\000\212\002f\000\000\002[\000\213\0037\0038\002\145\000\164\001D\000\000\002\146\003<\002\\\000\000\000\000\003A\000\000\003N\001\232\003!\003\190\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\000\000\226\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000\000\001\200\001\223\000\000\001\234\000\000\003)\000\000\001\235\000\000\0035\000\164\001D\001\236\000\000\000>\003\202\000\000\003\208\002m\000\000\003 \000\000\000\000\001F\000\000\002f\000\000\000\000\000\000\0037\0038\000\210\000\000\000\233\001m\000\000\003<\000\000\000\000\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\210\000\000\000\231\000\000\000\000\000\000\001p\000\000\001s\005'\002\159\001\233\000\000\002\235\000\000\000\000\001\234\002\\\000\227\002\187\001\235\000\000\000\000\000j\002\160\001\236\000\212\001\216\000\000\000\000\000\213\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000j\001\200\001\223\000\212\000\000\000\000\003)\000\213\000\000\000\000\0035\000\000\000\226\000\000\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \000\000\000\000\000\000\000\000\002f\000\000\000\000\000\000\0037\0038\000\000\000\226\000\000\000\000\000\000\003<\002\\\000\000\000\000\003A\000\252\003N\001\232\003!\000\000\001\202\001\216\002\190\000\210\001\203\000\231\002a\000\000\000\000\001\003\002b\000\164\001D\003(\000\000\001\217\002\191\001\233\000\000\001\200\001\223\003y\001\234\000\000\003)\000\000\001\235\000\000\003r\000\000\000\000\001\236\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \000\000\000\000\000\000\000\000\002f\000\000\000\227\000j\0037\003t\000\212\001\200\001\223\000\000\000\213\003<\000\000\000\000\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\000\000\000\227\000\000\001\203\000\000\003b\005(\000\000\000\000\000\000\001\200\001\221\000\000\000\000\000\226\000\000\001\233\000\000\000\000\000\000\000\000\001\234\002\\\000\000\000\000\001\235\000\000\000\000\000\251\002[\001\236\001\202\001\216\000\000\000\000\001\203\000\000\002a\005+\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\252\000\000\001\200\001\223\003q\000\253\000j\003)\001\202\000\254\000\000\003r\001\203\000\000\000\255\000\000\000>\000\000\000\000\000\000\002m\000\252\003 \000\000\000\000\000\000\000\000\002f\000\000\000\000\003h\0037\003t\000\000\001\228\001\005\000\000\000\000\003<\002\\\000\000\000\000\003A\000\000\003N\001\232\003!\000\227\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000\000\000\000\003\133\000\000\001\234\002\\\003)\000\000\001\235\000\000\003\134\001\200\001\221\001\236\000\000\001\216\000\000\000\000\000\000\000\000\002a\000\000\000\000\000\000\002b\000\000\002f\000\000\000\000\001\217\0037\003\136\000\000\001\200\001\223\000\000\000\000\003<\000\000\000\000\001\216\003A\003j\003N\001\232\000\000\000\000\000>\000\000\000\252\000\000\002m\000\000\003 \001\217\000j\000\000\001\202\002f\000\000\000\000\001\203\000\000\001\007\001\233\000\000\000\000\000\000\000\000\001\234\002\\\000\000\000\000\001\235\000\000\000\000\001\232\003!\001\236\001\202\001\216\000\000\000\210\001\203\000\231\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000\000\001\200\001\223\003\131\001\234\000\000\003)\000\000\001\235\000\000\003r\000\000\000\000\001\236\000\000\000>\003\144\000\000\000\000\002m\000\000\003 \000\000\000\000\001\233\000\000\002f\000\000\000\000\000j\0037\003t\000\212\000\000\000\000\000\000\000\213\003<\001\242\000\000\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\000\000\000>\000\000\001\203\000\000\005;\000\000\000\000\000h\000\000\001\216\000\000\000q\000\000\000\226\000\000\001\233\000\000\000\000\000\000\000\000\001\234\002\\\000\000\001\217\001\235\000\000\000\000\001\200\001\221\001\236\000\000\001\216\003\149\000\000\000>\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\001\200\001\223\000j\000\000\000\000\003)\000\000\000k\000\000\003\145\005O\000l\000\000\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \000\000\000j\000\000\001\202\002f\000\000\000\000\001\203\0037\003\147\000\000\000\000\000\000\000\000\000u\003<\002\\\000\000\005o\003A\001\233\003N\001\232\003!\000\227\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\000\000\000\001\244\002b\000\164\001D\003(\000\000\001\217\000\000\001\233\000\000\001\200\001\223\000\000\001\234\000\000\003)\000\000\001\235\000\000\003\145\005[\000\000\001\236\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \000\000\000\000\000\000\000\000\002f\000\164\005<\000\000\0037\003\147\000\000\000\000\000\000\000\000\000\000\003<\000\000\005>\005?\003A\003\003\003N\001\232\003!\000\000\001\202\000\000\000\252\000\000\001\203\000v\000\000\000\000\000\000\000\000\000\000\001\216\000\000\000\000\000\164\001D\001\t\001\233\000\000\000\210\000\000\000\231\001\234\002\\\002\182\001\217\001\235\005p\000\000\000w\000\000\001\236\000\000\001\216\000\000\000\000\000\000\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\001\200\001\223\000\000\000\150\000\000\003)\000\000\000\000\005s\005P\005^\005t\000j\000\174\000>\000\212\000\000\000\000\002m\000\213\003 \000\000\000\000\000\000\000y\002f\000\000\000\000\000\151\0037\005R\000\000\000\152\000\000\000\000\000\000\003<\002\\\000{\000\000\003A\001\233\003N\001\232\003!\000\226\001\202\001\216\000\000\000\000\001\203\000\000\002a\001\200\001\221\001\246\002b\000\164\001D\003(\000>\001\217\000\000\001\233\000\000\001\200\001\223\000\000\001\234\000\000\003)\000\000\001\235\000\000\005P\000\000\000\000\001\236\000\000\000>\000\000\000\000\000\000\003\183\000\000\000\000\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\000\0037\005R\000\000\000j\000\000\001\202\000\000\003<\003\215\001\203\000\000\003A\000\000\003N\001\232\003\218\000\000\001\202\000\000\001Y\000\000\001\203\000h\000\000\000\000\000h\000s\000\000\000\000\000}\000\000\000\000\000\227\001S\001\233\001\200\001\223\003\224\000\000\001\234\002\\\000\000\000\000\001\235\000\000\000\000\000\000\000\000\001\236\000>\001\216\000\000\000\000\003\183\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\004\006\000j\000\000\001\228\000j\001 \000k\004\n\003)\000k\000l\000\000\005P\000l\003\218\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000\000\000\000\000\000\001\200\001\223\002f\000\000\000\000\000\000\0037\005R\000u\000\252\003\224\000u\001\216\003<\000>\000\164\001D\003A\003\183\003N\001\232\000\000\000\000\001\011\001\216\000\000\001\217\000\000\001T\000\000\000\000\000\000\000\000\000\000\000\164\001D\003\225\003\217\001\217\000\000\001\233\000\000\000\000\000\000\003\218\001\234\001\202\003\226\000\000\001\235\001\203\004\008\000\000\000\000\001\236\001_\000\000\001j\000\000\000\000\001\\\000\000\000\000\001]\000\000\000\174\003\224\000\000\000\000\000\000\000\000\000\000\000\000\000h\000\000\000\000\000\000\000q\003\240\000>\000\000\000\000\004\t\002m\003\252\001\232\000\000\000>\001\216\000v\000\000\000\000\000v\001\233\000\000\000\000\000\000\000\000\000\164\001D\003\225\000\000\001\217\000\000\000\000\001\233\000\000\001\248\000\000\004B\001\234\003\226\000\000\000w\001\235\003\238\000w\000j\000\000\001\236\000\000\000\000\000k\000\000\000\000\000\000\000l\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000h\000x\000\000\000\000\000q\003\240\000\000\001\216\000\000\003\245\000\000\003\252\001\232\000u\000>\000\000\000\000\000\164\001D\003\225\000\000\001\217\000y\000\000\000\000\000y\000\000\000z\000\000\000\000\003\226\000\000\001\233\000\000\003\238\000\000\000{\001\234\000\000\000~\000\000\001\235\000\000\000h\000j\000\000\001\236\000q\000\000\000k\000\000\000\000\000\000\000l\000\000\000\000\002\143\000>\000\000\002\168\000\000\003\240\000\000\000\000\000\000\003\245\000\000\003\252\001\232\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000\000\000\000\000\000\000\000\000\164\001D\003(\000\000\000\000\000j\001\233\000\000\000\164\000\165\000k\001\234\000v\003)\000l\001\235\000>\001o\002[\000C\001\236\000\000\002\145\000\000\000\000\000\000\002\146\000\000\000\168\000\169\000\171\000\172\000\000\000\000\000\000\000\000\000w\004C\000u\000\000\000\000\000\000\000\000\000\000\003<\000\000\000E\000\000\003A\000\000\003N\000\000\000\000\000h\000\000\000\000\000\173\000q\000\174\000\000\000\000\000\150\000\000\000\000\000h\000\000\000\000\000>\000q\000\000\000\000\000\000\000\164\000\165\000\000\000\000\000v\000\000\000>\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\151\000\000\000\000\000\000\000\152\000\000\000\168\000\217\000\171\000\172\000{\000j\000\179\000\000\000w\000\000\000k\000>\000\000\000\000\000l\002m\000j\000\000\000\000\000\000\000\000\000k\000\000\000\164\000\165\000l\002\159\000v\000\173\002\226\000\174\000\000\000\000\000\150\002\143\002\187\000\000\002\168\000u\000\000\002\160\004B\000\000\000\168\001\207\000\171\000\172\000\000\000\000\000u\000\000\000w\000\000\000\000\000y\000h\000\000\000\000\000\151\000q\000\000\002\228\000\152\000\000\000\164\001D\000\000\000\000\000{\000>\000\179\000\173\000\000\000\174\000\000\000\000\000\150\001F\002[\000\000\000\000\002\143\002\145\000\000\002\168\000\000\002\146\000\000\001m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000y\000\000\000j\000\000\000\151\000\000\002\233\000k\000\152\000\000\000\000\000l\002\190\000\000\000{\001p\000\179\001s\000\164\000\165\000\000\000\000\000v\000\000\000\000\000\000\002\191\000\000\002[\000\164\000\165\000\000\002\145\000v\000\000\000u\002\146\000\000\000\168\002^\000\171\000\172\000\000\000\000\000\000\000\000\000w\000\000\000\000\000\168\002\150\000\171\000\172\000\000\000\164\001D\003(\000w\000\000\000\000\000\000\000h\000\000\000\000\000\000\000q\000\173\003)\000\174\000\000\000\000\000\150\000\000\000\000\000h\000>\000\000\000\173\000q\000\174\000\000\002\159\000\150\000\000\002\186\000\000\000\000\000\000\000>\000\000\002\187\004E\000y\000\000\000\000\002\160\000\151\000\000\003<\000\000\000\152\000\000\003A\000y\003N\000j\000{\000\151\000\179\000\000\000k\000\152\000\164\000\165\000l\000\000\000v\000{\000j\000\179\000\000\000\000\000\000\000k\000\000\000\000\000\000\000l\002\159\000\000\000\000\002\226\000\168\003>\000\171\000\172\002\143\002\187\000u\002\168\000w\000\000\002\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000\000\000\000\000h\000\000\000\000\000\000\000q\000\000\000\173\000\000\000\174\002\228\002\190\000\150\000\000\000\000\000>\000h\000\000\000\000\000\000\000q\000\000\000\000\000\000\000\000\002\191\000\000\000j\000\000\000\000\000>\002\145\000\000\000y\000\000\002\146\000\000\000\151\000\000\000\000\000\000\000\152\000\000\000\000\000\000\000j\000\000\000{\000\000\000\179\000k\000\000\002\231\000\000\000l\000\000\002\143\000\000\002\190\002\144\000j\000\000\000\164\000\165\000\000\000k\000v\000\000\000\000\000l\000\000\000\000\002\191\000\000\000\000\000\164\000\165\000h\000u\000v\000\000\000q\000\168\003\242\000\171\000\172\000\000\000\000\000\000\000\000\000w\000>\000\000\000u\000\000\000\181\000\000\000\000\000\172\000\000\000j\000\000\000\000\000w\002\145\000\000\000\000\000\000\002\146\000\000\000\173\000\000\000\174\000\000\000\000\000\150\000\000\000\000\000\000\000\000\000h\000j\000\000\000\173\000q\000\174\000k\002\159\000\150\000\000\000l\000\000\000\000\000\000\000>\000\000\000y\000\000\000\000\000\000\000\151\002\160\000\000\000\000\000\152\000\000\001\200\001\223\000\000\000y\000{\000\000\000\179\000\151\000u\000\164\000\165\000\152\000\000\000v\000\000\000\000\000\000\000{\000j\000\179\002T\004\031\000h\000k\000\164\000\165\000q\000l\000v\000\000\000\000\000\000\000\191\000\000\000\000\000\000\000\000\000w\000\000\000\000\000\000\000\000\000\000\000\000\002[\000\000\001\202\000\194\000\000\000\000\001\203\000u\000w\000\000\002\159\000\000\000\000\001.\000\000\000\174\000\000\000\000\000\150\000\000\002\169\000h\000j\000\000\002\160\000q\000\000\000k\000\196\000\000\000\174\000l\000\000\000\150\000h\000>\000\000\000\000\000q\000y\000\000\000\164\000\165\000\151\000\000\000v\000\000\000\152\000>\000\000\000\000\000\000\000\000\000{\000y\000u\000\000\000\000\000\151\000\000\001\200\001\223\000\152\000\000\000\194\000j\000\000\000\000\000{\000w\000k\000\000\000\000\000\000\000l\000\000\0011\000\000\000j\000\000\002T\003k\000h\000k\000\164\000\165\000s\000l\000v\0014\002\\\000\174\000\000\000\000\000\150\000\000\000\000\000\000\000u\000\000\001\216\001\200\001\223\000\000\002[\002a\001\202\000\191\000\000\002b\001\203\000u\000w\000\000\001\217\000y\000\000\000\000\000\000\000\151\000\000\002T\003a\000\152\001\200\001\221\000j\002d\000\000\000{\000\000\000k\001:\000\000\000\174\000l\000v\000\150\000\000\000\000\000\000\000\000\000\000\002f\000\000\002[\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000\000\001\"\000\000\000\000\000y\000u\000w\001\232\000\151\000\000\000\000\000\000\000\152\000\000\000j\000\000\001\202\000\000\000{\000\000\001\203\000\164\000\165\000\000\000\000\000v\000\000\001\233\000\000\000\000\000\000\000\150\001\234\000\000\000\164\000\165\001\235\000\000\000v\000\000\002\\\001\236\000\000\000\000\001\183\000\000\000\000\000\000\000\000\000w\001\216\000\000\000y\000\000\000\000\002a\000\151\001\183\000\000\002b\000\152\000\000\000w\000\000\001\217\000\000\000{\000\000\000\000\001\185\000\000\000\174\000\000\000\000\000\150\000\000\000>\002d\000\000\000\000\002m\002\\\002\012\000\000\000\174\000\000\000v\000\150\000h\000\000\000\000\001\216\000q\002f\000\000\000y\002a\000\000\000\000\000\151\002b\000\000\000>\000\152\000\000\001\217\004B\000\000\000y\000{\000w\001\232\000\151\000\000\001\216\000\000\000\152\000\000\002d\000\000\000\000\000\000\000{\001\200\001\223\000\000\000\000\000\000\001\217\000\000\000\000\001\233\000j\000\000\002f\000x\001\234\000k\000\000\000\000\001\235\000l\000\000\002T\002U\001\236\000\000\000\000\000\000\000\000\000\000\000\000\001\232\000\000\001\200\001\223\000y\000\000\000\000\000\000\000\000\000\160\000\000\000\000\000\000\000u\000\000\002[\000\000\001\202\000{\000\000\001\233\001\203\002T\002`\000\000\001\234\000h\000\000\000\000\001\235\000q\000\000\000\000\000\000\001\236\000\000\000\000\000\000\000\000\000\000\000>\000\000\000\000\001\233\000\000\000\000\002[\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000\000\000\000\001\250\000\000\000\000\001\200\001\223\000\000\000\000\000\164\001D\003(\000\000\000\000\000\000\000j\000\000\000\000\000\000\000\000\000k\000\000\003)\000\000\000l\002T\003m\000\000\000\000\000\000\000\000\000\000\000\000\000h\000\000\000\164\000\165\000s\000\000\000v\000\000\000\000\000\000\000\000\000\000\000\000\004G\000\000\000u\002[\002\\\001\202\000\000\003<\000\000\001\203\000\000\003A\002\127\003N\001\216\000\000\000\000\000w\000\000\002a\000\000\000\000\000\000\002b\000\000\000\000\000\000\000\000\001\217\000\000\000\000\000j\001\200\001\223\000\000\002\\\000k\002\129\000\000\000\174\000l\002d\000\150\000\000\000\000\001\216\000\000\000\000\000\000\000\000\002a\000\000\002T\0044\002b\000\000\000\000\002f\000\000\001\217\000\000\000\000\000\000\000y\000u\000\000\000\000\000\151\000\000\000\000\000\000\000\152\002d\000\000\000\000\001\232\002[\000{\001\202\000\164\000\165\000\000\001\203\000v\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\000\000\000\002\\\000\000\001\233\000\000\000\000\001\200\001\223\001\234\000\000\002\127\001\216\001\235\000\000\001\232\000w\002a\001\236\000\000\000\000\002b\000\000\000\000\000\000\000\000\001\217\002T\0046\000\000\000\000\000\000\000\000\000\000\000\000\001\233\002\166\000\000\000\174\002d\001\234\000\150\000h\000\000\001\235\000\000\000q\000\000\000\000\001\236\000\000\002[\000\000\001\202\000v\002f\000\000\001\203\000\000\000\000\000\000\000\000\000y\000\000\001\200\001\223\000\151\001\200\001\223\000\000\000\152\000\000\000\000\001\232\000\000\002\\\000{\000\000\000w\000\000\000\000\000\000\000\000\000\000\003d\001\216\000j\002T\0048\000\000\002a\000k\000\000\001\233\002b\000l\000\000\000\000\001\234\001\217\000h\000\000\001\235\000x\000q\000\000\000\000\001\236\002[\000\000\001\202\002[\002d\001\202\001\203\000\000\000\000\001\203\000\000\000u\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\002f\000\163\000h\000\000\000h\000\000\000}\000\000\000q\000\000\000{\000\000\002|\002\\\001\200\001\221\000j\000\000\001\232\000\000\000\000\000k\000\000\001\216\000\210\000l\000\231\000\000\002a\000\000\000\000\000\000\002b\000\000\000\000\000\000\000\000\001\217\001\233\000\000\000\000\000\000\000\000\001\234\000\000\000\000\000j\001\235\000j\000u\002d\000k\001\236\000k\000\000\000l\000\000\000l\000j\000\000\001\202\000\000\000\000\000\000\001\203\000\000\002f\000\000\000j\000\000\002\\\000\212\000v\002\\\000\000\000\213\000\000\000\000\000\000\000u\001\216\000u\000\000\001\216\001\232\002a\000\000\000\000\002a\002b\000\000\001\"\002b\000\000\001\217\000\000\000w\001\217\000\000\000\000\000\000\000\226\000\000\000\000\001\233\000\000\000\000\002d\000\000\001\234\002d\000\000\000\000\001\235\000\000\000\000\000\000\000\000\001\236\000\000\003\015\000\150\000\000\002f\000\000\000\000\002f\000\000\000\000\000\000\000v\000\000\000\000\000\000\000\000\000\000\000h\000\000\000\000\000h\000q\001\232\000y\000q\001\232\000\000\000\151\000\000\000>\002\182\000\152\000\210\003\023\000\231\000w\000\000\000{\000\000\001\216\000\000\000v\001\233\000v\000\000\001\233\000\000\001\234\000\000\000\000\001\234\001\235\000\000\001\217\001\235\000\000\001\236\000\000\000\000\001\236\000\150\000j\002\182\000\227\000j\000w\000k\000w\000\000\000k\000l\000\000\000\000\000l\000\000\000\000\000j\000\000\000\000\000\212\000\000\000y\001Y\000\213\000h\000\151\000h\000\000\000q\000\152\000q\000\000\000\150\000\000\000u\000{\001S\000u\000\000\000h\000\000\000\000\000h\000q\000\000\000\000\000q\000\000\000\000\000\226\000\000\000y\000\000\000y\000>\000\000\000\000\000\151\000\000\000\000\001\233\000\152\000\000\000\000\000\000\000\128\000\000\000{\000j\000\000\000j\000\252\000\000\000k\001\252\000k\000\000\000l\000\000\000l\000\000\000\000\000\000\000j\000\000\001\013\000j\000\000\000k\000\000\000\000\000k\000l\000\000\000\000\000l\000\000\000\000\000\000\000\000\000\000\000u\000\000\000u\000\000\003$\000\000\001Y\0033\000\164\001D\000\000\000\000\000\000\000\000\000v\000u\000\000\000v\000u\000\000\001S\001T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\227\000\000\000\000\000\000\002\182\000\000\000\000\002\182\000\000\000w\000\000\000\000\000w\000\000\000\000\000\000\000\000\000\000\000\000\001_\000\000\001`\000\000\000\000\001\\\000\000\000\000\001]\000\000\000\174\000\000\000h\000\000\000\000\000\150\000q\000\000\000\150\000\000\000\000\000\000\000\000\003J\000h\003R\000\000\000h\000q\000\000\000\000\000q\000\000\000v\000\000\000v\000y\000\000\003\188\000y\000\151\003\200\000\000\000\151\000\152\000\164\001D\000\152\000v\000\252\000{\000v\002\182\000{\002\182\000\000\000j\000w\001T\000w\000\000\000k\000\000\001\015\000\000\000l\000\000\002\182\000j\000\000\002\182\000j\000w\000k\000\000\000w\000k\000l\000\000\000\000\000l\000\000\000\150\000\000\000\150\001_\000\000\001e\000\000\000u\001\\\000\000\000\000\001]\000\000\000\174\000\000\000\150\000\000\000\000\000\150\000u\000\000\000y\000u\000y\000\000\000\151\000\000\000\151\000h\000\152\000\000\000\152\000q\000\000\000\000\000{\000y\000{\000\000\000y\000\151\000\000\000\000\000\151\000\152\000\000\000\000\000\152\000h\000\000\000{\000\000\000q\000{\000\000\000h\000\000\000\000\000\000\000q\000\000\000>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\000\000\000\000\000\000\000\000\000k\003\206\000\000\000\000\000l\000\000\000\000\000\000\000\000\000\000\000h\000v\000\000\003\213\000s\000j\003\222\000\000\000\000\000\000\000k\000\000\000j\000v\000l\000\000\000v\000k\000u\000\000\002\182\000l\000\000\000\000\000\000\000w\000\000\001Y\000\000\000h\000\000\000\000\002\182\000q\000\000\002\182\000\000\000w\000u\000\000\000w\001S\005\"\000\000\000j\000u\000\000\000\000\000\000\000k\000\150\000\000\000\000\000l\000\210\000\000\000\231\000\000\000\000\000\000\000\000\000\000\000\150\000\000\000\000\000\150\000\000\000\000\000\000\000\000\000\000\000y\000\000\000j\000\000\000\151\000h\000u\000k\000\152\000q\000\000\000l\000y\000>\000{\000y\000\151\000\000\003\236\000\151\000\152\000\000\000\000\000\152\000\000\000\000\000{\000j\000v\000{\000\212\000\000\000\000\000\000\000\213\000u\000\000\000h\003\250\000\000\000\000\000q\000\000\000\164\001D\004\001\000\000\002\182\000v\000j\005\148\000\000\000w\000\000\000k\000v\001T\000\000\000l\000\000\000\226\000\000\000\000\000\000\000\000\000\000\001Y\002\182\000\000\000\000\000\000\000h\000w\000\000\002\182\000q\000\000\000\150\000\000\000w\001S\000j\000u\001_\000\000\001\141\000k\000v\001\\\000\000\000l\001]\000\000\000\174\000\000\000\000\000\000\000\150\000y\001\200\001\221\000\000\000\151\000h\000\150\000\000\000\152\000q\000\000\000\000\000\000\000w\000{\000\000\000u\000j\000v\000\000\000y\000\000\000k\000\000\000\151\000\000\000l\000y\000\152\000\000\000\000\000\151\000h\000\000\000{\000\152\000s\005/\000x\000\000\000\000\000{\000w\000\227\000\000\000j\000\000\001\202\000\000\000j\000u\001\203\000\000\000\000\000k\000\164\001D\000\000\000l\000y\000\000\000\000\000\000\000\000\000\235\000v\000\000\000\150\001T\000\000\000\000\000h\000\000\000{\000h\000q\000j\000\000\000q\000\000\000\000\000k\000u\000\000\000\183\000l\000\000\000\000\000y\000w\000\000\000\000\000\151\000\000\000\000\001[\000\152\000v\000\000\000\000\001\\\000\000\000{\001]\000\000\000\174\000\000\000\000\000h\000u\000\000\000\252\000q\000\000\000\150\000j\005/\000\000\000j\000\000\000k\000w\000\000\000k\000l\001\017\000\000\000l\000\000\000\000\000\000\000v\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\151\000h\000\000\000\000\000\152\000q\001\216\000\150\000\000\000u\000{\000\220\000u\000j\001\200\001\221\000w\000\000\000k\000\000\001\217\000\000\000l\000\000\000v\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\151\000h\000\000\000\000\000\152\000q\000\000\000\000\000\000\000\150\000{\000\245\002\143\000j\000u\002\168\000w\000\000\000k\000v\000\000\000\000\000l\000\000\000\000\000\000\000j\000\000\001\202\000\000\000y\000\000\001\203\000\000\000\151\000h\000\000\000\000\000\152\000q\000\000\000\150\000\000\000w\000{\000j\000u\000\000\000h\000\000\000k\000\000\000q\000\000\000l\001\233\000j\000\000\000v\000\000\002\145\000v\000y\000\000\002\146\000\000\000\151\000\000\000x\001\254\000\152\000\000\000\000\000\210\000\000\000\231\000{\001$\000u\000j\001\170\000\000\000w\000\000\000k\000w\000\000\000\000\000l\000y\000\000\000\000\000j\000\000\000\237\000v\000\000\000k\000\000\000\000\000\000\000l\000\000\000{\000h\000\000\000\000\000\150\000q\000\000\000\150\000h\000u\000\000\001\174\000q\000\000\000j\000\000\000w\000\212\000\000\000\000\000\000\000\213\000u\001\216\000v\000y\000\000\000\000\000y\000\151\000\000\000\000\000\151\000\152\000\000\000\000\000\152\001\217\000\000\000{\000h\000\150\000{\001\210\000q\000j\000\000\000\226\000w\000\000\000k\000\000\000j\002\159\000l\000\000\000v\000k\000\000\000\000\000\000\000l\000y\000\000\000\000\000\000\000\151\002\160\000\000\000\000\000\152\000\000\000\000\000\150\000\000\002\017\000{\000\000\000u\000\000\000w\000\000\000\000\000\000\000j\000u\000\000\000\000\000h\000k\000v\000\000\000q\000l\000y\000\000\000\000\000\000\000\151\000\000\000\000\000\000\000\152\000v\001\233\000\150\000\000\000\000\000{\002\022\000\000\000\000\000\000\000\000\000w\000\000\000\000\000u\002\000\000\000\000\000\000\000\002\026\000\000\000\000\000\000\000y\000w\000\227\000\000\000\151\000\000\000j\000\000\000\152\000\000\002\190\000k\000\000\000\150\000{\000l\000\000\000\000\000h\000\000\000\000\000\000\000q\000\000\002\197\000h\000\150\000\000\000\000\000q\000\000\000\000\000\000\000v\000y\000\000\000\000\000\000\000\151\000u\000v\000\000\000\152\000\000\000\000\000\000\000>\000y\000{\000\000\000\000\000\151\0021\000\000\000\000\000\152\000h\000w\000\000\002X\000q\000{\000j\000\000\000w\000\000\000\000\000k\000\000\000j\000\252\000l\000v\000\000\000k\000\000\000\000\000\000\000l\000\000\000\000\000\000\000\150\000h\001\019\000\000\000\000\000s\000\000\000\150\000\000\002\153\000\000\000\000\000h\000u\000w\000\000\000s\001Y\000j\000\000\000u\000y\000\000\000k\000\000\000\151\000\000\000l\000y\000\152\000\000\001S\000\151\000>\000\000\000{\000\152\000\000\000v\000\150\002\143\000\000\000{\002\168\000\000\000j\000\000\000\000\000\000\000h\000k\000u\000\000\000}\000l\000\000\000j\002\171\000\000\000\000\000y\000k\000w\000\000\000\151\000l\000\000\002\143\000\152\000\000\002\168\000\000\000\000\000\000\000{\000\000\000\000\000\000\000u\000\000\000\000\000\000\000\000\000\000\002[\000\000\001Y\000\150\002\145\000u\000\000\000\000\002\146\000j\000v\000\000\000\000\000\000\000k\000\000\001S\000v\000l\000\000\000\164\001D\000\000\000\000\000y\000\000\000>\002[\000\151\002\173\000\000\002\145\000\152\001T\000w\002\146\003\176\000\000\000{\000\000\000\000\000w\000u\000\000\000\000\000>\000\000\000\000\000v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\150\001_\000\000\002q\000\000\000\000\001\\\000\150\004\024\001]\000\000\000\174\000\000\000w\000\000\000\000\000v\000\000\000\000\000\000\001Y\000y\000\000\000\000\000\000\000\151\000\000\000v\000y\000\152\000\164\001D\000\151\000\000\001S\000{\000\152\000>\000\150\001Y\000w\002\159\000{\001T\002\189\000\000\000\000\000\000\000>\000\000\002\187\000w\000>\001S\000\000\002\160\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\151\000v\000x\000\000\000\152\002\159\000\000\001_\002\238\002\255\000{\000\000\001\\\000x\002\187\001]\000\000\000\174\000\000\002\160\000\000\000\000\000\000\000y\000\000\000w\000\000\001Y\001\225\000h\000\000\000\000\000\000\000}\000y\000\000\000\000\000{\001Y\001\227\000\000\001S\001Y\000\000\000\164\001D\000\000\000h\000{\000\000\000\148\000}\001S\000\000\000\000\000\000\001S\001T\000\000\000\000\000\000\002\190\000\000\000\164\001D\000\000\000\000\000\000\000h\000\000\000\000\000y\000}\000j\000\000\002\191\001T\000\000\000k\000\000\000\000\000\000\000l\000\000\001_\000{\003\n\000\000\002\190\001\\\000\000\000j\001]\000\000\000\174\000h\000k\000\000\000\000\000}\000l\000\000\002\191\001_\000\000\003/\000u\000\000\001\\\000\000\000\000\001]\000j\000\174\000\164\001D\000\000\000k\000\000\000\000\000\000\000l\000\000\000\000\000u\000\164\001D\001T\000\000\000\164\001D\000\000\000h\000\000\000\000\000\000\000}\000\000\001T\000j\000\000\000\000\001T\000\000\000k\000u\000\000\000h\000l\000\000\000\000\000}\000\000\000h\001_\000\000\003E\000}\000\000\001\\\000\000\000\000\001]\000\000\000\174\001_\000\000\003\196\000\000\001_\001\\\003\232\000u\001]\001\\\000\174\000j\001]\000\000\000\174\000\000\000k\000\000\002\143\000h\000l\002\168\000v\000}\000\000\000h\000j\000\000\000\000\000}\000\000\000k\000j\000\000\000\000\000l\000\000\000k\000h\000\000\000v\000l\000}\000\000\000u\000h\000w\000\000\000\000\000}\000\000\000\000\000\000\000\210\000\000\000\231\000\000\000\000\000\000\000u\000\000\000v\000j\000j\000w\000u\002\145\000\000\000k\000j\002\146\000\000\000l\000\000\000k\000\000\000\000\000\000\000l\000\000\000\000\000\000\000j\000\000\000\000\000w\000\000\000k\000v\000j\000\000\000l\000y\000\000\000k\000\000\000u\000j\000l\000\000\000\212\000\000\000u\000\000\000\213\000\000\000\130\001\200\001\221\000\000\000y\000\000\000w\000\000\000\000\000u\000\210\000\000\000\231\000\000\000\000\000\000\000u\000\000\000\132\000v\000\000\000\210\000\000\000\231\000\226\000y\000\000\000\000\000\000\000\000\000\000\000\000\001\200\001\221\000v\000\000\000\000\000\000\000\000\000\134\000v\000\000\000\000\000w\000\000\000j\000\000\001\202\000\000\000\000\000\000\001\203\000y\000\000\000j\000\000\002\159\000\212\000w\000\000\000\000\000\213\001\200\001\221\000w\000j\000\136\000\000\000\212\000\000\002\160\000v\000\213\000\000\000\000\000\000\000j\000v\001\202\000\000\000\000\002\143\001\203\002\143\002\168\000\000\002\168\000\226\002\143\000y\000v\002\168\000\000\000\000\000\000\000w\000\000\000v\000\226\000\000\000\000\000w\000\000\000\138\000y\000\227\000j\000\000\001\202\000\000\000y\000\000\001\203\000\000\000w\000\000\000\000\000\000\000\140\000\000\000\000\000w\000\000\000\000\000\142\000j\000\000\000j\000\000\002\145\000\000\002\145\000j\002\146\002\143\002\146\002\145\002\168\000\000\002\190\002\146\000y\000\000\000\000\000\000\001\216\000\000\000y\000\000\002\143\000\000\002\143\002\168\002\199\002\168\000\144\000\000\000\000\000\000\001\217\000y\000\154\000\000\000\000\000\000\000\000\000\000\000y\000\227\002\143\000\000\000\000\002\168\000\252\000\156\000\000\001\216\000\000\000j\000\227\000\000\000\158\002\145\000\000\000\000\000\000\002\146\001\025\000\000\000\000\001\217\000\000\000\000\000j\000\000\000j\000\000\002\145\000\000\002\145\000\000\002\146\000\000\002\146\002\143\000\000\001\216\002\168\000\000\000\000\000\000\002\143\000\000\000j\002\168\000\000\000\000\002\145\000\000\000\000\001\217\002\146\000\000\000\000\000\000\002\159\001\233\002\159\000\000\000\000\000\000\000\000\002\159\000\000\000\000\000\000\000\252\000\000\000\000\002\160\002\006\002\160\000\000\000\000\000\000\000\000\002\160\000\252\000j\000\000\001\027\000\000\002\145\000\000\000\000\000j\002\146\001\233\000\000\002\145\000\000\001\029\000\000\002\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\008\000\000\000\000\000\000\000\000\000\000\000\000\002\159\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\233\000\000\000\000\000\000\000\000\002\160\002\159\000\000\002\159\000\000\000\000\000\000\000\000\000\000\002\n\000\000\000\000\000\000\000\000\000\000\002\160\002\190\002\160\002\190\000\000\000\000\002\159\000\000\002\190\000\000\000\000\000\000\000\000\000\000\000\000\002\201\000\000\002\203\000\000\000\000\002\160\000\000\002\205\000\000\000\000\000\000\000\000\000\000\000\000\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\159\000\000\000\000\000\000\000\000\000\000\000\000\002\159\000\000\000\000\000\000\000\000\000\000\002\190\002\160\000\000\000\000\000\000\000\000\000\000\000\000\002\160\000\000\000\000\000\000\000\000\000\000\002\207\002\190\000\000\002\190\000\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\002\211\000\000\000\000\000\000\002\190\000\000\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\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\190\000\000\000\000\000\000\000\000\000\000\000\000\002\190\000\000\000\000\000\000\000\000\000\000\000\000\002\215\000\000\000\000\000\000\000\000\000\000\000\000\002\217")) + ((16, "\001\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\011\000\000\000\223\012\200\000\000\000\167\000_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\025\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\006\204\000\167\000_\000\000\000\000\000\000\000\000\000\000\017l\000$\008t\000\000\000\000\000\000\005\014\000\000\001\138\000\233\023\246\000\000\000\000\000\027\000\000\nH\000\000\007\178\019V\004\254\027\196\004\254\017\030)N\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\013^\027\196\000\000\000\000\013\128\000\000\014p\000\000\016\020\000\000\000\000\000\000\000\000\000\246\000\000$\198\000\000\000\000\008T\000\000\t\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000v\000\000\000\000\031.\000\000\031\194\000\000\"6\000\000%N\000\000'\192\000\000*X\000\000,f\000\000,\210\000\0002R\000\000 R\000\000\007\012\000\000\000\000\000\000\000\000\000\0008B\000\0009\246\000\000:\026\000\000\016\018\000\000\000\000\017r\000\000\000\000\000\211\000\173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\000\164\000\000\000\136\000\000\000\000\002\236\000\00050\000\000\000\000\000\000\000\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\140\000\000\000\000\000\000\000\000\000\000\000\000\012\234)N\000\000\021\156\000\000\026d\026\154\000\000\000\000\000\000\0010\000\000&\002\000\000\000\0005\132\000\000\000\000\000\000\002\152\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\224\000\000#\146\000\000\000\000\000\000\000\000\000\012\000\000\000\0005\166\000\000\000\000\000\000 \146\002\182\000\000\000\000\000\000\000\000\000\000\000\000\004\162\000\000\n\002\000\000\018\232\000\000\022\174\000\000\023\216\000\000\024\238\000\000%\188\000\000%\246\000\000(H\000\000+\184\000\000)\170\000\000\000\n\000\000-\028\000\000/t\000\0003\012\000\000\000\000\000\000\000\000\000\000\000D6\028\000\000\002*\000\000\000\000\000-\016\238\000\000\002\158\000\000\000\000\000\000\005\180\000\000\000\000\000\000)f\000\000\000\000\000\000\000\000\000\000*\006\000\000\000\000\000\000\000\000\000\000\000\000\000\140\000\000\000\000\000\000\000\150\000\000\000\000\000\000\0026\000\000\000\000\011.\000\167\000\000\000\000\001\005\013F\000\000\000\000\000\000\000\000\000\000\004(\000\000\011r\000\000%n\000\000\000\000\005\192\000\000\000\000\000\000\000\000\000\000\000\000\012z\000\000\000\000\000\000\000\245\000\000\000\000\000\000\000\000\003B\015\204\000\000\002\138\000\000\000\000\001|\002\226\000\000\000\000\000\000\000\000\t\026\000\000\000\000\000\000\000\000\000\000\000\000\000'\019\214\000\000\0218\000\000\000\000\000\000\001\006\000\000\013\244\001~\000\000\016$\000\000\000\000\000\000\000\232\001\168\000\000\000\000\000\000\007(\000\000\000\000\001\206\000\000\000\242\000\000\000\000\000\000\000\000\001@\002\182\000\000\002v\000\000\000\000\000\000\000\000\000\000\000\00066\000\000\001(\000\0006\184\000\000\000\000\0024\000\000\008N\000\000\005\158\004V*\030\000\000\000\000\000\000\002\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t@*\030\000\000\n\\\000\000\015f\015\240\000\000\000\000\000\000\006\166\000\000&X\000\000\000\0006\214\000\000\000\000\000\000\007\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\174\000\000&\196\000\000\000\000\000\000\003*\000\000\000\000\000\000\000\000\000\000\000\000\007j\000\000\014\030\000\000\0178\000\000\023\250\000\000\030D\000\000#\240\000\000'\172\000\000(\028\000\000)\238\000\000.x\000\000/\002\000\000\012\242\000\0005\008\000\0005&\000\0005\224\000\000*\190\000\000\000\000\000\0007|\000\000\000\000\000\000\000\011\000\0007\184\000\000\000\000\000\0007\210\000\000\000\000\0000\000\000\026\176\000!\000\196\000\000\002\156\000\000\014\254\002l\tX\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0008.\000\000*l\000x\007\006\000\000\000\000\000\000/\008\000\000/\168\000\000/\190\000\000+\136,\012\000z\001\003\007$\000\000\000\000\000\000\000\183\000\000\000\000\001\246\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0008j\000\000\000\000\000\000\000\000\000\000&\240\000\000,\134\000\000\000\000\000\000\000\000\000\000\000\000\015|\000\000\005&\000\000\000\000\000\000\000\000\t\252\001\250\000\000\016\162\000\000\000\000\000\000\000W\000\000\000\000 \230\006\152\000\000\003`/\136\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\0052,b\000\000\013|\000\000\018j\019\150\000\000\000\000\000\000\007\194\000\000'\168\000\000\000\0008n\000\000\000\000\000\000\007\230\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000,\212\000\000\002t\000\000\000\0008\142\000\0009^\000\000\000\000\000\000\022\028\000\000\000\00000\000\000\000\000\000\000\000\000\007\254\000\000\000\000\000\000\005\226\000\000\000\000\007\174\000\000\002v\000\000\000\000\000\000\000R\000\000\007\216\000\000\020\134\000\000\027\"\000\0001\018\000\0003P\000\0004\244\000\0006(\000\0007\140\000\0008\000\000\0008\226\000\0009\\\000\000:.\000\000\000\000\000\000\000\000\000\000\000\228\000\000\013\012\000\000\027\182\002\222\000\000\028\204\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\214\000\000\000\000\000\000\000\000\000\000\000\000\003\232\000\000\000\000\022\138\000\000\000\000\000\0000\166\000\000\000\000\015<\000\000\000\000\000\000\025T\000\000\000\000\000\000\000\0000\188\000\000\000\000\000\000\000\000\002\n\006\002\000\0001>\000\000\000\000\000\000\000\000\027D\004X\000\000\028\140\000\000\000\000\006j\000\0001\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\234\000\000\000\000\028\030\000\000\000\000\000\0001\198\000\000\000\000\004z\000\000\000\000\014\192\000\000\029 \000\000\000\000'\254\000\000\000\000\000\000\004$\000\000\000\000\028\234\000\000\000\000\000\000\000\0002\028\000\000\000\000\000\000\000\000\003<\018D\000\00022\000\000\000\000\000\000\000\000\000\000\000\000\016\200\000\000\000\000\0058\000\000\017F\000\000\004$\000\000\000\000\004@.~\000\000\005&\000\000\000\000\000\000\000\000\003*\000\000-f\000\000\029\212\001\182\030h\000\000\003*\000\000\017\236\000\000\018\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\158\031\140\005\014 \000\000\000\000\000\000\007\014\000\000\019\016\000\000\005\222\000\000\000\000\004$\001\222!D\000\000\005(\000\000\019\220!\234\000\000\000\000\020Z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\190\t\214\000\000\007\200\000\000\000\000\000\000\000\000\007\214\000\000\021&\000\000\000\000\000\000\030\2169~\000\000\000\000\000\000$\160\000\000\000\000\000\000\000\000\n*\004\158\000\000\000\0002\146\000\000\000\000\000\000\000\000\004\240\000\000\000\000 F\000\000\000\000\000\0002\222\000\000\000\000\002.\000\000\000\0003v\000\000\000\000\003\216\004\252\000\000\000\0003z\000\000\000\000\007\252%P\000\000\005J\000\000\000\0003\214\000\000\000\000\000\000\000\000\000\000\000\000\005h\000\000\000\000\"\254\000\000\000\000\000\0003\236\000\000\000\000\000\000\000\000\000\000(\150\000\000\000\000\000\000\000-\000\000\000\000\000\0004\002\000\000\000\000\003\220\005\230\000\000\000\0004v\000\000\000\000\008\020\000\000\000\000\000\000\000\000\003*\000-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\204\000\000\021d\000\000\000\000\000\0009\130\000\000\n\162\000\000\000\000\000\000\002\238\000\000\000\000\003\148\021\226\000\000\023.\000\000\000\000\000\000\004\232\000\000\"\170\007L-V\000\0000\004\000\000\000\000\000\000\007\192\000\000.*\007\236.\192\000\000.\248\000\000\000\000\000\000\0082\000\0000\156\0084\000\000\000\000\001f\006j\008J\014\026\000\000\015\164\000\000\000\000\000\000\008\192\000\0005\252\008\212\000\000\000\000\000\000\002l\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\000\003\008\000\000\000\022\000\000\000\000\000\000\003\134\000\000\000\000\000\000\000\000\000\000\000C\000\000\008>\003\234\001B\000\000\000\000\007\246\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\246\000?\000\000\000\000\000\003\000\000\000\000\000\000\004v\000\000\000\000\006~\008H\000\000\000\000\000\000\000\000\017p\019\176\006<\000\000\020\140\000\000\000\000\000\000\000\000\000\000\000\000\003.\000\000\000\000\004\180\000\000\000\000\004\026\000\000\000\000\003|\000\000\000\000\004\022\000\000\t*\0056\002z\000\000\000\000\t\152\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\252\022\016\000\000\000\000\000\000\000\000\022\140\000\000\000\000\011:\000\000\000\000\015\026\000\000\000\000\000\000\023\024\000\000\000\000\0009\023@\007\204\000\000\023`\000\000\000\000\000\000\000\000\000\000\000\000\005\154\000\000\t0\003\140\000\142\000\000\000\000\000\000\000\000\002`\000\000\000\000\000\000\000\000\000\000\000\000\012\134\000\000\000\000\006*\000\000\t:\005v\003\144\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\200\000\000\000\000\019(\023\240\000\000\000\000\000\000\000\000\002T\000\000\003\134\000\000\0208\000\000\000\000\000\000\000\000\000\000\000\000\000\011\020\164\000\000\000\000\021\128\000\000\000\000\000\000\000\000\000B\000\000\021\254\000\000\000\000\000\000\000\000\005\254\000\000\000\000\000\000\000\155\000\000\000\000\000Y\000\000\000\000\000\000\000\000\000\000\000\000\000\0002\190\005\008\000\000\000\000\000\000\001\006\000\000\000\000\026\234\000\000\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\n\180\000\167\013\028\019\030\005b\000\000\000\000\006\164\006\188\007\250\008j\000\000\000\000\000\000\000\000\000\000\000\000\006\180\023\172\000\000\"(\t\024\000\000\000\000\t>\000\000\024x\000\000\025n\000\000\000\000\007.\024\182\000\000\"\216\000\000\007\136#\188\000\000\000\000\000\000\018\020\006\164\000\000\006\004\000\000\000\000\000\000\008\220\000\000\011\000\000\000\004:\006\170\000\000\000\000\000\000\000\000\004(\000\000\005\192\000\000\008\148\000\000\000\000\020\130\000\000\000\000\000\000\000\000\011 \000\000\000\000\006\164\tP\000\000\026\\\000\000\004$\005\220\000\000\000\000\000\000\000\000\000\000\0058\000\000\000\000\000\000\000\000\000\0004\132\t\026\000\000\tr\000\000\000\000\000\000\000\000\000\000\001\216\000\000\011\238\t\190\012l\000\000\003\180\013v\000\000\t\222\000\000\0048\000\000\005\128\000\000\006\004\000\000\000\000\000\000\000\000\000\000\t,\000\000\007L\000\000\t\246\000\000\007\208\000\000\004$\006*\000\000\004\\\000\000\006L\005\210\000\000\008h\000\000\008\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tB\000\000\t\202\000\000\000\000\000\000\000\000\000\000\006$\000\000\000\000\006\018\002r\007\208\000\000\008x\000\000\000\000\t^\t\242\000\000\007\158\000\000\000\000\000\000\000\000\007\224\000\000\000\000\000\000\000\000\000\000\000\000\008\022\008\156\008|\td\008\188\t\"\000\000\000\000\008\248\008\168\t\148\t\024\t\\\000\000\000\000\n2\000\000\000\000\000\000\000\000\n.\000\000\000\000"), (16, "\001\200\001\223\000>\000h\002u\004g\000\017\001<\002!\002\"\000\n\004|\000\005\004\206\000>\002E\001g\000*\002m\003n\003V\000\210\004e\000\231\001i\000>\004h\004t\004}\004t\004\207\004\210\004t\001?\004\225\000\t\000\008\000\t\003\007\005\026\005\027\004\127\000\016\004P\003!\000\167\001\202\000j\000*\004d\001\203\004\226\000k\002G\004\229\004t\000l\002\143\004}\004t\002\168\004\224\005\031\005 \0008\000j\004e\0009\000\212\002F\004h\004t\000\213\004\013\004\206\000h\001\200\001\223\000*\000}\000u\001+\005$\0055\005\006\004u\0056\004u\001\200\001\223\004u\004\207\004\210\004t\005b\003\157\003b\001\228\000\226\001 \005c\000j\000>\0008\005:\002\145\005d\002F\003 \002\146\001h\002!\002\"\004u\005\t\001-\004\214\004u\001h\000j\002[\000*\001\202\001\133\000k\004\019\001\203\000F\000l\004u\002\143\004\215\003!\002\168\001\202\002\\\001%\000\247\001\203\001@\001\135\0053\001\156\000\164\000\177\001\216\000>\000\210\000F\000\233\002a\004u\000u\003C\002b\000\164\001D\003(\000+\001\217\003\159\003|\000v\0053\001\200\001\223\000\164\000\165\003)\003h\001'\000\176\003j\001\228\002[\002v\005f\005*\002\145\004W\000\227\001\158\002\146\000*\002T\004\031\000w\000*\001x\002f\000>\000j\002\247\003W\000\212\003v\003\247\005g\000\213\004\128\003<\004\239\002\159\000\248\003\141\004k\003N\001\232\002[\000>\001\202\002\\\000*\002m\001\203\005\001\002\160\000\174\000\178\001A\000>\001\216\005\012\002\\\000\226\001E\002a\001\233\002$\001\023\002b\002H\001\234\001\216\000v\001\217\001\235\004v\002a\004B\004\216\001\236\002b\000\164\001D\003(\005i\001\217\003j\000\252\001t\000j\001\200\001\223\003p\005j\005\132\000*\000w\002\187\005\133\004\014\005\019\000\255\005\160\002f\000>\002K\002L\002N\005d\005\161\003 \001\136\003\143\002\159\002\228\002f\002\226\004l\000\017\0037\005\135\001\232\002\190\004\016\002\195\001\152\003<\002\160\001\135\000>\005\137\000n\003N\001\232\003!\000\187\001\202\002\\\002\198\001\146\001\203\001\233\004\219\000y\000\227\005\179\001\234\001\216\002\229\000*\001\235\000j\002a\001\233\002\193\001\236\002b\000~\001\234\003\020\000\215\001\217\001\235\001@\001\200\001\223\000>\001\236\002\143\001\162\005+\002\168\003\153\001\154\002d\004\225\001\159\003\007\000>\0009\000\017\000*\002m\003n\003V\002!\002\"\004\218\000\164\001D\003(\002f\004\226\000\251\005\180\004\229\004t\002\195\004\167\000\164\000\177\003)\004\215\005.\001\139\000F\001\200\001\221\003!\001\232\001\202\002\196\000j\000\252\001\203\004\168\002\145\001%\000\253\001\153\002\146\002\143\000\254\000*\002\168\002\\\004C\000\255\000h\001\233\000*\004o\000q\003<\001\234\001\216\003x\003A\001\235\003N\002a\0009\000>\001\236\002b\000\164\001D\003(\005\182\001\217\000j\001&\001\202\001B\004u\004\254\001\203\005j\005\132\002H\003}\001\228\005\184\001 \004U\002[\002o\000*\004\027\002\145\000\164\000\177\000j\002\146\001\161\000>\001+\000k\003p\002f\005\225\000l\000>\0037\005\186\000>\002\143\000F\001n\002\164\003<\000F\003\008\004\151\005\188\002J\003N\001\232\002\194\002\\\000>\004V\002#\001\163\004z\000u\004\\\000\164\000\165\001\216\001,\004\216\003O\002\159\002a\000E\000\250\001\233\002b\000\164\001D\003(\001\234\001\217\004\160\003\127\001\235\002\160\001\200\001\223\000j\001\236\003)\000F\002\145\003\203\003j\004\167\002\146\001I\000\224\004\161\000>\004\164\004t\001%\005d\005\166\003V\004a\002\187\001\216\004\215\002f\004\168\002\193\005\001\003W\000\174\003v\000>\004\030\000>\005\002\003<\001\217\002\159\004\029\003\141\002\233\003N\001\232\003!\004\018\001\202\002\190\002\245\000F\001\203\001\231\002\160\001q\000\248\000\164\000\165\001 \004\171\000v\005\176\000*\003\209\001\233\003\253\005\238\001\200\001\223\001\234\002\169\000*\000*\001\235\004\163\004u\000\181\004W\001\236\000\172\002\193\000>\001\200\001\223\000w\005d\005\166\003V\002u\000\164\000\165\004\161\003\029\004\164\004t\003s\000\164\000\177\001u\000\164\001D\003\007\003\030\000*\002\159\000\173\001\222\000\174\004%\0036\000\150\003!\001F\001\202\000\164\000\165\002\236\001\203\002\160\003\030\000\210\005\239\000\231\002\195\004|\004'\000j\005\171\001\202\005\240\004q\000y\001\203\004\029\004\221\000\151\002\\\002\196\004\152\000\152\000\174\004}\004t\000>\001+\000{\001\216\000\179\001p\001w\001s\002a\004u\003e\004\155\002b\000\164\001D\003(\005\172\001\217\004\154\000*\001(\000j\000\174\000h\000\212\005j\005\132\000q\000\213\000F\002d\000\164\000\177\000\164\000\177\001-\001\228\000>\000F\000F\002!\002\"\004\176\004\157\003g\000>\000D\002f\000C\002\143\003\130\003W\002\163\005\174\000\226\004\232\005x\004u\003<\002\\\000*\003\\\003A\003\143\003N\001\232\000*\000j\000F\001\216\001b\003\030\000k\003C\002a\000E\000l\002\246\002b\000\164\001D\003(\005\172\001\217\001\216\001\233\002\252\003,\001\200\001\223\001\234\005j\005\132\000j\001\235\004\173\002d\002\145\001\217\001\236\000u\002\146\000>\001\200\002\014\000*\005d\005\166\003V\005\145\005\146\001\230\005\248\002f\000h\004\016\003H\003W\000}\005\174\000*\001\030\001 \003\146\003<\003e\004\209\004\234\003A\000F\003N\001\232\003!\003L\001\202\004(\000\227\002\143\001\203\0050\002\168\000\164\000\165\004\207\004\210\004t\001\232\000j\005\173\001\202\005y\001\233\004'\001\203\001\200\001\223\001\234\002i\000j\003f\001\235\000>\005\150\000k\000*\001\236\001\233\000l\000>\004\131\000F\001\234\005d\005\166\003V\001\235\000F\003\185\000\164\000\165\001\236\002[\000v\000*\002u\002\145\000\164\001D\003\138\002\146\004\152\000u\000\174\003\132\002\159\005\022\004\228\000*\003!\001F\001\202\001\"\0051\004u\001\203\000\252\000w\005@\002\160\005\143\001m\005\190\005\004\004\226\005\175\000F\004\229\004t\003\193\001\001\003\138\0053\003\140\002\\\003\210\004\142\004t\001(\002\143\000\174\000F\002\168\000\150\001\216\005\194\001p\002u\001s\002a\002!\002\"\004|\002b\000\164\001D\003(\005\172\001\217\001\216\000*\005\014\000>\005E\000y\003\139\005j\005\132\000\151\004}\004t\002d\000\152\001\217\003\219\005E\005h\002\187\000{\000>\000@\001~\000C\002[\000v\001^\004u\002\145\002f\003\229\000*\002\146\003W\002\159\005\174\004u\002\189\000h\005\024\003<\002\\\000}\002\190\003A\000F\003N\001\232\002\160\000w\000E\001\216\002!\002\"\000\164\000\165\002a\005r\003\130\000F\002b\000\164\001D\003(\005\172\001\217\000>\001\233\005\213\004u\001\200\001\223\001\234\005j\005\132\002\193\001\235\000*\002d\000*\0051\001\236\000j\003\162\000>\001\200\001\221\000k\005d\005\166\003V\000l\005\218\003\254\000*\002f\0010\002!\002\"\003W\005\219\005\174\000\210\005\001\000\231\000\174\003<\003\021\005M\002\187\003A\000F\003N\001\232\003!\000u\001\202\003\164\002\195\002\143\001\203\000\210\002\168\0016\003\025\002\159\002\223\002\240\002\226\000j\005\183\001\202\002\196\001\233\002\190\001\203\001\200\001\223\001\234\002\160\002\143\001\205\001\235\002\168\000\164\001D\000j\001\236\003\168\000\212\000>\001\150\005I\000\213\005d\005\166\003V\005s\003\030\003\"\002\229\000\164\001D\002[\005H\000j\002\193\002\145\000\212\005[\005\224\002\146\000\213\000*\001F\005E\003&\004\200\004t\000\226\003!\004\137\001\202\004n\000j\001m\001\203\001\214\002\145\0025\005v\000*\002\146\005w\004/\000\174\005\187\000v\000\226\001\200\001\223\003\135\000h\000*\002D\002\\\000s\000\164\000\165\002\195\001p\0041\001s\000>\005`\001\216\003\162\002m\003n\003V\002a\000w\004|\002\196\002b\000\164\001D\003(\005\172\001\217\001\216\005E\000>\000@\000A\000C\004u\005j\005\132\004}\004t\004\003\002d\003!\001\217\001\202\000j\000\148\002\187\001\203\003\163\000k\0042\004\003\005\223\000l\001(\004l\000\174\002f\004r\000\227\000E\003W\002\159\005\174\005\205\002\192\000y\0041\003<\002\\\0049\002\190\003A\004\005\003N\001\232\002\160\000u\000\227\001\216\000{\002\148\005\233\002\159\002a\004\004\005\235\004;\002b\000\164\001D\003(\005\172\001\217\004s\001\233\004u\002\160\005\205\002\157\001\234\005j\005\132\002\193\001\235\004<\002d\005Q\004?\001\236\001\233\002\185\000j\000>\000@\001z\000C\003\030\001\200\001\220\004H\005G\004;\002f\001\238\0041\005T\003W\000\232\005\174\001\200\001\223\002\\\005\243\003<\005\134\003\030\004J\003A\005\241\003N\001\232\001\216\000E\000>\003\030\002\195\002a\002m\003n\003V\002b\000\164\001D\003(\005\250\001\217\004\022\003|\000v\002\196\001\233\000j\005z\001\202\003)\001\234\002\195\001\203\002d\001\235\000\164\001D\005\205\003!\001\236\001\202\005F\004\174\004K\001\203\002\200\004\222\000w\001F\004\235\002f\000h\004N\004\170\003W\000s\003v\001\200\001\223\001m\004J\003<\005\212\005\154\005\163\003A\005\155\003N\001\232\0041\004\168\000>\004\135\000x\005\152\002m\003n\003V\004\175\000\210\005\163\000\231\004\223\005\181\001p\004\236\001s\005\242\001\233\005\245\000>\005l\005\163\001\234\000y\000j\005\206\001\235\005\227\000\161\000k\003!\001\236\001\202\000l\005\205\005\177\001\203\000{\005\228\005\238\005\246\005\244\000>\000\210\004\168\000\233\005\159\000\164\001D\002t\005y\005\169\000j\001\200\001\219\000\212\001\216\000u\002\\\000\213\001F\005\238\005\249\005\185\005\252\005\251\0051\006\000\001\216\005\253\001\217\001m\003\184\002a\006\005\0051\006\001\002b\000\164\001D\003(\000\000\001\217\003z\003|\000\226\000\000\000j\001\200\001\223\000\212\003)\000\000\000\000\000\213\002d\001p\000j\001s\001\202\005\208\000\000\000>\001\203\000\000\0053\002m\003n\003V\000\000\005\237\000>\002f\005\237\000\000\005>\003W\000\238\003v\000\000\000\226\002\\\000\000\003<\000\000\000\000\000\000\003A\000\000\003N\001\232\001\216\003!\000\000\001\202\000\000\002a\005\237\001\203\000v\002b\000\164\001D\003(\000\000\001\217\003\161\003|\000\000\000>\001\233\001\200\001\223\000\000\003)\001\234\000\000\004\160\002d\001\235\000\164\001D\000\000\000w\001\236\000>\000\000\000\227\005\210\002m\003n\003V\000>\002\249\004\161\002f\004\164\004t\000\000\003W\000\000\003v\000\000\000\164\001D\000\000\003<\000\000\004\160\000x\003A\000\000\003N\001\232\000\000\003!\003\190\001\202\001\216\000\000\000\000\001\203\000\227\005{\000\000\004\161\000>\004\164\004t\003\005\000y\003\019\001\217\001\233\0017\000z\000\000\000\000\001\234\000\000\000\000\000\000\001\235\002\\\000{\001Y\000\000\001\236\000\241\000\000\000\000\000\000\003\202\001\216\003\208\004u\000\252\000\000\002a\001S\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\004\026\003|\001\003\000\251\000\164\005?\001\200\001\223\003)\000\000\000\000\001Y\002d\000\000\000\000\000\000\005K\005B\004u\000\000\000>\000\000\000\000\000\252\005d\001S\003 \000\000\000\253\002f\000\000\000\000\000\254\003W\000\000\003v\000\000\000\255\002\\\000\000\003<\000\000\000\164\001D\003A\000\000\003N\001\232\001\216\000\000\003!\000\000\001\202\002a\000\000\005s\001\203\002b\000\164\001D\003(\000\000\001\217\005\130\003|\000\164\001D\001\233\005\178\001\200\001\223\003)\001\234\000\000\000\000\002d\001\235\000\000\001T\000\000\000\000\001\236\000\000\000>\005~\000\000\005\127\005d\005v\003 \000>\005w\002f\000\174\000\000\000\000\003W\004\182\003v\000\164\001D\000\000\000\000\003<\000\000\004\225\001_\003A\001j\003N\001\232\001\\\001T\003!\001]\001\202\000\174\000\000\000\000\001\203\000\000\000\000\004\226\000\000\000\000\004\229\004t\000\000\004\188\000>\001\233\005\164\000\210\000\000\000\230\001\234\001\200\001\221\004\225\001\235\001_\002\\\001`\001Y\001\236\001\\\000\000\000\000\001]\002\143\000\174\001\216\002\168\000\000\000\000\004\226\002a\001S\004\229\004t\002b\000\164\001D\003(\005\165\001\217\000\000\000\000\000\000\000\000\000\000\000>\000\000\005j\005\132\005>\000j\000\000\005\168\000\212\000j\000\000\001\202\000\213\004u\000\000\001\203\000\000\000\000\000\000\000h\000\000\000>\002[\000\193\002f\000\000\002\145\000\000\0037\005\170\002\146\001\200\001\223\002\\\002\143\003<\000h\002\162\000\226\003A\000\190\003N\001\232\001\216\000\000\000>\004u\000\000\002a\005d\000\000\003 \002b\000\164\001D\003(\005\165\001\217\000\000\000\000\000\164\001D\001\233\000j\000\000\005j\005\132\001\234\000k\000\000\005\168\001\235\000l\001T\001R\003!\001\236\001\202\000j\000\000\000j\001\203\002\145\000\000\000\000\000k\002\146\002f\001S\000l\000\000\0037\005\170\005\167\001\200\001\223\000u\000\000\003<\000\164\000\165\001_\003A\001e\003N\001\232\001\\\002\187\000>\001]\001\216\000\174\002m\000u\003 \001\200\001\221\000\000\000\000\000\000\000\227\000\000\004\237\002\159\001\217\001\233\002\230\000>\000\000\000\000\001\234\002m\002\190\000\000\001\235\000\000\000\000\002\160\003!\001\236\001\202\000\164\005?\000\000\001\203\000\000\000\000\000\000\001\128\000\000\000\174\000\000\000\000\005J\005B\004\242\000h\004B\002\232\000j\000\189\001\202\000\164\001D\002\193\001\203\002\\\000\000\000\000\000\000\004 \000\000\002\004\000\000\003\156\001T\001\216\000\000\000v\002\159\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\005\165\001\217\000\000\001\233\002\160\000\000\000v\001\200\001\223\005j\005\132\000j\002\238\000w\005\168\0039\000k\001\236\002\195\001\\\000l\000>\001]\000\000\000\174\002m\003:\003V\000\000\000\000\000w\002f\002\196\000\000\000\000\0037\005\170\000\000\001\200\001\223\002\\\000\000\003<\000\000\000u\000\000\003A\000\000\003N\001\232\001\216\003!\000>\001\202\000\000\002a\002m\001\203\003 \002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\000\000\001\233\000\000\001\216\000\000\003)\001\234\000\000\004\160\003\145\001\235\000\164\001D\003(\003!\001\236\001\202\001\217\000\000\000\000\001\203\000\000\001\200\001\218\003)\004\161\002f\004\164\004t\000\000\0037\003\147\002u\001\200\001\223\000\000\000\000\003<\000\000\000\000\002k\003A\000\000\003N\001\232\003\007\003\154\000>\000\000\004E\003\156\002m\003\027\003 \000\000\000\000\003<\000\000\000v\000\000\003A\000\000\003N\000\000\001\233\000\000\000j\000>\001\202\001\234\000\000\002m\001\203\001\235\002\\\000\000\000\000\003!\001\236\001\202\000\000\000\000\000w\001\203\001\216\001\233\004u\000>\001o\002a\000C\001\200\001\201\002b\000\164\001D\003(\004B\001\217\001\240\000\000\000\000\000\000\000\000\000\000\002\\\000\000\003)\000h\000h\000\000\002d\000s\000i\000\000\001\216\000\000\000E\000\000\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\002f\001\217\000\000\000>\003W\000\000\003X\000j\000\000\001\202\003)\003<\000\000\001\203\003\145\003A\000\000\003N\001\232\000\000\000\000\000\000\000\000\000\000\000j\000j\000\000\000F\000\000\000k\000k\002f\003\008\000l\000l\0037\003\147\000\000\001\233\001\216\002\\\000\000\003<\001\234\000\000\000\000\003A\001\235\003N\001\232\001\216\000\000\001\236\001\217\000\000\002a\001Y\000u\000u\002b\000\164\001D\003(\000\000\001\217\000\000\000>\000\000\004\191\001\233\001S\001\200\001\223\003)\001\234\003\013\000\000\003[\001\235\003Y\000\164\001D\003(\001\236\000\000\000>\000\000\000\000\000\000\002m\003:\003V\003\017\003)\002f\000\000\000\000\000\000\0037\003]\000\164\001D\000\000\000\000\000>\003<\000\000\000\000\001\216\003_\000\000\003N\001\232\001F\000\210\003!\000\233\001\202\004G\001Y\000\000\001\203\001\217\000\000\001m\003<\000\000\001\200\001\221\003A\000\000\003N\001\233\001S\001\200\001\223\000\000\001\234\000\000\000v\000v\001\235\003^\000\000\000\164\001D\001\236\000\000\000>\001p\000\000\001s\002m\003:\003V\000\000\000h\001T\000j\000\000\000s\000\212\000\000\000w\000w\000\213\000\000\000>\000\000\000\000\001|\000j\000\000\001\202\000\000\000\000\000\000\001\203\003!\000\000\001\202\004|\000\000\000\000\001\203\001_\000\000\001\141\000\238\000x\001\\\000\226\000\000\001]\000\000\000\174\000\000\000E\004}\004t\000j\000\000\000\000\000\000\000\000\000k\002\\\000\164\001D\000l\000y\000\000\000\000\000\000\000\000\000\160\001\216\001\200\001\223\000\000\001T\002a\000\000\000\000\000{\002b\000\164\001D\003(\000\000\001\217\000>\000\000\000u\000\000\002m\003n\003V\000\000\003)\000\000\000\000\000\000\002d\000\000\000\164\000\165\000\000\001_\000\000\002q\000>\000\000\001\\\000\000\005>\001]\004u\000\174\000\000\002f\003!\000\000\001\202\003W\000\000\003X\001\203\000\000\002\\\000\000\003<\001\216\000\227\000\000\003A\000\000\003N\001\232\001\216\002\143\002t\000\000\002\161\002a\000\239\001\217\000\000\002b\000\164\001D\003(\002u\001\217\001*\000\000\000\174\000\000\001\233\000\241\001\200\001\223\003)\001\234\000\000\000*\002d\001\235\000\164\001D\000\000\000\000\001\236\000\000\000>\000v\000\000\000\000\002m\003n\003V\001F\000\251\002f\000j\000\000\000\000\003W\002\145\003X\000\000\000\000\002\146\000\000\003<\000\000\000\000\000\000\003A\000w\003N\001\232\000\252\000\210\003!\000\231\001\202\000\253\000\000\000\000\001\203\000\254\002\\\000\000\001\233\000\000\000\255\001p\000\000\001s\000\000\001\233\001\216\001\200\001\223\000x\001\234\002a\001\242\004\148\001\235\002b\000\164\001D\003(\001\236\001\217\000>\003u\000\000\000\000\002m\003n\003V\000>\003)\000y\000j\005>\002d\000\212\000\163\000\164\001D\000\213\000\000\000\000\000\000\000h\004\160\000{\000\000\000q\000\000\005A\005e\002f\003!\000\000\001\202\003W\000\000\003v\001\203\000\000\000F\004\161\003<\004\164\004t\000\226\003A\000\000\003N\001\232\002\159\000\000\000\000\000\000\000\000\002\143\000\000\000\000\002\144\000\000\002\\\000\000\000\000\000\000\002\160\000\000\003\005\000j\003\019\001\233\001\216\000\000\000k\000\000\001\234\002a\000l\000\000\001\235\002b\000\164\001D\003(\001\236\001\217\000\000\003w\000\000\003P\000\000\001\200\001\223\000\000\003)\004|\000\000\000\000\002d\000\000\000j\000u\000>\004u\002\145\000>\003T\000\000\002\146\002m\003\148\003V\004}\004t\000\000\002f\000\000\000\000\000\000\003W\000\000\003v\0011\000\000\002\\\000\000\003<\000\000\000\227\000\000\003A\000\000\003N\001\232\001\216\003!\000\000\001\202\000\000\002a\000\000\001\203\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\003\137\000\164\005?\001\233\001\200\001\223\000\000\003)\001\234\000\000\004\225\002d\001\235\005A\005B\000\000\000\000\001\236\000>\003\150\000\000\004u\002m\003\148\003V\000\000\002\143\004\226\002f\002\168\004\229\004t\003W\000v\003v\000\000\000\000\000\000\000>\003<\000\000\000\000\000\000\003A\000\000\003N\001\232\000\252\003!\000\000\001\202\002\159\001\"\000\000\001\203\004|\000\000\000w\000\000\000\000\000\000\001\005\000\000\004\248\004\225\002\160\001\233\000\000\000\000\000\000\000j\001\234\004}\004t\002\145\001\235\002\\\000\000\002\146\000\000\001\236\004\226\003\152\000\150\004\229\004t\001\216\000\000\000\000\004u\000\000\002a\005{\000\164\000\165\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\000y\000\000\001\200\001\223\000\151\003)\000\000\000\000\000\152\002d\003\170\000\000\000\000\000\000\000{\000\000\000>\000\000\000\000\000\000\002m\003:\003V\000\000\000\000\000>\002f\004u\000\000\004\146\003W\000\000\003\151\001\200\001\223\002\\\000\000\003<\001\130\004u\000\174\003A\000\000\003N\001\232\001\216\003!\000>\001\202\000\000\002a\002m\001\203\003 \002b\000\164\001D\003(\000\000\001\217\000\000\000\210\000\000\000\229\001\233\000\000\000\000\002\159\003)\001\234\004\225\000\000\002d\001\235\000\000\000\164\001D\003!\001\236\001\202\000\000\002\160\000\000\001\203\000\000\000\000\000\000\004\226\005s\002f\004\229\004t\000\000\003W\004\255\003\151\001\200\001\223\000\000\000\000\003<\000\000\000\000\000\000\003A\000j\003N\001\232\000\212\004\020\000>\000\000\000\213\003\156\002m\000\000\003 \005}\000\000\000\000\000\000\005v\000\000\000\000\005w\002\143\000\174\001\233\002\168\000\000\000\000\000\000\001\234\004\225\000\000\000\000\001\235\002\\\000\226\004\144\003!\001\236\001\202\000\000\000\000\004|\001\203\001\216\005\007\004u\004\226\002\195\002a\004\229\004t\000\000\002b\000\164\001D\003(\000\000\001\217\004}\004t\000\000\002\202\000\164\000\165\002\\\002[\003)\000\000\004\"\002\145\002d\000\000\003\156\002\146\001\216\000\000\000\000\000\000\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\002f\001\217\000\000\000>\003W\000\000\003X\000\210\000\000\000\231\003)\003<\000\000\000\000\003\145\003A\004|\003N\001\232\000\000\000\000\004u\000\000\000\000\001\132\000\000\000\174\000\000\000\000\000\227\004u\002f\000\000\004}\004t\0037\003\147\000\000\001\233\000\000\002\\\000\000\003<\001\234\000\000\000\000\003A\001\235\003N\001\232\001\216\000j\001\236\000\000\000\212\002a\001Y\000\000\000\213\002b\000\164\001D\003(\002\187\001\217\000\000\000\000\005\n\000\000\001\233\001S\001\200\001\223\003)\001\234\000\000\000\000\003\145\001\235\002\159\002\223\002\224\002\226\001\236\000\226\000>\004|\000\000\002\190\002m\000\000\003 \004u\002\160\002f\000\000\000\000\000\000\0037\003\147\000\000\000\000\000\000\004}\004t\003<\004|\000\000\000\000\003A\000\000\003N\001\232\000\000\002\229\003!\000\000\001\202\000\000\000\000\002\193\001\203\004|\004}\004t\000\000\000\000\000\000\000\000\000\000\005\017\000\000\001\233\000\000\001\200\001\223\000\000\001\234\000\000\004}\004t\001\235\004\180\000\000\000\164\001D\001\236\004$\000>\000\000\000\000\003\156\002m\000\000\003 \000\000\000\210\001T\000\231\000\000\000\000\000\000\004u\002\195\000\000\000\000\000\227\000\000\000\000\000\000\000\000\000h\000\000\001\200\001\221\000q\000\000\002\196\003!\000\000\001\202\000\000\004u\000\000\001\203\001_\000\000\002\255\000\000\000\000\001\\\000\000\000\000\001]\004|\000\174\000\000\000\000\004u\000\000\000j\000\000\000\000\000\212\004\185\000\000\002\\\000\213\000\000\000\000\005N\004}\004t\000\000\003\156\000j\001\216\000j\000\000\001\202\000k\002a\000\000\001\203\000l\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\226\001=\000\252\001\200\001\223\000\000\003)\000\000\000\000\000\000\003\145\005V\000\000\000\000\000\000\000u\001\007\000>\000\000\000\000\000\000\002m\003:\003V\000\000\000\000\000\000\002f\000\000\000\000\000\000\0037\003\147\000\000\001\200\001\223\002\\\004u\003<\000\000\000\000\004\195\003A\000\000\003N\001\232\001\216\003!\000>\001\202\000\000\002a\002m\001\203\003 \002b\000\164\001D\003(\000\000\001\217\004\204\000\210\000\000\000\231\001\233\000\000\000\000\000\000\003)\001\234\000\000\000\000\003\145\001\235\000\000\000\000\004\202\003!\001\236\001\202\000\000\000\227\000\000\001\203\001\216\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\000\0037\003\147\000\000\000v\000\000\001\217\000\000\003<\000\000\000\000\000\000\003A\000j\003N\001\232\000\212\005\\\000\000\000\000\000\213\003\156\000\000\000\149\000\000\000\000\000\000\000\000\000w\000\000\000\000\000\000\000\000\002\143\000>\001\233\002\168\000\000\000\000\000\000\001\234\000\000\000\000\000\000\001\235\002\\\000\226\000\000\000\000\001\236\000\000\000\000\000\000\000\000\000\150\001\216\004\246\000\000\000\252\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\001\t\000\000\001\233\000y\002\\\002[\003)\000\151\000\000\002\145\002d\000\152\000\000\002\146\001\216\001Y\001\244\000{\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\002f\001\217\001S\000\000\003W\000\000\003X\000\000\000\000\000\000\003)\003<\000\000\000\000\003\145\003A\000\000\003N\001\232\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\227\000\000\002f\000\000\000\000\000\000\0037\003\147\000\000\001\233\000\000\000\000\000\000\003<\001\234\000\000\000\000\003A\001\235\003N\001\232\000\000\000\000\001\236\001\200\001\223\000\000\000\000\000\210\000\000\000\228\000\000\005\136\000\000\002\187\000\000\000\000\000\000\000>\000\000\001\233\000\000\002m\003:\003V\001\234\000\000\000\164\001D\001\235\002\159\002\223\005X\002\226\001\236\000\210\000\000\000\211\000\000\002\190\001T\000\000\000\000\000\000\002\160\003\165\001\200\001\223\003!\000\252\001\202\000\000\000j\000\000\001\203\000\212\000\000\000\000\000\000\000\213\000>\000\000\000\000\001\011\002m\002\229\003V\000\000\001_\000\000\003\n\002\193\000\000\001\\\000\000\000\210\001]\000\233\000\174\000j\000\000\000\000\000\212\000\000\000\000\000\226\000\213\000\000\000\000\000\000\003!\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000\000\000\000\000\000\000\000\002\143\000\000\005-\002\168\000\000\000\000\000\000\000\000\000\000\000\226\000\000\002\195\000\000\000\000\000\000\000\000\000j\001\200\001\223\000\212\000\000\000\000\000\000\000\213\000\000\002\196\000\000\000\000\003Z\000\000\000\000\000>\000\000\000\000\000\000\002m\002\\\003 \000\000\000\000\000\000\000\000\000\000\000\000\000j\000\000\001\216\000\000\002\145\000\226\000\000\002a\002\146\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\003!\000\000\001\202\000\227\000\000\000\000\001\203\000\000\003)\000\000\000\000\000\000\002d\002\143\000\000\000\000\002\168\002\\\000\000\000\000\000h\000\000\000\000\000\000\000q\000\000\000\000\001\216\000\000\002f\000\227\000\000\002a\003W\000>\003X\002b\000\164\001D\003(\003<\001\217\000\000\000\000\003A\000\000\003N\001\232\000\000\000\000\003)\000\000\000\000\000\000\003\167\000\000\000\000\002[\000\000\000\000\000\000\002\145\000\000\000\000\000j\002\146\000\000\001\233\000\000\000k\000\227\002f\001\234\000l\000\000\003W\001\235\003\169\000\000\000>\000\000\001\236\003<\000\000\002\159\000\000\003A\000\000\003N\001\232\000\000\002\\\000\000\000\000\000\000\000\000\005+\000u\002\160\000\000\000\000\001\216\000\000\000\000\000\000\000\000\002a\000\000\000\000\001\233\002b\000\164\001D\003(\001\234\001\217\000\000\000\000\001\235\000\251\001\200\001\223\000\000\001\236\003)\000\000\000\000\000\000\0035\000\000\000\000\003\031\001Y\000\000\000>\000\000\000\000\000\000\002m\000\252\003 \000\000\002\187\000\000\000\253\002f\001S\000\000\000\254\0037\0038\000\000\002\143\000\255\000\000\002\168\003<\000\000\002\159\000\000\003A\002\230\003N\001\232\003!\000\000\001\202\002\190\002\195\000\000\001\203\000\000\002\160\000\000\000\000\000\164\000\165\000\000\000\000\000v\000\000\000>\002\204\001\233\000\000\000\000\000\000\000\000\001\234\000\000\000\000\000\000\001\235\002\232\001\200\001\223\002[\001\236\000\191\002\193\002\145\000\000\000\000\000w\002\146\003;\000\000\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \000\000\000\000\000\000\000\000\000\000\000\164\001D\000\000\000\000\001.\000\000\000\174\000\000\000\000\000\150\000\000\000\000\000\000\001T\001Y\000\000\002\237\000\000\003!\000\000\001\202\000\000\002\195\000\000\001\203\000\000\000\000\000\000\001S\000\000\000y\000\000\000\000\000\000\000\151\002\\\002\196\000\000\000\152\000\000\000\000\001_\000\000\003/\000{\001\216\001\\\000\000\000\000\001]\002a\000\174\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\002\187\000\000\000\000\001\200\001\223\000\000\000\000\003)\000\000\000\000\000\000\0035\000\000\000\000\000\000\000\000\002\159\000>\000\000\002\230\000\000\002m\000\000\003 \000\000\002\190\000\000\000\000\002f\000\000\002\160\000\000\0037\0038\000\000\000\000\000\000\000\000\000\000\003<\000\000\000\164\001D\003A\000\000\003N\001\232\003!\002\\\001\202\000\000\002\232\000\000\001\203\001T\000\000\000\000\002\193\001\216\001\200\001\221\000\000\000\000\002a\000\000\000\000\001\233\002b\000\164\001D\003(\001\234\001\217\000\000\000\000\001\235\000\000\001\200\001\223\000\000\001\236\003)\001_\000\000\003E\0035\000\000\001\\\000\000\000\000\001]\000>\000\174\000\000\002\235\002m\000\000\003 \000\000\000\000\002\195\000\000\002f\000j\000\000\001\202\0037\0038\000\000\001\203\000\000\000\000\000\000\003<\002\196\000\000\000\000\003A\000\000\003N\001\232\003!\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000\000\000\000\000\000\001\200\001\223\000\000\000\000\000h\002\\\000\000\001\233\000s\000\000\000\000\000\000\001\234\000\000\000>\001\216\001\235\000\000\003\183\000\000\002a\001\236\000\000\000\000\002b\000\164\001D\003(\000\000\001\217\000\000\000\000\000\000\000\000\000\000\003y\000\000\004\n\003)\000\000\000\000\000\000\003r\000h\003\218\000\000\001\202\000}\000j\000\000\001\203\000\000\000\000\000k\000\000\000\000\000\000\000l\000\000\002f\000\000\000\000\000\000\0037\003t\000\000\003\224\000\000\000\000\000\000\003<\001\216\000\000\000\000\003A\000\000\003N\001\232\000\000\002\\\000\000\000u\000\000\000\000\000\000\001\217\000\000\000j\000\000\001\216\001\200\001\223\000k\000\000\002a\000\000\000l\001\233\002b\000\164\001D\003(\001\234\001\217\000>\000\000\001\235\000\000\002m\003q\003 \001\236\003)\000\000\000\000\000\000\003r\000h\000\000\000\000\000u\000}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002f\003!\000\000\001\202\0037\003t\000\000\001\203\000\000\000\000\000\000\003<\001\216\000\000\000\000\003A\000\000\003N\001\232\000\000\001\233\000\000\000\164\001D\003\225\000\000\001\217\000\000\000j\000\000\000v\001\200\001\223\000k\001\246\003\226\000\000\000l\001\233\003\238\000\000\000\000\000\000\001\234\000\000\000>\000\000\001\235\000\000\002m\000\000\003 \001\236\000\000\000w\000\000\000h\000\000\000\000\000\000\000q\000u\000\000\000\000\000>\000\000\000\000\003\240\000\000\000v\000\000\003\245\000\000\003\252\001\232\003!\000\000\001\202\000\000\000\000\000x\001\203\000\000\000\000\000\000\000\000\000\000\000\000\000\210\000\000\000\233\000\000\002\\\000w\001\233\000\000\000\000\000\000\000\000\001\234\000j\000y\001\216\001\235\000\000\000k\000\235\002a\001\236\000l\000\000\002b\000\164\001D\003(\000{\001\217\001Y\000\000\000\146\000\000\003\133\000\000\000\000\000\000\003)\000\000\000\000\000\000\003\134\000h\001S\000j\000u\000q\000\212\000\000\000\000\000\000\000\213\000y\000\000\000\000\000v\000\000\000\000\002f\000\000\000\000\000\000\0037\003\136\000\000\000\000\000\128\000\000\000\000\003<\000\000\000\000\000\000\003A\000\000\003N\001\232\000\226\002\\\000w\000\000\000\000\000\000\000\000\000\000\000\000\000j\000\000\001\216\001\200\001\223\000k\000\000\002a\000\000\000l\001\233\002b\000\164\001D\003(\001\234\001\217\000>\000\000\001\235\000\000\002m\003\131\003 \001\236\003)\000\000\000\000\000\000\003r\000\000\000\164\001D\000u\000\000\000\000\000\000\000\000\000\000\000\000\000y\000v\000\000\000\000\001T\000\000\002f\003!\000\000\001\202\0037\003t\000\000\001\203\000\130\000\000\000\000\003<\000\000\000\000\000\149\003A\000\000\003N\001\232\000w\000\000\000\000\000\000\000\000\000\000\000\000\001_\000\227\003\196\000\000\000\000\001\\\000\000\000\000\001]\000\000\000\174\003\144\001\233\000\000\001\200\001\223\000\000\001\234\000\000\000\150\000\000\001\235\000\000\000\000\000\000\000\000\001\236\000\249\000>\000\000\000\000\000\000\002m\002\242\003 \000\000\000\000\000\000\000\000\000\000\000y\000\000\000\000\000v\000\151\001\200\001\223\000\000\000\152\000\000\000\251\000\000\000h\000\000\000{\005R\000}\000\000\003!\000>\001\202\000\000\002\183\002m\001\203\003 \002\\\000w\000\000\000\000\000\252\000\000\000\000\000\000\000\000\000\253\001\216\000\000\000\000\000\254\000\000\002a\000\000\000\000\000\255\002b\000\164\001D\003(\003!\001\217\001\202\000\000\000\150\003\149\001\203\000j\000\000\000\000\003)\000\000\000k\000\000\003\145\000\000\000l\000\000\000\000\000\000\000\000\000\210\000\000\000\233\000\000\000y\000\000\000\000\000\000\000\151\000\000\002f\000\000\000\152\000\000\0037\003\147\000\000\000\000\000{\000u\000\000\003<\000\000\001\200\001\223\003A\000\000\003N\001\232\000\000\000\000\000\000\000\000\005^\000\000\000\000\000\000\000>\000\000\002\\\000\000\002m\000\000\003 \000j\000\000\000\000\000\212\001\233\001\216\000\000\000\213\000\000\001\234\002a\000\000\000>\001\235\002b\000\164\001D\003(\001\236\001\217\000\000\000\000\000\000\003!\000\000\001\202\002\\\000\000\003)\001\203\000\000\000\000\003\145\000\226\000\000\000\000\001\216\000\000\000\000\000\000\000\000\002a\000\000\000\000\000\000\002b\000\164\001D\003(\002f\001\217\000\000\000\000\0037\003\147\000\000\000\000\000v\000\000\003)\003<\000\000\000\000\005S\003A\001Y\003N\001\232\000\000\000\000\000\000\000\000\000h\000\000\000\000\000\000\000s\000\000\000\000\001S\002f\000w\000\000\000\000\0037\005U\000\000\001\233\000\000\000\000\000\000\003<\001\234\001\200\001\223\003A\001\235\003N\001\232\000\000\000\000\001\236\000\000\005a\000\000\000\000\000\000\000>\000\000\000\000\000\000\002m\000\000\003 \002\\\000\227\000j\000\000\001\233\001\200\001\221\000k\000\000\001\234\001\216\000l\000\000\001\235\000y\002a\000\000\000\000\001\236\002b\000\164\001D\003(\003!\001\217\001\202\000\000\004*\000\132\001\203\000\000\000\000\000\000\003)\000\000\000u\000\000\005S\000\000\000\164\001D\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\000\251\001\202\001T\000\000\002f\001\203\000\000\000\000\0037\005U\000\000\000\000\000\000\000\000\000\000\003<\000\000\000\000\000\000\003A\000\252\003N\001\232\000\000\000\000\000\253\000\000\000\000\000\000\000\254\001_\000\000\003\232\000\000\000\255\001\\\000\000\000\000\001]\000\000\000\174\000\000\001\233\001\200\001\223\000\000\000\000\001\234\000\000\000\000\000h\001\235\000\000\000\000\000s\000\000\001\236\000>\000\000\000\000\000\000\003\183\000h\000\000\002\\\000\000\000q\000v\000\000\000\000\000\000\000\000\000\000\000\000\001\216\000\000\000>\000\000\000\000\002a\003\215\000\000\000\000\002b\000\164\001D\003(\003\218\001\217\001\202\000\000\000w\000\000\001\203\000j\000\000\000\000\003)\000\000\000k\001\216\005S\000\000\000l\000\000\000\000\000j\000\000\000\000\003\224\000\000\000k\000\000\000\000\001\217\000l\000\000\000x\002f\000\000\000\000\000\000\0037\005U\000\000\000\000\000\000\000u\000\000\003<\000h\001\200\001\223\003A\000}\003N\001\232\004\006\000y\000u\001\228\000\000\001 \000\237\000\000\000>\000\000\000\000\000\000\003\183\000\000\000\000\000{\000\000\000\000\000\000\001\233\000\000\000\000\000\000\000>\001\234\000\000\000\000\000\000\001\235\000\000\000\000\003\217\000\000\001\236\000\000\000\000\000\000\000j\003\218\000\000\001\202\000\000\000k\000\000\001\203\001\233\000l\000\000\000\210\000\000\000\231\001\216\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\248\003\224\000\164\001D\003\225\000\000\001\217\000\000\000\000\000\000\000\000\000u\000\000\000v\000\000\003\226\000\000\001Y\000\210\004\008\000\231\000\164\000\165\000\000\000h\000v\000\000\000\000\000q\000\000\000\000\001S\000\000\000j\000\000\000\000\000\212\000w\000>\000\000\000\213\000\168\000\169\000\171\000\172\000\000\000\000\003\240\000\000\000w\000\000\004\t\000\000\003\252\001\232\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000j\000x\000\000\000\212\000\226\000h\000j\000\213\000\173\000q\000\174\000k\001\233\000\150\000\000\000l\000\000\001\234\001\216\000>\000\000\001\235\000y\000\000\000\000\000\000\001\236\001\225\000\164\001D\003\225\000v\001\217\000\226\000y\000\000\000{\000\000\000\151\000u\000\000\003\226\000\152\000\164\001D\003\238\000\000\000\000\000{\000j\000\179\000\000\000\000\000\000\000k\000w\001T\000\000\000l\000h\000\000\000\000\000\000\000s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\240\000\000\000\000\000\000\003\245\000\000\003\252\001\232\000h\000u\000\000\001[\000q\000\227\000\000\000\000\001\\\000\000\000\000\001]\000\000\000\174\000>\000\000\000\000\000\000\000\000\001\233\000\000\000y\000j\000\000\001\234\000\000\000\000\000k\001\235\000\000\000\000\000l\000\000\001\236\000\227\000\134\000\164\000\165\000\000\000\000\000v\000\000\000\000\000\000\000j\000\000\000\000\000\000\000\000\000k\000\000\000\000\000\000\000l\000\000\000u\000\168\000\217\000\171\000\172\000\000\000\000\000\000\000\000\000w\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\252\000\000\000\000\000u\000\000\000\164\000\165\000\000\000\000\000v\000\000\000\173\000\000\000\174\001\013\000\000\000\150\000\000\000h\000\000\001\200\001\221\000q\000\000\000\000\000\168\001\207\000\171\000\172\000\252\000h\000\000\000>\000w\000}\000\000\000\000\000y\000\000\000\000\000\000\000\151\000\000\001\015\000\000\000\152\000\000\000\000\000\000\000\000\000\000\000{\000\000\000\179\000\173\000\000\000\174\000\000\000\000\000\150\000\000\000h\000j\000v\000j\000q\001\202\000k\000\000\000\000\001\203\000l\000\000\000\000\000j\000>\001\200\001\221\000\000\000k\000y\000\164\000\165\000l\000\151\000v\000\000\000w\000\152\000\000\000\000\000\000\000\000\000\000\000{\000u\000\179\000\000\000\210\000\000\000\231\000\168\002^\000\171\000\172\000j\000\000\000u\000\000\000w\000k\000\000\000\000\000x\000l\000\000\000\000\000\000\000\000\000\000\000j\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000\000\000\173\000\000\000\174\000\000\000y\000\150\000\000\000h\000u\001\227\000\000\000q\000j\000\000\000\000\000\212\000\000\000\000\000{\000\213\000\000\000>\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\151\000\000\000\000\000\000\000\152\001\216\000\000\000\000\000\000\000\000\000{\000\000\000\179\000\164\000\165\000\226\000\000\000v\000\000\001\217\000\000\000j\000\000\000\000\000\000\000\000\000k\000\000\000\000\000v\000l\000\000\000\000\000\168\002\150\000\171\000\172\000\000\000\000\000\000\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\000w\000u\000\000\000\164\000\165\000\000\000\000\000v\001\216\000\173\000\000\000\174\000\000\000\000\000\150\000\000\000h\000\000\000\000\000\000\000q\000\000\001\217\000\168\003>\000\171\000\172\000\000\000h\000\000\000>\000w\000q\000\000\001\233\000y\000\000\000\000\000\000\000\151\000\000\000\000\000>\000\152\000\227\000\000\000\000\000y\001\250\000{\000\000\000\179\000\173\000\000\000\174\000\000\000\000\000\150\000\000\000\000\000j\000\136\000h\000\000\000\000\000k\000q\000\000\000\000\000l\000\000\000\000\000j\000\000\000\000\000\000\000\000\000k\000y\000\164\000\165\000l\000\151\000v\000\000\000\000\000\152\000\000\000\000\000\000\001\233\000\000\000{\000u\000\179\000\000\001\200\001\221\000\000\000\168\003\242\000\171\000\172\000\000\001\252\000u\000j\000w\000h\000\000\000\000\000k\000q\000\252\000\000\000l\000\000\000\000\000\000\000\000\000h\000\000\000>\000\000\000q\001\021\000\000\001\017\000\173\000\000\000\174\000\000\000\000\000\150\000>\000\000\000\000\000\000\000\000\000u\000j\000\000\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000h\000\000\000\000\000j\000}\000y\000\000\000\000\000k\000\151\001\200\001\223\000l\000\152\000\000\000j\000\000\000\000\000\000\000{\000k\000\179\000\164\000\165\000l\000\000\000v\000\000\000\000\000\000\002T\003k\000\000\000\000\000\164\000\165\000u\000\000\000v\000\000\000\000\000\000\000\000\000\000\000j\000\194\000\000\000\000\000u\000k\000w\000h\000\000\000l\002[\000q\001\202\000\194\000\000\000\000\001\203\000\000\000w\000\000\000\000\000>\000\000\000\000\000\000\000\000\000\000\000\196\000v\000\174\000\000\000\000\000\150\000u\000\000\000\000\000\000\000\000\000\000\0014\000\000\000\174\000\000\000\000\000\150\000\000\000\000\000\149\001\216\000\000\000\000\000j\000w\000y\000\000\000\000\000k\000\151\000\000\000\000\000l\000\152\001\217\000\000\000\000\000y\000\000\000{\000\000\000\151\000\164\000\165\000\000\000\152\000v\000\000\000\000\000\000\000\150\000{\000\000\000\000\000\164\000\165\000u\000\000\000v\000\000\000\000\000\000\000\000\000\000\000\000\000\191\000\000\000\000\000\000\000\000\000w\000y\000\000\002\\\000\000\000\151\000\000\001\183\000\000\000\152\001\200\001\223\000w\001\216\000\000\000{\000\000\000v\002a\000\000\000\000\001:\002b\000\174\000\000\000\000\000\150\001\217\000\000\000\000\002T\003a\001\233\001\185\000\210\000\174\000\231\000\000\000\150\000\000\002d\000w\000\000\000\000\000\000\000\000\001\254\000y\000\000\000\000\000\000\000\151\000\000\000\000\002[\000\152\001\202\002f\000\000\000y\001\203\000{\000\000\000\151\000\164\000\165\000\000\000\152\000v\000\000\000\000\000\000\000\000\000{\000\000\001\232\001\200\001\223\000j\000\000\000\000\000\212\000\000\000\000\000\000\000\213\000\000\001\183\000y\000\000\000\000\000\000\000w\000\000\000\000\001\233\002T\002U\000\000\000\000\001\234\000\000\000\138\000\000\001\235\000\000\000\000\000\000\000\000\001\236\000\000\000\226\000\000\002\012\000\000\000\174\000\000\000\000\000\150\000h\002[\000h\001\202\000q\000\000\000}\001\203\000\000\000\000\000\000\000\000\000\000\000\000\000>\000\000\000\000\000\000\001\200\001\223\000y\000\000\000\000\000\000\000\151\000\000\002\\\000\000\000\152\000\000\000\000\000\000\000\000\000\000\000{\000\000\001\216\000\000\002T\002`\000\000\002a\000\000\000\000\000j\002b\000j\000\000\000\000\000k\001\217\000k\000\000\000l\000\000\000l\000h\000h\000\000\000\000\000}\000q\002[\002d\001\202\000\000\000\000\000\000\001\203\000\000\000\000\000>\000\000\000\000\000\227\000\000\000\000\000u\000\000\000u\002f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\\\000\210\000\000\000\231\000\000\000\000\001\232\000\000\000j\000j\001\216\000\000\000\000\000k\000k\002a\000\000\000l\000l\002b\000\000\000\000\000\000\000\000\001\217\000\000\001\233\000\000\000\000\000\000\000\210\001\234\000\233\000\000\000\000\001\235\000\000\002d\001\200\001\223\001\236\000u\000u\000\000\000\000\000j\000\000\000\000\000\212\000\000\000\000\000\252\000\213\000\000\002f\000\000\000\000\000\000\002T\003m\000\000\002\\\000\000\000\164\000\165\001\019\000\000\000v\000\000\000v\000\000\001\216\001\232\000\000\000j\000\000\002a\000\212\000\226\000\000\002b\000\213\002[\000\000\001\202\001\217\002\127\000\000\001\203\000\000\000\000\000w\001\233\000w\000\000\000\000\000\000\001\234\002d\000\000\000\000\001\235\000\000\000\000\000\000\000\000\001\236\000\226\000\000\000\000\000\000\000\000\002\129\000\000\000\174\002f\000\000\000\150\000\000\000\000\000\164\000\165\000\000\000v\000v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\232\000\000\000\000\001\200\001\223\000y\000\000\000y\000\000\000\151\002\127\000\000\000\000\000\152\000w\000w\000\000\000\000\000\000\000{\001\233\000\140\000\000\002T\0044\001\234\000\000\000\227\000\000\001\235\000\000\000\000\000\000\000\000\001\236\000\000\002\166\000\000\000\174\000\000\002\\\000\150\001\200\001\221\000\000\001\200\001\223\002[\000\000\001\202\001\216\000\000\000\000\001\203\000\000\002a\000\227\000\000\000\000\002b\000\000\000y\000y\000\000\001\217\003d\000\151\000\000\000\000\000\000\000\152\000\000\000\000\000\000\000\000\000\142\000{\002d\001\200\001\223\000\000\000\000\004,\000\000\000\000\000\000\000j\000\000\001\202\002[\000\000\001\202\001\203\000\000\002f\001\203\000\252\000\000\002T\0046\000\000\000\000\000\000\000\000\000\000\000\251\001\200\001\223\000\000\000\000\001\025\000h\001\232\000\000\000h\000q\000\000\000\000\000q\000\000\000\000\000\000\002[\000\000\001\202\000\252\002T\0048\001\203\000\000\000\253\000\000\001\233\000\000\000\254\000\000\000\000\001\234\002\\\000\255\000\000\001\235\000\000\000\000\000\000\000\000\001\236\000\000\001\216\000\000\002[\000\000\001\202\002a\000\000\000j\001\203\002b\000j\000\000\000k\000\000\001\217\000k\000l\000\000\000\000\000l\000\210\000\000\000\231\000\000\000\000\000\000\002\002\002d\000\000\0029\000h\000\000\002\\\000\000\000q\000\000\000\000\000\000\000\000\001\216\000u\000\000\001\216\000u\002f\000\000\000h\002a\000\000\000\000\000q\002b\000\000\001\217\000\000\000\000\001\217\000h\000\000\000\000\000\000\000q\001\232\000\000\000j\002\\\000\000\000\212\000\000\002d\000\000\000\213\000\000\000\000\000j\001\216\000\000\000\000\000\000\000k\002a\000\000\001\233\000l\002b\000\000\002f\001\234\000\000\001\217\000j\001\235\000\210\002\\\000\233\000k\001\236\000\226\000\000\000l\000\000\000j\002d\001\216\001\232\000\000\000k\000u\002a\002;\000l\000\000\002b\000\000\000h\000\000\000\000\001\217\000q\002f\002=\001\233\000v\000u\001\233\000v\000\000\000\000\002|\001\234\002d\000\000\000\000\001\235\000u\002\000\000j\001\232\001\236\000\212\000\000\000\149\000\000\000\213\000\149\000\000\000w\002f\000\000\000w\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\233\000j\000\000\000\000\000\000\001\234\000k\000\000\001\232\001\235\000l\000\210\000\226\000\233\001\236\000\150\000h\000\000\000\150\000\000\000q\000\000\000\227\000\000\000\000\000\000\000\000\000h\001\233\000\000\000\000\000q\000v\001\234\000u\000\000\000y\001\235\000\000\000y\000\151\000\000\001\236\000\151\000\152\000\000\000\000\000\152\000v\000\000\000{\001\"\000\000\000{\000\000\000j\000w\000\000\000\212\000v\000j\000\000\000\213\000\000\000\000\000k\000\000\000\149\000\000\000l\002\143\000j\000w\002\168\000\000\000\000\000k\000\000\000\149\000\000\000l\000\000\000\150\000w\000\000\000\000\000\000\000\000\000\226\000\000\000\000\000\252\000h\000u\000\227\000\000\000q\000\000\000\150\000\000\000\000\000\000\000\000\000y\000u\001\027\002\181\000\151\000\000\000\150\000\000\000\152\000\000\000\000\000j\000\000\000v\000{\002\145\000y\004.\000\000\002\146\000\151\000\000\000\000\000\000\000\152\000\000\000\000\000y\000\000\000\000\000{\000\151\002\183\000j\000\000\000\152\000\000\000w\000k\000\000\000\251\000{\000l\000\000\000\000\000\000\000h\000\000\000\000\000\000\000q\000\000\000\000\000\000\000\000\000\000\000\000\000h\000\000\000\000\000\252\000q\003\003\000\150\000\000\000\253\000u\000\227\000\000\000\254\000\000\000\000\000v\003\015\000\255\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000v\000y\000\000\000\000\000\000\000\151\000\000\000j\002\183\000\152\004>\000\000\000k\000w\000\000\000{\000l\000h\000j\002\183\000\000\000q\000\000\000k\000w\000\000\000\000\000l\000h\002\159\000\000\000\000\000q\000\251\000\000\000\000\000\000\000\000\000\000\000\150\000u\000\000\000\000\002\160\000h\000\000\000\000\000\000\000}\000\000\000\150\000u\000\000\000\252\000\000\003\023\000\000\000\000\000\253\000\000\000y\000j\000\254\000\000\000\151\000v\000k\000\255\000\152\000\000\000l\000y\000j\000\000\000{\000\151\000h\000k\000\000\000\152\000q\000l\000\000\000\000\002\183\000{\000\000\000\000\000j\000w\000\000\000\000\000\000\000k\000u\000\000\000\000\000l\000h\000\000\000\000\000\000\000q\000\000\000\000\000u\000\000\000\000\000\000\000\000\000\000\005%\003$\002\195\000h\000\150\000\000\000\000\000q\000\000\000j\000u\000v\0033\000\000\000k\000\000\002\206\000\000\000l\000\000\000\000\000\000\000v\000\000\000\000\000y\000\210\000\000\000\231\000\151\002\183\000j\000\000\000\152\000\000\000w\000k\000\000\000\000\000{\000l\002\183\000u\000\000\000\000\000\000\000w\000j\000\000\000\000\000\000\000\000\000k\000\000\000\000\003J\000l\000\000\000\000\000\000\002\143\000\150\000\000\002\168\000u\000v\003R\000\000\000\000\000\000\000j\000\000\000\150\000\212\000\000\000\000\000v\000\213\000\000\000h\000u\000h\000y\000q\002\183\000q\000\151\000\000\000\000\000w\000\152\000\000\000v\000y\000\000\002\183\000{\000\151\000\000\000\000\000w\000\152\000\000\000\226\000j\000\000\000\000\000{\002\145\000\000\000\000\000\000\002\146\000\000\003\188\000\150\000w\000\000\000\000\000\000\000\000\000\000\000\000\000j\000v\000j\000\150\000h\000k\000\000\000k\000q\000l\000\000\000l\000\000\000y\000\000\000h\000\000\000\151\000\000\000q\002\183\000\152\000\000\000v\000y\000w\000h\000{\000\151\003\200\000q\000\000\000\152\000u\000\000\000u\000\000\000\000\000{\000v\000y\000\000\0052\000\000\000\000\000\000\000\000\000w\000j\000\000\000\000\000\150\000\000\000k\000\144\000\000\000\000\000l\002\183\000j\000\000\000\000\000\227\000w\000k\000\000\000\000\000\000\000l\000\000\000j\000\000\000y\000\150\000\000\000k\000\151\000\000\000\000\000l\000\152\000u\002\159\000\000\000h\000\000\000{\000\000\000q\000\150\000\000\000h\000u\000\000\000y\000q\002\160\000\000\000\151\000\000\000\000\000\000\000\152\000u\005\151\003\206\000\000\003\213\000{\000\000\000y\000\000\000\000\000\000\000\151\000v\000\000\000v\000\152\000\000\000\000\000\000\000\000\000\000\000{\000\000\000\000\000\000\000j\000\000\000\000\000\252\000\000\000k\002\183\000j\002\183\000l\000\000\000w\000k\000w\000\000\000\000\000l\001\029\000\000\002\143\000\000\000\000\002\168\000\000\000\000\003\222\000\000\000\000\000\000\001\200\001\221\000\000\000\000\000u\000\000\000v\003\236\000\150\002\195\000\150\000u\000\000\000\000\000\000\001\200\001\221\000v\003\250\000\000\000h\000\000\000\000\002\208\000q\002\183\000\000\000\000\000v\000y\000w\000y\000\000\000\151\000j\000\151\002\183\000\152\002\145\000\152\000\000\000w\002\146\000{\000j\000{\001\202\002\183\000\000\000\000\001\203\000\000\000w\000\000\000\000\000\000\000\150\000\000\000\000\000j\000\000\001\202\000h\000\000\000j\001\203\000q\000\150\000\000\000k\000\000\000\000\000\000\000l\000\000\000\000\004\001\000y\000\150\000h\000\000\000\151\000\000\000q\000\000\000\152\000v\000\000\000y\000\000\000\000\000{\000\151\000v\000\000\000\000\000\152\000u\000\000\000y\000\000\000\000\000{\000\151\000\000\002\183\000j\000\152\001\200\001\221\000w\000k\0052\000{\000\000\000l\000\000\000w\000\000\000\000\000\000\000\000\000\210\000j\000\233\000\000\000\000\000\000\000k\000\000\000\000\000\000\000l\000\000\000\000\002\159\000\150\000\000\000h\000u\000\000\000\000\000q\000\150\002\143\001\216\000\000\002\168\000\000\002\160\000\000\000h\000j\000\000\001\202\000q\000u\000y\001\203\001\217\001\216\000\151\000\000\000\000\000y\000\152\000j\000\000\000\151\000\212\000\000\000{\000\152\000\213\001\217\000\000\000\000\000\000\000{\000v\000\000\000\000\000j\000\000\000\000\000\000\000\000\000k\000j\000\000\000\000\000l\002\145\000\000\000\000\000j\002\146\000\000\000\183\000\226\000k\000\000\000\000\000w\000l\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000h\000\000\000\000\002\195\000q\000v\000\000\000\000\000\000\000\000\000\000\001\233\000u\000\150\000\000\000h\000\000\002\210\000\000\000q\000\000\000\000\000v\000\000\000\220\002\006\001\233\000\000\000\000\000w\000\000\000\000\000\000\000\000\000y\000\000\000\000\001\216\000\151\000\000\002\008\000\245\000\152\000\000\000j\000\000\000w\000\000\000{\000k\000\000\001\217\000\000\000l\000\000\000\150\000\000\000\000\000\000\000j\000\000\000\000\000\000\000\000\000k\000\227\000\000\000\000\000l\000\000\000\000\000\000\000\150\002\159\000\000\000\000\000y\000u\000\000\000\000\000\151\000v\000\000\000\000\000\152\000\000\000\000\002\160\000\000\000\000\000{\004M\000u\000y\000v\000\000\000\000\000\151\000h\000\000\001$\000\152\000q\000\000\000\000\000w\002\143\000{\000\000\002\168\000\000\000\000\000\000\001\170\000\251\000\000\000\000\000\000\000w\001\233\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000h\000\000\000\000\000\150\000q\002\n\000\252\000\000\000\000\000\000\000\000\000\253\000\000\000h\000j\000\254\000\150\000q\000\000\000k\000\255\000\000\000j\000l\000y\000\000\002\145\000\000\000\151\002\195\002\146\000v\000\152\000\000\000\000\000\000\002\143\000y\000{\002\168\000\000\000\151\000\000\002\212\000j\000\152\000v\000u\000\000\000k\001\174\000{\000\000\000l\000\000\000w\000\000\000j\000\000\000h\000\000\000\000\000k\000q\000\000\001\210\000l\000\000\000\000\000h\000w\000\000\000\000\000}\000\000\000\000\000\000\000u\000\000\000\000\000j\000\150\000\000\000\000\002\145\000\000\000\000\000\000\002\146\000h\000u\000h\000\000\000q\000\000\000q\000\150\000\000\000\000\000\000\000\000\000\000\000y\000j\000\000\000\000\000\151\000h\000k\000\000\000\152\000q\000l\000j\000\000\000\000\000{\000y\000k\000\000\000\000\000\151\000l\002\159\000\000\000\152\000\000\000\000\000\000\000v\000\000\000{\000\000\000j\000\000\000j\000u\002\160\000k\000\000\000k\000\000\000l\000\000\000l\000\000\000u\000\000\002\017\002\143\000\000\000j\002\168\000w\000\000\000\000\000k\000\000\000\000\000v\000l\000\000\000\000\000\000\000\000\000\000\000u\000\000\000u\000\000\000\000\000\000\000v\000\000\000\000\000\000\000\000\000\000\002\022\000\150\000\000\002\159\000\000\000w\000u\000\000\000\000\000\000\000\000\000\000\000\000\002\026\000\000\000j\000\000\002\160\000w\002\145\000\000\000\000\000y\002\146\000\000\000\000\000\151\000\000\000\000\002\195\000\152\000\150\002\143\000h\000\000\002\168\000{\000q\000\000\000\000\000v\000\000\000\000\002\214\000\150\000\000\000\000\000\000\000\000\000h\000v\000h\000y\000q\000\000\000q\000\151\000\000\000\000\0021\000\152\000\000\000\000\000\000\000w\000y\000{\000\000\000\000\000\151\000v\000\000\000v\000\152\000w\000\000\000j\000j\000\000\000{\002\145\000\000\000k\000\000\002\146\000\000\000l\002\195\000v\002X\000\150\002\153\000\000\000j\000w\000j\000w\000\000\000k\000\000\000k\002\216\000l\000\000\000l\000\000\000\000\002\171\000\000\000h\000u\000y\000w\000}\000\000\000\151\002\159\000\000\000\000\000\152\000\150\000y\000\150\000\000\000\000\000{\000u\000h\000u\000\000\002\160\000}\000\000\000\000\000\000\000\154\000\000\002\143\000\150\000\000\002\168\000y\000\000\000y\000\000\000\151\000\000\000\151\000\000\000\152\000\000\000\152\000\000\000j\000\000\000{\000\000\000{\000k\000y\000\000\000\000\000l\000\151\000\000\000\000\000\000\000\152\000\000\000\000\000\000\000j\000\000\000{\000\000\000\000\000k\002\159\000\000\000\000\000l\000j\000\000\000\000\000\000\002\145\000u\000\000\000\000\002\146\000\000\002\160\000v\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\195\000\000\000\000\000\000\000u\000\000\000\000\000\000\000v\000\000\000v\002\173\000\000\000\000\002\218\000\000\000w\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\176\000\000\004\024\000\000\000\000\000w\000\000\000w\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\150\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\150\000\000\000\150\002\195\000\000\000y\000\000\000\000\000\000\000\151\000v\000\000\000\000\000\152\000\000\000\000\000\000\002\220\000\000\000{\000\000\000y\000\000\000y\002\159\000\151\000\000\000\151\000v\000\152\000\000\000\152\000\000\000\000\000w\000{\000\000\000{\002\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\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\156\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\195\000\000\000\000\000\000\000\000\000\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\222")) let semantic_action = [| @@ -1505,9 +1519,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_aexpr = -# 1740 "parser_cocci_menhir.mly" +# 1752 "parser_cocci_menhir.mly" ( Ast0.set_arg_exp _1 ) -# 1511 "parser_cocci_menhir.ml" +# 1525 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1526,14 +1540,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 65 "parser_cocci_menhir.mly" +# 66 "parser_cocci_menhir.mly" (Parse_aux.list_info) -# 1532 "parser_cocci_menhir.ml" +# 1546 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_aexpr = -# 1742 "parser_cocci_menhir.mly" +# 1754 "parser_cocci_menhir.mly" ( let (nm,lenname,pure,clt) = _1 in let nm = P.clt2mcode nm clt in let lenname = @@ -1541,7 +1555,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct Some nm -> Some(P.clt2mcode nm clt) | None -> None in Ast0.wrap(Ast0.MetaExprList(nm,lenname,pure)) ) -# 1545 "parser_cocci_menhir.ml" +# 1559 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1563,9 +1577,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_aexpr = -# 1750 "parser_cocci_menhir.mly" +# 1762 "parser_cocci_menhir.mly" ( Ast0.set_arg_exp(Ast0.wrap(Ast0.TypeExp(_1))) ) -# 1569 "parser_cocci_menhir.ml" +# 1583 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1585,9 +1599,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_any_strict = -# 1794 "parser_cocci_menhir.mly" +# 1806 "parser_cocci_menhir.mly" ( Ast.WhenAny ) -# 1591 "parser_cocci_menhir.ml" +# 1605 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1607,9 +1621,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_any_strict = -# 1795 "parser_cocci_menhir.mly" +# 1807 "parser_cocci_menhir.mly" ( Ast.WhenStrict ) -# 1613 "parser_cocci_menhir.ml" +# 1627 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1629,9 +1643,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_any_strict = -# 1796 "parser_cocci_menhir.mly" +# 1808 "parser_cocci_menhir.mly" ( Ast.WhenForall ) -# 1635 "parser_cocci_menhir.ml" +# 1649 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1651,9 +1665,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_any_strict = -# 1797 "parser_cocci_menhir.mly" +# 1809 "parser_cocci_menhir.mly" ( Ast.WhenExists ) -# 1657 "parser_cocci_menhir.ml" +# 1671 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1675,9 +1689,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1242 "parser_cocci_menhir.mly" +# 1253 "parser_cocci_menhir.mly" ( _1 ) -# 1681 "parser_cocci_menhir.ml" +# 1695 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1707,17 +1721,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 1713 "parser_cocci_menhir.ml" +# 1727 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1244 "parser_cocci_menhir.mly" +# 1255 "parser_cocci_menhir.mly" ( P.arith_op Ast.Mul _1 _2 _3 ) -# 1721 "parser_cocci_menhir.ml" +# 1735 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1747,17 +1761,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 96 "parser_cocci_menhir.mly" +# 97 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 1753 "parser_cocci_menhir.ml" +# 1767 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1246 "parser_cocci_menhir.mly" +# 1257 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 1761 "parser_cocci_menhir.ml" +# 1775 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1787,17 +1801,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 1793 "parser_cocci_menhir.ml" +# 1807 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1248 "parser_cocci_menhir.mly" +# 1259 "parser_cocci_menhir.mly" ( P.arith_op Ast.Plus _1 _2 _3 ) -# 1801 "parser_cocci_menhir.ml" +# 1815 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1827,17 +1841,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 1833 "parser_cocci_menhir.ml" +# 1847 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1250 "parser_cocci_menhir.mly" +# 1261 "parser_cocci_menhir.mly" ( P.arith_op Ast.Minus _1 _2 _3 ) -# 1841 "parser_cocci_menhir.ml" +# 1855 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1867,17 +1881,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 95 "parser_cocci_menhir.mly" +# 96 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 1873 "parser_cocci_menhir.ml" +# 1887 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1252 "parser_cocci_menhir.mly" +# 1263 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 1881 "parser_cocci_menhir.ml" +# 1895 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1907,17 +1921,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 94 "parser_cocci_menhir.mly" +# 95 "parser_cocci_menhir.mly" (Ast_cocci.logicalOp * Data.clt) -# 1913 "parser_cocci_menhir.ml" +# 1927 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1254 "parser_cocci_menhir.mly" +# 1265 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.logic_op op _1 clt _3 ) -# 1921 "parser_cocci_menhir.ml" +# 1935 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1947,17 +1961,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 1953 "parser_cocci_menhir.ml" +# 1967 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1256 "parser_cocci_menhir.mly" +# 1267 "parser_cocci_menhir.mly" ( P.logic_op Ast.Eq _1 _2 _3 ) -# 1961 "parser_cocci_menhir.ml" +# 1975 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -1987,17 +2001,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 1993 "parser_cocci_menhir.ml" +# 2007 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1258 "parser_cocci_menhir.mly" +# 1269 "parser_cocci_menhir.mly" ( P.logic_op Ast.NotEq _1 _2 _3 ) -# 2001 "parser_cocci_menhir.ml" +# 2015 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2027,17 +2041,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 92 "parser_cocci_menhir.mly" +# 93 "parser_cocci_menhir.mly" (Data.clt) -# 2033 "parser_cocci_menhir.ml" +# 2047 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1260 "parser_cocci_menhir.mly" +# 1271 "parser_cocci_menhir.mly" ( P.arith_op Ast.And _1 _2 _3 ) -# 2041 "parser_cocci_menhir.ml" +# 2055 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2067,17 +2081,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 90 "parser_cocci_menhir.mly" +# 91 "parser_cocci_menhir.mly" (Data.clt) -# 2073 "parser_cocci_menhir.ml" +# 2087 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1262 "parser_cocci_menhir.mly" +# 1273 "parser_cocci_menhir.mly" ( P.arith_op Ast.Or _1 _2 _3 ) -# 2081 "parser_cocci_menhir.ml" +# 2095 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2107,17 +2121,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 91 "parser_cocci_menhir.mly" +# 92 "parser_cocci_menhir.mly" (Data.clt) -# 2113 "parser_cocci_menhir.ml" +# 2127 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1264 "parser_cocci_menhir.mly" +# 1275 "parser_cocci_menhir.mly" ( P.arith_op Ast.Xor _1 _2 _3 ) -# 2121 "parser_cocci_menhir.ml" +# 2135 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2147,17 +2161,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 89 "parser_cocci_menhir.mly" +# 90 "parser_cocci_menhir.mly" (Data.clt) -# 2153 "parser_cocci_menhir.ml" +# 2167 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1266 "parser_cocci_menhir.mly" +# 1277 "parser_cocci_menhir.mly" ( P.logic_op Ast.AndLog _1 _2 _3 ) -# 2161 "parser_cocci_menhir.ml" +# 2175 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2187,17 +2201,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _3 in let _2 : ( -# 88 "parser_cocci_menhir.mly" +# 89 "parser_cocci_menhir.mly" (Data.clt) -# 2193 "parser_cocci_menhir.ml" +# 2207 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_dot_expressions_ = -# 1268 "parser_cocci_menhir.mly" +# 1279 "parser_cocci_menhir.mly" ( P.logic_op Ast.OrLog _1 _2 _3 ) -# 2201 "parser_cocci_menhir.ml" +# 2215 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2219,9 +2233,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1242 "parser_cocci_menhir.mly" +# 1253 "parser_cocci_menhir.mly" ( _1 ) -# 2225 "parser_cocci_menhir.ml" +# 2239 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2251,17 +2265,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 2257 "parser_cocci_menhir.ml" +# 2271 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1244 "parser_cocci_menhir.mly" +# 1255 "parser_cocci_menhir.mly" ( P.arith_op Ast.Mul _1 _2 _3 ) -# 2265 "parser_cocci_menhir.ml" +# 2279 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2291,17 +2305,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 96 "parser_cocci_menhir.mly" +# 97 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 2297 "parser_cocci_menhir.ml" +# 2311 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1246 "parser_cocci_menhir.mly" +# 1257 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 2305 "parser_cocci_menhir.ml" +# 2319 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2331,17 +2345,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 2337 "parser_cocci_menhir.ml" +# 2351 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1248 "parser_cocci_menhir.mly" +# 1259 "parser_cocci_menhir.mly" ( P.arith_op Ast.Plus _1 _2 _3 ) -# 2345 "parser_cocci_menhir.ml" +# 2359 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2371,17 +2385,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 2377 "parser_cocci_menhir.ml" +# 2391 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1250 "parser_cocci_menhir.mly" +# 1261 "parser_cocci_menhir.mly" ( P.arith_op Ast.Minus _1 _2 _3 ) -# 2385 "parser_cocci_menhir.ml" +# 2399 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2411,17 +2425,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 95 "parser_cocci_menhir.mly" +# 96 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 2417 "parser_cocci_menhir.ml" +# 2431 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1252 "parser_cocci_menhir.mly" +# 1263 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 2425 "parser_cocci_menhir.ml" +# 2439 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2451,17 +2465,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 94 "parser_cocci_menhir.mly" +# 95 "parser_cocci_menhir.mly" (Ast_cocci.logicalOp * Data.clt) -# 2457 "parser_cocci_menhir.ml" +# 2471 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1254 "parser_cocci_menhir.mly" +# 1265 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.logic_op op _1 clt _3 ) -# 2465 "parser_cocci_menhir.ml" +# 2479 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2491,17 +2505,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 2497 "parser_cocci_menhir.ml" +# 2511 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1256 "parser_cocci_menhir.mly" +# 1267 "parser_cocci_menhir.mly" ( P.logic_op Ast.Eq _1 _2 _3 ) -# 2505 "parser_cocci_menhir.ml" +# 2519 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2531,17 +2545,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 2537 "parser_cocci_menhir.ml" +# 2551 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1258 "parser_cocci_menhir.mly" +# 1269 "parser_cocci_menhir.mly" ( P.logic_op Ast.NotEq _1 _2 _3 ) -# 2545 "parser_cocci_menhir.ml" +# 2559 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2571,17 +2585,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 92 "parser_cocci_menhir.mly" +# 93 "parser_cocci_menhir.mly" (Data.clt) -# 2577 "parser_cocci_menhir.ml" +# 2591 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1260 "parser_cocci_menhir.mly" +# 1271 "parser_cocci_menhir.mly" ( P.arith_op Ast.And _1 _2 _3 ) -# 2585 "parser_cocci_menhir.ml" +# 2599 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2611,17 +2625,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 90 "parser_cocci_menhir.mly" +# 91 "parser_cocci_menhir.mly" (Data.clt) -# 2617 "parser_cocci_menhir.ml" +# 2631 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1262 "parser_cocci_menhir.mly" +# 1273 "parser_cocci_menhir.mly" ( P.arith_op Ast.Or _1 _2 _3 ) -# 2625 "parser_cocci_menhir.ml" +# 2639 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2651,17 +2665,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 91 "parser_cocci_menhir.mly" +# 92 "parser_cocci_menhir.mly" (Data.clt) -# 2657 "parser_cocci_menhir.ml" +# 2671 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1264 "parser_cocci_menhir.mly" +# 1275 "parser_cocci_menhir.mly" ( P.arith_op Ast.Xor _1 _2 _3 ) -# 2665 "parser_cocci_menhir.ml" +# 2679 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2691,17 +2705,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 89 "parser_cocci_menhir.mly" +# 90 "parser_cocci_menhir.mly" (Data.clt) -# 2697 "parser_cocci_menhir.ml" +# 2711 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1266 "parser_cocci_menhir.mly" +# 1277 "parser_cocci_menhir.mly" ( P.logic_op Ast.AndLog _1 _2 _3 ) -# 2705 "parser_cocci_menhir.ml" +# 2719 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2731,17 +2745,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _3 in let _2 : ( -# 88 "parser_cocci_menhir.mly" +# 89 "parser_cocci_menhir.mly" (Data.clt) -# 2737 "parser_cocci_menhir.ml" +# 2751 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_invalid_ = -# 1268 "parser_cocci_menhir.mly" +# 1279 "parser_cocci_menhir.mly" ( P.logic_op Ast.OrLog _1 _2 _3 ) -# 2745 "parser_cocci_menhir.ml" +# 2759 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2763,9 +2777,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1242 "parser_cocci_menhir.mly" +# 1253 "parser_cocci_menhir.mly" ( _1 ) -# 2769 "parser_cocci_menhir.ml" +# 2783 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2795,17 +2809,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 2801 "parser_cocci_menhir.ml" +# 2815 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1244 "parser_cocci_menhir.mly" +# 1255 "parser_cocci_menhir.mly" ( P.arith_op Ast.Mul _1 _2 _3 ) -# 2809 "parser_cocci_menhir.ml" +# 2823 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2835,17 +2849,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 96 "parser_cocci_menhir.mly" +# 97 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 2841 "parser_cocci_menhir.ml" +# 2855 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1246 "parser_cocci_menhir.mly" +# 1257 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 2849 "parser_cocci_menhir.ml" +# 2863 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2875,17 +2889,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 2881 "parser_cocci_menhir.ml" +# 2895 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1248 "parser_cocci_menhir.mly" +# 1259 "parser_cocci_menhir.mly" ( P.arith_op Ast.Plus _1 _2 _3 ) -# 2889 "parser_cocci_menhir.ml" +# 2903 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2915,17 +2929,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 2921 "parser_cocci_menhir.ml" +# 2935 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1250 "parser_cocci_menhir.mly" +# 1261 "parser_cocci_menhir.mly" ( P.arith_op Ast.Minus _1 _2 _3 ) -# 2929 "parser_cocci_menhir.ml" +# 2943 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2955,17 +2969,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 95 "parser_cocci_menhir.mly" +# 96 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 2961 "parser_cocci_menhir.ml" +# 2975 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1252 "parser_cocci_menhir.mly" +# 1263 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 2969 "parser_cocci_menhir.ml" +# 2983 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -2995,17 +3009,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 94 "parser_cocci_menhir.mly" +# 95 "parser_cocci_menhir.mly" (Ast_cocci.logicalOp * Data.clt) -# 3001 "parser_cocci_menhir.ml" +# 3015 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1254 "parser_cocci_menhir.mly" +# 1265 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.logic_op op _1 clt _3 ) -# 3009 "parser_cocci_menhir.ml" +# 3023 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3035,17 +3049,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 3041 "parser_cocci_menhir.ml" +# 3055 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1256 "parser_cocci_menhir.mly" +# 1267 "parser_cocci_menhir.mly" ( P.logic_op Ast.Eq _1 _2 _3 ) -# 3049 "parser_cocci_menhir.ml" +# 3063 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3075,17 +3089,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 3081 "parser_cocci_menhir.ml" +# 3095 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1258 "parser_cocci_menhir.mly" +# 1269 "parser_cocci_menhir.mly" ( P.logic_op Ast.NotEq _1 _2 _3 ) -# 3089 "parser_cocci_menhir.ml" +# 3103 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3115,17 +3129,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 92 "parser_cocci_menhir.mly" +# 93 "parser_cocci_menhir.mly" (Data.clt) -# 3121 "parser_cocci_menhir.ml" +# 3135 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1260 "parser_cocci_menhir.mly" +# 1271 "parser_cocci_menhir.mly" ( P.arith_op Ast.And _1 _2 _3 ) -# 3129 "parser_cocci_menhir.ml" +# 3143 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3155,17 +3169,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 90 "parser_cocci_menhir.mly" +# 91 "parser_cocci_menhir.mly" (Data.clt) -# 3161 "parser_cocci_menhir.ml" +# 3175 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1262 "parser_cocci_menhir.mly" +# 1273 "parser_cocci_menhir.mly" ( P.arith_op Ast.Or _1 _2 _3 ) -# 3169 "parser_cocci_menhir.ml" +# 3183 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3195,17 +3209,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 91 "parser_cocci_menhir.mly" +# 92 "parser_cocci_menhir.mly" (Data.clt) -# 3201 "parser_cocci_menhir.ml" +# 3215 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1264 "parser_cocci_menhir.mly" +# 1275 "parser_cocci_menhir.mly" ( P.arith_op Ast.Xor _1 _2 _3 ) -# 3209 "parser_cocci_menhir.ml" +# 3223 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3235,17 +3249,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 89 "parser_cocci_menhir.mly" +# 90 "parser_cocci_menhir.mly" (Data.clt) -# 3241 "parser_cocci_menhir.ml" +# 3255 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1266 "parser_cocci_menhir.mly" +# 1277 "parser_cocci_menhir.mly" ( P.logic_op Ast.AndLog _1 _2 _3 ) -# 3249 "parser_cocci_menhir.ml" +# 3263 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3275,17 +3289,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _3 in let _2 : ( -# 88 "parser_cocci_menhir.mly" +# 89 "parser_cocci_menhir.mly" (Data.clt) -# 3281 "parser_cocci_menhir.ml" +# 3295 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_eexpr_nest_expressions_ = -# 1268 "parser_cocci_menhir.mly" +# 1279 "parser_cocci_menhir.mly" ( P.logic_op Ast.OrLog _1 _2 _3 ) -# 3289 "parser_cocci_menhir.ml" +# 3303 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3307,9 +3321,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1242 "parser_cocci_menhir.mly" +# 1253 "parser_cocci_menhir.mly" ( _1 ) -# 3313 "parser_cocci_menhir.ml" +# 3327 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3339,17 +3353,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 3345 "parser_cocci_menhir.ml" +# 3359 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1244 "parser_cocci_menhir.mly" +# 1255 "parser_cocci_menhir.mly" ( P.arith_op Ast.Mul _1 _2 _3 ) -# 3353 "parser_cocci_menhir.ml" +# 3367 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3379,17 +3393,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 96 "parser_cocci_menhir.mly" +# 97 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 3385 "parser_cocci_menhir.ml" +# 3399 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1246 "parser_cocci_menhir.mly" +# 1257 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 3393 "parser_cocci_menhir.ml" +# 3407 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3419,17 +3433,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 3425 "parser_cocci_menhir.ml" +# 3439 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1248 "parser_cocci_menhir.mly" +# 1259 "parser_cocci_menhir.mly" ( P.arith_op Ast.Plus _1 _2 _3 ) -# 3433 "parser_cocci_menhir.ml" +# 3447 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3459,17 +3473,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 3465 "parser_cocci_menhir.ml" +# 3479 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1250 "parser_cocci_menhir.mly" +# 1261 "parser_cocci_menhir.mly" ( P.arith_op Ast.Minus _1 _2 _3 ) -# 3473 "parser_cocci_menhir.ml" +# 3487 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3499,17 +3513,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 95 "parser_cocci_menhir.mly" +# 96 "parser_cocci_menhir.mly" (Ast_cocci.arithOp * Data.clt) -# 3505 "parser_cocci_menhir.ml" +# 3519 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1252 "parser_cocci_menhir.mly" +# 1263 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.arith_op op _1 clt _3 ) -# 3513 "parser_cocci_menhir.ml" +# 3527 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3539,17 +3553,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 94 "parser_cocci_menhir.mly" +# 95 "parser_cocci_menhir.mly" (Ast_cocci.logicalOp * Data.clt) -# 3545 "parser_cocci_menhir.ml" +# 3559 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1254 "parser_cocci_menhir.mly" +# 1265 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in P.logic_op op _1 clt _3 ) -# 3553 "parser_cocci_menhir.ml" +# 3567 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3579,17 +3593,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 3585 "parser_cocci_menhir.ml" +# 3599 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1256 "parser_cocci_menhir.mly" +# 1267 "parser_cocci_menhir.mly" ( P.logic_op Ast.Eq _1 _2 _3 ) -# 3593 "parser_cocci_menhir.ml" +# 3607 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3619,17 +3633,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 93 "parser_cocci_menhir.mly" +# 94 "parser_cocci_menhir.mly" (Data.clt) -# 3625 "parser_cocci_menhir.ml" +# 3639 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1258 "parser_cocci_menhir.mly" +# 1269 "parser_cocci_menhir.mly" ( P.logic_op Ast.NotEq _1 _2 _3 ) -# 3633 "parser_cocci_menhir.ml" +# 3647 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3659,17 +3673,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 92 "parser_cocci_menhir.mly" +# 93 "parser_cocci_menhir.mly" (Data.clt) -# 3665 "parser_cocci_menhir.ml" +# 3679 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1260 "parser_cocci_menhir.mly" +# 1271 "parser_cocci_menhir.mly" ( P.arith_op Ast.And _1 _2 _3 ) -# 3673 "parser_cocci_menhir.ml" +# 3687 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3699,17 +3713,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 90 "parser_cocci_menhir.mly" +# 91 "parser_cocci_menhir.mly" (Data.clt) -# 3705 "parser_cocci_menhir.ml" +# 3719 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1262 "parser_cocci_menhir.mly" +# 1273 "parser_cocci_menhir.mly" ( P.arith_op Ast.Or _1 _2 _3 ) -# 3713 "parser_cocci_menhir.ml" +# 3727 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3739,17 +3753,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 91 "parser_cocci_menhir.mly" +# 92 "parser_cocci_menhir.mly" (Data.clt) -# 3745 "parser_cocci_menhir.ml" +# 3759 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1264 "parser_cocci_menhir.mly" +# 1275 "parser_cocci_menhir.mly" ( P.arith_op Ast.Xor _1 _2 _3 ) -# 3753 "parser_cocci_menhir.ml" +# 3767 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3779,17 +3793,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 89 "parser_cocci_menhir.mly" +# 90 "parser_cocci_menhir.mly" (Data.clt) -# 3785 "parser_cocci_menhir.ml" +# 3799 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1266 "parser_cocci_menhir.mly" +# 1277 "parser_cocci_menhir.mly" ( P.logic_op Ast.AndLog _1 _2 _3 ) -# 3793 "parser_cocci_menhir.ml" +# 3807 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3819,17 +3833,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_arith_expr_expr_invalid_ = Obj.magic _3 in let _2 : ( -# 88 "parser_cocci_menhir.mly" +# 89 "parser_cocci_menhir.mly" (Data.clt) -# 3825 "parser_cocci_menhir.ml" +# 3839 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_arith_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_arith_expr_expr_invalid_ = -# 1268 "parser_cocci_menhir.mly" +# 1279 "parser_cocci_menhir.mly" ( P.logic_op Ast.OrLog _1 _2 _3 ) -# 3833 "parser_cocci_menhir.ml" +# 3847 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3849,9 +3863,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_arity = -# 445 "parser_cocci_menhir.mly" +# 450 "parser_cocci_menhir.mly" ( Ast.UNIQUE ) -# 3855 "parser_cocci_menhir.ml" +# 3869 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3871,9 +3885,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_arity = -# 446 "parser_cocci_menhir.mly" +# 451 "parser_cocci_menhir.mly" ( Ast.OPT ) -# 3877 "parser_cocci_menhir.ml" +# 3891 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3893,9 +3907,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_arity = -# 447 "parser_cocci_menhir.mly" +# 452 "parser_cocci_menhir.mly" ( Ast.MULTI ) -# 3899 "parser_cocci_menhir.ml" +# 3913 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3910,9 +3924,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_arity = -# 448 "parser_cocci_menhir.mly" +# 453 "parser_cocci_menhir.mly" ( Ast.NONE ) -# 3916 "parser_cocci_menhir.ml" +# 3930 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3941,22 +3955,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let r : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 3947 "parser_cocci_menhir.ml" +# 3961 "parser_cocci_menhir.ml" ) = Obj.magic r in let i : 'tv_option_eexpr_ = Obj.magic i in let l : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 3953 "parser_cocci_menhir.ml" +# 3967 "parser_cocci_menhir.ml" ) = Obj.magic l in let _startpos = _startpos_l_ in let _endpos = _endpos_r_ in let _v : 'tv_array_dec = -# 1055 "parser_cocci_menhir.mly" +# 1060 "parser_cocci_menhir.mly" ( (l,i,r) ) -# 3960 "parser_cocci_menhir.ml" +# 3974 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -3978,9 +3992,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_assign_expr_eexpr_dot_expressions_ = -# 1214 "parser_cocci_menhir.mly" +# 1225 "parser_cocci_menhir.mly" ( _1 ) -# 3984 "parser_cocci_menhir.ml" +# 3998 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4010,19 +4024,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 107 "parser_cocci_menhir.mly" +# 108 "parser_cocci_menhir.mly" (Ast_cocci.assignOp * Data.clt) -# 4016 "parser_cocci_menhir.ml" +# 4030 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_eexpr_dot_expressions_ = -# 1216 "parser_cocci_menhir.mly" +# 1227 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt, Ast0.set_arg_exp _3,false)) ) -# 4026 "parser_cocci_menhir.ml" +# 4040 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4052,19 +4066,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 4058 "parser_cocci_menhir.ml" +# 4072 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_eexpr_dot_expressions_ = -# 1220 "parser_cocci_menhir.mly" +# 1231 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.Assignment (_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) ) -# 4068 "parser_cocci_menhir.ml" +# 4082 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4086,9 +4100,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_assign_expr_eexpr_nest_expressions_ = -# 1214 "parser_cocci_menhir.mly" +# 1225 "parser_cocci_menhir.mly" ( _1 ) -# 4092 "parser_cocci_menhir.ml" +# 4106 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4118,19 +4132,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 107 "parser_cocci_menhir.mly" +# 108 "parser_cocci_menhir.mly" (Ast_cocci.assignOp * Data.clt) -# 4124 "parser_cocci_menhir.ml" +# 4138 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_eexpr_nest_expressions_ = -# 1216 "parser_cocci_menhir.mly" +# 1227 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt, Ast0.set_arg_exp _3,false)) ) -# 4134 "parser_cocci_menhir.ml" +# 4148 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4160,19 +4174,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 4166 "parser_cocci_menhir.ml" +# 4180 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_eexpr_nest_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_eexpr_nest_expressions_ = -# 1220 "parser_cocci_menhir.mly" +# 1231 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.Assignment (_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) ) -# 4176 "parser_cocci_menhir.ml" +# 4190 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4194,9 +4208,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_assign_expr_expr_invalid_ = -# 1214 "parser_cocci_menhir.mly" +# 1225 "parser_cocci_menhir.mly" ( _1 ) -# 4200 "parser_cocci_menhir.ml" +# 4214 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4226,19 +4240,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 107 "parser_cocci_menhir.mly" +# 108 "parser_cocci_menhir.mly" (Ast_cocci.assignOp * Data.clt) -# 4232 "parser_cocci_menhir.ml" +# 4246 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_expr_invalid_ = -# 1216 "parser_cocci_menhir.mly" +# 1227 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt, Ast0.set_arg_exp _3,false)) ) -# 4242 "parser_cocci_menhir.ml" +# 4256 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4268,19 +4282,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 4274 "parser_cocci_menhir.ml" +# 4288 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_expr_invalid_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_expr_invalid_ = -# 1220 "parser_cocci_menhir.mly" +# 1231 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.Assignment (_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) ) -# 4284 "parser_cocci_menhir.ml" +# 4298 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4302,9 +4316,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_assign_expr_bis = -# 1225 "parser_cocci_menhir.mly" +# 1236 "parser_cocci_menhir.mly" ( _1 ) -# 4308 "parser_cocci_menhir.ml" +# 4322 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4334,19 +4348,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 107 "parser_cocci_menhir.mly" +# 108 "parser_cocci_menhir.mly" (Ast_cocci.assignOp * Data.clt) -# 4340 "parser_cocci_menhir.ml" +# 4354 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_bis = -# 1227 "parser_cocci_menhir.mly" +# 1238 "parser_cocci_menhir.mly" ( let (op,clt) = _2 in Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt, Ast0.set_arg_exp _3,false)) ) -# 4350 "parser_cocci_menhir.ml" +# 4364 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4376,19 +4390,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_assign_expr_bis = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 4382 "parser_cocci_menhir.ml" +# 4396 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_unary_expr_eexpr_dot_expressions_ = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_assign_expr_bis = -# 1231 "parser_cocci_menhir.mly" +# 1242 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.Assignment (_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) ) -# 4392 "parser_cocci_menhir.ml" +# 4406 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4410,9 +4424,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_basic_expr_eexpr_dot_expressions_ = -# 1211 "parser_cocci_menhir.mly" +# 1222 "parser_cocci_menhir.mly" ( _1 ) -# 4416 "parser_cocci_menhir.ml" +# 4430 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4434,9 +4448,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_basic_expr_eexpr_nest_expressions_ = -# 1211 "parser_cocci_menhir.mly" +# 1222 "parser_cocci_menhir.mly" ( _1 ) -# 4440 "parser_cocci_menhir.ml" +# 4454 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4458,9 +4472,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_basic_expr_expr_invalid_ = -# 1211 "parser_cocci_menhir.mly" +# 1222 "parser_cocci_menhir.mly" ( _1 ) -# 4464 "parser_cocci_menhir.ml" +# 4478 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4490,21 +4504,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_fun_start = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 4496 "parser_cocci_menhir.ml" +# 4510 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 4501 "parser_cocci_menhir.ml" +# 4515 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_case_line = -# 927 "parser_cocci_menhir.mly" +# 932 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Default(P.clt2mcode "default" _1,P.clt2mcode ":" _2,_3)) ) -# 4508 "parser_cocci_menhir.ml" +# 4522 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4539,22 +4553,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _4 : 'tv_fun_start = Obj.magic _4 in let _3 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 4545 "parser_cocci_menhir.ml" +# 4559 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_eexpr = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 4551 "parser_cocci_menhir.ml" +# 4565 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_case_line = -# 929 "parser_cocci_menhir.mly" +# 934 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Case(P.clt2mcode "case" _1,_2,P.clt2mcode ":" _3,_4)) ) -# 4558 "parser_cocci_menhir.ml" +# 4572 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4576,9 +4590,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_cast_expr_eexpr_dot_expressions_ = -# 1271 "parser_cocci_menhir.mly" +# 1282 "parser_cocci_menhir.mly" ( _1 ) -# 4582 "parser_cocci_menhir.ml" +# 4596 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4613,23 +4627,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let e : 'tv_cast_expr_eexpr_dot_expressions_ = Obj.magic e in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 4619 "parser_cocci_menhir.ml" +# 4633 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 4625 "parser_cocci_menhir.ml" +# 4639 "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_ = -# 1273 "parser_cocci_menhir.mly" +# 1284 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t, P.clt2mcode ")" rp, e)) ) -# 4633 "parser_cocci_menhir.ml" +# 4647 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4651,9 +4665,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_cast_expr_eexpr_invalid_ = -# 1271 "parser_cocci_menhir.mly" +# 1282 "parser_cocci_menhir.mly" ( _1 ) -# 4657 "parser_cocci_menhir.ml" +# 4671 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4688,23 +4702,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let e : 'tv_cast_expr_eexpr_invalid_ = Obj.magic e in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 4694 "parser_cocci_menhir.ml" +# 4708 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 4700 "parser_cocci_menhir.ml" +# 4714 "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_ = -# 1273 "parser_cocci_menhir.mly" +# 1284 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t, P.clt2mcode ")" rp, e)) ) -# 4708 "parser_cocci_menhir.ml" +# 4722 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4726,9 +4740,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_cast_expr_eexpr_nest_expressions_ = -# 1271 "parser_cocci_menhir.mly" +# 1282 "parser_cocci_menhir.mly" ( _1 ) -# 4732 "parser_cocci_menhir.ml" +# 4746 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4763,23 +4777,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let e : 'tv_cast_expr_eexpr_nest_expressions_ = Obj.magic e in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 4769 "parser_cocci_menhir.ml" +# 4783 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 4775 "parser_cocci_menhir.ml" +# 4789 "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_ = -# 1273 "parser_cocci_menhir.mly" +# 1284 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t, P.clt2mcode ")" rp, e)) ) -# 4783 "parser_cocci_menhir.ml" +# 4797 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4801,9 +4815,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_cast_expr_expr_invalid_ = -# 1271 "parser_cocci_menhir.mly" +# 1282 "parser_cocci_menhir.mly" ( _1 ) -# 4807 "parser_cocci_menhir.ml" +# 4821 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4838,23 +4852,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let e : 'tv_cast_expr_expr_invalid_ = Obj.magic e in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 4844 "parser_cocci_menhir.ml" +# 4858 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 4850 "parser_cocci_menhir.ml" +# 4864 "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_ = -# 1273 "parser_cocci_menhir.mly" +# 1284 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t, P.clt2mcode ")" rp, e)) ) -# 4858 "parser_cocci_menhir.ml" +# 4872 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4880,9 +4894,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_choose_iso = -# 232 "parser_cocci_menhir.mly" +# 233 "parser_cocci_menhir.mly" ( List.map P.id2name _2 ) -# 4886 "parser_cocci_menhir.ml" +# 4900 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4906,23 +4920,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 4912 "parser_cocci_menhir.ml" +# 4926 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 4917 "parser_cocci_menhir.ml" +# 4931 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_comma_decls_TEllipsis_decl_ = -# 1541 "parser_cocci_menhir.mly" +# 1553 "parser_cocci_menhir.mly" ( function dot_builder -> [Ast0.wrap(Ast0.PComma(P.clt2mcode "," _1)); dot_builder _2] ) -# 4926 "parser_cocci_menhir.ml" +# 4940 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4947,17 +4961,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_one_dec_decl_ = Obj.magic _2 in let _1 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 4953 "parser_cocci_menhir.ml" +# 4967 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_comma_decls_TEllipsis_decl_ = -# 1545 "parser_cocci_menhir.mly" +# 1557 "parser_cocci_menhir.mly" ( function dot_builder -> [Ast0.wrap(Ast0.PComma(P.clt2mcode "," _1)); _2] ) -# 4961 "parser_cocci_menhir.ml" +# 4975 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -4981,23 +4995,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 4987 "parser_cocci_menhir.ml" +# 5001 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 4992 "parser_cocci_menhir.ml" +# 5006 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_comma_decls_TEllipsis_name_opt_decl_ = -# 1541 "parser_cocci_menhir.mly" +# 1553 "parser_cocci_menhir.mly" ( function dot_builder -> [Ast0.wrap(Ast0.PComma(P.clt2mcode "," _1)); dot_builder _2] ) -# 5001 "parser_cocci_menhir.ml" +# 5015 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5022,17 +5036,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_one_dec_name_opt_decl_ = Obj.magic _2 in let _1 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 5028 "parser_cocci_menhir.ml" +# 5042 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_comma_decls_TEllipsis_name_opt_decl_ = -# 1545 "parser_cocci_menhir.mly" +# 1557 "parser_cocci_menhir.mly" ( function dot_builder -> [Ast0.wrap(Ast0.PComma(P.clt2mcode "," _1)); _2] ) -# 5036 "parser_cocci_menhir.ml" +# 5050 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5047,9 +5061,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_comma_initializers_edots_when_TEllipsis_initialize__ = -# 1102 "parser_cocci_menhir.mly" +# 1113 "parser_cocci_menhir.mly" ( [] ) -# 5053 "parser_cocci_menhir.ml" +# 5067 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5077,9 +5091,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_d_ in let _endpos = _endpos_r_ in let _v : 'tv_comma_initializers_edots_when_TEllipsis_initialize__ = -# 1104 "parser_cocci_menhir.mly" +# 1115 "parser_cocci_menhir.mly" ( (function dot_builder -> [dot_builder d])::r ) -# 5083 "parser_cocci_menhir.ml" +# 5097 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5109,18 +5123,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let r : 'tv_comma_initializers_edots_when_TEllipsis_initialize__ = Obj.magic r in let c : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 5115 "parser_cocci_menhir.ml" +# 5129 "parser_cocci_menhir.ml" ) = Obj.magic c in let i : 'tv_initialize2 = Obj.magic i in let _startpos = _startpos_i_ in let _endpos = _endpos_r_ in let _v : 'tv_comma_initializers_edots_when_TEllipsis_initialize__ = -# 1106 "parser_cocci_menhir.mly" +# 1117 "parser_cocci_menhir.mly" ( (function dot_builder -> [i; Ast0.wrap(Ast0.IComma(P.clt2mcode "," c))]):: r ) -# 5124 "parser_cocci_menhir.ml" +# 5138 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5135,9 +5149,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_comma_initializers2_edots_when_TEllipsis_initialize__ = -# 1110 "parser_cocci_menhir.mly" +# 1121 "parser_cocci_menhir.mly" ( [] ) -# 5141 "parser_cocci_menhir.ml" +# 5155 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5167,18 +5181,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let r : 'tv_comma_initializers_edots_when_TEllipsis_initialize__ = Obj.magic r in let c : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 5173 "parser_cocci_menhir.ml" +# 5187 "parser_cocci_menhir.ml" ) = Obj.magic c in let i : 'tv_initialize2 = Obj.magic i in let _startpos = _startpos_i_ in let _endpos = _endpos_r_ in let _v : 'tv_comma_initializers2_edots_when_TEllipsis_initialize__ = -# 1112 "parser_cocci_menhir.mly" +# 1123 "parser_cocci_menhir.mly" ( (function dot_builder -> [i; Ast0.wrap(Ast0.IComma(P.clt2mcode "," c))]):: r ) -# 5182 "parser_cocci_menhir.ml" +# 5196 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5200,9 +5214,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_any_strict_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5206 "parser_cocci_menhir.ml" +# 5220 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5224,9 +5238,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_ctype_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5230 "parser_cocci_menhir.ml" +# 5244 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5248,9 +5262,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_d_ident_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5254 "parser_cocci_menhir.ml" +# 5268 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5272,9 +5286,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_dexpr_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5278 "parser_cocci_menhir.ml" +# 5292 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5296,9 +5310,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_ident_or_const_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5302 "parser_cocci_menhir.ml" +# 5316 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5320,9 +5334,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_meta_ident_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5326 "parser_cocci_menhir.ml" +# 5340 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5344,9 +5358,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_pure_ident_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5350 "parser_cocci_menhir.ml" +# 5364 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5368,9 +5382,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_pure_ident_or_meta_ident_ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5374 "parser_cocci_menhir.ml" +# 5388 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5392,9 +5406,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_not_eq_not_ceq__ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5398 "parser_cocci_menhir.ml" +# 5412 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5416,9 +5430,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_not_eq_not_eq__ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5422 "parser_cocci_menhir.ml" +# 5436 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5440,9 +5454,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_not_eq_not_eqe__ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5446 "parser_cocci_menhir.ml" +# 5460 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5464,9 +5478,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_not_eq_not_pos__ = -# 1772 "parser_cocci_menhir.mly" +# 1784 "parser_cocci_menhir.mly" ( _1 ) -# 5470 "parser_cocci_menhir.ml" +# 5484 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5488,9 +5502,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_cond_expr_eexpr_dot_expressions_ = -# 1236 "parser_cocci_menhir.mly" +# 1247 "parser_cocci_menhir.mly" ( _1 ) -# 5494 "parser_cocci_menhir.ml" +# 5508 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5530,24 +5544,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let r : 'tv_cond_expr_eexpr_dot_expressions_ = Obj.magic r in let dd : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 5536 "parser_cocci_menhir.ml" +# 5550 "parser_cocci_menhir.ml" ) = Obj.magic dd in let t : 'tv_option_eexpr_ = Obj.magic t in let w : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 5542 "parser_cocci_menhir.ml" +# 5556 "parser_cocci_menhir.ml" ) = Obj.magic w in let l : 'tv_arith_expr_eexpr_dot_expressions_ = Obj.magic l in let _startpos = _startpos_l_ in let _endpos = _endpos_r_ in let _v : 'tv_cond_expr_eexpr_dot_expressions_ = -# 1238 "parser_cocci_menhir.mly" +# 1249 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t, P.clt2mcode ":" dd, r)) ) -# 5551 "parser_cocci_menhir.ml" +# 5565 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5569,9 +5583,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_cond_expr_eexpr_nest_expressions_ = -# 1236 "parser_cocci_menhir.mly" +# 1247 "parser_cocci_menhir.mly" ( _1 ) -# 5575 "parser_cocci_menhir.ml" +# 5589 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5611,24 +5625,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let r : 'tv_cond_expr_eexpr_nest_expressions_ = Obj.magic r in let dd : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 5617 "parser_cocci_menhir.ml" +# 5631 "parser_cocci_menhir.ml" ) = Obj.magic dd in let t : 'tv_option_eexpr_ = Obj.magic t in let w : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 5623 "parser_cocci_menhir.ml" +# 5637 "parser_cocci_menhir.ml" ) = Obj.magic w in let l : 'tv_arith_expr_eexpr_nest_expressions_ = Obj.magic l in let _startpos = _startpos_l_ in let _endpos = _endpos_r_ in let _v : 'tv_cond_expr_eexpr_nest_expressions_ = -# 1238 "parser_cocci_menhir.mly" +# 1249 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t, P.clt2mcode ":" dd, r)) ) -# 5632 "parser_cocci_menhir.ml" +# 5646 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5650,9 +5664,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_cond_expr_expr_invalid_ = -# 1236 "parser_cocci_menhir.mly" +# 1247 "parser_cocci_menhir.mly" ( _1 ) -# 5656 "parser_cocci_menhir.ml" +# 5670 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5692,24 +5706,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let r : 'tv_cond_expr_expr_invalid_ = Obj.magic r in let dd : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 5698 "parser_cocci_menhir.ml" +# 5712 "parser_cocci_menhir.ml" ) = Obj.magic dd in let t : 'tv_option_eexpr_ = Obj.magic t in let w : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 5704 "parser_cocci_menhir.ml" +# 5718 "parser_cocci_menhir.ml" ) = Obj.magic w in let l : 'tv_arith_expr_expr_invalid_ = Obj.magic l in let _startpos = _startpos_l_ in let _endpos = _endpos_r_ in let _v : 'tv_cond_expr_expr_invalid_ = -# 1238 "parser_cocci_menhir.mly" +# 1249 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t, P.clt2mcode ":" dd, r)) ) -# 5713 "parser_cocci_menhir.ml" +# 5727 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5730,14 +5744,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 54 "parser_cocci_menhir.mly" (Data.clt) -# 5734 "parser_cocci_menhir.ml" +# 5748 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_const_vol = -# 836 "parser_cocci_menhir.mly" +# 841 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Const _1 ) -# 5741 "parser_cocci_menhir.ml" +# 5755 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5758,14 +5772,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 54 "parser_cocci_menhir.mly" (Data.clt) -# 5762 "parser_cocci_menhir.ml" +# 5776 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_const_vol = -# 837 "parser_cocci_menhir.mly" +# 842 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Volatile _1 ) -# 5769 "parser_cocci_menhir.ml" +# 5783 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5780,9 +5794,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_continue_struct_decl_list = -# 535 "parser_cocci_menhir.mly" +# 540 "parser_cocci_menhir.mly" ( [] ) -# 5786 "parser_cocci_menhir.ml" +# 5800 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5810,9 +5824,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_continue_struct_decl_list = -# 536 "parser_cocci_menhir.mly" +# 541 "parser_cocci_menhir.mly" ( _1@_2 ) -# 5816 "parser_cocci_menhir.ml" +# 5830 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5834,9 +5848,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_continue_struct_decl_list = -# 537 "parser_cocci_menhir.mly" +# 542 "parser_cocci_menhir.mly" ( _1 ) -# 5840 "parser_cocci_menhir.ml" +# 5854 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5867,13 +5881,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 5871 "parser_cocci_menhir.ml" +# 5885 "parser_cocci_menhir.ml" in -# 541 "parser_cocci_menhir.mly" +# 546 "parser_cocci_menhir.mly" ( P.pointerify (P.make_cv cv ty) m ) -# 5877 "parser_cocci_menhir.ml" +# 5891 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5911,13 +5925,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 5915 "parser_cocci_menhir.ml" +# 5929 "parser_cocci_menhir.ml" in -# 541 "parser_cocci_menhir.mly" +# 546 "parser_cocci_menhir.mly" ( P.pointerify (P.make_cv cv ty) m ) -# 5921 "parser_cocci_menhir.ml" +# 5935 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5944,7 +5958,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 5948 "parser_cocci_menhir.ml" +# 5962 "parser_cocci_menhir.ml" ) = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_m_ in @@ -5952,15 +5966,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 5956 "parser_cocci_menhir.ml" +# 5970 "parser_cocci_menhir.ml" in -# 543 "parser_cocci_menhir.mly" +# 548 "parser_cocci_menhir.mly" ( let ty = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in P.pointerify (P.make_cv cv ty) m ) -# 5964 "parser_cocci_menhir.ml" +# 5978 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -5992,7 +6006,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 5996 "parser_cocci_menhir.ml" +# 6010 "parser_cocci_menhir.ml" ) = Obj.magic t in let x0 : 'tv_const_vol = Obj.magic x0 in let _startpos = _startpos_x0_ in @@ -6002,15 +6016,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 6006 "parser_cocci_menhir.ml" +# 6020 "parser_cocci_menhir.ml" in -# 543 "parser_cocci_menhir.mly" +# 548 "parser_cocci_menhir.mly" ( let ty = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in P.pointerify (P.make_cv cv ty) m ) -# 6014 "parser_cocci_menhir.ml" +# 6028 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6039,24 +6053,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 6045 "parser_cocci_menhir.ml" +# 6059 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_midzero_list_ctype_ctype_ = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 6051 "parser_cocci_menhir.ml" +# 6065 "parser_cocci_menhir.ml" ) = Obj.magic lp in let _startpos = _startpos_lp_ in let _endpos = _endpos_rp_ in let _v : 'tv_ctype = -# 548 "parser_cocci_menhir.mly" +# 553 "parser_cocci_menhir.mly" ( let (mids,code) = t in Ast0.wrap (Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) ) -# 6060 "parser_cocci_menhir.ml" +# 6074 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6087,13 +6101,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 6091 "parser_cocci_menhir.ml" +# 6105 "parser_cocci_menhir.ml" in -# 554 "parser_cocci_menhir.mly" +# 559 "parser_cocci_menhir.mly" ( P.pointerify (P.make_cv cv ty) m ) -# 6097 "parser_cocci_menhir.ml" +# 6111 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6131,13 +6145,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 6135 "parser_cocci_menhir.ml" +# 6149 "parser_cocci_menhir.ml" in -# 554 "parser_cocci_menhir.mly" +# 559 "parser_cocci_menhir.mly" ( P.pointerify (P.make_cv cv ty) m ) -# 6141 "parser_cocci_menhir.ml" +# 6155 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6164,7 +6178,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 6168 "parser_cocci_menhir.ml" +# 6182 "parser_cocci_menhir.ml" ) = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_m_ in @@ -6172,15 +6186,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 6176 "parser_cocci_menhir.ml" +# 6190 "parser_cocci_menhir.ml" in -# 556 "parser_cocci_menhir.mly" +# 561 "parser_cocci_menhir.mly" ( let ty = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in P.pointerify (P.make_cv cv ty) m ) -# 6184 "parser_cocci_menhir.ml" +# 6198 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6212,7 +6226,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 6216 "parser_cocci_menhir.ml" +# 6230 "parser_cocci_menhir.ml" ) = Obj.magic t in let x0 : 'tv_const_vol = Obj.magic x0 in let _startpos = _startpos_x0_ in @@ -6222,15 +6236,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 6226 "parser_cocci_menhir.ml" +# 6240 "parser_cocci_menhir.ml" in -# 556 "parser_cocci_menhir.mly" +# 561 "parser_cocci_menhir.mly" ( let ty = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in P.pointerify (P.make_cv cv ty) m ) -# 6234 "parser_cocci_menhir.ml" +# 6248 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6259,24 +6273,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 6265 "parser_cocci_menhir.ml" +# 6279 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_midzero_list_ctype_ctype_ = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 6271 "parser_cocci_menhir.ml" +# 6285 "parser_cocci_menhir.ml" ) = Obj.magic lp in let _startpos = _startpos_lp_ in let _endpos = _endpos_rp_ in let _v : 'tv_ctype_full = -# 561 "parser_cocci_menhir.mly" +# 566 "parser_cocci_menhir.mly" ( let (mids,code) = t in Ast0.wrap (Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) ) -# 6280 "parser_cocci_menhir.ml" +# 6294 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6304,7 +6318,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_d_ident = -# 1046 "parser_cocci_menhir.mly" +# 1051 "parser_cocci_menhir.mly" ( (_1, function t -> List.fold_right @@ -6313,7 +6327,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct Ast0.wrap (Ast0.Array(rest,P.clt2mcode "[" l,i,P.clt2mcode "]" r))) _2 t) ) -# 6317 "parser_cocci_menhir.ml" +# 6331 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6341,9 +6355,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_t_ in let _endpos = _endpos_i_ in let _v : 'tv_decl = -# 806 "parser_cocci_menhir.mly" +# 811 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Param(t, Some i)) ) -# 6347 "parser_cocci_menhir.ml" +# 6361 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6397,44 +6411,44 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 6403 "parser_cocci_menhir.ml" +# 6417 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 6409 "parser_cocci_menhir.ml" +# 6423 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 6414 "parser_cocci_menhir.ml" +# 6428 "parser_cocci_menhir.ml" ) = Obj.magic rp in let i : 'tv_ident = Obj.magic i in let s : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 6420 "parser_cocci_menhir.ml" +# 6434 "parser_cocci_menhir.ml" ) = Obj.magic s in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 6425 "parser_cocci_menhir.ml" +# 6439 "parser_cocci_menhir.ml" ) = Obj.magic lp in let t : 'tv_fn_ctype = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_rp1_ in let _v : 'tv_decl = -# 809 "parser_cocci_menhir.mly" +# 814 "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, Some i)) ) -# 6438 "parser_cocci_menhir.ml" +# 6452 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6455,16 +6469,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 6459 "parser_cocci_menhir.ml" +# 6473 "parser_cocci_menhir.ml" ) = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_t_ in let _v : 'tv_decl = -# 816 "parser_cocci_menhir.mly" +# 821 "parser_cocci_menhir.mly" ( let ty = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in Ast0.wrap(Ast0.VoidParam(ty)) ) -# 6468 "parser_cocci_menhir.ml" +# 6482 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6485,15 +6499,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 6489 "parser_cocci_menhir.ml" +# 6503 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl = -# 820 "parser_cocci_menhir.mly" +# 825 "parser_cocci_menhir.mly" ( let (nm,pure,clt) = _1 in Ast0.wrap(Ast0.MetaParam(P.clt2mcode nm clt,pure)) ) -# 6497 "parser_cocci_menhir.ml" +# 6511 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6514,14 +6528,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 6518 "parser_cocci_menhir.ml" +# 6532 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_ident = -# 1491 "parser_cocci_menhir.mly" +# 1502 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Id(P.id2mcode _1)) ) -# 6525 "parser_cocci_menhir.ml" +# 6539 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6542,15 +6556,32 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 62 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 6546 "parser_cocci_menhir.ml" +# 6560 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_ident = -# 1493 "parser_cocci_menhir.mly" +# 1504 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) ) -# 6554 "parser_cocci_menhir.ml" +# 6568 "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 _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in + let _endpos = _startpos in + let _v : 'tv_decl_list_decl_ = +# 1524 "parser_cocci_menhir.mly" + ( Ast0.wrap(Ast0.DOTS([])) ) +# 6585 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6572,13 +6603,30 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_list_decl_ = -# 1514 "parser_cocci_menhir.mly" +# 1526 "parser_cocci_menhir.mly" (let circle x = match Ast0.unwrap x with Ast0.Pcircles(_) -> true | _ -> false in if List.exists circle _1 then Ast0.wrap(Ast0.CIRCLES(_1)) else Ast0.wrap(Ast0.DOTS(_1)) ) -# 6582 "parser_cocci_menhir.ml" +# 6613 "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 _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in + let _endpos = _startpos in + let _v : 'tv_decl_list_name_opt_decl_ = +# 1524 "parser_cocci_menhir.mly" + ( Ast0.wrap(Ast0.DOTS([])) ) +# 6630 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6600,13 +6648,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_list_name_opt_decl_ = -# 1514 "parser_cocci_menhir.mly" +# 1526 "parser_cocci_menhir.mly" (let circle x = match Ast0.unwrap x with Ast0.Pcircles(_) -> true | _ -> false in if List.exists circle _1 then Ast0.wrap(Ast0.CIRCLES(_1)) else Ast0.wrap(Ast0.DOTS(_1)) ) -# 6610 "parser_cocci_menhir.ml" +# 6658 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6628,9 +6676,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_list_start_decl_ = -# 1521 "parser_cocci_menhir.mly" +# 1533 "parser_cocci_menhir.mly" ( [_1] ) -# 6634 "parser_cocci_menhir.ml" +# 6682 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6660,17 +6708,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_decl_list_start_decl_ = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 6666 "parser_cocci_menhir.ml" +# 6714 "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_decl_list_start_decl_ = -# 1523 "parser_cocci_menhir.mly" +# 1535 "parser_cocci_menhir.mly" ( _1::Ast0.wrap(Ast0.PComma(P.clt2mcode "," _2))::_3 ) -# 6674 "parser_cocci_menhir.ml" +# 6722 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6695,17 +6743,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_list_comma_decls_TEllipsis_decl__ = Obj.magic _2 in let _1 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 6701 "parser_cocci_menhir.ml" +# 6749 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_decl_list_start_decl_ = -# 1525 "parser_cocci_menhir.mly" +# 1537 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Pdots(P.clt2mcode "..." _1)):: (List.concat(List.map (function x -> x (P.mkpdots "...")) _2)) ) -# 6709 "parser_cocci_menhir.ml" +# 6757 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6727,9 +6775,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_list_start_name_opt_decl_ = -# 1521 "parser_cocci_menhir.mly" +# 1533 "parser_cocci_menhir.mly" ( [_1] ) -# 6733 "parser_cocci_menhir.ml" +# 6781 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6759,17 +6807,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_decl_list_start_name_opt_decl_ = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 6765 "parser_cocci_menhir.ml" +# 6813 "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_decl_list_start_name_opt_decl_ = -# 1523 "parser_cocci_menhir.mly" +# 1535 "parser_cocci_menhir.mly" ( _1::Ast0.wrap(Ast0.PComma(P.clt2mcode "," _2))::_3 ) -# 6773 "parser_cocci_menhir.ml" +# 6821 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6794,17 +6842,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_list_comma_decls_TEllipsis_name_opt_decl__ = Obj.magic _2 in let _1 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 6800 "parser_cocci_menhir.ml" +# 6848 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_decl_list_start_name_opt_decl_ = -# 1525 "parser_cocci_menhir.mly" +# 1537 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Pdots(P.clt2mcode "..." _1)):: (List.concat(List.map (function x -> x (P.mkpdots "...")) _2)) ) -# 6808 "parser_cocci_menhir.ml" +# 6856 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6825,15 +6873,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 6829 "parser_cocci_menhir.ml" +# 6877 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_statement = -# 1118 "parser_cocci_menhir.mly" +# 1129 "parser_cocci_menhir.mly" ( let (nm,pure,clt) = _1 in [Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] ) -# 6837 "parser_cocci_menhir.ml" +# 6885 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6855,13 +6903,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_statement = -# 1121 "parser_cocci_menhir.mly" +# 1132 "parser_cocci_menhir.mly" ( List.map (function x -> Ast0.wrap (Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),x))) _1 ) -# 6865 "parser_cocci_menhir.ml" +# 6913 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6883,9 +6931,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_statement = -# 1126 "parser_cocci_menhir.mly" +# 1137 "parser_cocci_menhir.mly" ( [_1] ) -# 6889 "parser_cocci_menhir.ml" +# 6937 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6914,20 +6962,20 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 6920 "parser_cocci_menhir.ml" +# 6968 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let t : 'tv_midzero_list_fun_start_fun_start_ = Obj.magic t in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 6926 "parser_cocci_menhir.ml" +# 6974 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_decl_statement = -# 1135 "parser_cocci_menhir.mly" +# 1146 "parser_cocci_menhir.mly" ( let (mids,code) = t in if List.for_all (function x -> @@ -6937,7 +6985,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct else [Ast0.wrap(Ast0.Disj(P.clt2mcode "(" _1, code, mids, P.clt2mcode ")" _3))] ) -# 6941 "parser_cocci_menhir.ml" +# 6989 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6958,15 +7006,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 6962 "parser_cocci_menhir.ml" +# 7010 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_statement_expr = -# 1148 "parser_cocci_menhir.mly" +# 1159 "parser_cocci_menhir.mly" ( let (nm,pure,clt) = _1 in [Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] ) -# 6970 "parser_cocci_menhir.ml" +# 7018 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -6988,13 +7036,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_statement_expr = -# 1151 "parser_cocci_menhir.mly" +# 1162 "parser_cocci_menhir.mly" ( List.map (function x -> Ast0.wrap (Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),x))) _1 ) -# 6998 "parser_cocci_menhir.ml" +# 7046 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7016,9 +7064,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_decl_statement_expr = -# 1156 "parser_cocci_menhir.mly" +# 1167 "parser_cocci_menhir.mly" ( [_1] ) -# 7022 "parser_cocci_menhir.ml" +# 7070 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7047,20 +7095,20 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 7053 "parser_cocci_menhir.ml" +# 7101 "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 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 7059 "parser_cocci_menhir.ml" +# 7107 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_decl_statement_expr = -# 1165 "parser_cocci_menhir.mly" +# 1176 "parser_cocci_menhir.mly" ( let (mids,code) = t in if List.for_all (function [] -> true | _ -> false) code then [] @@ -7069,7 +7117,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct List.map (function x -> Ast0.wrap(Ast0.DOTS x)) code in [Ast0.wrap(Ast0.Disj(P.clt2mcode "(" _1, dot_code, mids, P.clt2mcode ")" _3))] ) -# 7073 "parser_cocci_menhir.ml" +# 7121 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7093,17 +7141,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7099 "parser_cocci_menhir.ml" +# 7147 "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_decl_var = -# 937 "parser_cocci_menhir.mly" +# 942 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv))] ) -# 7107 "parser_cocci_menhir.ml" +# 7155 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7132,9 +7180,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7138 "parser_cocci_menhir.ml" +# 7186 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_comma_list_d_ident_ = Obj.magic d in let t : 'tv_ctype = Obj.magic t in @@ -7144,16 +7192,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 7148 "parser_cocci_menhir.ml" +# 7196 "parser_cocci_menhir.ml" in -# 939 "parser_cocci_menhir.mly" +# 944 "parser_cocci_menhir.mly" ( List.map (function (id,fn) -> Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv))) d ) -# 7157 "parser_cocci_menhir.ml" +# 7205 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7187,9 +7235,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7193 "parser_cocci_menhir.ml" +# 7241 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_comma_list_d_ident_ = Obj.magic d in let t : 'tv_ctype = Obj.magic t in @@ -7201,16 +7249,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7205 "parser_cocci_menhir.ml" +# 7253 "parser_cocci_menhir.ml" in -# 939 "parser_cocci_menhir.mly" +# 944 "parser_cocci_menhir.mly" ( List.map (function (id,fn) -> Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv))) d ) -# 7214 "parser_cocci_menhir.ml" +# 7262 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7232,9 +7280,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_f_ in let _endpos = _endpos_f_ in let _v : 'tv_decl_var = -# 943 "parser_cocci_menhir.mly" +# 948 "parser_cocci_menhir.mly" ( [f] ) -# 7238 "parser_cocci_menhir.ml" +# 7286 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7273,15 +7321,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7279 "parser_cocci_menhir.ml" +# 7327 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7285 "parser_cocci_menhir.ml" +# 7333 "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 @@ -7291,14 +7339,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 7295 "parser_cocci_menhir.ml" +# 7343 "parser_cocci_menhir.ml" in -# 945 "parser_cocci_menhir.mly" +# 950 "parser_cocci_menhir.mly" (let (id,fn) = d in [Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))]) -# 7302 "parser_cocci_menhir.ml" +# 7350 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7342,15 +7390,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7348 "parser_cocci_menhir.ml" +# 7396 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7354 "parser_cocci_menhir.ml" +# 7402 "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 @@ -7362,14 +7410,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7366 "parser_cocci_menhir.ml" +# 7414 "parser_cocci_menhir.ml" in -# 945 "parser_cocci_menhir.mly" +# 950 "parser_cocci_menhir.mly" (let (id,fn) = d in [Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))]) -# 7373 "parser_cocci_menhir.ml" +# 7421 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7398,9 +7446,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7404 "parser_cocci_menhir.ml" +# 7452 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_comma_list_d_ident_ = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7410,25 +7458,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 7414 "parser_cocci_menhir.ml" +# 7462 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 7421 "parser_cocci_menhir.ml" +# 7469 "parser_cocci_menhir.ml" in -# 950 "parser_cocci_menhir.mly" +# 955 "parser_cocci_menhir.mly" ( List.map (function (id,fn) -> 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))) d ) -# 7432 "parser_cocci_menhir.ml" +# 7480 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7462,9 +7510,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7468 "parser_cocci_menhir.ml" +# 7516 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_comma_list_d_ident_ = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7476,25 +7524,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7480 "parser_cocci_menhir.ml" +# 7528 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 7487 "parser_cocci_menhir.ml" +# 7535 "parser_cocci_menhir.ml" in -# 950 "parser_cocci_menhir.mly" +# 955 "parser_cocci_menhir.mly" ( List.map (function (id,fn) -> 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))) d ) -# 7498 "parser_cocci_menhir.ml" +# 7546 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7528,9 +7576,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7534 "parser_cocci_menhir.ml" +# 7582 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_comma_list_d_ident_ = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7541,7 +7589,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 7545 "parser_cocci_menhir.ml" +# 7593 "parser_cocci_menhir.ml" in let s = @@ -7549,18 +7597,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7553 "parser_cocci_menhir.ml" +# 7601 "parser_cocci_menhir.ml" in -# 950 "parser_cocci_menhir.mly" +# 955 "parser_cocci_menhir.mly" ( List.map (function (id,fn) -> 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))) d ) -# 7564 "parser_cocci_menhir.ml" +# 7612 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7599,9 +7647,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7605 "parser_cocci_menhir.ml" +# 7653 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_comma_list_d_ident_ = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7614,7 +7662,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7618 "parser_cocci_menhir.ml" +# 7666 "parser_cocci_menhir.ml" in let s = @@ -7622,18 +7670,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7626 "parser_cocci_menhir.ml" +# 7674 "parser_cocci_menhir.ml" in -# 950 "parser_cocci_menhir.mly" +# 955 "parser_cocci_menhir.mly" ( List.map (function (id,fn) -> 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))) d ) -# 7637 "parser_cocci_menhir.ml" +# 7685 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7672,15 +7720,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7678 "parser_cocci_menhir.ml" +# 7726 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7684 "parser_cocci_menhir.ml" +# 7732 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7690,24 +7738,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 7694 "parser_cocci_menhir.ml" +# 7742 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 7701 "parser_cocci_menhir.ml" +# 7749 "parser_cocci_menhir.ml" in -# 958 "parser_cocci_menhir.mly" +# 963 "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))] ) -# 7711 "parser_cocci_menhir.ml" +# 7759 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7751,15 +7799,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7757 "parser_cocci_menhir.ml" +# 7805 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7763 "parser_cocci_menhir.ml" +# 7811 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7771,24 +7819,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7775 "parser_cocci_menhir.ml" +# 7823 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 7782 "parser_cocci_menhir.ml" +# 7830 "parser_cocci_menhir.ml" in -# 958 "parser_cocci_menhir.mly" +# 963 "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))] ) -# 7792 "parser_cocci_menhir.ml" +# 7840 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7832,15 +7880,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7838 "parser_cocci_menhir.ml" +# 7886 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7844 "parser_cocci_menhir.ml" +# 7892 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7851,7 +7899,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 7855 "parser_cocci_menhir.ml" +# 7903 "parser_cocci_menhir.ml" in let s = @@ -7859,17 +7907,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7863 "parser_cocci_menhir.ml" +# 7911 "parser_cocci_menhir.ml" in -# 958 "parser_cocci_menhir.mly" +# 963 "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))] ) -# 7873 "parser_cocci_menhir.ml" +# 7921 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -7918,15 +7966,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7924 "parser_cocci_menhir.ml" +# 7972 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 7930 "parser_cocci_menhir.ml" +# 7978 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -7939,7 +7987,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7943 "parser_cocci_menhir.ml" +# 7991 "parser_cocci_menhir.ml" in let s = @@ -7947,17 +7995,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 7951 "parser_cocci_menhir.ml" +# 7999 "parser_cocci_menhir.ml" in -# 958 "parser_cocci_menhir.mly" +# 963 "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))] ) -# 7961 "parser_cocci_menhir.ml" +# 8009 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8016,36 +8064,36 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8022 "parser_cocci_menhir.ml" +# 8070 "parser_cocci_menhir.ml" ) = Obj.magic pv in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8027 "parser_cocci_menhir.ml" +# 8075 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8033 "parser_cocci_menhir.ml" +# 8081 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8038 "parser_cocci_menhir.ml" +# 8086 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 8044 "parser_cocci_menhir.ml" +# 8092 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8049 "parser_cocci_menhir.ml" +# 8097 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let _startpos = _startpos_t_ in @@ -8054,11 +8102,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 8058 "parser_cocci_menhir.ml" +# 8106 "parser_cocci_menhir.ml" in -# 968 "parser_cocci_menhir.mly" +# 973 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -8066,7 +8114,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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))] ) -# 8070 "parser_cocci_menhir.ml" +# 8118 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8130,36 +8178,36 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8136 "parser_cocci_menhir.ml" +# 8184 "parser_cocci_menhir.ml" ) = Obj.magic pv in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8141 "parser_cocci_menhir.ml" +# 8189 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8147 "parser_cocci_menhir.ml" +# 8195 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8152 "parser_cocci_menhir.ml" +# 8200 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 8158 "parser_cocci_menhir.ml" +# 8206 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8163 "parser_cocci_menhir.ml" +# 8211 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let x0 : 'tv_storage = Obj.magic x0 in @@ -8170,11 +8218,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 8174 "parser_cocci_menhir.ml" +# 8222 "parser_cocci_menhir.ml" in -# 968 "parser_cocci_menhir.mly" +# 973 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -8182,7 +8230,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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))] ) -# 8186 "parser_cocci_menhir.ml" +# 8234 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8221,29 +8269,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _5 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8227 "parser_cocci_menhir.ml" +# 8275 "parser_cocci_menhir.ml" ) = Obj.magic _5 in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8232 "parser_cocci_menhir.ml" +# 8280 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr_list_option = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8238 "parser_cocci_menhir.ml" +# 8286 "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_decl_var = -# 976 "parser_cocci_menhir.mly" +# 981 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.MacroDecl(_1,P.clt2mcode "(" _2,_3, P.clt2mcode ")" _4,P.clt2mcode ";" _5))] ) -# 8247 "parser_cocci_menhir.ml" +# 8295 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8312,42 +8360,42 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8318 "parser_cocci_menhir.ml" +# 8366 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8324 "parser_cocci_menhir.ml" +# 8372 "parser_cocci_menhir.ml" ) = Obj.magic q in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8329 "parser_cocci_menhir.ml" +# 8377 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8335 "parser_cocci_menhir.ml" +# 8383 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8340 "parser_cocci_menhir.ml" +# 8388 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 8346 "parser_cocci_menhir.ml" +# 8394 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8351 "parser_cocci_menhir.ml" +# 8399 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let _startpos = _startpos_t_ in @@ -8356,11 +8404,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 8360 "parser_cocci_menhir.ml" +# 8408 "parser_cocci_menhir.ml" in -# 982 "parser_cocci_menhir.mly" +# 987 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -8368,7 +8416,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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))]) -# 8372 "parser_cocci_menhir.ml" +# 8420 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8442,42 +8490,42 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8448 "parser_cocci_menhir.ml" +# 8496 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8454 "parser_cocci_menhir.ml" +# 8502 "parser_cocci_menhir.ml" ) = Obj.magic q in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8459 "parser_cocci_menhir.ml" +# 8507 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8465 "parser_cocci_menhir.ml" +# 8513 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8470 "parser_cocci_menhir.ml" +# 8518 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 8476 "parser_cocci_menhir.ml" +# 8524 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 8481 "parser_cocci_menhir.ml" +# 8529 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let x0 : 'tv_storage = Obj.magic x0 in @@ -8488,11 +8536,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 8492 "parser_cocci_menhir.ml" +# 8540 "parser_cocci_menhir.ml" in -# 982 "parser_cocci_menhir.mly" +# 987 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -8500,7 +8548,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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))]) -# 8504 "parser_cocci_menhir.ml" +# 8552 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8534,24 +8582,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8540 "parser_cocci_menhir.ml" +# 8588 "parser_cocci_menhir.ml" ) = Obj.magic pv in let id : 'tv_typedef_ident = Obj.magic id in let t : 'tv_ctype_full = Obj.magic t in let s : ( # 53 "parser_cocci_menhir.mly" (Data.clt) -# 8547 "parser_cocci_menhir.ml" +# 8595 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_pv_ in let _v : 'tv_decl_var = -# 990 "parser_cocci_menhir.mly" +# 995 "parser_cocci_menhir.mly" ( let s = P.clt2mcode "typedef" s in [Ast0.wrap(Ast0.Typedef(s,t,id,P.clt2mcode ";" pv))] ) -# 8555 "parser_cocci_menhir.ml" +# 8603 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8573,13 +8621,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_define_param_list = -# 698 "parser_cocci_menhir.mly" +# 703 "parser_cocci_menhir.mly" (let circle x = match Ast0.unwrap x with Ast0.DPcircles(_) -> true | _ -> false in if List.exists circle _1 then Ast0.wrap(Ast0.CIRCLES(_1)) else Ast0.wrap(Ast0.DOTS(_1)) ) -# 8583 "parser_cocci_menhir.ml" +# 8631 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8601,9 +8649,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_define_param_list_option = -# 722 "parser_cocci_menhir.mly" +# 727 "parser_cocci_menhir.mly" ( _1 ) -# 8607 "parser_cocci_menhir.ml" +# 8655 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8618,9 +8666,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_define_param_list_option = -# 723 "parser_cocci_menhir.mly" +# 728 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS([])) ) -# 8624 "parser_cocci_menhir.ml" +# 8672 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8642,9 +8690,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_define_param_list_start = -# 705 "parser_cocci_menhir.mly" +# 710 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.DParam _1)] ) -# 8648 "parser_cocci_menhir.ml" +# 8696 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8674,18 +8722,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_define_param_list_start = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 8680 "parser_cocci_menhir.ml" +# 8728 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_ident = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_define_param_list_start = -# 707 "parser_cocci_menhir.mly" +# 712 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DParam _1):: Ast0.wrap(Ast0.DPComma(P.clt2mcode "," _2))::_3 ) -# 8689 "parser_cocci_menhir.ml" +# 8737 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8710,17 +8758,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let r : 'tv_list_dp_comma_args_TEllipsis__ = Obj.magic r in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 8716 "parser_cocci_menhir.ml" +# 8764 "parser_cocci_menhir.ml" ) = Obj.magic d in let _startpos = _startpos_d_ in let _endpos = _endpos_r_ in let _v : 'tv_define_param_list_start = -# 710 "parser_cocci_menhir.mly" +# 715 "parser_cocci_menhir.mly" ( (P.mkdpdots "..." d):: (List.concat (List.map (function x -> x (P.mkdpdots "...")) r)) ) -# 8724 "parser_cocci_menhir.ml" +# 8772 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8739,14 +8787,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 80 "parser_cocci_menhir.mly" +# 81 "parser_cocci_menhir.mly" (Data.clt * token) -# 8745 "parser_cocci_menhir.ml" +# 8793 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_defineop = -# 659 "parser_cocci_menhir.mly" +# 664 "parser_cocci_menhir.mly" ( let (clt,ident) = _1 in function body -> Ast0.wrap @@ -8763,7 +8811,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct "unexpected name for a #define")), Ast0.wrap Ast0.NoParams, body)) ) -# 8767 "parser_cocci_menhir.ml" +# 8815 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8792,20 +8840,20 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 8798 "parser_cocci_menhir.ml" +# 8846 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_define_param_list_option = Obj.magic _2 in let _1 : ( -# 81 "parser_cocci_menhir.mly" +# 82 "parser_cocci_menhir.mly" (Data.clt * token * int) -# 8804 "parser_cocci_menhir.ml" +# 8852 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_defineop = -# 676 "parser_cocci_menhir.mly" +# 681 "parser_cocci_menhir.mly" ( let (clt,ident,parenoff) = _1 in let (arity,line,lline,offset,col,strbef,straft,pos) = clt in let lp = @@ -8824,7 +8872,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (Semantic_cocci.Semantic "unexpected name for a #define")), Ast0.wrap (Ast0.DParams (lp,_2,P.clt2mcode ")" _3)),body)) ) -# 8828 "parser_cocci_menhir.ml" +# 8876 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8846,9 +8894,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_dep = -# 220 "parser_cocci_menhir.mly" +# 221 "parser_cocci_menhir.mly" ( _1 ) -# 8852 "parser_cocci_menhir.ml" +# 8900 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8880,9 +8928,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_dep = -# 221 "parser_cocci_menhir.mly" +# 222 "parser_cocci_menhir.mly" ( Ast.AndDep(_1, _3) ) -# 8886 "parser_cocci_menhir.ml" +# 8934 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8914,9 +8962,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_dep = -# 222 "parser_cocci_menhir.mly" +# 223 "parser_cocci_menhir.mly" ( Ast.OrDep (_1, _3) ) -# 8920 "parser_cocci_menhir.ml" +# 8968 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8931,9 +8979,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_depends = -# 216 "parser_cocci_menhir.mly" +# 217 "parser_cocci_menhir.mly" ( Ast.NoDep ) -# 8937 "parser_cocci_menhir.ml" +# 8985 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8963,9 +9011,148 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_parents_ in let _v : 'tv_depends = -# 217 "parser_cocci_menhir.mly" +# 218 "parser_cocci_menhir.mly" ( parents ) -# 8969 "parser_cocci_menhir.ml" +# 9017 "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 { + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let _2 : 'tv_ident = Obj.magic _2 in + let _1 : ( +# 107 "parser_cocci_menhir.mly" + (Data.clt) +# 9044 "parser_cocci_menhir.ml" + ) = Obj.magic _1 in + let _startpos = _startpos__1_ in + let _endpos = _endpos__2_ in + let _v : 'tv_designator = +# 1093 "parser_cocci_menhir.mly" + ( Ast0.DesignatorField (P.clt2mcode "." _1,_2) ) +# 9051 "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 { + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + } = _menhir_stack in + let _3 : ( +# 102 "parser_cocci_menhir.mly" + (Data.clt) +# 9082 "parser_cocci_menhir.ml" + ) = Obj.magic _3 in + let _2 : 'tv_eexpr = Obj.magic _2 in + let _1 : ( +# 102 "parser_cocci_menhir.mly" + (Data.clt) +# 9088 "parser_cocci_menhir.ml" + ) = Obj.magic _1 in + let _startpos = _startpos__1_ in + let _endpos = _endpos__3_ in + let _v : 'tv_designator = +# 1095 "parser_cocci_menhir.mly" + ( Ast0.DesignatorIndex (P.clt2mcode "[" _1,_2,P.clt2mcode "]" _3) ) +# 9095 "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 { + MenhirLib.EngineTypes.semv = _5; + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.semv = _4; + MenhirLib.EngineTypes.startp = _startpos__4_; + MenhirLib.EngineTypes.endp = _endpos__4_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + } = _menhir_stack in + let _5 : ( +# 102 "parser_cocci_menhir.mly" + (Data.clt) +# 9136 "parser_cocci_menhir.ml" + ) = Obj.magic _5 in + let _4 : 'tv_eexpr = Obj.magic _4 in + let _3 : ( +# 73 "parser_cocci_menhir.mly" + (Data.clt) +# 9142 "parser_cocci_menhir.ml" + ) = Obj.magic _3 in + let _2 : 'tv_eexpr = Obj.magic _2 in + let _1 : ( +# 102 "parser_cocci_menhir.mly" + (Data.clt) +# 9148 "parser_cocci_menhir.ml" + ) = Obj.magic _1 in + let _startpos = _startpos__1_ in + let _endpos = _endpos__5_ in + let _v : 'tv_designator = +# 1097 "parser_cocci_menhir.mly" + ( Ast0.DesignatorRange (P.clt2mcode "[" _1,_2,P.clt2mcode "..." _3, + _4,P.clt2mcode "]" _5) ) +# 9156 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -8987,9 +9174,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_dexpr = -# 1185 "parser_cocci_menhir.mly" +# 1196 "parser_cocci_menhir.mly" ( _1 ) -# 8993 "parser_cocci_menhir.ml" +# 9180 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9015,9 +9202,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_disable = -# 235 "parser_cocci_menhir.mly" +# 236 "parser_cocci_menhir.mly" ( List.map P.id2name _2 ) -# 9021 "parser_cocci_menhir.ml" +# 9208 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9036,16 +9223,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9042 "parser_cocci_menhir.ml" +# 9229 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_dot_expressions = -# 1194 "parser_cocci_menhir.mly" +# 1205 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Edots(P.clt2mcode "..." _1,None)) ) -# 9049 "parser_cocci_menhir.ml" +# 9236 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9067,9 +9254,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_dot_expressions = -# 1195 "parser_cocci_menhir.mly" +# 1206 "parser_cocci_menhir.mly" ( _1 ) -# 9073 "parser_cocci_menhir.ml" +# 9260 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9093,22 +9280,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9099 "parser_cocci_menhir.ml" +# 9286 "parser_cocci_menhir.ml" ) = Obj.magic d in let c : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 9104 "parser_cocci_menhir.ml" +# 9291 "parser_cocci_menhir.ml" ) = Obj.magic c in let _startpos = _startpos_c_ in let _endpos = _endpos_d_ in let _v : 'tv_dp_comma_args_TEllipsis_ = -# 715 "parser_cocci_menhir.mly" +# 720 "parser_cocci_menhir.mly" ( function dot_builder -> [Ast0.wrap(Ast0.DPComma(P.clt2mcode "," c)); dot_builder d] ) -# 9112 "parser_cocci_menhir.ml" +# 9299 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9133,18 +9320,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_ident = Obj.magic _2 in let _1 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 9139 "parser_cocci_menhir.ml" +# 9326 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_dp_comma_args_TEllipsis_ = -# 718 "parser_cocci_menhir.mly" +# 723 "parser_cocci_menhir.mly" ( function dot_builder -> [Ast0.wrap(Ast0.DPComma(P.clt2mcode "," _1)); Ast0.wrap(Ast0.DParam _2)] ) -# 9148 "parser_cocci_menhir.ml" +# 9335 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9163,16 +9350,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9169 "parser_cocci_menhir.ml" +# 9356 "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_ = -# 1782 "parser_cocci_menhir.mly" +# 1794 "parser_cocci_menhir.mly" ( (d,None) ) -# 9176 "parser_cocci_menhir.ml" +# 9363 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9209,16 +9396,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let w : 'tv_eexpr = Obj.magic w in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9215 "parser_cocci_menhir.ml" +# 9402 "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_ = -# 1783 "parser_cocci_menhir.mly" +# 1795 "parser_cocci_menhir.mly" ( (d,Some w) ) -# 9222 "parser_cocci_menhir.ml" +# 9409 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9237,16 +9424,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9243 "parser_cocci_menhir.ml" +# 9430 "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_ = -# 1782 "parser_cocci_menhir.mly" +# 1794 "parser_cocci_menhir.mly" ( (d,None) ) -# 9250 "parser_cocci_menhir.ml" +# 9437 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9283,16 +9470,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let w : 'tv_initialize = Obj.magic w in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9289 "parser_cocci_menhir.ml" +# 9476 "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_ = -# 1783 "parser_cocci_menhir.mly" +# 1795 "parser_cocci_menhir.mly" ( (d,Some w) ) -# 9296 "parser_cocci_menhir.ml" +# 9483 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9311,16 +9498,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9317 "parser_cocci_menhir.ml" +# 9504 "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_ = -# 1782 "parser_cocci_menhir.mly" +# 1794 "parser_cocci_menhir.mly" ( (d,None) ) -# 9324 "parser_cocci_menhir.ml" +# 9511 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9357,16 +9544,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let w : 'tv_struct_decl = Obj.magic w in let d : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 9363 "parser_cocci_menhir.ml" +# 9550 "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_ = -# 1783 "parser_cocci_menhir.mly" +# 1795 "parser_cocci_menhir.mly" ( (d,Some w) ) -# 9370 "parser_cocci_menhir.ml" +# 9557 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9388,9 +9575,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_eexpr = -# 1183 "parser_cocci_menhir.mly" +# 1194 "parser_cocci_menhir.mly" ( _1 ) -# 9394 "parser_cocci_menhir.ml" +# 9581 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9412,7 +9599,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_eexpr_list = -# 1726 "parser_cocci_menhir.mly" +# 1738 "parser_cocci_menhir.mly" (let circle x = match Ast0.unwrap x with Ast0.Ecircles(_) -> true | _ -> false in let star x = @@ -9423,7 +9610,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct if List.exists star _1 then Ast0.wrap(Ast0.STARS(_1)) else Ast0.wrap(Ast0.DOTS(_1)) ) -# 9427 "parser_cocci_menhir.ml" +# 9614 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9445,9 +9632,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_eexpr_list_option = -# 1765 "parser_cocci_menhir.mly" +# 1777 "parser_cocci_menhir.mly" ( _1 ) -# 9451 "parser_cocci_menhir.ml" +# 9638 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9462,9 +9649,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_eexpr_list_option = -# 1766 "parser_cocci_menhir.mly" +# 1778 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS([])) ) -# 9468 "parser_cocci_menhir.ml" +# 9655 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9486,9 +9673,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_eexpr_list_start = -# 1753 "parser_cocci_menhir.mly" +# 1765 "parser_cocci_menhir.mly" ( [_1] ) -# 9492 "parser_cocci_menhir.ml" +# 9679 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9518,17 +9705,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_eexpr_list_start = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 9524 "parser_cocci_menhir.ml" +# 9711 "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_eexpr_list_start = -# 1755 "parser_cocci_menhir.mly" +# 1767 "parser_cocci_menhir.mly" ( _1::Ast0.wrap(Ast0.EComma(P.clt2mcode "," _2))::_3 ) -# 9532 "parser_cocci_menhir.ml" +# 9719 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9570,9 +9757,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__6_ in let _v : 'tv_error_words = -# 1552 "parser_cocci_menhir.mly" +# 1564 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.ERRORWORDS(cl))] ) -# 9576 "parser_cocci_menhir.ml" +# 9763 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9592,9 +9779,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_exists = -# 238 "parser_cocci_menhir.mly" +# 239 "parser_cocci_menhir.mly" ( Ast.Exists ) -# 9598 "parser_cocci_menhir.ml" +# 9785 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9614,9 +9801,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_exists = -# 239 "parser_cocci_menhir.mly" +# 240 "parser_cocci_menhir.mly" ( Ast.Forall ) -# 9620 "parser_cocci_menhir.ml" +# 9807 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9640,9 +9827,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_exists = -# 240 "parser_cocci_menhir.mly" +# 241 "parser_cocci_menhir.mly" ( Ast.ReverseForall ) -# 9646 "parser_cocci_menhir.ml" +# 9833 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9657,9 +9844,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_exists = -# 241 "parser_cocci_menhir.mly" +# 242 "parser_cocci_menhir.mly" ( Ast.Undetermined ) -# 9663 "parser_cocci_menhir.ml" +# 9850 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9681,9 +9868,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_expr = -# 1181 "parser_cocci_menhir.mly" +# 1192 "parser_cocci_menhir.mly" ( _1 ) -# 9687 "parser_cocci_menhir.ml" +# 9874 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9705,9 +9892,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_r_ in let _endpos = _endpos_r_ in let _v : 'tv_expr_dots_TEllipsis_ = -# 1363 "parser_cocci_menhir.mly" +# 1374 "parser_cocci_menhir.mly" ( r ) -# 9711 "parser_cocci_menhir.ml" +# 9898 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9722,9 +9909,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_extends = -# 211 "parser_cocci_menhir.mly" +# 212 "parser_cocci_menhir.mly" ( () ) -# 9728 "parser_cocci_menhir.ml" +# 9915 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9749,14 +9936,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let parent : ( # 47 "parser_cocci_menhir.mly" (string) -# 9753 "parser_cocci_menhir.ml" +# 9940 "parser_cocci_menhir.ml" ) = Obj.magic parent in let _startpos = _startpos__1_ in let _endpos = _endpos_parent_ in let _v : 'tv_extends = -# 213 "parser_cocci_menhir.mly" +# 214 "parser_cocci_menhir.mly" ( !Data.install_bindings (parent) ) -# 9760 "parser_cocci_menhir.ml" +# 9947 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9780,23 +9967,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 82 "parser_cocci_menhir.mly" +# 83 "parser_cocci_menhir.mly" (string * Data.clt) -# 9786 "parser_cocci_menhir.ml" +# 9973 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( -# 82 "parser_cocci_menhir.mly" +# 83 "parser_cocci_menhir.mly" (string * Data.clt) -# 9791 "parser_cocci_menhir.ml" +# 9978 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_filespec = -# 618 "parser_cocci_menhir.mly" +# 623 "parser_cocci_menhir.mly" ( [Ast0.wrap (Ast0.FILEINFO(P.id2mcode _1, P.id2mcode _2))] ) -# 9800 "parser_cocci_menhir.ml" +# 9987 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9824,9 +10011,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_ty_ in let _endpos = _endpos_m_ in let _v : 'tv_fn_ctype = -# 567 "parser_cocci_menhir.mly" +# 572 "parser_cocci_menhir.mly" ( P.pointerify ty m ) -# 9830 "parser_cocci_menhir.ml" +# 10017 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9853,16 +10040,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 9857 "parser_cocci_menhir.ml" +# 10044 "parser_cocci_menhir.ml" ) = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_m_ in let _v : 'tv_fn_ctype = -# 569 "parser_cocci_menhir.mly" +# 574 "parser_cocci_menhir.mly" ( P.pointerify (Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t]))) m ) -# 9866 "parser_cocci_menhir.ml" +# 10053 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9877,9 +10064,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_fninfo = -# 761 "parser_cocci_menhir.mly" +# 766 "parser_cocci_menhir.mly" ( [] ) -# 9883 "parser_cocci_menhir.ml" +# 10070 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9907,13 +10094,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fninfo = -# 763 "parser_cocci_menhir.mly" +# 768 "parser_cocci_menhir.mly" ( try let _ = List.find (function Ast0.FStorage(_) -> true | _ -> false) _2 in raise (Semantic_cocci.Semantic "duplicate storage") with Not_found -> (Ast0.FStorage(_1))::_2 ) -# 9917 "parser_cocci_menhir.ml" +# 10104 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9941,9 +10128,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_t_ in let _endpos = _endpos_r_ in let _v : 'tv_fninfo = -# 768 "parser_cocci_menhir.mly" +# 773 "parser_cocci_menhir.mly" ( (Ast0.FType(t))::r ) -# 9947 "parser_cocci_menhir.ml" +# 10134 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -9970,17 +10157,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 53 "parser_cocci_menhir.mly" (Data.clt) -# 9974 "parser_cocci_menhir.ml" +# 10161 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fninfo = -# 770 "parser_cocci_menhir.mly" +# 775 "parser_cocci_menhir.mly" ( try let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) _2 in raise (Semantic_cocci.Semantic "duplicate inline") with Not_found -> (Ast0.FInline(P.clt2mcode "inline" _1))::_2 ) -# 9984 "parser_cocci_menhir.ml" +# 10171 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10007,17 +10194,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 55 "parser_cocci_menhir.mly" (string * Data.clt) -# 10011 "parser_cocci_menhir.ml" +# 10198 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fninfo = -# 775 "parser_cocci_menhir.mly" +# 780 "parser_cocci_menhir.mly" ( try let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) _2 in raise (Semantic_cocci.Semantic "multiple attributes") with Not_found -> (Ast0.FAttr(P.id2mcode _1))::_2 ) -# 10021 "parser_cocci_menhir.ml" +# 10208 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10032,9 +10219,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_fninfo_nt = -# 781 "parser_cocci_menhir.mly" +# 786 "parser_cocci_menhir.mly" ( [] ) -# 10038 "parser_cocci_menhir.ml" +# 10225 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10062,13 +10249,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fninfo_nt = -# 783 "parser_cocci_menhir.mly" +# 788 "parser_cocci_menhir.mly" ( try let _ = List.find (function Ast0.FStorage(_) -> true | _ -> false) _2 in raise (Semantic_cocci.Semantic "duplicate storage") with Not_found -> (Ast0.FStorage(_1))::_2 ) -# 10072 "parser_cocci_menhir.ml" +# 10259 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10095,17 +10282,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 53 "parser_cocci_menhir.mly" (Data.clt) -# 10099 "parser_cocci_menhir.ml" +# 10286 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fninfo_nt = -# 789 "parser_cocci_menhir.mly" +# 794 "parser_cocci_menhir.mly" ( try let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) _2 in raise (Semantic_cocci.Semantic "duplicate inline") with Not_found -> (Ast0.FInline(P.clt2mcode "inline" _1))::_2 ) -# 10109 "parser_cocci_menhir.ml" +# 10296 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10132,17 +10319,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 55 "parser_cocci_menhir.mly" (string * Data.clt) -# 10136 "parser_cocci_menhir.ml" +# 10323 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fninfo_nt = -# 794 "parser_cocci_menhir.mly" +# 799 "parser_cocci_menhir.mly" ( try let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) _2 in raise (Semantic_cocci.Semantic "duplicate init") with Not_found -> (Ast0.FAttr(P.id2mcode _1))::_2 ) -# 10146 "parser_cocci_menhir.ml" +# 10333 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10157,9 +10344,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_fun_after_dots = -# 1674 "parser_cocci_menhir.mly" +# 1686 "parser_cocci_menhir.mly" ([]) -# 10163 "parser_cocci_menhir.ml" +# 10350 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10185,9 +10372,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_dots = -# 1675 "parser_cocci_menhir.mly" +# 1687 "parser_cocci_menhir.mly" (_2) -# 10191 "parser_cocci_menhir.ml" +# 10378 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10215,9 +10402,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_dots = -# 1676 "parser_cocci_menhir.mly" +# 1688 "parser_cocci_menhir.mly" (Ast0.wrap(Ast0.Exp(_1))::_2) -# 10221 "parser_cocci_menhir.ml" +# 10408 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10245,9 +10432,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_dots = -# 1677 "parser_cocci_menhir.mly" +# 1689 "parser_cocci_menhir.mly" (_1@_2) -# 10251 "parser_cocci_menhir.ml" +# 10438 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10262,9 +10449,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_fun_after_dots_or = -# 1684 "parser_cocci_menhir.mly" +# 1696 "parser_cocci_menhir.mly" ([]) -# 10268 "parser_cocci_menhir.ml" +# 10455 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10290,9 +10477,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_dots_or = -# 1685 "parser_cocci_menhir.mly" +# 1697 "parser_cocci_menhir.mly" (_2) -# 10296 "parser_cocci_menhir.ml" +# 10483 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10320,9 +10507,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_dots_or = -# 1686 "parser_cocci_menhir.mly" +# 1698 "parser_cocci_menhir.mly" (Ast0.wrap(Ast0.Exp(_1))::_2) -# 10326 "parser_cocci_menhir.ml" +# 10513 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10350,9 +10537,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_dots_or = -# 1687 "parser_cocci_menhir.mly" +# 1699 "parser_cocci_menhir.mly" (_1@_2) -# 10356 "parser_cocci_menhir.ml" +# 10543 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10380,9 +10567,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_exp = -# 1680 "parser_cocci_menhir.mly" +# 1692 "parser_cocci_menhir.mly" (_1::_2) -# 10386 "parser_cocci_menhir.ml" +# 10573 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10397,9 +10584,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_fun_after_exp_or = -# 1690 "parser_cocci_menhir.mly" +# 1702 "parser_cocci_menhir.mly" ([]) -# 10403 "parser_cocci_menhir.ml" +# 10590 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10427,9 +10614,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_exp_or = -# 1691 "parser_cocci_menhir.mly" +# 1703 "parser_cocci_menhir.mly" (_1::_2) -# 10433 "parser_cocci_menhir.ml" +# 10620 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10444,9 +10631,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_fun_after_stm = -# 1669 "parser_cocci_menhir.mly" +# 1681 "parser_cocci_menhir.mly" ([]) -# 10450 "parser_cocci_menhir.ml" +# 10637 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10474,9 +10661,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_stm = -# 1670 "parser_cocci_menhir.mly" +# 1682 "parser_cocci_menhir.mly" (_1::_2) -# 10480 "parser_cocci_menhir.ml" +# 10667 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10504,9 +10691,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_fun_after_stm = -# 1671 "parser_cocci_menhir.mly" +# 1683 "parser_cocci_menhir.mly" (_1@_2) -# 10510 "parser_cocci_menhir.ml" +# 10697 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10528,9 +10715,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_fun_start = -# 1666 "parser_cocci_menhir.mly" +# 1678 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS(_1)) ) -# 10534 "parser_cocci_menhir.ml" +# 10721 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10552,9 +10739,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_func_ident = -# 1471 "parser_cocci_menhir.mly" +# 1482 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Id(P.id2mcode _1)) ) -# 10558 "parser_cocci_menhir.ml" +# 10745 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10575,15 +10762,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 61 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 10579 "parser_cocci_menhir.ml" +# 10766 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_func_ident = -# 1473 "parser_cocci_menhir.mly" +# 1484 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) ) -# 10587 "parser_cocci_menhir.ml" +# 10774 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10604,15 +10791,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 61 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 10608 "parser_cocci_menhir.ml" +# 10795 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_func_ident = -# 1476 "parser_cocci_menhir.mly" +# 1487 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaFunc(P.clt2mcode nm clt,constraints,pure)) ) -# 10616 "parser_cocci_menhir.ml" +# 10803 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10633,16 +10820,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 61 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 10637 "parser_cocci_menhir.ml" +# 10824 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_func_ident = -# 1479 "parser_cocci_menhir.mly" +# 1490 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap (Ast0.MetaLocalFunc(P.clt2mcode nm clt,constraints,pure)) ) -# 10646 "parser_cocci_menhir.ml" +# 10833 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10700,40 +10887,40 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rb : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 10706 "parser_cocci_menhir.ml" +# 10893 "parser_cocci_menhir.ml" ) = Obj.magic rb in let b : 'tv_fun_start = Obj.magic b in let lb : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 10712 "parser_cocci_menhir.ml" +# 10899 "parser_cocci_menhir.ml" ) = Obj.magic lb in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 10717 "parser_cocci_menhir.ml" +# 10904 "parser_cocci_menhir.ml" ) = Obj.magic rp in let d : 'tv_decl_list_decl_ = Obj.magic d in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 10723 "parser_cocci_menhir.ml" +# 10910 "parser_cocci_menhir.ml" ) = Obj.magic lp in let i : 'tv_func_ident = Obj.magic i in let f : 'tv_fninfo = Obj.magic f in let _startpos = _startpos_f_ in let _endpos = _endpos_rb_ in let _v : 'tv_fundecl = -# 753 "parser_cocci_menhir.mly" +# 758 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.FunDecl((Ast0.default_info(),Ast0.context_befaft()), f, i, P.clt2mcode "(" lp, d, P.clt2mcode ")" rp, P.clt2mcode "{" lb, b, P.clt2mcode "}" rb)) ) -# 10737 "parser_cocci_menhir.ml" +# 10924 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10777,20 +10964,20 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pt : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 10783 "parser_cocci_menhir.ml" +# 10970 "parser_cocci_menhir.ml" ) = Obj.magic pt in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 10788 "parser_cocci_menhir.ml" +# 10975 "parser_cocci_menhir.ml" ) = Obj.magic rp in let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 10794 "parser_cocci_menhir.ml" +# 10981 "parser_cocci_menhir.ml" ) = Obj.magic lp in let id : 'tv_func_ident = Obj.magic id in let t : 'tv_ctype = Obj.magic t in @@ -10800,11 +10987,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 10804 "parser_cocci_menhir.ml" +# 10991 "parser_cocci_menhir.ml" in -# 730 "parser_cocci_menhir.mly" +# 735 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.UnInit (s, @@ -10812,7 +10999,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (Ast0.FunctionType(Some t, P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)), id, P.clt2mcode ";" pt)) ) -# 10816 "parser_cocci_menhir.ml" +# 11003 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10861,20 +11048,20 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pt : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 10867 "parser_cocci_menhir.ml" +# 11054 "parser_cocci_menhir.ml" ) = Obj.magic pt in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 10872 "parser_cocci_menhir.ml" +# 11059 "parser_cocci_menhir.ml" ) = Obj.magic rp in let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 10878 "parser_cocci_menhir.ml" +# 11065 "parser_cocci_menhir.ml" ) = Obj.magic lp in let id : 'tv_func_ident = Obj.magic id in let t : 'tv_ctype = Obj.magic t in @@ -10886,11 +11073,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 10890 "parser_cocci_menhir.ml" +# 11077 "parser_cocci_menhir.ml" in -# 730 "parser_cocci_menhir.mly" +# 735 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.UnInit (s, @@ -10898,7 +11085,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (Ast0.FunctionType(Some t, P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)), id, P.clt2mcode ";" pt)) ) -# 10902 "parser_cocci_menhir.ml" +# 11089 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -10942,26 +11129,26 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pt : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 10948 "parser_cocci_menhir.ml" +# 11135 "parser_cocci_menhir.ml" ) = Obj.magic pt in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 10953 "parser_cocci_menhir.ml" +# 11140 "parser_cocci_menhir.ml" ) = Obj.magic rp in let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 10959 "parser_cocci_menhir.ml" +# 11146 "parser_cocci_menhir.ml" ) = Obj.magic lp in let id : 'tv_func_ident = Obj.magic id in let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 10965 "parser_cocci_menhir.ml" +# 11152 "parser_cocci_menhir.ml" ) = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_pt_ in @@ -10969,11 +11156,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 10973 "parser_cocci_menhir.ml" +# 11160 "parser_cocci_menhir.ml" in -# 739 "parser_cocci_menhir.mly" +# 744 "parser_cocci_menhir.mly" ( let t = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in Ast0.wrap (Ast0.UnInit @@ -10982,7 +11169,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (Ast0.FunctionType(Some t, P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)), id, P.clt2mcode ";" pt)) ) -# 10986 "parser_cocci_menhir.ml" +# 11173 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11031,26 +11218,26 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pt : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 11037 "parser_cocci_menhir.ml" +# 11224 "parser_cocci_menhir.ml" ) = Obj.magic pt in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 11042 "parser_cocci_menhir.ml" +# 11229 "parser_cocci_menhir.ml" ) = Obj.magic rp in let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 11048 "parser_cocci_menhir.ml" +# 11235 "parser_cocci_menhir.ml" ) = Obj.magic lp in let id : 'tv_func_ident = Obj.magic id in let t : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 11054 "parser_cocci_menhir.ml" +# 11241 "parser_cocci_menhir.ml" ) = Obj.magic t in let x0 : 'tv_storage = Obj.magic x0 in let _startpos = _startpos_x0_ in @@ -11060,11 +11247,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 11064 "parser_cocci_menhir.ml" +# 11251 "parser_cocci_menhir.ml" in -# 739 "parser_cocci_menhir.mly" +# 744 "parser_cocci_menhir.mly" ( let t = Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" t])) in Ast0.wrap (Ast0.UnInit @@ -11073,7 +11260,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (Ast0.FunctionType(Some t, P.clt2mcode "(" lp, d, P.clt2mcode ")" rp)), id, P.clt2mcode ";" pt)) ) -# 11077 "parser_cocci_menhir.ml" +# 11264 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11094,22 +11281,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let r0 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11098 "parser_cocci_menhir.ml" +# 11285 "parser_cocci_menhir.ml" ) = Obj.magic r0 in let _startpos = _startpos_r0_ in let _endpos = _endpos_r0_ in let _v : 'tv_generic_ctype = let q = let r = r0 in -# 575 "parser_cocci_menhir.mly" +# 580 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) ) -# 11107 "parser_cocci_menhir.ml" +# 11294 "parser_cocci_menhir.ml" in -# 499 "parser_cocci_menhir.mly" +# 504 "parser_cocci_menhir.mly" ( q None ) -# 11113 "parser_cocci_menhir.ml" +# 11300 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11130,22 +11317,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let r0 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11134 "parser_cocci_menhir.ml" +# 11321 "parser_cocci_menhir.ml" ) = Obj.magic r0 in let _startpos = _startpos_r0_ in let _endpos = _endpos_r0_ in let _v : 'tv_generic_ctype = let q = let r = r0 in -# 577 "parser_cocci_menhir.mly" +# 582 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) ) -# 11143 "parser_cocci_menhir.ml" +# 11330 "parser_cocci_menhir.ml" in -# 499 "parser_cocci_menhir.mly" +# 504 "parser_cocci_menhir.mly" ( q None ) -# 11149 "parser_cocci_menhir.ml" +# 11336 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11167,9 +11354,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_generic_ctype = -# 500 "parser_cocci_menhir.mly" +# 505 "parser_cocci_menhir.mly" ( _1 ) -# 11173 "parser_cocci_menhir.ml" +# 11360 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11195,12 +11382,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11199 "parser_cocci_menhir.ml" +# 11386 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11204 "parser_cocci_menhir.ml" +# 11391 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11209,21 +11396,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 575 "parser_cocci_menhir.mly" +# 580 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) ) -# 11215 "parser_cocci_menhir.ml" +# 11402 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11221 "parser_cocci_menhir.ml" +# 11408 "parser_cocci_menhir.ml" in -# 452 "parser_cocci_menhir.mly" +# 457 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.CharType,[P.clt2mcode "char" ty]))) ) -# 11227 "parser_cocci_menhir.ml" +# 11414 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11249,12 +11436,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11253 "parser_cocci_menhir.ml" +# 11440 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11258 "parser_cocci_menhir.ml" +# 11445 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11263,21 +11450,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 577 "parser_cocci_menhir.mly" +# 582 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) ) -# 11269 "parser_cocci_menhir.ml" +# 11456 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11275 "parser_cocci_menhir.ml" +# 11462 "parser_cocci_menhir.ml" in -# 452 "parser_cocci_menhir.mly" +# 457 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.CharType,[P.clt2mcode "char" ty]))) ) -# 11281 "parser_cocci_menhir.ml" +# 11468 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11298,21 +11485,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11302 "parser_cocci_menhir.ml" +# 11489 "parser_cocci_menhir.ml" ) = Obj.magic ty in let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : 'tv_generic_ctype_full = let q = -# 581 "parser_cocci_menhir.mly" +# 586 "parser_cocci_menhir.mly" ( function x -> x ) -# 11310 "parser_cocci_menhir.ml" +# 11497 "parser_cocci_menhir.ml" in -# 452 "parser_cocci_menhir.mly" +# 457 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.CharType,[P.clt2mcode "char" ty]))) ) -# 11316 "parser_cocci_menhir.ml" +# 11503 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11338,12 +11525,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11342 "parser_cocci_menhir.ml" +# 11529 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11347 "parser_cocci_menhir.ml" +# 11534 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11352,21 +11539,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 575 "parser_cocci_menhir.mly" +# 580 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) ) -# 11358 "parser_cocci_menhir.ml" +# 11545 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11364 "parser_cocci_menhir.ml" +# 11551 "parser_cocci_menhir.ml" in -# 454 "parser_cocci_menhir.mly" +# 459 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.ShortType,[P.clt2mcode "short" ty])))) -# 11370 "parser_cocci_menhir.ml" +# 11557 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11392,12 +11579,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11396 "parser_cocci_menhir.ml" +# 11583 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11401 "parser_cocci_menhir.ml" +# 11588 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11406,21 +11593,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 577 "parser_cocci_menhir.mly" +# 582 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) ) -# 11412 "parser_cocci_menhir.ml" +# 11599 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11418 "parser_cocci_menhir.ml" +# 11605 "parser_cocci_menhir.ml" in -# 454 "parser_cocci_menhir.mly" +# 459 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.ShortType,[P.clt2mcode "short" ty])))) -# 11424 "parser_cocci_menhir.ml" +# 11611 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11441,21 +11628,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11445 "parser_cocci_menhir.ml" +# 11632 "parser_cocci_menhir.ml" ) = Obj.magic ty in let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : 'tv_generic_ctype_full = let q = -# 581 "parser_cocci_menhir.mly" +# 586 "parser_cocci_menhir.mly" ( function x -> x ) -# 11453 "parser_cocci_menhir.ml" +# 11640 "parser_cocci_menhir.ml" in -# 454 "parser_cocci_menhir.mly" +# 459 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.ShortType,[P.clt2mcode "short" ty])))) -# 11459 "parser_cocci_menhir.ml" +# 11646 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11481,12 +11668,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11485 "parser_cocci_menhir.ml" +# 11672 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11490 "parser_cocci_menhir.ml" +# 11677 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11495,21 +11682,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 575 "parser_cocci_menhir.mly" +# 580 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) ) -# 11501 "parser_cocci_menhir.ml" +# 11688 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11507 "parser_cocci_menhir.ml" +# 11694 "parser_cocci_menhir.ml" in -# 456 "parser_cocci_menhir.mly" +# 461 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.IntType,[P.clt2mcode "int" ty]))) ) -# 11513 "parser_cocci_menhir.ml" +# 11700 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11535,12 +11722,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11539 "parser_cocci_menhir.ml" +# 11726 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11544 "parser_cocci_menhir.ml" +# 11731 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11549,21 +11736,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 577 "parser_cocci_menhir.mly" +# 582 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) ) -# 11555 "parser_cocci_menhir.ml" +# 11742 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11561 "parser_cocci_menhir.ml" +# 11748 "parser_cocci_menhir.ml" in -# 456 "parser_cocci_menhir.mly" +# 461 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.IntType,[P.clt2mcode "int" ty]))) ) -# 11567 "parser_cocci_menhir.ml" +# 11754 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11584,21 +11771,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11588 "parser_cocci_menhir.ml" +# 11775 "parser_cocci_menhir.ml" ) = Obj.magic ty in let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : 'tv_generic_ctype_full = let q = -# 581 "parser_cocci_menhir.mly" +# 586 "parser_cocci_menhir.mly" ( function x -> x ) -# 11596 "parser_cocci_menhir.ml" +# 11783 "parser_cocci_menhir.ml" in -# 456 "parser_cocci_menhir.mly" +# 461 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.IntType,[P.clt2mcode "int" ty]))) ) -# 11602 "parser_cocci_menhir.ml" +# 11789 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11619,14 +11806,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11623 "parser_cocci_menhir.ml" +# 11810 "parser_cocci_menhir.ml" ) = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_t_ in let _v : 'tv_generic_ctype_full = -# 458 "parser_cocci_menhir.mly" +# 463 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.BaseType(Ast.DoubleType,[P.clt2mcode "double" t])) ) -# 11630 "parser_cocci_menhir.ml" +# 11817 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11647,14 +11834,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let t : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11651 "parser_cocci_menhir.ml" +# 11838 "parser_cocci_menhir.ml" ) = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_t_ in let _v : 'tv_generic_ctype_full = -# 460 "parser_cocci_menhir.mly" +# 465 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.BaseType(Ast.FloatType,[P.clt2mcode "float" t])) ) -# 11658 "parser_cocci_menhir.ml" +# 11845 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11680,12 +11867,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11684 "parser_cocci_menhir.ml" +# 11871 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11689 "parser_cocci_menhir.ml" +# 11876 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11694,21 +11881,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 575 "parser_cocci_menhir.mly" +# 580 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) ) -# 11700 "parser_cocci_menhir.ml" +# 11887 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11706 "parser_cocci_menhir.ml" +# 11893 "parser_cocci_menhir.ml" in -# 462 "parser_cocci_menhir.mly" +# 467 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.LongType,[P.clt2mcode "long" ty]))) ) -# 11712 "parser_cocci_menhir.ml" +# 11899 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11734,12 +11921,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11738 "parser_cocci_menhir.ml" +# 11925 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11743 "parser_cocci_menhir.ml" +# 11930 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty_ in @@ -11748,21 +11935,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 577 "parser_cocci_menhir.mly" +# 582 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) ) -# 11754 "parser_cocci_menhir.ml" +# 11941 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11760 "parser_cocci_menhir.ml" +# 11947 "parser_cocci_menhir.ml" in -# 462 "parser_cocci_menhir.mly" +# 467 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.LongType,[P.clt2mcode "long" ty]))) ) -# 11766 "parser_cocci_menhir.ml" +# 11953 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11783,21 +11970,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11787 "parser_cocci_menhir.ml" +# 11974 "parser_cocci_menhir.ml" ) = Obj.magic ty in let _startpos = _startpos_ty_ in let _endpos = _endpos_ty_ in let _v : 'tv_generic_ctype_full = let q = -# 581 "parser_cocci_menhir.mly" +# 586 "parser_cocci_menhir.mly" ( function x -> x ) -# 11795 "parser_cocci_menhir.ml" +# 11982 "parser_cocci_menhir.ml" in -# 462 "parser_cocci_menhir.mly" +# 467 "parser_cocci_menhir.mly" ( q (Ast0.wrap(Ast0.BaseType(Ast.LongType,[P.clt2mcode "long" ty]))) ) -# 11801 "parser_cocci_menhir.ml" +# 11988 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11828,17 +12015,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty1 : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11832 "parser_cocci_menhir.ml" +# 12019 "parser_cocci_menhir.ml" ) = Obj.magic ty1 in let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11837 "parser_cocci_menhir.ml" +# 12024 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11842 "parser_cocci_menhir.ml" +# 12029 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty1_ in @@ -11847,24 +12034,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 575 "parser_cocci_menhir.mly" +# 580 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) ) -# 11853 "parser_cocci_menhir.ml" +# 12040 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11859 "parser_cocci_menhir.ml" +# 12046 "parser_cocci_menhir.ml" in -# 464 "parser_cocci_menhir.mly" +# 469 "parser_cocci_menhir.mly" ( q (Ast0.wrap (Ast0.BaseType (Ast.LongLongType, [P.clt2mcode "long" ty;P.clt2mcode "long" ty1]))) ) -# 11868 "parser_cocci_menhir.ml" +# 12055 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11895,17 +12082,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty1 : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11899 "parser_cocci_menhir.ml" +# 12086 "parser_cocci_menhir.ml" ) = Obj.magic ty1 in let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11904 "parser_cocci_menhir.ml" +# 12091 "parser_cocci_menhir.ml" ) = Obj.magic ty in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 11909 "parser_cocci_menhir.ml" +# 12096 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_ty1_ in @@ -11914,24 +12101,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 577 "parser_cocci_menhir.mly" +# 582 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) ) -# 11920 "parser_cocci_menhir.ml" +# 12107 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 11926 "parser_cocci_menhir.ml" +# 12113 "parser_cocci_menhir.ml" in -# 464 "parser_cocci_menhir.mly" +# 469 "parser_cocci_menhir.mly" ( q (Ast0.wrap (Ast0.BaseType (Ast.LongLongType, [P.clt2mcode "long" ty;P.clt2mcode "long" ty1]))) ) -# 11935 "parser_cocci_menhir.ml" +# 12122 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -11957,29 +12144,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let ty1 : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11961 "parser_cocci_menhir.ml" +# 12148 "parser_cocci_menhir.ml" ) = Obj.magic ty1 in let ty : ( # 49 "parser_cocci_menhir.mly" (Data.clt) -# 11966 "parser_cocci_menhir.ml" +# 12153 "parser_cocci_menhir.ml" ) = Obj.magic ty in let _startpos = _startpos_ty_ in let _endpos = _endpos_ty1_ in let _v : 'tv_generic_ctype_full = let q = -# 581 "parser_cocci_menhir.mly" +# 586 "parser_cocci_menhir.mly" ( function x -> x ) -# 11974 "parser_cocci_menhir.ml" +# 12161 "parser_cocci_menhir.ml" in -# 464 "parser_cocci_menhir.mly" +# 469 "parser_cocci_menhir.mly" ( q (Ast0.wrap (Ast0.BaseType (Ast.LongLongType, [P.clt2mcode "long" ty;P.clt2mcode "long" ty1]))) ) -# 11983 "parser_cocci_menhir.ml" +# 12170 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12006,14 +12193,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 12010 "parser_cocci_menhir.ml" +# 12197 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_i_ in let _v : 'tv_generic_ctype_full = -# 469 "parser_cocci_menhir.mly" +# 474 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.EnumName(P.clt2mcode "enum" s, i)) ) -# 12017 "parser_cocci_menhir.ml" +# 12204 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12041,9 +12228,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_s_ in let _endpos = _endpos_i_ in let _v : 'tv_generic_ctype_full = -# 471 "parser_cocci_menhir.mly" +# 476 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.StructUnionName(s, Some i)) ) -# 12047 "parser_cocci_menhir.ml" +# 12234 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12077,15 +12264,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let r : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12083 "parser_cocci_menhir.ml" +# 12270 "parser_cocci_menhir.ml" ) = Obj.magic r in let d : 'tv_struct_decl_list = Obj.magic d in let l : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12089 "parser_cocci_menhir.ml" +# 12276 "parser_cocci_menhir.ml" ) = Obj.magic l in let s : 'tv_struct_or_union = Obj.magic s in let _startpos = _startpos_s_ in @@ -12094,17 +12281,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 12098 "parser_cocci_menhir.ml" +# 12285 "parser_cocci_menhir.ml" in -# 474 "parser_cocci_menhir.mly" +# 479 "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)) ) -# 12108 "parser_cocci_menhir.ml" +# 12295 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12143,15 +12330,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let r : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12149 "parser_cocci_menhir.ml" +# 12336 "parser_cocci_menhir.ml" ) = Obj.magic r in let d : 'tv_struct_decl_list = Obj.magic d in let l : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12155 "parser_cocci_menhir.ml" +# 12342 "parser_cocci_menhir.ml" ) = Obj.magic l in let x0 : 'tv_ident = Obj.magic x0 in let s : 'tv_struct_or_union = Obj.magic s in @@ -12162,17 +12349,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 12166 "parser_cocci_menhir.ml" +# 12353 "parser_cocci_menhir.ml" in -# 474 "parser_cocci_menhir.mly" +# 479 "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)) ) -# 12176 "parser_cocci_menhir.ml" +# 12363 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12206,31 +12393,31 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let r : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12212 "parser_cocci_menhir.ml" +# 12399 "parser_cocci_menhir.ml" ) = Obj.magic r in let d : 'tv_struct_decl_list = Obj.magic d in let l : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12218 "parser_cocci_menhir.ml" +# 12405 "parser_cocci_menhir.ml" ) = Obj.magic l in let s : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 12223 "parser_cocci_menhir.ml" +# 12410 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_r_ in let _v : 'tv_generic_ctype_full = -# 480 "parser_cocci_menhir.mly" +# 485 "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)) ) -# 12234 "parser_cocci_menhir.ml" +# 12421 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12260,24 +12447,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let p : ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 12264 "parser_cocci_menhir.ml" +# 12451 "parser_cocci_menhir.ml" ) = Obj.magic p in let r : ( # 47 "parser_cocci_menhir.mly" (string) -# 12269 "parser_cocci_menhir.ml" +# 12456 "parser_cocci_menhir.ml" ) = Obj.magic r in let _startpos = _startpos_r_ in let _endpos = _endpos_p_ in let _v : 'tv_generic_ctype_full = -# 486 "parser_cocci_menhir.mly" +# 491 "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*))) ) -# 12281 "parser_cocci_menhir.ml" +# 12468 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12298,14 +12485,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let p : ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 12302 "parser_cocci_menhir.ml" +# 12489 "parser_cocci_menhir.ml" ) = Obj.magic p in let _startpos = _startpos_p_ in let _endpos = _endpos_p_ in let _v : 'tv_generic_ctype_full = -# 493 "parser_cocci_menhir.mly" +# 498 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.TypeName(P.id2mcode p)) ) -# 12309 "parser_cocci_menhir.ml" +# 12496 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12331,12 +12518,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let p : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 12335 "parser_cocci_menhir.ml" +# 12522 "parser_cocci_menhir.ml" ) = Obj.magic p in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 12340 "parser_cocci_menhir.ml" +# 12527 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_p_ in @@ -12345,22 +12532,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 575 "parser_cocci_menhir.mly" +# 580 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,x)) ) -# 12351 "parser_cocci_menhir.ml" +# 12538 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 12357 "parser_cocci_menhir.ml" +# 12544 "parser_cocci_menhir.ml" in -# 495 "parser_cocci_menhir.mly" +# 500 "parser_cocci_menhir.mly" ( let (nm,pure,clt) = p in q (Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure))) ) -# 12364 "parser_cocci_menhir.ml" +# 12551 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12386,12 +12573,12 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let p : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 12390 "parser_cocci_menhir.ml" +# 12577 "parser_cocci_menhir.ml" ) = Obj.magic p in let r00 : ( # 51 "parser_cocci_menhir.mly" (Data.clt) -# 12395 "parser_cocci_menhir.ml" +# 12582 "parser_cocci_menhir.ml" ) = Obj.magic r00 in let _startpos = _startpos_r00_ in let _endpos = _endpos_p_ in @@ -12400,22 +12587,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s = let r = r0 in -# 577 "parser_cocci_menhir.mly" +# 582 "parser_cocci_menhir.mly" ( function x -> Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,x)) ) -# 12406 "parser_cocci_menhir.ml" +# 12593 "parser_cocci_menhir.ml" in -# 580 "parser_cocci_menhir.mly" +# 585 "parser_cocci_menhir.mly" ( function x -> s (Some x) ) -# 12412 "parser_cocci_menhir.ml" +# 12599 "parser_cocci_menhir.ml" in -# 495 "parser_cocci_menhir.mly" +# 500 "parser_cocci_menhir.mly" ( let (nm,pure,clt) = p in q (Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure))) ) -# 12419 "parser_cocci_menhir.ml" +# 12606 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12436,22 +12623,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let p : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 12440 "parser_cocci_menhir.ml" +# 12627 "parser_cocci_menhir.ml" ) = Obj.magic p in let _startpos = _startpos_p_ in let _endpos = _endpos_p_ in let _v : 'tv_generic_ctype_full = let q = -# 581 "parser_cocci_menhir.mly" +# 586 "parser_cocci_menhir.mly" ( function x -> x ) -# 12448 "parser_cocci_menhir.ml" +# 12635 "parser_cocci_menhir.ml" in -# 495 "parser_cocci_menhir.mly" +# 500 "parser_cocci_menhir.mly" ( let (nm,pure,clt) = p in q (Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure))) ) -# 12455 "parser_cocci_menhir.ml" +# 12642 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12473,9 +12660,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_ident = -# 1484 "parser_cocci_menhir.mly" +# 1495 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Id(P.id2mcode _1)) ) -# 12479 "parser_cocci_menhir.ml" +# 12666 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12496,15 +12683,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 61 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 12500 "parser_cocci_menhir.ml" +# 12687 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_ident = -# 1486 "parser_cocci_menhir.mly" +# 1497 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) ) -# 12508 "parser_cocci_menhir.ml" +# 12695 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12526,9 +12713,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_i_ in let _endpos = _endpos_i_ in let _v : 'tv_ident_or_const = -# 1438 "parser_cocci_menhir.mly" +# 1449 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i)))) ) -# 12532 "parser_cocci_menhir.ml" +# 12719 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12547,17 +12734,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 12553 "parser_cocci_menhir.ml" +# 12740 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_ident_or_const = -# 1440 "parser_cocci_menhir.mly" +# 1451 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) ) -# 12561 "parser_cocci_menhir.ml" +# 12748 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12580,16 +12767,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 12586 "parser_cocci_menhir.ml" +# 12773 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_incl = -# 252 "parser_cocci_menhir.mly" +# 253 "parser_cocci_menhir.mly" ( Common.Left(P.id2name _2) ) -# 12593 "parser_cocci_menhir.ml" +# 12780 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12612,16 +12799,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 78 "parser_cocci_menhir.mly" +# 79 "parser_cocci_menhir.mly" (string) -# 12618 "parser_cocci_menhir.ml" +# 12805 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_incl = -# 253 "parser_cocci_menhir.mly" +# 254 "parser_cocci_menhir.mly" ( Common.Right _2 ) -# 12625 "parser_cocci_menhir.ml" +# 12812 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12647,13 +12834,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 145 "parser_cocci_menhir.mly" +# 146 "parser_cocci_menhir.mly" ((string,string) Common.either list) -# 12653 "parser_cocci_menhir.ml" +# 12840 "parser_cocci_menhir.ml" ) = -# 248 "parser_cocci_menhir.mly" +# 249 "parser_cocci_menhir.mly" ( _1 ) -# 12657 "parser_cocci_menhir.ml" +# 12844 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12679,13 +12866,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 145 "parser_cocci_menhir.mly" +# 146 "parser_cocci_menhir.mly" ((string,string) Common.either list) -# 12685 "parser_cocci_menhir.ml" +# 12872 "parser_cocci_menhir.ml" ) = -# 249 "parser_cocci_menhir.mly" +# 250 "parser_cocci_menhir.mly" ( _1 ) -# 12689 "parser_cocci_menhir.ml" +# 12876 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12704,14 +12891,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 79 "parser_cocci_menhir.mly" +# 80 "parser_cocci_menhir.mly" (string * Data.clt) -# 12710 "parser_cocci_menhir.ml" +# 12897 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_includes = -# 624 "parser_cocci_menhir.mly" +# 629 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.Include(P.clt2mcode "#include" (P.drop_aft (P.id2clt _1)), let (arity,ln,lln,offset,col,strbef,straft,pos) = @@ -12721,7 +12908,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct P.clt2mcode (Ast.Local (Parse_aux.str2inc (P.id2name _1))) (P.drop_bef clt))) ) -# 12725 "parser_cocci_menhir.ml" +# 12912 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12740,14 +12927,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 79 "parser_cocci_menhir.mly" +# 80 "parser_cocci_menhir.mly" (string * Data.clt) -# 12746 "parser_cocci_menhir.ml" +# 12933 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_includes = -# 634 "parser_cocci_menhir.mly" +# 639 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.Include(P.clt2mcode "#include" (P.drop_aft (P.id2clt _1)), let (arity,ln,lln,offset,col,strbef,straft,pos) = @@ -12757,7 +12944,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct P.clt2mcode (Ast.NonLocal (Parse_aux.str2inc (P.id2name _1))) (P.drop_bef clt))) ) -# 12761 "parser_cocci_menhir.ml" +# 12948 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12789,10 +12976,10 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_d_ in let _endpos = _endpos__3_ in let _v : 'tv_includes = -# 644 "parser_cocci_menhir.mly" +# 649 "parser_cocci_menhir.mly" ( let ty = Ast0.wrap(Ast0.TopExp(Ast0.wrap(Ast0.TypeExp(t)))) in d (Ast0.wrap(Ast0.DOTS([ty]))) ) -# 12796 "parser_cocci_menhir.ml" +# 12983 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12824,7 +13011,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_includes = -# 647 "parser_cocci_menhir.mly" +# 652 "parser_cocci_menhir.mly" ( let body = match b with [e] -> @@ -12834,7 +13021,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct | _ -> b) | _ -> b in _1 (Ast0.wrap(Ast0.DOTS(body))) ) -# 12838 "parser_cocci_menhir.ml" +# 13025 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12856,9 +13043,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_initialize = -# 1059 "parser_cocci_menhir.mly" +# 1064 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.InitExpr(_1)) ) -# 12862 "parser_cocci_menhir.ml" +# 13049 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12887,22 +13074,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12893 "parser_cocci_menhir.ml" +# 13080 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_initialize_list = Obj.magic _2 in let _1 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12899 "parser_cocci_menhir.ml" +# 13086 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_initialize = -# 1061 "parser_cocci_menhir.mly" +# 1066 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.InitList(P.clt2mcode "{" _1,_2,P.clt2mcode "}" _3)) ) -# 12906 "parser_cocci_menhir.ml" +# 13093 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12926,23 +13113,52 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12932 "parser_cocci_menhir.ml" +# 13119 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 12937 "parser_cocci_menhir.ml" +# 13124 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_initialize = -# 1063 "parser_cocci_menhir.mly" +# 1068 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.InitList(P.clt2mcode "{" _1,Ast0.wrap(Ast0.DOTS []), P.clt2mcode "}" _2)) ) -# 12946 "parser_cocci_menhir.ml" +# 13133 "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 { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; + } = _menhir_stack in + let _1 : ( +# 65 "parser_cocci_menhir.mly" + (Parse_aux.info) +# 13154 "parser_cocci_menhir.ml" + ) = Obj.magic _1 in + let _startpos = _startpos__1_ in + let _endpos = _endpos__1_ in + let _v : 'tv_initialize = +# 1072 "parser_cocci_menhir.mly" + (let (nm,pure,clt) = _1 in + Ast0.wrap(Ast0.MetaInit(P.clt2mcode nm clt,pure)) ) +# 13162 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12964,9 +13180,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_initialize2 = -# 1070 "parser_cocci_menhir.mly" +# 1078 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.InitExpr(_1)) ) -# 12970 "parser_cocci_menhir.ml" +# 13186 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -12995,22 +13211,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 13001 "parser_cocci_menhir.ml" +# 13217 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_initialize_list = Obj.magic _2 in let _1 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 13007 "parser_cocci_menhir.ml" +# 13223 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_initialize2 = -# 1072 "parser_cocci_menhir.mly" +# 1080 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.InitList(P.clt2mcode "{" _1,_2,P.clt2mcode "}" _3)) ) -# 13014 "parser_cocci_menhir.ml" +# 13230 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13034,73 +13250,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 13040 "parser_cocci_menhir.ml" +# 13256 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 13045 "parser_cocci_menhir.ml" +# 13261 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_initialize2 = -# 1074 "parser_cocci_menhir.mly" +# 1082 "parser_cocci_menhir.mly" ( Ast0.wrap (Ast0.InitList(P.clt2mcode "{" _1,Ast0.wrap(Ast0.DOTS []), P.clt2mcode "}" _2)) ) -# 13054 "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 { - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - } = _menhir_stack in - let _4 : 'tv_initialize2 = Obj.magic _4 in - let _3 : ( -# 106 "parser_cocci_menhir.mly" - (Data.clt) -# 13091 "parser_cocci_menhir.ml" - ) = Obj.magic _3 in - let _2 : 'tv_ident = Obj.magic _2 in - let _1 : ( -# 106 "parser_cocci_menhir.mly" - (Data.clt) -# 13097 "parser_cocci_menhir.ml" - ) = Obj.magic _1 in - let _startpos = _startpos__1_ in - let _endpos = _endpos__4_ in - let _v : 'tv_initialize2 = -# 1079 "parser_cocci_menhir.mly" - ( Ast0.wrap(Ast0.InitGccDotName(P.clt2mcode "." _1,_2,P.clt2mcode "=" _3,_4)) ) -# 13104 "parser_cocci_menhir.ml" +# 13270 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13118,90 +13284,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = { MenhirLib.EngineTypes.semv = _2; MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - } = _menhir_stack in - let _3 : 'tv_initialize2 = Obj.magic _3 in - let _2 : ( -# 75 "parser_cocci_menhir.mly" - (Data.clt) -# 13136 "parser_cocci_menhir.ml" - ) = Obj.magic _2 in - let _1 : 'tv_ident = Obj.magic _1 in - let _startpos = _startpos__1_ in - let _endpos = _endpos__3_ in - let _v : 'tv_initialize2 = -# 1081 "parser_cocci_menhir.mly" - ( Ast0.wrap(Ast0.InitGccName(_1,P.clt2mcode ":" _2,_3)) ) -# 13144 "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 { - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; + MenhirLib.EngineTypes.endp = _endpos__2_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in - let _5 : 'tv_initialize2 = Obj.magic _5 in - let _4 : ( -# 106 "parser_cocci_menhir.mly" - (Data.clt) -# 13186 "parser_cocci_menhir.ml" - ) = Obj.magic _4 in - let _3 : ( -# 101 "parser_cocci_menhir.mly" - (Data.clt) -# 13191 "parser_cocci_menhir.ml" - ) = Obj.magic _3 in - let _2 : 'tv_eexpr = Obj.magic _2 in - let _1 : ( -# 101 "parser_cocci_menhir.mly" + let _3 : 'tv_initialize2 = Obj.magic _3 in + let _2 : ( +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 13197 "parser_cocci_menhir.ml" - ) = Obj.magic _1 in +# 13302 "parser_cocci_menhir.ml" + ) = Obj.magic _2 in + let _1 : 'tv_list_designator_ = Obj.magic _1 in let _startpos = _startpos__1_ in - let _endpos = _endpos__5_ in + let _endpos = _endpos__3_ in let _v : 'tv_initialize2 = -# 1083 "parser_cocci_menhir.mly" - ( Ast0.wrap(Ast0.InitGccIndex(P.clt2mcode "[" _1,_2,P.clt2mcode "]" _3, - P.clt2mcode "=" _4,_5)) ) -# 13205 "parser_cocci_menhir.ml" +# 1087 "parser_cocci_menhir.mly" + ( Ast0.wrap(Ast0.InitGccExt(_1,P.clt2mcode "=" _2,_3)) ) +# 13310 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13213,72 +13318,35 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (fun _menhir_env -> let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in let { - MenhirLib.EngineTypes.semv = _7; - MenhirLib.EngineTypes.startp = _startpos__7_; - MenhirLib.EngineTypes.endp = _endpos__7_; + MenhirLib.EngineTypes.semv = _3; + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _6; - MenhirLib.EngineTypes.startp = _startpos__6_; - MenhirLib.EngineTypes.endp = _endpos__6_; + MenhirLib.EngineTypes.semv = _2; + MenhirLib.EngineTypes.startp = _startpos__2_; + MenhirLib.EngineTypes.endp = _endpos__2_; MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _5; - MenhirLib.EngineTypes.startp = _startpos__5_; - MenhirLib.EngineTypes.endp = _endpos__5_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _4; - MenhirLib.EngineTypes.startp = _startpos__4_; - MenhirLib.EngineTypes.endp = _endpos__4_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _3; - MenhirLib.EngineTypes.startp = _startpos__3_; - MenhirLib.EngineTypes.endp = _endpos__3_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.semv = _2; - MenhirLib.EngineTypes.startp = _startpos__2_; - MenhirLib.EngineTypes.endp = _endpos__2_; - MenhirLib.EngineTypes.next = { - MenhirLib.EngineTypes.state = _menhir_s; - MenhirLib.EngineTypes.semv = _1; - MenhirLib.EngineTypes.startp = _startpos__1_; - MenhirLib.EngineTypes.endp = _endpos__1_; - MenhirLib.EngineTypes.next = _menhir_stack; - }; - }; - }; - }; + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = _1; + MenhirLib.EngineTypes.startp = _startpos__1_; + MenhirLib.EngineTypes.endp = _endpos__1_; + MenhirLib.EngineTypes.next = _menhir_stack; }; }; } = _menhir_stack in - let _7 : 'tv_initialize2 = Obj.magic _7 in - let _6 : ( -# 106 "parser_cocci_menhir.mly" - (Data.clt) -# 13257 "parser_cocci_menhir.ml" - ) = Obj.magic _6 in - let _5 : ( -# 101 "parser_cocci_menhir.mly" - (Data.clt) -# 13262 "parser_cocci_menhir.ml" - ) = Obj.magic _5 in - let _4 : 'tv_eexpr = Obj.magic _4 in - let _3 : ( -# 72 "parser_cocci_menhir.mly" - (Data.clt) -# 13268 "parser_cocci_menhir.ml" - ) = Obj.magic _3 in - let _2 : 'tv_eexpr = Obj.magic _2 in - let _1 : ( -# 101 "parser_cocci_menhir.mly" + let _3 : 'tv_initialize2 = Obj.magic _3 in + let _2 : ( +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 13274 "parser_cocci_menhir.ml" - ) = Obj.magic _1 in +# 13342 "parser_cocci_menhir.ml" + ) = Obj.magic _2 in + let _1 : 'tv_ident = Obj.magic _1 in let _startpos = _startpos__1_ in - let _endpos = _endpos__7_ in + let _endpos = _endpos__3_ in let _v : 'tv_initialize2 = -# 1086 "parser_cocci_menhir.mly" - ( Ast0.wrap(Ast0.InitGccRange(P.clt2mcode "[" _1,_2,P.clt2mcode "..." _3, - _4,P.clt2mcode "]" _5,P.clt2mcode "=" _6,_7)) ) -# 13282 "parser_cocci_menhir.ml" +# 1089 "parser_cocci_menhir.mly" + ( Ast0.wrap(Ast0.InitGccName(_1,P.clt2mcode ":" _2,_3)) ) +# 13350 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13300,9 +13368,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_initialize_list = -# 1090 "parser_cocci_menhir.mly" +# 1101 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS(_1)) ) -# 13306 "parser_cocci_menhir.ml" +# 13374 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13326,17 +13394,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 13332 "parser_cocci_menhir.ml" +# 13400 "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_initialize_list_start = -# 1093 "parser_cocci_menhir.mly" +# 1104 "parser_cocci_menhir.mly" ( [_1;Ast0.wrap(Ast0.IComma(P.clt2mcode "," _2))] ) -# 13340 "parser_cocci_menhir.ml" +# 13408 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13366,17 +13434,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_initialize_list_start = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 13372 "parser_cocci_menhir.ml" +# 13440 "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_initialize_list_start = -# 1095 "parser_cocci_menhir.mly" +# 1106 "parser_cocci_menhir.mly" ( _1::Ast0.wrap(Ast0.IComma(P.clt2mcode "," _2))::_3 ) -# 13380 "parser_cocci_menhir.ml" +# 13448 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13404,10 +13472,10 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_d_ in let _endpos = _endpos_r_ in let _v : 'tv_initialize_list_start = -# 1098 "parser_cocci_menhir.mly" +# 1109 "parser_cocci_menhir.mly" ( (P.mkidots "..." d):: (List.concat(List.map (function x -> x (P.mkidots "...")) r)) ) -# 13411 "parser_cocci_menhir.ml" +# 13479 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13427,9 +13495,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_invalid = -# 1191 "parser_cocci_menhir.mly" +# 1202 "parser_cocci_menhir.mly" ( raise (Semantic_cocci.Semantic "not matchable") ) -# 13433 "parser_cocci_menhir.ml" +# 13501 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13444,9 +13512,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_is_expression = -# 244 "parser_cocci_menhir.mly" +# 245 "parser_cocci_menhir.mly" ( false ) -# 13450 "parser_cocci_menhir.ml" +# 13518 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13466,9 +13534,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_is_expression = -# 245 "parser_cocci_menhir.mly" +# 246 "parser_cocci_menhir.mly" ( true ) -# 13472 "parser_cocci_menhir.ml" +# 13540 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13494,9 +13562,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_ctype_ = -# 1834 "parser_cocci_menhir.mly" +# 1846 "parser_cocci_menhir.mly" ( Common.Left t ) -# 13500 "parser_cocci_menhir.ml" +# 13568 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13522,9 +13590,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_ctype_ = -# 1835 "parser_cocci_menhir.mly" +# 1847 "parser_cocci_menhir.mly" ( Common.Right t ) -# 13528 "parser_cocci_menhir.ml" +# 13596 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13550,9 +13618,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_decl_var_ = -# 1834 "parser_cocci_menhir.mly" +# 1846 "parser_cocci_menhir.mly" ( Common.Left t ) -# 13556 "parser_cocci_menhir.ml" +# 13624 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13578,9 +13646,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_decl_var_ = -# 1835 "parser_cocci_menhir.mly" +# 1847 "parser_cocci_menhir.mly" ( Common.Right t ) -# 13584 "parser_cocci_menhir.ml" +# 13652 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13606,9 +13674,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_dexpr_ = -# 1834 "parser_cocci_menhir.mly" +# 1846 "parser_cocci_menhir.mly" ( Common.Left t ) -# 13612 "parser_cocci_menhir.ml" +# 13680 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13634,9 +13702,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_dexpr_ = -# 1835 "parser_cocci_menhir.mly" +# 1847 "parser_cocci_menhir.mly" ( Common.Right t ) -# 13640 "parser_cocci_menhir.ml" +# 13708 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13662,9 +13730,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_nest_start_ = -# 1834 "parser_cocci_menhir.mly" +# 1846 "parser_cocci_menhir.mly" ( Common.Left t ) -# 13668 "parser_cocci_menhir.ml" +# 13736 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13690,9 +13758,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_nest_start_ = -# 1835 "parser_cocci_menhir.mly" +# 1847 "parser_cocci_menhir.mly" ( Common.Right t ) -# 13696 "parser_cocci_menhir.ml" +# 13764 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13718,9 +13786,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_single_statement_ = -# 1834 "parser_cocci_menhir.mly" +# 1846 "parser_cocci_menhir.mly" ( Common.Left t ) -# 13724 "parser_cocci_menhir.ml" +# 13792 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13746,9 +13814,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_t_ in let _v : 'tv_iso_single_statement_ = -# 1835 "parser_cocci_menhir.mly" +# 1847 "parser_cocci_menhir.mly" ( Common.Right t ) -# 13752 "parser_cocci_menhir.ml" +# 13820 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13784,13 +13852,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 13790 "parser_cocci_menhir.ml" +# 13858 "parser_cocci_menhir.ml" ) = -# 1806 "parser_cocci_menhir.mly" +# 1818 "parser_cocci_menhir.mly" ( P.iso_adjust (function x -> Ast0.ExprTag x) e1 el ) -# 13794 "parser_cocci_menhir.ml" +# 13862 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13826,13 +13894,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 13832 "parser_cocci_menhir.ml" +# 13900 "parser_cocci_menhir.ml" ) = -# 1808 "parser_cocci_menhir.mly" +# 1820 "parser_cocci_menhir.mly" ( P.iso_adjust (function x -> Ast0.ArgExprTag x) e1 el ) -# 13836 "parser_cocci_menhir.ml" +# 13904 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13868,13 +13936,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 13874 "parser_cocci_menhir.ml" +# 13942 "parser_cocci_menhir.ml" ) = -# 1810 "parser_cocci_menhir.mly" +# 1822 "parser_cocci_menhir.mly" ( P.iso_adjust (function x -> Ast0.TestExprTag x) e1 el ) -# 13878 "parser_cocci_menhir.ml" +# 13946 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13910,13 +13978,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 13916 "parser_cocci_menhir.ml" +# 13984 "parser_cocci_menhir.ml" ) = -# 1812 "parser_cocci_menhir.mly" +# 1824 "parser_cocci_menhir.mly" ( P.iso_adjust (function x -> Ast0.StmtTag x) s1 sl ) -# 13920 "parser_cocci_menhir.ml" +# 13988 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13952,13 +14020,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 13958 "parser_cocci_menhir.ml" +# 14026 "parser_cocci_menhir.ml" ) = -# 1814 "parser_cocci_menhir.mly" +# 1826 "parser_cocci_menhir.mly" ( P.iso_adjust (function x -> Ast0.TypeCTag x) t1 tl ) -# 13962 "parser_cocci_menhir.ml" +# 14030 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -13994,13 +14062,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 14000 "parser_cocci_menhir.ml" +# 14068 "parser_cocci_menhir.ml" ) = -# 1816 "parser_cocci_menhir.mly" +# 1828 "parser_cocci_menhir.mly" ( P.iso_adjust (function x -> Ast0.DotsStmtTag x) e1 el ) -# 14004 "parser_cocci_menhir.ml" +# 14072 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14036,11 +14104,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 14042 "parser_cocci_menhir.ml" +# 14110 "parser_cocci_menhir.ml" ) = -# 1818 "parser_cocci_menhir.mly" +# 1830 "parser_cocci_menhir.mly" ( let check_one = function [x] -> x | _ -> @@ -14055,7 +14123,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct | Common.Right x -> Common.Right(check_one x)) dl in P.iso_adjust (function x -> Ast0.DeclTag x) d1 dl ) -# 14059 "parser_cocci_menhir.ml" +# 14127 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14077,13 +14145,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_m_ in let _endpos = _endpos_m_ in let _v : ( -# 164 "parser_cocci_menhir.mly" +# 165 "parser_cocci_menhir.mly" ((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list) -# 14083 "parser_cocci_menhir.ml" +# 14151 "parser_cocci_menhir.ml" ) = -# 181 "parser_cocci_menhir.mly" +# 182 "parser_cocci_menhir.mly" ( m "" ) -# 14087 "parser_cocci_menhir.ml" +# 14155 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14109,13 +14177,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_nm_ in let _endpos = _endpos__2_ in let _v : ( -# 148 "parser_cocci_menhir.mly" +# 149 "parser_cocci_menhir.mly" (Ast_cocci.rulename) -# 14115 "parser_cocci_menhir.ml" +# 14183 "parser_cocci_menhir.ml" ) = -# 196 "parser_cocci_menhir.mly" +# 197 "parser_cocci_menhir.mly" ( P.make_iso_rule_name_result (P.id2name nm) ) -# 14119 "parser_cocci_menhir.ml" +# 14187 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14136,14 +14204,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 14140 "parser_cocci_menhir.ml" +# 14208 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_iter_ident = -# 1498 "parser_cocci_menhir.mly" +# 1509 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Id(P.id2mcode _1)) ) -# 14147 "parser_cocci_menhir.ml" +# 14215 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14164,15 +14232,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 62 "parser_cocci_menhir.mly" (Parse_aux.idinfo) -# 14168 "parser_cocci_menhir.ml" +# 14236 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_iter_ident = -# 1500 "parser_cocci_menhir.mly" +# 1511 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,pure)) ) -# 14176 "parser_cocci_menhir.ml" +# 14244 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14189,7 +14257,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_TMul_ = # 114 "standard.mly" ( [] ) -# 14193 "parser_cocci_menhir.ml" +# 14261 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14214,16 +14282,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let xs : 'tv_list_TMul_ = Obj.magic xs in let x : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 14220 "parser_cocci_menhir.ml" +# 14288 "parser_cocci_menhir.ml" ) = Obj.magic x in let _startpos = _startpos_x_ in let _endpos = _endpos_xs_ in let _v : 'tv_list_TMul_ = # 116 "standard.mly" ( x :: xs ) -# 14227 "parser_cocci_menhir.ml" +# 14295 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14240,7 +14308,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_array_dec_ = # 114 "standard.mly" ( [] ) -# 14244 "parser_cocci_menhir.ml" +# 14312 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14270,7 +14338,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_array_dec_ = # 116 "standard.mly" ( x :: xs ) -# 14274 "parser_cocci_menhir.ml" +# 14342 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14287,7 +14355,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_case_line_ = # 114 "standard.mly" ( [] ) -# 14291 "parser_cocci_menhir.ml" +# 14359 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14317,7 +14385,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_case_line_ = # 116 "standard.mly" ( x :: xs ) -# 14321 "parser_cocci_menhir.ml" +# 14389 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14334,7 +14402,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_comma_decls_TEllipsis_decl__ = # 114 "standard.mly" ( [] ) -# 14338 "parser_cocci_menhir.ml" +# 14406 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14364,7 +14432,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_comma_decls_TEllipsis_decl__ = # 116 "standard.mly" ( x :: xs ) -# 14368 "parser_cocci_menhir.ml" +# 14436 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14381,7 +14449,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_comma_decls_TEllipsis_name_opt_decl__ = # 114 "standard.mly" ( [] ) -# 14385 "parser_cocci_menhir.ml" +# 14453 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14411,7 +14479,54 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_comma_decls_TEllipsis_name_opt_decl__ = # 116 "standard.mly" ( x :: xs ) -# 14415 "parser_cocci_menhir.ml" +# 14483 "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 _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in + let _endpos = _startpos in + let _v : 'tv_list_designator_ = +# 114 "standard.mly" + ( [] ) +# 14500 "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 { + MenhirLib.EngineTypes.semv = xs; + MenhirLib.EngineTypes.startp = _startpos_xs_; + MenhirLib.EngineTypes.endp = _endpos_xs_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = x; + MenhirLib.EngineTypes.startp = _startpos_x_; + MenhirLib.EngineTypes.endp = _endpos_x_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + } = _menhir_stack in + let xs : 'tv_list_designator_ = Obj.magic xs in + let x : 'tv_designator = Obj.magic x in + let _startpos = _startpos_x_ in + let _endpos = _endpos_xs_ in + let _v : 'tv_list_designator_ = +# 116 "standard.mly" + ( x :: xs ) +# 14530 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14428,7 +14543,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_dp_comma_args_TEllipsis__ = # 114 "standard.mly" ( [] ) -# 14432 "parser_cocci_menhir.ml" +# 14547 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14458,7 +14573,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_dp_comma_args_TEllipsis__ = # 116 "standard.mly" ( x :: xs ) -# 14462 "parser_cocci_menhir.ml" +# 14577 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14475,7 +14590,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_incl_ = # 114 "standard.mly" ( [] ) -# 14479 "parser_cocci_menhir.ml" +# 14594 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14505,7 +14620,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_incl_ = # 116 "standard.mly" ( x :: xs ) -# 14509 "parser_cocci_menhir.ml" +# 14624 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14522,7 +14637,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_ctype__ = # 114 "standard.mly" ( [] ) -# 14526 "parser_cocci_menhir.ml" +# 14641 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14552,7 +14667,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_ctype__ = # 116 "standard.mly" ( x :: xs ) -# 14556 "parser_cocci_menhir.ml" +# 14671 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14569,7 +14684,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_decl_var__ = # 114 "standard.mly" ( [] ) -# 14573 "parser_cocci_menhir.ml" +# 14688 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14599,7 +14714,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_decl_var__ = # 116 "standard.mly" ( x :: xs ) -# 14603 "parser_cocci_menhir.ml" +# 14718 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14616,7 +14731,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_dexpr__ = # 114 "standard.mly" ( [] ) -# 14620 "parser_cocci_menhir.ml" +# 14735 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14646,7 +14761,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_dexpr__ = # 116 "standard.mly" ( x :: xs ) -# 14650 "parser_cocci_menhir.ml" +# 14765 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14663,7 +14778,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_nest_start__ = # 114 "standard.mly" ( [] ) -# 14667 "parser_cocci_menhir.ml" +# 14782 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14693,7 +14808,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_nest_start__ = # 116 "standard.mly" ( x :: xs ) -# 14697 "parser_cocci_menhir.ml" +# 14812 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14710,7 +14825,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_single_statement__ = # 114 "standard.mly" ( [] ) -# 14714 "parser_cocci_menhir.ml" +# 14829 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14740,7 +14855,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_iso_single_statement__ = # 116 "standard.mly" ( x :: xs ) -# 14744 "parser_cocci_menhir.ml" +# 14859 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14757,7 +14872,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_ctype__ = # 114 "standard.mly" ( [] ) -# 14761 "parser_cocci_menhir.ml" +# 14876 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14787,7 +14902,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_ctype__ = # 116 "standard.mly" ( x :: xs ) -# 14791 "parser_cocci_menhir.ml" +# 14906 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14804,7 +14919,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_eexpr__ = # 114 "standard.mly" ( [] ) -# 14808 "parser_cocci_menhir.ml" +# 14923 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14834,7 +14949,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_eexpr__ = # 116 "standard.mly" ( x :: xs ) -# 14838 "parser_cocci_menhir.ml" +# 14953 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14851,7 +14966,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_fun_after_dots_or__ = # 114 "standard.mly" ( [] ) -# 14855 "parser_cocci_menhir.ml" +# 14970 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14881,7 +14996,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_fun_after_dots_or__ = # 116 "standard.mly" ( x :: xs ) -# 14885 "parser_cocci_menhir.ml" +# 15000 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14898,7 +15013,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_fun_start__ = # 114 "standard.mly" ( [] ) -# 14902 "parser_cocci_menhir.ml" +# 15017 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14928,7 +15043,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_fun_start__ = # 116 "standard.mly" ( x :: xs ) -# 14932 "parser_cocci_menhir.ml" +# 15047 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14945,7 +15060,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_rule_elem_statement__ = # 114 "standard.mly" ( [] ) -# 14949 "parser_cocci_menhir.ml" +# 15064 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14975,7 +15090,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_rule_elem_statement__ = # 116 "standard.mly" ( x :: xs ) -# 14979 "parser_cocci_menhir.ml" +# 15094 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -14992,7 +15107,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_statement__ = # 114 "standard.mly" ( [] ) -# 14996 "parser_cocci_menhir.ml" +# 15111 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15022,7 +15137,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_mzl_statement__ = # 116 "standard.mly" ( x :: xs ) -# 15026 "parser_cocci_menhir.ml" +# 15141 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15039,7 +15154,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_pair_edots_when_TEllipsis_eexpr__dexpr__ = # 114 "standard.mly" ( [] ) -# 15043 "parser_cocci_menhir.ml" +# 15158 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15078,13 +15193,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 70 "standard.mly" ( (x, y) ) -# 15082 "parser_cocci_menhir.ml" +# 15197 "parser_cocci_menhir.ml" in # 116 "standard.mly" ( x :: xs ) -# 15088 "parser_cocci_menhir.ml" +# 15203 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15101,7 +15216,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_whenppdecs_ = # 114 "standard.mly" ( [] ) -# 15105 "parser_cocci_menhir.ml" +# 15220 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15131,7 +15246,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_list_whenppdecs_ = # 116 "standard.mly" ( x :: xs ) -# 15135 "parser_cocci_menhir.ml" +# 15250 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15148,7 +15263,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_choose_iso_ = # 57 "standard.mly" ( [] ) -# 15152 "parser_cocci_menhir.ml" +# 15267 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15172,7 +15287,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_choose_iso_ = # 59 "standard.mly" ( x ) -# 15176 "parser_cocci_menhir.ml" +# 15291 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15189,7 +15304,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_disable_ = # 57 "standard.mly" ( [] ) -# 15193 "parser_cocci_menhir.ml" +# 15308 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15213,7 +15328,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_disable_ = # 59 "standard.mly" ( x ) -# 15217 "parser_cocci_menhir.ml" +# 15332 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15230,7 +15345,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_error_words_ = # 57 "standard.mly" ( [] ) -# 15234 "parser_cocci_menhir.ml" +# 15349 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15254,7 +15369,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_error_words_ = # 59 "standard.mly" ( x ) -# 15258 "parser_cocci_menhir.ml" +# 15373 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15271,7 +15386,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_filespec_ = # 57 "standard.mly" ( [] ) -# 15275 "parser_cocci_menhir.ml" +# 15390 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15295,7 +15410,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_filespec_ = # 59 "standard.mly" ( x ) -# 15299 "parser_cocci_menhir.ml" +# 15414 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15312,7 +15427,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_minus_start_ = # 57 "standard.mly" ( [] ) -# 15316 "parser_cocci_menhir.ml" +# 15431 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15336,7 +15451,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_minus_start_ = # 59 "standard.mly" ( x ) -# 15340 "parser_cocci_menhir.ml" +# 15455 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15353,7 +15468,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_ceq_ = # 57 "standard.mly" ( [] ) -# 15357 "parser_cocci_menhir.ml" +# 15472 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15377,7 +15492,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_ceq_ = # 59 "standard.mly" ( x ) -# 15381 "parser_cocci_menhir.ml" +# 15496 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15394,7 +15509,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_eq_ = # 57 "standard.mly" ( [] ) -# 15398 "parser_cocci_menhir.ml" +# 15513 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15418,7 +15533,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_eq_ = # 59 "standard.mly" ( x ) -# 15422 "parser_cocci_menhir.ml" +# 15537 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15435,7 +15550,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_eqe_ = # 57 "standard.mly" ( [] ) -# 15439 "parser_cocci_menhir.ml" +# 15554 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15459,7 +15574,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_eqe_ = # 59 "standard.mly" ( x ) -# 15463 "parser_cocci_menhir.ml" +# 15578 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15476,7 +15591,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_pos_ = # 57 "standard.mly" ( [] ) -# 15480 "parser_cocci_menhir.ml" +# 15595 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15500,7 +15615,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_not_pos_ = # 59 "standard.mly" ( x ) -# 15504 "parser_cocci_menhir.ml" +# 15619 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15517,7 +15632,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_plus_start_ = # 57 "standard.mly" ( [] ) -# 15521 "parser_cocci_menhir.ml" +# 15636 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15541,7 +15656,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_loption_plus_start_ = # 59 "standard.mly" ( x ) -# 15545 "parser_cocci_menhir.ml" +# 15660 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15563,9 +15678,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_t_ in let _endpos = _endpos_t_ in let _v : 'tv_meta_exp_type = -# 439 "parser_cocci_menhir.mly" +# 444 "parser_cocci_menhir.mly" ( [Ast0_cocci.ast0_type_to_type t] ) -# 15569 "parser_cocci_menhir.ml" +# 15684 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15601,11 +15716,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_m_ in let _v : 'tv_meta_exp_type = -# 441 "parser_cocci_menhir.mly" +# 446 "parser_cocci_menhir.mly" ( List.map (function x -> P.ty_pointerify (Ast0_cocci.ast0_type_to_type x) m) t ) -# 15609 "parser_cocci_menhir.ml" +# 15724 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15636,14 +15751,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 47 "parser_cocci_menhir.mly" (string) -# 15640 "parser_cocci_menhir.ml" +# 15755 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_meta_ident = -# 1377 "parser_cocci_menhir.mly" +# 1388 "parser_cocci_menhir.mly" ( (Some _1,P.id2name _3) ) -# 15647 "parser_cocci_menhir.ml" +# 15762 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15665,13 +15780,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_m_ in let _endpos = _endpos_m_ in let _v : ( -# 156 "parser_cocci_menhir.mly" +# 157 "parser_cocci_menhir.mly" ((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list) -# 15671 "parser_cocci_menhir.ml" +# 15786 "parser_cocci_menhir.ml" ) = -# 180 "parser_cocci_menhir.mly" +# 181 "parser_cocci_menhir.mly" ( m (!Ast0.rule_name) ) -# 15675 "parser_cocci_menhir.ml" +# 15790 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15718,17 +15833,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__6_ in let _v : 'tv_metadec = let kindfn = -# 304 "parser_cocci_menhir.mly" +# 305 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta -> let tok = check_meta(Ast.MetaFreshIdDecl(arity,name)) in !Data.add_id_meta name [] pure; tok) ) -# 15726 "parser_cocci_menhir.ml" +# 15841 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 15732 "parser_cocci_menhir.ml" +# 15847 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15771,17 +15886,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 308 "parser_cocci_menhir.mly" +# 309 "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) ) -# 15779 "parser_cocci_menhir.ml" +# 15894 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 15785 "parser_cocci_menhir.ml" +# 15900 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15828,17 +15943,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__6_ in let _v : 'tv_metadec = let kindfn = -# 312 "parser_cocci_menhir.mly" +# 313 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta -> let tok = check_meta(Ast.MetaParamListDecl(arity,name,None)) in !Data.add_paramlist_meta name None pure; tok) ) -# 15836 "parser_cocci_menhir.ml" +# 15951 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 15842 "parser_cocci_menhir.ml" +# 15957 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15885,17 +16000,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__6_ in let _v : 'tv_metadec = let kindfn = -# 316 "parser_cocci_menhir.mly" +# 317 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta -> let tok = check_meta(Ast.MetaExpListDecl(arity,name,None)) in !Data.add_explist_meta name None pure; tok) ) -# 15893 "parser_cocci_menhir.ml" +# 16008 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 15899 "parser_cocci_menhir.ml" +# 16014 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15938,17 +16053,70 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 320 "parser_cocci_menhir.mly" +# 321 "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) ) -# 15946 "parser_cocci_menhir.ml" +# 16061 "parser_cocci_menhir.ml" + + in + +# 259 "parser_cocci_menhir.mly" + ( P.create_metadec ar ispure kindfn ids ) +# 16067 "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 { + MenhirLib.EngineTypes.startp = _startpos__5_; + MenhirLib.EngineTypes.endp = _endpos__5_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.semv = ids; + MenhirLib.EngineTypes.startp = _startpos_ids_; + MenhirLib.EngineTypes.endp = _endpos_ids_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.startp = _startpos__3_; + MenhirLib.EngineTypes.endp = _endpos__3_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.semv = ispure; + MenhirLib.EngineTypes.startp = _startpos_ispure_; + MenhirLib.EngineTypes.endp = _endpos_ispure_; + MenhirLib.EngineTypes.next = { + MenhirLib.EngineTypes.state = _menhir_s; + MenhirLib.EngineTypes.semv = ar; + MenhirLib.EngineTypes.startp = _startpos_ar_; + MenhirLib.EngineTypes.endp = _endpos_ar_; + MenhirLib.EngineTypes.next = _menhir_stack; + }; + }; + }; + }; + } = _menhir_stack in + let ids : 'tv_comma_list_pure_ident_or_meta_ident_ = Obj.magic ids in + let ispure : 'tv_pure = Obj.magic ispure in + let ar : 'tv_arity = Obj.magic ar in + let _startpos = _startpos_ar_ in + let _endpos = _endpos__5_ in + let _v : 'tv_metadec = let kindfn = + +# 325 "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) ) +# 16114 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 15952 "parser_cocci_menhir.ml" +# 16120 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -15991,17 +16159,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 324 "parser_cocci_menhir.mly" +# 329 "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) ) -# 15999 "parser_cocci_menhir.ml" +# 16167 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 16005 "parser_cocci_menhir.ml" +# 16173 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16048,17 +16216,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__6_ in let _v : 'tv_metadec = let kindfn = -# 328 "parser_cocci_menhir.mly" +# 333 "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) ) -# 16056 "parser_cocci_menhir.ml" +# 16224 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 16062 "parser_cocci_menhir.ml" +# 16230 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16101,18 +16269,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 332 "parser_cocci_menhir.mly" +# 337 "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")) ) -# 16110 "parser_cocci_menhir.ml" +# 16278 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 16116 "parser_cocci_menhir.ml" +# 16284 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16159,18 +16327,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__6_ in let _v : 'tv_metadec = let kindfn = -# 337 "parser_cocci_menhir.mly" +# 342 "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")) ) -# 16168 "parser_cocci_menhir.ml" +# 16336 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 16174 "parser_cocci_menhir.ml" +# 16342 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16217,18 +16385,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__6_ in let _v : 'tv_metadec = let kindfn = -# 342 "parser_cocci_menhir.mly" +# 347 "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")) ) -# 16226 "parser_cocci_menhir.ml" +# 16394 "parser_cocci_menhir.ml" in -# 258 "parser_cocci_menhir.mly" +# 259 "parser_cocci_menhir.mly" ( P.create_metadec ar ispure kindfn ids ) -# 16232 "parser_cocci_menhir.ml" +# 16400 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16271,17 +16439,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 350 "parser_cocci_menhir.mly" +# 355 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta constraints -> let tok = check_meta(Ast.MetaIdDecl(arity,name)) in !Data.add_id_meta name constraints pure; tok) ) -# 16279 "parser_cocci_menhir.ml" +# 16447 "parser_cocci_menhir.ml" in -# 262 "parser_cocci_menhir.mly" +# 263 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16285 "parser_cocci_menhir.ml" +# 16453 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16324,17 +16492,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 354 "parser_cocci_menhir.mly" +# 359 "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) ) -# 16332 "parser_cocci_menhir.ml" +# 16500 "parser_cocci_menhir.ml" in -# 262 "parser_cocci_menhir.mly" +# 263 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16338 "parser_cocci_menhir.ml" +# 16506 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16381,18 +16549,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__6_ in let _v : 'tv_metadec = let kindfn = -# 358 "parser_cocci_menhir.mly" +# 363 "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) ) -# 16390 "parser_cocci_menhir.ml" +# 16558 "parser_cocci_menhir.ml" in -# 262 "parser_cocci_menhir.mly" +# 263 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16396 "parser_cocci_menhir.ml" +# 16564 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16435,17 +16603,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 363 "parser_cocci_menhir.mly" +# 368 "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) ) -# 16443 "parser_cocci_menhir.ml" +# 16611 "parser_cocci_menhir.ml" in -# 262 "parser_cocci_menhir.mly" +# 263 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16449 "parser_cocci_menhir.ml" +# 16617 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16488,17 +16656,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 367 "parser_cocci_menhir.mly" +# 372 "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) ) -# 16496 "parser_cocci_menhir.ml" +# 16664 "parser_cocci_menhir.ml" in -# 262 "parser_cocci_menhir.mly" +# 263 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16502 "parser_cocci_menhir.ml" +# 16670 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16541,17 +16709,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 373 "parser_cocci_menhir.mly" +# 378 "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) ) -# 16549 "parser_cocci_menhir.ml" +# 16717 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16555 "parser_cocci_menhir.ml" +# 16723 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16604,11 +16772,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 16608 "parser_cocci_menhir.ml" +# 16776 "parser_cocci_menhir.ml" in -# 377 "parser_cocci_menhir.mly" +# 382 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta constraints -> match l with None -> @@ -16617,13 +16785,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct | Some _ -> !Data.add_local_idexp_meta ty name constraints pure; check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) ) -# 16621 "parser_cocci_menhir.ml" +# 16789 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16627 "parser_cocci_menhir.ml" +# 16795 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16684,11 +16852,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 16688 "parser_cocci_menhir.ml" +# 16856 "parser_cocci_menhir.ml" in -# 377 "parser_cocci_menhir.mly" +# 382 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta constraints -> match l with None -> @@ -16697,13 +16865,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct | Some _ -> !Data.add_local_idexp_meta ty name constraints pure; check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) ) -# 16701 "parser_cocci_menhir.ml" +# 16869 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16707 "parser_cocci_menhir.ml" +# 16875 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16760,7 +16928,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let m = m0 in let l = l0 in -# 386 "parser_cocci_menhir.mly" +# 391 "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 @@ -16770,13 +16938,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct | Some _ -> !Data.add_local_idexp_meta ty name constraints pure; check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) ) -# 16774 "parser_cocci_menhir.ml" +# 16942 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16780 "parser_cocci_menhir.ml" +# 16948 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16826,18 +16994,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_metadec = let kindfn = let m = m0 in -# 396 "parser_cocci_menhir.mly" +# 401 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta constraints -> let ty = Some [P.ty_pointerify Type_cocci.Unknown m] in let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in !Data.add_exp_meta ty name constraints pure; tok) ) -# 16835 "parser_cocci_menhir.ml" +# 17003 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16841 "parser_cocci_menhir.ml" +# 17009 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16891,18 +17059,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_metadec = let kindfn = let vl = vl0 in -# 401 "parser_cocci_menhir.mly" +# 406 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta constraints -> let ty = Some (List.map (function x -> Type_cocci.Array x) vl) in let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in !Data.add_exp_meta ty name constraints pure; tok) ) -# 16900 "parser_cocci_menhir.ml" +# 17068 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16906 "parser_cocci_menhir.ml" +# 17074 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -16948,21 +17116,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 16952 "parser_cocci_menhir.ml" +# 17120 "parser_cocci_menhir.ml" in -# 406 "parser_cocci_menhir.mly" +# 411 "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) ) -# 16960 "parser_cocci_menhir.ml" +# 17128 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 16966 "parser_cocci_menhir.ml" +# 17134 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17016,21 +17184,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 17020 "parser_cocci_menhir.ml" +# 17188 "parser_cocci_menhir.ml" in -# 406 "parser_cocci_menhir.mly" +# 411 "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) ) -# 17028 "parser_cocci_menhir.ml" +# 17196 "parser_cocci_menhir.ml" in -# 266 "parser_cocci_menhir.mly" +# 267 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 17034 "parser_cocci_menhir.ml" +# 17202 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17073,17 +17241,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _endpos = _endpos__5_ in let _v : 'tv_metadec = let kindfn = -# 412 "parser_cocci_menhir.mly" +# 417 "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) ) -# 17081 "parser_cocci_menhir.ml" +# 17249 "parser_cocci_menhir.ml" in -# 270 "parser_cocci_menhir.mly" +# 271 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 17087 "parser_cocci_menhir.ml" +# 17255 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17129,7 +17297,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_metadec = let kindfn = let vl = vl0 in -# 416 "parser_cocci_menhir.mly" +# 421 "parser_cocci_menhir.mly" ( (fun arity name pure check_meta constraints -> let ty = Some vl in List.iter @@ -17149,13 +17317,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct constraints; let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in !Data.add_exp_meta ty name constraints pure; tok) ) -# 17153 "parser_cocci_menhir.ml" +# 17321 "parser_cocci_menhir.ml" in -# 270 "parser_cocci_menhir.mly" +# 271 "parser_cocci_menhir.mly" ( P.create_metadec_ne ar ispure kindfn ids ) -# 17159 "parser_cocci_menhir.ml" +# 17327 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17197,7 +17365,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_ar_ in let _endpos = _endpos__5_ in let _v : 'tv_metadec = -# 276 "parser_cocci_menhir.mly" +# 277 "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 = @@ -17205,7 +17373,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let any = match a with None -> Ast.PER | Some _ -> Ast.ALL in !Data.add_pos_meta name constraints any; tok in P.create_metadec_ne ar false kindfn ids ) -# 17209 "parser_cocci_menhir.ml" +# 17377 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17265,14 +17433,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_ar_ in let _endpos = _endpos__9_ in let _v : 'tv_metadec = -# 286 "parser_cocci_menhir.mly" +# 287 "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,Some lenname)) in !Data.add_paramlist_meta name (Some lenname) pure; tok) id ids ) -# 17276 "parser_cocci_menhir.ml" +# 17444 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17332,14 +17500,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_ar_ in let _endpos = _endpos__9_ in let _v : 'tv_metadec = -# 295 "parser_cocci_menhir.mly" +# 296 "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,Some lenname)) in !Data.add_explist_meta name (Some lenname) pure; tok) id ids ) -# 17343 "parser_cocci_menhir.ml" +# 17511 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17367,9 +17535,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_midzero_list_ctype_ctype_ = -# 1776 "parser_cocci_menhir.mly" +# 1788 "parser_cocci_menhir.mly" ( let (mids,code) = List.split b in (mids,(a::code)) ) -# 17373 "parser_cocci_menhir.ml" +# 17541 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17397,9 +17565,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_midzero_list_eexpr_eexpr_ = -# 1776 "parser_cocci_menhir.mly" +# 1788 "parser_cocci_menhir.mly" ( let (mids,code) = List.split b in (mids,(a::code)) ) -# 17403 "parser_cocci_menhir.ml" +# 17571 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17427,9 +17595,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_midzero_list_expr_eexpr_ = -# 1776 "parser_cocci_menhir.mly" +# 1788 "parser_cocci_menhir.mly" ( let (mids,code) = List.split b in (mids,(a::code)) ) -# 17433 "parser_cocci_menhir.ml" +# 17601 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17457,9 +17625,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_midzero_list_fun_after_stm_fun_after_dots_or_ = -# 1776 "parser_cocci_menhir.mly" +# 1788 "parser_cocci_menhir.mly" ( let (mids,code) = List.split b in (mids,(a::code)) ) -# 17463 "parser_cocci_menhir.ml" +# 17631 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17487,9 +17655,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_midzero_list_fun_start_fun_start_ = -# 1776 "parser_cocci_menhir.mly" +# 1788 "parser_cocci_menhir.mly" ( let (mids,code) = List.split b in (mids,(a::code)) ) -# 17493 "parser_cocci_menhir.ml" +# 17661 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17517,9 +17685,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_midzero_list_rule_elem_statement_rule_elem_statement_ = -# 1776 "parser_cocci_menhir.mly" +# 1788 "parser_cocci_menhir.mly" ( let (mids,code) = List.split b in (mids,(a::code)) ) -# 17523 "parser_cocci_menhir.ml" +# 17691 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17547,9 +17715,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_midzero_list_statement_statement_ = -# 1776 "parser_cocci_menhir.mly" +# 1788 "parser_cocci_menhir.mly" ( let (mids,code) = List.split b in (mids,(a::code)) ) -# 17553 "parser_cocci_menhir.ml" +# 17721 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17583,11 +17751,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_f_ in let _endpos = _endpos_ew_ in let _v : 'tv_minus_body = -# 592 "parser_cocci_menhir.mly" +# 597 "parser_cocci_menhir.mly" ( match f@b@ew with [] -> raise (Semantic_cocci.Semantic "minus slice can't be empty") | code -> Top_level.top_level code ) -# 17591 "parser_cocci_menhir.ml" +# 17759 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17621,11 +17789,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_f_ in let _endpos = _endpos_ew_ in let _v : 'tv_minus_exp_body = -# 606 "parser_cocci_menhir.mly" +# 611 "parser_cocci_menhir.mly" ( match f@[b]@ew with [] -> raise (Semantic_cocci.Semantic "minus slice can't be empty") | code -> Top_level.top_level code ) -# 17629 "parser_cocci_menhir.ml" +# 17797 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17651,13 +17819,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 136 "parser_cocci_menhir.mly" +# 137 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 17657 "parser_cocci_menhir.ml" +# 17825 "parser_cocci_menhir.ml" ) = -# 176 "parser_cocci_menhir.mly" +# 177 "parser_cocci_menhir.mly" ( _1 ) -# 17661 "parser_cocci_menhir.ml" +# 17829 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17683,13 +17851,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_m_ in let _endpos = _endpos__2_ in let _v : ( -# 136 "parser_cocci_menhir.mly" +# 137 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 17689 "parser_cocci_menhir.ml" +# 17857 "parser_cocci_menhir.ml" ) = -# 176 "parser_cocci_menhir.mly" +# 177 "parser_cocci_menhir.mly" ( m ) -# 17693 "parser_cocci_menhir.ml" +# 17861 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17715,13 +17883,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_m_ in let _endpos = _endpos__2_ in let _v : ( -# 136 "parser_cocci_menhir.mly" +# 137 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 17721 "parser_cocci_menhir.ml" +# 17889 "parser_cocci_menhir.ml" ) = -# 177 "parser_cocci_menhir.mly" +# 178 "parser_cocci_menhir.mly" ( m ) -# 17725 "parser_cocci_menhir.ml" +# 17893 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17747,13 +17915,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 133 "parser_cocci_menhir.mly" +# 134 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 17753 "parser_cocci_menhir.ml" +# 17921 "parser_cocci_menhir.ml" ) = -# 172 "parser_cocci_menhir.mly" +# 173 "parser_cocci_menhir.mly" ( _1 ) -# 17757 "parser_cocci_menhir.ml" +# 17925 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17779,13 +17947,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_m_ in let _endpos = _endpos__2_ in let _v : ( -# 133 "parser_cocci_menhir.mly" +# 134 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 17785 "parser_cocci_menhir.ml" +# 17953 "parser_cocci_menhir.ml" ) = -# 172 "parser_cocci_menhir.mly" +# 173 "parser_cocci_menhir.mly" ( m ) -# 17789 "parser_cocci_menhir.ml" +# 17957 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17811,13 +17979,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_m_ in let _endpos = _endpos__2_ in let _v : ( -# 133 "parser_cocci_menhir.mly" +# 134 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 17817 "parser_cocci_menhir.ml" +# 17985 "parser_cocci_menhir.ml" ) = -# 173 "parser_cocci_menhir.mly" +# 174 "parser_cocci_menhir.mly" ( m ) -# 17821 "parser_cocci_menhir.ml" +# 17989 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17839,9 +18007,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_minus_start = -# 1585 "parser_cocci_menhir.mly" +# 1597 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.DECL(_1))] ) -# 17845 "parser_cocci_menhir.ml" +# 18013 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17863,9 +18031,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_minus_start = -# 1586 "parser_cocci_menhir.mly" +# 1598 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty(_1))))] ) -# 17869 "parser_cocci_menhir.ml" +# 18037 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17887,9 +18055,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_minus_start = -# 1587 "parser_cocci_menhir.mly" +# 1599 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit(_1))))] ) -# 17893 "parser_cocci_menhir.ml" +# 18061 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17911,9 +18079,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_minus_start = -# 1589 "parser_cocci_menhir.mly" +# 1601 "parser_cocci_menhir.mly" ( List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1 ) -# 17917 "parser_cocci_menhir.ml" +# 18085 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17938,16 +18106,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_ctype = Obj.magic b in let a : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 17944 "parser_cocci_menhir.ml" +# 18112 "parser_cocci_menhir.ml" ) = Obj.magic a in let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_mzl_ctype_ = -# 1779 "parser_cocci_menhir.mly" +# 1791 "parser_cocci_menhir.mly" ( (P.clt2mcode "|" a, b) ) -# 17951 "parser_cocci_menhir.ml" +# 18119 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -17972,16 +18140,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_eexpr = Obj.magic b in let a : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 17978 "parser_cocci_menhir.ml" +# 18146 "parser_cocci_menhir.ml" ) = Obj.magic a in let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_mzl_eexpr_ = -# 1779 "parser_cocci_menhir.mly" +# 1791 "parser_cocci_menhir.mly" ( (P.clt2mcode "|" a, b) ) -# 17985 "parser_cocci_menhir.ml" +# 18153 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18006,16 +18174,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_fun_after_dots_or = Obj.magic b in let a : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 18012 "parser_cocci_menhir.ml" +# 18180 "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_ = -# 1779 "parser_cocci_menhir.mly" +# 1791 "parser_cocci_menhir.mly" ( (P.clt2mcode "|" a, b) ) -# 18019 "parser_cocci_menhir.ml" +# 18187 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18040,16 +18208,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_fun_start = Obj.magic b in let a : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 18046 "parser_cocci_menhir.ml" +# 18214 "parser_cocci_menhir.ml" ) = Obj.magic a in let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_mzl_fun_start_ = -# 1779 "parser_cocci_menhir.mly" +# 1791 "parser_cocci_menhir.mly" ( (P.clt2mcode "|" a, b) ) -# 18053 "parser_cocci_menhir.ml" +# 18221 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18074,16 +18242,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_rule_elem_statement = Obj.magic b in let a : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 18080 "parser_cocci_menhir.ml" +# 18248 "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_ = -# 1779 "parser_cocci_menhir.mly" +# 1791 "parser_cocci_menhir.mly" ( (P.clt2mcode "|" a, b) ) -# 18087 "parser_cocci_menhir.ml" +# 18255 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18108,16 +18276,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_statement = Obj.magic b in let a : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 18114 "parser_cocci_menhir.ml" +# 18282 "parser_cocci_menhir.ml" ) = Obj.magic a in let _startpos = _startpos_a_ in let _endpos = _endpos_b_ in let _v : 'tv_mzl_statement_ = -# 1779 "parser_cocci_menhir.mly" +# 1791 "parser_cocci_menhir.mly" ( (P.clt2mcode "|" a, b) ) -# 18121 "parser_cocci_menhir.ml" +# 18289 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18139,9 +18307,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_name_opt_decl = -# 824 "parser_cocci_menhir.mly" +# 829 "parser_cocci_menhir.mly" ( _1 ) -# 18145 "parser_cocci_menhir.ml" +# 18313 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18163,9 +18331,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_t_ in let _endpos = _endpos_t_ in let _v : 'tv_name_opt_decl = -# 825 "parser_cocci_menhir.mly" +# 830 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Param(t, None)) ) -# 18169 "parser_cocci_menhir.ml" +# 18337 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18214,43 +18382,43 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 18220 "parser_cocci_menhir.ml" +# 18388 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 18226 "parser_cocci_menhir.ml" +# 18394 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 18231 "parser_cocci_menhir.ml" +# 18399 "parser_cocci_menhir.ml" ) = Obj.magic rp in let s : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 18236 "parser_cocci_menhir.ml" +# 18404 "parser_cocci_menhir.ml" ) = Obj.magic s in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 18241 "parser_cocci_menhir.ml" +# 18409 "parser_cocci_menhir.ml" ) = Obj.magic lp in let t : 'tv_fn_ctype = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_rp1_ in let _v : 'tv_name_opt_decl = -# 828 "parser_cocci_menhir.mly" +# 833 "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)) ) -# 18254 "parser_cocci_menhir.ml" +# 18422 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18278,9 +18446,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_nest_after_dots = -# 1700 "parser_cocci_menhir.mly" +# 1712 "parser_cocci_menhir.mly" (_1@_2) -# 18284 "parser_cocci_menhir.ml" +# 18452 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18306,9 +18474,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_nest_after_dots = -# 1701 "parser_cocci_menhir.mly" +# 1713 "parser_cocci_menhir.mly" (_2) -# 18312 "parser_cocci_menhir.ml" +# 18480 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18336,9 +18504,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_nest_after_dots = -# 1702 "parser_cocci_menhir.mly" +# 1714 "parser_cocci_menhir.mly" ((Ast0.wrap(Ast0.Exp(_1)))::_2) -# 18342 "parser_cocci_menhir.ml" +# 18510 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18353,9 +18521,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_nest_after_exp = -# 1710 "parser_cocci_menhir.mly" +# 1722 "parser_cocci_menhir.mly" ([]) -# 18359 "parser_cocci_menhir.ml" +# 18527 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18383,9 +18551,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_nest_after_exp = -# 1711 "parser_cocci_menhir.mly" +# 1723 "parser_cocci_menhir.mly" (_1::_2) -# 18389 "parser_cocci_menhir.ml" +# 18557 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18400,9 +18568,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_nest_after_stm = -# 1705 "parser_cocci_menhir.mly" +# 1717 "parser_cocci_menhir.mly" ([]) -# 18406 "parser_cocci_menhir.ml" +# 18574 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18430,9 +18598,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_nest_after_stm = -# 1706 "parser_cocci_menhir.mly" +# 1718 "parser_cocci_menhir.mly" (_1::_2) -# 18436 "parser_cocci_menhir.ml" +# 18604 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18460,9 +18628,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_nest_after_stm = -# 1707 "parser_cocci_menhir.mly" +# 1719 "parser_cocci_menhir.mly" (_1@_2) -# 18466 "parser_cocci_menhir.ml" +# 18634 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18491,24 +18659,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let c : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 18497 "parser_cocci_menhir.ml" +# 18665 "parser_cocci_menhir.ml" ) = Obj.magic c in let e : 'tv_expr_dots_TEllipsis_ = Obj.magic e in let _1 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 18503 "parser_cocci_menhir.ml" +# 18671 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos_c_ in let _v : 'tv_nest_expressions = -# 1200 "parser_cocci_menhir.mly" +# 1211 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<..." _1, Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))), P.clt2mcode "...>" c, None, false)) ) -# 18512 "parser_cocci_menhir.ml" +# 18680 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18537,24 +18705,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let c : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 18543 "parser_cocci_menhir.ml" +# 18711 "parser_cocci_menhir.ml" ) = Obj.magic c in let e : 'tv_expr_dots_TEllipsis_ = Obj.magic e in let _1 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 18549 "parser_cocci_menhir.ml" +# 18717 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos_c_ in let _v : 'tv_nest_expressions = -# 1204 "parser_cocci_menhir.mly" +# 1215 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<+..." _1, Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))), P.clt2mcode "...+>" c, None, true)) ) -# 18558 "parser_cocci_menhir.ml" +# 18726 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18576,9 +18744,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_nest_start = -# 1697 "parser_cocci_menhir.mly" +# 1709 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS(_1)) ) -# 18582 "parser_cocci_menhir.ml" +# 18750 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18598,13 +18766,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : ( -# 167 "parser_cocci_menhir.mly" +# 168 "parser_cocci_menhir.mly" (unit) -# 18604 "parser_cocci_menhir.ml" +# 18772 "parser_cocci_menhir.ml" ) = -# 1842 "parser_cocci_menhir.mly" +# 1854 "parser_cocci_menhir.mly" ( () ) -# 18608 "parser_cocci_menhir.ml" +# 18776 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18628,13 +18796,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 167 "parser_cocci_menhir.mly" +# 168 "parser_cocci_menhir.mly" (unit) -# 18634 "parser_cocci_menhir.ml" +# 18802 "parser_cocci_menhir.ml" ) = -# 1843 "parser_cocci_menhir.mly" +# 1855 "parser_cocci_menhir.mly" ( () ) -# 18638 "parser_cocci_menhir.ml" +# 18806 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18654,13 +18822,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : ( -# 167 "parser_cocci_menhir.mly" +# 168 "parser_cocci_menhir.mly" (unit) -# 18660 "parser_cocci_menhir.ml" +# 18828 "parser_cocci_menhir.ml" ) = -# 1844 "parser_cocci_menhir.mly" +# 1856 "parser_cocci_menhir.mly" ( () ) -# 18664 "parser_cocci_menhir.ml" +# 18832 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18688,10 +18856,10 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_g_ in let _endpos = _endpos_dg_ in let _v : 'tv_no_dot_start_end_dexpr_edots_when_TEllipsis_eexpr__ = -# 1368 "parser_cocci_menhir.mly" +# 1379 "parser_cocci_menhir.mly" ( function dot_builder -> g :: (List.concat(List.map (function (d,g) -> [dot_builder d;g]) dg)) ) -# 18695 "parser_cocci_menhir.ml" +# 18863 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18710,16 +18878,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let x : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 18716 "parser_cocci_menhir.ml" +# 18884 "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 ] ) -# 18723 "parser_cocci_menhir.ml" +# 18891 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18744,16 +18912,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let xs : 'tv_nonempty_list_TMul_ = Obj.magic xs in let x : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 18750 "parser_cocci_menhir.ml" +# 18918 "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 ) -# 18757 "parser_cocci_menhir.ml" +# 18925 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18779,13 +18947,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_i_ in let _v : 'tv_not_ceq = -# 1425 "parser_cocci_menhir.mly" +# 1436 "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] ) -# 18789 "parser_cocci_menhir.ml" +# 18957 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18819,13 +18987,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_not_ceq = -# 1431 "parser_cocci_menhir.mly" +# 1442 "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 ) -# 18829 "parser_cocci_menhir.ml" +# 18997 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18851,7 +19019,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_i_ in let _v : 'tv_not_eq = -# 1392 "parser_cocci_menhir.mly" +# 1403 "parser_cocci_menhir.mly" ( (if !Data.in_iso then failwith "constraints not allowed in iso file"); (if !Data.in_generating @@ -18859,7 +19027,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct them in the pattern *) then failwith "constraints not allowed in a generated rule file"); [Ast0.wrap(Ast0.Id(P.id2mcode i))] ) -# 18863 "parser_cocci_menhir.ml" +# 19031 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18893,13 +19061,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_not_eq = -# 1400 "parser_cocci_menhir.mly" +# 1411 "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"); List.map (function i -> Ast0.wrap(Ast0.Id(P.id2mcode i))) l ) -# 18903 "parser_cocci_menhir.ml" +# 19071 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18925,13 +19093,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_i_ in let _v : 'tv_not_eqe = -# 1408 "parser_cocci_menhir.mly" +# 1419 "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))))] ) -# 18935 "parser_cocci_menhir.ml" +# 19103 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -18965,7 +19133,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_not_eqe = -# 1414 "parser_cocci_menhir.mly" +# 1425 "parser_cocci_menhir.mly" ( (if !Data.in_iso then failwith "constraints not allowed in iso file"); (if !Data.in_generating @@ -18974,7 +19142,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (function i -> Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i))))) l ) -# 18978 "parser_cocci_menhir.ml" +# 19146 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19000,7 +19168,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos_i_ in let _v : 'tv_not_pos = -# 1445 "parser_cocci_menhir.mly" +# 1456 "parser_cocci_menhir.mly" ( (if !Data.in_iso then failwith "constraints not allowed in iso file"); (if !Data.in_generating @@ -19011,7 +19179,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let i = (rule,name) in P.check_meta(Ast.MetaPosDecl(Ast.NONE,i)); [i] ) -# 19015 "parser_cocci_menhir.ml" +# 19183 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19045,7 +19213,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_not_pos = -# 1456 "parser_cocci_menhir.mly" +# 1467 "parser_cocci_menhir.mly" ( (if !Data.in_iso then failwith "constraints not allowed in iso file"); (if !Data.in_generating @@ -19059,7 +19227,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct P.check_meta(Ast.MetaPosDecl(Ast.NONE,i)); i) l ) -# 19063 "parser_cocci_menhir.ml" +# 19231 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19081,9 +19249,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_one_dec_decl_ = -# 1529 "parser_cocci_menhir.mly" +# 1541 "parser_cocci_menhir.mly" ( _1 ) -# 19087 "parser_cocci_menhir.ml" +# 19255 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19102,14 +19270,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 65 "parser_cocci_menhir.mly" +# 66 "parser_cocci_menhir.mly" (Parse_aux.list_info) -# 19108 "parser_cocci_menhir.ml" +# 19276 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_one_dec_decl_ = -# 1531 "parser_cocci_menhir.mly" +# 1543 "parser_cocci_menhir.mly" ( let (nm,lenname,pure,clt) = _1 in let nm = P.clt2mcode nm clt in let lenname = @@ -19117,7 +19285,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct Some nm -> Some(P.clt2mcode nm clt) | None -> None in Ast0.wrap(Ast0.MetaParamList(nm,lenname,pure)) ) -# 19121 "parser_cocci_menhir.ml" +# 19289 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19139,9 +19307,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_one_dec_name_opt_decl_ = -# 1529 "parser_cocci_menhir.mly" +# 1541 "parser_cocci_menhir.mly" ( _1 ) -# 19145 "parser_cocci_menhir.ml" +# 19313 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19160,14 +19328,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 65 "parser_cocci_menhir.mly" +# 66 "parser_cocci_menhir.mly" (Parse_aux.list_info) -# 19166 "parser_cocci_menhir.ml" +# 19334 "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_ = -# 1531 "parser_cocci_menhir.mly" +# 1543 "parser_cocci_menhir.mly" ( let (nm,lenname,pure,clt) = _1 in let nm = P.clt2mcode nm clt in let lenname = @@ -19175,7 +19343,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct Some nm -> Some(P.clt2mcode nm clt) | None -> None in Ast0.wrap(Ast0.MetaParamList(nm,lenname,pure)) ) -# 19179 "parser_cocci_menhir.ml" +# 19347 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19199,17 +19367,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19205 "parser_cocci_menhir.ml" +# 19373 "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 = -# 995 "parser_cocci_menhir.mly" +# 1000 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv)) ) -# 19213 "parser_cocci_menhir.ml" +# 19381 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19238,9 +19406,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19244 "parser_cocci_menhir.ml" +# 19412 "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 @@ -19250,14 +19418,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 19254 "parser_cocci_menhir.ml" +# 19422 "parser_cocci_menhir.ml" in -# 997 "parser_cocci_menhir.mly" +# 1002 "parser_cocci_menhir.mly" ( let (id,fn) = d in Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) ) -# 19261 "parser_cocci_menhir.ml" +# 19429 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19291,9 +19459,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19297 "parser_cocci_menhir.ml" +# 19465 "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 @@ -19305,14 +19473,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19309 "parser_cocci_menhir.ml" +# 19477 "parser_cocci_menhir.ml" in -# 997 "parser_cocci_menhir.mly" +# 1002 "parser_cocci_menhir.mly" ( let (id,fn) = d in Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) ) -# 19316 "parser_cocci_menhir.ml" +# 19484 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19334,9 +19502,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_f_ in let _endpos = _endpos_f_ in let _v : 'tv_one_decl_var = -# 999 "parser_cocci_menhir.mly" +# 1004 "parser_cocci_menhir.mly" ( f ) -# 19340 "parser_cocci_menhir.ml" +# 19508 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19375,15 +19543,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19381 "parser_cocci_menhir.ml" +# 19549 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19387 "parser_cocci_menhir.ml" +# 19555 "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 @@ -19393,14 +19561,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 19397 "parser_cocci_menhir.ml" +# 19565 "parser_cocci_menhir.ml" in -# 1001 "parser_cocci_menhir.mly" +# 1006 "parser_cocci_menhir.mly" ( let (id,fn) = d in Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)) ) -# 19404 "parser_cocci_menhir.ml" +# 19572 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19444,15 +19612,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19450 "parser_cocci_menhir.ml" +# 19618 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19456 "parser_cocci_menhir.ml" +# 19624 "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 @@ -19464,14 +19632,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19468 "parser_cocci_menhir.ml" +# 19636 "parser_cocci_menhir.ml" in -# 1001 "parser_cocci_menhir.mly" +# 1006 "parser_cocci_menhir.mly" ( let (id,fn) = d in Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)) ) -# 19475 "parser_cocci_menhir.ml" +# 19643 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19500,9 +19668,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19506 "parser_cocci_menhir.ml" +# 19674 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -19512,22 +19680,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 19516 "parser_cocci_menhir.ml" +# 19684 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 19523 "parser_cocci_menhir.ml" +# 19691 "parser_cocci_menhir.ml" in -# 1006 "parser_cocci_menhir.mly" +# 1011 "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)) ) -# 19531 "parser_cocci_menhir.ml" +# 19699 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19561,9 +19729,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19567 "parser_cocci_menhir.ml" +# 19735 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -19575,22 +19743,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19579 "parser_cocci_menhir.ml" +# 19747 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 19586 "parser_cocci_menhir.ml" +# 19754 "parser_cocci_menhir.ml" in -# 1006 "parser_cocci_menhir.mly" +# 1011 "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)) ) -# 19594 "parser_cocci_menhir.ml" +# 19762 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19624,9 +19792,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19630 "parser_cocci_menhir.ml" +# 19798 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -19637,7 +19805,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 19641 "parser_cocci_menhir.ml" +# 19809 "parser_cocci_menhir.ml" in let s = @@ -19645,15 +19813,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19649 "parser_cocci_menhir.ml" +# 19817 "parser_cocci_menhir.ml" in -# 1006 "parser_cocci_menhir.mly" +# 1011 "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)) ) -# 19657 "parser_cocci_menhir.ml" +# 19825 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19692,9 +19860,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19698 "parser_cocci_menhir.ml" +# 19866 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -19707,7 +19875,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19711 "parser_cocci_menhir.ml" +# 19879 "parser_cocci_menhir.ml" in let s = @@ -19715,15 +19883,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19719 "parser_cocci_menhir.ml" +# 19887 "parser_cocci_menhir.ml" in -# 1006 "parser_cocci_menhir.mly" +# 1011 "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)) ) -# 19727 "parser_cocci_menhir.ml" +# 19895 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19762,15 +19930,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19768 "parser_cocci_menhir.ml" +# 19936 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19774 "parser_cocci_menhir.ml" +# 19942 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -19780,24 +19948,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 19784 "parser_cocci_menhir.ml" +# 19952 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 19791 "parser_cocci_menhir.ml" +# 19959 "parser_cocci_menhir.ml" in -# 1011 "parser_cocci_menhir.mly" +# 1016 "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)) ) -# 19801 "parser_cocci_menhir.ml" +# 19969 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19841,15 +20009,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19847 "parser_cocci_menhir.ml" +# 20015 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19853 "parser_cocci_menhir.ml" +# 20021 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -19861,24 +20029,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19865 "parser_cocci_menhir.ml" +# 20033 "parser_cocci_menhir.ml" in let s = # 39 "standard.mly" ( None ) -# 19872 "parser_cocci_menhir.ml" +# 20040 "parser_cocci_menhir.ml" in -# 1011 "parser_cocci_menhir.mly" +# 1016 "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)) ) -# 19882 "parser_cocci_menhir.ml" +# 20050 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -19922,15 +20090,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19928 "parser_cocci_menhir.ml" +# 20096 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 19934 "parser_cocci_menhir.ml" +# 20102 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -19941,7 +20109,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 19945 "parser_cocci_menhir.ml" +# 20113 "parser_cocci_menhir.ml" in let s = @@ -19949,17 +20117,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 19953 "parser_cocci_menhir.ml" +# 20121 "parser_cocci_menhir.ml" in -# 1011 "parser_cocci_menhir.mly" +# 1016 "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)) ) -# 19963 "parser_cocci_menhir.ml" +# 20131 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20008,15 +20176,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20014 "parser_cocci_menhir.ml" +# 20182 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20020 "parser_cocci_menhir.ml" +# 20188 "parser_cocci_menhir.ml" ) = Obj.magic q in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -20029,7 +20197,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 20033 "parser_cocci_menhir.ml" +# 20201 "parser_cocci_menhir.ml" in let s = @@ -20037,17 +20205,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 20041 "parser_cocci_menhir.ml" +# 20209 "parser_cocci_menhir.ml" in -# 1011 "parser_cocci_menhir.mly" +# 1016 "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)) ) -# 20051 "parser_cocci_menhir.ml" +# 20219 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20106,36 +20274,36 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20112 "parser_cocci_menhir.ml" +# 20280 "parser_cocci_menhir.ml" ) = Obj.magic pv in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20117 "parser_cocci_menhir.ml" +# 20285 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20123 "parser_cocci_menhir.ml" +# 20291 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20128 "parser_cocci_menhir.ml" +# 20296 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 20134 "parser_cocci_menhir.ml" +# 20302 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20139 "parser_cocci_menhir.ml" +# 20307 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let _startpos = _startpos_t_ in @@ -20144,11 +20312,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 20148 "parser_cocci_menhir.ml" +# 20316 "parser_cocci_menhir.ml" in -# 1021 "parser_cocci_menhir.mly" +# 1026 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -20156,7 +20324,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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)) ) -# 20160 "parser_cocci_menhir.ml" +# 20328 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20220,36 +20388,36 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20226 "parser_cocci_menhir.ml" +# 20394 "parser_cocci_menhir.ml" ) = Obj.magic pv in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20231 "parser_cocci_menhir.ml" +# 20399 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20237 "parser_cocci_menhir.ml" +# 20405 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20242 "parser_cocci_menhir.ml" +# 20410 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 20248 "parser_cocci_menhir.ml" +# 20416 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20253 "parser_cocci_menhir.ml" +# 20421 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let x0 : 'tv_storage = Obj.magic x0 in @@ -20260,11 +20428,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 20264 "parser_cocci_menhir.ml" +# 20432 "parser_cocci_menhir.ml" in -# 1021 "parser_cocci_menhir.mly" +# 1026 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -20272,7 +20440,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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)) ) -# 20276 "parser_cocci_menhir.ml" +# 20444 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20311,29 +20479,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _5 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20317 "parser_cocci_menhir.ml" +# 20485 "parser_cocci_menhir.ml" ) = Obj.magic _5 in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20322 "parser_cocci_menhir.ml" +# 20490 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr_list_option = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20328 "parser_cocci_menhir.ml" +# 20496 "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 = -# 1029 "parser_cocci_menhir.mly" +# 1034 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.MacroDecl(_1,P.clt2mcode "(" _2,_3, P.clt2mcode ")" _4,P.clt2mcode ";" _5)) ) -# 20337 "parser_cocci_menhir.ml" +# 20505 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20402,42 +20570,42 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20408 "parser_cocci_menhir.ml" +# 20576 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20414 "parser_cocci_menhir.ml" +# 20582 "parser_cocci_menhir.ml" ) = Obj.magic q in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20419 "parser_cocci_menhir.ml" +# 20587 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20425 "parser_cocci_menhir.ml" +# 20593 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20430 "parser_cocci_menhir.ml" +# 20598 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 20436 "parser_cocci_menhir.ml" +# 20604 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20441 "parser_cocci_menhir.ml" +# 20609 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let _startpos = _startpos_t_ in @@ -20446,11 +20614,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 20450 "parser_cocci_menhir.ml" +# 20618 "parser_cocci_menhir.ml" in -# 1035 "parser_cocci_menhir.mly" +# 1040 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -20458,7 +20626,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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))) -# 20462 "parser_cocci_menhir.ml" +# 20630 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20532,42 +20700,42 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20538 "parser_cocci_menhir.ml" +# 20706 "parser_cocci_menhir.ml" ) = Obj.magic pv in let e : 'tv_initialize = Obj.magic e in let q : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 20544 "parser_cocci_menhir.ml" +# 20712 "parser_cocci_menhir.ml" ) = Obj.magic q in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20549 "parser_cocci_menhir.ml" +# 20717 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20555 "parser_cocci_menhir.ml" +# 20723 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 20560 "parser_cocci_menhir.ml" +# 20728 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 20566 "parser_cocci_menhir.ml" +# 20734 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 20571 "parser_cocci_menhir.ml" +# 20739 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let x0 : 'tv_storage = Obj.magic x0 in @@ -20578,11 +20746,11 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 20582 "parser_cocci_menhir.ml" +# 20750 "parser_cocci_menhir.ml" in -# 1035 "parser_cocci_menhir.mly" +# 1040 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -20590,7 +20758,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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))) -# 20594 "parser_cocci_menhir.ml" +# 20762 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20607,7 +20775,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_option_TLocal_ = # 29 "standard.mly" ( None ) -# 20611 "parser_cocci_menhir.ml" +# 20779 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20631,7 +20799,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_option_TLocal_ = # 31 "standard.mly" ( Some x ) -# 20635 "parser_cocci_menhir.ml" +# 20803 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20648,7 +20816,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_option_TPosAny_ = # 29 "standard.mly" ( None ) -# 20652 "parser_cocci_menhir.ml" +# 20820 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20672,7 +20840,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_option_TPosAny_ = # 31 "standard.mly" ( Some x ) -# 20676 "parser_cocci_menhir.ml" +# 20844 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20689,7 +20857,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_option_eexpr_ = # 29 "standard.mly" ( None ) -# 20693 "parser_cocci_menhir.ml" +# 20861 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20713,7 +20881,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_option_eexpr_ = # 31 "standard.mly" ( Some x ) -# 20717 "parser_cocci_menhir.ml" +# 20885 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20728,9 +20896,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_plus_after_dots = -# 1647 "parser_cocci_menhir.mly" +# 1659 "parser_cocci_menhir.mly" ([]) -# 20734 "parser_cocci_menhir.ml" +# 20902 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20756,9 +20924,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_dots = -# 1648 "parser_cocci_menhir.mly" +# 1660 "parser_cocci_menhir.mly" (_2) -# 20762 "parser_cocci_menhir.ml" +# 20930 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20786,9 +20954,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_dots = -# 1650 "parser_cocci_menhir.mly" +# 1662 "parser_cocci_menhir.mly" ( (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp(_1)))))::_2 ) -# 20792 "parser_cocci_menhir.ml" +# 20960 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20816,9 +20984,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_dots = -# 1651 "parser_cocci_menhir.mly" +# 1663 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DECL(_1))::_2 ) -# 20822 "parser_cocci_menhir.ml" +# 20990 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20846,9 +21014,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_dots = -# 1653 "parser_cocci_menhir.mly" +# 1665 "parser_cocci_menhir.mly" ( (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1)@_2 ) -# 20852 "parser_cocci_menhir.ml" +# 21020 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20863,9 +21031,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_plus_after_exp = -# 1643 "parser_cocci_menhir.mly" +# 1655 "parser_cocci_menhir.mly" ([]) -# 20869 "parser_cocci_menhir.ml" +# 21037 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20893,9 +21061,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_exp = -# 1644 "parser_cocci_menhir.mly" +# 1656 "parser_cocci_menhir.mly" ( (Ast0.wrap(Ast0.OTHER(_1)))::_2 ) -# 20899 "parser_cocci_menhir.ml" +# 21067 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20910,9 +21078,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_plus_after_stm = -# 1656 "parser_cocci_menhir.mly" +# 1668 "parser_cocci_menhir.mly" ([]) -# 20916 "parser_cocci_menhir.ml" +# 21084 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20940,9 +21108,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_stm = -# 1657 "parser_cocci_menhir.mly" +# 1669 "parser_cocci_menhir.mly" ( (Ast0.wrap(Ast0.OTHER(_1)))::_2 ) -# 20946 "parser_cocci_menhir.ml" +# 21114 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -20970,9 +21138,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_stm = -# 1658 "parser_cocci_menhir.mly" +# 1670 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DECL(_1))::_2 ) -# 20976 "parser_cocci_menhir.ml" +# 21144 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21000,9 +21168,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_after_stm = -# 1660 "parser_cocci_menhir.mly" +# 1672 "parser_cocci_menhir.mly" ( (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1)@_2 ) -# 21006 "parser_cocci_menhir.ml" +# 21174 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21036,9 +21204,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_f_ in let _endpos = _endpos_ew_ in let _v : 'tv_plus_body = -# 600 "parser_cocci_menhir.mly" +# 605 "parser_cocci_menhir.mly" ( Top_level.top_level (f@b@ew) ) -# 21042 "parser_cocci_menhir.ml" +# 21210 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21072,9 +21240,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_f_ in let _endpos = _endpos_ew_ in let _v : 'tv_plus_exp_body = -# 614 "parser_cocci_menhir.mly" +# 619 "parser_cocci_menhir.mly" ( Top_level.top_level (f@[b]@ew) ) -# 21078 "parser_cocci_menhir.ml" +# 21246 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21100,13 +21268,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 142 "parser_cocci_menhir.mly" +# 143 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 21106 "parser_cocci_menhir.ml" +# 21274 "parser_cocci_menhir.ml" ) = -# 178 "parser_cocci_menhir.mly" +# 179 "parser_cocci_menhir.mly" ( _1 ) -# 21110 "parser_cocci_menhir.ml" +# 21278 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21132,13 +21300,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_p_ in let _endpos = _endpos__2_ in let _v : ( -# 142 "parser_cocci_menhir.mly" +# 143 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 21138 "parser_cocci_menhir.ml" +# 21306 "parser_cocci_menhir.ml" ) = -# 178 "parser_cocci_menhir.mly" +# 179 "parser_cocci_menhir.mly" ( p ) -# 21142 "parser_cocci_menhir.ml" +# 21310 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21164,13 +21332,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_p_ in let _endpos = _endpos__2_ in let _v : ( -# 142 "parser_cocci_menhir.mly" +# 143 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 21170 "parser_cocci_menhir.ml" +# 21338 "parser_cocci_menhir.ml" ) = -# 179 "parser_cocci_menhir.mly" +# 180 "parser_cocci_menhir.mly" ( p ) -# 21174 "parser_cocci_menhir.ml" +# 21342 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21196,13 +21364,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : ( -# 139 "parser_cocci_menhir.mly" +# 140 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 21202 "parser_cocci_menhir.ml" +# 21370 "parser_cocci_menhir.ml" ) = -# 174 "parser_cocci_menhir.mly" +# 175 "parser_cocci_menhir.mly" ( _1 ) -# 21206 "parser_cocci_menhir.ml" +# 21374 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21228,13 +21396,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_p_ in let _endpos = _endpos__2_ in let _v : ( -# 139 "parser_cocci_menhir.mly" +# 140 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 21234 "parser_cocci_menhir.ml" +# 21402 "parser_cocci_menhir.ml" ) = -# 174 "parser_cocci_menhir.mly" +# 175 "parser_cocci_menhir.mly" ( p ) -# 21238 "parser_cocci_menhir.ml" +# 21406 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21260,13 +21428,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_p_ in let _endpos = _endpos__2_ in let _v : ( -# 139 "parser_cocci_menhir.mly" +# 140 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 21266 "parser_cocci_menhir.ml" +# 21434 "parser_cocci_menhir.ml" ) = -# 175 "parser_cocci_menhir.mly" +# 176 "parser_cocci_menhir.mly" ( p ) -# 21270 "parser_cocci_menhir.ml" +# 21438 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21288,9 +21456,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_plus_start = -# 1632 "parser_cocci_menhir.mly" +# 1644 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty(_1))))] ) -# 21294 "parser_cocci_menhir.ml" +# 21462 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21312,9 +21480,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_plus_start = -# 1633 "parser_cocci_menhir.mly" +# 1645 "parser_cocci_menhir.mly" ( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit(_1))))] ) -# 21318 "parser_cocci_menhir.ml" +# 21486 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21342,9 +21510,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_start = -# 1635 "parser_cocci_menhir.mly" +# 1647 "parser_cocci_menhir.mly" ( (Ast0.wrap(Ast0.OTHER(_1)))::_2 ) -# 21348 "parser_cocci_menhir.ml" +# 21516 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21372,9 +21540,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_start = -# 1637 "parser_cocci_menhir.mly" +# 1649 "parser_cocci_menhir.mly" ( (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp(_1)))))::_2 ) -# 21378 "parser_cocci_menhir.ml" +# 21546 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21402,9 +21570,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_start = -# 1638 "parser_cocci_menhir.mly" +# 1650 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DECL(_1))::_2 ) -# 21408 "parser_cocci_menhir.ml" +# 21576 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21432,9 +21600,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_plus_start = -# 1640 "parser_cocci_menhir.mly" +# 1652 "parser_cocci_menhir.mly" ( (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1)@_2 ) -# 21438 "parser_cocci_menhir.ml" +# 21606 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21455,14 +21623,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 47 "parser_cocci_menhir.mly" (string) -# 21459 "parser_cocci_menhir.ml" +# 21627 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pnrule = -# 225 "parser_cocci_menhir.mly" +# 226 "parser_cocci_menhir.mly" ( Ast.Dep _1 ) -# 21466 "parser_cocci_menhir.ml" +# 21634 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21487,14 +21655,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _2 : ( # 47 "parser_cocci_menhir.mly" (string) -# 21491 "parser_cocci_menhir.ml" +# 21659 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_pnrule = -# 226 "parser_cocci_menhir.mly" +# 227 "parser_cocci_menhir.mly" ( Ast.AntiDep _2 ) -# 21498 "parser_cocci_menhir.ml" +# 21666 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21519,14 +21687,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _2 : ( # 47 "parser_cocci_menhir.mly" (string) -# 21523 "parser_cocci_menhir.ml" +# 21691 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_pnrule = -# 227 "parser_cocci_menhir.mly" +# 228 "parser_cocci_menhir.mly" ( Ast.EverDep _2 ) -# 21530 "parser_cocci_menhir.ml" +# 21698 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21551,14 +21719,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _2 : ( # 47 "parser_cocci_menhir.mly" (string) -# 21555 "parser_cocci_menhir.ml" +# 21723 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_pnrule = -# 228 "parser_cocci_menhir.mly" +# 229 "parser_cocci_menhir.mly" ( Ast.NeverDep _2 ) -# 21562 "parser_cocci_menhir.ml" +# 21730 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21588,9 +21756,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_pnrule = -# 229 "parser_cocci_menhir.mly" +# 230 "parser_cocci_menhir.mly" ( _2 ) -# 21594 "parser_cocci_menhir.ml" +# 21762 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21612,9 +21780,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_postfix_expr_eexpr_dot_expressions_ = -# 1301 "parser_cocci_menhir.mly" +# 1312 "parser_cocci_menhir.mly" ( _1 ) -# 21618 "parser_cocci_menhir.ml" +# 21786 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21648,24 +21816,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 21654 "parser_cocci_menhir.ml" +# 21822 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 21660 "parser_cocci_menhir.ml" +# 21828 "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_ = -# 1303 "parser_cocci_menhir.mly" +# 1314 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3, P.clt2mcode "]" _4)) ) -# 21669 "parser_cocci_menhir.ml" +# 21837 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21695,17 +21863,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 21701 "parser_cocci_menhir.ml" +# 21869 "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_ = -# 1306 "parser_cocci_menhir.mly" +# 1317 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) ) -# 21709 "parser_cocci_menhir.ml" +# 21877 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21735,18 +21903,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 103 "parser_cocci_menhir.mly" +# 104 "parser_cocci_menhir.mly" (Data.clt) -# 21741 "parser_cocci_menhir.ml" +# 21909 "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_ = -# 1308 "parser_cocci_menhir.mly" +# 1319 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2, _3)) ) -# 21750 "parser_cocci_menhir.ml" +# 21918 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21770,17 +21938,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 21776 "parser_cocci_menhir.ml" +# 21944 "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_ = -# 1311 "parser_cocci_menhir.mly" +# 1322 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) ) -# 21784 "parser_cocci_menhir.ml" +# 21952 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21804,17 +21972,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 21810 "parser_cocci_menhir.ml" +# 21978 "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_ = -# 1313 "parser_cocci_menhir.mly" +# 1324 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) ) -# 21818 "parser_cocci_menhir.ml" +# 21986 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21848,25 +22016,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 21854 "parser_cocci_menhir.ml" +# 22022 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr_list_option = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 21860 "parser_cocci_menhir.ml" +# 22028 "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_ = -# 1315 "parser_cocci_menhir.mly" +# 1326 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2, _3, P.clt2mcode ")" _4)) ) -# 21870 "parser_cocci_menhir.ml" +# 22038 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21888,9 +22056,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_postfix_expr_eexpr_invalid_ = -# 1301 "parser_cocci_menhir.mly" +# 1312 "parser_cocci_menhir.mly" ( _1 ) -# 21894 "parser_cocci_menhir.ml" +# 22062 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21924,24 +22092,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 21930 "parser_cocci_menhir.ml" +# 22098 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 21936 "parser_cocci_menhir.ml" +# 22104 "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_ = -# 1303 "parser_cocci_menhir.mly" +# 1314 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3, P.clt2mcode "]" _4)) ) -# 21945 "parser_cocci_menhir.ml" +# 22113 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -21971,17 +22139,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 21977 "parser_cocci_menhir.ml" +# 22145 "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_ = -# 1306 "parser_cocci_menhir.mly" +# 1317 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) ) -# 21985 "parser_cocci_menhir.ml" +# 22153 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22011,18 +22179,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 103 "parser_cocci_menhir.mly" +# 104 "parser_cocci_menhir.mly" (Data.clt) -# 22017 "parser_cocci_menhir.ml" +# 22185 "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_ = -# 1308 "parser_cocci_menhir.mly" +# 1319 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2, _3)) ) -# 22026 "parser_cocci_menhir.ml" +# 22194 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22046,17 +22214,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 22052 "parser_cocci_menhir.ml" +# 22220 "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_ = -# 1311 "parser_cocci_menhir.mly" +# 1322 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) ) -# 22060 "parser_cocci_menhir.ml" +# 22228 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22080,17 +22248,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 22086 "parser_cocci_menhir.ml" +# 22254 "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_ = -# 1313 "parser_cocci_menhir.mly" +# 1324 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) ) -# 22094 "parser_cocci_menhir.ml" +# 22262 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22124,25 +22292,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 22130 "parser_cocci_menhir.ml" +# 22298 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr_list_option = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 22136 "parser_cocci_menhir.ml" +# 22304 "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_ = -# 1315 "parser_cocci_menhir.mly" +# 1326 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2, _3, P.clt2mcode ")" _4)) ) -# 22146 "parser_cocci_menhir.ml" +# 22314 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22164,9 +22332,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_postfix_expr_eexpr_nest_expressions_ = -# 1301 "parser_cocci_menhir.mly" +# 1312 "parser_cocci_menhir.mly" ( _1 ) -# 22170 "parser_cocci_menhir.ml" +# 22338 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22200,24 +22368,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 22206 "parser_cocci_menhir.ml" +# 22374 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 22212 "parser_cocci_menhir.ml" +# 22380 "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_ = -# 1303 "parser_cocci_menhir.mly" +# 1314 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3, P.clt2mcode "]" _4)) ) -# 22221 "parser_cocci_menhir.ml" +# 22389 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22247,17 +22415,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 22253 "parser_cocci_menhir.ml" +# 22421 "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_ = -# 1306 "parser_cocci_menhir.mly" +# 1317 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) ) -# 22261 "parser_cocci_menhir.ml" +# 22429 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22287,18 +22455,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 103 "parser_cocci_menhir.mly" +# 104 "parser_cocci_menhir.mly" (Data.clt) -# 22293 "parser_cocci_menhir.ml" +# 22461 "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_ = -# 1308 "parser_cocci_menhir.mly" +# 1319 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2, _3)) ) -# 22302 "parser_cocci_menhir.ml" +# 22470 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22322,17 +22490,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 22328 "parser_cocci_menhir.ml" +# 22496 "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_ = -# 1311 "parser_cocci_menhir.mly" +# 1322 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) ) -# 22336 "parser_cocci_menhir.ml" +# 22504 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22356,17 +22524,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 22362 "parser_cocci_menhir.ml" +# 22530 "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_ = -# 1313 "parser_cocci_menhir.mly" +# 1324 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) ) -# 22370 "parser_cocci_menhir.ml" +# 22538 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22400,25 +22568,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 22406 "parser_cocci_menhir.ml" +# 22574 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr_list_option = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 22412 "parser_cocci_menhir.ml" +# 22580 "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_ = -# 1315 "parser_cocci_menhir.mly" +# 1326 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2, _3, P.clt2mcode ")" _4)) ) -# 22422 "parser_cocci_menhir.ml" +# 22590 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22440,9 +22608,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_postfix_expr_expr_invalid_ = -# 1301 "parser_cocci_menhir.mly" +# 1312 "parser_cocci_menhir.mly" ( _1 ) -# 22446 "parser_cocci_menhir.ml" +# 22614 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22476,24 +22644,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 22482 "parser_cocci_menhir.ml" +# 22650 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 101 "parser_cocci_menhir.mly" +# 102 "parser_cocci_menhir.mly" (Data.clt) -# 22488 "parser_cocci_menhir.ml" +# 22656 "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_ = -# 1303 "parser_cocci_menhir.mly" +# 1314 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3, P.clt2mcode "]" _4)) ) -# 22497 "parser_cocci_menhir.ml" +# 22665 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22523,17 +22691,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 22529 "parser_cocci_menhir.ml" +# 22697 "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_ = -# 1306 "parser_cocci_menhir.mly" +# 1317 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) ) -# 22537 "parser_cocci_menhir.ml" +# 22705 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22563,18 +22731,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _3 : 'tv_ident = Obj.magic _3 in let _2 : ( -# 103 "parser_cocci_menhir.mly" +# 104 "parser_cocci_menhir.mly" (Data.clt) -# 22569 "parser_cocci_menhir.ml" +# 22737 "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_ = -# 1308 "parser_cocci_menhir.mly" +# 1319 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2, _3)) ) -# 22578 "parser_cocci_menhir.ml" +# 22746 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22598,17 +22766,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 22604 "parser_cocci_menhir.ml" +# 22772 "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_ = -# 1311 "parser_cocci_menhir.mly" +# 1322 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) ) -# 22612 "parser_cocci_menhir.ml" +# 22780 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22632,17 +22800,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 22638 "parser_cocci_menhir.ml" +# 22806 "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_ = -# 1313 "parser_cocci_menhir.mly" +# 1324 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) ) -# 22646 "parser_cocci_menhir.ml" +# 22814 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22676,25 +22844,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 22682 "parser_cocci_menhir.ml" +# 22850 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr_list_option = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 22688 "parser_cocci_menhir.ml" +# 22856 "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_ = -# 1315 "parser_cocci_menhir.mly" +# 1326 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2, _3, P.clt2mcode ")" _4)) ) -# 22698 "parser_cocci_menhir.ml" +# 22866 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22716,9 +22884,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_eexpr_dot_expressions_ = -# 1320 "parser_cocci_menhir.mly" +# 1331 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Ident(_1)) ) -# 22722 "parser_cocci_menhir.ml" +# 22890 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22737,17 +22905,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 22743 "parser_cocci_menhir.ml" +# 22911 "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_ = -# 1322 "parser_cocci_menhir.mly" +# 1333 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) ) -# 22751 "parser_cocci_menhir.ml" +# 22919 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22766,17 +22934,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 22772 "parser_cocci_menhir.ml" +# 22940 "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_ = -# 1325 "parser_cocci_menhir.mly" +# 1336 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) ) -# 22780 "parser_cocci_menhir.ml" +# 22948 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22795,17 +22963,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 22801 "parser_cocci_menhir.ml" +# 22969 "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_ = -# 1328 "parser_cocci_menhir.mly" +# 1339 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) ) -# 22809 "parser_cocci_menhir.ml" +# 22977 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22824,17 +22992,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 22830 "parser_cocci_menhir.ml" +# 22998 "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_ = -# 1331 "parser_cocci_menhir.mly" +# 1342 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) ) -# 22838 "parser_cocci_menhir.ml" +# 23006 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22853,18 +23021,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 22859 "parser_cocci_menhir.ml" +# 23027 "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_ = -# 1334 "parser_cocci_menhir.mly" +# 1345 "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)) ) -# 22868 "parser_cocci_menhir.ml" +# 23036 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22885,15 +23053,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 63 "parser_cocci_menhir.mly" (Parse_aux.expinfo) -# 22889 "parser_cocci_menhir.ml" +# 23057 "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_ = -# 1338 "parser_cocci_menhir.mly" +# 1349 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) ) -# 22897 "parser_cocci_menhir.ml" +# 23065 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22912,18 +23080,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 22918 "parser_cocci_menhir.ml" +# 23086 "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_ = -# 1341 "parser_cocci_menhir.mly" +# 1352 "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)) ) -# 22927 "parser_cocci_menhir.ml" +# 23095 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22942,18 +23110,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 22948 "parser_cocci_menhir.ml" +# 23116 "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_ = -# 1345 "parser_cocci_menhir.mly" +# 1356 "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)) ) -# 22957 "parser_cocci_menhir.ml" +# 23125 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -22972,18 +23140,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 22978 "parser_cocci_menhir.ml" +# 23146 "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_ = -# 1349 "parser_cocci_menhir.mly" +# 1360 "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)) ) -# 22987 "parser_cocci_menhir.ml" +# 23155 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23012,23 +23180,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 23018 "parser_cocci_menhir.ml" +# 23186 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_eexpr = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 23024 "parser_cocci_menhir.ml" +# 23192 "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_ = -# 1353 "parser_cocci_menhir.mly" +# 1364 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2, P.clt2mcode ")" _3)) ) -# 23032 "parser_cocci_menhir.ml" +# 23200 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23057,25 +23225,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 23063 "parser_cocci_menhir.ml" +# 23231 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_midzero_list_eexpr_eexpr_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 23069 "parser_cocci_menhir.ml" +# 23237 "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_ = -# 1356 "parser_cocci_menhir.mly" +# 1367 "parser_cocci_menhir.mly" ( let (mids,code) = _2 in Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1, code, mids, P.clt2mcode ")" _3)) ) -# 23079 "parser_cocci_menhir.ml" +# 23247 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23097,9 +23265,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_eexpr_dot_expressions_ = -# 1360 "parser_cocci_menhir.mly" +# 1371 "parser_cocci_menhir.mly" ( _1 ) -# 23103 "parser_cocci_menhir.ml" +# 23271 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23121,9 +23289,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_eexpr_invalid_ = -# 1320 "parser_cocci_menhir.mly" +# 1331 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Ident(_1)) ) -# 23127 "parser_cocci_menhir.ml" +# 23295 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23142,17 +23310,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23148 "parser_cocci_menhir.ml" +# 23316 "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_ = -# 1322 "parser_cocci_menhir.mly" +# 1333 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) ) -# 23156 "parser_cocci_menhir.ml" +# 23324 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23171,17 +23339,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23177 "parser_cocci_menhir.ml" +# 23345 "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_ = -# 1325 "parser_cocci_menhir.mly" +# 1336 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) ) -# 23185 "parser_cocci_menhir.ml" +# 23353 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23200,17 +23368,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23206 "parser_cocci_menhir.ml" +# 23374 "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_ = -# 1328 "parser_cocci_menhir.mly" +# 1339 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) ) -# 23214 "parser_cocci_menhir.ml" +# 23382 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23229,17 +23397,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23235 "parser_cocci_menhir.ml" +# 23403 "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_ = -# 1331 "parser_cocci_menhir.mly" +# 1342 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) ) -# 23243 "parser_cocci_menhir.ml" +# 23411 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23258,18 +23426,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23264 "parser_cocci_menhir.ml" +# 23432 "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_ = -# 1334 "parser_cocci_menhir.mly" +# 1345 "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)) ) -# 23273 "parser_cocci_menhir.ml" +# 23441 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23290,15 +23458,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 63 "parser_cocci_menhir.mly" (Parse_aux.expinfo) -# 23294 "parser_cocci_menhir.ml" +# 23462 "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_ = -# 1338 "parser_cocci_menhir.mly" +# 1349 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) ) -# 23302 "parser_cocci_menhir.ml" +# 23470 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23317,18 +23485,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23323 "parser_cocci_menhir.ml" +# 23491 "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_ = -# 1341 "parser_cocci_menhir.mly" +# 1352 "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)) ) -# 23332 "parser_cocci_menhir.ml" +# 23500 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23347,18 +23515,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23353 "parser_cocci_menhir.ml" +# 23521 "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_ = -# 1345 "parser_cocci_menhir.mly" +# 1356 "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)) ) -# 23362 "parser_cocci_menhir.ml" +# 23530 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23377,18 +23545,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23383 "parser_cocci_menhir.ml" +# 23551 "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_ = -# 1349 "parser_cocci_menhir.mly" +# 1360 "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)) ) -# 23392 "parser_cocci_menhir.ml" +# 23560 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23417,23 +23585,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 23423 "parser_cocci_menhir.ml" +# 23591 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_eexpr = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 23429 "parser_cocci_menhir.ml" +# 23597 "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_ = -# 1353 "parser_cocci_menhir.mly" +# 1364 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2, P.clt2mcode ")" _3)) ) -# 23437 "parser_cocci_menhir.ml" +# 23605 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23462,25 +23630,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 23468 "parser_cocci_menhir.ml" +# 23636 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_midzero_list_eexpr_eexpr_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 23474 "parser_cocci_menhir.ml" +# 23642 "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_ = -# 1356 "parser_cocci_menhir.mly" +# 1367 "parser_cocci_menhir.mly" ( let (mids,code) = _2 in Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1, code, mids, P.clt2mcode ")" _3)) ) -# 23484 "parser_cocci_menhir.ml" +# 23652 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23502,9 +23670,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_eexpr_invalid_ = -# 1360 "parser_cocci_menhir.mly" +# 1371 "parser_cocci_menhir.mly" ( _1 ) -# 23508 "parser_cocci_menhir.ml" +# 23676 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23526,9 +23694,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_eexpr_nest_expressions_ = -# 1320 "parser_cocci_menhir.mly" +# 1331 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Ident(_1)) ) -# 23532 "parser_cocci_menhir.ml" +# 23700 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23547,17 +23715,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23553 "parser_cocci_menhir.ml" +# 23721 "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_ = -# 1322 "parser_cocci_menhir.mly" +# 1333 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) ) -# 23561 "parser_cocci_menhir.ml" +# 23729 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23576,17 +23744,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23582 "parser_cocci_menhir.ml" +# 23750 "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_ = -# 1325 "parser_cocci_menhir.mly" +# 1336 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) ) -# 23590 "parser_cocci_menhir.ml" +# 23758 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23605,17 +23773,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23611 "parser_cocci_menhir.ml" +# 23779 "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_ = -# 1328 "parser_cocci_menhir.mly" +# 1339 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) ) -# 23619 "parser_cocci_menhir.ml" +# 23787 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23634,17 +23802,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23640 "parser_cocci_menhir.ml" +# 23808 "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_ = -# 1331 "parser_cocci_menhir.mly" +# 1342 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) ) -# 23648 "parser_cocci_menhir.ml" +# 23816 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23663,18 +23831,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23669 "parser_cocci_menhir.ml" +# 23837 "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_ = -# 1334 "parser_cocci_menhir.mly" +# 1345 "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)) ) -# 23678 "parser_cocci_menhir.ml" +# 23846 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23695,15 +23863,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 63 "parser_cocci_menhir.mly" (Parse_aux.expinfo) -# 23699 "parser_cocci_menhir.ml" +# 23867 "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_ = -# 1338 "parser_cocci_menhir.mly" +# 1349 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) ) -# 23707 "parser_cocci_menhir.ml" +# 23875 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23722,18 +23890,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23728 "parser_cocci_menhir.ml" +# 23896 "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_ = -# 1341 "parser_cocci_menhir.mly" +# 1352 "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)) ) -# 23737 "parser_cocci_menhir.ml" +# 23905 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23752,18 +23920,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23758 "parser_cocci_menhir.ml" +# 23926 "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_ = -# 1345 "parser_cocci_menhir.mly" +# 1356 "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)) ) -# 23767 "parser_cocci_menhir.ml" +# 23935 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23782,18 +23950,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 23788 "parser_cocci_menhir.ml" +# 23956 "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_ = -# 1349 "parser_cocci_menhir.mly" +# 1360 "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)) ) -# 23797 "parser_cocci_menhir.ml" +# 23965 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23822,23 +23990,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 23828 "parser_cocci_menhir.ml" +# 23996 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_eexpr = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 23834 "parser_cocci_menhir.ml" +# 24002 "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_ = -# 1353 "parser_cocci_menhir.mly" +# 1364 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2, P.clt2mcode ")" _3)) ) -# 23842 "parser_cocci_menhir.ml" +# 24010 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23867,25 +24035,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 23873 "parser_cocci_menhir.ml" +# 24041 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_midzero_list_eexpr_eexpr_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 23879 "parser_cocci_menhir.ml" +# 24047 "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_ = -# 1356 "parser_cocci_menhir.mly" +# 1367 "parser_cocci_menhir.mly" ( let (mids,code) = _2 in Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1, code, mids, P.clt2mcode ")" _3)) ) -# 23889 "parser_cocci_menhir.ml" +# 24057 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23907,9 +24075,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_eexpr_nest_expressions_ = -# 1360 "parser_cocci_menhir.mly" +# 1371 "parser_cocci_menhir.mly" ( _1 ) -# 23913 "parser_cocci_menhir.ml" +# 24081 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23931,9 +24099,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_expr_invalid_ = -# 1320 "parser_cocci_menhir.mly" +# 1331 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Ident(_1)) ) -# 23937 "parser_cocci_menhir.ml" +# 24105 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23952,17 +24120,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23958 "parser_cocci_menhir.ml" +# 24126 "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_ = -# 1322 "parser_cocci_menhir.mly" +# 1333 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) ) -# 23966 "parser_cocci_menhir.ml" +# 24134 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -23981,17 +24149,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 23987 "parser_cocci_menhir.ml" +# 24155 "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_ = -# 1325 "parser_cocci_menhir.mly" +# 1336 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) ) -# 23995 "parser_cocci_menhir.ml" +# 24163 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24010,17 +24178,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 24016 "parser_cocci_menhir.ml" +# 24184 "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_ = -# 1328 "parser_cocci_menhir.mly" +# 1339 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) ) -# 24024 "parser_cocci_menhir.ml" +# 24192 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24039,17 +24207,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 24045 "parser_cocci_menhir.ml" +# 24213 "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_ = -# 1331 "parser_cocci_menhir.mly" +# 1342 "parser_cocci_menhir.mly" ( let (x,clt) = _1 in Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) ) -# 24053 "parser_cocci_menhir.ml" +# 24221 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24068,18 +24236,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 24074 "parser_cocci_menhir.ml" +# 24242 "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_ = -# 1334 "parser_cocci_menhir.mly" +# 1345 "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)) ) -# 24083 "parser_cocci_menhir.ml" +# 24251 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24100,15 +24268,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 63 "parser_cocci_menhir.mly" (Parse_aux.expinfo) -# 24104 "parser_cocci_menhir.ml" +# 24272 "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_ = -# 1338 "parser_cocci_menhir.mly" +# 1349 "parser_cocci_menhir.mly" ( let (nm,constraints,pure,clt) = _1 in Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) ) -# 24112 "parser_cocci_menhir.ml" +# 24280 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24127,18 +24295,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 24133 "parser_cocci_menhir.ml" +# 24301 "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_ = -# 1341 "parser_cocci_menhir.mly" +# 1352 "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)) ) -# 24142 "parser_cocci_menhir.ml" +# 24310 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24157,18 +24325,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 24163 "parser_cocci_menhir.ml" +# 24331 "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_ = -# 1345 "parser_cocci_menhir.mly" +# 1356 "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)) ) -# 24172 "parser_cocci_menhir.ml" +# 24340 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24187,18 +24355,18 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 66 "parser_cocci_menhir.mly" +# 67 "parser_cocci_menhir.mly" (Parse_aux.typed_info) -# 24193 "parser_cocci_menhir.ml" +# 24361 "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_ = -# 1349 "parser_cocci_menhir.mly" +# 1360 "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)) ) -# 24202 "parser_cocci_menhir.ml" +# 24370 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24227,23 +24395,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 24233 "parser_cocci_menhir.ml" +# 24401 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_eexpr = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 24239 "parser_cocci_menhir.ml" +# 24407 "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_ = -# 1353 "parser_cocci_menhir.mly" +# 1364 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2, P.clt2mcode ")" _3)) ) -# 24247 "parser_cocci_menhir.ml" +# 24415 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24272,25 +24440,25 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 24278 "parser_cocci_menhir.ml" +# 24446 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_midzero_list_expr_eexpr_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 24284 "parser_cocci_menhir.ml" +# 24452 "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_ = -# 1356 "parser_cocci_menhir.mly" +# 1367 "parser_cocci_menhir.mly" ( let (mids,code) = _2 in Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1, code, mids, P.clt2mcode ")" _3)) ) -# 24294 "parser_cocci_menhir.ml" +# 24462 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24312,9 +24480,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_primary_expr_expr_invalid_ = -# 1360 "parser_cocci_menhir.mly" +# 1371 "parser_cocci_menhir.mly" ( _1 ) -# 24318 "parser_cocci_menhir.ml" +# 24486 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24334,9 +24502,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure = -# 189 "parser_cocci_menhir.mly" +# 190 "parser_cocci_menhir.mly" ( Ast0.Pure ) -# 24340 "parser_cocci_menhir.ml" +# 24508 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24356,9 +24524,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure = -# 190 "parser_cocci_menhir.mly" +# 191 "parser_cocci_menhir.mly" ( Ast0.Context ) -# 24362 "parser_cocci_menhir.ml" +# 24530 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24382,9 +24550,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_pure = -# 191 "parser_cocci_menhir.mly" +# 192 "parser_cocci_menhir.mly" ( Ast0.PureContext ) -# 24388 "parser_cocci_menhir.ml" +# 24556 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24408,9 +24576,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_pure = -# 192 "parser_cocci_menhir.mly" +# 193 "parser_cocci_menhir.mly" ( Ast0.PureContext ) -# 24414 "parser_cocci_menhir.ml" +# 24582 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24425,9 +24593,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_pure = -# 193 "parser_cocci_menhir.mly" +# 194 "parser_cocci_menhir.mly" ( Ast0.Impure ) -# 24431 "parser_cocci_menhir.ml" +# 24599 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24448,14 +24616,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 59 "parser_cocci_menhir.mly" (string * Data.clt) -# 24452 "parser_cocci_menhir.ml" +# 24620 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure_ident = -# 1374 "parser_cocci_menhir.mly" +# 1385 "parser_cocci_menhir.mly" ( _1 ) -# 24459 "parser_cocci_menhir.ml" +# 24627 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24477,9 +24645,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure_ident_or_meta_ident = -# 1380 "parser_cocci_menhir.mly" +# 1391 "parser_cocci_menhir.mly" ( (None,P.id2name _1) ) -# 24483 "parser_cocci_menhir.ml" +# 24651 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24501,9 +24669,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure_ident_or_meta_ident = -# 1381 "parser_cocci_menhir.mly" +# 1392 "parser_cocci_menhir.mly" ( _1 ) -# 24507 "parser_cocci_menhir.ml" +# 24675 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24523,9 +24691,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure_ident_or_meta_ident = -# 1382 "parser_cocci_menhir.mly" +# 1393 "parser_cocci_menhir.mly" ( (None,"list") ) -# 24529 "parser_cocci_menhir.ml" +# 24697 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24545,9 +24713,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure_ident_or_meta_ident = -# 1383 "parser_cocci_menhir.mly" +# 1394 "parser_cocci_menhir.mly" ( (None,"error") ) -# 24551 "parser_cocci_menhir.ml" +# 24719 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24567,9 +24735,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure_ident_or_meta_ident = -# 1384 "parser_cocci_menhir.mly" +# 1395 "parser_cocci_menhir.mly" ( (None,"type") ) -# 24573 "parser_cocci_menhir.ml" +# 24741 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24589,9 +24757,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_pure_ident_or_meta_ident = -# 1385 "parser_cocci_menhir.mly" +# 1396 "parser_cocci_menhir.mly" ( (None,"name") ) -# 24595 "parser_cocci_menhir.ml" +# 24763 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24619,9 +24787,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_i_ in let _endpos = _endpos_l_ in let _v : 'tv_pure_ident_or_meta_ident_with_not_eq_not_ceq_ = -# 1388 "parser_cocci_menhir.mly" +# 1399 "parser_cocci_menhir.mly" ( (i,l) ) -# 24625 "parser_cocci_menhir.ml" +# 24793 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24649,9 +24817,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_i_ in let _endpos = _endpos_l_ in let _v : 'tv_pure_ident_or_meta_ident_with_not_eq_not_eq_ = -# 1388 "parser_cocci_menhir.mly" +# 1399 "parser_cocci_menhir.mly" ( (i,l) ) -# 24655 "parser_cocci_menhir.ml" +# 24823 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24679,9 +24847,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_i_ in let _endpos = _endpos_l_ in let _v : 'tv_pure_ident_or_meta_ident_with_not_eq_not_eqe_ = -# 1388 "parser_cocci_menhir.mly" +# 1399 "parser_cocci_menhir.mly" ( (i,l) ) -# 24685 "parser_cocci_menhir.ml" +# 24853 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24709,9 +24877,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_i_ in let _endpos = _endpos_l_ in let _v : 'tv_pure_ident_or_meta_ident_with_not_eq_not_pos_ = -# 1388 "parser_cocci_menhir.mly" +# 1399 "parser_cocci_menhir.mly" ( (i,l) ) -# 24715 "parser_cocci_menhir.ml" +# 24883 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24726,13 +24894,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : ( -# 130 "parser_cocci_menhir.mly" +# 131 "parser_cocci_menhir.mly" (unit) -# 24732 "parser_cocci_menhir.ml" +# 24900 "parser_cocci_menhir.ml" ) = -# 171 "parser_cocci_menhir.mly" +# 172 "parser_cocci_menhir.mly" ( ) -# 24736 "parser_cocci_menhir.ml" +# 24904 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24754,9 +24922,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_rule_elem_statement = -# 900 "parser_cocci_menhir.mly" +# 905 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),_1)) ) -# 24760 "parser_cocci_menhir.ml" +# 24928 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24780,17 +24948,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 24786 "parser_cocci_menhir.ml" +# 24954 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_expr = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_rule_elem_statement = -# 901 "parser_cocci_menhir.mly" +# 906 "parser_cocci_menhir.mly" ( P.exp_stm _1 _2 ) -# 24794 "parser_cocci_menhir.ml" +# 24962 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24819,22 +24987,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 24825 "parser_cocci_menhir.ml" +# 24993 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_eexpr = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 24831 "parser_cocci_menhir.ml" +# 24999 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_rule_elem_statement = -# 902 "parser_cocci_menhir.mly" +# 907 "parser_cocci_menhir.mly" ( P.ret_exp _1 _2 _3 ) -# 24838 "parser_cocci_menhir.ml" +# 25006 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24858,21 +25026,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 24864 "parser_cocci_menhir.ml" +# 25032 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 24869 "parser_cocci_menhir.ml" +# 25037 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_rule_elem_statement = -# 903 "parser_cocci_menhir.mly" +# 908 "parser_cocci_menhir.mly" ( P.ret _1 _2 ) -# 24876 "parser_cocci_menhir.ml" +# 25044 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24896,21 +25064,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 24902 "parser_cocci_menhir.ml" +# 25070 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 24907 "parser_cocci_menhir.ml" +# 25075 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_rule_elem_statement = -# 904 "parser_cocci_menhir.mly" +# 909 "parser_cocci_menhir.mly" ( P.break _1 _2 ) -# 24914 "parser_cocci_menhir.ml" +# 25082 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24934,21 +25102,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 24940 "parser_cocci_menhir.ml" +# 25108 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 24945 "parser_cocci_menhir.ml" +# 25113 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_rule_elem_statement = -# 905 "parser_cocci_menhir.mly" +# 910 "parser_cocci_menhir.mly" ( P.cont _1 _2 ) -# 24952 "parser_cocci_menhir.ml" +# 25120 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -24977,26 +25145,26 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 24983 "parser_cocci_menhir.ml" +# 25151 "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 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 24989 "parser_cocci_menhir.ml" +# 25157 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_rule_elem_statement = -# 907 "parser_cocci_menhir.mly" +# 912 "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)) ) -# 25000 "parser_cocci_menhir.ml" +# 25168 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25050,20 +25218,20 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : ( -# 152 "parser_cocci_menhir.mly" +# 153 "parser_cocci_menhir.mly" (Ast_cocci.rulename) -# 25056 "parser_cocci_menhir.ml" +# 25224 "parser_cocci_menhir.ml" ) = let nm = # 39 "standard.mly" ( None ) -# 25061 "parser_cocci_menhir.ml" +# 25229 "parser_cocci_menhir.ml" in -# 201 "parser_cocci_menhir.mly" +# 202 "parser_cocci_menhir.mly" ( P.make_cocci_rule_name_result nm d i a e ee ) -# 25067 "parser_cocci_menhir.ml" +# 25235 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25123,21 +25291,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_x0_ in let _endpos = _endpos__8_ in let _v : ( -# 152 "parser_cocci_menhir.mly" +# 153 "parser_cocci_menhir.mly" (Ast_cocci.rulename) -# 25129 "parser_cocci_menhir.ml" +# 25297 "parser_cocci_menhir.ml" ) = let nm = let x = x0 in # 41 "standard.mly" ( Some x ) -# 25135 "parser_cocci_menhir.ml" +# 25303 "parser_cocci_menhir.ml" in -# 201 "parser_cocci_menhir.mly" +# 202 "parser_cocci_menhir.mly" ( P.make_cocci_rule_name_result nm d i a e ee ) -# 25141 "parser_cocci_menhir.ml" +# 25309 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25195,13 +25363,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__8_ in let _v : ( -# 152 "parser_cocci_menhir.mly" +# 153 "parser_cocci_menhir.mly" (Ast_cocci.rulename) -# 25201 "parser_cocci_menhir.ml" +# 25369 "parser_cocci_menhir.ml" ) = -# 206 "parser_cocci_menhir.mly" +# 207 "parser_cocci_menhir.mly" ( P.make_generated_rule_name_result None d i a e ee ) -# 25205 "parser_cocci_menhir.ml" +# 25373 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25241,13 +25409,13 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : ( -# 152 "parser_cocci_menhir.mly" +# 153 "parser_cocci_menhir.mly" (Ast_cocci.rulename) -# 25247 "parser_cocci_menhir.ml" +# 25415 "parser_cocci_menhir.ml" ) = -# 208 "parser_cocci_menhir.mly" +# 209 "parser_cocci_menhir.mly" ( P.make_script_rule_name_result lang d ) -# 25251 "parser_cocci_menhir.ml" +# 25419 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25291,19 +25459,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _3 : ( # 47 "parser_cocci_menhir.mly" (string) -# 25295 "parser_cocci_menhir.ml" +# 25463 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let py : 'tv_pure_ident = Obj.magic py in let _startpos = _startpos_py_ in let _endpos = _endpos__6_ in let _v : ( -# 158 "parser_cocci_menhir.mly" +# 159 "parser_cocci_menhir.mly" (string * (string * string)) -# 25303 "parser_cocci_menhir.ml" +# 25471 "parser_cocci_menhir.ml" ) = -# 1847 "parser_cocci_menhir.mly" +# 1859 "parser_cocci_menhir.mly" ( (P.id2name py, (_3, P.id2name cocci)) ) -# 25307 "parser_cocci_menhir.ml" +# 25475 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25322,16 +25490,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let x : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 25328 "parser_cocci_menhir.ml" +# 25496 "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 ] ) -# 25335 "parser_cocci_menhir.ml" +# 25503 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25360,16 +25528,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let xs : 'tv_separated_nonempty_list_TComma_TString_ = Obj.magic xs in let x : ( -# 86 "parser_cocci_menhir.mly" +# 87 "parser_cocci_menhir.mly" (string * Data.clt) -# 25366 "parser_cocci_menhir.ml" +# 25534 "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 ) -# 25373 "parser_cocci_menhir.ml" +# 25541 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25393,7 +25561,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_any_strict_ = # 144 "standard.mly" ( [ x ] ) -# 25397 "parser_cocci_menhir.ml" +# 25565 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25427,7 +25595,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_any_strict_ = # 146 "standard.mly" ( x :: xs ) -# 25431 "parser_cocci_menhir.ml" +# 25599 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25451,7 +25619,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_ctype_ = # 144 "standard.mly" ( [ x ] ) -# 25455 "parser_cocci_menhir.ml" +# 25623 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25485,7 +25653,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_ctype_ = # 146 "standard.mly" ( x :: xs ) -# 25489 "parser_cocci_menhir.ml" +# 25657 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25509,7 +25677,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_d_ident_ = # 144 "standard.mly" ( [ x ] ) -# 25513 "parser_cocci_menhir.ml" +# 25681 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25543,7 +25711,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_d_ident_ = # 146 "standard.mly" ( x :: xs ) -# 25547 "parser_cocci_menhir.ml" +# 25715 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25567,7 +25735,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_dexpr_ = # 144 "standard.mly" ( [ x ] ) -# 25571 "parser_cocci_menhir.ml" +# 25739 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25601,7 +25769,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_dexpr_ = # 146 "standard.mly" ( x :: xs ) -# 25605 "parser_cocci_menhir.ml" +# 25773 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25625,7 +25793,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_ident_or_const_ = # 144 "standard.mly" ( [ x ] ) -# 25629 "parser_cocci_menhir.ml" +# 25797 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25659,7 +25827,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_ident_or_const_ = # 146 "standard.mly" ( x :: xs ) -# 25663 "parser_cocci_menhir.ml" +# 25831 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25683,7 +25851,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_meta_ident_ = # 144 "standard.mly" ( [ x ] ) -# 25687 "parser_cocci_menhir.ml" +# 25855 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25717,7 +25885,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_meta_ident_ = # 146 "standard.mly" ( x :: xs ) -# 25721 "parser_cocci_menhir.ml" +# 25889 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25741,7 +25909,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_ = # 144 "standard.mly" ( [ x ] ) -# 25745 "parser_cocci_menhir.ml" +# 25913 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25775,7 +25943,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_ = # 146 "standard.mly" ( x :: xs ) -# 25779 "parser_cocci_menhir.ml" +# 25947 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25799,7 +25967,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_ = # 144 "standard.mly" ( [ x ] ) -# 25803 "parser_cocci_menhir.ml" +# 25971 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25833,7 +26001,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_ = # 146 "standard.mly" ( x :: xs ) -# 25837 "parser_cocci_menhir.ml" +# 26005 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25857,7 +26025,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_ceq__ = # 144 "standard.mly" ( [ x ] ) -# 25861 "parser_cocci_menhir.ml" +# 26029 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25891,7 +26059,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_ceq__ = # 146 "standard.mly" ( x :: xs ) -# 25895 "parser_cocci_menhir.ml" +# 26063 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25915,7 +26083,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_eq__ = # 144 "standard.mly" ( [ x ] ) -# 25919 "parser_cocci_menhir.ml" +# 26087 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25949,7 +26117,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_eq__ = # 146 "standard.mly" ( x :: xs ) -# 25953 "parser_cocci_menhir.ml" +# 26121 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -25973,7 +26141,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_eqe__ = # 144 "standard.mly" ( [ x ] ) -# 25977 "parser_cocci_menhir.ml" +# 26145 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26007,7 +26175,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_eqe__ = # 146 "standard.mly" ( x :: xs ) -# 26011 "parser_cocci_menhir.ml" +# 26179 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26031,7 +26199,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_pos__ = # 144 "standard.mly" ( [ x ] ) -# 26035 "parser_cocci_menhir.ml" +# 26203 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26065,7 +26233,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_not_eq_not_pos__ = # 146 "standard.mly" ( x :: xs ) -# 26069 "parser_cocci_menhir.ml" +# 26237 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26087,9 +26255,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_single_statement = -# 915 "parser_cocci_menhir.mly" +# 920 "parser_cocci_menhir.mly" ( _1 ) -# 26093 "parser_cocci_menhir.ml" +# 26261 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26118,26 +26286,26 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26124 "parser_cocci_menhir.ml" +# 26292 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_midzero_list_statement_statement_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26130 "parser_cocci_menhir.ml" +# 26298 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_single_statement = -# 919 "parser_cocci_menhir.mly" +# 924 "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)) ) -# 26141 "parser_cocci_menhir.ml" +# 26309 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26159,9 +26327,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_statement = -# 842 "parser_cocci_menhir.mly" +# 847 "parser_cocci_menhir.mly" ( _1 ) -# 26165 "parser_cocci_menhir.ml" +# 26333 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26182,14 +26350,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 26186 "parser_cocci_menhir.ml" +# 26354 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_statement = -# 844 "parser_cocci_menhir.mly" +# 849 "parser_cocci_menhir.mly" ( P.meta_stm _1 ) -# 26193 "parser_cocci_menhir.ml" +# 26361 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26213,17 +26381,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26219 "parser_cocci_menhir.ml" +# 26387 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_expr = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_statement = -# 846 "parser_cocci_menhir.mly" +# 851 "parser_cocci_menhir.mly" ( P.exp_stm _1 _2 ) -# 26227 "parser_cocci_menhir.ml" +# 26395 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26263,27 +26431,27 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _5 : 'tv_single_statement = Obj.magic _5 in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26269 "parser_cocci_menhir.ml" +# 26437 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26275 "parser_cocci_menhir.ml" +# 26443 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26280 "parser_cocci_menhir.ml" +# 26448 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : 'tv_statement = -# 848 "parser_cocci_menhir.mly" +# 853 "parser_cocci_menhir.mly" ( P.ifthen _1 _2 _3 _4 _5 ) -# 26287 "parser_cocci_menhir.ml" +# 26455 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26335,31 +26503,31 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _6 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26339 "parser_cocci_menhir.ml" +# 26507 "parser_cocci_menhir.ml" ) = Obj.magic _6 in let _5 : 'tv_single_statement = Obj.magic _5 in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26345 "parser_cocci_menhir.ml" +# 26513 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26351 "parser_cocci_menhir.ml" +# 26519 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26356 "parser_cocci_menhir.ml" +# 26524 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : 'tv_statement = -# 850 "parser_cocci_menhir.mly" +# 855 "parser_cocci_menhir.mly" ( P.ifthenelse _1 _2 _3 _4 _5 _6 _7 ) -# 26363 "parser_cocci_menhir.ml" +# 26531 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26419,39 +26587,39 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _9 : 'tv_single_statement = Obj.magic _9 in let _8 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26425 "parser_cocci_menhir.ml" +# 26593 "parser_cocci_menhir.ml" ) = Obj.magic _8 in let _7 : 'tv_option_eexpr_ = Obj.magic _7 in let _6 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26431 "parser_cocci_menhir.ml" +# 26599 "parser_cocci_menhir.ml" ) = Obj.magic _6 in let _5 : 'tv_option_eexpr_ = Obj.magic _5 in let _4 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26437 "parser_cocci_menhir.ml" +# 26605 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_option_eexpr_ = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26443 "parser_cocci_menhir.ml" +# 26611 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26448 "parser_cocci_menhir.ml" +# 26616 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__9_ in let _v : 'tv_statement = -# 853 "parser_cocci_menhir.mly" +# 858 "parser_cocci_menhir.mly" ( P.forloop _1 _2 _3 _4 _5 _6 _7 _8 _9 ) -# 26455 "parser_cocci_menhir.ml" +# 26623 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26491,27 +26659,27 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _5 : 'tv_single_statement = Obj.magic _5 in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26497 "parser_cocci_menhir.ml" +# 26665 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26503 "parser_cocci_menhir.ml" +# 26671 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26508 "parser_cocci_menhir.ml" +# 26676 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__5_ in let _v : 'tv_statement = -# 855 "parser_cocci_menhir.mly" +# 860 "parser_cocci_menhir.mly" ( P.whileloop _1 _2 _3 _4 _5 ) -# 26515 "parser_cocci_menhir.ml" +# 26683 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26560,38 +26728,38 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _7 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26566 "parser_cocci_menhir.ml" +# 26734 "parser_cocci_menhir.ml" ) = Obj.magic _7 in let _6 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26571 "parser_cocci_menhir.ml" +# 26739 "parser_cocci_menhir.ml" ) = Obj.magic _6 in let _5 : 'tv_eexpr = Obj.magic _5 in let _4 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26577 "parser_cocci_menhir.ml" +# 26745 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26582 "parser_cocci_menhir.ml" +# 26750 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_single_statement = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26588 "parser_cocci_menhir.ml" +# 26756 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : 'tv_statement = -# 857 "parser_cocci_menhir.mly" +# 862 "parser_cocci_menhir.mly" ( P.doloop _1 _2 _3 _4 _5 _6 _7 ) -# 26595 "parser_cocci_menhir.ml" +# 26763 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26631,23 +26799,23 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _5 : 'tv_single_statement = Obj.magic _5 in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26637 "parser_cocci_menhir.ml" +# 26805 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr_list_option = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26643 "parser_cocci_menhir.ml" +# 26811 "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 = -# 859 "parser_cocci_menhir.mly" +# 864 "parser_cocci_menhir.mly" ( P.iterator _1 _2 _3 _4 _5 ) -# 26651 "parser_cocci_menhir.ml" +# 26819 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26696,38 +26864,38 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _7 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 26702 "parser_cocci_menhir.ml" +# 26870 "parser_cocci_menhir.ml" ) = Obj.magic _7 in let _6 : 'tv_list_case_line_ = Obj.magic _6 in let _5 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 26708 "parser_cocci_menhir.ml" +# 26876 "parser_cocci_menhir.ml" ) = Obj.magic _5 in let _4 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 26713 "parser_cocci_menhir.ml" +# 26881 "parser_cocci_menhir.ml" ) = Obj.magic _4 in let _3 : 'tv_eexpr = Obj.magic _3 in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26719 "parser_cocci_menhir.ml" +# 26887 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26724 "parser_cocci_menhir.ml" +# 26892 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__7_ in let _v : 'tv_statement = -# 861 "parser_cocci_menhir.mly" +# 866 "parser_cocci_menhir.mly" ( P.switch _1 _2 _3 _4 _5 _6 _7 ) -# 26731 "parser_cocci_menhir.ml" +# 26899 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26756,22 +26924,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26762 "parser_cocci_menhir.ml" +# 26930 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_eexpr = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26768 "parser_cocci_menhir.ml" +# 26936 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_statement = -# 862 "parser_cocci_menhir.mly" +# 867 "parser_cocci_menhir.mly" ( P.ret_exp _1 _2 _3 ) -# 26775 "parser_cocci_menhir.ml" +# 26943 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26795,21 +26963,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26801 "parser_cocci_menhir.ml" +# 26969 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 57 "parser_cocci_menhir.mly" (Data.clt) -# 26806 "parser_cocci_menhir.ml" +# 26974 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_statement = -# 863 "parser_cocci_menhir.mly" +# 868 "parser_cocci_menhir.mly" ( P.ret _1 _2 ) -# 26813 "parser_cocci_menhir.ml" +# 26981 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26833,21 +27001,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26839 "parser_cocci_menhir.ml" +# 27007 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 26844 "parser_cocci_menhir.ml" +# 27012 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_statement = -# 864 "parser_cocci_menhir.mly" +# 869 "parser_cocci_menhir.mly" ( P.break _1 _2 ) -# 26851 "parser_cocci_menhir.ml" +# 27019 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26871,21 +27039,21 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26877 "parser_cocci_menhir.ml" +# 27045 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 26882 "parser_cocci_menhir.ml" +# 27050 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_statement = -# 865 "parser_cocci_menhir.mly" +# 870 "parser_cocci_menhir.mly" ( P.cont _1 _2 ) -# 26889 "parser_cocci_menhir.ml" +# 27057 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26909,17 +27077,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 26915 "parser_cocci_menhir.ml" +# 27083 "parser_cocci_menhir.ml" ) = Obj.magic _2 in let _1 : 'tv_ident = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_statement = -# 866 "parser_cocci_menhir.mly" +# 871 "parser_cocci_menhir.mly" ( P.label _1 _2 ) -# 26923 "parser_cocci_menhir.ml" +# 27091 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26948,22 +27116,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 26954 "parser_cocci_menhir.ml" +# 27122 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_ident = Obj.magic _2 in let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 26960 "parser_cocci_menhir.ml" +# 27128 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_statement = -# 867 "parser_cocci_menhir.mly" +# 872 "parser_cocci_menhir.mly" ( P.goto _1 _2 _3 ) -# 26967 "parser_cocci_menhir.ml" +# 27135 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -26992,22 +27160,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 26998 "parser_cocci_menhir.ml" +# 27166 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_fun_start = Obj.magic _2 in let _1 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 27004 "parser_cocci_menhir.ml" +# 27172 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_statement = -# 869 "parser_cocci_menhir.mly" +# 874 "parser_cocci_menhir.mly" ( P.seq _1 _2 _3 ) -# 27011 "parser_cocci_menhir.ml" +# 27179 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27032,16 +27200,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let w : 'tv_list_whenppdecs_ = Obj.magic w in let _1 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 27038 "parser_cocci_menhir.ml" +# 27206 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos_w_ in let _v : 'tv_stm_dots = -# 873 "parser_cocci_menhir.mly" +# 878 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Dots(P.clt2mcode "..." _1, List.concat w)) ) -# 27045 "parser_cocci_menhir.ml" +# 27213 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27075,24 +27243,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let c : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 27081 "parser_cocci_menhir.ml" +# 27249 "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 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 27088 "parser_cocci_menhir.ml" +# 27256 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos_c_ in let _v : 'tv_stm_dots = -# 875 "parser_cocci_menhir.mly" +# 880 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." _1, b, P.clt2mcode "...>" c, List.concat w, false)) ) -# 27096 "parser_cocci_menhir.ml" +# 27264 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27126,24 +27294,24 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let c : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 27132 "parser_cocci_menhir.ml" +# 27300 "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 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 27139 "parser_cocci_menhir.ml" +# 27307 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos_c_ in let _v : 'tv_stm_dots = -# 878 "parser_cocci_menhir.mly" +# 883 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." _1, b, P.clt2mcode "...+>" c, List.concat w, true)) ) -# 27147 "parser_cocci_menhir.ml" +# 27315 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27164,14 +27332,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s : ( # 53 "parser_cocci_menhir.mly" (Data.clt) -# 27168 "parser_cocci_menhir.ml" +# 27336 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_s_ in let _v : 'tv_storage = -# 800 "parser_cocci_menhir.mly" +# 805 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Static s ) -# 27175 "parser_cocci_menhir.ml" +# 27343 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27192,14 +27360,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s : ( # 53 "parser_cocci_menhir.mly" (Data.clt) -# 27196 "parser_cocci_menhir.ml" +# 27364 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_s_ in let _v : 'tv_storage = -# 801 "parser_cocci_menhir.mly" +# 806 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Auto s ) -# 27203 "parser_cocci_menhir.ml" +# 27371 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27220,14 +27388,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s : ( # 53 "parser_cocci_menhir.mly" (Data.clt) -# 27224 "parser_cocci_menhir.ml" +# 27392 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_s_ in let _v : 'tv_storage = -# 802 "parser_cocci_menhir.mly" +# 807 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Register s ) -# 27231 "parser_cocci_menhir.ml" +# 27399 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27248,14 +27416,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s : ( # 53 "parser_cocci_menhir.mly" (Data.clt) -# 27252 "parser_cocci_menhir.ml" +# 27420 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_s_ in let _v : 'tv_storage = -# 803 "parser_cocci_menhir.mly" +# 808 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Extern s ) -# 27259 "parser_cocci_menhir.ml" +# 27427 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27275,9 +27443,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_struct_decl = -# 507 "parser_cocci_menhir.mly" +# 512 "parser_cocci_menhir.mly" ( [] ) -# 27281 "parser_cocci_menhir.ml" +# 27449 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27306,19 +27474,19 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 27312 "parser_cocci_menhir.ml" +# 27480 "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 = -# 509 "parser_cocci_menhir.mly" +# 514 "parser_cocci_menhir.mly" ( let (id,fn) = d in [Ast0.wrap(Ast0.UnInit(None,fn t,id,P.clt2mcode ";" pv))] ) -# 27322 "parser_cocci_menhir.ml" +# 27490 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27377,42 +27545,42 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 27383 "parser_cocci_menhir.ml" +# 27551 "parser_cocci_menhir.ml" ) = Obj.magic pv in let rp2 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 27388 "parser_cocci_menhir.ml" +# 27556 "parser_cocci_menhir.ml" ) = Obj.magic rp2 in let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in let lp2 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 27394 "parser_cocci_menhir.ml" +# 27562 "parser_cocci_menhir.ml" ) = Obj.magic lp2 in let rp1 : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 27399 "parser_cocci_menhir.ml" +# 27567 "parser_cocci_menhir.ml" ) = Obj.magic rp1 in let d : 'tv_d_ident = Obj.magic d in let st : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 27405 "parser_cocci_menhir.ml" +# 27573 "parser_cocci_menhir.ml" ) = Obj.magic st in let lp1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 27410 "parser_cocci_menhir.ml" +# 27578 "parser_cocci_menhir.ml" ) = Obj.magic lp1 in let t : 'tv_fn_ctype = Obj.magic t in let _startpos = _startpos_t_ in let _endpos = _endpos_pv_ in let _v : 'tv_struct_decl = -# 513 "parser_cocci_menhir.mly" +# 518 "parser_cocci_menhir.mly" ( let (id,fn) = d in let t = Ast0.wrap @@ -27420,7 +27588,7 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct (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))] ) -# 27424 "parser_cocci_menhir.ml" +# 27592 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27449,9 +27617,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 27455 "parser_cocci_menhir.ml" +# 27623 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -27461,15 +27629,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 39 "standard.mly" ( None ) -# 27465 "parser_cocci_menhir.ml" +# 27633 "parser_cocci_menhir.ml" in -# 521 "parser_cocci_menhir.mly" +# 526 "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))] ) -# 27473 "parser_cocci_menhir.ml" +# 27641 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27503,9 +27671,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let pv : ( -# 106 "parser_cocci_menhir.mly" +# 107 "parser_cocci_menhir.mly" (Data.clt) -# 27509 "parser_cocci_menhir.ml" +# 27677 "parser_cocci_menhir.ml" ) = Obj.magic pv in let d : 'tv_d_ident = Obj.magic d in let i : 'tv_pure_ident = Obj.magic i in @@ -27517,15 +27685,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct # 41 "standard.mly" ( Some x ) -# 27521 "parser_cocci_menhir.ml" +# 27689 "parser_cocci_menhir.ml" in -# 521 "parser_cocci_menhir.mly" +# 526 "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))] ) -# 27529 "parser_cocci_menhir.ml" +# 27697 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27547,9 +27715,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_struct_decl_list = -# 526 "parser_cocci_menhir.mly" +# 531 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS(_1)) ) -# 27553 "parser_cocci_menhir.ml" +# 27721 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27571,9 +27739,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_struct_decl_list_start = -# 529 "parser_cocci_menhir.mly" +# 534 "parser_cocci_menhir.mly" ( _1 ) -# 27577 "parser_cocci_menhir.ml" +# 27745 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27601,9 +27769,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_struct_decl_list_start = -# 530 "parser_cocci_menhir.mly" +# 535 "parser_cocci_menhir.mly" ( _1@_2 ) -# 27607 "parser_cocci_menhir.ml" +# 27775 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27631,9 +27799,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_d_ in let _endpos = _endpos_r_ in let _v : 'tv_struct_decl_list_start = -# 532 "parser_cocci_menhir.mly" +# 537 "parser_cocci_menhir.mly" ( (P.mkddots "..." d)::r ) -# 27637 "parser_cocci_menhir.ml" +# 27805 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27654,14 +27822,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let s : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 27658 "parser_cocci_menhir.ml" +# 27826 "parser_cocci_menhir.ml" ) = Obj.magic s in let _startpos = _startpos_s_ in let _endpos = _endpos_s_ in let _v : 'tv_struct_or_union = -# 503 "parser_cocci_menhir.mly" +# 508 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Struct s ) -# 27665 "parser_cocci_menhir.ml" +# 27833 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27682,14 +27850,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let u : ( # 50 "parser_cocci_menhir.mly" (Data.clt) -# 27686 "parser_cocci_menhir.ml" +# 27854 "parser_cocci_menhir.ml" ) = Obj.magic u in let _startpos = _startpos_u_ in let _endpos = _endpos_u_ in let _v : 'tv_struct_or_union = -# 504 "parser_cocci_menhir.mly" +# 509 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Union u ) -# 27693 "parser_cocci_menhir.ml" +# 27861 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27711,9 +27879,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_top_eexpr = -# 1188 "parser_cocci_menhir.mly" +# 1199 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp(_1)))) ) -# 27717 "parser_cocci_menhir.ml" +# 27885 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27742,22 +27910,22 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let _3 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 27748 "parser_cocci_menhir.ml" +# 27916 "parser_cocci_menhir.ml" ) = Obj.magic _3 in let _2 : 'tv_initialize_list = Obj.magic _2 in let _1 : ( -# 100 "parser_cocci_menhir.mly" +# 101 "parser_cocci_menhir.mly" (Data.clt) -# 27754 "parser_cocci_menhir.ml" +# 27922 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_top_init = -# 1625 "parser_cocci_menhir.mly" +# 1637 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.InitList(P.clt2mcode "{" _1,_2,P.clt2mcode "}" _3)) ) -# 27761 "parser_cocci_menhir.ml" +# 27929 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27772,9 +27940,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_toplevel_after_dots = -# 1613 "parser_cocci_menhir.mly" +# 1625 "parser_cocci_menhir.mly" ([]) -# 27778 "parser_cocci_menhir.ml" +# 27946 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27800,9 +27968,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_dots = -# 1614 "parser_cocci_menhir.mly" +# 1626 "parser_cocci_menhir.mly" (_2) -# 27806 "parser_cocci_menhir.ml" +# 27974 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27830,9 +27998,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_dots = -# 1615 "parser_cocci_menhir.mly" +# 1627 "parser_cocci_menhir.mly" ((Ast0.wrap(Ast0.Exp(_1)))::_2) -# 27836 "parser_cocci_menhir.ml" +# 28004 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27860,9 +28028,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_dots = -# 1616 "parser_cocci_menhir.mly" +# 1628 "parser_cocci_menhir.mly" (_1@_2) -# 27866 "parser_cocci_menhir.ml" +# 28034 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27888,9 +28056,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_dots_init = -# 1604 "parser_cocci_menhir.mly" +# 1616 "parser_cocci_menhir.mly" (_2) -# 27894 "parser_cocci_menhir.ml" +# 28062 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27918,9 +28086,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_dots_init = -# 1605 "parser_cocci_menhir.mly" +# 1617 "parser_cocci_menhir.mly" ((Ast0.wrap(Ast0.Exp(_1)))::_2) -# 27924 "parser_cocci_menhir.ml" +# 28092 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27948,9 +28116,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_dots_init = -# 1606 "parser_cocci_menhir.mly" +# 1618 "parser_cocci_menhir.mly" (_1@_2) -# 27954 "parser_cocci_menhir.ml" +# 28122 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27965,9 +28133,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_toplevel_after_exp = -# 1609 "parser_cocci_menhir.mly" +# 1621 "parser_cocci_menhir.mly" ([]) -# 27971 "parser_cocci_menhir.ml" +# 28139 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -27995,9 +28163,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_exp = -# 1610 "parser_cocci_menhir.mly" +# 1622 "parser_cocci_menhir.mly" (_1::_2) -# 28001 "parser_cocci_menhir.ml" +# 28169 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28012,9 +28180,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in let _endpos = _startpos in let _v : 'tv_toplevel_after_stm = -# 1619 "parser_cocci_menhir.mly" +# 1631 "parser_cocci_menhir.mly" ([]) -# 28018 "parser_cocci_menhir.ml" +# 28186 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28042,9 +28210,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_stm = -# 1620 "parser_cocci_menhir.mly" +# 1632 "parser_cocci_menhir.mly" (_1::_2) -# 28048 "parser_cocci_menhir.ml" +# 28216 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28072,9 +28240,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_after_stm = -# 1621 "parser_cocci_menhir.mly" +# 1633 "parser_cocci_menhir.mly" (_1@_2) -# 28078 "parser_cocci_menhir.ml" +# 28246 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28102,9 +28270,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_seq_start_toplevel_after_dots_ = -# 1599 "parser_cocci_menhir.mly" +# 1611 "parser_cocci_menhir.mly" ( _1::_2 ) -# 28108 "parser_cocci_menhir.ml" +# 28276 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28132,9 +28300,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_seq_start_toplevel_after_dots_ = -# 1600 "parser_cocci_menhir.mly" +# 1612 "parser_cocci_menhir.mly" ( (Ast0.wrap(Ast0.Exp(_1)))::_2 ) -# 28138 "parser_cocci_menhir.ml" +# 28306 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28162,9 +28330,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_seq_start_toplevel_after_dots_ = -# 1601 "parser_cocci_menhir.mly" +# 1613 "parser_cocci_menhir.mly" ( _1@_2 ) -# 28168 "parser_cocci_menhir.ml" +# 28336 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28195,9 +28363,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let b : 'tv_toplevel_after_dots_init = Obj.magic b in let w0 : 'tv_list_whenppdecs_ = Obj.magic w0 in let a0 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28201 "parser_cocci_menhir.ml" +# 28369 "parser_cocci_menhir.ml" ) = Obj.magic a0 in let _startpos = _startpos_a0_ in let _endpos = _endpos_b_ in @@ -28205,15 +28373,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let w = w0 in let a = a0 in -# 883 "parser_cocci_menhir.mly" +# 888 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Dots(P.clt2mcode "..." a, List.concat w)) ) -# 28211 "parser_cocci_menhir.ml" +# 28379 "parser_cocci_menhir.ml" in -# 1592 "parser_cocci_menhir.mly" +# 1604 "parser_cocci_menhir.mly" ( a::b ) -# 28217 "parser_cocci_menhir.ml" +# 28385 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28253,16 +28421,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_toplevel_after_dots_init = Obj.magic b in let c0 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28259 "parser_cocci_menhir.ml" +# 28427 "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 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28266 "parser_cocci_menhir.ml" +# 28434 "parser_cocci_menhir.ml" ) = Obj.magic a0 in let _startpos = _startpos_a0_ in let _endpos = _endpos_b_ in @@ -28272,16 +28440,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let w = w0 in let a = a0 in -# 887 "parser_cocci_menhir.mly" +# 892 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." a, b, P.clt2mcode "...>" c, List.concat w, false)) ) -# 28279 "parser_cocci_menhir.ml" +# 28447 "parser_cocci_menhir.ml" in -# 1593 "parser_cocci_menhir.mly" +# 1605 "parser_cocci_menhir.mly" ( a::b ) -# 28285 "parser_cocci_menhir.ml" +# 28453 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28321,16 +28489,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let b : 'tv_toplevel_after_dots_init = Obj.magic b in let c0 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28327 "parser_cocci_menhir.ml" +# 28495 "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 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28334 "parser_cocci_menhir.ml" +# 28502 "parser_cocci_menhir.ml" ) = Obj.magic a0 in let _startpos = _startpos_a0_ in let _endpos = _endpos_b_ in @@ -28340,16 +28508,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let w = w0 in let a = a0 in -# 890 "parser_cocci_menhir.mly" +# 895 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." a, b, P.clt2mcode "...+>" c, List.concat w, true)) ) -# 28347 "parser_cocci_menhir.ml" +# 28515 "parser_cocci_menhir.ml" in -# 1593 "parser_cocci_menhir.mly" +# 1605 "parser_cocci_menhir.mly" ( a::b ) -# 28353 "parser_cocci_menhir.ml" +# 28521 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28383,16 +28551,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let c0 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28389 "parser_cocci_menhir.ml" +# 28557 "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 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28396 "parser_cocci_menhir.ml" +# 28564 "parser_cocci_menhir.ml" ) = Obj.magic a0 in let _startpos = _startpos_a0_ in let _endpos = _endpos_c0_ in @@ -28402,16 +28570,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let w = w0 in let a = a0 in -# 887 "parser_cocci_menhir.mly" +# 892 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." a, b, P.clt2mcode "...>" c, List.concat w, false)) ) -# 28409 "parser_cocci_menhir.ml" +# 28577 "parser_cocci_menhir.ml" in -# 1594 "parser_cocci_menhir.mly" +# 1606 "parser_cocci_menhir.mly" ( [a] ) -# 28415 "parser_cocci_menhir.ml" +# 28583 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28445,16 +28613,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let c0 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28451 "parser_cocci_menhir.ml" +# 28619 "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 : ( -# 72 "parser_cocci_menhir.mly" +# 73 "parser_cocci_menhir.mly" (Data.clt) -# 28458 "parser_cocci_menhir.ml" +# 28626 "parser_cocci_menhir.ml" ) = Obj.magic a0 in let _startpos = _startpos_a0_ in let _endpos = _endpos_c0_ in @@ -28464,16 +28632,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let w = w0 in let a = a0 in -# 890 "parser_cocci_menhir.mly" +# 895 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." a, b, P.clt2mcode "...+>" c, List.concat w, true)) ) -# 28471 "parser_cocci_menhir.ml" +# 28639 "parser_cocci_menhir.ml" in -# 1594 "parser_cocci_menhir.mly" +# 1606 "parser_cocci_menhir.mly" ( [a] ) -# 28477 "parser_cocci_menhir.ml" +# 28645 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28501,9 +28669,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_seq_startne_toplevel_after_dots_init_ = -# 1595 "parser_cocci_menhir.mly" +# 1607 "parser_cocci_menhir.mly" ( (Ast0.wrap(Ast0.Exp(_1)))::_2 ) -# 28507 "parser_cocci_menhir.ml" +# 28675 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28531,9 +28699,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_toplevel_seq_startne_toplevel_after_dots_init_ = -# 1596 "parser_cocci_menhir.mly" +# 1608 "parser_cocci_menhir.mly" ( _1@_2 ) -# 28537 "parser_cocci_menhir.ml" +# 28705 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28555,9 +28723,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_typedef_ident = -# 1505 "parser_cocci_menhir.mly" +# 1516 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.TypeName(P.id2mcode _1)) ) -# 28561 "parser_cocci_menhir.ml" +# 28729 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28578,15 +28746,15 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 64 "parser_cocci_menhir.mly" (Parse_aux.info) -# 28582 "parser_cocci_menhir.ml" +# 28750 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_typedef_ident = -# 1507 "parser_cocci_menhir.mly" +# 1518 "parser_cocci_menhir.mly" ( let (nm,pure,clt) = _1 in Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure)) ) -# 28590 "parser_cocci_menhir.ml" +# 28758 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28608,9 +28776,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_expr_eexpr_dot_expressions_ = -# 1277 "parser_cocci_menhir.mly" +# 1288 "parser_cocci_menhir.mly" ( _1 ) -# 28614 "parser_cocci_menhir.ml" +# 28782 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28635,16 +28803,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_dot_expressions_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 28641 "parser_cocci_menhir.ml" +# 28809 "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_ = -# 1279 "parser_cocci_menhir.mly" +# 1290 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) ) -# 28648 "parser_cocci_menhir.ml" +# 28816 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28669,16 +28837,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_dot_expressions_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 28675 "parser_cocci_menhir.ml" +# 28843 "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_ = -# 1281 "parser_cocci_menhir.mly" +# 1292 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) ) -# 28682 "parser_cocci_menhir.ml" +# 28850 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28706,9 +28874,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_unary_expr_eexpr_dot_expressions_ = -# 1283 "parser_cocci_menhir.mly" +# 1294 "parser_cocci_menhir.mly" ( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 28712 "parser_cocci_menhir.ml" +# 28880 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28733,17 +28901,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_dot_expressions_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 28739 "parser_cocci_menhir.ml" +# 28907 "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_ = -# 1285 "parser_cocci_menhir.mly" +# 1296 "parser_cocci_menhir.mly" ( let mcode = P.clt2mcode Ast.Not _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 28747 "parser_cocci_menhir.ml" +# 28915 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28770,14 +28938,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 28774 "parser_cocci_menhir.ml" +# 28942 "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_ = -# 1288 "parser_cocci_menhir.mly" +# 1299 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) ) -# 28781 "parser_cocci_menhir.ml" +# 28949 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28811,29 +28979,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 28817 "parser_cocci_menhir.ml" +# 28985 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 28823 "parser_cocci_menhir.ml" +# 28991 "parser_cocci_menhir.ml" ) = Obj.magic lp in let s : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 28828 "parser_cocci_menhir.ml" +# 28996 "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_ = -# 1290 "parser_cocci_menhir.mly" +# 1301 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s, P.clt2mcode "(" lp,t, P.clt2mcode ")" rp)) ) -# 28837 "parser_cocci_menhir.ml" +# 29005 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28855,9 +29023,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_expr_eexpr_invalid_ = -# 1277 "parser_cocci_menhir.mly" +# 1288 "parser_cocci_menhir.mly" ( _1 ) -# 28861 "parser_cocci_menhir.ml" +# 29029 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28882,16 +29050,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_invalid_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 28888 "parser_cocci_menhir.ml" +# 29056 "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_ = -# 1279 "parser_cocci_menhir.mly" +# 1290 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) ) -# 28895 "parser_cocci_menhir.ml" +# 29063 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28916,16 +29084,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_invalid_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 28922 "parser_cocci_menhir.ml" +# 29090 "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_ = -# 1281 "parser_cocci_menhir.mly" +# 1292 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) ) -# 28929 "parser_cocci_menhir.ml" +# 29097 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28953,9 +29121,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_unary_expr_eexpr_invalid_ = -# 1283 "parser_cocci_menhir.mly" +# 1294 "parser_cocci_menhir.mly" ( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 28959 "parser_cocci_menhir.ml" +# 29127 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -28980,17 +29148,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_invalid_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 28986 "parser_cocci_menhir.ml" +# 29154 "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_ = -# 1285 "parser_cocci_menhir.mly" +# 1296 "parser_cocci_menhir.mly" ( let mcode = P.clt2mcode Ast.Not _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 28994 "parser_cocci_menhir.ml" +# 29162 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29017,14 +29185,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 29021 "parser_cocci_menhir.ml" +# 29189 "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_ = -# 1288 "parser_cocci_menhir.mly" +# 1299 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) ) -# 29028 "parser_cocci_menhir.ml" +# 29196 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29058,29 +29226,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 29064 "parser_cocci_menhir.ml" +# 29232 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 29070 "parser_cocci_menhir.ml" +# 29238 "parser_cocci_menhir.ml" ) = Obj.magic lp in let s : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 29075 "parser_cocci_menhir.ml" +# 29243 "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_ = -# 1290 "parser_cocci_menhir.mly" +# 1301 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s, P.clt2mcode "(" lp,t, P.clt2mcode ")" rp)) ) -# 29084 "parser_cocci_menhir.ml" +# 29252 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29102,9 +29270,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_expr_eexpr_nest_expressions_ = -# 1277 "parser_cocci_menhir.mly" +# 1288 "parser_cocci_menhir.mly" ( _1 ) -# 29108 "parser_cocci_menhir.ml" +# 29276 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29129,16 +29297,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_nest_expressions_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 29135 "parser_cocci_menhir.ml" +# 29303 "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_ = -# 1279 "parser_cocci_menhir.mly" +# 1290 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) ) -# 29142 "parser_cocci_menhir.ml" +# 29310 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29163,16 +29331,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_nest_expressions_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 29169 "parser_cocci_menhir.ml" +# 29337 "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_ = -# 1281 "parser_cocci_menhir.mly" +# 1292 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) ) -# 29176 "parser_cocci_menhir.ml" +# 29344 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29200,9 +29368,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_unary_expr_eexpr_nest_expressions_ = -# 1283 "parser_cocci_menhir.mly" +# 1294 "parser_cocci_menhir.mly" ( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 29206 "parser_cocci_menhir.ml" +# 29374 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29227,17 +29395,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_eexpr_nest_expressions_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 29233 "parser_cocci_menhir.ml" +# 29401 "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_ = -# 1285 "parser_cocci_menhir.mly" +# 1296 "parser_cocci_menhir.mly" ( let mcode = P.clt2mcode Ast.Not _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 29241 "parser_cocci_menhir.ml" +# 29409 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29264,14 +29432,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 29268 "parser_cocci_menhir.ml" +# 29436 "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_ = -# 1288 "parser_cocci_menhir.mly" +# 1299 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) ) -# 29275 "parser_cocci_menhir.ml" +# 29443 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29305,29 +29473,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 29311 "parser_cocci_menhir.ml" +# 29479 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 29317 "parser_cocci_menhir.ml" +# 29485 "parser_cocci_menhir.ml" ) = Obj.magic lp in let s : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 29322 "parser_cocci_menhir.ml" +# 29490 "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_ = -# 1290 "parser_cocci_menhir.mly" +# 1301 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s, P.clt2mcode "(" lp,t, P.clt2mcode ")" rp)) ) -# 29331 "parser_cocci_menhir.ml" +# 29499 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29349,9 +29517,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_expr_expr_invalid_ = -# 1277 "parser_cocci_menhir.mly" +# 1288 "parser_cocci_menhir.mly" ( _1 ) -# 29355 "parser_cocci_menhir.ml" +# 29523 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29376,16 +29544,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_expr_invalid_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 29382 "parser_cocci_menhir.ml" +# 29550 "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_ = -# 1279 "parser_cocci_menhir.mly" +# 1290 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) ) -# 29389 "parser_cocci_menhir.ml" +# 29557 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29410,16 +29578,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_expr_invalid_ = Obj.magic _2 in let _1 : ( -# 84 "parser_cocci_menhir.mly" +# 85 "parser_cocci_menhir.mly" (Data.clt) -# 29416 "parser_cocci_menhir.ml" +# 29584 "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_ = -# 1281 "parser_cocci_menhir.mly" +# 1292 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) ) -# 29423 "parser_cocci_menhir.ml" +# 29591 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29447,9 +29615,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_unary_expr_expr_invalid_ = -# 1283 "parser_cocci_menhir.mly" +# 1294 "parser_cocci_menhir.mly" ( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 29453 "parser_cocci_menhir.ml" +# 29621 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29474,17 +29642,17 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct } = _menhir_stack in let _2 : 'tv_unary_expr_expr_invalid_ = Obj.magic _2 in let _1 : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 29480 "parser_cocci_menhir.ml" +# 29648 "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_ = -# 1285 "parser_cocci_menhir.mly" +# 1296 "parser_cocci_menhir.mly" ( let mcode = P.clt2mcode Ast.Not _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) ) -# 29488 "parser_cocci_menhir.ml" +# 29656 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29511,14 +29679,14 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _1 : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 29515 "parser_cocci_menhir.ml" +# 29683 "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_ = -# 1288 "parser_cocci_menhir.mly" +# 1299 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) ) -# 29522 "parser_cocci_menhir.ml" +# 29690 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29552,29 +29720,29 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct }; } = _menhir_stack in let rp : ( -# 76 "parser_cocci_menhir.mly" +# 77 "parser_cocci_menhir.mly" (Data.clt) -# 29558 "parser_cocci_menhir.ml" +# 29726 "parser_cocci_menhir.ml" ) = Obj.magic rp in let t : 'tv_ctype = Obj.magic t in let lp : ( -# 75 "parser_cocci_menhir.mly" +# 76 "parser_cocci_menhir.mly" (Data.clt) -# 29564 "parser_cocci_menhir.ml" +# 29732 "parser_cocci_menhir.ml" ) = Obj.magic lp in let s : ( # 58 "parser_cocci_menhir.mly" (Data.clt) -# 29569 "parser_cocci_menhir.ml" +# 29737 "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_ = -# 1290 "parser_cocci_menhir.mly" +# 1301 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s, P.clt2mcode "(" lp,t, P.clt2mcode ")" rp)) ) -# 29578 "parser_cocci_menhir.ml" +# 29746 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29593,16 +29761,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 92 "parser_cocci_menhir.mly" +# 93 "parser_cocci_menhir.mly" (Data.clt) -# 29599 "parser_cocci_menhir.ml" +# 29767 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_op = -# 1294 "parser_cocci_menhir.mly" +# 1305 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.GetRef _1 ) -# 29606 "parser_cocci_menhir.ml" +# 29774 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29621,16 +29789,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 29627 "parser_cocci_menhir.ml" +# 29795 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_op = -# 1295 "parser_cocci_menhir.mly" +# 1306 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.DeRef _1 ) -# 29634 "parser_cocci_menhir.ml" +# 29802 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29649,16 +29817,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 29655 "parser_cocci_menhir.ml" +# 29823 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_op = -# 1296 "parser_cocci_menhir.mly" +# 1307 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.UnPlus _1 ) -# 29662 "parser_cocci_menhir.ml" +# 29830 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29677,16 +29845,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 97 "parser_cocci_menhir.mly" +# 98 "parser_cocci_menhir.mly" (Data.clt) -# 29683 "parser_cocci_menhir.ml" +# 29851 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_op = -# 1297 "parser_cocci_menhir.mly" +# 1308 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.UnMinus _1 ) -# 29690 "parser_cocci_menhir.ml" +# 29858 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29705,16 +29873,16 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct MenhirLib.EngineTypes.next = _menhir_stack; } = _menhir_stack in let _1 : ( -# 98 "parser_cocci_menhir.mly" +# 99 "parser_cocci_menhir.mly" (Data.clt) -# 29711 "parser_cocci_menhir.ml" +# 29879 "parser_cocci_menhir.ml" ) = Obj.magic _1 in let _startpos = _startpos__1_ in let _endpos = _endpos__1_ in let _v : 'tv_unary_op = -# 1298 "parser_cocci_menhir.mly" +# 1309 "parser_cocci_menhir.mly" ( P.clt2mcode Ast.Tilde _1 ) -# 29718 "parser_cocci_menhir.ml" +# 29886 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29742,9 +29910,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_when_start = -# 1718 "parser_cocci_menhir.mly" +# 1730 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS((Ast0.wrap(Ast0.Exp(_1)))::_2)) ) -# 29748 "parser_cocci_menhir.ml" +# 29916 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29772,9 +29940,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__2_ in let _v : 'tv_when_start = -# 1720 "parser_cocci_menhir.mly" +# 1732 "parser_cocci_menhir.mly" ( Ast0.wrap(Ast0.DOTS(_1@_2)) ) -# 29778 "parser_cocci_menhir.ml" +# 29946 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29796,9 +29964,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos_w_ in let _endpos = _endpos_w_ in let _v : 'tv_whenppdecs = -# 894 "parser_cocci_menhir.mly" +# 899 "parser_cocci_menhir.mly" ( w ) -# 29802 "parser_cocci_menhir.ml" +# 29970 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29832,9 +30000,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_whens_when_start_rule_elem_statement_ = -# 1786 "parser_cocci_menhir.mly" +# 1798 "parser_cocci_menhir.mly" ( [Ast0.WhenNot w] ) -# 29838 "parser_cocci_menhir.ml" +# 30006 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29868,9 +30036,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_whens_when_start_rule_elem_statement_ = -# 1787 "parser_cocci_menhir.mly" +# 1799 "parser_cocci_menhir.mly" ( [Ast0.WhenAlways w] ) -# 29874 "parser_cocci_menhir.ml" +# 30042 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29900,9 +30068,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__3_ in let _v : 'tv_whens_when_start_rule_elem_statement_ = -# 1789 "parser_cocci_menhir.mly" +# 1801 "parser_cocci_menhir.mly" ( List.map (function x -> Ast0.WhenModifier(x)) _2 ) -# 29906 "parser_cocci_menhir.ml" +# 30074 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29936,9 +30104,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_whens_when_start_rule_elem_statement_ = -# 1790 "parser_cocci_menhir.mly" +# 1802 "parser_cocci_menhir.mly" ( [Ast0.WhenNotTrue e] ) -# 29942 "parser_cocci_menhir.ml" +# 30110 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29972,9 +30140,9 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let _startpos = _startpos__1_ in let _endpos = _endpos__4_ in let _v : 'tv_whens_when_start_rule_elem_statement_ = -# 1791 "parser_cocci_menhir.mly" +# 1803 "parser_cocci_menhir.mly" ( [Ast0.WhenNotFalse e] ) -# 29978 "parser_cocci_menhir.ml" +# 30146 "parser_cocci_menhir.ml" in _menhir_env.MenhirLib.EngineTypes.stack <- { MenhirLib.EngineTypes.state = _menhir_s; @@ -29995,106 +30163,106 @@ module MenhirInterpreter = MenhirLib.TableInterpreter.Make (struct let rec script_meta_main = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1531 lexer lexbuf) : ( -# 158 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1534 lexer lexbuf) : ( +# 159 "parser_cocci_menhir.mly" (string * (string * string)) -# 30002 "parser_cocci_menhir.ml" +# 30170 "parser_cocci_menhir.ml" )) and rule_name = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1467 lexer lexbuf) : ( -# 152 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1470 lexer lexbuf) : ( +# 153 "parser_cocci_menhir.mly" (Ast_cocci.rulename) -# 30010 "parser_cocci_menhir.ml" +# 30178 "parser_cocci_menhir.ml" )) and reinit = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1465 lexer lexbuf) : ( -# 130 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1468 lexer lexbuf) : ( +# 131 "parser_cocci_menhir.mly" (unit) -# 30018 "parser_cocci_menhir.ml" +# 30186 "parser_cocci_menhir.ml" )) and plus_main = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1429 lexer lexbuf) : ( -# 139 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1432 lexer lexbuf) : ( +# 140 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 30026 "parser_cocci_menhir.ml" +# 30194 "parser_cocci_menhir.ml" )) and plus_exp_main = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1420 lexer lexbuf) : ( -# 142 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1423 lexer lexbuf) : ( +# 143 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 30034 "parser_cocci_menhir.ml" +# 30202 "parser_cocci_menhir.ml" )) and never_used = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1414 lexer lexbuf) : ( -# 167 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1417 lexer lexbuf) : ( +# 168 "parser_cocci_menhir.mly" (unit) -# 30042 "parser_cocci_menhir.ml" +# 30210 "parser_cocci_menhir.ml" )) and minus_main = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1328 lexer lexbuf) : ( -# 133 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1331 lexer lexbuf) : ( +# 134 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 30050 "parser_cocci_menhir.ml" +# 30218 "parser_cocci_menhir.ml" )) and minus_exp_main = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1304 lexer lexbuf) : ( -# 136 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1307 lexer lexbuf) : ( +# 137 "parser_cocci_menhir.mly" (Ast0_cocci.rule) -# 30058 "parser_cocci_menhir.ml" +# 30226 "parser_cocci_menhir.ml" )) and meta_main = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1301 lexer lexbuf) : ( -# 156 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1304 lexer lexbuf) : ( +# 157 "parser_cocci_menhir.mly" ((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list) -# 30066 "parser_cocci_menhir.ml" +# 30234 "parser_cocci_menhir.ml" )) and iso_rule_name = fun lexer lexbuf -> - (Obj.magic (MenhirInterpreter.entry 1297 lexer lexbuf) : ( -# 148 "parser_cocci_menhir.mly" + (Obj.magic (MenhirInterpreter.entry 1300 lexer lexbuf) : ( +# 149 "parser_cocci_menhir.mly" (Ast_cocci.rulename) -# 30074 "parser_cocci_menhir.ml" +# 30242 "parser_cocci_menhir.ml" )) and iso_meta_main = fun lexer lexbuf -> (Obj.magic (MenhirInterpreter.entry 1104 lexer lexbuf) : ( -# 164 "parser_cocci_menhir.mly" +# 165 "parser_cocci_menhir.mly" ((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list) -# 30082 "parser_cocci_menhir.ml" +# 30250 "parser_cocci_menhir.ml" )) and iso_main = fun lexer lexbuf -> (Obj.magic (MenhirInterpreter.entry 10 lexer lexbuf) : ( -# 161 "parser_cocci_menhir.mly" +# 162 "parser_cocci_menhir.mly" (Ast0_cocci.anything list list) -# 30090 "parser_cocci_menhir.ml" +# 30258 "parser_cocci_menhir.ml" )) and include_main = fun lexer lexbuf -> (Obj.magic (MenhirInterpreter.entry 0 lexer lexbuf) : ( -# 145 "parser_cocci_menhir.mly" +# 146 "parser_cocci_menhir.mly" ((string,string) Common.either list) -# 30098 "parser_cocci_menhir.ml" +# 30266 "parser_cocci_menhir.ml" )) diff --git a/parsing_cocci/parser_cocci_menhir.mli b/parsing_cocci/parser_cocci_menhir.mli index 1021ed9..98f6859 100644 --- a/parsing_cocci/parser_cocci_menhir.mli +++ b/parsing_cocci/parser_cocci_menhir.mli @@ -88,6 +88,7 @@ type token = | TMetaLocalIdExp of (Parse_aux.typed_info) | TMetaLocalFunc of (Parse_aux.idinfo) | TMetaIterator of (Parse_aux.idinfo) + | TMetaInit of (Parse_aux.info) | TMetaIdExp of (Parse_aux.typed_info) | TMetaId of (Parse_aux.idinfo) | TMetaFunc of (Parse_aux.idinfo) @@ -112,6 +113,7 @@ type token = | TIso | TInvalid | TInt of (string * Data.clt) + | TInitialiser | TIncludeNL of (string * Data.clt) | TIncludeL of (string * Data.clt) | TInc of (Data.clt) diff --git a/parsing_cocci/parser_cocci_menhir.mly b/parsing_cocci/parser_cocci_menhir.mly index 8172b30..09fb8ad 100644 --- a/parsing_cocci/parser_cocci_menhir.mly +++ b/parsing_cocci/parser_cocci_menhir.mly @@ -38,7 +38,7 @@ module P = Parse_aux %token EOF %token TIdentifier TExpression TStatement TFunction TLocal TType TParameter -%token TIdExpression +%token TIdExpression TInitialiser %token Tlist TFresh TConstant TError TWords TWhy0 TPlus0 TBang0 %token TPure TContext TGenerated %token TTypedef TDeclarer TIterator TName TPosition TPosAny @@ -62,6 +62,7 @@ module P = Parse_aux %token TMetaIterator TMetaDeclarer %token TMetaErr %token TMetaParam TMetaStm TMetaStmList TMetaType +%token TMetaInit %token TMetaParamList TMetaExpList %token TMetaExp TMetaIdExp TMetaLocalIdExp TMetaConst %token TMetaPos @@ -320,6 +321,10 @@ metadec: { (fun arity name pure check_meta -> let tok = check_meta(Ast.MetaTypeDecl(arity,name)) in !Data.add_type_meta name pure; tok) } +| TInitialiser + { (fun arity name pure check_meta -> + let tok = check_meta(Ast.MetaInitDecl(arity,name)) in + !Data.add_init_meta name pure; tok) } | TStatement { (fun arity name pure check_meta -> let tok = check_meta(Ast.MetaStmDecl(arity,name)) in @@ -1063,6 +1068,9 @@ initialize: { Ast0.wrap (Ast0.InitList(P.clt2mcode "{" $1,Ast0.wrap(Ast0.DOTS []), P.clt2mcode "}" $2)) } + | TMetaInit + {let (nm,pure,clt) = $1 in + Ast0.wrap(Ast0.MetaInit(P.clt2mcode nm clt,pure)) } initialize2: /*arithexpr and not eexpr because can have ambiguity with comma*/ @@ -1075,16 +1083,19 @@ initialize2: (Ast0.InitList(P.clt2mcode "{" $1,Ast0.wrap(Ast0.DOTS []), P.clt2mcode "}" $2)) } /* gccext:, labeled elements */ -| TDot ident TEq initialize2 - { Ast0.wrap(Ast0.InitGccDotName(P.clt2mcode "." $1,$2,P.clt2mcode "=" $3,$4)) } +| list(designator) TEq initialize2 + { Ast0.wrap(Ast0.InitGccExt($1,P.clt2mcode "=" $2,$3)) } | ident TDotDot initialize2 { Ast0.wrap(Ast0.InitGccName($1,P.clt2mcode ":" $2,$3)) } /* in old kernel */ -| TOCro eexpr TCCro TEq initialize2 - { Ast0.wrap(Ast0.InitGccIndex(P.clt2mcode "[" $1,$2,P.clt2mcode "]" $3, - P.clt2mcode "=" $4,$5)) } -| TOCro eexpr TEllipsis eexpr TCCro TEq initialize2 - { Ast0.wrap(Ast0.InitGccRange(P.clt2mcode "[" $1,$2,P.clt2mcode "..." $3, - $4,P.clt2mcode "]" $5,P.clt2mcode "=" $6,$7)) } + +designator: + | TDot ident + { Ast0.DesignatorField (P.clt2mcode "." $1,$2) } + | TOCro eexpr TCCro + { Ast0.DesignatorIndex (P.clt2mcode "[" $1,$2,P.clt2mcode "]" $3) } + | TOCro eexpr TEllipsis eexpr TCCro + { Ast0.DesignatorRange (P.clt2mcode "[" $1,$2,P.clt2mcode "..." $3, + $4,P.clt2mcode "]" $5) } initialize_list: initialize_list_start { Ast0.wrap(Ast0.DOTS($1)) } @@ -1510,7 +1521,8 @@ typedef_ident: /*****************************************************************************/ decl_list(decl): - decl_list_start(decl) + /* empty */ { Ast0.wrap(Ast0.DOTS([])) } +| decl_list_start(decl) {let circle x = match Ast0.unwrap x with Ast0.Pcircles(_) -> true | _ -> false in if List.exists circle $1 diff --git a/parsing_cocci/pretty_print_cocci.ml b/parsing_cocci/pretty_print_cocci.ml index 0928872..9675e49 100644 --- a/parsing_cocci/pretty_print_cocci.ml +++ b/parsing_cocci/pretty_print_cocci.ml @@ -459,7 +459,9 @@ and declaration d = and initialiser i = match Ast.unwrap i with - Ast.InitExpr(exp) -> expression exp + Ast.MetaInit(name,_,_) -> + mcode print_meta name; print_string " " + | Ast.InitExpr(exp) -> expression exp | Ast.InitList(lb,initlist,rb,whencode) -> mcode print_string lb; open_box 0; if not (whencode = []) @@ -470,24 +472,23 @@ and initialiser i = force_newline()); List.iter initialiser initlist; close_box(); mcode print_string rb - | Ast.InitGccDotName(dot,name,eq,ini) -> - mcode print_string dot; ident name; print_string " "; + | Ast.InitGccExt(designators,eq,ini) -> + List.iter designator designators; print_string " "; mcode print_string eq; print_string " "; initialiser ini | Ast.InitGccName(name,eq,ini) -> ident name; mcode print_string eq; initialiser ini - | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> - mcode print_string lb; expression exp; mcode print_string rb; - print_string " "; mcode print_string eq; print_string " "; - initialiser ini - | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - mcode print_string lb; expression exp1; mcode print_string dots; - expression exp2; mcode print_string rb; - print_string " "; mcode print_string eq; print_string " "; - initialiser ini | Ast.IComma(comma) -> mcode print_string comma; force_newline() | Ast.OptIni(ini) -> print_string "?"; initialiser ini | Ast.UniqueIni(ini) -> print_string "!"; initialiser ini +and designator = function + Ast.DesignatorField(dot,id) -> mcode print_string dot; ident id + | Ast.DesignatorIndex(lb,exp,rb) -> + mcode print_string lb; expression exp; mcode print_string rb + | Ast.DesignatorRange(lb,min,dots,max,rb) -> + mcode print_string lb; expression min; mcode print_string dots; + expression max; mcode print_string rb + (* --------------------------------------------------------------------- *) (* Parameter *) diff --git a/parsing_cocci/unify_ast.ml b/parsing_cocci/unify_ast.ml index 6d14682..f29e4f7 100644 --- a/parsing_cocci/unify_ast.ml +++ b/parsing_cocci/unify_ast.ml @@ -312,27 +312,21 @@ and unify_declaration d1 d2 = and unify_initialiser i1 i2 = match (Ast.unwrap i1,Ast.unwrap i2) with - (Ast.InitExpr(expa),Ast.InitExpr(expb)) -> + (Ast.MetaInit(_,_,_),_) | (_,Ast.MetaInit(_,_,_)) -> return true + | (Ast.InitExpr(expa),Ast.InitExpr(expb)) -> unify_expression expa expb | (Ast.InitList(_,initlista,_,whena), Ast.InitList(_,initlistb,_,whenb)) -> (* ignore whencode - returns true safely *) unify_lists unify_initialiser (function _ -> false) initlista initlistb - | (Ast.InitGccDotName(_,namea,_,inia), - Ast.InitGccDotName(_,nameb,_,inib)) -> + | (Ast.InitGccExt(designatorsa,_,inia), + Ast.InitGccExt(designatorsb,_,inib)) -> conjunct_bindings - (unify_ident namea nameb) (unify_initialiser inia inib) + (unify_lists unify_designator (function _ -> false) + designatorsa designatorsb) + (unify_initialiser inia inib) | (Ast.InitGccName(namea,_,inia),Ast.InitGccName(nameb,_,inib)) -> conjunct_bindings (unify_ident namea nameb) (unify_initialiser inia inib) - | (Ast.InitGccIndex(_,expa,_,_,inia), - Ast.InitGccIndex(_,expb,_,_,inib)) -> - conjunct_bindings - (unify_expression expa expb) (unify_initialiser inia inib) - | (Ast.InitGccRange(_,exp1a,_,exp2a,_,_,inia), - Ast.InitGccRange(_,exp1b,_,exp2b,_,_,inib)) -> - conjunct_bindings (unify_expression exp1a exp1b) - (conjunct_bindings (unify_expression exp2a exp2b) - (unify_initialiser inia inib)) | (Ast.OptIni(_),_) | (Ast.UniqueIni(_),_) @@ -340,6 +334,18 @@ and unify_initialiser i1 i2 = | (_,Ast.UniqueIni(_)) -> failwith "unsupported decl" | _ -> return false +and unify_designator d1 d2 = + match (d1,d2) with + (Ast.DesignatorField(_,idb),Ast.DesignatorField(_,ida)) -> + unify_ident ida idb + | (Ast.DesignatorIndex(_,expa,_),Ast.DesignatorIndex(_,expb,_)) -> + unify_expression expa expb + | (Ast.DesignatorRange(_,mina,_,maxa,_), + Ast.DesignatorRange(_,minb,_,maxb,_)) -> + conjunct_bindings (unify_expression mina minb) + (unify_expression maxa maxb) + | _ -> return false + (* --------------------------------------------------------------------- *) (* Parameter *) diff --git a/parsing_cocci/unparse_ast0.ml b/parsing_cocci/unparse_ast0.ml index fe3dd11..b295646 100644 --- a/parsing_cocci/unparse_ast0.ml +++ b/parsing_cocci/unparse_ast0.ml @@ -356,25 +356,17 @@ and initialiser i = print_context i (function _ -> match Ast0.unwrap i with - Ast0.InitExpr(exp) -> expression exp + Ast0.MetaInit(name,_)-> mcode print_meta name; print_string " " + | Ast0.InitExpr(exp) -> expression exp | Ast0.InitList(lb,initlist,rb) -> mcode print_string lb; open_box 0; let _ = dots (function _ -> ()) initialiser initlist in close_box(); mcode print_string rb - | Ast0.InitGccDotName(dot,name,eq,ini) -> - mcode print_string dot; ident name; print_string " "; + | Ast0.InitGccExt(designators,eq,ini) -> + List.iter designator designators; print_string " "; mcode print_string eq; print_string " "; initialiser ini | Ast0.InitGccName(name,eq,ini) -> ident name; mcode print_string eq; initialiser ini - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> - mcode print_string lb; expression exp; mcode print_string rb; - print_string " "; mcode print_string eq; print_string " "; - initialiser ini - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - mcode print_string lb; expression exp1; mcode print_string dots; - expression exp2; mcode print_string rb; - print_string " "; mcode print_string eq; print_string " "; - initialiser ini | Ast0.IComma(cm) -> mcode print_string cm; force_newline() | Ast0.Idots(d,Some whencode) -> mcode print_string d; print_string " WHEN != "; @@ -383,6 +375,14 @@ and initialiser i = | Ast0.OptIni(ini) -> print_string "?"; initialiser ini | Ast0.UniqueIni(ini) -> print_string "!"; initialiser ini) +and designator = function + Ast0.DesignatorField(dot,id) -> mcode print_string dot; ident id + | Ast0.DesignatorIndex(lb,exp,rb) -> + mcode print_string lb; expression exp; mcode print_string rb + | Ast0.DesignatorRange(lb,min,dots,max,rb) -> + mcode print_string lb; expression min; mcode print_string dots; + expression max; mcode print_string rb + and initialiser_list l = dots (function _ -> ()) initialiser l (* --------------------------------------------------------------------- *) diff --git a/parsing_cocci/visitor_ast.ml b/parsing_cocci/visitor_ast.ml index 6541953..f0ca9c8 100644 --- a/parsing_cocci/visitor_ast.ml +++ b/parsing_cocci/visitor_ast.ml @@ -268,32 +268,34 @@ let combiner bind option_default and initialiser i = let k i = match Ast.unwrap i with - Ast.InitExpr(exp) -> expression exp + Ast.MetaInit(name,_,_) -> meta_mcode name + | Ast.InitExpr(exp) -> expression exp | Ast.InitList(lb,initlist,rb,whencode) -> multibind [string_mcode lb; multibind (List.map initialiser initlist); string_mcode rb; multibind (List.map initialiser whencode)] - | Ast.InitGccDotName(dot,name,eq,ini) -> - multibind - [string_mcode dot; ident name; string_mcode eq; initialiser ini] | Ast.InitGccName(name,eq,ini) -> multibind [ident name; string_mcode eq; initialiser ini] - | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> - multibind - [string_mcode lb; expression exp; string_mcode rb; - string_mcode eq; initialiser ini] - | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> + | Ast.InitGccExt(designators,eq,ini) -> multibind - [string_mcode lb; expression exp1; string_mcode dots; - expression exp2; string_mcode rb; string_mcode eq; - initialiser ini] + ((List.map designator designators) @ + [string_mcode eq; initialiser ini]) | Ast.IComma(cm) -> string_mcode cm | Ast.OptIni(i) -> initialiser i | Ast.UniqueIni(i) -> initialiser i in initfn all_functions k i + and designator = function + Ast.DesignatorField(dot,id) -> bind (string_mcode dot) (ident id) + | Ast.DesignatorIndex(lb,exp,rb) -> + bind (string_mcode lb) (bind (expression exp) (string_mcode rb)) + | Ast.DesignatorRange(lb,min,dots,max,rb) -> + multibind + [string_mcode lb; expression min; string_mcode dots; + expression max; string_mcode rb] + and parameterTypeDef p = let k p = match Ast.unwrap p with @@ -758,29 +760,32 @@ let rebuilder let k i = Ast.rewrap i (match Ast.unwrap i with - Ast.InitExpr(exp) -> Ast.InitExpr(expression exp) + Ast.MetaInit(name,keep,inherited) -> + Ast.MetaInit(meta_mcode name,keep,inherited) + | Ast.InitExpr(exp) -> Ast.InitExpr(expression exp) | Ast.InitList(lb,initlist,rb,whencode) -> Ast.InitList(string_mcode lb, List.map initialiser initlist, string_mcode rb, List.map initialiser whencode) - | Ast.InitGccDotName(dot,name,eq,ini) -> - Ast.InitGccDotName - (string_mcode dot, ident name, string_mcode eq, initialiser ini) | Ast.InitGccName(name,eq,ini) -> Ast.InitGccName(ident name, string_mcode eq, initialiser ini) - | Ast.InitGccIndex(lb,exp,rb,eq,ini) -> - Ast.InitGccIndex - (string_mcode lb, expression exp, string_mcode rb, - string_mcode eq, initialiser ini) - | Ast.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - Ast.InitGccRange - (string_mcode lb, expression exp1, string_mcode dots, - expression exp2, string_mcode rb, string_mcode eq, + | Ast.InitGccExt(designators,eq,ini) -> + Ast.InitGccExt + (List.map designator designators, string_mcode eq, initialiser ini) | Ast.IComma(cm) -> Ast.IComma(string_mcode cm) | Ast.OptIni(i) -> Ast.OptIni(initialiser i) | Ast.UniqueIni(i) -> Ast.UniqueIni(initialiser i)) in initfn all_functions k i + and designator = function + Ast.DesignatorField(dot,id) -> + Ast.DesignatorField(string_mcode dot,ident id) + | Ast.DesignatorIndex(lb,exp,rb) -> + Ast.DesignatorIndex(string_mcode lb,expression exp,string_mcode rb) + | Ast.DesignatorRange(lb,min,dots,max,rb) -> + Ast.DesignatorRange(string_mcode lb,expression min,string_mcode dots, + expression max,string_mcode rb) + and parameterTypeDef p = let k p = Ast.rewrap p diff --git a/parsing_cocci/visitor_ast0.ml b/parsing_cocci/visitor_ast0.ml index 8a5bd6e..16ae0a1 100644 --- a/parsing_cocci/visitor_ast0.ml +++ b/parsing_cocci/visitor_ast0.ml @@ -290,30 +290,33 @@ let combiner bind option_default and initialiser i = let k i = match Ast0.unwrap i with - Ast0.InitExpr(exp) -> expression exp + Ast0.MetaInit(name,_) -> meta_mcode name + | Ast0.InitExpr(exp) -> expression exp | Ast0.InitList(lb,initlist,rb) -> multibind [string_mcode lb; initialiser_dots initlist; string_mcode rb] - | Ast0.InitGccDotName(dot,name,eq,ini) -> + | Ast0.InitGccExt(designators,eq,ini) -> multibind - [string_mcode dot; ident name; string_mcode eq; initialiser ini] + ((List.map designator designators) @ + [string_mcode eq; initialiser ini]) | Ast0.InitGccName(name,eq,ini) -> multibind [ident name; string_mcode eq; initialiser ini] - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> - multibind - [string_mcode lb; expression exp; string_mcode rb; - string_mcode eq; initialiser ini] - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - multibind - [string_mcode lb; expression exp1; string_mcode dots; - expression exp2; string_mcode rb; string_mcode eq; - initialiser ini] | Ast0.IComma(cm) -> string_mcode cm | Ast0.Idots(dots,whencode) -> bind (string_mcode dots) (get_option initialiser whencode) | Ast0.OptIni(i) -> initialiser i | Ast0.UniqueIni(i) -> initialiser i in initfn all_functions k i + + and designator = function + Ast0.DesignatorField(dot,id) -> bind (string_mcode dot) (ident id) + | Ast0.DesignatorIndex(lb,exp,rb) -> + bind (string_mcode lb) (bind (expression exp) (string_mcode rb)) + | Ast0.DesignatorRange(lb,min,dots,max,rb) -> + multibind + [string_mcode lb; expression min; string_mcode dots; + expression max; string_mcode rb] + and parameterTypeDef p = let k p = match Ast0.unwrap p with @@ -778,30 +781,34 @@ let rebuilder = fun let k i = Ast0.rewrap i (match Ast0.unwrap i with - Ast0.InitExpr(exp) -> Ast0.InitExpr(expression exp) + Ast0.MetaInit(name,pure) -> + Ast0.MetaInit(meta_mcode name,pure) + | Ast0.InitExpr(exp) -> Ast0.InitExpr(expression exp) | Ast0.InitList(lb,initlist,rb) -> Ast0.InitList(string_mcode lb, initialiser_list initlist, string_mcode rb) - | Ast0.InitGccDotName(dot,name,eq,ini) -> - Ast0.InitGccDotName - (string_mcode dot, ident name, string_mcode eq, initialiser ini) + | Ast0.InitGccExt(designators,eq,ini) -> + Ast0.InitGccExt + (List.map designator designators, string_mcode eq, + initialiser ini) | Ast0.InitGccName(name,eq,ini) -> Ast0.InitGccName(ident name, string_mcode eq, initialiser ini) - | Ast0.InitGccIndex(lb,exp,rb,eq,ini) -> - Ast0.InitGccIndex - (string_mcode lb, expression exp, string_mcode rb, - string_mcode eq, initialiser ini) - | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) -> - Ast0.InitGccRange - (string_mcode lb, expression exp1, string_mcode dots, - expression exp2, string_mcode rb, string_mcode eq, - initialiser ini) | Ast0.IComma(cm) -> Ast0.IComma(string_mcode cm) | Ast0.Idots(d,whencode) -> Ast0.Idots(string_mcode d, get_option initialiser whencode) | Ast0.OptIni(i) -> Ast0.OptIni(initialiser i) | Ast0.UniqueIni(i) -> Ast0.UniqueIni(initialiser i)) in initfn all_functions k i + + and designator = function + Ast0.DesignatorField(dot,id) -> + Ast0.DesignatorField(string_mcode dot,ident id) + | Ast0.DesignatorIndex(lb,exp,rb) -> + Ast0.DesignatorIndex(string_mcode lb,expression exp,string_mcode rb) + | Ast0.DesignatorRange(lb,min,dots,max,rb) -> + Ast0.DesignatorRange(string_mcode lb,expression min,string_mcode dots, + expression max,string_mcode rb) + and parameterTypeDef p = let k p = Ast0.rewrap p diff --git a/python/.#yes_pycocci_aux.ml.1.1 b/python/.#yes_pycocci_aux.ml.1.1 new file mode 100644 index 0000000..1566b64 --- /dev/null +++ b/python/.#yes_pycocci_aux.ml.1.1 @@ -0,0 +1,79 @@ +(* +* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen +* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller +* 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 . +* +* The authors reserve the right to distribute this or future versions of +* Coccinelle under other licenses. +*) + + +open Ast_c +open Common +open Pycaml + +let rec exprrep expr = match expr with + Ast_c.Ident s -> s +| Ast_c.Constant c -> constantrep c +| Ast_c.FunCall (e,args) -> "TODO: FunCall" +| Ast_c.CondExpr (e1,e2,e3) -> "TODO: CondExpr" +| Ast_c.Sequence (e1,e2) -> "TODO: Sequence" +| Ast_c.Assignment (e1,op,e2) -> "TODO: Assignment" +| Ast_c.Postfix (e,op) -> "TODO: Postfix" +| Ast_c.Infix (e,op) -> "TODO: Infix" +| Ast_c.Unary (e,op) -> "TODO: Unary" +| Ast_c.Binary (e1,op,e2) -> "TODO: Binary" +| Ast_c.ArrayAccess (e1,e2) -> "TODO: ArrayAccess" +| Ast_c.RecordAccess (e1,s) -> "TODO: RecordAccess" +| Ast_c.RecordPtAccess (e,s) -> "TODO: RecordPtAccess" +| Ast_c.SizeOfExpr e -> "TODO: SizeOfExpr" +| Ast_c.SizeOfType t -> "TODO: SizeOfType" +| Ast_c.Cast (t,e) -> "TODO: Cast" +| Ast_c.StatementExpr c -> "TODO: StatementExpr" +| Ast_c.Constructor (t,i) -> "TODO: Constructor" +| Ast_c.ParenExpr e -> "TODO: ParenExpr" +and constantrep c = match c with + Ast_c.String (s,isWchar) -> s +| Ast_c.MultiString -> "TODO: MultiString" +| Ast_c.Char (s,isWchar) -> s +| Ast_c.Int s -> s +| Ast_c.Float (s,t) -> s + +let call_pretty f a = + let str = ref ([] : string list) in + let pr_elem info = str := (Ast_c.str_of_info info) :: !str in + let pr_sp _ = () in + f pr_elem pr_sp a; + String.concat " " (List.rev !str) + +let stringrep mvb = match mvb with + Ast_c.MetaIdVal s -> s +| Ast_c.MetaFuncVal s -> s +| Ast_c.MetaLocalFuncVal s -> s +| Ast_c.MetaExprVal ((expr,_),[il]) -> (exprrep expr) +| Ast_c.MetaExprVal e -> "TODO: <>" +| Ast_c.MetaExprListVal expr_list -> "TODO: <>" +| Ast_c.MetaTypeVal typ -> call_pretty Pretty_print_c.pp_type_gen typ +| Ast_c.MetaStmtVal statement -> "TODO: stmt" +| Ast_c.MetaParamVal params -> "TODO: <>" +| Ast_c.MetaParamListVal params -> "TODO: <>" +| Ast_c.MetaListlenVal n -> string_of_int n +| Ast_c.MetaPosVal (pos1, pos2) -> + let print_pos = function + Ast_cocci.Real x -> string_of_int x + | Ast_cocci.Virt(x,off) -> Printf.sprintf "%d+%d" x off in + Common.sprintf ("pos(%s,%s)") (print_pos pos1) (print_pos pos2) +| Ast_c.MetaPosValList positions -> "TODO: <>" + diff --git a/python/yes_pycocci_aux.ml b/python/yes_pycocci_aux.ml index 1566b64..8c5af0b 100644 --- a/python/yes_pycocci_aux.ml +++ b/python/yes_pycocci_aux.ml @@ -66,6 +66,7 @@ let stringrep mvb = match mvb with | Ast_c.MetaExprVal e -> "TODO: <>" | Ast_c.MetaExprListVal expr_list -> "TODO: <>" | Ast_c.MetaTypeVal typ -> call_pretty Pretty_print_c.pp_type_gen typ +| Ast_c.MetaInitVal ini -> "TODO: <>" | Ast_c.MetaStmtVal statement -> "TODO: stmt" | Ast_c.MetaParamVal params -> "TODO: <>" | Ast_c.MetaParamListVal params -> "TODO: <>" diff --git a/tests/ac.c b/tests/ac.c new file mode 100644 index 0000000..938ef99 --- /dev/null +++ b/tests/ac.c @@ -0,0 +1,17 @@ +static Scsi_Host_Template acornscsi_template = { + .module = THIS_MODULE, + .proc_info = acornscsi_proc_info, + .name = "AcornSCSI", + .info = acornscsi_info, + .queuecommand = acornscsi_queuecmd, +#warning fixme + .abort = acornscsi_abort, + .reset = acornscsi_reset, + .can_queue = 16, + .this_id = 7, + .sg_tablesize = SG_ALL, + .cmd_per_lun = 2, + .unchecked_isa_dma = 0, + .use_clustering = DISABLE_CLUSTERING, + .proc_name = "acornscsi", +}; diff --git a/tests/ben.c b/tests/ben.c new file mode 100644 index 0000000..be065c1 --- /dev/null +++ b/tests/ben.c @@ -0,0 +1,24 @@ +GType +lasso_provider_get_type() +{ + static GType this_type = 0; + + if (!this_type) { + static const GTypeInfo this_info = { + sizeof (LassoProviderClass), + NULL, + NULL, + (GClassInitFunc) class_init, + NULL, + NULL, + sizeof(LassoProvider), + 0, + (GInstanceInitFunc) instance_init, + NULL + }; + + this_type = g_type_register_static(LASSO_TYPE_NODE, + "LassoProvider", &this_info, 0); + } + return this_type; +} diff --git a/tests/ben.cocci b/tests/ben.cocci new file mode 100644 index 0000000..2689213 --- /dev/null +++ b/tests/ben.cocci @@ -0,0 +1,16 @@ +@@ +function get_type; +identifier this_info, this_type; +typedef GType, GTypeInfo; +initialiser E ; +@@ ++ static GType this_type = 0; ++ static const GTypeInfo this_info = E ; +GType get_type () { +- static GType this_type = 0; + if (...) { +- static const GTypeInfo this_info = E ; + ... + } +... +} diff --git a/tests/ben.res b/tests/ben.res new file mode 100644 index 0000000..582bd28 --- /dev/null +++ b/tests/ben.res @@ -0,0 +1,24 @@ +static GType this_type = 0; +static const GTypeInfo this_info = { + sizeof(LassoProviderClass), + NULL, + NULL, + (GClassInitFunc)class_init, + NULL, + NULL, + sizeof(LassoProvider), + 0, + (GInstanceInitFunc)instance_init, + NULL, +}; +GType +lasso_provider_get_type() +{ + + if (!this_type) { + + this_type = g_type_register_static(LASSO_TYPE_NODE, + "LassoProvider", &this_info, 0); + } + return this_type; +} diff --git a/tests/hil1.c b/tests/hil1.c new file mode 100644 index 0000000..7f30fca --- /dev/null +++ b/tests/hil1.c @@ -0,0 +1,6 @@ +#define FUNC(funct, funct_arg, zero_rc, neg_rc, pos_rc) \ +{ HILSE_FUNC, { func: &funct }, funct_arg, zero_rc }, + +int main () { + return 12; +} diff --git a/tests/hil1.cocci b/tests/hil1.cocci new file mode 100644 index 0000000..711d771 --- /dev/null +++ b/tests/hil1.cocci @@ -0,0 +1,5 @@ +@@ +@@ + +- 12 ++ 5 diff --git a/tests/hil1.res b/tests/hil1.res new file mode 100644 index 0000000..cb380c0 --- /dev/null +++ b/tests/hil1.res @@ -0,0 +1,6 @@ +#define FUNC(funct, funct_arg, zero_rc, neg_rc, pos_rc) \ +{ HILSE_FUNC, { func: &funct }, funct_arg, zero_rc }, + +int main () { + return 5; +} diff --git a/tests/pdbgg.c b/tests/pdbgg.c new file mode 100644 index 0000000..6fd1894 --- /dev/null +++ b/tests/pdbgg.c @@ -0,0 +1,74 @@ +/* regression if remove the definintion of PDBGG in standard.h: + +Great: a test file now works: /home/pad/linux/arch/mips/alchemy/common/au1xxx_irqmap.c +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/arch/powerpc/boot/ps3.c +Error : bad = 11, timeout = false +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/i2c/busses/i2c-ibm_iic.c +Error : bad = 52, timeout = false +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/media/video/et61x251/et61x251_core.c +Error : bad = 197, timeout = false +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/media/video/sn9c102/sn9c102_core.c +Error : bad = 247, timeout = false +Great: a test file now works: /home/pad/linux/drivers/media/video/w9968cf.c +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/media/video/zc0301/zc0301_core.c +Error : bad = 96, timeout = false +Great: a test file now works: /home/pad/linux/drivers/mtd/devices/docprobe.c +Great: a test file now works: /home/pad/linux/drivers/mtd/nand/diskonchip.c +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/net/ibm_newemac/core.c +Error : bad = 14, timeout = false +Great: a test file now works: /home/pad/linux/drivers/scsi/in2000.c +Great: a test file now works: /home/pad/linux/drivers/scsi/scsi_lib.c +Great: a test file now works: /home/pad/linux/drivers/scsi/wd33c93.c +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/usb/gadget/composite.c +Error : bad = 173, timeout = false +Semipb: still error but not same error : /home/pad/linux/drivers/usb/gadget/omap_udc.c +Old error: bad = 1, timeout = fals +New error: bad = 115, timeout = false +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/usb/gadget/printer.c +Error : bad = 168, timeout = false +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/usb/musb/cppi_dma.c +Error : bad = 20, timeout = false +Semipb: still error but not same error : /home/pad/linux/drivers/usb/musb/musb_core.c +Old error: bad = 2, timeout = fals +New error: bad = 315, timeout = false +PBBBBBBBB: a test file does not work anymore!!! : /home/pad/linux/drivers/usb/musb/musb_gadget.c +Error : bad = 104, timeout = false +Great: a test file now works: /home/pad/linux/kernel/auditfilter.c +Great: a test file now works: /home/pad/linux/sound/soc/sh/hac.c +Great: a test file now works: /home/pad/linux/sound/soc/sh/ssi.c + + +cp /home/pad/linux/arch/mips/alchemy/common/au1xxx_irqmap.c /home/pad/linux/arch/powerpc/boot/ps3.c /home/pad/linux/drivers/i2c/busses/i2c-ibm_iic.c /home/pad/linux/drivers/media/video/et61x251/et61x251_core.c /home/pad/linux/drivers/media/video/sn9c102/sn9c102_core.c /home/pad/linux/drivers/media/video/w9968cf.c /home/pad/linux/drivers/media/video/zc0301/zc0301_core.c /home/pad/linux/drivers/mtd/devices/docprobe.c /home/pad/linux/drivers/mtd/nand/diskonchip.c /home/pad/linux/drivers/net/ibm_newemac/core.c /home/pad/linux/drivers/scsi/in2000.c /home/pad/linux/drivers/scsi/scsi_lib.c /home/pad/linux/drivers/scsi/wd33c93.c /home/pad/linux/drivers/usb/gadget/composite.c /home/pad/linux/drivers/usb/gadget/omap_udc.c /home/pad/linux/drivers/usb/gadget/printer.c /home/pad/linux/drivers/usb/musb/cppi_dma.c /home/pad/linux/drivers/usb/musb/musb_core.c /home/pad/linux/drivers/usb/musb/musb_gadget.c /home/pad/linux/kernel/auditfilter.c /home/pad/linux/sound/soc/sh/hac.c /home/pad/linux/sound/soc/sh/ssi.c + + +*/ + +int main() { + PDBGG("this is a test %d\n",x); +} + +int main() { + PDBGG("this is a test %d\n",x) +} + +int main() +{ + PDBGG(static unsigned int prev_mask = 0); +} + + +int main() { + + PDBGG("Isochrnous frame: length %u, #%u i", len, i) + + /* + NOTE: It is probably correct to assume that SOF and EOF + headers do not occur between two consecutive packets, + but who knows..Whatever is the truth, this assumption + doesn't introduce bugs. + */ + +redo: + sof = sn9c102_find_sof_header(cam, pos, len); + +} diff --git a/tests/structfoo.c b/tests/structfoo.c new file mode 100644 index 0000000..109a1bd --- /dev/null +++ b/tests/structfoo.c @@ -0,0 +1,4 @@ +struct foo my_foo[] = { +.a = 1, +.u.b = 42, +}; diff --git a/tests/structfoo.cocci b/tests/structfoo.cocci new file mode 100644 index 0000000..f79110a --- /dev/null +++ b/tests/structfoo.cocci @@ -0,0 +1,9 @@ +@@ +declarer name FOO; +@@ + +- struct foo my_foo[] = { +- .a = 1, +- .u.b = 42, +- }; ++ FOO(1, 42); diff --git a/tests/structfoo.res b/tests/structfoo.res new file mode 100644 index 0000000..3f7c570 --- /dev/null +++ b/tests/structfoo.res @@ -0,0 +1 @@ +FOO(1, 42); -- 2.20.1