From c9783d8ea8b85d810483559e50dbf2297109e349 Mon Sep 17 00:00:00 2001 From: vlad shkapenyuk Date: Thu, 29 Aug 2019 12:50:14 -0400 Subject: [PATCH] Initial commit Signed-off-by: vlad shkapenyuk Change-Id: I24f531bb2b64e002b1ac05a7f5ede2ee83d82b00 --- LICENSE | 176 + README.md | 48 + bin/accept_recommendations.bat | 18 + bin/buildit | 42 + bin/buildit_with-stats | 41 + bin/get_last_trace.pl | 40 + bin/gshub.py | 376 + bin/gshub3.py | 398 + bin/monitor_gs.pl | 180 + bin/parse_cpuinfo.pl | 45 + bin/pin_processes.pl | 65 + bin/split_trace.pl | 36 + bin/start_processing | 24 + build_and_install.sh | 19 + cfg/cpu_info.csv | 88 + cfg/example.ifq | 3 + cfg/external_fcns.def | 183 + cfg/field_list.xml | 3 + cfg/ifres.xml | 23 + cfg/internal_fcn.def | 85 + cfg/localhost.ifq | 4 + cfg/packet_schema.txt | 36 + include/README.md | 17 + include/app.h | 106 + include/byteswap.h | 54 + include/clearinghouseregistries.h | 64 + include/filter.h | 46 + include/fta.h | 189 + include/fta_stat.h | 35 + include/gsconfig.h | 206 + include/gshub.h | 107 + include/gslog.h | 102 + include/gstypes.h | 63 + include/hfta/base_operator.h | 56 + include/hfta/clean_operator.h | 452 + include/hfta/file_output_operator.h | 216 + include/hfta/groupby_operator.h | 238 + include/hfta/groupby_operator_oop.h | 399 + include/hfta/hash_table.h | 610 + include/hfta/hfta.h | 1097 ++ include/hfta/hfta_runtime_library.h | 118 + include/hfta/hfta_sfun.h | 113 + include/hfta/hfta_udaf.h | 123 + include/hfta/host_tuple.h | 81 + include/hfta/join_eq_hash_operator.h | 417 + include/hfta/merge_operator.h | 247 + include/hfta/merge_operator_oop.h | 182 + include/hfta/running_gb_operator.h | 141 + include/hfta/selection_operator.h | 71 + include/hfta/zfile_output_operator.h | 205 + include/lapp.h | 131 + include/lfta/csv2_macro.h | 10017 +++++++++++++++ include/lfta/csv_macro.h | 10017 +++++++++++++++ include/lfta/gdat_macro.h | 10017 +++++++++++++++ include/lfta/gencsvinclude.pl | 35 + include/lfta/gengdatinclude.pl | 35 + include/lfta/md_stdlib.h | 23 + include/lfta/rts.h | 123 + include/lfta/rts_external.h | 153 + include/lfta/rts_udaf.h | 84 + include/lfta/schema_prototypes.h | 513 + include/packet.h | 65 + include/rdtsc.h | 36 + include/schemaparser.h | 317 + include/simple_http.h | 36 + include/stringhash.h | 874 ++ include/systat.h | 25 + include/type_indicators.h | 41 + include/vstring.h | 51 + lib/.keep | 0 qlib/CSVEXAMPLELIB/ex2_src.gsql | 17 + qlib/CSVEXAMPLELIB/output_spec.cfg | 1 + src/Makefile | 36 + src/ftacmp/Makefile | 163 + src/ftacmp/analyze_fta.cc | 5897 +++++++++ src/ftacmp/analyze_fta.h | 784 ++ src/ftacmp/ext_fcns.l | 170 + src/ftacmp/ext_fcns.tab.cc | 1493 +++ src/ftacmp/ext_fcns.tab.cc.h | 87 + src/ftacmp/ext_fcns.y | 168 + src/ftacmp/ext_fcnslexer.cc | 1781 +++ src/ftacmp/field_list.cc | 139 + src/ftacmp/field_list.h | 49 + src/ftacmp/fta.l | 313 + src/ftacmp/fta.tab.cc | 3059 +++++ src/ftacmp/fta.tab.cc.h | 221 + src/ftacmp/fta.y | 646 + src/ftacmp/ftalexer.cc | 2505 ++++ src/ftacmp/gen_tuple_access.cc | 279 + src/ftacmp/generate_lfta_code.cc | 4505 +++++++ src/ftacmp/generate_lfta_code.h | 37 + src/ftacmp/generate_nic_code.cc | 543 + src/ftacmp/generate_nic_code.h | 30 + src/ftacmp/generate_utils.cc | 391 + src/ftacmp/generate_utils.h | 82 + src/ftacmp/iface_q.cc | 649 + src/ftacmp/iface_q.h | 208 + src/ftacmp/ifq.l | 246 + src/ftacmp/ifq.tab.cc | 1469 +++ src/ftacmp/ifq.tab.cc.h | 171 + src/ftacmp/ifq.y | 220 + src/ftacmp/ifqlexer.cc | 1879 +++ src/ftacmp/literal_types.h | 31 + src/ftacmp/nic.l | 226 + src/ftacmp/nic.tab.cc | 1306 ++ src/ftacmp/nic.tab.cc.h | 77 + src/ftacmp/nic.y | 138 + src/ftacmp/nic_def.cc | 128 + src/ftacmp/nic_def.h | 84 + src/ftacmp/niclexer.cc | 1829 +++ src/ftacmp/parse_ext_fcns.h | 907 ++ src/ftacmp/parse_fta.h | 1889 +++ src/ftacmp/parse_partn.cc | 546 + src/ftacmp/parse_partn.h | 78 + src/ftacmp/parse_schema.cc | 524 + src/ftacmp/parse_schema.h | 555 + src/ftacmp/partn.l | 217 + src/ftacmp/partn.tab.cc | 1342 ++ src/ftacmp/partn.tab.cc.h | 82 + src/ftacmp/partn.y | 140 + src/ftacmp/partnlexer.cc | 1773 +++ src/ftacmp/print_plan.h | 107 + src/ftacmp/query_plan.cc | 13571 +++++++++++++++++++++ src/ftacmp/query_plan.h | 2068 ++++ src/ftacmp/res.l | 223 + src/ftacmp/res.tab.cc | 1228 ++ src/ftacmp/res.tab.cc.h | 65 + src/ftacmp/res.y | 119 + src/ftacmp/reslexer.cc | 1778 +++ src/ftacmp/schema.tab.cc | 933 ++ src/ftacmp/schema.tab.cc.h | 17 + src/ftacmp/schemalexer.cc | 1694 +++ src/ftacmp/schemaparser.cc | 1189 ++ src/ftacmp/schemaparser_impl.h | 160 + src/ftacmp/stream_query.cc | 1957 +++ src/ftacmp/stream_query.h | 170 + src/ftacmp/test_interfacelib.cc | 154 + src/ftacmp/translate_fta.cc | 2990 +++++ src/ftacmp/type_indicators.h | 37 + src/ftacmp/type_objects.cc | 1903 +++ src/ftacmp/type_objects.h | 162 + src/ftacmp/xml.l | 224 + src/ftacmp/xml.tab.cc | 1282 ++ src/ftacmp/xml.tab.hh | 63 + src/ftacmp/xml.y | 122 + src/ftacmp/xml_t.h | 56 + src/ftacmp/xmllexer.cc | 1779 +++ src/lib/Makefile | 56 + src/lib/gscpapp/Makefile | 36 + src/lib/gscpapp/appinterface.c | 372 + src/lib/gscpaux/Makefile | 36 + src/lib/gscpaux/block_allocator.cpp | 52 + src/lib/gscpaux/block_allocator.h | 37 + src/lib/gscpaux/gshub.cpp | 294 + src/lib/gscpaux/json.cpp | 475 + src/lib/gscpaux/json.h | 39 + src/lib/gscpaux/simple_http.cpp | 241 + src/lib/gscphftaaux/Makefile | 48 + src/lib/gscphftaaux/Manku_HH.cc | 73 + src/lib/gscphftaaux/SSstateful_count_distinct.cc | 623 + src/lib/gscphftaaux/hfta_runtime_library.cc | 520 + src/lib/gscphftaaux/hfta_udaf.cc | 434 + src/lib/gscphost/Makefile | 52 + src/lib/gscphost/callbackinterface.c | 932 ++ src/lib/gscphost/callbackregistries.c | 727 ++ src/lib/gscphost/clearinghouseregistries.c | 201 + src/lib/gscphost/gscpipc.c | 1344 ++ src/lib/gscphost/include/callbackregistries.h | 143 + src/lib/gscphost/include/gscpipc.h | 142 + src/lib/gscphost/include/gscpmsgq.h | 39 + src/lib/gscphost/include/ipcencoding.h | 188 + src/lib/gscphost/include/lappregistries.h | 41 + src/lib/gscphost/lappinterface.c | 608 + src/lib/gscphost/lappregistries.c | 159 + src/lib/gscphost/lfta.c | 72 + src/lib/gscphostaux/Makefile | 38 + src/lib/gscphostaux/byteswap.c | 40 + src/lib/gscplftaaux/Makefile | 48 + src/lib/gscplftaaux/rts_byteswap.c | 42 + src/lib/gscplftaaux/rts_options.c | 58 + src/lib/gscplftaaux/rts_sample.c | 44 + src/lib/gscplftaaux/rts_string.c | 367 + src/lib/gscplftaaux/rts_udaf.c | 256 + src/lib/gscprts/Makefile | 49 + src/lib/gscprts/rts_csv.c | 404 + src/lib/gscprts/rts_csv2.cc | 0 src/lib/gscprts/rts_env.c | 265 + src/lib/gscprts/rts_gdat.c | 479 + src/lib/gscprts/rts_main.c | 192 + src/tools/Makefile | 110 + src/tools/ascii2gdat.c | 268 + src/tools/gdat2ascii.c | 275 + src/tools/gdatcat.c | 143 + src/tools/gsexit.c | 285 + src/tools/gsgdatprint.c | 580 + src/tools/gsprintconsole.c | 454 + src/tools/gsprintconsole_ves.c | 643 + src/tools/gssinksim.c | 404 + src/tools/gssource.c | 280 + src/tools/process_logs.cc | 1512 +++ src/tools/qnode.h | 231 + src/tools/xml.l | 223 + src/tools/xml.tab.cc | 1645 +++ src/tools/xml.tab.hh | 76 + src/tools/xml.y | 123 + src/tools/xml_t.cc | 47 + src/tools/xml_t.h | 148 + src/tools/xmllexer.cc | 1788 +++ src/views/README.md | 0 tigon.png | Bin 0 -> 52783 bytes views/README.md | 1 + 211 files changed, 133944 insertions(+) create mode 100644 LICENSE create mode 100644 README.md create mode 100755 bin/accept_recommendations.bat create mode 100755 bin/buildit create mode 100755 bin/buildit_with-stats create mode 100755 bin/get_last_trace.pl create mode 100755 bin/gshub.py create mode 100755 bin/gshub3.py create mode 100755 bin/monitor_gs.pl create mode 100755 bin/parse_cpuinfo.pl create mode 100755 bin/pin_processes.pl create mode 100755 bin/split_trace.pl create mode 100755 bin/start_processing create mode 100755 build_and_install.sh create mode 100644 cfg/cpu_info.csv create mode 100644 cfg/example.ifq create mode 100644 cfg/external_fcns.def create mode 100644 cfg/field_list.xml create mode 100644 cfg/ifres.xml create mode 100644 cfg/internal_fcn.def create mode 100644 cfg/localhost.ifq create mode 100644 cfg/packet_schema.txt create mode 100644 include/README.md create mode 100644 include/app.h create mode 100644 include/byteswap.h create mode 100644 include/clearinghouseregistries.h create mode 100644 include/filter.h create mode 100644 include/fta.h create mode 100644 include/fta_stat.h create mode 100644 include/gsconfig.h create mode 100644 include/gshub.h create mode 100644 include/gslog.h create mode 100644 include/gstypes.h create mode 100644 include/hfta/base_operator.h create mode 100644 include/hfta/clean_operator.h create mode 100644 include/hfta/file_output_operator.h create mode 100644 include/hfta/groupby_operator.h create mode 100644 include/hfta/groupby_operator_oop.h create mode 100644 include/hfta/hash_table.h create mode 100644 include/hfta/hfta.h create mode 100644 include/hfta/hfta_runtime_library.h create mode 100644 include/hfta/hfta_sfun.h create mode 100644 include/hfta/hfta_udaf.h create mode 100644 include/hfta/host_tuple.h create mode 100644 include/hfta/join_eq_hash_operator.h create mode 100644 include/hfta/merge_operator.h create mode 100644 include/hfta/merge_operator_oop.h create mode 100644 include/hfta/running_gb_operator.h create mode 100644 include/hfta/selection_operator.h create mode 100644 include/hfta/zfile_output_operator.h create mode 100644 include/lapp.h create mode 100644 include/lfta/csv2_macro.h create mode 100644 include/lfta/csv_macro.h create mode 100644 include/lfta/gdat_macro.h create mode 100644 include/lfta/gencsvinclude.pl create mode 100644 include/lfta/gengdatinclude.pl create mode 100644 include/lfta/md_stdlib.h create mode 100644 include/lfta/rts.h create mode 100644 include/lfta/rts_external.h create mode 100644 include/lfta/rts_udaf.h create mode 100644 include/lfta/schema_prototypes.h create mode 100644 include/packet.h create mode 100644 include/rdtsc.h create mode 100644 include/schemaparser.h create mode 100644 include/simple_http.h create mode 100644 include/stringhash.h create mode 100644 include/systat.h create mode 100644 include/type_indicators.h create mode 100644 include/vstring.h create mode 100644 lib/.keep create mode 100644 qlib/CSVEXAMPLELIB/ex2_src.gsql create mode 100644 qlib/CSVEXAMPLELIB/output_spec.cfg create mode 100644 src/Makefile create mode 100644 src/ftacmp/Makefile create mode 100644 src/ftacmp/analyze_fta.cc create mode 100644 src/ftacmp/analyze_fta.h create mode 100644 src/ftacmp/ext_fcns.l create mode 100644 src/ftacmp/ext_fcns.tab.cc create mode 100644 src/ftacmp/ext_fcns.tab.cc.h create mode 100644 src/ftacmp/ext_fcns.y create mode 100644 src/ftacmp/ext_fcnslexer.cc create mode 100644 src/ftacmp/field_list.cc create mode 100644 src/ftacmp/field_list.h create mode 100644 src/ftacmp/fta.l create mode 100644 src/ftacmp/fta.tab.cc create mode 100644 src/ftacmp/fta.tab.cc.h create mode 100644 src/ftacmp/fta.y create mode 100644 src/ftacmp/ftalexer.cc create mode 100644 src/ftacmp/gen_tuple_access.cc create mode 100644 src/ftacmp/generate_lfta_code.cc create mode 100644 src/ftacmp/generate_lfta_code.h create mode 100644 src/ftacmp/generate_nic_code.cc create mode 100644 src/ftacmp/generate_nic_code.h create mode 100644 src/ftacmp/generate_utils.cc create mode 100644 src/ftacmp/generate_utils.h create mode 100644 src/ftacmp/iface_q.cc create mode 100644 src/ftacmp/iface_q.h create mode 100644 src/ftacmp/ifq.l create mode 100644 src/ftacmp/ifq.tab.cc create mode 100644 src/ftacmp/ifq.tab.cc.h create mode 100644 src/ftacmp/ifq.y create mode 100644 src/ftacmp/ifqlexer.cc create mode 100644 src/ftacmp/literal_types.h create mode 100644 src/ftacmp/nic.l create mode 100644 src/ftacmp/nic.tab.cc create mode 100644 src/ftacmp/nic.tab.cc.h create mode 100644 src/ftacmp/nic.y create mode 100644 src/ftacmp/nic_def.cc create mode 100644 src/ftacmp/nic_def.h create mode 100644 src/ftacmp/niclexer.cc create mode 100644 src/ftacmp/parse_ext_fcns.h create mode 100644 src/ftacmp/parse_fta.h create mode 100644 src/ftacmp/parse_partn.cc create mode 100644 src/ftacmp/parse_partn.h create mode 100644 src/ftacmp/parse_schema.cc create mode 100644 src/ftacmp/parse_schema.h create mode 100644 src/ftacmp/partn.l create mode 100644 src/ftacmp/partn.tab.cc create mode 100644 src/ftacmp/partn.tab.cc.h create mode 100644 src/ftacmp/partn.y create mode 100644 src/ftacmp/partnlexer.cc create mode 100644 src/ftacmp/print_plan.h create mode 100644 src/ftacmp/query_plan.cc create mode 100644 src/ftacmp/query_plan.h create mode 100644 src/ftacmp/res.l create mode 100644 src/ftacmp/res.tab.cc create mode 100644 src/ftacmp/res.tab.cc.h create mode 100644 src/ftacmp/res.y create mode 100644 src/ftacmp/reslexer.cc create mode 100644 src/ftacmp/schema.tab.cc create mode 100644 src/ftacmp/schema.tab.cc.h create mode 100644 src/ftacmp/schemalexer.cc create mode 100644 src/ftacmp/schemaparser.cc create mode 100644 src/ftacmp/schemaparser_impl.h create mode 100644 src/ftacmp/stream_query.cc create mode 100644 src/ftacmp/stream_query.h create mode 100644 src/ftacmp/test_interfacelib.cc create mode 100644 src/ftacmp/translate_fta.cc create mode 100644 src/ftacmp/type_indicators.h create mode 100644 src/ftacmp/type_objects.cc create mode 100644 src/ftacmp/type_objects.h create mode 100644 src/ftacmp/xml.l create mode 100644 src/ftacmp/xml.tab.cc create mode 100644 src/ftacmp/xml.tab.hh create mode 100644 src/ftacmp/xml.y create mode 100644 src/ftacmp/xml_t.h create mode 100644 src/ftacmp/xmllexer.cc create mode 100644 src/lib/Makefile create mode 100644 src/lib/gscpapp/Makefile create mode 100644 src/lib/gscpapp/appinterface.c create mode 100644 src/lib/gscpaux/Makefile create mode 100644 src/lib/gscpaux/block_allocator.cpp create mode 100644 src/lib/gscpaux/block_allocator.h create mode 100644 src/lib/gscpaux/gshub.cpp create mode 100644 src/lib/gscpaux/json.cpp create mode 100644 src/lib/gscpaux/json.h create mode 100644 src/lib/gscpaux/simple_http.cpp create mode 100644 src/lib/gscphftaaux/Makefile create mode 100644 src/lib/gscphftaaux/Manku_HH.cc create mode 100644 src/lib/gscphftaaux/SSstateful_count_distinct.cc create mode 100644 src/lib/gscphftaaux/hfta_runtime_library.cc create mode 100644 src/lib/gscphftaaux/hfta_udaf.cc create mode 100644 src/lib/gscphost/Makefile create mode 100644 src/lib/gscphost/callbackinterface.c create mode 100644 src/lib/gscphost/callbackregistries.c create mode 100644 src/lib/gscphost/clearinghouseregistries.c create mode 100644 src/lib/gscphost/gscpipc.c create mode 100644 src/lib/gscphost/include/callbackregistries.h create mode 100644 src/lib/gscphost/include/gscpipc.h create mode 100644 src/lib/gscphost/include/gscpmsgq.h create mode 100644 src/lib/gscphost/include/ipcencoding.h create mode 100644 src/lib/gscphost/include/lappregistries.h create mode 100644 src/lib/gscphost/lappinterface.c create mode 100644 src/lib/gscphost/lappregistries.c create mode 100644 src/lib/gscphost/lfta.c create mode 100644 src/lib/gscphostaux/Makefile create mode 100644 src/lib/gscphostaux/byteswap.c create mode 100644 src/lib/gscplftaaux/Makefile create mode 100644 src/lib/gscplftaaux/rts_byteswap.c create mode 100644 src/lib/gscplftaaux/rts_options.c create mode 100644 src/lib/gscplftaaux/rts_sample.c create mode 100644 src/lib/gscplftaaux/rts_string.c create mode 100644 src/lib/gscplftaaux/rts_udaf.c create mode 100644 src/lib/gscprts/Makefile create mode 100644 src/lib/gscprts/rts_csv.c create mode 100644 src/lib/gscprts/rts_csv2.cc create mode 100644 src/lib/gscprts/rts_env.c create mode 100644 src/lib/gscprts/rts_gdat.c create mode 100644 src/lib/gscprts/rts_main.c create mode 100644 src/tools/Makefile create mode 100644 src/tools/ascii2gdat.c create mode 100644 src/tools/gdat2ascii.c create mode 100644 src/tools/gdatcat.c create mode 100644 src/tools/gsexit.c create mode 100644 src/tools/gsgdatprint.c create mode 100644 src/tools/gsprintconsole.c create mode 100644 src/tools/gsprintconsole_ves.c create mode 100644 src/tools/gssinksim.c create mode 100644 src/tools/gssource.c create mode 100644 src/tools/process_logs.cc create mode 100644 src/tools/qnode.h create mode 100644 src/tools/xml.l create mode 100644 src/tools/xml.tab.cc create mode 100644 src/tools/xml.tab.hh create mode 100644 src/tools/xml.y create mode 100644 src/tools/xml_t.cc create mode 100644 src/tools/xml_t.h create mode 100644 src/tools/xmllexer.cc create mode 100644 src/views/README.md create mode 100644 tigon.png create mode 100644 views/README.md diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d9a10c0 --- /dev/null +++ b/LICENSE @@ -0,0 +1,176 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/README.md b/README.md new file mode 100644 index 0000000..4bb0795 --- /dev/null +++ b/README.md @@ -0,0 +1,48 @@ +# Tigon + +![Tigon Logo](tigon.png) + +**Introduction** + +**Tigon** is an open-source, real-time, low-latency, high-throughput stream processing framework. + +Tigon is a collaborative effort between Cask Data, Inc. and AT&T that combines +technologies from these companies to create a disruptive new framework to handle a diverse +set of real-time streaming requirements. + +Cask Data has built technology that provides scalable, reliable, and persistent high-throughput +event processing with high-level Java APIs using Hadoop and HBase. + +AT&T has built a streaming engine that provides massively scalable, flexible, and in-memory +low-latency stream processing with a SQL-like query Language. + +Together, they have combined to create **Tigon**. + + + +## Getting Started + +### Prerequisites + +Tigon is supported on *NIX systems such as Linux and Macintosh OS X. +It is not supported on Microsoft Windows. + + +## License and Trademarks + +Copyright © 2014 Cask Data, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except +in compliance with the License. You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software distributed under the +License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +either express or implied. See the License for the specific language governing permissions +and limitations under the License. + +Cask is a trademark of Cask Data, Inc. All rights reserved. + +Apache, Apache HBase, and HBase are trademarks of The Apache Software Foundation. Used with +permission. No endorsement by The Apache Software Foundation is implied by the use of these marks. diff --git a/bin/accept_recommendations.bat b/bin/accept_recommendations.bat new file mode 100755 index 0000000..255313c --- /dev/null +++ b/bin/accept_recommendations.bat @@ -0,0 +1,18 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +cp hfta_parallelism.cfg.recommended hfta_parallelism.cfg +cp lfta_htsize.cfg.recommended lfta_htsize.cfg +cp rts_load.cfg.recommended rts_load.cfg diff --git a/bin/buildit b/bin/buildit new file mode 100755 index 0000000..c762ffc --- /dev/null +++ b/bin/buildit @@ -0,0 +1,42 @@ +#!/bin/sh + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +# GSLITE_ROOT environment variable need to be set + +if [ -z "$GSLITE_ROOT" ] +then + echo "GSLITE_ROOT must be set to non-empty string" + exit -1 +fi + +$GSLITE_ROOT/bin/translate_fta -h localhost -c -M -R $GSLITE_ROOT -C $GSLITE_ROOT/cfg -l $GSLITE_ROOT/qlib packet_schema.txt *.gsql +ret=$? +if [ $ret -ne 0 ] +then + echo "Query translation failed!" + exit $ret +fi + +make +ret=$? +if [ $ret -ne 0 ] +then + echo "Query build failed!" + exit $ret +fi +exit $ret + diff --git a/bin/buildit_with-stats b/bin/buildit_with-stats new file mode 100755 index 0000000..cbf2bee --- /dev/null +++ b/bin/buildit_with-stats @@ -0,0 +1,41 @@ +#!/bin/sh + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +# GSLITE_ROOT environment variable need to be set + +if [ -z "$GSLITE_ROOT" ] +then + echo "GSLITE_ROOT must be set to non-empty string" + exit -1 +fi + +$GSLITE_ROOT/bin/translate_fta -h localhost -c -M -S -R $GSLITE_ROOT -C $GSLITE_ROOT/cfg -l $GSLITE_ROOT/qlib packet_schema.txt *.gsql +ret=$? +if [ $ret -ne 0 ] +then + echo "Query translation failed!" + exit $ret +fi + +make +ret=$? +if [ $ret -ne 0 ] +then + echo "Query build failed!" + exit $ret +fi +exit $ret diff --git a/bin/get_last_trace.pl b/bin/get_last_trace.pl new file mode 100755 index 0000000..b18962f --- /dev/null +++ b/bin/get_last_trace.pl @@ -0,0 +1,40 @@ +#! /usr/bin/perl + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + + +$outfile = "last_tracefile.txt"; +$infl = "/var/log/gstrace"; + +if(scalar(@ARGV)>0){ + $infl = $ARGV[0]; +} + +open I,$infl or die "Can't open input log file $infl\n"; + +open O,">$outfile"; + +while($line=){ + if($line =~ /rts:\[.*\]: Started Logging/){ + close O; + open O,">$outfile"; + } + print O $line; +} +close O; + + + diff --git a/bin/gshub.py b/bin/gshub.py new file mode 100755 index 0000000..e0cd082 --- /dev/null +++ b/bin/gshub.py @@ -0,0 +1,376 @@ +#!/usr/bin/python +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +# Implementation of GSHUB REST service +# for announcement and discovery of gs instances, sources and sinks + +from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer +import SocketServer +import json +import cgi +import threading +import getopt +import sys +import re +import cgi +import socket +import json + +# lis of URLS for all the REST calls we will serve +DISCOVER_INSTANCE_URL = '/v1/discover-instance' +DISCOVER_INITINSTANCE_URL = '/v1/discover-initialized-instance' +DISCOVER_SOURCE_URL = '/v1/discover-source' +DISCOVER_SINK_URL = '/v1/discover-sink' +DISCOVER_STARTPROCESSING_URL = '/v1/discover-start-processing' +ANNOUNCE_INSTANCE_URL = '/v1/announce-instance' +ANNOUNCE_INITINSTANCE_URL = '/v1/announce-initialized-instance' +ANNOUNCE_SOURCE_URL = '/v1/announce-source' +ANNOUNCE_SINK_URL = '/v1/announce-sink' +ANNOUNCE_STARTPROCESSING_URL = '/v1/announce-start-processing' +ANNOUNCE_STREAM_SUBSCRIPTION = '/v1/announce-stream-subscription' +ANNOUNCE_FTA_INSTANCE = '/v1/announce-fta-instance' +ANNOUNCE_METRICS = '/v1/log-metrics' + +# gs instance endpoints +gs_instances = {} + +# initialized gs instances +gs_init_instances = {} + +# instances for which processing started +gs_startprocessing_instances = {} + +# source endpoints +sources = {} + +# sink endpoints +sinks = {} + + +# exctract endpoint information from json data +def extract_endpoint(data) : + name = '' + ip = '' + port = 0 + + try : + doc = json.loads(str(data)) + except : + print ('Invalid json message ' + str(data)) + return [] + + for key in doc.keys() : + if key == 'name' : + name = doc[key] + elif key == 'ip' : + ip = doc[key] + # validate ip address + try : + socket.inet_pton(socket.AF_INET, ip) + except : + print ('Invalid IPV4 address ' + ip) + ip = '' + elif key == 'port' : + # validate port number + try : + port = int(doc[key]) + except : + print ('Invalid port number ' + doc[key]) + port = 0 + + if name == '' or ip == '' or port == 0 : + print ('Name, ip or port is missing from json message ' + str(doc)) + return [] + + + return [name, ip, port] + + +# extract instance name from json data +def extract_instance_name(data) : + name = '' + + try : + doc = json.loads(str(data)) + except : + print ('Invalid json message ' + str(data)) + return '' + + for key in doc.keys() : + if key == 'name' : + name = doc[key] + + if name == '' : + print ('Name field is missing in json message ' + str(doc)) + elif (name in gs_instances) == False: + print ('Attempt to announce the initialization or start of processing for unknown instance ' + name) + name = '' + + return name + +# handler for HTTP requests. We will override do_POST and do_GET of BaseHTTPRequestHandler +class Server(BaseHTTPRequestHandler) : + + def do_POST(self): + if re.search(ANNOUNCE_INSTANCE_URL, self.path) != None: + print self.path + print self.headers + if self.headers.getheader('content-type') == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'content-length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract endpoint information + endpoint = extract_endpoint(self.rfile.read(content_len)) + if endpoint == [] : + self.send_response(400) + else : + self.send_response(200) + gs_instances[endpoint[0]] = [endpoint[1], endpoint[2]] + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_INITINSTANCE_URL, self.path) != None: + if self.headers.getheader('content-type') == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'content-length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract name of initialized gs instance + name = extract_instance_name(self.rfile.read(content_len)) + if name == '' : + self.send_response(400) + else : + self.send_response(200) + gs_init_instances[name] = 1 + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_SOURCE_URL, self.path) != None: + if self.headers.getheader('content-type') == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'content-length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract endpoint information + endpoint = extract_endpoint(self.rfile.read(content_len)) + if endpoint == [] : + self.send_response(400) + else : + self.send_response(200) + sources[endpoint[0]] = [endpoint[1], endpoint[2]] + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_SINK_URL, self.path) != None: + if self.headers.getheader('content-type') == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'content-length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract endpoint information + endpoint = extract_endpoint(self.rfile.read(content_len)) + if endpoint == [] : + self.send_response(400) + else : + self.send_response(200) + sinks[endpoint[0]] = [endpoint[1], endpoint[2]] + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_STARTPROCESSING_URL, self.path) != None: + if self.headers.getheader('content-type') == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'content-length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract name of initialized gs instance + name = extract_instance_name(self.rfile.read(content_len)) + if name == '' : + self.send_response(400) + else : + self.send_response(200) + gs_startprocessing_instances[name] = 1 + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + # we do not do any processing for ANNOUNCE_STREAM_SUBSCRIPTION, ANNOUNCE_FTA_INSTANCE and ANNOUNCE_METRICS in gshub simulator + elif (re.search(ANNOUNCE_STREAM_SUBSCRIPTION, self.path) != None) or (re.search(ANNOUNCE_FTA_INSTANCE, self.path) != None) or (re.search(ANNOUNCE_METRICS, self.path) != None): + if self.headers.getheader('content-type') == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'content-length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + self.send_response(200) + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + else: + self.send_response(404) + self.end_headers() + return + + def do_GET(self): + if re.search(DISCOVER_INSTANCE_URL + '/*', self.path) != None: + instance = self.path.split('/')[-1] + # check if this instance is registered + if instance in gs_instances : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + gs_instances[instance][0] + "\", \"port\": " + str(gs_instances[instance][1]) + "}")) + else: + self.send_response(400) + self.end_headers() + + + elif re.search(DISCOVER_INITINSTANCE_URL + '/*', self.path) != None: + instance = self.path.split('/')[-1] + # check if this instance is initialized + if instance in gs_init_instances : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + gs_instances[instance][0] + "\", \"port\": " + str(gs_instances[instance][1]) + "}")) + else: + self.send_response(400) + self.end_headers() + + elif re.search(DISCOVER_SOURCE_URL + '/*', self.path) != None: + source = self.path.split('/')[-1] + # check if it is a registered source + if source in sources : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + sources[source][0] + "\", \"port\": " + str(sources[source][1]) + "}")) + else: + self.send_response(400) + self.end_headers() + + elif re.search(DISCOVER_SINK_URL + '/*', self.path) != None: + sink = self.path.split('/')[-1] + # check if it is a registered sink + if sink in sinks : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + sinks[sink][0] + "\", \"port\": " + str(sinks[sink][1]) + "}")) + else: + self.send_response(400) + self.end_headers() + + elif re.search(DISCOVER_STARTPROCESSING_URL + '/*', self.path) != None: + instance = self.path.split('/')[-1] + # check if this instance is initialized + if instance in gs_startprocessing_instances : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{}")) + else: + self.send_response(400) + self.end_headers() + else: + self.send_response(404) + self.end_headers() + return + + +# print usage instructions +def usage(): + print ('./gshub.py [-p port]') + + + +def main(): + # process command-line arguments + try: + opts, args = getopt.getopt(sys.argv[1:], "hp:v", ["help", "port="]) + except getopt.GetoptError as err: + # print help information and exit: + print(str(err)) + usage() + sys.exit(2) + + port = 0 + for o, a in opts: + if o in ("-h", "--help"): + usage() + sys.exit(0) + elif o in ("-p", "--port"): + port = int(a) + else: + print ('Unknown command-line option ' + o) + + # start HTTP server to serve REST calls + server_address = ('127.0.0.1', port) + httpd = HTTPServer(server_address, Server) + + # record HTTP server address in gshub.log + f = open('gshub.log', 'w') + f.write(str(httpd.server_address[0]) + ':' + str(httpd.server_address[1]) + '\n') + f.close() + + print ('GSHUB Running on port ' + str(httpd.server_address[1]) + ' ...') + + httpd.serve_forever() + + +if __name__ == "__main__": + main() diff --git a/bin/gshub3.py b/bin/gshub3.py new file mode 100755 index 0000000..a68a1d7 --- /dev/null +++ b/bin/gshub3.py @@ -0,0 +1,398 @@ +#!/usr/bin/python3.6 + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +# Implementation of GSHUB REST service +# for announcement and discovery of gs instances, sources and sinks + +from http.server import BaseHTTPRequestHandler, HTTPServer +from socketserver import ThreadingMixIn +import threading +import getopt +import sys +import re +import cgi +import socket +import json + +# lis of URLS for all the REST calls we will serve +DISCOVER_INSTANCE_URL = '/v1/discover-instance' +DISCOVER_INITINSTANCE_URL = '/v1/discover-initialized-instance' +DISCOVER_SOURCE_URL = '/v1/discover-source' +DISCOVER_SINK_URL = '/v1/discover-sink' +DISCOVER_STARTPROCESSING_URL = '/v1/discover-start-processing' +ANNOUNCE_INSTANCE_URL = '/v1/announce-instance' +ANNOUNCE_INITINSTANCE_URL = '/v1/announce-initialized-instance' +ANNOUNCE_SOURCE_URL = '/v1/announce-source' +ANNOUNCE_SINK_URL = '/v1/announce-sink' +ANNOUNCE_STARTPROCESSING_URL = '/v1/announce-start-processing' +ANNOUNCE_STREAM_SUBSCRIPTION = '/v1/announce-stream-subscription' +ANNOUNCE_FTA_INSTANCE = '/v1/announce-fta-instance' +ANNOUNCE_METRICS = '/v1/log-metrics' + +# gs instance endpoints +gs_instances = {} + +# initialized gs instances +gs_init_instances = {} + +# instances for which processing started +gs_startprocessing_instances = {} + +# source endpoints +sources = {} + +# sink endpoints +sinks = {} + + +# exctract endpoint information from json data +def extract_endpoint(data) : + name = '' + ip = '' + port = 0 + + try : + doc = json.loads(str(data, 'utf-8')) + except : + print ('Invalid json message ' + str(data, 'utf-8')) + return [] + + for key in doc.keys() : + if key == 'name' : + name = doc[key] + elif key == 'ip' : + ip = doc[key] + # validate ip address + try : + socket.inet_pton(socket.AF_INET, ip) + except : + print ('Invalid IPV4 address ' + ip) + ip = '' + elif key == 'port' : + # validate port number + try : + port = int(doc[key]) + except : + print ('Invalid port number ' + doc[key]) + port = 0 + + if name == '' or ip == '' or port == 0 : + print ('Name, ip or port is missing from json message ' + str(doc)) + return [] + + + return [name, ip, port] + + +# extract instance name from json data +def extract_instance_name(data) : + name = '' + + try : + doc = json.loads(str(data, 'utf-8')) + except : + print ('Invalid json message ' + str(data, "utf-8")) + return '' + + for key in doc.keys() : + if key == 'name' : + name = doc[key] + + if name == '' : + print ('Name field is missing in json message ' + str(doc)) + elif (name in gs_instances) == False: + print ('Attempt to announce the initialization or start of processing for unknown instance ' + name) + name = '' + + return name + +# handler for HTTP requests. We will override do_PORT and do_GET of BaseHTTPRequestHandler +class HTTPRequestHandler(BaseHTTPRequestHandler): + + def do_POST(self): + if re.search(ANNOUNCE_INSTANCE_URL, self.path) != None: + if self.headers.get_content_type() == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'Content-Length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract endpoint information + endpoint = extract_endpoint(self.rfile.read(content_len)) + if endpoint == [] : + self.send_response(400) + else : + self.send_response(200) + gs_instances[endpoint[0]] = [endpoint[1], endpoint[2]] + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_INITINSTANCE_URL, self.path) != None: + if self.headers.get_content_type() == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'Content-Length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract name of initialized gs instance + name = extract_instance_name(self.rfile.read(content_len)) + if name == '' : + self.send_response(400) + else : + self.send_response(200) + gs_init_instances[name] = 1 + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_SOURCE_URL, self.path) != None: + if self.headers.get_content_type() == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'Content-Length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract endpoint information + endpoint = extract_endpoint(self.rfile.read(content_len)) + if endpoint == [] : + self.send_response(400) + else : + self.send_response(200) + sources[endpoint[0]] = [endpoint[1], endpoint[2]] + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_SINK_URL, self.path) != None: + if self.headers.get_content_type() == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'Content-Length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract endpoint information + endpoint = extract_endpoint(self.rfile.read(content_len)) + if endpoint == [] : + self.send_response(400) + else : + self.send_response(200) + sinks[endpoint[0]] = [endpoint[1], endpoint[2]] + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + elif re.search(ANNOUNCE_STARTPROCESSING_URL, self.path) != None: + if self.headers.get_content_type() == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'Content-Length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + # extract name of initialized gs instance + name = extract_instance_name(self.rfile.read(content_len)) + if name == '' : + self.send_response(400) + else : + self.send_response(200) + gs_startprocessing_instances[name] = 1 + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + # we do not do any processing for ANNOUNCE_STREAM_SUBSCRIPTION, ANNOUNCE_FTA_INSTANCE and ANNOUNCE_METRICS in gshub simulator + elif (re.search(ANNOUNCE_STREAM_SUBSCRIPTION, self.path) != None) or (re.search(ANNOUNCE_FTA_INSTANCE, self.path) != None) or (re.search(ANNOUNCE_METRICS, self.path) != None): + if self.headers.get_content_type() == 'application/json' : + # Find content length + content_len = 0 + for i in range(len(self.headers.keys())): + if self.headers.keys()[i] == 'Content-Length' : + content_len = int (self.headers.values()[i]) + break + if content_len != 0 : + self.send_response(200) + else : + self.send_response(400) + + else: + self.send_response(400) + self.end_headers() + + else: + self.send_response(404) + self.end_headers() + return + + def do_GET(self): + if re.search(DISCOVER_INSTANCE_URL + '/*', self.path) != None: + instance = self.path.split('/')[-1] + # check if this instance is registered + if instance in gs_instances : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + gs_instances[instance][0] + "\", \"port\": " + str(gs_instances[instance][1]) + "}", "utf-8")) + else: + self.send_response(400) + self.end_headers() + + + elif re.search(DISCOVER_INITINSTANCE_URL + '/*', self.path) != None: + instance = self.path.split('/')[-1] + # check if this instance is initialized + if instance in gs_init_instances : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + gs_instances[instance][0] + "\", \"port\": " + str(gs_instances[instance][1]) + "}", "utf-8")) + else: + self.send_response(400) + self.end_headers() + + elif re.search(DISCOVER_SOURCE_URL + '/*', self.path) != None: + source = self.path.split('/')[-1] + # check if it is a registered source + if source in sources : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + sources[source][0] + "\", \"port\": " + str(sources[source][1]) + "}", "utf-8")) + else: + self.send_response(400) + self.end_headers() + + elif re.search(DISCOVER_SINK_URL + '/*', self.path) != None: + sink = self.path.split('/')[-1] + # check if it is a registered sink + if sink in sinks : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{\"ip\" : \"" + sinks[sink][0] + "\", \"port\": " + str(sinks[sink][1]) + "}", "utf-8")) + else: + self.send_response(400) + self.end_headers() + + elif re.search(DISCOVER_STARTPROCESSING_URL + '/*', self.path) != None: + instance = self.path.split('/')[-1] + # check if this instance is initialized + if instance in gs_startprocessing_instances : + self.send_response(200) + self.send_header('Content-Type', 'application/json') + self.end_headers() + self.wfile.write(bytes("{}", "utf-8")) + else: + self.send_response(400) + self.end_headers() + else: + self.send_response(404) + self.end_headers() + return + + +# we will use standard python threaded HTTP server +class ThreadedHTTPServer(ThreadingMixIn, HTTPServer): + allow_reuse_address = True + + def shutdown(self): + self.socket.close() + HTTPServer.shutdown(self) + +class SimpleHttpServer: + def __init__(self, ip, port): + self.server = ThreadedHTTPServer((ip,port), HTTPRequestHandler) + + def start(self): + self.server_thread = threading.Thread(target=self.server.serve_forever) + self.server_thread.daemon = True + self.server_thread.start() + + def waitForThread(self): + self.server_thread.join() + + def stop(self): + self.server.shutdown() + self.waitForThread() + + +# print usage instructions +def usage(): + print ('./gshub.py [-p port]') + + + +def main(): + # process command-line arguments + try: + opts, args = getopt.getopt(sys.argv[1:], "hp:v", ["help", "port="]) + except getopt.GetoptError as err: + # print help information and exit: + print(str(err)) + usage() + sys.exit(2) + + port = 0 + for o, a in opts: + if o in ("-h", "--help"): + usage() + sys.exit(0) + elif o in ("-p", "--port"): + port = int(a) + else: + print ('Unknown command-line option ' + o) + + # start HTTP server to serve REST calls + server = SimpleHttpServer('127.0.0.1', port) + + # record HTTP server address in gshub.log + f = open('gshub.log', 'w') + f.write('127.0.0.1:' + str(server.server.server_port) + '\n') + f.close() + + print ('GSHUB Running on port ' + str(server.server.server_port) + ' ...') + server.start() + server.waitForThread() + + +if __name__ == "__main__": + main() + diff --git a/bin/monitor_gs.pl b/bin/monitor_gs.pl new file mode 100755 index 0000000..e42eb85 --- /dev/null +++ b/bin/monitor_gs.pl @@ -0,0 +1,180 @@ +#! /usr/bin/perl + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +use English; + +$interval = 10; +$to_tty = 0; +if(scalar(@ARGV)>0){ + if(int($ARGV[0])>0){ + $interval = int($ARGV[0]); + }else{ + if($ARGV[0] eq '-'){ + $to_tty = 1; + }else{ + print STDERR "Argument 1 ($ARGV[0]) ignored.\n"; + } + } +} +if(scalar(@ARGV)>1){ + if(int($ARGV[1])>0){ + $interval = int($ARGV[1]); + }else{ + if($ARGV[1] eq '-'){ + $to_tty = 1; + }else{ + print STDERR "Argument 2 ($ARGV[1]) ignored.\n"; + } + } +} +if(scalar(@ARGV)>2){ + print STDERR "Only 2 arguments accepted, additional args ignored.\n"; +} + +open O, ">resource_log.csv" or die "Can't open resource_log.csv\n"; + + + +# get the page size +open I,"getconf PAGESIZE |"; +$line=; +chomp($line); +$pagesize = int($line); +close(I); + + +$effective_uid = $REAL_USER_ID; +$ps_cmd = "ps -U $effective_uid |"; + +%hfta_pid=(); + +open P,$ps_cmd; +while($line=

){ + chomp($line); + $line =~ s/^\s+//; + @flds = split /\s+/,$line; + if($flds[3] =~ /rts/){ + push @rts_pids,int($flds[0]); + } + if($flds[3] =~ /hfta_(\d+)/){ + $hfta_pid{$1} = int($flds[0]); + } +} + +$rts_pids = sort {$a<=>$b} @rts_pids; + +$now=time(); +print O "START monitoring at time $now\n"; +print O "ts,proc,pid,utime,stime,vm_size,rss,pagesize\n"; +if(to_tty){ + print "START monitoring at time $now\n"; + print "ts,proc,pid,utime,stime,vm_size,rss,pagesize\n"; +} +#print "RTS PIDs:\n"; +#foreach $p (@rts_pids){ +# print "$p "; +#} +#print "\nHFTA PIDs:\n"; +# foreach $h (sort {$a<=>$b} keys(%hfta_pid)){ +# print "($h,",$hfta_pid{$h},") "; +#} +#print "\n"; + +while(1){ + $now=time(); + foreach $p (@rts_pids){ + get_proc_stats($p); + print O "$now,rts,$p,$user_time,$sys_time,$vm_size,$resident_set_size,$pagesize\n"; + if(to_tty){ + print "$now,rts,$p,$user_time,$sys_time,$vm_size,$resident_set_size,$pagesize\n"; + } + } + foreach $h (sort {$a<=>$b} keys(%hfta_pid)){ + $p=$hfta_pid{$h}; + get_proc_stats($p); + print O "$now,hfta_$h,$p,$user_time,$sys_time,$vm_size,$resident_set_size,$pagesize\n"; + if(to_tty){ + print "$now,hfta_$h,$p,$user_time,$sys_time,$vm_size,$resident_set_size,$pagesize\n"; + } + } + + sleep($interval); +} + + + +sub get_proc_stats{ +my $pid = shift; +my $line; +my @flds; +my $pos; + + +open I_PROC_STATS,"/proc/$pid/stat"; + +$line=; +close I_PROC_STATS; + +#print "getstats($pid): $line\n"; + +chomp($line); +@flds = split / +/,$line; + +$pos=0; +$pid = $flds[$pos]; $pos++; +$fname = $flds[$pos]; $pos++; +$state = $flds[$pos]; $pos++; +$pppid = $flds[$pos]; $pos++; +$pgrp = $flds[$pos]; $pos++; +$session = $flds[$pos]; $pos++; +$tty_n = $flds[$pos]; $pos++; +$tpgid = $flds[$pos]; $pos++; +$flags = $flds[$pos]; $pos++; +$minor_faults = $flds[$pos]; $pos++; +$child_minor_faults = $flds[$pos]; $pos++; +$major_faults = $flds[$pos0]; $pos++; +$child_major_faults = $flds[$pos0]; $pos++; +$user_time = $flds[$pos]; $pos++; +$sys_time = $flds[$pos]; $pos++; +$child_user_time = $flds[$pos]; $pos++; +$child_sys_time = $flds[$pos]; $pos++; +$priority = $flds[$pos]; $pos++; +$nice = $flds[$pos]; $pos++; +$num_threads = $flds[$pos]; $pos++; +$interval_timer_realvalue = $flds[$pos]; $pos++; +$start_time = $flds[$pos]; $pos++; +$vm_size = $flds[$pos]; $pos++; +$resident_set_size = $flds[$pos]; $pos++; +$rss_limit = $flds[$pos]; $pos++; +$startcode = $flds[$pos]; $pos++; +$endcode = $flds[$pos]; $pos++; +$startstack = $flds[$pos]; $pos++; +$curr_kernel_stack_ptr = $flds[$pos]; $pos++; +$curr_instruction_ptr = $flds[$pos]; $pos++; +$signal = $flds[$pos]; $pos++; +$sigblocked = $flds[$pos]; $pos++; +$sigignore = $flds[$pos]; $pos++; +$wchan = $flds[$pos]; $pos++; +$nswap = $flds[$pos]; $pos++; +$exit_signal = $flds[$pos]; $pos++; +$processor = $flds[$pos]; $pos++; +$rt_priority = $flds[$pos]; $pos++; +$policy = $flds[$pos]; $pos++; +$aggr_block_io_delays = $flds[$pos]; $pos++; +$guest_time = $flds[$pos]; $pos++; +$cguest_time = $flds[$pos]; $pos++; +} diff --git a/bin/parse_cpuinfo.pl b/bin/parse_cpuinfo.pl new file mode 100755 index 0000000..61c1bcc --- /dev/null +++ b/bin/parse_cpuinfo.pl @@ -0,0 +1,45 @@ +#! /usr/bin/perl + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +$infl = "/proc/cpuinfo"; +open I,$infl or die "Can't open $infl, exiting.\n"; + +$curr_proc = -1; +$curr_socket = -1; +$curr_coreid = -1; + +while($line=){ + chomp($line); + @flds = split /:/,$line; + if(scalar(@flds)==2){ + if($flds[0] =~ /processor/){ + if($curr_proc != -1){ + print "$curr_proc,$curr_socket,$curr_coreid\n"; + } + $curr_proc = int($flds[1]); + } + if($flds[0] =~ /physical id/){ + $curr_socket = int($flds[1]); + } + if($flds[0] =~ /core id/){ + $curr_coreid = int($flds[1]); + } + } +} +if($curr_proc != -1){ + print "$curr_proc,$curr_socket,$curr_coreid\n"; +} diff --git a/bin/pin_processes.pl b/bin/pin_processes.pl new file mode 100755 index 0000000..4fdbec7 --- /dev/null +++ b/bin/pin_processes.pl @@ -0,0 +1,65 @@ +#! /usr/bin/perl + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + + +$infl = "/var/log/gstrace"; + +if(scalar(@ARGV)>0){ + $infl = $ARGV[0]; +} + +open I,$infl or die "Can't open input log file $infl\n"; + +%rts_pids= (); +%hfta_pids = (); +while($line=){ + if($line =~ /rts:\[.*\]: Started Logging/){ + %rts_pids= (); + %hfta_pids = (); + } + if($line =~ /hfta_(\d+):\[(\d+)\]: Started Logging/){ + $name = "hfta_" . $1; + $hfta_pids{$name} = $2; + } + if($line =~ /rts:\[(\d+)\]: Init LFTAs for (\w+)/){ + $name = "rts " . $2; + $rts_pids{$name} = $1; + } +} + +#foreach $k (keys(%rts_pids)){ +# print "$k, ",$rts_pids{$k},"\n"; +#} +#foreach $k (keys(%hfta_pids)){ +# print "$k, ",$hfta_pids{$k},"\n"; +#} + +open C,"pinning_info.csv" or die "Can't open pinning_info.csv\n"; + +while($line=){ + chomp($line); + @flds = split /,/,$line; + if(exists($rts_pids{$flds[0]})){ + $pinning_cmd = "taskset -pc $flds[1] ". $rts_pids{$flds[0]}; + } + if(exists($hfta_pids{$flds[0]})){ + $pinning_cmd = "taskset -pc $flds[1] ". $hfta_pids{$flds[0]}; + } + print "Executing $pinning_cmd\n"; + system($pinning_cmd); +} + diff --git a/bin/split_trace.pl b/bin/split_trace.pl new file mode 100755 index 0000000..a9f000f --- /dev/null +++ b/bin/split_trace.pl @@ -0,0 +1,36 @@ +#! /usr/bin/perl + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +$outfile_base = "tracefile_"; +$trace_cnt = 0; + +$outfile = $outfile_base . $trace_cnt . ".txt"; +open O,">$outfile"; + +while($line=<>){ + if($line =~ /rts:\[.*\]: Started Logging/){ + close O; + $trace_cnt ++; + $outfile = $outfile_base . $trace_cnt . ".txt"; + open O,">$outfile"; + } + print O $line; +} +close O; + + + diff --git a/bin/start_processing b/bin/start_processing new file mode 100755 index 0000000..3b235cc --- /dev/null +++ b/bin/start_processing @@ -0,0 +1,24 @@ +#!/usr/bin/bash +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +if [ ! -f gshub.log ] +then + echo "Unable to find gshub.log in current directory. Make sure bin/gshub.py is running" + exit -1 +fi +ADDR=`cat gshub.log` +curl -H 'Content-Type: application/json' -d '{"name": "default"}' $ADDR/v1/announce-start-processing + diff --git a/build_and_install.sh b/build_and_install.sh new file mode 100755 index 0000000..d117f41 --- /dev/null +++ b/build_and_install.sh @@ -0,0 +1,19 @@ +#!/bin/sh +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +cd src +make clean; make; make install; +cd .. diff --git a/cfg/cpu_info.csv b/cfg/cpu_info.csv new file mode 100644 index 0000000..d0ab47f --- /dev/null +++ b/cfg/cpu_info.csv @@ -0,0 +1,88 @@ +0,0,0 +1,1,0 +2,0,5 +3,1,5 +4,0,1 +5,1,1 +6,0,4 +7,1,4 +8,0,2 +9,1,2 +10,0,3 +11,1,3 +12,0,8 +13,1,8 +14,0,12 +15,1,12 +16,0,9 +17,1,9 +18,0,11 +19,1,11 +20,0,10 +21,1,10 +22,0,21 +23,1,21 +24,0,16 +25,1,16 +26,0,20 +27,1,20 +28,0,17 +29,1,17 +30,0,19 +31,1,19 +32,0,18 +33,1,18 +34,0,28 +35,1,28 +36,0,24 +37,1,24 +38,0,27 +39,1,27 +40,0,25 +41,1,25 +42,0,26 +43,1,26 +44,0,0 +45,1,0 +46,0,5 +47,1,5 +48,0,1 +49,1,1 +50,0,4 +51,1,4 +52,0,2 +53,1,2 +54,0,3 +55,1,3 +56,0,8 +57,1,8 +58,0,12 +59,1,12 +60,0,9 +61,1,9 +62,0,11 +63,1,11 +64,0,10 +65,1,10 +66,0,21 +67,1,21 +68,0,16 +69,1,16 +70,0,20 +71,1,20 +72,0,17 +73,1,17 +74,0,19 +75,1,19 +76,0,18 +77,1,18 +78,0,28 +79,1,28 +80,0,24 +81,1,24 +82,0,27 +83,1,27 +84,0,25 +85,1,25 +86,0,26 +87,1,26 diff --git a/cfg/example.ifq b/cfg/example.ifq new file mode 100644 index 0000000..f1d4061 --- /dev/null +++ b/cfg/example.ifq @@ -0,0 +1,3 @@ +default : Contains[InterfaceType,GDAT] and Equals[Host,'example']; +csv : Contains[InterfaceType,CSV] and Equals[Host,'example']; +gdat: Contains[InterfaceType,GDAT] and Equals[Host,'example'] diff --git a/cfg/external_fcns.def b/cfg/external_fcns.def new file mode 100644 index 0000000..0bb58f7 --- /dev/null +++ b/cfg/external_fcns.def @@ -0,0 +1,183 @@ + /////////////////////////////////////////////////////////// +// Matching predicates +/////////////////////////////////////////////////////////// + PRED [LFTA_LEGAL, COST HIGH]str_exists_substr[string, string]; + PRED [LFTA_LEGAL, COST HIGH]str_compare[string,string]; + PRED [LFTA_LEGAL, COST LOW] str_match_offset [uint,string,string]; + PRED [LFTA_LEGAL, COST LOW] byte_match_offset [uint,uint,string]; + +/////////////////////////////////////////////////////////// +// MIN/MAX functions +/////////////////////////////////////////////////////////// + + + ullong FUN [LFTA_LEGAL, COST FREE] LLMIN (ullong,ullong); + ullong FUN [LFTA_LEGAL, COST FREE] LLMAX (ullong,ullong); + uint FUN [LFTA_LEGAL, COST FREE] UMIN (uint,uint); + uint FUN [LFTA_LEGAL, COST FREE] UMAX (uint,uint); + + IP FUN [LFTA_LEGAL, COST FREE] UMIN (IP,IP); + IP FUN [LFTA_LEGAL, COST FREE] UMAX (IP,IP); + +/////////////////////////////////////////////////////////// +// Function for regex matching +/////////////////////////////////////////////////////////// + + +uint FUN [LFTA_LEGAL, COST EXPENSIVE] + str_regex_match( string, string HANDLE); + uint FUN [LFTA_LEGAL, COST EXPENSIVE] + str_partial_regex_match( string, string HANDLE, uint); + string FUN [PARTIAL, COST EXPENSIVE] str_extract_regex( string, string HANDLE); + +/////////////////////////////////////////////////////////// +// Truncating strings +/////////////////////////////////////////////////////////// + + string FUN [LFTA_LEGAL,PARTIAL,COST FREE] str_truncate (string, uint); + +/////////////////////////////////////////////////////////// +// Function for casting +/////////////////////////////////////////////////////////// + + int FUN [LFTA_LEGAL,COST FREE] non_temporal(int); + uint FUN [LFTA_LEGAL,COST FREE] non_temporal(uint); + llong FUN [LFTA_LEGAL,COST FREE] non_temporal(llong); + ullong FUN [LFTA_LEGAL,COST FREE] non_temporal(ullong); + + int FUN [LFTA_LEGAL,COST FREE]INT(uint); + int FUN [LFTA_LEGAL,COST FREE]INT(ullong); + int FUN [LFTA_LEGAL,COST FREE]INT(llong); + + uint FUN [LFTA_LEGAL,COST FREE]UINT(int); + uint FUN [LFTA_LEGAL,COST FREE]UINT(ullong); + uint FUN [LFTA_LEGAL,COST FREE]UINT(llong); + uint FUN [LFTA_LEGAL,COST FREE]UINT(IP); + + float FUN [LFTA_LEGAL,COST FREE] FLOAT(llong); + float FUN [LFTA_LEGAL,COST FREE] FLOAT(ullong); + float FUN [LFTA_LEGAL,COST FREE] FLOAT(int); + float FUN [LFTA_LEGAL,COST FREE] FLOAT(uint); + + ullong FUN [LFTA_LEGAL,COST FREE]ULLONG(uint); + ullong FUN [LFTA_LEGAL,COST FREE]ULLONG(int); + + +/////////////////////////////////////////////////////////// +// Convert an IPv4 address +/////////////////////////////////////////////////////////// + + + uint FUN [PARTIAL,COST HIGH] strtoi(string); + IP FUN [PARTIAL,COST HIGH] strtoip(string); + +// for constant strings - faster at runtime + uint FUN [LFTA_LEGAL,COST LOW] strtoi_c(string HANDLE); + IP FUN [LFTA_LEGAL,COST LOW] strtoip_c(string HANDLE); + + +/////////////////////////////////////////////////////////// +// Compute running sum +/////////////////////////////////////////////////////////// + + + + ullong UDAF [RUNNING, SUBAGGR moving_sum_lfta, SUPERAGGR super_moving_sum_udaf ] moving_sum_udaf fstring12 (uint, uint); + + uint EXTR moving_sum moving_sum_udaf moving_sum_extract (uint,uint); + uint FUN [COST LOW] moving_sum_extract(ullong); + + float EXTR moving_sum_exp moving_sum_udaf moving_sum_extract_exp (uint,uint, float); + float FUN [COST LOW] moving_sum_extract_exp(ullong, float); + + ullong UDAF [RUNNING] super_moving_sum_udaf fstring12 (ullong); + ullong UDAF moving_sum_lfta fstring8 (uint, uint); + + +/////////////////////////////////////////////////////////// +// Compute the average of +// all positive numbers +/////////////////////////////////////////////////////////// + + float UDAF POSAVG fstring16(float); + + +/////////////////////////////////////////////////////////// +// Simple average example +/////////////////////////////////////////////////////////// + + float EXTR extr_avg avg_udaf extr_avg_fcn (uint); + float FUN extr_avg_fcn (string); + string UDAF[SUBAGGR avg_udaf_lfta, SUPERAGGR avg_udaf_hfta] avg_udaf fstring12 (uint); + string UDAF avg_udaf_hfta fstring12 (string); + string UDAF avg_udaf_lfta fstring12 (uint); + +/////////////////////////////////////////////////////////// +// SAMPLING +/////////////////////////////////////////////////////////// + + fstring100 STATE smart_sampling_state; + int SFUN packet_count smart_sampling_state (); + float SFUN gamma smart_sampling_state (); + int SFUN do_clean_count smart_sampling_state (); + int SFUN init_threshold smart_sampling_state (); + int SFUN delay smart_sampling_state(); + int SFUN newly_closed smart_sampling_state(); + +/////////////////////////////////////////////////////////// +// Manku Heavy Hitter +/////////////////////////////////////////////////////////// + + + fstring20 STATE manku_hh_state; + BOOL SFUN local_count manku_hh_state (UINT); + int SFUN current_bucket manku_hh_state (); + +/////////////////////////////////////////////////////////// +// FIRST and LAST aggregation funciton +// Should be replaced by builtins +/////////////////////////////////////////////////////////// + + uint UDAF [RUNNING, SUBAGGR FIRST_lfta, SUPERAGGR FIRST_hfta] FIRST uint (uint); + uint UDAF [RUNNING] FIRST_hfta uint (uint); + uint UDAF [RUNNING] FIRST_lfta uint (uint); + + ullong UDAF [RUNNING, SUBAGGR FIRST_ULL_lfta, SUPERAGGR FIRST_ULL_hfta] FIRST ullong (ullong); + ullong UDAF [RUNNING] FIRST_ULL_hfta ullong (ullong); + ullong UDAF [RUNNING] FIRST_ULL_lfta ullong (ullong); + + IP UDAF [RUNNING, SUBAGGR FIRST_lfta, SUPERAGGR FIRST_hfta] FIRST IP (IP); + IP UDAF [RUNNING] FIRST_hfta IP (IP); + IP UDAF [RUNNING] FIRST_lfta IP (IP); + + string UDAF [RUNNING, SUBAGGR FIRST_STR_lfta, SUPERAGGR FIRST_STR_hfta] FIRST string (string); + string UDAF [RUNNING] FIRST_STR_hfta string (string); + string UDAF [RUNNING] FIRST_STR_lfta string (string); + + uint UDAF [RUNNING, SUBAGGR LAST_lfta, SUPERAGGR LAST_hfta] LAST uint (uint); + uint UDAF [RUNNING] LAST_hfta uint (uint); + uint UDAF [RUNNING] LAST_lfta uint (uint); + + ullong UDAF [RUNNING, SUBAGGR LAST_ULL_lfta, SUPERAGGR LAST_ULL_hfta] LAST ullong (ullong); + ullong UDAF [RUNNING] LAST_ULL_hfta ullong (ullong); + ullong UDAF [RUNNING] LAST_ULL_lfta ullong (ullong); + + IP UDAF [RUNNING, SUBAGGR LAST_lfta, SUPERAGGR LAST_hfta] LAST IP (IP); + IP UDAF [RUNNING] LAST_hfta IP (IP); + IP UDAF [RUNNING] LAST_lfta IP (IP); + + string UDAF [RUNNING, SUBAGGR LAST_STR_lfta, SUPERAGGR LAST_STR_hfta] LAST string (string); + string UDAF [RUNNING] LAST_STR_hfta string (string); + string UDAF [RUNNING] LAST_STR_lfta string (string); + +/////////////////////////////////////////////////////////// +// integer array aggregation funciton +// We are going to store 4 values in LFTA in fixed size buffer +// plus one byte for array length (17 bytes total) +// HFTA will combine partial aggregates +/////////////////////////////////////////////////////////// + + string UDAF [RUNNING, SUBAGGR running_array_aggr_lfta, SUPERAGGR running_array_aggr_hfta] running_array_aggr string (uint); + string UDAF [RUNNING] running_array_aggr_hfta string (string); + string UDAF [RUNNING] running_array_aggr_lfta fstring17 (uint); + \ No newline at end of file diff --git a/cfg/field_list.xml b/cfg/field_list.xml new file mode 100644 index 0000000..0373edd --- /dev/null +++ b/cfg/field_list.xml @@ -0,0 +1,3 @@ + + + diff --git a/cfg/ifres.xml b/cfg/ifres.xml new file mode 100644 index 0000000..6196c10 --- /dev/null +++ b/cfg/ifres.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/cfg/internal_fcn.def b/cfg/internal_fcn.def new file mode 100644 index 0000000..dff17b1 --- /dev/null +++ b/cfg/internal_fcn.def @@ -0,0 +1,85 @@ + +Add_Int_Timeval +static struct timeval Add_Int_Timeval(int inc, struct timeval t){ + struct timeval r; + r.tv_usec = t.tv_usec + (inc % 1000); + r.tv_sec = t.tv_sec + inc / 1000; + if(r.tv_usec > 999){ + r.tv_usec -= 1000; + r.tv_sec++; + } + return(r); +} + +Add_Timeval_Int +static struct timeval Add_Timeval_Int(struct timeval t, int inc){ + struct timeval r; + r.tv_usec = t.tv_usec + (inc % 1000); + r.tv_sec = t.tv_sec + inc / 1000; + if(r.tv_usec > 999){ + r.tv_usec -= 1000; + r.tv_sec++; + } + return(r); +} + +Subtract_Timeval_Int +static struct timeval Subtract_Timeval_Int(struct timeval t, int inc){ + struct timeval r; + r.tv_usec = t.tv_usec - (inc % 1000); + r.tv_sec = t.tv_sec - inc / 1000; + if(r.tv_usec < 0){ + r.tv_usec += 1000; + r.tv_sec--; + } + return(r); +} + +Divide_Timeval_Int +static struct timeval Divide_Timeval_Int(struct timeval t, int d){ + struct timeval r; + r.tv_sec = t.tv_sec / d; + r.tv_usec = (t.tv_usec + 1000*( t.tv_sec % d )) / d; + return(r); +} + + +Subtract_Timeval_Timeval +static int Subtract_Timeval_Timeval(struct timeval t1, struct timeval t2){ + return(1000*(t1.tv_sec - t2.tv_sec) + (t1.tv_usec - t2.tv_usec) ); +} + +Compare_Timeval +static int Compare_Timeval(struct timeval t1, struct timeval t2){ + return( t1.tv_sec != t2.tv_sec ? t1.tv_sec - t2.tv_sec : t1.tv_usec - t2.tv_usec ); +} + +Timeval_Constructor +static struct timeval Timeval_Constructor(int s, int m){ + struct timeval r; + r.tv_sec = s; + r.tv_usec = m; + return(r); +} + +String_Constructor +static struct gs_string String_Constructor(char *l){ + struct gs_string s; + s.data = l; + s.owner = NULL; + s.length = 0; + while(l[s.length] != '\0') s.length++; + return(s); +} + +Compare_String + +str_assign_with_copy + +str_assign_with_copy_in_tuple + +str_replace + +str_length + +str_destroy diff --git a/cfg/localhost.ifq b/cfg/localhost.ifq new file mode 100644 index 0000000..683ba2d --- /dev/null +++ b/cfg/localhost.ifq @@ -0,0 +1,4 @@ +default : Contains[InterfaceType,GDAT] and Equals[Host,'localhost']; +csv : Contains[InterfaceType,CSV] and Equals[Host,'localhost']; +csvtcp : Contains[InterfaceType,CSVTCP] and Equals[Host,'localhost']; +gdat: Contains[InterfaceType,GDAT] and Equals[Host,'localhost'] diff --git a/cfg/packet_schema.txt b/cfg/packet_schema.txt new file mode 100644 index 0000000..5634820 --- /dev/null +++ b/cfg/packet_schema.txt @@ -0,0 +1,36 @@ +PROTOCOL base{ + uint systemTime get_system_time (low_cardinality,required,increasing, snap_len 0); +} + +PROTOCOL CSV_EXAMPLE (base) { + uint uintInPosition1 get_csv_uint_pos1; + ullong ullongInPosition2 get_csv_ullong_pos2; + IP ipInPosition3 get_csv_ip_pos3; + IPV6 ipv6InPosition4 get_csv_ipv6_pos4; + string stringInPosition5 get_csv_string_pos5; + bool boolInPosition6 get_csv_bool_pos6; + int intInPosition7 get_csv_int_pos7; + llong llongInPosition8 get_csv_llong_pos8; + float floatInPosition9 get_csv_float_pos9; +} + + +PROTOCOL CSV_TCPEXAMPLE (base) { + uint ivalue get_csv_uint_pos1 (increasing); + uint value get_csv_uint_pos2; +} + +PROTOCOL GDAT_EXAMPLE (base) { + uint uintOldTime get_gdat_uint_pos1; + uint uintInPosition1 get_gdat_uint_pos2; + ullong ullongInPosition2 get_gdat_ullong_pos3; + IP ipInPosition3 get_gdat_ip_pos4; + IPV6 ipv6InPosition4 get_gdat_ipv6_pos5; + string stringInPosition5 get_gdat_string_pos6; + bool boolInPosition6 get_gdat_bool_pos7; + int intInPosition7 get_gdat_int_pos8; + llong llongInPosition8 get_gdat_llong_pos9; + float floatInPosition9 get_gdat_float_pos10; +} + + diff --git a/include/README.md b/include/README.md new file mode 100644 index 0000000..8935956 --- /dev/null +++ b/include/README.md @@ -0,0 +1,17 @@ +This directory contains the include files required by the SQL compiler + +## License and Trademarks + +Copyright 2014 Cask Data, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); you may not +use this file except in compliance with the License. You may obtain a copy of +the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +License for the specific language governing permissions and limitations under +the License. \ No newline at end of file diff --git a/include/app.h b/include/app.h new file mode 100644 index 0000000..d9967e3 --- /dev/null +++ b/include/app.h @@ -0,0 +1,106 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +/* + * app.h: interface for applications + */ +#ifndef APP_H +#define APP_H + + +#include "fta.h" +#include "lapp.h" + +/* HIGH LEVEL APPLICATION INTERFACE */ +/* ================================ */ + + + + +/* will call hostlib_init using the specified ringbuffer size + */ +gs_retval_t ftaapp_init(gs_uint32_t bufsz); + +/* this should be used before exit() to make sure everything gets + cleaned up + */ +gs_retval_t ftaapp_exit(); + +/* adds an FTA by key returns unique streamid which can be used to reference FTA*/ + +/* reuse: + if reuse is set to 0, only FTA information will be returned + if reuse is set to 1, instance will be returned provided there is an + instance that is marked as reusable by fta/app who instantiated it + */ + +/* reusable: + if reusable is 0, new instance will be created and it will be marked as + non-reusable regardless of how reuse flag is set by query writer + + if reusable is 1, new instance will be created and it will be marked as + reusable regardless of how reuse flag is set by query writer + + if reusable is set to 2. new instance will be created with reusability flag + matching the reusability flag of the query being instantiated + */ + +FTAID ftaapp_add_fta(FTAname name, gs_uint32_t reuse, gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data); + +/* adds an FTA by key returns unique streamid which can be used to reference + FTA. This FTA does not produce any local data. Instead it generates a + compressed outpufile in gdat format. The path specifies the directory + the file will be put in. base specifies the base part of the name + the will be prepented to the name and gdat.gz + will be appended. The temporal field needs to be specified which + can be an uint, int, ullong or llong. The delta is an integer defining how + much the temoral value has to change before a new file is generated. + The same ftaapp_remote_fta function is used to remove these FTAs. + */ +FTAID ftaapp_add_fta_print(FTAname name, gs_uint32_t reuse, gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, + void * data, gs_sp_t path, + gs_sp_t basename, gs_sp_t temporal_field, gs_sp_t split_field, + gs_uint32_t delta, gs_uint32_t split); + +/* get the schema handle definition for the FTA associated with the streamid + the returned handle will be freed by the app library when the corresponding + fta is removed + */ +gs_schemahandle_t ftaapp_get_fta_schema(FTAID f); + +/* get a schema handle definition for the FTA associated with the FTA name + this handle has to be freed by the caller using the schema interface */ +gs_schemahandle_t ftaapp_get_fta_schema_by_name(gs_sp_t name); + +/* get an ascii representation of the schema definition + for the FTA associated with the FTA name. The ascii representation + is stored in a static buffer. The value will therefore change + after subsequent calls to this function and the function is not + multithread safe.*/ +gs_sp_t ftaapp_get_fta_ascii_schema_by_name(gs_sp_t name); + +/* control operations keyed of one to one mapping of stream id */ +gs_retval_t ftaapp_control(FTAID f, gs_int32_t command, gs_int32_t sz, void * data); + +/* remove FTA keyed of stream id */ +/* if recursive is true the children of f will get removed too */ +gs_retval_t ftaapp_remove_fta(FTAID f, gs_uint32_t recursive); + +/* same as sgroup_get_buffer just repeated to have a complet ftapp interface */ +gs_retval_t ftaapp_get_tuple(FTAID * f, gs_uint32_t * size, void *tbuffer, + gs_int32_t tbuf_size, gs_int32_t timeout); + +#endif diff --git a/include/byteswap.h b/include/byteswap.h new file mode 100644 index 0000000..31b4e90 --- /dev/null +++ b/include/byteswap.h @@ -0,0 +1,54 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef BYTESWAP_H +#define BYTESWAP_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "gsconfig.h" +#include "gstypes.h" + + + gs_uint16_t gscpbswap16(gs_uint16_t); + gs_uint32_t gscpbswap32(gs_uint32_t); + gs_uint64_t gscpbswap64(gs_uint64_t); + +#ifdef __cplusplus +} +#endif + +#undef ntohl +#undef ntohs +#undef htons +#undef htonl +#undef htonll +#undef ntohll + + +#define ntohs(x) gscpbswap16((gs_uint16_t)(x)) +#define ntohl(x) gscpbswap32((gs_uint32_t)(x)) +#define ntohll(x) gscpbswap64((gs_uint64_t)(x)) +#define htons(x) gscpbswap16((gs_uint16_t)(x)) +#define htonl(x) gscpbswap32((gs_uint32_t)(x)) +#define htonll(x) gscpbswap64((gs_uint64_t)(x)) + +/* do nothing fo floating point numbers */ +#define htonf(x) (x) +#define ntohf(x) (x) + + +#endif diff --git a/include/clearinghouseregistries.h b/include/clearinghouseregistries.h new file mode 100644 index 0000000..8c66c9b --- /dev/null +++ b/include/clearinghouseregistries.h @@ -0,0 +1,64 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef CLEARINGHOUSEREGISTRIES_H +#define CLEARINGHOUSEREGISTRIES_H + +#include "fta.h" +#include "systat.h" +#include "fta_stat.h" + +/* The table is used to maintain the location information + * of FTAs within the clearinghouse it is not used outherwise + * Behaviour is undefined if the same name + * is registered more then once. + */ + +/* These functions are used for both FTAs and instances of FTAs + * if ftaid.streamid == 0 then the function is called for a FTA + * if not it is called for an FTA instance. + * if an FTA is registered reusable must be set to 1 + * if an FTA instance is registered reusable is either set to + * 0 or 1 depending if the fta can be reused + * if reuse is set to 1 an existing instance is returned + * if reuse is set to 0 the FTA and not an instance is returned + */ + +/* Adds a FTA to the lookup table if FTAID schema */ +gs_retval_t ftalookup_register_fta(FTAID subscriber, + FTAID ftaid, + FTAname name, + gs_uint32_t reusable, + gs_csp_t schema); + +/* Removes the FTA from the lookup table */ +gs_retval_t ftalookup_unregister_fta(FTAID subscriber, + FTAID ftaid); + +/* Looks an FTA up by name */ +gs_retval_t ftalookup_lookup_fta_index(FTAID caller, + FTAname name, + gs_uint32_t reuse, + FTAID * ftaid, + gs_csp_t * schema); + +/* Gets called when a consumer stoped receiving data */ + +gs_retval_t ftalookup_producer_failure(FTAID caller,FTAID producer); + +/* Gets called when a FTA sends a heart beat */ + +gs_retval_t ftalookup_heartbeat(FTAID caller, gs_uint64_t trace_id, + gs_uint32_t sz, fta_stat * trace ); +#endif diff --git a/include/filter.h b/include/filter.h new file mode 100644 index 0000000..9fe1141 --- /dev/null +++ b/include/filter.h @@ -0,0 +1,46 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + * filter.h: hash table function which match the interface + */ +#ifndef FILTER_H +#define FILTER_H + +/* FILTER FUNCTIONS */ +/* =============== */ + +/* The following functions are used to manage filter sets for flow + and connection filters +*/ + +struct filter { + gs_uint32_t size; + gs_uint8_t data[1]; +}; + +struct filter * ftafilter_create(gs_int32_t size); +void ftafilter_delete(struct filter * filter); +void ftafilter_add_flow ( struct filter * filter, gs_uint32_t ip, gs_uint32_t port); +void fyafilter_add_connection ( struct filter * filter, gs_uint32_t ip1, + gs_uint32_t port1, gs_uint32_t ip2, gs_uint32_t port2); +void ftafilter_rm_flow ( struct filter * filter, gs_uint32_t ip, gs_uint32_t port); +void ftafilter_rm_connection ( struct filter * filter, gs_uint32_t ip1, + gs_uint32_t port1, gs_uint32_t ip2, gs_uint32_t port2); +struct vstring * ftafilter_to_vstring(struct filter * f ); +void ftafilter_vstring_free(struct vstring * res); + + +#endif diff --git a/include/fta.h b/include/fta.h new file mode 100644 index 0000000..670090b --- /dev/null +++ b/include/fta.h @@ -0,0 +1,189 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +/* + * fta.h: fta definition for applications + */ +#ifndef FTA_H +#define FTA_H + +#include "gslog.h" +#include "gsconfig.h" + +typedef struct FTAID { + gs_uint32_t ip; /* identifies the node */ + gs_uint32_t port; /* identifies a process */ + gs_uint32_t index; /* the index identifies a particular FTA in the process */ + gs_p_t streamid; /* streamid if set identifies an instance */ +} FTAID; + + + +typedef struct PRINTFUNC { + gs_sp_t header; + gs_sp_t path; + gs_sp_t basename; + FILE * fa[MAXPRINTFILES]; + gs_uint32_t nexttime; + gs_uint32_t split; + gs_uint32_t base; + gs_uint32_t itt; + gs_uint32_t delta; + gs_schemahandle_t schemaid; + gs_int32_t split_field; + gs_int32_t temporal_field; + gs_int32_t in_use; +} PRINTFUNC; + +/* the following defines define the FTA commands */ + +#define FTA_COMMAND_LOAD_PARAMS 1 +#define FTA_COMMAND_FLUSH 2 +#define FTA_COMMAND_GET_TEMP_STATUS 3 +#define FTA_COMMAND_SET_SAMPLING_RATE 4 +#define FTA_COMMAND_FILE_DONE 5 + +typedef gs_csp_t FTAname; + +typedef gs_csp_t DEVname; + +#define DEFAULTDEV 0 + +// Use gs_param_handle_t defined in gscpv3/include/gstypes.h instead +// typedef gs_uint32_t param_handle_t; + +struct FTA { + + /* reference counts managed by the RTS */ + gs_uint32_t refcnt; + gs_uint32_t runrefcnt; + + /* the ID gets filled in by the runtime system */ + FTAID ftaid; + + /* indicates if the FTA instance can be reused. Set by FTA 0 indicates + * that it can not be reused. + */ + gs_uint32_t reusable; + + /* ftaids the HFTA is subscribed to*/ + FTAID stream_subscribed[64]; + + /* number of valid entries in stream_subscribe [0..stream_subscribed_cnt-1] */ + gs_uint32_t stream_subscribed_cnt; + + /* State needed to print directly to a file out of a HFTA */ + + PRINTFUNC printfunc; + + /* value of prefilter only used in lftas */ + gs_uint64_t prefilter; + + /* allocates and initializes a paramterized instance of a FTA + */ + struct FTA * (*alloc_fta) (FTAID ftaid, gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * value ); + + /* release all resources associated with FTA (including the FTA) */ + gs_retval_t (*free_fta) (struct FTA *, gs_uint32_t recursive); + + /* send control data from host to an instance of an FTA, may return status */ + gs_retval_t (*control_fta) (struct FTA *, gs_int32_t command, gs_int32_t sz, void * value); + + /* gets called once every second. Might be delayed until the current thread execution + * returns into the run time system. If delayed for more then 1 second then only one + * call will be made at the next oportunity. + */ + gs_retval_t (*clock_fta) (struct FTA *); + + /* + * process a packet received on the interface or a tuple received from + * another FTA. If ftaid is 0 then packet is of + * type struct packet otherwise it is a tuple as defined by the + * ftaid. + */ + gs_retval_t (*accept_packet)(struct FTA *, FTAID * f, void * packet, gs_int32_t sz); +}; + +/* The following definitions are used or provided in automatically generated files */ + +typedef struct FTA * (*alloc_fta) (FTAID ftaid, gs_uint32_t reusable, +gs_int32_t command, gs_int32_t sz, void * value ) ; + + +/* FTA INTERFACE */ +/* ============== */ +/* These functions are used by FTAs in addition to the LOW and HIGH + * level application interface functions. + */ + +/* start_service is called to process requests from the message queue + which would invoke callback functions registered by fta_register. + Number indicates how many seconds should be waited before the + function returns. If number < 0 then the function is an endless + loop (should be used for HFTA) if the number == 0 all currently + outstanding requests are processed before the function returns. + */ +gs_retval_t fta_start_service(gs_int32_t number); + +/* the dev name indicates on which device the FTA is supposed to execute. + * HFTA should always use DEFAULTDEV and a snaplen of -1 + */ +FTAID fta_register(FTAname name, gs_uint32_t reusable, DEVname device, + alloc_fta fta_alloc_functionptr, gs_csp_t schema,gs_int32_t snaplen, + gs_uint64_t prefilter); + +gs_retval_t fta_unregister(FTAID f); + + +/* + * get the maximum snap length of all ftas registered within the current proccess + */ + +gs_retval_t fta_max_snaplen(); + +/* + * Post a tupple back to the clearing house This tuple cannot + * use the lfta tuple allocation functions. NOTE: post tuple will + * return -1 if at least one ringbuffer for that FTA which is in the atomic + * set has not enought space. Otherwise 0 is returned. + */ +gs_retval_t hfta_post_tuple(struct FTA * self, gs_int32_t sz, void *tuple); + +/* the following function fills in the FTAID array r with the FTAIDs of processes receiving + * tuplese from the FTA specified in f. The space array indicates how many tuples of tuplesz + * can still fit in the ringbuffer corresponding to the FTAID of the process with the same index + * in r. The return values indicates how many ring buffers are valid in r. szr indicates the memory + * length (in elements) of r and space. The function will fill at most szr elements into these array. + * If the return value is larger then szr it is an indication that not enough memory in r and space + * were provided to hold all results. A return value of -1 indicates an error. + */ + +gs_retval_t hfta_get_ringbuf_space(struct FTA * f, FTAID * r, gs_int32_t* space, gs_int32_t szr, gs_int32_t tuplesz); + + +/* the following function can be used to put a ringbuffer to a process identified by the FTAID + * process into one of the following 3 modes. ATOMIC makes the ringbuffer part of the atomic set. + * A post to the atomic set either succeed or fails entirely. BESTEFFORT is the besteffort set + * posts to BESTEFFORT ringbuffers might fail quitely. SUSPEND will prevent any tuples of being + * posted to that proccess from the specified FTA. + */ + +#define HFTA_RINGBUF_ATOMIC 1 +#define HFTA_RINGBUF_BESTEFFORT 2 +#define HFTA_RINGBUF_SUSPEND 3 + +gs_retval_t hfta_set_ringbuf_type(struct FTA * f, FTAID process, gs_int32_t state); + +#endif diff --git a/include/fta_stat.h b/include/fta_stat.h new file mode 100644 index 0000000..66dbb94 --- /dev/null +++ b/include/fta_stat.h @@ -0,0 +1,35 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef FTA_STAT_H +#define FTA_STAT_H + +/* statiss are collected by FTAs and regularly sent to cluster manager (currently every 1 sec) + * Statistics refers to time interval since the last time statistics was reported */ +typedef struct fta_stat { + FTAID ftaid; + gs_uint32_t in_tuple_cnt; /* # of tuples received */ + gs_uint32_t out_tuple_cnt; /* # of tuples produced */ + gs_uint32_t out_tuple_sz; /* bytes in produced tuples */ + gs_uint32_t accepted_tuple_cnt; /* # of tuples that passed initial unpacking and selection predicate */ + gs_uint64_t cycle_cnt; /* # of cpu cycles spent in accept_tuple */ + gs_uint32_t collision_cnt; /* # of collisions in an aggregation hash table */ + gs_uint32_t eviction_cnt; /* # of collisions in an aggregation hash table */ + gs_float_t sampling_rate; /* sampling rate used by fta */ + + /* ...will add more fields in the future... */ +} fta_stat; + +#endif /* FTA_STAT_H */ diff --git a/include/gsconfig.h b/include/gsconfig.h new file mode 100644 index 0000000..73ad9b8 --- /dev/null +++ b/include/gsconfig.h @@ -0,0 +1,206 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef GSCONFIG +#define GSCONFIG + +// Contains all defines etc... . As we don't have a proper configure script yet at least that way all the defines are in one place. + +// ================================================== +// General defines +// ================================================== + + +// if set we use 64 BIT GS +#define GS64 + +// HOST NAME LENGTH FOR LOGGING +#ifndef HOST_NAME_MAX +#define HOST_NAME_MAX 255 +#endif + +// STATISTICS LOGGING INTERVAL IN SECONDS +#define GSLOGINTERVAL 10 + +// Start size of dynamiclly growing internal arrays +// TODO: current implementation penalizes large initial size of the array with slow linear search, change the size to 1 for now +#define STARTSZ 1 // T1024 + +// Use blocking ringbuffer +#define BLOCKRINGBUFFER + +//#define LOCALIP // restricts sockets to localhost IP + + +// maximume number of print streams +#define MAXPRINTFILES 16 + +// allows sampling on the schema level +//#define LOWSAMPLE 0 + +// if defined outputs logs larger then that level to stderr +#define LOGSTDERR LOG_WARNING + + +// ================================================== +// Callback stuff +// ================================================== + +// If POLLING is defined HFTA's poll the ring buffers every 100msec rather then +// block on a message receive +#define POLLING + + +// ================================================== +// LAP stuff +// ================================================== + +// ================================================== +// Tool stuff +// ================================================== + +// BLOCK size for gdatcat +#define CATBLOCKSZ 200*1024*1024 + +// Enables bzip2 compression rather then gzip compression in gsgdatprint +//#define GSBZIP2 + +// Uses the gzip library rather then forking a gzip process in gsgdaprint +//#define ZLIB + + +// ================================================== +// IPC stuff +// ================================================== + +#define MAXMSGSZ 10240 +#define MAXTUPLESZ 10240 +#define MAXRES MAXMSGSZ + +#define MAXSZ (((MAXTUPLESZ+128)>MAXMSGSZ?MAXTUPLESZ+128:MAXMSGSZ)) + +#define SOCK_BUF_SZ 160*(MAXMSGSZ+4) +#define SOCKET_HASH_SZ 512 +#define MAX_NUMBER_OF_SHM 64 + +//#define PRINTMSG // prints low level IPC messages for debugging VERY VERBOSE + +/* maximum size of an FTA name */ +#define MAXFTANAME 256 +#define MAXPRINTSTRING 256 + +/* maximum size of a schema definition */ +#define MAXSCHEMASZ (8*1024) + + +// ================================================== +// DAG related defines +// ================================================== + +#define DAGMAXPACKETSZ 2*4096 +#define DAGTIMEOUT 50 /* timeout in msec */ + +/* GPP record type defines has to match dagapi.h*/ +#ifndef TYPE_LEGACY +#define TYPE_LEGACY 0 +#define TYPE_HDLC_POS 1 +#define TYPE_ETH 2 +#define TYPE_ATM 3 +#define TYPE_AAL5 4 +#endif + +/* GSCP special types */ +#define TYPE_PPP_POS 5 +#define TYPE_ETH_PPP 6 +#define TYPE_CRS1_OC768_POS 7 +#define TYPE_ETH_VPLS_GRE 8 +#define TYPE_ETH_GTP 9 + +//#define DAGDEBUG + +//#define LLDUPREM + +//#define GTPONLY // then only the GTP parsing code gets compiled which saves a couple of milion cycles at high speeds. + +//#define DOUBLEHASH + +#define VMETR // detailed RTS stats + +#define DAGPOSCONFIGSTRING "" +#define DAGETHCONFIGSTRING "" +#define DAGATMAAL5CONFIGSTRING "" + +// ================================================== +// PCAP stuff +// ================================================== + + +#define PCAPTIMEOUT 50 /* timeout in msec for calls to pcap_process_packets */ +#define PCAPMAXPACKETSZ 1560 +#define PCAPBATCHSZ 1000 +#define PCAPMINBATCHSZ 30 + +// ================================================== +// REPLAY stuff +// ================================================== + +#define PCAPINITDELAY 120 /* time we wait before processing packets */ +#define PCAPREPLAYBATCHSZ 1 +//#define REPLAYNOW // if defined timestamps in pcap file are ignored + +// ================================================== +// system stuff +// ================================================== + +#ifdef sun // make sure the code which uses variables with the name sun +// still works on a sun .... +#undef sun +#endif + +#ifndef AF_LOCAL +#ifdef AF_UNIX +#define AF_LOCAL AF_UNIX +#endif +#endif + +#ifndef SUN_LEN +#define SUN_LEN(su) \ +(sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path)) +#endif + +#ifdef __linux__ +#include +#endif +#ifndef IPC_RALL +#define IPC_RALL 000444 /* read permission */ +#endif +#ifndef IPC_WALL +#define IPC_WALL 000222 /* write/alter permission */ +#endif +#ifndef IPC_R +#define IPC_R 000400 /* read permission */ +#endif +#ifndef IPC_W +#define IPC_W 000200 /* write/alter permission */ +#endif +#ifndef IPC_CREAT +#define IPC_CREAT 001000 /* create entry if key does not exist */ +#endif + +#ifndef ENOMSG +#define ENOMSG EAGAIN /* for MacOSX */ +#endif + +#endif + diff --git a/include/gshub.h b/include/gshub.h new file mode 100644 index 0000000..cc3a6a9 --- /dev/null +++ b/include/gshub.h @@ -0,0 +1,107 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + /* + * gshub.h: interface to GSHUB to announce and discover gs instances, sources and sinks + */ + +#ifndef GSHUB_H +#define GSHUB_H + +#include "gstypes.h" +#include "fta.h" +#include "fta_stat.h" + +#define DISCOVER_INSTANCE_URL "/v1/discover-instance" +#define DISCOVER_INITINSTANCE_URL "/v1/discover-initialized-instance" +#define DISCOVER_SOURCE_URL "/v1/discover-source" +#define DISCOVER_SINK_URL "/v1/discover-sink" +#define DISCOVER_STARTPROCESSING_URL "/v1/discover-start-processing" +#define ANNOUNCE_INSTANCE_URL "/v1/announce-instance" +#define ANNOUNCE_INITINSTANCE_URL "/v1/announce-initialized-instance" +#define ANNOUNCE_SOURCE_URL "/v1/announce-source" +#define ANNOUNCE_SINK_URL "/v1/announce-sink" +#define ANNOUNCE_STARTPROCESSING_URL "/v1/announce-start-processing" +#define ANNOUNCE_STREAM_SUBSCRIPTION "/v1/announce-stream-subscription" +#define ANNOUNCE_FTA_INSTANCE "/v1/announce-fta-instance" +#define ANNOUNCE_METRICS "/v1/log-metrics" + +typedef struct { + gs_uint32_t ip; + gs_uint16_t port; +} endpoint; + + +#ifdef __cplusplus +extern "C" { +#endif + +/* saving and retrival of gshub endpoint */ +gs_retval_t set_hub(endpoint gshub); +gs_retval_t get_hub(endpoint* gshub); + +/* savinf and retrieving instance name */ +gs_retval_t set_instance_name(gs_sp_t instancename); +gs_sp_t get_instance_name(); + +/* Discover gs instance endpoint by name. + * Return value of 0 indicates success. If blocking mode is used return value > 0 indicates that retry is needed. Return value < 0 indicates an error. */ +gs_retval_t get_instance(endpoint gshub, gs_sp_t instance_name, endpoint* instance, gs_bool_t block); + +/* Discover initialized gs instance endpoint by name. + * Return value of 0 indicates success. If blocking mode is used return value > 0 indicates that retry is needed. Return value < 0 indicates an error. */ +gs_retval_t get_initinstance(endpoint gshub, gs_sp_t instance_name, endpoint* instance, gs_bool_t block); + +/* Discover stream source endpoint by name. + * Return value of 0 indicates success. If blocking mode is used return value > 0 indicates that retry is needed. Return value < 0 indicates an error. */ +gs_retval_t get_streamsource(endpoint gshub, gs_sp_t source_name, endpoint* source, gs_bool_t block); + +/* Discover stream sink endpoint by name. + * Return value of 0 indicates success. If blocking mode is used return value > 0 indicates that retry is needed. Return value < 0 indicates an error. */ +gs_retval_t get_streamsink(endpoint gshub, gs_sp_t sink_name, endpoint* sink, gs_bool_t block); + +/* Discover if an isntance should start processing + * Return value of 0 indicates success. If blocking mode is used return value > 0 indicates that retry is needed. Return value < 0 indicates an error. */ +gs_retval_t get_startprocessing(endpoint gshub, gs_sp_t instance_name, gs_bool_t block); + +/* Announce gs instance endpoint to gshub. Return value of 0 indicates success. */ +gs_retval_t set_instance(endpoint gshub, gs_sp_t instance_name, endpoint instance); + +/* Announce initialized gs instance endpoint to gshub. Return value of 0 indicates success. */ +gs_retval_t set_initinstance(endpoint gshub, gs_sp_t instance_name); + +/* Announce stream source endpoint to gshub. Return value of 0 indicates success. */ +gs_retval_t set_streamsource(endpoint gshub, gs_sp_t source_name, endpoint source); + +/* Announce stream source endpoint to gshub. Return value of 0 indicates success. */ +gs_retval_t set_streamsink(endpoint gshub, gs_sp_t sink_name, endpoint sink); + +/* Announce to gshub that an instance can start processin. Return value of 0 indicates success. */ +gs_retval_t set_startprocessing(endpoint gshub, gs_sp_t instance_name); + +/* Announce stream subscription to gshub. Return value of 0 indicates success. */ +gs_retval_t set_streamsubscription(endpoint gshub, gs_sp_t instance_name, gs_sp_t sink_name); + +/* Announce new fta instantiation to gshub. Return value of 0 indicates success. */ +gs_retval_t set_ftainstance(endpoint gshub, gs_sp_t instance_name, gs_sp_t ftainstance_name, FTAID* id); + +/* Announce fta instance stats to gshub. Return value of 0 indicates success. */ +gs_retval_t set_instancestats(endpoint gshub, gs_sp_t instance_name, fta_stat* stats); + +#ifdef __cplusplus +} +#endif + +#endif /* GSHUB_H */ diff --git a/include/gslog.h b/include/gslog.h new file mode 100644 index 0000000..827af28 --- /dev/null +++ b/include/gslog.h @@ -0,0 +1,102 @@ + /*------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + * gslog.h: syslog wrappers for GS-lite + */ +#ifndef GSLOG_H +#define GSLOG_H + + +#include "unistd.h" +#include "sys/syslog.h" +#include "stdio.h" +#include "stdlib.h" +#include "string.h" +#include "stdarg.h" +#include "time.h" +#include "gsconfig.h" +#include "gstypes.h" + +#ifdef LOGSTDERR +static inline void gslog(int loglevel, const char * format, ...) { + va_list args; + va_start(args, format); + if (loglevel >= LOG_WARNING) { + vfprintf(stdout, format, args); + // Not generally syslog messages do not contain a \n so we need to add one for stdout/stderr + fprintf(stdout, "\n"); + fflush(stdout); + } else { + //STDERR is not-buffered by default. + vfprintf(stderr, format, args); + fprintf(stderr, "\n"); + } + va_end(args); +} + +static inline void gsopenlog(gs_sp_t p) { + return; +} + +#else + +#define gslog syslog + +#ifndef LOG_EMERG +#define LOG_EMERG 7 +#endif + +// some state used for reporting + +extern gs_uint64_t intupledrop; +extern gs_uint64_t outtupledrop; +extern gs_uint64_t intuple; +extern gs_uint64_t outtuple; +extern gs_uint64_t inbytes; +extern gs_uint64_t outbytes; +extern gs_uint64_t cycles; + + +static inline void gsopenlog(gs_sp_t p) { + gs_int8_t c[HOST_NAME_MAX+1]; + gs_int8_t t[HOST_NAME_MAX+1+1000]; + gs_sp_t t2; + if (gethostname(&c[0],HOST_NAME_MAX+1)!=0) { + fprintf(stderr,"GSCPV1::ERROR:could not get hostname\n"); + exit(1); + } + c[HOST_NAME_MAX]=0; + sprintf(t,"GSCPv2:%s:%s:",c,p); + t2=strdup(t); + openlog(t2,LOG_NOWAIT|LOG_PID|LOG_CONS,LOG_LOCAL5); + gslog(LOG_INFO,"Started Logging"); + intupledrop=0; + outtupledrop=0; + intuple=0; + outtuple=0; + inbytes=0; + outbytes=0; + cycles=0; +} +#endif + +static inline void gsstats() { + gs_uint32_t t; + //t=time(0); + //gslog(LOG_NOTICE,"STATS|%u|%llu|%llu|%llu|%llu|%llu|%llu|%llu",t,intuple,inbytes,intupledrop,outtuple,outbytes,outtupledrop,cycles); +} + +#endif diff --git a/include/gstypes.h b/include/gstypes.h new file mode 100644 index 0000000..905fc09 --- /dev/null +++ b/include/gstypes.h @@ -0,0 +1,63 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef GSTYPES +#define GSTYPES + +#include "gsconfig.h" + +// Basic type definitions used within the whole GS + +typedef unsigned char gs_uint8_t; +typedef char gs_int8_t; +typedef unsigned short gs_uint16_t; +typedef short gs_int16_t; +typedef unsigned int gs_uint32_t; +typedef int gs_int32_t; +typedef unsigned long long gs_uint64_t; +typedef long long gs_int64_t; +typedef gs_uint32_t gs_bool_t; +typedef double gs_float_t; + +// Return value to check function call success +typedef gs_int32_t gs_retval_t ; + +// Native String Pointer + +typedef gs_int8_t * gs_sp_t; + +// Const string pointer +typedef const gs_int8_t * gs_csp_t; + +// Generic GS pointer + +#ifdef GS64 + +typedef gs_uint64_t gs_p_t; + +// Handle type for external handle functions +typedef gs_int64_t gs_param_handle_t ; +#else + +typedef gs_uint32_t gs_p_t; + +// Handle type for external handle functions +typedef gs_int32_t gs_param_handle_t ; +#endif + +// Handle for GS schema + +typedef gs_int32_t gs_schemahandle_t ; + +#endif diff --git a/include/hfta/base_operator.h b/include/hfta/base_operator.h new file mode 100644 index 0000000..99df8fa --- /dev/null +++ b/include/hfta/base_operator.h @@ -0,0 +1,56 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef BASE_OPERATOR_H +#define BASE_OPERATOR_H + +#include "host_tuple.h" +#include +using namespace std; + +class base_operator +{ +protected: + unsigned int output_channel; + const char* op_name; +public: +// Tuple is presented to the operator. Output tuples +// returned in result + virtual int accept_tuple(host_tuple& tup, list& result) = 0; +// Flush output from the system + virtual int flush(list& result) = 0; +// Accept new query parameters + virtual int set_param_block(int sz, void * value) = 0; + virtual int get_temp_status(host_tuple& result) = 0; + virtual int get_blocked_status () = 0; + + base_operator(const char* name) { + output_channel = 0; + op_name = name; + } + + void set_output_channel(unsigned int channel) { + output_channel = channel; + } + +// Operator's memory footprint in bytes (estimate for the main structures - hash tables, etc ) + virtual unsigned int get_mem_footprint() { return 0; } + + virtual const char* get_name() { return op_name; } + + virtual ~base_operator() {} +}; + +#endif // BASE_OPERATOR_H diff --git a/include/hfta/clean_operator.h b/include/hfta/clean_operator.h new file mode 100644 index 0000000..6c8d0ed --- /dev/null +++ b/include/hfta/clean_operator.h @@ -0,0 +1,452 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef CLEAN_OPERATOR_H +#define CLEAN_OPERATOR_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +#include "hash_table.h" +#include + +#define _GB_FLUSH_PER_TUPLE_ 1 + +// #define _C_O_DEBUG 1 + +using namespace std; + +template class clean_operator: public base_operator{ + + private: + + class superattribute{ + public: + unsigned int count_distinct; + list l; + + superattribute(){ + count_distinct = 0; + }; + ~superattribute(){}; + }; + + clean_func func; + hash_table group_table[2]; + hash_table supergroup_table[2]; + // maintains count_distinct for every supergroup + // also maintains list of groups of this supergroup + hash_table sp_attribute[2]; + bool flush_finished; + unsigned int curr_table; + unsigned int curr_supertable; + unsigned int curr_attrtable; + unsigned int packet_count; + unsigned int ccc; + typename hash_table::iterator iter1; //find + typename hash_table::iterator flush_pos; + typename hash_table::iterator iter2; //find + typename hash_table::iterator super_flush_pos; + + public: + +// clean_operator(int schema_hadle): func(1){ + clean_operator(int schema_handle, const char* name) : base_operator(name), func(schema_handle){ + flush_finished = true; + curr_table = 0; + curr_supertable = 0; + curr_attrtable = 0; + packet_count = 0; + ccc = 0; + flush_pos = group_table[1-curr_table].end(); + super_flush_pos = supergroup_table[1-curr_supertable].end(); + } + + virtual int accept_tuple(host_tuple& tup, list& result){ + packet_count++; + // evict tuple from the old table + if(!flush_finished){ + partial_flush(result); + } + + //buffers to store keys + char buffer[sizeof(group)]; + + // key of the supergroup is all group-by attributes not including the once that define time window + // key of the supergroup is a subset of a group key + //cout << "clean_op: creating group" << "\n"; + group* grp = func.create_group(tup,buffer); +/*// Ignore temp tuples until we can fix their timestamps. +if(func.temp_status_received()){ + tup.free_tuple(); + return 0; +}*/ + state* curr_state; + int cd = 0; //count_distinct + + // do final clean at the border of the time window + if(func.flush_needed()){ + //cout << "number of records: " << packet_count << endl; + //cout << "number of EVAL records: " << ccc << endl; + packet_count = 0; + ccc = 0; + // for every supergroup - clean group table + //cout << "FINAL CLEANING PHASE: " << "\n"; + iter2 = supergroup_table[curr_supertable].begin(); + while (iter2 != supergroup_table[curr_supertable].end()) { + cd = ((*(sp_attribute[curr_attrtable].find((*iter2).first))).second)->count_distinct; + func.finalize_state((*iter2).second, cd); + clean((*iter2).first,(*iter2).second, true); + ++iter2; + } + + } + + if(!grp){ + //cout << "clean_op: failed to create group" << "\n"; + if(func.flush_needed()){ + flush(result); + superflush(); + } + if(func.temp_status_received()){ + host_tuple temp_tup; + if (!func.create_temp_status_tuple(temp_tup, flush_finished)) { + temp_tup.channel = output_channel; + result.push_back(temp_tup); + } + } + tup.free_tuple(); + return 0; + } + + // first flush everything from the old table if needed + // need it before anything else because of the definition of the key for supergroup + if(func.flush_needed()){ + //do flush of the old group table using state from the old supergroup table + flush(result); + //flush everything from the old supertable, swap tables; + superflush(); + } + + state* old_state; + + //supergroup exists in the new table + if ((iter2 = supergroup_table[curr_supertable].find(grp)) != supergroup_table[curr_supertable].end()){ + old_state = (*iter2).second; + + superattribute *temp = (*(sp_attribute[curr_attrtable].find(grp))).second; + cd = temp->count_distinct; + + if(!func.evaluate_predicate(tup,grp,old_state, cd)){ + ccc++; + tup.free_tuple(); + return 0; + } + // update superaggregates + func.update_plus_superaggr(tup, grp, old_state); + //((*(sp_attribute[curr_attrtable].find(grp))).second)->count_distinct++; + temp->count_distinct++; + cd = temp->count_distinct; + curr_state = old_state; + } + //new supergroup + else{ + + //look up the group in the old table, + if((iter2 = supergroup_table[1-curr_supertable].find(grp)) != supergroup_table[1-curr_supertable].end()){ + cd = ((*(sp_attribute[1-curr_attrtable].find(grp))).second)->count_distinct; + //curr_state = new state((*iter2).second); + curr_state = new state(); + old_state = (*iter2).second; + + //if there is one - do reinitialization + func.reinitialize_state(tup, grp, curr_state,old_state, cd); + } + else{ + curr_state = new state(); + //if there isn't - do initialization + func.initialize_state(tup, grp, curr_state); + } + + // have to create new object for superkey + group* new_sgrp = new group(grp); + + // need to insert the supergroup into the hash table even if the predicate + // evaluates to false, since the state is initialized with the first tuple of the supergroup + + //insert supergroup into the hash table + supergroup_table[curr_supertable].insert(new_sgrp, curr_state); + // create superattribute object + superattribute* sp_attr = new superattribute(); + sp_attribute[curr_attrtable].insert(new_sgrp,sp_attr); + + + if(!func.evaluate_predicate(tup, grp, curr_state, cd)){ + ccc++; + tup.free_tuple(); + return 0; + } + + // update superaggregates + func.update_plus_superaggr(tup, grp, curr_state); + ((*(sp_attribute[curr_attrtable].find(grp))).second)->count_distinct++; + } + + aggregate* ag; + cd = ((*(sp_attribute[curr_attrtable].find(grp))).second)->count_distinct; + + if ((iter1 = group_table[curr_table].find(grp)) != group_table[curr_table].end()) { + //cout << "clean_op: group already exists" << "\n"; + aggregate* old_aggr = (*iter1).second; + + //adjust count_distinct due to aggregation + ((*(sp_attribute[curr_attrtable].find(grp))).second)->count_distinct--; + + //update group aggregates + func.update_aggregate(tup, grp, old_aggr, curr_state, cd); + ag = old_aggr; + } + else{ + //cout << "clean_op: creating a new group" << "\n"; + // create a copy of the group on the heap + group *new_grp = new group(grp); // need a copy constructor for groups + aggregate* aggr = new aggregate(); + // create an aggregate in preallocated buffer + aggr = func.create_aggregate(tup, grp, (char*)aggr, curr_state, cd); + //cout << "clean_op: inserting group into hash" << "\n"; + group_table[curr_table].insert(new_grp, aggr); + ag = aggr; + + // remember group in the list of supergroup + ((*(sp_attribute[curr_attrtable].find(new_grp))).second)->l.push_back(new_grp); + + } + + + //used just for print + bool do_print = false; + cd = ((*(sp_attribute[curr_attrtable].find(grp))).second)->count_distinct; + + //CLEANING WHEN + if(func.need_to_clean(grp, curr_state, cd)){ + clean(grp, curr_state, false); + do_print = true; + } + + tup.free_tuple(); + return 0; + } + + virtual int flush(list& result){ + + //cout << "clean_op: flush" << "\n"; + host_tuple tup; + unsigned int old_table = 1-curr_table; + unsigned int old_supertable = 1-curr_supertable; + unsigned int old_attr = 1-curr_attrtable; + typename hash_table::iterator iter; + iter = supergroup_table[old_supertable].begin(); + unsigned int cd = 0; + + // if the old table isn't empty, flush it now. + if (!group_table[old_table].empty()) { + //cout << "clean_op: old table is not empty, flushing everything immediately" << "\n"; + for (; flush_pos != group_table[old_table].end(); ++flush_pos) { + + bool failed = false; + if((iter = supergroup_table[old_supertable].find((*flush_pos).first)) != supergroup_table[old_supertable].end()){ + + cd = ((*(sp_attribute[old_attr].find((*flush_pos).first))).second)->count_distinct; + + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, (*iter).second, cd ,failed); + if (!failed) { + //cout << "sampled\n"; + tup.channel = output_channel; + result.push_back(tup); + } + + // may not need deletion of the list pointer, since the supergroup will be flushed soon anyway. + } + + delete ((*flush_pos).first); + delete ((*flush_pos).second); + } + group_table[old_table].clear(); + group_table[old_table].rehash(); + } + + // swap tables, enable partial flush processing. + flush_pos = group_table[curr_table].begin(); + curr_table = old_table; + flush_finished = false; + + return 0; + } + + virtual int partial_flush(list& result){ + + //cout << "clean_op: partial flush" << "\n"; + host_tuple tup; + unsigned int old_table = 1-curr_table; + unsigned int old_supertable = 1-curr_supertable; + unsigned int old_attr = 1-curr_attrtable; + unsigned int i; + unsigned int cd = 0; + typename hash_table::iterator iter; + iter = supergroup_table[old_supertable].begin(); + + // emit up to _GB_FLUSH_PER_TABLE_ output tuples. + if (!group_table[old_table].empty()) { + for (i=0; flush_pos != group_table[old_table].end() && i<_GB_FLUSH_PER_TUPLE_; ++flush_pos, ++i) { + + bool failed = false; + // find supergroup of the group to be deleted + if((iter = supergroup_table[old_supertable].find((*flush_pos).first)) != supergroup_table[old_supertable].end()){ + + cd = ((*(sp_attribute[old_attr].find((*flush_pos).first))).second)->count_distinct; + + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, (*iter).second, cd, failed); + if (!failed) { + + //cout << "sampled\n"; + tup.channel = output_channel; + result.push_back(tup); + } + + // may not need deletion of the list pointer, since the supergroup will be flushed soon anyway. + } + + delete ((*flush_pos).first); + delete ((*flush_pos).second); + } + } + + // finalize processing if empty. + if(flush_pos == group_table[old_table].end()) { + flush_finished = true; + group_table[old_table].clear(); + group_table[old_table].rehash(); + } + + return 0; + } + + virtual int superflush(){ + + // cout << "clean_op: superflush" << "\n"; + typename hash_table::iterator attr_flush_pos; + unsigned int old = 1-curr_supertable; + unsigned int attr_old = 1-curr_attrtable; + + // if the old supergroup table isn't empty, flush it now. + if (!supergroup_table[old].empty()) { + //cout << "clean_op: flush supertable" << "\n"; + for (; super_flush_pos != supergroup_table[old].end(); ++super_flush_pos) { + //find that supergroup in the attributes table + attr_flush_pos = sp_attribute[attr_old].find((*super_flush_pos).first); + + delete ((*super_flush_pos).first); + delete ((*super_flush_pos).second); + //flush superattribute table too + //delete ((*attr_flush_pos).first); + delete ((*attr_flush_pos).second); + } + supergroup_table[old].clear(); + supergroup_table[old].rehash(); + sp_attribute[attr_old].clear(); + sp_attribute[attr_old].rehash(); + } + + // swap supertables + super_flush_pos = supergroup_table[curr_supertable].begin(); + curr_supertable = old; + // swap attribute tables + curr_attrtable = attr_old; + + return 0; + } + + virtual int clean(group* sgr, state* st, bool final_clean){ + //cout << "clean_op: clean" << "\n"; + bool sample = false; + + typename list::iterator viter; + superattribute* glist = (*(sp_attribute[curr_attrtable].find(sgr))).second; + int cd = ((*(sp_attribute[curr_attrtable].find(sgr))).second)->count_distinct; +// glist->l.size(); +// group_table[curr_table].size(); + if (!glist->l.empty()){ + + //cout << "clean_op: list of group pointers is not empty" << "\n"; + viter = glist->l.begin(); + for(; viter != glist->l.end();){ + iter1 = group_table[curr_table].find(*viter); + aggregate* old_aggr = (*iter1).second; + + //if (((*iter1).first->valid)){ + if (final_clean){ + // HAVING + sample = func.final_sample_group((*iter1).first, old_aggr, st, cd); + } + else + // CLEANING BY + sample = func.sample_group((*iter1).first, old_aggr, st, cd); + + if(!sample){ + //cout << "clean_op: evicting group from the group table" << "\n"; + //update superaggregates + func.update_minus_superaggr((*iter1).first, old_aggr, st); + //delete group + group* g = (*iter1).first; + aggregate* a = (*iter1).second; + group_table[curr_table].erase((*iter1).first); + delete g; + delete a; + //update count_distinct + ((*(sp_attribute[curr_attrtable].find((*iter1).first))).second)->count_distinct--; + //remove pointer from supergroup + viter = glist->l.erase(viter); + } + else + ++viter; + } + } + + return 0; + } + + virtual int set_param_block(int sz, void* value){ + func.set_param_block(sz, value); + return 0; + } + + virtual int get_temp_status(host_tuple& result){ + result.channel = output_channel; + return func.create_temp_status_tuple(result, flush_finished); + } + + virtual int get_blocked_status(){ + return -1; + } + + unsigned int get_mem_footprint() { + return group_table[0].get_mem_footprint() + group_table[1].get_mem_footprint() + + supergroup_table[0].get_mem_footprint() + supergroup_table[1].get_mem_footprint() + + sp_attribute[0].get_mem_footprint() + sp_attribute[1].get_mem_footprint(); + } + +}; + +#endif diff --git a/include/hfta/file_output_operator.h b/include/hfta/file_output_operator.h new file mode 100644 index 0000000..a446dc6 --- /dev/null +++ b/include/hfta/file_output_operator.h @@ -0,0 +1,216 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef FILE_OUTPUT_OPERATOR_H +#define FILE_OUTPUT_OPERATOR_H + +#include +#include +#include +#include +#include +#include + +#include "gsconfig.h" +#include "gstypes.h" +#include + +#include "host_tuple.h" +#include "base_operator.h" +#include +#include +#include +#include "gsconfig.h" +#include "gstypes.h" +#include + +using namespace std; + +#ifndef FILESTREAM_OPERATOR_UTILS +#define FILESTREAM_OPERATOR_UTILS +string fs_int_to_string(int i){ + string ret; + char tmpstr[100]; + sprintf(tmpstr,"%d",i); + ret=tmpstr; + return(ret); +} +#endif + +template class file_output_operator : + public base_operator +{ +private : + file_output_functor func; + + FILE **output_file; + bool do_compression; + vector xform_command; + vector temp_fname; + vector fname; + string qname; + string schema; + string file_header; + gs_uint32_t n_file_streams; + +int total_written; + +public: + +file_output_operator(int schema_handle, gs_csp_t name, gs_csp_t sch) : base_operator(name), func(schema_handle) { + char tmpstr[1000]; + int i; + + do_compression = func.do_compression(); + n_file_streams = func.num_file_streams(); + output_file = (FILE **)(malloc(sizeof(FILE *)*n_file_streams)); + for(i=0;i& result) { +string fname_base; +host_tuple res; +gs_uint32_t i; + + if(! func.temp_status_received(tup)){ // this operator doesn't write +// Check for EOF conditions. + if(func.is_eof_tuple()){ + if(output_file[0] != NULL){ + for(i=0;i 1){ + temp_fname[i] = fname_base + "_stream"+fs_int_to_string(i)+ ".txt.tmp"; + fname[i] = fname_base + "_stream"+fs_int_to_string(i)+ ".txt"; + }else{ + temp_fname[i] = fname_base + "_stream"+fs_int_to_string(i)+ ".txt.tmp"; + fname[i] = fname_base + "_stream"+fs_int_to_string(i)+ ".txt"; + } + if (do_compression) { + xform_command[i] = "gzip -S .tmpgz "+temp_fname[i]+" ; mv "+temp_fname[i]+".tmpgz "+fname[i]+".gz"; + } +// else{ +// xform_command = "mv "+temp_fname+" "+fname; +// } + if ((output_file[i]=fopen(temp_fname[i].c_str(),"w"))==0) { + gslog(LOG_EMERG,"Could not open file \"%s\".. EXITING\n", temp_fname[i].c_str()); + exit(1); + } + fwrite(file_header.c_str(),strlen(file_header.c_str()),1,output_file[i]); + fwrite(schema.c_str(),strlen(schema.c_str())+1,1,output_file[i]); + } + } + + gs_uint32_t sz = tup.tuple_size; + gs_uint32_t nsz = htonl(tup.tuple_size); + gs_uint32_t file_hash = func.output_hash(); +total_written += sizeof(gs_uint32_t) + sz; + + if (fwrite(&nsz,sizeof(gs_uint32_t),1,output_file[file_hash])!=1) { + gslog(LOG_EMERG,"file_output_operator: Could not write %d bytes to output \"%s\" .. EXITING\n", sizeof(gs_uint32_t), temp_fname[file_hash].c_str()); + exit(1); + } + + if (fwrite(tup.data,sz,1,output_file[file_hash])!=1) { + gslog(LOG_EMERG,"file_output_operator: Could not write %d bytes to output \"%s\" .. EXITING\n", sz, temp_fname[file_hash].c_str()); + exit(1); + } + if(func.propagate_tuple()){ + tup.channel = output_channel; + result.push_back(tup); + } + return 0; + }else{ +/* + if (!func.create_temp_status_tuple(res)) { + res.channel = output_channel; + result.push_back(res); + } +*/ + +//fprintf(stderr,"\tis temp tuple\n"); + } + + if(func.propagate_tuple()){ + tup.channel = output_channel; + result.push_back(tup); + } + return 0; +} + + + virtual int flush(list& result) { + return 0; + } + + virtual int set_param_block(int sz, void * value) { +// func.set_param_block(sz, value); + return 0; + } + + virtual int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result); + } + + virtual int get_blocked_status () { + return -1; // selection operators are not blocked on any input + } +}; + + +#endif // FILE_OUTPUT_OPERATOR_H + diff --git a/include/hfta/groupby_operator.h b/include/hfta/groupby_operator.h new file mode 100644 index 0000000..26645c3 --- /dev/null +++ b/include/hfta/groupby_operator.h @@ -0,0 +1,238 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef GROUPBY_OPERATOR_H +#define GROUPBY_OPERATOR_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +#include "hash_table.h" + +#define _GB_FLUSH_PER_TUPLE_ 1 + +using namespace std; + +template +class groupby_operator : public base_operator { +private : + groupby_func func; + hash_table group_table[2]; + bool flush_finished; + unsigned int curr_table; + typename hash_table::iterator flush_pos; + int n_patterns; + + + +public: + groupby_operator(int schema_handle, const char* name) : base_operator(name), func(schema_handle) { + flush_finished = true; + curr_table = 0; + flush_pos = group_table[1-curr_table].end(); + n_patterns = func.n_groupby_patterns(); + } + + int accept_tuple(host_tuple& tup, list& result) { + +// Push out completed groups + + if(!flush_finished) partial_flush(result); + + // create buffer on the stack to store key object + char buffer[sizeof(group)]; + + // extract the key information from the tuple and + // copy it into buffer + group* grp = func.create_group(tup, buffer); + if (!grp) { +/* +// Ignore temp tuples until we can fix their timestamps. +if (func.temp_status_received()) { + tup.free_tuple(); + return 0; +}*/ + if (func.flush_needed()){ + flush_old(result); + } + if (func.temp_status_received()) { + host_tuple temp_tup; + if (!func.create_temp_status_tuple(temp_tup, flush_finished)) { + temp_tup.channel = output_channel; + result.push_back(temp_tup); + } + } + tup.free_tuple(); + return 0; + } + + typename hash_table::iterator iter; + if ((iter = group_table[curr_table].find(grp)) != group_table[curr_table].end()) { +// Temporal GBvar is part of the group so no flush is needed. + aggregate* old_aggr = (*iter).second; + func.update_aggregate(tup, grp, old_aggr); + }else{ + if (func.flush_needed()) { + flush_old(result); + } + if(n_patterns <= 1){ + // create a copy of the group on the heap + group* new_grp = new group(grp); // need a copy constructor for groups +// aggregate* aggr = (aggregate*)malloc(sizeof(aggregate)); + aggregate* aggr = new aggregate(); + // create an aggregate in preallocated buffer + aggr = func.create_aggregate(tup, (char*)aggr); + + group_table[curr_table].insert(new_grp, aggr); + }else{ + int p; + for(p=0;p& result) { + host_tuple tup; + unsigned int old_table = 1-curr_table; + unsigned int i; + +// emit up to _GB_FLUSH_PER_TABLE_ output tuples. + if (!group_table[old_table].empty()) { + for (i=0; flush_pos != group_table[old_table].end() && i<_GB_FLUSH_PER_TUPLE_; ++flush_pos, ++i) { + bool failed = false; + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + if (!failed) { + tup.channel = output_channel; + result.push_back(tup); + } + delete ((*flush_pos).first); + delete ((*flush_pos).second); +// free((*flush_pos).second); + } + } + +// Finalize processing if empty. + if(flush_pos == group_table[old_table].end()) { + flush_finished = true; + group_table[old_table].clear(); + group_table[old_table].rehash(); + } + return 0; + } + + int flush(list& result) { + host_tuple tup; + typename hash_table::iterator iter; + unsigned int old_table = 1-curr_table; + +// If the old table isn't empty, flush it now. + if (!group_table[old_table].empty()) { + for (; flush_pos != group_table[old_table].end(); ++flush_pos) { + bool failed = false; + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + if (!failed) { + + tup.channel = output_channel; + result.push_back(tup); + } + delete ((*flush_pos).first); + delete ((*flush_pos).second); +// free((*flush_pos).second); + } + group_table[old_table].clear(); + group_table[old_table].rehash(); + } + + flush_pos = group_table[curr_table].begin(); +// If the old table isn't empty, flush it now. + if (!group_table[curr_table].empty()) { + for (; flush_pos != group_table[curr_table].end(); ++flush_pos) { + bool failed = false; + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + if (!failed) { + + tup.channel = output_channel; + result.push_back(tup); + } + delete ((*flush_pos).first); + delete ((*flush_pos).second); +// free((*flush_pos).second); + } + group_table[curr_table].clear(); + } + + flush_finished = true; + + return 0; + } + + int flush_old(list& result) { + host_tuple tup; + typename hash_table::iterator iter; + unsigned int old_table = 1-curr_table; + +// If the old table isn't empty, flush it now. + if (!group_table[old_table].empty()) { + for (; flush_pos != group_table[old_table].end(); ++flush_pos) { + bool failed = false; + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + if (!failed) { + + tup.channel = output_channel; + result.push_back(tup); + } + delete ((*flush_pos).first); + delete ((*flush_pos).second); +// free((*flush_pos).second); + } + group_table[old_table].clear(); + group_table[old_table].rehash(); + } + +// swap tables, enable partial flush processing. + flush_pos = group_table[curr_table].begin(); + curr_table = old_table; + flush_finished = false; + + return 0; + } + + int set_param_block(int sz, void * value) { + func.set_param_block(sz, value); + return 0; + } + + int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result, flush_finished); + } + + int get_blocked_status () { + return -1; + } + + unsigned int get_mem_footprint() { + return group_table[0].get_mem_footprint() + group_table[1].get_mem_footprint(); + } +}; + +#endif // GROUPBY_OPERATOR_H diff --git a/include/hfta/groupby_operator_oop.h b/include/hfta/groupby_operator_oop.h new file mode 100644 index 0000000..03a577f --- /dev/null +++ b/include/hfta/groupby_operator_oop.h @@ -0,0 +1,399 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef GROUPBY_OPERATOR_OOP_H +#define GROUPBY_OPERATOR_OOP_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +#include +#include "hash_table.h" +#include + +// TED: should be supplied by the groupby_func +#define _GB_FLUSH_PER_TUPLE_ 1 + +/* max allowed disorder -- Jin */ +// TED: should be supplied by the groupby_func +#define DISORDER_LEVEL 2 + +//#define NDEBUG + +using namespace std; + +// ASSUME temporal_type is one of int, uint, llong, ullong + +template +class groupby_operator_oop : public base_operator { +private : + groupby_func func; + + /* a list of hash tables, which maintains aggregates for current window and also k previous ones -- Jin */ + vector* > group_tables; + + /* the minimum and maximum window id of the hash tables -- Jin */ + temporal_type min_wid, max_wid; + + + bool flush_finished; + temporal_type curr_table; + typename hash_table::iterator flush_pos; + + temporal_type last_flushed_temporal_gb; + temporal_type last_temporal_gb; + +int n_slow_flush; + int n_patterns; + + +public: + groupby_operator_oop(int schema_handle, const char* name) : base_operator(name), func(schema_handle) { + flush_finished = true; + + min_wid = 0; + max_wid = 0; +n_slow_flush = 0; + n_patterns = func.n_groupby_patterns(); + } + + ~groupby_operator_oop() { + hash_table* table; + // delete all the elements in the group_tables list; + while (!group_tables.empty()) { + table = group_tables.back(); + group_tables.pop_back(); + table->clear(); +//fprintf(stderr,"Deleting group table (c) at %lx\n",(gs_uint64_t)(table)); + delete (table); + } + + } + + int accept_tuple(host_tuple& tup, list& result) { + + + // Push out completed groups + if(!flush_finished) partial_flush(result); + + // create buffer on the stack to store key object + char buffer[sizeof(group)]; + + // extract the key information from the tuple and + // copy it into buffer + group* grp = func.create_group(tup, buffer); + + + if (!grp) { +//printf("grp==NULL recieved "); + if (func.temp_status_received()) { +//printf("temp status record "); + last_flushed_temporal_gb = func.get_last_flushed_gb (); + last_temporal_gb = func.get_last_gb (); + } +//printf("\n"); + +//fprintf(stderr,"min_wid=%d, max_wid=%d, last_temporal_gb=%d, last_flushed_temporal_gb=%d, flush_finished=%d\n",min_wid, max_wid, last_temporal_gb, last_flushed_temporal_gb, flush_finished); + + /* no data has arrived, and so we ignore the temp tuples -- Jin */ + if (group_tables.size()>0) { + + gs_int64_t index; + if(last_flushed_temporal_gb >= min_wid){ + index = last_flushed_temporal_gb - min_wid; + }else{ + index = -(min_wid - last_flushed_temporal_gb); // unsigned arithmetic + } + + if (func.flush_needed() && index>=0) { +#ifdef NDEBUG +//fprintf(stderr, "flush needed: last_flushed_gb %u , min_wid %u \n", last_flushed_temporal_gb, min_wid); +#endif + // Init flush on first temp tuple -- Jin + if ( !flush_finished) { +#ifdef NDEBUG +//fprintf(stderr, "last_flushed_gb is %u, min_wid is %u \n", last_flushed_temporal_gb, min_wid); +#endif + flush_old(result); + } + if (last_temporal_gb > min_wid && group_tables.size()>0) { + flush_finished = false; + } + + // we start to flush from the head of the group tables -- Jin + if(group_tables.size()>0){ + flush_pos = group_tables[0]->begin(); + } + +#ifdef NDEBUG +//fprintf(stderr, "after flush old \n"); +#endif + } + } + + host_tuple temp_tup; + if (!func.create_temp_status_tuple(temp_tup, flush_finished)) { + temp_tup.channel = output_channel; + result.push_back(temp_tup); + } + + tup.free_tuple(); + return 0; + } + +//fprintf (stderr, "after create group grp=%lx, curr_table = %d\n",(gs_uint64_t)grp, grp->get_curr_gb()); + + /* This is a regular tuple -- Jin */ + typename hash_table::iterator iter; + /* first, decide which hash table we need to work at */ + curr_table = grp->get_curr_gb(); + if (max_wid == 0 && min_wid == 0) { + group_tables.push_back((new hash_table())); +//fprintf(stderr,"Added (1) hash tbl at %lx, pos=%d\n",(gs_uint64_t)(group_tables.back()),group_tables.size()); + max_wid = min_wid = curr_table; + } + if (curr_table < min_wid) { + for (temporal_type i = curr_table; i < min_wid; i++){ + group_tables.insert(group_tables.begin(), new hash_table()); +//fprintf(stderr,"Added (2) hash tbl at %lx, pos=%d\n",(gs_uint64_t)(group_tables.back()),group_tables.size()); + } + min_wid = curr_table; + } + if (curr_table > max_wid) { + hash_table* pt; + for (temporal_type i = max_wid; i < curr_table; i++) { + pt =new hash_table(); + group_tables.push_back(pt); +//fprintf(stderr,"Added (3) hash tbl at %lx, pos=%d\n",(gs_uint64_t)(group_tables.back()),group_tables.size()); + } + + max_wid = curr_table; + } + gs_int64_t index = curr_table - min_wid; + + if ((iter = group_tables[index]->find(grp)) != group_tables[index]->end()) { + aggregate* old_aggr = (*iter).second; + func.update_aggregate(tup, grp, old_aggr); + }else{ + /* We only flush when a temp tuple is received, so we only check on temp tuple -- Jin */ + // create a copy of the group on the heap + if(n_patterns <= 1){ + + group* new_grp = new group(grp); // need a copy constructor for groups + + aggregate* aggr = new aggregate(); + + // create an aggregate in preallocated buffer + aggr = func.create_aggregate(tup, (char*)aggr); + +// hash_table* pt; + group_tables[index]->insert(new_grp, aggr); + }else{ + int p; + for(p=0;pinsert(new_grp, aggr); + } + } + } + tup.free_tuple(); + return 0; + } + + int partial_flush(list& result) { + host_tuple tup; + /* the hash table we should flush is func->last_flushed_gb_0 -- Jin */ + /* should we guarantee that everything before func->last_flushed_gb_0 also flushed ??? */ + + gs_int64_t i; + +//fprintf(stderr, "partial_flush size of group_tables = %u, min_wid is %u, max_wid is %u last_temporal_gb=%d \n", group_tables.size(), min_wid, max_wid, last_temporal_gb); + if(group_tables.size()==0){ + flush_finished = true; +//fprintf(stderr, "out of partial flush early \n"); + return 0; + } + +// emit up to _GB_FLUSH_PER_TABLE_ output tuples. + if (!group_tables[0]->empty()) { + for (i=0; flush_pos!=group_tables[0]->end() && i < _GB_FLUSH_PER_TUPLE_; ++flush_pos, ++i) { +n_slow_flush++; + bool failed = false; + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + if (!failed) { + tup.channel = output_channel; + result.push_back(tup); + } +//fprintf(stderr,"partial_flush Deleting at Flush_pos=%lx \n",(gs_uint64_t)((*flush_pos).first)); + delete ((*flush_pos).first); + delete ((*flush_pos).second); + } + } + +// Finalize processing if empty. + if (flush_pos == group_tables[0]->end()) { + /* one window is completely flushed, so recycle the hash table -- Jin */ + + hash_table* table = group_tables[0]; + +//fprintf(stderr,"partial_flush Delelting group table %lx\n",(gs_uint64_t)(group_tables[0])); + group_tables[0]->clear(); + delete (group_tables[0]); + + group_tables.erase(group_tables.begin()); + + min_wid++; + + if (last_temporal_gb > min_wid && group_tables.size()>0) { + flush_pos = group_tables[0]->begin(); + + } else { + flush_finished = true; + } + } +//fprintf(stderr, "out of partial flush \n"); + return 0; + } + + + /* Where is this function called ??? */ /* externally */ + int flush(list& result) { + host_tuple tup; + typename hash_table::iterator iter; + /* the hash table we should flush is func->last_flushed_gb_0 -- Jin */ + /* should we guarantee that everything before func->last_flushed_gb_0 also flushed ??? */ + while ( group_tables.size() > 0) { + if (!group_tables[0]->empty()) { + if (flush_finished) + flush_pos = group_tables[0]->begin(); + for (; flush_pos != group_tables[0]->end(); ++flush_pos) { + bool failed = false; + + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + + if (!failed) { + + tup.channel = output_channel; + result.push_back(tup); + } +//fprintf(stderr,"flush_old Deleting at Flush_pos=%lx \n",(gs_uint64_t)((*flush_pos).first)); + delete ((*flush_pos).first); + delete ((*flush_pos).second); + + } + } + min_wid++; + + // remove the hashtable from group_tables + hash_table* table = group_tables[0]; + + table->clear(); +//fprintf(stderr,"flush_old Delelting group table %lx\n",(gs_uint64_t)(group_tables[0])); + delete (table); + group_tables.erase(group_tables.begin()); + + if(group_tables.size()>0){ + flush_pos = group_tables[0]->begin(); + } + } + + + + flush_finished = true; + + return 0; + } + + /* flushes every hash table before last_flush_gb, and get ready to flush the next window -- Jin */ + int flush_old(list& result) { + host_tuple tup; + typename hash_table::iterator iter; + gs_int64_t num, i; + +//fprintf(stderr, "flush_old size of group_tables = %u, min_wid is %u, max_wid is %u last_temporal_gb=%d, num=%d\n", group_tables.size(), min_wid, max_wid, last_temporal_gb, num); + + num = last_temporal_gb - min_wid; + + //If the old table isn't empty, flush it now. + for (i = 0; i < num && group_tables.size() > 0; i++) { + if (!group_tables[0]->empty()) { + for (; flush_pos != group_tables[0]->end(); ++flush_pos) { + bool failed = false; + + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + + if (!failed) { + + tup.channel = output_channel; + result.push_back(tup); + } +//fprintf(stderr,"flush_old Deleting at Flush_pos=%lx \n",(gs_uint64_t)((*flush_pos).first)); + delete ((*flush_pos).first); + delete ((*flush_pos).second); + + } + } + min_wid++; + + // remove the hashtable from group_tables + hash_table* table = group_tables[0]; + + table->clear(); +//fprintf(stderr,"flush_old Delelting group table %lx\n",(gs_uint64_t)(group_tables[0])); + delete (table); + group_tables.erase(group_tables.begin()); + + if(group_tables.size()>0){ + flush_pos = group_tables[0]->begin(); + } + } + + flush_finished = true; + +//fprintf(stderr, "end of flush_old \n"); + + return 0; + } + + + int set_param_block(int sz, void * value) { + func.set_param_block(sz, value); + return 0; + } + + int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result, flush_finished); + } + + int get_blocked_status () { + return -1; + } + + unsigned int get_mem_footprint() { + unsigned int ret; + unsigned int i; + + for(i=0;iget_mem_footprint() ; + + return ret; + } +}; + +#endif // GROUPBY_OPERATOR_OOP_H + diff --git a/include/hfta/hash_table.h b/include/hfta/hash_table.h new file mode 100644 index 0000000..f5b1afe --- /dev/null +++ b/include/hfta/hash_table.h @@ -0,0 +1,610 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __HASH_TABLE_H +#define __HASH_TABLE_H + +#include +#include + + + +#define NUM_PRIMES 23 + +static unsigned int primes[NUM_PRIMES] = { + 11, 23, 47, 97, 197, 397, 797, 1597, 3203, 6421, 12853, + 25717, 51437, 102877, 205759, 411527, 823117, 1646237, + 3292489, 6584983, 13169977, 26339969, 52679969 +}; + + + +template +class hash_table { + +public : + struct data_item { + key_type first; + value_type second; + data_item* next; // next data item in overflow chain + + data_item(const key_type& k, const value_type& v) : first(k), second(v), next(NULL) { } + }; + + struct hash_bucket { + data_item* data; // + hash_bucket* next_bucket; // index of the next bucket in the list of used buckets + hash_bucket* prev_bucket; // index of the next bucket in the list of used buckets + + hash_bucket() { + data = NULL; + next_bucket = 0; // 0 means no bucket follows this one + prev_bucket = 0; // 0 means no bucket precedes this one + } + }; + + struct iterator { + hash_bucket* bucket; + data_item* data; + + iterator& operator++() { + if (data->next) + data = data->next; + else { + bucket = bucket->next_bucket; + if (bucket) + data = bucket->data; + else + data = NULL; + } + return *this; + } + +// Like ++, but don't go beyond the end of the bucket chain. + iterator& next() { + if (data->next) + data = data->next; + else { + bucket = NULL; + data = NULL; + } + return *this; + } + + bool operator!=(const iterator& it) { + return (data != it.data || bucket != it.bucket); + } + + bool operator==(const iterator& it) { + return (data == it.data && bucket == it.bucket); + } + + data_item &operator*() { + return *data; + } + }; + +private: + hasher_func hasher; + equal_func equal; + + double load_factor; +// double max_load; + + size_t _size; + size_t _max_size; + size_t num_buckets; + size_t hash_mask; + + hash_bucket* first_bucket; // first used bucket + hash_bucket* last_bucket; // last used bucket + + hash_bucket* buckets; + + // memory footpritn in bytes + unsigned int total_memory; + +public: + + + hash_table(const size_t n_buckets = 131072, const double load = 0.5) { + load_factor = load; + int nb; + for(nb=2;nbnext_bucket = &buckets[bucket_index]; + } + + if (last_bucket) + buckets[bucket_index].prev_bucket = last_bucket; + + last_bucket = &buckets[bucket_index]; + } else { // we already have data items in this bucket + // prepend the item to overflow chain + data_item* temp = buckets[bucket_index].data; + buckets[bucket_index].data = d; + d->next = temp; + } + _size++; + if(_size>_max_size) + _max_size = _size; + + return 0; + } + + data_item *iterate_find(data_item* t, const key_type& key) { + data_item *temp = t; + while (temp && !equal(temp->first, key)){ + temp = temp->next; + } + return temp; + } + + + iterator find(const key_type& key) { + iterator iter; + + // find the insertion bucket + size_t bucket_index = hasher(key) & hash_mask; + // if the bucket is empty just add new data_item + if (!buckets[bucket_index].data) { + iter.bucket = NULL; + iter.data = NULL; + } else { // we already have data items in this bucket + data_item* temp = buckets[bucket_index].data; +// temp = iterate_find(temp,key); + + while (temp && !equal(temp->first, key)) + temp = temp->next; + + iter.data = temp; + if (!temp) + iter.bucket = NULL; + else + iter.bucket = &buckets[bucket_index]; + } + return iter; + } + + void erase(const key_type& key) { + // find the bucket + size_t bucket_index = hasher(key) & hash_mask; + // if the bucket is empty just add new data_item + if (!buckets[bucket_index].data) + return; + + data_item* temp = buckets[bucket_index].data; + data_item* prev = NULL; + while (temp && !equal(temp->first, key)) { + prev = temp; + temp = temp->next; + } + if (!temp) + return; + + // delete this data item from the chain + _size--; + if (!prev){ // we are deleting the first element in chain + buckets[bucket_index].data = temp->next; + + if(temp->next == NULL){ + if(buckets[bucket_index].next_bucket){ + buckets[bucket_index].next_bucket->prev_bucket = buckets[bucket_index].prev_bucket; + }else{ + last_bucket = buckets[bucket_index].prev_bucket; + } + if(buckets[bucket_index].prev_bucket){ + buckets[bucket_index].prev_bucket->next_bucket = buckets[bucket_index].next_bucket; + }else{ + first_bucket = buckets[bucket_index].next_bucket; + } + buckets[bucket_index].next_bucket = NULL; + buckets[bucket_index].prev_bucket = NULL; + } + }else{ + prev->next = temp->next; + } + delete temp; + total_memory -= sizeof(data_item); + } + + void erase_full(const key_type& key) { + // find the bucket + size_t bucket_index = hasher(key) & hash_mask; + // if the bucket is empty just add new data_item + if (!buckets[bucket_index].data) + return; + + data_item* temp = buckets[bucket_index].data; + data_item* prev = NULL; + while (temp && !equal(temp->first, key)) { + prev = temp; + temp = temp->next; + } + if (!temp) + return; + + // delete this data item from the chain + _size--; + if (!prev){ // we are deleting the first element in chain + buckets[bucket_index].data = temp->next; + + if(temp->next == NULL){ + if(buckets[bucket_index].next_bucket){ + buckets[bucket_index].next_bucket->prev_bucket = buckets[bucket_index].prev_bucket; + }else{ + last_bucket = buckets[bucket_index].prev_bucket; + } + if(buckets[bucket_index].prev_bucket){ + buckets[bucket_index].prev_bucket->next_bucket = buckets[bucket_index].next_bucket; + }else{ + first_bucket = buckets[bucket_index].next_bucket; + } + buckets[bucket_index].next_bucket = NULL; + buckets[bucket_index].prev_bucket = NULL; + } + }else{ + prev->next = temp->next; + } + delete (*temp).first; + delete (*temp).second; + delete temp; + total_memory -= sizeof(data_item); + } + + iterator begin() { + iterator iter; + // find the first data item + iter.bucket = first_bucket; + iter.data = (first_bucket) ? first_bucket->data : NULL; + return iter; + } + + iterator end() { + iterator iter; + iter.bucket = NULL; + iter.data = NULL; + return iter; + } + + void clear() { + data_item* temp; + data_item* next; + + hash_bucket* tmp; + while (first_bucket) { + temp = first_bucket->data; + while ( (next = temp->next) ) { + delete temp; + temp = next; + } + if(temp) delete(temp); + first_bucket->data = NULL; + tmp = first_bucket; + first_bucket = first_bucket->next_bucket; + tmp->next_bucket = NULL; + tmp->prev_bucket = NULL; + } + last_bucket = NULL; + _size = 0; + total_memory = num_buckets * sizeof(hash_bucket); + + } + + int rehash() { + if (_size) { + fprintf(stderr, "Error: rehashing non-empty hash table\n"); + exit(1); + } + + double max_load = (1.0 * _max_size) / num_buckets; + if (max_load > load_factor ) { + delete[] buckets; + // roughly double the size of the table + + num_buckets *= 2; + hash_mask = num_buckets-1; + + buckets = new hash_bucket[num_buckets]; + total_memory = num_buckets * sizeof(hash_bucket); + } + _max_size = _size; + return 0; + } + + + size_t size() const { + return _size; + } + + bool empty() const { + return (_size == 0); + } + + ~hash_table() { + clear(); + delete[] buckets; + } + + unsigned int get_mem_footprint() { + return total_memory; + } + +}; + + +template +class hash_set { + +public : + struct data_item { + key_type key; + data_item* next; // next data item in overflow chain + + data_item(const key_type& k) : key(k), next(NULL) { } + }; + + struct hash_bucket { + data_item* data; // + hash_bucket* next_bucket; // index of the next bucket in the list of used buckets + + hash_bucket() { + data = NULL; + next_bucket = 0; // 0 means no bucket follows this one + } + }; + + struct iterator { + hash_bucket* bucket; + data_item* data; + + iterator& operator++() { + if (data->next) + data = data->next; + else { + bucket = bucket->next_bucket; + if (bucket) + data = bucket->data; + else + data = NULL; + } + return *this; + } + + bool operator!=(const iterator& it) { + return (data != it.data || bucket != it.bucket); + } + + bool operator==(const iterator& it) { + return (data == it.data && bucket == it.bucket); + } + +// NOTE : not certain if returning ref always works + key_type &operator*() { + return data->key; + } + }; + +private: + hasher_func hasher; + equal_func equal; + + double load_factor; +// double max_load; + + size_t _size; + size_t _max_size; + size_t num_buckets; + size_t hash_mask; + + hash_bucket* first_bucket; // first used bucket + hash_bucket* last_bucket; // last used bucket + + hash_bucket* buckets; + +public: + hash_set(const size_t n_buckets = 131072, const double load = 0.75) { + load_factor = load; + + int nb; + for(nb=2;nbnext_bucket = &buckets[bucket_index]; + last_bucket = &buckets[bucket_index]; + } else { // we already have data items in this bucket + // prepend the item to overflow chain + data_item* temp = buckets[bucket_index].data; + buckets[bucket_index].data = d; + d->next = temp; + } + _size++; + if(_size>_max_size) + _max_size = _size; + + return 0; + } + + iterator find(const key_type& key) { + iterator iter; + + // find the insertion bucket + size_t bucket_index = hasher(key) & hash_mask; + // if the bucket is empty just add new data_item + if (!buckets[bucket_index].data) { + iter.bucket = NULL; + iter.data = NULL; + } else { // we already have data items in this bucket + data_item* temp = buckets[bucket_index].data; + while (temp && !equal(temp->key, key)) + temp = temp->next; + iter.data = temp; + if (!temp) + iter.bucket = NULL; + else + iter.bucket = &buckets[bucket_index]; + } + return iter; + } + + void erase(const key_type& key) { + // find the bucket + size_t bucket_index = hasher(key) & hash_mask; + // if the bucket is empty just add new data_item + if (!buckets[bucket_index].data) + return; + + data_item* temp = buckets[bucket_index].data; + data_item* prev = NULL; + while (temp && !equal(temp->key, key)) { + prev = temp; + temp = temp->next; + } + if (!temp) + return; + + // delete this data item from the chain + _size--; + if (!prev) // we are deleting the first element in chain + buckets[bucket_index].data = temp->next; + else + prev->next = temp->next; + delete temp; + } + + iterator begin() { + iterator iter; + // find the first data item + iter.bucket = first_bucket; + iter.data = (first_bucket) ? first_bucket->data : NULL; + return iter; + } + + iterator end() { + iterator iter; + iter.bucket = NULL; + iter.data = NULL; + return iter; + } + + void clear() { + data_item* temp; + data_item* next; + + hash_bucket* tmp; + while (first_bucket) { + temp = first_bucket->data; + while ( (next = temp->next) ) { + delete temp; + temp = next; + } + if(temp) delete(temp); + first_bucket->data = NULL; + tmp = first_bucket; + first_bucket = first_bucket->next_bucket; + tmp->next_bucket = NULL; + } + last_bucket = NULL; + _size = 0; + + } + + int rehash() { + if (_size) { + fprintf(stderr, "Error: rehashing non-empty hash table\n"); + exit(1); + } + + double max_load = (1.0 * _max_size) / num_buckets; + + if (max_load > load_factor ) { + delete[] buckets; + // roughly double the size of the table + + num_buckets *= 2; + hash_mask = num_buckets -1; + buckets = new hash_bucket[num_buckets]; + } + _max_size = _size; + return 0; + } + + + size_t size() const { + return _size; + } + + bool empty() const { + return (_size == 0); + } + + ~hash_set() { + clear(); + delete[] buckets; + } + +}; + + +#endif // __HASH_TABLE_H diff --git a/include/hfta/hfta.h b/include/hfta/hfta.h new file mode 100644 index 0000000..535b375 --- /dev/null +++ b/include/hfta/hfta.h @@ -0,0 +1,1097 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __HFTA_H +#define __HFTA_H + +#include "gstypes.h" +#include "host_tuple.h" +#include "base_operator.h" +#include +#include +#include "rdtsc.h" +using namespace std; + +#define hfta_ullong_hashfunc(x) (((int)(*(x)))^((int)((*(x))>>32))) +#define LLMIN(x,y) ((x)<(y)?(x):(y)) +#define LLMAX(x,y) ((x)<(y)?(y):(x)) +#define UMIN(x,y) ((x)<(y)?(x):(y)) +#define UMAX(x,y) ((x)<(y)?(y):(x)) +#define EQ(x,y) ((x)==(y)) +#define GEQ(x,y) ((x)>=(y)) +#define LEQ(x,y) ((x)<=(y)) +// Cast away temporality +#define non_temporal(x)(x) + + + +extern "C" { +#include +#include +#include +#include +#include +} + +struct param_block { + gs_int32_t block_length; + void* data; +}; + +// forward declaration of operator_node +struct operator_node; + +struct lfta_info { + gs_schemahandle_t schema_handle; + gs_sp_t schema; + gs_sp_t fta_name; +#ifdef PLAN_DAG + list parent_list; + list out_channel_list; +#else + operator_node* parent; + unsigned output_channel; +#endif + FTAID f; + + lfta_info() { + schema_handle = -1; + schema = NULL; + #ifndef PLAN_DAG + parent = NULL; + output_channel = 0; + #endif + } + + ~lfta_info() { + if (fta_name) + free (fta_name); + if (schema) + free (schema); + if (schema_handle >= 0) + ftaschema_free(schema_handle); + } +}; + + +struct operator_node { + base_operator* op; + +#ifdef PLAN_DAG + list parent_list; + list out_channel_list; +#else + operator_node* parent; +#endif + + operator_node* left_child; + operator_node* right_child; + lfta_info* left_lfta; + lfta_info* right_lfta; + + list input_queue; + + operator_node(base_operator* o) { + op = o; + #ifndef PLAN_DAG + parent = NULL; + #endif + left_child = right_child = NULL; + left_lfta = right_lfta = NULL; + } + + ~operator_node() { + delete op; + } + + void set_left_child_node(operator_node* child) { + left_child = child; + if (child) { + #ifdef PLAN_DAG + child->parent_list.push_back(this); + child->out_channel_list.push_back(0); + #else + child->parent = this; + child->op->set_output_channel(0); + #endif + } + } + + void set_right_child_node(operator_node* child) { + right_child = child; + if (child) { + #ifdef PLAN_DAG + child->parent_list.push_back(this); + child->out_channel_list.push_back(1); + #else + child->parent = this; + child->op->set_output_channel(1); + #endif + } + } + + void set_left_lfta(lfta_info* l_lfta) { + left_lfta = l_lfta; + if (left_lfta) { + #ifdef PLAN_DAG + left_lfta->parent_list.push_back(this); + left_lfta->out_channel_list.push_back(0); + #else + left_lfta->parent = this; + left_lfta->output_channel = 0; + #endif + } + } + + void set_right_lfta(lfta_info* r_lfta) { + right_lfta = r_lfta; + if (right_lfta) { + #ifdef PLAN_DAG + right_lfta->parent_list.push_back(this); + right_lfta->out_channel_list.push_back(1); + #else + right_lfta->parent = this; + right_lfta->output_channel = 1; + #endif + } + } + +}; + + + +int get_lfta_params(gs_int32_t sz, void * value, list& lst); +void finalize_tuple(host_tuple &tup); +void finalize_tuple(host_tuple &tup); +gs_retval_t UNOP_HFTA_free_fta (struct FTA *ftap, gs_uint32_t recursive); +gs_retval_t UNOP_HFTA_control_fta (struct FTA *ftap, gs_int32_t command, gs_int32_t sz, void * value); +gs_retval_t UNOP_HFTA_accept_packet (struct FTA *ftap, FTAID *ftaid, void * packet, gs_int32_t length); +gs_retval_t UNOP_HFTA_clock_fta(struct FTA *ftap); + +gs_retval_t MULTOP_HFTA_free_fta (struct FTA *ftap, gs_uint32_t recursive); +gs_retval_t MULTOP_HFTA_control_fta (struct FTA *ftap, gs_int32_t command, gs_int32_t sz, void * value); +gs_retval_t MULTOP_HFTA_accept_packet (struct FTA *ftap, FTAID *ftaid, void * packet, gs_int32_t length); +gs_retval_t MULTOP_HFTA_clock_fta(struct FTA *ftap); + +struct UNOP_HFTA { + struct FTA _fta; + base_operator* oper; + FTAID f; + bool failed; + gs_schemahandle_t schema_handle; + + list output_queue; + + // To create an hfta we will need all the parameters passed to alloc_fta by host library plus + // lfta_name and an instance of the base_operator + // We don't need to know the output schema as this information is already embeded + // in create_output_tuple method of operators' functor. + UNOP_HFTA(struct FTAID ftaid, FTAID child_ftaid, gs_int32_t command, gs_int32_t sz, void * value, base_operator* op, + gs_csp_t fta_name, char* schema, gs_schemahandle_t sch_handle, bool fta_reusable, gs_uint32_t reuse_option) { + + failed = false; + oper = op; + f = child_ftaid; + schema_handle = sch_handle; + + // assign streamid + _fta.ftaid = ftaid; + _fta.ftaid.streamid = (gs_p_t)this; + +#ifdef DEBUG + fprintf(stderr,"Instantiate a FTA\n"); +#endif + /* extract lfta param block from hfta param block */ + list param_list; + get_lfta_params(sz, value, param_list); + param_block param = param_list.front(); + + + gs_uint32_t reuse_flag = 2; + // we will try to create a new instance of child FTA only if it is parameterized + if (param.block_length > 0 && (reuse_option == 0 || (!fta_reusable && reuse_option == 2))) { + f.streamid = 0; // not interested in existing instances + reuse_flag = 0; + } + + if ((fta_alloc_instance(_fta.ftaid, &f,fta_name,schema,reuse_flag, FTA_COMMAND_LOAD_PARAMS,param.block_length,param.data))!=0) { + fprintf(stderr,"HFTA::error:could instantiate a FTA"); + failed = true; + return; + } + + free(param.data); + // set the operator's parameters + if(oper->set_param_block(sz, (void*)value)) failed = true;; + + + fprintf(stderr,"HFTA::Low level FTA (%s) instanciation done\n", fta_name); + _fta.stream_subscribed_cnt = 1; + _fta.stream_subscribed[0] = f; + + _fta.alloc_fta = NULL; // why should this be a part of the FTA (it is a factory function) + _fta.free_fta = UNOP_HFTA_free_fta; + _fta.control_fta = UNOP_HFTA_control_fta; + _fta.accept_packet = UNOP_HFTA_accept_packet; + _fta.clock_fta = UNOP_HFTA_clock_fta; + } + + ~UNOP_HFTA() { + delete oper; // free operators memory + + } + + int flush() { + list res; + if (!oper->flush(res)) { + + if (!res.empty()) { + // go through the list of returned tuples and finalyze them + list::iterator iter = res.begin(); + while (iter != res.end()) { + host_tuple& tup = *iter; + + // finalize the tuple + if (tup.tuple_size) + finalize_tuple(tup); + iter++; + } + + // append returned list to output_queue + output_queue.splice(output_queue.end(), res); + + + // post tuples + while (!output_queue.empty()) { + host_tuple& tup = output_queue.front(); + #ifdef DEBUG + fprintf(stderr, "HFTA::about to post tuple\n"); + #endif + if (hfta_post_tuple(&_fta,tup.tuple_size,tup.data) == 0) { + tup.free_tuple(); + output_queue.pop_front(); + } else + break; + } + } + } + + return 0; + } + + bool init_failed(){return failed;} +}; + +gs_retval_t UNOP_HFTA_free_fta (struct FTA *fta, gs_uint32_t recursive) { + UNOP_HFTA* ftap = (UNOP_HFTA*)fta; // deallocate the fta and call the destructor + // will be called on program exit + + if (recursive) + // free instance we are subscribed to + fta_free_instance(gscpipc_getftaid(), ftap->f, recursive); + + delete ftap; + return 0; +} + +gs_retval_t UNOP_HFTA_control_fta (struct FTA *fta, gs_int32_t command, gs_int32_t sz, void * value) { + UNOP_HFTA* ftap = (UNOP_HFTA*)fta; + + if (command == FTA_COMMAND_FLUSH) { + // ask lfta to do the flush + fta_control(gscpipc_getftaid(), ftap->f, FTA_COMMAND_FLUSH, sz, value); + ftap->flush(); + + } else if (command == FTA_COMMAND_LOAD_PARAMS) { + // ask lfta to do the flush + fta_control(gscpipc_getftaid(), ftap->f, FTA_COMMAND_FLUSH, sz, value); + ftap->flush(); + + /* extract lfta param block from hfta param block */ + list param_list; + get_lfta_params(sz, value, param_list); + param_block param = param_list.front(); + // load new parameters into lfta + fta_control(gscpipc_getftaid(), ftap->f, FTA_COMMAND_LOAD_PARAMS, param.block_length,param.data); + free(param.data); + + // notify the operator about the change of parameter + ftap->oper->set_param_block(sz, (void*)value); + + } else if (command == FTA_COMMAND_GET_TEMP_STATUS) { + // we no longer use temp_status commands + // hearbeat mechanism is used instead + } + return 0; +} + +gs_retval_t UNOP_HFTA_accept_packet (struct FTA *fta, FTAID *ftaid, void * packet, gs_int32_t length) { + UNOP_HFTA* ftap = (UNOP_HFTA*)fta; +#ifdef DEBUG + fprintf(stderr, "HFTA::accepted packet\n"); +#endif + if (!length) /* ignore null tuples */ + return 0; + + host_tuple temp; + temp.tuple_size = length; + temp.data = packet; + temp.channel = 0; + temp.heap_resident = false; + + // pass the tuple to operator + list res; + int ret; + fta_stat* tup_trace = NULL; + gs_uint32_t tup_trace_sz = 0; + gs_uint64_t trace_id = 0; + bool temp_tuple_received = false; + + + // if the tuple is temporal we need to extract the hearbeat payload + if (ftaschema_is_temporal_tuple(ftap->schema_handle, packet)) { + temp_tuple_received = true; + if (ftaschema_get_trace(ftap->schema_handle, packet, length, &trace_id, &tup_trace_sz, &tup_trace)) + fprintf(stderr, "HFTA error: received temporal status tuple with no trace\n"); + } + + if (ftaschema_is_eof_tuple(ftap->schema_handle, packet)) { + /* perform a flush */ + ftap->flush(); + + /* post eof_tuple to a parent */ + host_tuple eof_tuple; + ftap->oper->get_temp_status(eof_tuple); + + /* last byte of the tuple specifies the tuple type + * set it to EOF_TUPLE + */ + *((char*)eof_tuple.data + (eof_tuple.tuple_size - sizeof(char))) = EOF_TUPLE; + hfta_post_tuple(fta,eof_tuple.tuple_size,eof_tuple.data); + + return 0; + } + + ret = ftap->oper->accept_tuple(temp, res); + + // go through the list of returned tuples and finalyze them + list::iterator iter = res.begin(); + while (iter != res.end()) { + host_tuple& tup = *iter; + + // finalize the tuple + if (tup.tuple_size) + finalize_tuple(tup); + iter++; + } + + // if we received temporal tuple, last tuple of the result must be temporal too + // we need to extend the trace by adding ftaid and send a hearbeat to clearinghouse + if (temp_tuple_received) { + fta_stat stats; + host_tuple& temp_tup = res.back(); + + + int new_tuple_size = temp_tup.tuple_size + sizeof(gs_uint64_t) + (tup_trace_sz + 1)* sizeof(fta_stat); + char* new_data = (char*)malloc(new_tuple_size); + memcpy(new_data, temp_tup.data, temp_tup.tuple_size); + memcpy(new_data + temp_tup.tuple_size, &trace_id, sizeof(gs_uint64_t)); + memcpy(new_data + temp_tup.tuple_size + sizeof(gs_uint64_t), (char*)tup_trace, tup_trace_sz * sizeof(fta_stat)); + memcpy(new_data + temp_tup.tuple_size + sizeof(gs_uint64_t) + tup_trace_sz * sizeof(fta_stat), (char*)ftaid, sizeof(FTAID)); + + memset((char*)&stats, 0, sizeof(fta_stat)); + memcpy(new_data + temp_tup.tuple_size + sizeof(gs_uint64_t) + tup_trace_sz * sizeof(fta_stat), (char*)&stats, sizeof(fta_stat)); + + // Send a hearbeat message to clearinghouse. + fta_heartbeat(ftap->_fta.ftaid, trace_id, tup_trace_sz + 1, (fta_stat *)((char*)new_data + temp_tup.tuple_size + sizeof(gs_uint64_t))); + + temp_tup.free_tuple(); + temp_tup.data = new_data; + temp_tup.tuple_size = new_tuple_size; + } + + // append returned list to output_queue + ftap->output_queue.splice(ftap->output_queue.end(), res); + + // post tuples + while (!ftap->output_queue.empty()) { + host_tuple& tup = ftap->output_queue.front(); + #ifdef DEBUG + fprintf(stderr, "HFTA::about to post tuple\n"); + #endif + if (hfta_post_tuple(fta,tup.tuple_size,tup.data) == 0) { + tup.free_tuple(); + ftap->output_queue.pop_front(); + } else + break; + } + + return 1; +} + +gs_retval_t UNOP_HFTA_clock_fta(struct FTA *ftap) { + + // Send a hearbeat message to clearinghouse.to indicate we are alive + fta_heartbeat(ftap->ftaid, 0, 0, 0); + + return 0; +} + + +struct MULTOP_HFTA { + struct FTA _fta; + gs_csp_t fta_name; + gs_schemahandle_t schema_handle; + operator_node* root; + vector sorted_nodes; + int num_operators; + list *lfta_list; + /* number of eof tuples we received so far + * receiving eof tuples from every source fta will cause a flush + */ + int num_eof_tuples; + + bool failed; + bool reusable; + + list output_queue; + + // Runtime stats + gs_uint32_t in_tuple_cnt; + gs_uint32_t out_tuple_cnt; + gs_uint32_t out_tuple_sz; + gs_uint64_t cycle_cnt; + + gs_uint64_t trace_id; + + // memory occupied by output queue + gs_uint32_t output_queue_mem; + + + // To create an hfta we will need all the parameters passed to alloc_fta by host library plus + // lfta_name and an instance of the base_operator. We don't need to know the schema for lfta, + // as the schema handle is already passed during operator creation time. + // We also don't need to know the output schema as this information is already embeded + // in create_output_tuple method of operators' functor. + + + + MULTOP_HFTA(struct FTAID ftaid, gs_csp_t name, gs_int32_t command, gs_int32_t sz, void * value, gs_schemahandle_t sch_handle, operator_node* node, + list *lftas, bool fta_reusable, gs_uint32_t reuse_option) { + + fta_name = name; + failed = false; + + root = node; + lfta_list = lftas; + + // assign streamid + _fta.ftaid = ftaid; + _fta.ftaid.streamid = (gs_p_t)this; + + schema_handle = sch_handle; + + output_queue_mem = 0; + + // topologically sort the operators in the tree (or DAG) + // for DAG we make sure we add the node to the sorted list only once + operator_node* current_node; + map node_map; + vector node_list; + + int i = 0; + node_list.push_back(root); + node_map[root] = 0; + + num_operators = 1; + + while (i < node_list.size()) { + current_node = node_list[i]; + if (current_node->left_child && node_map.find(current_node->left_child) == node_map.end()) { + node_map[current_node->left_child] = num_operators++; + node_list.push_back(current_node->left_child); + } + if (current_node->right_child && node_map.find(current_node->right_child) == node_map.end()) { + node_map[current_node->right_child] = num_operators++; + node_list.push_back(current_node->right_child); + } + i++; + } + num_operators = i; + + // build adjacency lists for query DAG + list* adj_lists = new list[num_operators]; + bool* leaf_flags = new bool[num_operators]; + memset(leaf_flags, 0, num_operators * sizeof(bool)); + for (i = 0; i < num_operators; ++i) { + current_node = node_list[i]; + if (current_node->left_child) { + adj_lists[i].push_back(node_map[current_node->left_child]); + } + if (current_node->right_child && current_node->left_child != current_node->right_child) { + adj_lists[i].push_back(node_map[current_node->right_child]); + } + } + + // run topolofical sort + bool leaf_found = true; + while (leaf_found) { + leaf_found = false; + // add all leafs to sorted_nodes + for (i = 0; i < num_operators; ++i) { + if (!leaf_flags[i] && adj_lists[i].empty()) { + leaf_flags[i] = true; + sorted_nodes.push_back(node_list[i]); + leaf_found = true; + + // remove the node from its parents adjecency lists + for (int j = 0; j < num_operators; ++j) { + list::iterator iter; + for (iter = adj_lists[j].begin(); iter != adj_lists[j].end(); iter++) { + if (*iter == i) { + adj_lists[j].erase(iter); + break; + } + } + } + } + } + } + + delete[] adj_lists; + delete[] leaf_flags; + + // set the parameter block for every operator in tree + for (i = 0; i < num_operators; ++i) + if(sorted_nodes[i]->op->set_param_block(sz, (void*)value)) failed = true; + +#ifdef DEBUG + fprintf(stderr,"Instantiate FTAs\n"); +#endif + /* extract lfta param block from hfta param block */ +// NOTE: param_list must line up with lfta_list + list param_list; + get_lfta_params(sz, value, param_list); + list::iterator iter1; + list::iterator iter2 = lfta_list->begin(); + + for (iter1 = param_list.begin(), i = 0; iter1 != param_list.end(); iter1++, iter2++, i++) { + lfta_info* inf = *iter2; + + #ifdef DEBUG + fprintf(stderr,"Instantiate a FTA\n"); + #endif + + gs_uint32_t reuse_flag = 2; + + // we will try to create a new instance of child FTA only if it is parameterized + if ((*iter1).block_length > 0 && (reuse_option == 0 || (!fta_reusable && reuse_option == 2))) { + (*iter2)->f.streamid = 0; // not interested in existing instances + reuse_flag = 0; + } + if (fta_alloc_instance(_fta.ftaid, &(*iter2)->f,(*iter2)->fta_name, (*iter2)->schema, reuse_flag, FTA_COMMAND_LOAD_PARAMS,(*iter1).block_length,(*iter1).data)!=0) { + fprintf(stderr,"HFTA::error:could instantiate a FTA"); + failed = true; + return; + } + + free((*iter1).data); + + //fprintf(stderr,"HFTA::Low level FTA instanciation done\n"); + + _fta.stream_subscribed[i]=(*iter2)->f; + } + _fta.stream_subscribed_cnt = i; + + num_eof_tuples = 0; + + _fta.alloc_fta = NULL; // why should this be a part of the FTA (it is a factory function) + _fta.free_fta = MULTOP_HFTA_free_fta; + _fta.control_fta = MULTOP_HFTA_control_fta; + _fta.accept_packet = MULTOP_HFTA_accept_packet; + _fta.clock_fta = MULTOP_HFTA_clock_fta; + + // init runtime stats + in_tuple_cnt = 0; + out_tuple_cnt = 0; + out_tuple_sz = 0; + cycle_cnt = 0; + + } + + ~MULTOP_HFTA() { + + list::iterator iter; + int i = 0; + + for (iter = lfta_list->begin(); i < _fta.stream_subscribed_cnt; iter++, i++) { + delete *iter; + } + + delete root; // free operators memory + delete lfta_list; + + + } + + int flush() { + + list res; + + // go through the list of operators in topological order + // and flush them + list::iterator iter; + list temp_output_queue; + + for (int i = 0; i < num_operators; ++i) { + operator_node* node = sorted_nodes[i]; + +#ifdef PLAN_DAG + list& current_output_queue = (i < (num_operators - 1)) ? temp_output_queue : res; +#else + // for trees we can put output tuples directly into parent's input buffer + list& current_output_queue = (i < (num_operators - 1)) ? node->parent->input_queue : res; +#endif + // consume tuples waiting in your queue + for (iter = node->input_queue.begin(); iter != node->input_queue.end(); iter++) { + node->op->accept_tuple(*(iter), current_output_queue); + } + node->op->flush(current_output_queue); + node->input_queue.clear(); + +#ifdef PLAN_DAG + // copy the tuples from output queue into input queues of all parents + list::iterator node_iter; + + if (!node->parent_list.empty()) { + // append the content of the output queue to parent input queue + + for (iter = temp_output_queue.begin(); iter != temp_output_queue.end(); iter++) { + int* ref_cnt = 0; + if (node->parent_list.size() > 1) { + ref_cnt = (int*)malloc(sizeof(int)); + *ref_cnt = node->parent_list.size() - 1; + } + + for (node_iter = node->parent_list.begin(); node_iter != node->parent_list.end(); node_iter++) { + (*iter).ref_cnt = ref_cnt; + (*node_iter)->input_queue.push_back(*iter); + } + } + } +#endif + } + + if (!res.empty()) { + // go through the list of returned tuples and finalyze them + list::iterator iter = res.begin(); + while (iter != res.end()) { + host_tuple& tup = *iter; + + // finalize the tuple + if (tup.tuple_size) + finalize_tuple(tup); + + output_queue_mem += tup.tuple_size; + iter++; + } + + // append returned list to output_queue + output_queue.splice(output_queue.end(), res); + + + // post tuples + while (!output_queue.empty()) { + host_tuple& tup = output_queue.front(); + #ifdef DEBUG + fprintf(stderr, "HFTA::about to post tuple\n"); + #endif + if (hfta_post_tuple(&_fta,tup.tuple_size,tup.data) == 0) { + output_queue_mem -= tup.tuple_size; + tup.free_tuple(); + output_queue.pop_front(); + } else + break; + } + } + + return 0; + } + + bool init_failed(){return failed;} +}; + + +gs_retval_t MULTOP_HFTA_free_fta (struct FTA *fta, gs_uint32_t recursive) { + MULTOP_HFTA* ftap = (MULTOP_HFTA*)fta; // deallocate the fta and call the destructor + // will be called on program exit + + if (recursive) { + // free instance we are subscribed to + list::iterator iter; + int i = 0; + + for (iter = ftap->lfta_list->begin(); i < fta->stream_subscribed_cnt; iter++, i++) { + fta_free_instance(gscpipc_getftaid(), (*iter)->f, recursive); + } + } + + delete ftap; + return 0; +} + +gs_retval_t MULTOP_HFTA_control_fta (struct FTA *fta, gs_int32_t command, gs_int32_t sz, void * value) { + MULTOP_HFTA* ftap = (MULTOP_HFTA*)fta; + + if (command == FTA_COMMAND_FLUSH) { + + // ask lftas to do the flush + list::iterator iter; + for (iter = ftap->lfta_list->begin(); iter != ftap->lfta_list->end(); iter++) { + fta_control(gscpipc_getftaid(), (*iter)->f, FTA_COMMAND_FLUSH, sz, value); + } + // flush hfta operators + ftap->flush(); + + } else if (command == FTA_COMMAND_LOAD_PARAMS) { + + list param_list; + get_lfta_params(sz, value, param_list); + + // ask lftas to do the flush and set new parameters + list::iterator iter; + list::iterator iter2; + for (iter = ftap->lfta_list->begin(), iter2 = param_list.begin(); iter != ftap->lfta_list->end(); iter++, iter2++) { + fta_control(gscpipc_getftaid(), (*iter)->f, FTA_COMMAND_FLUSH, 0, NULL); + fta_control(gscpipc_getftaid(), (*iter)->f, FTA_COMMAND_LOAD_PARAMS, (*iter2).block_length,(*iter2).data); + free((*iter2).data); + } + // flush hfta operators + ftap->flush(); + + // set the new parameter block for every operator in tree + for (int i = 0; i < ftap->num_operators; ++i) + ftap->sorted_nodes[i]->op->set_param_block(sz, (void*)value); + + } else if (command == FTA_COMMAND_GET_TEMP_STATUS) { + // we no longer use temp_status commands + // hearbeat mechanism is used instead + } + return 0; +} + +gs_retval_t MULTOP_HFTA_accept_packet (struct FTA *fta, FTAID *ftaid, void * packet, gs_int32_t length) { + MULTOP_HFTA* ftap = (MULTOP_HFTA*)fta; + + gs_uint64_t start_cycle = rdtsc(); +#ifdef DEBUG + fprintf(stderr, "HFTA::accepted packet\n"); +#endif + if (!length) /* ignore null tuples */ + return 0; + + ftap->in_tuple_cnt++; + + host_tuple temp; + temp.tuple_size = length; + temp.data = packet; + temp.channel = 0; + temp.heap_resident = false; + +// fprintf(stderr,"created temp, channel=%d, resident=%d\n",temp.channel, (int)temp.heap_resident); + + // find from which lfta the tuple came + list::iterator iter; + lfta_info* inf = NULL; + int i; + + for (i = 0, iter = ftap->lfta_list->begin(); i < ftap->_fta.stream_subscribed_cnt; iter++, i++) { + if (ftap->_fta.stream_subscribed[i].ip == ftaid->ip && + ftap->_fta.stream_subscribed[i].port == ftaid->port && + ftap->_fta.stream_subscribed[i].index == ftaid->index && + ftap->_fta.stream_subscribed[i].streamid == ftaid->streamid) { + inf = *iter; + break; + } + } + + if (!inf) { + fprintf(stderr,"HFTA::error:received tuple from unknown stream\n"); + exit(1); + } + + // route tuple through operator chain + list result; + host_tuple tup; + int ret; + #ifndef PLAN_DAG + temp.channel = inf->output_channel; + #endif + operator_node* current_node = NULL, *child = NULL; + list temp_output_queue; + + + fta_stat* tup_trace = NULL; + gs_uint32_t tup_trace_sz = 0; + gs_uint64_t trace_id = 0; + bool temp_tuple_received = false; + + // if the tuple is temporal we need to extract the heartbeat payload + if (ftaschema_is_temporal_tuple(inf->schema_handle, packet)) { + temp_tuple_received = true; + if (ftaschema_get_trace(inf->schema_handle, packet, length, &trace_id, &tup_trace_sz, &tup_trace)) + fprintf(stderr, "HFTA error: received temporal status tuple with no trace\n"); + } + + if (ftaschema_is_eof_tuple(inf->schema_handle, packet)) { + + if (++ftap->num_eof_tuples < ftap->lfta_list->size()) + return 0; + + ftap->num_eof_tuples = 0; + + /* perform a flush */ + ftap->flush(); + + /* post eof_tuple to a parent */ + host_tuple eof_tuple; + ftap->sorted_nodes[ftap->num_operators - 1]->op->get_temp_status(eof_tuple); + + /* last byte of the tuple specify the tuple type + * set it to EOF_TUPLE + */ + *((char*)eof_tuple.data + (eof_tuple.tuple_size - sizeof(char))) = EOF_TUPLE; + hfta_post_tuple(fta,eof_tuple.tuple_size,eof_tuple.data); + ftap->out_tuple_cnt++; + ftap->out_tuple_sz+=eof_tuple.tuple_size; + + return 0; + } + + list::iterator iter2; + +#ifdef PLAN_DAG + + // push tuple to all parent operators of the lfta + list::iterator node_iter; + list::iterator chan_iter; + for (node_iter = inf->parent_list.begin(), chan_iter = inf->out_channel_list.begin(); node_iter != inf->parent_list.end(); node_iter++, chan_iter++) { + temp.channel = *chan_iter; + (*node_iter)->input_queue.push_back(temp); + } + + for (i = 0; i < ftap->num_operators; ++i) { + + operator_node* node = ftap->sorted_nodes[i]; + list& current_output_queue = (i < (ftap->num_operators - 1)) ? temp_output_queue : result; + + // consume tuples waiting in your queue + for (iter2 = node->input_queue.begin(); iter2 != node->input_queue.end(); iter2++) { + node->op->accept_tuple(*(iter2), current_output_queue); + } + node->input_queue.clear(); + + // copy the tuples from output queue into input queues of all parents + + if (!node->parent_list.empty()) { + + // append the content of the output queue to parent input queue + for (iter2 = temp_output_queue.begin(); iter2 != temp_output_queue.end(); iter2++) { + + int* ref_cnt = 0; + if (node->parent_list.size() > 1) { + ref_cnt = (int*)malloc(sizeof(int)); + *ref_cnt = node->parent_list.size() - 1; + } + + for (node_iter = node->parent_list.begin(), chan_iter = node->out_channel_list.begin(); node_iter != node->parent_list.end(); node_iter++, chan_iter++) { + (*iter2).ref_cnt = ref_cnt; + (*iter2).channel = *chan_iter; + (*node_iter)->input_queue.push_back(*iter2); + } + } + } + temp_output_queue.clear(); + } +#else + current_node = inf->parent; + +// fprintf(stderr,"Pushing temp, channel=%d, resident=%d\n",temp.channel, (int)temp.heap_resident); + current_node->input_queue.push_back(temp); + + do { +//fprintf(stderr,"Routing tuple, current node is %d, parent is %d\n",current_node,current_node->parent); + list& current_output_queue = (current_node->parent) ? current_node->parent->input_queue : result; + + // consume tuples waiting in your queue + for (iter2 = current_node->input_queue.begin(); iter2 != current_node->input_queue.end(); iter2++) { + current_node->op->accept_tuple((*iter2),current_output_queue); + } +// All consumed, delete them + current_node->input_queue.clear(); + current_node = current_node->parent; + + } while (current_node); +#endif + + + host_tuple temp_tup; + + bool no_temp_tuple = false; + + // if we received temporal tuple, last tuple of the result must be temporal too + // we need to extend the trace by adding ftaid and send a hearbeat to clearinghouse + if (temp_tuple_received) { + + if (result.empty()) { + no_temp_tuple = true; + + } else { + fta_stat stats; + temp_tup = result.back(); + finalize_tuple(temp_tup); + + int new_tuple_size = temp_tup.tuple_size + sizeof(gs_uint64_t) + (tup_trace_sz + 1)* sizeof(fta_stat); + char* new_data = (char*)malloc(new_tuple_size); + memcpy(new_data, temp_tup.data, temp_tup.tuple_size); + memcpy(new_data + temp_tup.tuple_size, &trace_id, sizeof(gs_uint64_t)); + memcpy(new_data + temp_tup.tuple_size + sizeof(gs_uint64_t), (char*)tup_trace, tup_trace_sz * sizeof(fta_stat)); + + + memset((char*)&stats, 0, sizeof(fta_stat)); + stats.ftaid = fta->ftaid; + stats.in_tuple_cnt = ftap->in_tuple_cnt; + stats.out_tuple_cnt = ftap->out_tuple_cnt; + stats.out_tuple_sz = ftap->out_tuple_sz; + stats.cycle_cnt = ftap->cycle_cnt; + memcpy(new_data + temp_tup.tuple_size + sizeof(gs_uint64_t) + tup_trace_sz * sizeof(fta_stat), (char*)&stats, sizeof(fta_stat)); + + // Send a hearbeat message to clearinghouse. + fta_heartbeat(fta->ftaid, trace_id, tup_trace_sz + 1, (fta_stat *)((char*)new_data + temp_tup.tuple_size + sizeof(gs_uint64_t))); + + // reset the stats + ftap->in_tuple_cnt = 0; + ftap->out_tuple_cnt = 0; + ftap->out_tuple_sz = 0; + ftap->cycle_cnt = 0; + + free(temp_tup.data); + temp_tup.data = new_data; + temp_tup.tuple_size = new_tuple_size; + result.pop_back(); + } + } + + // go through the list of returned tuples and finalyze them + // since we can produce multiple temporal tuples in DAG plans + // we can drop all of them except the last one + iter2 = result.begin(); + while(iter2 != result.end()) { + host_tuple tup = *iter2; + + // finalize the tuple + if (tup.tuple_size) { + finalize_tuple(tup); + + #ifdef PLAN_DAG + if (ftaschema_is_temporal_tuple(ftap->schema_handle, tup.data)) + tup.free_tuple(); + else + #endif + { + ftap->output_queue.push_back(tup); + ftap->output_queue_mem += tup.tuple_size; + } + + } + iter2++; + } + + // append returned list to output_queue + // ftap->output_queue.splice(ftap->output_queue.end(), result); + + if (temp_tuple_received && !no_temp_tuple) { + ftap->output_queue.push_back(temp_tup); + ftap->output_queue_mem += temp_tup.tuple_size; + } + + // post tuples + while (!ftap->output_queue.empty()) { + host_tuple& tup = ftap->output_queue.front(); + #ifdef DEBUG + fprintf(stderr, "HFTA::about to post tuple\n"); + #endif + if (hfta_post_tuple(fta,tup.tuple_size,tup.data) == 0) { + ftap->out_tuple_cnt++; + ftap->out_tuple_sz+=tup.tuple_size; + ftap->output_queue_mem -= tup.tuple_size; + tup.free_tuple(); + ftap->output_queue.pop_front(); + } else + break; + } + + ftap->cycle_cnt += rdtsc() - start_cycle; + + return 1; +} + +gs_retval_t MULTOP_HFTA_clock_fta(struct FTA *fta) { + MULTOP_HFTA* ftap = (MULTOP_HFTA*)fta; + +#ifdef HFTA_PROFILE + /* Print stats */ + fprintf(stderr, "FTA = %s|", ftap->fta_name); + fprintf(stderr, "in_tuple_cnt = %u|", ftap->in_tuple_cnt); + fprintf(stderr, "out_tuple_cnt = %u|", ftap->out_tuple_cnt); + fprintf(stderr, "out_tuple_sz = %u|", ftap->out_tuple_sz); + fprintf(stderr, "cycle_cnt = %llu|", ftap->cycle_cnt); + + + fprintf(stderr, "mem_footprint %s = %d", ftap->sorted_nodes[0]->op->get_name(), ftap->sorted_nodes[0]->op->get_mem_footprint()); + unsigned int total_mem = ftap->sorted_nodes[0]->op->get_mem_footprint(); + + for (int i = 1; i < ftap->num_operators; ++i) { + operator_node* node = ftap->sorted_nodes[i]; + fprintf(stderr, ",%s = %d", node->op->get_name(), node->op->get_mem_footprint()); + total_mem += node->op->get_mem_footprint(); + } + fprintf(stderr, ", total = %d|", total_mem ); + fprintf(stderr, "output_buffer_size = %d\n", ftap->output_queue_mem ); +#endif + + fta_stat stats; + memset((char*)&stats, 0, sizeof(fta_stat)); + stats.ftaid = fta->ftaid; + stats.in_tuple_cnt = ftap->in_tuple_cnt; + stats.out_tuple_cnt = ftap->out_tuple_cnt; + stats.out_tuple_sz = ftap->out_tuple_sz; + stats.cycle_cnt = ftap->cycle_cnt; + + // Send a hearbeat message to clearinghouse. + fta_heartbeat(fta->ftaid, ftap->trace_id++, 1, &stats); + + // resets runtime stats + ftap->in_tuple_cnt = 0; + ftap->out_tuple_cnt = 0; + ftap->out_tuple_sz = 0; + ftap->cycle_cnt = 0; + + return 0; +} + + +#endif // __HFTA_H + diff --git a/include/hfta/hfta_runtime_library.h b/include/hfta/hfta_runtime_library.h new file mode 100644 index 0000000..3a20ff3 --- /dev/null +++ b/include/hfta/hfta_runtime_library.h @@ -0,0 +1,118 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __HFTA_RUNTIME_LIBRARY__ +#define __HFTA_RUNTIME_LIBRARY__ +#include "host_tuple.h" +#include "gsconfig.h" +#include "gstypes.h" + +#define DNS_SAMPLE_HASH_SZ 50000000 +#define DNS_HITLIST_HASH_SZ 50000000 +#define DNS_HITLIST_ENTRY_SZ 500000 + + +// Internal functions +gs_retval_t Vstring_Constructor(vstring *, gs_csp_t); +gs_retval_t hfta_vstr_length(vstring *); +void hfta_vstr_assign_with_copy_in_tuple(vstring32 *, vstring *, gs_sp_t, int); +void hfta_vstr_assign_with_copy(vstring *, vstring *); +void hfta_vstr_destroy(vstring *); +void hfta_vstr_replace(vstring *, vstring *); + +gs_uint32_t hfta_vstr_hashfunc(const vstring *); +gs_retval_t hfta_vstr_compare(const vstring *, const vstring *); + +gs_retval_t hfta_ipv6_compare(const hfta_ipv6_str &i1, const hfta_ipv6_str &i2); +hfta_ipv6_str And_Ipv6(const hfta_ipv6_str &i1, const hfta_ipv6_str &i2); +hfta_ipv6_str Or_Ipv6(const hfta_ipv6_str &i1, const hfta_ipv6_str &i2); +gs_uint32_t hfta_ipv6_hashfunc(const hfta_ipv6_str *s) ; +hfta_ipv6_str hton_ipv6(hfta_ipv6_str s); +hfta_ipv6_str ntoh_ipv6(hfta_ipv6_str s); +gs_retval_t HFTA_Ipv6_Constructor(hfta_ipv6_str *s, gs_csp_t l) ; + + + + +// External functions + +inline static gs_retval_t str_truncate(vstring * result, vstring *str, gs_uint32_t length) { + result->offset=str->offset; + result->length=(str->lengthlength:length; + result->reserved=SHALLOW_COPY; + return 0; +} + +gs_retval_t str_exists_substr(vstring * s1, vstring * s2); +gs_retval_t str_compare(vstring * s1, vstring * s2); + +gs_uint32_t str_match_offset(gs_uint32_t offset,vstring *s1,vstring *s2); +gs_uint32_t byte_match_offset( gs_uint32_t offset, gs_uint32_t val,vstring *s2); + + +// REGEX functions + +gs_retval_t str_regex_match(vstring* str, gs_param_handle_t pattern_handle); +gs_param_handle_t register_handle_for_str_regex_match_slot_1(vstring* pattern); +gs_retval_t deregister_handle_for_str_regex_match_slot_1(gs_param_handle_t handle); + +gs_retval_t str_partial_regex_match(vstring* str, gs_param_handle_t pattern_handle); +gs_param_handle_t register_handle_for_str_partial_regex_match_slot_1(vstring* pattern); +gs_retval_t deregister_handle_for_str_partial_regex_match_slot_1(gs_param_handle_t handle); + +gs_param_handle_t register_handle_for_str_extract_regex_slot_1(vstring* pattern); +gs_retval_t str_extract_regex( vstring * result, vstring * str, gs_param_handle_t handle); +gs_retval_t deregister_handle_for_str_extract_regex_slot_1(gs_param_handle_t handle); + + + + +// type conversion +#define INT(c) ((int)(c)) +#define UINT(c) ((gs_uint32_t)(c)) +#define FLOAT(c) ((gs_float_t)(c)) +#define ULLONG(c) ((gs_uint64_t)(c)) + +// string conversions + +gs_uint32_t strtoi(gs_uint32_t * r, struct vstring *data); +gs_uint32_t strtoip(gs_uint32_t * r, struct vstring *data); + +// constant string conversions +gs_param_handle_t register_handle_for_strtoi_c_slot_0(vstring* istr) ; +gs_retval_t deregister_handle_for_strtoi_c_slot_0(gs_param_handle_t h) ; +#define strtoi_c(h) ((gs_uint32_t)(h)) + +gs_param_handle_t register_handle_for_strtoip_c_slot_0(vstring* istr) ; +gs_retval_t deregister_handle_for_strtoip_c_slot_0(gs_param_handle_t h) ; +#define strtoip_c(h) ((gs_uint32_t)(h)) + + +inline gs_uint32_t str_match_offset( gs_uint32_t offset, struct vstring * s1, struct vstring * s2) { + register gs_uint8_t *st1 = (gs_uint8_t *) s1->offset; + register gs_uint8_t *st2 = (gs_uint8_t *) (s2->offset+offset); + register gs_int32_t x; + register gs_int32_t len2 = s2->length-offset; + register gs_int32_t len1 = s1->length; + if (len2 +#include "fta.h" + + +/* vstring_type specifis the format in which vstirng data is stored +we will use the reserved field of vstirng to store the vstring_type +vstring_type desclaration should probably be in host.h +*/ +enum vstring_type { + // data immediately follows the tuple fields + PACKED, + // data allocated on a heap in one block + // offset is interpreted as pointer to data + INTERNAL, + // vstring is a shallow copy of another vstring (or its part) + // offset is interpreted as pointer to data + SHALLOW_COPY, + // data allocated on a heap as single linked list of data blocks + // offset is interpreted as pointer to the head of the list + // list node has the following format + // {int length, node* next) followed by the data block + SLIST, + // data allocated on a heap as double linked list of data blocks + // offset is interpreted as pointer to the head of the list + // list node has the following format + // {int length, node* next, node* prev) followed by the data block + DLIST +}; + +struct host_tuple { + + size_t tuple_size; // tuple size in bytes + void* data; // tuple data + unsigned int channel; // input or output channel the tuple should go to + bool heap_resident; // indicates whether tuple is heap or stack resident + + // we need to use reference counting for query plans that are DAGs +#ifdef PLAN_DAG + int* ref_cnt; + host_tuple() {ref_cnt = NULL;} +#endif + + + inline void free_tuple() { + if (heap_resident) { + #ifdef PLAN_DAG + if (!ref_cnt) + free(data); + else if (*ref_cnt == 0) { + free(data); + free(ref_cnt); + } else { + (*ref_cnt)--; + } + #else + free(data); + #endif + } + } + +}; + +#endif // HOST_TUPLE_H diff --git a/include/hfta/join_eq_hash_operator.h b/include/hfta/join_eq_hash_operator.h new file mode 100644 index 0000000..5038f7a --- /dev/null +++ b/include/hfta/join_eq_hash_operator.h @@ -0,0 +1,417 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef JOIN_EQ_HASH_OPERATOR_H +#define JOIN_EQ_HASH_OPERATOR_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +#include"hash_table.h" +using namespace std; + +#include + +#define JOIN_OP_INNER_JOIN 0 +#define JOIN_OP_LEFT_OUTER_JOIN 1 +#define JOIN_OP_RIGHT_OUTER_JOIN 2 +#define JOIN_OP_OUTER_JOIN 3 + + +#define MAX_TUPLE_SIZE 1024 + +template +class join_eq_hash_operator : public base_operator { +private : + // type of join : inner vs. outer + unsigned int join_type; +int n_calls, n_iters, n_eqk; + + // for tracing + int sch0, sch1; + + // list of tuples from one of the channel waiting to be compared + // against tuple from the other channel + list input_queue[2]; + +// Admission control timestamp objects + timestamp *max_input_ts[2], *curr_ts; + bool hash_empty, curr_ts_valid; + +// max tuples received from input channels + char max_input_tuple_data[2][MAX_TUPLE_SIZE]; + host_tuple max_input_tuple[2]; + +// The hash tables for the join algorithm + hash_table join_tbl[2]; + + + // comparator object used to provide methods for performing the joins. + join_eq_hash_functor func; + + // soft limit on queue size - we consider operator blocked on its input + // whenever we reach this soft limit (not used anymore) + size_t soft_queue_size_limit; + +// For matching on join hash key + equal_func equal_key; + + // memory footprint for the join queues in bytes + unsigned int queue_mem; + + + // appends tuple to the end of the one of the input queues + // if tuple is stack resident, makes it heap resident + int append_tuple(host_tuple& tup, int q) { + int ret = input_queue[q].empty() ? 1 : 2; + if (!tup.heap_resident) { + char* data = (char*)malloc(tup.tuple_size); + memcpy(data, tup.data, tup.tuple_size); + tup.data = data; + tup.heap_resident = true; + } + input_queue[q].push_back(tup); + queue_mem += tup.tuple_size; + return ret; + } + +// -1 if input queue i has smaller ts, 0 it equal, 1 if curr_ts is smaller + int compare_qts_to_hashts(int i){ + timestamp tmp_ts; + if(max_input_ts[i] == NULL) return(-1); + if(input_queue[i].empty()) + return(func.compare_ts_with_ts(max_input_ts[i], curr_ts)); + func.load_ts_from_tup(&tmp_ts,input_queue[i].front()); + return(func.compare_ts_with_ts(&tmp_ts, curr_ts)); + } + +// -1 if q0 is smaller, 1 if q1 is smaller, 0 if equal + int compare_qts(){ + if(max_input_ts[0] == NULL) return(-1); + if(max_input_ts[1] == NULL) return(1); + timestamp tmp_lts, tmp_rts, *lts,*rts; + + if(input_queue[0].empty()){ + lts = max_input_ts[0]; + }else{ + func.load_ts_from_tup(&tmp_lts, input_queue[0].front()); + lts = &tmp_lts; + } + + if(input_queue[1].empty()){ + rts = max_input_ts[1]; + }else{ + func.load_ts_from_tup(&tmp_rts, input_queue[1].front()); + rts = &tmp_rts; + } + + return(func.compare_ts_with_ts(lts,rts)); + } + + int compare_tup_with_ts(host_tuple &tup, timestamp *ts){ + timestamp tmp_ts; + func.load_ts_from_tup(&tmp_ts, tup); + return(func.compare_ts_with_ts(&tmp_ts, ts)); + } + + void process_join(list& result){ + int i; + for(i=0;i<2;++i){ + while(curr_ts_valid && !input_queue[i].empty() && compare_tup_with_ts(input_queue[i].front(), curr_ts) == 0 ){ +// apply tuples to join + int other = 1-i; // the other channel + bool failed; + +// Get tuple from list + host_tuple qtup = input_queue[i].front(); + input_queue[i].pop_front(); + queue_mem -= qtup.tuple_size; + +// Put it into its join table + hashkey *qtup_key = func.create_key(qtup,failed); // on heap + if(failed){ + qtup.free_tuple(); + continue; + } + join_tbl[i].insert(qtup_key, qtup); + +// Join with matching tuples in other table. + + typename hash_table::iterator jti = join_tbl[other].find(qtup_key); + while(jti != join_tbl[other].end()){ + if(equal_key((*jti).first, qtup_key)){ + host_tuple otup; + if(i==0) + otup = func.create_output_tuple( qtup, (*jti).second, failed ); + else + otup = func.create_output_tuple( (*jti).second, qtup, failed ); + if(!failed){ + otup.channel = output_channel; + result.push_back(otup); + qtup_key->touch(); + (*jti).first->touch(); + } + } + jti = jti.next(); + } + } + } + } + + void process_outer_join(list& result){ + int i; + bool failed; + host_tuple empty_tuple; + empty_tuple.tuple_size = 0; empty_tuple.data = NULL; + + hash_empty = true; + typename hash_table::iterator jti; + for(i=0;i<2;++i){ + if(!join_tbl[i].empty()){ + if(join_type & (i+1)){ + for(jti=join_tbl[i].begin();jti!=join_tbl[i].end();++jti){ +// Outer join processing + if( ! (*jti).first->is_touched() ){ + host_tuple otup; + if(i==0) + otup = func.create_output_tuple( (*jti).second, empty_tuple, failed ); + else + otup = func.create_output_tuple( empty_tuple, (*jti).second, failed ); + if(!failed){ + otup.channel = output_channel; + result.push_back(otup); + } + } +// end outer join processing + + delete((*jti).first); + (*jti).second.free_tuple(); + } + }else{ + for(jti=join_tbl[i].begin();jti!=join_tbl[i].end();++jti){ + delete((*jti).first); + (*jti).second.free_tuple(); + } + } + } + join_tbl[i].clear(); join_tbl[i].rehash(); + } + + } + +public: + join_eq_hash_operator(int schema_handle0, int schema_handle1, unsigned int jtype, const char* name, size_t size_limit = 10000) : base_operator(name), func(schema_handle0, schema_handle1) { + join_type = jtype; + max_input_ts[0] = NULL; max_input_ts[1] = NULL; + max_input_tuple[0].data = max_input_tuple_data[0]; + max_input_tuple[1].data = max_input_tuple_data[1]; + + curr_ts = new timestamp(); + curr_ts_valid = false; + hash_empty = true; + soft_queue_size_limit = size_limit; + + sch0=schema_handle0; + sch1=schema_handle1; +n_calls=0; n_iters=0; n_eqk=0; + + queue_mem = 0; + } + + int accept_tuple(host_tuple& tup, list& result) { + bool do_join_update = false; + int i; + bool failed; + +// Dummy tuple for outer join processing. + host_tuple empty_tuple; + empty_tuple.tuple_size = 0; empty_tuple.data = NULL; + + + if (tup.channel > 1) { + gslog(LOG_ALERT, "Illegal channel number %d for two-way join, handles=%d, %d\n", tup.channel, sch0, sch1); + return 0; + } + + bool is_temp_tuple = func.temp_status_received(tup); + +// Ensure that the queue ts is initialized. + if(max_input_ts[tup.channel] == NULL){ + max_input_ts[tup.channel] = new timestamp(); + if(! func.load_ts_from_tup(max_input_ts[tup.channel],tup)){ + tup.free_tuple(); + delete max_input_ts[tup.channel]; + max_input_ts[tup.channel] = NULL; + return(0); // can't load ts -- bail out. + } + + if( max_input_ts[1-tup.channel]){ + int qcmp = compare_qts(); + if(qcmp<=0){ + func.load_ts_from_ts(curr_ts, max_input_ts[0]); + }else{ + func.load_ts_from_ts(curr_ts, max_input_ts[1]); + } + curr_ts_valid = true; + } + } + +// reject "out of order" tuple - silently. + timestamp tup_ts; + if(! func.load_ts_from_tup(&tup_ts,tup)){ + tup.free_tuple(); + return(0); // can't load ts -- bail out. + } + + int tup_order=func.compare_ts_with_ts(&tup_ts,max_input_ts[tup.channel]); + if (tup_order < 0){ +printf("out of order ts.\n"); + tup.free_tuple(); + + // even for out of order temporal tuples we need to post new temporal tuple + if (is_temp_tuple) { + host_tuple temp_tup; + temp_tup.channel = output_channel; + if (!get_temp_status(temp_tup)) + result.push_back(temp_tup); + } + return 0; + } + +// Update max if larger + if(tup_order > 0){ + func.load_ts_from_ts(max_input_ts[tup.channel],&tup_ts); + + // save the content of the max tuple + max_input_tuple[tup.channel].channel = tup.channel; + max_input_tuple[tup.channel].tuple_size = tup.tuple_size; + memcpy(max_input_tuple[tup.channel].data, tup.data, tup.tuple_size); + +// do_join_update = true; + } + +// Add to input queue if it passes the prefilter. + if(!is_temp_tuple && func.apply_prefilter(tup)){ + if(append_tuple(tup,tup.channel) == 1){ + do_join_update = true; // added tuple to empty queue + } + }else{ + tup.free_tuple(); + } + +// If status changed, apply tuples to join. +// (updated max time, added tuple to empty queue) + +// clear queues, advance curr_ts + if(compare_qts_to_hashts(0)>0 && compare_qts_to_hashts(1)>0){ + process_outer_join(result); + + + int minq = 0; + if(compare_qts() > 0) + minq = 1; + if(input_queue[minq].empty()) + func.load_ts_from_ts(curr_ts,max_input_ts[minq]); + else + func.load_ts_from_tup(curr_ts,input_queue[minq].front()); + } + +// Process any tuples to be joined. + process_join(result); + + + // post new temporal tuple + + if(is_temp_tuple) { + host_tuple temp_tup; + temp_tup.channel = output_channel; + if (!get_temp_status(temp_tup)) + result.push_back(temp_tup); + } + + return 0; + } + + int flush(list& result) { + + process_outer_join(result); + + int minq = 0; + if(compare_qts() > 0) + minq = 1; + + if(input_queue[minq].empty()) + func.load_ts_from_ts(curr_ts,max_input_ts[minq]); + else + func.load_ts_from_tup(curr_ts,input_queue[minq].front()); + + process_join(result); + + return 0; + } + + int set_param_block(int sz, void * value) { + func.set_param_block(sz, value); + return 0; + } + + + int get_temp_status(host_tuple& result) { +// temp tuple timestamp should be minimum between +// minimums of all input queues + + // find the inputstream in minimum lowebound of the timestamp + int qcmp = compare_qts(); + int minq = 0; if(qcmp>0) minq = 1; + + host_tuple empty_tuple; + empty_tuple.tuple_size = 0; empty_tuple.data = NULL; + host_tuple& left_tuple = empty_tuple; + host_tuple& right_tuple = empty_tuple; + + if (minq == 0) { + if(max_input_ts[minq]) { + if (input_queue[minq].empty()) + left_tuple = max_input_tuple[minq]; + else + left_tuple = input_queue[minq].front(); + } + } else { + if(max_input_ts[minq]) { + if (input_queue[minq].empty()) + right_tuple = max_input_tuple[minq]; + else + right_tuple = input_queue[minq].front(); + } + } + + result.channel = output_channel; + return func.create_temp_status_tuple(left_tuple, right_tuple, result); + } + + + int get_blocked_status () { + if(input_queue[0].size() > soft_queue_size_limit) return(0); + if(input_queue[1].size() > soft_queue_size_limit) return(1); + return -1; + } + + unsigned int get_mem_footprint() { + return join_tbl[0].get_mem_footprint() + join_tbl[1].get_mem_footprint() + queue_mem; + } +}; + +#endif // JOIN_EQ_HASH_OPERATOR_H + diff --git a/include/hfta/merge_operator.h b/include/hfta/merge_operator.h new file mode 100644 index 0000000..662fd32 --- /dev/null +++ b/include/hfta/merge_operator.h @@ -0,0 +1,247 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef MERGE_OPERATOR_H +#define MERGE_OPERATOR_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +using namespace std; + +#include + + +//int last_tb = 0; + +template +class merge_operator : public base_operator { +private : + // input channel on which we want to receive the next tuple + // value -1 indicates that we never received a single tuple + // and we are not concerned on which channel tuple will arrive + int wait_channel; + + // list of tuples from one of the channel waiting to be compared + // against tuple from the other channel + list merge_queue; + int merge_qsize; + + // comparator object used to compare the tuples + merge_functor func; + + // soft limit on queue size - we consider operator blocked on its input + // whenever we reach this soft limit (not used anymore) + size_t soft_queue_size_limit; + + int dropped_cnt; + + // memory footprint for the merge queue in bytes + unsigned int queue_mem; + + // appends tuple to the end of the merge_queue + // if tuple is stack resident, makes it heap resident + void append_tuple(host_tuple& tup) { + if (!tup.heap_resident) { + char* data = (char*)malloc(tup.tuple_size); + memcpy(data, tup.data, tup.tuple_size); + tup.data = data; + tup.heap_resident = true; + } + merge_queue.push_back(tup); + merge_qsize++; + queue_mem += tup.tuple_size; + } + + void purge_queue(int channel, list& result){ + if (merge_queue.empty()) + return; + host_tuple top_tuple = merge_queue.front(); + // remove all the tuple smaller than arrived tuple + while(func.compare_stored_with_temp_status(top_tuple, 1-channel) <= 0) { + merge_queue.pop_front(); + merge_qsize--; + queue_mem -= top_tuple.tuple_size; + if(merge_qsize<0) abort(); + func.update_stored_temp_status(top_tuple,channel); + func.xform_tuple(top_tuple); + top_tuple.channel = output_channel; + result.push_back(top_tuple); + + if (merge_queue.empty()) + break; + + top_tuple = merge_queue.front(); + func.update_stored_temp_status(top_tuple,channel); + } + } + + + +public: + + merge_operator(int schema_handle1, int schema_handle2, size_t size_limit, const char* name ) : base_operator(name), func(schema_handle1) { + wait_channel = -1; + soft_queue_size_limit = size_limit; + merge_qsize = 0; + dropped_cnt = 0; + queue_mem = 0; + } + + + int accept_tuple(host_tuple& tup, list& result) { + int last_channel; + + if (tup.channel > 1) { + fprintf(stderr, "Illegal channel number %d for two-way merge\n", tup.channel); + return 0; + } + + /* reject "out of order" tuple - we can receive those after forced flush */ + func.get_timestamp(tup); + int res = func.compare_with_temp_status(tup.channel); + bool is_temp_tuple = func.temp_status_received(tup); + +/* +// Ignore temp tuples until we can fix their timestamps. +if(is_temp_tuple){ + tup.free_tuple(); + return 0; +}*/ + if (res < 0){ // out of order tuple + + if (++dropped_cnt % 100000 == 0) { + gslog(LOG_ALERT, "%d tuples dropped by %s merge\n", dropped_cnt,get_name()); + } + //if(func.print_warnings()) + // fprintf(stderr,"Warning: merge %s receives an out-of-order tuple on channel %d.\n", get_name(), tup.channel); + // free tuple memory + tup.free_tuple(); + return 0; + } else { + + if (wait_channel < 0 || wait_channel != tup.channel) { + if (wait_channel < 0) + func.update_temp_status(tup); + + if (!is_temp_tuple){ + if(func.compare_with_temp_status(1-tup.channel) <= 0){ + if (!tup.heap_resident) { + char* data = (char*)malloc(tup.tuple_size); + memcpy(data, tup.data, tup.tuple_size); + tup.data = data; + tup.heap_resident = true; + } + func.xform_tuple(tup); + tup.channel = output_channel; + result.push_back(tup); + }else{ + append_tuple(tup); // put arrived tuple in the queue + } + } +// func.update_temp_status_by_slack(tup, 1-tup.channel); +// purge_queue(tup.channel, result); + + wait_channel = 1-tup.channel; + }else{ + // If possible, clear tuples from the other queue. + func.update_temp_status(tup); + purge_queue(1-tup.channel, result); + + if(func.compare_with_temp_status(1-tup.channel) <= 0) { // other tuples in the queue are larger that arrived tuple + if (!is_temp_tuple) { + if (!tup.heap_resident) { + char* data = (char*)malloc(tup.tuple_size); + memcpy(data, tup.data, tup.tuple_size); + tup.data = data; + tup.heap_resident = true; + } + func.xform_tuple(tup); + tup.channel = output_channel; + result.push_back(tup); + } + } + else { + if (!is_temp_tuple) + append_tuple(tup); // put arrived tuple in the queue + wait_channel = 1 - tup.channel; // now we want the tuple from other channel + } + } + + } + + // temp status tuples emited by merge don't serve any other purpose + // other than tracing the flow of tuples + if (is_temp_tuple) { + host_tuple temp_tup; + if (!func.create_temp_status_tuple(temp_tup)) { + temp_tup.channel = output_channel; + result.push_back(temp_tup); + } + // clear memory of heap-resident temporal tuples + tup.free_tuple(); + } + + if (!merge_qsize) + wait_channel = -1; + + return 0; + } + + int flush(list& result) { + + if (merge_queue.empty()) + return 0; + + host_tuple top_tuple; + list::iterator iter; + for (iter = merge_queue.begin(); iter != merge_queue.end(); iter++) { + top_tuple = *iter; + func.update_stored_temp_status(top_tuple,top_tuple.channel); + func.xform_tuple(top_tuple); + top_tuple.channel = output_channel; + result.push_back(top_tuple); + } + + queue_mem = 0; + + return 0; + } + + int set_param_block(int sz, void * value) { + return 0; + } + + + int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result); + } + + + int get_blocked_status () { + if (merge_qsize> soft_queue_size_limit) + return wait_channel; + else + return -1; + } + + unsigned int get_mem_footprint() { + return queue_mem; + } + +}; + +#endif // MERGE_OPERATOR_H diff --git a/include/hfta/merge_operator_oop.h b/include/hfta/merge_operator_oop.h new file mode 100644 index 0000000..b416d34 --- /dev/null +++ b/include/hfta/merge_operator_oop.h @@ -0,0 +1,182 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef MERGE_OPERATOR_OOP_H +#define MERGE_OPERATOR_OOP_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +using namespace std; + +#include + + +//int last_tb = 0; + +template +class merge_operator_oop : public base_operator { +private : + // input channel on which we want to receive the next tuple + // value -1 indicates that we never received a single tuple + // and we are not concerned on which channel tuple will arrive + int wait_channel; + + // list of tuples from one of the channel waiting to be compared + // against tuple from the other channel + list merge_queue; + int merge_qsize; + + // comparator object used to compare the tuples + merge_functor func; + + // soft limit on queue size - we consider operator blocked on its input + // whenever we reach this soft limit (not used anymore) + size_t soft_queue_size_limit; + + int dropped_cnt; + + // memory footprint for the merge queue in bytes + unsigned int queue_mem; + + // appends tuple to the end of the merge_queue +// tuple is stack resident, makes it heap resident + void append_tuple(host_tuple& tup) { + if (!tup.heap_resident) { + char* data = (char*)malloc(tup.tuple_size); + memcpy(data, tup.data, tup.tuple_size); + tup.data = data; + tup.heap_resident = true; + } + merge_queue.push_back(tup); + merge_qsize++; + queue_mem += tup.tuple_size; + } + + + // purge tuples in the queue, which are from stream channel -- Jin + void purge_queue(int channel, list& result){ + if (merge_queue.empty()) + return; + host_tuple top_tuple = merge_queue.front(); + // remove all the tuple smaller than arrived tuple + while(func.compare_with_temp_status(top_tuple, 1-channel) <= 0) { + merge_queue.pop_front(); + merge_qsize--; + queue_mem -= top_tuple.tuple_size; + if(merge_qsize<0) abort(); + func.update_temp_status(top_tuple,channel); + func.xform_tuple(top_tuple); + top_tuple.channel = output_channel; + result.push_back(top_tuple); + + if (merge_queue.empty()) + break; + + top_tuple = merge_queue.front(); + func.update_temp_status(top_tuple,channel); + } + } + + + +public: + + merge_operator_oop(int schema_handle1, int schema_handle2, size_t size_limit, const char* name ) : base_operator(name), func(schema_handle1) { + wait_channel = -1; + soft_queue_size_limit = size_limit; + merge_qsize = 0; + dropped_cnt = 0; + queue_mem = 0; + } + + int accept_tuple(host_tuple& tup, list& result) { + int last_channel; + + if (tup.channel > 1) { + fprintf(stderr, "Illegal channel number %d for two-way merge\n", tup.channel); + return 0; + } + + func.get_timestamp(tup); + func.compare_with_temp_status(tup.channel); + bool is_temp_tuple = func.temp_status_received(tup); + + if (!is_temp_tuple) { + result.push_back(tup); + } else { + func.update_temp_status(tup); + + host_tuple temp_tup; + if (!func.create_temp_status_tuple(temp_tup)) { + temp_tup.channel = output_channel; + result.push_back(temp_tup); + } + // clear memory of heap-resident temporal tuples + tup.free_tuple(); + } + + return 0; + } + + + + /* where is this called? when using the blocking mode -- Jin */ + int flush(list& result) { + + if (merge_queue.empty()) + return 0; + + host_tuple top_tuple; + list::iterator iter; + for (iter = merge_queue.begin(); iter != merge_queue.end(); iter++) { + top_tuple = *iter; + func.update_stored_temp_status(top_tuple,top_tuple.channel); + func.xform_tuple(top_tuple); + top_tuple.channel = output_channel; + result.push_back(top_tuple); + } + + queue_mem = 0; + + return 0; + } + + int set_param_block(int sz, void * value) { + return 0; + } + + + int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result); + } + + + int get_blocked_status () { + if (merge_qsize> soft_queue_size_limit) + return wait_channel; + else + return -1; + } + + unsigned int get_mem_footprint() { + return queue_mem; + } + +}; + +#endif // MERGE_OPERATOR_OOP_H + diff --git a/include/hfta/running_gb_operator.h b/include/hfta/running_gb_operator.h new file mode 100644 index 0000000..5bd7388 --- /dev/null +++ b/include/hfta/running_gb_operator.h @@ -0,0 +1,141 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef RWGROUPBY_OPERATOR_H +#define RWGROUPBY_OPERATOR_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +#include "hash_table.h" + +#define _GB_FLUSH_PER_TUPLE_ 1 + +using namespace std; + +template +class running_agg_operator : public base_operator { +private : + groupby_func func; + hash_table group_table; + typename hash_table::iterator flush_pos; + + + +public: + running_agg_operator(int schema_handle, const char* name) : base_operator(name), func(schema_handle) { + flush_pos = group_table.end(); + } + + virtual int accept_tuple(host_tuple& tup, list& result) { + +// Push out completed groups + + // create buffer on the stack to store key object + char buffer[sizeof(group)]; + + // extract the key information from the tuple and + // copy it into buffer + group* grp = func.create_group(tup, buffer); +/*// Ignore temp tuples until we can fix their timestamps. +if (func.temp_status_received()) { + tup.free_tuple(); + return 0; +} +*/ + + if (!grp) { + if (func.flush_needed()){ + flush(result); + } + if (func.temp_status_received()) { + host_tuple temp_tup; + if (!func.create_temp_status_tuple(temp_tup, true)) { + temp_tup.channel = output_channel; + result.push_back(temp_tup); + } + } + tup.free_tuple(); + return 0; + } + + if (func.flush_needed()) { + flush(result); + } + typename hash_table::iterator iter; + if ((iter = group_table.find(grp)) != group_table.end()) { + aggregate* old_aggr = (*iter).second; + func.update_aggregate(tup, grp, old_aggr); + }else{ + // create a copy of the group on the heap + group* new_grp = new group(grp); // need a copy constructor for groups +// aggregate* aggr = (aggregate*)malloc(sizeof(aggregate)); + aggregate* aggr = new aggregate(); + // create an aggregate in preallocated buffer + aggr = func.create_aggregate(tup, (char*)aggr); + + group_table.insert(new_grp, aggr); + } + tup.free_tuple(); + return 0; + } + + virtual int flush(list& result) { + host_tuple tup; + typename hash_table::iterator iter; +// If the old table isn't empty, flush it now. + for (flush_pos = group_table.begin(); flush_pos != group_table.end(); ) { + bool failed = false; + tup = func.create_output_tuple((*flush_pos).first,(*flush_pos).second, failed); + if (!failed) { + tup.channel = output_channel; + result.push_back(tup); + } + if(func.cleaning_when((*flush_pos).first,(*flush_pos).second)){ + group* g = (*flush_pos).first; + aggregate* a = (*flush_pos).second; + ++flush_pos; + group_table.erase(g); + delete (g); + delete (a); + }else{ + func.reinit_aggregates((*flush_pos).first, (*flush_pos).second); + ++flush_pos; + } + } + + return 0; + } + + virtual int set_param_block(int sz, void * value) { + func.set_param_block(sz, value); + return 0; + } + + virtual int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result, true); + } + + virtual int get_blocked_status () { + return -1; + } + + unsigned int get_mem_footprint() { + return group_table.get_mem_footprint(); + } +}; + +#endif // GROUPBY_OPERATOR_H diff --git a/include/hfta/selection_operator.h b/include/hfta/selection_operator.h new file mode 100644 index 0000000..1da2640 --- /dev/null +++ b/include/hfta/selection_operator.h @@ -0,0 +1,71 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef SELECTION_OPERATOR_H +#define SELECTION_OPERATOR_H + +#include "host_tuple.h" +#include "base_operator.h" +#include +using namespace std; + +template class select_project_operator : + public base_operator +{ +private : + select_project_functor func; +public: + + select_project_operator(int schema_handle, const char* name) : base_operator(name), func(schema_handle) { } + + virtual int accept_tuple(host_tuple& tup, list& result) { + host_tuple res; + + if (func.predicate(tup)) { + res = func.create_output_tuple(); + res.channel = output_channel; + result.push_back(res); + } else { + if (func.temp_status_received()) { + if (!func.create_temp_status_tuple(res)) { + res.channel = output_channel; + result.push_back(res); + } + } + } + tup.free_tuple(); + return 0; + } + + virtual int flush(list& result) { + return 0; + } + + virtual int set_param_block(int sz, void * value) { + func.set_param_block(sz, value); + return 0; + } + + virtual int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result); + } + + virtual int get_blocked_status () { + return -1; // selection operators are not blocked on any input + } +}; + +#endif // SELECTION_OPERATOR_H diff --git a/include/hfta/zfile_output_operator.h b/include/hfta/zfile_output_operator.h new file mode 100644 index 0000000..51b9ef8 --- /dev/null +++ b/include/hfta/zfile_output_operator.h @@ -0,0 +1,205 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef ZFILE_OUTPUT_OPERATOR_H +#define ZFILE_OUTPUT_OPERATOR_H + +#include +#include +#include +#include +#include +#include + +#include "gsconfig.h" +#include "gstypes.h" +#include + +#include "host_tuple.h" +#include "base_operator.h" +#include +#include +#include +#include "gsconfig.h" +#include "gstypes.h" +#include + +#include + +using namespace std; + +#ifndef FILESTREAM_OPERATOR_UTILS +#define FILESTREAM_OPERATOR_UTILS +string fs_int_to_string(int i){ + string ret; + char tmpstr[100]; + sprintf(tmpstr,"%d",i); + ret=tmpstr; + return(ret); +} +#endif + +template class zfile_output_operator : + public base_operator +{ +private : + file_output_functor func; + + gzFile *output_file; + vector xform_command; + vector temp_fname; + vector fname; + string qname; + string schema; + string file_header; + gs_uint32_t n_file_streams; + +int total_written; + +public: + +zfile_output_operator(int schema_handle, gs_csp_t name, gs_csp_t sch) : base_operator(name), func(schema_handle) { + char tmpstr[1000]; + int i; + + n_file_streams = func.num_file_streams(); + output_file = (gzFile *)(malloc(sizeof(gzFile )*n_file_streams)); + for(i=0;i& result) { +string fname_base; +host_tuple res; +gs_uint32_t i; + + if(! func.temp_status_received(tup)){ // this operator doesn't write +// Check for EOF conditions. + if(func.is_eof_tuple()){ + if(output_file[0] != NULL){ + for(i=0;i 1){ + temp_fname[i] = fname_base + "_stream"+fs_int_to_string(i)+ ".txt.gz.tmp"; + fname[i] = fname_base + "_stream"+fs_int_to_string(i) + ".txt.gz"; + }else{ + temp_fname[i] = fname_base + "_stream"+fs_int_to_string(i)+ ".txt.gz.tmp"; + fname[i] = fname_base + "_stream"+fs_int_to_string(i) + ".txt.gz"; + } +// else{ +// xform_command = "mv "+temp_fname+" "+fname; +// } + if ((output_file[i]=gzopen(temp_fname[i].c_str(),"wb"))==0) { + gslog(LOG_EMERG,"Could not open file \"%s\".. EXITING\n", temp_fname[i].c_str()); + exit(1); + } + gzwrite(output_file[i],file_header.c_str(),strlen(file_header.c_str())); + gzwrite(output_file[i],schema.c_str(),strlen(schema.c_str())+1); + } + } + + gs_uint32_t sz = tup.tuple_size; + gs_uint32_t nsz = htonl(tup.tuple_size); + gs_uint32_t file_hash = func.output_hash(); +total_written += sizeof(gs_uint32_t) + sz; + if (gzwrite(output_file[file_hash],&nsz,sizeof(gs_uint32_t))==0) { + gslog(LOG_EMERG,"zfile_output_operator: Could not write %d bytes to output\"%s\".. EXITING\n", sizeof(gs_uint32_t), temp_fname[file_hash].c_str()); + exit(1); + } + + if (gzwrite(output_file[file_hash],tup.data,sz)==0) { + gslog(LOG_EMERG,"zfile_output_operator: Could not write %d bytes to output\"%s\".. EXITING\n", sz, temp_fname[file_hash].c_str()); + exit(1); + } + if(func.propagate_tuple()){ + tup.channel = output_channel; + result.push_back(tup); + } + return 0; + }else{ +/* + if (!func.create_temp_status_tuple(res)) { + res.channel = output_channel; + result.push_back(res); + } +*/ + +//fprintf(stderr,"\tis temp tuple\n"); + } + + if(func.propagate_tuple()){ + tup.channel = output_channel; + result.push_back(tup); + } + return 0; +} + + + virtual int flush(list& result) { + return 0; + } + + virtual int set_param_block(int sz, void * value) { +// func.set_param_block(sz, value); + return 0; + } + + virtual int get_temp_status(host_tuple& result) { + result.channel = output_channel; + return func.create_temp_status_tuple(result); + } + + virtual int get_blocked_status () { + return -1; // selection operators are not blocked on any input + } +}; + + +#endif // ZFILE_OUTPUT_OPERATOR_H + diff --git a/include/lapp.h b/include/lapp.h new file mode 100644 index 0000000..cfa1fbb --- /dev/null +++ b/include/lapp.h @@ -0,0 +1,131 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +/* + * lapp.h: low level interface for applications + */ +#ifndef LAPP_H +#define LAPP_H + +#include +#include +#include + +#define REGULAR_TUPLE 0 +#define TEMPORAL_TUPLE 1 +#define EOF_TUPLE 2 + +/* LOW LEVEL APPLICATION INTERFACE */ +/* =============================== */ + +/* NOTE: A streamid is only unique in the context of a particular + * producer. Therefore, all the fields in the FTAID need to be compared + * to decided if to FTA instances are the same + */ + +#define CLEARINGHOUSE 1 +#define APP 2 +#define HFTA 3 +#define LFTA 4 + +/* deviceid should be set to DEFAULTDEV mapcnt and map to 0 for HFTAs and apps */ + +gs_retval_t hostlib_init(gs_int32_t type, gs_int32_t recvbuffersz, gs_int32_t deviceid, gs_int32_t mapcnt, gs_sp_t map[]); + +void hostlib_free(); + +/* find an FTA message queue ID, index and schema based on an FTA key + * if reuse is set we return an already running instance if possible*/ + +gs_retval_t fta_find(FTAname name, gs_uint32_t reuse, FTAID * ftaid, + gs_sp_t schema , gs_int32_t buffersz ); + +/* the following is used to send a heart beat message to the clearinghouse. Self is the FTAID of the sending + * fta instance*/ + +gs_retval_t fta_heartbeat(FTAID self, gs_uint64_t trace_id, + gs_uint32_t sz, fta_stat * trace); + +/* + * FTA's cannot be dynamically installed (since we currently don't + * have a run-time linker in the card). however, new parameterized + * instances of previously installed FTAs can be created. The FTA + * template IDs have to defined in an include file. the following + * call will result in a call to the FTA's alloc_fta function. + * if sucessfull the streamid is set in the ftaid. + */ + +gs_retval_t fta_alloc_instance(FTAID subscriber, + FTAID * ftaid, FTAname name, gs_sp_t schema, + gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data); + +/* see app.h for description of the additional parameter */ +gs_retval_t fta_alloc_print_instance(FTAID subscriber, + FTAID * ftaid, + FTAname name, gs_sp_t schema,gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data, + gs_sp_t path,gs_sp_t basename, + gs_sp_t temporal_field, gs_sp_t split_field, + gs_uint32_t delta, gs_uint32_t split); + + +/* + * the next two functions result in callouts to the corresponding FTA + * functions (fta_free, control_fta). + */ + +gs_retval_t fta_free_instance(FTAID subscriber,FTAID ftaid, gs_uint32_t recursive); + + +gs_retval_t fta_control(FTAID subscriber, + FTAID ftaid, gs_int32_t command, gs_int32_t sz, void * value); + + +/* + * gscp_get_buffer: get a tuple from a read shared buffer + * established with any other porcess when an FTA + * was established. Returns -1 on error, 0 on success and 1 on timeout and 2 for a temporal tuple. + * On a timeout the streamid is set to 1 and the length to 0. + * The timeout is in seconds. A timeout of 0 makes the call blocking + * a timeout of -1 returns imidiatly if no buffer is availabe. + */ +gs_retval_t gscp_get_buffer(FTAID * ftaid, gs_int32_t * size, void *tbuffer, + gs_int32_t tbuf_size, gs_int32_t timeout); + +/* the following function send a control callback to every + active FTA in a particular process identified by the + IP and port part of the ftaid. The result is < 0 if not + successful if the control operation is returning a result it is ignored. + The main purpose of this message is to support a + flush of all FTAs in a proccess*/ + +gs_retval_t process_control(FTAID ftaid, gs_int32_t command, + gs_int32_t sz, void * value); + + +/* called by an FTA if one of its producers fails. Self is the FTAID of the instance + * sending the notification */ + +gs_retval_t fta_notify_producer_failure(FTAID self, FTAID producer); + +/* returns FTAID of current process */ +FTAID gscpipc_getftaid(); + +extern gs_uint64_t shared_memory_full_warning; + +/* returns 1 if GSCP ringbuffers are in blocking mode */ +gs_retval_t gscp_blocking_mode(); + +#endif diff --git a/include/lfta/csv2_macro.h b/include/lfta/csv2_macro.h new file mode 100644 index 0000000..914f7d2 --- /dev/null +++ b/include/lfta/csv2_macro.h @@ -0,0 +1,10017 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef CSV2_MACRO_H +#define CSV2_MACRO_H +#define get_csv2_uint_pos1(X,Y) get_csv2_uint((X),(Y),1) +#define get_csv2_ullong_pos1(X,Y) get_csv2_ullong((X),(Y),1) +#define get_csv2_ip_pos1(X,Y) get_csv2_ip((X),(Y),1) +#define get_csv2_ipv6_pos1(X,Y) get_csv2_ipv6((X),(Y),1) +#define get_csv2_string_pos1(X,Y) get_csv2_string((X),(Y),1) +#define get_csv2_v_str_pos1(X,Y) get_csv2_string((X),(Y),1) +#define get_csv2_bool_pos1(X,Y) get_csv2_bool((X),(Y),1) +#define get_csv2_int_pos1(X,Y) get_csv2_int((X),(Y),1) +#define get_csv2_llong_pos1(X,Y) get_csv2_llong((X),(Y),1) +#define get_csv2_float_pos1(X,Y) get_csv2_float((X),(Y),1) +#define get_csv2_uint_pos2(X,Y) get_csv2_uint((X),(Y),2) +#define get_csv2_ullong_pos2(X,Y) get_csv2_ullong((X),(Y),2) +#define get_csv2_ip_pos2(X,Y) get_csv2_ip((X),(Y),2) +#define get_csv2_ipv6_pos2(X,Y) get_csv2_ipv6((X),(Y),2) +#define get_csv2_string_pos2(X,Y) get_csv2_string((X),(Y),2) +#define get_csv2_v_str_pos2(X,Y) get_csv2_string((X),(Y),2) +#define get_csv2_bool_pos2(X,Y) get_csv2_bool((X),(Y),2) +#define get_csv2_int_pos2(X,Y) get_csv2_int((X),(Y),2) +#define get_csv2_llong_pos2(X,Y) get_csv2_llong((X),(Y),2) +#define get_csv2_float_pos2(X,Y) get_csv2_float((X),(Y),2) +#define get_csv2_uint_pos3(X,Y) get_csv2_uint((X),(Y),3) +#define get_csv2_ullong_pos3(X,Y) get_csv2_ullong((X),(Y),3) +#define get_csv2_ip_pos3(X,Y) get_csv2_ip((X),(Y),3) +#define get_csv2_ipv6_pos3(X,Y) get_csv2_ipv6((X),(Y),3) +#define get_csv2_string_pos3(X,Y) get_csv2_string((X),(Y),3) +#define get_csv2_v_str_pos3(X,Y) get_csv2_string((X),(Y),3) +#define get_csv2_bool_pos3(X,Y) get_csv2_bool((X),(Y),3) +#define get_csv2_int_pos3(X,Y) get_csv2_int((X),(Y),3) +#define get_csv2_llong_pos3(X,Y) get_csv2_llong((X),(Y),3) +#define get_csv2_float_pos3(X,Y) get_csv2_float((X),(Y),3) +#define get_csv2_uint_pos4(X,Y) get_csv2_uint((X),(Y),4) +#define get_csv2_ullong_pos4(X,Y) get_csv2_ullong((X),(Y),4) +#define get_csv2_ip_pos4(X,Y) get_csv2_ip((X),(Y),4) +#define get_csv2_ipv6_pos4(X,Y) get_csv2_ipv6((X),(Y),4) +#define get_csv2_string_pos4(X,Y) get_csv2_string((X),(Y),4) +#define get_csv2_v_str_pos4(X,Y) get_csv2_string((X),(Y),4) +#define get_csv2_bool_pos4(X,Y) get_csv2_bool((X),(Y),4) +#define get_csv2_int_pos4(X,Y) get_csv2_int((X),(Y),4) +#define get_csv2_llong_pos4(X,Y) get_csv2_llong((X),(Y),4) +#define get_csv2_float_pos4(X,Y) get_csv2_float((X),(Y),4) +#define get_csv2_uint_pos5(X,Y) get_csv2_uint((X),(Y),5) +#define get_csv2_ullong_pos5(X,Y) get_csv2_ullong((X),(Y),5) +#define get_csv2_ip_pos5(X,Y) get_csv2_ip((X),(Y),5) +#define get_csv2_ipv6_pos5(X,Y) get_csv2_ipv6((X),(Y),5) +#define get_csv2_string_pos5(X,Y) get_csv2_string((X),(Y),5) +#define get_csv2_v_str_pos5(X,Y) get_csv2_string((X),(Y),5) +#define get_csv2_bool_pos5(X,Y) get_csv2_bool((X),(Y),5) +#define get_csv2_int_pos5(X,Y) get_csv2_int((X),(Y),5) +#define get_csv2_llong_pos5(X,Y) get_csv2_llong((X),(Y),5) +#define get_csv2_float_pos5(X,Y) get_csv2_float((X),(Y),5) +#define get_csv2_uint_pos6(X,Y) get_csv2_uint((X),(Y),6) +#define get_csv2_ullong_pos6(X,Y) get_csv2_ullong((X),(Y),6) +#define get_csv2_ip_pos6(X,Y) get_csv2_ip((X),(Y),6) +#define get_csv2_ipv6_pos6(X,Y) get_csv2_ipv6((X),(Y),6) +#define get_csv2_string_pos6(X,Y) get_csv2_string((X),(Y),6) +#define get_csv2_v_str_pos6(X,Y) get_csv2_string((X),(Y),6) +#define get_csv2_bool_pos6(X,Y) get_csv2_bool((X),(Y),6) +#define get_csv2_int_pos6(X,Y) get_csv2_int((X),(Y),6) +#define get_csv2_llong_pos6(X,Y) get_csv2_llong((X),(Y),6) +#define get_csv2_float_pos6(X,Y) get_csv2_float((X),(Y),6) +#define get_csv2_uint_pos7(X,Y) get_csv2_uint((X),(Y),7) +#define get_csv2_ullong_pos7(X,Y) get_csv2_ullong((X),(Y),7) +#define get_csv2_ip_pos7(X,Y) get_csv2_ip((X),(Y),7) +#define get_csv2_ipv6_pos7(X,Y) get_csv2_ipv6((X),(Y),7) +#define get_csv2_string_pos7(X,Y) get_csv2_string((X),(Y),7) +#define get_csv2_v_str_pos7(X,Y) get_csv2_string((X),(Y),7) +#define get_csv2_bool_pos7(X,Y) get_csv2_bool((X),(Y),7) +#define get_csv2_int_pos7(X,Y) get_csv2_int((X),(Y),7) +#define get_csv2_llong_pos7(X,Y) get_csv2_llong((X),(Y),7) +#define get_csv2_float_pos7(X,Y) get_csv2_float((X),(Y),7) +#define get_csv2_uint_pos8(X,Y) get_csv2_uint((X),(Y),8) +#define get_csv2_ullong_pos8(X,Y) get_csv2_ullong((X),(Y),8) +#define get_csv2_ip_pos8(X,Y) get_csv2_ip((X),(Y),8) +#define get_csv2_ipv6_pos8(X,Y) get_csv2_ipv6((X),(Y),8) +#define get_csv2_string_pos8(X,Y) get_csv2_string((X),(Y),8) +#define get_csv2_v_str_pos8(X,Y) get_csv2_string((X),(Y),8) +#define get_csv2_bool_pos8(X,Y) get_csv2_bool((X),(Y),8) +#define get_csv2_int_pos8(X,Y) get_csv2_int((X),(Y),8) +#define get_csv2_llong_pos8(X,Y) get_csv2_llong((X),(Y),8) +#define get_csv2_float_pos8(X,Y) get_csv2_float((X),(Y),8) +#define get_csv2_uint_pos9(X,Y) get_csv2_uint((X),(Y),9) +#define get_csv2_ullong_pos9(X,Y) get_csv2_ullong((X),(Y),9) +#define get_csv2_ip_pos9(X,Y) get_csv2_ip((X),(Y),9) +#define get_csv2_ipv6_pos9(X,Y) get_csv2_ipv6((X),(Y),9) +#define get_csv2_string_pos9(X,Y) get_csv2_string((X),(Y),9) +#define get_csv2_v_str_pos9(X,Y) get_csv2_string((X),(Y),9) +#define get_csv2_bool_pos9(X,Y) get_csv2_bool((X),(Y),9) +#define get_csv2_int_pos9(X,Y) get_csv2_int((X),(Y),9) +#define get_csv2_llong_pos9(X,Y) get_csv2_llong((X),(Y),9) +#define get_csv2_float_pos9(X,Y) get_csv2_float((X),(Y),9) +#define get_csv2_uint_pos10(X,Y) get_csv2_uint((X),(Y),10) +#define get_csv2_ullong_pos10(X,Y) get_csv2_ullong((X),(Y),10) +#define get_csv2_ip_pos10(X,Y) get_csv2_ip((X),(Y),10) +#define get_csv2_ipv6_pos10(X,Y) get_csv2_ipv6((X),(Y),10) +#define get_csv2_string_pos10(X,Y) get_csv2_string((X),(Y),10) +#define get_csv2_v_str_pos10(X,Y) get_csv2_string((X),(Y),10) +#define get_csv2_bool_pos10(X,Y) get_csv2_bool((X),(Y),10) +#define get_csv2_int_pos10(X,Y) get_csv2_int((X),(Y),10) +#define get_csv2_llong_pos10(X,Y) get_csv2_llong((X),(Y),10) +#define get_csv2_float_pos10(X,Y) get_csv2_float((X),(Y),10) +#define get_csv2_uint_pos11(X,Y) get_csv2_uint((X),(Y),11) +#define get_csv2_ullong_pos11(X,Y) get_csv2_ullong((X),(Y),11) +#define get_csv2_ip_pos11(X,Y) get_csv2_ip((X),(Y),11) +#define get_csv2_ipv6_pos11(X,Y) get_csv2_ipv6((X),(Y),11) +#define get_csv2_string_pos11(X,Y) get_csv2_string((X),(Y),11) +#define get_csv2_v_str_pos11(X,Y) get_csv2_string((X),(Y),11) +#define get_csv2_bool_pos11(X,Y) get_csv2_bool((X),(Y),11) +#define get_csv2_int_pos11(X,Y) get_csv2_int((X),(Y),11) +#define get_csv2_llong_pos11(X,Y) get_csv2_llong((X),(Y),11) +#define get_csv2_float_pos11(X,Y) get_csv2_float((X),(Y),11) +#define get_csv2_uint_pos12(X,Y) get_csv2_uint((X),(Y),12) +#define get_csv2_ullong_pos12(X,Y) get_csv2_ullong((X),(Y),12) +#define get_csv2_ip_pos12(X,Y) get_csv2_ip((X),(Y),12) +#define get_csv2_ipv6_pos12(X,Y) get_csv2_ipv6((X),(Y),12) +#define get_csv2_string_pos12(X,Y) get_csv2_string((X),(Y),12) +#define get_csv2_v_str_pos12(X,Y) get_csv2_string((X),(Y),12) +#define get_csv2_bool_pos12(X,Y) get_csv2_bool((X),(Y),12) +#define get_csv2_int_pos12(X,Y) get_csv2_int((X),(Y),12) +#define get_csv2_llong_pos12(X,Y) get_csv2_llong((X),(Y),12) +#define get_csv2_float_pos12(X,Y) get_csv2_float((X),(Y),12) +#define get_csv2_uint_pos13(X,Y) get_csv2_uint((X),(Y),13) +#define get_csv2_ullong_pos13(X,Y) get_csv2_ullong((X),(Y),13) +#define get_csv2_ip_pos13(X,Y) get_csv2_ip((X),(Y),13) +#define get_csv2_ipv6_pos13(X,Y) get_csv2_ipv6((X),(Y),13) +#define get_csv2_string_pos13(X,Y) get_csv2_string((X),(Y),13) +#define get_csv2_v_str_pos13(X,Y) get_csv2_string((X),(Y),13) +#define get_csv2_bool_pos13(X,Y) get_csv2_bool((X),(Y),13) +#define get_csv2_int_pos13(X,Y) get_csv2_int((X),(Y),13) +#define get_csv2_llong_pos13(X,Y) get_csv2_llong((X),(Y),13) +#define get_csv2_float_pos13(X,Y) get_csv2_float((X),(Y),13) +#define get_csv2_uint_pos14(X,Y) get_csv2_uint((X),(Y),14) +#define get_csv2_ullong_pos14(X,Y) get_csv2_ullong((X),(Y),14) +#define get_csv2_ip_pos14(X,Y) get_csv2_ip((X),(Y),14) +#define get_csv2_ipv6_pos14(X,Y) get_csv2_ipv6((X),(Y),14) +#define get_csv2_string_pos14(X,Y) get_csv2_string((X),(Y),14) +#define get_csv2_v_str_pos14(X,Y) get_csv2_string((X),(Y),14) +#define get_csv2_bool_pos14(X,Y) get_csv2_bool((X),(Y),14) +#define get_csv2_int_pos14(X,Y) get_csv2_int((X),(Y),14) +#define get_csv2_llong_pos14(X,Y) get_csv2_llong((X),(Y),14) +#define get_csv2_float_pos14(X,Y) get_csv2_float((X),(Y),14) +#define get_csv2_uint_pos15(X,Y) get_csv2_uint((X),(Y),15) +#define get_csv2_ullong_pos15(X,Y) get_csv2_ullong((X),(Y),15) +#define get_csv2_ip_pos15(X,Y) get_csv2_ip((X),(Y),15) +#define get_csv2_ipv6_pos15(X,Y) get_csv2_ipv6((X),(Y),15) +#define get_csv2_string_pos15(X,Y) get_csv2_string((X),(Y),15) +#define get_csv2_v_str_pos15(X,Y) get_csv2_string((X),(Y),15) +#define get_csv2_bool_pos15(X,Y) get_csv2_bool((X),(Y),15) +#define get_csv2_int_pos15(X,Y) get_csv2_int((X),(Y),15) +#define get_csv2_llong_pos15(X,Y) get_csv2_llong((X),(Y),15) +#define get_csv2_float_pos15(X,Y) get_csv2_float((X),(Y),15) +#define get_csv2_uint_pos16(X,Y) get_csv2_uint((X),(Y),16) +#define get_csv2_ullong_pos16(X,Y) get_csv2_ullong((X),(Y),16) +#define get_csv2_ip_pos16(X,Y) get_csv2_ip((X),(Y),16) +#define get_csv2_ipv6_pos16(X,Y) get_csv2_ipv6((X),(Y),16) +#define get_csv2_string_pos16(X,Y) get_csv2_string((X),(Y),16) +#define get_csv2_v_str_pos16(X,Y) get_csv2_string((X),(Y),16) +#define get_csv2_bool_pos16(X,Y) get_csv2_bool((X),(Y),16) +#define get_csv2_int_pos16(X,Y) get_csv2_int((X),(Y),16) +#define get_csv2_llong_pos16(X,Y) get_csv2_llong((X),(Y),16) +#define get_csv2_float_pos16(X,Y) get_csv2_float((X),(Y),16) +#define get_csv2_uint_pos17(X,Y) get_csv2_uint((X),(Y),17) +#define get_csv2_ullong_pos17(X,Y) get_csv2_ullong((X),(Y),17) +#define get_csv2_ip_pos17(X,Y) get_csv2_ip((X),(Y),17) +#define get_csv2_ipv6_pos17(X,Y) get_csv2_ipv6((X),(Y),17) +#define get_csv2_string_pos17(X,Y) get_csv2_string((X),(Y),17) +#define get_csv2_v_str_pos17(X,Y) get_csv2_string((X),(Y),17) +#define get_csv2_bool_pos17(X,Y) get_csv2_bool((X),(Y),17) +#define get_csv2_int_pos17(X,Y) get_csv2_int((X),(Y),17) +#define get_csv2_llong_pos17(X,Y) get_csv2_llong((X),(Y),17) +#define get_csv2_float_pos17(X,Y) get_csv2_float((X),(Y),17) +#define get_csv2_uint_pos18(X,Y) get_csv2_uint((X),(Y),18) +#define get_csv2_ullong_pos18(X,Y) get_csv2_ullong((X),(Y),18) +#define get_csv2_ip_pos18(X,Y) get_csv2_ip((X),(Y),18) +#define get_csv2_ipv6_pos18(X,Y) get_csv2_ipv6((X),(Y),18) +#define get_csv2_string_pos18(X,Y) get_csv2_string((X),(Y),18) +#define get_csv2_v_str_pos18(X,Y) get_csv2_string((X),(Y),18) +#define get_csv2_bool_pos18(X,Y) get_csv2_bool((X),(Y),18) +#define get_csv2_int_pos18(X,Y) get_csv2_int((X),(Y),18) +#define get_csv2_llong_pos18(X,Y) get_csv2_llong((X),(Y),18) +#define get_csv2_float_pos18(X,Y) get_csv2_float((X),(Y),18) +#define get_csv2_uint_pos19(X,Y) get_csv2_uint((X),(Y),19) +#define get_csv2_ullong_pos19(X,Y) get_csv2_ullong((X),(Y),19) +#define get_csv2_ip_pos19(X,Y) get_csv2_ip((X),(Y),19) +#define get_csv2_ipv6_pos19(X,Y) get_csv2_ipv6((X),(Y),19) +#define get_csv2_string_pos19(X,Y) get_csv2_string((X),(Y),19) +#define get_csv2_v_str_pos19(X,Y) get_csv2_string((X),(Y),19) +#define get_csv2_bool_pos19(X,Y) get_csv2_bool((X),(Y),19) +#define get_csv2_int_pos19(X,Y) get_csv2_int((X),(Y),19) +#define get_csv2_llong_pos19(X,Y) get_csv2_llong((X),(Y),19) +#define get_csv2_float_pos19(X,Y) get_csv2_float((X),(Y),19) +#define get_csv2_uint_pos20(X,Y) get_csv2_uint((X),(Y),20) +#define get_csv2_ullong_pos20(X,Y) get_csv2_ullong((X),(Y),20) +#define get_csv2_ip_pos20(X,Y) get_csv2_ip((X),(Y),20) +#define get_csv2_ipv6_pos20(X,Y) get_csv2_ipv6((X),(Y),20) +#define get_csv2_string_pos20(X,Y) get_csv2_string((X),(Y),20) +#define get_csv2_v_str_pos20(X,Y) get_csv2_string((X),(Y),20) +#define get_csv2_bool_pos20(X,Y) get_csv2_bool((X),(Y),20) +#define get_csv2_int_pos20(X,Y) get_csv2_int((X),(Y),20) +#define get_csv2_llong_pos20(X,Y) get_csv2_llong((X),(Y),20) +#define get_csv2_float_pos20(X,Y) get_csv2_float((X),(Y),20) +#define get_csv2_uint_pos21(X,Y) get_csv2_uint((X),(Y),21) +#define get_csv2_ullong_pos21(X,Y) get_csv2_ullong((X),(Y),21) +#define get_csv2_ip_pos21(X,Y) get_csv2_ip((X),(Y),21) +#define get_csv2_ipv6_pos21(X,Y) get_csv2_ipv6((X),(Y),21) +#define get_csv2_string_pos21(X,Y) get_csv2_string((X),(Y),21) +#define get_csv2_v_str_pos21(X,Y) get_csv2_string((X),(Y),21) +#define get_csv2_bool_pos21(X,Y) get_csv2_bool((X),(Y),21) +#define get_csv2_int_pos21(X,Y) get_csv2_int((X),(Y),21) +#define get_csv2_llong_pos21(X,Y) get_csv2_llong((X),(Y),21) +#define get_csv2_float_pos21(X,Y) get_csv2_float((X),(Y),21) +#define get_csv2_uint_pos22(X,Y) get_csv2_uint((X),(Y),22) +#define get_csv2_ullong_pos22(X,Y) get_csv2_ullong((X),(Y),22) +#define get_csv2_ip_pos22(X,Y) get_csv2_ip((X),(Y),22) +#define get_csv2_ipv6_pos22(X,Y) get_csv2_ipv6((X),(Y),22) +#define get_csv2_string_pos22(X,Y) get_csv2_string((X),(Y),22) +#define get_csv2_v_str_pos22(X,Y) get_csv2_string((X),(Y),22) +#define get_csv2_bool_pos22(X,Y) get_csv2_bool((X),(Y),22) +#define get_csv2_int_pos22(X,Y) get_csv2_int((X),(Y),22) +#define get_csv2_llong_pos22(X,Y) get_csv2_llong((X),(Y),22) +#define get_csv2_float_pos22(X,Y) get_csv2_float((X),(Y),22) +#define get_csv2_uint_pos23(X,Y) get_csv2_uint((X),(Y),23) +#define get_csv2_ullong_pos23(X,Y) get_csv2_ullong((X),(Y),23) +#define get_csv2_ip_pos23(X,Y) get_csv2_ip((X),(Y),23) +#define get_csv2_ipv6_pos23(X,Y) get_csv2_ipv6((X),(Y),23) +#define get_csv2_string_pos23(X,Y) get_csv2_string((X),(Y),23) +#define get_csv2_v_str_pos23(X,Y) get_csv2_string((X),(Y),23) +#define get_csv2_bool_pos23(X,Y) get_csv2_bool((X),(Y),23) +#define get_csv2_int_pos23(X,Y) get_csv2_int((X),(Y),23) +#define get_csv2_llong_pos23(X,Y) get_csv2_llong((X),(Y),23) +#define get_csv2_float_pos23(X,Y) get_csv2_float((X),(Y),23) +#define get_csv2_uint_pos24(X,Y) get_csv2_uint((X),(Y),24) +#define get_csv2_ullong_pos24(X,Y) get_csv2_ullong((X),(Y),24) +#define get_csv2_ip_pos24(X,Y) get_csv2_ip((X),(Y),24) +#define get_csv2_ipv6_pos24(X,Y) get_csv2_ipv6((X),(Y),24) +#define get_csv2_string_pos24(X,Y) get_csv2_string((X),(Y),24) +#define get_csv2_v_str_pos24(X,Y) get_csv2_string((X),(Y),24) +#define get_csv2_bool_pos24(X,Y) get_csv2_bool((X),(Y),24) +#define get_csv2_int_pos24(X,Y) get_csv2_int((X),(Y),24) +#define get_csv2_llong_pos24(X,Y) get_csv2_llong((X),(Y),24) +#define get_csv2_float_pos24(X,Y) get_csv2_float((X),(Y),24) +#define get_csv2_uint_pos25(X,Y) get_csv2_uint((X),(Y),25) +#define get_csv2_ullong_pos25(X,Y) get_csv2_ullong((X),(Y),25) +#define get_csv2_ip_pos25(X,Y) get_csv2_ip((X),(Y),25) +#define get_csv2_ipv6_pos25(X,Y) get_csv2_ipv6((X),(Y),25) +#define get_csv2_string_pos25(X,Y) get_csv2_string((X),(Y),25) +#define get_csv2_v_str_pos25(X,Y) get_csv2_string((X),(Y),25) +#define get_csv2_bool_pos25(X,Y) get_csv2_bool((X),(Y),25) +#define get_csv2_int_pos25(X,Y) get_csv2_int((X),(Y),25) +#define get_csv2_llong_pos25(X,Y) get_csv2_llong((X),(Y),25) +#define get_csv2_float_pos25(X,Y) get_csv2_float((X),(Y),25) +#define get_csv2_uint_pos26(X,Y) get_csv2_uint((X),(Y),26) +#define get_csv2_ullong_pos26(X,Y) get_csv2_ullong((X),(Y),26) +#define get_csv2_ip_pos26(X,Y) get_csv2_ip((X),(Y),26) +#define get_csv2_ipv6_pos26(X,Y) get_csv2_ipv6((X),(Y),26) +#define get_csv2_string_pos26(X,Y) get_csv2_string((X),(Y),26) +#define get_csv2_v_str_pos26(X,Y) get_csv2_string((X),(Y),26) +#define get_csv2_bool_pos26(X,Y) get_csv2_bool((X),(Y),26) +#define get_csv2_int_pos26(X,Y) get_csv2_int((X),(Y),26) +#define get_csv2_llong_pos26(X,Y) get_csv2_llong((X),(Y),26) +#define get_csv2_float_pos26(X,Y) get_csv2_float((X),(Y),26) +#define get_csv2_uint_pos27(X,Y) get_csv2_uint((X),(Y),27) +#define get_csv2_ullong_pos27(X,Y) get_csv2_ullong((X),(Y),27) +#define get_csv2_ip_pos27(X,Y) get_csv2_ip((X),(Y),27) +#define get_csv2_ipv6_pos27(X,Y) get_csv2_ipv6((X),(Y),27) +#define get_csv2_string_pos27(X,Y) get_csv2_string((X),(Y),27) +#define get_csv2_v_str_pos27(X,Y) get_csv2_string((X),(Y),27) +#define get_csv2_bool_pos27(X,Y) get_csv2_bool((X),(Y),27) +#define get_csv2_int_pos27(X,Y) get_csv2_int((X),(Y),27) +#define get_csv2_llong_pos27(X,Y) get_csv2_llong((X),(Y),27) +#define get_csv2_float_pos27(X,Y) get_csv2_float((X),(Y),27) +#define get_csv2_uint_pos28(X,Y) get_csv2_uint((X),(Y),28) +#define get_csv2_ullong_pos28(X,Y) get_csv2_ullong((X),(Y),28) +#define get_csv2_ip_pos28(X,Y) get_csv2_ip((X),(Y),28) +#define get_csv2_ipv6_pos28(X,Y) get_csv2_ipv6((X),(Y),28) +#define get_csv2_string_pos28(X,Y) get_csv2_string((X),(Y),28) +#define get_csv2_v_str_pos28(X,Y) get_csv2_string((X),(Y),28) +#define get_csv2_bool_pos28(X,Y) get_csv2_bool((X),(Y),28) +#define get_csv2_int_pos28(X,Y) get_csv2_int((X),(Y),28) +#define get_csv2_llong_pos28(X,Y) get_csv2_llong((X),(Y),28) +#define get_csv2_float_pos28(X,Y) get_csv2_float((X),(Y),28) +#define get_csv2_uint_pos29(X,Y) get_csv2_uint((X),(Y),29) +#define get_csv2_ullong_pos29(X,Y) get_csv2_ullong((X),(Y),29) +#define get_csv2_ip_pos29(X,Y) get_csv2_ip((X),(Y),29) +#define get_csv2_ipv6_pos29(X,Y) get_csv2_ipv6((X),(Y),29) +#define get_csv2_string_pos29(X,Y) get_csv2_string((X),(Y),29) +#define get_csv2_v_str_pos29(X,Y) get_csv2_string((X),(Y),29) +#define get_csv2_bool_pos29(X,Y) get_csv2_bool((X),(Y),29) +#define get_csv2_int_pos29(X,Y) get_csv2_int((X),(Y),29) +#define get_csv2_llong_pos29(X,Y) get_csv2_llong((X),(Y),29) +#define get_csv2_float_pos29(X,Y) get_csv2_float((X),(Y),29) +#define get_csv2_uint_pos30(X,Y) get_csv2_uint((X),(Y),30) +#define get_csv2_ullong_pos30(X,Y) get_csv2_ullong((X),(Y),30) +#define get_csv2_ip_pos30(X,Y) get_csv2_ip((X),(Y),30) +#define get_csv2_ipv6_pos30(X,Y) get_csv2_ipv6((X),(Y),30) +#define get_csv2_string_pos30(X,Y) get_csv2_string((X),(Y),30) +#define get_csv2_v_str_pos30(X,Y) get_csv2_string((X),(Y),30) +#define get_csv2_bool_pos30(X,Y) get_csv2_bool((X),(Y),30) +#define get_csv2_int_pos30(X,Y) get_csv2_int((X),(Y),30) +#define get_csv2_llong_pos30(X,Y) get_csv2_llong((X),(Y),30) +#define get_csv2_float_pos30(X,Y) get_csv2_float((X),(Y),30) +#define get_csv2_uint_pos31(X,Y) get_csv2_uint((X),(Y),31) +#define get_csv2_ullong_pos31(X,Y) get_csv2_ullong((X),(Y),31) +#define get_csv2_ip_pos31(X,Y) get_csv2_ip((X),(Y),31) +#define get_csv2_ipv6_pos31(X,Y) get_csv2_ipv6((X),(Y),31) +#define get_csv2_string_pos31(X,Y) get_csv2_string((X),(Y),31) +#define get_csv2_v_str_pos31(X,Y) get_csv2_string((X),(Y),31) +#define get_csv2_bool_pos31(X,Y) get_csv2_bool((X),(Y),31) +#define get_csv2_int_pos31(X,Y) get_csv2_int((X),(Y),31) +#define get_csv2_llong_pos31(X,Y) get_csv2_llong((X),(Y),31) +#define get_csv2_float_pos31(X,Y) get_csv2_float((X),(Y),31) +#define get_csv2_uint_pos32(X,Y) get_csv2_uint((X),(Y),32) +#define get_csv2_ullong_pos32(X,Y) get_csv2_ullong((X),(Y),32) +#define get_csv2_ip_pos32(X,Y) get_csv2_ip((X),(Y),32) +#define get_csv2_ipv6_pos32(X,Y) get_csv2_ipv6((X),(Y),32) +#define get_csv2_string_pos32(X,Y) get_csv2_string((X),(Y),32) +#define get_csv2_v_str_pos32(X,Y) get_csv2_string((X),(Y),32) +#define get_csv2_bool_pos32(X,Y) get_csv2_bool((X),(Y),32) +#define get_csv2_int_pos32(X,Y) get_csv2_int((X),(Y),32) +#define get_csv2_llong_pos32(X,Y) get_csv2_llong((X),(Y),32) +#define get_csv2_float_pos32(X,Y) get_csv2_float((X),(Y),32) +#define get_csv2_uint_pos33(X,Y) get_csv2_uint((X),(Y),33) +#define get_csv2_ullong_pos33(X,Y) get_csv2_ullong((X),(Y),33) +#define get_csv2_ip_pos33(X,Y) get_csv2_ip((X),(Y),33) +#define get_csv2_ipv6_pos33(X,Y) get_csv2_ipv6((X),(Y),33) +#define get_csv2_string_pos33(X,Y) get_csv2_string((X),(Y),33) +#define get_csv2_v_str_pos33(X,Y) get_csv2_string((X),(Y),33) +#define get_csv2_bool_pos33(X,Y) get_csv2_bool((X),(Y),33) +#define get_csv2_int_pos33(X,Y) get_csv2_int((X),(Y),33) +#define get_csv2_llong_pos33(X,Y) get_csv2_llong((X),(Y),33) +#define get_csv2_float_pos33(X,Y) get_csv2_float((X),(Y),33) +#define get_csv2_uint_pos34(X,Y) get_csv2_uint((X),(Y),34) +#define get_csv2_ullong_pos34(X,Y) get_csv2_ullong((X),(Y),34) +#define get_csv2_ip_pos34(X,Y) get_csv2_ip((X),(Y),34) +#define get_csv2_ipv6_pos34(X,Y) get_csv2_ipv6((X),(Y),34) +#define get_csv2_string_pos34(X,Y) get_csv2_string((X),(Y),34) +#define get_csv2_v_str_pos34(X,Y) get_csv2_string((X),(Y),34) +#define get_csv2_bool_pos34(X,Y) get_csv2_bool((X),(Y),34) +#define get_csv2_int_pos34(X,Y) get_csv2_int((X),(Y),34) +#define get_csv2_llong_pos34(X,Y) get_csv2_llong((X),(Y),34) +#define get_csv2_float_pos34(X,Y) get_csv2_float((X),(Y),34) +#define get_csv2_uint_pos35(X,Y) get_csv2_uint((X),(Y),35) +#define get_csv2_ullong_pos35(X,Y) get_csv2_ullong((X),(Y),35) +#define get_csv2_ip_pos35(X,Y) get_csv2_ip((X),(Y),35) +#define get_csv2_ipv6_pos35(X,Y) get_csv2_ipv6((X),(Y),35) +#define get_csv2_string_pos35(X,Y) get_csv2_string((X),(Y),35) +#define get_csv2_v_str_pos35(X,Y) get_csv2_string((X),(Y),35) +#define get_csv2_bool_pos35(X,Y) get_csv2_bool((X),(Y),35) +#define get_csv2_int_pos35(X,Y) get_csv2_int((X),(Y),35) +#define get_csv2_llong_pos35(X,Y) get_csv2_llong((X),(Y),35) +#define get_csv2_float_pos35(X,Y) get_csv2_float((X),(Y),35) +#define get_csv2_uint_pos36(X,Y) get_csv2_uint((X),(Y),36) +#define get_csv2_ullong_pos36(X,Y) get_csv2_ullong((X),(Y),36) +#define get_csv2_ip_pos36(X,Y) get_csv2_ip((X),(Y),36) +#define get_csv2_ipv6_pos36(X,Y) get_csv2_ipv6((X),(Y),36) +#define get_csv2_string_pos36(X,Y) get_csv2_string((X),(Y),36) +#define get_csv2_v_str_pos36(X,Y) get_csv2_string((X),(Y),36) +#define get_csv2_bool_pos36(X,Y) get_csv2_bool((X),(Y),36) +#define get_csv2_int_pos36(X,Y) get_csv2_int((X),(Y),36) +#define get_csv2_llong_pos36(X,Y) get_csv2_llong((X),(Y),36) +#define get_csv2_float_pos36(X,Y) get_csv2_float((X),(Y),36) +#define get_csv2_uint_pos37(X,Y) get_csv2_uint((X),(Y),37) +#define get_csv2_ullong_pos37(X,Y) get_csv2_ullong((X),(Y),37) +#define get_csv2_ip_pos37(X,Y) get_csv2_ip((X),(Y),37) +#define get_csv2_ipv6_pos37(X,Y) get_csv2_ipv6((X),(Y),37) +#define get_csv2_string_pos37(X,Y) get_csv2_string((X),(Y),37) +#define get_csv2_v_str_pos37(X,Y) get_csv2_string((X),(Y),37) +#define get_csv2_bool_pos37(X,Y) get_csv2_bool((X),(Y),37) +#define get_csv2_int_pos37(X,Y) get_csv2_int((X),(Y),37) +#define get_csv2_llong_pos37(X,Y) get_csv2_llong((X),(Y),37) +#define get_csv2_float_pos37(X,Y) get_csv2_float((X),(Y),37) +#define get_csv2_uint_pos38(X,Y) get_csv2_uint((X),(Y),38) +#define get_csv2_ullong_pos38(X,Y) get_csv2_ullong((X),(Y),38) +#define get_csv2_ip_pos38(X,Y) get_csv2_ip((X),(Y),38) +#define get_csv2_ipv6_pos38(X,Y) get_csv2_ipv6((X),(Y),38) +#define get_csv2_string_pos38(X,Y) get_csv2_string((X),(Y),38) +#define get_csv2_v_str_pos38(X,Y) get_csv2_string((X),(Y),38) +#define get_csv2_bool_pos38(X,Y) get_csv2_bool((X),(Y),38) +#define get_csv2_int_pos38(X,Y) get_csv2_int((X),(Y),38) +#define get_csv2_llong_pos38(X,Y) get_csv2_llong((X),(Y),38) +#define get_csv2_float_pos38(X,Y) get_csv2_float((X),(Y),38) +#define get_csv2_uint_pos39(X,Y) get_csv2_uint((X),(Y),39) +#define get_csv2_ullong_pos39(X,Y) get_csv2_ullong((X),(Y),39) +#define get_csv2_ip_pos39(X,Y) get_csv2_ip((X),(Y),39) +#define get_csv2_ipv6_pos39(X,Y) get_csv2_ipv6((X),(Y),39) +#define get_csv2_string_pos39(X,Y) get_csv2_string((X),(Y),39) +#define get_csv2_v_str_pos39(X,Y) get_csv2_string((X),(Y),39) +#define get_csv2_bool_pos39(X,Y) get_csv2_bool((X),(Y),39) +#define get_csv2_int_pos39(X,Y) get_csv2_int((X),(Y),39) +#define get_csv2_llong_pos39(X,Y) get_csv2_llong((X),(Y),39) +#define get_csv2_float_pos39(X,Y) get_csv2_float((X),(Y),39) +#define get_csv2_uint_pos40(X,Y) get_csv2_uint((X),(Y),40) +#define get_csv2_ullong_pos40(X,Y) get_csv2_ullong((X),(Y),40) +#define get_csv2_ip_pos40(X,Y) get_csv2_ip((X),(Y),40) +#define get_csv2_ipv6_pos40(X,Y) get_csv2_ipv6((X),(Y),40) +#define get_csv2_string_pos40(X,Y) get_csv2_string((X),(Y),40) +#define get_csv2_v_str_pos40(X,Y) get_csv2_string((X),(Y),40) +#define get_csv2_bool_pos40(X,Y) get_csv2_bool((X),(Y),40) +#define get_csv2_int_pos40(X,Y) get_csv2_int((X),(Y),40) +#define get_csv2_llong_pos40(X,Y) get_csv2_llong((X),(Y),40) +#define get_csv2_float_pos40(X,Y) get_csv2_float((X),(Y),40) +#define get_csv2_uint_pos41(X,Y) get_csv2_uint((X),(Y),41) +#define get_csv2_ullong_pos41(X,Y) get_csv2_ullong((X),(Y),41) +#define get_csv2_ip_pos41(X,Y) get_csv2_ip((X),(Y),41) +#define get_csv2_ipv6_pos41(X,Y) get_csv2_ipv6((X),(Y),41) +#define get_csv2_string_pos41(X,Y) get_csv2_string((X),(Y),41) +#define get_csv2_v_str_pos41(X,Y) get_csv2_string((X),(Y),41) +#define get_csv2_bool_pos41(X,Y) get_csv2_bool((X),(Y),41) +#define get_csv2_int_pos41(X,Y) get_csv2_int((X),(Y),41) +#define get_csv2_llong_pos41(X,Y) get_csv2_llong((X),(Y),41) +#define get_csv2_float_pos41(X,Y) get_csv2_float((X),(Y),41) +#define get_csv2_uint_pos42(X,Y) get_csv2_uint((X),(Y),42) +#define get_csv2_ullong_pos42(X,Y) get_csv2_ullong((X),(Y),42) +#define get_csv2_ip_pos42(X,Y) get_csv2_ip((X),(Y),42) +#define get_csv2_ipv6_pos42(X,Y) get_csv2_ipv6((X),(Y),42) +#define get_csv2_string_pos42(X,Y) get_csv2_string((X),(Y),42) +#define get_csv2_v_str_pos42(X,Y) get_csv2_string((X),(Y),42) +#define get_csv2_bool_pos42(X,Y) get_csv2_bool((X),(Y),42) +#define get_csv2_int_pos42(X,Y) get_csv2_int((X),(Y),42) +#define get_csv2_llong_pos42(X,Y) get_csv2_llong((X),(Y),42) +#define get_csv2_float_pos42(X,Y) get_csv2_float((X),(Y),42) +#define get_csv2_uint_pos43(X,Y) get_csv2_uint((X),(Y),43) +#define get_csv2_ullong_pos43(X,Y) get_csv2_ullong((X),(Y),43) +#define get_csv2_ip_pos43(X,Y) get_csv2_ip((X),(Y),43) +#define get_csv2_ipv6_pos43(X,Y) get_csv2_ipv6((X),(Y),43) +#define get_csv2_string_pos43(X,Y) get_csv2_string((X),(Y),43) +#define get_csv2_v_str_pos43(X,Y) get_csv2_string((X),(Y),43) +#define get_csv2_bool_pos43(X,Y) get_csv2_bool((X),(Y),43) +#define get_csv2_int_pos43(X,Y) get_csv2_int((X),(Y),43) +#define get_csv2_llong_pos43(X,Y) get_csv2_llong((X),(Y),43) +#define get_csv2_float_pos43(X,Y) get_csv2_float((X),(Y),43) +#define get_csv2_uint_pos44(X,Y) get_csv2_uint((X),(Y),44) +#define get_csv2_ullong_pos44(X,Y) get_csv2_ullong((X),(Y),44) +#define get_csv2_ip_pos44(X,Y) get_csv2_ip((X),(Y),44) +#define get_csv2_ipv6_pos44(X,Y) get_csv2_ipv6((X),(Y),44) +#define get_csv2_string_pos44(X,Y) get_csv2_string((X),(Y),44) +#define get_csv2_v_str_pos44(X,Y) get_csv2_string((X),(Y),44) +#define get_csv2_bool_pos44(X,Y) get_csv2_bool((X),(Y),44) +#define get_csv2_int_pos44(X,Y) get_csv2_int((X),(Y),44) +#define get_csv2_llong_pos44(X,Y) get_csv2_llong((X),(Y),44) +#define get_csv2_float_pos44(X,Y) get_csv2_float((X),(Y),44) +#define get_csv2_uint_pos45(X,Y) get_csv2_uint((X),(Y),45) +#define get_csv2_ullong_pos45(X,Y) get_csv2_ullong((X),(Y),45) +#define get_csv2_ip_pos45(X,Y) get_csv2_ip((X),(Y),45) +#define get_csv2_ipv6_pos45(X,Y) get_csv2_ipv6((X),(Y),45) +#define get_csv2_string_pos45(X,Y) get_csv2_string((X),(Y),45) +#define get_csv2_v_str_pos45(X,Y) get_csv2_string((X),(Y),45) +#define get_csv2_bool_pos45(X,Y) get_csv2_bool((X),(Y),45) +#define get_csv2_int_pos45(X,Y) get_csv2_int((X),(Y),45) +#define get_csv2_llong_pos45(X,Y) get_csv2_llong((X),(Y),45) +#define get_csv2_float_pos45(X,Y) get_csv2_float((X),(Y),45) +#define get_csv2_uint_pos46(X,Y) get_csv2_uint((X),(Y),46) +#define get_csv2_ullong_pos46(X,Y) get_csv2_ullong((X),(Y),46) +#define get_csv2_ip_pos46(X,Y) get_csv2_ip((X),(Y),46) +#define get_csv2_ipv6_pos46(X,Y) get_csv2_ipv6((X),(Y),46) +#define get_csv2_string_pos46(X,Y) get_csv2_string((X),(Y),46) +#define get_csv2_v_str_pos46(X,Y) get_csv2_string((X),(Y),46) +#define get_csv2_bool_pos46(X,Y) get_csv2_bool((X),(Y),46) +#define get_csv2_int_pos46(X,Y) get_csv2_int((X),(Y),46) +#define get_csv2_llong_pos46(X,Y) get_csv2_llong((X),(Y),46) +#define get_csv2_float_pos46(X,Y) get_csv2_float((X),(Y),46) +#define get_csv2_uint_pos47(X,Y) get_csv2_uint((X),(Y),47) +#define get_csv2_ullong_pos47(X,Y) get_csv2_ullong((X),(Y),47) +#define get_csv2_ip_pos47(X,Y) get_csv2_ip((X),(Y),47) +#define get_csv2_ipv6_pos47(X,Y) get_csv2_ipv6((X),(Y),47) +#define get_csv2_string_pos47(X,Y) get_csv2_string((X),(Y),47) +#define get_csv2_v_str_pos47(X,Y) get_csv2_string((X),(Y),47) +#define get_csv2_bool_pos47(X,Y) get_csv2_bool((X),(Y),47) +#define get_csv2_int_pos47(X,Y) get_csv2_int((X),(Y),47) +#define get_csv2_llong_pos47(X,Y) get_csv2_llong((X),(Y),47) +#define get_csv2_float_pos47(X,Y) get_csv2_float((X),(Y),47) +#define get_csv2_uint_pos48(X,Y) get_csv2_uint((X),(Y),48) +#define get_csv2_ullong_pos48(X,Y) get_csv2_ullong((X),(Y),48) +#define get_csv2_ip_pos48(X,Y) get_csv2_ip((X),(Y),48) +#define get_csv2_ipv6_pos48(X,Y) get_csv2_ipv6((X),(Y),48) +#define get_csv2_string_pos48(X,Y) get_csv2_string((X),(Y),48) +#define get_csv2_v_str_pos48(X,Y) get_csv2_string((X),(Y),48) +#define get_csv2_bool_pos48(X,Y) get_csv2_bool((X),(Y),48) +#define get_csv2_int_pos48(X,Y) get_csv2_int((X),(Y),48) +#define get_csv2_llong_pos48(X,Y) get_csv2_llong((X),(Y),48) +#define get_csv2_float_pos48(X,Y) get_csv2_float((X),(Y),48) +#define get_csv2_uint_pos49(X,Y) get_csv2_uint((X),(Y),49) +#define get_csv2_ullong_pos49(X,Y) get_csv2_ullong((X),(Y),49) +#define get_csv2_ip_pos49(X,Y) get_csv2_ip((X),(Y),49) +#define get_csv2_ipv6_pos49(X,Y) get_csv2_ipv6((X),(Y),49) +#define get_csv2_string_pos49(X,Y) get_csv2_string((X),(Y),49) +#define get_csv2_v_str_pos49(X,Y) get_csv2_string((X),(Y),49) +#define get_csv2_bool_pos49(X,Y) get_csv2_bool((X),(Y),49) +#define get_csv2_int_pos49(X,Y) get_csv2_int((X),(Y),49) +#define get_csv2_llong_pos49(X,Y) get_csv2_llong((X),(Y),49) +#define get_csv2_float_pos49(X,Y) get_csv2_float((X),(Y),49) +#define get_csv2_uint_pos50(X,Y) get_csv2_uint((X),(Y),50) +#define get_csv2_ullong_pos50(X,Y) get_csv2_ullong((X),(Y),50) +#define get_csv2_ip_pos50(X,Y) get_csv2_ip((X),(Y),50) +#define get_csv2_ipv6_pos50(X,Y) get_csv2_ipv6((X),(Y),50) +#define get_csv2_string_pos50(X,Y) get_csv2_string((X),(Y),50) +#define get_csv2_v_str_pos50(X,Y) get_csv2_string((X),(Y),50) +#define get_csv2_bool_pos50(X,Y) get_csv2_bool((X),(Y),50) +#define get_csv2_int_pos50(X,Y) get_csv2_int((X),(Y),50) +#define get_csv2_llong_pos50(X,Y) get_csv2_llong((X),(Y),50) +#define get_csv2_float_pos50(X,Y) get_csv2_float((X),(Y),50) +#define get_csv2_uint_pos51(X,Y) get_csv2_uint((X),(Y),51) +#define get_csv2_ullong_pos51(X,Y) get_csv2_ullong((X),(Y),51) +#define get_csv2_ip_pos51(X,Y) get_csv2_ip((X),(Y),51) +#define get_csv2_ipv6_pos51(X,Y) get_csv2_ipv6((X),(Y),51) +#define get_csv2_string_pos51(X,Y) get_csv2_string((X),(Y),51) +#define get_csv2_v_str_pos51(X,Y) get_csv2_string((X),(Y),51) +#define get_csv2_bool_pos51(X,Y) get_csv2_bool((X),(Y),51) +#define get_csv2_int_pos51(X,Y) get_csv2_int((X),(Y),51) +#define get_csv2_llong_pos51(X,Y) get_csv2_llong((X),(Y),51) +#define get_csv2_float_pos51(X,Y) get_csv2_float((X),(Y),51) +#define get_csv2_uint_pos52(X,Y) get_csv2_uint((X),(Y),52) +#define get_csv2_ullong_pos52(X,Y) get_csv2_ullong((X),(Y),52) +#define get_csv2_ip_pos52(X,Y) get_csv2_ip((X),(Y),52) +#define get_csv2_ipv6_pos52(X,Y) get_csv2_ipv6((X),(Y),52) +#define get_csv2_string_pos52(X,Y) get_csv2_string((X),(Y),52) +#define get_csv2_v_str_pos52(X,Y) get_csv2_string((X),(Y),52) +#define get_csv2_bool_pos52(X,Y) get_csv2_bool((X),(Y),52) +#define get_csv2_int_pos52(X,Y) get_csv2_int((X),(Y),52) +#define get_csv2_llong_pos52(X,Y) get_csv2_llong((X),(Y),52) +#define get_csv2_float_pos52(X,Y) get_csv2_float((X),(Y),52) +#define get_csv2_uint_pos53(X,Y) get_csv2_uint((X),(Y),53) +#define get_csv2_ullong_pos53(X,Y) get_csv2_ullong((X),(Y),53) +#define get_csv2_ip_pos53(X,Y) get_csv2_ip((X),(Y),53) +#define get_csv2_ipv6_pos53(X,Y) get_csv2_ipv6((X),(Y),53) +#define get_csv2_string_pos53(X,Y) get_csv2_string((X),(Y),53) +#define get_csv2_v_str_pos53(X,Y) get_csv2_string((X),(Y),53) +#define get_csv2_bool_pos53(X,Y) get_csv2_bool((X),(Y),53) +#define get_csv2_int_pos53(X,Y) get_csv2_int((X),(Y),53) +#define get_csv2_llong_pos53(X,Y) get_csv2_llong((X),(Y),53) +#define get_csv2_float_pos53(X,Y) get_csv2_float((X),(Y),53) +#define get_csv2_uint_pos54(X,Y) get_csv2_uint((X),(Y),54) +#define get_csv2_ullong_pos54(X,Y) get_csv2_ullong((X),(Y),54) +#define get_csv2_ip_pos54(X,Y) get_csv2_ip((X),(Y),54) +#define get_csv2_ipv6_pos54(X,Y) get_csv2_ipv6((X),(Y),54) +#define get_csv2_string_pos54(X,Y) get_csv2_string((X),(Y),54) +#define get_csv2_v_str_pos54(X,Y) get_csv2_string((X),(Y),54) +#define get_csv2_bool_pos54(X,Y) get_csv2_bool((X),(Y),54) +#define get_csv2_int_pos54(X,Y) get_csv2_int((X),(Y),54) +#define get_csv2_llong_pos54(X,Y) get_csv2_llong((X),(Y),54) +#define get_csv2_float_pos54(X,Y) get_csv2_float((X),(Y),54) +#define get_csv2_uint_pos55(X,Y) get_csv2_uint((X),(Y),55) +#define get_csv2_ullong_pos55(X,Y) get_csv2_ullong((X),(Y),55) +#define get_csv2_ip_pos55(X,Y) get_csv2_ip((X),(Y),55) +#define get_csv2_ipv6_pos55(X,Y) get_csv2_ipv6((X),(Y),55) +#define get_csv2_string_pos55(X,Y) get_csv2_string((X),(Y),55) +#define get_csv2_v_str_pos55(X,Y) get_csv2_string((X),(Y),55) +#define get_csv2_bool_pos55(X,Y) get_csv2_bool((X),(Y),55) +#define get_csv2_int_pos55(X,Y) get_csv2_int((X),(Y),55) +#define get_csv2_llong_pos55(X,Y) get_csv2_llong((X),(Y),55) +#define get_csv2_float_pos55(X,Y) get_csv2_float((X),(Y),55) +#define get_csv2_uint_pos56(X,Y) get_csv2_uint((X),(Y),56) +#define get_csv2_ullong_pos56(X,Y) get_csv2_ullong((X),(Y),56) +#define get_csv2_ip_pos56(X,Y) get_csv2_ip((X),(Y),56) +#define get_csv2_ipv6_pos56(X,Y) get_csv2_ipv6((X),(Y),56) +#define get_csv2_string_pos56(X,Y) get_csv2_string((X),(Y),56) +#define get_csv2_v_str_pos56(X,Y) get_csv2_string((X),(Y),56) +#define get_csv2_bool_pos56(X,Y) get_csv2_bool((X),(Y),56) +#define get_csv2_int_pos56(X,Y) get_csv2_int((X),(Y),56) +#define get_csv2_llong_pos56(X,Y) get_csv2_llong((X),(Y),56) +#define get_csv2_float_pos56(X,Y) get_csv2_float((X),(Y),56) +#define get_csv2_uint_pos57(X,Y) get_csv2_uint((X),(Y),57) +#define get_csv2_ullong_pos57(X,Y) get_csv2_ullong((X),(Y),57) +#define get_csv2_ip_pos57(X,Y) get_csv2_ip((X),(Y),57) +#define get_csv2_ipv6_pos57(X,Y) get_csv2_ipv6((X),(Y),57) +#define get_csv2_string_pos57(X,Y) get_csv2_string((X),(Y),57) +#define get_csv2_v_str_pos57(X,Y) get_csv2_string((X),(Y),57) +#define get_csv2_bool_pos57(X,Y) get_csv2_bool((X),(Y),57) +#define get_csv2_int_pos57(X,Y) get_csv2_int((X),(Y),57) +#define get_csv2_llong_pos57(X,Y) get_csv2_llong((X),(Y),57) +#define get_csv2_float_pos57(X,Y) get_csv2_float((X),(Y),57) +#define get_csv2_uint_pos58(X,Y) get_csv2_uint((X),(Y),58) +#define get_csv2_ullong_pos58(X,Y) get_csv2_ullong((X),(Y),58) +#define get_csv2_ip_pos58(X,Y) get_csv2_ip((X),(Y),58) +#define get_csv2_ipv6_pos58(X,Y) get_csv2_ipv6((X),(Y),58) +#define get_csv2_string_pos58(X,Y) get_csv2_string((X),(Y),58) +#define get_csv2_v_str_pos58(X,Y) get_csv2_string((X),(Y),58) +#define get_csv2_bool_pos58(X,Y) get_csv2_bool((X),(Y),58) +#define get_csv2_int_pos58(X,Y) get_csv2_int((X),(Y),58) +#define get_csv2_llong_pos58(X,Y) get_csv2_llong((X),(Y),58) +#define get_csv2_float_pos58(X,Y) get_csv2_float((X),(Y),58) +#define get_csv2_uint_pos59(X,Y) get_csv2_uint((X),(Y),59) +#define get_csv2_ullong_pos59(X,Y) get_csv2_ullong((X),(Y),59) +#define get_csv2_ip_pos59(X,Y) get_csv2_ip((X),(Y),59) +#define get_csv2_ipv6_pos59(X,Y) get_csv2_ipv6((X),(Y),59) +#define get_csv2_string_pos59(X,Y) get_csv2_string((X),(Y),59) +#define get_csv2_v_str_pos59(X,Y) get_csv2_string((X),(Y),59) +#define get_csv2_bool_pos59(X,Y) get_csv2_bool((X),(Y),59) +#define get_csv2_int_pos59(X,Y) get_csv2_int((X),(Y),59) +#define get_csv2_llong_pos59(X,Y) get_csv2_llong((X),(Y),59) +#define get_csv2_float_pos59(X,Y) get_csv2_float((X),(Y),59) +#define get_csv2_uint_pos60(X,Y) get_csv2_uint((X),(Y),60) +#define get_csv2_ullong_pos60(X,Y) get_csv2_ullong((X),(Y),60) +#define get_csv2_ip_pos60(X,Y) get_csv2_ip((X),(Y),60) +#define get_csv2_ipv6_pos60(X,Y) get_csv2_ipv6((X),(Y),60) +#define get_csv2_string_pos60(X,Y) get_csv2_string((X),(Y),60) +#define get_csv2_v_str_pos60(X,Y) get_csv2_string((X),(Y),60) +#define get_csv2_bool_pos60(X,Y) get_csv2_bool((X),(Y),60) +#define get_csv2_int_pos60(X,Y) get_csv2_int((X),(Y),60) +#define get_csv2_llong_pos60(X,Y) get_csv2_llong((X),(Y),60) +#define get_csv2_float_pos60(X,Y) get_csv2_float((X),(Y),60) +#define get_csv2_uint_pos61(X,Y) get_csv2_uint((X),(Y),61) +#define get_csv2_ullong_pos61(X,Y) get_csv2_ullong((X),(Y),61) +#define get_csv2_ip_pos61(X,Y) get_csv2_ip((X),(Y),61) +#define get_csv2_ipv6_pos61(X,Y) get_csv2_ipv6((X),(Y),61) +#define get_csv2_string_pos61(X,Y) get_csv2_string((X),(Y),61) +#define get_csv2_v_str_pos61(X,Y) get_csv2_string((X),(Y),61) +#define get_csv2_bool_pos61(X,Y) get_csv2_bool((X),(Y),61) +#define get_csv2_int_pos61(X,Y) get_csv2_int((X),(Y),61) +#define get_csv2_llong_pos61(X,Y) get_csv2_llong((X),(Y),61) +#define get_csv2_float_pos61(X,Y) get_csv2_float((X),(Y),61) +#define get_csv2_uint_pos62(X,Y) get_csv2_uint((X),(Y),62) +#define get_csv2_ullong_pos62(X,Y) get_csv2_ullong((X),(Y),62) +#define get_csv2_ip_pos62(X,Y) get_csv2_ip((X),(Y),62) +#define get_csv2_ipv6_pos62(X,Y) get_csv2_ipv6((X),(Y),62) +#define get_csv2_string_pos62(X,Y) get_csv2_string((X),(Y),62) +#define get_csv2_v_str_pos62(X,Y) get_csv2_string((X),(Y),62) +#define get_csv2_bool_pos62(X,Y) get_csv2_bool((X),(Y),62) +#define get_csv2_int_pos62(X,Y) get_csv2_int((X),(Y),62) +#define get_csv2_llong_pos62(X,Y) get_csv2_llong((X),(Y),62) +#define get_csv2_float_pos62(X,Y) get_csv2_float((X),(Y),62) +#define get_csv2_uint_pos63(X,Y) get_csv2_uint((X),(Y),63) +#define get_csv2_ullong_pos63(X,Y) get_csv2_ullong((X),(Y),63) +#define get_csv2_ip_pos63(X,Y) get_csv2_ip((X),(Y),63) +#define get_csv2_ipv6_pos63(X,Y) get_csv2_ipv6((X),(Y),63) +#define get_csv2_string_pos63(X,Y) get_csv2_string((X),(Y),63) +#define get_csv2_v_str_pos63(X,Y) get_csv2_string((X),(Y),63) +#define get_csv2_bool_pos63(X,Y) get_csv2_bool((X),(Y),63) +#define get_csv2_int_pos63(X,Y) get_csv2_int((X),(Y),63) +#define get_csv2_llong_pos63(X,Y) get_csv2_llong((X),(Y),63) +#define get_csv2_float_pos63(X,Y) get_csv2_float((X),(Y),63) +#define get_csv2_uint_pos64(X,Y) get_csv2_uint((X),(Y),64) +#define get_csv2_ullong_pos64(X,Y) get_csv2_ullong((X),(Y),64) +#define get_csv2_ip_pos64(X,Y) get_csv2_ip((X),(Y),64) +#define get_csv2_ipv6_pos64(X,Y) get_csv2_ipv6((X),(Y),64) +#define get_csv2_string_pos64(X,Y) get_csv2_string((X),(Y),64) +#define get_csv2_v_str_pos64(X,Y) get_csv2_string((X),(Y),64) +#define get_csv2_bool_pos64(X,Y) get_csv2_bool((X),(Y),64) +#define get_csv2_int_pos64(X,Y) get_csv2_int((X),(Y),64) +#define get_csv2_llong_pos64(X,Y) get_csv2_llong((X),(Y),64) +#define get_csv2_float_pos64(X,Y) get_csv2_float((X),(Y),64) +#define get_csv2_uint_pos65(X,Y) get_csv2_uint((X),(Y),65) +#define get_csv2_ullong_pos65(X,Y) get_csv2_ullong((X),(Y),65) +#define get_csv2_ip_pos65(X,Y) get_csv2_ip((X),(Y),65) +#define get_csv2_ipv6_pos65(X,Y) get_csv2_ipv6((X),(Y),65) +#define get_csv2_string_pos65(X,Y) get_csv2_string((X),(Y),65) +#define get_csv2_v_str_pos65(X,Y) get_csv2_string((X),(Y),65) +#define get_csv2_bool_pos65(X,Y) get_csv2_bool((X),(Y),65) +#define get_csv2_int_pos65(X,Y) get_csv2_int((X),(Y),65) +#define get_csv2_llong_pos65(X,Y) get_csv2_llong((X),(Y),65) +#define get_csv2_float_pos65(X,Y) get_csv2_float((X),(Y),65) +#define get_csv2_uint_pos66(X,Y) get_csv2_uint((X),(Y),66) +#define get_csv2_ullong_pos66(X,Y) get_csv2_ullong((X),(Y),66) +#define get_csv2_ip_pos66(X,Y) get_csv2_ip((X),(Y),66) +#define get_csv2_ipv6_pos66(X,Y) get_csv2_ipv6((X),(Y),66) +#define get_csv2_string_pos66(X,Y) get_csv2_string((X),(Y),66) +#define get_csv2_v_str_pos66(X,Y) get_csv2_string((X),(Y),66) +#define get_csv2_bool_pos66(X,Y) get_csv2_bool((X),(Y),66) +#define get_csv2_int_pos66(X,Y) get_csv2_int((X),(Y),66) +#define get_csv2_llong_pos66(X,Y) get_csv2_llong((X),(Y),66) +#define get_csv2_float_pos66(X,Y) get_csv2_float((X),(Y),66) +#define get_csv2_uint_pos67(X,Y) get_csv2_uint((X),(Y),67) +#define get_csv2_ullong_pos67(X,Y) get_csv2_ullong((X),(Y),67) +#define get_csv2_ip_pos67(X,Y) get_csv2_ip((X),(Y),67) +#define get_csv2_ipv6_pos67(X,Y) get_csv2_ipv6((X),(Y),67) +#define get_csv2_string_pos67(X,Y) get_csv2_string((X),(Y),67) +#define get_csv2_v_str_pos67(X,Y) get_csv2_string((X),(Y),67) +#define get_csv2_bool_pos67(X,Y) get_csv2_bool((X),(Y),67) +#define get_csv2_int_pos67(X,Y) get_csv2_int((X),(Y),67) +#define get_csv2_llong_pos67(X,Y) get_csv2_llong((X),(Y),67) +#define get_csv2_float_pos67(X,Y) get_csv2_float((X),(Y),67) +#define get_csv2_uint_pos68(X,Y) get_csv2_uint((X),(Y),68) +#define get_csv2_ullong_pos68(X,Y) get_csv2_ullong((X),(Y),68) +#define get_csv2_ip_pos68(X,Y) get_csv2_ip((X),(Y),68) +#define get_csv2_ipv6_pos68(X,Y) get_csv2_ipv6((X),(Y),68) +#define get_csv2_string_pos68(X,Y) get_csv2_string((X),(Y),68) +#define get_csv2_v_str_pos68(X,Y) get_csv2_string((X),(Y),68) +#define get_csv2_bool_pos68(X,Y) get_csv2_bool((X),(Y),68) +#define get_csv2_int_pos68(X,Y) get_csv2_int((X),(Y),68) +#define get_csv2_llong_pos68(X,Y) get_csv2_llong((X),(Y),68) +#define get_csv2_float_pos68(X,Y) get_csv2_float((X),(Y),68) +#define get_csv2_uint_pos69(X,Y) get_csv2_uint((X),(Y),69) +#define get_csv2_ullong_pos69(X,Y) get_csv2_ullong((X),(Y),69) +#define get_csv2_ip_pos69(X,Y) get_csv2_ip((X),(Y),69) +#define get_csv2_ipv6_pos69(X,Y) get_csv2_ipv6((X),(Y),69) +#define get_csv2_string_pos69(X,Y) get_csv2_string((X),(Y),69) +#define get_csv2_v_str_pos69(X,Y) get_csv2_string((X),(Y),69) +#define get_csv2_bool_pos69(X,Y) get_csv2_bool((X),(Y),69) +#define get_csv2_int_pos69(X,Y) get_csv2_int((X),(Y),69) +#define get_csv2_llong_pos69(X,Y) get_csv2_llong((X),(Y),69) +#define get_csv2_float_pos69(X,Y) get_csv2_float((X),(Y),69) +#define get_csv2_uint_pos70(X,Y) get_csv2_uint((X),(Y),70) +#define get_csv2_ullong_pos70(X,Y) get_csv2_ullong((X),(Y),70) +#define get_csv2_ip_pos70(X,Y) get_csv2_ip((X),(Y),70) +#define get_csv2_ipv6_pos70(X,Y) get_csv2_ipv6((X),(Y),70) +#define get_csv2_string_pos70(X,Y) get_csv2_string((X),(Y),70) +#define get_csv2_v_str_pos70(X,Y) get_csv2_string((X),(Y),70) +#define get_csv2_bool_pos70(X,Y) get_csv2_bool((X),(Y),70) +#define get_csv2_int_pos70(X,Y) get_csv2_int((X),(Y),70) +#define get_csv2_llong_pos70(X,Y) get_csv2_llong((X),(Y),70) +#define get_csv2_float_pos70(X,Y) get_csv2_float((X),(Y),70) +#define get_csv2_uint_pos71(X,Y) get_csv2_uint((X),(Y),71) +#define get_csv2_ullong_pos71(X,Y) get_csv2_ullong((X),(Y),71) +#define get_csv2_ip_pos71(X,Y) get_csv2_ip((X),(Y),71) +#define get_csv2_ipv6_pos71(X,Y) get_csv2_ipv6((X),(Y),71) +#define get_csv2_string_pos71(X,Y) get_csv2_string((X),(Y),71) +#define get_csv2_v_str_pos71(X,Y) get_csv2_string((X),(Y),71) +#define get_csv2_bool_pos71(X,Y) get_csv2_bool((X),(Y),71) +#define get_csv2_int_pos71(X,Y) get_csv2_int((X),(Y),71) +#define get_csv2_llong_pos71(X,Y) get_csv2_llong((X),(Y),71) +#define get_csv2_float_pos71(X,Y) get_csv2_float((X),(Y),71) +#define get_csv2_uint_pos72(X,Y) get_csv2_uint((X),(Y),72) +#define get_csv2_ullong_pos72(X,Y) get_csv2_ullong((X),(Y),72) +#define get_csv2_ip_pos72(X,Y) get_csv2_ip((X),(Y),72) +#define get_csv2_ipv6_pos72(X,Y) get_csv2_ipv6((X),(Y),72) +#define get_csv2_string_pos72(X,Y) get_csv2_string((X),(Y),72) +#define get_csv2_v_str_pos72(X,Y) get_csv2_string((X),(Y),72) +#define get_csv2_bool_pos72(X,Y) get_csv2_bool((X),(Y),72) +#define get_csv2_int_pos72(X,Y) get_csv2_int((X),(Y),72) +#define get_csv2_llong_pos72(X,Y) get_csv2_llong((X),(Y),72) +#define get_csv2_float_pos72(X,Y) get_csv2_float((X),(Y),72) +#define get_csv2_uint_pos73(X,Y) get_csv2_uint((X),(Y),73) +#define get_csv2_ullong_pos73(X,Y) get_csv2_ullong((X),(Y),73) +#define get_csv2_ip_pos73(X,Y) get_csv2_ip((X),(Y),73) +#define get_csv2_ipv6_pos73(X,Y) get_csv2_ipv6((X),(Y),73) +#define get_csv2_string_pos73(X,Y) get_csv2_string((X),(Y),73) +#define get_csv2_v_str_pos73(X,Y) get_csv2_string((X),(Y),73) +#define get_csv2_bool_pos73(X,Y) get_csv2_bool((X),(Y),73) +#define get_csv2_int_pos73(X,Y) get_csv2_int((X),(Y),73) +#define get_csv2_llong_pos73(X,Y) get_csv2_llong((X),(Y),73) +#define get_csv2_float_pos73(X,Y) get_csv2_float((X),(Y),73) +#define get_csv2_uint_pos74(X,Y) get_csv2_uint((X),(Y),74) +#define get_csv2_ullong_pos74(X,Y) get_csv2_ullong((X),(Y),74) +#define get_csv2_ip_pos74(X,Y) get_csv2_ip((X),(Y),74) +#define get_csv2_ipv6_pos74(X,Y) get_csv2_ipv6((X),(Y),74) +#define get_csv2_string_pos74(X,Y) get_csv2_string((X),(Y),74) +#define get_csv2_v_str_pos74(X,Y) get_csv2_string((X),(Y),74) +#define get_csv2_bool_pos74(X,Y) get_csv2_bool((X),(Y),74) +#define get_csv2_int_pos74(X,Y) get_csv2_int((X),(Y),74) +#define get_csv2_llong_pos74(X,Y) get_csv2_llong((X),(Y),74) +#define get_csv2_float_pos74(X,Y) get_csv2_float((X),(Y),74) +#define get_csv2_uint_pos75(X,Y) get_csv2_uint((X),(Y),75) +#define get_csv2_ullong_pos75(X,Y) get_csv2_ullong((X),(Y),75) +#define get_csv2_ip_pos75(X,Y) get_csv2_ip((X),(Y),75) +#define get_csv2_ipv6_pos75(X,Y) get_csv2_ipv6((X),(Y),75) +#define get_csv2_string_pos75(X,Y) get_csv2_string((X),(Y),75) +#define get_csv2_v_str_pos75(X,Y) get_csv2_string((X),(Y),75) +#define get_csv2_bool_pos75(X,Y) get_csv2_bool((X),(Y),75) +#define get_csv2_int_pos75(X,Y) get_csv2_int((X),(Y),75) +#define get_csv2_llong_pos75(X,Y) get_csv2_llong((X),(Y),75) +#define get_csv2_float_pos75(X,Y) get_csv2_float((X),(Y),75) +#define get_csv2_uint_pos76(X,Y) get_csv2_uint((X),(Y),76) +#define get_csv2_ullong_pos76(X,Y) get_csv2_ullong((X),(Y),76) +#define get_csv2_ip_pos76(X,Y) get_csv2_ip((X),(Y),76) +#define get_csv2_ipv6_pos76(X,Y) get_csv2_ipv6((X),(Y),76) +#define get_csv2_string_pos76(X,Y) get_csv2_string((X),(Y),76) +#define get_csv2_v_str_pos76(X,Y) get_csv2_string((X),(Y),76) +#define get_csv2_bool_pos76(X,Y) get_csv2_bool((X),(Y),76) +#define get_csv2_int_pos76(X,Y) get_csv2_int((X),(Y),76) +#define get_csv2_llong_pos76(X,Y) get_csv2_llong((X),(Y),76) +#define get_csv2_float_pos76(X,Y) get_csv2_float((X),(Y),76) +#define get_csv2_uint_pos77(X,Y) get_csv2_uint((X),(Y),77) +#define get_csv2_ullong_pos77(X,Y) get_csv2_ullong((X),(Y),77) +#define get_csv2_ip_pos77(X,Y) get_csv2_ip((X),(Y),77) +#define get_csv2_ipv6_pos77(X,Y) get_csv2_ipv6((X),(Y),77) +#define get_csv2_string_pos77(X,Y) get_csv2_string((X),(Y),77) +#define get_csv2_v_str_pos77(X,Y) get_csv2_string((X),(Y),77) +#define get_csv2_bool_pos77(X,Y) get_csv2_bool((X),(Y),77) +#define get_csv2_int_pos77(X,Y) get_csv2_int((X),(Y),77) +#define get_csv2_llong_pos77(X,Y) get_csv2_llong((X),(Y),77) +#define get_csv2_float_pos77(X,Y) get_csv2_float((X),(Y),77) +#define get_csv2_uint_pos78(X,Y) get_csv2_uint((X),(Y),78) +#define get_csv2_ullong_pos78(X,Y) get_csv2_ullong((X),(Y),78) +#define get_csv2_ip_pos78(X,Y) get_csv2_ip((X),(Y),78) +#define get_csv2_ipv6_pos78(X,Y) get_csv2_ipv6((X),(Y),78) +#define get_csv2_string_pos78(X,Y) get_csv2_string((X),(Y),78) +#define get_csv2_v_str_pos78(X,Y) get_csv2_string((X),(Y),78) +#define get_csv2_bool_pos78(X,Y) get_csv2_bool((X),(Y),78) +#define get_csv2_int_pos78(X,Y) get_csv2_int((X),(Y),78) +#define get_csv2_llong_pos78(X,Y) get_csv2_llong((X),(Y),78) +#define get_csv2_float_pos78(X,Y) get_csv2_float((X),(Y),78) +#define get_csv2_uint_pos79(X,Y) get_csv2_uint((X),(Y),79) +#define get_csv2_ullong_pos79(X,Y) get_csv2_ullong((X),(Y),79) +#define get_csv2_ip_pos79(X,Y) get_csv2_ip((X),(Y),79) +#define get_csv2_ipv6_pos79(X,Y) get_csv2_ipv6((X),(Y),79) +#define get_csv2_string_pos79(X,Y) get_csv2_string((X),(Y),79) +#define get_csv2_v_str_pos79(X,Y) get_csv2_string((X),(Y),79) +#define get_csv2_bool_pos79(X,Y) get_csv2_bool((X),(Y),79) +#define get_csv2_int_pos79(X,Y) get_csv2_int((X),(Y),79) +#define get_csv2_llong_pos79(X,Y) get_csv2_llong((X),(Y),79) +#define get_csv2_float_pos79(X,Y) get_csv2_float((X),(Y),79) +#define get_csv2_uint_pos80(X,Y) get_csv2_uint((X),(Y),80) +#define get_csv2_ullong_pos80(X,Y) get_csv2_ullong((X),(Y),80) +#define get_csv2_ip_pos80(X,Y) get_csv2_ip((X),(Y),80) +#define get_csv2_ipv6_pos80(X,Y) get_csv2_ipv6((X),(Y),80) +#define get_csv2_string_pos80(X,Y) get_csv2_string((X),(Y),80) +#define get_csv2_v_str_pos80(X,Y) get_csv2_string((X),(Y),80) +#define get_csv2_bool_pos80(X,Y) get_csv2_bool((X),(Y),80) +#define get_csv2_int_pos80(X,Y) get_csv2_int((X),(Y),80) +#define get_csv2_llong_pos80(X,Y) get_csv2_llong((X),(Y),80) +#define get_csv2_float_pos80(X,Y) get_csv2_float((X),(Y),80) +#define get_csv2_uint_pos81(X,Y) get_csv2_uint((X),(Y),81) +#define get_csv2_ullong_pos81(X,Y) get_csv2_ullong((X),(Y),81) +#define get_csv2_ip_pos81(X,Y) get_csv2_ip((X),(Y),81) +#define get_csv2_ipv6_pos81(X,Y) get_csv2_ipv6((X),(Y),81) +#define get_csv2_string_pos81(X,Y) get_csv2_string((X),(Y),81) +#define get_csv2_v_str_pos81(X,Y) get_csv2_string((X),(Y),81) +#define get_csv2_bool_pos81(X,Y) get_csv2_bool((X),(Y),81) +#define get_csv2_int_pos81(X,Y) get_csv2_int((X),(Y),81) +#define get_csv2_llong_pos81(X,Y) get_csv2_llong((X),(Y),81) +#define get_csv2_float_pos81(X,Y) get_csv2_float((X),(Y),81) +#define get_csv2_uint_pos82(X,Y) get_csv2_uint((X),(Y),82) +#define get_csv2_ullong_pos82(X,Y) get_csv2_ullong((X),(Y),82) +#define get_csv2_ip_pos82(X,Y) get_csv2_ip((X),(Y),82) +#define get_csv2_ipv6_pos82(X,Y) get_csv2_ipv6((X),(Y),82) +#define get_csv2_string_pos82(X,Y) get_csv2_string((X),(Y),82) +#define get_csv2_v_str_pos82(X,Y) get_csv2_string((X),(Y),82) +#define get_csv2_bool_pos82(X,Y) get_csv2_bool((X),(Y),82) +#define get_csv2_int_pos82(X,Y) get_csv2_int((X),(Y),82) +#define get_csv2_llong_pos82(X,Y) get_csv2_llong((X),(Y),82) +#define get_csv2_float_pos82(X,Y) get_csv2_float((X),(Y),82) +#define get_csv2_uint_pos83(X,Y) get_csv2_uint((X),(Y),83) +#define get_csv2_ullong_pos83(X,Y) get_csv2_ullong((X),(Y),83) +#define get_csv2_ip_pos83(X,Y) get_csv2_ip((X),(Y),83) +#define get_csv2_ipv6_pos83(X,Y) get_csv2_ipv6((X),(Y),83) +#define get_csv2_string_pos83(X,Y) get_csv2_string((X),(Y),83) +#define get_csv2_v_str_pos83(X,Y) get_csv2_string((X),(Y),83) +#define get_csv2_bool_pos83(X,Y) get_csv2_bool((X),(Y),83) +#define get_csv2_int_pos83(X,Y) get_csv2_int((X),(Y),83) +#define get_csv2_llong_pos83(X,Y) get_csv2_llong((X),(Y),83) +#define get_csv2_float_pos83(X,Y) get_csv2_float((X),(Y),83) +#define get_csv2_uint_pos84(X,Y) get_csv2_uint((X),(Y),84) +#define get_csv2_ullong_pos84(X,Y) get_csv2_ullong((X),(Y),84) +#define get_csv2_ip_pos84(X,Y) get_csv2_ip((X),(Y),84) +#define get_csv2_ipv6_pos84(X,Y) get_csv2_ipv6((X),(Y),84) +#define get_csv2_string_pos84(X,Y) get_csv2_string((X),(Y),84) +#define get_csv2_v_str_pos84(X,Y) get_csv2_string((X),(Y),84) +#define get_csv2_bool_pos84(X,Y) get_csv2_bool((X),(Y),84) +#define get_csv2_int_pos84(X,Y) get_csv2_int((X),(Y),84) +#define get_csv2_llong_pos84(X,Y) get_csv2_llong((X),(Y),84) +#define get_csv2_float_pos84(X,Y) get_csv2_float((X),(Y),84) +#define get_csv2_uint_pos85(X,Y) get_csv2_uint((X),(Y),85) +#define get_csv2_ullong_pos85(X,Y) get_csv2_ullong((X),(Y),85) +#define get_csv2_ip_pos85(X,Y) get_csv2_ip((X),(Y),85) +#define get_csv2_ipv6_pos85(X,Y) get_csv2_ipv6((X),(Y),85) +#define get_csv2_string_pos85(X,Y) get_csv2_string((X),(Y),85) +#define get_csv2_v_str_pos85(X,Y) get_csv2_string((X),(Y),85) +#define get_csv2_bool_pos85(X,Y) get_csv2_bool((X),(Y),85) +#define get_csv2_int_pos85(X,Y) get_csv2_int((X),(Y),85) +#define get_csv2_llong_pos85(X,Y) get_csv2_llong((X),(Y),85) +#define get_csv2_float_pos85(X,Y) get_csv2_float((X),(Y),85) +#define get_csv2_uint_pos86(X,Y) get_csv2_uint((X),(Y),86) +#define get_csv2_ullong_pos86(X,Y) get_csv2_ullong((X),(Y),86) +#define get_csv2_ip_pos86(X,Y) get_csv2_ip((X),(Y),86) +#define get_csv2_ipv6_pos86(X,Y) get_csv2_ipv6((X),(Y),86) +#define get_csv2_string_pos86(X,Y) get_csv2_string((X),(Y),86) +#define get_csv2_v_str_pos86(X,Y) get_csv2_string((X),(Y),86) +#define get_csv2_bool_pos86(X,Y) get_csv2_bool((X),(Y),86) +#define get_csv2_int_pos86(X,Y) get_csv2_int((X),(Y),86) +#define get_csv2_llong_pos86(X,Y) get_csv2_llong((X),(Y),86) +#define get_csv2_float_pos86(X,Y) get_csv2_float((X),(Y),86) +#define get_csv2_uint_pos87(X,Y) get_csv2_uint((X),(Y),87) +#define get_csv2_ullong_pos87(X,Y) get_csv2_ullong((X),(Y),87) +#define get_csv2_ip_pos87(X,Y) get_csv2_ip((X),(Y),87) +#define get_csv2_ipv6_pos87(X,Y) get_csv2_ipv6((X),(Y),87) +#define get_csv2_string_pos87(X,Y) get_csv2_string((X),(Y),87) +#define get_csv2_v_str_pos87(X,Y) get_csv2_string((X),(Y),87) +#define get_csv2_bool_pos87(X,Y) get_csv2_bool((X),(Y),87) +#define get_csv2_int_pos87(X,Y) get_csv2_int((X),(Y),87) +#define get_csv2_llong_pos87(X,Y) get_csv2_llong((X),(Y),87) +#define get_csv2_float_pos87(X,Y) get_csv2_float((X),(Y),87) +#define get_csv2_uint_pos88(X,Y) get_csv2_uint((X),(Y),88) +#define get_csv2_ullong_pos88(X,Y) get_csv2_ullong((X),(Y),88) +#define get_csv2_ip_pos88(X,Y) get_csv2_ip((X),(Y),88) +#define get_csv2_ipv6_pos88(X,Y) get_csv2_ipv6((X),(Y),88) +#define get_csv2_string_pos88(X,Y) get_csv2_string((X),(Y),88) +#define get_csv2_v_str_pos88(X,Y) get_csv2_string((X),(Y),88) +#define get_csv2_bool_pos88(X,Y) get_csv2_bool((X),(Y),88) +#define get_csv2_int_pos88(X,Y) get_csv2_int((X),(Y),88) +#define get_csv2_llong_pos88(X,Y) get_csv2_llong((X),(Y),88) +#define get_csv2_float_pos88(X,Y) get_csv2_float((X),(Y),88) +#define get_csv2_uint_pos89(X,Y) get_csv2_uint((X),(Y),89) +#define get_csv2_ullong_pos89(X,Y) get_csv2_ullong((X),(Y),89) +#define get_csv2_ip_pos89(X,Y) get_csv2_ip((X),(Y),89) +#define get_csv2_ipv6_pos89(X,Y) get_csv2_ipv6((X),(Y),89) +#define get_csv2_string_pos89(X,Y) get_csv2_string((X),(Y),89) +#define get_csv2_v_str_pos89(X,Y) get_csv2_string((X),(Y),89) +#define get_csv2_bool_pos89(X,Y) get_csv2_bool((X),(Y),89) +#define get_csv2_int_pos89(X,Y) get_csv2_int((X),(Y),89) +#define get_csv2_llong_pos89(X,Y) get_csv2_llong((X),(Y),89) +#define get_csv2_float_pos89(X,Y) get_csv2_float((X),(Y),89) +#define get_csv2_uint_pos90(X,Y) get_csv2_uint((X),(Y),90) +#define get_csv2_ullong_pos90(X,Y) get_csv2_ullong((X),(Y),90) +#define get_csv2_ip_pos90(X,Y) get_csv2_ip((X),(Y),90) +#define get_csv2_ipv6_pos90(X,Y) get_csv2_ipv6((X),(Y),90) +#define get_csv2_string_pos90(X,Y) get_csv2_string((X),(Y),90) +#define get_csv2_v_str_pos90(X,Y) get_csv2_string((X),(Y),90) +#define get_csv2_bool_pos90(X,Y) get_csv2_bool((X),(Y),90) +#define get_csv2_int_pos90(X,Y) get_csv2_int((X),(Y),90) +#define get_csv2_llong_pos90(X,Y) get_csv2_llong((X),(Y),90) +#define get_csv2_float_pos90(X,Y) get_csv2_float((X),(Y),90) +#define get_csv2_uint_pos91(X,Y) get_csv2_uint((X),(Y),91) +#define get_csv2_ullong_pos91(X,Y) get_csv2_ullong((X),(Y),91) +#define get_csv2_ip_pos91(X,Y) get_csv2_ip((X),(Y),91) +#define get_csv2_ipv6_pos91(X,Y) get_csv2_ipv6((X),(Y),91) +#define get_csv2_string_pos91(X,Y) get_csv2_string((X),(Y),91) +#define get_csv2_v_str_pos91(X,Y) get_csv2_string((X),(Y),91) +#define get_csv2_bool_pos91(X,Y) get_csv2_bool((X),(Y),91) +#define get_csv2_int_pos91(X,Y) get_csv2_int((X),(Y),91) +#define get_csv2_llong_pos91(X,Y) get_csv2_llong((X),(Y),91) +#define get_csv2_float_pos91(X,Y) get_csv2_float((X),(Y),91) +#define get_csv2_uint_pos92(X,Y) get_csv2_uint((X),(Y),92) +#define get_csv2_ullong_pos92(X,Y) get_csv2_ullong((X),(Y),92) +#define get_csv2_ip_pos92(X,Y) get_csv2_ip((X),(Y),92) +#define get_csv2_ipv6_pos92(X,Y) get_csv2_ipv6((X),(Y),92) +#define get_csv2_string_pos92(X,Y) get_csv2_string((X),(Y),92) +#define get_csv2_v_str_pos92(X,Y) get_csv2_string((X),(Y),92) +#define get_csv2_bool_pos92(X,Y) get_csv2_bool((X),(Y),92) +#define get_csv2_int_pos92(X,Y) get_csv2_int((X),(Y),92) +#define get_csv2_llong_pos92(X,Y) get_csv2_llong((X),(Y),92) +#define get_csv2_float_pos92(X,Y) get_csv2_float((X),(Y),92) +#define get_csv2_uint_pos93(X,Y) get_csv2_uint((X),(Y),93) +#define get_csv2_ullong_pos93(X,Y) get_csv2_ullong((X),(Y),93) +#define get_csv2_ip_pos93(X,Y) get_csv2_ip((X),(Y),93) +#define get_csv2_ipv6_pos93(X,Y) get_csv2_ipv6((X),(Y),93) +#define get_csv2_string_pos93(X,Y) get_csv2_string((X),(Y),93) +#define get_csv2_v_str_pos93(X,Y) get_csv2_string((X),(Y),93) +#define get_csv2_bool_pos93(X,Y) get_csv2_bool((X),(Y),93) +#define get_csv2_int_pos93(X,Y) get_csv2_int((X),(Y),93) +#define get_csv2_llong_pos93(X,Y) get_csv2_llong((X),(Y),93) +#define get_csv2_float_pos93(X,Y) get_csv2_float((X),(Y),93) +#define get_csv2_uint_pos94(X,Y) get_csv2_uint((X),(Y),94) +#define get_csv2_ullong_pos94(X,Y) get_csv2_ullong((X),(Y),94) +#define get_csv2_ip_pos94(X,Y) get_csv2_ip((X),(Y),94) +#define get_csv2_ipv6_pos94(X,Y) get_csv2_ipv6((X),(Y),94) +#define get_csv2_string_pos94(X,Y) get_csv2_string((X),(Y),94) +#define get_csv2_v_str_pos94(X,Y) get_csv2_string((X),(Y),94) +#define get_csv2_bool_pos94(X,Y) get_csv2_bool((X),(Y),94) +#define get_csv2_int_pos94(X,Y) get_csv2_int((X),(Y),94) +#define get_csv2_llong_pos94(X,Y) get_csv2_llong((X),(Y),94) +#define get_csv2_float_pos94(X,Y) get_csv2_float((X),(Y),94) +#define get_csv2_uint_pos95(X,Y) get_csv2_uint((X),(Y),95) +#define get_csv2_ullong_pos95(X,Y) get_csv2_ullong((X),(Y),95) +#define get_csv2_ip_pos95(X,Y) get_csv2_ip((X),(Y),95) +#define get_csv2_ipv6_pos95(X,Y) get_csv2_ipv6((X),(Y),95) +#define get_csv2_string_pos95(X,Y) get_csv2_string((X),(Y),95) +#define get_csv2_v_str_pos95(X,Y) get_csv2_string((X),(Y),95) +#define get_csv2_bool_pos95(X,Y) get_csv2_bool((X),(Y),95) +#define get_csv2_int_pos95(X,Y) get_csv2_int((X),(Y),95) +#define get_csv2_llong_pos95(X,Y) get_csv2_llong((X),(Y),95) +#define get_csv2_float_pos95(X,Y) get_csv2_float((X),(Y),95) +#define get_csv2_uint_pos96(X,Y) get_csv2_uint((X),(Y),96) +#define get_csv2_ullong_pos96(X,Y) get_csv2_ullong((X),(Y),96) +#define get_csv2_ip_pos96(X,Y) get_csv2_ip((X),(Y),96) +#define get_csv2_ipv6_pos96(X,Y) get_csv2_ipv6((X),(Y),96) +#define get_csv2_string_pos96(X,Y) get_csv2_string((X),(Y),96) +#define get_csv2_v_str_pos96(X,Y) get_csv2_string((X),(Y),96) +#define get_csv2_bool_pos96(X,Y) get_csv2_bool((X),(Y),96) +#define get_csv2_int_pos96(X,Y) get_csv2_int((X),(Y),96) +#define get_csv2_llong_pos96(X,Y) get_csv2_llong((X),(Y),96) +#define get_csv2_float_pos96(X,Y) get_csv2_float((X),(Y),96) +#define get_csv2_uint_pos97(X,Y) get_csv2_uint((X),(Y),97) +#define get_csv2_ullong_pos97(X,Y) get_csv2_ullong((X),(Y),97) +#define get_csv2_ip_pos97(X,Y) get_csv2_ip((X),(Y),97) +#define get_csv2_ipv6_pos97(X,Y) get_csv2_ipv6((X),(Y),97) +#define get_csv2_string_pos97(X,Y) get_csv2_string((X),(Y),97) +#define get_csv2_v_str_pos97(X,Y) get_csv2_string((X),(Y),97) +#define get_csv2_bool_pos97(X,Y) get_csv2_bool((X),(Y),97) +#define get_csv2_int_pos97(X,Y) get_csv2_int((X),(Y),97) +#define get_csv2_llong_pos97(X,Y) get_csv2_llong((X),(Y),97) +#define get_csv2_float_pos97(X,Y) get_csv2_float((X),(Y),97) +#define get_csv2_uint_pos98(X,Y) get_csv2_uint((X),(Y),98) +#define get_csv2_ullong_pos98(X,Y) get_csv2_ullong((X),(Y),98) +#define get_csv2_ip_pos98(X,Y) get_csv2_ip((X),(Y),98) +#define get_csv2_ipv6_pos98(X,Y) get_csv2_ipv6((X),(Y),98) +#define get_csv2_string_pos98(X,Y) get_csv2_string((X),(Y),98) +#define get_csv2_v_str_pos98(X,Y) get_csv2_string((X),(Y),98) +#define get_csv2_bool_pos98(X,Y) get_csv2_bool((X),(Y),98) +#define get_csv2_int_pos98(X,Y) get_csv2_int((X),(Y),98) +#define get_csv2_llong_pos98(X,Y) get_csv2_llong((X),(Y),98) +#define get_csv2_float_pos98(X,Y) get_csv2_float((X),(Y),98) +#define get_csv2_uint_pos99(X,Y) get_csv2_uint((X),(Y),99) +#define get_csv2_ullong_pos99(X,Y) get_csv2_ullong((X),(Y),99) +#define get_csv2_ip_pos99(X,Y) get_csv2_ip((X),(Y),99) +#define get_csv2_ipv6_pos99(X,Y) get_csv2_ipv6((X),(Y),99) +#define get_csv2_string_pos99(X,Y) get_csv2_string((X),(Y),99) +#define get_csv2_v_str_pos99(X,Y) get_csv2_string((X),(Y),99) +#define get_csv2_bool_pos99(X,Y) get_csv2_bool((X),(Y),99) +#define get_csv2_int_pos99(X,Y) get_csv2_int((X),(Y),99) +#define get_csv2_llong_pos99(X,Y) get_csv2_llong((X),(Y),99) +#define get_csv2_float_pos99(X,Y) get_csv2_float((X),(Y),99) +#define get_csv2_uint_pos100(X,Y) get_csv2_uint((X),(Y),100) +#define get_csv2_ullong_pos100(X,Y) get_csv2_ullong((X),(Y),100) +#define get_csv2_ip_pos100(X,Y) get_csv2_ip((X),(Y),100) +#define get_csv2_ipv6_pos100(X,Y) get_csv2_ipv6((X),(Y),100) +#define get_csv2_string_pos100(X,Y) get_csv2_string((X),(Y),100) +#define get_csv2_v_str_pos100(X,Y) get_csv2_string((X),(Y),100) +#define get_csv2_bool_pos100(X,Y) get_csv2_bool((X),(Y),100) +#define get_csv2_int_pos100(X,Y) get_csv2_int((X),(Y),100) +#define get_csv2_llong_pos100(X,Y) get_csv2_llong((X),(Y),100) +#define get_csv2_float_pos100(X,Y) get_csv2_float((X),(Y),100) +#define get_csv2_uint_pos101(X,Y) get_csv2_uint((X),(Y),101) +#define get_csv2_ullong_pos101(X,Y) get_csv2_ullong((X),(Y),101) +#define get_csv2_ip_pos101(X,Y) get_csv2_ip((X),(Y),101) +#define get_csv2_ipv6_pos101(X,Y) get_csv2_ipv6((X),(Y),101) +#define get_csv2_string_pos101(X,Y) get_csv2_string((X),(Y),101) +#define get_csv2_v_str_pos101(X,Y) get_csv2_string((X),(Y),101) +#define get_csv2_bool_pos101(X,Y) get_csv2_bool((X),(Y),101) +#define get_csv2_int_pos101(X,Y) get_csv2_int((X),(Y),101) +#define get_csv2_llong_pos101(X,Y) get_csv2_llong((X),(Y),101) +#define get_csv2_float_pos101(X,Y) get_csv2_float((X),(Y),101) +#define get_csv2_uint_pos102(X,Y) get_csv2_uint((X),(Y),102) +#define get_csv2_ullong_pos102(X,Y) get_csv2_ullong((X),(Y),102) +#define get_csv2_ip_pos102(X,Y) get_csv2_ip((X),(Y),102) +#define get_csv2_ipv6_pos102(X,Y) get_csv2_ipv6((X),(Y),102) +#define get_csv2_string_pos102(X,Y) get_csv2_string((X),(Y),102) +#define get_csv2_v_str_pos102(X,Y) get_csv2_string((X),(Y),102) +#define get_csv2_bool_pos102(X,Y) get_csv2_bool((X),(Y),102) +#define get_csv2_int_pos102(X,Y) get_csv2_int((X),(Y),102) +#define get_csv2_llong_pos102(X,Y) get_csv2_llong((X),(Y),102) +#define get_csv2_float_pos102(X,Y) get_csv2_float((X),(Y),102) +#define get_csv2_uint_pos103(X,Y) get_csv2_uint((X),(Y),103) +#define get_csv2_ullong_pos103(X,Y) get_csv2_ullong((X),(Y),103) +#define get_csv2_ip_pos103(X,Y) get_csv2_ip((X),(Y),103) +#define get_csv2_ipv6_pos103(X,Y) get_csv2_ipv6((X),(Y),103) +#define get_csv2_string_pos103(X,Y) get_csv2_string((X),(Y),103) +#define get_csv2_v_str_pos103(X,Y) get_csv2_string((X),(Y),103) +#define get_csv2_bool_pos103(X,Y) get_csv2_bool((X),(Y),103) +#define get_csv2_int_pos103(X,Y) get_csv2_int((X),(Y),103) +#define get_csv2_llong_pos103(X,Y) get_csv2_llong((X),(Y),103) +#define get_csv2_float_pos103(X,Y) get_csv2_float((X),(Y),103) +#define get_csv2_uint_pos104(X,Y) get_csv2_uint((X),(Y),104) +#define get_csv2_ullong_pos104(X,Y) get_csv2_ullong((X),(Y),104) +#define get_csv2_ip_pos104(X,Y) get_csv2_ip((X),(Y),104) +#define get_csv2_ipv6_pos104(X,Y) get_csv2_ipv6((X),(Y),104) +#define get_csv2_string_pos104(X,Y) get_csv2_string((X),(Y),104) +#define get_csv2_v_str_pos104(X,Y) get_csv2_string((X),(Y),104) +#define get_csv2_bool_pos104(X,Y) get_csv2_bool((X),(Y),104) +#define get_csv2_int_pos104(X,Y) get_csv2_int((X),(Y),104) +#define get_csv2_llong_pos104(X,Y) get_csv2_llong((X),(Y),104) +#define get_csv2_float_pos104(X,Y) get_csv2_float((X),(Y),104) +#define get_csv2_uint_pos105(X,Y) get_csv2_uint((X),(Y),105) +#define get_csv2_ullong_pos105(X,Y) get_csv2_ullong((X),(Y),105) +#define get_csv2_ip_pos105(X,Y) get_csv2_ip((X),(Y),105) +#define get_csv2_ipv6_pos105(X,Y) get_csv2_ipv6((X),(Y),105) +#define get_csv2_string_pos105(X,Y) get_csv2_string((X),(Y),105) +#define get_csv2_v_str_pos105(X,Y) get_csv2_string((X),(Y),105) +#define get_csv2_bool_pos105(X,Y) get_csv2_bool((X),(Y),105) +#define get_csv2_int_pos105(X,Y) get_csv2_int((X),(Y),105) +#define get_csv2_llong_pos105(X,Y) get_csv2_llong((X),(Y),105) +#define get_csv2_float_pos105(X,Y) get_csv2_float((X),(Y),105) +#define get_csv2_uint_pos106(X,Y) get_csv2_uint((X),(Y),106) +#define get_csv2_ullong_pos106(X,Y) get_csv2_ullong((X),(Y),106) +#define get_csv2_ip_pos106(X,Y) get_csv2_ip((X),(Y),106) +#define get_csv2_ipv6_pos106(X,Y) get_csv2_ipv6((X),(Y),106) +#define get_csv2_string_pos106(X,Y) get_csv2_string((X),(Y),106) +#define get_csv2_v_str_pos106(X,Y) get_csv2_string((X),(Y),106) +#define get_csv2_bool_pos106(X,Y) get_csv2_bool((X),(Y),106) +#define get_csv2_int_pos106(X,Y) get_csv2_int((X),(Y),106) +#define get_csv2_llong_pos106(X,Y) get_csv2_llong((X),(Y),106) +#define get_csv2_float_pos106(X,Y) get_csv2_float((X),(Y),106) +#define get_csv2_uint_pos107(X,Y) get_csv2_uint((X),(Y),107) +#define get_csv2_ullong_pos107(X,Y) get_csv2_ullong((X),(Y),107) +#define get_csv2_ip_pos107(X,Y) get_csv2_ip((X),(Y),107) +#define get_csv2_ipv6_pos107(X,Y) get_csv2_ipv6((X),(Y),107) +#define get_csv2_string_pos107(X,Y) get_csv2_string((X),(Y),107) +#define get_csv2_v_str_pos107(X,Y) get_csv2_string((X),(Y),107) +#define get_csv2_bool_pos107(X,Y) get_csv2_bool((X),(Y),107) +#define get_csv2_int_pos107(X,Y) get_csv2_int((X),(Y),107) +#define get_csv2_llong_pos107(X,Y) get_csv2_llong((X),(Y),107) +#define get_csv2_float_pos107(X,Y) get_csv2_float((X),(Y),107) +#define get_csv2_uint_pos108(X,Y) get_csv2_uint((X),(Y),108) +#define get_csv2_ullong_pos108(X,Y) get_csv2_ullong((X),(Y),108) +#define get_csv2_ip_pos108(X,Y) get_csv2_ip((X),(Y),108) +#define get_csv2_ipv6_pos108(X,Y) get_csv2_ipv6((X),(Y),108) +#define get_csv2_string_pos108(X,Y) get_csv2_string((X),(Y),108) +#define get_csv2_v_str_pos108(X,Y) get_csv2_string((X),(Y),108) +#define get_csv2_bool_pos108(X,Y) get_csv2_bool((X),(Y),108) +#define get_csv2_int_pos108(X,Y) get_csv2_int((X),(Y),108) +#define get_csv2_llong_pos108(X,Y) get_csv2_llong((X),(Y),108) +#define get_csv2_float_pos108(X,Y) get_csv2_float((X),(Y),108) +#define get_csv2_uint_pos109(X,Y) get_csv2_uint((X),(Y),109) +#define get_csv2_ullong_pos109(X,Y) get_csv2_ullong((X),(Y),109) +#define get_csv2_ip_pos109(X,Y) get_csv2_ip((X),(Y),109) +#define get_csv2_ipv6_pos109(X,Y) get_csv2_ipv6((X),(Y),109) +#define get_csv2_string_pos109(X,Y) get_csv2_string((X),(Y),109) +#define get_csv2_v_str_pos109(X,Y) get_csv2_string((X),(Y),109) +#define get_csv2_bool_pos109(X,Y) get_csv2_bool((X),(Y),109) +#define get_csv2_int_pos109(X,Y) get_csv2_int((X),(Y),109) +#define get_csv2_llong_pos109(X,Y) get_csv2_llong((X),(Y),109) +#define get_csv2_float_pos109(X,Y) get_csv2_float((X),(Y),109) +#define get_csv2_uint_pos110(X,Y) get_csv2_uint((X),(Y),110) +#define get_csv2_ullong_pos110(X,Y) get_csv2_ullong((X),(Y),110) +#define get_csv2_ip_pos110(X,Y) get_csv2_ip((X),(Y),110) +#define get_csv2_ipv6_pos110(X,Y) get_csv2_ipv6((X),(Y),110) +#define get_csv2_string_pos110(X,Y) get_csv2_string((X),(Y),110) +#define get_csv2_v_str_pos110(X,Y) get_csv2_string((X),(Y),110) +#define get_csv2_bool_pos110(X,Y) get_csv2_bool((X),(Y),110) +#define get_csv2_int_pos110(X,Y) get_csv2_int((X),(Y),110) +#define get_csv2_llong_pos110(X,Y) get_csv2_llong((X),(Y),110) +#define get_csv2_float_pos110(X,Y) get_csv2_float((X),(Y),110) +#define get_csv2_uint_pos111(X,Y) get_csv2_uint((X),(Y),111) +#define get_csv2_ullong_pos111(X,Y) get_csv2_ullong((X),(Y),111) +#define get_csv2_ip_pos111(X,Y) get_csv2_ip((X),(Y),111) +#define get_csv2_ipv6_pos111(X,Y) get_csv2_ipv6((X),(Y),111) +#define get_csv2_string_pos111(X,Y) get_csv2_string((X),(Y),111) +#define get_csv2_v_str_pos111(X,Y) get_csv2_string((X),(Y),111) +#define get_csv2_bool_pos111(X,Y) get_csv2_bool((X),(Y),111) +#define get_csv2_int_pos111(X,Y) get_csv2_int((X),(Y),111) +#define get_csv2_llong_pos111(X,Y) get_csv2_llong((X),(Y),111) +#define get_csv2_float_pos111(X,Y) get_csv2_float((X),(Y),111) +#define get_csv2_uint_pos112(X,Y) get_csv2_uint((X),(Y),112) +#define get_csv2_ullong_pos112(X,Y) get_csv2_ullong((X),(Y),112) +#define get_csv2_ip_pos112(X,Y) get_csv2_ip((X),(Y),112) +#define get_csv2_ipv6_pos112(X,Y) get_csv2_ipv6((X),(Y),112) +#define get_csv2_string_pos112(X,Y) get_csv2_string((X),(Y),112) +#define get_csv2_v_str_pos112(X,Y) get_csv2_string((X),(Y),112) +#define get_csv2_bool_pos112(X,Y) get_csv2_bool((X),(Y),112) +#define get_csv2_int_pos112(X,Y) get_csv2_int((X),(Y),112) +#define get_csv2_llong_pos112(X,Y) get_csv2_llong((X),(Y),112) +#define get_csv2_float_pos112(X,Y) get_csv2_float((X),(Y),112) +#define get_csv2_uint_pos113(X,Y) get_csv2_uint((X),(Y),113) +#define get_csv2_ullong_pos113(X,Y) get_csv2_ullong((X),(Y),113) +#define get_csv2_ip_pos113(X,Y) get_csv2_ip((X),(Y),113) +#define get_csv2_ipv6_pos113(X,Y) get_csv2_ipv6((X),(Y),113) +#define get_csv2_string_pos113(X,Y) get_csv2_string((X),(Y),113) +#define get_csv2_v_str_pos113(X,Y) get_csv2_string((X),(Y),113) +#define get_csv2_bool_pos113(X,Y) get_csv2_bool((X),(Y),113) +#define get_csv2_int_pos113(X,Y) get_csv2_int((X),(Y),113) +#define get_csv2_llong_pos113(X,Y) get_csv2_llong((X),(Y),113) +#define get_csv2_float_pos113(X,Y) get_csv2_float((X),(Y),113) +#define get_csv2_uint_pos114(X,Y) get_csv2_uint((X),(Y),114) +#define get_csv2_ullong_pos114(X,Y) get_csv2_ullong((X),(Y),114) +#define get_csv2_ip_pos114(X,Y) get_csv2_ip((X),(Y),114) +#define get_csv2_ipv6_pos114(X,Y) get_csv2_ipv6((X),(Y),114) +#define get_csv2_string_pos114(X,Y) get_csv2_string((X),(Y),114) +#define get_csv2_v_str_pos114(X,Y) get_csv2_string((X),(Y),114) +#define get_csv2_bool_pos114(X,Y) get_csv2_bool((X),(Y),114) +#define get_csv2_int_pos114(X,Y) get_csv2_int((X),(Y),114) +#define get_csv2_llong_pos114(X,Y) get_csv2_llong((X),(Y),114) +#define get_csv2_float_pos114(X,Y) get_csv2_float((X),(Y),114) +#define get_csv2_uint_pos115(X,Y) get_csv2_uint((X),(Y),115) +#define get_csv2_ullong_pos115(X,Y) get_csv2_ullong((X),(Y),115) +#define get_csv2_ip_pos115(X,Y) get_csv2_ip((X),(Y),115) +#define get_csv2_ipv6_pos115(X,Y) get_csv2_ipv6((X),(Y),115) +#define get_csv2_string_pos115(X,Y) get_csv2_string((X),(Y),115) +#define get_csv2_v_str_pos115(X,Y) get_csv2_string((X),(Y),115) +#define get_csv2_bool_pos115(X,Y) get_csv2_bool((X),(Y),115) +#define get_csv2_int_pos115(X,Y) get_csv2_int((X),(Y),115) +#define get_csv2_llong_pos115(X,Y) get_csv2_llong((X),(Y),115) +#define get_csv2_float_pos115(X,Y) get_csv2_float((X),(Y),115) +#define get_csv2_uint_pos116(X,Y) get_csv2_uint((X),(Y),116) +#define get_csv2_ullong_pos116(X,Y) get_csv2_ullong((X),(Y),116) +#define get_csv2_ip_pos116(X,Y) get_csv2_ip((X),(Y),116) +#define get_csv2_ipv6_pos116(X,Y) get_csv2_ipv6((X),(Y),116) +#define get_csv2_string_pos116(X,Y) get_csv2_string((X),(Y),116) +#define get_csv2_v_str_pos116(X,Y) get_csv2_string((X),(Y),116) +#define get_csv2_bool_pos116(X,Y) get_csv2_bool((X),(Y),116) +#define get_csv2_int_pos116(X,Y) get_csv2_int((X),(Y),116) +#define get_csv2_llong_pos116(X,Y) get_csv2_llong((X),(Y),116) +#define get_csv2_float_pos116(X,Y) get_csv2_float((X),(Y),116) +#define get_csv2_uint_pos117(X,Y) get_csv2_uint((X),(Y),117) +#define get_csv2_ullong_pos117(X,Y) get_csv2_ullong((X),(Y),117) +#define get_csv2_ip_pos117(X,Y) get_csv2_ip((X),(Y),117) +#define get_csv2_ipv6_pos117(X,Y) get_csv2_ipv6((X),(Y),117) +#define get_csv2_string_pos117(X,Y) get_csv2_string((X),(Y),117) +#define get_csv2_v_str_pos117(X,Y) get_csv2_string((X),(Y),117) +#define get_csv2_bool_pos117(X,Y) get_csv2_bool((X),(Y),117) +#define get_csv2_int_pos117(X,Y) get_csv2_int((X),(Y),117) +#define get_csv2_llong_pos117(X,Y) get_csv2_llong((X),(Y),117) +#define get_csv2_float_pos117(X,Y) get_csv2_float((X),(Y),117) +#define get_csv2_uint_pos118(X,Y) get_csv2_uint((X),(Y),118) +#define get_csv2_ullong_pos118(X,Y) get_csv2_ullong((X),(Y),118) +#define get_csv2_ip_pos118(X,Y) get_csv2_ip((X),(Y),118) +#define get_csv2_ipv6_pos118(X,Y) get_csv2_ipv6((X),(Y),118) +#define get_csv2_string_pos118(X,Y) get_csv2_string((X),(Y),118) +#define get_csv2_v_str_pos118(X,Y) get_csv2_string((X),(Y),118) +#define get_csv2_bool_pos118(X,Y) get_csv2_bool((X),(Y),118) +#define get_csv2_int_pos118(X,Y) get_csv2_int((X),(Y),118) +#define get_csv2_llong_pos118(X,Y) get_csv2_llong((X),(Y),118) +#define get_csv2_float_pos118(X,Y) get_csv2_float((X),(Y),118) +#define get_csv2_uint_pos119(X,Y) get_csv2_uint((X),(Y),119) +#define get_csv2_ullong_pos119(X,Y) get_csv2_ullong((X),(Y),119) +#define get_csv2_ip_pos119(X,Y) get_csv2_ip((X),(Y),119) +#define get_csv2_ipv6_pos119(X,Y) get_csv2_ipv6((X),(Y),119) +#define get_csv2_string_pos119(X,Y) get_csv2_string((X),(Y),119) +#define get_csv2_v_str_pos119(X,Y) get_csv2_string((X),(Y),119) +#define get_csv2_bool_pos119(X,Y) get_csv2_bool((X),(Y),119) +#define get_csv2_int_pos119(X,Y) get_csv2_int((X),(Y),119) +#define get_csv2_llong_pos119(X,Y) get_csv2_llong((X),(Y),119) +#define get_csv2_float_pos119(X,Y) get_csv2_float((X),(Y),119) +#define get_csv2_uint_pos120(X,Y) get_csv2_uint((X),(Y),120) +#define get_csv2_ullong_pos120(X,Y) get_csv2_ullong((X),(Y),120) +#define get_csv2_ip_pos120(X,Y) get_csv2_ip((X),(Y),120) +#define get_csv2_ipv6_pos120(X,Y) get_csv2_ipv6((X),(Y),120) +#define get_csv2_string_pos120(X,Y) get_csv2_string((X),(Y),120) +#define get_csv2_v_str_pos120(X,Y) get_csv2_string((X),(Y),120) +#define get_csv2_bool_pos120(X,Y) get_csv2_bool((X),(Y),120) +#define get_csv2_int_pos120(X,Y) get_csv2_int((X),(Y),120) +#define get_csv2_llong_pos120(X,Y) get_csv2_llong((X),(Y),120) +#define get_csv2_float_pos120(X,Y) get_csv2_float((X),(Y),120) +#define get_csv2_uint_pos121(X,Y) get_csv2_uint((X),(Y),121) +#define get_csv2_ullong_pos121(X,Y) get_csv2_ullong((X),(Y),121) +#define get_csv2_ip_pos121(X,Y) get_csv2_ip((X),(Y),121) +#define get_csv2_ipv6_pos121(X,Y) get_csv2_ipv6((X),(Y),121) +#define get_csv2_string_pos121(X,Y) get_csv2_string((X),(Y),121) +#define get_csv2_v_str_pos121(X,Y) get_csv2_string((X),(Y),121) +#define get_csv2_bool_pos121(X,Y) get_csv2_bool((X),(Y),121) +#define get_csv2_int_pos121(X,Y) get_csv2_int((X),(Y),121) +#define get_csv2_llong_pos121(X,Y) get_csv2_llong((X),(Y),121) +#define get_csv2_float_pos121(X,Y) get_csv2_float((X),(Y),121) +#define get_csv2_uint_pos122(X,Y) get_csv2_uint((X),(Y),122) +#define get_csv2_ullong_pos122(X,Y) get_csv2_ullong((X),(Y),122) +#define get_csv2_ip_pos122(X,Y) get_csv2_ip((X),(Y),122) +#define get_csv2_ipv6_pos122(X,Y) get_csv2_ipv6((X),(Y),122) +#define get_csv2_string_pos122(X,Y) get_csv2_string((X),(Y),122) +#define get_csv2_v_str_pos122(X,Y) get_csv2_string((X),(Y),122) +#define get_csv2_bool_pos122(X,Y) get_csv2_bool((X),(Y),122) +#define get_csv2_int_pos122(X,Y) get_csv2_int((X),(Y),122) +#define get_csv2_llong_pos122(X,Y) get_csv2_llong((X),(Y),122) +#define get_csv2_float_pos122(X,Y) get_csv2_float((X),(Y),122) +#define get_csv2_uint_pos123(X,Y) get_csv2_uint((X),(Y),123) +#define get_csv2_ullong_pos123(X,Y) get_csv2_ullong((X),(Y),123) +#define get_csv2_ip_pos123(X,Y) get_csv2_ip((X),(Y),123) +#define get_csv2_ipv6_pos123(X,Y) get_csv2_ipv6((X),(Y),123) +#define get_csv2_string_pos123(X,Y) get_csv2_string((X),(Y),123) +#define get_csv2_v_str_pos123(X,Y) get_csv2_string((X),(Y),123) +#define get_csv2_bool_pos123(X,Y) get_csv2_bool((X),(Y),123) +#define get_csv2_int_pos123(X,Y) get_csv2_int((X),(Y),123) +#define get_csv2_llong_pos123(X,Y) get_csv2_llong((X),(Y),123) +#define get_csv2_float_pos123(X,Y) get_csv2_float((X),(Y),123) +#define get_csv2_uint_pos124(X,Y) get_csv2_uint((X),(Y),124) +#define get_csv2_ullong_pos124(X,Y) get_csv2_ullong((X),(Y),124) +#define get_csv2_ip_pos124(X,Y) get_csv2_ip((X),(Y),124) +#define get_csv2_ipv6_pos124(X,Y) get_csv2_ipv6((X),(Y),124) +#define get_csv2_string_pos124(X,Y) get_csv2_string((X),(Y),124) +#define get_csv2_v_str_pos124(X,Y) get_csv2_string((X),(Y),124) +#define get_csv2_bool_pos124(X,Y) get_csv2_bool((X),(Y),124) +#define get_csv2_int_pos124(X,Y) get_csv2_int((X),(Y),124) +#define get_csv2_llong_pos124(X,Y) get_csv2_llong((X),(Y),124) +#define get_csv2_float_pos124(X,Y) get_csv2_float((X),(Y),124) +#define get_csv2_uint_pos125(X,Y) get_csv2_uint((X),(Y),125) +#define get_csv2_ullong_pos125(X,Y) get_csv2_ullong((X),(Y),125) +#define get_csv2_ip_pos125(X,Y) get_csv2_ip((X),(Y),125) +#define get_csv2_ipv6_pos125(X,Y) get_csv2_ipv6((X),(Y),125) +#define get_csv2_string_pos125(X,Y) get_csv2_string((X),(Y),125) +#define get_csv2_v_str_pos125(X,Y) get_csv2_string((X),(Y),125) +#define get_csv2_bool_pos125(X,Y) get_csv2_bool((X),(Y),125) +#define get_csv2_int_pos125(X,Y) get_csv2_int((X),(Y),125) +#define get_csv2_llong_pos125(X,Y) get_csv2_llong((X),(Y),125) +#define get_csv2_float_pos125(X,Y) get_csv2_float((X),(Y),125) +#define get_csv2_uint_pos126(X,Y) get_csv2_uint((X),(Y),126) +#define get_csv2_ullong_pos126(X,Y) get_csv2_ullong((X),(Y),126) +#define get_csv2_ip_pos126(X,Y) get_csv2_ip((X),(Y),126) +#define get_csv2_ipv6_pos126(X,Y) get_csv2_ipv6((X),(Y),126) +#define get_csv2_string_pos126(X,Y) get_csv2_string((X),(Y),126) +#define get_csv2_v_str_pos126(X,Y) get_csv2_string((X),(Y),126) +#define get_csv2_bool_pos126(X,Y) get_csv2_bool((X),(Y),126) +#define get_csv2_int_pos126(X,Y) get_csv2_int((X),(Y),126) +#define get_csv2_llong_pos126(X,Y) get_csv2_llong((X),(Y),126) +#define get_csv2_float_pos126(X,Y) get_csv2_float((X),(Y),126) +#define get_csv2_uint_pos127(X,Y) get_csv2_uint((X),(Y),127) +#define get_csv2_ullong_pos127(X,Y) get_csv2_ullong((X),(Y),127) +#define get_csv2_ip_pos127(X,Y) get_csv2_ip((X),(Y),127) +#define get_csv2_ipv6_pos127(X,Y) get_csv2_ipv6((X),(Y),127) +#define get_csv2_string_pos127(X,Y) get_csv2_string((X),(Y),127) +#define get_csv2_v_str_pos127(X,Y) get_csv2_string((X),(Y),127) +#define get_csv2_bool_pos127(X,Y) get_csv2_bool((X),(Y),127) +#define get_csv2_int_pos127(X,Y) get_csv2_int((X),(Y),127) +#define get_csv2_llong_pos127(X,Y) get_csv2_llong((X),(Y),127) +#define get_csv2_float_pos127(X,Y) get_csv2_float((X),(Y),127) +#define get_csv2_uint_pos128(X,Y) get_csv2_uint((X),(Y),128) +#define get_csv2_ullong_pos128(X,Y) get_csv2_ullong((X),(Y),128) +#define get_csv2_ip_pos128(X,Y) get_csv2_ip((X),(Y),128) +#define get_csv2_ipv6_pos128(X,Y) get_csv2_ipv6((X),(Y),128) +#define get_csv2_string_pos128(X,Y) get_csv2_string((X),(Y),128) +#define get_csv2_v_str_pos128(X,Y) get_csv2_string((X),(Y),128) +#define get_csv2_bool_pos128(X,Y) get_csv2_bool((X),(Y),128) +#define get_csv2_int_pos128(X,Y) get_csv2_int((X),(Y),128) +#define get_csv2_llong_pos128(X,Y) get_csv2_llong((X),(Y),128) +#define get_csv2_float_pos128(X,Y) get_csv2_float((X),(Y),128) +#define get_csv2_uint_pos129(X,Y) get_csv2_uint((X),(Y),129) +#define get_csv2_ullong_pos129(X,Y) get_csv2_ullong((X),(Y),129) +#define get_csv2_ip_pos129(X,Y) get_csv2_ip((X),(Y),129) +#define get_csv2_ipv6_pos129(X,Y) get_csv2_ipv6((X),(Y),129) +#define get_csv2_string_pos129(X,Y) get_csv2_string((X),(Y),129) +#define get_csv2_v_str_pos129(X,Y) get_csv2_string((X),(Y),129) +#define get_csv2_bool_pos129(X,Y) get_csv2_bool((X),(Y),129) +#define get_csv2_int_pos129(X,Y) get_csv2_int((X),(Y),129) +#define get_csv2_llong_pos129(X,Y) get_csv2_llong((X),(Y),129) +#define get_csv2_float_pos129(X,Y) get_csv2_float((X),(Y),129) +#define get_csv2_uint_pos130(X,Y) get_csv2_uint((X),(Y),130) +#define get_csv2_ullong_pos130(X,Y) get_csv2_ullong((X),(Y),130) +#define get_csv2_ip_pos130(X,Y) get_csv2_ip((X),(Y),130) +#define get_csv2_ipv6_pos130(X,Y) get_csv2_ipv6((X),(Y),130) +#define get_csv2_string_pos130(X,Y) get_csv2_string((X),(Y),130) +#define get_csv2_v_str_pos130(X,Y) get_csv2_string((X),(Y),130) +#define get_csv2_bool_pos130(X,Y) get_csv2_bool((X),(Y),130) +#define get_csv2_int_pos130(X,Y) get_csv2_int((X),(Y),130) +#define get_csv2_llong_pos130(X,Y) get_csv2_llong((X),(Y),130) +#define get_csv2_float_pos130(X,Y) get_csv2_float((X),(Y),130) +#define get_csv2_uint_pos131(X,Y) get_csv2_uint((X),(Y),131) +#define get_csv2_ullong_pos131(X,Y) get_csv2_ullong((X),(Y),131) +#define get_csv2_ip_pos131(X,Y) get_csv2_ip((X),(Y),131) +#define get_csv2_ipv6_pos131(X,Y) get_csv2_ipv6((X),(Y),131) +#define get_csv2_string_pos131(X,Y) get_csv2_string((X),(Y),131) +#define get_csv2_v_str_pos131(X,Y) get_csv2_string((X),(Y),131) +#define get_csv2_bool_pos131(X,Y) get_csv2_bool((X),(Y),131) +#define get_csv2_int_pos131(X,Y) get_csv2_int((X),(Y),131) +#define get_csv2_llong_pos131(X,Y) get_csv2_llong((X),(Y),131) +#define get_csv2_float_pos131(X,Y) get_csv2_float((X),(Y),131) +#define get_csv2_uint_pos132(X,Y) get_csv2_uint((X),(Y),132) +#define get_csv2_ullong_pos132(X,Y) get_csv2_ullong((X),(Y),132) +#define get_csv2_ip_pos132(X,Y) get_csv2_ip((X),(Y),132) +#define get_csv2_ipv6_pos132(X,Y) get_csv2_ipv6((X),(Y),132) +#define get_csv2_string_pos132(X,Y) get_csv2_string((X),(Y),132) +#define get_csv2_v_str_pos132(X,Y) get_csv2_string((X),(Y),132) +#define get_csv2_bool_pos132(X,Y) get_csv2_bool((X),(Y),132) +#define get_csv2_int_pos132(X,Y) get_csv2_int((X),(Y),132) +#define get_csv2_llong_pos132(X,Y) get_csv2_llong((X),(Y),132) +#define get_csv2_float_pos132(X,Y) get_csv2_float((X),(Y),132) +#define get_csv2_uint_pos133(X,Y) get_csv2_uint((X),(Y),133) +#define get_csv2_ullong_pos133(X,Y) get_csv2_ullong((X),(Y),133) +#define get_csv2_ip_pos133(X,Y) get_csv2_ip((X),(Y),133) +#define get_csv2_ipv6_pos133(X,Y) get_csv2_ipv6((X),(Y),133) +#define get_csv2_string_pos133(X,Y) get_csv2_string((X),(Y),133) +#define get_csv2_v_str_pos133(X,Y) get_csv2_string((X),(Y),133) +#define get_csv2_bool_pos133(X,Y) get_csv2_bool((X),(Y),133) +#define get_csv2_int_pos133(X,Y) get_csv2_int((X),(Y),133) +#define get_csv2_llong_pos133(X,Y) get_csv2_llong((X),(Y),133) +#define get_csv2_float_pos133(X,Y) get_csv2_float((X),(Y),133) +#define get_csv2_uint_pos134(X,Y) get_csv2_uint((X),(Y),134) +#define get_csv2_ullong_pos134(X,Y) get_csv2_ullong((X),(Y),134) +#define get_csv2_ip_pos134(X,Y) get_csv2_ip((X),(Y),134) +#define get_csv2_ipv6_pos134(X,Y) get_csv2_ipv6((X),(Y),134) +#define get_csv2_string_pos134(X,Y) get_csv2_string((X),(Y),134) +#define get_csv2_v_str_pos134(X,Y) get_csv2_string((X),(Y),134) +#define get_csv2_bool_pos134(X,Y) get_csv2_bool((X),(Y),134) +#define get_csv2_int_pos134(X,Y) get_csv2_int((X),(Y),134) +#define get_csv2_llong_pos134(X,Y) get_csv2_llong((X),(Y),134) +#define get_csv2_float_pos134(X,Y) get_csv2_float((X),(Y),134) +#define get_csv2_uint_pos135(X,Y) get_csv2_uint((X),(Y),135) +#define get_csv2_ullong_pos135(X,Y) get_csv2_ullong((X),(Y),135) +#define get_csv2_ip_pos135(X,Y) get_csv2_ip((X),(Y),135) +#define get_csv2_ipv6_pos135(X,Y) get_csv2_ipv6((X),(Y),135) +#define get_csv2_string_pos135(X,Y) get_csv2_string((X),(Y),135) +#define get_csv2_v_str_pos135(X,Y) get_csv2_string((X),(Y),135) +#define get_csv2_bool_pos135(X,Y) get_csv2_bool((X),(Y),135) +#define get_csv2_int_pos135(X,Y) get_csv2_int((X),(Y),135) +#define get_csv2_llong_pos135(X,Y) get_csv2_llong((X),(Y),135) +#define get_csv2_float_pos135(X,Y) get_csv2_float((X),(Y),135) +#define get_csv2_uint_pos136(X,Y) get_csv2_uint((X),(Y),136) +#define get_csv2_ullong_pos136(X,Y) get_csv2_ullong((X),(Y),136) +#define get_csv2_ip_pos136(X,Y) get_csv2_ip((X),(Y),136) +#define get_csv2_ipv6_pos136(X,Y) get_csv2_ipv6((X),(Y),136) +#define get_csv2_string_pos136(X,Y) get_csv2_string((X),(Y),136) +#define get_csv2_v_str_pos136(X,Y) get_csv2_string((X),(Y),136) +#define get_csv2_bool_pos136(X,Y) get_csv2_bool((X),(Y),136) +#define get_csv2_int_pos136(X,Y) get_csv2_int((X),(Y),136) +#define get_csv2_llong_pos136(X,Y) get_csv2_llong((X),(Y),136) +#define get_csv2_float_pos136(X,Y) get_csv2_float((X),(Y),136) +#define get_csv2_uint_pos137(X,Y) get_csv2_uint((X),(Y),137) +#define get_csv2_ullong_pos137(X,Y) get_csv2_ullong((X),(Y),137) +#define get_csv2_ip_pos137(X,Y) get_csv2_ip((X),(Y),137) +#define get_csv2_ipv6_pos137(X,Y) get_csv2_ipv6((X),(Y),137) +#define get_csv2_string_pos137(X,Y) get_csv2_string((X),(Y),137) +#define get_csv2_v_str_pos137(X,Y) get_csv2_string((X),(Y),137) +#define get_csv2_bool_pos137(X,Y) get_csv2_bool((X),(Y),137) +#define get_csv2_int_pos137(X,Y) get_csv2_int((X),(Y),137) +#define get_csv2_llong_pos137(X,Y) get_csv2_llong((X),(Y),137) +#define get_csv2_float_pos137(X,Y) get_csv2_float((X),(Y),137) +#define get_csv2_uint_pos138(X,Y) get_csv2_uint((X),(Y),138) +#define get_csv2_ullong_pos138(X,Y) get_csv2_ullong((X),(Y),138) +#define get_csv2_ip_pos138(X,Y) get_csv2_ip((X),(Y),138) +#define get_csv2_ipv6_pos138(X,Y) get_csv2_ipv6((X),(Y),138) +#define get_csv2_string_pos138(X,Y) get_csv2_string((X),(Y),138) +#define get_csv2_v_str_pos138(X,Y) get_csv2_string((X),(Y),138) +#define get_csv2_bool_pos138(X,Y) get_csv2_bool((X),(Y),138) +#define get_csv2_int_pos138(X,Y) get_csv2_int((X),(Y),138) +#define get_csv2_llong_pos138(X,Y) get_csv2_llong((X),(Y),138) +#define get_csv2_float_pos138(X,Y) get_csv2_float((X),(Y),138) +#define get_csv2_uint_pos139(X,Y) get_csv2_uint((X),(Y),139) +#define get_csv2_ullong_pos139(X,Y) get_csv2_ullong((X),(Y),139) +#define get_csv2_ip_pos139(X,Y) get_csv2_ip((X),(Y),139) +#define get_csv2_ipv6_pos139(X,Y) get_csv2_ipv6((X),(Y),139) +#define get_csv2_string_pos139(X,Y) get_csv2_string((X),(Y),139) +#define get_csv2_v_str_pos139(X,Y) get_csv2_string((X),(Y),139) +#define get_csv2_bool_pos139(X,Y) get_csv2_bool((X),(Y),139) +#define get_csv2_int_pos139(X,Y) get_csv2_int((X),(Y),139) +#define get_csv2_llong_pos139(X,Y) get_csv2_llong((X),(Y),139) +#define get_csv2_float_pos139(X,Y) get_csv2_float((X),(Y),139) +#define get_csv2_uint_pos140(X,Y) get_csv2_uint((X),(Y),140) +#define get_csv2_ullong_pos140(X,Y) get_csv2_ullong((X),(Y),140) +#define get_csv2_ip_pos140(X,Y) get_csv2_ip((X),(Y),140) +#define get_csv2_ipv6_pos140(X,Y) get_csv2_ipv6((X),(Y),140) +#define get_csv2_string_pos140(X,Y) get_csv2_string((X),(Y),140) +#define get_csv2_v_str_pos140(X,Y) get_csv2_string((X),(Y),140) +#define get_csv2_bool_pos140(X,Y) get_csv2_bool((X),(Y),140) +#define get_csv2_int_pos140(X,Y) get_csv2_int((X),(Y),140) +#define get_csv2_llong_pos140(X,Y) get_csv2_llong((X),(Y),140) +#define get_csv2_float_pos140(X,Y) get_csv2_float((X),(Y),140) +#define get_csv2_uint_pos141(X,Y) get_csv2_uint((X),(Y),141) +#define get_csv2_ullong_pos141(X,Y) get_csv2_ullong((X),(Y),141) +#define get_csv2_ip_pos141(X,Y) get_csv2_ip((X),(Y),141) +#define get_csv2_ipv6_pos141(X,Y) get_csv2_ipv6((X),(Y),141) +#define get_csv2_string_pos141(X,Y) get_csv2_string((X),(Y),141) +#define get_csv2_v_str_pos141(X,Y) get_csv2_string((X),(Y),141) +#define get_csv2_bool_pos141(X,Y) get_csv2_bool((X),(Y),141) +#define get_csv2_int_pos141(X,Y) get_csv2_int((X),(Y),141) +#define get_csv2_llong_pos141(X,Y) get_csv2_llong((X),(Y),141) +#define get_csv2_float_pos141(X,Y) get_csv2_float((X),(Y),141) +#define get_csv2_uint_pos142(X,Y) get_csv2_uint((X),(Y),142) +#define get_csv2_ullong_pos142(X,Y) get_csv2_ullong((X),(Y),142) +#define get_csv2_ip_pos142(X,Y) get_csv2_ip((X),(Y),142) +#define get_csv2_ipv6_pos142(X,Y) get_csv2_ipv6((X),(Y),142) +#define get_csv2_string_pos142(X,Y) get_csv2_string((X),(Y),142) +#define get_csv2_v_str_pos142(X,Y) get_csv2_string((X),(Y),142) +#define get_csv2_bool_pos142(X,Y) get_csv2_bool((X),(Y),142) +#define get_csv2_int_pos142(X,Y) get_csv2_int((X),(Y),142) +#define get_csv2_llong_pos142(X,Y) get_csv2_llong((X),(Y),142) +#define get_csv2_float_pos142(X,Y) get_csv2_float((X),(Y),142) +#define get_csv2_uint_pos143(X,Y) get_csv2_uint((X),(Y),143) +#define get_csv2_ullong_pos143(X,Y) get_csv2_ullong((X),(Y),143) +#define get_csv2_ip_pos143(X,Y) get_csv2_ip((X),(Y),143) +#define get_csv2_ipv6_pos143(X,Y) get_csv2_ipv6((X),(Y),143) +#define get_csv2_string_pos143(X,Y) get_csv2_string((X),(Y),143) +#define get_csv2_v_str_pos143(X,Y) get_csv2_string((X),(Y),143) +#define get_csv2_bool_pos143(X,Y) get_csv2_bool((X),(Y),143) +#define get_csv2_int_pos143(X,Y) get_csv2_int((X),(Y),143) +#define get_csv2_llong_pos143(X,Y) get_csv2_llong((X),(Y),143) +#define get_csv2_float_pos143(X,Y) get_csv2_float((X),(Y),143) +#define get_csv2_uint_pos144(X,Y) get_csv2_uint((X),(Y),144) +#define get_csv2_ullong_pos144(X,Y) get_csv2_ullong((X),(Y),144) +#define get_csv2_ip_pos144(X,Y) get_csv2_ip((X),(Y),144) +#define get_csv2_ipv6_pos144(X,Y) get_csv2_ipv6((X),(Y),144) +#define get_csv2_string_pos144(X,Y) get_csv2_string((X),(Y),144) +#define get_csv2_v_str_pos144(X,Y) get_csv2_string((X),(Y),144) +#define get_csv2_bool_pos144(X,Y) get_csv2_bool((X),(Y),144) +#define get_csv2_int_pos144(X,Y) get_csv2_int((X),(Y),144) +#define get_csv2_llong_pos144(X,Y) get_csv2_llong((X),(Y),144) +#define get_csv2_float_pos144(X,Y) get_csv2_float((X),(Y),144) +#define get_csv2_uint_pos145(X,Y) get_csv2_uint((X),(Y),145) +#define get_csv2_ullong_pos145(X,Y) get_csv2_ullong((X),(Y),145) +#define get_csv2_ip_pos145(X,Y) get_csv2_ip((X),(Y),145) +#define get_csv2_ipv6_pos145(X,Y) get_csv2_ipv6((X),(Y),145) +#define get_csv2_string_pos145(X,Y) get_csv2_string((X),(Y),145) +#define get_csv2_v_str_pos145(X,Y) get_csv2_string((X),(Y),145) +#define get_csv2_bool_pos145(X,Y) get_csv2_bool((X),(Y),145) +#define get_csv2_int_pos145(X,Y) get_csv2_int((X),(Y),145) +#define get_csv2_llong_pos145(X,Y) get_csv2_llong((X),(Y),145) +#define get_csv2_float_pos145(X,Y) get_csv2_float((X),(Y),145) +#define get_csv2_uint_pos146(X,Y) get_csv2_uint((X),(Y),146) +#define get_csv2_ullong_pos146(X,Y) get_csv2_ullong((X),(Y),146) +#define get_csv2_ip_pos146(X,Y) get_csv2_ip((X),(Y),146) +#define get_csv2_ipv6_pos146(X,Y) get_csv2_ipv6((X),(Y),146) +#define get_csv2_string_pos146(X,Y) get_csv2_string((X),(Y),146) +#define get_csv2_v_str_pos146(X,Y) get_csv2_string((X),(Y),146) +#define get_csv2_bool_pos146(X,Y) get_csv2_bool((X),(Y),146) +#define get_csv2_int_pos146(X,Y) get_csv2_int((X),(Y),146) +#define get_csv2_llong_pos146(X,Y) get_csv2_llong((X),(Y),146) +#define get_csv2_float_pos146(X,Y) get_csv2_float((X),(Y),146) +#define get_csv2_uint_pos147(X,Y) get_csv2_uint((X),(Y),147) +#define get_csv2_ullong_pos147(X,Y) get_csv2_ullong((X),(Y),147) +#define get_csv2_ip_pos147(X,Y) get_csv2_ip((X),(Y),147) +#define get_csv2_ipv6_pos147(X,Y) get_csv2_ipv6((X),(Y),147) +#define get_csv2_string_pos147(X,Y) get_csv2_string((X),(Y),147) +#define get_csv2_v_str_pos147(X,Y) get_csv2_string((X),(Y),147) +#define get_csv2_bool_pos147(X,Y) get_csv2_bool((X),(Y),147) +#define get_csv2_int_pos147(X,Y) get_csv2_int((X),(Y),147) +#define get_csv2_llong_pos147(X,Y) get_csv2_llong((X),(Y),147) +#define get_csv2_float_pos147(X,Y) get_csv2_float((X),(Y),147) +#define get_csv2_uint_pos148(X,Y) get_csv2_uint((X),(Y),148) +#define get_csv2_ullong_pos148(X,Y) get_csv2_ullong((X),(Y),148) +#define get_csv2_ip_pos148(X,Y) get_csv2_ip((X),(Y),148) +#define get_csv2_ipv6_pos148(X,Y) get_csv2_ipv6((X),(Y),148) +#define get_csv2_string_pos148(X,Y) get_csv2_string((X),(Y),148) +#define get_csv2_v_str_pos148(X,Y) get_csv2_string((X),(Y),148) +#define get_csv2_bool_pos148(X,Y) get_csv2_bool((X),(Y),148) +#define get_csv2_int_pos148(X,Y) get_csv2_int((X),(Y),148) +#define get_csv2_llong_pos148(X,Y) get_csv2_llong((X),(Y),148) +#define get_csv2_float_pos148(X,Y) get_csv2_float((X),(Y),148) +#define get_csv2_uint_pos149(X,Y) get_csv2_uint((X),(Y),149) +#define get_csv2_ullong_pos149(X,Y) get_csv2_ullong((X),(Y),149) +#define get_csv2_ip_pos149(X,Y) get_csv2_ip((X),(Y),149) +#define get_csv2_ipv6_pos149(X,Y) get_csv2_ipv6((X),(Y),149) +#define get_csv2_string_pos149(X,Y) get_csv2_string((X),(Y),149) +#define get_csv2_v_str_pos149(X,Y) get_csv2_string((X),(Y),149) +#define get_csv2_bool_pos149(X,Y) get_csv2_bool((X),(Y),149) +#define get_csv2_int_pos149(X,Y) get_csv2_int((X),(Y),149) +#define get_csv2_llong_pos149(X,Y) get_csv2_llong((X),(Y),149) +#define get_csv2_float_pos149(X,Y) get_csv2_float((X),(Y),149) +#define get_csv2_uint_pos150(X,Y) get_csv2_uint((X),(Y),150) +#define get_csv2_ullong_pos150(X,Y) get_csv2_ullong((X),(Y),150) +#define get_csv2_ip_pos150(X,Y) get_csv2_ip((X),(Y),150) +#define get_csv2_ipv6_pos150(X,Y) get_csv2_ipv6((X),(Y),150) +#define get_csv2_string_pos150(X,Y) get_csv2_string((X),(Y),150) +#define get_csv2_v_str_pos150(X,Y) get_csv2_string((X),(Y),150) +#define get_csv2_bool_pos150(X,Y) get_csv2_bool((X),(Y),150) +#define get_csv2_int_pos150(X,Y) get_csv2_int((X),(Y),150) +#define get_csv2_llong_pos150(X,Y) get_csv2_llong((X),(Y),150) +#define get_csv2_float_pos150(X,Y) get_csv2_float((X),(Y),150) +#define get_csv2_uint_pos151(X,Y) get_csv2_uint((X),(Y),151) +#define get_csv2_ullong_pos151(X,Y) get_csv2_ullong((X),(Y),151) +#define get_csv2_ip_pos151(X,Y) get_csv2_ip((X),(Y),151) +#define get_csv2_ipv6_pos151(X,Y) get_csv2_ipv6((X),(Y),151) +#define get_csv2_string_pos151(X,Y) get_csv2_string((X),(Y),151) +#define get_csv2_v_str_pos151(X,Y) get_csv2_string((X),(Y),151) +#define get_csv2_bool_pos151(X,Y) get_csv2_bool((X),(Y),151) +#define get_csv2_int_pos151(X,Y) get_csv2_int((X),(Y),151) +#define get_csv2_llong_pos151(X,Y) get_csv2_llong((X),(Y),151) +#define get_csv2_float_pos151(X,Y) get_csv2_float((X),(Y),151) +#define get_csv2_uint_pos152(X,Y) get_csv2_uint((X),(Y),152) +#define get_csv2_ullong_pos152(X,Y) get_csv2_ullong((X),(Y),152) +#define get_csv2_ip_pos152(X,Y) get_csv2_ip((X),(Y),152) +#define get_csv2_ipv6_pos152(X,Y) get_csv2_ipv6((X),(Y),152) +#define get_csv2_string_pos152(X,Y) get_csv2_string((X),(Y),152) +#define get_csv2_v_str_pos152(X,Y) get_csv2_string((X),(Y),152) +#define get_csv2_bool_pos152(X,Y) get_csv2_bool((X),(Y),152) +#define get_csv2_int_pos152(X,Y) get_csv2_int((X),(Y),152) +#define get_csv2_llong_pos152(X,Y) get_csv2_llong((X),(Y),152) +#define get_csv2_float_pos152(X,Y) get_csv2_float((X),(Y),152) +#define get_csv2_uint_pos153(X,Y) get_csv2_uint((X),(Y),153) +#define get_csv2_ullong_pos153(X,Y) get_csv2_ullong((X),(Y),153) +#define get_csv2_ip_pos153(X,Y) get_csv2_ip((X),(Y),153) +#define get_csv2_ipv6_pos153(X,Y) get_csv2_ipv6((X),(Y),153) +#define get_csv2_string_pos153(X,Y) get_csv2_string((X),(Y),153) +#define get_csv2_v_str_pos153(X,Y) get_csv2_string((X),(Y),153) +#define get_csv2_bool_pos153(X,Y) get_csv2_bool((X),(Y),153) +#define get_csv2_int_pos153(X,Y) get_csv2_int((X),(Y),153) +#define get_csv2_llong_pos153(X,Y) get_csv2_llong((X),(Y),153) +#define get_csv2_float_pos153(X,Y) get_csv2_float((X),(Y),153) +#define get_csv2_uint_pos154(X,Y) get_csv2_uint((X),(Y),154) +#define get_csv2_ullong_pos154(X,Y) get_csv2_ullong((X),(Y),154) +#define get_csv2_ip_pos154(X,Y) get_csv2_ip((X),(Y),154) +#define get_csv2_ipv6_pos154(X,Y) get_csv2_ipv6((X),(Y),154) +#define get_csv2_string_pos154(X,Y) get_csv2_string((X),(Y),154) +#define get_csv2_v_str_pos154(X,Y) get_csv2_string((X),(Y),154) +#define get_csv2_bool_pos154(X,Y) get_csv2_bool((X),(Y),154) +#define get_csv2_int_pos154(X,Y) get_csv2_int((X),(Y),154) +#define get_csv2_llong_pos154(X,Y) get_csv2_llong((X),(Y),154) +#define get_csv2_float_pos154(X,Y) get_csv2_float((X),(Y),154) +#define get_csv2_uint_pos155(X,Y) get_csv2_uint((X),(Y),155) +#define get_csv2_ullong_pos155(X,Y) get_csv2_ullong((X),(Y),155) +#define get_csv2_ip_pos155(X,Y) get_csv2_ip((X),(Y),155) +#define get_csv2_ipv6_pos155(X,Y) get_csv2_ipv6((X),(Y),155) +#define get_csv2_string_pos155(X,Y) get_csv2_string((X),(Y),155) +#define get_csv2_v_str_pos155(X,Y) get_csv2_string((X),(Y),155) +#define get_csv2_bool_pos155(X,Y) get_csv2_bool((X),(Y),155) +#define get_csv2_int_pos155(X,Y) get_csv2_int((X),(Y),155) +#define get_csv2_llong_pos155(X,Y) get_csv2_llong((X),(Y),155) +#define get_csv2_float_pos155(X,Y) get_csv2_float((X),(Y),155) +#define get_csv2_uint_pos156(X,Y) get_csv2_uint((X),(Y),156) +#define get_csv2_ullong_pos156(X,Y) get_csv2_ullong((X),(Y),156) +#define get_csv2_ip_pos156(X,Y) get_csv2_ip((X),(Y),156) +#define get_csv2_ipv6_pos156(X,Y) get_csv2_ipv6((X),(Y),156) +#define get_csv2_string_pos156(X,Y) get_csv2_string((X),(Y),156) +#define get_csv2_v_str_pos156(X,Y) get_csv2_string((X),(Y),156) +#define get_csv2_bool_pos156(X,Y) get_csv2_bool((X),(Y),156) +#define get_csv2_int_pos156(X,Y) get_csv2_int((X),(Y),156) +#define get_csv2_llong_pos156(X,Y) get_csv2_llong((X),(Y),156) +#define get_csv2_float_pos156(X,Y) get_csv2_float((X),(Y),156) +#define get_csv2_uint_pos157(X,Y) get_csv2_uint((X),(Y),157) +#define get_csv2_ullong_pos157(X,Y) get_csv2_ullong((X),(Y),157) +#define get_csv2_ip_pos157(X,Y) get_csv2_ip((X),(Y),157) +#define get_csv2_ipv6_pos157(X,Y) get_csv2_ipv6((X),(Y),157) +#define get_csv2_string_pos157(X,Y) get_csv2_string((X),(Y),157) +#define get_csv2_v_str_pos157(X,Y) get_csv2_string((X),(Y),157) +#define get_csv2_bool_pos157(X,Y) get_csv2_bool((X),(Y),157) +#define get_csv2_int_pos157(X,Y) get_csv2_int((X),(Y),157) +#define get_csv2_llong_pos157(X,Y) get_csv2_llong((X),(Y),157) +#define get_csv2_float_pos157(X,Y) get_csv2_float((X),(Y),157) +#define get_csv2_uint_pos158(X,Y) get_csv2_uint((X),(Y),158) +#define get_csv2_ullong_pos158(X,Y) get_csv2_ullong((X),(Y),158) +#define get_csv2_ip_pos158(X,Y) get_csv2_ip((X),(Y),158) +#define get_csv2_ipv6_pos158(X,Y) get_csv2_ipv6((X),(Y),158) +#define get_csv2_string_pos158(X,Y) get_csv2_string((X),(Y),158) +#define get_csv2_v_str_pos158(X,Y) get_csv2_string((X),(Y),158) +#define get_csv2_bool_pos158(X,Y) get_csv2_bool((X),(Y),158) +#define get_csv2_int_pos158(X,Y) get_csv2_int((X),(Y),158) +#define get_csv2_llong_pos158(X,Y) get_csv2_llong((X),(Y),158) +#define get_csv2_float_pos158(X,Y) get_csv2_float((X),(Y),158) +#define get_csv2_uint_pos159(X,Y) get_csv2_uint((X),(Y),159) +#define get_csv2_ullong_pos159(X,Y) get_csv2_ullong((X),(Y),159) +#define get_csv2_ip_pos159(X,Y) get_csv2_ip((X),(Y),159) +#define get_csv2_ipv6_pos159(X,Y) get_csv2_ipv6((X),(Y),159) +#define get_csv2_string_pos159(X,Y) get_csv2_string((X),(Y),159) +#define get_csv2_v_str_pos159(X,Y) get_csv2_string((X),(Y),159) +#define get_csv2_bool_pos159(X,Y) get_csv2_bool((X),(Y),159) +#define get_csv2_int_pos159(X,Y) get_csv2_int((X),(Y),159) +#define get_csv2_llong_pos159(X,Y) get_csv2_llong((X),(Y),159) +#define get_csv2_float_pos159(X,Y) get_csv2_float((X),(Y),159) +#define get_csv2_uint_pos160(X,Y) get_csv2_uint((X),(Y),160) +#define get_csv2_ullong_pos160(X,Y) get_csv2_ullong((X),(Y),160) +#define get_csv2_ip_pos160(X,Y) get_csv2_ip((X),(Y),160) +#define get_csv2_ipv6_pos160(X,Y) get_csv2_ipv6((X),(Y),160) +#define get_csv2_string_pos160(X,Y) get_csv2_string((X),(Y),160) +#define get_csv2_v_str_pos160(X,Y) get_csv2_string((X),(Y),160) +#define get_csv2_bool_pos160(X,Y) get_csv2_bool((X),(Y),160) +#define get_csv2_int_pos160(X,Y) get_csv2_int((X),(Y),160) +#define get_csv2_llong_pos160(X,Y) get_csv2_llong((X),(Y),160) +#define get_csv2_float_pos160(X,Y) get_csv2_float((X),(Y),160) +#define get_csv2_uint_pos161(X,Y) get_csv2_uint((X),(Y),161) +#define get_csv2_ullong_pos161(X,Y) get_csv2_ullong((X),(Y),161) +#define get_csv2_ip_pos161(X,Y) get_csv2_ip((X),(Y),161) +#define get_csv2_ipv6_pos161(X,Y) get_csv2_ipv6((X),(Y),161) +#define get_csv2_string_pos161(X,Y) get_csv2_string((X),(Y),161) +#define get_csv2_v_str_pos161(X,Y) get_csv2_string((X),(Y),161) +#define get_csv2_bool_pos161(X,Y) get_csv2_bool((X),(Y),161) +#define get_csv2_int_pos161(X,Y) get_csv2_int((X),(Y),161) +#define get_csv2_llong_pos161(X,Y) get_csv2_llong((X),(Y),161) +#define get_csv2_float_pos161(X,Y) get_csv2_float((X),(Y),161) +#define get_csv2_uint_pos162(X,Y) get_csv2_uint((X),(Y),162) +#define get_csv2_ullong_pos162(X,Y) get_csv2_ullong((X),(Y),162) +#define get_csv2_ip_pos162(X,Y) get_csv2_ip((X),(Y),162) +#define get_csv2_ipv6_pos162(X,Y) get_csv2_ipv6((X),(Y),162) +#define get_csv2_string_pos162(X,Y) get_csv2_string((X),(Y),162) +#define get_csv2_v_str_pos162(X,Y) get_csv2_string((X),(Y),162) +#define get_csv2_bool_pos162(X,Y) get_csv2_bool((X),(Y),162) +#define get_csv2_int_pos162(X,Y) get_csv2_int((X),(Y),162) +#define get_csv2_llong_pos162(X,Y) get_csv2_llong((X),(Y),162) +#define get_csv2_float_pos162(X,Y) get_csv2_float((X),(Y),162) +#define get_csv2_uint_pos163(X,Y) get_csv2_uint((X),(Y),163) +#define get_csv2_ullong_pos163(X,Y) get_csv2_ullong((X),(Y),163) +#define get_csv2_ip_pos163(X,Y) get_csv2_ip((X),(Y),163) +#define get_csv2_ipv6_pos163(X,Y) get_csv2_ipv6((X),(Y),163) +#define get_csv2_string_pos163(X,Y) get_csv2_string((X),(Y),163) +#define get_csv2_v_str_pos163(X,Y) get_csv2_string((X),(Y),163) +#define get_csv2_bool_pos163(X,Y) get_csv2_bool((X),(Y),163) +#define get_csv2_int_pos163(X,Y) get_csv2_int((X),(Y),163) +#define get_csv2_llong_pos163(X,Y) get_csv2_llong((X),(Y),163) +#define get_csv2_float_pos163(X,Y) get_csv2_float((X),(Y),163) +#define get_csv2_uint_pos164(X,Y) get_csv2_uint((X),(Y),164) +#define get_csv2_ullong_pos164(X,Y) get_csv2_ullong((X),(Y),164) +#define get_csv2_ip_pos164(X,Y) get_csv2_ip((X),(Y),164) +#define get_csv2_ipv6_pos164(X,Y) get_csv2_ipv6((X),(Y),164) +#define get_csv2_string_pos164(X,Y) get_csv2_string((X),(Y),164) +#define get_csv2_v_str_pos164(X,Y) get_csv2_string((X),(Y),164) +#define get_csv2_bool_pos164(X,Y) get_csv2_bool((X),(Y),164) +#define get_csv2_int_pos164(X,Y) get_csv2_int((X),(Y),164) +#define get_csv2_llong_pos164(X,Y) get_csv2_llong((X),(Y),164) +#define get_csv2_float_pos164(X,Y) get_csv2_float((X),(Y),164) +#define get_csv2_uint_pos165(X,Y) get_csv2_uint((X),(Y),165) +#define get_csv2_ullong_pos165(X,Y) get_csv2_ullong((X),(Y),165) +#define get_csv2_ip_pos165(X,Y) get_csv2_ip((X),(Y),165) +#define get_csv2_ipv6_pos165(X,Y) get_csv2_ipv6((X),(Y),165) +#define get_csv2_string_pos165(X,Y) get_csv2_string((X),(Y),165) +#define get_csv2_v_str_pos165(X,Y) get_csv2_string((X),(Y),165) +#define get_csv2_bool_pos165(X,Y) get_csv2_bool((X),(Y),165) +#define get_csv2_int_pos165(X,Y) get_csv2_int((X),(Y),165) +#define get_csv2_llong_pos165(X,Y) get_csv2_llong((X),(Y),165) +#define get_csv2_float_pos165(X,Y) get_csv2_float((X),(Y),165) +#define get_csv2_uint_pos166(X,Y) get_csv2_uint((X),(Y),166) +#define get_csv2_ullong_pos166(X,Y) get_csv2_ullong((X),(Y),166) +#define get_csv2_ip_pos166(X,Y) get_csv2_ip((X),(Y),166) +#define get_csv2_ipv6_pos166(X,Y) get_csv2_ipv6((X),(Y),166) +#define get_csv2_string_pos166(X,Y) get_csv2_string((X),(Y),166) +#define get_csv2_v_str_pos166(X,Y) get_csv2_string((X),(Y),166) +#define get_csv2_bool_pos166(X,Y) get_csv2_bool((X),(Y),166) +#define get_csv2_int_pos166(X,Y) get_csv2_int((X),(Y),166) +#define get_csv2_llong_pos166(X,Y) get_csv2_llong((X),(Y),166) +#define get_csv2_float_pos166(X,Y) get_csv2_float((X),(Y),166) +#define get_csv2_uint_pos167(X,Y) get_csv2_uint((X),(Y),167) +#define get_csv2_ullong_pos167(X,Y) get_csv2_ullong((X),(Y),167) +#define get_csv2_ip_pos167(X,Y) get_csv2_ip((X),(Y),167) +#define get_csv2_ipv6_pos167(X,Y) get_csv2_ipv6((X),(Y),167) +#define get_csv2_string_pos167(X,Y) get_csv2_string((X),(Y),167) +#define get_csv2_v_str_pos167(X,Y) get_csv2_string((X),(Y),167) +#define get_csv2_bool_pos167(X,Y) get_csv2_bool((X),(Y),167) +#define get_csv2_int_pos167(X,Y) get_csv2_int((X),(Y),167) +#define get_csv2_llong_pos167(X,Y) get_csv2_llong((X),(Y),167) +#define get_csv2_float_pos167(X,Y) get_csv2_float((X),(Y),167) +#define get_csv2_uint_pos168(X,Y) get_csv2_uint((X),(Y),168) +#define get_csv2_ullong_pos168(X,Y) get_csv2_ullong((X),(Y),168) +#define get_csv2_ip_pos168(X,Y) get_csv2_ip((X),(Y),168) +#define get_csv2_ipv6_pos168(X,Y) get_csv2_ipv6((X),(Y),168) +#define get_csv2_string_pos168(X,Y) get_csv2_string((X),(Y),168) +#define get_csv2_v_str_pos168(X,Y) get_csv2_string((X),(Y),168) +#define get_csv2_bool_pos168(X,Y) get_csv2_bool((X),(Y),168) +#define get_csv2_int_pos168(X,Y) get_csv2_int((X),(Y),168) +#define get_csv2_llong_pos168(X,Y) get_csv2_llong((X),(Y),168) +#define get_csv2_float_pos168(X,Y) get_csv2_float((X),(Y),168) +#define get_csv2_uint_pos169(X,Y) get_csv2_uint((X),(Y),169) +#define get_csv2_ullong_pos169(X,Y) get_csv2_ullong((X),(Y),169) +#define get_csv2_ip_pos169(X,Y) get_csv2_ip((X),(Y),169) +#define get_csv2_ipv6_pos169(X,Y) get_csv2_ipv6((X),(Y),169) +#define get_csv2_string_pos169(X,Y) get_csv2_string((X),(Y),169) +#define get_csv2_v_str_pos169(X,Y) get_csv2_string((X),(Y),169) +#define get_csv2_bool_pos169(X,Y) get_csv2_bool((X),(Y),169) +#define get_csv2_int_pos169(X,Y) get_csv2_int((X),(Y),169) +#define get_csv2_llong_pos169(X,Y) get_csv2_llong((X),(Y),169) +#define get_csv2_float_pos169(X,Y) get_csv2_float((X),(Y),169) +#define get_csv2_uint_pos170(X,Y) get_csv2_uint((X),(Y),170) +#define get_csv2_ullong_pos170(X,Y) get_csv2_ullong((X),(Y),170) +#define get_csv2_ip_pos170(X,Y) get_csv2_ip((X),(Y),170) +#define get_csv2_ipv6_pos170(X,Y) get_csv2_ipv6((X),(Y),170) +#define get_csv2_string_pos170(X,Y) get_csv2_string((X),(Y),170) +#define get_csv2_v_str_pos170(X,Y) get_csv2_string((X),(Y),170) +#define get_csv2_bool_pos170(X,Y) get_csv2_bool((X),(Y),170) +#define get_csv2_int_pos170(X,Y) get_csv2_int((X),(Y),170) +#define get_csv2_llong_pos170(X,Y) get_csv2_llong((X),(Y),170) +#define get_csv2_float_pos170(X,Y) get_csv2_float((X),(Y),170) +#define get_csv2_uint_pos171(X,Y) get_csv2_uint((X),(Y),171) +#define get_csv2_ullong_pos171(X,Y) get_csv2_ullong((X),(Y),171) +#define get_csv2_ip_pos171(X,Y) get_csv2_ip((X),(Y),171) +#define get_csv2_ipv6_pos171(X,Y) get_csv2_ipv6((X),(Y),171) +#define get_csv2_string_pos171(X,Y) get_csv2_string((X),(Y),171) +#define get_csv2_v_str_pos171(X,Y) get_csv2_string((X),(Y),171) +#define get_csv2_bool_pos171(X,Y) get_csv2_bool((X),(Y),171) +#define get_csv2_int_pos171(X,Y) get_csv2_int((X),(Y),171) +#define get_csv2_llong_pos171(X,Y) get_csv2_llong((X),(Y),171) +#define get_csv2_float_pos171(X,Y) get_csv2_float((X),(Y),171) +#define get_csv2_uint_pos172(X,Y) get_csv2_uint((X),(Y),172) +#define get_csv2_ullong_pos172(X,Y) get_csv2_ullong((X),(Y),172) +#define get_csv2_ip_pos172(X,Y) get_csv2_ip((X),(Y),172) +#define get_csv2_ipv6_pos172(X,Y) get_csv2_ipv6((X),(Y),172) +#define get_csv2_string_pos172(X,Y) get_csv2_string((X),(Y),172) +#define get_csv2_v_str_pos172(X,Y) get_csv2_string((X),(Y),172) +#define get_csv2_bool_pos172(X,Y) get_csv2_bool((X),(Y),172) +#define get_csv2_int_pos172(X,Y) get_csv2_int((X),(Y),172) +#define get_csv2_llong_pos172(X,Y) get_csv2_llong((X),(Y),172) +#define get_csv2_float_pos172(X,Y) get_csv2_float((X),(Y),172) +#define get_csv2_uint_pos173(X,Y) get_csv2_uint((X),(Y),173) +#define get_csv2_ullong_pos173(X,Y) get_csv2_ullong((X),(Y),173) +#define get_csv2_ip_pos173(X,Y) get_csv2_ip((X),(Y),173) +#define get_csv2_ipv6_pos173(X,Y) get_csv2_ipv6((X),(Y),173) +#define get_csv2_string_pos173(X,Y) get_csv2_string((X),(Y),173) +#define get_csv2_v_str_pos173(X,Y) get_csv2_string((X),(Y),173) +#define get_csv2_bool_pos173(X,Y) get_csv2_bool((X),(Y),173) +#define get_csv2_int_pos173(X,Y) get_csv2_int((X),(Y),173) +#define get_csv2_llong_pos173(X,Y) get_csv2_llong((X),(Y),173) +#define get_csv2_float_pos173(X,Y) get_csv2_float((X),(Y),173) +#define get_csv2_uint_pos174(X,Y) get_csv2_uint((X),(Y),174) +#define get_csv2_ullong_pos174(X,Y) get_csv2_ullong((X),(Y),174) +#define get_csv2_ip_pos174(X,Y) get_csv2_ip((X),(Y),174) +#define get_csv2_ipv6_pos174(X,Y) get_csv2_ipv6((X),(Y),174) +#define get_csv2_string_pos174(X,Y) get_csv2_string((X),(Y),174) +#define get_csv2_v_str_pos174(X,Y) get_csv2_string((X),(Y),174) +#define get_csv2_bool_pos174(X,Y) get_csv2_bool((X),(Y),174) +#define get_csv2_int_pos174(X,Y) get_csv2_int((X),(Y),174) +#define get_csv2_llong_pos174(X,Y) get_csv2_llong((X),(Y),174) +#define get_csv2_float_pos174(X,Y) get_csv2_float((X),(Y),174) +#define get_csv2_uint_pos175(X,Y) get_csv2_uint((X),(Y),175) +#define get_csv2_ullong_pos175(X,Y) get_csv2_ullong((X),(Y),175) +#define get_csv2_ip_pos175(X,Y) get_csv2_ip((X),(Y),175) +#define get_csv2_ipv6_pos175(X,Y) get_csv2_ipv6((X),(Y),175) +#define get_csv2_string_pos175(X,Y) get_csv2_string((X),(Y),175) +#define get_csv2_v_str_pos175(X,Y) get_csv2_string((X),(Y),175) +#define get_csv2_bool_pos175(X,Y) get_csv2_bool((X),(Y),175) +#define get_csv2_int_pos175(X,Y) get_csv2_int((X),(Y),175) +#define get_csv2_llong_pos175(X,Y) get_csv2_llong((X),(Y),175) +#define get_csv2_float_pos175(X,Y) get_csv2_float((X),(Y),175) +#define get_csv2_uint_pos176(X,Y) get_csv2_uint((X),(Y),176) +#define get_csv2_ullong_pos176(X,Y) get_csv2_ullong((X),(Y),176) +#define get_csv2_ip_pos176(X,Y) get_csv2_ip((X),(Y),176) +#define get_csv2_ipv6_pos176(X,Y) get_csv2_ipv6((X),(Y),176) +#define get_csv2_string_pos176(X,Y) get_csv2_string((X),(Y),176) +#define get_csv2_v_str_pos176(X,Y) get_csv2_string((X),(Y),176) +#define get_csv2_bool_pos176(X,Y) get_csv2_bool((X),(Y),176) +#define get_csv2_int_pos176(X,Y) get_csv2_int((X),(Y),176) +#define get_csv2_llong_pos176(X,Y) get_csv2_llong((X),(Y),176) +#define get_csv2_float_pos176(X,Y) get_csv2_float((X),(Y),176) +#define get_csv2_uint_pos177(X,Y) get_csv2_uint((X),(Y),177) +#define get_csv2_ullong_pos177(X,Y) get_csv2_ullong((X),(Y),177) +#define get_csv2_ip_pos177(X,Y) get_csv2_ip((X),(Y),177) +#define get_csv2_ipv6_pos177(X,Y) get_csv2_ipv6((X),(Y),177) +#define get_csv2_string_pos177(X,Y) get_csv2_string((X),(Y),177) +#define get_csv2_v_str_pos177(X,Y) get_csv2_string((X),(Y),177) +#define get_csv2_bool_pos177(X,Y) get_csv2_bool((X),(Y),177) +#define get_csv2_int_pos177(X,Y) get_csv2_int((X),(Y),177) +#define get_csv2_llong_pos177(X,Y) get_csv2_llong((X),(Y),177) +#define get_csv2_float_pos177(X,Y) get_csv2_float((X),(Y),177) +#define get_csv2_uint_pos178(X,Y) get_csv2_uint((X),(Y),178) +#define get_csv2_ullong_pos178(X,Y) get_csv2_ullong((X),(Y),178) +#define get_csv2_ip_pos178(X,Y) get_csv2_ip((X),(Y),178) +#define get_csv2_ipv6_pos178(X,Y) get_csv2_ipv6((X),(Y),178) +#define get_csv2_string_pos178(X,Y) get_csv2_string((X),(Y),178) +#define get_csv2_v_str_pos178(X,Y) get_csv2_string((X),(Y),178) +#define get_csv2_bool_pos178(X,Y) get_csv2_bool((X),(Y),178) +#define get_csv2_int_pos178(X,Y) get_csv2_int((X),(Y),178) +#define get_csv2_llong_pos178(X,Y) get_csv2_llong((X),(Y),178) +#define get_csv2_float_pos178(X,Y) get_csv2_float((X),(Y),178) +#define get_csv2_uint_pos179(X,Y) get_csv2_uint((X),(Y),179) +#define get_csv2_ullong_pos179(X,Y) get_csv2_ullong((X),(Y),179) +#define get_csv2_ip_pos179(X,Y) get_csv2_ip((X),(Y),179) +#define get_csv2_ipv6_pos179(X,Y) get_csv2_ipv6((X),(Y),179) +#define get_csv2_string_pos179(X,Y) get_csv2_string((X),(Y),179) +#define get_csv2_v_str_pos179(X,Y) get_csv2_string((X),(Y),179) +#define get_csv2_bool_pos179(X,Y) get_csv2_bool((X),(Y),179) +#define get_csv2_int_pos179(X,Y) get_csv2_int((X),(Y),179) +#define get_csv2_llong_pos179(X,Y) get_csv2_llong((X),(Y),179) +#define get_csv2_float_pos179(X,Y) get_csv2_float((X),(Y),179) +#define get_csv2_uint_pos180(X,Y) get_csv2_uint((X),(Y),180) +#define get_csv2_ullong_pos180(X,Y) get_csv2_ullong((X),(Y),180) +#define get_csv2_ip_pos180(X,Y) get_csv2_ip((X),(Y),180) +#define get_csv2_ipv6_pos180(X,Y) get_csv2_ipv6((X),(Y),180) +#define get_csv2_string_pos180(X,Y) get_csv2_string((X),(Y),180) +#define get_csv2_v_str_pos180(X,Y) get_csv2_string((X),(Y),180) +#define get_csv2_bool_pos180(X,Y) get_csv2_bool((X),(Y),180) +#define get_csv2_int_pos180(X,Y) get_csv2_int((X),(Y),180) +#define get_csv2_llong_pos180(X,Y) get_csv2_llong((X),(Y),180) +#define get_csv2_float_pos180(X,Y) get_csv2_float((X),(Y),180) +#define get_csv2_uint_pos181(X,Y) get_csv2_uint((X),(Y),181) +#define get_csv2_ullong_pos181(X,Y) get_csv2_ullong((X),(Y),181) +#define get_csv2_ip_pos181(X,Y) get_csv2_ip((X),(Y),181) +#define get_csv2_ipv6_pos181(X,Y) get_csv2_ipv6((X),(Y),181) +#define get_csv2_string_pos181(X,Y) get_csv2_string((X),(Y),181) +#define get_csv2_v_str_pos181(X,Y) get_csv2_string((X),(Y),181) +#define get_csv2_bool_pos181(X,Y) get_csv2_bool((X),(Y),181) +#define get_csv2_int_pos181(X,Y) get_csv2_int((X),(Y),181) +#define get_csv2_llong_pos181(X,Y) get_csv2_llong((X),(Y),181) +#define get_csv2_float_pos181(X,Y) get_csv2_float((X),(Y),181) +#define get_csv2_uint_pos182(X,Y) get_csv2_uint((X),(Y),182) +#define get_csv2_ullong_pos182(X,Y) get_csv2_ullong((X),(Y),182) +#define get_csv2_ip_pos182(X,Y) get_csv2_ip((X),(Y),182) +#define get_csv2_ipv6_pos182(X,Y) get_csv2_ipv6((X),(Y),182) +#define get_csv2_string_pos182(X,Y) get_csv2_string((X),(Y),182) +#define get_csv2_v_str_pos182(X,Y) get_csv2_string((X),(Y),182) +#define get_csv2_bool_pos182(X,Y) get_csv2_bool((X),(Y),182) +#define get_csv2_int_pos182(X,Y) get_csv2_int((X),(Y),182) +#define get_csv2_llong_pos182(X,Y) get_csv2_llong((X),(Y),182) +#define get_csv2_float_pos182(X,Y) get_csv2_float((X),(Y),182) +#define get_csv2_uint_pos183(X,Y) get_csv2_uint((X),(Y),183) +#define get_csv2_ullong_pos183(X,Y) get_csv2_ullong((X),(Y),183) +#define get_csv2_ip_pos183(X,Y) get_csv2_ip((X),(Y),183) +#define get_csv2_ipv6_pos183(X,Y) get_csv2_ipv6((X),(Y),183) +#define get_csv2_string_pos183(X,Y) get_csv2_string((X),(Y),183) +#define get_csv2_v_str_pos183(X,Y) get_csv2_string((X),(Y),183) +#define get_csv2_bool_pos183(X,Y) get_csv2_bool((X),(Y),183) +#define get_csv2_int_pos183(X,Y) get_csv2_int((X),(Y),183) +#define get_csv2_llong_pos183(X,Y) get_csv2_llong((X),(Y),183) +#define get_csv2_float_pos183(X,Y) get_csv2_float((X),(Y),183) +#define get_csv2_uint_pos184(X,Y) get_csv2_uint((X),(Y),184) +#define get_csv2_ullong_pos184(X,Y) get_csv2_ullong((X),(Y),184) +#define get_csv2_ip_pos184(X,Y) get_csv2_ip((X),(Y),184) +#define get_csv2_ipv6_pos184(X,Y) get_csv2_ipv6((X),(Y),184) +#define get_csv2_string_pos184(X,Y) get_csv2_string((X),(Y),184) +#define get_csv2_v_str_pos184(X,Y) get_csv2_string((X),(Y),184) +#define get_csv2_bool_pos184(X,Y) get_csv2_bool((X),(Y),184) +#define get_csv2_int_pos184(X,Y) get_csv2_int((X),(Y),184) +#define get_csv2_llong_pos184(X,Y) get_csv2_llong((X),(Y),184) +#define get_csv2_float_pos184(X,Y) get_csv2_float((X),(Y),184) +#define get_csv2_uint_pos185(X,Y) get_csv2_uint((X),(Y),185) +#define get_csv2_ullong_pos185(X,Y) get_csv2_ullong((X),(Y),185) +#define get_csv2_ip_pos185(X,Y) get_csv2_ip((X),(Y),185) +#define get_csv2_ipv6_pos185(X,Y) get_csv2_ipv6((X),(Y),185) +#define get_csv2_string_pos185(X,Y) get_csv2_string((X),(Y),185) +#define get_csv2_v_str_pos185(X,Y) get_csv2_string((X),(Y),185) +#define get_csv2_bool_pos185(X,Y) get_csv2_bool((X),(Y),185) +#define get_csv2_int_pos185(X,Y) get_csv2_int((X),(Y),185) +#define get_csv2_llong_pos185(X,Y) get_csv2_llong((X),(Y),185) +#define get_csv2_float_pos185(X,Y) get_csv2_float((X),(Y),185) +#define get_csv2_uint_pos186(X,Y) get_csv2_uint((X),(Y),186) +#define get_csv2_ullong_pos186(X,Y) get_csv2_ullong((X),(Y),186) +#define get_csv2_ip_pos186(X,Y) get_csv2_ip((X),(Y),186) +#define get_csv2_ipv6_pos186(X,Y) get_csv2_ipv6((X),(Y),186) +#define get_csv2_string_pos186(X,Y) get_csv2_string((X),(Y),186) +#define get_csv2_v_str_pos186(X,Y) get_csv2_string((X),(Y),186) +#define get_csv2_bool_pos186(X,Y) get_csv2_bool((X),(Y),186) +#define get_csv2_int_pos186(X,Y) get_csv2_int((X),(Y),186) +#define get_csv2_llong_pos186(X,Y) get_csv2_llong((X),(Y),186) +#define get_csv2_float_pos186(X,Y) get_csv2_float((X),(Y),186) +#define get_csv2_uint_pos187(X,Y) get_csv2_uint((X),(Y),187) +#define get_csv2_ullong_pos187(X,Y) get_csv2_ullong((X),(Y),187) +#define get_csv2_ip_pos187(X,Y) get_csv2_ip((X),(Y),187) +#define get_csv2_ipv6_pos187(X,Y) get_csv2_ipv6((X),(Y),187) +#define get_csv2_string_pos187(X,Y) get_csv2_string((X),(Y),187) +#define get_csv2_v_str_pos187(X,Y) get_csv2_string((X),(Y),187) +#define get_csv2_bool_pos187(X,Y) get_csv2_bool((X),(Y),187) +#define get_csv2_int_pos187(X,Y) get_csv2_int((X),(Y),187) +#define get_csv2_llong_pos187(X,Y) get_csv2_llong((X),(Y),187) +#define get_csv2_float_pos187(X,Y) get_csv2_float((X),(Y),187) +#define get_csv2_uint_pos188(X,Y) get_csv2_uint((X),(Y),188) +#define get_csv2_ullong_pos188(X,Y) get_csv2_ullong((X),(Y),188) +#define get_csv2_ip_pos188(X,Y) get_csv2_ip((X),(Y),188) +#define get_csv2_ipv6_pos188(X,Y) get_csv2_ipv6((X),(Y),188) +#define get_csv2_string_pos188(X,Y) get_csv2_string((X),(Y),188) +#define get_csv2_v_str_pos188(X,Y) get_csv2_string((X),(Y),188) +#define get_csv2_bool_pos188(X,Y) get_csv2_bool((X),(Y),188) +#define get_csv2_int_pos188(X,Y) get_csv2_int((X),(Y),188) +#define get_csv2_llong_pos188(X,Y) get_csv2_llong((X),(Y),188) +#define get_csv2_float_pos188(X,Y) get_csv2_float((X),(Y),188) +#define get_csv2_uint_pos189(X,Y) get_csv2_uint((X),(Y),189) +#define get_csv2_ullong_pos189(X,Y) get_csv2_ullong((X),(Y),189) +#define get_csv2_ip_pos189(X,Y) get_csv2_ip((X),(Y),189) +#define get_csv2_ipv6_pos189(X,Y) get_csv2_ipv6((X),(Y),189) +#define get_csv2_string_pos189(X,Y) get_csv2_string((X),(Y),189) +#define get_csv2_v_str_pos189(X,Y) get_csv2_string((X),(Y),189) +#define get_csv2_bool_pos189(X,Y) get_csv2_bool((X),(Y),189) +#define get_csv2_int_pos189(X,Y) get_csv2_int((X),(Y),189) +#define get_csv2_llong_pos189(X,Y) get_csv2_llong((X),(Y),189) +#define get_csv2_float_pos189(X,Y) get_csv2_float((X),(Y),189) +#define get_csv2_uint_pos190(X,Y) get_csv2_uint((X),(Y),190) +#define get_csv2_ullong_pos190(X,Y) get_csv2_ullong((X),(Y),190) +#define get_csv2_ip_pos190(X,Y) get_csv2_ip((X),(Y),190) +#define get_csv2_ipv6_pos190(X,Y) get_csv2_ipv6((X),(Y),190) +#define get_csv2_string_pos190(X,Y) get_csv2_string((X),(Y),190) +#define get_csv2_v_str_pos190(X,Y) get_csv2_string((X),(Y),190) +#define get_csv2_bool_pos190(X,Y) get_csv2_bool((X),(Y),190) +#define get_csv2_int_pos190(X,Y) get_csv2_int((X),(Y),190) +#define get_csv2_llong_pos190(X,Y) get_csv2_llong((X),(Y),190) +#define get_csv2_float_pos190(X,Y) get_csv2_float((X),(Y),190) +#define get_csv2_uint_pos191(X,Y) get_csv2_uint((X),(Y),191) +#define get_csv2_ullong_pos191(X,Y) get_csv2_ullong((X),(Y),191) +#define get_csv2_ip_pos191(X,Y) get_csv2_ip((X),(Y),191) +#define get_csv2_ipv6_pos191(X,Y) get_csv2_ipv6((X),(Y),191) +#define get_csv2_string_pos191(X,Y) get_csv2_string((X),(Y),191) +#define get_csv2_v_str_pos191(X,Y) get_csv2_string((X),(Y),191) +#define get_csv2_bool_pos191(X,Y) get_csv2_bool((X),(Y),191) +#define get_csv2_int_pos191(X,Y) get_csv2_int((X),(Y),191) +#define get_csv2_llong_pos191(X,Y) get_csv2_llong((X),(Y),191) +#define get_csv2_float_pos191(X,Y) get_csv2_float((X),(Y),191) +#define get_csv2_uint_pos192(X,Y) get_csv2_uint((X),(Y),192) +#define get_csv2_ullong_pos192(X,Y) get_csv2_ullong((X),(Y),192) +#define get_csv2_ip_pos192(X,Y) get_csv2_ip((X),(Y),192) +#define get_csv2_ipv6_pos192(X,Y) get_csv2_ipv6((X),(Y),192) +#define get_csv2_string_pos192(X,Y) get_csv2_string((X),(Y),192) +#define get_csv2_v_str_pos192(X,Y) get_csv2_string((X),(Y),192) +#define get_csv2_bool_pos192(X,Y) get_csv2_bool((X),(Y),192) +#define get_csv2_int_pos192(X,Y) get_csv2_int((X),(Y),192) +#define get_csv2_llong_pos192(X,Y) get_csv2_llong((X),(Y),192) +#define get_csv2_float_pos192(X,Y) get_csv2_float((X),(Y),192) +#define get_csv2_uint_pos193(X,Y) get_csv2_uint((X),(Y),193) +#define get_csv2_ullong_pos193(X,Y) get_csv2_ullong((X),(Y),193) +#define get_csv2_ip_pos193(X,Y) get_csv2_ip((X),(Y),193) +#define get_csv2_ipv6_pos193(X,Y) get_csv2_ipv6((X),(Y),193) +#define get_csv2_string_pos193(X,Y) get_csv2_string((X),(Y),193) +#define get_csv2_v_str_pos193(X,Y) get_csv2_string((X),(Y),193) +#define get_csv2_bool_pos193(X,Y) get_csv2_bool((X),(Y),193) +#define get_csv2_int_pos193(X,Y) get_csv2_int((X),(Y),193) +#define get_csv2_llong_pos193(X,Y) get_csv2_llong((X),(Y),193) +#define get_csv2_float_pos193(X,Y) get_csv2_float((X),(Y),193) +#define get_csv2_uint_pos194(X,Y) get_csv2_uint((X),(Y),194) +#define get_csv2_ullong_pos194(X,Y) get_csv2_ullong((X),(Y),194) +#define get_csv2_ip_pos194(X,Y) get_csv2_ip((X),(Y),194) +#define get_csv2_ipv6_pos194(X,Y) get_csv2_ipv6((X),(Y),194) +#define get_csv2_string_pos194(X,Y) get_csv2_string((X),(Y),194) +#define get_csv2_v_str_pos194(X,Y) get_csv2_string((X),(Y),194) +#define get_csv2_bool_pos194(X,Y) get_csv2_bool((X),(Y),194) +#define get_csv2_int_pos194(X,Y) get_csv2_int((X),(Y),194) +#define get_csv2_llong_pos194(X,Y) get_csv2_llong((X),(Y),194) +#define get_csv2_float_pos194(X,Y) get_csv2_float((X),(Y),194) +#define get_csv2_uint_pos195(X,Y) get_csv2_uint((X),(Y),195) +#define get_csv2_ullong_pos195(X,Y) get_csv2_ullong((X),(Y),195) +#define get_csv2_ip_pos195(X,Y) get_csv2_ip((X),(Y),195) +#define get_csv2_ipv6_pos195(X,Y) get_csv2_ipv6((X),(Y),195) +#define get_csv2_string_pos195(X,Y) get_csv2_string((X),(Y),195) +#define get_csv2_v_str_pos195(X,Y) get_csv2_string((X),(Y),195) +#define get_csv2_bool_pos195(X,Y) get_csv2_bool((X),(Y),195) +#define get_csv2_int_pos195(X,Y) get_csv2_int((X),(Y),195) +#define get_csv2_llong_pos195(X,Y) get_csv2_llong((X),(Y),195) +#define get_csv2_float_pos195(X,Y) get_csv2_float((X),(Y),195) +#define get_csv2_uint_pos196(X,Y) get_csv2_uint((X),(Y),196) +#define get_csv2_ullong_pos196(X,Y) get_csv2_ullong((X),(Y),196) +#define get_csv2_ip_pos196(X,Y) get_csv2_ip((X),(Y),196) +#define get_csv2_ipv6_pos196(X,Y) get_csv2_ipv6((X),(Y),196) +#define get_csv2_string_pos196(X,Y) get_csv2_string((X),(Y),196) +#define get_csv2_v_str_pos196(X,Y) get_csv2_string((X),(Y),196) +#define get_csv2_bool_pos196(X,Y) get_csv2_bool((X),(Y),196) +#define get_csv2_int_pos196(X,Y) get_csv2_int((X),(Y),196) +#define get_csv2_llong_pos196(X,Y) get_csv2_llong((X),(Y),196) +#define get_csv2_float_pos196(X,Y) get_csv2_float((X),(Y),196) +#define get_csv2_uint_pos197(X,Y) get_csv2_uint((X),(Y),197) +#define get_csv2_ullong_pos197(X,Y) get_csv2_ullong((X),(Y),197) +#define get_csv2_ip_pos197(X,Y) get_csv2_ip((X),(Y),197) +#define get_csv2_ipv6_pos197(X,Y) get_csv2_ipv6((X),(Y),197) +#define get_csv2_string_pos197(X,Y) get_csv2_string((X),(Y),197) +#define get_csv2_v_str_pos197(X,Y) get_csv2_string((X),(Y),197) +#define get_csv2_bool_pos197(X,Y) get_csv2_bool((X),(Y),197) +#define get_csv2_int_pos197(X,Y) get_csv2_int((X),(Y),197) +#define get_csv2_llong_pos197(X,Y) get_csv2_llong((X),(Y),197) +#define get_csv2_float_pos197(X,Y) get_csv2_float((X),(Y),197) +#define get_csv2_uint_pos198(X,Y) get_csv2_uint((X),(Y),198) +#define get_csv2_ullong_pos198(X,Y) get_csv2_ullong((X),(Y),198) +#define get_csv2_ip_pos198(X,Y) get_csv2_ip((X),(Y),198) +#define get_csv2_ipv6_pos198(X,Y) get_csv2_ipv6((X),(Y),198) +#define get_csv2_string_pos198(X,Y) get_csv2_string((X),(Y),198) +#define get_csv2_v_str_pos198(X,Y) get_csv2_string((X),(Y),198) +#define get_csv2_bool_pos198(X,Y) get_csv2_bool((X),(Y),198) +#define get_csv2_int_pos198(X,Y) get_csv2_int((X),(Y),198) +#define get_csv2_llong_pos198(X,Y) get_csv2_llong((X),(Y),198) +#define get_csv2_float_pos198(X,Y) get_csv2_float((X),(Y),198) +#define get_csv2_uint_pos199(X,Y) get_csv2_uint((X),(Y),199) +#define get_csv2_ullong_pos199(X,Y) get_csv2_ullong((X),(Y),199) +#define get_csv2_ip_pos199(X,Y) get_csv2_ip((X),(Y),199) +#define get_csv2_ipv6_pos199(X,Y) get_csv2_ipv6((X),(Y),199) +#define get_csv2_string_pos199(X,Y) get_csv2_string((X),(Y),199) +#define get_csv2_v_str_pos199(X,Y) get_csv2_string((X),(Y),199) +#define get_csv2_bool_pos199(X,Y) get_csv2_bool((X),(Y),199) +#define get_csv2_int_pos199(X,Y) get_csv2_int((X),(Y),199) +#define get_csv2_llong_pos199(X,Y) get_csv2_llong((X),(Y),199) +#define get_csv2_float_pos199(X,Y) get_csv2_float((X),(Y),199) +#define get_csv2_uint_pos200(X,Y) get_csv2_uint((X),(Y),200) +#define get_csv2_ullong_pos200(X,Y) get_csv2_ullong((X),(Y),200) +#define get_csv2_ip_pos200(X,Y) get_csv2_ip((X),(Y),200) +#define get_csv2_ipv6_pos200(X,Y) get_csv2_ipv6((X),(Y),200) +#define get_csv2_string_pos200(X,Y) get_csv2_string((X),(Y),200) +#define get_csv2_v_str_pos200(X,Y) get_csv2_string((X),(Y),200) +#define get_csv2_bool_pos200(X,Y) get_csv2_bool((X),(Y),200) +#define get_csv2_int_pos200(X,Y) get_csv2_int((X),(Y),200) +#define get_csv2_llong_pos200(X,Y) get_csv2_llong((X),(Y),200) +#define get_csv2_float_pos200(X,Y) get_csv2_float((X),(Y),200) +#define get_csv2_uint_pos201(X,Y) get_csv2_uint((X),(Y),201) +#define get_csv2_ullong_pos201(X,Y) get_csv2_ullong((X),(Y),201) +#define get_csv2_ip_pos201(X,Y) get_csv2_ip((X),(Y),201) +#define get_csv2_ipv6_pos201(X,Y) get_csv2_ipv6((X),(Y),201) +#define get_csv2_string_pos201(X,Y) get_csv2_string((X),(Y),201) +#define get_csv2_v_str_pos201(X,Y) get_csv2_string((X),(Y),201) +#define get_csv2_bool_pos201(X,Y) get_csv2_bool((X),(Y),201) +#define get_csv2_int_pos201(X,Y) get_csv2_int((X),(Y),201) +#define get_csv2_llong_pos201(X,Y) get_csv2_llong((X),(Y),201) +#define get_csv2_float_pos201(X,Y) get_csv2_float((X),(Y),201) +#define get_csv2_uint_pos202(X,Y) get_csv2_uint((X),(Y),202) +#define get_csv2_ullong_pos202(X,Y) get_csv2_ullong((X),(Y),202) +#define get_csv2_ip_pos202(X,Y) get_csv2_ip((X),(Y),202) +#define get_csv2_ipv6_pos202(X,Y) get_csv2_ipv6((X),(Y),202) +#define get_csv2_string_pos202(X,Y) get_csv2_string((X),(Y),202) +#define get_csv2_v_str_pos202(X,Y) get_csv2_string((X),(Y),202) +#define get_csv2_bool_pos202(X,Y) get_csv2_bool((X),(Y),202) +#define get_csv2_int_pos202(X,Y) get_csv2_int((X),(Y),202) +#define get_csv2_llong_pos202(X,Y) get_csv2_llong((X),(Y),202) +#define get_csv2_float_pos202(X,Y) get_csv2_float((X),(Y),202) +#define get_csv2_uint_pos203(X,Y) get_csv2_uint((X),(Y),203) +#define get_csv2_ullong_pos203(X,Y) get_csv2_ullong((X),(Y),203) +#define get_csv2_ip_pos203(X,Y) get_csv2_ip((X),(Y),203) +#define get_csv2_ipv6_pos203(X,Y) get_csv2_ipv6((X),(Y),203) +#define get_csv2_string_pos203(X,Y) get_csv2_string((X),(Y),203) +#define get_csv2_v_str_pos203(X,Y) get_csv2_string((X),(Y),203) +#define get_csv2_bool_pos203(X,Y) get_csv2_bool((X),(Y),203) +#define get_csv2_int_pos203(X,Y) get_csv2_int((X),(Y),203) +#define get_csv2_llong_pos203(X,Y) get_csv2_llong((X),(Y),203) +#define get_csv2_float_pos203(X,Y) get_csv2_float((X),(Y),203) +#define get_csv2_uint_pos204(X,Y) get_csv2_uint((X),(Y),204) +#define get_csv2_ullong_pos204(X,Y) get_csv2_ullong((X),(Y),204) +#define get_csv2_ip_pos204(X,Y) get_csv2_ip((X),(Y),204) +#define get_csv2_ipv6_pos204(X,Y) get_csv2_ipv6((X),(Y),204) +#define get_csv2_string_pos204(X,Y) get_csv2_string((X),(Y),204) +#define get_csv2_v_str_pos204(X,Y) get_csv2_string((X),(Y),204) +#define get_csv2_bool_pos204(X,Y) get_csv2_bool((X),(Y),204) +#define get_csv2_int_pos204(X,Y) get_csv2_int((X),(Y),204) +#define get_csv2_llong_pos204(X,Y) get_csv2_llong((X),(Y),204) +#define get_csv2_float_pos204(X,Y) get_csv2_float((X),(Y),204) +#define get_csv2_uint_pos205(X,Y) get_csv2_uint((X),(Y),205) +#define get_csv2_ullong_pos205(X,Y) get_csv2_ullong((X),(Y),205) +#define get_csv2_ip_pos205(X,Y) get_csv2_ip((X),(Y),205) +#define get_csv2_ipv6_pos205(X,Y) get_csv2_ipv6((X),(Y),205) +#define get_csv2_string_pos205(X,Y) get_csv2_string((X),(Y),205) +#define get_csv2_v_str_pos205(X,Y) get_csv2_string((X),(Y),205) +#define get_csv2_bool_pos205(X,Y) get_csv2_bool((X),(Y),205) +#define get_csv2_int_pos205(X,Y) get_csv2_int((X),(Y),205) +#define get_csv2_llong_pos205(X,Y) get_csv2_llong((X),(Y),205) +#define get_csv2_float_pos205(X,Y) get_csv2_float((X),(Y),205) +#define get_csv2_uint_pos206(X,Y) get_csv2_uint((X),(Y),206) +#define get_csv2_ullong_pos206(X,Y) get_csv2_ullong((X),(Y),206) +#define get_csv2_ip_pos206(X,Y) get_csv2_ip((X),(Y),206) +#define get_csv2_ipv6_pos206(X,Y) get_csv2_ipv6((X),(Y),206) +#define get_csv2_string_pos206(X,Y) get_csv2_string((X),(Y),206) +#define get_csv2_v_str_pos206(X,Y) get_csv2_string((X),(Y),206) +#define get_csv2_bool_pos206(X,Y) get_csv2_bool((X),(Y),206) +#define get_csv2_int_pos206(X,Y) get_csv2_int((X),(Y),206) +#define get_csv2_llong_pos206(X,Y) get_csv2_llong((X),(Y),206) +#define get_csv2_float_pos206(X,Y) get_csv2_float((X),(Y),206) +#define get_csv2_uint_pos207(X,Y) get_csv2_uint((X),(Y),207) +#define get_csv2_ullong_pos207(X,Y) get_csv2_ullong((X),(Y),207) +#define get_csv2_ip_pos207(X,Y) get_csv2_ip((X),(Y),207) +#define get_csv2_ipv6_pos207(X,Y) get_csv2_ipv6((X),(Y),207) +#define get_csv2_string_pos207(X,Y) get_csv2_string((X),(Y),207) +#define get_csv2_v_str_pos207(X,Y) get_csv2_string((X),(Y),207) +#define get_csv2_bool_pos207(X,Y) get_csv2_bool((X),(Y),207) +#define get_csv2_int_pos207(X,Y) get_csv2_int((X),(Y),207) +#define get_csv2_llong_pos207(X,Y) get_csv2_llong((X),(Y),207) +#define get_csv2_float_pos207(X,Y) get_csv2_float((X),(Y),207) +#define get_csv2_uint_pos208(X,Y) get_csv2_uint((X),(Y),208) +#define get_csv2_ullong_pos208(X,Y) get_csv2_ullong((X),(Y),208) +#define get_csv2_ip_pos208(X,Y) get_csv2_ip((X),(Y),208) +#define get_csv2_ipv6_pos208(X,Y) get_csv2_ipv6((X),(Y),208) +#define get_csv2_string_pos208(X,Y) get_csv2_string((X),(Y),208) +#define get_csv2_v_str_pos208(X,Y) get_csv2_string((X),(Y),208) +#define get_csv2_bool_pos208(X,Y) get_csv2_bool((X),(Y),208) +#define get_csv2_int_pos208(X,Y) get_csv2_int((X),(Y),208) +#define get_csv2_llong_pos208(X,Y) get_csv2_llong((X),(Y),208) +#define get_csv2_float_pos208(X,Y) get_csv2_float((X),(Y),208) +#define get_csv2_uint_pos209(X,Y) get_csv2_uint((X),(Y),209) +#define get_csv2_ullong_pos209(X,Y) get_csv2_ullong((X),(Y),209) +#define get_csv2_ip_pos209(X,Y) get_csv2_ip((X),(Y),209) +#define get_csv2_ipv6_pos209(X,Y) get_csv2_ipv6((X),(Y),209) +#define get_csv2_string_pos209(X,Y) get_csv2_string((X),(Y),209) +#define get_csv2_v_str_pos209(X,Y) get_csv2_string((X),(Y),209) +#define get_csv2_bool_pos209(X,Y) get_csv2_bool((X),(Y),209) +#define get_csv2_int_pos209(X,Y) get_csv2_int((X),(Y),209) +#define get_csv2_llong_pos209(X,Y) get_csv2_llong((X),(Y),209) +#define get_csv2_float_pos209(X,Y) get_csv2_float((X),(Y),209) +#define get_csv2_uint_pos210(X,Y) get_csv2_uint((X),(Y),210) +#define get_csv2_ullong_pos210(X,Y) get_csv2_ullong((X),(Y),210) +#define get_csv2_ip_pos210(X,Y) get_csv2_ip((X),(Y),210) +#define get_csv2_ipv6_pos210(X,Y) get_csv2_ipv6((X),(Y),210) +#define get_csv2_string_pos210(X,Y) get_csv2_string((X),(Y),210) +#define get_csv2_v_str_pos210(X,Y) get_csv2_string((X),(Y),210) +#define get_csv2_bool_pos210(X,Y) get_csv2_bool((X),(Y),210) +#define get_csv2_int_pos210(X,Y) get_csv2_int((X),(Y),210) +#define get_csv2_llong_pos210(X,Y) get_csv2_llong((X),(Y),210) +#define get_csv2_float_pos210(X,Y) get_csv2_float((X),(Y),210) +#define get_csv2_uint_pos211(X,Y) get_csv2_uint((X),(Y),211) +#define get_csv2_ullong_pos211(X,Y) get_csv2_ullong((X),(Y),211) +#define get_csv2_ip_pos211(X,Y) get_csv2_ip((X),(Y),211) +#define get_csv2_ipv6_pos211(X,Y) get_csv2_ipv6((X),(Y),211) +#define get_csv2_string_pos211(X,Y) get_csv2_string((X),(Y),211) +#define get_csv2_v_str_pos211(X,Y) get_csv2_string((X),(Y),211) +#define get_csv2_bool_pos211(X,Y) get_csv2_bool((X),(Y),211) +#define get_csv2_int_pos211(X,Y) get_csv2_int((X),(Y),211) +#define get_csv2_llong_pos211(X,Y) get_csv2_llong((X),(Y),211) +#define get_csv2_float_pos211(X,Y) get_csv2_float((X),(Y),211) +#define get_csv2_uint_pos212(X,Y) get_csv2_uint((X),(Y),212) +#define get_csv2_ullong_pos212(X,Y) get_csv2_ullong((X),(Y),212) +#define get_csv2_ip_pos212(X,Y) get_csv2_ip((X),(Y),212) +#define get_csv2_ipv6_pos212(X,Y) get_csv2_ipv6((X),(Y),212) +#define get_csv2_string_pos212(X,Y) get_csv2_string((X),(Y),212) +#define get_csv2_v_str_pos212(X,Y) get_csv2_string((X),(Y),212) +#define get_csv2_bool_pos212(X,Y) get_csv2_bool((X),(Y),212) +#define get_csv2_int_pos212(X,Y) get_csv2_int((X),(Y),212) +#define get_csv2_llong_pos212(X,Y) get_csv2_llong((X),(Y),212) +#define get_csv2_float_pos212(X,Y) get_csv2_float((X),(Y),212) +#define get_csv2_uint_pos213(X,Y) get_csv2_uint((X),(Y),213) +#define get_csv2_ullong_pos213(X,Y) get_csv2_ullong((X),(Y),213) +#define get_csv2_ip_pos213(X,Y) get_csv2_ip((X),(Y),213) +#define get_csv2_ipv6_pos213(X,Y) get_csv2_ipv6((X),(Y),213) +#define get_csv2_string_pos213(X,Y) get_csv2_string((X),(Y),213) +#define get_csv2_v_str_pos213(X,Y) get_csv2_string((X),(Y),213) +#define get_csv2_bool_pos213(X,Y) get_csv2_bool((X),(Y),213) +#define get_csv2_int_pos213(X,Y) get_csv2_int((X),(Y),213) +#define get_csv2_llong_pos213(X,Y) get_csv2_llong((X),(Y),213) +#define get_csv2_float_pos213(X,Y) get_csv2_float((X),(Y),213) +#define get_csv2_uint_pos214(X,Y) get_csv2_uint((X),(Y),214) +#define get_csv2_ullong_pos214(X,Y) get_csv2_ullong((X),(Y),214) +#define get_csv2_ip_pos214(X,Y) get_csv2_ip((X),(Y),214) +#define get_csv2_ipv6_pos214(X,Y) get_csv2_ipv6((X),(Y),214) +#define get_csv2_string_pos214(X,Y) get_csv2_string((X),(Y),214) +#define get_csv2_v_str_pos214(X,Y) get_csv2_string((X),(Y),214) +#define get_csv2_bool_pos214(X,Y) get_csv2_bool((X),(Y),214) +#define get_csv2_int_pos214(X,Y) get_csv2_int((X),(Y),214) +#define get_csv2_llong_pos214(X,Y) get_csv2_llong((X),(Y),214) +#define get_csv2_float_pos214(X,Y) get_csv2_float((X),(Y),214) +#define get_csv2_uint_pos215(X,Y) get_csv2_uint((X),(Y),215) +#define get_csv2_ullong_pos215(X,Y) get_csv2_ullong((X),(Y),215) +#define get_csv2_ip_pos215(X,Y) get_csv2_ip((X),(Y),215) +#define get_csv2_ipv6_pos215(X,Y) get_csv2_ipv6((X),(Y),215) +#define get_csv2_string_pos215(X,Y) get_csv2_string((X),(Y),215) +#define get_csv2_v_str_pos215(X,Y) get_csv2_string((X),(Y),215) +#define get_csv2_bool_pos215(X,Y) get_csv2_bool((X),(Y),215) +#define get_csv2_int_pos215(X,Y) get_csv2_int((X),(Y),215) +#define get_csv2_llong_pos215(X,Y) get_csv2_llong((X),(Y),215) +#define get_csv2_float_pos215(X,Y) get_csv2_float((X),(Y),215) +#define get_csv2_uint_pos216(X,Y) get_csv2_uint((X),(Y),216) +#define get_csv2_ullong_pos216(X,Y) get_csv2_ullong((X),(Y),216) +#define get_csv2_ip_pos216(X,Y) get_csv2_ip((X),(Y),216) +#define get_csv2_ipv6_pos216(X,Y) get_csv2_ipv6((X),(Y),216) +#define get_csv2_string_pos216(X,Y) get_csv2_string((X),(Y),216) +#define get_csv2_v_str_pos216(X,Y) get_csv2_string((X),(Y),216) +#define get_csv2_bool_pos216(X,Y) get_csv2_bool((X),(Y),216) +#define get_csv2_int_pos216(X,Y) get_csv2_int((X),(Y),216) +#define get_csv2_llong_pos216(X,Y) get_csv2_llong((X),(Y),216) +#define get_csv2_float_pos216(X,Y) get_csv2_float((X),(Y),216) +#define get_csv2_uint_pos217(X,Y) get_csv2_uint((X),(Y),217) +#define get_csv2_ullong_pos217(X,Y) get_csv2_ullong((X),(Y),217) +#define get_csv2_ip_pos217(X,Y) get_csv2_ip((X),(Y),217) +#define get_csv2_ipv6_pos217(X,Y) get_csv2_ipv6((X),(Y),217) +#define get_csv2_string_pos217(X,Y) get_csv2_string((X),(Y),217) +#define get_csv2_v_str_pos217(X,Y) get_csv2_string((X),(Y),217) +#define get_csv2_bool_pos217(X,Y) get_csv2_bool((X),(Y),217) +#define get_csv2_int_pos217(X,Y) get_csv2_int((X),(Y),217) +#define get_csv2_llong_pos217(X,Y) get_csv2_llong((X),(Y),217) +#define get_csv2_float_pos217(X,Y) get_csv2_float((X),(Y),217) +#define get_csv2_uint_pos218(X,Y) get_csv2_uint((X),(Y),218) +#define get_csv2_ullong_pos218(X,Y) get_csv2_ullong((X),(Y),218) +#define get_csv2_ip_pos218(X,Y) get_csv2_ip((X),(Y),218) +#define get_csv2_ipv6_pos218(X,Y) get_csv2_ipv6((X),(Y),218) +#define get_csv2_string_pos218(X,Y) get_csv2_string((X),(Y),218) +#define get_csv2_v_str_pos218(X,Y) get_csv2_string((X),(Y),218) +#define get_csv2_bool_pos218(X,Y) get_csv2_bool((X),(Y),218) +#define get_csv2_int_pos218(X,Y) get_csv2_int((X),(Y),218) +#define get_csv2_llong_pos218(X,Y) get_csv2_llong((X),(Y),218) +#define get_csv2_float_pos218(X,Y) get_csv2_float((X),(Y),218) +#define get_csv2_uint_pos219(X,Y) get_csv2_uint((X),(Y),219) +#define get_csv2_ullong_pos219(X,Y) get_csv2_ullong((X),(Y),219) +#define get_csv2_ip_pos219(X,Y) get_csv2_ip((X),(Y),219) +#define get_csv2_ipv6_pos219(X,Y) get_csv2_ipv6((X),(Y),219) +#define get_csv2_string_pos219(X,Y) get_csv2_string((X),(Y),219) +#define get_csv2_v_str_pos219(X,Y) get_csv2_string((X),(Y),219) +#define get_csv2_bool_pos219(X,Y) get_csv2_bool((X),(Y),219) +#define get_csv2_int_pos219(X,Y) get_csv2_int((X),(Y),219) +#define get_csv2_llong_pos219(X,Y) get_csv2_llong((X),(Y),219) +#define get_csv2_float_pos219(X,Y) get_csv2_float((X),(Y),219) +#define get_csv2_uint_pos220(X,Y) get_csv2_uint((X),(Y),220) +#define get_csv2_ullong_pos220(X,Y) get_csv2_ullong((X),(Y),220) +#define get_csv2_ip_pos220(X,Y) get_csv2_ip((X),(Y),220) +#define get_csv2_ipv6_pos220(X,Y) get_csv2_ipv6((X),(Y),220) +#define get_csv2_string_pos220(X,Y) get_csv2_string((X),(Y),220) +#define get_csv2_v_str_pos220(X,Y) get_csv2_string((X),(Y),220) +#define get_csv2_bool_pos220(X,Y) get_csv2_bool((X),(Y),220) +#define get_csv2_int_pos220(X,Y) get_csv2_int((X),(Y),220) +#define get_csv2_llong_pos220(X,Y) get_csv2_llong((X),(Y),220) +#define get_csv2_float_pos220(X,Y) get_csv2_float((X),(Y),220) +#define get_csv2_uint_pos221(X,Y) get_csv2_uint((X),(Y),221) +#define get_csv2_ullong_pos221(X,Y) get_csv2_ullong((X),(Y),221) +#define get_csv2_ip_pos221(X,Y) get_csv2_ip((X),(Y),221) +#define get_csv2_ipv6_pos221(X,Y) get_csv2_ipv6((X),(Y),221) +#define get_csv2_string_pos221(X,Y) get_csv2_string((X),(Y),221) +#define get_csv2_v_str_pos221(X,Y) get_csv2_string((X),(Y),221) +#define get_csv2_bool_pos221(X,Y) get_csv2_bool((X),(Y),221) +#define get_csv2_int_pos221(X,Y) get_csv2_int((X),(Y),221) +#define get_csv2_llong_pos221(X,Y) get_csv2_llong((X),(Y),221) +#define get_csv2_float_pos221(X,Y) get_csv2_float((X),(Y),221) +#define get_csv2_uint_pos222(X,Y) get_csv2_uint((X),(Y),222) +#define get_csv2_ullong_pos222(X,Y) get_csv2_ullong((X),(Y),222) +#define get_csv2_ip_pos222(X,Y) get_csv2_ip((X),(Y),222) +#define get_csv2_ipv6_pos222(X,Y) get_csv2_ipv6((X),(Y),222) +#define get_csv2_string_pos222(X,Y) get_csv2_string((X),(Y),222) +#define get_csv2_v_str_pos222(X,Y) get_csv2_string((X),(Y),222) +#define get_csv2_bool_pos222(X,Y) get_csv2_bool((X),(Y),222) +#define get_csv2_int_pos222(X,Y) get_csv2_int((X),(Y),222) +#define get_csv2_llong_pos222(X,Y) get_csv2_llong((X),(Y),222) +#define get_csv2_float_pos222(X,Y) get_csv2_float((X),(Y),222) +#define get_csv2_uint_pos223(X,Y) get_csv2_uint((X),(Y),223) +#define get_csv2_ullong_pos223(X,Y) get_csv2_ullong((X),(Y),223) +#define get_csv2_ip_pos223(X,Y) get_csv2_ip((X),(Y),223) +#define get_csv2_ipv6_pos223(X,Y) get_csv2_ipv6((X),(Y),223) +#define get_csv2_string_pos223(X,Y) get_csv2_string((X),(Y),223) +#define get_csv2_v_str_pos223(X,Y) get_csv2_string((X),(Y),223) +#define get_csv2_bool_pos223(X,Y) get_csv2_bool((X),(Y),223) +#define get_csv2_int_pos223(X,Y) get_csv2_int((X),(Y),223) +#define get_csv2_llong_pos223(X,Y) get_csv2_llong((X),(Y),223) +#define get_csv2_float_pos223(X,Y) get_csv2_float((X),(Y),223) +#define get_csv2_uint_pos224(X,Y) get_csv2_uint((X),(Y),224) +#define get_csv2_ullong_pos224(X,Y) get_csv2_ullong((X),(Y),224) +#define get_csv2_ip_pos224(X,Y) get_csv2_ip((X),(Y),224) +#define get_csv2_ipv6_pos224(X,Y) get_csv2_ipv6((X),(Y),224) +#define get_csv2_string_pos224(X,Y) get_csv2_string((X),(Y),224) +#define get_csv2_v_str_pos224(X,Y) get_csv2_string((X),(Y),224) +#define get_csv2_bool_pos224(X,Y) get_csv2_bool((X),(Y),224) +#define get_csv2_int_pos224(X,Y) get_csv2_int((X),(Y),224) +#define get_csv2_llong_pos224(X,Y) get_csv2_llong((X),(Y),224) +#define get_csv2_float_pos224(X,Y) get_csv2_float((X),(Y),224) +#define get_csv2_uint_pos225(X,Y) get_csv2_uint((X),(Y),225) +#define get_csv2_ullong_pos225(X,Y) get_csv2_ullong((X),(Y),225) +#define get_csv2_ip_pos225(X,Y) get_csv2_ip((X),(Y),225) +#define get_csv2_ipv6_pos225(X,Y) get_csv2_ipv6((X),(Y),225) +#define get_csv2_string_pos225(X,Y) get_csv2_string((X),(Y),225) +#define get_csv2_v_str_pos225(X,Y) get_csv2_string((X),(Y),225) +#define get_csv2_bool_pos225(X,Y) get_csv2_bool((X),(Y),225) +#define get_csv2_int_pos225(X,Y) get_csv2_int((X),(Y),225) +#define get_csv2_llong_pos225(X,Y) get_csv2_llong((X),(Y),225) +#define get_csv2_float_pos225(X,Y) get_csv2_float((X),(Y),225) +#define get_csv2_uint_pos226(X,Y) get_csv2_uint((X),(Y),226) +#define get_csv2_ullong_pos226(X,Y) get_csv2_ullong((X),(Y),226) +#define get_csv2_ip_pos226(X,Y) get_csv2_ip((X),(Y),226) +#define get_csv2_ipv6_pos226(X,Y) get_csv2_ipv6((X),(Y),226) +#define get_csv2_string_pos226(X,Y) get_csv2_string((X),(Y),226) +#define get_csv2_v_str_pos226(X,Y) get_csv2_string((X),(Y),226) +#define get_csv2_bool_pos226(X,Y) get_csv2_bool((X),(Y),226) +#define get_csv2_int_pos226(X,Y) get_csv2_int((X),(Y),226) +#define get_csv2_llong_pos226(X,Y) get_csv2_llong((X),(Y),226) +#define get_csv2_float_pos226(X,Y) get_csv2_float((X),(Y),226) +#define get_csv2_uint_pos227(X,Y) get_csv2_uint((X),(Y),227) +#define get_csv2_ullong_pos227(X,Y) get_csv2_ullong((X),(Y),227) +#define get_csv2_ip_pos227(X,Y) get_csv2_ip((X),(Y),227) +#define get_csv2_ipv6_pos227(X,Y) get_csv2_ipv6((X),(Y),227) +#define get_csv2_string_pos227(X,Y) get_csv2_string((X),(Y),227) +#define get_csv2_v_str_pos227(X,Y) get_csv2_string((X),(Y),227) +#define get_csv2_bool_pos227(X,Y) get_csv2_bool((X),(Y),227) +#define get_csv2_int_pos227(X,Y) get_csv2_int((X),(Y),227) +#define get_csv2_llong_pos227(X,Y) get_csv2_llong((X),(Y),227) +#define get_csv2_float_pos227(X,Y) get_csv2_float((X),(Y),227) +#define get_csv2_uint_pos228(X,Y) get_csv2_uint((X),(Y),228) +#define get_csv2_ullong_pos228(X,Y) get_csv2_ullong((X),(Y),228) +#define get_csv2_ip_pos228(X,Y) get_csv2_ip((X),(Y),228) +#define get_csv2_ipv6_pos228(X,Y) get_csv2_ipv6((X),(Y),228) +#define get_csv2_string_pos228(X,Y) get_csv2_string((X),(Y),228) +#define get_csv2_v_str_pos228(X,Y) get_csv2_string((X),(Y),228) +#define get_csv2_bool_pos228(X,Y) get_csv2_bool((X),(Y),228) +#define get_csv2_int_pos228(X,Y) get_csv2_int((X),(Y),228) +#define get_csv2_llong_pos228(X,Y) get_csv2_llong((X),(Y),228) +#define get_csv2_float_pos228(X,Y) get_csv2_float((X),(Y),228) +#define get_csv2_uint_pos229(X,Y) get_csv2_uint((X),(Y),229) +#define get_csv2_ullong_pos229(X,Y) get_csv2_ullong((X),(Y),229) +#define get_csv2_ip_pos229(X,Y) get_csv2_ip((X),(Y),229) +#define get_csv2_ipv6_pos229(X,Y) get_csv2_ipv6((X),(Y),229) +#define get_csv2_string_pos229(X,Y) get_csv2_string((X),(Y),229) +#define get_csv2_v_str_pos229(X,Y) get_csv2_string((X),(Y),229) +#define get_csv2_bool_pos229(X,Y) get_csv2_bool((X),(Y),229) +#define get_csv2_int_pos229(X,Y) get_csv2_int((X),(Y),229) +#define get_csv2_llong_pos229(X,Y) get_csv2_llong((X),(Y),229) +#define get_csv2_float_pos229(X,Y) get_csv2_float((X),(Y),229) +#define get_csv2_uint_pos230(X,Y) get_csv2_uint((X),(Y),230) +#define get_csv2_ullong_pos230(X,Y) get_csv2_ullong((X),(Y),230) +#define get_csv2_ip_pos230(X,Y) get_csv2_ip((X),(Y),230) +#define get_csv2_ipv6_pos230(X,Y) get_csv2_ipv6((X),(Y),230) +#define get_csv2_string_pos230(X,Y) get_csv2_string((X),(Y),230) +#define get_csv2_v_str_pos230(X,Y) get_csv2_string((X),(Y),230) +#define get_csv2_bool_pos230(X,Y) get_csv2_bool((X),(Y),230) +#define get_csv2_int_pos230(X,Y) get_csv2_int((X),(Y),230) +#define get_csv2_llong_pos230(X,Y) get_csv2_llong((X),(Y),230) +#define get_csv2_float_pos230(X,Y) get_csv2_float((X),(Y),230) +#define get_csv2_uint_pos231(X,Y) get_csv2_uint((X),(Y),231) +#define get_csv2_ullong_pos231(X,Y) get_csv2_ullong((X),(Y),231) +#define get_csv2_ip_pos231(X,Y) get_csv2_ip((X),(Y),231) +#define get_csv2_ipv6_pos231(X,Y) get_csv2_ipv6((X),(Y),231) +#define get_csv2_string_pos231(X,Y) get_csv2_string((X),(Y),231) +#define get_csv2_v_str_pos231(X,Y) get_csv2_string((X),(Y),231) +#define get_csv2_bool_pos231(X,Y) get_csv2_bool((X),(Y),231) +#define get_csv2_int_pos231(X,Y) get_csv2_int((X),(Y),231) +#define get_csv2_llong_pos231(X,Y) get_csv2_llong((X),(Y),231) +#define get_csv2_float_pos231(X,Y) get_csv2_float((X),(Y),231) +#define get_csv2_uint_pos232(X,Y) get_csv2_uint((X),(Y),232) +#define get_csv2_ullong_pos232(X,Y) get_csv2_ullong((X),(Y),232) +#define get_csv2_ip_pos232(X,Y) get_csv2_ip((X),(Y),232) +#define get_csv2_ipv6_pos232(X,Y) get_csv2_ipv6((X),(Y),232) +#define get_csv2_string_pos232(X,Y) get_csv2_string((X),(Y),232) +#define get_csv2_v_str_pos232(X,Y) get_csv2_string((X),(Y),232) +#define get_csv2_bool_pos232(X,Y) get_csv2_bool((X),(Y),232) +#define get_csv2_int_pos232(X,Y) get_csv2_int((X),(Y),232) +#define get_csv2_llong_pos232(X,Y) get_csv2_llong((X),(Y),232) +#define get_csv2_float_pos232(X,Y) get_csv2_float((X),(Y),232) +#define get_csv2_uint_pos233(X,Y) get_csv2_uint((X),(Y),233) +#define get_csv2_ullong_pos233(X,Y) get_csv2_ullong((X),(Y),233) +#define get_csv2_ip_pos233(X,Y) get_csv2_ip((X),(Y),233) +#define get_csv2_ipv6_pos233(X,Y) get_csv2_ipv6((X),(Y),233) +#define get_csv2_string_pos233(X,Y) get_csv2_string((X),(Y),233) +#define get_csv2_v_str_pos233(X,Y) get_csv2_string((X),(Y),233) +#define get_csv2_bool_pos233(X,Y) get_csv2_bool((X),(Y),233) +#define get_csv2_int_pos233(X,Y) get_csv2_int((X),(Y),233) +#define get_csv2_llong_pos233(X,Y) get_csv2_llong((X),(Y),233) +#define get_csv2_float_pos233(X,Y) get_csv2_float((X),(Y),233) +#define get_csv2_uint_pos234(X,Y) get_csv2_uint((X),(Y),234) +#define get_csv2_ullong_pos234(X,Y) get_csv2_ullong((X),(Y),234) +#define get_csv2_ip_pos234(X,Y) get_csv2_ip((X),(Y),234) +#define get_csv2_ipv6_pos234(X,Y) get_csv2_ipv6((X),(Y),234) +#define get_csv2_string_pos234(X,Y) get_csv2_string((X),(Y),234) +#define get_csv2_v_str_pos234(X,Y) get_csv2_string((X),(Y),234) +#define get_csv2_bool_pos234(X,Y) get_csv2_bool((X),(Y),234) +#define get_csv2_int_pos234(X,Y) get_csv2_int((X),(Y),234) +#define get_csv2_llong_pos234(X,Y) get_csv2_llong((X),(Y),234) +#define get_csv2_float_pos234(X,Y) get_csv2_float((X),(Y),234) +#define get_csv2_uint_pos235(X,Y) get_csv2_uint((X),(Y),235) +#define get_csv2_ullong_pos235(X,Y) get_csv2_ullong((X),(Y),235) +#define get_csv2_ip_pos235(X,Y) get_csv2_ip((X),(Y),235) +#define get_csv2_ipv6_pos235(X,Y) get_csv2_ipv6((X),(Y),235) +#define get_csv2_string_pos235(X,Y) get_csv2_string((X),(Y),235) +#define get_csv2_v_str_pos235(X,Y) get_csv2_string((X),(Y),235) +#define get_csv2_bool_pos235(X,Y) get_csv2_bool((X),(Y),235) +#define get_csv2_int_pos235(X,Y) get_csv2_int((X),(Y),235) +#define get_csv2_llong_pos235(X,Y) get_csv2_llong((X),(Y),235) +#define get_csv2_float_pos235(X,Y) get_csv2_float((X),(Y),235) +#define get_csv2_uint_pos236(X,Y) get_csv2_uint((X),(Y),236) +#define get_csv2_ullong_pos236(X,Y) get_csv2_ullong((X),(Y),236) +#define get_csv2_ip_pos236(X,Y) get_csv2_ip((X),(Y),236) +#define get_csv2_ipv6_pos236(X,Y) get_csv2_ipv6((X),(Y),236) +#define get_csv2_string_pos236(X,Y) get_csv2_string((X),(Y),236) +#define get_csv2_v_str_pos236(X,Y) get_csv2_string((X),(Y),236) +#define get_csv2_bool_pos236(X,Y) get_csv2_bool((X),(Y),236) +#define get_csv2_int_pos236(X,Y) get_csv2_int((X),(Y),236) +#define get_csv2_llong_pos236(X,Y) get_csv2_llong((X),(Y),236) +#define get_csv2_float_pos236(X,Y) get_csv2_float((X),(Y),236) +#define get_csv2_uint_pos237(X,Y) get_csv2_uint((X),(Y),237) +#define get_csv2_ullong_pos237(X,Y) get_csv2_ullong((X),(Y),237) +#define get_csv2_ip_pos237(X,Y) get_csv2_ip((X),(Y),237) +#define get_csv2_ipv6_pos237(X,Y) get_csv2_ipv6((X),(Y),237) +#define get_csv2_string_pos237(X,Y) get_csv2_string((X),(Y),237) +#define get_csv2_v_str_pos237(X,Y) get_csv2_string((X),(Y),237) +#define get_csv2_bool_pos237(X,Y) get_csv2_bool((X),(Y),237) +#define get_csv2_int_pos237(X,Y) get_csv2_int((X),(Y),237) +#define get_csv2_llong_pos237(X,Y) get_csv2_llong((X),(Y),237) +#define get_csv2_float_pos237(X,Y) get_csv2_float((X),(Y),237) +#define get_csv2_uint_pos238(X,Y) get_csv2_uint((X),(Y),238) +#define get_csv2_ullong_pos238(X,Y) get_csv2_ullong((X),(Y),238) +#define get_csv2_ip_pos238(X,Y) get_csv2_ip((X),(Y),238) +#define get_csv2_ipv6_pos238(X,Y) get_csv2_ipv6((X),(Y),238) +#define get_csv2_string_pos238(X,Y) get_csv2_string((X),(Y),238) +#define get_csv2_v_str_pos238(X,Y) get_csv2_string((X),(Y),238) +#define get_csv2_bool_pos238(X,Y) get_csv2_bool((X),(Y),238) +#define get_csv2_int_pos238(X,Y) get_csv2_int((X),(Y),238) +#define get_csv2_llong_pos238(X,Y) get_csv2_llong((X),(Y),238) +#define get_csv2_float_pos238(X,Y) get_csv2_float((X),(Y),238) +#define get_csv2_uint_pos239(X,Y) get_csv2_uint((X),(Y),239) +#define get_csv2_ullong_pos239(X,Y) get_csv2_ullong((X),(Y),239) +#define get_csv2_ip_pos239(X,Y) get_csv2_ip((X),(Y),239) +#define get_csv2_ipv6_pos239(X,Y) get_csv2_ipv6((X),(Y),239) +#define get_csv2_string_pos239(X,Y) get_csv2_string((X),(Y),239) +#define get_csv2_v_str_pos239(X,Y) get_csv2_string((X),(Y),239) +#define get_csv2_bool_pos239(X,Y) get_csv2_bool((X),(Y),239) +#define get_csv2_int_pos239(X,Y) get_csv2_int((X),(Y),239) +#define get_csv2_llong_pos239(X,Y) get_csv2_llong((X),(Y),239) +#define get_csv2_float_pos239(X,Y) get_csv2_float((X),(Y),239) +#define get_csv2_uint_pos240(X,Y) get_csv2_uint((X),(Y),240) +#define get_csv2_ullong_pos240(X,Y) get_csv2_ullong((X),(Y),240) +#define get_csv2_ip_pos240(X,Y) get_csv2_ip((X),(Y),240) +#define get_csv2_ipv6_pos240(X,Y) get_csv2_ipv6((X),(Y),240) +#define get_csv2_string_pos240(X,Y) get_csv2_string((X),(Y),240) +#define get_csv2_v_str_pos240(X,Y) get_csv2_string((X),(Y),240) +#define get_csv2_bool_pos240(X,Y) get_csv2_bool((X),(Y),240) +#define get_csv2_int_pos240(X,Y) get_csv2_int((X),(Y),240) +#define get_csv2_llong_pos240(X,Y) get_csv2_llong((X),(Y),240) +#define get_csv2_float_pos240(X,Y) get_csv2_float((X),(Y),240) +#define get_csv2_uint_pos241(X,Y) get_csv2_uint((X),(Y),241) +#define get_csv2_ullong_pos241(X,Y) get_csv2_ullong((X),(Y),241) +#define get_csv2_ip_pos241(X,Y) get_csv2_ip((X),(Y),241) +#define get_csv2_ipv6_pos241(X,Y) get_csv2_ipv6((X),(Y),241) +#define get_csv2_string_pos241(X,Y) get_csv2_string((X),(Y),241) +#define get_csv2_v_str_pos241(X,Y) get_csv2_string((X),(Y),241) +#define get_csv2_bool_pos241(X,Y) get_csv2_bool((X),(Y),241) +#define get_csv2_int_pos241(X,Y) get_csv2_int((X),(Y),241) +#define get_csv2_llong_pos241(X,Y) get_csv2_llong((X),(Y),241) +#define get_csv2_float_pos241(X,Y) get_csv2_float((X),(Y),241) +#define get_csv2_uint_pos242(X,Y) get_csv2_uint((X),(Y),242) +#define get_csv2_ullong_pos242(X,Y) get_csv2_ullong((X),(Y),242) +#define get_csv2_ip_pos242(X,Y) get_csv2_ip((X),(Y),242) +#define get_csv2_ipv6_pos242(X,Y) get_csv2_ipv6((X),(Y),242) +#define get_csv2_string_pos242(X,Y) get_csv2_string((X),(Y),242) +#define get_csv2_v_str_pos242(X,Y) get_csv2_string((X),(Y),242) +#define get_csv2_bool_pos242(X,Y) get_csv2_bool((X),(Y),242) +#define get_csv2_int_pos242(X,Y) get_csv2_int((X),(Y),242) +#define get_csv2_llong_pos242(X,Y) get_csv2_llong((X),(Y),242) +#define get_csv2_float_pos242(X,Y) get_csv2_float((X),(Y),242) +#define get_csv2_uint_pos243(X,Y) get_csv2_uint((X),(Y),243) +#define get_csv2_ullong_pos243(X,Y) get_csv2_ullong((X),(Y),243) +#define get_csv2_ip_pos243(X,Y) get_csv2_ip((X),(Y),243) +#define get_csv2_ipv6_pos243(X,Y) get_csv2_ipv6((X),(Y),243) +#define get_csv2_string_pos243(X,Y) get_csv2_string((X),(Y),243) +#define get_csv2_v_str_pos243(X,Y) get_csv2_string((X),(Y),243) +#define get_csv2_bool_pos243(X,Y) get_csv2_bool((X),(Y),243) +#define get_csv2_int_pos243(X,Y) get_csv2_int((X),(Y),243) +#define get_csv2_llong_pos243(X,Y) get_csv2_llong((X),(Y),243) +#define get_csv2_float_pos243(X,Y) get_csv2_float((X),(Y),243) +#define get_csv2_uint_pos244(X,Y) get_csv2_uint((X),(Y),244) +#define get_csv2_ullong_pos244(X,Y) get_csv2_ullong((X),(Y),244) +#define get_csv2_ip_pos244(X,Y) get_csv2_ip((X),(Y),244) +#define get_csv2_ipv6_pos244(X,Y) get_csv2_ipv6((X),(Y),244) +#define get_csv2_string_pos244(X,Y) get_csv2_string((X),(Y),244) +#define get_csv2_v_str_pos244(X,Y) get_csv2_string((X),(Y),244) +#define get_csv2_bool_pos244(X,Y) get_csv2_bool((X),(Y),244) +#define get_csv2_int_pos244(X,Y) get_csv2_int((X),(Y),244) +#define get_csv2_llong_pos244(X,Y) get_csv2_llong((X),(Y),244) +#define get_csv2_float_pos244(X,Y) get_csv2_float((X),(Y),244) +#define get_csv2_uint_pos245(X,Y) get_csv2_uint((X),(Y),245) +#define get_csv2_ullong_pos245(X,Y) get_csv2_ullong((X),(Y),245) +#define get_csv2_ip_pos245(X,Y) get_csv2_ip((X),(Y),245) +#define get_csv2_ipv6_pos245(X,Y) get_csv2_ipv6((X),(Y),245) +#define get_csv2_string_pos245(X,Y) get_csv2_string((X),(Y),245) +#define get_csv2_v_str_pos245(X,Y) get_csv2_string((X),(Y),245) +#define get_csv2_bool_pos245(X,Y) get_csv2_bool((X),(Y),245) +#define get_csv2_int_pos245(X,Y) get_csv2_int((X),(Y),245) +#define get_csv2_llong_pos245(X,Y) get_csv2_llong((X),(Y),245) +#define get_csv2_float_pos245(X,Y) get_csv2_float((X),(Y),245) +#define get_csv2_uint_pos246(X,Y) get_csv2_uint((X),(Y),246) +#define get_csv2_ullong_pos246(X,Y) get_csv2_ullong((X),(Y),246) +#define get_csv2_ip_pos246(X,Y) get_csv2_ip((X),(Y),246) +#define get_csv2_ipv6_pos246(X,Y) get_csv2_ipv6((X),(Y),246) +#define get_csv2_string_pos246(X,Y) get_csv2_string((X),(Y),246) +#define get_csv2_v_str_pos246(X,Y) get_csv2_string((X),(Y),246) +#define get_csv2_bool_pos246(X,Y) get_csv2_bool((X),(Y),246) +#define get_csv2_int_pos246(X,Y) get_csv2_int((X),(Y),246) +#define get_csv2_llong_pos246(X,Y) get_csv2_llong((X),(Y),246) +#define get_csv2_float_pos246(X,Y) get_csv2_float((X),(Y),246) +#define get_csv2_uint_pos247(X,Y) get_csv2_uint((X),(Y),247) +#define get_csv2_ullong_pos247(X,Y) get_csv2_ullong((X),(Y),247) +#define get_csv2_ip_pos247(X,Y) get_csv2_ip((X),(Y),247) +#define get_csv2_ipv6_pos247(X,Y) get_csv2_ipv6((X),(Y),247) +#define get_csv2_string_pos247(X,Y) get_csv2_string((X),(Y),247) +#define get_csv2_v_str_pos247(X,Y) get_csv2_string((X),(Y),247) +#define get_csv2_bool_pos247(X,Y) get_csv2_bool((X),(Y),247) +#define get_csv2_int_pos247(X,Y) get_csv2_int((X),(Y),247) +#define get_csv2_llong_pos247(X,Y) get_csv2_llong((X),(Y),247) +#define get_csv2_float_pos247(X,Y) get_csv2_float((X),(Y),247) +#define get_csv2_uint_pos248(X,Y) get_csv2_uint((X),(Y),248) +#define get_csv2_ullong_pos248(X,Y) get_csv2_ullong((X),(Y),248) +#define get_csv2_ip_pos248(X,Y) get_csv2_ip((X),(Y),248) +#define get_csv2_ipv6_pos248(X,Y) get_csv2_ipv6((X),(Y),248) +#define get_csv2_string_pos248(X,Y) get_csv2_string((X),(Y),248) +#define get_csv2_v_str_pos248(X,Y) get_csv2_string((X),(Y),248) +#define get_csv2_bool_pos248(X,Y) get_csv2_bool((X),(Y),248) +#define get_csv2_int_pos248(X,Y) get_csv2_int((X),(Y),248) +#define get_csv2_llong_pos248(X,Y) get_csv2_llong((X),(Y),248) +#define get_csv2_float_pos248(X,Y) get_csv2_float((X),(Y),248) +#define get_csv2_uint_pos249(X,Y) get_csv2_uint((X),(Y),249) +#define get_csv2_ullong_pos249(X,Y) get_csv2_ullong((X),(Y),249) +#define get_csv2_ip_pos249(X,Y) get_csv2_ip((X),(Y),249) +#define get_csv2_ipv6_pos249(X,Y) get_csv2_ipv6((X),(Y),249) +#define get_csv2_string_pos249(X,Y) get_csv2_string((X),(Y),249) +#define get_csv2_v_str_pos249(X,Y) get_csv2_string((X),(Y),249) +#define get_csv2_bool_pos249(X,Y) get_csv2_bool((X),(Y),249) +#define get_csv2_int_pos249(X,Y) get_csv2_int((X),(Y),249) +#define get_csv2_llong_pos249(X,Y) get_csv2_llong((X),(Y),249) +#define get_csv2_float_pos249(X,Y) get_csv2_float((X),(Y),249) +#define get_csv2_uint_pos250(X,Y) get_csv2_uint((X),(Y),250) +#define get_csv2_ullong_pos250(X,Y) get_csv2_ullong((X),(Y),250) +#define get_csv2_ip_pos250(X,Y) get_csv2_ip((X),(Y),250) +#define get_csv2_ipv6_pos250(X,Y) get_csv2_ipv6((X),(Y),250) +#define get_csv2_string_pos250(X,Y) get_csv2_string((X),(Y),250) +#define get_csv2_v_str_pos250(X,Y) get_csv2_string((X),(Y),250) +#define get_csv2_bool_pos250(X,Y) get_csv2_bool((X),(Y),250) +#define get_csv2_int_pos250(X,Y) get_csv2_int((X),(Y),250) +#define get_csv2_llong_pos250(X,Y) get_csv2_llong((X),(Y),250) +#define get_csv2_float_pos250(X,Y) get_csv2_float((X),(Y),250) +#define get_csv2_uint_pos251(X,Y) get_csv2_uint((X),(Y),251) +#define get_csv2_ullong_pos251(X,Y) get_csv2_ullong((X),(Y),251) +#define get_csv2_ip_pos251(X,Y) get_csv2_ip((X),(Y),251) +#define get_csv2_ipv6_pos251(X,Y) get_csv2_ipv6((X),(Y),251) +#define get_csv2_string_pos251(X,Y) get_csv2_string((X),(Y),251) +#define get_csv2_v_str_pos251(X,Y) get_csv2_string((X),(Y),251) +#define get_csv2_bool_pos251(X,Y) get_csv2_bool((X),(Y),251) +#define get_csv2_int_pos251(X,Y) get_csv2_int((X),(Y),251) +#define get_csv2_llong_pos251(X,Y) get_csv2_llong((X),(Y),251) +#define get_csv2_float_pos251(X,Y) get_csv2_float((X),(Y),251) +#define get_csv2_uint_pos252(X,Y) get_csv2_uint((X),(Y),252) +#define get_csv2_ullong_pos252(X,Y) get_csv2_ullong((X),(Y),252) +#define get_csv2_ip_pos252(X,Y) get_csv2_ip((X),(Y),252) +#define get_csv2_ipv6_pos252(X,Y) get_csv2_ipv6((X),(Y),252) +#define get_csv2_string_pos252(X,Y) get_csv2_string((X),(Y),252) +#define get_csv2_v_str_pos252(X,Y) get_csv2_string((X),(Y),252) +#define get_csv2_bool_pos252(X,Y) get_csv2_bool((X),(Y),252) +#define get_csv2_int_pos252(X,Y) get_csv2_int((X),(Y),252) +#define get_csv2_llong_pos252(X,Y) get_csv2_llong((X),(Y),252) +#define get_csv2_float_pos252(X,Y) get_csv2_float((X),(Y),252) +#define get_csv2_uint_pos253(X,Y) get_csv2_uint((X),(Y),253) +#define get_csv2_ullong_pos253(X,Y) get_csv2_ullong((X),(Y),253) +#define get_csv2_ip_pos253(X,Y) get_csv2_ip((X),(Y),253) +#define get_csv2_ipv6_pos253(X,Y) get_csv2_ipv6((X),(Y),253) +#define get_csv2_string_pos253(X,Y) get_csv2_string((X),(Y),253) +#define get_csv2_v_str_pos253(X,Y) get_csv2_string((X),(Y),253) +#define get_csv2_bool_pos253(X,Y) get_csv2_bool((X),(Y),253) +#define get_csv2_int_pos253(X,Y) get_csv2_int((X),(Y),253) +#define get_csv2_llong_pos253(X,Y) get_csv2_llong((X),(Y),253) +#define get_csv2_float_pos253(X,Y) get_csv2_float((X),(Y),253) +#define get_csv2_uint_pos254(X,Y) get_csv2_uint((X),(Y),254) +#define get_csv2_ullong_pos254(X,Y) get_csv2_ullong((X),(Y),254) +#define get_csv2_ip_pos254(X,Y) get_csv2_ip((X),(Y),254) +#define get_csv2_ipv6_pos254(X,Y) get_csv2_ipv6((X),(Y),254) +#define get_csv2_string_pos254(X,Y) get_csv2_string((X),(Y),254) +#define get_csv2_v_str_pos254(X,Y) get_csv2_string((X),(Y),254) +#define get_csv2_bool_pos254(X,Y) get_csv2_bool((X),(Y),254) +#define get_csv2_int_pos254(X,Y) get_csv2_int((X),(Y),254) +#define get_csv2_llong_pos254(X,Y) get_csv2_llong((X),(Y),254) +#define get_csv2_float_pos254(X,Y) get_csv2_float((X),(Y),254) +#define get_csv2_uint_pos255(X,Y) get_csv2_uint((X),(Y),255) +#define get_csv2_ullong_pos255(X,Y) get_csv2_ullong((X),(Y),255) +#define get_csv2_ip_pos255(X,Y) get_csv2_ip((X),(Y),255) +#define get_csv2_ipv6_pos255(X,Y) get_csv2_ipv6((X),(Y),255) +#define get_csv2_string_pos255(X,Y) get_csv2_string((X),(Y),255) +#define get_csv2_v_str_pos255(X,Y) get_csv2_string((X),(Y),255) +#define get_csv2_bool_pos255(X,Y) get_csv2_bool((X),(Y),255) +#define get_csv2_int_pos255(X,Y) get_csv2_int((X),(Y),255) +#define get_csv2_llong_pos255(X,Y) get_csv2_llong((X),(Y),255) +#define get_csv2_float_pos255(X,Y) get_csv2_float((X),(Y),255) +#define get_csv2_uint_pos256(X,Y) get_csv2_uint((X),(Y),256) +#define get_csv2_ullong_pos256(X,Y) get_csv2_ullong((X),(Y),256) +#define get_csv2_ip_pos256(X,Y) get_csv2_ip((X),(Y),256) +#define get_csv2_ipv6_pos256(X,Y) get_csv2_ipv6((X),(Y),256) +#define get_csv2_string_pos256(X,Y) get_csv2_string((X),(Y),256) +#define get_csv2_v_str_pos256(X,Y) get_csv2_string((X),(Y),256) +#define get_csv2_bool_pos256(X,Y) get_csv2_bool((X),(Y),256) +#define get_csv2_int_pos256(X,Y) get_csv2_int((X),(Y),256) +#define get_csv2_llong_pos256(X,Y) get_csv2_llong((X),(Y),256) +#define get_csv2_float_pos256(X,Y) get_csv2_float((X),(Y),256) +#define get_csv2_uint_pos257(X,Y) get_csv2_uint((X),(Y),257) +#define get_csv2_ullong_pos257(X,Y) get_csv2_ullong((X),(Y),257) +#define get_csv2_ip_pos257(X,Y) get_csv2_ip((X),(Y),257) +#define get_csv2_ipv6_pos257(X,Y) get_csv2_ipv6((X),(Y),257) +#define get_csv2_string_pos257(X,Y) get_csv2_string((X),(Y),257) +#define get_csv2_v_str_pos257(X,Y) get_csv2_string((X),(Y),257) +#define get_csv2_bool_pos257(X,Y) get_csv2_bool((X),(Y),257) +#define get_csv2_int_pos257(X,Y) get_csv2_int((X),(Y),257) +#define get_csv2_llong_pos257(X,Y) get_csv2_llong((X),(Y),257) +#define get_csv2_float_pos257(X,Y) get_csv2_float((X),(Y),257) +#define get_csv2_uint_pos258(X,Y) get_csv2_uint((X),(Y),258) +#define get_csv2_ullong_pos258(X,Y) get_csv2_ullong((X),(Y),258) +#define get_csv2_ip_pos258(X,Y) get_csv2_ip((X),(Y),258) +#define get_csv2_ipv6_pos258(X,Y) get_csv2_ipv6((X),(Y),258) +#define get_csv2_string_pos258(X,Y) get_csv2_string((X),(Y),258) +#define get_csv2_v_str_pos258(X,Y) get_csv2_string((X),(Y),258) +#define get_csv2_bool_pos258(X,Y) get_csv2_bool((X),(Y),258) +#define get_csv2_int_pos258(X,Y) get_csv2_int((X),(Y),258) +#define get_csv2_llong_pos258(X,Y) get_csv2_llong((X),(Y),258) +#define get_csv2_float_pos258(X,Y) get_csv2_float((X),(Y),258) +#define get_csv2_uint_pos259(X,Y) get_csv2_uint((X),(Y),259) +#define get_csv2_ullong_pos259(X,Y) get_csv2_ullong((X),(Y),259) +#define get_csv2_ip_pos259(X,Y) get_csv2_ip((X),(Y),259) +#define get_csv2_ipv6_pos259(X,Y) get_csv2_ipv6((X),(Y),259) +#define get_csv2_string_pos259(X,Y) get_csv2_string((X),(Y),259) +#define get_csv2_v_str_pos259(X,Y) get_csv2_string((X),(Y),259) +#define get_csv2_bool_pos259(X,Y) get_csv2_bool((X),(Y),259) +#define get_csv2_int_pos259(X,Y) get_csv2_int((X),(Y),259) +#define get_csv2_llong_pos259(X,Y) get_csv2_llong((X),(Y),259) +#define get_csv2_float_pos259(X,Y) get_csv2_float((X),(Y),259) +#define get_csv2_uint_pos260(X,Y) get_csv2_uint((X),(Y),260) +#define get_csv2_ullong_pos260(X,Y) get_csv2_ullong((X),(Y),260) +#define get_csv2_ip_pos260(X,Y) get_csv2_ip((X),(Y),260) +#define get_csv2_ipv6_pos260(X,Y) get_csv2_ipv6((X),(Y),260) +#define get_csv2_string_pos260(X,Y) get_csv2_string((X),(Y),260) +#define get_csv2_v_str_pos260(X,Y) get_csv2_string((X),(Y),260) +#define get_csv2_bool_pos260(X,Y) get_csv2_bool((X),(Y),260) +#define get_csv2_int_pos260(X,Y) get_csv2_int((X),(Y),260) +#define get_csv2_llong_pos260(X,Y) get_csv2_llong((X),(Y),260) +#define get_csv2_float_pos260(X,Y) get_csv2_float((X),(Y),260) +#define get_csv2_uint_pos261(X,Y) get_csv2_uint((X),(Y),261) +#define get_csv2_ullong_pos261(X,Y) get_csv2_ullong((X),(Y),261) +#define get_csv2_ip_pos261(X,Y) get_csv2_ip((X),(Y),261) +#define get_csv2_ipv6_pos261(X,Y) get_csv2_ipv6((X),(Y),261) +#define get_csv2_string_pos261(X,Y) get_csv2_string((X),(Y),261) +#define get_csv2_v_str_pos261(X,Y) get_csv2_string((X),(Y),261) +#define get_csv2_bool_pos261(X,Y) get_csv2_bool((X),(Y),261) +#define get_csv2_int_pos261(X,Y) get_csv2_int((X),(Y),261) +#define get_csv2_llong_pos261(X,Y) get_csv2_llong((X),(Y),261) +#define get_csv2_float_pos261(X,Y) get_csv2_float((X),(Y),261) +#define get_csv2_uint_pos262(X,Y) get_csv2_uint((X),(Y),262) +#define get_csv2_ullong_pos262(X,Y) get_csv2_ullong((X),(Y),262) +#define get_csv2_ip_pos262(X,Y) get_csv2_ip((X),(Y),262) +#define get_csv2_ipv6_pos262(X,Y) get_csv2_ipv6((X),(Y),262) +#define get_csv2_string_pos262(X,Y) get_csv2_string((X),(Y),262) +#define get_csv2_v_str_pos262(X,Y) get_csv2_string((X),(Y),262) +#define get_csv2_bool_pos262(X,Y) get_csv2_bool((X),(Y),262) +#define get_csv2_int_pos262(X,Y) get_csv2_int((X),(Y),262) +#define get_csv2_llong_pos262(X,Y) get_csv2_llong((X),(Y),262) +#define get_csv2_float_pos262(X,Y) get_csv2_float((X),(Y),262) +#define get_csv2_uint_pos263(X,Y) get_csv2_uint((X),(Y),263) +#define get_csv2_ullong_pos263(X,Y) get_csv2_ullong((X),(Y),263) +#define get_csv2_ip_pos263(X,Y) get_csv2_ip((X),(Y),263) +#define get_csv2_ipv6_pos263(X,Y) get_csv2_ipv6((X),(Y),263) +#define get_csv2_string_pos263(X,Y) get_csv2_string((X),(Y),263) +#define get_csv2_v_str_pos263(X,Y) get_csv2_string((X),(Y),263) +#define get_csv2_bool_pos263(X,Y) get_csv2_bool((X),(Y),263) +#define get_csv2_int_pos263(X,Y) get_csv2_int((X),(Y),263) +#define get_csv2_llong_pos263(X,Y) get_csv2_llong((X),(Y),263) +#define get_csv2_float_pos263(X,Y) get_csv2_float((X),(Y),263) +#define get_csv2_uint_pos264(X,Y) get_csv2_uint((X),(Y),264) +#define get_csv2_ullong_pos264(X,Y) get_csv2_ullong((X),(Y),264) +#define get_csv2_ip_pos264(X,Y) get_csv2_ip((X),(Y),264) +#define get_csv2_ipv6_pos264(X,Y) get_csv2_ipv6((X),(Y),264) +#define get_csv2_string_pos264(X,Y) get_csv2_string((X),(Y),264) +#define get_csv2_v_str_pos264(X,Y) get_csv2_string((X),(Y),264) +#define get_csv2_bool_pos264(X,Y) get_csv2_bool((X),(Y),264) +#define get_csv2_int_pos264(X,Y) get_csv2_int((X),(Y),264) +#define get_csv2_llong_pos264(X,Y) get_csv2_llong((X),(Y),264) +#define get_csv2_float_pos264(X,Y) get_csv2_float((X),(Y),264) +#define get_csv2_uint_pos265(X,Y) get_csv2_uint((X),(Y),265) +#define get_csv2_ullong_pos265(X,Y) get_csv2_ullong((X),(Y),265) +#define get_csv2_ip_pos265(X,Y) get_csv2_ip((X),(Y),265) +#define get_csv2_ipv6_pos265(X,Y) get_csv2_ipv6((X),(Y),265) +#define get_csv2_string_pos265(X,Y) get_csv2_string((X),(Y),265) +#define get_csv2_v_str_pos265(X,Y) get_csv2_string((X),(Y),265) +#define get_csv2_bool_pos265(X,Y) get_csv2_bool((X),(Y),265) +#define get_csv2_int_pos265(X,Y) get_csv2_int((X),(Y),265) +#define get_csv2_llong_pos265(X,Y) get_csv2_llong((X),(Y),265) +#define get_csv2_float_pos265(X,Y) get_csv2_float((X),(Y),265) +#define get_csv2_uint_pos266(X,Y) get_csv2_uint((X),(Y),266) +#define get_csv2_ullong_pos266(X,Y) get_csv2_ullong((X),(Y),266) +#define get_csv2_ip_pos266(X,Y) get_csv2_ip((X),(Y),266) +#define get_csv2_ipv6_pos266(X,Y) get_csv2_ipv6((X),(Y),266) +#define get_csv2_string_pos266(X,Y) get_csv2_string((X),(Y),266) +#define get_csv2_v_str_pos266(X,Y) get_csv2_string((X),(Y),266) +#define get_csv2_bool_pos266(X,Y) get_csv2_bool((X),(Y),266) +#define get_csv2_int_pos266(X,Y) get_csv2_int((X),(Y),266) +#define get_csv2_llong_pos266(X,Y) get_csv2_llong((X),(Y),266) +#define get_csv2_float_pos266(X,Y) get_csv2_float((X),(Y),266) +#define get_csv2_uint_pos267(X,Y) get_csv2_uint((X),(Y),267) +#define get_csv2_ullong_pos267(X,Y) get_csv2_ullong((X),(Y),267) +#define get_csv2_ip_pos267(X,Y) get_csv2_ip((X),(Y),267) +#define get_csv2_ipv6_pos267(X,Y) get_csv2_ipv6((X),(Y),267) +#define get_csv2_string_pos267(X,Y) get_csv2_string((X),(Y),267) +#define get_csv2_v_str_pos267(X,Y) get_csv2_string((X),(Y),267) +#define get_csv2_bool_pos267(X,Y) get_csv2_bool((X),(Y),267) +#define get_csv2_int_pos267(X,Y) get_csv2_int((X),(Y),267) +#define get_csv2_llong_pos267(X,Y) get_csv2_llong((X),(Y),267) +#define get_csv2_float_pos267(X,Y) get_csv2_float((X),(Y),267) +#define get_csv2_uint_pos268(X,Y) get_csv2_uint((X),(Y),268) +#define get_csv2_ullong_pos268(X,Y) get_csv2_ullong((X),(Y),268) +#define get_csv2_ip_pos268(X,Y) get_csv2_ip((X),(Y),268) +#define get_csv2_ipv6_pos268(X,Y) get_csv2_ipv6((X),(Y),268) +#define get_csv2_string_pos268(X,Y) get_csv2_string((X),(Y),268) +#define get_csv2_v_str_pos268(X,Y) get_csv2_string((X),(Y),268) +#define get_csv2_bool_pos268(X,Y) get_csv2_bool((X),(Y),268) +#define get_csv2_int_pos268(X,Y) get_csv2_int((X),(Y),268) +#define get_csv2_llong_pos268(X,Y) get_csv2_llong((X),(Y),268) +#define get_csv2_float_pos268(X,Y) get_csv2_float((X),(Y),268) +#define get_csv2_uint_pos269(X,Y) get_csv2_uint((X),(Y),269) +#define get_csv2_ullong_pos269(X,Y) get_csv2_ullong((X),(Y),269) +#define get_csv2_ip_pos269(X,Y) get_csv2_ip((X),(Y),269) +#define get_csv2_ipv6_pos269(X,Y) get_csv2_ipv6((X),(Y),269) +#define get_csv2_string_pos269(X,Y) get_csv2_string((X),(Y),269) +#define get_csv2_v_str_pos269(X,Y) get_csv2_string((X),(Y),269) +#define get_csv2_bool_pos269(X,Y) get_csv2_bool((X),(Y),269) +#define get_csv2_int_pos269(X,Y) get_csv2_int((X),(Y),269) +#define get_csv2_llong_pos269(X,Y) get_csv2_llong((X),(Y),269) +#define get_csv2_float_pos269(X,Y) get_csv2_float((X),(Y),269) +#define get_csv2_uint_pos270(X,Y) get_csv2_uint((X),(Y),270) +#define get_csv2_ullong_pos270(X,Y) get_csv2_ullong((X),(Y),270) +#define get_csv2_ip_pos270(X,Y) get_csv2_ip((X),(Y),270) +#define get_csv2_ipv6_pos270(X,Y) get_csv2_ipv6((X),(Y),270) +#define get_csv2_string_pos270(X,Y) get_csv2_string((X),(Y),270) +#define get_csv2_v_str_pos270(X,Y) get_csv2_string((X),(Y),270) +#define get_csv2_bool_pos270(X,Y) get_csv2_bool((X),(Y),270) +#define get_csv2_int_pos270(X,Y) get_csv2_int((X),(Y),270) +#define get_csv2_llong_pos270(X,Y) get_csv2_llong((X),(Y),270) +#define get_csv2_float_pos270(X,Y) get_csv2_float((X),(Y),270) +#define get_csv2_uint_pos271(X,Y) get_csv2_uint((X),(Y),271) +#define get_csv2_ullong_pos271(X,Y) get_csv2_ullong((X),(Y),271) +#define get_csv2_ip_pos271(X,Y) get_csv2_ip((X),(Y),271) +#define get_csv2_ipv6_pos271(X,Y) get_csv2_ipv6((X),(Y),271) +#define get_csv2_string_pos271(X,Y) get_csv2_string((X),(Y),271) +#define get_csv2_v_str_pos271(X,Y) get_csv2_string((X),(Y),271) +#define get_csv2_bool_pos271(X,Y) get_csv2_bool((X),(Y),271) +#define get_csv2_int_pos271(X,Y) get_csv2_int((X),(Y),271) +#define get_csv2_llong_pos271(X,Y) get_csv2_llong((X),(Y),271) +#define get_csv2_float_pos271(X,Y) get_csv2_float((X),(Y),271) +#define get_csv2_uint_pos272(X,Y) get_csv2_uint((X),(Y),272) +#define get_csv2_ullong_pos272(X,Y) get_csv2_ullong((X),(Y),272) +#define get_csv2_ip_pos272(X,Y) get_csv2_ip((X),(Y),272) +#define get_csv2_ipv6_pos272(X,Y) get_csv2_ipv6((X),(Y),272) +#define get_csv2_string_pos272(X,Y) get_csv2_string((X),(Y),272) +#define get_csv2_v_str_pos272(X,Y) get_csv2_string((X),(Y),272) +#define get_csv2_bool_pos272(X,Y) get_csv2_bool((X),(Y),272) +#define get_csv2_int_pos272(X,Y) get_csv2_int((X),(Y),272) +#define get_csv2_llong_pos272(X,Y) get_csv2_llong((X),(Y),272) +#define get_csv2_float_pos272(X,Y) get_csv2_float((X),(Y),272) +#define get_csv2_uint_pos273(X,Y) get_csv2_uint((X),(Y),273) +#define get_csv2_ullong_pos273(X,Y) get_csv2_ullong((X),(Y),273) +#define get_csv2_ip_pos273(X,Y) get_csv2_ip((X),(Y),273) +#define get_csv2_ipv6_pos273(X,Y) get_csv2_ipv6((X),(Y),273) +#define get_csv2_string_pos273(X,Y) get_csv2_string((X),(Y),273) +#define get_csv2_v_str_pos273(X,Y) get_csv2_string((X),(Y),273) +#define get_csv2_bool_pos273(X,Y) get_csv2_bool((X),(Y),273) +#define get_csv2_int_pos273(X,Y) get_csv2_int((X),(Y),273) +#define get_csv2_llong_pos273(X,Y) get_csv2_llong((X),(Y),273) +#define get_csv2_float_pos273(X,Y) get_csv2_float((X),(Y),273) +#define get_csv2_uint_pos274(X,Y) get_csv2_uint((X),(Y),274) +#define get_csv2_ullong_pos274(X,Y) get_csv2_ullong((X),(Y),274) +#define get_csv2_ip_pos274(X,Y) get_csv2_ip((X),(Y),274) +#define get_csv2_ipv6_pos274(X,Y) get_csv2_ipv6((X),(Y),274) +#define get_csv2_string_pos274(X,Y) get_csv2_string((X),(Y),274) +#define get_csv2_v_str_pos274(X,Y) get_csv2_string((X),(Y),274) +#define get_csv2_bool_pos274(X,Y) get_csv2_bool((X),(Y),274) +#define get_csv2_int_pos274(X,Y) get_csv2_int((X),(Y),274) +#define get_csv2_llong_pos274(X,Y) get_csv2_llong((X),(Y),274) +#define get_csv2_float_pos274(X,Y) get_csv2_float((X),(Y),274) +#define get_csv2_uint_pos275(X,Y) get_csv2_uint((X),(Y),275) +#define get_csv2_ullong_pos275(X,Y) get_csv2_ullong((X),(Y),275) +#define get_csv2_ip_pos275(X,Y) get_csv2_ip((X),(Y),275) +#define get_csv2_ipv6_pos275(X,Y) get_csv2_ipv6((X),(Y),275) +#define get_csv2_string_pos275(X,Y) get_csv2_string((X),(Y),275) +#define get_csv2_v_str_pos275(X,Y) get_csv2_string((X),(Y),275) +#define get_csv2_bool_pos275(X,Y) get_csv2_bool((X),(Y),275) +#define get_csv2_int_pos275(X,Y) get_csv2_int((X),(Y),275) +#define get_csv2_llong_pos275(X,Y) get_csv2_llong((X),(Y),275) +#define get_csv2_float_pos275(X,Y) get_csv2_float((X),(Y),275) +#define get_csv2_uint_pos276(X,Y) get_csv2_uint((X),(Y),276) +#define get_csv2_ullong_pos276(X,Y) get_csv2_ullong((X),(Y),276) +#define get_csv2_ip_pos276(X,Y) get_csv2_ip((X),(Y),276) +#define get_csv2_ipv6_pos276(X,Y) get_csv2_ipv6((X),(Y),276) +#define get_csv2_string_pos276(X,Y) get_csv2_string((X),(Y),276) +#define get_csv2_v_str_pos276(X,Y) get_csv2_string((X),(Y),276) +#define get_csv2_bool_pos276(X,Y) get_csv2_bool((X),(Y),276) +#define get_csv2_int_pos276(X,Y) get_csv2_int((X),(Y),276) +#define get_csv2_llong_pos276(X,Y) get_csv2_llong((X),(Y),276) +#define get_csv2_float_pos276(X,Y) get_csv2_float((X),(Y),276) +#define get_csv2_uint_pos277(X,Y) get_csv2_uint((X),(Y),277) +#define get_csv2_ullong_pos277(X,Y) get_csv2_ullong((X),(Y),277) +#define get_csv2_ip_pos277(X,Y) get_csv2_ip((X),(Y),277) +#define get_csv2_ipv6_pos277(X,Y) get_csv2_ipv6((X),(Y),277) +#define get_csv2_string_pos277(X,Y) get_csv2_string((X),(Y),277) +#define get_csv2_v_str_pos277(X,Y) get_csv2_string((X),(Y),277) +#define get_csv2_bool_pos277(X,Y) get_csv2_bool((X),(Y),277) +#define get_csv2_int_pos277(X,Y) get_csv2_int((X),(Y),277) +#define get_csv2_llong_pos277(X,Y) get_csv2_llong((X),(Y),277) +#define get_csv2_float_pos277(X,Y) get_csv2_float((X),(Y),277) +#define get_csv2_uint_pos278(X,Y) get_csv2_uint((X),(Y),278) +#define get_csv2_ullong_pos278(X,Y) get_csv2_ullong((X),(Y),278) +#define get_csv2_ip_pos278(X,Y) get_csv2_ip((X),(Y),278) +#define get_csv2_ipv6_pos278(X,Y) get_csv2_ipv6((X),(Y),278) +#define get_csv2_string_pos278(X,Y) get_csv2_string((X),(Y),278) +#define get_csv2_v_str_pos278(X,Y) get_csv2_string((X),(Y),278) +#define get_csv2_bool_pos278(X,Y) get_csv2_bool((X),(Y),278) +#define get_csv2_int_pos278(X,Y) get_csv2_int((X),(Y),278) +#define get_csv2_llong_pos278(X,Y) get_csv2_llong((X),(Y),278) +#define get_csv2_float_pos278(X,Y) get_csv2_float((X),(Y),278) +#define get_csv2_uint_pos279(X,Y) get_csv2_uint((X),(Y),279) +#define get_csv2_ullong_pos279(X,Y) get_csv2_ullong((X),(Y),279) +#define get_csv2_ip_pos279(X,Y) get_csv2_ip((X),(Y),279) +#define get_csv2_ipv6_pos279(X,Y) get_csv2_ipv6((X),(Y),279) +#define get_csv2_string_pos279(X,Y) get_csv2_string((X),(Y),279) +#define get_csv2_v_str_pos279(X,Y) get_csv2_string((X),(Y),279) +#define get_csv2_bool_pos279(X,Y) get_csv2_bool((X),(Y),279) +#define get_csv2_int_pos279(X,Y) get_csv2_int((X),(Y),279) +#define get_csv2_llong_pos279(X,Y) get_csv2_llong((X),(Y),279) +#define get_csv2_float_pos279(X,Y) get_csv2_float((X),(Y),279) +#define get_csv2_uint_pos280(X,Y) get_csv2_uint((X),(Y),280) +#define get_csv2_ullong_pos280(X,Y) get_csv2_ullong((X),(Y),280) +#define get_csv2_ip_pos280(X,Y) get_csv2_ip((X),(Y),280) +#define get_csv2_ipv6_pos280(X,Y) get_csv2_ipv6((X),(Y),280) +#define get_csv2_string_pos280(X,Y) get_csv2_string((X),(Y),280) +#define get_csv2_v_str_pos280(X,Y) get_csv2_string((X),(Y),280) +#define get_csv2_bool_pos280(X,Y) get_csv2_bool((X),(Y),280) +#define get_csv2_int_pos280(X,Y) get_csv2_int((X),(Y),280) +#define get_csv2_llong_pos280(X,Y) get_csv2_llong((X),(Y),280) +#define get_csv2_float_pos280(X,Y) get_csv2_float((X),(Y),280) +#define get_csv2_uint_pos281(X,Y) get_csv2_uint((X),(Y),281) +#define get_csv2_ullong_pos281(X,Y) get_csv2_ullong((X),(Y),281) +#define get_csv2_ip_pos281(X,Y) get_csv2_ip((X),(Y),281) +#define get_csv2_ipv6_pos281(X,Y) get_csv2_ipv6((X),(Y),281) +#define get_csv2_string_pos281(X,Y) get_csv2_string((X),(Y),281) +#define get_csv2_v_str_pos281(X,Y) get_csv2_string((X),(Y),281) +#define get_csv2_bool_pos281(X,Y) get_csv2_bool((X),(Y),281) +#define get_csv2_int_pos281(X,Y) get_csv2_int((X),(Y),281) +#define get_csv2_llong_pos281(X,Y) get_csv2_llong((X),(Y),281) +#define get_csv2_float_pos281(X,Y) get_csv2_float((X),(Y),281) +#define get_csv2_uint_pos282(X,Y) get_csv2_uint((X),(Y),282) +#define get_csv2_ullong_pos282(X,Y) get_csv2_ullong((X),(Y),282) +#define get_csv2_ip_pos282(X,Y) get_csv2_ip((X),(Y),282) +#define get_csv2_ipv6_pos282(X,Y) get_csv2_ipv6((X),(Y),282) +#define get_csv2_string_pos282(X,Y) get_csv2_string((X),(Y),282) +#define get_csv2_v_str_pos282(X,Y) get_csv2_string((X),(Y),282) +#define get_csv2_bool_pos282(X,Y) get_csv2_bool((X),(Y),282) +#define get_csv2_int_pos282(X,Y) get_csv2_int((X),(Y),282) +#define get_csv2_llong_pos282(X,Y) get_csv2_llong((X),(Y),282) +#define get_csv2_float_pos282(X,Y) get_csv2_float((X),(Y),282) +#define get_csv2_uint_pos283(X,Y) get_csv2_uint((X),(Y),283) +#define get_csv2_ullong_pos283(X,Y) get_csv2_ullong((X),(Y),283) +#define get_csv2_ip_pos283(X,Y) get_csv2_ip((X),(Y),283) +#define get_csv2_ipv6_pos283(X,Y) get_csv2_ipv6((X),(Y),283) +#define get_csv2_string_pos283(X,Y) get_csv2_string((X),(Y),283) +#define get_csv2_v_str_pos283(X,Y) get_csv2_string((X),(Y),283) +#define get_csv2_bool_pos283(X,Y) get_csv2_bool((X),(Y),283) +#define get_csv2_int_pos283(X,Y) get_csv2_int((X),(Y),283) +#define get_csv2_llong_pos283(X,Y) get_csv2_llong((X),(Y),283) +#define get_csv2_float_pos283(X,Y) get_csv2_float((X),(Y),283) +#define get_csv2_uint_pos284(X,Y) get_csv2_uint((X),(Y),284) +#define get_csv2_ullong_pos284(X,Y) get_csv2_ullong((X),(Y),284) +#define get_csv2_ip_pos284(X,Y) get_csv2_ip((X),(Y),284) +#define get_csv2_ipv6_pos284(X,Y) get_csv2_ipv6((X),(Y),284) +#define get_csv2_string_pos284(X,Y) get_csv2_string((X),(Y),284) +#define get_csv2_v_str_pos284(X,Y) get_csv2_string((X),(Y),284) +#define get_csv2_bool_pos284(X,Y) get_csv2_bool((X),(Y),284) +#define get_csv2_int_pos284(X,Y) get_csv2_int((X),(Y),284) +#define get_csv2_llong_pos284(X,Y) get_csv2_llong((X),(Y),284) +#define get_csv2_float_pos284(X,Y) get_csv2_float((X),(Y),284) +#define get_csv2_uint_pos285(X,Y) get_csv2_uint((X),(Y),285) +#define get_csv2_ullong_pos285(X,Y) get_csv2_ullong((X),(Y),285) +#define get_csv2_ip_pos285(X,Y) get_csv2_ip((X),(Y),285) +#define get_csv2_ipv6_pos285(X,Y) get_csv2_ipv6((X),(Y),285) +#define get_csv2_string_pos285(X,Y) get_csv2_string((X),(Y),285) +#define get_csv2_v_str_pos285(X,Y) get_csv2_string((X),(Y),285) +#define get_csv2_bool_pos285(X,Y) get_csv2_bool((X),(Y),285) +#define get_csv2_int_pos285(X,Y) get_csv2_int((X),(Y),285) +#define get_csv2_llong_pos285(X,Y) get_csv2_llong((X),(Y),285) +#define get_csv2_float_pos285(X,Y) get_csv2_float((X),(Y),285) +#define get_csv2_uint_pos286(X,Y) get_csv2_uint((X),(Y),286) +#define get_csv2_ullong_pos286(X,Y) get_csv2_ullong((X),(Y),286) +#define get_csv2_ip_pos286(X,Y) get_csv2_ip((X),(Y),286) +#define get_csv2_ipv6_pos286(X,Y) get_csv2_ipv6((X),(Y),286) +#define get_csv2_string_pos286(X,Y) get_csv2_string((X),(Y),286) +#define get_csv2_v_str_pos286(X,Y) get_csv2_string((X),(Y),286) +#define get_csv2_bool_pos286(X,Y) get_csv2_bool((X),(Y),286) +#define get_csv2_int_pos286(X,Y) get_csv2_int((X),(Y),286) +#define get_csv2_llong_pos286(X,Y) get_csv2_llong((X),(Y),286) +#define get_csv2_float_pos286(X,Y) get_csv2_float((X),(Y),286) +#define get_csv2_uint_pos287(X,Y) get_csv2_uint((X),(Y),287) +#define get_csv2_ullong_pos287(X,Y) get_csv2_ullong((X),(Y),287) +#define get_csv2_ip_pos287(X,Y) get_csv2_ip((X),(Y),287) +#define get_csv2_ipv6_pos287(X,Y) get_csv2_ipv6((X),(Y),287) +#define get_csv2_string_pos287(X,Y) get_csv2_string((X),(Y),287) +#define get_csv2_v_str_pos287(X,Y) get_csv2_string((X),(Y),287) +#define get_csv2_bool_pos287(X,Y) get_csv2_bool((X),(Y),287) +#define get_csv2_int_pos287(X,Y) get_csv2_int((X),(Y),287) +#define get_csv2_llong_pos287(X,Y) get_csv2_llong((X),(Y),287) +#define get_csv2_float_pos287(X,Y) get_csv2_float((X),(Y),287) +#define get_csv2_uint_pos288(X,Y) get_csv2_uint((X),(Y),288) +#define get_csv2_ullong_pos288(X,Y) get_csv2_ullong((X),(Y),288) +#define get_csv2_ip_pos288(X,Y) get_csv2_ip((X),(Y),288) +#define get_csv2_ipv6_pos288(X,Y) get_csv2_ipv6((X),(Y),288) +#define get_csv2_string_pos288(X,Y) get_csv2_string((X),(Y),288) +#define get_csv2_v_str_pos288(X,Y) get_csv2_string((X),(Y),288) +#define get_csv2_bool_pos288(X,Y) get_csv2_bool((X),(Y),288) +#define get_csv2_int_pos288(X,Y) get_csv2_int((X),(Y),288) +#define get_csv2_llong_pos288(X,Y) get_csv2_llong((X),(Y),288) +#define get_csv2_float_pos288(X,Y) get_csv2_float((X),(Y),288) +#define get_csv2_uint_pos289(X,Y) get_csv2_uint((X),(Y),289) +#define get_csv2_ullong_pos289(X,Y) get_csv2_ullong((X),(Y),289) +#define get_csv2_ip_pos289(X,Y) get_csv2_ip((X),(Y),289) +#define get_csv2_ipv6_pos289(X,Y) get_csv2_ipv6((X),(Y),289) +#define get_csv2_string_pos289(X,Y) get_csv2_string((X),(Y),289) +#define get_csv2_v_str_pos289(X,Y) get_csv2_string((X),(Y),289) +#define get_csv2_bool_pos289(X,Y) get_csv2_bool((X),(Y),289) +#define get_csv2_int_pos289(X,Y) get_csv2_int((X),(Y),289) +#define get_csv2_llong_pos289(X,Y) get_csv2_llong((X),(Y),289) +#define get_csv2_float_pos289(X,Y) get_csv2_float((X),(Y),289) +#define get_csv2_uint_pos290(X,Y) get_csv2_uint((X),(Y),290) +#define get_csv2_ullong_pos290(X,Y) get_csv2_ullong((X),(Y),290) +#define get_csv2_ip_pos290(X,Y) get_csv2_ip((X),(Y),290) +#define get_csv2_ipv6_pos290(X,Y) get_csv2_ipv6((X),(Y),290) +#define get_csv2_string_pos290(X,Y) get_csv2_string((X),(Y),290) +#define get_csv2_v_str_pos290(X,Y) get_csv2_string((X),(Y),290) +#define get_csv2_bool_pos290(X,Y) get_csv2_bool((X),(Y),290) +#define get_csv2_int_pos290(X,Y) get_csv2_int((X),(Y),290) +#define get_csv2_llong_pos290(X,Y) get_csv2_llong((X),(Y),290) +#define get_csv2_float_pos290(X,Y) get_csv2_float((X),(Y),290) +#define get_csv2_uint_pos291(X,Y) get_csv2_uint((X),(Y),291) +#define get_csv2_ullong_pos291(X,Y) get_csv2_ullong((X),(Y),291) +#define get_csv2_ip_pos291(X,Y) get_csv2_ip((X),(Y),291) +#define get_csv2_ipv6_pos291(X,Y) get_csv2_ipv6((X),(Y),291) +#define get_csv2_string_pos291(X,Y) get_csv2_string((X),(Y),291) +#define get_csv2_v_str_pos291(X,Y) get_csv2_string((X),(Y),291) +#define get_csv2_bool_pos291(X,Y) get_csv2_bool((X),(Y),291) +#define get_csv2_int_pos291(X,Y) get_csv2_int((X),(Y),291) +#define get_csv2_llong_pos291(X,Y) get_csv2_llong((X),(Y),291) +#define get_csv2_float_pos291(X,Y) get_csv2_float((X),(Y),291) +#define get_csv2_uint_pos292(X,Y) get_csv2_uint((X),(Y),292) +#define get_csv2_ullong_pos292(X,Y) get_csv2_ullong((X),(Y),292) +#define get_csv2_ip_pos292(X,Y) get_csv2_ip((X),(Y),292) +#define get_csv2_ipv6_pos292(X,Y) get_csv2_ipv6((X),(Y),292) +#define get_csv2_string_pos292(X,Y) get_csv2_string((X),(Y),292) +#define get_csv2_v_str_pos292(X,Y) get_csv2_string((X),(Y),292) +#define get_csv2_bool_pos292(X,Y) get_csv2_bool((X),(Y),292) +#define get_csv2_int_pos292(X,Y) get_csv2_int((X),(Y),292) +#define get_csv2_llong_pos292(X,Y) get_csv2_llong((X),(Y),292) +#define get_csv2_float_pos292(X,Y) get_csv2_float((X),(Y),292) +#define get_csv2_uint_pos293(X,Y) get_csv2_uint((X),(Y),293) +#define get_csv2_ullong_pos293(X,Y) get_csv2_ullong((X),(Y),293) +#define get_csv2_ip_pos293(X,Y) get_csv2_ip((X),(Y),293) +#define get_csv2_ipv6_pos293(X,Y) get_csv2_ipv6((X),(Y),293) +#define get_csv2_string_pos293(X,Y) get_csv2_string((X),(Y),293) +#define get_csv2_v_str_pos293(X,Y) get_csv2_string((X),(Y),293) +#define get_csv2_bool_pos293(X,Y) get_csv2_bool((X),(Y),293) +#define get_csv2_int_pos293(X,Y) get_csv2_int((X),(Y),293) +#define get_csv2_llong_pos293(X,Y) get_csv2_llong((X),(Y),293) +#define get_csv2_float_pos293(X,Y) get_csv2_float((X),(Y),293) +#define get_csv2_uint_pos294(X,Y) get_csv2_uint((X),(Y),294) +#define get_csv2_ullong_pos294(X,Y) get_csv2_ullong((X),(Y),294) +#define get_csv2_ip_pos294(X,Y) get_csv2_ip((X),(Y),294) +#define get_csv2_ipv6_pos294(X,Y) get_csv2_ipv6((X),(Y),294) +#define get_csv2_string_pos294(X,Y) get_csv2_string((X),(Y),294) +#define get_csv2_v_str_pos294(X,Y) get_csv2_string((X),(Y),294) +#define get_csv2_bool_pos294(X,Y) get_csv2_bool((X),(Y),294) +#define get_csv2_int_pos294(X,Y) get_csv2_int((X),(Y),294) +#define get_csv2_llong_pos294(X,Y) get_csv2_llong((X),(Y),294) +#define get_csv2_float_pos294(X,Y) get_csv2_float((X),(Y),294) +#define get_csv2_uint_pos295(X,Y) get_csv2_uint((X),(Y),295) +#define get_csv2_ullong_pos295(X,Y) get_csv2_ullong((X),(Y),295) +#define get_csv2_ip_pos295(X,Y) get_csv2_ip((X),(Y),295) +#define get_csv2_ipv6_pos295(X,Y) get_csv2_ipv6((X),(Y),295) +#define get_csv2_string_pos295(X,Y) get_csv2_string((X),(Y),295) +#define get_csv2_v_str_pos295(X,Y) get_csv2_string((X),(Y),295) +#define get_csv2_bool_pos295(X,Y) get_csv2_bool((X),(Y),295) +#define get_csv2_int_pos295(X,Y) get_csv2_int((X),(Y),295) +#define get_csv2_llong_pos295(X,Y) get_csv2_llong((X),(Y),295) +#define get_csv2_float_pos295(X,Y) get_csv2_float((X),(Y),295) +#define get_csv2_uint_pos296(X,Y) get_csv2_uint((X),(Y),296) +#define get_csv2_ullong_pos296(X,Y) get_csv2_ullong((X),(Y),296) +#define get_csv2_ip_pos296(X,Y) get_csv2_ip((X),(Y),296) +#define get_csv2_ipv6_pos296(X,Y) get_csv2_ipv6((X),(Y),296) +#define get_csv2_string_pos296(X,Y) get_csv2_string((X),(Y),296) +#define get_csv2_v_str_pos296(X,Y) get_csv2_string((X),(Y),296) +#define get_csv2_bool_pos296(X,Y) get_csv2_bool((X),(Y),296) +#define get_csv2_int_pos296(X,Y) get_csv2_int((X),(Y),296) +#define get_csv2_llong_pos296(X,Y) get_csv2_llong((X),(Y),296) +#define get_csv2_float_pos296(X,Y) get_csv2_float((X),(Y),296) +#define get_csv2_uint_pos297(X,Y) get_csv2_uint((X),(Y),297) +#define get_csv2_ullong_pos297(X,Y) get_csv2_ullong((X),(Y),297) +#define get_csv2_ip_pos297(X,Y) get_csv2_ip((X),(Y),297) +#define get_csv2_ipv6_pos297(X,Y) get_csv2_ipv6((X),(Y),297) +#define get_csv2_string_pos297(X,Y) get_csv2_string((X),(Y),297) +#define get_csv2_v_str_pos297(X,Y) get_csv2_string((X),(Y),297) +#define get_csv2_bool_pos297(X,Y) get_csv2_bool((X),(Y),297) +#define get_csv2_int_pos297(X,Y) get_csv2_int((X),(Y),297) +#define get_csv2_llong_pos297(X,Y) get_csv2_llong((X),(Y),297) +#define get_csv2_float_pos297(X,Y) get_csv2_float((X),(Y),297) +#define get_csv2_uint_pos298(X,Y) get_csv2_uint((X),(Y),298) +#define get_csv2_ullong_pos298(X,Y) get_csv2_ullong((X),(Y),298) +#define get_csv2_ip_pos298(X,Y) get_csv2_ip((X),(Y),298) +#define get_csv2_ipv6_pos298(X,Y) get_csv2_ipv6((X),(Y),298) +#define get_csv2_string_pos298(X,Y) get_csv2_string((X),(Y),298) +#define get_csv2_v_str_pos298(X,Y) get_csv2_string((X),(Y),298) +#define get_csv2_bool_pos298(X,Y) get_csv2_bool((X),(Y),298) +#define get_csv2_int_pos298(X,Y) get_csv2_int((X),(Y),298) +#define get_csv2_llong_pos298(X,Y) get_csv2_llong((X),(Y),298) +#define get_csv2_float_pos298(X,Y) get_csv2_float((X),(Y),298) +#define get_csv2_uint_pos299(X,Y) get_csv2_uint((X),(Y),299) +#define get_csv2_ullong_pos299(X,Y) get_csv2_ullong((X),(Y),299) +#define get_csv2_ip_pos299(X,Y) get_csv2_ip((X),(Y),299) +#define get_csv2_ipv6_pos299(X,Y) get_csv2_ipv6((X),(Y),299) +#define get_csv2_string_pos299(X,Y) get_csv2_string((X),(Y),299) +#define get_csv2_v_str_pos299(X,Y) get_csv2_string((X),(Y),299) +#define get_csv2_bool_pos299(X,Y) get_csv2_bool((X),(Y),299) +#define get_csv2_int_pos299(X,Y) get_csv2_int((X),(Y),299) +#define get_csv2_llong_pos299(X,Y) get_csv2_llong((X),(Y),299) +#define get_csv2_float_pos299(X,Y) get_csv2_float((X),(Y),299) +#define get_csv2_uint_pos300(X,Y) get_csv2_uint((X),(Y),300) +#define get_csv2_ullong_pos300(X,Y) get_csv2_ullong((X),(Y),300) +#define get_csv2_ip_pos300(X,Y) get_csv2_ip((X),(Y),300) +#define get_csv2_ipv6_pos300(X,Y) get_csv2_ipv6((X),(Y),300) +#define get_csv2_string_pos300(X,Y) get_csv2_string((X),(Y),300) +#define get_csv2_v_str_pos300(X,Y) get_csv2_string((X),(Y),300) +#define get_csv2_bool_pos300(X,Y) get_csv2_bool((X),(Y),300) +#define get_csv2_int_pos300(X,Y) get_csv2_int((X),(Y),300) +#define get_csv2_llong_pos300(X,Y) get_csv2_llong((X),(Y),300) +#define get_csv2_float_pos300(X,Y) get_csv2_float((X),(Y),300) +#define get_csv2_uint_pos301(X,Y) get_csv2_uint((X),(Y),301) +#define get_csv2_ullong_pos301(X,Y) get_csv2_ullong((X),(Y),301) +#define get_csv2_ip_pos301(X,Y) get_csv2_ip((X),(Y),301) +#define get_csv2_ipv6_pos301(X,Y) get_csv2_ipv6((X),(Y),301) +#define get_csv2_string_pos301(X,Y) get_csv2_string((X),(Y),301) +#define get_csv2_v_str_pos301(X,Y) get_csv2_string((X),(Y),301) +#define get_csv2_bool_pos301(X,Y) get_csv2_bool((X),(Y),301) +#define get_csv2_int_pos301(X,Y) get_csv2_int((X),(Y),301) +#define get_csv2_llong_pos301(X,Y) get_csv2_llong((X),(Y),301) +#define get_csv2_float_pos301(X,Y) get_csv2_float((X),(Y),301) +#define get_csv2_uint_pos302(X,Y) get_csv2_uint((X),(Y),302) +#define get_csv2_ullong_pos302(X,Y) get_csv2_ullong((X),(Y),302) +#define get_csv2_ip_pos302(X,Y) get_csv2_ip((X),(Y),302) +#define get_csv2_ipv6_pos302(X,Y) get_csv2_ipv6((X),(Y),302) +#define get_csv2_string_pos302(X,Y) get_csv2_string((X),(Y),302) +#define get_csv2_v_str_pos302(X,Y) get_csv2_string((X),(Y),302) +#define get_csv2_bool_pos302(X,Y) get_csv2_bool((X),(Y),302) +#define get_csv2_int_pos302(X,Y) get_csv2_int((X),(Y),302) +#define get_csv2_llong_pos302(X,Y) get_csv2_llong((X),(Y),302) +#define get_csv2_float_pos302(X,Y) get_csv2_float((X),(Y),302) +#define get_csv2_uint_pos303(X,Y) get_csv2_uint((X),(Y),303) +#define get_csv2_ullong_pos303(X,Y) get_csv2_ullong((X),(Y),303) +#define get_csv2_ip_pos303(X,Y) get_csv2_ip((X),(Y),303) +#define get_csv2_ipv6_pos303(X,Y) get_csv2_ipv6((X),(Y),303) +#define get_csv2_string_pos303(X,Y) get_csv2_string((X),(Y),303) +#define get_csv2_v_str_pos303(X,Y) get_csv2_string((X),(Y),303) +#define get_csv2_bool_pos303(X,Y) get_csv2_bool((X),(Y),303) +#define get_csv2_int_pos303(X,Y) get_csv2_int((X),(Y),303) +#define get_csv2_llong_pos303(X,Y) get_csv2_llong((X),(Y),303) +#define get_csv2_float_pos303(X,Y) get_csv2_float((X),(Y),303) +#define get_csv2_uint_pos304(X,Y) get_csv2_uint((X),(Y),304) +#define get_csv2_ullong_pos304(X,Y) get_csv2_ullong((X),(Y),304) +#define get_csv2_ip_pos304(X,Y) get_csv2_ip((X),(Y),304) +#define get_csv2_ipv6_pos304(X,Y) get_csv2_ipv6((X),(Y),304) +#define get_csv2_string_pos304(X,Y) get_csv2_string((X),(Y),304) +#define get_csv2_v_str_pos304(X,Y) get_csv2_string((X),(Y),304) +#define get_csv2_bool_pos304(X,Y) get_csv2_bool((X),(Y),304) +#define get_csv2_int_pos304(X,Y) get_csv2_int((X),(Y),304) +#define get_csv2_llong_pos304(X,Y) get_csv2_llong((X),(Y),304) +#define get_csv2_float_pos304(X,Y) get_csv2_float((X),(Y),304) +#define get_csv2_uint_pos305(X,Y) get_csv2_uint((X),(Y),305) +#define get_csv2_ullong_pos305(X,Y) get_csv2_ullong((X),(Y),305) +#define get_csv2_ip_pos305(X,Y) get_csv2_ip((X),(Y),305) +#define get_csv2_ipv6_pos305(X,Y) get_csv2_ipv6((X),(Y),305) +#define get_csv2_string_pos305(X,Y) get_csv2_string((X),(Y),305) +#define get_csv2_v_str_pos305(X,Y) get_csv2_string((X),(Y),305) +#define get_csv2_bool_pos305(X,Y) get_csv2_bool((X),(Y),305) +#define get_csv2_int_pos305(X,Y) get_csv2_int((X),(Y),305) +#define get_csv2_llong_pos305(X,Y) get_csv2_llong((X),(Y),305) +#define get_csv2_float_pos305(X,Y) get_csv2_float((X),(Y),305) +#define get_csv2_uint_pos306(X,Y) get_csv2_uint((X),(Y),306) +#define get_csv2_ullong_pos306(X,Y) get_csv2_ullong((X),(Y),306) +#define get_csv2_ip_pos306(X,Y) get_csv2_ip((X),(Y),306) +#define get_csv2_ipv6_pos306(X,Y) get_csv2_ipv6((X),(Y),306) +#define get_csv2_string_pos306(X,Y) get_csv2_string((X),(Y),306) +#define get_csv2_v_str_pos306(X,Y) get_csv2_string((X),(Y),306) +#define get_csv2_bool_pos306(X,Y) get_csv2_bool((X),(Y),306) +#define get_csv2_int_pos306(X,Y) get_csv2_int((X),(Y),306) +#define get_csv2_llong_pos306(X,Y) get_csv2_llong((X),(Y),306) +#define get_csv2_float_pos306(X,Y) get_csv2_float((X),(Y),306) +#define get_csv2_uint_pos307(X,Y) get_csv2_uint((X),(Y),307) +#define get_csv2_ullong_pos307(X,Y) get_csv2_ullong((X),(Y),307) +#define get_csv2_ip_pos307(X,Y) get_csv2_ip((X),(Y),307) +#define get_csv2_ipv6_pos307(X,Y) get_csv2_ipv6((X),(Y),307) +#define get_csv2_string_pos307(X,Y) get_csv2_string((X),(Y),307) +#define get_csv2_v_str_pos307(X,Y) get_csv2_string((X),(Y),307) +#define get_csv2_bool_pos307(X,Y) get_csv2_bool((X),(Y),307) +#define get_csv2_int_pos307(X,Y) get_csv2_int((X),(Y),307) +#define get_csv2_llong_pos307(X,Y) get_csv2_llong((X),(Y),307) +#define get_csv2_float_pos307(X,Y) get_csv2_float((X),(Y),307) +#define get_csv2_uint_pos308(X,Y) get_csv2_uint((X),(Y),308) +#define get_csv2_ullong_pos308(X,Y) get_csv2_ullong((X),(Y),308) +#define get_csv2_ip_pos308(X,Y) get_csv2_ip((X),(Y),308) +#define get_csv2_ipv6_pos308(X,Y) get_csv2_ipv6((X),(Y),308) +#define get_csv2_string_pos308(X,Y) get_csv2_string((X),(Y),308) +#define get_csv2_v_str_pos308(X,Y) get_csv2_string((X),(Y),308) +#define get_csv2_bool_pos308(X,Y) get_csv2_bool((X),(Y),308) +#define get_csv2_int_pos308(X,Y) get_csv2_int((X),(Y),308) +#define get_csv2_llong_pos308(X,Y) get_csv2_llong((X),(Y),308) +#define get_csv2_float_pos308(X,Y) get_csv2_float((X),(Y),308) +#define get_csv2_uint_pos309(X,Y) get_csv2_uint((X),(Y),309) +#define get_csv2_ullong_pos309(X,Y) get_csv2_ullong((X),(Y),309) +#define get_csv2_ip_pos309(X,Y) get_csv2_ip((X),(Y),309) +#define get_csv2_ipv6_pos309(X,Y) get_csv2_ipv6((X),(Y),309) +#define get_csv2_string_pos309(X,Y) get_csv2_string((X),(Y),309) +#define get_csv2_v_str_pos309(X,Y) get_csv2_string((X),(Y),309) +#define get_csv2_bool_pos309(X,Y) get_csv2_bool((X),(Y),309) +#define get_csv2_int_pos309(X,Y) get_csv2_int((X),(Y),309) +#define get_csv2_llong_pos309(X,Y) get_csv2_llong((X),(Y),309) +#define get_csv2_float_pos309(X,Y) get_csv2_float((X),(Y),309) +#define get_csv2_uint_pos310(X,Y) get_csv2_uint((X),(Y),310) +#define get_csv2_ullong_pos310(X,Y) get_csv2_ullong((X),(Y),310) +#define get_csv2_ip_pos310(X,Y) get_csv2_ip((X),(Y),310) +#define get_csv2_ipv6_pos310(X,Y) get_csv2_ipv6((X),(Y),310) +#define get_csv2_string_pos310(X,Y) get_csv2_string((X),(Y),310) +#define get_csv2_v_str_pos310(X,Y) get_csv2_string((X),(Y),310) +#define get_csv2_bool_pos310(X,Y) get_csv2_bool((X),(Y),310) +#define get_csv2_int_pos310(X,Y) get_csv2_int((X),(Y),310) +#define get_csv2_llong_pos310(X,Y) get_csv2_llong((X),(Y),310) +#define get_csv2_float_pos310(X,Y) get_csv2_float((X),(Y),310) +#define get_csv2_uint_pos311(X,Y) get_csv2_uint((X),(Y),311) +#define get_csv2_ullong_pos311(X,Y) get_csv2_ullong((X),(Y),311) +#define get_csv2_ip_pos311(X,Y) get_csv2_ip((X),(Y),311) +#define get_csv2_ipv6_pos311(X,Y) get_csv2_ipv6((X),(Y),311) +#define get_csv2_string_pos311(X,Y) get_csv2_string((X),(Y),311) +#define get_csv2_v_str_pos311(X,Y) get_csv2_string((X),(Y),311) +#define get_csv2_bool_pos311(X,Y) get_csv2_bool((X),(Y),311) +#define get_csv2_int_pos311(X,Y) get_csv2_int((X),(Y),311) +#define get_csv2_llong_pos311(X,Y) get_csv2_llong((X),(Y),311) +#define get_csv2_float_pos311(X,Y) get_csv2_float((X),(Y),311) +#define get_csv2_uint_pos312(X,Y) get_csv2_uint((X),(Y),312) +#define get_csv2_ullong_pos312(X,Y) get_csv2_ullong((X),(Y),312) +#define get_csv2_ip_pos312(X,Y) get_csv2_ip((X),(Y),312) +#define get_csv2_ipv6_pos312(X,Y) get_csv2_ipv6((X),(Y),312) +#define get_csv2_string_pos312(X,Y) get_csv2_string((X),(Y),312) +#define get_csv2_v_str_pos312(X,Y) get_csv2_string((X),(Y),312) +#define get_csv2_bool_pos312(X,Y) get_csv2_bool((X),(Y),312) +#define get_csv2_int_pos312(X,Y) get_csv2_int((X),(Y),312) +#define get_csv2_llong_pos312(X,Y) get_csv2_llong((X),(Y),312) +#define get_csv2_float_pos312(X,Y) get_csv2_float((X),(Y),312) +#define get_csv2_uint_pos313(X,Y) get_csv2_uint((X),(Y),313) +#define get_csv2_ullong_pos313(X,Y) get_csv2_ullong((X),(Y),313) +#define get_csv2_ip_pos313(X,Y) get_csv2_ip((X),(Y),313) +#define get_csv2_ipv6_pos313(X,Y) get_csv2_ipv6((X),(Y),313) +#define get_csv2_string_pos313(X,Y) get_csv2_string((X),(Y),313) +#define get_csv2_v_str_pos313(X,Y) get_csv2_string((X),(Y),313) +#define get_csv2_bool_pos313(X,Y) get_csv2_bool((X),(Y),313) +#define get_csv2_int_pos313(X,Y) get_csv2_int((X),(Y),313) +#define get_csv2_llong_pos313(X,Y) get_csv2_llong((X),(Y),313) +#define get_csv2_float_pos313(X,Y) get_csv2_float((X),(Y),313) +#define get_csv2_uint_pos314(X,Y) get_csv2_uint((X),(Y),314) +#define get_csv2_ullong_pos314(X,Y) get_csv2_ullong((X),(Y),314) +#define get_csv2_ip_pos314(X,Y) get_csv2_ip((X),(Y),314) +#define get_csv2_ipv6_pos314(X,Y) get_csv2_ipv6((X),(Y),314) +#define get_csv2_string_pos314(X,Y) get_csv2_string((X),(Y),314) +#define get_csv2_v_str_pos314(X,Y) get_csv2_string((X),(Y),314) +#define get_csv2_bool_pos314(X,Y) get_csv2_bool((X),(Y),314) +#define get_csv2_int_pos314(X,Y) get_csv2_int((X),(Y),314) +#define get_csv2_llong_pos314(X,Y) get_csv2_llong((X),(Y),314) +#define get_csv2_float_pos314(X,Y) get_csv2_float((X),(Y),314) +#define get_csv2_uint_pos315(X,Y) get_csv2_uint((X),(Y),315) +#define get_csv2_ullong_pos315(X,Y) get_csv2_ullong((X),(Y),315) +#define get_csv2_ip_pos315(X,Y) get_csv2_ip((X),(Y),315) +#define get_csv2_ipv6_pos315(X,Y) get_csv2_ipv6((X),(Y),315) +#define get_csv2_string_pos315(X,Y) get_csv2_string((X),(Y),315) +#define get_csv2_v_str_pos315(X,Y) get_csv2_string((X),(Y),315) +#define get_csv2_bool_pos315(X,Y) get_csv2_bool((X),(Y),315) +#define get_csv2_int_pos315(X,Y) get_csv2_int((X),(Y),315) +#define get_csv2_llong_pos315(X,Y) get_csv2_llong((X),(Y),315) +#define get_csv2_float_pos315(X,Y) get_csv2_float((X),(Y),315) +#define get_csv2_uint_pos316(X,Y) get_csv2_uint((X),(Y),316) +#define get_csv2_ullong_pos316(X,Y) get_csv2_ullong((X),(Y),316) +#define get_csv2_ip_pos316(X,Y) get_csv2_ip((X),(Y),316) +#define get_csv2_ipv6_pos316(X,Y) get_csv2_ipv6((X),(Y),316) +#define get_csv2_string_pos316(X,Y) get_csv2_string((X),(Y),316) +#define get_csv2_v_str_pos316(X,Y) get_csv2_string((X),(Y),316) +#define get_csv2_bool_pos316(X,Y) get_csv2_bool((X),(Y),316) +#define get_csv2_int_pos316(X,Y) get_csv2_int((X),(Y),316) +#define get_csv2_llong_pos316(X,Y) get_csv2_llong((X),(Y),316) +#define get_csv2_float_pos316(X,Y) get_csv2_float((X),(Y),316) +#define get_csv2_uint_pos317(X,Y) get_csv2_uint((X),(Y),317) +#define get_csv2_ullong_pos317(X,Y) get_csv2_ullong((X),(Y),317) +#define get_csv2_ip_pos317(X,Y) get_csv2_ip((X),(Y),317) +#define get_csv2_ipv6_pos317(X,Y) get_csv2_ipv6((X),(Y),317) +#define get_csv2_string_pos317(X,Y) get_csv2_string((X),(Y),317) +#define get_csv2_v_str_pos317(X,Y) get_csv2_string((X),(Y),317) +#define get_csv2_bool_pos317(X,Y) get_csv2_bool((X),(Y),317) +#define get_csv2_int_pos317(X,Y) get_csv2_int((X),(Y),317) +#define get_csv2_llong_pos317(X,Y) get_csv2_llong((X),(Y),317) +#define get_csv2_float_pos317(X,Y) get_csv2_float((X),(Y),317) +#define get_csv2_uint_pos318(X,Y) get_csv2_uint((X),(Y),318) +#define get_csv2_ullong_pos318(X,Y) get_csv2_ullong((X),(Y),318) +#define get_csv2_ip_pos318(X,Y) get_csv2_ip((X),(Y),318) +#define get_csv2_ipv6_pos318(X,Y) get_csv2_ipv6((X),(Y),318) +#define get_csv2_string_pos318(X,Y) get_csv2_string((X),(Y),318) +#define get_csv2_v_str_pos318(X,Y) get_csv2_string((X),(Y),318) +#define get_csv2_bool_pos318(X,Y) get_csv2_bool((X),(Y),318) +#define get_csv2_int_pos318(X,Y) get_csv2_int((X),(Y),318) +#define get_csv2_llong_pos318(X,Y) get_csv2_llong((X),(Y),318) +#define get_csv2_float_pos318(X,Y) get_csv2_float((X),(Y),318) +#define get_csv2_uint_pos319(X,Y) get_csv2_uint((X),(Y),319) +#define get_csv2_ullong_pos319(X,Y) get_csv2_ullong((X),(Y),319) +#define get_csv2_ip_pos319(X,Y) get_csv2_ip((X),(Y),319) +#define get_csv2_ipv6_pos319(X,Y) get_csv2_ipv6((X),(Y),319) +#define get_csv2_string_pos319(X,Y) get_csv2_string((X),(Y),319) +#define get_csv2_v_str_pos319(X,Y) get_csv2_string((X),(Y),319) +#define get_csv2_bool_pos319(X,Y) get_csv2_bool((X),(Y),319) +#define get_csv2_int_pos319(X,Y) get_csv2_int((X),(Y),319) +#define get_csv2_llong_pos319(X,Y) get_csv2_llong((X),(Y),319) +#define get_csv2_float_pos319(X,Y) get_csv2_float((X),(Y),319) +#define get_csv2_uint_pos320(X,Y) get_csv2_uint((X),(Y),320) +#define get_csv2_ullong_pos320(X,Y) get_csv2_ullong((X),(Y),320) +#define get_csv2_ip_pos320(X,Y) get_csv2_ip((X),(Y),320) +#define get_csv2_ipv6_pos320(X,Y) get_csv2_ipv6((X),(Y),320) +#define get_csv2_string_pos320(X,Y) get_csv2_string((X),(Y),320) +#define get_csv2_v_str_pos320(X,Y) get_csv2_string((X),(Y),320) +#define get_csv2_bool_pos320(X,Y) get_csv2_bool((X),(Y),320) +#define get_csv2_int_pos320(X,Y) get_csv2_int((X),(Y),320) +#define get_csv2_llong_pos320(X,Y) get_csv2_llong((X),(Y),320) +#define get_csv2_float_pos320(X,Y) get_csv2_float((X),(Y),320) +#define get_csv2_uint_pos321(X,Y) get_csv2_uint((X),(Y),321) +#define get_csv2_ullong_pos321(X,Y) get_csv2_ullong((X),(Y),321) +#define get_csv2_ip_pos321(X,Y) get_csv2_ip((X),(Y),321) +#define get_csv2_ipv6_pos321(X,Y) get_csv2_ipv6((X),(Y),321) +#define get_csv2_string_pos321(X,Y) get_csv2_string((X),(Y),321) +#define get_csv2_v_str_pos321(X,Y) get_csv2_string((X),(Y),321) +#define get_csv2_bool_pos321(X,Y) get_csv2_bool((X),(Y),321) +#define get_csv2_int_pos321(X,Y) get_csv2_int((X),(Y),321) +#define get_csv2_llong_pos321(X,Y) get_csv2_llong((X),(Y),321) +#define get_csv2_float_pos321(X,Y) get_csv2_float((X),(Y),321) +#define get_csv2_uint_pos322(X,Y) get_csv2_uint((X),(Y),322) +#define get_csv2_ullong_pos322(X,Y) get_csv2_ullong((X),(Y),322) +#define get_csv2_ip_pos322(X,Y) get_csv2_ip((X),(Y),322) +#define get_csv2_ipv6_pos322(X,Y) get_csv2_ipv6((X),(Y),322) +#define get_csv2_string_pos322(X,Y) get_csv2_string((X),(Y),322) +#define get_csv2_v_str_pos322(X,Y) get_csv2_string((X),(Y),322) +#define get_csv2_bool_pos322(X,Y) get_csv2_bool((X),(Y),322) +#define get_csv2_int_pos322(X,Y) get_csv2_int((X),(Y),322) +#define get_csv2_llong_pos322(X,Y) get_csv2_llong((X),(Y),322) +#define get_csv2_float_pos322(X,Y) get_csv2_float((X),(Y),322) +#define get_csv2_uint_pos323(X,Y) get_csv2_uint((X),(Y),323) +#define get_csv2_ullong_pos323(X,Y) get_csv2_ullong((X),(Y),323) +#define get_csv2_ip_pos323(X,Y) get_csv2_ip((X),(Y),323) +#define get_csv2_ipv6_pos323(X,Y) get_csv2_ipv6((X),(Y),323) +#define get_csv2_string_pos323(X,Y) get_csv2_string((X),(Y),323) +#define get_csv2_v_str_pos323(X,Y) get_csv2_string((X),(Y),323) +#define get_csv2_bool_pos323(X,Y) get_csv2_bool((X),(Y),323) +#define get_csv2_int_pos323(X,Y) get_csv2_int((X),(Y),323) +#define get_csv2_llong_pos323(X,Y) get_csv2_llong((X),(Y),323) +#define get_csv2_float_pos323(X,Y) get_csv2_float((X),(Y),323) +#define get_csv2_uint_pos324(X,Y) get_csv2_uint((X),(Y),324) +#define get_csv2_ullong_pos324(X,Y) get_csv2_ullong((X),(Y),324) +#define get_csv2_ip_pos324(X,Y) get_csv2_ip((X),(Y),324) +#define get_csv2_ipv6_pos324(X,Y) get_csv2_ipv6((X),(Y),324) +#define get_csv2_string_pos324(X,Y) get_csv2_string((X),(Y),324) +#define get_csv2_v_str_pos324(X,Y) get_csv2_string((X),(Y),324) +#define get_csv2_bool_pos324(X,Y) get_csv2_bool((X),(Y),324) +#define get_csv2_int_pos324(X,Y) get_csv2_int((X),(Y),324) +#define get_csv2_llong_pos324(X,Y) get_csv2_llong((X),(Y),324) +#define get_csv2_float_pos324(X,Y) get_csv2_float((X),(Y),324) +#define get_csv2_uint_pos325(X,Y) get_csv2_uint((X),(Y),325) +#define get_csv2_ullong_pos325(X,Y) get_csv2_ullong((X),(Y),325) +#define get_csv2_ip_pos325(X,Y) get_csv2_ip((X),(Y),325) +#define get_csv2_ipv6_pos325(X,Y) get_csv2_ipv6((X),(Y),325) +#define get_csv2_string_pos325(X,Y) get_csv2_string((X),(Y),325) +#define get_csv2_v_str_pos325(X,Y) get_csv2_string((X),(Y),325) +#define get_csv2_bool_pos325(X,Y) get_csv2_bool((X),(Y),325) +#define get_csv2_int_pos325(X,Y) get_csv2_int((X),(Y),325) +#define get_csv2_llong_pos325(X,Y) get_csv2_llong((X),(Y),325) +#define get_csv2_float_pos325(X,Y) get_csv2_float((X),(Y),325) +#define get_csv2_uint_pos326(X,Y) get_csv2_uint((X),(Y),326) +#define get_csv2_ullong_pos326(X,Y) get_csv2_ullong((X),(Y),326) +#define get_csv2_ip_pos326(X,Y) get_csv2_ip((X),(Y),326) +#define get_csv2_ipv6_pos326(X,Y) get_csv2_ipv6((X),(Y),326) +#define get_csv2_string_pos326(X,Y) get_csv2_string((X),(Y),326) +#define get_csv2_v_str_pos326(X,Y) get_csv2_string((X),(Y),326) +#define get_csv2_bool_pos326(X,Y) get_csv2_bool((X),(Y),326) +#define get_csv2_int_pos326(X,Y) get_csv2_int((X),(Y),326) +#define get_csv2_llong_pos326(X,Y) get_csv2_llong((X),(Y),326) +#define get_csv2_float_pos326(X,Y) get_csv2_float((X),(Y),326) +#define get_csv2_uint_pos327(X,Y) get_csv2_uint((X),(Y),327) +#define get_csv2_ullong_pos327(X,Y) get_csv2_ullong((X),(Y),327) +#define get_csv2_ip_pos327(X,Y) get_csv2_ip((X),(Y),327) +#define get_csv2_ipv6_pos327(X,Y) get_csv2_ipv6((X),(Y),327) +#define get_csv2_string_pos327(X,Y) get_csv2_string((X),(Y),327) +#define get_csv2_v_str_pos327(X,Y) get_csv2_string((X),(Y),327) +#define get_csv2_bool_pos327(X,Y) get_csv2_bool((X),(Y),327) +#define get_csv2_int_pos327(X,Y) get_csv2_int((X),(Y),327) +#define get_csv2_llong_pos327(X,Y) get_csv2_llong((X),(Y),327) +#define get_csv2_float_pos327(X,Y) get_csv2_float((X),(Y),327) +#define get_csv2_uint_pos328(X,Y) get_csv2_uint((X),(Y),328) +#define get_csv2_ullong_pos328(X,Y) get_csv2_ullong((X),(Y),328) +#define get_csv2_ip_pos328(X,Y) get_csv2_ip((X),(Y),328) +#define get_csv2_ipv6_pos328(X,Y) get_csv2_ipv6((X),(Y),328) +#define get_csv2_string_pos328(X,Y) get_csv2_string((X),(Y),328) +#define get_csv2_v_str_pos328(X,Y) get_csv2_string((X),(Y),328) +#define get_csv2_bool_pos328(X,Y) get_csv2_bool((X),(Y),328) +#define get_csv2_int_pos328(X,Y) get_csv2_int((X),(Y),328) +#define get_csv2_llong_pos328(X,Y) get_csv2_llong((X),(Y),328) +#define get_csv2_float_pos328(X,Y) get_csv2_float((X),(Y),328) +#define get_csv2_uint_pos329(X,Y) get_csv2_uint((X),(Y),329) +#define get_csv2_ullong_pos329(X,Y) get_csv2_ullong((X),(Y),329) +#define get_csv2_ip_pos329(X,Y) get_csv2_ip((X),(Y),329) +#define get_csv2_ipv6_pos329(X,Y) get_csv2_ipv6((X),(Y),329) +#define get_csv2_string_pos329(X,Y) get_csv2_string((X),(Y),329) +#define get_csv2_v_str_pos329(X,Y) get_csv2_string((X),(Y),329) +#define get_csv2_bool_pos329(X,Y) get_csv2_bool((X),(Y),329) +#define get_csv2_int_pos329(X,Y) get_csv2_int((X),(Y),329) +#define get_csv2_llong_pos329(X,Y) get_csv2_llong((X),(Y),329) +#define get_csv2_float_pos329(X,Y) get_csv2_float((X),(Y),329) +#define get_csv2_uint_pos330(X,Y) get_csv2_uint((X),(Y),330) +#define get_csv2_ullong_pos330(X,Y) get_csv2_ullong((X),(Y),330) +#define get_csv2_ip_pos330(X,Y) get_csv2_ip((X),(Y),330) +#define get_csv2_ipv6_pos330(X,Y) get_csv2_ipv6((X),(Y),330) +#define get_csv2_string_pos330(X,Y) get_csv2_string((X),(Y),330) +#define get_csv2_v_str_pos330(X,Y) get_csv2_string((X),(Y),330) +#define get_csv2_bool_pos330(X,Y) get_csv2_bool((X),(Y),330) +#define get_csv2_int_pos330(X,Y) get_csv2_int((X),(Y),330) +#define get_csv2_llong_pos330(X,Y) get_csv2_llong((X),(Y),330) +#define get_csv2_float_pos330(X,Y) get_csv2_float((X),(Y),330) +#define get_csv2_uint_pos331(X,Y) get_csv2_uint((X),(Y),331) +#define get_csv2_ullong_pos331(X,Y) get_csv2_ullong((X),(Y),331) +#define get_csv2_ip_pos331(X,Y) get_csv2_ip((X),(Y),331) +#define get_csv2_ipv6_pos331(X,Y) get_csv2_ipv6((X),(Y),331) +#define get_csv2_string_pos331(X,Y) get_csv2_string((X),(Y),331) +#define get_csv2_v_str_pos331(X,Y) get_csv2_string((X),(Y),331) +#define get_csv2_bool_pos331(X,Y) get_csv2_bool((X),(Y),331) +#define get_csv2_int_pos331(X,Y) get_csv2_int((X),(Y),331) +#define get_csv2_llong_pos331(X,Y) get_csv2_llong((X),(Y),331) +#define get_csv2_float_pos331(X,Y) get_csv2_float((X),(Y),331) +#define get_csv2_uint_pos332(X,Y) get_csv2_uint((X),(Y),332) +#define get_csv2_ullong_pos332(X,Y) get_csv2_ullong((X),(Y),332) +#define get_csv2_ip_pos332(X,Y) get_csv2_ip((X),(Y),332) +#define get_csv2_ipv6_pos332(X,Y) get_csv2_ipv6((X),(Y),332) +#define get_csv2_string_pos332(X,Y) get_csv2_string((X),(Y),332) +#define get_csv2_v_str_pos332(X,Y) get_csv2_string((X),(Y),332) +#define get_csv2_bool_pos332(X,Y) get_csv2_bool((X),(Y),332) +#define get_csv2_int_pos332(X,Y) get_csv2_int((X),(Y),332) +#define get_csv2_llong_pos332(X,Y) get_csv2_llong((X),(Y),332) +#define get_csv2_float_pos332(X,Y) get_csv2_float((X),(Y),332) +#define get_csv2_uint_pos333(X,Y) get_csv2_uint((X),(Y),333) +#define get_csv2_ullong_pos333(X,Y) get_csv2_ullong((X),(Y),333) +#define get_csv2_ip_pos333(X,Y) get_csv2_ip((X),(Y),333) +#define get_csv2_ipv6_pos333(X,Y) get_csv2_ipv6((X),(Y),333) +#define get_csv2_string_pos333(X,Y) get_csv2_string((X),(Y),333) +#define get_csv2_v_str_pos333(X,Y) get_csv2_string((X),(Y),333) +#define get_csv2_bool_pos333(X,Y) get_csv2_bool((X),(Y),333) +#define get_csv2_int_pos333(X,Y) get_csv2_int((X),(Y),333) +#define get_csv2_llong_pos333(X,Y) get_csv2_llong((X),(Y),333) +#define get_csv2_float_pos333(X,Y) get_csv2_float((X),(Y),333) +#define get_csv2_uint_pos334(X,Y) get_csv2_uint((X),(Y),334) +#define get_csv2_ullong_pos334(X,Y) get_csv2_ullong((X),(Y),334) +#define get_csv2_ip_pos334(X,Y) get_csv2_ip((X),(Y),334) +#define get_csv2_ipv6_pos334(X,Y) get_csv2_ipv6((X),(Y),334) +#define get_csv2_string_pos334(X,Y) get_csv2_string((X),(Y),334) +#define get_csv2_v_str_pos334(X,Y) get_csv2_string((X),(Y),334) +#define get_csv2_bool_pos334(X,Y) get_csv2_bool((X),(Y),334) +#define get_csv2_int_pos334(X,Y) get_csv2_int((X),(Y),334) +#define get_csv2_llong_pos334(X,Y) get_csv2_llong((X),(Y),334) +#define get_csv2_float_pos334(X,Y) get_csv2_float((X),(Y),334) +#define get_csv2_uint_pos335(X,Y) get_csv2_uint((X),(Y),335) +#define get_csv2_ullong_pos335(X,Y) get_csv2_ullong((X),(Y),335) +#define get_csv2_ip_pos335(X,Y) get_csv2_ip((X),(Y),335) +#define get_csv2_ipv6_pos335(X,Y) get_csv2_ipv6((X),(Y),335) +#define get_csv2_string_pos335(X,Y) get_csv2_string((X),(Y),335) +#define get_csv2_v_str_pos335(X,Y) get_csv2_string((X),(Y),335) +#define get_csv2_bool_pos335(X,Y) get_csv2_bool((X),(Y),335) +#define get_csv2_int_pos335(X,Y) get_csv2_int((X),(Y),335) +#define get_csv2_llong_pos335(X,Y) get_csv2_llong((X),(Y),335) +#define get_csv2_float_pos335(X,Y) get_csv2_float((X),(Y),335) +#define get_csv2_uint_pos336(X,Y) get_csv2_uint((X),(Y),336) +#define get_csv2_ullong_pos336(X,Y) get_csv2_ullong((X),(Y),336) +#define get_csv2_ip_pos336(X,Y) get_csv2_ip((X),(Y),336) +#define get_csv2_ipv6_pos336(X,Y) get_csv2_ipv6((X),(Y),336) +#define get_csv2_string_pos336(X,Y) get_csv2_string((X),(Y),336) +#define get_csv2_v_str_pos336(X,Y) get_csv2_string((X),(Y),336) +#define get_csv2_bool_pos336(X,Y) get_csv2_bool((X),(Y),336) +#define get_csv2_int_pos336(X,Y) get_csv2_int((X),(Y),336) +#define get_csv2_llong_pos336(X,Y) get_csv2_llong((X),(Y),336) +#define get_csv2_float_pos336(X,Y) get_csv2_float((X),(Y),336) +#define get_csv2_uint_pos337(X,Y) get_csv2_uint((X),(Y),337) +#define get_csv2_ullong_pos337(X,Y) get_csv2_ullong((X),(Y),337) +#define get_csv2_ip_pos337(X,Y) get_csv2_ip((X),(Y),337) +#define get_csv2_ipv6_pos337(X,Y) get_csv2_ipv6((X),(Y),337) +#define get_csv2_string_pos337(X,Y) get_csv2_string((X),(Y),337) +#define get_csv2_v_str_pos337(X,Y) get_csv2_string((X),(Y),337) +#define get_csv2_bool_pos337(X,Y) get_csv2_bool((X),(Y),337) +#define get_csv2_int_pos337(X,Y) get_csv2_int((X),(Y),337) +#define get_csv2_llong_pos337(X,Y) get_csv2_llong((X),(Y),337) +#define get_csv2_float_pos337(X,Y) get_csv2_float((X),(Y),337) +#define get_csv2_uint_pos338(X,Y) get_csv2_uint((X),(Y),338) +#define get_csv2_ullong_pos338(X,Y) get_csv2_ullong((X),(Y),338) +#define get_csv2_ip_pos338(X,Y) get_csv2_ip((X),(Y),338) +#define get_csv2_ipv6_pos338(X,Y) get_csv2_ipv6((X),(Y),338) +#define get_csv2_string_pos338(X,Y) get_csv2_string((X),(Y),338) +#define get_csv2_v_str_pos338(X,Y) get_csv2_string((X),(Y),338) +#define get_csv2_bool_pos338(X,Y) get_csv2_bool((X),(Y),338) +#define get_csv2_int_pos338(X,Y) get_csv2_int((X),(Y),338) +#define get_csv2_llong_pos338(X,Y) get_csv2_llong((X),(Y),338) +#define get_csv2_float_pos338(X,Y) get_csv2_float((X),(Y),338) +#define get_csv2_uint_pos339(X,Y) get_csv2_uint((X),(Y),339) +#define get_csv2_ullong_pos339(X,Y) get_csv2_ullong((X),(Y),339) +#define get_csv2_ip_pos339(X,Y) get_csv2_ip((X),(Y),339) +#define get_csv2_ipv6_pos339(X,Y) get_csv2_ipv6((X),(Y),339) +#define get_csv2_string_pos339(X,Y) get_csv2_string((X),(Y),339) +#define get_csv2_v_str_pos339(X,Y) get_csv2_string((X),(Y),339) +#define get_csv2_bool_pos339(X,Y) get_csv2_bool((X),(Y),339) +#define get_csv2_int_pos339(X,Y) get_csv2_int((X),(Y),339) +#define get_csv2_llong_pos339(X,Y) get_csv2_llong((X),(Y),339) +#define get_csv2_float_pos339(X,Y) get_csv2_float((X),(Y),339) +#define get_csv2_uint_pos340(X,Y) get_csv2_uint((X),(Y),340) +#define get_csv2_ullong_pos340(X,Y) get_csv2_ullong((X),(Y),340) +#define get_csv2_ip_pos340(X,Y) get_csv2_ip((X),(Y),340) +#define get_csv2_ipv6_pos340(X,Y) get_csv2_ipv6((X),(Y),340) +#define get_csv2_string_pos340(X,Y) get_csv2_string((X),(Y),340) +#define get_csv2_v_str_pos340(X,Y) get_csv2_string((X),(Y),340) +#define get_csv2_bool_pos340(X,Y) get_csv2_bool((X),(Y),340) +#define get_csv2_int_pos340(X,Y) get_csv2_int((X),(Y),340) +#define get_csv2_llong_pos340(X,Y) get_csv2_llong((X),(Y),340) +#define get_csv2_float_pos340(X,Y) get_csv2_float((X),(Y),340) +#define get_csv2_uint_pos341(X,Y) get_csv2_uint((X),(Y),341) +#define get_csv2_ullong_pos341(X,Y) get_csv2_ullong((X),(Y),341) +#define get_csv2_ip_pos341(X,Y) get_csv2_ip((X),(Y),341) +#define get_csv2_ipv6_pos341(X,Y) get_csv2_ipv6((X),(Y),341) +#define get_csv2_string_pos341(X,Y) get_csv2_string((X),(Y),341) +#define get_csv2_v_str_pos341(X,Y) get_csv2_string((X),(Y),341) +#define get_csv2_bool_pos341(X,Y) get_csv2_bool((X),(Y),341) +#define get_csv2_int_pos341(X,Y) get_csv2_int((X),(Y),341) +#define get_csv2_llong_pos341(X,Y) get_csv2_llong((X),(Y),341) +#define get_csv2_float_pos341(X,Y) get_csv2_float((X),(Y),341) +#define get_csv2_uint_pos342(X,Y) get_csv2_uint((X),(Y),342) +#define get_csv2_ullong_pos342(X,Y) get_csv2_ullong((X),(Y),342) +#define get_csv2_ip_pos342(X,Y) get_csv2_ip((X),(Y),342) +#define get_csv2_ipv6_pos342(X,Y) get_csv2_ipv6((X),(Y),342) +#define get_csv2_string_pos342(X,Y) get_csv2_string((X),(Y),342) +#define get_csv2_v_str_pos342(X,Y) get_csv2_string((X),(Y),342) +#define get_csv2_bool_pos342(X,Y) get_csv2_bool((X),(Y),342) +#define get_csv2_int_pos342(X,Y) get_csv2_int((X),(Y),342) +#define get_csv2_llong_pos342(X,Y) get_csv2_llong((X),(Y),342) +#define get_csv2_float_pos342(X,Y) get_csv2_float((X),(Y),342) +#define get_csv2_uint_pos343(X,Y) get_csv2_uint((X),(Y),343) +#define get_csv2_ullong_pos343(X,Y) get_csv2_ullong((X),(Y),343) +#define get_csv2_ip_pos343(X,Y) get_csv2_ip((X),(Y),343) +#define get_csv2_ipv6_pos343(X,Y) get_csv2_ipv6((X),(Y),343) +#define get_csv2_string_pos343(X,Y) get_csv2_string((X),(Y),343) +#define get_csv2_v_str_pos343(X,Y) get_csv2_string((X),(Y),343) +#define get_csv2_bool_pos343(X,Y) get_csv2_bool((X),(Y),343) +#define get_csv2_int_pos343(X,Y) get_csv2_int((X),(Y),343) +#define get_csv2_llong_pos343(X,Y) get_csv2_llong((X),(Y),343) +#define get_csv2_float_pos343(X,Y) get_csv2_float((X),(Y),343) +#define get_csv2_uint_pos344(X,Y) get_csv2_uint((X),(Y),344) +#define get_csv2_ullong_pos344(X,Y) get_csv2_ullong((X),(Y),344) +#define get_csv2_ip_pos344(X,Y) get_csv2_ip((X),(Y),344) +#define get_csv2_ipv6_pos344(X,Y) get_csv2_ipv6((X),(Y),344) +#define get_csv2_string_pos344(X,Y) get_csv2_string((X),(Y),344) +#define get_csv2_v_str_pos344(X,Y) get_csv2_string((X),(Y),344) +#define get_csv2_bool_pos344(X,Y) get_csv2_bool((X),(Y),344) +#define get_csv2_int_pos344(X,Y) get_csv2_int((X),(Y),344) +#define get_csv2_llong_pos344(X,Y) get_csv2_llong((X),(Y),344) +#define get_csv2_float_pos344(X,Y) get_csv2_float((X),(Y),344) +#define get_csv2_uint_pos345(X,Y) get_csv2_uint((X),(Y),345) +#define get_csv2_ullong_pos345(X,Y) get_csv2_ullong((X),(Y),345) +#define get_csv2_ip_pos345(X,Y) get_csv2_ip((X),(Y),345) +#define get_csv2_ipv6_pos345(X,Y) get_csv2_ipv6((X),(Y),345) +#define get_csv2_string_pos345(X,Y) get_csv2_string((X),(Y),345) +#define get_csv2_v_str_pos345(X,Y) get_csv2_string((X),(Y),345) +#define get_csv2_bool_pos345(X,Y) get_csv2_bool((X),(Y),345) +#define get_csv2_int_pos345(X,Y) get_csv2_int((X),(Y),345) +#define get_csv2_llong_pos345(X,Y) get_csv2_llong((X),(Y),345) +#define get_csv2_float_pos345(X,Y) get_csv2_float((X),(Y),345) +#define get_csv2_uint_pos346(X,Y) get_csv2_uint((X),(Y),346) +#define get_csv2_ullong_pos346(X,Y) get_csv2_ullong((X),(Y),346) +#define get_csv2_ip_pos346(X,Y) get_csv2_ip((X),(Y),346) +#define get_csv2_ipv6_pos346(X,Y) get_csv2_ipv6((X),(Y),346) +#define get_csv2_string_pos346(X,Y) get_csv2_string((X),(Y),346) +#define get_csv2_v_str_pos346(X,Y) get_csv2_string((X),(Y),346) +#define get_csv2_bool_pos346(X,Y) get_csv2_bool((X),(Y),346) +#define get_csv2_int_pos346(X,Y) get_csv2_int((X),(Y),346) +#define get_csv2_llong_pos346(X,Y) get_csv2_llong((X),(Y),346) +#define get_csv2_float_pos346(X,Y) get_csv2_float((X),(Y),346) +#define get_csv2_uint_pos347(X,Y) get_csv2_uint((X),(Y),347) +#define get_csv2_ullong_pos347(X,Y) get_csv2_ullong((X),(Y),347) +#define get_csv2_ip_pos347(X,Y) get_csv2_ip((X),(Y),347) +#define get_csv2_ipv6_pos347(X,Y) get_csv2_ipv6((X),(Y),347) +#define get_csv2_string_pos347(X,Y) get_csv2_string((X),(Y),347) +#define get_csv2_v_str_pos347(X,Y) get_csv2_string((X),(Y),347) +#define get_csv2_bool_pos347(X,Y) get_csv2_bool((X),(Y),347) +#define get_csv2_int_pos347(X,Y) get_csv2_int((X),(Y),347) +#define get_csv2_llong_pos347(X,Y) get_csv2_llong((X),(Y),347) +#define get_csv2_float_pos347(X,Y) get_csv2_float((X),(Y),347) +#define get_csv2_uint_pos348(X,Y) get_csv2_uint((X),(Y),348) +#define get_csv2_ullong_pos348(X,Y) get_csv2_ullong((X),(Y),348) +#define get_csv2_ip_pos348(X,Y) get_csv2_ip((X),(Y),348) +#define get_csv2_ipv6_pos348(X,Y) get_csv2_ipv6((X),(Y),348) +#define get_csv2_string_pos348(X,Y) get_csv2_string((X),(Y),348) +#define get_csv2_v_str_pos348(X,Y) get_csv2_string((X),(Y),348) +#define get_csv2_bool_pos348(X,Y) get_csv2_bool((X),(Y),348) +#define get_csv2_int_pos348(X,Y) get_csv2_int((X),(Y),348) +#define get_csv2_llong_pos348(X,Y) get_csv2_llong((X),(Y),348) +#define get_csv2_float_pos348(X,Y) get_csv2_float((X),(Y),348) +#define get_csv2_uint_pos349(X,Y) get_csv2_uint((X),(Y),349) +#define get_csv2_ullong_pos349(X,Y) get_csv2_ullong((X),(Y),349) +#define get_csv2_ip_pos349(X,Y) get_csv2_ip((X),(Y),349) +#define get_csv2_ipv6_pos349(X,Y) get_csv2_ipv6((X),(Y),349) +#define get_csv2_string_pos349(X,Y) get_csv2_string((X),(Y),349) +#define get_csv2_v_str_pos349(X,Y) get_csv2_string((X),(Y),349) +#define get_csv2_bool_pos349(X,Y) get_csv2_bool((X),(Y),349) +#define get_csv2_int_pos349(X,Y) get_csv2_int((X),(Y),349) +#define get_csv2_llong_pos349(X,Y) get_csv2_llong((X),(Y),349) +#define get_csv2_float_pos349(X,Y) get_csv2_float((X),(Y),349) +#define get_csv2_uint_pos350(X,Y) get_csv2_uint((X),(Y),350) +#define get_csv2_ullong_pos350(X,Y) get_csv2_ullong((X),(Y),350) +#define get_csv2_ip_pos350(X,Y) get_csv2_ip((X),(Y),350) +#define get_csv2_ipv6_pos350(X,Y) get_csv2_ipv6((X),(Y),350) +#define get_csv2_string_pos350(X,Y) get_csv2_string((X),(Y),350) +#define get_csv2_v_str_pos350(X,Y) get_csv2_string((X),(Y),350) +#define get_csv2_bool_pos350(X,Y) get_csv2_bool((X),(Y),350) +#define get_csv2_int_pos350(X,Y) get_csv2_int((X),(Y),350) +#define get_csv2_llong_pos350(X,Y) get_csv2_llong((X),(Y),350) +#define get_csv2_float_pos350(X,Y) get_csv2_float((X),(Y),350) +#define get_csv2_uint_pos351(X,Y) get_csv2_uint((X),(Y),351) +#define get_csv2_ullong_pos351(X,Y) get_csv2_ullong((X),(Y),351) +#define get_csv2_ip_pos351(X,Y) get_csv2_ip((X),(Y),351) +#define get_csv2_ipv6_pos351(X,Y) get_csv2_ipv6((X),(Y),351) +#define get_csv2_string_pos351(X,Y) get_csv2_string((X),(Y),351) +#define get_csv2_v_str_pos351(X,Y) get_csv2_string((X),(Y),351) +#define get_csv2_bool_pos351(X,Y) get_csv2_bool((X),(Y),351) +#define get_csv2_int_pos351(X,Y) get_csv2_int((X),(Y),351) +#define get_csv2_llong_pos351(X,Y) get_csv2_llong((X),(Y),351) +#define get_csv2_float_pos351(X,Y) get_csv2_float((X),(Y),351) +#define get_csv2_uint_pos352(X,Y) get_csv2_uint((X),(Y),352) +#define get_csv2_ullong_pos352(X,Y) get_csv2_ullong((X),(Y),352) +#define get_csv2_ip_pos352(X,Y) get_csv2_ip((X),(Y),352) +#define get_csv2_ipv6_pos352(X,Y) get_csv2_ipv6((X),(Y),352) +#define get_csv2_string_pos352(X,Y) get_csv2_string((X),(Y),352) +#define get_csv2_v_str_pos352(X,Y) get_csv2_string((X),(Y),352) +#define get_csv2_bool_pos352(X,Y) get_csv2_bool((X),(Y),352) +#define get_csv2_int_pos352(X,Y) get_csv2_int((X),(Y),352) +#define get_csv2_llong_pos352(X,Y) get_csv2_llong((X),(Y),352) +#define get_csv2_float_pos352(X,Y) get_csv2_float((X),(Y),352) +#define get_csv2_uint_pos353(X,Y) get_csv2_uint((X),(Y),353) +#define get_csv2_ullong_pos353(X,Y) get_csv2_ullong((X),(Y),353) +#define get_csv2_ip_pos353(X,Y) get_csv2_ip((X),(Y),353) +#define get_csv2_ipv6_pos353(X,Y) get_csv2_ipv6((X),(Y),353) +#define get_csv2_string_pos353(X,Y) get_csv2_string((X),(Y),353) +#define get_csv2_v_str_pos353(X,Y) get_csv2_string((X),(Y),353) +#define get_csv2_bool_pos353(X,Y) get_csv2_bool((X),(Y),353) +#define get_csv2_int_pos353(X,Y) get_csv2_int((X),(Y),353) +#define get_csv2_llong_pos353(X,Y) get_csv2_llong((X),(Y),353) +#define get_csv2_float_pos353(X,Y) get_csv2_float((X),(Y),353) +#define get_csv2_uint_pos354(X,Y) get_csv2_uint((X),(Y),354) +#define get_csv2_ullong_pos354(X,Y) get_csv2_ullong((X),(Y),354) +#define get_csv2_ip_pos354(X,Y) get_csv2_ip((X),(Y),354) +#define get_csv2_ipv6_pos354(X,Y) get_csv2_ipv6((X),(Y),354) +#define get_csv2_string_pos354(X,Y) get_csv2_string((X),(Y),354) +#define get_csv2_v_str_pos354(X,Y) get_csv2_string((X),(Y),354) +#define get_csv2_bool_pos354(X,Y) get_csv2_bool((X),(Y),354) +#define get_csv2_int_pos354(X,Y) get_csv2_int((X),(Y),354) +#define get_csv2_llong_pos354(X,Y) get_csv2_llong((X),(Y),354) +#define get_csv2_float_pos354(X,Y) get_csv2_float((X),(Y),354) +#define get_csv2_uint_pos355(X,Y) get_csv2_uint((X),(Y),355) +#define get_csv2_ullong_pos355(X,Y) get_csv2_ullong((X),(Y),355) +#define get_csv2_ip_pos355(X,Y) get_csv2_ip((X),(Y),355) +#define get_csv2_ipv6_pos355(X,Y) get_csv2_ipv6((X),(Y),355) +#define get_csv2_string_pos355(X,Y) get_csv2_string((X),(Y),355) +#define get_csv2_v_str_pos355(X,Y) get_csv2_string((X),(Y),355) +#define get_csv2_bool_pos355(X,Y) get_csv2_bool((X),(Y),355) +#define get_csv2_int_pos355(X,Y) get_csv2_int((X),(Y),355) +#define get_csv2_llong_pos355(X,Y) get_csv2_llong((X),(Y),355) +#define get_csv2_float_pos355(X,Y) get_csv2_float((X),(Y),355) +#define get_csv2_uint_pos356(X,Y) get_csv2_uint((X),(Y),356) +#define get_csv2_ullong_pos356(X,Y) get_csv2_ullong((X),(Y),356) +#define get_csv2_ip_pos356(X,Y) get_csv2_ip((X),(Y),356) +#define get_csv2_ipv6_pos356(X,Y) get_csv2_ipv6((X),(Y),356) +#define get_csv2_string_pos356(X,Y) get_csv2_string((X),(Y),356) +#define get_csv2_v_str_pos356(X,Y) get_csv2_string((X),(Y),356) +#define get_csv2_bool_pos356(X,Y) get_csv2_bool((X),(Y),356) +#define get_csv2_int_pos356(X,Y) get_csv2_int((X),(Y),356) +#define get_csv2_llong_pos356(X,Y) get_csv2_llong((X),(Y),356) +#define get_csv2_float_pos356(X,Y) get_csv2_float((X),(Y),356) +#define get_csv2_uint_pos357(X,Y) get_csv2_uint((X),(Y),357) +#define get_csv2_ullong_pos357(X,Y) get_csv2_ullong((X),(Y),357) +#define get_csv2_ip_pos357(X,Y) get_csv2_ip((X),(Y),357) +#define get_csv2_ipv6_pos357(X,Y) get_csv2_ipv6((X),(Y),357) +#define get_csv2_string_pos357(X,Y) get_csv2_string((X),(Y),357) +#define get_csv2_v_str_pos357(X,Y) get_csv2_string((X),(Y),357) +#define get_csv2_bool_pos357(X,Y) get_csv2_bool((X),(Y),357) +#define get_csv2_int_pos357(X,Y) get_csv2_int((X),(Y),357) +#define get_csv2_llong_pos357(X,Y) get_csv2_llong((X),(Y),357) +#define get_csv2_float_pos357(X,Y) get_csv2_float((X),(Y),357) +#define get_csv2_uint_pos358(X,Y) get_csv2_uint((X),(Y),358) +#define get_csv2_ullong_pos358(X,Y) get_csv2_ullong((X),(Y),358) +#define get_csv2_ip_pos358(X,Y) get_csv2_ip((X),(Y),358) +#define get_csv2_ipv6_pos358(X,Y) get_csv2_ipv6((X),(Y),358) +#define get_csv2_string_pos358(X,Y) get_csv2_string((X),(Y),358) +#define get_csv2_v_str_pos358(X,Y) get_csv2_string((X),(Y),358) +#define get_csv2_bool_pos358(X,Y) get_csv2_bool((X),(Y),358) +#define get_csv2_int_pos358(X,Y) get_csv2_int((X),(Y),358) +#define get_csv2_llong_pos358(X,Y) get_csv2_llong((X),(Y),358) +#define get_csv2_float_pos358(X,Y) get_csv2_float((X),(Y),358) +#define get_csv2_uint_pos359(X,Y) get_csv2_uint((X),(Y),359) +#define get_csv2_ullong_pos359(X,Y) get_csv2_ullong((X),(Y),359) +#define get_csv2_ip_pos359(X,Y) get_csv2_ip((X),(Y),359) +#define get_csv2_ipv6_pos359(X,Y) get_csv2_ipv6((X),(Y),359) +#define get_csv2_string_pos359(X,Y) get_csv2_string((X),(Y),359) +#define get_csv2_v_str_pos359(X,Y) get_csv2_string((X),(Y),359) +#define get_csv2_bool_pos359(X,Y) get_csv2_bool((X),(Y),359) +#define get_csv2_int_pos359(X,Y) get_csv2_int((X),(Y),359) +#define get_csv2_llong_pos359(X,Y) get_csv2_llong((X),(Y),359) +#define get_csv2_float_pos359(X,Y) get_csv2_float((X),(Y),359) +#define get_csv2_uint_pos360(X,Y) get_csv2_uint((X),(Y),360) +#define get_csv2_ullong_pos360(X,Y) get_csv2_ullong((X),(Y),360) +#define get_csv2_ip_pos360(X,Y) get_csv2_ip((X),(Y),360) +#define get_csv2_ipv6_pos360(X,Y) get_csv2_ipv6((X),(Y),360) +#define get_csv2_string_pos360(X,Y) get_csv2_string((X),(Y),360) +#define get_csv2_v_str_pos360(X,Y) get_csv2_string((X),(Y),360) +#define get_csv2_bool_pos360(X,Y) get_csv2_bool((X),(Y),360) +#define get_csv2_int_pos360(X,Y) get_csv2_int((X),(Y),360) +#define get_csv2_llong_pos360(X,Y) get_csv2_llong((X),(Y),360) +#define get_csv2_float_pos360(X,Y) get_csv2_float((X),(Y),360) +#define get_csv2_uint_pos361(X,Y) get_csv2_uint((X),(Y),361) +#define get_csv2_ullong_pos361(X,Y) get_csv2_ullong((X),(Y),361) +#define get_csv2_ip_pos361(X,Y) get_csv2_ip((X),(Y),361) +#define get_csv2_ipv6_pos361(X,Y) get_csv2_ipv6((X),(Y),361) +#define get_csv2_string_pos361(X,Y) get_csv2_string((X),(Y),361) +#define get_csv2_v_str_pos361(X,Y) get_csv2_string((X),(Y),361) +#define get_csv2_bool_pos361(X,Y) get_csv2_bool((X),(Y),361) +#define get_csv2_int_pos361(X,Y) get_csv2_int((X),(Y),361) +#define get_csv2_llong_pos361(X,Y) get_csv2_llong((X),(Y),361) +#define get_csv2_float_pos361(X,Y) get_csv2_float((X),(Y),361) +#define get_csv2_uint_pos362(X,Y) get_csv2_uint((X),(Y),362) +#define get_csv2_ullong_pos362(X,Y) get_csv2_ullong((X),(Y),362) +#define get_csv2_ip_pos362(X,Y) get_csv2_ip((X),(Y),362) +#define get_csv2_ipv6_pos362(X,Y) get_csv2_ipv6((X),(Y),362) +#define get_csv2_string_pos362(X,Y) get_csv2_string((X),(Y),362) +#define get_csv2_v_str_pos362(X,Y) get_csv2_string((X),(Y),362) +#define get_csv2_bool_pos362(X,Y) get_csv2_bool((X),(Y),362) +#define get_csv2_int_pos362(X,Y) get_csv2_int((X),(Y),362) +#define get_csv2_llong_pos362(X,Y) get_csv2_llong((X),(Y),362) +#define get_csv2_float_pos362(X,Y) get_csv2_float((X),(Y),362) +#define get_csv2_uint_pos363(X,Y) get_csv2_uint((X),(Y),363) +#define get_csv2_ullong_pos363(X,Y) get_csv2_ullong((X),(Y),363) +#define get_csv2_ip_pos363(X,Y) get_csv2_ip((X),(Y),363) +#define get_csv2_ipv6_pos363(X,Y) get_csv2_ipv6((X),(Y),363) +#define get_csv2_string_pos363(X,Y) get_csv2_string((X),(Y),363) +#define get_csv2_v_str_pos363(X,Y) get_csv2_string((X),(Y),363) +#define get_csv2_bool_pos363(X,Y) get_csv2_bool((X),(Y),363) +#define get_csv2_int_pos363(X,Y) get_csv2_int((X),(Y),363) +#define get_csv2_llong_pos363(X,Y) get_csv2_llong((X),(Y),363) +#define get_csv2_float_pos363(X,Y) get_csv2_float((X),(Y),363) +#define get_csv2_uint_pos364(X,Y) get_csv2_uint((X),(Y),364) +#define get_csv2_ullong_pos364(X,Y) get_csv2_ullong((X),(Y),364) +#define get_csv2_ip_pos364(X,Y) get_csv2_ip((X),(Y),364) +#define get_csv2_ipv6_pos364(X,Y) get_csv2_ipv6((X),(Y),364) +#define get_csv2_string_pos364(X,Y) get_csv2_string((X),(Y),364) +#define get_csv2_v_str_pos364(X,Y) get_csv2_string((X),(Y),364) +#define get_csv2_bool_pos364(X,Y) get_csv2_bool((X),(Y),364) +#define get_csv2_int_pos364(X,Y) get_csv2_int((X),(Y),364) +#define get_csv2_llong_pos364(X,Y) get_csv2_llong((X),(Y),364) +#define get_csv2_float_pos364(X,Y) get_csv2_float((X),(Y),364) +#define get_csv2_uint_pos365(X,Y) get_csv2_uint((X),(Y),365) +#define get_csv2_ullong_pos365(X,Y) get_csv2_ullong((X),(Y),365) +#define get_csv2_ip_pos365(X,Y) get_csv2_ip((X),(Y),365) +#define get_csv2_ipv6_pos365(X,Y) get_csv2_ipv6((X),(Y),365) +#define get_csv2_string_pos365(X,Y) get_csv2_string((X),(Y),365) +#define get_csv2_v_str_pos365(X,Y) get_csv2_string((X),(Y),365) +#define get_csv2_bool_pos365(X,Y) get_csv2_bool((X),(Y),365) +#define get_csv2_int_pos365(X,Y) get_csv2_int((X),(Y),365) +#define get_csv2_llong_pos365(X,Y) get_csv2_llong((X),(Y),365) +#define get_csv2_float_pos365(X,Y) get_csv2_float((X),(Y),365) +#define get_csv2_uint_pos366(X,Y) get_csv2_uint((X),(Y),366) +#define get_csv2_ullong_pos366(X,Y) get_csv2_ullong((X),(Y),366) +#define get_csv2_ip_pos366(X,Y) get_csv2_ip((X),(Y),366) +#define get_csv2_ipv6_pos366(X,Y) get_csv2_ipv6((X),(Y),366) +#define get_csv2_string_pos366(X,Y) get_csv2_string((X),(Y),366) +#define get_csv2_v_str_pos366(X,Y) get_csv2_string((X),(Y),366) +#define get_csv2_bool_pos366(X,Y) get_csv2_bool((X),(Y),366) +#define get_csv2_int_pos366(X,Y) get_csv2_int((X),(Y),366) +#define get_csv2_llong_pos366(X,Y) get_csv2_llong((X),(Y),366) +#define get_csv2_float_pos366(X,Y) get_csv2_float((X),(Y),366) +#define get_csv2_uint_pos367(X,Y) get_csv2_uint((X),(Y),367) +#define get_csv2_ullong_pos367(X,Y) get_csv2_ullong((X),(Y),367) +#define get_csv2_ip_pos367(X,Y) get_csv2_ip((X),(Y),367) +#define get_csv2_ipv6_pos367(X,Y) get_csv2_ipv6((X),(Y),367) +#define get_csv2_string_pos367(X,Y) get_csv2_string((X),(Y),367) +#define get_csv2_v_str_pos367(X,Y) get_csv2_string((X),(Y),367) +#define get_csv2_bool_pos367(X,Y) get_csv2_bool((X),(Y),367) +#define get_csv2_int_pos367(X,Y) get_csv2_int((X),(Y),367) +#define get_csv2_llong_pos367(X,Y) get_csv2_llong((X),(Y),367) +#define get_csv2_float_pos367(X,Y) get_csv2_float((X),(Y),367) +#define get_csv2_uint_pos368(X,Y) get_csv2_uint((X),(Y),368) +#define get_csv2_ullong_pos368(X,Y) get_csv2_ullong((X),(Y),368) +#define get_csv2_ip_pos368(X,Y) get_csv2_ip((X),(Y),368) +#define get_csv2_ipv6_pos368(X,Y) get_csv2_ipv6((X),(Y),368) +#define get_csv2_string_pos368(X,Y) get_csv2_string((X),(Y),368) +#define get_csv2_v_str_pos368(X,Y) get_csv2_string((X),(Y),368) +#define get_csv2_bool_pos368(X,Y) get_csv2_bool((X),(Y),368) +#define get_csv2_int_pos368(X,Y) get_csv2_int((X),(Y),368) +#define get_csv2_llong_pos368(X,Y) get_csv2_llong((X),(Y),368) +#define get_csv2_float_pos368(X,Y) get_csv2_float((X),(Y),368) +#define get_csv2_uint_pos369(X,Y) get_csv2_uint((X),(Y),369) +#define get_csv2_ullong_pos369(X,Y) get_csv2_ullong((X),(Y),369) +#define get_csv2_ip_pos369(X,Y) get_csv2_ip((X),(Y),369) +#define get_csv2_ipv6_pos369(X,Y) get_csv2_ipv6((X),(Y),369) +#define get_csv2_string_pos369(X,Y) get_csv2_string((X),(Y),369) +#define get_csv2_v_str_pos369(X,Y) get_csv2_string((X),(Y),369) +#define get_csv2_bool_pos369(X,Y) get_csv2_bool((X),(Y),369) +#define get_csv2_int_pos369(X,Y) get_csv2_int((X),(Y),369) +#define get_csv2_llong_pos369(X,Y) get_csv2_llong((X),(Y),369) +#define get_csv2_float_pos369(X,Y) get_csv2_float((X),(Y),369) +#define get_csv2_uint_pos370(X,Y) get_csv2_uint((X),(Y),370) +#define get_csv2_ullong_pos370(X,Y) get_csv2_ullong((X),(Y),370) +#define get_csv2_ip_pos370(X,Y) get_csv2_ip((X),(Y),370) +#define get_csv2_ipv6_pos370(X,Y) get_csv2_ipv6((X),(Y),370) +#define get_csv2_string_pos370(X,Y) get_csv2_string((X),(Y),370) +#define get_csv2_v_str_pos370(X,Y) get_csv2_string((X),(Y),370) +#define get_csv2_bool_pos370(X,Y) get_csv2_bool((X),(Y),370) +#define get_csv2_int_pos370(X,Y) get_csv2_int((X),(Y),370) +#define get_csv2_llong_pos370(X,Y) get_csv2_llong((X),(Y),370) +#define get_csv2_float_pos370(X,Y) get_csv2_float((X),(Y),370) +#define get_csv2_uint_pos371(X,Y) get_csv2_uint((X),(Y),371) +#define get_csv2_ullong_pos371(X,Y) get_csv2_ullong((X),(Y),371) +#define get_csv2_ip_pos371(X,Y) get_csv2_ip((X),(Y),371) +#define get_csv2_ipv6_pos371(X,Y) get_csv2_ipv6((X),(Y),371) +#define get_csv2_string_pos371(X,Y) get_csv2_string((X),(Y),371) +#define get_csv2_v_str_pos371(X,Y) get_csv2_string((X),(Y),371) +#define get_csv2_bool_pos371(X,Y) get_csv2_bool((X),(Y),371) +#define get_csv2_int_pos371(X,Y) get_csv2_int((X),(Y),371) +#define get_csv2_llong_pos371(X,Y) get_csv2_llong((X),(Y),371) +#define get_csv2_float_pos371(X,Y) get_csv2_float((X),(Y),371) +#define get_csv2_uint_pos372(X,Y) get_csv2_uint((X),(Y),372) +#define get_csv2_ullong_pos372(X,Y) get_csv2_ullong((X),(Y),372) +#define get_csv2_ip_pos372(X,Y) get_csv2_ip((X),(Y),372) +#define get_csv2_ipv6_pos372(X,Y) get_csv2_ipv6((X),(Y),372) +#define get_csv2_string_pos372(X,Y) get_csv2_string((X),(Y),372) +#define get_csv2_v_str_pos372(X,Y) get_csv2_string((X),(Y),372) +#define get_csv2_bool_pos372(X,Y) get_csv2_bool((X),(Y),372) +#define get_csv2_int_pos372(X,Y) get_csv2_int((X),(Y),372) +#define get_csv2_llong_pos372(X,Y) get_csv2_llong((X),(Y),372) +#define get_csv2_float_pos372(X,Y) get_csv2_float((X),(Y),372) +#define get_csv2_uint_pos373(X,Y) get_csv2_uint((X),(Y),373) +#define get_csv2_ullong_pos373(X,Y) get_csv2_ullong((X),(Y),373) +#define get_csv2_ip_pos373(X,Y) get_csv2_ip((X),(Y),373) +#define get_csv2_ipv6_pos373(X,Y) get_csv2_ipv6((X),(Y),373) +#define get_csv2_string_pos373(X,Y) get_csv2_string((X),(Y),373) +#define get_csv2_v_str_pos373(X,Y) get_csv2_string((X),(Y),373) +#define get_csv2_bool_pos373(X,Y) get_csv2_bool((X),(Y),373) +#define get_csv2_int_pos373(X,Y) get_csv2_int((X),(Y),373) +#define get_csv2_llong_pos373(X,Y) get_csv2_llong((X),(Y),373) +#define get_csv2_float_pos373(X,Y) get_csv2_float((X),(Y),373) +#define get_csv2_uint_pos374(X,Y) get_csv2_uint((X),(Y),374) +#define get_csv2_ullong_pos374(X,Y) get_csv2_ullong((X),(Y),374) +#define get_csv2_ip_pos374(X,Y) get_csv2_ip((X),(Y),374) +#define get_csv2_ipv6_pos374(X,Y) get_csv2_ipv6((X),(Y),374) +#define get_csv2_string_pos374(X,Y) get_csv2_string((X),(Y),374) +#define get_csv2_v_str_pos374(X,Y) get_csv2_string((X),(Y),374) +#define get_csv2_bool_pos374(X,Y) get_csv2_bool((X),(Y),374) +#define get_csv2_int_pos374(X,Y) get_csv2_int((X),(Y),374) +#define get_csv2_llong_pos374(X,Y) get_csv2_llong((X),(Y),374) +#define get_csv2_float_pos374(X,Y) get_csv2_float((X),(Y),374) +#define get_csv2_uint_pos375(X,Y) get_csv2_uint((X),(Y),375) +#define get_csv2_ullong_pos375(X,Y) get_csv2_ullong((X),(Y),375) +#define get_csv2_ip_pos375(X,Y) get_csv2_ip((X),(Y),375) +#define get_csv2_ipv6_pos375(X,Y) get_csv2_ipv6((X),(Y),375) +#define get_csv2_string_pos375(X,Y) get_csv2_string((X),(Y),375) +#define get_csv2_v_str_pos375(X,Y) get_csv2_string((X),(Y),375) +#define get_csv2_bool_pos375(X,Y) get_csv2_bool((X),(Y),375) +#define get_csv2_int_pos375(X,Y) get_csv2_int((X),(Y),375) +#define get_csv2_llong_pos375(X,Y) get_csv2_llong((X),(Y),375) +#define get_csv2_float_pos375(X,Y) get_csv2_float((X),(Y),375) +#define get_csv2_uint_pos376(X,Y) get_csv2_uint((X),(Y),376) +#define get_csv2_ullong_pos376(X,Y) get_csv2_ullong((X),(Y),376) +#define get_csv2_ip_pos376(X,Y) get_csv2_ip((X),(Y),376) +#define get_csv2_ipv6_pos376(X,Y) get_csv2_ipv6((X),(Y),376) +#define get_csv2_string_pos376(X,Y) get_csv2_string((X),(Y),376) +#define get_csv2_v_str_pos376(X,Y) get_csv2_string((X),(Y),376) +#define get_csv2_bool_pos376(X,Y) get_csv2_bool((X),(Y),376) +#define get_csv2_int_pos376(X,Y) get_csv2_int((X),(Y),376) +#define get_csv2_llong_pos376(X,Y) get_csv2_llong((X),(Y),376) +#define get_csv2_float_pos376(X,Y) get_csv2_float((X),(Y),376) +#define get_csv2_uint_pos377(X,Y) get_csv2_uint((X),(Y),377) +#define get_csv2_ullong_pos377(X,Y) get_csv2_ullong((X),(Y),377) +#define get_csv2_ip_pos377(X,Y) get_csv2_ip((X),(Y),377) +#define get_csv2_ipv6_pos377(X,Y) get_csv2_ipv6((X),(Y),377) +#define get_csv2_string_pos377(X,Y) get_csv2_string((X),(Y),377) +#define get_csv2_v_str_pos377(X,Y) get_csv2_string((X),(Y),377) +#define get_csv2_bool_pos377(X,Y) get_csv2_bool((X),(Y),377) +#define get_csv2_int_pos377(X,Y) get_csv2_int((X),(Y),377) +#define get_csv2_llong_pos377(X,Y) get_csv2_llong((X),(Y),377) +#define get_csv2_float_pos377(X,Y) get_csv2_float((X),(Y),377) +#define get_csv2_uint_pos378(X,Y) get_csv2_uint((X),(Y),378) +#define get_csv2_ullong_pos378(X,Y) get_csv2_ullong((X),(Y),378) +#define get_csv2_ip_pos378(X,Y) get_csv2_ip((X),(Y),378) +#define get_csv2_ipv6_pos378(X,Y) get_csv2_ipv6((X),(Y),378) +#define get_csv2_string_pos378(X,Y) get_csv2_string((X),(Y),378) +#define get_csv2_v_str_pos378(X,Y) get_csv2_string((X),(Y),378) +#define get_csv2_bool_pos378(X,Y) get_csv2_bool((X),(Y),378) +#define get_csv2_int_pos378(X,Y) get_csv2_int((X),(Y),378) +#define get_csv2_llong_pos378(X,Y) get_csv2_llong((X),(Y),378) +#define get_csv2_float_pos378(X,Y) get_csv2_float((X),(Y),378) +#define get_csv2_uint_pos379(X,Y) get_csv2_uint((X),(Y),379) +#define get_csv2_ullong_pos379(X,Y) get_csv2_ullong((X),(Y),379) +#define get_csv2_ip_pos379(X,Y) get_csv2_ip((X),(Y),379) +#define get_csv2_ipv6_pos379(X,Y) get_csv2_ipv6((X),(Y),379) +#define get_csv2_string_pos379(X,Y) get_csv2_string((X),(Y),379) +#define get_csv2_v_str_pos379(X,Y) get_csv2_string((X),(Y),379) +#define get_csv2_bool_pos379(X,Y) get_csv2_bool((X),(Y),379) +#define get_csv2_int_pos379(X,Y) get_csv2_int((X),(Y),379) +#define get_csv2_llong_pos379(X,Y) get_csv2_llong((X),(Y),379) +#define get_csv2_float_pos379(X,Y) get_csv2_float((X),(Y),379) +#define get_csv2_uint_pos380(X,Y) get_csv2_uint((X),(Y),380) +#define get_csv2_ullong_pos380(X,Y) get_csv2_ullong((X),(Y),380) +#define get_csv2_ip_pos380(X,Y) get_csv2_ip((X),(Y),380) +#define get_csv2_ipv6_pos380(X,Y) get_csv2_ipv6((X),(Y),380) +#define get_csv2_string_pos380(X,Y) get_csv2_string((X),(Y),380) +#define get_csv2_v_str_pos380(X,Y) get_csv2_string((X),(Y),380) +#define get_csv2_bool_pos380(X,Y) get_csv2_bool((X),(Y),380) +#define get_csv2_int_pos380(X,Y) get_csv2_int((X),(Y),380) +#define get_csv2_llong_pos380(X,Y) get_csv2_llong((X),(Y),380) +#define get_csv2_float_pos380(X,Y) get_csv2_float((X),(Y),380) +#define get_csv2_uint_pos381(X,Y) get_csv2_uint((X),(Y),381) +#define get_csv2_ullong_pos381(X,Y) get_csv2_ullong((X),(Y),381) +#define get_csv2_ip_pos381(X,Y) get_csv2_ip((X),(Y),381) +#define get_csv2_ipv6_pos381(X,Y) get_csv2_ipv6((X),(Y),381) +#define get_csv2_string_pos381(X,Y) get_csv2_string((X),(Y),381) +#define get_csv2_v_str_pos381(X,Y) get_csv2_string((X),(Y),381) +#define get_csv2_bool_pos381(X,Y) get_csv2_bool((X),(Y),381) +#define get_csv2_int_pos381(X,Y) get_csv2_int((X),(Y),381) +#define get_csv2_llong_pos381(X,Y) get_csv2_llong((X),(Y),381) +#define get_csv2_float_pos381(X,Y) get_csv2_float((X),(Y),381) +#define get_csv2_uint_pos382(X,Y) get_csv2_uint((X),(Y),382) +#define get_csv2_ullong_pos382(X,Y) get_csv2_ullong((X),(Y),382) +#define get_csv2_ip_pos382(X,Y) get_csv2_ip((X),(Y),382) +#define get_csv2_ipv6_pos382(X,Y) get_csv2_ipv6((X),(Y),382) +#define get_csv2_string_pos382(X,Y) get_csv2_string((X),(Y),382) +#define get_csv2_v_str_pos382(X,Y) get_csv2_string((X),(Y),382) +#define get_csv2_bool_pos382(X,Y) get_csv2_bool((X),(Y),382) +#define get_csv2_int_pos382(X,Y) get_csv2_int((X),(Y),382) +#define get_csv2_llong_pos382(X,Y) get_csv2_llong((X),(Y),382) +#define get_csv2_float_pos382(X,Y) get_csv2_float((X),(Y),382) +#define get_csv2_uint_pos383(X,Y) get_csv2_uint((X),(Y),383) +#define get_csv2_ullong_pos383(X,Y) get_csv2_ullong((X),(Y),383) +#define get_csv2_ip_pos383(X,Y) get_csv2_ip((X),(Y),383) +#define get_csv2_ipv6_pos383(X,Y) get_csv2_ipv6((X),(Y),383) +#define get_csv2_string_pos383(X,Y) get_csv2_string((X),(Y),383) +#define get_csv2_v_str_pos383(X,Y) get_csv2_string((X),(Y),383) +#define get_csv2_bool_pos383(X,Y) get_csv2_bool((X),(Y),383) +#define get_csv2_int_pos383(X,Y) get_csv2_int((X),(Y),383) +#define get_csv2_llong_pos383(X,Y) get_csv2_llong((X),(Y),383) +#define get_csv2_float_pos383(X,Y) get_csv2_float((X),(Y),383) +#define get_csv2_uint_pos384(X,Y) get_csv2_uint((X),(Y),384) +#define get_csv2_ullong_pos384(X,Y) get_csv2_ullong((X),(Y),384) +#define get_csv2_ip_pos384(X,Y) get_csv2_ip((X),(Y),384) +#define get_csv2_ipv6_pos384(X,Y) get_csv2_ipv6((X),(Y),384) +#define get_csv2_string_pos384(X,Y) get_csv2_string((X),(Y),384) +#define get_csv2_v_str_pos384(X,Y) get_csv2_string((X),(Y),384) +#define get_csv2_bool_pos384(X,Y) get_csv2_bool((X),(Y),384) +#define get_csv2_int_pos384(X,Y) get_csv2_int((X),(Y),384) +#define get_csv2_llong_pos384(X,Y) get_csv2_llong((X),(Y),384) +#define get_csv2_float_pos384(X,Y) get_csv2_float((X),(Y),384) +#define get_csv2_uint_pos385(X,Y) get_csv2_uint((X),(Y),385) +#define get_csv2_ullong_pos385(X,Y) get_csv2_ullong((X),(Y),385) +#define get_csv2_ip_pos385(X,Y) get_csv2_ip((X),(Y),385) +#define get_csv2_ipv6_pos385(X,Y) get_csv2_ipv6((X),(Y),385) +#define get_csv2_string_pos385(X,Y) get_csv2_string((X),(Y),385) +#define get_csv2_v_str_pos385(X,Y) get_csv2_string((X),(Y),385) +#define get_csv2_bool_pos385(X,Y) get_csv2_bool((X),(Y),385) +#define get_csv2_int_pos385(X,Y) get_csv2_int((X),(Y),385) +#define get_csv2_llong_pos385(X,Y) get_csv2_llong((X),(Y),385) +#define get_csv2_float_pos385(X,Y) get_csv2_float((X),(Y),385) +#define get_csv2_uint_pos386(X,Y) get_csv2_uint((X),(Y),386) +#define get_csv2_ullong_pos386(X,Y) get_csv2_ullong((X),(Y),386) +#define get_csv2_ip_pos386(X,Y) get_csv2_ip((X),(Y),386) +#define get_csv2_ipv6_pos386(X,Y) get_csv2_ipv6((X),(Y),386) +#define get_csv2_string_pos386(X,Y) get_csv2_string((X),(Y),386) +#define get_csv2_v_str_pos386(X,Y) get_csv2_string((X),(Y),386) +#define get_csv2_bool_pos386(X,Y) get_csv2_bool((X),(Y),386) +#define get_csv2_int_pos386(X,Y) get_csv2_int((X),(Y),386) +#define get_csv2_llong_pos386(X,Y) get_csv2_llong((X),(Y),386) +#define get_csv2_float_pos386(X,Y) get_csv2_float((X),(Y),386) +#define get_csv2_uint_pos387(X,Y) get_csv2_uint((X),(Y),387) +#define get_csv2_ullong_pos387(X,Y) get_csv2_ullong((X),(Y),387) +#define get_csv2_ip_pos387(X,Y) get_csv2_ip((X),(Y),387) +#define get_csv2_ipv6_pos387(X,Y) get_csv2_ipv6((X),(Y),387) +#define get_csv2_string_pos387(X,Y) get_csv2_string((X),(Y),387) +#define get_csv2_v_str_pos387(X,Y) get_csv2_string((X),(Y),387) +#define get_csv2_bool_pos387(X,Y) get_csv2_bool((X),(Y),387) +#define get_csv2_int_pos387(X,Y) get_csv2_int((X),(Y),387) +#define get_csv2_llong_pos387(X,Y) get_csv2_llong((X),(Y),387) +#define get_csv2_float_pos387(X,Y) get_csv2_float((X),(Y),387) +#define get_csv2_uint_pos388(X,Y) get_csv2_uint((X),(Y),388) +#define get_csv2_ullong_pos388(X,Y) get_csv2_ullong((X),(Y),388) +#define get_csv2_ip_pos388(X,Y) get_csv2_ip((X),(Y),388) +#define get_csv2_ipv6_pos388(X,Y) get_csv2_ipv6((X),(Y),388) +#define get_csv2_string_pos388(X,Y) get_csv2_string((X),(Y),388) +#define get_csv2_v_str_pos388(X,Y) get_csv2_string((X),(Y),388) +#define get_csv2_bool_pos388(X,Y) get_csv2_bool((X),(Y),388) +#define get_csv2_int_pos388(X,Y) get_csv2_int((X),(Y),388) +#define get_csv2_llong_pos388(X,Y) get_csv2_llong((X),(Y),388) +#define get_csv2_float_pos388(X,Y) get_csv2_float((X),(Y),388) +#define get_csv2_uint_pos389(X,Y) get_csv2_uint((X),(Y),389) +#define get_csv2_ullong_pos389(X,Y) get_csv2_ullong((X),(Y),389) +#define get_csv2_ip_pos389(X,Y) get_csv2_ip((X),(Y),389) +#define get_csv2_ipv6_pos389(X,Y) get_csv2_ipv6((X),(Y),389) +#define get_csv2_string_pos389(X,Y) get_csv2_string((X),(Y),389) +#define get_csv2_v_str_pos389(X,Y) get_csv2_string((X),(Y),389) +#define get_csv2_bool_pos389(X,Y) get_csv2_bool((X),(Y),389) +#define get_csv2_int_pos389(X,Y) get_csv2_int((X),(Y),389) +#define get_csv2_llong_pos389(X,Y) get_csv2_llong((X),(Y),389) +#define get_csv2_float_pos389(X,Y) get_csv2_float((X),(Y),389) +#define get_csv2_uint_pos390(X,Y) get_csv2_uint((X),(Y),390) +#define get_csv2_ullong_pos390(X,Y) get_csv2_ullong((X),(Y),390) +#define get_csv2_ip_pos390(X,Y) get_csv2_ip((X),(Y),390) +#define get_csv2_ipv6_pos390(X,Y) get_csv2_ipv6((X),(Y),390) +#define get_csv2_string_pos390(X,Y) get_csv2_string((X),(Y),390) +#define get_csv2_v_str_pos390(X,Y) get_csv2_string((X),(Y),390) +#define get_csv2_bool_pos390(X,Y) get_csv2_bool((X),(Y),390) +#define get_csv2_int_pos390(X,Y) get_csv2_int((X),(Y),390) +#define get_csv2_llong_pos390(X,Y) get_csv2_llong((X),(Y),390) +#define get_csv2_float_pos390(X,Y) get_csv2_float((X),(Y),390) +#define get_csv2_uint_pos391(X,Y) get_csv2_uint((X),(Y),391) +#define get_csv2_ullong_pos391(X,Y) get_csv2_ullong((X),(Y),391) +#define get_csv2_ip_pos391(X,Y) get_csv2_ip((X),(Y),391) +#define get_csv2_ipv6_pos391(X,Y) get_csv2_ipv6((X),(Y),391) +#define get_csv2_string_pos391(X,Y) get_csv2_string((X),(Y),391) +#define get_csv2_v_str_pos391(X,Y) get_csv2_string((X),(Y),391) +#define get_csv2_bool_pos391(X,Y) get_csv2_bool((X),(Y),391) +#define get_csv2_int_pos391(X,Y) get_csv2_int((X),(Y),391) +#define get_csv2_llong_pos391(X,Y) get_csv2_llong((X),(Y),391) +#define get_csv2_float_pos391(X,Y) get_csv2_float((X),(Y),391) +#define get_csv2_uint_pos392(X,Y) get_csv2_uint((X),(Y),392) +#define get_csv2_ullong_pos392(X,Y) get_csv2_ullong((X),(Y),392) +#define get_csv2_ip_pos392(X,Y) get_csv2_ip((X),(Y),392) +#define get_csv2_ipv6_pos392(X,Y) get_csv2_ipv6((X),(Y),392) +#define get_csv2_string_pos392(X,Y) get_csv2_string((X),(Y),392) +#define get_csv2_v_str_pos392(X,Y) get_csv2_string((X),(Y),392) +#define get_csv2_bool_pos392(X,Y) get_csv2_bool((X),(Y),392) +#define get_csv2_int_pos392(X,Y) get_csv2_int((X),(Y),392) +#define get_csv2_llong_pos392(X,Y) get_csv2_llong((X),(Y),392) +#define get_csv2_float_pos392(X,Y) get_csv2_float((X),(Y),392) +#define get_csv2_uint_pos393(X,Y) get_csv2_uint((X),(Y),393) +#define get_csv2_ullong_pos393(X,Y) get_csv2_ullong((X),(Y),393) +#define get_csv2_ip_pos393(X,Y) get_csv2_ip((X),(Y),393) +#define get_csv2_ipv6_pos393(X,Y) get_csv2_ipv6((X),(Y),393) +#define get_csv2_string_pos393(X,Y) get_csv2_string((X),(Y),393) +#define get_csv2_v_str_pos393(X,Y) get_csv2_string((X),(Y),393) +#define get_csv2_bool_pos393(X,Y) get_csv2_bool((X),(Y),393) +#define get_csv2_int_pos393(X,Y) get_csv2_int((X),(Y),393) +#define get_csv2_llong_pos393(X,Y) get_csv2_llong((X),(Y),393) +#define get_csv2_float_pos393(X,Y) get_csv2_float((X),(Y),393) +#define get_csv2_uint_pos394(X,Y) get_csv2_uint((X),(Y),394) +#define get_csv2_ullong_pos394(X,Y) get_csv2_ullong((X),(Y),394) +#define get_csv2_ip_pos394(X,Y) get_csv2_ip((X),(Y),394) +#define get_csv2_ipv6_pos394(X,Y) get_csv2_ipv6((X),(Y),394) +#define get_csv2_string_pos394(X,Y) get_csv2_string((X),(Y),394) +#define get_csv2_v_str_pos394(X,Y) get_csv2_string((X),(Y),394) +#define get_csv2_bool_pos394(X,Y) get_csv2_bool((X),(Y),394) +#define get_csv2_int_pos394(X,Y) get_csv2_int((X),(Y),394) +#define get_csv2_llong_pos394(X,Y) get_csv2_llong((X),(Y),394) +#define get_csv2_float_pos394(X,Y) get_csv2_float((X),(Y),394) +#define get_csv2_uint_pos395(X,Y) get_csv2_uint((X),(Y),395) +#define get_csv2_ullong_pos395(X,Y) get_csv2_ullong((X),(Y),395) +#define get_csv2_ip_pos395(X,Y) get_csv2_ip((X),(Y),395) +#define get_csv2_ipv6_pos395(X,Y) get_csv2_ipv6((X),(Y),395) +#define get_csv2_string_pos395(X,Y) get_csv2_string((X),(Y),395) +#define get_csv2_v_str_pos395(X,Y) get_csv2_string((X),(Y),395) +#define get_csv2_bool_pos395(X,Y) get_csv2_bool((X),(Y),395) +#define get_csv2_int_pos395(X,Y) get_csv2_int((X),(Y),395) +#define get_csv2_llong_pos395(X,Y) get_csv2_llong((X),(Y),395) +#define get_csv2_float_pos395(X,Y) get_csv2_float((X),(Y),395) +#define get_csv2_uint_pos396(X,Y) get_csv2_uint((X),(Y),396) +#define get_csv2_ullong_pos396(X,Y) get_csv2_ullong((X),(Y),396) +#define get_csv2_ip_pos396(X,Y) get_csv2_ip((X),(Y),396) +#define get_csv2_ipv6_pos396(X,Y) get_csv2_ipv6((X),(Y),396) +#define get_csv2_string_pos396(X,Y) get_csv2_string((X),(Y),396) +#define get_csv2_v_str_pos396(X,Y) get_csv2_string((X),(Y),396) +#define get_csv2_bool_pos396(X,Y) get_csv2_bool((X),(Y),396) +#define get_csv2_int_pos396(X,Y) get_csv2_int((X),(Y),396) +#define get_csv2_llong_pos396(X,Y) get_csv2_llong((X),(Y),396) +#define get_csv2_float_pos396(X,Y) get_csv2_float((X),(Y),396) +#define get_csv2_uint_pos397(X,Y) get_csv2_uint((X),(Y),397) +#define get_csv2_ullong_pos397(X,Y) get_csv2_ullong((X),(Y),397) +#define get_csv2_ip_pos397(X,Y) get_csv2_ip((X),(Y),397) +#define get_csv2_ipv6_pos397(X,Y) get_csv2_ipv6((X),(Y),397) +#define get_csv2_string_pos397(X,Y) get_csv2_string((X),(Y),397) +#define get_csv2_v_str_pos397(X,Y) get_csv2_string((X),(Y),397) +#define get_csv2_bool_pos397(X,Y) get_csv2_bool((X),(Y),397) +#define get_csv2_int_pos397(X,Y) get_csv2_int((X),(Y),397) +#define get_csv2_llong_pos397(X,Y) get_csv2_llong((X),(Y),397) +#define get_csv2_float_pos397(X,Y) get_csv2_float((X),(Y),397) +#define get_csv2_uint_pos398(X,Y) get_csv2_uint((X),(Y),398) +#define get_csv2_ullong_pos398(X,Y) get_csv2_ullong((X),(Y),398) +#define get_csv2_ip_pos398(X,Y) get_csv2_ip((X),(Y),398) +#define get_csv2_ipv6_pos398(X,Y) get_csv2_ipv6((X),(Y),398) +#define get_csv2_string_pos398(X,Y) get_csv2_string((X),(Y),398) +#define get_csv2_v_str_pos398(X,Y) get_csv2_string((X),(Y),398) +#define get_csv2_bool_pos398(X,Y) get_csv2_bool((X),(Y),398) +#define get_csv2_int_pos398(X,Y) get_csv2_int((X),(Y),398) +#define get_csv2_llong_pos398(X,Y) get_csv2_llong((X),(Y),398) +#define get_csv2_float_pos398(X,Y) get_csv2_float((X),(Y),398) +#define get_csv2_uint_pos399(X,Y) get_csv2_uint((X),(Y),399) +#define get_csv2_ullong_pos399(X,Y) get_csv2_ullong((X),(Y),399) +#define get_csv2_ip_pos399(X,Y) get_csv2_ip((X),(Y),399) +#define get_csv2_ipv6_pos399(X,Y) get_csv2_ipv6((X),(Y),399) +#define get_csv2_string_pos399(X,Y) get_csv2_string((X),(Y),399) +#define get_csv2_v_str_pos399(X,Y) get_csv2_string((X),(Y),399) +#define get_csv2_bool_pos399(X,Y) get_csv2_bool((X),(Y),399) +#define get_csv2_int_pos399(X,Y) get_csv2_int((X),(Y),399) +#define get_csv2_llong_pos399(X,Y) get_csv2_llong((X),(Y),399) +#define get_csv2_float_pos399(X,Y) get_csv2_float((X),(Y),399) +#define get_csv2_uint_pos400(X,Y) get_csv2_uint((X),(Y),400) +#define get_csv2_ullong_pos400(X,Y) get_csv2_ullong((X),(Y),400) +#define get_csv2_ip_pos400(X,Y) get_csv2_ip((X),(Y),400) +#define get_csv2_ipv6_pos400(X,Y) get_csv2_ipv6((X),(Y),400) +#define get_csv2_string_pos400(X,Y) get_csv2_string((X),(Y),400) +#define get_csv2_v_str_pos400(X,Y) get_csv2_string((X),(Y),400) +#define get_csv2_bool_pos400(X,Y) get_csv2_bool((X),(Y),400) +#define get_csv2_int_pos400(X,Y) get_csv2_int((X),(Y),400) +#define get_csv2_llong_pos400(X,Y) get_csv2_llong((X),(Y),400) +#define get_csv2_float_pos400(X,Y) get_csv2_float((X),(Y),400) +#define get_csv2_uint_pos401(X,Y) get_csv2_uint((X),(Y),401) +#define get_csv2_ullong_pos401(X,Y) get_csv2_ullong((X),(Y),401) +#define get_csv2_ip_pos401(X,Y) get_csv2_ip((X),(Y),401) +#define get_csv2_ipv6_pos401(X,Y) get_csv2_ipv6((X),(Y),401) +#define get_csv2_string_pos401(X,Y) get_csv2_string((X),(Y),401) +#define get_csv2_v_str_pos401(X,Y) get_csv2_string((X),(Y),401) +#define get_csv2_bool_pos401(X,Y) get_csv2_bool((X),(Y),401) +#define get_csv2_int_pos401(X,Y) get_csv2_int((X),(Y),401) +#define get_csv2_llong_pos401(X,Y) get_csv2_llong((X),(Y),401) +#define get_csv2_float_pos401(X,Y) get_csv2_float((X),(Y),401) +#define get_csv2_uint_pos402(X,Y) get_csv2_uint((X),(Y),402) +#define get_csv2_ullong_pos402(X,Y) get_csv2_ullong((X),(Y),402) +#define get_csv2_ip_pos402(X,Y) get_csv2_ip((X),(Y),402) +#define get_csv2_ipv6_pos402(X,Y) get_csv2_ipv6((X),(Y),402) +#define get_csv2_string_pos402(X,Y) get_csv2_string((X),(Y),402) +#define get_csv2_v_str_pos402(X,Y) get_csv2_string((X),(Y),402) +#define get_csv2_bool_pos402(X,Y) get_csv2_bool((X),(Y),402) +#define get_csv2_int_pos402(X,Y) get_csv2_int((X),(Y),402) +#define get_csv2_llong_pos402(X,Y) get_csv2_llong((X),(Y),402) +#define get_csv2_float_pos402(X,Y) get_csv2_float((X),(Y),402) +#define get_csv2_uint_pos403(X,Y) get_csv2_uint((X),(Y),403) +#define get_csv2_ullong_pos403(X,Y) get_csv2_ullong((X),(Y),403) +#define get_csv2_ip_pos403(X,Y) get_csv2_ip((X),(Y),403) +#define get_csv2_ipv6_pos403(X,Y) get_csv2_ipv6((X),(Y),403) +#define get_csv2_string_pos403(X,Y) get_csv2_string((X),(Y),403) +#define get_csv2_v_str_pos403(X,Y) get_csv2_string((X),(Y),403) +#define get_csv2_bool_pos403(X,Y) get_csv2_bool((X),(Y),403) +#define get_csv2_int_pos403(X,Y) get_csv2_int((X),(Y),403) +#define get_csv2_llong_pos403(X,Y) get_csv2_llong((X),(Y),403) +#define get_csv2_float_pos403(X,Y) get_csv2_float((X),(Y),403) +#define get_csv2_uint_pos404(X,Y) get_csv2_uint((X),(Y),404) +#define get_csv2_ullong_pos404(X,Y) get_csv2_ullong((X),(Y),404) +#define get_csv2_ip_pos404(X,Y) get_csv2_ip((X),(Y),404) +#define get_csv2_ipv6_pos404(X,Y) get_csv2_ipv6((X),(Y),404) +#define get_csv2_string_pos404(X,Y) get_csv2_string((X),(Y),404) +#define get_csv2_v_str_pos404(X,Y) get_csv2_string((X),(Y),404) +#define get_csv2_bool_pos404(X,Y) get_csv2_bool((X),(Y),404) +#define get_csv2_int_pos404(X,Y) get_csv2_int((X),(Y),404) +#define get_csv2_llong_pos404(X,Y) get_csv2_llong((X),(Y),404) +#define get_csv2_float_pos404(X,Y) get_csv2_float((X),(Y),404) +#define get_csv2_uint_pos405(X,Y) get_csv2_uint((X),(Y),405) +#define get_csv2_ullong_pos405(X,Y) get_csv2_ullong((X),(Y),405) +#define get_csv2_ip_pos405(X,Y) get_csv2_ip((X),(Y),405) +#define get_csv2_ipv6_pos405(X,Y) get_csv2_ipv6((X),(Y),405) +#define get_csv2_string_pos405(X,Y) get_csv2_string((X),(Y),405) +#define get_csv2_v_str_pos405(X,Y) get_csv2_string((X),(Y),405) +#define get_csv2_bool_pos405(X,Y) get_csv2_bool((X),(Y),405) +#define get_csv2_int_pos405(X,Y) get_csv2_int((X),(Y),405) +#define get_csv2_llong_pos405(X,Y) get_csv2_llong((X),(Y),405) +#define get_csv2_float_pos405(X,Y) get_csv2_float((X),(Y),405) +#define get_csv2_uint_pos406(X,Y) get_csv2_uint((X),(Y),406) +#define get_csv2_ullong_pos406(X,Y) get_csv2_ullong((X),(Y),406) +#define get_csv2_ip_pos406(X,Y) get_csv2_ip((X),(Y),406) +#define get_csv2_ipv6_pos406(X,Y) get_csv2_ipv6((X),(Y),406) +#define get_csv2_string_pos406(X,Y) get_csv2_string((X),(Y),406) +#define get_csv2_v_str_pos406(X,Y) get_csv2_string((X),(Y),406) +#define get_csv2_bool_pos406(X,Y) get_csv2_bool((X),(Y),406) +#define get_csv2_int_pos406(X,Y) get_csv2_int((X),(Y),406) +#define get_csv2_llong_pos406(X,Y) get_csv2_llong((X),(Y),406) +#define get_csv2_float_pos406(X,Y) get_csv2_float((X),(Y),406) +#define get_csv2_uint_pos407(X,Y) get_csv2_uint((X),(Y),407) +#define get_csv2_ullong_pos407(X,Y) get_csv2_ullong((X),(Y),407) +#define get_csv2_ip_pos407(X,Y) get_csv2_ip((X),(Y),407) +#define get_csv2_ipv6_pos407(X,Y) get_csv2_ipv6((X),(Y),407) +#define get_csv2_string_pos407(X,Y) get_csv2_string((X),(Y),407) +#define get_csv2_v_str_pos407(X,Y) get_csv2_string((X),(Y),407) +#define get_csv2_bool_pos407(X,Y) get_csv2_bool((X),(Y),407) +#define get_csv2_int_pos407(X,Y) get_csv2_int((X),(Y),407) +#define get_csv2_llong_pos407(X,Y) get_csv2_llong((X),(Y),407) +#define get_csv2_float_pos407(X,Y) get_csv2_float((X),(Y),407) +#define get_csv2_uint_pos408(X,Y) get_csv2_uint((X),(Y),408) +#define get_csv2_ullong_pos408(X,Y) get_csv2_ullong((X),(Y),408) +#define get_csv2_ip_pos408(X,Y) get_csv2_ip((X),(Y),408) +#define get_csv2_ipv6_pos408(X,Y) get_csv2_ipv6((X),(Y),408) +#define get_csv2_string_pos408(X,Y) get_csv2_string((X),(Y),408) +#define get_csv2_v_str_pos408(X,Y) get_csv2_string((X),(Y),408) +#define get_csv2_bool_pos408(X,Y) get_csv2_bool((X),(Y),408) +#define get_csv2_int_pos408(X,Y) get_csv2_int((X),(Y),408) +#define get_csv2_llong_pos408(X,Y) get_csv2_llong((X),(Y),408) +#define get_csv2_float_pos408(X,Y) get_csv2_float((X),(Y),408) +#define get_csv2_uint_pos409(X,Y) get_csv2_uint((X),(Y),409) +#define get_csv2_ullong_pos409(X,Y) get_csv2_ullong((X),(Y),409) +#define get_csv2_ip_pos409(X,Y) get_csv2_ip((X),(Y),409) +#define get_csv2_ipv6_pos409(X,Y) get_csv2_ipv6((X),(Y),409) +#define get_csv2_string_pos409(X,Y) get_csv2_string((X),(Y),409) +#define get_csv2_v_str_pos409(X,Y) get_csv2_string((X),(Y),409) +#define get_csv2_bool_pos409(X,Y) get_csv2_bool((X),(Y),409) +#define get_csv2_int_pos409(X,Y) get_csv2_int((X),(Y),409) +#define get_csv2_llong_pos409(X,Y) get_csv2_llong((X),(Y),409) +#define get_csv2_float_pos409(X,Y) get_csv2_float((X),(Y),409) +#define get_csv2_uint_pos410(X,Y) get_csv2_uint((X),(Y),410) +#define get_csv2_ullong_pos410(X,Y) get_csv2_ullong((X),(Y),410) +#define get_csv2_ip_pos410(X,Y) get_csv2_ip((X),(Y),410) +#define get_csv2_ipv6_pos410(X,Y) get_csv2_ipv6((X),(Y),410) +#define get_csv2_string_pos410(X,Y) get_csv2_string((X),(Y),410) +#define get_csv2_v_str_pos410(X,Y) get_csv2_string((X),(Y),410) +#define get_csv2_bool_pos410(X,Y) get_csv2_bool((X),(Y),410) +#define get_csv2_int_pos410(X,Y) get_csv2_int((X),(Y),410) +#define get_csv2_llong_pos410(X,Y) get_csv2_llong((X),(Y),410) +#define get_csv2_float_pos410(X,Y) get_csv2_float((X),(Y),410) +#define get_csv2_uint_pos411(X,Y) get_csv2_uint((X),(Y),411) +#define get_csv2_ullong_pos411(X,Y) get_csv2_ullong((X),(Y),411) +#define get_csv2_ip_pos411(X,Y) get_csv2_ip((X),(Y),411) +#define get_csv2_ipv6_pos411(X,Y) get_csv2_ipv6((X),(Y),411) +#define get_csv2_string_pos411(X,Y) get_csv2_string((X),(Y),411) +#define get_csv2_v_str_pos411(X,Y) get_csv2_string((X),(Y),411) +#define get_csv2_bool_pos411(X,Y) get_csv2_bool((X),(Y),411) +#define get_csv2_int_pos411(X,Y) get_csv2_int((X),(Y),411) +#define get_csv2_llong_pos411(X,Y) get_csv2_llong((X),(Y),411) +#define get_csv2_float_pos411(X,Y) get_csv2_float((X),(Y),411) +#define get_csv2_uint_pos412(X,Y) get_csv2_uint((X),(Y),412) +#define get_csv2_ullong_pos412(X,Y) get_csv2_ullong((X),(Y),412) +#define get_csv2_ip_pos412(X,Y) get_csv2_ip((X),(Y),412) +#define get_csv2_ipv6_pos412(X,Y) get_csv2_ipv6((X),(Y),412) +#define get_csv2_string_pos412(X,Y) get_csv2_string((X),(Y),412) +#define get_csv2_v_str_pos412(X,Y) get_csv2_string((X),(Y),412) +#define get_csv2_bool_pos412(X,Y) get_csv2_bool((X),(Y),412) +#define get_csv2_int_pos412(X,Y) get_csv2_int((X),(Y),412) +#define get_csv2_llong_pos412(X,Y) get_csv2_llong((X),(Y),412) +#define get_csv2_float_pos412(X,Y) get_csv2_float((X),(Y),412) +#define get_csv2_uint_pos413(X,Y) get_csv2_uint((X),(Y),413) +#define get_csv2_ullong_pos413(X,Y) get_csv2_ullong((X),(Y),413) +#define get_csv2_ip_pos413(X,Y) get_csv2_ip((X),(Y),413) +#define get_csv2_ipv6_pos413(X,Y) get_csv2_ipv6((X),(Y),413) +#define get_csv2_string_pos413(X,Y) get_csv2_string((X),(Y),413) +#define get_csv2_v_str_pos413(X,Y) get_csv2_string((X),(Y),413) +#define get_csv2_bool_pos413(X,Y) get_csv2_bool((X),(Y),413) +#define get_csv2_int_pos413(X,Y) get_csv2_int((X),(Y),413) +#define get_csv2_llong_pos413(X,Y) get_csv2_llong((X),(Y),413) +#define get_csv2_float_pos413(X,Y) get_csv2_float((X),(Y),413) +#define get_csv2_uint_pos414(X,Y) get_csv2_uint((X),(Y),414) +#define get_csv2_ullong_pos414(X,Y) get_csv2_ullong((X),(Y),414) +#define get_csv2_ip_pos414(X,Y) get_csv2_ip((X),(Y),414) +#define get_csv2_ipv6_pos414(X,Y) get_csv2_ipv6((X),(Y),414) +#define get_csv2_string_pos414(X,Y) get_csv2_string((X),(Y),414) +#define get_csv2_v_str_pos414(X,Y) get_csv2_string((X),(Y),414) +#define get_csv2_bool_pos414(X,Y) get_csv2_bool((X),(Y),414) +#define get_csv2_int_pos414(X,Y) get_csv2_int((X),(Y),414) +#define get_csv2_llong_pos414(X,Y) get_csv2_llong((X),(Y),414) +#define get_csv2_float_pos414(X,Y) get_csv2_float((X),(Y),414) +#define get_csv2_uint_pos415(X,Y) get_csv2_uint((X),(Y),415) +#define get_csv2_ullong_pos415(X,Y) get_csv2_ullong((X),(Y),415) +#define get_csv2_ip_pos415(X,Y) get_csv2_ip((X),(Y),415) +#define get_csv2_ipv6_pos415(X,Y) get_csv2_ipv6((X),(Y),415) +#define get_csv2_string_pos415(X,Y) get_csv2_string((X),(Y),415) +#define get_csv2_v_str_pos415(X,Y) get_csv2_string((X),(Y),415) +#define get_csv2_bool_pos415(X,Y) get_csv2_bool((X),(Y),415) +#define get_csv2_int_pos415(X,Y) get_csv2_int((X),(Y),415) +#define get_csv2_llong_pos415(X,Y) get_csv2_llong((X),(Y),415) +#define get_csv2_float_pos415(X,Y) get_csv2_float((X),(Y),415) +#define get_csv2_uint_pos416(X,Y) get_csv2_uint((X),(Y),416) +#define get_csv2_ullong_pos416(X,Y) get_csv2_ullong((X),(Y),416) +#define get_csv2_ip_pos416(X,Y) get_csv2_ip((X),(Y),416) +#define get_csv2_ipv6_pos416(X,Y) get_csv2_ipv6((X),(Y),416) +#define get_csv2_string_pos416(X,Y) get_csv2_string((X),(Y),416) +#define get_csv2_v_str_pos416(X,Y) get_csv2_string((X),(Y),416) +#define get_csv2_bool_pos416(X,Y) get_csv2_bool((X),(Y),416) +#define get_csv2_int_pos416(X,Y) get_csv2_int((X),(Y),416) +#define get_csv2_llong_pos416(X,Y) get_csv2_llong((X),(Y),416) +#define get_csv2_float_pos416(X,Y) get_csv2_float((X),(Y),416) +#define get_csv2_uint_pos417(X,Y) get_csv2_uint((X),(Y),417) +#define get_csv2_ullong_pos417(X,Y) get_csv2_ullong((X),(Y),417) +#define get_csv2_ip_pos417(X,Y) get_csv2_ip((X),(Y),417) +#define get_csv2_ipv6_pos417(X,Y) get_csv2_ipv6((X),(Y),417) +#define get_csv2_string_pos417(X,Y) get_csv2_string((X),(Y),417) +#define get_csv2_v_str_pos417(X,Y) get_csv2_string((X),(Y),417) +#define get_csv2_bool_pos417(X,Y) get_csv2_bool((X),(Y),417) +#define get_csv2_int_pos417(X,Y) get_csv2_int((X),(Y),417) +#define get_csv2_llong_pos417(X,Y) get_csv2_llong((X),(Y),417) +#define get_csv2_float_pos417(X,Y) get_csv2_float((X),(Y),417) +#define get_csv2_uint_pos418(X,Y) get_csv2_uint((X),(Y),418) +#define get_csv2_ullong_pos418(X,Y) get_csv2_ullong((X),(Y),418) +#define get_csv2_ip_pos418(X,Y) get_csv2_ip((X),(Y),418) +#define get_csv2_ipv6_pos418(X,Y) get_csv2_ipv6((X),(Y),418) +#define get_csv2_string_pos418(X,Y) get_csv2_string((X),(Y),418) +#define get_csv2_v_str_pos418(X,Y) get_csv2_string((X),(Y),418) +#define get_csv2_bool_pos418(X,Y) get_csv2_bool((X),(Y),418) +#define get_csv2_int_pos418(X,Y) get_csv2_int((X),(Y),418) +#define get_csv2_llong_pos418(X,Y) get_csv2_llong((X),(Y),418) +#define get_csv2_float_pos418(X,Y) get_csv2_float((X),(Y),418) +#define get_csv2_uint_pos419(X,Y) get_csv2_uint((X),(Y),419) +#define get_csv2_ullong_pos419(X,Y) get_csv2_ullong((X),(Y),419) +#define get_csv2_ip_pos419(X,Y) get_csv2_ip((X),(Y),419) +#define get_csv2_ipv6_pos419(X,Y) get_csv2_ipv6((X),(Y),419) +#define get_csv2_string_pos419(X,Y) get_csv2_string((X),(Y),419) +#define get_csv2_v_str_pos419(X,Y) get_csv2_string((X),(Y),419) +#define get_csv2_bool_pos419(X,Y) get_csv2_bool((X),(Y),419) +#define get_csv2_int_pos419(X,Y) get_csv2_int((X),(Y),419) +#define get_csv2_llong_pos419(X,Y) get_csv2_llong((X),(Y),419) +#define get_csv2_float_pos419(X,Y) get_csv2_float((X),(Y),419) +#define get_csv2_uint_pos420(X,Y) get_csv2_uint((X),(Y),420) +#define get_csv2_ullong_pos420(X,Y) get_csv2_ullong((X),(Y),420) +#define get_csv2_ip_pos420(X,Y) get_csv2_ip((X),(Y),420) +#define get_csv2_ipv6_pos420(X,Y) get_csv2_ipv6((X),(Y),420) +#define get_csv2_string_pos420(X,Y) get_csv2_string((X),(Y),420) +#define get_csv2_v_str_pos420(X,Y) get_csv2_string((X),(Y),420) +#define get_csv2_bool_pos420(X,Y) get_csv2_bool((X),(Y),420) +#define get_csv2_int_pos420(X,Y) get_csv2_int((X),(Y),420) +#define get_csv2_llong_pos420(X,Y) get_csv2_llong((X),(Y),420) +#define get_csv2_float_pos420(X,Y) get_csv2_float((X),(Y),420) +#define get_csv2_uint_pos421(X,Y) get_csv2_uint((X),(Y),421) +#define get_csv2_ullong_pos421(X,Y) get_csv2_ullong((X),(Y),421) +#define get_csv2_ip_pos421(X,Y) get_csv2_ip((X),(Y),421) +#define get_csv2_ipv6_pos421(X,Y) get_csv2_ipv6((X),(Y),421) +#define get_csv2_string_pos421(X,Y) get_csv2_string((X),(Y),421) +#define get_csv2_v_str_pos421(X,Y) get_csv2_string((X),(Y),421) +#define get_csv2_bool_pos421(X,Y) get_csv2_bool((X),(Y),421) +#define get_csv2_int_pos421(X,Y) get_csv2_int((X),(Y),421) +#define get_csv2_llong_pos421(X,Y) get_csv2_llong((X),(Y),421) +#define get_csv2_float_pos421(X,Y) get_csv2_float((X),(Y),421) +#define get_csv2_uint_pos422(X,Y) get_csv2_uint((X),(Y),422) +#define get_csv2_ullong_pos422(X,Y) get_csv2_ullong((X),(Y),422) +#define get_csv2_ip_pos422(X,Y) get_csv2_ip((X),(Y),422) +#define get_csv2_ipv6_pos422(X,Y) get_csv2_ipv6((X),(Y),422) +#define get_csv2_string_pos422(X,Y) get_csv2_string((X),(Y),422) +#define get_csv2_v_str_pos422(X,Y) get_csv2_string((X),(Y),422) +#define get_csv2_bool_pos422(X,Y) get_csv2_bool((X),(Y),422) +#define get_csv2_int_pos422(X,Y) get_csv2_int((X),(Y),422) +#define get_csv2_llong_pos422(X,Y) get_csv2_llong((X),(Y),422) +#define get_csv2_float_pos422(X,Y) get_csv2_float((X),(Y),422) +#define get_csv2_uint_pos423(X,Y) get_csv2_uint((X),(Y),423) +#define get_csv2_ullong_pos423(X,Y) get_csv2_ullong((X),(Y),423) +#define get_csv2_ip_pos423(X,Y) get_csv2_ip((X),(Y),423) +#define get_csv2_ipv6_pos423(X,Y) get_csv2_ipv6((X),(Y),423) +#define get_csv2_string_pos423(X,Y) get_csv2_string((X),(Y),423) +#define get_csv2_v_str_pos423(X,Y) get_csv2_string((X),(Y),423) +#define get_csv2_bool_pos423(X,Y) get_csv2_bool((X),(Y),423) +#define get_csv2_int_pos423(X,Y) get_csv2_int((X),(Y),423) +#define get_csv2_llong_pos423(X,Y) get_csv2_llong((X),(Y),423) +#define get_csv2_float_pos423(X,Y) get_csv2_float((X),(Y),423) +#define get_csv2_uint_pos424(X,Y) get_csv2_uint((X),(Y),424) +#define get_csv2_ullong_pos424(X,Y) get_csv2_ullong((X),(Y),424) +#define get_csv2_ip_pos424(X,Y) get_csv2_ip((X),(Y),424) +#define get_csv2_ipv6_pos424(X,Y) get_csv2_ipv6((X),(Y),424) +#define get_csv2_string_pos424(X,Y) get_csv2_string((X),(Y),424) +#define get_csv2_v_str_pos424(X,Y) get_csv2_string((X),(Y),424) +#define get_csv2_bool_pos424(X,Y) get_csv2_bool((X),(Y),424) +#define get_csv2_int_pos424(X,Y) get_csv2_int((X),(Y),424) +#define get_csv2_llong_pos424(X,Y) get_csv2_llong((X),(Y),424) +#define get_csv2_float_pos424(X,Y) get_csv2_float((X),(Y),424) +#define get_csv2_uint_pos425(X,Y) get_csv2_uint((X),(Y),425) +#define get_csv2_ullong_pos425(X,Y) get_csv2_ullong((X),(Y),425) +#define get_csv2_ip_pos425(X,Y) get_csv2_ip((X),(Y),425) +#define get_csv2_ipv6_pos425(X,Y) get_csv2_ipv6((X),(Y),425) +#define get_csv2_string_pos425(X,Y) get_csv2_string((X),(Y),425) +#define get_csv2_v_str_pos425(X,Y) get_csv2_string((X),(Y),425) +#define get_csv2_bool_pos425(X,Y) get_csv2_bool((X),(Y),425) +#define get_csv2_int_pos425(X,Y) get_csv2_int((X),(Y),425) +#define get_csv2_llong_pos425(X,Y) get_csv2_llong((X),(Y),425) +#define get_csv2_float_pos425(X,Y) get_csv2_float((X),(Y),425) +#define get_csv2_uint_pos426(X,Y) get_csv2_uint((X),(Y),426) +#define get_csv2_ullong_pos426(X,Y) get_csv2_ullong((X),(Y),426) +#define get_csv2_ip_pos426(X,Y) get_csv2_ip((X),(Y),426) +#define get_csv2_ipv6_pos426(X,Y) get_csv2_ipv6((X),(Y),426) +#define get_csv2_string_pos426(X,Y) get_csv2_string((X),(Y),426) +#define get_csv2_v_str_pos426(X,Y) get_csv2_string((X),(Y),426) +#define get_csv2_bool_pos426(X,Y) get_csv2_bool((X),(Y),426) +#define get_csv2_int_pos426(X,Y) get_csv2_int((X),(Y),426) +#define get_csv2_llong_pos426(X,Y) get_csv2_llong((X),(Y),426) +#define get_csv2_float_pos426(X,Y) get_csv2_float((X),(Y),426) +#define get_csv2_uint_pos427(X,Y) get_csv2_uint((X),(Y),427) +#define get_csv2_ullong_pos427(X,Y) get_csv2_ullong((X),(Y),427) +#define get_csv2_ip_pos427(X,Y) get_csv2_ip((X),(Y),427) +#define get_csv2_ipv6_pos427(X,Y) get_csv2_ipv6((X),(Y),427) +#define get_csv2_string_pos427(X,Y) get_csv2_string((X),(Y),427) +#define get_csv2_v_str_pos427(X,Y) get_csv2_string((X),(Y),427) +#define get_csv2_bool_pos427(X,Y) get_csv2_bool((X),(Y),427) +#define get_csv2_int_pos427(X,Y) get_csv2_int((X),(Y),427) +#define get_csv2_llong_pos427(X,Y) get_csv2_llong((X),(Y),427) +#define get_csv2_float_pos427(X,Y) get_csv2_float((X),(Y),427) +#define get_csv2_uint_pos428(X,Y) get_csv2_uint((X),(Y),428) +#define get_csv2_ullong_pos428(X,Y) get_csv2_ullong((X),(Y),428) +#define get_csv2_ip_pos428(X,Y) get_csv2_ip((X),(Y),428) +#define get_csv2_ipv6_pos428(X,Y) get_csv2_ipv6((X),(Y),428) +#define get_csv2_string_pos428(X,Y) get_csv2_string((X),(Y),428) +#define get_csv2_v_str_pos428(X,Y) get_csv2_string((X),(Y),428) +#define get_csv2_bool_pos428(X,Y) get_csv2_bool((X),(Y),428) +#define get_csv2_int_pos428(X,Y) get_csv2_int((X),(Y),428) +#define get_csv2_llong_pos428(X,Y) get_csv2_llong((X),(Y),428) +#define get_csv2_float_pos428(X,Y) get_csv2_float((X),(Y),428) +#define get_csv2_uint_pos429(X,Y) get_csv2_uint((X),(Y),429) +#define get_csv2_ullong_pos429(X,Y) get_csv2_ullong((X),(Y),429) +#define get_csv2_ip_pos429(X,Y) get_csv2_ip((X),(Y),429) +#define get_csv2_ipv6_pos429(X,Y) get_csv2_ipv6((X),(Y),429) +#define get_csv2_string_pos429(X,Y) get_csv2_string((X),(Y),429) +#define get_csv2_v_str_pos429(X,Y) get_csv2_string((X),(Y),429) +#define get_csv2_bool_pos429(X,Y) get_csv2_bool((X),(Y),429) +#define get_csv2_int_pos429(X,Y) get_csv2_int((X),(Y),429) +#define get_csv2_llong_pos429(X,Y) get_csv2_llong((X),(Y),429) +#define get_csv2_float_pos429(X,Y) get_csv2_float((X),(Y),429) +#define get_csv2_uint_pos430(X,Y) get_csv2_uint((X),(Y),430) +#define get_csv2_ullong_pos430(X,Y) get_csv2_ullong((X),(Y),430) +#define get_csv2_ip_pos430(X,Y) get_csv2_ip((X),(Y),430) +#define get_csv2_ipv6_pos430(X,Y) get_csv2_ipv6((X),(Y),430) +#define get_csv2_string_pos430(X,Y) get_csv2_string((X),(Y),430) +#define get_csv2_v_str_pos430(X,Y) get_csv2_string((X),(Y),430) +#define get_csv2_bool_pos430(X,Y) get_csv2_bool((X),(Y),430) +#define get_csv2_int_pos430(X,Y) get_csv2_int((X),(Y),430) +#define get_csv2_llong_pos430(X,Y) get_csv2_llong((X),(Y),430) +#define get_csv2_float_pos430(X,Y) get_csv2_float((X),(Y),430) +#define get_csv2_uint_pos431(X,Y) get_csv2_uint((X),(Y),431) +#define get_csv2_ullong_pos431(X,Y) get_csv2_ullong((X),(Y),431) +#define get_csv2_ip_pos431(X,Y) get_csv2_ip((X),(Y),431) +#define get_csv2_ipv6_pos431(X,Y) get_csv2_ipv6((X),(Y),431) +#define get_csv2_string_pos431(X,Y) get_csv2_string((X),(Y),431) +#define get_csv2_v_str_pos431(X,Y) get_csv2_string((X),(Y),431) +#define get_csv2_bool_pos431(X,Y) get_csv2_bool((X),(Y),431) +#define get_csv2_int_pos431(X,Y) get_csv2_int((X),(Y),431) +#define get_csv2_llong_pos431(X,Y) get_csv2_llong((X),(Y),431) +#define get_csv2_float_pos431(X,Y) get_csv2_float((X),(Y),431) +#define get_csv2_uint_pos432(X,Y) get_csv2_uint((X),(Y),432) +#define get_csv2_ullong_pos432(X,Y) get_csv2_ullong((X),(Y),432) +#define get_csv2_ip_pos432(X,Y) get_csv2_ip((X),(Y),432) +#define get_csv2_ipv6_pos432(X,Y) get_csv2_ipv6((X),(Y),432) +#define get_csv2_string_pos432(X,Y) get_csv2_string((X),(Y),432) +#define get_csv2_v_str_pos432(X,Y) get_csv2_string((X),(Y),432) +#define get_csv2_bool_pos432(X,Y) get_csv2_bool((X),(Y),432) +#define get_csv2_int_pos432(X,Y) get_csv2_int((X),(Y),432) +#define get_csv2_llong_pos432(X,Y) get_csv2_llong((X),(Y),432) +#define get_csv2_float_pos432(X,Y) get_csv2_float((X),(Y),432) +#define get_csv2_uint_pos433(X,Y) get_csv2_uint((X),(Y),433) +#define get_csv2_ullong_pos433(X,Y) get_csv2_ullong((X),(Y),433) +#define get_csv2_ip_pos433(X,Y) get_csv2_ip((X),(Y),433) +#define get_csv2_ipv6_pos433(X,Y) get_csv2_ipv6((X),(Y),433) +#define get_csv2_string_pos433(X,Y) get_csv2_string((X),(Y),433) +#define get_csv2_v_str_pos433(X,Y) get_csv2_string((X),(Y),433) +#define get_csv2_bool_pos433(X,Y) get_csv2_bool((X),(Y),433) +#define get_csv2_int_pos433(X,Y) get_csv2_int((X),(Y),433) +#define get_csv2_llong_pos433(X,Y) get_csv2_llong((X),(Y),433) +#define get_csv2_float_pos433(X,Y) get_csv2_float((X),(Y),433) +#define get_csv2_uint_pos434(X,Y) get_csv2_uint((X),(Y),434) +#define get_csv2_ullong_pos434(X,Y) get_csv2_ullong((X),(Y),434) +#define get_csv2_ip_pos434(X,Y) get_csv2_ip((X),(Y),434) +#define get_csv2_ipv6_pos434(X,Y) get_csv2_ipv6((X),(Y),434) +#define get_csv2_string_pos434(X,Y) get_csv2_string((X),(Y),434) +#define get_csv2_v_str_pos434(X,Y) get_csv2_string((X),(Y),434) +#define get_csv2_bool_pos434(X,Y) get_csv2_bool((X),(Y),434) +#define get_csv2_int_pos434(X,Y) get_csv2_int((X),(Y),434) +#define get_csv2_llong_pos434(X,Y) get_csv2_llong((X),(Y),434) +#define get_csv2_float_pos434(X,Y) get_csv2_float((X),(Y),434) +#define get_csv2_uint_pos435(X,Y) get_csv2_uint((X),(Y),435) +#define get_csv2_ullong_pos435(X,Y) get_csv2_ullong((X),(Y),435) +#define get_csv2_ip_pos435(X,Y) get_csv2_ip((X),(Y),435) +#define get_csv2_ipv6_pos435(X,Y) get_csv2_ipv6((X),(Y),435) +#define get_csv2_string_pos435(X,Y) get_csv2_string((X),(Y),435) +#define get_csv2_v_str_pos435(X,Y) get_csv2_string((X),(Y),435) +#define get_csv2_bool_pos435(X,Y) get_csv2_bool((X),(Y),435) +#define get_csv2_int_pos435(X,Y) get_csv2_int((X),(Y),435) +#define get_csv2_llong_pos435(X,Y) get_csv2_llong((X),(Y),435) +#define get_csv2_float_pos435(X,Y) get_csv2_float((X),(Y),435) +#define get_csv2_uint_pos436(X,Y) get_csv2_uint((X),(Y),436) +#define get_csv2_ullong_pos436(X,Y) get_csv2_ullong((X),(Y),436) +#define get_csv2_ip_pos436(X,Y) get_csv2_ip((X),(Y),436) +#define get_csv2_ipv6_pos436(X,Y) get_csv2_ipv6((X),(Y),436) +#define get_csv2_string_pos436(X,Y) get_csv2_string((X),(Y),436) +#define get_csv2_v_str_pos436(X,Y) get_csv2_string((X),(Y),436) +#define get_csv2_bool_pos436(X,Y) get_csv2_bool((X),(Y),436) +#define get_csv2_int_pos436(X,Y) get_csv2_int((X),(Y),436) +#define get_csv2_llong_pos436(X,Y) get_csv2_llong((X),(Y),436) +#define get_csv2_float_pos436(X,Y) get_csv2_float((X),(Y),436) +#define get_csv2_uint_pos437(X,Y) get_csv2_uint((X),(Y),437) +#define get_csv2_ullong_pos437(X,Y) get_csv2_ullong((X),(Y),437) +#define get_csv2_ip_pos437(X,Y) get_csv2_ip((X),(Y),437) +#define get_csv2_ipv6_pos437(X,Y) get_csv2_ipv6((X),(Y),437) +#define get_csv2_string_pos437(X,Y) get_csv2_string((X),(Y),437) +#define get_csv2_v_str_pos437(X,Y) get_csv2_string((X),(Y),437) +#define get_csv2_bool_pos437(X,Y) get_csv2_bool((X),(Y),437) +#define get_csv2_int_pos437(X,Y) get_csv2_int((X),(Y),437) +#define get_csv2_llong_pos437(X,Y) get_csv2_llong((X),(Y),437) +#define get_csv2_float_pos437(X,Y) get_csv2_float((X),(Y),437) +#define get_csv2_uint_pos438(X,Y) get_csv2_uint((X),(Y),438) +#define get_csv2_ullong_pos438(X,Y) get_csv2_ullong((X),(Y),438) +#define get_csv2_ip_pos438(X,Y) get_csv2_ip((X),(Y),438) +#define get_csv2_ipv6_pos438(X,Y) get_csv2_ipv6((X),(Y),438) +#define get_csv2_string_pos438(X,Y) get_csv2_string((X),(Y),438) +#define get_csv2_v_str_pos438(X,Y) get_csv2_string((X),(Y),438) +#define get_csv2_bool_pos438(X,Y) get_csv2_bool((X),(Y),438) +#define get_csv2_int_pos438(X,Y) get_csv2_int((X),(Y),438) +#define get_csv2_llong_pos438(X,Y) get_csv2_llong((X),(Y),438) +#define get_csv2_float_pos438(X,Y) get_csv2_float((X),(Y),438) +#define get_csv2_uint_pos439(X,Y) get_csv2_uint((X),(Y),439) +#define get_csv2_ullong_pos439(X,Y) get_csv2_ullong((X),(Y),439) +#define get_csv2_ip_pos439(X,Y) get_csv2_ip((X),(Y),439) +#define get_csv2_ipv6_pos439(X,Y) get_csv2_ipv6((X),(Y),439) +#define get_csv2_string_pos439(X,Y) get_csv2_string((X),(Y),439) +#define get_csv2_v_str_pos439(X,Y) get_csv2_string((X),(Y),439) +#define get_csv2_bool_pos439(X,Y) get_csv2_bool((X),(Y),439) +#define get_csv2_int_pos439(X,Y) get_csv2_int((X),(Y),439) +#define get_csv2_llong_pos439(X,Y) get_csv2_llong((X),(Y),439) +#define get_csv2_float_pos439(X,Y) get_csv2_float((X),(Y),439) +#define get_csv2_uint_pos440(X,Y) get_csv2_uint((X),(Y),440) +#define get_csv2_ullong_pos440(X,Y) get_csv2_ullong((X),(Y),440) +#define get_csv2_ip_pos440(X,Y) get_csv2_ip((X),(Y),440) +#define get_csv2_ipv6_pos440(X,Y) get_csv2_ipv6((X),(Y),440) +#define get_csv2_string_pos440(X,Y) get_csv2_string((X),(Y),440) +#define get_csv2_v_str_pos440(X,Y) get_csv2_string((X),(Y),440) +#define get_csv2_bool_pos440(X,Y) get_csv2_bool((X),(Y),440) +#define get_csv2_int_pos440(X,Y) get_csv2_int((X),(Y),440) +#define get_csv2_llong_pos440(X,Y) get_csv2_llong((X),(Y),440) +#define get_csv2_float_pos440(X,Y) get_csv2_float((X),(Y),440) +#define get_csv2_uint_pos441(X,Y) get_csv2_uint((X),(Y),441) +#define get_csv2_ullong_pos441(X,Y) get_csv2_ullong((X),(Y),441) +#define get_csv2_ip_pos441(X,Y) get_csv2_ip((X),(Y),441) +#define get_csv2_ipv6_pos441(X,Y) get_csv2_ipv6((X),(Y),441) +#define get_csv2_string_pos441(X,Y) get_csv2_string((X),(Y),441) +#define get_csv2_v_str_pos441(X,Y) get_csv2_string((X),(Y),441) +#define get_csv2_bool_pos441(X,Y) get_csv2_bool((X),(Y),441) +#define get_csv2_int_pos441(X,Y) get_csv2_int((X),(Y),441) +#define get_csv2_llong_pos441(X,Y) get_csv2_llong((X),(Y),441) +#define get_csv2_float_pos441(X,Y) get_csv2_float((X),(Y),441) +#define get_csv2_uint_pos442(X,Y) get_csv2_uint((X),(Y),442) +#define get_csv2_ullong_pos442(X,Y) get_csv2_ullong((X),(Y),442) +#define get_csv2_ip_pos442(X,Y) get_csv2_ip((X),(Y),442) +#define get_csv2_ipv6_pos442(X,Y) get_csv2_ipv6((X),(Y),442) +#define get_csv2_string_pos442(X,Y) get_csv2_string((X),(Y),442) +#define get_csv2_v_str_pos442(X,Y) get_csv2_string((X),(Y),442) +#define get_csv2_bool_pos442(X,Y) get_csv2_bool((X),(Y),442) +#define get_csv2_int_pos442(X,Y) get_csv2_int((X),(Y),442) +#define get_csv2_llong_pos442(X,Y) get_csv2_llong((X),(Y),442) +#define get_csv2_float_pos442(X,Y) get_csv2_float((X),(Y),442) +#define get_csv2_uint_pos443(X,Y) get_csv2_uint((X),(Y),443) +#define get_csv2_ullong_pos443(X,Y) get_csv2_ullong((X),(Y),443) +#define get_csv2_ip_pos443(X,Y) get_csv2_ip((X),(Y),443) +#define get_csv2_ipv6_pos443(X,Y) get_csv2_ipv6((X),(Y),443) +#define get_csv2_string_pos443(X,Y) get_csv2_string((X),(Y),443) +#define get_csv2_v_str_pos443(X,Y) get_csv2_string((X),(Y),443) +#define get_csv2_bool_pos443(X,Y) get_csv2_bool((X),(Y),443) +#define get_csv2_int_pos443(X,Y) get_csv2_int((X),(Y),443) +#define get_csv2_llong_pos443(X,Y) get_csv2_llong((X),(Y),443) +#define get_csv2_float_pos443(X,Y) get_csv2_float((X),(Y),443) +#define get_csv2_uint_pos444(X,Y) get_csv2_uint((X),(Y),444) +#define get_csv2_ullong_pos444(X,Y) get_csv2_ullong((X),(Y),444) +#define get_csv2_ip_pos444(X,Y) get_csv2_ip((X),(Y),444) +#define get_csv2_ipv6_pos444(X,Y) get_csv2_ipv6((X),(Y),444) +#define get_csv2_string_pos444(X,Y) get_csv2_string((X),(Y),444) +#define get_csv2_v_str_pos444(X,Y) get_csv2_string((X),(Y),444) +#define get_csv2_bool_pos444(X,Y) get_csv2_bool((X),(Y),444) +#define get_csv2_int_pos444(X,Y) get_csv2_int((X),(Y),444) +#define get_csv2_llong_pos444(X,Y) get_csv2_llong((X),(Y),444) +#define get_csv2_float_pos444(X,Y) get_csv2_float((X),(Y),444) +#define get_csv2_uint_pos445(X,Y) get_csv2_uint((X),(Y),445) +#define get_csv2_ullong_pos445(X,Y) get_csv2_ullong((X),(Y),445) +#define get_csv2_ip_pos445(X,Y) get_csv2_ip((X),(Y),445) +#define get_csv2_ipv6_pos445(X,Y) get_csv2_ipv6((X),(Y),445) +#define get_csv2_string_pos445(X,Y) get_csv2_string((X),(Y),445) +#define get_csv2_v_str_pos445(X,Y) get_csv2_string((X),(Y),445) +#define get_csv2_bool_pos445(X,Y) get_csv2_bool((X),(Y),445) +#define get_csv2_int_pos445(X,Y) get_csv2_int((X),(Y),445) +#define get_csv2_llong_pos445(X,Y) get_csv2_llong((X),(Y),445) +#define get_csv2_float_pos445(X,Y) get_csv2_float((X),(Y),445) +#define get_csv2_uint_pos446(X,Y) get_csv2_uint((X),(Y),446) +#define get_csv2_ullong_pos446(X,Y) get_csv2_ullong((X),(Y),446) +#define get_csv2_ip_pos446(X,Y) get_csv2_ip((X),(Y),446) +#define get_csv2_ipv6_pos446(X,Y) get_csv2_ipv6((X),(Y),446) +#define get_csv2_string_pos446(X,Y) get_csv2_string((X),(Y),446) +#define get_csv2_v_str_pos446(X,Y) get_csv2_string((X),(Y),446) +#define get_csv2_bool_pos446(X,Y) get_csv2_bool((X),(Y),446) +#define get_csv2_int_pos446(X,Y) get_csv2_int((X),(Y),446) +#define get_csv2_llong_pos446(X,Y) get_csv2_llong((X),(Y),446) +#define get_csv2_float_pos446(X,Y) get_csv2_float((X),(Y),446) +#define get_csv2_uint_pos447(X,Y) get_csv2_uint((X),(Y),447) +#define get_csv2_ullong_pos447(X,Y) get_csv2_ullong((X),(Y),447) +#define get_csv2_ip_pos447(X,Y) get_csv2_ip((X),(Y),447) +#define get_csv2_ipv6_pos447(X,Y) get_csv2_ipv6((X),(Y),447) +#define get_csv2_string_pos447(X,Y) get_csv2_string((X),(Y),447) +#define get_csv2_v_str_pos447(X,Y) get_csv2_string((X),(Y),447) +#define get_csv2_bool_pos447(X,Y) get_csv2_bool((X),(Y),447) +#define get_csv2_int_pos447(X,Y) get_csv2_int((X),(Y),447) +#define get_csv2_llong_pos447(X,Y) get_csv2_llong((X),(Y),447) +#define get_csv2_float_pos447(X,Y) get_csv2_float((X),(Y),447) +#define get_csv2_uint_pos448(X,Y) get_csv2_uint((X),(Y),448) +#define get_csv2_ullong_pos448(X,Y) get_csv2_ullong((X),(Y),448) +#define get_csv2_ip_pos448(X,Y) get_csv2_ip((X),(Y),448) +#define get_csv2_ipv6_pos448(X,Y) get_csv2_ipv6((X),(Y),448) +#define get_csv2_string_pos448(X,Y) get_csv2_string((X),(Y),448) +#define get_csv2_v_str_pos448(X,Y) get_csv2_string((X),(Y),448) +#define get_csv2_bool_pos448(X,Y) get_csv2_bool((X),(Y),448) +#define get_csv2_int_pos448(X,Y) get_csv2_int((X),(Y),448) +#define get_csv2_llong_pos448(X,Y) get_csv2_llong((X),(Y),448) +#define get_csv2_float_pos448(X,Y) get_csv2_float((X),(Y),448) +#define get_csv2_uint_pos449(X,Y) get_csv2_uint((X),(Y),449) +#define get_csv2_ullong_pos449(X,Y) get_csv2_ullong((X),(Y),449) +#define get_csv2_ip_pos449(X,Y) get_csv2_ip((X),(Y),449) +#define get_csv2_ipv6_pos449(X,Y) get_csv2_ipv6((X),(Y),449) +#define get_csv2_string_pos449(X,Y) get_csv2_string((X),(Y),449) +#define get_csv2_v_str_pos449(X,Y) get_csv2_string((X),(Y),449) +#define get_csv2_bool_pos449(X,Y) get_csv2_bool((X),(Y),449) +#define get_csv2_int_pos449(X,Y) get_csv2_int((X),(Y),449) +#define get_csv2_llong_pos449(X,Y) get_csv2_llong((X),(Y),449) +#define get_csv2_float_pos449(X,Y) get_csv2_float((X),(Y),449) +#define get_csv2_uint_pos450(X,Y) get_csv2_uint((X),(Y),450) +#define get_csv2_ullong_pos450(X,Y) get_csv2_ullong((X),(Y),450) +#define get_csv2_ip_pos450(X,Y) get_csv2_ip((X),(Y),450) +#define get_csv2_ipv6_pos450(X,Y) get_csv2_ipv6((X),(Y),450) +#define get_csv2_string_pos450(X,Y) get_csv2_string((X),(Y),450) +#define get_csv2_v_str_pos450(X,Y) get_csv2_string((X),(Y),450) +#define get_csv2_bool_pos450(X,Y) get_csv2_bool((X),(Y),450) +#define get_csv2_int_pos450(X,Y) get_csv2_int((X),(Y),450) +#define get_csv2_llong_pos450(X,Y) get_csv2_llong((X),(Y),450) +#define get_csv2_float_pos450(X,Y) get_csv2_float((X),(Y),450) +#define get_csv2_uint_pos451(X,Y) get_csv2_uint((X),(Y),451) +#define get_csv2_ullong_pos451(X,Y) get_csv2_ullong((X),(Y),451) +#define get_csv2_ip_pos451(X,Y) get_csv2_ip((X),(Y),451) +#define get_csv2_ipv6_pos451(X,Y) get_csv2_ipv6((X),(Y),451) +#define get_csv2_string_pos451(X,Y) get_csv2_string((X),(Y),451) +#define get_csv2_v_str_pos451(X,Y) get_csv2_string((X),(Y),451) +#define get_csv2_bool_pos451(X,Y) get_csv2_bool((X),(Y),451) +#define get_csv2_int_pos451(X,Y) get_csv2_int((X),(Y),451) +#define get_csv2_llong_pos451(X,Y) get_csv2_llong((X),(Y),451) +#define get_csv2_float_pos451(X,Y) get_csv2_float((X),(Y),451) +#define get_csv2_uint_pos452(X,Y) get_csv2_uint((X),(Y),452) +#define get_csv2_ullong_pos452(X,Y) get_csv2_ullong((X),(Y),452) +#define get_csv2_ip_pos452(X,Y) get_csv2_ip((X),(Y),452) +#define get_csv2_ipv6_pos452(X,Y) get_csv2_ipv6((X),(Y),452) +#define get_csv2_string_pos452(X,Y) get_csv2_string((X),(Y),452) +#define get_csv2_v_str_pos452(X,Y) get_csv2_string((X),(Y),452) +#define get_csv2_bool_pos452(X,Y) get_csv2_bool((X),(Y),452) +#define get_csv2_int_pos452(X,Y) get_csv2_int((X),(Y),452) +#define get_csv2_llong_pos452(X,Y) get_csv2_llong((X),(Y),452) +#define get_csv2_float_pos452(X,Y) get_csv2_float((X),(Y),452) +#define get_csv2_uint_pos453(X,Y) get_csv2_uint((X),(Y),453) +#define get_csv2_ullong_pos453(X,Y) get_csv2_ullong((X),(Y),453) +#define get_csv2_ip_pos453(X,Y) get_csv2_ip((X),(Y),453) +#define get_csv2_ipv6_pos453(X,Y) get_csv2_ipv6((X),(Y),453) +#define get_csv2_string_pos453(X,Y) get_csv2_string((X),(Y),453) +#define get_csv2_v_str_pos453(X,Y) get_csv2_string((X),(Y),453) +#define get_csv2_bool_pos453(X,Y) get_csv2_bool((X),(Y),453) +#define get_csv2_int_pos453(X,Y) get_csv2_int((X),(Y),453) +#define get_csv2_llong_pos453(X,Y) get_csv2_llong((X),(Y),453) +#define get_csv2_float_pos453(X,Y) get_csv2_float((X),(Y),453) +#define get_csv2_uint_pos454(X,Y) get_csv2_uint((X),(Y),454) +#define get_csv2_ullong_pos454(X,Y) get_csv2_ullong((X),(Y),454) +#define get_csv2_ip_pos454(X,Y) get_csv2_ip((X),(Y),454) +#define get_csv2_ipv6_pos454(X,Y) get_csv2_ipv6((X),(Y),454) +#define get_csv2_string_pos454(X,Y) get_csv2_string((X),(Y),454) +#define get_csv2_v_str_pos454(X,Y) get_csv2_string((X),(Y),454) +#define get_csv2_bool_pos454(X,Y) get_csv2_bool((X),(Y),454) +#define get_csv2_int_pos454(X,Y) get_csv2_int((X),(Y),454) +#define get_csv2_llong_pos454(X,Y) get_csv2_llong((X),(Y),454) +#define get_csv2_float_pos454(X,Y) get_csv2_float((X),(Y),454) +#define get_csv2_uint_pos455(X,Y) get_csv2_uint((X),(Y),455) +#define get_csv2_ullong_pos455(X,Y) get_csv2_ullong((X),(Y),455) +#define get_csv2_ip_pos455(X,Y) get_csv2_ip((X),(Y),455) +#define get_csv2_ipv6_pos455(X,Y) get_csv2_ipv6((X),(Y),455) +#define get_csv2_string_pos455(X,Y) get_csv2_string((X),(Y),455) +#define get_csv2_v_str_pos455(X,Y) get_csv2_string((X),(Y),455) +#define get_csv2_bool_pos455(X,Y) get_csv2_bool((X),(Y),455) +#define get_csv2_int_pos455(X,Y) get_csv2_int((X),(Y),455) +#define get_csv2_llong_pos455(X,Y) get_csv2_llong((X),(Y),455) +#define get_csv2_float_pos455(X,Y) get_csv2_float((X),(Y),455) +#define get_csv2_uint_pos456(X,Y) get_csv2_uint((X),(Y),456) +#define get_csv2_ullong_pos456(X,Y) get_csv2_ullong((X),(Y),456) +#define get_csv2_ip_pos456(X,Y) get_csv2_ip((X),(Y),456) +#define get_csv2_ipv6_pos456(X,Y) get_csv2_ipv6((X),(Y),456) +#define get_csv2_string_pos456(X,Y) get_csv2_string((X),(Y),456) +#define get_csv2_v_str_pos456(X,Y) get_csv2_string((X),(Y),456) +#define get_csv2_bool_pos456(X,Y) get_csv2_bool((X),(Y),456) +#define get_csv2_int_pos456(X,Y) get_csv2_int((X),(Y),456) +#define get_csv2_llong_pos456(X,Y) get_csv2_llong((X),(Y),456) +#define get_csv2_float_pos456(X,Y) get_csv2_float((X),(Y),456) +#define get_csv2_uint_pos457(X,Y) get_csv2_uint((X),(Y),457) +#define get_csv2_ullong_pos457(X,Y) get_csv2_ullong((X),(Y),457) +#define get_csv2_ip_pos457(X,Y) get_csv2_ip((X),(Y),457) +#define get_csv2_ipv6_pos457(X,Y) get_csv2_ipv6((X),(Y),457) +#define get_csv2_string_pos457(X,Y) get_csv2_string((X),(Y),457) +#define get_csv2_v_str_pos457(X,Y) get_csv2_string((X),(Y),457) +#define get_csv2_bool_pos457(X,Y) get_csv2_bool((X),(Y),457) +#define get_csv2_int_pos457(X,Y) get_csv2_int((X),(Y),457) +#define get_csv2_llong_pos457(X,Y) get_csv2_llong((X),(Y),457) +#define get_csv2_float_pos457(X,Y) get_csv2_float((X),(Y),457) +#define get_csv2_uint_pos458(X,Y) get_csv2_uint((X),(Y),458) +#define get_csv2_ullong_pos458(X,Y) get_csv2_ullong((X),(Y),458) +#define get_csv2_ip_pos458(X,Y) get_csv2_ip((X),(Y),458) +#define get_csv2_ipv6_pos458(X,Y) get_csv2_ipv6((X),(Y),458) +#define get_csv2_string_pos458(X,Y) get_csv2_string((X),(Y),458) +#define get_csv2_v_str_pos458(X,Y) get_csv2_string((X),(Y),458) +#define get_csv2_bool_pos458(X,Y) get_csv2_bool((X),(Y),458) +#define get_csv2_int_pos458(X,Y) get_csv2_int((X),(Y),458) +#define get_csv2_llong_pos458(X,Y) get_csv2_llong((X),(Y),458) +#define get_csv2_float_pos458(X,Y) get_csv2_float((X),(Y),458) +#define get_csv2_uint_pos459(X,Y) get_csv2_uint((X),(Y),459) +#define get_csv2_ullong_pos459(X,Y) get_csv2_ullong((X),(Y),459) +#define get_csv2_ip_pos459(X,Y) get_csv2_ip((X),(Y),459) +#define get_csv2_ipv6_pos459(X,Y) get_csv2_ipv6((X),(Y),459) +#define get_csv2_string_pos459(X,Y) get_csv2_string((X),(Y),459) +#define get_csv2_v_str_pos459(X,Y) get_csv2_string((X),(Y),459) +#define get_csv2_bool_pos459(X,Y) get_csv2_bool((X),(Y),459) +#define get_csv2_int_pos459(X,Y) get_csv2_int((X),(Y),459) +#define get_csv2_llong_pos459(X,Y) get_csv2_llong((X),(Y),459) +#define get_csv2_float_pos459(X,Y) get_csv2_float((X),(Y),459) +#define get_csv2_uint_pos460(X,Y) get_csv2_uint((X),(Y),460) +#define get_csv2_ullong_pos460(X,Y) get_csv2_ullong((X),(Y),460) +#define get_csv2_ip_pos460(X,Y) get_csv2_ip((X),(Y),460) +#define get_csv2_ipv6_pos460(X,Y) get_csv2_ipv6((X),(Y),460) +#define get_csv2_string_pos460(X,Y) get_csv2_string((X),(Y),460) +#define get_csv2_v_str_pos460(X,Y) get_csv2_string((X),(Y),460) +#define get_csv2_bool_pos460(X,Y) get_csv2_bool((X),(Y),460) +#define get_csv2_int_pos460(X,Y) get_csv2_int((X),(Y),460) +#define get_csv2_llong_pos460(X,Y) get_csv2_llong((X),(Y),460) +#define get_csv2_float_pos460(X,Y) get_csv2_float((X),(Y),460) +#define get_csv2_uint_pos461(X,Y) get_csv2_uint((X),(Y),461) +#define get_csv2_ullong_pos461(X,Y) get_csv2_ullong((X),(Y),461) +#define get_csv2_ip_pos461(X,Y) get_csv2_ip((X),(Y),461) +#define get_csv2_ipv6_pos461(X,Y) get_csv2_ipv6((X),(Y),461) +#define get_csv2_string_pos461(X,Y) get_csv2_string((X),(Y),461) +#define get_csv2_v_str_pos461(X,Y) get_csv2_string((X),(Y),461) +#define get_csv2_bool_pos461(X,Y) get_csv2_bool((X),(Y),461) +#define get_csv2_int_pos461(X,Y) get_csv2_int((X),(Y),461) +#define get_csv2_llong_pos461(X,Y) get_csv2_llong((X),(Y),461) +#define get_csv2_float_pos461(X,Y) get_csv2_float((X),(Y),461) +#define get_csv2_uint_pos462(X,Y) get_csv2_uint((X),(Y),462) +#define get_csv2_ullong_pos462(X,Y) get_csv2_ullong((X),(Y),462) +#define get_csv2_ip_pos462(X,Y) get_csv2_ip((X),(Y),462) +#define get_csv2_ipv6_pos462(X,Y) get_csv2_ipv6((X),(Y),462) +#define get_csv2_string_pos462(X,Y) get_csv2_string((X),(Y),462) +#define get_csv2_v_str_pos462(X,Y) get_csv2_string((X),(Y),462) +#define get_csv2_bool_pos462(X,Y) get_csv2_bool((X),(Y),462) +#define get_csv2_int_pos462(X,Y) get_csv2_int((X),(Y),462) +#define get_csv2_llong_pos462(X,Y) get_csv2_llong((X),(Y),462) +#define get_csv2_float_pos462(X,Y) get_csv2_float((X),(Y),462) +#define get_csv2_uint_pos463(X,Y) get_csv2_uint((X),(Y),463) +#define get_csv2_ullong_pos463(X,Y) get_csv2_ullong((X),(Y),463) +#define get_csv2_ip_pos463(X,Y) get_csv2_ip((X),(Y),463) +#define get_csv2_ipv6_pos463(X,Y) get_csv2_ipv6((X),(Y),463) +#define get_csv2_string_pos463(X,Y) get_csv2_string((X),(Y),463) +#define get_csv2_v_str_pos463(X,Y) get_csv2_string((X),(Y),463) +#define get_csv2_bool_pos463(X,Y) get_csv2_bool((X),(Y),463) +#define get_csv2_int_pos463(X,Y) get_csv2_int((X),(Y),463) +#define get_csv2_llong_pos463(X,Y) get_csv2_llong((X),(Y),463) +#define get_csv2_float_pos463(X,Y) get_csv2_float((X),(Y),463) +#define get_csv2_uint_pos464(X,Y) get_csv2_uint((X),(Y),464) +#define get_csv2_ullong_pos464(X,Y) get_csv2_ullong((X),(Y),464) +#define get_csv2_ip_pos464(X,Y) get_csv2_ip((X),(Y),464) +#define get_csv2_ipv6_pos464(X,Y) get_csv2_ipv6((X),(Y),464) +#define get_csv2_string_pos464(X,Y) get_csv2_string((X),(Y),464) +#define get_csv2_v_str_pos464(X,Y) get_csv2_string((X),(Y),464) +#define get_csv2_bool_pos464(X,Y) get_csv2_bool((X),(Y),464) +#define get_csv2_int_pos464(X,Y) get_csv2_int((X),(Y),464) +#define get_csv2_llong_pos464(X,Y) get_csv2_llong((X),(Y),464) +#define get_csv2_float_pos464(X,Y) get_csv2_float((X),(Y),464) +#define get_csv2_uint_pos465(X,Y) get_csv2_uint((X),(Y),465) +#define get_csv2_ullong_pos465(X,Y) get_csv2_ullong((X),(Y),465) +#define get_csv2_ip_pos465(X,Y) get_csv2_ip((X),(Y),465) +#define get_csv2_ipv6_pos465(X,Y) get_csv2_ipv6((X),(Y),465) +#define get_csv2_string_pos465(X,Y) get_csv2_string((X),(Y),465) +#define get_csv2_v_str_pos465(X,Y) get_csv2_string((X),(Y),465) +#define get_csv2_bool_pos465(X,Y) get_csv2_bool((X),(Y),465) +#define get_csv2_int_pos465(X,Y) get_csv2_int((X),(Y),465) +#define get_csv2_llong_pos465(X,Y) get_csv2_llong((X),(Y),465) +#define get_csv2_float_pos465(X,Y) get_csv2_float((X),(Y),465) +#define get_csv2_uint_pos466(X,Y) get_csv2_uint((X),(Y),466) +#define get_csv2_ullong_pos466(X,Y) get_csv2_ullong((X),(Y),466) +#define get_csv2_ip_pos466(X,Y) get_csv2_ip((X),(Y),466) +#define get_csv2_ipv6_pos466(X,Y) get_csv2_ipv6((X),(Y),466) +#define get_csv2_string_pos466(X,Y) get_csv2_string((X),(Y),466) +#define get_csv2_v_str_pos466(X,Y) get_csv2_string((X),(Y),466) +#define get_csv2_bool_pos466(X,Y) get_csv2_bool((X),(Y),466) +#define get_csv2_int_pos466(X,Y) get_csv2_int((X),(Y),466) +#define get_csv2_llong_pos466(X,Y) get_csv2_llong((X),(Y),466) +#define get_csv2_float_pos466(X,Y) get_csv2_float((X),(Y),466) +#define get_csv2_uint_pos467(X,Y) get_csv2_uint((X),(Y),467) +#define get_csv2_ullong_pos467(X,Y) get_csv2_ullong((X),(Y),467) +#define get_csv2_ip_pos467(X,Y) get_csv2_ip((X),(Y),467) +#define get_csv2_ipv6_pos467(X,Y) get_csv2_ipv6((X),(Y),467) +#define get_csv2_string_pos467(X,Y) get_csv2_string((X),(Y),467) +#define get_csv2_v_str_pos467(X,Y) get_csv2_string((X),(Y),467) +#define get_csv2_bool_pos467(X,Y) get_csv2_bool((X),(Y),467) +#define get_csv2_int_pos467(X,Y) get_csv2_int((X),(Y),467) +#define get_csv2_llong_pos467(X,Y) get_csv2_llong((X),(Y),467) +#define get_csv2_float_pos467(X,Y) get_csv2_float((X),(Y),467) +#define get_csv2_uint_pos468(X,Y) get_csv2_uint((X),(Y),468) +#define get_csv2_ullong_pos468(X,Y) get_csv2_ullong((X),(Y),468) +#define get_csv2_ip_pos468(X,Y) get_csv2_ip((X),(Y),468) +#define get_csv2_ipv6_pos468(X,Y) get_csv2_ipv6((X),(Y),468) +#define get_csv2_string_pos468(X,Y) get_csv2_string((X),(Y),468) +#define get_csv2_v_str_pos468(X,Y) get_csv2_string((X),(Y),468) +#define get_csv2_bool_pos468(X,Y) get_csv2_bool((X),(Y),468) +#define get_csv2_int_pos468(X,Y) get_csv2_int((X),(Y),468) +#define get_csv2_llong_pos468(X,Y) get_csv2_llong((X),(Y),468) +#define get_csv2_float_pos468(X,Y) get_csv2_float((X),(Y),468) +#define get_csv2_uint_pos469(X,Y) get_csv2_uint((X),(Y),469) +#define get_csv2_ullong_pos469(X,Y) get_csv2_ullong((X),(Y),469) +#define get_csv2_ip_pos469(X,Y) get_csv2_ip((X),(Y),469) +#define get_csv2_ipv6_pos469(X,Y) get_csv2_ipv6((X),(Y),469) +#define get_csv2_string_pos469(X,Y) get_csv2_string((X),(Y),469) +#define get_csv2_v_str_pos469(X,Y) get_csv2_string((X),(Y),469) +#define get_csv2_bool_pos469(X,Y) get_csv2_bool((X),(Y),469) +#define get_csv2_int_pos469(X,Y) get_csv2_int((X),(Y),469) +#define get_csv2_llong_pos469(X,Y) get_csv2_llong((X),(Y),469) +#define get_csv2_float_pos469(X,Y) get_csv2_float((X),(Y),469) +#define get_csv2_uint_pos470(X,Y) get_csv2_uint((X),(Y),470) +#define get_csv2_ullong_pos470(X,Y) get_csv2_ullong((X),(Y),470) +#define get_csv2_ip_pos470(X,Y) get_csv2_ip((X),(Y),470) +#define get_csv2_ipv6_pos470(X,Y) get_csv2_ipv6((X),(Y),470) +#define get_csv2_string_pos470(X,Y) get_csv2_string((X),(Y),470) +#define get_csv2_v_str_pos470(X,Y) get_csv2_string((X),(Y),470) +#define get_csv2_bool_pos470(X,Y) get_csv2_bool((X),(Y),470) +#define get_csv2_int_pos470(X,Y) get_csv2_int((X),(Y),470) +#define get_csv2_llong_pos470(X,Y) get_csv2_llong((X),(Y),470) +#define get_csv2_float_pos470(X,Y) get_csv2_float((X),(Y),470) +#define get_csv2_uint_pos471(X,Y) get_csv2_uint((X),(Y),471) +#define get_csv2_ullong_pos471(X,Y) get_csv2_ullong((X),(Y),471) +#define get_csv2_ip_pos471(X,Y) get_csv2_ip((X),(Y),471) +#define get_csv2_ipv6_pos471(X,Y) get_csv2_ipv6((X),(Y),471) +#define get_csv2_string_pos471(X,Y) get_csv2_string((X),(Y),471) +#define get_csv2_v_str_pos471(X,Y) get_csv2_string((X),(Y),471) +#define get_csv2_bool_pos471(X,Y) get_csv2_bool((X),(Y),471) +#define get_csv2_int_pos471(X,Y) get_csv2_int((X),(Y),471) +#define get_csv2_llong_pos471(X,Y) get_csv2_llong((X),(Y),471) +#define get_csv2_float_pos471(X,Y) get_csv2_float((X),(Y),471) +#define get_csv2_uint_pos472(X,Y) get_csv2_uint((X),(Y),472) +#define get_csv2_ullong_pos472(X,Y) get_csv2_ullong((X),(Y),472) +#define get_csv2_ip_pos472(X,Y) get_csv2_ip((X),(Y),472) +#define get_csv2_ipv6_pos472(X,Y) get_csv2_ipv6((X),(Y),472) +#define get_csv2_string_pos472(X,Y) get_csv2_string((X),(Y),472) +#define get_csv2_v_str_pos472(X,Y) get_csv2_string((X),(Y),472) +#define get_csv2_bool_pos472(X,Y) get_csv2_bool((X),(Y),472) +#define get_csv2_int_pos472(X,Y) get_csv2_int((X),(Y),472) +#define get_csv2_llong_pos472(X,Y) get_csv2_llong((X),(Y),472) +#define get_csv2_float_pos472(X,Y) get_csv2_float((X),(Y),472) +#define get_csv2_uint_pos473(X,Y) get_csv2_uint((X),(Y),473) +#define get_csv2_ullong_pos473(X,Y) get_csv2_ullong((X),(Y),473) +#define get_csv2_ip_pos473(X,Y) get_csv2_ip((X),(Y),473) +#define get_csv2_ipv6_pos473(X,Y) get_csv2_ipv6((X),(Y),473) +#define get_csv2_string_pos473(X,Y) get_csv2_string((X),(Y),473) +#define get_csv2_v_str_pos473(X,Y) get_csv2_string((X),(Y),473) +#define get_csv2_bool_pos473(X,Y) get_csv2_bool((X),(Y),473) +#define get_csv2_int_pos473(X,Y) get_csv2_int((X),(Y),473) +#define get_csv2_llong_pos473(X,Y) get_csv2_llong((X),(Y),473) +#define get_csv2_float_pos473(X,Y) get_csv2_float((X),(Y),473) +#define get_csv2_uint_pos474(X,Y) get_csv2_uint((X),(Y),474) +#define get_csv2_ullong_pos474(X,Y) get_csv2_ullong((X),(Y),474) +#define get_csv2_ip_pos474(X,Y) get_csv2_ip((X),(Y),474) +#define get_csv2_ipv6_pos474(X,Y) get_csv2_ipv6((X),(Y),474) +#define get_csv2_string_pos474(X,Y) get_csv2_string((X),(Y),474) +#define get_csv2_v_str_pos474(X,Y) get_csv2_string((X),(Y),474) +#define get_csv2_bool_pos474(X,Y) get_csv2_bool((X),(Y),474) +#define get_csv2_int_pos474(X,Y) get_csv2_int((X),(Y),474) +#define get_csv2_llong_pos474(X,Y) get_csv2_llong((X),(Y),474) +#define get_csv2_float_pos474(X,Y) get_csv2_float((X),(Y),474) +#define get_csv2_uint_pos475(X,Y) get_csv2_uint((X),(Y),475) +#define get_csv2_ullong_pos475(X,Y) get_csv2_ullong((X),(Y),475) +#define get_csv2_ip_pos475(X,Y) get_csv2_ip((X),(Y),475) +#define get_csv2_ipv6_pos475(X,Y) get_csv2_ipv6((X),(Y),475) +#define get_csv2_string_pos475(X,Y) get_csv2_string((X),(Y),475) +#define get_csv2_v_str_pos475(X,Y) get_csv2_string((X),(Y),475) +#define get_csv2_bool_pos475(X,Y) get_csv2_bool((X),(Y),475) +#define get_csv2_int_pos475(X,Y) get_csv2_int((X),(Y),475) +#define get_csv2_llong_pos475(X,Y) get_csv2_llong((X),(Y),475) +#define get_csv2_float_pos475(X,Y) get_csv2_float((X),(Y),475) +#define get_csv2_uint_pos476(X,Y) get_csv2_uint((X),(Y),476) +#define get_csv2_ullong_pos476(X,Y) get_csv2_ullong((X),(Y),476) +#define get_csv2_ip_pos476(X,Y) get_csv2_ip((X),(Y),476) +#define get_csv2_ipv6_pos476(X,Y) get_csv2_ipv6((X),(Y),476) +#define get_csv2_string_pos476(X,Y) get_csv2_string((X),(Y),476) +#define get_csv2_v_str_pos476(X,Y) get_csv2_string((X),(Y),476) +#define get_csv2_bool_pos476(X,Y) get_csv2_bool((X),(Y),476) +#define get_csv2_int_pos476(X,Y) get_csv2_int((X),(Y),476) +#define get_csv2_llong_pos476(X,Y) get_csv2_llong((X),(Y),476) +#define get_csv2_float_pos476(X,Y) get_csv2_float((X),(Y),476) +#define get_csv2_uint_pos477(X,Y) get_csv2_uint((X),(Y),477) +#define get_csv2_ullong_pos477(X,Y) get_csv2_ullong((X),(Y),477) +#define get_csv2_ip_pos477(X,Y) get_csv2_ip((X),(Y),477) +#define get_csv2_ipv6_pos477(X,Y) get_csv2_ipv6((X),(Y),477) +#define get_csv2_string_pos477(X,Y) get_csv2_string((X),(Y),477) +#define get_csv2_v_str_pos477(X,Y) get_csv2_string((X),(Y),477) +#define get_csv2_bool_pos477(X,Y) get_csv2_bool((X),(Y),477) +#define get_csv2_int_pos477(X,Y) get_csv2_int((X),(Y),477) +#define get_csv2_llong_pos477(X,Y) get_csv2_llong((X),(Y),477) +#define get_csv2_float_pos477(X,Y) get_csv2_float((X),(Y),477) +#define get_csv2_uint_pos478(X,Y) get_csv2_uint((X),(Y),478) +#define get_csv2_ullong_pos478(X,Y) get_csv2_ullong((X),(Y),478) +#define get_csv2_ip_pos478(X,Y) get_csv2_ip((X),(Y),478) +#define get_csv2_ipv6_pos478(X,Y) get_csv2_ipv6((X),(Y),478) +#define get_csv2_string_pos478(X,Y) get_csv2_string((X),(Y),478) +#define get_csv2_v_str_pos478(X,Y) get_csv2_string((X),(Y),478) +#define get_csv2_bool_pos478(X,Y) get_csv2_bool((X),(Y),478) +#define get_csv2_int_pos478(X,Y) get_csv2_int((X),(Y),478) +#define get_csv2_llong_pos478(X,Y) get_csv2_llong((X),(Y),478) +#define get_csv2_float_pos478(X,Y) get_csv2_float((X),(Y),478) +#define get_csv2_uint_pos479(X,Y) get_csv2_uint((X),(Y),479) +#define get_csv2_ullong_pos479(X,Y) get_csv2_ullong((X),(Y),479) +#define get_csv2_ip_pos479(X,Y) get_csv2_ip((X),(Y),479) +#define get_csv2_ipv6_pos479(X,Y) get_csv2_ipv6((X),(Y),479) +#define get_csv2_string_pos479(X,Y) get_csv2_string((X),(Y),479) +#define get_csv2_v_str_pos479(X,Y) get_csv2_string((X),(Y),479) +#define get_csv2_bool_pos479(X,Y) get_csv2_bool((X),(Y),479) +#define get_csv2_int_pos479(X,Y) get_csv2_int((X),(Y),479) +#define get_csv2_llong_pos479(X,Y) get_csv2_llong((X),(Y),479) +#define get_csv2_float_pos479(X,Y) get_csv2_float((X),(Y),479) +#define get_csv2_uint_pos480(X,Y) get_csv2_uint((X),(Y),480) +#define get_csv2_ullong_pos480(X,Y) get_csv2_ullong((X),(Y),480) +#define get_csv2_ip_pos480(X,Y) get_csv2_ip((X),(Y),480) +#define get_csv2_ipv6_pos480(X,Y) get_csv2_ipv6((X),(Y),480) +#define get_csv2_string_pos480(X,Y) get_csv2_string((X),(Y),480) +#define get_csv2_v_str_pos480(X,Y) get_csv2_string((X),(Y),480) +#define get_csv2_bool_pos480(X,Y) get_csv2_bool((X),(Y),480) +#define get_csv2_int_pos480(X,Y) get_csv2_int((X),(Y),480) +#define get_csv2_llong_pos480(X,Y) get_csv2_llong((X),(Y),480) +#define get_csv2_float_pos480(X,Y) get_csv2_float((X),(Y),480) +#define get_csv2_uint_pos481(X,Y) get_csv2_uint((X),(Y),481) +#define get_csv2_ullong_pos481(X,Y) get_csv2_ullong((X),(Y),481) +#define get_csv2_ip_pos481(X,Y) get_csv2_ip((X),(Y),481) +#define get_csv2_ipv6_pos481(X,Y) get_csv2_ipv6((X),(Y),481) +#define get_csv2_string_pos481(X,Y) get_csv2_string((X),(Y),481) +#define get_csv2_v_str_pos481(X,Y) get_csv2_string((X),(Y),481) +#define get_csv2_bool_pos481(X,Y) get_csv2_bool((X),(Y),481) +#define get_csv2_int_pos481(X,Y) get_csv2_int((X),(Y),481) +#define get_csv2_llong_pos481(X,Y) get_csv2_llong((X),(Y),481) +#define get_csv2_float_pos481(X,Y) get_csv2_float((X),(Y),481) +#define get_csv2_uint_pos482(X,Y) get_csv2_uint((X),(Y),482) +#define get_csv2_ullong_pos482(X,Y) get_csv2_ullong((X),(Y),482) +#define get_csv2_ip_pos482(X,Y) get_csv2_ip((X),(Y),482) +#define get_csv2_ipv6_pos482(X,Y) get_csv2_ipv6((X),(Y),482) +#define get_csv2_string_pos482(X,Y) get_csv2_string((X),(Y),482) +#define get_csv2_v_str_pos482(X,Y) get_csv2_string((X),(Y),482) +#define get_csv2_bool_pos482(X,Y) get_csv2_bool((X),(Y),482) +#define get_csv2_int_pos482(X,Y) get_csv2_int((X),(Y),482) +#define get_csv2_llong_pos482(X,Y) get_csv2_llong((X),(Y),482) +#define get_csv2_float_pos482(X,Y) get_csv2_float((X),(Y),482) +#define get_csv2_uint_pos483(X,Y) get_csv2_uint((X),(Y),483) +#define get_csv2_ullong_pos483(X,Y) get_csv2_ullong((X),(Y),483) +#define get_csv2_ip_pos483(X,Y) get_csv2_ip((X),(Y),483) +#define get_csv2_ipv6_pos483(X,Y) get_csv2_ipv6((X),(Y),483) +#define get_csv2_string_pos483(X,Y) get_csv2_string((X),(Y),483) +#define get_csv2_v_str_pos483(X,Y) get_csv2_string((X),(Y),483) +#define get_csv2_bool_pos483(X,Y) get_csv2_bool((X),(Y),483) +#define get_csv2_int_pos483(X,Y) get_csv2_int((X),(Y),483) +#define get_csv2_llong_pos483(X,Y) get_csv2_llong((X),(Y),483) +#define get_csv2_float_pos483(X,Y) get_csv2_float((X),(Y),483) +#define get_csv2_uint_pos484(X,Y) get_csv2_uint((X),(Y),484) +#define get_csv2_ullong_pos484(X,Y) get_csv2_ullong((X),(Y),484) +#define get_csv2_ip_pos484(X,Y) get_csv2_ip((X),(Y),484) +#define get_csv2_ipv6_pos484(X,Y) get_csv2_ipv6((X),(Y),484) +#define get_csv2_string_pos484(X,Y) get_csv2_string((X),(Y),484) +#define get_csv2_v_str_pos484(X,Y) get_csv2_string((X),(Y),484) +#define get_csv2_bool_pos484(X,Y) get_csv2_bool((X),(Y),484) +#define get_csv2_int_pos484(X,Y) get_csv2_int((X),(Y),484) +#define get_csv2_llong_pos484(X,Y) get_csv2_llong((X),(Y),484) +#define get_csv2_float_pos484(X,Y) get_csv2_float((X),(Y),484) +#define get_csv2_uint_pos485(X,Y) get_csv2_uint((X),(Y),485) +#define get_csv2_ullong_pos485(X,Y) get_csv2_ullong((X),(Y),485) +#define get_csv2_ip_pos485(X,Y) get_csv2_ip((X),(Y),485) +#define get_csv2_ipv6_pos485(X,Y) get_csv2_ipv6((X),(Y),485) +#define get_csv2_string_pos485(X,Y) get_csv2_string((X),(Y),485) +#define get_csv2_v_str_pos485(X,Y) get_csv2_string((X),(Y),485) +#define get_csv2_bool_pos485(X,Y) get_csv2_bool((X),(Y),485) +#define get_csv2_int_pos485(X,Y) get_csv2_int((X),(Y),485) +#define get_csv2_llong_pos485(X,Y) get_csv2_llong((X),(Y),485) +#define get_csv2_float_pos485(X,Y) get_csv2_float((X),(Y),485) +#define get_csv2_uint_pos486(X,Y) get_csv2_uint((X),(Y),486) +#define get_csv2_ullong_pos486(X,Y) get_csv2_ullong((X),(Y),486) +#define get_csv2_ip_pos486(X,Y) get_csv2_ip((X),(Y),486) +#define get_csv2_ipv6_pos486(X,Y) get_csv2_ipv6((X),(Y),486) +#define get_csv2_string_pos486(X,Y) get_csv2_string((X),(Y),486) +#define get_csv2_v_str_pos486(X,Y) get_csv2_string((X),(Y),486) +#define get_csv2_bool_pos486(X,Y) get_csv2_bool((X),(Y),486) +#define get_csv2_int_pos486(X,Y) get_csv2_int((X),(Y),486) +#define get_csv2_llong_pos486(X,Y) get_csv2_llong((X),(Y),486) +#define get_csv2_float_pos486(X,Y) get_csv2_float((X),(Y),486) +#define get_csv2_uint_pos487(X,Y) get_csv2_uint((X),(Y),487) +#define get_csv2_ullong_pos487(X,Y) get_csv2_ullong((X),(Y),487) +#define get_csv2_ip_pos487(X,Y) get_csv2_ip((X),(Y),487) +#define get_csv2_ipv6_pos487(X,Y) get_csv2_ipv6((X),(Y),487) +#define get_csv2_string_pos487(X,Y) get_csv2_string((X),(Y),487) +#define get_csv2_v_str_pos487(X,Y) get_csv2_string((X),(Y),487) +#define get_csv2_bool_pos487(X,Y) get_csv2_bool((X),(Y),487) +#define get_csv2_int_pos487(X,Y) get_csv2_int((X),(Y),487) +#define get_csv2_llong_pos487(X,Y) get_csv2_llong((X),(Y),487) +#define get_csv2_float_pos487(X,Y) get_csv2_float((X),(Y),487) +#define get_csv2_uint_pos488(X,Y) get_csv2_uint((X),(Y),488) +#define get_csv2_ullong_pos488(X,Y) get_csv2_ullong((X),(Y),488) +#define get_csv2_ip_pos488(X,Y) get_csv2_ip((X),(Y),488) +#define get_csv2_ipv6_pos488(X,Y) get_csv2_ipv6((X),(Y),488) +#define get_csv2_string_pos488(X,Y) get_csv2_string((X),(Y),488) +#define get_csv2_v_str_pos488(X,Y) get_csv2_string((X),(Y),488) +#define get_csv2_bool_pos488(X,Y) get_csv2_bool((X),(Y),488) +#define get_csv2_int_pos488(X,Y) get_csv2_int((X),(Y),488) +#define get_csv2_llong_pos488(X,Y) get_csv2_llong((X),(Y),488) +#define get_csv2_float_pos488(X,Y) get_csv2_float((X),(Y),488) +#define get_csv2_uint_pos489(X,Y) get_csv2_uint((X),(Y),489) +#define get_csv2_ullong_pos489(X,Y) get_csv2_ullong((X),(Y),489) +#define get_csv2_ip_pos489(X,Y) get_csv2_ip((X),(Y),489) +#define get_csv2_ipv6_pos489(X,Y) get_csv2_ipv6((X),(Y),489) +#define get_csv2_string_pos489(X,Y) get_csv2_string((X),(Y),489) +#define get_csv2_v_str_pos489(X,Y) get_csv2_string((X),(Y),489) +#define get_csv2_bool_pos489(X,Y) get_csv2_bool((X),(Y),489) +#define get_csv2_int_pos489(X,Y) get_csv2_int((X),(Y),489) +#define get_csv2_llong_pos489(X,Y) get_csv2_llong((X),(Y),489) +#define get_csv2_float_pos489(X,Y) get_csv2_float((X),(Y),489) +#define get_csv2_uint_pos490(X,Y) get_csv2_uint((X),(Y),490) +#define get_csv2_ullong_pos490(X,Y) get_csv2_ullong((X),(Y),490) +#define get_csv2_ip_pos490(X,Y) get_csv2_ip((X),(Y),490) +#define get_csv2_ipv6_pos490(X,Y) get_csv2_ipv6((X),(Y),490) +#define get_csv2_string_pos490(X,Y) get_csv2_string((X),(Y),490) +#define get_csv2_v_str_pos490(X,Y) get_csv2_string((X),(Y),490) +#define get_csv2_bool_pos490(X,Y) get_csv2_bool((X),(Y),490) +#define get_csv2_int_pos490(X,Y) get_csv2_int((X),(Y),490) +#define get_csv2_llong_pos490(X,Y) get_csv2_llong((X),(Y),490) +#define get_csv2_float_pos490(X,Y) get_csv2_float((X),(Y),490) +#define get_csv2_uint_pos491(X,Y) get_csv2_uint((X),(Y),491) +#define get_csv2_ullong_pos491(X,Y) get_csv2_ullong((X),(Y),491) +#define get_csv2_ip_pos491(X,Y) get_csv2_ip((X),(Y),491) +#define get_csv2_ipv6_pos491(X,Y) get_csv2_ipv6((X),(Y),491) +#define get_csv2_string_pos491(X,Y) get_csv2_string((X),(Y),491) +#define get_csv2_v_str_pos491(X,Y) get_csv2_string((X),(Y),491) +#define get_csv2_bool_pos491(X,Y) get_csv2_bool((X),(Y),491) +#define get_csv2_int_pos491(X,Y) get_csv2_int((X),(Y),491) +#define get_csv2_llong_pos491(X,Y) get_csv2_llong((X),(Y),491) +#define get_csv2_float_pos491(X,Y) get_csv2_float((X),(Y),491) +#define get_csv2_uint_pos492(X,Y) get_csv2_uint((X),(Y),492) +#define get_csv2_ullong_pos492(X,Y) get_csv2_ullong((X),(Y),492) +#define get_csv2_ip_pos492(X,Y) get_csv2_ip((X),(Y),492) +#define get_csv2_ipv6_pos492(X,Y) get_csv2_ipv6((X),(Y),492) +#define get_csv2_string_pos492(X,Y) get_csv2_string((X),(Y),492) +#define get_csv2_v_str_pos492(X,Y) get_csv2_string((X),(Y),492) +#define get_csv2_bool_pos492(X,Y) get_csv2_bool((X),(Y),492) +#define get_csv2_int_pos492(X,Y) get_csv2_int((X),(Y),492) +#define get_csv2_llong_pos492(X,Y) get_csv2_llong((X),(Y),492) +#define get_csv2_float_pos492(X,Y) get_csv2_float((X),(Y),492) +#define get_csv2_uint_pos493(X,Y) get_csv2_uint((X),(Y),493) +#define get_csv2_ullong_pos493(X,Y) get_csv2_ullong((X),(Y),493) +#define get_csv2_ip_pos493(X,Y) get_csv2_ip((X),(Y),493) +#define get_csv2_ipv6_pos493(X,Y) get_csv2_ipv6((X),(Y),493) +#define get_csv2_string_pos493(X,Y) get_csv2_string((X),(Y),493) +#define get_csv2_v_str_pos493(X,Y) get_csv2_string((X),(Y),493) +#define get_csv2_bool_pos493(X,Y) get_csv2_bool((X),(Y),493) +#define get_csv2_int_pos493(X,Y) get_csv2_int((X),(Y),493) +#define get_csv2_llong_pos493(X,Y) get_csv2_llong((X),(Y),493) +#define get_csv2_float_pos493(X,Y) get_csv2_float((X),(Y),493) +#define get_csv2_uint_pos494(X,Y) get_csv2_uint((X),(Y),494) +#define get_csv2_ullong_pos494(X,Y) get_csv2_ullong((X),(Y),494) +#define get_csv2_ip_pos494(X,Y) get_csv2_ip((X),(Y),494) +#define get_csv2_ipv6_pos494(X,Y) get_csv2_ipv6((X),(Y),494) +#define get_csv2_string_pos494(X,Y) get_csv2_string((X),(Y),494) +#define get_csv2_v_str_pos494(X,Y) get_csv2_string((X),(Y),494) +#define get_csv2_bool_pos494(X,Y) get_csv2_bool((X),(Y),494) +#define get_csv2_int_pos494(X,Y) get_csv2_int((X),(Y),494) +#define get_csv2_llong_pos494(X,Y) get_csv2_llong((X),(Y),494) +#define get_csv2_float_pos494(X,Y) get_csv2_float((X),(Y),494) +#define get_csv2_uint_pos495(X,Y) get_csv2_uint((X),(Y),495) +#define get_csv2_ullong_pos495(X,Y) get_csv2_ullong((X),(Y),495) +#define get_csv2_ip_pos495(X,Y) get_csv2_ip((X),(Y),495) +#define get_csv2_ipv6_pos495(X,Y) get_csv2_ipv6((X),(Y),495) +#define get_csv2_string_pos495(X,Y) get_csv2_string((X),(Y),495) +#define get_csv2_v_str_pos495(X,Y) get_csv2_string((X),(Y),495) +#define get_csv2_bool_pos495(X,Y) get_csv2_bool((X),(Y),495) +#define get_csv2_int_pos495(X,Y) get_csv2_int((X),(Y),495) +#define get_csv2_llong_pos495(X,Y) get_csv2_llong((X),(Y),495) +#define get_csv2_float_pos495(X,Y) get_csv2_float((X),(Y),495) +#define get_csv2_uint_pos496(X,Y) get_csv2_uint((X),(Y),496) +#define get_csv2_ullong_pos496(X,Y) get_csv2_ullong((X),(Y),496) +#define get_csv2_ip_pos496(X,Y) get_csv2_ip((X),(Y),496) +#define get_csv2_ipv6_pos496(X,Y) get_csv2_ipv6((X),(Y),496) +#define get_csv2_string_pos496(X,Y) get_csv2_string((X),(Y),496) +#define get_csv2_v_str_pos496(X,Y) get_csv2_string((X),(Y),496) +#define get_csv2_bool_pos496(X,Y) get_csv2_bool((X),(Y),496) +#define get_csv2_int_pos496(X,Y) get_csv2_int((X),(Y),496) +#define get_csv2_llong_pos496(X,Y) get_csv2_llong((X),(Y),496) +#define get_csv2_float_pos496(X,Y) get_csv2_float((X),(Y),496) +#define get_csv2_uint_pos497(X,Y) get_csv2_uint((X),(Y),497) +#define get_csv2_ullong_pos497(X,Y) get_csv2_ullong((X),(Y),497) +#define get_csv2_ip_pos497(X,Y) get_csv2_ip((X),(Y),497) +#define get_csv2_ipv6_pos497(X,Y) get_csv2_ipv6((X),(Y),497) +#define get_csv2_string_pos497(X,Y) get_csv2_string((X),(Y),497) +#define get_csv2_v_str_pos497(X,Y) get_csv2_string((X),(Y),497) +#define get_csv2_bool_pos497(X,Y) get_csv2_bool((X),(Y),497) +#define get_csv2_int_pos497(X,Y) get_csv2_int((X),(Y),497) +#define get_csv2_llong_pos497(X,Y) get_csv2_llong((X),(Y),497) +#define get_csv2_float_pos497(X,Y) get_csv2_float((X),(Y),497) +#define get_csv2_uint_pos498(X,Y) get_csv2_uint((X),(Y),498) +#define get_csv2_ullong_pos498(X,Y) get_csv2_ullong((X),(Y),498) +#define get_csv2_ip_pos498(X,Y) get_csv2_ip((X),(Y),498) +#define get_csv2_ipv6_pos498(X,Y) get_csv2_ipv6((X),(Y),498) +#define get_csv2_string_pos498(X,Y) get_csv2_string((X),(Y),498) +#define get_csv2_v_str_pos498(X,Y) get_csv2_string((X),(Y),498) +#define get_csv2_bool_pos498(X,Y) get_csv2_bool((X),(Y),498) +#define get_csv2_int_pos498(X,Y) get_csv2_int((X),(Y),498) +#define get_csv2_llong_pos498(X,Y) get_csv2_llong((X),(Y),498) +#define get_csv2_float_pos498(X,Y) get_csv2_float((X),(Y),498) +#define get_csv2_uint_pos499(X,Y) get_csv2_uint((X),(Y),499) +#define get_csv2_ullong_pos499(X,Y) get_csv2_ullong((X),(Y),499) +#define get_csv2_ip_pos499(X,Y) get_csv2_ip((X),(Y),499) +#define get_csv2_ipv6_pos499(X,Y) get_csv2_ipv6((X),(Y),499) +#define get_csv2_string_pos499(X,Y) get_csv2_string((X),(Y),499) +#define get_csv2_v_str_pos499(X,Y) get_csv2_string((X),(Y),499) +#define get_csv2_bool_pos499(X,Y) get_csv2_bool((X),(Y),499) +#define get_csv2_int_pos499(X,Y) get_csv2_int((X),(Y),499) +#define get_csv2_llong_pos499(X,Y) get_csv2_llong((X),(Y),499) +#define get_csv2_float_pos499(X,Y) get_csv2_float((X),(Y),499) +#define get_csv2_uint_pos500(X,Y) get_csv2_uint((X),(Y),500) +#define get_csv2_ullong_pos500(X,Y) get_csv2_ullong((X),(Y),500) +#define get_csv2_ip_pos500(X,Y) get_csv2_ip((X),(Y),500) +#define get_csv2_ipv6_pos500(X,Y) get_csv2_ipv6((X),(Y),500) +#define get_csv2_string_pos500(X,Y) get_csv2_string((X),(Y),500) +#define get_csv2_v_str_pos500(X,Y) get_csv2_string((X),(Y),500) +#define get_csv2_bool_pos500(X,Y) get_csv2_bool((X),(Y),500) +#define get_csv2_int_pos500(X,Y) get_csv2_int((X),(Y),500) +#define get_csv2_llong_pos500(X,Y) get_csv2_llong((X),(Y),500) +#define get_csv2_float_pos500(X,Y) get_csv2_float((X),(Y),500) +#define get_csv2_uint_pos501(X,Y) get_csv2_uint((X),(Y),501) +#define get_csv2_ullong_pos501(X,Y) get_csv2_ullong((X),(Y),501) +#define get_csv2_ip_pos501(X,Y) get_csv2_ip((X),(Y),501) +#define get_csv2_ipv6_pos501(X,Y) get_csv2_ipv6((X),(Y),501) +#define get_csv2_string_pos501(X,Y) get_csv2_string((X),(Y),501) +#define get_csv2_v_str_pos501(X,Y) get_csv2_string((X),(Y),501) +#define get_csv2_bool_pos501(X,Y) get_csv2_bool((X),(Y),501) +#define get_csv2_int_pos501(X,Y) get_csv2_int((X),(Y),501) +#define get_csv2_llong_pos501(X,Y) get_csv2_llong((X),(Y),501) +#define get_csv2_float_pos501(X,Y) get_csv2_float((X),(Y),501) +#define get_csv2_uint_pos502(X,Y) get_csv2_uint((X),(Y),502) +#define get_csv2_ullong_pos502(X,Y) get_csv2_ullong((X),(Y),502) +#define get_csv2_ip_pos502(X,Y) get_csv2_ip((X),(Y),502) +#define get_csv2_ipv6_pos502(X,Y) get_csv2_ipv6((X),(Y),502) +#define get_csv2_string_pos502(X,Y) get_csv2_string((X),(Y),502) +#define get_csv2_v_str_pos502(X,Y) get_csv2_string((X),(Y),502) +#define get_csv2_bool_pos502(X,Y) get_csv2_bool((X),(Y),502) +#define get_csv2_int_pos502(X,Y) get_csv2_int((X),(Y),502) +#define get_csv2_llong_pos502(X,Y) get_csv2_llong((X),(Y),502) +#define get_csv2_float_pos502(X,Y) get_csv2_float((X),(Y),502) +#define get_csv2_uint_pos503(X,Y) get_csv2_uint((X),(Y),503) +#define get_csv2_ullong_pos503(X,Y) get_csv2_ullong((X),(Y),503) +#define get_csv2_ip_pos503(X,Y) get_csv2_ip((X),(Y),503) +#define get_csv2_ipv6_pos503(X,Y) get_csv2_ipv6((X),(Y),503) +#define get_csv2_string_pos503(X,Y) get_csv2_string((X),(Y),503) +#define get_csv2_v_str_pos503(X,Y) get_csv2_string((X),(Y),503) +#define get_csv2_bool_pos503(X,Y) get_csv2_bool((X),(Y),503) +#define get_csv2_int_pos503(X,Y) get_csv2_int((X),(Y),503) +#define get_csv2_llong_pos503(X,Y) get_csv2_llong((X),(Y),503) +#define get_csv2_float_pos503(X,Y) get_csv2_float((X),(Y),503) +#define get_csv2_uint_pos504(X,Y) get_csv2_uint((X),(Y),504) +#define get_csv2_ullong_pos504(X,Y) get_csv2_ullong((X),(Y),504) +#define get_csv2_ip_pos504(X,Y) get_csv2_ip((X),(Y),504) +#define get_csv2_ipv6_pos504(X,Y) get_csv2_ipv6((X),(Y),504) +#define get_csv2_string_pos504(X,Y) get_csv2_string((X),(Y),504) +#define get_csv2_v_str_pos504(X,Y) get_csv2_string((X),(Y),504) +#define get_csv2_bool_pos504(X,Y) get_csv2_bool((X),(Y),504) +#define get_csv2_int_pos504(X,Y) get_csv2_int((X),(Y),504) +#define get_csv2_llong_pos504(X,Y) get_csv2_llong((X),(Y),504) +#define get_csv2_float_pos504(X,Y) get_csv2_float((X),(Y),504) +#define get_csv2_uint_pos505(X,Y) get_csv2_uint((X),(Y),505) +#define get_csv2_ullong_pos505(X,Y) get_csv2_ullong((X),(Y),505) +#define get_csv2_ip_pos505(X,Y) get_csv2_ip((X),(Y),505) +#define get_csv2_ipv6_pos505(X,Y) get_csv2_ipv6((X),(Y),505) +#define get_csv2_string_pos505(X,Y) get_csv2_string((X),(Y),505) +#define get_csv2_v_str_pos505(X,Y) get_csv2_string((X),(Y),505) +#define get_csv2_bool_pos505(X,Y) get_csv2_bool((X),(Y),505) +#define get_csv2_int_pos505(X,Y) get_csv2_int((X),(Y),505) +#define get_csv2_llong_pos505(X,Y) get_csv2_llong((X),(Y),505) +#define get_csv2_float_pos505(X,Y) get_csv2_float((X),(Y),505) +#define get_csv2_uint_pos506(X,Y) get_csv2_uint((X),(Y),506) +#define get_csv2_ullong_pos506(X,Y) get_csv2_ullong((X),(Y),506) +#define get_csv2_ip_pos506(X,Y) get_csv2_ip((X),(Y),506) +#define get_csv2_ipv6_pos506(X,Y) get_csv2_ipv6((X),(Y),506) +#define get_csv2_string_pos506(X,Y) get_csv2_string((X),(Y),506) +#define get_csv2_v_str_pos506(X,Y) get_csv2_string((X),(Y),506) +#define get_csv2_bool_pos506(X,Y) get_csv2_bool((X),(Y),506) +#define get_csv2_int_pos506(X,Y) get_csv2_int((X),(Y),506) +#define get_csv2_llong_pos506(X,Y) get_csv2_llong((X),(Y),506) +#define get_csv2_float_pos506(X,Y) get_csv2_float((X),(Y),506) +#define get_csv2_uint_pos507(X,Y) get_csv2_uint((X),(Y),507) +#define get_csv2_ullong_pos507(X,Y) get_csv2_ullong((X),(Y),507) +#define get_csv2_ip_pos507(X,Y) get_csv2_ip((X),(Y),507) +#define get_csv2_ipv6_pos507(X,Y) get_csv2_ipv6((X),(Y),507) +#define get_csv2_string_pos507(X,Y) get_csv2_string((X),(Y),507) +#define get_csv2_v_str_pos507(X,Y) get_csv2_string((X),(Y),507) +#define get_csv2_bool_pos507(X,Y) get_csv2_bool((X),(Y),507) +#define get_csv2_int_pos507(X,Y) get_csv2_int((X),(Y),507) +#define get_csv2_llong_pos507(X,Y) get_csv2_llong((X),(Y),507) +#define get_csv2_float_pos507(X,Y) get_csv2_float((X),(Y),507) +#define get_csv2_uint_pos508(X,Y) get_csv2_uint((X),(Y),508) +#define get_csv2_ullong_pos508(X,Y) get_csv2_ullong((X),(Y),508) +#define get_csv2_ip_pos508(X,Y) get_csv2_ip((X),(Y),508) +#define get_csv2_ipv6_pos508(X,Y) get_csv2_ipv6((X),(Y),508) +#define get_csv2_string_pos508(X,Y) get_csv2_string((X),(Y),508) +#define get_csv2_v_str_pos508(X,Y) get_csv2_string((X),(Y),508) +#define get_csv2_bool_pos508(X,Y) get_csv2_bool((X),(Y),508) +#define get_csv2_int_pos508(X,Y) get_csv2_int((X),(Y),508) +#define get_csv2_llong_pos508(X,Y) get_csv2_llong((X),(Y),508) +#define get_csv2_float_pos508(X,Y) get_csv2_float((X),(Y),508) +#define get_csv2_uint_pos509(X,Y) get_csv2_uint((X),(Y),509) +#define get_csv2_ullong_pos509(X,Y) get_csv2_ullong((X),(Y),509) +#define get_csv2_ip_pos509(X,Y) get_csv2_ip((X),(Y),509) +#define get_csv2_ipv6_pos509(X,Y) get_csv2_ipv6((X),(Y),509) +#define get_csv2_string_pos509(X,Y) get_csv2_string((X),(Y),509) +#define get_csv2_v_str_pos509(X,Y) get_csv2_string((X),(Y),509) +#define get_csv2_bool_pos509(X,Y) get_csv2_bool((X),(Y),509) +#define get_csv2_int_pos509(X,Y) get_csv2_int((X),(Y),509) +#define get_csv2_llong_pos509(X,Y) get_csv2_llong((X),(Y),509) +#define get_csv2_float_pos509(X,Y) get_csv2_float((X),(Y),509) +#define get_csv2_uint_pos510(X,Y) get_csv2_uint((X),(Y),510) +#define get_csv2_ullong_pos510(X,Y) get_csv2_ullong((X),(Y),510) +#define get_csv2_ip_pos510(X,Y) get_csv2_ip((X),(Y),510) +#define get_csv2_ipv6_pos510(X,Y) get_csv2_ipv6((X),(Y),510) +#define get_csv2_string_pos510(X,Y) get_csv2_string((X),(Y),510) +#define get_csv2_v_str_pos510(X,Y) get_csv2_string((X),(Y),510) +#define get_csv2_bool_pos510(X,Y) get_csv2_bool((X),(Y),510) +#define get_csv2_int_pos510(X,Y) get_csv2_int((X),(Y),510) +#define get_csv2_llong_pos510(X,Y) get_csv2_llong((X),(Y),510) +#define get_csv2_float_pos510(X,Y) get_csv2_float((X),(Y),510) +#define get_csv2_uint_pos511(X,Y) get_csv2_uint((X),(Y),511) +#define get_csv2_ullong_pos511(X,Y) get_csv2_ullong((X),(Y),511) +#define get_csv2_ip_pos511(X,Y) get_csv2_ip((X),(Y),511) +#define get_csv2_ipv6_pos511(X,Y) get_csv2_ipv6((X),(Y),511) +#define get_csv2_string_pos511(X,Y) get_csv2_string((X),(Y),511) +#define get_csv2_v_str_pos511(X,Y) get_csv2_string((X),(Y),511) +#define get_csv2_bool_pos511(X,Y) get_csv2_bool((X),(Y),511) +#define get_csv2_int_pos511(X,Y) get_csv2_int((X),(Y),511) +#define get_csv2_llong_pos511(X,Y) get_csv2_llong((X),(Y),511) +#define get_csv2_float_pos511(X,Y) get_csv2_float((X),(Y),511) +#define get_csv2_uint_pos512(X,Y) get_csv2_uint((X),(Y),512) +#define get_csv2_ullong_pos512(X,Y) get_csv2_ullong((X),(Y),512) +#define get_csv2_ip_pos512(X,Y) get_csv2_ip((X),(Y),512) +#define get_csv2_ipv6_pos512(X,Y) get_csv2_ipv6((X),(Y),512) +#define get_csv2_string_pos512(X,Y) get_csv2_string((X),(Y),512) +#define get_csv2_v_str_pos512(X,Y) get_csv2_string((X),(Y),512) +#define get_csv2_bool_pos512(X,Y) get_csv2_bool((X),(Y),512) +#define get_csv2_int_pos512(X,Y) get_csv2_int((X),(Y),512) +#define get_csv2_llong_pos512(X,Y) get_csv2_llong((X),(Y),512) +#define get_csv2_float_pos512(X,Y) get_csv2_float((X),(Y),512) +#define get_csv2_uint_pos513(X,Y) get_csv2_uint((X),(Y),513) +#define get_csv2_ullong_pos513(X,Y) get_csv2_ullong((X),(Y),513) +#define get_csv2_ip_pos513(X,Y) get_csv2_ip((X),(Y),513) +#define get_csv2_ipv6_pos513(X,Y) get_csv2_ipv6((X),(Y),513) +#define get_csv2_string_pos513(X,Y) get_csv2_string((X),(Y),513) +#define get_csv2_v_str_pos513(X,Y) get_csv2_string((X),(Y),513) +#define get_csv2_bool_pos513(X,Y) get_csv2_bool((X),(Y),513) +#define get_csv2_int_pos513(X,Y) get_csv2_int((X),(Y),513) +#define get_csv2_llong_pos513(X,Y) get_csv2_llong((X),(Y),513) +#define get_csv2_float_pos513(X,Y) get_csv2_float((X),(Y),513) +#define get_csv2_uint_pos514(X,Y) get_csv2_uint((X),(Y),514) +#define get_csv2_ullong_pos514(X,Y) get_csv2_ullong((X),(Y),514) +#define get_csv2_ip_pos514(X,Y) get_csv2_ip((X),(Y),514) +#define get_csv2_ipv6_pos514(X,Y) get_csv2_ipv6((X),(Y),514) +#define get_csv2_string_pos514(X,Y) get_csv2_string((X),(Y),514) +#define get_csv2_v_str_pos514(X,Y) get_csv2_string((X),(Y),514) +#define get_csv2_bool_pos514(X,Y) get_csv2_bool((X),(Y),514) +#define get_csv2_int_pos514(X,Y) get_csv2_int((X),(Y),514) +#define get_csv2_llong_pos514(X,Y) get_csv2_llong((X),(Y),514) +#define get_csv2_float_pos514(X,Y) get_csv2_float((X),(Y),514) +#define get_csv2_uint_pos515(X,Y) get_csv2_uint((X),(Y),515) +#define get_csv2_ullong_pos515(X,Y) get_csv2_ullong((X),(Y),515) +#define get_csv2_ip_pos515(X,Y) get_csv2_ip((X),(Y),515) +#define get_csv2_ipv6_pos515(X,Y) get_csv2_ipv6((X),(Y),515) +#define get_csv2_string_pos515(X,Y) get_csv2_string((X),(Y),515) +#define get_csv2_v_str_pos515(X,Y) get_csv2_string((X),(Y),515) +#define get_csv2_bool_pos515(X,Y) get_csv2_bool((X),(Y),515) +#define get_csv2_int_pos515(X,Y) get_csv2_int((X),(Y),515) +#define get_csv2_llong_pos515(X,Y) get_csv2_llong((X),(Y),515) +#define get_csv2_float_pos515(X,Y) get_csv2_float((X),(Y),515) +#define get_csv2_uint_pos516(X,Y) get_csv2_uint((X),(Y),516) +#define get_csv2_ullong_pos516(X,Y) get_csv2_ullong((X),(Y),516) +#define get_csv2_ip_pos516(X,Y) get_csv2_ip((X),(Y),516) +#define get_csv2_ipv6_pos516(X,Y) get_csv2_ipv6((X),(Y),516) +#define get_csv2_string_pos516(X,Y) get_csv2_string((X),(Y),516) +#define get_csv2_v_str_pos516(X,Y) get_csv2_string((X),(Y),516) +#define get_csv2_bool_pos516(X,Y) get_csv2_bool((X),(Y),516) +#define get_csv2_int_pos516(X,Y) get_csv2_int((X),(Y),516) +#define get_csv2_llong_pos516(X,Y) get_csv2_llong((X),(Y),516) +#define get_csv2_float_pos516(X,Y) get_csv2_float((X),(Y),516) +#define get_csv2_uint_pos517(X,Y) get_csv2_uint((X),(Y),517) +#define get_csv2_ullong_pos517(X,Y) get_csv2_ullong((X),(Y),517) +#define get_csv2_ip_pos517(X,Y) get_csv2_ip((X),(Y),517) +#define get_csv2_ipv6_pos517(X,Y) get_csv2_ipv6((X),(Y),517) +#define get_csv2_string_pos517(X,Y) get_csv2_string((X),(Y),517) +#define get_csv2_v_str_pos517(X,Y) get_csv2_string((X),(Y),517) +#define get_csv2_bool_pos517(X,Y) get_csv2_bool((X),(Y),517) +#define get_csv2_int_pos517(X,Y) get_csv2_int((X),(Y),517) +#define get_csv2_llong_pos517(X,Y) get_csv2_llong((X),(Y),517) +#define get_csv2_float_pos517(X,Y) get_csv2_float((X),(Y),517) +#define get_csv2_uint_pos518(X,Y) get_csv2_uint((X),(Y),518) +#define get_csv2_ullong_pos518(X,Y) get_csv2_ullong((X),(Y),518) +#define get_csv2_ip_pos518(X,Y) get_csv2_ip((X),(Y),518) +#define get_csv2_ipv6_pos518(X,Y) get_csv2_ipv6((X),(Y),518) +#define get_csv2_string_pos518(X,Y) get_csv2_string((X),(Y),518) +#define get_csv2_v_str_pos518(X,Y) get_csv2_string((X),(Y),518) +#define get_csv2_bool_pos518(X,Y) get_csv2_bool((X),(Y),518) +#define get_csv2_int_pos518(X,Y) get_csv2_int((X),(Y),518) +#define get_csv2_llong_pos518(X,Y) get_csv2_llong((X),(Y),518) +#define get_csv2_float_pos518(X,Y) get_csv2_float((X),(Y),518) +#define get_csv2_uint_pos519(X,Y) get_csv2_uint((X),(Y),519) +#define get_csv2_ullong_pos519(X,Y) get_csv2_ullong((X),(Y),519) +#define get_csv2_ip_pos519(X,Y) get_csv2_ip((X),(Y),519) +#define get_csv2_ipv6_pos519(X,Y) get_csv2_ipv6((X),(Y),519) +#define get_csv2_string_pos519(X,Y) get_csv2_string((X),(Y),519) +#define get_csv2_v_str_pos519(X,Y) get_csv2_string((X),(Y),519) +#define get_csv2_bool_pos519(X,Y) get_csv2_bool((X),(Y),519) +#define get_csv2_int_pos519(X,Y) get_csv2_int((X),(Y),519) +#define get_csv2_llong_pos519(X,Y) get_csv2_llong((X),(Y),519) +#define get_csv2_float_pos519(X,Y) get_csv2_float((X),(Y),519) +#define get_csv2_uint_pos520(X,Y) get_csv2_uint((X),(Y),520) +#define get_csv2_ullong_pos520(X,Y) get_csv2_ullong((X),(Y),520) +#define get_csv2_ip_pos520(X,Y) get_csv2_ip((X),(Y),520) +#define get_csv2_ipv6_pos520(X,Y) get_csv2_ipv6((X),(Y),520) +#define get_csv2_string_pos520(X,Y) get_csv2_string((X),(Y),520) +#define get_csv2_v_str_pos520(X,Y) get_csv2_string((X),(Y),520) +#define get_csv2_bool_pos520(X,Y) get_csv2_bool((X),(Y),520) +#define get_csv2_int_pos520(X,Y) get_csv2_int((X),(Y),520) +#define get_csv2_llong_pos520(X,Y) get_csv2_llong((X),(Y),520) +#define get_csv2_float_pos520(X,Y) get_csv2_float((X),(Y),520) +#define get_csv2_uint_pos521(X,Y) get_csv2_uint((X),(Y),521) +#define get_csv2_ullong_pos521(X,Y) get_csv2_ullong((X),(Y),521) +#define get_csv2_ip_pos521(X,Y) get_csv2_ip((X),(Y),521) +#define get_csv2_ipv6_pos521(X,Y) get_csv2_ipv6((X),(Y),521) +#define get_csv2_string_pos521(X,Y) get_csv2_string((X),(Y),521) +#define get_csv2_v_str_pos521(X,Y) get_csv2_string((X),(Y),521) +#define get_csv2_bool_pos521(X,Y) get_csv2_bool((X),(Y),521) +#define get_csv2_int_pos521(X,Y) get_csv2_int((X),(Y),521) +#define get_csv2_llong_pos521(X,Y) get_csv2_llong((X),(Y),521) +#define get_csv2_float_pos521(X,Y) get_csv2_float((X),(Y),521) +#define get_csv2_uint_pos522(X,Y) get_csv2_uint((X),(Y),522) +#define get_csv2_ullong_pos522(X,Y) get_csv2_ullong((X),(Y),522) +#define get_csv2_ip_pos522(X,Y) get_csv2_ip((X),(Y),522) +#define get_csv2_ipv6_pos522(X,Y) get_csv2_ipv6((X),(Y),522) +#define get_csv2_string_pos522(X,Y) get_csv2_string((X),(Y),522) +#define get_csv2_v_str_pos522(X,Y) get_csv2_string((X),(Y),522) +#define get_csv2_bool_pos522(X,Y) get_csv2_bool((X),(Y),522) +#define get_csv2_int_pos522(X,Y) get_csv2_int((X),(Y),522) +#define get_csv2_llong_pos522(X,Y) get_csv2_llong((X),(Y),522) +#define get_csv2_float_pos522(X,Y) get_csv2_float((X),(Y),522) +#define get_csv2_uint_pos523(X,Y) get_csv2_uint((X),(Y),523) +#define get_csv2_ullong_pos523(X,Y) get_csv2_ullong((X),(Y),523) +#define get_csv2_ip_pos523(X,Y) get_csv2_ip((X),(Y),523) +#define get_csv2_ipv6_pos523(X,Y) get_csv2_ipv6((X),(Y),523) +#define get_csv2_string_pos523(X,Y) get_csv2_string((X),(Y),523) +#define get_csv2_v_str_pos523(X,Y) get_csv2_string((X),(Y),523) +#define get_csv2_bool_pos523(X,Y) get_csv2_bool((X),(Y),523) +#define get_csv2_int_pos523(X,Y) get_csv2_int((X),(Y),523) +#define get_csv2_llong_pos523(X,Y) get_csv2_llong((X),(Y),523) +#define get_csv2_float_pos523(X,Y) get_csv2_float((X),(Y),523) +#define get_csv2_uint_pos524(X,Y) get_csv2_uint((X),(Y),524) +#define get_csv2_ullong_pos524(X,Y) get_csv2_ullong((X),(Y),524) +#define get_csv2_ip_pos524(X,Y) get_csv2_ip((X),(Y),524) +#define get_csv2_ipv6_pos524(X,Y) get_csv2_ipv6((X),(Y),524) +#define get_csv2_string_pos524(X,Y) get_csv2_string((X),(Y),524) +#define get_csv2_v_str_pos524(X,Y) get_csv2_string((X),(Y),524) +#define get_csv2_bool_pos524(X,Y) get_csv2_bool((X),(Y),524) +#define get_csv2_int_pos524(X,Y) get_csv2_int((X),(Y),524) +#define get_csv2_llong_pos524(X,Y) get_csv2_llong((X),(Y),524) +#define get_csv2_float_pos524(X,Y) get_csv2_float((X),(Y),524) +#define get_csv2_uint_pos525(X,Y) get_csv2_uint((X),(Y),525) +#define get_csv2_ullong_pos525(X,Y) get_csv2_ullong((X),(Y),525) +#define get_csv2_ip_pos525(X,Y) get_csv2_ip((X),(Y),525) +#define get_csv2_ipv6_pos525(X,Y) get_csv2_ipv6((X),(Y),525) +#define get_csv2_string_pos525(X,Y) get_csv2_string((X),(Y),525) +#define get_csv2_v_str_pos525(X,Y) get_csv2_string((X),(Y),525) +#define get_csv2_bool_pos525(X,Y) get_csv2_bool((X),(Y),525) +#define get_csv2_int_pos525(X,Y) get_csv2_int((X),(Y),525) +#define get_csv2_llong_pos525(X,Y) get_csv2_llong((X),(Y),525) +#define get_csv2_float_pos525(X,Y) get_csv2_float((X),(Y),525) +#define get_csv2_uint_pos526(X,Y) get_csv2_uint((X),(Y),526) +#define get_csv2_ullong_pos526(X,Y) get_csv2_ullong((X),(Y),526) +#define get_csv2_ip_pos526(X,Y) get_csv2_ip((X),(Y),526) +#define get_csv2_ipv6_pos526(X,Y) get_csv2_ipv6((X),(Y),526) +#define get_csv2_string_pos526(X,Y) get_csv2_string((X),(Y),526) +#define get_csv2_v_str_pos526(X,Y) get_csv2_string((X),(Y),526) +#define get_csv2_bool_pos526(X,Y) get_csv2_bool((X),(Y),526) +#define get_csv2_int_pos526(X,Y) get_csv2_int((X),(Y),526) +#define get_csv2_llong_pos526(X,Y) get_csv2_llong((X),(Y),526) +#define get_csv2_float_pos526(X,Y) get_csv2_float((X),(Y),526) +#define get_csv2_uint_pos527(X,Y) get_csv2_uint((X),(Y),527) +#define get_csv2_ullong_pos527(X,Y) get_csv2_ullong((X),(Y),527) +#define get_csv2_ip_pos527(X,Y) get_csv2_ip((X),(Y),527) +#define get_csv2_ipv6_pos527(X,Y) get_csv2_ipv6((X),(Y),527) +#define get_csv2_string_pos527(X,Y) get_csv2_string((X),(Y),527) +#define get_csv2_v_str_pos527(X,Y) get_csv2_string((X),(Y),527) +#define get_csv2_bool_pos527(X,Y) get_csv2_bool((X),(Y),527) +#define get_csv2_int_pos527(X,Y) get_csv2_int((X),(Y),527) +#define get_csv2_llong_pos527(X,Y) get_csv2_llong((X),(Y),527) +#define get_csv2_float_pos527(X,Y) get_csv2_float((X),(Y),527) +#define get_csv2_uint_pos528(X,Y) get_csv2_uint((X),(Y),528) +#define get_csv2_ullong_pos528(X,Y) get_csv2_ullong((X),(Y),528) +#define get_csv2_ip_pos528(X,Y) get_csv2_ip((X),(Y),528) +#define get_csv2_ipv6_pos528(X,Y) get_csv2_ipv6((X),(Y),528) +#define get_csv2_string_pos528(X,Y) get_csv2_string((X),(Y),528) +#define get_csv2_v_str_pos528(X,Y) get_csv2_string((X),(Y),528) +#define get_csv2_bool_pos528(X,Y) get_csv2_bool((X),(Y),528) +#define get_csv2_int_pos528(X,Y) get_csv2_int((X),(Y),528) +#define get_csv2_llong_pos528(X,Y) get_csv2_llong((X),(Y),528) +#define get_csv2_float_pos528(X,Y) get_csv2_float((X),(Y),528) +#define get_csv2_uint_pos529(X,Y) get_csv2_uint((X),(Y),529) +#define get_csv2_ullong_pos529(X,Y) get_csv2_ullong((X),(Y),529) +#define get_csv2_ip_pos529(X,Y) get_csv2_ip((X),(Y),529) +#define get_csv2_ipv6_pos529(X,Y) get_csv2_ipv6((X),(Y),529) +#define get_csv2_string_pos529(X,Y) get_csv2_string((X),(Y),529) +#define get_csv2_v_str_pos529(X,Y) get_csv2_string((X),(Y),529) +#define get_csv2_bool_pos529(X,Y) get_csv2_bool((X),(Y),529) +#define get_csv2_int_pos529(X,Y) get_csv2_int((X),(Y),529) +#define get_csv2_llong_pos529(X,Y) get_csv2_llong((X),(Y),529) +#define get_csv2_float_pos529(X,Y) get_csv2_float((X),(Y),529) +#define get_csv2_uint_pos530(X,Y) get_csv2_uint((X),(Y),530) +#define get_csv2_ullong_pos530(X,Y) get_csv2_ullong((X),(Y),530) +#define get_csv2_ip_pos530(X,Y) get_csv2_ip((X),(Y),530) +#define get_csv2_ipv6_pos530(X,Y) get_csv2_ipv6((X),(Y),530) +#define get_csv2_string_pos530(X,Y) get_csv2_string((X),(Y),530) +#define get_csv2_v_str_pos530(X,Y) get_csv2_string((X),(Y),530) +#define get_csv2_bool_pos530(X,Y) get_csv2_bool((X),(Y),530) +#define get_csv2_int_pos530(X,Y) get_csv2_int((X),(Y),530) +#define get_csv2_llong_pos530(X,Y) get_csv2_llong((X),(Y),530) +#define get_csv2_float_pos530(X,Y) get_csv2_float((X),(Y),530) +#define get_csv2_uint_pos531(X,Y) get_csv2_uint((X),(Y),531) +#define get_csv2_ullong_pos531(X,Y) get_csv2_ullong((X),(Y),531) +#define get_csv2_ip_pos531(X,Y) get_csv2_ip((X),(Y),531) +#define get_csv2_ipv6_pos531(X,Y) get_csv2_ipv6((X),(Y),531) +#define get_csv2_string_pos531(X,Y) get_csv2_string((X),(Y),531) +#define get_csv2_v_str_pos531(X,Y) get_csv2_string((X),(Y),531) +#define get_csv2_bool_pos531(X,Y) get_csv2_bool((X),(Y),531) +#define get_csv2_int_pos531(X,Y) get_csv2_int((X),(Y),531) +#define get_csv2_llong_pos531(X,Y) get_csv2_llong((X),(Y),531) +#define get_csv2_float_pos531(X,Y) get_csv2_float((X),(Y),531) +#define get_csv2_uint_pos532(X,Y) get_csv2_uint((X),(Y),532) +#define get_csv2_ullong_pos532(X,Y) get_csv2_ullong((X),(Y),532) +#define get_csv2_ip_pos532(X,Y) get_csv2_ip((X),(Y),532) +#define get_csv2_ipv6_pos532(X,Y) get_csv2_ipv6((X),(Y),532) +#define get_csv2_string_pos532(X,Y) get_csv2_string((X),(Y),532) +#define get_csv2_v_str_pos532(X,Y) get_csv2_string((X),(Y),532) +#define get_csv2_bool_pos532(X,Y) get_csv2_bool((X),(Y),532) +#define get_csv2_int_pos532(X,Y) get_csv2_int((X),(Y),532) +#define get_csv2_llong_pos532(X,Y) get_csv2_llong((X),(Y),532) +#define get_csv2_float_pos532(X,Y) get_csv2_float((X),(Y),532) +#define get_csv2_uint_pos533(X,Y) get_csv2_uint((X),(Y),533) +#define get_csv2_ullong_pos533(X,Y) get_csv2_ullong((X),(Y),533) +#define get_csv2_ip_pos533(X,Y) get_csv2_ip((X),(Y),533) +#define get_csv2_ipv6_pos533(X,Y) get_csv2_ipv6((X),(Y),533) +#define get_csv2_string_pos533(X,Y) get_csv2_string((X),(Y),533) +#define get_csv2_v_str_pos533(X,Y) get_csv2_string((X),(Y),533) +#define get_csv2_bool_pos533(X,Y) get_csv2_bool((X),(Y),533) +#define get_csv2_int_pos533(X,Y) get_csv2_int((X),(Y),533) +#define get_csv2_llong_pos533(X,Y) get_csv2_llong((X),(Y),533) +#define get_csv2_float_pos533(X,Y) get_csv2_float((X),(Y),533) +#define get_csv2_uint_pos534(X,Y) get_csv2_uint((X),(Y),534) +#define get_csv2_ullong_pos534(X,Y) get_csv2_ullong((X),(Y),534) +#define get_csv2_ip_pos534(X,Y) get_csv2_ip((X),(Y),534) +#define get_csv2_ipv6_pos534(X,Y) get_csv2_ipv6((X),(Y),534) +#define get_csv2_string_pos534(X,Y) get_csv2_string((X),(Y),534) +#define get_csv2_v_str_pos534(X,Y) get_csv2_string((X),(Y),534) +#define get_csv2_bool_pos534(X,Y) get_csv2_bool((X),(Y),534) +#define get_csv2_int_pos534(X,Y) get_csv2_int((X),(Y),534) +#define get_csv2_llong_pos534(X,Y) get_csv2_llong((X),(Y),534) +#define get_csv2_float_pos534(X,Y) get_csv2_float((X),(Y),534) +#define get_csv2_uint_pos535(X,Y) get_csv2_uint((X),(Y),535) +#define get_csv2_ullong_pos535(X,Y) get_csv2_ullong((X),(Y),535) +#define get_csv2_ip_pos535(X,Y) get_csv2_ip((X),(Y),535) +#define get_csv2_ipv6_pos535(X,Y) get_csv2_ipv6((X),(Y),535) +#define get_csv2_string_pos535(X,Y) get_csv2_string((X),(Y),535) +#define get_csv2_v_str_pos535(X,Y) get_csv2_string((X),(Y),535) +#define get_csv2_bool_pos535(X,Y) get_csv2_bool((X),(Y),535) +#define get_csv2_int_pos535(X,Y) get_csv2_int((X),(Y),535) +#define get_csv2_llong_pos535(X,Y) get_csv2_llong((X),(Y),535) +#define get_csv2_float_pos535(X,Y) get_csv2_float((X),(Y),535) +#define get_csv2_uint_pos536(X,Y) get_csv2_uint((X),(Y),536) +#define get_csv2_ullong_pos536(X,Y) get_csv2_ullong((X),(Y),536) +#define get_csv2_ip_pos536(X,Y) get_csv2_ip((X),(Y),536) +#define get_csv2_ipv6_pos536(X,Y) get_csv2_ipv6((X),(Y),536) +#define get_csv2_string_pos536(X,Y) get_csv2_string((X),(Y),536) +#define get_csv2_v_str_pos536(X,Y) get_csv2_string((X),(Y),536) +#define get_csv2_bool_pos536(X,Y) get_csv2_bool((X),(Y),536) +#define get_csv2_int_pos536(X,Y) get_csv2_int((X),(Y),536) +#define get_csv2_llong_pos536(X,Y) get_csv2_llong((X),(Y),536) +#define get_csv2_float_pos536(X,Y) get_csv2_float((X),(Y),536) +#define get_csv2_uint_pos537(X,Y) get_csv2_uint((X),(Y),537) +#define get_csv2_ullong_pos537(X,Y) get_csv2_ullong((X),(Y),537) +#define get_csv2_ip_pos537(X,Y) get_csv2_ip((X),(Y),537) +#define get_csv2_ipv6_pos537(X,Y) get_csv2_ipv6((X),(Y),537) +#define get_csv2_string_pos537(X,Y) get_csv2_string((X),(Y),537) +#define get_csv2_v_str_pos537(X,Y) get_csv2_string((X),(Y),537) +#define get_csv2_bool_pos537(X,Y) get_csv2_bool((X),(Y),537) +#define get_csv2_int_pos537(X,Y) get_csv2_int((X),(Y),537) +#define get_csv2_llong_pos537(X,Y) get_csv2_llong((X),(Y),537) +#define get_csv2_float_pos537(X,Y) get_csv2_float((X),(Y),537) +#define get_csv2_uint_pos538(X,Y) get_csv2_uint((X),(Y),538) +#define get_csv2_ullong_pos538(X,Y) get_csv2_ullong((X),(Y),538) +#define get_csv2_ip_pos538(X,Y) get_csv2_ip((X),(Y),538) +#define get_csv2_ipv6_pos538(X,Y) get_csv2_ipv6((X),(Y),538) +#define get_csv2_string_pos538(X,Y) get_csv2_string((X),(Y),538) +#define get_csv2_v_str_pos538(X,Y) get_csv2_string((X),(Y),538) +#define get_csv2_bool_pos538(X,Y) get_csv2_bool((X),(Y),538) +#define get_csv2_int_pos538(X,Y) get_csv2_int((X),(Y),538) +#define get_csv2_llong_pos538(X,Y) get_csv2_llong((X),(Y),538) +#define get_csv2_float_pos538(X,Y) get_csv2_float((X),(Y),538) +#define get_csv2_uint_pos539(X,Y) get_csv2_uint((X),(Y),539) +#define get_csv2_ullong_pos539(X,Y) get_csv2_ullong((X),(Y),539) +#define get_csv2_ip_pos539(X,Y) get_csv2_ip((X),(Y),539) +#define get_csv2_ipv6_pos539(X,Y) get_csv2_ipv6((X),(Y),539) +#define get_csv2_string_pos539(X,Y) get_csv2_string((X),(Y),539) +#define get_csv2_v_str_pos539(X,Y) get_csv2_string((X),(Y),539) +#define get_csv2_bool_pos539(X,Y) get_csv2_bool((X),(Y),539) +#define get_csv2_int_pos539(X,Y) get_csv2_int((X),(Y),539) +#define get_csv2_llong_pos539(X,Y) get_csv2_llong((X),(Y),539) +#define get_csv2_float_pos539(X,Y) get_csv2_float((X),(Y),539) +#define get_csv2_uint_pos540(X,Y) get_csv2_uint((X),(Y),540) +#define get_csv2_ullong_pos540(X,Y) get_csv2_ullong((X),(Y),540) +#define get_csv2_ip_pos540(X,Y) get_csv2_ip((X),(Y),540) +#define get_csv2_ipv6_pos540(X,Y) get_csv2_ipv6((X),(Y),540) +#define get_csv2_string_pos540(X,Y) get_csv2_string((X),(Y),540) +#define get_csv2_v_str_pos540(X,Y) get_csv2_string((X),(Y),540) +#define get_csv2_bool_pos540(X,Y) get_csv2_bool((X),(Y),540) +#define get_csv2_int_pos540(X,Y) get_csv2_int((X),(Y),540) +#define get_csv2_llong_pos540(X,Y) get_csv2_llong((X),(Y),540) +#define get_csv2_float_pos540(X,Y) get_csv2_float((X),(Y),540) +#define get_csv2_uint_pos541(X,Y) get_csv2_uint((X),(Y),541) +#define get_csv2_ullong_pos541(X,Y) get_csv2_ullong((X),(Y),541) +#define get_csv2_ip_pos541(X,Y) get_csv2_ip((X),(Y),541) +#define get_csv2_ipv6_pos541(X,Y) get_csv2_ipv6((X),(Y),541) +#define get_csv2_string_pos541(X,Y) get_csv2_string((X),(Y),541) +#define get_csv2_v_str_pos541(X,Y) get_csv2_string((X),(Y),541) +#define get_csv2_bool_pos541(X,Y) get_csv2_bool((X),(Y),541) +#define get_csv2_int_pos541(X,Y) get_csv2_int((X),(Y),541) +#define get_csv2_llong_pos541(X,Y) get_csv2_llong((X),(Y),541) +#define get_csv2_float_pos541(X,Y) get_csv2_float((X),(Y),541) +#define get_csv2_uint_pos542(X,Y) get_csv2_uint((X),(Y),542) +#define get_csv2_ullong_pos542(X,Y) get_csv2_ullong((X),(Y),542) +#define get_csv2_ip_pos542(X,Y) get_csv2_ip((X),(Y),542) +#define get_csv2_ipv6_pos542(X,Y) get_csv2_ipv6((X),(Y),542) +#define get_csv2_string_pos542(X,Y) get_csv2_string((X),(Y),542) +#define get_csv2_v_str_pos542(X,Y) get_csv2_string((X),(Y),542) +#define get_csv2_bool_pos542(X,Y) get_csv2_bool((X),(Y),542) +#define get_csv2_int_pos542(X,Y) get_csv2_int((X),(Y),542) +#define get_csv2_llong_pos542(X,Y) get_csv2_llong((X),(Y),542) +#define get_csv2_float_pos542(X,Y) get_csv2_float((X),(Y),542) +#define get_csv2_uint_pos543(X,Y) get_csv2_uint((X),(Y),543) +#define get_csv2_ullong_pos543(X,Y) get_csv2_ullong((X),(Y),543) +#define get_csv2_ip_pos543(X,Y) get_csv2_ip((X),(Y),543) +#define get_csv2_ipv6_pos543(X,Y) get_csv2_ipv6((X),(Y),543) +#define get_csv2_string_pos543(X,Y) get_csv2_string((X),(Y),543) +#define get_csv2_v_str_pos543(X,Y) get_csv2_string((X),(Y),543) +#define get_csv2_bool_pos543(X,Y) get_csv2_bool((X),(Y),543) +#define get_csv2_int_pos543(X,Y) get_csv2_int((X),(Y),543) +#define get_csv2_llong_pos543(X,Y) get_csv2_llong((X),(Y),543) +#define get_csv2_float_pos543(X,Y) get_csv2_float((X),(Y),543) +#define get_csv2_uint_pos544(X,Y) get_csv2_uint((X),(Y),544) +#define get_csv2_ullong_pos544(X,Y) get_csv2_ullong((X),(Y),544) +#define get_csv2_ip_pos544(X,Y) get_csv2_ip((X),(Y),544) +#define get_csv2_ipv6_pos544(X,Y) get_csv2_ipv6((X),(Y),544) +#define get_csv2_string_pos544(X,Y) get_csv2_string((X),(Y),544) +#define get_csv2_v_str_pos544(X,Y) get_csv2_string((X),(Y),544) +#define get_csv2_bool_pos544(X,Y) get_csv2_bool((X),(Y),544) +#define get_csv2_int_pos544(X,Y) get_csv2_int((X),(Y),544) +#define get_csv2_llong_pos544(X,Y) get_csv2_llong((X),(Y),544) +#define get_csv2_float_pos544(X,Y) get_csv2_float((X),(Y),544) +#define get_csv2_uint_pos545(X,Y) get_csv2_uint((X),(Y),545) +#define get_csv2_ullong_pos545(X,Y) get_csv2_ullong((X),(Y),545) +#define get_csv2_ip_pos545(X,Y) get_csv2_ip((X),(Y),545) +#define get_csv2_ipv6_pos545(X,Y) get_csv2_ipv6((X),(Y),545) +#define get_csv2_string_pos545(X,Y) get_csv2_string((X),(Y),545) +#define get_csv2_v_str_pos545(X,Y) get_csv2_string((X),(Y),545) +#define get_csv2_bool_pos545(X,Y) get_csv2_bool((X),(Y),545) +#define get_csv2_int_pos545(X,Y) get_csv2_int((X),(Y),545) +#define get_csv2_llong_pos545(X,Y) get_csv2_llong((X),(Y),545) +#define get_csv2_float_pos545(X,Y) get_csv2_float((X),(Y),545) +#define get_csv2_uint_pos546(X,Y) get_csv2_uint((X),(Y),546) +#define get_csv2_ullong_pos546(X,Y) get_csv2_ullong((X),(Y),546) +#define get_csv2_ip_pos546(X,Y) get_csv2_ip((X),(Y),546) +#define get_csv2_ipv6_pos546(X,Y) get_csv2_ipv6((X),(Y),546) +#define get_csv2_string_pos546(X,Y) get_csv2_string((X),(Y),546) +#define get_csv2_v_str_pos546(X,Y) get_csv2_string((X),(Y),546) +#define get_csv2_bool_pos546(X,Y) get_csv2_bool((X),(Y),546) +#define get_csv2_int_pos546(X,Y) get_csv2_int((X),(Y),546) +#define get_csv2_llong_pos546(X,Y) get_csv2_llong((X),(Y),546) +#define get_csv2_float_pos546(X,Y) get_csv2_float((X),(Y),546) +#define get_csv2_uint_pos547(X,Y) get_csv2_uint((X),(Y),547) +#define get_csv2_ullong_pos547(X,Y) get_csv2_ullong((X),(Y),547) +#define get_csv2_ip_pos547(X,Y) get_csv2_ip((X),(Y),547) +#define get_csv2_ipv6_pos547(X,Y) get_csv2_ipv6((X),(Y),547) +#define get_csv2_string_pos547(X,Y) get_csv2_string((X),(Y),547) +#define get_csv2_v_str_pos547(X,Y) get_csv2_string((X),(Y),547) +#define get_csv2_bool_pos547(X,Y) get_csv2_bool((X),(Y),547) +#define get_csv2_int_pos547(X,Y) get_csv2_int((X),(Y),547) +#define get_csv2_llong_pos547(X,Y) get_csv2_llong((X),(Y),547) +#define get_csv2_float_pos547(X,Y) get_csv2_float((X),(Y),547) +#define get_csv2_uint_pos548(X,Y) get_csv2_uint((X),(Y),548) +#define get_csv2_ullong_pos548(X,Y) get_csv2_ullong((X),(Y),548) +#define get_csv2_ip_pos548(X,Y) get_csv2_ip((X),(Y),548) +#define get_csv2_ipv6_pos548(X,Y) get_csv2_ipv6((X),(Y),548) +#define get_csv2_string_pos548(X,Y) get_csv2_string((X),(Y),548) +#define get_csv2_v_str_pos548(X,Y) get_csv2_string((X),(Y),548) +#define get_csv2_bool_pos548(X,Y) get_csv2_bool((X),(Y),548) +#define get_csv2_int_pos548(X,Y) get_csv2_int((X),(Y),548) +#define get_csv2_llong_pos548(X,Y) get_csv2_llong((X),(Y),548) +#define get_csv2_float_pos548(X,Y) get_csv2_float((X),(Y),548) +#define get_csv2_uint_pos549(X,Y) get_csv2_uint((X),(Y),549) +#define get_csv2_ullong_pos549(X,Y) get_csv2_ullong((X),(Y),549) +#define get_csv2_ip_pos549(X,Y) get_csv2_ip((X),(Y),549) +#define get_csv2_ipv6_pos549(X,Y) get_csv2_ipv6((X),(Y),549) +#define get_csv2_string_pos549(X,Y) get_csv2_string((X),(Y),549) +#define get_csv2_v_str_pos549(X,Y) get_csv2_string((X),(Y),549) +#define get_csv2_bool_pos549(X,Y) get_csv2_bool((X),(Y),549) +#define get_csv2_int_pos549(X,Y) get_csv2_int((X),(Y),549) +#define get_csv2_llong_pos549(X,Y) get_csv2_llong((X),(Y),549) +#define get_csv2_float_pos549(X,Y) get_csv2_float((X),(Y),549) +#define get_csv2_uint_pos550(X,Y) get_csv2_uint((X),(Y),550) +#define get_csv2_ullong_pos550(X,Y) get_csv2_ullong((X),(Y),550) +#define get_csv2_ip_pos550(X,Y) get_csv2_ip((X),(Y),550) +#define get_csv2_ipv6_pos550(X,Y) get_csv2_ipv6((X),(Y),550) +#define get_csv2_string_pos550(X,Y) get_csv2_string((X),(Y),550) +#define get_csv2_v_str_pos550(X,Y) get_csv2_string((X),(Y),550) +#define get_csv2_bool_pos550(X,Y) get_csv2_bool((X),(Y),550) +#define get_csv2_int_pos550(X,Y) get_csv2_int((X),(Y),550) +#define get_csv2_llong_pos550(X,Y) get_csv2_llong((X),(Y),550) +#define get_csv2_float_pos550(X,Y) get_csv2_float((X),(Y),550) +#define get_csv2_uint_pos551(X,Y) get_csv2_uint((X),(Y),551) +#define get_csv2_ullong_pos551(X,Y) get_csv2_ullong((X),(Y),551) +#define get_csv2_ip_pos551(X,Y) get_csv2_ip((X),(Y),551) +#define get_csv2_ipv6_pos551(X,Y) get_csv2_ipv6((X),(Y),551) +#define get_csv2_string_pos551(X,Y) get_csv2_string((X),(Y),551) +#define get_csv2_v_str_pos551(X,Y) get_csv2_string((X),(Y),551) +#define get_csv2_bool_pos551(X,Y) get_csv2_bool((X),(Y),551) +#define get_csv2_int_pos551(X,Y) get_csv2_int((X),(Y),551) +#define get_csv2_llong_pos551(X,Y) get_csv2_llong((X),(Y),551) +#define get_csv2_float_pos551(X,Y) get_csv2_float((X),(Y),551) +#define get_csv2_uint_pos552(X,Y) get_csv2_uint((X),(Y),552) +#define get_csv2_ullong_pos552(X,Y) get_csv2_ullong((X),(Y),552) +#define get_csv2_ip_pos552(X,Y) get_csv2_ip((X),(Y),552) +#define get_csv2_ipv6_pos552(X,Y) get_csv2_ipv6((X),(Y),552) +#define get_csv2_string_pos552(X,Y) get_csv2_string((X),(Y),552) +#define get_csv2_v_str_pos552(X,Y) get_csv2_string((X),(Y),552) +#define get_csv2_bool_pos552(X,Y) get_csv2_bool((X),(Y),552) +#define get_csv2_int_pos552(X,Y) get_csv2_int((X),(Y),552) +#define get_csv2_llong_pos552(X,Y) get_csv2_llong((X),(Y),552) +#define get_csv2_float_pos552(X,Y) get_csv2_float((X),(Y),552) +#define get_csv2_uint_pos553(X,Y) get_csv2_uint((X),(Y),553) +#define get_csv2_ullong_pos553(X,Y) get_csv2_ullong((X),(Y),553) +#define get_csv2_ip_pos553(X,Y) get_csv2_ip((X),(Y),553) +#define get_csv2_ipv6_pos553(X,Y) get_csv2_ipv6((X),(Y),553) +#define get_csv2_string_pos553(X,Y) get_csv2_string((X),(Y),553) +#define get_csv2_v_str_pos553(X,Y) get_csv2_string((X),(Y),553) +#define get_csv2_bool_pos553(X,Y) get_csv2_bool((X),(Y),553) +#define get_csv2_int_pos553(X,Y) get_csv2_int((X),(Y),553) +#define get_csv2_llong_pos553(X,Y) get_csv2_llong((X),(Y),553) +#define get_csv2_float_pos553(X,Y) get_csv2_float((X),(Y),553) +#define get_csv2_uint_pos554(X,Y) get_csv2_uint((X),(Y),554) +#define get_csv2_ullong_pos554(X,Y) get_csv2_ullong((X),(Y),554) +#define get_csv2_ip_pos554(X,Y) get_csv2_ip((X),(Y),554) +#define get_csv2_ipv6_pos554(X,Y) get_csv2_ipv6((X),(Y),554) +#define get_csv2_string_pos554(X,Y) get_csv2_string((X),(Y),554) +#define get_csv2_v_str_pos554(X,Y) get_csv2_string((X),(Y),554) +#define get_csv2_bool_pos554(X,Y) get_csv2_bool((X),(Y),554) +#define get_csv2_int_pos554(X,Y) get_csv2_int((X),(Y),554) +#define get_csv2_llong_pos554(X,Y) get_csv2_llong((X),(Y),554) +#define get_csv2_float_pos554(X,Y) get_csv2_float((X),(Y),554) +#define get_csv2_uint_pos555(X,Y) get_csv2_uint((X),(Y),555) +#define get_csv2_ullong_pos555(X,Y) get_csv2_ullong((X),(Y),555) +#define get_csv2_ip_pos555(X,Y) get_csv2_ip((X),(Y),555) +#define get_csv2_ipv6_pos555(X,Y) get_csv2_ipv6((X),(Y),555) +#define get_csv2_string_pos555(X,Y) get_csv2_string((X),(Y),555) +#define get_csv2_v_str_pos555(X,Y) get_csv2_string((X),(Y),555) +#define get_csv2_bool_pos555(X,Y) get_csv2_bool((X),(Y),555) +#define get_csv2_int_pos555(X,Y) get_csv2_int((X),(Y),555) +#define get_csv2_llong_pos555(X,Y) get_csv2_llong((X),(Y),555) +#define get_csv2_float_pos555(X,Y) get_csv2_float((X),(Y),555) +#define get_csv2_uint_pos556(X,Y) get_csv2_uint((X),(Y),556) +#define get_csv2_ullong_pos556(X,Y) get_csv2_ullong((X),(Y),556) +#define get_csv2_ip_pos556(X,Y) get_csv2_ip((X),(Y),556) +#define get_csv2_ipv6_pos556(X,Y) get_csv2_ipv6((X),(Y),556) +#define get_csv2_string_pos556(X,Y) get_csv2_string((X),(Y),556) +#define get_csv2_v_str_pos556(X,Y) get_csv2_string((X),(Y),556) +#define get_csv2_bool_pos556(X,Y) get_csv2_bool((X),(Y),556) +#define get_csv2_int_pos556(X,Y) get_csv2_int((X),(Y),556) +#define get_csv2_llong_pos556(X,Y) get_csv2_llong((X),(Y),556) +#define get_csv2_float_pos556(X,Y) get_csv2_float((X),(Y),556) +#define get_csv2_uint_pos557(X,Y) get_csv2_uint((X),(Y),557) +#define get_csv2_ullong_pos557(X,Y) get_csv2_ullong((X),(Y),557) +#define get_csv2_ip_pos557(X,Y) get_csv2_ip((X),(Y),557) +#define get_csv2_ipv6_pos557(X,Y) get_csv2_ipv6((X),(Y),557) +#define get_csv2_string_pos557(X,Y) get_csv2_string((X),(Y),557) +#define get_csv2_v_str_pos557(X,Y) get_csv2_string((X),(Y),557) +#define get_csv2_bool_pos557(X,Y) get_csv2_bool((X),(Y),557) +#define get_csv2_int_pos557(X,Y) get_csv2_int((X),(Y),557) +#define get_csv2_llong_pos557(X,Y) get_csv2_llong((X),(Y),557) +#define get_csv2_float_pos557(X,Y) get_csv2_float((X),(Y),557) +#define get_csv2_uint_pos558(X,Y) get_csv2_uint((X),(Y),558) +#define get_csv2_ullong_pos558(X,Y) get_csv2_ullong((X),(Y),558) +#define get_csv2_ip_pos558(X,Y) get_csv2_ip((X),(Y),558) +#define get_csv2_ipv6_pos558(X,Y) get_csv2_ipv6((X),(Y),558) +#define get_csv2_string_pos558(X,Y) get_csv2_string((X),(Y),558) +#define get_csv2_v_str_pos558(X,Y) get_csv2_string((X),(Y),558) +#define get_csv2_bool_pos558(X,Y) get_csv2_bool((X),(Y),558) +#define get_csv2_int_pos558(X,Y) get_csv2_int((X),(Y),558) +#define get_csv2_llong_pos558(X,Y) get_csv2_llong((X),(Y),558) +#define get_csv2_float_pos558(X,Y) get_csv2_float((X),(Y),558) +#define get_csv2_uint_pos559(X,Y) get_csv2_uint((X),(Y),559) +#define get_csv2_ullong_pos559(X,Y) get_csv2_ullong((X),(Y),559) +#define get_csv2_ip_pos559(X,Y) get_csv2_ip((X),(Y),559) +#define get_csv2_ipv6_pos559(X,Y) get_csv2_ipv6((X),(Y),559) +#define get_csv2_string_pos559(X,Y) get_csv2_string((X),(Y),559) +#define get_csv2_v_str_pos559(X,Y) get_csv2_string((X),(Y),559) +#define get_csv2_bool_pos559(X,Y) get_csv2_bool((X),(Y),559) +#define get_csv2_int_pos559(X,Y) get_csv2_int((X),(Y),559) +#define get_csv2_llong_pos559(X,Y) get_csv2_llong((X),(Y),559) +#define get_csv2_float_pos559(X,Y) get_csv2_float((X),(Y),559) +#define get_csv2_uint_pos560(X,Y) get_csv2_uint((X),(Y),560) +#define get_csv2_ullong_pos560(X,Y) get_csv2_ullong((X),(Y),560) +#define get_csv2_ip_pos560(X,Y) get_csv2_ip((X),(Y),560) +#define get_csv2_ipv6_pos560(X,Y) get_csv2_ipv6((X),(Y),560) +#define get_csv2_string_pos560(X,Y) get_csv2_string((X),(Y),560) +#define get_csv2_v_str_pos560(X,Y) get_csv2_string((X),(Y),560) +#define get_csv2_bool_pos560(X,Y) get_csv2_bool((X),(Y),560) +#define get_csv2_int_pos560(X,Y) get_csv2_int((X),(Y),560) +#define get_csv2_llong_pos560(X,Y) get_csv2_llong((X),(Y),560) +#define get_csv2_float_pos560(X,Y) get_csv2_float((X),(Y),560) +#define get_csv2_uint_pos561(X,Y) get_csv2_uint((X),(Y),561) +#define get_csv2_ullong_pos561(X,Y) get_csv2_ullong((X),(Y),561) +#define get_csv2_ip_pos561(X,Y) get_csv2_ip((X),(Y),561) +#define get_csv2_ipv6_pos561(X,Y) get_csv2_ipv6((X),(Y),561) +#define get_csv2_string_pos561(X,Y) get_csv2_string((X),(Y),561) +#define get_csv2_v_str_pos561(X,Y) get_csv2_string((X),(Y),561) +#define get_csv2_bool_pos561(X,Y) get_csv2_bool((X),(Y),561) +#define get_csv2_int_pos561(X,Y) get_csv2_int((X),(Y),561) +#define get_csv2_llong_pos561(X,Y) get_csv2_llong((X),(Y),561) +#define get_csv2_float_pos561(X,Y) get_csv2_float((X),(Y),561) +#define get_csv2_uint_pos562(X,Y) get_csv2_uint((X),(Y),562) +#define get_csv2_ullong_pos562(X,Y) get_csv2_ullong((X),(Y),562) +#define get_csv2_ip_pos562(X,Y) get_csv2_ip((X),(Y),562) +#define get_csv2_ipv6_pos562(X,Y) get_csv2_ipv6((X),(Y),562) +#define get_csv2_string_pos562(X,Y) get_csv2_string((X),(Y),562) +#define get_csv2_v_str_pos562(X,Y) get_csv2_string((X),(Y),562) +#define get_csv2_bool_pos562(X,Y) get_csv2_bool((X),(Y),562) +#define get_csv2_int_pos562(X,Y) get_csv2_int((X),(Y),562) +#define get_csv2_llong_pos562(X,Y) get_csv2_llong((X),(Y),562) +#define get_csv2_float_pos562(X,Y) get_csv2_float((X),(Y),562) +#define get_csv2_uint_pos563(X,Y) get_csv2_uint((X),(Y),563) +#define get_csv2_ullong_pos563(X,Y) get_csv2_ullong((X),(Y),563) +#define get_csv2_ip_pos563(X,Y) get_csv2_ip((X),(Y),563) +#define get_csv2_ipv6_pos563(X,Y) get_csv2_ipv6((X),(Y),563) +#define get_csv2_string_pos563(X,Y) get_csv2_string((X),(Y),563) +#define get_csv2_v_str_pos563(X,Y) get_csv2_string((X),(Y),563) +#define get_csv2_bool_pos563(X,Y) get_csv2_bool((X),(Y),563) +#define get_csv2_int_pos563(X,Y) get_csv2_int((X),(Y),563) +#define get_csv2_llong_pos563(X,Y) get_csv2_llong((X),(Y),563) +#define get_csv2_float_pos563(X,Y) get_csv2_float((X),(Y),563) +#define get_csv2_uint_pos564(X,Y) get_csv2_uint((X),(Y),564) +#define get_csv2_ullong_pos564(X,Y) get_csv2_ullong((X),(Y),564) +#define get_csv2_ip_pos564(X,Y) get_csv2_ip((X),(Y),564) +#define get_csv2_ipv6_pos564(X,Y) get_csv2_ipv6((X),(Y),564) +#define get_csv2_string_pos564(X,Y) get_csv2_string((X),(Y),564) +#define get_csv2_v_str_pos564(X,Y) get_csv2_string((X),(Y),564) +#define get_csv2_bool_pos564(X,Y) get_csv2_bool((X),(Y),564) +#define get_csv2_int_pos564(X,Y) get_csv2_int((X),(Y),564) +#define get_csv2_llong_pos564(X,Y) get_csv2_llong((X),(Y),564) +#define get_csv2_float_pos564(X,Y) get_csv2_float((X),(Y),564) +#define get_csv2_uint_pos565(X,Y) get_csv2_uint((X),(Y),565) +#define get_csv2_ullong_pos565(X,Y) get_csv2_ullong((X),(Y),565) +#define get_csv2_ip_pos565(X,Y) get_csv2_ip((X),(Y),565) +#define get_csv2_ipv6_pos565(X,Y) get_csv2_ipv6((X),(Y),565) +#define get_csv2_string_pos565(X,Y) get_csv2_string((X),(Y),565) +#define get_csv2_v_str_pos565(X,Y) get_csv2_string((X),(Y),565) +#define get_csv2_bool_pos565(X,Y) get_csv2_bool((X),(Y),565) +#define get_csv2_int_pos565(X,Y) get_csv2_int((X),(Y),565) +#define get_csv2_llong_pos565(X,Y) get_csv2_llong((X),(Y),565) +#define get_csv2_float_pos565(X,Y) get_csv2_float((X),(Y),565) +#define get_csv2_uint_pos566(X,Y) get_csv2_uint((X),(Y),566) +#define get_csv2_ullong_pos566(X,Y) get_csv2_ullong((X),(Y),566) +#define get_csv2_ip_pos566(X,Y) get_csv2_ip((X),(Y),566) +#define get_csv2_ipv6_pos566(X,Y) get_csv2_ipv6((X),(Y),566) +#define get_csv2_string_pos566(X,Y) get_csv2_string((X),(Y),566) +#define get_csv2_v_str_pos566(X,Y) get_csv2_string((X),(Y),566) +#define get_csv2_bool_pos566(X,Y) get_csv2_bool((X),(Y),566) +#define get_csv2_int_pos566(X,Y) get_csv2_int((X),(Y),566) +#define get_csv2_llong_pos566(X,Y) get_csv2_llong((X),(Y),566) +#define get_csv2_float_pos566(X,Y) get_csv2_float((X),(Y),566) +#define get_csv2_uint_pos567(X,Y) get_csv2_uint((X),(Y),567) +#define get_csv2_ullong_pos567(X,Y) get_csv2_ullong((X),(Y),567) +#define get_csv2_ip_pos567(X,Y) get_csv2_ip((X),(Y),567) +#define get_csv2_ipv6_pos567(X,Y) get_csv2_ipv6((X),(Y),567) +#define get_csv2_string_pos567(X,Y) get_csv2_string((X),(Y),567) +#define get_csv2_v_str_pos567(X,Y) get_csv2_string((X),(Y),567) +#define get_csv2_bool_pos567(X,Y) get_csv2_bool((X),(Y),567) +#define get_csv2_int_pos567(X,Y) get_csv2_int((X),(Y),567) +#define get_csv2_llong_pos567(X,Y) get_csv2_llong((X),(Y),567) +#define get_csv2_float_pos567(X,Y) get_csv2_float((X),(Y),567) +#define get_csv2_uint_pos568(X,Y) get_csv2_uint((X),(Y),568) +#define get_csv2_ullong_pos568(X,Y) get_csv2_ullong((X),(Y),568) +#define get_csv2_ip_pos568(X,Y) get_csv2_ip((X),(Y),568) +#define get_csv2_ipv6_pos568(X,Y) get_csv2_ipv6((X),(Y),568) +#define get_csv2_string_pos568(X,Y) get_csv2_string((X),(Y),568) +#define get_csv2_v_str_pos568(X,Y) get_csv2_string((X),(Y),568) +#define get_csv2_bool_pos568(X,Y) get_csv2_bool((X),(Y),568) +#define get_csv2_int_pos568(X,Y) get_csv2_int((X),(Y),568) +#define get_csv2_llong_pos568(X,Y) get_csv2_llong((X),(Y),568) +#define get_csv2_float_pos568(X,Y) get_csv2_float((X),(Y),568) +#define get_csv2_uint_pos569(X,Y) get_csv2_uint((X),(Y),569) +#define get_csv2_ullong_pos569(X,Y) get_csv2_ullong((X),(Y),569) +#define get_csv2_ip_pos569(X,Y) get_csv2_ip((X),(Y),569) +#define get_csv2_ipv6_pos569(X,Y) get_csv2_ipv6((X),(Y),569) +#define get_csv2_string_pos569(X,Y) get_csv2_string((X),(Y),569) +#define get_csv2_v_str_pos569(X,Y) get_csv2_string((X),(Y),569) +#define get_csv2_bool_pos569(X,Y) get_csv2_bool((X),(Y),569) +#define get_csv2_int_pos569(X,Y) get_csv2_int((X),(Y),569) +#define get_csv2_llong_pos569(X,Y) get_csv2_llong((X),(Y),569) +#define get_csv2_float_pos569(X,Y) get_csv2_float((X),(Y),569) +#define get_csv2_uint_pos570(X,Y) get_csv2_uint((X),(Y),570) +#define get_csv2_ullong_pos570(X,Y) get_csv2_ullong((X),(Y),570) +#define get_csv2_ip_pos570(X,Y) get_csv2_ip((X),(Y),570) +#define get_csv2_ipv6_pos570(X,Y) get_csv2_ipv6((X),(Y),570) +#define get_csv2_string_pos570(X,Y) get_csv2_string((X),(Y),570) +#define get_csv2_v_str_pos570(X,Y) get_csv2_string((X),(Y),570) +#define get_csv2_bool_pos570(X,Y) get_csv2_bool((X),(Y),570) +#define get_csv2_int_pos570(X,Y) get_csv2_int((X),(Y),570) +#define get_csv2_llong_pos570(X,Y) get_csv2_llong((X),(Y),570) +#define get_csv2_float_pos570(X,Y) get_csv2_float((X),(Y),570) +#define get_csv2_uint_pos571(X,Y) get_csv2_uint((X),(Y),571) +#define get_csv2_ullong_pos571(X,Y) get_csv2_ullong((X),(Y),571) +#define get_csv2_ip_pos571(X,Y) get_csv2_ip((X),(Y),571) +#define get_csv2_ipv6_pos571(X,Y) get_csv2_ipv6((X),(Y),571) +#define get_csv2_string_pos571(X,Y) get_csv2_string((X),(Y),571) +#define get_csv2_v_str_pos571(X,Y) get_csv2_string((X),(Y),571) +#define get_csv2_bool_pos571(X,Y) get_csv2_bool((X),(Y),571) +#define get_csv2_int_pos571(X,Y) get_csv2_int((X),(Y),571) +#define get_csv2_llong_pos571(X,Y) get_csv2_llong((X),(Y),571) +#define get_csv2_float_pos571(X,Y) get_csv2_float((X),(Y),571) +#define get_csv2_uint_pos572(X,Y) get_csv2_uint((X),(Y),572) +#define get_csv2_ullong_pos572(X,Y) get_csv2_ullong((X),(Y),572) +#define get_csv2_ip_pos572(X,Y) get_csv2_ip((X),(Y),572) +#define get_csv2_ipv6_pos572(X,Y) get_csv2_ipv6((X),(Y),572) +#define get_csv2_string_pos572(X,Y) get_csv2_string((X),(Y),572) +#define get_csv2_v_str_pos572(X,Y) get_csv2_string((X),(Y),572) +#define get_csv2_bool_pos572(X,Y) get_csv2_bool((X),(Y),572) +#define get_csv2_int_pos572(X,Y) get_csv2_int((X),(Y),572) +#define get_csv2_llong_pos572(X,Y) get_csv2_llong((X),(Y),572) +#define get_csv2_float_pos572(X,Y) get_csv2_float((X),(Y),572) +#define get_csv2_uint_pos573(X,Y) get_csv2_uint((X),(Y),573) +#define get_csv2_ullong_pos573(X,Y) get_csv2_ullong((X),(Y),573) +#define get_csv2_ip_pos573(X,Y) get_csv2_ip((X),(Y),573) +#define get_csv2_ipv6_pos573(X,Y) get_csv2_ipv6((X),(Y),573) +#define get_csv2_string_pos573(X,Y) get_csv2_string((X),(Y),573) +#define get_csv2_v_str_pos573(X,Y) get_csv2_string((X),(Y),573) +#define get_csv2_bool_pos573(X,Y) get_csv2_bool((X),(Y),573) +#define get_csv2_int_pos573(X,Y) get_csv2_int((X),(Y),573) +#define get_csv2_llong_pos573(X,Y) get_csv2_llong((X),(Y),573) +#define get_csv2_float_pos573(X,Y) get_csv2_float((X),(Y),573) +#define get_csv2_uint_pos574(X,Y) get_csv2_uint((X),(Y),574) +#define get_csv2_ullong_pos574(X,Y) get_csv2_ullong((X),(Y),574) +#define get_csv2_ip_pos574(X,Y) get_csv2_ip((X),(Y),574) +#define get_csv2_ipv6_pos574(X,Y) get_csv2_ipv6((X),(Y),574) +#define get_csv2_string_pos574(X,Y) get_csv2_string((X),(Y),574) +#define get_csv2_v_str_pos574(X,Y) get_csv2_string((X),(Y),574) +#define get_csv2_bool_pos574(X,Y) get_csv2_bool((X),(Y),574) +#define get_csv2_int_pos574(X,Y) get_csv2_int((X),(Y),574) +#define get_csv2_llong_pos574(X,Y) get_csv2_llong((X),(Y),574) +#define get_csv2_float_pos574(X,Y) get_csv2_float((X),(Y),574) +#define get_csv2_uint_pos575(X,Y) get_csv2_uint((X),(Y),575) +#define get_csv2_ullong_pos575(X,Y) get_csv2_ullong((X),(Y),575) +#define get_csv2_ip_pos575(X,Y) get_csv2_ip((X),(Y),575) +#define get_csv2_ipv6_pos575(X,Y) get_csv2_ipv6((X),(Y),575) +#define get_csv2_string_pos575(X,Y) get_csv2_string((X),(Y),575) +#define get_csv2_v_str_pos575(X,Y) get_csv2_string((X),(Y),575) +#define get_csv2_bool_pos575(X,Y) get_csv2_bool((X),(Y),575) +#define get_csv2_int_pos575(X,Y) get_csv2_int((X),(Y),575) +#define get_csv2_llong_pos575(X,Y) get_csv2_llong((X),(Y),575) +#define get_csv2_float_pos575(X,Y) get_csv2_float((X),(Y),575) +#define get_csv2_uint_pos576(X,Y) get_csv2_uint((X),(Y),576) +#define get_csv2_ullong_pos576(X,Y) get_csv2_ullong((X),(Y),576) +#define get_csv2_ip_pos576(X,Y) get_csv2_ip((X),(Y),576) +#define get_csv2_ipv6_pos576(X,Y) get_csv2_ipv6((X),(Y),576) +#define get_csv2_string_pos576(X,Y) get_csv2_string((X),(Y),576) +#define get_csv2_v_str_pos576(X,Y) get_csv2_string((X),(Y),576) +#define get_csv2_bool_pos576(X,Y) get_csv2_bool((X),(Y),576) +#define get_csv2_int_pos576(X,Y) get_csv2_int((X),(Y),576) +#define get_csv2_llong_pos576(X,Y) get_csv2_llong((X),(Y),576) +#define get_csv2_float_pos576(X,Y) get_csv2_float((X),(Y),576) +#define get_csv2_uint_pos577(X,Y) get_csv2_uint((X),(Y),577) +#define get_csv2_ullong_pos577(X,Y) get_csv2_ullong((X),(Y),577) +#define get_csv2_ip_pos577(X,Y) get_csv2_ip((X),(Y),577) +#define get_csv2_ipv6_pos577(X,Y) get_csv2_ipv6((X),(Y),577) +#define get_csv2_string_pos577(X,Y) get_csv2_string((X),(Y),577) +#define get_csv2_v_str_pos577(X,Y) get_csv2_string((X),(Y),577) +#define get_csv2_bool_pos577(X,Y) get_csv2_bool((X),(Y),577) +#define get_csv2_int_pos577(X,Y) get_csv2_int((X),(Y),577) +#define get_csv2_llong_pos577(X,Y) get_csv2_llong((X),(Y),577) +#define get_csv2_float_pos577(X,Y) get_csv2_float((X),(Y),577) +#define get_csv2_uint_pos578(X,Y) get_csv2_uint((X),(Y),578) +#define get_csv2_ullong_pos578(X,Y) get_csv2_ullong((X),(Y),578) +#define get_csv2_ip_pos578(X,Y) get_csv2_ip((X),(Y),578) +#define get_csv2_ipv6_pos578(X,Y) get_csv2_ipv6((X),(Y),578) +#define get_csv2_string_pos578(X,Y) get_csv2_string((X),(Y),578) +#define get_csv2_v_str_pos578(X,Y) get_csv2_string((X),(Y),578) +#define get_csv2_bool_pos578(X,Y) get_csv2_bool((X),(Y),578) +#define get_csv2_int_pos578(X,Y) get_csv2_int((X),(Y),578) +#define get_csv2_llong_pos578(X,Y) get_csv2_llong((X),(Y),578) +#define get_csv2_float_pos578(X,Y) get_csv2_float((X),(Y),578) +#define get_csv2_uint_pos579(X,Y) get_csv2_uint((X),(Y),579) +#define get_csv2_ullong_pos579(X,Y) get_csv2_ullong((X),(Y),579) +#define get_csv2_ip_pos579(X,Y) get_csv2_ip((X),(Y),579) +#define get_csv2_ipv6_pos579(X,Y) get_csv2_ipv6((X),(Y),579) +#define get_csv2_string_pos579(X,Y) get_csv2_string((X),(Y),579) +#define get_csv2_v_str_pos579(X,Y) get_csv2_string((X),(Y),579) +#define get_csv2_bool_pos579(X,Y) get_csv2_bool((X),(Y),579) +#define get_csv2_int_pos579(X,Y) get_csv2_int((X),(Y),579) +#define get_csv2_llong_pos579(X,Y) get_csv2_llong((X),(Y),579) +#define get_csv2_float_pos579(X,Y) get_csv2_float((X),(Y),579) +#define get_csv2_uint_pos580(X,Y) get_csv2_uint((X),(Y),580) +#define get_csv2_ullong_pos580(X,Y) get_csv2_ullong((X),(Y),580) +#define get_csv2_ip_pos580(X,Y) get_csv2_ip((X),(Y),580) +#define get_csv2_ipv6_pos580(X,Y) get_csv2_ipv6((X),(Y),580) +#define get_csv2_string_pos580(X,Y) get_csv2_string((X),(Y),580) +#define get_csv2_v_str_pos580(X,Y) get_csv2_string((X),(Y),580) +#define get_csv2_bool_pos580(X,Y) get_csv2_bool((X),(Y),580) +#define get_csv2_int_pos580(X,Y) get_csv2_int((X),(Y),580) +#define get_csv2_llong_pos580(X,Y) get_csv2_llong((X),(Y),580) +#define get_csv2_float_pos580(X,Y) get_csv2_float((X),(Y),580) +#define get_csv2_uint_pos581(X,Y) get_csv2_uint((X),(Y),581) +#define get_csv2_ullong_pos581(X,Y) get_csv2_ullong((X),(Y),581) +#define get_csv2_ip_pos581(X,Y) get_csv2_ip((X),(Y),581) +#define get_csv2_ipv6_pos581(X,Y) get_csv2_ipv6((X),(Y),581) +#define get_csv2_string_pos581(X,Y) get_csv2_string((X),(Y),581) +#define get_csv2_v_str_pos581(X,Y) get_csv2_string((X),(Y),581) +#define get_csv2_bool_pos581(X,Y) get_csv2_bool((X),(Y),581) +#define get_csv2_int_pos581(X,Y) get_csv2_int((X),(Y),581) +#define get_csv2_llong_pos581(X,Y) get_csv2_llong((X),(Y),581) +#define get_csv2_float_pos581(X,Y) get_csv2_float((X),(Y),581) +#define get_csv2_uint_pos582(X,Y) get_csv2_uint((X),(Y),582) +#define get_csv2_ullong_pos582(X,Y) get_csv2_ullong((X),(Y),582) +#define get_csv2_ip_pos582(X,Y) get_csv2_ip((X),(Y),582) +#define get_csv2_ipv6_pos582(X,Y) get_csv2_ipv6((X),(Y),582) +#define get_csv2_string_pos582(X,Y) get_csv2_string((X),(Y),582) +#define get_csv2_v_str_pos582(X,Y) get_csv2_string((X),(Y),582) +#define get_csv2_bool_pos582(X,Y) get_csv2_bool((X),(Y),582) +#define get_csv2_int_pos582(X,Y) get_csv2_int((X),(Y),582) +#define get_csv2_llong_pos582(X,Y) get_csv2_llong((X),(Y),582) +#define get_csv2_float_pos582(X,Y) get_csv2_float((X),(Y),582) +#define get_csv2_uint_pos583(X,Y) get_csv2_uint((X),(Y),583) +#define get_csv2_ullong_pos583(X,Y) get_csv2_ullong((X),(Y),583) +#define get_csv2_ip_pos583(X,Y) get_csv2_ip((X),(Y),583) +#define get_csv2_ipv6_pos583(X,Y) get_csv2_ipv6((X),(Y),583) +#define get_csv2_string_pos583(X,Y) get_csv2_string((X),(Y),583) +#define get_csv2_v_str_pos583(X,Y) get_csv2_string((X),(Y),583) +#define get_csv2_bool_pos583(X,Y) get_csv2_bool((X),(Y),583) +#define get_csv2_int_pos583(X,Y) get_csv2_int((X),(Y),583) +#define get_csv2_llong_pos583(X,Y) get_csv2_llong((X),(Y),583) +#define get_csv2_float_pos583(X,Y) get_csv2_float((X),(Y),583) +#define get_csv2_uint_pos584(X,Y) get_csv2_uint((X),(Y),584) +#define get_csv2_ullong_pos584(X,Y) get_csv2_ullong((X),(Y),584) +#define get_csv2_ip_pos584(X,Y) get_csv2_ip((X),(Y),584) +#define get_csv2_ipv6_pos584(X,Y) get_csv2_ipv6((X),(Y),584) +#define get_csv2_string_pos584(X,Y) get_csv2_string((X),(Y),584) +#define get_csv2_v_str_pos584(X,Y) get_csv2_string((X),(Y),584) +#define get_csv2_bool_pos584(X,Y) get_csv2_bool((X),(Y),584) +#define get_csv2_int_pos584(X,Y) get_csv2_int((X),(Y),584) +#define get_csv2_llong_pos584(X,Y) get_csv2_llong((X),(Y),584) +#define get_csv2_float_pos584(X,Y) get_csv2_float((X),(Y),584) +#define get_csv2_uint_pos585(X,Y) get_csv2_uint((X),(Y),585) +#define get_csv2_ullong_pos585(X,Y) get_csv2_ullong((X),(Y),585) +#define get_csv2_ip_pos585(X,Y) get_csv2_ip((X),(Y),585) +#define get_csv2_ipv6_pos585(X,Y) get_csv2_ipv6((X),(Y),585) +#define get_csv2_string_pos585(X,Y) get_csv2_string((X),(Y),585) +#define get_csv2_v_str_pos585(X,Y) get_csv2_string((X),(Y),585) +#define get_csv2_bool_pos585(X,Y) get_csv2_bool((X),(Y),585) +#define get_csv2_int_pos585(X,Y) get_csv2_int((X),(Y),585) +#define get_csv2_llong_pos585(X,Y) get_csv2_llong((X),(Y),585) +#define get_csv2_float_pos585(X,Y) get_csv2_float((X),(Y),585) +#define get_csv2_uint_pos586(X,Y) get_csv2_uint((X),(Y),586) +#define get_csv2_ullong_pos586(X,Y) get_csv2_ullong((X),(Y),586) +#define get_csv2_ip_pos586(X,Y) get_csv2_ip((X),(Y),586) +#define get_csv2_ipv6_pos586(X,Y) get_csv2_ipv6((X),(Y),586) +#define get_csv2_string_pos586(X,Y) get_csv2_string((X),(Y),586) +#define get_csv2_v_str_pos586(X,Y) get_csv2_string((X),(Y),586) +#define get_csv2_bool_pos586(X,Y) get_csv2_bool((X),(Y),586) +#define get_csv2_int_pos586(X,Y) get_csv2_int((X),(Y),586) +#define get_csv2_llong_pos586(X,Y) get_csv2_llong((X),(Y),586) +#define get_csv2_float_pos586(X,Y) get_csv2_float((X),(Y),586) +#define get_csv2_uint_pos587(X,Y) get_csv2_uint((X),(Y),587) +#define get_csv2_ullong_pos587(X,Y) get_csv2_ullong((X),(Y),587) +#define get_csv2_ip_pos587(X,Y) get_csv2_ip((X),(Y),587) +#define get_csv2_ipv6_pos587(X,Y) get_csv2_ipv6((X),(Y),587) +#define get_csv2_string_pos587(X,Y) get_csv2_string((X),(Y),587) +#define get_csv2_v_str_pos587(X,Y) get_csv2_string((X),(Y),587) +#define get_csv2_bool_pos587(X,Y) get_csv2_bool((X),(Y),587) +#define get_csv2_int_pos587(X,Y) get_csv2_int((X),(Y),587) +#define get_csv2_llong_pos587(X,Y) get_csv2_llong((X),(Y),587) +#define get_csv2_float_pos587(X,Y) get_csv2_float((X),(Y),587) +#define get_csv2_uint_pos588(X,Y) get_csv2_uint((X),(Y),588) +#define get_csv2_ullong_pos588(X,Y) get_csv2_ullong((X),(Y),588) +#define get_csv2_ip_pos588(X,Y) get_csv2_ip((X),(Y),588) +#define get_csv2_ipv6_pos588(X,Y) get_csv2_ipv6((X),(Y),588) +#define get_csv2_string_pos588(X,Y) get_csv2_string((X),(Y),588) +#define get_csv2_v_str_pos588(X,Y) get_csv2_string((X),(Y),588) +#define get_csv2_bool_pos588(X,Y) get_csv2_bool((X),(Y),588) +#define get_csv2_int_pos588(X,Y) get_csv2_int((X),(Y),588) +#define get_csv2_llong_pos588(X,Y) get_csv2_llong((X),(Y),588) +#define get_csv2_float_pos588(X,Y) get_csv2_float((X),(Y),588) +#define get_csv2_uint_pos589(X,Y) get_csv2_uint((X),(Y),589) +#define get_csv2_ullong_pos589(X,Y) get_csv2_ullong((X),(Y),589) +#define get_csv2_ip_pos589(X,Y) get_csv2_ip((X),(Y),589) +#define get_csv2_ipv6_pos589(X,Y) get_csv2_ipv6((X),(Y),589) +#define get_csv2_string_pos589(X,Y) get_csv2_string((X),(Y),589) +#define get_csv2_v_str_pos589(X,Y) get_csv2_string((X),(Y),589) +#define get_csv2_bool_pos589(X,Y) get_csv2_bool((X),(Y),589) +#define get_csv2_int_pos589(X,Y) get_csv2_int((X),(Y),589) +#define get_csv2_llong_pos589(X,Y) get_csv2_llong((X),(Y),589) +#define get_csv2_float_pos589(X,Y) get_csv2_float((X),(Y),589) +#define get_csv2_uint_pos590(X,Y) get_csv2_uint((X),(Y),590) +#define get_csv2_ullong_pos590(X,Y) get_csv2_ullong((X),(Y),590) +#define get_csv2_ip_pos590(X,Y) get_csv2_ip((X),(Y),590) +#define get_csv2_ipv6_pos590(X,Y) get_csv2_ipv6((X),(Y),590) +#define get_csv2_string_pos590(X,Y) get_csv2_string((X),(Y),590) +#define get_csv2_v_str_pos590(X,Y) get_csv2_string((X),(Y),590) +#define get_csv2_bool_pos590(X,Y) get_csv2_bool((X),(Y),590) +#define get_csv2_int_pos590(X,Y) get_csv2_int((X),(Y),590) +#define get_csv2_llong_pos590(X,Y) get_csv2_llong((X),(Y),590) +#define get_csv2_float_pos590(X,Y) get_csv2_float((X),(Y),590) +#define get_csv2_uint_pos591(X,Y) get_csv2_uint((X),(Y),591) +#define get_csv2_ullong_pos591(X,Y) get_csv2_ullong((X),(Y),591) +#define get_csv2_ip_pos591(X,Y) get_csv2_ip((X),(Y),591) +#define get_csv2_ipv6_pos591(X,Y) get_csv2_ipv6((X),(Y),591) +#define get_csv2_string_pos591(X,Y) get_csv2_string((X),(Y),591) +#define get_csv2_v_str_pos591(X,Y) get_csv2_string((X),(Y),591) +#define get_csv2_bool_pos591(X,Y) get_csv2_bool((X),(Y),591) +#define get_csv2_int_pos591(X,Y) get_csv2_int((X),(Y),591) +#define get_csv2_llong_pos591(X,Y) get_csv2_llong((X),(Y),591) +#define get_csv2_float_pos591(X,Y) get_csv2_float((X),(Y),591) +#define get_csv2_uint_pos592(X,Y) get_csv2_uint((X),(Y),592) +#define get_csv2_ullong_pos592(X,Y) get_csv2_ullong((X),(Y),592) +#define get_csv2_ip_pos592(X,Y) get_csv2_ip((X),(Y),592) +#define get_csv2_ipv6_pos592(X,Y) get_csv2_ipv6((X),(Y),592) +#define get_csv2_string_pos592(X,Y) get_csv2_string((X),(Y),592) +#define get_csv2_v_str_pos592(X,Y) get_csv2_string((X),(Y),592) +#define get_csv2_bool_pos592(X,Y) get_csv2_bool((X),(Y),592) +#define get_csv2_int_pos592(X,Y) get_csv2_int((X),(Y),592) +#define get_csv2_llong_pos592(X,Y) get_csv2_llong((X),(Y),592) +#define get_csv2_float_pos592(X,Y) get_csv2_float((X),(Y),592) +#define get_csv2_uint_pos593(X,Y) get_csv2_uint((X),(Y),593) +#define get_csv2_ullong_pos593(X,Y) get_csv2_ullong((X),(Y),593) +#define get_csv2_ip_pos593(X,Y) get_csv2_ip((X),(Y),593) +#define get_csv2_ipv6_pos593(X,Y) get_csv2_ipv6((X),(Y),593) +#define get_csv2_string_pos593(X,Y) get_csv2_string((X),(Y),593) +#define get_csv2_v_str_pos593(X,Y) get_csv2_string((X),(Y),593) +#define get_csv2_bool_pos593(X,Y) get_csv2_bool((X),(Y),593) +#define get_csv2_int_pos593(X,Y) get_csv2_int((X),(Y),593) +#define get_csv2_llong_pos593(X,Y) get_csv2_llong((X),(Y),593) +#define get_csv2_float_pos593(X,Y) get_csv2_float((X),(Y),593) +#define get_csv2_uint_pos594(X,Y) get_csv2_uint((X),(Y),594) +#define get_csv2_ullong_pos594(X,Y) get_csv2_ullong((X),(Y),594) +#define get_csv2_ip_pos594(X,Y) get_csv2_ip((X),(Y),594) +#define get_csv2_ipv6_pos594(X,Y) get_csv2_ipv6((X),(Y),594) +#define get_csv2_string_pos594(X,Y) get_csv2_string((X),(Y),594) +#define get_csv2_v_str_pos594(X,Y) get_csv2_string((X),(Y),594) +#define get_csv2_bool_pos594(X,Y) get_csv2_bool((X),(Y),594) +#define get_csv2_int_pos594(X,Y) get_csv2_int((X),(Y),594) +#define get_csv2_llong_pos594(X,Y) get_csv2_llong((X),(Y),594) +#define get_csv2_float_pos594(X,Y) get_csv2_float((X),(Y),594) +#define get_csv2_uint_pos595(X,Y) get_csv2_uint((X),(Y),595) +#define get_csv2_ullong_pos595(X,Y) get_csv2_ullong((X),(Y),595) +#define get_csv2_ip_pos595(X,Y) get_csv2_ip((X),(Y),595) +#define get_csv2_ipv6_pos595(X,Y) get_csv2_ipv6((X),(Y),595) +#define get_csv2_string_pos595(X,Y) get_csv2_string((X),(Y),595) +#define get_csv2_v_str_pos595(X,Y) get_csv2_string((X),(Y),595) +#define get_csv2_bool_pos595(X,Y) get_csv2_bool((X),(Y),595) +#define get_csv2_int_pos595(X,Y) get_csv2_int((X),(Y),595) +#define get_csv2_llong_pos595(X,Y) get_csv2_llong((X),(Y),595) +#define get_csv2_float_pos595(X,Y) get_csv2_float((X),(Y),595) +#define get_csv2_uint_pos596(X,Y) get_csv2_uint((X),(Y),596) +#define get_csv2_ullong_pos596(X,Y) get_csv2_ullong((X),(Y),596) +#define get_csv2_ip_pos596(X,Y) get_csv2_ip((X),(Y),596) +#define get_csv2_ipv6_pos596(X,Y) get_csv2_ipv6((X),(Y),596) +#define get_csv2_string_pos596(X,Y) get_csv2_string((X),(Y),596) +#define get_csv2_v_str_pos596(X,Y) get_csv2_string((X),(Y),596) +#define get_csv2_bool_pos596(X,Y) get_csv2_bool((X),(Y),596) +#define get_csv2_int_pos596(X,Y) get_csv2_int((X),(Y),596) +#define get_csv2_llong_pos596(X,Y) get_csv2_llong((X),(Y),596) +#define get_csv2_float_pos596(X,Y) get_csv2_float((X),(Y),596) +#define get_csv2_uint_pos597(X,Y) get_csv2_uint((X),(Y),597) +#define get_csv2_ullong_pos597(X,Y) get_csv2_ullong((X),(Y),597) +#define get_csv2_ip_pos597(X,Y) get_csv2_ip((X),(Y),597) +#define get_csv2_ipv6_pos597(X,Y) get_csv2_ipv6((X),(Y),597) +#define get_csv2_string_pos597(X,Y) get_csv2_string((X),(Y),597) +#define get_csv2_v_str_pos597(X,Y) get_csv2_string((X),(Y),597) +#define get_csv2_bool_pos597(X,Y) get_csv2_bool((X),(Y),597) +#define get_csv2_int_pos597(X,Y) get_csv2_int((X),(Y),597) +#define get_csv2_llong_pos597(X,Y) get_csv2_llong((X),(Y),597) +#define get_csv2_float_pos597(X,Y) get_csv2_float((X),(Y),597) +#define get_csv2_uint_pos598(X,Y) get_csv2_uint((X),(Y),598) +#define get_csv2_ullong_pos598(X,Y) get_csv2_ullong((X),(Y),598) +#define get_csv2_ip_pos598(X,Y) get_csv2_ip((X),(Y),598) +#define get_csv2_ipv6_pos598(X,Y) get_csv2_ipv6((X),(Y),598) +#define get_csv2_string_pos598(X,Y) get_csv2_string((X),(Y),598) +#define get_csv2_v_str_pos598(X,Y) get_csv2_string((X),(Y),598) +#define get_csv2_bool_pos598(X,Y) get_csv2_bool((X),(Y),598) +#define get_csv2_int_pos598(X,Y) get_csv2_int((X),(Y),598) +#define get_csv2_llong_pos598(X,Y) get_csv2_llong((X),(Y),598) +#define get_csv2_float_pos598(X,Y) get_csv2_float((X),(Y),598) +#define get_csv2_uint_pos599(X,Y) get_csv2_uint((X),(Y),599) +#define get_csv2_ullong_pos599(X,Y) get_csv2_ullong((X),(Y),599) +#define get_csv2_ip_pos599(X,Y) get_csv2_ip((X),(Y),599) +#define get_csv2_ipv6_pos599(X,Y) get_csv2_ipv6((X),(Y),599) +#define get_csv2_string_pos599(X,Y) get_csv2_string((X),(Y),599) +#define get_csv2_v_str_pos599(X,Y) get_csv2_string((X),(Y),599) +#define get_csv2_bool_pos599(X,Y) get_csv2_bool((X),(Y),599) +#define get_csv2_int_pos599(X,Y) get_csv2_int((X),(Y),599) +#define get_csv2_llong_pos599(X,Y) get_csv2_llong((X),(Y),599) +#define get_csv2_float_pos599(X,Y) get_csv2_float((X),(Y),599) +#define get_csv2_uint_pos600(X,Y) get_csv2_uint((X),(Y),600) +#define get_csv2_ullong_pos600(X,Y) get_csv2_ullong((X),(Y),600) +#define get_csv2_ip_pos600(X,Y) get_csv2_ip((X),(Y),600) +#define get_csv2_ipv6_pos600(X,Y) get_csv2_ipv6((X),(Y),600) +#define get_csv2_string_pos600(X,Y) get_csv2_string((X),(Y),600) +#define get_csv2_v_str_pos600(X,Y) get_csv2_string((X),(Y),600) +#define get_csv2_bool_pos600(X,Y) get_csv2_bool((X),(Y),600) +#define get_csv2_int_pos600(X,Y) get_csv2_int((X),(Y),600) +#define get_csv2_llong_pos600(X,Y) get_csv2_llong((X),(Y),600) +#define get_csv2_float_pos600(X,Y) get_csv2_float((X),(Y),600) +#define get_csv2_uint_pos601(X,Y) get_csv2_uint((X),(Y),601) +#define get_csv2_ullong_pos601(X,Y) get_csv2_ullong((X),(Y),601) +#define get_csv2_ip_pos601(X,Y) get_csv2_ip((X),(Y),601) +#define get_csv2_ipv6_pos601(X,Y) get_csv2_ipv6((X),(Y),601) +#define get_csv2_string_pos601(X,Y) get_csv2_string((X),(Y),601) +#define get_csv2_v_str_pos601(X,Y) get_csv2_string((X),(Y),601) +#define get_csv2_bool_pos601(X,Y) get_csv2_bool((X),(Y),601) +#define get_csv2_int_pos601(X,Y) get_csv2_int((X),(Y),601) +#define get_csv2_llong_pos601(X,Y) get_csv2_llong((X),(Y),601) +#define get_csv2_float_pos601(X,Y) get_csv2_float((X),(Y),601) +#define get_csv2_uint_pos602(X,Y) get_csv2_uint((X),(Y),602) +#define get_csv2_ullong_pos602(X,Y) get_csv2_ullong((X),(Y),602) +#define get_csv2_ip_pos602(X,Y) get_csv2_ip((X),(Y),602) +#define get_csv2_ipv6_pos602(X,Y) get_csv2_ipv6((X),(Y),602) +#define get_csv2_string_pos602(X,Y) get_csv2_string((X),(Y),602) +#define get_csv2_v_str_pos602(X,Y) get_csv2_string((X),(Y),602) +#define get_csv2_bool_pos602(X,Y) get_csv2_bool((X),(Y),602) +#define get_csv2_int_pos602(X,Y) get_csv2_int((X),(Y),602) +#define get_csv2_llong_pos602(X,Y) get_csv2_llong((X),(Y),602) +#define get_csv2_float_pos602(X,Y) get_csv2_float((X),(Y),602) +#define get_csv2_uint_pos603(X,Y) get_csv2_uint((X),(Y),603) +#define get_csv2_ullong_pos603(X,Y) get_csv2_ullong((X),(Y),603) +#define get_csv2_ip_pos603(X,Y) get_csv2_ip((X),(Y),603) +#define get_csv2_ipv6_pos603(X,Y) get_csv2_ipv6((X),(Y),603) +#define get_csv2_string_pos603(X,Y) get_csv2_string((X),(Y),603) +#define get_csv2_v_str_pos603(X,Y) get_csv2_string((X),(Y),603) +#define get_csv2_bool_pos603(X,Y) get_csv2_bool((X),(Y),603) +#define get_csv2_int_pos603(X,Y) get_csv2_int((X),(Y),603) +#define get_csv2_llong_pos603(X,Y) get_csv2_llong((X),(Y),603) +#define get_csv2_float_pos603(X,Y) get_csv2_float((X),(Y),603) +#define get_csv2_uint_pos604(X,Y) get_csv2_uint((X),(Y),604) +#define get_csv2_ullong_pos604(X,Y) get_csv2_ullong((X),(Y),604) +#define get_csv2_ip_pos604(X,Y) get_csv2_ip((X),(Y),604) +#define get_csv2_ipv6_pos604(X,Y) get_csv2_ipv6((X),(Y),604) +#define get_csv2_string_pos604(X,Y) get_csv2_string((X),(Y),604) +#define get_csv2_v_str_pos604(X,Y) get_csv2_string((X),(Y),604) +#define get_csv2_bool_pos604(X,Y) get_csv2_bool((X),(Y),604) +#define get_csv2_int_pos604(X,Y) get_csv2_int((X),(Y),604) +#define get_csv2_llong_pos604(X,Y) get_csv2_llong((X),(Y),604) +#define get_csv2_float_pos604(X,Y) get_csv2_float((X),(Y),604) +#define get_csv2_uint_pos605(X,Y) get_csv2_uint((X),(Y),605) +#define get_csv2_ullong_pos605(X,Y) get_csv2_ullong((X),(Y),605) +#define get_csv2_ip_pos605(X,Y) get_csv2_ip((X),(Y),605) +#define get_csv2_ipv6_pos605(X,Y) get_csv2_ipv6((X),(Y),605) +#define get_csv2_string_pos605(X,Y) get_csv2_string((X),(Y),605) +#define get_csv2_v_str_pos605(X,Y) get_csv2_string((X),(Y),605) +#define get_csv2_bool_pos605(X,Y) get_csv2_bool((X),(Y),605) +#define get_csv2_int_pos605(X,Y) get_csv2_int((X),(Y),605) +#define get_csv2_llong_pos605(X,Y) get_csv2_llong((X),(Y),605) +#define get_csv2_float_pos605(X,Y) get_csv2_float((X),(Y),605) +#define get_csv2_uint_pos606(X,Y) get_csv2_uint((X),(Y),606) +#define get_csv2_ullong_pos606(X,Y) get_csv2_ullong((X),(Y),606) +#define get_csv2_ip_pos606(X,Y) get_csv2_ip((X),(Y),606) +#define get_csv2_ipv6_pos606(X,Y) get_csv2_ipv6((X),(Y),606) +#define get_csv2_string_pos606(X,Y) get_csv2_string((X),(Y),606) +#define get_csv2_v_str_pos606(X,Y) get_csv2_string((X),(Y),606) +#define get_csv2_bool_pos606(X,Y) get_csv2_bool((X),(Y),606) +#define get_csv2_int_pos606(X,Y) get_csv2_int((X),(Y),606) +#define get_csv2_llong_pos606(X,Y) get_csv2_llong((X),(Y),606) +#define get_csv2_float_pos606(X,Y) get_csv2_float((X),(Y),606) +#define get_csv2_uint_pos607(X,Y) get_csv2_uint((X),(Y),607) +#define get_csv2_ullong_pos607(X,Y) get_csv2_ullong((X),(Y),607) +#define get_csv2_ip_pos607(X,Y) get_csv2_ip((X),(Y),607) +#define get_csv2_ipv6_pos607(X,Y) get_csv2_ipv6((X),(Y),607) +#define get_csv2_string_pos607(X,Y) get_csv2_string((X),(Y),607) +#define get_csv2_v_str_pos607(X,Y) get_csv2_string((X),(Y),607) +#define get_csv2_bool_pos607(X,Y) get_csv2_bool((X),(Y),607) +#define get_csv2_int_pos607(X,Y) get_csv2_int((X),(Y),607) +#define get_csv2_llong_pos607(X,Y) get_csv2_llong((X),(Y),607) +#define get_csv2_float_pos607(X,Y) get_csv2_float((X),(Y),607) +#define get_csv2_uint_pos608(X,Y) get_csv2_uint((X),(Y),608) +#define get_csv2_ullong_pos608(X,Y) get_csv2_ullong((X),(Y),608) +#define get_csv2_ip_pos608(X,Y) get_csv2_ip((X),(Y),608) +#define get_csv2_ipv6_pos608(X,Y) get_csv2_ipv6((X),(Y),608) +#define get_csv2_string_pos608(X,Y) get_csv2_string((X),(Y),608) +#define get_csv2_v_str_pos608(X,Y) get_csv2_string((X),(Y),608) +#define get_csv2_bool_pos608(X,Y) get_csv2_bool((X),(Y),608) +#define get_csv2_int_pos608(X,Y) get_csv2_int((X),(Y),608) +#define get_csv2_llong_pos608(X,Y) get_csv2_llong((X),(Y),608) +#define get_csv2_float_pos608(X,Y) get_csv2_float((X),(Y),608) +#define get_csv2_uint_pos609(X,Y) get_csv2_uint((X),(Y),609) +#define get_csv2_ullong_pos609(X,Y) get_csv2_ullong((X),(Y),609) +#define get_csv2_ip_pos609(X,Y) get_csv2_ip((X),(Y),609) +#define get_csv2_ipv6_pos609(X,Y) get_csv2_ipv6((X),(Y),609) +#define get_csv2_string_pos609(X,Y) get_csv2_string((X),(Y),609) +#define get_csv2_v_str_pos609(X,Y) get_csv2_string((X),(Y),609) +#define get_csv2_bool_pos609(X,Y) get_csv2_bool((X),(Y),609) +#define get_csv2_int_pos609(X,Y) get_csv2_int((X),(Y),609) +#define get_csv2_llong_pos609(X,Y) get_csv2_llong((X),(Y),609) +#define get_csv2_float_pos609(X,Y) get_csv2_float((X),(Y),609) +#define get_csv2_uint_pos610(X,Y) get_csv2_uint((X),(Y),610) +#define get_csv2_ullong_pos610(X,Y) get_csv2_ullong((X),(Y),610) +#define get_csv2_ip_pos610(X,Y) get_csv2_ip((X),(Y),610) +#define get_csv2_ipv6_pos610(X,Y) get_csv2_ipv6((X),(Y),610) +#define get_csv2_string_pos610(X,Y) get_csv2_string((X),(Y),610) +#define get_csv2_v_str_pos610(X,Y) get_csv2_string((X),(Y),610) +#define get_csv2_bool_pos610(X,Y) get_csv2_bool((X),(Y),610) +#define get_csv2_int_pos610(X,Y) get_csv2_int((X),(Y),610) +#define get_csv2_llong_pos610(X,Y) get_csv2_llong((X),(Y),610) +#define get_csv2_float_pos610(X,Y) get_csv2_float((X),(Y),610) +#define get_csv2_uint_pos611(X,Y) get_csv2_uint((X),(Y),611) +#define get_csv2_ullong_pos611(X,Y) get_csv2_ullong((X),(Y),611) +#define get_csv2_ip_pos611(X,Y) get_csv2_ip((X),(Y),611) +#define get_csv2_ipv6_pos611(X,Y) get_csv2_ipv6((X),(Y),611) +#define get_csv2_string_pos611(X,Y) get_csv2_string((X),(Y),611) +#define get_csv2_v_str_pos611(X,Y) get_csv2_string((X),(Y),611) +#define get_csv2_bool_pos611(X,Y) get_csv2_bool((X),(Y),611) +#define get_csv2_int_pos611(X,Y) get_csv2_int((X),(Y),611) +#define get_csv2_llong_pos611(X,Y) get_csv2_llong((X),(Y),611) +#define get_csv2_float_pos611(X,Y) get_csv2_float((X),(Y),611) +#define get_csv2_uint_pos612(X,Y) get_csv2_uint((X),(Y),612) +#define get_csv2_ullong_pos612(X,Y) get_csv2_ullong((X),(Y),612) +#define get_csv2_ip_pos612(X,Y) get_csv2_ip((X),(Y),612) +#define get_csv2_ipv6_pos612(X,Y) get_csv2_ipv6((X),(Y),612) +#define get_csv2_string_pos612(X,Y) get_csv2_string((X),(Y),612) +#define get_csv2_v_str_pos612(X,Y) get_csv2_string((X),(Y),612) +#define get_csv2_bool_pos612(X,Y) get_csv2_bool((X),(Y),612) +#define get_csv2_int_pos612(X,Y) get_csv2_int((X),(Y),612) +#define get_csv2_llong_pos612(X,Y) get_csv2_llong((X),(Y),612) +#define get_csv2_float_pos612(X,Y) get_csv2_float((X),(Y),612) +#define get_csv2_uint_pos613(X,Y) get_csv2_uint((X),(Y),613) +#define get_csv2_ullong_pos613(X,Y) get_csv2_ullong((X),(Y),613) +#define get_csv2_ip_pos613(X,Y) get_csv2_ip((X),(Y),613) +#define get_csv2_ipv6_pos613(X,Y) get_csv2_ipv6((X),(Y),613) +#define get_csv2_string_pos613(X,Y) get_csv2_string((X),(Y),613) +#define get_csv2_v_str_pos613(X,Y) get_csv2_string((X),(Y),613) +#define get_csv2_bool_pos613(X,Y) get_csv2_bool((X),(Y),613) +#define get_csv2_int_pos613(X,Y) get_csv2_int((X),(Y),613) +#define get_csv2_llong_pos613(X,Y) get_csv2_llong((X),(Y),613) +#define get_csv2_float_pos613(X,Y) get_csv2_float((X),(Y),613) +#define get_csv2_uint_pos614(X,Y) get_csv2_uint((X),(Y),614) +#define get_csv2_ullong_pos614(X,Y) get_csv2_ullong((X),(Y),614) +#define get_csv2_ip_pos614(X,Y) get_csv2_ip((X),(Y),614) +#define get_csv2_ipv6_pos614(X,Y) get_csv2_ipv6((X),(Y),614) +#define get_csv2_string_pos614(X,Y) get_csv2_string((X),(Y),614) +#define get_csv2_v_str_pos614(X,Y) get_csv2_string((X),(Y),614) +#define get_csv2_bool_pos614(X,Y) get_csv2_bool((X),(Y),614) +#define get_csv2_int_pos614(X,Y) get_csv2_int((X),(Y),614) +#define get_csv2_llong_pos614(X,Y) get_csv2_llong((X),(Y),614) +#define get_csv2_float_pos614(X,Y) get_csv2_float((X),(Y),614) +#define get_csv2_uint_pos615(X,Y) get_csv2_uint((X),(Y),615) +#define get_csv2_ullong_pos615(X,Y) get_csv2_ullong((X),(Y),615) +#define get_csv2_ip_pos615(X,Y) get_csv2_ip((X),(Y),615) +#define get_csv2_ipv6_pos615(X,Y) get_csv2_ipv6((X),(Y),615) +#define get_csv2_string_pos615(X,Y) get_csv2_string((X),(Y),615) +#define get_csv2_v_str_pos615(X,Y) get_csv2_string((X),(Y),615) +#define get_csv2_bool_pos615(X,Y) get_csv2_bool((X),(Y),615) +#define get_csv2_int_pos615(X,Y) get_csv2_int((X),(Y),615) +#define get_csv2_llong_pos615(X,Y) get_csv2_llong((X),(Y),615) +#define get_csv2_float_pos615(X,Y) get_csv2_float((X),(Y),615) +#define get_csv2_uint_pos616(X,Y) get_csv2_uint((X),(Y),616) +#define get_csv2_ullong_pos616(X,Y) get_csv2_ullong((X),(Y),616) +#define get_csv2_ip_pos616(X,Y) get_csv2_ip((X),(Y),616) +#define get_csv2_ipv6_pos616(X,Y) get_csv2_ipv6((X),(Y),616) +#define get_csv2_string_pos616(X,Y) get_csv2_string((X),(Y),616) +#define get_csv2_v_str_pos616(X,Y) get_csv2_string((X),(Y),616) +#define get_csv2_bool_pos616(X,Y) get_csv2_bool((X),(Y),616) +#define get_csv2_int_pos616(X,Y) get_csv2_int((X),(Y),616) +#define get_csv2_llong_pos616(X,Y) get_csv2_llong((X),(Y),616) +#define get_csv2_float_pos616(X,Y) get_csv2_float((X),(Y),616) +#define get_csv2_uint_pos617(X,Y) get_csv2_uint((X),(Y),617) +#define get_csv2_ullong_pos617(X,Y) get_csv2_ullong((X),(Y),617) +#define get_csv2_ip_pos617(X,Y) get_csv2_ip((X),(Y),617) +#define get_csv2_ipv6_pos617(X,Y) get_csv2_ipv6((X),(Y),617) +#define get_csv2_string_pos617(X,Y) get_csv2_string((X),(Y),617) +#define get_csv2_v_str_pos617(X,Y) get_csv2_string((X),(Y),617) +#define get_csv2_bool_pos617(X,Y) get_csv2_bool((X),(Y),617) +#define get_csv2_int_pos617(X,Y) get_csv2_int((X),(Y),617) +#define get_csv2_llong_pos617(X,Y) get_csv2_llong((X),(Y),617) +#define get_csv2_float_pos617(X,Y) get_csv2_float((X),(Y),617) +#define get_csv2_uint_pos618(X,Y) get_csv2_uint((X),(Y),618) +#define get_csv2_ullong_pos618(X,Y) get_csv2_ullong((X),(Y),618) +#define get_csv2_ip_pos618(X,Y) get_csv2_ip((X),(Y),618) +#define get_csv2_ipv6_pos618(X,Y) get_csv2_ipv6((X),(Y),618) +#define get_csv2_string_pos618(X,Y) get_csv2_string((X),(Y),618) +#define get_csv2_v_str_pos618(X,Y) get_csv2_string((X),(Y),618) +#define get_csv2_bool_pos618(X,Y) get_csv2_bool((X),(Y),618) +#define get_csv2_int_pos618(X,Y) get_csv2_int((X),(Y),618) +#define get_csv2_llong_pos618(X,Y) get_csv2_llong((X),(Y),618) +#define get_csv2_float_pos618(X,Y) get_csv2_float((X),(Y),618) +#define get_csv2_uint_pos619(X,Y) get_csv2_uint((X),(Y),619) +#define get_csv2_ullong_pos619(X,Y) get_csv2_ullong((X),(Y),619) +#define get_csv2_ip_pos619(X,Y) get_csv2_ip((X),(Y),619) +#define get_csv2_ipv6_pos619(X,Y) get_csv2_ipv6((X),(Y),619) +#define get_csv2_string_pos619(X,Y) get_csv2_string((X),(Y),619) +#define get_csv2_v_str_pos619(X,Y) get_csv2_string((X),(Y),619) +#define get_csv2_bool_pos619(X,Y) get_csv2_bool((X),(Y),619) +#define get_csv2_int_pos619(X,Y) get_csv2_int((X),(Y),619) +#define get_csv2_llong_pos619(X,Y) get_csv2_llong((X),(Y),619) +#define get_csv2_float_pos619(X,Y) get_csv2_float((X),(Y),619) +#define get_csv2_uint_pos620(X,Y) get_csv2_uint((X),(Y),620) +#define get_csv2_ullong_pos620(X,Y) get_csv2_ullong((X),(Y),620) +#define get_csv2_ip_pos620(X,Y) get_csv2_ip((X),(Y),620) +#define get_csv2_ipv6_pos620(X,Y) get_csv2_ipv6((X),(Y),620) +#define get_csv2_string_pos620(X,Y) get_csv2_string((X),(Y),620) +#define get_csv2_v_str_pos620(X,Y) get_csv2_string((X),(Y),620) +#define get_csv2_bool_pos620(X,Y) get_csv2_bool((X),(Y),620) +#define get_csv2_int_pos620(X,Y) get_csv2_int((X),(Y),620) +#define get_csv2_llong_pos620(X,Y) get_csv2_llong((X),(Y),620) +#define get_csv2_float_pos620(X,Y) get_csv2_float((X),(Y),620) +#define get_csv2_uint_pos621(X,Y) get_csv2_uint((X),(Y),621) +#define get_csv2_ullong_pos621(X,Y) get_csv2_ullong((X),(Y),621) +#define get_csv2_ip_pos621(X,Y) get_csv2_ip((X),(Y),621) +#define get_csv2_ipv6_pos621(X,Y) get_csv2_ipv6((X),(Y),621) +#define get_csv2_string_pos621(X,Y) get_csv2_string((X),(Y),621) +#define get_csv2_v_str_pos621(X,Y) get_csv2_string((X),(Y),621) +#define get_csv2_bool_pos621(X,Y) get_csv2_bool((X),(Y),621) +#define get_csv2_int_pos621(X,Y) get_csv2_int((X),(Y),621) +#define get_csv2_llong_pos621(X,Y) get_csv2_llong((X),(Y),621) +#define get_csv2_float_pos621(X,Y) get_csv2_float((X),(Y),621) +#define get_csv2_uint_pos622(X,Y) get_csv2_uint((X),(Y),622) +#define get_csv2_ullong_pos622(X,Y) get_csv2_ullong((X),(Y),622) +#define get_csv2_ip_pos622(X,Y) get_csv2_ip((X),(Y),622) +#define get_csv2_ipv6_pos622(X,Y) get_csv2_ipv6((X),(Y),622) +#define get_csv2_string_pos622(X,Y) get_csv2_string((X),(Y),622) +#define get_csv2_v_str_pos622(X,Y) get_csv2_string((X),(Y),622) +#define get_csv2_bool_pos622(X,Y) get_csv2_bool((X),(Y),622) +#define get_csv2_int_pos622(X,Y) get_csv2_int((X),(Y),622) +#define get_csv2_llong_pos622(X,Y) get_csv2_llong((X),(Y),622) +#define get_csv2_float_pos622(X,Y) get_csv2_float((X),(Y),622) +#define get_csv2_uint_pos623(X,Y) get_csv2_uint((X),(Y),623) +#define get_csv2_ullong_pos623(X,Y) get_csv2_ullong((X),(Y),623) +#define get_csv2_ip_pos623(X,Y) get_csv2_ip((X),(Y),623) +#define get_csv2_ipv6_pos623(X,Y) get_csv2_ipv6((X),(Y),623) +#define get_csv2_string_pos623(X,Y) get_csv2_string((X),(Y),623) +#define get_csv2_v_str_pos623(X,Y) get_csv2_string((X),(Y),623) +#define get_csv2_bool_pos623(X,Y) get_csv2_bool((X),(Y),623) +#define get_csv2_int_pos623(X,Y) get_csv2_int((X),(Y),623) +#define get_csv2_llong_pos623(X,Y) get_csv2_llong((X),(Y),623) +#define get_csv2_float_pos623(X,Y) get_csv2_float((X),(Y),623) +#define get_csv2_uint_pos624(X,Y) get_csv2_uint((X),(Y),624) +#define get_csv2_ullong_pos624(X,Y) get_csv2_ullong((X),(Y),624) +#define get_csv2_ip_pos624(X,Y) get_csv2_ip((X),(Y),624) +#define get_csv2_ipv6_pos624(X,Y) get_csv2_ipv6((X),(Y),624) +#define get_csv2_string_pos624(X,Y) get_csv2_string((X),(Y),624) +#define get_csv2_v_str_pos624(X,Y) get_csv2_string((X),(Y),624) +#define get_csv2_bool_pos624(X,Y) get_csv2_bool((X),(Y),624) +#define get_csv2_int_pos624(X,Y) get_csv2_int((X),(Y),624) +#define get_csv2_llong_pos624(X,Y) get_csv2_llong((X),(Y),624) +#define get_csv2_float_pos624(X,Y) get_csv2_float((X),(Y),624) +#define get_csv2_uint_pos625(X,Y) get_csv2_uint((X),(Y),625) +#define get_csv2_ullong_pos625(X,Y) get_csv2_ullong((X),(Y),625) +#define get_csv2_ip_pos625(X,Y) get_csv2_ip((X),(Y),625) +#define get_csv2_ipv6_pos625(X,Y) get_csv2_ipv6((X),(Y),625) +#define get_csv2_string_pos625(X,Y) get_csv2_string((X),(Y),625) +#define get_csv2_v_str_pos625(X,Y) get_csv2_string((X),(Y),625) +#define get_csv2_bool_pos625(X,Y) get_csv2_bool((X),(Y),625) +#define get_csv2_int_pos625(X,Y) get_csv2_int((X),(Y),625) +#define get_csv2_llong_pos625(X,Y) get_csv2_llong((X),(Y),625) +#define get_csv2_float_pos625(X,Y) get_csv2_float((X),(Y),625) +#define get_csv2_uint_pos626(X,Y) get_csv2_uint((X),(Y),626) +#define get_csv2_ullong_pos626(X,Y) get_csv2_ullong((X),(Y),626) +#define get_csv2_ip_pos626(X,Y) get_csv2_ip((X),(Y),626) +#define get_csv2_ipv6_pos626(X,Y) get_csv2_ipv6((X),(Y),626) +#define get_csv2_string_pos626(X,Y) get_csv2_string((X),(Y),626) +#define get_csv2_v_str_pos626(X,Y) get_csv2_string((X),(Y),626) +#define get_csv2_bool_pos626(X,Y) get_csv2_bool((X),(Y),626) +#define get_csv2_int_pos626(X,Y) get_csv2_int((X),(Y),626) +#define get_csv2_llong_pos626(X,Y) get_csv2_llong((X),(Y),626) +#define get_csv2_float_pos626(X,Y) get_csv2_float((X),(Y),626) +#define get_csv2_uint_pos627(X,Y) get_csv2_uint((X),(Y),627) +#define get_csv2_ullong_pos627(X,Y) get_csv2_ullong((X),(Y),627) +#define get_csv2_ip_pos627(X,Y) get_csv2_ip((X),(Y),627) +#define get_csv2_ipv6_pos627(X,Y) get_csv2_ipv6((X),(Y),627) +#define get_csv2_string_pos627(X,Y) get_csv2_string((X),(Y),627) +#define get_csv2_v_str_pos627(X,Y) get_csv2_string((X),(Y),627) +#define get_csv2_bool_pos627(X,Y) get_csv2_bool((X),(Y),627) +#define get_csv2_int_pos627(X,Y) get_csv2_int((X),(Y),627) +#define get_csv2_llong_pos627(X,Y) get_csv2_llong((X),(Y),627) +#define get_csv2_float_pos627(X,Y) get_csv2_float((X),(Y),627) +#define get_csv2_uint_pos628(X,Y) get_csv2_uint((X),(Y),628) +#define get_csv2_ullong_pos628(X,Y) get_csv2_ullong((X),(Y),628) +#define get_csv2_ip_pos628(X,Y) get_csv2_ip((X),(Y),628) +#define get_csv2_ipv6_pos628(X,Y) get_csv2_ipv6((X),(Y),628) +#define get_csv2_string_pos628(X,Y) get_csv2_string((X),(Y),628) +#define get_csv2_v_str_pos628(X,Y) get_csv2_string((X),(Y),628) +#define get_csv2_bool_pos628(X,Y) get_csv2_bool((X),(Y),628) +#define get_csv2_int_pos628(X,Y) get_csv2_int((X),(Y),628) +#define get_csv2_llong_pos628(X,Y) get_csv2_llong((X),(Y),628) +#define get_csv2_float_pos628(X,Y) get_csv2_float((X),(Y),628) +#define get_csv2_uint_pos629(X,Y) get_csv2_uint((X),(Y),629) +#define get_csv2_ullong_pos629(X,Y) get_csv2_ullong((X),(Y),629) +#define get_csv2_ip_pos629(X,Y) get_csv2_ip((X),(Y),629) +#define get_csv2_ipv6_pos629(X,Y) get_csv2_ipv6((X),(Y),629) +#define get_csv2_string_pos629(X,Y) get_csv2_string((X),(Y),629) +#define get_csv2_v_str_pos629(X,Y) get_csv2_string((X),(Y),629) +#define get_csv2_bool_pos629(X,Y) get_csv2_bool((X),(Y),629) +#define get_csv2_int_pos629(X,Y) get_csv2_int((X),(Y),629) +#define get_csv2_llong_pos629(X,Y) get_csv2_llong((X),(Y),629) +#define get_csv2_float_pos629(X,Y) get_csv2_float((X),(Y),629) +#define get_csv2_uint_pos630(X,Y) get_csv2_uint((X),(Y),630) +#define get_csv2_ullong_pos630(X,Y) get_csv2_ullong((X),(Y),630) +#define get_csv2_ip_pos630(X,Y) get_csv2_ip((X),(Y),630) +#define get_csv2_ipv6_pos630(X,Y) get_csv2_ipv6((X),(Y),630) +#define get_csv2_string_pos630(X,Y) get_csv2_string((X),(Y),630) +#define get_csv2_v_str_pos630(X,Y) get_csv2_string((X),(Y),630) +#define get_csv2_bool_pos630(X,Y) get_csv2_bool((X),(Y),630) +#define get_csv2_int_pos630(X,Y) get_csv2_int((X),(Y),630) +#define get_csv2_llong_pos630(X,Y) get_csv2_llong((X),(Y),630) +#define get_csv2_float_pos630(X,Y) get_csv2_float((X),(Y),630) +#define get_csv2_uint_pos631(X,Y) get_csv2_uint((X),(Y),631) +#define get_csv2_ullong_pos631(X,Y) get_csv2_ullong((X),(Y),631) +#define get_csv2_ip_pos631(X,Y) get_csv2_ip((X),(Y),631) +#define get_csv2_ipv6_pos631(X,Y) get_csv2_ipv6((X),(Y),631) +#define get_csv2_string_pos631(X,Y) get_csv2_string((X),(Y),631) +#define get_csv2_v_str_pos631(X,Y) get_csv2_string((X),(Y),631) +#define get_csv2_bool_pos631(X,Y) get_csv2_bool((X),(Y),631) +#define get_csv2_int_pos631(X,Y) get_csv2_int((X),(Y),631) +#define get_csv2_llong_pos631(X,Y) get_csv2_llong((X),(Y),631) +#define get_csv2_float_pos631(X,Y) get_csv2_float((X),(Y),631) +#define get_csv2_uint_pos632(X,Y) get_csv2_uint((X),(Y),632) +#define get_csv2_ullong_pos632(X,Y) get_csv2_ullong((X),(Y),632) +#define get_csv2_ip_pos632(X,Y) get_csv2_ip((X),(Y),632) +#define get_csv2_ipv6_pos632(X,Y) get_csv2_ipv6((X),(Y),632) +#define get_csv2_string_pos632(X,Y) get_csv2_string((X),(Y),632) +#define get_csv2_v_str_pos632(X,Y) get_csv2_string((X),(Y),632) +#define get_csv2_bool_pos632(X,Y) get_csv2_bool((X),(Y),632) +#define get_csv2_int_pos632(X,Y) get_csv2_int((X),(Y),632) +#define get_csv2_llong_pos632(X,Y) get_csv2_llong((X),(Y),632) +#define get_csv2_float_pos632(X,Y) get_csv2_float((X),(Y),632) +#define get_csv2_uint_pos633(X,Y) get_csv2_uint((X),(Y),633) +#define get_csv2_ullong_pos633(X,Y) get_csv2_ullong((X),(Y),633) +#define get_csv2_ip_pos633(X,Y) get_csv2_ip((X),(Y),633) +#define get_csv2_ipv6_pos633(X,Y) get_csv2_ipv6((X),(Y),633) +#define get_csv2_string_pos633(X,Y) get_csv2_string((X),(Y),633) +#define get_csv2_v_str_pos633(X,Y) get_csv2_string((X),(Y),633) +#define get_csv2_bool_pos633(X,Y) get_csv2_bool((X),(Y),633) +#define get_csv2_int_pos633(X,Y) get_csv2_int((X),(Y),633) +#define get_csv2_llong_pos633(X,Y) get_csv2_llong((X),(Y),633) +#define get_csv2_float_pos633(X,Y) get_csv2_float((X),(Y),633) +#define get_csv2_uint_pos634(X,Y) get_csv2_uint((X),(Y),634) +#define get_csv2_ullong_pos634(X,Y) get_csv2_ullong((X),(Y),634) +#define get_csv2_ip_pos634(X,Y) get_csv2_ip((X),(Y),634) +#define get_csv2_ipv6_pos634(X,Y) get_csv2_ipv6((X),(Y),634) +#define get_csv2_string_pos634(X,Y) get_csv2_string((X),(Y),634) +#define get_csv2_v_str_pos634(X,Y) get_csv2_string((X),(Y),634) +#define get_csv2_bool_pos634(X,Y) get_csv2_bool((X),(Y),634) +#define get_csv2_int_pos634(X,Y) get_csv2_int((X),(Y),634) +#define get_csv2_llong_pos634(X,Y) get_csv2_llong((X),(Y),634) +#define get_csv2_float_pos634(X,Y) get_csv2_float((X),(Y),634) +#define get_csv2_uint_pos635(X,Y) get_csv2_uint((X),(Y),635) +#define get_csv2_ullong_pos635(X,Y) get_csv2_ullong((X),(Y),635) +#define get_csv2_ip_pos635(X,Y) get_csv2_ip((X),(Y),635) +#define get_csv2_ipv6_pos635(X,Y) get_csv2_ipv6((X),(Y),635) +#define get_csv2_string_pos635(X,Y) get_csv2_string((X),(Y),635) +#define get_csv2_v_str_pos635(X,Y) get_csv2_string((X),(Y),635) +#define get_csv2_bool_pos635(X,Y) get_csv2_bool((X),(Y),635) +#define get_csv2_int_pos635(X,Y) get_csv2_int((X),(Y),635) +#define get_csv2_llong_pos635(X,Y) get_csv2_llong((X),(Y),635) +#define get_csv2_float_pos635(X,Y) get_csv2_float((X),(Y),635) +#define get_csv2_uint_pos636(X,Y) get_csv2_uint((X),(Y),636) +#define get_csv2_ullong_pos636(X,Y) get_csv2_ullong((X),(Y),636) +#define get_csv2_ip_pos636(X,Y) get_csv2_ip((X),(Y),636) +#define get_csv2_ipv6_pos636(X,Y) get_csv2_ipv6((X),(Y),636) +#define get_csv2_string_pos636(X,Y) get_csv2_string((X),(Y),636) +#define get_csv2_v_str_pos636(X,Y) get_csv2_string((X),(Y),636) +#define get_csv2_bool_pos636(X,Y) get_csv2_bool((X),(Y),636) +#define get_csv2_int_pos636(X,Y) get_csv2_int((X),(Y),636) +#define get_csv2_llong_pos636(X,Y) get_csv2_llong((X),(Y),636) +#define get_csv2_float_pos636(X,Y) get_csv2_float((X),(Y),636) +#define get_csv2_uint_pos637(X,Y) get_csv2_uint((X),(Y),637) +#define get_csv2_ullong_pos637(X,Y) get_csv2_ullong((X),(Y),637) +#define get_csv2_ip_pos637(X,Y) get_csv2_ip((X),(Y),637) +#define get_csv2_ipv6_pos637(X,Y) get_csv2_ipv6((X),(Y),637) +#define get_csv2_string_pos637(X,Y) get_csv2_string((X),(Y),637) +#define get_csv2_v_str_pos637(X,Y) get_csv2_string((X),(Y),637) +#define get_csv2_bool_pos637(X,Y) get_csv2_bool((X),(Y),637) +#define get_csv2_int_pos637(X,Y) get_csv2_int((X),(Y),637) +#define get_csv2_llong_pos637(X,Y) get_csv2_llong((X),(Y),637) +#define get_csv2_float_pos637(X,Y) get_csv2_float((X),(Y),637) +#define get_csv2_uint_pos638(X,Y) get_csv2_uint((X),(Y),638) +#define get_csv2_ullong_pos638(X,Y) get_csv2_ullong((X),(Y),638) +#define get_csv2_ip_pos638(X,Y) get_csv2_ip((X),(Y),638) +#define get_csv2_ipv6_pos638(X,Y) get_csv2_ipv6((X),(Y),638) +#define get_csv2_string_pos638(X,Y) get_csv2_string((X),(Y),638) +#define get_csv2_v_str_pos638(X,Y) get_csv2_string((X),(Y),638) +#define get_csv2_bool_pos638(X,Y) get_csv2_bool((X),(Y),638) +#define get_csv2_int_pos638(X,Y) get_csv2_int((X),(Y),638) +#define get_csv2_llong_pos638(X,Y) get_csv2_llong((X),(Y),638) +#define get_csv2_float_pos638(X,Y) get_csv2_float((X),(Y),638) +#define get_csv2_uint_pos639(X,Y) get_csv2_uint((X),(Y),639) +#define get_csv2_ullong_pos639(X,Y) get_csv2_ullong((X),(Y),639) +#define get_csv2_ip_pos639(X,Y) get_csv2_ip((X),(Y),639) +#define get_csv2_ipv6_pos639(X,Y) get_csv2_ipv6((X),(Y),639) +#define get_csv2_string_pos639(X,Y) get_csv2_string((X),(Y),639) +#define get_csv2_v_str_pos639(X,Y) get_csv2_string((X),(Y),639) +#define get_csv2_bool_pos639(X,Y) get_csv2_bool((X),(Y),639) +#define get_csv2_int_pos639(X,Y) get_csv2_int((X),(Y),639) +#define get_csv2_llong_pos639(X,Y) get_csv2_llong((X),(Y),639) +#define get_csv2_float_pos639(X,Y) get_csv2_float((X),(Y),639) +#define get_csv2_uint_pos640(X,Y) get_csv2_uint((X),(Y),640) +#define get_csv2_ullong_pos640(X,Y) get_csv2_ullong((X),(Y),640) +#define get_csv2_ip_pos640(X,Y) get_csv2_ip((X),(Y),640) +#define get_csv2_ipv6_pos640(X,Y) get_csv2_ipv6((X),(Y),640) +#define get_csv2_string_pos640(X,Y) get_csv2_string((X),(Y),640) +#define get_csv2_v_str_pos640(X,Y) get_csv2_string((X),(Y),640) +#define get_csv2_bool_pos640(X,Y) get_csv2_bool((X),(Y),640) +#define get_csv2_int_pos640(X,Y) get_csv2_int((X),(Y),640) +#define get_csv2_llong_pos640(X,Y) get_csv2_llong((X),(Y),640) +#define get_csv2_float_pos640(X,Y) get_csv2_float((X),(Y),640) +#define get_csv2_uint_pos641(X,Y) get_csv2_uint((X),(Y),641) +#define get_csv2_ullong_pos641(X,Y) get_csv2_ullong((X),(Y),641) +#define get_csv2_ip_pos641(X,Y) get_csv2_ip((X),(Y),641) +#define get_csv2_ipv6_pos641(X,Y) get_csv2_ipv6((X),(Y),641) +#define get_csv2_string_pos641(X,Y) get_csv2_string((X),(Y),641) +#define get_csv2_v_str_pos641(X,Y) get_csv2_string((X),(Y),641) +#define get_csv2_bool_pos641(X,Y) get_csv2_bool((X),(Y),641) +#define get_csv2_int_pos641(X,Y) get_csv2_int((X),(Y),641) +#define get_csv2_llong_pos641(X,Y) get_csv2_llong((X),(Y),641) +#define get_csv2_float_pos641(X,Y) get_csv2_float((X),(Y),641) +#define get_csv2_uint_pos642(X,Y) get_csv2_uint((X),(Y),642) +#define get_csv2_ullong_pos642(X,Y) get_csv2_ullong((X),(Y),642) +#define get_csv2_ip_pos642(X,Y) get_csv2_ip((X),(Y),642) +#define get_csv2_ipv6_pos642(X,Y) get_csv2_ipv6((X),(Y),642) +#define get_csv2_string_pos642(X,Y) get_csv2_string((X),(Y),642) +#define get_csv2_v_str_pos642(X,Y) get_csv2_string((X),(Y),642) +#define get_csv2_bool_pos642(X,Y) get_csv2_bool((X),(Y),642) +#define get_csv2_int_pos642(X,Y) get_csv2_int((X),(Y),642) +#define get_csv2_llong_pos642(X,Y) get_csv2_llong((X),(Y),642) +#define get_csv2_float_pos642(X,Y) get_csv2_float((X),(Y),642) +#define get_csv2_uint_pos643(X,Y) get_csv2_uint((X),(Y),643) +#define get_csv2_ullong_pos643(X,Y) get_csv2_ullong((X),(Y),643) +#define get_csv2_ip_pos643(X,Y) get_csv2_ip((X),(Y),643) +#define get_csv2_ipv6_pos643(X,Y) get_csv2_ipv6((X),(Y),643) +#define get_csv2_string_pos643(X,Y) get_csv2_string((X),(Y),643) +#define get_csv2_v_str_pos643(X,Y) get_csv2_string((X),(Y),643) +#define get_csv2_bool_pos643(X,Y) get_csv2_bool((X),(Y),643) +#define get_csv2_int_pos643(X,Y) get_csv2_int((X),(Y),643) +#define get_csv2_llong_pos643(X,Y) get_csv2_llong((X),(Y),643) +#define get_csv2_float_pos643(X,Y) get_csv2_float((X),(Y),643) +#define get_csv2_uint_pos644(X,Y) get_csv2_uint((X),(Y),644) +#define get_csv2_ullong_pos644(X,Y) get_csv2_ullong((X),(Y),644) +#define get_csv2_ip_pos644(X,Y) get_csv2_ip((X),(Y),644) +#define get_csv2_ipv6_pos644(X,Y) get_csv2_ipv6((X),(Y),644) +#define get_csv2_string_pos644(X,Y) get_csv2_string((X),(Y),644) +#define get_csv2_v_str_pos644(X,Y) get_csv2_string((X),(Y),644) +#define get_csv2_bool_pos644(X,Y) get_csv2_bool((X),(Y),644) +#define get_csv2_int_pos644(X,Y) get_csv2_int((X),(Y),644) +#define get_csv2_llong_pos644(X,Y) get_csv2_llong((X),(Y),644) +#define get_csv2_float_pos644(X,Y) get_csv2_float((X),(Y),644) +#define get_csv2_uint_pos645(X,Y) get_csv2_uint((X),(Y),645) +#define get_csv2_ullong_pos645(X,Y) get_csv2_ullong((X),(Y),645) +#define get_csv2_ip_pos645(X,Y) get_csv2_ip((X),(Y),645) +#define get_csv2_ipv6_pos645(X,Y) get_csv2_ipv6((X),(Y),645) +#define get_csv2_string_pos645(X,Y) get_csv2_string((X),(Y),645) +#define get_csv2_v_str_pos645(X,Y) get_csv2_string((X),(Y),645) +#define get_csv2_bool_pos645(X,Y) get_csv2_bool((X),(Y),645) +#define get_csv2_int_pos645(X,Y) get_csv2_int((X),(Y),645) +#define get_csv2_llong_pos645(X,Y) get_csv2_llong((X),(Y),645) +#define get_csv2_float_pos645(X,Y) get_csv2_float((X),(Y),645) +#define get_csv2_uint_pos646(X,Y) get_csv2_uint((X),(Y),646) +#define get_csv2_ullong_pos646(X,Y) get_csv2_ullong((X),(Y),646) +#define get_csv2_ip_pos646(X,Y) get_csv2_ip((X),(Y),646) +#define get_csv2_ipv6_pos646(X,Y) get_csv2_ipv6((X),(Y),646) +#define get_csv2_string_pos646(X,Y) get_csv2_string((X),(Y),646) +#define get_csv2_v_str_pos646(X,Y) get_csv2_string((X),(Y),646) +#define get_csv2_bool_pos646(X,Y) get_csv2_bool((X),(Y),646) +#define get_csv2_int_pos646(X,Y) get_csv2_int((X),(Y),646) +#define get_csv2_llong_pos646(X,Y) get_csv2_llong((X),(Y),646) +#define get_csv2_float_pos646(X,Y) get_csv2_float((X),(Y),646) +#define get_csv2_uint_pos647(X,Y) get_csv2_uint((X),(Y),647) +#define get_csv2_ullong_pos647(X,Y) get_csv2_ullong((X),(Y),647) +#define get_csv2_ip_pos647(X,Y) get_csv2_ip((X),(Y),647) +#define get_csv2_ipv6_pos647(X,Y) get_csv2_ipv6((X),(Y),647) +#define get_csv2_string_pos647(X,Y) get_csv2_string((X),(Y),647) +#define get_csv2_v_str_pos647(X,Y) get_csv2_string((X),(Y),647) +#define get_csv2_bool_pos647(X,Y) get_csv2_bool((X),(Y),647) +#define get_csv2_int_pos647(X,Y) get_csv2_int((X),(Y),647) +#define get_csv2_llong_pos647(X,Y) get_csv2_llong((X),(Y),647) +#define get_csv2_float_pos647(X,Y) get_csv2_float((X),(Y),647) +#define get_csv2_uint_pos648(X,Y) get_csv2_uint((X),(Y),648) +#define get_csv2_ullong_pos648(X,Y) get_csv2_ullong((X),(Y),648) +#define get_csv2_ip_pos648(X,Y) get_csv2_ip((X),(Y),648) +#define get_csv2_ipv6_pos648(X,Y) get_csv2_ipv6((X),(Y),648) +#define get_csv2_string_pos648(X,Y) get_csv2_string((X),(Y),648) +#define get_csv2_v_str_pos648(X,Y) get_csv2_string((X),(Y),648) +#define get_csv2_bool_pos648(X,Y) get_csv2_bool((X),(Y),648) +#define get_csv2_int_pos648(X,Y) get_csv2_int((X),(Y),648) +#define get_csv2_llong_pos648(X,Y) get_csv2_llong((X),(Y),648) +#define get_csv2_float_pos648(X,Y) get_csv2_float((X),(Y),648) +#define get_csv2_uint_pos649(X,Y) get_csv2_uint((X),(Y),649) +#define get_csv2_ullong_pos649(X,Y) get_csv2_ullong((X),(Y),649) +#define get_csv2_ip_pos649(X,Y) get_csv2_ip((X),(Y),649) +#define get_csv2_ipv6_pos649(X,Y) get_csv2_ipv6((X),(Y),649) +#define get_csv2_string_pos649(X,Y) get_csv2_string((X),(Y),649) +#define get_csv2_v_str_pos649(X,Y) get_csv2_string((X),(Y),649) +#define get_csv2_bool_pos649(X,Y) get_csv2_bool((X),(Y),649) +#define get_csv2_int_pos649(X,Y) get_csv2_int((X),(Y),649) +#define get_csv2_llong_pos649(X,Y) get_csv2_llong((X),(Y),649) +#define get_csv2_float_pos649(X,Y) get_csv2_float((X),(Y),649) +#define get_csv2_uint_pos650(X,Y) get_csv2_uint((X),(Y),650) +#define get_csv2_ullong_pos650(X,Y) get_csv2_ullong((X),(Y),650) +#define get_csv2_ip_pos650(X,Y) get_csv2_ip((X),(Y),650) +#define get_csv2_ipv6_pos650(X,Y) get_csv2_ipv6((X),(Y),650) +#define get_csv2_string_pos650(X,Y) get_csv2_string((X),(Y),650) +#define get_csv2_v_str_pos650(X,Y) get_csv2_string((X),(Y),650) +#define get_csv2_bool_pos650(X,Y) get_csv2_bool((X),(Y),650) +#define get_csv2_int_pos650(X,Y) get_csv2_int((X),(Y),650) +#define get_csv2_llong_pos650(X,Y) get_csv2_llong((X),(Y),650) +#define get_csv2_float_pos650(X,Y) get_csv2_float((X),(Y),650) +#define get_csv2_uint_pos651(X,Y) get_csv2_uint((X),(Y),651) +#define get_csv2_ullong_pos651(X,Y) get_csv2_ullong((X),(Y),651) +#define get_csv2_ip_pos651(X,Y) get_csv2_ip((X),(Y),651) +#define get_csv2_ipv6_pos651(X,Y) get_csv2_ipv6((X),(Y),651) +#define get_csv2_string_pos651(X,Y) get_csv2_string((X),(Y),651) +#define get_csv2_v_str_pos651(X,Y) get_csv2_string((X),(Y),651) +#define get_csv2_bool_pos651(X,Y) get_csv2_bool((X),(Y),651) +#define get_csv2_int_pos651(X,Y) get_csv2_int((X),(Y),651) +#define get_csv2_llong_pos651(X,Y) get_csv2_llong((X),(Y),651) +#define get_csv2_float_pos651(X,Y) get_csv2_float((X),(Y),651) +#define get_csv2_uint_pos652(X,Y) get_csv2_uint((X),(Y),652) +#define get_csv2_ullong_pos652(X,Y) get_csv2_ullong((X),(Y),652) +#define get_csv2_ip_pos652(X,Y) get_csv2_ip((X),(Y),652) +#define get_csv2_ipv6_pos652(X,Y) get_csv2_ipv6((X),(Y),652) +#define get_csv2_string_pos652(X,Y) get_csv2_string((X),(Y),652) +#define get_csv2_v_str_pos652(X,Y) get_csv2_string((X),(Y),652) +#define get_csv2_bool_pos652(X,Y) get_csv2_bool((X),(Y),652) +#define get_csv2_int_pos652(X,Y) get_csv2_int((X),(Y),652) +#define get_csv2_llong_pos652(X,Y) get_csv2_llong((X),(Y),652) +#define get_csv2_float_pos652(X,Y) get_csv2_float((X),(Y),652) +#define get_csv2_uint_pos653(X,Y) get_csv2_uint((X),(Y),653) +#define get_csv2_ullong_pos653(X,Y) get_csv2_ullong((X),(Y),653) +#define get_csv2_ip_pos653(X,Y) get_csv2_ip((X),(Y),653) +#define get_csv2_ipv6_pos653(X,Y) get_csv2_ipv6((X),(Y),653) +#define get_csv2_string_pos653(X,Y) get_csv2_string((X),(Y),653) +#define get_csv2_v_str_pos653(X,Y) get_csv2_string((X),(Y),653) +#define get_csv2_bool_pos653(X,Y) get_csv2_bool((X),(Y),653) +#define get_csv2_int_pos653(X,Y) get_csv2_int((X),(Y),653) +#define get_csv2_llong_pos653(X,Y) get_csv2_llong((X),(Y),653) +#define get_csv2_float_pos653(X,Y) get_csv2_float((X),(Y),653) +#define get_csv2_uint_pos654(X,Y) get_csv2_uint((X),(Y),654) +#define get_csv2_ullong_pos654(X,Y) get_csv2_ullong((X),(Y),654) +#define get_csv2_ip_pos654(X,Y) get_csv2_ip((X),(Y),654) +#define get_csv2_ipv6_pos654(X,Y) get_csv2_ipv6((X),(Y),654) +#define get_csv2_string_pos654(X,Y) get_csv2_string((X),(Y),654) +#define get_csv2_v_str_pos654(X,Y) get_csv2_string((X),(Y),654) +#define get_csv2_bool_pos654(X,Y) get_csv2_bool((X),(Y),654) +#define get_csv2_int_pos654(X,Y) get_csv2_int((X),(Y),654) +#define get_csv2_llong_pos654(X,Y) get_csv2_llong((X),(Y),654) +#define get_csv2_float_pos654(X,Y) get_csv2_float((X),(Y),654) +#define get_csv2_uint_pos655(X,Y) get_csv2_uint((X),(Y),655) +#define get_csv2_ullong_pos655(X,Y) get_csv2_ullong((X),(Y),655) +#define get_csv2_ip_pos655(X,Y) get_csv2_ip((X),(Y),655) +#define get_csv2_ipv6_pos655(X,Y) get_csv2_ipv6((X),(Y),655) +#define get_csv2_string_pos655(X,Y) get_csv2_string((X),(Y),655) +#define get_csv2_v_str_pos655(X,Y) get_csv2_string((X),(Y),655) +#define get_csv2_bool_pos655(X,Y) get_csv2_bool((X),(Y),655) +#define get_csv2_int_pos655(X,Y) get_csv2_int((X),(Y),655) +#define get_csv2_llong_pos655(X,Y) get_csv2_llong((X),(Y),655) +#define get_csv2_float_pos655(X,Y) get_csv2_float((X),(Y),655) +#define get_csv2_uint_pos656(X,Y) get_csv2_uint((X),(Y),656) +#define get_csv2_ullong_pos656(X,Y) get_csv2_ullong((X),(Y),656) +#define get_csv2_ip_pos656(X,Y) get_csv2_ip((X),(Y),656) +#define get_csv2_ipv6_pos656(X,Y) get_csv2_ipv6((X),(Y),656) +#define get_csv2_string_pos656(X,Y) get_csv2_string((X),(Y),656) +#define get_csv2_v_str_pos656(X,Y) get_csv2_string((X),(Y),656) +#define get_csv2_bool_pos656(X,Y) get_csv2_bool((X),(Y),656) +#define get_csv2_int_pos656(X,Y) get_csv2_int((X),(Y),656) +#define get_csv2_llong_pos656(X,Y) get_csv2_llong((X),(Y),656) +#define get_csv2_float_pos656(X,Y) get_csv2_float((X),(Y),656) +#define get_csv2_uint_pos657(X,Y) get_csv2_uint((X),(Y),657) +#define get_csv2_ullong_pos657(X,Y) get_csv2_ullong((X),(Y),657) +#define get_csv2_ip_pos657(X,Y) get_csv2_ip((X),(Y),657) +#define get_csv2_ipv6_pos657(X,Y) get_csv2_ipv6((X),(Y),657) +#define get_csv2_string_pos657(X,Y) get_csv2_string((X),(Y),657) +#define get_csv2_v_str_pos657(X,Y) get_csv2_string((X),(Y),657) +#define get_csv2_bool_pos657(X,Y) get_csv2_bool((X),(Y),657) +#define get_csv2_int_pos657(X,Y) get_csv2_int((X),(Y),657) +#define get_csv2_llong_pos657(X,Y) get_csv2_llong((X),(Y),657) +#define get_csv2_float_pos657(X,Y) get_csv2_float((X),(Y),657) +#define get_csv2_uint_pos658(X,Y) get_csv2_uint((X),(Y),658) +#define get_csv2_ullong_pos658(X,Y) get_csv2_ullong((X),(Y),658) +#define get_csv2_ip_pos658(X,Y) get_csv2_ip((X),(Y),658) +#define get_csv2_ipv6_pos658(X,Y) get_csv2_ipv6((X),(Y),658) +#define get_csv2_string_pos658(X,Y) get_csv2_string((X),(Y),658) +#define get_csv2_v_str_pos658(X,Y) get_csv2_string((X),(Y),658) +#define get_csv2_bool_pos658(X,Y) get_csv2_bool((X),(Y),658) +#define get_csv2_int_pos658(X,Y) get_csv2_int((X),(Y),658) +#define get_csv2_llong_pos658(X,Y) get_csv2_llong((X),(Y),658) +#define get_csv2_float_pos658(X,Y) get_csv2_float((X),(Y),658) +#define get_csv2_uint_pos659(X,Y) get_csv2_uint((X),(Y),659) +#define get_csv2_ullong_pos659(X,Y) get_csv2_ullong((X),(Y),659) +#define get_csv2_ip_pos659(X,Y) get_csv2_ip((X),(Y),659) +#define get_csv2_ipv6_pos659(X,Y) get_csv2_ipv6((X),(Y),659) +#define get_csv2_string_pos659(X,Y) get_csv2_string((X),(Y),659) +#define get_csv2_v_str_pos659(X,Y) get_csv2_string((X),(Y),659) +#define get_csv2_bool_pos659(X,Y) get_csv2_bool((X),(Y),659) +#define get_csv2_int_pos659(X,Y) get_csv2_int((X),(Y),659) +#define get_csv2_llong_pos659(X,Y) get_csv2_llong((X),(Y),659) +#define get_csv2_float_pos659(X,Y) get_csv2_float((X),(Y),659) +#define get_csv2_uint_pos660(X,Y) get_csv2_uint((X),(Y),660) +#define get_csv2_ullong_pos660(X,Y) get_csv2_ullong((X),(Y),660) +#define get_csv2_ip_pos660(X,Y) get_csv2_ip((X),(Y),660) +#define get_csv2_ipv6_pos660(X,Y) get_csv2_ipv6((X),(Y),660) +#define get_csv2_string_pos660(X,Y) get_csv2_string((X),(Y),660) +#define get_csv2_v_str_pos660(X,Y) get_csv2_string((X),(Y),660) +#define get_csv2_bool_pos660(X,Y) get_csv2_bool((X),(Y),660) +#define get_csv2_int_pos660(X,Y) get_csv2_int((X),(Y),660) +#define get_csv2_llong_pos660(X,Y) get_csv2_llong((X),(Y),660) +#define get_csv2_float_pos660(X,Y) get_csv2_float((X),(Y),660) +#define get_csv2_uint_pos661(X,Y) get_csv2_uint((X),(Y),661) +#define get_csv2_ullong_pos661(X,Y) get_csv2_ullong((X),(Y),661) +#define get_csv2_ip_pos661(X,Y) get_csv2_ip((X),(Y),661) +#define get_csv2_ipv6_pos661(X,Y) get_csv2_ipv6((X),(Y),661) +#define get_csv2_string_pos661(X,Y) get_csv2_string((X),(Y),661) +#define get_csv2_v_str_pos661(X,Y) get_csv2_string((X),(Y),661) +#define get_csv2_bool_pos661(X,Y) get_csv2_bool((X),(Y),661) +#define get_csv2_int_pos661(X,Y) get_csv2_int((X),(Y),661) +#define get_csv2_llong_pos661(X,Y) get_csv2_llong((X),(Y),661) +#define get_csv2_float_pos661(X,Y) get_csv2_float((X),(Y),661) +#define get_csv2_uint_pos662(X,Y) get_csv2_uint((X),(Y),662) +#define get_csv2_ullong_pos662(X,Y) get_csv2_ullong((X),(Y),662) +#define get_csv2_ip_pos662(X,Y) get_csv2_ip((X),(Y),662) +#define get_csv2_ipv6_pos662(X,Y) get_csv2_ipv6((X),(Y),662) +#define get_csv2_string_pos662(X,Y) get_csv2_string((X),(Y),662) +#define get_csv2_v_str_pos662(X,Y) get_csv2_string((X),(Y),662) +#define get_csv2_bool_pos662(X,Y) get_csv2_bool((X),(Y),662) +#define get_csv2_int_pos662(X,Y) get_csv2_int((X),(Y),662) +#define get_csv2_llong_pos662(X,Y) get_csv2_llong((X),(Y),662) +#define get_csv2_float_pos662(X,Y) get_csv2_float((X),(Y),662) +#define get_csv2_uint_pos663(X,Y) get_csv2_uint((X),(Y),663) +#define get_csv2_ullong_pos663(X,Y) get_csv2_ullong((X),(Y),663) +#define get_csv2_ip_pos663(X,Y) get_csv2_ip((X),(Y),663) +#define get_csv2_ipv6_pos663(X,Y) get_csv2_ipv6((X),(Y),663) +#define get_csv2_string_pos663(X,Y) get_csv2_string((X),(Y),663) +#define get_csv2_v_str_pos663(X,Y) get_csv2_string((X),(Y),663) +#define get_csv2_bool_pos663(X,Y) get_csv2_bool((X),(Y),663) +#define get_csv2_int_pos663(X,Y) get_csv2_int((X),(Y),663) +#define get_csv2_llong_pos663(X,Y) get_csv2_llong((X),(Y),663) +#define get_csv2_float_pos663(X,Y) get_csv2_float((X),(Y),663) +#define get_csv2_uint_pos664(X,Y) get_csv2_uint((X),(Y),664) +#define get_csv2_ullong_pos664(X,Y) get_csv2_ullong((X),(Y),664) +#define get_csv2_ip_pos664(X,Y) get_csv2_ip((X),(Y),664) +#define get_csv2_ipv6_pos664(X,Y) get_csv2_ipv6((X),(Y),664) +#define get_csv2_string_pos664(X,Y) get_csv2_string((X),(Y),664) +#define get_csv2_v_str_pos664(X,Y) get_csv2_string((X),(Y),664) +#define get_csv2_bool_pos664(X,Y) get_csv2_bool((X),(Y),664) +#define get_csv2_int_pos664(X,Y) get_csv2_int((X),(Y),664) +#define get_csv2_llong_pos664(X,Y) get_csv2_llong((X),(Y),664) +#define get_csv2_float_pos664(X,Y) get_csv2_float((X),(Y),664) +#define get_csv2_uint_pos665(X,Y) get_csv2_uint((X),(Y),665) +#define get_csv2_ullong_pos665(X,Y) get_csv2_ullong((X),(Y),665) +#define get_csv2_ip_pos665(X,Y) get_csv2_ip((X),(Y),665) +#define get_csv2_ipv6_pos665(X,Y) get_csv2_ipv6((X),(Y),665) +#define get_csv2_string_pos665(X,Y) get_csv2_string((X),(Y),665) +#define get_csv2_v_str_pos665(X,Y) get_csv2_string((X),(Y),665) +#define get_csv2_bool_pos665(X,Y) get_csv2_bool((X),(Y),665) +#define get_csv2_int_pos665(X,Y) get_csv2_int((X),(Y),665) +#define get_csv2_llong_pos665(X,Y) get_csv2_llong((X),(Y),665) +#define get_csv2_float_pos665(X,Y) get_csv2_float((X),(Y),665) +#define get_csv2_uint_pos666(X,Y) get_csv2_uint((X),(Y),666) +#define get_csv2_ullong_pos666(X,Y) get_csv2_ullong((X),(Y),666) +#define get_csv2_ip_pos666(X,Y) get_csv2_ip((X),(Y),666) +#define get_csv2_ipv6_pos666(X,Y) get_csv2_ipv6((X),(Y),666) +#define get_csv2_string_pos666(X,Y) get_csv2_string((X),(Y),666) +#define get_csv2_v_str_pos666(X,Y) get_csv2_string((X),(Y),666) +#define get_csv2_bool_pos666(X,Y) get_csv2_bool((X),(Y),666) +#define get_csv2_int_pos666(X,Y) get_csv2_int((X),(Y),666) +#define get_csv2_llong_pos666(X,Y) get_csv2_llong((X),(Y),666) +#define get_csv2_float_pos666(X,Y) get_csv2_float((X),(Y),666) +#define get_csv2_uint_pos667(X,Y) get_csv2_uint((X),(Y),667) +#define get_csv2_ullong_pos667(X,Y) get_csv2_ullong((X),(Y),667) +#define get_csv2_ip_pos667(X,Y) get_csv2_ip((X),(Y),667) +#define get_csv2_ipv6_pos667(X,Y) get_csv2_ipv6((X),(Y),667) +#define get_csv2_string_pos667(X,Y) get_csv2_string((X),(Y),667) +#define get_csv2_v_str_pos667(X,Y) get_csv2_string((X),(Y),667) +#define get_csv2_bool_pos667(X,Y) get_csv2_bool((X),(Y),667) +#define get_csv2_int_pos667(X,Y) get_csv2_int((X),(Y),667) +#define get_csv2_llong_pos667(X,Y) get_csv2_llong((X),(Y),667) +#define get_csv2_float_pos667(X,Y) get_csv2_float((X),(Y),667) +#define get_csv2_uint_pos668(X,Y) get_csv2_uint((X),(Y),668) +#define get_csv2_ullong_pos668(X,Y) get_csv2_ullong((X),(Y),668) +#define get_csv2_ip_pos668(X,Y) get_csv2_ip((X),(Y),668) +#define get_csv2_ipv6_pos668(X,Y) get_csv2_ipv6((X),(Y),668) +#define get_csv2_string_pos668(X,Y) get_csv2_string((X),(Y),668) +#define get_csv2_v_str_pos668(X,Y) get_csv2_string((X),(Y),668) +#define get_csv2_bool_pos668(X,Y) get_csv2_bool((X),(Y),668) +#define get_csv2_int_pos668(X,Y) get_csv2_int((X),(Y),668) +#define get_csv2_llong_pos668(X,Y) get_csv2_llong((X),(Y),668) +#define get_csv2_float_pos668(X,Y) get_csv2_float((X),(Y),668) +#define get_csv2_uint_pos669(X,Y) get_csv2_uint((X),(Y),669) +#define get_csv2_ullong_pos669(X,Y) get_csv2_ullong((X),(Y),669) +#define get_csv2_ip_pos669(X,Y) get_csv2_ip((X),(Y),669) +#define get_csv2_ipv6_pos669(X,Y) get_csv2_ipv6((X),(Y),669) +#define get_csv2_string_pos669(X,Y) get_csv2_string((X),(Y),669) +#define get_csv2_v_str_pos669(X,Y) get_csv2_string((X),(Y),669) +#define get_csv2_bool_pos669(X,Y) get_csv2_bool((X),(Y),669) +#define get_csv2_int_pos669(X,Y) get_csv2_int((X),(Y),669) +#define get_csv2_llong_pos669(X,Y) get_csv2_llong((X),(Y),669) +#define get_csv2_float_pos669(X,Y) get_csv2_float((X),(Y),669) +#define get_csv2_uint_pos670(X,Y) get_csv2_uint((X),(Y),670) +#define get_csv2_ullong_pos670(X,Y) get_csv2_ullong((X),(Y),670) +#define get_csv2_ip_pos670(X,Y) get_csv2_ip((X),(Y),670) +#define get_csv2_ipv6_pos670(X,Y) get_csv2_ipv6((X),(Y),670) +#define get_csv2_string_pos670(X,Y) get_csv2_string((X),(Y),670) +#define get_csv2_v_str_pos670(X,Y) get_csv2_string((X),(Y),670) +#define get_csv2_bool_pos670(X,Y) get_csv2_bool((X),(Y),670) +#define get_csv2_int_pos670(X,Y) get_csv2_int((X),(Y),670) +#define get_csv2_llong_pos670(X,Y) get_csv2_llong((X),(Y),670) +#define get_csv2_float_pos670(X,Y) get_csv2_float((X),(Y),670) +#define get_csv2_uint_pos671(X,Y) get_csv2_uint((X),(Y),671) +#define get_csv2_ullong_pos671(X,Y) get_csv2_ullong((X),(Y),671) +#define get_csv2_ip_pos671(X,Y) get_csv2_ip((X),(Y),671) +#define get_csv2_ipv6_pos671(X,Y) get_csv2_ipv6((X),(Y),671) +#define get_csv2_string_pos671(X,Y) get_csv2_string((X),(Y),671) +#define get_csv2_v_str_pos671(X,Y) get_csv2_string((X),(Y),671) +#define get_csv2_bool_pos671(X,Y) get_csv2_bool((X),(Y),671) +#define get_csv2_int_pos671(X,Y) get_csv2_int((X),(Y),671) +#define get_csv2_llong_pos671(X,Y) get_csv2_llong((X),(Y),671) +#define get_csv2_float_pos671(X,Y) get_csv2_float((X),(Y),671) +#define get_csv2_uint_pos672(X,Y) get_csv2_uint((X),(Y),672) +#define get_csv2_ullong_pos672(X,Y) get_csv2_ullong((X),(Y),672) +#define get_csv2_ip_pos672(X,Y) get_csv2_ip((X),(Y),672) +#define get_csv2_ipv6_pos672(X,Y) get_csv2_ipv6((X),(Y),672) +#define get_csv2_string_pos672(X,Y) get_csv2_string((X),(Y),672) +#define get_csv2_v_str_pos672(X,Y) get_csv2_string((X),(Y),672) +#define get_csv2_bool_pos672(X,Y) get_csv2_bool((X),(Y),672) +#define get_csv2_int_pos672(X,Y) get_csv2_int((X),(Y),672) +#define get_csv2_llong_pos672(X,Y) get_csv2_llong((X),(Y),672) +#define get_csv2_float_pos672(X,Y) get_csv2_float((X),(Y),672) +#define get_csv2_uint_pos673(X,Y) get_csv2_uint((X),(Y),673) +#define get_csv2_ullong_pos673(X,Y) get_csv2_ullong((X),(Y),673) +#define get_csv2_ip_pos673(X,Y) get_csv2_ip((X),(Y),673) +#define get_csv2_ipv6_pos673(X,Y) get_csv2_ipv6((X),(Y),673) +#define get_csv2_string_pos673(X,Y) get_csv2_string((X),(Y),673) +#define get_csv2_v_str_pos673(X,Y) get_csv2_string((X),(Y),673) +#define get_csv2_bool_pos673(X,Y) get_csv2_bool((X),(Y),673) +#define get_csv2_int_pos673(X,Y) get_csv2_int((X),(Y),673) +#define get_csv2_llong_pos673(X,Y) get_csv2_llong((X),(Y),673) +#define get_csv2_float_pos673(X,Y) get_csv2_float((X),(Y),673) +#define get_csv2_uint_pos674(X,Y) get_csv2_uint((X),(Y),674) +#define get_csv2_ullong_pos674(X,Y) get_csv2_ullong((X),(Y),674) +#define get_csv2_ip_pos674(X,Y) get_csv2_ip((X),(Y),674) +#define get_csv2_ipv6_pos674(X,Y) get_csv2_ipv6((X),(Y),674) +#define get_csv2_string_pos674(X,Y) get_csv2_string((X),(Y),674) +#define get_csv2_v_str_pos674(X,Y) get_csv2_string((X),(Y),674) +#define get_csv2_bool_pos674(X,Y) get_csv2_bool((X),(Y),674) +#define get_csv2_int_pos674(X,Y) get_csv2_int((X),(Y),674) +#define get_csv2_llong_pos674(X,Y) get_csv2_llong((X),(Y),674) +#define get_csv2_float_pos674(X,Y) get_csv2_float((X),(Y),674) +#define get_csv2_uint_pos675(X,Y) get_csv2_uint((X),(Y),675) +#define get_csv2_ullong_pos675(X,Y) get_csv2_ullong((X),(Y),675) +#define get_csv2_ip_pos675(X,Y) get_csv2_ip((X),(Y),675) +#define get_csv2_ipv6_pos675(X,Y) get_csv2_ipv6((X),(Y),675) +#define get_csv2_string_pos675(X,Y) get_csv2_string((X),(Y),675) +#define get_csv2_v_str_pos675(X,Y) get_csv2_string((X),(Y),675) +#define get_csv2_bool_pos675(X,Y) get_csv2_bool((X),(Y),675) +#define get_csv2_int_pos675(X,Y) get_csv2_int((X),(Y),675) +#define get_csv2_llong_pos675(X,Y) get_csv2_llong((X),(Y),675) +#define get_csv2_float_pos675(X,Y) get_csv2_float((X),(Y),675) +#define get_csv2_uint_pos676(X,Y) get_csv2_uint((X),(Y),676) +#define get_csv2_ullong_pos676(X,Y) get_csv2_ullong((X),(Y),676) +#define get_csv2_ip_pos676(X,Y) get_csv2_ip((X),(Y),676) +#define get_csv2_ipv6_pos676(X,Y) get_csv2_ipv6((X),(Y),676) +#define get_csv2_string_pos676(X,Y) get_csv2_string((X),(Y),676) +#define get_csv2_v_str_pos676(X,Y) get_csv2_string((X),(Y),676) +#define get_csv2_bool_pos676(X,Y) get_csv2_bool((X),(Y),676) +#define get_csv2_int_pos676(X,Y) get_csv2_int((X),(Y),676) +#define get_csv2_llong_pos676(X,Y) get_csv2_llong((X),(Y),676) +#define get_csv2_float_pos676(X,Y) get_csv2_float((X),(Y),676) +#define get_csv2_uint_pos677(X,Y) get_csv2_uint((X),(Y),677) +#define get_csv2_ullong_pos677(X,Y) get_csv2_ullong((X),(Y),677) +#define get_csv2_ip_pos677(X,Y) get_csv2_ip((X),(Y),677) +#define get_csv2_ipv6_pos677(X,Y) get_csv2_ipv6((X),(Y),677) +#define get_csv2_string_pos677(X,Y) get_csv2_string((X),(Y),677) +#define get_csv2_v_str_pos677(X,Y) get_csv2_string((X),(Y),677) +#define get_csv2_bool_pos677(X,Y) get_csv2_bool((X),(Y),677) +#define get_csv2_int_pos677(X,Y) get_csv2_int((X),(Y),677) +#define get_csv2_llong_pos677(X,Y) get_csv2_llong((X),(Y),677) +#define get_csv2_float_pos677(X,Y) get_csv2_float((X),(Y),677) +#define get_csv2_uint_pos678(X,Y) get_csv2_uint((X),(Y),678) +#define get_csv2_ullong_pos678(X,Y) get_csv2_ullong((X),(Y),678) +#define get_csv2_ip_pos678(X,Y) get_csv2_ip((X),(Y),678) +#define get_csv2_ipv6_pos678(X,Y) get_csv2_ipv6((X),(Y),678) +#define get_csv2_string_pos678(X,Y) get_csv2_string((X),(Y),678) +#define get_csv2_v_str_pos678(X,Y) get_csv2_string((X),(Y),678) +#define get_csv2_bool_pos678(X,Y) get_csv2_bool((X),(Y),678) +#define get_csv2_int_pos678(X,Y) get_csv2_int((X),(Y),678) +#define get_csv2_llong_pos678(X,Y) get_csv2_llong((X),(Y),678) +#define get_csv2_float_pos678(X,Y) get_csv2_float((X),(Y),678) +#define get_csv2_uint_pos679(X,Y) get_csv2_uint((X),(Y),679) +#define get_csv2_ullong_pos679(X,Y) get_csv2_ullong((X),(Y),679) +#define get_csv2_ip_pos679(X,Y) get_csv2_ip((X),(Y),679) +#define get_csv2_ipv6_pos679(X,Y) get_csv2_ipv6((X),(Y),679) +#define get_csv2_string_pos679(X,Y) get_csv2_string((X),(Y),679) +#define get_csv2_v_str_pos679(X,Y) get_csv2_string((X),(Y),679) +#define get_csv2_bool_pos679(X,Y) get_csv2_bool((X),(Y),679) +#define get_csv2_int_pos679(X,Y) get_csv2_int((X),(Y),679) +#define get_csv2_llong_pos679(X,Y) get_csv2_llong((X),(Y),679) +#define get_csv2_float_pos679(X,Y) get_csv2_float((X),(Y),679) +#define get_csv2_uint_pos680(X,Y) get_csv2_uint((X),(Y),680) +#define get_csv2_ullong_pos680(X,Y) get_csv2_ullong((X),(Y),680) +#define get_csv2_ip_pos680(X,Y) get_csv2_ip((X),(Y),680) +#define get_csv2_ipv6_pos680(X,Y) get_csv2_ipv6((X),(Y),680) +#define get_csv2_string_pos680(X,Y) get_csv2_string((X),(Y),680) +#define get_csv2_v_str_pos680(X,Y) get_csv2_string((X),(Y),680) +#define get_csv2_bool_pos680(X,Y) get_csv2_bool((X),(Y),680) +#define get_csv2_int_pos680(X,Y) get_csv2_int((X),(Y),680) +#define get_csv2_llong_pos680(X,Y) get_csv2_llong((X),(Y),680) +#define get_csv2_float_pos680(X,Y) get_csv2_float((X),(Y),680) +#define get_csv2_uint_pos681(X,Y) get_csv2_uint((X),(Y),681) +#define get_csv2_ullong_pos681(X,Y) get_csv2_ullong((X),(Y),681) +#define get_csv2_ip_pos681(X,Y) get_csv2_ip((X),(Y),681) +#define get_csv2_ipv6_pos681(X,Y) get_csv2_ipv6((X),(Y),681) +#define get_csv2_string_pos681(X,Y) get_csv2_string((X),(Y),681) +#define get_csv2_v_str_pos681(X,Y) get_csv2_string((X),(Y),681) +#define get_csv2_bool_pos681(X,Y) get_csv2_bool((X),(Y),681) +#define get_csv2_int_pos681(X,Y) get_csv2_int((X),(Y),681) +#define get_csv2_llong_pos681(X,Y) get_csv2_llong((X),(Y),681) +#define get_csv2_float_pos681(X,Y) get_csv2_float((X),(Y),681) +#define get_csv2_uint_pos682(X,Y) get_csv2_uint((X),(Y),682) +#define get_csv2_ullong_pos682(X,Y) get_csv2_ullong((X),(Y),682) +#define get_csv2_ip_pos682(X,Y) get_csv2_ip((X),(Y),682) +#define get_csv2_ipv6_pos682(X,Y) get_csv2_ipv6((X),(Y),682) +#define get_csv2_string_pos682(X,Y) get_csv2_string((X),(Y),682) +#define get_csv2_v_str_pos682(X,Y) get_csv2_string((X),(Y),682) +#define get_csv2_bool_pos682(X,Y) get_csv2_bool((X),(Y),682) +#define get_csv2_int_pos682(X,Y) get_csv2_int((X),(Y),682) +#define get_csv2_llong_pos682(X,Y) get_csv2_llong((X),(Y),682) +#define get_csv2_float_pos682(X,Y) get_csv2_float((X),(Y),682) +#define get_csv2_uint_pos683(X,Y) get_csv2_uint((X),(Y),683) +#define get_csv2_ullong_pos683(X,Y) get_csv2_ullong((X),(Y),683) +#define get_csv2_ip_pos683(X,Y) get_csv2_ip((X),(Y),683) +#define get_csv2_ipv6_pos683(X,Y) get_csv2_ipv6((X),(Y),683) +#define get_csv2_string_pos683(X,Y) get_csv2_string((X),(Y),683) +#define get_csv2_v_str_pos683(X,Y) get_csv2_string((X),(Y),683) +#define get_csv2_bool_pos683(X,Y) get_csv2_bool((X),(Y),683) +#define get_csv2_int_pos683(X,Y) get_csv2_int((X),(Y),683) +#define get_csv2_llong_pos683(X,Y) get_csv2_llong((X),(Y),683) +#define get_csv2_float_pos683(X,Y) get_csv2_float((X),(Y),683) +#define get_csv2_uint_pos684(X,Y) get_csv2_uint((X),(Y),684) +#define get_csv2_ullong_pos684(X,Y) get_csv2_ullong((X),(Y),684) +#define get_csv2_ip_pos684(X,Y) get_csv2_ip((X),(Y),684) +#define get_csv2_ipv6_pos684(X,Y) get_csv2_ipv6((X),(Y),684) +#define get_csv2_string_pos684(X,Y) get_csv2_string((X),(Y),684) +#define get_csv2_v_str_pos684(X,Y) get_csv2_string((X),(Y),684) +#define get_csv2_bool_pos684(X,Y) get_csv2_bool((X),(Y),684) +#define get_csv2_int_pos684(X,Y) get_csv2_int((X),(Y),684) +#define get_csv2_llong_pos684(X,Y) get_csv2_llong((X),(Y),684) +#define get_csv2_float_pos684(X,Y) get_csv2_float((X),(Y),684) +#define get_csv2_uint_pos685(X,Y) get_csv2_uint((X),(Y),685) +#define get_csv2_ullong_pos685(X,Y) get_csv2_ullong((X),(Y),685) +#define get_csv2_ip_pos685(X,Y) get_csv2_ip((X),(Y),685) +#define get_csv2_ipv6_pos685(X,Y) get_csv2_ipv6((X),(Y),685) +#define get_csv2_string_pos685(X,Y) get_csv2_string((X),(Y),685) +#define get_csv2_v_str_pos685(X,Y) get_csv2_string((X),(Y),685) +#define get_csv2_bool_pos685(X,Y) get_csv2_bool((X),(Y),685) +#define get_csv2_int_pos685(X,Y) get_csv2_int((X),(Y),685) +#define get_csv2_llong_pos685(X,Y) get_csv2_llong((X),(Y),685) +#define get_csv2_float_pos685(X,Y) get_csv2_float((X),(Y),685) +#define get_csv2_uint_pos686(X,Y) get_csv2_uint((X),(Y),686) +#define get_csv2_ullong_pos686(X,Y) get_csv2_ullong((X),(Y),686) +#define get_csv2_ip_pos686(X,Y) get_csv2_ip((X),(Y),686) +#define get_csv2_ipv6_pos686(X,Y) get_csv2_ipv6((X),(Y),686) +#define get_csv2_string_pos686(X,Y) get_csv2_string((X),(Y),686) +#define get_csv2_v_str_pos686(X,Y) get_csv2_string((X),(Y),686) +#define get_csv2_bool_pos686(X,Y) get_csv2_bool((X),(Y),686) +#define get_csv2_int_pos686(X,Y) get_csv2_int((X),(Y),686) +#define get_csv2_llong_pos686(X,Y) get_csv2_llong((X),(Y),686) +#define get_csv2_float_pos686(X,Y) get_csv2_float((X),(Y),686) +#define get_csv2_uint_pos687(X,Y) get_csv2_uint((X),(Y),687) +#define get_csv2_ullong_pos687(X,Y) get_csv2_ullong((X),(Y),687) +#define get_csv2_ip_pos687(X,Y) get_csv2_ip((X),(Y),687) +#define get_csv2_ipv6_pos687(X,Y) get_csv2_ipv6((X),(Y),687) +#define get_csv2_string_pos687(X,Y) get_csv2_string((X),(Y),687) +#define get_csv2_v_str_pos687(X,Y) get_csv2_string((X),(Y),687) +#define get_csv2_bool_pos687(X,Y) get_csv2_bool((X),(Y),687) +#define get_csv2_int_pos687(X,Y) get_csv2_int((X),(Y),687) +#define get_csv2_llong_pos687(X,Y) get_csv2_llong((X),(Y),687) +#define get_csv2_float_pos687(X,Y) get_csv2_float((X),(Y),687) +#define get_csv2_uint_pos688(X,Y) get_csv2_uint((X),(Y),688) +#define get_csv2_ullong_pos688(X,Y) get_csv2_ullong((X),(Y),688) +#define get_csv2_ip_pos688(X,Y) get_csv2_ip((X),(Y),688) +#define get_csv2_ipv6_pos688(X,Y) get_csv2_ipv6((X),(Y),688) +#define get_csv2_string_pos688(X,Y) get_csv2_string((X),(Y),688) +#define get_csv2_v_str_pos688(X,Y) get_csv2_string((X),(Y),688) +#define get_csv2_bool_pos688(X,Y) get_csv2_bool((X),(Y),688) +#define get_csv2_int_pos688(X,Y) get_csv2_int((X),(Y),688) +#define get_csv2_llong_pos688(X,Y) get_csv2_llong((X),(Y),688) +#define get_csv2_float_pos688(X,Y) get_csv2_float((X),(Y),688) +#define get_csv2_uint_pos689(X,Y) get_csv2_uint((X),(Y),689) +#define get_csv2_ullong_pos689(X,Y) get_csv2_ullong((X),(Y),689) +#define get_csv2_ip_pos689(X,Y) get_csv2_ip((X),(Y),689) +#define get_csv2_ipv6_pos689(X,Y) get_csv2_ipv6((X),(Y),689) +#define get_csv2_string_pos689(X,Y) get_csv2_string((X),(Y),689) +#define get_csv2_v_str_pos689(X,Y) get_csv2_string((X),(Y),689) +#define get_csv2_bool_pos689(X,Y) get_csv2_bool((X),(Y),689) +#define get_csv2_int_pos689(X,Y) get_csv2_int((X),(Y),689) +#define get_csv2_llong_pos689(X,Y) get_csv2_llong((X),(Y),689) +#define get_csv2_float_pos689(X,Y) get_csv2_float((X),(Y),689) +#define get_csv2_uint_pos690(X,Y) get_csv2_uint((X),(Y),690) +#define get_csv2_ullong_pos690(X,Y) get_csv2_ullong((X),(Y),690) +#define get_csv2_ip_pos690(X,Y) get_csv2_ip((X),(Y),690) +#define get_csv2_ipv6_pos690(X,Y) get_csv2_ipv6((X),(Y),690) +#define get_csv2_string_pos690(X,Y) get_csv2_string((X),(Y),690) +#define get_csv2_v_str_pos690(X,Y) get_csv2_string((X),(Y),690) +#define get_csv2_bool_pos690(X,Y) get_csv2_bool((X),(Y),690) +#define get_csv2_int_pos690(X,Y) get_csv2_int((X),(Y),690) +#define get_csv2_llong_pos690(X,Y) get_csv2_llong((X),(Y),690) +#define get_csv2_float_pos690(X,Y) get_csv2_float((X),(Y),690) +#define get_csv2_uint_pos691(X,Y) get_csv2_uint((X),(Y),691) +#define get_csv2_ullong_pos691(X,Y) get_csv2_ullong((X),(Y),691) +#define get_csv2_ip_pos691(X,Y) get_csv2_ip((X),(Y),691) +#define get_csv2_ipv6_pos691(X,Y) get_csv2_ipv6((X),(Y),691) +#define get_csv2_string_pos691(X,Y) get_csv2_string((X),(Y),691) +#define get_csv2_v_str_pos691(X,Y) get_csv2_string((X),(Y),691) +#define get_csv2_bool_pos691(X,Y) get_csv2_bool((X),(Y),691) +#define get_csv2_int_pos691(X,Y) get_csv2_int((X),(Y),691) +#define get_csv2_llong_pos691(X,Y) get_csv2_llong((X),(Y),691) +#define get_csv2_float_pos691(X,Y) get_csv2_float((X),(Y),691) +#define get_csv2_uint_pos692(X,Y) get_csv2_uint((X),(Y),692) +#define get_csv2_ullong_pos692(X,Y) get_csv2_ullong((X),(Y),692) +#define get_csv2_ip_pos692(X,Y) get_csv2_ip((X),(Y),692) +#define get_csv2_ipv6_pos692(X,Y) get_csv2_ipv6((X),(Y),692) +#define get_csv2_string_pos692(X,Y) get_csv2_string((X),(Y),692) +#define get_csv2_v_str_pos692(X,Y) get_csv2_string((X),(Y),692) +#define get_csv2_bool_pos692(X,Y) get_csv2_bool((X),(Y),692) +#define get_csv2_int_pos692(X,Y) get_csv2_int((X),(Y),692) +#define get_csv2_llong_pos692(X,Y) get_csv2_llong((X),(Y),692) +#define get_csv2_float_pos692(X,Y) get_csv2_float((X),(Y),692) +#define get_csv2_uint_pos693(X,Y) get_csv2_uint((X),(Y),693) +#define get_csv2_ullong_pos693(X,Y) get_csv2_ullong((X),(Y),693) +#define get_csv2_ip_pos693(X,Y) get_csv2_ip((X),(Y),693) +#define get_csv2_ipv6_pos693(X,Y) get_csv2_ipv6((X),(Y),693) +#define get_csv2_string_pos693(X,Y) get_csv2_string((X),(Y),693) +#define get_csv2_v_str_pos693(X,Y) get_csv2_string((X),(Y),693) +#define get_csv2_bool_pos693(X,Y) get_csv2_bool((X),(Y),693) +#define get_csv2_int_pos693(X,Y) get_csv2_int((X),(Y),693) +#define get_csv2_llong_pos693(X,Y) get_csv2_llong((X),(Y),693) +#define get_csv2_float_pos693(X,Y) get_csv2_float((X),(Y),693) +#define get_csv2_uint_pos694(X,Y) get_csv2_uint((X),(Y),694) +#define get_csv2_ullong_pos694(X,Y) get_csv2_ullong((X),(Y),694) +#define get_csv2_ip_pos694(X,Y) get_csv2_ip((X),(Y),694) +#define get_csv2_ipv6_pos694(X,Y) get_csv2_ipv6((X),(Y),694) +#define get_csv2_string_pos694(X,Y) get_csv2_string((X),(Y),694) +#define get_csv2_v_str_pos694(X,Y) get_csv2_string((X),(Y),694) +#define get_csv2_bool_pos694(X,Y) get_csv2_bool((X),(Y),694) +#define get_csv2_int_pos694(X,Y) get_csv2_int((X),(Y),694) +#define get_csv2_llong_pos694(X,Y) get_csv2_llong((X),(Y),694) +#define get_csv2_float_pos694(X,Y) get_csv2_float((X),(Y),694) +#define get_csv2_uint_pos695(X,Y) get_csv2_uint((X),(Y),695) +#define get_csv2_ullong_pos695(X,Y) get_csv2_ullong((X),(Y),695) +#define get_csv2_ip_pos695(X,Y) get_csv2_ip((X),(Y),695) +#define get_csv2_ipv6_pos695(X,Y) get_csv2_ipv6((X),(Y),695) +#define get_csv2_string_pos695(X,Y) get_csv2_string((X),(Y),695) +#define get_csv2_v_str_pos695(X,Y) get_csv2_string((X),(Y),695) +#define get_csv2_bool_pos695(X,Y) get_csv2_bool((X),(Y),695) +#define get_csv2_int_pos695(X,Y) get_csv2_int((X),(Y),695) +#define get_csv2_llong_pos695(X,Y) get_csv2_llong((X),(Y),695) +#define get_csv2_float_pos695(X,Y) get_csv2_float((X),(Y),695) +#define get_csv2_uint_pos696(X,Y) get_csv2_uint((X),(Y),696) +#define get_csv2_ullong_pos696(X,Y) get_csv2_ullong((X),(Y),696) +#define get_csv2_ip_pos696(X,Y) get_csv2_ip((X),(Y),696) +#define get_csv2_ipv6_pos696(X,Y) get_csv2_ipv6((X),(Y),696) +#define get_csv2_string_pos696(X,Y) get_csv2_string((X),(Y),696) +#define get_csv2_v_str_pos696(X,Y) get_csv2_string((X),(Y),696) +#define get_csv2_bool_pos696(X,Y) get_csv2_bool((X),(Y),696) +#define get_csv2_int_pos696(X,Y) get_csv2_int((X),(Y),696) +#define get_csv2_llong_pos696(X,Y) get_csv2_llong((X),(Y),696) +#define get_csv2_float_pos696(X,Y) get_csv2_float((X),(Y),696) +#define get_csv2_uint_pos697(X,Y) get_csv2_uint((X),(Y),697) +#define get_csv2_ullong_pos697(X,Y) get_csv2_ullong((X),(Y),697) +#define get_csv2_ip_pos697(X,Y) get_csv2_ip((X),(Y),697) +#define get_csv2_ipv6_pos697(X,Y) get_csv2_ipv6((X),(Y),697) +#define get_csv2_string_pos697(X,Y) get_csv2_string((X),(Y),697) +#define get_csv2_v_str_pos697(X,Y) get_csv2_string((X),(Y),697) +#define get_csv2_bool_pos697(X,Y) get_csv2_bool((X),(Y),697) +#define get_csv2_int_pos697(X,Y) get_csv2_int((X),(Y),697) +#define get_csv2_llong_pos697(X,Y) get_csv2_llong((X),(Y),697) +#define get_csv2_float_pos697(X,Y) get_csv2_float((X),(Y),697) +#define get_csv2_uint_pos698(X,Y) get_csv2_uint((X),(Y),698) +#define get_csv2_ullong_pos698(X,Y) get_csv2_ullong((X),(Y),698) +#define get_csv2_ip_pos698(X,Y) get_csv2_ip((X),(Y),698) +#define get_csv2_ipv6_pos698(X,Y) get_csv2_ipv6((X),(Y),698) +#define get_csv2_string_pos698(X,Y) get_csv2_string((X),(Y),698) +#define get_csv2_v_str_pos698(X,Y) get_csv2_string((X),(Y),698) +#define get_csv2_bool_pos698(X,Y) get_csv2_bool((X),(Y),698) +#define get_csv2_int_pos698(X,Y) get_csv2_int((X),(Y),698) +#define get_csv2_llong_pos698(X,Y) get_csv2_llong((X),(Y),698) +#define get_csv2_float_pos698(X,Y) get_csv2_float((X),(Y),698) +#define get_csv2_uint_pos699(X,Y) get_csv2_uint((X),(Y),699) +#define get_csv2_ullong_pos699(X,Y) get_csv2_ullong((X),(Y),699) +#define get_csv2_ip_pos699(X,Y) get_csv2_ip((X),(Y),699) +#define get_csv2_ipv6_pos699(X,Y) get_csv2_ipv6((X),(Y),699) +#define get_csv2_string_pos699(X,Y) get_csv2_string((X),(Y),699) +#define get_csv2_v_str_pos699(X,Y) get_csv2_string((X),(Y),699) +#define get_csv2_bool_pos699(X,Y) get_csv2_bool((X),(Y),699) +#define get_csv2_int_pos699(X,Y) get_csv2_int((X),(Y),699) +#define get_csv2_llong_pos699(X,Y) get_csv2_llong((X),(Y),699) +#define get_csv2_float_pos699(X,Y) get_csv2_float((X),(Y),699) +#define get_csv2_uint_pos700(X,Y) get_csv2_uint((X),(Y),700) +#define get_csv2_ullong_pos700(X,Y) get_csv2_ullong((X),(Y),700) +#define get_csv2_ip_pos700(X,Y) get_csv2_ip((X),(Y),700) +#define get_csv2_ipv6_pos700(X,Y) get_csv2_ipv6((X),(Y),700) +#define get_csv2_string_pos700(X,Y) get_csv2_string((X),(Y),700) +#define get_csv2_v_str_pos700(X,Y) get_csv2_string((X),(Y),700) +#define get_csv2_bool_pos700(X,Y) get_csv2_bool((X),(Y),700) +#define get_csv2_int_pos700(X,Y) get_csv2_int((X),(Y),700) +#define get_csv2_llong_pos700(X,Y) get_csv2_llong((X),(Y),700) +#define get_csv2_float_pos700(X,Y) get_csv2_float((X),(Y),700) +#define get_csv2_uint_pos701(X,Y) get_csv2_uint((X),(Y),701) +#define get_csv2_ullong_pos701(X,Y) get_csv2_ullong((X),(Y),701) +#define get_csv2_ip_pos701(X,Y) get_csv2_ip((X),(Y),701) +#define get_csv2_ipv6_pos701(X,Y) get_csv2_ipv6((X),(Y),701) +#define get_csv2_string_pos701(X,Y) get_csv2_string((X),(Y),701) +#define get_csv2_v_str_pos701(X,Y) get_csv2_string((X),(Y),701) +#define get_csv2_bool_pos701(X,Y) get_csv2_bool((X),(Y),701) +#define get_csv2_int_pos701(X,Y) get_csv2_int((X),(Y),701) +#define get_csv2_llong_pos701(X,Y) get_csv2_llong((X),(Y),701) +#define get_csv2_float_pos701(X,Y) get_csv2_float((X),(Y),701) +#define get_csv2_uint_pos702(X,Y) get_csv2_uint((X),(Y),702) +#define get_csv2_ullong_pos702(X,Y) get_csv2_ullong((X),(Y),702) +#define get_csv2_ip_pos702(X,Y) get_csv2_ip((X),(Y),702) +#define get_csv2_ipv6_pos702(X,Y) get_csv2_ipv6((X),(Y),702) +#define get_csv2_string_pos702(X,Y) get_csv2_string((X),(Y),702) +#define get_csv2_v_str_pos702(X,Y) get_csv2_string((X),(Y),702) +#define get_csv2_bool_pos702(X,Y) get_csv2_bool((X),(Y),702) +#define get_csv2_int_pos702(X,Y) get_csv2_int((X),(Y),702) +#define get_csv2_llong_pos702(X,Y) get_csv2_llong((X),(Y),702) +#define get_csv2_float_pos702(X,Y) get_csv2_float((X),(Y),702) +#define get_csv2_uint_pos703(X,Y) get_csv2_uint((X),(Y),703) +#define get_csv2_ullong_pos703(X,Y) get_csv2_ullong((X),(Y),703) +#define get_csv2_ip_pos703(X,Y) get_csv2_ip((X),(Y),703) +#define get_csv2_ipv6_pos703(X,Y) get_csv2_ipv6((X),(Y),703) +#define get_csv2_string_pos703(X,Y) get_csv2_string((X),(Y),703) +#define get_csv2_v_str_pos703(X,Y) get_csv2_string((X),(Y),703) +#define get_csv2_bool_pos703(X,Y) get_csv2_bool((X),(Y),703) +#define get_csv2_int_pos703(X,Y) get_csv2_int((X),(Y),703) +#define get_csv2_llong_pos703(X,Y) get_csv2_llong((X),(Y),703) +#define get_csv2_float_pos703(X,Y) get_csv2_float((X),(Y),703) +#define get_csv2_uint_pos704(X,Y) get_csv2_uint((X),(Y),704) +#define get_csv2_ullong_pos704(X,Y) get_csv2_ullong((X),(Y),704) +#define get_csv2_ip_pos704(X,Y) get_csv2_ip((X),(Y),704) +#define get_csv2_ipv6_pos704(X,Y) get_csv2_ipv6((X),(Y),704) +#define get_csv2_string_pos704(X,Y) get_csv2_string((X),(Y),704) +#define get_csv2_v_str_pos704(X,Y) get_csv2_string((X),(Y),704) +#define get_csv2_bool_pos704(X,Y) get_csv2_bool((X),(Y),704) +#define get_csv2_int_pos704(X,Y) get_csv2_int((X),(Y),704) +#define get_csv2_llong_pos704(X,Y) get_csv2_llong((X),(Y),704) +#define get_csv2_float_pos704(X,Y) get_csv2_float((X),(Y),704) +#define get_csv2_uint_pos705(X,Y) get_csv2_uint((X),(Y),705) +#define get_csv2_ullong_pos705(X,Y) get_csv2_ullong((X),(Y),705) +#define get_csv2_ip_pos705(X,Y) get_csv2_ip((X),(Y),705) +#define get_csv2_ipv6_pos705(X,Y) get_csv2_ipv6((X),(Y),705) +#define get_csv2_string_pos705(X,Y) get_csv2_string((X),(Y),705) +#define get_csv2_v_str_pos705(X,Y) get_csv2_string((X),(Y),705) +#define get_csv2_bool_pos705(X,Y) get_csv2_bool((X),(Y),705) +#define get_csv2_int_pos705(X,Y) get_csv2_int((X),(Y),705) +#define get_csv2_llong_pos705(X,Y) get_csv2_llong((X),(Y),705) +#define get_csv2_float_pos705(X,Y) get_csv2_float((X),(Y),705) +#define get_csv2_uint_pos706(X,Y) get_csv2_uint((X),(Y),706) +#define get_csv2_ullong_pos706(X,Y) get_csv2_ullong((X),(Y),706) +#define get_csv2_ip_pos706(X,Y) get_csv2_ip((X),(Y),706) +#define get_csv2_ipv6_pos706(X,Y) get_csv2_ipv6((X),(Y),706) +#define get_csv2_string_pos706(X,Y) get_csv2_string((X),(Y),706) +#define get_csv2_v_str_pos706(X,Y) get_csv2_string((X),(Y),706) +#define get_csv2_bool_pos706(X,Y) get_csv2_bool((X),(Y),706) +#define get_csv2_int_pos706(X,Y) get_csv2_int((X),(Y),706) +#define get_csv2_llong_pos706(X,Y) get_csv2_llong((X),(Y),706) +#define get_csv2_float_pos706(X,Y) get_csv2_float((X),(Y),706) +#define get_csv2_uint_pos707(X,Y) get_csv2_uint((X),(Y),707) +#define get_csv2_ullong_pos707(X,Y) get_csv2_ullong((X),(Y),707) +#define get_csv2_ip_pos707(X,Y) get_csv2_ip((X),(Y),707) +#define get_csv2_ipv6_pos707(X,Y) get_csv2_ipv6((X),(Y),707) +#define get_csv2_string_pos707(X,Y) get_csv2_string((X),(Y),707) +#define get_csv2_v_str_pos707(X,Y) get_csv2_string((X),(Y),707) +#define get_csv2_bool_pos707(X,Y) get_csv2_bool((X),(Y),707) +#define get_csv2_int_pos707(X,Y) get_csv2_int((X),(Y),707) +#define get_csv2_llong_pos707(X,Y) get_csv2_llong((X),(Y),707) +#define get_csv2_float_pos707(X,Y) get_csv2_float((X),(Y),707) +#define get_csv2_uint_pos708(X,Y) get_csv2_uint((X),(Y),708) +#define get_csv2_ullong_pos708(X,Y) get_csv2_ullong((X),(Y),708) +#define get_csv2_ip_pos708(X,Y) get_csv2_ip((X),(Y),708) +#define get_csv2_ipv6_pos708(X,Y) get_csv2_ipv6((X),(Y),708) +#define get_csv2_string_pos708(X,Y) get_csv2_string((X),(Y),708) +#define get_csv2_v_str_pos708(X,Y) get_csv2_string((X),(Y),708) +#define get_csv2_bool_pos708(X,Y) get_csv2_bool((X),(Y),708) +#define get_csv2_int_pos708(X,Y) get_csv2_int((X),(Y),708) +#define get_csv2_llong_pos708(X,Y) get_csv2_llong((X),(Y),708) +#define get_csv2_float_pos708(X,Y) get_csv2_float((X),(Y),708) +#define get_csv2_uint_pos709(X,Y) get_csv2_uint((X),(Y),709) +#define get_csv2_ullong_pos709(X,Y) get_csv2_ullong((X),(Y),709) +#define get_csv2_ip_pos709(X,Y) get_csv2_ip((X),(Y),709) +#define get_csv2_ipv6_pos709(X,Y) get_csv2_ipv6((X),(Y),709) +#define get_csv2_string_pos709(X,Y) get_csv2_string((X),(Y),709) +#define get_csv2_v_str_pos709(X,Y) get_csv2_string((X),(Y),709) +#define get_csv2_bool_pos709(X,Y) get_csv2_bool((X),(Y),709) +#define get_csv2_int_pos709(X,Y) get_csv2_int((X),(Y),709) +#define get_csv2_llong_pos709(X,Y) get_csv2_llong((X),(Y),709) +#define get_csv2_float_pos709(X,Y) get_csv2_float((X),(Y),709) +#define get_csv2_uint_pos710(X,Y) get_csv2_uint((X),(Y),710) +#define get_csv2_ullong_pos710(X,Y) get_csv2_ullong((X),(Y),710) +#define get_csv2_ip_pos710(X,Y) get_csv2_ip((X),(Y),710) +#define get_csv2_ipv6_pos710(X,Y) get_csv2_ipv6((X),(Y),710) +#define get_csv2_string_pos710(X,Y) get_csv2_string((X),(Y),710) +#define get_csv2_v_str_pos710(X,Y) get_csv2_string((X),(Y),710) +#define get_csv2_bool_pos710(X,Y) get_csv2_bool((X),(Y),710) +#define get_csv2_int_pos710(X,Y) get_csv2_int((X),(Y),710) +#define get_csv2_llong_pos710(X,Y) get_csv2_llong((X),(Y),710) +#define get_csv2_float_pos710(X,Y) get_csv2_float((X),(Y),710) +#define get_csv2_uint_pos711(X,Y) get_csv2_uint((X),(Y),711) +#define get_csv2_ullong_pos711(X,Y) get_csv2_ullong((X),(Y),711) +#define get_csv2_ip_pos711(X,Y) get_csv2_ip((X),(Y),711) +#define get_csv2_ipv6_pos711(X,Y) get_csv2_ipv6((X),(Y),711) +#define get_csv2_string_pos711(X,Y) get_csv2_string((X),(Y),711) +#define get_csv2_v_str_pos711(X,Y) get_csv2_string((X),(Y),711) +#define get_csv2_bool_pos711(X,Y) get_csv2_bool((X),(Y),711) +#define get_csv2_int_pos711(X,Y) get_csv2_int((X),(Y),711) +#define get_csv2_llong_pos711(X,Y) get_csv2_llong((X),(Y),711) +#define get_csv2_float_pos711(X,Y) get_csv2_float((X),(Y),711) +#define get_csv2_uint_pos712(X,Y) get_csv2_uint((X),(Y),712) +#define get_csv2_ullong_pos712(X,Y) get_csv2_ullong((X),(Y),712) +#define get_csv2_ip_pos712(X,Y) get_csv2_ip((X),(Y),712) +#define get_csv2_ipv6_pos712(X,Y) get_csv2_ipv6((X),(Y),712) +#define get_csv2_string_pos712(X,Y) get_csv2_string((X),(Y),712) +#define get_csv2_v_str_pos712(X,Y) get_csv2_string((X),(Y),712) +#define get_csv2_bool_pos712(X,Y) get_csv2_bool((X),(Y),712) +#define get_csv2_int_pos712(X,Y) get_csv2_int((X),(Y),712) +#define get_csv2_llong_pos712(X,Y) get_csv2_llong((X),(Y),712) +#define get_csv2_float_pos712(X,Y) get_csv2_float((X),(Y),712) +#define get_csv2_uint_pos713(X,Y) get_csv2_uint((X),(Y),713) +#define get_csv2_ullong_pos713(X,Y) get_csv2_ullong((X),(Y),713) +#define get_csv2_ip_pos713(X,Y) get_csv2_ip((X),(Y),713) +#define get_csv2_ipv6_pos713(X,Y) get_csv2_ipv6((X),(Y),713) +#define get_csv2_string_pos713(X,Y) get_csv2_string((X),(Y),713) +#define get_csv2_v_str_pos713(X,Y) get_csv2_string((X),(Y),713) +#define get_csv2_bool_pos713(X,Y) get_csv2_bool((X),(Y),713) +#define get_csv2_int_pos713(X,Y) get_csv2_int((X),(Y),713) +#define get_csv2_llong_pos713(X,Y) get_csv2_llong((X),(Y),713) +#define get_csv2_float_pos713(X,Y) get_csv2_float((X),(Y),713) +#define get_csv2_uint_pos714(X,Y) get_csv2_uint((X),(Y),714) +#define get_csv2_ullong_pos714(X,Y) get_csv2_ullong((X),(Y),714) +#define get_csv2_ip_pos714(X,Y) get_csv2_ip((X),(Y),714) +#define get_csv2_ipv6_pos714(X,Y) get_csv2_ipv6((X),(Y),714) +#define get_csv2_string_pos714(X,Y) get_csv2_string((X),(Y),714) +#define get_csv2_v_str_pos714(X,Y) get_csv2_string((X),(Y),714) +#define get_csv2_bool_pos714(X,Y) get_csv2_bool((X),(Y),714) +#define get_csv2_int_pos714(X,Y) get_csv2_int((X),(Y),714) +#define get_csv2_llong_pos714(X,Y) get_csv2_llong((X),(Y),714) +#define get_csv2_float_pos714(X,Y) get_csv2_float((X),(Y),714) +#define get_csv2_uint_pos715(X,Y) get_csv2_uint((X),(Y),715) +#define get_csv2_ullong_pos715(X,Y) get_csv2_ullong((X),(Y),715) +#define get_csv2_ip_pos715(X,Y) get_csv2_ip((X),(Y),715) +#define get_csv2_ipv6_pos715(X,Y) get_csv2_ipv6((X),(Y),715) +#define get_csv2_string_pos715(X,Y) get_csv2_string((X),(Y),715) +#define get_csv2_v_str_pos715(X,Y) get_csv2_string((X),(Y),715) +#define get_csv2_bool_pos715(X,Y) get_csv2_bool((X),(Y),715) +#define get_csv2_int_pos715(X,Y) get_csv2_int((X),(Y),715) +#define get_csv2_llong_pos715(X,Y) get_csv2_llong((X),(Y),715) +#define get_csv2_float_pos715(X,Y) get_csv2_float((X),(Y),715) +#define get_csv2_uint_pos716(X,Y) get_csv2_uint((X),(Y),716) +#define get_csv2_ullong_pos716(X,Y) get_csv2_ullong((X),(Y),716) +#define get_csv2_ip_pos716(X,Y) get_csv2_ip((X),(Y),716) +#define get_csv2_ipv6_pos716(X,Y) get_csv2_ipv6((X),(Y),716) +#define get_csv2_string_pos716(X,Y) get_csv2_string((X),(Y),716) +#define get_csv2_v_str_pos716(X,Y) get_csv2_string((X),(Y),716) +#define get_csv2_bool_pos716(X,Y) get_csv2_bool((X),(Y),716) +#define get_csv2_int_pos716(X,Y) get_csv2_int((X),(Y),716) +#define get_csv2_llong_pos716(X,Y) get_csv2_llong((X),(Y),716) +#define get_csv2_float_pos716(X,Y) get_csv2_float((X),(Y),716) +#define get_csv2_uint_pos717(X,Y) get_csv2_uint((X),(Y),717) +#define get_csv2_ullong_pos717(X,Y) get_csv2_ullong((X),(Y),717) +#define get_csv2_ip_pos717(X,Y) get_csv2_ip((X),(Y),717) +#define get_csv2_ipv6_pos717(X,Y) get_csv2_ipv6((X),(Y),717) +#define get_csv2_string_pos717(X,Y) get_csv2_string((X),(Y),717) +#define get_csv2_v_str_pos717(X,Y) get_csv2_string((X),(Y),717) +#define get_csv2_bool_pos717(X,Y) get_csv2_bool((X),(Y),717) +#define get_csv2_int_pos717(X,Y) get_csv2_int((X),(Y),717) +#define get_csv2_llong_pos717(X,Y) get_csv2_llong((X),(Y),717) +#define get_csv2_float_pos717(X,Y) get_csv2_float((X),(Y),717) +#define get_csv2_uint_pos718(X,Y) get_csv2_uint((X),(Y),718) +#define get_csv2_ullong_pos718(X,Y) get_csv2_ullong((X),(Y),718) +#define get_csv2_ip_pos718(X,Y) get_csv2_ip((X),(Y),718) +#define get_csv2_ipv6_pos718(X,Y) get_csv2_ipv6((X),(Y),718) +#define get_csv2_string_pos718(X,Y) get_csv2_string((X),(Y),718) +#define get_csv2_v_str_pos718(X,Y) get_csv2_string((X),(Y),718) +#define get_csv2_bool_pos718(X,Y) get_csv2_bool((X),(Y),718) +#define get_csv2_int_pos718(X,Y) get_csv2_int((X),(Y),718) +#define get_csv2_llong_pos718(X,Y) get_csv2_llong((X),(Y),718) +#define get_csv2_float_pos718(X,Y) get_csv2_float((X),(Y),718) +#define get_csv2_uint_pos719(X,Y) get_csv2_uint((X),(Y),719) +#define get_csv2_ullong_pos719(X,Y) get_csv2_ullong((X),(Y),719) +#define get_csv2_ip_pos719(X,Y) get_csv2_ip((X),(Y),719) +#define get_csv2_ipv6_pos719(X,Y) get_csv2_ipv6((X),(Y),719) +#define get_csv2_string_pos719(X,Y) get_csv2_string((X),(Y),719) +#define get_csv2_v_str_pos719(X,Y) get_csv2_string((X),(Y),719) +#define get_csv2_bool_pos719(X,Y) get_csv2_bool((X),(Y),719) +#define get_csv2_int_pos719(X,Y) get_csv2_int((X),(Y),719) +#define get_csv2_llong_pos719(X,Y) get_csv2_llong((X),(Y),719) +#define get_csv2_float_pos719(X,Y) get_csv2_float((X),(Y),719) +#define get_csv2_uint_pos720(X,Y) get_csv2_uint((X),(Y),720) +#define get_csv2_ullong_pos720(X,Y) get_csv2_ullong((X),(Y),720) +#define get_csv2_ip_pos720(X,Y) get_csv2_ip((X),(Y),720) +#define get_csv2_ipv6_pos720(X,Y) get_csv2_ipv6((X),(Y),720) +#define get_csv2_string_pos720(X,Y) get_csv2_string((X),(Y),720) +#define get_csv2_v_str_pos720(X,Y) get_csv2_string((X),(Y),720) +#define get_csv2_bool_pos720(X,Y) get_csv2_bool((X),(Y),720) +#define get_csv2_int_pos720(X,Y) get_csv2_int((X),(Y),720) +#define get_csv2_llong_pos720(X,Y) get_csv2_llong((X),(Y),720) +#define get_csv2_float_pos720(X,Y) get_csv2_float((X),(Y),720) +#define get_csv2_uint_pos721(X,Y) get_csv2_uint((X),(Y),721) +#define get_csv2_ullong_pos721(X,Y) get_csv2_ullong((X),(Y),721) +#define get_csv2_ip_pos721(X,Y) get_csv2_ip((X),(Y),721) +#define get_csv2_ipv6_pos721(X,Y) get_csv2_ipv6((X),(Y),721) +#define get_csv2_string_pos721(X,Y) get_csv2_string((X),(Y),721) +#define get_csv2_v_str_pos721(X,Y) get_csv2_string((X),(Y),721) +#define get_csv2_bool_pos721(X,Y) get_csv2_bool((X),(Y),721) +#define get_csv2_int_pos721(X,Y) get_csv2_int((X),(Y),721) +#define get_csv2_llong_pos721(X,Y) get_csv2_llong((X),(Y),721) +#define get_csv2_float_pos721(X,Y) get_csv2_float((X),(Y),721) +#define get_csv2_uint_pos722(X,Y) get_csv2_uint((X),(Y),722) +#define get_csv2_ullong_pos722(X,Y) get_csv2_ullong((X),(Y),722) +#define get_csv2_ip_pos722(X,Y) get_csv2_ip((X),(Y),722) +#define get_csv2_ipv6_pos722(X,Y) get_csv2_ipv6((X),(Y),722) +#define get_csv2_string_pos722(X,Y) get_csv2_string((X),(Y),722) +#define get_csv2_v_str_pos722(X,Y) get_csv2_string((X),(Y),722) +#define get_csv2_bool_pos722(X,Y) get_csv2_bool((X),(Y),722) +#define get_csv2_int_pos722(X,Y) get_csv2_int((X),(Y),722) +#define get_csv2_llong_pos722(X,Y) get_csv2_llong((X),(Y),722) +#define get_csv2_float_pos722(X,Y) get_csv2_float((X),(Y),722) +#define get_csv2_uint_pos723(X,Y) get_csv2_uint((X),(Y),723) +#define get_csv2_ullong_pos723(X,Y) get_csv2_ullong((X),(Y),723) +#define get_csv2_ip_pos723(X,Y) get_csv2_ip((X),(Y),723) +#define get_csv2_ipv6_pos723(X,Y) get_csv2_ipv6((X),(Y),723) +#define get_csv2_string_pos723(X,Y) get_csv2_string((X),(Y),723) +#define get_csv2_v_str_pos723(X,Y) get_csv2_string((X),(Y),723) +#define get_csv2_bool_pos723(X,Y) get_csv2_bool((X),(Y),723) +#define get_csv2_int_pos723(X,Y) get_csv2_int((X),(Y),723) +#define get_csv2_llong_pos723(X,Y) get_csv2_llong((X),(Y),723) +#define get_csv2_float_pos723(X,Y) get_csv2_float((X),(Y),723) +#define get_csv2_uint_pos724(X,Y) get_csv2_uint((X),(Y),724) +#define get_csv2_ullong_pos724(X,Y) get_csv2_ullong((X),(Y),724) +#define get_csv2_ip_pos724(X,Y) get_csv2_ip((X),(Y),724) +#define get_csv2_ipv6_pos724(X,Y) get_csv2_ipv6((X),(Y),724) +#define get_csv2_string_pos724(X,Y) get_csv2_string((X),(Y),724) +#define get_csv2_v_str_pos724(X,Y) get_csv2_string((X),(Y),724) +#define get_csv2_bool_pos724(X,Y) get_csv2_bool((X),(Y),724) +#define get_csv2_int_pos724(X,Y) get_csv2_int((X),(Y),724) +#define get_csv2_llong_pos724(X,Y) get_csv2_llong((X),(Y),724) +#define get_csv2_float_pos724(X,Y) get_csv2_float((X),(Y),724) +#define get_csv2_uint_pos725(X,Y) get_csv2_uint((X),(Y),725) +#define get_csv2_ullong_pos725(X,Y) get_csv2_ullong((X),(Y),725) +#define get_csv2_ip_pos725(X,Y) get_csv2_ip((X),(Y),725) +#define get_csv2_ipv6_pos725(X,Y) get_csv2_ipv6((X),(Y),725) +#define get_csv2_string_pos725(X,Y) get_csv2_string((X),(Y),725) +#define get_csv2_v_str_pos725(X,Y) get_csv2_string((X),(Y),725) +#define get_csv2_bool_pos725(X,Y) get_csv2_bool((X),(Y),725) +#define get_csv2_int_pos725(X,Y) get_csv2_int((X),(Y),725) +#define get_csv2_llong_pos725(X,Y) get_csv2_llong((X),(Y),725) +#define get_csv2_float_pos725(X,Y) get_csv2_float((X),(Y),725) +#define get_csv2_uint_pos726(X,Y) get_csv2_uint((X),(Y),726) +#define get_csv2_ullong_pos726(X,Y) get_csv2_ullong((X),(Y),726) +#define get_csv2_ip_pos726(X,Y) get_csv2_ip((X),(Y),726) +#define get_csv2_ipv6_pos726(X,Y) get_csv2_ipv6((X),(Y),726) +#define get_csv2_string_pos726(X,Y) get_csv2_string((X),(Y),726) +#define get_csv2_v_str_pos726(X,Y) get_csv2_string((X),(Y),726) +#define get_csv2_bool_pos726(X,Y) get_csv2_bool((X),(Y),726) +#define get_csv2_int_pos726(X,Y) get_csv2_int((X),(Y),726) +#define get_csv2_llong_pos726(X,Y) get_csv2_llong((X),(Y),726) +#define get_csv2_float_pos726(X,Y) get_csv2_float((X),(Y),726) +#define get_csv2_uint_pos727(X,Y) get_csv2_uint((X),(Y),727) +#define get_csv2_ullong_pos727(X,Y) get_csv2_ullong((X),(Y),727) +#define get_csv2_ip_pos727(X,Y) get_csv2_ip((X),(Y),727) +#define get_csv2_ipv6_pos727(X,Y) get_csv2_ipv6((X),(Y),727) +#define get_csv2_string_pos727(X,Y) get_csv2_string((X),(Y),727) +#define get_csv2_v_str_pos727(X,Y) get_csv2_string((X),(Y),727) +#define get_csv2_bool_pos727(X,Y) get_csv2_bool((X),(Y),727) +#define get_csv2_int_pos727(X,Y) get_csv2_int((X),(Y),727) +#define get_csv2_llong_pos727(X,Y) get_csv2_llong((X),(Y),727) +#define get_csv2_float_pos727(X,Y) get_csv2_float((X),(Y),727) +#define get_csv2_uint_pos728(X,Y) get_csv2_uint((X),(Y),728) +#define get_csv2_ullong_pos728(X,Y) get_csv2_ullong((X),(Y),728) +#define get_csv2_ip_pos728(X,Y) get_csv2_ip((X),(Y),728) +#define get_csv2_ipv6_pos728(X,Y) get_csv2_ipv6((X),(Y),728) +#define get_csv2_string_pos728(X,Y) get_csv2_string((X),(Y),728) +#define get_csv2_v_str_pos728(X,Y) get_csv2_string((X),(Y),728) +#define get_csv2_bool_pos728(X,Y) get_csv2_bool((X),(Y),728) +#define get_csv2_int_pos728(X,Y) get_csv2_int((X),(Y),728) +#define get_csv2_llong_pos728(X,Y) get_csv2_llong((X),(Y),728) +#define get_csv2_float_pos728(X,Y) get_csv2_float((X),(Y),728) +#define get_csv2_uint_pos729(X,Y) get_csv2_uint((X),(Y),729) +#define get_csv2_ullong_pos729(X,Y) get_csv2_ullong((X),(Y),729) +#define get_csv2_ip_pos729(X,Y) get_csv2_ip((X),(Y),729) +#define get_csv2_ipv6_pos729(X,Y) get_csv2_ipv6((X),(Y),729) +#define get_csv2_string_pos729(X,Y) get_csv2_string((X),(Y),729) +#define get_csv2_v_str_pos729(X,Y) get_csv2_string((X),(Y),729) +#define get_csv2_bool_pos729(X,Y) get_csv2_bool((X),(Y),729) +#define get_csv2_int_pos729(X,Y) get_csv2_int((X),(Y),729) +#define get_csv2_llong_pos729(X,Y) get_csv2_llong((X),(Y),729) +#define get_csv2_float_pos729(X,Y) get_csv2_float((X),(Y),729) +#define get_csv2_uint_pos730(X,Y) get_csv2_uint((X),(Y),730) +#define get_csv2_ullong_pos730(X,Y) get_csv2_ullong((X),(Y),730) +#define get_csv2_ip_pos730(X,Y) get_csv2_ip((X),(Y),730) +#define get_csv2_ipv6_pos730(X,Y) get_csv2_ipv6((X),(Y),730) +#define get_csv2_string_pos730(X,Y) get_csv2_string((X),(Y),730) +#define get_csv2_v_str_pos730(X,Y) get_csv2_string((X),(Y),730) +#define get_csv2_bool_pos730(X,Y) get_csv2_bool((X),(Y),730) +#define get_csv2_int_pos730(X,Y) get_csv2_int((X),(Y),730) +#define get_csv2_llong_pos730(X,Y) get_csv2_llong((X),(Y),730) +#define get_csv2_float_pos730(X,Y) get_csv2_float((X),(Y),730) +#define get_csv2_uint_pos731(X,Y) get_csv2_uint((X),(Y),731) +#define get_csv2_ullong_pos731(X,Y) get_csv2_ullong((X),(Y),731) +#define get_csv2_ip_pos731(X,Y) get_csv2_ip((X),(Y),731) +#define get_csv2_ipv6_pos731(X,Y) get_csv2_ipv6((X),(Y),731) +#define get_csv2_string_pos731(X,Y) get_csv2_string((X),(Y),731) +#define get_csv2_v_str_pos731(X,Y) get_csv2_string((X),(Y),731) +#define get_csv2_bool_pos731(X,Y) get_csv2_bool((X),(Y),731) +#define get_csv2_int_pos731(X,Y) get_csv2_int((X),(Y),731) +#define get_csv2_llong_pos731(X,Y) get_csv2_llong((X),(Y),731) +#define get_csv2_float_pos731(X,Y) get_csv2_float((X),(Y),731) +#define get_csv2_uint_pos732(X,Y) get_csv2_uint((X),(Y),732) +#define get_csv2_ullong_pos732(X,Y) get_csv2_ullong((X),(Y),732) +#define get_csv2_ip_pos732(X,Y) get_csv2_ip((X),(Y),732) +#define get_csv2_ipv6_pos732(X,Y) get_csv2_ipv6((X),(Y),732) +#define get_csv2_string_pos732(X,Y) get_csv2_string((X),(Y),732) +#define get_csv2_v_str_pos732(X,Y) get_csv2_string((X),(Y),732) +#define get_csv2_bool_pos732(X,Y) get_csv2_bool((X),(Y),732) +#define get_csv2_int_pos732(X,Y) get_csv2_int((X),(Y),732) +#define get_csv2_llong_pos732(X,Y) get_csv2_llong((X),(Y),732) +#define get_csv2_float_pos732(X,Y) get_csv2_float((X),(Y),732) +#define get_csv2_uint_pos733(X,Y) get_csv2_uint((X),(Y),733) +#define get_csv2_ullong_pos733(X,Y) get_csv2_ullong((X),(Y),733) +#define get_csv2_ip_pos733(X,Y) get_csv2_ip((X),(Y),733) +#define get_csv2_ipv6_pos733(X,Y) get_csv2_ipv6((X),(Y),733) +#define get_csv2_string_pos733(X,Y) get_csv2_string((X),(Y),733) +#define get_csv2_v_str_pos733(X,Y) get_csv2_string((X),(Y),733) +#define get_csv2_bool_pos733(X,Y) get_csv2_bool((X),(Y),733) +#define get_csv2_int_pos733(X,Y) get_csv2_int((X),(Y),733) +#define get_csv2_llong_pos733(X,Y) get_csv2_llong((X),(Y),733) +#define get_csv2_float_pos733(X,Y) get_csv2_float((X),(Y),733) +#define get_csv2_uint_pos734(X,Y) get_csv2_uint((X),(Y),734) +#define get_csv2_ullong_pos734(X,Y) get_csv2_ullong((X),(Y),734) +#define get_csv2_ip_pos734(X,Y) get_csv2_ip((X),(Y),734) +#define get_csv2_ipv6_pos734(X,Y) get_csv2_ipv6((X),(Y),734) +#define get_csv2_string_pos734(X,Y) get_csv2_string((X),(Y),734) +#define get_csv2_v_str_pos734(X,Y) get_csv2_string((X),(Y),734) +#define get_csv2_bool_pos734(X,Y) get_csv2_bool((X),(Y),734) +#define get_csv2_int_pos734(X,Y) get_csv2_int((X),(Y),734) +#define get_csv2_llong_pos734(X,Y) get_csv2_llong((X),(Y),734) +#define get_csv2_float_pos734(X,Y) get_csv2_float((X),(Y),734) +#define get_csv2_uint_pos735(X,Y) get_csv2_uint((X),(Y),735) +#define get_csv2_ullong_pos735(X,Y) get_csv2_ullong((X),(Y),735) +#define get_csv2_ip_pos735(X,Y) get_csv2_ip((X),(Y),735) +#define get_csv2_ipv6_pos735(X,Y) get_csv2_ipv6((X),(Y),735) +#define get_csv2_string_pos735(X,Y) get_csv2_string((X),(Y),735) +#define get_csv2_v_str_pos735(X,Y) get_csv2_string((X),(Y),735) +#define get_csv2_bool_pos735(X,Y) get_csv2_bool((X),(Y),735) +#define get_csv2_int_pos735(X,Y) get_csv2_int((X),(Y),735) +#define get_csv2_llong_pos735(X,Y) get_csv2_llong((X),(Y),735) +#define get_csv2_float_pos735(X,Y) get_csv2_float((X),(Y),735) +#define get_csv2_uint_pos736(X,Y) get_csv2_uint((X),(Y),736) +#define get_csv2_ullong_pos736(X,Y) get_csv2_ullong((X),(Y),736) +#define get_csv2_ip_pos736(X,Y) get_csv2_ip((X),(Y),736) +#define get_csv2_ipv6_pos736(X,Y) get_csv2_ipv6((X),(Y),736) +#define get_csv2_string_pos736(X,Y) get_csv2_string((X),(Y),736) +#define get_csv2_v_str_pos736(X,Y) get_csv2_string((X),(Y),736) +#define get_csv2_bool_pos736(X,Y) get_csv2_bool((X),(Y),736) +#define get_csv2_int_pos736(X,Y) get_csv2_int((X),(Y),736) +#define get_csv2_llong_pos736(X,Y) get_csv2_llong((X),(Y),736) +#define get_csv2_float_pos736(X,Y) get_csv2_float((X),(Y),736) +#define get_csv2_uint_pos737(X,Y) get_csv2_uint((X),(Y),737) +#define get_csv2_ullong_pos737(X,Y) get_csv2_ullong((X),(Y),737) +#define get_csv2_ip_pos737(X,Y) get_csv2_ip((X),(Y),737) +#define get_csv2_ipv6_pos737(X,Y) get_csv2_ipv6((X),(Y),737) +#define get_csv2_string_pos737(X,Y) get_csv2_string((X),(Y),737) +#define get_csv2_v_str_pos737(X,Y) get_csv2_string((X),(Y),737) +#define get_csv2_bool_pos737(X,Y) get_csv2_bool((X),(Y),737) +#define get_csv2_int_pos737(X,Y) get_csv2_int((X),(Y),737) +#define get_csv2_llong_pos737(X,Y) get_csv2_llong((X),(Y),737) +#define get_csv2_float_pos737(X,Y) get_csv2_float((X),(Y),737) +#define get_csv2_uint_pos738(X,Y) get_csv2_uint((X),(Y),738) +#define get_csv2_ullong_pos738(X,Y) get_csv2_ullong((X),(Y),738) +#define get_csv2_ip_pos738(X,Y) get_csv2_ip((X),(Y),738) +#define get_csv2_ipv6_pos738(X,Y) get_csv2_ipv6((X),(Y),738) +#define get_csv2_string_pos738(X,Y) get_csv2_string((X),(Y),738) +#define get_csv2_v_str_pos738(X,Y) get_csv2_string((X),(Y),738) +#define get_csv2_bool_pos738(X,Y) get_csv2_bool((X),(Y),738) +#define get_csv2_int_pos738(X,Y) get_csv2_int((X),(Y),738) +#define get_csv2_llong_pos738(X,Y) get_csv2_llong((X),(Y),738) +#define get_csv2_float_pos738(X,Y) get_csv2_float((X),(Y),738) +#define get_csv2_uint_pos739(X,Y) get_csv2_uint((X),(Y),739) +#define get_csv2_ullong_pos739(X,Y) get_csv2_ullong((X),(Y),739) +#define get_csv2_ip_pos739(X,Y) get_csv2_ip((X),(Y),739) +#define get_csv2_ipv6_pos739(X,Y) get_csv2_ipv6((X),(Y),739) +#define get_csv2_string_pos739(X,Y) get_csv2_string((X),(Y),739) +#define get_csv2_v_str_pos739(X,Y) get_csv2_string((X),(Y),739) +#define get_csv2_bool_pos739(X,Y) get_csv2_bool((X),(Y),739) +#define get_csv2_int_pos739(X,Y) get_csv2_int((X),(Y),739) +#define get_csv2_llong_pos739(X,Y) get_csv2_llong((X),(Y),739) +#define get_csv2_float_pos739(X,Y) get_csv2_float((X),(Y),739) +#define get_csv2_uint_pos740(X,Y) get_csv2_uint((X),(Y),740) +#define get_csv2_ullong_pos740(X,Y) get_csv2_ullong((X),(Y),740) +#define get_csv2_ip_pos740(X,Y) get_csv2_ip((X),(Y),740) +#define get_csv2_ipv6_pos740(X,Y) get_csv2_ipv6((X),(Y),740) +#define get_csv2_string_pos740(X,Y) get_csv2_string((X),(Y),740) +#define get_csv2_v_str_pos740(X,Y) get_csv2_string((X),(Y),740) +#define get_csv2_bool_pos740(X,Y) get_csv2_bool((X),(Y),740) +#define get_csv2_int_pos740(X,Y) get_csv2_int((X),(Y),740) +#define get_csv2_llong_pos740(X,Y) get_csv2_llong((X),(Y),740) +#define get_csv2_float_pos740(X,Y) get_csv2_float((X),(Y),740) +#define get_csv2_uint_pos741(X,Y) get_csv2_uint((X),(Y),741) +#define get_csv2_ullong_pos741(X,Y) get_csv2_ullong((X),(Y),741) +#define get_csv2_ip_pos741(X,Y) get_csv2_ip((X),(Y),741) +#define get_csv2_ipv6_pos741(X,Y) get_csv2_ipv6((X),(Y),741) +#define get_csv2_string_pos741(X,Y) get_csv2_string((X),(Y),741) +#define get_csv2_v_str_pos741(X,Y) get_csv2_string((X),(Y),741) +#define get_csv2_bool_pos741(X,Y) get_csv2_bool((X),(Y),741) +#define get_csv2_int_pos741(X,Y) get_csv2_int((X),(Y),741) +#define get_csv2_llong_pos741(X,Y) get_csv2_llong((X),(Y),741) +#define get_csv2_float_pos741(X,Y) get_csv2_float((X),(Y),741) +#define get_csv2_uint_pos742(X,Y) get_csv2_uint((X),(Y),742) +#define get_csv2_ullong_pos742(X,Y) get_csv2_ullong((X),(Y),742) +#define get_csv2_ip_pos742(X,Y) get_csv2_ip((X),(Y),742) +#define get_csv2_ipv6_pos742(X,Y) get_csv2_ipv6((X),(Y),742) +#define get_csv2_string_pos742(X,Y) get_csv2_string((X),(Y),742) +#define get_csv2_v_str_pos742(X,Y) get_csv2_string((X),(Y),742) +#define get_csv2_bool_pos742(X,Y) get_csv2_bool((X),(Y),742) +#define get_csv2_int_pos742(X,Y) get_csv2_int((X),(Y),742) +#define get_csv2_llong_pos742(X,Y) get_csv2_llong((X),(Y),742) +#define get_csv2_float_pos742(X,Y) get_csv2_float((X),(Y),742) +#define get_csv2_uint_pos743(X,Y) get_csv2_uint((X),(Y),743) +#define get_csv2_ullong_pos743(X,Y) get_csv2_ullong((X),(Y),743) +#define get_csv2_ip_pos743(X,Y) get_csv2_ip((X),(Y),743) +#define get_csv2_ipv6_pos743(X,Y) get_csv2_ipv6((X),(Y),743) +#define get_csv2_string_pos743(X,Y) get_csv2_string((X),(Y),743) +#define get_csv2_v_str_pos743(X,Y) get_csv2_string((X),(Y),743) +#define get_csv2_bool_pos743(X,Y) get_csv2_bool((X),(Y),743) +#define get_csv2_int_pos743(X,Y) get_csv2_int((X),(Y),743) +#define get_csv2_llong_pos743(X,Y) get_csv2_llong((X),(Y),743) +#define get_csv2_float_pos743(X,Y) get_csv2_float((X),(Y),743) +#define get_csv2_uint_pos744(X,Y) get_csv2_uint((X),(Y),744) +#define get_csv2_ullong_pos744(X,Y) get_csv2_ullong((X),(Y),744) +#define get_csv2_ip_pos744(X,Y) get_csv2_ip((X),(Y),744) +#define get_csv2_ipv6_pos744(X,Y) get_csv2_ipv6((X),(Y),744) +#define get_csv2_string_pos744(X,Y) get_csv2_string((X),(Y),744) +#define get_csv2_v_str_pos744(X,Y) get_csv2_string((X),(Y),744) +#define get_csv2_bool_pos744(X,Y) get_csv2_bool((X),(Y),744) +#define get_csv2_int_pos744(X,Y) get_csv2_int((X),(Y),744) +#define get_csv2_llong_pos744(X,Y) get_csv2_llong((X),(Y),744) +#define get_csv2_float_pos744(X,Y) get_csv2_float((X),(Y),744) +#define get_csv2_uint_pos745(X,Y) get_csv2_uint((X),(Y),745) +#define get_csv2_ullong_pos745(X,Y) get_csv2_ullong((X),(Y),745) +#define get_csv2_ip_pos745(X,Y) get_csv2_ip((X),(Y),745) +#define get_csv2_ipv6_pos745(X,Y) get_csv2_ipv6((X),(Y),745) +#define get_csv2_string_pos745(X,Y) get_csv2_string((X),(Y),745) +#define get_csv2_v_str_pos745(X,Y) get_csv2_string((X),(Y),745) +#define get_csv2_bool_pos745(X,Y) get_csv2_bool((X),(Y),745) +#define get_csv2_int_pos745(X,Y) get_csv2_int((X),(Y),745) +#define get_csv2_llong_pos745(X,Y) get_csv2_llong((X),(Y),745) +#define get_csv2_float_pos745(X,Y) get_csv2_float((X),(Y),745) +#define get_csv2_uint_pos746(X,Y) get_csv2_uint((X),(Y),746) +#define get_csv2_ullong_pos746(X,Y) get_csv2_ullong((X),(Y),746) +#define get_csv2_ip_pos746(X,Y) get_csv2_ip((X),(Y),746) +#define get_csv2_ipv6_pos746(X,Y) get_csv2_ipv6((X),(Y),746) +#define get_csv2_string_pos746(X,Y) get_csv2_string((X),(Y),746) +#define get_csv2_v_str_pos746(X,Y) get_csv2_string((X),(Y),746) +#define get_csv2_bool_pos746(X,Y) get_csv2_bool((X),(Y),746) +#define get_csv2_int_pos746(X,Y) get_csv2_int((X),(Y),746) +#define get_csv2_llong_pos746(X,Y) get_csv2_llong((X),(Y),746) +#define get_csv2_float_pos746(X,Y) get_csv2_float((X),(Y),746) +#define get_csv2_uint_pos747(X,Y) get_csv2_uint((X),(Y),747) +#define get_csv2_ullong_pos747(X,Y) get_csv2_ullong((X),(Y),747) +#define get_csv2_ip_pos747(X,Y) get_csv2_ip((X),(Y),747) +#define get_csv2_ipv6_pos747(X,Y) get_csv2_ipv6((X),(Y),747) +#define get_csv2_string_pos747(X,Y) get_csv2_string((X),(Y),747) +#define get_csv2_v_str_pos747(X,Y) get_csv2_string((X),(Y),747) +#define get_csv2_bool_pos747(X,Y) get_csv2_bool((X),(Y),747) +#define get_csv2_int_pos747(X,Y) get_csv2_int((X),(Y),747) +#define get_csv2_llong_pos747(X,Y) get_csv2_llong((X),(Y),747) +#define get_csv2_float_pos747(X,Y) get_csv2_float((X),(Y),747) +#define get_csv2_uint_pos748(X,Y) get_csv2_uint((X),(Y),748) +#define get_csv2_ullong_pos748(X,Y) get_csv2_ullong((X),(Y),748) +#define get_csv2_ip_pos748(X,Y) get_csv2_ip((X),(Y),748) +#define get_csv2_ipv6_pos748(X,Y) get_csv2_ipv6((X),(Y),748) +#define get_csv2_string_pos748(X,Y) get_csv2_string((X),(Y),748) +#define get_csv2_v_str_pos748(X,Y) get_csv2_string((X),(Y),748) +#define get_csv2_bool_pos748(X,Y) get_csv2_bool((X),(Y),748) +#define get_csv2_int_pos748(X,Y) get_csv2_int((X),(Y),748) +#define get_csv2_llong_pos748(X,Y) get_csv2_llong((X),(Y),748) +#define get_csv2_float_pos748(X,Y) get_csv2_float((X),(Y),748) +#define get_csv2_uint_pos749(X,Y) get_csv2_uint((X),(Y),749) +#define get_csv2_ullong_pos749(X,Y) get_csv2_ullong((X),(Y),749) +#define get_csv2_ip_pos749(X,Y) get_csv2_ip((X),(Y),749) +#define get_csv2_ipv6_pos749(X,Y) get_csv2_ipv6((X),(Y),749) +#define get_csv2_string_pos749(X,Y) get_csv2_string((X),(Y),749) +#define get_csv2_v_str_pos749(X,Y) get_csv2_string((X),(Y),749) +#define get_csv2_bool_pos749(X,Y) get_csv2_bool((X),(Y),749) +#define get_csv2_int_pos749(X,Y) get_csv2_int((X),(Y),749) +#define get_csv2_llong_pos749(X,Y) get_csv2_llong((X),(Y),749) +#define get_csv2_float_pos749(X,Y) get_csv2_float((X),(Y),749) +#define get_csv2_uint_pos750(X,Y) get_csv2_uint((X),(Y),750) +#define get_csv2_ullong_pos750(X,Y) get_csv2_ullong((X),(Y),750) +#define get_csv2_ip_pos750(X,Y) get_csv2_ip((X),(Y),750) +#define get_csv2_ipv6_pos750(X,Y) get_csv2_ipv6((X),(Y),750) +#define get_csv2_string_pos750(X,Y) get_csv2_string((X),(Y),750) +#define get_csv2_v_str_pos750(X,Y) get_csv2_string((X),(Y),750) +#define get_csv2_bool_pos750(X,Y) get_csv2_bool((X),(Y),750) +#define get_csv2_int_pos750(X,Y) get_csv2_int((X),(Y),750) +#define get_csv2_llong_pos750(X,Y) get_csv2_llong((X),(Y),750) +#define get_csv2_float_pos750(X,Y) get_csv2_float((X),(Y),750) +#define get_csv2_uint_pos751(X,Y) get_csv2_uint((X),(Y),751) +#define get_csv2_ullong_pos751(X,Y) get_csv2_ullong((X),(Y),751) +#define get_csv2_ip_pos751(X,Y) get_csv2_ip((X),(Y),751) +#define get_csv2_ipv6_pos751(X,Y) get_csv2_ipv6((X),(Y),751) +#define get_csv2_string_pos751(X,Y) get_csv2_string((X),(Y),751) +#define get_csv2_v_str_pos751(X,Y) get_csv2_string((X),(Y),751) +#define get_csv2_bool_pos751(X,Y) get_csv2_bool((X),(Y),751) +#define get_csv2_int_pos751(X,Y) get_csv2_int((X),(Y),751) +#define get_csv2_llong_pos751(X,Y) get_csv2_llong((X),(Y),751) +#define get_csv2_float_pos751(X,Y) get_csv2_float((X),(Y),751) +#define get_csv2_uint_pos752(X,Y) get_csv2_uint((X),(Y),752) +#define get_csv2_ullong_pos752(X,Y) get_csv2_ullong((X),(Y),752) +#define get_csv2_ip_pos752(X,Y) get_csv2_ip((X),(Y),752) +#define get_csv2_ipv6_pos752(X,Y) get_csv2_ipv6((X),(Y),752) +#define get_csv2_string_pos752(X,Y) get_csv2_string((X),(Y),752) +#define get_csv2_v_str_pos752(X,Y) get_csv2_string((X),(Y),752) +#define get_csv2_bool_pos752(X,Y) get_csv2_bool((X),(Y),752) +#define get_csv2_int_pos752(X,Y) get_csv2_int((X),(Y),752) +#define get_csv2_llong_pos752(X,Y) get_csv2_llong((X),(Y),752) +#define get_csv2_float_pos752(X,Y) get_csv2_float((X),(Y),752) +#define get_csv2_uint_pos753(X,Y) get_csv2_uint((X),(Y),753) +#define get_csv2_ullong_pos753(X,Y) get_csv2_ullong((X),(Y),753) +#define get_csv2_ip_pos753(X,Y) get_csv2_ip((X),(Y),753) +#define get_csv2_ipv6_pos753(X,Y) get_csv2_ipv6((X),(Y),753) +#define get_csv2_string_pos753(X,Y) get_csv2_string((X),(Y),753) +#define get_csv2_v_str_pos753(X,Y) get_csv2_string((X),(Y),753) +#define get_csv2_bool_pos753(X,Y) get_csv2_bool((X),(Y),753) +#define get_csv2_int_pos753(X,Y) get_csv2_int((X),(Y),753) +#define get_csv2_llong_pos753(X,Y) get_csv2_llong((X),(Y),753) +#define get_csv2_float_pos753(X,Y) get_csv2_float((X),(Y),753) +#define get_csv2_uint_pos754(X,Y) get_csv2_uint((X),(Y),754) +#define get_csv2_ullong_pos754(X,Y) get_csv2_ullong((X),(Y),754) +#define get_csv2_ip_pos754(X,Y) get_csv2_ip((X),(Y),754) +#define get_csv2_ipv6_pos754(X,Y) get_csv2_ipv6((X),(Y),754) +#define get_csv2_string_pos754(X,Y) get_csv2_string((X),(Y),754) +#define get_csv2_v_str_pos754(X,Y) get_csv2_string((X),(Y),754) +#define get_csv2_bool_pos754(X,Y) get_csv2_bool((X),(Y),754) +#define get_csv2_int_pos754(X,Y) get_csv2_int((X),(Y),754) +#define get_csv2_llong_pos754(X,Y) get_csv2_llong((X),(Y),754) +#define get_csv2_float_pos754(X,Y) get_csv2_float((X),(Y),754) +#define get_csv2_uint_pos755(X,Y) get_csv2_uint((X),(Y),755) +#define get_csv2_ullong_pos755(X,Y) get_csv2_ullong((X),(Y),755) +#define get_csv2_ip_pos755(X,Y) get_csv2_ip((X),(Y),755) +#define get_csv2_ipv6_pos755(X,Y) get_csv2_ipv6((X),(Y),755) +#define get_csv2_string_pos755(X,Y) get_csv2_string((X),(Y),755) +#define get_csv2_v_str_pos755(X,Y) get_csv2_string((X),(Y),755) +#define get_csv2_bool_pos755(X,Y) get_csv2_bool((X),(Y),755) +#define get_csv2_int_pos755(X,Y) get_csv2_int((X),(Y),755) +#define get_csv2_llong_pos755(X,Y) get_csv2_llong((X),(Y),755) +#define get_csv2_float_pos755(X,Y) get_csv2_float((X),(Y),755) +#define get_csv2_uint_pos756(X,Y) get_csv2_uint((X),(Y),756) +#define get_csv2_ullong_pos756(X,Y) get_csv2_ullong((X),(Y),756) +#define get_csv2_ip_pos756(X,Y) get_csv2_ip((X),(Y),756) +#define get_csv2_ipv6_pos756(X,Y) get_csv2_ipv6((X),(Y),756) +#define get_csv2_string_pos756(X,Y) get_csv2_string((X),(Y),756) +#define get_csv2_v_str_pos756(X,Y) get_csv2_string((X),(Y),756) +#define get_csv2_bool_pos756(X,Y) get_csv2_bool((X),(Y),756) +#define get_csv2_int_pos756(X,Y) get_csv2_int((X),(Y),756) +#define get_csv2_llong_pos756(X,Y) get_csv2_llong((X),(Y),756) +#define get_csv2_float_pos756(X,Y) get_csv2_float((X),(Y),756) +#define get_csv2_uint_pos757(X,Y) get_csv2_uint((X),(Y),757) +#define get_csv2_ullong_pos757(X,Y) get_csv2_ullong((X),(Y),757) +#define get_csv2_ip_pos757(X,Y) get_csv2_ip((X),(Y),757) +#define get_csv2_ipv6_pos757(X,Y) get_csv2_ipv6((X),(Y),757) +#define get_csv2_string_pos757(X,Y) get_csv2_string((X),(Y),757) +#define get_csv2_v_str_pos757(X,Y) get_csv2_string((X),(Y),757) +#define get_csv2_bool_pos757(X,Y) get_csv2_bool((X),(Y),757) +#define get_csv2_int_pos757(X,Y) get_csv2_int((X),(Y),757) +#define get_csv2_llong_pos757(X,Y) get_csv2_llong((X),(Y),757) +#define get_csv2_float_pos757(X,Y) get_csv2_float((X),(Y),757) +#define get_csv2_uint_pos758(X,Y) get_csv2_uint((X),(Y),758) +#define get_csv2_ullong_pos758(X,Y) get_csv2_ullong((X),(Y),758) +#define get_csv2_ip_pos758(X,Y) get_csv2_ip((X),(Y),758) +#define get_csv2_ipv6_pos758(X,Y) get_csv2_ipv6((X),(Y),758) +#define get_csv2_string_pos758(X,Y) get_csv2_string((X),(Y),758) +#define get_csv2_v_str_pos758(X,Y) get_csv2_string((X),(Y),758) +#define get_csv2_bool_pos758(X,Y) get_csv2_bool((X),(Y),758) +#define get_csv2_int_pos758(X,Y) get_csv2_int((X),(Y),758) +#define get_csv2_llong_pos758(X,Y) get_csv2_llong((X),(Y),758) +#define get_csv2_float_pos758(X,Y) get_csv2_float((X),(Y),758) +#define get_csv2_uint_pos759(X,Y) get_csv2_uint((X),(Y),759) +#define get_csv2_ullong_pos759(X,Y) get_csv2_ullong((X),(Y),759) +#define get_csv2_ip_pos759(X,Y) get_csv2_ip((X),(Y),759) +#define get_csv2_ipv6_pos759(X,Y) get_csv2_ipv6((X),(Y),759) +#define get_csv2_string_pos759(X,Y) get_csv2_string((X),(Y),759) +#define get_csv2_v_str_pos759(X,Y) get_csv2_string((X),(Y),759) +#define get_csv2_bool_pos759(X,Y) get_csv2_bool((X),(Y),759) +#define get_csv2_int_pos759(X,Y) get_csv2_int((X),(Y),759) +#define get_csv2_llong_pos759(X,Y) get_csv2_llong((X),(Y),759) +#define get_csv2_float_pos759(X,Y) get_csv2_float((X),(Y),759) +#define get_csv2_uint_pos760(X,Y) get_csv2_uint((X),(Y),760) +#define get_csv2_ullong_pos760(X,Y) get_csv2_ullong((X),(Y),760) +#define get_csv2_ip_pos760(X,Y) get_csv2_ip((X),(Y),760) +#define get_csv2_ipv6_pos760(X,Y) get_csv2_ipv6((X),(Y),760) +#define get_csv2_string_pos760(X,Y) get_csv2_string((X),(Y),760) +#define get_csv2_v_str_pos760(X,Y) get_csv2_string((X),(Y),760) +#define get_csv2_bool_pos760(X,Y) get_csv2_bool((X),(Y),760) +#define get_csv2_int_pos760(X,Y) get_csv2_int((X),(Y),760) +#define get_csv2_llong_pos760(X,Y) get_csv2_llong((X),(Y),760) +#define get_csv2_float_pos760(X,Y) get_csv2_float((X),(Y),760) +#define get_csv2_uint_pos761(X,Y) get_csv2_uint((X),(Y),761) +#define get_csv2_ullong_pos761(X,Y) get_csv2_ullong((X),(Y),761) +#define get_csv2_ip_pos761(X,Y) get_csv2_ip((X),(Y),761) +#define get_csv2_ipv6_pos761(X,Y) get_csv2_ipv6((X),(Y),761) +#define get_csv2_string_pos761(X,Y) get_csv2_string((X),(Y),761) +#define get_csv2_v_str_pos761(X,Y) get_csv2_string((X),(Y),761) +#define get_csv2_bool_pos761(X,Y) get_csv2_bool((X),(Y),761) +#define get_csv2_int_pos761(X,Y) get_csv2_int((X),(Y),761) +#define get_csv2_llong_pos761(X,Y) get_csv2_llong((X),(Y),761) +#define get_csv2_float_pos761(X,Y) get_csv2_float((X),(Y),761) +#define get_csv2_uint_pos762(X,Y) get_csv2_uint((X),(Y),762) +#define get_csv2_ullong_pos762(X,Y) get_csv2_ullong((X),(Y),762) +#define get_csv2_ip_pos762(X,Y) get_csv2_ip((X),(Y),762) +#define get_csv2_ipv6_pos762(X,Y) get_csv2_ipv6((X),(Y),762) +#define get_csv2_string_pos762(X,Y) get_csv2_string((X),(Y),762) +#define get_csv2_v_str_pos762(X,Y) get_csv2_string((X),(Y),762) +#define get_csv2_bool_pos762(X,Y) get_csv2_bool((X),(Y),762) +#define get_csv2_int_pos762(X,Y) get_csv2_int((X),(Y),762) +#define get_csv2_llong_pos762(X,Y) get_csv2_llong((X),(Y),762) +#define get_csv2_float_pos762(X,Y) get_csv2_float((X),(Y),762) +#define get_csv2_uint_pos763(X,Y) get_csv2_uint((X),(Y),763) +#define get_csv2_ullong_pos763(X,Y) get_csv2_ullong((X),(Y),763) +#define get_csv2_ip_pos763(X,Y) get_csv2_ip((X),(Y),763) +#define get_csv2_ipv6_pos763(X,Y) get_csv2_ipv6((X),(Y),763) +#define get_csv2_string_pos763(X,Y) get_csv2_string((X),(Y),763) +#define get_csv2_v_str_pos763(X,Y) get_csv2_string((X),(Y),763) +#define get_csv2_bool_pos763(X,Y) get_csv2_bool((X),(Y),763) +#define get_csv2_int_pos763(X,Y) get_csv2_int((X),(Y),763) +#define get_csv2_llong_pos763(X,Y) get_csv2_llong((X),(Y),763) +#define get_csv2_float_pos763(X,Y) get_csv2_float((X),(Y),763) +#define get_csv2_uint_pos764(X,Y) get_csv2_uint((X),(Y),764) +#define get_csv2_ullong_pos764(X,Y) get_csv2_ullong((X),(Y),764) +#define get_csv2_ip_pos764(X,Y) get_csv2_ip((X),(Y),764) +#define get_csv2_ipv6_pos764(X,Y) get_csv2_ipv6((X),(Y),764) +#define get_csv2_string_pos764(X,Y) get_csv2_string((X),(Y),764) +#define get_csv2_v_str_pos764(X,Y) get_csv2_string((X),(Y),764) +#define get_csv2_bool_pos764(X,Y) get_csv2_bool((X),(Y),764) +#define get_csv2_int_pos764(X,Y) get_csv2_int((X),(Y),764) +#define get_csv2_llong_pos764(X,Y) get_csv2_llong((X),(Y),764) +#define get_csv2_float_pos764(X,Y) get_csv2_float((X),(Y),764) +#define get_csv2_uint_pos765(X,Y) get_csv2_uint((X),(Y),765) +#define get_csv2_ullong_pos765(X,Y) get_csv2_ullong((X),(Y),765) +#define get_csv2_ip_pos765(X,Y) get_csv2_ip((X),(Y),765) +#define get_csv2_ipv6_pos765(X,Y) get_csv2_ipv6((X),(Y),765) +#define get_csv2_string_pos765(X,Y) get_csv2_string((X),(Y),765) +#define get_csv2_v_str_pos765(X,Y) get_csv2_string((X),(Y),765) +#define get_csv2_bool_pos765(X,Y) get_csv2_bool((X),(Y),765) +#define get_csv2_int_pos765(X,Y) get_csv2_int((X),(Y),765) +#define get_csv2_llong_pos765(X,Y) get_csv2_llong((X),(Y),765) +#define get_csv2_float_pos765(X,Y) get_csv2_float((X),(Y),765) +#define get_csv2_uint_pos766(X,Y) get_csv2_uint((X),(Y),766) +#define get_csv2_ullong_pos766(X,Y) get_csv2_ullong((X),(Y),766) +#define get_csv2_ip_pos766(X,Y) get_csv2_ip((X),(Y),766) +#define get_csv2_ipv6_pos766(X,Y) get_csv2_ipv6((X),(Y),766) +#define get_csv2_string_pos766(X,Y) get_csv2_string((X),(Y),766) +#define get_csv2_v_str_pos766(X,Y) get_csv2_string((X),(Y),766) +#define get_csv2_bool_pos766(X,Y) get_csv2_bool((X),(Y),766) +#define get_csv2_int_pos766(X,Y) get_csv2_int((X),(Y),766) +#define get_csv2_llong_pos766(X,Y) get_csv2_llong((X),(Y),766) +#define get_csv2_float_pos766(X,Y) get_csv2_float((X),(Y),766) +#define get_csv2_uint_pos767(X,Y) get_csv2_uint((X),(Y),767) +#define get_csv2_ullong_pos767(X,Y) get_csv2_ullong((X),(Y),767) +#define get_csv2_ip_pos767(X,Y) get_csv2_ip((X),(Y),767) +#define get_csv2_ipv6_pos767(X,Y) get_csv2_ipv6((X),(Y),767) +#define get_csv2_string_pos767(X,Y) get_csv2_string((X),(Y),767) +#define get_csv2_v_str_pos767(X,Y) get_csv2_string((X),(Y),767) +#define get_csv2_bool_pos767(X,Y) get_csv2_bool((X),(Y),767) +#define get_csv2_int_pos767(X,Y) get_csv2_int((X),(Y),767) +#define get_csv2_llong_pos767(X,Y) get_csv2_llong((X),(Y),767) +#define get_csv2_float_pos767(X,Y) get_csv2_float((X),(Y),767) +#define get_csv2_uint_pos768(X,Y) get_csv2_uint((X),(Y),768) +#define get_csv2_ullong_pos768(X,Y) get_csv2_ullong((X),(Y),768) +#define get_csv2_ip_pos768(X,Y) get_csv2_ip((X),(Y),768) +#define get_csv2_ipv6_pos768(X,Y) get_csv2_ipv6((X),(Y),768) +#define get_csv2_string_pos768(X,Y) get_csv2_string((X),(Y),768) +#define get_csv2_v_str_pos768(X,Y) get_csv2_string((X),(Y),768) +#define get_csv2_bool_pos768(X,Y) get_csv2_bool((X),(Y),768) +#define get_csv2_int_pos768(X,Y) get_csv2_int((X),(Y),768) +#define get_csv2_llong_pos768(X,Y) get_csv2_llong((X),(Y),768) +#define get_csv2_float_pos768(X,Y) get_csv2_float((X),(Y),768) +#define get_csv2_uint_pos769(X,Y) get_csv2_uint((X),(Y),769) +#define get_csv2_ullong_pos769(X,Y) get_csv2_ullong((X),(Y),769) +#define get_csv2_ip_pos769(X,Y) get_csv2_ip((X),(Y),769) +#define get_csv2_ipv6_pos769(X,Y) get_csv2_ipv6((X),(Y),769) +#define get_csv2_string_pos769(X,Y) get_csv2_string((X),(Y),769) +#define get_csv2_v_str_pos769(X,Y) get_csv2_string((X),(Y),769) +#define get_csv2_bool_pos769(X,Y) get_csv2_bool((X),(Y),769) +#define get_csv2_int_pos769(X,Y) get_csv2_int((X),(Y),769) +#define get_csv2_llong_pos769(X,Y) get_csv2_llong((X),(Y),769) +#define get_csv2_float_pos769(X,Y) get_csv2_float((X),(Y),769) +#define get_csv2_uint_pos770(X,Y) get_csv2_uint((X),(Y),770) +#define get_csv2_ullong_pos770(X,Y) get_csv2_ullong((X),(Y),770) +#define get_csv2_ip_pos770(X,Y) get_csv2_ip((X),(Y),770) +#define get_csv2_ipv6_pos770(X,Y) get_csv2_ipv6((X),(Y),770) +#define get_csv2_string_pos770(X,Y) get_csv2_string((X),(Y),770) +#define get_csv2_v_str_pos770(X,Y) get_csv2_string((X),(Y),770) +#define get_csv2_bool_pos770(X,Y) get_csv2_bool((X),(Y),770) +#define get_csv2_int_pos770(X,Y) get_csv2_int((X),(Y),770) +#define get_csv2_llong_pos770(X,Y) get_csv2_llong((X),(Y),770) +#define get_csv2_float_pos770(X,Y) get_csv2_float((X),(Y),770) +#define get_csv2_uint_pos771(X,Y) get_csv2_uint((X),(Y),771) +#define get_csv2_ullong_pos771(X,Y) get_csv2_ullong((X),(Y),771) +#define get_csv2_ip_pos771(X,Y) get_csv2_ip((X),(Y),771) +#define get_csv2_ipv6_pos771(X,Y) get_csv2_ipv6((X),(Y),771) +#define get_csv2_string_pos771(X,Y) get_csv2_string((X),(Y),771) +#define get_csv2_v_str_pos771(X,Y) get_csv2_string((X),(Y),771) +#define get_csv2_bool_pos771(X,Y) get_csv2_bool((X),(Y),771) +#define get_csv2_int_pos771(X,Y) get_csv2_int((X),(Y),771) +#define get_csv2_llong_pos771(X,Y) get_csv2_llong((X),(Y),771) +#define get_csv2_float_pos771(X,Y) get_csv2_float((X),(Y),771) +#define get_csv2_uint_pos772(X,Y) get_csv2_uint((X),(Y),772) +#define get_csv2_ullong_pos772(X,Y) get_csv2_ullong((X),(Y),772) +#define get_csv2_ip_pos772(X,Y) get_csv2_ip((X),(Y),772) +#define get_csv2_ipv6_pos772(X,Y) get_csv2_ipv6((X),(Y),772) +#define get_csv2_string_pos772(X,Y) get_csv2_string((X),(Y),772) +#define get_csv2_v_str_pos772(X,Y) get_csv2_string((X),(Y),772) +#define get_csv2_bool_pos772(X,Y) get_csv2_bool((X),(Y),772) +#define get_csv2_int_pos772(X,Y) get_csv2_int((X),(Y),772) +#define get_csv2_llong_pos772(X,Y) get_csv2_llong((X),(Y),772) +#define get_csv2_float_pos772(X,Y) get_csv2_float((X),(Y),772) +#define get_csv2_uint_pos773(X,Y) get_csv2_uint((X),(Y),773) +#define get_csv2_ullong_pos773(X,Y) get_csv2_ullong((X),(Y),773) +#define get_csv2_ip_pos773(X,Y) get_csv2_ip((X),(Y),773) +#define get_csv2_ipv6_pos773(X,Y) get_csv2_ipv6((X),(Y),773) +#define get_csv2_string_pos773(X,Y) get_csv2_string((X),(Y),773) +#define get_csv2_v_str_pos773(X,Y) get_csv2_string((X),(Y),773) +#define get_csv2_bool_pos773(X,Y) get_csv2_bool((X),(Y),773) +#define get_csv2_int_pos773(X,Y) get_csv2_int((X),(Y),773) +#define get_csv2_llong_pos773(X,Y) get_csv2_llong((X),(Y),773) +#define get_csv2_float_pos773(X,Y) get_csv2_float((X),(Y),773) +#define get_csv2_uint_pos774(X,Y) get_csv2_uint((X),(Y),774) +#define get_csv2_ullong_pos774(X,Y) get_csv2_ullong((X),(Y),774) +#define get_csv2_ip_pos774(X,Y) get_csv2_ip((X),(Y),774) +#define get_csv2_ipv6_pos774(X,Y) get_csv2_ipv6((X),(Y),774) +#define get_csv2_string_pos774(X,Y) get_csv2_string((X),(Y),774) +#define get_csv2_v_str_pos774(X,Y) get_csv2_string((X),(Y),774) +#define get_csv2_bool_pos774(X,Y) get_csv2_bool((X),(Y),774) +#define get_csv2_int_pos774(X,Y) get_csv2_int((X),(Y),774) +#define get_csv2_llong_pos774(X,Y) get_csv2_llong((X),(Y),774) +#define get_csv2_float_pos774(X,Y) get_csv2_float((X),(Y),774) +#define get_csv2_uint_pos775(X,Y) get_csv2_uint((X),(Y),775) +#define get_csv2_ullong_pos775(X,Y) get_csv2_ullong((X),(Y),775) +#define get_csv2_ip_pos775(X,Y) get_csv2_ip((X),(Y),775) +#define get_csv2_ipv6_pos775(X,Y) get_csv2_ipv6((X),(Y),775) +#define get_csv2_string_pos775(X,Y) get_csv2_string((X),(Y),775) +#define get_csv2_v_str_pos775(X,Y) get_csv2_string((X),(Y),775) +#define get_csv2_bool_pos775(X,Y) get_csv2_bool((X),(Y),775) +#define get_csv2_int_pos775(X,Y) get_csv2_int((X),(Y),775) +#define get_csv2_llong_pos775(X,Y) get_csv2_llong((X),(Y),775) +#define get_csv2_float_pos775(X,Y) get_csv2_float((X),(Y),775) +#define get_csv2_uint_pos776(X,Y) get_csv2_uint((X),(Y),776) +#define get_csv2_ullong_pos776(X,Y) get_csv2_ullong((X),(Y),776) +#define get_csv2_ip_pos776(X,Y) get_csv2_ip((X),(Y),776) +#define get_csv2_ipv6_pos776(X,Y) get_csv2_ipv6((X),(Y),776) +#define get_csv2_string_pos776(X,Y) get_csv2_string((X),(Y),776) +#define get_csv2_v_str_pos776(X,Y) get_csv2_string((X),(Y),776) +#define get_csv2_bool_pos776(X,Y) get_csv2_bool((X),(Y),776) +#define get_csv2_int_pos776(X,Y) get_csv2_int((X),(Y),776) +#define get_csv2_llong_pos776(X,Y) get_csv2_llong((X),(Y),776) +#define get_csv2_float_pos776(X,Y) get_csv2_float((X),(Y),776) +#define get_csv2_uint_pos777(X,Y) get_csv2_uint((X),(Y),777) +#define get_csv2_ullong_pos777(X,Y) get_csv2_ullong((X),(Y),777) +#define get_csv2_ip_pos777(X,Y) get_csv2_ip((X),(Y),777) +#define get_csv2_ipv6_pos777(X,Y) get_csv2_ipv6((X),(Y),777) +#define get_csv2_string_pos777(X,Y) get_csv2_string((X),(Y),777) +#define get_csv2_v_str_pos777(X,Y) get_csv2_string((X),(Y),777) +#define get_csv2_bool_pos777(X,Y) get_csv2_bool((X),(Y),777) +#define get_csv2_int_pos777(X,Y) get_csv2_int((X),(Y),777) +#define get_csv2_llong_pos777(X,Y) get_csv2_llong((X),(Y),777) +#define get_csv2_float_pos777(X,Y) get_csv2_float((X),(Y),777) +#define get_csv2_uint_pos778(X,Y) get_csv2_uint((X),(Y),778) +#define get_csv2_ullong_pos778(X,Y) get_csv2_ullong((X),(Y),778) +#define get_csv2_ip_pos778(X,Y) get_csv2_ip((X),(Y),778) +#define get_csv2_ipv6_pos778(X,Y) get_csv2_ipv6((X),(Y),778) +#define get_csv2_string_pos778(X,Y) get_csv2_string((X),(Y),778) +#define get_csv2_v_str_pos778(X,Y) get_csv2_string((X),(Y),778) +#define get_csv2_bool_pos778(X,Y) get_csv2_bool((X),(Y),778) +#define get_csv2_int_pos778(X,Y) get_csv2_int((X),(Y),778) +#define get_csv2_llong_pos778(X,Y) get_csv2_llong((X),(Y),778) +#define get_csv2_float_pos778(X,Y) get_csv2_float((X),(Y),778) +#define get_csv2_uint_pos779(X,Y) get_csv2_uint((X),(Y),779) +#define get_csv2_ullong_pos779(X,Y) get_csv2_ullong((X),(Y),779) +#define get_csv2_ip_pos779(X,Y) get_csv2_ip((X),(Y),779) +#define get_csv2_ipv6_pos779(X,Y) get_csv2_ipv6((X),(Y),779) +#define get_csv2_string_pos779(X,Y) get_csv2_string((X),(Y),779) +#define get_csv2_v_str_pos779(X,Y) get_csv2_string((X),(Y),779) +#define get_csv2_bool_pos779(X,Y) get_csv2_bool((X),(Y),779) +#define get_csv2_int_pos779(X,Y) get_csv2_int((X),(Y),779) +#define get_csv2_llong_pos779(X,Y) get_csv2_llong((X),(Y),779) +#define get_csv2_float_pos779(X,Y) get_csv2_float((X),(Y),779) +#define get_csv2_uint_pos780(X,Y) get_csv2_uint((X),(Y),780) +#define get_csv2_ullong_pos780(X,Y) get_csv2_ullong((X),(Y),780) +#define get_csv2_ip_pos780(X,Y) get_csv2_ip((X),(Y),780) +#define get_csv2_ipv6_pos780(X,Y) get_csv2_ipv6((X),(Y),780) +#define get_csv2_string_pos780(X,Y) get_csv2_string((X),(Y),780) +#define get_csv2_v_str_pos780(X,Y) get_csv2_string((X),(Y),780) +#define get_csv2_bool_pos780(X,Y) get_csv2_bool((X),(Y),780) +#define get_csv2_int_pos780(X,Y) get_csv2_int((X),(Y),780) +#define get_csv2_llong_pos780(X,Y) get_csv2_llong((X),(Y),780) +#define get_csv2_float_pos780(X,Y) get_csv2_float((X),(Y),780) +#define get_csv2_uint_pos781(X,Y) get_csv2_uint((X),(Y),781) +#define get_csv2_ullong_pos781(X,Y) get_csv2_ullong((X),(Y),781) +#define get_csv2_ip_pos781(X,Y) get_csv2_ip((X),(Y),781) +#define get_csv2_ipv6_pos781(X,Y) get_csv2_ipv6((X),(Y),781) +#define get_csv2_string_pos781(X,Y) get_csv2_string((X),(Y),781) +#define get_csv2_v_str_pos781(X,Y) get_csv2_string((X),(Y),781) +#define get_csv2_bool_pos781(X,Y) get_csv2_bool((X),(Y),781) +#define get_csv2_int_pos781(X,Y) get_csv2_int((X),(Y),781) +#define get_csv2_llong_pos781(X,Y) get_csv2_llong((X),(Y),781) +#define get_csv2_float_pos781(X,Y) get_csv2_float((X),(Y),781) +#define get_csv2_uint_pos782(X,Y) get_csv2_uint((X),(Y),782) +#define get_csv2_ullong_pos782(X,Y) get_csv2_ullong((X),(Y),782) +#define get_csv2_ip_pos782(X,Y) get_csv2_ip((X),(Y),782) +#define get_csv2_ipv6_pos782(X,Y) get_csv2_ipv6((X),(Y),782) +#define get_csv2_string_pos782(X,Y) get_csv2_string((X),(Y),782) +#define get_csv2_v_str_pos782(X,Y) get_csv2_string((X),(Y),782) +#define get_csv2_bool_pos782(X,Y) get_csv2_bool((X),(Y),782) +#define get_csv2_int_pos782(X,Y) get_csv2_int((X),(Y),782) +#define get_csv2_llong_pos782(X,Y) get_csv2_llong((X),(Y),782) +#define get_csv2_float_pos782(X,Y) get_csv2_float((X),(Y),782) +#define get_csv2_uint_pos783(X,Y) get_csv2_uint((X),(Y),783) +#define get_csv2_ullong_pos783(X,Y) get_csv2_ullong((X),(Y),783) +#define get_csv2_ip_pos783(X,Y) get_csv2_ip((X),(Y),783) +#define get_csv2_ipv6_pos783(X,Y) get_csv2_ipv6((X),(Y),783) +#define get_csv2_string_pos783(X,Y) get_csv2_string((X),(Y),783) +#define get_csv2_v_str_pos783(X,Y) get_csv2_string((X),(Y),783) +#define get_csv2_bool_pos783(X,Y) get_csv2_bool((X),(Y),783) +#define get_csv2_int_pos783(X,Y) get_csv2_int((X),(Y),783) +#define get_csv2_llong_pos783(X,Y) get_csv2_llong((X),(Y),783) +#define get_csv2_float_pos783(X,Y) get_csv2_float((X),(Y),783) +#define get_csv2_uint_pos784(X,Y) get_csv2_uint((X),(Y),784) +#define get_csv2_ullong_pos784(X,Y) get_csv2_ullong((X),(Y),784) +#define get_csv2_ip_pos784(X,Y) get_csv2_ip((X),(Y),784) +#define get_csv2_ipv6_pos784(X,Y) get_csv2_ipv6((X),(Y),784) +#define get_csv2_string_pos784(X,Y) get_csv2_string((X),(Y),784) +#define get_csv2_v_str_pos784(X,Y) get_csv2_string((X),(Y),784) +#define get_csv2_bool_pos784(X,Y) get_csv2_bool((X),(Y),784) +#define get_csv2_int_pos784(X,Y) get_csv2_int((X),(Y),784) +#define get_csv2_llong_pos784(X,Y) get_csv2_llong((X),(Y),784) +#define get_csv2_float_pos784(X,Y) get_csv2_float((X),(Y),784) +#define get_csv2_uint_pos785(X,Y) get_csv2_uint((X),(Y),785) +#define get_csv2_ullong_pos785(X,Y) get_csv2_ullong((X),(Y),785) +#define get_csv2_ip_pos785(X,Y) get_csv2_ip((X),(Y),785) +#define get_csv2_ipv6_pos785(X,Y) get_csv2_ipv6((X),(Y),785) +#define get_csv2_string_pos785(X,Y) get_csv2_string((X),(Y),785) +#define get_csv2_v_str_pos785(X,Y) get_csv2_string((X),(Y),785) +#define get_csv2_bool_pos785(X,Y) get_csv2_bool((X),(Y),785) +#define get_csv2_int_pos785(X,Y) get_csv2_int((X),(Y),785) +#define get_csv2_llong_pos785(X,Y) get_csv2_llong((X),(Y),785) +#define get_csv2_float_pos785(X,Y) get_csv2_float((X),(Y),785) +#define get_csv2_uint_pos786(X,Y) get_csv2_uint((X),(Y),786) +#define get_csv2_ullong_pos786(X,Y) get_csv2_ullong((X),(Y),786) +#define get_csv2_ip_pos786(X,Y) get_csv2_ip((X),(Y),786) +#define get_csv2_ipv6_pos786(X,Y) get_csv2_ipv6((X),(Y),786) +#define get_csv2_string_pos786(X,Y) get_csv2_string((X),(Y),786) +#define get_csv2_v_str_pos786(X,Y) get_csv2_string((X),(Y),786) +#define get_csv2_bool_pos786(X,Y) get_csv2_bool((X),(Y),786) +#define get_csv2_int_pos786(X,Y) get_csv2_int((X),(Y),786) +#define get_csv2_llong_pos786(X,Y) get_csv2_llong((X),(Y),786) +#define get_csv2_float_pos786(X,Y) get_csv2_float((X),(Y),786) +#define get_csv2_uint_pos787(X,Y) get_csv2_uint((X),(Y),787) +#define get_csv2_ullong_pos787(X,Y) get_csv2_ullong((X),(Y),787) +#define get_csv2_ip_pos787(X,Y) get_csv2_ip((X),(Y),787) +#define get_csv2_ipv6_pos787(X,Y) get_csv2_ipv6((X),(Y),787) +#define get_csv2_string_pos787(X,Y) get_csv2_string((X),(Y),787) +#define get_csv2_v_str_pos787(X,Y) get_csv2_string((X),(Y),787) +#define get_csv2_bool_pos787(X,Y) get_csv2_bool((X),(Y),787) +#define get_csv2_int_pos787(X,Y) get_csv2_int((X),(Y),787) +#define get_csv2_llong_pos787(X,Y) get_csv2_llong((X),(Y),787) +#define get_csv2_float_pos787(X,Y) get_csv2_float((X),(Y),787) +#define get_csv2_uint_pos788(X,Y) get_csv2_uint((X),(Y),788) +#define get_csv2_ullong_pos788(X,Y) get_csv2_ullong((X),(Y),788) +#define get_csv2_ip_pos788(X,Y) get_csv2_ip((X),(Y),788) +#define get_csv2_ipv6_pos788(X,Y) get_csv2_ipv6((X),(Y),788) +#define get_csv2_string_pos788(X,Y) get_csv2_string((X),(Y),788) +#define get_csv2_v_str_pos788(X,Y) get_csv2_string((X),(Y),788) +#define get_csv2_bool_pos788(X,Y) get_csv2_bool((X),(Y),788) +#define get_csv2_int_pos788(X,Y) get_csv2_int((X),(Y),788) +#define get_csv2_llong_pos788(X,Y) get_csv2_llong((X),(Y),788) +#define get_csv2_float_pos788(X,Y) get_csv2_float((X),(Y),788) +#define get_csv2_uint_pos789(X,Y) get_csv2_uint((X),(Y),789) +#define get_csv2_ullong_pos789(X,Y) get_csv2_ullong((X),(Y),789) +#define get_csv2_ip_pos789(X,Y) get_csv2_ip((X),(Y),789) +#define get_csv2_ipv6_pos789(X,Y) get_csv2_ipv6((X),(Y),789) +#define get_csv2_string_pos789(X,Y) get_csv2_string((X),(Y),789) +#define get_csv2_v_str_pos789(X,Y) get_csv2_string((X),(Y),789) +#define get_csv2_bool_pos789(X,Y) get_csv2_bool((X),(Y),789) +#define get_csv2_int_pos789(X,Y) get_csv2_int((X),(Y),789) +#define get_csv2_llong_pos789(X,Y) get_csv2_llong((X),(Y),789) +#define get_csv2_float_pos789(X,Y) get_csv2_float((X),(Y),789) +#define get_csv2_uint_pos790(X,Y) get_csv2_uint((X),(Y),790) +#define get_csv2_ullong_pos790(X,Y) get_csv2_ullong((X),(Y),790) +#define get_csv2_ip_pos790(X,Y) get_csv2_ip((X),(Y),790) +#define get_csv2_ipv6_pos790(X,Y) get_csv2_ipv6((X),(Y),790) +#define get_csv2_string_pos790(X,Y) get_csv2_string((X),(Y),790) +#define get_csv2_v_str_pos790(X,Y) get_csv2_string((X),(Y),790) +#define get_csv2_bool_pos790(X,Y) get_csv2_bool((X),(Y),790) +#define get_csv2_int_pos790(X,Y) get_csv2_int((X),(Y),790) +#define get_csv2_llong_pos790(X,Y) get_csv2_llong((X),(Y),790) +#define get_csv2_float_pos790(X,Y) get_csv2_float((X),(Y),790) +#define get_csv2_uint_pos791(X,Y) get_csv2_uint((X),(Y),791) +#define get_csv2_ullong_pos791(X,Y) get_csv2_ullong((X),(Y),791) +#define get_csv2_ip_pos791(X,Y) get_csv2_ip((X),(Y),791) +#define get_csv2_ipv6_pos791(X,Y) get_csv2_ipv6((X),(Y),791) +#define get_csv2_string_pos791(X,Y) get_csv2_string((X),(Y),791) +#define get_csv2_v_str_pos791(X,Y) get_csv2_string((X),(Y),791) +#define get_csv2_bool_pos791(X,Y) get_csv2_bool((X),(Y),791) +#define get_csv2_int_pos791(X,Y) get_csv2_int((X),(Y),791) +#define get_csv2_llong_pos791(X,Y) get_csv2_llong((X),(Y),791) +#define get_csv2_float_pos791(X,Y) get_csv2_float((X),(Y),791) +#define get_csv2_uint_pos792(X,Y) get_csv2_uint((X),(Y),792) +#define get_csv2_ullong_pos792(X,Y) get_csv2_ullong((X),(Y),792) +#define get_csv2_ip_pos792(X,Y) get_csv2_ip((X),(Y),792) +#define get_csv2_ipv6_pos792(X,Y) get_csv2_ipv6((X),(Y),792) +#define get_csv2_string_pos792(X,Y) get_csv2_string((X),(Y),792) +#define get_csv2_v_str_pos792(X,Y) get_csv2_string((X),(Y),792) +#define get_csv2_bool_pos792(X,Y) get_csv2_bool((X),(Y),792) +#define get_csv2_int_pos792(X,Y) get_csv2_int((X),(Y),792) +#define get_csv2_llong_pos792(X,Y) get_csv2_llong((X),(Y),792) +#define get_csv2_float_pos792(X,Y) get_csv2_float((X),(Y),792) +#define get_csv2_uint_pos793(X,Y) get_csv2_uint((X),(Y),793) +#define get_csv2_ullong_pos793(X,Y) get_csv2_ullong((X),(Y),793) +#define get_csv2_ip_pos793(X,Y) get_csv2_ip((X),(Y),793) +#define get_csv2_ipv6_pos793(X,Y) get_csv2_ipv6((X),(Y),793) +#define get_csv2_string_pos793(X,Y) get_csv2_string((X),(Y),793) +#define get_csv2_v_str_pos793(X,Y) get_csv2_string((X),(Y),793) +#define get_csv2_bool_pos793(X,Y) get_csv2_bool((X),(Y),793) +#define get_csv2_int_pos793(X,Y) get_csv2_int((X),(Y),793) +#define get_csv2_llong_pos793(X,Y) get_csv2_llong((X),(Y),793) +#define get_csv2_float_pos793(X,Y) get_csv2_float((X),(Y),793) +#define get_csv2_uint_pos794(X,Y) get_csv2_uint((X),(Y),794) +#define get_csv2_ullong_pos794(X,Y) get_csv2_ullong((X),(Y),794) +#define get_csv2_ip_pos794(X,Y) get_csv2_ip((X),(Y),794) +#define get_csv2_ipv6_pos794(X,Y) get_csv2_ipv6((X),(Y),794) +#define get_csv2_string_pos794(X,Y) get_csv2_string((X),(Y),794) +#define get_csv2_v_str_pos794(X,Y) get_csv2_string((X),(Y),794) +#define get_csv2_bool_pos794(X,Y) get_csv2_bool((X),(Y),794) +#define get_csv2_int_pos794(X,Y) get_csv2_int((X),(Y),794) +#define get_csv2_llong_pos794(X,Y) get_csv2_llong((X),(Y),794) +#define get_csv2_float_pos794(X,Y) get_csv2_float((X),(Y),794) +#define get_csv2_uint_pos795(X,Y) get_csv2_uint((X),(Y),795) +#define get_csv2_ullong_pos795(X,Y) get_csv2_ullong((X),(Y),795) +#define get_csv2_ip_pos795(X,Y) get_csv2_ip((X),(Y),795) +#define get_csv2_ipv6_pos795(X,Y) get_csv2_ipv6((X),(Y),795) +#define get_csv2_string_pos795(X,Y) get_csv2_string((X),(Y),795) +#define get_csv2_v_str_pos795(X,Y) get_csv2_string((X),(Y),795) +#define get_csv2_bool_pos795(X,Y) get_csv2_bool((X),(Y),795) +#define get_csv2_int_pos795(X,Y) get_csv2_int((X),(Y),795) +#define get_csv2_llong_pos795(X,Y) get_csv2_llong((X),(Y),795) +#define get_csv2_float_pos795(X,Y) get_csv2_float((X),(Y),795) +#define get_csv2_uint_pos796(X,Y) get_csv2_uint((X),(Y),796) +#define get_csv2_ullong_pos796(X,Y) get_csv2_ullong((X),(Y),796) +#define get_csv2_ip_pos796(X,Y) get_csv2_ip((X),(Y),796) +#define get_csv2_ipv6_pos796(X,Y) get_csv2_ipv6((X),(Y),796) +#define get_csv2_string_pos796(X,Y) get_csv2_string((X),(Y),796) +#define get_csv2_v_str_pos796(X,Y) get_csv2_string((X),(Y),796) +#define get_csv2_bool_pos796(X,Y) get_csv2_bool((X),(Y),796) +#define get_csv2_int_pos796(X,Y) get_csv2_int((X),(Y),796) +#define get_csv2_llong_pos796(X,Y) get_csv2_llong((X),(Y),796) +#define get_csv2_float_pos796(X,Y) get_csv2_float((X),(Y),796) +#define get_csv2_uint_pos797(X,Y) get_csv2_uint((X),(Y),797) +#define get_csv2_ullong_pos797(X,Y) get_csv2_ullong((X),(Y),797) +#define get_csv2_ip_pos797(X,Y) get_csv2_ip((X),(Y),797) +#define get_csv2_ipv6_pos797(X,Y) get_csv2_ipv6((X),(Y),797) +#define get_csv2_string_pos797(X,Y) get_csv2_string((X),(Y),797) +#define get_csv2_v_str_pos797(X,Y) get_csv2_string((X),(Y),797) +#define get_csv2_bool_pos797(X,Y) get_csv2_bool((X),(Y),797) +#define get_csv2_int_pos797(X,Y) get_csv2_int((X),(Y),797) +#define get_csv2_llong_pos797(X,Y) get_csv2_llong((X),(Y),797) +#define get_csv2_float_pos797(X,Y) get_csv2_float((X),(Y),797) +#define get_csv2_uint_pos798(X,Y) get_csv2_uint((X),(Y),798) +#define get_csv2_ullong_pos798(X,Y) get_csv2_ullong((X),(Y),798) +#define get_csv2_ip_pos798(X,Y) get_csv2_ip((X),(Y),798) +#define get_csv2_ipv6_pos798(X,Y) get_csv2_ipv6((X),(Y),798) +#define get_csv2_string_pos798(X,Y) get_csv2_string((X),(Y),798) +#define get_csv2_v_str_pos798(X,Y) get_csv2_string((X),(Y),798) +#define get_csv2_bool_pos798(X,Y) get_csv2_bool((X),(Y),798) +#define get_csv2_int_pos798(X,Y) get_csv2_int((X),(Y),798) +#define get_csv2_llong_pos798(X,Y) get_csv2_llong((X),(Y),798) +#define get_csv2_float_pos798(X,Y) get_csv2_float((X),(Y),798) +#define get_csv2_uint_pos799(X,Y) get_csv2_uint((X),(Y),799) +#define get_csv2_ullong_pos799(X,Y) get_csv2_ullong((X),(Y),799) +#define get_csv2_ip_pos799(X,Y) get_csv2_ip((X),(Y),799) +#define get_csv2_ipv6_pos799(X,Y) get_csv2_ipv6((X),(Y),799) +#define get_csv2_string_pos799(X,Y) get_csv2_string((X),(Y),799) +#define get_csv2_v_str_pos799(X,Y) get_csv2_string((X),(Y),799) +#define get_csv2_bool_pos799(X,Y) get_csv2_bool((X),(Y),799) +#define get_csv2_int_pos799(X,Y) get_csv2_int((X),(Y),799) +#define get_csv2_llong_pos799(X,Y) get_csv2_llong((X),(Y),799) +#define get_csv2_float_pos799(X,Y) get_csv2_float((X),(Y),799) +#define get_csv2_uint_pos800(X,Y) get_csv2_uint((X),(Y),800) +#define get_csv2_ullong_pos800(X,Y) get_csv2_ullong((X),(Y),800) +#define get_csv2_ip_pos800(X,Y) get_csv2_ip((X),(Y),800) +#define get_csv2_ipv6_pos800(X,Y) get_csv2_ipv6((X),(Y),800) +#define get_csv2_string_pos800(X,Y) get_csv2_string((X),(Y),800) +#define get_csv2_v_str_pos800(X,Y) get_csv2_string((X),(Y),800) +#define get_csv2_bool_pos800(X,Y) get_csv2_bool((X),(Y),800) +#define get_csv2_int_pos800(X,Y) get_csv2_int((X),(Y),800) +#define get_csv2_llong_pos800(X,Y) get_csv2_llong((X),(Y),800) +#define get_csv2_float_pos800(X,Y) get_csv2_float((X),(Y),800) +#define get_csv2_uint_pos801(X,Y) get_csv2_uint((X),(Y),801) +#define get_csv2_ullong_pos801(X,Y) get_csv2_ullong((X),(Y),801) +#define get_csv2_ip_pos801(X,Y) get_csv2_ip((X),(Y),801) +#define get_csv2_ipv6_pos801(X,Y) get_csv2_ipv6((X),(Y),801) +#define get_csv2_string_pos801(X,Y) get_csv2_string((X),(Y),801) +#define get_csv2_v_str_pos801(X,Y) get_csv2_string((X),(Y),801) +#define get_csv2_bool_pos801(X,Y) get_csv2_bool((X),(Y),801) +#define get_csv2_int_pos801(X,Y) get_csv2_int((X),(Y),801) +#define get_csv2_llong_pos801(X,Y) get_csv2_llong((X),(Y),801) +#define get_csv2_float_pos801(X,Y) get_csv2_float((X),(Y),801) +#define get_csv2_uint_pos802(X,Y) get_csv2_uint((X),(Y),802) +#define get_csv2_ullong_pos802(X,Y) get_csv2_ullong((X),(Y),802) +#define get_csv2_ip_pos802(X,Y) get_csv2_ip((X),(Y),802) +#define get_csv2_ipv6_pos802(X,Y) get_csv2_ipv6((X),(Y),802) +#define get_csv2_string_pos802(X,Y) get_csv2_string((X),(Y),802) +#define get_csv2_v_str_pos802(X,Y) get_csv2_string((X),(Y),802) +#define get_csv2_bool_pos802(X,Y) get_csv2_bool((X),(Y),802) +#define get_csv2_int_pos802(X,Y) get_csv2_int((X),(Y),802) +#define get_csv2_llong_pos802(X,Y) get_csv2_llong((X),(Y),802) +#define get_csv2_float_pos802(X,Y) get_csv2_float((X),(Y),802) +#define get_csv2_uint_pos803(X,Y) get_csv2_uint((X),(Y),803) +#define get_csv2_ullong_pos803(X,Y) get_csv2_ullong((X),(Y),803) +#define get_csv2_ip_pos803(X,Y) get_csv2_ip((X),(Y),803) +#define get_csv2_ipv6_pos803(X,Y) get_csv2_ipv6((X),(Y),803) +#define get_csv2_string_pos803(X,Y) get_csv2_string((X),(Y),803) +#define get_csv2_v_str_pos803(X,Y) get_csv2_string((X),(Y),803) +#define get_csv2_bool_pos803(X,Y) get_csv2_bool((X),(Y),803) +#define get_csv2_int_pos803(X,Y) get_csv2_int((X),(Y),803) +#define get_csv2_llong_pos803(X,Y) get_csv2_llong((X),(Y),803) +#define get_csv2_float_pos803(X,Y) get_csv2_float((X),(Y),803) +#define get_csv2_uint_pos804(X,Y) get_csv2_uint((X),(Y),804) +#define get_csv2_ullong_pos804(X,Y) get_csv2_ullong((X),(Y),804) +#define get_csv2_ip_pos804(X,Y) get_csv2_ip((X),(Y),804) +#define get_csv2_ipv6_pos804(X,Y) get_csv2_ipv6((X),(Y),804) +#define get_csv2_string_pos804(X,Y) get_csv2_string((X),(Y),804) +#define get_csv2_v_str_pos804(X,Y) get_csv2_string((X),(Y),804) +#define get_csv2_bool_pos804(X,Y) get_csv2_bool((X),(Y),804) +#define get_csv2_int_pos804(X,Y) get_csv2_int((X),(Y),804) +#define get_csv2_llong_pos804(X,Y) get_csv2_llong((X),(Y),804) +#define get_csv2_float_pos804(X,Y) get_csv2_float((X),(Y),804) +#define get_csv2_uint_pos805(X,Y) get_csv2_uint((X),(Y),805) +#define get_csv2_ullong_pos805(X,Y) get_csv2_ullong((X),(Y),805) +#define get_csv2_ip_pos805(X,Y) get_csv2_ip((X),(Y),805) +#define get_csv2_ipv6_pos805(X,Y) get_csv2_ipv6((X),(Y),805) +#define get_csv2_string_pos805(X,Y) get_csv2_string((X),(Y),805) +#define get_csv2_v_str_pos805(X,Y) get_csv2_string((X),(Y),805) +#define get_csv2_bool_pos805(X,Y) get_csv2_bool((X),(Y),805) +#define get_csv2_int_pos805(X,Y) get_csv2_int((X),(Y),805) +#define get_csv2_llong_pos805(X,Y) get_csv2_llong((X),(Y),805) +#define get_csv2_float_pos805(X,Y) get_csv2_float((X),(Y),805) +#define get_csv2_uint_pos806(X,Y) get_csv2_uint((X),(Y),806) +#define get_csv2_ullong_pos806(X,Y) get_csv2_ullong((X),(Y),806) +#define get_csv2_ip_pos806(X,Y) get_csv2_ip((X),(Y),806) +#define get_csv2_ipv6_pos806(X,Y) get_csv2_ipv6((X),(Y),806) +#define get_csv2_string_pos806(X,Y) get_csv2_string((X),(Y),806) +#define get_csv2_v_str_pos806(X,Y) get_csv2_string((X),(Y),806) +#define get_csv2_bool_pos806(X,Y) get_csv2_bool((X),(Y),806) +#define get_csv2_int_pos806(X,Y) get_csv2_int((X),(Y),806) +#define get_csv2_llong_pos806(X,Y) get_csv2_llong((X),(Y),806) +#define get_csv2_float_pos806(X,Y) get_csv2_float((X),(Y),806) +#define get_csv2_uint_pos807(X,Y) get_csv2_uint((X),(Y),807) +#define get_csv2_ullong_pos807(X,Y) get_csv2_ullong((X),(Y),807) +#define get_csv2_ip_pos807(X,Y) get_csv2_ip((X),(Y),807) +#define get_csv2_ipv6_pos807(X,Y) get_csv2_ipv6((X),(Y),807) +#define get_csv2_string_pos807(X,Y) get_csv2_string((X),(Y),807) +#define get_csv2_v_str_pos807(X,Y) get_csv2_string((X),(Y),807) +#define get_csv2_bool_pos807(X,Y) get_csv2_bool((X),(Y),807) +#define get_csv2_int_pos807(X,Y) get_csv2_int((X),(Y),807) +#define get_csv2_llong_pos807(X,Y) get_csv2_llong((X),(Y),807) +#define get_csv2_float_pos807(X,Y) get_csv2_float((X),(Y),807) +#define get_csv2_uint_pos808(X,Y) get_csv2_uint((X),(Y),808) +#define get_csv2_ullong_pos808(X,Y) get_csv2_ullong((X),(Y),808) +#define get_csv2_ip_pos808(X,Y) get_csv2_ip((X),(Y),808) +#define get_csv2_ipv6_pos808(X,Y) get_csv2_ipv6((X),(Y),808) +#define get_csv2_string_pos808(X,Y) get_csv2_string((X),(Y),808) +#define get_csv2_v_str_pos808(X,Y) get_csv2_string((X),(Y),808) +#define get_csv2_bool_pos808(X,Y) get_csv2_bool((X),(Y),808) +#define get_csv2_int_pos808(X,Y) get_csv2_int((X),(Y),808) +#define get_csv2_llong_pos808(X,Y) get_csv2_llong((X),(Y),808) +#define get_csv2_float_pos808(X,Y) get_csv2_float((X),(Y),808) +#define get_csv2_uint_pos809(X,Y) get_csv2_uint((X),(Y),809) +#define get_csv2_ullong_pos809(X,Y) get_csv2_ullong((X),(Y),809) +#define get_csv2_ip_pos809(X,Y) get_csv2_ip((X),(Y),809) +#define get_csv2_ipv6_pos809(X,Y) get_csv2_ipv6((X),(Y),809) +#define get_csv2_string_pos809(X,Y) get_csv2_string((X),(Y),809) +#define get_csv2_v_str_pos809(X,Y) get_csv2_string((X),(Y),809) +#define get_csv2_bool_pos809(X,Y) get_csv2_bool((X),(Y),809) +#define get_csv2_int_pos809(X,Y) get_csv2_int((X),(Y),809) +#define get_csv2_llong_pos809(X,Y) get_csv2_llong((X),(Y),809) +#define get_csv2_float_pos809(X,Y) get_csv2_float((X),(Y),809) +#define get_csv2_uint_pos810(X,Y) get_csv2_uint((X),(Y),810) +#define get_csv2_ullong_pos810(X,Y) get_csv2_ullong((X),(Y),810) +#define get_csv2_ip_pos810(X,Y) get_csv2_ip((X),(Y),810) +#define get_csv2_ipv6_pos810(X,Y) get_csv2_ipv6((X),(Y),810) +#define get_csv2_string_pos810(X,Y) get_csv2_string((X),(Y),810) +#define get_csv2_v_str_pos810(X,Y) get_csv2_string((X),(Y),810) +#define get_csv2_bool_pos810(X,Y) get_csv2_bool((X),(Y),810) +#define get_csv2_int_pos810(X,Y) get_csv2_int((X),(Y),810) +#define get_csv2_llong_pos810(X,Y) get_csv2_llong((X),(Y),810) +#define get_csv2_float_pos810(X,Y) get_csv2_float((X),(Y),810) +#define get_csv2_uint_pos811(X,Y) get_csv2_uint((X),(Y),811) +#define get_csv2_ullong_pos811(X,Y) get_csv2_ullong((X),(Y),811) +#define get_csv2_ip_pos811(X,Y) get_csv2_ip((X),(Y),811) +#define get_csv2_ipv6_pos811(X,Y) get_csv2_ipv6((X),(Y),811) +#define get_csv2_string_pos811(X,Y) get_csv2_string((X),(Y),811) +#define get_csv2_v_str_pos811(X,Y) get_csv2_string((X),(Y),811) +#define get_csv2_bool_pos811(X,Y) get_csv2_bool((X),(Y),811) +#define get_csv2_int_pos811(X,Y) get_csv2_int((X),(Y),811) +#define get_csv2_llong_pos811(X,Y) get_csv2_llong((X),(Y),811) +#define get_csv2_float_pos811(X,Y) get_csv2_float((X),(Y),811) +#define get_csv2_uint_pos812(X,Y) get_csv2_uint((X),(Y),812) +#define get_csv2_ullong_pos812(X,Y) get_csv2_ullong((X),(Y),812) +#define get_csv2_ip_pos812(X,Y) get_csv2_ip((X),(Y),812) +#define get_csv2_ipv6_pos812(X,Y) get_csv2_ipv6((X),(Y),812) +#define get_csv2_string_pos812(X,Y) get_csv2_string((X),(Y),812) +#define get_csv2_v_str_pos812(X,Y) get_csv2_string((X),(Y),812) +#define get_csv2_bool_pos812(X,Y) get_csv2_bool((X),(Y),812) +#define get_csv2_int_pos812(X,Y) get_csv2_int((X),(Y),812) +#define get_csv2_llong_pos812(X,Y) get_csv2_llong((X),(Y),812) +#define get_csv2_float_pos812(X,Y) get_csv2_float((X),(Y),812) +#define get_csv2_uint_pos813(X,Y) get_csv2_uint((X),(Y),813) +#define get_csv2_ullong_pos813(X,Y) get_csv2_ullong((X),(Y),813) +#define get_csv2_ip_pos813(X,Y) get_csv2_ip((X),(Y),813) +#define get_csv2_ipv6_pos813(X,Y) get_csv2_ipv6((X),(Y),813) +#define get_csv2_string_pos813(X,Y) get_csv2_string((X),(Y),813) +#define get_csv2_v_str_pos813(X,Y) get_csv2_string((X),(Y),813) +#define get_csv2_bool_pos813(X,Y) get_csv2_bool((X),(Y),813) +#define get_csv2_int_pos813(X,Y) get_csv2_int((X),(Y),813) +#define get_csv2_llong_pos813(X,Y) get_csv2_llong((X),(Y),813) +#define get_csv2_float_pos813(X,Y) get_csv2_float((X),(Y),813) +#define get_csv2_uint_pos814(X,Y) get_csv2_uint((X),(Y),814) +#define get_csv2_ullong_pos814(X,Y) get_csv2_ullong((X),(Y),814) +#define get_csv2_ip_pos814(X,Y) get_csv2_ip((X),(Y),814) +#define get_csv2_ipv6_pos814(X,Y) get_csv2_ipv6((X),(Y),814) +#define get_csv2_string_pos814(X,Y) get_csv2_string((X),(Y),814) +#define get_csv2_v_str_pos814(X,Y) get_csv2_string((X),(Y),814) +#define get_csv2_bool_pos814(X,Y) get_csv2_bool((X),(Y),814) +#define get_csv2_int_pos814(X,Y) get_csv2_int((X),(Y),814) +#define get_csv2_llong_pos814(X,Y) get_csv2_llong((X),(Y),814) +#define get_csv2_float_pos814(X,Y) get_csv2_float((X),(Y),814) +#define get_csv2_uint_pos815(X,Y) get_csv2_uint((X),(Y),815) +#define get_csv2_ullong_pos815(X,Y) get_csv2_ullong((X),(Y),815) +#define get_csv2_ip_pos815(X,Y) get_csv2_ip((X),(Y),815) +#define get_csv2_ipv6_pos815(X,Y) get_csv2_ipv6((X),(Y),815) +#define get_csv2_string_pos815(X,Y) get_csv2_string((X),(Y),815) +#define get_csv2_v_str_pos815(X,Y) get_csv2_string((X),(Y),815) +#define get_csv2_bool_pos815(X,Y) get_csv2_bool((X),(Y),815) +#define get_csv2_int_pos815(X,Y) get_csv2_int((X),(Y),815) +#define get_csv2_llong_pos815(X,Y) get_csv2_llong((X),(Y),815) +#define get_csv2_float_pos815(X,Y) get_csv2_float((X),(Y),815) +#define get_csv2_uint_pos816(X,Y) get_csv2_uint((X),(Y),816) +#define get_csv2_ullong_pos816(X,Y) get_csv2_ullong((X),(Y),816) +#define get_csv2_ip_pos816(X,Y) get_csv2_ip((X),(Y),816) +#define get_csv2_ipv6_pos816(X,Y) get_csv2_ipv6((X),(Y),816) +#define get_csv2_string_pos816(X,Y) get_csv2_string((X),(Y),816) +#define get_csv2_v_str_pos816(X,Y) get_csv2_string((X),(Y),816) +#define get_csv2_bool_pos816(X,Y) get_csv2_bool((X),(Y),816) +#define get_csv2_int_pos816(X,Y) get_csv2_int((X),(Y),816) +#define get_csv2_llong_pos816(X,Y) get_csv2_llong((X),(Y),816) +#define get_csv2_float_pos816(X,Y) get_csv2_float((X),(Y),816) +#define get_csv2_uint_pos817(X,Y) get_csv2_uint((X),(Y),817) +#define get_csv2_ullong_pos817(X,Y) get_csv2_ullong((X),(Y),817) +#define get_csv2_ip_pos817(X,Y) get_csv2_ip((X),(Y),817) +#define get_csv2_ipv6_pos817(X,Y) get_csv2_ipv6((X),(Y),817) +#define get_csv2_string_pos817(X,Y) get_csv2_string((X),(Y),817) +#define get_csv2_v_str_pos817(X,Y) get_csv2_string((X),(Y),817) +#define get_csv2_bool_pos817(X,Y) get_csv2_bool((X),(Y),817) +#define get_csv2_int_pos817(X,Y) get_csv2_int((X),(Y),817) +#define get_csv2_llong_pos817(X,Y) get_csv2_llong((X),(Y),817) +#define get_csv2_float_pos817(X,Y) get_csv2_float((X),(Y),817) +#define get_csv2_uint_pos818(X,Y) get_csv2_uint((X),(Y),818) +#define get_csv2_ullong_pos818(X,Y) get_csv2_ullong((X),(Y),818) +#define get_csv2_ip_pos818(X,Y) get_csv2_ip((X),(Y),818) +#define get_csv2_ipv6_pos818(X,Y) get_csv2_ipv6((X),(Y),818) +#define get_csv2_string_pos818(X,Y) get_csv2_string((X),(Y),818) +#define get_csv2_v_str_pos818(X,Y) get_csv2_string((X),(Y),818) +#define get_csv2_bool_pos818(X,Y) get_csv2_bool((X),(Y),818) +#define get_csv2_int_pos818(X,Y) get_csv2_int((X),(Y),818) +#define get_csv2_llong_pos818(X,Y) get_csv2_llong((X),(Y),818) +#define get_csv2_float_pos818(X,Y) get_csv2_float((X),(Y),818) +#define get_csv2_uint_pos819(X,Y) get_csv2_uint((X),(Y),819) +#define get_csv2_ullong_pos819(X,Y) get_csv2_ullong((X),(Y),819) +#define get_csv2_ip_pos819(X,Y) get_csv2_ip((X),(Y),819) +#define get_csv2_ipv6_pos819(X,Y) get_csv2_ipv6((X),(Y),819) +#define get_csv2_string_pos819(X,Y) get_csv2_string((X),(Y),819) +#define get_csv2_v_str_pos819(X,Y) get_csv2_string((X),(Y),819) +#define get_csv2_bool_pos819(X,Y) get_csv2_bool((X),(Y),819) +#define get_csv2_int_pos819(X,Y) get_csv2_int((X),(Y),819) +#define get_csv2_llong_pos819(X,Y) get_csv2_llong((X),(Y),819) +#define get_csv2_float_pos819(X,Y) get_csv2_float((X),(Y),819) +#define get_csv2_uint_pos820(X,Y) get_csv2_uint((X),(Y),820) +#define get_csv2_ullong_pos820(X,Y) get_csv2_ullong((X),(Y),820) +#define get_csv2_ip_pos820(X,Y) get_csv2_ip((X),(Y),820) +#define get_csv2_ipv6_pos820(X,Y) get_csv2_ipv6((X),(Y),820) +#define get_csv2_string_pos820(X,Y) get_csv2_string((X),(Y),820) +#define get_csv2_v_str_pos820(X,Y) get_csv2_string((X),(Y),820) +#define get_csv2_bool_pos820(X,Y) get_csv2_bool((X),(Y),820) +#define get_csv2_int_pos820(X,Y) get_csv2_int((X),(Y),820) +#define get_csv2_llong_pos820(X,Y) get_csv2_llong((X),(Y),820) +#define get_csv2_float_pos820(X,Y) get_csv2_float((X),(Y),820) +#define get_csv2_uint_pos821(X,Y) get_csv2_uint((X),(Y),821) +#define get_csv2_ullong_pos821(X,Y) get_csv2_ullong((X),(Y),821) +#define get_csv2_ip_pos821(X,Y) get_csv2_ip((X),(Y),821) +#define get_csv2_ipv6_pos821(X,Y) get_csv2_ipv6((X),(Y),821) +#define get_csv2_string_pos821(X,Y) get_csv2_string((X),(Y),821) +#define get_csv2_v_str_pos821(X,Y) get_csv2_string((X),(Y),821) +#define get_csv2_bool_pos821(X,Y) get_csv2_bool((X),(Y),821) +#define get_csv2_int_pos821(X,Y) get_csv2_int((X),(Y),821) +#define get_csv2_llong_pos821(X,Y) get_csv2_llong((X),(Y),821) +#define get_csv2_float_pos821(X,Y) get_csv2_float((X),(Y),821) +#define get_csv2_uint_pos822(X,Y) get_csv2_uint((X),(Y),822) +#define get_csv2_ullong_pos822(X,Y) get_csv2_ullong((X),(Y),822) +#define get_csv2_ip_pos822(X,Y) get_csv2_ip((X),(Y),822) +#define get_csv2_ipv6_pos822(X,Y) get_csv2_ipv6((X),(Y),822) +#define get_csv2_string_pos822(X,Y) get_csv2_string((X),(Y),822) +#define get_csv2_v_str_pos822(X,Y) get_csv2_string((X),(Y),822) +#define get_csv2_bool_pos822(X,Y) get_csv2_bool((X),(Y),822) +#define get_csv2_int_pos822(X,Y) get_csv2_int((X),(Y),822) +#define get_csv2_llong_pos822(X,Y) get_csv2_llong((X),(Y),822) +#define get_csv2_float_pos822(X,Y) get_csv2_float((X),(Y),822) +#define get_csv2_uint_pos823(X,Y) get_csv2_uint((X),(Y),823) +#define get_csv2_ullong_pos823(X,Y) get_csv2_ullong((X),(Y),823) +#define get_csv2_ip_pos823(X,Y) get_csv2_ip((X),(Y),823) +#define get_csv2_ipv6_pos823(X,Y) get_csv2_ipv6((X),(Y),823) +#define get_csv2_string_pos823(X,Y) get_csv2_string((X),(Y),823) +#define get_csv2_v_str_pos823(X,Y) get_csv2_string((X),(Y),823) +#define get_csv2_bool_pos823(X,Y) get_csv2_bool((X),(Y),823) +#define get_csv2_int_pos823(X,Y) get_csv2_int((X),(Y),823) +#define get_csv2_llong_pos823(X,Y) get_csv2_llong((X),(Y),823) +#define get_csv2_float_pos823(X,Y) get_csv2_float((X),(Y),823) +#define get_csv2_uint_pos824(X,Y) get_csv2_uint((X),(Y),824) +#define get_csv2_ullong_pos824(X,Y) get_csv2_ullong((X),(Y),824) +#define get_csv2_ip_pos824(X,Y) get_csv2_ip((X),(Y),824) +#define get_csv2_ipv6_pos824(X,Y) get_csv2_ipv6((X),(Y),824) +#define get_csv2_string_pos824(X,Y) get_csv2_string((X),(Y),824) +#define get_csv2_v_str_pos824(X,Y) get_csv2_string((X),(Y),824) +#define get_csv2_bool_pos824(X,Y) get_csv2_bool((X),(Y),824) +#define get_csv2_int_pos824(X,Y) get_csv2_int((X),(Y),824) +#define get_csv2_llong_pos824(X,Y) get_csv2_llong((X),(Y),824) +#define get_csv2_float_pos824(X,Y) get_csv2_float((X),(Y),824) +#define get_csv2_uint_pos825(X,Y) get_csv2_uint((X),(Y),825) +#define get_csv2_ullong_pos825(X,Y) get_csv2_ullong((X),(Y),825) +#define get_csv2_ip_pos825(X,Y) get_csv2_ip((X),(Y),825) +#define get_csv2_ipv6_pos825(X,Y) get_csv2_ipv6((X),(Y),825) +#define get_csv2_string_pos825(X,Y) get_csv2_string((X),(Y),825) +#define get_csv2_v_str_pos825(X,Y) get_csv2_string((X),(Y),825) +#define get_csv2_bool_pos825(X,Y) get_csv2_bool((X),(Y),825) +#define get_csv2_int_pos825(X,Y) get_csv2_int((X),(Y),825) +#define get_csv2_llong_pos825(X,Y) get_csv2_llong((X),(Y),825) +#define get_csv2_float_pos825(X,Y) get_csv2_float((X),(Y),825) +#define get_csv2_uint_pos826(X,Y) get_csv2_uint((X),(Y),826) +#define get_csv2_ullong_pos826(X,Y) get_csv2_ullong((X),(Y),826) +#define get_csv2_ip_pos826(X,Y) get_csv2_ip((X),(Y),826) +#define get_csv2_ipv6_pos826(X,Y) get_csv2_ipv6((X),(Y),826) +#define get_csv2_string_pos826(X,Y) get_csv2_string((X),(Y),826) +#define get_csv2_v_str_pos826(X,Y) get_csv2_string((X),(Y),826) +#define get_csv2_bool_pos826(X,Y) get_csv2_bool((X),(Y),826) +#define get_csv2_int_pos826(X,Y) get_csv2_int((X),(Y),826) +#define get_csv2_llong_pos826(X,Y) get_csv2_llong((X),(Y),826) +#define get_csv2_float_pos826(X,Y) get_csv2_float((X),(Y),826) +#define get_csv2_uint_pos827(X,Y) get_csv2_uint((X),(Y),827) +#define get_csv2_ullong_pos827(X,Y) get_csv2_ullong((X),(Y),827) +#define get_csv2_ip_pos827(X,Y) get_csv2_ip((X),(Y),827) +#define get_csv2_ipv6_pos827(X,Y) get_csv2_ipv6((X),(Y),827) +#define get_csv2_string_pos827(X,Y) get_csv2_string((X),(Y),827) +#define get_csv2_v_str_pos827(X,Y) get_csv2_string((X),(Y),827) +#define get_csv2_bool_pos827(X,Y) get_csv2_bool((X),(Y),827) +#define get_csv2_int_pos827(X,Y) get_csv2_int((X),(Y),827) +#define get_csv2_llong_pos827(X,Y) get_csv2_llong((X),(Y),827) +#define get_csv2_float_pos827(X,Y) get_csv2_float((X),(Y),827) +#define get_csv2_uint_pos828(X,Y) get_csv2_uint((X),(Y),828) +#define get_csv2_ullong_pos828(X,Y) get_csv2_ullong((X),(Y),828) +#define get_csv2_ip_pos828(X,Y) get_csv2_ip((X),(Y),828) +#define get_csv2_ipv6_pos828(X,Y) get_csv2_ipv6((X),(Y),828) +#define get_csv2_string_pos828(X,Y) get_csv2_string((X),(Y),828) +#define get_csv2_v_str_pos828(X,Y) get_csv2_string((X),(Y),828) +#define get_csv2_bool_pos828(X,Y) get_csv2_bool((X),(Y),828) +#define get_csv2_int_pos828(X,Y) get_csv2_int((X),(Y),828) +#define get_csv2_llong_pos828(X,Y) get_csv2_llong((X),(Y),828) +#define get_csv2_float_pos828(X,Y) get_csv2_float((X),(Y),828) +#define get_csv2_uint_pos829(X,Y) get_csv2_uint((X),(Y),829) +#define get_csv2_ullong_pos829(X,Y) get_csv2_ullong((X),(Y),829) +#define get_csv2_ip_pos829(X,Y) get_csv2_ip((X),(Y),829) +#define get_csv2_ipv6_pos829(X,Y) get_csv2_ipv6((X),(Y),829) +#define get_csv2_string_pos829(X,Y) get_csv2_string((X),(Y),829) +#define get_csv2_v_str_pos829(X,Y) get_csv2_string((X),(Y),829) +#define get_csv2_bool_pos829(X,Y) get_csv2_bool((X),(Y),829) +#define get_csv2_int_pos829(X,Y) get_csv2_int((X),(Y),829) +#define get_csv2_llong_pos829(X,Y) get_csv2_llong((X),(Y),829) +#define get_csv2_float_pos829(X,Y) get_csv2_float((X),(Y),829) +#define get_csv2_uint_pos830(X,Y) get_csv2_uint((X),(Y),830) +#define get_csv2_ullong_pos830(X,Y) get_csv2_ullong((X),(Y),830) +#define get_csv2_ip_pos830(X,Y) get_csv2_ip((X),(Y),830) +#define get_csv2_ipv6_pos830(X,Y) get_csv2_ipv6((X),(Y),830) +#define get_csv2_string_pos830(X,Y) get_csv2_string((X),(Y),830) +#define get_csv2_v_str_pos830(X,Y) get_csv2_string((X),(Y),830) +#define get_csv2_bool_pos830(X,Y) get_csv2_bool((X),(Y),830) +#define get_csv2_int_pos830(X,Y) get_csv2_int((X),(Y),830) +#define get_csv2_llong_pos830(X,Y) get_csv2_llong((X),(Y),830) +#define get_csv2_float_pos830(X,Y) get_csv2_float((X),(Y),830) +#define get_csv2_uint_pos831(X,Y) get_csv2_uint((X),(Y),831) +#define get_csv2_ullong_pos831(X,Y) get_csv2_ullong((X),(Y),831) +#define get_csv2_ip_pos831(X,Y) get_csv2_ip((X),(Y),831) +#define get_csv2_ipv6_pos831(X,Y) get_csv2_ipv6((X),(Y),831) +#define get_csv2_string_pos831(X,Y) get_csv2_string((X),(Y),831) +#define get_csv2_v_str_pos831(X,Y) get_csv2_string((X),(Y),831) +#define get_csv2_bool_pos831(X,Y) get_csv2_bool((X),(Y),831) +#define get_csv2_int_pos831(X,Y) get_csv2_int((X),(Y),831) +#define get_csv2_llong_pos831(X,Y) get_csv2_llong((X),(Y),831) +#define get_csv2_float_pos831(X,Y) get_csv2_float((X),(Y),831) +#define get_csv2_uint_pos832(X,Y) get_csv2_uint((X),(Y),832) +#define get_csv2_ullong_pos832(X,Y) get_csv2_ullong((X),(Y),832) +#define get_csv2_ip_pos832(X,Y) get_csv2_ip((X),(Y),832) +#define get_csv2_ipv6_pos832(X,Y) get_csv2_ipv6((X),(Y),832) +#define get_csv2_string_pos832(X,Y) get_csv2_string((X),(Y),832) +#define get_csv2_v_str_pos832(X,Y) get_csv2_string((X),(Y),832) +#define get_csv2_bool_pos832(X,Y) get_csv2_bool((X),(Y),832) +#define get_csv2_int_pos832(X,Y) get_csv2_int((X),(Y),832) +#define get_csv2_llong_pos832(X,Y) get_csv2_llong((X),(Y),832) +#define get_csv2_float_pos832(X,Y) get_csv2_float((X),(Y),832) +#define get_csv2_uint_pos833(X,Y) get_csv2_uint((X),(Y),833) +#define get_csv2_ullong_pos833(X,Y) get_csv2_ullong((X),(Y),833) +#define get_csv2_ip_pos833(X,Y) get_csv2_ip((X),(Y),833) +#define get_csv2_ipv6_pos833(X,Y) get_csv2_ipv6((X),(Y),833) +#define get_csv2_string_pos833(X,Y) get_csv2_string((X),(Y),833) +#define get_csv2_v_str_pos833(X,Y) get_csv2_string((X),(Y),833) +#define get_csv2_bool_pos833(X,Y) get_csv2_bool((X),(Y),833) +#define get_csv2_int_pos833(X,Y) get_csv2_int((X),(Y),833) +#define get_csv2_llong_pos833(X,Y) get_csv2_llong((X),(Y),833) +#define get_csv2_float_pos833(X,Y) get_csv2_float((X),(Y),833) +#define get_csv2_uint_pos834(X,Y) get_csv2_uint((X),(Y),834) +#define get_csv2_ullong_pos834(X,Y) get_csv2_ullong((X),(Y),834) +#define get_csv2_ip_pos834(X,Y) get_csv2_ip((X),(Y),834) +#define get_csv2_ipv6_pos834(X,Y) get_csv2_ipv6((X),(Y),834) +#define get_csv2_string_pos834(X,Y) get_csv2_string((X),(Y),834) +#define get_csv2_v_str_pos834(X,Y) get_csv2_string((X),(Y),834) +#define get_csv2_bool_pos834(X,Y) get_csv2_bool((X),(Y),834) +#define get_csv2_int_pos834(X,Y) get_csv2_int((X),(Y),834) +#define get_csv2_llong_pos834(X,Y) get_csv2_llong((X),(Y),834) +#define get_csv2_float_pos834(X,Y) get_csv2_float((X),(Y),834) +#define get_csv2_uint_pos835(X,Y) get_csv2_uint((X),(Y),835) +#define get_csv2_ullong_pos835(X,Y) get_csv2_ullong((X),(Y),835) +#define get_csv2_ip_pos835(X,Y) get_csv2_ip((X),(Y),835) +#define get_csv2_ipv6_pos835(X,Y) get_csv2_ipv6((X),(Y),835) +#define get_csv2_string_pos835(X,Y) get_csv2_string((X),(Y),835) +#define get_csv2_v_str_pos835(X,Y) get_csv2_string((X),(Y),835) +#define get_csv2_bool_pos835(X,Y) get_csv2_bool((X),(Y),835) +#define get_csv2_int_pos835(X,Y) get_csv2_int((X),(Y),835) +#define get_csv2_llong_pos835(X,Y) get_csv2_llong((X),(Y),835) +#define get_csv2_float_pos835(X,Y) get_csv2_float((X),(Y),835) +#define get_csv2_uint_pos836(X,Y) get_csv2_uint((X),(Y),836) +#define get_csv2_ullong_pos836(X,Y) get_csv2_ullong((X),(Y),836) +#define get_csv2_ip_pos836(X,Y) get_csv2_ip((X),(Y),836) +#define get_csv2_ipv6_pos836(X,Y) get_csv2_ipv6((X),(Y),836) +#define get_csv2_string_pos836(X,Y) get_csv2_string((X),(Y),836) +#define get_csv2_v_str_pos836(X,Y) get_csv2_string((X),(Y),836) +#define get_csv2_bool_pos836(X,Y) get_csv2_bool((X),(Y),836) +#define get_csv2_int_pos836(X,Y) get_csv2_int((X),(Y),836) +#define get_csv2_llong_pos836(X,Y) get_csv2_llong((X),(Y),836) +#define get_csv2_float_pos836(X,Y) get_csv2_float((X),(Y),836) +#define get_csv2_uint_pos837(X,Y) get_csv2_uint((X),(Y),837) +#define get_csv2_ullong_pos837(X,Y) get_csv2_ullong((X),(Y),837) +#define get_csv2_ip_pos837(X,Y) get_csv2_ip((X),(Y),837) +#define get_csv2_ipv6_pos837(X,Y) get_csv2_ipv6((X),(Y),837) +#define get_csv2_string_pos837(X,Y) get_csv2_string((X),(Y),837) +#define get_csv2_v_str_pos837(X,Y) get_csv2_string((X),(Y),837) +#define get_csv2_bool_pos837(X,Y) get_csv2_bool((X),(Y),837) +#define get_csv2_int_pos837(X,Y) get_csv2_int((X),(Y),837) +#define get_csv2_llong_pos837(X,Y) get_csv2_llong((X),(Y),837) +#define get_csv2_float_pos837(X,Y) get_csv2_float((X),(Y),837) +#define get_csv2_uint_pos838(X,Y) get_csv2_uint((X),(Y),838) +#define get_csv2_ullong_pos838(X,Y) get_csv2_ullong((X),(Y),838) +#define get_csv2_ip_pos838(X,Y) get_csv2_ip((X),(Y),838) +#define get_csv2_ipv6_pos838(X,Y) get_csv2_ipv6((X),(Y),838) +#define get_csv2_string_pos838(X,Y) get_csv2_string((X),(Y),838) +#define get_csv2_v_str_pos838(X,Y) get_csv2_string((X),(Y),838) +#define get_csv2_bool_pos838(X,Y) get_csv2_bool((X),(Y),838) +#define get_csv2_int_pos838(X,Y) get_csv2_int((X),(Y),838) +#define get_csv2_llong_pos838(X,Y) get_csv2_llong((X),(Y),838) +#define get_csv2_float_pos838(X,Y) get_csv2_float((X),(Y),838) +#define get_csv2_uint_pos839(X,Y) get_csv2_uint((X),(Y),839) +#define get_csv2_ullong_pos839(X,Y) get_csv2_ullong((X),(Y),839) +#define get_csv2_ip_pos839(X,Y) get_csv2_ip((X),(Y),839) +#define get_csv2_ipv6_pos839(X,Y) get_csv2_ipv6((X),(Y),839) +#define get_csv2_string_pos839(X,Y) get_csv2_string((X),(Y),839) +#define get_csv2_v_str_pos839(X,Y) get_csv2_string((X),(Y),839) +#define get_csv2_bool_pos839(X,Y) get_csv2_bool((X),(Y),839) +#define get_csv2_int_pos839(X,Y) get_csv2_int((X),(Y),839) +#define get_csv2_llong_pos839(X,Y) get_csv2_llong((X),(Y),839) +#define get_csv2_float_pos839(X,Y) get_csv2_float((X),(Y),839) +#define get_csv2_uint_pos840(X,Y) get_csv2_uint((X),(Y),840) +#define get_csv2_ullong_pos840(X,Y) get_csv2_ullong((X),(Y),840) +#define get_csv2_ip_pos840(X,Y) get_csv2_ip((X),(Y),840) +#define get_csv2_ipv6_pos840(X,Y) get_csv2_ipv6((X),(Y),840) +#define get_csv2_string_pos840(X,Y) get_csv2_string((X),(Y),840) +#define get_csv2_v_str_pos840(X,Y) get_csv2_string((X),(Y),840) +#define get_csv2_bool_pos840(X,Y) get_csv2_bool((X),(Y),840) +#define get_csv2_int_pos840(X,Y) get_csv2_int((X),(Y),840) +#define get_csv2_llong_pos840(X,Y) get_csv2_llong((X),(Y),840) +#define get_csv2_float_pos840(X,Y) get_csv2_float((X),(Y),840) +#define get_csv2_uint_pos841(X,Y) get_csv2_uint((X),(Y),841) +#define get_csv2_ullong_pos841(X,Y) get_csv2_ullong((X),(Y),841) +#define get_csv2_ip_pos841(X,Y) get_csv2_ip((X),(Y),841) +#define get_csv2_ipv6_pos841(X,Y) get_csv2_ipv6((X),(Y),841) +#define get_csv2_string_pos841(X,Y) get_csv2_string((X),(Y),841) +#define get_csv2_v_str_pos841(X,Y) get_csv2_string((X),(Y),841) +#define get_csv2_bool_pos841(X,Y) get_csv2_bool((X),(Y),841) +#define get_csv2_int_pos841(X,Y) get_csv2_int((X),(Y),841) +#define get_csv2_llong_pos841(X,Y) get_csv2_llong((X),(Y),841) +#define get_csv2_float_pos841(X,Y) get_csv2_float((X),(Y),841) +#define get_csv2_uint_pos842(X,Y) get_csv2_uint((X),(Y),842) +#define get_csv2_ullong_pos842(X,Y) get_csv2_ullong((X),(Y),842) +#define get_csv2_ip_pos842(X,Y) get_csv2_ip((X),(Y),842) +#define get_csv2_ipv6_pos842(X,Y) get_csv2_ipv6((X),(Y),842) +#define get_csv2_string_pos842(X,Y) get_csv2_string((X),(Y),842) +#define get_csv2_v_str_pos842(X,Y) get_csv2_string((X),(Y),842) +#define get_csv2_bool_pos842(X,Y) get_csv2_bool((X),(Y),842) +#define get_csv2_int_pos842(X,Y) get_csv2_int((X),(Y),842) +#define get_csv2_llong_pos842(X,Y) get_csv2_llong((X),(Y),842) +#define get_csv2_float_pos842(X,Y) get_csv2_float((X),(Y),842) +#define get_csv2_uint_pos843(X,Y) get_csv2_uint((X),(Y),843) +#define get_csv2_ullong_pos843(X,Y) get_csv2_ullong((X),(Y),843) +#define get_csv2_ip_pos843(X,Y) get_csv2_ip((X),(Y),843) +#define get_csv2_ipv6_pos843(X,Y) get_csv2_ipv6((X),(Y),843) +#define get_csv2_string_pos843(X,Y) get_csv2_string((X),(Y),843) +#define get_csv2_v_str_pos843(X,Y) get_csv2_string((X),(Y),843) +#define get_csv2_bool_pos843(X,Y) get_csv2_bool((X),(Y),843) +#define get_csv2_int_pos843(X,Y) get_csv2_int((X),(Y),843) +#define get_csv2_llong_pos843(X,Y) get_csv2_llong((X),(Y),843) +#define get_csv2_float_pos843(X,Y) get_csv2_float((X),(Y),843) +#define get_csv2_uint_pos844(X,Y) get_csv2_uint((X),(Y),844) +#define get_csv2_ullong_pos844(X,Y) get_csv2_ullong((X),(Y),844) +#define get_csv2_ip_pos844(X,Y) get_csv2_ip((X),(Y),844) +#define get_csv2_ipv6_pos844(X,Y) get_csv2_ipv6((X),(Y),844) +#define get_csv2_string_pos844(X,Y) get_csv2_string((X),(Y),844) +#define get_csv2_v_str_pos844(X,Y) get_csv2_string((X),(Y),844) +#define get_csv2_bool_pos844(X,Y) get_csv2_bool((X),(Y),844) +#define get_csv2_int_pos844(X,Y) get_csv2_int((X),(Y),844) +#define get_csv2_llong_pos844(X,Y) get_csv2_llong((X),(Y),844) +#define get_csv2_float_pos844(X,Y) get_csv2_float((X),(Y),844) +#define get_csv2_uint_pos845(X,Y) get_csv2_uint((X),(Y),845) +#define get_csv2_ullong_pos845(X,Y) get_csv2_ullong((X),(Y),845) +#define get_csv2_ip_pos845(X,Y) get_csv2_ip((X),(Y),845) +#define get_csv2_ipv6_pos845(X,Y) get_csv2_ipv6((X),(Y),845) +#define get_csv2_string_pos845(X,Y) get_csv2_string((X),(Y),845) +#define get_csv2_v_str_pos845(X,Y) get_csv2_string((X),(Y),845) +#define get_csv2_bool_pos845(X,Y) get_csv2_bool((X),(Y),845) +#define get_csv2_int_pos845(X,Y) get_csv2_int((X),(Y),845) +#define get_csv2_llong_pos845(X,Y) get_csv2_llong((X),(Y),845) +#define get_csv2_float_pos845(X,Y) get_csv2_float((X),(Y),845) +#define get_csv2_uint_pos846(X,Y) get_csv2_uint((X),(Y),846) +#define get_csv2_ullong_pos846(X,Y) get_csv2_ullong((X),(Y),846) +#define get_csv2_ip_pos846(X,Y) get_csv2_ip((X),(Y),846) +#define get_csv2_ipv6_pos846(X,Y) get_csv2_ipv6((X),(Y),846) +#define get_csv2_string_pos846(X,Y) get_csv2_string((X),(Y),846) +#define get_csv2_v_str_pos846(X,Y) get_csv2_string((X),(Y),846) +#define get_csv2_bool_pos846(X,Y) get_csv2_bool((X),(Y),846) +#define get_csv2_int_pos846(X,Y) get_csv2_int((X),(Y),846) +#define get_csv2_llong_pos846(X,Y) get_csv2_llong((X),(Y),846) +#define get_csv2_float_pos846(X,Y) get_csv2_float((X),(Y),846) +#define get_csv2_uint_pos847(X,Y) get_csv2_uint((X),(Y),847) +#define get_csv2_ullong_pos847(X,Y) get_csv2_ullong((X),(Y),847) +#define get_csv2_ip_pos847(X,Y) get_csv2_ip((X),(Y),847) +#define get_csv2_ipv6_pos847(X,Y) get_csv2_ipv6((X),(Y),847) +#define get_csv2_string_pos847(X,Y) get_csv2_string((X),(Y),847) +#define get_csv2_v_str_pos847(X,Y) get_csv2_string((X),(Y),847) +#define get_csv2_bool_pos847(X,Y) get_csv2_bool((X),(Y),847) +#define get_csv2_int_pos847(X,Y) get_csv2_int((X),(Y),847) +#define get_csv2_llong_pos847(X,Y) get_csv2_llong((X),(Y),847) +#define get_csv2_float_pos847(X,Y) get_csv2_float((X),(Y),847) +#define get_csv2_uint_pos848(X,Y) get_csv2_uint((X),(Y),848) +#define get_csv2_ullong_pos848(X,Y) get_csv2_ullong((X),(Y),848) +#define get_csv2_ip_pos848(X,Y) get_csv2_ip((X),(Y),848) +#define get_csv2_ipv6_pos848(X,Y) get_csv2_ipv6((X),(Y),848) +#define get_csv2_string_pos848(X,Y) get_csv2_string((X),(Y),848) +#define get_csv2_v_str_pos848(X,Y) get_csv2_string((X),(Y),848) +#define get_csv2_bool_pos848(X,Y) get_csv2_bool((X),(Y),848) +#define get_csv2_int_pos848(X,Y) get_csv2_int((X),(Y),848) +#define get_csv2_llong_pos848(X,Y) get_csv2_llong((X),(Y),848) +#define get_csv2_float_pos848(X,Y) get_csv2_float((X),(Y),848) +#define get_csv2_uint_pos849(X,Y) get_csv2_uint((X),(Y),849) +#define get_csv2_ullong_pos849(X,Y) get_csv2_ullong((X),(Y),849) +#define get_csv2_ip_pos849(X,Y) get_csv2_ip((X),(Y),849) +#define get_csv2_ipv6_pos849(X,Y) get_csv2_ipv6((X),(Y),849) +#define get_csv2_string_pos849(X,Y) get_csv2_string((X),(Y),849) +#define get_csv2_v_str_pos849(X,Y) get_csv2_string((X),(Y),849) +#define get_csv2_bool_pos849(X,Y) get_csv2_bool((X),(Y),849) +#define get_csv2_int_pos849(X,Y) get_csv2_int((X),(Y),849) +#define get_csv2_llong_pos849(X,Y) get_csv2_llong((X),(Y),849) +#define get_csv2_float_pos849(X,Y) get_csv2_float((X),(Y),849) +#define get_csv2_uint_pos850(X,Y) get_csv2_uint((X),(Y),850) +#define get_csv2_ullong_pos850(X,Y) get_csv2_ullong((X),(Y),850) +#define get_csv2_ip_pos850(X,Y) get_csv2_ip((X),(Y),850) +#define get_csv2_ipv6_pos850(X,Y) get_csv2_ipv6((X),(Y),850) +#define get_csv2_string_pos850(X,Y) get_csv2_string((X),(Y),850) +#define get_csv2_v_str_pos850(X,Y) get_csv2_string((X),(Y),850) +#define get_csv2_bool_pos850(X,Y) get_csv2_bool((X),(Y),850) +#define get_csv2_int_pos850(X,Y) get_csv2_int((X),(Y),850) +#define get_csv2_llong_pos850(X,Y) get_csv2_llong((X),(Y),850) +#define get_csv2_float_pos850(X,Y) get_csv2_float((X),(Y),850) +#define get_csv2_uint_pos851(X,Y) get_csv2_uint((X),(Y),851) +#define get_csv2_ullong_pos851(X,Y) get_csv2_ullong((X),(Y),851) +#define get_csv2_ip_pos851(X,Y) get_csv2_ip((X),(Y),851) +#define get_csv2_ipv6_pos851(X,Y) get_csv2_ipv6((X),(Y),851) +#define get_csv2_string_pos851(X,Y) get_csv2_string((X),(Y),851) +#define get_csv2_v_str_pos851(X,Y) get_csv2_string((X),(Y),851) +#define get_csv2_bool_pos851(X,Y) get_csv2_bool((X),(Y),851) +#define get_csv2_int_pos851(X,Y) get_csv2_int((X),(Y),851) +#define get_csv2_llong_pos851(X,Y) get_csv2_llong((X),(Y),851) +#define get_csv2_float_pos851(X,Y) get_csv2_float((X),(Y),851) +#define get_csv2_uint_pos852(X,Y) get_csv2_uint((X),(Y),852) +#define get_csv2_ullong_pos852(X,Y) get_csv2_ullong((X),(Y),852) +#define get_csv2_ip_pos852(X,Y) get_csv2_ip((X),(Y),852) +#define get_csv2_ipv6_pos852(X,Y) get_csv2_ipv6((X),(Y),852) +#define get_csv2_string_pos852(X,Y) get_csv2_string((X),(Y),852) +#define get_csv2_v_str_pos852(X,Y) get_csv2_string((X),(Y),852) +#define get_csv2_bool_pos852(X,Y) get_csv2_bool((X),(Y),852) +#define get_csv2_int_pos852(X,Y) get_csv2_int((X),(Y),852) +#define get_csv2_llong_pos852(X,Y) get_csv2_llong((X),(Y),852) +#define get_csv2_float_pos852(X,Y) get_csv2_float((X),(Y),852) +#define get_csv2_uint_pos853(X,Y) get_csv2_uint((X),(Y),853) +#define get_csv2_ullong_pos853(X,Y) get_csv2_ullong((X),(Y),853) +#define get_csv2_ip_pos853(X,Y) get_csv2_ip((X),(Y),853) +#define get_csv2_ipv6_pos853(X,Y) get_csv2_ipv6((X),(Y),853) +#define get_csv2_string_pos853(X,Y) get_csv2_string((X),(Y),853) +#define get_csv2_v_str_pos853(X,Y) get_csv2_string((X),(Y),853) +#define get_csv2_bool_pos853(X,Y) get_csv2_bool((X),(Y),853) +#define get_csv2_int_pos853(X,Y) get_csv2_int((X),(Y),853) +#define get_csv2_llong_pos853(X,Y) get_csv2_llong((X),(Y),853) +#define get_csv2_float_pos853(X,Y) get_csv2_float((X),(Y),853) +#define get_csv2_uint_pos854(X,Y) get_csv2_uint((X),(Y),854) +#define get_csv2_ullong_pos854(X,Y) get_csv2_ullong((X),(Y),854) +#define get_csv2_ip_pos854(X,Y) get_csv2_ip((X),(Y),854) +#define get_csv2_ipv6_pos854(X,Y) get_csv2_ipv6((X),(Y),854) +#define get_csv2_string_pos854(X,Y) get_csv2_string((X),(Y),854) +#define get_csv2_v_str_pos854(X,Y) get_csv2_string((X),(Y),854) +#define get_csv2_bool_pos854(X,Y) get_csv2_bool((X),(Y),854) +#define get_csv2_int_pos854(X,Y) get_csv2_int((X),(Y),854) +#define get_csv2_llong_pos854(X,Y) get_csv2_llong((X),(Y),854) +#define get_csv2_float_pos854(X,Y) get_csv2_float((X),(Y),854) +#define get_csv2_uint_pos855(X,Y) get_csv2_uint((X),(Y),855) +#define get_csv2_ullong_pos855(X,Y) get_csv2_ullong((X),(Y),855) +#define get_csv2_ip_pos855(X,Y) get_csv2_ip((X),(Y),855) +#define get_csv2_ipv6_pos855(X,Y) get_csv2_ipv6((X),(Y),855) +#define get_csv2_string_pos855(X,Y) get_csv2_string((X),(Y),855) +#define get_csv2_v_str_pos855(X,Y) get_csv2_string((X),(Y),855) +#define get_csv2_bool_pos855(X,Y) get_csv2_bool((X),(Y),855) +#define get_csv2_int_pos855(X,Y) get_csv2_int((X),(Y),855) +#define get_csv2_llong_pos855(X,Y) get_csv2_llong((X),(Y),855) +#define get_csv2_float_pos855(X,Y) get_csv2_float((X),(Y),855) +#define get_csv2_uint_pos856(X,Y) get_csv2_uint((X),(Y),856) +#define get_csv2_ullong_pos856(X,Y) get_csv2_ullong((X),(Y),856) +#define get_csv2_ip_pos856(X,Y) get_csv2_ip((X),(Y),856) +#define get_csv2_ipv6_pos856(X,Y) get_csv2_ipv6((X),(Y),856) +#define get_csv2_string_pos856(X,Y) get_csv2_string((X),(Y),856) +#define get_csv2_v_str_pos856(X,Y) get_csv2_string((X),(Y),856) +#define get_csv2_bool_pos856(X,Y) get_csv2_bool((X),(Y),856) +#define get_csv2_int_pos856(X,Y) get_csv2_int((X),(Y),856) +#define get_csv2_llong_pos856(X,Y) get_csv2_llong((X),(Y),856) +#define get_csv2_float_pos856(X,Y) get_csv2_float((X),(Y),856) +#define get_csv2_uint_pos857(X,Y) get_csv2_uint((X),(Y),857) +#define get_csv2_ullong_pos857(X,Y) get_csv2_ullong((X),(Y),857) +#define get_csv2_ip_pos857(X,Y) get_csv2_ip((X),(Y),857) +#define get_csv2_ipv6_pos857(X,Y) get_csv2_ipv6((X),(Y),857) +#define get_csv2_string_pos857(X,Y) get_csv2_string((X),(Y),857) +#define get_csv2_v_str_pos857(X,Y) get_csv2_string((X),(Y),857) +#define get_csv2_bool_pos857(X,Y) get_csv2_bool((X),(Y),857) +#define get_csv2_int_pos857(X,Y) get_csv2_int((X),(Y),857) +#define get_csv2_llong_pos857(X,Y) get_csv2_llong((X),(Y),857) +#define get_csv2_float_pos857(X,Y) get_csv2_float((X),(Y),857) +#define get_csv2_uint_pos858(X,Y) get_csv2_uint((X),(Y),858) +#define get_csv2_ullong_pos858(X,Y) get_csv2_ullong((X),(Y),858) +#define get_csv2_ip_pos858(X,Y) get_csv2_ip((X),(Y),858) +#define get_csv2_ipv6_pos858(X,Y) get_csv2_ipv6((X),(Y),858) +#define get_csv2_string_pos858(X,Y) get_csv2_string((X),(Y),858) +#define get_csv2_v_str_pos858(X,Y) get_csv2_string((X),(Y),858) +#define get_csv2_bool_pos858(X,Y) get_csv2_bool((X),(Y),858) +#define get_csv2_int_pos858(X,Y) get_csv2_int((X),(Y),858) +#define get_csv2_llong_pos858(X,Y) get_csv2_llong((X),(Y),858) +#define get_csv2_float_pos858(X,Y) get_csv2_float((X),(Y),858) +#define get_csv2_uint_pos859(X,Y) get_csv2_uint((X),(Y),859) +#define get_csv2_ullong_pos859(X,Y) get_csv2_ullong((X),(Y),859) +#define get_csv2_ip_pos859(X,Y) get_csv2_ip((X),(Y),859) +#define get_csv2_ipv6_pos859(X,Y) get_csv2_ipv6((X),(Y),859) +#define get_csv2_string_pos859(X,Y) get_csv2_string((X),(Y),859) +#define get_csv2_v_str_pos859(X,Y) get_csv2_string((X),(Y),859) +#define get_csv2_bool_pos859(X,Y) get_csv2_bool((X),(Y),859) +#define get_csv2_int_pos859(X,Y) get_csv2_int((X),(Y),859) +#define get_csv2_llong_pos859(X,Y) get_csv2_llong((X),(Y),859) +#define get_csv2_float_pos859(X,Y) get_csv2_float((X),(Y),859) +#define get_csv2_uint_pos860(X,Y) get_csv2_uint((X),(Y),860) +#define get_csv2_ullong_pos860(X,Y) get_csv2_ullong((X),(Y),860) +#define get_csv2_ip_pos860(X,Y) get_csv2_ip((X),(Y),860) +#define get_csv2_ipv6_pos860(X,Y) get_csv2_ipv6((X),(Y),860) +#define get_csv2_string_pos860(X,Y) get_csv2_string((X),(Y),860) +#define get_csv2_v_str_pos860(X,Y) get_csv2_string((X),(Y),860) +#define get_csv2_bool_pos860(X,Y) get_csv2_bool((X),(Y),860) +#define get_csv2_int_pos860(X,Y) get_csv2_int((X),(Y),860) +#define get_csv2_llong_pos860(X,Y) get_csv2_llong((X),(Y),860) +#define get_csv2_float_pos860(X,Y) get_csv2_float((X),(Y),860) +#define get_csv2_uint_pos861(X,Y) get_csv2_uint((X),(Y),861) +#define get_csv2_ullong_pos861(X,Y) get_csv2_ullong((X),(Y),861) +#define get_csv2_ip_pos861(X,Y) get_csv2_ip((X),(Y),861) +#define get_csv2_ipv6_pos861(X,Y) get_csv2_ipv6((X),(Y),861) +#define get_csv2_string_pos861(X,Y) get_csv2_string((X),(Y),861) +#define get_csv2_v_str_pos861(X,Y) get_csv2_string((X),(Y),861) +#define get_csv2_bool_pos861(X,Y) get_csv2_bool((X),(Y),861) +#define get_csv2_int_pos861(X,Y) get_csv2_int((X),(Y),861) +#define get_csv2_llong_pos861(X,Y) get_csv2_llong((X),(Y),861) +#define get_csv2_float_pos861(X,Y) get_csv2_float((X),(Y),861) +#define get_csv2_uint_pos862(X,Y) get_csv2_uint((X),(Y),862) +#define get_csv2_ullong_pos862(X,Y) get_csv2_ullong((X),(Y),862) +#define get_csv2_ip_pos862(X,Y) get_csv2_ip((X),(Y),862) +#define get_csv2_ipv6_pos862(X,Y) get_csv2_ipv6((X),(Y),862) +#define get_csv2_string_pos862(X,Y) get_csv2_string((X),(Y),862) +#define get_csv2_v_str_pos862(X,Y) get_csv2_string((X),(Y),862) +#define get_csv2_bool_pos862(X,Y) get_csv2_bool((X),(Y),862) +#define get_csv2_int_pos862(X,Y) get_csv2_int((X),(Y),862) +#define get_csv2_llong_pos862(X,Y) get_csv2_llong((X),(Y),862) +#define get_csv2_float_pos862(X,Y) get_csv2_float((X),(Y),862) +#define get_csv2_uint_pos863(X,Y) get_csv2_uint((X),(Y),863) +#define get_csv2_ullong_pos863(X,Y) get_csv2_ullong((X),(Y),863) +#define get_csv2_ip_pos863(X,Y) get_csv2_ip((X),(Y),863) +#define get_csv2_ipv6_pos863(X,Y) get_csv2_ipv6((X),(Y),863) +#define get_csv2_string_pos863(X,Y) get_csv2_string((X),(Y),863) +#define get_csv2_v_str_pos863(X,Y) get_csv2_string((X),(Y),863) +#define get_csv2_bool_pos863(X,Y) get_csv2_bool((X),(Y),863) +#define get_csv2_int_pos863(X,Y) get_csv2_int((X),(Y),863) +#define get_csv2_llong_pos863(X,Y) get_csv2_llong((X),(Y),863) +#define get_csv2_float_pos863(X,Y) get_csv2_float((X),(Y),863) +#define get_csv2_uint_pos864(X,Y) get_csv2_uint((X),(Y),864) +#define get_csv2_ullong_pos864(X,Y) get_csv2_ullong((X),(Y),864) +#define get_csv2_ip_pos864(X,Y) get_csv2_ip((X),(Y),864) +#define get_csv2_ipv6_pos864(X,Y) get_csv2_ipv6((X),(Y),864) +#define get_csv2_string_pos864(X,Y) get_csv2_string((X),(Y),864) +#define get_csv2_v_str_pos864(X,Y) get_csv2_string((X),(Y),864) +#define get_csv2_bool_pos864(X,Y) get_csv2_bool((X),(Y),864) +#define get_csv2_int_pos864(X,Y) get_csv2_int((X),(Y),864) +#define get_csv2_llong_pos864(X,Y) get_csv2_llong((X),(Y),864) +#define get_csv2_float_pos864(X,Y) get_csv2_float((X),(Y),864) +#define get_csv2_uint_pos865(X,Y) get_csv2_uint((X),(Y),865) +#define get_csv2_ullong_pos865(X,Y) get_csv2_ullong((X),(Y),865) +#define get_csv2_ip_pos865(X,Y) get_csv2_ip((X),(Y),865) +#define get_csv2_ipv6_pos865(X,Y) get_csv2_ipv6((X),(Y),865) +#define get_csv2_string_pos865(X,Y) get_csv2_string((X),(Y),865) +#define get_csv2_v_str_pos865(X,Y) get_csv2_string((X),(Y),865) +#define get_csv2_bool_pos865(X,Y) get_csv2_bool((X),(Y),865) +#define get_csv2_int_pos865(X,Y) get_csv2_int((X),(Y),865) +#define get_csv2_llong_pos865(X,Y) get_csv2_llong((X),(Y),865) +#define get_csv2_float_pos865(X,Y) get_csv2_float((X),(Y),865) +#define get_csv2_uint_pos866(X,Y) get_csv2_uint((X),(Y),866) +#define get_csv2_ullong_pos866(X,Y) get_csv2_ullong((X),(Y),866) +#define get_csv2_ip_pos866(X,Y) get_csv2_ip((X),(Y),866) +#define get_csv2_ipv6_pos866(X,Y) get_csv2_ipv6((X),(Y),866) +#define get_csv2_string_pos866(X,Y) get_csv2_string((X),(Y),866) +#define get_csv2_v_str_pos866(X,Y) get_csv2_string((X),(Y),866) +#define get_csv2_bool_pos866(X,Y) get_csv2_bool((X),(Y),866) +#define get_csv2_int_pos866(X,Y) get_csv2_int((X),(Y),866) +#define get_csv2_llong_pos866(X,Y) get_csv2_llong((X),(Y),866) +#define get_csv2_float_pos866(X,Y) get_csv2_float((X),(Y),866) +#define get_csv2_uint_pos867(X,Y) get_csv2_uint((X),(Y),867) +#define get_csv2_ullong_pos867(X,Y) get_csv2_ullong((X),(Y),867) +#define get_csv2_ip_pos867(X,Y) get_csv2_ip((X),(Y),867) +#define get_csv2_ipv6_pos867(X,Y) get_csv2_ipv6((X),(Y),867) +#define get_csv2_string_pos867(X,Y) get_csv2_string((X),(Y),867) +#define get_csv2_v_str_pos867(X,Y) get_csv2_string((X),(Y),867) +#define get_csv2_bool_pos867(X,Y) get_csv2_bool((X),(Y),867) +#define get_csv2_int_pos867(X,Y) get_csv2_int((X),(Y),867) +#define get_csv2_llong_pos867(X,Y) get_csv2_llong((X),(Y),867) +#define get_csv2_float_pos867(X,Y) get_csv2_float((X),(Y),867) +#define get_csv2_uint_pos868(X,Y) get_csv2_uint((X),(Y),868) +#define get_csv2_ullong_pos868(X,Y) get_csv2_ullong((X),(Y),868) +#define get_csv2_ip_pos868(X,Y) get_csv2_ip((X),(Y),868) +#define get_csv2_ipv6_pos868(X,Y) get_csv2_ipv6((X),(Y),868) +#define get_csv2_string_pos868(X,Y) get_csv2_string((X),(Y),868) +#define get_csv2_v_str_pos868(X,Y) get_csv2_string((X),(Y),868) +#define get_csv2_bool_pos868(X,Y) get_csv2_bool((X),(Y),868) +#define get_csv2_int_pos868(X,Y) get_csv2_int((X),(Y),868) +#define get_csv2_llong_pos868(X,Y) get_csv2_llong((X),(Y),868) +#define get_csv2_float_pos868(X,Y) get_csv2_float((X),(Y),868) +#define get_csv2_uint_pos869(X,Y) get_csv2_uint((X),(Y),869) +#define get_csv2_ullong_pos869(X,Y) get_csv2_ullong((X),(Y),869) +#define get_csv2_ip_pos869(X,Y) get_csv2_ip((X),(Y),869) +#define get_csv2_ipv6_pos869(X,Y) get_csv2_ipv6((X),(Y),869) +#define get_csv2_string_pos869(X,Y) get_csv2_string((X),(Y),869) +#define get_csv2_v_str_pos869(X,Y) get_csv2_string((X),(Y),869) +#define get_csv2_bool_pos869(X,Y) get_csv2_bool((X),(Y),869) +#define get_csv2_int_pos869(X,Y) get_csv2_int((X),(Y),869) +#define get_csv2_llong_pos869(X,Y) get_csv2_llong((X),(Y),869) +#define get_csv2_float_pos869(X,Y) get_csv2_float((X),(Y),869) +#define get_csv2_uint_pos870(X,Y) get_csv2_uint((X),(Y),870) +#define get_csv2_ullong_pos870(X,Y) get_csv2_ullong((X),(Y),870) +#define get_csv2_ip_pos870(X,Y) get_csv2_ip((X),(Y),870) +#define get_csv2_ipv6_pos870(X,Y) get_csv2_ipv6((X),(Y),870) +#define get_csv2_string_pos870(X,Y) get_csv2_string((X),(Y),870) +#define get_csv2_v_str_pos870(X,Y) get_csv2_string((X),(Y),870) +#define get_csv2_bool_pos870(X,Y) get_csv2_bool((X),(Y),870) +#define get_csv2_int_pos870(X,Y) get_csv2_int((X),(Y),870) +#define get_csv2_llong_pos870(X,Y) get_csv2_llong((X),(Y),870) +#define get_csv2_float_pos870(X,Y) get_csv2_float((X),(Y),870) +#define get_csv2_uint_pos871(X,Y) get_csv2_uint((X),(Y),871) +#define get_csv2_ullong_pos871(X,Y) get_csv2_ullong((X),(Y),871) +#define get_csv2_ip_pos871(X,Y) get_csv2_ip((X),(Y),871) +#define get_csv2_ipv6_pos871(X,Y) get_csv2_ipv6((X),(Y),871) +#define get_csv2_string_pos871(X,Y) get_csv2_string((X),(Y),871) +#define get_csv2_v_str_pos871(X,Y) get_csv2_string((X),(Y),871) +#define get_csv2_bool_pos871(X,Y) get_csv2_bool((X),(Y),871) +#define get_csv2_int_pos871(X,Y) get_csv2_int((X),(Y),871) +#define get_csv2_llong_pos871(X,Y) get_csv2_llong((X),(Y),871) +#define get_csv2_float_pos871(X,Y) get_csv2_float((X),(Y),871) +#define get_csv2_uint_pos872(X,Y) get_csv2_uint((X),(Y),872) +#define get_csv2_ullong_pos872(X,Y) get_csv2_ullong((X),(Y),872) +#define get_csv2_ip_pos872(X,Y) get_csv2_ip((X),(Y),872) +#define get_csv2_ipv6_pos872(X,Y) get_csv2_ipv6((X),(Y),872) +#define get_csv2_string_pos872(X,Y) get_csv2_string((X),(Y),872) +#define get_csv2_v_str_pos872(X,Y) get_csv2_string((X),(Y),872) +#define get_csv2_bool_pos872(X,Y) get_csv2_bool((X),(Y),872) +#define get_csv2_int_pos872(X,Y) get_csv2_int((X),(Y),872) +#define get_csv2_llong_pos872(X,Y) get_csv2_llong((X),(Y),872) +#define get_csv2_float_pos872(X,Y) get_csv2_float((X),(Y),872) +#define get_csv2_uint_pos873(X,Y) get_csv2_uint((X),(Y),873) +#define get_csv2_ullong_pos873(X,Y) get_csv2_ullong((X),(Y),873) +#define get_csv2_ip_pos873(X,Y) get_csv2_ip((X),(Y),873) +#define get_csv2_ipv6_pos873(X,Y) get_csv2_ipv6((X),(Y),873) +#define get_csv2_string_pos873(X,Y) get_csv2_string((X),(Y),873) +#define get_csv2_v_str_pos873(X,Y) get_csv2_string((X),(Y),873) +#define get_csv2_bool_pos873(X,Y) get_csv2_bool((X),(Y),873) +#define get_csv2_int_pos873(X,Y) get_csv2_int((X),(Y),873) +#define get_csv2_llong_pos873(X,Y) get_csv2_llong((X),(Y),873) +#define get_csv2_float_pos873(X,Y) get_csv2_float((X),(Y),873) +#define get_csv2_uint_pos874(X,Y) get_csv2_uint((X),(Y),874) +#define get_csv2_ullong_pos874(X,Y) get_csv2_ullong((X),(Y),874) +#define get_csv2_ip_pos874(X,Y) get_csv2_ip((X),(Y),874) +#define get_csv2_ipv6_pos874(X,Y) get_csv2_ipv6((X),(Y),874) +#define get_csv2_string_pos874(X,Y) get_csv2_string((X),(Y),874) +#define get_csv2_v_str_pos874(X,Y) get_csv2_string((X),(Y),874) +#define get_csv2_bool_pos874(X,Y) get_csv2_bool((X),(Y),874) +#define get_csv2_int_pos874(X,Y) get_csv2_int((X),(Y),874) +#define get_csv2_llong_pos874(X,Y) get_csv2_llong((X),(Y),874) +#define get_csv2_float_pos874(X,Y) get_csv2_float((X),(Y),874) +#define get_csv2_uint_pos875(X,Y) get_csv2_uint((X),(Y),875) +#define get_csv2_ullong_pos875(X,Y) get_csv2_ullong((X),(Y),875) +#define get_csv2_ip_pos875(X,Y) get_csv2_ip((X),(Y),875) +#define get_csv2_ipv6_pos875(X,Y) get_csv2_ipv6((X),(Y),875) +#define get_csv2_string_pos875(X,Y) get_csv2_string((X),(Y),875) +#define get_csv2_v_str_pos875(X,Y) get_csv2_string((X),(Y),875) +#define get_csv2_bool_pos875(X,Y) get_csv2_bool((X),(Y),875) +#define get_csv2_int_pos875(X,Y) get_csv2_int((X),(Y),875) +#define get_csv2_llong_pos875(X,Y) get_csv2_llong((X),(Y),875) +#define get_csv2_float_pos875(X,Y) get_csv2_float((X),(Y),875) +#define get_csv2_uint_pos876(X,Y) get_csv2_uint((X),(Y),876) +#define get_csv2_ullong_pos876(X,Y) get_csv2_ullong((X),(Y),876) +#define get_csv2_ip_pos876(X,Y) get_csv2_ip((X),(Y),876) +#define get_csv2_ipv6_pos876(X,Y) get_csv2_ipv6((X),(Y),876) +#define get_csv2_string_pos876(X,Y) get_csv2_string((X),(Y),876) +#define get_csv2_v_str_pos876(X,Y) get_csv2_string((X),(Y),876) +#define get_csv2_bool_pos876(X,Y) get_csv2_bool((X),(Y),876) +#define get_csv2_int_pos876(X,Y) get_csv2_int((X),(Y),876) +#define get_csv2_llong_pos876(X,Y) get_csv2_llong((X),(Y),876) +#define get_csv2_float_pos876(X,Y) get_csv2_float((X),(Y),876) +#define get_csv2_uint_pos877(X,Y) get_csv2_uint((X),(Y),877) +#define get_csv2_ullong_pos877(X,Y) get_csv2_ullong((X),(Y),877) +#define get_csv2_ip_pos877(X,Y) get_csv2_ip((X),(Y),877) +#define get_csv2_ipv6_pos877(X,Y) get_csv2_ipv6((X),(Y),877) +#define get_csv2_string_pos877(X,Y) get_csv2_string((X),(Y),877) +#define get_csv2_v_str_pos877(X,Y) get_csv2_string((X),(Y),877) +#define get_csv2_bool_pos877(X,Y) get_csv2_bool((X),(Y),877) +#define get_csv2_int_pos877(X,Y) get_csv2_int((X),(Y),877) +#define get_csv2_llong_pos877(X,Y) get_csv2_llong((X),(Y),877) +#define get_csv2_float_pos877(X,Y) get_csv2_float((X),(Y),877) +#define get_csv2_uint_pos878(X,Y) get_csv2_uint((X),(Y),878) +#define get_csv2_ullong_pos878(X,Y) get_csv2_ullong((X),(Y),878) +#define get_csv2_ip_pos878(X,Y) get_csv2_ip((X),(Y),878) +#define get_csv2_ipv6_pos878(X,Y) get_csv2_ipv6((X),(Y),878) +#define get_csv2_string_pos878(X,Y) get_csv2_string((X),(Y),878) +#define get_csv2_v_str_pos878(X,Y) get_csv2_string((X),(Y),878) +#define get_csv2_bool_pos878(X,Y) get_csv2_bool((X),(Y),878) +#define get_csv2_int_pos878(X,Y) get_csv2_int((X),(Y),878) +#define get_csv2_llong_pos878(X,Y) get_csv2_llong((X),(Y),878) +#define get_csv2_float_pos878(X,Y) get_csv2_float((X),(Y),878) +#define get_csv2_uint_pos879(X,Y) get_csv2_uint((X),(Y),879) +#define get_csv2_ullong_pos879(X,Y) get_csv2_ullong((X),(Y),879) +#define get_csv2_ip_pos879(X,Y) get_csv2_ip((X),(Y),879) +#define get_csv2_ipv6_pos879(X,Y) get_csv2_ipv6((X),(Y),879) +#define get_csv2_string_pos879(X,Y) get_csv2_string((X),(Y),879) +#define get_csv2_v_str_pos879(X,Y) get_csv2_string((X),(Y),879) +#define get_csv2_bool_pos879(X,Y) get_csv2_bool((X),(Y),879) +#define get_csv2_int_pos879(X,Y) get_csv2_int((X),(Y),879) +#define get_csv2_llong_pos879(X,Y) get_csv2_llong((X),(Y),879) +#define get_csv2_float_pos879(X,Y) get_csv2_float((X),(Y),879) +#define get_csv2_uint_pos880(X,Y) get_csv2_uint((X),(Y),880) +#define get_csv2_ullong_pos880(X,Y) get_csv2_ullong((X),(Y),880) +#define get_csv2_ip_pos880(X,Y) get_csv2_ip((X),(Y),880) +#define get_csv2_ipv6_pos880(X,Y) get_csv2_ipv6((X),(Y),880) +#define get_csv2_string_pos880(X,Y) get_csv2_string((X),(Y),880) +#define get_csv2_v_str_pos880(X,Y) get_csv2_string((X),(Y),880) +#define get_csv2_bool_pos880(X,Y) get_csv2_bool((X),(Y),880) +#define get_csv2_int_pos880(X,Y) get_csv2_int((X),(Y),880) +#define get_csv2_llong_pos880(X,Y) get_csv2_llong((X),(Y),880) +#define get_csv2_float_pos880(X,Y) get_csv2_float((X),(Y),880) +#define get_csv2_uint_pos881(X,Y) get_csv2_uint((X),(Y),881) +#define get_csv2_ullong_pos881(X,Y) get_csv2_ullong((X),(Y),881) +#define get_csv2_ip_pos881(X,Y) get_csv2_ip((X),(Y),881) +#define get_csv2_ipv6_pos881(X,Y) get_csv2_ipv6((X),(Y),881) +#define get_csv2_string_pos881(X,Y) get_csv2_string((X),(Y),881) +#define get_csv2_v_str_pos881(X,Y) get_csv2_string((X),(Y),881) +#define get_csv2_bool_pos881(X,Y) get_csv2_bool((X),(Y),881) +#define get_csv2_int_pos881(X,Y) get_csv2_int((X),(Y),881) +#define get_csv2_llong_pos881(X,Y) get_csv2_llong((X),(Y),881) +#define get_csv2_float_pos881(X,Y) get_csv2_float((X),(Y),881) +#define get_csv2_uint_pos882(X,Y) get_csv2_uint((X),(Y),882) +#define get_csv2_ullong_pos882(X,Y) get_csv2_ullong((X),(Y),882) +#define get_csv2_ip_pos882(X,Y) get_csv2_ip((X),(Y),882) +#define get_csv2_ipv6_pos882(X,Y) get_csv2_ipv6((X),(Y),882) +#define get_csv2_string_pos882(X,Y) get_csv2_string((X),(Y),882) +#define get_csv2_v_str_pos882(X,Y) get_csv2_string((X),(Y),882) +#define get_csv2_bool_pos882(X,Y) get_csv2_bool((X),(Y),882) +#define get_csv2_int_pos882(X,Y) get_csv2_int((X),(Y),882) +#define get_csv2_llong_pos882(X,Y) get_csv2_llong((X),(Y),882) +#define get_csv2_float_pos882(X,Y) get_csv2_float((X),(Y),882) +#define get_csv2_uint_pos883(X,Y) get_csv2_uint((X),(Y),883) +#define get_csv2_ullong_pos883(X,Y) get_csv2_ullong((X),(Y),883) +#define get_csv2_ip_pos883(X,Y) get_csv2_ip((X),(Y),883) +#define get_csv2_ipv6_pos883(X,Y) get_csv2_ipv6((X),(Y),883) +#define get_csv2_string_pos883(X,Y) get_csv2_string((X),(Y),883) +#define get_csv2_v_str_pos883(X,Y) get_csv2_string((X),(Y),883) +#define get_csv2_bool_pos883(X,Y) get_csv2_bool((X),(Y),883) +#define get_csv2_int_pos883(X,Y) get_csv2_int((X),(Y),883) +#define get_csv2_llong_pos883(X,Y) get_csv2_llong((X),(Y),883) +#define get_csv2_float_pos883(X,Y) get_csv2_float((X),(Y),883) +#define get_csv2_uint_pos884(X,Y) get_csv2_uint((X),(Y),884) +#define get_csv2_ullong_pos884(X,Y) get_csv2_ullong((X),(Y),884) +#define get_csv2_ip_pos884(X,Y) get_csv2_ip((X),(Y),884) +#define get_csv2_ipv6_pos884(X,Y) get_csv2_ipv6((X),(Y),884) +#define get_csv2_string_pos884(X,Y) get_csv2_string((X),(Y),884) +#define get_csv2_v_str_pos884(X,Y) get_csv2_string((X),(Y),884) +#define get_csv2_bool_pos884(X,Y) get_csv2_bool((X),(Y),884) +#define get_csv2_int_pos884(X,Y) get_csv2_int((X),(Y),884) +#define get_csv2_llong_pos884(X,Y) get_csv2_llong((X),(Y),884) +#define get_csv2_float_pos884(X,Y) get_csv2_float((X),(Y),884) +#define get_csv2_uint_pos885(X,Y) get_csv2_uint((X),(Y),885) +#define get_csv2_ullong_pos885(X,Y) get_csv2_ullong((X),(Y),885) +#define get_csv2_ip_pos885(X,Y) get_csv2_ip((X),(Y),885) +#define get_csv2_ipv6_pos885(X,Y) get_csv2_ipv6((X),(Y),885) +#define get_csv2_string_pos885(X,Y) get_csv2_string((X),(Y),885) +#define get_csv2_v_str_pos885(X,Y) get_csv2_string((X),(Y),885) +#define get_csv2_bool_pos885(X,Y) get_csv2_bool((X),(Y),885) +#define get_csv2_int_pos885(X,Y) get_csv2_int((X),(Y),885) +#define get_csv2_llong_pos885(X,Y) get_csv2_llong((X),(Y),885) +#define get_csv2_float_pos885(X,Y) get_csv2_float((X),(Y),885) +#define get_csv2_uint_pos886(X,Y) get_csv2_uint((X),(Y),886) +#define get_csv2_ullong_pos886(X,Y) get_csv2_ullong((X),(Y),886) +#define get_csv2_ip_pos886(X,Y) get_csv2_ip((X),(Y),886) +#define get_csv2_ipv6_pos886(X,Y) get_csv2_ipv6((X),(Y),886) +#define get_csv2_string_pos886(X,Y) get_csv2_string((X),(Y),886) +#define get_csv2_v_str_pos886(X,Y) get_csv2_string((X),(Y),886) +#define get_csv2_bool_pos886(X,Y) get_csv2_bool((X),(Y),886) +#define get_csv2_int_pos886(X,Y) get_csv2_int((X),(Y),886) +#define get_csv2_llong_pos886(X,Y) get_csv2_llong((X),(Y),886) +#define get_csv2_float_pos886(X,Y) get_csv2_float((X),(Y),886) +#define get_csv2_uint_pos887(X,Y) get_csv2_uint((X),(Y),887) +#define get_csv2_ullong_pos887(X,Y) get_csv2_ullong((X),(Y),887) +#define get_csv2_ip_pos887(X,Y) get_csv2_ip((X),(Y),887) +#define get_csv2_ipv6_pos887(X,Y) get_csv2_ipv6((X),(Y),887) +#define get_csv2_string_pos887(X,Y) get_csv2_string((X),(Y),887) +#define get_csv2_v_str_pos887(X,Y) get_csv2_string((X),(Y),887) +#define get_csv2_bool_pos887(X,Y) get_csv2_bool((X),(Y),887) +#define get_csv2_int_pos887(X,Y) get_csv2_int((X),(Y),887) +#define get_csv2_llong_pos887(X,Y) get_csv2_llong((X),(Y),887) +#define get_csv2_float_pos887(X,Y) get_csv2_float((X),(Y),887) +#define get_csv2_uint_pos888(X,Y) get_csv2_uint((X),(Y),888) +#define get_csv2_ullong_pos888(X,Y) get_csv2_ullong((X),(Y),888) +#define get_csv2_ip_pos888(X,Y) get_csv2_ip((X),(Y),888) +#define get_csv2_ipv6_pos888(X,Y) get_csv2_ipv6((X),(Y),888) +#define get_csv2_string_pos888(X,Y) get_csv2_string((X),(Y),888) +#define get_csv2_v_str_pos888(X,Y) get_csv2_string((X),(Y),888) +#define get_csv2_bool_pos888(X,Y) get_csv2_bool((X),(Y),888) +#define get_csv2_int_pos888(X,Y) get_csv2_int((X),(Y),888) +#define get_csv2_llong_pos888(X,Y) get_csv2_llong((X),(Y),888) +#define get_csv2_float_pos888(X,Y) get_csv2_float((X),(Y),888) +#define get_csv2_uint_pos889(X,Y) get_csv2_uint((X),(Y),889) +#define get_csv2_ullong_pos889(X,Y) get_csv2_ullong((X),(Y),889) +#define get_csv2_ip_pos889(X,Y) get_csv2_ip((X),(Y),889) +#define get_csv2_ipv6_pos889(X,Y) get_csv2_ipv6((X),(Y),889) +#define get_csv2_string_pos889(X,Y) get_csv2_string((X),(Y),889) +#define get_csv2_v_str_pos889(X,Y) get_csv2_string((X),(Y),889) +#define get_csv2_bool_pos889(X,Y) get_csv2_bool((X),(Y),889) +#define get_csv2_int_pos889(X,Y) get_csv2_int((X),(Y),889) +#define get_csv2_llong_pos889(X,Y) get_csv2_llong((X),(Y),889) +#define get_csv2_float_pos889(X,Y) get_csv2_float((X),(Y),889) +#define get_csv2_uint_pos890(X,Y) get_csv2_uint((X),(Y),890) +#define get_csv2_ullong_pos890(X,Y) get_csv2_ullong((X),(Y),890) +#define get_csv2_ip_pos890(X,Y) get_csv2_ip((X),(Y),890) +#define get_csv2_ipv6_pos890(X,Y) get_csv2_ipv6((X),(Y),890) +#define get_csv2_string_pos890(X,Y) get_csv2_string((X),(Y),890) +#define get_csv2_v_str_pos890(X,Y) get_csv2_string((X),(Y),890) +#define get_csv2_bool_pos890(X,Y) get_csv2_bool((X),(Y),890) +#define get_csv2_int_pos890(X,Y) get_csv2_int((X),(Y),890) +#define get_csv2_llong_pos890(X,Y) get_csv2_llong((X),(Y),890) +#define get_csv2_float_pos890(X,Y) get_csv2_float((X),(Y),890) +#define get_csv2_uint_pos891(X,Y) get_csv2_uint((X),(Y),891) +#define get_csv2_ullong_pos891(X,Y) get_csv2_ullong((X),(Y),891) +#define get_csv2_ip_pos891(X,Y) get_csv2_ip((X),(Y),891) +#define get_csv2_ipv6_pos891(X,Y) get_csv2_ipv6((X),(Y),891) +#define get_csv2_string_pos891(X,Y) get_csv2_string((X),(Y),891) +#define get_csv2_v_str_pos891(X,Y) get_csv2_string((X),(Y),891) +#define get_csv2_bool_pos891(X,Y) get_csv2_bool((X),(Y),891) +#define get_csv2_int_pos891(X,Y) get_csv2_int((X),(Y),891) +#define get_csv2_llong_pos891(X,Y) get_csv2_llong((X),(Y),891) +#define get_csv2_float_pos891(X,Y) get_csv2_float((X),(Y),891) +#define get_csv2_uint_pos892(X,Y) get_csv2_uint((X),(Y),892) +#define get_csv2_ullong_pos892(X,Y) get_csv2_ullong((X),(Y),892) +#define get_csv2_ip_pos892(X,Y) get_csv2_ip((X),(Y),892) +#define get_csv2_ipv6_pos892(X,Y) get_csv2_ipv6((X),(Y),892) +#define get_csv2_string_pos892(X,Y) get_csv2_string((X),(Y),892) +#define get_csv2_v_str_pos892(X,Y) get_csv2_string((X),(Y),892) +#define get_csv2_bool_pos892(X,Y) get_csv2_bool((X),(Y),892) +#define get_csv2_int_pos892(X,Y) get_csv2_int((X),(Y),892) +#define get_csv2_llong_pos892(X,Y) get_csv2_llong((X),(Y),892) +#define get_csv2_float_pos892(X,Y) get_csv2_float((X),(Y),892) +#define get_csv2_uint_pos893(X,Y) get_csv2_uint((X),(Y),893) +#define get_csv2_ullong_pos893(X,Y) get_csv2_ullong((X),(Y),893) +#define get_csv2_ip_pos893(X,Y) get_csv2_ip((X),(Y),893) +#define get_csv2_ipv6_pos893(X,Y) get_csv2_ipv6((X),(Y),893) +#define get_csv2_string_pos893(X,Y) get_csv2_string((X),(Y),893) +#define get_csv2_v_str_pos893(X,Y) get_csv2_string((X),(Y),893) +#define get_csv2_bool_pos893(X,Y) get_csv2_bool((X),(Y),893) +#define get_csv2_int_pos893(X,Y) get_csv2_int((X),(Y),893) +#define get_csv2_llong_pos893(X,Y) get_csv2_llong((X),(Y),893) +#define get_csv2_float_pos893(X,Y) get_csv2_float((X),(Y),893) +#define get_csv2_uint_pos894(X,Y) get_csv2_uint((X),(Y),894) +#define get_csv2_ullong_pos894(X,Y) get_csv2_ullong((X),(Y),894) +#define get_csv2_ip_pos894(X,Y) get_csv2_ip((X),(Y),894) +#define get_csv2_ipv6_pos894(X,Y) get_csv2_ipv6((X),(Y),894) +#define get_csv2_string_pos894(X,Y) get_csv2_string((X),(Y),894) +#define get_csv2_v_str_pos894(X,Y) get_csv2_string((X),(Y),894) +#define get_csv2_bool_pos894(X,Y) get_csv2_bool((X),(Y),894) +#define get_csv2_int_pos894(X,Y) get_csv2_int((X),(Y),894) +#define get_csv2_llong_pos894(X,Y) get_csv2_llong((X),(Y),894) +#define get_csv2_float_pos894(X,Y) get_csv2_float((X),(Y),894) +#define get_csv2_uint_pos895(X,Y) get_csv2_uint((X),(Y),895) +#define get_csv2_ullong_pos895(X,Y) get_csv2_ullong((X),(Y),895) +#define get_csv2_ip_pos895(X,Y) get_csv2_ip((X),(Y),895) +#define get_csv2_ipv6_pos895(X,Y) get_csv2_ipv6((X),(Y),895) +#define get_csv2_string_pos895(X,Y) get_csv2_string((X),(Y),895) +#define get_csv2_v_str_pos895(X,Y) get_csv2_string((X),(Y),895) +#define get_csv2_bool_pos895(X,Y) get_csv2_bool((X),(Y),895) +#define get_csv2_int_pos895(X,Y) get_csv2_int((X),(Y),895) +#define get_csv2_llong_pos895(X,Y) get_csv2_llong((X),(Y),895) +#define get_csv2_float_pos895(X,Y) get_csv2_float((X),(Y),895) +#define get_csv2_uint_pos896(X,Y) get_csv2_uint((X),(Y),896) +#define get_csv2_ullong_pos896(X,Y) get_csv2_ullong((X),(Y),896) +#define get_csv2_ip_pos896(X,Y) get_csv2_ip((X),(Y),896) +#define get_csv2_ipv6_pos896(X,Y) get_csv2_ipv6((X),(Y),896) +#define get_csv2_string_pos896(X,Y) get_csv2_string((X),(Y),896) +#define get_csv2_v_str_pos896(X,Y) get_csv2_string((X),(Y),896) +#define get_csv2_bool_pos896(X,Y) get_csv2_bool((X),(Y),896) +#define get_csv2_int_pos896(X,Y) get_csv2_int((X),(Y),896) +#define get_csv2_llong_pos896(X,Y) get_csv2_llong((X),(Y),896) +#define get_csv2_float_pos896(X,Y) get_csv2_float((X),(Y),896) +#define get_csv2_uint_pos897(X,Y) get_csv2_uint((X),(Y),897) +#define get_csv2_ullong_pos897(X,Y) get_csv2_ullong((X),(Y),897) +#define get_csv2_ip_pos897(X,Y) get_csv2_ip((X),(Y),897) +#define get_csv2_ipv6_pos897(X,Y) get_csv2_ipv6((X),(Y),897) +#define get_csv2_string_pos897(X,Y) get_csv2_string((X),(Y),897) +#define get_csv2_v_str_pos897(X,Y) get_csv2_string((X),(Y),897) +#define get_csv2_bool_pos897(X,Y) get_csv2_bool((X),(Y),897) +#define get_csv2_int_pos897(X,Y) get_csv2_int((X),(Y),897) +#define get_csv2_llong_pos897(X,Y) get_csv2_llong((X),(Y),897) +#define get_csv2_float_pos897(X,Y) get_csv2_float((X),(Y),897) +#define get_csv2_uint_pos898(X,Y) get_csv2_uint((X),(Y),898) +#define get_csv2_ullong_pos898(X,Y) get_csv2_ullong((X),(Y),898) +#define get_csv2_ip_pos898(X,Y) get_csv2_ip((X),(Y),898) +#define get_csv2_ipv6_pos898(X,Y) get_csv2_ipv6((X),(Y),898) +#define get_csv2_string_pos898(X,Y) get_csv2_string((X),(Y),898) +#define get_csv2_v_str_pos898(X,Y) get_csv2_string((X),(Y),898) +#define get_csv2_bool_pos898(X,Y) get_csv2_bool((X),(Y),898) +#define get_csv2_int_pos898(X,Y) get_csv2_int((X),(Y),898) +#define get_csv2_llong_pos898(X,Y) get_csv2_llong((X),(Y),898) +#define get_csv2_float_pos898(X,Y) get_csv2_float((X),(Y),898) +#define get_csv2_uint_pos899(X,Y) get_csv2_uint((X),(Y),899) +#define get_csv2_ullong_pos899(X,Y) get_csv2_ullong((X),(Y),899) +#define get_csv2_ip_pos899(X,Y) get_csv2_ip((X),(Y),899) +#define get_csv2_ipv6_pos899(X,Y) get_csv2_ipv6((X),(Y),899) +#define get_csv2_string_pos899(X,Y) get_csv2_string((X),(Y),899) +#define get_csv2_v_str_pos899(X,Y) get_csv2_string((X),(Y),899) +#define get_csv2_bool_pos899(X,Y) get_csv2_bool((X),(Y),899) +#define get_csv2_int_pos899(X,Y) get_csv2_int((X),(Y),899) +#define get_csv2_llong_pos899(X,Y) get_csv2_llong((X),(Y),899) +#define get_csv2_float_pos899(X,Y) get_csv2_float((X),(Y),899) +#define get_csv2_uint_pos900(X,Y) get_csv2_uint((X),(Y),900) +#define get_csv2_ullong_pos900(X,Y) get_csv2_ullong((X),(Y),900) +#define get_csv2_ip_pos900(X,Y) get_csv2_ip((X),(Y),900) +#define get_csv2_ipv6_pos900(X,Y) get_csv2_ipv6((X),(Y),900) +#define get_csv2_string_pos900(X,Y) get_csv2_string((X),(Y),900) +#define get_csv2_v_str_pos900(X,Y) get_csv2_string((X),(Y),900) +#define get_csv2_bool_pos900(X,Y) get_csv2_bool((X),(Y),900) +#define get_csv2_int_pos900(X,Y) get_csv2_int((X),(Y),900) +#define get_csv2_llong_pos900(X,Y) get_csv2_llong((X),(Y),900) +#define get_csv2_float_pos900(X,Y) get_csv2_float((X),(Y),900) +#define get_csv2_uint_pos901(X,Y) get_csv2_uint((X),(Y),901) +#define get_csv2_ullong_pos901(X,Y) get_csv2_ullong((X),(Y),901) +#define get_csv2_ip_pos901(X,Y) get_csv2_ip((X),(Y),901) +#define get_csv2_ipv6_pos901(X,Y) get_csv2_ipv6((X),(Y),901) +#define get_csv2_string_pos901(X,Y) get_csv2_string((X),(Y),901) +#define get_csv2_v_str_pos901(X,Y) get_csv2_string((X),(Y),901) +#define get_csv2_bool_pos901(X,Y) get_csv2_bool((X),(Y),901) +#define get_csv2_int_pos901(X,Y) get_csv2_int((X),(Y),901) +#define get_csv2_llong_pos901(X,Y) get_csv2_llong((X),(Y),901) +#define get_csv2_float_pos901(X,Y) get_csv2_float((X),(Y),901) +#define get_csv2_uint_pos902(X,Y) get_csv2_uint((X),(Y),902) +#define get_csv2_ullong_pos902(X,Y) get_csv2_ullong((X),(Y),902) +#define get_csv2_ip_pos902(X,Y) get_csv2_ip((X),(Y),902) +#define get_csv2_ipv6_pos902(X,Y) get_csv2_ipv6((X),(Y),902) +#define get_csv2_string_pos902(X,Y) get_csv2_string((X),(Y),902) +#define get_csv2_v_str_pos902(X,Y) get_csv2_string((X),(Y),902) +#define get_csv2_bool_pos902(X,Y) get_csv2_bool((X),(Y),902) +#define get_csv2_int_pos902(X,Y) get_csv2_int((X),(Y),902) +#define get_csv2_llong_pos902(X,Y) get_csv2_llong((X),(Y),902) +#define get_csv2_float_pos902(X,Y) get_csv2_float((X),(Y),902) +#define get_csv2_uint_pos903(X,Y) get_csv2_uint((X),(Y),903) +#define get_csv2_ullong_pos903(X,Y) get_csv2_ullong((X),(Y),903) +#define get_csv2_ip_pos903(X,Y) get_csv2_ip((X),(Y),903) +#define get_csv2_ipv6_pos903(X,Y) get_csv2_ipv6((X),(Y),903) +#define get_csv2_string_pos903(X,Y) get_csv2_string((X),(Y),903) +#define get_csv2_v_str_pos903(X,Y) get_csv2_string((X),(Y),903) +#define get_csv2_bool_pos903(X,Y) get_csv2_bool((X),(Y),903) +#define get_csv2_int_pos903(X,Y) get_csv2_int((X),(Y),903) +#define get_csv2_llong_pos903(X,Y) get_csv2_llong((X),(Y),903) +#define get_csv2_float_pos903(X,Y) get_csv2_float((X),(Y),903) +#define get_csv2_uint_pos904(X,Y) get_csv2_uint((X),(Y),904) +#define get_csv2_ullong_pos904(X,Y) get_csv2_ullong((X),(Y),904) +#define get_csv2_ip_pos904(X,Y) get_csv2_ip((X),(Y),904) +#define get_csv2_ipv6_pos904(X,Y) get_csv2_ipv6((X),(Y),904) +#define get_csv2_string_pos904(X,Y) get_csv2_string((X),(Y),904) +#define get_csv2_v_str_pos904(X,Y) get_csv2_string((X),(Y),904) +#define get_csv2_bool_pos904(X,Y) get_csv2_bool((X),(Y),904) +#define get_csv2_int_pos904(X,Y) get_csv2_int((X),(Y),904) +#define get_csv2_llong_pos904(X,Y) get_csv2_llong((X),(Y),904) +#define get_csv2_float_pos904(X,Y) get_csv2_float((X),(Y),904) +#define get_csv2_uint_pos905(X,Y) get_csv2_uint((X),(Y),905) +#define get_csv2_ullong_pos905(X,Y) get_csv2_ullong((X),(Y),905) +#define get_csv2_ip_pos905(X,Y) get_csv2_ip((X),(Y),905) +#define get_csv2_ipv6_pos905(X,Y) get_csv2_ipv6((X),(Y),905) +#define get_csv2_string_pos905(X,Y) get_csv2_string((X),(Y),905) +#define get_csv2_v_str_pos905(X,Y) get_csv2_string((X),(Y),905) +#define get_csv2_bool_pos905(X,Y) get_csv2_bool((X),(Y),905) +#define get_csv2_int_pos905(X,Y) get_csv2_int((X),(Y),905) +#define get_csv2_llong_pos905(X,Y) get_csv2_llong((X),(Y),905) +#define get_csv2_float_pos905(X,Y) get_csv2_float((X),(Y),905) +#define get_csv2_uint_pos906(X,Y) get_csv2_uint((X),(Y),906) +#define get_csv2_ullong_pos906(X,Y) get_csv2_ullong((X),(Y),906) +#define get_csv2_ip_pos906(X,Y) get_csv2_ip((X),(Y),906) +#define get_csv2_ipv6_pos906(X,Y) get_csv2_ipv6((X),(Y),906) +#define get_csv2_string_pos906(X,Y) get_csv2_string((X),(Y),906) +#define get_csv2_v_str_pos906(X,Y) get_csv2_string((X),(Y),906) +#define get_csv2_bool_pos906(X,Y) get_csv2_bool((X),(Y),906) +#define get_csv2_int_pos906(X,Y) get_csv2_int((X),(Y),906) +#define get_csv2_llong_pos906(X,Y) get_csv2_llong((X),(Y),906) +#define get_csv2_float_pos906(X,Y) get_csv2_float((X),(Y),906) +#define get_csv2_uint_pos907(X,Y) get_csv2_uint((X),(Y),907) +#define get_csv2_ullong_pos907(X,Y) get_csv2_ullong((X),(Y),907) +#define get_csv2_ip_pos907(X,Y) get_csv2_ip((X),(Y),907) +#define get_csv2_ipv6_pos907(X,Y) get_csv2_ipv6((X),(Y),907) +#define get_csv2_string_pos907(X,Y) get_csv2_string((X),(Y),907) +#define get_csv2_v_str_pos907(X,Y) get_csv2_string((X),(Y),907) +#define get_csv2_bool_pos907(X,Y) get_csv2_bool((X),(Y),907) +#define get_csv2_int_pos907(X,Y) get_csv2_int((X),(Y),907) +#define get_csv2_llong_pos907(X,Y) get_csv2_llong((X),(Y),907) +#define get_csv2_float_pos907(X,Y) get_csv2_float((X),(Y),907) +#define get_csv2_uint_pos908(X,Y) get_csv2_uint((X),(Y),908) +#define get_csv2_ullong_pos908(X,Y) get_csv2_ullong((X),(Y),908) +#define get_csv2_ip_pos908(X,Y) get_csv2_ip((X),(Y),908) +#define get_csv2_ipv6_pos908(X,Y) get_csv2_ipv6((X),(Y),908) +#define get_csv2_string_pos908(X,Y) get_csv2_string((X),(Y),908) +#define get_csv2_v_str_pos908(X,Y) get_csv2_string((X),(Y),908) +#define get_csv2_bool_pos908(X,Y) get_csv2_bool((X),(Y),908) +#define get_csv2_int_pos908(X,Y) get_csv2_int((X),(Y),908) +#define get_csv2_llong_pos908(X,Y) get_csv2_llong((X),(Y),908) +#define get_csv2_float_pos908(X,Y) get_csv2_float((X),(Y),908) +#define get_csv2_uint_pos909(X,Y) get_csv2_uint((X),(Y),909) +#define get_csv2_ullong_pos909(X,Y) get_csv2_ullong((X),(Y),909) +#define get_csv2_ip_pos909(X,Y) get_csv2_ip((X),(Y),909) +#define get_csv2_ipv6_pos909(X,Y) get_csv2_ipv6((X),(Y),909) +#define get_csv2_string_pos909(X,Y) get_csv2_string((X),(Y),909) +#define get_csv2_v_str_pos909(X,Y) get_csv2_string((X),(Y),909) +#define get_csv2_bool_pos909(X,Y) get_csv2_bool((X),(Y),909) +#define get_csv2_int_pos909(X,Y) get_csv2_int((X),(Y),909) +#define get_csv2_llong_pos909(X,Y) get_csv2_llong((X),(Y),909) +#define get_csv2_float_pos909(X,Y) get_csv2_float((X),(Y),909) +#define get_csv2_uint_pos910(X,Y) get_csv2_uint((X),(Y),910) +#define get_csv2_ullong_pos910(X,Y) get_csv2_ullong((X),(Y),910) +#define get_csv2_ip_pos910(X,Y) get_csv2_ip((X),(Y),910) +#define get_csv2_ipv6_pos910(X,Y) get_csv2_ipv6((X),(Y),910) +#define get_csv2_string_pos910(X,Y) get_csv2_string((X),(Y),910) +#define get_csv2_v_str_pos910(X,Y) get_csv2_string((X),(Y),910) +#define get_csv2_bool_pos910(X,Y) get_csv2_bool((X),(Y),910) +#define get_csv2_int_pos910(X,Y) get_csv2_int((X),(Y),910) +#define get_csv2_llong_pos910(X,Y) get_csv2_llong((X),(Y),910) +#define get_csv2_float_pos910(X,Y) get_csv2_float((X),(Y),910) +#define get_csv2_uint_pos911(X,Y) get_csv2_uint((X),(Y),911) +#define get_csv2_ullong_pos911(X,Y) get_csv2_ullong((X),(Y),911) +#define get_csv2_ip_pos911(X,Y) get_csv2_ip((X),(Y),911) +#define get_csv2_ipv6_pos911(X,Y) get_csv2_ipv6((X),(Y),911) +#define get_csv2_string_pos911(X,Y) get_csv2_string((X),(Y),911) +#define get_csv2_v_str_pos911(X,Y) get_csv2_string((X),(Y),911) +#define get_csv2_bool_pos911(X,Y) get_csv2_bool((X),(Y),911) +#define get_csv2_int_pos911(X,Y) get_csv2_int((X),(Y),911) +#define get_csv2_llong_pos911(X,Y) get_csv2_llong((X),(Y),911) +#define get_csv2_float_pos911(X,Y) get_csv2_float((X),(Y),911) +#define get_csv2_uint_pos912(X,Y) get_csv2_uint((X),(Y),912) +#define get_csv2_ullong_pos912(X,Y) get_csv2_ullong((X),(Y),912) +#define get_csv2_ip_pos912(X,Y) get_csv2_ip((X),(Y),912) +#define get_csv2_ipv6_pos912(X,Y) get_csv2_ipv6((X),(Y),912) +#define get_csv2_string_pos912(X,Y) get_csv2_string((X),(Y),912) +#define get_csv2_v_str_pos912(X,Y) get_csv2_string((X),(Y),912) +#define get_csv2_bool_pos912(X,Y) get_csv2_bool((X),(Y),912) +#define get_csv2_int_pos912(X,Y) get_csv2_int((X),(Y),912) +#define get_csv2_llong_pos912(X,Y) get_csv2_llong((X),(Y),912) +#define get_csv2_float_pos912(X,Y) get_csv2_float((X),(Y),912) +#define get_csv2_uint_pos913(X,Y) get_csv2_uint((X),(Y),913) +#define get_csv2_ullong_pos913(X,Y) get_csv2_ullong((X),(Y),913) +#define get_csv2_ip_pos913(X,Y) get_csv2_ip((X),(Y),913) +#define get_csv2_ipv6_pos913(X,Y) get_csv2_ipv6((X),(Y),913) +#define get_csv2_string_pos913(X,Y) get_csv2_string((X),(Y),913) +#define get_csv2_v_str_pos913(X,Y) get_csv2_string((X),(Y),913) +#define get_csv2_bool_pos913(X,Y) get_csv2_bool((X),(Y),913) +#define get_csv2_int_pos913(X,Y) get_csv2_int((X),(Y),913) +#define get_csv2_llong_pos913(X,Y) get_csv2_llong((X),(Y),913) +#define get_csv2_float_pos913(X,Y) get_csv2_float((X),(Y),913) +#define get_csv2_uint_pos914(X,Y) get_csv2_uint((X),(Y),914) +#define get_csv2_ullong_pos914(X,Y) get_csv2_ullong((X),(Y),914) +#define get_csv2_ip_pos914(X,Y) get_csv2_ip((X),(Y),914) +#define get_csv2_ipv6_pos914(X,Y) get_csv2_ipv6((X),(Y),914) +#define get_csv2_string_pos914(X,Y) get_csv2_string((X),(Y),914) +#define get_csv2_v_str_pos914(X,Y) get_csv2_string((X),(Y),914) +#define get_csv2_bool_pos914(X,Y) get_csv2_bool((X),(Y),914) +#define get_csv2_int_pos914(X,Y) get_csv2_int((X),(Y),914) +#define get_csv2_llong_pos914(X,Y) get_csv2_llong((X),(Y),914) +#define get_csv2_float_pos914(X,Y) get_csv2_float((X),(Y),914) +#define get_csv2_uint_pos915(X,Y) get_csv2_uint((X),(Y),915) +#define get_csv2_ullong_pos915(X,Y) get_csv2_ullong((X),(Y),915) +#define get_csv2_ip_pos915(X,Y) get_csv2_ip((X),(Y),915) +#define get_csv2_ipv6_pos915(X,Y) get_csv2_ipv6((X),(Y),915) +#define get_csv2_string_pos915(X,Y) get_csv2_string((X),(Y),915) +#define get_csv2_v_str_pos915(X,Y) get_csv2_string((X),(Y),915) +#define get_csv2_bool_pos915(X,Y) get_csv2_bool((X),(Y),915) +#define get_csv2_int_pos915(X,Y) get_csv2_int((X),(Y),915) +#define get_csv2_llong_pos915(X,Y) get_csv2_llong((X),(Y),915) +#define get_csv2_float_pos915(X,Y) get_csv2_float((X),(Y),915) +#define get_csv2_uint_pos916(X,Y) get_csv2_uint((X),(Y),916) +#define get_csv2_ullong_pos916(X,Y) get_csv2_ullong((X),(Y),916) +#define get_csv2_ip_pos916(X,Y) get_csv2_ip((X),(Y),916) +#define get_csv2_ipv6_pos916(X,Y) get_csv2_ipv6((X),(Y),916) +#define get_csv2_string_pos916(X,Y) get_csv2_string((X),(Y),916) +#define get_csv2_v_str_pos916(X,Y) get_csv2_string((X),(Y),916) +#define get_csv2_bool_pos916(X,Y) get_csv2_bool((X),(Y),916) +#define get_csv2_int_pos916(X,Y) get_csv2_int((X),(Y),916) +#define get_csv2_llong_pos916(X,Y) get_csv2_llong((X),(Y),916) +#define get_csv2_float_pos916(X,Y) get_csv2_float((X),(Y),916) +#define get_csv2_uint_pos917(X,Y) get_csv2_uint((X),(Y),917) +#define get_csv2_ullong_pos917(X,Y) get_csv2_ullong((X),(Y),917) +#define get_csv2_ip_pos917(X,Y) get_csv2_ip((X),(Y),917) +#define get_csv2_ipv6_pos917(X,Y) get_csv2_ipv6((X),(Y),917) +#define get_csv2_string_pos917(X,Y) get_csv2_string((X),(Y),917) +#define get_csv2_v_str_pos917(X,Y) get_csv2_string((X),(Y),917) +#define get_csv2_bool_pos917(X,Y) get_csv2_bool((X),(Y),917) +#define get_csv2_int_pos917(X,Y) get_csv2_int((X),(Y),917) +#define get_csv2_llong_pos917(X,Y) get_csv2_llong((X),(Y),917) +#define get_csv2_float_pos917(X,Y) get_csv2_float((X),(Y),917) +#define get_csv2_uint_pos918(X,Y) get_csv2_uint((X),(Y),918) +#define get_csv2_ullong_pos918(X,Y) get_csv2_ullong((X),(Y),918) +#define get_csv2_ip_pos918(X,Y) get_csv2_ip((X),(Y),918) +#define get_csv2_ipv6_pos918(X,Y) get_csv2_ipv6((X),(Y),918) +#define get_csv2_string_pos918(X,Y) get_csv2_string((X),(Y),918) +#define get_csv2_v_str_pos918(X,Y) get_csv2_string((X),(Y),918) +#define get_csv2_bool_pos918(X,Y) get_csv2_bool((X),(Y),918) +#define get_csv2_int_pos918(X,Y) get_csv2_int((X),(Y),918) +#define get_csv2_llong_pos918(X,Y) get_csv2_llong((X),(Y),918) +#define get_csv2_float_pos918(X,Y) get_csv2_float((X),(Y),918) +#define get_csv2_uint_pos919(X,Y) get_csv2_uint((X),(Y),919) +#define get_csv2_ullong_pos919(X,Y) get_csv2_ullong((X),(Y),919) +#define get_csv2_ip_pos919(X,Y) get_csv2_ip((X),(Y),919) +#define get_csv2_ipv6_pos919(X,Y) get_csv2_ipv6((X),(Y),919) +#define get_csv2_string_pos919(X,Y) get_csv2_string((X),(Y),919) +#define get_csv2_v_str_pos919(X,Y) get_csv2_string((X),(Y),919) +#define get_csv2_bool_pos919(X,Y) get_csv2_bool((X),(Y),919) +#define get_csv2_int_pos919(X,Y) get_csv2_int((X),(Y),919) +#define get_csv2_llong_pos919(X,Y) get_csv2_llong((X),(Y),919) +#define get_csv2_float_pos919(X,Y) get_csv2_float((X),(Y),919) +#define get_csv2_uint_pos920(X,Y) get_csv2_uint((X),(Y),920) +#define get_csv2_ullong_pos920(X,Y) get_csv2_ullong((X),(Y),920) +#define get_csv2_ip_pos920(X,Y) get_csv2_ip((X),(Y),920) +#define get_csv2_ipv6_pos920(X,Y) get_csv2_ipv6((X),(Y),920) +#define get_csv2_string_pos920(X,Y) get_csv2_string((X),(Y),920) +#define get_csv2_v_str_pos920(X,Y) get_csv2_string((X),(Y),920) +#define get_csv2_bool_pos920(X,Y) get_csv2_bool((X),(Y),920) +#define get_csv2_int_pos920(X,Y) get_csv2_int((X),(Y),920) +#define get_csv2_llong_pos920(X,Y) get_csv2_llong((X),(Y),920) +#define get_csv2_float_pos920(X,Y) get_csv2_float((X),(Y),920) +#define get_csv2_uint_pos921(X,Y) get_csv2_uint((X),(Y),921) +#define get_csv2_ullong_pos921(X,Y) get_csv2_ullong((X),(Y),921) +#define get_csv2_ip_pos921(X,Y) get_csv2_ip((X),(Y),921) +#define get_csv2_ipv6_pos921(X,Y) get_csv2_ipv6((X),(Y),921) +#define get_csv2_string_pos921(X,Y) get_csv2_string((X),(Y),921) +#define get_csv2_v_str_pos921(X,Y) get_csv2_string((X),(Y),921) +#define get_csv2_bool_pos921(X,Y) get_csv2_bool((X),(Y),921) +#define get_csv2_int_pos921(X,Y) get_csv2_int((X),(Y),921) +#define get_csv2_llong_pos921(X,Y) get_csv2_llong((X),(Y),921) +#define get_csv2_float_pos921(X,Y) get_csv2_float((X),(Y),921) +#define get_csv2_uint_pos922(X,Y) get_csv2_uint((X),(Y),922) +#define get_csv2_ullong_pos922(X,Y) get_csv2_ullong((X),(Y),922) +#define get_csv2_ip_pos922(X,Y) get_csv2_ip((X),(Y),922) +#define get_csv2_ipv6_pos922(X,Y) get_csv2_ipv6((X),(Y),922) +#define get_csv2_string_pos922(X,Y) get_csv2_string((X),(Y),922) +#define get_csv2_v_str_pos922(X,Y) get_csv2_string((X),(Y),922) +#define get_csv2_bool_pos922(X,Y) get_csv2_bool((X),(Y),922) +#define get_csv2_int_pos922(X,Y) get_csv2_int((X),(Y),922) +#define get_csv2_llong_pos922(X,Y) get_csv2_llong((X),(Y),922) +#define get_csv2_float_pos922(X,Y) get_csv2_float((X),(Y),922) +#define get_csv2_uint_pos923(X,Y) get_csv2_uint((X),(Y),923) +#define get_csv2_ullong_pos923(X,Y) get_csv2_ullong((X),(Y),923) +#define get_csv2_ip_pos923(X,Y) get_csv2_ip((X),(Y),923) +#define get_csv2_ipv6_pos923(X,Y) get_csv2_ipv6((X),(Y),923) +#define get_csv2_string_pos923(X,Y) get_csv2_string((X),(Y),923) +#define get_csv2_v_str_pos923(X,Y) get_csv2_string((X),(Y),923) +#define get_csv2_bool_pos923(X,Y) get_csv2_bool((X),(Y),923) +#define get_csv2_int_pos923(X,Y) get_csv2_int((X),(Y),923) +#define get_csv2_llong_pos923(X,Y) get_csv2_llong((X),(Y),923) +#define get_csv2_float_pos923(X,Y) get_csv2_float((X),(Y),923) +#define get_csv2_uint_pos924(X,Y) get_csv2_uint((X),(Y),924) +#define get_csv2_ullong_pos924(X,Y) get_csv2_ullong((X),(Y),924) +#define get_csv2_ip_pos924(X,Y) get_csv2_ip((X),(Y),924) +#define get_csv2_ipv6_pos924(X,Y) get_csv2_ipv6((X),(Y),924) +#define get_csv2_string_pos924(X,Y) get_csv2_string((X),(Y),924) +#define get_csv2_v_str_pos924(X,Y) get_csv2_string((X),(Y),924) +#define get_csv2_bool_pos924(X,Y) get_csv2_bool((X),(Y),924) +#define get_csv2_int_pos924(X,Y) get_csv2_int((X),(Y),924) +#define get_csv2_llong_pos924(X,Y) get_csv2_llong((X),(Y),924) +#define get_csv2_float_pos924(X,Y) get_csv2_float((X),(Y),924) +#define get_csv2_uint_pos925(X,Y) get_csv2_uint((X),(Y),925) +#define get_csv2_ullong_pos925(X,Y) get_csv2_ullong((X),(Y),925) +#define get_csv2_ip_pos925(X,Y) get_csv2_ip((X),(Y),925) +#define get_csv2_ipv6_pos925(X,Y) get_csv2_ipv6((X),(Y),925) +#define get_csv2_string_pos925(X,Y) get_csv2_string((X),(Y),925) +#define get_csv2_v_str_pos925(X,Y) get_csv2_string((X),(Y),925) +#define get_csv2_bool_pos925(X,Y) get_csv2_bool((X),(Y),925) +#define get_csv2_int_pos925(X,Y) get_csv2_int((X),(Y),925) +#define get_csv2_llong_pos925(X,Y) get_csv2_llong((X),(Y),925) +#define get_csv2_float_pos925(X,Y) get_csv2_float((X),(Y),925) +#define get_csv2_uint_pos926(X,Y) get_csv2_uint((X),(Y),926) +#define get_csv2_ullong_pos926(X,Y) get_csv2_ullong((X),(Y),926) +#define get_csv2_ip_pos926(X,Y) get_csv2_ip((X),(Y),926) +#define get_csv2_ipv6_pos926(X,Y) get_csv2_ipv6((X),(Y),926) +#define get_csv2_string_pos926(X,Y) get_csv2_string((X),(Y),926) +#define get_csv2_v_str_pos926(X,Y) get_csv2_string((X),(Y),926) +#define get_csv2_bool_pos926(X,Y) get_csv2_bool((X),(Y),926) +#define get_csv2_int_pos926(X,Y) get_csv2_int((X),(Y),926) +#define get_csv2_llong_pos926(X,Y) get_csv2_llong((X),(Y),926) +#define get_csv2_float_pos926(X,Y) get_csv2_float((X),(Y),926) +#define get_csv2_uint_pos927(X,Y) get_csv2_uint((X),(Y),927) +#define get_csv2_ullong_pos927(X,Y) get_csv2_ullong((X),(Y),927) +#define get_csv2_ip_pos927(X,Y) get_csv2_ip((X),(Y),927) +#define get_csv2_ipv6_pos927(X,Y) get_csv2_ipv6((X),(Y),927) +#define get_csv2_string_pos927(X,Y) get_csv2_string((X),(Y),927) +#define get_csv2_v_str_pos927(X,Y) get_csv2_string((X),(Y),927) +#define get_csv2_bool_pos927(X,Y) get_csv2_bool((X),(Y),927) +#define get_csv2_int_pos927(X,Y) get_csv2_int((X),(Y),927) +#define get_csv2_llong_pos927(X,Y) get_csv2_llong((X),(Y),927) +#define get_csv2_float_pos927(X,Y) get_csv2_float((X),(Y),927) +#define get_csv2_uint_pos928(X,Y) get_csv2_uint((X),(Y),928) +#define get_csv2_ullong_pos928(X,Y) get_csv2_ullong((X),(Y),928) +#define get_csv2_ip_pos928(X,Y) get_csv2_ip((X),(Y),928) +#define get_csv2_ipv6_pos928(X,Y) get_csv2_ipv6((X),(Y),928) +#define get_csv2_string_pos928(X,Y) get_csv2_string((X),(Y),928) +#define get_csv2_v_str_pos928(X,Y) get_csv2_string((X),(Y),928) +#define get_csv2_bool_pos928(X,Y) get_csv2_bool((X),(Y),928) +#define get_csv2_int_pos928(X,Y) get_csv2_int((X),(Y),928) +#define get_csv2_llong_pos928(X,Y) get_csv2_llong((X),(Y),928) +#define get_csv2_float_pos928(X,Y) get_csv2_float((X),(Y),928) +#define get_csv2_uint_pos929(X,Y) get_csv2_uint((X),(Y),929) +#define get_csv2_ullong_pos929(X,Y) get_csv2_ullong((X),(Y),929) +#define get_csv2_ip_pos929(X,Y) get_csv2_ip((X),(Y),929) +#define get_csv2_ipv6_pos929(X,Y) get_csv2_ipv6((X),(Y),929) +#define get_csv2_string_pos929(X,Y) get_csv2_string((X),(Y),929) +#define get_csv2_v_str_pos929(X,Y) get_csv2_string((X),(Y),929) +#define get_csv2_bool_pos929(X,Y) get_csv2_bool((X),(Y),929) +#define get_csv2_int_pos929(X,Y) get_csv2_int((X),(Y),929) +#define get_csv2_llong_pos929(X,Y) get_csv2_llong((X),(Y),929) +#define get_csv2_float_pos929(X,Y) get_csv2_float((X),(Y),929) +#define get_csv2_uint_pos930(X,Y) get_csv2_uint((X),(Y),930) +#define get_csv2_ullong_pos930(X,Y) get_csv2_ullong((X),(Y),930) +#define get_csv2_ip_pos930(X,Y) get_csv2_ip((X),(Y),930) +#define get_csv2_ipv6_pos930(X,Y) get_csv2_ipv6((X),(Y),930) +#define get_csv2_string_pos930(X,Y) get_csv2_string((X),(Y),930) +#define get_csv2_v_str_pos930(X,Y) get_csv2_string((X),(Y),930) +#define get_csv2_bool_pos930(X,Y) get_csv2_bool((X),(Y),930) +#define get_csv2_int_pos930(X,Y) get_csv2_int((X),(Y),930) +#define get_csv2_llong_pos930(X,Y) get_csv2_llong((X),(Y),930) +#define get_csv2_float_pos930(X,Y) get_csv2_float((X),(Y),930) +#define get_csv2_uint_pos931(X,Y) get_csv2_uint((X),(Y),931) +#define get_csv2_ullong_pos931(X,Y) get_csv2_ullong((X),(Y),931) +#define get_csv2_ip_pos931(X,Y) get_csv2_ip((X),(Y),931) +#define get_csv2_ipv6_pos931(X,Y) get_csv2_ipv6((X),(Y),931) +#define get_csv2_string_pos931(X,Y) get_csv2_string((X),(Y),931) +#define get_csv2_v_str_pos931(X,Y) get_csv2_string((X),(Y),931) +#define get_csv2_bool_pos931(X,Y) get_csv2_bool((X),(Y),931) +#define get_csv2_int_pos931(X,Y) get_csv2_int((X),(Y),931) +#define get_csv2_llong_pos931(X,Y) get_csv2_llong((X),(Y),931) +#define get_csv2_float_pos931(X,Y) get_csv2_float((X),(Y),931) +#define get_csv2_uint_pos932(X,Y) get_csv2_uint((X),(Y),932) +#define get_csv2_ullong_pos932(X,Y) get_csv2_ullong((X),(Y),932) +#define get_csv2_ip_pos932(X,Y) get_csv2_ip((X),(Y),932) +#define get_csv2_ipv6_pos932(X,Y) get_csv2_ipv6((X),(Y),932) +#define get_csv2_string_pos932(X,Y) get_csv2_string((X),(Y),932) +#define get_csv2_v_str_pos932(X,Y) get_csv2_string((X),(Y),932) +#define get_csv2_bool_pos932(X,Y) get_csv2_bool((X),(Y),932) +#define get_csv2_int_pos932(X,Y) get_csv2_int((X),(Y),932) +#define get_csv2_llong_pos932(X,Y) get_csv2_llong((X),(Y),932) +#define get_csv2_float_pos932(X,Y) get_csv2_float((X),(Y),932) +#define get_csv2_uint_pos933(X,Y) get_csv2_uint((X),(Y),933) +#define get_csv2_ullong_pos933(X,Y) get_csv2_ullong((X),(Y),933) +#define get_csv2_ip_pos933(X,Y) get_csv2_ip((X),(Y),933) +#define get_csv2_ipv6_pos933(X,Y) get_csv2_ipv6((X),(Y),933) +#define get_csv2_string_pos933(X,Y) get_csv2_string((X),(Y),933) +#define get_csv2_v_str_pos933(X,Y) get_csv2_string((X),(Y),933) +#define get_csv2_bool_pos933(X,Y) get_csv2_bool((X),(Y),933) +#define get_csv2_int_pos933(X,Y) get_csv2_int((X),(Y),933) +#define get_csv2_llong_pos933(X,Y) get_csv2_llong((X),(Y),933) +#define get_csv2_float_pos933(X,Y) get_csv2_float((X),(Y),933) +#define get_csv2_uint_pos934(X,Y) get_csv2_uint((X),(Y),934) +#define get_csv2_ullong_pos934(X,Y) get_csv2_ullong((X),(Y),934) +#define get_csv2_ip_pos934(X,Y) get_csv2_ip((X),(Y),934) +#define get_csv2_ipv6_pos934(X,Y) get_csv2_ipv6((X),(Y),934) +#define get_csv2_string_pos934(X,Y) get_csv2_string((X),(Y),934) +#define get_csv2_v_str_pos934(X,Y) get_csv2_string((X),(Y),934) +#define get_csv2_bool_pos934(X,Y) get_csv2_bool((X),(Y),934) +#define get_csv2_int_pos934(X,Y) get_csv2_int((X),(Y),934) +#define get_csv2_llong_pos934(X,Y) get_csv2_llong((X),(Y),934) +#define get_csv2_float_pos934(X,Y) get_csv2_float((X),(Y),934) +#define get_csv2_uint_pos935(X,Y) get_csv2_uint((X),(Y),935) +#define get_csv2_ullong_pos935(X,Y) get_csv2_ullong((X),(Y),935) +#define get_csv2_ip_pos935(X,Y) get_csv2_ip((X),(Y),935) +#define get_csv2_ipv6_pos935(X,Y) get_csv2_ipv6((X),(Y),935) +#define get_csv2_string_pos935(X,Y) get_csv2_string((X),(Y),935) +#define get_csv2_v_str_pos935(X,Y) get_csv2_string((X),(Y),935) +#define get_csv2_bool_pos935(X,Y) get_csv2_bool((X),(Y),935) +#define get_csv2_int_pos935(X,Y) get_csv2_int((X),(Y),935) +#define get_csv2_llong_pos935(X,Y) get_csv2_llong((X),(Y),935) +#define get_csv2_float_pos935(X,Y) get_csv2_float((X),(Y),935) +#define get_csv2_uint_pos936(X,Y) get_csv2_uint((X),(Y),936) +#define get_csv2_ullong_pos936(X,Y) get_csv2_ullong((X),(Y),936) +#define get_csv2_ip_pos936(X,Y) get_csv2_ip((X),(Y),936) +#define get_csv2_ipv6_pos936(X,Y) get_csv2_ipv6((X),(Y),936) +#define get_csv2_string_pos936(X,Y) get_csv2_string((X),(Y),936) +#define get_csv2_v_str_pos936(X,Y) get_csv2_string((X),(Y),936) +#define get_csv2_bool_pos936(X,Y) get_csv2_bool((X),(Y),936) +#define get_csv2_int_pos936(X,Y) get_csv2_int((X),(Y),936) +#define get_csv2_llong_pos936(X,Y) get_csv2_llong((X),(Y),936) +#define get_csv2_float_pos936(X,Y) get_csv2_float((X),(Y),936) +#define get_csv2_uint_pos937(X,Y) get_csv2_uint((X),(Y),937) +#define get_csv2_ullong_pos937(X,Y) get_csv2_ullong((X),(Y),937) +#define get_csv2_ip_pos937(X,Y) get_csv2_ip((X),(Y),937) +#define get_csv2_ipv6_pos937(X,Y) get_csv2_ipv6((X),(Y),937) +#define get_csv2_string_pos937(X,Y) get_csv2_string((X),(Y),937) +#define get_csv2_v_str_pos937(X,Y) get_csv2_string((X),(Y),937) +#define get_csv2_bool_pos937(X,Y) get_csv2_bool((X),(Y),937) +#define get_csv2_int_pos937(X,Y) get_csv2_int((X),(Y),937) +#define get_csv2_llong_pos937(X,Y) get_csv2_llong((X),(Y),937) +#define get_csv2_float_pos937(X,Y) get_csv2_float((X),(Y),937) +#define get_csv2_uint_pos938(X,Y) get_csv2_uint((X),(Y),938) +#define get_csv2_ullong_pos938(X,Y) get_csv2_ullong((X),(Y),938) +#define get_csv2_ip_pos938(X,Y) get_csv2_ip((X),(Y),938) +#define get_csv2_ipv6_pos938(X,Y) get_csv2_ipv6((X),(Y),938) +#define get_csv2_string_pos938(X,Y) get_csv2_string((X),(Y),938) +#define get_csv2_v_str_pos938(X,Y) get_csv2_string((X),(Y),938) +#define get_csv2_bool_pos938(X,Y) get_csv2_bool((X),(Y),938) +#define get_csv2_int_pos938(X,Y) get_csv2_int((X),(Y),938) +#define get_csv2_llong_pos938(X,Y) get_csv2_llong((X),(Y),938) +#define get_csv2_float_pos938(X,Y) get_csv2_float((X),(Y),938) +#define get_csv2_uint_pos939(X,Y) get_csv2_uint((X),(Y),939) +#define get_csv2_ullong_pos939(X,Y) get_csv2_ullong((X),(Y),939) +#define get_csv2_ip_pos939(X,Y) get_csv2_ip((X),(Y),939) +#define get_csv2_ipv6_pos939(X,Y) get_csv2_ipv6((X),(Y),939) +#define get_csv2_string_pos939(X,Y) get_csv2_string((X),(Y),939) +#define get_csv2_v_str_pos939(X,Y) get_csv2_string((X),(Y),939) +#define get_csv2_bool_pos939(X,Y) get_csv2_bool((X),(Y),939) +#define get_csv2_int_pos939(X,Y) get_csv2_int((X),(Y),939) +#define get_csv2_llong_pos939(X,Y) get_csv2_llong((X),(Y),939) +#define get_csv2_float_pos939(X,Y) get_csv2_float((X),(Y),939) +#define get_csv2_uint_pos940(X,Y) get_csv2_uint((X),(Y),940) +#define get_csv2_ullong_pos940(X,Y) get_csv2_ullong((X),(Y),940) +#define get_csv2_ip_pos940(X,Y) get_csv2_ip((X),(Y),940) +#define get_csv2_ipv6_pos940(X,Y) get_csv2_ipv6((X),(Y),940) +#define get_csv2_string_pos940(X,Y) get_csv2_string((X),(Y),940) +#define get_csv2_v_str_pos940(X,Y) get_csv2_string((X),(Y),940) +#define get_csv2_bool_pos940(X,Y) get_csv2_bool((X),(Y),940) +#define get_csv2_int_pos940(X,Y) get_csv2_int((X),(Y),940) +#define get_csv2_llong_pos940(X,Y) get_csv2_llong((X),(Y),940) +#define get_csv2_float_pos940(X,Y) get_csv2_float((X),(Y),940) +#define get_csv2_uint_pos941(X,Y) get_csv2_uint((X),(Y),941) +#define get_csv2_ullong_pos941(X,Y) get_csv2_ullong((X),(Y),941) +#define get_csv2_ip_pos941(X,Y) get_csv2_ip((X),(Y),941) +#define get_csv2_ipv6_pos941(X,Y) get_csv2_ipv6((X),(Y),941) +#define get_csv2_string_pos941(X,Y) get_csv2_string((X),(Y),941) +#define get_csv2_v_str_pos941(X,Y) get_csv2_string((X),(Y),941) +#define get_csv2_bool_pos941(X,Y) get_csv2_bool((X),(Y),941) +#define get_csv2_int_pos941(X,Y) get_csv2_int((X),(Y),941) +#define get_csv2_llong_pos941(X,Y) get_csv2_llong((X),(Y),941) +#define get_csv2_float_pos941(X,Y) get_csv2_float((X),(Y),941) +#define get_csv2_uint_pos942(X,Y) get_csv2_uint((X),(Y),942) +#define get_csv2_ullong_pos942(X,Y) get_csv2_ullong((X),(Y),942) +#define get_csv2_ip_pos942(X,Y) get_csv2_ip((X),(Y),942) +#define get_csv2_ipv6_pos942(X,Y) get_csv2_ipv6((X),(Y),942) +#define get_csv2_string_pos942(X,Y) get_csv2_string((X),(Y),942) +#define get_csv2_v_str_pos942(X,Y) get_csv2_string((X),(Y),942) +#define get_csv2_bool_pos942(X,Y) get_csv2_bool((X),(Y),942) +#define get_csv2_int_pos942(X,Y) get_csv2_int((X),(Y),942) +#define get_csv2_llong_pos942(X,Y) get_csv2_llong((X),(Y),942) +#define get_csv2_float_pos942(X,Y) get_csv2_float((X),(Y),942) +#define get_csv2_uint_pos943(X,Y) get_csv2_uint((X),(Y),943) +#define get_csv2_ullong_pos943(X,Y) get_csv2_ullong((X),(Y),943) +#define get_csv2_ip_pos943(X,Y) get_csv2_ip((X),(Y),943) +#define get_csv2_ipv6_pos943(X,Y) get_csv2_ipv6((X),(Y),943) +#define get_csv2_string_pos943(X,Y) get_csv2_string((X),(Y),943) +#define get_csv2_v_str_pos943(X,Y) get_csv2_string((X),(Y),943) +#define get_csv2_bool_pos943(X,Y) get_csv2_bool((X),(Y),943) +#define get_csv2_int_pos943(X,Y) get_csv2_int((X),(Y),943) +#define get_csv2_llong_pos943(X,Y) get_csv2_llong((X),(Y),943) +#define get_csv2_float_pos943(X,Y) get_csv2_float((X),(Y),943) +#define get_csv2_uint_pos944(X,Y) get_csv2_uint((X),(Y),944) +#define get_csv2_ullong_pos944(X,Y) get_csv2_ullong((X),(Y),944) +#define get_csv2_ip_pos944(X,Y) get_csv2_ip((X),(Y),944) +#define get_csv2_ipv6_pos944(X,Y) get_csv2_ipv6((X),(Y),944) +#define get_csv2_string_pos944(X,Y) get_csv2_string((X),(Y),944) +#define get_csv2_v_str_pos944(X,Y) get_csv2_string((X),(Y),944) +#define get_csv2_bool_pos944(X,Y) get_csv2_bool((X),(Y),944) +#define get_csv2_int_pos944(X,Y) get_csv2_int((X),(Y),944) +#define get_csv2_llong_pos944(X,Y) get_csv2_llong((X),(Y),944) +#define get_csv2_float_pos944(X,Y) get_csv2_float((X),(Y),944) +#define get_csv2_uint_pos945(X,Y) get_csv2_uint((X),(Y),945) +#define get_csv2_ullong_pos945(X,Y) get_csv2_ullong((X),(Y),945) +#define get_csv2_ip_pos945(X,Y) get_csv2_ip((X),(Y),945) +#define get_csv2_ipv6_pos945(X,Y) get_csv2_ipv6((X),(Y),945) +#define get_csv2_string_pos945(X,Y) get_csv2_string((X),(Y),945) +#define get_csv2_v_str_pos945(X,Y) get_csv2_string((X),(Y),945) +#define get_csv2_bool_pos945(X,Y) get_csv2_bool((X),(Y),945) +#define get_csv2_int_pos945(X,Y) get_csv2_int((X),(Y),945) +#define get_csv2_llong_pos945(X,Y) get_csv2_llong((X),(Y),945) +#define get_csv2_float_pos945(X,Y) get_csv2_float((X),(Y),945) +#define get_csv2_uint_pos946(X,Y) get_csv2_uint((X),(Y),946) +#define get_csv2_ullong_pos946(X,Y) get_csv2_ullong((X),(Y),946) +#define get_csv2_ip_pos946(X,Y) get_csv2_ip((X),(Y),946) +#define get_csv2_ipv6_pos946(X,Y) get_csv2_ipv6((X),(Y),946) +#define get_csv2_string_pos946(X,Y) get_csv2_string((X),(Y),946) +#define get_csv2_v_str_pos946(X,Y) get_csv2_string((X),(Y),946) +#define get_csv2_bool_pos946(X,Y) get_csv2_bool((X),(Y),946) +#define get_csv2_int_pos946(X,Y) get_csv2_int((X),(Y),946) +#define get_csv2_llong_pos946(X,Y) get_csv2_llong((X),(Y),946) +#define get_csv2_float_pos946(X,Y) get_csv2_float((X),(Y),946) +#define get_csv2_uint_pos947(X,Y) get_csv2_uint((X),(Y),947) +#define get_csv2_ullong_pos947(X,Y) get_csv2_ullong((X),(Y),947) +#define get_csv2_ip_pos947(X,Y) get_csv2_ip((X),(Y),947) +#define get_csv2_ipv6_pos947(X,Y) get_csv2_ipv6((X),(Y),947) +#define get_csv2_string_pos947(X,Y) get_csv2_string((X),(Y),947) +#define get_csv2_v_str_pos947(X,Y) get_csv2_string((X),(Y),947) +#define get_csv2_bool_pos947(X,Y) get_csv2_bool((X),(Y),947) +#define get_csv2_int_pos947(X,Y) get_csv2_int((X),(Y),947) +#define get_csv2_llong_pos947(X,Y) get_csv2_llong((X),(Y),947) +#define get_csv2_float_pos947(X,Y) get_csv2_float((X),(Y),947) +#define get_csv2_uint_pos948(X,Y) get_csv2_uint((X),(Y),948) +#define get_csv2_ullong_pos948(X,Y) get_csv2_ullong((X),(Y),948) +#define get_csv2_ip_pos948(X,Y) get_csv2_ip((X),(Y),948) +#define get_csv2_ipv6_pos948(X,Y) get_csv2_ipv6((X),(Y),948) +#define get_csv2_string_pos948(X,Y) get_csv2_string((X),(Y),948) +#define get_csv2_v_str_pos948(X,Y) get_csv2_string((X),(Y),948) +#define get_csv2_bool_pos948(X,Y) get_csv2_bool((X),(Y),948) +#define get_csv2_int_pos948(X,Y) get_csv2_int((X),(Y),948) +#define get_csv2_llong_pos948(X,Y) get_csv2_llong((X),(Y),948) +#define get_csv2_float_pos948(X,Y) get_csv2_float((X),(Y),948) +#define get_csv2_uint_pos949(X,Y) get_csv2_uint((X),(Y),949) +#define get_csv2_ullong_pos949(X,Y) get_csv2_ullong((X),(Y),949) +#define get_csv2_ip_pos949(X,Y) get_csv2_ip((X),(Y),949) +#define get_csv2_ipv6_pos949(X,Y) get_csv2_ipv6((X),(Y),949) +#define get_csv2_string_pos949(X,Y) get_csv2_string((X),(Y),949) +#define get_csv2_v_str_pos949(X,Y) get_csv2_string((X),(Y),949) +#define get_csv2_bool_pos949(X,Y) get_csv2_bool((X),(Y),949) +#define get_csv2_int_pos949(X,Y) get_csv2_int((X),(Y),949) +#define get_csv2_llong_pos949(X,Y) get_csv2_llong((X),(Y),949) +#define get_csv2_float_pos949(X,Y) get_csv2_float((X),(Y),949) +#define get_csv2_uint_pos950(X,Y) get_csv2_uint((X),(Y),950) +#define get_csv2_ullong_pos950(X,Y) get_csv2_ullong((X),(Y),950) +#define get_csv2_ip_pos950(X,Y) get_csv2_ip((X),(Y),950) +#define get_csv2_ipv6_pos950(X,Y) get_csv2_ipv6((X),(Y),950) +#define get_csv2_string_pos950(X,Y) get_csv2_string((X),(Y),950) +#define get_csv2_v_str_pos950(X,Y) get_csv2_string((X),(Y),950) +#define get_csv2_bool_pos950(X,Y) get_csv2_bool((X),(Y),950) +#define get_csv2_int_pos950(X,Y) get_csv2_int((X),(Y),950) +#define get_csv2_llong_pos950(X,Y) get_csv2_llong((X),(Y),950) +#define get_csv2_float_pos950(X,Y) get_csv2_float((X),(Y),950) +#define get_csv2_uint_pos951(X,Y) get_csv2_uint((X),(Y),951) +#define get_csv2_ullong_pos951(X,Y) get_csv2_ullong((X),(Y),951) +#define get_csv2_ip_pos951(X,Y) get_csv2_ip((X),(Y),951) +#define get_csv2_ipv6_pos951(X,Y) get_csv2_ipv6((X),(Y),951) +#define get_csv2_string_pos951(X,Y) get_csv2_string((X),(Y),951) +#define get_csv2_v_str_pos951(X,Y) get_csv2_string((X),(Y),951) +#define get_csv2_bool_pos951(X,Y) get_csv2_bool((X),(Y),951) +#define get_csv2_int_pos951(X,Y) get_csv2_int((X),(Y),951) +#define get_csv2_llong_pos951(X,Y) get_csv2_llong((X),(Y),951) +#define get_csv2_float_pos951(X,Y) get_csv2_float((X),(Y),951) +#define get_csv2_uint_pos952(X,Y) get_csv2_uint((X),(Y),952) +#define get_csv2_ullong_pos952(X,Y) get_csv2_ullong((X),(Y),952) +#define get_csv2_ip_pos952(X,Y) get_csv2_ip((X),(Y),952) +#define get_csv2_ipv6_pos952(X,Y) get_csv2_ipv6((X),(Y),952) +#define get_csv2_string_pos952(X,Y) get_csv2_string((X),(Y),952) +#define get_csv2_v_str_pos952(X,Y) get_csv2_string((X),(Y),952) +#define get_csv2_bool_pos952(X,Y) get_csv2_bool((X),(Y),952) +#define get_csv2_int_pos952(X,Y) get_csv2_int((X),(Y),952) +#define get_csv2_llong_pos952(X,Y) get_csv2_llong((X),(Y),952) +#define get_csv2_float_pos952(X,Y) get_csv2_float((X),(Y),952) +#define get_csv2_uint_pos953(X,Y) get_csv2_uint((X),(Y),953) +#define get_csv2_ullong_pos953(X,Y) get_csv2_ullong((X),(Y),953) +#define get_csv2_ip_pos953(X,Y) get_csv2_ip((X),(Y),953) +#define get_csv2_ipv6_pos953(X,Y) get_csv2_ipv6((X),(Y),953) +#define get_csv2_string_pos953(X,Y) get_csv2_string((X),(Y),953) +#define get_csv2_v_str_pos953(X,Y) get_csv2_string((X),(Y),953) +#define get_csv2_bool_pos953(X,Y) get_csv2_bool((X),(Y),953) +#define get_csv2_int_pos953(X,Y) get_csv2_int((X),(Y),953) +#define get_csv2_llong_pos953(X,Y) get_csv2_llong((X),(Y),953) +#define get_csv2_float_pos953(X,Y) get_csv2_float((X),(Y),953) +#define get_csv2_uint_pos954(X,Y) get_csv2_uint((X),(Y),954) +#define get_csv2_ullong_pos954(X,Y) get_csv2_ullong((X),(Y),954) +#define get_csv2_ip_pos954(X,Y) get_csv2_ip((X),(Y),954) +#define get_csv2_ipv6_pos954(X,Y) get_csv2_ipv6((X),(Y),954) +#define get_csv2_string_pos954(X,Y) get_csv2_string((X),(Y),954) +#define get_csv2_v_str_pos954(X,Y) get_csv2_string((X),(Y),954) +#define get_csv2_bool_pos954(X,Y) get_csv2_bool((X),(Y),954) +#define get_csv2_int_pos954(X,Y) get_csv2_int((X),(Y),954) +#define get_csv2_llong_pos954(X,Y) get_csv2_llong((X),(Y),954) +#define get_csv2_float_pos954(X,Y) get_csv2_float((X),(Y),954) +#define get_csv2_uint_pos955(X,Y) get_csv2_uint((X),(Y),955) +#define get_csv2_ullong_pos955(X,Y) get_csv2_ullong((X),(Y),955) +#define get_csv2_ip_pos955(X,Y) get_csv2_ip((X),(Y),955) +#define get_csv2_ipv6_pos955(X,Y) get_csv2_ipv6((X),(Y),955) +#define get_csv2_string_pos955(X,Y) get_csv2_string((X),(Y),955) +#define get_csv2_v_str_pos955(X,Y) get_csv2_string((X),(Y),955) +#define get_csv2_bool_pos955(X,Y) get_csv2_bool((X),(Y),955) +#define get_csv2_int_pos955(X,Y) get_csv2_int((X),(Y),955) +#define get_csv2_llong_pos955(X,Y) get_csv2_llong((X),(Y),955) +#define get_csv2_float_pos955(X,Y) get_csv2_float((X),(Y),955) +#define get_csv2_uint_pos956(X,Y) get_csv2_uint((X),(Y),956) +#define get_csv2_ullong_pos956(X,Y) get_csv2_ullong((X),(Y),956) +#define get_csv2_ip_pos956(X,Y) get_csv2_ip((X),(Y),956) +#define get_csv2_ipv6_pos956(X,Y) get_csv2_ipv6((X),(Y),956) +#define get_csv2_string_pos956(X,Y) get_csv2_string((X),(Y),956) +#define get_csv2_v_str_pos956(X,Y) get_csv2_string((X),(Y),956) +#define get_csv2_bool_pos956(X,Y) get_csv2_bool((X),(Y),956) +#define get_csv2_int_pos956(X,Y) get_csv2_int((X),(Y),956) +#define get_csv2_llong_pos956(X,Y) get_csv2_llong((X),(Y),956) +#define get_csv2_float_pos956(X,Y) get_csv2_float((X),(Y),956) +#define get_csv2_uint_pos957(X,Y) get_csv2_uint((X),(Y),957) +#define get_csv2_ullong_pos957(X,Y) get_csv2_ullong((X),(Y),957) +#define get_csv2_ip_pos957(X,Y) get_csv2_ip((X),(Y),957) +#define get_csv2_ipv6_pos957(X,Y) get_csv2_ipv6((X),(Y),957) +#define get_csv2_string_pos957(X,Y) get_csv2_string((X),(Y),957) +#define get_csv2_v_str_pos957(X,Y) get_csv2_string((X),(Y),957) +#define get_csv2_bool_pos957(X,Y) get_csv2_bool((X),(Y),957) +#define get_csv2_int_pos957(X,Y) get_csv2_int((X),(Y),957) +#define get_csv2_llong_pos957(X,Y) get_csv2_llong((X),(Y),957) +#define get_csv2_float_pos957(X,Y) get_csv2_float((X),(Y),957) +#define get_csv2_uint_pos958(X,Y) get_csv2_uint((X),(Y),958) +#define get_csv2_ullong_pos958(X,Y) get_csv2_ullong((X),(Y),958) +#define get_csv2_ip_pos958(X,Y) get_csv2_ip((X),(Y),958) +#define get_csv2_ipv6_pos958(X,Y) get_csv2_ipv6((X),(Y),958) +#define get_csv2_string_pos958(X,Y) get_csv2_string((X),(Y),958) +#define get_csv2_v_str_pos958(X,Y) get_csv2_string((X),(Y),958) +#define get_csv2_bool_pos958(X,Y) get_csv2_bool((X),(Y),958) +#define get_csv2_int_pos958(X,Y) get_csv2_int((X),(Y),958) +#define get_csv2_llong_pos958(X,Y) get_csv2_llong((X),(Y),958) +#define get_csv2_float_pos958(X,Y) get_csv2_float((X),(Y),958) +#define get_csv2_uint_pos959(X,Y) get_csv2_uint((X),(Y),959) +#define get_csv2_ullong_pos959(X,Y) get_csv2_ullong((X),(Y),959) +#define get_csv2_ip_pos959(X,Y) get_csv2_ip((X),(Y),959) +#define get_csv2_ipv6_pos959(X,Y) get_csv2_ipv6((X),(Y),959) +#define get_csv2_string_pos959(X,Y) get_csv2_string((X),(Y),959) +#define get_csv2_v_str_pos959(X,Y) get_csv2_string((X),(Y),959) +#define get_csv2_bool_pos959(X,Y) get_csv2_bool((X),(Y),959) +#define get_csv2_int_pos959(X,Y) get_csv2_int((X),(Y),959) +#define get_csv2_llong_pos959(X,Y) get_csv2_llong((X),(Y),959) +#define get_csv2_float_pos959(X,Y) get_csv2_float((X),(Y),959) +#define get_csv2_uint_pos960(X,Y) get_csv2_uint((X),(Y),960) +#define get_csv2_ullong_pos960(X,Y) get_csv2_ullong((X),(Y),960) +#define get_csv2_ip_pos960(X,Y) get_csv2_ip((X),(Y),960) +#define get_csv2_ipv6_pos960(X,Y) get_csv2_ipv6((X),(Y),960) +#define get_csv2_string_pos960(X,Y) get_csv2_string((X),(Y),960) +#define get_csv2_v_str_pos960(X,Y) get_csv2_string((X),(Y),960) +#define get_csv2_bool_pos960(X,Y) get_csv2_bool((X),(Y),960) +#define get_csv2_int_pos960(X,Y) get_csv2_int((X),(Y),960) +#define get_csv2_llong_pos960(X,Y) get_csv2_llong((X),(Y),960) +#define get_csv2_float_pos960(X,Y) get_csv2_float((X),(Y),960) +#define get_csv2_uint_pos961(X,Y) get_csv2_uint((X),(Y),961) +#define get_csv2_ullong_pos961(X,Y) get_csv2_ullong((X),(Y),961) +#define get_csv2_ip_pos961(X,Y) get_csv2_ip((X),(Y),961) +#define get_csv2_ipv6_pos961(X,Y) get_csv2_ipv6((X),(Y),961) +#define get_csv2_string_pos961(X,Y) get_csv2_string((X),(Y),961) +#define get_csv2_v_str_pos961(X,Y) get_csv2_string((X),(Y),961) +#define get_csv2_bool_pos961(X,Y) get_csv2_bool((X),(Y),961) +#define get_csv2_int_pos961(X,Y) get_csv2_int((X),(Y),961) +#define get_csv2_llong_pos961(X,Y) get_csv2_llong((X),(Y),961) +#define get_csv2_float_pos961(X,Y) get_csv2_float((X),(Y),961) +#define get_csv2_uint_pos962(X,Y) get_csv2_uint((X),(Y),962) +#define get_csv2_ullong_pos962(X,Y) get_csv2_ullong((X),(Y),962) +#define get_csv2_ip_pos962(X,Y) get_csv2_ip((X),(Y),962) +#define get_csv2_ipv6_pos962(X,Y) get_csv2_ipv6((X),(Y),962) +#define get_csv2_string_pos962(X,Y) get_csv2_string((X),(Y),962) +#define get_csv2_v_str_pos962(X,Y) get_csv2_string((X),(Y),962) +#define get_csv2_bool_pos962(X,Y) get_csv2_bool((X),(Y),962) +#define get_csv2_int_pos962(X,Y) get_csv2_int((X),(Y),962) +#define get_csv2_llong_pos962(X,Y) get_csv2_llong((X),(Y),962) +#define get_csv2_float_pos962(X,Y) get_csv2_float((X),(Y),962) +#define get_csv2_uint_pos963(X,Y) get_csv2_uint((X),(Y),963) +#define get_csv2_ullong_pos963(X,Y) get_csv2_ullong((X),(Y),963) +#define get_csv2_ip_pos963(X,Y) get_csv2_ip((X),(Y),963) +#define get_csv2_ipv6_pos963(X,Y) get_csv2_ipv6((X),(Y),963) +#define get_csv2_string_pos963(X,Y) get_csv2_string((X),(Y),963) +#define get_csv2_v_str_pos963(X,Y) get_csv2_string((X),(Y),963) +#define get_csv2_bool_pos963(X,Y) get_csv2_bool((X),(Y),963) +#define get_csv2_int_pos963(X,Y) get_csv2_int((X),(Y),963) +#define get_csv2_llong_pos963(X,Y) get_csv2_llong((X),(Y),963) +#define get_csv2_float_pos963(X,Y) get_csv2_float((X),(Y),963) +#define get_csv2_uint_pos964(X,Y) get_csv2_uint((X),(Y),964) +#define get_csv2_ullong_pos964(X,Y) get_csv2_ullong((X),(Y),964) +#define get_csv2_ip_pos964(X,Y) get_csv2_ip((X),(Y),964) +#define get_csv2_ipv6_pos964(X,Y) get_csv2_ipv6((X),(Y),964) +#define get_csv2_string_pos964(X,Y) get_csv2_string((X),(Y),964) +#define get_csv2_v_str_pos964(X,Y) get_csv2_string((X),(Y),964) +#define get_csv2_bool_pos964(X,Y) get_csv2_bool((X),(Y),964) +#define get_csv2_int_pos964(X,Y) get_csv2_int((X),(Y),964) +#define get_csv2_llong_pos964(X,Y) get_csv2_llong((X),(Y),964) +#define get_csv2_float_pos964(X,Y) get_csv2_float((X),(Y),964) +#define get_csv2_uint_pos965(X,Y) get_csv2_uint((X),(Y),965) +#define get_csv2_ullong_pos965(X,Y) get_csv2_ullong((X),(Y),965) +#define get_csv2_ip_pos965(X,Y) get_csv2_ip((X),(Y),965) +#define get_csv2_ipv6_pos965(X,Y) get_csv2_ipv6((X),(Y),965) +#define get_csv2_string_pos965(X,Y) get_csv2_string((X),(Y),965) +#define get_csv2_v_str_pos965(X,Y) get_csv2_string((X),(Y),965) +#define get_csv2_bool_pos965(X,Y) get_csv2_bool((X),(Y),965) +#define get_csv2_int_pos965(X,Y) get_csv2_int((X),(Y),965) +#define get_csv2_llong_pos965(X,Y) get_csv2_llong((X),(Y),965) +#define get_csv2_float_pos965(X,Y) get_csv2_float((X),(Y),965) +#define get_csv2_uint_pos966(X,Y) get_csv2_uint((X),(Y),966) +#define get_csv2_ullong_pos966(X,Y) get_csv2_ullong((X),(Y),966) +#define get_csv2_ip_pos966(X,Y) get_csv2_ip((X),(Y),966) +#define get_csv2_ipv6_pos966(X,Y) get_csv2_ipv6((X),(Y),966) +#define get_csv2_string_pos966(X,Y) get_csv2_string((X),(Y),966) +#define get_csv2_v_str_pos966(X,Y) get_csv2_string((X),(Y),966) +#define get_csv2_bool_pos966(X,Y) get_csv2_bool((X),(Y),966) +#define get_csv2_int_pos966(X,Y) get_csv2_int((X),(Y),966) +#define get_csv2_llong_pos966(X,Y) get_csv2_llong((X),(Y),966) +#define get_csv2_float_pos966(X,Y) get_csv2_float((X),(Y),966) +#define get_csv2_uint_pos967(X,Y) get_csv2_uint((X),(Y),967) +#define get_csv2_ullong_pos967(X,Y) get_csv2_ullong((X),(Y),967) +#define get_csv2_ip_pos967(X,Y) get_csv2_ip((X),(Y),967) +#define get_csv2_ipv6_pos967(X,Y) get_csv2_ipv6((X),(Y),967) +#define get_csv2_string_pos967(X,Y) get_csv2_string((X),(Y),967) +#define get_csv2_v_str_pos967(X,Y) get_csv2_string((X),(Y),967) +#define get_csv2_bool_pos967(X,Y) get_csv2_bool((X),(Y),967) +#define get_csv2_int_pos967(X,Y) get_csv2_int((X),(Y),967) +#define get_csv2_llong_pos967(X,Y) get_csv2_llong((X),(Y),967) +#define get_csv2_float_pos967(X,Y) get_csv2_float((X),(Y),967) +#define get_csv2_uint_pos968(X,Y) get_csv2_uint((X),(Y),968) +#define get_csv2_ullong_pos968(X,Y) get_csv2_ullong((X),(Y),968) +#define get_csv2_ip_pos968(X,Y) get_csv2_ip((X),(Y),968) +#define get_csv2_ipv6_pos968(X,Y) get_csv2_ipv6((X),(Y),968) +#define get_csv2_string_pos968(X,Y) get_csv2_string((X),(Y),968) +#define get_csv2_v_str_pos968(X,Y) get_csv2_string((X),(Y),968) +#define get_csv2_bool_pos968(X,Y) get_csv2_bool((X),(Y),968) +#define get_csv2_int_pos968(X,Y) get_csv2_int((X),(Y),968) +#define get_csv2_llong_pos968(X,Y) get_csv2_llong((X),(Y),968) +#define get_csv2_float_pos968(X,Y) get_csv2_float((X),(Y),968) +#define get_csv2_uint_pos969(X,Y) get_csv2_uint((X),(Y),969) +#define get_csv2_ullong_pos969(X,Y) get_csv2_ullong((X),(Y),969) +#define get_csv2_ip_pos969(X,Y) get_csv2_ip((X),(Y),969) +#define get_csv2_ipv6_pos969(X,Y) get_csv2_ipv6((X),(Y),969) +#define get_csv2_string_pos969(X,Y) get_csv2_string((X),(Y),969) +#define get_csv2_v_str_pos969(X,Y) get_csv2_string((X),(Y),969) +#define get_csv2_bool_pos969(X,Y) get_csv2_bool((X),(Y),969) +#define get_csv2_int_pos969(X,Y) get_csv2_int((X),(Y),969) +#define get_csv2_llong_pos969(X,Y) get_csv2_llong((X),(Y),969) +#define get_csv2_float_pos969(X,Y) get_csv2_float((X),(Y),969) +#define get_csv2_uint_pos970(X,Y) get_csv2_uint((X),(Y),970) +#define get_csv2_ullong_pos970(X,Y) get_csv2_ullong((X),(Y),970) +#define get_csv2_ip_pos970(X,Y) get_csv2_ip((X),(Y),970) +#define get_csv2_ipv6_pos970(X,Y) get_csv2_ipv6((X),(Y),970) +#define get_csv2_string_pos970(X,Y) get_csv2_string((X),(Y),970) +#define get_csv2_v_str_pos970(X,Y) get_csv2_string((X),(Y),970) +#define get_csv2_bool_pos970(X,Y) get_csv2_bool((X),(Y),970) +#define get_csv2_int_pos970(X,Y) get_csv2_int((X),(Y),970) +#define get_csv2_llong_pos970(X,Y) get_csv2_llong((X),(Y),970) +#define get_csv2_float_pos970(X,Y) get_csv2_float((X),(Y),970) +#define get_csv2_uint_pos971(X,Y) get_csv2_uint((X),(Y),971) +#define get_csv2_ullong_pos971(X,Y) get_csv2_ullong((X),(Y),971) +#define get_csv2_ip_pos971(X,Y) get_csv2_ip((X),(Y),971) +#define get_csv2_ipv6_pos971(X,Y) get_csv2_ipv6((X),(Y),971) +#define get_csv2_string_pos971(X,Y) get_csv2_string((X),(Y),971) +#define get_csv2_v_str_pos971(X,Y) get_csv2_string((X),(Y),971) +#define get_csv2_bool_pos971(X,Y) get_csv2_bool((X),(Y),971) +#define get_csv2_int_pos971(X,Y) get_csv2_int((X),(Y),971) +#define get_csv2_llong_pos971(X,Y) get_csv2_llong((X),(Y),971) +#define get_csv2_float_pos971(X,Y) get_csv2_float((X),(Y),971) +#define get_csv2_uint_pos972(X,Y) get_csv2_uint((X),(Y),972) +#define get_csv2_ullong_pos972(X,Y) get_csv2_ullong((X),(Y),972) +#define get_csv2_ip_pos972(X,Y) get_csv2_ip((X),(Y),972) +#define get_csv2_ipv6_pos972(X,Y) get_csv2_ipv6((X),(Y),972) +#define get_csv2_string_pos972(X,Y) get_csv2_string((X),(Y),972) +#define get_csv2_v_str_pos972(X,Y) get_csv2_string((X),(Y),972) +#define get_csv2_bool_pos972(X,Y) get_csv2_bool((X),(Y),972) +#define get_csv2_int_pos972(X,Y) get_csv2_int((X),(Y),972) +#define get_csv2_llong_pos972(X,Y) get_csv2_llong((X),(Y),972) +#define get_csv2_float_pos972(X,Y) get_csv2_float((X),(Y),972) +#define get_csv2_uint_pos973(X,Y) get_csv2_uint((X),(Y),973) +#define get_csv2_ullong_pos973(X,Y) get_csv2_ullong((X),(Y),973) +#define get_csv2_ip_pos973(X,Y) get_csv2_ip((X),(Y),973) +#define get_csv2_ipv6_pos973(X,Y) get_csv2_ipv6((X),(Y),973) +#define get_csv2_string_pos973(X,Y) get_csv2_string((X),(Y),973) +#define get_csv2_v_str_pos973(X,Y) get_csv2_string((X),(Y),973) +#define get_csv2_bool_pos973(X,Y) get_csv2_bool((X),(Y),973) +#define get_csv2_int_pos973(X,Y) get_csv2_int((X),(Y),973) +#define get_csv2_llong_pos973(X,Y) get_csv2_llong((X),(Y),973) +#define get_csv2_float_pos973(X,Y) get_csv2_float((X),(Y),973) +#define get_csv2_uint_pos974(X,Y) get_csv2_uint((X),(Y),974) +#define get_csv2_ullong_pos974(X,Y) get_csv2_ullong((X),(Y),974) +#define get_csv2_ip_pos974(X,Y) get_csv2_ip((X),(Y),974) +#define get_csv2_ipv6_pos974(X,Y) get_csv2_ipv6((X),(Y),974) +#define get_csv2_string_pos974(X,Y) get_csv2_string((X),(Y),974) +#define get_csv2_v_str_pos974(X,Y) get_csv2_string((X),(Y),974) +#define get_csv2_bool_pos974(X,Y) get_csv2_bool((X),(Y),974) +#define get_csv2_int_pos974(X,Y) get_csv2_int((X),(Y),974) +#define get_csv2_llong_pos974(X,Y) get_csv2_llong((X),(Y),974) +#define get_csv2_float_pos974(X,Y) get_csv2_float((X),(Y),974) +#define get_csv2_uint_pos975(X,Y) get_csv2_uint((X),(Y),975) +#define get_csv2_ullong_pos975(X,Y) get_csv2_ullong((X),(Y),975) +#define get_csv2_ip_pos975(X,Y) get_csv2_ip((X),(Y),975) +#define get_csv2_ipv6_pos975(X,Y) get_csv2_ipv6((X),(Y),975) +#define get_csv2_string_pos975(X,Y) get_csv2_string((X),(Y),975) +#define get_csv2_v_str_pos975(X,Y) get_csv2_string((X),(Y),975) +#define get_csv2_bool_pos975(X,Y) get_csv2_bool((X),(Y),975) +#define get_csv2_int_pos975(X,Y) get_csv2_int((X),(Y),975) +#define get_csv2_llong_pos975(X,Y) get_csv2_llong((X),(Y),975) +#define get_csv2_float_pos975(X,Y) get_csv2_float((X),(Y),975) +#define get_csv2_uint_pos976(X,Y) get_csv2_uint((X),(Y),976) +#define get_csv2_ullong_pos976(X,Y) get_csv2_ullong((X),(Y),976) +#define get_csv2_ip_pos976(X,Y) get_csv2_ip((X),(Y),976) +#define get_csv2_ipv6_pos976(X,Y) get_csv2_ipv6((X),(Y),976) +#define get_csv2_string_pos976(X,Y) get_csv2_string((X),(Y),976) +#define get_csv2_v_str_pos976(X,Y) get_csv2_string((X),(Y),976) +#define get_csv2_bool_pos976(X,Y) get_csv2_bool((X),(Y),976) +#define get_csv2_int_pos976(X,Y) get_csv2_int((X),(Y),976) +#define get_csv2_llong_pos976(X,Y) get_csv2_llong((X),(Y),976) +#define get_csv2_float_pos976(X,Y) get_csv2_float((X),(Y),976) +#define get_csv2_uint_pos977(X,Y) get_csv2_uint((X),(Y),977) +#define get_csv2_ullong_pos977(X,Y) get_csv2_ullong((X),(Y),977) +#define get_csv2_ip_pos977(X,Y) get_csv2_ip((X),(Y),977) +#define get_csv2_ipv6_pos977(X,Y) get_csv2_ipv6((X),(Y),977) +#define get_csv2_string_pos977(X,Y) get_csv2_string((X),(Y),977) +#define get_csv2_v_str_pos977(X,Y) get_csv2_string((X),(Y),977) +#define get_csv2_bool_pos977(X,Y) get_csv2_bool((X),(Y),977) +#define get_csv2_int_pos977(X,Y) get_csv2_int((X),(Y),977) +#define get_csv2_llong_pos977(X,Y) get_csv2_llong((X),(Y),977) +#define get_csv2_float_pos977(X,Y) get_csv2_float((X),(Y),977) +#define get_csv2_uint_pos978(X,Y) get_csv2_uint((X),(Y),978) +#define get_csv2_ullong_pos978(X,Y) get_csv2_ullong((X),(Y),978) +#define get_csv2_ip_pos978(X,Y) get_csv2_ip((X),(Y),978) +#define get_csv2_ipv6_pos978(X,Y) get_csv2_ipv6((X),(Y),978) +#define get_csv2_string_pos978(X,Y) get_csv2_string((X),(Y),978) +#define get_csv2_v_str_pos978(X,Y) get_csv2_string((X),(Y),978) +#define get_csv2_bool_pos978(X,Y) get_csv2_bool((X),(Y),978) +#define get_csv2_int_pos978(X,Y) get_csv2_int((X),(Y),978) +#define get_csv2_llong_pos978(X,Y) get_csv2_llong((X),(Y),978) +#define get_csv2_float_pos978(X,Y) get_csv2_float((X),(Y),978) +#define get_csv2_uint_pos979(X,Y) get_csv2_uint((X),(Y),979) +#define get_csv2_ullong_pos979(X,Y) get_csv2_ullong((X),(Y),979) +#define get_csv2_ip_pos979(X,Y) get_csv2_ip((X),(Y),979) +#define get_csv2_ipv6_pos979(X,Y) get_csv2_ipv6((X),(Y),979) +#define get_csv2_string_pos979(X,Y) get_csv2_string((X),(Y),979) +#define get_csv2_v_str_pos979(X,Y) get_csv2_string((X),(Y),979) +#define get_csv2_bool_pos979(X,Y) get_csv2_bool((X),(Y),979) +#define get_csv2_int_pos979(X,Y) get_csv2_int((X),(Y),979) +#define get_csv2_llong_pos979(X,Y) get_csv2_llong((X),(Y),979) +#define get_csv2_float_pos979(X,Y) get_csv2_float((X),(Y),979) +#define get_csv2_uint_pos980(X,Y) get_csv2_uint((X),(Y),980) +#define get_csv2_ullong_pos980(X,Y) get_csv2_ullong((X),(Y),980) +#define get_csv2_ip_pos980(X,Y) get_csv2_ip((X),(Y),980) +#define get_csv2_ipv6_pos980(X,Y) get_csv2_ipv6((X),(Y),980) +#define get_csv2_string_pos980(X,Y) get_csv2_string((X),(Y),980) +#define get_csv2_v_str_pos980(X,Y) get_csv2_string((X),(Y),980) +#define get_csv2_bool_pos980(X,Y) get_csv2_bool((X),(Y),980) +#define get_csv2_int_pos980(X,Y) get_csv2_int((X),(Y),980) +#define get_csv2_llong_pos980(X,Y) get_csv2_llong((X),(Y),980) +#define get_csv2_float_pos980(X,Y) get_csv2_float((X),(Y),980) +#define get_csv2_uint_pos981(X,Y) get_csv2_uint((X),(Y),981) +#define get_csv2_ullong_pos981(X,Y) get_csv2_ullong((X),(Y),981) +#define get_csv2_ip_pos981(X,Y) get_csv2_ip((X),(Y),981) +#define get_csv2_ipv6_pos981(X,Y) get_csv2_ipv6((X),(Y),981) +#define get_csv2_string_pos981(X,Y) get_csv2_string((X),(Y),981) +#define get_csv2_v_str_pos981(X,Y) get_csv2_string((X),(Y),981) +#define get_csv2_bool_pos981(X,Y) get_csv2_bool((X),(Y),981) +#define get_csv2_int_pos981(X,Y) get_csv2_int((X),(Y),981) +#define get_csv2_llong_pos981(X,Y) get_csv2_llong((X),(Y),981) +#define get_csv2_float_pos981(X,Y) get_csv2_float((X),(Y),981) +#define get_csv2_uint_pos982(X,Y) get_csv2_uint((X),(Y),982) +#define get_csv2_ullong_pos982(X,Y) get_csv2_ullong((X),(Y),982) +#define get_csv2_ip_pos982(X,Y) get_csv2_ip((X),(Y),982) +#define get_csv2_ipv6_pos982(X,Y) get_csv2_ipv6((X),(Y),982) +#define get_csv2_string_pos982(X,Y) get_csv2_string((X),(Y),982) +#define get_csv2_v_str_pos982(X,Y) get_csv2_string((X),(Y),982) +#define get_csv2_bool_pos982(X,Y) get_csv2_bool((X),(Y),982) +#define get_csv2_int_pos982(X,Y) get_csv2_int((X),(Y),982) +#define get_csv2_llong_pos982(X,Y) get_csv2_llong((X),(Y),982) +#define get_csv2_float_pos982(X,Y) get_csv2_float((X),(Y),982) +#define get_csv2_uint_pos983(X,Y) get_csv2_uint((X),(Y),983) +#define get_csv2_ullong_pos983(X,Y) get_csv2_ullong((X),(Y),983) +#define get_csv2_ip_pos983(X,Y) get_csv2_ip((X),(Y),983) +#define get_csv2_ipv6_pos983(X,Y) get_csv2_ipv6((X),(Y),983) +#define get_csv2_string_pos983(X,Y) get_csv2_string((X),(Y),983) +#define get_csv2_v_str_pos983(X,Y) get_csv2_string((X),(Y),983) +#define get_csv2_bool_pos983(X,Y) get_csv2_bool((X),(Y),983) +#define get_csv2_int_pos983(X,Y) get_csv2_int((X),(Y),983) +#define get_csv2_llong_pos983(X,Y) get_csv2_llong((X),(Y),983) +#define get_csv2_float_pos983(X,Y) get_csv2_float((X),(Y),983) +#define get_csv2_uint_pos984(X,Y) get_csv2_uint((X),(Y),984) +#define get_csv2_ullong_pos984(X,Y) get_csv2_ullong((X),(Y),984) +#define get_csv2_ip_pos984(X,Y) get_csv2_ip((X),(Y),984) +#define get_csv2_ipv6_pos984(X,Y) get_csv2_ipv6((X),(Y),984) +#define get_csv2_string_pos984(X,Y) get_csv2_string((X),(Y),984) +#define get_csv2_v_str_pos984(X,Y) get_csv2_string((X),(Y),984) +#define get_csv2_bool_pos984(X,Y) get_csv2_bool((X),(Y),984) +#define get_csv2_int_pos984(X,Y) get_csv2_int((X),(Y),984) +#define get_csv2_llong_pos984(X,Y) get_csv2_llong((X),(Y),984) +#define get_csv2_float_pos984(X,Y) get_csv2_float((X),(Y),984) +#define get_csv2_uint_pos985(X,Y) get_csv2_uint((X),(Y),985) +#define get_csv2_ullong_pos985(X,Y) get_csv2_ullong((X),(Y),985) +#define get_csv2_ip_pos985(X,Y) get_csv2_ip((X),(Y),985) +#define get_csv2_ipv6_pos985(X,Y) get_csv2_ipv6((X),(Y),985) +#define get_csv2_string_pos985(X,Y) get_csv2_string((X),(Y),985) +#define get_csv2_v_str_pos985(X,Y) get_csv2_string((X),(Y),985) +#define get_csv2_bool_pos985(X,Y) get_csv2_bool((X),(Y),985) +#define get_csv2_int_pos985(X,Y) get_csv2_int((X),(Y),985) +#define get_csv2_llong_pos985(X,Y) get_csv2_llong((X),(Y),985) +#define get_csv2_float_pos985(X,Y) get_csv2_float((X),(Y),985) +#define get_csv2_uint_pos986(X,Y) get_csv2_uint((X),(Y),986) +#define get_csv2_ullong_pos986(X,Y) get_csv2_ullong((X),(Y),986) +#define get_csv2_ip_pos986(X,Y) get_csv2_ip((X),(Y),986) +#define get_csv2_ipv6_pos986(X,Y) get_csv2_ipv6((X),(Y),986) +#define get_csv2_string_pos986(X,Y) get_csv2_string((X),(Y),986) +#define get_csv2_v_str_pos986(X,Y) get_csv2_string((X),(Y),986) +#define get_csv2_bool_pos986(X,Y) get_csv2_bool((X),(Y),986) +#define get_csv2_int_pos986(X,Y) get_csv2_int((X),(Y),986) +#define get_csv2_llong_pos986(X,Y) get_csv2_llong((X),(Y),986) +#define get_csv2_float_pos986(X,Y) get_csv2_float((X),(Y),986) +#define get_csv2_uint_pos987(X,Y) get_csv2_uint((X),(Y),987) +#define get_csv2_ullong_pos987(X,Y) get_csv2_ullong((X),(Y),987) +#define get_csv2_ip_pos987(X,Y) get_csv2_ip((X),(Y),987) +#define get_csv2_ipv6_pos987(X,Y) get_csv2_ipv6((X),(Y),987) +#define get_csv2_string_pos987(X,Y) get_csv2_string((X),(Y),987) +#define get_csv2_v_str_pos987(X,Y) get_csv2_string((X),(Y),987) +#define get_csv2_bool_pos987(X,Y) get_csv2_bool((X),(Y),987) +#define get_csv2_int_pos987(X,Y) get_csv2_int((X),(Y),987) +#define get_csv2_llong_pos987(X,Y) get_csv2_llong((X),(Y),987) +#define get_csv2_float_pos987(X,Y) get_csv2_float((X),(Y),987) +#define get_csv2_uint_pos988(X,Y) get_csv2_uint((X),(Y),988) +#define get_csv2_ullong_pos988(X,Y) get_csv2_ullong((X),(Y),988) +#define get_csv2_ip_pos988(X,Y) get_csv2_ip((X),(Y),988) +#define get_csv2_ipv6_pos988(X,Y) get_csv2_ipv6((X),(Y),988) +#define get_csv2_string_pos988(X,Y) get_csv2_string((X),(Y),988) +#define get_csv2_v_str_pos988(X,Y) get_csv2_string((X),(Y),988) +#define get_csv2_bool_pos988(X,Y) get_csv2_bool((X),(Y),988) +#define get_csv2_int_pos988(X,Y) get_csv2_int((X),(Y),988) +#define get_csv2_llong_pos988(X,Y) get_csv2_llong((X),(Y),988) +#define get_csv2_float_pos988(X,Y) get_csv2_float((X),(Y),988) +#define get_csv2_uint_pos989(X,Y) get_csv2_uint((X),(Y),989) +#define get_csv2_ullong_pos989(X,Y) get_csv2_ullong((X),(Y),989) +#define get_csv2_ip_pos989(X,Y) get_csv2_ip((X),(Y),989) +#define get_csv2_ipv6_pos989(X,Y) get_csv2_ipv6((X),(Y),989) +#define get_csv2_string_pos989(X,Y) get_csv2_string((X),(Y),989) +#define get_csv2_v_str_pos989(X,Y) get_csv2_string((X),(Y),989) +#define get_csv2_bool_pos989(X,Y) get_csv2_bool((X),(Y),989) +#define get_csv2_int_pos989(X,Y) get_csv2_int((X),(Y),989) +#define get_csv2_llong_pos989(X,Y) get_csv2_llong((X),(Y),989) +#define get_csv2_float_pos989(X,Y) get_csv2_float((X),(Y),989) +#define get_csv2_uint_pos990(X,Y) get_csv2_uint((X),(Y),990) +#define get_csv2_ullong_pos990(X,Y) get_csv2_ullong((X),(Y),990) +#define get_csv2_ip_pos990(X,Y) get_csv2_ip((X),(Y),990) +#define get_csv2_ipv6_pos990(X,Y) get_csv2_ipv6((X),(Y),990) +#define get_csv2_string_pos990(X,Y) get_csv2_string((X),(Y),990) +#define get_csv2_v_str_pos990(X,Y) get_csv2_string((X),(Y),990) +#define get_csv2_bool_pos990(X,Y) get_csv2_bool((X),(Y),990) +#define get_csv2_int_pos990(X,Y) get_csv2_int((X),(Y),990) +#define get_csv2_llong_pos990(X,Y) get_csv2_llong((X),(Y),990) +#define get_csv2_float_pos990(X,Y) get_csv2_float((X),(Y),990) +#define get_csv2_uint_pos991(X,Y) get_csv2_uint((X),(Y),991) +#define get_csv2_ullong_pos991(X,Y) get_csv2_ullong((X),(Y),991) +#define get_csv2_ip_pos991(X,Y) get_csv2_ip((X),(Y),991) +#define get_csv2_ipv6_pos991(X,Y) get_csv2_ipv6((X),(Y),991) +#define get_csv2_string_pos991(X,Y) get_csv2_string((X),(Y),991) +#define get_csv2_v_str_pos991(X,Y) get_csv2_string((X),(Y),991) +#define get_csv2_bool_pos991(X,Y) get_csv2_bool((X),(Y),991) +#define get_csv2_int_pos991(X,Y) get_csv2_int((X),(Y),991) +#define get_csv2_llong_pos991(X,Y) get_csv2_llong((X),(Y),991) +#define get_csv2_float_pos991(X,Y) get_csv2_float((X),(Y),991) +#define get_csv2_uint_pos992(X,Y) get_csv2_uint((X),(Y),992) +#define get_csv2_ullong_pos992(X,Y) get_csv2_ullong((X),(Y),992) +#define get_csv2_ip_pos992(X,Y) get_csv2_ip((X),(Y),992) +#define get_csv2_ipv6_pos992(X,Y) get_csv2_ipv6((X),(Y),992) +#define get_csv2_string_pos992(X,Y) get_csv2_string((X),(Y),992) +#define get_csv2_v_str_pos992(X,Y) get_csv2_string((X),(Y),992) +#define get_csv2_bool_pos992(X,Y) get_csv2_bool((X),(Y),992) +#define get_csv2_int_pos992(X,Y) get_csv2_int((X),(Y),992) +#define get_csv2_llong_pos992(X,Y) get_csv2_llong((X),(Y),992) +#define get_csv2_float_pos992(X,Y) get_csv2_float((X),(Y),992) +#define get_csv2_uint_pos993(X,Y) get_csv2_uint((X),(Y),993) +#define get_csv2_ullong_pos993(X,Y) get_csv2_ullong((X),(Y),993) +#define get_csv2_ip_pos993(X,Y) get_csv2_ip((X),(Y),993) +#define get_csv2_ipv6_pos993(X,Y) get_csv2_ipv6((X),(Y),993) +#define get_csv2_string_pos993(X,Y) get_csv2_string((X),(Y),993) +#define get_csv2_v_str_pos993(X,Y) get_csv2_string((X),(Y),993) +#define get_csv2_bool_pos993(X,Y) get_csv2_bool((X),(Y),993) +#define get_csv2_int_pos993(X,Y) get_csv2_int((X),(Y),993) +#define get_csv2_llong_pos993(X,Y) get_csv2_llong((X),(Y),993) +#define get_csv2_float_pos993(X,Y) get_csv2_float((X),(Y),993) +#define get_csv2_uint_pos994(X,Y) get_csv2_uint((X),(Y),994) +#define get_csv2_ullong_pos994(X,Y) get_csv2_ullong((X),(Y),994) +#define get_csv2_ip_pos994(X,Y) get_csv2_ip((X),(Y),994) +#define get_csv2_ipv6_pos994(X,Y) get_csv2_ipv6((X),(Y),994) +#define get_csv2_string_pos994(X,Y) get_csv2_string((X),(Y),994) +#define get_csv2_v_str_pos994(X,Y) get_csv2_string((X),(Y),994) +#define get_csv2_bool_pos994(X,Y) get_csv2_bool((X),(Y),994) +#define get_csv2_int_pos994(X,Y) get_csv2_int((X),(Y),994) +#define get_csv2_llong_pos994(X,Y) get_csv2_llong((X),(Y),994) +#define get_csv2_float_pos994(X,Y) get_csv2_float((X),(Y),994) +#define get_csv2_uint_pos995(X,Y) get_csv2_uint((X),(Y),995) +#define get_csv2_ullong_pos995(X,Y) get_csv2_ullong((X),(Y),995) +#define get_csv2_ip_pos995(X,Y) get_csv2_ip((X),(Y),995) +#define get_csv2_ipv6_pos995(X,Y) get_csv2_ipv6((X),(Y),995) +#define get_csv2_string_pos995(X,Y) get_csv2_string((X),(Y),995) +#define get_csv2_v_str_pos995(X,Y) get_csv2_string((X),(Y),995) +#define get_csv2_bool_pos995(X,Y) get_csv2_bool((X),(Y),995) +#define get_csv2_int_pos995(X,Y) get_csv2_int((X),(Y),995) +#define get_csv2_llong_pos995(X,Y) get_csv2_llong((X),(Y),995) +#define get_csv2_float_pos995(X,Y) get_csv2_float((X),(Y),995) +#define get_csv2_uint_pos996(X,Y) get_csv2_uint((X),(Y),996) +#define get_csv2_ullong_pos996(X,Y) get_csv2_ullong((X),(Y),996) +#define get_csv2_ip_pos996(X,Y) get_csv2_ip((X),(Y),996) +#define get_csv2_ipv6_pos996(X,Y) get_csv2_ipv6((X),(Y),996) +#define get_csv2_string_pos996(X,Y) get_csv2_string((X),(Y),996) +#define get_csv2_v_str_pos996(X,Y) get_csv2_string((X),(Y),996) +#define get_csv2_bool_pos996(X,Y) get_csv2_bool((X),(Y),996) +#define get_csv2_int_pos996(X,Y) get_csv2_int((X),(Y),996) +#define get_csv2_llong_pos996(X,Y) get_csv2_llong((X),(Y),996) +#define get_csv2_float_pos996(X,Y) get_csv2_float((X),(Y),996) +#define get_csv2_uint_pos997(X,Y) get_csv2_uint((X),(Y),997) +#define get_csv2_ullong_pos997(X,Y) get_csv2_ullong((X),(Y),997) +#define get_csv2_ip_pos997(X,Y) get_csv2_ip((X),(Y),997) +#define get_csv2_ipv6_pos997(X,Y) get_csv2_ipv6((X),(Y),997) +#define get_csv2_string_pos997(X,Y) get_csv2_string((X),(Y),997) +#define get_csv2_v_str_pos997(X,Y) get_csv2_string((X),(Y),997) +#define get_csv2_bool_pos997(X,Y) get_csv2_bool((X),(Y),997) +#define get_csv2_int_pos997(X,Y) get_csv2_int((X),(Y),997) +#define get_csv2_llong_pos997(X,Y) get_csv2_llong((X),(Y),997) +#define get_csv2_float_pos997(X,Y) get_csv2_float((X),(Y),997) +#define get_csv2_uint_pos998(X,Y) get_csv2_uint((X),(Y),998) +#define get_csv2_ullong_pos998(X,Y) get_csv2_ullong((X),(Y),998) +#define get_csv2_ip_pos998(X,Y) get_csv2_ip((X),(Y),998) +#define get_csv2_ipv6_pos998(X,Y) get_csv2_ipv6((X),(Y),998) +#define get_csv2_string_pos998(X,Y) get_csv2_string((X),(Y),998) +#define get_csv2_v_str_pos998(X,Y) get_csv2_string((X),(Y),998) +#define get_csv2_bool_pos998(X,Y) get_csv2_bool((X),(Y),998) +#define get_csv2_int_pos998(X,Y) get_csv2_int((X),(Y),998) +#define get_csv2_llong_pos998(X,Y) get_csv2_llong((X),(Y),998) +#define get_csv2_float_pos998(X,Y) get_csv2_float((X),(Y),998) +#define get_csv2_uint_pos999(X,Y) get_csv2_uint((X),(Y),999) +#define get_csv2_ullong_pos999(X,Y) get_csv2_ullong((X),(Y),999) +#define get_csv2_ip_pos999(X,Y) get_csv2_ip((X),(Y),999) +#define get_csv2_ipv6_pos999(X,Y) get_csv2_ipv6((X),(Y),999) +#define get_csv2_string_pos999(X,Y) get_csv2_string((X),(Y),999) +#define get_csv2_v_str_pos999(X,Y) get_csv2_string((X),(Y),999) +#define get_csv2_bool_pos999(X,Y) get_csv2_bool((X),(Y),999) +#define get_csv2_int_pos999(X,Y) get_csv2_int((X),(Y),999) +#define get_csv2_llong_pos999(X,Y) get_csv2_llong((X),(Y),999) +#define get_csv2_float_pos999(X,Y) get_csv2_float((X),(Y),999) +#define get_csv2_uint_pos1000(X,Y) get_csv2_uint((X),(Y),1000) +#define get_csv2_ullong_pos1000(X,Y) get_csv2_ullong((X),(Y),1000) +#define get_csv2_ip_pos1000(X,Y) get_csv2_ip((X),(Y),1000) +#define get_csv2_ipv6_pos1000(X,Y) get_csv2_ipv6((X),(Y),1000) +#define get_csv2_string_pos1000(X,Y) get_csv2_string((X),(Y),1000) +#define get_csv2_v_str_pos1000(X,Y) get_csv2_string((X),(Y),1000) +#define get_csv2_bool_pos1000(X,Y) get_csv2_bool((X),(Y),1000) +#define get_csv2_int_pos1000(X,Y) get_csv2_int((X),(Y),1000) +#define get_csv2_llong_pos1000(X,Y) get_csv2_llong((X),(Y),1000) +#define get_csv2_float_pos1000(X,Y) get_csv2_float((X),(Y),1000) +#endif diff --git a/include/lfta/csv_macro.h b/include/lfta/csv_macro.h new file mode 100644 index 0000000..f2b9f84 --- /dev/null +++ b/include/lfta/csv_macro.h @@ -0,0 +1,10017 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef CSV_MACRO_H +#define CSV_MACRO_H +#define get_csv_uint_pos1(X,Y) get_csv_uint((X),(Y),1) +#define get_csv_ullong_pos1(X,Y) get_csv_ullong((X),(Y),1) +#define get_csv_ip_pos1(X,Y) get_csv_ip((X),(Y),1) +#define get_csv_ipv6_pos1(X,Y) get_csv_ipv6((X),(Y),1) +#define get_csv_string_pos1(X,Y) get_csv_string((X),(Y),1) +#define get_csv_v_str_pos1(X,Y) get_csv_string((X),(Y),1) +#define get_csv_bool_pos1(X,Y) get_csv_bool((X),(Y),1) +#define get_csv_int_pos1(X,Y) get_csv_int((X),(Y),1) +#define get_csv_llong_pos1(X,Y) get_csv_llong((X),(Y),1) +#define get_csv_float_pos1(X,Y) get_csv_float((X),(Y),1) +#define get_csv_uint_pos2(X,Y) get_csv_uint((X),(Y),2) +#define get_csv_ullong_pos2(X,Y) get_csv_ullong((X),(Y),2) +#define get_csv_ip_pos2(X,Y) get_csv_ip((X),(Y),2) +#define get_csv_ipv6_pos2(X,Y) get_csv_ipv6((X),(Y),2) +#define get_csv_string_pos2(X,Y) get_csv_string((X),(Y),2) +#define get_csv_v_str_pos2(X,Y) get_csv_string((X),(Y),2) +#define get_csv_bool_pos2(X,Y) get_csv_bool((X),(Y),2) +#define get_csv_int_pos2(X,Y) get_csv_int((X),(Y),2) +#define get_csv_llong_pos2(X,Y) get_csv_llong((X),(Y),2) +#define get_csv_float_pos2(X,Y) get_csv_float((X),(Y),2) +#define get_csv_uint_pos3(X,Y) get_csv_uint((X),(Y),3) +#define get_csv_ullong_pos3(X,Y) get_csv_ullong((X),(Y),3) +#define get_csv_ip_pos3(X,Y) get_csv_ip((X),(Y),3) +#define get_csv_ipv6_pos3(X,Y) get_csv_ipv6((X),(Y),3) +#define get_csv_string_pos3(X,Y) get_csv_string((X),(Y),3) +#define get_csv_v_str_pos3(X,Y) get_csv_string((X),(Y),3) +#define get_csv_bool_pos3(X,Y) get_csv_bool((X),(Y),3) +#define get_csv_int_pos3(X,Y) get_csv_int((X),(Y),3) +#define get_csv_llong_pos3(X,Y) get_csv_llong((X),(Y),3) +#define get_csv_float_pos3(X,Y) get_csv_float((X),(Y),3) +#define get_csv_uint_pos4(X,Y) get_csv_uint((X),(Y),4) +#define get_csv_ullong_pos4(X,Y) get_csv_ullong((X),(Y),4) +#define get_csv_ip_pos4(X,Y) get_csv_ip((X),(Y),4) +#define get_csv_ipv6_pos4(X,Y) get_csv_ipv6((X),(Y),4) +#define get_csv_string_pos4(X,Y) get_csv_string((X),(Y),4) +#define get_csv_v_str_pos4(X,Y) get_csv_string((X),(Y),4) +#define get_csv_bool_pos4(X,Y) get_csv_bool((X),(Y),4) +#define get_csv_int_pos4(X,Y) get_csv_int((X),(Y),4) +#define get_csv_llong_pos4(X,Y) get_csv_llong((X),(Y),4) +#define get_csv_float_pos4(X,Y) get_csv_float((X),(Y),4) +#define get_csv_uint_pos5(X,Y) get_csv_uint((X),(Y),5) +#define get_csv_ullong_pos5(X,Y) get_csv_ullong((X),(Y),5) +#define get_csv_ip_pos5(X,Y) get_csv_ip((X),(Y),5) +#define get_csv_ipv6_pos5(X,Y) get_csv_ipv6((X),(Y),5) +#define get_csv_string_pos5(X,Y) get_csv_string((X),(Y),5) +#define get_csv_v_str_pos5(X,Y) get_csv_string((X),(Y),5) +#define get_csv_bool_pos5(X,Y) get_csv_bool((X),(Y),5) +#define get_csv_int_pos5(X,Y) get_csv_int((X),(Y),5) +#define get_csv_llong_pos5(X,Y) get_csv_llong((X),(Y),5) +#define get_csv_float_pos5(X,Y) get_csv_float((X),(Y),5) +#define get_csv_uint_pos6(X,Y) get_csv_uint((X),(Y),6) +#define get_csv_ullong_pos6(X,Y) get_csv_ullong((X),(Y),6) +#define get_csv_ip_pos6(X,Y) get_csv_ip((X),(Y),6) +#define get_csv_ipv6_pos6(X,Y) get_csv_ipv6((X),(Y),6) +#define get_csv_string_pos6(X,Y) get_csv_string((X),(Y),6) +#define get_csv_v_str_pos6(X,Y) get_csv_string((X),(Y),6) +#define get_csv_bool_pos6(X,Y) get_csv_bool((X),(Y),6) +#define get_csv_int_pos6(X,Y) get_csv_int((X),(Y),6) +#define get_csv_llong_pos6(X,Y) get_csv_llong((X),(Y),6) +#define get_csv_float_pos6(X,Y) get_csv_float((X),(Y),6) +#define get_csv_uint_pos7(X,Y) get_csv_uint((X),(Y),7) +#define get_csv_ullong_pos7(X,Y) get_csv_ullong((X),(Y),7) +#define get_csv_ip_pos7(X,Y) get_csv_ip((X),(Y),7) +#define get_csv_ipv6_pos7(X,Y) get_csv_ipv6((X),(Y),7) +#define get_csv_string_pos7(X,Y) get_csv_string((X),(Y),7) +#define get_csv_v_str_pos7(X,Y) get_csv_string((X),(Y),7) +#define get_csv_bool_pos7(X,Y) get_csv_bool((X),(Y),7) +#define get_csv_int_pos7(X,Y) get_csv_int((X),(Y),7) +#define get_csv_llong_pos7(X,Y) get_csv_llong((X),(Y),7) +#define get_csv_float_pos7(X,Y) get_csv_float((X),(Y),7) +#define get_csv_uint_pos8(X,Y) get_csv_uint((X),(Y),8) +#define get_csv_ullong_pos8(X,Y) get_csv_ullong((X),(Y),8) +#define get_csv_ip_pos8(X,Y) get_csv_ip((X),(Y),8) +#define get_csv_ipv6_pos8(X,Y) get_csv_ipv6((X),(Y),8) +#define get_csv_string_pos8(X,Y) get_csv_string((X),(Y),8) +#define get_csv_v_str_pos8(X,Y) get_csv_string((X),(Y),8) +#define get_csv_bool_pos8(X,Y) get_csv_bool((X),(Y),8) +#define get_csv_int_pos8(X,Y) get_csv_int((X),(Y),8) +#define get_csv_llong_pos8(X,Y) get_csv_llong((X),(Y),8) +#define get_csv_float_pos8(X,Y) get_csv_float((X),(Y),8) +#define get_csv_uint_pos9(X,Y) get_csv_uint((X),(Y),9) +#define get_csv_ullong_pos9(X,Y) get_csv_ullong((X),(Y),9) +#define get_csv_ip_pos9(X,Y) get_csv_ip((X),(Y),9) +#define get_csv_ipv6_pos9(X,Y) get_csv_ipv6((X),(Y),9) +#define get_csv_string_pos9(X,Y) get_csv_string((X),(Y),9) +#define get_csv_v_str_pos9(X,Y) get_csv_string((X),(Y),9) +#define get_csv_bool_pos9(X,Y) get_csv_bool((X),(Y),9) +#define get_csv_int_pos9(X,Y) get_csv_int((X),(Y),9) +#define get_csv_llong_pos9(X,Y) get_csv_llong((X),(Y),9) +#define get_csv_float_pos9(X,Y) get_csv_float((X),(Y),9) +#define get_csv_uint_pos10(X,Y) get_csv_uint((X),(Y),10) +#define get_csv_ullong_pos10(X,Y) get_csv_ullong((X),(Y),10) +#define get_csv_ip_pos10(X,Y) get_csv_ip((X),(Y),10) +#define get_csv_ipv6_pos10(X,Y) get_csv_ipv6((X),(Y),10) +#define get_csv_string_pos10(X,Y) get_csv_string((X),(Y),10) +#define get_csv_v_str_pos10(X,Y) get_csv_string((X),(Y),10) +#define get_csv_bool_pos10(X,Y) get_csv_bool((X),(Y),10) +#define get_csv_int_pos10(X,Y) get_csv_int((X),(Y),10) +#define get_csv_llong_pos10(X,Y) get_csv_llong((X),(Y),10) +#define get_csv_float_pos10(X,Y) get_csv_float((X),(Y),10) +#define get_csv_uint_pos11(X,Y) get_csv_uint((X),(Y),11) +#define get_csv_ullong_pos11(X,Y) get_csv_ullong((X),(Y),11) +#define get_csv_ip_pos11(X,Y) get_csv_ip((X),(Y),11) +#define get_csv_ipv6_pos11(X,Y) get_csv_ipv6((X),(Y),11) +#define get_csv_string_pos11(X,Y) get_csv_string((X),(Y),11) +#define get_csv_v_str_pos11(X,Y) get_csv_string((X),(Y),11) +#define get_csv_bool_pos11(X,Y) get_csv_bool((X),(Y),11) +#define get_csv_int_pos11(X,Y) get_csv_int((X),(Y),11) +#define get_csv_llong_pos11(X,Y) get_csv_llong((X),(Y),11) +#define get_csv_float_pos11(X,Y) get_csv_float((X),(Y),11) +#define get_csv_uint_pos12(X,Y) get_csv_uint((X),(Y),12) +#define get_csv_ullong_pos12(X,Y) get_csv_ullong((X),(Y),12) +#define get_csv_ip_pos12(X,Y) get_csv_ip((X),(Y),12) +#define get_csv_ipv6_pos12(X,Y) get_csv_ipv6((X),(Y),12) +#define get_csv_string_pos12(X,Y) get_csv_string((X),(Y),12) +#define get_csv_v_str_pos12(X,Y) get_csv_string((X),(Y),12) +#define get_csv_bool_pos12(X,Y) get_csv_bool((X),(Y),12) +#define get_csv_int_pos12(X,Y) get_csv_int((X),(Y),12) +#define get_csv_llong_pos12(X,Y) get_csv_llong((X),(Y),12) +#define get_csv_float_pos12(X,Y) get_csv_float((X),(Y),12) +#define get_csv_uint_pos13(X,Y) get_csv_uint((X),(Y),13) +#define get_csv_ullong_pos13(X,Y) get_csv_ullong((X),(Y),13) +#define get_csv_ip_pos13(X,Y) get_csv_ip((X),(Y),13) +#define get_csv_ipv6_pos13(X,Y) get_csv_ipv6((X),(Y),13) +#define get_csv_string_pos13(X,Y) get_csv_string((X),(Y),13) +#define get_csv_v_str_pos13(X,Y) get_csv_string((X),(Y),13) +#define get_csv_bool_pos13(X,Y) get_csv_bool((X),(Y),13) +#define get_csv_int_pos13(X,Y) get_csv_int((X),(Y),13) +#define get_csv_llong_pos13(X,Y) get_csv_llong((X),(Y),13) +#define get_csv_float_pos13(X,Y) get_csv_float((X),(Y),13) +#define get_csv_uint_pos14(X,Y) get_csv_uint((X),(Y),14) +#define get_csv_ullong_pos14(X,Y) get_csv_ullong((X),(Y),14) +#define get_csv_ip_pos14(X,Y) get_csv_ip((X),(Y),14) +#define get_csv_ipv6_pos14(X,Y) get_csv_ipv6((X),(Y),14) +#define get_csv_string_pos14(X,Y) get_csv_string((X),(Y),14) +#define get_csv_v_str_pos14(X,Y) get_csv_string((X),(Y),14) +#define get_csv_bool_pos14(X,Y) get_csv_bool((X),(Y),14) +#define get_csv_int_pos14(X,Y) get_csv_int((X),(Y),14) +#define get_csv_llong_pos14(X,Y) get_csv_llong((X),(Y),14) +#define get_csv_float_pos14(X,Y) get_csv_float((X),(Y),14) +#define get_csv_uint_pos15(X,Y) get_csv_uint((X),(Y),15) +#define get_csv_ullong_pos15(X,Y) get_csv_ullong((X),(Y),15) +#define get_csv_ip_pos15(X,Y) get_csv_ip((X),(Y),15) +#define get_csv_ipv6_pos15(X,Y) get_csv_ipv6((X),(Y),15) +#define get_csv_string_pos15(X,Y) get_csv_string((X),(Y),15) +#define get_csv_v_str_pos15(X,Y) get_csv_string((X),(Y),15) +#define get_csv_bool_pos15(X,Y) get_csv_bool((X),(Y),15) +#define get_csv_int_pos15(X,Y) get_csv_int((X),(Y),15) +#define get_csv_llong_pos15(X,Y) get_csv_llong((X),(Y),15) +#define get_csv_float_pos15(X,Y) get_csv_float((X),(Y),15) +#define get_csv_uint_pos16(X,Y) get_csv_uint((X),(Y),16) +#define get_csv_ullong_pos16(X,Y) get_csv_ullong((X),(Y),16) +#define get_csv_ip_pos16(X,Y) get_csv_ip((X),(Y),16) +#define get_csv_ipv6_pos16(X,Y) get_csv_ipv6((X),(Y),16) +#define get_csv_string_pos16(X,Y) get_csv_string((X),(Y),16) +#define get_csv_v_str_pos16(X,Y) get_csv_string((X),(Y),16) +#define get_csv_bool_pos16(X,Y) get_csv_bool((X),(Y),16) +#define get_csv_int_pos16(X,Y) get_csv_int((X),(Y),16) +#define get_csv_llong_pos16(X,Y) get_csv_llong((X),(Y),16) +#define get_csv_float_pos16(X,Y) get_csv_float((X),(Y),16) +#define get_csv_uint_pos17(X,Y) get_csv_uint((X),(Y),17) +#define get_csv_ullong_pos17(X,Y) get_csv_ullong((X),(Y),17) +#define get_csv_ip_pos17(X,Y) get_csv_ip((X),(Y),17) +#define get_csv_ipv6_pos17(X,Y) get_csv_ipv6((X),(Y),17) +#define get_csv_string_pos17(X,Y) get_csv_string((X),(Y),17) +#define get_csv_v_str_pos17(X,Y) get_csv_string((X),(Y),17) +#define get_csv_bool_pos17(X,Y) get_csv_bool((X),(Y),17) +#define get_csv_int_pos17(X,Y) get_csv_int((X),(Y),17) +#define get_csv_llong_pos17(X,Y) get_csv_llong((X),(Y),17) +#define get_csv_float_pos17(X,Y) get_csv_float((X),(Y),17) +#define get_csv_uint_pos18(X,Y) get_csv_uint((X),(Y),18) +#define get_csv_ullong_pos18(X,Y) get_csv_ullong((X),(Y),18) +#define get_csv_ip_pos18(X,Y) get_csv_ip((X),(Y),18) +#define get_csv_ipv6_pos18(X,Y) get_csv_ipv6((X),(Y),18) +#define get_csv_string_pos18(X,Y) get_csv_string((X),(Y),18) +#define get_csv_v_str_pos18(X,Y) get_csv_string((X),(Y),18) +#define get_csv_bool_pos18(X,Y) get_csv_bool((X),(Y),18) +#define get_csv_int_pos18(X,Y) get_csv_int((X),(Y),18) +#define get_csv_llong_pos18(X,Y) get_csv_llong((X),(Y),18) +#define get_csv_float_pos18(X,Y) get_csv_float((X),(Y),18) +#define get_csv_uint_pos19(X,Y) get_csv_uint((X),(Y),19) +#define get_csv_ullong_pos19(X,Y) get_csv_ullong((X),(Y),19) +#define get_csv_ip_pos19(X,Y) get_csv_ip((X),(Y),19) +#define get_csv_ipv6_pos19(X,Y) get_csv_ipv6((X),(Y),19) +#define get_csv_string_pos19(X,Y) get_csv_string((X),(Y),19) +#define get_csv_v_str_pos19(X,Y) get_csv_string((X),(Y),19) +#define get_csv_bool_pos19(X,Y) get_csv_bool((X),(Y),19) +#define get_csv_int_pos19(X,Y) get_csv_int((X),(Y),19) +#define get_csv_llong_pos19(X,Y) get_csv_llong((X),(Y),19) +#define get_csv_float_pos19(X,Y) get_csv_float((X),(Y),19) +#define get_csv_uint_pos20(X,Y) get_csv_uint((X),(Y),20) +#define get_csv_ullong_pos20(X,Y) get_csv_ullong((X),(Y),20) +#define get_csv_ip_pos20(X,Y) get_csv_ip((X),(Y),20) +#define get_csv_ipv6_pos20(X,Y) get_csv_ipv6((X),(Y),20) +#define get_csv_string_pos20(X,Y) get_csv_string((X),(Y),20) +#define get_csv_v_str_pos20(X,Y) get_csv_string((X),(Y),20) +#define get_csv_bool_pos20(X,Y) get_csv_bool((X),(Y),20) +#define get_csv_int_pos20(X,Y) get_csv_int((X),(Y),20) +#define get_csv_llong_pos20(X,Y) get_csv_llong((X),(Y),20) +#define get_csv_float_pos20(X,Y) get_csv_float((X),(Y),20) +#define get_csv_uint_pos21(X,Y) get_csv_uint((X),(Y),21) +#define get_csv_ullong_pos21(X,Y) get_csv_ullong((X),(Y),21) +#define get_csv_ip_pos21(X,Y) get_csv_ip((X),(Y),21) +#define get_csv_ipv6_pos21(X,Y) get_csv_ipv6((X),(Y),21) +#define get_csv_string_pos21(X,Y) get_csv_string((X),(Y),21) +#define get_csv_v_str_pos21(X,Y) get_csv_string((X),(Y),21) +#define get_csv_bool_pos21(X,Y) get_csv_bool((X),(Y),21) +#define get_csv_int_pos21(X,Y) get_csv_int((X),(Y),21) +#define get_csv_llong_pos21(X,Y) get_csv_llong((X),(Y),21) +#define get_csv_float_pos21(X,Y) get_csv_float((X),(Y),21) +#define get_csv_uint_pos22(X,Y) get_csv_uint((X),(Y),22) +#define get_csv_ullong_pos22(X,Y) get_csv_ullong((X),(Y),22) +#define get_csv_ip_pos22(X,Y) get_csv_ip((X),(Y),22) +#define get_csv_ipv6_pos22(X,Y) get_csv_ipv6((X),(Y),22) +#define get_csv_string_pos22(X,Y) get_csv_string((X),(Y),22) +#define get_csv_v_str_pos22(X,Y) get_csv_string((X),(Y),22) +#define get_csv_bool_pos22(X,Y) get_csv_bool((X),(Y),22) +#define get_csv_int_pos22(X,Y) get_csv_int((X),(Y),22) +#define get_csv_llong_pos22(X,Y) get_csv_llong((X),(Y),22) +#define get_csv_float_pos22(X,Y) get_csv_float((X),(Y),22) +#define get_csv_uint_pos23(X,Y) get_csv_uint((X),(Y),23) +#define get_csv_ullong_pos23(X,Y) get_csv_ullong((X),(Y),23) +#define get_csv_ip_pos23(X,Y) get_csv_ip((X),(Y),23) +#define get_csv_ipv6_pos23(X,Y) get_csv_ipv6((X),(Y),23) +#define get_csv_string_pos23(X,Y) get_csv_string((X),(Y),23) +#define get_csv_v_str_pos23(X,Y) get_csv_string((X),(Y),23) +#define get_csv_bool_pos23(X,Y) get_csv_bool((X),(Y),23) +#define get_csv_int_pos23(X,Y) get_csv_int((X),(Y),23) +#define get_csv_llong_pos23(X,Y) get_csv_llong((X),(Y),23) +#define get_csv_float_pos23(X,Y) get_csv_float((X),(Y),23) +#define get_csv_uint_pos24(X,Y) get_csv_uint((X),(Y),24) +#define get_csv_ullong_pos24(X,Y) get_csv_ullong((X),(Y),24) +#define get_csv_ip_pos24(X,Y) get_csv_ip((X),(Y),24) +#define get_csv_ipv6_pos24(X,Y) get_csv_ipv6((X),(Y),24) +#define get_csv_string_pos24(X,Y) get_csv_string((X),(Y),24) +#define get_csv_v_str_pos24(X,Y) get_csv_string((X),(Y),24) +#define get_csv_bool_pos24(X,Y) get_csv_bool((X),(Y),24) +#define get_csv_int_pos24(X,Y) get_csv_int((X),(Y),24) +#define get_csv_llong_pos24(X,Y) get_csv_llong((X),(Y),24) +#define get_csv_float_pos24(X,Y) get_csv_float((X),(Y),24) +#define get_csv_uint_pos25(X,Y) get_csv_uint((X),(Y),25) +#define get_csv_ullong_pos25(X,Y) get_csv_ullong((X),(Y),25) +#define get_csv_ip_pos25(X,Y) get_csv_ip((X),(Y),25) +#define get_csv_ipv6_pos25(X,Y) get_csv_ipv6((X),(Y),25) +#define get_csv_string_pos25(X,Y) get_csv_string((X),(Y),25) +#define get_csv_v_str_pos25(X,Y) get_csv_string((X),(Y),25) +#define get_csv_bool_pos25(X,Y) get_csv_bool((X),(Y),25) +#define get_csv_int_pos25(X,Y) get_csv_int((X),(Y),25) +#define get_csv_llong_pos25(X,Y) get_csv_llong((X),(Y),25) +#define get_csv_float_pos25(X,Y) get_csv_float((X),(Y),25) +#define get_csv_uint_pos26(X,Y) get_csv_uint((X),(Y),26) +#define get_csv_ullong_pos26(X,Y) get_csv_ullong((X),(Y),26) +#define get_csv_ip_pos26(X,Y) get_csv_ip((X),(Y),26) +#define get_csv_ipv6_pos26(X,Y) get_csv_ipv6((X),(Y),26) +#define get_csv_string_pos26(X,Y) get_csv_string((X),(Y),26) +#define get_csv_v_str_pos26(X,Y) get_csv_string((X),(Y),26) +#define get_csv_bool_pos26(X,Y) get_csv_bool((X),(Y),26) +#define get_csv_int_pos26(X,Y) get_csv_int((X),(Y),26) +#define get_csv_llong_pos26(X,Y) get_csv_llong((X),(Y),26) +#define get_csv_float_pos26(X,Y) get_csv_float((X),(Y),26) +#define get_csv_uint_pos27(X,Y) get_csv_uint((X),(Y),27) +#define get_csv_ullong_pos27(X,Y) get_csv_ullong((X),(Y),27) +#define get_csv_ip_pos27(X,Y) get_csv_ip((X),(Y),27) +#define get_csv_ipv6_pos27(X,Y) get_csv_ipv6((X),(Y),27) +#define get_csv_string_pos27(X,Y) get_csv_string((X),(Y),27) +#define get_csv_v_str_pos27(X,Y) get_csv_string((X),(Y),27) +#define get_csv_bool_pos27(X,Y) get_csv_bool((X),(Y),27) +#define get_csv_int_pos27(X,Y) get_csv_int((X),(Y),27) +#define get_csv_llong_pos27(X,Y) get_csv_llong((X),(Y),27) +#define get_csv_float_pos27(X,Y) get_csv_float((X),(Y),27) +#define get_csv_uint_pos28(X,Y) get_csv_uint((X),(Y),28) +#define get_csv_ullong_pos28(X,Y) get_csv_ullong((X),(Y),28) +#define get_csv_ip_pos28(X,Y) get_csv_ip((X),(Y),28) +#define get_csv_ipv6_pos28(X,Y) get_csv_ipv6((X),(Y),28) +#define get_csv_string_pos28(X,Y) get_csv_string((X),(Y),28) +#define get_csv_v_str_pos28(X,Y) get_csv_string((X),(Y),28) +#define get_csv_bool_pos28(X,Y) get_csv_bool((X),(Y),28) +#define get_csv_int_pos28(X,Y) get_csv_int((X),(Y),28) +#define get_csv_llong_pos28(X,Y) get_csv_llong((X),(Y),28) +#define get_csv_float_pos28(X,Y) get_csv_float((X),(Y),28) +#define get_csv_uint_pos29(X,Y) get_csv_uint((X),(Y),29) +#define get_csv_ullong_pos29(X,Y) get_csv_ullong((X),(Y),29) +#define get_csv_ip_pos29(X,Y) get_csv_ip((X),(Y),29) +#define get_csv_ipv6_pos29(X,Y) get_csv_ipv6((X),(Y),29) +#define get_csv_string_pos29(X,Y) get_csv_string((X),(Y),29) +#define get_csv_v_str_pos29(X,Y) get_csv_string((X),(Y),29) +#define get_csv_bool_pos29(X,Y) get_csv_bool((X),(Y),29) +#define get_csv_int_pos29(X,Y) get_csv_int((X),(Y),29) +#define get_csv_llong_pos29(X,Y) get_csv_llong((X),(Y),29) +#define get_csv_float_pos29(X,Y) get_csv_float((X),(Y),29) +#define get_csv_uint_pos30(X,Y) get_csv_uint((X),(Y),30) +#define get_csv_ullong_pos30(X,Y) get_csv_ullong((X),(Y),30) +#define get_csv_ip_pos30(X,Y) get_csv_ip((X),(Y),30) +#define get_csv_ipv6_pos30(X,Y) get_csv_ipv6((X),(Y),30) +#define get_csv_string_pos30(X,Y) get_csv_string((X),(Y),30) +#define get_csv_v_str_pos30(X,Y) get_csv_string((X),(Y),30) +#define get_csv_bool_pos30(X,Y) get_csv_bool((X),(Y),30) +#define get_csv_int_pos30(X,Y) get_csv_int((X),(Y),30) +#define get_csv_llong_pos30(X,Y) get_csv_llong((X),(Y),30) +#define get_csv_float_pos30(X,Y) get_csv_float((X),(Y),30) +#define get_csv_uint_pos31(X,Y) get_csv_uint((X),(Y),31) +#define get_csv_ullong_pos31(X,Y) get_csv_ullong((X),(Y),31) +#define get_csv_ip_pos31(X,Y) get_csv_ip((X),(Y),31) +#define get_csv_ipv6_pos31(X,Y) get_csv_ipv6((X),(Y),31) +#define get_csv_string_pos31(X,Y) get_csv_string((X),(Y),31) +#define get_csv_v_str_pos31(X,Y) get_csv_string((X),(Y),31) +#define get_csv_bool_pos31(X,Y) get_csv_bool((X),(Y),31) +#define get_csv_int_pos31(X,Y) get_csv_int((X),(Y),31) +#define get_csv_llong_pos31(X,Y) get_csv_llong((X),(Y),31) +#define get_csv_float_pos31(X,Y) get_csv_float((X),(Y),31) +#define get_csv_uint_pos32(X,Y) get_csv_uint((X),(Y),32) +#define get_csv_ullong_pos32(X,Y) get_csv_ullong((X),(Y),32) +#define get_csv_ip_pos32(X,Y) get_csv_ip((X),(Y),32) +#define get_csv_ipv6_pos32(X,Y) get_csv_ipv6((X),(Y),32) +#define get_csv_string_pos32(X,Y) get_csv_string((X),(Y),32) +#define get_csv_v_str_pos32(X,Y) get_csv_string((X),(Y),32) +#define get_csv_bool_pos32(X,Y) get_csv_bool((X),(Y),32) +#define get_csv_int_pos32(X,Y) get_csv_int((X),(Y),32) +#define get_csv_llong_pos32(X,Y) get_csv_llong((X),(Y),32) +#define get_csv_float_pos32(X,Y) get_csv_float((X),(Y),32) +#define get_csv_uint_pos33(X,Y) get_csv_uint((X),(Y),33) +#define get_csv_ullong_pos33(X,Y) get_csv_ullong((X),(Y),33) +#define get_csv_ip_pos33(X,Y) get_csv_ip((X),(Y),33) +#define get_csv_ipv6_pos33(X,Y) get_csv_ipv6((X),(Y),33) +#define get_csv_string_pos33(X,Y) get_csv_string((X),(Y),33) +#define get_csv_v_str_pos33(X,Y) get_csv_string((X),(Y),33) +#define get_csv_bool_pos33(X,Y) get_csv_bool((X),(Y),33) +#define get_csv_int_pos33(X,Y) get_csv_int((X),(Y),33) +#define get_csv_llong_pos33(X,Y) get_csv_llong((X),(Y),33) +#define get_csv_float_pos33(X,Y) get_csv_float((X),(Y),33) +#define get_csv_uint_pos34(X,Y) get_csv_uint((X),(Y),34) +#define get_csv_ullong_pos34(X,Y) get_csv_ullong((X),(Y),34) +#define get_csv_ip_pos34(X,Y) get_csv_ip((X),(Y),34) +#define get_csv_ipv6_pos34(X,Y) get_csv_ipv6((X),(Y),34) +#define get_csv_string_pos34(X,Y) get_csv_string((X),(Y),34) +#define get_csv_v_str_pos34(X,Y) get_csv_string((X),(Y),34) +#define get_csv_bool_pos34(X,Y) get_csv_bool((X),(Y),34) +#define get_csv_int_pos34(X,Y) get_csv_int((X),(Y),34) +#define get_csv_llong_pos34(X,Y) get_csv_llong((X),(Y),34) +#define get_csv_float_pos34(X,Y) get_csv_float((X),(Y),34) +#define get_csv_uint_pos35(X,Y) get_csv_uint((X),(Y),35) +#define get_csv_ullong_pos35(X,Y) get_csv_ullong((X),(Y),35) +#define get_csv_ip_pos35(X,Y) get_csv_ip((X),(Y),35) +#define get_csv_ipv6_pos35(X,Y) get_csv_ipv6((X),(Y),35) +#define get_csv_string_pos35(X,Y) get_csv_string((X),(Y),35) +#define get_csv_v_str_pos35(X,Y) get_csv_string((X),(Y),35) +#define get_csv_bool_pos35(X,Y) get_csv_bool((X),(Y),35) +#define get_csv_int_pos35(X,Y) get_csv_int((X),(Y),35) +#define get_csv_llong_pos35(X,Y) get_csv_llong((X),(Y),35) +#define get_csv_float_pos35(X,Y) get_csv_float((X),(Y),35) +#define get_csv_uint_pos36(X,Y) get_csv_uint((X),(Y),36) +#define get_csv_ullong_pos36(X,Y) get_csv_ullong((X),(Y),36) +#define get_csv_ip_pos36(X,Y) get_csv_ip((X),(Y),36) +#define get_csv_ipv6_pos36(X,Y) get_csv_ipv6((X),(Y),36) +#define get_csv_string_pos36(X,Y) get_csv_string((X),(Y),36) +#define get_csv_v_str_pos36(X,Y) get_csv_string((X),(Y),36) +#define get_csv_bool_pos36(X,Y) get_csv_bool((X),(Y),36) +#define get_csv_int_pos36(X,Y) get_csv_int((X),(Y),36) +#define get_csv_llong_pos36(X,Y) get_csv_llong((X),(Y),36) +#define get_csv_float_pos36(X,Y) get_csv_float((X),(Y),36) +#define get_csv_uint_pos37(X,Y) get_csv_uint((X),(Y),37) +#define get_csv_ullong_pos37(X,Y) get_csv_ullong((X),(Y),37) +#define get_csv_ip_pos37(X,Y) get_csv_ip((X),(Y),37) +#define get_csv_ipv6_pos37(X,Y) get_csv_ipv6((X),(Y),37) +#define get_csv_string_pos37(X,Y) get_csv_string((X),(Y),37) +#define get_csv_v_str_pos37(X,Y) get_csv_string((X),(Y),37) +#define get_csv_bool_pos37(X,Y) get_csv_bool((X),(Y),37) +#define get_csv_int_pos37(X,Y) get_csv_int((X),(Y),37) +#define get_csv_llong_pos37(X,Y) get_csv_llong((X),(Y),37) +#define get_csv_float_pos37(X,Y) get_csv_float((X),(Y),37) +#define get_csv_uint_pos38(X,Y) get_csv_uint((X),(Y),38) +#define get_csv_ullong_pos38(X,Y) get_csv_ullong((X),(Y),38) +#define get_csv_ip_pos38(X,Y) get_csv_ip((X),(Y),38) +#define get_csv_ipv6_pos38(X,Y) get_csv_ipv6((X),(Y),38) +#define get_csv_string_pos38(X,Y) get_csv_string((X),(Y),38) +#define get_csv_v_str_pos38(X,Y) get_csv_string((X),(Y),38) +#define get_csv_bool_pos38(X,Y) get_csv_bool((X),(Y),38) +#define get_csv_int_pos38(X,Y) get_csv_int((X),(Y),38) +#define get_csv_llong_pos38(X,Y) get_csv_llong((X),(Y),38) +#define get_csv_float_pos38(X,Y) get_csv_float((X),(Y),38) +#define get_csv_uint_pos39(X,Y) get_csv_uint((X),(Y),39) +#define get_csv_ullong_pos39(X,Y) get_csv_ullong((X),(Y),39) +#define get_csv_ip_pos39(X,Y) get_csv_ip((X),(Y),39) +#define get_csv_ipv6_pos39(X,Y) get_csv_ipv6((X),(Y),39) +#define get_csv_string_pos39(X,Y) get_csv_string((X),(Y),39) +#define get_csv_v_str_pos39(X,Y) get_csv_string((X),(Y),39) +#define get_csv_bool_pos39(X,Y) get_csv_bool((X),(Y),39) +#define get_csv_int_pos39(X,Y) get_csv_int((X),(Y),39) +#define get_csv_llong_pos39(X,Y) get_csv_llong((X),(Y),39) +#define get_csv_float_pos39(X,Y) get_csv_float((X),(Y),39) +#define get_csv_uint_pos40(X,Y) get_csv_uint((X),(Y),40) +#define get_csv_ullong_pos40(X,Y) get_csv_ullong((X),(Y),40) +#define get_csv_ip_pos40(X,Y) get_csv_ip((X),(Y),40) +#define get_csv_ipv6_pos40(X,Y) get_csv_ipv6((X),(Y),40) +#define get_csv_string_pos40(X,Y) get_csv_string((X),(Y),40) +#define get_csv_v_str_pos40(X,Y) get_csv_string((X),(Y),40) +#define get_csv_bool_pos40(X,Y) get_csv_bool((X),(Y),40) +#define get_csv_int_pos40(X,Y) get_csv_int((X),(Y),40) +#define get_csv_llong_pos40(X,Y) get_csv_llong((X),(Y),40) +#define get_csv_float_pos40(X,Y) get_csv_float((X),(Y),40) +#define get_csv_uint_pos41(X,Y) get_csv_uint((X),(Y),41) +#define get_csv_ullong_pos41(X,Y) get_csv_ullong((X),(Y),41) +#define get_csv_ip_pos41(X,Y) get_csv_ip((X),(Y),41) +#define get_csv_ipv6_pos41(X,Y) get_csv_ipv6((X),(Y),41) +#define get_csv_string_pos41(X,Y) get_csv_string((X),(Y),41) +#define get_csv_v_str_pos41(X,Y) get_csv_string((X),(Y),41) +#define get_csv_bool_pos41(X,Y) get_csv_bool((X),(Y),41) +#define get_csv_int_pos41(X,Y) get_csv_int((X),(Y),41) +#define get_csv_llong_pos41(X,Y) get_csv_llong((X),(Y),41) +#define get_csv_float_pos41(X,Y) get_csv_float((X),(Y),41) +#define get_csv_uint_pos42(X,Y) get_csv_uint((X),(Y),42) +#define get_csv_ullong_pos42(X,Y) get_csv_ullong((X),(Y),42) +#define get_csv_ip_pos42(X,Y) get_csv_ip((X),(Y),42) +#define get_csv_ipv6_pos42(X,Y) get_csv_ipv6((X),(Y),42) +#define get_csv_string_pos42(X,Y) get_csv_string((X),(Y),42) +#define get_csv_v_str_pos42(X,Y) get_csv_string((X),(Y),42) +#define get_csv_bool_pos42(X,Y) get_csv_bool((X),(Y),42) +#define get_csv_int_pos42(X,Y) get_csv_int((X),(Y),42) +#define get_csv_llong_pos42(X,Y) get_csv_llong((X),(Y),42) +#define get_csv_float_pos42(X,Y) get_csv_float((X),(Y),42) +#define get_csv_uint_pos43(X,Y) get_csv_uint((X),(Y),43) +#define get_csv_ullong_pos43(X,Y) get_csv_ullong((X),(Y),43) +#define get_csv_ip_pos43(X,Y) get_csv_ip((X),(Y),43) +#define get_csv_ipv6_pos43(X,Y) get_csv_ipv6((X),(Y),43) +#define get_csv_string_pos43(X,Y) get_csv_string((X),(Y),43) +#define get_csv_v_str_pos43(X,Y) get_csv_string((X),(Y),43) +#define get_csv_bool_pos43(X,Y) get_csv_bool((X),(Y),43) +#define get_csv_int_pos43(X,Y) get_csv_int((X),(Y),43) +#define get_csv_llong_pos43(X,Y) get_csv_llong((X),(Y),43) +#define get_csv_float_pos43(X,Y) get_csv_float((X),(Y),43) +#define get_csv_uint_pos44(X,Y) get_csv_uint((X),(Y),44) +#define get_csv_ullong_pos44(X,Y) get_csv_ullong((X),(Y),44) +#define get_csv_ip_pos44(X,Y) get_csv_ip((X),(Y),44) +#define get_csv_ipv6_pos44(X,Y) get_csv_ipv6((X),(Y),44) +#define get_csv_string_pos44(X,Y) get_csv_string((X),(Y),44) +#define get_csv_v_str_pos44(X,Y) get_csv_string((X),(Y),44) +#define get_csv_bool_pos44(X,Y) get_csv_bool((X),(Y),44) +#define get_csv_int_pos44(X,Y) get_csv_int((X),(Y),44) +#define get_csv_llong_pos44(X,Y) get_csv_llong((X),(Y),44) +#define get_csv_float_pos44(X,Y) get_csv_float((X),(Y),44) +#define get_csv_uint_pos45(X,Y) get_csv_uint((X),(Y),45) +#define get_csv_ullong_pos45(X,Y) get_csv_ullong((X),(Y),45) +#define get_csv_ip_pos45(X,Y) get_csv_ip((X),(Y),45) +#define get_csv_ipv6_pos45(X,Y) get_csv_ipv6((X),(Y),45) +#define get_csv_string_pos45(X,Y) get_csv_string((X),(Y),45) +#define get_csv_v_str_pos45(X,Y) get_csv_string((X),(Y),45) +#define get_csv_bool_pos45(X,Y) get_csv_bool((X),(Y),45) +#define get_csv_int_pos45(X,Y) get_csv_int((X),(Y),45) +#define get_csv_llong_pos45(X,Y) get_csv_llong((X),(Y),45) +#define get_csv_float_pos45(X,Y) get_csv_float((X),(Y),45) +#define get_csv_uint_pos46(X,Y) get_csv_uint((X),(Y),46) +#define get_csv_ullong_pos46(X,Y) get_csv_ullong((X),(Y),46) +#define get_csv_ip_pos46(X,Y) get_csv_ip((X),(Y),46) +#define get_csv_ipv6_pos46(X,Y) get_csv_ipv6((X),(Y),46) +#define get_csv_string_pos46(X,Y) get_csv_string((X),(Y),46) +#define get_csv_v_str_pos46(X,Y) get_csv_string((X),(Y),46) +#define get_csv_bool_pos46(X,Y) get_csv_bool((X),(Y),46) +#define get_csv_int_pos46(X,Y) get_csv_int((X),(Y),46) +#define get_csv_llong_pos46(X,Y) get_csv_llong((X),(Y),46) +#define get_csv_float_pos46(X,Y) get_csv_float((X),(Y),46) +#define get_csv_uint_pos47(X,Y) get_csv_uint((X),(Y),47) +#define get_csv_ullong_pos47(X,Y) get_csv_ullong((X),(Y),47) +#define get_csv_ip_pos47(X,Y) get_csv_ip((X),(Y),47) +#define get_csv_ipv6_pos47(X,Y) get_csv_ipv6((X),(Y),47) +#define get_csv_string_pos47(X,Y) get_csv_string((X),(Y),47) +#define get_csv_v_str_pos47(X,Y) get_csv_string((X),(Y),47) +#define get_csv_bool_pos47(X,Y) get_csv_bool((X),(Y),47) +#define get_csv_int_pos47(X,Y) get_csv_int((X),(Y),47) +#define get_csv_llong_pos47(X,Y) get_csv_llong((X),(Y),47) +#define get_csv_float_pos47(X,Y) get_csv_float((X),(Y),47) +#define get_csv_uint_pos48(X,Y) get_csv_uint((X),(Y),48) +#define get_csv_ullong_pos48(X,Y) get_csv_ullong((X),(Y),48) +#define get_csv_ip_pos48(X,Y) get_csv_ip((X),(Y),48) +#define get_csv_ipv6_pos48(X,Y) get_csv_ipv6((X),(Y),48) +#define get_csv_string_pos48(X,Y) get_csv_string((X),(Y),48) +#define get_csv_v_str_pos48(X,Y) get_csv_string((X),(Y),48) +#define get_csv_bool_pos48(X,Y) get_csv_bool((X),(Y),48) +#define get_csv_int_pos48(X,Y) get_csv_int((X),(Y),48) +#define get_csv_llong_pos48(X,Y) get_csv_llong((X),(Y),48) +#define get_csv_float_pos48(X,Y) get_csv_float((X),(Y),48) +#define get_csv_uint_pos49(X,Y) get_csv_uint((X),(Y),49) +#define get_csv_ullong_pos49(X,Y) get_csv_ullong((X),(Y),49) +#define get_csv_ip_pos49(X,Y) get_csv_ip((X),(Y),49) +#define get_csv_ipv6_pos49(X,Y) get_csv_ipv6((X),(Y),49) +#define get_csv_string_pos49(X,Y) get_csv_string((X),(Y),49) +#define get_csv_v_str_pos49(X,Y) get_csv_string((X),(Y),49) +#define get_csv_bool_pos49(X,Y) get_csv_bool((X),(Y),49) +#define get_csv_int_pos49(X,Y) get_csv_int((X),(Y),49) +#define get_csv_llong_pos49(X,Y) get_csv_llong((X),(Y),49) +#define get_csv_float_pos49(X,Y) get_csv_float((X),(Y),49) +#define get_csv_uint_pos50(X,Y) get_csv_uint((X),(Y),50) +#define get_csv_ullong_pos50(X,Y) get_csv_ullong((X),(Y),50) +#define get_csv_ip_pos50(X,Y) get_csv_ip((X),(Y),50) +#define get_csv_ipv6_pos50(X,Y) get_csv_ipv6((X),(Y),50) +#define get_csv_string_pos50(X,Y) get_csv_string((X),(Y),50) +#define get_csv_v_str_pos50(X,Y) get_csv_string((X),(Y),50) +#define get_csv_bool_pos50(X,Y) get_csv_bool((X),(Y),50) +#define get_csv_int_pos50(X,Y) get_csv_int((X),(Y),50) +#define get_csv_llong_pos50(X,Y) get_csv_llong((X),(Y),50) +#define get_csv_float_pos50(X,Y) get_csv_float((X),(Y),50) +#define get_csv_uint_pos51(X,Y) get_csv_uint((X),(Y),51) +#define get_csv_ullong_pos51(X,Y) get_csv_ullong((X),(Y),51) +#define get_csv_ip_pos51(X,Y) get_csv_ip((X),(Y),51) +#define get_csv_ipv6_pos51(X,Y) get_csv_ipv6((X),(Y),51) +#define get_csv_string_pos51(X,Y) get_csv_string((X),(Y),51) +#define get_csv_v_str_pos51(X,Y) get_csv_string((X),(Y),51) +#define get_csv_bool_pos51(X,Y) get_csv_bool((X),(Y),51) +#define get_csv_int_pos51(X,Y) get_csv_int((X),(Y),51) +#define get_csv_llong_pos51(X,Y) get_csv_llong((X),(Y),51) +#define get_csv_float_pos51(X,Y) get_csv_float((X),(Y),51) +#define get_csv_uint_pos52(X,Y) get_csv_uint((X),(Y),52) +#define get_csv_ullong_pos52(X,Y) get_csv_ullong((X),(Y),52) +#define get_csv_ip_pos52(X,Y) get_csv_ip((X),(Y),52) +#define get_csv_ipv6_pos52(X,Y) get_csv_ipv6((X),(Y),52) +#define get_csv_string_pos52(X,Y) get_csv_string((X),(Y),52) +#define get_csv_v_str_pos52(X,Y) get_csv_string((X),(Y),52) +#define get_csv_bool_pos52(X,Y) get_csv_bool((X),(Y),52) +#define get_csv_int_pos52(X,Y) get_csv_int((X),(Y),52) +#define get_csv_llong_pos52(X,Y) get_csv_llong((X),(Y),52) +#define get_csv_float_pos52(X,Y) get_csv_float((X),(Y),52) +#define get_csv_uint_pos53(X,Y) get_csv_uint((X),(Y),53) +#define get_csv_ullong_pos53(X,Y) get_csv_ullong((X),(Y),53) +#define get_csv_ip_pos53(X,Y) get_csv_ip((X),(Y),53) +#define get_csv_ipv6_pos53(X,Y) get_csv_ipv6((X),(Y),53) +#define get_csv_string_pos53(X,Y) get_csv_string((X),(Y),53) +#define get_csv_v_str_pos53(X,Y) get_csv_string((X),(Y),53) +#define get_csv_bool_pos53(X,Y) get_csv_bool((X),(Y),53) +#define get_csv_int_pos53(X,Y) get_csv_int((X),(Y),53) +#define get_csv_llong_pos53(X,Y) get_csv_llong((X),(Y),53) +#define get_csv_float_pos53(X,Y) get_csv_float((X),(Y),53) +#define get_csv_uint_pos54(X,Y) get_csv_uint((X),(Y),54) +#define get_csv_ullong_pos54(X,Y) get_csv_ullong((X),(Y),54) +#define get_csv_ip_pos54(X,Y) get_csv_ip((X),(Y),54) +#define get_csv_ipv6_pos54(X,Y) get_csv_ipv6((X),(Y),54) +#define get_csv_string_pos54(X,Y) get_csv_string((X),(Y),54) +#define get_csv_v_str_pos54(X,Y) get_csv_string((X),(Y),54) +#define get_csv_bool_pos54(X,Y) get_csv_bool((X),(Y),54) +#define get_csv_int_pos54(X,Y) get_csv_int((X),(Y),54) +#define get_csv_llong_pos54(X,Y) get_csv_llong((X),(Y),54) +#define get_csv_float_pos54(X,Y) get_csv_float((X),(Y),54) +#define get_csv_uint_pos55(X,Y) get_csv_uint((X),(Y),55) +#define get_csv_ullong_pos55(X,Y) get_csv_ullong((X),(Y),55) +#define get_csv_ip_pos55(X,Y) get_csv_ip((X),(Y),55) +#define get_csv_ipv6_pos55(X,Y) get_csv_ipv6((X),(Y),55) +#define get_csv_string_pos55(X,Y) get_csv_string((X),(Y),55) +#define get_csv_v_str_pos55(X,Y) get_csv_string((X),(Y),55) +#define get_csv_bool_pos55(X,Y) get_csv_bool((X),(Y),55) +#define get_csv_int_pos55(X,Y) get_csv_int((X),(Y),55) +#define get_csv_llong_pos55(X,Y) get_csv_llong((X),(Y),55) +#define get_csv_float_pos55(X,Y) get_csv_float((X),(Y),55) +#define get_csv_uint_pos56(X,Y) get_csv_uint((X),(Y),56) +#define get_csv_ullong_pos56(X,Y) get_csv_ullong((X),(Y),56) +#define get_csv_ip_pos56(X,Y) get_csv_ip((X),(Y),56) +#define get_csv_ipv6_pos56(X,Y) get_csv_ipv6((X),(Y),56) +#define get_csv_string_pos56(X,Y) get_csv_string((X),(Y),56) +#define get_csv_v_str_pos56(X,Y) get_csv_string((X),(Y),56) +#define get_csv_bool_pos56(X,Y) get_csv_bool((X),(Y),56) +#define get_csv_int_pos56(X,Y) get_csv_int((X),(Y),56) +#define get_csv_llong_pos56(X,Y) get_csv_llong((X),(Y),56) +#define get_csv_float_pos56(X,Y) get_csv_float((X),(Y),56) +#define get_csv_uint_pos57(X,Y) get_csv_uint((X),(Y),57) +#define get_csv_ullong_pos57(X,Y) get_csv_ullong((X),(Y),57) +#define get_csv_ip_pos57(X,Y) get_csv_ip((X),(Y),57) +#define get_csv_ipv6_pos57(X,Y) get_csv_ipv6((X),(Y),57) +#define get_csv_string_pos57(X,Y) get_csv_string((X),(Y),57) +#define get_csv_v_str_pos57(X,Y) get_csv_string((X),(Y),57) +#define get_csv_bool_pos57(X,Y) get_csv_bool((X),(Y),57) +#define get_csv_int_pos57(X,Y) get_csv_int((X),(Y),57) +#define get_csv_llong_pos57(X,Y) get_csv_llong((X),(Y),57) +#define get_csv_float_pos57(X,Y) get_csv_float((X),(Y),57) +#define get_csv_uint_pos58(X,Y) get_csv_uint((X),(Y),58) +#define get_csv_ullong_pos58(X,Y) get_csv_ullong((X),(Y),58) +#define get_csv_ip_pos58(X,Y) get_csv_ip((X),(Y),58) +#define get_csv_ipv6_pos58(X,Y) get_csv_ipv6((X),(Y),58) +#define get_csv_string_pos58(X,Y) get_csv_string((X),(Y),58) +#define get_csv_v_str_pos58(X,Y) get_csv_string((X),(Y),58) +#define get_csv_bool_pos58(X,Y) get_csv_bool((X),(Y),58) +#define get_csv_int_pos58(X,Y) get_csv_int((X),(Y),58) +#define get_csv_llong_pos58(X,Y) get_csv_llong((X),(Y),58) +#define get_csv_float_pos58(X,Y) get_csv_float((X),(Y),58) +#define get_csv_uint_pos59(X,Y) get_csv_uint((X),(Y),59) +#define get_csv_ullong_pos59(X,Y) get_csv_ullong((X),(Y),59) +#define get_csv_ip_pos59(X,Y) get_csv_ip((X),(Y),59) +#define get_csv_ipv6_pos59(X,Y) get_csv_ipv6((X),(Y),59) +#define get_csv_string_pos59(X,Y) get_csv_string((X),(Y),59) +#define get_csv_v_str_pos59(X,Y) get_csv_string((X),(Y),59) +#define get_csv_bool_pos59(X,Y) get_csv_bool((X),(Y),59) +#define get_csv_int_pos59(X,Y) get_csv_int((X),(Y),59) +#define get_csv_llong_pos59(X,Y) get_csv_llong((X),(Y),59) +#define get_csv_float_pos59(X,Y) get_csv_float((X),(Y),59) +#define get_csv_uint_pos60(X,Y) get_csv_uint((X),(Y),60) +#define get_csv_ullong_pos60(X,Y) get_csv_ullong((X),(Y),60) +#define get_csv_ip_pos60(X,Y) get_csv_ip((X),(Y),60) +#define get_csv_ipv6_pos60(X,Y) get_csv_ipv6((X),(Y),60) +#define get_csv_string_pos60(X,Y) get_csv_string((X),(Y),60) +#define get_csv_v_str_pos60(X,Y) get_csv_string((X),(Y),60) +#define get_csv_bool_pos60(X,Y) get_csv_bool((X),(Y),60) +#define get_csv_int_pos60(X,Y) get_csv_int((X),(Y),60) +#define get_csv_llong_pos60(X,Y) get_csv_llong((X),(Y),60) +#define get_csv_float_pos60(X,Y) get_csv_float((X),(Y),60) +#define get_csv_uint_pos61(X,Y) get_csv_uint((X),(Y),61) +#define get_csv_ullong_pos61(X,Y) get_csv_ullong((X),(Y),61) +#define get_csv_ip_pos61(X,Y) get_csv_ip((X),(Y),61) +#define get_csv_ipv6_pos61(X,Y) get_csv_ipv6((X),(Y),61) +#define get_csv_string_pos61(X,Y) get_csv_string((X),(Y),61) +#define get_csv_v_str_pos61(X,Y) get_csv_string((X),(Y),61) +#define get_csv_bool_pos61(X,Y) get_csv_bool((X),(Y),61) +#define get_csv_int_pos61(X,Y) get_csv_int((X),(Y),61) +#define get_csv_llong_pos61(X,Y) get_csv_llong((X),(Y),61) +#define get_csv_float_pos61(X,Y) get_csv_float((X),(Y),61) +#define get_csv_uint_pos62(X,Y) get_csv_uint((X),(Y),62) +#define get_csv_ullong_pos62(X,Y) get_csv_ullong((X),(Y),62) +#define get_csv_ip_pos62(X,Y) get_csv_ip((X),(Y),62) +#define get_csv_ipv6_pos62(X,Y) get_csv_ipv6((X),(Y),62) +#define get_csv_string_pos62(X,Y) get_csv_string((X),(Y),62) +#define get_csv_v_str_pos62(X,Y) get_csv_string((X),(Y),62) +#define get_csv_bool_pos62(X,Y) get_csv_bool((X),(Y),62) +#define get_csv_int_pos62(X,Y) get_csv_int((X),(Y),62) +#define get_csv_llong_pos62(X,Y) get_csv_llong((X),(Y),62) +#define get_csv_float_pos62(X,Y) get_csv_float((X),(Y),62) +#define get_csv_uint_pos63(X,Y) get_csv_uint((X),(Y),63) +#define get_csv_ullong_pos63(X,Y) get_csv_ullong((X),(Y),63) +#define get_csv_ip_pos63(X,Y) get_csv_ip((X),(Y),63) +#define get_csv_ipv6_pos63(X,Y) get_csv_ipv6((X),(Y),63) +#define get_csv_string_pos63(X,Y) get_csv_string((X),(Y),63) +#define get_csv_v_str_pos63(X,Y) get_csv_string((X),(Y),63) +#define get_csv_bool_pos63(X,Y) get_csv_bool((X),(Y),63) +#define get_csv_int_pos63(X,Y) get_csv_int((X),(Y),63) +#define get_csv_llong_pos63(X,Y) get_csv_llong((X),(Y),63) +#define get_csv_float_pos63(X,Y) get_csv_float((X),(Y),63) +#define get_csv_uint_pos64(X,Y) get_csv_uint((X),(Y),64) +#define get_csv_ullong_pos64(X,Y) get_csv_ullong((X),(Y),64) +#define get_csv_ip_pos64(X,Y) get_csv_ip((X),(Y),64) +#define get_csv_ipv6_pos64(X,Y) get_csv_ipv6((X),(Y),64) +#define get_csv_string_pos64(X,Y) get_csv_string((X),(Y),64) +#define get_csv_v_str_pos64(X,Y) get_csv_string((X),(Y),64) +#define get_csv_bool_pos64(X,Y) get_csv_bool((X),(Y),64) +#define get_csv_int_pos64(X,Y) get_csv_int((X),(Y),64) +#define get_csv_llong_pos64(X,Y) get_csv_llong((X),(Y),64) +#define get_csv_float_pos64(X,Y) get_csv_float((X),(Y),64) +#define get_csv_uint_pos65(X,Y) get_csv_uint((X),(Y),65) +#define get_csv_ullong_pos65(X,Y) get_csv_ullong((X),(Y),65) +#define get_csv_ip_pos65(X,Y) get_csv_ip((X),(Y),65) +#define get_csv_ipv6_pos65(X,Y) get_csv_ipv6((X),(Y),65) +#define get_csv_string_pos65(X,Y) get_csv_string((X),(Y),65) +#define get_csv_v_str_pos65(X,Y) get_csv_string((X),(Y),65) +#define get_csv_bool_pos65(X,Y) get_csv_bool((X),(Y),65) +#define get_csv_int_pos65(X,Y) get_csv_int((X),(Y),65) +#define get_csv_llong_pos65(X,Y) get_csv_llong((X),(Y),65) +#define get_csv_float_pos65(X,Y) get_csv_float((X),(Y),65) +#define get_csv_uint_pos66(X,Y) get_csv_uint((X),(Y),66) +#define get_csv_ullong_pos66(X,Y) get_csv_ullong((X),(Y),66) +#define get_csv_ip_pos66(X,Y) get_csv_ip((X),(Y),66) +#define get_csv_ipv6_pos66(X,Y) get_csv_ipv6((X),(Y),66) +#define get_csv_string_pos66(X,Y) get_csv_string((X),(Y),66) +#define get_csv_v_str_pos66(X,Y) get_csv_string((X),(Y),66) +#define get_csv_bool_pos66(X,Y) get_csv_bool((X),(Y),66) +#define get_csv_int_pos66(X,Y) get_csv_int((X),(Y),66) +#define get_csv_llong_pos66(X,Y) get_csv_llong((X),(Y),66) +#define get_csv_float_pos66(X,Y) get_csv_float((X),(Y),66) +#define get_csv_uint_pos67(X,Y) get_csv_uint((X),(Y),67) +#define get_csv_ullong_pos67(X,Y) get_csv_ullong((X),(Y),67) +#define get_csv_ip_pos67(X,Y) get_csv_ip((X),(Y),67) +#define get_csv_ipv6_pos67(X,Y) get_csv_ipv6((X),(Y),67) +#define get_csv_string_pos67(X,Y) get_csv_string((X),(Y),67) +#define get_csv_v_str_pos67(X,Y) get_csv_string((X),(Y),67) +#define get_csv_bool_pos67(X,Y) get_csv_bool((X),(Y),67) +#define get_csv_int_pos67(X,Y) get_csv_int((X),(Y),67) +#define get_csv_llong_pos67(X,Y) get_csv_llong((X),(Y),67) +#define get_csv_float_pos67(X,Y) get_csv_float((X),(Y),67) +#define get_csv_uint_pos68(X,Y) get_csv_uint((X),(Y),68) +#define get_csv_ullong_pos68(X,Y) get_csv_ullong((X),(Y),68) +#define get_csv_ip_pos68(X,Y) get_csv_ip((X),(Y),68) +#define get_csv_ipv6_pos68(X,Y) get_csv_ipv6((X),(Y),68) +#define get_csv_string_pos68(X,Y) get_csv_string((X),(Y),68) +#define get_csv_v_str_pos68(X,Y) get_csv_string((X),(Y),68) +#define get_csv_bool_pos68(X,Y) get_csv_bool((X),(Y),68) +#define get_csv_int_pos68(X,Y) get_csv_int((X),(Y),68) +#define get_csv_llong_pos68(X,Y) get_csv_llong((X),(Y),68) +#define get_csv_float_pos68(X,Y) get_csv_float((X),(Y),68) +#define get_csv_uint_pos69(X,Y) get_csv_uint((X),(Y),69) +#define get_csv_ullong_pos69(X,Y) get_csv_ullong((X),(Y),69) +#define get_csv_ip_pos69(X,Y) get_csv_ip((X),(Y),69) +#define get_csv_ipv6_pos69(X,Y) get_csv_ipv6((X),(Y),69) +#define get_csv_string_pos69(X,Y) get_csv_string((X),(Y),69) +#define get_csv_v_str_pos69(X,Y) get_csv_string((X),(Y),69) +#define get_csv_bool_pos69(X,Y) get_csv_bool((X),(Y),69) +#define get_csv_int_pos69(X,Y) get_csv_int((X),(Y),69) +#define get_csv_llong_pos69(X,Y) get_csv_llong((X),(Y),69) +#define get_csv_float_pos69(X,Y) get_csv_float((X),(Y),69) +#define get_csv_uint_pos70(X,Y) get_csv_uint((X),(Y),70) +#define get_csv_ullong_pos70(X,Y) get_csv_ullong((X),(Y),70) +#define get_csv_ip_pos70(X,Y) get_csv_ip((X),(Y),70) +#define get_csv_ipv6_pos70(X,Y) get_csv_ipv6((X),(Y),70) +#define get_csv_string_pos70(X,Y) get_csv_string((X),(Y),70) +#define get_csv_v_str_pos70(X,Y) get_csv_string((X),(Y),70) +#define get_csv_bool_pos70(X,Y) get_csv_bool((X),(Y),70) +#define get_csv_int_pos70(X,Y) get_csv_int((X),(Y),70) +#define get_csv_llong_pos70(X,Y) get_csv_llong((X),(Y),70) +#define get_csv_float_pos70(X,Y) get_csv_float((X),(Y),70) +#define get_csv_uint_pos71(X,Y) get_csv_uint((X),(Y),71) +#define get_csv_ullong_pos71(X,Y) get_csv_ullong((X),(Y),71) +#define get_csv_ip_pos71(X,Y) get_csv_ip((X),(Y),71) +#define get_csv_ipv6_pos71(X,Y) get_csv_ipv6((X),(Y),71) +#define get_csv_string_pos71(X,Y) get_csv_string((X),(Y),71) +#define get_csv_v_str_pos71(X,Y) get_csv_string((X),(Y),71) +#define get_csv_bool_pos71(X,Y) get_csv_bool((X),(Y),71) +#define get_csv_int_pos71(X,Y) get_csv_int((X),(Y),71) +#define get_csv_llong_pos71(X,Y) get_csv_llong((X),(Y),71) +#define get_csv_float_pos71(X,Y) get_csv_float((X),(Y),71) +#define get_csv_uint_pos72(X,Y) get_csv_uint((X),(Y),72) +#define get_csv_ullong_pos72(X,Y) get_csv_ullong((X),(Y),72) +#define get_csv_ip_pos72(X,Y) get_csv_ip((X),(Y),72) +#define get_csv_ipv6_pos72(X,Y) get_csv_ipv6((X),(Y),72) +#define get_csv_string_pos72(X,Y) get_csv_string((X),(Y),72) +#define get_csv_v_str_pos72(X,Y) get_csv_string((X),(Y),72) +#define get_csv_bool_pos72(X,Y) get_csv_bool((X),(Y),72) +#define get_csv_int_pos72(X,Y) get_csv_int((X),(Y),72) +#define get_csv_llong_pos72(X,Y) get_csv_llong((X),(Y),72) +#define get_csv_float_pos72(X,Y) get_csv_float((X),(Y),72) +#define get_csv_uint_pos73(X,Y) get_csv_uint((X),(Y),73) +#define get_csv_ullong_pos73(X,Y) get_csv_ullong((X),(Y),73) +#define get_csv_ip_pos73(X,Y) get_csv_ip((X),(Y),73) +#define get_csv_ipv6_pos73(X,Y) get_csv_ipv6((X),(Y),73) +#define get_csv_string_pos73(X,Y) get_csv_string((X),(Y),73) +#define get_csv_v_str_pos73(X,Y) get_csv_string((X),(Y),73) +#define get_csv_bool_pos73(X,Y) get_csv_bool((X),(Y),73) +#define get_csv_int_pos73(X,Y) get_csv_int((X),(Y),73) +#define get_csv_llong_pos73(X,Y) get_csv_llong((X),(Y),73) +#define get_csv_float_pos73(X,Y) get_csv_float((X),(Y),73) +#define get_csv_uint_pos74(X,Y) get_csv_uint((X),(Y),74) +#define get_csv_ullong_pos74(X,Y) get_csv_ullong((X),(Y),74) +#define get_csv_ip_pos74(X,Y) get_csv_ip((X),(Y),74) +#define get_csv_ipv6_pos74(X,Y) get_csv_ipv6((X),(Y),74) +#define get_csv_string_pos74(X,Y) get_csv_string((X),(Y),74) +#define get_csv_v_str_pos74(X,Y) get_csv_string((X),(Y),74) +#define get_csv_bool_pos74(X,Y) get_csv_bool((X),(Y),74) +#define get_csv_int_pos74(X,Y) get_csv_int((X),(Y),74) +#define get_csv_llong_pos74(X,Y) get_csv_llong((X),(Y),74) +#define get_csv_float_pos74(X,Y) get_csv_float((X),(Y),74) +#define get_csv_uint_pos75(X,Y) get_csv_uint((X),(Y),75) +#define get_csv_ullong_pos75(X,Y) get_csv_ullong((X),(Y),75) +#define get_csv_ip_pos75(X,Y) get_csv_ip((X),(Y),75) +#define get_csv_ipv6_pos75(X,Y) get_csv_ipv6((X),(Y),75) +#define get_csv_string_pos75(X,Y) get_csv_string((X),(Y),75) +#define get_csv_v_str_pos75(X,Y) get_csv_string((X),(Y),75) +#define get_csv_bool_pos75(X,Y) get_csv_bool((X),(Y),75) +#define get_csv_int_pos75(X,Y) get_csv_int((X),(Y),75) +#define get_csv_llong_pos75(X,Y) get_csv_llong((X),(Y),75) +#define get_csv_float_pos75(X,Y) get_csv_float((X),(Y),75) +#define get_csv_uint_pos76(X,Y) get_csv_uint((X),(Y),76) +#define get_csv_ullong_pos76(X,Y) get_csv_ullong((X),(Y),76) +#define get_csv_ip_pos76(X,Y) get_csv_ip((X),(Y),76) +#define get_csv_ipv6_pos76(X,Y) get_csv_ipv6((X),(Y),76) +#define get_csv_string_pos76(X,Y) get_csv_string((X),(Y),76) +#define get_csv_v_str_pos76(X,Y) get_csv_string((X),(Y),76) +#define get_csv_bool_pos76(X,Y) get_csv_bool((X),(Y),76) +#define get_csv_int_pos76(X,Y) get_csv_int((X),(Y),76) +#define get_csv_llong_pos76(X,Y) get_csv_llong((X),(Y),76) +#define get_csv_float_pos76(X,Y) get_csv_float((X),(Y),76) +#define get_csv_uint_pos77(X,Y) get_csv_uint((X),(Y),77) +#define get_csv_ullong_pos77(X,Y) get_csv_ullong((X),(Y),77) +#define get_csv_ip_pos77(X,Y) get_csv_ip((X),(Y),77) +#define get_csv_ipv6_pos77(X,Y) get_csv_ipv6((X),(Y),77) +#define get_csv_string_pos77(X,Y) get_csv_string((X),(Y),77) +#define get_csv_v_str_pos77(X,Y) get_csv_string((X),(Y),77) +#define get_csv_bool_pos77(X,Y) get_csv_bool((X),(Y),77) +#define get_csv_int_pos77(X,Y) get_csv_int((X),(Y),77) +#define get_csv_llong_pos77(X,Y) get_csv_llong((X),(Y),77) +#define get_csv_float_pos77(X,Y) get_csv_float((X),(Y),77) +#define get_csv_uint_pos78(X,Y) get_csv_uint((X),(Y),78) +#define get_csv_ullong_pos78(X,Y) get_csv_ullong((X),(Y),78) +#define get_csv_ip_pos78(X,Y) get_csv_ip((X),(Y),78) +#define get_csv_ipv6_pos78(X,Y) get_csv_ipv6((X),(Y),78) +#define get_csv_string_pos78(X,Y) get_csv_string((X),(Y),78) +#define get_csv_v_str_pos78(X,Y) get_csv_string((X),(Y),78) +#define get_csv_bool_pos78(X,Y) get_csv_bool((X),(Y),78) +#define get_csv_int_pos78(X,Y) get_csv_int((X),(Y),78) +#define get_csv_llong_pos78(X,Y) get_csv_llong((X),(Y),78) +#define get_csv_float_pos78(X,Y) get_csv_float((X),(Y),78) +#define get_csv_uint_pos79(X,Y) get_csv_uint((X),(Y),79) +#define get_csv_ullong_pos79(X,Y) get_csv_ullong((X),(Y),79) +#define get_csv_ip_pos79(X,Y) get_csv_ip((X),(Y),79) +#define get_csv_ipv6_pos79(X,Y) get_csv_ipv6((X),(Y),79) +#define get_csv_string_pos79(X,Y) get_csv_string((X),(Y),79) +#define get_csv_v_str_pos79(X,Y) get_csv_string((X),(Y),79) +#define get_csv_bool_pos79(X,Y) get_csv_bool((X),(Y),79) +#define get_csv_int_pos79(X,Y) get_csv_int((X),(Y),79) +#define get_csv_llong_pos79(X,Y) get_csv_llong((X),(Y),79) +#define get_csv_float_pos79(X,Y) get_csv_float((X),(Y),79) +#define get_csv_uint_pos80(X,Y) get_csv_uint((X),(Y),80) +#define get_csv_ullong_pos80(X,Y) get_csv_ullong((X),(Y),80) +#define get_csv_ip_pos80(X,Y) get_csv_ip((X),(Y),80) +#define get_csv_ipv6_pos80(X,Y) get_csv_ipv6((X),(Y),80) +#define get_csv_string_pos80(X,Y) get_csv_string((X),(Y),80) +#define get_csv_v_str_pos80(X,Y) get_csv_string((X),(Y),80) +#define get_csv_bool_pos80(X,Y) get_csv_bool((X),(Y),80) +#define get_csv_int_pos80(X,Y) get_csv_int((X),(Y),80) +#define get_csv_llong_pos80(X,Y) get_csv_llong((X),(Y),80) +#define get_csv_float_pos80(X,Y) get_csv_float((X),(Y),80) +#define get_csv_uint_pos81(X,Y) get_csv_uint((X),(Y),81) +#define get_csv_ullong_pos81(X,Y) get_csv_ullong((X),(Y),81) +#define get_csv_ip_pos81(X,Y) get_csv_ip((X),(Y),81) +#define get_csv_ipv6_pos81(X,Y) get_csv_ipv6((X),(Y),81) +#define get_csv_string_pos81(X,Y) get_csv_string((X),(Y),81) +#define get_csv_v_str_pos81(X,Y) get_csv_string((X),(Y),81) +#define get_csv_bool_pos81(X,Y) get_csv_bool((X),(Y),81) +#define get_csv_int_pos81(X,Y) get_csv_int((X),(Y),81) +#define get_csv_llong_pos81(X,Y) get_csv_llong((X),(Y),81) +#define get_csv_float_pos81(X,Y) get_csv_float((X),(Y),81) +#define get_csv_uint_pos82(X,Y) get_csv_uint((X),(Y),82) +#define get_csv_ullong_pos82(X,Y) get_csv_ullong((X),(Y),82) +#define get_csv_ip_pos82(X,Y) get_csv_ip((X),(Y),82) +#define get_csv_ipv6_pos82(X,Y) get_csv_ipv6((X),(Y),82) +#define get_csv_string_pos82(X,Y) get_csv_string((X),(Y),82) +#define get_csv_v_str_pos82(X,Y) get_csv_string((X),(Y),82) +#define get_csv_bool_pos82(X,Y) get_csv_bool((X),(Y),82) +#define get_csv_int_pos82(X,Y) get_csv_int((X),(Y),82) +#define get_csv_llong_pos82(X,Y) get_csv_llong((X),(Y),82) +#define get_csv_float_pos82(X,Y) get_csv_float((X),(Y),82) +#define get_csv_uint_pos83(X,Y) get_csv_uint((X),(Y),83) +#define get_csv_ullong_pos83(X,Y) get_csv_ullong((X),(Y),83) +#define get_csv_ip_pos83(X,Y) get_csv_ip((X),(Y),83) +#define get_csv_ipv6_pos83(X,Y) get_csv_ipv6((X),(Y),83) +#define get_csv_string_pos83(X,Y) get_csv_string((X),(Y),83) +#define get_csv_v_str_pos83(X,Y) get_csv_string((X),(Y),83) +#define get_csv_bool_pos83(X,Y) get_csv_bool((X),(Y),83) +#define get_csv_int_pos83(X,Y) get_csv_int((X),(Y),83) +#define get_csv_llong_pos83(X,Y) get_csv_llong((X),(Y),83) +#define get_csv_float_pos83(X,Y) get_csv_float((X),(Y),83) +#define get_csv_uint_pos84(X,Y) get_csv_uint((X),(Y),84) +#define get_csv_ullong_pos84(X,Y) get_csv_ullong((X),(Y),84) +#define get_csv_ip_pos84(X,Y) get_csv_ip((X),(Y),84) +#define get_csv_ipv6_pos84(X,Y) get_csv_ipv6((X),(Y),84) +#define get_csv_string_pos84(X,Y) get_csv_string((X),(Y),84) +#define get_csv_v_str_pos84(X,Y) get_csv_string((X),(Y),84) +#define get_csv_bool_pos84(X,Y) get_csv_bool((X),(Y),84) +#define get_csv_int_pos84(X,Y) get_csv_int((X),(Y),84) +#define get_csv_llong_pos84(X,Y) get_csv_llong((X),(Y),84) +#define get_csv_float_pos84(X,Y) get_csv_float((X),(Y),84) +#define get_csv_uint_pos85(X,Y) get_csv_uint((X),(Y),85) +#define get_csv_ullong_pos85(X,Y) get_csv_ullong((X),(Y),85) +#define get_csv_ip_pos85(X,Y) get_csv_ip((X),(Y),85) +#define get_csv_ipv6_pos85(X,Y) get_csv_ipv6((X),(Y),85) +#define get_csv_string_pos85(X,Y) get_csv_string((X),(Y),85) +#define get_csv_v_str_pos85(X,Y) get_csv_string((X),(Y),85) +#define get_csv_bool_pos85(X,Y) get_csv_bool((X),(Y),85) +#define get_csv_int_pos85(X,Y) get_csv_int((X),(Y),85) +#define get_csv_llong_pos85(X,Y) get_csv_llong((X),(Y),85) +#define get_csv_float_pos85(X,Y) get_csv_float((X),(Y),85) +#define get_csv_uint_pos86(X,Y) get_csv_uint((X),(Y),86) +#define get_csv_ullong_pos86(X,Y) get_csv_ullong((X),(Y),86) +#define get_csv_ip_pos86(X,Y) get_csv_ip((X),(Y),86) +#define get_csv_ipv6_pos86(X,Y) get_csv_ipv6((X),(Y),86) +#define get_csv_string_pos86(X,Y) get_csv_string((X),(Y),86) +#define get_csv_v_str_pos86(X,Y) get_csv_string((X),(Y),86) +#define get_csv_bool_pos86(X,Y) get_csv_bool((X),(Y),86) +#define get_csv_int_pos86(X,Y) get_csv_int((X),(Y),86) +#define get_csv_llong_pos86(X,Y) get_csv_llong((X),(Y),86) +#define get_csv_float_pos86(X,Y) get_csv_float((X),(Y),86) +#define get_csv_uint_pos87(X,Y) get_csv_uint((X),(Y),87) +#define get_csv_ullong_pos87(X,Y) get_csv_ullong((X),(Y),87) +#define get_csv_ip_pos87(X,Y) get_csv_ip((X),(Y),87) +#define get_csv_ipv6_pos87(X,Y) get_csv_ipv6((X),(Y),87) +#define get_csv_string_pos87(X,Y) get_csv_string((X),(Y),87) +#define get_csv_v_str_pos87(X,Y) get_csv_string((X),(Y),87) +#define get_csv_bool_pos87(X,Y) get_csv_bool((X),(Y),87) +#define get_csv_int_pos87(X,Y) get_csv_int((X),(Y),87) +#define get_csv_llong_pos87(X,Y) get_csv_llong((X),(Y),87) +#define get_csv_float_pos87(X,Y) get_csv_float((X),(Y),87) +#define get_csv_uint_pos88(X,Y) get_csv_uint((X),(Y),88) +#define get_csv_ullong_pos88(X,Y) get_csv_ullong((X),(Y),88) +#define get_csv_ip_pos88(X,Y) get_csv_ip((X),(Y),88) +#define get_csv_ipv6_pos88(X,Y) get_csv_ipv6((X),(Y),88) +#define get_csv_string_pos88(X,Y) get_csv_string((X),(Y),88) +#define get_csv_v_str_pos88(X,Y) get_csv_string((X),(Y),88) +#define get_csv_bool_pos88(X,Y) get_csv_bool((X),(Y),88) +#define get_csv_int_pos88(X,Y) get_csv_int((X),(Y),88) +#define get_csv_llong_pos88(X,Y) get_csv_llong((X),(Y),88) +#define get_csv_float_pos88(X,Y) get_csv_float((X),(Y),88) +#define get_csv_uint_pos89(X,Y) get_csv_uint((X),(Y),89) +#define get_csv_ullong_pos89(X,Y) get_csv_ullong((X),(Y),89) +#define get_csv_ip_pos89(X,Y) get_csv_ip((X),(Y),89) +#define get_csv_ipv6_pos89(X,Y) get_csv_ipv6((X),(Y),89) +#define get_csv_string_pos89(X,Y) get_csv_string((X),(Y),89) +#define get_csv_v_str_pos89(X,Y) get_csv_string((X),(Y),89) +#define get_csv_bool_pos89(X,Y) get_csv_bool((X),(Y),89) +#define get_csv_int_pos89(X,Y) get_csv_int((X),(Y),89) +#define get_csv_llong_pos89(X,Y) get_csv_llong((X),(Y),89) +#define get_csv_float_pos89(X,Y) get_csv_float((X),(Y),89) +#define get_csv_uint_pos90(X,Y) get_csv_uint((X),(Y),90) +#define get_csv_ullong_pos90(X,Y) get_csv_ullong((X),(Y),90) +#define get_csv_ip_pos90(X,Y) get_csv_ip((X),(Y),90) +#define get_csv_ipv6_pos90(X,Y) get_csv_ipv6((X),(Y),90) +#define get_csv_string_pos90(X,Y) get_csv_string((X),(Y),90) +#define get_csv_v_str_pos90(X,Y) get_csv_string((X),(Y),90) +#define get_csv_bool_pos90(X,Y) get_csv_bool((X),(Y),90) +#define get_csv_int_pos90(X,Y) get_csv_int((X),(Y),90) +#define get_csv_llong_pos90(X,Y) get_csv_llong((X),(Y),90) +#define get_csv_float_pos90(X,Y) get_csv_float((X),(Y),90) +#define get_csv_uint_pos91(X,Y) get_csv_uint((X),(Y),91) +#define get_csv_ullong_pos91(X,Y) get_csv_ullong((X),(Y),91) +#define get_csv_ip_pos91(X,Y) get_csv_ip((X),(Y),91) +#define get_csv_ipv6_pos91(X,Y) get_csv_ipv6((X),(Y),91) +#define get_csv_string_pos91(X,Y) get_csv_string((X),(Y),91) +#define get_csv_v_str_pos91(X,Y) get_csv_string((X),(Y),91) +#define get_csv_bool_pos91(X,Y) get_csv_bool((X),(Y),91) +#define get_csv_int_pos91(X,Y) get_csv_int((X),(Y),91) +#define get_csv_llong_pos91(X,Y) get_csv_llong((X),(Y),91) +#define get_csv_float_pos91(X,Y) get_csv_float((X),(Y),91) +#define get_csv_uint_pos92(X,Y) get_csv_uint((X),(Y),92) +#define get_csv_ullong_pos92(X,Y) get_csv_ullong((X),(Y),92) +#define get_csv_ip_pos92(X,Y) get_csv_ip((X),(Y),92) +#define get_csv_ipv6_pos92(X,Y) get_csv_ipv6((X),(Y),92) +#define get_csv_string_pos92(X,Y) get_csv_string((X),(Y),92) +#define get_csv_v_str_pos92(X,Y) get_csv_string((X),(Y),92) +#define get_csv_bool_pos92(X,Y) get_csv_bool((X),(Y),92) +#define get_csv_int_pos92(X,Y) get_csv_int((X),(Y),92) +#define get_csv_llong_pos92(X,Y) get_csv_llong((X),(Y),92) +#define get_csv_float_pos92(X,Y) get_csv_float((X),(Y),92) +#define get_csv_uint_pos93(X,Y) get_csv_uint((X),(Y),93) +#define get_csv_ullong_pos93(X,Y) get_csv_ullong((X),(Y),93) +#define get_csv_ip_pos93(X,Y) get_csv_ip((X),(Y),93) +#define get_csv_ipv6_pos93(X,Y) get_csv_ipv6((X),(Y),93) +#define get_csv_string_pos93(X,Y) get_csv_string((X),(Y),93) +#define get_csv_v_str_pos93(X,Y) get_csv_string((X),(Y),93) +#define get_csv_bool_pos93(X,Y) get_csv_bool((X),(Y),93) +#define get_csv_int_pos93(X,Y) get_csv_int((X),(Y),93) +#define get_csv_llong_pos93(X,Y) get_csv_llong((X),(Y),93) +#define get_csv_float_pos93(X,Y) get_csv_float((X),(Y),93) +#define get_csv_uint_pos94(X,Y) get_csv_uint((X),(Y),94) +#define get_csv_ullong_pos94(X,Y) get_csv_ullong((X),(Y),94) +#define get_csv_ip_pos94(X,Y) get_csv_ip((X),(Y),94) +#define get_csv_ipv6_pos94(X,Y) get_csv_ipv6((X),(Y),94) +#define get_csv_string_pos94(X,Y) get_csv_string((X),(Y),94) +#define get_csv_v_str_pos94(X,Y) get_csv_string((X),(Y),94) +#define get_csv_bool_pos94(X,Y) get_csv_bool((X),(Y),94) +#define get_csv_int_pos94(X,Y) get_csv_int((X),(Y),94) +#define get_csv_llong_pos94(X,Y) get_csv_llong((X),(Y),94) +#define get_csv_float_pos94(X,Y) get_csv_float((X),(Y),94) +#define get_csv_uint_pos95(X,Y) get_csv_uint((X),(Y),95) +#define get_csv_ullong_pos95(X,Y) get_csv_ullong((X),(Y),95) +#define get_csv_ip_pos95(X,Y) get_csv_ip((X),(Y),95) +#define get_csv_ipv6_pos95(X,Y) get_csv_ipv6((X),(Y),95) +#define get_csv_string_pos95(X,Y) get_csv_string((X),(Y),95) +#define get_csv_v_str_pos95(X,Y) get_csv_string((X),(Y),95) +#define get_csv_bool_pos95(X,Y) get_csv_bool((X),(Y),95) +#define get_csv_int_pos95(X,Y) get_csv_int((X),(Y),95) +#define get_csv_llong_pos95(X,Y) get_csv_llong((X),(Y),95) +#define get_csv_float_pos95(X,Y) get_csv_float((X),(Y),95) +#define get_csv_uint_pos96(X,Y) get_csv_uint((X),(Y),96) +#define get_csv_ullong_pos96(X,Y) get_csv_ullong((X),(Y),96) +#define get_csv_ip_pos96(X,Y) get_csv_ip((X),(Y),96) +#define get_csv_ipv6_pos96(X,Y) get_csv_ipv6((X),(Y),96) +#define get_csv_string_pos96(X,Y) get_csv_string((X),(Y),96) +#define get_csv_v_str_pos96(X,Y) get_csv_string((X),(Y),96) +#define get_csv_bool_pos96(X,Y) get_csv_bool((X),(Y),96) +#define get_csv_int_pos96(X,Y) get_csv_int((X),(Y),96) +#define get_csv_llong_pos96(X,Y) get_csv_llong((X),(Y),96) +#define get_csv_float_pos96(X,Y) get_csv_float((X),(Y),96) +#define get_csv_uint_pos97(X,Y) get_csv_uint((X),(Y),97) +#define get_csv_ullong_pos97(X,Y) get_csv_ullong((X),(Y),97) +#define get_csv_ip_pos97(X,Y) get_csv_ip((X),(Y),97) +#define get_csv_ipv6_pos97(X,Y) get_csv_ipv6((X),(Y),97) +#define get_csv_string_pos97(X,Y) get_csv_string((X),(Y),97) +#define get_csv_v_str_pos97(X,Y) get_csv_string((X),(Y),97) +#define get_csv_bool_pos97(X,Y) get_csv_bool((X),(Y),97) +#define get_csv_int_pos97(X,Y) get_csv_int((X),(Y),97) +#define get_csv_llong_pos97(X,Y) get_csv_llong((X),(Y),97) +#define get_csv_float_pos97(X,Y) get_csv_float((X),(Y),97) +#define get_csv_uint_pos98(X,Y) get_csv_uint((X),(Y),98) +#define get_csv_ullong_pos98(X,Y) get_csv_ullong((X),(Y),98) +#define get_csv_ip_pos98(X,Y) get_csv_ip((X),(Y),98) +#define get_csv_ipv6_pos98(X,Y) get_csv_ipv6((X),(Y),98) +#define get_csv_string_pos98(X,Y) get_csv_string((X),(Y),98) +#define get_csv_v_str_pos98(X,Y) get_csv_string((X),(Y),98) +#define get_csv_bool_pos98(X,Y) get_csv_bool((X),(Y),98) +#define get_csv_int_pos98(X,Y) get_csv_int((X),(Y),98) +#define get_csv_llong_pos98(X,Y) get_csv_llong((X),(Y),98) +#define get_csv_float_pos98(X,Y) get_csv_float((X),(Y),98) +#define get_csv_uint_pos99(X,Y) get_csv_uint((X),(Y),99) +#define get_csv_ullong_pos99(X,Y) get_csv_ullong((X),(Y),99) +#define get_csv_ip_pos99(X,Y) get_csv_ip((X),(Y),99) +#define get_csv_ipv6_pos99(X,Y) get_csv_ipv6((X),(Y),99) +#define get_csv_string_pos99(X,Y) get_csv_string((X),(Y),99) +#define get_csv_v_str_pos99(X,Y) get_csv_string((X),(Y),99) +#define get_csv_bool_pos99(X,Y) get_csv_bool((X),(Y),99) +#define get_csv_int_pos99(X,Y) get_csv_int((X),(Y),99) +#define get_csv_llong_pos99(X,Y) get_csv_llong((X),(Y),99) +#define get_csv_float_pos99(X,Y) get_csv_float((X),(Y),99) +#define get_csv_uint_pos100(X,Y) get_csv_uint((X),(Y),100) +#define get_csv_ullong_pos100(X,Y) get_csv_ullong((X),(Y),100) +#define get_csv_ip_pos100(X,Y) get_csv_ip((X),(Y),100) +#define get_csv_ipv6_pos100(X,Y) get_csv_ipv6((X),(Y),100) +#define get_csv_string_pos100(X,Y) get_csv_string((X),(Y),100) +#define get_csv_v_str_pos100(X,Y) get_csv_string((X),(Y),100) +#define get_csv_bool_pos100(X,Y) get_csv_bool((X),(Y),100) +#define get_csv_int_pos100(X,Y) get_csv_int((X),(Y),100) +#define get_csv_llong_pos100(X,Y) get_csv_llong((X),(Y),100) +#define get_csv_float_pos100(X,Y) get_csv_float((X),(Y),100) +#define get_csv_uint_pos101(X,Y) get_csv_uint((X),(Y),101) +#define get_csv_ullong_pos101(X,Y) get_csv_ullong((X),(Y),101) +#define get_csv_ip_pos101(X,Y) get_csv_ip((X),(Y),101) +#define get_csv_ipv6_pos101(X,Y) get_csv_ipv6((X),(Y),101) +#define get_csv_string_pos101(X,Y) get_csv_string((X),(Y),101) +#define get_csv_v_str_pos101(X,Y) get_csv_string((X),(Y),101) +#define get_csv_bool_pos101(X,Y) get_csv_bool((X),(Y),101) +#define get_csv_int_pos101(X,Y) get_csv_int((X),(Y),101) +#define get_csv_llong_pos101(X,Y) get_csv_llong((X),(Y),101) +#define get_csv_float_pos101(X,Y) get_csv_float((X),(Y),101) +#define get_csv_uint_pos102(X,Y) get_csv_uint((X),(Y),102) +#define get_csv_ullong_pos102(X,Y) get_csv_ullong((X),(Y),102) +#define get_csv_ip_pos102(X,Y) get_csv_ip((X),(Y),102) +#define get_csv_ipv6_pos102(X,Y) get_csv_ipv6((X),(Y),102) +#define get_csv_string_pos102(X,Y) get_csv_string((X),(Y),102) +#define get_csv_v_str_pos102(X,Y) get_csv_string((X),(Y),102) +#define get_csv_bool_pos102(X,Y) get_csv_bool((X),(Y),102) +#define get_csv_int_pos102(X,Y) get_csv_int((X),(Y),102) +#define get_csv_llong_pos102(X,Y) get_csv_llong((X),(Y),102) +#define get_csv_float_pos102(X,Y) get_csv_float((X),(Y),102) +#define get_csv_uint_pos103(X,Y) get_csv_uint((X),(Y),103) +#define get_csv_ullong_pos103(X,Y) get_csv_ullong((X),(Y),103) +#define get_csv_ip_pos103(X,Y) get_csv_ip((X),(Y),103) +#define get_csv_ipv6_pos103(X,Y) get_csv_ipv6((X),(Y),103) +#define get_csv_string_pos103(X,Y) get_csv_string((X),(Y),103) +#define get_csv_v_str_pos103(X,Y) get_csv_string((X),(Y),103) +#define get_csv_bool_pos103(X,Y) get_csv_bool((X),(Y),103) +#define get_csv_int_pos103(X,Y) get_csv_int((X),(Y),103) +#define get_csv_llong_pos103(X,Y) get_csv_llong((X),(Y),103) +#define get_csv_float_pos103(X,Y) get_csv_float((X),(Y),103) +#define get_csv_uint_pos104(X,Y) get_csv_uint((X),(Y),104) +#define get_csv_ullong_pos104(X,Y) get_csv_ullong((X),(Y),104) +#define get_csv_ip_pos104(X,Y) get_csv_ip((X),(Y),104) +#define get_csv_ipv6_pos104(X,Y) get_csv_ipv6((X),(Y),104) +#define get_csv_string_pos104(X,Y) get_csv_string((X),(Y),104) +#define get_csv_v_str_pos104(X,Y) get_csv_string((X),(Y),104) +#define get_csv_bool_pos104(X,Y) get_csv_bool((X),(Y),104) +#define get_csv_int_pos104(X,Y) get_csv_int((X),(Y),104) +#define get_csv_llong_pos104(X,Y) get_csv_llong((X),(Y),104) +#define get_csv_float_pos104(X,Y) get_csv_float((X),(Y),104) +#define get_csv_uint_pos105(X,Y) get_csv_uint((X),(Y),105) +#define get_csv_ullong_pos105(X,Y) get_csv_ullong((X),(Y),105) +#define get_csv_ip_pos105(X,Y) get_csv_ip((X),(Y),105) +#define get_csv_ipv6_pos105(X,Y) get_csv_ipv6((X),(Y),105) +#define get_csv_string_pos105(X,Y) get_csv_string((X),(Y),105) +#define get_csv_v_str_pos105(X,Y) get_csv_string((X),(Y),105) +#define get_csv_bool_pos105(X,Y) get_csv_bool((X),(Y),105) +#define get_csv_int_pos105(X,Y) get_csv_int((X),(Y),105) +#define get_csv_llong_pos105(X,Y) get_csv_llong((X),(Y),105) +#define get_csv_float_pos105(X,Y) get_csv_float((X),(Y),105) +#define get_csv_uint_pos106(X,Y) get_csv_uint((X),(Y),106) +#define get_csv_ullong_pos106(X,Y) get_csv_ullong((X),(Y),106) +#define get_csv_ip_pos106(X,Y) get_csv_ip((X),(Y),106) +#define get_csv_ipv6_pos106(X,Y) get_csv_ipv6((X),(Y),106) +#define get_csv_string_pos106(X,Y) get_csv_string((X),(Y),106) +#define get_csv_v_str_pos106(X,Y) get_csv_string((X),(Y),106) +#define get_csv_bool_pos106(X,Y) get_csv_bool((X),(Y),106) +#define get_csv_int_pos106(X,Y) get_csv_int((X),(Y),106) +#define get_csv_llong_pos106(X,Y) get_csv_llong((X),(Y),106) +#define get_csv_float_pos106(X,Y) get_csv_float((X),(Y),106) +#define get_csv_uint_pos107(X,Y) get_csv_uint((X),(Y),107) +#define get_csv_ullong_pos107(X,Y) get_csv_ullong((X),(Y),107) +#define get_csv_ip_pos107(X,Y) get_csv_ip((X),(Y),107) +#define get_csv_ipv6_pos107(X,Y) get_csv_ipv6((X),(Y),107) +#define get_csv_string_pos107(X,Y) get_csv_string((X),(Y),107) +#define get_csv_v_str_pos107(X,Y) get_csv_string((X),(Y),107) +#define get_csv_bool_pos107(X,Y) get_csv_bool((X),(Y),107) +#define get_csv_int_pos107(X,Y) get_csv_int((X),(Y),107) +#define get_csv_llong_pos107(X,Y) get_csv_llong((X),(Y),107) +#define get_csv_float_pos107(X,Y) get_csv_float((X),(Y),107) +#define get_csv_uint_pos108(X,Y) get_csv_uint((X),(Y),108) +#define get_csv_ullong_pos108(X,Y) get_csv_ullong((X),(Y),108) +#define get_csv_ip_pos108(X,Y) get_csv_ip((X),(Y),108) +#define get_csv_ipv6_pos108(X,Y) get_csv_ipv6((X),(Y),108) +#define get_csv_string_pos108(X,Y) get_csv_string((X),(Y),108) +#define get_csv_v_str_pos108(X,Y) get_csv_string((X),(Y),108) +#define get_csv_bool_pos108(X,Y) get_csv_bool((X),(Y),108) +#define get_csv_int_pos108(X,Y) get_csv_int((X),(Y),108) +#define get_csv_llong_pos108(X,Y) get_csv_llong((X),(Y),108) +#define get_csv_float_pos108(X,Y) get_csv_float((X),(Y),108) +#define get_csv_uint_pos109(X,Y) get_csv_uint((X),(Y),109) +#define get_csv_ullong_pos109(X,Y) get_csv_ullong((X),(Y),109) +#define get_csv_ip_pos109(X,Y) get_csv_ip((X),(Y),109) +#define get_csv_ipv6_pos109(X,Y) get_csv_ipv6((X),(Y),109) +#define get_csv_string_pos109(X,Y) get_csv_string((X),(Y),109) +#define get_csv_v_str_pos109(X,Y) get_csv_string((X),(Y),109) +#define get_csv_bool_pos109(X,Y) get_csv_bool((X),(Y),109) +#define get_csv_int_pos109(X,Y) get_csv_int((X),(Y),109) +#define get_csv_llong_pos109(X,Y) get_csv_llong((X),(Y),109) +#define get_csv_float_pos109(X,Y) get_csv_float((X),(Y),109) +#define get_csv_uint_pos110(X,Y) get_csv_uint((X),(Y),110) +#define get_csv_ullong_pos110(X,Y) get_csv_ullong((X),(Y),110) +#define get_csv_ip_pos110(X,Y) get_csv_ip((X),(Y),110) +#define get_csv_ipv6_pos110(X,Y) get_csv_ipv6((X),(Y),110) +#define get_csv_string_pos110(X,Y) get_csv_string((X),(Y),110) +#define get_csv_v_str_pos110(X,Y) get_csv_string((X),(Y),110) +#define get_csv_bool_pos110(X,Y) get_csv_bool((X),(Y),110) +#define get_csv_int_pos110(X,Y) get_csv_int((X),(Y),110) +#define get_csv_llong_pos110(X,Y) get_csv_llong((X),(Y),110) +#define get_csv_float_pos110(X,Y) get_csv_float((X),(Y),110) +#define get_csv_uint_pos111(X,Y) get_csv_uint((X),(Y),111) +#define get_csv_ullong_pos111(X,Y) get_csv_ullong((X),(Y),111) +#define get_csv_ip_pos111(X,Y) get_csv_ip((X),(Y),111) +#define get_csv_ipv6_pos111(X,Y) get_csv_ipv6((X),(Y),111) +#define get_csv_string_pos111(X,Y) get_csv_string((X),(Y),111) +#define get_csv_v_str_pos111(X,Y) get_csv_string((X),(Y),111) +#define get_csv_bool_pos111(X,Y) get_csv_bool((X),(Y),111) +#define get_csv_int_pos111(X,Y) get_csv_int((X),(Y),111) +#define get_csv_llong_pos111(X,Y) get_csv_llong((X),(Y),111) +#define get_csv_float_pos111(X,Y) get_csv_float((X),(Y),111) +#define get_csv_uint_pos112(X,Y) get_csv_uint((X),(Y),112) +#define get_csv_ullong_pos112(X,Y) get_csv_ullong((X),(Y),112) +#define get_csv_ip_pos112(X,Y) get_csv_ip((X),(Y),112) +#define get_csv_ipv6_pos112(X,Y) get_csv_ipv6((X),(Y),112) +#define get_csv_string_pos112(X,Y) get_csv_string((X),(Y),112) +#define get_csv_v_str_pos112(X,Y) get_csv_string((X),(Y),112) +#define get_csv_bool_pos112(X,Y) get_csv_bool((X),(Y),112) +#define get_csv_int_pos112(X,Y) get_csv_int((X),(Y),112) +#define get_csv_llong_pos112(X,Y) get_csv_llong((X),(Y),112) +#define get_csv_float_pos112(X,Y) get_csv_float((X),(Y),112) +#define get_csv_uint_pos113(X,Y) get_csv_uint((X),(Y),113) +#define get_csv_ullong_pos113(X,Y) get_csv_ullong((X),(Y),113) +#define get_csv_ip_pos113(X,Y) get_csv_ip((X),(Y),113) +#define get_csv_ipv6_pos113(X,Y) get_csv_ipv6((X),(Y),113) +#define get_csv_string_pos113(X,Y) get_csv_string((X),(Y),113) +#define get_csv_v_str_pos113(X,Y) get_csv_string((X),(Y),113) +#define get_csv_bool_pos113(X,Y) get_csv_bool((X),(Y),113) +#define get_csv_int_pos113(X,Y) get_csv_int((X),(Y),113) +#define get_csv_llong_pos113(X,Y) get_csv_llong((X),(Y),113) +#define get_csv_float_pos113(X,Y) get_csv_float((X),(Y),113) +#define get_csv_uint_pos114(X,Y) get_csv_uint((X),(Y),114) +#define get_csv_ullong_pos114(X,Y) get_csv_ullong((X),(Y),114) +#define get_csv_ip_pos114(X,Y) get_csv_ip((X),(Y),114) +#define get_csv_ipv6_pos114(X,Y) get_csv_ipv6((X),(Y),114) +#define get_csv_string_pos114(X,Y) get_csv_string((X),(Y),114) +#define get_csv_v_str_pos114(X,Y) get_csv_string((X),(Y),114) +#define get_csv_bool_pos114(X,Y) get_csv_bool((X),(Y),114) +#define get_csv_int_pos114(X,Y) get_csv_int((X),(Y),114) +#define get_csv_llong_pos114(X,Y) get_csv_llong((X),(Y),114) +#define get_csv_float_pos114(X,Y) get_csv_float((X),(Y),114) +#define get_csv_uint_pos115(X,Y) get_csv_uint((X),(Y),115) +#define get_csv_ullong_pos115(X,Y) get_csv_ullong((X),(Y),115) +#define get_csv_ip_pos115(X,Y) get_csv_ip((X),(Y),115) +#define get_csv_ipv6_pos115(X,Y) get_csv_ipv6((X),(Y),115) +#define get_csv_string_pos115(X,Y) get_csv_string((X),(Y),115) +#define get_csv_v_str_pos115(X,Y) get_csv_string((X),(Y),115) +#define get_csv_bool_pos115(X,Y) get_csv_bool((X),(Y),115) +#define get_csv_int_pos115(X,Y) get_csv_int((X),(Y),115) +#define get_csv_llong_pos115(X,Y) get_csv_llong((X),(Y),115) +#define get_csv_float_pos115(X,Y) get_csv_float((X),(Y),115) +#define get_csv_uint_pos116(X,Y) get_csv_uint((X),(Y),116) +#define get_csv_ullong_pos116(X,Y) get_csv_ullong((X),(Y),116) +#define get_csv_ip_pos116(X,Y) get_csv_ip((X),(Y),116) +#define get_csv_ipv6_pos116(X,Y) get_csv_ipv6((X),(Y),116) +#define get_csv_string_pos116(X,Y) get_csv_string((X),(Y),116) +#define get_csv_v_str_pos116(X,Y) get_csv_string((X),(Y),116) +#define get_csv_bool_pos116(X,Y) get_csv_bool((X),(Y),116) +#define get_csv_int_pos116(X,Y) get_csv_int((X),(Y),116) +#define get_csv_llong_pos116(X,Y) get_csv_llong((X),(Y),116) +#define get_csv_float_pos116(X,Y) get_csv_float((X),(Y),116) +#define get_csv_uint_pos117(X,Y) get_csv_uint((X),(Y),117) +#define get_csv_ullong_pos117(X,Y) get_csv_ullong((X),(Y),117) +#define get_csv_ip_pos117(X,Y) get_csv_ip((X),(Y),117) +#define get_csv_ipv6_pos117(X,Y) get_csv_ipv6((X),(Y),117) +#define get_csv_string_pos117(X,Y) get_csv_string((X),(Y),117) +#define get_csv_v_str_pos117(X,Y) get_csv_string((X),(Y),117) +#define get_csv_bool_pos117(X,Y) get_csv_bool((X),(Y),117) +#define get_csv_int_pos117(X,Y) get_csv_int((X),(Y),117) +#define get_csv_llong_pos117(X,Y) get_csv_llong((X),(Y),117) +#define get_csv_float_pos117(X,Y) get_csv_float((X),(Y),117) +#define get_csv_uint_pos118(X,Y) get_csv_uint((X),(Y),118) +#define get_csv_ullong_pos118(X,Y) get_csv_ullong((X),(Y),118) +#define get_csv_ip_pos118(X,Y) get_csv_ip((X),(Y),118) +#define get_csv_ipv6_pos118(X,Y) get_csv_ipv6((X),(Y),118) +#define get_csv_string_pos118(X,Y) get_csv_string((X),(Y),118) +#define get_csv_v_str_pos118(X,Y) get_csv_string((X),(Y),118) +#define get_csv_bool_pos118(X,Y) get_csv_bool((X),(Y),118) +#define get_csv_int_pos118(X,Y) get_csv_int((X),(Y),118) +#define get_csv_llong_pos118(X,Y) get_csv_llong((X),(Y),118) +#define get_csv_float_pos118(X,Y) get_csv_float((X),(Y),118) +#define get_csv_uint_pos119(X,Y) get_csv_uint((X),(Y),119) +#define get_csv_ullong_pos119(X,Y) get_csv_ullong((X),(Y),119) +#define get_csv_ip_pos119(X,Y) get_csv_ip((X),(Y),119) +#define get_csv_ipv6_pos119(X,Y) get_csv_ipv6((X),(Y),119) +#define get_csv_string_pos119(X,Y) get_csv_string((X),(Y),119) +#define get_csv_v_str_pos119(X,Y) get_csv_string((X),(Y),119) +#define get_csv_bool_pos119(X,Y) get_csv_bool((X),(Y),119) +#define get_csv_int_pos119(X,Y) get_csv_int((X),(Y),119) +#define get_csv_llong_pos119(X,Y) get_csv_llong((X),(Y),119) +#define get_csv_float_pos119(X,Y) get_csv_float((X),(Y),119) +#define get_csv_uint_pos120(X,Y) get_csv_uint((X),(Y),120) +#define get_csv_ullong_pos120(X,Y) get_csv_ullong((X),(Y),120) +#define get_csv_ip_pos120(X,Y) get_csv_ip((X),(Y),120) +#define get_csv_ipv6_pos120(X,Y) get_csv_ipv6((X),(Y),120) +#define get_csv_string_pos120(X,Y) get_csv_string((X),(Y),120) +#define get_csv_v_str_pos120(X,Y) get_csv_string((X),(Y),120) +#define get_csv_bool_pos120(X,Y) get_csv_bool((X),(Y),120) +#define get_csv_int_pos120(X,Y) get_csv_int((X),(Y),120) +#define get_csv_llong_pos120(X,Y) get_csv_llong((X),(Y),120) +#define get_csv_float_pos120(X,Y) get_csv_float((X),(Y),120) +#define get_csv_uint_pos121(X,Y) get_csv_uint((X),(Y),121) +#define get_csv_ullong_pos121(X,Y) get_csv_ullong((X),(Y),121) +#define get_csv_ip_pos121(X,Y) get_csv_ip((X),(Y),121) +#define get_csv_ipv6_pos121(X,Y) get_csv_ipv6((X),(Y),121) +#define get_csv_string_pos121(X,Y) get_csv_string((X),(Y),121) +#define get_csv_v_str_pos121(X,Y) get_csv_string((X),(Y),121) +#define get_csv_bool_pos121(X,Y) get_csv_bool((X),(Y),121) +#define get_csv_int_pos121(X,Y) get_csv_int((X),(Y),121) +#define get_csv_llong_pos121(X,Y) get_csv_llong((X),(Y),121) +#define get_csv_float_pos121(X,Y) get_csv_float((X),(Y),121) +#define get_csv_uint_pos122(X,Y) get_csv_uint((X),(Y),122) +#define get_csv_ullong_pos122(X,Y) get_csv_ullong((X),(Y),122) +#define get_csv_ip_pos122(X,Y) get_csv_ip((X),(Y),122) +#define get_csv_ipv6_pos122(X,Y) get_csv_ipv6((X),(Y),122) +#define get_csv_string_pos122(X,Y) get_csv_string((X),(Y),122) +#define get_csv_v_str_pos122(X,Y) get_csv_string((X),(Y),122) +#define get_csv_bool_pos122(X,Y) get_csv_bool((X),(Y),122) +#define get_csv_int_pos122(X,Y) get_csv_int((X),(Y),122) +#define get_csv_llong_pos122(X,Y) get_csv_llong((X),(Y),122) +#define get_csv_float_pos122(X,Y) get_csv_float((X),(Y),122) +#define get_csv_uint_pos123(X,Y) get_csv_uint((X),(Y),123) +#define get_csv_ullong_pos123(X,Y) get_csv_ullong((X),(Y),123) +#define get_csv_ip_pos123(X,Y) get_csv_ip((X),(Y),123) +#define get_csv_ipv6_pos123(X,Y) get_csv_ipv6((X),(Y),123) +#define get_csv_string_pos123(X,Y) get_csv_string((X),(Y),123) +#define get_csv_v_str_pos123(X,Y) get_csv_string((X),(Y),123) +#define get_csv_bool_pos123(X,Y) get_csv_bool((X),(Y),123) +#define get_csv_int_pos123(X,Y) get_csv_int((X),(Y),123) +#define get_csv_llong_pos123(X,Y) get_csv_llong((X),(Y),123) +#define get_csv_float_pos123(X,Y) get_csv_float((X),(Y),123) +#define get_csv_uint_pos124(X,Y) get_csv_uint((X),(Y),124) +#define get_csv_ullong_pos124(X,Y) get_csv_ullong((X),(Y),124) +#define get_csv_ip_pos124(X,Y) get_csv_ip((X),(Y),124) +#define get_csv_ipv6_pos124(X,Y) get_csv_ipv6((X),(Y),124) +#define get_csv_string_pos124(X,Y) get_csv_string((X),(Y),124) +#define get_csv_v_str_pos124(X,Y) get_csv_string((X),(Y),124) +#define get_csv_bool_pos124(X,Y) get_csv_bool((X),(Y),124) +#define get_csv_int_pos124(X,Y) get_csv_int((X),(Y),124) +#define get_csv_llong_pos124(X,Y) get_csv_llong((X),(Y),124) +#define get_csv_float_pos124(X,Y) get_csv_float((X),(Y),124) +#define get_csv_uint_pos125(X,Y) get_csv_uint((X),(Y),125) +#define get_csv_ullong_pos125(X,Y) get_csv_ullong((X),(Y),125) +#define get_csv_ip_pos125(X,Y) get_csv_ip((X),(Y),125) +#define get_csv_ipv6_pos125(X,Y) get_csv_ipv6((X),(Y),125) +#define get_csv_string_pos125(X,Y) get_csv_string((X),(Y),125) +#define get_csv_v_str_pos125(X,Y) get_csv_string((X),(Y),125) +#define get_csv_bool_pos125(X,Y) get_csv_bool((X),(Y),125) +#define get_csv_int_pos125(X,Y) get_csv_int((X),(Y),125) +#define get_csv_llong_pos125(X,Y) get_csv_llong((X),(Y),125) +#define get_csv_float_pos125(X,Y) get_csv_float((X),(Y),125) +#define get_csv_uint_pos126(X,Y) get_csv_uint((X),(Y),126) +#define get_csv_ullong_pos126(X,Y) get_csv_ullong((X),(Y),126) +#define get_csv_ip_pos126(X,Y) get_csv_ip((X),(Y),126) +#define get_csv_ipv6_pos126(X,Y) get_csv_ipv6((X),(Y),126) +#define get_csv_string_pos126(X,Y) get_csv_string((X),(Y),126) +#define get_csv_v_str_pos126(X,Y) get_csv_string((X),(Y),126) +#define get_csv_bool_pos126(X,Y) get_csv_bool((X),(Y),126) +#define get_csv_int_pos126(X,Y) get_csv_int((X),(Y),126) +#define get_csv_llong_pos126(X,Y) get_csv_llong((X),(Y),126) +#define get_csv_float_pos126(X,Y) get_csv_float((X),(Y),126) +#define get_csv_uint_pos127(X,Y) get_csv_uint((X),(Y),127) +#define get_csv_ullong_pos127(X,Y) get_csv_ullong((X),(Y),127) +#define get_csv_ip_pos127(X,Y) get_csv_ip((X),(Y),127) +#define get_csv_ipv6_pos127(X,Y) get_csv_ipv6((X),(Y),127) +#define get_csv_string_pos127(X,Y) get_csv_string((X),(Y),127) +#define get_csv_v_str_pos127(X,Y) get_csv_string((X),(Y),127) +#define get_csv_bool_pos127(X,Y) get_csv_bool((X),(Y),127) +#define get_csv_int_pos127(X,Y) get_csv_int((X),(Y),127) +#define get_csv_llong_pos127(X,Y) get_csv_llong((X),(Y),127) +#define get_csv_float_pos127(X,Y) get_csv_float((X),(Y),127) +#define get_csv_uint_pos128(X,Y) get_csv_uint((X),(Y),128) +#define get_csv_ullong_pos128(X,Y) get_csv_ullong((X),(Y),128) +#define get_csv_ip_pos128(X,Y) get_csv_ip((X),(Y),128) +#define get_csv_ipv6_pos128(X,Y) get_csv_ipv6((X),(Y),128) +#define get_csv_string_pos128(X,Y) get_csv_string((X),(Y),128) +#define get_csv_v_str_pos128(X,Y) get_csv_string((X),(Y),128) +#define get_csv_bool_pos128(X,Y) get_csv_bool((X),(Y),128) +#define get_csv_int_pos128(X,Y) get_csv_int((X),(Y),128) +#define get_csv_llong_pos128(X,Y) get_csv_llong((X),(Y),128) +#define get_csv_float_pos128(X,Y) get_csv_float((X),(Y),128) +#define get_csv_uint_pos129(X,Y) get_csv_uint((X),(Y),129) +#define get_csv_ullong_pos129(X,Y) get_csv_ullong((X),(Y),129) +#define get_csv_ip_pos129(X,Y) get_csv_ip((X),(Y),129) +#define get_csv_ipv6_pos129(X,Y) get_csv_ipv6((X),(Y),129) +#define get_csv_string_pos129(X,Y) get_csv_string((X),(Y),129) +#define get_csv_v_str_pos129(X,Y) get_csv_string((X),(Y),129) +#define get_csv_bool_pos129(X,Y) get_csv_bool((X),(Y),129) +#define get_csv_int_pos129(X,Y) get_csv_int((X),(Y),129) +#define get_csv_llong_pos129(X,Y) get_csv_llong((X),(Y),129) +#define get_csv_float_pos129(X,Y) get_csv_float((X),(Y),129) +#define get_csv_uint_pos130(X,Y) get_csv_uint((X),(Y),130) +#define get_csv_ullong_pos130(X,Y) get_csv_ullong((X),(Y),130) +#define get_csv_ip_pos130(X,Y) get_csv_ip((X),(Y),130) +#define get_csv_ipv6_pos130(X,Y) get_csv_ipv6((X),(Y),130) +#define get_csv_string_pos130(X,Y) get_csv_string((X),(Y),130) +#define get_csv_v_str_pos130(X,Y) get_csv_string((X),(Y),130) +#define get_csv_bool_pos130(X,Y) get_csv_bool((X),(Y),130) +#define get_csv_int_pos130(X,Y) get_csv_int((X),(Y),130) +#define get_csv_llong_pos130(X,Y) get_csv_llong((X),(Y),130) +#define get_csv_float_pos130(X,Y) get_csv_float((X),(Y),130) +#define get_csv_uint_pos131(X,Y) get_csv_uint((X),(Y),131) +#define get_csv_ullong_pos131(X,Y) get_csv_ullong((X),(Y),131) +#define get_csv_ip_pos131(X,Y) get_csv_ip((X),(Y),131) +#define get_csv_ipv6_pos131(X,Y) get_csv_ipv6((X),(Y),131) +#define get_csv_string_pos131(X,Y) get_csv_string((X),(Y),131) +#define get_csv_v_str_pos131(X,Y) get_csv_string((X),(Y),131) +#define get_csv_bool_pos131(X,Y) get_csv_bool((X),(Y),131) +#define get_csv_int_pos131(X,Y) get_csv_int((X),(Y),131) +#define get_csv_llong_pos131(X,Y) get_csv_llong((X),(Y),131) +#define get_csv_float_pos131(X,Y) get_csv_float((X),(Y),131) +#define get_csv_uint_pos132(X,Y) get_csv_uint((X),(Y),132) +#define get_csv_ullong_pos132(X,Y) get_csv_ullong((X),(Y),132) +#define get_csv_ip_pos132(X,Y) get_csv_ip((X),(Y),132) +#define get_csv_ipv6_pos132(X,Y) get_csv_ipv6((X),(Y),132) +#define get_csv_string_pos132(X,Y) get_csv_string((X),(Y),132) +#define get_csv_v_str_pos132(X,Y) get_csv_string((X),(Y),132) +#define get_csv_bool_pos132(X,Y) get_csv_bool((X),(Y),132) +#define get_csv_int_pos132(X,Y) get_csv_int((X),(Y),132) +#define get_csv_llong_pos132(X,Y) get_csv_llong((X),(Y),132) +#define get_csv_float_pos132(X,Y) get_csv_float((X),(Y),132) +#define get_csv_uint_pos133(X,Y) get_csv_uint((X),(Y),133) +#define get_csv_ullong_pos133(X,Y) get_csv_ullong((X),(Y),133) +#define get_csv_ip_pos133(X,Y) get_csv_ip((X),(Y),133) +#define get_csv_ipv6_pos133(X,Y) get_csv_ipv6((X),(Y),133) +#define get_csv_string_pos133(X,Y) get_csv_string((X),(Y),133) +#define get_csv_v_str_pos133(X,Y) get_csv_string((X),(Y),133) +#define get_csv_bool_pos133(X,Y) get_csv_bool((X),(Y),133) +#define get_csv_int_pos133(X,Y) get_csv_int((X),(Y),133) +#define get_csv_llong_pos133(X,Y) get_csv_llong((X),(Y),133) +#define get_csv_float_pos133(X,Y) get_csv_float((X),(Y),133) +#define get_csv_uint_pos134(X,Y) get_csv_uint((X),(Y),134) +#define get_csv_ullong_pos134(X,Y) get_csv_ullong((X),(Y),134) +#define get_csv_ip_pos134(X,Y) get_csv_ip((X),(Y),134) +#define get_csv_ipv6_pos134(X,Y) get_csv_ipv6((X),(Y),134) +#define get_csv_string_pos134(X,Y) get_csv_string((X),(Y),134) +#define get_csv_v_str_pos134(X,Y) get_csv_string((X),(Y),134) +#define get_csv_bool_pos134(X,Y) get_csv_bool((X),(Y),134) +#define get_csv_int_pos134(X,Y) get_csv_int((X),(Y),134) +#define get_csv_llong_pos134(X,Y) get_csv_llong((X),(Y),134) +#define get_csv_float_pos134(X,Y) get_csv_float((X),(Y),134) +#define get_csv_uint_pos135(X,Y) get_csv_uint((X),(Y),135) +#define get_csv_ullong_pos135(X,Y) get_csv_ullong((X),(Y),135) +#define get_csv_ip_pos135(X,Y) get_csv_ip((X),(Y),135) +#define get_csv_ipv6_pos135(X,Y) get_csv_ipv6((X),(Y),135) +#define get_csv_string_pos135(X,Y) get_csv_string((X),(Y),135) +#define get_csv_v_str_pos135(X,Y) get_csv_string((X),(Y),135) +#define get_csv_bool_pos135(X,Y) get_csv_bool((X),(Y),135) +#define get_csv_int_pos135(X,Y) get_csv_int((X),(Y),135) +#define get_csv_llong_pos135(X,Y) get_csv_llong((X),(Y),135) +#define get_csv_float_pos135(X,Y) get_csv_float((X),(Y),135) +#define get_csv_uint_pos136(X,Y) get_csv_uint((X),(Y),136) +#define get_csv_ullong_pos136(X,Y) get_csv_ullong((X),(Y),136) +#define get_csv_ip_pos136(X,Y) get_csv_ip((X),(Y),136) +#define get_csv_ipv6_pos136(X,Y) get_csv_ipv6((X),(Y),136) +#define get_csv_string_pos136(X,Y) get_csv_string((X),(Y),136) +#define get_csv_v_str_pos136(X,Y) get_csv_string((X),(Y),136) +#define get_csv_bool_pos136(X,Y) get_csv_bool((X),(Y),136) +#define get_csv_int_pos136(X,Y) get_csv_int((X),(Y),136) +#define get_csv_llong_pos136(X,Y) get_csv_llong((X),(Y),136) +#define get_csv_float_pos136(X,Y) get_csv_float((X),(Y),136) +#define get_csv_uint_pos137(X,Y) get_csv_uint((X),(Y),137) +#define get_csv_ullong_pos137(X,Y) get_csv_ullong((X),(Y),137) +#define get_csv_ip_pos137(X,Y) get_csv_ip((X),(Y),137) +#define get_csv_ipv6_pos137(X,Y) get_csv_ipv6((X),(Y),137) +#define get_csv_string_pos137(X,Y) get_csv_string((X),(Y),137) +#define get_csv_v_str_pos137(X,Y) get_csv_string((X),(Y),137) +#define get_csv_bool_pos137(X,Y) get_csv_bool((X),(Y),137) +#define get_csv_int_pos137(X,Y) get_csv_int((X),(Y),137) +#define get_csv_llong_pos137(X,Y) get_csv_llong((X),(Y),137) +#define get_csv_float_pos137(X,Y) get_csv_float((X),(Y),137) +#define get_csv_uint_pos138(X,Y) get_csv_uint((X),(Y),138) +#define get_csv_ullong_pos138(X,Y) get_csv_ullong((X),(Y),138) +#define get_csv_ip_pos138(X,Y) get_csv_ip((X),(Y),138) +#define get_csv_ipv6_pos138(X,Y) get_csv_ipv6((X),(Y),138) +#define get_csv_string_pos138(X,Y) get_csv_string((X),(Y),138) +#define get_csv_v_str_pos138(X,Y) get_csv_string((X),(Y),138) +#define get_csv_bool_pos138(X,Y) get_csv_bool((X),(Y),138) +#define get_csv_int_pos138(X,Y) get_csv_int((X),(Y),138) +#define get_csv_llong_pos138(X,Y) get_csv_llong((X),(Y),138) +#define get_csv_float_pos138(X,Y) get_csv_float((X),(Y),138) +#define get_csv_uint_pos139(X,Y) get_csv_uint((X),(Y),139) +#define get_csv_ullong_pos139(X,Y) get_csv_ullong((X),(Y),139) +#define get_csv_ip_pos139(X,Y) get_csv_ip((X),(Y),139) +#define get_csv_ipv6_pos139(X,Y) get_csv_ipv6((X),(Y),139) +#define get_csv_string_pos139(X,Y) get_csv_string((X),(Y),139) +#define get_csv_v_str_pos139(X,Y) get_csv_string((X),(Y),139) +#define get_csv_bool_pos139(X,Y) get_csv_bool((X),(Y),139) +#define get_csv_int_pos139(X,Y) get_csv_int((X),(Y),139) +#define get_csv_llong_pos139(X,Y) get_csv_llong((X),(Y),139) +#define get_csv_float_pos139(X,Y) get_csv_float((X),(Y),139) +#define get_csv_uint_pos140(X,Y) get_csv_uint((X),(Y),140) +#define get_csv_ullong_pos140(X,Y) get_csv_ullong((X),(Y),140) +#define get_csv_ip_pos140(X,Y) get_csv_ip((X),(Y),140) +#define get_csv_ipv6_pos140(X,Y) get_csv_ipv6((X),(Y),140) +#define get_csv_string_pos140(X,Y) get_csv_string((X),(Y),140) +#define get_csv_v_str_pos140(X,Y) get_csv_string((X),(Y),140) +#define get_csv_bool_pos140(X,Y) get_csv_bool((X),(Y),140) +#define get_csv_int_pos140(X,Y) get_csv_int((X),(Y),140) +#define get_csv_llong_pos140(X,Y) get_csv_llong((X),(Y),140) +#define get_csv_float_pos140(X,Y) get_csv_float((X),(Y),140) +#define get_csv_uint_pos141(X,Y) get_csv_uint((X),(Y),141) +#define get_csv_ullong_pos141(X,Y) get_csv_ullong((X),(Y),141) +#define get_csv_ip_pos141(X,Y) get_csv_ip((X),(Y),141) +#define get_csv_ipv6_pos141(X,Y) get_csv_ipv6((X),(Y),141) +#define get_csv_string_pos141(X,Y) get_csv_string((X),(Y),141) +#define get_csv_v_str_pos141(X,Y) get_csv_string((X),(Y),141) +#define get_csv_bool_pos141(X,Y) get_csv_bool((X),(Y),141) +#define get_csv_int_pos141(X,Y) get_csv_int((X),(Y),141) +#define get_csv_llong_pos141(X,Y) get_csv_llong((X),(Y),141) +#define get_csv_float_pos141(X,Y) get_csv_float((X),(Y),141) +#define get_csv_uint_pos142(X,Y) get_csv_uint((X),(Y),142) +#define get_csv_ullong_pos142(X,Y) get_csv_ullong((X),(Y),142) +#define get_csv_ip_pos142(X,Y) get_csv_ip((X),(Y),142) +#define get_csv_ipv6_pos142(X,Y) get_csv_ipv6((X),(Y),142) +#define get_csv_string_pos142(X,Y) get_csv_string((X),(Y),142) +#define get_csv_v_str_pos142(X,Y) get_csv_string((X),(Y),142) +#define get_csv_bool_pos142(X,Y) get_csv_bool((X),(Y),142) +#define get_csv_int_pos142(X,Y) get_csv_int((X),(Y),142) +#define get_csv_llong_pos142(X,Y) get_csv_llong((X),(Y),142) +#define get_csv_float_pos142(X,Y) get_csv_float((X),(Y),142) +#define get_csv_uint_pos143(X,Y) get_csv_uint((X),(Y),143) +#define get_csv_ullong_pos143(X,Y) get_csv_ullong((X),(Y),143) +#define get_csv_ip_pos143(X,Y) get_csv_ip((X),(Y),143) +#define get_csv_ipv6_pos143(X,Y) get_csv_ipv6((X),(Y),143) +#define get_csv_string_pos143(X,Y) get_csv_string((X),(Y),143) +#define get_csv_v_str_pos143(X,Y) get_csv_string((X),(Y),143) +#define get_csv_bool_pos143(X,Y) get_csv_bool((X),(Y),143) +#define get_csv_int_pos143(X,Y) get_csv_int((X),(Y),143) +#define get_csv_llong_pos143(X,Y) get_csv_llong((X),(Y),143) +#define get_csv_float_pos143(X,Y) get_csv_float((X),(Y),143) +#define get_csv_uint_pos144(X,Y) get_csv_uint((X),(Y),144) +#define get_csv_ullong_pos144(X,Y) get_csv_ullong((X),(Y),144) +#define get_csv_ip_pos144(X,Y) get_csv_ip((X),(Y),144) +#define get_csv_ipv6_pos144(X,Y) get_csv_ipv6((X),(Y),144) +#define get_csv_string_pos144(X,Y) get_csv_string((X),(Y),144) +#define get_csv_v_str_pos144(X,Y) get_csv_string((X),(Y),144) +#define get_csv_bool_pos144(X,Y) get_csv_bool((X),(Y),144) +#define get_csv_int_pos144(X,Y) get_csv_int((X),(Y),144) +#define get_csv_llong_pos144(X,Y) get_csv_llong((X),(Y),144) +#define get_csv_float_pos144(X,Y) get_csv_float((X),(Y),144) +#define get_csv_uint_pos145(X,Y) get_csv_uint((X),(Y),145) +#define get_csv_ullong_pos145(X,Y) get_csv_ullong((X),(Y),145) +#define get_csv_ip_pos145(X,Y) get_csv_ip((X),(Y),145) +#define get_csv_ipv6_pos145(X,Y) get_csv_ipv6((X),(Y),145) +#define get_csv_string_pos145(X,Y) get_csv_string((X),(Y),145) +#define get_csv_v_str_pos145(X,Y) get_csv_string((X),(Y),145) +#define get_csv_bool_pos145(X,Y) get_csv_bool((X),(Y),145) +#define get_csv_int_pos145(X,Y) get_csv_int((X),(Y),145) +#define get_csv_llong_pos145(X,Y) get_csv_llong((X),(Y),145) +#define get_csv_float_pos145(X,Y) get_csv_float((X),(Y),145) +#define get_csv_uint_pos146(X,Y) get_csv_uint((X),(Y),146) +#define get_csv_ullong_pos146(X,Y) get_csv_ullong((X),(Y),146) +#define get_csv_ip_pos146(X,Y) get_csv_ip((X),(Y),146) +#define get_csv_ipv6_pos146(X,Y) get_csv_ipv6((X),(Y),146) +#define get_csv_string_pos146(X,Y) get_csv_string((X),(Y),146) +#define get_csv_v_str_pos146(X,Y) get_csv_string((X),(Y),146) +#define get_csv_bool_pos146(X,Y) get_csv_bool((X),(Y),146) +#define get_csv_int_pos146(X,Y) get_csv_int((X),(Y),146) +#define get_csv_llong_pos146(X,Y) get_csv_llong((X),(Y),146) +#define get_csv_float_pos146(X,Y) get_csv_float((X),(Y),146) +#define get_csv_uint_pos147(X,Y) get_csv_uint((X),(Y),147) +#define get_csv_ullong_pos147(X,Y) get_csv_ullong((X),(Y),147) +#define get_csv_ip_pos147(X,Y) get_csv_ip((X),(Y),147) +#define get_csv_ipv6_pos147(X,Y) get_csv_ipv6((X),(Y),147) +#define get_csv_string_pos147(X,Y) get_csv_string((X),(Y),147) +#define get_csv_v_str_pos147(X,Y) get_csv_string((X),(Y),147) +#define get_csv_bool_pos147(X,Y) get_csv_bool((X),(Y),147) +#define get_csv_int_pos147(X,Y) get_csv_int((X),(Y),147) +#define get_csv_llong_pos147(X,Y) get_csv_llong((X),(Y),147) +#define get_csv_float_pos147(X,Y) get_csv_float((X),(Y),147) +#define get_csv_uint_pos148(X,Y) get_csv_uint((X),(Y),148) +#define get_csv_ullong_pos148(X,Y) get_csv_ullong((X),(Y),148) +#define get_csv_ip_pos148(X,Y) get_csv_ip((X),(Y),148) +#define get_csv_ipv6_pos148(X,Y) get_csv_ipv6((X),(Y),148) +#define get_csv_string_pos148(X,Y) get_csv_string((X),(Y),148) +#define get_csv_v_str_pos148(X,Y) get_csv_string((X),(Y),148) +#define get_csv_bool_pos148(X,Y) get_csv_bool((X),(Y),148) +#define get_csv_int_pos148(X,Y) get_csv_int((X),(Y),148) +#define get_csv_llong_pos148(X,Y) get_csv_llong((X),(Y),148) +#define get_csv_float_pos148(X,Y) get_csv_float((X),(Y),148) +#define get_csv_uint_pos149(X,Y) get_csv_uint((X),(Y),149) +#define get_csv_ullong_pos149(X,Y) get_csv_ullong((X),(Y),149) +#define get_csv_ip_pos149(X,Y) get_csv_ip((X),(Y),149) +#define get_csv_ipv6_pos149(X,Y) get_csv_ipv6((X),(Y),149) +#define get_csv_string_pos149(X,Y) get_csv_string((X),(Y),149) +#define get_csv_v_str_pos149(X,Y) get_csv_string((X),(Y),149) +#define get_csv_bool_pos149(X,Y) get_csv_bool((X),(Y),149) +#define get_csv_int_pos149(X,Y) get_csv_int((X),(Y),149) +#define get_csv_llong_pos149(X,Y) get_csv_llong((X),(Y),149) +#define get_csv_float_pos149(X,Y) get_csv_float((X),(Y),149) +#define get_csv_uint_pos150(X,Y) get_csv_uint((X),(Y),150) +#define get_csv_ullong_pos150(X,Y) get_csv_ullong((X),(Y),150) +#define get_csv_ip_pos150(X,Y) get_csv_ip((X),(Y),150) +#define get_csv_ipv6_pos150(X,Y) get_csv_ipv6((X),(Y),150) +#define get_csv_string_pos150(X,Y) get_csv_string((X),(Y),150) +#define get_csv_v_str_pos150(X,Y) get_csv_string((X),(Y),150) +#define get_csv_bool_pos150(X,Y) get_csv_bool((X),(Y),150) +#define get_csv_int_pos150(X,Y) get_csv_int((X),(Y),150) +#define get_csv_llong_pos150(X,Y) get_csv_llong((X),(Y),150) +#define get_csv_float_pos150(X,Y) get_csv_float((X),(Y),150) +#define get_csv_uint_pos151(X,Y) get_csv_uint((X),(Y),151) +#define get_csv_ullong_pos151(X,Y) get_csv_ullong((X),(Y),151) +#define get_csv_ip_pos151(X,Y) get_csv_ip((X),(Y),151) +#define get_csv_ipv6_pos151(X,Y) get_csv_ipv6((X),(Y),151) +#define get_csv_string_pos151(X,Y) get_csv_string((X),(Y),151) +#define get_csv_v_str_pos151(X,Y) get_csv_string((X),(Y),151) +#define get_csv_bool_pos151(X,Y) get_csv_bool((X),(Y),151) +#define get_csv_int_pos151(X,Y) get_csv_int((X),(Y),151) +#define get_csv_llong_pos151(X,Y) get_csv_llong((X),(Y),151) +#define get_csv_float_pos151(X,Y) get_csv_float((X),(Y),151) +#define get_csv_uint_pos152(X,Y) get_csv_uint((X),(Y),152) +#define get_csv_ullong_pos152(X,Y) get_csv_ullong((X),(Y),152) +#define get_csv_ip_pos152(X,Y) get_csv_ip((X),(Y),152) +#define get_csv_ipv6_pos152(X,Y) get_csv_ipv6((X),(Y),152) +#define get_csv_string_pos152(X,Y) get_csv_string((X),(Y),152) +#define get_csv_v_str_pos152(X,Y) get_csv_string((X),(Y),152) +#define get_csv_bool_pos152(X,Y) get_csv_bool((X),(Y),152) +#define get_csv_int_pos152(X,Y) get_csv_int((X),(Y),152) +#define get_csv_llong_pos152(X,Y) get_csv_llong((X),(Y),152) +#define get_csv_float_pos152(X,Y) get_csv_float((X),(Y),152) +#define get_csv_uint_pos153(X,Y) get_csv_uint((X),(Y),153) +#define get_csv_ullong_pos153(X,Y) get_csv_ullong((X),(Y),153) +#define get_csv_ip_pos153(X,Y) get_csv_ip((X),(Y),153) +#define get_csv_ipv6_pos153(X,Y) get_csv_ipv6((X),(Y),153) +#define get_csv_string_pos153(X,Y) get_csv_string((X),(Y),153) +#define get_csv_v_str_pos153(X,Y) get_csv_string((X),(Y),153) +#define get_csv_bool_pos153(X,Y) get_csv_bool((X),(Y),153) +#define get_csv_int_pos153(X,Y) get_csv_int((X),(Y),153) +#define get_csv_llong_pos153(X,Y) get_csv_llong((X),(Y),153) +#define get_csv_float_pos153(X,Y) get_csv_float((X),(Y),153) +#define get_csv_uint_pos154(X,Y) get_csv_uint((X),(Y),154) +#define get_csv_ullong_pos154(X,Y) get_csv_ullong((X),(Y),154) +#define get_csv_ip_pos154(X,Y) get_csv_ip((X),(Y),154) +#define get_csv_ipv6_pos154(X,Y) get_csv_ipv6((X),(Y),154) +#define get_csv_string_pos154(X,Y) get_csv_string((X),(Y),154) +#define get_csv_v_str_pos154(X,Y) get_csv_string((X),(Y),154) +#define get_csv_bool_pos154(X,Y) get_csv_bool((X),(Y),154) +#define get_csv_int_pos154(X,Y) get_csv_int((X),(Y),154) +#define get_csv_llong_pos154(X,Y) get_csv_llong((X),(Y),154) +#define get_csv_float_pos154(X,Y) get_csv_float((X),(Y),154) +#define get_csv_uint_pos155(X,Y) get_csv_uint((X),(Y),155) +#define get_csv_ullong_pos155(X,Y) get_csv_ullong((X),(Y),155) +#define get_csv_ip_pos155(X,Y) get_csv_ip((X),(Y),155) +#define get_csv_ipv6_pos155(X,Y) get_csv_ipv6((X),(Y),155) +#define get_csv_string_pos155(X,Y) get_csv_string((X),(Y),155) +#define get_csv_v_str_pos155(X,Y) get_csv_string((X),(Y),155) +#define get_csv_bool_pos155(X,Y) get_csv_bool((X),(Y),155) +#define get_csv_int_pos155(X,Y) get_csv_int((X),(Y),155) +#define get_csv_llong_pos155(X,Y) get_csv_llong((X),(Y),155) +#define get_csv_float_pos155(X,Y) get_csv_float((X),(Y),155) +#define get_csv_uint_pos156(X,Y) get_csv_uint((X),(Y),156) +#define get_csv_ullong_pos156(X,Y) get_csv_ullong((X),(Y),156) +#define get_csv_ip_pos156(X,Y) get_csv_ip((X),(Y),156) +#define get_csv_ipv6_pos156(X,Y) get_csv_ipv6((X),(Y),156) +#define get_csv_string_pos156(X,Y) get_csv_string((X),(Y),156) +#define get_csv_v_str_pos156(X,Y) get_csv_string((X),(Y),156) +#define get_csv_bool_pos156(X,Y) get_csv_bool((X),(Y),156) +#define get_csv_int_pos156(X,Y) get_csv_int((X),(Y),156) +#define get_csv_llong_pos156(X,Y) get_csv_llong((X),(Y),156) +#define get_csv_float_pos156(X,Y) get_csv_float((X),(Y),156) +#define get_csv_uint_pos157(X,Y) get_csv_uint((X),(Y),157) +#define get_csv_ullong_pos157(X,Y) get_csv_ullong((X),(Y),157) +#define get_csv_ip_pos157(X,Y) get_csv_ip((X),(Y),157) +#define get_csv_ipv6_pos157(X,Y) get_csv_ipv6((X),(Y),157) +#define get_csv_string_pos157(X,Y) get_csv_string((X),(Y),157) +#define get_csv_v_str_pos157(X,Y) get_csv_string((X),(Y),157) +#define get_csv_bool_pos157(X,Y) get_csv_bool((X),(Y),157) +#define get_csv_int_pos157(X,Y) get_csv_int((X),(Y),157) +#define get_csv_llong_pos157(X,Y) get_csv_llong((X),(Y),157) +#define get_csv_float_pos157(X,Y) get_csv_float((X),(Y),157) +#define get_csv_uint_pos158(X,Y) get_csv_uint((X),(Y),158) +#define get_csv_ullong_pos158(X,Y) get_csv_ullong((X),(Y),158) +#define get_csv_ip_pos158(X,Y) get_csv_ip((X),(Y),158) +#define get_csv_ipv6_pos158(X,Y) get_csv_ipv6((X),(Y),158) +#define get_csv_string_pos158(X,Y) get_csv_string((X),(Y),158) +#define get_csv_v_str_pos158(X,Y) get_csv_string((X),(Y),158) +#define get_csv_bool_pos158(X,Y) get_csv_bool((X),(Y),158) +#define get_csv_int_pos158(X,Y) get_csv_int((X),(Y),158) +#define get_csv_llong_pos158(X,Y) get_csv_llong((X),(Y),158) +#define get_csv_float_pos158(X,Y) get_csv_float((X),(Y),158) +#define get_csv_uint_pos159(X,Y) get_csv_uint((X),(Y),159) +#define get_csv_ullong_pos159(X,Y) get_csv_ullong((X),(Y),159) +#define get_csv_ip_pos159(X,Y) get_csv_ip((X),(Y),159) +#define get_csv_ipv6_pos159(X,Y) get_csv_ipv6((X),(Y),159) +#define get_csv_string_pos159(X,Y) get_csv_string((X),(Y),159) +#define get_csv_v_str_pos159(X,Y) get_csv_string((X),(Y),159) +#define get_csv_bool_pos159(X,Y) get_csv_bool((X),(Y),159) +#define get_csv_int_pos159(X,Y) get_csv_int((X),(Y),159) +#define get_csv_llong_pos159(X,Y) get_csv_llong((X),(Y),159) +#define get_csv_float_pos159(X,Y) get_csv_float((X),(Y),159) +#define get_csv_uint_pos160(X,Y) get_csv_uint((X),(Y),160) +#define get_csv_ullong_pos160(X,Y) get_csv_ullong((X),(Y),160) +#define get_csv_ip_pos160(X,Y) get_csv_ip((X),(Y),160) +#define get_csv_ipv6_pos160(X,Y) get_csv_ipv6((X),(Y),160) +#define get_csv_string_pos160(X,Y) get_csv_string((X),(Y),160) +#define get_csv_v_str_pos160(X,Y) get_csv_string((X),(Y),160) +#define get_csv_bool_pos160(X,Y) get_csv_bool((X),(Y),160) +#define get_csv_int_pos160(X,Y) get_csv_int((X),(Y),160) +#define get_csv_llong_pos160(X,Y) get_csv_llong((X),(Y),160) +#define get_csv_float_pos160(X,Y) get_csv_float((X),(Y),160) +#define get_csv_uint_pos161(X,Y) get_csv_uint((X),(Y),161) +#define get_csv_ullong_pos161(X,Y) get_csv_ullong((X),(Y),161) +#define get_csv_ip_pos161(X,Y) get_csv_ip((X),(Y),161) +#define get_csv_ipv6_pos161(X,Y) get_csv_ipv6((X),(Y),161) +#define get_csv_string_pos161(X,Y) get_csv_string((X),(Y),161) +#define get_csv_v_str_pos161(X,Y) get_csv_string((X),(Y),161) +#define get_csv_bool_pos161(X,Y) get_csv_bool((X),(Y),161) +#define get_csv_int_pos161(X,Y) get_csv_int((X),(Y),161) +#define get_csv_llong_pos161(X,Y) get_csv_llong((X),(Y),161) +#define get_csv_float_pos161(X,Y) get_csv_float((X),(Y),161) +#define get_csv_uint_pos162(X,Y) get_csv_uint((X),(Y),162) +#define get_csv_ullong_pos162(X,Y) get_csv_ullong((X),(Y),162) +#define get_csv_ip_pos162(X,Y) get_csv_ip((X),(Y),162) +#define get_csv_ipv6_pos162(X,Y) get_csv_ipv6((X),(Y),162) +#define get_csv_string_pos162(X,Y) get_csv_string((X),(Y),162) +#define get_csv_v_str_pos162(X,Y) get_csv_string((X),(Y),162) +#define get_csv_bool_pos162(X,Y) get_csv_bool((X),(Y),162) +#define get_csv_int_pos162(X,Y) get_csv_int((X),(Y),162) +#define get_csv_llong_pos162(X,Y) get_csv_llong((X),(Y),162) +#define get_csv_float_pos162(X,Y) get_csv_float((X),(Y),162) +#define get_csv_uint_pos163(X,Y) get_csv_uint((X),(Y),163) +#define get_csv_ullong_pos163(X,Y) get_csv_ullong((X),(Y),163) +#define get_csv_ip_pos163(X,Y) get_csv_ip((X),(Y),163) +#define get_csv_ipv6_pos163(X,Y) get_csv_ipv6((X),(Y),163) +#define get_csv_string_pos163(X,Y) get_csv_string((X),(Y),163) +#define get_csv_v_str_pos163(X,Y) get_csv_string((X),(Y),163) +#define get_csv_bool_pos163(X,Y) get_csv_bool((X),(Y),163) +#define get_csv_int_pos163(X,Y) get_csv_int((X),(Y),163) +#define get_csv_llong_pos163(X,Y) get_csv_llong((X),(Y),163) +#define get_csv_float_pos163(X,Y) get_csv_float((X),(Y),163) +#define get_csv_uint_pos164(X,Y) get_csv_uint((X),(Y),164) +#define get_csv_ullong_pos164(X,Y) get_csv_ullong((X),(Y),164) +#define get_csv_ip_pos164(X,Y) get_csv_ip((X),(Y),164) +#define get_csv_ipv6_pos164(X,Y) get_csv_ipv6((X),(Y),164) +#define get_csv_string_pos164(X,Y) get_csv_string((X),(Y),164) +#define get_csv_v_str_pos164(X,Y) get_csv_string((X),(Y),164) +#define get_csv_bool_pos164(X,Y) get_csv_bool((X),(Y),164) +#define get_csv_int_pos164(X,Y) get_csv_int((X),(Y),164) +#define get_csv_llong_pos164(X,Y) get_csv_llong((X),(Y),164) +#define get_csv_float_pos164(X,Y) get_csv_float((X),(Y),164) +#define get_csv_uint_pos165(X,Y) get_csv_uint((X),(Y),165) +#define get_csv_ullong_pos165(X,Y) get_csv_ullong((X),(Y),165) +#define get_csv_ip_pos165(X,Y) get_csv_ip((X),(Y),165) +#define get_csv_ipv6_pos165(X,Y) get_csv_ipv6((X),(Y),165) +#define get_csv_string_pos165(X,Y) get_csv_string((X),(Y),165) +#define get_csv_v_str_pos165(X,Y) get_csv_string((X),(Y),165) +#define get_csv_bool_pos165(X,Y) get_csv_bool((X),(Y),165) +#define get_csv_int_pos165(X,Y) get_csv_int((X),(Y),165) +#define get_csv_llong_pos165(X,Y) get_csv_llong((X),(Y),165) +#define get_csv_float_pos165(X,Y) get_csv_float((X),(Y),165) +#define get_csv_uint_pos166(X,Y) get_csv_uint((X),(Y),166) +#define get_csv_ullong_pos166(X,Y) get_csv_ullong((X),(Y),166) +#define get_csv_ip_pos166(X,Y) get_csv_ip((X),(Y),166) +#define get_csv_ipv6_pos166(X,Y) get_csv_ipv6((X),(Y),166) +#define get_csv_string_pos166(X,Y) get_csv_string((X),(Y),166) +#define get_csv_v_str_pos166(X,Y) get_csv_string((X),(Y),166) +#define get_csv_bool_pos166(X,Y) get_csv_bool((X),(Y),166) +#define get_csv_int_pos166(X,Y) get_csv_int((X),(Y),166) +#define get_csv_llong_pos166(X,Y) get_csv_llong((X),(Y),166) +#define get_csv_float_pos166(X,Y) get_csv_float((X),(Y),166) +#define get_csv_uint_pos167(X,Y) get_csv_uint((X),(Y),167) +#define get_csv_ullong_pos167(X,Y) get_csv_ullong((X),(Y),167) +#define get_csv_ip_pos167(X,Y) get_csv_ip((X),(Y),167) +#define get_csv_ipv6_pos167(X,Y) get_csv_ipv6((X),(Y),167) +#define get_csv_string_pos167(X,Y) get_csv_string((X),(Y),167) +#define get_csv_v_str_pos167(X,Y) get_csv_string((X),(Y),167) +#define get_csv_bool_pos167(X,Y) get_csv_bool((X),(Y),167) +#define get_csv_int_pos167(X,Y) get_csv_int((X),(Y),167) +#define get_csv_llong_pos167(X,Y) get_csv_llong((X),(Y),167) +#define get_csv_float_pos167(X,Y) get_csv_float((X),(Y),167) +#define get_csv_uint_pos168(X,Y) get_csv_uint((X),(Y),168) +#define get_csv_ullong_pos168(X,Y) get_csv_ullong((X),(Y),168) +#define get_csv_ip_pos168(X,Y) get_csv_ip((X),(Y),168) +#define get_csv_ipv6_pos168(X,Y) get_csv_ipv6((X),(Y),168) +#define get_csv_string_pos168(X,Y) get_csv_string((X),(Y),168) +#define get_csv_v_str_pos168(X,Y) get_csv_string((X),(Y),168) +#define get_csv_bool_pos168(X,Y) get_csv_bool((X),(Y),168) +#define get_csv_int_pos168(X,Y) get_csv_int((X),(Y),168) +#define get_csv_llong_pos168(X,Y) get_csv_llong((X),(Y),168) +#define get_csv_float_pos168(X,Y) get_csv_float((X),(Y),168) +#define get_csv_uint_pos169(X,Y) get_csv_uint((X),(Y),169) +#define get_csv_ullong_pos169(X,Y) get_csv_ullong((X),(Y),169) +#define get_csv_ip_pos169(X,Y) get_csv_ip((X),(Y),169) +#define get_csv_ipv6_pos169(X,Y) get_csv_ipv6((X),(Y),169) +#define get_csv_string_pos169(X,Y) get_csv_string((X),(Y),169) +#define get_csv_v_str_pos169(X,Y) get_csv_string((X),(Y),169) +#define get_csv_bool_pos169(X,Y) get_csv_bool((X),(Y),169) +#define get_csv_int_pos169(X,Y) get_csv_int((X),(Y),169) +#define get_csv_llong_pos169(X,Y) get_csv_llong((X),(Y),169) +#define get_csv_float_pos169(X,Y) get_csv_float((X),(Y),169) +#define get_csv_uint_pos170(X,Y) get_csv_uint((X),(Y),170) +#define get_csv_ullong_pos170(X,Y) get_csv_ullong((X),(Y),170) +#define get_csv_ip_pos170(X,Y) get_csv_ip((X),(Y),170) +#define get_csv_ipv6_pos170(X,Y) get_csv_ipv6((X),(Y),170) +#define get_csv_string_pos170(X,Y) get_csv_string((X),(Y),170) +#define get_csv_v_str_pos170(X,Y) get_csv_string((X),(Y),170) +#define get_csv_bool_pos170(X,Y) get_csv_bool((X),(Y),170) +#define get_csv_int_pos170(X,Y) get_csv_int((X),(Y),170) +#define get_csv_llong_pos170(X,Y) get_csv_llong((X),(Y),170) +#define get_csv_float_pos170(X,Y) get_csv_float((X),(Y),170) +#define get_csv_uint_pos171(X,Y) get_csv_uint((X),(Y),171) +#define get_csv_ullong_pos171(X,Y) get_csv_ullong((X),(Y),171) +#define get_csv_ip_pos171(X,Y) get_csv_ip((X),(Y),171) +#define get_csv_ipv6_pos171(X,Y) get_csv_ipv6((X),(Y),171) +#define get_csv_string_pos171(X,Y) get_csv_string((X),(Y),171) +#define get_csv_v_str_pos171(X,Y) get_csv_string((X),(Y),171) +#define get_csv_bool_pos171(X,Y) get_csv_bool((X),(Y),171) +#define get_csv_int_pos171(X,Y) get_csv_int((X),(Y),171) +#define get_csv_llong_pos171(X,Y) get_csv_llong((X),(Y),171) +#define get_csv_float_pos171(X,Y) get_csv_float((X),(Y),171) +#define get_csv_uint_pos172(X,Y) get_csv_uint((X),(Y),172) +#define get_csv_ullong_pos172(X,Y) get_csv_ullong((X),(Y),172) +#define get_csv_ip_pos172(X,Y) get_csv_ip((X),(Y),172) +#define get_csv_ipv6_pos172(X,Y) get_csv_ipv6((X),(Y),172) +#define get_csv_string_pos172(X,Y) get_csv_string((X),(Y),172) +#define get_csv_v_str_pos172(X,Y) get_csv_string((X),(Y),172) +#define get_csv_bool_pos172(X,Y) get_csv_bool((X),(Y),172) +#define get_csv_int_pos172(X,Y) get_csv_int((X),(Y),172) +#define get_csv_llong_pos172(X,Y) get_csv_llong((X),(Y),172) +#define get_csv_float_pos172(X,Y) get_csv_float((X),(Y),172) +#define get_csv_uint_pos173(X,Y) get_csv_uint((X),(Y),173) +#define get_csv_ullong_pos173(X,Y) get_csv_ullong((X),(Y),173) +#define get_csv_ip_pos173(X,Y) get_csv_ip((X),(Y),173) +#define get_csv_ipv6_pos173(X,Y) get_csv_ipv6((X),(Y),173) +#define get_csv_string_pos173(X,Y) get_csv_string((X),(Y),173) +#define get_csv_v_str_pos173(X,Y) get_csv_string((X),(Y),173) +#define get_csv_bool_pos173(X,Y) get_csv_bool((X),(Y),173) +#define get_csv_int_pos173(X,Y) get_csv_int((X),(Y),173) +#define get_csv_llong_pos173(X,Y) get_csv_llong((X),(Y),173) +#define get_csv_float_pos173(X,Y) get_csv_float((X),(Y),173) +#define get_csv_uint_pos174(X,Y) get_csv_uint((X),(Y),174) +#define get_csv_ullong_pos174(X,Y) get_csv_ullong((X),(Y),174) +#define get_csv_ip_pos174(X,Y) get_csv_ip((X),(Y),174) +#define get_csv_ipv6_pos174(X,Y) get_csv_ipv6((X),(Y),174) +#define get_csv_string_pos174(X,Y) get_csv_string((X),(Y),174) +#define get_csv_v_str_pos174(X,Y) get_csv_string((X),(Y),174) +#define get_csv_bool_pos174(X,Y) get_csv_bool((X),(Y),174) +#define get_csv_int_pos174(X,Y) get_csv_int((X),(Y),174) +#define get_csv_llong_pos174(X,Y) get_csv_llong((X),(Y),174) +#define get_csv_float_pos174(X,Y) get_csv_float((X),(Y),174) +#define get_csv_uint_pos175(X,Y) get_csv_uint((X),(Y),175) +#define get_csv_ullong_pos175(X,Y) get_csv_ullong((X),(Y),175) +#define get_csv_ip_pos175(X,Y) get_csv_ip((X),(Y),175) +#define get_csv_ipv6_pos175(X,Y) get_csv_ipv6((X),(Y),175) +#define get_csv_string_pos175(X,Y) get_csv_string((X),(Y),175) +#define get_csv_v_str_pos175(X,Y) get_csv_string((X),(Y),175) +#define get_csv_bool_pos175(X,Y) get_csv_bool((X),(Y),175) +#define get_csv_int_pos175(X,Y) get_csv_int((X),(Y),175) +#define get_csv_llong_pos175(X,Y) get_csv_llong((X),(Y),175) +#define get_csv_float_pos175(X,Y) get_csv_float((X),(Y),175) +#define get_csv_uint_pos176(X,Y) get_csv_uint((X),(Y),176) +#define get_csv_ullong_pos176(X,Y) get_csv_ullong((X),(Y),176) +#define get_csv_ip_pos176(X,Y) get_csv_ip((X),(Y),176) +#define get_csv_ipv6_pos176(X,Y) get_csv_ipv6((X),(Y),176) +#define get_csv_string_pos176(X,Y) get_csv_string((X),(Y),176) +#define get_csv_v_str_pos176(X,Y) get_csv_string((X),(Y),176) +#define get_csv_bool_pos176(X,Y) get_csv_bool((X),(Y),176) +#define get_csv_int_pos176(X,Y) get_csv_int((X),(Y),176) +#define get_csv_llong_pos176(X,Y) get_csv_llong((X),(Y),176) +#define get_csv_float_pos176(X,Y) get_csv_float((X),(Y),176) +#define get_csv_uint_pos177(X,Y) get_csv_uint((X),(Y),177) +#define get_csv_ullong_pos177(X,Y) get_csv_ullong((X),(Y),177) +#define get_csv_ip_pos177(X,Y) get_csv_ip((X),(Y),177) +#define get_csv_ipv6_pos177(X,Y) get_csv_ipv6((X),(Y),177) +#define get_csv_string_pos177(X,Y) get_csv_string((X),(Y),177) +#define get_csv_v_str_pos177(X,Y) get_csv_string((X),(Y),177) +#define get_csv_bool_pos177(X,Y) get_csv_bool((X),(Y),177) +#define get_csv_int_pos177(X,Y) get_csv_int((X),(Y),177) +#define get_csv_llong_pos177(X,Y) get_csv_llong((X),(Y),177) +#define get_csv_float_pos177(X,Y) get_csv_float((X),(Y),177) +#define get_csv_uint_pos178(X,Y) get_csv_uint((X),(Y),178) +#define get_csv_ullong_pos178(X,Y) get_csv_ullong((X),(Y),178) +#define get_csv_ip_pos178(X,Y) get_csv_ip((X),(Y),178) +#define get_csv_ipv6_pos178(X,Y) get_csv_ipv6((X),(Y),178) +#define get_csv_string_pos178(X,Y) get_csv_string((X),(Y),178) +#define get_csv_v_str_pos178(X,Y) get_csv_string((X),(Y),178) +#define get_csv_bool_pos178(X,Y) get_csv_bool((X),(Y),178) +#define get_csv_int_pos178(X,Y) get_csv_int((X),(Y),178) +#define get_csv_llong_pos178(X,Y) get_csv_llong((X),(Y),178) +#define get_csv_float_pos178(X,Y) get_csv_float((X),(Y),178) +#define get_csv_uint_pos179(X,Y) get_csv_uint((X),(Y),179) +#define get_csv_ullong_pos179(X,Y) get_csv_ullong((X),(Y),179) +#define get_csv_ip_pos179(X,Y) get_csv_ip((X),(Y),179) +#define get_csv_ipv6_pos179(X,Y) get_csv_ipv6((X),(Y),179) +#define get_csv_string_pos179(X,Y) get_csv_string((X),(Y),179) +#define get_csv_v_str_pos179(X,Y) get_csv_string((X),(Y),179) +#define get_csv_bool_pos179(X,Y) get_csv_bool((X),(Y),179) +#define get_csv_int_pos179(X,Y) get_csv_int((X),(Y),179) +#define get_csv_llong_pos179(X,Y) get_csv_llong((X),(Y),179) +#define get_csv_float_pos179(X,Y) get_csv_float((X),(Y),179) +#define get_csv_uint_pos180(X,Y) get_csv_uint((X),(Y),180) +#define get_csv_ullong_pos180(X,Y) get_csv_ullong((X),(Y),180) +#define get_csv_ip_pos180(X,Y) get_csv_ip((X),(Y),180) +#define get_csv_ipv6_pos180(X,Y) get_csv_ipv6((X),(Y),180) +#define get_csv_string_pos180(X,Y) get_csv_string((X),(Y),180) +#define get_csv_v_str_pos180(X,Y) get_csv_string((X),(Y),180) +#define get_csv_bool_pos180(X,Y) get_csv_bool((X),(Y),180) +#define get_csv_int_pos180(X,Y) get_csv_int((X),(Y),180) +#define get_csv_llong_pos180(X,Y) get_csv_llong((X),(Y),180) +#define get_csv_float_pos180(X,Y) get_csv_float((X),(Y),180) +#define get_csv_uint_pos181(X,Y) get_csv_uint((X),(Y),181) +#define get_csv_ullong_pos181(X,Y) get_csv_ullong((X),(Y),181) +#define get_csv_ip_pos181(X,Y) get_csv_ip((X),(Y),181) +#define get_csv_ipv6_pos181(X,Y) get_csv_ipv6((X),(Y),181) +#define get_csv_string_pos181(X,Y) get_csv_string((X),(Y),181) +#define get_csv_v_str_pos181(X,Y) get_csv_string((X),(Y),181) +#define get_csv_bool_pos181(X,Y) get_csv_bool((X),(Y),181) +#define get_csv_int_pos181(X,Y) get_csv_int((X),(Y),181) +#define get_csv_llong_pos181(X,Y) get_csv_llong((X),(Y),181) +#define get_csv_float_pos181(X,Y) get_csv_float((X),(Y),181) +#define get_csv_uint_pos182(X,Y) get_csv_uint((X),(Y),182) +#define get_csv_ullong_pos182(X,Y) get_csv_ullong((X),(Y),182) +#define get_csv_ip_pos182(X,Y) get_csv_ip((X),(Y),182) +#define get_csv_ipv6_pos182(X,Y) get_csv_ipv6((X),(Y),182) +#define get_csv_string_pos182(X,Y) get_csv_string((X),(Y),182) +#define get_csv_v_str_pos182(X,Y) get_csv_string((X),(Y),182) +#define get_csv_bool_pos182(X,Y) get_csv_bool((X),(Y),182) +#define get_csv_int_pos182(X,Y) get_csv_int((X),(Y),182) +#define get_csv_llong_pos182(X,Y) get_csv_llong((X),(Y),182) +#define get_csv_float_pos182(X,Y) get_csv_float((X),(Y),182) +#define get_csv_uint_pos183(X,Y) get_csv_uint((X),(Y),183) +#define get_csv_ullong_pos183(X,Y) get_csv_ullong((X),(Y),183) +#define get_csv_ip_pos183(X,Y) get_csv_ip((X),(Y),183) +#define get_csv_ipv6_pos183(X,Y) get_csv_ipv6((X),(Y),183) +#define get_csv_string_pos183(X,Y) get_csv_string((X),(Y),183) +#define get_csv_v_str_pos183(X,Y) get_csv_string((X),(Y),183) +#define get_csv_bool_pos183(X,Y) get_csv_bool((X),(Y),183) +#define get_csv_int_pos183(X,Y) get_csv_int((X),(Y),183) +#define get_csv_llong_pos183(X,Y) get_csv_llong((X),(Y),183) +#define get_csv_float_pos183(X,Y) get_csv_float((X),(Y),183) +#define get_csv_uint_pos184(X,Y) get_csv_uint((X),(Y),184) +#define get_csv_ullong_pos184(X,Y) get_csv_ullong((X),(Y),184) +#define get_csv_ip_pos184(X,Y) get_csv_ip((X),(Y),184) +#define get_csv_ipv6_pos184(X,Y) get_csv_ipv6((X),(Y),184) +#define get_csv_string_pos184(X,Y) get_csv_string((X),(Y),184) +#define get_csv_v_str_pos184(X,Y) get_csv_string((X),(Y),184) +#define get_csv_bool_pos184(X,Y) get_csv_bool((X),(Y),184) +#define get_csv_int_pos184(X,Y) get_csv_int((X),(Y),184) +#define get_csv_llong_pos184(X,Y) get_csv_llong((X),(Y),184) +#define get_csv_float_pos184(X,Y) get_csv_float((X),(Y),184) +#define get_csv_uint_pos185(X,Y) get_csv_uint((X),(Y),185) +#define get_csv_ullong_pos185(X,Y) get_csv_ullong((X),(Y),185) +#define get_csv_ip_pos185(X,Y) get_csv_ip((X),(Y),185) +#define get_csv_ipv6_pos185(X,Y) get_csv_ipv6((X),(Y),185) +#define get_csv_string_pos185(X,Y) get_csv_string((X),(Y),185) +#define get_csv_v_str_pos185(X,Y) get_csv_string((X),(Y),185) +#define get_csv_bool_pos185(X,Y) get_csv_bool((X),(Y),185) +#define get_csv_int_pos185(X,Y) get_csv_int((X),(Y),185) +#define get_csv_llong_pos185(X,Y) get_csv_llong((X),(Y),185) +#define get_csv_float_pos185(X,Y) get_csv_float((X),(Y),185) +#define get_csv_uint_pos186(X,Y) get_csv_uint((X),(Y),186) +#define get_csv_ullong_pos186(X,Y) get_csv_ullong((X),(Y),186) +#define get_csv_ip_pos186(X,Y) get_csv_ip((X),(Y),186) +#define get_csv_ipv6_pos186(X,Y) get_csv_ipv6((X),(Y),186) +#define get_csv_string_pos186(X,Y) get_csv_string((X),(Y),186) +#define get_csv_v_str_pos186(X,Y) get_csv_string((X),(Y),186) +#define get_csv_bool_pos186(X,Y) get_csv_bool((X),(Y),186) +#define get_csv_int_pos186(X,Y) get_csv_int((X),(Y),186) +#define get_csv_llong_pos186(X,Y) get_csv_llong((X),(Y),186) +#define get_csv_float_pos186(X,Y) get_csv_float((X),(Y),186) +#define get_csv_uint_pos187(X,Y) get_csv_uint((X),(Y),187) +#define get_csv_ullong_pos187(X,Y) get_csv_ullong((X),(Y),187) +#define get_csv_ip_pos187(X,Y) get_csv_ip((X),(Y),187) +#define get_csv_ipv6_pos187(X,Y) get_csv_ipv6((X),(Y),187) +#define get_csv_string_pos187(X,Y) get_csv_string((X),(Y),187) +#define get_csv_v_str_pos187(X,Y) get_csv_string((X),(Y),187) +#define get_csv_bool_pos187(X,Y) get_csv_bool((X),(Y),187) +#define get_csv_int_pos187(X,Y) get_csv_int((X),(Y),187) +#define get_csv_llong_pos187(X,Y) get_csv_llong((X),(Y),187) +#define get_csv_float_pos187(X,Y) get_csv_float((X),(Y),187) +#define get_csv_uint_pos188(X,Y) get_csv_uint((X),(Y),188) +#define get_csv_ullong_pos188(X,Y) get_csv_ullong((X),(Y),188) +#define get_csv_ip_pos188(X,Y) get_csv_ip((X),(Y),188) +#define get_csv_ipv6_pos188(X,Y) get_csv_ipv6((X),(Y),188) +#define get_csv_string_pos188(X,Y) get_csv_string((X),(Y),188) +#define get_csv_v_str_pos188(X,Y) get_csv_string((X),(Y),188) +#define get_csv_bool_pos188(X,Y) get_csv_bool((X),(Y),188) +#define get_csv_int_pos188(X,Y) get_csv_int((X),(Y),188) +#define get_csv_llong_pos188(X,Y) get_csv_llong((X),(Y),188) +#define get_csv_float_pos188(X,Y) get_csv_float((X),(Y),188) +#define get_csv_uint_pos189(X,Y) get_csv_uint((X),(Y),189) +#define get_csv_ullong_pos189(X,Y) get_csv_ullong((X),(Y),189) +#define get_csv_ip_pos189(X,Y) get_csv_ip((X),(Y),189) +#define get_csv_ipv6_pos189(X,Y) get_csv_ipv6((X),(Y),189) +#define get_csv_string_pos189(X,Y) get_csv_string((X),(Y),189) +#define get_csv_v_str_pos189(X,Y) get_csv_string((X),(Y),189) +#define get_csv_bool_pos189(X,Y) get_csv_bool((X),(Y),189) +#define get_csv_int_pos189(X,Y) get_csv_int((X),(Y),189) +#define get_csv_llong_pos189(X,Y) get_csv_llong((X),(Y),189) +#define get_csv_float_pos189(X,Y) get_csv_float((X),(Y),189) +#define get_csv_uint_pos190(X,Y) get_csv_uint((X),(Y),190) +#define get_csv_ullong_pos190(X,Y) get_csv_ullong((X),(Y),190) +#define get_csv_ip_pos190(X,Y) get_csv_ip((X),(Y),190) +#define get_csv_ipv6_pos190(X,Y) get_csv_ipv6((X),(Y),190) +#define get_csv_string_pos190(X,Y) get_csv_string((X),(Y),190) +#define get_csv_v_str_pos190(X,Y) get_csv_string((X),(Y),190) +#define get_csv_bool_pos190(X,Y) get_csv_bool((X),(Y),190) +#define get_csv_int_pos190(X,Y) get_csv_int((X),(Y),190) +#define get_csv_llong_pos190(X,Y) get_csv_llong((X),(Y),190) +#define get_csv_float_pos190(X,Y) get_csv_float((X),(Y),190) +#define get_csv_uint_pos191(X,Y) get_csv_uint((X),(Y),191) +#define get_csv_ullong_pos191(X,Y) get_csv_ullong((X),(Y),191) +#define get_csv_ip_pos191(X,Y) get_csv_ip((X),(Y),191) +#define get_csv_ipv6_pos191(X,Y) get_csv_ipv6((X),(Y),191) +#define get_csv_string_pos191(X,Y) get_csv_string((X),(Y),191) +#define get_csv_v_str_pos191(X,Y) get_csv_string((X),(Y),191) +#define get_csv_bool_pos191(X,Y) get_csv_bool((X),(Y),191) +#define get_csv_int_pos191(X,Y) get_csv_int((X),(Y),191) +#define get_csv_llong_pos191(X,Y) get_csv_llong((X),(Y),191) +#define get_csv_float_pos191(X,Y) get_csv_float((X),(Y),191) +#define get_csv_uint_pos192(X,Y) get_csv_uint((X),(Y),192) +#define get_csv_ullong_pos192(X,Y) get_csv_ullong((X),(Y),192) +#define get_csv_ip_pos192(X,Y) get_csv_ip((X),(Y),192) +#define get_csv_ipv6_pos192(X,Y) get_csv_ipv6((X),(Y),192) +#define get_csv_string_pos192(X,Y) get_csv_string((X),(Y),192) +#define get_csv_v_str_pos192(X,Y) get_csv_string((X),(Y),192) +#define get_csv_bool_pos192(X,Y) get_csv_bool((X),(Y),192) +#define get_csv_int_pos192(X,Y) get_csv_int((X),(Y),192) +#define get_csv_llong_pos192(X,Y) get_csv_llong((X),(Y),192) +#define get_csv_float_pos192(X,Y) get_csv_float((X),(Y),192) +#define get_csv_uint_pos193(X,Y) get_csv_uint((X),(Y),193) +#define get_csv_ullong_pos193(X,Y) get_csv_ullong((X),(Y),193) +#define get_csv_ip_pos193(X,Y) get_csv_ip((X),(Y),193) +#define get_csv_ipv6_pos193(X,Y) get_csv_ipv6((X),(Y),193) +#define get_csv_string_pos193(X,Y) get_csv_string((X),(Y),193) +#define get_csv_v_str_pos193(X,Y) get_csv_string((X),(Y),193) +#define get_csv_bool_pos193(X,Y) get_csv_bool((X),(Y),193) +#define get_csv_int_pos193(X,Y) get_csv_int((X),(Y),193) +#define get_csv_llong_pos193(X,Y) get_csv_llong((X),(Y),193) +#define get_csv_float_pos193(X,Y) get_csv_float((X),(Y),193) +#define get_csv_uint_pos194(X,Y) get_csv_uint((X),(Y),194) +#define get_csv_ullong_pos194(X,Y) get_csv_ullong((X),(Y),194) +#define get_csv_ip_pos194(X,Y) get_csv_ip((X),(Y),194) +#define get_csv_ipv6_pos194(X,Y) get_csv_ipv6((X),(Y),194) +#define get_csv_string_pos194(X,Y) get_csv_string((X),(Y),194) +#define get_csv_v_str_pos194(X,Y) get_csv_string((X),(Y),194) +#define get_csv_bool_pos194(X,Y) get_csv_bool((X),(Y),194) +#define get_csv_int_pos194(X,Y) get_csv_int((X),(Y),194) +#define get_csv_llong_pos194(X,Y) get_csv_llong((X),(Y),194) +#define get_csv_float_pos194(X,Y) get_csv_float((X),(Y),194) +#define get_csv_uint_pos195(X,Y) get_csv_uint((X),(Y),195) +#define get_csv_ullong_pos195(X,Y) get_csv_ullong((X),(Y),195) +#define get_csv_ip_pos195(X,Y) get_csv_ip((X),(Y),195) +#define get_csv_ipv6_pos195(X,Y) get_csv_ipv6((X),(Y),195) +#define get_csv_string_pos195(X,Y) get_csv_string((X),(Y),195) +#define get_csv_v_str_pos195(X,Y) get_csv_string((X),(Y),195) +#define get_csv_bool_pos195(X,Y) get_csv_bool((X),(Y),195) +#define get_csv_int_pos195(X,Y) get_csv_int((X),(Y),195) +#define get_csv_llong_pos195(X,Y) get_csv_llong((X),(Y),195) +#define get_csv_float_pos195(X,Y) get_csv_float((X),(Y),195) +#define get_csv_uint_pos196(X,Y) get_csv_uint((X),(Y),196) +#define get_csv_ullong_pos196(X,Y) get_csv_ullong((X),(Y),196) +#define get_csv_ip_pos196(X,Y) get_csv_ip((X),(Y),196) +#define get_csv_ipv6_pos196(X,Y) get_csv_ipv6((X),(Y),196) +#define get_csv_string_pos196(X,Y) get_csv_string((X),(Y),196) +#define get_csv_v_str_pos196(X,Y) get_csv_string((X),(Y),196) +#define get_csv_bool_pos196(X,Y) get_csv_bool((X),(Y),196) +#define get_csv_int_pos196(X,Y) get_csv_int((X),(Y),196) +#define get_csv_llong_pos196(X,Y) get_csv_llong((X),(Y),196) +#define get_csv_float_pos196(X,Y) get_csv_float((X),(Y),196) +#define get_csv_uint_pos197(X,Y) get_csv_uint((X),(Y),197) +#define get_csv_ullong_pos197(X,Y) get_csv_ullong((X),(Y),197) +#define get_csv_ip_pos197(X,Y) get_csv_ip((X),(Y),197) +#define get_csv_ipv6_pos197(X,Y) get_csv_ipv6((X),(Y),197) +#define get_csv_string_pos197(X,Y) get_csv_string((X),(Y),197) +#define get_csv_v_str_pos197(X,Y) get_csv_string((X),(Y),197) +#define get_csv_bool_pos197(X,Y) get_csv_bool((X),(Y),197) +#define get_csv_int_pos197(X,Y) get_csv_int((X),(Y),197) +#define get_csv_llong_pos197(X,Y) get_csv_llong((X),(Y),197) +#define get_csv_float_pos197(X,Y) get_csv_float((X),(Y),197) +#define get_csv_uint_pos198(X,Y) get_csv_uint((X),(Y),198) +#define get_csv_ullong_pos198(X,Y) get_csv_ullong((X),(Y),198) +#define get_csv_ip_pos198(X,Y) get_csv_ip((X),(Y),198) +#define get_csv_ipv6_pos198(X,Y) get_csv_ipv6((X),(Y),198) +#define get_csv_string_pos198(X,Y) get_csv_string((X),(Y),198) +#define get_csv_v_str_pos198(X,Y) get_csv_string((X),(Y),198) +#define get_csv_bool_pos198(X,Y) get_csv_bool((X),(Y),198) +#define get_csv_int_pos198(X,Y) get_csv_int((X),(Y),198) +#define get_csv_llong_pos198(X,Y) get_csv_llong((X),(Y),198) +#define get_csv_float_pos198(X,Y) get_csv_float((X),(Y),198) +#define get_csv_uint_pos199(X,Y) get_csv_uint((X),(Y),199) +#define get_csv_ullong_pos199(X,Y) get_csv_ullong((X),(Y),199) +#define get_csv_ip_pos199(X,Y) get_csv_ip((X),(Y),199) +#define get_csv_ipv6_pos199(X,Y) get_csv_ipv6((X),(Y),199) +#define get_csv_string_pos199(X,Y) get_csv_string((X),(Y),199) +#define get_csv_v_str_pos199(X,Y) get_csv_string((X),(Y),199) +#define get_csv_bool_pos199(X,Y) get_csv_bool((X),(Y),199) +#define get_csv_int_pos199(X,Y) get_csv_int((X),(Y),199) +#define get_csv_llong_pos199(X,Y) get_csv_llong((X),(Y),199) +#define get_csv_float_pos199(X,Y) get_csv_float((X),(Y),199) +#define get_csv_uint_pos200(X,Y) get_csv_uint((X),(Y),200) +#define get_csv_ullong_pos200(X,Y) get_csv_ullong((X),(Y),200) +#define get_csv_ip_pos200(X,Y) get_csv_ip((X),(Y),200) +#define get_csv_ipv6_pos200(X,Y) get_csv_ipv6((X),(Y),200) +#define get_csv_string_pos200(X,Y) get_csv_string((X),(Y),200) +#define get_csv_v_str_pos200(X,Y) get_csv_string((X),(Y),200) +#define get_csv_bool_pos200(X,Y) get_csv_bool((X),(Y),200) +#define get_csv_int_pos200(X,Y) get_csv_int((X),(Y),200) +#define get_csv_llong_pos200(X,Y) get_csv_llong((X),(Y),200) +#define get_csv_float_pos200(X,Y) get_csv_float((X),(Y),200) +#define get_csv_uint_pos201(X,Y) get_csv_uint((X),(Y),201) +#define get_csv_ullong_pos201(X,Y) get_csv_ullong((X),(Y),201) +#define get_csv_ip_pos201(X,Y) get_csv_ip((X),(Y),201) +#define get_csv_ipv6_pos201(X,Y) get_csv_ipv6((X),(Y),201) +#define get_csv_string_pos201(X,Y) get_csv_string((X),(Y),201) +#define get_csv_v_str_pos201(X,Y) get_csv_string((X),(Y),201) +#define get_csv_bool_pos201(X,Y) get_csv_bool((X),(Y),201) +#define get_csv_int_pos201(X,Y) get_csv_int((X),(Y),201) +#define get_csv_llong_pos201(X,Y) get_csv_llong((X),(Y),201) +#define get_csv_float_pos201(X,Y) get_csv_float((X),(Y),201) +#define get_csv_uint_pos202(X,Y) get_csv_uint((X),(Y),202) +#define get_csv_ullong_pos202(X,Y) get_csv_ullong((X),(Y),202) +#define get_csv_ip_pos202(X,Y) get_csv_ip((X),(Y),202) +#define get_csv_ipv6_pos202(X,Y) get_csv_ipv6((X),(Y),202) +#define get_csv_string_pos202(X,Y) get_csv_string((X),(Y),202) +#define get_csv_v_str_pos202(X,Y) get_csv_string((X),(Y),202) +#define get_csv_bool_pos202(X,Y) get_csv_bool((X),(Y),202) +#define get_csv_int_pos202(X,Y) get_csv_int((X),(Y),202) +#define get_csv_llong_pos202(X,Y) get_csv_llong((X),(Y),202) +#define get_csv_float_pos202(X,Y) get_csv_float((X),(Y),202) +#define get_csv_uint_pos203(X,Y) get_csv_uint((X),(Y),203) +#define get_csv_ullong_pos203(X,Y) get_csv_ullong((X),(Y),203) +#define get_csv_ip_pos203(X,Y) get_csv_ip((X),(Y),203) +#define get_csv_ipv6_pos203(X,Y) get_csv_ipv6((X),(Y),203) +#define get_csv_string_pos203(X,Y) get_csv_string((X),(Y),203) +#define get_csv_v_str_pos203(X,Y) get_csv_string((X),(Y),203) +#define get_csv_bool_pos203(X,Y) get_csv_bool((X),(Y),203) +#define get_csv_int_pos203(X,Y) get_csv_int((X),(Y),203) +#define get_csv_llong_pos203(X,Y) get_csv_llong((X),(Y),203) +#define get_csv_float_pos203(X,Y) get_csv_float((X),(Y),203) +#define get_csv_uint_pos204(X,Y) get_csv_uint((X),(Y),204) +#define get_csv_ullong_pos204(X,Y) get_csv_ullong((X),(Y),204) +#define get_csv_ip_pos204(X,Y) get_csv_ip((X),(Y),204) +#define get_csv_ipv6_pos204(X,Y) get_csv_ipv6((X),(Y),204) +#define get_csv_string_pos204(X,Y) get_csv_string((X),(Y),204) +#define get_csv_v_str_pos204(X,Y) get_csv_string((X),(Y),204) +#define get_csv_bool_pos204(X,Y) get_csv_bool((X),(Y),204) +#define get_csv_int_pos204(X,Y) get_csv_int((X),(Y),204) +#define get_csv_llong_pos204(X,Y) get_csv_llong((X),(Y),204) +#define get_csv_float_pos204(X,Y) get_csv_float((X),(Y),204) +#define get_csv_uint_pos205(X,Y) get_csv_uint((X),(Y),205) +#define get_csv_ullong_pos205(X,Y) get_csv_ullong((X),(Y),205) +#define get_csv_ip_pos205(X,Y) get_csv_ip((X),(Y),205) +#define get_csv_ipv6_pos205(X,Y) get_csv_ipv6((X),(Y),205) +#define get_csv_string_pos205(X,Y) get_csv_string((X),(Y),205) +#define get_csv_v_str_pos205(X,Y) get_csv_string((X),(Y),205) +#define get_csv_bool_pos205(X,Y) get_csv_bool((X),(Y),205) +#define get_csv_int_pos205(X,Y) get_csv_int((X),(Y),205) +#define get_csv_llong_pos205(X,Y) get_csv_llong((X),(Y),205) +#define get_csv_float_pos205(X,Y) get_csv_float((X),(Y),205) +#define get_csv_uint_pos206(X,Y) get_csv_uint((X),(Y),206) +#define get_csv_ullong_pos206(X,Y) get_csv_ullong((X),(Y),206) +#define get_csv_ip_pos206(X,Y) get_csv_ip((X),(Y),206) +#define get_csv_ipv6_pos206(X,Y) get_csv_ipv6((X),(Y),206) +#define get_csv_string_pos206(X,Y) get_csv_string((X),(Y),206) +#define get_csv_v_str_pos206(X,Y) get_csv_string((X),(Y),206) +#define get_csv_bool_pos206(X,Y) get_csv_bool((X),(Y),206) +#define get_csv_int_pos206(X,Y) get_csv_int((X),(Y),206) +#define get_csv_llong_pos206(X,Y) get_csv_llong((X),(Y),206) +#define get_csv_float_pos206(X,Y) get_csv_float((X),(Y),206) +#define get_csv_uint_pos207(X,Y) get_csv_uint((X),(Y),207) +#define get_csv_ullong_pos207(X,Y) get_csv_ullong((X),(Y),207) +#define get_csv_ip_pos207(X,Y) get_csv_ip((X),(Y),207) +#define get_csv_ipv6_pos207(X,Y) get_csv_ipv6((X),(Y),207) +#define get_csv_string_pos207(X,Y) get_csv_string((X),(Y),207) +#define get_csv_v_str_pos207(X,Y) get_csv_string((X),(Y),207) +#define get_csv_bool_pos207(X,Y) get_csv_bool((X),(Y),207) +#define get_csv_int_pos207(X,Y) get_csv_int((X),(Y),207) +#define get_csv_llong_pos207(X,Y) get_csv_llong((X),(Y),207) +#define get_csv_float_pos207(X,Y) get_csv_float((X),(Y),207) +#define get_csv_uint_pos208(X,Y) get_csv_uint((X),(Y),208) +#define get_csv_ullong_pos208(X,Y) get_csv_ullong((X),(Y),208) +#define get_csv_ip_pos208(X,Y) get_csv_ip((X),(Y),208) +#define get_csv_ipv6_pos208(X,Y) get_csv_ipv6((X),(Y),208) +#define get_csv_string_pos208(X,Y) get_csv_string((X),(Y),208) +#define get_csv_v_str_pos208(X,Y) get_csv_string((X),(Y),208) +#define get_csv_bool_pos208(X,Y) get_csv_bool((X),(Y),208) +#define get_csv_int_pos208(X,Y) get_csv_int((X),(Y),208) +#define get_csv_llong_pos208(X,Y) get_csv_llong((X),(Y),208) +#define get_csv_float_pos208(X,Y) get_csv_float((X),(Y),208) +#define get_csv_uint_pos209(X,Y) get_csv_uint((X),(Y),209) +#define get_csv_ullong_pos209(X,Y) get_csv_ullong((X),(Y),209) +#define get_csv_ip_pos209(X,Y) get_csv_ip((X),(Y),209) +#define get_csv_ipv6_pos209(X,Y) get_csv_ipv6((X),(Y),209) +#define get_csv_string_pos209(X,Y) get_csv_string((X),(Y),209) +#define get_csv_v_str_pos209(X,Y) get_csv_string((X),(Y),209) +#define get_csv_bool_pos209(X,Y) get_csv_bool((X),(Y),209) +#define get_csv_int_pos209(X,Y) get_csv_int((X),(Y),209) +#define get_csv_llong_pos209(X,Y) get_csv_llong((X),(Y),209) +#define get_csv_float_pos209(X,Y) get_csv_float((X),(Y),209) +#define get_csv_uint_pos210(X,Y) get_csv_uint((X),(Y),210) +#define get_csv_ullong_pos210(X,Y) get_csv_ullong((X),(Y),210) +#define get_csv_ip_pos210(X,Y) get_csv_ip((X),(Y),210) +#define get_csv_ipv6_pos210(X,Y) get_csv_ipv6((X),(Y),210) +#define get_csv_string_pos210(X,Y) get_csv_string((X),(Y),210) +#define get_csv_v_str_pos210(X,Y) get_csv_string((X),(Y),210) +#define get_csv_bool_pos210(X,Y) get_csv_bool((X),(Y),210) +#define get_csv_int_pos210(X,Y) get_csv_int((X),(Y),210) +#define get_csv_llong_pos210(X,Y) get_csv_llong((X),(Y),210) +#define get_csv_float_pos210(X,Y) get_csv_float((X),(Y),210) +#define get_csv_uint_pos211(X,Y) get_csv_uint((X),(Y),211) +#define get_csv_ullong_pos211(X,Y) get_csv_ullong((X),(Y),211) +#define get_csv_ip_pos211(X,Y) get_csv_ip((X),(Y),211) +#define get_csv_ipv6_pos211(X,Y) get_csv_ipv6((X),(Y),211) +#define get_csv_string_pos211(X,Y) get_csv_string((X),(Y),211) +#define get_csv_v_str_pos211(X,Y) get_csv_string((X),(Y),211) +#define get_csv_bool_pos211(X,Y) get_csv_bool((X),(Y),211) +#define get_csv_int_pos211(X,Y) get_csv_int((X),(Y),211) +#define get_csv_llong_pos211(X,Y) get_csv_llong((X),(Y),211) +#define get_csv_float_pos211(X,Y) get_csv_float((X),(Y),211) +#define get_csv_uint_pos212(X,Y) get_csv_uint((X),(Y),212) +#define get_csv_ullong_pos212(X,Y) get_csv_ullong((X),(Y),212) +#define get_csv_ip_pos212(X,Y) get_csv_ip((X),(Y),212) +#define get_csv_ipv6_pos212(X,Y) get_csv_ipv6((X),(Y),212) +#define get_csv_string_pos212(X,Y) get_csv_string((X),(Y),212) +#define get_csv_v_str_pos212(X,Y) get_csv_string((X),(Y),212) +#define get_csv_bool_pos212(X,Y) get_csv_bool((X),(Y),212) +#define get_csv_int_pos212(X,Y) get_csv_int((X),(Y),212) +#define get_csv_llong_pos212(X,Y) get_csv_llong((X),(Y),212) +#define get_csv_float_pos212(X,Y) get_csv_float((X),(Y),212) +#define get_csv_uint_pos213(X,Y) get_csv_uint((X),(Y),213) +#define get_csv_ullong_pos213(X,Y) get_csv_ullong((X),(Y),213) +#define get_csv_ip_pos213(X,Y) get_csv_ip((X),(Y),213) +#define get_csv_ipv6_pos213(X,Y) get_csv_ipv6((X),(Y),213) +#define get_csv_string_pos213(X,Y) get_csv_string((X),(Y),213) +#define get_csv_v_str_pos213(X,Y) get_csv_string((X),(Y),213) +#define get_csv_bool_pos213(X,Y) get_csv_bool((X),(Y),213) +#define get_csv_int_pos213(X,Y) get_csv_int((X),(Y),213) +#define get_csv_llong_pos213(X,Y) get_csv_llong((X),(Y),213) +#define get_csv_float_pos213(X,Y) get_csv_float((X),(Y),213) +#define get_csv_uint_pos214(X,Y) get_csv_uint((X),(Y),214) +#define get_csv_ullong_pos214(X,Y) get_csv_ullong((X),(Y),214) +#define get_csv_ip_pos214(X,Y) get_csv_ip((X),(Y),214) +#define get_csv_ipv6_pos214(X,Y) get_csv_ipv6((X),(Y),214) +#define get_csv_string_pos214(X,Y) get_csv_string((X),(Y),214) +#define get_csv_v_str_pos214(X,Y) get_csv_string((X),(Y),214) +#define get_csv_bool_pos214(X,Y) get_csv_bool((X),(Y),214) +#define get_csv_int_pos214(X,Y) get_csv_int((X),(Y),214) +#define get_csv_llong_pos214(X,Y) get_csv_llong((X),(Y),214) +#define get_csv_float_pos214(X,Y) get_csv_float((X),(Y),214) +#define get_csv_uint_pos215(X,Y) get_csv_uint((X),(Y),215) +#define get_csv_ullong_pos215(X,Y) get_csv_ullong((X),(Y),215) +#define get_csv_ip_pos215(X,Y) get_csv_ip((X),(Y),215) +#define get_csv_ipv6_pos215(X,Y) get_csv_ipv6((X),(Y),215) +#define get_csv_string_pos215(X,Y) get_csv_string((X),(Y),215) +#define get_csv_v_str_pos215(X,Y) get_csv_string((X),(Y),215) +#define get_csv_bool_pos215(X,Y) get_csv_bool((X),(Y),215) +#define get_csv_int_pos215(X,Y) get_csv_int((X),(Y),215) +#define get_csv_llong_pos215(X,Y) get_csv_llong((X),(Y),215) +#define get_csv_float_pos215(X,Y) get_csv_float((X),(Y),215) +#define get_csv_uint_pos216(X,Y) get_csv_uint((X),(Y),216) +#define get_csv_ullong_pos216(X,Y) get_csv_ullong((X),(Y),216) +#define get_csv_ip_pos216(X,Y) get_csv_ip((X),(Y),216) +#define get_csv_ipv6_pos216(X,Y) get_csv_ipv6((X),(Y),216) +#define get_csv_string_pos216(X,Y) get_csv_string((X),(Y),216) +#define get_csv_v_str_pos216(X,Y) get_csv_string((X),(Y),216) +#define get_csv_bool_pos216(X,Y) get_csv_bool((X),(Y),216) +#define get_csv_int_pos216(X,Y) get_csv_int((X),(Y),216) +#define get_csv_llong_pos216(X,Y) get_csv_llong((X),(Y),216) +#define get_csv_float_pos216(X,Y) get_csv_float((X),(Y),216) +#define get_csv_uint_pos217(X,Y) get_csv_uint((X),(Y),217) +#define get_csv_ullong_pos217(X,Y) get_csv_ullong((X),(Y),217) +#define get_csv_ip_pos217(X,Y) get_csv_ip((X),(Y),217) +#define get_csv_ipv6_pos217(X,Y) get_csv_ipv6((X),(Y),217) +#define get_csv_string_pos217(X,Y) get_csv_string((X),(Y),217) +#define get_csv_v_str_pos217(X,Y) get_csv_string((X),(Y),217) +#define get_csv_bool_pos217(X,Y) get_csv_bool((X),(Y),217) +#define get_csv_int_pos217(X,Y) get_csv_int((X),(Y),217) +#define get_csv_llong_pos217(X,Y) get_csv_llong((X),(Y),217) +#define get_csv_float_pos217(X,Y) get_csv_float((X),(Y),217) +#define get_csv_uint_pos218(X,Y) get_csv_uint((X),(Y),218) +#define get_csv_ullong_pos218(X,Y) get_csv_ullong((X),(Y),218) +#define get_csv_ip_pos218(X,Y) get_csv_ip((X),(Y),218) +#define get_csv_ipv6_pos218(X,Y) get_csv_ipv6((X),(Y),218) +#define get_csv_string_pos218(X,Y) get_csv_string((X),(Y),218) +#define get_csv_v_str_pos218(X,Y) get_csv_string((X),(Y),218) +#define get_csv_bool_pos218(X,Y) get_csv_bool((X),(Y),218) +#define get_csv_int_pos218(X,Y) get_csv_int((X),(Y),218) +#define get_csv_llong_pos218(X,Y) get_csv_llong((X),(Y),218) +#define get_csv_float_pos218(X,Y) get_csv_float((X),(Y),218) +#define get_csv_uint_pos219(X,Y) get_csv_uint((X),(Y),219) +#define get_csv_ullong_pos219(X,Y) get_csv_ullong((X),(Y),219) +#define get_csv_ip_pos219(X,Y) get_csv_ip((X),(Y),219) +#define get_csv_ipv6_pos219(X,Y) get_csv_ipv6((X),(Y),219) +#define get_csv_string_pos219(X,Y) get_csv_string((X),(Y),219) +#define get_csv_v_str_pos219(X,Y) get_csv_string((X),(Y),219) +#define get_csv_bool_pos219(X,Y) get_csv_bool((X),(Y),219) +#define get_csv_int_pos219(X,Y) get_csv_int((X),(Y),219) +#define get_csv_llong_pos219(X,Y) get_csv_llong((X),(Y),219) +#define get_csv_float_pos219(X,Y) get_csv_float((X),(Y),219) +#define get_csv_uint_pos220(X,Y) get_csv_uint((X),(Y),220) +#define get_csv_ullong_pos220(X,Y) get_csv_ullong((X),(Y),220) +#define get_csv_ip_pos220(X,Y) get_csv_ip((X),(Y),220) +#define get_csv_ipv6_pos220(X,Y) get_csv_ipv6((X),(Y),220) +#define get_csv_string_pos220(X,Y) get_csv_string((X),(Y),220) +#define get_csv_v_str_pos220(X,Y) get_csv_string((X),(Y),220) +#define get_csv_bool_pos220(X,Y) get_csv_bool((X),(Y),220) +#define get_csv_int_pos220(X,Y) get_csv_int((X),(Y),220) +#define get_csv_llong_pos220(X,Y) get_csv_llong((X),(Y),220) +#define get_csv_float_pos220(X,Y) get_csv_float((X),(Y),220) +#define get_csv_uint_pos221(X,Y) get_csv_uint((X),(Y),221) +#define get_csv_ullong_pos221(X,Y) get_csv_ullong((X),(Y),221) +#define get_csv_ip_pos221(X,Y) get_csv_ip((X),(Y),221) +#define get_csv_ipv6_pos221(X,Y) get_csv_ipv6((X),(Y),221) +#define get_csv_string_pos221(X,Y) get_csv_string((X),(Y),221) +#define get_csv_v_str_pos221(X,Y) get_csv_string((X),(Y),221) +#define get_csv_bool_pos221(X,Y) get_csv_bool((X),(Y),221) +#define get_csv_int_pos221(X,Y) get_csv_int((X),(Y),221) +#define get_csv_llong_pos221(X,Y) get_csv_llong((X),(Y),221) +#define get_csv_float_pos221(X,Y) get_csv_float((X),(Y),221) +#define get_csv_uint_pos222(X,Y) get_csv_uint((X),(Y),222) +#define get_csv_ullong_pos222(X,Y) get_csv_ullong((X),(Y),222) +#define get_csv_ip_pos222(X,Y) get_csv_ip((X),(Y),222) +#define get_csv_ipv6_pos222(X,Y) get_csv_ipv6((X),(Y),222) +#define get_csv_string_pos222(X,Y) get_csv_string((X),(Y),222) +#define get_csv_v_str_pos222(X,Y) get_csv_string((X),(Y),222) +#define get_csv_bool_pos222(X,Y) get_csv_bool((X),(Y),222) +#define get_csv_int_pos222(X,Y) get_csv_int((X),(Y),222) +#define get_csv_llong_pos222(X,Y) get_csv_llong((X),(Y),222) +#define get_csv_float_pos222(X,Y) get_csv_float((X),(Y),222) +#define get_csv_uint_pos223(X,Y) get_csv_uint((X),(Y),223) +#define get_csv_ullong_pos223(X,Y) get_csv_ullong((X),(Y),223) +#define get_csv_ip_pos223(X,Y) get_csv_ip((X),(Y),223) +#define get_csv_ipv6_pos223(X,Y) get_csv_ipv6((X),(Y),223) +#define get_csv_string_pos223(X,Y) get_csv_string((X),(Y),223) +#define get_csv_v_str_pos223(X,Y) get_csv_string((X),(Y),223) +#define get_csv_bool_pos223(X,Y) get_csv_bool((X),(Y),223) +#define get_csv_int_pos223(X,Y) get_csv_int((X),(Y),223) +#define get_csv_llong_pos223(X,Y) get_csv_llong((X),(Y),223) +#define get_csv_float_pos223(X,Y) get_csv_float((X),(Y),223) +#define get_csv_uint_pos224(X,Y) get_csv_uint((X),(Y),224) +#define get_csv_ullong_pos224(X,Y) get_csv_ullong((X),(Y),224) +#define get_csv_ip_pos224(X,Y) get_csv_ip((X),(Y),224) +#define get_csv_ipv6_pos224(X,Y) get_csv_ipv6((X),(Y),224) +#define get_csv_string_pos224(X,Y) get_csv_string((X),(Y),224) +#define get_csv_v_str_pos224(X,Y) get_csv_string((X),(Y),224) +#define get_csv_bool_pos224(X,Y) get_csv_bool((X),(Y),224) +#define get_csv_int_pos224(X,Y) get_csv_int((X),(Y),224) +#define get_csv_llong_pos224(X,Y) get_csv_llong((X),(Y),224) +#define get_csv_float_pos224(X,Y) get_csv_float((X),(Y),224) +#define get_csv_uint_pos225(X,Y) get_csv_uint((X),(Y),225) +#define get_csv_ullong_pos225(X,Y) get_csv_ullong((X),(Y),225) +#define get_csv_ip_pos225(X,Y) get_csv_ip((X),(Y),225) +#define get_csv_ipv6_pos225(X,Y) get_csv_ipv6((X),(Y),225) +#define get_csv_string_pos225(X,Y) get_csv_string((X),(Y),225) +#define get_csv_v_str_pos225(X,Y) get_csv_string((X),(Y),225) +#define get_csv_bool_pos225(X,Y) get_csv_bool((X),(Y),225) +#define get_csv_int_pos225(X,Y) get_csv_int((X),(Y),225) +#define get_csv_llong_pos225(X,Y) get_csv_llong((X),(Y),225) +#define get_csv_float_pos225(X,Y) get_csv_float((X),(Y),225) +#define get_csv_uint_pos226(X,Y) get_csv_uint((X),(Y),226) +#define get_csv_ullong_pos226(X,Y) get_csv_ullong((X),(Y),226) +#define get_csv_ip_pos226(X,Y) get_csv_ip((X),(Y),226) +#define get_csv_ipv6_pos226(X,Y) get_csv_ipv6((X),(Y),226) +#define get_csv_string_pos226(X,Y) get_csv_string((X),(Y),226) +#define get_csv_v_str_pos226(X,Y) get_csv_string((X),(Y),226) +#define get_csv_bool_pos226(X,Y) get_csv_bool((X),(Y),226) +#define get_csv_int_pos226(X,Y) get_csv_int((X),(Y),226) +#define get_csv_llong_pos226(X,Y) get_csv_llong((X),(Y),226) +#define get_csv_float_pos226(X,Y) get_csv_float((X),(Y),226) +#define get_csv_uint_pos227(X,Y) get_csv_uint((X),(Y),227) +#define get_csv_ullong_pos227(X,Y) get_csv_ullong((X),(Y),227) +#define get_csv_ip_pos227(X,Y) get_csv_ip((X),(Y),227) +#define get_csv_ipv6_pos227(X,Y) get_csv_ipv6((X),(Y),227) +#define get_csv_string_pos227(X,Y) get_csv_string((X),(Y),227) +#define get_csv_v_str_pos227(X,Y) get_csv_string((X),(Y),227) +#define get_csv_bool_pos227(X,Y) get_csv_bool((X),(Y),227) +#define get_csv_int_pos227(X,Y) get_csv_int((X),(Y),227) +#define get_csv_llong_pos227(X,Y) get_csv_llong((X),(Y),227) +#define get_csv_float_pos227(X,Y) get_csv_float((X),(Y),227) +#define get_csv_uint_pos228(X,Y) get_csv_uint((X),(Y),228) +#define get_csv_ullong_pos228(X,Y) get_csv_ullong((X),(Y),228) +#define get_csv_ip_pos228(X,Y) get_csv_ip((X),(Y),228) +#define get_csv_ipv6_pos228(X,Y) get_csv_ipv6((X),(Y),228) +#define get_csv_string_pos228(X,Y) get_csv_string((X),(Y),228) +#define get_csv_v_str_pos228(X,Y) get_csv_string((X),(Y),228) +#define get_csv_bool_pos228(X,Y) get_csv_bool((X),(Y),228) +#define get_csv_int_pos228(X,Y) get_csv_int((X),(Y),228) +#define get_csv_llong_pos228(X,Y) get_csv_llong((X),(Y),228) +#define get_csv_float_pos228(X,Y) get_csv_float((X),(Y),228) +#define get_csv_uint_pos229(X,Y) get_csv_uint((X),(Y),229) +#define get_csv_ullong_pos229(X,Y) get_csv_ullong((X),(Y),229) +#define get_csv_ip_pos229(X,Y) get_csv_ip((X),(Y),229) +#define get_csv_ipv6_pos229(X,Y) get_csv_ipv6((X),(Y),229) +#define get_csv_string_pos229(X,Y) get_csv_string((X),(Y),229) +#define get_csv_v_str_pos229(X,Y) get_csv_string((X),(Y),229) +#define get_csv_bool_pos229(X,Y) get_csv_bool((X),(Y),229) +#define get_csv_int_pos229(X,Y) get_csv_int((X),(Y),229) +#define get_csv_llong_pos229(X,Y) get_csv_llong((X),(Y),229) +#define get_csv_float_pos229(X,Y) get_csv_float((X),(Y),229) +#define get_csv_uint_pos230(X,Y) get_csv_uint((X),(Y),230) +#define get_csv_ullong_pos230(X,Y) get_csv_ullong((X),(Y),230) +#define get_csv_ip_pos230(X,Y) get_csv_ip((X),(Y),230) +#define get_csv_ipv6_pos230(X,Y) get_csv_ipv6((X),(Y),230) +#define get_csv_string_pos230(X,Y) get_csv_string((X),(Y),230) +#define get_csv_v_str_pos230(X,Y) get_csv_string((X),(Y),230) +#define get_csv_bool_pos230(X,Y) get_csv_bool((X),(Y),230) +#define get_csv_int_pos230(X,Y) get_csv_int((X),(Y),230) +#define get_csv_llong_pos230(X,Y) get_csv_llong((X),(Y),230) +#define get_csv_float_pos230(X,Y) get_csv_float((X),(Y),230) +#define get_csv_uint_pos231(X,Y) get_csv_uint((X),(Y),231) +#define get_csv_ullong_pos231(X,Y) get_csv_ullong((X),(Y),231) +#define get_csv_ip_pos231(X,Y) get_csv_ip((X),(Y),231) +#define get_csv_ipv6_pos231(X,Y) get_csv_ipv6((X),(Y),231) +#define get_csv_string_pos231(X,Y) get_csv_string((X),(Y),231) +#define get_csv_v_str_pos231(X,Y) get_csv_string((X),(Y),231) +#define get_csv_bool_pos231(X,Y) get_csv_bool((X),(Y),231) +#define get_csv_int_pos231(X,Y) get_csv_int((X),(Y),231) +#define get_csv_llong_pos231(X,Y) get_csv_llong((X),(Y),231) +#define get_csv_float_pos231(X,Y) get_csv_float((X),(Y),231) +#define get_csv_uint_pos232(X,Y) get_csv_uint((X),(Y),232) +#define get_csv_ullong_pos232(X,Y) get_csv_ullong((X),(Y),232) +#define get_csv_ip_pos232(X,Y) get_csv_ip((X),(Y),232) +#define get_csv_ipv6_pos232(X,Y) get_csv_ipv6((X),(Y),232) +#define get_csv_string_pos232(X,Y) get_csv_string((X),(Y),232) +#define get_csv_v_str_pos232(X,Y) get_csv_string((X),(Y),232) +#define get_csv_bool_pos232(X,Y) get_csv_bool((X),(Y),232) +#define get_csv_int_pos232(X,Y) get_csv_int((X),(Y),232) +#define get_csv_llong_pos232(X,Y) get_csv_llong((X),(Y),232) +#define get_csv_float_pos232(X,Y) get_csv_float((X),(Y),232) +#define get_csv_uint_pos233(X,Y) get_csv_uint((X),(Y),233) +#define get_csv_ullong_pos233(X,Y) get_csv_ullong((X),(Y),233) +#define get_csv_ip_pos233(X,Y) get_csv_ip((X),(Y),233) +#define get_csv_ipv6_pos233(X,Y) get_csv_ipv6((X),(Y),233) +#define get_csv_string_pos233(X,Y) get_csv_string((X),(Y),233) +#define get_csv_v_str_pos233(X,Y) get_csv_string((X),(Y),233) +#define get_csv_bool_pos233(X,Y) get_csv_bool((X),(Y),233) +#define get_csv_int_pos233(X,Y) get_csv_int((X),(Y),233) +#define get_csv_llong_pos233(X,Y) get_csv_llong((X),(Y),233) +#define get_csv_float_pos233(X,Y) get_csv_float((X),(Y),233) +#define get_csv_uint_pos234(X,Y) get_csv_uint((X),(Y),234) +#define get_csv_ullong_pos234(X,Y) get_csv_ullong((X),(Y),234) +#define get_csv_ip_pos234(X,Y) get_csv_ip((X),(Y),234) +#define get_csv_ipv6_pos234(X,Y) get_csv_ipv6((X),(Y),234) +#define get_csv_string_pos234(X,Y) get_csv_string((X),(Y),234) +#define get_csv_v_str_pos234(X,Y) get_csv_string((X),(Y),234) +#define get_csv_bool_pos234(X,Y) get_csv_bool((X),(Y),234) +#define get_csv_int_pos234(X,Y) get_csv_int((X),(Y),234) +#define get_csv_llong_pos234(X,Y) get_csv_llong((X),(Y),234) +#define get_csv_float_pos234(X,Y) get_csv_float((X),(Y),234) +#define get_csv_uint_pos235(X,Y) get_csv_uint((X),(Y),235) +#define get_csv_ullong_pos235(X,Y) get_csv_ullong((X),(Y),235) +#define get_csv_ip_pos235(X,Y) get_csv_ip((X),(Y),235) +#define get_csv_ipv6_pos235(X,Y) get_csv_ipv6((X),(Y),235) +#define get_csv_string_pos235(X,Y) get_csv_string((X),(Y),235) +#define get_csv_v_str_pos235(X,Y) get_csv_string((X),(Y),235) +#define get_csv_bool_pos235(X,Y) get_csv_bool((X),(Y),235) +#define get_csv_int_pos235(X,Y) get_csv_int((X),(Y),235) +#define get_csv_llong_pos235(X,Y) get_csv_llong((X),(Y),235) +#define get_csv_float_pos235(X,Y) get_csv_float((X),(Y),235) +#define get_csv_uint_pos236(X,Y) get_csv_uint((X),(Y),236) +#define get_csv_ullong_pos236(X,Y) get_csv_ullong((X),(Y),236) +#define get_csv_ip_pos236(X,Y) get_csv_ip((X),(Y),236) +#define get_csv_ipv6_pos236(X,Y) get_csv_ipv6((X),(Y),236) +#define get_csv_string_pos236(X,Y) get_csv_string((X),(Y),236) +#define get_csv_v_str_pos236(X,Y) get_csv_string((X),(Y),236) +#define get_csv_bool_pos236(X,Y) get_csv_bool((X),(Y),236) +#define get_csv_int_pos236(X,Y) get_csv_int((X),(Y),236) +#define get_csv_llong_pos236(X,Y) get_csv_llong((X),(Y),236) +#define get_csv_float_pos236(X,Y) get_csv_float((X),(Y),236) +#define get_csv_uint_pos237(X,Y) get_csv_uint((X),(Y),237) +#define get_csv_ullong_pos237(X,Y) get_csv_ullong((X),(Y),237) +#define get_csv_ip_pos237(X,Y) get_csv_ip((X),(Y),237) +#define get_csv_ipv6_pos237(X,Y) get_csv_ipv6((X),(Y),237) +#define get_csv_string_pos237(X,Y) get_csv_string((X),(Y),237) +#define get_csv_v_str_pos237(X,Y) get_csv_string((X),(Y),237) +#define get_csv_bool_pos237(X,Y) get_csv_bool((X),(Y),237) +#define get_csv_int_pos237(X,Y) get_csv_int((X),(Y),237) +#define get_csv_llong_pos237(X,Y) get_csv_llong((X),(Y),237) +#define get_csv_float_pos237(X,Y) get_csv_float((X),(Y),237) +#define get_csv_uint_pos238(X,Y) get_csv_uint((X),(Y),238) +#define get_csv_ullong_pos238(X,Y) get_csv_ullong((X),(Y),238) +#define get_csv_ip_pos238(X,Y) get_csv_ip((X),(Y),238) +#define get_csv_ipv6_pos238(X,Y) get_csv_ipv6((X),(Y),238) +#define get_csv_string_pos238(X,Y) get_csv_string((X),(Y),238) +#define get_csv_v_str_pos238(X,Y) get_csv_string((X),(Y),238) +#define get_csv_bool_pos238(X,Y) get_csv_bool((X),(Y),238) +#define get_csv_int_pos238(X,Y) get_csv_int((X),(Y),238) +#define get_csv_llong_pos238(X,Y) get_csv_llong((X),(Y),238) +#define get_csv_float_pos238(X,Y) get_csv_float((X),(Y),238) +#define get_csv_uint_pos239(X,Y) get_csv_uint((X),(Y),239) +#define get_csv_ullong_pos239(X,Y) get_csv_ullong((X),(Y),239) +#define get_csv_ip_pos239(X,Y) get_csv_ip((X),(Y),239) +#define get_csv_ipv6_pos239(X,Y) get_csv_ipv6((X),(Y),239) +#define get_csv_string_pos239(X,Y) get_csv_string((X),(Y),239) +#define get_csv_v_str_pos239(X,Y) get_csv_string((X),(Y),239) +#define get_csv_bool_pos239(X,Y) get_csv_bool((X),(Y),239) +#define get_csv_int_pos239(X,Y) get_csv_int((X),(Y),239) +#define get_csv_llong_pos239(X,Y) get_csv_llong((X),(Y),239) +#define get_csv_float_pos239(X,Y) get_csv_float((X),(Y),239) +#define get_csv_uint_pos240(X,Y) get_csv_uint((X),(Y),240) +#define get_csv_ullong_pos240(X,Y) get_csv_ullong((X),(Y),240) +#define get_csv_ip_pos240(X,Y) get_csv_ip((X),(Y),240) +#define get_csv_ipv6_pos240(X,Y) get_csv_ipv6((X),(Y),240) +#define get_csv_string_pos240(X,Y) get_csv_string((X),(Y),240) +#define get_csv_v_str_pos240(X,Y) get_csv_string((X),(Y),240) +#define get_csv_bool_pos240(X,Y) get_csv_bool((X),(Y),240) +#define get_csv_int_pos240(X,Y) get_csv_int((X),(Y),240) +#define get_csv_llong_pos240(X,Y) get_csv_llong((X),(Y),240) +#define get_csv_float_pos240(X,Y) get_csv_float((X),(Y),240) +#define get_csv_uint_pos241(X,Y) get_csv_uint((X),(Y),241) +#define get_csv_ullong_pos241(X,Y) get_csv_ullong((X),(Y),241) +#define get_csv_ip_pos241(X,Y) get_csv_ip((X),(Y),241) +#define get_csv_ipv6_pos241(X,Y) get_csv_ipv6((X),(Y),241) +#define get_csv_string_pos241(X,Y) get_csv_string((X),(Y),241) +#define get_csv_v_str_pos241(X,Y) get_csv_string((X),(Y),241) +#define get_csv_bool_pos241(X,Y) get_csv_bool((X),(Y),241) +#define get_csv_int_pos241(X,Y) get_csv_int((X),(Y),241) +#define get_csv_llong_pos241(X,Y) get_csv_llong((X),(Y),241) +#define get_csv_float_pos241(X,Y) get_csv_float((X),(Y),241) +#define get_csv_uint_pos242(X,Y) get_csv_uint((X),(Y),242) +#define get_csv_ullong_pos242(X,Y) get_csv_ullong((X),(Y),242) +#define get_csv_ip_pos242(X,Y) get_csv_ip((X),(Y),242) +#define get_csv_ipv6_pos242(X,Y) get_csv_ipv6((X),(Y),242) +#define get_csv_string_pos242(X,Y) get_csv_string((X),(Y),242) +#define get_csv_v_str_pos242(X,Y) get_csv_string((X),(Y),242) +#define get_csv_bool_pos242(X,Y) get_csv_bool((X),(Y),242) +#define get_csv_int_pos242(X,Y) get_csv_int((X),(Y),242) +#define get_csv_llong_pos242(X,Y) get_csv_llong((X),(Y),242) +#define get_csv_float_pos242(X,Y) get_csv_float((X),(Y),242) +#define get_csv_uint_pos243(X,Y) get_csv_uint((X),(Y),243) +#define get_csv_ullong_pos243(X,Y) get_csv_ullong((X),(Y),243) +#define get_csv_ip_pos243(X,Y) get_csv_ip((X),(Y),243) +#define get_csv_ipv6_pos243(X,Y) get_csv_ipv6((X),(Y),243) +#define get_csv_string_pos243(X,Y) get_csv_string((X),(Y),243) +#define get_csv_v_str_pos243(X,Y) get_csv_string((X),(Y),243) +#define get_csv_bool_pos243(X,Y) get_csv_bool((X),(Y),243) +#define get_csv_int_pos243(X,Y) get_csv_int((X),(Y),243) +#define get_csv_llong_pos243(X,Y) get_csv_llong((X),(Y),243) +#define get_csv_float_pos243(X,Y) get_csv_float((X),(Y),243) +#define get_csv_uint_pos244(X,Y) get_csv_uint((X),(Y),244) +#define get_csv_ullong_pos244(X,Y) get_csv_ullong((X),(Y),244) +#define get_csv_ip_pos244(X,Y) get_csv_ip((X),(Y),244) +#define get_csv_ipv6_pos244(X,Y) get_csv_ipv6((X),(Y),244) +#define get_csv_string_pos244(X,Y) get_csv_string((X),(Y),244) +#define get_csv_v_str_pos244(X,Y) get_csv_string((X),(Y),244) +#define get_csv_bool_pos244(X,Y) get_csv_bool((X),(Y),244) +#define get_csv_int_pos244(X,Y) get_csv_int((X),(Y),244) +#define get_csv_llong_pos244(X,Y) get_csv_llong((X),(Y),244) +#define get_csv_float_pos244(X,Y) get_csv_float((X),(Y),244) +#define get_csv_uint_pos245(X,Y) get_csv_uint((X),(Y),245) +#define get_csv_ullong_pos245(X,Y) get_csv_ullong((X),(Y),245) +#define get_csv_ip_pos245(X,Y) get_csv_ip((X),(Y),245) +#define get_csv_ipv6_pos245(X,Y) get_csv_ipv6((X),(Y),245) +#define get_csv_string_pos245(X,Y) get_csv_string((X),(Y),245) +#define get_csv_v_str_pos245(X,Y) get_csv_string((X),(Y),245) +#define get_csv_bool_pos245(X,Y) get_csv_bool((X),(Y),245) +#define get_csv_int_pos245(X,Y) get_csv_int((X),(Y),245) +#define get_csv_llong_pos245(X,Y) get_csv_llong((X),(Y),245) +#define get_csv_float_pos245(X,Y) get_csv_float((X),(Y),245) +#define get_csv_uint_pos246(X,Y) get_csv_uint((X),(Y),246) +#define get_csv_ullong_pos246(X,Y) get_csv_ullong((X),(Y),246) +#define get_csv_ip_pos246(X,Y) get_csv_ip((X),(Y),246) +#define get_csv_ipv6_pos246(X,Y) get_csv_ipv6((X),(Y),246) +#define get_csv_string_pos246(X,Y) get_csv_string((X),(Y),246) +#define get_csv_v_str_pos246(X,Y) get_csv_string((X),(Y),246) +#define get_csv_bool_pos246(X,Y) get_csv_bool((X),(Y),246) +#define get_csv_int_pos246(X,Y) get_csv_int((X),(Y),246) +#define get_csv_llong_pos246(X,Y) get_csv_llong((X),(Y),246) +#define get_csv_float_pos246(X,Y) get_csv_float((X),(Y),246) +#define get_csv_uint_pos247(X,Y) get_csv_uint((X),(Y),247) +#define get_csv_ullong_pos247(X,Y) get_csv_ullong((X),(Y),247) +#define get_csv_ip_pos247(X,Y) get_csv_ip((X),(Y),247) +#define get_csv_ipv6_pos247(X,Y) get_csv_ipv6((X),(Y),247) +#define get_csv_string_pos247(X,Y) get_csv_string((X),(Y),247) +#define get_csv_v_str_pos247(X,Y) get_csv_string((X),(Y),247) +#define get_csv_bool_pos247(X,Y) get_csv_bool((X),(Y),247) +#define get_csv_int_pos247(X,Y) get_csv_int((X),(Y),247) +#define get_csv_llong_pos247(X,Y) get_csv_llong((X),(Y),247) +#define get_csv_float_pos247(X,Y) get_csv_float((X),(Y),247) +#define get_csv_uint_pos248(X,Y) get_csv_uint((X),(Y),248) +#define get_csv_ullong_pos248(X,Y) get_csv_ullong((X),(Y),248) +#define get_csv_ip_pos248(X,Y) get_csv_ip((X),(Y),248) +#define get_csv_ipv6_pos248(X,Y) get_csv_ipv6((X),(Y),248) +#define get_csv_string_pos248(X,Y) get_csv_string((X),(Y),248) +#define get_csv_v_str_pos248(X,Y) get_csv_string((X),(Y),248) +#define get_csv_bool_pos248(X,Y) get_csv_bool((X),(Y),248) +#define get_csv_int_pos248(X,Y) get_csv_int((X),(Y),248) +#define get_csv_llong_pos248(X,Y) get_csv_llong((X),(Y),248) +#define get_csv_float_pos248(X,Y) get_csv_float((X),(Y),248) +#define get_csv_uint_pos249(X,Y) get_csv_uint((X),(Y),249) +#define get_csv_ullong_pos249(X,Y) get_csv_ullong((X),(Y),249) +#define get_csv_ip_pos249(X,Y) get_csv_ip((X),(Y),249) +#define get_csv_ipv6_pos249(X,Y) get_csv_ipv6((X),(Y),249) +#define get_csv_string_pos249(X,Y) get_csv_string((X),(Y),249) +#define get_csv_v_str_pos249(X,Y) get_csv_string((X),(Y),249) +#define get_csv_bool_pos249(X,Y) get_csv_bool((X),(Y),249) +#define get_csv_int_pos249(X,Y) get_csv_int((X),(Y),249) +#define get_csv_llong_pos249(X,Y) get_csv_llong((X),(Y),249) +#define get_csv_float_pos249(X,Y) get_csv_float((X),(Y),249) +#define get_csv_uint_pos250(X,Y) get_csv_uint((X),(Y),250) +#define get_csv_ullong_pos250(X,Y) get_csv_ullong((X),(Y),250) +#define get_csv_ip_pos250(X,Y) get_csv_ip((X),(Y),250) +#define get_csv_ipv6_pos250(X,Y) get_csv_ipv6((X),(Y),250) +#define get_csv_string_pos250(X,Y) get_csv_string((X),(Y),250) +#define get_csv_v_str_pos250(X,Y) get_csv_string((X),(Y),250) +#define get_csv_bool_pos250(X,Y) get_csv_bool((X),(Y),250) +#define get_csv_int_pos250(X,Y) get_csv_int((X),(Y),250) +#define get_csv_llong_pos250(X,Y) get_csv_llong((X),(Y),250) +#define get_csv_float_pos250(X,Y) get_csv_float((X),(Y),250) +#define get_csv_uint_pos251(X,Y) get_csv_uint((X),(Y),251) +#define get_csv_ullong_pos251(X,Y) get_csv_ullong((X),(Y),251) +#define get_csv_ip_pos251(X,Y) get_csv_ip((X),(Y),251) +#define get_csv_ipv6_pos251(X,Y) get_csv_ipv6((X),(Y),251) +#define get_csv_string_pos251(X,Y) get_csv_string((X),(Y),251) +#define get_csv_v_str_pos251(X,Y) get_csv_string((X),(Y),251) +#define get_csv_bool_pos251(X,Y) get_csv_bool((X),(Y),251) +#define get_csv_int_pos251(X,Y) get_csv_int((X),(Y),251) +#define get_csv_llong_pos251(X,Y) get_csv_llong((X),(Y),251) +#define get_csv_float_pos251(X,Y) get_csv_float((X),(Y),251) +#define get_csv_uint_pos252(X,Y) get_csv_uint((X),(Y),252) +#define get_csv_ullong_pos252(X,Y) get_csv_ullong((X),(Y),252) +#define get_csv_ip_pos252(X,Y) get_csv_ip((X),(Y),252) +#define get_csv_ipv6_pos252(X,Y) get_csv_ipv6((X),(Y),252) +#define get_csv_string_pos252(X,Y) get_csv_string((X),(Y),252) +#define get_csv_v_str_pos252(X,Y) get_csv_string((X),(Y),252) +#define get_csv_bool_pos252(X,Y) get_csv_bool((X),(Y),252) +#define get_csv_int_pos252(X,Y) get_csv_int((X),(Y),252) +#define get_csv_llong_pos252(X,Y) get_csv_llong((X),(Y),252) +#define get_csv_float_pos252(X,Y) get_csv_float((X),(Y),252) +#define get_csv_uint_pos253(X,Y) get_csv_uint((X),(Y),253) +#define get_csv_ullong_pos253(X,Y) get_csv_ullong((X),(Y),253) +#define get_csv_ip_pos253(X,Y) get_csv_ip((X),(Y),253) +#define get_csv_ipv6_pos253(X,Y) get_csv_ipv6((X),(Y),253) +#define get_csv_string_pos253(X,Y) get_csv_string((X),(Y),253) +#define get_csv_v_str_pos253(X,Y) get_csv_string((X),(Y),253) +#define get_csv_bool_pos253(X,Y) get_csv_bool((X),(Y),253) +#define get_csv_int_pos253(X,Y) get_csv_int((X),(Y),253) +#define get_csv_llong_pos253(X,Y) get_csv_llong((X),(Y),253) +#define get_csv_float_pos253(X,Y) get_csv_float((X),(Y),253) +#define get_csv_uint_pos254(X,Y) get_csv_uint((X),(Y),254) +#define get_csv_ullong_pos254(X,Y) get_csv_ullong((X),(Y),254) +#define get_csv_ip_pos254(X,Y) get_csv_ip((X),(Y),254) +#define get_csv_ipv6_pos254(X,Y) get_csv_ipv6((X),(Y),254) +#define get_csv_string_pos254(X,Y) get_csv_string((X),(Y),254) +#define get_csv_v_str_pos254(X,Y) get_csv_string((X),(Y),254) +#define get_csv_bool_pos254(X,Y) get_csv_bool((X),(Y),254) +#define get_csv_int_pos254(X,Y) get_csv_int((X),(Y),254) +#define get_csv_llong_pos254(X,Y) get_csv_llong((X),(Y),254) +#define get_csv_float_pos254(X,Y) get_csv_float((X),(Y),254) +#define get_csv_uint_pos255(X,Y) get_csv_uint((X),(Y),255) +#define get_csv_ullong_pos255(X,Y) get_csv_ullong((X),(Y),255) +#define get_csv_ip_pos255(X,Y) get_csv_ip((X),(Y),255) +#define get_csv_ipv6_pos255(X,Y) get_csv_ipv6((X),(Y),255) +#define get_csv_string_pos255(X,Y) get_csv_string((X),(Y),255) +#define get_csv_v_str_pos255(X,Y) get_csv_string((X),(Y),255) +#define get_csv_bool_pos255(X,Y) get_csv_bool((X),(Y),255) +#define get_csv_int_pos255(X,Y) get_csv_int((X),(Y),255) +#define get_csv_llong_pos255(X,Y) get_csv_llong((X),(Y),255) +#define get_csv_float_pos255(X,Y) get_csv_float((X),(Y),255) +#define get_csv_uint_pos256(X,Y) get_csv_uint((X),(Y),256) +#define get_csv_ullong_pos256(X,Y) get_csv_ullong((X),(Y),256) +#define get_csv_ip_pos256(X,Y) get_csv_ip((X),(Y),256) +#define get_csv_ipv6_pos256(X,Y) get_csv_ipv6((X),(Y),256) +#define get_csv_string_pos256(X,Y) get_csv_string((X),(Y),256) +#define get_csv_v_str_pos256(X,Y) get_csv_string((X),(Y),256) +#define get_csv_bool_pos256(X,Y) get_csv_bool((X),(Y),256) +#define get_csv_int_pos256(X,Y) get_csv_int((X),(Y),256) +#define get_csv_llong_pos256(X,Y) get_csv_llong((X),(Y),256) +#define get_csv_float_pos256(X,Y) get_csv_float((X),(Y),256) +#define get_csv_uint_pos257(X,Y) get_csv_uint((X),(Y),257) +#define get_csv_ullong_pos257(X,Y) get_csv_ullong((X),(Y),257) +#define get_csv_ip_pos257(X,Y) get_csv_ip((X),(Y),257) +#define get_csv_ipv6_pos257(X,Y) get_csv_ipv6((X),(Y),257) +#define get_csv_string_pos257(X,Y) get_csv_string((X),(Y),257) +#define get_csv_v_str_pos257(X,Y) get_csv_string((X),(Y),257) +#define get_csv_bool_pos257(X,Y) get_csv_bool((X),(Y),257) +#define get_csv_int_pos257(X,Y) get_csv_int((X),(Y),257) +#define get_csv_llong_pos257(X,Y) get_csv_llong((X),(Y),257) +#define get_csv_float_pos257(X,Y) get_csv_float((X),(Y),257) +#define get_csv_uint_pos258(X,Y) get_csv_uint((X),(Y),258) +#define get_csv_ullong_pos258(X,Y) get_csv_ullong((X),(Y),258) +#define get_csv_ip_pos258(X,Y) get_csv_ip((X),(Y),258) +#define get_csv_ipv6_pos258(X,Y) get_csv_ipv6((X),(Y),258) +#define get_csv_string_pos258(X,Y) get_csv_string((X),(Y),258) +#define get_csv_v_str_pos258(X,Y) get_csv_string((X),(Y),258) +#define get_csv_bool_pos258(X,Y) get_csv_bool((X),(Y),258) +#define get_csv_int_pos258(X,Y) get_csv_int((X),(Y),258) +#define get_csv_llong_pos258(X,Y) get_csv_llong((X),(Y),258) +#define get_csv_float_pos258(X,Y) get_csv_float((X),(Y),258) +#define get_csv_uint_pos259(X,Y) get_csv_uint((X),(Y),259) +#define get_csv_ullong_pos259(X,Y) get_csv_ullong((X),(Y),259) +#define get_csv_ip_pos259(X,Y) get_csv_ip((X),(Y),259) +#define get_csv_ipv6_pos259(X,Y) get_csv_ipv6((X),(Y),259) +#define get_csv_string_pos259(X,Y) get_csv_string((X),(Y),259) +#define get_csv_v_str_pos259(X,Y) get_csv_string((X),(Y),259) +#define get_csv_bool_pos259(X,Y) get_csv_bool((X),(Y),259) +#define get_csv_int_pos259(X,Y) get_csv_int((X),(Y),259) +#define get_csv_llong_pos259(X,Y) get_csv_llong((X),(Y),259) +#define get_csv_float_pos259(X,Y) get_csv_float((X),(Y),259) +#define get_csv_uint_pos260(X,Y) get_csv_uint((X),(Y),260) +#define get_csv_ullong_pos260(X,Y) get_csv_ullong((X),(Y),260) +#define get_csv_ip_pos260(X,Y) get_csv_ip((X),(Y),260) +#define get_csv_ipv6_pos260(X,Y) get_csv_ipv6((X),(Y),260) +#define get_csv_string_pos260(X,Y) get_csv_string((X),(Y),260) +#define get_csv_v_str_pos260(X,Y) get_csv_string((X),(Y),260) +#define get_csv_bool_pos260(X,Y) get_csv_bool((X),(Y),260) +#define get_csv_int_pos260(X,Y) get_csv_int((X),(Y),260) +#define get_csv_llong_pos260(X,Y) get_csv_llong((X),(Y),260) +#define get_csv_float_pos260(X,Y) get_csv_float((X),(Y),260) +#define get_csv_uint_pos261(X,Y) get_csv_uint((X),(Y),261) +#define get_csv_ullong_pos261(X,Y) get_csv_ullong((X),(Y),261) +#define get_csv_ip_pos261(X,Y) get_csv_ip((X),(Y),261) +#define get_csv_ipv6_pos261(X,Y) get_csv_ipv6((X),(Y),261) +#define get_csv_string_pos261(X,Y) get_csv_string((X),(Y),261) +#define get_csv_v_str_pos261(X,Y) get_csv_string((X),(Y),261) +#define get_csv_bool_pos261(X,Y) get_csv_bool((X),(Y),261) +#define get_csv_int_pos261(X,Y) get_csv_int((X),(Y),261) +#define get_csv_llong_pos261(X,Y) get_csv_llong((X),(Y),261) +#define get_csv_float_pos261(X,Y) get_csv_float((X),(Y),261) +#define get_csv_uint_pos262(X,Y) get_csv_uint((X),(Y),262) +#define get_csv_ullong_pos262(X,Y) get_csv_ullong((X),(Y),262) +#define get_csv_ip_pos262(X,Y) get_csv_ip((X),(Y),262) +#define get_csv_ipv6_pos262(X,Y) get_csv_ipv6((X),(Y),262) +#define get_csv_string_pos262(X,Y) get_csv_string((X),(Y),262) +#define get_csv_v_str_pos262(X,Y) get_csv_string((X),(Y),262) +#define get_csv_bool_pos262(X,Y) get_csv_bool((X),(Y),262) +#define get_csv_int_pos262(X,Y) get_csv_int((X),(Y),262) +#define get_csv_llong_pos262(X,Y) get_csv_llong((X),(Y),262) +#define get_csv_float_pos262(X,Y) get_csv_float((X),(Y),262) +#define get_csv_uint_pos263(X,Y) get_csv_uint((X),(Y),263) +#define get_csv_ullong_pos263(X,Y) get_csv_ullong((X),(Y),263) +#define get_csv_ip_pos263(X,Y) get_csv_ip((X),(Y),263) +#define get_csv_ipv6_pos263(X,Y) get_csv_ipv6((X),(Y),263) +#define get_csv_string_pos263(X,Y) get_csv_string((X),(Y),263) +#define get_csv_v_str_pos263(X,Y) get_csv_string((X),(Y),263) +#define get_csv_bool_pos263(X,Y) get_csv_bool((X),(Y),263) +#define get_csv_int_pos263(X,Y) get_csv_int((X),(Y),263) +#define get_csv_llong_pos263(X,Y) get_csv_llong((X),(Y),263) +#define get_csv_float_pos263(X,Y) get_csv_float((X),(Y),263) +#define get_csv_uint_pos264(X,Y) get_csv_uint((X),(Y),264) +#define get_csv_ullong_pos264(X,Y) get_csv_ullong((X),(Y),264) +#define get_csv_ip_pos264(X,Y) get_csv_ip((X),(Y),264) +#define get_csv_ipv6_pos264(X,Y) get_csv_ipv6((X),(Y),264) +#define get_csv_string_pos264(X,Y) get_csv_string((X),(Y),264) +#define get_csv_v_str_pos264(X,Y) get_csv_string((X),(Y),264) +#define get_csv_bool_pos264(X,Y) get_csv_bool((X),(Y),264) +#define get_csv_int_pos264(X,Y) get_csv_int((X),(Y),264) +#define get_csv_llong_pos264(X,Y) get_csv_llong((X),(Y),264) +#define get_csv_float_pos264(X,Y) get_csv_float((X),(Y),264) +#define get_csv_uint_pos265(X,Y) get_csv_uint((X),(Y),265) +#define get_csv_ullong_pos265(X,Y) get_csv_ullong((X),(Y),265) +#define get_csv_ip_pos265(X,Y) get_csv_ip((X),(Y),265) +#define get_csv_ipv6_pos265(X,Y) get_csv_ipv6((X),(Y),265) +#define get_csv_string_pos265(X,Y) get_csv_string((X),(Y),265) +#define get_csv_v_str_pos265(X,Y) get_csv_string((X),(Y),265) +#define get_csv_bool_pos265(X,Y) get_csv_bool((X),(Y),265) +#define get_csv_int_pos265(X,Y) get_csv_int((X),(Y),265) +#define get_csv_llong_pos265(X,Y) get_csv_llong((X),(Y),265) +#define get_csv_float_pos265(X,Y) get_csv_float((X),(Y),265) +#define get_csv_uint_pos266(X,Y) get_csv_uint((X),(Y),266) +#define get_csv_ullong_pos266(X,Y) get_csv_ullong((X),(Y),266) +#define get_csv_ip_pos266(X,Y) get_csv_ip((X),(Y),266) +#define get_csv_ipv6_pos266(X,Y) get_csv_ipv6((X),(Y),266) +#define get_csv_string_pos266(X,Y) get_csv_string((X),(Y),266) +#define get_csv_v_str_pos266(X,Y) get_csv_string((X),(Y),266) +#define get_csv_bool_pos266(X,Y) get_csv_bool((X),(Y),266) +#define get_csv_int_pos266(X,Y) get_csv_int((X),(Y),266) +#define get_csv_llong_pos266(X,Y) get_csv_llong((X),(Y),266) +#define get_csv_float_pos266(X,Y) get_csv_float((X),(Y),266) +#define get_csv_uint_pos267(X,Y) get_csv_uint((X),(Y),267) +#define get_csv_ullong_pos267(X,Y) get_csv_ullong((X),(Y),267) +#define get_csv_ip_pos267(X,Y) get_csv_ip((X),(Y),267) +#define get_csv_ipv6_pos267(X,Y) get_csv_ipv6((X),(Y),267) +#define get_csv_string_pos267(X,Y) get_csv_string((X),(Y),267) +#define get_csv_v_str_pos267(X,Y) get_csv_string((X),(Y),267) +#define get_csv_bool_pos267(X,Y) get_csv_bool((X),(Y),267) +#define get_csv_int_pos267(X,Y) get_csv_int((X),(Y),267) +#define get_csv_llong_pos267(X,Y) get_csv_llong((X),(Y),267) +#define get_csv_float_pos267(X,Y) get_csv_float((X),(Y),267) +#define get_csv_uint_pos268(X,Y) get_csv_uint((X),(Y),268) +#define get_csv_ullong_pos268(X,Y) get_csv_ullong((X),(Y),268) +#define get_csv_ip_pos268(X,Y) get_csv_ip((X),(Y),268) +#define get_csv_ipv6_pos268(X,Y) get_csv_ipv6((X),(Y),268) +#define get_csv_string_pos268(X,Y) get_csv_string((X),(Y),268) +#define get_csv_v_str_pos268(X,Y) get_csv_string((X),(Y),268) +#define get_csv_bool_pos268(X,Y) get_csv_bool((X),(Y),268) +#define get_csv_int_pos268(X,Y) get_csv_int((X),(Y),268) +#define get_csv_llong_pos268(X,Y) get_csv_llong((X),(Y),268) +#define get_csv_float_pos268(X,Y) get_csv_float((X),(Y),268) +#define get_csv_uint_pos269(X,Y) get_csv_uint((X),(Y),269) +#define get_csv_ullong_pos269(X,Y) get_csv_ullong((X),(Y),269) +#define get_csv_ip_pos269(X,Y) get_csv_ip((X),(Y),269) +#define get_csv_ipv6_pos269(X,Y) get_csv_ipv6((X),(Y),269) +#define get_csv_string_pos269(X,Y) get_csv_string((X),(Y),269) +#define get_csv_v_str_pos269(X,Y) get_csv_string((X),(Y),269) +#define get_csv_bool_pos269(X,Y) get_csv_bool((X),(Y),269) +#define get_csv_int_pos269(X,Y) get_csv_int((X),(Y),269) +#define get_csv_llong_pos269(X,Y) get_csv_llong((X),(Y),269) +#define get_csv_float_pos269(X,Y) get_csv_float((X),(Y),269) +#define get_csv_uint_pos270(X,Y) get_csv_uint((X),(Y),270) +#define get_csv_ullong_pos270(X,Y) get_csv_ullong((X),(Y),270) +#define get_csv_ip_pos270(X,Y) get_csv_ip((X),(Y),270) +#define get_csv_ipv6_pos270(X,Y) get_csv_ipv6((X),(Y),270) +#define get_csv_string_pos270(X,Y) get_csv_string((X),(Y),270) +#define get_csv_v_str_pos270(X,Y) get_csv_string((X),(Y),270) +#define get_csv_bool_pos270(X,Y) get_csv_bool((X),(Y),270) +#define get_csv_int_pos270(X,Y) get_csv_int((X),(Y),270) +#define get_csv_llong_pos270(X,Y) get_csv_llong((X),(Y),270) +#define get_csv_float_pos270(X,Y) get_csv_float((X),(Y),270) +#define get_csv_uint_pos271(X,Y) get_csv_uint((X),(Y),271) +#define get_csv_ullong_pos271(X,Y) get_csv_ullong((X),(Y),271) +#define get_csv_ip_pos271(X,Y) get_csv_ip((X),(Y),271) +#define get_csv_ipv6_pos271(X,Y) get_csv_ipv6((X),(Y),271) +#define get_csv_string_pos271(X,Y) get_csv_string((X),(Y),271) +#define get_csv_v_str_pos271(X,Y) get_csv_string((X),(Y),271) +#define get_csv_bool_pos271(X,Y) get_csv_bool((X),(Y),271) +#define get_csv_int_pos271(X,Y) get_csv_int((X),(Y),271) +#define get_csv_llong_pos271(X,Y) get_csv_llong((X),(Y),271) +#define get_csv_float_pos271(X,Y) get_csv_float((X),(Y),271) +#define get_csv_uint_pos272(X,Y) get_csv_uint((X),(Y),272) +#define get_csv_ullong_pos272(X,Y) get_csv_ullong((X),(Y),272) +#define get_csv_ip_pos272(X,Y) get_csv_ip((X),(Y),272) +#define get_csv_ipv6_pos272(X,Y) get_csv_ipv6((X),(Y),272) +#define get_csv_string_pos272(X,Y) get_csv_string((X),(Y),272) +#define get_csv_v_str_pos272(X,Y) get_csv_string((X),(Y),272) +#define get_csv_bool_pos272(X,Y) get_csv_bool((X),(Y),272) +#define get_csv_int_pos272(X,Y) get_csv_int((X),(Y),272) +#define get_csv_llong_pos272(X,Y) get_csv_llong((X),(Y),272) +#define get_csv_float_pos272(X,Y) get_csv_float((X),(Y),272) +#define get_csv_uint_pos273(X,Y) get_csv_uint((X),(Y),273) +#define get_csv_ullong_pos273(X,Y) get_csv_ullong((X),(Y),273) +#define get_csv_ip_pos273(X,Y) get_csv_ip((X),(Y),273) +#define get_csv_ipv6_pos273(X,Y) get_csv_ipv6((X),(Y),273) +#define get_csv_string_pos273(X,Y) get_csv_string((X),(Y),273) +#define get_csv_v_str_pos273(X,Y) get_csv_string((X),(Y),273) +#define get_csv_bool_pos273(X,Y) get_csv_bool((X),(Y),273) +#define get_csv_int_pos273(X,Y) get_csv_int((X),(Y),273) +#define get_csv_llong_pos273(X,Y) get_csv_llong((X),(Y),273) +#define get_csv_float_pos273(X,Y) get_csv_float((X),(Y),273) +#define get_csv_uint_pos274(X,Y) get_csv_uint((X),(Y),274) +#define get_csv_ullong_pos274(X,Y) get_csv_ullong((X),(Y),274) +#define get_csv_ip_pos274(X,Y) get_csv_ip((X),(Y),274) +#define get_csv_ipv6_pos274(X,Y) get_csv_ipv6((X),(Y),274) +#define get_csv_string_pos274(X,Y) get_csv_string((X),(Y),274) +#define get_csv_v_str_pos274(X,Y) get_csv_string((X),(Y),274) +#define get_csv_bool_pos274(X,Y) get_csv_bool((X),(Y),274) +#define get_csv_int_pos274(X,Y) get_csv_int((X),(Y),274) +#define get_csv_llong_pos274(X,Y) get_csv_llong((X),(Y),274) +#define get_csv_float_pos274(X,Y) get_csv_float((X),(Y),274) +#define get_csv_uint_pos275(X,Y) get_csv_uint((X),(Y),275) +#define get_csv_ullong_pos275(X,Y) get_csv_ullong((X),(Y),275) +#define get_csv_ip_pos275(X,Y) get_csv_ip((X),(Y),275) +#define get_csv_ipv6_pos275(X,Y) get_csv_ipv6((X),(Y),275) +#define get_csv_string_pos275(X,Y) get_csv_string((X),(Y),275) +#define get_csv_v_str_pos275(X,Y) get_csv_string((X),(Y),275) +#define get_csv_bool_pos275(X,Y) get_csv_bool((X),(Y),275) +#define get_csv_int_pos275(X,Y) get_csv_int((X),(Y),275) +#define get_csv_llong_pos275(X,Y) get_csv_llong((X),(Y),275) +#define get_csv_float_pos275(X,Y) get_csv_float((X),(Y),275) +#define get_csv_uint_pos276(X,Y) get_csv_uint((X),(Y),276) +#define get_csv_ullong_pos276(X,Y) get_csv_ullong((X),(Y),276) +#define get_csv_ip_pos276(X,Y) get_csv_ip((X),(Y),276) +#define get_csv_ipv6_pos276(X,Y) get_csv_ipv6((X),(Y),276) +#define get_csv_string_pos276(X,Y) get_csv_string((X),(Y),276) +#define get_csv_v_str_pos276(X,Y) get_csv_string((X),(Y),276) +#define get_csv_bool_pos276(X,Y) get_csv_bool((X),(Y),276) +#define get_csv_int_pos276(X,Y) get_csv_int((X),(Y),276) +#define get_csv_llong_pos276(X,Y) get_csv_llong((X),(Y),276) +#define get_csv_float_pos276(X,Y) get_csv_float((X),(Y),276) +#define get_csv_uint_pos277(X,Y) get_csv_uint((X),(Y),277) +#define get_csv_ullong_pos277(X,Y) get_csv_ullong((X),(Y),277) +#define get_csv_ip_pos277(X,Y) get_csv_ip((X),(Y),277) +#define get_csv_ipv6_pos277(X,Y) get_csv_ipv6((X),(Y),277) +#define get_csv_string_pos277(X,Y) get_csv_string((X),(Y),277) +#define get_csv_v_str_pos277(X,Y) get_csv_string((X),(Y),277) +#define get_csv_bool_pos277(X,Y) get_csv_bool((X),(Y),277) +#define get_csv_int_pos277(X,Y) get_csv_int((X),(Y),277) +#define get_csv_llong_pos277(X,Y) get_csv_llong((X),(Y),277) +#define get_csv_float_pos277(X,Y) get_csv_float((X),(Y),277) +#define get_csv_uint_pos278(X,Y) get_csv_uint((X),(Y),278) +#define get_csv_ullong_pos278(X,Y) get_csv_ullong((X),(Y),278) +#define get_csv_ip_pos278(X,Y) get_csv_ip((X),(Y),278) +#define get_csv_ipv6_pos278(X,Y) get_csv_ipv6((X),(Y),278) +#define get_csv_string_pos278(X,Y) get_csv_string((X),(Y),278) +#define get_csv_v_str_pos278(X,Y) get_csv_string((X),(Y),278) +#define get_csv_bool_pos278(X,Y) get_csv_bool((X),(Y),278) +#define get_csv_int_pos278(X,Y) get_csv_int((X),(Y),278) +#define get_csv_llong_pos278(X,Y) get_csv_llong((X),(Y),278) +#define get_csv_float_pos278(X,Y) get_csv_float((X),(Y),278) +#define get_csv_uint_pos279(X,Y) get_csv_uint((X),(Y),279) +#define get_csv_ullong_pos279(X,Y) get_csv_ullong((X),(Y),279) +#define get_csv_ip_pos279(X,Y) get_csv_ip((X),(Y),279) +#define get_csv_ipv6_pos279(X,Y) get_csv_ipv6((X),(Y),279) +#define get_csv_string_pos279(X,Y) get_csv_string((X),(Y),279) +#define get_csv_v_str_pos279(X,Y) get_csv_string((X),(Y),279) +#define get_csv_bool_pos279(X,Y) get_csv_bool((X),(Y),279) +#define get_csv_int_pos279(X,Y) get_csv_int((X),(Y),279) +#define get_csv_llong_pos279(X,Y) get_csv_llong((X),(Y),279) +#define get_csv_float_pos279(X,Y) get_csv_float((X),(Y),279) +#define get_csv_uint_pos280(X,Y) get_csv_uint((X),(Y),280) +#define get_csv_ullong_pos280(X,Y) get_csv_ullong((X),(Y),280) +#define get_csv_ip_pos280(X,Y) get_csv_ip((X),(Y),280) +#define get_csv_ipv6_pos280(X,Y) get_csv_ipv6((X),(Y),280) +#define get_csv_string_pos280(X,Y) get_csv_string((X),(Y),280) +#define get_csv_v_str_pos280(X,Y) get_csv_string((X),(Y),280) +#define get_csv_bool_pos280(X,Y) get_csv_bool((X),(Y),280) +#define get_csv_int_pos280(X,Y) get_csv_int((X),(Y),280) +#define get_csv_llong_pos280(X,Y) get_csv_llong((X),(Y),280) +#define get_csv_float_pos280(X,Y) get_csv_float((X),(Y),280) +#define get_csv_uint_pos281(X,Y) get_csv_uint((X),(Y),281) +#define get_csv_ullong_pos281(X,Y) get_csv_ullong((X),(Y),281) +#define get_csv_ip_pos281(X,Y) get_csv_ip((X),(Y),281) +#define get_csv_ipv6_pos281(X,Y) get_csv_ipv6((X),(Y),281) +#define get_csv_string_pos281(X,Y) get_csv_string((X),(Y),281) +#define get_csv_v_str_pos281(X,Y) get_csv_string((X),(Y),281) +#define get_csv_bool_pos281(X,Y) get_csv_bool((X),(Y),281) +#define get_csv_int_pos281(X,Y) get_csv_int((X),(Y),281) +#define get_csv_llong_pos281(X,Y) get_csv_llong((X),(Y),281) +#define get_csv_float_pos281(X,Y) get_csv_float((X),(Y),281) +#define get_csv_uint_pos282(X,Y) get_csv_uint((X),(Y),282) +#define get_csv_ullong_pos282(X,Y) get_csv_ullong((X),(Y),282) +#define get_csv_ip_pos282(X,Y) get_csv_ip((X),(Y),282) +#define get_csv_ipv6_pos282(X,Y) get_csv_ipv6((X),(Y),282) +#define get_csv_string_pos282(X,Y) get_csv_string((X),(Y),282) +#define get_csv_v_str_pos282(X,Y) get_csv_string((X),(Y),282) +#define get_csv_bool_pos282(X,Y) get_csv_bool((X),(Y),282) +#define get_csv_int_pos282(X,Y) get_csv_int((X),(Y),282) +#define get_csv_llong_pos282(X,Y) get_csv_llong((X),(Y),282) +#define get_csv_float_pos282(X,Y) get_csv_float((X),(Y),282) +#define get_csv_uint_pos283(X,Y) get_csv_uint((X),(Y),283) +#define get_csv_ullong_pos283(X,Y) get_csv_ullong((X),(Y),283) +#define get_csv_ip_pos283(X,Y) get_csv_ip((X),(Y),283) +#define get_csv_ipv6_pos283(X,Y) get_csv_ipv6((X),(Y),283) +#define get_csv_string_pos283(X,Y) get_csv_string((X),(Y),283) +#define get_csv_v_str_pos283(X,Y) get_csv_string((X),(Y),283) +#define get_csv_bool_pos283(X,Y) get_csv_bool((X),(Y),283) +#define get_csv_int_pos283(X,Y) get_csv_int((X),(Y),283) +#define get_csv_llong_pos283(X,Y) get_csv_llong((X),(Y),283) +#define get_csv_float_pos283(X,Y) get_csv_float((X),(Y),283) +#define get_csv_uint_pos284(X,Y) get_csv_uint((X),(Y),284) +#define get_csv_ullong_pos284(X,Y) get_csv_ullong((X),(Y),284) +#define get_csv_ip_pos284(X,Y) get_csv_ip((X),(Y),284) +#define get_csv_ipv6_pos284(X,Y) get_csv_ipv6((X),(Y),284) +#define get_csv_string_pos284(X,Y) get_csv_string((X),(Y),284) +#define get_csv_v_str_pos284(X,Y) get_csv_string((X),(Y),284) +#define get_csv_bool_pos284(X,Y) get_csv_bool((X),(Y),284) +#define get_csv_int_pos284(X,Y) get_csv_int((X),(Y),284) +#define get_csv_llong_pos284(X,Y) get_csv_llong((X),(Y),284) +#define get_csv_float_pos284(X,Y) get_csv_float((X),(Y),284) +#define get_csv_uint_pos285(X,Y) get_csv_uint((X),(Y),285) +#define get_csv_ullong_pos285(X,Y) get_csv_ullong((X),(Y),285) +#define get_csv_ip_pos285(X,Y) get_csv_ip((X),(Y),285) +#define get_csv_ipv6_pos285(X,Y) get_csv_ipv6((X),(Y),285) +#define get_csv_string_pos285(X,Y) get_csv_string((X),(Y),285) +#define get_csv_v_str_pos285(X,Y) get_csv_string((X),(Y),285) +#define get_csv_bool_pos285(X,Y) get_csv_bool((X),(Y),285) +#define get_csv_int_pos285(X,Y) get_csv_int((X),(Y),285) +#define get_csv_llong_pos285(X,Y) get_csv_llong((X),(Y),285) +#define get_csv_float_pos285(X,Y) get_csv_float((X),(Y),285) +#define get_csv_uint_pos286(X,Y) get_csv_uint((X),(Y),286) +#define get_csv_ullong_pos286(X,Y) get_csv_ullong((X),(Y),286) +#define get_csv_ip_pos286(X,Y) get_csv_ip((X),(Y),286) +#define get_csv_ipv6_pos286(X,Y) get_csv_ipv6((X),(Y),286) +#define get_csv_string_pos286(X,Y) get_csv_string((X),(Y),286) +#define get_csv_v_str_pos286(X,Y) get_csv_string((X),(Y),286) +#define get_csv_bool_pos286(X,Y) get_csv_bool((X),(Y),286) +#define get_csv_int_pos286(X,Y) get_csv_int((X),(Y),286) +#define get_csv_llong_pos286(X,Y) get_csv_llong((X),(Y),286) +#define get_csv_float_pos286(X,Y) get_csv_float((X),(Y),286) +#define get_csv_uint_pos287(X,Y) get_csv_uint((X),(Y),287) +#define get_csv_ullong_pos287(X,Y) get_csv_ullong((X),(Y),287) +#define get_csv_ip_pos287(X,Y) get_csv_ip((X),(Y),287) +#define get_csv_ipv6_pos287(X,Y) get_csv_ipv6((X),(Y),287) +#define get_csv_string_pos287(X,Y) get_csv_string((X),(Y),287) +#define get_csv_v_str_pos287(X,Y) get_csv_string((X),(Y),287) +#define get_csv_bool_pos287(X,Y) get_csv_bool((X),(Y),287) +#define get_csv_int_pos287(X,Y) get_csv_int((X),(Y),287) +#define get_csv_llong_pos287(X,Y) get_csv_llong((X),(Y),287) +#define get_csv_float_pos287(X,Y) get_csv_float((X),(Y),287) +#define get_csv_uint_pos288(X,Y) get_csv_uint((X),(Y),288) +#define get_csv_ullong_pos288(X,Y) get_csv_ullong((X),(Y),288) +#define get_csv_ip_pos288(X,Y) get_csv_ip((X),(Y),288) +#define get_csv_ipv6_pos288(X,Y) get_csv_ipv6((X),(Y),288) +#define get_csv_string_pos288(X,Y) get_csv_string((X),(Y),288) +#define get_csv_v_str_pos288(X,Y) get_csv_string((X),(Y),288) +#define get_csv_bool_pos288(X,Y) get_csv_bool((X),(Y),288) +#define get_csv_int_pos288(X,Y) get_csv_int((X),(Y),288) +#define get_csv_llong_pos288(X,Y) get_csv_llong((X),(Y),288) +#define get_csv_float_pos288(X,Y) get_csv_float((X),(Y),288) +#define get_csv_uint_pos289(X,Y) get_csv_uint((X),(Y),289) +#define get_csv_ullong_pos289(X,Y) get_csv_ullong((X),(Y),289) +#define get_csv_ip_pos289(X,Y) get_csv_ip((X),(Y),289) +#define get_csv_ipv6_pos289(X,Y) get_csv_ipv6((X),(Y),289) +#define get_csv_string_pos289(X,Y) get_csv_string((X),(Y),289) +#define get_csv_v_str_pos289(X,Y) get_csv_string((X),(Y),289) +#define get_csv_bool_pos289(X,Y) get_csv_bool((X),(Y),289) +#define get_csv_int_pos289(X,Y) get_csv_int((X),(Y),289) +#define get_csv_llong_pos289(X,Y) get_csv_llong((X),(Y),289) +#define get_csv_float_pos289(X,Y) get_csv_float((X),(Y),289) +#define get_csv_uint_pos290(X,Y) get_csv_uint((X),(Y),290) +#define get_csv_ullong_pos290(X,Y) get_csv_ullong((X),(Y),290) +#define get_csv_ip_pos290(X,Y) get_csv_ip((X),(Y),290) +#define get_csv_ipv6_pos290(X,Y) get_csv_ipv6((X),(Y),290) +#define get_csv_string_pos290(X,Y) get_csv_string((X),(Y),290) +#define get_csv_v_str_pos290(X,Y) get_csv_string((X),(Y),290) +#define get_csv_bool_pos290(X,Y) get_csv_bool((X),(Y),290) +#define get_csv_int_pos290(X,Y) get_csv_int((X),(Y),290) +#define get_csv_llong_pos290(X,Y) get_csv_llong((X),(Y),290) +#define get_csv_float_pos290(X,Y) get_csv_float((X),(Y),290) +#define get_csv_uint_pos291(X,Y) get_csv_uint((X),(Y),291) +#define get_csv_ullong_pos291(X,Y) get_csv_ullong((X),(Y),291) +#define get_csv_ip_pos291(X,Y) get_csv_ip((X),(Y),291) +#define get_csv_ipv6_pos291(X,Y) get_csv_ipv6((X),(Y),291) +#define get_csv_string_pos291(X,Y) get_csv_string((X),(Y),291) +#define get_csv_v_str_pos291(X,Y) get_csv_string((X),(Y),291) +#define get_csv_bool_pos291(X,Y) get_csv_bool((X),(Y),291) +#define get_csv_int_pos291(X,Y) get_csv_int((X),(Y),291) +#define get_csv_llong_pos291(X,Y) get_csv_llong((X),(Y),291) +#define get_csv_float_pos291(X,Y) get_csv_float((X),(Y),291) +#define get_csv_uint_pos292(X,Y) get_csv_uint((X),(Y),292) +#define get_csv_ullong_pos292(X,Y) get_csv_ullong((X),(Y),292) +#define get_csv_ip_pos292(X,Y) get_csv_ip((X),(Y),292) +#define get_csv_ipv6_pos292(X,Y) get_csv_ipv6((X),(Y),292) +#define get_csv_string_pos292(X,Y) get_csv_string((X),(Y),292) +#define get_csv_v_str_pos292(X,Y) get_csv_string((X),(Y),292) +#define get_csv_bool_pos292(X,Y) get_csv_bool((X),(Y),292) +#define get_csv_int_pos292(X,Y) get_csv_int((X),(Y),292) +#define get_csv_llong_pos292(X,Y) get_csv_llong((X),(Y),292) +#define get_csv_float_pos292(X,Y) get_csv_float((X),(Y),292) +#define get_csv_uint_pos293(X,Y) get_csv_uint((X),(Y),293) +#define get_csv_ullong_pos293(X,Y) get_csv_ullong((X),(Y),293) +#define get_csv_ip_pos293(X,Y) get_csv_ip((X),(Y),293) +#define get_csv_ipv6_pos293(X,Y) get_csv_ipv6((X),(Y),293) +#define get_csv_string_pos293(X,Y) get_csv_string((X),(Y),293) +#define get_csv_v_str_pos293(X,Y) get_csv_string((X),(Y),293) +#define get_csv_bool_pos293(X,Y) get_csv_bool((X),(Y),293) +#define get_csv_int_pos293(X,Y) get_csv_int((X),(Y),293) +#define get_csv_llong_pos293(X,Y) get_csv_llong((X),(Y),293) +#define get_csv_float_pos293(X,Y) get_csv_float((X),(Y),293) +#define get_csv_uint_pos294(X,Y) get_csv_uint((X),(Y),294) +#define get_csv_ullong_pos294(X,Y) get_csv_ullong((X),(Y),294) +#define get_csv_ip_pos294(X,Y) get_csv_ip((X),(Y),294) +#define get_csv_ipv6_pos294(X,Y) get_csv_ipv6((X),(Y),294) +#define get_csv_string_pos294(X,Y) get_csv_string((X),(Y),294) +#define get_csv_v_str_pos294(X,Y) get_csv_string((X),(Y),294) +#define get_csv_bool_pos294(X,Y) get_csv_bool((X),(Y),294) +#define get_csv_int_pos294(X,Y) get_csv_int((X),(Y),294) +#define get_csv_llong_pos294(X,Y) get_csv_llong((X),(Y),294) +#define get_csv_float_pos294(X,Y) get_csv_float((X),(Y),294) +#define get_csv_uint_pos295(X,Y) get_csv_uint((X),(Y),295) +#define get_csv_ullong_pos295(X,Y) get_csv_ullong((X),(Y),295) +#define get_csv_ip_pos295(X,Y) get_csv_ip((X),(Y),295) +#define get_csv_ipv6_pos295(X,Y) get_csv_ipv6((X),(Y),295) +#define get_csv_string_pos295(X,Y) get_csv_string((X),(Y),295) +#define get_csv_v_str_pos295(X,Y) get_csv_string((X),(Y),295) +#define get_csv_bool_pos295(X,Y) get_csv_bool((X),(Y),295) +#define get_csv_int_pos295(X,Y) get_csv_int((X),(Y),295) +#define get_csv_llong_pos295(X,Y) get_csv_llong((X),(Y),295) +#define get_csv_float_pos295(X,Y) get_csv_float((X),(Y),295) +#define get_csv_uint_pos296(X,Y) get_csv_uint((X),(Y),296) +#define get_csv_ullong_pos296(X,Y) get_csv_ullong((X),(Y),296) +#define get_csv_ip_pos296(X,Y) get_csv_ip((X),(Y),296) +#define get_csv_ipv6_pos296(X,Y) get_csv_ipv6((X),(Y),296) +#define get_csv_string_pos296(X,Y) get_csv_string((X),(Y),296) +#define get_csv_v_str_pos296(X,Y) get_csv_string((X),(Y),296) +#define get_csv_bool_pos296(X,Y) get_csv_bool((X),(Y),296) +#define get_csv_int_pos296(X,Y) get_csv_int((X),(Y),296) +#define get_csv_llong_pos296(X,Y) get_csv_llong((X),(Y),296) +#define get_csv_float_pos296(X,Y) get_csv_float((X),(Y),296) +#define get_csv_uint_pos297(X,Y) get_csv_uint((X),(Y),297) +#define get_csv_ullong_pos297(X,Y) get_csv_ullong((X),(Y),297) +#define get_csv_ip_pos297(X,Y) get_csv_ip((X),(Y),297) +#define get_csv_ipv6_pos297(X,Y) get_csv_ipv6((X),(Y),297) +#define get_csv_string_pos297(X,Y) get_csv_string((X),(Y),297) +#define get_csv_v_str_pos297(X,Y) get_csv_string((X),(Y),297) +#define get_csv_bool_pos297(X,Y) get_csv_bool((X),(Y),297) +#define get_csv_int_pos297(X,Y) get_csv_int((X),(Y),297) +#define get_csv_llong_pos297(X,Y) get_csv_llong((X),(Y),297) +#define get_csv_float_pos297(X,Y) get_csv_float((X),(Y),297) +#define get_csv_uint_pos298(X,Y) get_csv_uint((X),(Y),298) +#define get_csv_ullong_pos298(X,Y) get_csv_ullong((X),(Y),298) +#define get_csv_ip_pos298(X,Y) get_csv_ip((X),(Y),298) +#define get_csv_ipv6_pos298(X,Y) get_csv_ipv6((X),(Y),298) +#define get_csv_string_pos298(X,Y) get_csv_string((X),(Y),298) +#define get_csv_v_str_pos298(X,Y) get_csv_string((X),(Y),298) +#define get_csv_bool_pos298(X,Y) get_csv_bool((X),(Y),298) +#define get_csv_int_pos298(X,Y) get_csv_int((X),(Y),298) +#define get_csv_llong_pos298(X,Y) get_csv_llong((X),(Y),298) +#define get_csv_float_pos298(X,Y) get_csv_float((X),(Y),298) +#define get_csv_uint_pos299(X,Y) get_csv_uint((X),(Y),299) +#define get_csv_ullong_pos299(X,Y) get_csv_ullong((X),(Y),299) +#define get_csv_ip_pos299(X,Y) get_csv_ip((X),(Y),299) +#define get_csv_ipv6_pos299(X,Y) get_csv_ipv6((X),(Y),299) +#define get_csv_string_pos299(X,Y) get_csv_string((X),(Y),299) +#define get_csv_v_str_pos299(X,Y) get_csv_string((X),(Y),299) +#define get_csv_bool_pos299(X,Y) get_csv_bool((X),(Y),299) +#define get_csv_int_pos299(X,Y) get_csv_int((X),(Y),299) +#define get_csv_llong_pos299(X,Y) get_csv_llong((X),(Y),299) +#define get_csv_float_pos299(X,Y) get_csv_float((X),(Y),299) +#define get_csv_uint_pos300(X,Y) get_csv_uint((X),(Y),300) +#define get_csv_ullong_pos300(X,Y) get_csv_ullong((X),(Y),300) +#define get_csv_ip_pos300(X,Y) get_csv_ip((X),(Y),300) +#define get_csv_ipv6_pos300(X,Y) get_csv_ipv6((X),(Y),300) +#define get_csv_string_pos300(X,Y) get_csv_string((X),(Y),300) +#define get_csv_v_str_pos300(X,Y) get_csv_string((X),(Y),300) +#define get_csv_bool_pos300(X,Y) get_csv_bool((X),(Y),300) +#define get_csv_int_pos300(X,Y) get_csv_int((X),(Y),300) +#define get_csv_llong_pos300(X,Y) get_csv_llong((X),(Y),300) +#define get_csv_float_pos300(X,Y) get_csv_float((X),(Y),300) +#define get_csv_uint_pos301(X,Y) get_csv_uint((X),(Y),301) +#define get_csv_ullong_pos301(X,Y) get_csv_ullong((X),(Y),301) +#define get_csv_ip_pos301(X,Y) get_csv_ip((X),(Y),301) +#define get_csv_ipv6_pos301(X,Y) get_csv_ipv6((X),(Y),301) +#define get_csv_string_pos301(X,Y) get_csv_string((X),(Y),301) +#define get_csv_v_str_pos301(X,Y) get_csv_string((X),(Y),301) +#define get_csv_bool_pos301(X,Y) get_csv_bool((X),(Y),301) +#define get_csv_int_pos301(X,Y) get_csv_int((X),(Y),301) +#define get_csv_llong_pos301(X,Y) get_csv_llong((X),(Y),301) +#define get_csv_float_pos301(X,Y) get_csv_float((X),(Y),301) +#define get_csv_uint_pos302(X,Y) get_csv_uint((X),(Y),302) +#define get_csv_ullong_pos302(X,Y) get_csv_ullong((X),(Y),302) +#define get_csv_ip_pos302(X,Y) get_csv_ip((X),(Y),302) +#define get_csv_ipv6_pos302(X,Y) get_csv_ipv6((X),(Y),302) +#define get_csv_string_pos302(X,Y) get_csv_string((X),(Y),302) +#define get_csv_v_str_pos302(X,Y) get_csv_string((X),(Y),302) +#define get_csv_bool_pos302(X,Y) get_csv_bool((X),(Y),302) +#define get_csv_int_pos302(X,Y) get_csv_int((X),(Y),302) +#define get_csv_llong_pos302(X,Y) get_csv_llong((X),(Y),302) +#define get_csv_float_pos302(X,Y) get_csv_float((X),(Y),302) +#define get_csv_uint_pos303(X,Y) get_csv_uint((X),(Y),303) +#define get_csv_ullong_pos303(X,Y) get_csv_ullong((X),(Y),303) +#define get_csv_ip_pos303(X,Y) get_csv_ip((X),(Y),303) +#define get_csv_ipv6_pos303(X,Y) get_csv_ipv6((X),(Y),303) +#define get_csv_string_pos303(X,Y) get_csv_string((X),(Y),303) +#define get_csv_v_str_pos303(X,Y) get_csv_string((X),(Y),303) +#define get_csv_bool_pos303(X,Y) get_csv_bool((X),(Y),303) +#define get_csv_int_pos303(X,Y) get_csv_int((X),(Y),303) +#define get_csv_llong_pos303(X,Y) get_csv_llong((X),(Y),303) +#define get_csv_float_pos303(X,Y) get_csv_float((X),(Y),303) +#define get_csv_uint_pos304(X,Y) get_csv_uint((X),(Y),304) +#define get_csv_ullong_pos304(X,Y) get_csv_ullong((X),(Y),304) +#define get_csv_ip_pos304(X,Y) get_csv_ip((X),(Y),304) +#define get_csv_ipv6_pos304(X,Y) get_csv_ipv6((X),(Y),304) +#define get_csv_string_pos304(X,Y) get_csv_string((X),(Y),304) +#define get_csv_v_str_pos304(X,Y) get_csv_string((X),(Y),304) +#define get_csv_bool_pos304(X,Y) get_csv_bool((X),(Y),304) +#define get_csv_int_pos304(X,Y) get_csv_int((X),(Y),304) +#define get_csv_llong_pos304(X,Y) get_csv_llong((X),(Y),304) +#define get_csv_float_pos304(X,Y) get_csv_float((X),(Y),304) +#define get_csv_uint_pos305(X,Y) get_csv_uint((X),(Y),305) +#define get_csv_ullong_pos305(X,Y) get_csv_ullong((X),(Y),305) +#define get_csv_ip_pos305(X,Y) get_csv_ip((X),(Y),305) +#define get_csv_ipv6_pos305(X,Y) get_csv_ipv6((X),(Y),305) +#define get_csv_string_pos305(X,Y) get_csv_string((X),(Y),305) +#define get_csv_v_str_pos305(X,Y) get_csv_string((X),(Y),305) +#define get_csv_bool_pos305(X,Y) get_csv_bool((X),(Y),305) +#define get_csv_int_pos305(X,Y) get_csv_int((X),(Y),305) +#define get_csv_llong_pos305(X,Y) get_csv_llong((X),(Y),305) +#define get_csv_float_pos305(X,Y) get_csv_float((X),(Y),305) +#define get_csv_uint_pos306(X,Y) get_csv_uint((X),(Y),306) +#define get_csv_ullong_pos306(X,Y) get_csv_ullong((X),(Y),306) +#define get_csv_ip_pos306(X,Y) get_csv_ip((X),(Y),306) +#define get_csv_ipv6_pos306(X,Y) get_csv_ipv6((X),(Y),306) +#define get_csv_string_pos306(X,Y) get_csv_string((X),(Y),306) +#define get_csv_v_str_pos306(X,Y) get_csv_string((X),(Y),306) +#define get_csv_bool_pos306(X,Y) get_csv_bool((X),(Y),306) +#define get_csv_int_pos306(X,Y) get_csv_int((X),(Y),306) +#define get_csv_llong_pos306(X,Y) get_csv_llong((X),(Y),306) +#define get_csv_float_pos306(X,Y) get_csv_float((X),(Y),306) +#define get_csv_uint_pos307(X,Y) get_csv_uint((X),(Y),307) +#define get_csv_ullong_pos307(X,Y) get_csv_ullong((X),(Y),307) +#define get_csv_ip_pos307(X,Y) get_csv_ip((X),(Y),307) +#define get_csv_ipv6_pos307(X,Y) get_csv_ipv6((X),(Y),307) +#define get_csv_string_pos307(X,Y) get_csv_string((X),(Y),307) +#define get_csv_v_str_pos307(X,Y) get_csv_string((X),(Y),307) +#define get_csv_bool_pos307(X,Y) get_csv_bool((X),(Y),307) +#define get_csv_int_pos307(X,Y) get_csv_int((X),(Y),307) +#define get_csv_llong_pos307(X,Y) get_csv_llong((X),(Y),307) +#define get_csv_float_pos307(X,Y) get_csv_float((X),(Y),307) +#define get_csv_uint_pos308(X,Y) get_csv_uint((X),(Y),308) +#define get_csv_ullong_pos308(X,Y) get_csv_ullong((X),(Y),308) +#define get_csv_ip_pos308(X,Y) get_csv_ip((X),(Y),308) +#define get_csv_ipv6_pos308(X,Y) get_csv_ipv6((X),(Y),308) +#define get_csv_string_pos308(X,Y) get_csv_string((X),(Y),308) +#define get_csv_v_str_pos308(X,Y) get_csv_string((X),(Y),308) +#define get_csv_bool_pos308(X,Y) get_csv_bool((X),(Y),308) +#define get_csv_int_pos308(X,Y) get_csv_int((X),(Y),308) +#define get_csv_llong_pos308(X,Y) get_csv_llong((X),(Y),308) +#define get_csv_float_pos308(X,Y) get_csv_float((X),(Y),308) +#define get_csv_uint_pos309(X,Y) get_csv_uint((X),(Y),309) +#define get_csv_ullong_pos309(X,Y) get_csv_ullong((X),(Y),309) +#define get_csv_ip_pos309(X,Y) get_csv_ip((X),(Y),309) +#define get_csv_ipv6_pos309(X,Y) get_csv_ipv6((X),(Y),309) +#define get_csv_string_pos309(X,Y) get_csv_string((X),(Y),309) +#define get_csv_v_str_pos309(X,Y) get_csv_string((X),(Y),309) +#define get_csv_bool_pos309(X,Y) get_csv_bool((X),(Y),309) +#define get_csv_int_pos309(X,Y) get_csv_int((X),(Y),309) +#define get_csv_llong_pos309(X,Y) get_csv_llong((X),(Y),309) +#define get_csv_float_pos309(X,Y) get_csv_float((X),(Y),309) +#define get_csv_uint_pos310(X,Y) get_csv_uint((X),(Y),310) +#define get_csv_ullong_pos310(X,Y) get_csv_ullong((X),(Y),310) +#define get_csv_ip_pos310(X,Y) get_csv_ip((X),(Y),310) +#define get_csv_ipv6_pos310(X,Y) get_csv_ipv6((X),(Y),310) +#define get_csv_string_pos310(X,Y) get_csv_string((X),(Y),310) +#define get_csv_v_str_pos310(X,Y) get_csv_string((X),(Y),310) +#define get_csv_bool_pos310(X,Y) get_csv_bool((X),(Y),310) +#define get_csv_int_pos310(X,Y) get_csv_int((X),(Y),310) +#define get_csv_llong_pos310(X,Y) get_csv_llong((X),(Y),310) +#define get_csv_float_pos310(X,Y) get_csv_float((X),(Y),310) +#define get_csv_uint_pos311(X,Y) get_csv_uint((X),(Y),311) +#define get_csv_ullong_pos311(X,Y) get_csv_ullong((X),(Y),311) +#define get_csv_ip_pos311(X,Y) get_csv_ip((X),(Y),311) +#define get_csv_ipv6_pos311(X,Y) get_csv_ipv6((X),(Y),311) +#define get_csv_string_pos311(X,Y) get_csv_string((X),(Y),311) +#define get_csv_v_str_pos311(X,Y) get_csv_string((X),(Y),311) +#define get_csv_bool_pos311(X,Y) get_csv_bool((X),(Y),311) +#define get_csv_int_pos311(X,Y) get_csv_int((X),(Y),311) +#define get_csv_llong_pos311(X,Y) get_csv_llong((X),(Y),311) +#define get_csv_float_pos311(X,Y) get_csv_float((X),(Y),311) +#define get_csv_uint_pos312(X,Y) get_csv_uint((X),(Y),312) +#define get_csv_ullong_pos312(X,Y) get_csv_ullong((X),(Y),312) +#define get_csv_ip_pos312(X,Y) get_csv_ip((X),(Y),312) +#define get_csv_ipv6_pos312(X,Y) get_csv_ipv6((X),(Y),312) +#define get_csv_string_pos312(X,Y) get_csv_string((X),(Y),312) +#define get_csv_v_str_pos312(X,Y) get_csv_string((X),(Y),312) +#define get_csv_bool_pos312(X,Y) get_csv_bool((X),(Y),312) +#define get_csv_int_pos312(X,Y) get_csv_int((X),(Y),312) +#define get_csv_llong_pos312(X,Y) get_csv_llong((X),(Y),312) +#define get_csv_float_pos312(X,Y) get_csv_float((X),(Y),312) +#define get_csv_uint_pos313(X,Y) get_csv_uint((X),(Y),313) +#define get_csv_ullong_pos313(X,Y) get_csv_ullong((X),(Y),313) +#define get_csv_ip_pos313(X,Y) get_csv_ip((X),(Y),313) +#define get_csv_ipv6_pos313(X,Y) get_csv_ipv6((X),(Y),313) +#define get_csv_string_pos313(X,Y) get_csv_string((X),(Y),313) +#define get_csv_v_str_pos313(X,Y) get_csv_string((X),(Y),313) +#define get_csv_bool_pos313(X,Y) get_csv_bool((X),(Y),313) +#define get_csv_int_pos313(X,Y) get_csv_int((X),(Y),313) +#define get_csv_llong_pos313(X,Y) get_csv_llong((X),(Y),313) +#define get_csv_float_pos313(X,Y) get_csv_float((X),(Y),313) +#define get_csv_uint_pos314(X,Y) get_csv_uint((X),(Y),314) +#define get_csv_ullong_pos314(X,Y) get_csv_ullong((X),(Y),314) +#define get_csv_ip_pos314(X,Y) get_csv_ip((X),(Y),314) +#define get_csv_ipv6_pos314(X,Y) get_csv_ipv6((X),(Y),314) +#define get_csv_string_pos314(X,Y) get_csv_string((X),(Y),314) +#define get_csv_v_str_pos314(X,Y) get_csv_string((X),(Y),314) +#define get_csv_bool_pos314(X,Y) get_csv_bool((X),(Y),314) +#define get_csv_int_pos314(X,Y) get_csv_int((X),(Y),314) +#define get_csv_llong_pos314(X,Y) get_csv_llong((X),(Y),314) +#define get_csv_float_pos314(X,Y) get_csv_float((X),(Y),314) +#define get_csv_uint_pos315(X,Y) get_csv_uint((X),(Y),315) +#define get_csv_ullong_pos315(X,Y) get_csv_ullong((X),(Y),315) +#define get_csv_ip_pos315(X,Y) get_csv_ip((X),(Y),315) +#define get_csv_ipv6_pos315(X,Y) get_csv_ipv6((X),(Y),315) +#define get_csv_string_pos315(X,Y) get_csv_string((X),(Y),315) +#define get_csv_v_str_pos315(X,Y) get_csv_string((X),(Y),315) +#define get_csv_bool_pos315(X,Y) get_csv_bool((X),(Y),315) +#define get_csv_int_pos315(X,Y) get_csv_int((X),(Y),315) +#define get_csv_llong_pos315(X,Y) get_csv_llong((X),(Y),315) +#define get_csv_float_pos315(X,Y) get_csv_float((X),(Y),315) +#define get_csv_uint_pos316(X,Y) get_csv_uint((X),(Y),316) +#define get_csv_ullong_pos316(X,Y) get_csv_ullong((X),(Y),316) +#define get_csv_ip_pos316(X,Y) get_csv_ip((X),(Y),316) +#define get_csv_ipv6_pos316(X,Y) get_csv_ipv6((X),(Y),316) +#define get_csv_string_pos316(X,Y) get_csv_string((X),(Y),316) +#define get_csv_v_str_pos316(X,Y) get_csv_string((X),(Y),316) +#define get_csv_bool_pos316(X,Y) get_csv_bool((X),(Y),316) +#define get_csv_int_pos316(X,Y) get_csv_int((X),(Y),316) +#define get_csv_llong_pos316(X,Y) get_csv_llong((X),(Y),316) +#define get_csv_float_pos316(X,Y) get_csv_float((X),(Y),316) +#define get_csv_uint_pos317(X,Y) get_csv_uint((X),(Y),317) +#define get_csv_ullong_pos317(X,Y) get_csv_ullong((X),(Y),317) +#define get_csv_ip_pos317(X,Y) get_csv_ip((X),(Y),317) +#define get_csv_ipv6_pos317(X,Y) get_csv_ipv6((X),(Y),317) +#define get_csv_string_pos317(X,Y) get_csv_string((X),(Y),317) +#define get_csv_v_str_pos317(X,Y) get_csv_string((X),(Y),317) +#define get_csv_bool_pos317(X,Y) get_csv_bool((X),(Y),317) +#define get_csv_int_pos317(X,Y) get_csv_int((X),(Y),317) +#define get_csv_llong_pos317(X,Y) get_csv_llong((X),(Y),317) +#define get_csv_float_pos317(X,Y) get_csv_float((X),(Y),317) +#define get_csv_uint_pos318(X,Y) get_csv_uint((X),(Y),318) +#define get_csv_ullong_pos318(X,Y) get_csv_ullong((X),(Y),318) +#define get_csv_ip_pos318(X,Y) get_csv_ip((X),(Y),318) +#define get_csv_ipv6_pos318(X,Y) get_csv_ipv6((X),(Y),318) +#define get_csv_string_pos318(X,Y) get_csv_string((X),(Y),318) +#define get_csv_v_str_pos318(X,Y) get_csv_string((X),(Y),318) +#define get_csv_bool_pos318(X,Y) get_csv_bool((X),(Y),318) +#define get_csv_int_pos318(X,Y) get_csv_int((X),(Y),318) +#define get_csv_llong_pos318(X,Y) get_csv_llong((X),(Y),318) +#define get_csv_float_pos318(X,Y) get_csv_float((X),(Y),318) +#define get_csv_uint_pos319(X,Y) get_csv_uint((X),(Y),319) +#define get_csv_ullong_pos319(X,Y) get_csv_ullong((X),(Y),319) +#define get_csv_ip_pos319(X,Y) get_csv_ip((X),(Y),319) +#define get_csv_ipv6_pos319(X,Y) get_csv_ipv6((X),(Y),319) +#define get_csv_string_pos319(X,Y) get_csv_string((X),(Y),319) +#define get_csv_v_str_pos319(X,Y) get_csv_string((X),(Y),319) +#define get_csv_bool_pos319(X,Y) get_csv_bool((X),(Y),319) +#define get_csv_int_pos319(X,Y) get_csv_int((X),(Y),319) +#define get_csv_llong_pos319(X,Y) get_csv_llong((X),(Y),319) +#define get_csv_float_pos319(X,Y) get_csv_float((X),(Y),319) +#define get_csv_uint_pos320(X,Y) get_csv_uint((X),(Y),320) +#define get_csv_ullong_pos320(X,Y) get_csv_ullong((X),(Y),320) +#define get_csv_ip_pos320(X,Y) get_csv_ip((X),(Y),320) +#define get_csv_ipv6_pos320(X,Y) get_csv_ipv6((X),(Y),320) +#define get_csv_string_pos320(X,Y) get_csv_string((X),(Y),320) +#define get_csv_v_str_pos320(X,Y) get_csv_string((X),(Y),320) +#define get_csv_bool_pos320(X,Y) get_csv_bool((X),(Y),320) +#define get_csv_int_pos320(X,Y) get_csv_int((X),(Y),320) +#define get_csv_llong_pos320(X,Y) get_csv_llong((X),(Y),320) +#define get_csv_float_pos320(X,Y) get_csv_float((X),(Y),320) +#define get_csv_uint_pos321(X,Y) get_csv_uint((X),(Y),321) +#define get_csv_ullong_pos321(X,Y) get_csv_ullong((X),(Y),321) +#define get_csv_ip_pos321(X,Y) get_csv_ip((X),(Y),321) +#define get_csv_ipv6_pos321(X,Y) get_csv_ipv6((X),(Y),321) +#define get_csv_string_pos321(X,Y) get_csv_string((X),(Y),321) +#define get_csv_v_str_pos321(X,Y) get_csv_string((X),(Y),321) +#define get_csv_bool_pos321(X,Y) get_csv_bool((X),(Y),321) +#define get_csv_int_pos321(X,Y) get_csv_int((X),(Y),321) +#define get_csv_llong_pos321(X,Y) get_csv_llong((X),(Y),321) +#define get_csv_float_pos321(X,Y) get_csv_float((X),(Y),321) +#define get_csv_uint_pos322(X,Y) get_csv_uint((X),(Y),322) +#define get_csv_ullong_pos322(X,Y) get_csv_ullong((X),(Y),322) +#define get_csv_ip_pos322(X,Y) get_csv_ip((X),(Y),322) +#define get_csv_ipv6_pos322(X,Y) get_csv_ipv6((X),(Y),322) +#define get_csv_string_pos322(X,Y) get_csv_string((X),(Y),322) +#define get_csv_v_str_pos322(X,Y) get_csv_string((X),(Y),322) +#define get_csv_bool_pos322(X,Y) get_csv_bool((X),(Y),322) +#define get_csv_int_pos322(X,Y) get_csv_int((X),(Y),322) +#define get_csv_llong_pos322(X,Y) get_csv_llong((X),(Y),322) +#define get_csv_float_pos322(X,Y) get_csv_float((X),(Y),322) +#define get_csv_uint_pos323(X,Y) get_csv_uint((X),(Y),323) +#define get_csv_ullong_pos323(X,Y) get_csv_ullong((X),(Y),323) +#define get_csv_ip_pos323(X,Y) get_csv_ip((X),(Y),323) +#define get_csv_ipv6_pos323(X,Y) get_csv_ipv6((X),(Y),323) +#define get_csv_string_pos323(X,Y) get_csv_string((X),(Y),323) +#define get_csv_v_str_pos323(X,Y) get_csv_string((X),(Y),323) +#define get_csv_bool_pos323(X,Y) get_csv_bool((X),(Y),323) +#define get_csv_int_pos323(X,Y) get_csv_int((X),(Y),323) +#define get_csv_llong_pos323(X,Y) get_csv_llong((X),(Y),323) +#define get_csv_float_pos323(X,Y) get_csv_float((X),(Y),323) +#define get_csv_uint_pos324(X,Y) get_csv_uint((X),(Y),324) +#define get_csv_ullong_pos324(X,Y) get_csv_ullong((X),(Y),324) +#define get_csv_ip_pos324(X,Y) get_csv_ip((X),(Y),324) +#define get_csv_ipv6_pos324(X,Y) get_csv_ipv6((X),(Y),324) +#define get_csv_string_pos324(X,Y) get_csv_string((X),(Y),324) +#define get_csv_v_str_pos324(X,Y) get_csv_string((X),(Y),324) +#define get_csv_bool_pos324(X,Y) get_csv_bool((X),(Y),324) +#define get_csv_int_pos324(X,Y) get_csv_int((X),(Y),324) +#define get_csv_llong_pos324(X,Y) get_csv_llong((X),(Y),324) +#define get_csv_float_pos324(X,Y) get_csv_float((X),(Y),324) +#define get_csv_uint_pos325(X,Y) get_csv_uint((X),(Y),325) +#define get_csv_ullong_pos325(X,Y) get_csv_ullong((X),(Y),325) +#define get_csv_ip_pos325(X,Y) get_csv_ip((X),(Y),325) +#define get_csv_ipv6_pos325(X,Y) get_csv_ipv6((X),(Y),325) +#define get_csv_string_pos325(X,Y) get_csv_string((X),(Y),325) +#define get_csv_v_str_pos325(X,Y) get_csv_string((X),(Y),325) +#define get_csv_bool_pos325(X,Y) get_csv_bool((X),(Y),325) +#define get_csv_int_pos325(X,Y) get_csv_int((X),(Y),325) +#define get_csv_llong_pos325(X,Y) get_csv_llong((X),(Y),325) +#define get_csv_float_pos325(X,Y) get_csv_float((X),(Y),325) +#define get_csv_uint_pos326(X,Y) get_csv_uint((X),(Y),326) +#define get_csv_ullong_pos326(X,Y) get_csv_ullong((X),(Y),326) +#define get_csv_ip_pos326(X,Y) get_csv_ip((X),(Y),326) +#define get_csv_ipv6_pos326(X,Y) get_csv_ipv6((X),(Y),326) +#define get_csv_string_pos326(X,Y) get_csv_string((X),(Y),326) +#define get_csv_v_str_pos326(X,Y) get_csv_string((X),(Y),326) +#define get_csv_bool_pos326(X,Y) get_csv_bool((X),(Y),326) +#define get_csv_int_pos326(X,Y) get_csv_int((X),(Y),326) +#define get_csv_llong_pos326(X,Y) get_csv_llong((X),(Y),326) +#define get_csv_float_pos326(X,Y) get_csv_float((X),(Y),326) +#define get_csv_uint_pos327(X,Y) get_csv_uint((X),(Y),327) +#define get_csv_ullong_pos327(X,Y) get_csv_ullong((X),(Y),327) +#define get_csv_ip_pos327(X,Y) get_csv_ip((X),(Y),327) +#define get_csv_ipv6_pos327(X,Y) get_csv_ipv6((X),(Y),327) +#define get_csv_string_pos327(X,Y) get_csv_string((X),(Y),327) +#define get_csv_v_str_pos327(X,Y) get_csv_string((X),(Y),327) +#define get_csv_bool_pos327(X,Y) get_csv_bool((X),(Y),327) +#define get_csv_int_pos327(X,Y) get_csv_int((X),(Y),327) +#define get_csv_llong_pos327(X,Y) get_csv_llong((X),(Y),327) +#define get_csv_float_pos327(X,Y) get_csv_float((X),(Y),327) +#define get_csv_uint_pos328(X,Y) get_csv_uint((X),(Y),328) +#define get_csv_ullong_pos328(X,Y) get_csv_ullong((X),(Y),328) +#define get_csv_ip_pos328(X,Y) get_csv_ip((X),(Y),328) +#define get_csv_ipv6_pos328(X,Y) get_csv_ipv6((X),(Y),328) +#define get_csv_string_pos328(X,Y) get_csv_string((X),(Y),328) +#define get_csv_v_str_pos328(X,Y) get_csv_string((X),(Y),328) +#define get_csv_bool_pos328(X,Y) get_csv_bool((X),(Y),328) +#define get_csv_int_pos328(X,Y) get_csv_int((X),(Y),328) +#define get_csv_llong_pos328(X,Y) get_csv_llong((X),(Y),328) +#define get_csv_float_pos328(X,Y) get_csv_float((X),(Y),328) +#define get_csv_uint_pos329(X,Y) get_csv_uint((X),(Y),329) +#define get_csv_ullong_pos329(X,Y) get_csv_ullong((X),(Y),329) +#define get_csv_ip_pos329(X,Y) get_csv_ip((X),(Y),329) +#define get_csv_ipv6_pos329(X,Y) get_csv_ipv6((X),(Y),329) +#define get_csv_string_pos329(X,Y) get_csv_string((X),(Y),329) +#define get_csv_v_str_pos329(X,Y) get_csv_string((X),(Y),329) +#define get_csv_bool_pos329(X,Y) get_csv_bool((X),(Y),329) +#define get_csv_int_pos329(X,Y) get_csv_int((X),(Y),329) +#define get_csv_llong_pos329(X,Y) get_csv_llong((X),(Y),329) +#define get_csv_float_pos329(X,Y) get_csv_float((X),(Y),329) +#define get_csv_uint_pos330(X,Y) get_csv_uint((X),(Y),330) +#define get_csv_ullong_pos330(X,Y) get_csv_ullong((X),(Y),330) +#define get_csv_ip_pos330(X,Y) get_csv_ip((X),(Y),330) +#define get_csv_ipv6_pos330(X,Y) get_csv_ipv6((X),(Y),330) +#define get_csv_string_pos330(X,Y) get_csv_string((X),(Y),330) +#define get_csv_v_str_pos330(X,Y) get_csv_string((X),(Y),330) +#define get_csv_bool_pos330(X,Y) get_csv_bool((X),(Y),330) +#define get_csv_int_pos330(X,Y) get_csv_int((X),(Y),330) +#define get_csv_llong_pos330(X,Y) get_csv_llong((X),(Y),330) +#define get_csv_float_pos330(X,Y) get_csv_float((X),(Y),330) +#define get_csv_uint_pos331(X,Y) get_csv_uint((X),(Y),331) +#define get_csv_ullong_pos331(X,Y) get_csv_ullong((X),(Y),331) +#define get_csv_ip_pos331(X,Y) get_csv_ip((X),(Y),331) +#define get_csv_ipv6_pos331(X,Y) get_csv_ipv6((X),(Y),331) +#define get_csv_string_pos331(X,Y) get_csv_string((X),(Y),331) +#define get_csv_v_str_pos331(X,Y) get_csv_string((X),(Y),331) +#define get_csv_bool_pos331(X,Y) get_csv_bool((X),(Y),331) +#define get_csv_int_pos331(X,Y) get_csv_int((X),(Y),331) +#define get_csv_llong_pos331(X,Y) get_csv_llong((X),(Y),331) +#define get_csv_float_pos331(X,Y) get_csv_float((X),(Y),331) +#define get_csv_uint_pos332(X,Y) get_csv_uint((X),(Y),332) +#define get_csv_ullong_pos332(X,Y) get_csv_ullong((X),(Y),332) +#define get_csv_ip_pos332(X,Y) get_csv_ip((X),(Y),332) +#define get_csv_ipv6_pos332(X,Y) get_csv_ipv6((X),(Y),332) +#define get_csv_string_pos332(X,Y) get_csv_string((X),(Y),332) +#define get_csv_v_str_pos332(X,Y) get_csv_string((X),(Y),332) +#define get_csv_bool_pos332(X,Y) get_csv_bool((X),(Y),332) +#define get_csv_int_pos332(X,Y) get_csv_int((X),(Y),332) +#define get_csv_llong_pos332(X,Y) get_csv_llong((X),(Y),332) +#define get_csv_float_pos332(X,Y) get_csv_float((X),(Y),332) +#define get_csv_uint_pos333(X,Y) get_csv_uint((X),(Y),333) +#define get_csv_ullong_pos333(X,Y) get_csv_ullong((X),(Y),333) +#define get_csv_ip_pos333(X,Y) get_csv_ip((X),(Y),333) +#define get_csv_ipv6_pos333(X,Y) get_csv_ipv6((X),(Y),333) +#define get_csv_string_pos333(X,Y) get_csv_string((X),(Y),333) +#define get_csv_v_str_pos333(X,Y) get_csv_string((X),(Y),333) +#define get_csv_bool_pos333(X,Y) get_csv_bool((X),(Y),333) +#define get_csv_int_pos333(X,Y) get_csv_int((X),(Y),333) +#define get_csv_llong_pos333(X,Y) get_csv_llong((X),(Y),333) +#define get_csv_float_pos333(X,Y) get_csv_float((X),(Y),333) +#define get_csv_uint_pos334(X,Y) get_csv_uint((X),(Y),334) +#define get_csv_ullong_pos334(X,Y) get_csv_ullong((X),(Y),334) +#define get_csv_ip_pos334(X,Y) get_csv_ip((X),(Y),334) +#define get_csv_ipv6_pos334(X,Y) get_csv_ipv6((X),(Y),334) +#define get_csv_string_pos334(X,Y) get_csv_string((X),(Y),334) +#define get_csv_v_str_pos334(X,Y) get_csv_string((X),(Y),334) +#define get_csv_bool_pos334(X,Y) get_csv_bool((X),(Y),334) +#define get_csv_int_pos334(X,Y) get_csv_int((X),(Y),334) +#define get_csv_llong_pos334(X,Y) get_csv_llong((X),(Y),334) +#define get_csv_float_pos334(X,Y) get_csv_float((X),(Y),334) +#define get_csv_uint_pos335(X,Y) get_csv_uint((X),(Y),335) +#define get_csv_ullong_pos335(X,Y) get_csv_ullong((X),(Y),335) +#define get_csv_ip_pos335(X,Y) get_csv_ip((X),(Y),335) +#define get_csv_ipv6_pos335(X,Y) get_csv_ipv6((X),(Y),335) +#define get_csv_string_pos335(X,Y) get_csv_string((X),(Y),335) +#define get_csv_v_str_pos335(X,Y) get_csv_string((X),(Y),335) +#define get_csv_bool_pos335(X,Y) get_csv_bool((X),(Y),335) +#define get_csv_int_pos335(X,Y) get_csv_int((X),(Y),335) +#define get_csv_llong_pos335(X,Y) get_csv_llong((X),(Y),335) +#define get_csv_float_pos335(X,Y) get_csv_float((X),(Y),335) +#define get_csv_uint_pos336(X,Y) get_csv_uint((X),(Y),336) +#define get_csv_ullong_pos336(X,Y) get_csv_ullong((X),(Y),336) +#define get_csv_ip_pos336(X,Y) get_csv_ip((X),(Y),336) +#define get_csv_ipv6_pos336(X,Y) get_csv_ipv6((X),(Y),336) +#define get_csv_string_pos336(X,Y) get_csv_string((X),(Y),336) +#define get_csv_v_str_pos336(X,Y) get_csv_string((X),(Y),336) +#define get_csv_bool_pos336(X,Y) get_csv_bool((X),(Y),336) +#define get_csv_int_pos336(X,Y) get_csv_int((X),(Y),336) +#define get_csv_llong_pos336(X,Y) get_csv_llong((X),(Y),336) +#define get_csv_float_pos336(X,Y) get_csv_float((X),(Y),336) +#define get_csv_uint_pos337(X,Y) get_csv_uint((X),(Y),337) +#define get_csv_ullong_pos337(X,Y) get_csv_ullong((X),(Y),337) +#define get_csv_ip_pos337(X,Y) get_csv_ip((X),(Y),337) +#define get_csv_ipv6_pos337(X,Y) get_csv_ipv6((X),(Y),337) +#define get_csv_string_pos337(X,Y) get_csv_string((X),(Y),337) +#define get_csv_v_str_pos337(X,Y) get_csv_string((X),(Y),337) +#define get_csv_bool_pos337(X,Y) get_csv_bool((X),(Y),337) +#define get_csv_int_pos337(X,Y) get_csv_int((X),(Y),337) +#define get_csv_llong_pos337(X,Y) get_csv_llong((X),(Y),337) +#define get_csv_float_pos337(X,Y) get_csv_float((X),(Y),337) +#define get_csv_uint_pos338(X,Y) get_csv_uint((X),(Y),338) +#define get_csv_ullong_pos338(X,Y) get_csv_ullong((X),(Y),338) +#define get_csv_ip_pos338(X,Y) get_csv_ip((X),(Y),338) +#define get_csv_ipv6_pos338(X,Y) get_csv_ipv6((X),(Y),338) +#define get_csv_string_pos338(X,Y) get_csv_string((X),(Y),338) +#define get_csv_v_str_pos338(X,Y) get_csv_string((X),(Y),338) +#define get_csv_bool_pos338(X,Y) get_csv_bool((X),(Y),338) +#define get_csv_int_pos338(X,Y) get_csv_int((X),(Y),338) +#define get_csv_llong_pos338(X,Y) get_csv_llong((X),(Y),338) +#define get_csv_float_pos338(X,Y) get_csv_float((X),(Y),338) +#define get_csv_uint_pos339(X,Y) get_csv_uint((X),(Y),339) +#define get_csv_ullong_pos339(X,Y) get_csv_ullong((X),(Y),339) +#define get_csv_ip_pos339(X,Y) get_csv_ip((X),(Y),339) +#define get_csv_ipv6_pos339(X,Y) get_csv_ipv6((X),(Y),339) +#define get_csv_string_pos339(X,Y) get_csv_string((X),(Y),339) +#define get_csv_v_str_pos339(X,Y) get_csv_string((X),(Y),339) +#define get_csv_bool_pos339(X,Y) get_csv_bool((X),(Y),339) +#define get_csv_int_pos339(X,Y) get_csv_int((X),(Y),339) +#define get_csv_llong_pos339(X,Y) get_csv_llong((X),(Y),339) +#define get_csv_float_pos339(X,Y) get_csv_float((X),(Y),339) +#define get_csv_uint_pos340(X,Y) get_csv_uint((X),(Y),340) +#define get_csv_ullong_pos340(X,Y) get_csv_ullong((X),(Y),340) +#define get_csv_ip_pos340(X,Y) get_csv_ip((X),(Y),340) +#define get_csv_ipv6_pos340(X,Y) get_csv_ipv6((X),(Y),340) +#define get_csv_string_pos340(X,Y) get_csv_string((X),(Y),340) +#define get_csv_v_str_pos340(X,Y) get_csv_string((X),(Y),340) +#define get_csv_bool_pos340(X,Y) get_csv_bool((X),(Y),340) +#define get_csv_int_pos340(X,Y) get_csv_int((X),(Y),340) +#define get_csv_llong_pos340(X,Y) get_csv_llong((X),(Y),340) +#define get_csv_float_pos340(X,Y) get_csv_float((X),(Y),340) +#define get_csv_uint_pos341(X,Y) get_csv_uint((X),(Y),341) +#define get_csv_ullong_pos341(X,Y) get_csv_ullong((X),(Y),341) +#define get_csv_ip_pos341(X,Y) get_csv_ip((X),(Y),341) +#define get_csv_ipv6_pos341(X,Y) get_csv_ipv6((X),(Y),341) +#define get_csv_string_pos341(X,Y) get_csv_string((X),(Y),341) +#define get_csv_v_str_pos341(X,Y) get_csv_string((X),(Y),341) +#define get_csv_bool_pos341(X,Y) get_csv_bool((X),(Y),341) +#define get_csv_int_pos341(X,Y) get_csv_int((X),(Y),341) +#define get_csv_llong_pos341(X,Y) get_csv_llong((X),(Y),341) +#define get_csv_float_pos341(X,Y) get_csv_float((X),(Y),341) +#define get_csv_uint_pos342(X,Y) get_csv_uint((X),(Y),342) +#define get_csv_ullong_pos342(X,Y) get_csv_ullong((X),(Y),342) +#define get_csv_ip_pos342(X,Y) get_csv_ip((X),(Y),342) +#define get_csv_ipv6_pos342(X,Y) get_csv_ipv6((X),(Y),342) +#define get_csv_string_pos342(X,Y) get_csv_string((X),(Y),342) +#define get_csv_v_str_pos342(X,Y) get_csv_string((X),(Y),342) +#define get_csv_bool_pos342(X,Y) get_csv_bool((X),(Y),342) +#define get_csv_int_pos342(X,Y) get_csv_int((X),(Y),342) +#define get_csv_llong_pos342(X,Y) get_csv_llong((X),(Y),342) +#define get_csv_float_pos342(X,Y) get_csv_float((X),(Y),342) +#define get_csv_uint_pos343(X,Y) get_csv_uint((X),(Y),343) +#define get_csv_ullong_pos343(X,Y) get_csv_ullong((X),(Y),343) +#define get_csv_ip_pos343(X,Y) get_csv_ip((X),(Y),343) +#define get_csv_ipv6_pos343(X,Y) get_csv_ipv6((X),(Y),343) +#define get_csv_string_pos343(X,Y) get_csv_string((X),(Y),343) +#define get_csv_v_str_pos343(X,Y) get_csv_string((X),(Y),343) +#define get_csv_bool_pos343(X,Y) get_csv_bool((X),(Y),343) +#define get_csv_int_pos343(X,Y) get_csv_int((X),(Y),343) +#define get_csv_llong_pos343(X,Y) get_csv_llong((X),(Y),343) +#define get_csv_float_pos343(X,Y) get_csv_float((X),(Y),343) +#define get_csv_uint_pos344(X,Y) get_csv_uint((X),(Y),344) +#define get_csv_ullong_pos344(X,Y) get_csv_ullong((X),(Y),344) +#define get_csv_ip_pos344(X,Y) get_csv_ip((X),(Y),344) +#define get_csv_ipv6_pos344(X,Y) get_csv_ipv6((X),(Y),344) +#define get_csv_string_pos344(X,Y) get_csv_string((X),(Y),344) +#define get_csv_v_str_pos344(X,Y) get_csv_string((X),(Y),344) +#define get_csv_bool_pos344(X,Y) get_csv_bool((X),(Y),344) +#define get_csv_int_pos344(X,Y) get_csv_int((X),(Y),344) +#define get_csv_llong_pos344(X,Y) get_csv_llong((X),(Y),344) +#define get_csv_float_pos344(X,Y) get_csv_float((X),(Y),344) +#define get_csv_uint_pos345(X,Y) get_csv_uint((X),(Y),345) +#define get_csv_ullong_pos345(X,Y) get_csv_ullong((X),(Y),345) +#define get_csv_ip_pos345(X,Y) get_csv_ip((X),(Y),345) +#define get_csv_ipv6_pos345(X,Y) get_csv_ipv6((X),(Y),345) +#define get_csv_string_pos345(X,Y) get_csv_string((X),(Y),345) +#define get_csv_v_str_pos345(X,Y) get_csv_string((X),(Y),345) +#define get_csv_bool_pos345(X,Y) get_csv_bool((X),(Y),345) +#define get_csv_int_pos345(X,Y) get_csv_int((X),(Y),345) +#define get_csv_llong_pos345(X,Y) get_csv_llong((X),(Y),345) +#define get_csv_float_pos345(X,Y) get_csv_float((X),(Y),345) +#define get_csv_uint_pos346(X,Y) get_csv_uint((X),(Y),346) +#define get_csv_ullong_pos346(X,Y) get_csv_ullong((X),(Y),346) +#define get_csv_ip_pos346(X,Y) get_csv_ip((X),(Y),346) +#define get_csv_ipv6_pos346(X,Y) get_csv_ipv6((X),(Y),346) +#define get_csv_string_pos346(X,Y) get_csv_string((X),(Y),346) +#define get_csv_v_str_pos346(X,Y) get_csv_string((X),(Y),346) +#define get_csv_bool_pos346(X,Y) get_csv_bool((X),(Y),346) +#define get_csv_int_pos346(X,Y) get_csv_int((X),(Y),346) +#define get_csv_llong_pos346(X,Y) get_csv_llong((X),(Y),346) +#define get_csv_float_pos346(X,Y) get_csv_float((X),(Y),346) +#define get_csv_uint_pos347(X,Y) get_csv_uint((X),(Y),347) +#define get_csv_ullong_pos347(X,Y) get_csv_ullong((X),(Y),347) +#define get_csv_ip_pos347(X,Y) get_csv_ip((X),(Y),347) +#define get_csv_ipv6_pos347(X,Y) get_csv_ipv6((X),(Y),347) +#define get_csv_string_pos347(X,Y) get_csv_string((X),(Y),347) +#define get_csv_v_str_pos347(X,Y) get_csv_string((X),(Y),347) +#define get_csv_bool_pos347(X,Y) get_csv_bool((X),(Y),347) +#define get_csv_int_pos347(X,Y) get_csv_int((X),(Y),347) +#define get_csv_llong_pos347(X,Y) get_csv_llong((X),(Y),347) +#define get_csv_float_pos347(X,Y) get_csv_float((X),(Y),347) +#define get_csv_uint_pos348(X,Y) get_csv_uint((X),(Y),348) +#define get_csv_ullong_pos348(X,Y) get_csv_ullong((X),(Y),348) +#define get_csv_ip_pos348(X,Y) get_csv_ip((X),(Y),348) +#define get_csv_ipv6_pos348(X,Y) get_csv_ipv6((X),(Y),348) +#define get_csv_string_pos348(X,Y) get_csv_string((X),(Y),348) +#define get_csv_v_str_pos348(X,Y) get_csv_string((X),(Y),348) +#define get_csv_bool_pos348(X,Y) get_csv_bool((X),(Y),348) +#define get_csv_int_pos348(X,Y) get_csv_int((X),(Y),348) +#define get_csv_llong_pos348(X,Y) get_csv_llong((X),(Y),348) +#define get_csv_float_pos348(X,Y) get_csv_float((X),(Y),348) +#define get_csv_uint_pos349(X,Y) get_csv_uint((X),(Y),349) +#define get_csv_ullong_pos349(X,Y) get_csv_ullong((X),(Y),349) +#define get_csv_ip_pos349(X,Y) get_csv_ip((X),(Y),349) +#define get_csv_ipv6_pos349(X,Y) get_csv_ipv6((X),(Y),349) +#define get_csv_string_pos349(X,Y) get_csv_string((X),(Y),349) +#define get_csv_v_str_pos349(X,Y) get_csv_string((X),(Y),349) +#define get_csv_bool_pos349(X,Y) get_csv_bool((X),(Y),349) +#define get_csv_int_pos349(X,Y) get_csv_int((X),(Y),349) +#define get_csv_llong_pos349(X,Y) get_csv_llong((X),(Y),349) +#define get_csv_float_pos349(X,Y) get_csv_float((X),(Y),349) +#define get_csv_uint_pos350(X,Y) get_csv_uint((X),(Y),350) +#define get_csv_ullong_pos350(X,Y) get_csv_ullong((X),(Y),350) +#define get_csv_ip_pos350(X,Y) get_csv_ip((X),(Y),350) +#define get_csv_ipv6_pos350(X,Y) get_csv_ipv6((X),(Y),350) +#define get_csv_string_pos350(X,Y) get_csv_string((X),(Y),350) +#define get_csv_v_str_pos350(X,Y) get_csv_string((X),(Y),350) +#define get_csv_bool_pos350(X,Y) get_csv_bool((X),(Y),350) +#define get_csv_int_pos350(X,Y) get_csv_int((X),(Y),350) +#define get_csv_llong_pos350(X,Y) get_csv_llong((X),(Y),350) +#define get_csv_float_pos350(X,Y) get_csv_float((X),(Y),350) +#define get_csv_uint_pos351(X,Y) get_csv_uint((X),(Y),351) +#define get_csv_ullong_pos351(X,Y) get_csv_ullong((X),(Y),351) +#define get_csv_ip_pos351(X,Y) get_csv_ip((X),(Y),351) +#define get_csv_ipv6_pos351(X,Y) get_csv_ipv6((X),(Y),351) +#define get_csv_string_pos351(X,Y) get_csv_string((X),(Y),351) +#define get_csv_v_str_pos351(X,Y) get_csv_string((X),(Y),351) +#define get_csv_bool_pos351(X,Y) get_csv_bool((X),(Y),351) +#define get_csv_int_pos351(X,Y) get_csv_int((X),(Y),351) +#define get_csv_llong_pos351(X,Y) get_csv_llong((X),(Y),351) +#define get_csv_float_pos351(X,Y) get_csv_float((X),(Y),351) +#define get_csv_uint_pos352(X,Y) get_csv_uint((X),(Y),352) +#define get_csv_ullong_pos352(X,Y) get_csv_ullong((X),(Y),352) +#define get_csv_ip_pos352(X,Y) get_csv_ip((X),(Y),352) +#define get_csv_ipv6_pos352(X,Y) get_csv_ipv6((X),(Y),352) +#define get_csv_string_pos352(X,Y) get_csv_string((X),(Y),352) +#define get_csv_v_str_pos352(X,Y) get_csv_string((X),(Y),352) +#define get_csv_bool_pos352(X,Y) get_csv_bool((X),(Y),352) +#define get_csv_int_pos352(X,Y) get_csv_int((X),(Y),352) +#define get_csv_llong_pos352(X,Y) get_csv_llong((X),(Y),352) +#define get_csv_float_pos352(X,Y) get_csv_float((X),(Y),352) +#define get_csv_uint_pos353(X,Y) get_csv_uint((X),(Y),353) +#define get_csv_ullong_pos353(X,Y) get_csv_ullong((X),(Y),353) +#define get_csv_ip_pos353(X,Y) get_csv_ip((X),(Y),353) +#define get_csv_ipv6_pos353(X,Y) get_csv_ipv6((X),(Y),353) +#define get_csv_string_pos353(X,Y) get_csv_string((X),(Y),353) +#define get_csv_v_str_pos353(X,Y) get_csv_string((X),(Y),353) +#define get_csv_bool_pos353(X,Y) get_csv_bool((X),(Y),353) +#define get_csv_int_pos353(X,Y) get_csv_int((X),(Y),353) +#define get_csv_llong_pos353(X,Y) get_csv_llong((X),(Y),353) +#define get_csv_float_pos353(X,Y) get_csv_float((X),(Y),353) +#define get_csv_uint_pos354(X,Y) get_csv_uint((X),(Y),354) +#define get_csv_ullong_pos354(X,Y) get_csv_ullong((X),(Y),354) +#define get_csv_ip_pos354(X,Y) get_csv_ip((X),(Y),354) +#define get_csv_ipv6_pos354(X,Y) get_csv_ipv6((X),(Y),354) +#define get_csv_string_pos354(X,Y) get_csv_string((X),(Y),354) +#define get_csv_v_str_pos354(X,Y) get_csv_string((X),(Y),354) +#define get_csv_bool_pos354(X,Y) get_csv_bool((X),(Y),354) +#define get_csv_int_pos354(X,Y) get_csv_int((X),(Y),354) +#define get_csv_llong_pos354(X,Y) get_csv_llong((X),(Y),354) +#define get_csv_float_pos354(X,Y) get_csv_float((X),(Y),354) +#define get_csv_uint_pos355(X,Y) get_csv_uint((X),(Y),355) +#define get_csv_ullong_pos355(X,Y) get_csv_ullong((X),(Y),355) +#define get_csv_ip_pos355(X,Y) get_csv_ip((X),(Y),355) +#define get_csv_ipv6_pos355(X,Y) get_csv_ipv6((X),(Y),355) +#define get_csv_string_pos355(X,Y) get_csv_string((X),(Y),355) +#define get_csv_v_str_pos355(X,Y) get_csv_string((X),(Y),355) +#define get_csv_bool_pos355(X,Y) get_csv_bool((X),(Y),355) +#define get_csv_int_pos355(X,Y) get_csv_int((X),(Y),355) +#define get_csv_llong_pos355(X,Y) get_csv_llong((X),(Y),355) +#define get_csv_float_pos355(X,Y) get_csv_float((X),(Y),355) +#define get_csv_uint_pos356(X,Y) get_csv_uint((X),(Y),356) +#define get_csv_ullong_pos356(X,Y) get_csv_ullong((X),(Y),356) +#define get_csv_ip_pos356(X,Y) get_csv_ip((X),(Y),356) +#define get_csv_ipv6_pos356(X,Y) get_csv_ipv6((X),(Y),356) +#define get_csv_string_pos356(X,Y) get_csv_string((X),(Y),356) +#define get_csv_v_str_pos356(X,Y) get_csv_string((X),(Y),356) +#define get_csv_bool_pos356(X,Y) get_csv_bool((X),(Y),356) +#define get_csv_int_pos356(X,Y) get_csv_int((X),(Y),356) +#define get_csv_llong_pos356(X,Y) get_csv_llong((X),(Y),356) +#define get_csv_float_pos356(X,Y) get_csv_float((X),(Y),356) +#define get_csv_uint_pos357(X,Y) get_csv_uint((X),(Y),357) +#define get_csv_ullong_pos357(X,Y) get_csv_ullong((X),(Y),357) +#define get_csv_ip_pos357(X,Y) get_csv_ip((X),(Y),357) +#define get_csv_ipv6_pos357(X,Y) get_csv_ipv6((X),(Y),357) +#define get_csv_string_pos357(X,Y) get_csv_string((X),(Y),357) +#define get_csv_v_str_pos357(X,Y) get_csv_string((X),(Y),357) +#define get_csv_bool_pos357(X,Y) get_csv_bool((X),(Y),357) +#define get_csv_int_pos357(X,Y) get_csv_int((X),(Y),357) +#define get_csv_llong_pos357(X,Y) get_csv_llong((X),(Y),357) +#define get_csv_float_pos357(X,Y) get_csv_float((X),(Y),357) +#define get_csv_uint_pos358(X,Y) get_csv_uint((X),(Y),358) +#define get_csv_ullong_pos358(X,Y) get_csv_ullong((X),(Y),358) +#define get_csv_ip_pos358(X,Y) get_csv_ip((X),(Y),358) +#define get_csv_ipv6_pos358(X,Y) get_csv_ipv6((X),(Y),358) +#define get_csv_string_pos358(X,Y) get_csv_string((X),(Y),358) +#define get_csv_v_str_pos358(X,Y) get_csv_string((X),(Y),358) +#define get_csv_bool_pos358(X,Y) get_csv_bool((X),(Y),358) +#define get_csv_int_pos358(X,Y) get_csv_int((X),(Y),358) +#define get_csv_llong_pos358(X,Y) get_csv_llong((X),(Y),358) +#define get_csv_float_pos358(X,Y) get_csv_float((X),(Y),358) +#define get_csv_uint_pos359(X,Y) get_csv_uint((X),(Y),359) +#define get_csv_ullong_pos359(X,Y) get_csv_ullong((X),(Y),359) +#define get_csv_ip_pos359(X,Y) get_csv_ip((X),(Y),359) +#define get_csv_ipv6_pos359(X,Y) get_csv_ipv6((X),(Y),359) +#define get_csv_string_pos359(X,Y) get_csv_string((X),(Y),359) +#define get_csv_v_str_pos359(X,Y) get_csv_string((X),(Y),359) +#define get_csv_bool_pos359(X,Y) get_csv_bool((X),(Y),359) +#define get_csv_int_pos359(X,Y) get_csv_int((X),(Y),359) +#define get_csv_llong_pos359(X,Y) get_csv_llong((X),(Y),359) +#define get_csv_float_pos359(X,Y) get_csv_float((X),(Y),359) +#define get_csv_uint_pos360(X,Y) get_csv_uint((X),(Y),360) +#define get_csv_ullong_pos360(X,Y) get_csv_ullong((X),(Y),360) +#define get_csv_ip_pos360(X,Y) get_csv_ip((X),(Y),360) +#define get_csv_ipv6_pos360(X,Y) get_csv_ipv6((X),(Y),360) +#define get_csv_string_pos360(X,Y) get_csv_string((X),(Y),360) +#define get_csv_v_str_pos360(X,Y) get_csv_string((X),(Y),360) +#define get_csv_bool_pos360(X,Y) get_csv_bool((X),(Y),360) +#define get_csv_int_pos360(X,Y) get_csv_int((X),(Y),360) +#define get_csv_llong_pos360(X,Y) get_csv_llong((X),(Y),360) +#define get_csv_float_pos360(X,Y) get_csv_float((X),(Y),360) +#define get_csv_uint_pos361(X,Y) get_csv_uint((X),(Y),361) +#define get_csv_ullong_pos361(X,Y) get_csv_ullong((X),(Y),361) +#define get_csv_ip_pos361(X,Y) get_csv_ip((X),(Y),361) +#define get_csv_ipv6_pos361(X,Y) get_csv_ipv6((X),(Y),361) +#define get_csv_string_pos361(X,Y) get_csv_string((X),(Y),361) +#define get_csv_v_str_pos361(X,Y) get_csv_string((X),(Y),361) +#define get_csv_bool_pos361(X,Y) get_csv_bool((X),(Y),361) +#define get_csv_int_pos361(X,Y) get_csv_int((X),(Y),361) +#define get_csv_llong_pos361(X,Y) get_csv_llong((X),(Y),361) +#define get_csv_float_pos361(X,Y) get_csv_float((X),(Y),361) +#define get_csv_uint_pos362(X,Y) get_csv_uint((X),(Y),362) +#define get_csv_ullong_pos362(X,Y) get_csv_ullong((X),(Y),362) +#define get_csv_ip_pos362(X,Y) get_csv_ip((X),(Y),362) +#define get_csv_ipv6_pos362(X,Y) get_csv_ipv6((X),(Y),362) +#define get_csv_string_pos362(X,Y) get_csv_string((X),(Y),362) +#define get_csv_v_str_pos362(X,Y) get_csv_string((X),(Y),362) +#define get_csv_bool_pos362(X,Y) get_csv_bool((X),(Y),362) +#define get_csv_int_pos362(X,Y) get_csv_int((X),(Y),362) +#define get_csv_llong_pos362(X,Y) get_csv_llong((X),(Y),362) +#define get_csv_float_pos362(X,Y) get_csv_float((X),(Y),362) +#define get_csv_uint_pos363(X,Y) get_csv_uint((X),(Y),363) +#define get_csv_ullong_pos363(X,Y) get_csv_ullong((X),(Y),363) +#define get_csv_ip_pos363(X,Y) get_csv_ip((X),(Y),363) +#define get_csv_ipv6_pos363(X,Y) get_csv_ipv6((X),(Y),363) +#define get_csv_string_pos363(X,Y) get_csv_string((X),(Y),363) +#define get_csv_v_str_pos363(X,Y) get_csv_string((X),(Y),363) +#define get_csv_bool_pos363(X,Y) get_csv_bool((X),(Y),363) +#define get_csv_int_pos363(X,Y) get_csv_int((X),(Y),363) +#define get_csv_llong_pos363(X,Y) get_csv_llong((X),(Y),363) +#define get_csv_float_pos363(X,Y) get_csv_float((X),(Y),363) +#define get_csv_uint_pos364(X,Y) get_csv_uint((X),(Y),364) +#define get_csv_ullong_pos364(X,Y) get_csv_ullong((X),(Y),364) +#define get_csv_ip_pos364(X,Y) get_csv_ip((X),(Y),364) +#define get_csv_ipv6_pos364(X,Y) get_csv_ipv6((X),(Y),364) +#define get_csv_string_pos364(X,Y) get_csv_string((X),(Y),364) +#define get_csv_v_str_pos364(X,Y) get_csv_string((X),(Y),364) +#define get_csv_bool_pos364(X,Y) get_csv_bool((X),(Y),364) +#define get_csv_int_pos364(X,Y) get_csv_int((X),(Y),364) +#define get_csv_llong_pos364(X,Y) get_csv_llong((X),(Y),364) +#define get_csv_float_pos364(X,Y) get_csv_float((X),(Y),364) +#define get_csv_uint_pos365(X,Y) get_csv_uint((X),(Y),365) +#define get_csv_ullong_pos365(X,Y) get_csv_ullong((X),(Y),365) +#define get_csv_ip_pos365(X,Y) get_csv_ip((X),(Y),365) +#define get_csv_ipv6_pos365(X,Y) get_csv_ipv6((X),(Y),365) +#define get_csv_string_pos365(X,Y) get_csv_string((X),(Y),365) +#define get_csv_v_str_pos365(X,Y) get_csv_string((X),(Y),365) +#define get_csv_bool_pos365(X,Y) get_csv_bool((X),(Y),365) +#define get_csv_int_pos365(X,Y) get_csv_int((X),(Y),365) +#define get_csv_llong_pos365(X,Y) get_csv_llong((X),(Y),365) +#define get_csv_float_pos365(X,Y) get_csv_float((X),(Y),365) +#define get_csv_uint_pos366(X,Y) get_csv_uint((X),(Y),366) +#define get_csv_ullong_pos366(X,Y) get_csv_ullong((X),(Y),366) +#define get_csv_ip_pos366(X,Y) get_csv_ip((X),(Y),366) +#define get_csv_ipv6_pos366(X,Y) get_csv_ipv6((X),(Y),366) +#define get_csv_string_pos366(X,Y) get_csv_string((X),(Y),366) +#define get_csv_v_str_pos366(X,Y) get_csv_string((X),(Y),366) +#define get_csv_bool_pos366(X,Y) get_csv_bool((X),(Y),366) +#define get_csv_int_pos366(X,Y) get_csv_int((X),(Y),366) +#define get_csv_llong_pos366(X,Y) get_csv_llong((X),(Y),366) +#define get_csv_float_pos366(X,Y) get_csv_float((X),(Y),366) +#define get_csv_uint_pos367(X,Y) get_csv_uint((X),(Y),367) +#define get_csv_ullong_pos367(X,Y) get_csv_ullong((X),(Y),367) +#define get_csv_ip_pos367(X,Y) get_csv_ip((X),(Y),367) +#define get_csv_ipv6_pos367(X,Y) get_csv_ipv6((X),(Y),367) +#define get_csv_string_pos367(X,Y) get_csv_string((X),(Y),367) +#define get_csv_v_str_pos367(X,Y) get_csv_string((X),(Y),367) +#define get_csv_bool_pos367(X,Y) get_csv_bool((X),(Y),367) +#define get_csv_int_pos367(X,Y) get_csv_int((X),(Y),367) +#define get_csv_llong_pos367(X,Y) get_csv_llong((X),(Y),367) +#define get_csv_float_pos367(X,Y) get_csv_float((X),(Y),367) +#define get_csv_uint_pos368(X,Y) get_csv_uint((X),(Y),368) +#define get_csv_ullong_pos368(X,Y) get_csv_ullong((X),(Y),368) +#define get_csv_ip_pos368(X,Y) get_csv_ip((X),(Y),368) +#define get_csv_ipv6_pos368(X,Y) get_csv_ipv6((X),(Y),368) +#define get_csv_string_pos368(X,Y) get_csv_string((X),(Y),368) +#define get_csv_v_str_pos368(X,Y) get_csv_string((X),(Y),368) +#define get_csv_bool_pos368(X,Y) get_csv_bool((X),(Y),368) +#define get_csv_int_pos368(X,Y) get_csv_int((X),(Y),368) +#define get_csv_llong_pos368(X,Y) get_csv_llong((X),(Y),368) +#define get_csv_float_pos368(X,Y) get_csv_float((X),(Y),368) +#define get_csv_uint_pos369(X,Y) get_csv_uint((X),(Y),369) +#define get_csv_ullong_pos369(X,Y) get_csv_ullong((X),(Y),369) +#define get_csv_ip_pos369(X,Y) get_csv_ip((X),(Y),369) +#define get_csv_ipv6_pos369(X,Y) get_csv_ipv6((X),(Y),369) +#define get_csv_string_pos369(X,Y) get_csv_string((X),(Y),369) +#define get_csv_v_str_pos369(X,Y) get_csv_string((X),(Y),369) +#define get_csv_bool_pos369(X,Y) get_csv_bool((X),(Y),369) +#define get_csv_int_pos369(X,Y) get_csv_int((X),(Y),369) +#define get_csv_llong_pos369(X,Y) get_csv_llong((X),(Y),369) +#define get_csv_float_pos369(X,Y) get_csv_float((X),(Y),369) +#define get_csv_uint_pos370(X,Y) get_csv_uint((X),(Y),370) +#define get_csv_ullong_pos370(X,Y) get_csv_ullong((X),(Y),370) +#define get_csv_ip_pos370(X,Y) get_csv_ip((X),(Y),370) +#define get_csv_ipv6_pos370(X,Y) get_csv_ipv6((X),(Y),370) +#define get_csv_string_pos370(X,Y) get_csv_string((X),(Y),370) +#define get_csv_v_str_pos370(X,Y) get_csv_string((X),(Y),370) +#define get_csv_bool_pos370(X,Y) get_csv_bool((X),(Y),370) +#define get_csv_int_pos370(X,Y) get_csv_int((X),(Y),370) +#define get_csv_llong_pos370(X,Y) get_csv_llong((X),(Y),370) +#define get_csv_float_pos370(X,Y) get_csv_float((X),(Y),370) +#define get_csv_uint_pos371(X,Y) get_csv_uint((X),(Y),371) +#define get_csv_ullong_pos371(X,Y) get_csv_ullong((X),(Y),371) +#define get_csv_ip_pos371(X,Y) get_csv_ip((X),(Y),371) +#define get_csv_ipv6_pos371(X,Y) get_csv_ipv6((X),(Y),371) +#define get_csv_string_pos371(X,Y) get_csv_string((X),(Y),371) +#define get_csv_v_str_pos371(X,Y) get_csv_string((X),(Y),371) +#define get_csv_bool_pos371(X,Y) get_csv_bool((X),(Y),371) +#define get_csv_int_pos371(X,Y) get_csv_int((X),(Y),371) +#define get_csv_llong_pos371(X,Y) get_csv_llong((X),(Y),371) +#define get_csv_float_pos371(X,Y) get_csv_float((X),(Y),371) +#define get_csv_uint_pos372(X,Y) get_csv_uint((X),(Y),372) +#define get_csv_ullong_pos372(X,Y) get_csv_ullong((X),(Y),372) +#define get_csv_ip_pos372(X,Y) get_csv_ip((X),(Y),372) +#define get_csv_ipv6_pos372(X,Y) get_csv_ipv6((X),(Y),372) +#define get_csv_string_pos372(X,Y) get_csv_string((X),(Y),372) +#define get_csv_v_str_pos372(X,Y) get_csv_string((X),(Y),372) +#define get_csv_bool_pos372(X,Y) get_csv_bool((X),(Y),372) +#define get_csv_int_pos372(X,Y) get_csv_int((X),(Y),372) +#define get_csv_llong_pos372(X,Y) get_csv_llong((X),(Y),372) +#define get_csv_float_pos372(X,Y) get_csv_float((X),(Y),372) +#define get_csv_uint_pos373(X,Y) get_csv_uint((X),(Y),373) +#define get_csv_ullong_pos373(X,Y) get_csv_ullong((X),(Y),373) +#define get_csv_ip_pos373(X,Y) get_csv_ip((X),(Y),373) +#define get_csv_ipv6_pos373(X,Y) get_csv_ipv6((X),(Y),373) +#define get_csv_string_pos373(X,Y) get_csv_string((X),(Y),373) +#define get_csv_v_str_pos373(X,Y) get_csv_string((X),(Y),373) +#define get_csv_bool_pos373(X,Y) get_csv_bool((X),(Y),373) +#define get_csv_int_pos373(X,Y) get_csv_int((X),(Y),373) +#define get_csv_llong_pos373(X,Y) get_csv_llong((X),(Y),373) +#define get_csv_float_pos373(X,Y) get_csv_float((X),(Y),373) +#define get_csv_uint_pos374(X,Y) get_csv_uint((X),(Y),374) +#define get_csv_ullong_pos374(X,Y) get_csv_ullong((X),(Y),374) +#define get_csv_ip_pos374(X,Y) get_csv_ip((X),(Y),374) +#define get_csv_ipv6_pos374(X,Y) get_csv_ipv6((X),(Y),374) +#define get_csv_string_pos374(X,Y) get_csv_string((X),(Y),374) +#define get_csv_v_str_pos374(X,Y) get_csv_string((X),(Y),374) +#define get_csv_bool_pos374(X,Y) get_csv_bool((X),(Y),374) +#define get_csv_int_pos374(X,Y) get_csv_int((X),(Y),374) +#define get_csv_llong_pos374(X,Y) get_csv_llong((X),(Y),374) +#define get_csv_float_pos374(X,Y) get_csv_float((X),(Y),374) +#define get_csv_uint_pos375(X,Y) get_csv_uint((X),(Y),375) +#define get_csv_ullong_pos375(X,Y) get_csv_ullong((X),(Y),375) +#define get_csv_ip_pos375(X,Y) get_csv_ip((X),(Y),375) +#define get_csv_ipv6_pos375(X,Y) get_csv_ipv6((X),(Y),375) +#define get_csv_string_pos375(X,Y) get_csv_string((X),(Y),375) +#define get_csv_v_str_pos375(X,Y) get_csv_string((X),(Y),375) +#define get_csv_bool_pos375(X,Y) get_csv_bool((X),(Y),375) +#define get_csv_int_pos375(X,Y) get_csv_int((X),(Y),375) +#define get_csv_llong_pos375(X,Y) get_csv_llong((X),(Y),375) +#define get_csv_float_pos375(X,Y) get_csv_float((X),(Y),375) +#define get_csv_uint_pos376(X,Y) get_csv_uint((X),(Y),376) +#define get_csv_ullong_pos376(X,Y) get_csv_ullong((X),(Y),376) +#define get_csv_ip_pos376(X,Y) get_csv_ip((X),(Y),376) +#define get_csv_ipv6_pos376(X,Y) get_csv_ipv6((X),(Y),376) +#define get_csv_string_pos376(X,Y) get_csv_string((X),(Y),376) +#define get_csv_v_str_pos376(X,Y) get_csv_string((X),(Y),376) +#define get_csv_bool_pos376(X,Y) get_csv_bool((X),(Y),376) +#define get_csv_int_pos376(X,Y) get_csv_int((X),(Y),376) +#define get_csv_llong_pos376(X,Y) get_csv_llong((X),(Y),376) +#define get_csv_float_pos376(X,Y) get_csv_float((X),(Y),376) +#define get_csv_uint_pos377(X,Y) get_csv_uint((X),(Y),377) +#define get_csv_ullong_pos377(X,Y) get_csv_ullong((X),(Y),377) +#define get_csv_ip_pos377(X,Y) get_csv_ip((X),(Y),377) +#define get_csv_ipv6_pos377(X,Y) get_csv_ipv6((X),(Y),377) +#define get_csv_string_pos377(X,Y) get_csv_string((X),(Y),377) +#define get_csv_v_str_pos377(X,Y) get_csv_string((X),(Y),377) +#define get_csv_bool_pos377(X,Y) get_csv_bool((X),(Y),377) +#define get_csv_int_pos377(X,Y) get_csv_int((X),(Y),377) +#define get_csv_llong_pos377(X,Y) get_csv_llong((X),(Y),377) +#define get_csv_float_pos377(X,Y) get_csv_float((X),(Y),377) +#define get_csv_uint_pos378(X,Y) get_csv_uint((X),(Y),378) +#define get_csv_ullong_pos378(X,Y) get_csv_ullong((X),(Y),378) +#define get_csv_ip_pos378(X,Y) get_csv_ip((X),(Y),378) +#define get_csv_ipv6_pos378(X,Y) get_csv_ipv6((X),(Y),378) +#define get_csv_string_pos378(X,Y) get_csv_string((X),(Y),378) +#define get_csv_v_str_pos378(X,Y) get_csv_string((X),(Y),378) +#define get_csv_bool_pos378(X,Y) get_csv_bool((X),(Y),378) +#define get_csv_int_pos378(X,Y) get_csv_int((X),(Y),378) +#define get_csv_llong_pos378(X,Y) get_csv_llong((X),(Y),378) +#define get_csv_float_pos378(X,Y) get_csv_float((X),(Y),378) +#define get_csv_uint_pos379(X,Y) get_csv_uint((X),(Y),379) +#define get_csv_ullong_pos379(X,Y) get_csv_ullong((X),(Y),379) +#define get_csv_ip_pos379(X,Y) get_csv_ip((X),(Y),379) +#define get_csv_ipv6_pos379(X,Y) get_csv_ipv6((X),(Y),379) +#define get_csv_string_pos379(X,Y) get_csv_string((X),(Y),379) +#define get_csv_v_str_pos379(X,Y) get_csv_string((X),(Y),379) +#define get_csv_bool_pos379(X,Y) get_csv_bool((X),(Y),379) +#define get_csv_int_pos379(X,Y) get_csv_int((X),(Y),379) +#define get_csv_llong_pos379(X,Y) get_csv_llong((X),(Y),379) +#define get_csv_float_pos379(X,Y) get_csv_float((X),(Y),379) +#define get_csv_uint_pos380(X,Y) get_csv_uint((X),(Y),380) +#define get_csv_ullong_pos380(X,Y) get_csv_ullong((X),(Y),380) +#define get_csv_ip_pos380(X,Y) get_csv_ip((X),(Y),380) +#define get_csv_ipv6_pos380(X,Y) get_csv_ipv6((X),(Y),380) +#define get_csv_string_pos380(X,Y) get_csv_string((X),(Y),380) +#define get_csv_v_str_pos380(X,Y) get_csv_string((X),(Y),380) +#define get_csv_bool_pos380(X,Y) get_csv_bool((X),(Y),380) +#define get_csv_int_pos380(X,Y) get_csv_int((X),(Y),380) +#define get_csv_llong_pos380(X,Y) get_csv_llong((X),(Y),380) +#define get_csv_float_pos380(X,Y) get_csv_float((X),(Y),380) +#define get_csv_uint_pos381(X,Y) get_csv_uint((X),(Y),381) +#define get_csv_ullong_pos381(X,Y) get_csv_ullong((X),(Y),381) +#define get_csv_ip_pos381(X,Y) get_csv_ip((X),(Y),381) +#define get_csv_ipv6_pos381(X,Y) get_csv_ipv6((X),(Y),381) +#define get_csv_string_pos381(X,Y) get_csv_string((X),(Y),381) +#define get_csv_v_str_pos381(X,Y) get_csv_string((X),(Y),381) +#define get_csv_bool_pos381(X,Y) get_csv_bool((X),(Y),381) +#define get_csv_int_pos381(X,Y) get_csv_int((X),(Y),381) +#define get_csv_llong_pos381(X,Y) get_csv_llong((X),(Y),381) +#define get_csv_float_pos381(X,Y) get_csv_float((X),(Y),381) +#define get_csv_uint_pos382(X,Y) get_csv_uint((X),(Y),382) +#define get_csv_ullong_pos382(X,Y) get_csv_ullong((X),(Y),382) +#define get_csv_ip_pos382(X,Y) get_csv_ip((X),(Y),382) +#define get_csv_ipv6_pos382(X,Y) get_csv_ipv6((X),(Y),382) +#define get_csv_string_pos382(X,Y) get_csv_string((X),(Y),382) +#define get_csv_v_str_pos382(X,Y) get_csv_string((X),(Y),382) +#define get_csv_bool_pos382(X,Y) get_csv_bool((X),(Y),382) +#define get_csv_int_pos382(X,Y) get_csv_int((X),(Y),382) +#define get_csv_llong_pos382(X,Y) get_csv_llong((X),(Y),382) +#define get_csv_float_pos382(X,Y) get_csv_float((X),(Y),382) +#define get_csv_uint_pos383(X,Y) get_csv_uint((X),(Y),383) +#define get_csv_ullong_pos383(X,Y) get_csv_ullong((X),(Y),383) +#define get_csv_ip_pos383(X,Y) get_csv_ip((X),(Y),383) +#define get_csv_ipv6_pos383(X,Y) get_csv_ipv6((X),(Y),383) +#define get_csv_string_pos383(X,Y) get_csv_string((X),(Y),383) +#define get_csv_v_str_pos383(X,Y) get_csv_string((X),(Y),383) +#define get_csv_bool_pos383(X,Y) get_csv_bool((X),(Y),383) +#define get_csv_int_pos383(X,Y) get_csv_int((X),(Y),383) +#define get_csv_llong_pos383(X,Y) get_csv_llong((X),(Y),383) +#define get_csv_float_pos383(X,Y) get_csv_float((X),(Y),383) +#define get_csv_uint_pos384(X,Y) get_csv_uint((X),(Y),384) +#define get_csv_ullong_pos384(X,Y) get_csv_ullong((X),(Y),384) +#define get_csv_ip_pos384(X,Y) get_csv_ip((X),(Y),384) +#define get_csv_ipv6_pos384(X,Y) get_csv_ipv6((X),(Y),384) +#define get_csv_string_pos384(X,Y) get_csv_string((X),(Y),384) +#define get_csv_v_str_pos384(X,Y) get_csv_string((X),(Y),384) +#define get_csv_bool_pos384(X,Y) get_csv_bool((X),(Y),384) +#define get_csv_int_pos384(X,Y) get_csv_int((X),(Y),384) +#define get_csv_llong_pos384(X,Y) get_csv_llong((X),(Y),384) +#define get_csv_float_pos384(X,Y) get_csv_float((X),(Y),384) +#define get_csv_uint_pos385(X,Y) get_csv_uint((X),(Y),385) +#define get_csv_ullong_pos385(X,Y) get_csv_ullong((X),(Y),385) +#define get_csv_ip_pos385(X,Y) get_csv_ip((X),(Y),385) +#define get_csv_ipv6_pos385(X,Y) get_csv_ipv6((X),(Y),385) +#define get_csv_string_pos385(X,Y) get_csv_string((X),(Y),385) +#define get_csv_v_str_pos385(X,Y) get_csv_string((X),(Y),385) +#define get_csv_bool_pos385(X,Y) get_csv_bool((X),(Y),385) +#define get_csv_int_pos385(X,Y) get_csv_int((X),(Y),385) +#define get_csv_llong_pos385(X,Y) get_csv_llong((X),(Y),385) +#define get_csv_float_pos385(X,Y) get_csv_float((X),(Y),385) +#define get_csv_uint_pos386(X,Y) get_csv_uint((X),(Y),386) +#define get_csv_ullong_pos386(X,Y) get_csv_ullong((X),(Y),386) +#define get_csv_ip_pos386(X,Y) get_csv_ip((X),(Y),386) +#define get_csv_ipv6_pos386(X,Y) get_csv_ipv6((X),(Y),386) +#define get_csv_string_pos386(X,Y) get_csv_string((X),(Y),386) +#define get_csv_v_str_pos386(X,Y) get_csv_string((X),(Y),386) +#define get_csv_bool_pos386(X,Y) get_csv_bool((X),(Y),386) +#define get_csv_int_pos386(X,Y) get_csv_int((X),(Y),386) +#define get_csv_llong_pos386(X,Y) get_csv_llong((X),(Y),386) +#define get_csv_float_pos386(X,Y) get_csv_float((X),(Y),386) +#define get_csv_uint_pos387(X,Y) get_csv_uint((X),(Y),387) +#define get_csv_ullong_pos387(X,Y) get_csv_ullong((X),(Y),387) +#define get_csv_ip_pos387(X,Y) get_csv_ip((X),(Y),387) +#define get_csv_ipv6_pos387(X,Y) get_csv_ipv6((X),(Y),387) +#define get_csv_string_pos387(X,Y) get_csv_string((X),(Y),387) +#define get_csv_v_str_pos387(X,Y) get_csv_string((X),(Y),387) +#define get_csv_bool_pos387(X,Y) get_csv_bool((X),(Y),387) +#define get_csv_int_pos387(X,Y) get_csv_int((X),(Y),387) +#define get_csv_llong_pos387(X,Y) get_csv_llong((X),(Y),387) +#define get_csv_float_pos387(X,Y) get_csv_float((X),(Y),387) +#define get_csv_uint_pos388(X,Y) get_csv_uint((X),(Y),388) +#define get_csv_ullong_pos388(X,Y) get_csv_ullong((X),(Y),388) +#define get_csv_ip_pos388(X,Y) get_csv_ip((X),(Y),388) +#define get_csv_ipv6_pos388(X,Y) get_csv_ipv6((X),(Y),388) +#define get_csv_string_pos388(X,Y) get_csv_string((X),(Y),388) +#define get_csv_v_str_pos388(X,Y) get_csv_string((X),(Y),388) +#define get_csv_bool_pos388(X,Y) get_csv_bool((X),(Y),388) +#define get_csv_int_pos388(X,Y) get_csv_int((X),(Y),388) +#define get_csv_llong_pos388(X,Y) get_csv_llong((X),(Y),388) +#define get_csv_float_pos388(X,Y) get_csv_float((X),(Y),388) +#define get_csv_uint_pos389(X,Y) get_csv_uint((X),(Y),389) +#define get_csv_ullong_pos389(X,Y) get_csv_ullong((X),(Y),389) +#define get_csv_ip_pos389(X,Y) get_csv_ip((X),(Y),389) +#define get_csv_ipv6_pos389(X,Y) get_csv_ipv6((X),(Y),389) +#define get_csv_string_pos389(X,Y) get_csv_string((X),(Y),389) +#define get_csv_v_str_pos389(X,Y) get_csv_string((X),(Y),389) +#define get_csv_bool_pos389(X,Y) get_csv_bool((X),(Y),389) +#define get_csv_int_pos389(X,Y) get_csv_int((X),(Y),389) +#define get_csv_llong_pos389(X,Y) get_csv_llong((X),(Y),389) +#define get_csv_float_pos389(X,Y) get_csv_float((X),(Y),389) +#define get_csv_uint_pos390(X,Y) get_csv_uint((X),(Y),390) +#define get_csv_ullong_pos390(X,Y) get_csv_ullong((X),(Y),390) +#define get_csv_ip_pos390(X,Y) get_csv_ip((X),(Y),390) +#define get_csv_ipv6_pos390(X,Y) get_csv_ipv6((X),(Y),390) +#define get_csv_string_pos390(X,Y) get_csv_string((X),(Y),390) +#define get_csv_v_str_pos390(X,Y) get_csv_string((X),(Y),390) +#define get_csv_bool_pos390(X,Y) get_csv_bool((X),(Y),390) +#define get_csv_int_pos390(X,Y) get_csv_int((X),(Y),390) +#define get_csv_llong_pos390(X,Y) get_csv_llong((X),(Y),390) +#define get_csv_float_pos390(X,Y) get_csv_float((X),(Y),390) +#define get_csv_uint_pos391(X,Y) get_csv_uint((X),(Y),391) +#define get_csv_ullong_pos391(X,Y) get_csv_ullong((X),(Y),391) +#define get_csv_ip_pos391(X,Y) get_csv_ip((X),(Y),391) +#define get_csv_ipv6_pos391(X,Y) get_csv_ipv6((X),(Y),391) +#define get_csv_string_pos391(X,Y) get_csv_string((X),(Y),391) +#define get_csv_v_str_pos391(X,Y) get_csv_string((X),(Y),391) +#define get_csv_bool_pos391(X,Y) get_csv_bool((X),(Y),391) +#define get_csv_int_pos391(X,Y) get_csv_int((X),(Y),391) +#define get_csv_llong_pos391(X,Y) get_csv_llong((X),(Y),391) +#define get_csv_float_pos391(X,Y) get_csv_float((X),(Y),391) +#define get_csv_uint_pos392(X,Y) get_csv_uint((X),(Y),392) +#define get_csv_ullong_pos392(X,Y) get_csv_ullong((X),(Y),392) +#define get_csv_ip_pos392(X,Y) get_csv_ip((X),(Y),392) +#define get_csv_ipv6_pos392(X,Y) get_csv_ipv6((X),(Y),392) +#define get_csv_string_pos392(X,Y) get_csv_string((X),(Y),392) +#define get_csv_v_str_pos392(X,Y) get_csv_string((X),(Y),392) +#define get_csv_bool_pos392(X,Y) get_csv_bool((X),(Y),392) +#define get_csv_int_pos392(X,Y) get_csv_int((X),(Y),392) +#define get_csv_llong_pos392(X,Y) get_csv_llong((X),(Y),392) +#define get_csv_float_pos392(X,Y) get_csv_float((X),(Y),392) +#define get_csv_uint_pos393(X,Y) get_csv_uint((X),(Y),393) +#define get_csv_ullong_pos393(X,Y) get_csv_ullong((X),(Y),393) +#define get_csv_ip_pos393(X,Y) get_csv_ip((X),(Y),393) +#define get_csv_ipv6_pos393(X,Y) get_csv_ipv6((X),(Y),393) +#define get_csv_string_pos393(X,Y) get_csv_string((X),(Y),393) +#define get_csv_v_str_pos393(X,Y) get_csv_string((X),(Y),393) +#define get_csv_bool_pos393(X,Y) get_csv_bool((X),(Y),393) +#define get_csv_int_pos393(X,Y) get_csv_int((X),(Y),393) +#define get_csv_llong_pos393(X,Y) get_csv_llong((X),(Y),393) +#define get_csv_float_pos393(X,Y) get_csv_float((X),(Y),393) +#define get_csv_uint_pos394(X,Y) get_csv_uint((X),(Y),394) +#define get_csv_ullong_pos394(X,Y) get_csv_ullong((X),(Y),394) +#define get_csv_ip_pos394(X,Y) get_csv_ip((X),(Y),394) +#define get_csv_ipv6_pos394(X,Y) get_csv_ipv6((X),(Y),394) +#define get_csv_string_pos394(X,Y) get_csv_string((X),(Y),394) +#define get_csv_v_str_pos394(X,Y) get_csv_string((X),(Y),394) +#define get_csv_bool_pos394(X,Y) get_csv_bool((X),(Y),394) +#define get_csv_int_pos394(X,Y) get_csv_int((X),(Y),394) +#define get_csv_llong_pos394(X,Y) get_csv_llong((X),(Y),394) +#define get_csv_float_pos394(X,Y) get_csv_float((X),(Y),394) +#define get_csv_uint_pos395(X,Y) get_csv_uint((X),(Y),395) +#define get_csv_ullong_pos395(X,Y) get_csv_ullong((X),(Y),395) +#define get_csv_ip_pos395(X,Y) get_csv_ip((X),(Y),395) +#define get_csv_ipv6_pos395(X,Y) get_csv_ipv6((X),(Y),395) +#define get_csv_string_pos395(X,Y) get_csv_string((X),(Y),395) +#define get_csv_v_str_pos395(X,Y) get_csv_string((X),(Y),395) +#define get_csv_bool_pos395(X,Y) get_csv_bool((X),(Y),395) +#define get_csv_int_pos395(X,Y) get_csv_int((X),(Y),395) +#define get_csv_llong_pos395(X,Y) get_csv_llong((X),(Y),395) +#define get_csv_float_pos395(X,Y) get_csv_float((X),(Y),395) +#define get_csv_uint_pos396(X,Y) get_csv_uint((X),(Y),396) +#define get_csv_ullong_pos396(X,Y) get_csv_ullong((X),(Y),396) +#define get_csv_ip_pos396(X,Y) get_csv_ip((X),(Y),396) +#define get_csv_ipv6_pos396(X,Y) get_csv_ipv6((X),(Y),396) +#define get_csv_string_pos396(X,Y) get_csv_string((X),(Y),396) +#define get_csv_v_str_pos396(X,Y) get_csv_string((X),(Y),396) +#define get_csv_bool_pos396(X,Y) get_csv_bool((X),(Y),396) +#define get_csv_int_pos396(X,Y) get_csv_int((X),(Y),396) +#define get_csv_llong_pos396(X,Y) get_csv_llong((X),(Y),396) +#define get_csv_float_pos396(X,Y) get_csv_float((X),(Y),396) +#define get_csv_uint_pos397(X,Y) get_csv_uint((X),(Y),397) +#define get_csv_ullong_pos397(X,Y) get_csv_ullong((X),(Y),397) +#define get_csv_ip_pos397(X,Y) get_csv_ip((X),(Y),397) +#define get_csv_ipv6_pos397(X,Y) get_csv_ipv6((X),(Y),397) +#define get_csv_string_pos397(X,Y) get_csv_string((X),(Y),397) +#define get_csv_v_str_pos397(X,Y) get_csv_string((X),(Y),397) +#define get_csv_bool_pos397(X,Y) get_csv_bool((X),(Y),397) +#define get_csv_int_pos397(X,Y) get_csv_int((X),(Y),397) +#define get_csv_llong_pos397(X,Y) get_csv_llong((X),(Y),397) +#define get_csv_float_pos397(X,Y) get_csv_float((X),(Y),397) +#define get_csv_uint_pos398(X,Y) get_csv_uint((X),(Y),398) +#define get_csv_ullong_pos398(X,Y) get_csv_ullong((X),(Y),398) +#define get_csv_ip_pos398(X,Y) get_csv_ip((X),(Y),398) +#define get_csv_ipv6_pos398(X,Y) get_csv_ipv6((X),(Y),398) +#define get_csv_string_pos398(X,Y) get_csv_string((X),(Y),398) +#define get_csv_v_str_pos398(X,Y) get_csv_string((X),(Y),398) +#define get_csv_bool_pos398(X,Y) get_csv_bool((X),(Y),398) +#define get_csv_int_pos398(X,Y) get_csv_int((X),(Y),398) +#define get_csv_llong_pos398(X,Y) get_csv_llong((X),(Y),398) +#define get_csv_float_pos398(X,Y) get_csv_float((X),(Y),398) +#define get_csv_uint_pos399(X,Y) get_csv_uint((X),(Y),399) +#define get_csv_ullong_pos399(X,Y) get_csv_ullong((X),(Y),399) +#define get_csv_ip_pos399(X,Y) get_csv_ip((X),(Y),399) +#define get_csv_ipv6_pos399(X,Y) get_csv_ipv6((X),(Y),399) +#define get_csv_string_pos399(X,Y) get_csv_string((X),(Y),399) +#define get_csv_v_str_pos399(X,Y) get_csv_string((X),(Y),399) +#define get_csv_bool_pos399(X,Y) get_csv_bool((X),(Y),399) +#define get_csv_int_pos399(X,Y) get_csv_int((X),(Y),399) +#define get_csv_llong_pos399(X,Y) get_csv_llong((X),(Y),399) +#define get_csv_float_pos399(X,Y) get_csv_float((X),(Y),399) +#define get_csv_uint_pos400(X,Y) get_csv_uint((X),(Y),400) +#define get_csv_ullong_pos400(X,Y) get_csv_ullong((X),(Y),400) +#define get_csv_ip_pos400(X,Y) get_csv_ip((X),(Y),400) +#define get_csv_ipv6_pos400(X,Y) get_csv_ipv6((X),(Y),400) +#define get_csv_string_pos400(X,Y) get_csv_string((X),(Y),400) +#define get_csv_v_str_pos400(X,Y) get_csv_string((X),(Y),400) +#define get_csv_bool_pos400(X,Y) get_csv_bool((X),(Y),400) +#define get_csv_int_pos400(X,Y) get_csv_int((X),(Y),400) +#define get_csv_llong_pos400(X,Y) get_csv_llong((X),(Y),400) +#define get_csv_float_pos400(X,Y) get_csv_float((X),(Y),400) +#define get_csv_uint_pos401(X,Y) get_csv_uint((X),(Y),401) +#define get_csv_ullong_pos401(X,Y) get_csv_ullong((X),(Y),401) +#define get_csv_ip_pos401(X,Y) get_csv_ip((X),(Y),401) +#define get_csv_ipv6_pos401(X,Y) get_csv_ipv6((X),(Y),401) +#define get_csv_string_pos401(X,Y) get_csv_string((X),(Y),401) +#define get_csv_v_str_pos401(X,Y) get_csv_string((X),(Y),401) +#define get_csv_bool_pos401(X,Y) get_csv_bool((X),(Y),401) +#define get_csv_int_pos401(X,Y) get_csv_int((X),(Y),401) +#define get_csv_llong_pos401(X,Y) get_csv_llong((X),(Y),401) +#define get_csv_float_pos401(X,Y) get_csv_float((X),(Y),401) +#define get_csv_uint_pos402(X,Y) get_csv_uint((X),(Y),402) +#define get_csv_ullong_pos402(X,Y) get_csv_ullong((X),(Y),402) +#define get_csv_ip_pos402(X,Y) get_csv_ip((X),(Y),402) +#define get_csv_ipv6_pos402(X,Y) get_csv_ipv6((X),(Y),402) +#define get_csv_string_pos402(X,Y) get_csv_string((X),(Y),402) +#define get_csv_v_str_pos402(X,Y) get_csv_string((X),(Y),402) +#define get_csv_bool_pos402(X,Y) get_csv_bool((X),(Y),402) +#define get_csv_int_pos402(X,Y) get_csv_int((X),(Y),402) +#define get_csv_llong_pos402(X,Y) get_csv_llong((X),(Y),402) +#define get_csv_float_pos402(X,Y) get_csv_float((X),(Y),402) +#define get_csv_uint_pos403(X,Y) get_csv_uint((X),(Y),403) +#define get_csv_ullong_pos403(X,Y) get_csv_ullong((X),(Y),403) +#define get_csv_ip_pos403(X,Y) get_csv_ip((X),(Y),403) +#define get_csv_ipv6_pos403(X,Y) get_csv_ipv6((X),(Y),403) +#define get_csv_string_pos403(X,Y) get_csv_string((X),(Y),403) +#define get_csv_v_str_pos403(X,Y) get_csv_string((X),(Y),403) +#define get_csv_bool_pos403(X,Y) get_csv_bool((X),(Y),403) +#define get_csv_int_pos403(X,Y) get_csv_int((X),(Y),403) +#define get_csv_llong_pos403(X,Y) get_csv_llong((X),(Y),403) +#define get_csv_float_pos403(X,Y) get_csv_float((X),(Y),403) +#define get_csv_uint_pos404(X,Y) get_csv_uint((X),(Y),404) +#define get_csv_ullong_pos404(X,Y) get_csv_ullong((X),(Y),404) +#define get_csv_ip_pos404(X,Y) get_csv_ip((X),(Y),404) +#define get_csv_ipv6_pos404(X,Y) get_csv_ipv6((X),(Y),404) +#define get_csv_string_pos404(X,Y) get_csv_string((X),(Y),404) +#define get_csv_v_str_pos404(X,Y) get_csv_string((X),(Y),404) +#define get_csv_bool_pos404(X,Y) get_csv_bool((X),(Y),404) +#define get_csv_int_pos404(X,Y) get_csv_int((X),(Y),404) +#define get_csv_llong_pos404(X,Y) get_csv_llong((X),(Y),404) +#define get_csv_float_pos404(X,Y) get_csv_float((X),(Y),404) +#define get_csv_uint_pos405(X,Y) get_csv_uint((X),(Y),405) +#define get_csv_ullong_pos405(X,Y) get_csv_ullong((X),(Y),405) +#define get_csv_ip_pos405(X,Y) get_csv_ip((X),(Y),405) +#define get_csv_ipv6_pos405(X,Y) get_csv_ipv6((X),(Y),405) +#define get_csv_string_pos405(X,Y) get_csv_string((X),(Y),405) +#define get_csv_v_str_pos405(X,Y) get_csv_string((X),(Y),405) +#define get_csv_bool_pos405(X,Y) get_csv_bool((X),(Y),405) +#define get_csv_int_pos405(X,Y) get_csv_int((X),(Y),405) +#define get_csv_llong_pos405(X,Y) get_csv_llong((X),(Y),405) +#define get_csv_float_pos405(X,Y) get_csv_float((X),(Y),405) +#define get_csv_uint_pos406(X,Y) get_csv_uint((X),(Y),406) +#define get_csv_ullong_pos406(X,Y) get_csv_ullong((X),(Y),406) +#define get_csv_ip_pos406(X,Y) get_csv_ip((X),(Y),406) +#define get_csv_ipv6_pos406(X,Y) get_csv_ipv6((X),(Y),406) +#define get_csv_string_pos406(X,Y) get_csv_string((X),(Y),406) +#define get_csv_v_str_pos406(X,Y) get_csv_string((X),(Y),406) +#define get_csv_bool_pos406(X,Y) get_csv_bool((X),(Y),406) +#define get_csv_int_pos406(X,Y) get_csv_int((X),(Y),406) +#define get_csv_llong_pos406(X,Y) get_csv_llong((X),(Y),406) +#define get_csv_float_pos406(X,Y) get_csv_float((X),(Y),406) +#define get_csv_uint_pos407(X,Y) get_csv_uint((X),(Y),407) +#define get_csv_ullong_pos407(X,Y) get_csv_ullong((X),(Y),407) +#define get_csv_ip_pos407(X,Y) get_csv_ip((X),(Y),407) +#define get_csv_ipv6_pos407(X,Y) get_csv_ipv6((X),(Y),407) +#define get_csv_string_pos407(X,Y) get_csv_string((X),(Y),407) +#define get_csv_v_str_pos407(X,Y) get_csv_string((X),(Y),407) +#define get_csv_bool_pos407(X,Y) get_csv_bool((X),(Y),407) +#define get_csv_int_pos407(X,Y) get_csv_int((X),(Y),407) +#define get_csv_llong_pos407(X,Y) get_csv_llong((X),(Y),407) +#define get_csv_float_pos407(X,Y) get_csv_float((X),(Y),407) +#define get_csv_uint_pos408(X,Y) get_csv_uint((X),(Y),408) +#define get_csv_ullong_pos408(X,Y) get_csv_ullong((X),(Y),408) +#define get_csv_ip_pos408(X,Y) get_csv_ip((X),(Y),408) +#define get_csv_ipv6_pos408(X,Y) get_csv_ipv6((X),(Y),408) +#define get_csv_string_pos408(X,Y) get_csv_string((X),(Y),408) +#define get_csv_v_str_pos408(X,Y) get_csv_string((X),(Y),408) +#define get_csv_bool_pos408(X,Y) get_csv_bool((X),(Y),408) +#define get_csv_int_pos408(X,Y) get_csv_int((X),(Y),408) +#define get_csv_llong_pos408(X,Y) get_csv_llong((X),(Y),408) +#define get_csv_float_pos408(X,Y) get_csv_float((X),(Y),408) +#define get_csv_uint_pos409(X,Y) get_csv_uint((X),(Y),409) +#define get_csv_ullong_pos409(X,Y) get_csv_ullong((X),(Y),409) +#define get_csv_ip_pos409(X,Y) get_csv_ip((X),(Y),409) +#define get_csv_ipv6_pos409(X,Y) get_csv_ipv6((X),(Y),409) +#define get_csv_string_pos409(X,Y) get_csv_string((X),(Y),409) +#define get_csv_v_str_pos409(X,Y) get_csv_string((X),(Y),409) +#define get_csv_bool_pos409(X,Y) get_csv_bool((X),(Y),409) +#define get_csv_int_pos409(X,Y) get_csv_int((X),(Y),409) +#define get_csv_llong_pos409(X,Y) get_csv_llong((X),(Y),409) +#define get_csv_float_pos409(X,Y) get_csv_float((X),(Y),409) +#define get_csv_uint_pos410(X,Y) get_csv_uint((X),(Y),410) +#define get_csv_ullong_pos410(X,Y) get_csv_ullong((X),(Y),410) +#define get_csv_ip_pos410(X,Y) get_csv_ip((X),(Y),410) +#define get_csv_ipv6_pos410(X,Y) get_csv_ipv6((X),(Y),410) +#define get_csv_string_pos410(X,Y) get_csv_string((X),(Y),410) +#define get_csv_v_str_pos410(X,Y) get_csv_string((X),(Y),410) +#define get_csv_bool_pos410(X,Y) get_csv_bool((X),(Y),410) +#define get_csv_int_pos410(X,Y) get_csv_int((X),(Y),410) +#define get_csv_llong_pos410(X,Y) get_csv_llong((X),(Y),410) +#define get_csv_float_pos410(X,Y) get_csv_float((X),(Y),410) +#define get_csv_uint_pos411(X,Y) get_csv_uint((X),(Y),411) +#define get_csv_ullong_pos411(X,Y) get_csv_ullong((X),(Y),411) +#define get_csv_ip_pos411(X,Y) get_csv_ip((X),(Y),411) +#define get_csv_ipv6_pos411(X,Y) get_csv_ipv6((X),(Y),411) +#define get_csv_string_pos411(X,Y) get_csv_string((X),(Y),411) +#define get_csv_v_str_pos411(X,Y) get_csv_string((X),(Y),411) +#define get_csv_bool_pos411(X,Y) get_csv_bool((X),(Y),411) +#define get_csv_int_pos411(X,Y) get_csv_int((X),(Y),411) +#define get_csv_llong_pos411(X,Y) get_csv_llong((X),(Y),411) +#define get_csv_float_pos411(X,Y) get_csv_float((X),(Y),411) +#define get_csv_uint_pos412(X,Y) get_csv_uint((X),(Y),412) +#define get_csv_ullong_pos412(X,Y) get_csv_ullong((X),(Y),412) +#define get_csv_ip_pos412(X,Y) get_csv_ip((X),(Y),412) +#define get_csv_ipv6_pos412(X,Y) get_csv_ipv6((X),(Y),412) +#define get_csv_string_pos412(X,Y) get_csv_string((X),(Y),412) +#define get_csv_v_str_pos412(X,Y) get_csv_string((X),(Y),412) +#define get_csv_bool_pos412(X,Y) get_csv_bool((X),(Y),412) +#define get_csv_int_pos412(X,Y) get_csv_int((X),(Y),412) +#define get_csv_llong_pos412(X,Y) get_csv_llong((X),(Y),412) +#define get_csv_float_pos412(X,Y) get_csv_float((X),(Y),412) +#define get_csv_uint_pos413(X,Y) get_csv_uint((X),(Y),413) +#define get_csv_ullong_pos413(X,Y) get_csv_ullong((X),(Y),413) +#define get_csv_ip_pos413(X,Y) get_csv_ip((X),(Y),413) +#define get_csv_ipv6_pos413(X,Y) get_csv_ipv6((X),(Y),413) +#define get_csv_string_pos413(X,Y) get_csv_string((X),(Y),413) +#define get_csv_v_str_pos413(X,Y) get_csv_string((X),(Y),413) +#define get_csv_bool_pos413(X,Y) get_csv_bool((X),(Y),413) +#define get_csv_int_pos413(X,Y) get_csv_int((X),(Y),413) +#define get_csv_llong_pos413(X,Y) get_csv_llong((X),(Y),413) +#define get_csv_float_pos413(X,Y) get_csv_float((X),(Y),413) +#define get_csv_uint_pos414(X,Y) get_csv_uint((X),(Y),414) +#define get_csv_ullong_pos414(X,Y) get_csv_ullong((X),(Y),414) +#define get_csv_ip_pos414(X,Y) get_csv_ip((X),(Y),414) +#define get_csv_ipv6_pos414(X,Y) get_csv_ipv6((X),(Y),414) +#define get_csv_string_pos414(X,Y) get_csv_string((X),(Y),414) +#define get_csv_v_str_pos414(X,Y) get_csv_string((X),(Y),414) +#define get_csv_bool_pos414(X,Y) get_csv_bool((X),(Y),414) +#define get_csv_int_pos414(X,Y) get_csv_int((X),(Y),414) +#define get_csv_llong_pos414(X,Y) get_csv_llong((X),(Y),414) +#define get_csv_float_pos414(X,Y) get_csv_float((X),(Y),414) +#define get_csv_uint_pos415(X,Y) get_csv_uint((X),(Y),415) +#define get_csv_ullong_pos415(X,Y) get_csv_ullong((X),(Y),415) +#define get_csv_ip_pos415(X,Y) get_csv_ip((X),(Y),415) +#define get_csv_ipv6_pos415(X,Y) get_csv_ipv6((X),(Y),415) +#define get_csv_string_pos415(X,Y) get_csv_string((X),(Y),415) +#define get_csv_v_str_pos415(X,Y) get_csv_string((X),(Y),415) +#define get_csv_bool_pos415(X,Y) get_csv_bool((X),(Y),415) +#define get_csv_int_pos415(X,Y) get_csv_int((X),(Y),415) +#define get_csv_llong_pos415(X,Y) get_csv_llong((X),(Y),415) +#define get_csv_float_pos415(X,Y) get_csv_float((X),(Y),415) +#define get_csv_uint_pos416(X,Y) get_csv_uint((X),(Y),416) +#define get_csv_ullong_pos416(X,Y) get_csv_ullong((X),(Y),416) +#define get_csv_ip_pos416(X,Y) get_csv_ip((X),(Y),416) +#define get_csv_ipv6_pos416(X,Y) get_csv_ipv6((X),(Y),416) +#define get_csv_string_pos416(X,Y) get_csv_string((X),(Y),416) +#define get_csv_v_str_pos416(X,Y) get_csv_string((X),(Y),416) +#define get_csv_bool_pos416(X,Y) get_csv_bool((X),(Y),416) +#define get_csv_int_pos416(X,Y) get_csv_int((X),(Y),416) +#define get_csv_llong_pos416(X,Y) get_csv_llong((X),(Y),416) +#define get_csv_float_pos416(X,Y) get_csv_float((X),(Y),416) +#define get_csv_uint_pos417(X,Y) get_csv_uint((X),(Y),417) +#define get_csv_ullong_pos417(X,Y) get_csv_ullong((X),(Y),417) +#define get_csv_ip_pos417(X,Y) get_csv_ip((X),(Y),417) +#define get_csv_ipv6_pos417(X,Y) get_csv_ipv6((X),(Y),417) +#define get_csv_string_pos417(X,Y) get_csv_string((X),(Y),417) +#define get_csv_v_str_pos417(X,Y) get_csv_string((X),(Y),417) +#define get_csv_bool_pos417(X,Y) get_csv_bool((X),(Y),417) +#define get_csv_int_pos417(X,Y) get_csv_int((X),(Y),417) +#define get_csv_llong_pos417(X,Y) get_csv_llong((X),(Y),417) +#define get_csv_float_pos417(X,Y) get_csv_float((X),(Y),417) +#define get_csv_uint_pos418(X,Y) get_csv_uint((X),(Y),418) +#define get_csv_ullong_pos418(X,Y) get_csv_ullong((X),(Y),418) +#define get_csv_ip_pos418(X,Y) get_csv_ip((X),(Y),418) +#define get_csv_ipv6_pos418(X,Y) get_csv_ipv6((X),(Y),418) +#define get_csv_string_pos418(X,Y) get_csv_string((X),(Y),418) +#define get_csv_v_str_pos418(X,Y) get_csv_string((X),(Y),418) +#define get_csv_bool_pos418(X,Y) get_csv_bool((X),(Y),418) +#define get_csv_int_pos418(X,Y) get_csv_int((X),(Y),418) +#define get_csv_llong_pos418(X,Y) get_csv_llong((X),(Y),418) +#define get_csv_float_pos418(X,Y) get_csv_float((X),(Y),418) +#define get_csv_uint_pos419(X,Y) get_csv_uint((X),(Y),419) +#define get_csv_ullong_pos419(X,Y) get_csv_ullong((X),(Y),419) +#define get_csv_ip_pos419(X,Y) get_csv_ip((X),(Y),419) +#define get_csv_ipv6_pos419(X,Y) get_csv_ipv6((X),(Y),419) +#define get_csv_string_pos419(X,Y) get_csv_string((X),(Y),419) +#define get_csv_v_str_pos419(X,Y) get_csv_string((X),(Y),419) +#define get_csv_bool_pos419(X,Y) get_csv_bool((X),(Y),419) +#define get_csv_int_pos419(X,Y) get_csv_int((X),(Y),419) +#define get_csv_llong_pos419(X,Y) get_csv_llong((X),(Y),419) +#define get_csv_float_pos419(X,Y) get_csv_float((X),(Y),419) +#define get_csv_uint_pos420(X,Y) get_csv_uint((X),(Y),420) +#define get_csv_ullong_pos420(X,Y) get_csv_ullong((X),(Y),420) +#define get_csv_ip_pos420(X,Y) get_csv_ip((X),(Y),420) +#define get_csv_ipv6_pos420(X,Y) get_csv_ipv6((X),(Y),420) +#define get_csv_string_pos420(X,Y) get_csv_string((X),(Y),420) +#define get_csv_v_str_pos420(X,Y) get_csv_string((X),(Y),420) +#define get_csv_bool_pos420(X,Y) get_csv_bool((X),(Y),420) +#define get_csv_int_pos420(X,Y) get_csv_int((X),(Y),420) +#define get_csv_llong_pos420(X,Y) get_csv_llong((X),(Y),420) +#define get_csv_float_pos420(X,Y) get_csv_float((X),(Y),420) +#define get_csv_uint_pos421(X,Y) get_csv_uint((X),(Y),421) +#define get_csv_ullong_pos421(X,Y) get_csv_ullong((X),(Y),421) +#define get_csv_ip_pos421(X,Y) get_csv_ip((X),(Y),421) +#define get_csv_ipv6_pos421(X,Y) get_csv_ipv6((X),(Y),421) +#define get_csv_string_pos421(X,Y) get_csv_string((X),(Y),421) +#define get_csv_v_str_pos421(X,Y) get_csv_string((X),(Y),421) +#define get_csv_bool_pos421(X,Y) get_csv_bool((X),(Y),421) +#define get_csv_int_pos421(X,Y) get_csv_int((X),(Y),421) +#define get_csv_llong_pos421(X,Y) get_csv_llong((X),(Y),421) +#define get_csv_float_pos421(X,Y) get_csv_float((X),(Y),421) +#define get_csv_uint_pos422(X,Y) get_csv_uint((X),(Y),422) +#define get_csv_ullong_pos422(X,Y) get_csv_ullong((X),(Y),422) +#define get_csv_ip_pos422(X,Y) get_csv_ip((X),(Y),422) +#define get_csv_ipv6_pos422(X,Y) get_csv_ipv6((X),(Y),422) +#define get_csv_string_pos422(X,Y) get_csv_string((X),(Y),422) +#define get_csv_v_str_pos422(X,Y) get_csv_string((X),(Y),422) +#define get_csv_bool_pos422(X,Y) get_csv_bool((X),(Y),422) +#define get_csv_int_pos422(X,Y) get_csv_int((X),(Y),422) +#define get_csv_llong_pos422(X,Y) get_csv_llong((X),(Y),422) +#define get_csv_float_pos422(X,Y) get_csv_float((X),(Y),422) +#define get_csv_uint_pos423(X,Y) get_csv_uint((X),(Y),423) +#define get_csv_ullong_pos423(X,Y) get_csv_ullong((X),(Y),423) +#define get_csv_ip_pos423(X,Y) get_csv_ip((X),(Y),423) +#define get_csv_ipv6_pos423(X,Y) get_csv_ipv6((X),(Y),423) +#define get_csv_string_pos423(X,Y) get_csv_string((X),(Y),423) +#define get_csv_v_str_pos423(X,Y) get_csv_string((X),(Y),423) +#define get_csv_bool_pos423(X,Y) get_csv_bool((X),(Y),423) +#define get_csv_int_pos423(X,Y) get_csv_int((X),(Y),423) +#define get_csv_llong_pos423(X,Y) get_csv_llong((X),(Y),423) +#define get_csv_float_pos423(X,Y) get_csv_float((X),(Y),423) +#define get_csv_uint_pos424(X,Y) get_csv_uint((X),(Y),424) +#define get_csv_ullong_pos424(X,Y) get_csv_ullong((X),(Y),424) +#define get_csv_ip_pos424(X,Y) get_csv_ip((X),(Y),424) +#define get_csv_ipv6_pos424(X,Y) get_csv_ipv6((X),(Y),424) +#define get_csv_string_pos424(X,Y) get_csv_string((X),(Y),424) +#define get_csv_v_str_pos424(X,Y) get_csv_string((X),(Y),424) +#define get_csv_bool_pos424(X,Y) get_csv_bool((X),(Y),424) +#define get_csv_int_pos424(X,Y) get_csv_int((X),(Y),424) +#define get_csv_llong_pos424(X,Y) get_csv_llong((X),(Y),424) +#define get_csv_float_pos424(X,Y) get_csv_float((X),(Y),424) +#define get_csv_uint_pos425(X,Y) get_csv_uint((X),(Y),425) +#define get_csv_ullong_pos425(X,Y) get_csv_ullong((X),(Y),425) +#define get_csv_ip_pos425(X,Y) get_csv_ip((X),(Y),425) +#define get_csv_ipv6_pos425(X,Y) get_csv_ipv6((X),(Y),425) +#define get_csv_string_pos425(X,Y) get_csv_string((X),(Y),425) +#define get_csv_v_str_pos425(X,Y) get_csv_string((X),(Y),425) +#define get_csv_bool_pos425(X,Y) get_csv_bool((X),(Y),425) +#define get_csv_int_pos425(X,Y) get_csv_int((X),(Y),425) +#define get_csv_llong_pos425(X,Y) get_csv_llong((X),(Y),425) +#define get_csv_float_pos425(X,Y) get_csv_float((X),(Y),425) +#define get_csv_uint_pos426(X,Y) get_csv_uint((X),(Y),426) +#define get_csv_ullong_pos426(X,Y) get_csv_ullong((X),(Y),426) +#define get_csv_ip_pos426(X,Y) get_csv_ip((X),(Y),426) +#define get_csv_ipv6_pos426(X,Y) get_csv_ipv6((X),(Y),426) +#define get_csv_string_pos426(X,Y) get_csv_string((X),(Y),426) +#define get_csv_v_str_pos426(X,Y) get_csv_string((X),(Y),426) +#define get_csv_bool_pos426(X,Y) get_csv_bool((X),(Y),426) +#define get_csv_int_pos426(X,Y) get_csv_int((X),(Y),426) +#define get_csv_llong_pos426(X,Y) get_csv_llong((X),(Y),426) +#define get_csv_float_pos426(X,Y) get_csv_float((X),(Y),426) +#define get_csv_uint_pos427(X,Y) get_csv_uint((X),(Y),427) +#define get_csv_ullong_pos427(X,Y) get_csv_ullong((X),(Y),427) +#define get_csv_ip_pos427(X,Y) get_csv_ip((X),(Y),427) +#define get_csv_ipv6_pos427(X,Y) get_csv_ipv6((X),(Y),427) +#define get_csv_string_pos427(X,Y) get_csv_string((X),(Y),427) +#define get_csv_v_str_pos427(X,Y) get_csv_string((X),(Y),427) +#define get_csv_bool_pos427(X,Y) get_csv_bool((X),(Y),427) +#define get_csv_int_pos427(X,Y) get_csv_int((X),(Y),427) +#define get_csv_llong_pos427(X,Y) get_csv_llong((X),(Y),427) +#define get_csv_float_pos427(X,Y) get_csv_float((X),(Y),427) +#define get_csv_uint_pos428(X,Y) get_csv_uint((X),(Y),428) +#define get_csv_ullong_pos428(X,Y) get_csv_ullong((X),(Y),428) +#define get_csv_ip_pos428(X,Y) get_csv_ip((X),(Y),428) +#define get_csv_ipv6_pos428(X,Y) get_csv_ipv6((X),(Y),428) +#define get_csv_string_pos428(X,Y) get_csv_string((X),(Y),428) +#define get_csv_v_str_pos428(X,Y) get_csv_string((X),(Y),428) +#define get_csv_bool_pos428(X,Y) get_csv_bool((X),(Y),428) +#define get_csv_int_pos428(X,Y) get_csv_int((X),(Y),428) +#define get_csv_llong_pos428(X,Y) get_csv_llong((X),(Y),428) +#define get_csv_float_pos428(X,Y) get_csv_float((X),(Y),428) +#define get_csv_uint_pos429(X,Y) get_csv_uint((X),(Y),429) +#define get_csv_ullong_pos429(X,Y) get_csv_ullong((X),(Y),429) +#define get_csv_ip_pos429(X,Y) get_csv_ip((X),(Y),429) +#define get_csv_ipv6_pos429(X,Y) get_csv_ipv6((X),(Y),429) +#define get_csv_string_pos429(X,Y) get_csv_string((X),(Y),429) +#define get_csv_v_str_pos429(X,Y) get_csv_string((X),(Y),429) +#define get_csv_bool_pos429(X,Y) get_csv_bool((X),(Y),429) +#define get_csv_int_pos429(X,Y) get_csv_int((X),(Y),429) +#define get_csv_llong_pos429(X,Y) get_csv_llong((X),(Y),429) +#define get_csv_float_pos429(X,Y) get_csv_float((X),(Y),429) +#define get_csv_uint_pos430(X,Y) get_csv_uint((X),(Y),430) +#define get_csv_ullong_pos430(X,Y) get_csv_ullong((X),(Y),430) +#define get_csv_ip_pos430(X,Y) get_csv_ip((X),(Y),430) +#define get_csv_ipv6_pos430(X,Y) get_csv_ipv6((X),(Y),430) +#define get_csv_string_pos430(X,Y) get_csv_string((X),(Y),430) +#define get_csv_v_str_pos430(X,Y) get_csv_string((X),(Y),430) +#define get_csv_bool_pos430(X,Y) get_csv_bool((X),(Y),430) +#define get_csv_int_pos430(X,Y) get_csv_int((X),(Y),430) +#define get_csv_llong_pos430(X,Y) get_csv_llong((X),(Y),430) +#define get_csv_float_pos430(X,Y) get_csv_float((X),(Y),430) +#define get_csv_uint_pos431(X,Y) get_csv_uint((X),(Y),431) +#define get_csv_ullong_pos431(X,Y) get_csv_ullong((X),(Y),431) +#define get_csv_ip_pos431(X,Y) get_csv_ip((X),(Y),431) +#define get_csv_ipv6_pos431(X,Y) get_csv_ipv6((X),(Y),431) +#define get_csv_string_pos431(X,Y) get_csv_string((X),(Y),431) +#define get_csv_v_str_pos431(X,Y) get_csv_string((X),(Y),431) +#define get_csv_bool_pos431(X,Y) get_csv_bool((X),(Y),431) +#define get_csv_int_pos431(X,Y) get_csv_int((X),(Y),431) +#define get_csv_llong_pos431(X,Y) get_csv_llong((X),(Y),431) +#define get_csv_float_pos431(X,Y) get_csv_float((X),(Y),431) +#define get_csv_uint_pos432(X,Y) get_csv_uint((X),(Y),432) +#define get_csv_ullong_pos432(X,Y) get_csv_ullong((X),(Y),432) +#define get_csv_ip_pos432(X,Y) get_csv_ip((X),(Y),432) +#define get_csv_ipv6_pos432(X,Y) get_csv_ipv6((X),(Y),432) +#define get_csv_string_pos432(X,Y) get_csv_string((X),(Y),432) +#define get_csv_v_str_pos432(X,Y) get_csv_string((X),(Y),432) +#define get_csv_bool_pos432(X,Y) get_csv_bool((X),(Y),432) +#define get_csv_int_pos432(X,Y) get_csv_int((X),(Y),432) +#define get_csv_llong_pos432(X,Y) get_csv_llong((X),(Y),432) +#define get_csv_float_pos432(X,Y) get_csv_float((X),(Y),432) +#define get_csv_uint_pos433(X,Y) get_csv_uint((X),(Y),433) +#define get_csv_ullong_pos433(X,Y) get_csv_ullong((X),(Y),433) +#define get_csv_ip_pos433(X,Y) get_csv_ip((X),(Y),433) +#define get_csv_ipv6_pos433(X,Y) get_csv_ipv6((X),(Y),433) +#define get_csv_string_pos433(X,Y) get_csv_string((X),(Y),433) +#define get_csv_v_str_pos433(X,Y) get_csv_string((X),(Y),433) +#define get_csv_bool_pos433(X,Y) get_csv_bool((X),(Y),433) +#define get_csv_int_pos433(X,Y) get_csv_int((X),(Y),433) +#define get_csv_llong_pos433(X,Y) get_csv_llong((X),(Y),433) +#define get_csv_float_pos433(X,Y) get_csv_float((X),(Y),433) +#define get_csv_uint_pos434(X,Y) get_csv_uint((X),(Y),434) +#define get_csv_ullong_pos434(X,Y) get_csv_ullong((X),(Y),434) +#define get_csv_ip_pos434(X,Y) get_csv_ip((X),(Y),434) +#define get_csv_ipv6_pos434(X,Y) get_csv_ipv6((X),(Y),434) +#define get_csv_string_pos434(X,Y) get_csv_string((X),(Y),434) +#define get_csv_v_str_pos434(X,Y) get_csv_string((X),(Y),434) +#define get_csv_bool_pos434(X,Y) get_csv_bool((X),(Y),434) +#define get_csv_int_pos434(X,Y) get_csv_int((X),(Y),434) +#define get_csv_llong_pos434(X,Y) get_csv_llong((X),(Y),434) +#define get_csv_float_pos434(X,Y) get_csv_float((X),(Y),434) +#define get_csv_uint_pos435(X,Y) get_csv_uint((X),(Y),435) +#define get_csv_ullong_pos435(X,Y) get_csv_ullong((X),(Y),435) +#define get_csv_ip_pos435(X,Y) get_csv_ip((X),(Y),435) +#define get_csv_ipv6_pos435(X,Y) get_csv_ipv6((X),(Y),435) +#define get_csv_string_pos435(X,Y) get_csv_string((X),(Y),435) +#define get_csv_v_str_pos435(X,Y) get_csv_string((X),(Y),435) +#define get_csv_bool_pos435(X,Y) get_csv_bool((X),(Y),435) +#define get_csv_int_pos435(X,Y) get_csv_int((X),(Y),435) +#define get_csv_llong_pos435(X,Y) get_csv_llong((X),(Y),435) +#define get_csv_float_pos435(X,Y) get_csv_float((X),(Y),435) +#define get_csv_uint_pos436(X,Y) get_csv_uint((X),(Y),436) +#define get_csv_ullong_pos436(X,Y) get_csv_ullong((X),(Y),436) +#define get_csv_ip_pos436(X,Y) get_csv_ip((X),(Y),436) +#define get_csv_ipv6_pos436(X,Y) get_csv_ipv6((X),(Y),436) +#define get_csv_string_pos436(X,Y) get_csv_string((X),(Y),436) +#define get_csv_v_str_pos436(X,Y) get_csv_string((X),(Y),436) +#define get_csv_bool_pos436(X,Y) get_csv_bool((X),(Y),436) +#define get_csv_int_pos436(X,Y) get_csv_int((X),(Y),436) +#define get_csv_llong_pos436(X,Y) get_csv_llong((X),(Y),436) +#define get_csv_float_pos436(X,Y) get_csv_float((X),(Y),436) +#define get_csv_uint_pos437(X,Y) get_csv_uint((X),(Y),437) +#define get_csv_ullong_pos437(X,Y) get_csv_ullong((X),(Y),437) +#define get_csv_ip_pos437(X,Y) get_csv_ip((X),(Y),437) +#define get_csv_ipv6_pos437(X,Y) get_csv_ipv6((X),(Y),437) +#define get_csv_string_pos437(X,Y) get_csv_string((X),(Y),437) +#define get_csv_v_str_pos437(X,Y) get_csv_string((X),(Y),437) +#define get_csv_bool_pos437(X,Y) get_csv_bool((X),(Y),437) +#define get_csv_int_pos437(X,Y) get_csv_int((X),(Y),437) +#define get_csv_llong_pos437(X,Y) get_csv_llong((X),(Y),437) +#define get_csv_float_pos437(X,Y) get_csv_float((X),(Y),437) +#define get_csv_uint_pos438(X,Y) get_csv_uint((X),(Y),438) +#define get_csv_ullong_pos438(X,Y) get_csv_ullong((X),(Y),438) +#define get_csv_ip_pos438(X,Y) get_csv_ip((X),(Y),438) +#define get_csv_ipv6_pos438(X,Y) get_csv_ipv6((X),(Y),438) +#define get_csv_string_pos438(X,Y) get_csv_string((X),(Y),438) +#define get_csv_v_str_pos438(X,Y) get_csv_string((X),(Y),438) +#define get_csv_bool_pos438(X,Y) get_csv_bool((X),(Y),438) +#define get_csv_int_pos438(X,Y) get_csv_int((X),(Y),438) +#define get_csv_llong_pos438(X,Y) get_csv_llong((X),(Y),438) +#define get_csv_float_pos438(X,Y) get_csv_float((X),(Y),438) +#define get_csv_uint_pos439(X,Y) get_csv_uint((X),(Y),439) +#define get_csv_ullong_pos439(X,Y) get_csv_ullong((X),(Y),439) +#define get_csv_ip_pos439(X,Y) get_csv_ip((X),(Y),439) +#define get_csv_ipv6_pos439(X,Y) get_csv_ipv6((X),(Y),439) +#define get_csv_string_pos439(X,Y) get_csv_string((X),(Y),439) +#define get_csv_v_str_pos439(X,Y) get_csv_string((X),(Y),439) +#define get_csv_bool_pos439(X,Y) get_csv_bool((X),(Y),439) +#define get_csv_int_pos439(X,Y) get_csv_int((X),(Y),439) +#define get_csv_llong_pos439(X,Y) get_csv_llong((X),(Y),439) +#define get_csv_float_pos439(X,Y) get_csv_float((X),(Y),439) +#define get_csv_uint_pos440(X,Y) get_csv_uint((X),(Y),440) +#define get_csv_ullong_pos440(X,Y) get_csv_ullong((X),(Y),440) +#define get_csv_ip_pos440(X,Y) get_csv_ip((X),(Y),440) +#define get_csv_ipv6_pos440(X,Y) get_csv_ipv6((X),(Y),440) +#define get_csv_string_pos440(X,Y) get_csv_string((X),(Y),440) +#define get_csv_v_str_pos440(X,Y) get_csv_string((X),(Y),440) +#define get_csv_bool_pos440(X,Y) get_csv_bool((X),(Y),440) +#define get_csv_int_pos440(X,Y) get_csv_int((X),(Y),440) +#define get_csv_llong_pos440(X,Y) get_csv_llong((X),(Y),440) +#define get_csv_float_pos440(X,Y) get_csv_float((X),(Y),440) +#define get_csv_uint_pos441(X,Y) get_csv_uint((X),(Y),441) +#define get_csv_ullong_pos441(X,Y) get_csv_ullong((X),(Y),441) +#define get_csv_ip_pos441(X,Y) get_csv_ip((X),(Y),441) +#define get_csv_ipv6_pos441(X,Y) get_csv_ipv6((X),(Y),441) +#define get_csv_string_pos441(X,Y) get_csv_string((X),(Y),441) +#define get_csv_v_str_pos441(X,Y) get_csv_string((X),(Y),441) +#define get_csv_bool_pos441(X,Y) get_csv_bool((X),(Y),441) +#define get_csv_int_pos441(X,Y) get_csv_int((X),(Y),441) +#define get_csv_llong_pos441(X,Y) get_csv_llong((X),(Y),441) +#define get_csv_float_pos441(X,Y) get_csv_float((X),(Y),441) +#define get_csv_uint_pos442(X,Y) get_csv_uint((X),(Y),442) +#define get_csv_ullong_pos442(X,Y) get_csv_ullong((X),(Y),442) +#define get_csv_ip_pos442(X,Y) get_csv_ip((X),(Y),442) +#define get_csv_ipv6_pos442(X,Y) get_csv_ipv6((X),(Y),442) +#define get_csv_string_pos442(X,Y) get_csv_string((X),(Y),442) +#define get_csv_v_str_pos442(X,Y) get_csv_string((X),(Y),442) +#define get_csv_bool_pos442(X,Y) get_csv_bool((X),(Y),442) +#define get_csv_int_pos442(X,Y) get_csv_int((X),(Y),442) +#define get_csv_llong_pos442(X,Y) get_csv_llong((X),(Y),442) +#define get_csv_float_pos442(X,Y) get_csv_float((X),(Y),442) +#define get_csv_uint_pos443(X,Y) get_csv_uint((X),(Y),443) +#define get_csv_ullong_pos443(X,Y) get_csv_ullong((X),(Y),443) +#define get_csv_ip_pos443(X,Y) get_csv_ip((X),(Y),443) +#define get_csv_ipv6_pos443(X,Y) get_csv_ipv6((X),(Y),443) +#define get_csv_string_pos443(X,Y) get_csv_string((X),(Y),443) +#define get_csv_v_str_pos443(X,Y) get_csv_string((X),(Y),443) +#define get_csv_bool_pos443(X,Y) get_csv_bool((X),(Y),443) +#define get_csv_int_pos443(X,Y) get_csv_int((X),(Y),443) +#define get_csv_llong_pos443(X,Y) get_csv_llong((X),(Y),443) +#define get_csv_float_pos443(X,Y) get_csv_float((X),(Y),443) +#define get_csv_uint_pos444(X,Y) get_csv_uint((X),(Y),444) +#define get_csv_ullong_pos444(X,Y) get_csv_ullong((X),(Y),444) +#define get_csv_ip_pos444(X,Y) get_csv_ip((X),(Y),444) +#define get_csv_ipv6_pos444(X,Y) get_csv_ipv6((X),(Y),444) +#define get_csv_string_pos444(X,Y) get_csv_string((X),(Y),444) +#define get_csv_v_str_pos444(X,Y) get_csv_string((X),(Y),444) +#define get_csv_bool_pos444(X,Y) get_csv_bool((X),(Y),444) +#define get_csv_int_pos444(X,Y) get_csv_int((X),(Y),444) +#define get_csv_llong_pos444(X,Y) get_csv_llong((X),(Y),444) +#define get_csv_float_pos444(X,Y) get_csv_float((X),(Y),444) +#define get_csv_uint_pos445(X,Y) get_csv_uint((X),(Y),445) +#define get_csv_ullong_pos445(X,Y) get_csv_ullong((X),(Y),445) +#define get_csv_ip_pos445(X,Y) get_csv_ip((X),(Y),445) +#define get_csv_ipv6_pos445(X,Y) get_csv_ipv6((X),(Y),445) +#define get_csv_string_pos445(X,Y) get_csv_string((X),(Y),445) +#define get_csv_v_str_pos445(X,Y) get_csv_string((X),(Y),445) +#define get_csv_bool_pos445(X,Y) get_csv_bool((X),(Y),445) +#define get_csv_int_pos445(X,Y) get_csv_int((X),(Y),445) +#define get_csv_llong_pos445(X,Y) get_csv_llong((X),(Y),445) +#define get_csv_float_pos445(X,Y) get_csv_float((X),(Y),445) +#define get_csv_uint_pos446(X,Y) get_csv_uint((X),(Y),446) +#define get_csv_ullong_pos446(X,Y) get_csv_ullong((X),(Y),446) +#define get_csv_ip_pos446(X,Y) get_csv_ip((X),(Y),446) +#define get_csv_ipv6_pos446(X,Y) get_csv_ipv6((X),(Y),446) +#define get_csv_string_pos446(X,Y) get_csv_string((X),(Y),446) +#define get_csv_v_str_pos446(X,Y) get_csv_string((X),(Y),446) +#define get_csv_bool_pos446(X,Y) get_csv_bool((X),(Y),446) +#define get_csv_int_pos446(X,Y) get_csv_int((X),(Y),446) +#define get_csv_llong_pos446(X,Y) get_csv_llong((X),(Y),446) +#define get_csv_float_pos446(X,Y) get_csv_float((X),(Y),446) +#define get_csv_uint_pos447(X,Y) get_csv_uint((X),(Y),447) +#define get_csv_ullong_pos447(X,Y) get_csv_ullong((X),(Y),447) +#define get_csv_ip_pos447(X,Y) get_csv_ip((X),(Y),447) +#define get_csv_ipv6_pos447(X,Y) get_csv_ipv6((X),(Y),447) +#define get_csv_string_pos447(X,Y) get_csv_string((X),(Y),447) +#define get_csv_v_str_pos447(X,Y) get_csv_string((X),(Y),447) +#define get_csv_bool_pos447(X,Y) get_csv_bool((X),(Y),447) +#define get_csv_int_pos447(X,Y) get_csv_int((X),(Y),447) +#define get_csv_llong_pos447(X,Y) get_csv_llong((X),(Y),447) +#define get_csv_float_pos447(X,Y) get_csv_float((X),(Y),447) +#define get_csv_uint_pos448(X,Y) get_csv_uint((X),(Y),448) +#define get_csv_ullong_pos448(X,Y) get_csv_ullong((X),(Y),448) +#define get_csv_ip_pos448(X,Y) get_csv_ip((X),(Y),448) +#define get_csv_ipv6_pos448(X,Y) get_csv_ipv6((X),(Y),448) +#define get_csv_string_pos448(X,Y) get_csv_string((X),(Y),448) +#define get_csv_v_str_pos448(X,Y) get_csv_string((X),(Y),448) +#define get_csv_bool_pos448(X,Y) get_csv_bool((X),(Y),448) +#define get_csv_int_pos448(X,Y) get_csv_int((X),(Y),448) +#define get_csv_llong_pos448(X,Y) get_csv_llong((X),(Y),448) +#define get_csv_float_pos448(X,Y) get_csv_float((X),(Y),448) +#define get_csv_uint_pos449(X,Y) get_csv_uint((X),(Y),449) +#define get_csv_ullong_pos449(X,Y) get_csv_ullong((X),(Y),449) +#define get_csv_ip_pos449(X,Y) get_csv_ip((X),(Y),449) +#define get_csv_ipv6_pos449(X,Y) get_csv_ipv6((X),(Y),449) +#define get_csv_string_pos449(X,Y) get_csv_string((X),(Y),449) +#define get_csv_v_str_pos449(X,Y) get_csv_string((X),(Y),449) +#define get_csv_bool_pos449(X,Y) get_csv_bool((X),(Y),449) +#define get_csv_int_pos449(X,Y) get_csv_int((X),(Y),449) +#define get_csv_llong_pos449(X,Y) get_csv_llong((X),(Y),449) +#define get_csv_float_pos449(X,Y) get_csv_float((X),(Y),449) +#define get_csv_uint_pos450(X,Y) get_csv_uint((X),(Y),450) +#define get_csv_ullong_pos450(X,Y) get_csv_ullong((X),(Y),450) +#define get_csv_ip_pos450(X,Y) get_csv_ip((X),(Y),450) +#define get_csv_ipv6_pos450(X,Y) get_csv_ipv6((X),(Y),450) +#define get_csv_string_pos450(X,Y) get_csv_string((X),(Y),450) +#define get_csv_v_str_pos450(X,Y) get_csv_string((X),(Y),450) +#define get_csv_bool_pos450(X,Y) get_csv_bool((X),(Y),450) +#define get_csv_int_pos450(X,Y) get_csv_int((X),(Y),450) +#define get_csv_llong_pos450(X,Y) get_csv_llong((X),(Y),450) +#define get_csv_float_pos450(X,Y) get_csv_float((X),(Y),450) +#define get_csv_uint_pos451(X,Y) get_csv_uint((X),(Y),451) +#define get_csv_ullong_pos451(X,Y) get_csv_ullong((X),(Y),451) +#define get_csv_ip_pos451(X,Y) get_csv_ip((X),(Y),451) +#define get_csv_ipv6_pos451(X,Y) get_csv_ipv6((X),(Y),451) +#define get_csv_string_pos451(X,Y) get_csv_string((X),(Y),451) +#define get_csv_v_str_pos451(X,Y) get_csv_string((X),(Y),451) +#define get_csv_bool_pos451(X,Y) get_csv_bool((X),(Y),451) +#define get_csv_int_pos451(X,Y) get_csv_int((X),(Y),451) +#define get_csv_llong_pos451(X,Y) get_csv_llong((X),(Y),451) +#define get_csv_float_pos451(X,Y) get_csv_float((X),(Y),451) +#define get_csv_uint_pos452(X,Y) get_csv_uint((X),(Y),452) +#define get_csv_ullong_pos452(X,Y) get_csv_ullong((X),(Y),452) +#define get_csv_ip_pos452(X,Y) get_csv_ip((X),(Y),452) +#define get_csv_ipv6_pos452(X,Y) get_csv_ipv6((X),(Y),452) +#define get_csv_string_pos452(X,Y) get_csv_string((X),(Y),452) +#define get_csv_v_str_pos452(X,Y) get_csv_string((X),(Y),452) +#define get_csv_bool_pos452(X,Y) get_csv_bool((X),(Y),452) +#define get_csv_int_pos452(X,Y) get_csv_int((X),(Y),452) +#define get_csv_llong_pos452(X,Y) get_csv_llong((X),(Y),452) +#define get_csv_float_pos452(X,Y) get_csv_float((X),(Y),452) +#define get_csv_uint_pos453(X,Y) get_csv_uint((X),(Y),453) +#define get_csv_ullong_pos453(X,Y) get_csv_ullong((X),(Y),453) +#define get_csv_ip_pos453(X,Y) get_csv_ip((X),(Y),453) +#define get_csv_ipv6_pos453(X,Y) get_csv_ipv6((X),(Y),453) +#define get_csv_string_pos453(X,Y) get_csv_string((X),(Y),453) +#define get_csv_v_str_pos453(X,Y) get_csv_string((X),(Y),453) +#define get_csv_bool_pos453(X,Y) get_csv_bool((X),(Y),453) +#define get_csv_int_pos453(X,Y) get_csv_int((X),(Y),453) +#define get_csv_llong_pos453(X,Y) get_csv_llong((X),(Y),453) +#define get_csv_float_pos453(X,Y) get_csv_float((X),(Y),453) +#define get_csv_uint_pos454(X,Y) get_csv_uint((X),(Y),454) +#define get_csv_ullong_pos454(X,Y) get_csv_ullong((X),(Y),454) +#define get_csv_ip_pos454(X,Y) get_csv_ip((X),(Y),454) +#define get_csv_ipv6_pos454(X,Y) get_csv_ipv6((X),(Y),454) +#define get_csv_string_pos454(X,Y) get_csv_string((X),(Y),454) +#define get_csv_v_str_pos454(X,Y) get_csv_string((X),(Y),454) +#define get_csv_bool_pos454(X,Y) get_csv_bool((X),(Y),454) +#define get_csv_int_pos454(X,Y) get_csv_int((X),(Y),454) +#define get_csv_llong_pos454(X,Y) get_csv_llong((X),(Y),454) +#define get_csv_float_pos454(X,Y) get_csv_float((X),(Y),454) +#define get_csv_uint_pos455(X,Y) get_csv_uint((X),(Y),455) +#define get_csv_ullong_pos455(X,Y) get_csv_ullong((X),(Y),455) +#define get_csv_ip_pos455(X,Y) get_csv_ip((X),(Y),455) +#define get_csv_ipv6_pos455(X,Y) get_csv_ipv6((X),(Y),455) +#define get_csv_string_pos455(X,Y) get_csv_string((X),(Y),455) +#define get_csv_v_str_pos455(X,Y) get_csv_string((X),(Y),455) +#define get_csv_bool_pos455(X,Y) get_csv_bool((X),(Y),455) +#define get_csv_int_pos455(X,Y) get_csv_int((X),(Y),455) +#define get_csv_llong_pos455(X,Y) get_csv_llong((X),(Y),455) +#define get_csv_float_pos455(X,Y) get_csv_float((X),(Y),455) +#define get_csv_uint_pos456(X,Y) get_csv_uint((X),(Y),456) +#define get_csv_ullong_pos456(X,Y) get_csv_ullong((X),(Y),456) +#define get_csv_ip_pos456(X,Y) get_csv_ip((X),(Y),456) +#define get_csv_ipv6_pos456(X,Y) get_csv_ipv6((X),(Y),456) +#define get_csv_string_pos456(X,Y) get_csv_string((X),(Y),456) +#define get_csv_v_str_pos456(X,Y) get_csv_string((X),(Y),456) +#define get_csv_bool_pos456(X,Y) get_csv_bool((X),(Y),456) +#define get_csv_int_pos456(X,Y) get_csv_int((X),(Y),456) +#define get_csv_llong_pos456(X,Y) get_csv_llong((X),(Y),456) +#define get_csv_float_pos456(X,Y) get_csv_float((X),(Y),456) +#define get_csv_uint_pos457(X,Y) get_csv_uint((X),(Y),457) +#define get_csv_ullong_pos457(X,Y) get_csv_ullong((X),(Y),457) +#define get_csv_ip_pos457(X,Y) get_csv_ip((X),(Y),457) +#define get_csv_ipv6_pos457(X,Y) get_csv_ipv6((X),(Y),457) +#define get_csv_string_pos457(X,Y) get_csv_string((X),(Y),457) +#define get_csv_v_str_pos457(X,Y) get_csv_string((X),(Y),457) +#define get_csv_bool_pos457(X,Y) get_csv_bool((X),(Y),457) +#define get_csv_int_pos457(X,Y) get_csv_int((X),(Y),457) +#define get_csv_llong_pos457(X,Y) get_csv_llong((X),(Y),457) +#define get_csv_float_pos457(X,Y) get_csv_float((X),(Y),457) +#define get_csv_uint_pos458(X,Y) get_csv_uint((X),(Y),458) +#define get_csv_ullong_pos458(X,Y) get_csv_ullong((X),(Y),458) +#define get_csv_ip_pos458(X,Y) get_csv_ip((X),(Y),458) +#define get_csv_ipv6_pos458(X,Y) get_csv_ipv6((X),(Y),458) +#define get_csv_string_pos458(X,Y) get_csv_string((X),(Y),458) +#define get_csv_v_str_pos458(X,Y) get_csv_string((X),(Y),458) +#define get_csv_bool_pos458(X,Y) get_csv_bool((X),(Y),458) +#define get_csv_int_pos458(X,Y) get_csv_int((X),(Y),458) +#define get_csv_llong_pos458(X,Y) get_csv_llong((X),(Y),458) +#define get_csv_float_pos458(X,Y) get_csv_float((X),(Y),458) +#define get_csv_uint_pos459(X,Y) get_csv_uint((X),(Y),459) +#define get_csv_ullong_pos459(X,Y) get_csv_ullong((X),(Y),459) +#define get_csv_ip_pos459(X,Y) get_csv_ip((X),(Y),459) +#define get_csv_ipv6_pos459(X,Y) get_csv_ipv6((X),(Y),459) +#define get_csv_string_pos459(X,Y) get_csv_string((X),(Y),459) +#define get_csv_v_str_pos459(X,Y) get_csv_string((X),(Y),459) +#define get_csv_bool_pos459(X,Y) get_csv_bool((X),(Y),459) +#define get_csv_int_pos459(X,Y) get_csv_int((X),(Y),459) +#define get_csv_llong_pos459(X,Y) get_csv_llong((X),(Y),459) +#define get_csv_float_pos459(X,Y) get_csv_float((X),(Y),459) +#define get_csv_uint_pos460(X,Y) get_csv_uint((X),(Y),460) +#define get_csv_ullong_pos460(X,Y) get_csv_ullong((X),(Y),460) +#define get_csv_ip_pos460(X,Y) get_csv_ip((X),(Y),460) +#define get_csv_ipv6_pos460(X,Y) get_csv_ipv6((X),(Y),460) +#define get_csv_string_pos460(X,Y) get_csv_string((X),(Y),460) +#define get_csv_v_str_pos460(X,Y) get_csv_string((X),(Y),460) +#define get_csv_bool_pos460(X,Y) get_csv_bool((X),(Y),460) +#define get_csv_int_pos460(X,Y) get_csv_int((X),(Y),460) +#define get_csv_llong_pos460(X,Y) get_csv_llong((X),(Y),460) +#define get_csv_float_pos460(X,Y) get_csv_float((X),(Y),460) +#define get_csv_uint_pos461(X,Y) get_csv_uint((X),(Y),461) +#define get_csv_ullong_pos461(X,Y) get_csv_ullong((X),(Y),461) +#define get_csv_ip_pos461(X,Y) get_csv_ip((X),(Y),461) +#define get_csv_ipv6_pos461(X,Y) get_csv_ipv6((X),(Y),461) +#define get_csv_string_pos461(X,Y) get_csv_string((X),(Y),461) +#define get_csv_v_str_pos461(X,Y) get_csv_string((X),(Y),461) +#define get_csv_bool_pos461(X,Y) get_csv_bool((X),(Y),461) +#define get_csv_int_pos461(X,Y) get_csv_int((X),(Y),461) +#define get_csv_llong_pos461(X,Y) get_csv_llong((X),(Y),461) +#define get_csv_float_pos461(X,Y) get_csv_float((X),(Y),461) +#define get_csv_uint_pos462(X,Y) get_csv_uint((X),(Y),462) +#define get_csv_ullong_pos462(X,Y) get_csv_ullong((X),(Y),462) +#define get_csv_ip_pos462(X,Y) get_csv_ip((X),(Y),462) +#define get_csv_ipv6_pos462(X,Y) get_csv_ipv6((X),(Y),462) +#define get_csv_string_pos462(X,Y) get_csv_string((X),(Y),462) +#define get_csv_v_str_pos462(X,Y) get_csv_string((X),(Y),462) +#define get_csv_bool_pos462(X,Y) get_csv_bool((X),(Y),462) +#define get_csv_int_pos462(X,Y) get_csv_int((X),(Y),462) +#define get_csv_llong_pos462(X,Y) get_csv_llong((X),(Y),462) +#define get_csv_float_pos462(X,Y) get_csv_float((X),(Y),462) +#define get_csv_uint_pos463(X,Y) get_csv_uint((X),(Y),463) +#define get_csv_ullong_pos463(X,Y) get_csv_ullong((X),(Y),463) +#define get_csv_ip_pos463(X,Y) get_csv_ip((X),(Y),463) +#define get_csv_ipv6_pos463(X,Y) get_csv_ipv6((X),(Y),463) +#define get_csv_string_pos463(X,Y) get_csv_string((X),(Y),463) +#define get_csv_v_str_pos463(X,Y) get_csv_string((X),(Y),463) +#define get_csv_bool_pos463(X,Y) get_csv_bool((X),(Y),463) +#define get_csv_int_pos463(X,Y) get_csv_int((X),(Y),463) +#define get_csv_llong_pos463(X,Y) get_csv_llong((X),(Y),463) +#define get_csv_float_pos463(X,Y) get_csv_float((X),(Y),463) +#define get_csv_uint_pos464(X,Y) get_csv_uint((X),(Y),464) +#define get_csv_ullong_pos464(X,Y) get_csv_ullong((X),(Y),464) +#define get_csv_ip_pos464(X,Y) get_csv_ip((X),(Y),464) +#define get_csv_ipv6_pos464(X,Y) get_csv_ipv6((X),(Y),464) +#define get_csv_string_pos464(X,Y) get_csv_string((X),(Y),464) +#define get_csv_v_str_pos464(X,Y) get_csv_string((X),(Y),464) +#define get_csv_bool_pos464(X,Y) get_csv_bool((X),(Y),464) +#define get_csv_int_pos464(X,Y) get_csv_int((X),(Y),464) +#define get_csv_llong_pos464(X,Y) get_csv_llong((X),(Y),464) +#define get_csv_float_pos464(X,Y) get_csv_float((X),(Y),464) +#define get_csv_uint_pos465(X,Y) get_csv_uint((X),(Y),465) +#define get_csv_ullong_pos465(X,Y) get_csv_ullong((X),(Y),465) +#define get_csv_ip_pos465(X,Y) get_csv_ip((X),(Y),465) +#define get_csv_ipv6_pos465(X,Y) get_csv_ipv6((X),(Y),465) +#define get_csv_string_pos465(X,Y) get_csv_string((X),(Y),465) +#define get_csv_v_str_pos465(X,Y) get_csv_string((X),(Y),465) +#define get_csv_bool_pos465(X,Y) get_csv_bool((X),(Y),465) +#define get_csv_int_pos465(X,Y) get_csv_int((X),(Y),465) +#define get_csv_llong_pos465(X,Y) get_csv_llong((X),(Y),465) +#define get_csv_float_pos465(X,Y) get_csv_float((X),(Y),465) +#define get_csv_uint_pos466(X,Y) get_csv_uint((X),(Y),466) +#define get_csv_ullong_pos466(X,Y) get_csv_ullong((X),(Y),466) +#define get_csv_ip_pos466(X,Y) get_csv_ip((X),(Y),466) +#define get_csv_ipv6_pos466(X,Y) get_csv_ipv6((X),(Y),466) +#define get_csv_string_pos466(X,Y) get_csv_string((X),(Y),466) +#define get_csv_v_str_pos466(X,Y) get_csv_string((X),(Y),466) +#define get_csv_bool_pos466(X,Y) get_csv_bool((X),(Y),466) +#define get_csv_int_pos466(X,Y) get_csv_int((X),(Y),466) +#define get_csv_llong_pos466(X,Y) get_csv_llong((X),(Y),466) +#define get_csv_float_pos466(X,Y) get_csv_float((X),(Y),466) +#define get_csv_uint_pos467(X,Y) get_csv_uint((X),(Y),467) +#define get_csv_ullong_pos467(X,Y) get_csv_ullong((X),(Y),467) +#define get_csv_ip_pos467(X,Y) get_csv_ip((X),(Y),467) +#define get_csv_ipv6_pos467(X,Y) get_csv_ipv6((X),(Y),467) +#define get_csv_string_pos467(X,Y) get_csv_string((X),(Y),467) +#define get_csv_v_str_pos467(X,Y) get_csv_string((X),(Y),467) +#define get_csv_bool_pos467(X,Y) get_csv_bool((X),(Y),467) +#define get_csv_int_pos467(X,Y) get_csv_int((X),(Y),467) +#define get_csv_llong_pos467(X,Y) get_csv_llong((X),(Y),467) +#define get_csv_float_pos467(X,Y) get_csv_float((X),(Y),467) +#define get_csv_uint_pos468(X,Y) get_csv_uint((X),(Y),468) +#define get_csv_ullong_pos468(X,Y) get_csv_ullong((X),(Y),468) +#define get_csv_ip_pos468(X,Y) get_csv_ip((X),(Y),468) +#define get_csv_ipv6_pos468(X,Y) get_csv_ipv6((X),(Y),468) +#define get_csv_string_pos468(X,Y) get_csv_string((X),(Y),468) +#define get_csv_v_str_pos468(X,Y) get_csv_string((X),(Y),468) +#define get_csv_bool_pos468(X,Y) get_csv_bool((X),(Y),468) +#define get_csv_int_pos468(X,Y) get_csv_int((X),(Y),468) +#define get_csv_llong_pos468(X,Y) get_csv_llong((X),(Y),468) +#define get_csv_float_pos468(X,Y) get_csv_float((X),(Y),468) +#define get_csv_uint_pos469(X,Y) get_csv_uint((X),(Y),469) +#define get_csv_ullong_pos469(X,Y) get_csv_ullong((X),(Y),469) +#define get_csv_ip_pos469(X,Y) get_csv_ip((X),(Y),469) +#define get_csv_ipv6_pos469(X,Y) get_csv_ipv6((X),(Y),469) +#define get_csv_string_pos469(X,Y) get_csv_string((X),(Y),469) +#define get_csv_v_str_pos469(X,Y) get_csv_string((X),(Y),469) +#define get_csv_bool_pos469(X,Y) get_csv_bool((X),(Y),469) +#define get_csv_int_pos469(X,Y) get_csv_int((X),(Y),469) +#define get_csv_llong_pos469(X,Y) get_csv_llong((X),(Y),469) +#define get_csv_float_pos469(X,Y) get_csv_float((X),(Y),469) +#define get_csv_uint_pos470(X,Y) get_csv_uint((X),(Y),470) +#define get_csv_ullong_pos470(X,Y) get_csv_ullong((X),(Y),470) +#define get_csv_ip_pos470(X,Y) get_csv_ip((X),(Y),470) +#define get_csv_ipv6_pos470(X,Y) get_csv_ipv6((X),(Y),470) +#define get_csv_string_pos470(X,Y) get_csv_string((X),(Y),470) +#define get_csv_v_str_pos470(X,Y) get_csv_string((X),(Y),470) +#define get_csv_bool_pos470(X,Y) get_csv_bool((X),(Y),470) +#define get_csv_int_pos470(X,Y) get_csv_int((X),(Y),470) +#define get_csv_llong_pos470(X,Y) get_csv_llong((X),(Y),470) +#define get_csv_float_pos470(X,Y) get_csv_float((X),(Y),470) +#define get_csv_uint_pos471(X,Y) get_csv_uint((X),(Y),471) +#define get_csv_ullong_pos471(X,Y) get_csv_ullong((X),(Y),471) +#define get_csv_ip_pos471(X,Y) get_csv_ip((X),(Y),471) +#define get_csv_ipv6_pos471(X,Y) get_csv_ipv6((X),(Y),471) +#define get_csv_string_pos471(X,Y) get_csv_string((X),(Y),471) +#define get_csv_v_str_pos471(X,Y) get_csv_string((X),(Y),471) +#define get_csv_bool_pos471(X,Y) get_csv_bool((X),(Y),471) +#define get_csv_int_pos471(X,Y) get_csv_int((X),(Y),471) +#define get_csv_llong_pos471(X,Y) get_csv_llong((X),(Y),471) +#define get_csv_float_pos471(X,Y) get_csv_float((X),(Y),471) +#define get_csv_uint_pos472(X,Y) get_csv_uint((X),(Y),472) +#define get_csv_ullong_pos472(X,Y) get_csv_ullong((X),(Y),472) +#define get_csv_ip_pos472(X,Y) get_csv_ip((X),(Y),472) +#define get_csv_ipv6_pos472(X,Y) get_csv_ipv6((X),(Y),472) +#define get_csv_string_pos472(X,Y) get_csv_string((X),(Y),472) +#define get_csv_v_str_pos472(X,Y) get_csv_string((X),(Y),472) +#define get_csv_bool_pos472(X,Y) get_csv_bool((X),(Y),472) +#define get_csv_int_pos472(X,Y) get_csv_int((X),(Y),472) +#define get_csv_llong_pos472(X,Y) get_csv_llong((X),(Y),472) +#define get_csv_float_pos472(X,Y) get_csv_float((X),(Y),472) +#define get_csv_uint_pos473(X,Y) get_csv_uint((X),(Y),473) +#define get_csv_ullong_pos473(X,Y) get_csv_ullong((X),(Y),473) +#define get_csv_ip_pos473(X,Y) get_csv_ip((X),(Y),473) +#define get_csv_ipv6_pos473(X,Y) get_csv_ipv6((X),(Y),473) +#define get_csv_string_pos473(X,Y) get_csv_string((X),(Y),473) +#define get_csv_v_str_pos473(X,Y) get_csv_string((X),(Y),473) +#define get_csv_bool_pos473(X,Y) get_csv_bool((X),(Y),473) +#define get_csv_int_pos473(X,Y) get_csv_int((X),(Y),473) +#define get_csv_llong_pos473(X,Y) get_csv_llong((X),(Y),473) +#define get_csv_float_pos473(X,Y) get_csv_float((X),(Y),473) +#define get_csv_uint_pos474(X,Y) get_csv_uint((X),(Y),474) +#define get_csv_ullong_pos474(X,Y) get_csv_ullong((X),(Y),474) +#define get_csv_ip_pos474(X,Y) get_csv_ip((X),(Y),474) +#define get_csv_ipv6_pos474(X,Y) get_csv_ipv6((X),(Y),474) +#define get_csv_string_pos474(X,Y) get_csv_string((X),(Y),474) +#define get_csv_v_str_pos474(X,Y) get_csv_string((X),(Y),474) +#define get_csv_bool_pos474(X,Y) get_csv_bool((X),(Y),474) +#define get_csv_int_pos474(X,Y) get_csv_int((X),(Y),474) +#define get_csv_llong_pos474(X,Y) get_csv_llong((X),(Y),474) +#define get_csv_float_pos474(X,Y) get_csv_float((X),(Y),474) +#define get_csv_uint_pos475(X,Y) get_csv_uint((X),(Y),475) +#define get_csv_ullong_pos475(X,Y) get_csv_ullong((X),(Y),475) +#define get_csv_ip_pos475(X,Y) get_csv_ip((X),(Y),475) +#define get_csv_ipv6_pos475(X,Y) get_csv_ipv6((X),(Y),475) +#define get_csv_string_pos475(X,Y) get_csv_string((X),(Y),475) +#define get_csv_v_str_pos475(X,Y) get_csv_string((X),(Y),475) +#define get_csv_bool_pos475(X,Y) get_csv_bool((X),(Y),475) +#define get_csv_int_pos475(X,Y) get_csv_int((X),(Y),475) +#define get_csv_llong_pos475(X,Y) get_csv_llong((X),(Y),475) +#define get_csv_float_pos475(X,Y) get_csv_float((X),(Y),475) +#define get_csv_uint_pos476(X,Y) get_csv_uint((X),(Y),476) +#define get_csv_ullong_pos476(X,Y) get_csv_ullong((X),(Y),476) +#define get_csv_ip_pos476(X,Y) get_csv_ip((X),(Y),476) +#define get_csv_ipv6_pos476(X,Y) get_csv_ipv6((X),(Y),476) +#define get_csv_string_pos476(X,Y) get_csv_string((X),(Y),476) +#define get_csv_v_str_pos476(X,Y) get_csv_string((X),(Y),476) +#define get_csv_bool_pos476(X,Y) get_csv_bool((X),(Y),476) +#define get_csv_int_pos476(X,Y) get_csv_int((X),(Y),476) +#define get_csv_llong_pos476(X,Y) get_csv_llong((X),(Y),476) +#define get_csv_float_pos476(X,Y) get_csv_float((X),(Y),476) +#define get_csv_uint_pos477(X,Y) get_csv_uint((X),(Y),477) +#define get_csv_ullong_pos477(X,Y) get_csv_ullong((X),(Y),477) +#define get_csv_ip_pos477(X,Y) get_csv_ip((X),(Y),477) +#define get_csv_ipv6_pos477(X,Y) get_csv_ipv6((X),(Y),477) +#define get_csv_string_pos477(X,Y) get_csv_string((X),(Y),477) +#define get_csv_v_str_pos477(X,Y) get_csv_string((X),(Y),477) +#define get_csv_bool_pos477(X,Y) get_csv_bool((X),(Y),477) +#define get_csv_int_pos477(X,Y) get_csv_int((X),(Y),477) +#define get_csv_llong_pos477(X,Y) get_csv_llong((X),(Y),477) +#define get_csv_float_pos477(X,Y) get_csv_float((X),(Y),477) +#define get_csv_uint_pos478(X,Y) get_csv_uint((X),(Y),478) +#define get_csv_ullong_pos478(X,Y) get_csv_ullong((X),(Y),478) +#define get_csv_ip_pos478(X,Y) get_csv_ip((X),(Y),478) +#define get_csv_ipv6_pos478(X,Y) get_csv_ipv6((X),(Y),478) +#define get_csv_string_pos478(X,Y) get_csv_string((X),(Y),478) +#define get_csv_v_str_pos478(X,Y) get_csv_string((X),(Y),478) +#define get_csv_bool_pos478(X,Y) get_csv_bool((X),(Y),478) +#define get_csv_int_pos478(X,Y) get_csv_int((X),(Y),478) +#define get_csv_llong_pos478(X,Y) get_csv_llong((X),(Y),478) +#define get_csv_float_pos478(X,Y) get_csv_float((X),(Y),478) +#define get_csv_uint_pos479(X,Y) get_csv_uint((X),(Y),479) +#define get_csv_ullong_pos479(X,Y) get_csv_ullong((X),(Y),479) +#define get_csv_ip_pos479(X,Y) get_csv_ip((X),(Y),479) +#define get_csv_ipv6_pos479(X,Y) get_csv_ipv6((X),(Y),479) +#define get_csv_string_pos479(X,Y) get_csv_string((X),(Y),479) +#define get_csv_v_str_pos479(X,Y) get_csv_string((X),(Y),479) +#define get_csv_bool_pos479(X,Y) get_csv_bool((X),(Y),479) +#define get_csv_int_pos479(X,Y) get_csv_int((X),(Y),479) +#define get_csv_llong_pos479(X,Y) get_csv_llong((X),(Y),479) +#define get_csv_float_pos479(X,Y) get_csv_float((X),(Y),479) +#define get_csv_uint_pos480(X,Y) get_csv_uint((X),(Y),480) +#define get_csv_ullong_pos480(X,Y) get_csv_ullong((X),(Y),480) +#define get_csv_ip_pos480(X,Y) get_csv_ip((X),(Y),480) +#define get_csv_ipv6_pos480(X,Y) get_csv_ipv6((X),(Y),480) +#define get_csv_string_pos480(X,Y) get_csv_string((X),(Y),480) +#define get_csv_v_str_pos480(X,Y) get_csv_string((X),(Y),480) +#define get_csv_bool_pos480(X,Y) get_csv_bool((X),(Y),480) +#define get_csv_int_pos480(X,Y) get_csv_int((X),(Y),480) +#define get_csv_llong_pos480(X,Y) get_csv_llong((X),(Y),480) +#define get_csv_float_pos480(X,Y) get_csv_float((X),(Y),480) +#define get_csv_uint_pos481(X,Y) get_csv_uint((X),(Y),481) +#define get_csv_ullong_pos481(X,Y) get_csv_ullong((X),(Y),481) +#define get_csv_ip_pos481(X,Y) get_csv_ip((X),(Y),481) +#define get_csv_ipv6_pos481(X,Y) get_csv_ipv6((X),(Y),481) +#define get_csv_string_pos481(X,Y) get_csv_string((X),(Y),481) +#define get_csv_v_str_pos481(X,Y) get_csv_string((X),(Y),481) +#define get_csv_bool_pos481(X,Y) get_csv_bool((X),(Y),481) +#define get_csv_int_pos481(X,Y) get_csv_int((X),(Y),481) +#define get_csv_llong_pos481(X,Y) get_csv_llong((X),(Y),481) +#define get_csv_float_pos481(X,Y) get_csv_float((X),(Y),481) +#define get_csv_uint_pos482(X,Y) get_csv_uint((X),(Y),482) +#define get_csv_ullong_pos482(X,Y) get_csv_ullong((X),(Y),482) +#define get_csv_ip_pos482(X,Y) get_csv_ip((X),(Y),482) +#define get_csv_ipv6_pos482(X,Y) get_csv_ipv6((X),(Y),482) +#define get_csv_string_pos482(X,Y) get_csv_string((X),(Y),482) +#define get_csv_v_str_pos482(X,Y) get_csv_string((X),(Y),482) +#define get_csv_bool_pos482(X,Y) get_csv_bool((X),(Y),482) +#define get_csv_int_pos482(X,Y) get_csv_int((X),(Y),482) +#define get_csv_llong_pos482(X,Y) get_csv_llong((X),(Y),482) +#define get_csv_float_pos482(X,Y) get_csv_float((X),(Y),482) +#define get_csv_uint_pos483(X,Y) get_csv_uint((X),(Y),483) +#define get_csv_ullong_pos483(X,Y) get_csv_ullong((X),(Y),483) +#define get_csv_ip_pos483(X,Y) get_csv_ip((X),(Y),483) +#define get_csv_ipv6_pos483(X,Y) get_csv_ipv6((X),(Y),483) +#define get_csv_string_pos483(X,Y) get_csv_string((X),(Y),483) +#define get_csv_v_str_pos483(X,Y) get_csv_string((X),(Y),483) +#define get_csv_bool_pos483(X,Y) get_csv_bool((X),(Y),483) +#define get_csv_int_pos483(X,Y) get_csv_int((X),(Y),483) +#define get_csv_llong_pos483(X,Y) get_csv_llong((X),(Y),483) +#define get_csv_float_pos483(X,Y) get_csv_float((X),(Y),483) +#define get_csv_uint_pos484(X,Y) get_csv_uint((X),(Y),484) +#define get_csv_ullong_pos484(X,Y) get_csv_ullong((X),(Y),484) +#define get_csv_ip_pos484(X,Y) get_csv_ip((X),(Y),484) +#define get_csv_ipv6_pos484(X,Y) get_csv_ipv6((X),(Y),484) +#define get_csv_string_pos484(X,Y) get_csv_string((X),(Y),484) +#define get_csv_v_str_pos484(X,Y) get_csv_string((X),(Y),484) +#define get_csv_bool_pos484(X,Y) get_csv_bool((X),(Y),484) +#define get_csv_int_pos484(X,Y) get_csv_int((X),(Y),484) +#define get_csv_llong_pos484(X,Y) get_csv_llong((X),(Y),484) +#define get_csv_float_pos484(X,Y) get_csv_float((X),(Y),484) +#define get_csv_uint_pos485(X,Y) get_csv_uint((X),(Y),485) +#define get_csv_ullong_pos485(X,Y) get_csv_ullong((X),(Y),485) +#define get_csv_ip_pos485(X,Y) get_csv_ip((X),(Y),485) +#define get_csv_ipv6_pos485(X,Y) get_csv_ipv6((X),(Y),485) +#define get_csv_string_pos485(X,Y) get_csv_string((X),(Y),485) +#define get_csv_v_str_pos485(X,Y) get_csv_string((X),(Y),485) +#define get_csv_bool_pos485(X,Y) get_csv_bool((X),(Y),485) +#define get_csv_int_pos485(X,Y) get_csv_int((X),(Y),485) +#define get_csv_llong_pos485(X,Y) get_csv_llong((X),(Y),485) +#define get_csv_float_pos485(X,Y) get_csv_float((X),(Y),485) +#define get_csv_uint_pos486(X,Y) get_csv_uint((X),(Y),486) +#define get_csv_ullong_pos486(X,Y) get_csv_ullong((X),(Y),486) +#define get_csv_ip_pos486(X,Y) get_csv_ip((X),(Y),486) +#define get_csv_ipv6_pos486(X,Y) get_csv_ipv6((X),(Y),486) +#define get_csv_string_pos486(X,Y) get_csv_string((X),(Y),486) +#define get_csv_v_str_pos486(X,Y) get_csv_string((X),(Y),486) +#define get_csv_bool_pos486(X,Y) get_csv_bool((X),(Y),486) +#define get_csv_int_pos486(X,Y) get_csv_int((X),(Y),486) +#define get_csv_llong_pos486(X,Y) get_csv_llong((X),(Y),486) +#define get_csv_float_pos486(X,Y) get_csv_float((X),(Y),486) +#define get_csv_uint_pos487(X,Y) get_csv_uint((X),(Y),487) +#define get_csv_ullong_pos487(X,Y) get_csv_ullong((X),(Y),487) +#define get_csv_ip_pos487(X,Y) get_csv_ip((X),(Y),487) +#define get_csv_ipv6_pos487(X,Y) get_csv_ipv6((X),(Y),487) +#define get_csv_string_pos487(X,Y) get_csv_string((X),(Y),487) +#define get_csv_v_str_pos487(X,Y) get_csv_string((X),(Y),487) +#define get_csv_bool_pos487(X,Y) get_csv_bool((X),(Y),487) +#define get_csv_int_pos487(X,Y) get_csv_int((X),(Y),487) +#define get_csv_llong_pos487(X,Y) get_csv_llong((X),(Y),487) +#define get_csv_float_pos487(X,Y) get_csv_float((X),(Y),487) +#define get_csv_uint_pos488(X,Y) get_csv_uint((X),(Y),488) +#define get_csv_ullong_pos488(X,Y) get_csv_ullong((X),(Y),488) +#define get_csv_ip_pos488(X,Y) get_csv_ip((X),(Y),488) +#define get_csv_ipv6_pos488(X,Y) get_csv_ipv6((X),(Y),488) +#define get_csv_string_pos488(X,Y) get_csv_string((X),(Y),488) +#define get_csv_v_str_pos488(X,Y) get_csv_string((X),(Y),488) +#define get_csv_bool_pos488(X,Y) get_csv_bool((X),(Y),488) +#define get_csv_int_pos488(X,Y) get_csv_int((X),(Y),488) +#define get_csv_llong_pos488(X,Y) get_csv_llong((X),(Y),488) +#define get_csv_float_pos488(X,Y) get_csv_float((X),(Y),488) +#define get_csv_uint_pos489(X,Y) get_csv_uint((X),(Y),489) +#define get_csv_ullong_pos489(X,Y) get_csv_ullong((X),(Y),489) +#define get_csv_ip_pos489(X,Y) get_csv_ip((X),(Y),489) +#define get_csv_ipv6_pos489(X,Y) get_csv_ipv6((X),(Y),489) +#define get_csv_string_pos489(X,Y) get_csv_string((X),(Y),489) +#define get_csv_v_str_pos489(X,Y) get_csv_string((X),(Y),489) +#define get_csv_bool_pos489(X,Y) get_csv_bool((X),(Y),489) +#define get_csv_int_pos489(X,Y) get_csv_int((X),(Y),489) +#define get_csv_llong_pos489(X,Y) get_csv_llong((X),(Y),489) +#define get_csv_float_pos489(X,Y) get_csv_float((X),(Y),489) +#define get_csv_uint_pos490(X,Y) get_csv_uint((X),(Y),490) +#define get_csv_ullong_pos490(X,Y) get_csv_ullong((X),(Y),490) +#define get_csv_ip_pos490(X,Y) get_csv_ip((X),(Y),490) +#define get_csv_ipv6_pos490(X,Y) get_csv_ipv6((X),(Y),490) +#define get_csv_string_pos490(X,Y) get_csv_string((X),(Y),490) +#define get_csv_v_str_pos490(X,Y) get_csv_string((X),(Y),490) +#define get_csv_bool_pos490(X,Y) get_csv_bool((X),(Y),490) +#define get_csv_int_pos490(X,Y) get_csv_int((X),(Y),490) +#define get_csv_llong_pos490(X,Y) get_csv_llong((X),(Y),490) +#define get_csv_float_pos490(X,Y) get_csv_float((X),(Y),490) +#define get_csv_uint_pos491(X,Y) get_csv_uint((X),(Y),491) +#define get_csv_ullong_pos491(X,Y) get_csv_ullong((X),(Y),491) +#define get_csv_ip_pos491(X,Y) get_csv_ip((X),(Y),491) +#define get_csv_ipv6_pos491(X,Y) get_csv_ipv6((X),(Y),491) +#define get_csv_string_pos491(X,Y) get_csv_string((X),(Y),491) +#define get_csv_v_str_pos491(X,Y) get_csv_string((X),(Y),491) +#define get_csv_bool_pos491(X,Y) get_csv_bool((X),(Y),491) +#define get_csv_int_pos491(X,Y) get_csv_int((X),(Y),491) +#define get_csv_llong_pos491(X,Y) get_csv_llong((X),(Y),491) +#define get_csv_float_pos491(X,Y) get_csv_float((X),(Y),491) +#define get_csv_uint_pos492(X,Y) get_csv_uint((X),(Y),492) +#define get_csv_ullong_pos492(X,Y) get_csv_ullong((X),(Y),492) +#define get_csv_ip_pos492(X,Y) get_csv_ip((X),(Y),492) +#define get_csv_ipv6_pos492(X,Y) get_csv_ipv6((X),(Y),492) +#define get_csv_string_pos492(X,Y) get_csv_string((X),(Y),492) +#define get_csv_v_str_pos492(X,Y) get_csv_string((X),(Y),492) +#define get_csv_bool_pos492(X,Y) get_csv_bool((X),(Y),492) +#define get_csv_int_pos492(X,Y) get_csv_int((X),(Y),492) +#define get_csv_llong_pos492(X,Y) get_csv_llong((X),(Y),492) +#define get_csv_float_pos492(X,Y) get_csv_float((X),(Y),492) +#define get_csv_uint_pos493(X,Y) get_csv_uint((X),(Y),493) +#define get_csv_ullong_pos493(X,Y) get_csv_ullong((X),(Y),493) +#define get_csv_ip_pos493(X,Y) get_csv_ip((X),(Y),493) +#define get_csv_ipv6_pos493(X,Y) get_csv_ipv6((X),(Y),493) +#define get_csv_string_pos493(X,Y) get_csv_string((X),(Y),493) +#define get_csv_v_str_pos493(X,Y) get_csv_string((X),(Y),493) +#define get_csv_bool_pos493(X,Y) get_csv_bool((X),(Y),493) +#define get_csv_int_pos493(X,Y) get_csv_int((X),(Y),493) +#define get_csv_llong_pos493(X,Y) get_csv_llong((X),(Y),493) +#define get_csv_float_pos493(X,Y) get_csv_float((X),(Y),493) +#define get_csv_uint_pos494(X,Y) get_csv_uint((X),(Y),494) +#define get_csv_ullong_pos494(X,Y) get_csv_ullong((X),(Y),494) +#define get_csv_ip_pos494(X,Y) get_csv_ip((X),(Y),494) +#define get_csv_ipv6_pos494(X,Y) get_csv_ipv6((X),(Y),494) +#define get_csv_string_pos494(X,Y) get_csv_string((X),(Y),494) +#define get_csv_v_str_pos494(X,Y) get_csv_string((X),(Y),494) +#define get_csv_bool_pos494(X,Y) get_csv_bool((X),(Y),494) +#define get_csv_int_pos494(X,Y) get_csv_int((X),(Y),494) +#define get_csv_llong_pos494(X,Y) get_csv_llong((X),(Y),494) +#define get_csv_float_pos494(X,Y) get_csv_float((X),(Y),494) +#define get_csv_uint_pos495(X,Y) get_csv_uint((X),(Y),495) +#define get_csv_ullong_pos495(X,Y) get_csv_ullong((X),(Y),495) +#define get_csv_ip_pos495(X,Y) get_csv_ip((X),(Y),495) +#define get_csv_ipv6_pos495(X,Y) get_csv_ipv6((X),(Y),495) +#define get_csv_string_pos495(X,Y) get_csv_string((X),(Y),495) +#define get_csv_v_str_pos495(X,Y) get_csv_string((X),(Y),495) +#define get_csv_bool_pos495(X,Y) get_csv_bool((X),(Y),495) +#define get_csv_int_pos495(X,Y) get_csv_int((X),(Y),495) +#define get_csv_llong_pos495(X,Y) get_csv_llong((X),(Y),495) +#define get_csv_float_pos495(X,Y) get_csv_float((X),(Y),495) +#define get_csv_uint_pos496(X,Y) get_csv_uint((X),(Y),496) +#define get_csv_ullong_pos496(X,Y) get_csv_ullong((X),(Y),496) +#define get_csv_ip_pos496(X,Y) get_csv_ip((X),(Y),496) +#define get_csv_ipv6_pos496(X,Y) get_csv_ipv6((X),(Y),496) +#define get_csv_string_pos496(X,Y) get_csv_string((X),(Y),496) +#define get_csv_v_str_pos496(X,Y) get_csv_string((X),(Y),496) +#define get_csv_bool_pos496(X,Y) get_csv_bool((X),(Y),496) +#define get_csv_int_pos496(X,Y) get_csv_int((X),(Y),496) +#define get_csv_llong_pos496(X,Y) get_csv_llong((X),(Y),496) +#define get_csv_float_pos496(X,Y) get_csv_float((X),(Y),496) +#define get_csv_uint_pos497(X,Y) get_csv_uint((X),(Y),497) +#define get_csv_ullong_pos497(X,Y) get_csv_ullong((X),(Y),497) +#define get_csv_ip_pos497(X,Y) get_csv_ip((X),(Y),497) +#define get_csv_ipv6_pos497(X,Y) get_csv_ipv6((X),(Y),497) +#define get_csv_string_pos497(X,Y) get_csv_string((X),(Y),497) +#define get_csv_v_str_pos497(X,Y) get_csv_string((X),(Y),497) +#define get_csv_bool_pos497(X,Y) get_csv_bool((X),(Y),497) +#define get_csv_int_pos497(X,Y) get_csv_int((X),(Y),497) +#define get_csv_llong_pos497(X,Y) get_csv_llong((X),(Y),497) +#define get_csv_float_pos497(X,Y) get_csv_float((X),(Y),497) +#define get_csv_uint_pos498(X,Y) get_csv_uint((X),(Y),498) +#define get_csv_ullong_pos498(X,Y) get_csv_ullong((X),(Y),498) +#define get_csv_ip_pos498(X,Y) get_csv_ip((X),(Y),498) +#define get_csv_ipv6_pos498(X,Y) get_csv_ipv6((X),(Y),498) +#define get_csv_string_pos498(X,Y) get_csv_string((X),(Y),498) +#define get_csv_v_str_pos498(X,Y) get_csv_string((X),(Y),498) +#define get_csv_bool_pos498(X,Y) get_csv_bool((X),(Y),498) +#define get_csv_int_pos498(X,Y) get_csv_int((X),(Y),498) +#define get_csv_llong_pos498(X,Y) get_csv_llong((X),(Y),498) +#define get_csv_float_pos498(X,Y) get_csv_float((X),(Y),498) +#define get_csv_uint_pos499(X,Y) get_csv_uint((X),(Y),499) +#define get_csv_ullong_pos499(X,Y) get_csv_ullong((X),(Y),499) +#define get_csv_ip_pos499(X,Y) get_csv_ip((X),(Y),499) +#define get_csv_ipv6_pos499(X,Y) get_csv_ipv6((X),(Y),499) +#define get_csv_string_pos499(X,Y) get_csv_string((X),(Y),499) +#define get_csv_v_str_pos499(X,Y) get_csv_string((X),(Y),499) +#define get_csv_bool_pos499(X,Y) get_csv_bool((X),(Y),499) +#define get_csv_int_pos499(X,Y) get_csv_int((X),(Y),499) +#define get_csv_llong_pos499(X,Y) get_csv_llong((X),(Y),499) +#define get_csv_float_pos499(X,Y) get_csv_float((X),(Y),499) +#define get_csv_uint_pos500(X,Y) get_csv_uint((X),(Y),500) +#define get_csv_ullong_pos500(X,Y) get_csv_ullong((X),(Y),500) +#define get_csv_ip_pos500(X,Y) get_csv_ip((X),(Y),500) +#define get_csv_ipv6_pos500(X,Y) get_csv_ipv6((X),(Y),500) +#define get_csv_string_pos500(X,Y) get_csv_string((X),(Y),500) +#define get_csv_v_str_pos500(X,Y) get_csv_string((X),(Y),500) +#define get_csv_bool_pos500(X,Y) get_csv_bool((X),(Y),500) +#define get_csv_int_pos500(X,Y) get_csv_int((X),(Y),500) +#define get_csv_llong_pos500(X,Y) get_csv_llong((X),(Y),500) +#define get_csv_float_pos500(X,Y) get_csv_float((X),(Y),500) +#define get_csv_uint_pos501(X,Y) get_csv_uint((X),(Y),501) +#define get_csv_ullong_pos501(X,Y) get_csv_ullong((X),(Y),501) +#define get_csv_ip_pos501(X,Y) get_csv_ip((X),(Y),501) +#define get_csv_ipv6_pos501(X,Y) get_csv_ipv6((X),(Y),501) +#define get_csv_string_pos501(X,Y) get_csv_string((X),(Y),501) +#define get_csv_v_str_pos501(X,Y) get_csv_string((X),(Y),501) +#define get_csv_bool_pos501(X,Y) get_csv_bool((X),(Y),501) +#define get_csv_int_pos501(X,Y) get_csv_int((X),(Y),501) +#define get_csv_llong_pos501(X,Y) get_csv_llong((X),(Y),501) +#define get_csv_float_pos501(X,Y) get_csv_float((X),(Y),501) +#define get_csv_uint_pos502(X,Y) get_csv_uint((X),(Y),502) +#define get_csv_ullong_pos502(X,Y) get_csv_ullong((X),(Y),502) +#define get_csv_ip_pos502(X,Y) get_csv_ip((X),(Y),502) +#define get_csv_ipv6_pos502(X,Y) get_csv_ipv6((X),(Y),502) +#define get_csv_string_pos502(X,Y) get_csv_string((X),(Y),502) +#define get_csv_v_str_pos502(X,Y) get_csv_string((X),(Y),502) +#define get_csv_bool_pos502(X,Y) get_csv_bool((X),(Y),502) +#define get_csv_int_pos502(X,Y) get_csv_int((X),(Y),502) +#define get_csv_llong_pos502(X,Y) get_csv_llong((X),(Y),502) +#define get_csv_float_pos502(X,Y) get_csv_float((X),(Y),502) +#define get_csv_uint_pos503(X,Y) get_csv_uint((X),(Y),503) +#define get_csv_ullong_pos503(X,Y) get_csv_ullong((X),(Y),503) +#define get_csv_ip_pos503(X,Y) get_csv_ip((X),(Y),503) +#define get_csv_ipv6_pos503(X,Y) get_csv_ipv6((X),(Y),503) +#define get_csv_string_pos503(X,Y) get_csv_string((X),(Y),503) +#define get_csv_v_str_pos503(X,Y) get_csv_string((X),(Y),503) +#define get_csv_bool_pos503(X,Y) get_csv_bool((X),(Y),503) +#define get_csv_int_pos503(X,Y) get_csv_int((X),(Y),503) +#define get_csv_llong_pos503(X,Y) get_csv_llong((X),(Y),503) +#define get_csv_float_pos503(X,Y) get_csv_float((X),(Y),503) +#define get_csv_uint_pos504(X,Y) get_csv_uint((X),(Y),504) +#define get_csv_ullong_pos504(X,Y) get_csv_ullong((X),(Y),504) +#define get_csv_ip_pos504(X,Y) get_csv_ip((X),(Y),504) +#define get_csv_ipv6_pos504(X,Y) get_csv_ipv6((X),(Y),504) +#define get_csv_string_pos504(X,Y) get_csv_string((X),(Y),504) +#define get_csv_v_str_pos504(X,Y) get_csv_string((X),(Y),504) +#define get_csv_bool_pos504(X,Y) get_csv_bool((X),(Y),504) +#define get_csv_int_pos504(X,Y) get_csv_int((X),(Y),504) +#define get_csv_llong_pos504(X,Y) get_csv_llong((X),(Y),504) +#define get_csv_float_pos504(X,Y) get_csv_float((X),(Y),504) +#define get_csv_uint_pos505(X,Y) get_csv_uint((X),(Y),505) +#define get_csv_ullong_pos505(X,Y) get_csv_ullong((X),(Y),505) +#define get_csv_ip_pos505(X,Y) get_csv_ip((X),(Y),505) +#define get_csv_ipv6_pos505(X,Y) get_csv_ipv6((X),(Y),505) +#define get_csv_string_pos505(X,Y) get_csv_string((X),(Y),505) +#define get_csv_v_str_pos505(X,Y) get_csv_string((X),(Y),505) +#define get_csv_bool_pos505(X,Y) get_csv_bool((X),(Y),505) +#define get_csv_int_pos505(X,Y) get_csv_int((X),(Y),505) +#define get_csv_llong_pos505(X,Y) get_csv_llong((X),(Y),505) +#define get_csv_float_pos505(X,Y) get_csv_float((X),(Y),505) +#define get_csv_uint_pos506(X,Y) get_csv_uint((X),(Y),506) +#define get_csv_ullong_pos506(X,Y) get_csv_ullong((X),(Y),506) +#define get_csv_ip_pos506(X,Y) get_csv_ip((X),(Y),506) +#define get_csv_ipv6_pos506(X,Y) get_csv_ipv6((X),(Y),506) +#define get_csv_string_pos506(X,Y) get_csv_string((X),(Y),506) +#define get_csv_v_str_pos506(X,Y) get_csv_string((X),(Y),506) +#define get_csv_bool_pos506(X,Y) get_csv_bool((X),(Y),506) +#define get_csv_int_pos506(X,Y) get_csv_int((X),(Y),506) +#define get_csv_llong_pos506(X,Y) get_csv_llong((X),(Y),506) +#define get_csv_float_pos506(X,Y) get_csv_float((X),(Y),506) +#define get_csv_uint_pos507(X,Y) get_csv_uint((X),(Y),507) +#define get_csv_ullong_pos507(X,Y) get_csv_ullong((X),(Y),507) +#define get_csv_ip_pos507(X,Y) get_csv_ip((X),(Y),507) +#define get_csv_ipv6_pos507(X,Y) get_csv_ipv6((X),(Y),507) +#define get_csv_string_pos507(X,Y) get_csv_string((X),(Y),507) +#define get_csv_v_str_pos507(X,Y) get_csv_string((X),(Y),507) +#define get_csv_bool_pos507(X,Y) get_csv_bool((X),(Y),507) +#define get_csv_int_pos507(X,Y) get_csv_int((X),(Y),507) +#define get_csv_llong_pos507(X,Y) get_csv_llong((X),(Y),507) +#define get_csv_float_pos507(X,Y) get_csv_float((X),(Y),507) +#define get_csv_uint_pos508(X,Y) get_csv_uint((X),(Y),508) +#define get_csv_ullong_pos508(X,Y) get_csv_ullong((X),(Y),508) +#define get_csv_ip_pos508(X,Y) get_csv_ip((X),(Y),508) +#define get_csv_ipv6_pos508(X,Y) get_csv_ipv6((X),(Y),508) +#define get_csv_string_pos508(X,Y) get_csv_string((X),(Y),508) +#define get_csv_v_str_pos508(X,Y) get_csv_string((X),(Y),508) +#define get_csv_bool_pos508(X,Y) get_csv_bool((X),(Y),508) +#define get_csv_int_pos508(X,Y) get_csv_int((X),(Y),508) +#define get_csv_llong_pos508(X,Y) get_csv_llong((X),(Y),508) +#define get_csv_float_pos508(X,Y) get_csv_float((X),(Y),508) +#define get_csv_uint_pos509(X,Y) get_csv_uint((X),(Y),509) +#define get_csv_ullong_pos509(X,Y) get_csv_ullong((X),(Y),509) +#define get_csv_ip_pos509(X,Y) get_csv_ip((X),(Y),509) +#define get_csv_ipv6_pos509(X,Y) get_csv_ipv6((X),(Y),509) +#define get_csv_string_pos509(X,Y) get_csv_string((X),(Y),509) +#define get_csv_v_str_pos509(X,Y) get_csv_string((X),(Y),509) +#define get_csv_bool_pos509(X,Y) get_csv_bool((X),(Y),509) +#define get_csv_int_pos509(X,Y) get_csv_int((X),(Y),509) +#define get_csv_llong_pos509(X,Y) get_csv_llong((X),(Y),509) +#define get_csv_float_pos509(X,Y) get_csv_float((X),(Y),509) +#define get_csv_uint_pos510(X,Y) get_csv_uint((X),(Y),510) +#define get_csv_ullong_pos510(X,Y) get_csv_ullong((X),(Y),510) +#define get_csv_ip_pos510(X,Y) get_csv_ip((X),(Y),510) +#define get_csv_ipv6_pos510(X,Y) get_csv_ipv6((X),(Y),510) +#define get_csv_string_pos510(X,Y) get_csv_string((X),(Y),510) +#define get_csv_v_str_pos510(X,Y) get_csv_string((X),(Y),510) +#define get_csv_bool_pos510(X,Y) get_csv_bool((X),(Y),510) +#define get_csv_int_pos510(X,Y) get_csv_int((X),(Y),510) +#define get_csv_llong_pos510(X,Y) get_csv_llong((X),(Y),510) +#define get_csv_float_pos510(X,Y) get_csv_float((X),(Y),510) +#define get_csv_uint_pos511(X,Y) get_csv_uint((X),(Y),511) +#define get_csv_ullong_pos511(X,Y) get_csv_ullong((X),(Y),511) +#define get_csv_ip_pos511(X,Y) get_csv_ip((X),(Y),511) +#define get_csv_ipv6_pos511(X,Y) get_csv_ipv6((X),(Y),511) +#define get_csv_string_pos511(X,Y) get_csv_string((X),(Y),511) +#define get_csv_v_str_pos511(X,Y) get_csv_string((X),(Y),511) +#define get_csv_bool_pos511(X,Y) get_csv_bool((X),(Y),511) +#define get_csv_int_pos511(X,Y) get_csv_int((X),(Y),511) +#define get_csv_llong_pos511(X,Y) get_csv_llong((X),(Y),511) +#define get_csv_float_pos511(X,Y) get_csv_float((X),(Y),511) +#define get_csv_uint_pos512(X,Y) get_csv_uint((X),(Y),512) +#define get_csv_ullong_pos512(X,Y) get_csv_ullong((X),(Y),512) +#define get_csv_ip_pos512(X,Y) get_csv_ip((X),(Y),512) +#define get_csv_ipv6_pos512(X,Y) get_csv_ipv6((X),(Y),512) +#define get_csv_string_pos512(X,Y) get_csv_string((X),(Y),512) +#define get_csv_v_str_pos512(X,Y) get_csv_string((X),(Y),512) +#define get_csv_bool_pos512(X,Y) get_csv_bool((X),(Y),512) +#define get_csv_int_pos512(X,Y) get_csv_int((X),(Y),512) +#define get_csv_llong_pos512(X,Y) get_csv_llong((X),(Y),512) +#define get_csv_float_pos512(X,Y) get_csv_float((X),(Y),512) +#define get_csv_uint_pos513(X,Y) get_csv_uint((X),(Y),513) +#define get_csv_ullong_pos513(X,Y) get_csv_ullong((X),(Y),513) +#define get_csv_ip_pos513(X,Y) get_csv_ip((X),(Y),513) +#define get_csv_ipv6_pos513(X,Y) get_csv_ipv6((X),(Y),513) +#define get_csv_string_pos513(X,Y) get_csv_string((X),(Y),513) +#define get_csv_v_str_pos513(X,Y) get_csv_string((X),(Y),513) +#define get_csv_bool_pos513(X,Y) get_csv_bool((X),(Y),513) +#define get_csv_int_pos513(X,Y) get_csv_int((X),(Y),513) +#define get_csv_llong_pos513(X,Y) get_csv_llong((X),(Y),513) +#define get_csv_float_pos513(X,Y) get_csv_float((X),(Y),513) +#define get_csv_uint_pos514(X,Y) get_csv_uint((X),(Y),514) +#define get_csv_ullong_pos514(X,Y) get_csv_ullong((X),(Y),514) +#define get_csv_ip_pos514(X,Y) get_csv_ip((X),(Y),514) +#define get_csv_ipv6_pos514(X,Y) get_csv_ipv6((X),(Y),514) +#define get_csv_string_pos514(X,Y) get_csv_string((X),(Y),514) +#define get_csv_v_str_pos514(X,Y) get_csv_string((X),(Y),514) +#define get_csv_bool_pos514(X,Y) get_csv_bool((X),(Y),514) +#define get_csv_int_pos514(X,Y) get_csv_int((X),(Y),514) +#define get_csv_llong_pos514(X,Y) get_csv_llong((X),(Y),514) +#define get_csv_float_pos514(X,Y) get_csv_float((X),(Y),514) +#define get_csv_uint_pos515(X,Y) get_csv_uint((X),(Y),515) +#define get_csv_ullong_pos515(X,Y) get_csv_ullong((X),(Y),515) +#define get_csv_ip_pos515(X,Y) get_csv_ip((X),(Y),515) +#define get_csv_ipv6_pos515(X,Y) get_csv_ipv6((X),(Y),515) +#define get_csv_string_pos515(X,Y) get_csv_string((X),(Y),515) +#define get_csv_v_str_pos515(X,Y) get_csv_string((X),(Y),515) +#define get_csv_bool_pos515(X,Y) get_csv_bool((X),(Y),515) +#define get_csv_int_pos515(X,Y) get_csv_int((X),(Y),515) +#define get_csv_llong_pos515(X,Y) get_csv_llong((X),(Y),515) +#define get_csv_float_pos515(X,Y) get_csv_float((X),(Y),515) +#define get_csv_uint_pos516(X,Y) get_csv_uint((X),(Y),516) +#define get_csv_ullong_pos516(X,Y) get_csv_ullong((X),(Y),516) +#define get_csv_ip_pos516(X,Y) get_csv_ip((X),(Y),516) +#define get_csv_ipv6_pos516(X,Y) get_csv_ipv6((X),(Y),516) +#define get_csv_string_pos516(X,Y) get_csv_string((X),(Y),516) +#define get_csv_v_str_pos516(X,Y) get_csv_string((X),(Y),516) +#define get_csv_bool_pos516(X,Y) get_csv_bool((X),(Y),516) +#define get_csv_int_pos516(X,Y) get_csv_int((X),(Y),516) +#define get_csv_llong_pos516(X,Y) get_csv_llong((X),(Y),516) +#define get_csv_float_pos516(X,Y) get_csv_float((X),(Y),516) +#define get_csv_uint_pos517(X,Y) get_csv_uint((X),(Y),517) +#define get_csv_ullong_pos517(X,Y) get_csv_ullong((X),(Y),517) +#define get_csv_ip_pos517(X,Y) get_csv_ip((X),(Y),517) +#define get_csv_ipv6_pos517(X,Y) get_csv_ipv6((X),(Y),517) +#define get_csv_string_pos517(X,Y) get_csv_string((X),(Y),517) +#define get_csv_v_str_pos517(X,Y) get_csv_string((X),(Y),517) +#define get_csv_bool_pos517(X,Y) get_csv_bool((X),(Y),517) +#define get_csv_int_pos517(X,Y) get_csv_int((X),(Y),517) +#define get_csv_llong_pos517(X,Y) get_csv_llong((X),(Y),517) +#define get_csv_float_pos517(X,Y) get_csv_float((X),(Y),517) +#define get_csv_uint_pos518(X,Y) get_csv_uint((X),(Y),518) +#define get_csv_ullong_pos518(X,Y) get_csv_ullong((X),(Y),518) +#define get_csv_ip_pos518(X,Y) get_csv_ip((X),(Y),518) +#define get_csv_ipv6_pos518(X,Y) get_csv_ipv6((X),(Y),518) +#define get_csv_string_pos518(X,Y) get_csv_string((X),(Y),518) +#define get_csv_v_str_pos518(X,Y) get_csv_string((X),(Y),518) +#define get_csv_bool_pos518(X,Y) get_csv_bool((X),(Y),518) +#define get_csv_int_pos518(X,Y) get_csv_int((X),(Y),518) +#define get_csv_llong_pos518(X,Y) get_csv_llong((X),(Y),518) +#define get_csv_float_pos518(X,Y) get_csv_float((X),(Y),518) +#define get_csv_uint_pos519(X,Y) get_csv_uint((X),(Y),519) +#define get_csv_ullong_pos519(X,Y) get_csv_ullong((X),(Y),519) +#define get_csv_ip_pos519(X,Y) get_csv_ip((X),(Y),519) +#define get_csv_ipv6_pos519(X,Y) get_csv_ipv6((X),(Y),519) +#define get_csv_string_pos519(X,Y) get_csv_string((X),(Y),519) +#define get_csv_v_str_pos519(X,Y) get_csv_string((X),(Y),519) +#define get_csv_bool_pos519(X,Y) get_csv_bool((X),(Y),519) +#define get_csv_int_pos519(X,Y) get_csv_int((X),(Y),519) +#define get_csv_llong_pos519(X,Y) get_csv_llong((X),(Y),519) +#define get_csv_float_pos519(X,Y) get_csv_float((X),(Y),519) +#define get_csv_uint_pos520(X,Y) get_csv_uint((X),(Y),520) +#define get_csv_ullong_pos520(X,Y) get_csv_ullong((X),(Y),520) +#define get_csv_ip_pos520(X,Y) get_csv_ip((X),(Y),520) +#define get_csv_ipv6_pos520(X,Y) get_csv_ipv6((X),(Y),520) +#define get_csv_string_pos520(X,Y) get_csv_string((X),(Y),520) +#define get_csv_v_str_pos520(X,Y) get_csv_string((X),(Y),520) +#define get_csv_bool_pos520(X,Y) get_csv_bool((X),(Y),520) +#define get_csv_int_pos520(X,Y) get_csv_int((X),(Y),520) +#define get_csv_llong_pos520(X,Y) get_csv_llong((X),(Y),520) +#define get_csv_float_pos520(X,Y) get_csv_float((X),(Y),520) +#define get_csv_uint_pos521(X,Y) get_csv_uint((X),(Y),521) +#define get_csv_ullong_pos521(X,Y) get_csv_ullong((X),(Y),521) +#define get_csv_ip_pos521(X,Y) get_csv_ip((X),(Y),521) +#define get_csv_ipv6_pos521(X,Y) get_csv_ipv6((X),(Y),521) +#define get_csv_string_pos521(X,Y) get_csv_string((X),(Y),521) +#define get_csv_v_str_pos521(X,Y) get_csv_string((X),(Y),521) +#define get_csv_bool_pos521(X,Y) get_csv_bool((X),(Y),521) +#define get_csv_int_pos521(X,Y) get_csv_int((X),(Y),521) +#define get_csv_llong_pos521(X,Y) get_csv_llong((X),(Y),521) +#define get_csv_float_pos521(X,Y) get_csv_float((X),(Y),521) +#define get_csv_uint_pos522(X,Y) get_csv_uint((X),(Y),522) +#define get_csv_ullong_pos522(X,Y) get_csv_ullong((X),(Y),522) +#define get_csv_ip_pos522(X,Y) get_csv_ip((X),(Y),522) +#define get_csv_ipv6_pos522(X,Y) get_csv_ipv6((X),(Y),522) +#define get_csv_string_pos522(X,Y) get_csv_string((X),(Y),522) +#define get_csv_v_str_pos522(X,Y) get_csv_string((X),(Y),522) +#define get_csv_bool_pos522(X,Y) get_csv_bool((X),(Y),522) +#define get_csv_int_pos522(X,Y) get_csv_int((X),(Y),522) +#define get_csv_llong_pos522(X,Y) get_csv_llong((X),(Y),522) +#define get_csv_float_pos522(X,Y) get_csv_float((X),(Y),522) +#define get_csv_uint_pos523(X,Y) get_csv_uint((X),(Y),523) +#define get_csv_ullong_pos523(X,Y) get_csv_ullong((X),(Y),523) +#define get_csv_ip_pos523(X,Y) get_csv_ip((X),(Y),523) +#define get_csv_ipv6_pos523(X,Y) get_csv_ipv6((X),(Y),523) +#define get_csv_string_pos523(X,Y) get_csv_string((X),(Y),523) +#define get_csv_v_str_pos523(X,Y) get_csv_string((X),(Y),523) +#define get_csv_bool_pos523(X,Y) get_csv_bool((X),(Y),523) +#define get_csv_int_pos523(X,Y) get_csv_int((X),(Y),523) +#define get_csv_llong_pos523(X,Y) get_csv_llong((X),(Y),523) +#define get_csv_float_pos523(X,Y) get_csv_float((X),(Y),523) +#define get_csv_uint_pos524(X,Y) get_csv_uint((X),(Y),524) +#define get_csv_ullong_pos524(X,Y) get_csv_ullong((X),(Y),524) +#define get_csv_ip_pos524(X,Y) get_csv_ip((X),(Y),524) +#define get_csv_ipv6_pos524(X,Y) get_csv_ipv6((X),(Y),524) +#define get_csv_string_pos524(X,Y) get_csv_string((X),(Y),524) +#define get_csv_v_str_pos524(X,Y) get_csv_string((X),(Y),524) +#define get_csv_bool_pos524(X,Y) get_csv_bool((X),(Y),524) +#define get_csv_int_pos524(X,Y) get_csv_int((X),(Y),524) +#define get_csv_llong_pos524(X,Y) get_csv_llong((X),(Y),524) +#define get_csv_float_pos524(X,Y) get_csv_float((X),(Y),524) +#define get_csv_uint_pos525(X,Y) get_csv_uint((X),(Y),525) +#define get_csv_ullong_pos525(X,Y) get_csv_ullong((X),(Y),525) +#define get_csv_ip_pos525(X,Y) get_csv_ip((X),(Y),525) +#define get_csv_ipv6_pos525(X,Y) get_csv_ipv6((X),(Y),525) +#define get_csv_string_pos525(X,Y) get_csv_string((X),(Y),525) +#define get_csv_v_str_pos525(X,Y) get_csv_string((X),(Y),525) +#define get_csv_bool_pos525(X,Y) get_csv_bool((X),(Y),525) +#define get_csv_int_pos525(X,Y) get_csv_int((X),(Y),525) +#define get_csv_llong_pos525(X,Y) get_csv_llong((X),(Y),525) +#define get_csv_float_pos525(X,Y) get_csv_float((X),(Y),525) +#define get_csv_uint_pos526(X,Y) get_csv_uint((X),(Y),526) +#define get_csv_ullong_pos526(X,Y) get_csv_ullong((X),(Y),526) +#define get_csv_ip_pos526(X,Y) get_csv_ip((X),(Y),526) +#define get_csv_ipv6_pos526(X,Y) get_csv_ipv6((X),(Y),526) +#define get_csv_string_pos526(X,Y) get_csv_string((X),(Y),526) +#define get_csv_v_str_pos526(X,Y) get_csv_string((X),(Y),526) +#define get_csv_bool_pos526(X,Y) get_csv_bool((X),(Y),526) +#define get_csv_int_pos526(X,Y) get_csv_int((X),(Y),526) +#define get_csv_llong_pos526(X,Y) get_csv_llong((X),(Y),526) +#define get_csv_float_pos526(X,Y) get_csv_float((X),(Y),526) +#define get_csv_uint_pos527(X,Y) get_csv_uint((X),(Y),527) +#define get_csv_ullong_pos527(X,Y) get_csv_ullong((X),(Y),527) +#define get_csv_ip_pos527(X,Y) get_csv_ip((X),(Y),527) +#define get_csv_ipv6_pos527(X,Y) get_csv_ipv6((X),(Y),527) +#define get_csv_string_pos527(X,Y) get_csv_string((X),(Y),527) +#define get_csv_v_str_pos527(X,Y) get_csv_string((X),(Y),527) +#define get_csv_bool_pos527(X,Y) get_csv_bool((X),(Y),527) +#define get_csv_int_pos527(X,Y) get_csv_int((X),(Y),527) +#define get_csv_llong_pos527(X,Y) get_csv_llong((X),(Y),527) +#define get_csv_float_pos527(X,Y) get_csv_float((X),(Y),527) +#define get_csv_uint_pos528(X,Y) get_csv_uint((X),(Y),528) +#define get_csv_ullong_pos528(X,Y) get_csv_ullong((X),(Y),528) +#define get_csv_ip_pos528(X,Y) get_csv_ip((X),(Y),528) +#define get_csv_ipv6_pos528(X,Y) get_csv_ipv6((X),(Y),528) +#define get_csv_string_pos528(X,Y) get_csv_string((X),(Y),528) +#define get_csv_v_str_pos528(X,Y) get_csv_string((X),(Y),528) +#define get_csv_bool_pos528(X,Y) get_csv_bool((X),(Y),528) +#define get_csv_int_pos528(X,Y) get_csv_int((X),(Y),528) +#define get_csv_llong_pos528(X,Y) get_csv_llong((X),(Y),528) +#define get_csv_float_pos528(X,Y) get_csv_float((X),(Y),528) +#define get_csv_uint_pos529(X,Y) get_csv_uint((X),(Y),529) +#define get_csv_ullong_pos529(X,Y) get_csv_ullong((X),(Y),529) +#define get_csv_ip_pos529(X,Y) get_csv_ip((X),(Y),529) +#define get_csv_ipv6_pos529(X,Y) get_csv_ipv6((X),(Y),529) +#define get_csv_string_pos529(X,Y) get_csv_string((X),(Y),529) +#define get_csv_v_str_pos529(X,Y) get_csv_string((X),(Y),529) +#define get_csv_bool_pos529(X,Y) get_csv_bool((X),(Y),529) +#define get_csv_int_pos529(X,Y) get_csv_int((X),(Y),529) +#define get_csv_llong_pos529(X,Y) get_csv_llong((X),(Y),529) +#define get_csv_float_pos529(X,Y) get_csv_float((X),(Y),529) +#define get_csv_uint_pos530(X,Y) get_csv_uint((X),(Y),530) +#define get_csv_ullong_pos530(X,Y) get_csv_ullong((X),(Y),530) +#define get_csv_ip_pos530(X,Y) get_csv_ip((X),(Y),530) +#define get_csv_ipv6_pos530(X,Y) get_csv_ipv6((X),(Y),530) +#define get_csv_string_pos530(X,Y) get_csv_string((X),(Y),530) +#define get_csv_v_str_pos530(X,Y) get_csv_string((X),(Y),530) +#define get_csv_bool_pos530(X,Y) get_csv_bool((X),(Y),530) +#define get_csv_int_pos530(X,Y) get_csv_int((X),(Y),530) +#define get_csv_llong_pos530(X,Y) get_csv_llong((X),(Y),530) +#define get_csv_float_pos530(X,Y) get_csv_float((X),(Y),530) +#define get_csv_uint_pos531(X,Y) get_csv_uint((X),(Y),531) +#define get_csv_ullong_pos531(X,Y) get_csv_ullong((X),(Y),531) +#define get_csv_ip_pos531(X,Y) get_csv_ip((X),(Y),531) +#define get_csv_ipv6_pos531(X,Y) get_csv_ipv6((X),(Y),531) +#define get_csv_string_pos531(X,Y) get_csv_string((X),(Y),531) +#define get_csv_v_str_pos531(X,Y) get_csv_string((X),(Y),531) +#define get_csv_bool_pos531(X,Y) get_csv_bool((X),(Y),531) +#define get_csv_int_pos531(X,Y) get_csv_int((X),(Y),531) +#define get_csv_llong_pos531(X,Y) get_csv_llong((X),(Y),531) +#define get_csv_float_pos531(X,Y) get_csv_float((X),(Y),531) +#define get_csv_uint_pos532(X,Y) get_csv_uint((X),(Y),532) +#define get_csv_ullong_pos532(X,Y) get_csv_ullong((X),(Y),532) +#define get_csv_ip_pos532(X,Y) get_csv_ip((X),(Y),532) +#define get_csv_ipv6_pos532(X,Y) get_csv_ipv6((X),(Y),532) +#define get_csv_string_pos532(X,Y) get_csv_string((X),(Y),532) +#define get_csv_v_str_pos532(X,Y) get_csv_string((X),(Y),532) +#define get_csv_bool_pos532(X,Y) get_csv_bool((X),(Y),532) +#define get_csv_int_pos532(X,Y) get_csv_int((X),(Y),532) +#define get_csv_llong_pos532(X,Y) get_csv_llong((X),(Y),532) +#define get_csv_float_pos532(X,Y) get_csv_float((X),(Y),532) +#define get_csv_uint_pos533(X,Y) get_csv_uint((X),(Y),533) +#define get_csv_ullong_pos533(X,Y) get_csv_ullong((X),(Y),533) +#define get_csv_ip_pos533(X,Y) get_csv_ip((X),(Y),533) +#define get_csv_ipv6_pos533(X,Y) get_csv_ipv6((X),(Y),533) +#define get_csv_string_pos533(X,Y) get_csv_string((X),(Y),533) +#define get_csv_v_str_pos533(X,Y) get_csv_string((X),(Y),533) +#define get_csv_bool_pos533(X,Y) get_csv_bool((X),(Y),533) +#define get_csv_int_pos533(X,Y) get_csv_int((X),(Y),533) +#define get_csv_llong_pos533(X,Y) get_csv_llong((X),(Y),533) +#define get_csv_float_pos533(X,Y) get_csv_float((X),(Y),533) +#define get_csv_uint_pos534(X,Y) get_csv_uint((X),(Y),534) +#define get_csv_ullong_pos534(X,Y) get_csv_ullong((X),(Y),534) +#define get_csv_ip_pos534(X,Y) get_csv_ip((X),(Y),534) +#define get_csv_ipv6_pos534(X,Y) get_csv_ipv6((X),(Y),534) +#define get_csv_string_pos534(X,Y) get_csv_string((X),(Y),534) +#define get_csv_v_str_pos534(X,Y) get_csv_string((X),(Y),534) +#define get_csv_bool_pos534(X,Y) get_csv_bool((X),(Y),534) +#define get_csv_int_pos534(X,Y) get_csv_int((X),(Y),534) +#define get_csv_llong_pos534(X,Y) get_csv_llong((X),(Y),534) +#define get_csv_float_pos534(X,Y) get_csv_float((X),(Y),534) +#define get_csv_uint_pos535(X,Y) get_csv_uint((X),(Y),535) +#define get_csv_ullong_pos535(X,Y) get_csv_ullong((X),(Y),535) +#define get_csv_ip_pos535(X,Y) get_csv_ip((X),(Y),535) +#define get_csv_ipv6_pos535(X,Y) get_csv_ipv6((X),(Y),535) +#define get_csv_string_pos535(X,Y) get_csv_string((X),(Y),535) +#define get_csv_v_str_pos535(X,Y) get_csv_string((X),(Y),535) +#define get_csv_bool_pos535(X,Y) get_csv_bool((X),(Y),535) +#define get_csv_int_pos535(X,Y) get_csv_int((X),(Y),535) +#define get_csv_llong_pos535(X,Y) get_csv_llong((X),(Y),535) +#define get_csv_float_pos535(X,Y) get_csv_float((X),(Y),535) +#define get_csv_uint_pos536(X,Y) get_csv_uint((X),(Y),536) +#define get_csv_ullong_pos536(X,Y) get_csv_ullong((X),(Y),536) +#define get_csv_ip_pos536(X,Y) get_csv_ip((X),(Y),536) +#define get_csv_ipv6_pos536(X,Y) get_csv_ipv6((X),(Y),536) +#define get_csv_string_pos536(X,Y) get_csv_string((X),(Y),536) +#define get_csv_v_str_pos536(X,Y) get_csv_string((X),(Y),536) +#define get_csv_bool_pos536(X,Y) get_csv_bool((X),(Y),536) +#define get_csv_int_pos536(X,Y) get_csv_int((X),(Y),536) +#define get_csv_llong_pos536(X,Y) get_csv_llong((X),(Y),536) +#define get_csv_float_pos536(X,Y) get_csv_float((X),(Y),536) +#define get_csv_uint_pos537(X,Y) get_csv_uint((X),(Y),537) +#define get_csv_ullong_pos537(X,Y) get_csv_ullong((X),(Y),537) +#define get_csv_ip_pos537(X,Y) get_csv_ip((X),(Y),537) +#define get_csv_ipv6_pos537(X,Y) get_csv_ipv6((X),(Y),537) +#define get_csv_string_pos537(X,Y) get_csv_string((X),(Y),537) +#define get_csv_v_str_pos537(X,Y) get_csv_string((X),(Y),537) +#define get_csv_bool_pos537(X,Y) get_csv_bool((X),(Y),537) +#define get_csv_int_pos537(X,Y) get_csv_int((X),(Y),537) +#define get_csv_llong_pos537(X,Y) get_csv_llong((X),(Y),537) +#define get_csv_float_pos537(X,Y) get_csv_float((X),(Y),537) +#define get_csv_uint_pos538(X,Y) get_csv_uint((X),(Y),538) +#define get_csv_ullong_pos538(X,Y) get_csv_ullong((X),(Y),538) +#define get_csv_ip_pos538(X,Y) get_csv_ip((X),(Y),538) +#define get_csv_ipv6_pos538(X,Y) get_csv_ipv6((X),(Y),538) +#define get_csv_string_pos538(X,Y) get_csv_string((X),(Y),538) +#define get_csv_v_str_pos538(X,Y) get_csv_string((X),(Y),538) +#define get_csv_bool_pos538(X,Y) get_csv_bool((X),(Y),538) +#define get_csv_int_pos538(X,Y) get_csv_int((X),(Y),538) +#define get_csv_llong_pos538(X,Y) get_csv_llong((X),(Y),538) +#define get_csv_float_pos538(X,Y) get_csv_float((X),(Y),538) +#define get_csv_uint_pos539(X,Y) get_csv_uint((X),(Y),539) +#define get_csv_ullong_pos539(X,Y) get_csv_ullong((X),(Y),539) +#define get_csv_ip_pos539(X,Y) get_csv_ip((X),(Y),539) +#define get_csv_ipv6_pos539(X,Y) get_csv_ipv6((X),(Y),539) +#define get_csv_string_pos539(X,Y) get_csv_string((X),(Y),539) +#define get_csv_v_str_pos539(X,Y) get_csv_string((X),(Y),539) +#define get_csv_bool_pos539(X,Y) get_csv_bool((X),(Y),539) +#define get_csv_int_pos539(X,Y) get_csv_int((X),(Y),539) +#define get_csv_llong_pos539(X,Y) get_csv_llong((X),(Y),539) +#define get_csv_float_pos539(X,Y) get_csv_float((X),(Y),539) +#define get_csv_uint_pos540(X,Y) get_csv_uint((X),(Y),540) +#define get_csv_ullong_pos540(X,Y) get_csv_ullong((X),(Y),540) +#define get_csv_ip_pos540(X,Y) get_csv_ip((X),(Y),540) +#define get_csv_ipv6_pos540(X,Y) get_csv_ipv6((X),(Y),540) +#define get_csv_string_pos540(X,Y) get_csv_string((X),(Y),540) +#define get_csv_v_str_pos540(X,Y) get_csv_string((X),(Y),540) +#define get_csv_bool_pos540(X,Y) get_csv_bool((X),(Y),540) +#define get_csv_int_pos540(X,Y) get_csv_int((X),(Y),540) +#define get_csv_llong_pos540(X,Y) get_csv_llong((X),(Y),540) +#define get_csv_float_pos540(X,Y) get_csv_float((X),(Y),540) +#define get_csv_uint_pos541(X,Y) get_csv_uint((X),(Y),541) +#define get_csv_ullong_pos541(X,Y) get_csv_ullong((X),(Y),541) +#define get_csv_ip_pos541(X,Y) get_csv_ip((X),(Y),541) +#define get_csv_ipv6_pos541(X,Y) get_csv_ipv6((X),(Y),541) +#define get_csv_string_pos541(X,Y) get_csv_string((X),(Y),541) +#define get_csv_v_str_pos541(X,Y) get_csv_string((X),(Y),541) +#define get_csv_bool_pos541(X,Y) get_csv_bool((X),(Y),541) +#define get_csv_int_pos541(X,Y) get_csv_int((X),(Y),541) +#define get_csv_llong_pos541(X,Y) get_csv_llong((X),(Y),541) +#define get_csv_float_pos541(X,Y) get_csv_float((X),(Y),541) +#define get_csv_uint_pos542(X,Y) get_csv_uint((X),(Y),542) +#define get_csv_ullong_pos542(X,Y) get_csv_ullong((X),(Y),542) +#define get_csv_ip_pos542(X,Y) get_csv_ip((X),(Y),542) +#define get_csv_ipv6_pos542(X,Y) get_csv_ipv6((X),(Y),542) +#define get_csv_string_pos542(X,Y) get_csv_string((X),(Y),542) +#define get_csv_v_str_pos542(X,Y) get_csv_string((X),(Y),542) +#define get_csv_bool_pos542(X,Y) get_csv_bool((X),(Y),542) +#define get_csv_int_pos542(X,Y) get_csv_int((X),(Y),542) +#define get_csv_llong_pos542(X,Y) get_csv_llong((X),(Y),542) +#define get_csv_float_pos542(X,Y) get_csv_float((X),(Y),542) +#define get_csv_uint_pos543(X,Y) get_csv_uint((X),(Y),543) +#define get_csv_ullong_pos543(X,Y) get_csv_ullong((X),(Y),543) +#define get_csv_ip_pos543(X,Y) get_csv_ip((X),(Y),543) +#define get_csv_ipv6_pos543(X,Y) get_csv_ipv6((X),(Y),543) +#define get_csv_string_pos543(X,Y) get_csv_string((X),(Y),543) +#define get_csv_v_str_pos543(X,Y) get_csv_string((X),(Y),543) +#define get_csv_bool_pos543(X,Y) get_csv_bool((X),(Y),543) +#define get_csv_int_pos543(X,Y) get_csv_int((X),(Y),543) +#define get_csv_llong_pos543(X,Y) get_csv_llong((X),(Y),543) +#define get_csv_float_pos543(X,Y) get_csv_float((X),(Y),543) +#define get_csv_uint_pos544(X,Y) get_csv_uint((X),(Y),544) +#define get_csv_ullong_pos544(X,Y) get_csv_ullong((X),(Y),544) +#define get_csv_ip_pos544(X,Y) get_csv_ip((X),(Y),544) +#define get_csv_ipv6_pos544(X,Y) get_csv_ipv6((X),(Y),544) +#define get_csv_string_pos544(X,Y) get_csv_string((X),(Y),544) +#define get_csv_v_str_pos544(X,Y) get_csv_string((X),(Y),544) +#define get_csv_bool_pos544(X,Y) get_csv_bool((X),(Y),544) +#define get_csv_int_pos544(X,Y) get_csv_int((X),(Y),544) +#define get_csv_llong_pos544(X,Y) get_csv_llong((X),(Y),544) +#define get_csv_float_pos544(X,Y) get_csv_float((X),(Y),544) +#define get_csv_uint_pos545(X,Y) get_csv_uint((X),(Y),545) +#define get_csv_ullong_pos545(X,Y) get_csv_ullong((X),(Y),545) +#define get_csv_ip_pos545(X,Y) get_csv_ip((X),(Y),545) +#define get_csv_ipv6_pos545(X,Y) get_csv_ipv6((X),(Y),545) +#define get_csv_string_pos545(X,Y) get_csv_string((X),(Y),545) +#define get_csv_v_str_pos545(X,Y) get_csv_string((X),(Y),545) +#define get_csv_bool_pos545(X,Y) get_csv_bool((X),(Y),545) +#define get_csv_int_pos545(X,Y) get_csv_int((X),(Y),545) +#define get_csv_llong_pos545(X,Y) get_csv_llong((X),(Y),545) +#define get_csv_float_pos545(X,Y) get_csv_float((X),(Y),545) +#define get_csv_uint_pos546(X,Y) get_csv_uint((X),(Y),546) +#define get_csv_ullong_pos546(X,Y) get_csv_ullong((X),(Y),546) +#define get_csv_ip_pos546(X,Y) get_csv_ip((X),(Y),546) +#define get_csv_ipv6_pos546(X,Y) get_csv_ipv6((X),(Y),546) +#define get_csv_string_pos546(X,Y) get_csv_string((X),(Y),546) +#define get_csv_v_str_pos546(X,Y) get_csv_string((X),(Y),546) +#define get_csv_bool_pos546(X,Y) get_csv_bool((X),(Y),546) +#define get_csv_int_pos546(X,Y) get_csv_int((X),(Y),546) +#define get_csv_llong_pos546(X,Y) get_csv_llong((X),(Y),546) +#define get_csv_float_pos546(X,Y) get_csv_float((X),(Y),546) +#define get_csv_uint_pos547(X,Y) get_csv_uint((X),(Y),547) +#define get_csv_ullong_pos547(X,Y) get_csv_ullong((X),(Y),547) +#define get_csv_ip_pos547(X,Y) get_csv_ip((X),(Y),547) +#define get_csv_ipv6_pos547(X,Y) get_csv_ipv6((X),(Y),547) +#define get_csv_string_pos547(X,Y) get_csv_string((X),(Y),547) +#define get_csv_v_str_pos547(X,Y) get_csv_string((X),(Y),547) +#define get_csv_bool_pos547(X,Y) get_csv_bool((X),(Y),547) +#define get_csv_int_pos547(X,Y) get_csv_int((X),(Y),547) +#define get_csv_llong_pos547(X,Y) get_csv_llong((X),(Y),547) +#define get_csv_float_pos547(X,Y) get_csv_float((X),(Y),547) +#define get_csv_uint_pos548(X,Y) get_csv_uint((X),(Y),548) +#define get_csv_ullong_pos548(X,Y) get_csv_ullong((X),(Y),548) +#define get_csv_ip_pos548(X,Y) get_csv_ip((X),(Y),548) +#define get_csv_ipv6_pos548(X,Y) get_csv_ipv6((X),(Y),548) +#define get_csv_string_pos548(X,Y) get_csv_string((X),(Y),548) +#define get_csv_v_str_pos548(X,Y) get_csv_string((X),(Y),548) +#define get_csv_bool_pos548(X,Y) get_csv_bool((X),(Y),548) +#define get_csv_int_pos548(X,Y) get_csv_int((X),(Y),548) +#define get_csv_llong_pos548(X,Y) get_csv_llong((X),(Y),548) +#define get_csv_float_pos548(X,Y) get_csv_float((X),(Y),548) +#define get_csv_uint_pos549(X,Y) get_csv_uint((X),(Y),549) +#define get_csv_ullong_pos549(X,Y) get_csv_ullong((X),(Y),549) +#define get_csv_ip_pos549(X,Y) get_csv_ip((X),(Y),549) +#define get_csv_ipv6_pos549(X,Y) get_csv_ipv6((X),(Y),549) +#define get_csv_string_pos549(X,Y) get_csv_string((X),(Y),549) +#define get_csv_v_str_pos549(X,Y) get_csv_string((X),(Y),549) +#define get_csv_bool_pos549(X,Y) get_csv_bool((X),(Y),549) +#define get_csv_int_pos549(X,Y) get_csv_int((X),(Y),549) +#define get_csv_llong_pos549(X,Y) get_csv_llong((X),(Y),549) +#define get_csv_float_pos549(X,Y) get_csv_float((X),(Y),549) +#define get_csv_uint_pos550(X,Y) get_csv_uint((X),(Y),550) +#define get_csv_ullong_pos550(X,Y) get_csv_ullong((X),(Y),550) +#define get_csv_ip_pos550(X,Y) get_csv_ip((X),(Y),550) +#define get_csv_ipv6_pos550(X,Y) get_csv_ipv6((X),(Y),550) +#define get_csv_string_pos550(X,Y) get_csv_string((X),(Y),550) +#define get_csv_v_str_pos550(X,Y) get_csv_string((X),(Y),550) +#define get_csv_bool_pos550(X,Y) get_csv_bool((X),(Y),550) +#define get_csv_int_pos550(X,Y) get_csv_int((X),(Y),550) +#define get_csv_llong_pos550(X,Y) get_csv_llong((X),(Y),550) +#define get_csv_float_pos550(X,Y) get_csv_float((X),(Y),550) +#define get_csv_uint_pos551(X,Y) get_csv_uint((X),(Y),551) +#define get_csv_ullong_pos551(X,Y) get_csv_ullong((X),(Y),551) +#define get_csv_ip_pos551(X,Y) get_csv_ip((X),(Y),551) +#define get_csv_ipv6_pos551(X,Y) get_csv_ipv6((X),(Y),551) +#define get_csv_string_pos551(X,Y) get_csv_string((X),(Y),551) +#define get_csv_v_str_pos551(X,Y) get_csv_string((X),(Y),551) +#define get_csv_bool_pos551(X,Y) get_csv_bool((X),(Y),551) +#define get_csv_int_pos551(X,Y) get_csv_int((X),(Y),551) +#define get_csv_llong_pos551(X,Y) get_csv_llong((X),(Y),551) +#define get_csv_float_pos551(X,Y) get_csv_float((X),(Y),551) +#define get_csv_uint_pos552(X,Y) get_csv_uint((X),(Y),552) +#define get_csv_ullong_pos552(X,Y) get_csv_ullong((X),(Y),552) +#define get_csv_ip_pos552(X,Y) get_csv_ip((X),(Y),552) +#define get_csv_ipv6_pos552(X,Y) get_csv_ipv6((X),(Y),552) +#define get_csv_string_pos552(X,Y) get_csv_string((X),(Y),552) +#define get_csv_v_str_pos552(X,Y) get_csv_string((X),(Y),552) +#define get_csv_bool_pos552(X,Y) get_csv_bool((X),(Y),552) +#define get_csv_int_pos552(X,Y) get_csv_int((X),(Y),552) +#define get_csv_llong_pos552(X,Y) get_csv_llong((X),(Y),552) +#define get_csv_float_pos552(X,Y) get_csv_float((X),(Y),552) +#define get_csv_uint_pos553(X,Y) get_csv_uint((X),(Y),553) +#define get_csv_ullong_pos553(X,Y) get_csv_ullong((X),(Y),553) +#define get_csv_ip_pos553(X,Y) get_csv_ip((X),(Y),553) +#define get_csv_ipv6_pos553(X,Y) get_csv_ipv6((X),(Y),553) +#define get_csv_string_pos553(X,Y) get_csv_string((X),(Y),553) +#define get_csv_v_str_pos553(X,Y) get_csv_string((X),(Y),553) +#define get_csv_bool_pos553(X,Y) get_csv_bool((X),(Y),553) +#define get_csv_int_pos553(X,Y) get_csv_int((X),(Y),553) +#define get_csv_llong_pos553(X,Y) get_csv_llong((X),(Y),553) +#define get_csv_float_pos553(X,Y) get_csv_float((X),(Y),553) +#define get_csv_uint_pos554(X,Y) get_csv_uint((X),(Y),554) +#define get_csv_ullong_pos554(X,Y) get_csv_ullong((X),(Y),554) +#define get_csv_ip_pos554(X,Y) get_csv_ip((X),(Y),554) +#define get_csv_ipv6_pos554(X,Y) get_csv_ipv6((X),(Y),554) +#define get_csv_string_pos554(X,Y) get_csv_string((X),(Y),554) +#define get_csv_v_str_pos554(X,Y) get_csv_string((X),(Y),554) +#define get_csv_bool_pos554(X,Y) get_csv_bool((X),(Y),554) +#define get_csv_int_pos554(X,Y) get_csv_int((X),(Y),554) +#define get_csv_llong_pos554(X,Y) get_csv_llong((X),(Y),554) +#define get_csv_float_pos554(X,Y) get_csv_float((X),(Y),554) +#define get_csv_uint_pos555(X,Y) get_csv_uint((X),(Y),555) +#define get_csv_ullong_pos555(X,Y) get_csv_ullong((X),(Y),555) +#define get_csv_ip_pos555(X,Y) get_csv_ip((X),(Y),555) +#define get_csv_ipv6_pos555(X,Y) get_csv_ipv6((X),(Y),555) +#define get_csv_string_pos555(X,Y) get_csv_string((X),(Y),555) +#define get_csv_v_str_pos555(X,Y) get_csv_string((X),(Y),555) +#define get_csv_bool_pos555(X,Y) get_csv_bool((X),(Y),555) +#define get_csv_int_pos555(X,Y) get_csv_int((X),(Y),555) +#define get_csv_llong_pos555(X,Y) get_csv_llong((X),(Y),555) +#define get_csv_float_pos555(X,Y) get_csv_float((X),(Y),555) +#define get_csv_uint_pos556(X,Y) get_csv_uint((X),(Y),556) +#define get_csv_ullong_pos556(X,Y) get_csv_ullong((X),(Y),556) +#define get_csv_ip_pos556(X,Y) get_csv_ip((X),(Y),556) +#define get_csv_ipv6_pos556(X,Y) get_csv_ipv6((X),(Y),556) +#define get_csv_string_pos556(X,Y) get_csv_string((X),(Y),556) +#define get_csv_v_str_pos556(X,Y) get_csv_string((X),(Y),556) +#define get_csv_bool_pos556(X,Y) get_csv_bool((X),(Y),556) +#define get_csv_int_pos556(X,Y) get_csv_int((X),(Y),556) +#define get_csv_llong_pos556(X,Y) get_csv_llong((X),(Y),556) +#define get_csv_float_pos556(X,Y) get_csv_float((X),(Y),556) +#define get_csv_uint_pos557(X,Y) get_csv_uint((X),(Y),557) +#define get_csv_ullong_pos557(X,Y) get_csv_ullong((X),(Y),557) +#define get_csv_ip_pos557(X,Y) get_csv_ip((X),(Y),557) +#define get_csv_ipv6_pos557(X,Y) get_csv_ipv6((X),(Y),557) +#define get_csv_string_pos557(X,Y) get_csv_string((X),(Y),557) +#define get_csv_v_str_pos557(X,Y) get_csv_string((X),(Y),557) +#define get_csv_bool_pos557(X,Y) get_csv_bool((X),(Y),557) +#define get_csv_int_pos557(X,Y) get_csv_int((X),(Y),557) +#define get_csv_llong_pos557(X,Y) get_csv_llong((X),(Y),557) +#define get_csv_float_pos557(X,Y) get_csv_float((X),(Y),557) +#define get_csv_uint_pos558(X,Y) get_csv_uint((X),(Y),558) +#define get_csv_ullong_pos558(X,Y) get_csv_ullong((X),(Y),558) +#define get_csv_ip_pos558(X,Y) get_csv_ip((X),(Y),558) +#define get_csv_ipv6_pos558(X,Y) get_csv_ipv6((X),(Y),558) +#define get_csv_string_pos558(X,Y) get_csv_string((X),(Y),558) +#define get_csv_v_str_pos558(X,Y) get_csv_string((X),(Y),558) +#define get_csv_bool_pos558(X,Y) get_csv_bool((X),(Y),558) +#define get_csv_int_pos558(X,Y) get_csv_int((X),(Y),558) +#define get_csv_llong_pos558(X,Y) get_csv_llong((X),(Y),558) +#define get_csv_float_pos558(X,Y) get_csv_float((X),(Y),558) +#define get_csv_uint_pos559(X,Y) get_csv_uint((X),(Y),559) +#define get_csv_ullong_pos559(X,Y) get_csv_ullong((X),(Y),559) +#define get_csv_ip_pos559(X,Y) get_csv_ip((X),(Y),559) +#define get_csv_ipv6_pos559(X,Y) get_csv_ipv6((X),(Y),559) +#define get_csv_string_pos559(X,Y) get_csv_string((X),(Y),559) +#define get_csv_v_str_pos559(X,Y) get_csv_string((X),(Y),559) +#define get_csv_bool_pos559(X,Y) get_csv_bool((X),(Y),559) +#define get_csv_int_pos559(X,Y) get_csv_int((X),(Y),559) +#define get_csv_llong_pos559(X,Y) get_csv_llong((X),(Y),559) +#define get_csv_float_pos559(X,Y) get_csv_float((X),(Y),559) +#define get_csv_uint_pos560(X,Y) get_csv_uint((X),(Y),560) +#define get_csv_ullong_pos560(X,Y) get_csv_ullong((X),(Y),560) +#define get_csv_ip_pos560(X,Y) get_csv_ip((X),(Y),560) +#define get_csv_ipv6_pos560(X,Y) get_csv_ipv6((X),(Y),560) +#define get_csv_string_pos560(X,Y) get_csv_string((X),(Y),560) +#define get_csv_v_str_pos560(X,Y) get_csv_string((X),(Y),560) +#define get_csv_bool_pos560(X,Y) get_csv_bool((X),(Y),560) +#define get_csv_int_pos560(X,Y) get_csv_int((X),(Y),560) +#define get_csv_llong_pos560(X,Y) get_csv_llong((X),(Y),560) +#define get_csv_float_pos560(X,Y) get_csv_float((X),(Y),560) +#define get_csv_uint_pos561(X,Y) get_csv_uint((X),(Y),561) +#define get_csv_ullong_pos561(X,Y) get_csv_ullong((X),(Y),561) +#define get_csv_ip_pos561(X,Y) get_csv_ip((X),(Y),561) +#define get_csv_ipv6_pos561(X,Y) get_csv_ipv6((X),(Y),561) +#define get_csv_string_pos561(X,Y) get_csv_string((X),(Y),561) +#define get_csv_v_str_pos561(X,Y) get_csv_string((X),(Y),561) +#define get_csv_bool_pos561(X,Y) get_csv_bool((X),(Y),561) +#define get_csv_int_pos561(X,Y) get_csv_int((X),(Y),561) +#define get_csv_llong_pos561(X,Y) get_csv_llong((X),(Y),561) +#define get_csv_float_pos561(X,Y) get_csv_float((X),(Y),561) +#define get_csv_uint_pos562(X,Y) get_csv_uint((X),(Y),562) +#define get_csv_ullong_pos562(X,Y) get_csv_ullong((X),(Y),562) +#define get_csv_ip_pos562(X,Y) get_csv_ip((X),(Y),562) +#define get_csv_ipv6_pos562(X,Y) get_csv_ipv6((X),(Y),562) +#define get_csv_string_pos562(X,Y) get_csv_string((X),(Y),562) +#define get_csv_v_str_pos562(X,Y) get_csv_string((X),(Y),562) +#define get_csv_bool_pos562(X,Y) get_csv_bool((X),(Y),562) +#define get_csv_int_pos562(X,Y) get_csv_int((X),(Y),562) +#define get_csv_llong_pos562(X,Y) get_csv_llong((X),(Y),562) +#define get_csv_float_pos562(X,Y) get_csv_float((X),(Y),562) +#define get_csv_uint_pos563(X,Y) get_csv_uint((X),(Y),563) +#define get_csv_ullong_pos563(X,Y) get_csv_ullong((X),(Y),563) +#define get_csv_ip_pos563(X,Y) get_csv_ip((X),(Y),563) +#define get_csv_ipv6_pos563(X,Y) get_csv_ipv6((X),(Y),563) +#define get_csv_string_pos563(X,Y) get_csv_string((X),(Y),563) +#define get_csv_v_str_pos563(X,Y) get_csv_string((X),(Y),563) +#define get_csv_bool_pos563(X,Y) get_csv_bool((X),(Y),563) +#define get_csv_int_pos563(X,Y) get_csv_int((X),(Y),563) +#define get_csv_llong_pos563(X,Y) get_csv_llong((X),(Y),563) +#define get_csv_float_pos563(X,Y) get_csv_float((X),(Y),563) +#define get_csv_uint_pos564(X,Y) get_csv_uint((X),(Y),564) +#define get_csv_ullong_pos564(X,Y) get_csv_ullong((X),(Y),564) +#define get_csv_ip_pos564(X,Y) get_csv_ip((X),(Y),564) +#define get_csv_ipv6_pos564(X,Y) get_csv_ipv6((X),(Y),564) +#define get_csv_string_pos564(X,Y) get_csv_string((X),(Y),564) +#define get_csv_v_str_pos564(X,Y) get_csv_string((X),(Y),564) +#define get_csv_bool_pos564(X,Y) get_csv_bool((X),(Y),564) +#define get_csv_int_pos564(X,Y) get_csv_int((X),(Y),564) +#define get_csv_llong_pos564(X,Y) get_csv_llong((X),(Y),564) +#define get_csv_float_pos564(X,Y) get_csv_float((X),(Y),564) +#define get_csv_uint_pos565(X,Y) get_csv_uint((X),(Y),565) +#define get_csv_ullong_pos565(X,Y) get_csv_ullong((X),(Y),565) +#define get_csv_ip_pos565(X,Y) get_csv_ip((X),(Y),565) +#define get_csv_ipv6_pos565(X,Y) get_csv_ipv6((X),(Y),565) +#define get_csv_string_pos565(X,Y) get_csv_string((X),(Y),565) +#define get_csv_v_str_pos565(X,Y) get_csv_string((X),(Y),565) +#define get_csv_bool_pos565(X,Y) get_csv_bool((X),(Y),565) +#define get_csv_int_pos565(X,Y) get_csv_int((X),(Y),565) +#define get_csv_llong_pos565(X,Y) get_csv_llong((X),(Y),565) +#define get_csv_float_pos565(X,Y) get_csv_float((X),(Y),565) +#define get_csv_uint_pos566(X,Y) get_csv_uint((X),(Y),566) +#define get_csv_ullong_pos566(X,Y) get_csv_ullong((X),(Y),566) +#define get_csv_ip_pos566(X,Y) get_csv_ip((X),(Y),566) +#define get_csv_ipv6_pos566(X,Y) get_csv_ipv6((X),(Y),566) +#define get_csv_string_pos566(X,Y) get_csv_string((X),(Y),566) +#define get_csv_v_str_pos566(X,Y) get_csv_string((X),(Y),566) +#define get_csv_bool_pos566(X,Y) get_csv_bool((X),(Y),566) +#define get_csv_int_pos566(X,Y) get_csv_int((X),(Y),566) +#define get_csv_llong_pos566(X,Y) get_csv_llong((X),(Y),566) +#define get_csv_float_pos566(X,Y) get_csv_float((X),(Y),566) +#define get_csv_uint_pos567(X,Y) get_csv_uint((X),(Y),567) +#define get_csv_ullong_pos567(X,Y) get_csv_ullong((X),(Y),567) +#define get_csv_ip_pos567(X,Y) get_csv_ip((X),(Y),567) +#define get_csv_ipv6_pos567(X,Y) get_csv_ipv6((X),(Y),567) +#define get_csv_string_pos567(X,Y) get_csv_string((X),(Y),567) +#define get_csv_v_str_pos567(X,Y) get_csv_string((X),(Y),567) +#define get_csv_bool_pos567(X,Y) get_csv_bool((X),(Y),567) +#define get_csv_int_pos567(X,Y) get_csv_int((X),(Y),567) +#define get_csv_llong_pos567(X,Y) get_csv_llong((X),(Y),567) +#define get_csv_float_pos567(X,Y) get_csv_float((X),(Y),567) +#define get_csv_uint_pos568(X,Y) get_csv_uint((X),(Y),568) +#define get_csv_ullong_pos568(X,Y) get_csv_ullong((X),(Y),568) +#define get_csv_ip_pos568(X,Y) get_csv_ip((X),(Y),568) +#define get_csv_ipv6_pos568(X,Y) get_csv_ipv6((X),(Y),568) +#define get_csv_string_pos568(X,Y) get_csv_string((X),(Y),568) +#define get_csv_v_str_pos568(X,Y) get_csv_string((X),(Y),568) +#define get_csv_bool_pos568(X,Y) get_csv_bool((X),(Y),568) +#define get_csv_int_pos568(X,Y) get_csv_int((X),(Y),568) +#define get_csv_llong_pos568(X,Y) get_csv_llong((X),(Y),568) +#define get_csv_float_pos568(X,Y) get_csv_float((X),(Y),568) +#define get_csv_uint_pos569(X,Y) get_csv_uint((X),(Y),569) +#define get_csv_ullong_pos569(X,Y) get_csv_ullong((X),(Y),569) +#define get_csv_ip_pos569(X,Y) get_csv_ip((X),(Y),569) +#define get_csv_ipv6_pos569(X,Y) get_csv_ipv6((X),(Y),569) +#define get_csv_string_pos569(X,Y) get_csv_string((X),(Y),569) +#define get_csv_v_str_pos569(X,Y) get_csv_string((X),(Y),569) +#define get_csv_bool_pos569(X,Y) get_csv_bool((X),(Y),569) +#define get_csv_int_pos569(X,Y) get_csv_int((X),(Y),569) +#define get_csv_llong_pos569(X,Y) get_csv_llong((X),(Y),569) +#define get_csv_float_pos569(X,Y) get_csv_float((X),(Y),569) +#define get_csv_uint_pos570(X,Y) get_csv_uint((X),(Y),570) +#define get_csv_ullong_pos570(X,Y) get_csv_ullong((X),(Y),570) +#define get_csv_ip_pos570(X,Y) get_csv_ip((X),(Y),570) +#define get_csv_ipv6_pos570(X,Y) get_csv_ipv6((X),(Y),570) +#define get_csv_string_pos570(X,Y) get_csv_string((X),(Y),570) +#define get_csv_v_str_pos570(X,Y) get_csv_string((X),(Y),570) +#define get_csv_bool_pos570(X,Y) get_csv_bool((X),(Y),570) +#define get_csv_int_pos570(X,Y) get_csv_int((X),(Y),570) +#define get_csv_llong_pos570(X,Y) get_csv_llong((X),(Y),570) +#define get_csv_float_pos570(X,Y) get_csv_float((X),(Y),570) +#define get_csv_uint_pos571(X,Y) get_csv_uint((X),(Y),571) +#define get_csv_ullong_pos571(X,Y) get_csv_ullong((X),(Y),571) +#define get_csv_ip_pos571(X,Y) get_csv_ip((X),(Y),571) +#define get_csv_ipv6_pos571(X,Y) get_csv_ipv6((X),(Y),571) +#define get_csv_string_pos571(X,Y) get_csv_string((X),(Y),571) +#define get_csv_v_str_pos571(X,Y) get_csv_string((X),(Y),571) +#define get_csv_bool_pos571(X,Y) get_csv_bool((X),(Y),571) +#define get_csv_int_pos571(X,Y) get_csv_int((X),(Y),571) +#define get_csv_llong_pos571(X,Y) get_csv_llong((X),(Y),571) +#define get_csv_float_pos571(X,Y) get_csv_float((X),(Y),571) +#define get_csv_uint_pos572(X,Y) get_csv_uint((X),(Y),572) +#define get_csv_ullong_pos572(X,Y) get_csv_ullong((X),(Y),572) +#define get_csv_ip_pos572(X,Y) get_csv_ip((X),(Y),572) +#define get_csv_ipv6_pos572(X,Y) get_csv_ipv6((X),(Y),572) +#define get_csv_string_pos572(X,Y) get_csv_string((X),(Y),572) +#define get_csv_v_str_pos572(X,Y) get_csv_string((X),(Y),572) +#define get_csv_bool_pos572(X,Y) get_csv_bool((X),(Y),572) +#define get_csv_int_pos572(X,Y) get_csv_int((X),(Y),572) +#define get_csv_llong_pos572(X,Y) get_csv_llong((X),(Y),572) +#define get_csv_float_pos572(X,Y) get_csv_float((X),(Y),572) +#define get_csv_uint_pos573(X,Y) get_csv_uint((X),(Y),573) +#define get_csv_ullong_pos573(X,Y) get_csv_ullong((X),(Y),573) +#define get_csv_ip_pos573(X,Y) get_csv_ip((X),(Y),573) +#define get_csv_ipv6_pos573(X,Y) get_csv_ipv6((X),(Y),573) +#define get_csv_string_pos573(X,Y) get_csv_string((X),(Y),573) +#define get_csv_v_str_pos573(X,Y) get_csv_string((X),(Y),573) +#define get_csv_bool_pos573(X,Y) get_csv_bool((X),(Y),573) +#define get_csv_int_pos573(X,Y) get_csv_int((X),(Y),573) +#define get_csv_llong_pos573(X,Y) get_csv_llong((X),(Y),573) +#define get_csv_float_pos573(X,Y) get_csv_float((X),(Y),573) +#define get_csv_uint_pos574(X,Y) get_csv_uint((X),(Y),574) +#define get_csv_ullong_pos574(X,Y) get_csv_ullong((X),(Y),574) +#define get_csv_ip_pos574(X,Y) get_csv_ip((X),(Y),574) +#define get_csv_ipv6_pos574(X,Y) get_csv_ipv6((X),(Y),574) +#define get_csv_string_pos574(X,Y) get_csv_string((X),(Y),574) +#define get_csv_v_str_pos574(X,Y) get_csv_string((X),(Y),574) +#define get_csv_bool_pos574(X,Y) get_csv_bool((X),(Y),574) +#define get_csv_int_pos574(X,Y) get_csv_int((X),(Y),574) +#define get_csv_llong_pos574(X,Y) get_csv_llong((X),(Y),574) +#define get_csv_float_pos574(X,Y) get_csv_float((X),(Y),574) +#define get_csv_uint_pos575(X,Y) get_csv_uint((X),(Y),575) +#define get_csv_ullong_pos575(X,Y) get_csv_ullong((X),(Y),575) +#define get_csv_ip_pos575(X,Y) get_csv_ip((X),(Y),575) +#define get_csv_ipv6_pos575(X,Y) get_csv_ipv6((X),(Y),575) +#define get_csv_string_pos575(X,Y) get_csv_string((X),(Y),575) +#define get_csv_v_str_pos575(X,Y) get_csv_string((X),(Y),575) +#define get_csv_bool_pos575(X,Y) get_csv_bool((X),(Y),575) +#define get_csv_int_pos575(X,Y) get_csv_int((X),(Y),575) +#define get_csv_llong_pos575(X,Y) get_csv_llong((X),(Y),575) +#define get_csv_float_pos575(X,Y) get_csv_float((X),(Y),575) +#define get_csv_uint_pos576(X,Y) get_csv_uint((X),(Y),576) +#define get_csv_ullong_pos576(X,Y) get_csv_ullong((X),(Y),576) +#define get_csv_ip_pos576(X,Y) get_csv_ip((X),(Y),576) +#define get_csv_ipv6_pos576(X,Y) get_csv_ipv6((X),(Y),576) +#define get_csv_string_pos576(X,Y) get_csv_string((X),(Y),576) +#define get_csv_v_str_pos576(X,Y) get_csv_string((X),(Y),576) +#define get_csv_bool_pos576(X,Y) get_csv_bool((X),(Y),576) +#define get_csv_int_pos576(X,Y) get_csv_int((X),(Y),576) +#define get_csv_llong_pos576(X,Y) get_csv_llong((X),(Y),576) +#define get_csv_float_pos576(X,Y) get_csv_float((X),(Y),576) +#define get_csv_uint_pos577(X,Y) get_csv_uint((X),(Y),577) +#define get_csv_ullong_pos577(X,Y) get_csv_ullong((X),(Y),577) +#define get_csv_ip_pos577(X,Y) get_csv_ip((X),(Y),577) +#define get_csv_ipv6_pos577(X,Y) get_csv_ipv6((X),(Y),577) +#define get_csv_string_pos577(X,Y) get_csv_string((X),(Y),577) +#define get_csv_v_str_pos577(X,Y) get_csv_string((X),(Y),577) +#define get_csv_bool_pos577(X,Y) get_csv_bool((X),(Y),577) +#define get_csv_int_pos577(X,Y) get_csv_int((X),(Y),577) +#define get_csv_llong_pos577(X,Y) get_csv_llong((X),(Y),577) +#define get_csv_float_pos577(X,Y) get_csv_float((X),(Y),577) +#define get_csv_uint_pos578(X,Y) get_csv_uint((X),(Y),578) +#define get_csv_ullong_pos578(X,Y) get_csv_ullong((X),(Y),578) +#define get_csv_ip_pos578(X,Y) get_csv_ip((X),(Y),578) +#define get_csv_ipv6_pos578(X,Y) get_csv_ipv6((X),(Y),578) +#define get_csv_string_pos578(X,Y) get_csv_string((X),(Y),578) +#define get_csv_v_str_pos578(X,Y) get_csv_string((X),(Y),578) +#define get_csv_bool_pos578(X,Y) get_csv_bool((X),(Y),578) +#define get_csv_int_pos578(X,Y) get_csv_int((X),(Y),578) +#define get_csv_llong_pos578(X,Y) get_csv_llong((X),(Y),578) +#define get_csv_float_pos578(X,Y) get_csv_float((X),(Y),578) +#define get_csv_uint_pos579(X,Y) get_csv_uint((X),(Y),579) +#define get_csv_ullong_pos579(X,Y) get_csv_ullong((X),(Y),579) +#define get_csv_ip_pos579(X,Y) get_csv_ip((X),(Y),579) +#define get_csv_ipv6_pos579(X,Y) get_csv_ipv6((X),(Y),579) +#define get_csv_string_pos579(X,Y) get_csv_string((X),(Y),579) +#define get_csv_v_str_pos579(X,Y) get_csv_string((X),(Y),579) +#define get_csv_bool_pos579(X,Y) get_csv_bool((X),(Y),579) +#define get_csv_int_pos579(X,Y) get_csv_int((X),(Y),579) +#define get_csv_llong_pos579(X,Y) get_csv_llong((X),(Y),579) +#define get_csv_float_pos579(X,Y) get_csv_float((X),(Y),579) +#define get_csv_uint_pos580(X,Y) get_csv_uint((X),(Y),580) +#define get_csv_ullong_pos580(X,Y) get_csv_ullong((X),(Y),580) +#define get_csv_ip_pos580(X,Y) get_csv_ip((X),(Y),580) +#define get_csv_ipv6_pos580(X,Y) get_csv_ipv6((X),(Y),580) +#define get_csv_string_pos580(X,Y) get_csv_string((X),(Y),580) +#define get_csv_v_str_pos580(X,Y) get_csv_string((X),(Y),580) +#define get_csv_bool_pos580(X,Y) get_csv_bool((X),(Y),580) +#define get_csv_int_pos580(X,Y) get_csv_int((X),(Y),580) +#define get_csv_llong_pos580(X,Y) get_csv_llong((X),(Y),580) +#define get_csv_float_pos580(X,Y) get_csv_float((X),(Y),580) +#define get_csv_uint_pos581(X,Y) get_csv_uint((X),(Y),581) +#define get_csv_ullong_pos581(X,Y) get_csv_ullong((X),(Y),581) +#define get_csv_ip_pos581(X,Y) get_csv_ip((X),(Y),581) +#define get_csv_ipv6_pos581(X,Y) get_csv_ipv6((X),(Y),581) +#define get_csv_string_pos581(X,Y) get_csv_string((X),(Y),581) +#define get_csv_v_str_pos581(X,Y) get_csv_string((X),(Y),581) +#define get_csv_bool_pos581(X,Y) get_csv_bool((X),(Y),581) +#define get_csv_int_pos581(X,Y) get_csv_int((X),(Y),581) +#define get_csv_llong_pos581(X,Y) get_csv_llong((X),(Y),581) +#define get_csv_float_pos581(X,Y) get_csv_float((X),(Y),581) +#define get_csv_uint_pos582(X,Y) get_csv_uint((X),(Y),582) +#define get_csv_ullong_pos582(X,Y) get_csv_ullong((X),(Y),582) +#define get_csv_ip_pos582(X,Y) get_csv_ip((X),(Y),582) +#define get_csv_ipv6_pos582(X,Y) get_csv_ipv6((X),(Y),582) +#define get_csv_string_pos582(X,Y) get_csv_string((X),(Y),582) +#define get_csv_v_str_pos582(X,Y) get_csv_string((X),(Y),582) +#define get_csv_bool_pos582(X,Y) get_csv_bool((X),(Y),582) +#define get_csv_int_pos582(X,Y) get_csv_int((X),(Y),582) +#define get_csv_llong_pos582(X,Y) get_csv_llong((X),(Y),582) +#define get_csv_float_pos582(X,Y) get_csv_float((X),(Y),582) +#define get_csv_uint_pos583(X,Y) get_csv_uint((X),(Y),583) +#define get_csv_ullong_pos583(X,Y) get_csv_ullong((X),(Y),583) +#define get_csv_ip_pos583(X,Y) get_csv_ip((X),(Y),583) +#define get_csv_ipv6_pos583(X,Y) get_csv_ipv6((X),(Y),583) +#define get_csv_string_pos583(X,Y) get_csv_string((X),(Y),583) +#define get_csv_v_str_pos583(X,Y) get_csv_string((X),(Y),583) +#define get_csv_bool_pos583(X,Y) get_csv_bool((X),(Y),583) +#define get_csv_int_pos583(X,Y) get_csv_int((X),(Y),583) +#define get_csv_llong_pos583(X,Y) get_csv_llong((X),(Y),583) +#define get_csv_float_pos583(X,Y) get_csv_float((X),(Y),583) +#define get_csv_uint_pos584(X,Y) get_csv_uint((X),(Y),584) +#define get_csv_ullong_pos584(X,Y) get_csv_ullong((X),(Y),584) +#define get_csv_ip_pos584(X,Y) get_csv_ip((X),(Y),584) +#define get_csv_ipv6_pos584(X,Y) get_csv_ipv6((X),(Y),584) +#define get_csv_string_pos584(X,Y) get_csv_string((X),(Y),584) +#define get_csv_v_str_pos584(X,Y) get_csv_string((X),(Y),584) +#define get_csv_bool_pos584(X,Y) get_csv_bool((X),(Y),584) +#define get_csv_int_pos584(X,Y) get_csv_int((X),(Y),584) +#define get_csv_llong_pos584(X,Y) get_csv_llong((X),(Y),584) +#define get_csv_float_pos584(X,Y) get_csv_float((X),(Y),584) +#define get_csv_uint_pos585(X,Y) get_csv_uint((X),(Y),585) +#define get_csv_ullong_pos585(X,Y) get_csv_ullong((X),(Y),585) +#define get_csv_ip_pos585(X,Y) get_csv_ip((X),(Y),585) +#define get_csv_ipv6_pos585(X,Y) get_csv_ipv6((X),(Y),585) +#define get_csv_string_pos585(X,Y) get_csv_string((X),(Y),585) +#define get_csv_v_str_pos585(X,Y) get_csv_string((X),(Y),585) +#define get_csv_bool_pos585(X,Y) get_csv_bool((X),(Y),585) +#define get_csv_int_pos585(X,Y) get_csv_int((X),(Y),585) +#define get_csv_llong_pos585(X,Y) get_csv_llong((X),(Y),585) +#define get_csv_float_pos585(X,Y) get_csv_float((X),(Y),585) +#define get_csv_uint_pos586(X,Y) get_csv_uint((X),(Y),586) +#define get_csv_ullong_pos586(X,Y) get_csv_ullong((X),(Y),586) +#define get_csv_ip_pos586(X,Y) get_csv_ip((X),(Y),586) +#define get_csv_ipv6_pos586(X,Y) get_csv_ipv6((X),(Y),586) +#define get_csv_string_pos586(X,Y) get_csv_string((X),(Y),586) +#define get_csv_v_str_pos586(X,Y) get_csv_string((X),(Y),586) +#define get_csv_bool_pos586(X,Y) get_csv_bool((X),(Y),586) +#define get_csv_int_pos586(X,Y) get_csv_int((X),(Y),586) +#define get_csv_llong_pos586(X,Y) get_csv_llong((X),(Y),586) +#define get_csv_float_pos586(X,Y) get_csv_float((X),(Y),586) +#define get_csv_uint_pos587(X,Y) get_csv_uint((X),(Y),587) +#define get_csv_ullong_pos587(X,Y) get_csv_ullong((X),(Y),587) +#define get_csv_ip_pos587(X,Y) get_csv_ip((X),(Y),587) +#define get_csv_ipv6_pos587(X,Y) get_csv_ipv6((X),(Y),587) +#define get_csv_string_pos587(X,Y) get_csv_string((X),(Y),587) +#define get_csv_v_str_pos587(X,Y) get_csv_string((X),(Y),587) +#define get_csv_bool_pos587(X,Y) get_csv_bool((X),(Y),587) +#define get_csv_int_pos587(X,Y) get_csv_int((X),(Y),587) +#define get_csv_llong_pos587(X,Y) get_csv_llong((X),(Y),587) +#define get_csv_float_pos587(X,Y) get_csv_float((X),(Y),587) +#define get_csv_uint_pos588(X,Y) get_csv_uint((X),(Y),588) +#define get_csv_ullong_pos588(X,Y) get_csv_ullong((X),(Y),588) +#define get_csv_ip_pos588(X,Y) get_csv_ip((X),(Y),588) +#define get_csv_ipv6_pos588(X,Y) get_csv_ipv6((X),(Y),588) +#define get_csv_string_pos588(X,Y) get_csv_string((X),(Y),588) +#define get_csv_v_str_pos588(X,Y) get_csv_string((X),(Y),588) +#define get_csv_bool_pos588(X,Y) get_csv_bool((X),(Y),588) +#define get_csv_int_pos588(X,Y) get_csv_int((X),(Y),588) +#define get_csv_llong_pos588(X,Y) get_csv_llong((X),(Y),588) +#define get_csv_float_pos588(X,Y) get_csv_float((X),(Y),588) +#define get_csv_uint_pos589(X,Y) get_csv_uint((X),(Y),589) +#define get_csv_ullong_pos589(X,Y) get_csv_ullong((X),(Y),589) +#define get_csv_ip_pos589(X,Y) get_csv_ip((X),(Y),589) +#define get_csv_ipv6_pos589(X,Y) get_csv_ipv6((X),(Y),589) +#define get_csv_string_pos589(X,Y) get_csv_string((X),(Y),589) +#define get_csv_v_str_pos589(X,Y) get_csv_string((X),(Y),589) +#define get_csv_bool_pos589(X,Y) get_csv_bool((X),(Y),589) +#define get_csv_int_pos589(X,Y) get_csv_int((X),(Y),589) +#define get_csv_llong_pos589(X,Y) get_csv_llong((X),(Y),589) +#define get_csv_float_pos589(X,Y) get_csv_float((X),(Y),589) +#define get_csv_uint_pos590(X,Y) get_csv_uint((X),(Y),590) +#define get_csv_ullong_pos590(X,Y) get_csv_ullong((X),(Y),590) +#define get_csv_ip_pos590(X,Y) get_csv_ip((X),(Y),590) +#define get_csv_ipv6_pos590(X,Y) get_csv_ipv6((X),(Y),590) +#define get_csv_string_pos590(X,Y) get_csv_string((X),(Y),590) +#define get_csv_v_str_pos590(X,Y) get_csv_string((X),(Y),590) +#define get_csv_bool_pos590(X,Y) get_csv_bool((X),(Y),590) +#define get_csv_int_pos590(X,Y) get_csv_int((X),(Y),590) +#define get_csv_llong_pos590(X,Y) get_csv_llong((X),(Y),590) +#define get_csv_float_pos590(X,Y) get_csv_float((X),(Y),590) +#define get_csv_uint_pos591(X,Y) get_csv_uint((X),(Y),591) +#define get_csv_ullong_pos591(X,Y) get_csv_ullong((X),(Y),591) +#define get_csv_ip_pos591(X,Y) get_csv_ip((X),(Y),591) +#define get_csv_ipv6_pos591(X,Y) get_csv_ipv6((X),(Y),591) +#define get_csv_string_pos591(X,Y) get_csv_string((X),(Y),591) +#define get_csv_v_str_pos591(X,Y) get_csv_string((X),(Y),591) +#define get_csv_bool_pos591(X,Y) get_csv_bool((X),(Y),591) +#define get_csv_int_pos591(X,Y) get_csv_int((X),(Y),591) +#define get_csv_llong_pos591(X,Y) get_csv_llong((X),(Y),591) +#define get_csv_float_pos591(X,Y) get_csv_float((X),(Y),591) +#define get_csv_uint_pos592(X,Y) get_csv_uint((X),(Y),592) +#define get_csv_ullong_pos592(X,Y) get_csv_ullong((X),(Y),592) +#define get_csv_ip_pos592(X,Y) get_csv_ip((X),(Y),592) +#define get_csv_ipv6_pos592(X,Y) get_csv_ipv6((X),(Y),592) +#define get_csv_string_pos592(X,Y) get_csv_string((X),(Y),592) +#define get_csv_v_str_pos592(X,Y) get_csv_string((X),(Y),592) +#define get_csv_bool_pos592(X,Y) get_csv_bool((X),(Y),592) +#define get_csv_int_pos592(X,Y) get_csv_int((X),(Y),592) +#define get_csv_llong_pos592(X,Y) get_csv_llong((X),(Y),592) +#define get_csv_float_pos592(X,Y) get_csv_float((X),(Y),592) +#define get_csv_uint_pos593(X,Y) get_csv_uint((X),(Y),593) +#define get_csv_ullong_pos593(X,Y) get_csv_ullong((X),(Y),593) +#define get_csv_ip_pos593(X,Y) get_csv_ip((X),(Y),593) +#define get_csv_ipv6_pos593(X,Y) get_csv_ipv6((X),(Y),593) +#define get_csv_string_pos593(X,Y) get_csv_string((X),(Y),593) +#define get_csv_v_str_pos593(X,Y) get_csv_string((X),(Y),593) +#define get_csv_bool_pos593(X,Y) get_csv_bool((X),(Y),593) +#define get_csv_int_pos593(X,Y) get_csv_int((X),(Y),593) +#define get_csv_llong_pos593(X,Y) get_csv_llong((X),(Y),593) +#define get_csv_float_pos593(X,Y) get_csv_float((X),(Y),593) +#define get_csv_uint_pos594(X,Y) get_csv_uint((X),(Y),594) +#define get_csv_ullong_pos594(X,Y) get_csv_ullong((X),(Y),594) +#define get_csv_ip_pos594(X,Y) get_csv_ip((X),(Y),594) +#define get_csv_ipv6_pos594(X,Y) get_csv_ipv6((X),(Y),594) +#define get_csv_string_pos594(X,Y) get_csv_string((X),(Y),594) +#define get_csv_v_str_pos594(X,Y) get_csv_string((X),(Y),594) +#define get_csv_bool_pos594(X,Y) get_csv_bool((X),(Y),594) +#define get_csv_int_pos594(X,Y) get_csv_int((X),(Y),594) +#define get_csv_llong_pos594(X,Y) get_csv_llong((X),(Y),594) +#define get_csv_float_pos594(X,Y) get_csv_float((X),(Y),594) +#define get_csv_uint_pos595(X,Y) get_csv_uint((X),(Y),595) +#define get_csv_ullong_pos595(X,Y) get_csv_ullong((X),(Y),595) +#define get_csv_ip_pos595(X,Y) get_csv_ip((X),(Y),595) +#define get_csv_ipv6_pos595(X,Y) get_csv_ipv6((X),(Y),595) +#define get_csv_string_pos595(X,Y) get_csv_string((X),(Y),595) +#define get_csv_v_str_pos595(X,Y) get_csv_string((X),(Y),595) +#define get_csv_bool_pos595(X,Y) get_csv_bool((X),(Y),595) +#define get_csv_int_pos595(X,Y) get_csv_int((X),(Y),595) +#define get_csv_llong_pos595(X,Y) get_csv_llong((X),(Y),595) +#define get_csv_float_pos595(X,Y) get_csv_float((X),(Y),595) +#define get_csv_uint_pos596(X,Y) get_csv_uint((X),(Y),596) +#define get_csv_ullong_pos596(X,Y) get_csv_ullong((X),(Y),596) +#define get_csv_ip_pos596(X,Y) get_csv_ip((X),(Y),596) +#define get_csv_ipv6_pos596(X,Y) get_csv_ipv6((X),(Y),596) +#define get_csv_string_pos596(X,Y) get_csv_string((X),(Y),596) +#define get_csv_v_str_pos596(X,Y) get_csv_string((X),(Y),596) +#define get_csv_bool_pos596(X,Y) get_csv_bool((X),(Y),596) +#define get_csv_int_pos596(X,Y) get_csv_int((X),(Y),596) +#define get_csv_llong_pos596(X,Y) get_csv_llong((X),(Y),596) +#define get_csv_float_pos596(X,Y) get_csv_float((X),(Y),596) +#define get_csv_uint_pos597(X,Y) get_csv_uint((X),(Y),597) +#define get_csv_ullong_pos597(X,Y) get_csv_ullong((X),(Y),597) +#define get_csv_ip_pos597(X,Y) get_csv_ip((X),(Y),597) +#define get_csv_ipv6_pos597(X,Y) get_csv_ipv6((X),(Y),597) +#define get_csv_string_pos597(X,Y) get_csv_string((X),(Y),597) +#define get_csv_v_str_pos597(X,Y) get_csv_string((X),(Y),597) +#define get_csv_bool_pos597(X,Y) get_csv_bool((X),(Y),597) +#define get_csv_int_pos597(X,Y) get_csv_int((X),(Y),597) +#define get_csv_llong_pos597(X,Y) get_csv_llong((X),(Y),597) +#define get_csv_float_pos597(X,Y) get_csv_float((X),(Y),597) +#define get_csv_uint_pos598(X,Y) get_csv_uint((X),(Y),598) +#define get_csv_ullong_pos598(X,Y) get_csv_ullong((X),(Y),598) +#define get_csv_ip_pos598(X,Y) get_csv_ip((X),(Y),598) +#define get_csv_ipv6_pos598(X,Y) get_csv_ipv6((X),(Y),598) +#define get_csv_string_pos598(X,Y) get_csv_string((X),(Y),598) +#define get_csv_v_str_pos598(X,Y) get_csv_string((X),(Y),598) +#define get_csv_bool_pos598(X,Y) get_csv_bool((X),(Y),598) +#define get_csv_int_pos598(X,Y) get_csv_int((X),(Y),598) +#define get_csv_llong_pos598(X,Y) get_csv_llong((X),(Y),598) +#define get_csv_float_pos598(X,Y) get_csv_float((X),(Y),598) +#define get_csv_uint_pos599(X,Y) get_csv_uint((X),(Y),599) +#define get_csv_ullong_pos599(X,Y) get_csv_ullong((X),(Y),599) +#define get_csv_ip_pos599(X,Y) get_csv_ip((X),(Y),599) +#define get_csv_ipv6_pos599(X,Y) get_csv_ipv6((X),(Y),599) +#define get_csv_string_pos599(X,Y) get_csv_string((X),(Y),599) +#define get_csv_v_str_pos599(X,Y) get_csv_string((X),(Y),599) +#define get_csv_bool_pos599(X,Y) get_csv_bool((X),(Y),599) +#define get_csv_int_pos599(X,Y) get_csv_int((X),(Y),599) +#define get_csv_llong_pos599(X,Y) get_csv_llong((X),(Y),599) +#define get_csv_float_pos599(X,Y) get_csv_float((X),(Y),599) +#define get_csv_uint_pos600(X,Y) get_csv_uint((X),(Y),600) +#define get_csv_ullong_pos600(X,Y) get_csv_ullong((X),(Y),600) +#define get_csv_ip_pos600(X,Y) get_csv_ip((X),(Y),600) +#define get_csv_ipv6_pos600(X,Y) get_csv_ipv6((X),(Y),600) +#define get_csv_string_pos600(X,Y) get_csv_string((X),(Y),600) +#define get_csv_v_str_pos600(X,Y) get_csv_string((X),(Y),600) +#define get_csv_bool_pos600(X,Y) get_csv_bool((X),(Y),600) +#define get_csv_int_pos600(X,Y) get_csv_int((X),(Y),600) +#define get_csv_llong_pos600(X,Y) get_csv_llong((X),(Y),600) +#define get_csv_float_pos600(X,Y) get_csv_float((X),(Y),600) +#define get_csv_uint_pos601(X,Y) get_csv_uint((X),(Y),601) +#define get_csv_ullong_pos601(X,Y) get_csv_ullong((X),(Y),601) +#define get_csv_ip_pos601(X,Y) get_csv_ip((X),(Y),601) +#define get_csv_ipv6_pos601(X,Y) get_csv_ipv6((X),(Y),601) +#define get_csv_string_pos601(X,Y) get_csv_string((X),(Y),601) +#define get_csv_v_str_pos601(X,Y) get_csv_string((X),(Y),601) +#define get_csv_bool_pos601(X,Y) get_csv_bool((X),(Y),601) +#define get_csv_int_pos601(X,Y) get_csv_int((X),(Y),601) +#define get_csv_llong_pos601(X,Y) get_csv_llong((X),(Y),601) +#define get_csv_float_pos601(X,Y) get_csv_float((X),(Y),601) +#define get_csv_uint_pos602(X,Y) get_csv_uint((X),(Y),602) +#define get_csv_ullong_pos602(X,Y) get_csv_ullong((X),(Y),602) +#define get_csv_ip_pos602(X,Y) get_csv_ip((X),(Y),602) +#define get_csv_ipv6_pos602(X,Y) get_csv_ipv6((X),(Y),602) +#define get_csv_string_pos602(X,Y) get_csv_string((X),(Y),602) +#define get_csv_v_str_pos602(X,Y) get_csv_string((X),(Y),602) +#define get_csv_bool_pos602(X,Y) get_csv_bool((X),(Y),602) +#define get_csv_int_pos602(X,Y) get_csv_int((X),(Y),602) +#define get_csv_llong_pos602(X,Y) get_csv_llong((X),(Y),602) +#define get_csv_float_pos602(X,Y) get_csv_float((X),(Y),602) +#define get_csv_uint_pos603(X,Y) get_csv_uint((X),(Y),603) +#define get_csv_ullong_pos603(X,Y) get_csv_ullong((X),(Y),603) +#define get_csv_ip_pos603(X,Y) get_csv_ip((X),(Y),603) +#define get_csv_ipv6_pos603(X,Y) get_csv_ipv6((X),(Y),603) +#define get_csv_string_pos603(X,Y) get_csv_string((X),(Y),603) +#define get_csv_v_str_pos603(X,Y) get_csv_string((X),(Y),603) +#define get_csv_bool_pos603(X,Y) get_csv_bool((X),(Y),603) +#define get_csv_int_pos603(X,Y) get_csv_int((X),(Y),603) +#define get_csv_llong_pos603(X,Y) get_csv_llong((X),(Y),603) +#define get_csv_float_pos603(X,Y) get_csv_float((X),(Y),603) +#define get_csv_uint_pos604(X,Y) get_csv_uint((X),(Y),604) +#define get_csv_ullong_pos604(X,Y) get_csv_ullong((X),(Y),604) +#define get_csv_ip_pos604(X,Y) get_csv_ip((X),(Y),604) +#define get_csv_ipv6_pos604(X,Y) get_csv_ipv6((X),(Y),604) +#define get_csv_string_pos604(X,Y) get_csv_string((X),(Y),604) +#define get_csv_v_str_pos604(X,Y) get_csv_string((X),(Y),604) +#define get_csv_bool_pos604(X,Y) get_csv_bool((X),(Y),604) +#define get_csv_int_pos604(X,Y) get_csv_int((X),(Y),604) +#define get_csv_llong_pos604(X,Y) get_csv_llong((X),(Y),604) +#define get_csv_float_pos604(X,Y) get_csv_float((X),(Y),604) +#define get_csv_uint_pos605(X,Y) get_csv_uint((X),(Y),605) +#define get_csv_ullong_pos605(X,Y) get_csv_ullong((X),(Y),605) +#define get_csv_ip_pos605(X,Y) get_csv_ip((X),(Y),605) +#define get_csv_ipv6_pos605(X,Y) get_csv_ipv6((X),(Y),605) +#define get_csv_string_pos605(X,Y) get_csv_string((X),(Y),605) +#define get_csv_v_str_pos605(X,Y) get_csv_string((X),(Y),605) +#define get_csv_bool_pos605(X,Y) get_csv_bool((X),(Y),605) +#define get_csv_int_pos605(X,Y) get_csv_int((X),(Y),605) +#define get_csv_llong_pos605(X,Y) get_csv_llong((X),(Y),605) +#define get_csv_float_pos605(X,Y) get_csv_float((X),(Y),605) +#define get_csv_uint_pos606(X,Y) get_csv_uint((X),(Y),606) +#define get_csv_ullong_pos606(X,Y) get_csv_ullong((X),(Y),606) +#define get_csv_ip_pos606(X,Y) get_csv_ip((X),(Y),606) +#define get_csv_ipv6_pos606(X,Y) get_csv_ipv6((X),(Y),606) +#define get_csv_string_pos606(X,Y) get_csv_string((X),(Y),606) +#define get_csv_v_str_pos606(X,Y) get_csv_string((X),(Y),606) +#define get_csv_bool_pos606(X,Y) get_csv_bool((X),(Y),606) +#define get_csv_int_pos606(X,Y) get_csv_int((X),(Y),606) +#define get_csv_llong_pos606(X,Y) get_csv_llong((X),(Y),606) +#define get_csv_float_pos606(X,Y) get_csv_float((X),(Y),606) +#define get_csv_uint_pos607(X,Y) get_csv_uint((X),(Y),607) +#define get_csv_ullong_pos607(X,Y) get_csv_ullong((X),(Y),607) +#define get_csv_ip_pos607(X,Y) get_csv_ip((X),(Y),607) +#define get_csv_ipv6_pos607(X,Y) get_csv_ipv6((X),(Y),607) +#define get_csv_string_pos607(X,Y) get_csv_string((X),(Y),607) +#define get_csv_v_str_pos607(X,Y) get_csv_string((X),(Y),607) +#define get_csv_bool_pos607(X,Y) get_csv_bool((X),(Y),607) +#define get_csv_int_pos607(X,Y) get_csv_int((X),(Y),607) +#define get_csv_llong_pos607(X,Y) get_csv_llong((X),(Y),607) +#define get_csv_float_pos607(X,Y) get_csv_float((X),(Y),607) +#define get_csv_uint_pos608(X,Y) get_csv_uint((X),(Y),608) +#define get_csv_ullong_pos608(X,Y) get_csv_ullong((X),(Y),608) +#define get_csv_ip_pos608(X,Y) get_csv_ip((X),(Y),608) +#define get_csv_ipv6_pos608(X,Y) get_csv_ipv6((X),(Y),608) +#define get_csv_string_pos608(X,Y) get_csv_string((X),(Y),608) +#define get_csv_v_str_pos608(X,Y) get_csv_string((X),(Y),608) +#define get_csv_bool_pos608(X,Y) get_csv_bool((X),(Y),608) +#define get_csv_int_pos608(X,Y) get_csv_int((X),(Y),608) +#define get_csv_llong_pos608(X,Y) get_csv_llong((X),(Y),608) +#define get_csv_float_pos608(X,Y) get_csv_float((X),(Y),608) +#define get_csv_uint_pos609(X,Y) get_csv_uint((X),(Y),609) +#define get_csv_ullong_pos609(X,Y) get_csv_ullong((X),(Y),609) +#define get_csv_ip_pos609(X,Y) get_csv_ip((X),(Y),609) +#define get_csv_ipv6_pos609(X,Y) get_csv_ipv6((X),(Y),609) +#define get_csv_string_pos609(X,Y) get_csv_string((X),(Y),609) +#define get_csv_v_str_pos609(X,Y) get_csv_string((X),(Y),609) +#define get_csv_bool_pos609(X,Y) get_csv_bool((X),(Y),609) +#define get_csv_int_pos609(X,Y) get_csv_int((X),(Y),609) +#define get_csv_llong_pos609(X,Y) get_csv_llong((X),(Y),609) +#define get_csv_float_pos609(X,Y) get_csv_float((X),(Y),609) +#define get_csv_uint_pos610(X,Y) get_csv_uint((X),(Y),610) +#define get_csv_ullong_pos610(X,Y) get_csv_ullong((X),(Y),610) +#define get_csv_ip_pos610(X,Y) get_csv_ip((X),(Y),610) +#define get_csv_ipv6_pos610(X,Y) get_csv_ipv6((X),(Y),610) +#define get_csv_string_pos610(X,Y) get_csv_string((X),(Y),610) +#define get_csv_v_str_pos610(X,Y) get_csv_string((X),(Y),610) +#define get_csv_bool_pos610(X,Y) get_csv_bool((X),(Y),610) +#define get_csv_int_pos610(X,Y) get_csv_int((X),(Y),610) +#define get_csv_llong_pos610(X,Y) get_csv_llong((X),(Y),610) +#define get_csv_float_pos610(X,Y) get_csv_float((X),(Y),610) +#define get_csv_uint_pos611(X,Y) get_csv_uint((X),(Y),611) +#define get_csv_ullong_pos611(X,Y) get_csv_ullong((X),(Y),611) +#define get_csv_ip_pos611(X,Y) get_csv_ip((X),(Y),611) +#define get_csv_ipv6_pos611(X,Y) get_csv_ipv6((X),(Y),611) +#define get_csv_string_pos611(X,Y) get_csv_string((X),(Y),611) +#define get_csv_v_str_pos611(X,Y) get_csv_string((X),(Y),611) +#define get_csv_bool_pos611(X,Y) get_csv_bool((X),(Y),611) +#define get_csv_int_pos611(X,Y) get_csv_int((X),(Y),611) +#define get_csv_llong_pos611(X,Y) get_csv_llong((X),(Y),611) +#define get_csv_float_pos611(X,Y) get_csv_float((X),(Y),611) +#define get_csv_uint_pos612(X,Y) get_csv_uint((X),(Y),612) +#define get_csv_ullong_pos612(X,Y) get_csv_ullong((X),(Y),612) +#define get_csv_ip_pos612(X,Y) get_csv_ip((X),(Y),612) +#define get_csv_ipv6_pos612(X,Y) get_csv_ipv6((X),(Y),612) +#define get_csv_string_pos612(X,Y) get_csv_string((X),(Y),612) +#define get_csv_v_str_pos612(X,Y) get_csv_string((X),(Y),612) +#define get_csv_bool_pos612(X,Y) get_csv_bool((X),(Y),612) +#define get_csv_int_pos612(X,Y) get_csv_int((X),(Y),612) +#define get_csv_llong_pos612(X,Y) get_csv_llong((X),(Y),612) +#define get_csv_float_pos612(X,Y) get_csv_float((X),(Y),612) +#define get_csv_uint_pos613(X,Y) get_csv_uint((X),(Y),613) +#define get_csv_ullong_pos613(X,Y) get_csv_ullong((X),(Y),613) +#define get_csv_ip_pos613(X,Y) get_csv_ip((X),(Y),613) +#define get_csv_ipv6_pos613(X,Y) get_csv_ipv6((X),(Y),613) +#define get_csv_string_pos613(X,Y) get_csv_string((X),(Y),613) +#define get_csv_v_str_pos613(X,Y) get_csv_string((X),(Y),613) +#define get_csv_bool_pos613(X,Y) get_csv_bool((X),(Y),613) +#define get_csv_int_pos613(X,Y) get_csv_int((X),(Y),613) +#define get_csv_llong_pos613(X,Y) get_csv_llong((X),(Y),613) +#define get_csv_float_pos613(X,Y) get_csv_float((X),(Y),613) +#define get_csv_uint_pos614(X,Y) get_csv_uint((X),(Y),614) +#define get_csv_ullong_pos614(X,Y) get_csv_ullong((X),(Y),614) +#define get_csv_ip_pos614(X,Y) get_csv_ip((X),(Y),614) +#define get_csv_ipv6_pos614(X,Y) get_csv_ipv6((X),(Y),614) +#define get_csv_string_pos614(X,Y) get_csv_string((X),(Y),614) +#define get_csv_v_str_pos614(X,Y) get_csv_string((X),(Y),614) +#define get_csv_bool_pos614(X,Y) get_csv_bool((X),(Y),614) +#define get_csv_int_pos614(X,Y) get_csv_int((X),(Y),614) +#define get_csv_llong_pos614(X,Y) get_csv_llong((X),(Y),614) +#define get_csv_float_pos614(X,Y) get_csv_float((X),(Y),614) +#define get_csv_uint_pos615(X,Y) get_csv_uint((X),(Y),615) +#define get_csv_ullong_pos615(X,Y) get_csv_ullong((X),(Y),615) +#define get_csv_ip_pos615(X,Y) get_csv_ip((X),(Y),615) +#define get_csv_ipv6_pos615(X,Y) get_csv_ipv6((X),(Y),615) +#define get_csv_string_pos615(X,Y) get_csv_string((X),(Y),615) +#define get_csv_v_str_pos615(X,Y) get_csv_string((X),(Y),615) +#define get_csv_bool_pos615(X,Y) get_csv_bool((X),(Y),615) +#define get_csv_int_pos615(X,Y) get_csv_int((X),(Y),615) +#define get_csv_llong_pos615(X,Y) get_csv_llong((X),(Y),615) +#define get_csv_float_pos615(X,Y) get_csv_float((X),(Y),615) +#define get_csv_uint_pos616(X,Y) get_csv_uint((X),(Y),616) +#define get_csv_ullong_pos616(X,Y) get_csv_ullong((X),(Y),616) +#define get_csv_ip_pos616(X,Y) get_csv_ip((X),(Y),616) +#define get_csv_ipv6_pos616(X,Y) get_csv_ipv6((X),(Y),616) +#define get_csv_string_pos616(X,Y) get_csv_string((X),(Y),616) +#define get_csv_v_str_pos616(X,Y) get_csv_string((X),(Y),616) +#define get_csv_bool_pos616(X,Y) get_csv_bool((X),(Y),616) +#define get_csv_int_pos616(X,Y) get_csv_int((X),(Y),616) +#define get_csv_llong_pos616(X,Y) get_csv_llong((X),(Y),616) +#define get_csv_float_pos616(X,Y) get_csv_float((X),(Y),616) +#define get_csv_uint_pos617(X,Y) get_csv_uint((X),(Y),617) +#define get_csv_ullong_pos617(X,Y) get_csv_ullong((X),(Y),617) +#define get_csv_ip_pos617(X,Y) get_csv_ip((X),(Y),617) +#define get_csv_ipv6_pos617(X,Y) get_csv_ipv6((X),(Y),617) +#define get_csv_string_pos617(X,Y) get_csv_string((X),(Y),617) +#define get_csv_v_str_pos617(X,Y) get_csv_string((X),(Y),617) +#define get_csv_bool_pos617(X,Y) get_csv_bool((X),(Y),617) +#define get_csv_int_pos617(X,Y) get_csv_int((X),(Y),617) +#define get_csv_llong_pos617(X,Y) get_csv_llong((X),(Y),617) +#define get_csv_float_pos617(X,Y) get_csv_float((X),(Y),617) +#define get_csv_uint_pos618(X,Y) get_csv_uint((X),(Y),618) +#define get_csv_ullong_pos618(X,Y) get_csv_ullong((X),(Y),618) +#define get_csv_ip_pos618(X,Y) get_csv_ip((X),(Y),618) +#define get_csv_ipv6_pos618(X,Y) get_csv_ipv6((X),(Y),618) +#define get_csv_string_pos618(X,Y) get_csv_string((X),(Y),618) +#define get_csv_v_str_pos618(X,Y) get_csv_string((X),(Y),618) +#define get_csv_bool_pos618(X,Y) get_csv_bool((X),(Y),618) +#define get_csv_int_pos618(X,Y) get_csv_int((X),(Y),618) +#define get_csv_llong_pos618(X,Y) get_csv_llong((X),(Y),618) +#define get_csv_float_pos618(X,Y) get_csv_float((X),(Y),618) +#define get_csv_uint_pos619(X,Y) get_csv_uint((X),(Y),619) +#define get_csv_ullong_pos619(X,Y) get_csv_ullong((X),(Y),619) +#define get_csv_ip_pos619(X,Y) get_csv_ip((X),(Y),619) +#define get_csv_ipv6_pos619(X,Y) get_csv_ipv6((X),(Y),619) +#define get_csv_string_pos619(X,Y) get_csv_string((X),(Y),619) +#define get_csv_v_str_pos619(X,Y) get_csv_string((X),(Y),619) +#define get_csv_bool_pos619(X,Y) get_csv_bool((X),(Y),619) +#define get_csv_int_pos619(X,Y) get_csv_int((X),(Y),619) +#define get_csv_llong_pos619(X,Y) get_csv_llong((X),(Y),619) +#define get_csv_float_pos619(X,Y) get_csv_float((X),(Y),619) +#define get_csv_uint_pos620(X,Y) get_csv_uint((X),(Y),620) +#define get_csv_ullong_pos620(X,Y) get_csv_ullong((X),(Y),620) +#define get_csv_ip_pos620(X,Y) get_csv_ip((X),(Y),620) +#define get_csv_ipv6_pos620(X,Y) get_csv_ipv6((X),(Y),620) +#define get_csv_string_pos620(X,Y) get_csv_string((X),(Y),620) +#define get_csv_v_str_pos620(X,Y) get_csv_string((X),(Y),620) +#define get_csv_bool_pos620(X,Y) get_csv_bool((X),(Y),620) +#define get_csv_int_pos620(X,Y) get_csv_int((X),(Y),620) +#define get_csv_llong_pos620(X,Y) get_csv_llong((X),(Y),620) +#define get_csv_float_pos620(X,Y) get_csv_float((X),(Y),620) +#define get_csv_uint_pos621(X,Y) get_csv_uint((X),(Y),621) +#define get_csv_ullong_pos621(X,Y) get_csv_ullong((X),(Y),621) +#define get_csv_ip_pos621(X,Y) get_csv_ip((X),(Y),621) +#define get_csv_ipv6_pos621(X,Y) get_csv_ipv6((X),(Y),621) +#define get_csv_string_pos621(X,Y) get_csv_string((X),(Y),621) +#define get_csv_v_str_pos621(X,Y) get_csv_string((X),(Y),621) +#define get_csv_bool_pos621(X,Y) get_csv_bool((X),(Y),621) +#define get_csv_int_pos621(X,Y) get_csv_int((X),(Y),621) +#define get_csv_llong_pos621(X,Y) get_csv_llong((X),(Y),621) +#define get_csv_float_pos621(X,Y) get_csv_float((X),(Y),621) +#define get_csv_uint_pos622(X,Y) get_csv_uint((X),(Y),622) +#define get_csv_ullong_pos622(X,Y) get_csv_ullong((X),(Y),622) +#define get_csv_ip_pos622(X,Y) get_csv_ip((X),(Y),622) +#define get_csv_ipv6_pos622(X,Y) get_csv_ipv6((X),(Y),622) +#define get_csv_string_pos622(X,Y) get_csv_string((X),(Y),622) +#define get_csv_v_str_pos622(X,Y) get_csv_string((X),(Y),622) +#define get_csv_bool_pos622(X,Y) get_csv_bool((X),(Y),622) +#define get_csv_int_pos622(X,Y) get_csv_int((X),(Y),622) +#define get_csv_llong_pos622(X,Y) get_csv_llong((X),(Y),622) +#define get_csv_float_pos622(X,Y) get_csv_float((X),(Y),622) +#define get_csv_uint_pos623(X,Y) get_csv_uint((X),(Y),623) +#define get_csv_ullong_pos623(X,Y) get_csv_ullong((X),(Y),623) +#define get_csv_ip_pos623(X,Y) get_csv_ip((X),(Y),623) +#define get_csv_ipv6_pos623(X,Y) get_csv_ipv6((X),(Y),623) +#define get_csv_string_pos623(X,Y) get_csv_string((X),(Y),623) +#define get_csv_v_str_pos623(X,Y) get_csv_string((X),(Y),623) +#define get_csv_bool_pos623(X,Y) get_csv_bool((X),(Y),623) +#define get_csv_int_pos623(X,Y) get_csv_int((X),(Y),623) +#define get_csv_llong_pos623(X,Y) get_csv_llong((X),(Y),623) +#define get_csv_float_pos623(X,Y) get_csv_float((X),(Y),623) +#define get_csv_uint_pos624(X,Y) get_csv_uint((X),(Y),624) +#define get_csv_ullong_pos624(X,Y) get_csv_ullong((X),(Y),624) +#define get_csv_ip_pos624(X,Y) get_csv_ip((X),(Y),624) +#define get_csv_ipv6_pos624(X,Y) get_csv_ipv6((X),(Y),624) +#define get_csv_string_pos624(X,Y) get_csv_string((X),(Y),624) +#define get_csv_v_str_pos624(X,Y) get_csv_string((X),(Y),624) +#define get_csv_bool_pos624(X,Y) get_csv_bool((X),(Y),624) +#define get_csv_int_pos624(X,Y) get_csv_int((X),(Y),624) +#define get_csv_llong_pos624(X,Y) get_csv_llong((X),(Y),624) +#define get_csv_float_pos624(X,Y) get_csv_float((X),(Y),624) +#define get_csv_uint_pos625(X,Y) get_csv_uint((X),(Y),625) +#define get_csv_ullong_pos625(X,Y) get_csv_ullong((X),(Y),625) +#define get_csv_ip_pos625(X,Y) get_csv_ip((X),(Y),625) +#define get_csv_ipv6_pos625(X,Y) get_csv_ipv6((X),(Y),625) +#define get_csv_string_pos625(X,Y) get_csv_string((X),(Y),625) +#define get_csv_v_str_pos625(X,Y) get_csv_string((X),(Y),625) +#define get_csv_bool_pos625(X,Y) get_csv_bool((X),(Y),625) +#define get_csv_int_pos625(X,Y) get_csv_int((X),(Y),625) +#define get_csv_llong_pos625(X,Y) get_csv_llong((X),(Y),625) +#define get_csv_float_pos625(X,Y) get_csv_float((X),(Y),625) +#define get_csv_uint_pos626(X,Y) get_csv_uint((X),(Y),626) +#define get_csv_ullong_pos626(X,Y) get_csv_ullong((X),(Y),626) +#define get_csv_ip_pos626(X,Y) get_csv_ip((X),(Y),626) +#define get_csv_ipv6_pos626(X,Y) get_csv_ipv6((X),(Y),626) +#define get_csv_string_pos626(X,Y) get_csv_string((X),(Y),626) +#define get_csv_v_str_pos626(X,Y) get_csv_string((X),(Y),626) +#define get_csv_bool_pos626(X,Y) get_csv_bool((X),(Y),626) +#define get_csv_int_pos626(X,Y) get_csv_int((X),(Y),626) +#define get_csv_llong_pos626(X,Y) get_csv_llong((X),(Y),626) +#define get_csv_float_pos626(X,Y) get_csv_float((X),(Y),626) +#define get_csv_uint_pos627(X,Y) get_csv_uint((X),(Y),627) +#define get_csv_ullong_pos627(X,Y) get_csv_ullong((X),(Y),627) +#define get_csv_ip_pos627(X,Y) get_csv_ip((X),(Y),627) +#define get_csv_ipv6_pos627(X,Y) get_csv_ipv6((X),(Y),627) +#define get_csv_string_pos627(X,Y) get_csv_string((X),(Y),627) +#define get_csv_v_str_pos627(X,Y) get_csv_string((X),(Y),627) +#define get_csv_bool_pos627(X,Y) get_csv_bool((X),(Y),627) +#define get_csv_int_pos627(X,Y) get_csv_int((X),(Y),627) +#define get_csv_llong_pos627(X,Y) get_csv_llong((X),(Y),627) +#define get_csv_float_pos627(X,Y) get_csv_float((X),(Y),627) +#define get_csv_uint_pos628(X,Y) get_csv_uint((X),(Y),628) +#define get_csv_ullong_pos628(X,Y) get_csv_ullong((X),(Y),628) +#define get_csv_ip_pos628(X,Y) get_csv_ip((X),(Y),628) +#define get_csv_ipv6_pos628(X,Y) get_csv_ipv6((X),(Y),628) +#define get_csv_string_pos628(X,Y) get_csv_string((X),(Y),628) +#define get_csv_v_str_pos628(X,Y) get_csv_string((X),(Y),628) +#define get_csv_bool_pos628(X,Y) get_csv_bool((X),(Y),628) +#define get_csv_int_pos628(X,Y) get_csv_int((X),(Y),628) +#define get_csv_llong_pos628(X,Y) get_csv_llong((X),(Y),628) +#define get_csv_float_pos628(X,Y) get_csv_float((X),(Y),628) +#define get_csv_uint_pos629(X,Y) get_csv_uint((X),(Y),629) +#define get_csv_ullong_pos629(X,Y) get_csv_ullong((X),(Y),629) +#define get_csv_ip_pos629(X,Y) get_csv_ip((X),(Y),629) +#define get_csv_ipv6_pos629(X,Y) get_csv_ipv6((X),(Y),629) +#define get_csv_string_pos629(X,Y) get_csv_string((X),(Y),629) +#define get_csv_v_str_pos629(X,Y) get_csv_string((X),(Y),629) +#define get_csv_bool_pos629(X,Y) get_csv_bool((X),(Y),629) +#define get_csv_int_pos629(X,Y) get_csv_int((X),(Y),629) +#define get_csv_llong_pos629(X,Y) get_csv_llong((X),(Y),629) +#define get_csv_float_pos629(X,Y) get_csv_float((X),(Y),629) +#define get_csv_uint_pos630(X,Y) get_csv_uint((X),(Y),630) +#define get_csv_ullong_pos630(X,Y) get_csv_ullong((X),(Y),630) +#define get_csv_ip_pos630(X,Y) get_csv_ip((X),(Y),630) +#define get_csv_ipv6_pos630(X,Y) get_csv_ipv6((X),(Y),630) +#define get_csv_string_pos630(X,Y) get_csv_string((X),(Y),630) +#define get_csv_v_str_pos630(X,Y) get_csv_string((X),(Y),630) +#define get_csv_bool_pos630(X,Y) get_csv_bool((X),(Y),630) +#define get_csv_int_pos630(X,Y) get_csv_int((X),(Y),630) +#define get_csv_llong_pos630(X,Y) get_csv_llong((X),(Y),630) +#define get_csv_float_pos630(X,Y) get_csv_float((X),(Y),630) +#define get_csv_uint_pos631(X,Y) get_csv_uint((X),(Y),631) +#define get_csv_ullong_pos631(X,Y) get_csv_ullong((X),(Y),631) +#define get_csv_ip_pos631(X,Y) get_csv_ip((X),(Y),631) +#define get_csv_ipv6_pos631(X,Y) get_csv_ipv6((X),(Y),631) +#define get_csv_string_pos631(X,Y) get_csv_string((X),(Y),631) +#define get_csv_v_str_pos631(X,Y) get_csv_string((X),(Y),631) +#define get_csv_bool_pos631(X,Y) get_csv_bool((X),(Y),631) +#define get_csv_int_pos631(X,Y) get_csv_int((X),(Y),631) +#define get_csv_llong_pos631(X,Y) get_csv_llong((X),(Y),631) +#define get_csv_float_pos631(X,Y) get_csv_float((X),(Y),631) +#define get_csv_uint_pos632(X,Y) get_csv_uint((X),(Y),632) +#define get_csv_ullong_pos632(X,Y) get_csv_ullong((X),(Y),632) +#define get_csv_ip_pos632(X,Y) get_csv_ip((X),(Y),632) +#define get_csv_ipv6_pos632(X,Y) get_csv_ipv6((X),(Y),632) +#define get_csv_string_pos632(X,Y) get_csv_string((X),(Y),632) +#define get_csv_v_str_pos632(X,Y) get_csv_string((X),(Y),632) +#define get_csv_bool_pos632(X,Y) get_csv_bool((X),(Y),632) +#define get_csv_int_pos632(X,Y) get_csv_int((X),(Y),632) +#define get_csv_llong_pos632(X,Y) get_csv_llong((X),(Y),632) +#define get_csv_float_pos632(X,Y) get_csv_float((X),(Y),632) +#define get_csv_uint_pos633(X,Y) get_csv_uint((X),(Y),633) +#define get_csv_ullong_pos633(X,Y) get_csv_ullong((X),(Y),633) +#define get_csv_ip_pos633(X,Y) get_csv_ip((X),(Y),633) +#define get_csv_ipv6_pos633(X,Y) get_csv_ipv6((X),(Y),633) +#define get_csv_string_pos633(X,Y) get_csv_string((X),(Y),633) +#define get_csv_v_str_pos633(X,Y) get_csv_string((X),(Y),633) +#define get_csv_bool_pos633(X,Y) get_csv_bool((X),(Y),633) +#define get_csv_int_pos633(X,Y) get_csv_int((X),(Y),633) +#define get_csv_llong_pos633(X,Y) get_csv_llong((X),(Y),633) +#define get_csv_float_pos633(X,Y) get_csv_float((X),(Y),633) +#define get_csv_uint_pos634(X,Y) get_csv_uint((X),(Y),634) +#define get_csv_ullong_pos634(X,Y) get_csv_ullong((X),(Y),634) +#define get_csv_ip_pos634(X,Y) get_csv_ip((X),(Y),634) +#define get_csv_ipv6_pos634(X,Y) get_csv_ipv6((X),(Y),634) +#define get_csv_string_pos634(X,Y) get_csv_string((X),(Y),634) +#define get_csv_v_str_pos634(X,Y) get_csv_string((X),(Y),634) +#define get_csv_bool_pos634(X,Y) get_csv_bool((X),(Y),634) +#define get_csv_int_pos634(X,Y) get_csv_int((X),(Y),634) +#define get_csv_llong_pos634(X,Y) get_csv_llong((X),(Y),634) +#define get_csv_float_pos634(X,Y) get_csv_float((X),(Y),634) +#define get_csv_uint_pos635(X,Y) get_csv_uint((X),(Y),635) +#define get_csv_ullong_pos635(X,Y) get_csv_ullong((X),(Y),635) +#define get_csv_ip_pos635(X,Y) get_csv_ip((X),(Y),635) +#define get_csv_ipv6_pos635(X,Y) get_csv_ipv6((X),(Y),635) +#define get_csv_string_pos635(X,Y) get_csv_string((X),(Y),635) +#define get_csv_v_str_pos635(X,Y) get_csv_string((X),(Y),635) +#define get_csv_bool_pos635(X,Y) get_csv_bool((X),(Y),635) +#define get_csv_int_pos635(X,Y) get_csv_int((X),(Y),635) +#define get_csv_llong_pos635(X,Y) get_csv_llong((X),(Y),635) +#define get_csv_float_pos635(X,Y) get_csv_float((X),(Y),635) +#define get_csv_uint_pos636(X,Y) get_csv_uint((X),(Y),636) +#define get_csv_ullong_pos636(X,Y) get_csv_ullong((X),(Y),636) +#define get_csv_ip_pos636(X,Y) get_csv_ip((X),(Y),636) +#define get_csv_ipv6_pos636(X,Y) get_csv_ipv6((X),(Y),636) +#define get_csv_string_pos636(X,Y) get_csv_string((X),(Y),636) +#define get_csv_v_str_pos636(X,Y) get_csv_string((X),(Y),636) +#define get_csv_bool_pos636(X,Y) get_csv_bool((X),(Y),636) +#define get_csv_int_pos636(X,Y) get_csv_int((X),(Y),636) +#define get_csv_llong_pos636(X,Y) get_csv_llong((X),(Y),636) +#define get_csv_float_pos636(X,Y) get_csv_float((X),(Y),636) +#define get_csv_uint_pos637(X,Y) get_csv_uint((X),(Y),637) +#define get_csv_ullong_pos637(X,Y) get_csv_ullong((X),(Y),637) +#define get_csv_ip_pos637(X,Y) get_csv_ip((X),(Y),637) +#define get_csv_ipv6_pos637(X,Y) get_csv_ipv6((X),(Y),637) +#define get_csv_string_pos637(X,Y) get_csv_string((X),(Y),637) +#define get_csv_v_str_pos637(X,Y) get_csv_string((X),(Y),637) +#define get_csv_bool_pos637(X,Y) get_csv_bool((X),(Y),637) +#define get_csv_int_pos637(X,Y) get_csv_int((X),(Y),637) +#define get_csv_llong_pos637(X,Y) get_csv_llong((X),(Y),637) +#define get_csv_float_pos637(X,Y) get_csv_float((X),(Y),637) +#define get_csv_uint_pos638(X,Y) get_csv_uint((X),(Y),638) +#define get_csv_ullong_pos638(X,Y) get_csv_ullong((X),(Y),638) +#define get_csv_ip_pos638(X,Y) get_csv_ip((X),(Y),638) +#define get_csv_ipv6_pos638(X,Y) get_csv_ipv6((X),(Y),638) +#define get_csv_string_pos638(X,Y) get_csv_string((X),(Y),638) +#define get_csv_v_str_pos638(X,Y) get_csv_string((X),(Y),638) +#define get_csv_bool_pos638(X,Y) get_csv_bool((X),(Y),638) +#define get_csv_int_pos638(X,Y) get_csv_int((X),(Y),638) +#define get_csv_llong_pos638(X,Y) get_csv_llong((X),(Y),638) +#define get_csv_float_pos638(X,Y) get_csv_float((X),(Y),638) +#define get_csv_uint_pos639(X,Y) get_csv_uint((X),(Y),639) +#define get_csv_ullong_pos639(X,Y) get_csv_ullong((X),(Y),639) +#define get_csv_ip_pos639(X,Y) get_csv_ip((X),(Y),639) +#define get_csv_ipv6_pos639(X,Y) get_csv_ipv6((X),(Y),639) +#define get_csv_string_pos639(X,Y) get_csv_string((X),(Y),639) +#define get_csv_v_str_pos639(X,Y) get_csv_string((X),(Y),639) +#define get_csv_bool_pos639(X,Y) get_csv_bool((X),(Y),639) +#define get_csv_int_pos639(X,Y) get_csv_int((X),(Y),639) +#define get_csv_llong_pos639(X,Y) get_csv_llong((X),(Y),639) +#define get_csv_float_pos639(X,Y) get_csv_float((X),(Y),639) +#define get_csv_uint_pos640(X,Y) get_csv_uint((X),(Y),640) +#define get_csv_ullong_pos640(X,Y) get_csv_ullong((X),(Y),640) +#define get_csv_ip_pos640(X,Y) get_csv_ip((X),(Y),640) +#define get_csv_ipv6_pos640(X,Y) get_csv_ipv6((X),(Y),640) +#define get_csv_string_pos640(X,Y) get_csv_string((X),(Y),640) +#define get_csv_v_str_pos640(X,Y) get_csv_string((X),(Y),640) +#define get_csv_bool_pos640(X,Y) get_csv_bool((X),(Y),640) +#define get_csv_int_pos640(X,Y) get_csv_int((X),(Y),640) +#define get_csv_llong_pos640(X,Y) get_csv_llong((X),(Y),640) +#define get_csv_float_pos640(X,Y) get_csv_float((X),(Y),640) +#define get_csv_uint_pos641(X,Y) get_csv_uint((X),(Y),641) +#define get_csv_ullong_pos641(X,Y) get_csv_ullong((X),(Y),641) +#define get_csv_ip_pos641(X,Y) get_csv_ip((X),(Y),641) +#define get_csv_ipv6_pos641(X,Y) get_csv_ipv6((X),(Y),641) +#define get_csv_string_pos641(X,Y) get_csv_string((X),(Y),641) +#define get_csv_v_str_pos641(X,Y) get_csv_string((X),(Y),641) +#define get_csv_bool_pos641(X,Y) get_csv_bool((X),(Y),641) +#define get_csv_int_pos641(X,Y) get_csv_int((X),(Y),641) +#define get_csv_llong_pos641(X,Y) get_csv_llong((X),(Y),641) +#define get_csv_float_pos641(X,Y) get_csv_float((X),(Y),641) +#define get_csv_uint_pos642(X,Y) get_csv_uint((X),(Y),642) +#define get_csv_ullong_pos642(X,Y) get_csv_ullong((X),(Y),642) +#define get_csv_ip_pos642(X,Y) get_csv_ip((X),(Y),642) +#define get_csv_ipv6_pos642(X,Y) get_csv_ipv6((X),(Y),642) +#define get_csv_string_pos642(X,Y) get_csv_string((X),(Y),642) +#define get_csv_v_str_pos642(X,Y) get_csv_string((X),(Y),642) +#define get_csv_bool_pos642(X,Y) get_csv_bool((X),(Y),642) +#define get_csv_int_pos642(X,Y) get_csv_int((X),(Y),642) +#define get_csv_llong_pos642(X,Y) get_csv_llong((X),(Y),642) +#define get_csv_float_pos642(X,Y) get_csv_float((X),(Y),642) +#define get_csv_uint_pos643(X,Y) get_csv_uint((X),(Y),643) +#define get_csv_ullong_pos643(X,Y) get_csv_ullong((X),(Y),643) +#define get_csv_ip_pos643(X,Y) get_csv_ip((X),(Y),643) +#define get_csv_ipv6_pos643(X,Y) get_csv_ipv6((X),(Y),643) +#define get_csv_string_pos643(X,Y) get_csv_string((X),(Y),643) +#define get_csv_v_str_pos643(X,Y) get_csv_string((X),(Y),643) +#define get_csv_bool_pos643(X,Y) get_csv_bool((X),(Y),643) +#define get_csv_int_pos643(X,Y) get_csv_int((X),(Y),643) +#define get_csv_llong_pos643(X,Y) get_csv_llong((X),(Y),643) +#define get_csv_float_pos643(X,Y) get_csv_float((X),(Y),643) +#define get_csv_uint_pos644(X,Y) get_csv_uint((X),(Y),644) +#define get_csv_ullong_pos644(X,Y) get_csv_ullong((X),(Y),644) +#define get_csv_ip_pos644(X,Y) get_csv_ip((X),(Y),644) +#define get_csv_ipv6_pos644(X,Y) get_csv_ipv6((X),(Y),644) +#define get_csv_string_pos644(X,Y) get_csv_string((X),(Y),644) +#define get_csv_v_str_pos644(X,Y) get_csv_string((X),(Y),644) +#define get_csv_bool_pos644(X,Y) get_csv_bool((X),(Y),644) +#define get_csv_int_pos644(X,Y) get_csv_int((X),(Y),644) +#define get_csv_llong_pos644(X,Y) get_csv_llong((X),(Y),644) +#define get_csv_float_pos644(X,Y) get_csv_float((X),(Y),644) +#define get_csv_uint_pos645(X,Y) get_csv_uint((X),(Y),645) +#define get_csv_ullong_pos645(X,Y) get_csv_ullong((X),(Y),645) +#define get_csv_ip_pos645(X,Y) get_csv_ip((X),(Y),645) +#define get_csv_ipv6_pos645(X,Y) get_csv_ipv6((X),(Y),645) +#define get_csv_string_pos645(X,Y) get_csv_string((X),(Y),645) +#define get_csv_v_str_pos645(X,Y) get_csv_string((X),(Y),645) +#define get_csv_bool_pos645(X,Y) get_csv_bool((X),(Y),645) +#define get_csv_int_pos645(X,Y) get_csv_int((X),(Y),645) +#define get_csv_llong_pos645(X,Y) get_csv_llong((X),(Y),645) +#define get_csv_float_pos645(X,Y) get_csv_float((X),(Y),645) +#define get_csv_uint_pos646(X,Y) get_csv_uint((X),(Y),646) +#define get_csv_ullong_pos646(X,Y) get_csv_ullong((X),(Y),646) +#define get_csv_ip_pos646(X,Y) get_csv_ip((X),(Y),646) +#define get_csv_ipv6_pos646(X,Y) get_csv_ipv6((X),(Y),646) +#define get_csv_string_pos646(X,Y) get_csv_string((X),(Y),646) +#define get_csv_v_str_pos646(X,Y) get_csv_string((X),(Y),646) +#define get_csv_bool_pos646(X,Y) get_csv_bool((X),(Y),646) +#define get_csv_int_pos646(X,Y) get_csv_int((X),(Y),646) +#define get_csv_llong_pos646(X,Y) get_csv_llong((X),(Y),646) +#define get_csv_float_pos646(X,Y) get_csv_float((X),(Y),646) +#define get_csv_uint_pos647(X,Y) get_csv_uint((X),(Y),647) +#define get_csv_ullong_pos647(X,Y) get_csv_ullong((X),(Y),647) +#define get_csv_ip_pos647(X,Y) get_csv_ip((X),(Y),647) +#define get_csv_ipv6_pos647(X,Y) get_csv_ipv6((X),(Y),647) +#define get_csv_string_pos647(X,Y) get_csv_string((X),(Y),647) +#define get_csv_v_str_pos647(X,Y) get_csv_string((X),(Y),647) +#define get_csv_bool_pos647(X,Y) get_csv_bool((X),(Y),647) +#define get_csv_int_pos647(X,Y) get_csv_int((X),(Y),647) +#define get_csv_llong_pos647(X,Y) get_csv_llong((X),(Y),647) +#define get_csv_float_pos647(X,Y) get_csv_float((X),(Y),647) +#define get_csv_uint_pos648(X,Y) get_csv_uint((X),(Y),648) +#define get_csv_ullong_pos648(X,Y) get_csv_ullong((X),(Y),648) +#define get_csv_ip_pos648(X,Y) get_csv_ip((X),(Y),648) +#define get_csv_ipv6_pos648(X,Y) get_csv_ipv6((X),(Y),648) +#define get_csv_string_pos648(X,Y) get_csv_string((X),(Y),648) +#define get_csv_v_str_pos648(X,Y) get_csv_string((X),(Y),648) +#define get_csv_bool_pos648(X,Y) get_csv_bool((X),(Y),648) +#define get_csv_int_pos648(X,Y) get_csv_int((X),(Y),648) +#define get_csv_llong_pos648(X,Y) get_csv_llong((X),(Y),648) +#define get_csv_float_pos648(X,Y) get_csv_float((X),(Y),648) +#define get_csv_uint_pos649(X,Y) get_csv_uint((X),(Y),649) +#define get_csv_ullong_pos649(X,Y) get_csv_ullong((X),(Y),649) +#define get_csv_ip_pos649(X,Y) get_csv_ip((X),(Y),649) +#define get_csv_ipv6_pos649(X,Y) get_csv_ipv6((X),(Y),649) +#define get_csv_string_pos649(X,Y) get_csv_string((X),(Y),649) +#define get_csv_v_str_pos649(X,Y) get_csv_string((X),(Y),649) +#define get_csv_bool_pos649(X,Y) get_csv_bool((X),(Y),649) +#define get_csv_int_pos649(X,Y) get_csv_int((X),(Y),649) +#define get_csv_llong_pos649(X,Y) get_csv_llong((X),(Y),649) +#define get_csv_float_pos649(X,Y) get_csv_float((X),(Y),649) +#define get_csv_uint_pos650(X,Y) get_csv_uint((X),(Y),650) +#define get_csv_ullong_pos650(X,Y) get_csv_ullong((X),(Y),650) +#define get_csv_ip_pos650(X,Y) get_csv_ip((X),(Y),650) +#define get_csv_ipv6_pos650(X,Y) get_csv_ipv6((X),(Y),650) +#define get_csv_string_pos650(X,Y) get_csv_string((X),(Y),650) +#define get_csv_v_str_pos650(X,Y) get_csv_string((X),(Y),650) +#define get_csv_bool_pos650(X,Y) get_csv_bool((X),(Y),650) +#define get_csv_int_pos650(X,Y) get_csv_int((X),(Y),650) +#define get_csv_llong_pos650(X,Y) get_csv_llong((X),(Y),650) +#define get_csv_float_pos650(X,Y) get_csv_float((X),(Y),650) +#define get_csv_uint_pos651(X,Y) get_csv_uint((X),(Y),651) +#define get_csv_ullong_pos651(X,Y) get_csv_ullong((X),(Y),651) +#define get_csv_ip_pos651(X,Y) get_csv_ip((X),(Y),651) +#define get_csv_ipv6_pos651(X,Y) get_csv_ipv6((X),(Y),651) +#define get_csv_string_pos651(X,Y) get_csv_string((X),(Y),651) +#define get_csv_v_str_pos651(X,Y) get_csv_string((X),(Y),651) +#define get_csv_bool_pos651(X,Y) get_csv_bool((X),(Y),651) +#define get_csv_int_pos651(X,Y) get_csv_int((X),(Y),651) +#define get_csv_llong_pos651(X,Y) get_csv_llong((X),(Y),651) +#define get_csv_float_pos651(X,Y) get_csv_float((X),(Y),651) +#define get_csv_uint_pos652(X,Y) get_csv_uint((X),(Y),652) +#define get_csv_ullong_pos652(X,Y) get_csv_ullong((X),(Y),652) +#define get_csv_ip_pos652(X,Y) get_csv_ip((X),(Y),652) +#define get_csv_ipv6_pos652(X,Y) get_csv_ipv6((X),(Y),652) +#define get_csv_string_pos652(X,Y) get_csv_string((X),(Y),652) +#define get_csv_v_str_pos652(X,Y) get_csv_string((X),(Y),652) +#define get_csv_bool_pos652(X,Y) get_csv_bool((X),(Y),652) +#define get_csv_int_pos652(X,Y) get_csv_int((X),(Y),652) +#define get_csv_llong_pos652(X,Y) get_csv_llong((X),(Y),652) +#define get_csv_float_pos652(X,Y) get_csv_float((X),(Y),652) +#define get_csv_uint_pos653(X,Y) get_csv_uint((X),(Y),653) +#define get_csv_ullong_pos653(X,Y) get_csv_ullong((X),(Y),653) +#define get_csv_ip_pos653(X,Y) get_csv_ip((X),(Y),653) +#define get_csv_ipv6_pos653(X,Y) get_csv_ipv6((X),(Y),653) +#define get_csv_string_pos653(X,Y) get_csv_string((X),(Y),653) +#define get_csv_v_str_pos653(X,Y) get_csv_string((X),(Y),653) +#define get_csv_bool_pos653(X,Y) get_csv_bool((X),(Y),653) +#define get_csv_int_pos653(X,Y) get_csv_int((X),(Y),653) +#define get_csv_llong_pos653(X,Y) get_csv_llong((X),(Y),653) +#define get_csv_float_pos653(X,Y) get_csv_float((X),(Y),653) +#define get_csv_uint_pos654(X,Y) get_csv_uint((X),(Y),654) +#define get_csv_ullong_pos654(X,Y) get_csv_ullong((X),(Y),654) +#define get_csv_ip_pos654(X,Y) get_csv_ip((X),(Y),654) +#define get_csv_ipv6_pos654(X,Y) get_csv_ipv6((X),(Y),654) +#define get_csv_string_pos654(X,Y) get_csv_string((X),(Y),654) +#define get_csv_v_str_pos654(X,Y) get_csv_string((X),(Y),654) +#define get_csv_bool_pos654(X,Y) get_csv_bool((X),(Y),654) +#define get_csv_int_pos654(X,Y) get_csv_int((X),(Y),654) +#define get_csv_llong_pos654(X,Y) get_csv_llong((X),(Y),654) +#define get_csv_float_pos654(X,Y) get_csv_float((X),(Y),654) +#define get_csv_uint_pos655(X,Y) get_csv_uint((X),(Y),655) +#define get_csv_ullong_pos655(X,Y) get_csv_ullong((X),(Y),655) +#define get_csv_ip_pos655(X,Y) get_csv_ip((X),(Y),655) +#define get_csv_ipv6_pos655(X,Y) get_csv_ipv6((X),(Y),655) +#define get_csv_string_pos655(X,Y) get_csv_string((X),(Y),655) +#define get_csv_v_str_pos655(X,Y) get_csv_string((X),(Y),655) +#define get_csv_bool_pos655(X,Y) get_csv_bool((X),(Y),655) +#define get_csv_int_pos655(X,Y) get_csv_int((X),(Y),655) +#define get_csv_llong_pos655(X,Y) get_csv_llong((X),(Y),655) +#define get_csv_float_pos655(X,Y) get_csv_float((X),(Y),655) +#define get_csv_uint_pos656(X,Y) get_csv_uint((X),(Y),656) +#define get_csv_ullong_pos656(X,Y) get_csv_ullong((X),(Y),656) +#define get_csv_ip_pos656(X,Y) get_csv_ip((X),(Y),656) +#define get_csv_ipv6_pos656(X,Y) get_csv_ipv6((X),(Y),656) +#define get_csv_string_pos656(X,Y) get_csv_string((X),(Y),656) +#define get_csv_v_str_pos656(X,Y) get_csv_string((X),(Y),656) +#define get_csv_bool_pos656(X,Y) get_csv_bool((X),(Y),656) +#define get_csv_int_pos656(X,Y) get_csv_int((X),(Y),656) +#define get_csv_llong_pos656(X,Y) get_csv_llong((X),(Y),656) +#define get_csv_float_pos656(X,Y) get_csv_float((X),(Y),656) +#define get_csv_uint_pos657(X,Y) get_csv_uint((X),(Y),657) +#define get_csv_ullong_pos657(X,Y) get_csv_ullong((X),(Y),657) +#define get_csv_ip_pos657(X,Y) get_csv_ip((X),(Y),657) +#define get_csv_ipv6_pos657(X,Y) get_csv_ipv6((X),(Y),657) +#define get_csv_string_pos657(X,Y) get_csv_string((X),(Y),657) +#define get_csv_v_str_pos657(X,Y) get_csv_string((X),(Y),657) +#define get_csv_bool_pos657(X,Y) get_csv_bool((X),(Y),657) +#define get_csv_int_pos657(X,Y) get_csv_int((X),(Y),657) +#define get_csv_llong_pos657(X,Y) get_csv_llong((X),(Y),657) +#define get_csv_float_pos657(X,Y) get_csv_float((X),(Y),657) +#define get_csv_uint_pos658(X,Y) get_csv_uint((X),(Y),658) +#define get_csv_ullong_pos658(X,Y) get_csv_ullong((X),(Y),658) +#define get_csv_ip_pos658(X,Y) get_csv_ip((X),(Y),658) +#define get_csv_ipv6_pos658(X,Y) get_csv_ipv6((X),(Y),658) +#define get_csv_string_pos658(X,Y) get_csv_string((X),(Y),658) +#define get_csv_v_str_pos658(X,Y) get_csv_string((X),(Y),658) +#define get_csv_bool_pos658(X,Y) get_csv_bool((X),(Y),658) +#define get_csv_int_pos658(X,Y) get_csv_int((X),(Y),658) +#define get_csv_llong_pos658(X,Y) get_csv_llong((X),(Y),658) +#define get_csv_float_pos658(X,Y) get_csv_float((X),(Y),658) +#define get_csv_uint_pos659(X,Y) get_csv_uint((X),(Y),659) +#define get_csv_ullong_pos659(X,Y) get_csv_ullong((X),(Y),659) +#define get_csv_ip_pos659(X,Y) get_csv_ip((X),(Y),659) +#define get_csv_ipv6_pos659(X,Y) get_csv_ipv6((X),(Y),659) +#define get_csv_string_pos659(X,Y) get_csv_string((X),(Y),659) +#define get_csv_v_str_pos659(X,Y) get_csv_string((X),(Y),659) +#define get_csv_bool_pos659(X,Y) get_csv_bool((X),(Y),659) +#define get_csv_int_pos659(X,Y) get_csv_int((X),(Y),659) +#define get_csv_llong_pos659(X,Y) get_csv_llong((X),(Y),659) +#define get_csv_float_pos659(X,Y) get_csv_float((X),(Y),659) +#define get_csv_uint_pos660(X,Y) get_csv_uint((X),(Y),660) +#define get_csv_ullong_pos660(X,Y) get_csv_ullong((X),(Y),660) +#define get_csv_ip_pos660(X,Y) get_csv_ip((X),(Y),660) +#define get_csv_ipv6_pos660(X,Y) get_csv_ipv6((X),(Y),660) +#define get_csv_string_pos660(X,Y) get_csv_string((X),(Y),660) +#define get_csv_v_str_pos660(X,Y) get_csv_string((X),(Y),660) +#define get_csv_bool_pos660(X,Y) get_csv_bool((X),(Y),660) +#define get_csv_int_pos660(X,Y) get_csv_int((X),(Y),660) +#define get_csv_llong_pos660(X,Y) get_csv_llong((X),(Y),660) +#define get_csv_float_pos660(X,Y) get_csv_float((X),(Y),660) +#define get_csv_uint_pos661(X,Y) get_csv_uint((X),(Y),661) +#define get_csv_ullong_pos661(X,Y) get_csv_ullong((X),(Y),661) +#define get_csv_ip_pos661(X,Y) get_csv_ip((X),(Y),661) +#define get_csv_ipv6_pos661(X,Y) get_csv_ipv6((X),(Y),661) +#define get_csv_string_pos661(X,Y) get_csv_string((X),(Y),661) +#define get_csv_v_str_pos661(X,Y) get_csv_string((X),(Y),661) +#define get_csv_bool_pos661(X,Y) get_csv_bool((X),(Y),661) +#define get_csv_int_pos661(X,Y) get_csv_int((X),(Y),661) +#define get_csv_llong_pos661(X,Y) get_csv_llong((X),(Y),661) +#define get_csv_float_pos661(X,Y) get_csv_float((X),(Y),661) +#define get_csv_uint_pos662(X,Y) get_csv_uint((X),(Y),662) +#define get_csv_ullong_pos662(X,Y) get_csv_ullong((X),(Y),662) +#define get_csv_ip_pos662(X,Y) get_csv_ip((X),(Y),662) +#define get_csv_ipv6_pos662(X,Y) get_csv_ipv6((X),(Y),662) +#define get_csv_string_pos662(X,Y) get_csv_string((X),(Y),662) +#define get_csv_v_str_pos662(X,Y) get_csv_string((X),(Y),662) +#define get_csv_bool_pos662(X,Y) get_csv_bool((X),(Y),662) +#define get_csv_int_pos662(X,Y) get_csv_int((X),(Y),662) +#define get_csv_llong_pos662(X,Y) get_csv_llong((X),(Y),662) +#define get_csv_float_pos662(X,Y) get_csv_float((X),(Y),662) +#define get_csv_uint_pos663(X,Y) get_csv_uint((X),(Y),663) +#define get_csv_ullong_pos663(X,Y) get_csv_ullong((X),(Y),663) +#define get_csv_ip_pos663(X,Y) get_csv_ip((X),(Y),663) +#define get_csv_ipv6_pos663(X,Y) get_csv_ipv6((X),(Y),663) +#define get_csv_string_pos663(X,Y) get_csv_string((X),(Y),663) +#define get_csv_v_str_pos663(X,Y) get_csv_string((X),(Y),663) +#define get_csv_bool_pos663(X,Y) get_csv_bool((X),(Y),663) +#define get_csv_int_pos663(X,Y) get_csv_int((X),(Y),663) +#define get_csv_llong_pos663(X,Y) get_csv_llong((X),(Y),663) +#define get_csv_float_pos663(X,Y) get_csv_float((X),(Y),663) +#define get_csv_uint_pos664(X,Y) get_csv_uint((X),(Y),664) +#define get_csv_ullong_pos664(X,Y) get_csv_ullong((X),(Y),664) +#define get_csv_ip_pos664(X,Y) get_csv_ip((X),(Y),664) +#define get_csv_ipv6_pos664(X,Y) get_csv_ipv6((X),(Y),664) +#define get_csv_string_pos664(X,Y) get_csv_string((X),(Y),664) +#define get_csv_v_str_pos664(X,Y) get_csv_string((X),(Y),664) +#define get_csv_bool_pos664(X,Y) get_csv_bool((X),(Y),664) +#define get_csv_int_pos664(X,Y) get_csv_int((X),(Y),664) +#define get_csv_llong_pos664(X,Y) get_csv_llong((X),(Y),664) +#define get_csv_float_pos664(X,Y) get_csv_float((X),(Y),664) +#define get_csv_uint_pos665(X,Y) get_csv_uint((X),(Y),665) +#define get_csv_ullong_pos665(X,Y) get_csv_ullong((X),(Y),665) +#define get_csv_ip_pos665(X,Y) get_csv_ip((X),(Y),665) +#define get_csv_ipv6_pos665(X,Y) get_csv_ipv6((X),(Y),665) +#define get_csv_string_pos665(X,Y) get_csv_string((X),(Y),665) +#define get_csv_v_str_pos665(X,Y) get_csv_string((X),(Y),665) +#define get_csv_bool_pos665(X,Y) get_csv_bool((X),(Y),665) +#define get_csv_int_pos665(X,Y) get_csv_int((X),(Y),665) +#define get_csv_llong_pos665(X,Y) get_csv_llong((X),(Y),665) +#define get_csv_float_pos665(X,Y) get_csv_float((X),(Y),665) +#define get_csv_uint_pos666(X,Y) get_csv_uint((X),(Y),666) +#define get_csv_ullong_pos666(X,Y) get_csv_ullong((X),(Y),666) +#define get_csv_ip_pos666(X,Y) get_csv_ip((X),(Y),666) +#define get_csv_ipv6_pos666(X,Y) get_csv_ipv6((X),(Y),666) +#define get_csv_string_pos666(X,Y) get_csv_string((X),(Y),666) +#define get_csv_v_str_pos666(X,Y) get_csv_string((X),(Y),666) +#define get_csv_bool_pos666(X,Y) get_csv_bool((X),(Y),666) +#define get_csv_int_pos666(X,Y) get_csv_int((X),(Y),666) +#define get_csv_llong_pos666(X,Y) get_csv_llong((X),(Y),666) +#define get_csv_float_pos666(X,Y) get_csv_float((X),(Y),666) +#define get_csv_uint_pos667(X,Y) get_csv_uint((X),(Y),667) +#define get_csv_ullong_pos667(X,Y) get_csv_ullong((X),(Y),667) +#define get_csv_ip_pos667(X,Y) get_csv_ip((X),(Y),667) +#define get_csv_ipv6_pos667(X,Y) get_csv_ipv6((X),(Y),667) +#define get_csv_string_pos667(X,Y) get_csv_string((X),(Y),667) +#define get_csv_v_str_pos667(X,Y) get_csv_string((X),(Y),667) +#define get_csv_bool_pos667(X,Y) get_csv_bool((X),(Y),667) +#define get_csv_int_pos667(X,Y) get_csv_int((X),(Y),667) +#define get_csv_llong_pos667(X,Y) get_csv_llong((X),(Y),667) +#define get_csv_float_pos667(X,Y) get_csv_float((X),(Y),667) +#define get_csv_uint_pos668(X,Y) get_csv_uint((X),(Y),668) +#define get_csv_ullong_pos668(X,Y) get_csv_ullong((X),(Y),668) +#define get_csv_ip_pos668(X,Y) get_csv_ip((X),(Y),668) +#define get_csv_ipv6_pos668(X,Y) get_csv_ipv6((X),(Y),668) +#define get_csv_string_pos668(X,Y) get_csv_string((X),(Y),668) +#define get_csv_v_str_pos668(X,Y) get_csv_string((X),(Y),668) +#define get_csv_bool_pos668(X,Y) get_csv_bool((X),(Y),668) +#define get_csv_int_pos668(X,Y) get_csv_int((X),(Y),668) +#define get_csv_llong_pos668(X,Y) get_csv_llong((X),(Y),668) +#define get_csv_float_pos668(X,Y) get_csv_float((X),(Y),668) +#define get_csv_uint_pos669(X,Y) get_csv_uint((X),(Y),669) +#define get_csv_ullong_pos669(X,Y) get_csv_ullong((X),(Y),669) +#define get_csv_ip_pos669(X,Y) get_csv_ip((X),(Y),669) +#define get_csv_ipv6_pos669(X,Y) get_csv_ipv6((X),(Y),669) +#define get_csv_string_pos669(X,Y) get_csv_string((X),(Y),669) +#define get_csv_v_str_pos669(X,Y) get_csv_string((X),(Y),669) +#define get_csv_bool_pos669(X,Y) get_csv_bool((X),(Y),669) +#define get_csv_int_pos669(X,Y) get_csv_int((X),(Y),669) +#define get_csv_llong_pos669(X,Y) get_csv_llong((X),(Y),669) +#define get_csv_float_pos669(X,Y) get_csv_float((X),(Y),669) +#define get_csv_uint_pos670(X,Y) get_csv_uint((X),(Y),670) +#define get_csv_ullong_pos670(X,Y) get_csv_ullong((X),(Y),670) +#define get_csv_ip_pos670(X,Y) get_csv_ip((X),(Y),670) +#define get_csv_ipv6_pos670(X,Y) get_csv_ipv6((X),(Y),670) +#define get_csv_string_pos670(X,Y) get_csv_string((X),(Y),670) +#define get_csv_v_str_pos670(X,Y) get_csv_string((X),(Y),670) +#define get_csv_bool_pos670(X,Y) get_csv_bool((X),(Y),670) +#define get_csv_int_pos670(X,Y) get_csv_int((X),(Y),670) +#define get_csv_llong_pos670(X,Y) get_csv_llong((X),(Y),670) +#define get_csv_float_pos670(X,Y) get_csv_float((X),(Y),670) +#define get_csv_uint_pos671(X,Y) get_csv_uint((X),(Y),671) +#define get_csv_ullong_pos671(X,Y) get_csv_ullong((X),(Y),671) +#define get_csv_ip_pos671(X,Y) get_csv_ip((X),(Y),671) +#define get_csv_ipv6_pos671(X,Y) get_csv_ipv6((X),(Y),671) +#define get_csv_string_pos671(X,Y) get_csv_string((X),(Y),671) +#define get_csv_v_str_pos671(X,Y) get_csv_string((X),(Y),671) +#define get_csv_bool_pos671(X,Y) get_csv_bool((X),(Y),671) +#define get_csv_int_pos671(X,Y) get_csv_int((X),(Y),671) +#define get_csv_llong_pos671(X,Y) get_csv_llong((X),(Y),671) +#define get_csv_float_pos671(X,Y) get_csv_float((X),(Y),671) +#define get_csv_uint_pos672(X,Y) get_csv_uint((X),(Y),672) +#define get_csv_ullong_pos672(X,Y) get_csv_ullong((X),(Y),672) +#define get_csv_ip_pos672(X,Y) get_csv_ip((X),(Y),672) +#define get_csv_ipv6_pos672(X,Y) get_csv_ipv6((X),(Y),672) +#define get_csv_string_pos672(X,Y) get_csv_string((X),(Y),672) +#define get_csv_v_str_pos672(X,Y) get_csv_string((X),(Y),672) +#define get_csv_bool_pos672(X,Y) get_csv_bool((X),(Y),672) +#define get_csv_int_pos672(X,Y) get_csv_int((X),(Y),672) +#define get_csv_llong_pos672(X,Y) get_csv_llong((X),(Y),672) +#define get_csv_float_pos672(X,Y) get_csv_float((X),(Y),672) +#define get_csv_uint_pos673(X,Y) get_csv_uint((X),(Y),673) +#define get_csv_ullong_pos673(X,Y) get_csv_ullong((X),(Y),673) +#define get_csv_ip_pos673(X,Y) get_csv_ip((X),(Y),673) +#define get_csv_ipv6_pos673(X,Y) get_csv_ipv6((X),(Y),673) +#define get_csv_string_pos673(X,Y) get_csv_string((X),(Y),673) +#define get_csv_v_str_pos673(X,Y) get_csv_string((X),(Y),673) +#define get_csv_bool_pos673(X,Y) get_csv_bool((X),(Y),673) +#define get_csv_int_pos673(X,Y) get_csv_int((X),(Y),673) +#define get_csv_llong_pos673(X,Y) get_csv_llong((X),(Y),673) +#define get_csv_float_pos673(X,Y) get_csv_float((X),(Y),673) +#define get_csv_uint_pos674(X,Y) get_csv_uint((X),(Y),674) +#define get_csv_ullong_pos674(X,Y) get_csv_ullong((X),(Y),674) +#define get_csv_ip_pos674(X,Y) get_csv_ip((X),(Y),674) +#define get_csv_ipv6_pos674(X,Y) get_csv_ipv6((X),(Y),674) +#define get_csv_string_pos674(X,Y) get_csv_string((X),(Y),674) +#define get_csv_v_str_pos674(X,Y) get_csv_string((X),(Y),674) +#define get_csv_bool_pos674(X,Y) get_csv_bool((X),(Y),674) +#define get_csv_int_pos674(X,Y) get_csv_int((X),(Y),674) +#define get_csv_llong_pos674(X,Y) get_csv_llong((X),(Y),674) +#define get_csv_float_pos674(X,Y) get_csv_float((X),(Y),674) +#define get_csv_uint_pos675(X,Y) get_csv_uint((X),(Y),675) +#define get_csv_ullong_pos675(X,Y) get_csv_ullong((X),(Y),675) +#define get_csv_ip_pos675(X,Y) get_csv_ip((X),(Y),675) +#define get_csv_ipv6_pos675(X,Y) get_csv_ipv6((X),(Y),675) +#define get_csv_string_pos675(X,Y) get_csv_string((X),(Y),675) +#define get_csv_v_str_pos675(X,Y) get_csv_string((X),(Y),675) +#define get_csv_bool_pos675(X,Y) get_csv_bool((X),(Y),675) +#define get_csv_int_pos675(X,Y) get_csv_int((X),(Y),675) +#define get_csv_llong_pos675(X,Y) get_csv_llong((X),(Y),675) +#define get_csv_float_pos675(X,Y) get_csv_float((X),(Y),675) +#define get_csv_uint_pos676(X,Y) get_csv_uint((X),(Y),676) +#define get_csv_ullong_pos676(X,Y) get_csv_ullong((X),(Y),676) +#define get_csv_ip_pos676(X,Y) get_csv_ip((X),(Y),676) +#define get_csv_ipv6_pos676(X,Y) get_csv_ipv6((X),(Y),676) +#define get_csv_string_pos676(X,Y) get_csv_string((X),(Y),676) +#define get_csv_v_str_pos676(X,Y) get_csv_string((X),(Y),676) +#define get_csv_bool_pos676(X,Y) get_csv_bool((X),(Y),676) +#define get_csv_int_pos676(X,Y) get_csv_int((X),(Y),676) +#define get_csv_llong_pos676(X,Y) get_csv_llong((X),(Y),676) +#define get_csv_float_pos676(X,Y) get_csv_float((X),(Y),676) +#define get_csv_uint_pos677(X,Y) get_csv_uint((X),(Y),677) +#define get_csv_ullong_pos677(X,Y) get_csv_ullong((X),(Y),677) +#define get_csv_ip_pos677(X,Y) get_csv_ip((X),(Y),677) +#define get_csv_ipv6_pos677(X,Y) get_csv_ipv6((X),(Y),677) +#define get_csv_string_pos677(X,Y) get_csv_string((X),(Y),677) +#define get_csv_v_str_pos677(X,Y) get_csv_string((X),(Y),677) +#define get_csv_bool_pos677(X,Y) get_csv_bool((X),(Y),677) +#define get_csv_int_pos677(X,Y) get_csv_int((X),(Y),677) +#define get_csv_llong_pos677(X,Y) get_csv_llong((X),(Y),677) +#define get_csv_float_pos677(X,Y) get_csv_float((X),(Y),677) +#define get_csv_uint_pos678(X,Y) get_csv_uint((X),(Y),678) +#define get_csv_ullong_pos678(X,Y) get_csv_ullong((X),(Y),678) +#define get_csv_ip_pos678(X,Y) get_csv_ip((X),(Y),678) +#define get_csv_ipv6_pos678(X,Y) get_csv_ipv6((X),(Y),678) +#define get_csv_string_pos678(X,Y) get_csv_string((X),(Y),678) +#define get_csv_v_str_pos678(X,Y) get_csv_string((X),(Y),678) +#define get_csv_bool_pos678(X,Y) get_csv_bool((X),(Y),678) +#define get_csv_int_pos678(X,Y) get_csv_int((X),(Y),678) +#define get_csv_llong_pos678(X,Y) get_csv_llong((X),(Y),678) +#define get_csv_float_pos678(X,Y) get_csv_float((X),(Y),678) +#define get_csv_uint_pos679(X,Y) get_csv_uint((X),(Y),679) +#define get_csv_ullong_pos679(X,Y) get_csv_ullong((X),(Y),679) +#define get_csv_ip_pos679(X,Y) get_csv_ip((X),(Y),679) +#define get_csv_ipv6_pos679(X,Y) get_csv_ipv6((X),(Y),679) +#define get_csv_string_pos679(X,Y) get_csv_string((X),(Y),679) +#define get_csv_v_str_pos679(X,Y) get_csv_string((X),(Y),679) +#define get_csv_bool_pos679(X,Y) get_csv_bool((X),(Y),679) +#define get_csv_int_pos679(X,Y) get_csv_int((X),(Y),679) +#define get_csv_llong_pos679(X,Y) get_csv_llong((X),(Y),679) +#define get_csv_float_pos679(X,Y) get_csv_float((X),(Y),679) +#define get_csv_uint_pos680(X,Y) get_csv_uint((X),(Y),680) +#define get_csv_ullong_pos680(X,Y) get_csv_ullong((X),(Y),680) +#define get_csv_ip_pos680(X,Y) get_csv_ip((X),(Y),680) +#define get_csv_ipv6_pos680(X,Y) get_csv_ipv6((X),(Y),680) +#define get_csv_string_pos680(X,Y) get_csv_string((X),(Y),680) +#define get_csv_v_str_pos680(X,Y) get_csv_string((X),(Y),680) +#define get_csv_bool_pos680(X,Y) get_csv_bool((X),(Y),680) +#define get_csv_int_pos680(X,Y) get_csv_int((X),(Y),680) +#define get_csv_llong_pos680(X,Y) get_csv_llong((X),(Y),680) +#define get_csv_float_pos680(X,Y) get_csv_float((X),(Y),680) +#define get_csv_uint_pos681(X,Y) get_csv_uint((X),(Y),681) +#define get_csv_ullong_pos681(X,Y) get_csv_ullong((X),(Y),681) +#define get_csv_ip_pos681(X,Y) get_csv_ip((X),(Y),681) +#define get_csv_ipv6_pos681(X,Y) get_csv_ipv6((X),(Y),681) +#define get_csv_string_pos681(X,Y) get_csv_string((X),(Y),681) +#define get_csv_v_str_pos681(X,Y) get_csv_string((X),(Y),681) +#define get_csv_bool_pos681(X,Y) get_csv_bool((X),(Y),681) +#define get_csv_int_pos681(X,Y) get_csv_int((X),(Y),681) +#define get_csv_llong_pos681(X,Y) get_csv_llong((X),(Y),681) +#define get_csv_float_pos681(X,Y) get_csv_float((X),(Y),681) +#define get_csv_uint_pos682(X,Y) get_csv_uint((X),(Y),682) +#define get_csv_ullong_pos682(X,Y) get_csv_ullong((X),(Y),682) +#define get_csv_ip_pos682(X,Y) get_csv_ip((X),(Y),682) +#define get_csv_ipv6_pos682(X,Y) get_csv_ipv6((X),(Y),682) +#define get_csv_string_pos682(X,Y) get_csv_string((X),(Y),682) +#define get_csv_v_str_pos682(X,Y) get_csv_string((X),(Y),682) +#define get_csv_bool_pos682(X,Y) get_csv_bool((X),(Y),682) +#define get_csv_int_pos682(X,Y) get_csv_int((X),(Y),682) +#define get_csv_llong_pos682(X,Y) get_csv_llong((X),(Y),682) +#define get_csv_float_pos682(X,Y) get_csv_float((X),(Y),682) +#define get_csv_uint_pos683(X,Y) get_csv_uint((X),(Y),683) +#define get_csv_ullong_pos683(X,Y) get_csv_ullong((X),(Y),683) +#define get_csv_ip_pos683(X,Y) get_csv_ip((X),(Y),683) +#define get_csv_ipv6_pos683(X,Y) get_csv_ipv6((X),(Y),683) +#define get_csv_string_pos683(X,Y) get_csv_string((X),(Y),683) +#define get_csv_v_str_pos683(X,Y) get_csv_string((X),(Y),683) +#define get_csv_bool_pos683(X,Y) get_csv_bool((X),(Y),683) +#define get_csv_int_pos683(X,Y) get_csv_int((X),(Y),683) +#define get_csv_llong_pos683(X,Y) get_csv_llong((X),(Y),683) +#define get_csv_float_pos683(X,Y) get_csv_float((X),(Y),683) +#define get_csv_uint_pos684(X,Y) get_csv_uint((X),(Y),684) +#define get_csv_ullong_pos684(X,Y) get_csv_ullong((X),(Y),684) +#define get_csv_ip_pos684(X,Y) get_csv_ip((X),(Y),684) +#define get_csv_ipv6_pos684(X,Y) get_csv_ipv6((X),(Y),684) +#define get_csv_string_pos684(X,Y) get_csv_string((X),(Y),684) +#define get_csv_v_str_pos684(X,Y) get_csv_string((X),(Y),684) +#define get_csv_bool_pos684(X,Y) get_csv_bool((X),(Y),684) +#define get_csv_int_pos684(X,Y) get_csv_int((X),(Y),684) +#define get_csv_llong_pos684(X,Y) get_csv_llong((X),(Y),684) +#define get_csv_float_pos684(X,Y) get_csv_float((X),(Y),684) +#define get_csv_uint_pos685(X,Y) get_csv_uint((X),(Y),685) +#define get_csv_ullong_pos685(X,Y) get_csv_ullong((X),(Y),685) +#define get_csv_ip_pos685(X,Y) get_csv_ip((X),(Y),685) +#define get_csv_ipv6_pos685(X,Y) get_csv_ipv6((X),(Y),685) +#define get_csv_string_pos685(X,Y) get_csv_string((X),(Y),685) +#define get_csv_v_str_pos685(X,Y) get_csv_string((X),(Y),685) +#define get_csv_bool_pos685(X,Y) get_csv_bool((X),(Y),685) +#define get_csv_int_pos685(X,Y) get_csv_int((X),(Y),685) +#define get_csv_llong_pos685(X,Y) get_csv_llong((X),(Y),685) +#define get_csv_float_pos685(X,Y) get_csv_float((X),(Y),685) +#define get_csv_uint_pos686(X,Y) get_csv_uint((X),(Y),686) +#define get_csv_ullong_pos686(X,Y) get_csv_ullong((X),(Y),686) +#define get_csv_ip_pos686(X,Y) get_csv_ip((X),(Y),686) +#define get_csv_ipv6_pos686(X,Y) get_csv_ipv6((X),(Y),686) +#define get_csv_string_pos686(X,Y) get_csv_string((X),(Y),686) +#define get_csv_v_str_pos686(X,Y) get_csv_string((X),(Y),686) +#define get_csv_bool_pos686(X,Y) get_csv_bool((X),(Y),686) +#define get_csv_int_pos686(X,Y) get_csv_int((X),(Y),686) +#define get_csv_llong_pos686(X,Y) get_csv_llong((X),(Y),686) +#define get_csv_float_pos686(X,Y) get_csv_float((X),(Y),686) +#define get_csv_uint_pos687(X,Y) get_csv_uint((X),(Y),687) +#define get_csv_ullong_pos687(X,Y) get_csv_ullong((X),(Y),687) +#define get_csv_ip_pos687(X,Y) get_csv_ip((X),(Y),687) +#define get_csv_ipv6_pos687(X,Y) get_csv_ipv6((X),(Y),687) +#define get_csv_string_pos687(X,Y) get_csv_string((X),(Y),687) +#define get_csv_v_str_pos687(X,Y) get_csv_string((X),(Y),687) +#define get_csv_bool_pos687(X,Y) get_csv_bool((X),(Y),687) +#define get_csv_int_pos687(X,Y) get_csv_int((X),(Y),687) +#define get_csv_llong_pos687(X,Y) get_csv_llong((X),(Y),687) +#define get_csv_float_pos687(X,Y) get_csv_float((X),(Y),687) +#define get_csv_uint_pos688(X,Y) get_csv_uint((X),(Y),688) +#define get_csv_ullong_pos688(X,Y) get_csv_ullong((X),(Y),688) +#define get_csv_ip_pos688(X,Y) get_csv_ip((X),(Y),688) +#define get_csv_ipv6_pos688(X,Y) get_csv_ipv6((X),(Y),688) +#define get_csv_string_pos688(X,Y) get_csv_string((X),(Y),688) +#define get_csv_v_str_pos688(X,Y) get_csv_string((X),(Y),688) +#define get_csv_bool_pos688(X,Y) get_csv_bool((X),(Y),688) +#define get_csv_int_pos688(X,Y) get_csv_int((X),(Y),688) +#define get_csv_llong_pos688(X,Y) get_csv_llong((X),(Y),688) +#define get_csv_float_pos688(X,Y) get_csv_float((X),(Y),688) +#define get_csv_uint_pos689(X,Y) get_csv_uint((X),(Y),689) +#define get_csv_ullong_pos689(X,Y) get_csv_ullong((X),(Y),689) +#define get_csv_ip_pos689(X,Y) get_csv_ip((X),(Y),689) +#define get_csv_ipv6_pos689(X,Y) get_csv_ipv6((X),(Y),689) +#define get_csv_string_pos689(X,Y) get_csv_string((X),(Y),689) +#define get_csv_v_str_pos689(X,Y) get_csv_string((X),(Y),689) +#define get_csv_bool_pos689(X,Y) get_csv_bool((X),(Y),689) +#define get_csv_int_pos689(X,Y) get_csv_int((X),(Y),689) +#define get_csv_llong_pos689(X,Y) get_csv_llong((X),(Y),689) +#define get_csv_float_pos689(X,Y) get_csv_float((X),(Y),689) +#define get_csv_uint_pos690(X,Y) get_csv_uint((X),(Y),690) +#define get_csv_ullong_pos690(X,Y) get_csv_ullong((X),(Y),690) +#define get_csv_ip_pos690(X,Y) get_csv_ip((X),(Y),690) +#define get_csv_ipv6_pos690(X,Y) get_csv_ipv6((X),(Y),690) +#define get_csv_string_pos690(X,Y) get_csv_string((X),(Y),690) +#define get_csv_v_str_pos690(X,Y) get_csv_string((X),(Y),690) +#define get_csv_bool_pos690(X,Y) get_csv_bool((X),(Y),690) +#define get_csv_int_pos690(X,Y) get_csv_int((X),(Y),690) +#define get_csv_llong_pos690(X,Y) get_csv_llong((X),(Y),690) +#define get_csv_float_pos690(X,Y) get_csv_float((X),(Y),690) +#define get_csv_uint_pos691(X,Y) get_csv_uint((X),(Y),691) +#define get_csv_ullong_pos691(X,Y) get_csv_ullong((X),(Y),691) +#define get_csv_ip_pos691(X,Y) get_csv_ip((X),(Y),691) +#define get_csv_ipv6_pos691(X,Y) get_csv_ipv6((X),(Y),691) +#define get_csv_string_pos691(X,Y) get_csv_string((X),(Y),691) +#define get_csv_v_str_pos691(X,Y) get_csv_string((X),(Y),691) +#define get_csv_bool_pos691(X,Y) get_csv_bool((X),(Y),691) +#define get_csv_int_pos691(X,Y) get_csv_int((X),(Y),691) +#define get_csv_llong_pos691(X,Y) get_csv_llong((X),(Y),691) +#define get_csv_float_pos691(X,Y) get_csv_float((X),(Y),691) +#define get_csv_uint_pos692(X,Y) get_csv_uint((X),(Y),692) +#define get_csv_ullong_pos692(X,Y) get_csv_ullong((X),(Y),692) +#define get_csv_ip_pos692(X,Y) get_csv_ip((X),(Y),692) +#define get_csv_ipv6_pos692(X,Y) get_csv_ipv6((X),(Y),692) +#define get_csv_string_pos692(X,Y) get_csv_string((X),(Y),692) +#define get_csv_v_str_pos692(X,Y) get_csv_string((X),(Y),692) +#define get_csv_bool_pos692(X,Y) get_csv_bool((X),(Y),692) +#define get_csv_int_pos692(X,Y) get_csv_int((X),(Y),692) +#define get_csv_llong_pos692(X,Y) get_csv_llong((X),(Y),692) +#define get_csv_float_pos692(X,Y) get_csv_float((X),(Y),692) +#define get_csv_uint_pos693(X,Y) get_csv_uint((X),(Y),693) +#define get_csv_ullong_pos693(X,Y) get_csv_ullong((X),(Y),693) +#define get_csv_ip_pos693(X,Y) get_csv_ip((X),(Y),693) +#define get_csv_ipv6_pos693(X,Y) get_csv_ipv6((X),(Y),693) +#define get_csv_string_pos693(X,Y) get_csv_string((X),(Y),693) +#define get_csv_v_str_pos693(X,Y) get_csv_string((X),(Y),693) +#define get_csv_bool_pos693(X,Y) get_csv_bool((X),(Y),693) +#define get_csv_int_pos693(X,Y) get_csv_int((X),(Y),693) +#define get_csv_llong_pos693(X,Y) get_csv_llong((X),(Y),693) +#define get_csv_float_pos693(X,Y) get_csv_float((X),(Y),693) +#define get_csv_uint_pos694(X,Y) get_csv_uint((X),(Y),694) +#define get_csv_ullong_pos694(X,Y) get_csv_ullong((X),(Y),694) +#define get_csv_ip_pos694(X,Y) get_csv_ip((X),(Y),694) +#define get_csv_ipv6_pos694(X,Y) get_csv_ipv6((X),(Y),694) +#define get_csv_string_pos694(X,Y) get_csv_string((X),(Y),694) +#define get_csv_v_str_pos694(X,Y) get_csv_string((X),(Y),694) +#define get_csv_bool_pos694(X,Y) get_csv_bool((X),(Y),694) +#define get_csv_int_pos694(X,Y) get_csv_int((X),(Y),694) +#define get_csv_llong_pos694(X,Y) get_csv_llong((X),(Y),694) +#define get_csv_float_pos694(X,Y) get_csv_float((X),(Y),694) +#define get_csv_uint_pos695(X,Y) get_csv_uint((X),(Y),695) +#define get_csv_ullong_pos695(X,Y) get_csv_ullong((X),(Y),695) +#define get_csv_ip_pos695(X,Y) get_csv_ip((X),(Y),695) +#define get_csv_ipv6_pos695(X,Y) get_csv_ipv6((X),(Y),695) +#define get_csv_string_pos695(X,Y) get_csv_string((X),(Y),695) +#define get_csv_v_str_pos695(X,Y) get_csv_string((X),(Y),695) +#define get_csv_bool_pos695(X,Y) get_csv_bool((X),(Y),695) +#define get_csv_int_pos695(X,Y) get_csv_int((X),(Y),695) +#define get_csv_llong_pos695(X,Y) get_csv_llong((X),(Y),695) +#define get_csv_float_pos695(X,Y) get_csv_float((X),(Y),695) +#define get_csv_uint_pos696(X,Y) get_csv_uint((X),(Y),696) +#define get_csv_ullong_pos696(X,Y) get_csv_ullong((X),(Y),696) +#define get_csv_ip_pos696(X,Y) get_csv_ip((X),(Y),696) +#define get_csv_ipv6_pos696(X,Y) get_csv_ipv6((X),(Y),696) +#define get_csv_string_pos696(X,Y) get_csv_string((X),(Y),696) +#define get_csv_v_str_pos696(X,Y) get_csv_string((X),(Y),696) +#define get_csv_bool_pos696(X,Y) get_csv_bool((X),(Y),696) +#define get_csv_int_pos696(X,Y) get_csv_int((X),(Y),696) +#define get_csv_llong_pos696(X,Y) get_csv_llong((X),(Y),696) +#define get_csv_float_pos696(X,Y) get_csv_float((X),(Y),696) +#define get_csv_uint_pos697(X,Y) get_csv_uint((X),(Y),697) +#define get_csv_ullong_pos697(X,Y) get_csv_ullong((X),(Y),697) +#define get_csv_ip_pos697(X,Y) get_csv_ip((X),(Y),697) +#define get_csv_ipv6_pos697(X,Y) get_csv_ipv6((X),(Y),697) +#define get_csv_string_pos697(X,Y) get_csv_string((X),(Y),697) +#define get_csv_v_str_pos697(X,Y) get_csv_string((X),(Y),697) +#define get_csv_bool_pos697(X,Y) get_csv_bool((X),(Y),697) +#define get_csv_int_pos697(X,Y) get_csv_int((X),(Y),697) +#define get_csv_llong_pos697(X,Y) get_csv_llong((X),(Y),697) +#define get_csv_float_pos697(X,Y) get_csv_float((X),(Y),697) +#define get_csv_uint_pos698(X,Y) get_csv_uint((X),(Y),698) +#define get_csv_ullong_pos698(X,Y) get_csv_ullong((X),(Y),698) +#define get_csv_ip_pos698(X,Y) get_csv_ip((X),(Y),698) +#define get_csv_ipv6_pos698(X,Y) get_csv_ipv6((X),(Y),698) +#define get_csv_string_pos698(X,Y) get_csv_string((X),(Y),698) +#define get_csv_v_str_pos698(X,Y) get_csv_string((X),(Y),698) +#define get_csv_bool_pos698(X,Y) get_csv_bool((X),(Y),698) +#define get_csv_int_pos698(X,Y) get_csv_int((X),(Y),698) +#define get_csv_llong_pos698(X,Y) get_csv_llong((X),(Y),698) +#define get_csv_float_pos698(X,Y) get_csv_float((X),(Y),698) +#define get_csv_uint_pos699(X,Y) get_csv_uint((X),(Y),699) +#define get_csv_ullong_pos699(X,Y) get_csv_ullong((X),(Y),699) +#define get_csv_ip_pos699(X,Y) get_csv_ip((X),(Y),699) +#define get_csv_ipv6_pos699(X,Y) get_csv_ipv6((X),(Y),699) +#define get_csv_string_pos699(X,Y) get_csv_string((X),(Y),699) +#define get_csv_v_str_pos699(X,Y) get_csv_string((X),(Y),699) +#define get_csv_bool_pos699(X,Y) get_csv_bool((X),(Y),699) +#define get_csv_int_pos699(X,Y) get_csv_int((X),(Y),699) +#define get_csv_llong_pos699(X,Y) get_csv_llong((X),(Y),699) +#define get_csv_float_pos699(X,Y) get_csv_float((X),(Y),699) +#define get_csv_uint_pos700(X,Y) get_csv_uint((X),(Y),700) +#define get_csv_ullong_pos700(X,Y) get_csv_ullong((X),(Y),700) +#define get_csv_ip_pos700(X,Y) get_csv_ip((X),(Y),700) +#define get_csv_ipv6_pos700(X,Y) get_csv_ipv6((X),(Y),700) +#define get_csv_string_pos700(X,Y) get_csv_string((X),(Y),700) +#define get_csv_v_str_pos700(X,Y) get_csv_string((X),(Y),700) +#define get_csv_bool_pos700(X,Y) get_csv_bool((X),(Y),700) +#define get_csv_int_pos700(X,Y) get_csv_int((X),(Y),700) +#define get_csv_llong_pos700(X,Y) get_csv_llong((X),(Y),700) +#define get_csv_float_pos700(X,Y) get_csv_float((X),(Y),700) +#define get_csv_uint_pos701(X,Y) get_csv_uint((X),(Y),701) +#define get_csv_ullong_pos701(X,Y) get_csv_ullong((X),(Y),701) +#define get_csv_ip_pos701(X,Y) get_csv_ip((X),(Y),701) +#define get_csv_ipv6_pos701(X,Y) get_csv_ipv6((X),(Y),701) +#define get_csv_string_pos701(X,Y) get_csv_string((X),(Y),701) +#define get_csv_v_str_pos701(X,Y) get_csv_string((X),(Y),701) +#define get_csv_bool_pos701(X,Y) get_csv_bool((X),(Y),701) +#define get_csv_int_pos701(X,Y) get_csv_int((X),(Y),701) +#define get_csv_llong_pos701(X,Y) get_csv_llong((X),(Y),701) +#define get_csv_float_pos701(X,Y) get_csv_float((X),(Y),701) +#define get_csv_uint_pos702(X,Y) get_csv_uint((X),(Y),702) +#define get_csv_ullong_pos702(X,Y) get_csv_ullong((X),(Y),702) +#define get_csv_ip_pos702(X,Y) get_csv_ip((X),(Y),702) +#define get_csv_ipv6_pos702(X,Y) get_csv_ipv6((X),(Y),702) +#define get_csv_string_pos702(X,Y) get_csv_string((X),(Y),702) +#define get_csv_v_str_pos702(X,Y) get_csv_string((X),(Y),702) +#define get_csv_bool_pos702(X,Y) get_csv_bool((X),(Y),702) +#define get_csv_int_pos702(X,Y) get_csv_int((X),(Y),702) +#define get_csv_llong_pos702(X,Y) get_csv_llong((X),(Y),702) +#define get_csv_float_pos702(X,Y) get_csv_float((X),(Y),702) +#define get_csv_uint_pos703(X,Y) get_csv_uint((X),(Y),703) +#define get_csv_ullong_pos703(X,Y) get_csv_ullong((X),(Y),703) +#define get_csv_ip_pos703(X,Y) get_csv_ip((X),(Y),703) +#define get_csv_ipv6_pos703(X,Y) get_csv_ipv6((X),(Y),703) +#define get_csv_string_pos703(X,Y) get_csv_string((X),(Y),703) +#define get_csv_v_str_pos703(X,Y) get_csv_string((X),(Y),703) +#define get_csv_bool_pos703(X,Y) get_csv_bool((X),(Y),703) +#define get_csv_int_pos703(X,Y) get_csv_int((X),(Y),703) +#define get_csv_llong_pos703(X,Y) get_csv_llong((X),(Y),703) +#define get_csv_float_pos703(X,Y) get_csv_float((X),(Y),703) +#define get_csv_uint_pos704(X,Y) get_csv_uint((X),(Y),704) +#define get_csv_ullong_pos704(X,Y) get_csv_ullong((X),(Y),704) +#define get_csv_ip_pos704(X,Y) get_csv_ip((X),(Y),704) +#define get_csv_ipv6_pos704(X,Y) get_csv_ipv6((X),(Y),704) +#define get_csv_string_pos704(X,Y) get_csv_string((X),(Y),704) +#define get_csv_v_str_pos704(X,Y) get_csv_string((X),(Y),704) +#define get_csv_bool_pos704(X,Y) get_csv_bool((X),(Y),704) +#define get_csv_int_pos704(X,Y) get_csv_int((X),(Y),704) +#define get_csv_llong_pos704(X,Y) get_csv_llong((X),(Y),704) +#define get_csv_float_pos704(X,Y) get_csv_float((X),(Y),704) +#define get_csv_uint_pos705(X,Y) get_csv_uint((X),(Y),705) +#define get_csv_ullong_pos705(X,Y) get_csv_ullong((X),(Y),705) +#define get_csv_ip_pos705(X,Y) get_csv_ip((X),(Y),705) +#define get_csv_ipv6_pos705(X,Y) get_csv_ipv6((X),(Y),705) +#define get_csv_string_pos705(X,Y) get_csv_string((X),(Y),705) +#define get_csv_v_str_pos705(X,Y) get_csv_string((X),(Y),705) +#define get_csv_bool_pos705(X,Y) get_csv_bool((X),(Y),705) +#define get_csv_int_pos705(X,Y) get_csv_int((X),(Y),705) +#define get_csv_llong_pos705(X,Y) get_csv_llong((X),(Y),705) +#define get_csv_float_pos705(X,Y) get_csv_float((X),(Y),705) +#define get_csv_uint_pos706(X,Y) get_csv_uint((X),(Y),706) +#define get_csv_ullong_pos706(X,Y) get_csv_ullong((X),(Y),706) +#define get_csv_ip_pos706(X,Y) get_csv_ip((X),(Y),706) +#define get_csv_ipv6_pos706(X,Y) get_csv_ipv6((X),(Y),706) +#define get_csv_string_pos706(X,Y) get_csv_string((X),(Y),706) +#define get_csv_v_str_pos706(X,Y) get_csv_string((X),(Y),706) +#define get_csv_bool_pos706(X,Y) get_csv_bool((X),(Y),706) +#define get_csv_int_pos706(X,Y) get_csv_int((X),(Y),706) +#define get_csv_llong_pos706(X,Y) get_csv_llong((X),(Y),706) +#define get_csv_float_pos706(X,Y) get_csv_float((X),(Y),706) +#define get_csv_uint_pos707(X,Y) get_csv_uint((X),(Y),707) +#define get_csv_ullong_pos707(X,Y) get_csv_ullong((X),(Y),707) +#define get_csv_ip_pos707(X,Y) get_csv_ip((X),(Y),707) +#define get_csv_ipv6_pos707(X,Y) get_csv_ipv6((X),(Y),707) +#define get_csv_string_pos707(X,Y) get_csv_string((X),(Y),707) +#define get_csv_v_str_pos707(X,Y) get_csv_string((X),(Y),707) +#define get_csv_bool_pos707(X,Y) get_csv_bool((X),(Y),707) +#define get_csv_int_pos707(X,Y) get_csv_int((X),(Y),707) +#define get_csv_llong_pos707(X,Y) get_csv_llong((X),(Y),707) +#define get_csv_float_pos707(X,Y) get_csv_float((X),(Y),707) +#define get_csv_uint_pos708(X,Y) get_csv_uint((X),(Y),708) +#define get_csv_ullong_pos708(X,Y) get_csv_ullong((X),(Y),708) +#define get_csv_ip_pos708(X,Y) get_csv_ip((X),(Y),708) +#define get_csv_ipv6_pos708(X,Y) get_csv_ipv6((X),(Y),708) +#define get_csv_string_pos708(X,Y) get_csv_string((X),(Y),708) +#define get_csv_v_str_pos708(X,Y) get_csv_string((X),(Y),708) +#define get_csv_bool_pos708(X,Y) get_csv_bool((X),(Y),708) +#define get_csv_int_pos708(X,Y) get_csv_int((X),(Y),708) +#define get_csv_llong_pos708(X,Y) get_csv_llong((X),(Y),708) +#define get_csv_float_pos708(X,Y) get_csv_float((X),(Y),708) +#define get_csv_uint_pos709(X,Y) get_csv_uint((X),(Y),709) +#define get_csv_ullong_pos709(X,Y) get_csv_ullong((X),(Y),709) +#define get_csv_ip_pos709(X,Y) get_csv_ip((X),(Y),709) +#define get_csv_ipv6_pos709(X,Y) get_csv_ipv6((X),(Y),709) +#define get_csv_string_pos709(X,Y) get_csv_string((X),(Y),709) +#define get_csv_v_str_pos709(X,Y) get_csv_string((X),(Y),709) +#define get_csv_bool_pos709(X,Y) get_csv_bool((X),(Y),709) +#define get_csv_int_pos709(X,Y) get_csv_int((X),(Y),709) +#define get_csv_llong_pos709(X,Y) get_csv_llong((X),(Y),709) +#define get_csv_float_pos709(X,Y) get_csv_float((X),(Y),709) +#define get_csv_uint_pos710(X,Y) get_csv_uint((X),(Y),710) +#define get_csv_ullong_pos710(X,Y) get_csv_ullong((X),(Y),710) +#define get_csv_ip_pos710(X,Y) get_csv_ip((X),(Y),710) +#define get_csv_ipv6_pos710(X,Y) get_csv_ipv6((X),(Y),710) +#define get_csv_string_pos710(X,Y) get_csv_string((X),(Y),710) +#define get_csv_v_str_pos710(X,Y) get_csv_string((X),(Y),710) +#define get_csv_bool_pos710(X,Y) get_csv_bool((X),(Y),710) +#define get_csv_int_pos710(X,Y) get_csv_int((X),(Y),710) +#define get_csv_llong_pos710(X,Y) get_csv_llong((X),(Y),710) +#define get_csv_float_pos710(X,Y) get_csv_float((X),(Y),710) +#define get_csv_uint_pos711(X,Y) get_csv_uint((X),(Y),711) +#define get_csv_ullong_pos711(X,Y) get_csv_ullong((X),(Y),711) +#define get_csv_ip_pos711(X,Y) get_csv_ip((X),(Y),711) +#define get_csv_ipv6_pos711(X,Y) get_csv_ipv6((X),(Y),711) +#define get_csv_string_pos711(X,Y) get_csv_string((X),(Y),711) +#define get_csv_v_str_pos711(X,Y) get_csv_string((X),(Y),711) +#define get_csv_bool_pos711(X,Y) get_csv_bool((X),(Y),711) +#define get_csv_int_pos711(X,Y) get_csv_int((X),(Y),711) +#define get_csv_llong_pos711(X,Y) get_csv_llong((X),(Y),711) +#define get_csv_float_pos711(X,Y) get_csv_float((X),(Y),711) +#define get_csv_uint_pos712(X,Y) get_csv_uint((X),(Y),712) +#define get_csv_ullong_pos712(X,Y) get_csv_ullong((X),(Y),712) +#define get_csv_ip_pos712(X,Y) get_csv_ip((X),(Y),712) +#define get_csv_ipv6_pos712(X,Y) get_csv_ipv6((X),(Y),712) +#define get_csv_string_pos712(X,Y) get_csv_string((X),(Y),712) +#define get_csv_v_str_pos712(X,Y) get_csv_string((X),(Y),712) +#define get_csv_bool_pos712(X,Y) get_csv_bool((X),(Y),712) +#define get_csv_int_pos712(X,Y) get_csv_int((X),(Y),712) +#define get_csv_llong_pos712(X,Y) get_csv_llong((X),(Y),712) +#define get_csv_float_pos712(X,Y) get_csv_float((X),(Y),712) +#define get_csv_uint_pos713(X,Y) get_csv_uint((X),(Y),713) +#define get_csv_ullong_pos713(X,Y) get_csv_ullong((X),(Y),713) +#define get_csv_ip_pos713(X,Y) get_csv_ip((X),(Y),713) +#define get_csv_ipv6_pos713(X,Y) get_csv_ipv6((X),(Y),713) +#define get_csv_string_pos713(X,Y) get_csv_string((X),(Y),713) +#define get_csv_v_str_pos713(X,Y) get_csv_string((X),(Y),713) +#define get_csv_bool_pos713(X,Y) get_csv_bool((X),(Y),713) +#define get_csv_int_pos713(X,Y) get_csv_int((X),(Y),713) +#define get_csv_llong_pos713(X,Y) get_csv_llong((X),(Y),713) +#define get_csv_float_pos713(X,Y) get_csv_float((X),(Y),713) +#define get_csv_uint_pos714(X,Y) get_csv_uint((X),(Y),714) +#define get_csv_ullong_pos714(X,Y) get_csv_ullong((X),(Y),714) +#define get_csv_ip_pos714(X,Y) get_csv_ip((X),(Y),714) +#define get_csv_ipv6_pos714(X,Y) get_csv_ipv6((X),(Y),714) +#define get_csv_string_pos714(X,Y) get_csv_string((X),(Y),714) +#define get_csv_v_str_pos714(X,Y) get_csv_string((X),(Y),714) +#define get_csv_bool_pos714(X,Y) get_csv_bool((X),(Y),714) +#define get_csv_int_pos714(X,Y) get_csv_int((X),(Y),714) +#define get_csv_llong_pos714(X,Y) get_csv_llong((X),(Y),714) +#define get_csv_float_pos714(X,Y) get_csv_float((X),(Y),714) +#define get_csv_uint_pos715(X,Y) get_csv_uint((X),(Y),715) +#define get_csv_ullong_pos715(X,Y) get_csv_ullong((X),(Y),715) +#define get_csv_ip_pos715(X,Y) get_csv_ip((X),(Y),715) +#define get_csv_ipv6_pos715(X,Y) get_csv_ipv6((X),(Y),715) +#define get_csv_string_pos715(X,Y) get_csv_string((X),(Y),715) +#define get_csv_v_str_pos715(X,Y) get_csv_string((X),(Y),715) +#define get_csv_bool_pos715(X,Y) get_csv_bool((X),(Y),715) +#define get_csv_int_pos715(X,Y) get_csv_int((X),(Y),715) +#define get_csv_llong_pos715(X,Y) get_csv_llong((X),(Y),715) +#define get_csv_float_pos715(X,Y) get_csv_float((X),(Y),715) +#define get_csv_uint_pos716(X,Y) get_csv_uint((X),(Y),716) +#define get_csv_ullong_pos716(X,Y) get_csv_ullong((X),(Y),716) +#define get_csv_ip_pos716(X,Y) get_csv_ip((X),(Y),716) +#define get_csv_ipv6_pos716(X,Y) get_csv_ipv6((X),(Y),716) +#define get_csv_string_pos716(X,Y) get_csv_string((X),(Y),716) +#define get_csv_v_str_pos716(X,Y) get_csv_string((X),(Y),716) +#define get_csv_bool_pos716(X,Y) get_csv_bool((X),(Y),716) +#define get_csv_int_pos716(X,Y) get_csv_int((X),(Y),716) +#define get_csv_llong_pos716(X,Y) get_csv_llong((X),(Y),716) +#define get_csv_float_pos716(X,Y) get_csv_float((X),(Y),716) +#define get_csv_uint_pos717(X,Y) get_csv_uint((X),(Y),717) +#define get_csv_ullong_pos717(X,Y) get_csv_ullong((X),(Y),717) +#define get_csv_ip_pos717(X,Y) get_csv_ip((X),(Y),717) +#define get_csv_ipv6_pos717(X,Y) get_csv_ipv6((X),(Y),717) +#define get_csv_string_pos717(X,Y) get_csv_string((X),(Y),717) +#define get_csv_v_str_pos717(X,Y) get_csv_string((X),(Y),717) +#define get_csv_bool_pos717(X,Y) get_csv_bool((X),(Y),717) +#define get_csv_int_pos717(X,Y) get_csv_int((X),(Y),717) +#define get_csv_llong_pos717(X,Y) get_csv_llong((X),(Y),717) +#define get_csv_float_pos717(X,Y) get_csv_float((X),(Y),717) +#define get_csv_uint_pos718(X,Y) get_csv_uint((X),(Y),718) +#define get_csv_ullong_pos718(X,Y) get_csv_ullong((X),(Y),718) +#define get_csv_ip_pos718(X,Y) get_csv_ip((X),(Y),718) +#define get_csv_ipv6_pos718(X,Y) get_csv_ipv6((X),(Y),718) +#define get_csv_string_pos718(X,Y) get_csv_string((X),(Y),718) +#define get_csv_v_str_pos718(X,Y) get_csv_string((X),(Y),718) +#define get_csv_bool_pos718(X,Y) get_csv_bool((X),(Y),718) +#define get_csv_int_pos718(X,Y) get_csv_int((X),(Y),718) +#define get_csv_llong_pos718(X,Y) get_csv_llong((X),(Y),718) +#define get_csv_float_pos718(X,Y) get_csv_float((X),(Y),718) +#define get_csv_uint_pos719(X,Y) get_csv_uint((X),(Y),719) +#define get_csv_ullong_pos719(X,Y) get_csv_ullong((X),(Y),719) +#define get_csv_ip_pos719(X,Y) get_csv_ip((X),(Y),719) +#define get_csv_ipv6_pos719(X,Y) get_csv_ipv6((X),(Y),719) +#define get_csv_string_pos719(X,Y) get_csv_string((X),(Y),719) +#define get_csv_v_str_pos719(X,Y) get_csv_string((X),(Y),719) +#define get_csv_bool_pos719(X,Y) get_csv_bool((X),(Y),719) +#define get_csv_int_pos719(X,Y) get_csv_int((X),(Y),719) +#define get_csv_llong_pos719(X,Y) get_csv_llong((X),(Y),719) +#define get_csv_float_pos719(X,Y) get_csv_float((X),(Y),719) +#define get_csv_uint_pos720(X,Y) get_csv_uint((X),(Y),720) +#define get_csv_ullong_pos720(X,Y) get_csv_ullong((X),(Y),720) +#define get_csv_ip_pos720(X,Y) get_csv_ip((X),(Y),720) +#define get_csv_ipv6_pos720(X,Y) get_csv_ipv6((X),(Y),720) +#define get_csv_string_pos720(X,Y) get_csv_string((X),(Y),720) +#define get_csv_v_str_pos720(X,Y) get_csv_string((X),(Y),720) +#define get_csv_bool_pos720(X,Y) get_csv_bool((X),(Y),720) +#define get_csv_int_pos720(X,Y) get_csv_int((X),(Y),720) +#define get_csv_llong_pos720(X,Y) get_csv_llong((X),(Y),720) +#define get_csv_float_pos720(X,Y) get_csv_float((X),(Y),720) +#define get_csv_uint_pos721(X,Y) get_csv_uint((X),(Y),721) +#define get_csv_ullong_pos721(X,Y) get_csv_ullong((X),(Y),721) +#define get_csv_ip_pos721(X,Y) get_csv_ip((X),(Y),721) +#define get_csv_ipv6_pos721(X,Y) get_csv_ipv6((X),(Y),721) +#define get_csv_string_pos721(X,Y) get_csv_string((X),(Y),721) +#define get_csv_v_str_pos721(X,Y) get_csv_string((X),(Y),721) +#define get_csv_bool_pos721(X,Y) get_csv_bool((X),(Y),721) +#define get_csv_int_pos721(X,Y) get_csv_int((X),(Y),721) +#define get_csv_llong_pos721(X,Y) get_csv_llong((X),(Y),721) +#define get_csv_float_pos721(X,Y) get_csv_float((X),(Y),721) +#define get_csv_uint_pos722(X,Y) get_csv_uint((X),(Y),722) +#define get_csv_ullong_pos722(X,Y) get_csv_ullong((X),(Y),722) +#define get_csv_ip_pos722(X,Y) get_csv_ip((X),(Y),722) +#define get_csv_ipv6_pos722(X,Y) get_csv_ipv6((X),(Y),722) +#define get_csv_string_pos722(X,Y) get_csv_string((X),(Y),722) +#define get_csv_v_str_pos722(X,Y) get_csv_string((X),(Y),722) +#define get_csv_bool_pos722(X,Y) get_csv_bool((X),(Y),722) +#define get_csv_int_pos722(X,Y) get_csv_int((X),(Y),722) +#define get_csv_llong_pos722(X,Y) get_csv_llong((X),(Y),722) +#define get_csv_float_pos722(X,Y) get_csv_float((X),(Y),722) +#define get_csv_uint_pos723(X,Y) get_csv_uint((X),(Y),723) +#define get_csv_ullong_pos723(X,Y) get_csv_ullong((X),(Y),723) +#define get_csv_ip_pos723(X,Y) get_csv_ip((X),(Y),723) +#define get_csv_ipv6_pos723(X,Y) get_csv_ipv6((X),(Y),723) +#define get_csv_string_pos723(X,Y) get_csv_string((X),(Y),723) +#define get_csv_v_str_pos723(X,Y) get_csv_string((X),(Y),723) +#define get_csv_bool_pos723(X,Y) get_csv_bool((X),(Y),723) +#define get_csv_int_pos723(X,Y) get_csv_int((X),(Y),723) +#define get_csv_llong_pos723(X,Y) get_csv_llong((X),(Y),723) +#define get_csv_float_pos723(X,Y) get_csv_float((X),(Y),723) +#define get_csv_uint_pos724(X,Y) get_csv_uint((X),(Y),724) +#define get_csv_ullong_pos724(X,Y) get_csv_ullong((X),(Y),724) +#define get_csv_ip_pos724(X,Y) get_csv_ip((X),(Y),724) +#define get_csv_ipv6_pos724(X,Y) get_csv_ipv6((X),(Y),724) +#define get_csv_string_pos724(X,Y) get_csv_string((X),(Y),724) +#define get_csv_v_str_pos724(X,Y) get_csv_string((X),(Y),724) +#define get_csv_bool_pos724(X,Y) get_csv_bool((X),(Y),724) +#define get_csv_int_pos724(X,Y) get_csv_int((X),(Y),724) +#define get_csv_llong_pos724(X,Y) get_csv_llong((X),(Y),724) +#define get_csv_float_pos724(X,Y) get_csv_float((X),(Y),724) +#define get_csv_uint_pos725(X,Y) get_csv_uint((X),(Y),725) +#define get_csv_ullong_pos725(X,Y) get_csv_ullong((X),(Y),725) +#define get_csv_ip_pos725(X,Y) get_csv_ip((X),(Y),725) +#define get_csv_ipv6_pos725(X,Y) get_csv_ipv6((X),(Y),725) +#define get_csv_string_pos725(X,Y) get_csv_string((X),(Y),725) +#define get_csv_v_str_pos725(X,Y) get_csv_string((X),(Y),725) +#define get_csv_bool_pos725(X,Y) get_csv_bool((X),(Y),725) +#define get_csv_int_pos725(X,Y) get_csv_int((X),(Y),725) +#define get_csv_llong_pos725(X,Y) get_csv_llong((X),(Y),725) +#define get_csv_float_pos725(X,Y) get_csv_float((X),(Y),725) +#define get_csv_uint_pos726(X,Y) get_csv_uint((X),(Y),726) +#define get_csv_ullong_pos726(X,Y) get_csv_ullong((X),(Y),726) +#define get_csv_ip_pos726(X,Y) get_csv_ip((X),(Y),726) +#define get_csv_ipv6_pos726(X,Y) get_csv_ipv6((X),(Y),726) +#define get_csv_string_pos726(X,Y) get_csv_string((X),(Y),726) +#define get_csv_v_str_pos726(X,Y) get_csv_string((X),(Y),726) +#define get_csv_bool_pos726(X,Y) get_csv_bool((X),(Y),726) +#define get_csv_int_pos726(X,Y) get_csv_int((X),(Y),726) +#define get_csv_llong_pos726(X,Y) get_csv_llong((X),(Y),726) +#define get_csv_float_pos726(X,Y) get_csv_float((X),(Y),726) +#define get_csv_uint_pos727(X,Y) get_csv_uint((X),(Y),727) +#define get_csv_ullong_pos727(X,Y) get_csv_ullong((X),(Y),727) +#define get_csv_ip_pos727(X,Y) get_csv_ip((X),(Y),727) +#define get_csv_ipv6_pos727(X,Y) get_csv_ipv6((X),(Y),727) +#define get_csv_string_pos727(X,Y) get_csv_string((X),(Y),727) +#define get_csv_v_str_pos727(X,Y) get_csv_string((X),(Y),727) +#define get_csv_bool_pos727(X,Y) get_csv_bool((X),(Y),727) +#define get_csv_int_pos727(X,Y) get_csv_int((X),(Y),727) +#define get_csv_llong_pos727(X,Y) get_csv_llong((X),(Y),727) +#define get_csv_float_pos727(X,Y) get_csv_float((X),(Y),727) +#define get_csv_uint_pos728(X,Y) get_csv_uint((X),(Y),728) +#define get_csv_ullong_pos728(X,Y) get_csv_ullong((X),(Y),728) +#define get_csv_ip_pos728(X,Y) get_csv_ip((X),(Y),728) +#define get_csv_ipv6_pos728(X,Y) get_csv_ipv6((X),(Y),728) +#define get_csv_string_pos728(X,Y) get_csv_string((X),(Y),728) +#define get_csv_v_str_pos728(X,Y) get_csv_string((X),(Y),728) +#define get_csv_bool_pos728(X,Y) get_csv_bool((X),(Y),728) +#define get_csv_int_pos728(X,Y) get_csv_int((X),(Y),728) +#define get_csv_llong_pos728(X,Y) get_csv_llong((X),(Y),728) +#define get_csv_float_pos728(X,Y) get_csv_float((X),(Y),728) +#define get_csv_uint_pos729(X,Y) get_csv_uint((X),(Y),729) +#define get_csv_ullong_pos729(X,Y) get_csv_ullong((X),(Y),729) +#define get_csv_ip_pos729(X,Y) get_csv_ip((X),(Y),729) +#define get_csv_ipv6_pos729(X,Y) get_csv_ipv6((X),(Y),729) +#define get_csv_string_pos729(X,Y) get_csv_string((X),(Y),729) +#define get_csv_v_str_pos729(X,Y) get_csv_string((X),(Y),729) +#define get_csv_bool_pos729(X,Y) get_csv_bool((X),(Y),729) +#define get_csv_int_pos729(X,Y) get_csv_int((X),(Y),729) +#define get_csv_llong_pos729(X,Y) get_csv_llong((X),(Y),729) +#define get_csv_float_pos729(X,Y) get_csv_float((X),(Y),729) +#define get_csv_uint_pos730(X,Y) get_csv_uint((X),(Y),730) +#define get_csv_ullong_pos730(X,Y) get_csv_ullong((X),(Y),730) +#define get_csv_ip_pos730(X,Y) get_csv_ip((X),(Y),730) +#define get_csv_ipv6_pos730(X,Y) get_csv_ipv6((X),(Y),730) +#define get_csv_string_pos730(X,Y) get_csv_string((X),(Y),730) +#define get_csv_v_str_pos730(X,Y) get_csv_string((X),(Y),730) +#define get_csv_bool_pos730(X,Y) get_csv_bool((X),(Y),730) +#define get_csv_int_pos730(X,Y) get_csv_int((X),(Y),730) +#define get_csv_llong_pos730(X,Y) get_csv_llong((X),(Y),730) +#define get_csv_float_pos730(X,Y) get_csv_float((X),(Y),730) +#define get_csv_uint_pos731(X,Y) get_csv_uint((X),(Y),731) +#define get_csv_ullong_pos731(X,Y) get_csv_ullong((X),(Y),731) +#define get_csv_ip_pos731(X,Y) get_csv_ip((X),(Y),731) +#define get_csv_ipv6_pos731(X,Y) get_csv_ipv6((X),(Y),731) +#define get_csv_string_pos731(X,Y) get_csv_string((X),(Y),731) +#define get_csv_v_str_pos731(X,Y) get_csv_string((X),(Y),731) +#define get_csv_bool_pos731(X,Y) get_csv_bool((X),(Y),731) +#define get_csv_int_pos731(X,Y) get_csv_int((X),(Y),731) +#define get_csv_llong_pos731(X,Y) get_csv_llong((X),(Y),731) +#define get_csv_float_pos731(X,Y) get_csv_float((X),(Y),731) +#define get_csv_uint_pos732(X,Y) get_csv_uint((X),(Y),732) +#define get_csv_ullong_pos732(X,Y) get_csv_ullong((X),(Y),732) +#define get_csv_ip_pos732(X,Y) get_csv_ip((X),(Y),732) +#define get_csv_ipv6_pos732(X,Y) get_csv_ipv6((X),(Y),732) +#define get_csv_string_pos732(X,Y) get_csv_string((X),(Y),732) +#define get_csv_v_str_pos732(X,Y) get_csv_string((X),(Y),732) +#define get_csv_bool_pos732(X,Y) get_csv_bool((X),(Y),732) +#define get_csv_int_pos732(X,Y) get_csv_int((X),(Y),732) +#define get_csv_llong_pos732(X,Y) get_csv_llong((X),(Y),732) +#define get_csv_float_pos732(X,Y) get_csv_float((X),(Y),732) +#define get_csv_uint_pos733(X,Y) get_csv_uint((X),(Y),733) +#define get_csv_ullong_pos733(X,Y) get_csv_ullong((X),(Y),733) +#define get_csv_ip_pos733(X,Y) get_csv_ip((X),(Y),733) +#define get_csv_ipv6_pos733(X,Y) get_csv_ipv6((X),(Y),733) +#define get_csv_string_pos733(X,Y) get_csv_string((X),(Y),733) +#define get_csv_v_str_pos733(X,Y) get_csv_string((X),(Y),733) +#define get_csv_bool_pos733(X,Y) get_csv_bool((X),(Y),733) +#define get_csv_int_pos733(X,Y) get_csv_int((X),(Y),733) +#define get_csv_llong_pos733(X,Y) get_csv_llong((X),(Y),733) +#define get_csv_float_pos733(X,Y) get_csv_float((X),(Y),733) +#define get_csv_uint_pos734(X,Y) get_csv_uint((X),(Y),734) +#define get_csv_ullong_pos734(X,Y) get_csv_ullong((X),(Y),734) +#define get_csv_ip_pos734(X,Y) get_csv_ip((X),(Y),734) +#define get_csv_ipv6_pos734(X,Y) get_csv_ipv6((X),(Y),734) +#define get_csv_string_pos734(X,Y) get_csv_string((X),(Y),734) +#define get_csv_v_str_pos734(X,Y) get_csv_string((X),(Y),734) +#define get_csv_bool_pos734(X,Y) get_csv_bool((X),(Y),734) +#define get_csv_int_pos734(X,Y) get_csv_int((X),(Y),734) +#define get_csv_llong_pos734(X,Y) get_csv_llong((X),(Y),734) +#define get_csv_float_pos734(X,Y) get_csv_float((X),(Y),734) +#define get_csv_uint_pos735(X,Y) get_csv_uint((X),(Y),735) +#define get_csv_ullong_pos735(X,Y) get_csv_ullong((X),(Y),735) +#define get_csv_ip_pos735(X,Y) get_csv_ip((X),(Y),735) +#define get_csv_ipv6_pos735(X,Y) get_csv_ipv6((X),(Y),735) +#define get_csv_string_pos735(X,Y) get_csv_string((X),(Y),735) +#define get_csv_v_str_pos735(X,Y) get_csv_string((X),(Y),735) +#define get_csv_bool_pos735(X,Y) get_csv_bool((X),(Y),735) +#define get_csv_int_pos735(X,Y) get_csv_int((X),(Y),735) +#define get_csv_llong_pos735(X,Y) get_csv_llong((X),(Y),735) +#define get_csv_float_pos735(X,Y) get_csv_float((X),(Y),735) +#define get_csv_uint_pos736(X,Y) get_csv_uint((X),(Y),736) +#define get_csv_ullong_pos736(X,Y) get_csv_ullong((X),(Y),736) +#define get_csv_ip_pos736(X,Y) get_csv_ip((X),(Y),736) +#define get_csv_ipv6_pos736(X,Y) get_csv_ipv6((X),(Y),736) +#define get_csv_string_pos736(X,Y) get_csv_string((X),(Y),736) +#define get_csv_v_str_pos736(X,Y) get_csv_string((X),(Y),736) +#define get_csv_bool_pos736(X,Y) get_csv_bool((X),(Y),736) +#define get_csv_int_pos736(X,Y) get_csv_int((X),(Y),736) +#define get_csv_llong_pos736(X,Y) get_csv_llong((X),(Y),736) +#define get_csv_float_pos736(X,Y) get_csv_float((X),(Y),736) +#define get_csv_uint_pos737(X,Y) get_csv_uint((X),(Y),737) +#define get_csv_ullong_pos737(X,Y) get_csv_ullong((X),(Y),737) +#define get_csv_ip_pos737(X,Y) get_csv_ip((X),(Y),737) +#define get_csv_ipv6_pos737(X,Y) get_csv_ipv6((X),(Y),737) +#define get_csv_string_pos737(X,Y) get_csv_string((X),(Y),737) +#define get_csv_v_str_pos737(X,Y) get_csv_string((X),(Y),737) +#define get_csv_bool_pos737(X,Y) get_csv_bool((X),(Y),737) +#define get_csv_int_pos737(X,Y) get_csv_int((X),(Y),737) +#define get_csv_llong_pos737(X,Y) get_csv_llong((X),(Y),737) +#define get_csv_float_pos737(X,Y) get_csv_float((X),(Y),737) +#define get_csv_uint_pos738(X,Y) get_csv_uint((X),(Y),738) +#define get_csv_ullong_pos738(X,Y) get_csv_ullong((X),(Y),738) +#define get_csv_ip_pos738(X,Y) get_csv_ip((X),(Y),738) +#define get_csv_ipv6_pos738(X,Y) get_csv_ipv6((X),(Y),738) +#define get_csv_string_pos738(X,Y) get_csv_string((X),(Y),738) +#define get_csv_v_str_pos738(X,Y) get_csv_string((X),(Y),738) +#define get_csv_bool_pos738(X,Y) get_csv_bool((X),(Y),738) +#define get_csv_int_pos738(X,Y) get_csv_int((X),(Y),738) +#define get_csv_llong_pos738(X,Y) get_csv_llong((X),(Y),738) +#define get_csv_float_pos738(X,Y) get_csv_float((X),(Y),738) +#define get_csv_uint_pos739(X,Y) get_csv_uint((X),(Y),739) +#define get_csv_ullong_pos739(X,Y) get_csv_ullong((X),(Y),739) +#define get_csv_ip_pos739(X,Y) get_csv_ip((X),(Y),739) +#define get_csv_ipv6_pos739(X,Y) get_csv_ipv6((X),(Y),739) +#define get_csv_string_pos739(X,Y) get_csv_string((X),(Y),739) +#define get_csv_v_str_pos739(X,Y) get_csv_string((X),(Y),739) +#define get_csv_bool_pos739(X,Y) get_csv_bool((X),(Y),739) +#define get_csv_int_pos739(X,Y) get_csv_int((X),(Y),739) +#define get_csv_llong_pos739(X,Y) get_csv_llong((X),(Y),739) +#define get_csv_float_pos739(X,Y) get_csv_float((X),(Y),739) +#define get_csv_uint_pos740(X,Y) get_csv_uint((X),(Y),740) +#define get_csv_ullong_pos740(X,Y) get_csv_ullong((X),(Y),740) +#define get_csv_ip_pos740(X,Y) get_csv_ip((X),(Y),740) +#define get_csv_ipv6_pos740(X,Y) get_csv_ipv6((X),(Y),740) +#define get_csv_string_pos740(X,Y) get_csv_string((X),(Y),740) +#define get_csv_v_str_pos740(X,Y) get_csv_string((X),(Y),740) +#define get_csv_bool_pos740(X,Y) get_csv_bool((X),(Y),740) +#define get_csv_int_pos740(X,Y) get_csv_int((X),(Y),740) +#define get_csv_llong_pos740(X,Y) get_csv_llong((X),(Y),740) +#define get_csv_float_pos740(X,Y) get_csv_float((X),(Y),740) +#define get_csv_uint_pos741(X,Y) get_csv_uint((X),(Y),741) +#define get_csv_ullong_pos741(X,Y) get_csv_ullong((X),(Y),741) +#define get_csv_ip_pos741(X,Y) get_csv_ip((X),(Y),741) +#define get_csv_ipv6_pos741(X,Y) get_csv_ipv6((X),(Y),741) +#define get_csv_string_pos741(X,Y) get_csv_string((X),(Y),741) +#define get_csv_v_str_pos741(X,Y) get_csv_string((X),(Y),741) +#define get_csv_bool_pos741(X,Y) get_csv_bool((X),(Y),741) +#define get_csv_int_pos741(X,Y) get_csv_int((X),(Y),741) +#define get_csv_llong_pos741(X,Y) get_csv_llong((X),(Y),741) +#define get_csv_float_pos741(X,Y) get_csv_float((X),(Y),741) +#define get_csv_uint_pos742(X,Y) get_csv_uint((X),(Y),742) +#define get_csv_ullong_pos742(X,Y) get_csv_ullong((X),(Y),742) +#define get_csv_ip_pos742(X,Y) get_csv_ip((X),(Y),742) +#define get_csv_ipv6_pos742(X,Y) get_csv_ipv6((X),(Y),742) +#define get_csv_string_pos742(X,Y) get_csv_string((X),(Y),742) +#define get_csv_v_str_pos742(X,Y) get_csv_string((X),(Y),742) +#define get_csv_bool_pos742(X,Y) get_csv_bool((X),(Y),742) +#define get_csv_int_pos742(X,Y) get_csv_int((X),(Y),742) +#define get_csv_llong_pos742(X,Y) get_csv_llong((X),(Y),742) +#define get_csv_float_pos742(X,Y) get_csv_float((X),(Y),742) +#define get_csv_uint_pos743(X,Y) get_csv_uint((X),(Y),743) +#define get_csv_ullong_pos743(X,Y) get_csv_ullong((X),(Y),743) +#define get_csv_ip_pos743(X,Y) get_csv_ip((X),(Y),743) +#define get_csv_ipv6_pos743(X,Y) get_csv_ipv6((X),(Y),743) +#define get_csv_string_pos743(X,Y) get_csv_string((X),(Y),743) +#define get_csv_v_str_pos743(X,Y) get_csv_string((X),(Y),743) +#define get_csv_bool_pos743(X,Y) get_csv_bool((X),(Y),743) +#define get_csv_int_pos743(X,Y) get_csv_int((X),(Y),743) +#define get_csv_llong_pos743(X,Y) get_csv_llong((X),(Y),743) +#define get_csv_float_pos743(X,Y) get_csv_float((X),(Y),743) +#define get_csv_uint_pos744(X,Y) get_csv_uint((X),(Y),744) +#define get_csv_ullong_pos744(X,Y) get_csv_ullong((X),(Y),744) +#define get_csv_ip_pos744(X,Y) get_csv_ip((X),(Y),744) +#define get_csv_ipv6_pos744(X,Y) get_csv_ipv6((X),(Y),744) +#define get_csv_string_pos744(X,Y) get_csv_string((X),(Y),744) +#define get_csv_v_str_pos744(X,Y) get_csv_string((X),(Y),744) +#define get_csv_bool_pos744(X,Y) get_csv_bool((X),(Y),744) +#define get_csv_int_pos744(X,Y) get_csv_int((X),(Y),744) +#define get_csv_llong_pos744(X,Y) get_csv_llong((X),(Y),744) +#define get_csv_float_pos744(X,Y) get_csv_float((X),(Y),744) +#define get_csv_uint_pos745(X,Y) get_csv_uint((X),(Y),745) +#define get_csv_ullong_pos745(X,Y) get_csv_ullong((X),(Y),745) +#define get_csv_ip_pos745(X,Y) get_csv_ip((X),(Y),745) +#define get_csv_ipv6_pos745(X,Y) get_csv_ipv6((X),(Y),745) +#define get_csv_string_pos745(X,Y) get_csv_string((X),(Y),745) +#define get_csv_v_str_pos745(X,Y) get_csv_string((X),(Y),745) +#define get_csv_bool_pos745(X,Y) get_csv_bool((X),(Y),745) +#define get_csv_int_pos745(X,Y) get_csv_int((X),(Y),745) +#define get_csv_llong_pos745(X,Y) get_csv_llong((X),(Y),745) +#define get_csv_float_pos745(X,Y) get_csv_float((X),(Y),745) +#define get_csv_uint_pos746(X,Y) get_csv_uint((X),(Y),746) +#define get_csv_ullong_pos746(X,Y) get_csv_ullong((X),(Y),746) +#define get_csv_ip_pos746(X,Y) get_csv_ip((X),(Y),746) +#define get_csv_ipv6_pos746(X,Y) get_csv_ipv6((X),(Y),746) +#define get_csv_string_pos746(X,Y) get_csv_string((X),(Y),746) +#define get_csv_v_str_pos746(X,Y) get_csv_string((X),(Y),746) +#define get_csv_bool_pos746(X,Y) get_csv_bool((X),(Y),746) +#define get_csv_int_pos746(X,Y) get_csv_int((X),(Y),746) +#define get_csv_llong_pos746(X,Y) get_csv_llong((X),(Y),746) +#define get_csv_float_pos746(X,Y) get_csv_float((X),(Y),746) +#define get_csv_uint_pos747(X,Y) get_csv_uint((X),(Y),747) +#define get_csv_ullong_pos747(X,Y) get_csv_ullong((X),(Y),747) +#define get_csv_ip_pos747(X,Y) get_csv_ip((X),(Y),747) +#define get_csv_ipv6_pos747(X,Y) get_csv_ipv6((X),(Y),747) +#define get_csv_string_pos747(X,Y) get_csv_string((X),(Y),747) +#define get_csv_v_str_pos747(X,Y) get_csv_string((X),(Y),747) +#define get_csv_bool_pos747(X,Y) get_csv_bool((X),(Y),747) +#define get_csv_int_pos747(X,Y) get_csv_int((X),(Y),747) +#define get_csv_llong_pos747(X,Y) get_csv_llong((X),(Y),747) +#define get_csv_float_pos747(X,Y) get_csv_float((X),(Y),747) +#define get_csv_uint_pos748(X,Y) get_csv_uint((X),(Y),748) +#define get_csv_ullong_pos748(X,Y) get_csv_ullong((X),(Y),748) +#define get_csv_ip_pos748(X,Y) get_csv_ip((X),(Y),748) +#define get_csv_ipv6_pos748(X,Y) get_csv_ipv6((X),(Y),748) +#define get_csv_string_pos748(X,Y) get_csv_string((X),(Y),748) +#define get_csv_v_str_pos748(X,Y) get_csv_string((X),(Y),748) +#define get_csv_bool_pos748(X,Y) get_csv_bool((X),(Y),748) +#define get_csv_int_pos748(X,Y) get_csv_int((X),(Y),748) +#define get_csv_llong_pos748(X,Y) get_csv_llong((X),(Y),748) +#define get_csv_float_pos748(X,Y) get_csv_float((X),(Y),748) +#define get_csv_uint_pos749(X,Y) get_csv_uint((X),(Y),749) +#define get_csv_ullong_pos749(X,Y) get_csv_ullong((X),(Y),749) +#define get_csv_ip_pos749(X,Y) get_csv_ip((X),(Y),749) +#define get_csv_ipv6_pos749(X,Y) get_csv_ipv6((X),(Y),749) +#define get_csv_string_pos749(X,Y) get_csv_string((X),(Y),749) +#define get_csv_v_str_pos749(X,Y) get_csv_string((X),(Y),749) +#define get_csv_bool_pos749(X,Y) get_csv_bool((X),(Y),749) +#define get_csv_int_pos749(X,Y) get_csv_int((X),(Y),749) +#define get_csv_llong_pos749(X,Y) get_csv_llong((X),(Y),749) +#define get_csv_float_pos749(X,Y) get_csv_float((X),(Y),749) +#define get_csv_uint_pos750(X,Y) get_csv_uint((X),(Y),750) +#define get_csv_ullong_pos750(X,Y) get_csv_ullong((X),(Y),750) +#define get_csv_ip_pos750(X,Y) get_csv_ip((X),(Y),750) +#define get_csv_ipv6_pos750(X,Y) get_csv_ipv6((X),(Y),750) +#define get_csv_string_pos750(X,Y) get_csv_string((X),(Y),750) +#define get_csv_v_str_pos750(X,Y) get_csv_string((X),(Y),750) +#define get_csv_bool_pos750(X,Y) get_csv_bool((X),(Y),750) +#define get_csv_int_pos750(X,Y) get_csv_int((X),(Y),750) +#define get_csv_llong_pos750(X,Y) get_csv_llong((X),(Y),750) +#define get_csv_float_pos750(X,Y) get_csv_float((X),(Y),750) +#define get_csv_uint_pos751(X,Y) get_csv_uint((X),(Y),751) +#define get_csv_ullong_pos751(X,Y) get_csv_ullong((X),(Y),751) +#define get_csv_ip_pos751(X,Y) get_csv_ip((X),(Y),751) +#define get_csv_ipv6_pos751(X,Y) get_csv_ipv6((X),(Y),751) +#define get_csv_string_pos751(X,Y) get_csv_string((X),(Y),751) +#define get_csv_v_str_pos751(X,Y) get_csv_string((X),(Y),751) +#define get_csv_bool_pos751(X,Y) get_csv_bool((X),(Y),751) +#define get_csv_int_pos751(X,Y) get_csv_int((X),(Y),751) +#define get_csv_llong_pos751(X,Y) get_csv_llong((X),(Y),751) +#define get_csv_float_pos751(X,Y) get_csv_float((X),(Y),751) +#define get_csv_uint_pos752(X,Y) get_csv_uint((X),(Y),752) +#define get_csv_ullong_pos752(X,Y) get_csv_ullong((X),(Y),752) +#define get_csv_ip_pos752(X,Y) get_csv_ip((X),(Y),752) +#define get_csv_ipv6_pos752(X,Y) get_csv_ipv6((X),(Y),752) +#define get_csv_string_pos752(X,Y) get_csv_string((X),(Y),752) +#define get_csv_v_str_pos752(X,Y) get_csv_string((X),(Y),752) +#define get_csv_bool_pos752(X,Y) get_csv_bool((X),(Y),752) +#define get_csv_int_pos752(X,Y) get_csv_int((X),(Y),752) +#define get_csv_llong_pos752(X,Y) get_csv_llong((X),(Y),752) +#define get_csv_float_pos752(X,Y) get_csv_float((X),(Y),752) +#define get_csv_uint_pos753(X,Y) get_csv_uint((X),(Y),753) +#define get_csv_ullong_pos753(X,Y) get_csv_ullong((X),(Y),753) +#define get_csv_ip_pos753(X,Y) get_csv_ip((X),(Y),753) +#define get_csv_ipv6_pos753(X,Y) get_csv_ipv6((X),(Y),753) +#define get_csv_string_pos753(X,Y) get_csv_string((X),(Y),753) +#define get_csv_v_str_pos753(X,Y) get_csv_string((X),(Y),753) +#define get_csv_bool_pos753(X,Y) get_csv_bool((X),(Y),753) +#define get_csv_int_pos753(X,Y) get_csv_int((X),(Y),753) +#define get_csv_llong_pos753(X,Y) get_csv_llong((X),(Y),753) +#define get_csv_float_pos753(X,Y) get_csv_float((X),(Y),753) +#define get_csv_uint_pos754(X,Y) get_csv_uint((X),(Y),754) +#define get_csv_ullong_pos754(X,Y) get_csv_ullong((X),(Y),754) +#define get_csv_ip_pos754(X,Y) get_csv_ip((X),(Y),754) +#define get_csv_ipv6_pos754(X,Y) get_csv_ipv6((X),(Y),754) +#define get_csv_string_pos754(X,Y) get_csv_string((X),(Y),754) +#define get_csv_v_str_pos754(X,Y) get_csv_string((X),(Y),754) +#define get_csv_bool_pos754(X,Y) get_csv_bool((X),(Y),754) +#define get_csv_int_pos754(X,Y) get_csv_int((X),(Y),754) +#define get_csv_llong_pos754(X,Y) get_csv_llong((X),(Y),754) +#define get_csv_float_pos754(X,Y) get_csv_float((X),(Y),754) +#define get_csv_uint_pos755(X,Y) get_csv_uint((X),(Y),755) +#define get_csv_ullong_pos755(X,Y) get_csv_ullong((X),(Y),755) +#define get_csv_ip_pos755(X,Y) get_csv_ip((X),(Y),755) +#define get_csv_ipv6_pos755(X,Y) get_csv_ipv6((X),(Y),755) +#define get_csv_string_pos755(X,Y) get_csv_string((X),(Y),755) +#define get_csv_v_str_pos755(X,Y) get_csv_string((X),(Y),755) +#define get_csv_bool_pos755(X,Y) get_csv_bool((X),(Y),755) +#define get_csv_int_pos755(X,Y) get_csv_int((X),(Y),755) +#define get_csv_llong_pos755(X,Y) get_csv_llong((X),(Y),755) +#define get_csv_float_pos755(X,Y) get_csv_float((X),(Y),755) +#define get_csv_uint_pos756(X,Y) get_csv_uint((X),(Y),756) +#define get_csv_ullong_pos756(X,Y) get_csv_ullong((X),(Y),756) +#define get_csv_ip_pos756(X,Y) get_csv_ip((X),(Y),756) +#define get_csv_ipv6_pos756(X,Y) get_csv_ipv6((X),(Y),756) +#define get_csv_string_pos756(X,Y) get_csv_string((X),(Y),756) +#define get_csv_v_str_pos756(X,Y) get_csv_string((X),(Y),756) +#define get_csv_bool_pos756(X,Y) get_csv_bool((X),(Y),756) +#define get_csv_int_pos756(X,Y) get_csv_int((X),(Y),756) +#define get_csv_llong_pos756(X,Y) get_csv_llong((X),(Y),756) +#define get_csv_float_pos756(X,Y) get_csv_float((X),(Y),756) +#define get_csv_uint_pos757(X,Y) get_csv_uint((X),(Y),757) +#define get_csv_ullong_pos757(X,Y) get_csv_ullong((X),(Y),757) +#define get_csv_ip_pos757(X,Y) get_csv_ip((X),(Y),757) +#define get_csv_ipv6_pos757(X,Y) get_csv_ipv6((X),(Y),757) +#define get_csv_string_pos757(X,Y) get_csv_string((X),(Y),757) +#define get_csv_v_str_pos757(X,Y) get_csv_string((X),(Y),757) +#define get_csv_bool_pos757(X,Y) get_csv_bool((X),(Y),757) +#define get_csv_int_pos757(X,Y) get_csv_int((X),(Y),757) +#define get_csv_llong_pos757(X,Y) get_csv_llong((X),(Y),757) +#define get_csv_float_pos757(X,Y) get_csv_float((X),(Y),757) +#define get_csv_uint_pos758(X,Y) get_csv_uint((X),(Y),758) +#define get_csv_ullong_pos758(X,Y) get_csv_ullong((X),(Y),758) +#define get_csv_ip_pos758(X,Y) get_csv_ip((X),(Y),758) +#define get_csv_ipv6_pos758(X,Y) get_csv_ipv6((X),(Y),758) +#define get_csv_string_pos758(X,Y) get_csv_string((X),(Y),758) +#define get_csv_v_str_pos758(X,Y) get_csv_string((X),(Y),758) +#define get_csv_bool_pos758(X,Y) get_csv_bool((X),(Y),758) +#define get_csv_int_pos758(X,Y) get_csv_int((X),(Y),758) +#define get_csv_llong_pos758(X,Y) get_csv_llong((X),(Y),758) +#define get_csv_float_pos758(X,Y) get_csv_float((X),(Y),758) +#define get_csv_uint_pos759(X,Y) get_csv_uint((X),(Y),759) +#define get_csv_ullong_pos759(X,Y) get_csv_ullong((X),(Y),759) +#define get_csv_ip_pos759(X,Y) get_csv_ip((X),(Y),759) +#define get_csv_ipv6_pos759(X,Y) get_csv_ipv6((X),(Y),759) +#define get_csv_string_pos759(X,Y) get_csv_string((X),(Y),759) +#define get_csv_v_str_pos759(X,Y) get_csv_string((X),(Y),759) +#define get_csv_bool_pos759(X,Y) get_csv_bool((X),(Y),759) +#define get_csv_int_pos759(X,Y) get_csv_int((X),(Y),759) +#define get_csv_llong_pos759(X,Y) get_csv_llong((X),(Y),759) +#define get_csv_float_pos759(X,Y) get_csv_float((X),(Y),759) +#define get_csv_uint_pos760(X,Y) get_csv_uint((X),(Y),760) +#define get_csv_ullong_pos760(X,Y) get_csv_ullong((X),(Y),760) +#define get_csv_ip_pos760(X,Y) get_csv_ip((X),(Y),760) +#define get_csv_ipv6_pos760(X,Y) get_csv_ipv6((X),(Y),760) +#define get_csv_string_pos760(X,Y) get_csv_string((X),(Y),760) +#define get_csv_v_str_pos760(X,Y) get_csv_string((X),(Y),760) +#define get_csv_bool_pos760(X,Y) get_csv_bool((X),(Y),760) +#define get_csv_int_pos760(X,Y) get_csv_int((X),(Y),760) +#define get_csv_llong_pos760(X,Y) get_csv_llong((X),(Y),760) +#define get_csv_float_pos760(X,Y) get_csv_float((X),(Y),760) +#define get_csv_uint_pos761(X,Y) get_csv_uint((X),(Y),761) +#define get_csv_ullong_pos761(X,Y) get_csv_ullong((X),(Y),761) +#define get_csv_ip_pos761(X,Y) get_csv_ip((X),(Y),761) +#define get_csv_ipv6_pos761(X,Y) get_csv_ipv6((X),(Y),761) +#define get_csv_string_pos761(X,Y) get_csv_string((X),(Y),761) +#define get_csv_v_str_pos761(X,Y) get_csv_string((X),(Y),761) +#define get_csv_bool_pos761(X,Y) get_csv_bool((X),(Y),761) +#define get_csv_int_pos761(X,Y) get_csv_int((X),(Y),761) +#define get_csv_llong_pos761(X,Y) get_csv_llong((X),(Y),761) +#define get_csv_float_pos761(X,Y) get_csv_float((X),(Y),761) +#define get_csv_uint_pos762(X,Y) get_csv_uint((X),(Y),762) +#define get_csv_ullong_pos762(X,Y) get_csv_ullong((X),(Y),762) +#define get_csv_ip_pos762(X,Y) get_csv_ip((X),(Y),762) +#define get_csv_ipv6_pos762(X,Y) get_csv_ipv6((X),(Y),762) +#define get_csv_string_pos762(X,Y) get_csv_string((X),(Y),762) +#define get_csv_v_str_pos762(X,Y) get_csv_string((X),(Y),762) +#define get_csv_bool_pos762(X,Y) get_csv_bool((X),(Y),762) +#define get_csv_int_pos762(X,Y) get_csv_int((X),(Y),762) +#define get_csv_llong_pos762(X,Y) get_csv_llong((X),(Y),762) +#define get_csv_float_pos762(X,Y) get_csv_float((X),(Y),762) +#define get_csv_uint_pos763(X,Y) get_csv_uint((X),(Y),763) +#define get_csv_ullong_pos763(X,Y) get_csv_ullong((X),(Y),763) +#define get_csv_ip_pos763(X,Y) get_csv_ip((X),(Y),763) +#define get_csv_ipv6_pos763(X,Y) get_csv_ipv6((X),(Y),763) +#define get_csv_string_pos763(X,Y) get_csv_string((X),(Y),763) +#define get_csv_v_str_pos763(X,Y) get_csv_string((X),(Y),763) +#define get_csv_bool_pos763(X,Y) get_csv_bool((X),(Y),763) +#define get_csv_int_pos763(X,Y) get_csv_int((X),(Y),763) +#define get_csv_llong_pos763(X,Y) get_csv_llong((X),(Y),763) +#define get_csv_float_pos763(X,Y) get_csv_float((X),(Y),763) +#define get_csv_uint_pos764(X,Y) get_csv_uint((X),(Y),764) +#define get_csv_ullong_pos764(X,Y) get_csv_ullong((X),(Y),764) +#define get_csv_ip_pos764(X,Y) get_csv_ip((X),(Y),764) +#define get_csv_ipv6_pos764(X,Y) get_csv_ipv6((X),(Y),764) +#define get_csv_string_pos764(X,Y) get_csv_string((X),(Y),764) +#define get_csv_v_str_pos764(X,Y) get_csv_string((X),(Y),764) +#define get_csv_bool_pos764(X,Y) get_csv_bool((X),(Y),764) +#define get_csv_int_pos764(X,Y) get_csv_int((X),(Y),764) +#define get_csv_llong_pos764(X,Y) get_csv_llong((X),(Y),764) +#define get_csv_float_pos764(X,Y) get_csv_float((X),(Y),764) +#define get_csv_uint_pos765(X,Y) get_csv_uint((X),(Y),765) +#define get_csv_ullong_pos765(X,Y) get_csv_ullong((X),(Y),765) +#define get_csv_ip_pos765(X,Y) get_csv_ip((X),(Y),765) +#define get_csv_ipv6_pos765(X,Y) get_csv_ipv6((X),(Y),765) +#define get_csv_string_pos765(X,Y) get_csv_string((X),(Y),765) +#define get_csv_v_str_pos765(X,Y) get_csv_string((X),(Y),765) +#define get_csv_bool_pos765(X,Y) get_csv_bool((X),(Y),765) +#define get_csv_int_pos765(X,Y) get_csv_int((X),(Y),765) +#define get_csv_llong_pos765(X,Y) get_csv_llong((X),(Y),765) +#define get_csv_float_pos765(X,Y) get_csv_float((X),(Y),765) +#define get_csv_uint_pos766(X,Y) get_csv_uint((X),(Y),766) +#define get_csv_ullong_pos766(X,Y) get_csv_ullong((X),(Y),766) +#define get_csv_ip_pos766(X,Y) get_csv_ip((X),(Y),766) +#define get_csv_ipv6_pos766(X,Y) get_csv_ipv6((X),(Y),766) +#define get_csv_string_pos766(X,Y) get_csv_string((X),(Y),766) +#define get_csv_v_str_pos766(X,Y) get_csv_string((X),(Y),766) +#define get_csv_bool_pos766(X,Y) get_csv_bool((X),(Y),766) +#define get_csv_int_pos766(X,Y) get_csv_int((X),(Y),766) +#define get_csv_llong_pos766(X,Y) get_csv_llong((X),(Y),766) +#define get_csv_float_pos766(X,Y) get_csv_float((X),(Y),766) +#define get_csv_uint_pos767(X,Y) get_csv_uint((X),(Y),767) +#define get_csv_ullong_pos767(X,Y) get_csv_ullong((X),(Y),767) +#define get_csv_ip_pos767(X,Y) get_csv_ip((X),(Y),767) +#define get_csv_ipv6_pos767(X,Y) get_csv_ipv6((X),(Y),767) +#define get_csv_string_pos767(X,Y) get_csv_string((X),(Y),767) +#define get_csv_v_str_pos767(X,Y) get_csv_string((X),(Y),767) +#define get_csv_bool_pos767(X,Y) get_csv_bool((X),(Y),767) +#define get_csv_int_pos767(X,Y) get_csv_int((X),(Y),767) +#define get_csv_llong_pos767(X,Y) get_csv_llong((X),(Y),767) +#define get_csv_float_pos767(X,Y) get_csv_float((X),(Y),767) +#define get_csv_uint_pos768(X,Y) get_csv_uint((X),(Y),768) +#define get_csv_ullong_pos768(X,Y) get_csv_ullong((X),(Y),768) +#define get_csv_ip_pos768(X,Y) get_csv_ip((X),(Y),768) +#define get_csv_ipv6_pos768(X,Y) get_csv_ipv6((X),(Y),768) +#define get_csv_string_pos768(X,Y) get_csv_string((X),(Y),768) +#define get_csv_v_str_pos768(X,Y) get_csv_string((X),(Y),768) +#define get_csv_bool_pos768(X,Y) get_csv_bool((X),(Y),768) +#define get_csv_int_pos768(X,Y) get_csv_int((X),(Y),768) +#define get_csv_llong_pos768(X,Y) get_csv_llong((X),(Y),768) +#define get_csv_float_pos768(X,Y) get_csv_float((X),(Y),768) +#define get_csv_uint_pos769(X,Y) get_csv_uint((X),(Y),769) +#define get_csv_ullong_pos769(X,Y) get_csv_ullong((X),(Y),769) +#define get_csv_ip_pos769(X,Y) get_csv_ip((X),(Y),769) +#define get_csv_ipv6_pos769(X,Y) get_csv_ipv6((X),(Y),769) +#define get_csv_string_pos769(X,Y) get_csv_string((X),(Y),769) +#define get_csv_v_str_pos769(X,Y) get_csv_string((X),(Y),769) +#define get_csv_bool_pos769(X,Y) get_csv_bool((X),(Y),769) +#define get_csv_int_pos769(X,Y) get_csv_int((X),(Y),769) +#define get_csv_llong_pos769(X,Y) get_csv_llong((X),(Y),769) +#define get_csv_float_pos769(X,Y) get_csv_float((X),(Y),769) +#define get_csv_uint_pos770(X,Y) get_csv_uint((X),(Y),770) +#define get_csv_ullong_pos770(X,Y) get_csv_ullong((X),(Y),770) +#define get_csv_ip_pos770(X,Y) get_csv_ip((X),(Y),770) +#define get_csv_ipv6_pos770(X,Y) get_csv_ipv6((X),(Y),770) +#define get_csv_string_pos770(X,Y) get_csv_string((X),(Y),770) +#define get_csv_v_str_pos770(X,Y) get_csv_string((X),(Y),770) +#define get_csv_bool_pos770(X,Y) get_csv_bool((X),(Y),770) +#define get_csv_int_pos770(X,Y) get_csv_int((X),(Y),770) +#define get_csv_llong_pos770(X,Y) get_csv_llong((X),(Y),770) +#define get_csv_float_pos770(X,Y) get_csv_float((X),(Y),770) +#define get_csv_uint_pos771(X,Y) get_csv_uint((X),(Y),771) +#define get_csv_ullong_pos771(X,Y) get_csv_ullong((X),(Y),771) +#define get_csv_ip_pos771(X,Y) get_csv_ip((X),(Y),771) +#define get_csv_ipv6_pos771(X,Y) get_csv_ipv6((X),(Y),771) +#define get_csv_string_pos771(X,Y) get_csv_string((X),(Y),771) +#define get_csv_v_str_pos771(X,Y) get_csv_string((X),(Y),771) +#define get_csv_bool_pos771(X,Y) get_csv_bool((X),(Y),771) +#define get_csv_int_pos771(X,Y) get_csv_int((X),(Y),771) +#define get_csv_llong_pos771(X,Y) get_csv_llong((X),(Y),771) +#define get_csv_float_pos771(X,Y) get_csv_float((X),(Y),771) +#define get_csv_uint_pos772(X,Y) get_csv_uint((X),(Y),772) +#define get_csv_ullong_pos772(X,Y) get_csv_ullong((X),(Y),772) +#define get_csv_ip_pos772(X,Y) get_csv_ip((X),(Y),772) +#define get_csv_ipv6_pos772(X,Y) get_csv_ipv6((X),(Y),772) +#define get_csv_string_pos772(X,Y) get_csv_string((X),(Y),772) +#define get_csv_v_str_pos772(X,Y) get_csv_string((X),(Y),772) +#define get_csv_bool_pos772(X,Y) get_csv_bool((X),(Y),772) +#define get_csv_int_pos772(X,Y) get_csv_int((X),(Y),772) +#define get_csv_llong_pos772(X,Y) get_csv_llong((X),(Y),772) +#define get_csv_float_pos772(X,Y) get_csv_float((X),(Y),772) +#define get_csv_uint_pos773(X,Y) get_csv_uint((X),(Y),773) +#define get_csv_ullong_pos773(X,Y) get_csv_ullong((X),(Y),773) +#define get_csv_ip_pos773(X,Y) get_csv_ip((X),(Y),773) +#define get_csv_ipv6_pos773(X,Y) get_csv_ipv6((X),(Y),773) +#define get_csv_string_pos773(X,Y) get_csv_string((X),(Y),773) +#define get_csv_v_str_pos773(X,Y) get_csv_string((X),(Y),773) +#define get_csv_bool_pos773(X,Y) get_csv_bool((X),(Y),773) +#define get_csv_int_pos773(X,Y) get_csv_int((X),(Y),773) +#define get_csv_llong_pos773(X,Y) get_csv_llong((X),(Y),773) +#define get_csv_float_pos773(X,Y) get_csv_float((X),(Y),773) +#define get_csv_uint_pos774(X,Y) get_csv_uint((X),(Y),774) +#define get_csv_ullong_pos774(X,Y) get_csv_ullong((X),(Y),774) +#define get_csv_ip_pos774(X,Y) get_csv_ip((X),(Y),774) +#define get_csv_ipv6_pos774(X,Y) get_csv_ipv6((X),(Y),774) +#define get_csv_string_pos774(X,Y) get_csv_string((X),(Y),774) +#define get_csv_v_str_pos774(X,Y) get_csv_string((X),(Y),774) +#define get_csv_bool_pos774(X,Y) get_csv_bool((X),(Y),774) +#define get_csv_int_pos774(X,Y) get_csv_int((X),(Y),774) +#define get_csv_llong_pos774(X,Y) get_csv_llong((X),(Y),774) +#define get_csv_float_pos774(X,Y) get_csv_float((X),(Y),774) +#define get_csv_uint_pos775(X,Y) get_csv_uint((X),(Y),775) +#define get_csv_ullong_pos775(X,Y) get_csv_ullong((X),(Y),775) +#define get_csv_ip_pos775(X,Y) get_csv_ip((X),(Y),775) +#define get_csv_ipv6_pos775(X,Y) get_csv_ipv6((X),(Y),775) +#define get_csv_string_pos775(X,Y) get_csv_string((X),(Y),775) +#define get_csv_v_str_pos775(X,Y) get_csv_string((X),(Y),775) +#define get_csv_bool_pos775(X,Y) get_csv_bool((X),(Y),775) +#define get_csv_int_pos775(X,Y) get_csv_int((X),(Y),775) +#define get_csv_llong_pos775(X,Y) get_csv_llong((X),(Y),775) +#define get_csv_float_pos775(X,Y) get_csv_float((X),(Y),775) +#define get_csv_uint_pos776(X,Y) get_csv_uint((X),(Y),776) +#define get_csv_ullong_pos776(X,Y) get_csv_ullong((X),(Y),776) +#define get_csv_ip_pos776(X,Y) get_csv_ip((X),(Y),776) +#define get_csv_ipv6_pos776(X,Y) get_csv_ipv6((X),(Y),776) +#define get_csv_string_pos776(X,Y) get_csv_string((X),(Y),776) +#define get_csv_v_str_pos776(X,Y) get_csv_string((X),(Y),776) +#define get_csv_bool_pos776(X,Y) get_csv_bool((X),(Y),776) +#define get_csv_int_pos776(X,Y) get_csv_int((X),(Y),776) +#define get_csv_llong_pos776(X,Y) get_csv_llong((X),(Y),776) +#define get_csv_float_pos776(X,Y) get_csv_float((X),(Y),776) +#define get_csv_uint_pos777(X,Y) get_csv_uint((X),(Y),777) +#define get_csv_ullong_pos777(X,Y) get_csv_ullong((X),(Y),777) +#define get_csv_ip_pos777(X,Y) get_csv_ip((X),(Y),777) +#define get_csv_ipv6_pos777(X,Y) get_csv_ipv6((X),(Y),777) +#define get_csv_string_pos777(X,Y) get_csv_string((X),(Y),777) +#define get_csv_v_str_pos777(X,Y) get_csv_string((X),(Y),777) +#define get_csv_bool_pos777(X,Y) get_csv_bool((X),(Y),777) +#define get_csv_int_pos777(X,Y) get_csv_int((X),(Y),777) +#define get_csv_llong_pos777(X,Y) get_csv_llong((X),(Y),777) +#define get_csv_float_pos777(X,Y) get_csv_float((X),(Y),777) +#define get_csv_uint_pos778(X,Y) get_csv_uint((X),(Y),778) +#define get_csv_ullong_pos778(X,Y) get_csv_ullong((X),(Y),778) +#define get_csv_ip_pos778(X,Y) get_csv_ip((X),(Y),778) +#define get_csv_ipv6_pos778(X,Y) get_csv_ipv6((X),(Y),778) +#define get_csv_string_pos778(X,Y) get_csv_string((X),(Y),778) +#define get_csv_v_str_pos778(X,Y) get_csv_string((X),(Y),778) +#define get_csv_bool_pos778(X,Y) get_csv_bool((X),(Y),778) +#define get_csv_int_pos778(X,Y) get_csv_int((X),(Y),778) +#define get_csv_llong_pos778(X,Y) get_csv_llong((X),(Y),778) +#define get_csv_float_pos778(X,Y) get_csv_float((X),(Y),778) +#define get_csv_uint_pos779(X,Y) get_csv_uint((X),(Y),779) +#define get_csv_ullong_pos779(X,Y) get_csv_ullong((X),(Y),779) +#define get_csv_ip_pos779(X,Y) get_csv_ip((X),(Y),779) +#define get_csv_ipv6_pos779(X,Y) get_csv_ipv6((X),(Y),779) +#define get_csv_string_pos779(X,Y) get_csv_string((X),(Y),779) +#define get_csv_v_str_pos779(X,Y) get_csv_string((X),(Y),779) +#define get_csv_bool_pos779(X,Y) get_csv_bool((X),(Y),779) +#define get_csv_int_pos779(X,Y) get_csv_int((X),(Y),779) +#define get_csv_llong_pos779(X,Y) get_csv_llong((X),(Y),779) +#define get_csv_float_pos779(X,Y) get_csv_float((X),(Y),779) +#define get_csv_uint_pos780(X,Y) get_csv_uint((X),(Y),780) +#define get_csv_ullong_pos780(X,Y) get_csv_ullong((X),(Y),780) +#define get_csv_ip_pos780(X,Y) get_csv_ip((X),(Y),780) +#define get_csv_ipv6_pos780(X,Y) get_csv_ipv6((X),(Y),780) +#define get_csv_string_pos780(X,Y) get_csv_string((X),(Y),780) +#define get_csv_v_str_pos780(X,Y) get_csv_string((X),(Y),780) +#define get_csv_bool_pos780(X,Y) get_csv_bool((X),(Y),780) +#define get_csv_int_pos780(X,Y) get_csv_int((X),(Y),780) +#define get_csv_llong_pos780(X,Y) get_csv_llong((X),(Y),780) +#define get_csv_float_pos780(X,Y) get_csv_float((X),(Y),780) +#define get_csv_uint_pos781(X,Y) get_csv_uint((X),(Y),781) +#define get_csv_ullong_pos781(X,Y) get_csv_ullong((X),(Y),781) +#define get_csv_ip_pos781(X,Y) get_csv_ip((X),(Y),781) +#define get_csv_ipv6_pos781(X,Y) get_csv_ipv6((X),(Y),781) +#define get_csv_string_pos781(X,Y) get_csv_string((X),(Y),781) +#define get_csv_v_str_pos781(X,Y) get_csv_string((X),(Y),781) +#define get_csv_bool_pos781(X,Y) get_csv_bool((X),(Y),781) +#define get_csv_int_pos781(X,Y) get_csv_int((X),(Y),781) +#define get_csv_llong_pos781(X,Y) get_csv_llong((X),(Y),781) +#define get_csv_float_pos781(X,Y) get_csv_float((X),(Y),781) +#define get_csv_uint_pos782(X,Y) get_csv_uint((X),(Y),782) +#define get_csv_ullong_pos782(X,Y) get_csv_ullong((X),(Y),782) +#define get_csv_ip_pos782(X,Y) get_csv_ip((X),(Y),782) +#define get_csv_ipv6_pos782(X,Y) get_csv_ipv6((X),(Y),782) +#define get_csv_string_pos782(X,Y) get_csv_string((X),(Y),782) +#define get_csv_v_str_pos782(X,Y) get_csv_string((X),(Y),782) +#define get_csv_bool_pos782(X,Y) get_csv_bool((X),(Y),782) +#define get_csv_int_pos782(X,Y) get_csv_int((X),(Y),782) +#define get_csv_llong_pos782(X,Y) get_csv_llong((X),(Y),782) +#define get_csv_float_pos782(X,Y) get_csv_float((X),(Y),782) +#define get_csv_uint_pos783(X,Y) get_csv_uint((X),(Y),783) +#define get_csv_ullong_pos783(X,Y) get_csv_ullong((X),(Y),783) +#define get_csv_ip_pos783(X,Y) get_csv_ip((X),(Y),783) +#define get_csv_ipv6_pos783(X,Y) get_csv_ipv6((X),(Y),783) +#define get_csv_string_pos783(X,Y) get_csv_string((X),(Y),783) +#define get_csv_v_str_pos783(X,Y) get_csv_string((X),(Y),783) +#define get_csv_bool_pos783(X,Y) get_csv_bool((X),(Y),783) +#define get_csv_int_pos783(X,Y) get_csv_int((X),(Y),783) +#define get_csv_llong_pos783(X,Y) get_csv_llong((X),(Y),783) +#define get_csv_float_pos783(X,Y) get_csv_float((X),(Y),783) +#define get_csv_uint_pos784(X,Y) get_csv_uint((X),(Y),784) +#define get_csv_ullong_pos784(X,Y) get_csv_ullong((X),(Y),784) +#define get_csv_ip_pos784(X,Y) get_csv_ip((X),(Y),784) +#define get_csv_ipv6_pos784(X,Y) get_csv_ipv6((X),(Y),784) +#define get_csv_string_pos784(X,Y) get_csv_string((X),(Y),784) +#define get_csv_v_str_pos784(X,Y) get_csv_string((X),(Y),784) +#define get_csv_bool_pos784(X,Y) get_csv_bool((X),(Y),784) +#define get_csv_int_pos784(X,Y) get_csv_int((X),(Y),784) +#define get_csv_llong_pos784(X,Y) get_csv_llong((X),(Y),784) +#define get_csv_float_pos784(X,Y) get_csv_float((X),(Y),784) +#define get_csv_uint_pos785(X,Y) get_csv_uint((X),(Y),785) +#define get_csv_ullong_pos785(X,Y) get_csv_ullong((X),(Y),785) +#define get_csv_ip_pos785(X,Y) get_csv_ip((X),(Y),785) +#define get_csv_ipv6_pos785(X,Y) get_csv_ipv6((X),(Y),785) +#define get_csv_string_pos785(X,Y) get_csv_string((X),(Y),785) +#define get_csv_v_str_pos785(X,Y) get_csv_string((X),(Y),785) +#define get_csv_bool_pos785(X,Y) get_csv_bool((X),(Y),785) +#define get_csv_int_pos785(X,Y) get_csv_int((X),(Y),785) +#define get_csv_llong_pos785(X,Y) get_csv_llong((X),(Y),785) +#define get_csv_float_pos785(X,Y) get_csv_float((X),(Y),785) +#define get_csv_uint_pos786(X,Y) get_csv_uint((X),(Y),786) +#define get_csv_ullong_pos786(X,Y) get_csv_ullong((X),(Y),786) +#define get_csv_ip_pos786(X,Y) get_csv_ip((X),(Y),786) +#define get_csv_ipv6_pos786(X,Y) get_csv_ipv6((X),(Y),786) +#define get_csv_string_pos786(X,Y) get_csv_string((X),(Y),786) +#define get_csv_v_str_pos786(X,Y) get_csv_string((X),(Y),786) +#define get_csv_bool_pos786(X,Y) get_csv_bool((X),(Y),786) +#define get_csv_int_pos786(X,Y) get_csv_int((X),(Y),786) +#define get_csv_llong_pos786(X,Y) get_csv_llong((X),(Y),786) +#define get_csv_float_pos786(X,Y) get_csv_float((X),(Y),786) +#define get_csv_uint_pos787(X,Y) get_csv_uint((X),(Y),787) +#define get_csv_ullong_pos787(X,Y) get_csv_ullong((X),(Y),787) +#define get_csv_ip_pos787(X,Y) get_csv_ip((X),(Y),787) +#define get_csv_ipv6_pos787(X,Y) get_csv_ipv6((X),(Y),787) +#define get_csv_string_pos787(X,Y) get_csv_string((X),(Y),787) +#define get_csv_v_str_pos787(X,Y) get_csv_string((X),(Y),787) +#define get_csv_bool_pos787(X,Y) get_csv_bool((X),(Y),787) +#define get_csv_int_pos787(X,Y) get_csv_int((X),(Y),787) +#define get_csv_llong_pos787(X,Y) get_csv_llong((X),(Y),787) +#define get_csv_float_pos787(X,Y) get_csv_float((X),(Y),787) +#define get_csv_uint_pos788(X,Y) get_csv_uint((X),(Y),788) +#define get_csv_ullong_pos788(X,Y) get_csv_ullong((X),(Y),788) +#define get_csv_ip_pos788(X,Y) get_csv_ip((X),(Y),788) +#define get_csv_ipv6_pos788(X,Y) get_csv_ipv6((X),(Y),788) +#define get_csv_string_pos788(X,Y) get_csv_string((X),(Y),788) +#define get_csv_v_str_pos788(X,Y) get_csv_string((X),(Y),788) +#define get_csv_bool_pos788(X,Y) get_csv_bool((X),(Y),788) +#define get_csv_int_pos788(X,Y) get_csv_int((X),(Y),788) +#define get_csv_llong_pos788(X,Y) get_csv_llong((X),(Y),788) +#define get_csv_float_pos788(X,Y) get_csv_float((X),(Y),788) +#define get_csv_uint_pos789(X,Y) get_csv_uint((X),(Y),789) +#define get_csv_ullong_pos789(X,Y) get_csv_ullong((X),(Y),789) +#define get_csv_ip_pos789(X,Y) get_csv_ip((X),(Y),789) +#define get_csv_ipv6_pos789(X,Y) get_csv_ipv6((X),(Y),789) +#define get_csv_string_pos789(X,Y) get_csv_string((X),(Y),789) +#define get_csv_v_str_pos789(X,Y) get_csv_string((X),(Y),789) +#define get_csv_bool_pos789(X,Y) get_csv_bool((X),(Y),789) +#define get_csv_int_pos789(X,Y) get_csv_int((X),(Y),789) +#define get_csv_llong_pos789(X,Y) get_csv_llong((X),(Y),789) +#define get_csv_float_pos789(X,Y) get_csv_float((X),(Y),789) +#define get_csv_uint_pos790(X,Y) get_csv_uint((X),(Y),790) +#define get_csv_ullong_pos790(X,Y) get_csv_ullong((X),(Y),790) +#define get_csv_ip_pos790(X,Y) get_csv_ip((X),(Y),790) +#define get_csv_ipv6_pos790(X,Y) get_csv_ipv6((X),(Y),790) +#define get_csv_string_pos790(X,Y) get_csv_string((X),(Y),790) +#define get_csv_v_str_pos790(X,Y) get_csv_string((X),(Y),790) +#define get_csv_bool_pos790(X,Y) get_csv_bool((X),(Y),790) +#define get_csv_int_pos790(X,Y) get_csv_int((X),(Y),790) +#define get_csv_llong_pos790(X,Y) get_csv_llong((X),(Y),790) +#define get_csv_float_pos790(X,Y) get_csv_float((X),(Y),790) +#define get_csv_uint_pos791(X,Y) get_csv_uint((X),(Y),791) +#define get_csv_ullong_pos791(X,Y) get_csv_ullong((X),(Y),791) +#define get_csv_ip_pos791(X,Y) get_csv_ip((X),(Y),791) +#define get_csv_ipv6_pos791(X,Y) get_csv_ipv6((X),(Y),791) +#define get_csv_string_pos791(X,Y) get_csv_string((X),(Y),791) +#define get_csv_v_str_pos791(X,Y) get_csv_string((X),(Y),791) +#define get_csv_bool_pos791(X,Y) get_csv_bool((X),(Y),791) +#define get_csv_int_pos791(X,Y) get_csv_int((X),(Y),791) +#define get_csv_llong_pos791(X,Y) get_csv_llong((X),(Y),791) +#define get_csv_float_pos791(X,Y) get_csv_float((X),(Y),791) +#define get_csv_uint_pos792(X,Y) get_csv_uint((X),(Y),792) +#define get_csv_ullong_pos792(X,Y) get_csv_ullong((X),(Y),792) +#define get_csv_ip_pos792(X,Y) get_csv_ip((X),(Y),792) +#define get_csv_ipv6_pos792(X,Y) get_csv_ipv6((X),(Y),792) +#define get_csv_string_pos792(X,Y) get_csv_string((X),(Y),792) +#define get_csv_v_str_pos792(X,Y) get_csv_string((X),(Y),792) +#define get_csv_bool_pos792(X,Y) get_csv_bool((X),(Y),792) +#define get_csv_int_pos792(X,Y) get_csv_int((X),(Y),792) +#define get_csv_llong_pos792(X,Y) get_csv_llong((X),(Y),792) +#define get_csv_float_pos792(X,Y) get_csv_float((X),(Y),792) +#define get_csv_uint_pos793(X,Y) get_csv_uint((X),(Y),793) +#define get_csv_ullong_pos793(X,Y) get_csv_ullong((X),(Y),793) +#define get_csv_ip_pos793(X,Y) get_csv_ip((X),(Y),793) +#define get_csv_ipv6_pos793(X,Y) get_csv_ipv6((X),(Y),793) +#define get_csv_string_pos793(X,Y) get_csv_string((X),(Y),793) +#define get_csv_v_str_pos793(X,Y) get_csv_string((X),(Y),793) +#define get_csv_bool_pos793(X,Y) get_csv_bool((X),(Y),793) +#define get_csv_int_pos793(X,Y) get_csv_int((X),(Y),793) +#define get_csv_llong_pos793(X,Y) get_csv_llong((X),(Y),793) +#define get_csv_float_pos793(X,Y) get_csv_float((X),(Y),793) +#define get_csv_uint_pos794(X,Y) get_csv_uint((X),(Y),794) +#define get_csv_ullong_pos794(X,Y) get_csv_ullong((X),(Y),794) +#define get_csv_ip_pos794(X,Y) get_csv_ip((X),(Y),794) +#define get_csv_ipv6_pos794(X,Y) get_csv_ipv6((X),(Y),794) +#define get_csv_string_pos794(X,Y) get_csv_string((X),(Y),794) +#define get_csv_v_str_pos794(X,Y) get_csv_string((X),(Y),794) +#define get_csv_bool_pos794(X,Y) get_csv_bool((X),(Y),794) +#define get_csv_int_pos794(X,Y) get_csv_int((X),(Y),794) +#define get_csv_llong_pos794(X,Y) get_csv_llong((X),(Y),794) +#define get_csv_float_pos794(X,Y) get_csv_float((X),(Y),794) +#define get_csv_uint_pos795(X,Y) get_csv_uint((X),(Y),795) +#define get_csv_ullong_pos795(X,Y) get_csv_ullong((X),(Y),795) +#define get_csv_ip_pos795(X,Y) get_csv_ip((X),(Y),795) +#define get_csv_ipv6_pos795(X,Y) get_csv_ipv6((X),(Y),795) +#define get_csv_string_pos795(X,Y) get_csv_string((X),(Y),795) +#define get_csv_v_str_pos795(X,Y) get_csv_string((X),(Y),795) +#define get_csv_bool_pos795(X,Y) get_csv_bool((X),(Y),795) +#define get_csv_int_pos795(X,Y) get_csv_int((X),(Y),795) +#define get_csv_llong_pos795(X,Y) get_csv_llong((X),(Y),795) +#define get_csv_float_pos795(X,Y) get_csv_float((X),(Y),795) +#define get_csv_uint_pos796(X,Y) get_csv_uint((X),(Y),796) +#define get_csv_ullong_pos796(X,Y) get_csv_ullong((X),(Y),796) +#define get_csv_ip_pos796(X,Y) get_csv_ip((X),(Y),796) +#define get_csv_ipv6_pos796(X,Y) get_csv_ipv6((X),(Y),796) +#define get_csv_string_pos796(X,Y) get_csv_string((X),(Y),796) +#define get_csv_v_str_pos796(X,Y) get_csv_string((X),(Y),796) +#define get_csv_bool_pos796(X,Y) get_csv_bool((X),(Y),796) +#define get_csv_int_pos796(X,Y) get_csv_int((X),(Y),796) +#define get_csv_llong_pos796(X,Y) get_csv_llong((X),(Y),796) +#define get_csv_float_pos796(X,Y) get_csv_float((X),(Y),796) +#define get_csv_uint_pos797(X,Y) get_csv_uint((X),(Y),797) +#define get_csv_ullong_pos797(X,Y) get_csv_ullong((X),(Y),797) +#define get_csv_ip_pos797(X,Y) get_csv_ip((X),(Y),797) +#define get_csv_ipv6_pos797(X,Y) get_csv_ipv6((X),(Y),797) +#define get_csv_string_pos797(X,Y) get_csv_string((X),(Y),797) +#define get_csv_v_str_pos797(X,Y) get_csv_string((X),(Y),797) +#define get_csv_bool_pos797(X,Y) get_csv_bool((X),(Y),797) +#define get_csv_int_pos797(X,Y) get_csv_int((X),(Y),797) +#define get_csv_llong_pos797(X,Y) get_csv_llong((X),(Y),797) +#define get_csv_float_pos797(X,Y) get_csv_float((X),(Y),797) +#define get_csv_uint_pos798(X,Y) get_csv_uint((X),(Y),798) +#define get_csv_ullong_pos798(X,Y) get_csv_ullong((X),(Y),798) +#define get_csv_ip_pos798(X,Y) get_csv_ip((X),(Y),798) +#define get_csv_ipv6_pos798(X,Y) get_csv_ipv6((X),(Y),798) +#define get_csv_string_pos798(X,Y) get_csv_string((X),(Y),798) +#define get_csv_v_str_pos798(X,Y) get_csv_string((X),(Y),798) +#define get_csv_bool_pos798(X,Y) get_csv_bool((X),(Y),798) +#define get_csv_int_pos798(X,Y) get_csv_int((X),(Y),798) +#define get_csv_llong_pos798(X,Y) get_csv_llong((X),(Y),798) +#define get_csv_float_pos798(X,Y) get_csv_float((X),(Y),798) +#define get_csv_uint_pos799(X,Y) get_csv_uint((X),(Y),799) +#define get_csv_ullong_pos799(X,Y) get_csv_ullong((X),(Y),799) +#define get_csv_ip_pos799(X,Y) get_csv_ip((X),(Y),799) +#define get_csv_ipv6_pos799(X,Y) get_csv_ipv6((X),(Y),799) +#define get_csv_string_pos799(X,Y) get_csv_string((X),(Y),799) +#define get_csv_v_str_pos799(X,Y) get_csv_string((X),(Y),799) +#define get_csv_bool_pos799(X,Y) get_csv_bool((X),(Y),799) +#define get_csv_int_pos799(X,Y) get_csv_int((X),(Y),799) +#define get_csv_llong_pos799(X,Y) get_csv_llong((X),(Y),799) +#define get_csv_float_pos799(X,Y) get_csv_float((X),(Y),799) +#define get_csv_uint_pos800(X,Y) get_csv_uint((X),(Y),800) +#define get_csv_ullong_pos800(X,Y) get_csv_ullong((X),(Y),800) +#define get_csv_ip_pos800(X,Y) get_csv_ip((X),(Y),800) +#define get_csv_ipv6_pos800(X,Y) get_csv_ipv6((X),(Y),800) +#define get_csv_string_pos800(X,Y) get_csv_string((X),(Y),800) +#define get_csv_v_str_pos800(X,Y) get_csv_string((X),(Y),800) +#define get_csv_bool_pos800(X,Y) get_csv_bool((X),(Y),800) +#define get_csv_int_pos800(X,Y) get_csv_int((X),(Y),800) +#define get_csv_llong_pos800(X,Y) get_csv_llong((X),(Y),800) +#define get_csv_float_pos800(X,Y) get_csv_float((X),(Y),800) +#define get_csv_uint_pos801(X,Y) get_csv_uint((X),(Y),801) +#define get_csv_ullong_pos801(X,Y) get_csv_ullong((X),(Y),801) +#define get_csv_ip_pos801(X,Y) get_csv_ip((X),(Y),801) +#define get_csv_ipv6_pos801(X,Y) get_csv_ipv6((X),(Y),801) +#define get_csv_string_pos801(X,Y) get_csv_string((X),(Y),801) +#define get_csv_v_str_pos801(X,Y) get_csv_string((X),(Y),801) +#define get_csv_bool_pos801(X,Y) get_csv_bool((X),(Y),801) +#define get_csv_int_pos801(X,Y) get_csv_int((X),(Y),801) +#define get_csv_llong_pos801(X,Y) get_csv_llong((X),(Y),801) +#define get_csv_float_pos801(X,Y) get_csv_float((X),(Y),801) +#define get_csv_uint_pos802(X,Y) get_csv_uint((X),(Y),802) +#define get_csv_ullong_pos802(X,Y) get_csv_ullong((X),(Y),802) +#define get_csv_ip_pos802(X,Y) get_csv_ip((X),(Y),802) +#define get_csv_ipv6_pos802(X,Y) get_csv_ipv6((X),(Y),802) +#define get_csv_string_pos802(X,Y) get_csv_string((X),(Y),802) +#define get_csv_v_str_pos802(X,Y) get_csv_string((X),(Y),802) +#define get_csv_bool_pos802(X,Y) get_csv_bool((X),(Y),802) +#define get_csv_int_pos802(X,Y) get_csv_int((X),(Y),802) +#define get_csv_llong_pos802(X,Y) get_csv_llong((X),(Y),802) +#define get_csv_float_pos802(X,Y) get_csv_float((X),(Y),802) +#define get_csv_uint_pos803(X,Y) get_csv_uint((X),(Y),803) +#define get_csv_ullong_pos803(X,Y) get_csv_ullong((X),(Y),803) +#define get_csv_ip_pos803(X,Y) get_csv_ip((X),(Y),803) +#define get_csv_ipv6_pos803(X,Y) get_csv_ipv6((X),(Y),803) +#define get_csv_string_pos803(X,Y) get_csv_string((X),(Y),803) +#define get_csv_v_str_pos803(X,Y) get_csv_string((X),(Y),803) +#define get_csv_bool_pos803(X,Y) get_csv_bool((X),(Y),803) +#define get_csv_int_pos803(X,Y) get_csv_int((X),(Y),803) +#define get_csv_llong_pos803(X,Y) get_csv_llong((X),(Y),803) +#define get_csv_float_pos803(X,Y) get_csv_float((X),(Y),803) +#define get_csv_uint_pos804(X,Y) get_csv_uint((X),(Y),804) +#define get_csv_ullong_pos804(X,Y) get_csv_ullong((X),(Y),804) +#define get_csv_ip_pos804(X,Y) get_csv_ip((X),(Y),804) +#define get_csv_ipv6_pos804(X,Y) get_csv_ipv6((X),(Y),804) +#define get_csv_string_pos804(X,Y) get_csv_string((X),(Y),804) +#define get_csv_v_str_pos804(X,Y) get_csv_string((X),(Y),804) +#define get_csv_bool_pos804(X,Y) get_csv_bool((X),(Y),804) +#define get_csv_int_pos804(X,Y) get_csv_int((X),(Y),804) +#define get_csv_llong_pos804(X,Y) get_csv_llong((X),(Y),804) +#define get_csv_float_pos804(X,Y) get_csv_float((X),(Y),804) +#define get_csv_uint_pos805(X,Y) get_csv_uint((X),(Y),805) +#define get_csv_ullong_pos805(X,Y) get_csv_ullong((X),(Y),805) +#define get_csv_ip_pos805(X,Y) get_csv_ip((X),(Y),805) +#define get_csv_ipv6_pos805(X,Y) get_csv_ipv6((X),(Y),805) +#define get_csv_string_pos805(X,Y) get_csv_string((X),(Y),805) +#define get_csv_v_str_pos805(X,Y) get_csv_string((X),(Y),805) +#define get_csv_bool_pos805(X,Y) get_csv_bool((X),(Y),805) +#define get_csv_int_pos805(X,Y) get_csv_int((X),(Y),805) +#define get_csv_llong_pos805(X,Y) get_csv_llong((X),(Y),805) +#define get_csv_float_pos805(X,Y) get_csv_float((X),(Y),805) +#define get_csv_uint_pos806(X,Y) get_csv_uint((X),(Y),806) +#define get_csv_ullong_pos806(X,Y) get_csv_ullong((X),(Y),806) +#define get_csv_ip_pos806(X,Y) get_csv_ip((X),(Y),806) +#define get_csv_ipv6_pos806(X,Y) get_csv_ipv6((X),(Y),806) +#define get_csv_string_pos806(X,Y) get_csv_string((X),(Y),806) +#define get_csv_v_str_pos806(X,Y) get_csv_string((X),(Y),806) +#define get_csv_bool_pos806(X,Y) get_csv_bool((X),(Y),806) +#define get_csv_int_pos806(X,Y) get_csv_int((X),(Y),806) +#define get_csv_llong_pos806(X,Y) get_csv_llong((X),(Y),806) +#define get_csv_float_pos806(X,Y) get_csv_float((X),(Y),806) +#define get_csv_uint_pos807(X,Y) get_csv_uint((X),(Y),807) +#define get_csv_ullong_pos807(X,Y) get_csv_ullong((X),(Y),807) +#define get_csv_ip_pos807(X,Y) get_csv_ip((X),(Y),807) +#define get_csv_ipv6_pos807(X,Y) get_csv_ipv6((X),(Y),807) +#define get_csv_string_pos807(X,Y) get_csv_string((X),(Y),807) +#define get_csv_v_str_pos807(X,Y) get_csv_string((X),(Y),807) +#define get_csv_bool_pos807(X,Y) get_csv_bool((X),(Y),807) +#define get_csv_int_pos807(X,Y) get_csv_int((X),(Y),807) +#define get_csv_llong_pos807(X,Y) get_csv_llong((X),(Y),807) +#define get_csv_float_pos807(X,Y) get_csv_float((X),(Y),807) +#define get_csv_uint_pos808(X,Y) get_csv_uint((X),(Y),808) +#define get_csv_ullong_pos808(X,Y) get_csv_ullong((X),(Y),808) +#define get_csv_ip_pos808(X,Y) get_csv_ip((X),(Y),808) +#define get_csv_ipv6_pos808(X,Y) get_csv_ipv6((X),(Y),808) +#define get_csv_string_pos808(X,Y) get_csv_string((X),(Y),808) +#define get_csv_v_str_pos808(X,Y) get_csv_string((X),(Y),808) +#define get_csv_bool_pos808(X,Y) get_csv_bool((X),(Y),808) +#define get_csv_int_pos808(X,Y) get_csv_int((X),(Y),808) +#define get_csv_llong_pos808(X,Y) get_csv_llong((X),(Y),808) +#define get_csv_float_pos808(X,Y) get_csv_float((X),(Y),808) +#define get_csv_uint_pos809(X,Y) get_csv_uint((X),(Y),809) +#define get_csv_ullong_pos809(X,Y) get_csv_ullong((X),(Y),809) +#define get_csv_ip_pos809(X,Y) get_csv_ip((X),(Y),809) +#define get_csv_ipv6_pos809(X,Y) get_csv_ipv6((X),(Y),809) +#define get_csv_string_pos809(X,Y) get_csv_string((X),(Y),809) +#define get_csv_v_str_pos809(X,Y) get_csv_string((X),(Y),809) +#define get_csv_bool_pos809(X,Y) get_csv_bool((X),(Y),809) +#define get_csv_int_pos809(X,Y) get_csv_int((X),(Y),809) +#define get_csv_llong_pos809(X,Y) get_csv_llong((X),(Y),809) +#define get_csv_float_pos809(X,Y) get_csv_float((X),(Y),809) +#define get_csv_uint_pos810(X,Y) get_csv_uint((X),(Y),810) +#define get_csv_ullong_pos810(X,Y) get_csv_ullong((X),(Y),810) +#define get_csv_ip_pos810(X,Y) get_csv_ip((X),(Y),810) +#define get_csv_ipv6_pos810(X,Y) get_csv_ipv6((X),(Y),810) +#define get_csv_string_pos810(X,Y) get_csv_string((X),(Y),810) +#define get_csv_v_str_pos810(X,Y) get_csv_string((X),(Y),810) +#define get_csv_bool_pos810(X,Y) get_csv_bool((X),(Y),810) +#define get_csv_int_pos810(X,Y) get_csv_int((X),(Y),810) +#define get_csv_llong_pos810(X,Y) get_csv_llong((X),(Y),810) +#define get_csv_float_pos810(X,Y) get_csv_float((X),(Y),810) +#define get_csv_uint_pos811(X,Y) get_csv_uint((X),(Y),811) +#define get_csv_ullong_pos811(X,Y) get_csv_ullong((X),(Y),811) +#define get_csv_ip_pos811(X,Y) get_csv_ip((X),(Y),811) +#define get_csv_ipv6_pos811(X,Y) get_csv_ipv6((X),(Y),811) +#define get_csv_string_pos811(X,Y) get_csv_string((X),(Y),811) +#define get_csv_v_str_pos811(X,Y) get_csv_string((X),(Y),811) +#define get_csv_bool_pos811(X,Y) get_csv_bool((X),(Y),811) +#define get_csv_int_pos811(X,Y) get_csv_int((X),(Y),811) +#define get_csv_llong_pos811(X,Y) get_csv_llong((X),(Y),811) +#define get_csv_float_pos811(X,Y) get_csv_float((X),(Y),811) +#define get_csv_uint_pos812(X,Y) get_csv_uint((X),(Y),812) +#define get_csv_ullong_pos812(X,Y) get_csv_ullong((X),(Y),812) +#define get_csv_ip_pos812(X,Y) get_csv_ip((X),(Y),812) +#define get_csv_ipv6_pos812(X,Y) get_csv_ipv6((X),(Y),812) +#define get_csv_string_pos812(X,Y) get_csv_string((X),(Y),812) +#define get_csv_v_str_pos812(X,Y) get_csv_string((X),(Y),812) +#define get_csv_bool_pos812(X,Y) get_csv_bool((X),(Y),812) +#define get_csv_int_pos812(X,Y) get_csv_int((X),(Y),812) +#define get_csv_llong_pos812(X,Y) get_csv_llong((X),(Y),812) +#define get_csv_float_pos812(X,Y) get_csv_float((X),(Y),812) +#define get_csv_uint_pos813(X,Y) get_csv_uint((X),(Y),813) +#define get_csv_ullong_pos813(X,Y) get_csv_ullong((X),(Y),813) +#define get_csv_ip_pos813(X,Y) get_csv_ip((X),(Y),813) +#define get_csv_ipv6_pos813(X,Y) get_csv_ipv6((X),(Y),813) +#define get_csv_string_pos813(X,Y) get_csv_string((X),(Y),813) +#define get_csv_v_str_pos813(X,Y) get_csv_string((X),(Y),813) +#define get_csv_bool_pos813(X,Y) get_csv_bool((X),(Y),813) +#define get_csv_int_pos813(X,Y) get_csv_int((X),(Y),813) +#define get_csv_llong_pos813(X,Y) get_csv_llong((X),(Y),813) +#define get_csv_float_pos813(X,Y) get_csv_float((X),(Y),813) +#define get_csv_uint_pos814(X,Y) get_csv_uint((X),(Y),814) +#define get_csv_ullong_pos814(X,Y) get_csv_ullong((X),(Y),814) +#define get_csv_ip_pos814(X,Y) get_csv_ip((X),(Y),814) +#define get_csv_ipv6_pos814(X,Y) get_csv_ipv6((X),(Y),814) +#define get_csv_string_pos814(X,Y) get_csv_string((X),(Y),814) +#define get_csv_v_str_pos814(X,Y) get_csv_string((X),(Y),814) +#define get_csv_bool_pos814(X,Y) get_csv_bool((X),(Y),814) +#define get_csv_int_pos814(X,Y) get_csv_int((X),(Y),814) +#define get_csv_llong_pos814(X,Y) get_csv_llong((X),(Y),814) +#define get_csv_float_pos814(X,Y) get_csv_float((X),(Y),814) +#define get_csv_uint_pos815(X,Y) get_csv_uint((X),(Y),815) +#define get_csv_ullong_pos815(X,Y) get_csv_ullong((X),(Y),815) +#define get_csv_ip_pos815(X,Y) get_csv_ip((X),(Y),815) +#define get_csv_ipv6_pos815(X,Y) get_csv_ipv6((X),(Y),815) +#define get_csv_string_pos815(X,Y) get_csv_string((X),(Y),815) +#define get_csv_v_str_pos815(X,Y) get_csv_string((X),(Y),815) +#define get_csv_bool_pos815(X,Y) get_csv_bool((X),(Y),815) +#define get_csv_int_pos815(X,Y) get_csv_int((X),(Y),815) +#define get_csv_llong_pos815(X,Y) get_csv_llong((X),(Y),815) +#define get_csv_float_pos815(X,Y) get_csv_float((X),(Y),815) +#define get_csv_uint_pos816(X,Y) get_csv_uint((X),(Y),816) +#define get_csv_ullong_pos816(X,Y) get_csv_ullong((X),(Y),816) +#define get_csv_ip_pos816(X,Y) get_csv_ip((X),(Y),816) +#define get_csv_ipv6_pos816(X,Y) get_csv_ipv6((X),(Y),816) +#define get_csv_string_pos816(X,Y) get_csv_string((X),(Y),816) +#define get_csv_v_str_pos816(X,Y) get_csv_string((X),(Y),816) +#define get_csv_bool_pos816(X,Y) get_csv_bool((X),(Y),816) +#define get_csv_int_pos816(X,Y) get_csv_int((X),(Y),816) +#define get_csv_llong_pos816(X,Y) get_csv_llong((X),(Y),816) +#define get_csv_float_pos816(X,Y) get_csv_float((X),(Y),816) +#define get_csv_uint_pos817(X,Y) get_csv_uint((X),(Y),817) +#define get_csv_ullong_pos817(X,Y) get_csv_ullong((X),(Y),817) +#define get_csv_ip_pos817(X,Y) get_csv_ip((X),(Y),817) +#define get_csv_ipv6_pos817(X,Y) get_csv_ipv6((X),(Y),817) +#define get_csv_string_pos817(X,Y) get_csv_string((X),(Y),817) +#define get_csv_v_str_pos817(X,Y) get_csv_string((X),(Y),817) +#define get_csv_bool_pos817(X,Y) get_csv_bool((X),(Y),817) +#define get_csv_int_pos817(X,Y) get_csv_int((X),(Y),817) +#define get_csv_llong_pos817(X,Y) get_csv_llong((X),(Y),817) +#define get_csv_float_pos817(X,Y) get_csv_float((X),(Y),817) +#define get_csv_uint_pos818(X,Y) get_csv_uint((X),(Y),818) +#define get_csv_ullong_pos818(X,Y) get_csv_ullong((X),(Y),818) +#define get_csv_ip_pos818(X,Y) get_csv_ip((X),(Y),818) +#define get_csv_ipv6_pos818(X,Y) get_csv_ipv6((X),(Y),818) +#define get_csv_string_pos818(X,Y) get_csv_string((X),(Y),818) +#define get_csv_v_str_pos818(X,Y) get_csv_string((X),(Y),818) +#define get_csv_bool_pos818(X,Y) get_csv_bool((X),(Y),818) +#define get_csv_int_pos818(X,Y) get_csv_int((X),(Y),818) +#define get_csv_llong_pos818(X,Y) get_csv_llong((X),(Y),818) +#define get_csv_float_pos818(X,Y) get_csv_float((X),(Y),818) +#define get_csv_uint_pos819(X,Y) get_csv_uint((X),(Y),819) +#define get_csv_ullong_pos819(X,Y) get_csv_ullong((X),(Y),819) +#define get_csv_ip_pos819(X,Y) get_csv_ip((X),(Y),819) +#define get_csv_ipv6_pos819(X,Y) get_csv_ipv6((X),(Y),819) +#define get_csv_string_pos819(X,Y) get_csv_string((X),(Y),819) +#define get_csv_v_str_pos819(X,Y) get_csv_string((X),(Y),819) +#define get_csv_bool_pos819(X,Y) get_csv_bool((X),(Y),819) +#define get_csv_int_pos819(X,Y) get_csv_int((X),(Y),819) +#define get_csv_llong_pos819(X,Y) get_csv_llong((X),(Y),819) +#define get_csv_float_pos819(X,Y) get_csv_float((X),(Y),819) +#define get_csv_uint_pos820(X,Y) get_csv_uint((X),(Y),820) +#define get_csv_ullong_pos820(X,Y) get_csv_ullong((X),(Y),820) +#define get_csv_ip_pos820(X,Y) get_csv_ip((X),(Y),820) +#define get_csv_ipv6_pos820(X,Y) get_csv_ipv6((X),(Y),820) +#define get_csv_string_pos820(X,Y) get_csv_string((X),(Y),820) +#define get_csv_v_str_pos820(X,Y) get_csv_string((X),(Y),820) +#define get_csv_bool_pos820(X,Y) get_csv_bool((X),(Y),820) +#define get_csv_int_pos820(X,Y) get_csv_int((X),(Y),820) +#define get_csv_llong_pos820(X,Y) get_csv_llong((X),(Y),820) +#define get_csv_float_pos820(X,Y) get_csv_float((X),(Y),820) +#define get_csv_uint_pos821(X,Y) get_csv_uint((X),(Y),821) +#define get_csv_ullong_pos821(X,Y) get_csv_ullong((X),(Y),821) +#define get_csv_ip_pos821(X,Y) get_csv_ip((X),(Y),821) +#define get_csv_ipv6_pos821(X,Y) get_csv_ipv6((X),(Y),821) +#define get_csv_string_pos821(X,Y) get_csv_string((X),(Y),821) +#define get_csv_v_str_pos821(X,Y) get_csv_string((X),(Y),821) +#define get_csv_bool_pos821(X,Y) get_csv_bool((X),(Y),821) +#define get_csv_int_pos821(X,Y) get_csv_int((X),(Y),821) +#define get_csv_llong_pos821(X,Y) get_csv_llong((X),(Y),821) +#define get_csv_float_pos821(X,Y) get_csv_float((X),(Y),821) +#define get_csv_uint_pos822(X,Y) get_csv_uint((X),(Y),822) +#define get_csv_ullong_pos822(X,Y) get_csv_ullong((X),(Y),822) +#define get_csv_ip_pos822(X,Y) get_csv_ip((X),(Y),822) +#define get_csv_ipv6_pos822(X,Y) get_csv_ipv6((X),(Y),822) +#define get_csv_string_pos822(X,Y) get_csv_string((X),(Y),822) +#define get_csv_v_str_pos822(X,Y) get_csv_string((X),(Y),822) +#define get_csv_bool_pos822(X,Y) get_csv_bool((X),(Y),822) +#define get_csv_int_pos822(X,Y) get_csv_int((X),(Y),822) +#define get_csv_llong_pos822(X,Y) get_csv_llong((X),(Y),822) +#define get_csv_float_pos822(X,Y) get_csv_float((X),(Y),822) +#define get_csv_uint_pos823(X,Y) get_csv_uint((X),(Y),823) +#define get_csv_ullong_pos823(X,Y) get_csv_ullong((X),(Y),823) +#define get_csv_ip_pos823(X,Y) get_csv_ip((X),(Y),823) +#define get_csv_ipv6_pos823(X,Y) get_csv_ipv6((X),(Y),823) +#define get_csv_string_pos823(X,Y) get_csv_string((X),(Y),823) +#define get_csv_v_str_pos823(X,Y) get_csv_string((X),(Y),823) +#define get_csv_bool_pos823(X,Y) get_csv_bool((X),(Y),823) +#define get_csv_int_pos823(X,Y) get_csv_int((X),(Y),823) +#define get_csv_llong_pos823(X,Y) get_csv_llong((X),(Y),823) +#define get_csv_float_pos823(X,Y) get_csv_float((X),(Y),823) +#define get_csv_uint_pos824(X,Y) get_csv_uint((X),(Y),824) +#define get_csv_ullong_pos824(X,Y) get_csv_ullong((X),(Y),824) +#define get_csv_ip_pos824(X,Y) get_csv_ip((X),(Y),824) +#define get_csv_ipv6_pos824(X,Y) get_csv_ipv6((X),(Y),824) +#define get_csv_string_pos824(X,Y) get_csv_string((X),(Y),824) +#define get_csv_v_str_pos824(X,Y) get_csv_string((X),(Y),824) +#define get_csv_bool_pos824(X,Y) get_csv_bool((X),(Y),824) +#define get_csv_int_pos824(X,Y) get_csv_int((X),(Y),824) +#define get_csv_llong_pos824(X,Y) get_csv_llong((X),(Y),824) +#define get_csv_float_pos824(X,Y) get_csv_float((X),(Y),824) +#define get_csv_uint_pos825(X,Y) get_csv_uint((X),(Y),825) +#define get_csv_ullong_pos825(X,Y) get_csv_ullong((X),(Y),825) +#define get_csv_ip_pos825(X,Y) get_csv_ip((X),(Y),825) +#define get_csv_ipv6_pos825(X,Y) get_csv_ipv6((X),(Y),825) +#define get_csv_string_pos825(X,Y) get_csv_string((X),(Y),825) +#define get_csv_v_str_pos825(X,Y) get_csv_string((X),(Y),825) +#define get_csv_bool_pos825(X,Y) get_csv_bool((X),(Y),825) +#define get_csv_int_pos825(X,Y) get_csv_int((X),(Y),825) +#define get_csv_llong_pos825(X,Y) get_csv_llong((X),(Y),825) +#define get_csv_float_pos825(X,Y) get_csv_float((X),(Y),825) +#define get_csv_uint_pos826(X,Y) get_csv_uint((X),(Y),826) +#define get_csv_ullong_pos826(X,Y) get_csv_ullong((X),(Y),826) +#define get_csv_ip_pos826(X,Y) get_csv_ip((X),(Y),826) +#define get_csv_ipv6_pos826(X,Y) get_csv_ipv6((X),(Y),826) +#define get_csv_string_pos826(X,Y) get_csv_string((X),(Y),826) +#define get_csv_v_str_pos826(X,Y) get_csv_string((X),(Y),826) +#define get_csv_bool_pos826(X,Y) get_csv_bool((X),(Y),826) +#define get_csv_int_pos826(X,Y) get_csv_int((X),(Y),826) +#define get_csv_llong_pos826(X,Y) get_csv_llong((X),(Y),826) +#define get_csv_float_pos826(X,Y) get_csv_float((X),(Y),826) +#define get_csv_uint_pos827(X,Y) get_csv_uint((X),(Y),827) +#define get_csv_ullong_pos827(X,Y) get_csv_ullong((X),(Y),827) +#define get_csv_ip_pos827(X,Y) get_csv_ip((X),(Y),827) +#define get_csv_ipv6_pos827(X,Y) get_csv_ipv6((X),(Y),827) +#define get_csv_string_pos827(X,Y) get_csv_string((X),(Y),827) +#define get_csv_v_str_pos827(X,Y) get_csv_string((X),(Y),827) +#define get_csv_bool_pos827(X,Y) get_csv_bool((X),(Y),827) +#define get_csv_int_pos827(X,Y) get_csv_int((X),(Y),827) +#define get_csv_llong_pos827(X,Y) get_csv_llong((X),(Y),827) +#define get_csv_float_pos827(X,Y) get_csv_float((X),(Y),827) +#define get_csv_uint_pos828(X,Y) get_csv_uint((X),(Y),828) +#define get_csv_ullong_pos828(X,Y) get_csv_ullong((X),(Y),828) +#define get_csv_ip_pos828(X,Y) get_csv_ip((X),(Y),828) +#define get_csv_ipv6_pos828(X,Y) get_csv_ipv6((X),(Y),828) +#define get_csv_string_pos828(X,Y) get_csv_string((X),(Y),828) +#define get_csv_v_str_pos828(X,Y) get_csv_string((X),(Y),828) +#define get_csv_bool_pos828(X,Y) get_csv_bool((X),(Y),828) +#define get_csv_int_pos828(X,Y) get_csv_int((X),(Y),828) +#define get_csv_llong_pos828(X,Y) get_csv_llong((X),(Y),828) +#define get_csv_float_pos828(X,Y) get_csv_float((X),(Y),828) +#define get_csv_uint_pos829(X,Y) get_csv_uint((X),(Y),829) +#define get_csv_ullong_pos829(X,Y) get_csv_ullong((X),(Y),829) +#define get_csv_ip_pos829(X,Y) get_csv_ip((X),(Y),829) +#define get_csv_ipv6_pos829(X,Y) get_csv_ipv6((X),(Y),829) +#define get_csv_string_pos829(X,Y) get_csv_string((X),(Y),829) +#define get_csv_v_str_pos829(X,Y) get_csv_string((X),(Y),829) +#define get_csv_bool_pos829(X,Y) get_csv_bool((X),(Y),829) +#define get_csv_int_pos829(X,Y) get_csv_int((X),(Y),829) +#define get_csv_llong_pos829(X,Y) get_csv_llong((X),(Y),829) +#define get_csv_float_pos829(X,Y) get_csv_float((X),(Y),829) +#define get_csv_uint_pos830(X,Y) get_csv_uint((X),(Y),830) +#define get_csv_ullong_pos830(X,Y) get_csv_ullong((X),(Y),830) +#define get_csv_ip_pos830(X,Y) get_csv_ip((X),(Y),830) +#define get_csv_ipv6_pos830(X,Y) get_csv_ipv6((X),(Y),830) +#define get_csv_string_pos830(X,Y) get_csv_string((X),(Y),830) +#define get_csv_v_str_pos830(X,Y) get_csv_string((X),(Y),830) +#define get_csv_bool_pos830(X,Y) get_csv_bool((X),(Y),830) +#define get_csv_int_pos830(X,Y) get_csv_int((X),(Y),830) +#define get_csv_llong_pos830(X,Y) get_csv_llong((X),(Y),830) +#define get_csv_float_pos830(X,Y) get_csv_float((X),(Y),830) +#define get_csv_uint_pos831(X,Y) get_csv_uint((X),(Y),831) +#define get_csv_ullong_pos831(X,Y) get_csv_ullong((X),(Y),831) +#define get_csv_ip_pos831(X,Y) get_csv_ip((X),(Y),831) +#define get_csv_ipv6_pos831(X,Y) get_csv_ipv6((X),(Y),831) +#define get_csv_string_pos831(X,Y) get_csv_string((X),(Y),831) +#define get_csv_v_str_pos831(X,Y) get_csv_string((X),(Y),831) +#define get_csv_bool_pos831(X,Y) get_csv_bool((X),(Y),831) +#define get_csv_int_pos831(X,Y) get_csv_int((X),(Y),831) +#define get_csv_llong_pos831(X,Y) get_csv_llong((X),(Y),831) +#define get_csv_float_pos831(X,Y) get_csv_float((X),(Y),831) +#define get_csv_uint_pos832(X,Y) get_csv_uint((X),(Y),832) +#define get_csv_ullong_pos832(X,Y) get_csv_ullong((X),(Y),832) +#define get_csv_ip_pos832(X,Y) get_csv_ip((X),(Y),832) +#define get_csv_ipv6_pos832(X,Y) get_csv_ipv6((X),(Y),832) +#define get_csv_string_pos832(X,Y) get_csv_string((X),(Y),832) +#define get_csv_v_str_pos832(X,Y) get_csv_string((X),(Y),832) +#define get_csv_bool_pos832(X,Y) get_csv_bool((X),(Y),832) +#define get_csv_int_pos832(X,Y) get_csv_int((X),(Y),832) +#define get_csv_llong_pos832(X,Y) get_csv_llong((X),(Y),832) +#define get_csv_float_pos832(X,Y) get_csv_float((X),(Y),832) +#define get_csv_uint_pos833(X,Y) get_csv_uint((X),(Y),833) +#define get_csv_ullong_pos833(X,Y) get_csv_ullong((X),(Y),833) +#define get_csv_ip_pos833(X,Y) get_csv_ip((X),(Y),833) +#define get_csv_ipv6_pos833(X,Y) get_csv_ipv6((X),(Y),833) +#define get_csv_string_pos833(X,Y) get_csv_string((X),(Y),833) +#define get_csv_v_str_pos833(X,Y) get_csv_string((X),(Y),833) +#define get_csv_bool_pos833(X,Y) get_csv_bool((X),(Y),833) +#define get_csv_int_pos833(X,Y) get_csv_int((X),(Y),833) +#define get_csv_llong_pos833(X,Y) get_csv_llong((X),(Y),833) +#define get_csv_float_pos833(X,Y) get_csv_float((X),(Y),833) +#define get_csv_uint_pos834(X,Y) get_csv_uint((X),(Y),834) +#define get_csv_ullong_pos834(X,Y) get_csv_ullong((X),(Y),834) +#define get_csv_ip_pos834(X,Y) get_csv_ip((X),(Y),834) +#define get_csv_ipv6_pos834(X,Y) get_csv_ipv6((X),(Y),834) +#define get_csv_string_pos834(X,Y) get_csv_string((X),(Y),834) +#define get_csv_v_str_pos834(X,Y) get_csv_string((X),(Y),834) +#define get_csv_bool_pos834(X,Y) get_csv_bool((X),(Y),834) +#define get_csv_int_pos834(X,Y) get_csv_int((X),(Y),834) +#define get_csv_llong_pos834(X,Y) get_csv_llong((X),(Y),834) +#define get_csv_float_pos834(X,Y) get_csv_float((X),(Y),834) +#define get_csv_uint_pos835(X,Y) get_csv_uint((X),(Y),835) +#define get_csv_ullong_pos835(X,Y) get_csv_ullong((X),(Y),835) +#define get_csv_ip_pos835(X,Y) get_csv_ip((X),(Y),835) +#define get_csv_ipv6_pos835(X,Y) get_csv_ipv6((X),(Y),835) +#define get_csv_string_pos835(X,Y) get_csv_string((X),(Y),835) +#define get_csv_v_str_pos835(X,Y) get_csv_string((X),(Y),835) +#define get_csv_bool_pos835(X,Y) get_csv_bool((X),(Y),835) +#define get_csv_int_pos835(X,Y) get_csv_int((X),(Y),835) +#define get_csv_llong_pos835(X,Y) get_csv_llong((X),(Y),835) +#define get_csv_float_pos835(X,Y) get_csv_float((X),(Y),835) +#define get_csv_uint_pos836(X,Y) get_csv_uint((X),(Y),836) +#define get_csv_ullong_pos836(X,Y) get_csv_ullong((X),(Y),836) +#define get_csv_ip_pos836(X,Y) get_csv_ip((X),(Y),836) +#define get_csv_ipv6_pos836(X,Y) get_csv_ipv6((X),(Y),836) +#define get_csv_string_pos836(X,Y) get_csv_string((X),(Y),836) +#define get_csv_v_str_pos836(X,Y) get_csv_string((X),(Y),836) +#define get_csv_bool_pos836(X,Y) get_csv_bool((X),(Y),836) +#define get_csv_int_pos836(X,Y) get_csv_int((X),(Y),836) +#define get_csv_llong_pos836(X,Y) get_csv_llong((X),(Y),836) +#define get_csv_float_pos836(X,Y) get_csv_float((X),(Y),836) +#define get_csv_uint_pos837(X,Y) get_csv_uint((X),(Y),837) +#define get_csv_ullong_pos837(X,Y) get_csv_ullong((X),(Y),837) +#define get_csv_ip_pos837(X,Y) get_csv_ip((X),(Y),837) +#define get_csv_ipv6_pos837(X,Y) get_csv_ipv6((X),(Y),837) +#define get_csv_string_pos837(X,Y) get_csv_string((X),(Y),837) +#define get_csv_v_str_pos837(X,Y) get_csv_string((X),(Y),837) +#define get_csv_bool_pos837(X,Y) get_csv_bool((X),(Y),837) +#define get_csv_int_pos837(X,Y) get_csv_int((X),(Y),837) +#define get_csv_llong_pos837(X,Y) get_csv_llong((X),(Y),837) +#define get_csv_float_pos837(X,Y) get_csv_float((X),(Y),837) +#define get_csv_uint_pos838(X,Y) get_csv_uint((X),(Y),838) +#define get_csv_ullong_pos838(X,Y) get_csv_ullong((X),(Y),838) +#define get_csv_ip_pos838(X,Y) get_csv_ip((X),(Y),838) +#define get_csv_ipv6_pos838(X,Y) get_csv_ipv6((X),(Y),838) +#define get_csv_string_pos838(X,Y) get_csv_string((X),(Y),838) +#define get_csv_v_str_pos838(X,Y) get_csv_string((X),(Y),838) +#define get_csv_bool_pos838(X,Y) get_csv_bool((X),(Y),838) +#define get_csv_int_pos838(X,Y) get_csv_int((X),(Y),838) +#define get_csv_llong_pos838(X,Y) get_csv_llong((X),(Y),838) +#define get_csv_float_pos838(X,Y) get_csv_float((X),(Y),838) +#define get_csv_uint_pos839(X,Y) get_csv_uint((X),(Y),839) +#define get_csv_ullong_pos839(X,Y) get_csv_ullong((X),(Y),839) +#define get_csv_ip_pos839(X,Y) get_csv_ip((X),(Y),839) +#define get_csv_ipv6_pos839(X,Y) get_csv_ipv6((X),(Y),839) +#define get_csv_string_pos839(X,Y) get_csv_string((X),(Y),839) +#define get_csv_v_str_pos839(X,Y) get_csv_string((X),(Y),839) +#define get_csv_bool_pos839(X,Y) get_csv_bool((X),(Y),839) +#define get_csv_int_pos839(X,Y) get_csv_int((X),(Y),839) +#define get_csv_llong_pos839(X,Y) get_csv_llong((X),(Y),839) +#define get_csv_float_pos839(X,Y) get_csv_float((X),(Y),839) +#define get_csv_uint_pos840(X,Y) get_csv_uint((X),(Y),840) +#define get_csv_ullong_pos840(X,Y) get_csv_ullong((X),(Y),840) +#define get_csv_ip_pos840(X,Y) get_csv_ip((X),(Y),840) +#define get_csv_ipv6_pos840(X,Y) get_csv_ipv6((X),(Y),840) +#define get_csv_string_pos840(X,Y) get_csv_string((X),(Y),840) +#define get_csv_v_str_pos840(X,Y) get_csv_string((X),(Y),840) +#define get_csv_bool_pos840(X,Y) get_csv_bool((X),(Y),840) +#define get_csv_int_pos840(X,Y) get_csv_int((X),(Y),840) +#define get_csv_llong_pos840(X,Y) get_csv_llong((X),(Y),840) +#define get_csv_float_pos840(X,Y) get_csv_float((X),(Y),840) +#define get_csv_uint_pos841(X,Y) get_csv_uint((X),(Y),841) +#define get_csv_ullong_pos841(X,Y) get_csv_ullong((X),(Y),841) +#define get_csv_ip_pos841(X,Y) get_csv_ip((X),(Y),841) +#define get_csv_ipv6_pos841(X,Y) get_csv_ipv6((X),(Y),841) +#define get_csv_string_pos841(X,Y) get_csv_string((X),(Y),841) +#define get_csv_v_str_pos841(X,Y) get_csv_string((X),(Y),841) +#define get_csv_bool_pos841(X,Y) get_csv_bool((X),(Y),841) +#define get_csv_int_pos841(X,Y) get_csv_int((X),(Y),841) +#define get_csv_llong_pos841(X,Y) get_csv_llong((X),(Y),841) +#define get_csv_float_pos841(X,Y) get_csv_float((X),(Y),841) +#define get_csv_uint_pos842(X,Y) get_csv_uint((X),(Y),842) +#define get_csv_ullong_pos842(X,Y) get_csv_ullong((X),(Y),842) +#define get_csv_ip_pos842(X,Y) get_csv_ip((X),(Y),842) +#define get_csv_ipv6_pos842(X,Y) get_csv_ipv6((X),(Y),842) +#define get_csv_string_pos842(X,Y) get_csv_string((X),(Y),842) +#define get_csv_v_str_pos842(X,Y) get_csv_string((X),(Y),842) +#define get_csv_bool_pos842(X,Y) get_csv_bool((X),(Y),842) +#define get_csv_int_pos842(X,Y) get_csv_int((X),(Y),842) +#define get_csv_llong_pos842(X,Y) get_csv_llong((X),(Y),842) +#define get_csv_float_pos842(X,Y) get_csv_float((X),(Y),842) +#define get_csv_uint_pos843(X,Y) get_csv_uint((X),(Y),843) +#define get_csv_ullong_pos843(X,Y) get_csv_ullong((X),(Y),843) +#define get_csv_ip_pos843(X,Y) get_csv_ip((X),(Y),843) +#define get_csv_ipv6_pos843(X,Y) get_csv_ipv6((X),(Y),843) +#define get_csv_string_pos843(X,Y) get_csv_string((X),(Y),843) +#define get_csv_v_str_pos843(X,Y) get_csv_string((X),(Y),843) +#define get_csv_bool_pos843(X,Y) get_csv_bool((X),(Y),843) +#define get_csv_int_pos843(X,Y) get_csv_int((X),(Y),843) +#define get_csv_llong_pos843(X,Y) get_csv_llong((X),(Y),843) +#define get_csv_float_pos843(X,Y) get_csv_float((X),(Y),843) +#define get_csv_uint_pos844(X,Y) get_csv_uint((X),(Y),844) +#define get_csv_ullong_pos844(X,Y) get_csv_ullong((X),(Y),844) +#define get_csv_ip_pos844(X,Y) get_csv_ip((X),(Y),844) +#define get_csv_ipv6_pos844(X,Y) get_csv_ipv6((X),(Y),844) +#define get_csv_string_pos844(X,Y) get_csv_string((X),(Y),844) +#define get_csv_v_str_pos844(X,Y) get_csv_string((X),(Y),844) +#define get_csv_bool_pos844(X,Y) get_csv_bool((X),(Y),844) +#define get_csv_int_pos844(X,Y) get_csv_int((X),(Y),844) +#define get_csv_llong_pos844(X,Y) get_csv_llong((X),(Y),844) +#define get_csv_float_pos844(X,Y) get_csv_float((X),(Y),844) +#define get_csv_uint_pos845(X,Y) get_csv_uint((X),(Y),845) +#define get_csv_ullong_pos845(X,Y) get_csv_ullong((X),(Y),845) +#define get_csv_ip_pos845(X,Y) get_csv_ip((X),(Y),845) +#define get_csv_ipv6_pos845(X,Y) get_csv_ipv6((X),(Y),845) +#define get_csv_string_pos845(X,Y) get_csv_string((X),(Y),845) +#define get_csv_v_str_pos845(X,Y) get_csv_string((X),(Y),845) +#define get_csv_bool_pos845(X,Y) get_csv_bool((X),(Y),845) +#define get_csv_int_pos845(X,Y) get_csv_int((X),(Y),845) +#define get_csv_llong_pos845(X,Y) get_csv_llong((X),(Y),845) +#define get_csv_float_pos845(X,Y) get_csv_float((X),(Y),845) +#define get_csv_uint_pos846(X,Y) get_csv_uint((X),(Y),846) +#define get_csv_ullong_pos846(X,Y) get_csv_ullong((X),(Y),846) +#define get_csv_ip_pos846(X,Y) get_csv_ip((X),(Y),846) +#define get_csv_ipv6_pos846(X,Y) get_csv_ipv6((X),(Y),846) +#define get_csv_string_pos846(X,Y) get_csv_string((X),(Y),846) +#define get_csv_v_str_pos846(X,Y) get_csv_string((X),(Y),846) +#define get_csv_bool_pos846(X,Y) get_csv_bool((X),(Y),846) +#define get_csv_int_pos846(X,Y) get_csv_int((X),(Y),846) +#define get_csv_llong_pos846(X,Y) get_csv_llong((X),(Y),846) +#define get_csv_float_pos846(X,Y) get_csv_float((X),(Y),846) +#define get_csv_uint_pos847(X,Y) get_csv_uint((X),(Y),847) +#define get_csv_ullong_pos847(X,Y) get_csv_ullong((X),(Y),847) +#define get_csv_ip_pos847(X,Y) get_csv_ip((X),(Y),847) +#define get_csv_ipv6_pos847(X,Y) get_csv_ipv6((X),(Y),847) +#define get_csv_string_pos847(X,Y) get_csv_string((X),(Y),847) +#define get_csv_v_str_pos847(X,Y) get_csv_string((X),(Y),847) +#define get_csv_bool_pos847(X,Y) get_csv_bool((X),(Y),847) +#define get_csv_int_pos847(X,Y) get_csv_int((X),(Y),847) +#define get_csv_llong_pos847(X,Y) get_csv_llong((X),(Y),847) +#define get_csv_float_pos847(X,Y) get_csv_float((X),(Y),847) +#define get_csv_uint_pos848(X,Y) get_csv_uint((X),(Y),848) +#define get_csv_ullong_pos848(X,Y) get_csv_ullong((X),(Y),848) +#define get_csv_ip_pos848(X,Y) get_csv_ip((X),(Y),848) +#define get_csv_ipv6_pos848(X,Y) get_csv_ipv6((X),(Y),848) +#define get_csv_string_pos848(X,Y) get_csv_string((X),(Y),848) +#define get_csv_v_str_pos848(X,Y) get_csv_string((X),(Y),848) +#define get_csv_bool_pos848(X,Y) get_csv_bool((X),(Y),848) +#define get_csv_int_pos848(X,Y) get_csv_int((X),(Y),848) +#define get_csv_llong_pos848(X,Y) get_csv_llong((X),(Y),848) +#define get_csv_float_pos848(X,Y) get_csv_float((X),(Y),848) +#define get_csv_uint_pos849(X,Y) get_csv_uint((X),(Y),849) +#define get_csv_ullong_pos849(X,Y) get_csv_ullong((X),(Y),849) +#define get_csv_ip_pos849(X,Y) get_csv_ip((X),(Y),849) +#define get_csv_ipv6_pos849(X,Y) get_csv_ipv6((X),(Y),849) +#define get_csv_string_pos849(X,Y) get_csv_string((X),(Y),849) +#define get_csv_v_str_pos849(X,Y) get_csv_string((X),(Y),849) +#define get_csv_bool_pos849(X,Y) get_csv_bool((X),(Y),849) +#define get_csv_int_pos849(X,Y) get_csv_int((X),(Y),849) +#define get_csv_llong_pos849(X,Y) get_csv_llong((X),(Y),849) +#define get_csv_float_pos849(X,Y) get_csv_float((X),(Y),849) +#define get_csv_uint_pos850(X,Y) get_csv_uint((X),(Y),850) +#define get_csv_ullong_pos850(X,Y) get_csv_ullong((X),(Y),850) +#define get_csv_ip_pos850(X,Y) get_csv_ip((X),(Y),850) +#define get_csv_ipv6_pos850(X,Y) get_csv_ipv6((X),(Y),850) +#define get_csv_string_pos850(X,Y) get_csv_string((X),(Y),850) +#define get_csv_v_str_pos850(X,Y) get_csv_string((X),(Y),850) +#define get_csv_bool_pos850(X,Y) get_csv_bool((X),(Y),850) +#define get_csv_int_pos850(X,Y) get_csv_int((X),(Y),850) +#define get_csv_llong_pos850(X,Y) get_csv_llong((X),(Y),850) +#define get_csv_float_pos850(X,Y) get_csv_float((X),(Y),850) +#define get_csv_uint_pos851(X,Y) get_csv_uint((X),(Y),851) +#define get_csv_ullong_pos851(X,Y) get_csv_ullong((X),(Y),851) +#define get_csv_ip_pos851(X,Y) get_csv_ip((X),(Y),851) +#define get_csv_ipv6_pos851(X,Y) get_csv_ipv6((X),(Y),851) +#define get_csv_string_pos851(X,Y) get_csv_string((X),(Y),851) +#define get_csv_v_str_pos851(X,Y) get_csv_string((X),(Y),851) +#define get_csv_bool_pos851(X,Y) get_csv_bool((X),(Y),851) +#define get_csv_int_pos851(X,Y) get_csv_int((X),(Y),851) +#define get_csv_llong_pos851(X,Y) get_csv_llong((X),(Y),851) +#define get_csv_float_pos851(X,Y) get_csv_float((X),(Y),851) +#define get_csv_uint_pos852(X,Y) get_csv_uint((X),(Y),852) +#define get_csv_ullong_pos852(X,Y) get_csv_ullong((X),(Y),852) +#define get_csv_ip_pos852(X,Y) get_csv_ip((X),(Y),852) +#define get_csv_ipv6_pos852(X,Y) get_csv_ipv6((X),(Y),852) +#define get_csv_string_pos852(X,Y) get_csv_string((X),(Y),852) +#define get_csv_v_str_pos852(X,Y) get_csv_string((X),(Y),852) +#define get_csv_bool_pos852(X,Y) get_csv_bool((X),(Y),852) +#define get_csv_int_pos852(X,Y) get_csv_int((X),(Y),852) +#define get_csv_llong_pos852(X,Y) get_csv_llong((X),(Y),852) +#define get_csv_float_pos852(X,Y) get_csv_float((X),(Y),852) +#define get_csv_uint_pos853(X,Y) get_csv_uint((X),(Y),853) +#define get_csv_ullong_pos853(X,Y) get_csv_ullong((X),(Y),853) +#define get_csv_ip_pos853(X,Y) get_csv_ip((X),(Y),853) +#define get_csv_ipv6_pos853(X,Y) get_csv_ipv6((X),(Y),853) +#define get_csv_string_pos853(X,Y) get_csv_string((X),(Y),853) +#define get_csv_v_str_pos853(X,Y) get_csv_string((X),(Y),853) +#define get_csv_bool_pos853(X,Y) get_csv_bool((X),(Y),853) +#define get_csv_int_pos853(X,Y) get_csv_int((X),(Y),853) +#define get_csv_llong_pos853(X,Y) get_csv_llong((X),(Y),853) +#define get_csv_float_pos853(X,Y) get_csv_float((X),(Y),853) +#define get_csv_uint_pos854(X,Y) get_csv_uint((X),(Y),854) +#define get_csv_ullong_pos854(X,Y) get_csv_ullong((X),(Y),854) +#define get_csv_ip_pos854(X,Y) get_csv_ip((X),(Y),854) +#define get_csv_ipv6_pos854(X,Y) get_csv_ipv6((X),(Y),854) +#define get_csv_string_pos854(X,Y) get_csv_string((X),(Y),854) +#define get_csv_v_str_pos854(X,Y) get_csv_string((X),(Y),854) +#define get_csv_bool_pos854(X,Y) get_csv_bool((X),(Y),854) +#define get_csv_int_pos854(X,Y) get_csv_int((X),(Y),854) +#define get_csv_llong_pos854(X,Y) get_csv_llong((X),(Y),854) +#define get_csv_float_pos854(X,Y) get_csv_float((X),(Y),854) +#define get_csv_uint_pos855(X,Y) get_csv_uint((X),(Y),855) +#define get_csv_ullong_pos855(X,Y) get_csv_ullong((X),(Y),855) +#define get_csv_ip_pos855(X,Y) get_csv_ip((X),(Y),855) +#define get_csv_ipv6_pos855(X,Y) get_csv_ipv6((X),(Y),855) +#define get_csv_string_pos855(X,Y) get_csv_string((X),(Y),855) +#define get_csv_v_str_pos855(X,Y) get_csv_string((X),(Y),855) +#define get_csv_bool_pos855(X,Y) get_csv_bool((X),(Y),855) +#define get_csv_int_pos855(X,Y) get_csv_int((X),(Y),855) +#define get_csv_llong_pos855(X,Y) get_csv_llong((X),(Y),855) +#define get_csv_float_pos855(X,Y) get_csv_float((X),(Y),855) +#define get_csv_uint_pos856(X,Y) get_csv_uint((X),(Y),856) +#define get_csv_ullong_pos856(X,Y) get_csv_ullong((X),(Y),856) +#define get_csv_ip_pos856(X,Y) get_csv_ip((X),(Y),856) +#define get_csv_ipv6_pos856(X,Y) get_csv_ipv6((X),(Y),856) +#define get_csv_string_pos856(X,Y) get_csv_string((X),(Y),856) +#define get_csv_v_str_pos856(X,Y) get_csv_string((X),(Y),856) +#define get_csv_bool_pos856(X,Y) get_csv_bool((X),(Y),856) +#define get_csv_int_pos856(X,Y) get_csv_int((X),(Y),856) +#define get_csv_llong_pos856(X,Y) get_csv_llong((X),(Y),856) +#define get_csv_float_pos856(X,Y) get_csv_float((X),(Y),856) +#define get_csv_uint_pos857(X,Y) get_csv_uint((X),(Y),857) +#define get_csv_ullong_pos857(X,Y) get_csv_ullong((X),(Y),857) +#define get_csv_ip_pos857(X,Y) get_csv_ip((X),(Y),857) +#define get_csv_ipv6_pos857(X,Y) get_csv_ipv6((X),(Y),857) +#define get_csv_string_pos857(X,Y) get_csv_string((X),(Y),857) +#define get_csv_v_str_pos857(X,Y) get_csv_string((X),(Y),857) +#define get_csv_bool_pos857(X,Y) get_csv_bool((X),(Y),857) +#define get_csv_int_pos857(X,Y) get_csv_int((X),(Y),857) +#define get_csv_llong_pos857(X,Y) get_csv_llong((X),(Y),857) +#define get_csv_float_pos857(X,Y) get_csv_float((X),(Y),857) +#define get_csv_uint_pos858(X,Y) get_csv_uint((X),(Y),858) +#define get_csv_ullong_pos858(X,Y) get_csv_ullong((X),(Y),858) +#define get_csv_ip_pos858(X,Y) get_csv_ip((X),(Y),858) +#define get_csv_ipv6_pos858(X,Y) get_csv_ipv6((X),(Y),858) +#define get_csv_string_pos858(X,Y) get_csv_string((X),(Y),858) +#define get_csv_v_str_pos858(X,Y) get_csv_string((X),(Y),858) +#define get_csv_bool_pos858(X,Y) get_csv_bool((X),(Y),858) +#define get_csv_int_pos858(X,Y) get_csv_int((X),(Y),858) +#define get_csv_llong_pos858(X,Y) get_csv_llong((X),(Y),858) +#define get_csv_float_pos858(X,Y) get_csv_float((X),(Y),858) +#define get_csv_uint_pos859(X,Y) get_csv_uint((X),(Y),859) +#define get_csv_ullong_pos859(X,Y) get_csv_ullong((X),(Y),859) +#define get_csv_ip_pos859(X,Y) get_csv_ip((X),(Y),859) +#define get_csv_ipv6_pos859(X,Y) get_csv_ipv6((X),(Y),859) +#define get_csv_string_pos859(X,Y) get_csv_string((X),(Y),859) +#define get_csv_v_str_pos859(X,Y) get_csv_string((X),(Y),859) +#define get_csv_bool_pos859(X,Y) get_csv_bool((X),(Y),859) +#define get_csv_int_pos859(X,Y) get_csv_int((X),(Y),859) +#define get_csv_llong_pos859(X,Y) get_csv_llong((X),(Y),859) +#define get_csv_float_pos859(X,Y) get_csv_float((X),(Y),859) +#define get_csv_uint_pos860(X,Y) get_csv_uint((X),(Y),860) +#define get_csv_ullong_pos860(X,Y) get_csv_ullong((X),(Y),860) +#define get_csv_ip_pos860(X,Y) get_csv_ip((X),(Y),860) +#define get_csv_ipv6_pos860(X,Y) get_csv_ipv6((X),(Y),860) +#define get_csv_string_pos860(X,Y) get_csv_string((X),(Y),860) +#define get_csv_v_str_pos860(X,Y) get_csv_string((X),(Y),860) +#define get_csv_bool_pos860(X,Y) get_csv_bool((X),(Y),860) +#define get_csv_int_pos860(X,Y) get_csv_int((X),(Y),860) +#define get_csv_llong_pos860(X,Y) get_csv_llong((X),(Y),860) +#define get_csv_float_pos860(X,Y) get_csv_float((X),(Y),860) +#define get_csv_uint_pos861(X,Y) get_csv_uint((X),(Y),861) +#define get_csv_ullong_pos861(X,Y) get_csv_ullong((X),(Y),861) +#define get_csv_ip_pos861(X,Y) get_csv_ip((X),(Y),861) +#define get_csv_ipv6_pos861(X,Y) get_csv_ipv6((X),(Y),861) +#define get_csv_string_pos861(X,Y) get_csv_string((X),(Y),861) +#define get_csv_v_str_pos861(X,Y) get_csv_string((X),(Y),861) +#define get_csv_bool_pos861(X,Y) get_csv_bool((X),(Y),861) +#define get_csv_int_pos861(X,Y) get_csv_int((X),(Y),861) +#define get_csv_llong_pos861(X,Y) get_csv_llong((X),(Y),861) +#define get_csv_float_pos861(X,Y) get_csv_float((X),(Y),861) +#define get_csv_uint_pos862(X,Y) get_csv_uint((X),(Y),862) +#define get_csv_ullong_pos862(X,Y) get_csv_ullong((X),(Y),862) +#define get_csv_ip_pos862(X,Y) get_csv_ip((X),(Y),862) +#define get_csv_ipv6_pos862(X,Y) get_csv_ipv6((X),(Y),862) +#define get_csv_string_pos862(X,Y) get_csv_string((X),(Y),862) +#define get_csv_v_str_pos862(X,Y) get_csv_string((X),(Y),862) +#define get_csv_bool_pos862(X,Y) get_csv_bool((X),(Y),862) +#define get_csv_int_pos862(X,Y) get_csv_int((X),(Y),862) +#define get_csv_llong_pos862(X,Y) get_csv_llong((X),(Y),862) +#define get_csv_float_pos862(X,Y) get_csv_float((X),(Y),862) +#define get_csv_uint_pos863(X,Y) get_csv_uint((X),(Y),863) +#define get_csv_ullong_pos863(X,Y) get_csv_ullong((X),(Y),863) +#define get_csv_ip_pos863(X,Y) get_csv_ip((X),(Y),863) +#define get_csv_ipv6_pos863(X,Y) get_csv_ipv6((X),(Y),863) +#define get_csv_string_pos863(X,Y) get_csv_string((X),(Y),863) +#define get_csv_v_str_pos863(X,Y) get_csv_string((X),(Y),863) +#define get_csv_bool_pos863(X,Y) get_csv_bool((X),(Y),863) +#define get_csv_int_pos863(X,Y) get_csv_int((X),(Y),863) +#define get_csv_llong_pos863(X,Y) get_csv_llong((X),(Y),863) +#define get_csv_float_pos863(X,Y) get_csv_float((X),(Y),863) +#define get_csv_uint_pos864(X,Y) get_csv_uint((X),(Y),864) +#define get_csv_ullong_pos864(X,Y) get_csv_ullong((X),(Y),864) +#define get_csv_ip_pos864(X,Y) get_csv_ip((X),(Y),864) +#define get_csv_ipv6_pos864(X,Y) get_csv_ipv6((X),(Y),864) +#define get_csv_string_pos864(X,Y) get_csv_string((X),(Y),864) +#define get_csv_v_str_pos864(X,Y) get_csv_string((X),(Y),864) +#define get_csv_bool_pos864(X,Y) get_csv_bool((X),(Y),864) +#define get_csv_int_pos864(X,Y) get_csv_int((X),(Y),864) +#define get_csv_llong_pos864(X,Y) get_csv_llong((X),(Y),864) +#define get_csv_float_pos864(X,Y) get_csv_float((X),(Y),864) +#define get_csv_uint_pos865(X,Y) get_csv_uint((X),(Y),865) +#define get_csv_ullong_pos865(X,Y) get_csv_ullong((X),(Y),865) +#define get_csv_ip_pos865(X,Y) get_csv_ip((X),(Y),865) +#define get_csv_ipv6_pos865(X,Y) get_csv_ipv6((X),(Y),865) +#define get_csv_string_pos865(X,Y) get_csv_string((X),(Y),865) +#define get_csv_v_str_pos865(X,Y) get_csv_string((X),(Y),865) +#define get_csv_bool_pos865(X,Y) get_csv_bool((X),(Y),865) +#define get_csv_int_pos865(X,Y) get_csv_int((X),(Y),865) +#define get_csv_llong_pos865(X,Y) get_csv_llong((X),(Y),865) +#define get_csv_float_pos865(X,Y) get_csv_float((X),(Y),865) +#define get_csv_uint_pos866(X,Y) get_csv_uint((X),(Y),866) +#define get_csv_ullong_pos866(X,Y) get_csv_ullong((X),(Y),866) +#define get_csv_ip_pos866(X,Y) get_csv_ip((X),(Y),866) +#define get_csv_ipv6_pos866(X,Y) get_csv_ipv6((X),(Y),866) +#define get_csv_string_pos866(X,Y) get_csv_string((X),(Y),866) +#define get_csv_v_str_pos866(X,Y) get_csv_string((X),(Y),866) +#define get_csv_bool_pos866(X,Y) get_csv_bool((X),(Y),866) +#define get_csv_int_pos866(X,Y) get_csv_int((X),(Y),866) +#define get_csv_llong_pos866(X,Y) get_csv_llong((X),(Y),866) +#define get_csv_float_pos866(X,Y) get_csv_float((X),(Y),866) +#define get_csv_uint_pos867(X,Y) get_csv_uint((X),(Y),867) +#define get_csv_ullong_pos867(X,Y) get_csv_ullong((X),(Y),867) +#define get_csv_ip_pos867(X,Y) get_csv_ip((X),(Y),867) +#define get_csv_ipv6_pos867(X,Y) get_csv_ipv6((X),(Y),867) +#define get_csv_string_pos867(X,Y) get_csv_string((X),(Y),867) +#define get_csv_v_str_pos867(X,Y) get_csv_string((X),(Y),867) +#define get_csv_bool_pos867(X,Y) get_csv_bool((X),(Y),867) +#define get_csv_int_pos867(X,Y) get_csv_int((X),(Y),867) +#define get_csv_llong_pos867(X,Y) get_csv_llong((X),(Y),867) +#define get_csv_float_pos867(X,Y) get_csv_float((X),(Y),867) +#define get_csv_uint_pos868(X,Y) get_csv_uint((X),(Y),868) +#define get_csv_ullong_pos868(X,Y) get_csv_ullong((X),(Y),868) +#define get_csv_ip_pos868(X,Y) get_csv_ip((X),(Y),868) +#define get_csv_ipv6_pos868(X,Y) get_csv_ipv6((X),(Y),868) +#define get_csv_string_pos868(X,Y) get_csv_string((X),(Y),868) +#define get_csv_v_str_pos868(X,Y) get_csv_string((X),(Y),868) +#define get_csv_bool_pos868(X,Y) get_csv_bool((X),(Y),868) +#define get_csv_int_pos868(X,Y) get_csv_int((X),(Y),868) +#define get_csv_llong_pos868(X,Y) get_csv_llong((X),(Y),868) +#define get_csv_float_pos868(X,Y) get_csv_float((X),(Y),868) +#define get_csv_uint_pos869(X,Y) get_csv_uint((X),(Y),869) +#define get_csv_ullong_pos869(X,Y) get_csv_ullong((X),(Y),869) +#define get_csv_ip_pos869(X,Y) get_csv_ip((X),(Y),869) +#define get_csv_ipv6_pos869(X,Y) get_csv_ipv6((X),(Y),869) +#define get_csv_string_pos869(X,Y) get_csv_string((X),(Y),869) +#define get_csv_v_str_pos869(X,Y) get_csv_string((X),(Y),869) +#define get_csv_bool_pos869(X,Y) get_csv_bool((X),(Y),869) +#define get_csv_int_pos869(X,Y) get_csv_int((X),(Y),869) +#define get_csv_llong_pos869(X,Y) get_csv_llong((X),(Y),869) +#define get_csv_float_pos869(X,Y) get_csv_float((X),(Y),869) +#define get_csv_uint_pos870(X,Y) get_csv_uint((X),(Y),870) +#define get_csv_ullong_pos870(X,Y) get_csv_ullong((X),(Y),870) +#define get_csv_ip_pos870(X,Y) get_csv_ip((X),(Y),870) +#define get_csv_ipv6_pos870(X,Y) get_csv_ipv6((X),(Y),870) +#define get_csv_string_pos870(X,Y) get_csv_string((X),(Y),870) +#define get_csv_v_str_pos870(X,Y) get_csv_string((X),(Y),870) +#define get_csv_bool_pos870(X,Y) get_csv_bool((X),(Y),870) +#define get_csv_int_pos870(X,Y) get_csv_int((X),(Y),870) +#define get_csv_llong_pos870(X,Y) get_csv_llong((X),(Y),870) +#define get_csv_float_pos870(X,Y) get_csv_float((X),(Y),870) +#define get_csv_uint_pos871(X,Y) get_csv_uint((X),(Y),871) +#define get_csv_ullong_pos871(X,Y) get_csv_ullong((X),(Y),871) +#define get_csv_ip_pos871(X,Y) get_csv_ip((X),(Y),871) +#define get_csv_ipv6_pos871(X,Y) get_csv_ipv6((X),(Y),871) +#define get_csv_string_pos871(X,Y) get_csv_string((X),(Y),871) +#define get_csv_v_str_pos871(X,Y) get_csv_string((X),(Y),871) +#define get_csv_bool_pos871(X,Y) get_csv_bool((X),(Y),871) +#define get_csv_int_pos871(X,Y) get_csv_int((X),(Y),871) +#define get_csv_llong_pos871(X,Y) get_csv_llong((X),(Y),871) +#define get_csv_float_pos871(X,Y) get_csv_float((X),(Y),871) +#define get_csv_uint_pos872(X,Y) get_csv_uint((X),(Y),872) +#define get_csv_ullong_pos872(X,Y) get_csv_ullong((X),(Y),872) +#define get_csv_ip_pos872(X,Y) get_csv_ip((X),(Y),872) +#define get_csv_ipv6_pos872(X,Y) get_csv_ipv6((X),(Y),872) +#define get_csv_string_pos872(X,Y) get_csv_string((X),(Y),872) +#define get_csv_v_str_pos872(X,Y) get_csv_string((X),(Y),872) +#define get_csv_bool_pos872(X,Y) get_csv_bool((X),(Y),872) +#define get_csv_int_pos872(X,Y) get_csv_int((X),(Y),872) +#define get_csv_llong_pos872(X,Y) get_csv_llong((X),(Y),872) +#define get_csv_float_pos872(X,Y) get_csv_float((X),(Y),872) +#define get_csv_uint_pos873(X,Y) get_csv_uint((X),(Y),873) +#define get_csv_ullong_pos873(X,Y) get_csv_ullong((X),(Y),873) +#define get_csv_ip_pos873(X,Y) get_csv_ip((X),(Y),873) +#define get_csv_ipv6_pos873(X,Y) get_csv_ipv6((X),(Y),873) +#define get_csv_string_pos873(X,Y) get_csv_string((X),(Y),873) +#define get_csv_v_str_pos873(X,Y) get_csv_string((X),(Y),873) +#define get_csv_bool_pos873(X,Y) get_csv_bool((X),(Y),873) +#define get_csv_int_pos873(X,Y) get_csv_int((X),(Y),873) +#define get_csv_llong_pos873(X,Y) get_csv_llong((X),(Y),873) +#define get_csv_float_pos873(X,Y) get_csv_float((X),(Y),873) +#define get_csv_uint_pos874(X,Y) get_csv_uint((X),(Y),874) +#define get_csv_ullong_pos874(X,Y) get_csv_ullong((X),(Y),874) +#define get_csv_ip_pos874(X,Y) get_csv_ip((X),(Y),874) +#define get_csv_ipv6_pos874(X,Y) get_csv_ipv6((X),(Y),874) +#define get_csv_string_pos874(X,Y) get_csv_string((X),(Y),874) +#define get_csv_v_str_pos874(X,Y) get_csv_string((X),(Y),874) +#define get_csv_bool_pos874(X,Y) get_csv_bool((X),(Y),874) +#define get_csv_int_pos874(X,Y) get_csv_int((X),(Y),874) +#define get_csv_llong_pos874(X,Y) get_csv_llong((X),(Y),874) +#define get_csv_float_pos874(X,Y) get_csv_float((X),(Y),874) +#define get_csv_uint_pos875(X,Y) get_csv_uint((X),(Y),875) +#define get_csv_ullong_pos875(X,Y) get_csv_ullong((X),(Y),875) +#define get_csv_ip_pos875(X,Y) get_csv_ip((X),(Y),875) +#define get_csv_ipv6_pos875(X,Y) get_csv_ipv6((X),(Y),875) +#define get_csv_string_pos875(X,Y) get_csv_string((X),(Y),875) +#define get_csv_v_str_pos875(X,Y) get_csv_string((X),(Y),875) +#define get_csv_bool_pos875(X,Y) get_csv_bool((X),(Y),875) +#define get_csv_int_pos875(X,Y) get_csv_int((X),(Y),875) +#define get_csv_llong_pos875(X,Y) get_csv_llong((X),(Y),875) +#define get_csv_float_pos875(X,Y) get_csv_float((X),(Y),875) +#define get_csv_uint_pos876(X,Y) get_csv_uint((X),(Y),876) +#define get_csv_ullong_pos876(X,Y) get_csv_ullong((X),(Y),876) +#define get_csv_ip_pos876(X,Y) get_csv_ip((X),(Y),876) +#define get_csv_ipv6_pos876(X,Y) get_csv_ipv6((X),(Y),876) +#define get_csv_string_pos876(X,Y) get_csv_string((X),(Y),876) +#define get_csv_v_str_pos876(X,Y) get_csv_string((X),(Y),876) +#define get_csv_bool_pos876(X,Y) get_csv_bool((X),(Y),876) +#define get_csv_int_pos876(X,Y) get_csv_int((X),(Y),876) +#define get_csv_llong_pos876(X,Y) get_csv_llong((X),(Y),876) +#define get_csv_float_pos876(X,Y) get_csv_float((X),(Y),876) +#define get_csv_uint_pos877(X,Y) get_csv_uint((X),(Y),877) +#define get_csv_ullong_pos877(X,Y) get_csv_ullong((X),(Y),877) +#define get_csv_ip_pos877(X,Y) get_csv_ip((X),(Y),877) +#define get_csv_ipv6_pos877(X,Y) get_csv_ipv6((X),(Y),877) +#define get_csv_string_pos877(X,Y) get_csv_string((X),(Y),877) +#define get_csv_v_str_pos877(X,Y) get_csv_string((X),(Y),877) +#define get_csv_bool_pos877(X,Y) get_csv_bool((X),(Y),877) +#define get_csv_int_pos877(X,Y) get_csv_int((X),(Y),877) +#define get_csv_llong_pos877(X,Y) get_csv_llong((X),(Y),877) +#define get_csv_float_pos877(X,Y) get_csv_float((X),(Y),877) +#define get_csv_uint_pos878(X,Y) get_csv_uint((X),(Y),878) +#define get_csv_ullong_pos878(X,Y) get_csv_ullong((X),(Y),878) +#define get_csv_ip_pos878(X,Y) get_csv_ip((X),(Y),878) +#define get_csv_ipv6_pos878(X,Y) get_csv_ipv6((X),(Y),878) +#define get_csv_string_pos878(X,Y) get_csv_string((X),(Y),878) +#define get_csv_v_str_pos878(X,Y) get_csv_string((X),(Y),878) +#define get_csv_bool_pos878(X,Y) get_csv_bool((X),(Y),878) +#define get_csv_int_pos878(X,Y) get_csv_int((X),(Y),878) +#define get_csv_llong_pos878(X,Y) get_csv_llong((X),(Y),878) +#define get_csv_float_pos878(X,Y) get_csv_float((X),(Y),878) +#define get_csv_uint_pos879(X,Y) get_csv_uint((X),(Y),879) +#define get_csv_ullong_pos879(X,Y) get_csv_ullong((X),(Y),879) +#define get_csv_ip_pos879(X,Y) get_csv_ip((X),(Y),879) +#define get_csv_ipv6_pos879(X,Y) get_csv_ipv6((X),(Y),879) +#define get_csv_string_pos879(X,Y) get_csv_string((X),(Y),879) +#define get_csv_v_str_pos879(X,Y) get_csv_string((X),(Y),879) +#define get_csv_bool_pos879(X,Y) get_csv_bool((X),(Y),879) +#define get_csv_int_pos879(X,Y) get_csv_int((X),(Y),879) +#define get_csv_llong_pos879(X,Y) get_csv_llong((X),(Y),879) +#define get_csv_float_pos879(X,Y) get_csv_float((X),(Y),879) +#define get_csv_uint_pos880(X,Y) get_csv_uint((X),(Y),880) +#define get_csv_ullong_pos880(X,Y) get_csv_ullong((X),(Y),880) +#define get_csv_ip_pos880(X,Y) get_csv_ip((X),(Y),880) +#define get_csv_ipv6_pos880(X,Y) get_csv_ipv6((X),(Y),880) +#define get_csv_string_pos880(X,Y) get_csv_string((X),(Y),880) +#define get_csv_v_str_pos880(X,Y) get_csv_string((X),(Y),880) +#define get_csv_bool_pos880(X,Y) get_csv_bool((X),(Y),880) +#define get_csv_int_pos880(X,Y) get_csv_int((X),(Y),880) +#define get_csv_llong_pos880(X,Y) get_csv_llong((X),(Y),880) +#define get_csv_float_pos880(X,Y) get_csv_float((X),(Y),880) +#define get_csv_uint_pos881(X,Y) get_csv_uint((X),(Y),881) +#define get_csv_ullong_pos881(X,Y) get_csv_ullong((X),(Y),881) +#define get_csv_ip_pos881(X,Y) get_csv_ip((X),(Y),881) +#define get_csv_ipv6_pos881(X,Y) get_csv_ipv6((X),(Y),881) +#define get_csv_string_pos881(X,Y) get_csv_string((X),(Y),881) +#define get_csv_v_str_pos881(X,Y) get_csv_string((X),(Y),881) +#define get_csv_bool_pos881(X,Y) get_csv_bool((X),(Y),881) +#define get_csv_int_pos881(X,Y) get_csv_int((X),(Y),881) +#define get_csv_llong_pos881(X,Y) get_csv_llong((X),(Y),881) +#define get_csv_float_pos881(X,Y) get_csv_float((X),(Y),881) +#define get_csv_uint_pos882(X,Y) get_csv_uint((X),(Y),882) +#define get_csv_ullong_pos882(X,Y) get_csv_ullong((X),(Y),882) +#define get_csv_ip_pos882(X,Y) get_csv_ip((X),(Y),882) +#define get_csv_ipv6_pos882(X,Y) get_csv_ipv6((X),(Y),882) +#define get_csv_string_pos882(X,Y) get_csv_string((X),(Y),882) +#define get_csv_v_str_pos882(X,Y) get_csv_string((X),(Y),882) +#define get_csv_bool_pos882(X,Y) get_csv_bool((X),(Y),882) +#define get_csv_int_pos882(X,Y) get_csv_int((X),(Y),882) +#define get_csv_llong_pos882(X,Y) get_csv_llong((X),(Y),882) +#define get_csv_float_pos882(X,Y) get_csv_float((X),(Y),882) +#define get_csv_uint_pos883(X,Y) get_csv_uint((X),(Y),883) +#define get_csv_ullong_pos883(X,Y) get_csv_ullong((X),(Y),883) +#define get_csv_ip_pos883(X,Y) get_csv_ip((X),(Y),883) +#define get_csv_ipv6_pos883(X,Y) get_csv_ipv6((X),(Y),883) +#define get_csv_string_pos883(X,Y) get_csv_string((X),(Y),883) +#define get_csv_v_str_pos883(X,Y) get_csv_string((X),(Y),883) +#define get_csv_bool_pos883(X,Y) get_csv_bool((X),(Y),883) +#define get_csv_int_pos883(X,Y) get_csv_int((X),(Y),883) +#define get_csv_llong_pos883(X,Y) get_csv_llong((X),(Y),883) +#define get_csv_float_pos883(X,Y) get_csv_float((X),(Y),883) +#define get_csv_uint_pos884(X,Y) get_csv_uint((X),(Y),884) +#define get_csv_ullong_pos884(X,Y) get_csv_ullong((X),(Y),884) +#define get_csv_ip_pos884(X,Y) get_csv_ip((X),(Y),884) +#define get_csv_ipv6_pos884(X,Y) get_csv_ipv6((X),(Y),884) +#define get_csv_string_pos884(X,Y) get_csv_string((X),(Y),884) +#define get_csv_v_str_pos884(X,Y) get_csv_string((X),(Y),884) +#define get_csv_bool_pos884(X,Y) get_csv_bool((X),(Y),884) +#define get_csv_int_pos884(X,Y) get_csv_int((X),(Y),884) +#define get_csv_llong_pos884(X,Y) get_csv_llong((X),(Y),884) +#define get_csv_float_pos884(X,Y) get_csv_float((X),(Y),884) +#define get_csv_uint_pos885(X,Y) get_csv_uint((X),(Y),885) +#define get_csv_ullong_pos885(X,Y) get_csv_ullong((X),(Y),885) +#define get_csv_ip_pos885(X,Y) get_csv_ip((X),(Y),885) +#define get_csv_ipv6_pos885(X,Y) get_csv_ipv6((X),(Y),885) +#define get_csv_string_pos885(X,Y) get_csv_string((X),(Y),885) +#define get_csv_v_str_pos885(X,Y) get_csv_string((X),(Y),885) +#define get_csv_bool_pos885(X,Y) get_csv_bool((X),(Y),885) +#define get_csv_int_pos885(X,Y) get_csv_int((X),(Y),885) +#define get_csv_llong_pos885(X,Y) get_csv_llong((X),(Y),885) +#define get_csv_float_pos885(X,Y) get_csv_float((X),(Y),885) +#define get_csv_uint_pos886(X,Y) get_csv_uint((X),(Y),886) +#define get_csv_ullong_pos886(X,Y) get_csv_ullong((X),(Y),886) +#define get_csv_ip_pos886(X,Y) get_csv_ip((X),(Y),886) +#define get_csv_ipv6_pos886(X,Y) get_csv_ipv6((X),(Y),886) +#define get_csv_string_pos886(X,Y) get_csv_string((X),(Y),886) +#define get_csv_v_str_pos886(X,Y) get_csv_string((X),(Y),886) +#define get_csv_bool_pos886(X,Y) get_csv_bool((X),(Y),886) +#define get_csv_int_pos886(X,Y) get_csv_int((X),(Y),886) +#define get_csv_llong_pos886(X,Y) get_csv_llong((X),(Y),886) +#define get_csv_float_pos886(X,Y) get_csv_float((X),(Y),886) +#define get_csv_uint_pos887(X,Y) get_csv_uint((X),(Y),887) +#define get_csv_ullong_pos887(X,Y) get_csv_ullong((X),(Y),887) +#define get_csv_ip_pos887(X,Y) get_csv_ip((X),(Y),887) +#define get_csv_ipv6_pos887(X,Y) get_csv_ipv6((X),(Y),887) +#define get_csv_string_pos887(X,Y) get_csv_string((X),(Y),887) +#define get_csv_v_str_pos887(X,Y) get_csv_string((X),(Y),887) +#define get_csv_bool_pos887(X,Y) get_csv_bool((X),(Y),887) +#define get_csv_int_pos887(X,Y) get_csv_int((X),(Y),887) +#define get_csv_llong_pos887(X,Y) get_csv_llong((X),(Y),887) +#define get_csv_float_pos887(X,Y) get_csv_float((X),(Y),887) +#define get_csv_uint_pos888(X,Y) get_csv_uint((X),(Y),888) +#define get_csv_ullong_pos888(X,Y) get_csv_ullong((X),(Y),888) +#define get_csv_ip_pos888(X,Y) get_csv_ip((X),(Y),888) +#define get_csv_ipv6_pos888(X,Y) get_csv_ipv6((X),(Y),888) +#define get_csv_string_pos888(X,Y) get_csv_string((X),(Y),888) +#define get_csv_v_str_pos888(X,Y) get_csv_string((X),(Y),888) +#define get_csv_bool_pos888(X,Y) get_csv_bool((X),(Y),888) +#define get_csv_int_pos888(X,Y) get_csv_int((X),(Y),888) +#define get_csv_llong_pos888(X,Y) get_csv_llong((X),(Y),888) +#define get_csv_float_pos888(X,Y) get_csv_float((X),(Y),888) +#define get_csv_uint_pos889(X,Y) get_csv_uint((X),(Y),889) +#define get_csv_ullong_pos889(X,Y) get_csv_ullong((X),(Y),889) +#define get_csv_ip_pos889(X,Y) get_csv_ip((X),(Y),889) +#define get_csv_ipv6_pos889(X,Y) get_csv_ipv6((X),(Y),889) +#define get_csv_string_pos889(X,Y) get_csv_string((X),(Y),889) +#define get_csv_v_str_pos889(X,Y) get_csv_string((X),(Y),889) +#define get_csv_bool_pos889(X,Y) get_csv_bool((X),(Y),889) +#define get_csv_int_pos889(X,Y) get_csv_int((X),(Y),889) +#define get_csv_llong_pos889(X,Y) get_csv_llong((X),(Y),889) +#define get_csv_float_pos889(X,Y) get_csv_float((X),(Y),889) +#define get_csv_uint_pos890(X,Y) get_csv_uint((X),(Y),890) +#define get_csv_ullong_pos890(X,Y) get_csv_ullong((X),(Y),890) +#define get_csv_ip_pos890(X,Y) get_csv_ip((X),(Y),890) +#define get_csv_ipv6_pos890(X,Y) get_csv_ipv6((X),(Y),890) +#define get_csv_string_pos890(X,Y) get_csv_string((X),(Y),890) +#define get_csv_v_str_pos890(X,Y) get_csv_string((X),(Y),890) +#define get_csv_bool_pos890(X,Y) get_csv_bool((X),(Y),890) +#define get_csv_int_pos890(X,Y) get_csv_int((X),(Y),890) +#define get_csv_llong_pos890(X,Y) get_csv_llong((X),(Y),890) +#define get_csv_float_pos890(X,Y) get_csv_float((X),(Y),890) +#define get_csv_uint_pos891(X,Y) get_csv_uint((X),(Y),891) +#define get_csv_ullong_pos891(X,Y) get_csv_ullong((X),(Y),891) +#define get_csv_ip_pos891(X,Y) get_csv_ip((X),(Y),891) +#define get_csv_ipv6_pos891(X,Y) get_csv_ipv6((X),(Y),891) +#define get_csv_string_pos891(X,Y) get_csv_string((X),(Y),891) +#define get_csv_v_str_pos891(X,Y) get_csv_string((X),(Y),891) +#define get_csv_bool_pos891(X,Y) get_csv_bool((X),(Y),891) +#define get_csv_int_pos891(X,Y) get_csv_int((X),(Y),891) +#define get_csv_llong_pos891(X,Y) get_csv_llong((X),(Y),891) +#define get_csv_float_pos891(X,Y) get_csv_float((X),(Y),891) +#define get_csv_uint_pos892(X,Y) get_csv_uint((X),(Y),892) +#define get_csv_ullong_pos892(X,Y) get_csv_ullong((X),(Y),892) +#define get_csv_ip_pos892(X,Y) get_csv_ip((X),(Y),892) +#define get_csv_ipv6_pos892(X,Y) get_csv_ipv6((X),(Y),892) +#define get_csv_string_pos892(X,Y) get_csv_string((X),(Y),892) +#define get_csv_v_str_pos892(X,Y) get_csv_string((X),(Y),892) +#define get_csv_bool_pos892(X,Y) get_csv_bool((X),(Y),892) +#define get_csv_int_pos892(X,Y) get_csv_int((X),(Y),892) +#define get_csv_llong_pos892(X,Y) get_csv_llong((X),(Y),892) +#define get_csv_float_pos892(X,Y) get_csv_float((X),(Y),892) +#define get_csv_uint_pos893(X,Y) get_csv_uint((X),(Y),893) +#define get_csv_ullong_pos893(X,Y) get_csv_ullong((X),(Y),893) +#define get_csv_ip_pos893(X,Y) get_csv_ip((X),(Y),893) +#define get_csv_ipv6_pos893(X,Y) get_csv_ipv6((X),(Y),893) +#define get_csv_string_pos893(X,Y) get_csv_string((X),(Y),893) +#define get_csv_v_str_pos893(X,Y) get_csv_string((X),(Y),893) +#define get_csv_bool_pos893(X,Y) get_csv_bool((X),(Y),893) +#define get_csv_int_pos893(X,Y) get_csv_int((X),(Y),893) +#define get_csv_llong_pos893(X,Y) get_csv_llong((X),(Y),893) +#define get_csv_float_pos893(X,Y) get_csv_float((X),(Y),893) +#define get_csv_uint_pos894(X,Y) get_csv_uint((X),(Y),894) +#define get_csv_ullong_pos894(X,Y) get_csv_ullong((X),(Y),894) +#define get_csv_ip_pos894(X,Y) get_csv_ip((X),(Y),894) +#define get_csv_ipv6_pos894(X,Y) get_csv_ipv6((X),(Y),894) +#define get_csv_string_pos894(X,Y) get_csv_string((X),(Y),894) +#define get_csv_v_str_pos894(X,Y) get_csv_string((X),(Y),894) +#define get_csv_bool_pos894(X,Y) get_csv_bool((X),(Y),894) +#define get_csv_int_pos894(X,Y) get_csv_int((X),(Y),894) +#define get_csv_llong_pos894(X,Y) get_csv_llong((X),(Y),894) +#define get_csv_float_pos894(X,Y) get_csv_float((X),(Y),894) +#define get_csv_uint_pos895(X,Y) get_csv_uint((X),(Y),895) +#define get_csv_ullong_pos895(X,Y) get_csv_ullong((X),(Y),895) +#define get_csv_ip_pos895(X,Y) get_csv_ip((X),(Y),895) +#define get_csv_ipv6_pos895(X,Y) get_csv_ipv6((X),(Y),895) +#define get_csv_string_pos895(X,Y) get_csv_string((X),(Y),895) +#define get_csv_v_str_pos895(X,Y) get_csv_string((X),(Y),895) +#define get_csv_bool_pos895(X,Y) get_csv_bool((X),(Y),895) +#define get_csv_int_pos895(X,Y) get_csv_int((X),(Y),895) +#define get_csv_llong_pos895(X,Y) get_csv_llong((X),(Y),895) +#define get_csv_float_pos895(X,Y) get_csv_float((X),(Y),895) +#define get_csv_uint_pos896(X,Y) get_csv_uint((X),(Y),896) +#define get_csv_ullong_pos896(X,Y) get_csv_ullong((X),(Y),896) +#define get_csv_ip_pos896(X,Y) get_csv_ip((X),(Y),896) +#define get_csv_ipv6_pos896(X,Y) get_csv_ipv6((X),(Y),896) +#define get_csv_string_pos896(X,Y) get_csv_string((X),(Y),896) +#define get_csv_v_str_pos896(X,Y) get_csv_string((X),(Y),896) +#define get_csv_bool_pos896(X,Y) get_csv_bool((X),(Y),896) +#define get_csv_int_pos896(X,Y) get_csv_int((X),(Y),896) +#define get_csv_llong_pos896(X,Y) get_csv_llong((X),(Y),896) +#define get_csv_float_pos896(X,Y) get_csv_float((X),(Y),896) +#define get_csv_uint_pos897(X,Y) get_csv_uint((X),(Y),897) +#define get_csv_ullong_pos897(X,Y) get_csv_ullong((X),(Y),897) +#define get_csv_ip_pos897(X,Y) get_csv_ip((X),(Y),897) +#define get_csv_ipv6_pos897(X,Y) get_csv_ipv6((X),(Y),897) +#define get_csv_string_pos897(X,Y) get_csv_string((X),(Y),897) +#define get_csv_v_str_pos897(X,Y) get_csv_string((X),(Y),897) +#define get_csv_bool_pos897(X,Y) get_csv_bool((X),(Y),897) +#define get_csv_int_pos897(X,Y) get_csv_int((X),(Y),897) +#define get_csv_llong_pos897(X,Y) get_csv_llong((X),(Y),897) +#define get_csv_float_pos897(X,Y) get_csv_float((X),(Y),897) +#define get_csv_uint_pos898(X,Y) get_csv_uint((X),(Y),898) +#define get_csv_ullong_pos898(X,Y) get_csv_ullong((X),(Y),898) +#define get_csv_ip_pos898(X,Y) get_csv_ip((X),(Y),898) +#define get_csv_ipv6_pos898(X,Y) get_csv_ipv6((X),(Y),898) +#define get_csv_string_pos898(X,Y) get_csv_string((X),(Y),898) +#define get_csv_v_str_pos898(X,Y) get_csv_string((X),(Y),898) +#define get_csv_bool_pos898(X,Y) get_csv_bool((X),(Y),898) +#define get_csv_int_pos898(X,Y) get_csv_int((X),(Y),898) +#define get_csv_llong_pos898(X,Y) get_csv_llong((X),(Y),898) +#define get_csv_float_pos898(X,Y) get_csv_float((X),(Y),898) +#define get_csv_uint_pos899(X,Y) get_csv_uint((X),(Y),899) +#define get_csv_ullong_pos899(X,Y) get_csv_ullong((X),(Y),899) +#define get_csv_ip_pos899(X,Y) get_csv_ip((X),(Y),899) +#define get_csv_ipv6_pos899(X,Y) get_csv_ipv6((X),(Y),899) +#define get_csv_string_pos899(X,Y) get_csv_string((X),(Y),899) +#define get_csv_v_str_pos899(X,Y) get_csv_string((X),(Y),899) +#define get_csv_bool_pos899(X,Y) get_csv_bool((X),(Y),899) +#define get_csv_int_pos899(X,Y) get_csv_int((X),(Y),899) +#define get_csv_llong_pos899(X,Y) get_csv_llong((X),(Y),899) +#define get_csv_float_pos899(X,Y) get_csv_float((X),(Y),899) +#define get_csv_uint_pos900(X,Y) get_csv_uint((X),(Y),900) +#define get_csv_ullong_pos900(X,Y) get_csv_ullong((X),(Y),900) +#define get_csv_ip_pos900(X,Y) get_csv_ip((X),(Y),900) +#define get_csv_ipv6_pos900(X,Y) get_csv_ipv6((X),(Y),900) +#define get_csv_string_pos900(X,Y) get_csv_string((X),(Y),900) +#define get_csv_v_str_pos900(X,Y) get_csv_string((X),(Y),900) +#define get_csv_bool_pos900(X,Y) get_csv_bool((X),(Y),900) +#define get_csv_int_pos900(X,Y) get_csv_int((X),(Y),900) +#define get_csv_llong_pos900(X,Y) get_csv_llong((X),(Y),900) +#define get_csv_float_pos900(X,Y) get_csv_float((X),(Y),900) +#define get_csv_uint_pos901(X,Y) get_csv_uint((X),(Y),901) +#define get_csv_ullong_pos901(X,Y) get_csv_ullong((X),(Y),901) +#define get_csv_ip_pos901(X,Y) get_csv_ip((X),(Y),901) +#define get_csv_ipv6_pos901(X,Y) get_csv_ipv6((X),(Y),901) +#define get_csv_string_pos901(X,Y) get_csv_string((X),(Y),901) +#define get_csv_v_str_pos901(X,Y) get_csv_string((X),(Y),901) +#define get_csv_bool_pos901(X,Y) get_csv_bool((X),(Y),901) +#define get_csv_int_pos901(X,Y) get_csv_int((X),(Y),901) +#define get_csv_llong_pos901(X,Y) get_csv_llong((X),(Y),901) +#define get_csv_float_pos901(X,Y) get_csv_float((X),(Y),901) +#define get_csv_uint_pos902(X,Y) get_csv_uint((X),(Y),902) +#define get_csv_ullong_pos902(X,Y) get_csv_ullong((X),(Y),902) +#define get_csv_ip_pos902(X,Y) get_csv_ip((X),(Y),902) +#define get_csv_ipv6_pos902(X,Y) get_csv_ipv6((X),(Y),902) +#define get_csv_string_pos902(X,Y) get_csv_string((X),(Y),902) +#define get_csv_v_str_pos902(X,Y) get_csv_string((X),(Y),902) +#define get_csv_bool_pos902(X,Y) get_csv_bool((X),(Y),902) +#define get_csv_int_pos902(X,Y) get_csv_int((X),(Y),902) +#define get_csv_llong_pos902(X,Y) get_csv_llong((X),(Y),902) +#define get_csv_float_pos902(X,Y) get_csv_float((X),(Y),902) +#define get_csv_uint_pos903(X,Y) get_csv_uint((X),(Y),903) +#define get_csv_ullong_pos903(X,Y) get_csv_ullong((X),(Y),903) +#define get_csv_ip_pos903(X,Y) get_csv_ip((X),(Y),903) +#define get_csv_ipv6_pos903(X,Y) get_csv_ipv6((X),(Y),903) +#define get_csv_string_pos903(X,Y) get_csv_string((X),(Y),903) +#define get_csv_v_str_pos903(X,Y) get_csv_string((X),(Y),903) +#define get_csv_bool_pos903(X,Y) get_csv_bool((X),(Y),903) +#define get_csv_int_pos903(X,Y) get_csv_int((X),(Y),903) +#define get_csv_llong_pos903(X,Y) get_csv_llong((X),(Y),903) +#define get_csv_float_pos903(X,Y) get_csv_float((X),(Y),903) +#define get_csv_uint_pos904(X,Y) get_csv_uint((X),(Y),904) +#define get_csv_ullong_pos904(X,Y) get_csv_ullong((X),(Y),904) +#define get_csv_ip_pos904(X,Y) get_csv_ip((X),(Y),904) +#define get_csv_ipv6_pos904(X,Y) get_csv_ipv6((X),(Y),904) +#define get_csv_string_pos904(X,Y) get_csv_string((X),(Y),904) +#define get_csv_v_str_pos904(X,Y) get_csv_string((X),(Y),904) +#define get_csv_bool_pos904(X,Y) get_csv_bool((X),(Y),904) +#define get_csv_int_pos904(X,Y) get_csv_int((X),(Y),904) +#define get_csv_llong_pos904(X,Y) get_csv_llong((X),(Y),904) +#define get_csv_float_pos904(X,Y) get_csv_float((X),(Y),904) +#define get_csv_uint_pos905(X,Y) get_csv_uint((X),(Y),905) +#define get_csv_ullong_pos905(X,Y) get_csv_ullong((X),(Y),905) +#define get_csv_ip_pos905(X,Y) get_csv_ip((X),(Y),905) +#define get_csv_ipv6_pos905(X,Y) get_csv_ipv6((X),(Y),905) +#define get_csv_string_pos905(X,Y) get_csv_string((X),(Y),905) +#define get_csv_v_str_pos905(X,Y) get_csv_string((X),(Y),905) +#define get_csv_bool_pos905(X,Y) get_csv_bool((X),(Y),905) +#define get_csv_int_pos905(X,Y) get_csv_int((X),(Y),905) +#define get_csv_llong_pos905(X,Y) get_csv_llong((X),(Y),905) +#define get_csv_float_pos905(X,Y) get_csv_float((X),(Y),905) +#define get_csv_uint_pos906(X,Y) get_csv_uint((X),(Y),906) +#define get_csv_ullong_pos906(X,Y) get_csv_ullong((X),(Y),906) +#define get_csv_ip_pos906(X,Y) get_csv_ip((X),(Y),906) +#define get_csv_ipv6_pos906(X,Y) get_csv_ipv6((X),(Y),906) +#define get_csv_string_pos906(X,Y) get_csv_string((X),(Y),906) +#define get_csv_v_str_pos906(X,Y) get_csv_string((X),(Y),906) +#define get_csv_bool_pos906(X,Y) get_csv_bool((X),(Y),906) +#define get_csv_int_pos906(X,Y) get_csv_int((X),(Y),906) +#define get_csv_llong_pos906(X,Y) get_csv_llong((X),(Y),906) +#define get_csv_float_pos906(X,Y) get_csv_float((X),(Y),906) +#define get_csv_uint_pos907(X,Y) get_csv_uint((X),(Y),907) +#define get_csv_ullong_pos907(X,Y) get_csv_ullong((X),(Y),907) +#define get_csv_ip_pos907(X,Y) get_csv_ip((X),(Y),907) +#define get_csv_ipv6_pos907(X,Y) get_csv_ipv6((X),(Y),907) +#define get_csv_string_pos907(X,Y) get_csv_string((X),(Y),907) +#define get_csv_v_str_pos907(X,Y) get_csv_string((X),(Y),907) +#define get_csv_bool_pos907(X,Y) get_csv_bool((X),(Y),907) +#define get_csv_int_pos907(X,Y) get_csv_int((X),(Y),907) +#define get_csv_llong_pos907(X,Y) get_csv_llong((X),(Y),907) +#define get_csv_float_pos907(X,Y) get_csv_float((X),(Y),907) +#define get_csv_uint_pos908(X,Y) get_csv_uint((X),(Y),908) +#define get_csv_ullong_pos908(X,Y) get_csv_ullong((X),(Y),908) +#define get_csv_ip_pos908(X,Y) get_csv_ip((X),(Y),908) +#define get_csv_ipv6_pos908(X,Y) get_csv_ipv6((X),(Y),908) +#define get_csv_string_pos908(X,Y) get_csv_string((X),(Y),908) +#define get_csv_v_str_pos908(X,Y) get_csv_string((X),(Y),908) +#define get_csv_bool_pos908(X,Y) get_csv_bool((X),(Y),908) +#define get_csv_int_pos908(X,Y) get_csv_int((X),(Y),908) +#define get_csv_llong_pos908(X,Y) get_csv_llong((X),(Y),908) +#define get_csv_float_pos908(X,Y) get_csv_float((X),(Y),908) +#define get_csv_uint_pos909(X,Y) get_csv_uint((X),(Y),909) +#define get_csv_ullong_pos909(X,Y) get_csv_ullong((X),(Y),909) +#define get_csv_ip_pos909(X,Y) get_csv_ip((X),(Y),909) +#define get_csv_ipv6_pos909(X,Y) get_csv_ipv6((X),(Y),909) +#define get_csv_string_pos909(X,Y) get_csv_string((X),(Y),909) +#define get_csv_v_str_pos909(X,Y) get_csv_string((X),(Y),909) +#define get_csv_bool_pos909(X,Y) get_csv_bool((X),(Y),909) +#define get_csv_int_pos909(X,Y) get_csv_int((X),(Y),909) +#define get_csv_llong_pos909(X,Y) get_csv_llong((X),(Y),909) +#define get_csv_float_pos909(X,Y) get_csv_float((X),(Y),909) +#define get_csv_uint_pos910(X,Y) get_csv_uint((X),(Y),910) +#define get_csv_ullong_pos910(X,Y) get_csv_ullong((X),(Y),910) +#define get_csv_ip_pos910(X,Y) get_csv_ip((X),(Y),910) +#define get_csv_ipv6_pos910(X,Y) get_csv_ipv6((X),(Y),910) +#define get_csv_string_pos910(X,Y) get_csv_string((X),(Y),910) +#define get_csv_v_str_pos910(X,Y) get_csv_string((X),(Y),910) +#define get_csv_bool_pos910(X,Y) get_csv_bool((X),(Y),910) +#define get_csv_int_pos910(X,Y) get_csv_int((X),(Y),910) +#define get_csv_llong_pos910(X,Y) get_csv_llong((X),(Y),910) +#define get_csv_float_pos910(X,Y) get_csv_float((X),(Y),910) +#define get_csv_uint_pos911(X,Y) get_csv_uint((X),(Y),911) +#define get_csv_ullong_pos911(X,Y) get_csv_ullong((X),(Y),911) +#define get_csv_ip_pos911(X,Y) get_csv_ip((X),(Y),911) +#define get_csv_ipv6_pos911(X,Y) get_csv_ipv6((X),(Y),911) +#define get_csv_string_pos911(X,Y) get_csv_string((X),(Y),911) +#define get_csv_v_str_pos911(X,Y) get_csv_string((X),(Y),911) +#define get_csv_bool_pos911(X,Y) get_csv_bool((X),(Y),911) +#define get_csv_int_pos911(X,Y) get_csv_int((X),(Y),911) +#define get_csv_llong_pos911(X,Y) get_csv_llong((X),(Y),911) +#define get_csv_float_pos911(X,Y) get_csv_float((X),(Y),911) +#define get_csv_uint_pos912(X,Y) get_csv_uint((X),(Y),912) +#define get_csv_ullong_pos912(X,Y) get_csv_ullong((X),(Y),912) +#define get_csv_ip_pos912(X,Y) get_csv_ip((X),(Y),912) +#define get_csv_ipv6_pos912(X,Y) get_csv_ipv6((X),(Y),912) +#define get_csv_string_pos912(X,Y) get_csv_string((X),(Y),912) +#define get_csv_v_str_pos912(X,Y) get_csv_string((X),(Y),912) +#define get_csv_bool_pos912(X,Y) get_csv_bool((X),(Y),912) +#define get_csv_int_pos912(X,Y) get_csv_int((X),(Y),912) +#define get_csv_llong_pos912(X,Y) get_csv_llong((X),(Y),912) +#define get_csv_float_pos912(X,Y) get_csv_float((X),(Y),912) +#define get_csv_uint_pos913(X,Y) get_csv_uint((X),(Y),913) +#define get_csv_ullong_pos913(X,Y) get_csv_ullong((X),(Y),913) +#define get_csv_ip_pos913(X,Y) get_csv_ip((X),(Y),913) +#define get_csv_ipv6_pos913(X,Y) get_csv_ipv6((X),(Y),913) +#define get_csv_string_pos913(X,Y) get_csv_string((X),(Y),913) +#define get_csv_v_str_pos913(X,Y) get_csv_string((X),(Y),913) +#define get_csv_bool_pos913(X,Y) get_csv_bool((X),(Y),913) +#define get_csv_int_pos913(X,Y) get_csv_int((X),(Y),913) +#define get_csv_llong_pos913(X,Y) get_csv_llong((X),(Y),913) +#define get_csv_float_pos913(X,Y) get_csv_float((X),(Y),913) +#define get_csv_uint_pos914(X,Y) get_csv_uint((X),(Y),914) +#define get_csv_ullong_pos914(X,Y) get_csv_ullong((X),(Y),914) +#define get_csv_ip_pos914(X,Y) get_csv_ip((X),(Y),914) +#define get_csv_ipv6_pos914(X,Y) get_csv_ipv6((X),(Y),914) +#define get_csv_string_pos914(X,Y) get_csv_string((X),(Y),914) +#define get_csv_v_str_pos914(X,Y) get_csv_string((X),(Y),914) +#define get_csv_bool_pos914(X,Y) get_csv_bool((X),(Y),914) +#define get_csv_int_pos914(X,Y) get_csv_int((X),(Y),914) +#define get_csv_llong_pos914(X,Y) get_csv_llong((X),(Y),914) +#define get_csv_float_pos914(X,Y) get_csv_float((X),(Y),914) +#define get_csv_uint_pos915(X,Y) get_csv_uint((X),(Y),915) +#define get_csv_ullong_pos915(X,Y) get_csv_ullong((X),(Y),915) +#define get_csv_ip_pos915(X,Y) get_csv_ip((X),(Y),915) +#define get_csv_ipv6_pos915(X,Y) get_csv_ipv6((X),(Y),915) +#define get_csv_string_pos915(X,Y) get_csv_string((X),(Y),915) +#define get_csv_v_str_pos915(X,Y) get_csv_string((X),(Y),915) +#define get_csv_bool_pos915(X,Y) get_csv_bool((X),(Y),915) +#define get_csv_int_pos915(X,Y) get_csv_int((X),(Y),915) +#define get_csv_llong_pos915(X,Y) get_csv_llong((X),(Y),915) +#define get_csv_float_pos915(X,Y) get_csv_float((X),(Y),915) +#define get_csv_uint_pos916(X,Y) get_csv_uint((X),(Y),916) +#define get_csv_ullong_pos916(X,Y) get_csv_ullong((X),(Y),916) +#define get_csv_ip_pos916(X,Y) get_csv_ip((X),(Y),916) +#define get_csv_ipv6_pos916(X,Y) get_csv_ipv6((X),(Y),916) +#define get_csv_string_pos916(X,Y) get_csv_string((X),(Y),916) +#define get_csv_v_str_pos916(X,Y) get_csv_string((X),(Y),916) +#define get_csv_bool_pos916(X,Y) get_csv_bool((X),(Y),916) +#define get_csv_int_pos916(X,Y) get_csv_int((X),(Y),916) +#define get_csv_llong_pos916(X,Y) get_csv_llong((X),(Y),916) +#define get_csv_float_pos916(X,Y) get_csv_float((X),(Y),916) +#define get_csv_uint_pos917(X,Y) get_csv_uint((X),(Y),917) +#define get_csv_ullong_pos917(X,Y) get_csv_ullong((X),(Y),917) +#define get_csv_ip_pos917(X,Y) get_csv_ip((X),(Y),917) +#define get_csv_ipv6_pos917(X,Y) get_csv_ipv6((X),(Y),917) +#define get_csv_string_pos917(X,Y) get_csv_string((X),(Y),917) +#define get_csv_v_str_pos917(X,Y) get_csv_string((X),(Y),917) +#define get_csv_bool_pos917(X,Y) get_csv_bool((X),(Y),917) +#define get_csv_int_pos917(X,Y) get_csv_int((X),(Y),917) +#define get_csv_llong_pos917(X,Y) get_csv_llong((X),(Y),917) +#define get_csv_float_pos917(X,Y) get_csv_float((X),(Y),917) +#define get_csv_uint_pos918(X,Y) get_csv_uint((X),(Y),918) +#define get_csv_ullong_pos918(X,Y) get_csv_ullong((X),(Y),918) +#define get_csv_ip_pos918(X,Y) get_csv_ip((X),(Y),918) +#define get_csv_ipv6_pos918(X,Y) get_csv_ipv6((X),(Y),918) +#define get_csv_string_pos918(X,Y) get_csv_string((X),(Y),918) +#define get_csv_v_str_pos918(X,Y) get_csv_string((X),(Y),918) +#define get_csv_bool_pos918(X,Y) get_csv_bool((X),(Y),918) +#define get_csv_int_pos918(X,Y) get_csv_int((X),(Y),918) +#define get_csv_llong_pos918(X,Y) get_csv_llong((X),(Y),918) +#define get_csv_float_pos918(X,Y) get_csv_float((X),(Y),918) +#define get_csv_uint_pos919(X,Y) get_csv_uint((X),(Y),919) +#define get_csv_ullong_pos919(X,Y) get_csv_ullong((X),(Y),919) +#define get_csv_ip_pos919(X,Y) get_csv_ip((X),(Y),919) +#define get_csv_ipv6_pos919(X,Y) get_csv_ipv6((X),(Y),919) +#define get_csv_string_pos919(X,Y) get_csv_string((X),(Y),919) +#define get_csv_v_str_pos919(X,Y) get_csv_string((X),(Y),919) +#define get_csv_bool_pos919(X,Y) get_csv_bool((X),(Y),919) +#define get_csv_int_pos919(X,Y) get_csv_int((X),(Y),919) +#define get_csv_llong_pos919(X,Y) get_csv_llong((X),(Y),919) +#define get_csv_float_pos919(X,Y) get_csv_float((X),(Y),919) +#define get_csv_uint_pos920(X,Y) get_csv_uint((X),(Y),920) +#define get_csv_ullong_pos920(X,Y) get_csv_ullong((X),(Y),920) +#define get_csv_ip_pos920(X,Y) get_csv_ip((X),(Y),920) +#define get_csv_ipv6_pos920(X,Y) get_csv_ipv6((X),(Y),920) +#define get_csv_string_pos920(X,Y) get_csv_string((X),(Y),920) +#define get_csv_v_str_pos920(X,Y) get_csv_string((X),(Y),920) +#define get_csv_bool_pos920(X,Y) get_csv_bool((X),(Y),920) +#define get_csv_int_pos920(X,Y) get_csv_int((X),(Y),920) +#define get_csv_llong_pos920(X,Y) get_csv_llong((X),(Y),920) +#define get_csv_float_pos920(X,Y) get_csv_float((X),(Y),920) +#define get_csv_uint_pos921(X,Y) get_csv_uint((X),(Y),921) +#define get_csv_ullong_pos921(X,Y) get_csv_ullong((X),(Y),921) +#define get_csv_ip_pos921(X,Y) get_csv_ip((X),(Y),921) +#define get_csv_ipv6_pos921(X,Y) get_csv_ipv6((X),(Y),921) +#define get_csv_string_pos921(X,Y) get_csv_string((X),(Y),921) +#define get_csv_v_str_pos921(X,Y) get_csv_string((X),(Y),921) +#define get_csv_bool_pos921(X,Y) get_csv_bool((X),(Y),921) +#define get_csv_int_pos921(X,Y) get_csv_int((X),(Y),921) +#define get_csv_llong_pos921(X,Y) get_csv_llong((X),(Y),921) +#define get_csv_float_pos921(X,Y) get_csv_float((X),(Y),921) +#define get_csv_uint_pos922(X,Y) get_csv_uint((X),(Y),922) +#define get_csv_ullong_pos922(X,Y) get_csv_ullong((X),(Y),922) +#define get_csv_ip_pos922(X,Y) get_csv_ip((X),(Y),922) +#define get_csv_ipv6_pos922(X,Y) get_csv_ipv6((X),(Y),922) +#define get_csv_string_pos922(X,Y) get_csv_string((X),(Y),922) +#define get_csv_v_str_pos922(X,Y) get_csv_string((X),(Y),922) +#define get_csv_bool_pos922(X,Y) get_csv_bool((X),(Y),922) +#define get_csv_int_pos922(X,Y) get_csv_int((X),(Y),922) +#define get_csv_llong_pos922(X,Y) get_csv_llong((X),(Y),922) +#define get_csv_float_pos922(X,Y) get_csv_float((X),(Y),922) +#define get_csv_uint_pos923(X,Y) get_csv_uint((X),(Y),923) +#define get_csv_ullong_pos923(X,Y) get_csv_ullong((X),(Y),923) +#define get_csv_ip_pos923(X,Y) get_csv_ip((X),(Y),923) +#define get_csv_ipv6_pos923(X,Y) get_csv_ipv6((X),(Y),923) +#define get_csv_string_pos923(X,Y) get_csv_string((X),(Y),923) +#define get_csv_v_str_pos923(X,Y) get_csv_string((X),(Y),923) +#define get_csv_bool_pos923(X,Y) get_csv_bool((X),(Y),923) +#define get_csv_int_pos923(X,Y) get_csv_int((X),(Y),923) +#define get_csv_llong_pos923(X,Y) get_csv_llong((X),(Y),923) +#define get_csv_float_pos923(X,Y) get_csv_float((X),(Y),923) +#define get_csv_uint_pos924(X,Y) get_csv_uint((X),(Y),924) +#define get_csv_ullong_pos924(X,Y) get_csv_ullong((X),(Y),924) +#define get_csv_ip_pos924(X,Y) get_csv_ip((X),(Y),924) +#define get_csv_ipv6_pos924(X,Y) get_csv_ipv6((X),(Y),924) +#define get_csv_string_pos924(X,Y) get_csv_string((X),(Y),924) +#define get_csv_v_str_pos924(X,Y) get_csv_string((X),(Y),924) +#define get_csv_bool_pos924(X,Y) get_csv_bool((X),(Y),924) +#define get_csv_int_pos924(X,Y) get_csv_int((X),(Y),924) +#define get_csv_llong_pos924(X,Y) get_csv_llong((X),(Y),924) +#define get_csv_float_pos924(X,Y) get_csv_float((X),(Y),924) +#define get_csv_uint_pos925(X,Y) get_csv_uint((X),(Y),925) +#define get_csv_ullong_pos925(X,Y) get_csv_ullong((X),(Y),925) +#define get_csv_ip_pos925(X,Y) get_csv_ip((X),(Y),925) +#define get_csv_ipv6_pos925(X,Y) get_csv_ipv6((X),(Y),925) +#define get_csv_string_pos925(X,Y) get_csv_string((X),(Y),925) +#define get_csv_v_str_pos925(X,Y) get_csv_string((X),(Y),925) +#define get_csv_bool_pos925(X,Y) get_csv_bool((X),(Y),925) +#define get_csv_int_pos925(X,Y) get_csv_int((X),(Y),925) +#define get_csv_llong_pos925(X,Y) get_csv_llong((X),(Y),925) +#define get_csv_float_pos925(X,Y) get_csv_float((X),(Y),925) +#define get_csv_uint_pos926(X,Y) get_csv_uint((X),(Y),926) +#define get_csv_ullong_pos926(X,Y) get_csv_ullong((X),(Y),926) +#define get_csv_ip_pos926(X,Y) get_csv_ip((X),(Y),926) +#define get_csv_ipv6_pos926(X,Y) get_csv_ipv6((X),(Y),926) +#define get_csv_string_pos926(X,Y) get_csv_string((X),(Y),926) +#define get_csv_v_str_pos926(X,Y) get_csv_string((X),(Y),926) +#define get_csv_bool_pos926(X,Y) get_csv_bool((X),(Y),926) +#define get_csv_int_pos926(X,Y) get_csv_int((X),(Y),926) +#define get_csv_llong_pos926(X,Y) get_csv_llong((X),(Y),926) +#define get_csv_float_pos926(X,Y) get_csv_float((X),(Y),926) +#define get_csv_uint_pos927(X,Y) get_csv_uint((X),(Y),927) +#define get_csv_ullong_pos927(X,Y) get_csv_ullong((X),(Y),927) +#define get_csv_ip_pos927(X,Y) get_csv_ip((X),(Y),927) +#define get_csv_ipv6_pos927(X,Y) get_csv_ipv6((X),(Y),927) +#define get_csv_string_pos927(X,Y) get_csv_string((X),(Y),927) +#define get_csv_v_str_pos927(X,Y) get_csv_string((X),(Y),927) +#define get_csv_bool_pos927(X,Y) get_csv_bool((X),(Y),927) +#define get_csv_int_pos927(X,Y) get_csv_int((X),(Y),927) +#define get_csv_llong_pos927(X,Y) get_csv_llong((X),(Y),927) +#define get_csv_float_pos927(X,Y) get_csv_float((X),(Y),927) +#define get_csv_uint_pos928(X,Y) get_csv_uint((X),(Y),928) +#define get_csv_ullong_pos928(X,Y) get_csv_ullong((X),(Y),928) +#define get_csv_ip_pos928(X,Y) get_csv_ip((X),(Y),928) +#define get_csv_ipv6_pos928(X,Y) get_csv_ipv6((X),(Y),928) +#define get_csv_string_pos928(X,Y) get_csv_string((X),(Y),928) +#define get_csv_v_str_pos928(X,Y) get_csv_string((X),(Y),928) +#define get_csv_bool_pos928(X,Y) get_csv_bool((X),(Y),928) +#define get_csv_int_pos928(X,Y) get_csv_int((X),(Y),928) +#define get_csv_llong_pos928(X,Y) get_csv_llong((X),(Y),928) +#define get_csv_float_pos928(X,Y) get_csv_float((X),(Y),928) +#define get_csv_uint_pos929(X,Y) get_csv_uint((X),(Y),929) +#define get_csv_ullong_pos929(X,Y) get_csv_ullong((X),(Y),929) +#define get_csv_ip_pos929(X,Y) get_csv_ip((X),(Y),929) +#define get_csv_ipv6_pos929(X,Y) get_csv_ipv6((X),(Y),929) +#define get_csv_string_pos929(X,Y) get_csv_string((X),(Y),929) +#define get_csv_v_str_pos929(X,Y) get_csv_string((X),(Y),929) +#define get_csv_bool_pos929(X,Y) get_csv_bool((X),(Y),929) +#define get_csv_int_pos929(X,Y) get_csv_int((X),(Y),929) +#define get_csv_llong_pos929(X,Y) get_csv_llong((X),(Y),929) +#define get_csv_float_pos929(X,Y) get_csv_float((X),(Y),929) +#define get_csv_uint_pos930(X,Y) get_csv_uint((X),(Y),930) +#define get_csv_ullong_pos930(X,Y) get_csv_ullong((X),(Y),930) +#define get_csv_ip_pos930(X,Y) get_csv_ip((X),(Y),930) +#define get_csv_ipv6_pos930(X,Y) get_csv_ipv6((X),(Y),930) +#define get_csv_string_pos930(X,Y) get_csv_string((X),(Y),930) +#define get_csv_v_str_pos930(X,Y) get_csv_string((X),(Y),930) +#define get_csv_bool_pos930(X,Y) get_csv_bool((X),(Y),930) +#define get_csv_int_pos930(X,Y) get_csv_int((X),(Y),930) +#define get_csv_llong_pos930(X,Y) get_csv_llong((X),(Y),930) +#define get_csv_float_pos930(X,Y) get_csv_float((X),(Y),930) +#define get_csv_uint_pos931(X,Y) get_csv_uint((X),(Y),931) +#define get_csv_ullong_pos931(X,Y) get_csv_ullong((X),(Y),931) +#define get_csv_ip_pos931(X,Y) get_csv_ip((X),(Y),931) +#define get_csv_ipv6_pos931(X,Y) get_csv_ipv6((X),(Y),931) +#define get_csv_string_pos931(X,Y) get_csv_string((X),(Y),931) +#define get_csv_v_str_pos931(X,Y) get_csv_string((X),(Y),931) +#define get_csv_bool_pos931(X,Y) get_csv_bool((X),(Y),931) +#define get_csv_int_pos931(X,Y) get_csv_int((X),(Y),931) +#define get_csv_llong_pos931(X,Y) get_csv_llong((X),(Y),931) +#define get_csv_float_pos931(X,Y) get_csv_float((X),(Y),931) +#define get_csv_uint_pos932(X,Y) get_csv_uint((X),(Y),932) +#define get_csv_ullong_pos932(X,Y) get_csv_ullong((X),(Y),932) +#define get_csv_ip_pos932(X,Y) get_csv_ip((X),(Y),932) +#define get_csv_ipv6_pos932(X,Y) get_csv_ipv6((X),(Y),932) +#define get_csv_string_pos932(X,Y) get_csv_string((X),(Y),932) +#define get_csv_v_str_pos932(X,Y) get_csv_string((X),(Y),932) +#define get_csv_bool_pos932(X,Y) get_csv_bool((X),(Y),932) +#define get_csv_int_pos932(X,Y) get_csv_int((X),(Y),932) +#define get_csv_llong_pos932(X,Y) get_csv_llong((X),(Y),932) +#define get_csv_float_pos932(X,Y) get_csv_float((X),(Y),932) +#define get_csv_uint_pos933(X,Y) get_csv_uint((X),(Y),933) +#define get_csv_ullong_pos933(X,Y) get_csv_ullong((X),(Y),933) +#define get_csv_ip_pos933(X,Y) get_csv_ip((X),(Y),933) +#define get_csv_ipv6_pos933(X,Y) get_csv_ipv6((X),(Y),933) +#define get_csv_string_pos933(X,Y) get_csv_string((X),(Y),933) +#define get_csv_v_str_pos933(X,Y) get_csv_string((X),(Y),933) +#define get_csv_bool_pos933(X,Y) get_csv_bool((X),(Y),933) +#define get_csv_int_pos933(X,Y) get_csv_int((X),(Y),933) +#define get_csv_llong_pos933(X,Y) get_csv_llong((X),(Y),933) +#define get_csv_float_pos933(X,Y) get_csv_float((X),(Y),933) +#define get_csv_uint_pos934(X,Y) get_csv_uint((X),(Y),934) +#define get_csv_ullong_pos934(X,Y) get_csv_ullong((X),(Y),934) +#define get_csv_ip_pos934(X,Y) get_csv_ip((X),(Y),934) +#define get_csv_ipv6_pos934(X,Y) get_csv_ipv6((X),(Y),934) +#define get_csv_string_pos934(X,Y) get_csv_string((X),(Y),934) +#define get_csv_v_str_pos934(X,Y) get_csv_string((X),(Y),934) +#define get_csv_bool_pos934(X,Y) get_csv_bool((X),(Y),934) +#define get_csv_int_pos934(X,Y) get_csv_int((X),(Y),934) +#define get_csv_llong_pos934(X,Y) get_csv_llong((X),(Y),934) +#define get_csv_float_pos934(X,Y) get_csv_float((X),(Y),934) +#define get_csv_uint_pos935(X,Y) get_csv_uint((X),(Y),935) +#define get_csv_ullong_pos935(X,Y) get_csv_ullong((X),(Y),935) +#define get_csv_ip_pos935(X,Y) get_csv_ip((X),(Y),935) +#define get_csv_ipv6_pos935(X,Y) get_csv_ipv6((X),(Y),935) +#define get_csv_string_pos935(X,Y) get_csv_string((X),(Y),935) +#define get_csv_v_str_pos935(X,Y) get_csv_string((X),(Y),935) +#define get_csv_bool_pos935(X,Y) get_csv_bool((X),(Y),935) +#define get_csv_int_pos935(X,Y) get_csv_int((X),(Y),935) +#define get_csv_llong_pos935(X,Y) get_csv_llong((X),(Y),935) +#define get_csv_float_pos935(X,Y) get_csv_float((X),(Y),935) +#define get_csv_uint_pos936(X,Y) get_csv_uint((X),(Y),936) +#define get_csv_ullong_pos936(X,Y) get_csv_ullong((X),(Y),936) +#define get_csv_ip_pos936(X,Y) get_csv_ip((X),(Y),936) +#define get_csv_ipv6_pos936(X,Y) get_csv_ipv6((X),(Y),936) +#define get_csv_string_pos936(X,Y) get_csv_string((X),(Y),936) +#define get_csv_v_str_pos936(X,Y) get_csv_string((X),(Y),936) +#define get_csv_bool_pos936(X,Y) get_csv_bool((X),(Y),936) +#define get_csv_int_pos936(X,Y) get_csv_int((X),(Y),936) +#define get_csv_llong_pos936(X,Y) get_csv_llong((X),(Y),936) +#define get_csv_float_pos936(X,Y) get_csv_float((X),(Y),936) +#define get_csv_uint_pos937(X,Y) get_csv_uint((X),(Y),937) +#define get_csv_ullong_pos937(X,Y) get_csv_ullong((X),(Y),937) +#define get_csv_ip_pos937(X,Y) get_csv_ip((X),(Y),937) +#define get_csv_ipv6_pos937(X,Y) get_csv_ipv6((X),(Y),937) +#define get_csv_string_pos937(X,Y) get_csv_string((X),(Y),937) +#define get_csv_v_str_pos937(X,Y) get_csv_string((X),(Y),937) +#define get_csv_bool_pos937(X,Y) get_csv_bool((X),(Y),937) +#define get_csv_int_pos937(X,Y) get_csv_int((X),(Y),937) +#define get_csv_llong_pos937(X,Y) get_csv_llong((X),(Y),937) +#define get_csv_float_pos937(X,Y) get_csv_float((X),(Y),937) +#define get_csv_uint_pos938(X,Y) get_csv_uint((X),(Y),938) +#define get_csv_ullong_pos938(X,Y) get_csv_ullong((X),(Y),938) +#define get_csv_ip_pos938(X,Y) get_csv_ip((X),(Y),938) +#define get_csv_ipv6_pos938(X,Y) get_csv_ipv6((X),(Y),938) +#define get_csv_string_pos938(X,Y) get_csv_string((X),(Y),938) +#define get_csv_v_str_pos938(X,Y) get_csv_string((X),(Y),938) +#define get_csv_bool_pos938(X,Y) get_csv_bool((X),(Y),938) +#define get_csv_int_pos938(X,Y) get_csv_int((X),(Y),938) +#define get_csv_llong_pos938(X,Y) get_csv_llong((X),(Y),938) +#define get_csv_float_pos938(X,Y) get_csv_float((X),(Y),938) +#define get_csv_uint_pos939(X,Y) get_csv_uint((X),(Y),939) +#define get_csv_ullong_pos939(X,Y) get_csv_ullong((X),(Y),939) +#define get_csv_ip_pos939(X,Y) get_csv_ip((X),(Y),939) +#define get_csv_ipv6_pos939(X,Y) get_csv_ipv6((X),(Y),939) +#define get_csv_string_pos939(X,Y) get_csv_string((X),(Y),939) +#define get_csv_v_str_pos939(X,Y) get_csv_string((X),(Y),939) +#define get_csv_bool_pos939(X,Y) get_csv_bool((X),(Y),939) +#define get_csv_int_pos939(X,Y) get_csv_int((X),(Y),939) +#define get_csv_llong_pos939(X,Y) get_csv_llong((X),(Y),939) +#define get_csv_float_pos939(X,Y) get_csv_float((X),(Y),939) +#define get_csv_uint_pos940(X,Y) get_csv_uint((X),(Y),940) +#define get_csv_ullong_pos940(X,Y) get_csv_ullong((X),(Y),940) +#define get_csv_ip_pos940(X,Y) get_csv_ip((X),(Y),940) +#define get_csv_ipv6_pos940(X,Y) get_csv_ipv6((X),(Y),940) +#define get_csv_string_pos940(X,Y) get_csv_string((X),(Y),940) +#define get_csv_v_str_pos940(X,Y) get_csv_string((X),(Y),940) +#define get_csv_bool_pos940(X,Y) get_csv_bool((X),(Y),940) +#define get_csv_int_pos940(X,Y) get_csv_int((X),(Y),940) +#define get_csv_llong_pos940(X,Y) get_csv_llong((X),(Y),940) +#define get_csv_float_pos940(X,Y) get_csv_float((X),(Y),940) +#define get_csv_uint_pos941(X,Y) get_csv_uint((X),(Y),941) +#define get_csv_ullong_pos941(X,Y) get_csv_ullong((X),(Y),941) +#define get_csv_ip_pos941(X,Y) get_csv_ip((X),(Y),941) +#define get_csv_ipv6_pos941(X,Y) get_csv_ipv6((X),(Y),941) +#define get_csv_string_pos941(X,Y) get_csv_string((X),(Y),941) +#define get_csv_v_str_pos941(X,Y) get_csv_string((X),(Y),941) +#define get_csv_bool_pos941(X,Y) get_csv_bool((X),(Y),941) +#define get_csv_int_pos941(X,Y) get_csv_int((X),(Y),941) +#define get_csv_llong_pos941(X,Y) get_csv_llong((X),(Y),941) +#define get_csv_float_pos941(X,Y) get_csv_float((X),(Y),941) +#define get_csv_uint_pos942(X,Y) get_csv_uint((X),(Y),942) +#define get_csv_ullong_pos942(X,Y) get_csv_ullong((X),(Y),942) +#define get_csv_ip_pos942(X,Y) get_csv_ip((X),(Y),942) +#define get_csv_ipv6_pos942(X,Y) get_csv_ipv6((X),(Y),942) +#define get_csv_string_pos942(X,Y) get_csv_string((X),(Y),942) +#define get_csv_v_str_pos942(X,Y) get_csv_string((X),(Y),942) +#define get_csv_bool_pos942(X,Y) get_csv_bool((X),(Y),942) +#define get_csv_int_pos942(X,Y) get_csv_int((X),(Y),942) +#define get_csv_llong_pos942(X,Y) get_csv_llong((X),(Y),942) +#define get_csv_float_pos942(X,Y) get_csv_float((X),(Y),942) +#define get_csv_uint_pos943(X,Y) get_csv_uint((X),(Y),943) +#define get_csv_ullong_pos943(X,Y) get_csv_ullong((X),(Y),943) +#define get_csv_ip_pos943(X,Y) get_csv_ip((X),(Y),943) +#define get_csv_ipv6_pos943(X,Y) get_csv_ipv6((X),(Y),943) +#define get_csv_string_pos943(X,Y) get_csv_string((X),(Y),943) +#define get_csv_v_str_pos943(X,Y) get_csv_string((X),(Y),943) +#define get_csv_bool_pos943(X,Y) get_csv_bool((X),(Y),943) +#define get_csv_int_pos943(X,Y) get_csv_int((X),(Y),943) +#define get_csv_llong_pos943(X,Y) get_csv_llong((X),(Y),943) +#define get_csv_float_pos943(X,Y) get_csv_float((X),(Y),943) +#define get_csv_uint_pos944(X,Y) get_csv_uint((X),(Y),944) +#define get_csv_ullong_pos944(X,Y) get_csv_ullong((X),(Y),944) +#define get_csv_ip_pos944(X,Y) get_csv_ip((X),(Y),944) +#define get_csv_ipv6_pos944(X,Y) get_csv_ipv6((X),(Y),944) +#define get_csv_string_pos944(X,Y) get_csv_string((X),(Y),944) +#define get_csv_v_str_pos944(X,Y) get_csv_string((X),(Y),944) +#define get_csv_bool_pos944(X,Y) get_csv_bool((X),(Y),944) +#define get_csv_int_pos944(X,Y) get_csv_int((X),(Y),944) +#define get_csv_llong_pos944(X,Y) get_csv_llong((X),(Y),944) +#define get_csv_float_pos944(X,Y) get_csv_float((X),(Y),944) +#define get_csv_uint_pos945(X,Y) get_csv_uint((X),(Y),945) +#define get_csv_ullong_pos945(X,Y) get_csv_ullong((X),(Y),945) +#define get_csv_ip_pos945(X,Y) get_csv_ip((X),(Y),945) +#define get_csv_ipv6_pos945(X,Y) get_csv_ipv6((X),(Y),945) +#define get_csv_string_pos945(X,Y) get_csv_string((X),(Y),945) +#define get_csv_v_str_pos945(X,Y) get_csv_string((X),(Y),945) +#define get_csv_bool_pos945(X,Y) get_csv_bool((X),(Y),945) +#define get_csv_int_pos945(X,Y) get_csv_int((X),(Y),945) +#define get_csv_llong_pos945(X,Y) get_csv_llong((X),(Y),945) +#define get_csv_float_pos945(X,Y) get_csv_float((X),(Y),945) +#define get_csv_uint_pos946(X,Y) get_csv_uint((X),(Y),946) +#define get_csv_ullong_pos946(X,Y) get_csv_ullong((X),(Y),946) +#define get_csv_ip_pos946(X,Y) get_csv_ip((X),(Y),946) +#define get_csv_ipv6_pos946(X,Y) get_csv_ipv6((X),(Y),946) +#define get_csv_string_pos946(X,Y) get_csv_string((X),(Y),946) +#define get_csv_v_str_pos946(X,Y) get_csv_string((X),(Y),946) +#define get_csv_bool_pos946(X,Y) get_csv_bool((X),(Y),946) +#define get_csv_int_pos946(X,Y) get_csv_int((X),(Y),946) +#define get_csv_llong_pos946(X,Y) get_csv_llong((X),(Y),946) +#define get_csv_float_pos946(X,Y) get_csv_float((X),(Y),946) +#define get_csv_uint_pos947(X,Y) get_csv_uint((X),(Y),947) +#define get_csv_ullong_pos947(X,Y) get_csv_ullong((X),(Y),947) +#define get_csv_ip_pos947(X,Y) get_csv_ip((X),(Y),947) +#define get_csv_ipv6_pos947(X,Y) get_csv_ipv6((X),(Y),947) +#define get_csv_string_pos947(X,Y) get_csv_string((X),(Y),947) +#define get_csv_v_str_pos947(X,Y) get_csv_string((X),(Y),947) +#define get_csv_bool_pos947(X,Y) get_csv_bool((X),(Y),947) +#define get_csv_int_pos947(X,Y) get_csv_int((X),(Y),947) +#define get_csv_llong_pos947(X,Y) get_csv_llong((X),(Y),947) +#define get_csv_float_pos947(X,Y) get_csv_float((X),(Y),947) +#define get_csv_uint_pos948(X,Y) get_csv_uint((X),(Y),948) +#define get_csv_ullong_pos948(X,Y) get_csv_ullong((X),(Y),948) +#define get_csv_ip_pos948(X,Y) get_csv_ip((X),(Y),948) +#define get_csv_ipv6_pos948(X,Y) get_csv_ipv6((X),(Y),948) +#define get_csv_string_pos948(X,Y) get_csv_string((X),(Y),948) +#define get_csv_v_str_pos948(X,Y) get_csv_string((X),(Y),948) +#define get_csv_bool_pos948(X,Y) get_csv_bool((X),(Y),948) +#define get_csv_int_pos948(X,Y) get_csv_int((X),(Y),948) +#define get_csv_llong_pos948(X,Y) get_csv_llong((X),(Y),948) +#define get_csv_float_pos948(X,Y) get_csv_float((X),(Y),948) +#define get_csv_uint_pos949(X,Y) get_csv_uint((X),(Y),949) +#define get_csv_ullong_pos949(X,Y) get_csv_ullong((X),(Y),949) +#define get_csv_ip_pos949(X,Y) get_csv_ip((X),(Y),949) +#define get_csv_ipv6_pos949(X,Y) get_csv_ipv6((X),(Y),949) +#define get_csv_string_pos949(X,Y) get_csv_string((X),(Y),949) +#define get_csv_v_str_pos949(X,Y) get_csv_string((X),(Y),949) +#define get_csv_bool_pos949(X,Y) get_csv_bool((X),(Y),949) +#define get_csv_int_pos949(X,Y) get_csv_int((X),(Y),949) +#define get_csv_llong_pos949(X,Y) get_csv_llong((X),(Y),949) +#define get_csv_float_pos949(X,Y) get_csv_float((X),(Y),949) +#define get_csv_uint_pos950(X,Y) get_csv_uint((X),(Y),950) +#define get_csv_ullong_pos950(X,Y) get_csv_ullong((X),(Y),950) +#define get_csv_ip_pos950(X,Y) get_csv_ip((X),(Y),950) +#define get_csv_ipv6_pos950(X,Y) get_csv_ipv6((X),(Y),950) +#define get_csv_string_pos950(X,Y) get_csv_string((X),(Y),950) +#define get_csv_v_str_pos950(X,Y) get_csv_string((X),(Y),950) +#define get_csv_bool_pos950(X,Y) get_csv_bool((X),(Y),950) +#define get_csv_int_pos950(X,Y) get_csv_int((X),(Y),950) +#define get_csv_llong_pos950(X,Y) get_csv_llong((X),(Y),950) +#define get_csv_float_pos950(X,Y) get_csv_float((X),(Y),950) +#define get_csv_uint_pos951(X,Y) get_csv_uint((X),(Y),951) +#define get_csv_ullong_pos951(X,Y) get_csv_ullong((X),(Y),951) +#define get_csv_ip_pos951(X,Y) get_csv_ip((X),(Y),951) +#define get_csv_ipv6_pos951(X,Y) get_csv_ipv6((X),(Y),951) +#define get_csv_string_pos951(X,Y) get_csv_string((X),(Y),951) +#define get_csv_v_str_pos951(X,Y) get_csv_string((X),(Y),951) +#define get_csv_bool_pos951(X,Y) get_csv_bool((X),(Y),951) +#define get_csv_int_pos951(X,Y) get_csv_int((X),(Y),951) +#define get_csv_llong_pos951(X,Y) get_csv_llong((X),(Y),951) +#define get_csv_float_pos951(X,Y) get_csv_float((X),(Y),951) +#define get_csv_uint_pos952(X,Y) get_csv_uint((X),(Y),952) +#define get_csv_ullong_pos952(X,Y) get_csv_ullong((X),(Y),952) +#define get_csv_ip_pos952(X,Y) get_csv_ip((X),(Y),952) +#define get_csv_ipv6_pos952(X,Y) get_csv_ipv6((X),(Y),952) +#define get_csv_string_pos952(X,Y) get_csv_string((X),(Y),952) +#define get_csv_v_str_pos952(X,Y) get_csv_string((X),(Y),952) +#define get_csv_bool_pos952(X,Y) get_csv_bool((X),(Y),952) +#define get_csv_int_pos952(X,Y) get_csv_int((X),(Y),952) +#define get_csv_llong_pos952(X,Y) get_csv_llong((X),(Y),952) +#define get_csv_float_pos952(X,Y) get_csv_float((X),(Y),952) +#define get_csv_uint_pos953(X,Y) get_csv_uint((X),(Y),953) +#define get_csv_ullong_pos953(X,Y) get_csv_ullong((X),(Y),953) +#define get_csv_ip_pos953(X,Y) get_csv_ip((X),(Y),953) +#define get_csv_ipv6_pos953(X,Y) get_csv_ipv6((X),(Y),953) +#define get_csv_string_pos953(X,Y) get_csv_string((X),(Y),953) +#define get_csv_v_str_pos953(X,Y) get_csv_string((X),(Y),953) +#define get_csv_bool_pos953(X,Y) get_csv_bool((X),(Y),953) +#define get_csv_int_pos953(X,Y) get_csv_int((X),(Y),953) +#define get_csv_llong_pos953(X,Y) get_csv_llong((X),(Y),953) +#define get_csv_float_pos953(X,Y) get_csv_float((X),(Y),953) +#define get_csv_uint_pos954(X,Y) get_csv_uint((X),(Y),954) +#define get_csv_ullong_pos954(X,Y) get_csv_ullong((X),(Y),954) +#define get_csv_ip_pos954(X,Y) get_csv_ip((X),(Y),954) +#define get_csv_ipv6_pos954(X,Y) get_csv_ipv6((X),(Y),954) +#define get_csv_string_pos954(X,Y) get_csv_string((X),(Y),954) +#define get_csv_v_str_pos954(X,Y) get_csv_string((X),(Y),954) +#define get_csv_bool_pos954(X,Y) get_csv_bool((X),(Y),954) +#define get_csv_int_pos954(X,Y) get_csv_int((X),(Y),954) +#define get_csv_llong_pos954(X,Y) get_csv_llong((X),(Y),954) +#define get_csv_float_pos954(X,Y) get_csv_float((X),(Y),954) +#define get_csv_uint_pos955(X,Y) get_csv_uint((X),(Y),955) +#define get_csv_ullong_pos955(X,Y) get_csv_ullong((X),(Y),955) +#define get_csv_ip_pos955(X,Y) get_csv_ip((X),(Y),955) +#define get_csv_ipv6_pos955(X,Y) get_csv_ipv6((X),(Y),955) +#define get_csv_string_pos955(X,Y) get_csv_string((X),(Y),955) +#define get_csv_v_str_pos955(X,Y) get_csv_string((X),(Y),955) +#define get_csv_bool_pos955(X,Y) get_csv_bool((X),(Y),955) +#define get_csv_int_pos955(X,Y) get_csv_int((X),(Y),955) +#define get_csv_llong_pos955(X,Y) get_csv_llong((X),(Y),955) +#define get_csv_float_pos955(X,Y) get_csv_float((X),(Y),955) +#define get_csv_uint_pos956(X,Y) get_csv_uint((X),(Y),956) +#define get_csv_ullong_pos956(X,Y) get_csv_ullong((X),(Y),956) +#define get_csv_ip_pos956(X,Y) get_csv_ip((X),(Y),956) +#define get_csv_ipv6_pos956(X,Y) get_csv_ipv6((X),(Y),956) +#define get_csv_string_pos956(X,Y) get_csv_string((X),(Y),956) +#define get_csv_v_str_pos956(X,Y) get_csv_string((X),(Y),956) +#define get_csv_bool_pos956(X,Y) get_csv_bool((X),(Y),956) +#define get_csv_int_pos956(X,Y) get_csv_int((X),(Y),956) +#define get_csv_llong_pos956(X,Y) get_csv_llong((X),(Y),956) +#define get_csv_float_pos956(X,Y) get_csv_float((X),(Y),956) +#define get_csv_uint_pos957(X,Y) get_csv_uint((X),(Y),957) +#define get_csv_ullong_pos957(X,Y) get_csv_ullong((X),(Y),957) +#define get_csv_ip_pos957(X,Y) get_csv_ip((X),(Y),957) +#define get_csv_ipv6_pos957(X,Y) get_csv_ipv6((X),(Y),957) +#define get_csv_string_pos957(X,Y) get_csv_string((X),(Y),957) +#define get_csv_v_str_pos957(X,Y) get_csv_string((X),(Y),957) +#define get_csv_bool_pos957(X,Y) get_csv_bool((X),(Y),957) +#define get_csv_int_pos957(X,Y) get_csv_int((X),(Y),957) +#define get_csv_llong_pos957(X,Y) get_csv_llong((X),(Y),957) +#define get_csv_float_pos957(X,Y) get_csv_float((X),(Y),957) +#define get_csv_uint_pos958(X,Y) get_csv_uint((X),(Y),958) +#define get_csv_ullong_pos958(X,Y) get_csv_ullong((X),(Y),958) +#define get_csv_ip_pos958(X,Y) get_csv_ip((X),(Y),958) +#define get_csv_ipv6_pos958(X,Y) get_csv_ipv6((X),(Y),958) +#define get_csv_string_pos958(X,Y) get_csv_string((X),(Y),958) +#define get_csv_v_str_pos958(X,Y) get_csv_string((X),(Y),958) +#define get_csv_bool_pos958(X,Y) get_csv_bool((X),(Y),958) +#define get_csv_int_pos958(X,Y) get_csv_int((X),(Y),958) +#define get_csv_llong_pos958(X,Y) get_csv_llong((X),(Y),958) +#define get_csv_float_pos958(X,Y) get_csv_float((X),(Y),958) +#define get_csv_uint_pos959(X,Y) get_csv_uint((X),(Y),959) +#define get_csv_ullong_pos959(X,Y) get_csv_ullong((X),(Y),959) +#define get_csv_ip_pos959(X,Y) get_csv_ip((X),(Y),959) +#define get_csv_ipv6_pos959(X,Y) get_csv_ipv6((X),(Y),959) +#define get_csv_string_pos959(X,Y) get_csv_string((X),(Y),959) +#define get_csv_v_str_pos959(X,Y) get_csv_string((X),(Y),959) +#define get_csv_bool_pos959(X,Y) get_csv_bool((X),(Y),959) +#define get_csv_int_pos959(X,Y) get_csv_int((X),(Y),959) +#define get_csv_llong_pos959(X,Y) get_csv_llong((X),(Y),959) +#define get_csv_float_pos959(X,Y) get_csv_float((X),(Y),959) +#define get_csv_uint_pos960(X,Y) get_csv_uint((X),(Y),960) +#define get_csv_ullong_pos960(X,Y) get_csv_ullong((X),(Y),960) +#define get_csv_ip_pos960(X,Y) get_csv_ip((X),(Y),960) +#define get_csv_ipv6_pos960(X,Y) get_csv_ipv6((X),(Y),960) +#define get_csv_string_pos960(X,Y) get_csv_string((X),(Y),960) +#define get_csv_v_str_pos960(X,Y) get_csv_string((X),(Y),960) +#define get_csv_bool_pos960(X,Y) get_csv_bool((X),(Y),960) +#define get_csv_int_pos960(X,Y) get_csv_int((X),(Y),960) +#define get_csv_llong_pos960(X,Y) get_csv_llong((X),(Y),960) +#define get_csv_float_pos960(X,Y) get_csv_float((X),(Y),960) +#define get_csv_uint_pos961(X,Y) get_csv_uint((X),(Y),961) +#define get_csv_ullong_pos961(X,Y) get_csv_ullong((X),(Y),961) +#define get_csv_ip_pos961(X,Y) get_csv_ip((X),(Y),961) +#define get_csv_ipv6_pos961(X,Y) get_csv_ipv6((X),(Y),961) +#define get_csv_string_pos961(X,Y) get_csv_string((X),(Y),961) +#define get_csv_v_str_pos961(X,Y) get_csv_string((X),(Y),961) +#define get_csv_bool_pos961(X,Y) get_csv_bool((X),(Y),961) +#define get_csv_int_pos961(X,Y) get_csv_int((X),(Y),961) +#define get_csv_llong_pos961(X,Y) get_csv_llong((X),(Y),961) +#define get_csv_float_pos961(X,Y) get_csv_float((X),(Y),961) +#define get_csv_uint_pos962(X,Y) get_csv_uint((X),(Y),962) +#define get_csv_ullong_pos962(X,Y) get_csv_ullong((X),(Y),962) +#define get_csv_ip_pos962(X,Y) get_csv_ip((X),(Y),962) +#define get_csv_ipv6_pos962(X,Y) get_csv_ipv6((X),(Y),962) +#define get_csv_string_pos962(X,Y) get_csv_string((X),(Y),962) +#define get_csv_v_str_pos962(X,Y) get_csv_string((X),(Y),962) +#define get_csv_bool_pos962(X,Y) get_csv_bool((X),(Y),962) +#define get_csv_int_pos962(X,Y) get_csv_int((X),(Y),962) +#define get_csv_llong_pos962(X,Y) get_csv_llong((X),(Y),962) +#define get_csv_float_pos962(X,Y) get_csv_float((X),(Y),962) +#define get_csv_uint_pos963(X,Y) get_csv_uint((X),(Y),963) +#define get_csv_ullong_pos963(X,Y) get_csv_ullong((X),(Y),963) +#define get_csv_ip_pos963(X,Y) get_csv_ip((X),(Y),963) +#define get_csv_ipv6_pos963(X,Y) get_csv_ipv6((X),(Y),963) +#define get_csv_string_pos963(X,Y) get_csv_string((X),(Y),963) +#define get_csv_v_str_pos963(X,Y) get_csv_string((X),(Y),963) +#define get_csv_bool_pos963(X,Y) get_csv_bool((X),(Y),963) +#define get_csv_int_pos963(X,Y) get_csv_int((X),(Y),963) +#define get_csv_llong_pos963(X,Y) get_csv_llong((X),(Y),963) +#define get_csv_float_pos963(X,Y) get_csv_float((X),(Y),963) +#define get_csv_uint_pos964(X,Y) get_csv_uint((X),(Y),964) +#define get_csv_ullong_pos964(X,Y) get_csv_ullong((X),(Y),964) +#define get_csv_ip_pos964(X,Y) get_csv_ip((X),(Y),964) +#define get_csv_ipv6_pos964(X,Y) get_csv_ipv6((X),(Y),964) +#define get_csv_string_pos964(X,Y) get_csv_string((X),(Y),964) +#define get_csv_v_str_pos964(X,Y) get_csv_string((X),(Y),964) +#define get_csv_bool_pos964(X,Y) get_csv_bool((X),(Y),964) +#define get_csv_int_pos964(X,Y) get_csv_int((X),(Y),964) +#define get_csv_llong_pos964(X,Y) get_csv_llong((X),(Y),964) +#define get_csv_float_pos964(X,Y) get_csv_float((X),(Y),964) +#define get_csv_uint_pos965(X,Y) get_csv_uint((X),(Y),965) +#define get_csv_ullong_pos965(X,Y) get_csv_ullong((X),(Y),965) +#define get_csv_ip_pos965(X,Y) get_csv_ip((X),(Y),965) +#define get_csv_ipv6_pos965(X,Y) get_csv_ipv6((X),(Y),965) +#define get_csv_string_pos965(X,Y) get_csv_string((X),(Y),965) +#define get_csv_v_str_pos965(X,Y) get_csv_string((X),(Y),965) +#define get_csv_bool_pos965(X,Y) get_csv_bool((X),(Y),965) +#define get_csv_int_pos965(X,Y) get_csv_int((X),(Y),965) +#define get_csv_llong_pos965(X,Y) get_csv_llong((X),(Y),965) +#define get_csv_float_pos965(X,Y) get_csv_float((X),(Y),965) +#define get_csv_uint_pos966(X,Y) get_csv_uint((X),(Y),966) +#define get_csv_ullong_pos966(X,Y) get_csv_ullong((X),(Y),966) +#define get_csv_ip_pos966(X,Y) get_csv_ip((X),(Y),966) +#define get_csv_ipv6_pos966(X,Y) get_csv_ipv6((X),(Y),966) +#define get_csv_string_pos966(X,Y) get_csv_string((X),(Y),966) +#define get_csv_v_str_pos966(X,Y) get_csv_string((X),(Y),966) +#define get_csv_bool_pos966(X,Y) get_csv_bool((X),(Y),966) +#define get_csv_int_pos966(X,Y) get_csv_int((X),(Y),966) +#define get_csv_llong_pos966(X,Y) get_csv_llong((X),(Y),966) +#define get_csv_float_pos966(X,Y) get_csv_float((X),(Y),966) +#define get_csv_uint_pos967(X,Y) get_csv_uint((X),(Y),967) +#define get_csv_ullong_pos967(X,Y) get_csv_ullong((X),(Y),967) +#define get_csv_ip_pos967(X,Y) get_csv_ip((X),(Y),967) +#define get_csv_ipv6_pos967(X,Y) get_csv_ipv6((X),(Y),967) +#define get_csv_string_pos967(X,Y) get_csv_string((X),(Y),967) +#define get_csv_v_str_pos967(X,Y) get_csv_string((X),(Y),967) +#define get_csv_bool_pos967(X,Y) get_csv_bool((X),(Y),967) +#define get_csv_int_pos967(X,Y) get_csv_int((X),(Y),967) +#define get_csv_llong_pos967(X,Y) get_csv_llong((X),(Y),967) +#define get_csv_float_pos967(X,Y) get_csv_float((X),(Y),967) +#define get_csv_uint_pos968(X,Y) get_csv_uint((X),(Y),968) +#define get_csv_ullong_pos968(X,Y) get_csv_ullong((X),(Y),968) +#define get_csv_ip_pos968(X,Y) get_csv_ip((X),(Y),968) +#define get_csv_ipv6_pos968(X,Y) get_csv_ipv6((X),(Y),968) +#define get_csv_string_pos968(X,Y) get_csv_string((X),(Y),968) +#define get_csv_v_str_pos968(X,Y) get_csv_string((X),(Y),968) +#define get_csv_bool_pos968(X,Y) get_csv_bool((X),(Y),968) +#define get_csv_int_pos968(X,Y) get_csv_int((X),(Y),968) +#define get_csv_llong_pos968(X,Y) get_csv_llong((X),(Y),968) +#define get_csv_float_pos968(X,Y) get_csv_float((X),(Y),968) +#define get_csv_uint_pos969(X,Y) get_csv_uint((X),(Y),969) +#define get_csv_ullong_pos969(X,Y) get_csv_ullong((X),(Y),969) +#define get_csv_ip_pos969(X,Y) get_csv_ip((X),(Y),969) +#define get_csv_ipv6_pos969(X,Y) get_csv_ipv6((X),(Y),969) +#define get_csv_string_pos969(X,Y) get_csv_string((X),(Y),969) +#define get_csv_v_str_pos969(X,Y) get_csv_string((X),(Y),969) +#define get_csv_bool_pos969(X,Y) get_csv_bool((X),(Y),969) +#define get_csv_int_pos969(X,Y) get_csv_int((X),(Y),969) +#define get_csv_llong_pos969(X,Y) get_csv_llong((X),(Y),969) +#define get_csv_float_pos969(X,Y) get_csv_float((X),(Y),969) +#define get_csv_uint_pos970(X,Y) get_csv_uint((X),(Y),970) +#define get_csv_ullong_pos970(X,Y) get_csv_ullong((X),(Y),970) +#define get_csv_ip_pos970(X,Y) get_csv_ip((X),(Y),970) +#define get_csv_ipv6_pos970(X,Y) get_csv_ipv6((X),(Y),970) +#define get_csv_string_pos970(X,Y) get_csv_string((X),(Y),970) +#define get_csv_v_str_pos970(X,Y) get_csv_string((X),(Y),970) +#define get_csv_bool_pos970(X,Y) get_csv_bool((X),(Y),970) +#define get_csv_int_pos970(X,Y) get_csv_int((X),(Y),970) +#define get_csv_llong_pos970(X,Y) get_csv_llong((X),(Y),970) +#define get_csv_float_pos970(X,Y) get_csv_float((X),(Y),970) +#define get_csv_uint_pos971(X,Y) get_csv_uint((X),(Y),971) +#define get_csv_ullong_pos971(X,Y) get_csv_ullong((X),(Y),971) +#define get_csv_ip_pos971(X,Y) get_csv_ip((X),(Y),971) +#define get_csv_ipv6_pos971(X,Y) get_csv_ipv6((X),(Y),971) +#define get_csv_string_pos971(X,Y) get_csv_string((X),(Y),971) +#define get_csv_v_str_pos971(X,Y) get_csv_string((X),(Y),971) +#define get_csv_bool_pos971(X,Y) get_csv_bool((X),(Y),971) +#define get_csv_int_pos971(X,Y) get_csv_int((X),(Y),971) +#define get_csv_llong_pos971(X,Y) get_csv_llong((X),(Y),971) +#define get_csv_float_pos971(X,Y) get_csv_float((X),(Y),971) +#define get_csv_uint_pos972(X,Y) get_csv_uint((X),(Y),972) +#define get_csv_ullong_pos972(X,Y) get_csv_ullong((X),(Y),972) +#define get_csv_ip_pos972(X,Y) get_csv_ip((X),(Y),972) +#define get_csv_ipv6_pos972(X,Y) get_csv_ipv6((X),(Y),972) +#define get_csv_string_pos972(X,Y) get_csv_string((X),(Y),972) +#define get_csv_v_str_pos972(X,Y) get_csv_string((X),(Y),972) +#define get_csv_bool_pos972(X,Y) get_csv_bool((X),(Y),972) +#define get_csv_int_pos972(X,Y) get_csv_int((X),(Y),972) +#define get_csv_llong_pos972(X,Y) get_csv_llong((X),(Y),972) +#define get_csv_float_pos972(X,Y) get_csv_float((X),(Y),972) +#define get_csv_uint_pos973(X,Y) get_csv_uint((X),(Y),973) +#define get_csv_ullong_pos973(X,Y) get_csv_ullong((X),(Y),973) +#define get_csv_ip_pos973(X,Y) get_csv_ip((X),(Y),973) +#define get_csv_ipv6_pos973(X,Y) get_csv_ipv6((X),(Y),973) +#define get_csv_string_pos973(X,Y) get_csv_string((X),(Y),973) +#define get_csv_v_str_pos973(X,Y) get_csv_string((X),(Y),973) +#define get_csv_bool_pos973(X,Y) get_csv_bool((X),(Y),973) +#define get_csv_int_pos973(X,Y) get_csv_int((X),(Y),973) +#define get_csv_llong_pos973(X,Y) get_csv_llong((X),(Y),973) +#define get_csv_float_pos973(X,Y) get_csv_float((X),(Y),973) +#define get_csv_uint_pos974(X,Y) get_csv_uint((X),(Y),974) +#define get_csv_ullong_pos974(X,Y) get_csv_ullong((X),(Y),974) +#define get_csv_ip_pos974(X,Y) get_csv_ip((X),(Y),974) +#define get_csv_ipv6_pos974(X,Y) get_csv_ipv6((X),(Y),974) +#define get_csv_string_pos974(X,Y) get_csv_string((X),(Y),974) +#define get_csv_v_str_pos974(X,Y) get_csv_string((X),(Y),974) +#define get_csv_bool_pos974(X,Y) get_csv_bool((X),(Y),974) +#define get_csv_int_pos974(X,Y) get_csv_int((X),(Y),974) +#define get_csv_llong_pos974(X,Y) get_csv_llong((X),(Y),974) +#define get_csv_float_pos974(X,Y) get_csv_float((X),(Y),974) +#define get_csv_uint_pos975(X,Y) get_csv_uint((X),(Y),975) +#define get_csv_ullong_pos975(X,Y) get_csv_ullong((X),(Y),975) +#define get_csv_ip_pos975(X,Y) get_csv_ip((X),(Y),975) +#define get_csv_ipv6_pos975(X,Y) get_csv_ipv6((X),(Y),975) +#define get_csv_string_pos975(X,Y) get_csv_string((X),(Y),975) +#define get_csv_v_str_pos975(X,Y) get_csv_string((X),(Y),975) +#define get_csv_bool_pos975(X,Y) get_csv_bool((X),(Y),975) +#define get_csv_int_pos975(X,Y) get_csv_int((X),(Y),975) +#define get_csv_llong_pos975(X,Y) get_csv_llong((X),(Y),975) +#define get_csv_float_pos975(X,Y) get_csv_float((X),(Y),975) +#define get_csv_uint_pos976(X,Y) get_csv_uint((X),(Y),976) +#define get_csv_ullong_pos976(X,Y) get_csv_ullong((X),(Y),976) +#define get_csv_ip_pos976(X,Y) get_csv_ip((X),(Y),976) +#define get_csv_ipv6_pos976(X,Y) get_csv_ipv6((X),(Y),976) +#define get_csv_string_pos976(X,Y) get_csv_string((X),(Y),976) +#define get_csv_v_str_pos976(X,Y) get_csv_string((X),(Y),976) +#define get_csv_bool_pos976(X,Y) get_csv_bool((X),(Y),976) +#define get_csv_int_pos976(X,Y) get_csv_int((X),(Y),976) +#define get_csv_llong_pos976(X,Y) get_csv_llong((X),(Y),976) +#define get_csv_float_pos976(X,Y) get_csv_float((X),(Y),976) +#define get_csv_uint_pos977(X,Y) get_csv_uint((X),(Y),977) +#define get_csv_ullong_pos977(X,Y) get_csv_ullong((X),(Y),977) +#define get_csv_ip_pos977(X,Y) get_csv_ip((X),(Y),977) +#define get_csv_ipv6_pos977(X,Y) get_csv_ipv6((X),(Y),977) +#define get_csv_string_pos977(X,Y) get_csv_string((X),(Y),977) +#define get_csv_v_str_pos977(X,Y) get_csv_string((X),(Y),977) +#define get_csv_bool_pos977(X,Y) get_csv_bool((X),(Y),977) +#define get_csv_int_pos977(X,Y) get_csv_int((X),(Y),977) +#define get_csv_llong_pos977(X,Y) get_csv_llong((X),(Y),977) +#define get_csv_float_pos977(X,Y) get_csv_float((X),(Y),977) +#define get_csv_uint_pos978(X,Y) get_csv_uint((X),(Y),978) +#define get_csv_ullong_pos978(X,Y) get_csv_ullong((X),(Y),978) +#define get_csv_ip_pos978(X,Y) get_csv_ip((X),(Y),978) +#define get_csv_ipv6_pos978(X,Y) get_csv_ipv6((X),(Y),978) +#define get_csv_string_pos978(X,Y) get_csv_string((X),(Y),978) +#define get_csv_v_str_pos978(X,Y) get_csv_string((X),(Y),978) +#define get_csv_bool_pos978(X,Y) get_csv_bool((X),(Y),978) +#define get_csv_int_pos978(X,Y) get_csv_int((X),(Y),978) +#define get_csv_llong_pos978(X,Y) get_csv_llong((X),(Y),978) +#define get_csv_float_pos978(X,Y) get_csv_float((X),(Y),978) +#define get_csv_uint_pos979(X,Y) get_csv_uint((X),(Y),979) +#define get_csv_ullong_pos979(X,Y) get_csv_ullong((X),(Y),979) +#define get_csv_ip_pos979(X,Y) get_csv_ip((X),(Y),979) +#define get_csv_ipv6_pos979(X,Y) get_csv_ipv6((X),(Y),979) +#define get_csv_string_pos979(X,Y) get_csv_string((X),(Y),979) +#define get_csv_v_str_pos979(X,Y) get_csv_string((X),(Y),979) +#define get_csv_bool_pos979(X,Y) get_csv_bool((X),(Y),979) +#define get_csv_int_pos979(X,Y) get_csv_int((X),(Y),979) +#define get_csv_llong_pos979(X,Y) get_csv_llong((X),(Y),979) +#define get_csv_float_pos979(X,Y) get_csv_float((X),(Y),979) +#define get_csv_uint_pos980(X,Y) get_csv_uint((X),(Y),980) +#define get_csv_ullong_pos980(X,Y) get_csv_ullong((X),(Y),980) +#define get_csv_ip_pos980(X,Y) get_csv_ip((X),(Y),980) +#define get_csv_ipv6_pos980(X,Y) get_csv_ipv6((X),(Y),980) +#define get_csv_string_pos980(X,Y) get_csv_string((X),(Y),980) +#define get_csv_v_str_pos980(X,Y) get_csv_string((X),(Y),980) +#define get_csv_bool_pos980(X,Y) get_csv_bool((X),(Y),980) +#define get_csv_int_pos980(X,Y) get_csv_int((X),(Y),980) +#define get_csv_llong_pos980(X,Y) get_csv_llong((X),(Y),980) +#define get_csv_float_pos980(X,Y) get_csv_float((X),(Y),980) +#define get_csv_uint_pos981(X,Y) get_csv_uint((X),(Y),981) +#define get_csv_ullong_pos981(X,Y) get_csv_ullong((X),(Y),981) +#define get_csv_ip_pos981(X,Y) get_csv_ip((X),(Y),981) +#define get_csv_ipv6_pos981(X,Y) get_csv_ipv6((X),(Y),981) +#define get_csv_string_pos981(X,Y) get_csv_string((X),(Y),981) +#define get_csv_v_str_pos981(X,Y) get_csv_string((X),(Y),981) +#define get_csv_bool_pos981(X,Y) get_csv_bool((X),(Y),981) +#define get_csv_int_pos981(X,Y) get_csv_int((X),(Y),981) +#define get_csv_llong_pos981(X,Y) get_csv_llong((X),(Y),981) +#define get_csv_float_pos981(X,Y) get_csv_float((X),(Y),981) +#define get_csv_uint_pos982(X,Y) get_csv_uint((X),(Y),982) +#define get_csv_ullong_pos982(X,Y) get_csv_ullong((X),(Y),982) +#define get_csv_ip_pos982(X,Y) get_csv_ip((X),(Y),982) +#define get_csv_ipv6_pos982(X,Y) get_csv_ipv6((X),(Y),982) +#define get_csv_string_pos982(X,Y) get_csv_string((X),(Y),982) +#define get_csv_v_str_pos982(X,Y) get_csv_string((X),(Y),982) +#define get_csv_bool_pos982(X,Y) get_csv_bool((X),(Y),982) +#define get_csv_int_pos982(X,Y) get_csv_int((X),(Y),982) +#define get_csv_llong_pos982(X,Y) get_csv_llong((X),(Y),982) +#define get_csv_float_pos982(X,Y) get_csv_float((X),(Y),982) +#define get_csv_uint_pos983(X,Y) get_csv_uint((X),(Y),983) +#define get_csv_ullong_pos983(X,Y) get_csv_ullong((X),(Y),983) +#define get_csv_ip_pos983(X,Y) get_csv_ip((X),(Y),983) +#define get_csv_ipv6_pos983(X,Y) get_csv_ipv6((X),(Y),983) +#define get_csv_string_pos983(X,Y) get_csv_string((X),(Y),983) +#define get_csv_v_str_pos983(X,Y) get_csv_string((X),(Y),983) +#define get_csv_bool_pos983(X,Y) get_csv_bool((X),(Y),983) +#define get_csv_int_pos983(X,Y) get_csv_int((X),(Y),983) +#define get_csv_llong_pos983(X,Y) get_csv_llong((X),(Y),983) +#define get_csv_float_pos983(X,Y) get_csv_float((X),(Y),983) +#define get_csv_uint_pos984(X,Y) get_csv_uint((X),(Y),984) +#define get_csv_ullong_pos984(X,Y) get_csv_ullong((X),(Y),984) +#define get_csv_ip_pos984(X,Y) get_csv_ip((X),(Y),984) +#define get_csv_ipv6_pos984(X,Y) get_csv_ipv6((X),(Y),984) +#define get_csv_string_pos984(X,Y) get_csv_string((X),(Y),984) +#define get_csv_v_str_pos984(X,Y) get_csv_string((X),(Y),984) +#define get_csv_bool_pos984(X,Y) get_csv_bool((X),(Y),984) +#define get_csv_int_pos984(X,Y) get_csv_int((X),(Y),984) +#define get_csv_llong_pos984(X,Y) get_csv_llong((X),(Y),984) +#define get_csv_float_pos984(X,Y) get_csv_float((X),(Y),984) +#define get_csv_uint_pos985(X,Y) get_csv_uint((X),(Y),985) +#define get_csv_ullong_pos985(X,Y) get_csv_ullong((X),(Y),985) +#define get_csv_ip_pos985(X,Y) get_csv_ip((X),(Y),985) +#define get_csv_ipv6_pos985(X,Y) get_csv_ipv6((X),(Y),985) +#define get_csv_string_pos985(X,Y) get_csv_string((X),(Y),985) +#define get_csv_v_str_pos985(X,Y) get_csv_string((X),(Y),985) +#define get_csv_bool_pos985(X,Y) get_csv_bool((X),(Y),985) +#define get_csv_int_pos985(X,Y) get_csv_int((X),(Y),985) +#define get_csv_llong_pos985(X,Y) get_csv_llong((X),(Y),985) +#define get_csv_float_pos985(X,Y) get_csv_float((X),(Y),985) +#define get_csv_uint_pos986(X,Y) get_csv_uint((X),(Y),986) +#define get_csv_ullong_pos986(X,Y) get_csv_ullong((X),(Y),986) +#define get_csv_ip_pos986(X,Y) get_csv_ip((X),(Y),986) +#define get_csv_ipv6_pos986(X,Y) get_csv_ipv6((X),(Y),986) +#define get_csv_string_pos986(X,Y) get_csv_string((X),(Y),986) +#define get_csv_v_str_pos986(X,Y) get_csv_string((X),(Y),986) +#define get_csv_bool_pos986(X,Y) get_csv_bool((X),(Y),986) +#define get_csv_int_pos986(X,Y) get_csv_int((X),(Y),986) +#define get_csv_llong_pos986(X,Y) get_csv_llong((X),(Y),986) +#define get_csv_float_pos986(X,Y) get_csv_float((X),(Y),986) +#define get_csv_uint_pos987(X,Y) get_csv_uint((X),(Y),987) +#define get_csv_ullong_pos987(X,Y) get_csv_ullong((X),(Y),987) +#define get_csv_ip_pos987(X,Y) get_csv_ip((X),(Y),987) +#define get_csv_ipv6_pos987(X,Y) get_csv_ipv6((X),(Y),987) +#define get_csv_string_pos987(X,Y) get_csv_string((X),(Y),987) +#define get_csv_v_str_pos987(X,Y) get_csv_string((X),(Y),987) +#define get_csv_bool_pos987(X,Y) get_csv_bool((X),(Y),987) +#define get_csv_int_pos987(X,Y) get_csv_int((X),(Y),987) +#define get_csv_llong_pos987(X,Y) get_csv_llong((X),(Y),987) +#define get_csv_float_pos987(X,Y) get_csv_float((X),(Y),987) +#define get_csv_uint_pos988(X,Y) get_csv_uint((X),(Y),988) +#define get_csv_ullong_pos988(X,Y) get_csv_ullong((X),(Y),988) +#define get_csv_ip_pos988(X,Y) get_csv_ip((X),(Y),988) +#define get_csv_ipv6_pos988(X,Y) get_csv_ipv6((X),(Y),988) +#define get_csv_string_pos988(X,Y) get_csv_string((X),(Y),988) +#define get_csv_v_str_pos988(X,Y) get_csv_string((X),(Y),988) +#define get_csv_bool_pos988(X,Y) get_csv_bool((X),(Y),988) +#define get_csv_int_pos988(X,Y) get_csv_int((X),(Y),988) +#define get_csv_llong_pos988(X,Y) get_csv_llong((X),(Y),988) +#define get_csv_float_pos988(X,Y) get_csv_float((X),(Y),988) +#define get_csv_uint_pos989(X,Y) get_csv_uint((X),(Y),989) +#define get_csv_ullong_pos989(X,Y) get_csv_ullong((X),(Y),989) +#define get_csv_ip_pos989(X,Y) get_csv_ip((X),(Y),989) +#define get_csv_ipv6_pos989(X,Y) get_csv_ipv6((X),(Y),989) +#define get_csv_string_pos989(X,Y) get_csv_string((X),(Y),989) +#define get_csv_v_str_pos989(X,Y) get_csv_string((X),(Y),989) +#define get_csv_bool_pos989(X,Y) get_csv_bool((X),(Y),989) +#define get_csv_int_pos989(X,Y) get_csv_int((X),(Y),989) +#define get_csv_llong_pos989(X,Y) get_csv_llong((X),(Y),989) +#define get_csv_float_pos989(X,Y) get_csv_float((X),(Y),989) +#define get_csv_uint_pos990(X,Y) get_csv_uint((X),(Y),990) +#define get_csv_ullong_pos990(X,Y) get_csv_ullong((X),(Y),990) +#define get_csv_ip_pos990(X,Y) get_csv_ip((X),(Y),990) +#define get_csv_ipv6_pos990(X,Y) get_csv_ipv6((X),(Y),990) +#define get_csv_string_pos990(X,Y) get_csv_string((X),(Y),990) +#define get_csv_v_str_pos990(X,Y) get_csv_string((X),(Y),990) +#define get_csv_bool_pos990(X,Y) get_csv_bool((X),(Y),990) +#define get_csv_int_pos990(X,Y) get_csv_int((X),(Y),990) +#define get_csv_llong_pos990(X,Y) get_csv_llong((X),(Y),990) +#define get_csv_float_pos990(X,Y) get_csv_float((X),(Y),990) +#define get_csv_uint_pos991(X,Y) get_csv_uint((X),(Y),991) +#define get_csv_ullong_pos991(X,Y) get_csv_ullong((X),(Y),991) +#define get_csv_ip_pos991(X,Y) get_csv_ip((X),(Y),991) +#define get_csv_ipv6_pos991(X,Y) get_csv_ipv6((X),(Y),991) +#define get_csv_string_pos991(X,Y) get_csv_string((X),(Y),991) +#define get_csv_v_str_pos991(X,Y) get_csv_string((X),(Y),991) +#define get_csv_bool_pos991(X,Y) get_csv_bool((X),(Y),991) +#define get_csv_int_pos991(X,Y) get_csv_int((X),(Y),991) +#define get_csv_llong_pos991(X,Y) get_csv_llong((X),(Y),991) +#define get_csv_float_pos991(X,Y) get_csv_float((X),(Y),991) +#define get_csv_uint_pos992(X,Y) get_csv_uint((X),(Y),992) +#define get_csv_ullong_pos992(X,Y) get_csv_ullong((X),(Y),992) +#define get_csv_ip_pos992(X,Y) get_csv_ip((X),(Y),992) +#define get_csv_ipv6_pos992(X,Y) get_csv_ipv6((X),(Y),992) +#define get_csv_string_pos992(X,Y) get_csv_string((X),(Y),992) +#define get_csv_v_str_pos992(X,Y) get_csv_string((X),(Y),992) +#define get_csv_bool_pos992(X,Y) get_csv_bool((X),(Y),992) +#define get_csv_int_pos992(X,Y) get_csv_int((X),(Y),992) +#define get_csv_llong_pos992(X,Y) get_csv_llong((X),(Y),992) +#define get_csv_float_pos992(X,Y) get_csv_float((X),(Y),992) +#define get_csv_uint_pos993(X,Y) get_csv_uint((X),(Y),993) +#define get_csv_ullong_pos993(X,Y) get_csv_ullong((X),(Y),993) +#define get_csv_ip_pos993(X,Y) get_csv_ip((X),(Y),993) +#define get_csv_ipv6_pos993(X,Y) get_csv_ipv6((X),(Y),993) +#define get_csv_string_pos993(X,Y) get_csv_string((X),(Y),993) +#define get_csv_v_str_pos993(X,Y) get_csv_string((X),(Y),993) +#define get_csv_bool_pos993(X,Y) get_csv_bool((X),(Y),993) +#define get_csv_int_pos993(X,Y) get_csv_int((X),(Y),993) +#define get_csv_llong_pos993(X,Y) get_csv_llong((X),(Y),993) +#define get_csv_float_pos993(X,Y) get_csv_float((X),(Y),993) +#define get_csv_uint_pos994(X,Y) get_csv_uint((X),(Y),994) +#define get_csv_ullong_pos994(X,Y) get_csv_ullong((X),(Y),994) +#define get_csv_ip_pos994(X,Y) get_csv_ip((X),(Y),994) +#define get_csv_ipv6_pos994(X,Y) get_csv_ipv6((X),(Y),994) +#define get_csv_string_pos994(X,Y) get_csv_string((X),(Y),994) +#define get_csv_v_str_pos994(X,Y) get_csv_string((X),(Y),994) +#define get_csv_bool_pos994(X,Y) get_csv_bool((X),(Y),994) +#define get_csv_int_pos994(X,Y) get_csv_int((X),(Y),994) +#define get_csv_llong_pos994(X,Y) get_csv_llong((X),(Y),994) +#define get_csv_float_pos994(X,Y) get_csv_float((X),(Y),994) +#define get_csv_uint_pos995(X,Y) get_csv_uint((X),(Y),995) +#define get_csv_ullong_pos995(X,Y) get_csv_ullong((X),(Y),995) +#define get_csv_ip_pos995(X,Y) get_csv_ip((X),(Y),995) +#define get_csv_ipv6_pos995(X,Y) get_csv_ipv6((X),(Y),995) +#define get_csv_string_pos995(X,Y) get_csv_string((X),(Y),995) +#define get_csv_v_str_pos995(X,Y) get_csv_string((X),(Y),995) +#define get_csv_bool_pos995(X,Y) get_csv_bool((X),(Y),995) +#define get_csv_int_pos995(X,Y) get_csv_int((X),(Y),995) +#define get_csv_llong_pos995(X,Y) get_csv_llong((X),(Y),995) +#define get_csv_float_pos995(X,Y) get_csv_float((X),(Y),995) +#define get_csv_uint_pos996(X,Y) get_csv_uint((X),(Y),996) +#define get_csv_ullong_pos996(X,Y) get_csv_ullong((X),(Y),996) +#define get_csv_ip_pos996(X,Y) get_csv_ip((X),(Y),996) +#define get_csv_ipv6_pos996(X,Y) get_csv_ipv6((X),(Y),996) +#define get_csv_string_pos996(X,Y) get_csv_string((X),(Y),996) +#define get_csv_v_str_pos996(X,Y) get_csv_string((X),(Y),996) +#define get_csv_bool_pos996(X,Y) get_csv_bool((X),(Y),996) +#define get_csv_int_pos996(X,Y) get_csv_int((X),(Y),996) +#define get_csv_llong_pos996(X,Y) get_csv_llong((X),(Y),996) +#define get_csv_float_pos996(X,Y) get_csv_float((X),(Y),996) +#define get_csv_uint_pos997(X,Y) get_csv_uint((X),(Y),997) +#define get_csv_ullong_pos997(X,Y) get_csv_ullong((X),(Y),997) +#define get_csv_ip_pos997(X,Y) get_csv_ip((X),(Y),997) +#define get_csv_ipv6_pos997(X,Y) get_csv_ipv6((X),(Y),997) +#define get_csv_string_pos997(X,Y) get_csv_string((X),(Y),997) +#define get_csv_v_str_pos997(X,Y) get_csv_string((X),(Y),997) +#define get_csv_bool_pos997(X,Y) get_csv_bool((X),(Y),997) +#define get_csv_int_pos997(X,Y) get_csv_int((X),(Y),997) +#define get_csv_llong_pos997(X,Y) get_csv_llong((X),(Y),997) +#define get_csv_float_pos997(X,Y) get_csv_float((X),(Y),997) +#define get_csv_uint_pos998(X,Y) get_csv_uint((X),(Y),998) +#define get_csv_ullong_pos998(X,Y) get_csv_ullong((X),(Y),998) +#define get_csv_ip_pos998(X,Y) get_csv_ip((X),(Y),998) +#define get_csv_ipv6_pos998(X,Y) get_csv_ipv6((X),(Y),998) +#define get_csv_string_pos998(X,Y) get_csv_string((X),(Y),998) +#define get_csv_v_str_pos998(X,Y) get_csv_string((X),(Y),998) +#define get_csv_bool_pos998(X,Y) get_csv_bool((X),(Y),998) +#define get_csv_int_pos998(X,Y) get_csv_int((X),(Y),998) +#define get_csv_llong_pos998(X,Y) get_csv_llong((X),(Y),998) +#define get_csv_float_pos998(X,Y) get_csv_float((X),(Y),998) +#define get_csv_uint_pos999(X,Y) get_csv_uint((X),(Y),999) +#define get_csv_ullong_pos999(X,Y) get_csv_ullong((X),(Y),999) +#define get_csv_ip_pos999(X,Y) get_csv_ip((X),(Y),999) +#define get_csv_ipv6_pos999(X,Y) get_csv_ipv6((X),(Y),999) +#define get_csv_string_pos999(X,Y) get_csv_string((X),(Y),999) +#define get_csv_v_str_pos999(X,Y) get_csv_string((X),(Y),999) +#define get_csv_bool_pos999(X,Y) get_csv_bool((X),(Y),999) +#define get_csv_int_pos999(X,Y) get_csv_int((X),(Y),999) +#define get_csv_llong_pos999(X,Y) get_csv_llong((X),(Y),999) +#define get_csv_float_pos999(X,Y) get_csv_float((X),(Y),999) +#define get_csv_uint_pos1000(X,Y) get_csv_uint((X),(Y),1000) +#define get_csv_ullong_pos1000(X,Y) get_csv_ullong((X),(Y),1000) +#define get_csv_ip_pos1000(X,Y) get_csv_ip((X),(Y),1000) +#define get_csv_ipv6_pos1000(X,Y) get_csv_ipv6((X),(Y),1000) +#define get_csv_string_pos1000(X,Y) get_csv_string((X),(Y),1000) +#define get_csv_v_str_pos1000(X,Y) get_csv_string((X),(Y),1000) +#define get_csv_bool_pos1000(X,Y) get_csv_bool((X),(Y),1000) +#define get_csv_int_pos1000(X,Y) get_csv_int((X),(Y),1000) +#define get_csv_llong_pos1000(X,Y) get_csv_llong((X),(Y),1000) +#define get_csv_float_pos1000(X,Y) get_csv_float((X),(Y),1000) +#endif diff --git a/include/lfta/gdat_macro.h b/include/lfta/gdat_macro.h new file mode 100644 index 0000000..971f833 --- /dev/null +++ b/include/lfta/gdat_macro.h @@ -0,0 +1,10017 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef GDAT_MACRO_H +#define GDAT_MACRO_H +#define get_gdat_uint_pos1(X,Y) get_gdat_uint((X),(Y),1) +#define get_gdat_ullong_pos1(X,Y) get_gdat_ullong((X),(Y),1) +#define get_gdat_ip_pos1(X,Y) get_gdat_ip((X),(Y),1) +#define get_gdat_ipv6_pos1(X,Y) get_gdat_ipv6((X),(Y),1) +#define get_gdat_string_pos1(X,Y) get_gdat_string((X),(Y),1) +#define get_gdat_v_str_pos1(X,Y) get_gdat_string((X),(Y),1) +#define get_gdat_bool_pos1(X,Y) get_gdat_bool((X),(Y),1) +#define get_gdat_int_pos1(X,Y) get_gdat_int((X),(Y),1) +#define get_gdat_llong_pos1(X,Y) get_gdat_llong((X),(Y),1) +#define get_gdat_float_pos1(X,Y) get_gdat_float((X),(Y),1) +#define get_gdat_uint_pos2(X,Y) get_gdat_uint((X),(Y),2) +#define get_gdat_ullong_pos2(X,Y) get_gdat_ullong((X),(Y),2) +#define get_gdat_ip_pos2(X,Y) get_gdat_ip((X),(Y),2) +#define get_gdat_ipv6_pos2(X,Y) get_gdat_ipv6((X),(Y),2) +#define get_gdat_string_pos2(X,Y) get_gdat_string((X),(Y),2) +#define get_gdat_v_str_pos2(X,Y) get_gdat_string((X),(Y),2) +#define get_gdat_bool_pos2(X,Y) get_gdat_bool((X),(Y),2) +#define get_gdat_int_pos2(X,Y) get_gdat_int((X),(Y),2) +#define get_gdat_llong_pos2(X,Y) get_gdat_llong((X),(Y),2) +#define get_gdat_float_pos2(X,Y) get_gdat_float((X),(Y),2) +#define get_gdat_uint_pos3(X,Y) get_gdat_uint((X),(Y),3) +#define get_gdat_ullong_pos3(X,Y) get_gdat_ullong((X),(Y),3) +#define get_gdat_ip_pos3(X,Y) get_gdat_ip((X),(Y),3) +#define get_gdat_ipv6_pos3(X,Y) get_gdat_ipv6((X),(Y),3) +#define get_gdat_string_pos3(X,Y) get_gdat_string((X),(Y),3) +#define get_gdat_v_str_pos3(X,Y) get_gdat_string((X),(Y),3) +#define get_gdat_bool_pos3(X,Y) get_gdat_bool((X),(Y),3) +#define get_gdat_int_pos3(X,Y) get_gdat_int((X),(Y),3) +#define get_gdat_llong_pos3(X,Y) get_gdat_llong((X),(Y),3) +#define get_gdat_float_pos3(X,Y) get_gdat_float((X),(Y),3) +#define get_gdat_uint_pos4(X,Y) get_gdat_uint((X),(Y),4) +#define get_gdat_ullong_pos4(X,Y) get_gdat_ullong((X),(Y),4) +#define get_gdat_ip_pos4(X,Y) get_gdat_ip((X),(Y),4) +#define get_gdat_ipv6_pos4(X,Y) get_gdat_ipv6((X),(Y),4) +#define get_gdat_string_pos4(X,Y) get_gdat_string((X),(Y),4) +#define get_gdat_v_str_pos4(X,Y) get_gdat_string((X),(Y),4) +#define get_gdat_bool_pos4(X,Y) get_gdat_bool((X),(Y),4) +#define get_gdat_int_pos4(X,Y) get_gdat_int((X),(Y),4) +#define get_gdat_llong_pos4(X,Y) get_gdat_llong((X),(Y),4) +#define get_gdat_float_pos4(X,Y) get_gdat_float((X),(Y),4) +#define get_gdat_uint_pos5(X,Y) get_gdat_uint((X),(Y),5) +#define get_gdat_ullong_pos5(X,Y) get_gdat_ullong((X),(Y),5) +#define get_gdat_ip_pos5(X,Y) get_gdat_ip((X),(Y),5) +#define get_gdat_ipv6_pos5(X,Y) get_gdat_ipv6((X),(Y),5) +#define get_gdat_string_pos5(X,Y) get_gdat_string((X),(Y),5) +#define get_gdat_v_str_pos5(X,Y) get_gdat_string((X),(Y),5) +#define get_gdat_bool_pos5(X,Y) get_gdat_bool((X),(Y),5) +#define get_gdat_int_pos5(X,Y) get_gdat_int((X),(Y),5) +#define get_gdat_llong_pos5(X,Y) get_gdat_llong((X),(Y),5) +#define get_gdat_float_pos5(X,Y) get_gdat_float((X),(Y),5) +#define get_gdat_uint_pos6(X,Y) get_gdat_uint((X),(Y),6) +#define get_gdat_ullong_pos6(X,Y) get_gdat_ullong((X),(Y),6) +#define get_gdat_ip_pos6(X,Y) get_gdat_ip((X),(Y),6) +#define get_gdat_ipv6_pos6(X,Y) get_gdat_ipv6((X),(Y),6) +#define get_gdat_string_pos6(X,Y) get_gdat_string((X),(Y),6) +#define get_gdat_v_str_pos6(X,Y) get_gdat_string((X),(Y),6) +#define get_gdat_bool_pos6(X,Y) get_gdat_bool((X),(Y),6) +#define get_gdat_int_pos6(X,Y) get_gdat_int((X),(Y),6) +#define get_gdat_llong_pos6(X,Y) get_gdat_llong((X),(Y),6) +#define get_gdat_float_pos6(X,Y) get_gdat_float((X),(Y),6) +#define get_gdat_uint_pos7(X,Y) get_gdat_uint((X),(Y),7) +#define get_gdat_ullong_pos7(X,Y) get_gdat_ullong((X),(Y),7) +#define get_gdat_ip_pos7(X,Y) get_gdat_ip((X),(Y),7) +#define get_gdat_ipv6_pos7(X,Y) get_gdat_ipv6((X),(Y),7) +#define get_gdat_string_pos7(X,Y) get_gdat_string((X),(Y),7) +#define get_gdat_v_str_pos7(X,Y) get_gdat_string((X),(Y),7) +#define get_gdat_bool_pos7(X,Y) get_gdat_bool((X),(Y),7) +#define get_gdat_int_pos7(X,Y) get_gdat_int((X),(Y),7) +#define get_gdat_llong_pos7(X,Y) get_gdat_llong((X),(Y),7) +#define get_gdat_float_pos7(X,Y) get_gdat_float((X),(Y),7) +#define get_gdat_uint_pos8(X,Y) get_gdat_uint((X),(Y),8) +#define get_gdat_ullong_pos8(X,Y) get_gdat_ullong((X),(Y),8) +#define get_gdat_ip_pos8(X,Y) get_gdat_ip((X),(Y),8) +#define get_gdat_ipv6_pos8(X,Y) get_gdat_ipv6((X),(Y),8) +#define get_gdat_string_pos8(X,Y) get_gdat_string((X),(Y),8) +#define get_gdat_v_str_pos8(X,Y) get_gdat_string((X),(Y),8) +#define get_gdat_bool_pos8(X,Y) get_gdat_bool((X),(Y),8) +#define get_gdat_int_pos8(X,Y) get_gdat_int((X),(Y),8) +#define get_gdat_llong_pos8(X,Y) get_gdat_llong((X),(Y),8) +#define get_gdat_float_pos8(X,Y) get_gdat_float((X),(Y),8) +#define get_gdat_uint_pos9(X,Y) get_gdat_uint((X),(Y),9) +#define get_gdat_ullong_pos9(X,Y) get_gdat_ullong((X),(Y),9) +#define get_gdat_ip_pos9(X,Y) get_gdat_ip((X),(Y),9) +#define get_gdat_ipv6_pos9(X,Y) get_gdat_ipv6((X),(Y),9) +#define get_gdat_string_pos9(X,Y) get_gdat_string((X),(Y),9) +#define get_gdat_v_str_pos9(X,Y) get_gdat_string((X),(Y),9) +#define get_gdat_bool_pos9(X,Y) get_gdat_bool((X),(Y),9) +#define get_gdat_int_pos9(X,Y) get_gdat_int((X),(Y),9) +#define get_gdat_llong_pos9(X,Y) get_gdat_llong((X),(Y),9) +#define get_gdat_float_pos9(X,Y) get_gdat_float((X),(Y),9) +#define get_gdat_uint_pos10(X,Y) get_gdat_uint((X),(Y),10) +#define get_gdat_ullong_pos10(X,Y) get_gdat_ullong((X),(Y),10) +#define get_gdat_ip_pos10(X,Y) get_gdat_ip((X),(Y),10) +#define get_gdat_ipv6_pos10(X,Y) get_gdat_ipv6((X),(Y),10) +#define get_gdat_string_pos10(X,Y) get_gdat_string((X),(Y),10) +#define get_gdat_v_str_pos10(X,Y) get_gdat_string((X),(Y),10) +#define get_gdat_bool_pos10(X,Y) get_gdat_bool((X),(Y),10) +#define get_gdat_int_pos10(X,Y) get_gdat_int((X),(Y),10) +#define get_gdat_llong_pos10(X,Y) get_gdat_llong((X),(Y),10) +#define get_gdat_float_pos10(X,Y) get_gdat_float((X),(Y),10) +#define get_gdat_uint_pos11(X,Y) get_gdat_uint((X),(Y),11) +#define get_gdat_ullong_pos11(X,Y) get_gdat_ullong((X),(Y),11) +#define get_gdat_ip_pos11(X,Y) get_gdat_ip((X),(Y),11) +#define get_gdat_ipv6_pos11(X,Y) get_gdat_ipv6((X),(Y),11) +#define get_gdat_string_pos11(X,Y) get_gdat_string((X),(Y),11) +#define get_gdat_v_str_pos11(X,Y) get_gdat_string((X),(Y),11) +#define get_gdat_bool_pos11(X,Y) get_gdat_bool((X),(Y),11) +#define get_gdat_int_pos11(X,Y) get_gdat_int((X),(Y),11) +#define get_gdat_llong_pos11(X,Y) get_gdat_llong((X),(Y),11) +#define get_gdat_float_pos11(X,Y) get_gdat_float((X),(Y),11) +#define get_gdat_uint_pos12(X,Y) get_gdat_uint((X),(Y),12) +#define get_gdat_ullong_pos12(X,Y) get_gdat_ullong((X),(Y),12) +#define get_gdat_ip_pos12(X,Y) get_gdat_ip((X),(Y),12) +#define get_gdat_ipv6_pos12(X,Y) get_gdat_ipv6((X),(Y),12) +#define get_gdat_string_pos12(X,Y) get_gdat_string((X),(Y),12) +#define get_gdat_v_str_pos12(X,Y) get_gdat_string((X),(Y),12) +#define get_gdat_bool_pos12(X,Y) get_gdat_bool((X),(Y),12) +#define get_gdat_int_pos12(X,Y) get_gdat_int((X),(Y),12) +#define get_gdat_llong_pos12(X,Y) get_gdat_llong((X),(Y),12) +#define get_gdat_float_pos12(X,Y) get_gdat_float((X),(Y),12) +#define get_gdat_uint_pos13(X,Y) get_gdat_uint((X),(Y),13) +#define get_gdat_ullong_pos13(X,Y) get_gdat_ullong((X),(Y),13) +#define get_gdat_ip_pos13(X,Y) get_gdat_ip((X),(Y),13) +#define get_gdat_ipv6_pos13(X,Y) get_gdat_ipv6((X),(Y),13) +#define get_gdat_string_pos13(X,Y) get_gdat_string((X),(Y),13) +#define get_gdat_v_str_pos13(X,Y) get_gdat_string((X),(Y),13) +#define get_gdat_bool_pos13(X,Y) get_gdat_bool((X),(Y),13) +#define get_gdat_int_pos13(X,Y) get_gdat_int((X),(Y),13) +#define get_gdat_llong_pos13(X,Y) get_gdat_llong((X),(Y),13) +#define get_gdat_float_pos13(X,Y) get_gdat_float((X),(Y),13) +#define get_gdat_uint_pos14(X,Y) get_gdat_uint((X),(Y),14) +#define get_gdat_ullong_pos14(X,Y) get_gdat_ullong((X),(Y),14) +#define get_gdat_ip_pos14(X,Y) get_gdat_ip((X),(Y),14) +#define get_gdat_ipv6_pos14(X,Y) get_gdat_ipv6((X),(Y),14) +#define get_gdat_string_pos14(X,Y) get_gdat_string((X),(Y),14) +#define get_gdat_v_str_pos14(X,Y) get_gdat_string((X),(Y),14) +#define get_gdat_bool_pos14(X,Y) get_gdat_bool((X),(Y),14) +#define get_gdat_int_pos14(X,Y) get_gdat_int((X),(Y),14) +#define get_gdat_llong_pos14(X,Y) get_gdat_llong((X),(Y),14) +#define get_gdat_float_pos14(X,Y) get_gdat_float((X),(Y),14) +#define get_gdat_uint_pos15(X,Y) get_gdat_uint((X),(Y),15) +#define get_gdat_ullong_pos15(X,Y) get_gdat_ullong((X),(Y),15) +#define get_gdat_ip_pos15(X,Y) get_gdat_ip((X),(Y),15) +#define get_gdat_ipv6_pos15(X,Y) get_gdat_ipv6((X),(Y),15) +#define get_gdat_string_pos15(X,Y) get_gdat_string((X),(Y),15) +#define get_gdat_v_str_pos15(X,Y) get_gdat_string((X),(Y),15) +#define get_gdat_bool_pos15(X,Y) get_gdat_bool((X),(Y),15) +#define get_gdat_int_pos15(X,Y) get_gdat_int((X),(Y),15) +#define get_gdat_llong_pos15(X,Y) get_gdat_llong((X),(Y),15) +#define get_gdat_float_pos15(X,Y) get_gdat_float((X),(Y),15) +#define get_gdat_uint_pos16(X,Y) get_gdat_uint((X),(Y),16) +#define get_gdat_ullong_pos16(X,Y) get_gdat_ullong((X),(Y),16) +#define get_gdat_ip_pos16(X,Y) get_gdat_ip((X),(Y),16) +#define get_gdat_ipv6_pos16(X,Y) get_gdat_ipv6((X),(Y),16) +#define get_gdat_string_pos16(X,Y) get_gdat_string((X),(Y),16) +#define get_gdat_v_str_pos16(X,Y) get_gdat_string((X),(Y),16) +#define get_gdat_bool_pos16(X,Y) get_gdat_bool((X),(Y),16) +#define get_gdat_int_pos16(X,Y) get_gdat_int((X),(Y),16) +#define get_gdat_llong_pos16(X,Y) get_gdat_llong((X),(Y),16) +#define get_gdat_float_pos16(X,Y) get_gdat_float((X),(Y),16) +#define get_gdat_uint_pos17(X,Y) get_gdat_uint((X),(Y),17) +#define get_gdat_ullong_pos17(X,Y) get_gdat_ullong((X),(Y),17) +#define get_gdat_ip_pos17(X,Y) get_gdat_ip((X),(Y),17) +#define get_gdat_ipv6_pos17(X,Y) get_gdat_ipv6((X),(Y),17) +#define get_gdat_string_pos17(X,Y) get_gdat_string((X),(Y),17) +#define get_gdat_v_str_pos17(X,Y) get_gdat_string((X),(Y),17) +#define get_gdat_bool_pos17(X,Y) get_gdat_bool((X),(Y),17) +#define get_gdat_int_pos17(X,Y) get_gdat_int((X),(Y),17) +#define get_gdat_llong_pos17(X,Y) get_gdat_llong((X),(Y),17) +#define get_gdat_float_pos17(X,Y) get_gdat_float((X),(Y),17) +#define get_gdat_uint_pos18(X,Y) get_gdat_uint((X),(Y),18) +#define get_gdat_ullong_pos18(X,Y) get_gdat_ullong((X),(Y),18) +#define get_gdat_ip_pos18(X,Y) get_gdat_ip((X),(Y),18) +#define get_gdat_ipv6_pos18(X,Y) get_gdat_ipv6((X),(Y),18) +#define get_gdat_string_pos18(X,Y) get_gdat_string((X),(Y),18) +#define get_gdat_v_str_pos18(X,Y) get_gdat_string((X),(Y),18) +#define get_gdat_bool_pos18(X,Y) get_gdat_bool((X),(Y),18) +#define get_gdat_int_pos18(X,Y) get_gdat_int((X),(Y),18) +#define get_gdat_llong_pos18(X,Y) get_gdat_llong((X),(Y),18) +#define get_gdat_float_pos18(X,Y) get_gdat_float((X),(Y),18) +#define get_gdat_uint_pos19(X,Y) get_gdat_uint((X),(Y),19) +#define get_gdat_ullong_pos19(X,Y) get_gdat_ullong((X),(Y),19) +#define get_gdat_ip_pos19(X,Y) get_gdat_ip((X),(Y),19) +#define get_gdat_ipv6_pos19(X,Y) get_gdat_ipv6((X),(Y),19) +#define get_gdat_string_pos19(X,Y) get_gdat_string((X),(Y),19) +#define get_gdat_v_str_pos19(X,Y) get_gdat_string((X),(Y),19) +#define get_gdat_bool_pos19(X,Y) get_gdat_bool((X),(Y),19) +#define get_gdat_int_pos19(X,Y) get_gdat_int((X),(Y),19) +#define get_gdat_llong_pos19(X,Y) get_gdat_llong((X),(Y),19) +#define get_gdat_float_pos19(X,Y) get_gdat_float((X),(Y),19) +#define get_gdat_uint_pos20(X,Y) get_gdat_uint((X),(Y),20) +#define get_gdat_ullong_pos20(X,Y) get_gdat_ullong((X),(Y),20) +#define get_gdat_ip_pos20(X,Y) get_gdat_ip((X),(Y),20) +#define get_gdat_ipv6_pos20(X,Y) get_gdat_ipv6((X),(Y),20) +#define get_gdat_string_pos20(X,Y) get_gdat_string((X),(Y),20) +#define get_gdat_v_str_pos20(X,Y) get_gdat_string((X),(Y),20) +#define get_gdat_bool_pos20(X,Y) get_gdat_bool((X),(Y),20) +#define get_gdat_int_pos20(X,Y) get_gdat_int((X),(Y),20) +#define get_gdat_llong_pos20(X,Y) get_gdat_llong((X),(Y),20) +#define get_gdat_float_pos20(X,Y) get_gdat_float((X),(Y),20) +#define get_gdat_uint_pos21(X,Y) get_gdat_uint((X),(Y),21) +#define get_gdat_ullong_pos21(X,Y) get_gdat_ullong((X),(Y),21) +#define get_gdat_ip_pos21(X,Y) get_gdat_ip((X),(Y),21) +#define get_gdat_ipv6_pos21(X,Y) get_gdat_ipv6((X),(Y),21) +#define get_gdat_string_pos21(X,Y) get_gdat_string((X),(Y),21) +#define get_gdat_v_str_pos21(X,Y) get_gdat_string((X),(Y),21) +#define get_gdat_bool_pos21(X,Y) get_gdat_bool((X),(Y),21) +#define get_gdat_int_pos21(X,Y) get_gdat_int((X),(Y),21) +#define get_gdat_llong_pos21(X,Y) get_gdat_llong((X),(Y),21) +#define get_gdat_float_pos21(X,Y) get_gdat_float((X),(Y),21) +#define get_gdat_uint_pos22(X,Y) get_gdat_uint((X),(Y),22) +#define get_gdat_ullong_pos22(X,Y) get_gdat_ullong((X),(Y),22) +#define get_gdat_ip_pos22(X,Y) get_gdat_ip((X),(Y),22) +#define get_gdat_ipv6_pos22(X,Y) get_gdat_ipv6((X),(Y),22) +#define get_gdat_string_pos22(X,Y) get_gdat_string((X),(Y),22) +#define get_gdat_v_str_pos22(X,Y) get_gdat_string((X),(Y),22) +#define get_gdat_bool_pos22(X,Y) get_gdat_bool((X),(Y),22) +#define get_gdat_int_pos22(X,Y) get_gdat_int((X),(Y),22) +#define get_gdat_llong_pos22(X,Y) get_gdat_llong((X),(Y),22) +#define get_gdat_float_pos22(X,Y) get_gdat_float((X),(Y),22) +#define get_gdat_uint_pos23(X,Y) get_gdat_uint((X),(Y),23) +#define get_gdat_ullong_pos23(X,Y) get_gdat_ullong((X),(Y),23) +#define get_gdat_ip_pos23(X,Y) get_gdat_ip((X),(Y),23) +#define get_gdat_ipv6_pos23(X,Y) get_gdat_ipv6((X),(Y),23) +#define get_gdat_string_pos23(X,Y) get_gdat_string((X),(Y),23) +#define get_gdat_v_str_pos23(X,Y) get_gdat_string((X),(Y),23) +#define get_gdat_bool_pos23(X,Y) get_gdat_bool((X),(Y),23) +#define get_gdat_int_pos23(X,Y) get_gdat_int((X),(Y),23) +#define get_gdat_llong_pos23(X,Y) get_gdat_llong((X),(Y),23) +#define get_gdat_float_pos23(X,Y) get_gdat_float((X),(Y),23) +#define get_gdat_uint_pos24(X,Y) get_gdat_uint((X),(Y),24) +#define get_gdat_ullong_pos24(X,Y) get_gdat_ullong((X),(Y),24) +#define get_gdat_ip_pos24(X,Y) get_gdat_ip((X),(Y),24) +#define get_gdat_ipv6_pos24(X,Y) get_gdat_ipv6((X),(Y),24) +#define get_gdat_string_pos24(X,Y) get_gdat_string((X),(Y),24) +#define get_gdat_v_str_pos24(X,Y) get_gdat_string((X),(Y),24) +#define get_gdat_bool_pos24(X,Y) get_gdat_bool((X),(Y),24) +#define get_gdat_int_pos24(X,Y) get_gdat_int((X),(Y),24) +#define get_gdat_llong_pos24(X,Y) get_gdat_llong((X),(Y),24) +#define get_gdat_float_pos24(X,Y) get_gdat_float((X),(Y),24) +#define get_gdat_uint_pos25(X,Y) get_gdat_uint((X),(Y),25) +#define get_gdat_ullong_pos25(X,Y) get_gdat_ullong((X),(Y),25) +#define get_gdat_ip_pos25(X,Y) get_gdat_ip((X),(Y),25) +#define get_gdat_ipv6_pos25(X,Y) get_gdat_ipv6((X),(Y),25) +#define get_gdat_string_pos25(X,Y) get_gdat_string((X),(Y),25) +#define get_gdat_v_str_pos25(X,Y) get_gdat_string((X),(Y),25) +#define get_gdat_bool_pos25(X,Y) get_gdat_bool((X),(Y),25) +#define get_gdat_int_pos25(X,Y) get_gdat_int((X),(Y),25) +#define get_gdat_llong_pos25(X,Y) get_gdat_llong((X),(Y),25) +#define get_gdat_float_pos25(X,Y) get_gdat_float((X),(Y),25) +#define get_gdat_uint_pos26(X,Y) get_gdat_uint((X),(Y),26) +#define get_gdat_ullong_pos26(X,Y) get_gdat_ullong((X),(Y),26) +#define get_gdat_ip_pos26(X,Y) get_gdat_ip((X),(Y),26) +#define get_gdat_ipv6_pos26(X,Y) get_gdat_ipv6((X),(Y),26) +#define get_gdat_string_pos26(X,Y) get_gdat_string((X),(Y),26) +#define get_gdat_v_str_pos26(X,Y) get_gdat_string((X),(Y),26) +#define get_gdat_bool_pos26(X,Y) get_gdat_bool((X),(Y),26) +#define get_gdat_int_pos26(X,Y) get_gdat_int((X),(Y),26) +#define get_gdat_llong_pos26(X,Y) get_gdat_llong((X),(Y),26) +#define get_gdat_float_pos26(X,Y) get_gdat_float((X),(Y),26) +#define get_gdat_uint_pos27(X,Y) get_gdat_uint((X),(Y),27) +#define get_gdat_ullong_pos27(X,Y) get_gdat_ullong((X),(Y),27) +#define get_gdat_ip_pos27(X,Y) get_gdat_ip((X),(Y),27) +#define get_gdat_ipv6_pos27(X,Y) get_gdat_ipv6((X),(Y),27) +#define get_gdat_string_pos27(X,Y) get_gdat_string((X),(Y),27) +#define get_gdat_v_str_pos27(X,Y) get_gdat_string((X),(Y),27) +#define get_gdat_bool_pos27(X,Y) get_gdat_bool((X),(Y),27) +#define get_gdat_int_pos27(X,Y) get_gdat_int((X),(Y),27) +#define get_gdat_llong_pos27(X,Y) get_gdat_llong((X),(Y),27) +#define get_gdat_float_pos27(X,Y) get_gdat_float((X),(Y),27) +#define get_gdat_uint_pos28(X,Y) get_gdat_uint((X),(Y),28) +#define get_gdat_ullong_pos28(X,Y) get_gdat_ullong((X),(Y),28) +#define get_gdat_ip_pos28(X,Y) get_gdat_ip((X),(Y),28) +#define get_gdat_ipv6_pos28(X,Y) get_gdat_ipv6((X),(Y),28) +#define get_gdat_string_pos28(X,Y) get_gdat_string((X),(Y),28) +#define get_gdat_v_str_pos28(X,Y) get_gdat_string((X),(Y),28) +#define get_gdat_bool_pos28(X,Y) get_gdat_bool((X),(Y),28) +#define get_gdat_int_pos28(X,Y) get_gdat_int((X),(Y),28) +#define get_gdat_llong_pos28(X,Y) get_gdat_llong((X),(Y),28) +#define get_gdat_float_pos28(X,Y) get_gdat_float((X),(Y),28) +#define get_gdat_uint_pos29(X,Y) get_gdat_uint((X),(Y),29) +#define get_gdat_ullong_pos29(X,Y) get_gdat_ullong((X),(Y),29) +#define get_gdat_ip_pos29(X,Y) get_gdat_ip((X),(Y),29) +#define get_gdat_ipv6_pos29(X,Y) get_gdat_ipv6((X),(Y),29) +#define get_gdat_string_pos29(X,Y) get_gdat_string((X),(Y),29) +#define get_gdat_v_str_pos29(X,Y) get_gdat_string((X),(Y),29) +#define get_gdat_bool_pos29(X,Y) get_gdat_bool((X),(Y),29) +#define get_gdat_int_pos29(X,Y) get_gdat_int((X),(Y),29) +#define get_gdat_llong_pos29(X,Y) get_gdat_llong((X),(Y),29) +#define get_gdat_float_pos29(X,Y) get_gdat_float((X),(Y),29) +#define get_gdat_uint_pos30(X,Y) get_gdat_uint((X),(Y),30) +#define get_gdat_ullong_pos30(X,Y) get_gdat_ullong((X),(Y),30) +#define get_gdat_ip_pos30(X,Y) get_gdat_ip((X),(Y),30) +#define get_gdat_ipv6_pos30(X,Y) get_gdat_ipv6((X),(Y),30) +#define get_gdat_string_pos30(X,Y) get_gdat_string((X),(Y),30) +#define get_gdat_v_str_pos30(X,Y) get_gdat_string((X),(Y),30) +#define get_gdat_bool_pos30(X,Y) get_gdat_bool((X),(Y),30) +#define get_gdat_int_pos30(X,Y) get_gdat_int((X),(Y),30) +#define get_gdat_llong_pos30(X,Y) get_gdat_llong((X),(Y),30) +#define get_gdat_float_pos30(X,Y) get_gdat_float((X),(Y),30) +#define get_gdat_uint_pos31(X,Y) get_gdat_uint((X),(Y),31) +#define get_gdat_ullong_pos31(X,Y) get_gdat_ullong((X),(Y),31) +#define get_gdat_ip_pos31(X,Y) get_gdat_ip((X),(Y),31) +#define get_gdat_ipv6_pos31(X,Y) get_gdat_ipv6((X),(Y),31) +#define get_gdat_string_pos31(X,Y) get_gdat_string((X),(Y),31) +#define get_gdat_v_str_pos31(X,Y) get_gdat_string((X),(Y),31) +#define get_gdat_bool_pos31(X,Y) get_gdat_bool((X),(Y),31) +#define get_gdat_int_pos31(X,Y) get_gdat_int((X),(Y),31) +#define get_gdat_llong_pos31(X,Y) get_gdat_llong((X),(Y),31) +#define get_gdat_float_pos31(X,Y) get_gdat_float((X),(Y),31) +#define get_gdat_uint_pos32(X,Y) get_gdat_uint((X),(Y),32) +#define get_gdat_ullong_pos32(X,Y) get_gdat_ullong((X),(Y),32) +#define get_gdat_ip_pos32(X,Y) get_gdat_ip((X),(Y),32) +#define get_gdat_ipv6_pos32(X,Y) get_gdat_ipv6((X),(Y),32) +#define get_gdat_string_pos32(X,Y) get_gdat_string((X),(Y),32) +#define get_gdat_v_str_pos32(X,Y) get_gdat_string((X),(Y),32) +#define get_gdat_bool_pos32(X,Y) get_gdat_bool((X),(Y),32) +#define get_gdat_int_pos32(X,Y) get_gdat_int((X),(Y),32) +#define get_gdat_llong_pos32(X,Y) get_gdat_llong((X),(Y),32) +#define get_gdat_float_pos32(X,Y) get_gdat_float((X),(Y),32) +#define get_gdat_uint_pos33(X,Y) get_gdat_uint((X),(Y),33) +#define get_gdat_ullong_pos33(X,Y) get_gdat_ullong((X),(Y),33) +#define get_gdat_ip_pos33(X,Y) get_gdat_ip((X),(Y),33) +#define get_gdat_ipv6_pos33(X,Y) get_gdat_ipv6((X),(Y),33) +#define get_gdat_string_pos33(X,Y) get_gdat_string((X),(Y),33) +#define get_gdat_v_str_pos33(X,Y) get_gdat_string((X),(Y),33) +#define get_gdat_bool_pos33(X,Y) get_gdat_bool((X),(Y),33) +#define get_gdat_int_pos33(X,Y) get_gdat_int((X),(Y),33) +#define get_gdat_llong_pos33(X,Y) get_gdat_llong((X),(Y),33) +#define get_gdat_float_pos33(X,Y) get_gdat_float((X),(Y),33) +#define get_gdat_uint_pos34(X,Y) get_gdat_uint((X),(Y),34) +#define get_gdat_ullong_pos34(X,Y) get_gdat_ullong((X),(Y),34) +#define get_gdat_ip_pos34(X,Y) get_gdat_ip((X),(Y),34) +#define get_gdat_ipv6_pos34(X,Y) get_gdat_ipv6((X),(Y),34) +#define get_gdat_string_pos34(X,Y) get_gdat_string((X),(Y),34) +#define get_gdat_v_str_pos34(X,Y) get_gdat_string((X),(Y),34) +#define get_gdat_bool_pos34(X,Y) get_gdat_bool((X),(Y),34) +#define get_gdat_int_pos34(X,Y) get_gdat_int((X),(Y),34) +#define get_gdat_llong_pos34(X,Y) get_gdat_llong((X),(Y),34) +#define get_gdat_float_pos34(X,Y) get_gdat_float((X),(Y),34) +#define get_gdat_uint_pos35(X,Y) get_gdat_uint((X),(Y),35) +#define get_gdat_ullong_pos35(X,Y) get_gdat_ullong((X),(Y),35) +#define get_gdat_ip_pos35(X,Y) get_gdat_ip((X),(Y),35) +#define get_gdat_ipv6_pos35(X,Y) get_gdat_ipv6((X),(Y),35) +#define get_gdat_string_pos35(X,Y) get_gdat_string((X),(Y),35) +#define get_gdat_v_str_pos35(X,Y) get_gdat_string((X),(Y),35) +#define get_gdat_bool_pos35(X,Y) get_gdat_bool((X),(Y),35) +#define get_gdat_int_pos35(X,Y) get_gdat_int((X),(Y),35) +#define get_gdat_llong_pos35(X,Y) get_gdat_llong((X),(Y),35) +#define get_gdat_float_pos35(X,Y) get_gdat_float((X),(Y),35) +#define get_gdat_uint_pos36(X,Y) get_gdat_uint((X),(Y),36) +#define get_gdat_ullong_pos36(X,Y) get_gdat_ullong((X),(Y),36) +#define get_gdat_ip_pos36(X,Y) get_gdat_ip((X),(Y),36) +#define get_gdat_ipv6_pos36(X,Y) get_gdat_ipv6((X),(Y),36) +#define get_gdat_string_pos36(X,Y) get_gdat_string((X),(Y),36) +#define get_gdat_v_str_pos36(X,Y) get_gdat_string((X),(Y),36) +#define get_gdat_bool_pos36(X,Y) get_gdat_bool((X),(Y),36) +#define get_gdat_int_pos36(X,Y) get_gdat_int((X),(Y),36) +#define get_gdat_llong_pos36(X,Y) get_gdat_llong((X),(Y),36) +#define get_gdat_float_pos36(X,Y) get_gdat_float((X),(Y),36) +#define get_gdat_uint_pos37(X,Y) get_gdat_uint((X),(Y),37) +#define get_gdat_ullong_pos37(X,Y) get_gdat_ullong((X),(Y),37) +#define get_gdat_ip_pos37(X,Y) get_gdat_ip((X),(Y),37) +#define get_gdat_ipv6_pos37(X,Y) get_gdat_ipv6((X),(Y),37) +#define get_gdat_string_pos37(X,Y) get_gdat_string((X),(Y),37) +#define get_gdat_v_str_pos37(X,Y) get_gdat_string((X),(Y),37) +#define get_gdat_bool_pos37(X,Y) get_gdat_bool((X),(Y),37) +#define get_gdat_int_pos37(X,Y) get_gdat_int((X),(Y),37) +#define get_gdat_llong_pos37(X,Y) get_gdat_llong((X),(Y),37) +#define get_gdat_float_pos37(X,Y) get_gdat_float((X),(Y),37) +#define get_gdat_uint_pos38(X,Y) get_gdat_uint((X),(Y),38) +#define get_gdat_ullong_pos38(X,Y) get_gdat_ullong((X),(Y),38) +#define get_gdat_ip_pos38(X,Y) get_gdat_ip((X),(Y),38) +#define get_gdat_ipv6_pos38(X,Y) get_gdat_ipv6((X),(Y),38) +#define get_gdat_string_pos38(X,Y) get_gdat_string((X),(Y),38) +#define get_gdat_v_str_pos38(X,Y) get_gdat_string((X),(Y),38) +#define get_gdat_bool_pos38(X,Y) get_gdat_bool((X),(Y),38) +#define get_gdat_int_pos38(X,Y) get_gdat_int((X),(Y),38) +#define get_gdat_llong_pos38(X,Y) get_gdat_llong((X),(Y),38) +#define get_gdat_float_pos38(X,Y) get_gdat_float((X),(Y),38) +#define get_gdat_uint_pos39(X,Y) get_gdat_uint((X),(Y),39) +#define get_gdat_ullong_pos39(X,Y) get_gdat_ullong((X),(Y),39) +#define get_gdat_ip_pos39(X,Y) get_gdat_ip((X),(Y),39) +#define get_gdat_ipv6_pos39(X,Y) get_gdat_ipv6((X),(Y),39) +#define get_gdat_string_pos39(X,Y) get_gdat_string((X),(Y),39) +#define get_gdat_v_str_pos39(X,Y) get_gdat_string((X),(Y),39) +#define get_gdat_bool_pos39(X,Y) get_gdat_bool((X),(Y),39) +#define get_gdat_int_pos39(X,Y) get_gdat_int((X),(Y),39) +#define get_gdat_llong_pos39(X,Y) get_gdat_llong((X),(Y),39) +#define get_gdat_float_pos39(X,Y) get_gdat_float((X),(Y),39) +#define get_gdat_uint_pos40(X,Y) get_gdat_uint((X),(Y),40) +#define get_gdat_ullong_pos40(X,Y) get_gdat_ullong((X),(Y),40) +#define get_gdat_ip_pos40(X,Y) get_gdat_ip((X),(Y),40) +#define get_gdat_ipv6_pos40(X,Y) get_gdat_ipv6((X),(Y),40) +#define get_gdat_string_pos40(X,Y) get_gdat_string((X),(Y),40) +#define get_gdat_v_str_pos40(X,Y) get_gdat_string((X),(Y),40) +#define get_gdat_bool_pos40(X,Y) get_gdat_bool((X),(Y),40) +#define get_gdat_int_pos40(X,Y) get_gdat_int((X),(Y),40) +#define get_gdat_llong_pos40(X,Y) get_gdat_llong((X),(Y),40) +#define get_gdat_float_pos40(X,Y) get_gdat_float((X),(Y),40) +#define get_gdat_uint_pos41(X,Y) get_gdat_uint((X),(Y),41) +#define get_gdat_ullong_pos41(X,Y) get_gdat_ullong((X),(Y),41) +#define get_gdat_ip_pos41(X,Y) get_gdat_ip((X),(Y),41) +#define get_gdat_ipv6_pos41(X,Y) get_gdat_ipv6((X),(Y),41) +#define get_gdat_string_pos41(X,Y) get_gdat_string((X),(Y),41) +#define get_gdat_v_str_pos41(X,Y) get_gdat_string((X),(Y),41) +#define get_gdat_bool_pos41(X,Y) get_gdat_bool((X),(Y),41) +#define get_gdat_int_pos41(X,Y) get_gdat_int((X),(Y),41) +#define get_gdat_llong_pos41(X,Y) get_gdat_llong((X),(Y),41) +#define get_gdat_float_pos41(X,Y) get_gdat_float((X),(Y),41) +#define get_gdat_uint_pos42(X,Y) get_gdat_uint((X),(Y),42) +#define get_gdat_ullong_pos42(X,Y) get_gdat_ullong((X),(Y),42) +#define get_gdat_ip_pos42(X,Y) get_gdat_ip((X),(Y),42) +#define get_gdat_ipv6_pos42(X,Y) get_gdat_ipv6((X),(Y),42) +#define get_gdat_string_pos42(X,Y) get_gdat_string((X),(Y),42) +#define get_gdat_v_str_pos42(X,Y) get_gdat_string((X),(Y),42) +#define get_gdat_bool_pos42(X,Y) get_gdat_bool((X),(Y),42) +#define get_gdat_int_pos42(X,Y) get_gdat_int((X),(Y),42) +#define get_gdat_llong_pos42(X,Y) get_gdat_llong((X),(Y),42) +#define get_gdat_float_pos42(X,Y) get_gdat_float((X),(Y),42) +#define get_gdat_uint_pos43(X,Y) get_gdat_uint((X),(Y),43) +#define get_gdat_ullong_pos43(X,Y) get_gdat_ullong((X),(Y),43) +#define get_gdat_ip_pos43(X,Y) get_gdat_ip((X),(Y),43) +#define get_gdat_ipv6_pos43(X,Y) get_gdat_ipv6((X),(Y),43) +#define get_gdat_string_pos43(X,Y) get_gdat_string((X),(Y),43) +#define get_gdat_v_str_pos43(X,Y) get_gdat_string((X),(Y),43) +#define get_gdat_bool_pos43(X,Y) get_gdat_bool((X),(Y),43) +#define get_gdat_int_pos43(X,Y) get_gdat_int((X),(Y),43) +#define get_gdat_llong_pos43(X,Y) get_gdat_llong((X),(Y),43) +#define get_gdat_float_pos43(X,Y) get_gdat_float((X),(Y),43) +#define get_gdat_uint_pos44(X,Y) get_gdat_uint((X),(Y),44) +#define get_gdat_ullong_pos44(X,Y) get_gdat_ullong((X),(Y),44) +#define get_gdat_ip_pos44(X,Y) get_gdat_ip((X),(Y),44) +#define get_gdat_ipv6_pos44(X,Y) get_gdat_ipv6((X),(Y),44) +#define get_gdat_string_pos44(X,Y) get_gdat_string((X),(Y),44) +#define get_gdat_v_str_pos44(X,Y) get_gdat_string((X),(Y),44) +#define get_gdat_bool_pos44(X,Y) get_gdat_bool((X),(Y),44) +#define get_gdat_int_pos44(X,Y) get_gdat_int((X),(Y),44) +#define get_gdat_llong_pos44(X,Y) get_gdat_llong((X),(Y),44) +#define get_gdat_float_pos44(X,Y) get_gdat_float((X),(Y),44) +#define get_gdat_uint_pos45(X,Y) get_gdat_uint((X),(Y),45) +#define get_gdat_ullong_pos45(X,Y) get_gdat_ullong((X),(Y),45) +#define get_gdat_ip_pos45(X,Y) get_gdat_ip((X),(Y),45) +#define get_gdat_ipv6_pos45(X,Y) get_gdat_ipv6((X),(Y),45) +#define get_gdat_string_pos45(X,Y) get_gdat_string((X),(Y),45) +#define get_gdat_v_str_pos45(X,Y) get_gdat_string((X),(Y),45) +#define get_gdat_bool_pos45(X,Y) get_gdat_bool((X),(Y),45) +#define get_gdat_int_pos45(X,Y) get_gdat_int((X),(Y),45) +#define get_gdat_llong_pos45(X,Y) get_gdat_llong((X),(Y),45) +#define get_gdat_float_pos45(X,Y) get_gdat_float((X),(Y),45) +#define get_gdat_uint_pos46(X,Y) get_gdat_uint((X),(Y),46) +#define get_gdat_ullong_pos46(X,Y) get_gdat_ullong((X),(Y),46) +#define get_gdat_ip_pos46(X,Y) get_gdat_ip((X),(Y),46) +#define get_gdat_ipv6_pos46(X,Y) get_gdat_ipv6((X),(Y),46) +#define get_gdat_string_pos46(X,Y) get_gdat_string((X),(Y),46) +#define get_gdat_v_str_pos46(X,Y) get_gdat_string((X),(Y),46) +#define get_gdat_bool_pos46(X,Y) get_gdat_bool((X),(Y),46) +#define get_gdat_int_pos46(X,Y) get_gdat_int((X),(Y),46) +#define get_gdat_llong_pos46(X,Y) get_gdat_llong((X),(Y),46) +#define get_gdat_float_pos46(X,Y) get_gdat_float((X),(Y),46) +#define get_gdat_uint_pos47(X,Y) get_gdat_uint((X),(Y),47) +#define get_gdat_ullong_pos47(X,Y) get_gdat_ullong((X),(Y),47) +#define get_gdat_ip_pos47(X,Y) get_gdat_ip((X),(Y),47) +#define get_gdat_ipv6_pos47(X,Y) get_gdat_ipv6((X),(Y),47) +#define get_gdat_string_pos47(X,Y) get_gdat_string((X),(Y),47) +#define get_gdat_v_str_pos47(X,Y) get_gdat_string((X),(Y),47) +#define get_gdat_bool_pos47(X,Y) get_gdat_bool((X),(Y),47) +#define get_gdat_int_pos47(X,Y) get_gdat_int((X),(Y),47) +#define get_gdat_llong_pos47(X,Y) get_gdat_llong((X),(Y),47) +#define get_gdat_float_pos47(X,Y) get_gdat_float((X),(Y),47) +#define get_gdat_uint_pos48(X,Y) get_gdat_uint((X),(Y),48) +#define get_gdat_ullong_pos48(X,Y) get_gdat_ullong((X),(Y),48) +#define get_gdat_ip_pos48(X,Y) get_gdat_ip((X),(Y),48) +#define get_gdat_ipv6_pos48(X,Y) get_gdat_ipv6((X),(Y),48) +#define get_gdat_string_pos48(X,Y) get_gdat_string((X),(Y),48) +#define get_gdat_v_str_pos48(X,Y) get_gdat_string((X),(Y),48) +#define get_gdat_bool_pos48(X,Y) get_gdat_bool((X),(Y),48) +#define get_gdat_int_pos48(X,Y) get_gdat_int((X),(Y),48) +#define get_gdat_llong_pos48(X,Y) get_gdat_llong((X),(Y),48) +#define get_gdat_float_pos48(X,Y) get_gdat_float((X),(Y),48) +#define get_gdat_uint_pos49(X,Y) get_gdat_uint((X),(Y),49) +#define get_gdat_ullong_pos49(X,Y) get_gdat_ullong((X),(Y),49) +#define get_gdat_ip_pos49(X,Y) get_gdat_ip((X),(Y),49) +#define get_gdat_ipv6_pos49(X,Y) get_gdat_ipv6((X),(Y),49) +#define get_gdat_string_pos49(X,Y) get_gdat_string((X),(Y),49) +#define get_gdat_v_str_pos49(X,Y) get_gdat_string((X),(Y),49) +#define get_gdat_bool_pos49(X,Y) get_gdat_bool((X),(Y),49) +#define get_gdat_int_pos49(X,Y) get_gdat_int((X),(Y),49) +#define get_gdat_llong_pos49(X,Y) get_gdat_llong((X),(Y),49) +#define get_gdat_float_pos49(X,Y) get_gdat_float((X),(Y),49) +#define get_gdat_uint_pos50(X,Y) get_gdat_uint((X),(Y),50) +#define get_gdat_ullong_pos50(X,Y) get_gdat_ullong((X),(Y),50) +#define get_gdat_ip_pos50(X,Y) get_gdat_ip((X),(Y),50) +#define get_gdat_ipv6_pos50(X,Y) get_gdat_ipv6((X),(Y),50) +#define get_gdat_string_pos50(X,Y) get_gdat_string((X),(Y),50) +#define get_gdat_v_str_pos50(X,Y) get_gdat_string((X),(Y),50) +#define get_gdat_bool_pos50(X,Y) get_gdat_bool((X),(Y),50) +#define get_gdat_int_pos50(X,Y) get_gdat_int((X),(Y),50) +#define get_gdat_llong_pos50(X,Y) get_gdat_llong((X),(Y),50) +#define get_gdat_float_pos50(X,Y) get_gdat_float((X),(Y),50) +#define get_gdat_uint_pos51(X,Y) get_gdat_uint((X),(Y),51) +#define get_gdat_ullong_pos51(X,Y) get_gdat_ullong((X),(Y),51) +#define get_gdat_ip_pos51(X,Y) get_gdat_ip((X),(Y),51) +#define get_gdat_ipv6_pos51(X,Y) get_gdat_ipv6((X),(Y),51) +#define get_gdat_string_pos51(X,Y) get_gdat_string((X),(Y),51) +#define get_gdat_v_str_pos51(X,Y) get_gdat_string((X),(Y),51) +#define get_gdat_bool_pos51(X,Y) get_gdat_bool((X),(Y),51) +#define get_gdat_int_pos51(X,Y) get_gdat_int((X),(Y),51) +#define get_gdat_llong_pos51(X,Y) get_gdat_llong((X),(Y),51) +#define get_gdat_float_pos51(X,Y) get_gdat_float((X),(Y),51) +#define get_gdat_uint_pos52(X,Y) get_gdat_uint((X),(Y),52) +#define get_gdat_ullong_pos52(X,Y) get_gdat_ullong((X),(Y),52) +#define get_gdat_ip_pos52(X,Y) get_gdat_ip((X),(Y),52) +#define get_gdat_ipv6_pos52(X,Y) get_gdat_ipv6((X),(Y),52) +#define get_gdat_string_pos52(X,Y) get_gdat_string((X),(Y),52) +#define get_gdat_v_str_pos52(X,Y) get_gdat_string((X),(Y),52) +#define get_gdat_bool_pos52(X,Y) get_gdat_bool((X),(Y),52) +#define get_gdat_int_pos52(X,Y) get_gdat_int((X),(Y),52) +#define get_gdat_llong_pos52(X,Y) get_gdat_llong((X),(Y),52) +#define get_gdat_float_pos52(X,Y) get_gdat_float((X),(Y),52) +#define get_gdat_uint_pos53(X,Y) get_gdat_uint((X),(Y),53) +#define get_gdat_ullong_pos53(X,Y) get_gdat_ullong((X),(Y),53) +#define get_gdat_ip_pos53(X,Y) get_gdat_ip((X),(Y),53) +#define get_gdat_ipv6_pos53(X,Y) get_gdat_ipv6((X),(Y),53) +#define get_gdat_string_pos53(X,Y) get_gdat_string((X),(Y),53) +#define get_gdat_v_str_pos53(X,Y) get_gdat_string((X),(Y),53) +#define get_gdat_bool_pos53(X,Y) get_gdat_bool((X),(Y),53) +#define get_gdat_int_pos53(X,Y) get_gdat_int((X),(Y),53) +#define get_gdat_llong_pos53(X,Y) get_gdat_llong((X),(Y),53) +#define get_gdat_float_pos53(X,Y) get_gdat_float((X),(Y),53) +#define get_gdat_uint_pos54(X,Y) get_gdat_uint((X),(Y),54) +#define get_gdat_ullong_pos54(X,Y) get_gdat_ullong((X),(Y),54) +#define get_gdat_ip_pos54(X,Y) get_gdat_ip((X),(Y),54) +#define get_gdat_ipv6_pos54(X,Y) get_gdat_ipv6((X),(Y),54) +#define get_gdat_string_pos54(X,Y) get_gdat_string((X),(Y),54) +#define get_gdat_v_str_pos54(X,Y) get_gdat_string((X),(Y),54) +#define get_gdat_bool_pos54(X,Y) get_gdat_bool((X),(Y),54) +#define get_gdat_int_pos54(X,Y) get_gdat_int((X),(Y),54) +#define get_gdat_llong_pos54(X,Y) get_gdat_llong((X),(Y),54) +#define get_gdat_float_pos54(X,Y) get_gdat_float((X),(Y),54) +#define get_gdat_uint_pos55(X,Y) get_gdat_uint((X),(Y),55) +#define get_gdat_ullong_pos55(X,Y) get_gdat_ullong((X),(Y),55) +#define get_gdat_ip_pos55(X,Y) get_gdat_ip((X),(Y),55) +#define get_gdat_ipv6_pos55(X,Y) get_gdat_ipv6((X),(Y),55) +#define get_gdat_string_pos55(X,Y) get_gdat_string((X),(Y),55) +#define get_gdat_v_str_pos55(X,Y) get_gdat_string((X),(Y),55) +#define get_gdat_bool_pos55(X,Y) get_gdat_bool((X),(Y),55) +#define get_gdat_int_pos55(X,Y) get_gdat_int((X),(Y),55) +#define get_gdat_llong_pos55(X,Y) get_gdat_llong((X),(Y),55) +#define get_gdat_float_pos55(X,Y) get_gdat_float((X),(Y),55) +#define get_gdat_uint_pos56(X,Y) get_gdat_uint((X),(Y),56) +#define get_gdat_ullong_pos56(X,Y) get_gdat_ullong((X),(Y),56) +#define get_gdat_ip_pos56(X,Y) get_gdat_ip((X),(Y),56) +#define get_gdat_ipv6_pos56(X,Y) get_gdat_ipv6((X),(Y),56) +#define get_gdat_string_pos56(X,Y) get_gdat_string((X),(Y),56) +#define get_gdat_v_str_pos56(X,Y) get_gdat_string((X),(Y),56) +#define get_gdat_bool_pos56(X,Y) get_gdat_bool((X),(Y),56) +#define get_gdat_int_pos56(X,Y) get_gdat_int((X),(Y),56) +#define get_gdat_llong_pos56(X,Y) get_gdat_llong((X),(Y),56) +#define get_gdat_float_pos56(X,Y) get_gdat_float((X),(Y),56) +#define get_gdat_uint_pos57(X,Y) get_gdat_uint((X),(Y),57) +#define get_gdat_ullong_pos57(X,Y) get_gdat_ullong((X),(Y),57) +#define get_gdat_ip_pos57(X,Y) get_gdat_ip((X),(Y),57) +#define get_gdat_ipv6_pos57(X,Y) get_gdat_ipv6((X),(Y),57) +#define get_gdat_string_pos57(X,Y) get_gdat_string((X),(Y),57) +#define get_gdat_v_str_pos57(X,Y) get_gdat_string((X),(Y),57) +#define get_gdat_bool_pos57(X,Y) get_gdat_bool((X),(Y),57) +#define get_gdat_int_pos57(X,Y) get_gdat_int((X),(Y),57) +#define get_gdat_llong_pos57(X,Y) get_gdat_llong((X),(Y),57) +#define get_gdat_float_pos57(X,Y) get_gdat_float((X),(Y),57) +#define get_gdat_uint_pos58(X,Y) get_gdat_uint((X),(Y),58) +#define get_gdat_ullong_pos58(X,Y) get_gdat_ullong((X),(Y),58) +#define get_gdat_ip_pos58(X,Y) get_gdat_ip((X),(Y),58) +#define get_gdat_ipv6_pos58(X,Y) get_gdat_ipv6((X),(Y),58) +#define get_gdat_string_pos58(X,Y) get_gdat_string((X),(Y),58) +#define get_gdat_v_str_pos58(X,Y) get_gdat_string((X),(Y),58) +#define get_gdat_bool_pos58(X,Y) get_gdat_bool((X),(Y),58) +#define get_gdat_int_pos58(X,Y) get_gdat_int((X),(Y),58) +#define get_gdat_llong_pos58(X,Y) get_gdat_llong((X),(Y),58) +#define get_gdat_float_pos58(X,Y) get_gdat_float((X),(Y),58) +#define get_gdat_uint_pos59(X,Y) get_gdat_uint((X),(Y),59) +#define get_gdat_ullong_pos59(X,Y) get_gdat_ullong((X),(Y),59) +#define get_gdat_ip_pos59(X,Y) get_gdat_ip((X),(Y),59) +#define get_gdat_ipv6_pos59(X,Y) get_gdat_ipv6((X),(Y),59) +#define get_gdat_string_pos59(X,Y) get_gdat_string((X),(Y),59) +#define get_gdat_v_str_pos59(X,Y) get_gdat_string((X),(Y),59) +#define get_gdat_bool_pos59(X,Y) get_gdat_bool((X),(Y),59) +#define get_gdat_int_pos59(X,Y) get_gdat_int((X),(Y),59) +#define get_gdat_llong_pos59(X,Y) get_gdat_llong((X),(Y),59) +#define get_gdat_float_pos59(X,Y) get_gdat_float((X),(Y),59) +#define get_gdat_uint_pos60(X,Y) get_gdat_uint((X),(Y),60) +#define get_gdat_ullong_pos60(X,Y) get_gdat_ullong((X),(Y),60) +#define get_gdat_ip_pos60(X,Y) get_gdat_ip((X),(Y),60) +#define get_gdat_ipv6_pos60(X,Y) get_gdat_ipv6((X),(Y),60) +#define get_gdat_string_pos60(X,Y) get_gdat_string((X),(Y),60) +#define get_gdat_v_str_pos60(X,Y) get_gdat_string((X),(Y),60) +#define get_gdat_bool_pos60(X,Y) get_gdat_bool((X),(Y),60) +#define get_gdat_int_pos60(X,Y) get_gdat_int((X),(Y),60) +#define get_gdat_llong_pos60(X,Y) get_gdat_llong((X),(Y),60) +#define get_gdat_float_pos60(X,Y) get_gdat_float((X),(Y),60) +#define get_gdat_uint_pos61(X,Y) get_gdat_uint((X),(Y),61) +#define get_gdat_ullong_pos61(X,Y) get_gdat_ullong((X),(Y),61) +#define get_gdat_ip_pos61(X,Y) get_gdat_ip((X),(Y),61) +#define get_gdat_ipv6_pos61(X,Y) get_gdat_ipv6((X),(Y),61) +#define get_gdat_string_pos61(X,Y) get_gdat_string((X),(Y),61) +#define get_gdat_v_str_pos61(X,Y) get_gdat_string((X),(Y),61) +#define get_gdat_bool_pos61(X,Y) get_gdat_bool((X),(Y),61) +#define get_gdat_int_pos61(X,Y) get_gdat_int((X),(Y),61) +#define get_gdat_llong_pos61(X,Y) get_gdat_llong((X),(Y),61) +#define get_gdat_float_pos61(X,Y) get_gdat_float((X),(Y),61) +#define get_gdat_uint_pos62(X,Y) get_gdat_uint((X),(Y),62) +#define get_gdat_ullong_pos62(X,Y) get_gdat_ullong((X),(Y),62) +#define get_gdat_ip_pos62(X,Y) get_gdat_ip((X),(Y),62) +#define get_gdat_ipv6_pos62(X,Y) get_gdat_ipv6((X),(Y),62) +#define get_gdat_string_pos62(X,Y) get_gdat_string((X),(Y),62) +#define get_gdat_v_str_pos62(X,Y) get_gdat_string((X),(Y),62) +#define get_gdat_bool_pos62(X,Y) get_gdat_bool((X),(Y),62) +#define get_gdat_int_pos62(X,Y) get_gdat_int((X),(Y),62) +#define get_gdat_llong_pos62(X,Y) get_gdat_llong((X),(Y),62) +#define get_gdat_float_pos62(X,Y) get_gdat_float((X),(Y),62) +#define get_gdat_uint_pos63(X,Y) get_gdat_uint((X),(Y),63) +#define get_gdat_ullong_pos63(X,Y) get_gdat_ullong((X),(Y),63) +#define get_gdat_ip_pos63(X,Y) get_gdat_ip((X),(Y),63) +#define get_gdat_ipv6_pos63(X,Y) get_gdat_ipv6((X),(Y),63) +#define get_gdat_string_pos63(X,Y) get_gdat_string((X),(Y),63) +#define get_gdat_v_str_pos63(X,Y) get_gdat_string((X),(Y),63) +#define get_gdat_bool_pos63(X,Y) get_gdat_bool((X),(Y),63) +#define get_gdat_int_pos63(X,Y) get_gdat_int((X),(Y),63) +#define get_gdat_llong_pos63(X,Y) get_gdat_llong((X),(Y),63) +#define get_gdat_float_pos63(X,Y) get_gdat_float((X),(Y),63) +#define get_gdat_uint_pos64(X,Y) get_gdat_uint((X),(Y),64) +#define get_gdat_ullong_pos64(X,Y) get_gdat_ullong((X),(Y),64) +#define get_gdat_ip_pos64(X,Y) get_gdat_ip((X),(Y),64) +#define get_gdat_ipv6_pos64(X,Y) get_gdat_ipv6((X),(Y),64) +#define get_gdat_string_pos64(X,Y) get_gdat_string((X),(Y),64) +#define get_gdat_v_str_pos64(X,Y) get_gdat_string((X),(Y),64) +#define get_gdat_bool_pos64(X,Y) get_gdat_bool((X),(Y),64) +#define get_gdat_int_pos64(X,Y) get_gdat_int((X),(Y),64) +#define get_gdat_llong_pos64(X,Y) get_gdat_llong((X),(Y),64) +#define get_gdat_float_pos64(X,Y) get_gdat_float((X),(Y),64) +#define get_gdat_uint_pos65(X,Y) get_gdat_uint((X),(Y),65) +#define get_gdat_ullong_pos65(X,Y) get_gdat_ullong((X),(Y),65) +#define get_gdat_ip_pos65(X,Y) get_gdat_ip((X),(Y),65) +#define get_gdat_ipv6_pos65(X,Y) get_gdat_ipv6((X),(Y),65) +#define get_gdat_string_pos65(X,Y) get_gdat_string((X),(Y),65) +#define get_gdat_v_str_pos65(X,Y) get_gdat_string((X),(Y),65) +#define get_gdat_bool_pos65(X,Y) get_gdat_bool((X),(Y),65) +#define get_gdat_int_pos65(X,Y) get_gdat_int((X),(Y),65) +#define get_gdat_llong_pos65(X,Y) get_gdat_llong((X),(Y),65) +#define get_gdat_float_pos65(X,Y) get_gdat_float((X),(Y),65) +#define get_gdat_uint_pos66(X,Y) get_gdat_uint((X),(Y),66) +#define get_gdat_ullong_pos66(X,Y) get_gdat_ullong((X),(Y),66) +#define get_gdat_ip_pos66(X,Y) get_gdat_ip((X),(Y),66) +#define get_gdat_ipv6_pos66(X,Y) get_gdat_ipv6((X),(Y),66) +#define get_gdat_string_pos66(X,Y) get_gdat_string((X),(Y),66) +#define get_gdat_v_str_pos66(X,Y) get_gdat_string((X),(Y),66) +#define get_gdat_bool_pos66(X,Y) get_gdat_bool((X),(Y),66) +#define get_gdat_int_pos66(X,Y) get_gdat_int((X),(Y),66) +#define get_gdat_llong_pos66(X,Y) get_gdat_llong((X),(Y),66) +#define get_gdat_float_pos66(X,Y) get_gdat_float((X),(Y),66) +#define get_gdat_uint_pos67(X,Y) get_gdat_uint((X),(Y),67) +#define get_gdat_ullong_pos67(X,Y) get_gdat_ullong((X),(Y),67) +#define get_gdat_ip_pos67(X,Y) get_gdat_ip((X),(Y),67) +#define get_gdat_ipv6_pos67(X,Y) get_gdat_ipv6((X),(Y),67) +#define get_gdat_string_pos67(X,Y) get_gdat_string((X),(Y),67) +#define get_gdat_v_str_pos67(X,Y) get_gdat_string((X),(Y),67) +#define get_gdat_bool_pos67(X,Y) get_gdat_bool((X),(Y),67) +#define get_gdat_int_pos67(X,Y) get_gdat_int((X),(Y),67) +#define get_gdat_llong_pos67(X,Y) get_gdat_llong((X),(Y),67) +#define get_gdat_float_pos67(X,Y) get_gdat_float((X),(Y),67) +#define get_gdat_uint_pos68(X,Y) get_gdat_uint((X),(Y),68) +#define get_gdat_ullong_pos68(X,Y) get_gdat_ullong((X),(Y),68) +#define get_gdat_ip_pos68(X,Y) get_gdat_ip((X),(Y),68) +#define get_gdat_ipv6_pos68(X,Y) get_gdat_ipv6((X),(Y),68) +#define get_gdat_string_pos68(X,Y) get_gdat_string((X),(Y),68) +#define get_gdat_v_str_pos68(X,Y) get_gdat_string((X),(Y),68) +#define get_gdat_bool_pos68(X,Y) get_gdat_bool((X),(Y),68) +#define get_gdat_int_pos68(X,Y) get_gdat_int((X),(Y),68) +#define get_gdat_llong_pos68(X,Y) get_gdat_llong((X),(Y),68) +#define get_gdat_float_pos68(X,Y) get_gdat_float((X),(Y),68) +#define get_gdat_uint_pos69(X,Y) get_gdat_uint((X),(Y),69) +#define get_gdat_ullong_pos69(X,Y) get_gdat_ullong((X),(Y),69) +#define get_gdat_ip_pos69(X,Y) get_gdat_ip((X),(Y),69) +#define get_gdat_ipv6_pos69(X,Y) get_gdat_ipv6((X),(Y),69) +#define get_gdat_string_pos69(X,Y) get_gdat_string((X),(Y),69) +#define get_gdat_v_str_pos69(X,Y) get_gdat_string((X),(Y),69) +#define get_gdat_bool_pos69(X,Y) get_gdat_bool((X),(Y),69) +#define get_gdat_int_pos69(X,Y) get_gdat_int((X),(Y),69) +#define get_gdat_llong_pos69(X,Y) get_gdat_llong((X),(Y),69) +#define get_gdat_float_pos69(X,Y) get_gdat_float((X),(Y),69) +#define get_gdat_uint_pos70(X,Y) get_gdat_uint((X),(Y),70) +#define get_gdat_ullong_pos70(X,Y) get_gdat_ullong((X),(Y),70) +#define get_gdat_ip_pos70(X,Y) get_gdat_ip((X),(Y),70) +#define get_gdat_ipv6_pos70(X,Y) get_gdat_ipv6((X),(Y),70) +#define get_gdat_string_pos70(X,Y) get_gdat_string((X),(Y),70) +#define get_gdat_v_str_pos70(X,Y) get_gdat_string((X),(Y),70) +#define get_gdat_bool_pos70(X,Y) get_gdat_bool((X),(Y),70) +#define get_gdat_int_pos70(X,Y) get_gdat_int((X),(Y),70) +#define get_gdat_llong_pos70(X,Y) get_gdat_llong((X),(Y),70) +#define get_gdat_float_pos70(X,Y) get_gdat_float((X),(Y),70) +#define get_gdat_uint_pos71(X,Y) get_gdat_uint((X),(Y),71) +#define get_gdat_ullong_pos71(X,Y) get_gdat_ullong((X),(Y),71) +#define get_gdat_ip_pos71(X,Y) get_gdat_ip((X),(Y),71) +#define get_gdat_ipv6_pos71(X,Y) get_gdat_ipv6((X),(Y),71) +#define get_gdat_string_pos71(X,Y) get_gdat_string((X),(Y),71) +#define get_gdat_v_str_pos71(X,Y) get_gdat_string((X),(Y),71) +#define get_gdat_bool_pos71(X,Y) get_gdat_bool((X),(Y),71) +#define get_gdat_int_pos71(X,Y) get_gdat_int((X),(Y),71) +#define get_gdat_llong_pos71(X,Y) get_gdat_llong((X),(Y),71) +#define get_gdat_float_pos71(X,Y) get_gdat_float((X),(Y),71) +#define get_gdat_uint_pos72(X,Y) get_gdat_uint((X),(Y),72) +#define get_gdat_ullong_pos72(X,Y) get_gdat_ullong((X),(Y),72) +#define get_gdat_ip_pos72(X,Y) get_gdat_ip((X),(Y),72) +#define get_gdat_ipv6_pos72(X,Y) get_gdat_ipv6((X),(Y),72) +#define get_gdat_string_pos72(X,Y) get_gdat_string((X),(Y),72) +#define get_gdat_v_str_pos72(X,Y) get_gdat_string((X),(Y),72) +#define get_gdat_bool_pos72(X,Y) get_gdat_bool((X),(Y),72) +#define get_gdat_int_pos72(X,Y) get_gdat_int((X),(Y),72) +#define get_gdat_llong_pos72(X,Y) get_gdat_llong((X),(Y),72) +#define get_gdat_float_pos72(X,Y) get_gdat_float((X),(Y),72) +#define get_gdat_uint_pos73(X,Y) get_gdat_uint((X),(Y),73) +#define get_gdat_ullong_pos73(X,Y) get_gdat_ullong((X),(Y),73) +#define get_gdat_ip_pos73(X,Y) get_gdat_ip((X),(Y),73) +#define get_gdat_ipv6_pos73(X,Y) get_gdat_ipv6((X),(Y),73) +#define get_gdat_string_pos73(X,Y) get_gdat_string((X),(Y),73) +#define get_gdat_v_str_pos73(X,Y) get_gdat_string((X),(Y),73) +#define get_gdat_bool_pos73(X,Y) get_gdat_bool((X),(Y),73) +#define get_gdat_int_pos73(X,Y) get_gdat_int((X),(Y),73) +#define get_gdat_llong_pos73(X,Y) get_gdat_llong((X),(Y),73) +#define get_gdat_float_pos73(X,Y) get_gdat_float((X),(Y),73) +#define get_gdat_uint_pos74(X,Y) get_gdat_uint((X),(Y),74) +#define get_gdat_ullong_pos74(X,Y) get_gdat_ullong((X),(Y),74) +#define get_gdat_ip_pos74(X,Y) get_gdat_ip((X),(Y),74) +#define get_gdat_ipv6_pos74(X,Y) get_gdat_ipv6((X),(Y),74) +#define get_gdat_string_pos74(X,Y) get_gdat_string((X),(Y),74) +#define get_gdat_v_str_pos74(X,Y) get_gdat_string((X),(Y),74) +#define get_gdat_bool_pos74(X,Y) get_gdat_bool((X),(Y),74) +#define get_gdat_int_pos74(X,Y) get_gdat_int((X),(Y),74) +#define get_gdat_llong_pos74(X,Y) get_gdat_llong((X),(Y),74) +#define get_gdat_float_pos74(X,Y) get_gdat_float((X),(Y),74) +#define get_gdat_uint_pos75(X,Y) get_gdat_uint((X),(Y),75) +#define get_gdat_ullong_pos75(X,Y) get_gdat_ullong((X),(Y),75) +#define get_gdat_ip_pos75(X,Y) get_gdat_ip((X),(Y),75) +#define get_gdat_ipv6_pos75(X,Y) get_gdat_ipv6((X),(Y),75) +#define get_gdat_string_pos75(X,Y) get_gdat_string((X),(Y),75) +#define get_gdat_v_str_pos75(X,Y) get_gdat_string((X),(Y),75) +#define get_gdat_bool_pos75(X,Y) get_gdat_bool((X),(Y),75) +#define get_gdat_int_pos75(X,Y) get_gdat_int((X),(Y),75) +#define get_gdat_llong_pos75(X,Y) get_gdat_llong((X),(Y),75) +#define get_gdat_float_pos75(X,Y) get_gdat_float((X),(Y),75) +#define get_gdat_uint_pos76(X,Y) get_gdat_uint((X),(Y),76) +#define get_gdat_ullong_pos76(X,Y) get_gdat_ullong((X),(Y),76) +#define get_gdat_ip_pos76(X,Y) get_gdat_ip((X),(Y),76) +#define get_gdat_ipv6_pos76(X,Y) get_gdat_ipv6((X),(Y),76) +#define get_gdat_string_pos76(X,Y) get_gdat_string((X),(Y),76) +#define get_gdat_v_str_pos76(X,Y) get_gdat_string((X),(Y),76) +#define get_gdat_bool_pos76(X,Y) get_gdat_bool((X),(Y),76) +#define get_gdat_int_pos76(X,Y) get_gdat_int((X),(Y),76) +#define get_gdat_llong_pos76(X,Y) get_gdat_llong((X),(Y),76) +#define get_gdat_float_pos76(X,Y) get_gdat_float((X),(Y),76) +#define get_gdat_uint_pos77(X,Y) get_gdat_uint((X),(Y),77) +#define get_gdat_ullong_pos77(X,Y) get_gdat_ullong((X),(Y),77) +#define get_gdat_ip_pos77(X,Y) get_gdat_ip((X),(Y),77) +#define get_gdat_ipv6_pos77(X,Y) get_gdat_ipv6((X),(Y),77) +#define get_gdat_string_pos77(X,Y) get_gdat_string((X),(Y),77) +#define get_gdat_v_str_pos77(X,Y) get_gdat_string((X),(Y),77) +#define get_gdat_bool_pos77(X,Y) get_gdat_bool((X),(Y),77) +#define get_gdat_int_pos77(X,Y) get_gdat_int((X),(Y),77) +#define get_gdat_llong_pos77(X,Y) get_gdat_llong((X),(Y),77) +#define get_gdat_float_pos77(X,Y) get_gdat_float((X),(Y),77) +#define get_gdat_uint_pos78(X,Y) get_gdat_uint((X),(Y),78) +#define get_gdat_ullong_pos78(X,Y) get_gdat_ullong((X),(Y),78) +#define get_gdat_ip_pos78(X,Y) get_gdat_ip((X),(Y),78) +#define get_gdat_ipv6_pos78(X,Y) get_gdat_ipv6((X),(Y),78) +#define get_gdat_string_pos78(X,Y) get_gdat_string((X),(Y),78) +#define get_gdat_v_str_pos78(X,Y) get_gdat_string((X),(Y),78) +#define get_gdat_bool_pos78(X,Y) get_gdat_bool((X),(Y),78) +#define get_gdat_int_pos78(X,Y) get_gdat_int((X),(Y),78) +#define get_gdat_llong_pos78(X,Y) get_gdat_llong((X),(Y),78) +#define get_gdat_float_pos78(X,Y) get_gdat_float((X),(Y),78) +#define get_gdat_uint_pos79(X,Y) get_gdat_uint((X),(Y),79) +#define get_gdat_ullong_pos79(X,Y) get_gdat_ullong((X),(Y),79) +#define get_gdat_ip_pos79(X,Y) get_gdat_ip((X),(Y),79) +#define get_gdat_ipv6_pos79(X,Y) get_gdat_ipv6((X),(Y),79) +#define get_gdat_string_pos79(X,Y) get_gdat_string((X),(Y),79) +#define get_gdat_v_str_pos79(X,Y) get_gdat_string((X),(Y),79) +#define get_gdat_bool_pos79(X,Y) get_gdat_bool((X),(Y),79) +#define get_gdat_int_pos79(X,Y) get_gdat_int((X),(Y),79) +#define get_gdat_llong_pos79(X,Y) get_gdat_llong((X),(Y),79) +#define get_gdat_float_pos79(X,Y) get_gdat_float((X),(Y),79) +#define get_gdat_uint_pos80(X,Y) get_gdat_uint((X),(Y),80) +#define get_gdat_ullong_pos80(X,Y) get_gdat_ullong((X),(Y),80) +#define get_gdat_ip_pos80(X,Y) get_gdat_ip((X),(Y),80) +#define get_gdat_ipv6_pos80(X,Y) get_gdat_ipv6((X),(Y),80) +#define get_gdat_string_pos80(X,Y) get_gdat_string((X),(Y),80) +#define get_gdat_v_str_pos80(X,Y) get_gdat_string((X),(Y),80) +#define get_gdat_bool_pos80(X,Y) get_gdat_bool((X),(Y),80) +#define get_gdat_int_pos80(X,Y) get_gdat_int((X),(Y),80) +#define get_gdat_llong_pos80(X,Y) get_gdat_llong((X),(Y),80) +#define get_gdat_float_pos80(X,Y) get_gdat_float((X),(Y),80) +#define get_gdat_uint_pos81(X,Y) get_gdat_uint((X),(Y),81) +#define get_gdat_ullong_pos81(X,Y) get_gdat_ullong((X),(Y),81) +#define get_gdat_ip_pos81(X,Y) get_gdat_ip((X),(Y),81) +#define get_gdat_ipv6_pos81(X,Y) get_gdat_ipv6((X),(Y),81) +#define get_gdat_string_pos81(X,Y) get_gdat_string((X),(Y),81) +#define get_gdat_v_str_pos81(X,Y) get_gdat_string((X),(Y),81) +#define get_gdat_bool_pos81(X,Y) get_gdat_bool((X),(Y),81) +#define get_gdat_int_pos81(X,Y) get_gdat_int((X),(Y),81) +#define get_gdat_llong_pos81(X,Y) get_gdat_llong((X),(Y),81) +#define get_gdat_float_pos81(X,Y) get_gdat_float((X),(Y),81) +#define get_gdat_uint_pos82(X,Y) get_gdat_uint((X),(Y),82) +#define get_gdat_ullong_pos82(X,Y) get_gdat_ullong((X),(Y),82) +#define get_gdat_ip_pos82(X,Y) get_gdat_ip((X),(Y),82) +#define get_gdat_ipv6_pos82(X,Y) get_gdat_ipv6((X),(Y),82) +#define get_gdat_string_pos82(X,Y) get_gdat_string((X),(Y),82) +#define get_gdat_v_str_pos82(X,Y) get_gdat_string((X),(Y),82) +#define get_gdat_bool_pos82(X,Y) get_gdat_bool((X),(Y),82) +#define get_gdat_int_pos82(X,Y) get_gdat_int((X),(Y),82) +#define get_gdat_llong_pos82(X,Y) get_gdat_llong((X),(Y),82) +#define get_gdat_float_pos82(X,Y) get_gdat_float((X),(Y),82) +#define get_gdat_uint_pos83(X,Y) get_gdat_uint((X),(Y),83) +#define get_gdat_ullong_pos83(X,Y) get_gdat_ullong((X),(Y),83) +#define get_gdat_ip_pos83(X,Y) get_gdat_ip((X),(Y),83) +#define get_gdat_ipv6_pos83(X,Y) get_gdat_ipv6((X),(Y),83) +#define get_gdat_string_pos83(X,Y) get_gdat_string((X),(Y),83) +#define get_gdat_v_str_pos83(X,Y) get_gdat_string((X),(Y),83) +#define get_gdat_bool_pos83(X,Y) get_gdat_bool((X),(Y),83) +#define get_gdat_int_pos83(X,Y) get_gdat_int((X),(Y),83) +#define get_gdat_llong_pos83(X,Y) get_gdat_llong((X),(Y),83) +#define get_gdat_float_pos83(X,Y) get_gdat_float((X),(Y),83) +#define get_gdat_uint_pos84(X,Y) get_gdat_uint((X),(Y),84) +#define get_gdat_ullong_pos84(X,Y) get_gdat_ullong((X),(Y),84) +#define get_gdat_ip_pos84(X,Y) get_gdat_ip((X),(Y),84) +#define get_gdat_ipv6_pos84(X,Y) get_gdat_ipv6((X),(Y),84) +#define get_gdat_string_pos84(X,Y) get_gdat_string((X),(Y),84) +#define get_gdat_v_str_pos84(X,Y) get_gdat_string((X),(Y),84) +#define get_gdat_bool_pos84(X,Y) get_gdat_bool((X),(Y),84) +#define get_gdat_int_pos84(X,Y) get_gdat_int((X),(Y),84) +#define get_gdat_llong_pos84(X,Y) get_gdat_llong((X),(Y),84) +#define get_gdat_float_pos84(X,Y) get_gdat_float((X),(Y),84) +#define get_gdat_uint_pos85(X,Y) get_gdat_uint((X),(Y),85) +#define get_gdat_ullong_pos85(X,Y) get_gdat_ullong((X),(Y),85) +#define get_gdat_ip_pos85(X,Y) get_gdat_ip((X),(Y),85) +#define get_gdat_ipv6_pos85(X,Y) get_gdat_ipv6((X),(Y),85) +#define get_gdat_string_pos85(X,Y) get_gdat_string((X),(Y),85) +#define get_gdat_v_str_pos85(X,Y) get_gdat_string((X),(Y),85) +#define get_gdat_bool_pos85(X,Y) get_gdat_bool((X),(Y),85) +#define get_gdat_int_pos85(X,Y) get_gdat_int((X),(Y),85) +#define get_gdat_llong_pos85(X,Y) get_gdat_llong((X),(Y),85) +#define get_gdat_float_pos85(X,Y) get_gdat_float((X),(Y),85) +#define get_gdat_uint_pos86(X,Y) get_gdat_uint((X),(Y),86) +#define get_gdat_ullong_pos86(X,Y) get_gdat_ullong((X),(Y),86) +#define get_gdat_ip_pos86(X,Y) get_gdat_ip((X),(Y),86) +#define get_gdat_ipv6_pos86(X,Y) get_gdat_ipv6((X),(Y),86) +#define get_gdat_string_pos86(X,Y) get_gdat_string((X),(Y),86) +#define get_gdat_v_str_pos86(X,Y) get_gdat_string((X),(Y),86) +#define get_gdat_bool_pos86(X,Y) get_gdat_bool((X),(Y),86) +#define get_gdat_int_pos86(X,Y) get_gdat_int((X),(Y),86) +#define get_gdat_llong_pos86(X,Y) get_gdat_llong((X),(Y),86) +#define get_gdat_float_pos86(X,Y) get_gdat_float((X),(Y),86) +#define get_gdat_uint_pos87(X,Y) get_gdat_uint((X),(Y),87) +#define get_gdat_ullong_pos87(X,Y) get_gdat_ullong((X),(Y),87) +#define get_gdat_ip_pos87(X,Y) get_gdat_ip((X),(Y),87) +#define get_gdat_ipv6_pos87(X,Y) get_gdat_ipv6((X),(Y),87) +#define get_gdat_string_pos87(X,Y) get_gdat_string((X),(Y),87) +#define get_gdat_v_str_pos87(X,Y) get_gdat_string((X),(Y),87) +#define get_gdat_bool_pos87(X,Y) get_gdat_bool((X),(Y),87) +#define get_gdat_int_pos87(X,Y) get_gdat_int((X),(Y),87) +#define get_gdat_llong_pos87(X,Y) get_gdat_llong((X),(Y),87) +#define get_gdat_float_pos87(X,Y) get_gdat_float((X),(Y),87) +#define get_gdat_uint_pos88(X,Y) get_gdat_uint((X),(Y),88) +#define get_gdat_ullong_pos88(X,Y) get_gdat_ullong((X),(Y),88) +#define get_gdat_ip_pos88(X,Y) get_gdat_ip((X),(Y),88) +#define get_gdat_ipv6_pos88(X,Y) get_gdat_ipv6((X),(Y),88) +#define get_gdat_string_pos88(X,Y) get_gdat_string((X),(Y),88) +#define get_gdat_v_str_pos88(X,Y) get_gdat_string((X),(Y),88) +#define get_gdat_bool_pos88(X,Y) get_gdat_bool((X),(Y),88) +#define get_gdat_int_pos88(X,Y) get_gdat_int((X),(Y),88) +#define get_gdat_llong_pos88(X,Y) get_gdat_llong((X),(Y),88) +#define get_gdat_float_pos88(X,Y) get_gdat_float((X),(Y),88) +#define get_gdat_uint_pos89(X,Y) get_gdat_uint((X),(Y),89) +#define get_gdat_ullong_pos89(X,Y) get_gdat_ullong((X),(Y),89) +#define get_gdat_ip_pos89(X,Y) get_gdat_ip((X),(Y),89) +#define get_gdat_ipv6_pos89(X,Y) get_gdat_ipv6((X),(Y),89) +#define get_gdat_string_pos89(X,Y) get_gdat_string((X),(Y),89) +#define get_gdat_v_str_pos89(X,Y) get_gdat_string((X),(Y),89) +#define get_gdat_bool_pos89(X,Y) get_gdat_bool((X),(Y),89) +#define get_gdat_int_pos89(X,Y) get_gdat_int((X),(Y),89) +#define get_gdat_llong_pos89(X,Y) get_gdat_llong((X),(Y),89) +#define get_gdat_float_pos89(X,Y) get_gdat_float((X),(Y),89) +#define get_gdat_uint_pos90(X,Y) get_gdat_uint((X),(Y),90) +#define get_gdat_ullong_pos90(X,Y) get_gdat_ullong((X),(Y),90) +#define get_gdat_ip_pos90(X,Y) get_gdat_ip((X),(Y),90) +#define get_gdat_ipv6_pos90(X,Y) get_gdat_ipv6((X),(Y),90) +#define get_gdat_string_pos90(X,Y) get_gdat_string((X),(Y),90) +#define get_gdat_v_str_pos90(X,Y) get_gdat_string((X),(Y),90) +#define get_gdat_bool_pos90(X,Y) get_gdat_bool((X),(Y),90) +#define get_gdat_int_pos90(X,Y) get_gdat_int((X),(Y),90) +#define get_gdat_llong_pos90(X,Y) get_gdat_llong((X),(Y),90) +#define get_gdat_float_pos90(X,Y) get_gdat_float((X),(Y),90) +#define get_gdat_uint_pos91(X,Y) get_gdat_uint((X),(Y),91) +#define get_gdat_ullong_pos91(X,Y) get_gdat_ullong((X),(Y),91) +#define get_gdat_ip_pos91(X,Y) get_gdat_ip((X),(Y),91) +#define get_gdat_ipv6_pos91(X,Y) get_gdat_ipv6((X),(Y),91) +#define get_gdat_string_pos91(X,Y) get_gdat_string((X),(Y),91) +#define get_gdat_v_str_pos91(X,Y) get_gdat_string((X),(Y),91) +#define get_gdat_bool_pos91(X,Y) get_gdat_bool((X),(Y),91) +#define get_gdat_int_pos91(X,Y) get_gdat_int((X),(Y),91) +#define get_gdat_llong_pos91(X,Y) get_gdat_llong((X),(Y),91) +#define get_gdat_float_pos91(X,Y) get_gdat_float((X),(Y),91) +#define get_gdat_uint_pos92(X,Y) get_gdat_uint((X),(Y),92) +#define get_gdat_ullong_pos92(X,Y) get_gdat_ullong((X),(Y),92) +#define get_gdat_ip_pos92(X,Y) get_gdat_ip((X),(Y),92) +#define get_gdat_ipv6_pos92(X,Y) get_gdat_ipv6((X),(Y),92) +#define get_gdat_string_pos92(X,Y) get_gdat_string((X),(Y),92) +#define get_gdat_v_str_pos92(X,Y) get_gdat_string((X),(Y),92) +#define get_gdat_bool_pos92(X,Y) get_gdat_bool((X),(Y),92) +#define get_gdat_int_pos92(X,Y) get_gdat_int((X),(Y),92) +#define get_gdat_llong_pos92(X,Y) get_gdat_llong((X),(Y),92) +#define get_gdat_float_pos92(X,Y) get_gdat_float((X),(Y),92) +#define get_gdat_uint_pos93(X,Y) get_gdat_uint((X),(Y),93) +#define get_gdat_ullong_pos93(X,Y) get_gdat_ullong((X),(Y),93) +#define get_gdat_ip_pos93(X,Y) get_gdat_ip((X),(Y),93) +#define get_gdat_ipv6_pos93(X,Y) get_gdat_ipv6((X),(Y),93) +#define get_gdat_string_pos93(X,Y) get_gdat_string((X),(Y),93) +#define get_gdat_v_str_pos93(X,Y) get_gdat_string((X),(Y),93) +#define get_gdat_bool_pos93(X,Y) get_gdat_bool((X),(Y),93) +#define get_gdat_int_pos93(X,Y) get_gdat_int((X),(Y),93) +#define get_gdat_llong_pos93(X,Y) get_gdat_llong((X),(Y),93) +#define get_gdat_float_pos93(X,Y) get_gdat_float((X),(Y),93) +#define get_gdat_uint_pos94(X,Y) get_gdat_uint((X),(Y),94) +#define get_gdat_ullong_pos94(X,Y) get_gdat_ullong((X),(Y),94) +#define get_gdat_ip_pos94(X,Y) get_gdat_ip((X),(Y),94) +#define get_gdat_ipv6_pos94(X,Y) get_gdat_ipv6((X),(Y),94) +#define get_gdat_string_pos94(X,Y) get_gdat_string((X),(Y),94) +#define get_gdat_v_str_pos94(X,Y) get_gdat_string((X),(Y),94) +#define get_gdat_bool_pos94(X,Y) get_gdat_bool((X),(Y),94) +#define get_gdat_int_pos94(X,Y) get_gdat_int((X),(Y),94) +#define get_gdat_llong_pos94(X,Y) get_gdat_llong((X),(Y),94) +#define get_gdat_float_pos94(X,Y) get_gdat_float((X),(Y),94) +#define get_gdat_uint_pos95(X,Y) get_gdat_uint((X),(Y),95) +#define get_gdat_ullong_pos95(X,Y) get_gdat_ullong((X),(Y),95) +#define get_gdat_ip_pos95(X,Y) get_gdat_ip((X),(Y),95) +#define get_gdat_ipv6_pos95(X,Y) get_gdat_ipv6((X),(Y),95) +#define get_gdat_string_pos95(X,Y) get_gdat_string((X),(Y),95) +#define get_gdat_v_str_pos95(X,Y) get_gdat_string((X),(Y),95) +#define get_gdat_bool_pos95(X,Y) get_gdat_bool((X),(Y),95) +#define get_gdat_int_pos95(X,Y) get_gdat_int((X),(Y),95) +#define get_gdat_llong_pos95(X,Y) get_gdat_llong((X),(Y),95) +#define get_gdat_float_pos95(X,Y) get_gdat_float((X),(Y),95) +#define get_gdat_uint_pos96(X,Y) get_gdat_uint((X),(Y),96) +#define get_gdat_ullong_pos96(X,Y) get_gdat_ullong((X),(Y),96) +#define get_gdat_ip_pos96(X,Y) get_gdat_ip((X),(Y),96) +#define get_gdat_ipv6_pos96(X,Y) get_gdat_ipv6((X),(Y),96) +#define get_gdat_string_pos96(X,Y) get_gdat_string((X),(Y),96) +#define get_gdat_v_str_pos96(X,Y) get_gdat_string((X),(Y),96) +#define get_gdat_bool_pos96(X,Y) get_gdat_bool((X),(Y),96) +#define get_gdat_int_pos96(X,Y) get_gdat_int((X),(Y),96) +#define get_gdat_llong_pos96(X,Y) get_gdat_llong((X),(Y),96) +#define get_gdat_float_pos96(X,Y) get_gdat_float((X),(Y),96) +#define get_gdat_uint_pos97(X,Y) get_gdat_uint((X),(Y),97) +#define get_gdat_ullong_pos97(X,Y) get_gdat_ullong((X),(Y),97) +#define get_gdat_ip_pos97(X,Y) get_gdat_ip((X),(Y),97) +#define get_gdat_ipv6_pos97(X,Y) get_gdat_ipv6((X),(Y),97) +#define get_gdat_string_pos97(X,Y) get_gdat_string((X),(Y),97) +#define get_gdat_v_str_pos97(X,Y) get_gdat_string((X),(Y),97) +#define get_gdat_bool_pos97(X,Y) get_gdat_bool((X),(Y),97) +#define get_gdat_int_pos97(X,Y) get_gdat_int((X),(Y),97) +#define get_gdat_llong_pos97(X,Y) get_gdat_llong((X),(Y),97) +#define get_gdat_float_pos97(X,Y) get_gdat_float((X),(Y),97) +#define get_gdat_uint_pos98(X,Y) get_gdat_uint((X),(Y),98) +#define get_gdat_ullong_pos98(X,Y) get_gdat_ullong((X),(Y),98) +#define get_gdat_ip_pos98(X,Y) get_gdat_ip((X),(Y),98) +#define get_gdat_ipv6_pos98(X,Y) get_gdat_ipv6((X),(Y),98) +#define get_gdat_string_pos98(X,Y) get_gdat_string((X),(Y),98) +#define get_gdat_v_str_pos98(X,Y) get_gdat_string((X),(Y),98) +#define get_gdat_bool_pos98(X,Y) get_gdat_bool((X),(Y),98) +#define get_gdat_int_pos98(X,Y) get_gdat_int((X),(Y),98) +#define get_gdat_llong_pos98(X,Y) get_gdat_llong((X),(Y),98) +#define get_gdat_float_pos98(X,Y) get_gdat_float((X),(Y),98) +#define get_gdat_uint_pos99(X,Y) get_gdat_uint((X),(Y),99) +#define get_gdat_ullong_pos99(X,Y) get_gdat_ullong((X),(Y),99) +#define get_gdat_ip_pos99(X,Y) get_gdat_ip((X),(Y),99) +#define get_gdat_ipv6_pos99(X,Y) get_gdat_ipv6((X),(Y),99) +#define get_gdat_string_pos99(X,Y) get_gdat_string((X),(Y),99) +#define get_gdat_v_str_pos99(X,Y) get_gdat_string((X),(Y),99) +#define get_gdat_bool_pos99(X,Y) get_gdat_bool((X),(Y),99) +#define get_gdat_int_pos99(X,Y) get_gdat_int((X),(Y),99) +#define get_gdat_llong_pos99(X,Y) get_gdat_llong((X),(Y),99) +#define get_gdat_float_pos99(X,Y) get_gdat_float((X),(Y),99) +#define get_gdat_uint_pos100(X,Y) get_gdat_uint((X),(Y),100) +#define get_gdat_ullong_pos100(X,Y) get_gdat_ullong((X),(Y),100) +#define get_gdat_ip_pos100(X,Y) get_gdat_ip((X),(Y),100) +#define get_gdat_ipv6_pos100(X,Y) get_gdat_ipv6((X),(Y),100) +#define get_gdat_string_pos100(X,Y) get_gdat_string((X),(Y),100) +#define get_gdat_v_str_pos100(X,Y) get_gdat_string((X),(Y),100) +#define get_gdat_bool_pos100(X,Y) get_gdat_bool((X),(Y),100) +#define get_gdat_int_pos100(X,Y) get_gdat_int((X),(Y),100) +#define get_gdat_llong_pos100(X,Y) get_gdat_llong((X),(Y),100) +#define get_gdat_float_pos100(X,Y) get_gdat_float((X),(Y),100) +#define get_gdat_uint_pos101(X,Y) get_gdat_uint((X),(Y),101) +#define get_gdat_ullong_pos101(X,Y) get_gdat_ullong((X),(Y),101) +#define get_gdat_ip_pos101(X,Y) get_gdat_ip((X),(Y),101) +#define get_gdat_ipv6_pos101(X,Y) get_gdat_ipv6((X),(Y),101) +#define get_gdat_string_pos101(X,Y) get_gdat_string((X),(Y),101) +#define get_gdat_v_str_pos101(X,Y) get_gdat_string((X),(Y),101) +#define get_gdat_bool_pos101(X,Y) get_gdat_bool((X),(Y),101) +#define get_gdat_int_pos101(X,Y) get_gdat_int((X),(Y),101) +#define get_gdat_llong_pos101(X,Y) get_gdat_llong((X),(Y),101) +#define get_gdat_float_pos101(X,Y) get_gdat_float((X),(Y),101) +#define get_gdat_uint_pos102(X,Y) get_gdat_uint((X),(Y),102) +#define get_gdat_ullong_pos102(X,Y) get_gdat_ullong((X),(Y),102) +#define get_gdat_ip_pos102(X,Y) get_gdat_ip((X),(Y),102) +#define get_gdat_ipv6_pos102(X,Y) get_gdat_ipv6((X),(Y),102) +#define get_gdat_string_pos102(X,Y) get_gdat_string((X),(Y),102) +#define get_gdat_v_str_pos102(X,Y) get_gdat_string((X),(Y),102) +#define get_gdat_bool_pos102(X,Y) get_gdat_bool((X),(Y),102) +#define get_gdat_int_pos102(X,Y) get_gdat_int((X),(Y),102) +#define get_gdat_llong_pos102(X,Y) get_gdat_llong((X),(Y),102) +#define get_gdat_float_pos102(X,Y) get_gdat_float((X),(Y),102) +#define get_gdat_uint_pos103(X,Y) get_gdat_uint((X),(Y),103) +#define get_gdat_ullong_pos103(X,Y) get_gdat_ullong((X),(Y),103) +#define get_gdat_ip_pos103(X,Y) get_gdat_ip((X),(Y),103) +#define get_gdat_ipv6_pos103(X,Y) get_gdat_ipv6((X),(Y),103) +#define get_gdat_string_pos103(X,Y) get_gdat_string((X),(Y),103) +#define get_gdat_v_str_pos103(X,Y) get_gdat_string((X),(Y),103) +#define get_gdat_bool_pos103(X,Y) get_gdat_bool((X),(Y),103) +#define get_gdat_int_pos103(X,Y) get_gdat_int((X),(Y),103) +#define get_gdat_llong_pos103(X,Y) get_gdat_llong((X),(Y),103) +#define get_gdat_float_pos103(X,Y) get_gdat_float((X),(Y),103) +#define get_gdat_uint_pos104(X,Y) get_gdat_uint((X),(Y),104) +#define get_gdat_ullong_pos104(X,Y) get_gdat_ullong((X),(Y),104) +#define get_gdat_ip_pos104(X,Y) get_gdat_ip((X),(Y),104) +#define get_gdat_ipv6_pos104(X,Y) get_gdat_ipv6((X),(Y),104) +#define get_gdat_string_pos104(X,Y) get_gdat_string((X),(Y),104) +#define get_gdat_v_str_pos104(X,Y) get_gdat_string((X),(Y),104) +#define get_gdat_bool_pos104(X,Y) get_gdat_bool((X),(Y),104) +#define get_gdat_int_pos104(X,Y) get_gdat_int((X),(Y),104) +#define get_gdat_llong_pos104(X,Y) get_gdat_llong((X),(Y),104) +#define get_gdat_float_pos104(X,Y) get_gdat_float((X),(Y),104) +#define get_gdat_uint_pos105(X,Y) get_gdat_uint((X),(Y),105) +#define get_gdat_ullong_pos105(X,Y) get_gdat_ullong((X),(Y),105) +#define get_gdat_ip_pos105(X,Y) get_gdat_ip((X),(Y),105) +#define get_gdat_ipv6_pos105(X,Y) get_gdat_ipv6((X),(Y),105) +#define get_gdat_string_pos105(X,Y) get_gdat_string((X),(Y),105) +#define get_gdat_v_str_pos105(X,Y) get_gdat_string((X),(Y),105) +#define get_gdat_bool_pos105(X,Y) get_gdat_bool((X),(Y),105) +#define get_gdat_int_pos105(X,Y) get_gdat_int((X),(Y),105) +#define get_gdat_llong_pos105(X,Y) get_gdat_llong((X),(Y),105) +#define get_gdat_float_pos105(X,Y) get_gdat_float((X),(Y),105) +#define get_gdat_uint_pos106(X,Y) get_gdat_uint((X),(Y),106) +#define get_gdat_ullong_pos106(X,Y) get_gdat_ullong((X),(Y),106) +#define get_gdat_ip_pos106(X,Y) get_gdat_ip((X),(Y),106) +#define get_gdat_ipv6_pos106(X,Y) get_gdat_ipv6((X),(Y),106) +#define get_gdat_string_pos106(X,Y) get_gdat_string((X),(Y),106) +#define get_gdat_v_str_pos106(X,Y) get_gdat_string((X),(Y),106) +#define get_gdat_bool_pos106(X,Y) get_gdat_bool((X),(Y),106) +#define get_gdat_int_pos106(X,Y) get_gdat_int((X),(Y),106) +#define get_gdat_llong_pos106(X,Y) get_gdat_llong((X),(Y),106) +#define get_gdat_float_pos106(X,Y) get_gdat_float((X),(Y),106) +#define get_gdat_uint_pos107(X,Y) get_gdat_uint((X),(Y),107) +#define get_gdat_ullong_pos107(X,Y) get_gdat_ullong((X),(Y),107) +#define get_gdat_ip_pos107(X,Y) get_gdat_ip((X),(Y),107) +#define get_gdat_ipv6_pos107(X,Y) get_gdat_ipv6((X),(Y),107) +#define get_gdat_string_pos107(X,Y) get_gdat_string((X),(Y),107) +#define get_gdat_v_str_pos107(X,Y) get_gdat_string((X),(Y),107) +#define get_gdat_bool_pos107(X,Y) get_gdat_bool((X),(Y),107) +#define get_gdat_int_pos107(X,Y) get_gdat_int((X),(Y),107) +#define get_gdat_llong_pos107(X,Y) get_gdat_llong((X),(Y),107) +#define get_gdat_float_pos107(X,Y) get_gdat_float((X),(Y),107) +#define get_gdat_uint_pos108(X,Y) get_gdat_uint((X),(Y),108) +#define get_gdat_ullong_pos108(X,Y) get_gdat_ullong((X),(Y),108) +#define get_gdat_ip_pos108(X,Y) get_gdat_ip((X),(Y),108) +#define get_gdat_ipv6_pos108(X,Y) get_gdat_ipv6((X),(Y),108) +#define get_gdat_string_pos108(X,Y) get_gdat_string((X),(Y),108) +#define get_gdat_v_str_pos108(X,Y) get_gdat_string((X),(Y),108) +#define get_gdat_bool_pos108(X,Y) get_gdat_bool((X),(Y),108) +#define get_gdat_int_pos108(X,Y) get_gdat_int((X),(Y),108) +#define get_gdat_llong_pos108(X,Y) get_gdat_llong((X),(Y),108) +#define get_gdat_float_pos108(X,Y) get_gdat_float((X),(Y),108) +#define get_gdat_uint_pos109(X,Y) get_gdat_uint((X),(Y),109) +#define get_gdat_ullong_pos109(X,Y) get_gdat_ullong((X),(Y),109) +#define get_gdat_ip_pos109(X,Y) get_gdat_ip((X),(Y),109) +#define get_gdat_ipv6_pos109(X,Y) get_gdat_ipv6((X),(Y),109) +#define get_gdat_string_pos109(X,Y) get_gdat_string((X),(Y),109) +#define get_gdat_v_str_pos109(X,Y) get_gdat_string((X),(Y),109) +#define get_gdat_bool_pos109(X,Y) get_gdat_bool((X),(Y),109) +#define get_gdat_int_pos109(X,Y) get_gdat_int((X),(Y),109) +#define get_gdat_llong_pos109(X,Y) get_gdat_llong((X),(Y),109) +#define get_gdat_float_pos109(X,Y) get_gdat_float((X),(Y),109) +#define get_gdat_uint_pos110(X,Y) get_gdat_uint((X),(Y),110) +#define get_gdat_ullong_pos110(X,Y) get_gdat_ullong((X),(Y),110) +#define get_gdat_ip_pos110(X,Y) get_gdat_ip((X),(Y),110) +#define get_gdat_ipv6_pos110(X,Y) get_gdat_ipv6((X),(Y),110) +#define get_gdat_string_pos110(X,Y) get_gdat_string((X),(Y),110) +#define get_gdat_v_str_pos110(X,Y) get_gdat_string((X),(Y),110) +#define get_gdat_bool_pos110(X,Y) get_gdat_bool((X),(Y),110) +#define get_gdat_int_pos110(X,Y) get_gdat_int((X),(Y),110) +#define get_gdat_llong_pos110(X,Y) get_gdat_llong((X),(Y),110) +#define get_gdat_float_pos110(X,Y) get_gdat_float((X),(Y),110) +#define get_gdat_uint_pos111(X,Y) get_gdat_uint((X),(Y),111) +#define get_gdat_ullong_pos111(X,Y) get_gdat_ullong((X),(Y),111) +#define get_gdat_ip_pos111(X,Y) get_gdat_ip((X),(Y),111) +#define get_gdat_ipv6_pos111(X,Y) get_gdat_ipv6((X),(Y),111) +#define get_gdat_string_pos111(X,Y) get_gdat_string((X),(Y),111) +#define get_gdat_v_str_pos111(X,Y) get_gdat_string((X),(Y),111) +#define get_gdat_bool_pos111(X,Y) get_gdat_bool((X),(Y),111) +#define get_gdat_int_pos111(X,Y) get_gdat_int((X),(Y),111) +#define get_gdat_llong_pos111(X,Y) get_gdat_llong((X),(Y),111) +#define get_gdat_float_pos111(X,Y) get_gdat_float((X),(Y),111) +#define get_gdat_uint_pos112(X,Y) get_gdat_uint((X),(Y),112) +#define get_gdat_ullong_pos112(X,Y) get_gdat_ullong((X),(Y),112) +#define get_gdat_ip_pos112(X,Y) get_gdat_ip((X),(Y),112) +#define get_gdat_ipv6_pos112(X,Y) get_gdat_ipv6((X),(Y),112) +#define get_gdat_string_pos112(X,Y) get_gdat_string((X),(Y),112) +#define get_gdat_v_str_pos112(X,Y) get_gdat_string((X),(Y),112) +#define get_gdat_bool_pos112(X,Y) get_gdat_bool((X),(Y),112) +#define get_gdat_int_pos112(X,Y) get_gdat_int((X),(Y),112) +#define get_gdat_llong_pos112(X,Y) get_gdat_llong((X),(Y),112) +#define get_gdat_float_pos112(X,Y) get_gdat_float((X),(Y),112) +#define get_gdat_uint_pos113(X,Y) get_gdat_uint((X),(Y),113) +#define get_gdat_ullong_pos113(X,Y) get_gdat_ullong((X),(Y),113) +#define get_gdat_ip_pos113(X,Y) get_gdat_ip((X),(Y),113) +#define get_gdat_ipv6_pos113(X,Y) get_gdat_ipv6((X),(Y),113) +#define get_gdat_string_pos113(X,Y) get_gdat_string((X),(Y),113) +#define get_gdat_v_str_pos113(X,Y) get_gdat_string((X),(Y),113) +#define get_gdat_bool_pos113(X,Y) get_gdat_bool((X),(Y),113) +#define get_gdat_int_pos113(X,Y) get_gdat_int((X),(Y),113) +#define get_gdat_llong_pos113(X,Y) get_gdat_llong((X),(Y),113) +#define get_gdat_float_pos113(X,Y) get_gdat_float((X),(Y),113) +#define get_gdat_uint_pos114(X,Y) get_gdat_uint((X),(Y),114) +#define get_gdat_ullong_pos114(X,Y) get_gdat_ullong((X),(Y),114) +#define get_gdat_ip_pos114(X,Y) get_gdat_ip((X),(Y),114) +#define get_gdat_ipv6_pos114(X,Y) get_gdat_ipv6((X),(Y),114) +#define get_gdat_string_pos114(X,Y) get_gdat_string((X),(Y),114) +#define get_gdat_v_str_pos114(X,Y) get_gdat_string((X),(Y),114) +#define get_gdat_bool_pos114(X,Y) get_gdat_bool((X),(Y),114) +#define get_gdat_int_pos114(X,Y) get_gdat_int((X),(Y),114) +#define get_gdat_llong_pos114(X,Y) get_gdat_llong((X),(Y),114) +#define get_gdat_float_pos114(X,Y) get_gdat_float((X),(Y),114) +#define get_gdat_uint_pos115(X,Y) get_gdat_uint((X),(Y),115) +#define get_gdat_ullong_pos115(X,Y) get_gdat_ullong((X),(Y),115) +#define get_gdat_ip_pos115(X,Y) get_gdat_ip((X),(Y),115) +#define get_gdat_ipv6_pos115(X,Y) get_gdat_ipv6((X),(Y),115) +#define get_gdat_string_pos115(X,Y) get_gdat_string((X),(Y),115) +#define get_gdat_v_str_pos115(X,Y) get_gdat_string((X),(Y),115) +#define get_gdat_bool_pos115(X,Y) get_gdat_bool((X),(Y),115) +#define get_gdat_int_pos115(X,Y) get_gdat_int((X),(Y),115) +#define get_gdat_llong_pos115(X,Y) get_gdat_llong((X),(Y),115) +#define get_gdat_float_pos115(X,Y) get_gdat_float((X),(Y),115) +#define get_gdat_uint_pos116(X,Y) get_gdat_uint((X),(Y),116) +#define get_gdat_ullong_pos116(X,Y) get_gdat_ullong((X),(Y),116) +#define get_gdat_ip_pos116(X,Y) get_gdat_ip((X),(Y),116) +#define get_gdat_ipv6_pos116(X,Y) get_gdat_ipv6((X),(Y),116) +#define get_gdat_string_pos116(X,Y) get_gdat_string((X),(Y),116) +#define get_gdat_v_str_pos116(X,Y) get_gdat_string((X),(Y),116) +#define get_gdat_bool_pos116(X,Y) get_gdat_bool((X),(Y),116) +#define get_gdat_int_pos116(X,Y) get_gdat_int((X),(Y),116) +#define get_gdat_llong_pos116(X,Y) get_gdat_llong((X),(Y),116) +#define get_gdat_float_pos116(X,Y) get_gdat_float((X),(Y),116) +#define get_gdat_uint_pos117(X,Y) get_gdat_uint((X),(Y),117) +#define get_gdat_ullong_pos117(X,Y) get_gdat_ullong((X),(Y),117) +#define get_gdat_ip_pos117(X,Y) get_gdat_ip((X),(Y),117) +#define get_gdat_ipv6_pos117(X,Y) get_gdat_ipv6((X),(Y),117) +#define get_gdat_string_pos117(X,Y) get_gdat_string((X),(Y),117) +#define get_gdat_v_str_pos117(X,Y) get_gdat_string((X),(Y),117) +#define get_gdat_bool_pos117(X,Y) get_gdat_bool((X),(Y),117) +#define get_gdat_int_pos117(X,Y) get_gdat_int((X),(Y),117) +#define get_gdat_llong_pos117(X,Y) get_gdat_llong((X),(Y),117) +#define get_gdat_float_pos117(X,Y) get_gdat_float((X),(Y),117) +#define get_gdat_uint_pos118(X,Y) get_gdat_uint((X),(Y),118) +#define get_gdat_ullong_pos118(X,Y) get_gdat_ullong((X),(Y),118) +#define get_gdat_ip_pos118(X,Y) get_gdat_ip((X),(Y),118) +#define get_gdat_ipv6_pos118(X,Y) get_gdat_ipv6((X),(Y),118) +#define get_gdat_string_pos118(X,Y) get_gdat_string((X),(Y),118) +#define get_gdat_v_str_pos118(X,Y) get_gdat_string((X),(Y),118) +#define get_gdat_bool_pos118(X,Y) get_gdat_bool((X),(Y),118) +#define get_gdat_int_pos118(X,Y) get_gdat_int((X),(Y),118) +#define get_gdat_llong_pos118(X,Y) get_gdat_llong((X),(Y),118) +#define get_gdat_float_pos118(X,Y) get_gdat_float((X),(Y),118) +#define get_gdat_uint_pos119(X,Y) get_gdat_uint((X),(Y),119) +#define get_gdat_ullong_pos119(X,Y) get_gdat_ullong((X),(Y),119) +#define get_gdat_ip_pos119(X,Y) get_gdat_ip((X),(Y),119) +#define get_gdat_ipv6_pos119(X,Y) get_gdat_ipv6((X),(Y),119) +#define get_gdat_string_pos119(X,Y) get_gdat_string((X),(Y),119) +#define get_gdat_v_str_pos119(X,Y) get_gdat_string((X),(Y),119) +#define get_gdat_bool_pos119(X,Y) get_gdat_bool((X),(Y),119) +#define get_gdat_int_pos119(X,Y) get_gdat_int((X),(Y),119) +#define get_gdat_llong_pos119(X,Y) get_gdat_llong((X),(Y),119) +#define get_gdat_float_pos119(X,Y) get_gdat_float((X),(Y),119) +#define get_gdat_uint_pos120(X,Y) get_gdat_uint((X),(Y),120) +#define get_gdat_ullong_pos120(X,Y) get_gdat_ullong((X),(Y),120) +#define get_gdat_ip_pos120(X,Y) get_gdat_ip((X),(Y),120) +#define get_gdat_ipv6_pos120(X,Y) get_gdat_ipv6((X),(Y),120) +#define get_gdat_string_pos120(X,Y) get_gdat_string((X),(Y),120) +#define get_gdat_v_str_pos120(X,Y) get_gdat_string((X),(Y),120) +#define get_gdat_bool_pos120(X,Y) get_gdat_bool((X),(Y),120) +#define get_gdat_int_pos120(X,Y) get_gdat_int((X),(Y),120) +#define get_gdat_llong_pos120(X,Y) get_gdat_llong((X),(Y),120) +#define get_gdat_float_pos120(X,Y) get_gdat_float((X),(Y),120) +#define get_gdat_uint_pos121(X,Y) get_gdat_uint((X),(Y),121) +#define get_gdat_ullong_pos121(X,Y) get_gdat_ullong((X),(Y),121) +#define get_gdat_ip_pos121(X,Y) get_gdat_ip((X),(Y),121) +#define get_gdat_ipv6_pos121(X,Y) get_gdat_ipv6((X),(Y),121) +#define get_gdat_string_pos121(X,Y) get_gdat_string((X),(Y),121) +#define get_gdat_v_str_pos121(X,Y) get_gdat_string((X),(Y),121) +#define get_gdat_bool_pos121(X,Y) get_gdat_bool((X),(Y),121) +#define get_gdat_int_pos121(X,Y) get_gdat_int((X),(Y),121) +#define get_gdat_llong_pos121(X,Y) get_gdat_llong((X),(Y),121) +#define get_gdat_float_pos121(X,Y) get_gdat_float((X),(Y),121) +#define get_gdat_uint_pos122(X,Y) get_gdat_uint((X),(Y),122) +#define get_gdat_ullong_pos122(X,Y) get_gdat_ullong((X),(Y),122) +#define get_gdat_ip_pos122(X,Y) get_gdat_ip((X),(Y),122) +#define get_gdat_ipv6_pos122(X,Y) get_gdat_ipv6((X),(Y),122) +#define get_gdat_string_pos122(X,Y) get_gdat_string((X),(Y),122) +#define get_gdat_v_str_pos122(X,Y) get_gdat_string((X),(Y),122) +#define get_gdat_bool_pos122(X,Y) get_gdat_bool((X),(Y),122) +#define get_gdat_int_pos122(X,Y) get_gdat_int((X),(Y),122) +#define get_gdat_llong_pos122(X,Y) get_gdat_llong((X),(Y),122) +#define get_gdat_float_pos122(X,Y) get_gdat_float((X),(Y),122) +#define get_gdat_uint_pos123(X,Y) get_gdat_uint((X),(Y),123) +#define get_gdat_ullong_pos123(X,Y) get_gdat_ullong((X),(Y),123) +#define get_gdat_ip_pos123(X,Y) get_gdat_ip((X),(Y),123) +#define get_gdat_ipv6_pos123(X,Y) get_gdat_ipv6((X),(Y),123) +#define get_gdat_string_pos123(X,Y) get_gdat_string((X),(Y),123) +#define get_gdat_v_str_pos123(X,Y) get_gdat_string((X),(Y),123) +#define get_gdat_bool_pos123(X,Y) get_gdat_bool((X),(Y),123) +#define get_gdat_int_pos123(X,Y) get_gdat_int((X),(Y),123) +#define get_gdat_llong_pos123(X,Y) get_gdat_llong((X),(Y),123) +#define get_gdat_float_pos123(X,Y) get_gdat_float((X),(Y),123) +#define get_gdat_uint_pos124(X,Y) get_gdat_uint((X),(Y),124) +#define get_gdat_ullong_pos124(X,Y) get_gdat_ullong((X),(Y),124) +#define get_gdat_ip_pos124(X,Y) get_gdat_ip((X),(Y),124) +#define get_gdat_ipv6_pos124(X,Y) get_gdat_ipv6((X),(Y),124) +#define get_gdat_string_pos124(X,Y) get_gdat_string((X),(Y),124) +#define get_gdat_v_str_pos124(X,Y) get_gdat_string((X),(Y),124) +#define get_gdat_bool_pos124(X,Y) get_gdat_bool((X),(Y),124) +#define get_gdat_int_pos124(X,Y) get_gdat_int((X),(Y),124) +#define get_gdat_llong_pos124(X,Y) get_gdat_llong((X),(Y),124) +#define get_gdat_float_pos124(X,Y) get_gdat_float((X),(Y),124) +#define get_gdat_uint_pos125(X,Y) get_gdat_uint((X),(Y),125) +#define get_gdat_ullong_pos125(X,Y) get_gdat_ullong((X),(Y),125) +#define get_gdat_ip_pos125(X,Y) get_gdat_ip((X),(Y),125) +#define get_gdat_ipv6_pos125(X,Y) get_gdat_ipv6((X),(Y),125) +#define get_gdat_string_pos125(X,Y) get_gdat_string((X),(Y),125) +#define get_gdat_v_str_pos125(X,Y) get_gdat_string((X),(Y),125) +#define get_gdat_bool_pos125(X,Y) get_gdat_bool((X),(Y),125) +#define get_gdat_int_pos125(X,Y) get_gdat_int((X),(Y),125) +#define get_gdat_llong_pos125(X,Y) get_gdat_llong((X),(Y),125) +#define get_gdat_float_pos125(X,Y) get_gdat_float((X),(Y),125) +#define get_gdat_uint_pos126(X,Y) get_gdat_uint((X),(Y),126) +#define get_gdat_ullong_pos126(X,Y) get_gdat_ullong((X),(Y),126) +#define get_gdat_ip_pos126(X,Y) get_gdat_ip((X),(Y),126) +#define get_gdat_ipv6_pos126(X,Y) get_gdat_ipv6((X),(Y),126) +#define get_gdat_string_pos126(X,Y) get_gdat_string((X),(Y),126) +#define get_gdat_v_str_pos126(X,Y) get_gdat_string((X),(Y),126) +#define get_gdat_bool_pos126(X,Y) get_gdat_bool((X),(Y),126) +#define get_gdat_int_pos126(X,Y) get_gdat_int((X),(Y),126) +#define get_gdat_llong_pos126(X,Y) get_gdat_llong((X),(Y),126) +#define get_gdat_float_pos126(X,Y) get_gdat_float((X),(Y),126) +#define get_gdat_uint_pos127(X,Y) get_gdat_uint((X),(Y),127) +#define get_gdat_ullong_pos127(X,Y) get_gdat_ullong((X),(Y),127) +#define get_gdat_ip_pos127(X,Y) get_gdat_ip((X),(Y),127) +#define get_gdat_ipv6_pos127(X,Y) get_gdat_ipv6((X),(Y),127) +#define get_gdat_string_pos127(X,Y) get_gdat_string((X),(Y),127) +#define get_gdat_v_str_pos127(X,Y) get_gdat_string((X),(Y),127) +#define get_gdat_bool_pos127(X,Y) get_gdat_bool((X),(Y),127) +#define get_gdat_int_pos127(X,Y) get_gdat_int((X),(Y),127) +#define get_gdat_llong_pos127(X,Y) get_gdat_llong((X),(Y),127) +#define get_gdat_float_pos127(X,Y) get_gdat_float((X),(Y),127) +#define get_gdat_uint_pos128(X,Y) get_gdat_uint((X),(Y),128) +#define get_gdat_ullong_pos128(X,Y) get_gdat_ullong((X),(Y),128) +#define get_gdat_ip_pos128(X,Y) get_gdat_ip((X),(Y),128) +#define get_gdat_ipv6_pos128(X,Y) get_gdat_ipv6((X),(Y),128) +#define get_gdat_string_pos128(X,Y) get_gdat_string((X),(Y),128) +#define get_gdat_v_str_pos128(X,Y) get_gdat_string((X),(Y),128) +#define get_gdat_bool_pos128(X,Y) get_gdat_bool((X),(Y),128) +#define get_gdat_int_pos128(X,Y) get_gdat_int((X),(Y),128) +#define get_gdat_llong_pos128(X,Y) get_gdat_llong((X),(Y),128) +#define get_gdat_float_pos128(X,Y) get_gdat_float((X),(Y),128) +#define get_gdat_uint_pos129(X,Y) get_gdat_uint((X),(Y),129) +#define get_gdat_ullong_pos129(X,Y) get_gdat_ullong((X),(Y),129) +#define get_gdat_ip_pos129(X,Y) get_gdat_ip((X),(Y),129) +#define get_gdat_ipv6_pos129(X,Y) get_gdat_ipv6((X),(Y),129) +#define get_gdat_string_pos129(X,Y) get_gdat_string((X),(Y),129) +#define get_gdat_v_str_pos129(X,Y) get_gdat_string((X),(Y),129) +#define get_gdat_bool_pos129(X,Y) get_gdat_bool((X),(Y),129) +#define get_gdat_int_pos129(X,Y) get_gdat_int((X),(Y),129) +#define get_gdat_llong_pos129(X,Y) get_gdat_llong((X),(Y),129) +#define get_gdat_float_pos129(X,Y) get_gdat_float((X),(Y),129) +#define get_gdat_uint_pos130(X,Y) get_gdat_uint((X),(Y),130) +#define get_gdat_ullong_pos130(X,Y) get_gdat_ullong((X),(Y),130) +#define get_gdat_ip_pos130(X,Y) get_gdat_ip((X),(Y),130) +#define get_gdat_ipv6_pos130(X,Y) get_gdat_ipv6((X),(Y),130) +#define get_gdat_string_pos130(X,Y) get_gdat_string((X),(Y),130) +#define get_gdat_v_str_pos130(X,Y) get_gdat_string((X),(Y),130) +#define get_gdat_bool_pos130(X,Y) get_gdat_bool((X),(Y),130) +#define get_gdat_int_pos130(X,Y) get_gdat_int((X),(Y),130) +#define get_gdat_llong_pos130(X,Y) get_gdat_llong((X),(Y),130) +#define get_gdat_float_pos130(X,Y) get_gdat_float((X),(Y),130) +#define get_gdat_uint_pos131(X,Y) get_gdat_uint((X),(Y),131) +#define get_gdat_ullong_pos131(X,Y) get_gdat_ullong((X),(Y),131) +#define get_gdat_ip_pos131(X,Y) get_gdat_ip((X),(Y),131) +#define get_gdat_ipv6_pos131(X,Y) get_gdat_ipv6((X),(Y),131) +#define get_gdat_string_pos131(X,Y) get_gdat_string((X),(Y),131) +#define get_gdat_v_str_pos131(X,Y) get_gdat_string((X),(Y),131) +#define get_gdat_bool_pos131(X,Y) get_gdat_bool((X),(Y),131) +#define get_gdat_int_pos131(X,Y) get_gdat_int((X),(Y),131) +#define get_gdat_llong_pos131(X,Y) get_gdat_llong((X),(Y),131) +#define get_gdat_float_pos131(X,Y) get_gdat_float((X),(Y),131) +#define get_gdat_uint_pos132(X,Y) get_gdat_uint((X),(Y),132) +#define get_gdat_ullong_pos132(X,Y) get_gdat_ullong((X),(Y),132) +#define get_gdat_ip_pos132(X,Y) get_gdat_ip((X),(Y),132) +#define get_gdat_ipv6_pos132(X,Y) get_gdat_ipv6((X),(Y),132) +#define get_gdat_string_pos132(X,Y) get_gdat_string((X),(Y),132) +#define get_gdat_v_str_pos132(X,Y) get_gdat_string((X),(Y),132) +#define get_gdat_bool_pos132(X,Y) get_gdat_bool((X),(Y),132) +#define get_gdat_int_pos132(X,Y) get_gdat_int((X),(Y),132) +#define get_gdat_llong_pos132(X,Y) get_gdat_llong((X),(Y),132) +#define get_gdat_float_pos132(X,Y) get_gdat_float((X),(Y),132) +#define get_gdat_uint_pos133(X,Y) get_gdat_uint((X),(Y),133) +#define get_gdat_ullong_pos133(X,Y) get_gdat_ullong((X),(Y),133) +#define get_gdat_ip_pos133(X,Y) get_gdat_ip((X),(Y),133) +#define get_gdat_ipv6_pos133(X,Y) get_gdat_ipv6((X),(Y),133) +#define get_gdat_string_pos133(X,Y) get_gdat_string((X),(Y),133) +#define get_gdat_v_str_pos133(X,Y) get_gdat_string((X),(Y),133) +#define get_gdat_bool_pos133(X,Y) get_gdat_bool((X),(Y),133) +#define get_gdat_int_pos133(X,Y) get_gdat_int((X),(Y),133) +#define get_gdat_llong_pos133(X,Y) get_gdat_llong((X),(Y),133) +#define get_gdat_float_pos133(X,Y) get_gdat_float((X),(Y),133) +#define get_gdat_uint_pos134(X,Y) get_gdat_uint((X),(Y),134) +#define get_gdat_ullong_pos134(X,Y) get_gdat_ullong((X),(Y),134) +#define get_gdat_ip_pos134(X,Y) get_gdat_ip((X),(Y),134) +#define get_gdat_ipv6_pos134(X,Y) get_gdat_ipv6((X),(Y),134) +#define get_gdat_string_pos134(X,Y) get_gdat_string((X),(Y),134) +#define get_gdat_v_str_pos134(X,Y) get_gdat_string((X),(Y),134) +#define get_gdat_bool_pos134(X,Y) get_gdat_bool((X),(Y),134) +#define get_gdat_int_pos134(X,Y) get_gdat_int((X),(Y),134) +#define get_gdat_llong_pos134(X,Y) get_gdat_llong((X),(Y),134) +#define get_gdat_float_pos134(X,Y) get_gdat_float((X),(Y),134) +#define get_gdat_uint_pos135(X,Y) get_gdat_uint((X),(Y),135) +#define get_gdat_ullong_pos135(X,Y) get_gdat_ullong((X),(Y),135) +#define get_gdat_ip_pos135(X,Y) get_gdat_ip((X),(Y),135) +#define get_gdat_ipv6_pos135(X,Y) get_gdat_ipv6((X),(Y),135) +#define get_gdat_string_pos135(X,Y) get_gdat_string((X),(Y),135) +#define get_gdat_v_str_pos135(X,Y) get_gdat_string((X),(Y),135) +#define get_gdat_bool_pos135(X,Y) get_gdat_bool((X),(Y),135) +#define get_gdat_int_pos135(X,Y) get_gdat_int((X),(Y),135) +#define get_gdat_llong_pos135(X,Y) get_gdat_llong((X),(Y),135) +#define get_gdat_float_pos135(X,Y) get_gdat_float((X),(Y),135) +#define get_gdat_uint_pos136(X,Y) get_gdat_uint((X),(Y),136) +#define get_gdat_ullong_pos136(X,Y) get_gdat_ullong((X),(Y),136) +#define get_gdat_ip_pos136(X,Y) get_gdat_ip((X),(Y),136) +#define get_gdat_ipv6_pos136(X,Y) get_gdat_ipv6((X),(Y),136) +#define get_gdat_string_pos136(X,Y) get_gdat_string((X),(Y),136) +#define get_gdat_v_str_pos136(X,Y) get_gdat_string((X),(Y),136) +#define get_gdat_bool_pos136(X,Y) get_gdat_bool((X),(Y),136) +#define get_gdat_int_pos136(X,Y) get_gdat_int((X),(Y),136) +#define get_gdat_llong_pos136(X,Y) get_gdat_llong((X),(Y),136) +#define get_gdat_float_pos136(X,Y) get_gdat_float((X),(Y),136) +#define get_gdat_uint_pos137(X,Y) get_gdat_uint((X),(Y),137) +#define get_gdat_ullong_pos137(X,Y) get_gdat_ullong((X),(Y),137) +#define get_gdat_ip_pos137(X,Y) get_gdat_ip((X),(Y),137) +#define get_gdat_ipv6_pos137(X,Y) get_gdat_ipv6((X),(Y),137) +#define get_gdat_string_pos137(X,Y) get_gdat_string((X),(Y),137) +#define get_gdat_v_str_pos137(X,Y) get_gdat_string((X),(Y),137) +#define get_gdat_bool_pos137(X,Y) get_gdat_bool((X),(Y),137) +#define get_gdat_int_pos137(X,Y) get_gdat_int((X),(Y),137) +#define get_gdat_llong_pos137(X,Y) get_gdat_llong((X),(Y),137) +#define get_gdat_float_pos137(X,Y) get_gdat_float((X),(Y),137) +#define get_gdat_uint_pos138(X,Y) get_gdat_uint((X),(Y),138) +#define get_gdat_ullong_pos138(X,Y) get_gdat_ullong((X),(Y),138) +#define get_gdat_ip_pos138(X,Y) get_gdat_ip((X),(Y),138) +#define get_gdat_ipv6_pos138(X,Y) get_gdat_ipv6((X),(Y),138) +#define get_gdat_string_pos138(X,Y) get_gdat_string((X),(Y),138) +#define get_gdat_v_str_pos138(X,Y) get_gdat_string((X),(Y),138) +#define get_gdat_bool_pos138(X,Y) get_gdat_bool((X),(Y),138) +#define get_gdat_int_pos138(X,Y) get_gdat_int((X),(Y),138) +#define get_gdat_llong_pos138(X,Y) get_gdat_llong((X),(Y),138) +#define get_gdat_float_pos138(X,Y) get_gdat_float((X),(Y),138) +#define get_gdat_uint_pos139(X,Y) get_gdat_uint((X),(Y),139) +#define get_gdat_ullong_pos139(X,Y) get_gdat_ullong((X),(Y),139) +#define get_gdat_ip_pos139(X,Y) get_gdat_ip((X),(Y),139) +#define get_gdat_ipv6_pos139(X,Y) get_gdat_ipv6((X),(Y),139) +#define get_gdat_string_pos139(X,Y) get_gdat_string((X),(Y),139) +#define get_gdat_v_str_pos139(X,Y) get_gdat_string((X),(Y),139) +#define get_gdat_bool_pos139(X,Y) get_gdat_bool((X),(Y),139) +#define get_gdat_int_pos139(X,Y) get_gdat_int((X),(Y),139) +#define get_gdat_llong_pos139(X,Y) get_gdat_llong((X),(Y),139) +#define get_gdat_float_pos139(X,Y) get_gdat_float((X),(Y),139) +#define get_gdat_uint_pos140(X,Y) get_gdat_uint((X),(Y),140) +#define get_gdat_ullong_pos140(X,Y) get_gdat_ullong((X),(Y),140) +#define get_gdat_ip_pos140(X,Y) get_gdat_ip((X),(Y),140) +#define get_gdat_ipv6_pos140(X,Y) get_gdat_ipv6((X),(Y),140) +#define get_gdat_string_pos140(X,Y) get_gdat_string((X),(Y),140) +#define get_gdat_v_str_pos140(X,Y) get_gdat_string((X),(Y),140) +#define get_gdat_bool_pos140(X,Y) get_gdat_bool((X),(Y),140) +#define get_gdat_int_pos140(X,Y) get_gdat_int((X),(Y),140) +#define get_gdat_llong_pos140(X,Y) get_gdat_llong((X),(Y),140) +#define get_gdat_float_pos140(X,Y) get_gdat_float((X),(Y),140) +#define get_gdat_uint_pos141(X,Y) get_gdat_uint((X),(Y),141) +#define get_gdat_ullong_pos141(X,Y) get_gdat_ullong((X),(Y),141) +#define get_gdat_ip_pos141(X,Y) get_gdat_ip((X),(Y),141) +#define get_gdat_ipv6_pos141(X,Y) get_gdat_ipv6((X),(Y),141) +#define get_gdat_string_pos141(X,Y) get_gdat_string((X),(Y),141) +#define get_gdat_v_str_pos141(X,Y) get_gdat_string((X),(Y),141) +#define get_gdat_bool_pos141(X,Y) get_gdat_bool((X),(Y),141) +#define get_gdat_int_pos141(X,Y) get_gdat_int((X),(Y),141) +#define get_gdat_llong_pos141(X,Y) get_gdat_llong((X),(Y),141) +#define get_gdat_float_pos141(X,Y) get_gdat_float((X),(Y),141) +#define get_gdat_uint_pos142(X,Y) get_gdat_uint((X),(Y),142) +#define get_gdat_ullong_pos142(X,Y) get_gdat_ullong((X),(Y),142) +#define get_gdat_ip_pos142(X,Y) get_gdat_ip((X),(Y),142) +#define get_gdat_ipv6_pos142(X,Y) get_gdat_ipv6((X),(Y),142) +#define get_gdat_string_pos142(X,Y) get_gdat_string((X),(Y),142) +#define get_gdat_v_str_pos142(X,Y) get_gdat_string((X),(Y),142) +#define get_gdat_bool_pos142(X,Y) get_gdat_bool((X),(Y),142) +#define get_gdat_int_pos142(X,Y) get_gdat_int((X),(Y),142) +#define get_gdat_llong_pos142(X,Y) get_gdat_llong((X),(Y),142) +#define get_gdat_float_pos142(X,Y) get_gdat_float((X),(Y),142) +#define get_gdat_uint_pos143(X,Y) get_gdat_uint((X),(Y),143) +#define get_gdat_ullong_pos143(X,Y) get_gdat_ullong((X),(Y),143) +#define get_gdat_ip_pos143(X,Y) get_gdat_ip((X),(Y),143) +#define get_gdat_ipv6_pos143(X,Y) get_gdat_ipv6((X),(Y),143) +#define get_gdat_string_pos143(X,Y) get_gdat_string((X),(Y),143) +#define get_gdat_v_str_pos143(X,Y) get_gdat_string((X),(Y),143) +#define get_gdat_bool_pos143(X,Y) get_gdat_bool((X),(Y),143) +#define get_gdat_int_pos143(X,Y) get_gdat_int((X),(Y),143) +#define get_gdat_llong_pos143(X,Y) get_gdat_llong((X),(Y),143) +#define get_gdat_float_pos143(X,Y) get_gdat_float((X),(Y),143) +#define get_gdat_uint_pos144(X,Y) get_gdat_uint((X),(Y),144) +#define get_gdat_ullong_pos144(X,Y) get_gdat_ullong((X),(Y),144) +#define get_gdat_ip_pos144(X,Y) get_gdat_ip((X),(Y),144) +#define get_gdat_ipv6_pos144(X,Y) get_gdat_ipv6((X),(Y),144) +#define get_gdat_string_pos144(X,Y) get_gdat_string((X),(Y),144) +#define get_gdat_v_str_pos144(X,Y) get_gdat_string((X),(Y),144) +#define get_gdat_bool_pos144(X,Y) get_gdat_bool((X),(Y),144) +#define get_gdat_int_pos144(X,Y) get_gdat_int((X),(Y),144) +#define get_gdat_llong_pos144(X,Y) get_gdat_llong((X),(Y),144) +#define get_gdat_float_pos144(X,Y) get_gdat_float((X),(Y),144) +#define get_gdat_uint_pos145(X,Y) get_gdat_uint((X),(Y),145) +#define get_gdat_ullong_pos145(X,Y) get_gdat_ullong((X),(Y),145) +#define get_gdat_ip_pos145(X,Y) get_gdat_ip((X),(Y),145) +#define get_gdat_ipv6_pos145(X,Y) get_gdat_ipv6((X),(Y),145) +#define get_gdat_string_pos145(X,Y) get_gdat_string((X),(Y),145) +#define get_gdat_v_str_pos145(X,Y) get_gdat_string((X),(Y),145) +#define get_gdat_bool_pos145(X,Y) get_gdat_bool((X),(Y),145) +#define get_gdat_int_pos145(X,Y) get_gdat_int((X),(Y),145) +#define get_gdat_llong_pos145(X,Y) get_gdat_llong((X),(Y),145) +#define get_gdat_float_pos145(X,Y) get_gdat_float((X),(Y),145) +#define get_gdat_uint_pos146(X,Y) get_gdat_uint((X),(Y),146) +#define get_gdat_ullong_pos146(X,Y) get_gdat_ullong((X),(Y),146) +#define get_gdat_ip_pos146(X,Y) get_gdat_ip((X),(Y),146) +#define get_gdat_ipv6_pos146(X,Y) get_gdat_ipv6((X),(Y),146) +#define get_gdat_string_pos146(X,Y) get_gdat_string((X),(Y),146) +#define get_gdat_v_str_pos146(X,Y) get_gdat_string((X),(Y),146) +#define get_gdat_bool_pos146(X,Y) get_gdat_bool((X),(Y),146) +#define get_gdat_int_pos146(X,Y) get_gdat_int((X),(Y),146) +#define get_gdat_llong_pos146(X,Y) get_gdat_llong((X),(Y),146) +#define get_gdat_float_pos146(X,Y) get_gdat_float((X),(Y),146) +#define get_gdat_uint_pos147(X,Y) get_gdat_uint((X),(Y),147) +#define get_gdat_ullong_pos147(X,Y) get_gdat_ullong((X),(Y),147) +#define get_gdat_ip_pos147(X,Y) get_gdat_ip((X),(Y),147) +#define get_gdat_ipv6_pos147(X,Y) get_gdat_ipv6((X),(Y),147) +#define get_gdat_string_pos147(X,Y) get_gdat_string((X),(Y),147) +#define get_gdat_v_str_pos147(X,Y) get_gdat_string((X),(Y),147) +#define get_gdat_bool_pos147(X,Y) get_gdat_bool((X),(Y),147) +#define get_gdat_int_pos147(X,Y) get_gdat_int((X),(Y),147) +#define get_gdat_llong_pos147(X,Y) get_gdat_llong((X),(Y),147) +#define get_gdat_float_pos147(X,Y) get_gdat_float((X),(Y),147) +#define get_gdat_uint_pos148(X,Y) get_gdat_uint((X),(Y),148) +#define get_gdat_ullong_pos148(X,Y) get_gdat_ullong((X),(Y),148) +#define get_gdat_ip_pos148(X,Y) get_gdat_ip((X),(Y),148) +#define get_gdat_ipv6_pos148(X,Y) get_gdat_ipv6((X),(Y),148) +#define get_gdat_string_pos148(X,Y) get_gdat_string((X),(Y),148) +#define get_gdat_v_str_pos148(X,Y) get_gdat_string((X),(Y),148) +#define get_gdat_bool_pos148(X,Y) get_gdat_bool((X),(Y),148) +#define get_gdat_int_pos148(X,Y) get_gdat_int((X),(Y),148) +#define get_gdat_llong_pos148(X,Y) get_gdat_llong((X),(Y),148) +#define get_gdat_float_pos148(X,Y) get_gdat_float((X),(Y),148) +#define get_gdat_uint_pos149(X,Y) get_gdat_uint((X),(Y),149) +#define get_gdat_ullong_pos149(X,Y) get_gdat_ullong((X),(Y),149) +#define get_gdat_ip_pos149(X,Y) get_gdat_ip((X),(Y),149) +#define get_gdat_ipv6_pos149(X,Y) get_gdat_ipv6((X),(Y),149) +#define get_gdat_string_pos149(X,Y) get_gdat_string((X),(Y),149) +#define get_gdat_v_str_pos149(X,Y) get_gdat_string((X),(Y),149) +#define get_gdat_bool_pos149(X,Y) get_gdat_bool((X),(Y),149) +#define get_gdat_int_pos149(X,Y) get_gdat_int((X),(Y),149) +#define get_gdat_llong_pos149(X,Y) get_gdat_llong((X),(Y),149) +#define get_gdat_float_pos149(X,Y) get_gdat_float((X),(Y),149) +#define get_gdat_uint_pos150(X,Y) get_gdat_uint((X),(Y),150) +#define get_gdat_ullong_pos150(X,Y) get_gdat_ullong((X),(Y),150) +#define get_gdat_ip_pos150(X,Y) get_gdat_ip((X),(Y),150) +#define get_gdat_ipv6_pos150(X,Y) get_gdat_ipv6((X),(Y),150) +#define get_gdat_string_pos150(X,Y) get_gdat_string((X),(Y),150) +#define get_gdat_v_str_pos150(X,Y) get_gdat_string((X),(Y),150) +#define get_gdat_bool_pos150(X,Y) get_gdat_bool((X),(Y),150) +#define get_gdat_int_pos150(X,Y) get_gdat_int((X),(Y),150) +#define get_gdat_llong_pos150(X,Y) get_gdat_llong((X),(Y),150) +#define get_gdat_float_pos150(X,Y) get_gdat_float((X),(Y),150) +#define get_gdat_uint_pos151(X,Y) get_gdat_uint((X),(Y),151) +#define get_gdat_ullong_pos151(X,Y) get_gdat_ullong((X),(Y),151) +#define get_gdat_ip_pos151(X,Y) get_gdat_ip((X),(Y),151) +#define get_gdat_ipv6_pos151(X,Y) get_gdat_ipv6((X),(Y),151) +#define get_gdat_string_pos151(X,Y) get_gdat_string((X),(Y),151) +#define get_gdat_v_str_pos151(X,Y) get_gdat_string((X),(Y),151) +#define get_gdat_bool_pos151(X,Y) get_gdat_bool((X),(Y),151) +#define get_gdat_int_pos151(X,Y) get_gdat_int((X),(Y),151) +#define get_gdat_llong_pos151(X,Y) get_gdat_llong((X),(Y),151) +#define get_gdat_float_pos151(X,Y) get_gdat_float((X),(Y),151) +#define get_gdat_uint_pos152(X,Y) get_gdat_uint((X),(Y),152) +#define get_gdat_ullong_pos152(X,Y) get_gdat_ullong((X),(Y),152) +#define get_gdat_ip_pos152(X,Y) get_gdat_ip((X),(Y),152) +#define get_gdat_ipv6_pos152(X,Y) get_gdat_ipv6((X),(Y),152) +#define get_gdat_string_pos152(X,Y) get_gdat_string((X),(Y),152) +#define get_gdat_v_str_pos152(X,Y) get_gdat_string((X),(Y),152) +#define get_gdat_bool_pos152(X,Y) get_gdat_bool((X),(Y),152) +#define get_gdat_int_pos152(X,Y) get_gdat_int((X),(Y),152) +#define get_gdat_llong_pos152(X,Y) get_gdat_llong((X),(Y),152) +#define get_gdat_float_pos152(X,Y) get_gdat_float((X),(Y),152) +#define get_gdat_uint_pos153(X,Y) get_gdat_uint((X),(Y),153) +#define get_gdat_ullong_pos153(X,Y) get_gdat_ullong((X),(Y),153) +#define get_gdat_ip_pos153(X,Y) get_gdat_ip((X),(Y),153) +#define get_gdat_ipv6_pos153(X,Y) get_gdat_ipv6((X),(Y),153) +#define get_gdat_string_pos153(X,Y) get_gdat_string((X),(Y),153) +#define get_gdat_v_str_pos153(X,Y) get_gdat_string((X),(Y),153) +#define get_gdat_bool_pos153(X,Y) get_gdat_bool((X),(Y),153) +#define get_gdat_int_pos153(X,Y) get_gdat_int((X),(Y),153) +#define get_gdat_llong_pos153(X,Y) get_gdat_llong((X),(Y),153) +#define get_gdat_float_pos153(X,Y) get_gdat_float((X),(Y),153) +#define get_gdat_uint_pos154(X,Y) get_gdat_uint((X),(Y),154) +#define get_gdat_ullong_pos154(X,Y) get_gdat_ullong((X),(Y),154) +#define get_gdat_ip_pos154(X,Y) get_gdat_ip((X),(Y),154) +#define get_gdat_ipv6_pos154(X,Y) get_gdat_ipv6((X),(Y),154) +#define get_gdat_string_pos154(X,Y) get_gdat_string((X),(Y),154) +#define get_gdat_v_str_pos154(X,Y) get_gdat_string((X),(Y),154) +#define get_gdat_bool_pos154(X,Y) get_gdat_bool((X),(Y),154) +#define get_gdat_int_pos154(X,Y) get_gdat_int((X),(Y),154) +#define get_gdat_llong_pos154(X,Y) get_gdat_llong((X),(Y),154) +#define get_gdat_float_pos154(X,Y) get_gdat_float((X),(Y),154) +#define get_gdat_uint_pos155(X,Y) get_gdat_uint((X),(Y),155) +#define get_gdat_ullong_pos155(X,Y) get_gdat_ullong((X),(Y),155) +#define get_gdat_ip_pos155(X,Y) get_gdat_ip((X),(Y),155) +#define get_gdat_ipv6_pos155(X,Y) get_gdat_ipv6((X),(Y),155) +#define get_gdat_string_pos155(X,Y) get_gdat_string((X),(Y),155) +#define get_gdat_v_str_pos155(X,Y) get_gdat_string((X),(Y),155) +#define get_gdat_bool_pos155(X,Y) get_gdat_bool((X),(Y),155) +#define get_gdat_int_pos155(X,Y) get_gdat_int((X),(Y),155) +#define get_gdat_llong_pos155(X,Y) get_gdat_llong((X),(Y),155) +#define get_gdat_float_pos155(X,Y) get_gdat_float((X),(Y),155) +#define get_gdat_uint_pos156(X,Y) get_gdat_uint((X),(Y),156) +#define get_gdat_ullong_pos156(X,Y) get_gdat_ullong((X),(Y),156) +#define get_gdat_ip_pos156(X,Y) get_gdat_ip((X),(Y),156) +#define get_gdat_ipv6_pos156(X,Y) get_gdat_ipv6((X),(Y),156) +#define get_gdat_string_pos156(X,Y) get_gdat_string((X),(Y),156) +#define get_gdat_v_str_pos156(X,Y) get_gdat_string((X),(Y),156) +#define get_gdat_bool_pos156(X,Y) get_gdat_bool((X),(Y),156) +#define get_gdat_int_pos156(X,Y) get_gdat_int((X),(Y),156) +#define get_gdat_llong_pos156(X,Y) get_gdat_llong((X),(Y),156) +#define get_gdat_float_pos156(X,Y) get_gdat_float((X),(Y),156) +#define get_gdat_uint_pos157(X,Y) get_gdat_uint((X),(Y),157) +#define get_gdat_ullong_pos157(X,Y) get_gdat_ullong((X),(Y),157) +#define get_gdat_ip_pos157(X,Y) get_gdat_ip((X),(Y),157) +#define get_gdat_ipv6_pos157(X,Y) get_gdat_ipv6((X),(Y),157) +#define get_gdat_string_pos157(X,Y) get_gdat_string((X),(Y),157) +#define get_gdat_v_str_pos157(X,Y) get_gdat_string((X),(Y),157) +#define get_gdat_bool_pos157(X,Y) get_gdat_bool((X),(Y),157) +#define get_gdat_int_pos157(X,Y) get_gdat_int((X),(Y),157) +#define get_gdat_llong_pos157(X,Y) get_gdat_llong((X),(Y),157) +#define get_gdat_float_pos157(X,Y) get_gdat_float((X),(Y),157) +#define get_gdat_uint_pos158(X,Y) get_gdat_uint((X),(Y),158) +#define get_gdat_ullong_pos158(X,Y) get_gdat_ullong((X),(Y),158) +#define get_gdat_ip_pos158(X,Y) get_gdat_ip((X),(Y),158) +#define get_gdat_ipv6_pos158(X,Y) get_gdat_ipv6((X),(Y),158) +#define get_gdat_string_pos158(X,Y) get_gdat_string((X),(Y),158) +#define get_gdat_v_str_pos158(X,Y) get_gdat_string((X),(Y),158) +#define get_gdat_bool_pos158(X,Y) get_gdat_bool((X),(Y),158) +#define get_gdat_int_pos158(X,Y) get_gdat_int((X),(Y),158) +#define get_gdat_llong_pos158(X,Y) get_gdat_llong((X),(Y),158) +#define get_gdat_float_pos158(X,Y) get_gdat_float((X),(Y),158) +#define get_gdat_uint_pos159(X,Y) get_gdat_uint((X),(Y),159) +#define get_gdat_ullong_pos159(X,Y) get_gdat_ullong((X),(Y),159) +#define get_gdat_ip_pos159(X,Y) get_gdat_ip((X),(Y),159) +#define get_gdat_ipv6_pos159(X,Y) get_gdat_ipv6((X),(Y),159) +#define get_gdat_string_pos159(X,Y) get_gdat_string((X),(Y),159) +#define get_gdat_v_str_pos159(X,Y) get_gdat_string((X),(Y),159) +#define get_gdat_bool_pos159(X,Y) get_gdat_bool((X),(Y),159) +#define get_gdat_int_pos159(X,Y) get_gdat_int((X),(Y),159) +#define get_gdat_llong_pos159(X,Y) get_gdat_llong((X),(Y),159) +#define get_gdat_float_pos159(X,Y) get_gdat_float((X),(Y),159) +#define get_gdat_uint_pos160(X,Y) get_gdat_uint((X),(Y),160) +#define get_gdat_ullong_pos160(X,Y) get_gdat_ullong((X),(Y),160) +#define get_gdat_ip_pos160(X,Y) get_gdat_ip((X),(Y),160) +#define get_gdat_ipv6_pos160(X,Y) get_gdat_ipv6((X),(Y),160) +#define get_gdat_string_pos160(X,Y) get_gdat_string((X),(Y),160) +#define get_gdat_v_str_pos160(X,Y) get_gdat_string((X),(Y),160) +#define get_gdat_bool_pos160(X,Y) get_gdat_bool((X),(Y),160) +#define get_gdat_int_pos160(X,Y) get_gdat_int((X),(Y),160) +#define get_gdat_llong_pos160(X,Y) get_gdat_llong((X),(Y),160) +#define get_gdat_float_pos160(X,Y) get_gdat_float((X),(Y),160) +#define get_gdat_uint_pos161(X,Y) get_gdat_uint((X),(Y),161) +#define get_gdat_ullong_pos161(X,Y) get_gdat_ullong((X),(Y),161) +#define get_gdat_ip_pos161(X,Y) get_gdat_ip((X),(Y),161) +#define get_gdat_ipv6_pos161(X,Y) get_gdat_ipv6((X),(Y),161) +#define get_gdat_string_pos161(X,Y) get_gdat_string((X),(Y),161) +#define get_gdat_v_str_pos161(X,Y) get_gdat_string((X),(Y),161) +#define get_gdat_bool_pos161(X,Y) get_gdat_bool((X),(Y),161) +#define get_gdat_int_pos161(X,Y) get_gdat_int((X),(Y),161) +#define get_gdat_llong_pos161(X,Y) get_gdat_llong((X),(Y),161) +#define get_gdat_float_pos161(X,Y) get_gdat_float((X),(Y),161) +#define get_gdat_uint_pos162(X,Y) get_gdat_uint((X),(Y),162) +#define get_gdat_ullong_pos162(X,Y) get_gdat_ullong((X),(Y),162) +#define get_gdat_ip_pos162(X,Y) get_gdat_ip((X),(Y),162) +#define get_gdat_ipv6_pos162(X,Y) get_gdat_ipv6((X),(Y),162) +#define get_gdat_string_pos162(X,Y) get_gdat_string((X),(Y),162) +#define get_gdat_v_str_pos162(X,Y) get_gdat_string((X),(Y),162) +#define get_gdat_bool_pos162(X,Y) get_gdat_bool((X),(Y),162) +#define get_gdat_int_pos162(X,Y) get_gdat_int((X),(Y),162) +#define get_gdat_llong_pos162(X,Y) get_gdat_llong((X),(Y),162) +#define get_gdat_float_pos162(X,Y) get_gdat_float((X),(Y),162) +#define get_gdat_uint_pos163(X,Y) get_gdat_uint((X),(Y),163) +#define get_gdat_ullong_pos163(X,Y) get_gdat_ullong((X),(Y),163) +#define get_gdat_ip_pos163(X,Y) get_gdat_ip((X),(Y),163) +#define get_gdat_ipv6_pos163(X,Y) get_gdat_ipv6((X),(Y),163) +#define get_gdat_string_pos163(X,Y) get_gdat_string((X),(Y),163) +#define get_gdat_v_str_pos163(X,Y) get_gdat_string((X),(Y),163) +#define get_gdat_bool_pos163(X,Y) get_gdat_bool((X),(Y),163) +#define get_gdat_int_pos163(X,Y) get_gdat_int((X),(Y),163) +#define get_gdat_llong_pos163(X,Y) get_gdat_llong((X),(Y),163) +#define get_gdat_float_pos163(X,Y) get_gdat_float((X),(Y),163) +#define get_gdat_uint_pos164(X,Y) get_gdat_uint((X),(Y),164) +#define get_gdat_ullong_pos164(X,Y) get_gdat_ullong((X),(Y),164) +#define get_gdat_ip_pos164(X,Y) get_gdat_ip((X),(Y),164) +#define get_gdat_ipv6_pos164(X,Y) get_gdat_ipv6((X),(Y),164) +#define get_gdat_string_pos164(X,Y) get_gdat_string((X),(Y),164) +#define get_gdat_v_str_pos164(X,Y) get_gdat_string((X),(Y),164) +#define get_gdat_bool_pos164(X,Y) get_gdat_bool((X),(Y),164) +#define get_gdat_int_pos164(X,Y) get_gdat_int((X),(Y),164) +#define get_gdat_llong_pos164(X,Y) get_gdat_llong((X),(Y),164) +#define get_gdat_float_pos164(X,Y) get_gdat_float((X),(Y),164) +#define get_gdat_uint_pos165(X,Y) get_gdat_uint((X),(Y),165) +#define get_gdat_ullong_pos165(X,Y) get_gdat_ullong((X),(Y),165) +#define get_gdat_ip_pos165(X,Y) get_gdat_ip((X),(Y),165) +#define get_gdat_ipv6_pos165(X,Y) get_gdat_ipv6((X),(Y),165) +#define get_gdat_string_pos165(X,Y) get_gdat_string((X),(Y),165) +#define get_gdat_v_str_pos165(X,Y) get_gdat_string((X),(Y),165) +#define get_gdat_bool_pos165(X,Y) get_gdat_bool((X),(Y),165) +#define get_gdat_int_pos165(X,Y) get_gdat_int((X),(Y),165) +#define get_gdat_llong_pos165(X,Y) get_gdat_llong((X),(Y),165) +#define get_gdat_float_pos165(X,Y) get_gdat_float((X),(Y),165) +#define get_gdat_uint_pos166(X,Y) get_gdat_uint((X),(Y),166) +#define get_gdat_ullong_pos166(X,Y) get_gdat_ullong((X),(Y),166) +#define get_gdat_ip_pos166(X,Y) get_gdat_ip((X),(Y),166) +#define get_gdat_ipv6_pos166(X,Y) get_gdat_ipv6((X),(Y),166) +#define get_gdat_string_pos166(X,Y) get_gdat_string((X),(Y),166) +#define get_gdat_v_str_pos166(X,Y) get_gdat_string((X),(Y),166) +#define get_gdat_bool_pos166(X,Y) get_gdat_bool((X),(Y),166) +#define get_gdat_int_pos166(X,Y) get_gdat_int((X),(Y),166) +#define get_gdat_llong_pos166(X,Y) get_gdat_llong((X),(Y),166) +#define get_gdat_float_pos166(X,Y) get_gdat_float((X),(Y),166) +#define get_gdat_uint_pos167(X,Y) get_gdat_uint((X),(Y),167) +#define get_gdat_ullong_pos167(X,Y) get_gdat_ullong((X),(Y),167) +#define get_gdat_ip_pos167(X,Y) get_gdat_ip((X),(Y),167) +#define get_gdat_ipv6_pos167(X,Y) get_gdat_ipv6((X),(Y),167) +#define get_gdat_string_pos167(X,Y) get_gdat_string((X),(Y),167) +#define get_gdat_v_str_pos167(X,Y) get_gdat_string((X),(Y),167) +#define get_gdat_bool_pos167(X,Y) get_gdat_bool((X),(Y),167) +#define get_gdat_int_pos167(X,Y) get_gdat_int((X),(Y),167) +#define get_gdat_llong_pos167(X,Y) get_gdat_llong((X),(Y),167) +#define get_gdat_float_pos167(X,Y) get_gdat_float((X),(Y),167) +#define get_gdat_uint_pos168(X,Y) get_gdat_uint((X),(Y),168) +#define get_gdat_ullong_pos168(X,Y) get_gdat_ullong((X),(Y),168) +#define get_gdat_ip_pos168(X,Y) get_gdat_ip((X),(Y),168) +#define get_gdat_ipv6_pos168(X,Y) get_gdat_ipv6((X),(Y),168) +#define get_gdat_string_pos168(X,Y) get_gdat_string((X),(Y),168) +#define get_gdat_v_str_pos168(X,Y) get_gdat_string((X),(Y),168) +#define get_gdat_bool_pos168(X,Y) get_gdat_bool((X),(Y),168) +#define get_gdat_int_pos168(X,Y) get_gdat_int((X),(Y),168) +#define get_gdat_llong_pos168(X,Y) get_gdat_llong((X),(Y),168) +#define get_gdat_float_pos168(X,Y) get_gdat_float((X),(Y),168) +#define get_gdat_uint_pos169(X,Y) get_gdat_uint((X),(Y),169) +#define get_gdat_ullong_pos169(X,Y) get_gdat_ullong((X),(Y),169) +#define get_gdat_ip_pos169(X,Y) get_gdat_ip((X),(Y),169) +#define get_gdat_ipv6_pos169(X,Y) get_gdat_ipv6((X),(Y),169) +#define get_gdat_string_pos169(X,Y) get_gdat_string((X),(Y),169) +#define get_gdat_v_str_pos169(X,Y) get_gdat_string((X),(Y),169) +#define get_gdat_bool_pos169(X,Y) get_gdat_bool((X),(Y),169) +#define get_gdat_int_pos169(X,Y) get_gdat_int((X),(Y),169) +#define get_gdat_llong_pos169(X,Y) get_gdat_llong((X),(Y),169) +#define get_gdat_float_pos169(X,Y) get_gdat_float((X),(Y),169) +#define get_gdat_uint_pos170(X,Y) get_gdat_uint((X),(Y),170) +#define get_gdat_ullong_pos170(X,Y) get_gdat_ullong((X),(Y),170) +#define get_gdat_ip_pos170(X,Y) get_gdat_ip((X),(Y),170) +#define get_gdat_ipv6_pos170(X,Y) get_gdat_ipv6((X),(Y),170) +#define get_gdat_string_pos170(X,Y) get_gdat_string((X),(Y),170) +#define get_gdat_v_str_pos170(X,Y) get_gdat_string((X),(Y),170) +#define get_gdat_bool_pos170(X,Y) get_gdat_bool((X),(Y),170) +#define get_gdat_int_pos170(X,Y) get_gdat_int((X),(Y),170) +#define get_gdat_llong_pos170(X,Y) get_gdat_llong((X),(Y),170) +#define get_gdat_float_pos170(X,Y) get_gdat_float((X),(Y),170) +#define get_gdat_uint_pos171(X,Y) get_gdat_uint((X),(Y),171) +#define get_gdat_ullong_pos171(X,Y) get_gdat_ullong((X),(Y),171) +#define get_gdat_ip_pos171(X,Y) get_gdat_ip((X),(Y),171) +#define get_gdat_ipv6_pos171(X,Y) get_gdat_ipv6((X),(Y),171) +#define get_gdat_string_pos171(X,Y) get_gdat_string((X),(Y),171) +#define get_gdat_v_str_pos171(X,Y) get_gdat_string((X),(Y),171) +#define get_gdat_bool_pos171(X,Y) get_gdat_bool((X),(Y),171) +#define get_gdat_int_pos171(X,Y) get_gdat_int((X),(Y),171) +#define get_gdat_llong_pos171(X,Y) get_gdat_llong((X),(Y),171) +#define get_gdat_float_pos171(X,Y) get_gdat_float((X),(Y),171) +#define get_gdat_uint_pos172(X,Y) get_gdat_uint((X),(Y),172) +#define get_gdat_ullong_pos172(X,Y) get_gdat_ullong((X),(Y),172) +#define get_gdat_ip_pos172(X,Y) get_gdat_ip((X),(Y),172) +#define get_gdat_ipv6_pos172(X,Y) get_gdat_ipv6((X),(Y),172) +#define get_gdat_string_pos172(X,Y) get_gdat_string((X),(Y),172) +#define get_gdat_v_str_pos172(X,Y) get_gdat_string((X),(Y),172) +#define get_gdat_bool_pos172(X,Y) get_gdat_bool((X),(Y),172) +#define get_gdat_int_pos172(X,Y) get_gdat_int((X),(Y),172) +#define get_gdat_llong_pos172(X,Y) get_gdat_llong((X),(Y),172) +#define get_gdat_float_pos172(X,Y) get_gdat_float((X),(Y),172) +#define get_gdat_uint_pos173(X,Y) get_gdat_uint((X),(Y),173) +#define get_gdat_ullong_pos173(X,Y) get_gdat_ullong((X),(Y),173) +#define get_gdat_ip_pos173(X,Y) get_gdat_ip((X),(Y),173) +#define get_gdat_ipv6_pos173(X,Y) get_gdat_ipv6((X),(Y),173) +#define get_gdat_string_pos173(X,Y) get_gdat_string((X),(Y),173) +#define get_gdat_v_str_pos173(X,Y) get_gdat_string((X),(Y),173) +#define get_gdat_bool_pos173(X,Y) get_gdat_bool((X),(Y),173) +#define get_gdat_int_pos173(X,Y) get_gdat_int((X),(Y),173) +#define get_gdat_llong_pos173(X,Y) get_gdat_llong((X),(Y),173) +#define get_gdat_float_pos173(X,Y) get_gdat_float((X),(Y),173) +#define get_gdat_uint_pos174(X,Y) get_gdat_uint((X),(Y),174) +#define get_gdat_ullong_pos174(X,Y) get_gdat_ullong((X),(Y),174) +#define get_gdat_ip_pos174(X,Y) get_gdat_ip((X),(Y),174) +#define get_gdat_ipv6_pos174(X,Y) get_gdat_ipv6((X),(Y),174) +#define get_gdat_string_pos174(X,Y) get_gdat_string((X),(Y),174) +#define get_gdat_v_str_pos174(X,Y) get_gdat_string((X),(Y),174) +#define get_gdat_bool_pos174(X,Y) get_gdat_bool((X),(Y),174) +#define get_gdat_int_pos174(X,Y) get_gdat_int((X),(Y),174) +#define get_gdat_llong_pos174(X,Y) get_gdat_llong((X),(Y),174) +#define get_gdat_float_pos174(X,Y) get_gdat_float((X),(Y),174) +#define get_gdat_uint_pos175(X,Y) get_gdat_uint((X),(Y),175) +#define get_gdat_ullong_pos175(X,Y) get_gdat_ullong((X),(Y),175) +#define get_gdat_ip_pos175(X,Y) get_gdat_ip((X),(Y),175) +#define get_gdat_ipv6_pos175(X,Y) get_gdat_ipv6((X),(Y),175) +#define get_gdat_string_pos175(X,Y) get_gdat_string((X),(Y),175) +#define get_gdat_v_str_pos175(X,Y) get_gdat_string((X),(Y),175) +#define get_gdat_bool_pos175(X,Y) get_gdat_bool((X),(Y),175) +#define get_gdat_int_pos175(X,Y) get_gdat_int((X),(Y),175) +#define get_gdat_llong_pos175(X,Y) get_gdat_llong((X),(Y),175) +#define get_gdat_float_pos175(X,Y) get_gdat_float((X),(Y),175) +#define get_gdat_uint_pos176(X,Y) get_gdat_uint((X),(Y),176) +#define get_gdat_ullong_pos176(X,Y) get_gdat_ullong((X),(Y),176) +#define get_gdat_ip_pos176(X,Y) get_gdat_ip((X),(Y),176) +#define get_gdat_ipv6_pos176(X,Y) get_gdat_ipv6((X),(Y),176) +#define get_gdat_string_pos176(X,Y) get_gdat_string((X),(Y),176) +#define get_gdat_v_str_pos176(X,Y) get_gdat_string((X),(Y),176) +#define get_gdat_bool_pos176(X,Y) get_gdat_bool((X),(Y),176) +#define get_gdat_int_pos176(X,Y) get_gdat_int((X),(Y),176) +#define get_gdat_llong_pos176(X,Y) get_gdat_llong((X),(Y),176) +#define get_gdat_float_pos176(X,Y) get_gdat_float((X),(Y),176) +#define get_gdat_uint_pos177(X,Y) get_gdat_uint((X),(Y),177) +#define get_gdat_ullong_pos177(X,Y) get_gdat_ullong((X),(Y),177) +#define get_gdat_ip_pos177(X,Y) get_gdat_ip((X),(Y),177) +#define get_gdat_ipv6_pos177(X,Y) get_gdat_ipv6((X),(Y),177) +#define get_gdat_string_pos177(X,Y) get_gdat_string((X),(Y),177) +#define get_gdat_v_str_pos177(X,Y) get_gdat_string((X),(Y),177) +#define get_gdat_bool_pos177(X,Y) get_gdat_bool((X),(Y),177) +#define get_gdat_int_pos177(X,Y) get_gdat_int((X),(Y),177) +#define get_gdat_llong_pos177(X,Y) get_gdat_llong((X),(Y),177) +#define get_gdat_float_pos177(X,Y) get_gdat_float((X),(Y),177) +#define get_gdat_uint_pos178(X,Y) get_gdat_uint((X),(Y),178) +#define get_gdat_ullong_pos178(X,Y) get_gdat_ullong((X),(Y),178) +#define get_gdat_ip_pos178(X,Y) get_gdat_ip((X),(Y),178) +#define get_gdat_ipv6_pos178(X,Y) get_gdat_ipv6((X),(Y),178) +#define get_gdat_string_pos178(X,Y) get_gdat_string((X),(Y),178) +#define get_gdat_v_str_pos178(X,Y) get_gdat_string((X),(Y),178) +#define get_gdat_bool_pos178(X,Y) get_gdat_bool((X),(Y),178) +#define get_gdat_int_pos178(X,Y) get_gdat_int((X),(Y),178) +#define get_gdat_llong_pos178(X,Y) get_gdat_llong((X),(Y),178) +#define get_gdat_float_pos178(X,Y) get_gdat_float((X),(Y),178) +#define get_gdat_uint_pos179(X,Y) get_gdat_uint((X),(Y),179) +#define get_gdat_ullong_pos179(X,Y) get_gdat_ullong((X),(Y),179) +#define get_gdat_ip_pos179(X,Y) get_gdat_ip((X),(Y),179) +#define get_gdat_ipv6_pos179(X,Y) get_gdat_ipv6((X),(Y),179) +#define get_gdat_string_pos179(X,Y) get_gdat_string((X),(Y),179) +#define get_gdat_v_str_pos179(X,Y) get_gdat_string((X),(Y),179) +#define get_gdat_bool_pos179(X,Y) get_gdat_bool((X),(Y),179) +#define get_gdat_int_pos179(X,Y) get_gdat_int((X),(Y),179) +#define get_gdat_llong_pos179(X,Y) get_gdat_llong((X),(Y),179) +#define get_gdat_float_pos179(X,Y) get_gdat_float((X),(Y),179) +#define get_gdat_uint_pos180(X,Y) get_gdat_uint((X),(Y),180) +#define get_gdat_ullong_pos180(X,Y) get_gdat_ullong((X),(Y),180) +#define get_gdat_ip_pos180(X,Y) get_gdat_ip((X),(Y),180) +#define get_gdat_ipv6_pos180(X,Y) get_gdat_ipv6((X),(Y),180) +#define get_gdat_string_pos180(X,Y) get_gdat_string((X),(Y),180) +#define get_gdat_v_str_pos180(X,Y) get_gdat_string((X),(Y),180) +#define get_gdat_bool_pos180(X,Y) get_gdat_bool((X),(Y),180) +#define get_gdat_int_pos180(X,Y) get_gdat_int((X),(Y),180) +#define get_gdat_llong_pos180(X,Y) get_gdat_llong((X),(Y),180) +#define get_gdat_float_pos180(X,Y) get_gdat_float((X),(Y),180) +#define get_gdat_uint_pos181(X,Y) get_gdat_uint((X),(Y),181) +#define get_gdat_ullong_pos181(X,Y) get_gdat_ullong((X),(Y),181) +#define get_gdat_ip_pos181(X,Y) get_gdat_ip((X),(Y),181) +#define get_gdat_ipv6_pos181(X,Y) get_gdat_ipv6((X),(Y),181) +#define get_gdat_string_pos181(X,Y) get_gdat_string((X),(Y),181) +#define get_gdat_v_str_pos181(X,Y) get_gdat_string((X),(Y),181) +#define get_gdat_bool_pos181(X,Y) get_gdat_bool((X),(Y),181) +#define get_gdat_int_pos181(X,Y) get_gdat_int((X),(Y),181) +#define get_gdat_llong_pos181(X,Y) get_gdat_llong((X),(Y),181) +#define get_gdat_float_pos181(X,Y) get_gdat_float((X),(Y),181) +#define get_gdat_uint_pos182(X,Y) get_gdat_uint((X),(Y),182) +#define get_gdat_ullong_pos182(X,Y) get_gdat_ullong((X),(Y),182) +#define get_gdat_ip_pos182(X,Y) get_gdat_ip((X),(Y),182) +#define get_gdat_ipv6_pos182(X,Y) get_gdat_ipv6((X),(Y),182) +#define get_gdat_string_pos182(X,Y) get_gdat_string((X),(Y),182) +#define get_gdat_v_str_pos182(X,Y) get_gdat_string((X),(Y),182) +#define get_gdat_bool_pos182(X,Y) get_gdat_bool((X),(Y),182) +#define get_gdat_int_pos182(X,Y) get_gdat_int((X),(Y),182) +#define get_gdat_llong_pos182(X,Y) get_gdat_llong((X),(Y),182) +#define get_gdat_float_pos182(X,Y) get_gdat_float((X),(Y),182) +#define get_gdat_uint_pos183(X,Y) get_gdat_uint((X),(Y),183) +#define get_gdat_ullong_pos183(X,Y) get_gdat_ullong((X),(Y),183) +#define get_gdat_ip_pos183(X,Y) get_gdat_ip((X),(Y),183) +#define get_gdat_ipv6_pos183(X,Y) get_gdat_ipv6((X),(Y),183) +#define get_gdat_string_pos183(X,Y) get_gdat_string((X),(Y),183) +#define get_gdat_v_str_pos183(X,Y) get_gdat_string((X),(Y),183) +#define get_gdat_bool_pos183(X,Y) get_gdat_bool((X),(Y),183) +#define get_gdat_int_pos183(X,Y) get_gdat_int((X),(Y),183) +#define get_gdat_llong_pos183(X,Y) get_gdat_llong((X),(Y),183) +#define get_gdat_float_pos183(X,Y) get_gdat_float((X),(Y),183) +#define get_gdat_uint_pos184(X,Y) get_gdat_uint((X),(Y),184) +#define get_gdat_ullong_pos184(X,Y) get_gdat_ullong((X),(Y),184) +#define get_gdat_ip_pos184(X,Y) get_gdat_ip((X),(Y),184) +#define get_gdat_ipv6_pos184(X,Y) get_gdat_ipv6((X),(Y),184) +#define get_gdat_string_pos184(X,Y) get_gdat_string((X),(Y),184) +#define get_gdat_v_str_pos184(X,Y) get_gdat_string((X),(Y),184) +#define get_gdat_bool_pos184(X,Y) get_gdat_bool((X),(Y),184) +#define get_gdat_int_pos184(X,Y) get_gdat_int((X),(Y),184) +#define get_gdat_llong_pos184(X,Y) get_gdat_llong((X),(Y),184) +#define get_gdat_float_pos184(X,Y) get_gdat_float((X),(Y),184) +#define get_gdat_uint_pos185(X,Y) get_gdat_uint((X),(Y),185) +#define get_gdat_ullong_pos185(X,Y) get_gdat_ullong((X),(Y),185) +#define get_gdat_ip_pos185(X,Y) get_gdat_ip((X),(Y),185) +#define get_gdat_ipv6_pos185(X,Y) get_gdat_ipv6((X),(Y),185) +#define get_gdat_string_pos185(X,Y) get_gdat_string((X),(Y),185) +#define get_gdat_v_str_pos185(X,Y) get_gdat_string((X),(Y),185) +#define get_gdat_bool_pos185(X,Y) get_gdat_bool((X),(Y),185) +#define get_gdat_int_pos185(X,Y) get_gdat_int((X),(Y),185) +#define get_gdat_llong_pos185(X,Y) get_gdat_llong((X),(Y),185) +#define get_gdat_float_pos185(X,Y) get_gdat_float((X),(Y),185) +#define get_gdat_uint_pos186(X,Y) get_gdat_uint((X),(Y),186) +#define get_gdat_ullong_pos186(X,Y) get_gdat_ullong((X),(Y),186) +#define get_gdat_ip_pos186(X,Y) get_gdat_ip((X),(Y),186) +#define get_gdat_ipv6_pos186(X,Y) get_gdat_ipv6((X),(Y),186) +#define get_gdat_string_pos186(X,Y) get_gdat_string((X),(Y),186) +#define get_gdat_v_str_pos186(X,Y) get_gdat_string((X),(Y),186) +#define get_gdat_bool_pos186(X,Y) get_gdat_bool((X),(Y),186) +#define get_gdat_int_pos186(X,Y) get_gdat_int((X),(Y),186) +#define get_gdat_llong_pos186(X,Y) get_gdat_llong((X),(Y),186) +#define get_gdat_float_pos186(X,Y) get_gdat_float((X),(Y),186) +#define get_gdat_uint_pos187(X,Y) get_gdat_uint((X),(Y),187) +#define get_gdat_ullong_pos187(X,Y) get_gdat_ullong((X),(Y),187) +#define get_gdat_ip_pos187(X,Y) get_gdat_ip((X),(Y),187) +#define get_gdat_ipv6_pos187(X,Y) get_gdat_ipv6((X),(Y),187) +#define get_gdat_string_pos187(X,Y) get_gdat_string((X),(Y),187) +#define get_gdat_v_str_pos187(X,Y) get_gdat_string((X),(Y),187) +#define get_gdat_bool_pos187(X,Y) get_gdat_bool((X),(Y),187) +#define get_gdat_int_pos187(X,Y) get_gdat_int((X),(Y),187) +#define get_gdat_llong_pos187(X,Y) get_gdat_llong((X),(Y),187) +#define get_gdat_float_pos187(X,Y) get_gdat_float((X),(Y),187) +#define get_gdat_uint_pos188(X,Y) get_gdat_uint((X),(Y),188) +#define get_gdat_ullong_pos188(X,Y) get_gdat_ullong((X),(Y),188) +#define get_gdat_ip_pos188(X,Y) get_gdat_ip((X),(Y),188) +#define get_gdat_ipv6_pos188(X,Y) get_gdat_ipv6((X),(Y),188) +#define get_gdat_string_pos188(X,Y) get_gdat_string((X),(Y),188) +#define get_gdat_v_str_pos188(X,Y) get_gdat_string((X),(Y),188) +#define get_gdat_bool_pos188(X,Y) get_gdat_bool((X),(Y),188) +#define get_gdat_int_pos188(X,Y) get_gdat_int((X),(Y),188) +#define get_gdat_llong_pos188(X,Y) get_gdat_llong((X),(Y),188) +#define get_gdat_float_pos188(X,Y) get_gdat_float((X),(Y),188) +#define get_gdat_uint_pos189(X,Y) get_gdat_uint((X),(Y),189) +#define get_gdat_ullong_pos189(X,Y) get_gdat_ullong((X),(Y),189) +#define get_gdat_ip_pos189(X,Y) get_gdat_ip((X),(Y),189) +#define get_gdat_ipv6_pos189(X,Y) get_gdat_ipv6((X),(Y),189) +#define get_gdat_string_pos189(X,Y) get_gdat_string((X),(Y),189) +#define get_gdat_v_str_pos189(X,Y) get_gdat_string((X),(Y),189) +#define get_gdat_bool_pos189(X,Y) get_gdat_bool((X),(Y),189) +#define get_gdat_int_pos189(X,Y) get_gdat_int((X),(Y),189) +#define get_gdat_llong_pos189(X,Y) get_gdat_llong((X),(Y),189) +#define get_gdat_float_pos189(X,Y) get_gdat_float((X),(Y),189) +#define get_gdat_uint_pos190(X,Y) get_gdat_uint((X),(Y),190) +#define get_gdat_ullong_pos190(X,Y) get_gdat_ullong((X),(Y),190) +#define get_gdat_ip_pos190(X,Y) get_gdat_ip((X),(Y),190) +#define get_gdat_ipv6_pos190(X,Y) get_gdat_ipv6((X),(Y),190) +#define get_gdat_string_pos190(X,Y) get_gdat_string((X),(Y),190) +#define get_gdat_v_str_pos190(X,Y) get_gdat_string((X),(Y),190) +#define get_gdat_bool_pos190(X,Y) get_gdat_bool((X),(Y),190) +#define get_gdat_int_pos190(X,Y) get_gdat_int((X),(Y),190) +#define get_gdat_llong_pos190(X,Y) get_gdat_llong((X),(Y),190) +#define get_gdat_float_pos190(X,Y) get_gdat_float((X),(Y),190) +#define get_gdat_uint_pos191(X,Y) get_gdat_uint((X),(Y),191) +#define get_gdat_ullong_pos191(X,Y) get_gdat_ullong((X),(Y),191) +#define get_gdat_ip_pos191(X,Y) get_gdat_ip((X),(Y),191) +#define get_gdat_ipv6_pos191(X,Y) get_gdat_ipv6((X),(Y),191) +#define get_gdat_string_pos191(X,Y) get_gdat_string((X),(Y),191) +#define get_gdat_v_str_pos191(X,Y) get_gdat_string((X),(Y),191) +#define get_gdat_bool_pos191(X,Y) get_gdat_bool((X),(Y),191) +#define get_gdat_int_pos191(X,Y) get_gdat_int((X),(Y),191) +#define get_gdat_llong_pos191(X,Y) get_gdat_llong((X),(Y),191) +#define get_gdat_float_pos191(X,Y) get_gdat_float((X),(Y),191) +#define get_gdat_uint_pos192(X,Y) get_gdat_uint((X),(Y),192) +#define get_gdat_ullong_pos192(X,Y) get_gdat_ullong((X),(Y),192) +#define get_gdat_ip_pos192(X,Y) get_gdat_ip((X),(Y),192) +#define get_gdat_ipv6_pos192(X,Y) get_gdat_ipv6((X),(Y),192) +#define get_gdat_string_pos192(X,Y) get_gdat_string((X),(Y),192) +#define get_gdat_v_str_pos192(X,Y) get_gdat_string((X),(Y),192) +#define get_gdat_bool_pos192(X,Y) get_gdat_bool((X),(Y),192) +#define get_gdat_int_pos192(X,Y) get_gdat_int((X),(Y),192) +#define get_gdat_llong_pos192(X,Y) get_gdat_llong((X),(Y),192) +#define get_gdat_float_pos192(X,Y) get_gdat_float((X),(Y),192) +#define get_gdat_uint_pos193(X,Y) get_gdat_uint((X),(Y),193) +#define get_gdat_ullong_pos193(X,Y) get_gdat_ullong((X),(Y),193) +#define get_gdat_ip_pos193(X,Y) get_gdat_ip((X),(Y),193) +#define get_gdat_ipv6_pos193(X,Y) get_gdat_ipv6((X),(Y),193) +#define get_gdat_string_pos193(X,Y) get_gdat_string((X),(Y),193) +#define get_gdat_v_str_pos193(X,Y) get_gdat_string((X),(Y),193) +#define get_gdat_bool_pos193(X,Y) get_gdat_bool((X),(Y),193) +#define get_gdat_int_pos193(X,Y) get_gdat_int((X),(Y),193) +#define get_gdat_llong_pos193(X,Y) get_gdat_llong((X),(Y),193) +#define get_gdat_float_pos193(X,Y) get_gdat_float((X),(Y),193) +#define get_gdat_uint_pos194(X,Y) get_gdat_uint((X),(Y),194) +#define get_gdat_ullong_pos194(X,Y) get_gdat_ullong((X),(Y),194) +#define get_gdat_ip_pos194(X,Y) get_gdat_ip((X),(Y),194) +#define get_gdat_ipv6_pos194(X,Y) get_gdat_ipv6((X),(Y),194) +#define get_gdat_string_pos194(X,Y) get_gdat_string((X),(Y),194) +#define get_gdat_v_str_pos194(X,Y) get_gdat_string((X),(Y),194) +#define get_gdat_bool_pos194(X,Y) get_gdat_bool((X),(Y),194) +#define get_gdat_int_pos194(X,Y) get_gdat_int((X),(Y),194) +#define get_gdat_llong_pos194(X,Y) get_gdat_llong((X),(Y),194) +#define get_gdat_float_pos194(X,Y) get_gdat_float((X),(Y),194) +#define get_gdat_uint_pos195(X,Y) get_gdat_uint((X),(Y),195) +#define get_gdat_ullong_pos195(X,Y) get_gdat_ullong((X),(Y),195) +#define get_gdat_ip_pos195(X,Y) get_gdat_ip((X),(Y),195) +#define get_gdat_ipv6_pos195(X,Y) get_gdat_ipv6((X),(Y),195) +#define get_gdat_string_pos195(X,Y) get_gdat_string((X),(Y),195) +#define get_gdat_v_str_pos195(X,Y) get_gdat_string((X),(Y),195) +#define get_gdat_bool_pos195(X,Y) get_gdat_bool((X),(Y),195) +#define get_gdat_int_pos195(X,Y) get_gdat_int((X),(Y),195) +#define get_gdat_llong_pos195(X,Y) get_gdat_llong((X),(Y),195) +#define get_gdat_float_pos195(X,Y) get_gdat_float((X),(Y),195) +#define get_gdat_uint_pos196(X,Y) get_gdat_uint((X),(Y),196) +#define get_gdat_ullong_pos196(X,Y) get_gdat_ullong((X),(Y),196) +#define get_gdat_ip_pos196(X,Y) get_gdat_ip((X),(Y),196) +#define get_gdat_ipv6_pos196(X,Y) get_gdat_ipv6((X),(Y),196) +#define get_gdat_string_pos196(X,Y) get_gdat_string((X),(Y),196) +#define get_gdat_v_str_pos196(X,Y) get_gdat_string((X),(Y),196) +#define get_gdat_bool_pos196(X,Y) get_gdat_bool((X),(Y),196) +#define get_gdat_int_pos196(X,Y) get_gdat_int((X),(Y),196) +#define get_gdat_llong_pos196(X,Y) get_gdat_llong((X),(Y),196) +#define get_gdat_float_pos196(X,Y) get_gdat_float((X),(Y),196) +#define get_gdat_uint_pos197(X,Y) get_gdat_uint((X),(Y),197) +#define get_gdat_ullong_pos197(X,Y) get_gdat_ullong((X),(Y),197) +#define get_gdat_ip_pos197(X,Y) get_gdat_ip((X),(Y),197) +#define get_gdat_ipv6_pos197(X,Y) get_gdat_ipv6((X),(Y),197) +#define get_gdat_string_pos197(X,Y) get_gdat_string((X),(Y),197) +#define get_gdat_v_str_pos197(X,Y) get_gdat_string((X),(Y),197) +#define get_gdat_bool_pos197(X,Y) get_gdat_bool((X),(Y),197) +#define get_gdat_int_pos197(X,Y) get_gdat_int((X),(Y),197) +#define get_gdat_llong_pos197(X,Y) get_gdat_llong((X),(Y),197) +#define get_gdat_float_pos197(X,Y) get_gdat_float((X),(Y),197) +#define get_gdat_uint_pos198(X,Y) get_gdat_uint((X),(Y),198) +#define get_gdat_ullong_pos198(X,Y) get_gdat_ullong((X),(Y),198) +#define get_gdat_ip_pos198(X,Y) get_gdat_ip((X),(Y),198) +#define get_gdat_ipv6_pos198(X,Y) get_gdat_ipv6((X),(Y),198) +#define get_gdat_string_pos198(X,Y) get_gdat_string((X),(Y),198) +#define get_gdat_v_str_pos198(X,Y) get_gdat_string((X),(Y),198) +#define get_gdat_bool_pos198(X,Y) get_gdat_bool((X),(Y),198) +#define get_gdat_int_pos198(X,Y) get_gdat_int((X),(Y),198) +#define get_gdat_llong_pos198(X,Y) get_gdat_llong((X),(Y),198) +#define get_gdat_float_pos198(X,Y) get_gdat_float((X),(Y),198) +#define get_gdat_uint_pos199(X,Y) get_gdat_uint((X),(Y),199) +#define get_gdat_ullong_pos199(X,Y) get_gdat_ullong((X),(Y),199) +#define get_gdat_ip_pos199(X,Y) get_gdat_ip((X),(Y),199) +#define get_gdat_ipv6_pos199(X,Y) get_gdat_ipv6((X),(Y),199) +#define get_gdat_string_pos199(X,Y) get_gdat_string((X),(Y),199) +#define get_gdat_v_str_pos199(X,Y) get_gdat_string((X),(Y),199) +#define get_gdat_bool_pos199(X,Y) get_gdat_bool((X),(Y),199) +#define get_gdat_int_pos199(X,Y) get_gdat_int((X),(Y),199) +#define get_gdat_llong_pos199(X,Y) get_gdat_llong((X),(Y),199) +#define get_gdat_float_pos199(X,Y) get_gdat_float((X),(Y),199) +#define get_gdat_uint_pos200(X,Y) get_gdat_uint((X),(Y),200) +#define get_gdat_ullong_pos200(X,Y) get_gdat_ullong((X),(Y),200) +#define get_gdat_ip_pos200(X,Y) get_gdat_ip((X),(Y),200) +#define get_gdat_ipv6_pos200(X,Y) get_gdat_ipv6((X),(Y),200) +#define get_gdat_string_pos200(X,Y) get_gdat_string((X),(Y),200) +#define get_gdat_v_str_pos200(X,Y) get_gdat_string((X),(Y),200) +#define get_gdat_bool_pos200(X,Y) get_gdat_bool((X),(Y),200) +#define get_gdat_int_pos200(X,Y) get_gdat_int((X),(Y),200) +#define get_gdat_llong_pos200(X,Y) get_gdat_llong((X),(Y),200) +#define get_gdat_float_pos200(X,Y) get_gdat_float((X),(Y),200) +#define get_gdat_uint_pos201(X,Y) get_gdat_uint((X),(Y),201) +#define get_gdat_ullong_pos201(X,Y) get_gdat_ullong((X),(Y),201) +#define get_gdat_ip_pos201(X,Y) get_gdat_ip((X),(Y),201) +#define get_gdat_ipv6_pos201(X,Y) get_gdat_ipv6((X),(Y),201) +#define get_gdat_string_pos201(X,Y) get_gdat_string((X),(Y),201) +#define get_gdat_v_str_pos201(X,Y) get_gdat_string((X),(Y),201) +#define get_gdat_bool_pos201(X,Y) get_gdat_bool((X),(Y),201) +#define get_gdat_int_pos201(X,Y) get_gdat_int((X),(Y),201) +#define get_gdat_llong_pos201(X,Y) get_gdat_llong((X),(Y),201) +#define get_gdat_float_pos201(X,Y) get_gdat_float((X),(Y),201) +#define get_gdat_uint_pos202(X,Y) get_gdat_uint((X),(Y),202) +#define get_gdat_ullong_pos202(X,Y) get_gdat_ullong((X),(Y),202) +#define get_gdat_ip_pos202(X,Y) get_gdat_ip((X),(Y),202) +#define get_gdat_ipv6_pos202(X,Y) get_gdat_ipv6((X),(Y),202) +#define get_gdat_string_pos202(X,Y) get_gdat_string((X),(Y),202) +#define get_gdat_v_str_pos202(X,Y) get_gdat_string((X),(Y),202) +#define get_gdat_bool_pos202(X,Y) get_gdat_bool((X),(Y),202) +#define get_gdat_int_pos202(X,Y) get_gdat_int((X),(Y),202) +#define get_gdat_llong_pos202(X,Y) get_gdat_llong((X),(Y),202) +#define get_gdat_float_pos202(X,Y) get_gdat_float((X),(Y),202) +#define get_gdat_uint_pos203(X,Y) get_gdat_uint((X),(Y),203) +#define get_gdat_ullong_pos203(X,Y) get_gdat_ullong((X),(Y),203) +#define get_gdat_ip_pos203(X,Y) get_gdat_ip((X),(Y),203) +#define get_gdat_ipv6_pos203(X,Y) get_gdat_ipv6((X),(Y),203) +#define get_gdat_string_pos203(X,Y) get_gdat_string((X),(Y),203) +#define get_gdat_v_str_pos203(X,Y) get_gdat_string((X),(Y),203) +#define get_gdat_bool_pos203(X,Y) get_gdat_bool((X),(Y),203) +#define get_gdat_int_pos203(X,Y) get_gdat_int((X),(Y),203) +#define get_gdat_llong_pos203(X,Y) get_gdat_llong((X),(Y),203) +#define get_gdat_float_pos203(X,Y) get_gdat_float((X),(Y),203) +#define get_gdat_uint_pos204(X,Y) get_gdat_uint((X),(Y),204) +#define get_gdat_ullong_pos204(X,Y) get_gdat_ullong((X),(Y),204) +#define get_gdat_ip_pos204(X,Y) get_gdat_ip((X),(Y),204) +#define get_gdat_ipv6_pos204(X,Y) get_gdat_ipv6((X),(Y),204) +#define get_gdat_string_pos204(X,Y) get_gdat_string((X),(Y),204) +#define get_gdat_v_str_pos204(X,Y) get_gdat_string((X),(Y),204) +#define get_gdat_bool_pos204(X,Y) get_gdat_bool((X),(Y),204) +#define get_gdat_int_pos204(X,Y) get_gdat_int((X),(Y),204) +#define get_gdat_llong_pos204(X,Y) get_gdat_llong((X),(Y),204) +#define get_gdat_float_pos204(X,Y) get_gdat_float((X),(Y),204) +#define get_gdat_uint_pos205(X,Y) get_gdat_uint((X),(Y),205) +#define get_gdat_ullong_pos205(X,Y) get_gdat_ullong((X),(Y),205) +#define get_gdat_ip_pos205(X,Y) get_gdat_ip((X),(Y),205) +#define get_gdat_ipv6_pos205(X,Y) get_gdat_ipv6((X),(Y),205) +#define get_gdat_string_pos205(X,Y) get_gdat_string((X),(Y),205) +#define get_gdat_v_str_pos205(X,Y) get_gdat_string((X),(Y),205) +#define get_gdat_bool_pos205(X,Y) get_gdat_bool((X),(Y),205) +#define get_gdat_int_pos205(X,Y) get_gdat_int((X),(Y),205) +#define get_gdat_llong_pos205(X,Y) get_gdat_llong((X),(Y),205) +#define get_gdat_float_pos205(X,Y) get_gdat_float((X),(Y),205) +#define get_gdat_uint_pos206(X,Y) get_gdat_uint((X),(Y),206) +#define get_gdat_ullong_pos206(X,Y) get_gdat_ullong((X),(Y),206) +#define get_gdat_ip_pos206(X,Y) get_gdat_ip((X),(Y),206) +#define get_gdat_ipv6_pos206(X,Y) get_gdat_ipv6((X),(Y),206) +#define get_gdat_string_pos206(X,Y) get_gdat_string((X),(Y),206) +#define get_gdat_v_str_pos206(X,Y) get_gdat_string((X),(Y),206) +#define get_gdat_bool_pos206(X,Y) get_gdat_bool((X),(Y),206) +#define get_gdat_int_pos206(X,Y) get_gdat_int((X),(Y),206) +#define get_gdat_llong_pos206(X,Y) get_gdat_llong((X),(Y),206) +#define get_gdat_float_pos206(X,Y) get_gdat_float((X),(Y),206) +#define get_gdat_uint_pos207(X,Y) get_gdat_uint((X),(Y),207) +#define get_gdat_ullong_pos207(X,Y) get_gdat_ullong((X),(Y),207) +#define get_gdat_ip_pos207(X,Y) get_gdat_ip((X),(Y),207) +#define get_gdat_ipv6_pos207(X,Y) get_gdat_ipv6((X),(Y),207) +#define get_gdat_string_pos207(X,Y) get_gdat_string((X),(Y),207) +#define get_gdat_v_str_pos207(X,Y) get_gdat_string((X),(Y),207) +#define get_gdat_bool_pos207(X,Y) get_gdat_bool((X),(Y),207) +#define get_gdat_int_pos207(X,Y) get_gdat_int((X),(Y),207) +#define get_gdat_llong_pos207(X,Y) get_gdat_llong((X),(Y),207) +#define get_gdat_float_pos207(X,Y) get_gdat_float((X),(Y),207) +#define get_gdat_uint_pos208(X,Y) get_gdat_uint((X),(Y),208) +#define get_gdat_ullong_pos208(X,Y) get_gdat_ullong((X),(Y),208) +#define get_gdat_ip_pos208(X,Y) get_gdat_ip((X),(Y),208) +#define get_gdat_ipv6_pos208(X,Y) get_gdat_ipv6((X),(Y),208) +#define get_gdat_string_pos208(X,Y) get_gdat_string((X),(Y),208) +#define get_gdat_v_str_pos208(X,Y) get_gdat_string((X),(Y),208) +#define get_gdat_bool_pos208(X,Y) get_gdat_bool((X),(Y),208) +#define get_gdat_int_pos208(X,Y) get_gdat_int((X),(Y),208) +#define get_gdat_llong_pos208(X,Y) get_gdat_llong((X),(Y),208) +#define get_gdat_float_pos208(X,Y) get_gdat_float((X),(Y),208) +#define get_gdat_uint_pos209(X,Y) get_gdat_uint((X),(Y),209) +#define get_gdat_ullong_pos209(X,Y) get_gdat_ullong((X),(Y),209) +#define get_gdat_ip_pos209(X,Y) get_gdat_ip((X),(Y),209) +#define get_gdat_ipv6_pos209(X,Y) get_gdat_ipv6((X),(Y),209) +#define get_gdat_string_pos209(X,Y) get_gdat_string((X),(Y),209) +#define get_gdat_v_str_pos209(X,Y) get_gdat_string((X),(Y),209) +#define get_gdat_bool_pos209(X,Y) get_gdat_bool((X),(Y),209) +#define get_gdat_int_pos209(X,Y) get_gdat_int((X),(Y),209) +#define get_gdat_llong_pos209(X,Y) get_gdat_llong((X),(Y),209) +#define get_gdat_float_pos209(X,Y) get_gdat_float((X),(Y),209) +#define get_gdat_uint_pos210(X,Y) get_gdat_uint((X),(Y),210) +#define get_gdat_ullong_pos210(X,Y) get_gdat_ullong((X),(Y),210) +#define get_gdat_ip_pos210(X,Y) get_gdat_ip((X),(Y),210) +#define get_gdat_ipv6_pos210(X,Y) get_gdat_ipv6((X),(Y),210) +#define get_gdat_string_pos210(X,Y) get_gdat_string((X),(Y),210) +#define get_gdat_v_str_pos210(X,Y) get_gdat_string((X),(Y),210) +#define get_gdat_bool_pos210(X,Y) get_gdat_bool((X),(Y),210) +#define get_gdat_int_pos210(X,Y) get_gdat_int((X),(Y),210) +#define get_gdat_llong_pos210(X,Y) get_gdat_llong((X),(Y),210) +#define get_gdat_float_pos210(X,Y) get_gdat_float((X),(Y),210) +#define get_gdat_uint_pos211(X,Y) get_gdat_uint((X),(Y),211) +#define get_gdat_ullong_pos211(X,Y) get_gdat_ullong((X),(Y),211) +#define get_gdat_ip_pos211(X,Y) get_gdat_ip((X),(Y),211) +#define get_gdat_ipv6_pos211(X,Y) get_gdat_ipv6((X),(Y),211) +#define get_gdat_string_pos211(X,Y) get_gdat_string((X),(Y),211) +#define get_gdat_v_str_pos211(X,Y) get_gdat_string((X),(Y),211) +#define get_gdat_bool_pos211(X,Y) get_gdat_bool((X),(Y),211) +#define get_gdat_int_pos211(X,Y) get_gdat_int((X),(Y),211) +#define get_gdat_llong_pos211(X,Y) get_gdat_llong((X),(Y),211) +#define get_gdat_float_pos211(X,Y) get_gdat_float((X),(Y),211) +#define get_gdat_uint_pos212(X,Y) get_gdat_uint((X),(Y),212) +#define get_gdat_ullong_pos212(X,Y) get_gdat_ullong((X),(Y),212) +#define get_gdat_ip_pos212(X,Y) get_gdat_ip((X),(Y),212) +#define get_gdat_ipv6_pos212(X,Y) get_gdat_ipv6((X),(Y),212) +#define get_gdat_string_pos212(X,Y) get_gdat_string((X),(Y),212) +#define get_gdat_v_str_pos212(X,Y) get_gdat_string((X),(Y),212) +#define get_gdat_bool_pos212(X,Y) get_gdat_bool((X),(Y),212) +#define get_gdat_int_pos212(X,Y) get_gdat_int((X),(Y),212) +#define get_gdat_llong_pos212(X,Y) get_gdat_llong((X),(Y),212) +#define get_gdat_float_pos212(X,Y) get_gdat_float((X),(Y),212) +#define get_gdat_uint_pos213(X,Y) get_gdat_uint((X),(Y),213) +#define get_gdat_ullong_pos213(X,Y) get_gdat_ullong((X),(Y),213) +#define get_gdat_ip_pos213(X,Y) get_gdat_ip((X),(Y),213) +#define get_gdat_ipv6_pos213(X,Y) get_gdat_ipv6((X),(Y),213) +#define get_gdat_string_pos213(X,Y) get_gdat_string((X),(Y),213) +#define get_gdat_v_str_pos213(X,Y) get_gdat_string((X),(Y),213) +#define get_gdat_bool_pos213(X,Y) get_gdat_bool((X),(Y),213) +#define get_gdat_int_pos213(X,Y) get_gdat_int((X),(Y),213) +#define get_gdat_llong_pos213(X,Y) get_gdat_llong((X),(Y),213) +#define get_gdat_float_pos213(X,Y) get_gdat_float((X),(Y),213) +#define get_gdat_uint_pos214(X,Y) get_gdat_uint((X),(Y),214) +#define get_gdat_ullong_pos214(X,Y) get_gdat_ullong((X),(Y),214) +#define get_gdat_ip_pos214(X,Y) get_gdat_ip((X),(Y),214) +#define get_gdat_ipv6_pos214(X,Y) get_gdat_ipv6((X),(Y),214) +#define get_gdat_string_pos214(X,Y) get_gdat_string((X),(Y),214) +#define get_gdat_v_str_pos214(X,Y) get_gdat_string((X),(Y),214) +#define get_gdat_bool_pos214(X,Y) get_gdat_bool((X),(Y),214) +#define get_gdat_int_pos214(X,Y) get_gdat_int((X),(Y),214) +#define get_gdat_llong_pos214(X,Y) get_gdat_llong((X),(Y),214) +#define get_gdat_float_pos214(X,Y) get_gdat_float((X),(Y),214) +#define get_gdat_uint_pos215(X,Y) get_gdat_uint((X),(Y),215) +#define get_gdat_ullong_pos215(X,Y) get_gdat_ullong((X),(Y),215) +#define get_gdat_ip_pos215(X,Y) get_gdat_ip((X),(Y),215) +#define get_gdat_ipv6_pos215(X,Y) get_gdat_ipv6((X),(Y),215) +#define get_gdat_string_pos215(X,Y) get_gdat_string((X),(Y),215) +#define get_gdat_v_str_pos215(X,Y) get_gdat_string((X),(Y),215) +#define get_gdat_bool_pos215(X,Y) get_gdat_bool((X),(Y),215) +#define get_gdat_int_pos215(X,Y) get_gdat_int((X),(Y),215) +#define get_gdat_llong_pos215(X,Y) get_gdat_llong((X),(Y),215) +#define get_gdat_float_pos215(X,Y) get_gdat_float((X),(Y),215) +#define get_gdat_uint_pos216(X,Y) get_gdat_uint((X),(Y),216) +#define get_gdat_ullong_pos216(X,Y) get_gdat_ullong((X),(Y),216) +#define get_gdat_ip_pos216(X,Y) get_gdat_ip((X),(Y),216) +#define get_gdat_ipv6_pos216(X,Y) get_gdat_ipv6((X),(Y),216) +#define get_gdat_string_pos216(X,Y) get_gdat_string((X),(Y),216) +#define get_gdat_v_str_pos216(X,Y) get_gdat_string((X),(Y),216) +#define get_gdat_bool_pos216(X,Y) get_gdat_bool((X),(Y),216) +#define get_gdat_int_pos216(X,Y) get_gdat_int((X),(Y),216) +#define get_gdat_llong_pos216(X,Y) get_gdat_llong((X),(Y),216) +#define get_gdat_float_pos216(X,Y) get_gdat_float((X),(Y),216) +#define get_gdat_uint_pos217(X,Y) get_gdat_uint((X),(Y),217) +#define get_gdat_ullong_pos217(X,Y) get_gdat_ullong((X),(Y),217) +#define get_gdat_ip_pos217(X,Y) get_gdat_ip((X),(Y),217) +#define get_gdat_ipv6_pos217(X,Y) get_gdat_ipv6((X),(Y),217) +#define get_gdat_string_pos217(X,Y) get_gdat_string((X),(Y),217) +#define get_gdat_v_str_pos217(X,Y) get_gdat_string((X),(Y),217) +#define get_gdat_bool_pos217(X,Y) get_gdat_bool((X),(Y),217) +#define get_gdat_int_pos217(X,Y) get_gdat_int((X),(Y),217) +#define get_gdat_llong_pos217(X,Y) get_gdat_llong((X),(Y),217) +#define get_gdat_float_pos217(X,Y) get_gdat_float((X),(Y),217) +#define get_gdat_uint_pos218(X,Y) get_gdat_uint((X),(Y),218) +#define get_gdat_ullong_pos218(X,Y) get_gdat_ullong((X),(Y),218) +#define get_gdat_ip_pos218(X,Y) get_gdat_ip((X),(Y),218) +#define get_gdat_ipv6_pos218(X,Y) get_gdat_ipv6((X),(Y),218) +#define get_gdat_string_pos218(X,Y) get_gdat_string((X),(Y),218) +#define get_gdat_v_str_pos218(X,Y) get_gdat_string((X),(Y),218) +#define get_gdat_bool_pos218(X,Y) get_gdat_bool((X),(Y),218) +#define get_gdat_int_pos218(X,Y) get_gdat_int((X),(Y),218) +#define get_gdat_llong_pos218(X,Y) get_gdat_llong((X),(Y),218) +#define get_gdat_float_pos218(X,Y) get_gdat_float((X),(Y),218) +#define get_gdat_uint_pos219(X,Y) get_gdat_uint((X),(Y),219) +#define get_gdat_ullong_pos219(X,Y) get_gdat_ullong((X),(Y),219) +#define get_gdat_ip_pos219(X,Y) get_gdat_ip((X),(Y),219) +#define get_gdat_ipv6_pos219(X,Y) get_gdat_ipv6((X),(Y),219) +#define get_gdat_string_pos219(X,Y) get_gdat_string((X),(Y),219) +#define get_gdat_v_str_pos219(X,Y) get_gdat_string((X),(Y),219) +#define get_gdat_bool_pos219(X,Y) get_gdat_bool((X),(Y),219) +#define get_gdat_int_pos219(X,Y) get_gdat_int((X),(Y),219) +#define get_gdat_llong_pos219(X,Y) get_gdat_llong((X),(Y),219) +#define get_gdat_float_pos219(X,Y) get_gdat_float((X),(Y),219) +#define get_gdat_uint_pos220(X,Y) get_gdat_uint((X),(Y),220) +#define get_gdat_ullong_pos220(X,Y) get_gdat_ullong((X),(Y),220) +#define get_gdat_ip_pos220(X,Y) get_gdat_ip((X),(Y),220) +#define get_gdat_ipv6_pos220(X,Y) get_gdat_ipv6((X),(Y),220) +#define get_gdat_string_pos220(X,Y) get_gdat_string((X),(Y),220) +#define get_gdat_v_str_pos220(X,Y) get_gdat_string((X),(Y),220) +#define get_gdat_bool_pos220(X,Y) get_gdat_bool((X),(Y),220) +#define get_gdat_int_pos220(X,Y) get_gdat_int((X),(Y),220) +#define get_gdat_llong_pos220(X,Y) get_gdat_llong((X),(Y),220) +#define get_gdat_float_pos220(X,Y) get_gdat_float((X),(Y),220) +#define get_gdat_uint_pos221(X,Y) get_gdat_uint((X),(Y),221) +#define get_gdat_ullong_pos221(X,Y) get_gdat_ullong((X),(Y),221) +#define get_gdat_ip_pos221(X,Y) get_gdat_ip((X),(Y),221) +#define get_gdat_ipv6_pos221(X,Y) get_gdat_ipv6((X),(Y),221) +#define get_gdat_string_pos221(X,Y) get_gdat_string((X),(Y),221) +#define get_gdat_v_str_pos221(X,Y) get_gdat_string((X),(Y),221) +#define get_gdat_bool_pos221(X,Y) get_gdat_bool((X),(Y),221) +#define get_gdat_int_pos221(X,Y) get_gdat_int((X),(Y),221) +#define get_gdat_llong_pos221(X,Y) get_gdat_llong((X),(Y),221) +#define get_gdat_float_pos221(X,Y) get_gdat_float((X),(Y),221) +#define get_gdat_uint_pos222(X,Y) get_gdat_uint((X),(Y),222) +#define get_gdat_ullong_pos222(X,Y) get_gdat_ullong((X),(Y),222) +#define get_gdat_ip_pos222(X,Y) get_gdat_ip((X),(Y),222) +#define get_gdat_ipv6_pos222(X,Y) get_gdat_ipv6((X),(Y),222) +#define get_gdat_string_pos222(X,Y) get_gdat_string((X),(Y),222) +#define get_gdat_v_str_pos222(X,Y) get_gdat_string((X),(Y),222) +#define get_gdat_bool_pos222(X,Y) get_gdat_bool((X),(Y),222) +#define get_gdat_int_pos222(X,Y) get_gdat_int((X),(Y),222) +#define get_gdat_llong_pos222(X,Y) get_gdat_llong((X),(Y),222) +#define get_gdat_float_pos222(X,Y) get_gdat_float((X),(Y),222) +#define get_gdat_uint_pos223(X,Y) get_gdat_uint((X),(Y),223) +#define get_gdat_ullong_pos223(X,Y) get_gdat_ullong((X),(Y),223) +#define get_gdat_ip_pos223(X,Y) get_gdat_ip((X),(Y),223) +#define get_gdat_ipv6_pos223(X,Y) get_gdat_ipv6((X),(Y),223) +#define get_gdat_string_pos223(X,Y) get_gdat_string((X),(Y),223) +#define get_gdat_v_str_pos223(X,Y) get_gdat_string((X),(Y),223) +#define get_gdat_bool_pos223(X,Y) get_gdat_bool((X),(Y),223) +#define get_gdat_int_pos223(X,Y) get_gdat_int((X),(Y),223) +#define get_gdat_llong_pos223(X,Y) get_gdat_llong((X),(Y),223) +#define get_gdat_float_pos223(X,Y) get_gdat_float((X),(Y),223) +#define get_gdat_uint_pos224(X,Y) get_gdat_uint((X),(Y),224) +#define get_gdat_ullong_pos224(X,Y) get_gdat_ullong((X),(Y),224) +#define get_gdat_ip_pos224(X,Y) get_gdat_ip((X),(Y),224) +#define get_gdat_ipv6_pos224(X,Y) get_gdat_ipv6((X),(Y),224) +#define get_gdat_string_pos224(X,Y) get_gdat_string((X),(Y),224) +#define get_gdat_v_str_pos224(X,Y) get_gdat_string((X),(Y),224) +#define get_gdat_bool_pos224(X,Y) get_gdat_bool((X),(Y),224) +#define get_gdat_int_pos224(X,Y) get_gdat_int((X),(Y),224) +#define get_gdat_llong_pos224(X,Y) get_gdat_llong((X),(Y),224) +#define get_gdat_float_pos224(X,Y) get_gdat_float((X),(Y),224) +#define get_gdat_uint_pos225(X,Y) get_gdat_uint((X),(Y),225) +#define get_gdat_ullong_pos225(X,Y) get_gdat_ullong((X),(Y),225) +#define get_gdat_ip_pos225(X,Y) get_gdat_ip((X),(Y),225) +#define get_gdat_ipv6_pos225(X,Y) get_gdat_ipv6((X),(Y),225) +#define get_gdat_string_pos225(X,Y) get_gdat_string((X),(Y),225) +#define get_gdat_v_str_pos225(X,Y) get_gdat_string((X),(Y),225) +#define get_gdat_bool_pos225(X,Y) get_gdat_bool((X),(Y),225) +#define get_gdat_int_pos225(X,Y) get_gdat_int((X),(Y),225) +#define get_gdat_llong_pos225(X,Y) get_gdat_llong((X),(Y),225) +#define get_gdat_float_pos225(X,Y) get_gdat_float((X),(Y),225) +#define get_gdat_uint_pos226(X,Y) get_gdat_uint((X),(Y),226) +#define get_gdat_ullong_pos226(X,Y) get_gdat_ullong((X),(Y),226) +#define get_gdat_ip_pos226(X,Y) get_gdat_ip((X),(Y),226) +#define get_gdat_ipv6_pos226(X,Y) get_gdat_ipv6((X),(Y),226) +#define get_gdat_string_pos226(X,Y) get_gdat_string((X),(Y),226) +#define get_gdat_v_str_pos226(X,Y) get_gdat_string((X),(Y),226) +#define get_gdat_bool_pos226(X,Y) get_gdat_bool((X),(Y),226) +#define get_gdat_int_pos226(X,Y) get_gdat_int((X),(Y),226) +#define get_gdat_llong_pos226(X,Y) get_gdat_llong((X),(Y),226) +#define get_gdat_float_pos226(X,Y) get_gdat_float((X),(Y),226) +#define get_gdat_uint_pos227(X,Y) get_gdat_uint((X),(Y),227) +#define get_gdat_ullong_pos227(X,Y) get_gdat_ullong((X),(Y),227) +#define get_gdat_ip_pos227(X,Y) get_gdat_ip((X),(Y),227) +#define get_gdat_ipv6_pos227(X,Y) get_gdat_ipv6((X),(Y),227) +#define get_gdat_string_pos227(X,Y) get_gdat_string((X),(Y),227) +#define get_gdat_v_str_pos227(X,Y) get_gdat_string((X),(Y),227) +#define get_gdat_bool_pos227(X,Y) get_gdat_bool((X),(Y),227) +#define get_gdat_int_pos227(X,Y) get_gdat_int((X),(Y),227) +#define get_gdat_llong_pos227(X,Y) get_gdat_llong((X),(Y),227) +#define get_gdat_float_pos227(X,Y) get_gdat_float((X),(Y),227) +#define get_gdat_uint_pos228(X,Y) get_gdat_uint((X),(Y),228) +#define get_gdat_ullong_pos228(X,Y) get_gdat_ullong((X),(Y),228) +#define get_gdat_ip_pos228(X,Y) get_gdat_ip((X),(Y),228) +#define get_gdat_ipv6_pos228(X,Y) get_gdat_ipv6((X),(Y),228) +#define get_gdat_string_pos228(X,Y) get_gdat_string((X),(Y),228) +#define get_gdat_v_str_pos228(X,Y) get_gdat_string((X),(Y),228) +#define get_gdat_bool_pos228(X,Y) get_gdat_bool((X),(Y),228) +#define get_gdat_int_pos228(X,Y) get_gdat_int((X),(Y),228) +#define get_gdat_llong_pos228(X,Y) get_gdat_llong((X),(Y),228) +#define get_gdat_float_pos228(X,Y) get_gdat_float((X),(Y),228) +#define get_gdat_uint_pos229(X,Y) get_gdat_uint((X),(Y),229) +#define get_gdat_ullong_pos229(X,Y) get_gdat_ullong((X),(Y),229) +#define get_gdat_ip_pos229(X,Y) get_gdat_ip((X),(Y),229) +#define get_gdat_ipv6_pos229(X,Y) get_gdat_ipv6((X),(Y),229) +#define get_gdat_string_pos229(X,Y) get_gdat_string((X),(Y),229) +#define get_gdat_v_str_pos229(X,Y) get_gdat_string((X),(Y),229) +#define get_gdat_bool_pos229(X,Y) get_gdat_bool((X),(Y),229) +#define get_gdat_int_pos229(X,Y) get_gdat_int((X),(Y),229) +#define get_gdat_llong_pos229(X,Y) get_gdat_llong((X),(Y),229) +#define get_gdat_float_pos229(X,Y) get_gdat_float((X),(Y),229) +#define get_gdat_uint_pos230(X,Y) get_gdat_uint((X),(Y),230) +#define get_gdat_ullong_pos230(X,Y) get_gdat_ullong((X),(Y),230) +#define get_gdat_ip_pos230(X,Y) get_gdat_ip((X),(Y),230) +#define get_gdat_ipv6_pos230(X,Y) get_gdat_ipv6((X),(Y),230) +#define get_gdat_string_pos230(X,Y) get_gdat_string((X),(Y),230) +#define get_gdat_v_str_pos230(X,Y) get_gdat_string((X),(Y),230) +#define get_gdat_bool_pos230(X,Y) get_gdat_bool((X),(Y),230) +#define get_gdat_int_pos230(X,Y) get_gdat_int((X),(Y),230) +#define get_gdat_llong_pos230(X,Y) get_gdat_llong((X),(Y),230) +#define get_gdat_float_pos230(X,Y) get_gdat_float((X),(Y),230) +#define get_gdat_uint_pos231(X,Y) get_gdat_uint((X),(Y),231) +#define get_gdat_ullong_pos231(X,Y) get_gdat_ullong((X),(Y),231) +#define get_gdat_ip_pos231(X,Y) get_gdat_ip((X),(Y),231) +#define get_gdat_ipv6_pos231(X,Y) get_gdat_ipv6((X),(Y),231) +#define get_gdat_string_pos231(X,Y) get_gdat_string((X),(Y),231) +#define get_gdat_v_str_pos231(X,Y) get_gdat_string((X),(Y),231) +#define get_gdat_bool_pos231(X,Y) get_gdat_bool((X),(Y),231) +#define get_gdat_int_pos231(X,Y) get_gdat_int((X),(Y),231) +#define get_gdat_llong_pos231(X,Y) get_gdat_llong((X),(Y),231) +#define get_gdat_float_pos231(X,Y) get_gdat_float((X),(Y),231) +#define get_gdat_uint_pos232(X,Y) get_gdat_uint((X),(Y),232) +#define get_gdat_ullong_pos232(X,Y) get_gdat_ullong((X),(Y),232) +#define get_gdat_ip_pos232(X,Y) get_gdat_ip((X),(Y),232) +#define get_gdat_ipv6_pos232(X,Y) get_gdat_ipv6((X),(Y),232) +#define get_gdat_string_pos232(X,Y) get_gdat_string((X),(Y),232) +#define get_gdat_v_str_pos232(X,Y) get_gdat_string((X),(Y),232) +#define get_gdat_bool_pos232(X,Y) get_gdat_bool((X),(Y),232) +#define get_gdat_int_pos232(X,Y) get_gdat_int((X),(Y),232) +#define get_gdat_llong_pos232(X,Y) get_gdat_llong((X),(Y),232) +#define get_gdat_float_pos232(X,Y) get_gdat_float((X),(Y),232) +#define get_gdat_uint_pos233(X,Y) get_gdat_uint((X),(Y),233) +#define get_gdat_ullong_pos233(X,Y) get_gdat_ullong((X),(Y),233) +#define get_gdat_ip_pos233(X,Y) get_gdat_ip((X),(Y),233) +#define get_gdat_ipv6_pos233(X,Y) get_gdat_ipv6((X),(Y),233) +#define get_gdat_string_pos233(X,Y) get_gdat_string((X),(Y),233) +#define get_gdat_v_str_pos233(X,Y) get_gdat_string((X),(Y),233) +#define get_gdat_bool_pos233(X,Y) get_gdat_bool((X),(Y),233) +#define get_gdat_int_pos233(X,Y) get_gdat_int((X),(Y),233) +#define get_gdat_llong_pos233(X,Y) get_gdat_llong((X),(Y),233) +#define get_gdat_float_pos233(X,Y) get_gdat_float((X),(Y),233) +#define get_gdat_uint_pos234(X,Y) get_gdat_uint((X),(Y),234) +#define get_gdat_ullong_pos234(X,Y) get_gdat_ullong((X),(Y),234) +#define get_gdat_ip_pos234(X,Y) get_gdat_ip((X),(Y),234) +#define get_gdat_ipv6_pos234(X,Y) get_gdat_ipv6((X),(Y),234) +#define get_gdat_string_pos234(X,Y) get_gdat_string((X),(Y),234) +#define get_gdat_v_str_pos234(X,Y) get_gdat_string((X),(Y),234) +#define get_gdat_bool_pos234(X,Y) get_gdat_bool((X),(Y),234) +#define get_gdat_int_pos234(X,Y) get_gdat_int((X),(Y),234) +#define get_gdat_llong_pos234(X,Y) get_gdat_llong((X),(Y),234) +#define get_gdat_float_pos234(X,Y) get_gdat_float((X),(Y),234) +#define get_gdat_uint_pos235(X,Y) get_gdat_uint((X),(Y),235) +#define get_gdat_ullong_pos235(X,Y) get_gdat_ullong((X),(Y),235) +#define get_gdat_ip_pos235(X,Y) get_gdat_ip((X),(Y),235) +#define get_gdat_ipv6_pos235(X,Y) get_gdat_ipv6((X),(Y),235) +#define get_gdat_string_pos235(X,Y) get_gdat_string((X),(Y),235) +#define get_gdat_v_str_pos235(X,Y) get_gdat_string((X),(Y),235) +#define get_gdat_bool_pos235(X,Y) get_gdat_bool((X),(Y),235) +#define get_gdat_int_pos235(X,Y) get_gdat_int((X),(Y),235) +#define get_gdat_llong_pos235(X,Y) get_gdat_llong((X),(Y),235) +#define get_gdat_float_pos235(X,Y) get_gdat_float((X),(Y),235) +#define get_gdat_uint_pos236(X,Y) get_gdat_uint((X),(Y),236) +#define get_gdat_ullong_pos236(X,Y) get_gdat_ullong((X),(Y),236) +#define get_gdat_ip_pos236(X,Y) get_gdat_ip((X),(Y),236) +#define get_gdat_ipv6_pos236(X,Y) get_gdat_ipv6((X),(Y),236) +#define get_gdat_string_pos236(X,Y) get_gdat_string((X),(Y),236) +#define get_gdat_v_str_pos236(X,Y) get_gdat_string((X),(Y),236) +#define get_gdat_bool_pos236(X,Y) get_gdat_bool((X),(Y),236) +#define get_gdat_int_pos236(X,Y) get_gdat_int((X),(Y),236) +#define get_gdat_llong_pos236(X,Y) get_gdat_llong((X),(Y),236) +#define get_gdat_float_pos236(X,Y) get_gdat_float((X),(Y),236) +#define get_gdat_uint_pos237(X,Y) get_gdat_uint((X),(Y),237) +#define get_gdat_ullong_pos237(X,Y) get_gdat_ullong((X),(Y),237) +#define get_gdat_ip_pos237(X,Y) get_gdat_ip((X),(Y),237) +#define get_gdat_ipv6_pos237(X,Y) get_gdat_ipv6((X),(Y),237) +#define get_gdat_string_pos237(X,Y) get_gdat_string((X),(Y),237) +#define get_gdat_v_str_pos237(X,Y) get_gdat_string((X),(Y),237) +#define get_gdat_bool_pos237(X,Y) get_gdat_bool((X),(Y),237) +#define get_gdat_int_pos237(X,Y) get_gdat_int((X),(Y),237) +#define get_gdat_llong_pos237(X,Y) get_gdat_llong((X),(Y),237) +#define get_gdat_float_pos237(X,Y) get_gdat_float((X),(Y),237) +#define get_gdat_uint_pos238(X,Y) get_gdat_uint((X),(Y),238) +#define get_gdat_ullong_pos238(X,Y) get_gdat_ullong((X),(Y),238) +#define get_gdat_ip_pos238(X,Y) get_gdat_ip((X),(Y),238) +#define get_gdat_ipv6_pos238(X,Y) get_gdat_ipv6((X),(Y),238) +#define get_gdat_string_pos238(X,Y) get_gdat_string((X),(Y),238) +#define get_gdat_v_str_pos238(X,Y) get_gdat_string((X),(Y),238) +#define get_gdat_bool_pos238(X,Y) get_gdat_bool((X),(Y),238) +#define get_gdat_int_pos238(X,Y) get_gdat_int((X),(Y),238) +#define get_gdat_llong_pos238(X,Y) get_gdat_llong((X),(Y),238) +#define get_gdat_float_pos238(X,Y) get_gdat_float((X),(Y),238) +#define get_gdat_uint_pos239(X,Y) get_gdat_uint((X),(Y),239) +#define get_gdat_ullong_pos239(X,Y) get_gdat_ullong((X),(Y),239) +#define get_gdat_ip_pos239(X,Y) get_gdat_ip((X),(Y),239) +#define get_gdat_ipv6_pos239(X,Y) get_gdat_ipv6((X),(Y),239) +#define get_gdat_string_pos239(X,Y) get_gdat_string((X),(Y),239) +#define get_gdat_v_str_pos239(X,Y) get_gdat_string((X),(Y),239) +#define get_gdat_bool_pos239(X,Y) get_gdat_bool((X),(Y),239) +#define get_gdat_int_pos239(X,Y) get_gdat_int((X),(Y),239) +#define get_gdat_llong_pos239(X,Y) get_gdat_llong((X),(Y),239) +#define get_gdat_float_pos239(X,Y) get_gdat_float((X),(Y),239) +#define get_gdat_uint_pos240(X,Y) get_gdat_uint((X),(Y),240) +#define get_gdat_ullong_pos240(X,Y) get_gdat_ullong((X),(Y),240) +#define get_gdat_ip_pos240(X,Y) get_gdat_ip((X),(Y),240) +#define get_gdat_ipv6_pos240(X,Y) get_gdat_ipv6((X),(Y),240) +#define get_gdat_string_pos240(X,Y) get_gdat_string((X),(Y),240) +#define get_gdat_v_str_pos240(X,Y) get_gdat_string((X),(Y),240) +#define get_gdat_bool_pos240(X,Y) get_gdat_bool((X),(Y),240) +#define get_gdat_int_pos240(X,Y) get_gdat_int((X),(Y),240) +#define get_gdat_llong_pos240(X,Y) get_gdat_llong((X),(Y),240) +#define get_gdat_float_pos240(X,Y) get_gdat_float((X),(Y),240) +#define get_gdat_uint_pos241(X,Y) get_gdat_uint((X),(Y),241) +#define get_gdat_ullong_pos241(X,Y) get_gdat_ullong((X),(Y),241) +#define get_gdat_ip_pos241(X,Y) get_gdat_ip((X),(Y),241) +#define get_gdat_ipv6_pos241(X,Y) get_gdat_ipv6((X),(Y),241) +#define get_gdat_string_pos241(X,Y) get_gdat_string((X),(Y),241) +#define get_gdat_v_str_pos241(X,Y) get_gdat_string((X),(Y),241) +#define get_gdat_bool_pos241(X,Y) get_gdat_bool((X),(Y),241) +#define get_gdat_int_pos241(X,Y) get_gdat_int((X),(Y),241) +#define get_gdat_llong_pos241(X,Y) get_gdat_llong((X),(Y),241) +#define get_gdat_float_pos241(X,Y) get_gdat_float((X),(Y),241) +#define get_gdat_uint_pos242(X,Y) get_gdat_uint((X),(Y),242) +#define get_gdat_ullong_pos242(X,Y) get_gdat_ullong((X),(Y),242) +#define get_gdat_ip_pos242(X,Y) get_gdat_ip((X),(Y),242) +#define get_gdat_ipv6_pos242(X,Y) get_gdat_ipv6((X),(Y),242) +#define get_gdat_string_pos242(X,Y) get_gdat_string((X),(Y),242) +#define get_gdat_v_str_pos242(X,Y) get_gdat_string((X),(Y),242) +#define get_gdat_bool_pos242(X,Y) get_gdat_bool((X),(Y),242) +#define get_gdat_int_pos242(X,Y) get_gdat_int((X),(Y),242) +#define get_gdat_llong_pos242(X,Y) get_gdat_llong((X),(Y),242) +#define get_gdat_float_pos242(X,Y) get_gdat_float((X),(Y),242) +#define get_gdat_uint_pos243(X,Y) get_gdat_uint((X),(Y),243) +#define get_gdat_ullong_pos243(X,Y) get_gdat_ullong((X),(Y),243) +#define get_gdat_ip_pos243(X,Y) get_gdat_ip((X),(Y),243) +#define get_gdat_ipv6_pos243(X,Y) get_gdat_ipv6((X),(Y),243) +#define get_gdat_string_pos243(X,Y) get_gdat_string((X),(Y),243) +#define get_gdat_v_str_pos243(X,Y) get_gdat_string((X),(Y),243) +#define get_gdat_bool_pos243(X,Y) get_gdat_bool((X),(Y),243) +#define get_gdat_int_pos243(X,Y) get_gdat_int((X),(Y),243) +#define get_gdat_llong_pos243(X,Y) get_gdat_llong((X),(Y),243) +#define get_gdat_float_pos243(X,Y) get_gdat_float((X),(Y),243) +#define get_gdat_uint_pos244(X,Y) get_gdat_uint((X),(Y),244) +#define get_gdat_ullong_pos244(X,Y) get_gdat_ullong((X),(Y),244) +#define get_gdat_ip_pos244(X,Y) get_gdat_ip((X),(Y),244) +#define get_gdat_ipv6_pos244(X,Y) get_gdat_ipv6((X),(Y),244) +#define get_gdat_string_pos244(X,Y) get_gdat_string((X),(Y),244) +#define get_gdat_v_str_pos244(X,Y) get_gdat_string((X),(Y),244) +#define get_gdat_bool_pos244(X,Y) get_gdat_bool((X),(Y),244) +#define get_gdat_int_pos244(X,Y) get_gdat_int((X),(Y),244) +#define get_gdat_llong_pos244(X,Y) get_gdat_llong((X),(Y),244) +#define get_gdat_float_pos244(X,Y) get_gdat_float((X),(Y),244) +#define get_gdat_uint_pos245(X,Y) get_gdat_uint((X),(Y),245) +#define get_gdat_ullong_pos245(X,Y) get_gdat_ullong((X),(Y),245) +#define get_gdat_ip_pos245(X,Y) get_gdat_ip((X),(Y),245) +#define get_gdat_ipv6_pos245(X,Y) get_gdat_ipv6((X),(Y),245) +#define get_gdat_string_pos245(X,Y) get_gdat_string((X),(Y),245) +#define get_gdat_v_str_pos245(X,Y) get_gdat_string((X),(Y),245) +#define get_gdat_bool_pos245(X,Y) get_gdat_bool((X),(Y),245) +#define get_gdat_int_pos245(X,Y) get_gdat_int((X),(Y),245) +#define get_gdat_llong_pos245(X,Y) get_gdat_llong((X),(Y),245) +#define get_gdat_float_pos245(X,Y) get_gdat_float((X),(Y),245) +#define get_gdat_uint_pos246(X,Y) get_gdat_uint((X),(Y),246) +#define get_gdat_ullong_pos246(X,Y) get_gdat_ullong((X),(Y),246) +#define get_gdat_ip_pos246(X,Y) get_gdat_ip((X),(Y),246) +#define get_gdat_ipv6_pos246(X,Y) get_gdat_ipv6((X),(Y),246) +#define get_gdat_string_pos246(X,Y) get_gdat_string((X),(Y),246) +#define get_gdat_v_str_pos246(X,Y) get_gdat_string((X),(Y),246) +#define get_gdat_bool_pos246(X,Y) get_gdat_bool((X),(Y),246) +#define get_gdat_int_pos246(X,Y) get_gdat_int((X),(Y),246) +#define get_gdat_llong_pos246(X,Y) get_gdat_llong((X),(Y),246) +#define get_gdat_float_pos246(X,Y) get_gdat_float((X),(Y),246) +#define get_gdat_uint_pos247(X,Y) get_gdat_uint((X),(Y),247) +#define get_gdat_ullong_pos247(X,Y) get_gdat_ullong((X),(Y),247) +#define get_gdat_ip_pos247(X,Y) get_gdat_ip((X),(Y),247) +#define get_gdat_ipv6_pos247(X,Y) get_gdat_ipv6((X),(Y),247) +#define get_gdat_string_pos247(X,Y) get_gdat_string((X),(Y),247) +#define get_gdat_v_str_pos247(X,Y) get_gdat_string((X),(Y),247) +#define get_gdat_bool_pos247(X,Y) get_gdat_bool((X),(Y),247) +#define get_gdat_int_pos247(X,Y) get_gdat_int((X),(Y),247) +#define get_gdat_llong_pos247(X,Y) get_gdat_llong((X),(Y),247) +#define get_gdat_float_pos247(X,Y) get_gdat_float((X),(Y),247) +#define get_gdat_uint_pos248(X,Y) get_gdat_uint((X),(Y),248) +#define get_gdat_ullong_pos248(X,Y) get_gdat_ullong((X),(Y),248) +#define get_gdat_ip_pos248(X,Y) get_gdat_ip((X),(Y),248) +#define get_gdat_ipv6_pos248(X,Y) get_gdat_ipv6((X),(Y),248) +#define get_gdat_string_pos248(X,Y) get_gdat_string((X),(Y),248) +#define get_gdat_v_str_pos248(X,Y) get_gdat_string((X),(Y),248) +#define get_gdat_bool_pos248(X,Y) get_gdat_bool((X),(Y),248) +#define get_gdat_int_pos248(X,Y) get_gdat_int((X),(Y),248) +#define get_gdat_llong_pos248(X,Y) get_gdat_llong((X),(Y),248) +#define get_gdat_float_pos248(X,Y) get_gdat_float((X),(Y),248) +#define get_gdat_uint_pos249(X,Y) get_gdat_uint((X),(Y),249) +#define get_gdat_ullong_pos249(X,Y) get_gdat_ullong((X),(Y),249) +#define get_gdat_ip_pos249(X,Y) get_gdat_ip((X),(Y),249) +#define get_gdat_ipv6_pos249(X,Y) get_gdat_ipv6((X),(Y),249) +#define get_gdat_string_pos249(X,Y) get_gdat_string((X),(Y),249) +#define get_gdat_v_str_pos249(X,Y) get_gdat_string((X),(Y),249) +#define get_gdat_bool_pos249(X,Y) get_gdat_bool((X),(Y),249) +#define get_gdat_int_pos249(X,Y) get_gdat_int((X),(Y),249) +#define get_gdat_llong_pos249(X,Y) get_gdat_llong((X),(Y),249) +#define get_gdat_float_pos249(X,Y) get_gdat_float((X),(Y),249) +#define get_gdat_uint_pos250(X,Y) get_gdat_uint((X),(Y),250) +#define get_gdat_ullong_pos250(X,Y) get_gdat_ullong((X),(Y),250) +#define get_gdat_ip_pos250(X,Y) get_gdat_ip((X),(Y),250) +#define get_gdat_ipv6_pos250(X,Y) get_gdat_ipv6((X),(Y),250) +#define get_gdat_string_pos250(X,Y) get_gdat_string((X),(Y),250) +#define get_gdat_v_str_pos250(X,Y) get_gdat_string((X),(Y),250) +#define get_gdat_bool_pos250(X,Y) get_gdat_bool((X),(Y),250) +#define get_gdat_int_pos250(X,Y) get_gdat_int((X),(Y),250) +#define get_gdat_llong_pos250(X,Y) get_gdat_llong((X),(Y),250) +#define get_gdat_float_pos250(X,Y) get_gdat_float((X),(Y),250) +#define get_gdat_uint_pos251(X,Y) get_gdat_uint((X),(Y),251) +#define get_gdat_ullong_pos251(X,Y) get_gdat_ullong((X),(Y),251) +#define get_gdat_ip_pos251(X,Y) get_gdat_ip((X),(Y),251) +#define get_gdat_ipv6_pos251(X,Y) get_gdat_ipv6((X),(Y),251) +#define get_gdat_string_pos251(X,Y) get_gdat_string((X),(Y),251) +#define get_gdat_v_str_pos251(X,Y) get_gdat_string((X),(Y),251) +#define get_gdat_bool_pos251(X,Y) get_gdat_bool((X),(Y),251) +#define get_gdat_int_pos251(X,Y) get_gdat_int((X),(Y),251) +#define get_gdat_llong_pos251(X,Y) get_gdat_llong((X),(Y),251) +#define get_gdat_float_pos251(X,Y) get_gdat_float((X),(Y),251) +#define get_gdat_uint_pos252(X,Y) get_gdat_uint((X),(Y),252) +#define get_gdat_ullong_pos252(X,Y) get_gdat_ullong((X),(Y),252) +#define get_gdat_ip_pos252(X,Y) get_gdat_ip((X),(Y),252) +#define get_gdat_ipv6_pos252(X,Y) get_gdat_ipv6((X),(Y),252) +#define get_gdat_string_pos252(X,Y) get_gdat_string((X),(Y),252) +#define get_gdat_v_str_pos252(X,Y) get_gdat_string((X),(Y),252) +#define get_gdat_bool_pos252(X,Y) get_gdat_bool((X),(Y),252) +#define get_gdat_int_pos252(X,Y) get_gdat_int((X),(Y),252) +#define get_gdat_llong_pos252(X,Y) get_gdat_llong((X),(Y),252) +#define get_gdat_float_pos252(X,Y) get_gdat_float((X),(Y),252) +#define get_gdat_uint_pos253(X,Y) get_gdat_uint((X),(Y),253) +#define get_gdat_ullong_pos253(X,Y) get_gdat_ullong((X),(Y),253) +#define get_gdat_ip_pos253(X,Y) get_gdat_ip((X),(Y),253) +#define get_gdat_ipv6_pos253(X,Y) get_gdat_ipv6((X),(Y),253) +#define get_gdat_string_pos253(X,Y) get_gdat_string((X),(Y),253) +#define get_gdat_v_str_pos253(X,Y) get_gdat_string((X),(Y),253) +#define get_gdat_bool_pos253(X,Y) get_gdat_bool((X),(Y),253) +#define get_gdat_int_pos253(X,Y) get_gdat_int((X),(Y),253) +#define get_gdat_llong_pos253(X,Y) get_gdat_llong((X),(Y),253) +#define get_gdat_float_pos253(X,Y) get_gdat_float((X),(Y),253) +#define get_gdat_uint_pos254(X,Y) get_gdat_uint((X),(Y),254) +#define get_gdat_ullong_pos254(X,Y) get_gdat_ullong((X),(Y),254) +#define get_gdat_ip_pos254(X,Y) get_gdat_ip((X),(Y),254) +#define get_gdat_ipv6_pos254(X,Y) get_gdat_ipv6((X),(Y),254) +#define get_gdat_string_pos254(X,Y) get_gdat_string((X),(Y),254) +#define get_gdat_v_str_pos254(X,Y) get_gdat_string((X),(Y),254) +#define get_gdat_bool_pos254(X,Y) get_gdat_bool((X),(Y),254) +#define get_gdat_int_pos254(X,Y) get_gdat_int((X),(Y),254) +#define get_gdat_llong_pos254(X,Y) get_gdat_llong((X),(Y),254) +#define get_gdat_float_pos254(X,Y) get_gdat_float((X),(Y),254) +#define get_gdat_uint_pos255(X,Y) get_gdat_uint((X),(Y),255) +#define get_gdat_ullong_pos255(X,Y) get_gdat_ullong((X),(Y),255) +#define get_gdat_ip_pos255(X,Y) get_gdat_ip((X),(Y),255) +#define get_gdat_ipv6_pos255(X,Y) get_gdat_ipv6((X),(Y),255) +#define get_gdat_string_pos255(X,Y) get_gdat_string((X),(Y),255) +#define get_gdat_v_str_pos255(X,Y) get_gdat_string((X),(Y),255) +#define get_gdat_bool_pos255(X,Y) get_gdat_bool((X),(Y),255) +#define get_gdat_int_pos255(X,Y) get_gdat_int((X),(Y),255) +#define get_gdat_llong_pos255(X,Y) get_gdat_llong((X),(Y),255) +#define get_gdat_float_pos255(X,Y) get_gdat_float((X),(Y),255) +#define get_gdat_uint_pos256(X,Y) get_gdat_uint((X),(Y),256) +#define get_gdat_ullong_pos256(X,Y) get_gdat_ullong((X),(Y),256) +#define get_gdat_ip_pos256(X,Y) get_gdat_ip((X),(Y),256) +#define get_gdat_ipv6_pos256(X,Y) get_gdat_ipv6((X),(Y),256) +#define get_gdat_string_pos256(X,Y) get_gdat_string((X),(Y),256) +#define get_gdat_v_str_pos256(X,Y) get_gdat_string((X),(Y),256) +#define get_gdat_bool_pos256(X,Y) get_gdat_bool((X),(Y),256) +#define get_gdat_int_pos256(X,Y) get_gdat_int((X),(Y),256) +#define get_gdat_llong_pos256(X,Y) get_gdat_llong((X),(Y),256) +#define get_gdat_float_pos256(X,Y) get_gdat_float((X),(Y),256) +#define get_gdat_uint_pos257(X,Y) get_gdat_uint((X),(Y),257) +#define get_gdat_ullong_pos257(X,Y) get_gdat_ullong((X),(Y),257) +#define get_gdat_ip_pos257(X,Y) get_gdat_ip((X),(Y),257) +#define get_gdat_ipv6_pos257(X,Y) get_gdat_ipv6((X),(Y),257) +#define get_gdat_string_pos257(X,Y) get_gdat_string((X),(Y),257) +#define get_gdat_v_str_pos257(X,Y) get_gdat_string((X),(Y),257) +#define get_gdat_bool_pos257(X,Y) get_gdat_bool((X),(Y),257) +#define get_gdat_int_pos257(X,Y) get_gdat_int((X),(Y),257) +#define get_gdat_llong_pos257(X,Y) get_gdat_llong((X),(Y),257) +#define get_gdat_float_pos257(X,Y) get_gdat_float((X),(Y),257) +#define get_gdat_uint_pos258(X,Y) get_gdat_uint((X),(Y),258) +#define get_gdat_ullong_pos258(X,Y) get_gdat_ullong((X),(Y),258) +#define get_gdat_ip_pos258(X,Y) get_gdat_ip((X),(Y),258) +#define get_gdat_ipv6_pos258(X,Y) get_gdat_ipv6((X),(Y),258) +#define get_gdat_string_pos258(X,Y) get_gdat_string((X),(Y),258) +#define get_gdat_v_str_pos258(X,Y) get_gdat_string((X),(Y),258) +#define get_gdat_bool_pos258(X,Y) get_gdat_bool((X),(Y),258) +#define get_gdat_int_pos258(X,Y) get_gdat_int((X),(Y),258) +#define get_gdat_llong_pos258(X,Y) get_gdat_llong((X),(Y),258) +#define get_gdat_float_pos258(X,Y) get_gdat_float((X),(Y),258) +#define get_gdat_uint_pos259(X,Y) get_gdat_uint((X),(Y),259) +#define get_gdat_ullong_pos259(X,Y) get_gdat_ullong((X),(Y),259) +#define get_gdat_ip_pos259(X,Y) get_gdat_ip((X),(Y),259) +#define get_gdat_ipv6_pos259(X,Y) get_gdat_ipv6((X),(Y),259) +#define get_gdat_string_pos259(X,Y) get_gdat_string((X),(Y),259) +#define get_gdat_v_str_pos259(X,Y) get_gdat_string((X),(Y),259) +#define get_gdat_bool_pos259(X,Y) get_gdat_bool((X),(Y),259) +#define get_gdat_int_pos259(X,Y) get_gdat_int((X),(Y),259) +#define get_gdat_llong_pos259(X,Y) get_gdat_llong((X),(Y),259) +#define get_gdat_float_pos259(X,Y) get_gdat_float((X),(Y),259) +#define get_gdat_uint_pos260(X,Y) get_gdat_uint((X),(Y),260) +#define get_gdat_ullong_pos260(X,Y) get_gdat_ullong((X),(Y),260) +#define get_gdat_ip_pos260(X,Y) get_gdat_ip((X),(Y),260) +#define get_gdat_ipv6_pos260(X,Y) get_gdat_ipv6((X),(Y),260) +#define get_gdat_string_pos260(X,Y) get_gdat_string((X),(Y),260) +#define get_gdat_v_str_pos260(X,Y) get_gdat_string((X),(Y),260) +#define get_gdat_bool_pos260(X,Y) get_gdat_bool((X),(Y),260) +#define get_gdat_int_pos260(X,Y) get_gdat_int((X),(Y),260) +#define get_gdat_llong_pos260(X,Y) get_gdat_llong((X),(Y),260) +#define get_gdat_float_pos260(X,Y) get_gdat_float((X),(Y),260) +#define get_gdat_uint_pos261(X,Y) get_gdat_uint((X),(Y),261) +#define get_gdat_ullong_pos261(X,Y) get_gdat_ullong((X),(Y),261) +#define get_gdat_ip_pos261(X,Y) get_gdat_ip((X),(Y),261) +#define get_gdat_ipv6_pos261(X,Y) get_gdat_ipv6((X),(Y),261) +#define get_gdat_string_pos261(X,Y) get_gdat_string((X),(Y),261) +#define get_gdat_v_str_pos261(X,Y) get_gdat_string((X),(Y),261) +#define get_gdat_bool_pos261(X,Y) get_gdat_bool((X),(Y),261) +#define get_gdat_int_pos261(X,Y) get_gdat_int((X),(Y),261) +#define get_gdat_llong_pos261(X,Y) get_gdat_llong((X),(Y),261) +#define get_gdat_float_pos261(X,Y) get_gdat_float((X),(Y),261) +#define get_gdat_uint_pos262(X,Y) get_gdat_uint((X),(Y),262) +#define get_gdat_ullong_pos262(X,Y) get_gdat_ullong((X),(Y),262) +#define get_gdat_ip_pos262(X,Y) get_gdat_ip((X),(Y),262) +#define get_gdat_ipv6_pos262(X,Y) get_gdat_ipv6((X),(Y),262) +#define get_gdat_string_pos262(X,Y) get_gdat_string((X),(Y),262) +#define get_gdat_v_str_pos262(X,Y) get_gdat_string((X),(Y),262) +#define get_gdat_bool_pos262(X,Y) get_gdat_bool((X),(Y),262) +#define get_gdat_int_pos262(X,Y) get_gdat_int((X),(Y),262) +#define get_gdat_llong_pos262(X,Y) get_gdat_llong((X),(Y),262) +#define get_gdat_float_pos262(X,Y) get_gdat_float((X),(Y),262) +#define get_gdat_uint_pos263(X,Y) get_gdat_uint((X),(Y),263) +#define get_gdat_ullong_pos263(X,Y) get_gdat_ullong((X),(Y),263) +#define get_gdat_ip_pos263(X,Y) get_gdat_ip((X),(Y),263) +#define get_gdat_ipv6_pos263(X,Y) get_gdat_ipv6((X),(Y),263) +#define get_gdat_string_pos263(X,Y) get_gdat_string((X),(Y),263) +#define get_gdat_v_str_pos263(X,Y) get_gdat_string((X),(Y),263) +#define get_gdat_bool_pos263(X,Y) get_gdat_bool((X),(Y),263) +#define get_gdat_int_pos263(X,Y) get_gdat_int((X),(Y),263) +#define get_gdat_llong_pos263(X,Y) get_gdat_llong((X),(Y),263) +#define get_gdat_float_pos263(X,Y) get_gdat_float((X),(Y),263) +#define get_gdat_uint_pos264(X,Y) get_gdat_uint((X),(Y),264) +#define get_gdat_ullong_pos264(X,Y) get_gdat_ullong((X),(Y),264) +#define get_gdat_ip_pos264(X,Y) get_gdat_ip((X),(Y),264) +#define get_gdat_ipv6_pos264(X,Y) get_gdat_ipv6((X),(Y),264) +#define get_gdat_string_pos264(X,Y) get_gdat_string((X),(Y),264) +#define get_gdat_v_str_pos264(X,Y) get_gdat_string((X),(Y),264) +#define get_gdat_bool_pos264(X,Y) get_gdat_bool((X),(Y),264) +#define get_gdat_int_pos264(X,Y) get_gdat_int((X),(Y),264) +#define get_gdat_llong_pos264(X,Y) get_gdat_llong((X),(Y),264) +#define get_gdat_float_pos264(X,Y) get_gdat_float((X),(Y),264) +#define get_gdat_uint_pos265(X,Y) get_gdat_uint((X),(Y),265) +#define get_gdat_ullong_pos265(X,Y) get_gdat_ullong((X),(Y),265) +#define get_gdat_ip_pos265(X,Y) get_gdat_ip((X),(Y),265) +#define get_gdat_ipv6_pos265(X,Y) get_gdat_ipv6((X),(Y),265) +#define get_gdat_string_pos265(X,Y) get_gdat_string((X),(Y),265) +#define get_gdat_v_str_pos265(X,Y) get_gdat_string((X),(Y),265) +#define get_gdat_bool_pos265(X,Y) get_gdat_bool((X),(Y),265) +#define get_gdat_int_pos265(X,Y) get_gdat_int((X),(Y),265) +#define get_gdat_llong_pos265(X,Y) get_gdat_llong((X),(Y),265) +#define get_gdat_float_pos265(X,Y) get_gdat_float((X),(Y),265) +#define get_gdat_uint_pos266(X,Y) get_gdat_uint((X),(Y),266) +#define get_gdat_ullong_pos266(X,Y) get_gdat_ullong((X),(Y),266) +#define get_gdat_ip_pos266(X,Y) get_gdat_ip((X),(Y),266) +#define get_gdat_ipv6_pos266(X,Y) get_gdat_ipv6((X),(Y),266) +#define get_gdat_string_pos266(X,Y) get_gdat_string((X),(Y),266) +#define get_gdat_v_str_pos266(X,Y) get_gdat_string((X),(Y),266) +#define get_gdat_bool_pos266(X,Y) get_gdat_bool((X),(Y),266) +#define get_gdat_int_pos266(X,Y) get_gdat_int((X),(Y),266) +#define get_gdat_llong_pos266(X,Y) get_gdat_llong((X),(Y),266) +#define get_gdat_float_pos266(X,Y) get_gdat_float((X),(Y),266) +#define get_gdat_uint_pos267(X,Y) get_gdat_uint((X),(Y),267) +#define get_gdat_ullong_pos267(X,Y) get_gdat_ullong((X),(Y),267) +#define get_gdat_ip_pos267(X,Y) get_gdat_ip((X),(Y),267) +#define get_gdat_ipv6_pos267(X,Y) get_gdat_ipv6((X),(Y),267) +#define get_gdat_string_pos267(X,Y) get_gdat_string((X),(Y),267) +#define get_gdat_v_str_pos267(X,Y) get_gdat_string((X),(Y),267) +#define get_gdat_bool_pos267(X,Y) get_gdat_bool((X),(Y),267) +#define get_gdat_int_pos267(X,Y) get_gdat_int((X),(Y),267) +#define get_gdat_llong_pos267(X,Y) get_gdat_llong((X),(Y),267) +#define get_gdat_float_pos267(X,Y) get_gdat_float((X),(Y),267) +#define get_gdat_uint_pos268(X,Y) get_gdat_uint((X),(Y),268) +#define get_gdat_ullong_pos268(X,Y) get_gdat_ullong((X),(Y),268) +#define get_gdat_ip_pos268(X,Y) get_gdat_ip((X),(Y),268) +#define get_gdat_ipv6_pos268(X,Y) get_gdat_ipv6((X),(Y),268) +#define get_gdat_string_pos268(X,Y) get_gdat_string((X),(Y),268) +#define get_gdat_v_str_pos268(X,Y) get_gdat_string((X),(Y),268) +#define get_gdat_bool_pos268(X,Y) get_gdat_bool((X),(Y),268) +#define get_gdat_int_pos268(X,Y) get_gdat_int((X),(Y),268) +#define get_gdat_llong_pos268(X,Y) get_gdat_llong((X),(Y),268) +#define get_gdat_float_pos268(X,Y) get_gdat_float((X),(Y),268) +#define get_gdat_uint_pos269(X,Y) get_gdat_uint((X),(Y),269) +#define get_gdat_ullong_pos269(X,Y) get_gdat_ullong((X),(Y),269) +#define get_gdat_ip_pos269(X,Y) get_gdat_ip((X),(Y),269) +#define get_gdat_ipv6_pos269(X,Y) get_gdat_ipv6((X),(Y),269) +#define get_gdat_string_pos269(X,Y) get_gdat_string((X),(Y),269) +#define get_gdat_v_str_pos269(X,Y) get_gdat_string((X),(Y),269) +#define get_gdat_bool_pos269(X,Y) get_gdat_bool((X),(Y),269) +#define get_gdat_int_pos269(X,Y) get_gdat_int((X),(Y),269) +#define get_gdat_llong_pos269(X,Y) get_gdat_llong((X),(Y),269) +#define get_gdat_float_pos269(X,Y) get_gdat_float((X),(Y),269) +#define get_gdat_uint_pos270(X,Y) get_gdat_uint((X),(Y),270) +#define get_gdat_ullong_pos270(X,Y) get_gdat_ullong((X),(Y),270) +#define get_gdat_ip_pos270(X,Y) get_gdat_ip((X),(Y),270) +#define get_gdat_ipv6_pos270(X,Y) get_gdat_ipv6((X),(Y),270) +#define get_gdat_string_pos270(X,Y) get_gdat_string((X),(Y),270) +#define get_gdat_v_str_pos270(X,Y) get_gdat_string((X),(Y),270) +#define get_gdat_bool_pos270(X,Y) get_gdat_bool((X),(Y),270) +#define get_gdat_int_pos270(X,Y) get_gdat_int((X),(Y),270) +#define get_gdat_llong_pos270(X,Y) get_gdat_llong((X),(Y),270) +#define get_gdat_float_pos270(X,Y) get_gdat_float((X),(Y),270) +#define get_gdat_uint_pos271(X,Y) get_gdat_uint((X),(Y),271) +#define get_gdat_ullong_pos271(X,Y) get_gdat_ullong((X),(Y),271) +#define get_gdat_ip_pos271(X,Y) get_gdat_ip((X),(Y),271) +#define get_gdat_ipv6_pos271(X,Y) get_gdat_ipv6((X),(Y),271) +#define get_gdat_string_pos271(X,Y) get_gdat_string((X),(Y),271) +#define get_gdat_v_str_pos271(X,Y) get_gdat_string((X),(Y),271) +#define get_gdat_bool_pos271(X,Y) get_gdat_bool((X),(Y),271) +#define get_gdat_int_pos271(X,Y) get_gdat_int((X),(Y),271) +#define get_gdat_llong_pos271(X,Y) get_gdat_llong((X),(Y),271) +#define get_gdat_float_pos271(X,Y) get_gdat_float((X),(Y),271) +#define get_gdat_uint_pos272(X,Y) get_gdat_uint((X),(Y),272) +#define get_gdat_ullong_pos272(X,Y) get_gdat_ullong((X),(Y),272) +#define get_gdat_ip_pos272(X,Y) get_gdat_ip((X),(Y),272) +#define get_gdat_ipv6_pos272(X,Y) get_gdat_ipv6((X),(Y),272) +#define get_gdat_string_pos272(X,Y) get_gdat_string((X),(Y),272) +#define get_gdat_v_str_pos272(X,Y) get_gdat_string((X),(Y),272) +#define get_gdat_bool_pos272(X,Y) get_gdat_bool((X),(Y),272) +#define get_gdat_int_pos272(X,Y) get_gdat_int((X),(Y),272) +#define get_gdat_llong_pos272(X,Y) get_gdat_llong((X),(Y),272) +#define get_gdat_float_pos272(X,Y) get_gdat_float((X),(Y),272) +#define get_gdat_uint_pos273(X,Y) get_gdat_uint((X),(Y),273) +#define get_gdat_ullong_pos273(X,Y) get_gdat_ullong((X),(Y),273) +#define get_gdat_ip_pos273(X,Y) get_gdat_ip((X),(Y),273) +#define get_gdat_ipv6_pos273(X,Y) get_gdat_ipv6((X),(Y),273) +#define get_gdat_string_pos273(X,Y) get_gdat_string((X),(Y),273) +#define get_gdat_v_str_pos273(X,Y) get_gdat_string((X),(Y),273) +#define get_gdat_bool_pos273(X,Y) get_gdat_bool((X),(Y),273) +#define get_gdat_int_pos273(X,Y) get_gdat_int((X),(Y),273) +#define get_gdat_llong_pos273(X,Y) get_gdat_llong((X),(Y),273) +#define get_gdat_float_pos273(X,Y) get_gdat_float((X),(Y),273) +#define get_gdat_uint_pos274(X,Y) get_gdat_uint((X),(Y),274) +#define get_gdat_ullong_pos274(X,Y) get_gdat_ullong((X),(Y),274) +#define get_gdat_ip_pos274(X,Y) get_gdat_ip((X),(Y),274) +#define get_gdat_ipv6_pos274(X,Y) get_gdat_ipv6((X),(Y),274) +#define get_gdat_string_pos274(X,Y) get_gdat_string((X),(Y),274) +#define get_gdat_v_str_pos274(X,Y) get_gdat_string((X),(Y),274) +#define get_gdat_bool_pos274(X,Y) get_gdat_bool((X),(Y),274) +#define get_gdat_int_pos274(X,Y) get_gdat_int((X),(Y),274) +#define get_gdat_llong_pos274(X,Y) get_gdat_llong((X),(Y),274) +#define get_gdat_float_pos274(X,Y) get_gdat_float((X),(Y),274) +#define get_gdat_uint_pos275(X,Y) get_gdat_uint((X),(Y),275) +#define get_gdat_ullong_pos275(X,Y) get_gdat_ullong((X),(Y),275) +#define get_gdat_ip_pos275(X,Y) get_gdat_ip((X),(Y),275) +#define get_gdat_ipv6_pos275(X,Y) get_gdat_ipv6((X),(Y),275) +#define get_gdat_string_pos275(X,Y) get_gdat_string((X),(Y),275) +#define get_gdat_v_str_pos275(X,Y) get_gdat_string((X),(Y),275) +#define get_gdat_bool_pos275(X,Y) get_gdat_bool((X),(Y),275) +#define get_gdat_int_pos275(X,Y) get_gdat_int((X),(Y),275) +#define get_gdat_llong_pos275(X,Y) get_gdat_llong((X),(Y),275) +#define get_gdat_float_pos275(X,Y) get_gdat_float((X),(Y),275) +#define get_gdat_uint_pos276(X,Y) get_gdat_uint((X),(Y),276) +#define get_gdat_ullong_pos276(X,Y) get_gdat_ullong((X),(Y),276) +#define get_gdat_ip_pos276(X,Y) get_gdat_ip((X),(Y),276) +#define get_gdat_ipv6_pos276(X,Y) get_gdat_ipv6((X),(Y),276) +#define get_gdat_string_pos276(X,Y) get_gdat_string((X),(Y),276) +#define get_gdat_v_str_pos276(X,Y) get_gdat_string((X),(Y),276) +#define get_gdat_bool_pos276(X,Y) get_gdat_bool((X),(Y),276) +#define get_gdat_int_pos276(X,Y) get_gdat_int((X),(Y),276) +#define get_gdat_llong_pos276(X,Y) get_gdat_llong((X),(Y),276) +#define get_gdat_float_pos276(X,Y) get_gdat_float((X),(Y),276) +#define get_gdat_uint_pos277(X,Y) get_gdat_uint((X),(Y),277) +#define get_gdat_ullong_pos277(X,Y) get_gdat_ullong((X),(Y),277) +#define get_gdat_ip_pos277(X,Y) get_gdat_ip((X),(Y),277) +#define get_gdat_ipv6_pos277(X,Y) get_gdat_ipv6((X),(Y),277) +#define get_gdat_string_pos277(X,Y) get_gdat_string((X),(Y),277) +#define get_gdat_v_str_pos277(X,Y) get_gdat_string((X),(Y),277) +#define get_gdat_bool_pos277(X,Y) get_gdat_bool((X),(Y),277) +#define get_gdat_int_pos277(X,Y) get_gdat_int((X),(Y),277) +#define get_gdat_llong_pos277(X,Y) get_gdat_llong((X),(Y),277) +#define get_gdat_float_pos277(X,Y) get_gdat_float((X),(Y),277) +#define get_gdat_uint_pos278(X,Y) get_gdat_uint((X),(Y),278) +#define get_gdat_ullong_pos278(X,Y) get_gdat_ullong((X),(Y),278) +#define get_gdat_ip_pos278(X,Y) get_gdat_ip((X),(Y),278) +#define get_gdat_ipv6_pos278(X,Y) get_gdat_ipv6((X),(Y),278) +#define get_gdat_string_pos278(X,Y) get_gdat_string((X),(Y),278) +#define get_gdat_v_str_pos278(X,Y) get_gdat_string((X),(Y),278) +#define get_gdat_bool_pos278(X,Y) get_gdat_bool((X),(Y),278) +#define get_gdat_int_pos278(X,Y) get_gdat_int((X),(Y),278) +#define get_gdat_llong_pos278(X,Y) get_gdat_llong((X),(Y),278) +#define get_gdat_float_pos278(X,Y) get_gdat_float((X),(Y),278) +#define get_gdat_uint_pos279(X,Y) get_gdat_uint((X),(Y),279) +#define get_gdat_ullong_pos279(X,Y) get_gdat_ullong((X),(Y),279) +#define get_gdat_ip_pos279(X,Y) get_gdat_ip((X),(Y),279) +#define get_gdat_ipv6_pos279(X,Y) get_gdat_ipv6((X),(Y),279) +#define get_gdat_string_pos279(X,Y) get_gdat_string((X),(Y),279) +#define get_gdat_v_str_pos279(X,Y) get_gdat_string((X),(Y),279) +#define get_gdat_bool_pos279(X,Y) get_gdat_bool((X),(Y),279) +#define get_gdat_int_pos279(X,Y) get_gdat_int((X),(Y),279) +#define get_gdat_llong_pos279(X,Y) get_gdat_llong((X),(Y),279) +#define get_gdat_float_pos279(X,Y) get_gdat_float((X),(Y),279) +#define get_gdat_uint_pos280(X,Y) get_gdat_uint((X),(Y),280) +#define get_gdat_ullong_pos280(X,Y) get_gdat_ullong((X),(Y),280) +#define get_gdat_ip_pos280(X,Y) get_gdat_ip((X),(Y),280) +#define get_gdat_ipv6_pos280(X,Y) get_gdat_ipv6((X),(Y),280) +#define get_gdat_string_pos280(X,Y) get_gdat_string((X),(Y),280) +#define get_gdat_v_str_pos280(X,Y) get_gdat_string((X),(Y),280) +#define get_gdat_bool_pos280(X,Y) get_gdat_bool((X),(Y),280) +#define get_gdat_int_pos280(X,Y) get_gdat_int((X),(Y),280) +#define get_gdat_llong_pos280(X,Y) get_gdat_llong((X),(Y),280) +#define get_gdat_float_pos280(X,Y) get_gdat_float((X),(Y),280) +#define get_gdat_uint_pos281(X,Y) get_gdat_uint((X),(Y),281) +#define get_gdat_ullong_pos281(X,Y) get_gdat_ullong((X),(Y),281) +#define get_gdat_ip_pos281(X,Y) get_gdat_ip((X),(Y),281) +#define get_gdat_ipv6_pos281(X,Y) get_gdat_ipv6((X),(Y),281) +#define get_gdat_string_pos281(X,Y) get_gdat_string((X),(Y),281) +#define get_gdat_v_str_pos281(X,Y) get_gdat_string((X),(Y),281) +#define get_gdat_bool_pos281(X,Y) get_gdat_bool((X),(Y),281) +#define get_gdat_int_pos281(X,Y) get_gdat_int((X),(Y),281) +#define get_gdat_llong_pos281(X,Y) get_gdat_llong((X),(Y),281) +#define get_gdat_float_pos281(X,Y) get_gdat_float((X),(Y),281) +#define get_gdat_uint_pos282(X,Y) get_gdat_uint((X),(Y),282) +#define get_gdat_ullong_pos282(X,Y) get_gdat_ullong((X),(Y),282) +#define get_gdat_ip_pos282(X,Y) get_gdat_ip((X),(Y),282) +#define get_gdat_ipv6_pos282(X,Y) get_gdat_ipv6((X),(Y),282) +#define get_gdat_string_pos282(X,Y) get_gdat_string((X),(Y),282) +#define get_gdat_v_str_pos282(X,Y) get_gdat_string((X),(Y),282) +#define get_gdat_bool_pos282(X,Y) get_gdat_bool((X),(Y),282) +#define get_gdat_int_pos282(X,Y) get_gdat_int((X),(Y),282) +#define get_gdat_llong_pos282(X,Y) get_gdat_llong((X),(Y),282) +#define get_gdat_float_pos282(X,Y) get_gdat_float((X),(Y),282) +#define get_gdat_uint_pos283(X,Y) get_gdat_uint((X),(Y),283) +#define get_gdat_ullong_pos283(X,Y) get_gdat_ullong((X),(Y),283) +#define get_gdat_ip_pos283(X,Y) get_gdat_ip((X),(Y),283) +#define get_gdat_ipv6_pos283(X,Y) get_gdat_ipv6((X),(Y),283) +#define get_gdat_string_pos283(X,Y) get_gdat_string((X),(Y),283) +#define get_gdat_v_str_pos283(X,Y) get_gdat_string((X),(Y),283) +#define get_gdat_bool_pos283(X,Y) get_gdat_bool((X),(Y),283) +#define get_gdat_int_pos283(X,Y) get_gdat_int((X),(Y),283) +#define get_gdat_llong_pos283(X,Y) get_gdat_llong((X),(Y),283) +#define get_gdat_float_pos283(X,Y) get_gdat_float((X),(Y),283) +#define get_gdat_uint_pos284(X,Y) get_gdat_uint((X),(Y),284) +#define get_gdat_ullong_pos284(X,Y) get_gdat_ullong((X),(Y),284) +#define get_gdat_ip_pos284(X,Y) get_gdat_ip((X),(Y),284) +#define get_gdat_ipv6_pos284(X,Y) get_gdat_ipv6((X),(Y),284) +#define get_gdat_string_pos284(X,Y) get_gdat_string((X),(Y),284) +#define get_gdat_v_str_pos284(X,Y) get_gdat_string((X),(Y),284) +#define get_gdat_bool_pos284(X,Y) get_gdat_bool((X),(Y),284) +#define get_gdat_int_pos284(X,Y) get_gdat_int((X),(Y),284) +#define get_gdat_llong_pos284(X,Y) get_gdat_llong((X),(Y),284) +#define get_gdat_float_pos284(X,Y) get_gdat_float((X),(Y),284) +#define get_gdat_uint_pos285(X,Y) get_gdat_uint((X),(Y),285) +#define get_gdat_ullong_pos285(X,Y) get_gdat_ullong((X),(Y),285) +#define get_gdat_ip_pos285(X,Y) get_gdat_ip((X),(Y),285) +#define get_gdat_ipv6_pos285(X,Y) get_gdat_ipv6((X),(Y),285) +#define get_gdat_string_pos285(X,Y) get_gdat_string((X),(Y),285) +#define get_gdat_v_str_pos285(X,Y) get_gdat_string((X),(Y),285) +#define get_gdat_bool_pos285(X,Y) get_gdat_bool((X),(Y),285) +#define get_gdat_int_pos285(X,Y) get_gdat_int((X),(Y),285) +#define get_gdat_llong_pos285(X,Y) get_gdat_llong((X),(Y),285) +#define get_gdat_float_pos285(X,Y) get_gdat_float((X),(Y),285) +#define get_gdat_uint_pos286(X,Y) get_gdat_uint((X),(Y),286) +#define get_gdat_ullong_pos286(X,Y) get_gdat_ullong((X),(Y),286) +#define get_gdat_ip_pos286(X,Y) get_gdat_ip((X),(Y),286) +#define get_gdat_ipv6_pos286(X,Y) get_gdat_ipv6((X),(Y),286) +#define get_gdat_string_pos286(X,Y) get_gdat_string((X),(Y),286) +#define get_gdat_v_str_pos286(X,Y) get_gdat_string((X),(Y),286) +#define get_gdat_bool_pos286(X,Y) get_gdat_bool((X),(Y),286) +#define get_gdat_int_pos286(X,Y) get_gdat_int((X),(Y),286) +#define get_gdat_llong_pos286(X,Y) get_gdat_llong((X),(Y),286) +#define get_gdat_float_pos286(X,Y) get_gdat_float((X),(Y),286) +#define get_gdat_uint_pos287(X,Y) get_gdat_uint((X),(Y),287) +#define get_gdat_ullong_pos287(X,Y) get_gdat_ullong((X),(Y),287) +#define get_gdat_ip_pos287(X,Y) get_gdat_ip((X),(Y),287) +#define get_gdat_ipv6_pos287(X,Y) get_gdat_ipv6((X),(Y),287) +#define get_gdat_string_pos287(X,Y) get_gdat_string((X),(Y),287) +#define get_gdat_v_str_pos287(X,Y) get_gdat_string((X),(Y),287) +#define get_gdat_bool_pos287(X,Y) get_gdat_bool((X),(Y),287) +#define get_gdat_int_pos287(X,Y) get_gdat_int((X),(Y),287) +#define get_gdat_llong_pos287(X,Y) get_gdat_llong((X),(Y),287) +#define get_gdat_float_pos287(X,Y) get_gdat_float((X),(Y),287) +#define get_gdat_uint_pos288(X,Y) get_gdat_uint((X),(Y),288) +#define get_gdat_ullong_pos288(X,Y) get_gdat_ullong((X),(Y),288) +#define get_gdat_ip_pos288(X,Y) get_gdat_ip((X),(Y),288) +#define get_gdat_ipv6_pos288(X,Y) get_gdat_ipv6((X),(Y),288) +#define get_gdat_string_pos288(X,Y) get_gdat_string((X),(Y),288) +#define get_gdat_v_str_pos288(X,Y) get_gdat_string((X),(Y),288) +#define get_gdat_bool_pos288(X,Y) get_gdat_bool((X),(Y),288) +#define get_gdat_int_pos288(X,Y) get_gdat_int((X),(Y),288) +#define get_gdat_llong_pos288(X,Y) get_gdat_llong((X),(Y),288) +#define get_gdat_float_pos288(X,Y) get_gdat_float((X),(Y),288) +#define get_gdat_uint_pos289(X,Y) get_gdat_uint((X),(Y),289) +#define get_gdat_ullong_pos289(X,Y) get_gdat_ullong((X),(Y),289) +#define get_gdat_ip_pos289(X,Y) get_gdat_ip((X),(Y),289) +#define get_gdat_ipv6_pos289(X,Y) get_gdat_ipv6((X),(Y),289) +#define get_gdat_string_pos289(X,Y) get_gdat_string((X),(Y),289) +#define get_gdat_v_str_pos289(X,Y) get_gdat_string((X),(Y),289) +#define get_gdat_bool_pos289(X,Y) get_gdat_bool((X),(Y),289) +#define get_gdat_int_pos289(X,Y) get_gdat_int((X),(Y),289) +#define get_gdat_llong_pos289(X,Y) get_gdat_llong((X),(Y),289) +#define get_gdat_float_pos289(X,Y) get_gdat_float((X),(Y),289) +#define get_gdat_uint_pos290(X,Y) get_gdat_uint((X),(Y),290) +#define get_gdat_ullong_pos290(X,Y) get_gdat_ullong((X),(Y),290) +#define get_gdat_ip_pos290(X,Y) get_gdat_ip((X),(Y),290) +#define get_gdat_ipv6_pos290(X,Y) get_gdat_ipv6((X),(Y),290) +#define get_gdat_string_pos290(X,Y) get_gdat_string((X),(Y),290) +#define get_gdat_v_str_pos290(X,Y) get_gdat_string((X),(Y),290) +#define get_gdat_bool_pos290(X,Y) get_gdat_bool((X),(Y),290) +#define get_gdat_int_pos290(X,Y) get_gdat_int((X),(Y),290) +#define get_gdat_llong_pos290(X,Y) get_gdat_llong((X),(Y),290) +#define get_gdat_float_pos290(X,Y) get_gdat_float((X),(Y),290) +#define get_gdat_uint_pos291(X,Y) get_gdat_uint((X),(Y),291) +#define get_gdat_ullong_pos291(X,Y) get_gdat_ullong((X),(Y),291) +#define get_gdat_ip_pos291(X,Y) get_gdat_ip((X),(Y),291) +#define get_gdat_ipv6_pos291(X,Y) get_gdat_ipv6((X),(Y),291) +#define get_gdat_string_pos291(X,Y) get_gdat_string((X),(Y),291) +#define get_gdat_v_str_pos291(X,Y) get_gdat_string((X),(Y),291) +#define get_gdat_bool_pos291(X,Y) get_gdat_bool((X),(Y),291) +#define get_gdat_int_pos291(X,Y) get_gdat_int((X),(Y),291) +#define get_gdat_llong_pos291(X,Y) get_gdat_llong((X),(Y),291) +#define get_gdat_float_pos291(X,Y) get_gdat_float((X),(Y),291) +#define get_gdat_uint_pos292(X,Y) get_gdat_uint((X),(Y),292) +#define get_gdat_ullong_pos292(X,Y) get_gdat_ullong((X),(Y),292) +#define get_gdat_ip_pos292(X,Y) get_gdat_ip((X),(Y),292) +#define get_gdat_ipv6_pos292(X,Y) get_gdat_ipv6((X),(Y),292) +#define get_gdat_string_pos292(X,Y) get_gdat_string((X),(Y),292) +#define get_gdat_v_str_pos292(X,Y) get_gdat_string((X),(Y),292) +#define get_gdat_bool_pos292(X,Y) get_gdat_bool((X),(Y),292) +#define get_gdat_int_pos292(X,Y) get_gdat_int((X),(Y),292) +#define get_gdat_llong_pos292(X,Y) get_gdat_llong((X),(Y),292) +#define get_gdat_float_pos292(X,Y) get_gdat_float((X),(Y),292) +#define get_gdat_uint_pos293(X,Y) get_gdat_uint((X),(Y),293) +#define get_gdat_ullong_pos293(X,Y) get_gdat_ullong((X),(Y),293) +#define get_gdat_ip_pos293(X,Y) get_gdat_ip((X),(Y),293) +#define get_gdat_ipv6_pos293(X,Y) get_gdat_ipv6((X),(Y),293) +#define get_gdat_string_pos293(X,Y) get_gdat_string((X),(Y),293) +#define get_gdat_v_str_pos293(X,Y) get_gdat_string((X),(Y),293) +#define get_gdat_bool_pos293(X,Y) get_gdat_bool((X),(Y),293) +#define get_gdat_int_pos293(X,Y) get_gdat_int((X),(Y),293) +#define get_gdat_llong_pos293(X,Y) get_gdat_llong((X),(Y),293) +#define get_gdat_float_pos293(X,Y) get_gdat_float((X),(Y),293) +#define get_gdat_uint_pos294(X,Y) get_gdat_uint((X),(Y),294) +#define get_gdat_ullong_pos294(X,Y) get_gdat_ullong((X),(Y),294) +#define get_gdat_ip_pos294(X,Y) get_gdat_ip((X),(Y),294) +#define get_gdat_ipv6_pos294(X,Y) get_gdat_ipv6((X),(Y),294) +#define get_gdat_string_pos294(X,Y) get_gdat_string((X),(Y),294) +#define get_gdat_v_str_pos294(X,Y) get_gdat_string((X),(Y),294) +#define get_gdat_bool_pos294(X,Y) get_gdat_bool((X),(Y),294) +#define get_gdat_int_pos294(X,Y) get_gdat_int((X),(Y),294) +#define get_gdat_llong_pos294(X,Y) get_gdat_llong((X),(Y),294) +#define get_gdat_float_pos294(X,Y) get_gdat_float((X),(Y),294) +#define get_gdat_uint_pos295(X,Y) get_gdat_uint((X),(Y),295) +#define get_gdat_ullong_pos295(X,Y) get_gdat_ullong((X),(Y),295) +#define get_gdat_ip_pos295(X,Y) get_gdat_ip((X),(Y),295) +#define get_gdat_ipv6_pos295(X,Y) get_gdat_ipv6((X),(Y),295) +#define get_gdat_string_pos295(X,Y) get_gdat_string((X),(Y),295) +#define get_gdat_v_str_pos295(X,Y) get_gdat_string((X),(Y),295) +#define get_gdat_bool_pos295(X,Y) get_gdat_bool((X),(Y),295) +#define get_gdat_int_pos295(X,Y) get_gdat_int((X),(Y),295) +#define get_gdat_llong_pos295(X,Y) get_gdat_llong((X),(Y),295) +#define get_gdat_float_pos295(X,Y) get_gdat_float((X),(Y),295) +#define get_gdat_uint_pos296(X,Y) get_gdat_uint((X),(Y),296) +#define get_gdat_ullong_pos296(X,Y) get_gdat_ullong((X),(Y),296) +#define get_gdat_ip_pos296(X,Y) get_gdat_ip((X),(Y),296) +#define get_gdat_ipv6_pos296(X,Y) get_gdat_ipv6((X),(Y),296) +#define get_gdat_string_pos296(X,Y) get_gdat_string((X),(Y),296) +#define get_gdat_v_str_pos296(X,Y) get_gdat_string((X),(Y),296) +#define get_gdat_bool_pos296(X,Y) get_gdat_bool((X),(Y),296) +#define get_gdat_int_pos296(X,Y) get_gdat_int((X),(Y),296) +#define get_gdat_llong_pos296(X,Y) get_gdat_llong((X),(Y),296) +#define get_gdat_float_pos296(X,Y) get_gdat_float((X),(Y),296) +#define get_gdat_uint_pos297(X,Y) get_gdat_uint((X),(Y),297) +#define get_gdat_ullong_pos297(X,Y) get_gdat_ullong((X),(Y),297) +#define get_gdat_ip_pos297(X,Y) get_gdat_ip((X),(Y),297) +#define get_gdat_ipv6_pos297(X,Y) get_gdat_ipv6((X),(Y),297) +#define get_gdat_string_pos297(X,Y) get_gdat_string((X),(Y),297) +#define get_gdat_v_str_pos297(X,Y) get_gdat_string((X),(Y),297) +#define get_gdat_bool_pos297(X,Y) get_gdat_bool((X),(Y),297) +#define get_gdat_int_pos297(X,Y) get_gdat_int((X),(Y),297) +#define get_gdat_llong_pos297(X,Y) get_gdat_llong((X),(Y),297) +#define get_gdat_float_pos297(X,Y) get_gdat_float((X),(Y),297) +#define get_gdat_uint_pos298(X,Y) get_gdat_uint((X),(Y),298) +#define get_gdat_ullong_pos298(X,Y) get_gdat_ullong((X),(Y),298) +#define get_gdat_ip_pos298(X,Y) get_gdat_ip((X),(Y),298) +#define get_gdat_ipv6_pos298(X,Y) get_gdat_ipv6((X),(Y),298) +#define get_gdat_string_pos298(X,Y) get_gdat_string((X),(Y),298) +#define get_gdat_v_str_pos298(X,Y) get_gdat_string((X),(Y),298) +#define get_gdat_bool_pos298(X,Y) get_gdat_bool((X),(Y),298) +#define get_gdat_int_pos298(X,Y) get_gdat_int((X),(Y),298) +#define get_gdat_llong_pos298(X,Y) get_gdat_llong((X),(Y),298) +#define get_gdat_float_pos298(X,Y) get_gdat_float((X),(Y),298) +#define get_gdat_uint_pos299(X,Y) get_gdat_uint((X),(Y),299) +#define get_gdat_ullong_pos299(X,Y) get_gdat_ullong((X),(Y),299) +#define get_gdat_ip_pos299(X,Y) get_gdat_ip((X),(Y),299) +#define get_gdat_ipv6_pos299(X,Y) get_gdat_ipv6((X),(Y),299) +#define get_gdat_string_pos299(X,Y) get_gdat_string((X),(Y),299) +#define get_gdat_v_str_pos299(X,Y) get_gdat_string((X),(Y),299) +#define get_gdat_bool_pos299(X,Y) get_gdat_bool((X),(Y),299) +#define get_gdat_int_pos299(X,Y) get_gdat_int((X),(Y),299) +#define get_gdat_llong_pos299(X,Y) get_gdat_llong((X),(Y),299) +#define get_gdat_float_pos299(X,Y) get_gdat_float((X),(Y),299) +#define get_gdat_uint_pos300(X,Y) get_gdat_uint((X),(Y),300) +#define get_gdat_ullong_pos300(X,Y) get_gdat_ullong((X),(Y),300) +#define get_gdat_ip_pos300(X,Y) get_gdat_ip((X),(Y),300) +#define get_gdat_ipv6_pos300(X,Y) get_gdat_ipv6((X),(Y),300) +#define get_gdat_string_pos300(X,Y) get_gdat_string((X),(Y),300) +#define get_gdat_v_str_pos300(X,Y) get_gdat_string((X),(Y),300) +#define get_gdat_bool_pos300(X,Y) get_gdat_bool((X),(Y),300) +#define get_gdat_int_pos300(X,Y) get_gdat_int((X),(Y),300) +#define get_gdat_llong_pos300(X,Y) get_gdat_llong((X),(Y),300) +#define get_gdat_float_pos300(X,Y) get_gdat_float((X),(Y),300) +#define get_gdat_uint_pos301(X,Y) get_gdat_uint((X),(Y),301) +#define get_gdat_ullong_pos301(X,Y) get_gdat_ullong((X),(Y),301) +#define get_gdat_ip_pos301(X,Y) get_gdat_ip((X),(Y),301) +#define get_gdat_ipv6_pos301(X,Y) get_gdat_ipv6((X),(Y),301) +#define get_gdat_string_pos301(X,Y) get_gdat_string((X),(Y),301) +#define get_gdat_v_str_pos301(X,Y) get_gdat_string((X),(Y),301) +#define get_gdat_bool_pos301(X,Y) get_gdat_bool((X),(Y),301) +#define get_gdat_int_pos301(X,Y) get_gdat_int((X),(Y),301) +#define get_gdat_llong_pos301(X,Y) get_gdat_llong((X),(Y),301) +#define get_gdat_float_pos301(X,Y) get_gdat_float((X),(Y),301) +#define get_gdat_uint_pos302(X,Y) get_gdat_uint((X),(Y),302) +#define get_gdat_ullong_pos302(X,Y) get_gdat_ullong((X),(Y),302) +#define get_gdat_ip_pos302(X,Y) get_gdat_ip((X),(Y),302) +#define get_gdat_ipv6_pos302(X,Y) get_gdat_ipv6((X),(Y),302) +#define get_gdat_string_pos302(X,Y) get_gdat_string((X),(Y),302) +#define get_gdat_v_str_pos302(X,Y) get_gdat_string((X),(Y),302) +#define get_gdat_bool_pos302(X,Y) get_gdat_bool((X),(Y),302) +#define get_gdat_int_pos302(X,Y) get_gdat_int((X),(Y),302) +#define get_gdat_llong_pos302(X,Y) get_gdat_llong((X),(Y),302) +#define get_gdat_float_pos302(X,Y) get_gdat_float((X),(Y),302) +#define get_gdat_uint_pos303(X,Y) get_gdat_uint((X),(Y),303) +#define get_gdat_ullong_pos303(X,Y) get_gdat_ullong((X),(Y),303) +#define get_gdat_ip_pos303(X,Y) get_gdat_ip((X),(Y),303) +#define get_gdat_ipv6_pos303(X,Y) get_gdat_ipv6((X),(Y),303) +#define get_gdat_string_pos303(X,Y) get_gdat_string((X),(Y),303) +#define get_gdat_v_str_pos303(X,Y) get_gdat_string((X),(Y),303) +#define get_gdat_bool_pos303(X,Y) get_gdat_bool((X),(Y),303) +#define get_gdat_int_pos303(X,Y) get_gdat_int((X),(Y),303) +#define get_gdat_llong_pos303(X,Y) get_gdat_llong((X),(Y),303) +#define get_gdat_float_pos303(X,Y) get_gdat_float((X),(Y),303) +#define get_gdat_uint_pos304(X,Y) get_gdat_uint((X),(Y),304) +#define get_gdat_ullong_pos304(X,Y) get_gdat_ullong((X),(Y),304) +#define get_gdat_ip_pos304(X,Y) get_gdat_ip((X),(Y),304) +#define get_gdat_ipv6_pos304(X,Y) get_gdat_ipv6((X),(Y),304) +#define get_gdat_string_pos304(X,Y) get_gdat_string((X),(Y),304) +#define get_gdat_v_str_pos304(X,Y) get_gdat_string((X),(Y),304) +#define get_gdat_bool_pos304(X,Y) get_gdat_bool((X),(Y),304) +#define get_gdat_int_pos304(X,Y) get_gdat_int((X),(Y),304) +#define get_gdat_llong_pos304(X,Y) get_gdat_llong((X),(Y),304) +#define get_gdat_float_pos304(X,Y) get_gdat_float((X),(Y),304) +#define get_gdat_uint_pos305(X,Y) get_gdat_uint((X),(Y),305) +#define get_gdat_ullong_pos305(X,Y) get_gdat_ullong((X),(Y),305) +#define get_gdat_ip_pos305(X,Y) get_gdat_ip((X),(Y),305) +#define get_gdat_ipv6_pos305(X,Y) get_gdat_ipv6((X),(Y),305) +#define get_gdat_string_pos305(X,Y) get_gdat_string((X),(Y),305) +#define get_gdat_v_str_pos305(X,Y) get_gdat_string((X),(Y),305) +#define get_gdat_bool_pos305(X,Y) get_gdat_bool((X),(Y),305) +#define get_gdat_int_pos305(X,Y) get_gdat_int((X),(Y),305) +#define get_gdat_llong_pos305(X,Y) get_gdat_llong((X),(Y),305) +#define get_gdat_float_pos305(X,Y) get_gdat_float((X),(Y),305) +#define get_gdat_uint_pos306(X,Y) get_gdat_uint((X),(Y),306) +#define get_gdat_ullong_pos306(X,Y) get_gdat_ullong((X),(Y),306) +#define get_gdat_ip_pos306(X,Y) get_gdat_ip((X),(Y),306) +#define get_gdat_ipv6_pos306(X,Y) get_gdat_ipv6((X),(Y),306) +#define get_gdat_string_pos306(X,Y) get_gdat_string((X),(Y),306) +#define get_gdat_v_str_pos306(X,Y) get_gdat_string((X),(Y),306) +#define get_gdat_bool_pos306(X,Y) get_gdat_bool((X),(Y),306) +#define get_gdat_int_pos306(X,Y) get_gdat_int((X),(Y),306) +#define get_gdat_llong_pos306(X,Y) get_gdat_llong((X),(Y),306) +#define get_gdat_float_pos306(X,Y) get_gdat_float((X),(Y),306) +#define get_gdat_uint_pos307(X,Y) get_gdat_uint((X),(Y),307) +#define get_gdat_ullong_pos307(X,Y) get_gdat_ullong((X),(Y),307) +#define get_gdat_ip_pos307(X,Y) get_gdat_ip((X),(Y),307) +#define get_gdat_ipv6_pos307(X,Y) get_gdat_ipv6((X),(Y),307) +#define get_gdat_string_pos307(X,Y) get_gdat_string((X),(Y),307) +#define get_gdat_v_str_pos307(X,Y) get_gdat_string((X),(Y),307) +#define get_gdat_bool_pos307(X,Y) get_gdat_bool((X),(Y),307) +#define get_gdat_int_pos307(X,Y) get_gdat_int((X),(Y),307) +#define get_gdat_llong_pos307(X,Y) get_gdat_llong((X),(Y),307) +#define get_gdat_float_pos307(X,Y) get_gdat_float((X),(Y),307) +#define get_gdat_uint_pos308(X,Y) get_gdat_uint((X),(Y),308) +#define get_gdat_ullong_pos308(X,Y) get_gdat_ullong((X),(Y),308) +#define get_gdat_ip_pos308(X,Y) get_gdat_ip((X),(Y),308) +#define get_gdat_ipv6_pos308(X,Y) get_gdat_ipv6((X),(Y),308) +#define get_gdat_string_pos308(X,Y) get_gdat_string((X),(Y),308) +#define get_gdat_v_str_pos308(X,Y) get_gdat_string((X),(Y),308) +#define get_gdat_bool_pos308(X,Y) get_gdat_bool((X),(Y),308) +#define get_gdat_int_pos308(X,Y) get_gdat_int((X),(Y),308) +#define get_gdat_llong_pos308(X,Y) get_gdat_llong((X),(Y),308) +#define get_gdat_float_pos308(X,Y) get_gdat_float((X),(Y),308) +#define get_gdat_uint_pos309(X,Y) get_gdat_uint((X),(Y),309) +#define get_gdat_ullong_pos309(X,Y) get_gdat_ullong((X),(Y),309) +#define get_gdat_ip_pos309(X,Y) get_gdat_ip((X),(Y),309) +#define get_gdat_ipv6_pos309(X,Y) get_gdat_ipv6((X),(Y),309) +#define get_gdat_string_pos309(X,Y) get_gdat_string((X),(Y),309) +#define get_gdat_v_str_pos309(X,Y) get_gdat_string((X),(Y),309) +#define get_gdat_bool_pos309(X,Y) get_gdat_bool((X),(Y),309) +#define get_gdat_int_pos309(X,Y) get_gdat_int((X),(Y),309) +#define get_gdat_llong_pos309(X,Y) get_gdat_llong((X),(Y),309) +#define get_gdat_float_pos309(X,Y) get_gdat_float((X),(Y),309) +#define get_gdat_uint_pos310(X,Y) get_gdat_uint((X),(Y),310) +#define get_gdat_ullong_pos310(X,Y) get_gdat_ullong((X),(Y),310) +#define get_gdat_ip_pos310(X,Y) get_gdat_ip((X),(Y),310) +#define get_gdat_ipv6_pos310(X,Y) get_gdat_ipv6((X),(Y),310) +#define get_gdat_string_pos310(X,Y) get_gdat_string((X),(Y),310) +#define get_gdat_v_str_pos310(X,Y) get_gdat_string((X),(Y),310) +#define get_gdat_bool_pos310(X,Y) get_gdat_bool((X),(Y),310) +#define get_gdat_int_pos310(X,Y) get_gdat_int((X),(Y),310) +#define get_gdat_llong_pos310(X,Y) get_gdat_llong((X),(Y),310) +#define get_gdat_float_pos310(X,Y) get_gdat_float((X),(Y),310) +#define get_gdat_uint_pos311(X,Y) get_gdat_uint((X),(Y),311) +#define get_gdat_ullong_pos311(X,Y) get_gdat_ullong((X),(Y),311) +#define get_gdat_ip_pos311(X,Y) get_gdat_ip((X),(Y),311) +#define get_gdat_ipv6_pos311(X,Y) get_gdat_ipv6((X),(Y),311) +#define get_gdat_string_pos311(X,Y) get_gdat_string((X),(Y),311) +#define get_gdat_v_str_pos311(X,Y) get_gdat_string((X),(Y),311) +#define get_gdat_bool_pos311(X,Y) get_gdat_bool((X),(Y),311) +#define get_gdat_int_pos311(X,Y) get_gdat_int((X),(Y),311) +#define get_gdat_llong_pos311(X,Y) get_gdat_llong((X),(Y),311) +#define get_gdat_float_pos311(X,Y) get_gdat_float((X),(Y),311) +#define get_gdat_uint_pos312(X,Y) get_gdat_uint((X),(Y),312) +#define get_gdat_ullong_pos312(X,Y) get_gdat_ullong((X),(Y),312) +#define get_gdat_ip_pos312(X,Y) get_gdat_ip((X),(Y),312) +#define get_gdat_ipv6_pos312(X,Y) get_gdat_ipv6((X),(Y),312) +#define get_gdat_string_pos312(X,Y) get_gdat_string((X),(Y),312) +#define get_gdat_v_str_pos312(X,Y) get_gdat_string((X),(Y),312) +#define get_gdat_bool_pos312(X,Y) get_gdat_bool((X),(Y),312) +#define get_gdat_int_pos312(X,Y) get_gdat_int((X),(Y),312) +#define get_gdat_llong_pos312(X,Y) get_gdat_llong((X),(Y),312) +#define get_gdat_float_pos312(X,Y) get_gdat_float((X),(Y),312) +#define get_gdat_uint_pos313(X,Y) get_gdat_uint((X),(Y),313) +#define get_gdat_ullong_pos313(X,Y) get_gdat_ullong((X),(Y),313) +#define get_gdat_ip_pos313(X,Y) get_gdat_ip((X),(Y),313) +#define get_gdat_ipv6_pos313(X,Y) get_gdat_ipv6((X),(Y),313) +#define get_gdat_string_pos313(X,Y) get_gdat_string((X),(Y),313) +#define get_gdat_v_str_pos313(X,Y) get_gdat_string((X),(Y),313) +#define get_gdat_bool_pos313(X,Y) get_gdat_bool((X),(Y),313) +#define get_gdat_int_pos313(X,Y) get_gdat_int((X),(Y),313) +#define get_gdat_llong_pos313(X,Y) get_gdat_llong((X),(Y),313) +#define get_gdat_float_pos313(X,Y) get_gdat_float((X),(Y),313) +#define get_gdat_uint_pos314(X,Y) get_gdat_uint((X),(Y),314) +#define get_gdat_ullong_pos314(X,Y) get_gdat_ullong((X),(Y),314) +#define get_gdat_ip_pos314(X,Y) get_gdat_ip((X),(Y),314) +#define get_gdat_ipv6_pos314(X,Y) get_gdat_ipv6((X),(Y),314) +#define get_gdat_string_pos314(X,Y) get_gdat_string((X),(Y),314) +#define get_gdat_v_str_pos314(X,Y) get_gdat_string((X),(Y),314) +#define get_gdat_bool_pos314(X,Y) get_gdat_bool((X),(Y),314) +#define get_gdat_int_pos314(X,Y) get_gdat_int((X),(Y),314) +#define get_gdat_llong_pos314(X,Y) get_gdat_llong((X),(Y),314) +#define get_gdat_float_pos314(X,Y) get_gdat_float((X),(Y),314) +#define get_gdat_uint_pos315(X,Y) get_gdat_uint((X),(Y),315) +#define get_gdat_ullong_pos315(X,Y) get_gdat_ullong((X),(Y),315) +#define get_gdat_ip_pos315(X,Y) get_gdat_ip((X),(Y),315) +#define get_gdat_ipv6_pos315(X,Y) get_gdat_ipv6((X),(Y),315) +#define get_gdat_string_pos315(X,Y) get_gdat_string((X),(Y),315) +#define get_gdat_v_str_pos315(X,Y) get_gdat_string((X),(Y),315) +#define get_gdat_bool_pos315(X,Y) get_gdat_bool((X),(Y),315) +#define get_gdat_int_pos315(X,Y) get_gdat_int((X),(Y),315) +#define get_gdat_llong_pos315(X,Y) get_gdat_llong((X),(Y),315) +#define get_gdat_float_pos315(X,Y) get_gdat_float((X),(Y),315) +#define get_gdat_uint_pos316(X,Y) get_gdat_uint((X),(Y),316) +#define get_gdat_ullong_pos316(X,Y) get_gdat_ullong((X),(Y),316) +#define get_gdat_ip_pos316(X,Y) get_gdat_ip((X),(Y),316) +#define get_gdat_ipv6_pos316(X,Y) get_gdat_ipv6((X),(Y),316) +#define get_gdat_string_pos316(X,Y) get_gdat_string((X),(Y),316) +#define get_gdat_v_str_pos316(X,Y) get_gdat_string((X),(Y),316) +#define get_gdat_bool_pos316(X,Y) get_gdat_bool((X),(Y),316) +#define get_gdat_int_pos316(X,Y) get_gdat_int((X),(Y),316) +#define get_gdat_llong_pos316(X,Y) get_gdat_llong((X),(Y),316) +#define get_gdat_float_pos316(X,Y) get_gdat_float((X),(Y),316) +#define get_gdat_uint_pos317(X,Y) get_gdat_uint((X),(Y),317) +#define get_gdat_ullong_pos317(X,Y) get_gdat_ullong((X),(Y),317) +#define get_gdat_ip_pos317(X,Y) get_gdat_ip((X),(Y),317) +#define get_gdat_ipv6_pos317(X,Y) get_gdat_ipv6((X),(Y),317) +#define get_gdat_string_pos317(X,Y) get_gdat_string((X),(Y),317) +#define get_gdat_v_str_pos317(X,Y) get_gdat_string((X),(Y),317) +#define get_gdat_bool_pos317(X,Y) get_gdat_bool((X),(Y),317) +#define get_gdat_int_pos317(X,Y) get_gdat_int((X),(Y),317) +#define get_gdat_llong_pos317(X,Y) get_gdat_llong((X),(Y),317) +#define get_gdat_float_pos317(X,Y) get_gdat_float((X),(Y),317) +#define get_gdat_uint_pos318(X,Y) get_gdat_uint((X),(Y),318) +#define get_gdat_ullong_pos318(X,Y) get_gdat_ullong((X),(Y),318) +#define get_gdat_ip_pos318(X,Y) get_gdat_ip((X),(Y),318) +#define get_gdat_ipv6_pos318(X,Y) get_gdat_ipv6((X),(Y),318) +#define get_gdat_string_pos318(X,Y) get_gdat_string((X),(Y),318) +#define get_gdat_v_str_pos318(X,Y) get_gdat_string((X),(Y),318) +#define get_gdat_bool_pos318(X,Y) get_gdat_bool((X),(Y),318) +#define get_gdat_int_pos318(X,Y) get_gdat_int((X),(Y),318) +#define get_gdat_llong_pos318(X,Y) get_gdat_llong((X),(Y),318) +#define get_gdat_float_pos318(X,Y) get_gdat_float((X),(Y),318) +#define get_gdat_uint_pos319(X,Y) get_gdat_uint((X),(Y),319) +#define get_gdat_ullong_pos319(X,Y) get_gdat_ullong((X),(Y),319) +#define get_gdat_ip_pos319(X,Y) get_gdat_ip((X),(Y),319) +#define get_gdat_ipv6_pos319(X,Y) get_gdat_ipv6((X),(Y),319) +#define get_gdat_string_pos319(X,Y) get_gdat_string((X),(Y),319) +#define get_gdat_v_str_pos319(X,Y) get_gdat_string((X),(Y),319) +#define get_gdat_bool_pos319(X,Y) get_gdat_bool((X),(Y),319) +#define get_gdat_int_pos319(X,Y) get_gdat_int((X),(Y),319) +#define get_gdat_llong_pos319(X,Y) get_gdat_llong((X),(Y),319) +#define get_gdat_float_pos319(X,Y) get_gdat_float((X),(Y),319) +#define get_gdat_uint_pos320(X,Y) get_gdat_uint((X),(Y),320) +#define get_gdat_ullong_pos320(X,Y) get_gdat_ullong((X),(Y),320) +#define get_gdat_ip_pos320(X,Y) get_gdat_ip((X),(Y),320) +#define get_gdat_ipv6_pos320(X,Y) get_gdat_ipv6((X),(Y),320) +#define get_gdat_string_pos320(X,Y) get_gdat_string((X),(Y),320) +#define get_gdat_v_str_pos320(X,Y) get_gdat_string((X),(Y),320) +#define get_gdat_bool_pos320(X,Y) get_gdat_bool((X),(Y),320) +#define get_gdat_int_pos320(X,Y) get_gdat_int((X),(Y),320) +#define get_gdat_llong_pos320(X,Y) get_gdat_llong((X),(Y),320) +#define get_gdat_float_pos320(X,Y) get_gdat_float((X),(Y),320) +#define get_gdat_uint_pos321(X,Y) get_gdat_uint((X),(Y),321) +#define get_gdat_ullong_pos321(X,Y) get_gdat_ullong((X),(Y),321) +#define get_gdat_ip_pos321(X,Y) get_gdat_ip((X),(Y),321) +#define get_gdat_ipv6_pos321(X,Y) get_gdat_ipv6((X),(Y),321) +#define get_gdat_string_pos321(X,Y) get_gdat_string((X),(Y),321) +#define get_gdat_v_str_pos321(X,Y) get_gdat_string((X),(Y),321) +#define get_gdat_bool_pos321(X,Y) get_gdat_bool((X),(Y),321) +#define get_gdat_int_pos321(X,Y) get_gdat_int((X),(Y),321) +#define get_gdat_llong_pos321(X,Y) get_gdat_llong((X),(Y),321) +#define get_gdat_float_pos321(X,Y) get_gdat_float((X),(Y),321) +#define get_gdat_uint_pos322(X,Y) get_gdat_uint((X),(Y),322) +#define get_gdat_ullong_pos322(X,Y) get_gdat_ullong((X),(Y),322) +#define get_gdat_ip_pos322(X,Y) get_gdat_ip((X),(Y),322) +#define get_gdat_ipv6_pos322(X,Y) get_gdat_ipv6((X),(Y),322) +#define get_gdat_string_pos322(X,Y) get_gdat_string((X),(Y),322) +#define get_gdat_v_str_pos322(X,Y) get_gdat_string((X),(Y),322) +#define get_gdat_bool_pos322(X,Y) get_gdat_bool((X),(Y),322) +#define get_gdat_int_pos322(X,Y) get_gdat_int((X),(Y),322) +#define get_gdat_llong_pos322(X,Y) get_gdat_llong((X),(Y),322) +#define get_gdat_float_pos322(X,Y) get_gdat_float((X),(Y),322) +#define get_gdat_uint_pos323(X,Y) get_gdat_uint((X),(Y),323) +#define get_gdat_ullong_pos323(X,Y) get_gdat_ullong((X),(Y),323) +#define get_gdat_ip_pos323(X,Y) get_gdat_ip((X),(Y),323) +#define get_gdat_ipv6_pos323(X,Y) get_gdat_ipv6((X),(Y),323) +#define get_gdat_string_pos323(X,Y) get_gdat_string((X),(Y),323) +#define get_gdat_v_str_pos323(X,Y) get_gdat_string((X),(Y),323) +#define get_gdat_bool_pos323(X,Y) get_gdat_bool((X),(Y),323) +#define get_gdat_int_pos323(X,Y) get_gdat_int((X),(Y),323) +#define get_gdat_llong_pos323(X,Y) get_gdat_llong((X),(Y),323) +#define get_gdat_float_pos323(X,Y) get_gdat_float((X),(Y),323) +#define get_gdat_uint_pos324(X,Y) get_gdat_uint((X),(Y),324) +#define get_gdat_ullong_pos324(X,Y) get_gdat_ullong((X),(Y),324) +#define get_gdat_ip_pos324(X,Y) get_gdat_ip((X),(Y),324) +#define get_gdat_ipv6_pos324(X,Y) get_gdat_ipv6((X),(Y),324) +#define get_gdat_string_pos324(X,Y) get_gdat_string((X),(Y),324) +#define get_gdat_v_str_pos324(X,Y) get_gdat_string((X),(Y),324) +#define get_gdat_bool_pos324(X,Y) get_gdat_bool((X),(Y),324) +#define get_gdat_int_pos324(X,Y) get_gdat_int((X),(Y),324) +#define get_gdat_llong_pos324(X,Y) get_gdat_llong((X),(Y),324) +#define get_gdat_float_pos324(X,Y) get_gdat_float((X),(Y),324) +#define get_gdat_uint_pos325(X,Y) get_gdat_uint((X),(Y),325) +#define get_gdat_ullong_pos325(X,Y) get_gdat_ullong((X),(Y),325) +#define get_gdat_ip_pos325(X,Y) get_gdat_ip((X),(Y),325) +#define get_gdat_ipv6_pos325(X,Y) get_gdat_ipv6((X),(Y),325) +#define get_gdat_string_pos325(X,Y) get_gdat_string((X),(Y),325) +#define get_gdat_v_str_pos325(X,Y) get_gdat_string((X),(Y),325) +#define get_gdat_bool_pos325(X,Y) get_gdat_bool((X),(Y),325) +#define get_gdat_int_pos325(X,Y) get_gdat_int((X),(Y),325) +#define get_gdat_llong_pos325(X,Y) get_gdat_llong((X),(Y),325) +#define get_gdat_float_pos325(X,Y) get_gdat_float((X),(Y),325) +#define get_gdat_uint_pos326(X,Y) get_gdat_uint((X),(Y),326) +#define get_gdat_ullong_pos326(X,Y) get_gdat_ullong((X),(Y),326) +#define get_gdat_ip_pos326(X,Y) get_gdat_ip((X),(Y),326) +#define get_gdat_ipv6_pos326(X,Y) get_gdat_ipv6((X),(Y),326) +#define get_gdat_string_pos326(X,Y) get_gdat_string((X),(Y),326) +#define get_gdat_v_str_pos326(X,Y) get_gdat_string((X),(Y),326) +#define get_gdat_bool_pos326(X,Y) get_gdat_bool((X),(Y),326) +#define get_gdat_int_pos326(X,Y) get_gdat_int((X),(Y),326) +#define get_gdat_llong_pos326(X,Y) get_gdat_llong((X),(Y),326) +#define get_gdat_float_pos326(X,Y) get_gdat_float((X),(Y),326) +#define get_gdat_uint_pos327(X,Y) get_gdat_uint((X),(Y),327) +#define get_gdat_ullong_pos327(X,Y) get_gdat_ullong((X),(Y),327) +#define get_gdat_ip_pos327(X,Y) get_gdat_ip((X),(Y),327) +#define get_gdat_ipv6_pos327(X,Y) get_gdat_ipv6((X),(Y),327) +#define get_gdat_string_pos327(X,Y) get_gdat_string((X),(Y),327) +#define get_gdat_v_str_pos327(X,Y) get_gdat_string((X),(Y),327) +#define get_gdat_bool_pos327(X,Y) get_gdat_bool((X),(Y),327) +#define get_gdat_int_pos327(X,Y) get_gdat_int((X),(Y),327) +#define get_gdat_llong_pos327(X,Y) get_gdat_llong((X),(Y),327) +#define get_gdat_float_pos327(X,Y) get_gdat_float((X),(Y),327) +#define get_gdat_uint_pos328(X,Y) get_gdat_uint((X),(Y),328) +#define get_gdat_ullong_pos328(X,Y) get_gdat_ullong((X),(Y),328) +#define get_gdat_ip_pos328(X,Y) get_gdat_ip((X),(Y),328) +#define get_gdat_ipv6_pos328(X,Y) get_gdat_ipv6((X),(Y),328) +#define get_gdat_string_pos328(X,Y) get_gdat_string((X),(Y),328) +#define get_gdat_v_str_pos328(X,Y) get_gdat_string((X),(Y),328) +#define get_gdat_bool_pos328(X,Y) get_gdat_bool((X),(Y),328) +#define get_gdat_int_pos328(X,Y) get_gdat_int((X),(Y),328) +#define get_gdat_llong_pos328(X,Y) get_gdat_llong((X),(Y),328) +#define get_gdat_float_pos328(X,Y) get_gdat_float((X),(Y),328) +#define get_gdat_uint_pos329(X,Y) get_gdat_uint((X),(Y),329) +#define get_gdat_ullong_pos329(X,Y) get_gdat_ullong((X),(Y),329) +#define get_gdat_ip_pos329(X,Y) get_gdat_ip((X),(Y),329) +#define get_gdat_ipv6_pos329(X,Y) get_gdat_ipv6((X),(Y),329) +#define get_gdat_string_pos329(X,Y) get_gdat_string((X),(Y),329) +#define get_gdat_v_str_pos329(X,Y) get_gdat_string((X),(Y),329) +#define get_gdat_bool_pos329(X,Y) get_gdat_bool((X),(Y),329) +#define get_gdat_int_pos329(X,Y) get_gdat_int((X),(Y),329) +#define get_gdat_llong_pos329(X,Y) get_gdat_llong((X),(Y),329) +#define get_gdat_float_pos329(X,Y) get_gdat_float((X),(Y),329) +#define get_gdat_uint_pos330(X,Y) get_gdat_uint((X),(Y),330) +#define get_gdat_ullong_pos330(X,Y) get_gdat_ullong((X),(Y),330) +#define get_gdat_ip_pos330(X,Y) get_gdat_ip((X),(Y),330) +#define get_gdat_ipv6_pos330(X,Y) get_gdat_ipv6((X),(Y),330) +#define get_gdat_string_pos330(X,Y) get_gdat_string((X),(Y),330) +#define get_gdat_v_str_pos330(X,Y) get_gdat_string((X),(Y),330) +#define get_gdat_bool_pos330(X,Y) get_gdat_bool((X),(Y),330) +#define get_gdat_int_pos330(X,Y) get_gdat_int((X),(Y),330) +#define get_gdat_llong_pos330(X,Y) get_gdat_llong((X),(Y),330) +#define get_gdat_float_pos330(X,Y) get_gdat_float((X),(Y),330) +#define get_gdat_uint_pos331(X,Y) get_gdat_uint((X),(Y),331) +#define get_gdat_ullong_pos331(X,Y) get_gdat_ullong((X),(Y),331) +#define get_gdat_ip_pos331(X,Y) get_gdat_ip((X),(Y),331) +#define get_gdat_ipv6_pos331(X,Y) get_gdat_ipv6((X),(Y),331) +#define get_gdat_string_pos331(X,Y) get_gdat_string((X),(Y),331) +#define get_gdat_v_str_pos331(X,Y) get_gdat_string((X),(Y),331) +#define get_gdat_bool_pos331(X,Y) get_gdat_bool((X),(Y),331) +#define get_gdat_int_pos331(X,Y) get_gdat_int((X),(Y),331) +#define get_gdat_llong_pos331(X,Y) get_gdat_llong((X),(Y),331) +#define get_gdat_float_pos331(X,Y) get_gdat_float((X),(Y),331) +#define get_gdat_uint_pos332(X,Y) get_gdat_uint((X),(Y),332) +#define get_gdat_ullong_pos332(X,Y) get_gdat_ullong((X),(Y),332) +#define get_gdat_ip_pos332(X,Y) get_gdat_ip((X),(Y),332) +#define get_gdat_ipv6_pos332(X,Y) get_gdat_ipv6((X),(Y),332) +#define get_gdat_string_pos332(X,Y) get_gdat_string((X),(Y),332) +#define get_gdat_v_str_pos332(X,Y) get_gdat_string((X),(Y),332) +#define get_gdat_bool_pos332(X,Y) get_gdat_bool((X),(Y),332) +#define get_gdat_int_pos332(X,Y) get_gdat_int((X),(Y),332) +#define get_gdat_llong_pos332(X,Y) get_gdat_llong((X),(Y),332) +#define get_gdat_float_pos332(X,Y) get_gdat_float((X),(Y),332) +#define get_gdat_uint_pos333(X,Y) get_gdat_uint((X),(Y),333) +#define get_gdat_ullong_pos333(X,Y) get_gdat_ullong((X),(Y),333) +#define get_gdat_ip_pos333(X,Y) get_gdat_ip((X),(Y),333) +#define get_gdat_ipv6_pos333(X,Y) get_gdat_ipv6((X),(Y),333) +#define get_gdat_string_pos333(X,Y) get_gdat_string((X),(Y),333) +#define get_gdat_v_str_pos333(X,Y) get_gdat_string((X),(Y),333) +#define get_gdat_bool_pos333(X,Y) get_gdat_bool((X),(Y),333) +#define get_gdat_int_pos333(X,Y) get_gdat_int((X),(Y),333) +#define get_gdat_llong_pos333(X,Y) get_gdat_llong((X),(Y),333) +#define get_gdat_float_pos333(X,Y) get_gdat_float((X),(Y),333) +#define get_gdat_uint_pos334(X,Y) get_gdat_uint((X),(Y),334) +#define get_gdat_ullong_pos334(X,Y) get_gdat_ullong((X),(Y),334) +#define get_gdat_ip_pos334(X,Y) get_gdat_ip((X),(Y),334) +#define get_gdat_ipv6_pos334(X,Y) get_gdat_ipv6((X),(Y),334) +#define get_gdat_string_pos334(X,Y) get_gdat_string((X),(Y),334) +#define get_gdat_v_str_pos334(X,Y) get_gdat_string((X),(Y),334) +#define get_gdat_bool_pos334(X,Y) get_gdat_bool((X),(Y),334) +#define get_gdat_int_pos334(X,Y) get_gdat_int((X),(Y),334) +#define get_gdat_llong_pos334(X,Y) get_gdat_llong((X),(Y),334) +#define get_gdat_float_pos334(X,Y) get_gdat_float((X),(Y),334) +#define get_gdat_uint_pos335(X,Y) get_gdat_uint((X),(Y),335) +#define get_gdat_ullong_pos335(X,Y) get_gdat_ullong((X),(Y),335) +#define get_gdat_ip_pos335(X,Y) get_gdat_ip((X),(Y),335) +#define get_gdat_ipv6_pos335(X,Y) get_gdat_ipv6((X),(Y),335) +#define get_gdat_string_pos335(X,Y) get_gdat_string((X),(Y),335) +#define get_gdat_v_str_pos335(X,Y) get_gdat_string((X),(Y),335) +#define get_gdat_bool_pos335(X,Y) get_gdat_bool((X),(Y),335) +#define get_gdat_int_pos335(X,Y) get_gdat_int((X),(Y),335) +#define get_gdat_llong_pos335(X,Y) get_gdat_llong((X),(Y),335) +#define get_gdat_float_pos335(X,Y) get_gdat_float((X),(Y),335) +#define get_gdat_uint_pos336(X,Y) get_gdat_uint((X),(Y),336) +#define get_gdat_ullong_pos336(X,Y) get_gdat_ullong((X),(Y),336) +#define get_gdat_ip_pos336(X,Y) get_gdat_ip((X),(Y),336) +#define get_gdat_ipv6_pos336(X,Y) get_gdat_ipv6((X),(Y),336) +#define get_gdat_string_pos336(X,Y) get_gdat_string((X),(Y),336) +#define get_gdat_v_str_pos336(X,Y) get_gdat_string((X),(Y),336) +#define get_gdat_bool_pos336(X,Y) get_gdat_bool((X),(Y),336) +#define get_gdat_int_pos336(X,Y) get_gdat_int((X),(Y),336) +#define get_gdat_llong_pos336(X,Y) get_gdat_llong((X),(Y),336) +#define get_gdat_float_pos336(X,Y) get_gdat_float((X),(Y),336) +#define get_gdat_uint_pos337(X,Y) get_gdat_uint((X),(Y),337) +#define get_gdat_ullong_pos337(X,Y) get_gdat_ullong((X),(Y),337) +#define get_gdat_ip_pos337(X,Y) get_gdat_ip((X),(Y),337) +#define get_gdat_ipv6_pos337(X,Y) get_gdat_ipv6((X),(Y),337) +#define get_gdat_string_pos337(X,Y) get_gdat_string((X),(Y),337) +#define get_gdat_v_str_pos337(X,Y) get_gdat_string((X),(Y),337) +#define get_gdat_bool_pos337(X,Y) get_gdat_bool((X),(Y),337) +#define get_gdat_int_pos337(X,Y) get_gdat_int((X),(Y),337) +#define get_gdat_llong_pos337(X,Y) get_gdat_llong((X),(Y),337) +#define get_gdat_float_pos337(X,Y) get_gdat_float((X),(Y),337) +#define get_gdat_uint_pos338(X,Y) get_gdat_uint((X),(Y),338) +#define get_gdat_ullong_pos338(X,Y) get_gdat_ullong((X),(Y),338) +#define get_gdat_ip_pos338(X,Y) get_gdat_ip((X),(Y),338) +#define get_gdat_ipv6_pos338(X,Y) get_gdat_ipv6((X),(Y),338) +#define get_gdat_string_pos338(X,Y) get_gdat_string((X),(Y),338) +#define get_gdat_v_str_pos338(X,Y) get_gdat_string((X),(Y),338) +#define get_gdat_bool_pos338(X,Y) get_gdat_bool((X),(Y),338) +#define get_gdat_int_pos338(X,Y) get_gdat_int((X),(Y),338) +#define get_gdat_llong_pos338(X,Y) get_gdat_llong((X),(Y),338) +#define get_gdat_float_pos338(X,Y) get_gdat_float((X),(Y),338) +#define get_gdat_uint_pos339(X,Y) get_gdat_uint((X),(Y),339) +#define get_gdat_ullong_pos339(X,Y) get_gdat_ullong((X),(Y),339) +#define get_gdat_ip_pos339(X,Y) get_gdat_ip((X),(Y),339) +#define get_gdat_ipv6_pos339(X,Y) get_gdat_ipv6((X),(Y),339) +#define get_gdat_string_pos339(X,Y) get_gdat_string((X),(Y),339) +#define get_gdat_v_str_pos339(X,Y) get_gdat_string((X),(Y),339) +#define get_gdat_bool_pos339(X,Y) get_gdat_bool((X),(Y),339) +#define get_gdat_int_pos339(X,Y) get_gdat_int((X),(Y),339) +#define get_gdat_llong_pos339(X,Y) get_gdat_llong((X),(Y),339) +#define get_gdat_float_pos339(X,Y) get_gdat_float((X),(Y),339) +#define get_gdat_uint_pos340(X,Y) get_gdat_uint((X),(Y),340) +#define get_gdat_ullong_pos340(X,Y) get_gdat_ullong((X),(Y),340) +#define get_gdat_ip_pos340(X,Y) get_gdat_ip((X),(Y),340) +#define get_gdat_ipv6_pos340(X,Y) get_gdat_ipv6((X),(Y),340) +#define get_gdat_string_pos340(X,Y) get_gdat_string((X),(Y),340) +#define get_gdat_v_str_pos340(X,Y) get_gdat_string((X),(Y),340) +#define get_gdat_bool_pos340(X,Y) get_gdat_bool((X),(Y),340) +#define get_gdat_int_pos340(X,Y) get_gdat_int((X),(Y),340) +#define get_gdat_llong_pos340(X,Y) get_gdat_llong((X),(Y),340) +#define get_gdat_float_pos340(X,Y) get_gdat_float((X),(Y),340) +#define get_gdat_uint_pos341(X,Y) get_gdat_uint((X),(Y),341) +#define get_gdat_ullong_pos341(X,Y) get_gdat_ullong((X),(Y),341) +#define get_gdat_ip_pos341(X,Y) get_gdat_ip((X),(Y),341) +#define get_gdat_ipv6_pos341(X,Y) get_gdat_ipv6((X),(Y),341) +#define get_gdat_string_pos341(X,Y) get_gdat_string((X),(Y),341) +#define get_gdat_v_str_pos341(X,Y) get_gdat_string((X),(Y),341) +#define get_gdat_bool_pos341(X,Y) get_gdat_bool((X),(Y),341) +#define get_gdat_int_pos341(X,Y) get_gdat_int((X),(Y),341) +#define get_gdat_llong_pos341(X,Y) get_gdat_llong((X),(Y),341) +#define get_gdat_float_pos341(X,Y) get_gdat_float((X),(Y),341) +#define get_gdat_uint_pos342(X,Y) get_gdat_uint((X),(Y),342) +#define get_gdat_ullong_pos342(X,Y) get_gdat_ullong((X),(Y),342) +#define get_gdat_ip_pos342(X,Y) get_gdat_ip((X),(Y),342) +#define get_gdat_ipv6_pos342(X,Y) get_gdat_ipv6((X),(Y),342) +#define get_gdat_string_pos342(X,Y) get_gdat_string((X),(Y),342) +#define get_gdat_v_str_pos342(X,Y) get_gdat_string((X),(Y),342) +#define get_gdat_bool_pos342(X,Y) get_gdat_bool((X),(Y),342) +#define get_gdat_int_pos342(X,Y) get_gdat_int((X),(Y),342) +#define get_gdat_llong_pos342(X,Y) get_gdat_llong((X),(Y),342) +#define get_gdat_float_pos342(X,Y) get_gdat_float((X),(Y),342) +#define get_gdat_uint_pos343(X,Y) get_gdat_uint((X),(Y),343) +#define get_gdat_ullong_pos343(X,Y) get_gdat_ullong((X),(Y),343) +#define get_gdat_ip_pos343(X,Y) get_gdat_ip((X),(Y),343) +#define get_gdat_ipv6_pos343(X,Y) get_gdat_ipv6((X),(Y),343) +#define get_gdat_string_pos343(X,Y) get_gdat_string((X),(Y),343) +#define get_gdat_v_str_pos343(X,Y) get_gdat_string((X),(Y),343) +#define get_gdat_bool_pos343(X,Y) get_gdat_bool((X),(Y),343) +#define get_gdat_int_pos343(X,Y) get_gdat_int((X),(Y),343) +#define get_gdat_llong_pos343(X,Y) get_gdat_llong((X),(Y),343) +#define get_gdat_float_pos343(X,Y) get_gdat_float((X),(Y),343) +#define get_gdat_uint_pos344(X,Y) get_gdat_uint((X),(Y),344) +#define get_gdat_ullong_pos344(X,Y) get_gdat_ullong((X),(Y),344) +#define get_gdat_ip_pos344(X,Y) get_gdat_ip((X),(Y),344) +#define get_gdat_ipv6_pos344(X,Y) get_gdat_ipv6((X),(Y),344) +#define get_gdat_string_pos344(X,Y) get_gdat_string((X),(Y),344) +#define get_gdat_v_str_pos344(X,Y) get_gdat_string((X),(Y),344) +#define get_gdat_bool_pos344(X,Y) get_gdat_bool((X),(Y),344) +#define get_gdat_int_pos344(X,Y) get_gdat_int((X),(Y),344) +#define get_gdat_llong_pos344(X,Y) get_gdat_llong((X),(Y),344) +#define get_gdat_float_pos344(X,Y) get_gdat_float((X),(Y),344) +#define get_gdat_uint_pos345(X,Y) get_gdat_uint((X),(Y),345) +#define get_gdat_ullong_pos345(X,Y) get_gdat_ullong((X),(Y),345) +#define get_gdat_ip_pos345(X,Y) get_gdat_ip((X),(Y),345) +#define get_gdat_ipv6_pos345(X,Y) get_gdat_ipv6((X),(Y),345) +#define get_gdat_string_pos345(X,Y) get_gdat_string((X),(Y),345) +#define get_gdat_v_str_pos345(X,Y) get_gdat_string((X),(Y),345) +#define get_gdat_bool_pos345(X,Y) get_gdat_bool((X),(Y),345) +#define get_gdat_int_pos345(X,Y) get_gdat_int((X),(Y),345) +#define get_gdat_llong_pos345(X,Y) get_gdat_llong((X),(Y),345) +#define get_gdat_float_pos345(X,Y) get_gdat_float((X),(Y),345) +#define get_gdat_uint_pos346(X,Y) get_gdat_uint((X),(Y),346) +#define get_gdat_ullong_pos346(X,Y) get_gdat_ullong((X),(Y),346) +#define get_gdat_ip_pos346(X,Y) get_gdat_ip((X),(Y),346) +#define get_gdat_ipv6_pos346(X,Y) get_gdat_ipv6((X),(Y),346) +#define get_gdat_string_pos346(X,Y) get_gdat_string((X),(Y),346) +#define get_gdat_v_str_pos346(X,Y) get_gdat_string((X),(Y),346) +#define get_gdat_bool_pos346(X,Y) get_gdat_bool((X),(Y),346) +#define get_gdat_int_pos346(X,Y) get_gdat_int((X),(Y),346) +#define get_gdat_llong_pos346(X,Y) get_gdat_llong((X),(Y),346) +#define get_gdat_float_pos346(X,Y) get_gdat_float((X),(Y),346) +#define get_gdat_uint_pos347(X,Y) get_gdat_uint((X),(Y),347) +#define get_gdat_ullong_pos347(X,Y) get_gdat_ullong((X),(Y),347) +#define get_gdat_ip_pos347(X,Y) get_gdat_ip((X),(Y),347) +#define get_gdat_ipv6_pos347(X,Y) get_gdat_ipv6((X),(Y),347) +#define get_gdat_string_pos347(X,Y) get_gdat_string((X),(Y),347) +#define get_gdat_v_str_pos347(X,Y) get_gdat_string((X),(Y),347) +#define get_gdat_bool_pos347(X,Y) get_gdat_bool((X),(Y),347) +#define get_gdat_int_pos347(X,Y) get_gdat_int((X),(Y),347) +#define get_gdat_llong_pos347(X,Y) get_gdat_llong((X),(Y),347) +#define get_gdat_float_pos347(X,Y) get_gdat_float((X),(Y),347) +#define get_gdat_uint_pos348(X,Y) get_gdat_uint((X),(Y),348) +#define get_gdat_ullong_pos348(X,Y) get_gdat_ullong((X),(Y),348) +#define get_gdat_ip_pos348(X,Y) get_gdat_ip((X),(Y),348) +#define get_gdat_ipv6_pos348(X,Y) get_gdat_ipv6((X),(Y),348) +#define get_gdat_string_pos348(X,Y) get_gdat_string((X),(Y),348) +#define get_gdat_v_str_pos348(X,Y) get_gdat_string((X),(Y),348) +#define get_gdat_bool_pos348(X,Y) get_gdat_bool((X),(Y),348) +#define get_gdat_int_pos348(X,Y) get_gdat_int((X),(Y),348) +#define get_gdat_llong_pos348(X,Y) get_gdat_llong((X),(Y),348) +#define get_gdat_float_pos348(X,Y) get_gdat_float((X),(Y),348) +#define get_gdat_uint_pos349(X,Y) get_gdat_uint((X),(Y),349) +#define get_gdat_ullong_pos349(X,Y) get_gdat_ullong((X),(Y),349) +#define get_gdat_ip_pos349(X,Y) get_gdat_ip((X),(Y),349) +#define get_gdat_ipv6_pos349(X,Y) get_gdat_ipv6((X),(Y),349) +#define get_gdat_string_pos349(X,Y) get_gdat_string((X),(Y),349) +#define get_gdat_v_str_pos349(X,Y) get_gdat_string((X),(Y),349) +#define get_gdat_bool_pos349(X,Y) get_gdat_bool((X),(Y),349) +#define get_gdat_int_pos349(X,Y) get_gdat_int((X),(Y),349) +#define get_gdat_llong_pos349(X,Y) get_gdat_llong((X),(Y),349) +#define get_gdat_float_pos349(X,Y) get_gdat_float((X),(Y),349) +#define get_gdat_uint_pos350(X,Y) get_gdat_uint((X),(Y),350) +#define get_gdat_ullong_pos350(X,Y) get_gdat_ullong((X),(Y),350) +#define get_gdat_ip_pos350(X,Y) get_gdat_ip((X),(Y),350) +#define get_gdat_ipv6_pos350(X,Y) get_gdat_ipv6((X),(Y),350) +#define get_gdat_string_pos350(X,Y) get_gdat_string((X),(Y),350) +#define get_gdat_v_str_pos350(X,Y) get_gdat_string((X),(Y),350) +#define get_gdat_bool_pos350(X,Y) get_gdat_bool((X),(Y),350) +#define get_gdat_int_pos350(X,Y) get_gdat_int((X),(Y),350) +#define get_gdat_llong_pos350(X,Y) get_gdat_llong((X),(Y),350) +#define get_gdat_float_pos350(X,Y) get_gdat_float((X),(Y),350) +#define get_gdat_uint_pos351(X,Y) get_gdat_uint((X),(Y),351) +#define get_gdat_ullong_pos351(X,Y) get_gdat_ullong((X),(Y),351) +#define get_gdat_ip_pos351(X,Y) get_gdat_ip((X),(Y),351) +#define get_gdat_ipv6_pos351(X,Y) get_gdat_ipv6((X),(Y),351) +#define get_gdat_string_pos351(X,Y) get_gdat_string((X),(Y),351) +#define get_gdat_v_str_pos351(X,Y) get_gdat_string((X),(Y),351) +#define get_gdat_bool_pos351(X,Y) get_gdat_bool((X),(Y),351) +#define get_gdat_int_pos351(X,Y) get_gdat_int((X),(Y),351) +#define get_gdat_llong_pos351(X,Y) get_gdat_llong((X),(Y),351) +#define get_gdat_float_pos351(X,Y) get_gdat_float((X),(Y),351) +#define get_gdat_uint_pos352(X,Y) get_gdat_uint((X),(Y),352) +#define get_gdat_ullong_pos352(X,Y) get_gdat_ullong((X),(Y),352) +#define get_gdat_ip_pos352(X,Y) get_gdat_ip((X),(Y),352) +#define get_gdat_ipv6_pos352(X,Y) get_gdat_ipv6((X),(Y),352) +#define get_gdat_string_pos352(X,Y) get_gdat_string((X),(Y),352) +#define get_gdat_v_str_pos352(X,Y) get_gdat_string((X),(Y),352) +#define get_gdat_bool_pos352(X,Y) get_gdat_bool((X),(Y),352) +#define get_gdat_int_pos352(X,Y) get_gdat_int((X),(Y),352) +#define get_gdat_llong_pos352(X,Y) get_gdat_llong((X),(Y),352) +#define get_gdat_float_pos352(X,Y) get_gdat_float((X),(Y),352) +#define get_gdat_uint_pos353(X,Y) get_gdat_uint((X),(Y),353) +#define get_gdat_ullong_pos353(X,Y) get_gdat_ullong((X),(Y),353) +#define get_gdat_ip_pos353(X,Y) get_gdat_ip((X),(Y),353) +#define get_gdat_ipv6_pos353(X,Y) get_gdat_ipv6((X),(Y),353) +#define get_gdat_string_pos353(X,Y) get_gdat_string((X),(Y),353) +#define get_gdat_v_str_pos353(X,Y) get_gdat_string((X),(Y),353) +#define get_gdat_bool_pos353(X,Y) get_gdat_bool((X),(Y),353) +#define get_gdat_int_pos353(X,Y) get_gdat_int((X),(Y),353) +#define get_gdat_llong_pos353(X,Y) get_gdat_llong((X),(Y),353) +#define get_gdat_float_pos353(X,Y) get_gdat_float((X),(Y),353) +#define get_gdat_uint_pos354(X,Y) get_gdat_uint((X),(Y),354) +#define get_gdat_ullong_pos354(X,Y) get_gdat_ullong((X),(Y),354) +#define get_gdat_ip_pos354(X,Y) get_gdat_ip((X),(Y),354) +#define get_gdat_ipv6_pos354(X,Y) get_gdat_ipv6((X),(Y),354) +#define get_gdat_string_pos354(X,Y) get_gdat_string((X),(Y),354) +#define get_gdat_v_str_pos354(X,Y) get_gdat_string((X),(Y),354) +#define get_gdat_bool_pos354(X,Y) get_gdat_bool((X),(Y),354) +#define get_gdat_int_pos354(X,Y) get_gdat_int((X),(Y),354) +#define get_gdat_llong_pos354(X,Y) get_gdat_llong((X),(Y),354) +#define get_gdat_float_pos354(X,Y) get_gdat_float((X),(Y),354) +#define get_gdat_uint_pos355(X,Y) get_gdat_uint((X),(Y),355) +#define get_gdat_ullong_pos355(X,Y) get_gdat_ullong((X),(Y),355) +#define get_gdat_ip_pos355(X,Y) get_gdat_ip((X),(Y),355) +#define get_gdat_ipv6_pos355(X,Y) get_gdat_ipv6((X),(Y),355) +#define get_gdat_string_pos355(X,Y) get_gdat_string((X),(Y),355) +#define get_gdat_v_str_pos355(X,Y) get_gdat_string((X),(Y),355) +#define get_gdat_bool_pos355(X,Y) get_gdat_bool((X),(Y),355) +#define get_gdat_int_pos355(X,Y) get_gdat_int((X),(Y),355) +#define get_gdat_llong_pos355(X,Y) get_gdat_llong((X),(Y),355) +#define get_gdat_float_pos355(X,Y) get_gdat_float((X),(Y),355) +#define get_gdat_uint_pos356(X,Y) get_gdat_uint((X),(Y),356) +#define get_gdat_ullong_pos356(X,Y) get_gdat_ullong((X),(Y),356) +#define get_gdat_ip_pos356(X,Y) get_gdat_ip((X),(Y),356) +#define get_gdat_ipv6_pos356(X,Y) get_gdat_ipv6((X),(Y),356) +#define get_gdat_string_pos356(X,Y) get_gdat_string((X),(Y),356) +#define get_gdat_v_str_pos356(X,Y) get_gdat_string((X),(Y),356) +#define get_gdat_bool_pos356(X,Y) get_gdat_bool((X),(Y),356) +#define get_gdat_int_pos356(X,Y) get_gdat_int((X),(Y),356) +#define get_gdat_llong_pos356(X,Y) get_gdat_llong((X),(Y),356) +#define get_gdat_float_pos356(X,Y) get_gdat_float((X),(Y),356) +#define get_gdat_uint_pos357(X,Y) get_gdat_uint((X),(Y),357) +#define get_gdat_ullong_pos357(X,Y) get_gdat_ullong((X),(Y),357) +#define get_gdat_ip_pos357(X,Y) get_gdat_ip((X),(Y),357) +#define get_gdat_ipv6_pos357(X,Y) get_gdat_ipv6((X),(Y),357) +#define get_gdat_string_pos357(X,Y) get_gdat_string((X),(Y),357) +#define get_gdat_v_str_pos357(X,Y) get_gdat_string((X),(Y),357) +#define get_gdat_bool_pos357(X,Y) get_gdat_bool((X),(Y),357) +#define get_gdat_int_pos357(X,Y) get_gdat_int((X),(Y),357) +#define get_gdat_llong_pos357(X,Y) get_gdat_llong((X),(Y),357) +#define get_gdat_float_pos357(X,Y) get_gdat_float((X),(Y),357) +#define get_gdat_uint_pos358(X,Y) get_gdat_uint((X),(Y),358) +#define get_gdat_ullong_pos358(X,Y) get_gdat_ullong((X),(Y),358) +#define get_gdat_ip_pos358(X,Y) get_gdat_ip((X),(Y),358) +#define get_gdat_ipv6_pos358(X,Y) get_gdat_ipv6((X),(Y),358) +#define get_gdat_string_pos358(X,Y) get_gdat_string((X),(Y),358) +#define get_gdat_v_str_pos358(X,Y) get_gdat_string((X),(Y),358) +#define get_gdat_bool_pos358(X,Y) get_gdat_bool((X),(Y),358) +#define get_gdat_int_pos358(X,Y) get_gdat_int((X),(Y),358) +#define get_gdat_llong_pos358(X,Y) get_gdat_llong((X),(Y),358) +#define get_gdat_float_pos358(X,Y) get_gdat_float((X),(Y),358) +#define get_gdat_uint_pos359(X,Y) get_gdat_uint((X),(Y),359) +#define get_gdat_ullong_pos359(X,Y) get_gdat_ullong((X),(Y),359) +#define get_gdat_ip_pos359(X,Y) get_gdat_ip((X),(Y),359) +#define get_gdat_ipv6_pos359(X,Y) get_gdat_ipv6((X),(Y),359) +#define get_gdat_string_pos359(X,Y) get_gdat_string((X),(Y),359) +#define get_gdat_v_str_pos359(X,Y) get_gdat_string((X),(Y),359) +#define get_gdat_bool_pos359(X,Y) get_gdat_bool((X),(Y),359) +#define get_gdat_int_pos359(X,Y) get_gdat_int((X),(Y),359) +#define get_gdat_llong_pos359(X,Y) get_gdat_llong((X),(Y),359) +#define get_gdat_float_pos359(X,Y) get_gdat_float((X),(Y),359) +#define get_gdat_uint_pos360(X,Y) get_gdat_uint((X),(Y),360) +#define get_gdat_ullong_pos360(X,Y) get_gdat_ullong((X),(Y),360) +#define get_gdat_ip_pos360(X,Y) get_gdat_ip((X),(Y),360) +#define get_gdat_ipv6_pos360(X,Y) get_gdat_ipv6((X),(Y),360) +#define get_gdat_string_pos360(X,Y) get_gdat_string((X),(Y),360) +#define get_gdat_v_str_pos360(X,Y) get_gdat_string((X),(Y),360) +#define get_gdat_bool_pos360(X,Y) get_gdat_bool((X),(Y),360) +#define get_gdat_int_pos360(X,Y) get_gdat_int((X),(Y),360) +#define get_gdat_llong_pos360(X,Y) get_gdat_llong((X),(Y),360) +#define get_gdat_float_pos360(X,Y) get_gdat_float((X),(Y),360) +#define get_gdat_uint_pos361(X,Y) get_gdat_uint((X),(Y),361) +#define get_gdat_ullong_pos361(X,Y) get_gdat_ullong((X),(Y),361) +#define get_gdat_ip_pos361(X,Y) get_gdat_ip((X),(Y),361) +#define get_gdat_ipv6_pos361(X,Y) get_gdat_ipv6((X),(Y),361) +#define get_gdat_string_pos361(X,Y) get_gdat_string((X),(Y),361) +#define get_gdat_v_str_pos361(X,Y) get_gdat_string((X),(Y),361) +#define get_gdat_bool_pos361(X,Y) get_gdat_bool((X),(Y),361) +#define get_gdat_int_pos361(X,Y) get_gdat_int((X),(Y),361) +#define get_gdat_llong_pos361(X,Y) get_gdat_llong((X),(Y),361) +#define get_gdat_float_pos361(X,Y) get_gdat_float((X),(Y),361) +#define get_gdat_uint_pos362(X,Y) get_gdat_uint((X),(Y),362) +#define get_gdat_ullong_pos362(X,Y) get_gdat_ullong((X),(Y),362) +#define get_gdat_ip_pos362(X,Y) get_gdat_ip((X),(Y),362) +#define get_gdat_ipv6_pos362(X,Y) get_gdat_ipv6((X),(Y),362) +#define get_gdat_string_pos362(X,Y) get_gdat_string((X),(Y),362) +#define get_gdat_v_str_pos362(X,Y) get_gdat_string((X),(Y),362) +#define get_gdat_bool_pos362(X,Y) get_gdat_bool((X),(Y),362) +#define get_gdat_int_pos362(X,Y) get_gdat_int((X),(Y),362) +#define get_gdat_llong_pos362(X,Y) get_gdat_llong((X),(Y),362) +#define get_gdat_float_pos362(X,Y) get_gdat_float((X),(Y),362) +#define get_gdat_uint_pos363(X,Y) get_gdat_uint((X),(Y),363) +#define get_gdat_ullong_pos363(X,Y) get_gdat_ullong((X),(Y),363) +#define get_gdat_ip_pos363(X,Y) get_gdat_ip((X),(Y),363) +#define get_gdat_ipv6_pos363(X,Y) get_gdat_ipv6((X),(Y),363) +#define get_gdat_string_pos363(X,Y) get_gdat_string((X),(Y),363) +#define get_gdat_v_str_pos363(X,Y) get_gdat_string((X),(Y),363) +#define get_gdat_bool_pos363(X,Y) get_gdat_bool((X),(Y),363) +#define get_gdat_int_pos363(X,Y) get_gdat_int((X),(Y),363) +#define get_gdat_llong_pos363(X,Y) get_gdat_llong((X),(Y),363) +#define get_gdat_float_pos363(X,Y) get_gdat_float((X),(Y),363) +#define get_gdat_uint_pos364(X,Y) get_gdat_uint((X),(Y),364) +#define get_gdat_ullong_pos364(X,Y) get_gdat_ullong((X),(Y),364) +#define get_gdat_ip_pos364(X,Y) get_gdat_ip((X),(Y),364) +#define get_gdat_ipv6_pos364(X,Y) get_gdat_ipv6((X),(Y),364) +#define get_gdat_string_pos364(X,Y) get_gdat_string((X),(Y),364) +#define get_gdat_v_str_pos364(X,Y) get_gdat_string((X),(Y),364) +#define get_gdat_bool_pos364(X,Y) get_gdat_bool((X),(Y),364) +#define get_gdat_int_pos364(X,Y) get_gdat_int((X),(Y),364) +#define get_gdat_llong_pos364(X,Y) get_gdat_llong((X),(Y),364) +#define get_gdat_float_pos364(X,Y) get_gdat_float((X),(Y),364) +#define get_gdat_uint_pos365(X,Y) get_gdat_uint((X),(Y),365) +#define get_gdat_ullong_pos365(X,Y) get_gdat_ullong((X),(Y),365) +#define get_gdat_ip_pos365(X,Y) get_gdat_ip((X),(Y),365) +#define get_gdat_ipv6_pos365(X,Y) get_gdat_ipv6((X),(Y),365) +#define get_gdat_string_pos365(X,Y) get_gdat_string((X),(Y),365) +#define get_gdat_v_str_pos365(X,Y) get_gdat_string((X),(Y),365) +#define get_gdat_bool_pos365(X,Y) get_gdat_bool((X),(Y),365) +#define get_gdat_int_pos365(X,Y) get_gdat_int((X),(Y),365) +#define get_gdat_llong_pos365(X,Y) get_gdat_llong((X),(Y),365) +#define get_gdat_float_pos365(X,Y) get_gdat_float((X),(Y),365) +#define get_gdat_uint_pos366(X,Y) get_gdat_uint((X),(Y),366) +#define get_gdat_ullong_pos366(X,Y) get_gdat_ullong((X),(Y),366) +#define get_gdat_ip_pos366(X,Y) get_gdat_ip((X),(Y),366) +#define get_gdat_ipv6_pos366(X,Y) get_gdat_ipv6((X),(Y),366) +#define get_gdat_string_pos366(X,Y) get_gdat_string((X),(Y),366) +#define get_gdat_v_str_pos366(X,Y) get_gdat_string((X),(Y),366) +#define get_gdat_bool_pos366(X,Y) get_gdat_bool((X),(Y),366) +#define get_gdat_int_pos366(X,Y) get_gdat_int((X),(Y),366) +#define get_gdat_llong_pos366(X,Y) get_gdat_llong((X),(Y),366) +#define get_gdat_float_pos366(X,Y) get_gdat_float((X),(Y),366) +#define get_gdat_uint_pos367(X,Y) get_gdat_uint((X),(Y),367) +#define get_gdat_ullong_pos367(X,Y) get_gdat_ullong((X),(Y),367) +#define get_gdat_ip_pos367(X,Y) get_gdat_ip((X),(Y),367) +#define get_gdat_ipv6_pos367(X,Y) get_gdat_ipv6((X),(Y),367) +#define get_gdat_string_pos367(X,Y) get_gdat_string((X),(Y),367) +#define get_gdat_v_str_pos367(X,Y) get_gdat_string((X),(Y),367) +#define get_gdat_bool_pos367(X,Y) get_gdat_bool((X),(Y),367) +#define get_gdat_int_pos367(X,Y) get_gdat_int((X),(Y),367) +#define get_gdat_llong_pos367(X,Y) get_gdat_llong((X),(Y),367) +#define get_gdat_float_pos367(X,Y) get_gdat_float((X),(Y),367) +#define get_gdat_uint_pos368(X,Y) get_gdat_uint((X),(Y),368) +#define get_gdat_ullong_pos368(X,Y) get_gdat_ullong((X),(Y),368) +#define get_gdat_ip_pos368(X,Y) get_gdat_ip((X),(Y),368) +#define get_gdat_ipv6_pos368(X,Y) get_gdat_ipv6((X),(Y),368) +#define get_gdat_string_pos368(X,Y) get_gdat_string((X),(Y),368) +#define get_gdat_v_str_pos368(X,Y) get_gdat_string((X),(Y),368) +#define get_gdat_bool_pos368(X,Y) get_gdat_bool((X),(Y),368) +#define get_gdat_int_pos368(X,Y) get_gdat_int((X),(Y),368) +#define get_gdat_llong_pos368(X,Y) get_gdat_llong((X),(Y),368) +#define get_gdat_float_pos368(X,Y) get_gdat_float((X),(Y),368) +#define get_gdat_uint_pos369(X,Y) get_gdat_uint((X),(Y),369) +#define get_gdat_ullong_pos369(X,Y) get_gdat_ullong((X),(Y),369) +#define get_gdat_ip_pos369(X,Y) get_gdat_ip((X),(Y),369) +#define get_gdat_ipv6_pos369(X,Y) get_gdat_ipv6((X),(Y),369) +#define get_gdat_string_pos369(X,Y) get_gdat_string((X),(Y),369) +#define get_gdat_v_str_pos369(X,Y) get_gdat_string((X),(Y),369) +#define get_gdat_bool_pos369(X,Y) get_gdat_bool((X),(Y),369) +#define get_gdat_int_pos369(X,Y) get_gdat_int((X),(Y),369) +#define get_gdat_llong_pos369(X,Y) get_gdat_llong((X),(Y),369) +#define get_gdat_float_pos369(X,Y) get_gdat_float((X),(Y),369) +#define get_gdat_uint_pos370(X,Y) get_gdat_uint((X),(Y),370) +#define get_gdat_ullong_pos370(X,Y) get_gdat_ullong((X),(Y),370) +#define get_gdat_ip_pos370(X,Y) get_gdat_ip((X),(Y),370) +#define get_gdat_ipv6_pos370(X,Y) get_gdat_ipv6((X),(Y),370) +#define get_gdat_string_pos370(X,Y) get_gdat_string((X),(Y),370) +#define get_gdat_v_str_pos370(X,Y) get_gdat_string((X),(Y),370) +#define get_gdat_bool_pos370(X,Y) get_gdat_bool((X),(Y),370) +#define get_gdat_int_pos370(X,Y) get_gdat_int((X),(Y),370) +#define get_gdat_llong_pos370(X,Y) get_gdat_llong((X),(Y),370) +#define get_gdat_float_pos370(X,Y) get_gdat_float((X),(Y),370) +#define get_gdat_uint_pos371(X,Y) get_gdat_uint((X),(Y),371) +#define get_gdat_ullong_pos371(X,Y) get_gdat_ullong((X),(Y),371) +#define get_gdat_ip_pos371(X,Y) get_gdat_ip((X),(Y),371) +#define get_gdat_ipv6_pos371(X,Y) get_gdat_ipv6((X),(Y),371) +#define get_gdat_string_pos371(X,Y) get_gdat_string((X),(Y),371) +#define get_gdat_v_str_pos371(X,Y) get_gdat_string((X),(Y),371) +#define get_gdat_bool_pos371(X,Y) get_gdat_bool((X),(Y),371) +#define get_gdat_int_pos371(X,Y) get_gdat_int((X),(Y),371) +#define get_gdat_llong_pos371(X,Y) get_gdat_llong((X),(Y),371) +#define get_gdat_float_pos371(X,Y) get_gdat_float((X),(Y),371) +#define get_gdat_uint_pos372(X,Y) get_gdat_uint((X),(Y),372) +#define get_gdat_ullong_pos372(X,Y) get_gdat_ullong((X),(Y),372) +#define get_gdat_ip_pos372(X,Y) get_gdat_ip((X),(Y),372) +#define get_gdat_ipv6_pos372(X,Y) get_gdat_ipv6((X),(Y),372) +#define get_gdat_string_pos372(X,Y) get_gdat_string((X),(Y),372) +#define get_gdat_v_str_pos372(X,Y) get_gdat_string((X),(Y),372) +#define get_gdat_bool_pos372(X,Y) get_gdat_bool((X),(Y),372) +#define get_gdat_int_pos372(X,Y) get_gdat_int((X),(Y),372) +#define get_gdat_llong_pos372(X,Y) get_gdat_llong((X),(Y),372) +#define get_gdat_float_pos372(X,Y) get_gdat_float((X),(Y),372) +#define get_gdat_uint_pos373(X,Y) get_gdat_uint((X),(Y),373) +#define get_gdat_ullong_pos373(X,Y) get_gdat_ullong((X),(Y),373) +#define get_gdat_ip_pos373(X,Y) get_gdat_ip((X),(Y),373) +#define get_gdat_ipv6_pos373(X,Y) get_gdat_ipv6((X),(Y),373) +#define get_gdat_string_pos373(X,Y) get_gdat_string((X),(Y),373) +#define get_gdat_v_str_pos373(X,Y) get_gdat_string((X),(Y),373) +#define get_gdat_bool_pos373(X,Y) get_gdat_bool((X),(Y),373) +#define get_gdat_int_pos373(X,Y) get_gdat_int((X),(Y),373) +#define get_gdat_llong_pos373(X,Y) get_gdat_llong((X),(Y),373) +#define get_gdat_float_pos373(X,Y) get_gdat_float((X),(Y),373) +#define get_gdat_uint_pos374(X,Y) get_gdat_uint((X),(Y),374) +#define get_gdat_ullong_pos374(X,Y) get_gdat_ullong((X),(Y),374) +#define get_gdat_ip_pos374(X,Y) get_gdat_ip((X),(Y),374) +#define get_gdat_ipv6_pos374(X,Y) get_gdat_ipv6((X),(Y),374) +#define get_gdat_string_pos374(X,Y) get_gdat_string((X),(Y),374) +#define get_gdat_v_str_pos374(X,Y) get_gdat_string((X),(Y),374) +#define get_gdat_bool_pos374(X,Y) get_gdat_bool((X),(Y),374) +#define get_gdat_int_pos374(X,Y) get_gdat_int((X),(Y),374) +#define get_gdat_llong_pos374(X,Y) get_gdat_llong((X),(Y),374) +#define get_gdat_float_pos374(X,Y) get_gdat_float((X),(Y),374) +#define get_gdat_uint_pos375(X,Y) get_gdat_uint((X),(Y),375) +#define get_gdat_ullong_pos375(X,Y) get_gdat_ullong((X),(Y),375) +#define get_gdat_ip_pos375(X,Y) get_gdat_ip((X),(Y),375) +#define get_gdat_ipv6_pos375(X,Y) get_gdat_ipv6((X),(Y),375) +#define get_gdat_string_pos375(X,Y) get_gdat_string((X),(Y),375) +#define get_gdat_v_str_pos375(X,Y) get_gdat_string((X),(Y),375) +#define get_gdat_bool_pos375(X,Y) get_gdat_bool((X),(Y),375) +#define get_gdat_int_pos375(X,Y) get_gdat_int((X),(Y),375) +#define get_gdat_llong_pos375(X,Y) get_gdat_llong((X),(Y),375) +#define get_gdat_float_pos375(X,Y) get_gdat_float((X),(Y),375) +#define get_gdat_uint_pos376(X,Y) get_gdat_uint((X),(Y),376) +#define get_gdat_ullong_pos376(X,Y) get_gdat_ullong((X),(Y),376) +#define get_gdat_ip_pos376(X,Y) get_gdat_ip((X),(Y),376) +#define get_gdat_ipv6_pos376(X,Y) get_gdat_ipv6((X),(Y),376) +#define get_gdat_string_pos376(X,Y) get_gdat_string((X),(Y),376) +#define get_gdat_v_str_pos376(X,Y) get_gdat_string((X),(Y),376) +#define get_gdat_bool_pos376(X,Y) get_gdat_bool((X),(Y),376) +#define get_gdat_int_pos376(X,Y) get_gdat_int((X),(Y),376) +#define get_gdat_llong_pos376(X,Y) get_gdat_llong((X),(Y),376) +#define get_gdat_float_pos376(X,Y) get_gdat_float((X),(Y),376) +#define get_gdat_uint_pos377(X,Y) get_gdat_uint((X),(Y),377) +#define get_gdat_ullong_pos377(X,Y) get_gdat_ullong((X),(Y),377) +#define get_gdat_ip_pos377(X,Y) get_gdat_ip((X),(Y),377) +#define get_gdat_ipv6_pos377(X,Y) get_gdat_ipv6((X),(Y),377) +#define get_gdat_string_pos377(X,Y) get_gdat_string((X),(Y),377) +#define get_gdat_v_str_pos377(X,Y) get_gdat_string((X),(Y),377) +#define get_gdat_bool_pos377(X,Y) get_gdat_bool((X),(Y),377) +#define get_gdat_int_pos377(X,Y) get_gdat_int((X),(Y),377) +#define get_gdat_llong_pos377(X,Y) get_gdat_llong((X),(Y),377) +#define get_gdat_float_pos377(X,Y) get_gdat_float((X),(Y),377) +#define get_gdat_uint_pos378(X,Y) get_gdat_uint((X),(Y),378) +#define get_gdat_ullong_pos378(X,Y) get_gdat_ullong((X),(Y),378) +#define get_gdat_ip_pos378(X,Y) get_gdat_ip((X),(Y),378) +#define get_gdat_ipv6_pos378(X,Y) get_gdat_ipv6((X),(Y),378) +#define get_gdat_string_pos378(X,Y) get_gdat_string((X),(Y),378) +#define get_gdat_v_str_pos378(X,Y) get_gdat_string((X),(Y),378) +#define get_gdat_bool_pos378(X,Y) get_gdat_bool((X),(Y),378) +#define get_gdat_int_pos378(X,Y) get_gdat_int((X),(Y),378) +#define get_gdat_llong_pos378(X,Y) get_gdat_llong((X),(Y),378) +#define get_gdat_float_pos378(X,Y) get_gdat_float((X),(Y),378) +#define get_gdat_uint_pos379(X,Y) get_gdat_uint((X),(Y),379) +#define get_gdat_ullong_pos379(X,Y) get_gdat_ullong((X),(Y),379) +#define get_gdat_ip_pos379(X,Y) get_gdat_ip((X),(Y),379) +#define get_gdat_ipv6_pos379(X,Y) get_gdat_ipv6((X),(Y),379) +#define get_gdat_string_pos379(X,Y) get_gdat_string((X),(Y),379) +#define get_gdat_v_str_pos379(X,Y) get_gdat_string((X),(Y),379) +#define get_gdat_bool_pos379(X,Y) get_gdat_bool((X),(Y),379) +#define get_gdat_int_pos379(X,Y) get_gdat_int((X),(Y),379) +#define get_gdat_llong_pos379(X,Y) get_gdat_llong((X),(Y),379) +#define get_gdat_float_pos379(X,Y) get_gdat_float((X),(Y),379) +#define get_gdat_uint_pos380(X,Y) get_gdat_uint((X),(Y),380) +#define get_gdat_ullong_pos380(X,Y) get_gdat_ullong((X),(Y),380) +#define get_gdat_ip_pos380(X,Y) get_gdat_ip((X),(Y),380) +#define get_gdat_ipv6_pos380(X,Y) get_gdat_ipv6((X),(Y),380) +#define get_gdat_string_pos380(X,Y) get_gdat_string((X),(Y),380) +#define get_gdat_v_str_pos380(X,Y) get_gdat_string((X),(Y),380) +#define get_gdat_bool_pos380(X,Y) get_gdat_bool((X),(Y),380) +#define get_gdat_int_pos380(X,Y) get_gdat_int((X),(Y),380) +#define get_gdat_llong_pos380(X,Y) get_gdat_llong((X),(Y),380) +#define get_gdat_float_pos380(X,Y) get_gdat_float((X),(Y),380) +#define get_gdat_uint_pos381(X,Y) get_gdat_uint((X),(Y),381) +#define get_gdat_ullong_pos381(X,Y) get_gdat_ullong((X),(Y),381) +#define get_gdat_ip_pos381(X,Y) get_gdat_ip((X),(Y),381) +#define get_gdat_ipv6_pos381(X,Y) get_gdat_ipv6((X),(Y),381) +#define get_gdat_string_pos381(X,Y) get_gdat_string((X),(Y),381) +#define get_gdat_v_str_pos381(X,Y) get_gdat_string((X),(Y),381) +#define get_gdat_bool_pos381(X,Y) get_gdat_bool((X),(Y),381) +#define get_gdat_int_pos381(X,Y) get_gdat_int((X),(Y),381) +#define get_gdat_llong_pos381(X,Y) get_gdat_llong((X),(Y),381) +#define get_gdat_float_pos381(X,Y) get_gdat_float((X),(Y),381) +#define get_gdat_uint_pos382(X,Y) get_gdat_uint((X),(Y),382) +#define get_gdat_ullong_pos382(X,Y) get_gdat_ullong((X),(Y),382) +#define get_gdat_ip_pos382(X,Y) get_gdat_ip((X),(Y),382) +#define get_gdat_ipv6_pos382(X,Y) get_gdat_ipv6((X),(Y),382) +#define get_gdat_string_pos382(X,Y) get_gdat_string((X),(Y),382) +#define get_gdat_v_str_pos382(X,Y) get_gdat_string((X),(Y),382) +#define get_gdat_bool_pos382(X,Y) get_gdat_bool((X),(Y),382) +#define get_gdat_int_pos382(X,Y) get_gdat_int((X),(Y),382) +#define get_gdat_llong_pos382(X,Y) get_gdat_llong((X),(Y),382) +#define get_gdat_float_pos382(X,Y) get_gdat_float((X),(Y),382) +#define get_gdat_uint_pos383(X,Y) get_gdat_uint((X),(Y),383) +#define get_gdat_ullong_pos383(X,Y) get_gdat_ullong((X),(Y),383) +#define get_gdat_ip_pos383(X,Y) get_gdat_ip((X),(Y),383) +#define get_gdat_ipv6_pos383(X,Y) get_gdat_ipv6((X),(Y),383) +#define get_gdat_string_pos383(X,Y) get_gdat_string((X),(Y),383) +#define get_gdat_v_str_pos383(X,Y) get_gdat_string((X),(Y),383) +#define get_gdat_bool_pos383(X,Y) get_gdat_bool((X),(Y),383) +#define get_gdat_int_pos383(X,Y) get_gdat_int((X),(Y),383) +#define get_gdat_llong_pos383(X,Y) get_gdat_llong((X),(Y),383) +#define get_gdat_float_pos383(X,Y) get_gdat_float((X),(Y),383) +#define get_gdat_uint_pos384(X,Y) get_gdat_uint((X),(Y),384) +#define get_gdat_ullong_pos384(X,Y) get_gdat_ullong((X),(Y),384) +#define get_gdat_ip_pos384(X,Y) get_gdat_ip((X),(Y),384) +#define get_gdat_ipv6_pos384(X,Y) get_gdat_ipv6((X),(Y),384) +#define get_gdat_string_pos384(X,Y) get_gdat_string((X),(Y),384) +#define get_gdat_v_str_pos384(X,Y) get_gdat_string((X),(Y),384) +#define get_gdat_bool_pos384(X,Y) get_gdat_bool((X),(Y),384) +#define get_gdat_int_pos384(X,Y) get_gdat_int((X),(Y),384) +#define get_gdat_llong_pos384(X,Y) get_gdat_llong((X),(Y),384) +#define get_gdat_float_pos384(X,Y) get_gdat_float((X),(Y),384) +#define get_gdat_uint_pos385(X,Y) get_gdat_uint((X),(Y),385) +#define get_gdat_ullong_pos385(X,Y) get_gdat_ullong((X),(Y),385) +#define get_gdat_ip_pos385(X,Y) get_gdat_ip((X),(Y),385) +#define get_gdat_ipv6_pos385(X,Y) get_gdat_ipv6((X),(Y),385) +#define get_gdat_string_pos385(X,Y) get_gdat_string((X),(Y),385) +#define get_gdat_v_str_pos385(X,Y) get_gdat_string((X),(Y),385) +#define get_gdat_bool_pos385(X,Y) get_gdat_bool((X),(Y),385) +#define get_gdat_int_pos385(X,Y) get_gdat_int((X),(Y),385) +#define get_gdat_llong_pos385(X,Y) get_gdat_llong((X),(Y),385) +#define get_gdat_float_pos385(X,Y) get_gdat_float((X),(Y),385) +#define get_gdat_uint_pos386(X,Y) get_gdat_uint((X),(Y),386) +#define get_gdat_ullong_pos386(X,Y) get_gdat_ullong((X),(Y),386) +#define get_gdat_ip_pos386(X,Y) get_gdat_ip((X),(Y),386) +#define get_gdat_ipv6_pos386(X,Y) get_gdat_ipv6((X),(Y),386) +#define get_gdat_string_pos386(X,Y) get_gdat_string((X),(Y),386) +#define get_gdat_v_str_pos386(X,Y) get_gdat_string((X),(Y),386) +#define get_gdat_bool_pos386(X,Y) get_gdat_bool((X),(Y),386) +#define get_gdat_int_pos386(X,Y) get_gdat_int((X),(Y),386) +#define get_gdat_llong_pos386(X,Y) get_gdat_llong((X),(Y),386) +#define get_gdat_float_pos386(X,Y) get_gdat_float((X),(Y),386) +#define get_gdat_uint_pos387(X,Y) get_gdat_uint((X),(Y),387) +#define get_gdat_ullong_pos387(X,Y) get_gdat_ullong((X),(Y),387) +#define get_gdat_ip_pos387(X,Y) get_gdat_ip((X),(Y),387) +#define get_gdat_ipv6_pos387(X,Y) get_gdat_ipv6((X),(Y),387) +#define get_gdat_string_pos387(X,Y) get_gdat_string((X),(Y),387) +#define get_gdat_v_str_pos387(X,Y) get_gdat_string((X),(Y),387) +#define get_gdat_bool_pos387(X,Y) get_gdat_bool((X),(Y),387) +#define get_gdat_int_pos387(X,Y) get_gdat_int((X),(Y),387) +#define get_gdat_llong_pos387(X,Y) get_gdat_llong((X),(Y),387) +#define get_gdat_float_pos387(X,Y) get_gdat_float((X),(Y),387) +#define get_gdat_uint_pos388(X,Y) get_gdat_uint((X),(Y),388) +#define get_gdat_ullong_pos388(X,Y) get_gdat_ullong((X),(Y),388) +#define get_gdat_ip_pos388(X,Y) get_gdat_ip((X),(Y),388) +#define get_gdat_ipv6_pos388(X,Y) get_gdat_ipv6((X),(Y),388) +#define get_gdat_string_pos388(X,Y) get_gdat_string((X),(Y),388) +#define get_gdat_v_str_pos388(X,Y) get_gdat_string((X),(Y),388) +#define get_gdat_bool_pos388(X,Y) get_gdat_bool((X),(Y),388) +#define get_gdat_int_pos388(X,Y) get_gdat_int((X),(Y),388) +#define get_gdat_llong_pos388(X,Y) get_gdat_llong((X),(Y),388) +#define get_gdat_float_pos388(X,Y) get_gdat_float((X),(Y),388) +#define get_gdat_uint_pos389(X,Y) get_gdat_uint((X),(Y),389) +#define get_gdat_ullong_pos389(X,Y) get_gdat_ullong((X),(Y),389) +#define get_gdat_ip_pos389(X,Y) get_gdat_ip((X),(Y),389) +#define get_gdat_ipv6_pos389(X,Y) get_gdat_ipv6((X),(Y),389) +#define get_gdat_string_pos389(X,Y) get_gdat_string((X),(Y),389) +#define get_gdat_v_str_pos389(X,Y) get_gdat_string((X),(Y),389) +#define get_gdat_bool_pos389(X,Y) get_gdat_bool((X),(Y),389) +#define get_gdat_int_pos389(X,Y) get_gdat_int((X),(Y),389) +#define get_gdat_llong_pos389(X,Y) get_gdat_llong((X),(Y),389) +#define get_gdat_float_pos389(X,Y) get_gdat_float((X),(Y),389) +#define get_gdat_uint_pos390(X,Y) get_gdat_uint((X),(Y),390) +#define get_gdat_ullong_pos390(X,Y) get_gdat_ullong((X),(Y),390) +#define get_gdat_ip_pos390(X,Y) get_gdat_ip((X),(Y),390) +#define get_gdat_ipv6_pos390(X,Y) get_gdat_ipv6((X),(Y),390) +#define get_gdat_string_pos390(X,Y) get_gdat_string((X),(Y),390) +#define get_gdat_v_str_pos390(X,Y) get_gdat_string((X),(Y),390) +#define get_gdat_bool_pos390(X,Y) get_gdat_bool((X),(Y),390) +#define get_gdat_int_pos390(X,Y) get_gdat_int((X),(Y),390) +#define get_gdat_llong_pos390(X,Y) get_gdat_llong((X),(Y),390) +#define get_gdat_float_pos390(X,Y) get_gdat_float((X),(Y),390) +#define get_gdat_uint_pos391(X,Y) get_gdat_uint((X),(Y),391) +#define get_gdat_ullong_pos391(X,Y) get_gdat_ullong((X),(Y),391) +#define get_gdat_ip_pos391(X,Y) get_gdat_ip((X),(Y),391) +#define get_gdat_ipv6_pos391(X,Y) get_gdat_ipv6((X),(Y),391) +#define get_gdat_string_pos391(X,Y) get_gdat_string((X),(Y),391) +#define get_gdat_v_str_pos391(X,Y) get_gdat_string((X),(Y),391) +#define get_gdat_bool_pos391(X,Y) get_gdat_bool((X),(Y),391) +#define get_gdat_int_pos391(X,Y) get_gdat_int((X),(Y),391) +#define get_gdat_llong_pos391(X,Y) get_gdat_llong((X),(Y),391) +#define get_gdat_float_pos391(X,Y) get_gdat_float((X),(Y),391) +#define get_gdat_uint_pos392(X,Y) get_gdat_uint((X),(Y),392) +#define get_gdat_ullong_pos392(X,Y) get_gdat_ullong((X),(Y),392) +#define get_gdat_ip_pos392(X,Y) get_gdat_ip((X),(Y),392) +#define get_gdat_ipv6_pos392(X,Y) get_gdat_ipv6((X),(Y),392) +#define get_gdat_string_pos392(X,Y) get_gdat_string((X),(Y),392) +#define get_gdat_v_str_pos392(X,Y) get_gdat_string((X),(Y),392) +#define get_gdat_bool_pos392(X,Y) get_gdat_bool((X),(Y),392) +#define get_gdat_int_pos392(X,Y) get_gdat_int((X),(Y),392) +#define get_gdat_llong_pos392(X,Y) get_gdat_llong((X),(Y),392) +#define get_gdat_float_pos392(X,Y) get_gdat_float((X),(Y),392) +#define get_gdat_uint_pos393(X,Y) get_gdat_uint((X),(Y),393) +#define get_gdat_ullong_pos393(X,Y) get_gdat_ullong((X),(Y),393) +#define get_gdat_ip_pos393(X,Y) get_gdat_ip((X),(Y),393) +#define get_gdat_ipv6_pos393(X,Y) get_gdat_ipv6((X),(Y),393) +#define get_gdat_string_pos393(X,Y) get_gdat_string((X),(Y),393) +#define get_gdat_v_str_pos393(X,Y) get_gdat_string((X),(Y),393) +#define get_gdat_bool_pos393(X,Y) get_gdat_bool((X),(Y),393) +#define get_gdat_int_pos393(X,Y) get_gdat_int((X),(Y),393) +#define get_gdat_llong_pos393(X,Y) get_gdat_llong((X),(Y),393) +#define get_gdat_float_pos393(X,Y) get_gdat_float((X),(Y),393) +#define get_gdat_uint_pos394(X,Y) get_gdat_uint((X),(Y),394) +#define get_gdat_ullong_pos394(X,Y) get_gdat_ullong((X),(Y),394) +#define get_gdat_ip_pos394(X,Y) get_gdat_ip((X),(Y),394) +#define get_gdat_ipv6_pos394(X,Y) get_gdat_ipv6((X),(Y),394) +#define get_gdat_string_pos394(X,Y) get_gdat_string((X),(Y),394) +#define get_gdat_v_str_pos394(X,Y) get_gdat_string((X),(Y),394) +#define get_gdat_bool_pos394(X,Y) get_gdat_bool((X),(Y),394) +#define get_gdat_int_pos394(X,Y) get_gdat_int((X),(Y),394) +#define get_gdat_llong_pos394(X,Y) get_gdat_llong((X),(Y),394) +#define get_gdat_float_pos394(X,Y) get_gdat_float((X),(Y),394) +#define get_gdat_uint_pos395(X,Y) get_gdat_uint((X),(Y),395) +#define get_gdat_ullong_pos395(X,Y) get_gdat_ullong((X),(Y),395) +#define get_gdat_ip_pos395(X,Y) get_gdat_ip((X),(Y),395) +#define get_gdat_ipv6_pos395(X,Y) get_gdat_ipv6((X),(Y),395) +#define get_gdat_string_pos395(X,Y) get_gdat_string((X),(Y),395) +#define get_gdat_v_str_pos395(X,Y) get_gdat_string((X),(Y),395) +#define get_gdat_bool_pos395(X,Y) get_gdat_bool((X),(Y),395) +#define get_gdat_int_pos395(X,Y) get_gdat_int((X),(Y),395) +#define get_gdat_llong_pos395(X,Y) get_gdat_llong((X),(Y),395) +#define get_gdat_float_pos395(X,Y) get_gdat_float((X),(Y),395) +#define get_gdat_uint_pos396(X,Y) get_gdat_uint((X),(Y),396) +#define get_gdat_ullong_pos396(X,Y) get_gdat_ullong((X),(Y),396) +#define get_gdat_ip_pos396(X,Y) get_gdat_ip((X),(Y),396) +#define get_gdat_ipv6_pos396(X,Y) get_gdat_ipv6((X),(Y),396) +#define get_gdat_string_pos396(X,Y) get_gdat_string((X),(Y),396) +#define get_gdat_v_str_pos396(X,Y) get_gdat_string((X),(Y),396) +#define get_gdat_bool_pos396(X,Y) get_gdat_bool((X),(Y),396) +#define get_gdat_int_pos396(X,Y) get_gdat_int((X),(Y),396) +#define get_gdat_llong_pos396(X,Y) get_gdat_llong((X),(Y),396) +#define get_gdat_float_pos396(X,Y) get_gdat_float((X),(Y),396) +#define get_gdat_uint_pos397(X,Y) get_gdat_uint((X),(Y),397) +#define get_gdat_ullong_pos397(X,Y) get_gdat_ullong((X),(Y),397) +#define get_gdat_ip_pos397(X,Y) get_gdat_ip((X),(Y),397) +#define get_gdat_ipv6_pos397(X,Y) get_gdat_ipv6((X),(Y),397) +#define get_gdat_string_pos397(X,Y) get_gdat_string((X),(Y),397) +#define get_gdat_v_str_pos397(X,Y) get_gdat_string((X),(Y),397) +#define get_gdat_bool_pos397(X,Y) get_gdat_bool((X),(Y),397) +#define get_gdat_int_pos397(X,Y) get_gdat_int((X),(Y),397) +#define get_gdat_llong_pos397(X,Y) get_gdat_llong((X),(Y),397) +#define get_gdat_float_pos397(X,Y) get_gdat_float((X),(Y),397) +#define get_gdat_uint_pos398(X,Y) get_gdat_uint((X),(Y),398) +#define get_gdat_ullong_pos398(X,Y) get_gdat_ullong((X),(Y),398) +#define get_gdat_ip_pos398(X,Y) get_gdat_ip((X),(Y),398) +#define get_gdat_ipv6_pos398(X,Y) get_gdat_ipv6((X),(Y),398) +#define get_gdat_string_pos398(X,Y) get_gdat_string((X),(Y),398) +#define get_gdat_v_str_pos398(X,Y) get_gdat_string((X),(Y),398) +#define get_gdat_bool_pos398(X,Y) get_gdat_bool((X),(Y),398) +#define get_gdat_int_pos398(X,Y) get_gdat_int((X),(Y),398) +#define get_gdat_llong_pos398(X,Y) get_gdat_llong((X),(Y),398) +#define get_gdat_float_pos398(X,Y) get_gdat_float((X),(Y),398) +#define get_gdat_uint_pos399(X,Y) get_gdat_uint((X),(Y),399) +#define get_gdat_ullong_pos399(X,Y) get_gdat_ullong((X),(Y),399) +#define get_gdat_ip_pos399(X,Y) get_gdat_ip((X),(Y),399) +#define get_gdat_ipv6_pos399(X,Y) get_gdat_ipv6((X),(Y),399) +#define get_gdat_string_pos399(X,Y) get_gdat_string((X),(Y),399) +#define get_gdat_v_str_pos399(X,Y) get_gdat_string((X),(Y),399) +#define get_gdat_bool_pos399(X,Y) get_gdat_bool((X),(Y),399) +#define get_gdat_int_pos399(X,Y) get_gdat_int((X),(Y),399) +#define get_gdat_llong_pos399(X,Y) get_gdat_llong((X),(Y),399) +#define get_gdat_float_pos399(X,Y) get_gdat_float((X),(Y),399) +#define get_gdat_uint_pos400(X,Y) get_gdat_uint((X),(Y),400) +#define get_gdat_ullong_pos400(X,Y) get_gdat_ullong((X),(Y),400) +#define get_gdat_ip_pos400(X,Y) get_gdat_ip((X),(Y),400) +#define get_gdat_ipv6_pos400(X,Y) get_gdat_ipv6((X),(Y),400) +#define get_gdat_string_pos400(X,Y) get_gdat_string((X),(Y),400) +#define get_gdat_v_str_pos400(X,Y) get_gdat_string((X),(Y),400) +#define get_gdat_bool_pos400(X,Y) get_gdat_bool((X),(Y),400) +#define get_gdat_int_pos400(X,Y) get_gdat_int((X),(Y),400) +#define get_gdat_llong_pos400(X,Y) get_gdat_llong((X),(Y),400) +#define get_gdat_float_pos400(X,Y) get_gdat_float((X),(Y),400) +#define get_gdat_uint_pos401(X,Y) get_gdat_uint((X),(Y),401) +#define get_gdat_ullong_pos401(X,Y) get_gdat_ullong((X),(Y),401) +#define get_gdat_ip_pos401(X,Y) get_gdat_ip((X),(Y),401) +#define get_gdat_ipv6_pos401(X,Y) get_gdat_ipv6((X),(Y),401) +#define get_gdat_string_pos401(X,Y) get_gdat_string((X),(Y),401) +#define get_gdat_v_str_pos401(X,Y) get_gdat_string((X),(Y),401) +#define get_gdat_bool_pos401(X,Y) get_gdat_bool((X),(Y),401) +#define get_gdat_int_pos401(X,Y) get_gdat_int((X),(Y),401) +#define get_gdat_llong_pos401(X,Y) get_gdat_llong((X),(Y),401) +#define get_gdat_float_pos401(X,Y) get_gdat_float((X),(Y),401) +#define get_gdat_uint_pos402(X,Y) get_gdat_uint((X),(Y),402) +#define get_gdat_ullong_pos402(X,Y) get_gdat_ullong((X),(Y),402) +#define get_gdat_ip_pos402(X,Y) get_gdat_ip((X),(Y),402) +#define get_gdat_ipv6_pos402(X,Y) get_gdat_ipv6((X),(Y),402) +#define get_gdat_string_pos402(X,Y) get_gdat_string((X),(Y),402) +#define get_gdat_v_str_pos402(X,Y) get_gdat_string((X),(Y),402) +#define get_gdat_bool_pos402(X,Y) get_gdat_bool((X),(Y),402) +#define get_gdat_int_pos402(X,Y) get_gdat_int((X),(Y),402) +#define get_gdat_llong_pos402(X,Y) get_gdat_llong((X),(Y),402) +#define get_gdat_float_pos402(X,Y) get_gdat_float((X),(Y),402) +#define get_gdat_uint_pos403(X,Y) get_gdat_uint((X),(Y),403) +#define get_gdat_ullong_pos403(X,Y) get_gdat_ullong((X),(Y),403) +#define get_gdat_ip_pos403(X,Y) get_gdat_ip((X),(Y),403) +#define get_gdat_ipv6_pos403(X,Y) get_gdat_ipv6((X),(Y),403) +#define get_gdat_string_pos403(X,Y) get_gdat_string((X),(Y),403) +#define get_gdat_v_str_pos403(X,Y) get_gdat_string((X),(Y),403) +#define get_gdat_bool_pos403(X,Y) get_gdat_bool((X),(Y),403) +#define get_gdat_int_pos403(X,Y) get_gdat_int((X),(Y),403) +#define get_gdat_llong_pos403(X,Y) get_gdat_llong((X),(Y),403) +#define get_gdat_float_pos403(X,Y) get_gdat_float((X),(Y),403) +#define get_gdat_uint_pos404(X,Y) get_gdat_uint((X),(Y),404) +#define get_gdat_ullong_pos404(X,Y) get_gdat_ullong((X),(Y),404) +#define get_gdat_ip_pos404(X,Y) get_gdat_ip((X),(Y),404) +#define get_gdat_ipv6_pos404(X,Y) get_gdat_ipv6((X),(Y),404) +#define get_gdat_string_pos404(X,Y) get_gdat_string((X),(Y),404) +#define get_gdat_v_str_pos404(X,Y) get_gdat_string((X),(Y),404) +#define get_gdat_bool_pos404(X,Y) get_gdat_bool((X),(Y),404) +#define get_gdat_int_pos404(X,Y) get_gdat_int((X),(Y),404) +#define get_gdat_llong_pos404(X,Y) get_gdat_llong((X),(Y),404) +#define get_gdat_float_pos404(X,Y) get_gdat_float((X),(Y),404) +#define get_gdat_uint_pos405(X,Y) get_gdat_uint((X),(Y),405) +#define get_gdat_ullong_pos405(X,Y) get_gdat_ullong((X),(Y),405) +#define get_gdat_ip_pos405(X,Y) get_gdat_ip((X),(Y),405) +#define get_gdat_ipv6_pos405(X,Y) get_gdat_ipv6((X),(Y),405) +#define get_gdat_string_pos405(X,Y) get_gdat_string((X),(Y),405) +#define get_gdat_v_str_pos405(X,Y) get_gdat_string((X),(Y),405) +#define get_gdat_bool_pos405(X,Y) get_gdat_bool((X),(Y),405) +#define get_gdat_int_pos405(X,Y) get_gdat_int((X),(Y),405) +#define get_gdat_llong_pos405(X,Y) get_gdat_llong((X),(Y),405) +#define get_gdat_float_pos405(X,Y) get_gdat_float((X),(Y),405) +#define get_gdat_uint_pos406(X,Y) get_gdat_uint((X),(Y),406) +#define get_gdat_ullong_pos406(X,Y) get_gdat_ullong((X),(Y),406) +#define get_gdat_ip_pos406(X,Y) get_gdat_ip((X),(Y),406) +#define get_gdat_ipv6_pos406(X,Y) get_gdat_ipv6((X),(Y),406) +#define get_gdat_string_pos406(X,Y) get_gdat_string((X),(Y),406) +#define get_gdat_v_str_pos406(X,Y) get_gdat_string((X),(Y),406) +#define get_gdat_bool_pos406(X,Y) get_gdat_bool((X),(Y),406) +#define get_gdat_int_pos406(X,Y) get_gdat_int((X),(Y),406) +#define get_gdat_llong_pos406(X,Y) get_gdat_llong((X),(Y),406) +#define get_gdat_float_pos406(X,Y) get_gdat_float((X),(Y),406) +#define get_gdat_uint_pos407(X,Y) get_gdat_uint((X),(Y),407) +#define get_gdat_ullong_pos407(X,Y) get_gdat_ullong((X),(Y),407) +#define get_gdat_ip_pos407(X,Y) get_gdat_ip((X),(Y),407) +#define get_gdat_ipv6_pos407(X,Y) get_gdat_ipv6((X),(Y),407) +#define get_gdat_string_pos407(X,Y) get_gdat_string((X),(Y),407) +#define get_gdat_v_str_pos407(X,Y) get_gdat_string((X),(Y),407) +#define get_gdat_bool_pos407(X,Y) get_gdat_bool((X),(Y),407) +#define get_gdat_int_pos407(X,Y) get_gdat_int((X),(Y),407) +#define get_gdat_llong_pos407(X,Y) get_gdat_llong((X),(Y),407) +#define get_gdat_float_pos407(X,Y) get_gdat_float((X),(Y),407) +#define get_gdat_uint_pos408(X,Y) get_gdat_uint((X),(Y),408) +#define get_gdat_ullong_pos408(X,Y) get_gdat_ullong((X),(Y),408) +#define get_gdat_ip_pos408(X,Y) get_gdat_ip((X),(Y),408) +#define get_gdat_ipv6_pos408(X,Y) get_gdat_ipv6((X),(Y),408) +#define get_gdat_string_pos408(X,Y) get_gdat_string((X),(Y),408) +#define get_gdat_v_str_pos408(X,Y) get_gdat_string((X),(Y),408) +#define get_gdat_bool_pos408(X,Y) get_gdat_bool((X),(Y),408) +#define get_gdat_int_pos408(X,Y) get_gdat_int((X),(Y),408) +#define get_gdat_llong_pos408(X,Y) get_gdat_llong((X),(Y),408) +#define get_gdat_float_pos408(X,Y) get_gdat_float((X),(Y),408) +#define get_gdat_uint_pos409(X,Y) get_gdat_uint((X),(Y),409) +#define get_gdat_ullong_pos409(X,Y) get_gdat_ullong((X),(Y),409) +#define get_gdat_ip_pos409(X,Y) get_gdat_ip((X),(Y),409) +#define get_gdat_ipv6_pos409(X,Y) get_gdat_ipv6((X),(Y),409) +#define get_gdat_string_pos409(X,Y) get_gdat_string((X),(Y),409) +#define get_gdat_v_str_pos409(X,Y) get_gdat_string((X),(Y),409) +#define get_gdat_bool_pos409(X,Y) get_gdat_bool((X),(Y),409) +#define get_gdat_int_pos409(X,Y) get_gdat_int((X),(Y),409) +#define get_gdat_llong_pos409(X,Y) get_gdat_llong((X),(Y),409) +#define get_gdat_float_pos409(X,Y) get_gdat_float((X),(Y),409) +#define get_gdat_uint_pos410(X,Y) get_gdat_uint((X),(Y),410) +#define get_gdat_ullong_pos410(X,Y) get_gdat_ullong((X),(Y),410) +#define get_gdat_ip_pos410(X,Y) get_gdat_ip((X),(Y),410) +#define get_gdat_ipv6_pos410(X,Y) get_gdat_ipv6((X),(Y),410) +#define get_gdat_string_pos410(X,Y) get_gdat_string((X),(Y),410) +#define get_gdat_v_str_pos410(X,Y) get_gdat_string((X),(Y),410) +#define get_gdat_bool_pos410(X,Y) get_gdat_bool((X),(Y),410) +#define get_gdat_int_pos410(X,Y) get_gdat_int((X),(Y),410) +#define get_gdat_llong_pos410(X,Y) get_gdat_llong((X),(Y),410) +#define get_gdat_float_pos410(X,Y) get_gdat_float((X),(Y),410) +#define get_gdat_uint_pos411(X,Y) get_gdat_uint((X),(Y),411) +#define get_gdat_ullong_pos411(X,Y) get_gdat_ullong((X),(Y),411) +#define get_gdat_ip_pos411(X,Y) get_gdat_ip((X),(Y),411) +#define get_gdat_ipv6_pos411(X,Y) get_gdat_ipv6((X),(Y),411) +#define get_gdat_string_pos411(X,Y) get_gdat_string((X),(Y),411) +#define get_gdat_v_str_pos411(X,Y) get_gdat_string((X),(Y),411) +#define get_gdat_bool_pos411(X,Y) get_gdat_bool((X),(Y),411) +#define get_gdat_int_pos411(X,Y) get_gdat_int((X),(Y),411) +#define get_gdat_llong_pos411(X,Y) get_gdat_llong((X),(Y),411) +#define get_gdat_float_pos411(X,Y) get_gdat_float((X),(Y),411) +#define get_gdat_uint_pos412(X,Y) get_gdat_uint((X),(Y),412) +#define get_gdat_ullong_pos412(X,Y) get_gdat_ullong((X),(Y),412) +#define get_gdat_ip_pos412(X,Y) get_gdat_ip((X),(Y),412) +#define get_gdat_ipv6_pos412(X,Y) get_gdat_ipv6((X),(Y),412) +#define get_gdat_string_pos412(X,Y) get_gdat_string((X),(Y),412) +#define get_gdat_v_str_pos412(X,Y) get_gdat_string((X),(Y),412) +#define get_gdat_bool_pos412(X,Y) get_gdat_bool((X),(Y),412) +#define get_gdat_int_pos412(X,Y) get_gdat_int((X),(Y),412) +#define get_gdat_llong_pos412(X,Y) get_gdat_llong((X),(Y),412) +#define get_gdat_float_pos412(X,Y) get_gdat_float((X),(Y),412) +#define get_gdat_uint_pos413(X,Y) get_gdat_uint((X),(Y),413) +#define get_gdat_ullong_pos413(X,Y) get_gdat_ullong((X),(Y),413) +#define get_gdat_ip_pos413(X,Y) get_gdat_ip((X),(Y),413) +#define get_gdat_ipv6_pos413(X,Y) get_gdat_ipv6((X),(Y),413) +#define get_gdat_string_pos413(X,Y) get_gdat_string((X),(Y),413) +#define get_gdat_v_str_pos413(X,Y) get_gdat_string((X),(Y),413) +#define get_gdat_bool_pos413(X,Y) get_gdat_bool((X),(Y),413) +#define get_gdat_int_pos413(X,Y) get_gdat_int((X),(Y),413) +#define get_gdat_llong_pos413(X,Y) get_gdat_llong((X),(Y),413) +#define get_gdat_float_pos413(X,Y) get_gdat_float((X),(Y),413) +#define get_gdat_uint_pos414(X,Y) get_gdat_uint((X),(Y),414) +#define get_gdat_ullong_pos414(X,Y) get_gdat_ullong((X),(Y),414) +#define get_gdat_ip_pos414(X,Y) get_gdat_ip((X),(Y),414) +#define get_gdat_ipv6_pos414(X,Y) get_gdat_ipv6((X),(Y),414) +#define get_gdat_string_pos414(X,Y) get_gdat_string((X),(Y),414) +#define get_gdat_v_str_pos414(X,Y) get_gdat_string((X),(Y),414) +#define get_gdat_bool_pos414(X,Y) get_gdat_bool((X),(Y),414) +#define get_gdat_int_pos414(X,Y) get_gdat_int((X),(Y),414) +#define get_gdat_llong_pos414(X,Y) get_gdat_llong((X),(Y),414) +#define get_gdat_float_pos414(X,Y) get_gdat_float((X),(Y),414) +#define get_gdat_uint_pos415(X,Y) get_gdat_uint((X),(Y),415) +#define get_gdat_ullong_pos415(X,Y) get_gdat_ullong((X),(Y),415) +#define get_gdat_ip_pos415(X,Y) get_gdat_ip((X),(Y),415) +#define get_gdat_ipv6_pos415(X,Y) get_gdat_ipv6((X),(Y),415) +#define get_gdat_string_pos415(X,Y) get_gdat_string((X),(Y),415) +#define get_gdat_v_str_pos415(X,Y) get_gdat_string((X),(Y),415) +#define get_gdat_bool_pos415(X,Y) get_gdat_bool((X),(Y),415) +#define get_gdat_int_pos415(X,Y) get_gdat_int((X),(Y),415) +#define get_gdat_llong_pos415(X,Y) get_gdat_llong((X),(Y),415) +#define get_gdat_float_pos415(X,Y) get_gdat_float((X),(Y),415) +#define get_gdat_uint_pos416(X,Y) get_gdat_uint((X),(Y),416) +#define get_gdat_ullong_pos416(X,Y) get_gdat_ullong((X),(Y),416) +#define get_gdat_ip_pos416(X,Y) get_gdat_ip((X),(Y),416) +#define get_gdat_ipv6_pos416(X,Y) get_gdat_ipv6((X),(Y),416) +#define get_gdat_string_pos416(X,Y) get_gdat_string((X),(Y),416) +#define get_gdat_v_str_pos416(X,Y) get_gdat_string((X),(Y),416) +#define get_gdat_bool_pos416(X,Y) get_gdat_bool((X),(Y),416) +#define get_gdat_int_pos416(X,Y) get_gdat_int((X),(Y),416) +#define get_gdat_llong_pos416(X,Y) get_gdat_llong((X),(Y),416) +#define get_gdat_float_pos416(X,Y) get_gdat_float((X),(Y),416) +#define get_gdat_uint_pos417(X,Y) get_gdat_uint((X),(Y),417) +#define get_gdat_ullong_pos417(X,Y) get_gdat_ullong((X),(Y),417) +#define get_gdat_ip_pos417(X,Y) get_gdat_ip((X),(Y),417) +#define get_gdat_ipv6_pos417(X,Y) get_gdat_ipv6((X),(Y),417) +#define get_gdat_string_pos417(X,Y) get_gdat_string((X),(Y),417) +#define get_gdat_v_str_pos417(X,Y) get_gdat_string((X),(Y),417) +#define get_gdat_bool_pos417(X,Y) get_gdat_bool((X),(Y),417) +#define get_gdat_int_pos417(X,Y) get_gdat_int((X),(Y),417) +#define get_gdat_llong_pos417(X,Y) get_gdat_llong((X),(Y),417) +#define get_gdat_float_pos417(X,Y) get_gdat_float((X),(Y),417) +#define get_gdat_uint_pos418(X,Y) get_gdat_uint((X),(Y),418) +#define get_gdat_ullong_pos418(X,Y) get_gdat_ullong((X),(Y),418) +#define get_gdat_ip_pos418(X,Y) get_gdat_ip((X),(Y),418) +#define get_gdat_ipv6_pos418(X,Y) get_gdat_ipv6((X),(Y),418) +#define get_gdat_string_pos418(X,Y) get_gdat_string((X),(Y),418) +#define get_gdat_v_str_pos418(X,Y) get_gdat_string((X),(Y),418) +#define get_gdat_bool_pos418(X,Y) get_gdat_bool((X),(Y),418) +#define get_gdat_int_pos418(X,Y) get_gdat_int((X),(Y),418) +#define get_gdat_llong_pos418(X,Y) get_gdat_llong((X),(Y),418) +#define get_gdat_float_pos418(X,Y) get_gdat_float((X),(Y),418) +#define get_gdat_uint_pos419(X,Y) get_gdat_uint((X),(Y),419) +#define get_gdat_ullong_pos419(X,Y) get_gdat_ullong((X),(Y),419) +#define get_gdat_ip_pos419(X,Y) get_gdat_ip((X),(Y),419) +#define get_gdat_ipv6_pos419(X,Y) get_gdat_ipv6((X),(Y),419) +#define get_gdat_string_pos419(X,Y) get_gdat_string((X),(Y),419) +#define get_gdat_v_str_pos419(X,Y) get_gdat_string((X),(Y),419) +#define get_gdat_bool_pos419(X,Y) get_gdat_bool((X),(Y),419) +#define get_gdat_int_pos419(X,Y) get_gdat_int((X),(Y),419) +#define get_gdat_llong_pos419(X,Y) get_gdat_llong((X),(Y),419) +#define get_gdat_float_pos419(X,Y) get_gdat_float((X),(Y),419) +#define get_gdat_uint_pos420(X,Y) get_gdat_uint((X),(Y),420) +#define get_gdat_ullong_pos420(X,Y) get_gdat_ullong((X),(Y),420) +#define get_gdat_ip_pos420(X,Y) get_gdat_ip((X),(Y),420) +#define get_gdat_ipv6_pos420(X,Y) get_gdat_ipv6((X),(Y),420) +#define get_gdat_string_pos420(X,Y) get_gdat_string((X),(Y),420) +#define get_gdat_v_str_pos420(X,Y) get_gdat_string((X),(Y),420) +#define get_gdat_bool_pos420(X,Y) get_gdat_bool((X),(Y),420) +#define get_gdat_int_pos420(X,Y) get_gdat_int((X),(Y),420) +#define get_gdat_llong_pos420(X,Y) get_gdat_llong((X),(Y),420) +#define get_gdat_float_pos420(X,Y) get_gdat_float((X),(Y),420) +#define get_gdat_uint_pos421(X,Y) get_gdat_uint((X),(Y),421) +#define get_gdat_ullong_pos421(X,Y) get_gdat_ullong((X),(Y),421) +#define get_gdat_ip_pos421(X,Y) get_gdat_ip((X),(Y),421) +#define get_gdat_ipv6_pos421(X,Y) get_gdat_ipv6((X),(Y),421) +#define get_gdat_string_pos421(X,Y) get_gdat_string((X),(Y),421) +#define get_gdat_v_str_pos421(X,Y) get_gdat_string((X),(Y),421) +#define get_gdat_bool_pos421(X,Y) get_gdat_bool((X),(Y),421) +#define get_gdat_int_pos421(X,Y) get_gdat_int((X),(Y),421) +#define get_gdat_llong_pos421(X,Y) get_gdat_llong((X),(Y),421) +#define get_gdat_float_pos421(X,Y) get_gdat_float((X),(Y),421) +#define get_gdat_uint_pos422(X,Y) get_gdat_uint((X),(Y),422) +#define get_gdat_ullong_pos422(X,Y) get_gdat_ullong((X),(Y),422) +#define get_gdat_ip_pos422(X,Y) get_gdat_ip((X),(Y),422) +#define get_gdat_ipv6_pos422(X,Y) get_gdat_ipv6((X),(Y),422) +#define get_gdat_string_pos422(X,Y) get_gdat_string((X),(Y),422) +#define get_gdat_v_str_pos422(X,Y) get_gdat_string((X),(Y),422) +#define get_gdat_bool_pos422(X,Y) get_gdat_bool((X),(Y),422) +#define get_gdat_int_pos422(X,Y) get_gdat_int((X),(Y),422) +#define get_gdat_llong_pos422(X,Y) get_gdat_llong((X),(Y),422) +#define get_gdat_float_pos422(X,Y) get_gdat_float((X),(Y),422) +#define get_gdat_uint_pos423(X,Y) get_gdat_uint((X),(Y),423) +#define get_gdat_ullong_pos423(X,Y) get_gdat_ullong((X),(Y),423) +#define get_gdat_ip_pos423(X,Y) get_gdat_ip((X),(Y),423) +#define get_gdat_ipv6_pos423(X,Y) get_gdat_ipv6((X),(Y),423) +#define get_gdat_string_pos423(X,Y) get_gdat_string((X),(Y),423) +#define get_gdat_v_str_pos423(X,Y) get_gdat_string((X),(Y),423) +#define get_gdat_bool_pos423(X,Y) get_gdat_bool((X),(Y),423) +#define get_gdat_int_pos423(X,Y) get_gdat_int((X),(Y),423) +#define get_gdat_llong_pos423(X,Y) get_gdat_llong((X),(Y),423) +#define get_gdat_float_pos423(X,Y) get_gdat_float((X),(Y),423) +#define get_gdat_uint_pos424(X,Y) get_gdat_uint((X),(Y),424) +#define get_gdat_ullong_pos424(X,Y) get_gdat_ullong((X),(Y),424) +#define get_gdat_ip_pos424(X,Y) get_gdat_ip((X),(Y),424) +#define get_gdat_ipv6_pos424(X,Y) get_gdat_ipv6((X),(Y),424) +#define get_gdat_string_pos424(X,Y) get_gdat_string((X),(Y),424) +#define get_gdat_v_str_pos424(X,Y) get_gdat_string((X),(Y),424) +#define get_gdat_bool_pos424(X,Y) get_gdat_bool((X),(Y),424) +#define get_gdat_int_pos424(X,Y) get_gdat_int((X),(Y),424) +#define get_gdat_llong_pos424(X,Y) get_gdat_llong((X),(Y),424) +#define get_gdat_float_pos424(X,Y) get_gdat_float((X),(Y),424) +#define get_gdat_uint_pos425(X,Y) get_gdat_uint((X),(Y),425) +#define get_gdat_ullong_pos425(X,Y) get_gdat_ullong((X),(Y),425) +#define get_gdat_ip_pos425(X,Y) get_gdat_ip((X),(Y),425) +#define get_gdat_ipv6_pos425(X,Y) get_gdat_ipv6((X),(Y),425) +#define get_gdat_string_pos425(X,Y) get_gdat_string((X),(Y),425) +#define get_gdat_v_str_pos425(X,Y) get_gdat_string((X),(Y),425) +#define get_gdat_bool_pos425(X,Y) get_gdat_bool((X),(Y),425) +#define get_gdat_int_pos425(X,Y) get_gdat_int((X),(Y),425) +#define get_gdat_llong_pos425(X,Y) get_gdat_llong((X),(Y),425) +#define get_gdat_float_pos425(X,Y) get_gdat_float((X),(Y),425) +#define get_gdat_uint_pos426(X,Y) get_gdat_uint((X),(Y),426) +#define get_gdat_ullong_pos426(X,Y) get_gdat_ullong((X),(Y),426) +#define get_gdat_ip_pos426(X,Y) get_gdat_ip((X),(Y),426) +#define get_gdat_ipv6_pos426(X,Y) get_gdat_ipv6((X),(Y),426) +#define get_gdat_string_pos426(X,Y) get_gdat_string((X),(Y),426) +#define get_gdat_v_str_pos426(X,Y) get_gdat_string((X),(Y),426) +#define get_gdat_bool_pos426(X,Y) get_gdat_bool((X),(Y),426) +#define get_gdat_int_pos426(X,Y) get_gdat_int((X),(Y),426) +#define get_gdat_llong_pos426(X,Y) get_gdat_llong((X),(Y),426) +#define get_gdat_float_pos426(X,Y) get_gdat_float((X),(Y),426) +#define get_gdat_uint_pos427(X,Y) get_gdat_uint((X),(Y),427) +#define get_gdat_ullong_pos427(X,Y) get_gdat_ullong((X),(Y),427) +#define get_gdat_ip_pos427(X,Y) get_gdat_ip((X),(Y),427) +#define get_gdat_ipv6_pos427(X,Y) get_gdat_ipv6((X),(Y),427) +#define get_gdat_string_pos427(X,Y) get_gdat_string((X),(Y),427) +#define get_gdat_v_str_pos427(X,Y) get_gdat_string((X),(Y),427) +#define get_gdat_bool_pos427(X,Y) get_gdat_bool((X),(Y),427) +#define get_gdat_int_pos427(X,Y) get_gdat_int((X),(Y),427) +#define get_gdat_llong_pos427(X,Y) get_gdat_llong((X),(Y),427) +#define get_gdat_float_pos427(X,Y) get_gdat_float((X),(Y),427) +#define get_gdat_uint_pos428(X,Y) get_gdat_uint((X),(Y),428) +#define get_gdat_ullong_pos428(X,Y) get_gdat_ullong((X),(Y),428) +#define get_gdat_ip_pos428(X,Y) get_gdat_ip((X),(Y),428) +#define get_gdat_ipv6_pos428(X,Y) get_gdat_ipv6((X),(Y),428) +#define get_gdat_string_pos428(X,Y) get_gdat_string((X),(Y),428) +#define get_gdat_v_str_pos428(X,Y) get_gdat_string((X),(Y),428) +#define get_gdat_bool_pos428(X,Y) get_gdat_bool((X),(Y),428) +#define get_gdat_int_pos428(X,Y) get_gdat_int((X),(Y),428) +#define get_gdat_llong_pos428(X,Y) get_gdat_llong((X),(Y),428) +#define get_gdat_float_pos428(X,Y) get_gdat_float((X),(Y),428) +#define get_gdat_uint_pos429(X,Y) get_gdat_uint((X),(Y),429) +#define get_gdat_ullong_pos429(X,Y) get_gdat_ullong((X),(Y),429) +#define get_gdat_ip_pos429(X,Y) get_gdat_ip((X),(Y),429) +#define get_gdat_ipv6_pos429(X,Y) get_gdat_ipv6((X),(Y),429) +#define get_gdat_string_pos429(X,Y) get_gdat_string((X),(Y),429) +#define get_gdat_v_str_pos429(X,Y) get_gdat_string((X),(Y),429) +#define get_gdat_bool_pos429(X,Y) get_gdat_bool((X),(Y),429) +#define get_gdat_int_pos429(X,Y) get_gdat_int((X),(Y),429) +#define get_gdat_llong_pos429(X,Y) get_gdat_llong((X),(Y),429) +#define get_gdat_float_pos429(X,Y) get_gdat_float((X),(Y),429) +#define get_gdat_uint_pos430(X,Y) get_gdat_uint((X),(Y),430) +#define get_gdat_ullong_pos430(X,Y) get_gdat_ullong((X),(Y),430) +#define get_gdat_ip_pos430(X,Y) get_gdat_ip((X),(Y),430) +#define get_gdat_ipv6_pos430(X,Y) get_gdat_ipv6((X),(Y),430) +#define get_gdat_string_pos430(X,Y) get_gdat_string((X),(Y),430) +#define get_gdat_v_str_pos430(X,Y) get_gdat_string((X),(Y),430) +#define get_gdat_bool_pos430(X,Y) get_gdat_bool((X),(Y),430) +#define get_gdat_int_pos430(X,Y) get_gdat_int((X),(Y),430) +#define get_gdat_llong_pos430(X,Y) get_gdat_llong((X),(Y),430) +#define get_gdat_float_pos430(X,Y) get_gdat_float((X),(Y),430) +#define get_gdat_uint_pos431(X,Y) get_gdat_uint((X),(Y),431) +#define get_gdat_ullong_pos431(X,Y) get_gdat_ullong((X),(Y),431) +#define get_gdat_ip_pos431(X,Y) get_gdat_ip((X),(Y),431) +#define get_gdat_ipv6_pos431(X,Y) get_gdat_ipv6((X),(Y),431) +#define get_gdat_string_pos431(X,Y) get_gdat_string((X),(Y),431) +#define get_gdat_v_str_pos431(X,Y) get_gdat_string((X),(Y),431) +#define get_gdat_bool_pos431(X,Y) get_gdat_bool((X),(Y),431) +#define get_gdat_int_pos431(X,Y) get_gdat_int((X),(Y),431) +#define get_gdat_llong_pos431(X,Y) get_gdat_llong((X),(Y),431) +#define get_gdat_float_pos431(X,Y) get_gdat_float((X),(Y),431) +#define get_gdat_uint_pos432(X,Y) get_gdat_uint((X),(Y),432) +#define get_gdat_ullong_pos432(X,Y) get_gdat_ullong((X),(Y),432) +#define get_gdat_ip_pos432(X,Y) get_gdat_ip((X),(Y),432) +#define get_gdat_ipv6_pos432(X,Y) get_gdat_ipv6((X),(Y),432) +#define get_gdat_string_pos432(X,Y) get_gdat_string((X),(Y),432) +#define get_gdat_v_str_pos432(X,Y) get_gdat_string((X),(Y),432) +#define get_gdat_bool_pos432(X,Y) get_gdat_bool((X),(Y),432) +#define get_gdat_int_pos432(X,Y) get_gdat_int((X),(Y),432) +#define get_gdat_llong_pos432(X,Y) get_gdat_llong((X),(Y),432) +#define get_gdat_float_pos432(X,Y) get_gdat_float((X),(Y),432) +#define get_gdat_uint_pos433(X,Y) get_gdat_uint((X),(Y),433) +#define get_gdat_ullong_pos433(X,Y) get_gdat_ullong((X),(Y),433) +#define get_gdat_ip_pos433(X,Y) get_gdat_ip((X),(Y),433) +#define get_gdat_ipv6_pos433(X,Y) get_gdat_ipv6((X),(Y),433) +#define get_gdat_string_pos433(X,Y) get_gdat_string((X),(Y),433) +#define get_gdat_v_str_pos433(X,Y) get_gdat_string((X),(Y),433) +#define get_gdat_bool_pos433(X,Y) get_gdat_bool((X),(Y),433) +#define get_gdat_int_pos433(X,Y) get_gdat_int((X),(Y),433) +#define get_gdat_llong_pos433(X,Y) get_gdat_llong((X),(Y),433) +#define get_gdat_float_pos433(X,Y) get_gdat_float((X),(Y),433) +#define get_gdat_uint_pos434(X,Y) get_gdat_uint((X),(Y),434) +#define get_gdat_ullong_pos434(X,Y) get_gdat_ullong((X),(Y),434) +#define get_gdat_ip_pos434(X,Y) get_gdat_ip((X),(Y),434) +#define get_gdat_ipv6_pos434(X,Y) get_gdat_ipv6((X),(Y),434) +#define get_gdat_string_pos434(X,Y) get_gdat_string((X),(Y),434) +#define get_gdat_v_str_pos434(X,Y) get_gdat_string((X),(Y),434) +#define get_gdat_bool_pos434(X,Y) get_gdat_bool((X),(Y),434) +#define get_gdat_int_pos434(X,Y) get_gdat_int((X),(Y),434) +#define get_gdat_llong_pos434(X,Y) get_gdat_llong((X),(Y),434) +#define get_gdat_float_pos434(X,Y) get_gdat_float((X),(Y),434) +#define get_gdat_uint_pos435(X,Y) get_gdat_uint((X),(Y),435) +#define get_gdat_ullong_pos435(X,Y) get_gdat_ullong((X),(Y),435) +#define get_gdat_ip_pos435(X,Y) get_gdat_ip((X),(Y),435) +#define get_gdat_ipv6_pos435(X,Y) get_gdat_ipv6((X),(Y),435) +#define get_gdat_string_pos435(X,Y) get_gdat_string((X),(Y),435) +#define get_gdat_v_str_pos435(X,Y) get_gdat_string((X),(Y),435) +#define get_gdat_bool_pos435(X,Y) get_gdat_bool((X),(Y),435) +#define get_gdat_int_pos435(X,Y) get_gdat_int((X),(Y),435) +#define get_gdat_llong_pos435(X,Y) get_gdat_llong((X),(Y),435) +#define get_gdat_float_pos435(X,Y) get_gdat_float((X),(Y),435) +#define get_gdat_uint_pos436(X,Y) get_gdat_uint((X),(Y),436) +#define get_gdat_ullong_pos436(X,Y) get_gdat_ullong((X),(Y),436) +#define get_gdat_ip_pos436(X,Y) get_gdat_ip((X),(Y),436) +#define get_gdat_ipv6_pos436(X,Y) get_gdat_ipv6((X),(Y),436) +#define get_gdat_string_pos436(X,Y) get_gdat_string((X),(Y),436) +#define get_gdat_v_str_pos436(X,Y) get_gdat_string((X),(Y),436) +#define get_gdat_bool_pos436(X,Y) get_gdat_bool((X),(Y),436) +#define get_gdat_int_pos436(X,Y) get_gdat_int((X),(Y),436) +#define get_gdat_llong_pos436(X,Y) get_gdat_llong((X),(Y),436) +#define get_gdat_float_pos436(X,Y) get_gdat_float((X),(Y),436) +#define get_gdat_uint_pos437(X,Y) get_gdat_uint((X),(Y),437) +#define get_gdat_ullong_pos437(X,Y) get_gdat_ullong((X),(Y),437) +#define get_gdat_ip_pos437(X,Y) get_gdat_ip((X),(Y),437) +#define get_gdat_ipv6_pos437(X,Y) get_gdat_ipv6((X),(Y),437) +#define get_gdat_string_pos437(X,Y) get_gdat_string((X),(Y),437) +#define get_gdat_v_str_pos437(X,Y) get_gdat_string((X),(Y),437) +#define get_gdat_bool_pos437(X,Y) get_gdat_bool((X),(Y),437) +#define get_gdat_int_pos437(X,Y) get_gdat_int((X),(Y),437) +#define get_gdat_llong_pos437(X,Y) get_gdat_llong((X),(Y),437) +#define get_gdat_float_pos437(X,Y) get_gdat_float((X),(Y),437) +#define get_gdat_uint_pos438(X,Y) get_gdat_uint((X),(Y),438) +#define get_gdat_ullong_pos438(X,Y) get_gdat_ullong((X),(Y),438) +#define get_gdat_ip_pos438(X,Y) get_gdat_ip((X),(Y),438) +#define get_gdat_ipv6_pos438(X,Y) get_gdat_ipv6((X),(Y),438) +#define get_gdat_string_pos438(X,Y) get_gdat_string((X),(Y),438) +#define get_gdat_v_str_pos438(X,Y) get_gdat_string((X),(Y),438) +#define get_gdat_bool_pos438(X,Y) get_gdat_bool((X),(Y),438) +#define get_gdat_int_pos438(X,Y) get_gdat_int((X),(Y),438) +#define get_gdat_llong_pos438(X,Y) get_gdat_llong((X),(Y),438) +#define get_gdat_float_pos438(X,Y) get_gdat_float((X),(Y),438) +#define get_gdat_uint_pos439(X,Y) get_gdat_uint((X),(Y),439) +#define get_gdat_ullong_pos439(X,Y) get_gdat_ullong((X),(Y),439) +#define get_gdat_ip_pos439(X,Y) get_gdat_ip((X),(Y),439) +#define get_gdat_ipv6_pos439(X,Y) get_gdat_ipv6((X),(Y),439) +#define get_gdat_string_pos439(X,Y) get_gdat_string((X),(Y),439) +#define get_gdat_v_str_pos439(X,Y) get_gdat_string((X),(Y),439) +#define get_gdat_bool_pos439(X,Y) get_gdat_bool((X),(Y),439) +#define get_gdat_int_pos439(X,Y) get_gdat_int((X),(Y),439) +#define get_gdat_llong_pos439(X,Y) get_gdat_llong((X),(Y),439) +#define get_gdat_float_pos439(X,Y) get_gdat_float((X),(Y),439) +#define get_gdat_uint_pos440(X,Y) get_gdat_uint((X),(Y),440) +#define get_gdat_ullong_pos440(X,Y) get_gdat_ullong((X),(Y),440) +#define get_gdat_ip_pos440(X,Y) get_gdat_ip((X),(Y),440) +#define get_gdat_ipv6_pos440(X,Y) get_gdat_ipv6((X),(Y),440) +#define get_gdat_string_pos440(X,Y) get_gdat_string((X),(Y),440) +#define get_gdat_v_str_pos440(X,Y) get_gdat_string((X),(Y),440) +#define get_gdat_bool_pos440(X,Y) get_gdat_bool((X),(Y),440) +#define get_gdat_int_pos440(X,Y) get_gdat_int((X),(Y),440) +#define get_gdat_llong_pos440(X,Y) get_gdat_llong((X),(Y),440) +#define get_gdat_float_pos440(X,Y) get_gdat_float((X),(Y),440) +#define get_gdat_uint_pos441(X,Y) get_gdat_uint((X),(Y),441) +#define get_gdat_ullong_pos441(X,Y) get_gdat_ullong((X),(Y),441) +#define get_gdat_ip_pos441(X,Y) get_gdat_ip((X),(Y),441) +#define get_gdat_ipv6_pos441(X,Y) get_gdat_ipv6((X),(Y),441) +#define get_gdat_string_pos441(X,Y) get_gdat_string((X),(Y),441) +#define get_gdat_v_str_pos441(X,Y) get_gdat_string((X),(Y),441) +#define get_gdat_bool_pos441(X,Y) get_gdat_bool((X),(Y),441) +#define get_gdat_int_pos441(X,Y) get_gdat_int((X),(Y),441) +#define get_gdat_llong_pos441(X,Y) get_gdat_llong((X),(Y),441) +#define get_gdat_float_pos441(X,Y) get_gdat_float((X),(Y),441) +#define get_gdat_uint_pos442(X,Y) get_gdat_uint((X),(Y),442) +#define get_gdat_ullong_pos442(X,Y) get_gdat_ullong((X),(Y),442) +#define get_gdat_ip_pos442(X,Y) get_gdat_ip((X),(Y),442) +#define get_gdat_ipv6_pos442(X,Y) get_gdat_ipv6((X),(Y),442) +#define get_gdat_string_pos442(X,Y) get_gdat_string((X),(Y),442) +#define get_gdat_v_str_pos442(X,Y) get_gdat_string((X),(Y),442) +#define get_gdat_bool_pos442(X,Y) get_gdat_bool((X),(Y),442) +#define get_gdat_int_pos442(X,Y) get_gdat_int((X),(Y),442) +#define get_gdat_llong_pos442(X,Y) get_gdat_llong((X),(Y),442) +#define get_gdat_float_pos442(X,Y) get_gdat_float((X),(Y),442) +#define get_gdat_uint_pos443(X,Y) get_gdat_uint((X),(Y),443) +#define get_gdat_ullong_pos443(X,Y) get_gdat_ullong((X),(Y),443) +#define get_gdat_ip_pos443(X,Y) get_gdat_ip((X),(Y),443) +#define get_gdat_ipv6_pos443(X,Y) get_gdat_ipv6((X),(Y),443) +#define get_gdat_string_pos443(X,Y) get_gdat_string((X),(Y),443) +#define get_gdat_v_str_pos443(X,Y) get_gdat_string((X),(Y),443) +#define get_gdat_bool_pos443(X,Y) get_gdat_bool((X),(Y),443) +#define get_gdat_int_pos443(X,Y) get_gdat_int((X),(Y),443) +#define get_gdat_llong_pos443(X,Y) get_gdat_llong((X),(Y),443) +#define get_gdat_float_pos443(X,Y) get_gdat_float((X),(Y),443) +#define get_gdat_uint_pos444(X,Y) get_gdat_uint((X),(Y),444) +#define get_gdat_ullong_pos444(X,Y) get_gdat_ullong((X),(Y),444) +#define get_gdat_ip_pos444(X,Y) get_gdat_ip((X),(Y),444) +#define get_gdat_ipv6_pos444(X,Y) get_gdat_ipv6((X),(Y),444) +#define get_gdat_string_pos444(X,Y) get_gdat_string((X),(Y),444) +#define get_gdat_v_str_pos444(X,Y) get_gdat_string((X),(Y),444) +#define get_gdat_bool_pos444(X,Y) get_gdat_bool((X),(Y),444) +#define get_gdat_int_pos444(X,Y) get_gdat_int((X),(Y),444) +#define get_gdat_llong_pos444(X,Y) get_gdat_llong((X),(Y),444) +#define get_gdat_float_pos444(X,Y) get_gdat_float((X),(Y),444) +#define get_gdat_uint_pos445(X,Y) get_gdat_uint((X),(Y),445) +#define get_gdat_ullong_pos445(X,Y) get_gdat_ullong((X),(Y),445) +#define get_gdat_ip_pos445(X,Y) get_gdat_ip((X),(Y),445) +#define get_gdat_ipv6_pos445(X,Y) get_gdat_ipv6((X),(Y),445) +#define get_gdat_string_pos445(X,Y) get_gdat_string((X),(Y),445) +#define get_gdat_v_str_pos445(X,Y) get_gdat_string((X),(Y),445) +#define get_gdat_bool_pos445(X,Y) get_gdat_bool((X),(Y),445) +#define get_gdat_int_pos445(X,Y) get_gdat_int((X),(Y),445) +#define get_gdat_llong_pos445(X,Y) get_gdat_llong((X),(Y),445) +#define get_gdat_float_pos445(X,Y) get_gdat_float((X),(Y),445) +#define get_gdat_uint_pos446(X,Y) get_gdat_uint((X),(Y),446) +#define get_gdat_ullong_pos446(X,Y) get_gdat_ullong((X),(Y),446) +#define get_gdat_ip_pos446(X,Y) get_gdat_ip((X),(Y),446) +#define get_gdat_ipv6_pos446(X,Y) get_gdat_ipv6((X),(Y),446) +#define get_gdat_string_pos446(X,Y) get_gdat_string((X),(Y),446) +#define get_gdat_v_str_pos446(X,Y) get_gdat_string((X),(Y),446) +#define get_gdat_bool_pos446(X,Y) get_gdat_bool((X),(Y),446) +#define get_gdat_int_pos446(X,Y) get_gdat_int((X),(Y),446) +#define get_gdat_llong_pos446(X,Y) get_gdat_llong((X),(Y),446) +#define get_gdat_float_pos446(X,Y) get_gdat_float((X),(Y),446) +#define get_gdat_uint_pos447(X,Y) get_gdat_uint((X),(Y),447) +#define get_gdat_ullong_pos447(X,Y) get_gdat_ullong((X),(Y),447) +#define get_gdat_ip_pos447(X,Y) get_gdat_ip((X),(Y),447) +#define get_gdat_ipv6_pos447(X,Y) get_gdat_ipv6((X),(Y),447) +#define get_gdat_string_pos447(X,Y) get_gdat_string((X),(Y),447) +#define get_gdat_v_str_pos447(X,Y) get_gdat_string((X),(Y),447) +#define get_gdat_bool_pos447(X,Y) get_gdat_bool((X),(Y),447) +#define get_gdat_int_pos447(X,Y) get_gdat_int((X),(Y),447) +#define get_gdat_llong_pos447(X,Y) get_gdat_llong((X),(Y),447) +#define get_gdat_float_pos447(X,Y) get_gdat_float((X),(Y),447) +#define get_gdat_uint_pos448(X,Y) get_gdat_uint((X),(Y),448) +#define get_gdat_ullong_pos448(X,Y) get_gdat_ullong((X),(Y),448) +#define get_gdat_ip_pos448(X,Y) get_gdat_ip((X),(Y),448) +#define get_gdat_ipv6_pos448(X,Y) get_gdat_ipv6((X),(Y),448) +#define get_gdat_string_pos448(X,Y) get_gdat_string((X),(Y),448) +#define get_gdat_v_str_pos448(X,Y) get_gdat_string((X),(Y),448) +#define get_gdat_bool_pos448(X,Y) get_gdat_bool((X),(Y),448) +#define get_gdat_int_pos448(X,Y) get_gdat_int((X),(Y),448) +#define get_gdat_llong_pos448(X,Y) get_gdat_llong((X),(Y),448) +#define get_gdat_float_pos448(X,Y) get_gdat_float((X),(Y),448) +#define get_gdat_uint_pos449(X,Y) get_gdat_uint((X),(Y),449) +#define get_gdat_ullong_pos449(X,Y) get_gdat_ullong((X),(Y),449) +#define get_gdat_ip_pos449(X,Y) get_gdat_ip((X),(Y),449) +#define get_gdat_ipv6_pos449(X,Y) get_gdat_ipv6((X),(Y),449) +#define get_gdat_string_pos449(X,Y) get_gdat_string((X),(Y),449) +#define get_gdat_v_str_pos449(X,Y) get_gdat_string((X),(Y),449) +#define get_gdat_bool_pos449(X,Y) get_gdat_bool((X),(Y),449) +#define get_gdat_int_pos449(X,Y) get_gdat_int((X),(Y),449) +#define get_gdat_llong_pos449(X,Y) get_gdat_llong((X),(Y),449) +#define get_gdat_float_pos449(X,Y) get_gdat_float((X),(Y),449) +#define get_gdat_uint_pos450(X,Y) get_gdat_uint((X),(Y),450) +#define get_gdat_ullong_pos450(X,Y) get_gdat_ullong((X),(Y),450) +#define get_gdat_ip_pos450(X,Y) get_gdat_ip((X),(Y),450) +#define get_gdat_ipv6_pos450(X,Y) get_gdat_ipv6((X),(Y),450) +#define get_gdat_string_pos450(X,Y) get_gdat_string((X),(Y),450) +#define get_gdat_v_str_pos450(X,Y) get_gdat_string((X),(Y),450) +#define get_gdat_bool_pos450(X,Y) get_gdat_bool((X),(Y),450) +#define get_gdat_int_pos450(X,Y) get_gdat_int((X),(Y),450) +#define get_gdat_llong_pos450(X,Y) get_gdat_llong((X),(Y),450) +#define get_gdat_float_pos450(X,Y) get_gdat_float((X),(Y),450) +#define get_gdat_uint_pos451(X,Y) get_gdat_uint((X),(Y),451) +#define get_gdat_ullong_pos451(X,Y) get_gdat_ullong((X),(Y),451) +#define get_gdat_ip_pos451(X,Y) get_gdat_ip((X),(Y),451) +#define get_gdat_ipv6_pos451(X,Y) get_gdat_ipv6((X),(Y),451) +#define get_gdat_string_pos451(X,Y) get_gdat_string((X),(Y),451) +#define get_gdat_v_str_pos451(X,Y) get_gdat_string((X),(Y),451) +#define get_gdat_bool_pos451(X,Y) get_gdat_bool((X),(Y),451) +#define get_gdat_int_pos451(X,Y) get_gdat_int((X),(Y),451) +#define get_gdat_llong_pos451(X,Y) get_gdat_llong((X),(Y),451) +#define get_gdat_float_pos451(X,Y) get_gdat_float((X),(Y),451) +#define get_gdat_uint_pos452(X,Y) get_gdat_uint((X),(Y),452) +#define get_gdat_ullong_pos452(X,Y) get_gdat_ullong((X),(Y),452) +#define get_gdat_ip_pos452(X,Y) get_gdat_ip((X),(Y),452) +#define get_gdat_ipv6_pos452(X,Y) get_gdat_ipv6((X),(Y),452) +#define get_gdat_string_pos452(X,Y) get_gdat_string((X),(Y),452) +#define get_gdat_v_str_pos452(X,Y) get_gdat_string((X),(Y),452) +#define get_gdat_bool_pos452(X,Y) get_gdat_bool((X),(Y),452) +#define get_gdat_int_pos452(X,Y) get_gdat_int((X),(Y),452) +#define get_gdat_llong_pos452(X,Y) get_gdat_llong((X),(Y),452) +#define get_gdat_float_pos452(X,Y) get_gdat_float((X),(Y),452) +#define get_gdat_uint_pos453(X,Y) get_gdat_uint((X),(Y),453) +#define get_gdat_ullong_pos453(X,Y) get_gdat_ullong((X),(Y),453) +#define get_gdat_ip_pos453(X,Y) get_gdat_ip((X),(Y),453) +#define get_gdat_ipv6_pos453(X,Y) get_gdat_ipv6((X),(Y),453) +#define get_gdat_string_pos453(X,Y) get_gdat_string((X),(Y),453) +#define get_gdat_v_str_pos453(X,Y) get_gdat_string((X),(Y),453) +#define get_gdat_bool_pos453(X,Y) get_gdat_bool((X),(Y),453) +#define get_gdat_int_pos453(X,Y) get_gdat_int((X),(Y),453) +#define get_gdat_llong_pos453(X,Y) get_gdat_llong((X),(Y),453) +#define get_gdat_float_pos453(X,Y) get_gdat_float((X),(Y),453) +#define get_gdat_uint_pos454(X,Y) get_gdat_uint((X),(Y),454) +#define get_gdat_ullong_pos454(X,Y) get_gdat_ullong((X),(Y),454) +#define get_gdat_ip_pos454(X,Y) get_gdat_ip((X),(Y),454) +#define get_gdat_ipv6_pos454(X,Y) get_gdat_ipv6((X),(Y),454) +#define get_gdat_string_pos454(X,Y) get_gdat_string((X),(Y),454) +#define get_gdat_v_str_pos454(X,Y) get_gdat_string((X),(Y),454) +#define get_gdat_bool_pos454(X,Y) get_gdat_bool((X),(Y),454) +#define get_gdat_int_pos454(X,Y) get_gdat_int((X),(Y),454) +#define get_gdat_llong_pos454(X,Y) get_gdat_llong((X),(Y),454) +#define get_gdat_float_pos454(X,Y) get_gdat_float((X),(Y),454) +#define get_gdat_uint_pos455(X,Y) get_gdat_uint((X),(Y),455) +#define get_gdat_ullong_pos455(X,Y) get_gdat_ullong((X),(Y),455) +#define get_gdat_ip_pos455(X,Y) get_gdat_ip((X),(Y),455) +#define get_gdat_ipv6_pos455(X,Y) get_gdat_ipv6((X),(Y),455) +#define get_gdat_string_pos455(X,Y) get_gdat_string((X),(Y),455) +#define get_gdat_v_str_pos455(X,Y) get_gdat_string((X),(Y),455) +#define get_gdat_bool_pos455(X,Y) get_gdat_bool((X),(Y),455) +#define get_gdat_int_pos455(X,Y) get_gdat_int((X),(Y),455) +#define get_gdat_llong_pos455(X,Y) get_gdat_llong((X),(Y),455) +#define get_gdat_float_pos455(X,Y) get_gdat_float((X),(Y),455) +#define get_gdat_uint_pos456(X,Y) get_gdat_uint((X),(Y),456) +#define get_gdat_ullong_pos456(X,Y) get_gdat_ullong((X),(Y),456) +#define get_gdat_ip_pos456(X,Y) get_gdat_ip((X),(Y),456) +#define get_gdat_ipv6_pos456(X,Y) get_gdat_ipv6((X),(Y),456) +#define get_gdat_string_pos456(X,Y) get_gdat_string((X),(Y),456) +#define get_gdat_v_str_pos456(X,Y) get_gdat_string((X),(Y),456) +#define get_gdat_bool_pos456(X,Y) get_gdat_bool((X),(Y),456) +#define get_gdat_int_pos456(X,Y) get_gdat_int((X),(Y),456) +#define get_gdat_llong_pos456(X,Y) get_gdat_llong((X),(Y),456) +#define get_gdat_float_pos456(X,Y) get_gdat_float((X),(Y),456) +#define get_gdat_uint_pos457(X,Y) get_gdat_uint((X),(Y),457) +#define get_gdat_ullong_pos457(X,Y) get_gdat_ullong((X),(Y),457) +#define get_gdat_ip_pos457(X,Y) get_gdat_ip((X),(Y),457) +#define get_gdat_ipv6_pos457(X,Y) get_gdat_ipv6((X),(Y),457) +#define get_gdat_string_pos457(X,Y) get_gdat_string((X),(Y),457) +#define get_gdat_v_str_pos457(X,Y) get_gdat_string((X),(Y),457) +#define get_gdat_bool_pos457(X,Y) get_gdat_bool((X),(Y),457) +#define get_gdat_int_pos457(X,Y) get_gdat_int((X),(Y),457) +#define get_gdat_llong_pos457(X,Y) get_gdat_llong((X),(Y),457) +#define get_gdat_float_pos457(X,Y) get_gdat_float((X),(Y),457) +#define get_gdat_uint_pos458(X,Y) get_gdat_uint((X),(Y),458) +#define get_gdat_ullong_pos458(X,Y) get_gdat_ullong((X),(Y),458) +#define get_gdat_ip_pos458(X,Y) get_gdat_ip((X),(Y),458) +#define get_gdat_ipv6_pos458(X,Y) get_gdat_ipv6((X),(Y),458) +#define get_gdat_string_pos458(X,Y) get_gdat_string((X),(Y),458) +#define get_gdat_v_str_pos458(X,Y) get_gdat_string((X),(Y),458) +#define get_gdat_bool_pos458(X,Y) get_gdat_bool((X),(Y),458) +#define get_gdat_int_pos458(X,Y) get_gdat_int((X),(Y),458) +#define get_gdat_llong_pos458(X,Y) get_gdat_llong((X),(Y),458) +#define get_gdat_float_pos458(X,Y) get_gdat_float((X),(Y),458) +#define get_gdat_uint_pos459(X,Y) get_gdat_uint((X),(Y),459) +#define get_gdat_ullong_pos459(X,Y) get_gdat_ullong((X),(Y),459) +#define get_gdat_ip_pos459(X,Y) get_gdat_ip((X),(Y),459) +#define get_gdat_ipv6_pos459(X,Y) get_gdat_ipv6((X),(Y),459) +#define get_gdat_string_pos459(X,Y) get_gdat_string((X),(Y),459) +#define get_gdat_v_str_pos459(X,Y) get_gdat_string((X),(Y),459) +#define get_gdat_bool_pos459(X,Y) get_gdat_bool((X),(Y),459) +#define get_gdat_int_pos459(X,Y) get_gdat_int((X),(Y),459) +#define get_gdat_llong_pos459(X,Y) get_gdat_llong((X),(Y),459) +#define get_gdat_float_pos459(X,Y) get_gdat_float((X),(Y),459) +#define get_gdat_uint_pos460(X,Y) get_gdat_uint((X),(Y),460) +#define get_gdat_ullong_pos460(X,Y) get_gdat_ullong((X),(Y),460) +#define get_gdat_ip_pos460(X,Y) get_gdat_ip((X),(Y),460) +#define get_gdat_ipv6_pos460(X,Y) get_gdat_ipv6((X),(Y),460) +#define get_gdat_string_pos460(X,Y) get_gdat_string((X),(Y),460) +#define get_gdat_v_str_pos460(X,Y) get_gdat_string((X),(Y),460) +#define get_gdat_bool_pos460(X,Y) get_gdat_bool((X),(Y),460) +#define get_gdat_int_pos460(X,Y) get_gdat_int((X),(Y),460) +#define get_gdat_llong_pos460(X,Y) get_gdat_llong((X),(Y),460) +#define get_gdat_float_pos460(X,Y) get_gdat_float((X),(Y),460) +#define get_gdat_uint_pos461(X,Y) get_gdat_uint((X),(Y),461) +#define get_gdat_ullong_pos461(X,Y) get_gdat_ullong((X),(Y),461) +#define get_gdat_ip_pos461(X,Y) get_gdat_ip((X),(Y),461) +#define get_gdat_ipv6_pos461(X,Y) get_gdat_ipv6((X),(Y),461) +#define get_gdat_string_pos461(X,Y) get_gdat_string((X),(Y),461) +#define get_gdat_v_str_pos461(X,Y) get_gdat_string((X),(Y),461) +#define get_gdat_bool_pos461(X,Y) get_gdat_bool((X),(Y),461) +#define get_gdat_int_pos461(X,Y) get_gdat_int((X),(Y),461) +#define get_gdat_llong_pos461(X,Y) get_gdat_llong((X),(Y),461) +#define get_gdat_float_pos461(X,Y) get_gdat_float((X),(Y),461) +#define get_gdat_uint_pos462(X,Y) get_gdat_uint((X),(Y),462) +#define get_gdat_ullong_pos462(X,Y) get_gdat_ullong((X),(Y),462) +#define get_gdat_ip_pos462(X,Y) get_gdat_ip((X),(Y),462) +#define get_gdat_ipv6_pos462(X,Y) get_gdat_ipv6((X),(Y),462) +#define get_gdat_string_pos462(X,Y) get_gdat_string((X),(Y),462) +#define get_gdat_v_str_pos462(X,Y) get_gdat_string((X),(Y),462) +#define get_gdat_bool_pos462(X,Y) get_gdat_bool((X),(Y),462) +#define get_gdat_int_pos462(X,Y) get_gdat_int((X),(Y),462) +#define get_gdat_llong_pos462(X,Y) get_gdat_llong((X),(Y),462) +#define get_gdat_float_pos462(X,Y) get_gdat_float((X),(Y),462) +#define get_gdat_uint_pos463(X,Y) get_gdat_uint((X),(Y),463) +#define get_gdat_ullong_pos463(X,Y) get_gdat_ullong((X),(Y),463) +#define get_gdat_ip_pos463(X,Y) get_gdat_ip((X),(Y),463) +#define get_gdat_ipv6_pos463(X,Y) get_gdat_ipv6((X),(Y),463) +#define get_gdat_string_pos463(X,Y) get_gdat_string((X),(Y),463) +#define get_gdat_v_str_pos463(X,Y) get_gdat_string((X),(Y),463) +#define get_gdat_bool_pos463(X,Y) get_gdat_bool((X),(Y),463) +#define get_gdat_int_pos463(X,Y) get_gdat_int((X),(Y),463) +#define get_gdat_llong_pos463(X,Y) get_gdat_llong((X),(Y),463) +#define get_gdat_float_pos463(X,Y) get_gdat_float((X),(Y),463) +#define get_gdat_uint_pos464(X,Y) get_gdat_uint((X),(Y),464) +#define get_gdat_ullong_pos464(X,Y) get_gdat_ullong((X),(Y),464) +#define get_gdat_ip_pos464(X,Y) get_gdat_ip((X),(Y),464) +#define get_gdat_ipv6_pos464(X,Y) get_gdat_ipv6((X),(Y),464) +#define get_gdat_string_pos464(X,Y) get_gdat_string((X),(Y),464) +#define get_gdat_v_str_pos464(X,Y) get_gdat_string((X),(Y),464) +#define get_gdat_bool_pos464(X,Y) get_gdat_bool((X),(Y),464) +#define get_gdat_int_pos464(X,Y) get_gdat_int((X),(Y),464) +#define get_gdat_llong_pos464(X,Y) get_gdat_llong((X),(Y),464) +#define get_gdat_float_pos464(X,Y) get_gdat_float((X),(Y),464) +#define get_gdat_uint_pos465(X,Y) get_gdat_uint((X),(Y),465) +#define get_gdat_ullong_pos465(X,Y) get_gdat_ullong((X),(Y),465) +#define get_gdat_ip_pos465(X,Y) get_gdat_ip((X),(Y),465) +#define get_gdat_ipv6_pos465(X,Y) get_gdat_ipv6((X),(Y),465) +#define get_gdat_string_pos465(X,Y) get_gdat_string((X),(Y),465) +#define get_gdat_v_str_pos465(X,Y) get_gdat_string((X),(Y),465) +#define get_gdat_bool_pos465(X,Y) get_gdat_bool((X),(Y),465) +#define get_gdat_int_pos465(X,Y) get_gdat_int((X),(Y),465) +#define get_gdat_llong_pos465(X,Y) get_gdat_llong((X),(Y),465) +#define get_gdat_float_pos465(X,Y) get_gdat_float((X),(Y),465) +#define get_gdat_uint_pos466(X,Y) get_gdat_uint((X),(Y),466) +#define get_gdat_ullong_pos466(X,Y) get_gdat_ullong((X),(Y),466) +#define get_gdat_ip_pos466(X,Y) get_gdat_ip((X),(Y),466) +#define get_gdat_ipv6_pos466(X,Y) get_gdat_ipv6((X),(Y),466) +#define get_gdat_string_pos466(X,Y) get_gdat_string((X),(Y),466) +#define get_gdat_v_str_pos466(X,Y) get_gdat_string((X),(Y),466) +#define get_gdat_bool_pos466(X,Y) get_gdat_bool((X),(Y),466) +#define get_gdat_int_pos466(X,Y) get_gdat_int((X),(Y),466) +#define get_gdat_llong_pos466(X,Y) get_gdat_llong((X),(Y),466) +#define get_gdat_float_pos466(X,Y) get_gdat_float((X),(Y),466) +#define get_gdat_uint_pos467(X,Y) get_gdat_uint((X),(Y),467) +#define get_gdat_ullong_pos467(X,Y) get_gdat_ullong((X),(Y),467) +#define get_gdat_ip_pos467(X,Y) get_gdat_ip((X),(Y),467) +#define get_gdat_ipv6_pos467(X,Y) get_gdat_ipv6((X),(Y),467) +#define get_gdat_string_pos467(X,Y) get_gdat_string((X),(Y),467) +#define get_gdat_v_str_pos467(X,Y) get_gdat_string((X),(Y),467) +#define get_gdat_bool_pos467(X,Y) get_gdat_bool((X),(Y),467) +#define get_gdat_int_pos467(X,Y) get_gdat_int((X),(Y),467) +#define get_gdat_llong_pos467(X,Y) get_gdat_llong((X),(Y),467) +#define get_gdat_float_pos467(X,Y) get_gdat_float((X),(Y),467) +#define get_gdat_uint_pos468(X,Y) get_gdat_uint((X),(Y),468) +#define get_gdat_ullong_pos468(X,Y) get_gdat_ullong((X),(Y),468) +#define get_gdat_ip_pos468(X,Y) get_gdat_ip((X),(Y),468) +#define get_gdat_ipv6_pos468(X,Y) get_gdat_ipv6((X),(Y),468) +#define get_gdat_string_pos468(X,Y) get_gdat_string((X),(Y),468) +#define get_gdat_v_str_pos468(X,Y) get_gdat_string((X),(Y),468) +#define get_gdat_bool_pos468(X,Y) get_gdat_bool((X),(Y),468) +#define get_gdat_int_pos468(X,Y) get_gdat_int((X),(Y),468) +#define get_gdat_llong_pos468(X,Y) get_gdat_llong((X),(Y),468) +#define get_gdat_float_pos468(X,Y) get_gdat_float((X),(Y),468) +#define get_gdat_uint_pos469(X,Y) get_gdat_uint((X),(Y),469) +#define get_gdat_ullong_pos469(X,Y) get_gdat_ullong((X),(Y),469) +#define get_gdat_ip_pos469(X,Y) get_gdat_ip((X),(Y),469) +#define get_gdat_ipv6_pos469(X,Y) get_gdat_ipv6((X),(Y),469) +#define get_gdat_string_pos469(X,Y) get_gdat_string((X),(Y),469) +#define get_gdat_v_str_pos469(X,Y) get_gdat_string((X),(Y),469) +#define get_gdat_bool_pos469(X,Y) get_gdat_bool((X),(Y),469) +#define get_gdat_int_pos469(X,Y) get_gdat_int((X),(Y),469) +#define get_gdat_llong_pos469(X,Y) get_gdat_llong((X),(Y),469) +#define get_gdat_float_pos469(X,Y) get_gdat_float((X),(Y),469) +#define get_gdat_uint_pos470(X,Y) get_gdat_uint((X),(Y),470) +#define get_gdat_ullong_pos470(X,Y) get_gdat_ullong((X),(Y),470) +#define get_gdat_ip_pos470(X,Y) get_gdat_ip((X),(Y),470) +#define get_gdat_ipv6_pos470(X,Y) get_gdat_ipv6((X),(Y),470) +#define get_gdat_string_pos470(X,Y) get_gdat_string((X),(Y),470) +#define get_gdat_v_str_pos470(X,Y) get_gdat_string((X),(Y),470) +#define get_gdat_bool_pos470(X,Y) get_gdat_bool((X),(Y),470) +#define get_gdat_int_pos470(X,Y) get_gdat_int((X),(Y),470) +#define get_gdat_llong_pos470(X,Y) get_gdat_llong((X),(Y),470) +#define get_gdat_float_pos470(X,Y) get_gdat_float((X),(Y),470) +#define get_gdat_uint_pos471(X,Y) get_gdat_uint((X),(Y),471) +#define get_gdat_ullong_pos471(X,Y) get_gdat_ullong((X),(Y),471) +#define get_gdat_ip_pos471(X,Y) get_gdat_ip((X),(Y),471) +#define get_gdat_ipv6_pos471(X,Y) get_gdat_ipv6((X),(Y),471) +#define get_gdat_string_pos471(X,Y) get_gdat_string((X),(Y),471) +#define get_gdat_v_str_pos471(X,Y) get_gdat_string((X),(Y),471) +#define get_gdat_bool_pos471(X,Y) get_gdat_bool((X),(Y),471) +#define get_gdat_int_pos471(X,Y) get_gdat_int((X),(Y),471) +#define get_gdat_llong_pos471(X,Y) get_gdat_llong((X),(Y),471) +#define get_gdat_float_pos471(X,Y) get_gdat_float((X),(Y),471) +#define get_gdat_uint_pos472(X,Y) get_gdat_uint((X),(Y),472) +#define get_gdat_ullong_pos472(X,Y) get_gdat_ullong((X),(Y),472) +#define get_gdat_ip_pos472(X,Y) get_gdat_ip((X),(Y),472) +#define get_gdat_ipv6_pos472(X,Y) get_gdat_ipv6((X),(Y),472) +#define get_gdat_string_pos472(X,Y) get_gdat_string((X),(Y),472) +#define get_gdat_v_str_pos472(X,Y) get_gdat_string((X),(Y),472) +#define get_gdat_bool_pos472(X,Y) get_gdat_bool((X),(Y),472) +#define get_gdat_int_pos472(X,Y) get_gdat_int((X),(Y),472) +#define get_gdat_llong_pos472(X,Y) get_gdat_llong((X),(Y),472) +#define get_gdat_float_pos472(X,Y) get_gdat_float((X),(Y),472) +#define get_gdat_uint_pos473(X,Y) get_gdat_uint((X),(Y),473) +#define get_gdat_ullong_pos473(X,Y) get_gdat_ullong((X),(Y),473) +#define get_gdat_ip_pos473(X,Y) get_gdat_ip((X),(Y),473) +#define get_gdat_ipv6_pos473(X,Y) get_gdat_ipv6((X),(Y),473) +#define get_gdat_string_pos473(X,Y) get_gdat_string((X),(Y),473) +#define get_gdat_v_str_pos473(X,Y) get_gdat_string((X),(Y),473) +#define get_gdat_bool_pos473(X,Y) get_gdat_bool((X),(Y),473) +#define get_gdat_int_pos473(X,Y) get_gdat_int((X),(Y),473) +#define get_gdat_llong_pos473(X,Y) get_gdat_llong((X),(Y),473) +#define get_gdat_float_pos473(X,Y) get_gdat_float((X),(Y),473) +#define get_gdat_uint_pos474(X,Y) get_gdat_uint((X),(Y),474) +#define get_gdat_ullong_pos474(X,Y) get_gdat_ullong((X),(Y),474) +#define get_gdat_ip_pos474(X,Y) get_gdat_ip((X),(Y),474) +#define get_gdat_ipv6_pos474(X,Y) get_gdat_ipv6((X),(Y),474) +#define get_gdat_string_pos474(X,Y) get_gdat_string((X),(Y),474) +#define get_gdat_v_str_pos474(X,Y) get_gdat_string((X),(Y),474) +#define get_gdat_bool_pos474(X,Y) get_gdat_bool((X),(Y),474) +#define get_gdat_int_pos474(X,Y) get_gdat_int((X),(Y),474) +#define get_gdat_llong_pos474(X,Y) get_gdat_llong((X),(Y),474) +#define get_gdat_float_pos474(X,Y) get_gdat_float((X),(Y),474) +#define get_gdat_uint_pos475(X,Y) get_gdat_uint((X),(Y),475) +#define get_gdat_ullong_pos475(X,Y) get_gdat_ullong((X),(Y),475) +#define get_gdat_ip_pos475(X,Y) get_gdat_ip((X),(Y),475) +#define get_gdat_ipv6_pos475(X,Y) get_gdat_ipv6((X),(Y),475) +#define get_gdat_string_pos475(X,Y) get_gdat_string((X),(Y),475) +#define get_gdat_v_str_pos475(X,Y) get_gdat_string((X),(Y),475) +#define get_gdat_bool_pos475(X,Y) get_gdat_bool((X),(Y),475) +#define get_gdat_int_pos475(X,Y) get_gdat_int((X),(Y),475) +#define get_gdat_llong_pos475(X,Y) get_gdat_llong((X),(Y),475) +#define get_gdat_float_pos475(X,Y) get_gdat_float((X),(Y),475) +#define get_gdat_uint_pos476(X,Y) get_gdat_uint((X),(Y),476) +#define get_gdat_ullong_pos476(X,Y) get_gdat_ullong((X),(Y),476) +#define get_gdat_ip_pos476(X,Y) get_gdat_ip((X),(Y),476) +#define get_gdat_ipv6_pos476(X,Y) get_gdat_ipv6((X),(Y),476) +#define get_gdat_string_pos476(X,Y) get_gdat_string((X),(Y),476) +#define get_gdat_v_str_pos476(X,Y) get_gdat_string((X),(Y),476) +#define get_gdat_bool_pos476(X,Y) get_gdat_bool((X),(Y),476) +#define get_gdat_int_pos476(X,Y) get_gdat_int((X),(Y),476) +#define get_gdat_llong_pos476(X,Y) get_gdat_llong((X),(Y),476) +#define get_gdat_float_pos476(X,Y) get_gdat_float((X),(Y),476) +#define get_gdat_uint_pos477(X,Y) get_gdat_uint((X),(Y),477) +#define get_gdat_ullong_pos477(X,Y) get_gdat_ullong((X),(Y),477) +#define get_gdat_ip_pos477(X,Y) get_gdat_ip((X),(Y),477) +#define get_gdat_ipv6_pos477(X,Y) get_gdat_ipv6((X),(Y),477) +#define get_gdat_string_pos477(X,Y) get_gdat_string((X),(Y),477) +#define get_gdat_v_str_pos477(X,Y) get_gdat_string((X),(Y),477) +#define get_gdat_bool_pos477(X,Y) get_gdat_bool((X),(Y),477) +#define get_gdat_int_pos477(X,Y) get_gdat_int((X),(Y),477) +#define get_gdat_llong_pos477(X,Y) get_gdat_llong((X),(Y),477) +#define get_gdat_float_pos477(X,Y) get_gdat_float((X),(Y),477) +#define get_gdat_uint_pos478(X,Y) get_gdat_uint((X),(Y),478) +#define get_gdat_ullong_pos478(X,Y) get_gdat_ullong((X),(Y),478) +#define get_gdat_ip_pos478(X,Y) get_gdat_ip((X),(Y),478) +#define get_gdat_ipv6_pos478(X,Y) get_gdat_ipv6((X),(Y),478) +#define get_gdat_string_pos478(X,Y) get_gdat_string((X),(Y),478) +#define get_gdat_v_str_pos478(X,Y) get_gdat_string((X),(Y),478) +#define get_gdat_bool_pos478(X,Y) get_gdat_bool((X),(Y),478) +#define get_gdat_int_pos478(X,Y) get_gdat_int((X),(Y),478) +#define get_gdat_llong_pos478(X,Y) get_gdat_llong((X),(Y),478) +#define get_gdat_float_pos478(X,Y) get_gdat_float((X),(Y),478) +#define get_gdat_uint_pos479(X,Y) get_gdat_uint((X),(Y),479) +#define get_gdat_ullong_pos479(X,Y) get_gdat_ullong((X),(Y),479) +#define get_gdat_ip_pos479(X,Y) get_gdat_ip((X),(Y),479) +#define get_gdat_ipv6_pos479(X,Y) get_gdat_ipv6((X),(Y),479) +#define get_gdat_string_pos479(X,Y) get_gdat_string((X),(Y),479) +#define get_gdat_v_str_pos479(X,Y) get_gdat_string((X),(Y),479) +#define get_gdat_bool_pos479(X,Y) get_gdat_bool((X),(Y),479) +#define get_gdat_int_pos479(X,Y) get_gdat_int((X),(Y),479) +#define get_gdat_llong_pos479(X,Y) get_gdat_llong((X),(Y),479) +#define get_gdat_float_pos479(X,Y) get_gdat_float((X),(Y),479) +#define get_gdat_uint_pos480(X,Y) get_gdat_uint((X),(Y),480) +#define get_gdat_ullong_pos480(X,Y) get_gdat_ullong((X),(Y),480) +#define get_gdat_ip_pos480(X,Y) get_gdat_ip((X),(Y),480) +#define get_gdat_ipv6_pos480(X,Y) get_gdat_ipv6((X),(Y),480) +#define get_gdat_string_pos480(X,Y) get_gdat_string((X),(Y),480) +#define get_gdat_v_str_pos480(X,Y) get_gdat_string((X),(Y),480) +#define get_gdat_bool_pos480(X,Y) get_gdat_bool((X),(Y),480) +#define get_gdat_int_pos480(X,Y) get_gdat_int((X),(Y),480) +#define get_gdat_llong_pos480(X,Y) get_gdat_llong((X),(Y),480) +#define get_gdat_float_pos480(X,Y) get_gdat_float((X),(Y),480) +#define get_gdat_uint_pos481(X,Y) get_gdat_uint((X),(Y),481) +#define get_gdat_ullong_pos481(X,Y) get_gdat_ullong((X),(Y),481) +#define get_gdat_ip_pos481(X,Y) get_gdat_ip((X),(Y),481) +#define get_gdat_ipv6_pos481(X,Y) get_gdat_ipv6((X),(Y),481) +#define get_gdat_string_pos481(X,Y) get_gdat_string((X),(Y),481) +#define get_gdat_v_str_pos481(X,Y) get_gdat_string((X),(Y),481) +#define get_gdat_bool_pos481(X,Y) get_gdat_bool((X),(Y),481) +#define get_gdat_int_pos481(X,Y) get_gdat_int((X),(Y),481) +#define get_gdat_llong_pos481(X,Y) get_gdat_llong((X),(Y),481) +#define get_gdat_float_pos481(X,Y) get_gdat_float((X),(Y),481) +#define get_gdat_uint_pos482(X,Y) get_gdat_uint((X),(Y),482) +#define get_gdat_ullong_pos482(X,Y) get_gdat_ullong((X),(Y),482) +#define get_gdat_ip_pos482(X,Y) get_gdat_ip((X),(Y),482) +#define get_gdat_ipv6_pos482(X,Y) get_gdat_ipv6((X),(Y),482) +#define get_gdat_string_pos482(X,Y) get_gdat_string((X),(Y),482) +#define get_gdat_v_str_pos482(X,Y) get_gdat_string((X),(Y),482) +#define get_gdat_bool_pos482(X,Y) get_gdat_bool((X),(Y),482) +#define get_gdat_int_pos482(X,Y) get_gdat_int((X),(Y),482) +#define get_gdat_llong_pos482(X,Y) get_gdat_llong((X),(Y),482) +#define get_gdat_float_pos482(X,Y) get_gdat_float((X),(Y),482) +#define get_gdat_uint_pos483(X,Y) get_gdat_uint((X),(Y),483) +#define get_gdat_ullong_pos483(X,Y) get_gdat_ullong((X),(Y),483) +#define get_gdat_ip_pos483(X,Y) get_gdat_ip((X),(Y),483) +#define get_gdat_ipv6_pos483(X,Y) get_gdat_ipv6((X),(Y),483) +#define get_gdat_string_pos483(X,Y) get_gdat_string((X),(Y),483) +#define get_gdat_v_str_pos483(X,Y) get_gdat_string((X),(Y),483) +#define get_gdat_bool_pos483(X,Y) get_gdat_bool((X),(Y),483) +#define get_gdat_int_pos483(X,Y) get_gdat_int((X),(Y),483) +#define get_gdat_llong_pos483(X,Y) get_gdat_llong((X),(Y),483) +#define get_gdat_float_pos483(X,Y) get_gdat_float((X),(Y),483) +#define get_gdat_uint_pos484(X,Y) get_gdat_uint((X),(Y),484) +#define get_gdat_ullong_pos484(X,Y) get_gdat_ullong((X),(Y),484) +#define get_gdat_ip_pos484(X,Y) get_gdat_ip((X),(Y),484) +#define get_gdat_ipv6_pos484(X,Y) get_gdat_ipv6((X),(Y),484) +#define get_gdat_string_pos484(X,Y) get_gdat_string((X),(Y),484) +#define get_gdat_v_str_pos484(X,Y) get_gdat_string((X),(Y),484) +#define get_gdat_bool_pos484(X,Y) get_gdat_bool((X),(Y),484) +#define get_gdat_int_pos484(X,Y) get_gdat_int((X),(Y),484) +#define get_gdat_llong_pos484(X,Y) get_gdat_llong((X),(Y),484) +#define get_gdat_float_pos484(X,Y) get_gdat_float((X),(Y),484) +#define get_gdat_uint_pos485(X,Y) get_gdat_uint((X),(Y),485) +#define get_gdat_ullong_pos485(X,Y) get_gdat_ullong((X),(Y),485) +#define get_gdat_ip_pos485(X,Y) get_gdat_ip((X),(Y),485) +#define get_gdat_ipv6_pos485(X,Y) get_gdat_ipv6((X),(Y),485) +#define get_gdat_string_pos485(X,Y) get_gdat_string((X),(Y),485) +#define get_gdat_v_str_pos485(X,Y) get_gdat_string((X),(Y),485) +#define get_gdat_bool_pos485(X,Y) get_gdat_bool((X),(Y),485) +#define get_gdat_int_pos485(X,Y) get_gdat_int((X),(Y),485) +#define get_gdat_llong_pos485(X,Y) get_gdat_llong((X),(Y),485) +#define get_gdat_float_pos485(X,Y) get_gdat_float((X),(Y),485) +#define get_gdat_uint_pos486(X,Y) get_gdat_uint((X),(Y),486) +#define get_gdat_ullong_pos486(X,Y) get_gdat_ullong((X),(Y),486) +#define get_gdat_ip_pos486(X,Y) get_gdat_ip((X),(Y),486) +#define get_gdat_ipv6_pos486(X,Y) get_gdat_ipv6((X),(Y),486) +#define get_gdat_string_pos486(X,Y) get_gdat_string((X),(Y),486) +#define get_gdat_v_str_pos486(X,Y) get_gdat_string((X),(Y),486) +#define get_gdat_bool_pos486(X,Y) get_gdat_bool((X),(Y),486) +#define get_gdat_int_pos486(X,Y) get_gdat_int((X),(Y),486) +#define get_gdat_llong_pos486(X,Y) get_gdat_llong((X),(Y),486) +#define get_gdat_float_pos486(X,Y) get_gdat_float((X),(Y),486) +#define get_gdat_uint_pos487(X,Y) get_gdat_uint((X),(Y),487) +#define get_gdat_ullong_pos487(X,Y) get_gdat_ullong((X),(Y),487) +#define get_gdat_ip_pos487(X,Y) get_gdat_ip((X),(Y),487) +#define get_gdat_ipv6_pos487(X,Y) get_gdat_ipv6((X),(Y),487) +#define get_gdat_string_pos487(X,Y) get_gdat_string((X),(Y),487) +#define get_gdat_v_str_pos487(X,Y) get_gdat_string((X),(Y),487) +#define get_gdat_bool_pos487(X,Y) get_gdat_bool((X),(Y),487) +#define get_gdat_int_pos487(X,Y) get_gdat_int((X),(Y),487) +#define get_gdat_llong_pos487(X,Y) get_gdat_llong((X),(Y),487) +#define get_gdat_float_pos487(X,Y) get_gdat_float((X),(Y),487) +#define get_gdat_uint_pos488(X,Y) get_gdat_uint((X),(Y),488) +#define get_gdat_ullong_pos488(X,Y) get_gdat_ullong((X),(Y),488) +#define get_gdat_ip_pos488(X,Y) get_gdat_ip((X),(Y),488) +#define get_gdat_ipv6_pos488(X,Y) get_gdat_ipv6((X),(Y),488) +#define get_gdat_string_pos488(X,Y) get_gdat_string((X),(Y),488) +#define get_gdat_v_str_pos488(X,Y) get_gdat_string((X),(Y),488) +#define get_gdat_bool_pos488(X,Y) get_gdat_bool((X),(Y),488) +#define get_gdat_int_pos488(X,Y) get_gdat_int((X),(Y),488) +#define get_gdat_llong_pos488(X,Y) get_gdat_llong((X),(Y),488) +#define get_gdat_float_pos488(X,Y) get_gdat_float((X),(Y),488) +#define get_gdat_uint_pos489(X,Y) get_gdat_uint((X),(Y),489) +#define get_gdat_ullong_pos489(X,Y) get_gdat_ullong((X),(Y),489) +#define get_gdat_ip_pos489(X,Y) get_gdat_ip((X),(Y),489) +#define get_gdat_ipv6_pos489(X,Y) get_gdat_ipv6((X),(Y),489) +#define get_gdat_string_pos489(X,Y) get_gdat_string((X),(Y),489) +#define get_gdat_v_str_pos489(X,Y) get_gdat_string((X),(Y),489) +#define get_gdat_bool_pos489(X,Y) get_gdat_bool((X),(Y),489) +#define get_gdat_int_pos489(X,Y) get_gdat_int((X),(Y),489) +#define get_gdat_llong_pos489(X,Y) get_gdat_llong((X),(Y),489) +#define get_gdat_float_pos489(X,Y) get_gdat_float((X),(Y),489) +#define get_gdat_uint_pos490(X,Y) get_gdat_uint((X),(Y),490) +#define get_gdat_ullong_pos490(X,Y) get_gdat_ullong((X),(Y),490) +#define get_gdat_ip_pos490(X,Y) get_gdat_ip((X),(Y),490) +#define get_gdat_ipv6_pos490(X,Y) get_gdat_ipv6((X),(Y),490) +#define get_gdat_string_pos490(X,Y) get_gdat_string((X),(Y),490) +#define get_gdat_v_str_pos490(X,Y) get_gdat_string((X),(Y),490) +#define get_gdat_bool_pos490(X,Y) get_gdat_bool((X),(Y),490) +#define get_gdat_int_pos490(X,Y) get_gdat_int((X),(Y),490) +#define get_gdat_llong_pos490(X,Y) get_gdat_llong((X),(Y),490) +#define get_gdat_float_pos490(X,Y) get_gdat_float((X),(Y),490) +#define get_gdat_uint_pos491(X,Y) get_gdat_uint((X),(Y),491) +#define get_gdat_ullong_pos491(X,Y) get_gdat_ullong((X),(Y),491) +#define get_gdat_ip_pos491(X,Y) get_gdat_ip((X),(Y),491) +#define get_gdat_ipv6_pos491(X,Y) get_gdat_ipv6((X),(Y),491) +#define get_gdat_string_pos491(X,Y) get_gdat_string((X),(Y),491) +#define get_gdat_v_str_pos491(X,Y) get_gdat_string((X),(Y),491) +#define get_gdat_bool_pos491(X,Y) get_gdat_bool((X),(Y),491) +#define get_gdat_int_pos491(X,Y) get_gdat_int((X),(Y),491) +#define get_gdat_llong_pos491(X,Y) get_gdat_llong((X),(Y),491) +#define get_gdat_float_pos491(X,Y) get_gdat_float((X),(Y),491) +#define get_gdat_uint_pos492(X,Y) get_gdat_uint((X),(Y),492) +#define get_gdat_ullong_pos492(X,Y) get_gdat_ullong((X),(Y),492) +#define get_gdat_ip_pos492(X,Y) get_gdat_ip((X),(Y),492) +#define get_gdat_ipv6_pos492(X,Y) get_gdat_ipv6((X),(Y),492) +#define get_gdat_string_pos492(X,Y) get_gdat_string((X),(Y),492) +#define get_gdat_v_str_pos492(X,Y) get_gdat_string((X),(Y),492) +#define get_gdat_bool_pos492(X,Y) get_gdat_bool((X),(Y),492) +#define get_gdat_int_pos492(X,Y) get_gdat_int((X),(Y),492) +#define get_gdat_llong_pos492(X,Y) get_gdat_llong((X),(Y),492) +#define get_gdat_float_pos492(X,Y) get_gdat_float((X),(Y),492) +#define get_gdat_uint_pos493(X,Y) get_gdat_uint((X),(Y),493) +#define get_gdat_ullong_pos493(X,Y) get_gdat_ullong((X),(Y),493) +#define get_gdat_ip_pos493(X,Y) get_gdat_ip((X),(Y),493) +#define get_gdat_ipv6_pos493(X,Y) get_gdat_ipv6((X),(Y),493) +#define get_gdat_string_pos493(X,Y) get_gdat_string((X),(Y),493) +#define get_gdat_v_str_pos493(X,Y) get_gdat_string((X),(Y),493) +#define get_gdat_bool_pos493(X,Y) get_gdat_bool((X),(Y),493) +#define get_gdat_int_pos493(X,Y) get_gdat_int((X),(Y),493) +#define get_gdat_llong_pos493(X,Y) get_gdat_llong((X),(Y),493) +#define get_gdat_float_pos493(X,Y) get_gdat_float((X),(Y),493) +#define get_gdat_uint_pos494(X,Y) get_gdat_uint((X),(Y),494) +#define get_gdat_ullong_pos494(X,Y) get_gdat_ullong((X),(Y),494) +#define get_gdat_ip_pos494(X,Y) get_gdat_ip((X),(Y),494) +#define get_gdat_ipv6_pos494(X,Y) get_gdat_ipv6((X),(Y),494) +#define get_gdat_string_pos494(X,Y) get_gdat_string((X),(Y),494) +#define get_gdat_v_str_pos494(X,Y) get_gdat_string((X),(Y),494) +#define get_gdat_bool_pos494(X,Y) get_gdat_bool((X),(Y),494) +#define get_gdat_int_pos494(X,Y) get_gdat_int((X),(Y),494) +#define get_gdat_llong_pos494(X,Y) get_gdat_llong((X),(Y),494) +#define get_gdat_float_pos494(X,Y) get_gdat_float((X),(Y),494) +#define get_gdat_uint_pos495(X,Y) get_gdat_uint((X),(Y),495) +#define get_gdat_ullong_pos495(X,Y) get_gdat_ullong((X),(Y),495) +#define get_gdat_ip_pos495(X,Y) get_gdat_ip((X),(Y),495) +#define get_gdat_ipv6_pos495(X,Y) get_gdat_ipv6((X),(Y),495) +#define get_gdat_string_pos495(X,Y) get_gdat_string((X),(Y),495) +#define get_gdat_v_str_pos495(X,Y) get_gdat_string((X),(Y),495) +#define get_gdat_bool_pos495(X,Y) get_gdat_bool((X),(Y),495) +#define get_gdat_int_pos495(X,Y) get_gdat_int((X),(Y),495) +#define get_gdat_llong_pos495(X,Y) get_gdat_llong((X),(Y),495) +#define get_gdat_float_pos495(X,Y) get_gdat_float((X),(Y),495) +#define get_gdat_uint_pos496(X,Y) get_gdat_uint((X),(Y),496) +#define get_gdat_ullong_pos496(X,Y) get_gdat_ullong((X),(Y),496) +#define get_gdat_ip_pos496(X,Y) get_gdat_ip((X),(Y),496) +#define get_gdat_ipv6_pos496(X,Y) get_gdat_ipv6((X),(Y),496) +#define get_gdat_string_pos496(X,Y) get_gdat_string((X),(Y),496) +#define get_gdat_v_str_pos496(X,Y) get_gdat_string((X),(Y),496) +#define get_gdat_bool_pos496(X,Y) get_gdat_bool((X),(Y),496) +#define get_gdat_int_pos496(X,Y) get_gdat_int((X),(Y),496) +#define get_gdat_llong_pos496(X,Y) get_gdat_llong((X),(Y),496) +#define get_gdat_float_pos496(X,Y) get_gdat_float((X),(Y),496) +#define get_gdat_uint_pos497(X,Y) get_gdat_uint((X),(Y),497) +#define get_gdat_ullong_pos497(X,Y) get_gdat_ullong((X),(Y),497) +#define get_gdat_ip_pos497(X,Y) get_gdat_ip((X),(Y),497) +#define get_gdat_ipv6_pos497(X,Y) get_gdat_ipv6((X),(Y),497) +#define get_gdat_string_pos497(X,Y) get_gdat_string((X),(Y),497) +#define get_gdat_v_str_pos497(X,Y) get_gdat_string((X),(Y),497) +#define get_gdat_bool_pos497(X,Y) get_gdat_bool((X),(Y),497) +#define get_gdat_int_pos497(X,Y) get_gdat_int((X),(Y),497) +#define get_gdat_llong_pos497(X,Y) get_gdat_llong((X),(Y),497) +#define get_gdat_float_pos497(X,Y) get_gdat_float((X),(Y),497) +#define get_gdat_uint_pos498(X,Y) get_gdat_uint((X),(Y),498) +#define get_gdat_ullong_pos498(X,Y) get_gdat_ullong((X),(Y),498) +#define get_gdat_ip_pos498(X,Y) get_gdat_ip((X),(Y),498) +#define get_gdat_ipv6_pos498(X,Y) get_gdat_ipv6((X),(Y),498) +#define get_gdat_string_pos498(X,Y) get_gdat_string((X),(Y),498) +#define get_gdat_v_str_pos498(X,Y) get_gdat_string((X),(Y),498) +#define get_gdat_bool_pos498(X,Y) get_gdat_bool((X),(Y),498) +#define get_gdat_int_pos498(X,Y) get_gdat_int((X),(Y),498) +#define get_gdat_llong_pos498(X,Y) get_gdat_llong((X),(Y),498) +#define get_gdat_float_pos498(X,Y) get_gdat_float((X),(Y),498) +#define get_gdat_uint_pos499(X,Y) get_gdat_uint((X),(Y),499) +#define get_gdat_ullong_pos499(X,Y) get_gdat_ullong((X),(Y),499) +#define get_gdat_ip_pos499(X,Y) get_gdat_ip((X),(Y),499) +#define get_gdat_ipv6_pos499(X,Y) get_gdat_ipv6((X),(Y),499) +#define get_gdat_string_pos499(X,Y) get_gdat_string((X),(Y),499) +#define get_gdat_v_str_pos499(X,Y) get_gdat_string((X),(Y),499) +#define get_gdat_bool_pos499(X,Y) get_gdat_bool((X),(Y),499) +#define get_gdat_int_pos499(X,Y) get_gdat_int((X),(Y),499) +#define get_gdat_llong_pos499(X,Y) get_gdat_llong((X),(Y),499) +#define get_gdat_float_pos499(X,Y) get_gdat_float((X),(Y),499) +#define get_gdat_uint_pos500(X,Y) get_gdat_uint((X),(Y),500) +#define get_gdat_ullong_pos500(X,Y) get_gdat_ullong((X),(Y),500) +#define get_gdat_ip_pos500(X,Y) get_gdat_ip((X),(Y),500) +#define get_gdat_ipv6_pos500(X,Y) get_gdat_ipv6((X),(Y),500) +#define get_gdat_string_pos500(X,Y) get_gdat_string((X),(Y),500) +#define get_gdat_v_str_pos500(X,Y) get_gdat_string((X),(Y),500) +#define get_gdat_bool_pos500(X,Y) get_gdat_bool((X),(Y),500) +#define get_gdat_int_pos500(X,Y) get_gdat_int((X),(Y),500) +#define get_gdat_llong_pos500(X,Y) get_gdat_llong((X),(Y),500) +#define get_gdat_float_pos500(X,Y) get_gdat_float((X),(Y),500) +#define get_gdat_uint_pos501(X,Y) get_gdat_uint((X),(Y),501) +#define get_gdat_ullong_pos501(X,Y) get_gdat_ullong((X),(Y),501) +#define get_gdat_ip_pos501(X,Y) get_gdat_ip((X),(Y),501) +#define get_gdat_ipv6_pos501(X,Y) get_gdat_ipv6((X),(Y),501) +#define get_gdat_string_pos501(X,Y) get_gdat_string((X),(Y),501) +#define get_gdat_v_str_pos501(X,Y) get_gdat_string((X),(Y),501) +#define get_gdat_bool_pos501(X,Y) get_gdat_bool((X),(Y),501) +#define get_gdat_int_pos501(X,Y) get_gdat_int((X),(Y),501) +#define get_gdat_llong_pos501(X,Y) get_gdat_llong((X),(Y),501) +#define get_gdat_float_pos501(X,Y) get_gdat_float((X),(Y),501) +#define get_gdat_uint_pos502(X,Y) get_gdat_uint((X),(Y),502) +#define get_gdat_ullong_pos502(X,Y) get_gdat_ullong((X),(Y),502) +#define get_gdat_ip_pos502(X,Y) get_gdat_ip((X),(Y),502) +#define get_gdat_ipv6_pos502(X,Y) get_gdat_ipv6((X),(Y),502) +#define get_gdat_string_pos502(X,Y) get_gdat_string((X),(Y),502) +#define get_gdat_v_str_pos502(X,Y) get_gdat_string((X),(Y),502) +#define get_gdat_bool_pos502(X,Y) get_gdat_bool((X),(Y),502) +#define get_gdat_int_pos502(X,Y) get_gdat_int((X),(Y),502) +#define get_gdat_llong_pos502(X,Y) get_gdat_llong((X),(Y),502) +#define get_gdat_float_pos502(X,Y) get_gdat_float((X),(Y),502) +#define get_gdat_uint_pos503(X,Y) get_gdat_uint((X),(Y),503) +#define get_gdat_ullong_pos503(X,Y) get_gdat_ullong((X),(Y),503) +#define get_gdat_ip_pos503(X,Y) get_gdat_ip((X),(Y),503) +#define get_gdat_ipv6_pos503(X,Y) get_gdat_ipv6((X),(Y),503) +#define get_gdat_string_pos503(X,Y) get_gdat_string((X),(Y),503) +#define get_gdat_v_str_pos503(X,Y) get_gdat_string((X),(Y),503) +#define get_gdat_bool_pos503(X,Y) get_gdat_bool((X),(Y),503) +#define get_gdat_int_pos503(X,Y) get_gdat_int((X),(Y),503) +#define get_gdat_llong_pos503(X,Y) get_gdat_llong((X),(Y),503) +#define get_gdat_float_pos503(X,Y) get_gdat_float((X),(Y),503) +#define get_gdat_uint_pos504(X,Y) get_gdat_uint((X),(Y),504) +#define get_gdat_ullong_pos504(X,Y) get_gdat_ullong((X),(Y),504) +#define get_gdat_ip_pos504(X,Y) get_gdat_ip((X),(Y),504) +#define get_gdat_ipv6_pos504(X,Y) get_gdat_ipv6((X),(Y),504) +#define get_gdat_string_pos504(X,Y) get_gdat_string((X),(Y),504) +#define get_gdat_v_str_pos504(X,Y) get_gdat_string((X),(Y),504) +#define get_gdat_bool_pos504(X,Y) get_gdat_bool((X),(Y),504) +#define get_gdat_int_pos504(X,Y) get_gdat_int((X),(Y),504) +#define get_gdat_llong_pos504(X,Y) get_gdat_llong((X),(Y),504) +#define get_gdat_float_pos504(X,Y) get_gdat_float((X),(Y),504) +#define get_gdat_uint_pos505(X,Y) get_gdat_uint((X),(Y),505) +#define get_gdat_ullong_pos505(X,Y) get_gdat_ullong((X),(Y),505) +#define get_gdat_ip_pos505(X,Y) get_gdat_ip((X),(Y),505) +#define get_gdat_ipv6_pos505(X,Y) get_gdat_ipv6((X),(Y),505) +#define get_gdat_string_pos505(X,Y) get_gdat_string((X),(Y),505) +#define get_gdat_v_str_pos505(X,Y) get_gdat_string((X),(Y),505) +#define get_gdat_bool_pos505(X,Y) get_gdat_bool((X),(Y),505) +#define get_gdat_int_pos505(X,Y) get_gdat_int((X),(Y),505) +#define get_gdat_llong_pos505(X,Y) get_gdat_llong((X),(Y),505) +#define get_gdat_float_pos505(X,Y) get_gdat_float((X),(Y),505) +#define get_gdat_uint_pos506(X,Y) get_gdat_uint((X),(Y),506) +#define get_gdat_ullong_pos506(X,Y) get_gdat_ullong((X),(Y),506) +#define get_gdat_ip_pos506(X,Y) get_gdat_ip((X),(Y),506) +#define get_gdat_ipv6_pos506(X,Y) get_gdat_ipv6((X),(Y),506) +#define get_gdat_string_pos506(X,Y) get_gdat_string((X),(Y),506) +#define get_gdat_v_str_pos506(X,Y) get_gdat_string((X),(Y),506) +#define get_gdat_bool_pos506(X,Y) get_gdat_bool((X),(Y),506) +#define get_gdat_int_pos506(X,Y) get_gdat_int((X),(Y),506) +#define get_gdat_llong_pos506(X,Y) get_gdat_llong((X),(Y),506) +#define get_gdat_float_pos506(X,Y) get_gdat_float((X),(Y),506) +#define get_gdat_uint_pos507(X,Y) get_gdat_uint((X),(Y),507) +#define get_gdat_ullong_pos507(X,Y) get_gdat_ullong((X),(Y),507) +#define get_gdat_ip_pos507(X,Y) get_gdat_ip((X),(Y),507) +#define get_gdat_ipv6_pos507(X,Y) get_gdat_ipv6((X),(Y),507) +#define get_gdat_string_pos507(X,Y) get_gdat_string((X),(Y),507) +#define get_gdat_v_str_pos507(X,Y) get_gdat_string((X),(Y),507) +#define get_gdat_bool_pos507(X,Y) get_gdat_bool((X),(Y),507) +#define get_gdat_int_pos507(X,Y) get_gdat_int((X),(Y),507) +#define get_gdat_llong_pos507(X,Y) get_gdat_llong((X),(Y),507) +#define get_gdat_float_pos507(X,Y) get_gdat_float((X),(Y),507) +#define get_gdat_uint_pos508(X,Y) get_gdat_uint((X),(Y),508) +#define get_gdat_ullong_pos508(X,Y) get_gdat_ullong((X),(Y),508) +#define get_gdat_ip_pos508(X,Y) get_gdat_ip((X),(Y),508) +#define get_gdat_ipv6_pos508(X,Y) get_gdat_ipv6((X),(Y),508) +#define get_gdat_string_pos508(X,Y) get_gdat_string((X),(Y),508) +#define get_gdat_v_str_pos508(X,Y) get_gdat_string((X),(Y),508) +#define get_gdat_bool_pos508(X,Y) get_gdat_bool((X),(Y),508) +#define get_gdat_int_pos508(X,Y) get_gdat_int((X),(Y),508) +#define get_gdat_llong_pos508(X,Y) get_gdat_llong((X),(Y),508) +#define get_gdat_float_pos508(X,Y) get_gdat_float((X),(Y),508) +#define get_gdat_uint_pos509(X,Y) get_gdat_uint((X),(Y),509) +#define get_gdat_ullong_pos509(X,Y) get_gdat_ullong((X),(Y),509) +#define get_gdat_ip_pos509(X,Y) get_gdat_ip((X),(Y),509) +#define get_gdat_ipv6_pos509(X,Y) get_gdat_ipv6((X),(Y),509) +#define get_gdat_string_pos509(X,Y) get_gdat_string((X),(Y),509) +#define get_gdat_v_str_pos509(X,Y) get_gdat_string((X),(Y),509) +#define get_gdat_bool_pos509(X,Y) get_gdat_bool((X),(Y),509) +#define get_gdat_int_pos509(X,Y) get_gdat_int((X),(Y),509) +#define get_gdat_llong_pos509(X,Y) get_gdat_llong((X),(Y),509) +#define get_gdat_float_pos509(X,Y) get_gdat_float((X),(Y),509) +#define get_gdat_uint_pos510(X,Y) get_gdat_uint((X),(Y),510) +#define get_gdat_ullong_pos510(X,Y) get_gdat_ullong((X),(Y),510) +#define get_gdat_ip_pos510(X,Y) get_gdat_ip((X),(Y),510) +#define get_gdat_ipv6_pos510(X,Y) get_gdat_ipv6((X),(Y),510) +#define get_gdat_string_pos510(X,Y) get_gdat_string((X),(Y),510) +#define get_gdat_v_str_pos510(X,Y) get_gdat_string((X),(Y),510) +#define get_gdat_bool_pos510(X,Y) get_gdat_bool((X),(Y),510) +#define get_gdat_int_pos510(X,Y) get_gdat_int((X),(Y),510) +#define get_gdat_llong_pos510(X,Y) get_gdat_llong((X),(Y),510) +#define get_gdat_float_pos510(X,Y) get_gdat_float((X),(Y),510) +#define get_gdat_uint_pos511(X,Y) get_gdat_uint((X),(Y),511) +#define get_gdat_ullong_pos511(X,Y) get_gdat_ullong((X),(Y),511) +#define get_gdat_ip_pos511(X,Y) get_gdat_ip((X),(Y),511) +#define get_gdat_ipv6_pos511(X,Y) get_gdat_ipv6((X),(Y),511) +#define get_gdat_string_pos511(X,Y) get_gdat_string((X),(Y),511) +#define get_gdat_v_str_pos511(X,Y) get_gdat_string((X),(Y),511) +#define get_gdat_bool_pos511(X,Y) get_gdat_bool((X),(Y),511) +#define get_gdat_int_pos511(X,Y) get_gdat_int((X),(Y),511) +#define get_gdat_llong_pos511(X,Y) get_gdat_llong((X),(Y),511) +#define get_gdat_float_pos511(X,Y) get_gdat_float((X),(Y),511) +#define get_gdat_uint_pos512(X,Y) get_gdat_uint((X),(Y),512) +#define get_gdat_ullong_pos512(X,Y) get_gdat_ullong((X),(Y),512) +#define get_gdat_ip_pos512(X,Y) get_gdat_ip((X),(Y),512) +#define get_gdat_ipv6_pos512(X,Y) get_gdat_ipv6((X),(Y),512) +#define get_gdat_string_pos512(X,Y) get_gdat_string((X),(Y),512) +#define get_gdat_v_str_pos512(X,Y) get_gdat_string((X),(Y),512) +#define get_gdat_bool_pos512(X,Y) get_gdat_bool((X),(Y),512) +#define get_gdat_int_pos512(X,Y) get_gdat_int((X),(Y),512) +#define get_gdat_llong_pos512(X,Y) get_gdat_llong((X),(Y),512) +#define get_gdat_float_pos512(X,Y) get_gdat_float((X),(Y),512) +#define get_gdat_uint_pos513(X,Y) get_gdat_uint((X),(Y),513) +#define get_gdat_ullong_pos513(X,Y) get_gdat_ullong((X),(Y),513) +#define get_gdat_ip_pos513(X,Y) get_gdat_ip((X),(Y),513) +#define get_gdat_ipv6_pos513(X,Y) get_gdat_ipv6((X),(Y),513) +#define get_gdat_string_pos513(X,Y) get_gdat_string((X),(Y),513) +#define get_gdat_v_str_pos513(X,Y) get_gdat_string((X),(Y),513) +#define get_gdat_bool_pos513(X,Y) get_gdat_bool((X),(Y),513) +#define get_gdat_int_pos513(X,Y) get_gdat_int((X),(Y),513) +#define get_gdat_llong_pos513(X,Y) get_gdat_llong((X),(Y),513) +#define get_gdat_float_pos513(X,Y) get_gdat_float((X),(Y),513) +#define get_gdat_uint_pos514(X,Y) get_gdat_uint((X),(Y),514) +#define get_gdat_ullong_pos514(X,Y) get_gdat_ullong((X),(Y),514) +#define get_gdat_ip_pos514(X,Y) get_gdat_ip((X),(Y),514) +#define get_gdat_ipv6_pos514(X,Y) get_gdat_ipv6((X),(Y),514) +#define get_gdat_string_pos514(X,Y) get_gdat_string((X),(Y),514) +#define get_gdat_v_str_pos514(X,Y) get_gdat_string((X),(Y),514) +#define get_gdat_bool_pos514(X,Y) get_gdat_bool((X),(Y),514) +#define get_gdat_int_pos514(X,Y) get_gdat_int((X),(Y),514) +#define get_gdat_llong_pos514(X,Y) get_gdat_llong((X),(Y),514) +#define get_gdat_float_pos514(X,Y) get_gdat_float((X),(Y),514) +#define get_gdat_uint_pos515(X,Y) get_gdat_uint((X),(Y),515) +#define get_gdat_ullong_pos515(X,Y) get_gdat_ullong((X),(Y),515) +#define get_gdat_ip_pos515(X,Y) get_gdat_ip((X),(Y),515) +#define get_gdat_ipv6_pos515(X,Y) get_gdat_ipv6((X),(Y),515) +#define get_gdat_string_pos515(X,Y) get_gdat_string((X),(Y),515) +#define get_gdat_v_str_pos515(X,Y) get_gdat_string((X),(Y),515) +#define get_gdat_bool_pos515(X,Y) get_gdat_bool((X),(Y),515) +#define get_gdat_int_pos515(X,Y) get_gdat_int((X),(Y),515) +#define get_gdat_llong_pos515(X,Y) get_gdat_llong((X),(Y),515) +#define get_gdat_float_pos515(X,Y) get_gdat_float((X),(Y),515) +#define get_gdat_uint_pos516(X,Y) get_gdat_uint((X),(Y),516) +#define get_gdat_ullong_pos516(X,Y) get_gdat_ullong((X),(Y),516) +#define get_gdat_ip_pos516(X,Y) get_gdat_ip((X),(Y),516) +#define get_gdat_ipv6_pos516(X,Y) get_gdat_ipv6((X),(Y),516) +#define get_gdat_string_pos516(X,Y) get_gdat_string((X),(Y),516) +#define get_gdat_v_str_pos516(X,Y) get_gdat_string((X),(Y),516) +#define get_gdat_bool_pos516(X,Y) get_gdat_bool((X),(Y),516) +#define get_gdat_int_pos516(X,Y) get_gdat_int((X),(Y),516) +#define get_gdat_llong_pos516(X,Y) get_gdat_llong((X),(Y),516) +#define get_gdat_float_pos516(X,Y) get_gdat_float((X),(Y),516) +#define get_gdat_uint_pos517(X,Y) get_gdat_uint((X),(Y),517) +#define get_gdat_ullong_pos517(X,Y) get_gdat_ullong((X),(Y),517) +#define get_gdat_ip_pos517(X,Y) get_gdat_ip((X),(Y),517) +#define get_gdat_ipv6_pos517(X,Y) get_gdat_ipv6((X),(Y),517) +#define get_gdat_string_pos517(X,Y) get_gdat_string((X),(Y),517) +#define get_gdat_v_str_pos517(X,Y) get_gdat_string((X),(Y),517) +#define get_gdat_bool_pos517(X,Y) get_gdat_bool((X),(Y),517) +#define get_gdat_int_pos517(X,Y) get_gdat_int((X),(Y),517) +#define get_gdat_llong_pos517(X,Y) get_gdat_llong((X),(Y),517) +#define get_gdat_float_pos517(X,Y) get_gdat_float((X),(Y),517) +#define get_gdat_uint_pos518(X,Y) get_gdat_uint((X),(Y),518) +#define get_gdat_ullong_pos518(X,Y) get_gdat_ullong((X),(Y),518) +#define get_gdat_ip_pos518(X,Y) get_gdat_ip((X),(Y),518) +#define get_gdat_ipv6_pos518(X,Y) get_gdat_ipv6((X),(Y),518) +#define get_gdat_string_pos518(X,Y) get_gdat_string((X),(Y),518) +#define get_gdat_v_str_pos518(X,Y) get_gdat_string((X),(Y),518) +#define get_gdat_bool_pos518(X,Y) get_gdat_bool((X),(Y),518) +#define get_gdat_int_pos518(X,Y) get_gdat_int((X),(Y),518) +#define get_gdat_llong_pos518(X,Y) get_gdat_llong((X),(Y),518) +#define get_gdat_float_pos518(X,Y) get_gdat_float((X),(Y),518) +#define get_gdat_uint_pos519(X,Y) get_gdat_uint((X),(Y),519) +#define get_gdat_ullong_pos519(X,Y) get_gdat_ullong((X),(Y),519) +#define get_gdat_ip_pos519(X,Y) get_gdat_ip((X),(Y),519) +#define get_gdat_ipv6_pos519(X,Y) get_gdat_ipv6((X),(Y),519) +#define get_gdat_string_pos519(X,Y) get_gdat_string((X),(Y),519) +#define get_gdat_v_str_pos519(X,Y) get_gdat_string((X),(Y),519) +#define get_gdat_bool_pos519(X,Y) get_gdat_bool((X),(Y),519) +#define get_gdat_int_pos519(X,Y) get_gdat_int((X),(Y),519) +#define get_gdat_llong_pos519(X,Y) get_gdat_llong((X),(Y),519) +#define get_gdat_float_pos519(X,Y) get_gdat_float((X),(Y),519) +#define get_gdat_uint_pos520(X,Y) get_gdat_uint((X),(Y),520) +#define get_gdat_ullong_pos520(X,Y) get_gdat_ullong((X),(Y),520) +#define get_gdat_ip_pos520(X,Y) get_gdat_ip((X),(Y),520) +#define get_gdat_ipv6_pos520(X,Y) get_gdat_ipv6((X),(Y),520) +#define get_gdat_string_pos520(X,Y) get_gdat_string((X),(Y),520) +#define get_gdat_v_str_pos520(X,Y) get_gdat_string((X),(Y),520) +#define get_gdat_bool_pos520(X,Y) get_gdat_bool((X),(Y),520) +#define get_gdat_int_pos520(X,Y) get_gdat_int((X),(Y),520) +#define get_gdat_llong_pos520(X,Y) get_gdat_llong((X),(Y),520) +#define get_gdat_float_pos520(X,Y) get_gdat_float((X),(Y),520) +#define get_gdat_uint_pos521(X,Y) get_gdat_uint((X),(Y),521) +#define get_gdat_ullong_pos521(X,Y) get_gdat_ullong((X),(Y),521) +#define get_gdat_ip_pos521(X,Y) get_gdat_ip((X),(Y),521) +#define get_gdat_ipv6_pos521(X,Y) get_gdat_ipv6((X),(Y),521) +#define get_gdat_string_pos521(X,Y) get_gdat_string((X),(Y),521) +#define get_gdat_v_str_pos521(X,Y) get_gdat_string((X),(Y),521) +#define get_gdat_bool_pos521(X,Y) get_gdat_bool((X),(Y),521) +#define get_gdat_int_pos521(X,Y) get_gdat_int((X),(Y),521) +#define get_gdat_llong_pos521(X,Y) get_gdat_llong((X),(Y),521) +#define get_gdat_float_pos521(X,Y) get_gdat_float((X),(Y),521) +#define get_gdat_uint_pos522(X,Y) get_gdat_uint((X),(Y),522) +#define get_gdat_ullong_pos522(X,Y) get_gdat_ullong((X),(Y),522) +#define get_gdat_ip_pos522(X,Y) get_gdat_ip((X),(Y),522) +#define get_gdat_ipv6_pos522(X,Y) get_gdat_ipv6((X),(Y),522) +#define get_gdat_string_pos522(X,Y) get_gdat_string((X),(Y),522) +#define get_gdat_v_str_pos522(X,Y) get_gdat_string((X),(Y),522) +#define get_gdat_bool_pos522(X,Y) get_gdat_bool((X),(Y),522) +#define get_gdat_int_pos522(X,Y) get_gdat_int((X),(Y),522) +#define get_gdat_llong_pos522(X,Y) get_gdat_llong((X),(Y),522) +#define get_gdat_float_pos522(X,Y) get_gdat_float((X),(Y),522) +#define get_gdat_uint_pos523(X,Y) get_gdat_uint((X),(Y),523) +#define get_gdat_ullong_pos523(X,Y) get_gdat_ullong((X),(Y),523) +#define get_gdat_ip_pos523(X,Y) get_gdat_ip((X),(Y),523) +#define get_gdat_ipv6_pos523(X,Y) get_gdat_ipv6((X),(Y),523) +#define get_gdat_string_pos523(X,Y) get_gdat_string((X),(Y),523) +#define get_gdat_v_str_pos523(X,Y) get_gdat_string((X),(Y),523) +#define get_gdat_bool_pos523(X,Y) get_gdat_bool((X),(Y),523) +#define get_gdat_int_pos523(X,Y) get_gdat_int((X),(Y),523) +#define get_gdat_llong_pos523(X,Y) get_gdat_llong((X),(Y),523) +#define get_gdat_float_pos523(X,Y) get_gdat_float((X),(Y),523) +#define get_gdat_uint_pos524(X,Y) get_gdat_uint((X),(Y),524) +#define get_gdat_ullong_pos524(X,Y) get_gdat_ullong((X),(Y),524) +#define get_gdat_ip_pos524(X,Y) get_gdat_ip((X),(Y),524) +#define get_gdat_ipv6_pos524(X,Y) get_gdat_ipv6((X),(Y),524) +#define get_gdat_string_pos524(X,Y) get_gdat_string((X),(Y),524) +#define get_gdat_v_str_pos524(X,Y) get_gdat_string((X),(Y),524) +#define get_gdat_bool_pos524(X,Y) get_gdat_bool((X),(Y),524) +#define get_gdat_int_pos524(X,Y) get_gdat_int((X),(Y),524) +#define get_gdat_llong_pos524(X,Y) get_gdat_llong((X),(Y),524) +#define get_gdat_float_pos524(X,Y) get_gdat_float((X),(Y),524) +#define get_gdat_uint_pos525(X,Y) get_gdat_uint((X),(Y),525) +#define get_gdat_ullong_pos525(X,Y) get_gdat_ullong((X),(Y),525) +#define get_gdat_ip_pos525(X,Y) get_gdat_ip((X),(Y),525) +#define get_gdat_ipv6_pos525(X,Y) get_gdat_ipv6((X),(Y),525) +#define get_gdat_string_pos525(X,Y) get_gdat_string((X),(Y),525) +#define get_gdat_v_str_pos525(X,Y) get_gdat_string((X),(Y),525) +#define get_gdat_bool_pos525(X,Y) get_gdat_bool((X),(Y),525) +#define get_gdat_int_pos525(X,Y) get_gdat_int((X),(Y),525) +#define get_gdat_llong_pos525(X,Y) get_gdat_llong((X),(Y),525) +#define get_gdat_float_pos525(X,Y) get_gdat_float((X),(Y),525) +#define get_gdat_uint_pos526(X,Y) get_gdat_uint((X),(Y),526) +#define get_gdat_ullong_pos526(X,Y) get_gdat_ullong((X),(Y),526) +#define get_gdat_ip_pos526(X,Y) get_gdat_ip((X),(Y),526) +#define get_gdat_ipv6_pos526(X,Y) get_gdat_ipv6((X),(Y),526) +#define get_gdat_string_pos526(X,Y) get_gdat_string((X),(Y),526) +#define get_gdat_v_str_pos526(X,Y) get_gdat_string((X),(Y),526) +#define get_gdat_bool_pos526(X,Y) get_gdat_bool((X),(Y),526) +#define get_gdat_int_pos526(X,Y) get_gdat_int((X),(Y),526) +#define get_gdat_llong_pos526(X,Y) get_gdat_llong((X),(Y),526) +#define get_gdat_float_pos526(X,Y) get_gdat_float((X),(Y),526) +#define get_gdat_uint_pos527(X,Y) get_gdat_uint((X),(Y),527) +#define get_gdat_ullong_pos527(X,Y) get_gdat_ullong((X),(Y),527) +#define get_gdat_ip_pos527(X,Y) get_gdat_ip((X),(Y),527) +#define get_gdat_ipv6_pos527(X,Y) get_gdat_ipv6((X),(Y),527) +#define get_gdat_string_pos527(X,Y) get_gdat_string((X),(Y),527) +#define get_gdat_v_str_pos527(X,Y) get_gdat_string((X),(Y),527) +#define get_gdat_bool_pos527(X,Y) get_gdat_bool((X),(Y),527) +#define get_gdat_int_pos527(X,Y) get_gdat_int((X),(Y),527) +#define get_gdat_llong_pos527(X,Y) get_gdat_llong((X),(Y),527) +#define get_gdat_float_pos527(X,Y) get_gdat_float((X),(Y),527) +#define get_gdat_uint_pos528(X,Y) get_gdat_uint((X),(Y),528) +#define get_gdat_ullong_pos528(X,Y) get_gdat_ullong((X),(Y),528) +#define get_gdat_ip_pos528(X,Y) get_gdat_ip((X),(Y),528) +#define get_gdat_ipv6_pos528(X,Y) get_gdat_ipv6((X),(Y),528) +#define get_gdat_string_pos528(X,Y) get_gdat_string((X),(Y),528) +#define get_gdat_v_str_pos528(X,Y) get_gdat_string((X),(Y),528) +#define get_gdat_bool_pos528(X,Y) get_gdat_bool((X),(Y),528) +#define get_gdat_int_pos528(X,Y) get_gdat_int((X),(Y),528) +#define get_gdat_llong_pos528(X,Y) get_gdat_llong((X),(Y),528) +#define get_gdat_float_pos528(X,Y) get_gdat_float((X),(Y),528) +#define get_gdat_uint_pos529(X,Y) get_gdat_uint((X),(Y),529) +#define get_gdat_ullong_pos529(X,Y) get_gdat_ullong((X),(Y),529) +#define get_gdat_ip_pos529(X,Y) get_gdat_ip((X),(Y),529) +#define get_gdat_ipv6_pos529(X,Y) get_gdat_ipv6((X),(Y),529) +#define get_gdat_string_pos529(X,Y) get_gdat_string((X),(Y),529) +#define get_gdat_v_str_pos529(X,Y) get_gdat_string((X),(Y),529) +#define get_gdat_bool_pos529(X,Y) get_gdat_bool((X),(Y),529) +#define get_gdat_int_pos529(X,Y) get_gdat_int((X),(Y),529) +#define get_gdat_llong_pos529(X,Y) get_gdat_llong((X),(Y),529) +#define get_gdat_float_pos529(X,Y) get_gdat_float((X),(Y),529) +#define get_gdat_uint_pos530(X,Y) get_gdat_uint((X),(Y),530) +#define get_gdat_ullong_pos530(X,Y) get_gdat_ullong((X),(Y),530) +#define get_gdat_ip_pos530(X,Y) get_gdat_ip((X),(Y),530) +#define get_gdat_ipv6_pos530(X,Y) get_gdat_ipv6((X),(Y),530) +#define get_gdat_string_pos530(X,Y) get_gdat_string((X),(Y),530) +#define get_gdat_v_str_pos530(X,Y) get_gdat_string((X),(Y),530) +#define get_gdat_bool_pos530(X,Y) get_gdat_bool((X),(Y),530) +#define get_gdat_int_pos530(X,Y) get_gdat_int((X),(Y),530) +#define get_gdat_llong_pos530(X,Y) get_gdat_llong((X),(Y),530) +#define get_gdat_float_pos530(X,Y) get_gdat_float((X),(Y),530) +#define get_gdat_uint_pos531(X,Y) get_gdat_uint((X),(Y),531) +#define get_gdat_ullong_pos531(X,Y) get_gdat_ullong((X),(Y),531) +#define get_gdat_ip_pos531(X,Y) get_gdat_ip((X),(Y),531) +#define get_gdat_ipv6_pos531(X,Y) get_gdat_ipv6((X),(Y),531) +#define get_gdat_string_pos531(X,Y) get_gdat_string((X),(Y),531) +#define get_gdat_v_str_pos531(X,Y) get_gdat_string((X),(Y),531) +#define get_gdat_bool_pos531(X,Y) get_gdat_bool((X),(Y),531) +#define get_gdat_int_pos531(X,Y) get_gdat_int((X),(Y),531) +#define get_gdat_llong_pos531(X,Y) get_gdat_llong((X),(Y),531) +#define get_gdat_float_pos531(X,Y) get_gdat_float((X),(Y),531) +#define get_gdat_uint_pos532(X,Y) get_gdat_uint((X),(Y),532) +#define get_gdat_ullong_pos532(X,Y) get_gdat_ullong((X),(Y),532) +#define get_gdat_ip_pos532(X,Y) get_gdat_ip((X),(Y),532) +#define get_gdat_ipv6_pos532(X,Y) get_gdat_ipv6((X),(Y),532) +#define get_gdat_string_pos532(X,Y) get_gdat_string((X),(Y),532) +#define get_gdat_v_str_pos532(X,Y) get_gdat_string((X),(Y),532) +#define get_gdat_bool_pos532(X,Y) get_gdat_bool((X),(Y),532) +#define get_gdat_int_pos532(X,Y) get_gdat_int((X),(Y),532) +#define get_gdat_llong_pos532(X,Y) get_gdat_llong((X),(Y),532) +#define get_gdat_float_pos532(X,Y) get_gdat_float((X),(Y),532) +#define get_gdat_uint_pos533(X,Y) get_gdat_uint((X),(Y),533) +#define get_gdat_ullong_pos533(X,Y) get_gdat_ullong((X),(Y),533) +#define get_gdat_ip_pos533(X,Y) get_gdat_ip((X),(Y),533) +#define get_gdat_ipv6_pos533(X,Y) get_gdat_ipv6((X),(Y),533) +#define get_gdat_string_pos533(X,Y) get_gdat_string((X),(Y),533) +#define get_gdat_v_str_pos533(X,Y) get_gdat_string((X),(Y),533) +#define get_gdat_bool_pos533(X,Y) get_gdat_bool((X),(Y),533) +#define get_gdat_int_pos533(X,Y) get_gdat_int((X),(Y),533) +#define get_gdat_llong_pos533(X,Y) get_gdat_llong((X),(Y),533) +#define get_gdat_float_pos533(X,Y) get_gdat_float((X),(Y),533) +#define get_gdat_uint_pos534(X,Y) get_gdat_uint((X),(Y),534) +#define get_gdat_ullong_pos534(X,Y) get_gdat_ullong((X),(Y),534) +#define get_gdat_ip_pos534(X,Y) get_gdat_ip((X),(Y),534) +#define get_gdat_ipv6_pos534(X,Y) get_gdat_ipv6((X),(Y),534) +#define get_gdat_string_pos534(X,Y) get_gdat_string((X),(Y),534) +#define get_gdat_v_str_pos534(X,Y) get_gdat_string((X),(Y),534) +#define get_gdat_bool_pos534(X,Y) get_gdat_bool((X),(Y),534) +#define get_gdat_int_pos534(X,Y) get_gdat_int((X),(Y),534) +#define get_gdat_llong_pos534(X,Y) get_gdat_llong((X),(Y),534) +#define get_gdat_float_pos534(X,Y) get_gdat_float((X),(Y),534) +#define get_gdat_uint_pos535(X,Y) get_gdat_uint((X),(Y),535) +#define get_gdat_ullong_pos535(X,Y) get_gdat_ullong((X),(Y),535) +#define get_gdat_ip_pos535(X,Y) get_gdat_ip((X),(Y),535) +#define get_gdat_ipv6_pos535(X,Y) get_gdat_ipv6((X),(Y),535) +#define get_gdat_string_pos535(X,Y) get_gdat_string((X),(Y),535) +#define get_gdat_v_str_pos535(X,Y) get_gdat_string((X),(Y),535) +#define get_gdat_bool_pos535(X,Y) get_gdat_bool((X),(Y),535) +#define get_gdat_int_pos535(X,Y) get_gdat_int((X),(Y),535) +#define get_gdat_llong_pos535(X,Y) get_gdat_llong((X),(Y),535) +#define get_gdat_float_pos535(X,Y) get_gdat_float((X),(Y),535) +#define get_gdat_uint_pos536(X,Y) get_gdat_uint((X),(Y),536) +#define get_gdat_ullong_pos536(X,Y) get_gdat_ullong((X),(Y),536) +#define get_gdat_ip_pos536(X,Y) get_gdat_ip((X),(Y),536) +#define get_gdat_ipv6_pos536(X,Y) get_gdat_ipv6((X),(Y),536) +#define get_gdat_string_pos536(X,Y) get_gdat_string((X),(Y),536) +#define get_gdat_v_str_pos536(X,Y) get_gdat_string((X),(Y),536) +#define get_gdat_bool_pos536(X,Y) get_gdat_bool((X),(Y),536) +#define get_gdat_int_pos536(X,Y) get_gdat_int((X),(Y),536) +#define get_gdat_llong_pos536(X,Y) get_gdat_llong((X),(Y),536) +#define get_gdat_float_pos536(X,Y) get_gdat_float((X),(Y),536) +#define get_gdat_uint_pos537(X,Y) get_gdat_uint((X),(Y),537) +#define get_gdat_ullong_pos537(X,Y) get_gdat_ullong((X),(Y),537) +#define get_gdat_ip_pos537(X,Y) get_gdat_ip((X),(Y),537) +#define get_gdat_ipv6_pos537(X,Y) get_gdat_ipv6((X),(Y),537) +#define get_gdat_string_pos537(X,Y) get_gdat_string((X),(Y),537) +#define get_gdat_v_str_pos537(X,Y) get_gdat_string((X),(Y),537) +#define get_gdat_bool_pos537(X,Y) get_gdat_bool((X),(Y),537) +#define get_gdat_int_pos537(X,Y) get_gdat_int((X),(Y),537) +#define get_gdat_llong_pos537(X,Y) get_gdat_llong((X),(Y),537) +#define get_gdat_float_pos537(X,Y) get_gdat_float((X),(Y),537) +#define get_gdat_uint_pos538(X,Y) get_gdat_uint((X),(Y),538) +#define get_gdat_ullong_pos538(X,Y) get_gdat_ullong((X),(Y),538) +#define get_gdat_ip_pos538(X,Y) get_gdat_ip((X),(Y),538) +#define get_gdat_ipv6_pos538(X,Y) get_gdat_ipv6((X),(Y),538) +#define get_gdat_string_pos538(X,Y) get_gdat_string((X),(Y),538) +#define get_gdat_v_str_pos538(X,Y) get_gdat_string((X),(Y),538) +#define get_gdat_bool_pos538(X,Y) get_gdat_bool((X),(Y),538) +#define get_gdat_int_pos538(X,Y) get_gdat_int((X),(Y),538) +#define get_gdat_llong_pos538(X,Y) get_gdat_llong((X),(Y),538) +#define get_gdat_float_pos538(X,Y) get_gdat_float((X),(Y),538) +#define get_gdat_uint_pos539(X,Y) get_gdat_uint((X),(Y),539) +#define get_gdat_ullong_pos539(X,Y) get_gdat_ullong((X),(Y),539) +#define get_gdat_ip_pos539(X,Y) get_gdat_ip((X),(Y),539) +#define get_gdat_ipv6_pos539(X,Y) get_gdat_ipv6((X),(Y),539) +#define get_gdat_string_pos539(X,Y) get_gdat_string((X),(Y),539) +#define get_gdat_v_str_pos539(X,Y) get_gdat_string((X),(Y),539) +#define get_gdat_bool_pos539(X,Y) get_gdat_bool((X),(Y),539) +#define get_gdat_int_pos539(X,Y) get_gdat_int((X),(Y),539) +#define get_gdat_llong_pos539(X,Y) get_gdat_llong((X),(Y),539) +#define get_gdat_float_pos539(X,Y) get_gdat_float((X),(Y),539) +#define get_gdat_uint_pos540(X,Y) get_gdat_uint((X),(Y),540) +#define get_gdat_ullong_pos540(X,Y) get_gdat_ullong((X),(Y),540) +#define get_gdat_ip_pos540(X,Y) get_gdat_ip((X),(Y),540) +#define get_gdat_ipv6_pos540(X,Y) get_gdat_ipv6((X),(Y),540) +#define get_gdat_string_pos540(X,Y) get_gdat_string((X),(Y),540) +#define get_gdat_v_str_pos540(X,Y) get_gdat_string((X),(Y),540) +#define get_gdat_bool_pos540(X,Y) get_gdat_bool((X),(Y),540) +#define get_gdat_int_pos540(X,Y) get_gdat_int((X),(Y),540) +#define get_gdat_llong_pos540(X,Y) get_gdat_llong((X),(Y),540) +#define get_gdat_float_pos540(X,Y) get_gdat_float((X),(Y),540) +#define get_gdat_uint_pos541(X,Y) get_gdat_uint((X),(Y),541) +#define get_gdat_ullong_pos541(X,Y) get_gdat_ullong((X),(Y),541) +#define get_gdat_ip_pos541(X,Y) get_gdat_ip((X),(Y),541) +#define get_gdat_ipv6_pos541(X,Y) get_gdat_ipv6((X),(Y),541) +#define get_gdat_string_pos541(X,Y) get_gdat_string((X),(Y),541) +#define get_gdat_v_str_pos541(X,Y) get_gdat_string((X),(Y),541) +#define get_gdat_bool_pos541(X,Y) get_gdat_bool((X),(Y),541) +#define get_gdat_int_pos541(X,Y) get_gdat_int((X),(Y),541) +#define get_gdat_llong_pos541(X,Y) get_gdat_llong((X),(Y),541) +#define get_gdat_float_pos541(X,Y) get_gdat_float((X),(Y),541) +#define get_gdat_uint_pos542(X,Y) get_gdat_uint((X),(Y),542) +#define get_gdat_ullong_pos542(X,Y) get_gdat_ullong((X),(Y),542) +#define get_gdat_ip_pos542(X,Y) get_gdat_ip((X),(Y),542) +#define get_gdat_ipv6_pos542(X,Y) get_gdat_ipv6((X),(Y),542) +#define get_gdat_string_pos542(X,Y) get_gdat_string((X),(Y),542) +#define get_gdat_v_str_pos542(X,Y) get_gdat_string((X),(Y),542) +#define get_gdat_bool_pos542(X,Y) get_gdat_bool((X),(Y),542) +#define get_gdat_int_pos542(X,Y) get_gdat_int((X),(Y),542) +#define get_gdat_llong_pos542(X,Y) get_gdat_llong((X),(Y),542) +#define get_gdat_float_pos542(X,Y) get_gdat_float((X),(Y),542) +#define get_gdat_uint_pos543(X,Y) get_gdat_uint((X),(Y),543) +#define get_gdat_ullong_pos543(X,Y) get_gdat_ullong((X),(Y),543) +#define get_gdat_ip_pos543(X,Y) get_gdat_ip((X),(Y),543) +#define get_gdat_ipv6_pos543(X,Y) get_gdat_ipv6((X),(Y),543) +#define get_gdat_string_pos543(X,Y) get_gdat_string((X),(Y),543) +#define get_gdat_v_str_pos543(X,Y) get_gdat_string((X),(Y),543) +#define get_gdat_bool_pos543(X,Y) get_gdat_bool((X),(Y),543) +#define get_gdat_int_pos543(X,Y) get_gdat_int((X),(Y),543) +#define get_gdat_llong_pos543(X,Y) get_gdat_llong((X),(Y),543) +#define get_gdat_float_pos543(X,Y) get_gdat_float((X),(Y),543) +#define get_gdat_uint_pos544(X,Y) get_gdat_uint((X),(Y),544) +#define get_gdat_ullong_pos544(X,Y) get_gdat_ullong((X),(Y),544) +#define get_gdat_ip_pos544(X,Y) get_gdat_ip((X),(Y),544) +#define get_gdat_ipv6_pos544(X,Y) get_gdat_ipv6((X),(Y),544) +#define get_gdat_string_pos544(X,Y) get_gdat_string((X),(Y),544) +#define get_gdat_v_str_pos544(X,Y) get_gdat_string((X),(Y),544) +#define get_gdat_bool_pos544(X,Y) get_gdat_bool((X),(Y),544) +#define get_gdat_int_pos544(X,Y) get_gdat_int((X),(Y),544) +#define get_gdat_llong_pos544(X,Y) get_gdat_llong((X),(Y),544) +#define get_gdat_float_pos544(X,Y) get_gdat_float((X),(Y),544) +#define get_gdat_uint_pos545(X,Y) get_gdat_uint((X),(Y),545) +#define get_gdat_ullong_pos545(X,Y) get_gdat_ullong((X),(Y),545) +#define get_gdat_ip_pos545(X,Y) get_gdat_ip((X),(Y),545) +#define get_gdat_ipv6_pos545(X,Y) get_gdat_ipv6((X),(Y),545) +#define get_gdat_string_pos545(X,Y) get_gdat_string((X),(Y),545) +#define get_gdat_v_str_pos545(X,Y) get_gdat_string((X),(Y),545) +#define get_gdat_bool_pos545(X,Y) get_gdat_bool((X),(Y),545) +#define get_gdat_int_pos545(X,Y) get_gdat_int((X),(Y),545) +#define get_gdat_llong_pos545(X,Y) get_gdat_llong((X),(Y),545) +#define get_gdat_float_pos545(X,Y) get_gdat_float((X),(Y),545) +#define get_gdat_uint_pos546(X,Y) get_gdat_uint((X),(Y),546) +#define get_gdat_ullong_pos546(X,Y) get_gdat_ullong((X),(Y),546) +#define get_gdat_ip_pos546(X,Y) get_gdat_ip((X),(Y),546) +#define get_gdat_ipv6_pos546(X,Y) get_gdat_ipv6((X),(Y),546) +#define get_gdat_string_pos546(X,Y) get_gdat_string((X),(Y),546) +#define get_gdat_v_str_pos546(X,Y) get_gdat_string((X),(Y),546) +#define get_gdat_bool_pos546(X,Y) get_gdat_bool((X),(Y),546) +#define get_gdat_int_pos546(X,Y) get_gdat_int((X),(Y),546) +#define get_gdat_llong_pos546(X,Y) get_gdat_llong((X),(Y),546) +#define get_gdat_float_pos546(X,Y) get_gdat_float((X),(Y),546) +#define get_gdat_uint_pos547(X,Y) get_gdat_uint((X),(Y),547) +#define get_gdat_ullong_pos547(X,Y) get_gdat_ullong((X),(Y),547) +#define get_gdat_ip_pos547(X,Y) get_gdat_ip((X),(Y),547) +#define get_gdat_ipv6_pos547(X,Y) get_gdat_ipv6((X),(Y),547) +#define get_gdat_string_pos547(X,Y) get_gdat_string((X),(Y),547) +#define get_gdat_v_str_pos547(X,Y) get_gdat_string((X),(Y),547) +#define get_gdat_bool_pos547(X,Y) get_gdat_bool((X),(Y),547) +#define get_gdat_int_pos547(X,Y) get_gdat_int((X),(Y),547) +#define get_gdat_llong_pos547(X,Y) get_gdat_llong((X),(Y),547) +#define get_gdat_float_pos547(X,Y) get_gdat_float((X),(Y),547) +#define get_gdat_uint_pos548(X,Y) get_gdat_uint((X),(Y),548) +#define get_gdat_ullong_pos548(X,Y) get_gdat_ullong((X),(Y),548) +#define get_gdat_ip_pos548(X,Y) get_gdat_ip((X),(Y),548) +#define get_gdat_ipv6_pos548(X,Y) get_gdat_ipv6((X),(Y),548) +#define get_gdat_string_pos548(X,Y) get_gdat_string((X),(Y),548) +#define get_gdat_v_str_pos548(X,Y) get_gdat_string((X),(Y),548) +#define get_gdat_bool_pos548(X,Y) get_gdat_bool((X),(Y),548) +#define get_gdat_int_pos548(X,Y) get_gdat_int((X),(Y),548) +#define get_gdat_llong_pos548(X,Y) get_gdat_llong((X),(Y),548) +#define get_gdat_float_pos548(X,Y) get_gdat_float((X),(Y),548) +#define get_gdat_uint_pos549(X,Y) get_gdat_uint((X),(Y),549) +#define get_gdat_ullong_pos549(X,Y) get_gdat_ullong((X),(Y),549) +#define get_gdat_ip_pos549(X,Y) get_gdat_ip((X),(Y),549) +#define get_gdat_ipv6_pos549(X,Y) get_gdat_ipv6((X),(Y),549) +#define get_gdat_string_pos549(X,Y) get_gdat_string((X),(Y),549) +#define get_gdat_v_str_pos549(X,Y) get_gdat_string((X),(Y),549) +#define get_gdat_bool_pos549(X,Y) get_gdat_bool((X),(Y),549) +#define get_gdat_int_pos549(X,Y) get_gdat_int((X),(Y),549) +#define get_gdat_llong_pos549(X,Y) get_gdat_llong((X),(Y),549) +#define get_gdat_float_pos549(X,Y) get_gdat_float((X),(Y),549) +#define get_gdat_uint_pos550(X,Y) get_gdat_uint((X),(Y),550) +#define get_gdat_ullong_pos550(X,Y) get_gdat_ullong((X),(Y),550) +#define get_gdat_ip_pos550(X,Y) get_gdat_ip((X),(Y),550) +#define get_gdat_ipv6_pos550(X,Y) get_gdat_ipv6((X),(Y),550) +#define get_gdat_string_pos550(X,Y) get_gdat_string((X),(Y),550) +#define get_gdat_v_str_pos550(X,Y) get_gdat_string((X),(Y),550) +#define get_gdat_bool_pos550(X,Y) get_gdat_bool((X),(Y),550) +#define get_gdat_int_pos550(X,Y) get_gdat_int((X),(Y),550) +#define get_gdat_llong_pos550(X,Y) get_gdat_llong((X),(Y),550) +#define get_gdat_float_pos550(X,Y) get_gdat_float((X),(Y),550) +#define get_gdat_uint_pos551(X,Y) get_gdat_uint((X),(Y),551) +#define get_gdat_ullong_pos551(X,Y) get_gdat_ullong((X),(Y),551) +#define get_gdat_ip_pos551(X,Y) get_gdat_ip((X),(Y),551) +#define get_gdat_ipv6_pos551(X,Y) get_gdat_ipv6((X),(Y),551) +#define get_gdat_string_pos551(X,Y) get_gdat_string((X),(Y),551) +#define get_gdat_v_str_pos551(X,Y) get_gdat_string((X),(Y),551) +#define get_gdat_bool_pos551(X,Y) get_gdat_bool((X),(Y),551) +#define get_gdat_int_pos551(X,Y) get_gdat_int((X),(Y),551) +#define get_gdat_llong_pos551(X,Y) get_gdat_llong((X),(Y),551) +#define get_gdat_float_pos551(X,Y) get_gdat_float((X),(Y),551) +#define get_gdat_uint_pos552(X,Y) get_gdat_uint((X),(Y),552) +#define get_gdat_ullong_pos552(X,Y) get_gdat_ullong((X),(Y),552) +#define get_gdat_ip_pos552(X,Y) get_gdat_ip((X),(Y),552) +#define get_gdat_ipv6_pos552(X,Y) get_gdat_ipv6((X),(Y),552) +#define get_gdat_string_pos552(X,Y) get_gdat_string((X),(Y),552) +#define get_gdat_v_str_pos552(X,Y) get_gdat_string((X),(Y),552) +#define get_gdat_bool_pos552(X,Y) get_gdat_bool((X),(Y),552) +#define get_gdat_int_pos552(X,Y) get_gdat_int((X),(Y),552) +#define get_gdat_llong_pos552(X,Y) get_gdat_llong((X),(Y),552) +#define get_gdat_float_pos552(X,Y) get_gdat_float((X),(Y),552) +#define get_gdat_uint_pos553(X,Y) get_gdat_uint((X),(Y),553) +#define get_gdat_ullong_pos553(X,Y) get_gdat_ullong((X),(Y),553) +#define get_gdat_ip_pos553(X,Y) get_gdat_ip((X),(Y),553) +#define get_gdat_ipv6_pos553(X,Y) get_gdat_ipv6((X),(Y),553) +#define get_gdat_string_pos553(X,Y) get_gdat_string((X),(Y),553) +#define get_gdat_v_str_pos553(X,Y) get_gdat_string((X),(Y),553) +#define get_gdat_bool_pos553(X,Y) get_gdat_bool((X),(Y),553) +#define get_gdat_int_pos553(X,Y) get_gdat_int((X),(Y),553) +#define get_gdat_llong_pos553(X,Y) get_gdat_llong((X),(Y),553) +#define get_gdat_float_pos553(X,Y) get_gdat_float((X),(Y),553) +#define get_gdat_uint_pos554(X,Y) get_gdat_uint((X),(Y),554) +#define get_gdat_ullong_pos554(X,Y) get_gdat_ullong((X),(Y),554) +#define get_gdat_ip_pos554(X,Y) get_gdat_ip((X),(Y),554) +#define get_gdat_ipv6_pos554(X,Y) get_gdat_ipv6((X),(Y),554) +#define get_gdat_string_pos554(X,Y) get_gdat_string((X),(Y),554) +#define get_gdat_v_str_pos554(X,Y) get_gdat_string((X),(Y),554) +#define get_gdat_bool_pos554(X,Y) get_gdat_bool((X),(Y),554) +#define get_gdat_int_pos554(X,Y) get_gdat_int((X),(Y),554) +#define get_gdat_llong_pos554(X,Y) get_gdat_llong((X),(Y),554) +#define get_gdat_float_pos554(X,Y) get_gdat_float((X),(Y),554) +#define get_gdat_uint_pos555(X,Y) get_gdat_uint((X),(Y),555) +#define get_gdat_ullong_pos555(X,Y) get_gdat_ullong((X),(Y),555) +#define get_gdat_ip_pos555(X,Y) get_gdat_ip((X),(Y),555) +#define get_gdat_ipv6_pos555(X,Y) get_gdat_ipv6((X),(Y),555) +#define get_gdat_string_pos555(X,Y) get_gdat_string((X),(Y),555) +#define get_gdat_v_str_pos555(X,Y) get_gdat_string((X),(Y),555) +#define get_gdat_bool_pos555(X,Y) get_gdat_bool((X),(Y),555) +#define get_gdat_int_pos555(X,Y) get_gdat_int((X),(Y),555) +#define get_gdat_llong_pos555(X,Y) get_gdat_llong((X),(Y),555) +#define get_gdat_float_pos555(X,Y) get_gdat_float((X),(Y),555) +#define get_gdat_uint_pos556(X,Y) get_gdat_uint((X),(Y),556) +#define get_gdat_ullong_pos556(X,Y) get_gdat_ullong((X),(Y),556) +#define get_gdat_ip_pos556(X,Y) get_gdat_ip((X),(Y),556) +#define get_gdat_ipv6_pos556(X,Y) get_gdat_ipv6((X),(Y),556) +#define get_gdat_string_pos556(X,Y) get_gdat_string((X),(Y),556) +#define get_gdat_v_str_pos556(X,Y) get_gdat_string((X),(Y),556) +#define get_gdat_bool_pos556(X,Y) get_gdat_bool((X),(Y),556) +#define get_gdat_int_pos556(X,Y) get_gdat_int((X),(Y),556) +#define get_gdat_llong_pos556(X,Y) get_gdat_llong((X),(Y),556) +#define get_gdat_float_pos556(X,Y) get_gdat_float((X),(Y),556) +#define get_gdat_uint_pos557(X,Y) get_gdat_uint((X),(Y),557) +#define get_gdat_ullong_pos557(X,Y) get_gdat_ullong((X),(Y),557) +#define get_gdat_ip_pos557(X,Y) get_gdat_ip((X),(Y),557) +#define get_gdat_ipv6_pos557(X,Y) get_gdat_ipv6((X),(Y),557) +#define get_gdat_string_pos557(X,Y) get_gdat_string((X),(Y),557) +#define get_gdat_v_str_pos557(X,Y) get_gdat_string((X),(Y),557) +#define get_gdat_bool_pos557(X,Y) get_gdat_bool((X),(Y),557) +#define get_gdat_int_pos557(X,Y) get_gdat_int((X),(Y),557) +#define get_gdat_llong_pos557(X,Y) get_gdat_llong((X),(Y),557) +#define get_gdat_float_pos557(X,Y) get_gdat_float((X),(Y),557) +#define get_gdat_uint_pos558(X,Y) get_gdat_uint((X),(Y),558) +#define get_gdat_ullong_pos558(X,Y) get_gdat_ullong((X),(Y),558) +#define get_gdat_ip_pos558(X,Y) get_gdat_ip((X),(Y),558) +#define get_gdat_ipv6_pos558(X,Y) get_gdat_ipv6((X),(Y),558) +#define get_gdat_string_pos558(X,Y) get_gdat_string((X),(Y),558) +#define get_gdat_v_str_pos558(X,Y) get_gdat_string((X),(Y),558) +#define get_gdat_bool_pos558(X,Y) get_gdat_bool((X),(Y),558) +#define get_gdat_int_pos558(X,Y) get_gdat_int((X),(Y),558) +#define get_gdat_llong_pos558(X,Y) get_gdat_llong((X),(Y),558) +#define get_gdat_float_pos558(X,Y) get_gdat_float((X),(Y),558) +#define get_gdat_uint_pos559(X,Y) get_gdat_uint((X),(Y),559) +#define get_gdat_ullong_pos559(X,Y) get_gdat_ullong((X),(Y),559) +#define get_gdat_ip_pos559(X,Y) get_gdat_ip((X),(Y),559) +#define get_gdat_ipv6_pos559(X,Y) get_gdat_ipv6((X),(Y),559) +#define get_gdat_string_pos559(X,Y) get_gdat_string((X),(Y),559) +#define get_gdat_v_str_pos559(X,Y) get_gdat_string((X),(Y),559) +#define get_gdat_bool_pos559(X,Y) get_gdat_bool((X),(Y),559) +#define get_gdat_int_pos559(X,Y) get_gdat_int((X),(Y),559) +#define get_gdat_llong_pos559(X,Y) get_gdat_llong((X),(Y),559) +#define get_gdat_float_pos559(X,Y) get_gdat_float((X),(Y),559) +#define get_gdat_uint_pos560(X,Y) get_gdat_uint((X),(Y),560) +#define get_gdat_ullong_pos560(X,Y) get_gdat_ullong((X),(Y),560) +#define get_gdat_ip_pos560(X,Y) get_gdat_ip((X),(Y),560) +#define get_gdat_ipv6_pos560(X,Y) get_gdat_ipv6((X),(Y),560) +#define get_gdat_string_pos560(X,Y) get_gdat_string((X),(Y),560) +#define get_gdat_v_str_pos560(X,Y) get_gdat_string((X),(Y),560) +#define get_gdat_bool_pos560(X,Y) get_gdat_bool((X),(Y),560) +#define get_gdat_int_pos560(X,Y) get_gdat_int((X),(Y),560) +#define get_gdat_llong_pos560(X,Y) get_gdat_llong((X),(Y),560) +#define get_gdat_float_pos560(X,Y) get_gdat_float((X),(Y),560) +#define get_gdat_uint_pos561(X,Y) get_gdat_uint((X),(Y),561) +#define get_gdat_ullong_pos561(X,Y) get_gdat_ullong((X),(Y),561) +#define get_gdat_ip_pos561(X,Y) get_gdat_ip((X),(Y),561) +#define get_gdat_ipv6_pos561(X,Y) get_gdat_ipv6((X),(Y),561) +#define get_gdat_string_pos561(X,Y) get_gdat_string((X),(Y),561) +#define get_gdat_v_str_pos561(X,Y) get_gdat_string((X),(Y),561) +#define get_gdat_bool_pos561(X,Y) get_gdat_bool((X),(Y),561) +#define get_gdat_int_pos561(X,Y) get_gdat_int((X),(Y),561) +#define get_gdat_llong_pos561(X,Y) get_gdat_llong((X),(Y),561) +#define get_gdat_float_pos561(X,Y) get_gdat_float((X),(Y),561) +#define get_gdat_uint_pos562(X,Y) get_gdat_uint((X),(Y),562) +#define get_gdat_ullong_pos562(X,Y) get_gdat_ullong((X),(Y),562) +#define get_gdat_ip_pos562(X,Y) get_gdat_ip((X),(Y),562) +#define get_gdat_ipv6_pos562(X,Y) get_gdat_ipv6((X),(Y),562) +#define get_gdat_string_pos562(X,Y) get_gdat_string((X),(Y),562) +#define get_gdat_v_str_pos562(X,Y) get_gdat_string((X),(Y),562) +#define get_gdat_bool_pos562(X,Y) get_gdat_bool((X),(Y),562) +#define get_gdat_int_pos562(X,Y) get_gdat_int((X),(Y),562) +#define get_gdat_llong_pos562(X,Y) get_gdat_llong((X),(Y),562) +#define get_gdat_float_pos562(X,Y) get_gdat_float((X),(Y),562) +#define get_gdat_uint_pos563(X,Y) get_gdat_uint((X),(Y),563) +#define get_gdat_ullong_pos563(X,Y) get_gdat_ullong((X),(Y),563) +#define get_gdat_ip_pos563(X,Y) get_gdat_ip((X),(Y),563) +#define get_gdat_ipv6_pos563(X,Y) get_gdat_ipv6((X),(Y),563) +#define get_gdat_string_pos563(X,Y) get_gdat_string((X),(Y),563) +#define get_gdat_v_str_pos563(X,Y) get_gdat_string((X),(Y),563) +#define get_gdat_bool_pos563(X,Y) get_gdat_bool((X),(Y),563) +#define get_gdat_int_pos563(X,Y) get_gdat_int((X),(Y),563) +#define get_gdat_llong_pos563(X,Y) get_gdat_llong((X),(Y),563) +#define get_gdat_float_pos563(X,Y) get_gdat_float((X),(Y),563) +#define get_gdat_uint_pos564(X,Y) get_gdat_uint((X),(Y),564) +#define get_gdat_ullong_pos564(X,Y) get_gdat_ullong((X),(Y),564) +#define get_gdat_ip_pos564(X,Y) get_gdat_ip((X),(Y),564) +#define get_gdat_ipv6_pos564(X,Y) get_gdat_ipv6((X),(Y),564) +#define get_gdat_string_pos564(X,Y) get_gdat_string((X),(Y),564) +#define get_gdat_v_str_pos564(X,Y) get_gdat_string((X),(Y),564) +#define get_gdat_bool_pos564(X,Y) get_gdat_bool((X),(Y),564) +#define get_gdat_int_pos564(X,Y) get_gdat_int((X),(Y),564) +#define get_gdat_llong_pos564(X,Y) get_gdat_llong((X),(Y),564) +#define get_gdat_float_pos564(X,Y) get_gdat_float((X),(Y),564) +#define get_gdat_uint_pos565(X,Y) get_gdat_uint((X),(Y),565) +#define get_gdat_ullong_pos565(X,Y) get_gdat_ullong((X),(Y),565) +#define get_gdat_ip_pos565(X,Y) get_gdat_ip((X),(Y),565) +#define get_gdat_ipv6_pos565(X,Y) get_gdat_ipv6((X),(Y),565) +#define get_gdat_string_pos565(X,Y) get_gdat_string((X),(Y),565) +#define get_gdat_v_str_pos565(X,Y) get_gdat_string((X),(Y),565) +#define get_gdat_bool_pos565(X,Y) get_gdat_bool((X),(Y),565) +#define get_gdat_int_pos565(X,Y) get_gdat_int((X),(Y),565) +#define get_gdat_llong_pos565(X,Y) get_gdat_llong((X),(Y),565) +#define get_gdat_float_pos565(X,Y) get_gdat_float((X),(Y),565) +#define get_gdat_uint_pos566(X,Y) get_gdat_uint((X),(Y),566) +#define get_gdat_ullong_pos566(X,Y) get_gdat_ullong((X),(Y),566) +#define get_gdat_ip_pos566(X,Y) get_gdat_ip((X),(Y),566) +#define get_gdat_ipv6_pos566(X,Y) get_gdat_ipv6((X),(Y),566) +#define get_gdat_string_pos566(X,Y) get_gdat_string((X),(Y),566) +#define get_gdat_v_str_pos566(X,Y) get_gdat_string((X),(Y),566) +#define get_gdat_bool_pos566(X,Y) get_gdat_bool((X),(Y),566) +#define get_gdat_int_pos566(X,Y) get_gdat_int((X),(Y),566) +#define get_gdat_llong_pos566(X,Y) get_gdat_llong((X),(Y),566) +#define get_gdat_float_pos566(X,Y) get_gdat_float((X),(Y),566) +#define get_gdat_uint_pos567(X,Y) get_gdat_uint((X),(Y),567) +#define get_gdat_ullong_pos567(X,Y) get_gdat_ullong((X),(Y),567) +#define get_gdat_ip_pos567(X,Y) get_gdat_ip((X),(Y),567) +#define get_gdat_ipv6_pos567(X,Y) get_gdat_ipv6((X),(Y),567) +#define get_gdat_string_pos567(X,Y) get_gdat_string((X),(Y),567) +#define get_gdat_v_str_pos567(X,Y) get_gdat_string((X),(Y),567) +#define get_gdat_bool_pos567(X,Y) get_gdat_bool((X),(Y),567) +#define get_gdat_int_pos567(X,Y) get_gdat_int((X),(Y),567) +#define get_gdat_llong_pos567(X,Y) get_gdat_llong((X),(Y),567) +#define get_gdat_float_pos567(X,Y) get_gdat_float((X),(Y),567) +#define get_gdat_uint_pos568(X,Y) get_gdat_uint((X),(Y),568) +#define get_gdat_ullong_pos568(X,Y) get_gdat_ullong((X),(Y),568) +#define get_gdat_ip_pos568(X,Y) get_gdat_ip((X),(Y),568) +#define get_gdat_ipv6_pos568(X,Y) get_gdat_ipv6((X),(Y),568) +#define get_gdat_string_pos568(X,Y) get_gdat_string((X),(Y),568) +#define get_gdat_v_str_pos568(X,Y) get_gdat_string((X),(Y),568) +#define get_gdat_bool_pos568(X,Y) get_gdat_bool((X),(Y),568) +#define get_gdat_int_pos568(X,Y) get_gdat_int((X),(Y),568) +#define get_gdat_llong_pos568(X,Y) get_gdat_llong((X),(Y),568) +#define get_gdat_float_pos568(X,Y) get_gdat_float((X),(Y),568) +#define get_gdat_uint_pos569(X,Y) get_gdat_uint((X),(Y),569) +#define get_gdat_ullong_pos569(X,Y) get_gdat_ullong((X),(Y),569) +#define get_gdat_ip_pos569(X,Y) get_gdat_ip((X),(Y),569) +#define get_gdat_ipv6_pos569(X,Y) get_gdat_ipv6((X),(Y),569) +#define get_gdat_string_pos569(X,Y) get_gdat_string((X),(Y),569) +#define get_gdat_v_str_pos569(X,Y) get_gdat_string((X),(Y),569) +#define get_gdat_bool_pos569(X,Y) get_gdat_bool((X),(Y),569) +#define get_gdat_int_pos569(X,Y) get_gdat_int((X),(Y),569) +#define get_gdat_llong_pos569(X,Y) get_gdat_llong((X),(Y),569) +#define get_gdat_float_pos569(X,Y) get_gdat_float((X),(Y),569) +#define get_gdat_uint_pos570(X,Y) get_gdat_uint((X),(Y),570) +#define get_gdat_ullong_pos570(X,Y) get_gdat_ullong((X),(Y),570) +#define get_gdat_ip_pos570(X,Y) get_gdat_ip((X),(Y),570) +#define get_gdat_ipv6_pos570(X,Y) get_gdat_ipv6((X),(Y),570) +#define get_gdat_string_pos570(X,Y) get_gdat_string((X),(Y),570) +#define get_gdat_v_str_pos570(X,Y) get_gdat_string((X),(Y),570) +#define get_gdat_bool_pos570(X,Y) get_gdat_bool((X),(Y),570) +#define get_gdat_int_pos570(X,Y) get_gdat_int((X),(Y),570) +#define get_gdat_llong_pos570(X,Y) get_gdat_llong((X),(Y),570) +#define get_gdat_float_pos570(X,Y) get_gdat_float((X),(Y),570) +#define get_gdat_uint_pos571(X,Y) get_gdat_uint((X),(Y),571) +#define get_gdat_ullong_pos571(X,Y) get_gdat_ullong((X),(Y),571) +#define get_gdat_ip_pos571(X,Y) get_gdat_ip((X),(Y),571) +#define get_gdat_ipv6_pos571(X,Y) get_gdat_ipv6((X),(Y),571) +#define get_gdat_string_pos571(X,Y) get_gdat_string((X),(Y),571) +#define get_gdat_v_str_pos571(X,Y) get_gdat_string((X),(Y),571) +#define get_gdat_bool_pos571(X,Y) get_gdat_bool((X),(Y),571) +#define get_gdat_int_pos571(X,Y) get_gdat_int((X),(Y),571) +#define get_gdat_llong_pos571(X,Y) get_gdat_llong((X),(Y),571) +#define get_gdat_float_pos571(X,Y) get_gdat_float((X),(Y),571) +#define get_gdat_uint_pos572(X,Y) get_gdat_uint((X),(Y),572) +#define get_gdat_ullong_pos572(X,Y) get_gdat_ullong((X),(Y),572) +#define get_gdat_ip_pos572(X,Y) get_gdat_ip((X),(Y),572) +#define get_gdat_ipv6_pos572(X,Y) get_gdat_ipv6((X),(Y),572) +#define get_gdat_string_pos572(X,Y) get_gdat_string((X),(Y),572) +#define get_gdat_v_str_pos572(X,Y) get_gdat_string((X),(Y),572) +#define get_gdat_bool_pos572(X,Y) get_gdat_bool((X),(Y),572) +#define get_gdat_int_pos572(X,Y) get_gdat_int((X),(Y),572) +#define get_gdat_llong_pos572(X,Y) get_gdat_llong((X),(Y),572) +#define get_gdat_float_pos572(X,Y) get_gdat_float((X),(Y),572) +#define get_gdat_uint_pos573(X,Y) get_gdat_uint((X),(Y),573) +#define get_gdat_ullong_pos573(X,Y) get_gdat_ullong((X),(Y),573) +#define get_gdat_ip_pos573(X,Y) get_gdat_ip((X),(Y),573) +#define get_gdat_ipv6_pos573(X,Y) get_gdat_ipv6((X),(Y),573) +#define get_gdat_string_pos573(X,Y) get_gdat_string((X),(Y),573) +#define get_gdat_v_str_pos573(X,Y) get_gdat_string((X),(Y),573) +#define get_gdat_bool_pos573(X,Y) get_gdat_bool((X),(Y),573) +#define get_gdat_int_pos573(X,Y) get_gdat_int((X),(Y),573) +#define get_gdat_llong_pos573(X,Y) get_gdat_llong((X),(Y),573) +#define get_gdat_float_pos573(X,Y) get_gdat_float((X),(Y),573) +#define get_gdat_uint_pos574(X,Y) get_gdat_uint((X),(Y),574) +#define get_gdat_ullong_pos574(X,Y) get_gdat_ullong((X),(Y),574) +#define get_gdat_ip_pos574(X,Y) get_gdat_ip((X),(Y),574) +#define get_gdat_ipv6_pos574(X,Y) get_gdat_ipv6((X),(Y),574) +#define get_gdat_string_pos574(X,Y) get_gdat_string((X),(Y),574) +#define get_gdat_v_str_pos574(X,Y) get_gdat_string((X),(Y),574) +#define get_gdat_bool_pos574(X,Y) get_gdat_bool((X),(Y),574) +#define get_gdat_int_pos574(X,Y) get_gdat_int((X),(Y),574) +#define get_gdat_llong_pos574(X,Y) get_gdat_llong((X),(Y),574) +#define get_gdat_float_pos574(X,Y) get_gdat_float((X),(Y),574) +#define get_gdat_uint_pos575(X,Y) get_gdat_uint((X),(Y),575) +#define get_gdat_ullong_pos575(X,Y) get_gdat_ullong((X),(Y),575) +#define get_gdat_ip_pos575(X,Y) get_gdat_ip((X),(Y),575) +#define get_gdat_ipv6_pos575(X,Y) get_gdat_ipv6((X),(Y),575) +#define get_gdat_string_pos575(X,Y) get_gdat_string((X),(Y),575) +#define get_gdat_v_str_pos575(X,Y) get_gdat_string((X),(Y),575) +#define get_gdat_bool_pos575(X,Y) get_gdat_bool((X),(Y),575) +#define get_gdat_int_pos575(X,Y) get_gdat_int((X),(Y),575) +#define get_gdat_llong_pos575(X,Y) get_gdat_llong((X),(Y),575) +#define get_gdat_float_pos575(X,Y) get_gdat_float((X),(Y),575) +#define get_gdat_uint_pos576(X,Y) get_gdat_uint((X),(Y),576) +#define get_gdat_ullong_pos576(X,Y) get_gdat_ullong((X),(Y),576) +#define get_gdat_ip_pos576(X,Y) get_gdat_ip((X),(Y),576) +#define get_gdat_ipv6_pos576(X,Y) get_gdat_ipv6((X),(Y),576) +#define get_gdat_string_pos576(X,Y) get_gdat_string((X),(Y),576) +#define get_gdat_v_str_pos576(X,Y) get_gdat_string((X),(Y),576) +#define get_gdat_bool_pos576(X,Y) get_gdat_bool((X),(Y),576) +#define get_gdat_int_pos576(X,Y) get_gdat_int((X),(Y),576) +#define get_gdat_llong_pos576(X,Y) get_gdat_llong((X),(Y),576) +#define get_gdat_float_pos576(X,Y) get_gdat_float((X),(Y),576) +#define get_gdat_uint_pos577(X,Y) get_gdat_uint((X),(Y),577) +#define get_gdat_ullong_pos577(X,Y) get_gdat_ullong((X),(Y),577) +#define get_gdat_ip_pos577(X,Y) get_gdat_ip((X),(Y),577) +#define get_gdat_ipv6_pos577(X,Y) get_gdat_ipv6((X),(Y),577) +#define get_gdat_string_pos577(X,Y) get_gdat_string((X),(Y),577) +#define get_gdat_v_str_pos577(X,Y) get_gdat_string((X),(Y),577) +#define get_gdat_bool_pos577(X,Y) get_gdat_bool((X),(Y),577) +#define get_gdat_int_pos577(X,Y) get_gdat_int((X),(Y),577) +#define get_gdat_llong_pos577(X,Y) get_gdat_llong((X),(Y),577) +#define get_gdat_float_pos577(X,Y) get_gdat_float((X),(Y),577) +#define get_gdat_uint_pos578(X,Y) get_gdat_uint((X),(Y),578) +#define get_gdat_ullong_pos578(X,Y) get_gdat_ullong((X),(Y),578) +#define get_gdat_ip_pos578(X,Y) get_gdat_ip((X),(Y),578) +#define get_gdat_ipv6_pos578(X,Y) get_gdat_ipv6((X),(Y),578) +#define get_gdat_string_pos578(X,Y) get_gdat_string((X),(Y),578) +#define get_gdat_v_str_pos578(X,Y) get_gdat_string((X),(Y),578) +#define get_gdat_bool_pos578(X,Y) get_gdat_bool((X),(Y),578) +#define get_gdat_int_pos578(X,Y) get_gdat_int((X),(Y),578) +#define get_gdat_llong_pos578(X,Y) get_gdat_llong((X),(Y),578) +#define get_gdat_float_pos578(X,Y) get_gdat_float((X),(Y),578) +#define get_gdat_uint_pos579(X,Y) get_gdat_uint((X),(Y),579) +#define get_gdat_ullong_pos579(X,Y) get_gdat_ullong((X),(Y),579) +#define get_gdat_ip_pos579(X,Y) get_gdat_ip((X),(Y),579) +#define get_gdat_ipv6_pos579(X,Y) get_gdat_ipv6((X),(Y),579) +#define get_gdat_string_pos579(X,Y) get_gdat_string((X),(Y),579) +#define get_gdat_v_str_pos579(X,Y) get_gdat_string((X),(Y),579) +#define get_gdat_bool_pos579(X,Y) get_gdat_bool((X),(Y),579) +#define get_gdat_int_pos579(X,Y) get_gdat_int((X),(Y),579) +#define get_gdat_llong_pos579(X,Y) get_gdat_llong((X),(Y),579) +#define get_gdat_float_pos579(X,Y) get_gdat_float((X),(Y),579) +#define get_gdat_uint_pos580(X,Y) get_gdat_uint((X),(Y),580) +#define get_gdat_ullong_pos580(X,Y) get_gdat_ullong((X),(Y),580) +#define get_gdat_ip_pos580(X,Y) get_gdat_ip((X),(Y),580) +#define get_gdat_ipv6_pos580(X,Y) get_gdat_ipv6((X),(Y),580) +#define get_gdat_string_pos580(X,Y) get_gdat_string((X),(Y),580) +#define get_gdat_v_str_pos580(X,Y) get_gdat_string((X),(Y),580) +#define get_gdat_bool_pos580(X,Y) get_gdat_bool((X),(Y),580) +#define get_gdat_int_pos580(X,Y) get_gdat_int((X),(Y),580) +#define get_gdat_llong_pos580(X,Y) get_gdat_llong((X),(Y),580) +#define get_gdat_float_pos580(X,Y) get_gdat_float((X),(Y),580) +#define get_gdat_uint_pos581(X,Y) get_gdat_uint((X),(Y),581) +#define get_gdat_ullong_pos581(X,Y) get_gdat_ullong((X),(Y),581) +#define get_gdat_ip_pos581(X,Y) get_gdat_ip((X),(Y),581) +#define get_gdat_ipv6_pos581(X,Y) get_gdat_ipv6((X),(Y),581) +#define get_gdat_string_pos581(X,Y) get_gdat_string((X),(Y),581) +#define get_gdat_v_str_pos581(X,Y) get_gdat_string((X),(Y),581) +#define get_gdat_bool_pos581(X,Y) get_gdat_bool((X),(Y),581) +#define get_gdat_int_pos581(X,Y) get_gdat_int((X),(Y),581) +#define get_gdat_llong_pos581(X,Y) get_gdat_llong((X),(Y),581) +#define get_gdat_float_pos581(X,Y) get_gdat_float((X),(Y),581) +#define get_gdat_uint_pos582(X,Y) get_gdat_uint((X),(Y),582) +#define get_gdat_ullong_pos582(X,Y) get_gdat_ullong((X),(Y),582) +#define get_gdat_ip_pos582(X,Y) get_gdat_ip((X),(Y),582) +#define get_gdat_ipv6_pos582(X,Y) get_gdat_ipv6((X),(Y),582) +#define get_gdat_string_pos582(X,Y) get_gdat_string((X),(Y),582) +#define get_gdat_v_str_pos582(X,Y) get_gdat_string((X),(Y),582) +#define get_gdat_bool_pos582(X,Y) get_gdat_bool((X),(Y),582) +#define get_gdat_int_pos582(X,Y) get_gdat_int((X),(Y),582) +#define get_gdat_llong_pos582(X,Y) get_gdat_llong((X),(Y),582) +#define get_gdat_float_pos582(X,Y) get_gdat_float((X),(Y),582) +#define get_gdat_uint_pos583(X,Y) get_gdat_uint((X),(Y),583) +#define get_gdat_ullong_pos583(X,Y) get_gdat_ullong((X),(Y),583) +#define get_gdat_ip_pos583(X,Y) get_gdat_ip((X),(Y),583) +#define get_gdat_ipv6_pos583(X,Y) get_gdat_ipv6((X),(Y),583) +#define get_gdat_string_pos583(X,Y) get_gdat_string((X),(Y),583) +#define get_gdat_v_str_pos583(X,Y) get_gdat_string((X),(Y),583) +#define get_gdat_bool_pos583(X,Y) get_gdat_bool((X),(Y),583) +#define get_gdat_int_pos583(X,Y) get_gdat_int((X),(Y),583) +#define get_gdat_llong_pos583(X,Y) get_gdat_llong((X),(Y),583) +#define get_gdat_float_pos583(X,Y) get_gdat_float((X),(Y),583) +#define get_gdat_uint_pos584(X,Y) get_gdat_uint((X),(Y),584) +#define get_gdat_ullong_pos584(X,Y) get_gdat_ullong((X),(Y),584) +#define get_gdat_ip_pos584(X,Y) get_gdat_ip((X),(Y),584) +#define get_gdat_ipv6_pos584(X,Y) get_gdat_ipv6((X),(Y),584) +#define get_gdat_string_pos584(X,Y) get_gdat_string((X),(Y),584) +#define get_gdat_v_str_pos584(X,Y) get_gdat_string((X),(Y),584) +#define get_gdat_bool_pos584(X,Y) get_gdat_bool((X),(Y),584) +#define get_gdat_int_pos584(X,Y) get_gdat_int((X),(Y),584) +#define get_gdat_llong_pos584(X,Y) get_gdat_llong((X),(Y),584) +#define get_gdat_float_pos584(X,Y) get_gdat_float((X),(Y),584) +#define get_gdat_uint_pos585(X,Y) get_gdat_uint((X),(Y),585) +#define get_gdat_ullong_pos585(X,Y) get_gdat_ullong((X),(Y),585) +#define get_gdat_ip_pos585(X,Y) get_gdat_ip((X),(Y),585) +#define get_gdat_ipv6_pos585(X,Y) get_gdat_ipv6((X),(Y),585) +#define get_gdat_string_pos585(X,Y) get_gdat_string((X),(Y),585) +#define get_gdat_v_str_pos585(X,Y) get_gdat_string((X),(Y),585) +#define get_gdat_bool_pos585(X,Y) get_gdat_bool((X),(Y),585) +#define get_gdat_int_pos585(X,Y) get_gdat_int((X),(Y),585) +#define get_gdat_llong_pos585(X,Y) get_gdat_llong((X),(Y),585) +#define get_gdat_float_pos585(X,Y) get_gdat_float((X),(Y),585) +#define get_gdat_uint_pos586(X,Y) get_gdat_uint((X),(Y),586) +#define get_gdat_ullong_pos586(X,Y) get_gdat_ullong((X),(Y),586) +#define get_gdat_ip_pos586(X,Y) get_gdat_ip((X),(Y),586) +#define get_gdat_ipv6_pos586(X,Y) get_gdat_ipv6((X),(Y),586) +#define get_gdat_string_pos586(X,Y) get_gdat_string((X),(Y),586) +#define get_gdat_v_str_pos586(X,Y) get_gdat_string((X),(Y),586) +#define get_gdat_bool_pos586(X,Y) get_gdat_bool((X),(Y),586) +#define get_gdat_int_pos586(X,Y) get_gdat_int((X),(Y),586) +#define get_gdat_llong_pos586(X,Y) get_gdat_llong((X),(Y),586) +#define get_gdat_float_pos586(X,Y) get_gdat_float((X),(Y),586) +#define get_gdat_uint_pos587(X,Y) get_gdat_uint((X),(Y),587) +#define get_gdat_ullong_pos587(X,Y) get_gdat_ullong((X),(Y),587) +#define get_gdat_ip_pos587(X,Y) get_gdat_ip((X),(Y),587) +#define get_gdat_ipv6_pos587(X,Y) get_gdat_ipv6((X),(Y),587) +#define get_gdat_string_pos587(X,Y) get_gdat_string((X),(Y),587) +#define get_gdat_v_str_pos587(X,Y) get_gdat_string((X),(Y),587) +#define get_gdat_bool_pos587(X,Y) get_gdat_bool((X),(Y),587) +#define get_gdat_int_pos587(X,Y) get_gdat_int((X),(Y),587) +#define get_gdat_llong_pos587(X,Y) get_gdat_llong((X),(Y),587) +#define get_gdat_float_pos587(X,Y) get_gdat_float((X),(Y),587) +#define get_gdat_uint_pos588(X,Y) get_gdat_uint((X),(Y),588) +#define get_gdat_ullong_pos588(X,Y) get_gdat_ullong((X),(Y),588) +#define get_gdat_ip_pos588(X,Y) get_gdat_ip((X),(Y),588) +#define get_gdat_ipv6_pos588(X,Y) get_gdat_ipv6((X),(Y),588) +#define get_gdat_string_pos588(X,Y) get_gdat_string((X),(Y),588) +#define get_gdat_v_str_pos588(X,Y) get_gdat_string((X),(Y),588) +#define get_gdat_bool_pos588(X,Y) get_gdat_bool((X),(Y),588) +#define get_gdat_int_pos588(X,Y) get_gdat_int((X),(Y),588) +#define get_gdat_llong_pos588(X,Y) get_gdat_llong((X),(Y),588) +#define get_gdat_float_pos588(X,Y) get_gdat_float((X),(Y),588) +#define get_gdat_uint_pos589(X,Y) get_gdat_uint((X),(Y),589) +#define get_gdat_ullong_pos589(X,Y) get_gdat_ullong((X),(Y),589) +#define get_gdat_ip_pos589(X,Y) get_gdat_ip((X),(Y),589) +#define get_gdat_ipv6_pos589(X,Y) get_gdat_ipv6((X),(Y),589) +#define get_gdat_string_pos589(X,Y) get_gdat_string((X),(Y),589) +#define get_gdat_v_str_pos589(X,Y) get_gdat_string((X),(Y),589) +#define get_gdat_bool_pos589(X,Y) get_gdat_bool((X),(Y),589) +#define get_gdat_int_pos589(X,Y) get_gdat_int((X),(Y),589) +#define get_gdat_llong_pos589(X,Y) get_gdat_llong((X),(Y),589) +#define get_gdat_float_pos589(X,Y) get_gdat_float((X),(Y),589) +#define get_gdat_uint_pos590(X,Y) get_gdat_uint((X),(Y),590) +#define get_gdat_ullong_pos590(X,Y) get_gdat_ullong((X),(Y),590) +#define get_gdat_ip_pos590(X,Y) get_gdat_ip((X),(Y),590) +#define get_gdat_ipv6_pos590(X,Y) get_gdat_ipv6((X),(Y),590) +#define get_gdat_string_pos590(X,Y) get_gdat_string((X),(Y),590) +#define get_gdat_v_str_pos590(X,Y) get_gdat_string((X),(Y),590) +#define get_gdat_bool_pos590(X,Y) get_gdat_bool((X),(Y),590) +#define get_gdat_int_pos590(X,Y) get_gdat_int((X),(Y),590) +#define get_gdat_llong_pos590(X,Y) get_gdat_llong((X),(Y),590) +#define get_gdat_float_pos590(X,Y) get_gdat_float((X),(Y),590) +#define get_gdat_uint_pos591(X,Y) get_gdat_uint((X),(Y),591) +#define get_gdat_ullong_pos591(X,Y) get_gdat_ullong((X),(Y),591) +#define get_gdat_ip_pos591(X,Y) get_gdat_ip((X),(Y),591) +#define get_gdat_ipv6_pos591(X,Y) get_gdat_ipv6((X),(Y),591) +#define get_gdat_string_pos591(X,Y) get_gdat_string((X),(Y),591) +#define get_gdat_v_str_pos591(X,Y) get_gdat_string((X),(Y),591) +#define get_gdat_bool_pos591(X,Y) get_gdat_bool((X),(Y),591) +#define get_gdat_int_pos591(X,Y) get_gdat_int((X),(Y),591) +#define get_gdat_llong_pos591(X,Y) get_gdat_llong((X),(Y),591) +#define get_gdat_float_pos591(X,Y) get_gdat_float((X),(Y),591) +#define get_gdat_uint_pos592(X,Y) get_gdat_uint((X),(Y),592) +#define get_gdat_ullong_pos592(X,Y) get_gdat_ullong((X),(Y),592) +#define get_gdat_ip_pos592(X,Y) get_gdat_ip((X),(Y),592) +#define get_gdat_ipv6_pos592(X,Y) get_gdat_ipv6((X),(Y),592) +#define get_gdat_string_pos592(X,Y) get_gdat_string((X),(Y),592) +#define get_gdat_v_str_pos592(X,Y) get_gdat_string((X),(Y),592) +#define get_gdat_bool_pos592(X,Y) get_gdat_bool((X),(Y),592) +#define get_gdat_int_pos592(X,Y) get_gdat_int((X),(Y),592) +#define get_gdat_llong_pos592(X,Y) get_gdat_llong((X),(Y),592) +#define get_gdat_float_pos592(X,Y) get_gdat_float((X),(Y),592) +#define get_gdat_uint_pos593(X,Y) get_gdat_uint((X),(Y),593) +#define get_gdat_ullong_pos593(X,Y) get_gdat_ullong((X),(Y),593) +#define get_gdat_ip_pos593(X,Y) get_gdat_ip((X),(Y),593) +#define get_gdat_ipv6_pos593(X,Y) get_gdat_ipv6((X),(Y),593) +#define get_gdat_string_pos593(X,Y) get_gdat_string((X),(Y),593) +#define get_gdat_v_str_pos593(X,Y) get_gdat_string((X),(Y),593) +#define get_gdat_bool_pos593(X,Y) get_gdat_bool((X),(Y),593) +#define get_gdat_int_pos593(X,Y) get_gdat_int((X),(Y),593) +#define get_gdat_llong_pos593(X,Y) get_gdat_llong((X),(Y),593) +#define get_gdat_float_pos593(X,Y) get_gdat_float((X),(Y),593) +#define get_gdat_uint_pos594(X,Y) get_gdat_uint((X),(Y),594) +#define get_gdat_ullong_pos594(X,Y) get_gdat_ullong((X),(Y),594) +#define get_gdat_ip_pos594(X,Y) get_gdat_ip((X),(Y),594) +#define get_gdat_ipv6_pos594(X,Y) get_gdat_ipv6((X),(Y),594) +#define get_gdat_string_pos594(X,Y) get_gdat_string((X),(Y),594) +#define get_gdat_v_str_pos594(X,Y) get_gdat_string((X),(Y),594) +#define get_gdat_bool_pos594(X,Y) get_gdat_bool((X),(Y),594) +#define get_gdat_int_pos594(X,Y) get_gdat_int((X),(Y),594) +#define get_gdat_llong_pos594(X,Y) get_gdat_llong((X),(Y),594) +#define get_gdat_float_pos594(X,Y) get_gdat_float((X),(Y),594) +#define get_gdat_uint_pos595(X,Y) get_gdat_uint((X),(Y),595) +#define get_gdat_ullong_pos595(X,Y) get_gdat_ullong((X),(Y),595) +#define get_gdat_ip_pos595(X,Y) get_gdat_ip((X),(Y),595) +#define get_gdat_ipv6_pos595(X,Y) get_gdat_ipv6((X),(Y),595) +#define get_gdat_string_pos595(X,Y) get_gdat_string((X),(Y),595) +#define get_gdat_v_str_pos595(X,Y) get_gdat_string((X),(Y),595) +#define get_gdat_bool_pos595(X,Y) get_gdat_bool((X),(Y),595) +#define get_gdat_int_pos595(X,Y) get_gdat_int((X),(Y),595) +#define get_gdat_llong_pos595(X,Y) get_gdat_llong((X),(Y),595) +#define get_gdat_float_pos595(X,Y) get_gdat_float((X),(Y),595) +#define get_gdat_uint_pos596(X,Y) get_gdat_uint((X),(Y),596) +#define get_gdat_ullong_pos596(X,Y) get_gdat_ullong((X),(Y),596) +#define get_gdat_ip_pos596(X,Y) get_gdat_ip((X),(Y),596) +#define get_gdat_ipv6_pos596(X,Y) get_gdat_ipv6((X),(Y),596) +#define get_gdat_string_pos596(X,Y) get_gdat_string((X),(Y),596) +#define get_gdat_v_str_pos596(X,Y) get_gdat_string((X),(Y),596) +#define get_gdat_bool_pos596(X,Y) get_gdat_bool((X),(Y),596) +#define get_gdat_int_pos596(X,Y) get_gdat_int((X),(Y),596) +#define get_gdat_llong_pos596(X,Y) get_gdat_llong((X),(Y),596) +#define get_gdat_float_pos596(X,Y) get_gdat_float((X),(Y),596) +#define get_gdat_uint_pos597(X,Y) get_gdat_uint((X),(Y),597) +#define get_gdat_ullong_pos597(X,Y) get_gdat_ullong((X),(Y),597) +#define get_gdat_ip_pos597(X,Y) get_gdat_ip((X),(Y),597) +#define get_gdat_ipv6_pos597(X,Y) get_gdat_ipv6((X),(Y),597) +#define get_gdat_string_pos597(X,Y) get_gdat_string((X),(Y),597) +#define get_gdat_v_str_pos597(X,Y) get_gdat_string((X),(Y),597) +#define get_gdat_bool_pos597(X,Y) get_gdat_bool((X),(Y),597) +#define get_gdat_int_pos597(X,Y) get_gdat_int((X),(Y),597) +#define get_gdat_llong_pos597(X,Y) get_gdat_llong((X),(Y),597) +#define get_gdat_float_pos597(X,Y) get_gdat_float((X),(Y),597) +#define get_gdat_uint_pos598(X,Y) get_gdat_uint((X),(Y),598) +#define get_gdat_ullong_pos598(X,Y) get_gdat_ullong((X),(Y),598) +#define get_gdat_ip_pos598(X,Y) get_gdat_ip((X),(Y),598) +#define get_gdat_ipv6_pos598(X,Y) get_gdat_ipv6((X),(Y),598) +#define get_gdat_string_pos598(X,Y) get_gdat_string((X),(Y),598) +#define get_gdat_v_str_pos598(X,Y) get_gdat_string((X),(Y),598) +#define get_gdat_bool_pos598(X,Y) get_gdat_bool((X),(Y),598) +#define get_gdat_int_pos598(X,Y) get_gdat_int((X),(Y),598) +#define get_gdat_llong_pos598(X,Y) get_gdat_llong((X),(Y),598) +#define get_gdat_float_pos598(X,Y) get_gdat_float((X),(Y),598) +#define get_gdat_uint_pos599(X,Y) get_gdat_uint((X),(Y),599) +#define get_gdat_ullong_pos599(X,Y) get_gdat_ullong((X),(Y),599) +#define get_gdat_ip_pos599(X,Y) get_gdat_ip((X),(Y),599) +#define get_gdat_ipv6_pos599(X,Y) get_gdat_ipv6((X),(Y),599) +#define get_gdat_string_pos599(X,Y) get_gdat_string((X),(Y),599) +#define get_gdat_v_str_pos599(X,Y) get_gdat_string((X),(Y),599) +#define get_gdat_bool_pos599(X,Y) get_gdat_bool((X),(Y),599) +#define get_gdat_int_pos599(X,Y) get_gdat_int((X),(Y),599) +#define get_gdat_llong_pos599(X,Y) get_gdat_llong((X),(Y),599) +#define get_gdat_float_pos599(X,Y) get_gdat_float((X),(Y),599) +#define get_gdat_uint_pos600(X,Y) get_gdat_uint((X),(Y),600) +#define get_gdat_ullong_pos600(X,Y) get_gdat_ullong((X),(Y),600) +#define get_gdat_ip_pos600(X,Y) get_gdat_ip((X),(Y),600) +#define get_gdat_ipv6_pos600(X,Y) get_gdat_ipv6((X),(Y),600) +#define get_gdat_string_pos600(X,Y) get_gdat_string((X),(Y),600) +#define get_gdat_v_str_pos600(X,Y) get_gdat_string((X),(Y),600) +#define get_gdat_bool_pos600(X,Y) get_gdat_bool((X),(Y),600) +#define get_gdat_int_pos600(X,Y) get_gdat_int((X),(Y),600) +#define get_gdat_llong_pos600(X,Y) get_gdat_llong((X),(Y),600) +#define get_gdat_float_pos600(X,Y) get_gdat_float((X),(Y),600) +#define get_gdat_uint_pos601(X,Y) get_gdat_uint((X),(Y),601) +#define get_gdat_ullong_pos601(X,Y) get_gdat_ullong((X),(Y),601) +#define get_gdat_ip_pos601(X,Y) get_gdat_ip((X),(Y),601) +#define get_gdat_ipv6_pos601(X,Y) get_gdat_ipv6((X),(Y),601) +#define get_gdat_string_pos601(X,Y) get_gdat_string((X),(Y),601) +#define get_gdat_v_str_pos601(X,Y) get_gdat_string((X),(Y),601) +#define get_gdat_bool_pos601(X,Y) get_gdat_bool((X),(Y),601) +#define get_gdat_int_pos601(X,Y) get_gdat_int((X),(Y),601) +#define get_gdat_llong_pos601(X,Y) get_gdat_llong((X),(Y),601) +#define get_gdat_float_pos601(X,Y) get_gdat_float((X),(Y),601) +#define get_gdat_uint_pos602(X,Y) get_gdat_uint((X),(Y),602) +#define get_gdat_ullong_pos602(X,Y) get_gdat_ullong((X),(Y),602) +#define get_gdat_ip_pos602(X,Y) get_gdat_ip((X),(Y),602) +#define get_gdat_ipv6_pos602(X,Y) get_gdat_ipv6((X),(Y),602) +#define get_gdat_string_pos602(X,Y) get_gdat_string((X),(Y),602) +#define get_gdat_v_str_pos602(X,Y) get_gdat_string((X),(Y),602) +#define get_gdat_bool_pos602(X,Y) get_gdat_bool((X),(Y),602) +#define get_gdat_int_pos602(X,Y) get_gdat_int((X),(Y),602) +#define get_gdat_llong_pos602(X,Y) get_gdat_llong((X),(Y),602) +#define get_gdat_float_pos602(X,Y) get_gdat_float((X),(Y),602) +#define get_gdat_uint_pos603(X,Y) get_gdat_uint((X),(Y),603) +#define get_gdat_ullong_pos603(X,Y) get_gdat_ullong((X),(Y),603) +#define get_gdat_ip_pos603(X,Y) get_gdat_ip((X),(Y),603) +#define get_gdat_ipv6_pos603(X,Y) get_gdat_ipv6((X),(Y),603) +#define get_gdat_string_pos603(X,Y) get_gdat_string((X),(Y),603) +#define get_gdat_v_str_pos603(X,Y) get_gdat_string((X),(Y),603) +#define get_gdat_bool_pos603(X,Y) get_gdat_bool((X),(Y),603) +#define get_gdat_int_pos603(X,Y) get_gdat_int((X),(Y),603) +#define get_gdat_llong_pos603(X,Y) get_gdat_llong((X),(Y),603) +#define get_gdat_float_pos603(X,Y) get_gdat_float((X),(Y),603) +#define get_gdat_uint_pos604(X,Y) get_gdat_uint((X),(Y),604) +#define get_gdat_ullong_pos604(X,Y) get_gdat_ullong((X),(Y),604) +#define get_gdat_ip_pos604(X,Y) get_gdat_ip((X),(Y),604) +#define get_gdat_ipv6_pos604(X,Y) get_gdat_ipv6((X),(Y),604) +#define get_gdat_string_pos604(X,Y) get_gdat_string((X),(Y),604) +#define get_gdat_v_str_pos604(X,Y) get_gdat_string((X),(Y),604) +#define get_gdat_bool_pos604(X,Y) get_gdat_bool((X),(Y),604) +#define get_gdat_int_pos604(X,Y) get_gdat_int((X),(Y),604) +#define get_gdat_llong_pos604(X,Y) get_gdat_llong((X),(Y),604) +#define get_gdat_float_pos604(X,Y) get_gdat_float((X),(Y),604) +#define get_gdat_uint_pos605(X,Y) get_gdat_uint((X),(Y),605) +#define get_gdat_ullong_pos605(X,Y) get_gdat_ullong((X),(Y),605) +#define get_gdat_ip_pos605(X,Y) get_gdat_ip((X),(Y),605) +#define get_gdat_ipv6_pos605(X,Y) get_gdat_ipv6((X),(Y),605) +#define get_gdat_string_pos605(X,Y) get_gdat_string((X),(Y),605) +#define get_gdat_v_str_pos605(X,Y) get_gdat_string((X),(Y),605) +#define get_gdat_bool_pos605(X,Y) get_gdat_bool((X),(Y),605) +#define get_gdat_int_pos605(X,Y) get_gdat_int((X),(Y),605) +#define get_gdat_llong_pos605(X,Y) get_gdat_llong((X),(Y),605) +#define get_gdat_float_pos605(X,Y) get_gdat_float((X),(Y),605) +#define get_gdat_uint_pos606(X,Y) get_gdat_uint((X),(Y),606) +#define get_gdat_ullong_pos606(X,Y) get_gdat_ullong((X),(Y),606) +#define get_gdat_ip_pos606(X,Y) get_gdat_ip((X),(Y),606) +#define get_gdat_ipv6_pos606(X,Y) get_gdat_ipv6((X),(Y),606) +#define get_gdat_string_pos606(X,Y) get_gdat_string((X),(Y),606) +#define get_gdat_v_str_pos606(X,Y) get_gdat_string((X),(Y),606) +#define get_gdat_bool_pos606(X,Y) get_gdat_bool((X),(Y),606) +#define get_gdat_int_pos606(X,Y) get_gdat_int((X),(Y),606) +#define get_gdat_llong_pos606(X,Y) get_gdat_llong((X),(Y),606) +#define get_gdat_float_pos606(X,Y) get_gdat_float((X),(Y),606) +#define get_gdat_uint_pos607(X,Y) get_gdat_uint((X),(Y),607) +#define get_gdat_ullong_pos607(X,Y) get_gdat_ullong((X),(Y),607) +#define get_gdat_ip_pos607(X,Y) get_gdat_ip((X),(Y),607) +#define get_gdat_ipv6_pos607(X,Y) get_gdat_ipv6((X),(Y),607) +#define get_gdat_string_pos607(X,Y) get_gdat_string((X),(Y),607) +#define get_gdat_v_str_pos607(X,Y) get_gdat_string((X),(Y),607) +#define get_gdat_bool_pos607(X,Y) get_gdat_bool((X),(Y),607) +#define get_gdat_int_pos607(X,Y) get_gdat_int((X),(Y),607) +#define get_gdat_llong_pos607(X,Y) get_gdat_llong((X),(Y),607) +#define get_gdat_float_pos607(X,Y) get_gdat_float((X),(Y),607) +#define get_gdat_uint_pos608(X,Y) get_gdat_uint((X),(Y),608) +#define get_gdat_ullong_pos608(X,Y) get_gdat_ullong((X),(Y),608) +#define get_gdat_ip_pos608(X,Y) get_gdat_ip((X),(Y),608) +#define get_gdat_ipv6_pos608(X,Y) get_gdat_ipv6((X),(Y),608) +#define get_gdat_string_pos608(X,Y) get_gdat_string((X),(Y),608) +#define get_gdat_v_str_pos608(X,Y) get_gdat_string((X),(Y),608) +#define get_gdat_bool_pos608(X,Y) get_gdat_bool((X),(Y),608) +#define get_gdat_int_pos608(X,Y) get_gdat_int((X),(Y),608) +#define get_gdat_llong_pos608(X,Y) get_gdat_llong((X),(Y),608) +#define get_gdat_float_pos608(X,Y) get_gdat_float((X),(Y),608) +#define get_gdat_uint_pos609(X,Y) get_gdat_uint((X),(Y),609) +#define get_gdat_ullong_pos609(X,Y) get_gdat_ullong((X),(Y),609) +#define get_gdat_ip_pos609(X,Y) get_gdat_ip((X),(Y),609) +#define get_gdat_ipv6_pos609(X,Y) get_gdat_ipv6((X),(Y),609) +#define get_gdat_string_pos609(X,Y) get_gdat_string((X),(Y),609) +#define get_gdat_v_str_pos609(X,Y) get_gdat_string((X),(Y),609) +#define get_gdat_bool_pos609(X,Y) get_gdat_bool((X),(Y),609) +#define get_gdat_int_pos609(X,Y) get_gdat_int((X),(Y),609) +#define get_gdat_llong_pos609(X,Y) get_gdat_llong((X),(Y),609) +#define get_gdat_float_pos609(X,Y) get_gdat_float((X),(Y),609) +#define get_gdat_uint_pos610(X,Y) get_gdat_uint((X),(Y),610) +#define get_gdat_ullong_pos610(X,Y) get_gdat_ullong((X),(Y),610) +#define get_gdat_ip_pos610(X,Y) get_gdat_ip((X),(Y),610) +#define get_gdat_ipv6_pos610(X,Y) get_gdat_ipv6((X),(Y),610) +#define get_gdat_string_pos610(X,Y) get_gdat_string((X),(Y),610) +#define get_gdat_v_str_pos610(X,Y) get_gdat_string((X),(Y),610) +#define get_gdat_bool_pos610(X,Y) get_gdat_bool((X),(Y),610) +#define get_gdat_int_pos610(X,Y) get_gdat_int((X),(Y),610) +#define get_gdat_llong_pos610(X,Y) get_gdat_llong((X),(Y),610) +#define get_gdat_float_pos610(X,Y) get_gdat_float((X),(Y),610) +#define get_gdat_uint_pos611(X,Y) get_gdat_uint((X),(Y),611) +#define get_gdat_ullong_pos611(X,Y) get_gdat_ullong((X),(Y),611) +#define get_gdat_ip_pos611(X,Y) get_gdat_ip((X),(Y),611) +#define get_gdat_ipv6_pos611(X,Y) get_gdat_ipv6((X),(Y),611) +#define get_gdat_string_pos611(X,Y) get_gdat_string((X),(Y),611) +#define get_gdat_v_str_pos611(X,Y) get_gdat_string((X),(Y),611) +#define get_gdat_bool_pos611(X,Y) get_gdat_bool((X),(Y),611) +#define get_gdat_int_pos611(X,Y) get_gdat_int((X),(Y),611) +#define get_gdat_llong_pos611(X,Y) get_gdat_llong((X),(Y),611) +#define get_gdat_float_pos611(X,Y) get_gdat_float((X),(Y),611) +#define get_gdat_uint_pos612(X,Y) get_gdat_uint((X),(Y),612) +#define get_gdat_ullong_pos612(X,Y) get_gdat_ullong((X),(Y),612) +#define get_gdat_ip_pos612(X,Y) get_gdat_ip((X),(Y),612) +#define get_gdat_ipv6_pos612(X,Y) get_gdat_ipv6((X),(Y),612) +#define get_gdat_string_pos612(X,Y) get_gdat_string((X),(Y),612) +#define get_gdat_v_str_pos612(X,Y) get_gdat_string((X),(Y),612) +#define get_gdat_bool_pos612(X,Y) get_gdat_bool((X),(Y),612) +#define get_gdat_int_pos612(X,Y) get_gdat_int((X),(Y),612) +#define get_gdat_llong_pos612(X,Y) get_gdat_llong((X),(Y),612) +#define get_gdat_float_pos612(X,Y) get_gdat_float((X),(Y),612) +#define get_gdat_uint_pos613(X,Y) get_gdat_uint((X),(Y),613) +#define get_gdat_ullong_pos613(X,Y) get_gdat_ullong((X),(Y),613) +#define get_gdat_ip_pos613(X,Y) get_gdat_ip((X),(Y),613) +#define get_gdat_ipv6_pos613(X,Y) get_gdat_ipv6((X),(Y),613) +#define get_gdat_string_pos613(X,Y) get_gdat_string((X),(Y),613) +#define get_gdat_v_str_pos613(X,Y) get_gdat_string((X),(Y),613) +#define get_gdat_bool_pos613(X,Y) get_gdat_bool((X),(Y),613) +#define get_gdat_int_pos613(X,Y) get_gdat_int((X),(Y),613) +#define get_gdat_llong_pos613(X,Y) get_gdat_llong((X),(Y),613) +#define get_gdat_float_pos613(X,Y) get_gdat_float((X),(Y),613) +#define get_gdat_uint_pos614(X,Y) get_gdat_uint((X),(Y),614) +#define get_gdat_ullong_pos614(X,Y) get_gdat_ullong((X),(Y),614) +#define get_gdat_ip_pos614(X,Y) get_gdat_ip((X),(Y),614) +#define get_gdat_ipv6_pos614(X,Y) get_gdat_ipv6((X),(Y),614) +#define get_gdat_string_pos614(X,Y) get_gdat_string((X),(Y),614) +#define get_gdat_v_str_pos614(X,Y) get_gdat_string((X),(Y),614) +#define get_gdat_bool_pos614(X,Y) get_gdat_bool((X),(Y),614) +#define get_gdat_int_pos614(X,Y) get_gdat_int((X),(Y),614) +#define get_gdat_llong_pos614(X,Y) get_gdat_llong((X),(Y),614) +#define get_gdat_float_pos614(X,Y) get_gdat_float((X),(Y),614) +#define get_gdat_uint_pos615(X,Y) get_gdat_uint((X),(Y),615) +#define get_gdat_ullong_pos615(X,Y) get_gdat_ullong((X),(Y),615) +#define get_gdat_ip_pos615(X,Y) get_gdat_ip((X),(Y),615) +#define get_gdat_ipv6_pos615(X,Y) get_gdat_ipv6((X),(Y),615) +#define get_gdat_string_pos615(X,Y) get_gdat_string((X),(Y),615) +#define get_gdat_v_str_pos615(X,Y) get_gdat_string((X),(Y),615) +#define get_gdat_bool_pos615(X,Y) get_gdat_bool((X),(Y),615) +#define get_gdat_int_pos615(X,Y) get_gdat_int((X),(Y),615) +#define get_gdat_llong_pos615(X,Y) get_gdat_llong((X),(Y),615) +#define get_gdat_float_pos615(X,Y) get_gdat_float((X),(Y),615) +#define get_gdat_uint_pos616(X,Y) get_gdat_uint((X),(Y),616) +#define get_gdat_ullong_pos616(X,Y) get_gdat_ullong((X),(Y),616) +#define get_gdat_ip_pos616(X,Y) get_gdat_ip((X),(Y),616) +#define get_gdat_ipv6_pos616(X,Y) get_gdat_ipv6((X),(Y),616) +#define get_gdat_string_pos616(X,Y) get_gdat_string((X),(Y),616) +#define get_gdat_v_str_pos616(X,Y) get_gdat_string((X),(Y),616) +#define get_gdat_bool_pos616(X,Y) get_gdat_bool((X),(Y),616) +#define get_gdat_int_pos616(X,Y) get_gdat_int((X),(Y),616) +#define get_gdat_llong_pos616(X,Y) get_gdat_llong((X),(Y),616) +#define get_gdat_float_pos616(X,Y) get_gdat_float((X),(Y),616) +#define get_gdat_uint_pos617(X,Y) get_gdat_uint((X),(Y),617) +#define get_gdat_ullong_pos617(X,Y) get_gdat_ullong((X),(Y),617) +#define get_gdat_ip_pos617(X,Y) get_gdat_ip((X),(Y),617) +#define get_gdat_ipv6_pos617(X,Y) get_gdat_ipv6((X),(Y),617) +#define get_gdat_string_pos617(X,Y) get_gdat_string((X),(Y),617) +#define get_gdat_v_str_pos617(X,Y) get_gdat_string((X),(Y),617) +#define get_gdat_bool_pos617(X,Y) get_gdat_bool((X),(Y),617) +#define get_gdat_int_pos617(X,Y) get_gdat_int((X),(Y),617) +#define get_gdat_llong_pos617(X,Y) get_gdat_llong((X),(Y),617) +#define get_gdat_float_pos617(X,Y) get_gdat_float((X),(Y),617) +#define get_gdat_uint_pos618(X,Y) get_gdat_uint((X),(Y),618) +#define get_gdat_ullong_pos618(X,Y) get_gdat_ullong((X),(Y),618) +#define get_gdat_ip_pos618(X,Y) get_gdat_ip((X),(Y),618) +#define get_gdat_ipv6_pos618(X,Y) get_gdat_ipv6((X),(Y),618) +#define get_gdat_string_pos618(X,Y) get_gdat_string((X),(Y),618) +#define get_gdat_v_str_pos618(X,Y) get_gdat_string((X),(Y),618) +#define get_gdat_bool_pos618(X,Y) get_gdat_bool((X),(Y),618) +#define get_gdat_int_pos618(X,Y) get_gdat_int((X),(Y),618) +#define get_gdat_llong_pos618(X,Y) get_gdat_llong((X),(Y),618) +#define get_gdat_float_pos618(X,Y) get_gdat_float((X),(Y),618) +#define get_gdat_uint_pos619(X,Y) get_gdat_uint((X),(Y),619) +#define get_gdat_ullong_pos619(X,Y) get_gdat_ullong((X),(Y),619) +#define get_gdat_ip_pos619(X,Y) get_gdat_ip((X),(Y),619) +#define get_gdat_ipv6_pos619(X,Y) get_gdat_ipv6((X),(Y),619) +#define get_gdat_string_pos619(X,Y) get_gdat_string((X),(Y),619) +#define get_gdat_v_str_pos619(X,Y) get_gdat_string((X),(Y),619) +#define get_gdat_bool_pos619(X,Y) get_gdat_bool((X),(Y),619) +#define get_gdat_int_pos619(X,Y) get_gdat_int((X),(Y),619) +#define get_gdat_llong_pos619(X,Y) get_gdat_llong((X),(Y),619) +#define get_gdat_float_pos619(X,Y) get_gdat_float((X),(Y),619) +#define get_gdat_uint_pos620(X,Y) get_gdat_uint((X),(Y),620) +#define get_gdat_ullong_pos620(X,Y) get_gdat_ullong((X),(Y),620) +#define get_gdat_ip_pos620(X,Y) get_gdat_ip((X),(Y),620) +#define get_gdat_ipv6_pos620(X,Y) get_gdat_ipv6((X),(Y),620) +#define get_gdat_string_pos620(X,Y) get_gdat_string((X),(Y),620) +#define get_gdat_v_str_pos620(X,Y) get_gdat_string((X),(Y),620) +#define get_gdat_bool_pos620(X,Y) get_gdat_bool((X),(Y),620) +#define get_gdat_int_pos620(X,Y) get_gdat_int((X),(Y),620) +#define get_gdat_llong_pos620(X,Y) get_gdat_llong((X),(Y),620) +#define get_gdat_float_pos620(X,Y) get_gdat_float((X),(Y),620) +#define get_gdat_uint_pos621(X,Y) get_gdat_uint((X),(Y),621) +#define get_gdat_ullong_pos621(X,Y) get_gdat_ullong((X),(Y),621) +#define get_gdat_ip_pos621(X,Y) get_gdat_ip((X),(Y),621) +#define get_gdat_ipv6_pos621(X,Y) get_gdat_ipv6((X),(Y),621) +#define get_gdat_string_pos621(X,Y) get_gdat_string((X),(Y),621) +#define get_gdat_v_str_pos621(X,Y) get_gdat_string((X),(Y),621) +#define get_gdat_bool_pos621(X,Y) get_gdat_bool((X),(Y),621) +#define get_gdat_int_pos621(X,Y) get_gdat_int((X),(Y),621) +#define get_gdat_llong_pos621(X,Y) get_gdat_llong((X),(Y),621) +#define get_gdat_float_pos621(X,Y) get_gdat_float((X),(Y),621) +#define get_gdat_uint_pos622(X,Y) get_gdat_uint((X),(Y),622) +#define get_gdat_ullong_pos622(X,Y) get_gdat_ullong((X),(Y),622) +#define get_gdat_ip_pos622(X,Y) get_gdat_ip((X),(Y),622) +#define get_gdat_ipv6_pos622(X,Y) get_gdat_ipv6((X),(Y),622) +#define get_gdat_string_pos622(X,Y) get_gdat_string((X),(Y),622) +#define get_gdat_v_str_pos622(X,Y) get_gdat_string((X),(Y),622) +#define get_gdat_bool_pos622(X,Y) get_gdat_bool((X),(Y),622) +#define get_gdat_int_pos622(X,Y) get_gdat_int((X),(Y),622) +#define get_gdat_llong_pos622(X,Y) get_gdat_llong((X),(Y),622) +#define get_gdat_float_pos622(X,Y) get_gdat_float((X),(Y),622) +#define get_gdat_uint_pos623(X,Y) get_gdat_uint((X),(Y),623) +#define get_gdat_ullong_pos623(X,Y) get_gdat_ullong((X),(Y),623) +#define get_gdat_ip_pos623(X,Y) get_gdat_ip((X),(Y),623) +#define get_gdat_ipv6_pos623(X,Y) get_gdat_ipv6((X),(Y),623) +#define get_gdat_string_pos623(X,Y) get_gdat_string((X),(Y),623) +#define get_gdat_v_str_pos623(X,Y) get_gdat_string((X),(Y),623) +#define get_gdat_bool_pos623(X,Y) get_gdat_bool((X),(Y),623) +#define get_gdat_int_pos623(X,Y) get_gdat_int((X),(Y),623) +#define get_gdat_llong_pos623(X,Y) get_gdat_llong((X),(Y),623) +#define get_gdat_float_pos623(X,Y) get_gdat_float((X),(Y),623) +#define get_gdat_uint_pos624(X,Y) get_gdat_uint((X),(Y),624) +#define get_gdat_ullong_pos624(X,Y) get_gdat_ullong((X),(Y),624) +#define get_gdat_ip_pos624(X,Y) get_gdat_ip((X),(Y),624) +#define get_gdat_ipv6_pos624(X,Y) get_gdat_ipv6((X),(Y),624) +#define get_gdat_string_pos624(X,Y) get_gdat_string((X),(Y),624) +#define get_gdat_v_str_pos624(X,Y) get_gdat_string((X),(Y),624) +#define get_gdat_bool_pos624(X,Y) get_gdat_bool((X),(Y),624) +#define get_gdat_int_pos624(X,Y) get_gdat_int((X),(Y),624) +#define get_gdat_llong_pos624(X,Y) get_gdat_llong((X),(Y),624) +#define get_gdat_float_pos624(X,Y) get_gdat_float((X),(Y),624) +#define get_gdat_uint_pos625(X,Y) get_gdat_uint((X),(Y),625) +#define get_gdat_ullong_pos625(X,Y) get_gdat_ullong((X),(Y),625) +#define get_gdat_ip_pos625(X,Y) get_gdat_ip((X),(Y),625) +#define get_gdat_ipv6_pos625(X,Y) get_gdat_ipv6((X),(Y),625) +#define get_gdat_string_pos625(X,Y) get_gdat_string((X),(Y),625) +#define get_gdat_v_str_pos625(X,Y) get_gdat_string((X),(Y),625) +#define get_gdat_bool_pos625(X,Y) get_gdat_bool((X),(Y),625) +#define get_gdat_int_pos625(X,Y) get_gdat_int((X),(Y),625) +#define get_gdat_llong_pos625(X,Y) get_gdat_llong((X),(Y),625) +#define get_gdat_float_pos625(X,Y) get_gdat_float((X),(Y),625) +#define get_gdat_uint_pos626(X,Y) get_gdat_uint((X),(Y),626) +#define get_gdat_ullong_pos626(X,Y) get_gdat_ullong((X),(Y),626) +#define get_gdat_ip_pos626(X,Y) get_gdat_ip((X),(Y),626) +#define get_gdat_ipv6_pos626(X,Y) get_gdat_ipv6((X),(Y),626) +#define get_gdat_string_pos626(X,Y) get_gdat_string((X),(Y),626) +#define get_gdat_v_str_pos626(X,Y) get_gdat_string((X),(Y),626) +#define get_gdat_bool_pos626(X,Y) get_gdat_bool((X),(Y),626) +#define get_gdat_int_pos626(X,Y) get_gdat_int((X),(Y),626) +#define get_gdat_llong_pos626(X,Y) get_gdat_llong((X),(Y),626) +#define get_gdat_float_pos626(X,Y) get_gdat_float((X),(Y),626) +#define get_gdat_uint_pos627(X,Y) get_gdat_uint((X),(Y),627) +#define get_gdat_ullong_pos627(X,Y) get_gdat_ullong((X),(Y),627) +#define get_gdat_ip_pos627(X,Y) get_gdat_ip((X),(Y),627) +#define get_gdat_ipv6_pos627(X,Y) get_gdat_ipv6((X),(Y),627) +#define get_gdat_string_pos627(X,Y) get_gdat_string((X),(Y),627) +#define get_gdat_v_str_pos627(X,Y) get_gdat_string((X),(Y),627) +#define get_gdat_bool_pos627(X,Y) get_gdat_bool((X),(Y),627) +#define get_gdat_int_pos627(X,Y) get_gdat_int((X),(Y),627) +#define get_gdat_llong_pos627(X,Y) get_gdat_llong((X),(Y),627) +#define get_gdat_float_pos627(X,Y) get_gdat_float((X),(Y),627) +#define get_gdat_uint_pos628(X,Y) get_gdat_uint((X),(Y),628) +#define get_gdat_ullong_pos628(X,Y) get_gdat_ullong((X),(Y),628) +#define get_gdat_ip_pos628(X,Y) get_gdat_ip((X),(Y),628) +#define get_gdat_ipv6_pos628(X,Y) get_gdat_ipv6((X),(Y),628) +#define get_gdat_string_pos628(X,Y) get_gdat_string((X),(Y),628) +#define get_gdat_v_str_pos628(X,Y) get_gdat_string((X),(Y),628) +#define get_gdat_bool_pos628(X,Y) get_gdat_bool((X),(Y),628) +#define get_gdat_int_pos628(X,Y) get_gdat_int((X),(Y),628) +#define get_gdat_llong_pos628(X,Y) get_gdat_llong((X),(Y),628) +#define get_gdat_float_pos628(X,Y) get_gdat_float((X),(Y),628) +#define get_gdat_uint_pos629(X,Y) get_gdat_uint((X),(Y),629) +#define get_gdat_ullong_pos629(X,Y) get_gdat_ullong((X),(Y),629) +#define get_gdat_ip_pos629(X,Y) get_gdat_ip((X),(Y),629) +#define get_gdat_ipv6_pos629(X,Y) get_gdat_ipv6((X),(Y),629) +#define get_gdat_string_pos629(X,Y) get_gdat_string((X),(Y),629) +#define get_gdat_v_str_pos629(X,Y) get_gdat_string((X),(Y),629) +#define get_gdat_bool_pos629(X,Y) get_gdat_bool((X),(Y),629) +#define get_gdat_int_pos629(X,Y) get_gdat_int((X),(Y),629) +#define get_gdat_llong_pos629(X,Y) get_gdat_llong((X),(Y),629) +#define get_gdat_float_pos629(X,Y) get_gdat_float((X),(Y),629) +#define get_gdat_uint_pos630(X,Y) get_gdat_uint((X),(Y),630) +#define get_gdat_ullong_pos630(X,Y) get_gdat_ullong((X),(Y),630) +#define get_gdat_ip_pos630(X,Y) get_gdat_ip((X),(Y),630) +#define get_gdat_ipv6_pos630(X,Y) get_gdat_ipv6((X),(Y),630) +#define get_gdat_string_pos630(X,Y) get_gdat_string((X),(Y),630) +#define get_gdat_v_str_pos630(X,Y) get_gdat_string((X),(Y),630) +#define get_gdat_bool_pos630(X,Y) get_gdat_bool((X),(Y),630) +#define get_gdat_int_pos630(X,Y) get_gdat_int((X),(Y),630) +#define get_gdat_llong_pos630(X,Y) get_gdat_llong((X),(Y),630) +#define get_gdat_float_pos630(X,Y) get_gdat_float((X),(Y),630) +#define get_gdat_uint_pos631(X,Y) get_gdat_uint((X),(Y),631) +#define get_gdat_ullong_pos631(X,Y) get_gdat_ullong((X),(Y),631) +#define get_gdat_ip_pos631(X,Y) get_gdat_ip((X),(Y),631) +#define get_gdat_ipv6_pos631(X,Y) get_gdat_ipv6((X),(Y),631) +#define get_gdat_string_pos631(X,Y) get_gdat_string((X),(Y),631) +#define get_gdat_v_str_pos631(X,Y) get_gdat_string((X),(Y),631) +#define get_gdat_bool_pos631(X,Y) get_gdat_bool((X),(Y),631) +#define get_gdat_int_pos631(X,Y) get_gdat_int((X),(Y),631) +#define get_gdat_llong_pos631(X,Y) get_gdat_llong((X),(Y),631) +#define get_gdat_float_pos631(X,Y) get_gdat_float((X),(Y),631) +#define get_gdat_uint_pos632(X,Y) get_gdat_uint((X),(Y),632) +#define get_gdat_ullong_pos632(X,Y) get_gdat_ullong((X),(Y),632) +#define get_gdat_ip_pos632(X,Y) get_gdat_ip((X),(Y),632) +#define get_gdat_ipv6_pos632(X,Y) get_gdat_ipv6((X),(Y),632) +#define get_gdat_string_pos632(X,Y) get_gdat_string((X),(Y),632) +#define get_gdat_v_str_pos632(X,Y) get_gdat_string((X),(Y),632) +#define get_gdat_bool_pos632(X,Y) get_gdat_bool((X),(Y),632) +#define get_gdat_int_pos632(X,Y) get_gdat_int((X),(Y),632) +#define get_gdat_llong_pos632(X,Y) get_gdat_llong((X),(Y),632) +#define get_gdat_float_pos632(X,Y) get_gdat_float((X),(Y),632) +#define get_gdat_uint_pos633(X,Y) get_gdat_uint((X),(Y),633) +#define get_gdat_ullong_pos633(X,Y) get_gdat_ullong((X),(Y),633) +#define get_gdat_ip_pos633(X,Y) get_gdat_ip((X),(Y),633) +#define get_gdat_ipv6_pos633(X,Y) get_gdat_ipv6((X),(Y),633) +#define get_gdat_string_pos633(X,Y) get_gdat_string((X),(Y),633) +#define get_gdat_v_str_pos633(X,Y) get_gdat_string((X),(Y),633) +#define get_gdat_bool_pos633(X,Y) get_gdat_bool((X),(Y),633) +#define get_gdat_int_pos633(X,Y) get_gdat_int((X),(Y),633) +#define get_gdat_llong_pos633(X,Y) get_gdat_llong((X),(Y),633) +#define get_gdat_float_pos633(X,Y) get_gdat_float((X),(Y),633) +#define get_gdat_uint_pos634(X,Y) get_gdat_uint((X),(Y),634) +#define get_gdat_ullong_pos634(X,Y) get_gdat_ullong((X),(Y),634) +#define get_gdat_ip_pos634(X,Y) get_gdat_ip((X),(Y),634) +#define get_gdat_ipv6_pos634(X,Y) get_gdat_ipv6((X),(Y),634) +#define get_gdat_string_pos634(X,Y) get_gdat_string((X),(Y),634) +#define get_gdat_v_str_pos634(X,Y) get_gdat_string((X),(Y),634) +#define get_gdat_bool_pos634(X,Y) get_gdat_bool((X),(Y),634) +#define get_gdat_int_pos634(X,Y) get_gdat_int((X),(Y),634) +#define get_gdat_llong_pos634(X,Y) get_gdat_llong((X),(Y),634) +#define get_gdat_float_pos634(X,Y) get_gdat_float((X),(Y),634) +#define get_gdat_uint_pos635(X,Y) get_gdat_uint((X),(Y),635) +#define get_gdat_ullong_pos635(X,Y) get_gdat_ullong((X),(Y),635) +#define get_gdat_ip_pos635(X,Y) get_gdat_ip((X),(Y),635) +#define get_gdat_ipv6_pos635(X,Y) get_gdat_ipv6((X),(Y),635) +#define get_gdat_string_pos635(X,Y) get_gdat_string((X),(Y),635) +#define get_gdat_v_str_pos635(X,Y) get_gdat_string((X),(Y),635) +#define get_gdat_bool_pos635(X,Y) get_gdat_bool((X),(Y),635) +#define get_gdat_int_pos635(X,Y) get_gdat_int((X),(Y),635) +#define get_gdat_llong_pos635(X,Y) get_gdat_llong((X),(Y),635) +#define get_gdat_float_pos635(X,Y) get_gdat_float((X),(Y),635) +#define get_gdat_uint_pos636(X,Y) get_gdat_uint((X),(Y),636) +#define get_gdat_ullong_pos636(X,Y) get_gdat_ullong((X),(Y),636) +#define get_gdat_ip_pos636(X,Y) get_gdat_ip((X),(Y),636) +#define get_gdat_ipv6_pos636(X,Y) get_gdat_ipv6((X),(Y),636) +#define get_gdat_string_pos636(X,Y) get_gdat_string((X),(Y),636) +#define get_gdat_v_str_pos636(X,Y) get_gdat_string((X),(Y),636) +#define get_gdat_bool_pos636(X,Y) get_gdat_bool((X),(Y),636) +#define get_gdat_int_pos636(X,Y) get_gdat_int((X),(Y),636) +#define get_gdat_llong_pos636(X,Y) get_gdat_llong((X),(Y),636) +#define get_gdat_float_pos636(X,Y) get_gdat_float((X),(Y),636) +#define get_gdat_uint_pos637(X,Y) get_gdat_uint((X),(Y),637) +#define get_gdat_ullong_pos637(X,Y) get_gdat_ullong((X),(Y),637) +#define get_gdat_ip_pos637(X,Y) get_gdat_ip((X),(Y),637) +#define get_gdat_ipv6_pos637(X,Y) get_gdat_ipv6((X),(Y),637) +#define get_gdat_string_pos637(X,Y) get_gdat_string((X),(Y),637) +#define get_gdat_v_str_pos637(X,Y) get_gdat_string((X),(Y),637) +#define get_gdat_bool_pos637(X,Y) get_gdat_bool((X),(Y),637) +#define get_gdat_int_pos637(X,Y) get_gdat_int((X),(Y),637) +#define get_gdat_llong_pos637(X,Y) get_gdat_llong((X),(Y),637) +#define get_gdat_float_pos637(X,Y) get_gdat_float((X),(Y),637) +#define get_gdat_uint_pos638(X,Y) get_gdat_uint((X),(Y),638) +#define get_gdat_ullong_pos638(X,Y) get_gdat_ullong((X),(Y),638) +#define get_gdat_ip_pos638(X,Y) get_gdat_ip((X),(Y),638) +#define get_gdat_ipv6_pos638(X,Y) get_gdat_ipv6((X),(Y),638) +#define get_gdat_string_pos638(X,Y) get_gdat_string((X),(Y),638) +#define get_gdat_v_str_pos638(X,Y) get_gdat_string((X),(Y),638) +#define get_gdat_bool_pos638(X,Y) get_gdat_bool((X),(Y),638) +#define get_gdat_int_pos638(X,Y) get_gdat_int((X),(Y),638) +#define get_gdat_llong_pos638(X,Y) get_gdat_llong((X),(Y),638) +#define get_gdat_float_pos638(X,Y) get_gdat_float((X),(Y),638) +#define get_gdat_uint_pos639(X,Y) get_gdat_uint((X),(Y),639) +#define get_gdat_ullong_pos639(X,Y) get_gdat_ullong((X),(Y),639) +#define get_gdat_ip_pos639(X,Y) get_gdat_ip((X),(Y),639) +#define get_gdat_ipv6_pos639(X,Y) get_gdat_ipv6((X),(Y),639) +#define get_gdat_string_pos639(X,Y) get_gdat_string((X),(Y),639) +#define get_gdat_v_str_pos639(X,Y) get_gdat_string((X),(Y),639) +#define get_gdat_bool_pos639(X,Y) get_gdat_bool((X),(Y),639) +#define get_gdat_int_pos639(X,Y) get_gdat_int((X),(Y),639) +#define get_gdat_llong_pos639(X,Y) get_gdat_llong((X),(Y),639) +#define get_gdat_float_pos639(X,Y) get_gdat_float((X),(Y),639) +#define get_gdat_uint_pos640(X,Y) get_gdat_uint((X),(Y),640) +#define get_gdat_ullong_pos640(X,Y) get_gdat_ullong((X),(Y),640) +#define get_gdat_ip_pos640(X,Y) get_gdat_ip((X),(Y),640) +#define get_gdat_ipv6_pos640(X,Y) get_gdat_ipv6((X),(Y),640) +#define get_gdat_string_pos640(X,Y) get_gdat_string((X),(Y),640) +#define get_gdat_v_str_pos640(X,Y) get_gdat_string((X),(Y),640) +#define get_gdat_bool_pos640(X,Y) get_gdat_bool((X),(Y),640) +#define get_gdat_int_pos640(X,Y) get_gdat_int((X),(Y),640) +#define get_gdat_llong_pos640(X,Y) get_gdat_llong((X),(Y),640) +#define get_gdat_float_pos640(X,Y) get_gdat_float((X),(Y),640) +#define get_gdat_uint_pos641(X,Y) get_gdat_uint((X),(Y),641) +#define get_gdat_ullong_pos641(X,Y) get_gdat_ullong((X),(Y),641) +#define get_gdat_ip_pos641(X,Y) get_gdat_ip((X),(Y),641) +#define get_gdat_ipv6_pos641(X,Y) get_gdat_ipv6((X),(Y),641) +#define get_gdat_string_pos641(X,Y) get_gdat_string((X),(Y),641) +#define get_gdat_v_str_pos641(X,Y) get_gdat_string((X),(Y),641) +#define get_gdat_bool_pos641(X,Y) get_gdat_bool((X),(Y),641) +#define get_gdat_int_pos641(X,Y) get_gdat_int((X),(Y),641) +#define get_gdat_llong_pos641(X,Y) get_gdat_llong((X),(Y),641) +#define get_gdat_float_pos641(X,Y) get_gdat_float((X),(Y),641) +#define get_gdat_uint_pos642(X,Y) get_gdat_uint((X),(Y),642) +#define get_gdat_ullong_pos642(X,Y) get_gdat_ullong((X),(Y),642) +#define get_gdat_ip_pos642(X,Y) get_gdat_ip((X),(Y),642) +#define get_gdat_ipv6_pos642(X,Y) get_gdat_ipv6((X),(Y),642) +#define get_gdat_string_pos642(X,Y) get_gdat_string((X),(Y),642) +#define get_gdat_v_str_pos642(X,Y) get_gdat_string((X),(Y),642) +#define get_gdat_bool_pos642(X,Y) get_gdat_bool((X),(Y),642) +#define get_gdat_int_pos642(X,Y) get_gdat_int((X),(Y),642) +#define get_gdat_llong_pos642(X,Y) get_gdat_llong((X),(Y),642) +#define get_gdat_float_pos642(X,Y) get_gdat_float((X),(Y),642) +#define get_gdat_uint_pos643(X,Y) get_gdat_uint((X),(Y),643) +#define get_gdat_ullong_pos643(X,Y) get_gdat_ullong((X),(Y),643) +#define get_gdat_ip_pos643(X,Y) get_gdat_ip((X),(Y),643) +#define get_gdat_ipv6_pos643(X,Y) get_gdat_ipv6((X),(Y),643) +#define get_gdat_string_pos643(X,Y) get_gdat_string((X),(Y),643) +#define get_gdat_v_str_pos643(X,Y) get_gdat_string((X),(Y),643) +#define get_gdat_bool_pos643(X,Y) get_gdat_bool((X),(Y),643) +#define get_gdat_int_pos643(X,Y) get_gdat_int((X),(Y),643) +#define get_gdat_llong_pos643(X,Y) get_gdat_llong((X),(Y),643) +#define get_gdat_float_pos643(X,Y) get_gdat_float((X),(Y),643) +#define get_gdat_uint_pos644(X,Y) get_gdat_uint((X),(Y),644) +#define get_gdat_ullong_pos644(X,Y) get_gdat_ullong((X),(Y),644) +#define get_gdat_ip_pos644(X,Y) get_gdat_ip((X),(Y),644) +#define get_gdat_ipv6_pos644(X,Y) get_gdat_ipv6((X),(Y),644) +#define get_gdat_string_pos644(X,Y) get_gdat_string((X),(Y),644) +#define get_gdat_v_str_pos644(X,Y) get_gdat_string((X),(Y),644) +#define get_gdat_bool_pos644(X,Y) get_gdat_bool((X),(Y),644) +#define get_gdat_int_pos644(X,Y) get_gdat_int((X),(Y),644) +#define get_gdat_llong_pos644(X,Y) get_gdat_llong((X),(Y),644) +#define get_gdat_float_pos644(X,Y) get_gdat_float((X),(Y),644) +#define get_gdat_uint_pos645(X,Y) get_gdat_uint((X),(Y),645) +#define get_gdat_ullong_pos645(X,Y) get_gdat_ullong((X),(Y),645) +#define get_gdat_ip_pos645(X,Y) get_gdat_ip((X),(Y),645) +#define get_gdat_ipv6_pos645(X,Y) get_gdat_ipv6((X),(Y),645) +#define get_gdat_string_pos645(X,Y) get_gdat_string((X),(Y),645) +#define get_gdat_v_str_pos645(X,Y) get_gdat_string((X),(Y),645) +#define get_gdat_bool_pos645(X,Y) get_gdat_bool((X),(Y),645) +#define get_gdat_int_pos645(X,Y) get_gdat_int((X),(Y),645) +#define get_gdat_llong_pos645(X,Y) get_gdat_llong((X),(Y),645) +#define get_gdat_float_pos645(X,Y) get_gdat_float((X),(Y),645) +#define get_gdat_uint_pos646(X,Y) get_gdat_uint((X),(Y),646) +#define get_gdat_ullong_pos646(X,Y) get_gdat_ullong((X),(Y),646) +#define get_gdat_ip_pos646(X,Y) get_gdat_ip((X),(Y),646) +#define get_gdat_ipv6_pos646(X,Y) get_gdat_ipv6((X),(Y),646) +#define get_gdat_string_pos646(X,Y) get_gdat_string((X),(Y),646) +#define get_gdat_v_str_pos646(X,Y) get_gdat_string((X),(Y),646) +#define get_gdat_bool_pos646(X,Y) get_gdat_bool((X),(Y),646) +#define get_gdat_int_pos646(X,Y) get_gdat_int((X),(Y),646) +#define get_gdat_llong_pos646(X,Y) get_gdat_llong((X),(Y),646) +#define get_gdat_float_pos646(X,Y) get_gdat_float((X),(Y),646) +#define get_gdat_uint_pos647(X,Y) get_gdat_uint((X),(Y),647) +#define get_gdat_ullong_pos647(X,Y) get_gdat_ullong((X),(Y),647) +#define get_gdat_ip_pos647(X,Y) get_gdat_ip((X),(Y),647) +#define get_gdat_ipv6_pos647(X,Y) get_gdat_ipv6((X),(Y),647) +#define get_gdat_string_pos647(X,Y) get_gdat_string((X),(Y),647) +#define get_gdat_v_str_pos647(X,Y) get_gdat_string((X),(Y),647) +#define get_gdat_bool_pos647(X,Y) get_gdat_bool((X),(Y),647) +#define get_gdat_int_pos647(X,Y) get_gdat_int((X),(Y),647) +#define get_gdat_llong_pos647(X,Y) get_gdat_llong((X),(Y),647) +#define get_gdat_float_pos647(X,Y) get_gdat_float((X),(Y),647) +#define get_gdat_uint_pos648(X,Y) get_gdat_uint((X),(Y),648) +#define get_gdat_ullong_pos648(X,Y) get_gdat_ullong((X),(Y),648) +#define get_gdat_ip_pos648(X,Y) get_gdat_ip((X),(Y),648) +#define get_gdat_ipv6_pos648(X,Y) get_gdat_ipv6((X),(Y),648) +#define get_gdat_string_pos648(X,Y) get_gdat_string((X),(Y),648) +#define get_gdat_v_str_pos648(X,Y) get_gdat_string((X),(Y),648) +#define get_gdat_bool_pos648(X,Y) get_gdat_bool((X),(Y),648) +#define get_gdat_int_pos648(X,Y) get_gdat_int((X),(Y),648) +#define get_gdat_llong_pos648(X,Y) get_gdat_llong((X),(Y),648) +#define get_gdat_float_pos648(X,Y) get_gdat_float((X),(Y),648) +#define get_gdat_uint_pos649(X,Y) get_gdat_uint((X),(Y),649) +#define get_gdat_ullong_pos649(X,Y) get_gdat_ullong((X),(Y),649) +#define get_gdat_ip_pos649(X,Y) get_gdat_ip((X),(Y),649) +#define get_gdat_ipv6_pos649(X,Y) get_gdat_ipv6((X),(Y),649) +#define get_gdat_string_pos649(X,Y) get_gdat_string((X),(Y),649) +#define get_gdat_v_str_pos649(X,Y) get_gdat_string((X),(Y),649) +#define get_gdat_bool_pos649(X,Y) get_gdat_bool((X),(Y),649) +#define get_gdat_int_pos649(X,Y) get_gdat_int((X),(Y),649) +#define get_gdat_llong_pos649(X,Y) get_gdat_llong((X),(Y),649) +#define get_gdat_float_pos649(X,Y) get_gdat_float((X),(Y),649) +#define get_gdat_uint_pos650(X,Y) get_gdat_uint((X),(Y),650) +#define get_gdat_ullong_pos650(X,Y) get_gdat_ullong((X),(Y),650) +#define get_gdat_ip_pos650(X,Y) get_gdat_ip((X),(Y),650) +#define get_gdat_ipv6_pos650(X,Y) get_gdat_ipv6((X),(Y),650) +#define get_gdat_string_pos650(X,Y) get_gdat_string((X),(Y),650) +#define get_gdat_v_str_pos650(X,Y) get_gdat_string((X),(Y),650) +#define get_gdat_bool_pos650(X,Y) get_gdat_bool((X),(Y),650) +#define get_gdat_int_pos650(X,Y) get_gdat_int((X),(Y),650) +#define get_gdat_llong_pos650(X,Y) get_gdat_llong((X),(Y),650) +#define get_gdat_float_pos650(X,Y) get_gdat_float((X),(Y),650) +#define get_gdat_uint_pos651(X,Y) get_gdat_uint((X),(Y),651) +#define get_gdat_ullong_pos651(X,Y) get_gdat_ullong((X),(Y),651) +#define get_gdat_ip_pos651(X,Y) get_gdat_ip((X),(Y),651) +#define get_gdat_ipv6_pos651(X,Y) get_gdat_ipv6((X),(Y),651) +#define get_gdat_string_pos651(X,Y) get_gdat_string((X),(Y),651) +#define get_gdat_v_str_pos651(X,Y) get_gdat_string((X),(Y),651) +#define get_gdat_bool_pos651(X,Y) get_gdat_bool((X),(Y),651) +#define get_gdat_int_pos651(X,Y) get_gdat_int((X),(Y),651) +#define get_gdat_llong_pos651(X,Y) get_gdat_llong((X),(Y),651) +#define get_gdat_float_pos651(X,Y) get_gdat_float((X),(Y),651) +#define get_gdat_uint_pos652(X,Y) get_gdat_uint((X),(Y),652) +#define get_gdat_ullong_pos652(X,Y) get_gdat_ullong((X),(Y),652) +#define get_gdat_ip_pos652(X,Y) get_gdat_ip((X),(Y),652) +#define get_gdat_ipv6_pos652(X,Y) get_gdat_ipv6((X),(Y),652) +#define get_gdat_string_pos652(X,Y) get_gdat_string((X),(Y),652) +#define get_gdat_v_str_pos652(X,Y) get_gdat_string((X),(Y),652) +#define get_gdat_bool_pos652(X,Y) get_gdat_bool((X),(Y),652) +#define get_gdat_int_pos652(X,Y) get_gdat_int((X),(Y),652) +#define get_gdat_llong_pos652(X,Y) get_gdat_llong((X),(Y),652) +#define get_gdat_float_pos652(X,Y) get_gdat_float((X),(Y),652) +#define get_gdat_uint_pos653(X,Y) get_gdat_uint((X),(Y),653) +#define get_gdat_ullong_pos653(X,Y) get_gdat_ullong((X),(Y),653) +#define get_gdat_ip_pos653(X,Y) get_gdat_ip((X),(Y),653) +#define get_gdat_ipv6_pos653(X,Y) get_gdat_ipv6((X),(Y),653) +#define get_gdat_string_pos653(X,Y) get_gdat_string((X),(Y),653) +#define get_gdat_v_str_pos653(X,Y) get_gdat_string((X),(Y),653) +#define get_gdat_bool_pos653(X,Y) get_gdat_bool((X),(Y),653) +#define get_gdat_int_pos653(X,Y) get_gdat_int((X),(Y),653) +#define get_gdat_llong_pos653(X,Y) get_gdat_llong((X),(Y),653) +#define get_gdat_float_pos653(X,Y) get_gdat_float((X),(Y),653) +#define get_gdat_uint_pos654(X,Y) get_gdat_uint((X),(Y),654) +#define get_gdat_ullong_pos654(X,Y) get_gdat_ullong((X),(Y),654) +#define get_gdat_ip_pos654(X,Y) get_gdat_ip((X),(Y),654) +#define get_gdat_ipv6_pos654(X,Y) get_gdat_ipv6((X),(Y),654) +#define get_gdat_string_pos654(X,Y) get_gdat_string((X),(Y),654) +#define get_gdat_v_str_pos654(X,Y) get_gdat_string((X),(Y),654) +#define get_gdat_bool_pos654(X,Y) get_gdat_bool((X),(Y),654) +#define get_gdat_int_pos654(X,Y) get_gdat_int((X),(Y),654) +#define get_gdat_llong_pos654(X,Y) get_gdat_llong((X),(Y),654) +#define get_gdat_float_pos654(X,Y) get_gdat_float((X),(Y),654) +#define get_gdat_uint_pos655(X,Y) get_gdat_uint((X),(Y),655) +#define get_gdat_ullong_pos655(X,Y) get_gdat_ullong((X),(Y),655) +#define get_gdat_ip_pos655(X,Y) get_gdat_ip((X),(Y),655) +#define get_gdat_ipv6_pos655(X,Y) get_gdat_ipv6((X),(Y),655) +#define get_gdat_string_pos655(X,Y) get_gdat_string((X),(Y),655) +#define get_gdat_v_str_pos655(X,Y) get_gdat_string((X),(Y),655) +#define get_gdat_bool_pos655(X,Y) get_gdat_bool((X),(Y),655) +#define get_gdat_int_pos655(X,Y) get_gdat_int((X),(Y),655) +#define get_gdat_llong_pos655(X,Y) get_gdat_llong((X),(Y),655) +#define get_gdat_float_pos655(X,Y) get_gdat_float((X),(Y),655) +#define get_gdat_uint_pos656(X,Y) get_gdat_uint((X),(Y),656) +#define get_gdat_ullong_pos656(X,Y) get_gdat_ullong((X),(Y),656) +#define get_gdat_ip_pos656(X,Y) get_gdat_ip((X),(Y),656) +#define get_gdat_ipv6_pos656(X,Y) get_gdat_ipv6((X),(Y),656) +#define get_gdat_string_pos656(X,Y) get_gdat_string((X),(Y),656) +#define get_gdat_v_str_pos656(X,Y) get_gdat_string((X),(Y),656) +#define get_gdat_bool_pos656(X,Y) get_gdat_bool((X),(Y),656) +#define get_gdat_int_pos656(X,Y) get_gdat_int((X),(Y),656) +#define get_gdat_llong_pos656(X,Y) get_gdat_llong((X),(Y),656) +#define get_gdat_float_pos656(X,Y) get_gdat_float((X),(Y),656) +#define get_gdat_uint_pos657(X,Y) get_gdat_uint((X),(Y),657) +#define get_gdat_ullong_pos657(X,Y) get_gdat_ullong((X),(Y),657) +#define get_gdat_ip_pos657(X,Y) get_gdat_ip((X),(Y),657) +#define get_gdat_ipv6_pos657(X,Y) get_gdat_ipv6((X),(Y),657) +#define get_gdat_string_pos657(X,Y) get_gdat_string((X),(Y),657) +#define get_gdat_v_str_pos657(X,Y) get_gdat_string((X),(Y),657) +#define get_gdat_bool_pos657(X,Y) get_gdat_bool((X),(Y),657) +#define get_gdat_int_pos657(X,Y) get_gdat_int((X),(Y),657) +#define get_gdat_llong_pos657(X,Y) get_gdat_llong((X),(Y),657) +#define get_gdat_float_pos657(X,Y) get_gdat_float((X),(Y),657) +#define get_gdat_uint_pos658(X,Y) get_gdat_uint((X),(Y),658) +#define get_gdat_ullong_pos658(X,Y) get_gdat_ullong((X),(Y),658) +#define get_gdat_ip_pos658(X,Y) get_gdat_ip((X),(Y),658) +#define get_gdat_ipv6_pos658(X,Y) get_gdat_ipv6((X),(Y),658) +#define get_gdat_string_pos658(X,Y) get_gdat_string((X),(Y),658) +#define get_gdat_v_str_pos658(X,Y) get_gdat_string((X),(Y),658) +#define get_gdat_bool_pos658(X,Y) get_gdat_bool((X),(Y),658) +#define get_gdat_int_pos658(X,Y) get_gdat_int((X),(Y),658) +#define get_gdat_llong_pos658(X,Y) get_gdat_llong((X),(Y),658) +#define get_gdat_float_pos658(X,Y) get_gdat_float((X),(Y),658) +#define get_gdat_uint_pos659(X,Y) get_gdat_uint((X),(Y),659) +#define get_gdat_ullong_pos659(X,Y) get_gdat_ullong((X),(Y),659) +#define get_gdat_ip_pos659(X,Y) get_gdat_ip((X),(Y),659) +#define get_gdat_ipv6_pos659(X,Y) get_gdat_ipv6((X),(Y),659) +#define get_gdat_string_pos659(X,Y) get_gdat_string((X),(Y),659) +#define get_gdat_v_str_pos659(X,Y) get_gdat_string((X),(Y),659) +#define get_gdat_bool_pos659(X,Y) get_gdat_bool((X),(Y),659) +#define get_gdat_int_pos659(X,Y) get_gdat_int((X),(Y),659) +#define get_gdat_llong_pos659(X,Y) get_gdat_llong((X),(Y),659) +#define get_gdat_float_pos659(X,Y) get_gdat_float((X),(Y),659) +#define get_gdat_uint_pos660(X,Y) get_gdat_uint((X),(Y),660) +#define get_gdat_ullong_pos660(X,Y) get_gdat_ullong((X),(Y),660) +#define get_gdat_ip_pos660(X,Y) get_gdat_ip((X),(Y),660) +#define get_gdat_ipv6_pos660(X,Y) get_gdat_ipv6((X),(Y),660) +#define get_gdat_string_pos660(X,Y) get_gdat_string((X),(Y),660) +#define get_gdat_v_str_pos660(X,Y) get_gdat_string((X),(Y),660) +#define get_gdat_bool_pos660(X,Y) get_gdat_bool((X),(Y),660) +#define get_gdat_int_pos660(X,Y) get_gdat_int((X),(Y),660) +#define get_gdat_llong_pos660(X,Y) get_gdat_llong((X),(Y),660) +#define get_gdat_float_pos660(X,Y) get_gdat_float((X),(Y),660) +#define get_gdat_uint_pos661(X,Y) get_gdat_uint((X),(Y),661) +#define get_gdat_ullong_pos661(X,Y) get_gdat_ullong((X),(Y),661) +#define get_gdat_ip_pos661(X,Y) get_gdat_ip((X),(Y),661) +#define get_gdat_ipv6_pos661(X,Y) get_gdat_ipv6((X),(Y),661) +#define get_gdat_string_pos661(X,Y) get_gdat_string((X),(Y),661) +#define get_gdat_v_str_pos661(X,Y) get_gdat_string((X),(Y),661) +#define get_gdat_bool_pos661(X,Y) get_gdat_bool((X),(Y),661) +#define get_gdat_int_pos661(X,Y) get_gdat_int((X),(Y),661) +#define get_gdat_llong_pos661(X,Y) get_gdat_llong((X),(Y),661) +#define get_gdat_float_pos661(X,Y) get_gdat_float((X),(Y),661) +#define get_gdat_uint_pos662(X,Y) get_gdat_uint((X),(Y),662) +#define get_gdat_ullong_pos662(X,Y) get_gdat_ullong((X),(Y),662) +#define get_gdat_ip_pos662(X,Y) get_gdat_ip((X),(Y),662) +#define get_gdat_ipv6_pos662(X,Y) get_gdat_ipv6((X),(Y),662) +#define get_gdat_string_pos662(X,Y) get_gdat_string((X),(Y),662) +#define get_gdat_v_str_pos662(X,Y) get_gdat_string((X),(Y),662) +#define get_gdat_bool_pos662(X,Y) get_gdat_bool((X),(Y),662) +#define get_gdat_int_pos662(X,Y) get_gdat_int((X),(Y),662) +#define get_gdat_llong_pos662(X,Y) get_gdat_llong((X),(Y),662) +#define get_gdat_float_pos662(X,Y) get_gdat_float((X),(Y),662) +#define get_gdat_uint_pos663(X,Y) get_gdat_uint((X),(Y),663) +#define get_gdat_ullong_pos663(X,Y) get_gdat_ullong((X),(Y),663) +#define get_gdat_ip_pos663(X,Y) get_gdat_ip((X),(Y),663) +#define get_gdat_ipv6_pos663(X,Y) get_gdat_ipv6((X),(Y),663) +#define get_gdat_string_pos663(X,Y) get_gdat_string((X),(Y),663) +#define get_gdat_v_str_pos663(X,Y) get_gdat_string((X),(Y),663) +#define get_gdat_bool_pos663(X,Y) get_gdat_bool((X),(Y),663) +#define get_gdat_int_pos663(X,Y) get_gdat_int((X),(Y),663) +#define get_gdat_llong_pos663(X,Y) get_gdat_llong((X),(Y),663) +#define get_gdat_float_pos663(X,Y) get_gdat_float((X),(Y),663) +#define get_gdat_uint_pos664(X,Y) get_gdat_uint((X),(Y),664) +#define get_gdat_ullong_pos664(X,Y) get_gdat_ullong((X),(Y),664) +#define get_gdat_ip_pos664(X,Y) get_gdat_ip((X),(Y),664) +#define get_gdat_ipv6_pos664(X,Y) get_gdat_ipv6((X),(Y),664) +#define get_gdat_string_pos664(X,Y) get_gdat_string((X),(Y),664) +#define get_gdat_v_str_pos664(X,Y) get_gdat_string((X),(Y),664) +#define get_gdat_bool_pos664(X,Y) get_gdat_bool((X),(Y),664) +#define get_gdat_int_pos664(X,Y) get_gdat_int((X),(Y),664) +#define get_gdat_llong_pos664(X,Y) get_gdat_llong((X),(Y),664) +#define get_gdat_float_pos664(X,Y) get_gdat_float((X),(Y),664) +#define get_gdat_uint_pos665(X,Y) get_gdat_uint((X),(Y),665) +#define get_gdat_ullong_pos665(X,Y) get_gdat_ullong((X),(Y),665) +#define get_gdat_ip_pos665(X,Y) get_gdat_ip((X),(Y),665) +#define get_gdat_ipv6_pos665(X,Y) get_gdat_ipv6((X),(Y),665) +#define get_gdat_string_pos665(X,Y) get_gdat_string((X),(Y),665) +#define get_gdat_v_str_pos665(X,Y) get_gdat_string((X),(Y),665) +#define get_gdat_bool_pos665(X,Y) get_gdat_bool((X),(Y),665) +#define get_gdat_int_pos665(X,Y) get_gdat_int((X),(Y),665) +#define get_gdat_llong_pos665(X,Y) get_gdat_llong((X),(Y),665) +#define get_gdat_float_pos665(X,Y) get_gdat_float((X),(Y),665) +#define get_gdat_uint_pos666(X,Y) get_gdat_uint((X),(Y),666) +#define get_gdat_ullong_pos666(X,Y) get_gdat_ullong((X),(Y),666) +#define get_gdat_ip_pos666(X,Y) get_gdat_ip((X),(Y),666) +#define get_gdat_ipv6_pos666(X,Y) get_gdat_ipv6((X),(Y),666) +#define get_gdat_string_pos666(X,Y) get_gdat_string((X),(Y),666) +#define get_gdat_v_str_pos666(X,Y) get_gdat_string((X),(Y),666) +#define get_gdat_bool_pos666(X,Y) get_gdat_bool((X),(Y),666) +#define get_gdat_int_pos666(X,Y) get_gdat_int((X),(Y),666) +#define get_gdat_llong_pos666(X,Y) get_gdat_llong((X),(Y),666) +#define get_gdat_float_pos666(X,Y) get_gdat_float((X),(Y),666) +#define get_gdat_uint_pos667(X,Y) get_gdat_uint((X),(Y),667) +#define get_gdat_ullong_pos667(X,Y) get_gdat_ullong((X),(Y),667) +#define get_gdat_ip_pos667(X,Y) get_gdat_ip((X),(Y),667) +#define get_gdat_ipv6_pos667(X,Y) get_gdat_ipv6((X),(Y),667) +#define get_gdat_string_pos667(X,Y) get_gdat_string((X),(Y),667) +#define get_gdat_v_str_pos667(X,Y) get_gdat_string((X),(Y),667) +#define get_gdat_bool_pos667(X,Y) get_gdat_bool((X),(Y),667) +#define get_gdat_int_pos667(X,Y) get_gdat_int((X),(Y),667) +#define get_gdat_llong_pos667(X,Y) get_gdat_llong((X),(Y),667) +#define get_gdat_float_pos667(X,Y) get_gdat_float((X),(Y),667) +#define get_gdat_uint_pos668(X,Y) get_gdat_uint((X),(Y),668) +#define get_gdat_ullong_pos668(X,Y) get_gdat_ullong((X),(Y),668) +#define get_gdat_ip_pos668(X,Y) get_gdat_ip((X),(Y),668) +#define get_gdat_ipv6_pos668(X,Y) get_gdat_ipv6((X),(Y),668) +#define get_gdat_string_pos668(X,Y) get_gdat_string((X),(Y),668) +#define get_gdat_v_str_pos668(X,Y) get_gdat_string((X),(Y),668) +#define get_gdat_bool_pos668(X,Y) get_gdat_bool((X),(Y),668) +#define get_gdat_int_pos668(X,Y) get_gdat_int((X),(Y),668) +#define get_gdat_llong_pos668(X,Y) get_gdat_llong((X),(Y),668) +#define get_gdat_float_pos668(X,Y) get_gdat_float((X),(Y),668) +#define get_gdat_uint_pos669(X,Y) get_gdat_uint((X),(Y),669) +#define get_gdat_ullong_pos669(X,Y) get_gdat_ullong((X),(Y),669) +#define get_gdat_ip_pos669(X,Y) get_gdat_ip((X),(Y),669) +#define get_gdat_ipv6_pos669(X,Y) get_gdat_ipv6((X),(Y),669) +#define get_gdat_string_pos669(X,Y) get_gdat_string((X),(Y),669) +#define get_gdat_v_str_pos669(X,Y) get_gdat_string((X),(Y),669) +#define get_gdat_bool_pos669(X,Y) get_gdat_bool((X),(Y),669) +#define get_gdat_int_pos669(X,Y) get_gdat_int((X),(Y),669) +#define get_gdat_llong_pos669(X,Y) get_gdat_llong((X),(Y),669) +#define get_gdat_float_pos669(X,Y) get_gdat_float((X),(Y),669) +#define get_gdat_uint_pos670(X,Y) get_gdat_uint((X),(Y),670) +#define get_gdat_ullong_pos670(X,Y) get_gdat_ullong((X),(Y),670) +#define get_gdat_ip_pos670(X,Y) get_gdat_ip((X),(Y),670) +#define get_gdat_ipv6_pos670(X,Y) get_gdat_ipv6((X),(Y),670) +#define get_gdat_string_pos670(X,Y) get_gdat_string((X),(Y),670) +#define get_gdat_v_str_pos670(X,Y) get_gdat_string((X),(Y),670) +#define get_gdat_bool_pos670(X,Y) get_gdat_bool((X),(Y),670) +#define get_gdat_int_pos670(X,Y) get_gdat_int((X),(Y),670) +#define get_gdat_llong_pos670(X,Y) get_gdat_llong((X),(Y),670) +#define get_gdat_float_pos670(X,Y) get_gdat_float((X),(Y),670) +#define get_gdat_uint_pos671(X,Y) get_gdat_uint((X),(Y),671) +#define get_gdat_ullong_pos671(X,Y) get_gdat_ullong((X),(Y),671) +#define get_gdat_ip_pos671(X,Y) get_gdat_ip((X),(Y),671) +#define get_gdat_ipv6_pos671(X,Y) get_gdat_ipv6((X),(Y),671) +#define get_gdat_string_pos671(X,Y) get_gdat_string((X),(Y),671) +#define get_gdat_v_str_pos671(X,Y) get_gdat_string((X),(Y),671) +#define get_gdat_bool_pos671(X,Y) get_gdat_bool((X),(Y),671) +#define get_gdat_int_pos671(X,Y) get_gdat_int((X),(Y),671) +#define get_gdat_llong_pos671(X,Y) get_gdat_llong((X),(Y),671) +#define get_gdat_float_pos671(X,Y) get_gdat_float((X),(Y),671) +#define get_gdat_uint_pos672(X,Y) get_gdat_uint((X),(Y),672) +#define get_gdat_ullong_pos672(X,Y) get_gdat_ullong((X),(Y),672) +#define get_gdat_ip_pos672(X,Y) get_gdat_ip((X),(Y),672) +#define get_gdat_ipv6_pos672(X,Y) get_gdat_ipv6((X),(Y),672) +#define get_gdat_string_pos672(X,Y) get_gdat_string((X),(Y),672) +#define get_gdat_v_str_pos672(X,Y) get_gdat_string((X),(Y),672) +#define get_gdat_bool_pos672(X,Y) get_gdat_bool((X),(Y),672) +#define get_gdat_int_pos672(X,Y) get_gdat_int((X),(Y),672) +#define get_gdat_llong_pos672(X,Y) get_gdat_llong((X),(Y),672) +#define get_gdat_float_pos672(X,Y) get_gdat_float((X),(Y),672) +#define get_gdat_uint_pos673(X,Y) get_gdat_uint((X),(Y),673) +#define get_gdat_ullong_pos673(X,Y) get_gdat_ullong((X),(Y),673) +#define get_gdat_ip_pos673(X,Y) get_gdat_ip((X),(Y),673) +#define get_gdat_ipv6_pos673(X,Y) get_gdat_ipv6((X),(Y),673) +#define get_gdat_string_pos673(X,Y) get_gdat_string((X),(Y),673) +#define get_gdat_v_str_pos673(X,Y) get_gdat_string((X),(Y),673) +#define get_gdat_bool_pos673(X,Y) get_gdat_bool((X),(Y),673) +#define get_gdat_int_pos673(X,Y) get_gdat_int((X),(Y),673) +#define get_gdat_llong_pos673(X,Y) get_gdat_llong((X),(Y),673) +#define get_gdat_float_pos673(X,Y) get_gdat_float((X),(Y),673) +#define get_gdat_uint_pos674(X,Y) get_gdat_uint((X),(Y),674) +#define get_gdat_ullong_pos674(X,Y) get_gdat_ullong((X),(Y),674) +#define get_gdat_ip_pos674(X,Y) get_gdat_ip((X),(Y),674) +#define get_gdat_ipv6_pos674(X,Y) get_gdat_ipv6((X),(Y),674) +#define get_gdat_string_pos674(X,Y) get_gdat_string((X),(Y),674) +#define get_gdat_v_str_pos674(X,Y) get_gdat_string((X),(Y),674) +#define get_gdat_bool_pos674(X,Y) get_gdat_bool((X),(Y),674) +#define get_gdat_int_pos674(X,Y) get_gdat_int((X),(Y),674) +#define get_gdat_llong_pos674(X,Y) get_gdat_llong((X),(Y),674) +#define get_gdat_float_pos674(X,Y) get_gdat_float((X),(Y),674) +#define get_gdat_uint_pos675(X,Y) get_gdat_uint((X),(Y),675) +#define get_gdat_ullong_pos675(X,Y) get_gdat_ullong((X),(Y),675) +#define get_gdat_ip_pos675(X,Y) get_gdat_ip((X),(Y),675) +#define get_gdat_ipv6_pos675(X,Y) get_gdat_ipv6((X),(Y),675) +#define get_gdat_string_pos675(X,Y) get_gdat_string((X),(Y),675) +#define get_gdat_v_str_pos675(X,Y) get_gdat_string((X),(Y),675) +#define get_gdat_bool_pos675(X,Y) get_gdat_bool((X),(Y),675) +#define get_gdat_int_pos675(X,Y) get_gdat_int((X),(Y),675) +#define get_gdat_llong_pos675(X,Y) get_gdat_llong((X),(Y),675) +#define get_gdat_float_pos675(X,Y) get_gdat_float((X),(Y),675) +#define get_gdat_uint_pos676(X,Y) get_gdat_uint((X),(Y),676) +#define get_gdat_ullong_pos676(X,Y) get_gdat_ullong((X),(Y),676) +#define get_gdat_ip_pos676(X,Y) get_gdat_ip((X),(Y),676) +#define get_gdat_ipv6_pos676(X,Y) get_gdat_ipv6((X),(Y),676) +#define get_gdat_string_pos676(X,Y) get_gdat_string((X),(Y),676) +#define get_gdat_v_str_pos676(X,Y) get_gdat_string((X),(Y),676) +#define get_gdat_bool_pos676(X,Y) get_gdat_bool((X),(Y),676) +#define get_gdat_int_pos676(X,Y) get_gdat_int((X),(Y),676) +#define get_gdat_llong_pos676(X,Y) get_gdat_llong((X),(Y),676) +#define get_gdat_float_pos676(X,Y) get_gdat_float((X),(Y),676) +#define get_gdat_uint_pos677(X,Y) get_gdat_uint((X),(Y),677) +#define get_gdat_ullong_pos677(X,Y) get_gdat_ullong((X),(Y),677) +#define get_gdat_ip_pos677(X,Y) get_gdat_ip((X),(Y),677) +#define get_gdat_ipv6_pos677(X,Y) get_gdat_ipv6((X),(Y),677) +#define get_gdat_string_pos677(X,Y) get_gdat_string((X),(Y),677) +#define get_gdat_v_str_pos677(X,Y) get_gdat_string((X),(Y),677) +#define get_gdat_bool_pos677(X,Y) get_gdat_bool((X),(Y),677) +#define get_gdat_int_pos677(X,Y) get_gdat_int((X),(Y),677) +#define get_gdat_llong_pos677(X,Y) get_gdat_llong((X),(Y),677) +#define get_gdat_float_pos677(X,Y) get_gdat_float((X),(Y),677) +#define get_gdat_uint_pos678(X,Y) get_gdat_uint((X),(Y),678) +#define get_gdat_ullong_pos678(X,Y) get_gdat_ullong((X),(Y),678) +#define get_gdat_ip_pos678(X,Y) get_gdat_ip((X),(Y),678) +#define get_gdat_ipv6_pos678(X,Y) get_gdat_ipv6((X),(Y),678) +#define get_gdat_string_pos678(X,Y) get_gdat_string((X),(Y),678) +#define get_gdat_v_str_pos678(X,Y) get_gdat_string((X),(Y),678) +#define get_gdat_bool_pos678(X,Y) get_gdat_bool((X),(Y),678) +#define get_gdat_int_pos678(X,Y) get_gdat_int((X),(Y),678) +#define get_gdat_llong_pos678(X,Y) get_gdat_llong((X),(Y),678) +#define get_gdat_float_pos678(X,Y) get_gdat_float((X),(Y),678) +#define get_gdat_uint_pos679(X,Y) get_gdat_uint((X),(Y),679) +#define get_gdat_ullong_pos679(X,Y) get_gdat_ullong((X),(Y),679) +#define get_gdat_ip_pos679(X,Y) get_gdat_ip((X),(Y),679) +#define get_gdat_ipv6_pos679(X,Y) get_gdat_ipv6((X),(Y),679) +#define get_gdat_string_pos679(X,Y) get_gdat_string((X),(Y),679) +#define get_gdat_v_str_pos679(X,Y) get_gdat_string((X),(Y),679) +#define get_gdat_bool_pos679(X,Y) get_gdat_bool((X),(Y),679) +#define get_gdat_int_pos679(X,Y) get_gdat_int((X),(Y),679) +#define get_gdat_llong_pos679(X,Y) get_gdat_llong((X),(Y),679) +#define get_gdat_float_pos679(X,Y) get_gdat_float((X),(Y),679) +#define get_gdat_uint_pos680(X,Y) get_gdat_uint((X),(Y),680) +#define get_gdat_ullong_pos680(X,Y) get_gdat_ullong((X),(Y),680) +#define get_gdat_ip_pos680(X,Y) get_gdat_ip((X),(Y),680) +#define get_gdat_ipv6_pos680(X,Y) get_gdat_ipv6((X),(Y),680) +#define get_gdat_string_pos680(X,Y) get_gdat_string((X),(Y),680) +#define get_gdat_v_str_pos680(X,Y) get_gdat_string((X),(Y),680) +#define get_gdat_bool_pos680(X,Y) get_gdat_bool((X),(Y),680) +#define get_gdat_int_pos680(X,Y) get_gdat_int((X),(Y),680) +#define get_gdat_llong_pos680(X,Y) get_gdat_llong((X),(Y),680) +#define get_gdat_float_pos680(X,Y) get_gdat_float((X),(Y),680) +#define get_gdat_uint_pos681(X,Y) get_gdat_uint((X),(Y),681) +#define get_gdat_ullong_pos681(X,Y) get_gdat_ullong((X),(Y),681) +#define get_gdat_ip_pos681(X,Y) get_gdat_ip((X),(Y),681) +#define get_gdat_ipv6_pos681(X,Y) get_gdat_ipv6((X),(Y),681) +#define get_gdat_string_pos681(X,Y) get_gdat_string((X),(Y),681) +#define get_gdat_v_str_pos681(X,Y) get_gdat_string((X),(Y),681) +#define get_gdat_bool_pos681(X,Y) get_gdat_bool((X),(Y),681) +#define get_gdat_int_pos681(X,Y) get_gdat_int((X),(Y),681) +#define get_gdat_llong_pos681(X,Y) get_gdat_llong((X),(Y),681) +#define get_gdat_float_pos681(X,Y) get_gdat_float((X),(Y),681) +#define get_gdat_uint_pos682(X,Y) get_gdat_uint((X),(Y),682) +#define get_gdat_ullong_pos682(X,Y) get_gdat_ullong((X),(Y),682) +#define get_gdat_ip_pos682(X,Y) get_gdat_ip((X),(Y),682) +#define get_gdat_ipv6_pos682(X,Y) get_gdat_ipv6((X),(Y),682) +#define get_gdat_string_pos682(X,Y) get_gdat_string((X),(Y),682) +#define get_gdat_v_str_pos682(X,Y) get_gdat_string((X),(Y),682) +#define get_gdat_bool_pos682(X,Y) get_gdat_bool((X),(Y),682) +#define get_gdat_int_pos682(X,Y) get_gdat_int((X),(Y),682) +#define get_gdat_llong_pos682(X,Y) get_gdat_llong((X),(Y),682) +#define get_gdat_float_pos682(X,Y) get_gdat_float((X),(Y),682) +#define get_gdat_uint_pos683(X,Y) get_gdat_uint((X),(Y),683) +#define get_gdat_ullong_pos683(X,Y) get_gdat_ullong((X),(Y),683) +#define get_gdat_ip_pos683(X,Y) get_gdat_ip((X),(Y),683) +#define get_gdat_ipv6_pos683(X,Y) get_gdat_ipv6((X),(Y),683) +#define get_gdat_string_pos683(X,Y) get_gdat_string((X),(Y),683) +#define get_gdat_v_str_pos683(X,Y) get_gdat_string((X),(Y),683) +#define get_gdat_bool_pos683(X,Y) get_gdat_bool((X),(Y),683) +#define get_gdat_int_pos683(X,Y) get_gdat_int((X),(Y),683) +#define get_gdat_llong_pos683(X,Y) get_gdat_llong((X),(Y),683) +#define get_gdat_float_pos683(X,Y) get_gdat_float((X),(Y),683) +#define get_gdat_uint_pos684(X,Y) get_gdat_uint((X),(Y),684) +#define get_gdat_ullong_pos684(X,Y) get_gdat_ullong((X),(Y),684) +#define get_gdat_ip_pos684(X,Y) get_gdat_ip((X),(Y),684) +#define get_gdat_ipv6_pos684(X,Y) get_gdat_ipv6((X),(Y),684) +#define get_gdat_string_pos684(X,Y) get_gdat_string((X),(Y),684) +#define get_gdat_v_str_pos684(X,Y) get_gdat_string((X),(Y),684) +#define get_gdat_bool_pos684(X,Y) get_gdat_bool((X),(Y),684) +#define get_gdat_int_pos684(X,Y) get_gdat_int((X),(Y),684) +#define get_gdat_llong_pos684(X,Y) get_gdat_llong((X),(Y),684) +#define get_gdat_float_pos684(X,Y) get_gdat_float((X),(Y),684) +#define get_gdat_uint_pos685(X,Y) get_gdat_uint((X),(Y),685) +#define get_gdat_ullong_pos685(X,Y) get_gdat_ullong((X),(Y),685) +#define get_gdat_ip_pos685(X,Y) get_gdat_ip((X),(Y),685) +#define get_gdat_ipv6_pos685(X,Y) get_gdat_ipv6((X),(Y),685) +#define get_gdat_string_pos685(X,Y) get_gdat_string((X),(Y),685) +#define get_gdat_v_str_pos685(X,Y) get_gdat_string((X),(Y),685) +#define get_gdat_bool_pos685(X,Y) get_gdat_bool((X),(Y),685) +#define get_gdat_int_pos685(X,Y) get_gdat_int((X),(Y),685) +#define get_gdat_llong_pos685(X,Y) get_gdat_llong((X),(Y),685) +#define get_gdat_float_pos685(X,Y) get_gdat_float((X),(Y),685) +#define get_gdat_uint_pos686(X,Y) get_gdat_uint((X),(Y),686) +#define get_gdat_ullong_pos686(X,Y) get_gdat_ullong((X),(Y),686) +#define get_gdat_ip_pos686(X,Y) get_gdat_ip((X),(Y),686) +#define get_gdat_ipv6_pos686(X,Y) get_gdat_ipv6((X),(Y),686) +#define get_gdat_string_pos686(X,Y) get_gdat_string((X),(Y),686) +#define get_gdat_v_str_pos686(X,Y) get_gdat_string((X),(Y),686) +#define get_gdat_bool_pos686(X,Y) get_gdat_bool((X),(Y),686) +#define get_gdat_int_pos686(X,Y) get_gdat_int((X),(Y),686) +#define get_gdat_llong_pos686(X,Y) get_gdat_llong((X),(Y),686) +#define get_gdat_float_pos686(X,Y) get_gdat_float((X),(Y),686) +#define get_gdat_uint_pos687(X,Y) get_gdat_uint((X),(Y),687) +#define get_gdat_ullong_pos687(X,Y) get_gdat_ullong((X),(Y),687) +#define get_gdat_ip_pos687(X,Y) get_gdat_ip((X),(Y),687) +#define get_gdat_ipv6_pos687(X,Y) get_gdat_ipv6((X),(Y),687) +#define get_gdat_string_pos687(X,Y) get_gdat_string((X),(Y),687) +#define get_gdat_v_str_pos687(X,Y) get_gdat_string((X),(Y),687) +#define get_gdat_bool_pos687(X,Y) get_gdat_bool((X),(Y),687) +#define get_gdat_int_pos687(X,Y) get_gdat_int((X),(Y),687) +#define get_gdat_llong_pos687(X,Y) get_gdat_llong((X),(Y),687) +#define get_gdat_float_pos687(X,Y) get_gdat_float((X),(Y),687) +#define get_gdat_uint_pos688(X,Y) get_gdat_uint((X),(Y),688) +#define get_gdat_ullong_pos688(X,Y) get_gdat_ullong((X),(Y),688) +#define get_gdat_ip_pos688(X,Y) get_gdat_ip((X),(Y),688) +#define get_gdat_ipv6_pos688(X,Y) get_gdat_ipv6((X),(Y),688) +#define get_gdat_string_pos688(X,Y) get_gdat_string((X),(Y),688) +#define get_gdat_v_str_pos688(X,Y) get_gdat_string((X),(Y),688) +#define get_gdat_bool_pos688(X,Y) get_gdat_bool((X),(Y),688) +#define get_gdat_int_pos688(X,Y) get_gdat_int((X),(Y),688) +#define get_gdat_llong_pos688(X,Y) get_gdat_llong((X),(Y),688) +#define get_gdat_float_pos688(X,Y) get_gdat_float((X),(Y),688) +#define get_gdat_uint_pos689(X,Y) get_gdat_uint((X),(Y),689) +#define get_gdat_ullong_pos689(X,Y) get_gdat_ullong((X),(Y),689) +#define get_gdat_ip_pos689(X,Y) get_gdat_ip((X),(Y),689) +#define get_gdat_ipv6_pos689(X,Y) get_gdat_ipv6((X),(Y),689) +#define get_gdat_string_pos689(X,Y) get_gdat_string((X),(Y),689) +#define get_gdat_v_str_pos689(X,Y) get_gdat_string((X),(Y),689) +#define get_gdat_bool_pos689(X,Y) get_gdat_bool((X),(Y),689) +#define get_gdat_int_pos689(X,Y) get_gdat_int((X),(Y),689) +#define get_gdat_llong_pos689(X,Y) get_gdat_llong((X),(Y),689) +#define get_gdat_float_pos689(X,Y) get_gdat_float((X),(Y),689) +#define get_gdat_uint_pos690(X,Y) get_gdat_uint((X),(Y),690) +#define get_gdat_ullong_pos690(X,Y) get_gdat_ullong((X),(Y),690) +#define get_gdat_ip_pos690(X,Y) get_gdat_ip((X),(Y),690) +#define get_gdat_ipv6_pos690(X,Y) get_gdat_ipv6((X),(Y),690) +#define get_gdat_string_pos690(X,Y) get_gdat_string((X),(Y),690) +#define get_gdat_v_str_pos690(X,Y) get_gdat_string((X),(Y),690) +#define get_gdat_bool_pos690(X,Y) get_gdat_bool((X),(Y),690) +#define get_gdat_int_pos690(X,Y) get_gdat_int((X),(Y),690) +#define get_gdat_llong_pos690(X,Y) get_gdat_llong((X),(Y),690) +#define get_gdat_float_pos690(X,Y) get_gdat_float((X),(Y),690) +#define get_gdat_uint_pos691(X,Y) get_gdat_uint((X),(Y),691) +#define get_gdat_ullong_pos691(X,Y) get_gdat_ullong((X),(Y),691) +#define get_gdat_ip_pos691(X,Y) get_gdat_ip((X),(Y),691) +#define get_gdat_ipv6_pos691(X,Y) get_gdat_ipv6((X),(Y),691) +#define get_gdat_string_pos691(X,Y) get_gdat_string((X),(Y),691) +#define get_gdat_v_str_pos691(X,Y) get_gdat_string((X),(Y),691) +#define get_gdat_bool_pos691(X,Y) get_gdat_bool((X),(Y),691) +#define get_gdat_int_pos691(X,Y) get_gdat_int((X),(Y),691) +#define get_gdat_llong_pos691(X,Y) get_gdat_llong((X),(Y),691) +#define get_gdat_float_pos691(X,Y) get_gdat_float((X),(Y),691) +#define get_gdat_uint_pos692(X,Y) get_gdat_uint((X),(Y),692) +#define get_gdat_ullong_pos692(X,Y) get_gdat_ullong((X),(Y),692) +#define get_gdat_ip_pos692(X,Y) get_gdat_ip((X),(Y),692) +#define get_gdat_ipv6_pos692(X,Y) get_gdat_ipv6((X),(Y),692) +#define get_gdat_string_pos692(X,Y) get_gdat_string((X),(Y),692) +#define get_gdat_v_str_pos692(X,Y) get_gdat_string((X),(Y),692) +#define get_gdat_bool_pos692(X,Y) get_gdat_bool((X),(Y),692) +#define get_gdat_int_pos692(X,Y) get_gdat_int((X),(Y),692) +#define get_gdat_llong_pos692(X,Y) get_gdat_llong((X),(Y),692) +#define get_gdat_float_pos692(X,Y) get_gdat_float((X),(Y),692) +#define get_gdat_uint_pos693(X,Y) get_gdat_uint((X),(Y),693) +#define get_gdat_ullong_pos693(X,Y) get_gdat_ullong((X),(Y),693) +#define get_gdat_ip_pos693(X,Y) get_gdat_ip((X),(Y),693) +#define get_gdat_ipv6_pos693(X,Y) get_gdat_ipv6((X),(Y),693) +#define get_gdat_string_pos693(X,Y) get_gdat_string((X),(Y),693) +#define get_gdat_v_str_pos693(X,Y) get_gdat_string((X),(Y),693) +#define get_gdat_bool_pos693(X,Y) get_gdat_bool((X),(Y),693) +#define get_gdat_int_pos693(X,Y) get_gdat_int((X),(Y),693) +#define get_gdat_llong_pos693(X,Y) get_gdat_llong((X),(Y),693) +#define get_gdat_float_pos693(X,Y) get_gdat_float((X),(Y),693) +#define get_gdat_uint_pos694(X,Y) get_gdat_uint((X),(Y),694) +#define get_gdat_ullong_pos694(X,Y) get_gdat_ullong((X),(Y),694) +#define get_gdat_ip_pos694(X,Y) get_gdat_ip((X),(Y),694) +#define get_gdat_ipv6_pos694(X,Y) get_gdat_ipv6((X),(Y),694) +#define get_gdat_string_pos694(X,Y) get_gdat_string((X),(Y),694) +#define get_gdat_v_str_pos694(X,Y) get_gdat_string((X),(Y),694) +#define get_gdat_bool_pos694(X,Y) get_gdat_bool((X),(Y),694) +#define get_gdat_int_pos694(X,Y) get_gdat_int((X),(Y),694) +#define get_gdat_llong_pos694(X,Y) get_gdat_llong((X),(Y),694) +#define get_gdat_float_pos694(X,Y) get_gdat_float((X),(Y),694) +#define get_gdat_uint_pos695(X,Y) get_gdat_uint((X),(Y),695) +#define get_gdat_ullong_pos695(X,Y) get_gdat_ullong((X),(Y),695) +#define get_gdat_ip_pos695(X,Y) get_gdat_ip((X),(Y),695) +#define get_gdat_ipv6_pos695(X,Y) get_gdat_ipv6((X),(Y),695) +#define get_gdat_string_pos695(X,Y) get_gdat_string((X),(Y),695) +#define get_gdat_v_str_pos695(X,Y) get_gdat_string((X),(Y),695) +#define get_gdat_bool_pos695(X,Y) get_gdat_bool((X),(Y),695) +#define get_gdat_int_pos695(X,Y) get_gdat_int((X),(Y),695) +#define get_gdat_llong_pos695(X,Y) get_gdat_llong((X),(Y),695) +#define get_gdat_float_pos695(X,Y) get_gdat_float((X),(Y),695) +#define get_gdat_uint_pos696(X,Y) get_gdat_uint((X),(Y),696) +#define get_gdat_ullong_pos696(X,Y) get_gdat_ullong((X),(Y),696) +#define get_gdat_ip_pos696(X,Y) get_gdat_ip((X),(Y),696) +#define get_gdat_ipv6_pos696(X,Y) get_gdat_ipv6((X),(Y),696) +#define get_gdat_string_pos696(X,Y) get_gdat_string((X),(Y),696) +#define get_gdat_v_str_pos696(X,Y) get_gdat_string((X),(Y),696) +#define get_gdat_bool_pos696(X,Y) get_gdat_bool((X),(Y),696) +#define get_gdat_int_pos696(X,Y) get_gdat_int((X),(Y),696) +#define get_gdat_llong_pos696(X,Y) get_gdat_llong((X),(Y),696) +#define get_gdat_float_pos696(X,Y) get_gdat_float((X),(Y),696) +#define get_gdat_uint_pos697(X,Y) get_gdat_uint((X),(Y),697) +#define get_gdat_ullong_pos697(X,Y) get_gdat_ullong((X),(Y),697) +#define get_gdat_ip_pos697(X,Y) get_gdat_ip((X),(Y),697) +#define get_gdat_ipv6_pos697(X,Y) get_gdat_ipv6((X),(Y),697) +#define get_gdat_string_pos697(X,Y) get_gdat_string((X),(Y),697) +#define get_gdat_v_str_pos697(X,Y) get_gdat_string((X),(Y),697) +#define get_gdat_bool_pos697(X,Y) get_gdat_bool((X),(Y),697) +#define get_gdat_int_pos697(X,Y) get_gdat_int((X),(Y),697) +#define get_gdat_llong_pos697(X,Y) get_gdat_llong((X),(Y),697) +#define get_gdat_float_pos697(X,Y) get_gdat_float((X),(Y),697) +#define get_gdat_uint_pos698(X,Y) get_gdat_uint((X),(Y),698) +#define get_gdat_ullong_pos698(X,Y) get_gdat_ullong((X),(Y),698) +#define get_gdat_ip_pos698(X,Y) get_gdat_ip((X),(Y),698) +#define get_gdat_ipv6_pos698(X,Y) get_gdat_ipv6((X),(Y),698) +#define get_gdat_string_pos698(X,Y) get_gdat_string((X),(Y),698) +#define get_gdat_v_str_pos698(X,Y) get_gdat_string((X),(Y),698) +#define get_gdat_bool_pos698(X,Y) get_gdat_bool((X),(Y),698) +#define get_gdat_int_pos698(X,Y) get_gdat_int((X),(Y),698) +#define get_gdat_llong_pos698(X,Y) get_gdat_llong((X),(Y),698) +#define get_gdat_float_pos698(X,Y) get_gdat_float((X),(Y),698) +#define get_gdat_uint_pos699(X,Y) get_gdat_uint((X),(Y),699) +#define get_gdat_ullong_pos699(X,Y) get_gdat_ullong((X),(Y),699) +#define get_gdat_ip_pos699(X,Y) get_gdat_ip((X),(Y),699) +#define get_gdat_ipv6_pos699(X,Y) get_gdat_ipv6((X),(Y),699) +#define get_gdat_string_pos699(X,Y) get_gdat_string((X),(Y),699) +#define get_gdat_v_str_pos699(X,Y) get_gdat_string((X),(Y),699) +#define get_gdat_bool_pos699(X,Y) get_gdat_bool((X),(Y),699) +#define get_gdat_int_pos699(X,Y) get_gdat_int((X),(Y),699) +#define get_gdat_llong_pos699(X,Y) get_gdat_llong((X),(Y),699) +#define get_gdat_float_pos699(X,Y) get_gdat_float((X),(Y),699) +#define get_gdat_uint_pos700(X,Y) get_gdat_uint((X),(Y),700) +#define get_gdat_ullong_pos700(X,Y) get_gdat_ullong((X),(Y),700) +#define get_gdat_ip_pos700(X,Y) get_gdat_ip((X),(Y),700) +#define get_gdat_ipv6_pos700(X,Y) get_gdat_ipv6((X),(Y),700) +#define get_gdat_string_pos700(X,Y) get_gdat_string((X),(Y),700) +#define get_gdat_v_str_pos700(X,Y) get_gdat_string((X),(Y),700) +#define get_gdat_bool_pos700(X,Y) get_gdat_bool((X),(Y),700) +#define get_gdat_int_pos700(X,Y) get_gdat_int((X),(Y),700) +#define get_gdat_llong_pos700(X,Y) get_gdat_llong((X),(Y),700) +#define get_gdat_float_pos700(X,Y) get_gdat_float((X),(Y),700) +#define get_gdat_uint_pos701(X,Y) get_gdat_uint((X),(Y),701) +#define get_gdat_ullong_pos701(X,Y) get_gdat_ullong((X),(Y),701) +#define get_gdat_ip_pos701(X,Y) get_gdat_ip((X),(Y),701) +#define get_gdat_ipv6_pos701(X,Y) get_gdat_ipv6((X),(Y),701) +#define get_gdat_string_pos701(X,Y) get_gdat_string((X),(Y),701) +#define get_gdat_v_str_pos701(X,Y) get_gdat_string((X),(Y),701) +#define get_gdat_bool_pos701(X,Y) get_gdat_bool((X),(Y),701) +#define get_gdat_int_pos701(X,Y) get_gdat_int((X),(Y),701) +#define get_gdat_llong_pos701(X,Y) get_gdat_llong((X),(Y),701) +#define get_gdat_float_pos701(X,Y) get_gdat_float((X),(Y),701) +#define get_gdat_uint_pos702(X,Y) get_gdat_uint((X),(Y),702) +#define get_gdat_ullong_pos702(X,Y) get_gdat_ullong((X),(Y),702) +#define get_gdat_ip_pos702(X,Y) get_gdat_ip((X),(Y),702) +#define get_gdat_ipv6_pos702(X,Y) get_gdat_ipv6((X),(Y),702) +#define get_gdat_string_pos702(X,Y) get_gdat_string((X),(Y),702) +#define get_gdat_v_str_pos702(X,Y) get_gdat_string((X),(Y),702) +#define get_gdat_bool_pos702(X,Y) get_gdat_bool((X),(Y),702) +#define get_gdat_int_pos702(X,Y) get_gdat_int((X),(Y),702) +#define get_gdat_llong_pos702(X,Y) get_gdat_llong((X),(Y),702) +#define get_gdat_float_pos702(X,Y) get_gdat_float((X),(Y),702) +#define get_gdat_uint_pos703(X,Y) get_gdat_uint((X),(Y),703) +#define get_gdat_ullong_pos703(X,Y) get_gdat_ullong((X),(Y),703) +#define get_gdat_ip_pos703(X,Y) get_gdat_ip((X),(Y),703) +#define get_gdat_ipv6_pos703(X,Y) get_gdat_ipv6((X),(Y),703) +#define get_gdat_string_pos703(X,Y) get_gdat_string((X),(Y),703) +#define get_gdat_v_str_pos703(X,Y) get_gdat_string((X),(Y),703) +#define get_gdat_bool_pos703(X,Y) get_gdat_bool((X),(Y),703) +#define get_gdat_int_pos703(X,Y) get_gdat_int((X),(Y),703) +#define get_gdat_llong_pos703(X,Y) get_gdat_llong((X),(Y),703) +#define get_gdat_float_pos703(X,Y) get_gdat_float((X),(Y),703) +#define get_gdat_uint_pos704(X,Y) get_gdat_uint((X),(Y),704) +#define get_gdat_ullong_pos704(X,Y) get_gdat_ullong((X),(Y),704) +#define get_gdat_ip_pos704(X,Y) get_gdat_ip((X),(Y),704) +#define get_gdat_ipv6_pos704(X,Y) get_gdat_ipv6((X),(Y),704) +#define get_gdat_string_pos704(X,Y) get_gdat_string((X),(Y),704) +#define get_gdat_v_str_pos704(X,Y) get_gdat_string((X),(Y),704) +#define get_gdat_bool_pos704(X,Y) get_gdat_bool((X),(Y),704) +#define get_gdat_int_pos704(X,Y) get_gdat_int((X),(Y),704) +#define get_gdat_llong_pos704(X,Y) get_gdat_llong((X),(Y),704) +#define get_gdat_float_pos704(X,Y) get_gdat_float((X),(Y),704) +#define get_gdat_uint_pos705(X,Y) get_gdat_uint((X),(Y),705) +#define get_gdat_ullong_pos705(X,Y) get_gdat_ullong((X),(Y),705) +#define get_gdat_ip_pos705(X,Y) get_gdat_ip((X),(Y),705) +#define get_gdat_ipv6_pos705(X,Y) get_gdat_ipv6((X),(Y),705) +#define get_gdat_string_pos705(X,Y) get_gdat_string((X),(Y),705) +#define get_gdat_v_str_pos705(X,Y) get_gdat_string((X),(Y),705) +#define get_gdat_bool_pos705(X,Y) get_gdat_bool((X),(Y),705) +#define get_gdat_int_pos705(X,Y) get_gdat_int((X),(Y),705) +#define get_gdat_llong_pos705(X,Y) get_gdat_llong((X),(Y),705) +#define get_gdat_float_pos705(X,Y) get_gdat_float((X),(Y),705) +#define get_gdat_uint_pos706(X,Y) get_gdat_uint((X),(Y),706) +#define get_gdat_ullong_pos706(X,Y) get_gdat_ullong((X),(Y),706) +#define get_gdat_ip_pos706(X,Y) get_gdat_ip((X),(Y),706) +#define get_gdat_ipv6_pos706(X,Y) get_gdat_ipv6((X),(Y),706) +#define get_gdat_string_pos706(X,Y) get_gdat_string((X),(Y),706) +#define get_gdat_v_str_pos706(X,Y) get_gdat_string((X),(Y),706) +#define get_gdat_bool_pos706(X,Y) get_gdat_bool((X),(Y),706) +#define get_gdat_int_pos706(X,Y) get_gdat_int((X),(Y),706) +#define get_gdat_llong_pos706(X,Y) get_gdat_llong((X),(Y),706) +#define get_gdat_float_pos706(X,Y) get_gdat_float((X),(Y),706) +#define get_gdat_uint_pos707(X,Y) get_gdat_uint((X),(Y),707) +#define get_gdat_ullong_pos707(X,Y) get_gdat_ullong((X),(Y),707) +#define get_gdat_ip_pos707(X,Y) get_gdat_ip((X),(Y),707) +#define get_gdat_ipv6_pos707(X,Y) get_gdat_ipv6((X),(Y),707) +#define get_gdat_string_pos707(X,Y) get_gdat_string((X),(Y),707) +#define get_gdat_v_str_pos707(X,Y) get_gdat_string((X),(Y),707) +#define get_gdat_bool_pos707(X,Y) get_gdat_bool((X),(Y),707) +#define get_gdat_int_pos707(X,Y) get_gdat_int((X),(Y),707) +#define get_gdat_llong_pos707(X,Y) get_gdat_llong((X),(Y),707) +#define get_gdat_float_pos707(X,Y) get_gdat_float((X),(Y),707) +#define get_gdat_uint_pos708(X,Y) get_gdat_uint((X),(Y),708) +#define get_gdat_ullong_pos708(X,Y) get_gdat_ullong((X),(Y),708) +#define get_gdat_ip_pos708(X,Y) get_gdat_ip((X),(Y),708) +#define get_gdat_ipv6_pos708(X,Y) get_gdat_ipv6((X),(Y),708) +#define get_gdat_string_pos708(X,Y) get_gdat_string((X),(Y),708) +#define get_gdat_v_str_pos708(X,Y) get_gdat_string((X),(Y),708) +#define get_gdat_bool_pos708(X,Y) get_gdat_bool((X),(Y),708) +#define get_gdat_int_pos708(X,Y) get_gdat_int((X),(Y),708) +#define get_gdat_llong_pos708(X,Y) get_gdat_llong((X),(Y),708) +#define get_gdat_float_pos708(X,Y) get_gdat_float((X),(Y),708) +#define get_gdat_uint_pos709(X,Y) get_gdat_uint((X),(Y),709) +#define get_gdat_ullong_pos709(X,Y) get_gdat_ullong((X),(Y),709) +#define get_gdat_ip_pos709(X,Y) get_gdat_ip((X),(Y),709) +#define get_gdat_ipv6_pos709(X,Y) get_gdat_ipv6((X),(Y),709) +#define get_gdat_string_pos709(X,Y) get_gdat_string((X),(Y),709) +#define get_gdat_v_str_pos709(X,Y) get_gdat_string((X),(Y),709) +#define get_gdat_bool_pos709(X,Y) get_gdat_bool((X),(Y),709) +#define get_gdat_int_pos709(X,Y) get_gdat_int((X),(Y),709) +#define get_gdat_llong_pos709(X,Y) get_gdat_llong((X),(Y),709) +#define get_gdat_float_pos709(X,Y) get_gdat_float((X),(Y),709) +#define get_gdat_uint_pos710(X,Y) get_gdat_uint((X),(Y),710) +#define get_gdat_ullong_pos710(X,Y) get_gdat_ullong((X),(Y),710) +#define get_gdat_ip_pos710(X,Y) get_gdat_ip((X),(Y),710) +#define get_gdat_ipv6_pos710(X,Y) get_gdat_ipv6((X),(Y),710) +#define get_gdat_string_pos710(X,Y) get_gdat_string((X),(Y),710) +#define get_gdat_v_str_pos710(X,Y) get_gdat_string((X),(Y),710) +#define get_gdat_bool_pos710(X,Y) get_gdat_bool((X),(Y),710) +#define get_gdat_int_pos710(X,Y) get_gdat_int((X),(Y),710) +#define get_gdat_llong_pos710(X,Y) get_gdat_llong((X),(Y),710) +#define get_gdat_float_pos710(X,Y) get_gdat_float((X),(Y),710) +#define get_gdat_uint_pos711(X,Y) get_gdat_uint((X),(Y),711) +#define get_gdat_ullong_pos711(X,Y) get_gdat_ullong((X),(Y),711) +#define get_gdat_ip_pos711(X,Y) get_gdat_ip((X),(Y),711) +#define get_gdat_ipv6_pos711(X,Y) get_gdat_ipv6((X),(Y),711) +#define get_gdat_string_pos711(X,Y) get_gdat_string((X),(Y),711) +#define get_gdat_v_str_pos711(X,Y) get_gdat_string((X),(Y),711) +#define get_gdat_bool_pos711(X,Y) get_gdat_bool((X),(Y),711) +#define get_gdat_int_pos711(X,Y) get_gdat_int((X),(Y),711) +#define get_gdat_llong_pos711(X,Y) get_gdat_llong((X),(Y),711) +#define get_gdat_float_pos711(X,Y) get_gdat_float((X),(Y),711) +#define get_gdat_uint_pos712(X,Y) get_gdat_uint((X),(Y),712) +#define get_gdat_ullong_pos712(X,Y) get_gdat_ullong((X),(Y),712) +#define get_gdat_ip_pos712(X,Y) get_gdat_ip((X),(Y),712) +#define get_gdat_ipv6_pos712(X,Y) get_gdat_ipv6((X),(Y),712) +#define get_gdat_string_pos712(X,Y) get_gdat_string((X),(Y),712) +#define get_gdat_v_str_pos712(X,Y) get_gdat_string((X),(Y),712) +#define get_gdat_bool_pos712(X,Y) get_gdat_bool((X),(Y),712) +#define get_gdat_int_pos712(X,Y) get_gdat_int((X),(Y),712) +#define get_gdat_llong_pos712(X,Y) get_gdat_llong((X),(Y),712) +#define get_gdat_float_pos712(X,Y) get_gdat_float((X),(Y),712) +#define get_gdat_uint_pos713(X,Y) get_gdat_uint((X),(Y),713) +#define get_gdat_ullong_pos713(X,Y) get_gdat_ullong((X),(Y),713) +#define get_gdat_ip_pos713(X,Y) get_gdat_ip((X),(Y),713) +#define get_gdat_ipv6_pos713(X,Y) get_gdat_ipv6((X),(Y),713) +#define get_gdat_string_pos713(X,Y) get_gdat_string((X),(Y),713) +#define get_gdat_v_str_pos713(X,Y) get_gdat_string((X),(Y),713) +#define get_gdat_bool_pos713(X,Y) get_gdat_bool((X),(Y),713) +#define get_gdat_int_pos713(X,Y) get_gdat_int((X),(Y),713) +#define get_gdat_llong_pos713(X,Y) get_gdat_llong((X),(Y),713) +#define get_gdat_float_pos713(X,Y) get_gdat_float((X),(Y),713) +#define get_gdat_uint_pos714(X,Y) get_gdat_uint((X),(Y),714) +#define get_gdat_ullong_pos714(X,Y) get_gdat_ullong((X),(Y),714) +#define get_gdat_ip_pos714(X,Y) get_gdat_ip((X),(Y),714) +#define get_gdat_ipv6_pos714(X,Y) get_gdat_ipv6((X),(Y),714) +#define get_gdat_string_pos714(X,Y) get_gdat_string((X),(Y),714) +#define get_gdat_v_str_pos714(X,Y) get_gdat_string((X),(Y),714) +#define get_gdat_bool_pos714(X,Y) get_gdat_bool((X),(Y),714) +#define get_gdat_int_pos714(X,Y) get_gdat_int((X),(Y),714) +#define get_gdat_llong_pos714(X,Y) get_gdat_llong((X),(Y),714) +#define get_gdat_float_pos714(X,Y) get_gdat_float((X),(Y),714) +#define get_gdat_uint_pos715(X,Y) get_gdat_uint((X),(Y),715) +#define get_gdat_ullong_pos715(X,Y) get_gdat_ullong((X),(Y),715) +#define get_gdat_ip_pos715(X,Y) get_gdat_ip((X),(Y),715) +#define get_gdat_ipv6_pos715(X,Y) get_gdat_ipv6((X),(Y),715) +#define get_gdat_string_pos715(X,Y) get_gdat_string((X),(Y),715) +#define get_gdat_v_str_pos715(X,Y) get_gdat_string((X),(Y),715) +#define get_gdat_bool_pos715(X,Y) get_gdat_bool((X),(Y),715) +#define get_gdat_int_pos715(X,Y) get_gdat_int((X),(Y),715) +#define get_gdat_llong_pos715(X,Y) get_gdat_llong((X),(Y),715) +#define get_gdat_float_pos715(X,Y) get_gdat_float((X),(Y),715) +#define get_gdat_uint_pos716(X,Y) get_gdat_uint((X),(Y),716) +#define get_gdat_ullong_pos716(X,Y) get_gdat_ullong((X),(Y),716) +#define get_gdat_ip_pos716(X,Y) get_gdat_ip((X),(Y),716) +#define get_gdat_ipv6_pos716(X,Y) get_gdat_ipv6((X),(Y),716) +#define get_gdat_string_pos716(X,Y) get_gdat_string((X),(Y),716) +#define get_gdat_v_str_pos716(X,Y) get_gdat_string((X),(Y),716) +#define get_gdat_bool_pos716(X,Y) get_gdat_bool((X),(Y),716) +#define get_gdat_int_pos716(X,Y) get_gdat_int((X),(Y),716) +#define get_gdat_llong_pos716(X,Y) get_gdat_llong((X),(Y),716) +#define get_gdat_float_pos716(X,Y) get_gdat_float((X),(Y),716) +#define get_gdat_uint_pos717(X,Y) get_gdat_uint((X),(Y),717) +#define get_gdat_ullong_pos717(X,Y) get_gdat_ullong((X),(Y),717) +#define get_gdat_ip_pos717(X,Y) get_gdat_ip((X),(Y),717) +#define get_gdat_ipv6_pos717(X,Y) get_gdat_ipv6((X),(Y),717) +#define get_gdat_string_pos717(X,Y) get_gdat_string((X),(Y),717) +#define get_gdat_v_str_pos717(X,Y) get_gdat_string((X),(Y),717) +#define get_gdat_bool_pos717(X,Y) get_gdat_bool((X),(Y),717) +#define get_gdat_int_pos717(X,Y) get_gdat_int((X),(Y),717) +#define get_gdat_llong_pos717(X,Y) get_gdat_llong((X),(Y),717) +#define get_gdat_float_pos717(X,Y) get_gdat_float((X),(Y),717) +#define get_gdat_uint_pos718(X,Y) get_gdat_uint((X),(Y),718) +#define get_gdat_ullong_pos718(X,Y) get_gdat_ullong((X),(Y),718) +#define get_gdat_ip_pos718(X,Y) get_gdat_ip((X),(Y),718) +#define get_gdat_ipv6_pos718(X,Y) get_gdat_ipv6((X),(Y),718) +#define get_gdat_string_pos718(X,Y) get_gdat_string((X),(Y),718) +#define get_gdat_v_str_pos718(X,Y) get_gdat_string((X),(Y),718) +#define get_gdat_bool_pos718(X,Y) get_gdat_bool((X),(Y),718) +#define get_gdat_int_pos718(X,Y) get_gdat_int((X),(Y),718) +#define get_gdat_llong_pos718(X,Y) get_gdat_llong((X),(Y),718) +#define get_gdat_float_pos718(X,Y) get_gdat_float((X),(Y),718) +#define get_gdat_uint_pos719(X,Y) get_gdat_uint((X),(Y),719) +#define get_gdat_ullong_pos719(X,Y) get_gdat_ullong((X),(Y),719) +#define get_gdat_ip_pos719(X,Y) get_gdat_ip((X),(Y),719) +#define get_gdat_ipv6_pos719(X,Y) get_gdat_ipv6((X),(Y),719) +#define get_gdat_string_pos719(X,Y) get_gdat_string((X),(Y),719) +#define get_gdat_v_str_pos719(X,Y) get_gdat_string((X),(Y),719) +#define get_gdat_bool_pos719(X,Y) get_gdat_bool((X),(Y),719) +#define get_gdat_int_pos719(X,Y) get_gdat_int((X),(Y),719) +#define get_gdat_llong_pos719(X,Y) get_gdat_llong((X),(Y),719) +#define get_gdat_float_pos719(X,Y) get_gdat_float((X),(Y),719) +#define get_gdat_uint_pos720(X,Y) get_gdat_uint((X),(Y),720) +#define get_gdat_ullong_pos720(X,Y) get_gdat_ullong((X),(Y),720) +#define get_gdat_ip_pos720(X,Y) get_gdat_ip((X),(Y),720) +#define get_gdat_ipv6_pos720(X,Y) get_gdat_ipv6((X),(Y),720) +#define get_gdat_string_pos720(X,Y) get_gdat_string((X),(Y),720) +#define get_gdat_v_str_pos720(X,Y) get_gdat_string((X),(Y),720) +#define get_gdat_bool_pos720(X,Y) get_gdat_bool((X),(Y),720) +#define get_gdat_int_pos720(X,Y) get_gdat_int((X),(Y),720) +#define get_gdat_llong_pos720(X,Y) get_gdat_llong((X),(Y),720) +#define get_gdat_float_pos720(X,Y) get_gdat_float((X),(Y),720) +#define get_gdat_uint_pos721(X,Y) get_gdat_uint((X),(Y),721) +#define get_gdat_ullong_pos721(X,Y) get_gdat_ullong((X),(Y),721) +#define get_gdat_ip_pos721(X,Y) get_gdat_ip((X),(Y),721) +#define get_gdat_ipv6_pos721(X,Y) get_gdat_ipv6((X),(Y),721) +#define get_gdat_string_pos721(X,Y) get_gdat_string((X),(Y),721) +#define get_gdat_v_str_pos721(X,Y) get_gdat_string((X),(Y),721) +#define get_gdat_bool_pos721(X,Y) get_gdat_bool((X),(Y),721) +#define get_gdat_int_pos721(X,Y) get_gdat_int((X),(Y),721) +#define get_gdat_llong_pos721(X,Y) get_gdat_llong((X),(Y),721) +#define get_gdat_float_pos721(X,Y) get_gdat_float((X),(Y),721) +#define get_gdat_uint_pos722(X,Y) get_gdat_uint((X),(Y),722) +#define get_gdat_ullong_pos722(X,Y) get_gdat_ullong((X),(Y),722) +#define get_gdat_ip_pos722(X,Y) get_gdat_ip((X),(Y),722) +#define get_gdat_ipv6_pos722(X,Y) get_gdat_ipv6((X),(Y),722) +#define get_gdat_string_pos722(X,Y) get_gdat_string((X),(Y),722) +#define get_gdat_v_str_pos722(X,Y) get_gdat_string((X),(Y),722) +#define get_gdat_bool_pos722(X,Y) get_gdat_bool((X),(Y),722) +#define get_gdat_int_pos722(X,Y) get_gdat_int((X),(Y),722) +#define get_gdat_llong_pos722(X,Y) get_gdat_llong((X),(Y),722) +#define get_gdat_float_pos722(X,Y) get_gdat_float((X),(Y),722) +#define get_gdat_uint_pos723(X,Y) get_gdat_uint((X),(Y),723) +#define get_gdat_ullong_pos723(X,Y) get_gdat_ullong((X),(Y),723) +#define get_gdat_ip_pos723(X,Y) get_gdat_ip((X),(Y),723) +#define get_gdat_ipv6_pos723(X,Y) get_gdat_ipv6((X),(Y),723) +#define get_gdat_string_pos723(X,Y) get_gdat_string((X),(Y),723) +#define get_gdat_v_str_pos723(X,Y) get_gdat_string((X),(Y),723) +#define get_gdat_bool_pos723(X,Y) get_gdat_bool((X),(Y),723) +#define get_gdat_int_pos723(X,Y) get_gdat_int((X),(Y),723) +#define get_gdat_llong_pos723(X,Y) get_gdat_llong((X),(Y),723) +#define get_gdat_float_pos723(X,Y) get_gdat_float((X),(Y),723) +#define get_gdat_uint_pos724(X,Y) get_gdat_uint((X),(Y),724) +#define get_gdat_ullong_pos724(X,Y) get_gdat_ullong((X),(Y),724) +#define get_gdat_ip_pos724(X,Y) get_gdat_ip((X),(Y),724) +#define get_gdat_ipv6_pos724(X,Y) get_gdat_ipv6((X),(Y),724) +#define get_gdat_string_pos724(X,Y) get_gdat_string((X),(Y),724) +#define get_gdat_v_str_pos724(X,Y) get_gdat_string((X),(Y),724) +#define get_gdat_bool_pos724(X,Y) get_gdat_bool((X),(Y),724) +#define get_gdat_int_pos724(X,Y) get_gdat_int((X),(Y),724) +#define get_gdat_llong_pos724(X,Y) get_gdat_llong((X),(Y),724) +#define get_gdat_float_pos724(X,Y) get_gdat_float((X),(Y),724) +#define get_gdat_uint_pos725(X,Y) get_gdat_uint((X),(Y),725) +#define get_gdat_ullong_pos725(X,Y) get_gdat_ullong((X),(Y),725) +#define get_gdat_ip_pos725(X,Y) get_gdat_ip((X),(Y),725) +#define get_gdat_ipv6_pos725(X,Y) get_gdat_ipv6((X),(Y),725) +#define get_gdat_string_pos725(X,Y) get_gdat_string((X),(Y),725) +#define get_gdat_v_str_pos725(X,Y) get_gdat_string((X),(Y),725) +#define get_gdat_bool_pos725(X,Y) get_gdat_bool((X),(Y),725) +#define get_gdat_int_pos725(X,Y) get_gdat_int((X),(Y),725) +#define get_gdat_llong_pos725(X,Y) get_gdat_llong((X),(Y),725) +#define get_gdat_float_pos725(X,Y) get_gdat_float((X),(Y),725) +#define get_gdat_uint_pos726(X,Y) get_gdat_uint((X),(Y),726) +#define get_gdat_ullong_pos726(X,Y) get_gdat_ullong((X),(Y),726) +#define get_gdat_ip_pos726(X,Y) get_gdat_ip((X),(Y),726) +#define get_gdat_ipv6_pos726(X,Y) get_gdat_ipv6((X),(Y),726) +#define get_gdat_string_pos726(X,Y) get_gdat_string((X),(Y),726) +#define get_gdat_v_str_pos726(X,Y) get_gdat_string((X),(Y),726) +#define get_gdat_bool_pos726(X,Y) get_gdat_bool((X),(Y),726) +#define get_gdat_int_pos726(X,Y) get_gdat_int((X),(Y),726) +#define get_gdat_llong_pos726(X,Y) get_gdat_llong((X),(Y),726) +#define get_gdat_float_pos726(X,Y) get_gdat_float((X),(Y),726) +#define get_gdat_uint_pos727(X,Y) get_gdat_uint((X),(Y),727) +#define get_gdat_ullong_pos727(X,Y) get_gdat_ullong((X),(Y),727) +#define get_gdat_ip_pos727(X,Y) get_gdat_ip((X),(Y),727) +#define get_gdat_ipv6_pos727(X,Y) get_gdat_ipv6((X),(Y),727) +#define get_gdat_string_pos727(X,Y) get_gdat_string((X),(Y),727) +#define get_gdat_v_str_pos727(X,Y) get_gdat_string((X),(Y),727) +#define get_gdat_bool_pos727(X,Y) get_gdat_bool((X),(Y),727) +#define get_gdat_int_pos727(X,Y) get_gdat_int((X),(Y),727) +#define get_gdat_llong_pos727(X,Y) get_gdat_llong((X),(Y),727) +#define get_gdat_float_pos727(X,Y) get_gdat_float((X),(Y),727) +#define get_gdat_uint_pos728(X,Y) get_gdat_uint((X),(Y),728) +#define get_gdat_ullong_pos728(X,Y) get_gdat_ullong((X),(Y),728) +#define get_gdat_ip_pos728(X,Y) get_gdat_ip((X),(Y),728) +#define get_gdat_ipv6_pos728(X,Y) get_gdat_ipv6((X),(Y),728) +#define get_gdat_string_pos728(X,Y) get_gdat_string((X),(Y),728) +#define get_gdat_v_str_pos728(X,Y) get_gdat_string((X),(Y),728) +#define get_gdat_bool_pos728(X,Y) get_gdat_bool((X),(Y),728) +#define get_gdat_int_pos728(X,Y) get_gdat_int((X),(Y),728) +#define get_gdat_llong_pos728(X,Y) get_gdat_llong((X),(Y),728) +#define get_gdat_float_pos728(X,Y) get_gdat_float((X),(Y),728) +#define get_gdat_uint_pos729(X,Y) get_gdat_uint((X),(Y),729) +#define get_gdat_ullong_pos729(X,Y) get_gdat_ullong((X),(Y),729) +#define get_gdat_ip_pos729(X,Y) get_gdat_ip((X),(Y),729) +#define get_gdat_ipv6_pos729(X,Y) get_gdat_ipv6((X),(Y),729) +#define get_gdat_string_pos729(X,Y) get_gdat_string((X),(Y),729) +#define get_gdat_v_str_pos729(X,Y) get_gdat_string((X),(Y),729) +#define get_gdat_bool_pos729(X,Y) get_gdat_bool((X),(Y),729) +#define get_gdat_int_pos729(X,Y) get_gdat_int((X),(Y),729) +#define get_gdat_llong_pos729(X,Y) get_gdat_llong((X),(Y),729) +#define get_gdat_float_pos729(X,Y) get_gdat_float((X),(Y),729) +#define get_gdat_uint_pos730(X,Y) get_gdat_uint((X),(Y),730) +#define get_gdat_ullong_pos730(X,Y) get_gdat_ullong((X),(Y),730) +#define get_gdat_ip_pos730(X,Y) get_gdat_ip((X),(Y),730) +#define get_gdat_ipv6_pos730(X,Y) get_gdat_ipv6((X),(Y),730) +#define get_gdat_string_pos730(X,Y) get_gdat_string((X),(Y),730) +#define get_gdat_v_str_pos730(X,Y) get_gdat_string((X),(Y),730) +#define get_gdat_bool_pos730(X,Y) get_gdat_bool((X),(Y),730) +#define get_gdat_int_pos730(X,Y) get_gdat_int((X),(Y),730) +#define get_gdat_llong_pos730(X,Y) get_gdat_llong((X),(Y),730) +#define get_gdat_float_pos730(X,Y) get_gdat_float((X),(Y),730) +#define get_gdat_uint_pos731(X,Y) get_gdat_uint((X),(Y),731) +#define get_gdat_ullong_pos731(X,Y) get_gdat_ullong((X),(Y),731) +#define get_gdat_ip_pos731(X,Y) get_gdat_ip((X),(Y),731) +#define get_gdat_ipv6_pos731(X,Y) get_gdat_ipv6((X),(Y),731) +#define get_gdat_string_pos731(X,Y) get_gdat_string((X),(Y),731) +#define get_gdat_v_str_pos731(X,Y) get_gdat_string((X),(Y),731) +#define get_gdat_bool_pos731(X,Y) get_gdat_bool((X),(Y),731) +#define get_gdat_int_pos731(X,Y) get_gdat_int((X),(Y),731) +#define get_gdat_llong_pos731(X,Y) get_gdat_llong((X),(Y),731) +#define get_gdat_float_pos731(X,Y) get_gdat_float((X),(Y),731) +#define get_gdat_uint_pos732(X,Y) get_gdat_uint((X),(Y),732) +#define get_gdat_ullong_pos732(X,Y) get_gdat_ullong((X),(Y),732) +#define get_gdat_ip_pos732(X,Y) get_gdat_ip((X),(Y),732) +#define get_gdat_ipv6_pos732(X,Y) get_gdat_ipv6((X),(Y),732) +#define get_gdat_string_pos732(X,Y) get_gdat_string((X),(Y),732) +#define get_gdat_v_str_pos732(X,Y) get_gdat_string((X),(Y),732) +#define get_gdat_bool_pos732(X,Y) get_gdat_bool((X),(Y),732) +#define get_gdat_int_pos732(X,Y) get_gdat_int((X),(Y),732) +#define get_gdat_llong_pos732(X,Y) get_gdat_llong((X),(Y),732) +#define get_gdat_float_pos732(X,Y) get_gdat_float((X),(Y),732) +#define get_gdat_uint_pos733(X,Y) get_gdat_uint((X),(Y),733) +#define get_gdat_ullong_pos733(X,Y) get_gdat_ullong((X),(Y),733) +#define get_gdat_ip_pos733(X,Y) get_gdat_ip((X),(Y),733) +#define get_gdat_ipv6_pos733(X,Y) get_gdat_ipv6((X),(Y),733) +#define get_gdat_string_pos733(X,Y) get_gdat_string((X),(Y),733) +#define get_gdat_v_str_pos733(X,Y) get_gdat_string((X),(Y),733) +#define get_gdat_bool_pos733(X,Y) get_gdat_bool((X),(Y),733) +#define get_gdat_int_pos733(X,Y) get_gdat_int((X),(Y),733) +#define get_gdat_llong_pos733(X,Y) get_gdat_llong((X),(Y),733) +#define get_gdat_float_pos733(X,Y) get_gdat_float((X),(Y),733) +#define get_gdat_uint_pos734(X,Y) get_gdat_uint((X),(Y),734) +#define get_gdat_ullong_pos734(X,Y) get_gdat_ullong((X),(Y),734) +#define get_gdat_ip_pos734(X,Y) get_gdat_ip((X),(Y),734) +#define get_gdat_ipv6_pos734(X,Y) get_gdat_ipv6((X),(Y),734) +#define get_gdat_string_pos734(X,Y) get_gdat_string((X),(Y),734) +#define get_gdat_v_str_pos734(X,Y) get_gdat_string((X),(Y),734) +#define get_gdat_bool_pos734(X,Y) get_gdat_bool((X),(Y),734) +#define get_gdat_int_pos734(X,Y) get_gdat_int((X),(Y),734) +#define get_gdat_llong_pos734(X,Y) get_gdat_llong((X),(Y),734) +#define get_gdat_float_pos734(X,Y) get_gdat_float((X),(Y),734) +#define get_gdat_uint_pos735(X,Y) get_gdat_uint((X),(Y),735) +#define get_gdat_ullong_pos735(X,Y) get_gdat_ullong((X),(Y),735) +#define get_gdat_ip_pos735(X,Y) get_gdat_ip((X),(Y),735) +#define get_gdat_ipv6_pos735(X,Y) get_gdat_ipv6((X),(Y),735) +#define get_gdat_string_pos735(X,Y) get_gdat_string((X),(Y),735) +#define get_gdat_v_str_pos735(X,Y) get_gdat_string((X),(Y),735) +#define get_gdat_bool_pos735(X,Y) get_gdat_bool((X),(Y),735) +#define get_gdat_int_pos735(X,Y) get_gdat_int((X),(Y),735) +#define get_gdat_llong_pos735(X,Y) get_gdat_llong((X),(Y),735) +#define get_gdat_float_pos735(X,Y) get_gdat_float((X),(Y),735) +#define get_gdat_uint_pos736(X,Y) get_gdat_uint((X),(Y),736) +#define get_gdat_ullong_pos736(X,Y) get_gdat_ullong((X),(Y),736) +#define get_gdat_ip_pos736(X,Y) get_gdat_ip((X),(Y),736) +#define get_gdat_ipv6_pos736(X,Y) get_gdat_ipv6((X),(Y),736) +#define get_gdat_string_pos736(X,Y) get_gdat_string((X),(Y),736) +#define get_gdat_v_str_pos736(X,Y) get_gdat_string((X),(Y),736) +#define get_gdat_bool_pos736(X,Y) get_gdat_bool((X),(Y),736) +#define get_gdat_int_pos736(X,Y) get_gdat_int((X),(Y),736) +#define get_gdat_llong_pos736(X,Y) get_gdat_llong((X),(Y),736) +#define get_gdat_float_pos736(X,Y) get_gdat_float((X),(Y),736) +#define get_gdat_uint_pos737(X,Y) get_gdat_uint((X),(Y),737) +#define get_gdat_ullong_pos737(X,Y) get_gdat_ullong((X),(Y),737) +#define get_gdat_ip_pos737(X,Y) get_gdat_ip((X),(Y),737) +#define get_gdat_ipv6_pos737(X,Y) get_gdat_ipv6((X),(Y),737) +#define get_gdat_string_pos737(X,Y) get_gdat_string((X),(Y),737) +#define get_gdat_v_str_pos737(X,Y) get_gdat_string((X),(Y),737) +#define get_gdat_bool_pos737(X,Y) get_gdat_bool((X),(Y),737) +#define get_gdat_int_pos737(X,Y) get_gdat_int((X),(Y),737) +#define get_gdat_llong_pos737(X,Y) get_gdat_llong((X),(Y),737) +#define get_gdat_float_pos737(X,Y) get_gdat_float((X),(Y),737) +#define get_gdat_uint_pos738(X,Y) get_gdat_uint((X),(Y),738) +#define get_gdat_ullong_pos738(X,Y) get_gdat_ullong((X),(Y),738) +#define get_gdat_ip_pos738(X,Y) get_gdat_ip((X),(Y),738) +#define get_gdat_ipv6_pos738(X,Y) get_gdat_ipv6((X),(Y),738) +#define get_gdat_string_pos738(X,Y) get_gdat_string((X),(Y),738) +#define get_gdat_v_str_pos738(X,Y) get_gdat_string((X),(Y),738) +#define get_gdat_bool_pos738(X,Y) get_gdat_bool((X),(Y),738) +#define get_gdat_int_pos738(X,Y) get_gdat_int((X),(Y),738) +#define get_gdat_llong_pos738(X,Y) get_gdat_llong((X),(Y),738) +#define get_gdat_float_pos738(X,Y) get_gdat_float((X),(Y),738) +#define get_gdat_uint_pos739(X,Y) get_gdat_uint((X),(Y),739) +#define get_gdat_ullong_pos739(X,Y) get_gdat_ullong((X),(Y),739) +#define get_gdat_ip_pos739(X,Y) get_gdat_ip((X),(Y),739) +#define get_gdat_ipv6_pos739(X,Y) get_gdat_ipv6((X),(Y),739) +#define get_gdat_string_pos739(X,Y) get_gdat_string((X),(Y),739) +#define get_gdat_v_str_pos739(X,Y) get_gdat_string((X),(Y),739) +#define get_gdat_bool_pos739(X,Y) get_gdat_bool((X),(Y),739) +#define get_gdat_int_pos739(X,Y) get_gdat_int((X),(Y),739) +#define get_gdat_llong_pos739(X,Y) get_gdat_llong((X),(Y),739) +#define get_gdat_float_pos739(X,Y) get_gdat_float((X),(Y),739) +#define get_gdat_uint_pos740(X,Y) get_gdat_uint((X),(Y),740) +#define get_gdat_ullong_pos740(X,Y) get_gdat_ullong((X),(Y),740) +#define get_gdat_ip_pos740(X,Y) get_gdat_ip((X),(Y),740) +#define get_gdat_ipv6_pos740(X,Y) get_gdat_ipv6((X),(Y),740) +#define get_gdat_string_pos740(X,Y) get_gdat_string((X),(Y),740) +#define get_gdat_v_str_pos740(X,Y) get_gdat_string((X),(Y),740) +#define get_gdat_bool_pos740(X,Y) get_gdat_bool((X),(Y),740) +#define get_gdat_int_pos740(X,Y) get_gdat_int((X),(Y),740) +#define get_gdat_llong_pos740(X,Y) get_gdat_llong((X),(Y),740) +#define get_gdat_float_pos740(X,Y) get_gdat_float((X),(Y),740) +#define get_gdat_uint_pos741(X,Y) get_gdat_uint((X),(Y),741) +#define get_gdat_ullong_pos741(X,Y) get_gdat_ullong((X),(Y),741) +#define get_gdat_ip_pos741(X,Y) get_gdat_ip((X),(Y),741) +#define get_gdat_ipv6_pos741(X,Y) get_gdat_ipv6((X),(Y),741) +#define get_gdat_string_pos741(X,Y) get_gdat_string((X),(Y),741) +#define get_gdat_v_str_pos741(X,Y) get_gdat_string((X),(Y),741) +#define get_gdat_bool_pos741(X,Y) get_gdat_bool((X),(Y),741) +#define get_gdat_int_pos741(X,Y) get_gdat_int((X),(Y),741) +#define get_gdat_llong_pos741(X,Y) get_gdat_llong((X),(Y),741) +#define get_gdat_float_pos741(X,Y) get_gdat_float((X),(Y),741) +#define get_gdat_uint_pos742(X,Y) get_gdat_uint((X),(Y),742) +#define get_gdat_ullong_pos742(X,Y) get_gdat_ullong((X),(Y),742) +#define get_gdat_ip_pos742(X,Y) get_gdat_ip((X),(Y),742) +#define get_gdat_ipv6_pos742(X,Y) get_gdat_ipv6((X),(Y),742) +#define get_gdat_string_pos742(X,Y) get_gdat_string((X),(Y),742) +#define get_gdat_v_str_pos742(X,Y) get_gdat_string((X),(Y),742) +#define get_gdat_bool_pos742(X,Y) get_gdat_bool((X),(Y),742) +#define get_gdat_int_pos742(X,Y) get_gdat_int((X),(Y),742) +#define get_gdat_llong_pos742(X,Y) get_gdat_llong((X),(Y),742) +#define get_gdat_float_pos742(X,Y) get_gdat_float((X),(Y),742) +#define get_gdat_uint_pos743(X,Y) get_gdat_uint((X),(Y),743) +#define get_gdat_ullong_pos743(X,Y) get_gdat_ullong((X),(Y),743) +#define get_gdat_ip_pos743(X,Y) get_gdat_ip((X),(Y),743) +#define get_gdat_ipv6_pos743(X,Y) get_gdat_ipv6((X),(Y),743) +#define get_gdat_string_pos743(X,Y) get_gdat_string((X),(Y),743) +#define get_gdat_v_str_pos743(X,Y) get_gdat_string((X),(Y),743) +#define get_gdat_bool_pos743(X,Y) get_gdat_bool((X),(Y),743) +#define get_gdat_int_pos743(X,Y) get_gdat_int((X),(Y),743) +#define get_gdat_llong_pos743(X,Y) get_gdat_llong((X),(Y),743) +#define get_gdat_float_pos743(X,Y) get_gdat_float((X),(Y),743) +#define get_gdat_uint_pos744(X,Y) get_gdat_uint((X),(Y),744) +#define get_gdat_ullong_pos744(X,Y) get_gdat_ullong((X),(Y),744) +#define get_gdat_ip_pos744(X,Y) get_gdat_ip((X),(Y),744) +#define get_gdat_ipv6_pos744(X,Y) get_gdat_ipv6((X),(Y),744) +#define get_gdat_string_pos744(X,Y) get_gdat_string((X),(Y),744) +#define get_gdat_v_str_pos744(X,Y) get_gdat_string((X),(Y),744) +#define get_gdat_bool_pos744(X,Y) get_gdat_bool((X),(Y),744) +#define get_gdat_int_pos744(X,Y) get_gdat_int((X),(Y),744) +#define get_gdat_llong_pos744(X,Y) get_gdat_llong((X),(Y),744) +#define get_gdat_float_pos744(X,Y) get_gdat_float((X),(Y),744) +#define get_gdat_uint_pos745(X,Y) get_gdat_uint((X),(Y),745) +#define get_gdat_ullong_pos745(X,Y) get_gdat_ullong((X),(Y),745) +#define get_gdat_ip_pos745(X,Y) get_gdat_ip((X),(Y),745) +#define get_gdat_ipv6_pos745(X,Y) get_gdat_ipv6((X),(Y),745) +#define get_gdat_string_pos745(X,Y) get_gdat_string((X),(Y),745) +#define get_gdat_v_str_pos745(X,Y) get_gdat_string((X),(Y),745) +#define get_gdat_bool_pos745(X,Y) get_gdat_bool((X),(Y),745) +#define get_gdat_int_pos745(X,Y) get_gdat_int((X),(Y),745) +#define get_gdat_llong_pos745(X,Y) get_gdat_llong((X),(Y),745) +#define get_gdat_float_pos745(X,Y) get_gdat_float((X),(Y),745) +#define get_gdat_uint_pos746(X,Y) get_gdat_uint((X),(Y),746) +#define get_gdat_ullong_pos746(X,Y) get_gdat_ullong((X),(Y),746) +#define get_gdat_ip_pos746(X,Y) get_gdat_ip((X),(Y),746) +#define get_gdat_ipv6_pos746(X,Y) get_gdat_ipv6((X),(Y),746) +#define get_gdat_string_pos746(X,Y) get_gdat_string((X),(Y),746) +#define get_gdat_v_str_pos746(X,Y) get_gdat_string((X),(Y),746) +#define get_gdat_bool_pos746(X,Y) get_gdat_bool((X),(Y),746) +#define get_gdat_int_pos746(X,Y) get_gdat_int((X),(Y),746) +#define get_gdat_llong_pos746(X,Y) get_gdat_llong((X),(Y),746) +#define get_gdat_float_pos746(X,Y) get_gdat_float((X),(Y),746) +#define get_gdat_uint_pos747(X,Y) get_gdat_uint((X),(Y),747) +#define get_gdat_ullong_pos747(X,Y) get_gdat_ullong((X),(Y),747) +#define get_gdat_ip_pos747(X,Y) get_gdat_ip((X),(Y),747) +#define get_gdat_ipv6_pos747(X,Y) get_gdat_ipv6((X),(Y),747) +#define get_gdat_string_pos747(X,Y) get_gdat_string((X),(Y),747) +#define get_gdat_v_str_pos747(X,Y) get_gdat_string((X),(Y),747) +#define get_gdat_bool_pos747(X,Y) get_gdat_bool((X),(Y),747) +#define get_gdat_int_pos747(X,Y) get_gdat_int((X),(Y),747) +#define get_gdat_llong_pos747(X,Y) get_gdat_llong((X),(Y),747) +#define get_gdat_float_pos747(X,Y) get_gdat_float((X),(Y),747) +#define get_gdat_uint_pos748(X,Y) get_gdat_uint((X),(Y),748) +#define get_gdat_ullong_pos748(X,Y) get_gdat_ullong((X),(Y),748) +#define get_gdat_ip_pos748(X,Y) get_gdat_ip((X),(Y),748) +#define get_gdat_ipv6_pos748(X,Y) get_gdat_ipv6((X),(Y),748) +#define get_gdat_string_pos748(X,Y) get_gdat_string((X),(Y),748) +#define get_gdat_v_str_pos748(X,Y) get_gdat_string((X),(Y),748) +#define get_gdat_bool_pos748(X,Y) get_gdat_bool((X),(Y),748) +#define get_gdat_int_pos748(X,Y) get_gdat_int((X),(Y),748) +#define get_gdat_llong_pos748(X,Y) get_gdat_llong((X),(Y),748) +#define get_gdat_float_pos748(X,Y) get_gdat_float((X),(Y),748) +#define get_gdat_uint_pos749(X,Y) get_gdat_uint((X),(Y),749) +#define get_gdat_ullong_pos749(X,Y) get_gdat_ullong((X),(Y),749) +#define get_gdat_ip_pos749(X,Y) get_gdat_ip((X),(Y),749) +#define get_gdat_ipv6_pos749(X,Y) get_gdat_ipv6((X),(Y),749) +#define get_gdat_string_pos749(X,Y) get_gdat_string((X),(Y),749) +#define get_gdat_v_str_pos749(X,Y) get_gdat_string((X),(Y),749) +#define get_gdat_bool_pos749(X,Y) get_gdat_bool((X),(Y),749) +#define get_gdat_int_pos749(X,Y) get_gdat_int((X),(Y),749) +#define get_gdat_llong_pos749(X,Y) get_gdat_llong((X),(Y),749) +#define get_gdat_float_pos749(X,Y) get_gdat_float((X),(Y),749) +#define get_gdat_uint_pos750(X,Y) get_gdat_uint((X),(Y),750) +#define get_gdat_ullong_pos750(X,Y) get_gdat_ullong((X),(Y),750) +#define get_gdat_ip_pos750(X,Y) get_gdat_ip((X),(Y),750) +#define get_gdat_ipv6_pos750(X,Y) get_gdat_ipv6((X),(Y),750) +#define get_gdat_string_pos750(X,Y) get_gdat_string((X),(Y),750) +#define get_gdat_v_str_pos750(X,Y) get_gdat_string((X),(Y),750) +#define get_gdat_bool_pos750(X,Y) get_gdat_bool((X),(Y),750) +#define get_gdat_int_pos750(X,Y) get_gdat_int((X),(Y),750) +#define get_gdat_llong_pos750(X,Y) get_gdat_llong((X),(Y),750) +#define get_gdat_float_pos750(X,Y) get_gdat_float((X),(Y),750) +#define get_gdat_uint_pos751(X,Y) get_gdat_uint((X),(Y),751) +#define get_gdat_ullong_pos751(X,Y) get_gdat_ullong((X),(Y),751) +#define get_gdat_ip_pos751(X,Y) get_gdat_ip((X),(Y),751) +#define get_gdat_ipv6_pos751(X,Y) get_gdat_ipv6((X),(Y),751) +#define get_gdat_string_pos751(X,Y) get_gdat_string((X),(Y),751) +#define get_gdat_v_str_pos751(X,Y) get_gdat_string((X),(Y),751) +#define get_gdat_bool_pos751(X,Y) get_gdat_bool((X),(Y),751) +#define get_gdat_int_pos751(X,Y) get_gdat_int((X),(Y),751) +#define get_gdat_llong_pos751(X,Y) get_gdat_llong((X),(Y),751) +#define get_gdat_float_pos751(X,Y) get_gdat_float((X),(Y),751) +#define get_gdat_uint_pos752(X,Y) get_gdat_uint((X),(Y),752) +#define get_gdat_ullong_pos752(X,Y) get_gdat_ullong((X),(Y),752) +#define get_gdat_ip_pos752(X,Y) get_gdat_ip((X),(Y),752) +#define get_gdat_ipv6_pos752(X,Y) get_gdat_ipv6((X),(Y),752) +#define get_gdat_string_pos752(X,Y) get_gdat_string((X),(Y),752) +#define get_gdat_v_str_pos752(X,Y) get_gdat_string((X),(Y),752) +#define get_gdat_bool_pos752(X,Y) get_gdat_bool((X),(Y),752) +#define get_gdat_int_pos752(X,Y) get_gdat_int((X),(Y),752) +#define get_gdat_llong_pos752(X,Y) get_gdat_llong((X),(Y),752) +#define get_gdat_float_pos752(X,Y) get_gdat_float((X),(Y),752) +#define get_gdat_uint_pos753(X,Y) get_gdat_uint((X),(Y),753) +#define get_gdat_ullong_pos753(X,Y) get_gdat_ullong((X),(Y),753) +#define get_gdat_ip_pos753(X,Y) get_gdat_ip((X),(Y),753) +#define get_gdat_ipv6_pos753(X,Y) get_gdat_ipv6((X),(Y),753) +#define get_gdat_string_pos753(X,Y) get_gdat_string((X),(Y),753) +#define get_gdat_v_str_pos753(X,Y) get_gdat_string((X),(Y),753) +#define get_gdat_bool_pos753(X,Y) get_gdat_bool((X),(Y),753) +#define get_gdat_int_pos753(X,Y) get_gdat_int((X),(Y),753) +#define get_gdat_llong_pos753(X,Y) get_gdat_llong((X),(Y),753) +#define get_gdat_float_pos753(X,Y) get_gdat_float((X),(Y),753) +#define get_gdat_uint_pos754(X,Y) get_gdat_uint((X),(Y),754) +#define get_gdat_ullong_pos754(X,Y) get_gdat_ullong((X),(Y),754) +#define get_gdat_ip_pos754(X,Y) get_gdat_ip((X),(Y),754) +#define get_gdat_ipv6_pos754(X,Y) get_gdat_ipv6((X),(Y),754) +#define get_gdat_string_pos754(X,Y) get_gdat_string((X),(Y),754) +#define get_gdat_v_str_pos754(X,Y) get_gdat_string((X),(Y),754) +#define get_gdat_bool_pos754(X,Y) get_gdat_bool((X),(Y),754) +#define get_gdat_int_pos754(X,Y) get_gdat_int((X),(Y),754) +#define get_gdat_llong_pos754(X,Y) get_gdat_llong((X),(Y),754) +#define get_gdat_float_pos754(X,Y) get_gdat_float((X),(Y),754) +#define get_gdat_uint_pos755(X,Y) get_gdat_uint((X),(Y),755) +#define get_gdat_ullong_pos755(X,Y) get_gdat_ullong((X),(Y),755) +#define get_gdat_ip_pos755(X,Y) get_gdat_ip((X),(Y),755) +#define get_gdat_ipv6_pos755(X,Y) get_gdat_ipv6((X),(Y),755) +#define get_gdat_string_pos755(X,Y) get_gdat_string((X),(Y),755) +#define get_gdat_v_str_pos755(X,Y) get_gdat_string((X),(Y),755) +#define get_gdat_bool_pos755(X,Y) get_gdat_bool((X),(Y),755) +#define get_gdat_int_pos755(X,Y) get_gdat_int((X),(Y),755) +#define get_gdat_llong_pos755(X,Y) get_gdat_llong((X),(Y),755) +#define get_gdat_float_pos755(X,Y) get_gdat_float((X),(Y),755) +#define get_gdat_uint_pos756(X,Y) get_gdat_uint((X),(Y),756) +#define get_gdat_ullong_pos756(X,Y) get_gdat_ullong((X),(Y),756) +#define get_gdat_ip_pos756(X,Y) get_gdat_ip((X),(Y),756) +#define get_gdat_ipv6_pos756(X,Y) get_gdat_ipv6((X),(Y),756) +#define get_gdat_string_pos756(X,Y) get_gdat_string((X),(Y),756) +#define get_gdat_v_str_pos756(X,Y) get_gdat_string((X),(Y),756) +#define get_gdat_bool_pos756(X,Y) get_gdat_bool((X),(Y),756) +#define get_gdat_int_pos756(X,Y) get_gdat_int((X),(Y),756) +#define get_gdat_llong_pos756(X,Y) get_gdat_llong((X),(Y),756) +#define get_gdat_float_pos756(X,Y) get_gdat_float((X),(Y),756) +#define get_gdat_uint_pos757(X,Y) get_gdat_uint((X),(Y),757) +#define get_gdat_ullong_pos757(X,Y) get_gdat_ullong((X),(Y),757) +#define get_gdat_ip_pos757(X,Y) get_gdat_ip((X),(Y),757) +#define get_gdat_ipv6_pos757(X,Y) get_gdat_ipv6((X),(Y),757) +#define get_gdat_string_pos757(X,Y) get_gdat_string((X),(Y),757) +#define get_gdat_v_str_pos757(X,Y) get_gdat_string((X),(Y),757) +#define get_gdat_bool_pos757(X,Y) get_gdat_bool((X),(Y),757) +#define get_gdat_int_pos757(X,Y) get_gdat_int((X),(Y),757) +#define get_gdat_llong_pos757(X,Y) get_gdat_llong((X),(Y),757) +#define get_gdat_float_pos757(X,Y) get_gdat_float((X),(Y),757) +#define get_gdat_uint_pos758(X,Y) get_gdat_uint((X),(Y),758) +#define get_gdat_ullong_pos758(X,Y) get_gdat_ullong((X),(Y),758) +#define get_gdat_ip_pos758(X,Y) get_gdat_ip((X),(Y),758) +#define get_gdat_ipv6_pos758(X,Y) get_gdat_ipv6((X),(Y),758) +#define get_gdat_string_pos758(X,Y) get_gdat_string((X),(Y),758) +#define get_gdat_v_str_pos758(X,Y) get_gdat_string((X),(Y),758) +#define get_gdat_bool_pos758(X,Y) get_gdat_bool((X),(Y),758) +#define get_gdat_int_pos758(X,Y) get_gdat_int((X),(Y),758) +#define get_gdat_llong_pos758(X,Y) get_gdat_llong((X),(Y),758) +#define get_gdat_float_pos758(X,Y) get_gdat_float((X),(Y),758) +#define get_gdat_uint_pos759(X,Y) get_gdat_uint((X),(Y),759) +#define get_gdat_ullong_pos759(X,Y) get_gdat_ullong((X),(Y),759) +#define get_gdat_ip_pos759(X,Y) get_gdat_ip((X),(Y),759) +#define get_gdat_ipv6_pos759(X,Y) get_gdat_ipv6((X),(Y),759) +#define get_gdat_string_pos759(X,Y) get_gdat_string((X),(Y),759) +#define get_gdat_v_str_pos759(X,Y) get_gdat_string((X),(Y),759) +#define get_gdat_bool_pos759(X,Y) get_gdat_bool((X),(Y),759) +#define get_gdat_int_pos759(X,Y) get_gdat_int((X),(Y),759) +#define get_gdat_llong_pos759(X,Y) get_gdat_llong((X),(Y),759) +#define get_gdat_float_pos759(X,Y) get_gdat_float((X),(Y),759) +#define get_gdat_uint_pos760(X,Y) get_gdat_uint((X),(Y),760) +#define get_gdat_ullong_pos760(X,Y) get_gdat_ullong((X),(Y),760) +#define get_gdat_ip_pos760(X,Y) get_gdat_ip((X),(Y),760) +#define get_gdat_ipv6_pos760(X,Y) get_gdat_ipv6((X),(Y),760) +#define get_gdat_string_pos760(X,Y) get_gdat_string((X),(Y),760) +#define get_gdat_v_str_pos760(X,Y) get_gdat_string((X),(Y),760) +#define get_gdat_bool_pos760(X,Y) get_gdat_bool((X),(Y),760) +#define get_gdat_int_pos760(X,Y) get_gdat_int((X),(Y),760) +#define get_gdat_llong_pos760(X,Y) get_gdat_llong((X),(Y),760) +#define get_gdat_float_pos760(X,Y) get_gdat_float((X),(Y),760) +#define get_gdat_uint_pos761(X,Y) get_gdat_uint((X),(Y),761) +#define get_gdat_ullong_pos761(X,Y) get_gdat_ullong((X),(Y),761) +#define get_gdat_ip_pos761(X,Y) get_gdat_ip((X),(Y),761) +#define get_gdat_ipv6_pos761(X,Y) get_gdat_ipv6((X),(Y),761) +#define get_gdat_string_pos761(X,Y) get_gdat_string((X),(Y),761) +#define get_gdat_v_str_pos761(X,Y) get_gdat_string((X),(Y),761) +#define get_gdat_bool_pos761(X,Y) get_gdat_bool((X),(Y),761) +#define get_gdat_int_pos761(X,Y) get_gdat_int((X),(Y),761) +#define get_gdat_llong_pos761(X,Y) get_gdat_llong((X),(Y),761) +#define get_gdat_float_pos761(X,Y) get_gdat_float((X),(Y),761) +#define get_gdat_uint_pos762(X,Y) get_gdat_uint((X),(Y),762) +#define get_gdat_ullong_pos762(X,Y) get_gdat_ullong((X),(Y),762) +#define get_gdat_ip_pos762(X,Y) get_gdat_ip((X),(Y),762) +#define get_gdat_ipv6_pos762(X,Y) get_gdat_ipv6((X),(Y),762) +#define get_gdat_string_pos762(X,Y) get_gdat_string((X),(Y),762) +#define get_gdat_v_str_pos762(X,Y) get_gdat_string((X),(Y),762) +#define get_gdat_bool_pos762(X,Y) get_gdat_bool((X),(Y),762) +#define get_gdat_int_pos762(X,Y) get_gdat_int((X),(Y),762) +#define get_gdat_llong_pos762(X,Y) get_gdat_llong((X),(Y),762) +#define get_gdat_float_pos762(X,Y) get_gdat_float((X),(Y),762) +#define get_gdat_uint_pos763(X,Y) get_gdat_uint((X),(Y),763) +#define get_gdat_ullong_pos763(X,Y) get_gdat_ullong((X),(Y),763) +#define get_gdat_ip_pos763(X,Y) get_gdat_ip((X),(Y),763) +#define get_gdat_ipv6_pos763(X,Y) get_gdat_ipv6((X),(Y),763) +#define get_gdat_string_pos763(X,Y) get_gdat_string((X),(Y),763) +#define get_gdat_v_str_pos763(X,Y) get_gdat_string((X),(Y),763) +#define get_gdat_bool_pos763(X,Y) get_gdat_bool((X),(Y),763) +#define get_gdat_int_pos763(X,Y) get_gdat_int((X),(Y),763) +#define get_gdat_llong_pos763(X,Y) get_gdat_llong((X),(Y),763) +#define get_gdat_float_pos763(X,Y) get_gdat_float((X),(Y),763) +#define get_gdat_uint_pos764(X,Y) get_gdat_uint((X),(Y),764) +#define get_gdat_ullong_pos764(X,Y) get_gdat_ullong((X),(Y),764) +#define get_gdat_ip_pos764(X,Y) get_gdat_ip((X),(Y),764) +#define get_gdat_ipv6_pos764(X,Y) get_gdat_ipv6((X),(Y),764) +#define get_gdat_string_pos764(X,Y) get_gdat_string((X),(Y),764) +#define get_gdat_v_str_pos764(X,Y) get_gdat_string((X),(Y),764) +#define get_gdat_bool_pos764(X,Y) get_gdat_bool((X),(Y),764) +#define get_gdat_int_pos764(X,Y) get_gdat_int((X),(Y),764) +#define get_gdat_llong_pos764(X,Y) get_gdat_llong((X),(Y),764) +#define get_gdat_float_pos764(X,Y) get_gdat_float((X),(Y),764) +#define get_gdat_uint_pos765(X,Y) get_gdat_uint((X),(Y),765) +#define get_gdat_ullong_pos765(X,Y) get_gdat_ullong((X),(Y),765) +#define get_gdat_ip_pos765(X,Y) get_gdat_ip((X),(Y),765) +#define get_gdat_ipv6_pos765(X,Y) get_gdat_ipv6((X),(Y),765) +#define get_gdat_string_pos765(X,Y) get_gdat_string((X),(Y),765) +#define get_gdat_v_str_pos765(X,Y) get_gdat_string((X),(Y),765) +#define get_gdat_bool_pos765(X,Y) get_gdat_bool((X),(Y),765) +#define get_gdat_int_pos765(X,Y) get_gdat_int((X),(Y),765) +#define get_gdat_llong_pos765(X,Y) get_gdat_llong((X),(Y),765) +#define get_gdat_float_pos765(X,Y) get_gdat_float((X),(Y),765) +#define get_gdat_uint_pos766(X,Y) get_gdat_uint((X),(Y),766) +#define get_gdat_ullong_pos766(X,Y) get_gdat_ullong((X),(Y),766) +#define get_gdat_ip_pos766(X,Y) get_gdat_ip((X),(Y),766) +#define get_gdat_ipv6_pos766(X,Y) get_gdat_ipv6((X),(Y),766) +#define get_gdat_string_pos766(X,Y) get_gdat_string((X),(Y),766) +#define get_gdat_v_str_pos766(X,Y) get_gdat_string((X),(Y),766) +#define get_gdat_bool_pos766(X,Y) get_gdat_bool((X),(Y),766) +#define get_gdat_int_pos766(X,Y) get_gdat_int((X),(Y),766) +#define get_gdat_llong_pos766(X,Y) get_gdat_llong((X),(Y),766) +#define get_gdat_float_pos766(X,Y) get_gdat_float((X),(Y),766) +#define get_gdat_uint_pos767(X,Y) get_gdat_uint((X),(Y),767) +#define get_gdat_ullong_pos767(X,Y) get_gdat_ullong((X),(Y),767) +#define get_gdat_ip_pos767(X,Y) get_gdat_ip((X),(Y),767) +#define get_gdat_ipv6_pos767(X,Y) get_gdat_ipv6((X),(Y),767) +#define get_gdat_string_pos767(X,Y) get_gdat_string((X),(Y),767) +#define get_gdat_v_str_pos767(X,Y) get_gdat_string((X),(Y),767) +#define get_gdat_bool_pos767(X,Y) get_gdat_bool((X),(Y),767) +#define get_gdat_int_pos767(X,Y) get_gdat_int((X),(Y),767) +#define get_gdat_llong_pos767(X,Y) get_gdat_llong((X),(Y),767) +#define get_gdat_float_pos767(X,Y) get_gdat_float((X),(Y),767) +#define get_gdat_uint_pos768(X,Y) get_gdat_uint((X),(Y),768) +#define get_gdat_ullong_pos768(X,Y) get_gdat_ullong((X),(Y),768) +#define get_gdat_ip_pos768(X,Y) get_gdat_ip((X),(Y),768) +#define get_gdat_ipv6_pos768(X,Y) get_gdat_ipv6((X),(Y),768) +#define get_gdat_string_pos768(X,Y) get_gdat_string((X),(Y),768) +#define get_gdat_v_str_pos768(X,Y) get_gdat_string((X),(Y),768) +#define get_gdat_bool_pos768(X,Y) get_gdat_bool((X),(Y),768) +#define get_gdat_int_pos768(X,Y) get_gdat_int((X),(Y),768) +#define get_gdat_llong_pos768(X,Y) get_gdat_llong((X),(Y),768) +#define get_gdat_float_pos768(X,Y) get_gdat_float((X),(Y),768) +#define get_gdat_uint_pos769(X,Y) get_gdat_uint((X),(Y),769) +#define get_gdat_ullong_pos769(X,Y) get_gdat_ullong((X),(Y),769) +#define get_gdat_ip_pos769(X,Y) get_gdat_ip((X),(Y),769) +#define get_gdat_ipv6_pos769(X,Y) get_gdat_ipv6((X),(Y),769) +#define get_gdat_string_pos769(X,Y) get_gdat_string((X),(Y),769) +#define get_gdat_v_str_pos769(X,Y) get_gdat_string((X),(Y),769) +#define get_gdat_bool_pos769(X,Y) get_gdat_bool((X),(Y),769) +#define get_gdat_int_pos769(X,Y) get_gdat_int((X),(Y),769) +#define get_gdat_llong_pos769(X,Y) get_gdat_llong((X),(Y),769) +#define get_gdat_float_pos769(X,Y) get_gdat_float((X),(Y),769) +#define get_gdat_uint_pos770(X,Y) get_gdat_uint((X),(Y),770) +#define get_gdat_ullong_pos770(X,Y) get_gdat_ullong((X),(Y),770) +#define get_gdat_ip_pos770(X,Y) get_gdat_ip((X),(Y),770) +#define get_gdat_ipv6_pos770(X,Y) get_gdat_ipv6((X),(Y),770) +#define get_gdat_string_pos770(X,Y) get_gdat_string((X),(Y),770) +#define get_gdat_v_str_pos770(X,Y) get_gdat_string((X),(Y),770) +#define get_gdat_bool_pos770(X,Y) get_gdat_bool((X),(Y),770) +#define get_gdat_int_pos770(X,Y) get_gdat_int((X),(Y),770) +#define get_gdat_llong_pos770(X,Y) get_gdat_llong((X),(Y),770) +#define get_gdat_float_pos770(X,Y) get_gdat_float((X),(Y),770) +#define get_gdat_uint_pos771(X,Y) get_gdat_uint((X),(Y),771) +#define get_gdat_ullong_pos771(X,Y) get_gdat_ullong((X),(Y),771) +#define get_gdat_ip_pos771(X,Y) get_gdat_ip((X),(Y),771) +#define get_gdat_ipv6_pos771(X,Y) get_gdat_ipv6((X),(Y),771) +#define get_gdat_string_pos771(X,Y) get_gdat_string((X),(Y),771) +#define get_gdat_v_str_pos771(X,Y) get_gdat_string((X),(Y),771) +#define get_gdat_bool_pos771(X,Y) get_gdat_bool((X),(Y),771) +#define get_gdat_int_pos771(X,Y) get_gdat_int((X),(Y),771) +#define get_gdat_llong_pos771(X,Y) get_gdat_llong((X),(Y),771) +#define get_gdat_float_pos771(X,Y) get_gdat_float((X),(Y),771) +#define get_gdat_uint_pos772(X,Y) get_gdat_uint((X),(Y),772) +#define get_gdat_ullong_pos772(X,Y) get_gdat_ullong((X),(Y),772) +#define get_gdat_ip_pos772(X,Y) get_gdat_ip((X),(Y),772) +#define get_gdat_ipv6_pos772(X,Y) get_gdat_ipv6((X),(Y),772) +#define get_gdat_string_pos772(X,Y) get_gdat_string((X),(Y),772) +#define get_gdat_v_str_pos772(X,Y) get_gdat_string((X),(Y),772) +#define get_gdat_bool_pos772(X,Y) get_gdat_bool((X),(Y),772) +#define get_gdat_int_pos772(X,Y) get_gdat_int((X),(Y),772) +#define get_gdat_llong_pos772(X,Y) get_gdat_llong((X),(Y),772) +#define get_gdat_float_pos772(X,Y) get_gdat_float((X),(Y),772) +#define get_gdat_uint_pos773(X,Y) get_gdat_uint((X),(Y),773) +#define get_gdat_ullong_pos773(X,Y) get_gdat_ullong((X),(Y),773) +#define get_gdat_ip_pos773(X,Y) get_gdat_ip((X),(Y),773) +#define get_gdat_ipv6_pos773(X,Y) get_gdat_ipv6((X),(Y),773) +#define get_gdat_string_pos773(X,Y) get_gdat_string((X),(Y),773) +#define get_gdat_v_str_pos773(X,Y) get_gdat_string((X),(Y),773) +#define get_gdat_bool_pos773(X,Y) get_gdat_bool((X),(Y),773) +#define get_gdat_int_pos773(X,Y) get_gdat_int((X),(Y),773) +#define get_gdat_llong_pos773(X,Y) get_gdat_llong((X),(Y),773) +#define get_gdat_float_pos773(X,Y) get_gdat_float((X),(Y),773) +#define get_gdat_uint_pos774(X,Y) get_gdat_uint((X),(Y),774) +#define get_gdat_ullong_pos774(X,Y) get_gdat_ullong((X),(Y),774) +#define get_gdat_ip_pos774(X,Y) get_gdat_ip((X),(Y),774) +#define get_gdat_ipv6_pos774(X,Y) get_gdat_ipv6((X),(Y),774) +#define get_gdat_string_pos774(X,Y) get_gdat_string((X),(Y),774) +#define get_gdat_v_str_pos774(X,Y) get_gdat_string((X),(Y),774) +#define get_gdat_bool_pos774(X,Y) get_gdat_bool((X),(Y),774) +#define get_gdat_int_pos774(X,Y) get_gdat_int((X),(Y),774) +#define get_gdat_llong_pos774(X,Y) get_gdat_llong((X),(Y),774) +#define get_gdat_float_pos774(X,Y) get_gdat_float((X),(Y),774) +#define get_gdat_uint_pos775(X,Y) get_gdat_uint((X),(Y),775) +#define get_gdat_ullong_pos775(X,Y) get_gdat_ullong((X),(Y),775) +#define get_gdat_ip_pos775(X,Y) get_gdat_ip((X),(Y),775) +#define get_gdat_ipv6_pos775(X,Y) get_gdat_ipv6((X),(Y),775) +#define get_gdat_string_pos775(X,Y) get_gdat_string((X),(Y),775) +#define get_gdat_v_str_pos775(X,Y) get_gdat_string((X),(Y),775) +#define get_gdat_bool_pos775(X,Y) get_gdat_bool((X),(Y),775) +#define get_gdat_int_pos775(X,Y) get_gdat_int((X),(Y),775) +#define get_gdat_llong_pos775(X,Y) get_gdat_llong((X),(Y),775) +#define get_gdat_float_pos775(X,Y) get_gdat_float((X),(Y),775) +#define get_gdat_uint_pos776(X,Y) get_gdat_uint((X),(Y),776) +#define get_gdat_ullong_pos776(X,Y) get_gdat_ullong((X),(Y),776) +#define get_gdat_ip_pos776(X,Y) get_gdat_ip((X),(Y),776) +#define get_gdat_ipv6_pos776(X,Y) get_gdat_ipv6((X),(Y),776) +#define get_gdat_string_pos776(X,Y) get_gdat_string((X),(Y),776) +#define get_gdat_v_str_pos776(X,Y) get_gdat_string((X),(Y),776) +#define get_gdat_bool_pos776(X,Y) get_gdat_bool((X),(Y),776) +#define get_gdat_int_pos776(X,Y) get_gdat_int((X),(Y),776) +#define get_gdat_llong_pos776(X,Y) get_gdat_llong((X),(Y),776) +#define get_gdat_float_pos776(X,Y) get_gdat_float((X),(Y),776) +#define get_gdat_uint_pos777(X,Y) get_gdat_uint((X),(Y),777) +#define get_gdat_ullong_pos777(X,Y) get_gdat_ullong((X),(Y),777) +#define get_gdat_ip_pos777(X,Y) get_gdat_ip((X),(Y),777) +#define get_gdat_ipv6_pos777(X,Y) get_gdat_ipv6((X),(Y),777) +#define get_gdat_string_pos777(X,Y) get_gdat_string((X),(Y),777) +#define get_gdat_v_str_pos777(X,Y) get_gdat_string((X),(Y),777) +#define get_gdat_bool_pos777(X,Y) get_gdat_bool((X),(Y),777) +#define get_gdat_int_pos777(X,Y) get_gdat_int((X),(Y),777) +#define get_gdat_llong_pos777(X,Y) get_gdat_llong((X),(Y),777) +#define get_gdat_float_pos777(X,Y) get_gdat_float((X),(Y),777) +#define get_gdat_uint_pos778(X,Y) get_gdat_uint((X),(Y),778) +#define get_gdat_ullong_pos778(X,Y) get_gdat_ullong((X),(Y),778) +#define get_gdat_ip_pos778(X,Y) get_gdat_ip((X),(Y),778) +#define get_gdat_ipv6_pos778(X,Y) get_gdat_ipv6((X),(Y),778) +#define get_gdat_string_pos778(X,Y) get_gdat_string((X),(Y),778) +#define get_gdat_v_str_pos778(X,Y) get_gdat_string((X),(Y),778) +#define get_gdat_bool_pos778(X,Y) get_gdat_bool((X),(Y),778) +#define get_gdat_int_pos778(X,Y) get_gdat_int((X),(Y),778) +#define get_gdat_llong_pos778(X,Y) get_gdat_llong((X),(Y),778) +#define get_gdat_float_pos778(X,Y) get_gdat_float((X),(Y),778) +#define get_gdat_uint_pos779(X,Y) get_gdat_uint((X),(Y),779) +#define get_gdat_ullong_pos779(X,Y) get_gdat_ullong((X),(Y),779) +#define get_gdat_ip_pos779(X,Y) get_gdat_ip((X),(Y),779) +#define get_gdat_ipv6_pos779(X,Y) get_gdat_ipv6((X),(Y),779) +#define get_gdat_string_pos779(X,Y) get_gdat_string((X),(Y),779) +#define get_gdat_v_str_pos779(X,Y) get_gdat_string((X),(Y),779) +#define get_gdat_bool_pos779(X,Y) get_gdat_bool((X),(Y),779) +#define get_gdat_int_pos779(X,Y) get_gdat_int((X),(Y),779) +#define get_gdat_llong_pos779(X,Y) get_gdat_llong((X),(Y),779) +#define get_gdat_float_pos779(X,Y) get_gdat_float((X),(Y),779) +#define get_gdat_uint_pos780(X,Y) get_gdat_uint((X),(Y),780) +#define get_gdat_ullong_pos780(X,Y) get_gdat_ullong((X),(Y),780) +#define get_gdat_ip_pos780(X,Y) get_gdat_ip((X),(Y),780) +#define get_gdat_ipv6_pos780(X,Y) get_gdat_ipv6((X),(Y),780) +#define get_gdat_string_pos780(X,Y) get_gdat_string((X),(Y),780) +#define get_gdat_v_str_pos780(X,Y) get_gdat_string((X),(Y),780) +#define get_gdat_bool_pos780(X,Y) get_gdat_bool((X),(Y),780) +#define get_gdat_int_pos780(X,Y) get_gdat_int((X),(Y),780) +#define get_gdat_llong_pos780(X,Y) get_gdat_llong((X),(Y),780) +#define get_gdat_float_pos780(X,Y) get_gdat_float((X),(Y),780) +#define get_gdat_uint_pos781(X,Y) get_gdat_uint((X),(Y),781) +#define get_gdat_ullong_pos781(X,Y) get_gdat_ullong((X),(Y),781) +#define get_gdat_ip_pos781(X,Y) get_gdat_ip((X),(Y),781) +#define get_gdat_ipv6_pos781(X,Y) get_gdat_ipv6((X),(Y),781) +#define get_gdat_string_pos781(X,Y) get_gdat_string((X),(Y),781) +#define get_gdat_v_str_pos781(X,Y) get_gdat_string((X),(Y),781) +#define get_gdat_bool_pos781(X,Y) get_gdat_bool((X),(Y),781) +#define get_gdat_int_pos781(X,Y) get_gdat_int((X),(Y),781) +#define get_gdat_llong_pos781(X,Y) get_gdat_llong((X),(Y),781) +#define get_gdat_float_pos781(X,Y) get_gdat_float((X),(Y),781) +#define get_gdat_uint_pos782(X,Y) get_gdat_uint((X),(Y),782) +#define get_gdat_ullong_pos782(X,Y) get_gdat_ullong((X),(Y),782) +#define get_gdat_ip_pos782(X,Y) get_gdat_ip((X),(Y),782) +#define get_gdat_ipv6_pos782(X,Y) get_gdat_ipv6((X),(Y),782) +#define get_gdat_string_pos782(X,Y) get_gdat_string((X),(Y),782) +#define get_gdat_v_str_pos782(X,Y) get_gdat_string((X),(Y),782) +#define get_gdat_bool_pos782(X,Y) get_gdat_bool((X),(Y),782) +#define get_gdat_int_pos782(X,Y) get_gdat_int((X),(Y),782) +#define get_gdat_llong_pos782(X,Y) get_gdat_llong((X),(Y),782) +#define get_gdat_float_pos782(X,Y) get_gdat_float((X),(Y),782) +#define get_gdat_uint_pos783(X,Y) get_gdat_uint((X),(Y),783) +#define get_gdat_ullong_pos783(X,Y) get_gdat_ullong((X),(Y),783) +#define get_gdat_ip_pos783(X,Y) get_gdat_ip((X),(Y),783) +#define get_gdat_ipv6_pos783(X,Y) get_gdat_ipv6((X),(Y),783) +#define get_gdat_string_pos783(X,Y) get_gdat_string((X),(Y),783) +#define get_gdat_v_str_pos783(X,Y) get_gdat_string((X),(Y),783) +#define get_gdat_bool_pos783(X,Y) get_gdat_bool((X),(Y),783) +#define get_gdat_int_pos783(X,Y) get_gdat_int((X),(Y),783) +#define get_gdat_llong_pos783(X,Y) get_gdat_llong((X),(Y),783) +#define get_gdat_float_pos783(X,Y) get_gdat_float((X),(Y),783) +#define get_gdat_uint_pos784(X,Y) get_gdat_uint((X),(Y),784) +#define get_gdat_ullong_pos784(X,Y) get_gdat_ullong((X),(Y),784) +#define get_gdat_ip_pos784(X,Y) get_gdat_ip((X),(Y),784) +#define get_gdat_ipv6_pos784(X,Y) get_gdat_ipv6((X),(Y),784) +#define get_gdat_string_pos784(X,Y) get_gdat_string((X),(Y),784) +#define get_gdat_v_str_pos784(X,Y) get_gdat_string((X),(Y),784) +#define get_gdat_bool_pos784(X,Y) get_gdat_bool((X),(Y),784) +#define get_gdat_int_pos784(X,Y) get_gdat_int((X),(Y),784) +#define get_gdat_llong_pos784(X,Y) get_gdat_llong((X),(Y),784) +#define get_gdat_float_pos784(X,Y) get_gdat_float((X),(Y),784) +#define get_gdat_uint_pos785(X,Y) get_gdat_uint((X),(Y),785) +#define get_gdat_ullong_pos785(X,Y) get_gdat_ullong((X),(Y),785) +#define get_gdat_ip_pos785(X,Y) get_gdat_ip((X),(Y),785) +#define get_gdat_ipv6_pos785(X,Y) get_gdat_ipv6((X),(Y),785) +#define get_gdat_string_pos785(X,Y) get_gdat_string((X),(Y),785) +#define get_gdat_v_str_pos785(X,Y) get_gdat_string((X),(Y),785) +#define get_gdat_bool_pos785(X,Y) get_gdat_bool((X),(Y),785) +#define get_gdat_int_pos785(X,Y) get_gdat_int((X),(Y),785) +#define get_gdat_llong_pos785(X,Y) get_gdat_llong((X),(Y),785) +#define get_gdat_float_pos785(X,Y) get_gdat_float((X),(Y),785) +#define get_gdat_uint_pos786(X,Y) get_gdat_uint((X),(Y),786) +#define get_gdat_ullong_pos786(X,Y) get_gdat_ullong((X),(Y),786) +#define get_gdat_ip_pos786(X,Y) get_gdat_ip((X),(Y),786) +#define get_gdat_ipv6_pos786(X,Y) get_gdat_ipv6((X),(Y),786) +#define get_gdat_string_pos786(X,Y) get_gdat_string((X),(Y),786) +#define get_gdat_v_str_pos786(X,Y) get_gdat_string((X),(Y),786) +#define get_gdat_bool_pos786(X,Y) get_gdat_bool((X),(Y),786) +#define get_gdat_int_pos786(X,Y) get_gdat_int((X),(Y),786) +#define get_gdat_llong_pos786(X,Y) get_gdat_llong((X),(Y),786) +#define get_gdat_float_pos786(X,Y) get_gdat_float((X),(Y),786) +#define get_gdat_uint_pos787(X,Y) get_gdat_uint((X),(Y),787) +#define get_gdat_ullong_pos787(X,Y) get_gdat_ullong((X),(Y),787) +#define get_gdat_ip_pos787(X,Y) get_gdat_ip((X),(Y),787) +#define get_gdat_ipv6_pos787(X,Y) get_gdat_ipv6((X),(Y),787) +#define get_gdat_string_pos787(X,Y) get_gdat_string((X),(Y),787) +#define get_gdat_v_str_pos787(X,Y) get_gdat_string((X),(Y),787) +#define get_gdat_bool_pos787(X,Y) get_gdat_bool((X),(Y),787) +#define get_gdat_int_pos787(X,Y) get_gdat_int((X),(Y),787) +#define get_gdat_llong_pos787(X,Y) get_gdat_llong((X),(Y),787) +#define get_gdat_float_pos787(X,Y) get_gdat_float((X),(Y),787) +#define get_gdat_uint_pos788(X,Y) get_gdat_uint((X),(Y),788) +#define get_gdat_ullong_pos788(X,Y) get_gdat_ullong((X),(Y),788) +#define get_gdat_ip_pos788(X,Y) get_gdat_ip((X),(Y),788) +#define get_gdat_ipv6_pos788(X,Y) get_gdat_ipv6((X),(Y),788) +#define get_gdat_string_pos788(X,Y) get_gdat_string((X),(Y),788) +#define get_gdat_v_str_pos788(X,Y) get_gdat_string((X),(Y),788) +#define get_gdat_bool_pos788(X,Y) get_gdat_bool((X),(Y),788) +#define get_gdat_int_pos788(X,Y) get_gdat_int((X),(Y),788) +#define get_gdat_llong_pos788(X,Y) get_gdat_llong((X),(Y),788) +#define get_gdat_float_pos788(X,Y) get_gdat_float((X),(Y),788) +#define get_gdat_uint_pos789(X,Y) get_gdat_uint((X),(Y),789) +#define get_gdat_ullong_pos789(X,Y) get_gdat_ullong((X),(Y),789) +#define get_gdat_ip_pos789(X,Y) get_gdat_ip((X),(Y),789) +#define get_gdat_ipv6_pos789(X,Y) get_gdat_ipv6((X),(Y),789) +#define get_gdat_string_pos789(X,Y) get_gdat_string((X),(Y),789) +#define get_gdat_v_str_pos789(X,Y) get_gdat_string((X),(Y),789) +#define get_gdat_bool_pos789(X,Y) get_gdat_bool((X),(Y),789) +#define get_gdat_int_pos789(X,Y) get_gdat_int((X),(Y),789) +#define get_gdat_llong_pos789(X,Y) get_gdat_llong((X),(Y),789) +#define get_gdat_float_pos789(X,Y) get_gdat_float((X),(Y),789) +#define get_gdat_uint_pos790(X,Y) get_gdat_uint((X),(Y),790) +#define get_gdat_ullong_pos790(X,Y) get_gdat_ullong((X),(Y),790) +#define get_gdat_ip_pos790(X,Y) get_gdat_ip((X),(Y),790) +#define get_gdat_ipv6_pos790(X,Y) get_gdat_ipv6((X),(Y),790) +#define get_gdat_string_pos790(X,Y) get_gdat_string((X),(Y),790) +#define get_gdat_v_str_pos790(X,Y) get_gdat_string((X),(Y),790) +#define get_gdat_bool_pos790(X,Y) get_gdat_bool((X),(Y),790) +#define get_gdat_int_pos790(X,Y) get_gdat_int((X),(Y),790) +#define get_gdat_llong_pos790(X,Y) get_gdat_llong((X),(Y),790) +#define get_gdat_float_pos790(X,Y) get_gdat_float((X),(Y),790) +#define get_gdat_uint_pos791(X,Y) get_gdat_uint((X),(Y),791) +#define get_gdat_ullong_pos791(X,Y) get_gdat_ullong((X),(Y),791) +#define get_gdat_ip_pos791(X,Y) get_gdat_ip((X),(Y),791) +#define get_gdat_ipv6_pos791(X,Y) get_gdat_ipv6((X),(Y),791) +#define get_gdat_string_pos791(X,Y) get_gdat_string((X),(Y),791) +#define get_gdat_v_str_pos791(X,Y) get_gdat_string((X),(Y),791) +#define get_gdat_bool_pos791(X,Y) get_gdat_bool((X),(Y),791) +#define get_gdat_int_pos791(X,Y) get_gdat_int((X),(Y),791) +#define get_gdat_llong_pos791(X,Y) get_gdat_llong((X),(Y),791) +#define get_gdat_float_pos791(X,Y) get_gdat_float((X),(Y),791) +#define get_gdat_uint_pos792(X,Y) get_gdat_uint((X),(Y),792) +#define get_gdat_ullong_pos792(X,Y) get_gdat_ullong((X),(Y),792) +#define get_gdat_ip_pos792(X,Y) get_gdat_ip((X),(Y),792) +#define get_gdat_ipv6_pos792(X,Y) get_gdat_ipv6((X),(Y),792) +#define get_gdat_string_pos792(X,Y) get_gdat_string((X),(Y),792) +#define get_gdat_v_str_pos792(X,Y) get_gdat_string((X),(Y),792) +#define get_gdat_bool_pos792(X,Y) get_gdat_bool((X),(Y),792) +#define get_gdat_int_pos792(X,Y) get_gdat_int((X),(Y),792) +#define get_gdat_llong_pos792(X,Y) get_gdat_llong((X),(Y),792) +#define get_gdat_float_pos792(X,Y) get_gdat_float((X),(Y),792) +#define get_gdat_uint_pos793(X,Y) get_gdat_uint((X),(Y),793) +#define get_gdat_ullong_pos793(X,Y) get_gdat_ullong((X),(Y),793) +#define get_gdat_ip_pos793(X,Y) get_gdat_ip((X),(Y),793) +#define get_gdat_ipv6_pos793(X,Y) get_gdat_ipv6((X),(Y),793) +#define get_gdat_string_pos793(X,Y) get_gdat_string((X),(Y),793) +#define get_gdat_v_str_pos793(X,Y) get_gdat_string((X),(Y),793) +#define get_gdat_bool_pos793(X,Y) get_gdat_bool((X),(Y),793) +#define get_gdat_int_pos793(X,Y) get_gdat_int((X),(Y),793) +#define get_gdat_llong_pos793(X,Y) get_gdat_llong((X),(Y),793) +#define get_gdat_float_pos793(X,Y) get_gdat_float((X),(Y),793) +#define get_gdat_uint_pos794(X,Y) get_gdat_uint((X),(Y),794) +#define get_gdat_ullong_pos794(X,Y) get_gdat_ullong((X),(Y),794) +#define get_gdat_ip_pos794(X,Y) get_gdat_ip((X),(Y),794) +#define get_gdat_ipv6_pos794(X,Y) get_gdat_ipv6((X),(Y),794) +#define get_gdat_string_pos794(X,Y) get_gdat_string((X),(Y),794) +#define get_gdat_v_str_pos794(X,Y) get_gdat_string((X),(Y),794) +#define get_gdat_bool_pos794(X,Y) get_gdat_bool((X),(Y),794) +#define get_gdat_int_pos794(X,Y) get_gdat_int((X),(Y),794) +#define get_gdat_llong_pos794(X,Y) get_gdat_llong((X),(Y),794) +#define get_gdat_float_pos794(X,Y) get_gdat_float((X),(Y),794) +#define get_gdat_uint_pos795(X,Y) get_gdat_uint((X),(Y),795) +#define get_gdat_ullong_pos795(X,Y) get_gdat_ullong((X),(Y),795) +#define get_gdat_ip_pos795(X,Y) get_gdat_ip((X),(Y),795) +#define get_gdat_ipv6_pos795(X,Y) get_gdat_ipv6((X),(Y),795) +#define get_gdat_string_pos795(X,Y) get_gdat_string((X),(Y),795) +#define get_gdat_v_str_pos795(X,Y) get_gdat_string((X),(Y),795) +#define get_gdat_bool_pos795(X,Y) get_gdat_bool((X),(Y),795) +#define get_gdat_int_pos795(X,Y) get_gdat_int((X),(Y),795) +#define get_gdat_llong_pos795(X,Y) get_gdat_llong((X),(Y),795) +#define get_gdat_float_pos795(X,Y) get_gdat_float((X),(Y),795) +#define get_gdat_uint_pos796(X,Y) get_gdat_uint((X),(Y),796) +#define get_gdat_ullong_pos796(X,Y) get_gdat_ullong((X),(Y),796) +#define get_gdat_ip_pos796(X,Y) get_gdat_ip((X),(Y),796) +#define get_gdat_ipv6_pos796(X,Y) get_gdat_ipv6((X),(Y),796) +#define get_gdat_string_pos796(X,Y) get_gdat_string((X),(Y),796) +#define get_gdat_v_str_pos796(X,Y) get_gdat_string((X),(Y),796) +#define get_gdat_bool_pos796(X,Y) get_gdat_bool((X),(Y),796) +#define get_gdat_int_pos796(X,Y) get_gdat_int((X),(Y),796) +#define get_gdat_llong_pos796(X,Y) get_gdat_llong((X),(Y),796) +#define get_gdat_float_pos796(X,Y) get_gdat_float((X),(Y),796) +#define get_gdat_uint_pos797(X,Y) get_gdat_uint((X),(Y),797) +#define get_gdat_ullong_pos797(X,Y) get_gdat_ullong((X),(Y),797) +#define get_gdat_ip_pos797(X,Y) get_gdat_ip((X),(Y),797) +#define get_gdat_ipv6_pos797(X,Y) get_gdat_ipv6((X),(Y),797) +#define get_gdat_string_pos797(X,Y) get_gdat_string((X),(Y),797) +#define get_gdat_v_str_pos797(X,Y) get_gdat_string((X),(Y),797) +#define get_gdat_bool_pos797(X,Y) get_gdat_bool((X),(Y),797) +#define get_gdat_int_pos797(X,Y) get_gdat_int((X),(Y),797) +#define get_gdat_llong_pos797(X,Y) get_gdat_llong((X),(Y),797) +#define get_gdat_float_pos797(X,Y) get_gdat_float((X),(Y),797) +#define get_gdat_uint_pos798(X,Y) get_gdat_uint((X),(Y),798) +#define get_gdat_ullong_pos798(X,Y) get_gdat_ullong((X),(Y),798) +#define get_gdat_ip_pos798(X,Y) get_gdat_ip((X),(Y),798) +#define get_gdat_ipv6_pos798(X,Y) get_gdat_ipv6((X),(Y),798) +#define get_gdat_string_pos798(X,Y) get_gdat_string((X),(Y),798) +#define get_gdat_v_str_pos798(X,Y) get_gdat_string((X),(Y),798) +#define get_gdat_bool_pos798(X,Y) get_gdat_bool((X),(Y),798) +#define get_gdat_int_pos798(X,Y) get_gdat_int((X),(Y),798) +#define get_gdat_llong_pos798(X,Y) get_gdat_llong((X),(Y),798) +#define get_gdat_float_pos798(X,Y) get_gdat_float((X),(Y),798) +#define get_gdat_uint_pos799(X,Y) get_gdat_uint((X),(Y),799) +#define get_gdat_ullong_pos799(X,Y) get_gdat_ullong((X),(Y),799) +#define get_gdat_ip_pos799(X,Y) get_gdat_ip((X),(Y),799) +#define get_gdat_ipv6_pos799(X,Y) get_gdat_ipv6((X),(Y),799) +#define get_gdat_string_pos799(X,Y) get_gdat_string((X),(Y),799) +#define get_gdat_v_str_pos799(X,Y) get_gdat_string((X),(Y),799) +#define get_gdat_bool_pos799(X,Y) get_gdat_bool((X),(Y),799) +#define get_gdat_int_pos799(X,Y) get_gdat_int((X),(Y),799) +#define get_gdat_llong_pos799(X,Y) get_gdat_llong((X),(Y),799) +#define get_gdat_float_pos799(X,Y) get_gdat_float((X),(Y),799) +#define get_gdat_uint_pos800(X,Y) get_gdat_uint((X),(Y),800) +#define get_gdat_ullong_pos800(X,Y) get_gdat_ullong((X),(Y),800) +#define get_gdat_ip_pos800(X,Y) get_gdat_ip((X),(Y),800) +#define get_gdat_ipv6_pos800(X,Y) get_gdat_ipv6((X),(Y),800) +#define get_gdat_string_pos800(X,Y) get_gdat_string((X),(Y),800) +#define get_gdat_v_str_pos800(X,Y) get_gdat_string((X),(Y),800) +#define get_gdat_bool_pos800(X,Y) get_gdat_bool((X),(Y),800) +#define get_gdat_int_pos800(X,Y) get_gdat_int((X),(Y),800) +#define get_gdat_llong_pos800(X,Y) get_gdat_llong((X),(Y),800) +#define get_gdat_float_pos800(X,Y) get_gdat_float((X),(Y),800) +#define get_gdat_uint_pos801(X,Y) get_gdat_uint((X),(Y),801) +#define get_gdat_ullong_pos801(X,Y) get_gdat_ullong((X),(Y),801) +#define get_gdat_ip_pos801(X,Y) get_gdat_ip((X),(Y),801) +#define get_gdat_ipv6_pos801(X,Y) get_gdat_ipv6((X),(Y),801) +#define get_gdat_string_pos801(X,Y) get_gdat_string((X),(Y),801) +#define get_gdat_v_str_pos801(X,Y) get_gdat_string((X),(Y),801) +#define get_gdat_bool_pos801(X,Y) get_gdat_bool((X),(Y),801) +#define get_gdat_int_pos801(X,Y) get_gdat_int((X),(Y),801) +#define get_gdat_llong_pos801(X,Y) get_gdat_llong((X),(Y),801) +#define get_gdat_float_pos801(X,Y) get_gdat_float((X),(Y),801) +#define get_gdat_uint_pos802(X,Y) get_gdat_uint((X),(Y),802) +#define get_gdat_ullong_pos802(X,Y) get_gdat_ullong((X),(Y),802) +#define get_gdat_ip_pos802(X,Y) get_gdat_ip((X),(Y),802) +#define get_gdat_ipv6_pos802(X,Y) get_gdat_ipv6((X),(Y),802) +#define get_gdat_string_pos802(X,Y) get_gdat_string((X),(Y),802) +#define get_gdat_v_str_pos802(X,Y) get_gdat_string((X),(Y),802) +#define get_gdat_bool_pos802(X,Y) get_gdat_bool((X),(Y),802) +#define get_gdat_int_pos802(X,Y) get_gdat_int((X),(Y),802) +#define get_gdat_llong_pos802(X,Y) get_gdat_llong((X),(Y),802) +#define get_gdat_float_pos802(X,Y) get_gdat_float((X),(Y),802) +#define get_gdat_uint_pos803(X,Y) get_gdat_uint((X),(Y),803) +#define get_gdat_ullong_pos803(X,Y) get_gdat_ullong((X),(Y),803) +#define get_gdat_ip_pos803(X,Y) get_gdat_ip((X),(Y),803) +#define get_gdat_ipv6_pos803(X,Y) get_gdat_ipv6((X),(Y),803) +#define get_gdat_string_pos803(X,Y) get_gdat_string((X),(Y),803) +#define get_gdat_v_str_pos803(X,Y) get_gdat_string((X),(Y),803) +#define get_gdat_bool_pos803(X,Y) get_gdat_bool((X),(Y),803) +#define get_gdat_int_pos803(X,Y) get_gdat_int((X),(Y),803) +#define get_gdat_llong_pos803(X,Y) get_gdat_llong((X),(Y),803) +#define get_gdat_float_pos803(X,Y) get_gdat_float((X),(Y),803) +#define get_gdat_uint_pos804(X,Y) get_gdat_uint((X),(Y),804) +#define get_gdat_ullong_pos804(X,Y) get_gdat_ullong((X),(Y),804) +#define get_gdat_ip_pos804(X,Y) get_gdat_ip((X),(Y),804) +#define get_gdat_ipv6_pos804(X,Y) get_gdat_ipv6((X),(Y),804) +#define get_gdat_string_pos804(X,Y) get_gdat_string((X),(Y),804) +#define get_gdat_v_str_pos804(X,Y) get_gdat_string((X),(Y),804) +#define get_gdat_bool_pos804(X,Y) get_gdat_bool((X),(Y),804) +#define get_gdat_int_pos804(X,Y) get_gdat_int((X),(Y),804) +#define get_gdat_llong_pos804(X,Y) get_gdat_llong((X),(Y),804) +#define get_gdat_float_pos804(X,Y) get_gdat_float((X),(Y),804) +#define get_gdat_uint_pos805(X,Y) get_gdat_uint((X),(Y),805) +#define get_gdat_ullong_pos805(X,Y) get_gdat_ullong((X),(Y),805) +#define get_gdat_ip_pos805(X,Y) get_gdat_ip((X),(Y),805) +#define get_gdat_ipv6_pos805(X,Y) get_gdat_ipv6((X),(Y),805) +#define get_gdat_string_pos805(X,Y) get_gdat_string((X),(Y),805) +#define get_gdat_v_str_pos805(X,Y) get_gdat_string((X),(Y),805) +#define get_gdat_bool_pos805(X,Y) get_gdat_bool((X),(Y),805) +#define get_gdat_int_pos805(X,Y) get_gdat_int((X),(Y),805) +#define get_gdat_llong_pos805(X,Y) get_gdat_llong((X),(Y),805) +#define get_gdat_float_pos805(X,Y) get_gdat_float((X),(Y),805) +#define get_gdat_uint_pos806(X,Y) get_gdat_uint((X),(Y),806) +#define get_gdat_ullong_pos806(X,Y) get_gdat_ullong((X),(Y),806) +#define get_gdat_ip_pos806(X,Y) get_gdat_ip((X),(Y),806) +#define get_gdat_ipv6_pos806(X,Y) get_gdat_ipv6((X),(Y),806) +#define get_gdat_string_pos806(X,Y) get_gdat_string((X),(Y),806) +#define get_gdat_v_str_pos806(X,Y) get_gdat_string((X),(Y),806) +#define get_gdat_bool_pos806(X,Y) get_gdat_bool((X),(Y),806) +#define get_gdat_int_pos806(X,Y) get_gdat_int((X),(Y),806) +#define get_gdat_llong_pos806(X,Y) get_gdat_llong((X),(Y),806) +#define get_gdat_float_pos806(X,Y) get_gdat_float((X),(Y),806) +#define get_gdat_uint_pos807(X,Y) get_gdat_uint((X),(Y),807) +#define get_gdat_ullong_pos807(X,Y) get_gdat_ullong((X),(Y),807) +#define get_gdat_ip_pos807(X,Y) get_gdat_ip((X),(Y),807) +#define get_gdat_ipv6_pos807(X,Y) get_gdat_ipv6((X),(Y),807) +#define get_gdat_string_pos807(X,Y) get_gdat_string((X),(Y),807) +#define get_gdat_v_str_pos807(X,Y) get_gdat_string((X),(Y),807) +#define get_gdat_bool_pos807(X,Y) get_gdat_bool((X),(Y),807) +#define get_gdat_int_pos807(X,Y) get_gdat_int((X),(Y),807) +#define get_gdat_llong_pos807(X,Y) get_gdat_llong((X),(Y),807) +#define get_gdat_float_pos807(X,Y) get_gdat_float((X),(Y),807) +#define get_gdat_uint_pos808(X,Y) get_gdat_uint((X),(Y),808) +#define get_gdat_ullong_pos808(X,Y) get_gdat_ullong((X),(Y),808) +#define get_gdat_ip_pos808(X,Y) get_gdat_ip((X),(Y),808) +#define get_gdat_ipv6_pos808(X,Y) get_gdat_ipv6((X),(Y),808) +#define get_gdat_string_pos808(X,Y) get_gdat_string((X),(Y),808) +#define get_gdat_v_str_pos808(X,Y) get_gdat_string((X),(Y),808) +#define get_gdat_bool_pos808(X,Y) get_gdat_bool((X),(Y),808) +#define get_gdat_int_pos808(X,Y) get_gdat_int((X),(Y),808) +#define get_gdat_llong_pos808(X,Y) get_gdat_llong((X),(Y),808) +#define get_gdat_float_pos808(X,Y) get_gdat_float((X),(Y),808) +#define get_gdat_uint_pos809(X,Y) get_gdat_uint((X),(Y),809) +#define get_gdat_ullong_pos809(X,Y) get_gdat_ullong((X),(Y),809) +#define get_gdat_ip_pos809(X,Y) get_gdat_ip((X),(Y),809) +#define get_gdat_ipv6_pos809(X,Y) get_gdat_ipv6((X),(Y),809) +#define get_gdat_string_pos809(X,Y) get_gdat_string((X),(Y),809) +#define get_gdat_v_str_pos809(X,Y) get_gdat_string((X),(Y),809) +#define get_gdat_bool_pos809(X,Y) get_gdat_bool((X),(Y),809) +#define get_gdat_int_pos809(X,Y) get_gdat_int((X),(Y),809) +#define get_gdat_llong_pos809(X,Y) get_gdat_llong((X),(Y),809) +#define get_gdat_float_pos809(X,Y) get_gdat_float((X),(Y),809) +#define get_gdat_uint_pos810(X,Y) get_gdat_uint((X),(Y),810) +#define get_gdat_ullong_pos810(X,Y) get_gdat_ullong((X),(Y),810) +#define get_gdat_ip_pos810(X,Y) get_gdat_ip((X),(Y),810) +#define get_gdat_ipv6_pos810(X,Y) get_gdat_ipv6((X),(Y),810) +#define get_gdat_string_pos810(X,Y) get_gdat_string((X),(Y),810) +#define get_gdat_v_str_pos810(X,Y) get_gdat_string((X),(Y),810) +#define get_gdat_bool_pos810(X,Y) get_gdat_bool((X),(Y),810) +#define get_gdat_int_pos810(X,Y) get_gdat_int((X),(Y),810) +#define get_gdat_llong_pos810(X,Y) get_gdat_llong((X),(Y),810) +#define get_gdat_float_pos810(X,Y) get_gdat_float((X),(Y),810) +#define get_gdat_uint_pos811(X,Y) get_gdat_uint((X),(Y),811) +#define get_gdat_ullong_pos811(X,Y) get_gdat_ullong((X),(Y),811) +#define get_gdat_ip_pos811(X,Y) get_gdat_ip((X),(Y),811) +#define get_gdat_ipv6_pos811(X,Y) get_gdat_ipv6((X),(Y),811) +#define get_gdat_string_pos811(X,Y) get_gdat_string((X),(Y),811) +#define get_gdat_v_str_pos811(X,Y) get_gdat_string((X),(Y),811) +#define get_gdat_bool_pos811(X,Y) get_gdat_bool((X),(Y),811) +#define get_gdat_int_pos811(X,Y) get_gdat_int((X),(Y),811) +#define get_gdat_llong_pos811(X,Y) get_gdat_llong((X),(Y),811) +#define get_gdat_float_pos811(X,Y) get_gdat_float((X),(Y),811) +#define get_gdat_uint_pos812(X,Y) get_gdat_uint((X),(Y),812) +#define get_gdat_ullong_pos812(X,Y) get_gdat_ullong((X),(Y),812) +#define get_gdat_ip_pos812(X,Y) get_gdat_ip((X),(Y),812) +#define get_gdat_ipv6_pos812(X,Y) get_gdat_ipv6((X),(Y),812) +#define get_gdat_string_pos812(X,Y) get_gdat_string((X),(Y),812) +#define get_gdat_v_str_pos812(X,Y) get_gdat_string((X),(Y),812) +#define get_gdat_bool_pos812(X,Y) get_gdat_bool((X),(Y),812) +#define get_gdat_int_pos812(X,Y) get_gdat_int((X),(Y),812) +#define get_gdat_llong_pos812(X,Y) get_gdat_llong((X),(Y),812) +#define get_gdat_float_pos812(X,Y) get_gdat_float((X),(Y),812) +#define get_gdat_uint_pos813(X,Y) get_gdat_uint((X),(Y),813) +#define get_gdat_ullong_pos813(X,Y) get_gdat_ullong((X),(Y),813) +#define get_gdat_ip_pos813(X,Y) get_gdat_ip((X),(Y),813) +#define get_gdat_ipv6_pos813(X,Y) get_gdat_ipv6((X),(Y),813) +#define get_gdat_string_pos813(X,Y) get_gdat_string((X),(Y),813) +#define get_gdat_v_str_pos813(X,Y) get_gdat_string((X),(Y),813) +#define get_gdat_bool_pos813(X,Y) get_gdat_bool((X),(Y),813) +#define get_gdat_int_pos813(X,Y) get_gdat_int((X),(Y),813) +#define get_gdat_llong_pos813(X,Y) get_gdat_llong((X),(Y),813) +#define get_gdat_float_pos813(X,Y) get_gdat_float((X),(Y),813) +#define get_gdat_uint_pos814(X,Y) get_gdat_uint((X),(Y),814) +#define get_gdat_ullong_pos814(X,Y) get_gdat_ullong((X),(Y),814) +#define get_gdat_ip_pos814(X,Y) get_gdat_ip((X),(Y),814) +#define get_gdat_ipv6_pos814(X,Y) get_gdat_ipv6((X),(Y),814) +#define get_gdat_string_pos814(X,Y) get_gdat_string((X),(Y),814) +#define get_gdat_v_str_pos814(X,Y) get_gdat_string((X),(Y),814) +#define get_gdat_bool_pos814(X,Y) get_gdat_bool((X),(Y),814) +#define get_gdat_int_pos814(X,Y) get_gdat_int((X),(Y),814) +#define get_gdat_llong_pos814(X,Y) get_gdat_llong((X),(Y),814) +#define get_gdat_float_pos814(X,Y) get_gdat_float((X),(Y),814) +#define get_gdat_uint_pos815(X,Y) get_gdat_uint((X),(Y),815) +#define get_gdat_ullong_pos815(X,Y) get_gdat_ullong((X),(Y),815) +#define get_gdat_ip_pos815(X,Y) get_gdat_ip((X),(Y),815) +#define get_gdat_ipv6_pos815(X,Y) get_gdat_ipv6((X),(Y),815) +#define get_gdat_string_pos815(X,Y) get_gdat_string((X),(Y),815) +#define get_gdat_v_str_pos815(X,Y) get_gdat_string((X),(Y),815) +#define get_gdat_bool_pos815(X,Y) get_gdat_bool((X),(Y),815) +#define get_gdat_int_pos815(X,Y) get_gdat_int((X),(Y),815) +#define get_gdat_llong_pos815(X,Y) get_gdat_llong((X),(Y),815) +#define get_gdat_float_pos815(X,Y) get_gdat_float((X),(Y),815) +#define get_gdat_uint_pos816(X,Y) get_gdat_uint((X),(Y),816) +#define get_gdat_ullong_pos816(X,Y) get_gdat_ullong((X),(Y),816) +#define get_gdat_ip_pos816(X,Y) get_gdat_ip((X),(Y),816) +#define get_gdat_ipv6_pos816(X,Y) get_gdat_ipv6((X),(Y),816) +#define get_gdat_string_pos816(X,Y) get_gdat_string((X),(Y),816) +#define get_gdat_v_str_pos816(X,Y) get_gdat_string((X),(Y),816) +#define get_gdat_bool_pos816(X,Y) get_gdat_bool((X),(Y),816) +#define get_gdat_int_pos816(X,Y) get_gdat_int((X),(Y),816) +#define get_gdat_llong_pos816(X,Y) get_gdat_llong((X),(Y),816) +#define get_gdat_float_pos816(X,Y) get_gdat_float((X),(Y),816) +#define get_gdat_uint_pos817(X,Y) get_gdat_uint((X),(Y),817) +#define get_gdat_ullong_pos817(X,Y) get_gdat_ullong((X),(Y),817) +#define get_gdat_ip_pos817(X,Y) get_gdat_ip((X),(Y),817) +#define get_gdat_ipv6_pos817(X,Y) get_gdat_ipv6((X),(Y),817) +#define get_gdat_string_pos817(X,Y) get_gdat_string((X),(Y),817) +#define get_gdat_v_str_pos817(X,Y) get_gdat_string((X),(Y),817) +#define get_gdat_bool_pos817(X,Y) get_gdat_bool((X),(Y),817) +#define get_gdat_int_pos817(X,Y) get_gdat_int((X),(Y),817) +#define get_gdat_llong_pos817(X,Y) get_gdat_llong((X),(Y),817) +#define get_gdat_float_pos817(X,Y) get_gdat_float((X),(Y),817) +#define get_gdat_uint_pos818(X,Y) get_gdat_uint((X),(Y),818) +#define get_gdat_ullong_pos818(X,Y) get_gdat_ullong((X),(Y),818) +#define get_gdat_ip_pos818(X,Y) get_gdat_ip((X),(Y),818) +#define get_gdat_ipv6_pos818(X,Y) get_gdat_ipv6((X),(Y),818) +#define get_gdat_string_pos818(X,Y) get_gdat_string((X),(Y),818) +#define get_gdat_v_str_pos818(X,Y) get_gdat_string((X),(Y),818) +#define get_gdat_bool_pos818(X,Y) get_gdat_bool((X),(Y),818) +#define get_gdat_int_pos818(X,Y) get_gdat_int((X),(Y),818) +#define get_gdat_llong_pos818(X,Y) get_gdat_llong((X),(Y),818) +#define get_gdat_float_pos818(X,Y) get_gdat_float((X),(Y),818) +#define get_gdat_uint_pos819(X,Y) get_gdat_uint((X),(Y),819) +#define get_gdat_ullong_pos819(X,Y) get_gdat_ullong((X),(Y),819) +#define get_gdat_ip_pos819(X,Y) get_gdat_ip((X),(Y),819) +#define get_gdat_ipv6_pos819(X,Y) get_gdat_ipv6((X),(Y),819) +#define get_gdat_string_pos819(X,Y) get_gdat_string((X),(Y),819) +#define get_gdat_v_str_pos819(X,Y) get_gdat_string((X),(Y),819) +#define get_gdat_bool_pos819(X,Y) get_gdat_bool((X),(Y),819) +#define get_gdat_int_pos819(X,Y) get_gdat_int((X),(Y),819) +#define get_gdat_llong_pos819(X,Y) get_gdat_llong((X),(Y),819) +#define get_gdat_float_pos819(X,Y) get_gdat_float((X),(Y),819) +#define get_gdat_uint_pos820(X,Y) get_gdat_uint((X),(Y),820) +#define get_gdat_ullong_pos820(X,Y) get_gdat_ullong((X),(Y),820) +#define get_gdat_ip_pos820(X,Y) get_gdat_ip((X),(Y),820) +#define get_gdat_ipv6_pos820(X,Y) get_gdat_ipv6((X),(Y),820) +#define get_gdat_string_pos820(X,Y) get_gdat_string((X),(Y),820) +#define get_gdat_v_str_pos820(X,Y) get_gdat_string((X),(Y),820) +#define get_gdat_bool_pos820(X,Y) get_gdat_bool((X),(Y),820) +#define get_gdat_int_pos820(X,Y) get_gdat_int((X),(Y),820) +#define get_gdat_llong_pos820(X,Y) get_gdat_llong((X),(Y),820) +#define get_gdat_float_pos820(X,Y) get_gdat_float((X),(Y),820) +#define get_gdat_uint_pos821(X,Y) get_gdat_uint((X),(Y),821) +#define get_gdat_ullong_pos821(X,Y) get_gdat_ullong((X),(Y),821) +#define get_gdat_ip_pos821(X,Y) get_gdat_ip((X),(Y),821) +#define get_gdat_ipv6_pos821(X,Y) get_gdat_ipv6((X),(Y),821) +#define get_gdat_string_pos821(X,Y) get_gdat_string((X),(Y),821) +#define get_gdat_v_str_pos821(X,Y) get_gdat_string((X),(Y),821) +#define get_gdat_bool_pos821(X,Y) get_gdat_bool((X),(Y),821) +#define get_gdat_int_pos821(X,Y) get_gdat_int((X),(Y),821) +#define get_gdat_llong_pos821(X,Y) get_gdat_llong((X),(Y),821) +#define get_gdat_float_pos821(X,Y) get_gdat_float((X),(Y),821) +#define get_gdat_uint_pos822(X,Y) get_gdat_uint((X),(Y),822) +#define get_gdat_ullong_pos822(X,Y) get_gdat_ullong((X),(Y),822) +#define get_gdat_ip_pos822(X,Y) get_gdat_ip((X),(Y),822) +#define get_gdat_ipv6_pos822(X,Y) get_gdat_ipv6((X),(Y),822) +#define get_gdat_string_pos822(X,Y) get_gdat_string((X),(Y),822) +#define get_gdat_v_str_pos822(X,Y) get_gdat_string((X),(Y),822) +#define get_gdat_bool_pos822(X,Y) get_gdat_bool((X),(Y),822) +#define get_gdat_int_pos822(X,Y) get_gdat_int((X),(Y),822) +#define get_gdat_llong_pos822(X,Y) get_gdat_llong((X),(Y),822) +#define get_gdat_float_pos822(X,Y) get_gdat_float((X),(Y),822) +#define get_gdat_uint_pos823(X,Y) get_gdat_uint((X),(Y),823) +#define get_gdat_ullong_pos823(X,Y) get_gdat_ullong((X),(Y),823) +#define get_gdat_ip_pos823(X,Y) get_gdat_ip((X),(Y),823) +#define get_gdat_ipv6_pos823(X,Y) get_gdat_ipv6((X),(Y),823) +#define get_gdat_string_pos823(X,Y) get_gdat_string((X),(Y),823) +#define get_gdat_v_str_pos823(X,Y) get_gdat_string((X),(Y),823) +#define get_gdat_bool_pos823(X,Y) get_gdat_bool((X),(Y),823) +#define get_gdat_int_pos823(X,Y) get_gdat_int((X),(Y),823) +#define get_gdat_llong_pos823(X,Y) get_gdat_llong((X),(Y),823) +#define get_gdat_float_pos823(X,Y) get_gdat_float((X),(Y),823) +#define get_gdat_uint_pos824(X,Y) get_gdat_uint((X),(Y),824) +#define get_gdat_ullong_pos824(X,Y) get_gdat_ullong((X),(Y),824) +#define get_gdat_ip_pos824(X,Y) get_gdat_ip((X),(Y),824) +#define get_gdat_ipv6_pos824(X,Y) get_gdat_ipv6((X),(Y),824) +#define get_gdat_string_pos824(X,Y) get_gdat_string((X),(Y),824) +#define get_gdat_v_str_pos824(X,Y) get_gdat_string((X),(Y),824) +#define get_gdat_bool_pos824(X,Y) get_gdat_bool((X),(Y),824) +#define get_gdat_int_pos824(X,Y) get_gdat_int((X),(Y),824) +#define get_gdat_llong_pos824(X,Y) get_gdat_llong((X),(Y),824) +#define get_gdat_float_pos824(X,Y) get_gdat_float((X),(Y),824) +#define get_gdat_uint_pos825(X,Y) get_gdat_uint((X),(Y),825) +#define get_gdat_ullong_pos825(X,Y) get_gdat_ullong((X),(Y),825) +#define get_gdat_ip_pos825(X,Y) get_gdat_ip((X),(Y),825) +#define get_gdat_ipv6_pos825(X,Y) get_gdat_ipv6((X),(Y),825) +#define get_gdat_string_pos825(X,Y) get_gdat_string((X),(Y),825) +#define get_gdat_v_str_pos825(X,Y) get_gdat_string((X),(Y),825) +#define get_gdat_bool_pos825(X,Y) get_gdat_bool((X),(Y),825) +#define get_gdat_int_pos825(X,Y) get_gdat_int((X),(Y),825) +#define get_gdat_llong_pos825(X,Y) get_gdat_llong((X),(Y),825) +#define get_gdat_float_pos825(X,Y) get_gdat_float((X),(Y),825) +#define get_gdat_uint_pos826(X,Y) get_gdat_uint((X),(Y),826) +#define get_gdat_ullong_pos826(X,Y) get_gdat_ullong((X),(Y),826) +#define get_gdat_ip_pos826(X,Y) get_gdat_ip((X),(Y),826) +#define get_gdat_ipv6_pos826(X,Y) get_gdat_ipv6((X),(Y),826) +#define get_gdat_string_pos826(X,Y) get_gdat_string((X),(Y),826) +#define get_gdat_v_str_pos826(X,Y) get_gdat_string((X),(Y),826) +#define get_gdat_bool_pos826(X,Y) get_gdat_bool((X),(Y),826) +#define get_gdat_int_pos826(X,Y) get_gdat_int((X),(Y),826) +#define get_gdat_llong_pos826(X,Y) get_gdat_llong((X),(Y),826) +#define get_gdat_float_pos826(X,Y) get_gdat_float((X),(Y),826) +#define get_gdat_uint_pos827(X,Y) get_gdat_uint((X),(Y),827) +#define get_gdat_ullong_pos827(X,Y) get_gdat_ullong((X),(Y),827) +#define get_gdat_ip_pos827(X,Y) get_gdat_ip((X),(Y),827) +#define get_gdat_ipv6_pos827(X,Y) get_gdat_ipv6((X),(Y),827) +#define get_gdat_string_pos827(X,Y) get_gdat_string((X),(Y),827) +#define get_gdat_v_str_pos827(X,Y) get_gdat_string((X),(Y),827) +#define get_gdat_bool_pos827(X,Y) get_gdat_bool((X),(Y),827) +#define get_gdat_int_pos827(X,Y) get_gdat_int((X),(Y),827) +#define get_gdat_llong_pos827(X,Y) get_gdat_llong((X),(Y),827) +#define get_gdat_float_pos827(X,Y) get_gdat_float((X),(Y),827) +#define get_gdat_uint_pos828(X,Y) get_gdat_uint((X),(Y),828) +#define get_gdat_ullong_pos828(X,Y) get_gdat_ullong((X),(Y),828) +#define get_gdat_ip_pos828(X,Y) get_gdat_ip((X),(Y),828) +#define get_gdat_ipv6_pos828(X,Y) get_gdat_ipv6((X),(Y),828) +#define get_gdat_string_pos828(X,Y) get_gdat_string((X),(Y),828) +#define get_gdat_v_str_pos828(X,Y) get_gdat_string((X),(Y),828) +#define get_gdat_bool_pos828(X,Y) get_gdat_bool((X),(Y),828) +#define get_gdat_int_pos828(X,Y) get_gdat_int((X),(Y),828) +#define get_gdat_llong_pos828(X,Y) get_gdat_llong((X),(Y),828) +#define get_gdat_float_pos828(X,Y) get_gdat_float((X),(Y),828) +#define get_gdat_uint_pos829(X,Y) get_gdat_uint((X),(Y),829) +#define get_gdat_ullong_pos829(X,Y) get_gdat_ullong((X),(Y),829) +#define get_gdat_ip_pos829(X,Y) get_gdat_ip((X),(Y),829) +#define get_gdat_ipv6_pos829(X,Y) get_gdat_ipv6((X),(Y),829) +#define get_gdat_string_pos829(X,Y) get_gdat_string((X),(Y),829) +#define get_gdat_v_str_pos829(X,Y) get_gdat_string((X),(Y),829) +#define get_gdat_bool_pos829(X,Y) get_gdat_bool((X),(Y),829) +#define get_gdat_int_pos829(X,Y) get_gdat_int((X),(Y),829) +#define get_gdat_llong_pos829(X,Y) get_gdat_llong((X),(Y),829) +#define get_gdat_float_pos829(X,Y) get_gdat_float((X),(Y),829) +#define get_gdat_uint_pos830(X,Y) get_gdat_uint((X),(Y),830) +#define get_gdat_ullong_pos830(X,Y) get_gdat_ullong((X),(Y),830) +#define get_gdat_ip_pos830(X,Y) get_gdat_ip((X),(Y),830) +#define get_gdat_ipv6_pos830(X,Y) get_gdat_ipv6((X),(Y),830) +#define get_gdat_string_pos830(X,Y) get_gdat_string((X),(Y),830) +#define get_gdat_v_str_pos830(X,Y) get_gdat_string((X),(Y),830) +#define get_gdat_bool_pos830(X,Y) get_gdat_bool((X),(Y),830) +#define get_gdat_int_pos830(X,Y) get_gdat_int((X),(Y),830) +#define get_gdat_llong_pos830(X,Y) get_gdat_llong((X),(Y),830) +#define get_gdat_float_pos830(X,Y) get_gdat_float((X),(Y),830) +#define get_gdat_uint_pos831(X,Y) get_gdat_uint((X),(Y),831) +#define get_gdat_ullong_pos831(X,Y) get_gdat_ullong((X),(Y),831) +#define get_gdat_ip_pos831(X,Y) get_gdat_ip((X),(Y),831) +#define get_gdat_ipv6_pos831(X,Y) get_gdat_ipv6((X),(Y),831) +#define get_gdat_string_pos831(X,Y) get_gdat_string((X),(Y),831) +#define get_gdat_v_str_pos831(X,Y) get_gdat_string((X),(Y),831) +#define get_gdat_bool_pos831(X,Y) get_gdat_bool((X),(Y),831) +#define get_gdat_int_pos831(X,Y) get_gdat_int((X),(Y),831) +#define get_gdat_llong_pos831(X,Y) get_gdat_llong((X),(Y),831) +#define get_gdat_float_pos831(X,Y) get_gdat_float((X),(Y),831) +#define get_gdat_uint_pos832(X,Y) get_gdat_uint((X),(Y),832) +#define get_gdat_ullong_pos832(X,Y) get_gdat_ullong((X),(Y),832) +#define get_gdat_ip_pos832(X,Y) get_gdat_ip((X),(Y),832) +#define get_gdat_ipv6_pos832(X,Y) get_gdat_ipv6((X),(Y),832) +#define get_gdat_string_pos832(X,Y) get_gdat_string((X),(Y),832) +#define get_gdat_v_str_pos832(X,Y) get_gdat_string((X),(Y),832) +#define get_gdat_bool_pos832(X,Y) get_gdat_bool((X),(Y),832) +#define get_gdat_int_pos832(X,Y) get_gdat_int((X),(Y),832) +#define get_gdat_llong_pos832(X,Y) get_gdat_llong((X),(Y),832) +#define get_gdat_float_pos832(X,Y) get_gdat_float((X),(Y),832) +#define get_gdat_uint_pos833(X,Y) get_gdat_uint((X),(Y),833) +#define get_gdat_ullong_pos833(X,Y) get_gdat_ullong((X),(Y),833) +#define get_gdat_ip_pos833(X,Y) get_gdat_ip((X),(Y),833) +#define get_gdat_ipv6_pos833(X,Y) get_gdat_ipv6((X),(Y),833) +#define get_gdat_string_pos833(X,Y) get_gdat_string((X),(Y),833) +#define get_gdat_v_str_pos833(X,Y) get_gdat_string((X),(Y),833) +#define get_gdat_bool_pos833(X,Y) get_gdat_bool((X),(Y),833) +#define get_gdat_int_pos833(X,Y) get_gdat_int((X),(Y),833) +#define get_gdat_llong_pos833(X,Y) get_gdat_llong((X),(Y),833) +#define get_gdat_float_pos833(X,Y) get_gdat_float((X),(Y),833) +#define get_gdat_uint_pos834(X,Y) get_gdat_uint((X),(Y),834) +#define get_gdat_ullong_pos834(X,Y) get_gdat_ullong((X),(Y),834) +#define get_gdat_ip_pos834(X,Y) get_gdat_ip((X),(Y),834) +#define get_gdat_ipv6_pos834(X,Y) get_gdat_ipv6((X),(Y),834) +#define get_gdat_string_pos834(X,Y) get_gdat_string((X),(Y),834) +#define get_gdat_v_str_pos834(X,Y) get_gdat_string((X),(Y),834) +#define get_gdat_bool_pos834(X,Y) get_gdat_bool((X),(Y),834) +#define get_gdat_int_pos834(X,Y) get_gdat_int((X),(Y),834) +#define get_gdat_llong_pos834(X,Y) get_gdat_llong((X),(Y),834) +#define get_gdat_float_pos834(X,Y) get_gdat_float((X),(Y),834) +#define get_gdat_uint_pos835(X,Y) get_gdat_uint((X),(Y),835) +#define get_gdat_ullong_pos835(X,Y) get_gdat_ullong((X),(Y),835) +#define get_gdat_ip_pos835(X,Y) get_gdat_ip((X),(Y),835) +#define get_gdat_ipv6_pos835(X,Y) get_gdat_ipv6((X),(Y),835) +#define get_gdat_string_pos835(X,Y) get_gdat_string((X),(Y),835) +#define get_gdat_v_str_pos835(X,Y) get_gdat_string((X),(Y),835) +#define get_gdat_bool_pos835(X,Y) get_gdat_bool((X),(Y),835) +#define get_gdat_int_pos835(X,Y) get_gdat_int((X),(Y),835) +#define get_gdat_llong_pos835(X,Y) get_gdat_llong((X),(Y),835) +#define get_gdat_float_pos835(X,Y) get_gdat_float((X),(Y),835) +#define get_gdat_uint_pos836(X,Y) get_gdat_uint((X),(Y),836) +#define get_gdat_ullong_pos836(X,Y) get_gdat_ullong((X),(Y),836) +#define get_gdat_ip_pos836(X,Y) get_gdat_ip((X),(Y),836) +#define get_gdat_ipv6_pos836(X,Y) get_gdat_ipv6((X),(Y),836) +#define get_gdat_string_pos836(X,Y) get_gdat_string((X),(Y),836) +#define get_gdat_v_str_pos836(X,Y) get_gdat_string((X),(Y),836) +#define get_gdat_bool_pos836(X,Y) get_gdat_bool((X),(Y),836) +#define get_gdat_int_pos836(X,Y) get_gdat_int((X),(Y),836) +#define get_gdat_llong_pos836(X,Y) get_gdat_llong((X),(Y),836) +#define get_gdat_float_pos836(X,Y) get_gdat_float((X),(Y),836) +#define get_gdat_uint_pos837(X,Y) get_gdat_uint((X),(Y),837) +#define get_gdat_ullong_pos837(X,Y) get_gdat_ullong((X),(Y),837) +#define get_gdat_ip_pos837(X,Y) get_gdat_ip((X),(Y),837) +#define get_gdat_ipv6_pos837(X,Y) get_gdat_ipv6((X),(Y),837) +#define get_gdat_string_pos837(X,Y) get_gdat_string((X),(Y),837) +#define get_gdat_v_str_pos837(X,Y) get_gdat_string((X),(Y),837) +#define get_gdat_bool_pos837(X,Y) get_gdat_bool((X),(Y),837) +#define get_gdat_int_pos837(X,Y) get_gdat_int((X),(Y),837) +#define get_gdat_llong_pos837(X,Y) get_gdat_llong((X),(Y),837) +#define get_gdat_float_pos837(X,Y) get_gdat_float((X),(Y),837) +#define get_gdat_uint_pos838(X,Y) get_gdat_uint((X),(Y),838) +#define get_gdat_ullong_pos838(X,Y) get_gdat_ullong((X),(Y),838) +#define get_gdat_ip_pos838(X,Y) get_gdat_ip((X),(Y),838) +#define get_gdat_ipv6_pos838(X,Y) get_gdat_ipv6((X),(Y),838) +#define get_gdat_string_pos838(X,Y) get_gdat_string((X),(Y),838) +#define get_gdat_v_str_pos838(X,Y) get_gdat_string((X),(Y),838) +#define get_gdat_bool_pos838(X,Y) get_gdat_bool((X),(Y),838) +#define get_gdat_int_pos838(X,Y) get_gdat_int((X),(Y),838) +#define get_gdat_llong_pos838(X,Y) get_gdat_llong((X),(Y),838) +#define get_gdat_float_pos838(X,Y) get_gdat_float((X),(Y),838) +#define get_gdat_uint_pos839(X,Y) get_gdat_uint((X),(Y),839) +#define get_gdat_ullong_pos839(X,Y) get_gdat_ullong((X),(Y),839) +#define get_gdat_ip_pos839(X,Y) get_gdat_ip((X),(Y),839) +#define get_gdat_ipv6_pos839(X,Y) get_gdat_ipv6((X),(Y),839) +#define get_gdat_string_pos839(X,Y) get_gdat_string((X),(Y),839) +#define get_gdat_v_str_pos839(X,Y) get_gdat_string((X),(Y),839) +#define get_gdat_bool_pos839(X,Y) get_gdat_bool((X),(Y),839) +#define get_gdat_int_pos839(X,Y) get_gdat_int((X),(Y),839) +#define get_gdat_llong_pos839(X,Y) get_gdat_llong((X),(Y),839) +#define get_gdat_float_pos839(X,Y) get_gdat_float((X),(Y),839) +#define get_gdat_uint_pos840(X,Y) get_gdat_uint((X),(Y),840) +#define get_gdat_ullong_pos840(X,Y) get_gdat_ullong((X),(Y),840) +#define get_gdat_ip_pos840(X,Y) get_gdat_ip((X),(Y),840) +#define get_gdat_ipv6_pos840(X,Y) get_gdat_ipv6((X),(Y),840) +#define get_gdat_string_pos840(X,Y) get_gdat_string((X),(Y),840) +#define get_gdat_v_str_pos840(X,Y) get_gdat_string((X),(Y),840) +#define get_gdat_bool_pos840(X,Y) get_gdat_bool((X),(Y),840) +#define get_gdat_int_pos840(X,Y) get_gdat_int((X),(Y),840) +#define get_gdat_llong_pos840(X,Y) get_gdat_llong((X),(Y),840) +#define get_gdat_float_pos840(X,Y) get_gdat_float((X),(Y),840) +#define get_gdat_uint_pos841(X,Y) get_gdat_uint((X),(Y),841) +#define get_gdat_ullong_pos841(X,Y) get_gdat_ullong((X),(Y),841) +#define get_gdat_ip_pos841(X,Y) get_gdat_ip((X),(Y),841) +#define get_gdat_ipv6_pos841(X,Y) get_gdat_ipv6((X),(Y),841) +#define get_gdat_string_pos841(X,Y) get_gdat_string((X),(Y),841) +#define get_gdat_v_str_pos841(X,Y) get_gdat_string((X),(Y),841) +#define get_gdat_bool_pos841(X,Y) get_gdat_bool((X),(Y),841) +#define get_gdat_int_pos841(X,Y) get_gdat_int((X),(Y),841) +#define get_gdat_llong_pos841(X,Y) get_gdat_llong((X),(Y),841) +#define get_gdat_float_pos841(X,Y) get_gdat_float((X),(Y),841) +#define get_gdat_uint_pos842(X,Y) get_gdat_uint((X),(Y),842) +#define get_gdat_ullong_pos842(X,Y) get_gdat_ullong((X),(Y),842) +#define get_gdat_ip_pos842(X,Y) get_gdat_ip((X),(Y),842) +#define get_gdat_ipv6_pos842(X,Y) get_gdat_ipv6((X),(Y),842) +#define get_gdat_string_pos842(X,Y) get_gdat_string((X),(Y),842) +#define get_gdat_v_str_pos842(X,Y) get_gdat_string((X),(Y),842) +#define get_gdat_bool_pos842(X,Y) get_gdat_bool((X),(Y),842) +#define get_gdat_int_pos842(X,Y) get_gdat_int((X),(Y),842) +#define get_gdat_llong_pos842(X,Y) get_gdat_llong((X),(Y),842) +#define get_gdat_float_pos842(X,Y) get_gdat_float((X),(Y),842) +#define get_gdat_uint_pos843(X,Y) get_gdat_uint((X),(Y),843) +#define get_gdat_ullong_pos843(X,Y) get_gdat_ullong((X),(Y),843) +#define get_gdat_ip_pos843(X,Y) get_gdat_ip((X),(Y),843) +#define get_gdat_ipv6_pos843(X,Y) get_gdat_ipv6((X),(Y),843) +#define get_gdat_string_pos843(X,Y) get_gdat_string((X),(Y),843) +#define get_gdat_v_str_pos843(X,Y) get_gdat_string((X),(Y),843) +#define get_gdat_bool_pos843(X,Y) get_gdat_bool((X),(Y),843) +#define get_gdat_int_pos843(X,Y) get_gdat_int((X),(Y),843) +#define get_gdat_llong_pos843(X,Y) get_gdat_llong((X),(Y),843) +#define get_gdat_float_pos843(X,Y) get_gdat_float((X),(Y),843) +#define get_gdat_uint_pos844(X,Y) get_gdat_uint((X),(Y),844) +#define get_gdat_ullong_pos844(X,Y) get_gdat_ullong((X),(Y),844) +#define get_gdat_ip_pos844(X,Y) get_gdat_ip((X),(Y),844) +#define get_gdat_ipv6_pos844(X,Y) get_gdat_ipv6((X),(Y),844) +#define get_gdat_string_pos844(X,Y) get_gdat_string((X),(Y),844) +#define get_gdat_v_str_pos844(X,Y) get_gdat_string((X),(Y),844) +#define get_gdat_bool_pos844(X,Y) get_gdat_bool((X),(Y),844) +#define get_gdat_int_pos844(X,Y) get_gdat_int((X),(Y),844) +#define get_gdat_llong_pos844(X,Y) get_gdat_llong((X),(Y),844) +#define get_gdat_float_pos844(X,Y) get_gdat_float((X),(Y),844) +#define get_gdat_uint_pos845(X,Y) get_gdat_uint((X),(Y),845) +#define get_gdat_ullong_pos845(X,Y) get_gdat_ullong((X),(Y),845) +#define get_gdat_ip_pos845(X,Y) get_gdat_ip((X),(Y),845) +#define get_gdat_ipv6_pos845(X,Y) get_gdat_ipv6((X),(Y),845) +#define get_gdat_string_pos845(X,Y) get_gdat_string((X),(Y),845) +#define get_gdat_v_str_pos845(X,Y) get_gdat_string((X),(Y),845) +#define get_gdat_bool_pos845(X,Y) get_gdat_bool((X),(Y),845) +#define get_gdat_int_pos845(X,Y) get_gdat_int((X),(Y),845) +#define get_gdat_llong_pos845(X,Y) get_gdat_llong((X),(Y),845) +#define get_gdat_float_pos845(X,Y) get_gdat_float((X),(Y),845) +#define get_gdat_uint_pos846(X,Y) get_gdat_uint((X),(Y),846) +#define get_gdat_ullong_pos846(X,Y) get_gdat_ullong((X),(Y),846) +#define get_gdat_ip_pos846(X,Y) get_gdat_ip((X),(Y),846) +#define get_gdat_ipv6_pos846(X,Y) get_gdat_ipv6((X),(Y),846) +#define get_gdat_string_pos846(X,Y) get_gdat_string((X),(Y),846) +#define get_gdat_v_str_pos846(X,Y) get_gdat_string((X),(Y),846) +#define get_gdat_bool_pos846(X,Y) get_gdat_bool((X),(Y),846) +#define get_gdat_int_pos846(X,Y) get_gdat_int((X),(Y),846) +#define get_gdat_llong_pos846(X,Y) get_gdat_llong((X),(Y),846) +#define get_gdat_float_pos846(X,Y) get_gdat_float((X),(Y),846) +#define get_gdat_uint_pos847(X,Y) get_gdat_uint((X),(Y),847) +#define get_gdat_ullong_pos847(X,Y) get_gdat_ullong((X),(Y),847) +#define get_gdat_ip_pos847(X,Y) get_gdat_ip((X),(Y),847) +#define get_gdat_ipv6_pos847(X,Y) get_gdat_ipv6((X),(Y),847) +#define get_gdat_string_pos847(X,Y) get_gdat_string((X),(Y),847) +#define get_gdat_v_str_pos847(X,Y) get_gdat_string((X),(Y),847) +#define get_gdat_bool_pos847(X,Y) get_gdat_bool((X),(Y),847) +#define get_gdat_int_pos847(X,Y) get_gdat_int((X),(Y),847) +#define get_gdat_llong_pos847(X,Y) get_gdat_llong((X),(Y),847) +#define get_gdat_float_pos847(X,Y) get_gdat_float((X),(Y),847) +#define get_gdat_uint_pos848(X,Y) get_gdat_uint((X),(Y),848) +#define get_gdat_ullong_pos848(X,Y) get_gdat_ullong((X),(Y),848) +#define get_gdat_ip_pos848(X,Y) get_gdat_ip((X),(Y),848) +#define get_gdat_ipv6_pos848(X,Y) get_gdat_ipv6((X),(Y),848) +#define get_gdat_string_pos848(X,Y) get_gdat_string((X),(Y),848) +#define get_gdat_v_str_pos848(X,Y) get_gdat_string((X),(Y),848) +#define get_gdat_bool_pos848(X,Y) get_gdat_bool((X),(Y),848) +#define get_gdat_int_pos848(X,Y) get_gdat_int((X),(Y),848) +#define get_gdat_llong_pos848(X,Y) get_gdat_llong((X),(Y),848) +#define get_gdat_float_pos848(X,Y) get_gdat_float((X),(Y),848) +#define get_gdat_uint_pos849(X,Y) get_gdat_uint((X),(Y),849) +#define get_gdat_ullong_pos849(X,Y) get_gdat_ullong((X),(Y),849) +#define get_gdat_ip_pos849(X,Y) get_gdat_ip((X),(Y),849) +#define get_gdat_ipv6_pos849(X,Y) get_gdat_ipv6((X),(Y),849) +#define get_gdat_string_pos849(X,Y) get_gdat_string((X),(Y),849) +#define get_gdat_v_str_pos849(X,Y) get_gdat_string((X),(Y),849) +#define get_gdat_bool_pos849(X,Y) get_gdat_bool((X),(Y),849) +#define get_gdat_int_pos849(X,Y) get_gdat_int((X),(Y),849) +#define get_gdat_llong_pos849(X,Y) get_gdat_llong((X),(Y),849) +#define get_gdat_float_pos849(X,Y) get_gdat_float((X),(Y),849) +#define get_gdat_uint_pos850(X,Y) get_gdat_uint((X),(Y),850) +#define get_gdat_ullong_pos850(X,Y) get_gdat_ullong((X),(Y),850) +#define get_gdat_ip_pos850(X,Y) get_gdat_ip((X),(Y),850) +#define get_gdat_ipv6_pos850(X,Y) get_gdat_ipv6((X),(Y),850) +#define get_gdat_string_pos850(X,Y) get_gdat_string((X),(Y),850) +#define get_gdat_v_str_pos850(X,Y) get_gdat_string((X),(Y),850) +#define get_gdat_bool_pos850(X,Y) get_gdat_bool((X),(Y),850) +#define get_gdat_int_pos850(X,Y) get_gdat_int((X),(Y),850) +#define get_gdat_llong_pos850(X,Y) get_gdat_llong((X),(Y),850) +#define get_gdat_float_pos850(X,Y) get_gdat_float((X),(Y),850) +#define get_gdat_uint_pos851(X,Y) get_gdat_uint((X),(Y),851) +#define get_gdat_ullong_pos851(X,Y) get_gdat_ullong((X),(Y),851) +#define get_gdat_ip_pos851(X,Y) get_gdat_ip((X),(Y),851) +#define get_gdat_ipv6_pos851(X,Y) get_gdat_ipv6((X),(Y),851) +#define get_gdat_string_pos851(X,Y) get_gdat_string((X),(Y),851) +#define get_gdat_v_str_pos851(X,Y) get_gdat_string((X),(Y),851) +#define get_gdat_bool_pos851(X,Y) get_gdat_bool((X),(Y),851) +#define get_gdat_int_pos851(X,Y) get_gdat_int((X),(Y),851) +#define get_gdat_llong_pos851(X,Y) get_gdat_llong((X),(Y),851) +#define get_gdat_float_pos851(X,Y) get_gdat_float((X),(Y),851) +#define get_gdat_uint_pos852(X,Y) get_gdat_uint((X),(Y),852) +#define get_gdat_ullong_pos852(X,Y) get_gdat_ullong((X),(Y),852) +#define get_gdat_ip_pos852(X,Y) get_gdat_ip((X),(Y),852) +#define get_gdat_ipv6_pos852(X,Y) get_gdat_ipv6((X),(Y),852) +#define get_gdat_string_pos852(X,Y) get_gdat_string((X),(Y),852) +#define get_gdat_v_str_pos852(X,Y) get_gdat_string((X),(Y),852) +#define get_gdat_bool_pos852(X,Y) get_gdat_bool((X),(Y),852) +#define get_gdat_int_pos852(X,Y) get_gdat_int((X),(Y),852) +#define get_gdat_llong_pos852(X,Y) get_gdat_llong((X),(Y),852) +#define get_gdat_float_pos852(X,Y) get_gdat_float((X),(Y),852) +#define get_gdat_uint_pos853(X,Y) get_gdat_uint((X),(Y),853) +#define get_gdat_ullong_pos853(X,Y) get_gdat_ullong((X),(Y),853) +#define get_gdat_ip_pos853(X,Y) get_gdat_ip((X),(Y),853) +#define get_gdat_ipv6_pos853(X,Y) get_gdat_ipv6((X),(Y),853) +#define get_gdat_string_pos853(X,Y) get_gdat_string((X),(Y),853) +#define get_gdat_v_str_pos853(X,Y) get_gdat_string((X),(Y),853) +#define get_gdat_bool_pos853(X,Y) get_gdat_bool((X),(Y),853) +#define get_gdat_int_pos853(X,Y) get_gdat_int((X),(Y),853) +#define get_gdat_llong_pos853(X,Y) get_gdat_llong((X),(Y),853) +#define get_gdat_float_pos853(X,Y) get_gdat_float((X),(Y),853) +#define get_gdat_uint_pos854(X,Y) get_gdat_uint((X),(Y),854) +#define get_gdat_ullong_pos854(X,Y) get_gdat_ullong((X),(Y),854) +#define get_gdat_ip_pos854(X,Y) get_gdat_ip((X),(Y),854) +#define get_gdat_ipv6_pos854(X,Y) get_gdat_ipv6((X),(Y),854) +#define get_gdat_string_pos854(X,Y) get_gdat_string((X),(Y),854) +#define get_gdat_v_str_pos854(X,Y) get_gdat_string((X),(Y),854) +#define get_gdat_bool_pos854(X,Y) get_gdat_bool((X),(Y),854) +#define get_gdat_int_pos854(X,Y) get_gdat_int((X),(Y),854) +#define get_gdat_llong_pos854(X,Y) get_gdat_llong((X),(Y),854) +#define get_gdat_float_pos854(X,Y) get_gdat_float((X),(Y),854) +#define get_gdat_uint_pos855(X,Y) get_gdat_uint((X),(Y),855) +#define get_gdat_ullong_pos855(X,Y) get_gdat_ullong((X),(Y),855) +#define get_gdat_ip_pos855(X,Y) get_gdat_ip((X),(Y),855) +#define get_gdat_ipv6_pos855(X,Y) get_gdat_ipv6((X),(Y),855) +#define get_gdat_string_pos855(X,Y) get_gdat_string((X),(Y),855) +#define get_gdat_v_str_pos855(X,Y) get_gdat_string((X),(Y),855) +#define get_gdat_bool_pos855(X,Y) get_gdat_bool((X),(Y),855) +#define get_gdat_int_pos855(X,Y) get_gdat_int((X),(Y),855) +#define get_gdat_llong_pos855(X,Y) get_gdat_llong((X),(Y),855) +#define get_gdat_float_pos855(X,Y) get_gdat_float((X),(Y),855) +#define get_gdat_uint_pos856(X,Y) get_gdat_uint((X),(Y),856) +#define get_gdat_ullong_pos856(X,Y) get_gdat_ullong((X),(Y),856) +#define get_gdat_ip_pos856(X,Y) get_gdat_ip((X),(Y),856) +#define get_gdat_ipv6_pos856(X,Y) get_gdat_ipv6((X),(Y),856) +#define get_gdat_string_pos856(X,Y) get_gdat_string((X),(Y),856) +#define get_gdat_v_str_pos856(X,Y) get_gdat_string((X),(Y),856) +#define get_gdat_bool_pos856(X,Y) get_gdat_bool((X),(Y),856) +#define get_gdat_int_pos856(X,Y) get_gdat_int((X),(Y),856) +#define get_gdat_llong_pos856(X,Y) get_gdat_llong((X),(Y),856) +#define get_gdat_float_pos856(X,Y) get_gdat_float((X),(Y),856) +#define get_gdat_uint_pos857(X,Y) get_gdat_uint((X),(Y),857) +#define get_gdat_ullong_pos857(X,Y) get_gdat_ullong((X),(Y),857) +#define get_gdat_ip_pos857(X,Y) get_gdat_ip((X),(Y),857) +#define get_gdat_ipv6_pos857(X,Y) get_gdat_ipv6((X),(Y),857) +#define get_gdat_string_pos857(X,Y) get_gdat_string((X),(Y),857) +#define get_gdat_v_str_pos857(X,Y) get_gdat_string((X),(Y),857) +#define get_gdat_bool_pos857(X,Y) get_gdat_bool((X),(Y),857) +#define get_gdat_int_pos857(X,Y) get_gdat_int((X),(Y),857) +#define get_gdat_llong_pos857(X,Y) get_gdat_llong((X),(Y),857) +#define get_gdat_float_pos857(X,Y) get_gdat_float((X),(Y),857) +#define get_gdat_uint_pos858(X,Y) get_gdat_uint((X),(Y),858) +#define get_gdat_ullong_pos858(X,Y) get_gdat_ullong((X),(Y),858) +#define get_gdat_ip_pos858(X,Y) get_gdat_ip((X),(Y),858) +#define get_gdat_ipv6_pos858(X,Y) get_gdat_ipv6((X),(Y),858) +#define get_gdat_string_pos858(X,Y) get_gdat_string((X),(Y),858) +#define get_gdat_v_str_pos858(X,Y) get_gdat_string((X),(Y),858) +#define get_gdat_bool_pos858(X,Y) get_gdat_bool((X),(Y),858) +#define get_gdat_int_pos858(X,Y) get_gdat_int((X),(Y),858) +#define get_gdat_llong_pos858(X,Y) get_gdat_llong((X),(Y),858) +#define get_gdat_float_pos858(X,Y) get_gdat_float((X),(Y),858) +#define get_gdat_uint_pos859(X,Y) get_gdat_uint((X),(Y),859) +#define get_gdat_ullong_pos859(X,Y) get_gdat_ullong((X),(Y),859) +#define get_gdat_ip_pos859(X,Y) get_gdat_ip((X),(Y),859) +#define get_gdat_ipv6_pos859(X,Y) get_gdat_ipv6((X),(Y),859) +#define get_gdat_string_pos859(X,Y) get_gdat_string((X),(Y),859) +#define get_gdat_v_str_pos859(X,Y) get_gdat_string((X),(Y),859) +#define get_gdat_bool_pos859(X,Y) get_gdat_bool((X),(Y),859) +#define get_gdat_int_pos859(X,Y) get_gdat_int((X),(Y),859) +#define get_gdat_llong_pos859(X,Y) get_gdat_llong((X),(Y),859) +#define get_gdat_float_pos859(X,Y) get_gdat_float((X),(Y),859) +#define get_gdat_uint_pos860(X,Y) get_gdat_uint((X),(Y),860) +#define get_gdat_ullong_pos860(X,Y) get_gdat_ullong((X),(Y),860) +#define get_gdat_ip_pos860(X,Y) get_gdat_ip((X),(Y),860) +#define get_gdat_ipv6_pos860(X,Y) get_gdat_ipv6((X),(Y),860) +#define get_gdat_string_pos860(X,Y) get_gdat_string((X),(Y),860) +#define get_gdat_v_str_pos860(X,Y) get_gdat_string((X),(Y),860) +#define get_gdat_bool_pos860(X,Y) get_gdat_bool((X),(Y),860) +#define get_gdat_int_pos860(X,Y) get_gdat_int((X),(Y),860) +#define get_gdat_llong_pos860(X,Y) get_gdat_llong((X),(Y),860) +#define get_gdat_float_pos860(X,Y) get_gdat_float((X),(Y),860) +#define get_gdat_uint_pos861(X,Y) get_gdat_uint((X),(Y),861) +#define get_gdat_ullong_pos861(X,Y) get_gdat_ullong((X),(Y),861) +#define get_gdat_ip_pos861(X,Y) get_gdat_ip((X),(Y),861) +#define get_gdat_ipv6_pos861(X,Y) get_gdat_ipv6((X),(Y),861) +#define get_gdat_string_pos861(X,Y) get_gdat_string((X),(Y),861) +#define get_gdat_v_str_pos861(X,Y) get_gdat_string((X),(Y),861) +#define get_gdat_bool_pos861(X,Y) get_gdat_bool((X),(Y),861) +#define get_gdat_int_pos861(X,Y) get_gdat_int((X),(Y),861) +#define get_gdat_llong_pos861(X,Y) get_gdat_llong((X),(Y),861) +#define get_gdat_float_pos861(X,Y) get_gdat_float((X),(Y),861) +#define get_gdat_uint_pos862(X,Y) get_gdat_uint((X),(Y),862) +#define get_gdat_ullong_pos862(X,Y) get_gdat_ullong((X),(Y),862) +#define get_gdat_ip_pos862(X,Y) get_gdat_ip((X),(Y),862) +#define get_gdat_ipv6_pos862(X,Y) get_gdat_ipv6((X),(Y),862) +#define get_gdat_string_pos862(X,Y) get_gdat_string((X),(Y),862) +#define get_gdat_v_str_pos862(X,Y) get_gdat_string((X),(Y),862) +#define get_gdat_bool_pos862(X,Y) get_gdat_bool((X),(Y),862) +#define get_gdat_int_pos862(X,Y) get_gdat_int((X),(Y),862) +#define get_gdat_llong_pos862(X,Y) get_gdat_llong((X),(Y),862) +#define get_gdat_float_pos862(X,Y) get_gdat_float((X),(Y),862) +#define get_gdat_uint_pos863(X,Y) get_gdat_uint((X),(Y),863) +#define get_gdat_ullong_pos863(X,Y) get_gdat_ullong((X),(Y),863) +#define get_gdat_ip_pos863(X,Y) get_gdat_ip((X),(Y),863) +#define get_gdat_ipv6_pos863(X,Y) get_gdat_ipv6((X),(Y),863) +#define get_gdat_string_pos863(X,Y) get_gdat_string((X),(Y),863) +#define get_gdat_v_str_pos863(X,Y) get_gdat_string((X),(Y),863) +#define get_gdat_bool_pos863(X,Y) get_gdat_bool((X),(Y),863) +#define get_gdat_int_pos863(X,Y) get_gdat_int((X),(Y),863) +#define get_gdat_llong_pos863(X,Y) get_gdat_llong((X),(Y),863) +#define get_gdat_float_pos863(X,Y) get_gdat_float((X),(Y),863) +#define get_gdat_uint_pos864(X,Y) get_gdat_uint((X),(Y),864) +#define get_gdat_ullong_pos864(X,Y) get_gdat_ullong((X),(Y),864) +#define get_gdat_ip_pos864(X,Y) get_gdat_ip((X),(Y),864) +#define get_gdat_ipv6_pos864(X,Y) get_gdat_ipv6((X),(Y),864) +#define get_gdat_string_pos864(X,Y) get_gdat_string((X),(Y),864) +#define get_gdat_v_str_pos864(X,Y) get_gdat_string((X),(Y),864) +#define get_gdat_bool_pos864(X,Y) get_gdat_bool((X),(Y),864) +#define get_gdat_int_pos864(X,Y) get_gdat_int((X),(Y),864) +#define get_gdat_llong_pos864(X,Y) get_gdat_llong((X),(Y),864) +#define get_gdat_float_pos864(X,Y) get_gdat_float((X),(Y),864) +#define get_gdat_uint_pos865(X,Y) get_gdat_uint((X),(Y),865) +#define get_gdat_ullong_pos865(X,Y) get_gdat_ullong((X),(Y),865) +#define get_gdat_ip_pos865(X,Y) get_gdat_ip((X),(Y),865) +#define get_gdat_ipv6_pos865(X,Y) get_gdat_ipv6((X),(Y),865) +#define get_gdat_string_pos865(X,Y) get_gdat_string((X),(Y),865) +#define get_gdat_v_str_pos865(X,Y) get_gdat_string((X),(Y),865) +#define get_gdat_bool_pos865(X,Y) get_gdat_bool((X),(Y),865) +#define get_gdat_int_pos865(X,Y) get_gdat_int((X),(Y),865) +#define get_gdat_llong_pos865(X,Y) get_gdat_llong((X),(Y),865) +#define get_gdat_float_pos865(X,Y) get_gdat_float((X),(Y),865) +#define get_gdat_uint_pos866(X,Y) get_gdat_uint((X),(Y),866) +#define get_gdat_ullong_pos866(X,Y) get_gdat_ullong((X),(Y),866) +#define get_gdat_ip_pos866(X,Y) get_gdat_ip((X),(Y),866) +#define get_gdat_ipv6_pos866(X,Y) get_gdat_ipv6((X),(Y),866) +#define get_gdat_string_pos866(X,Y) get_gdat_string((X),(Y),866) +#define get_gdat_v_str_pos866(X,Y) get_gdat_string((X),(Y),866) +#define get_gdat_bool_pos866(X,Y) get_gdat_bool((X),(Y),866) +#define get_gdat_int_pos866(X,Y) get_gdat_int((X),(Y),866) +#define get_gdat_llong_pos866(X,Y) get_gdat_llong((X),(Y),866) +#define get_gdat_float_pos866(X,Y) get_gdat_float((X),(Y),866) +#define get_gdat_uint_pos867(X,Y) get_gdat_uint((X),(Y),867) +#define get_gdat_ullong_pos867(X,Y) get_gdat_ullong((X),(Y),867) +#define get_gdat_ip_pos867(X,Y) get_gdat_ip((X),(Y),867) +#define get_gdat_ipv6_pos867(X,Y) get_gdat_ipv6((X),(Y),867) +#define get_gdat_string_pos867(X,Y) get_gdat_string((X),(Y),867) +#define get_gdat_v_str_pos867(X,Y) get_gdat_string((X),(Y),867) +#define get_gdat_bool_pos867(X,Y) get_gdat_bool((X),(Y),867) +#define get_gdat_int_pos867(X,Y) get_gdat_int((X),(Y),867) +#define get_gdat_llong_pos867(X,Y) get_gdat_llong((X),(Y),867) +#define get_gdat_float_pos867(X,Y) get_gdat_float((X),(Y),867) +#define get_gdat_uint_pos868(X,Y) get_gdat_uint((X),(Y),868) +#define get_gdat_ullong_pos868(X,Y) get_gdat_ullong((X),(Y),868) +#define get_gdat_ip_pos868(X,Y) get_gdat_ip((X),(Y),868) +#define get_gdat_ipv6_pos868(X,Y) get_gdat_ipv6((X),(Y),868) +#define get_gdat_string_pos868(X,Y) get_gdat_string((X),(Y),868) +#define get_gdat_v_str_pos868(X,Y) get_gdat_string((X),(Y),868) +#define get_gdat_bool_pos868(X,Y) get_gdat_bool((X),(Y),868) +#define get_gdat_int_pos868(X,Y) get_gdat_int((X),(Y),868) +#define get_gdat_llong_pos868(X,Y) get_gdat_llong((X),(Y),868) +#define get_gdat_float_pos868(X,Y) get_gdat_float((X),(Y),868) +#define get_gdat_uint_pos869(X,Y) get_gdat_uint((X),(Y),869) +#define get_gdat_ullong_pos869(X,Y) get_gdat_ullong((X),(Y),869) +#define get_gdat_ip_pos869(X,Y) get_gdat_ip((X),(Y),869) +#define get_gdat_ipv6_pos869(X,Y) get_gdat_ipv6((X),(Y),869) +#define get_gdat_string_pos869(X,Y) get_gdat_string((X),(Y),869) +#define get_gdat_v_str_pos869(X,Y) get_gdat_string((X),(Y),869) +#define get_gdat_bool_pos869(X,Y) get_gdat_bool((X),(Y),869) +#define get_gdat_int_pos869(X,Y) get_gdat_int((X),(Y),869) +#define get_gdat_llong_pos869(X,Y) get_gdat_llong((X),(Y),869) +#define get_gdat_float_pos869(X,Y) get_gdat_float((X),(Y),869) +#define get_gdat_uint_pos870(X,Y) get_gdat_uint((X),(Y),870) +#define get_gdat_ullong_pos870(X,Y) get_gdat_ullong((X),(Y),870) +#define get_gdat_ip_pos870(X,Y) get_gdat_ip((X),(Y),870) +#define get_gdat_ipv6_pos870(X,Y) get_gdat_ipv6((X),(Y),870) +#define get_gdat_string_pos870(X,Y) get_gdat_string((X),(Y),870) +#define get_gdat_v_str_pos870(X,Y) get_gdat_string((X),(Y),870) +#define get_gdat_bool_pos870(X,Y) get_gdat_bool((X),(Y),870) +#define get_gdat_int_pos870(X,Y) get_gdat_int((X),(Y),870) +#define get_gdat_llong_pos870(X,Y) get_gdat_llong((X),(Y),870) +#define get_gdat_float_pos870(X,Y) get_gdat_float((X),(Y),870) +#define get_gdat_uint_pos871(X,Y) get_gdat_uint((X),(Y),871) +#define get_gdat_ullong_pos871(X,Y) get_gdat_ullong((X),(Y),871) +#define get_gdat_ip_pos871(X,Y) get_gdat_ip((X),(Y),871) +#define get_gdat_ipv6_pos871(X,Y) get_gdat_ipv6((X),(Y),871) +#define get_gdat_string_pos871(X,Y) get_gdat_string((X),(Y),871) +#define get_gdat_v_str_pos871(X,Y) get_gdat_string((X),(Y),871) +#define get_gdat_bool_pos871(X,Y) get_gdat_bool((X),(Y),871) +#define get_gdat_int_pos871(X,Y) get_gdat_int((X),(Y),871) +#define get_gdat_llong_pos871(X,Y) get_gdat_llong((X),(Y),871) +#define get_gdat_float_pos871(X,Y) get_gdat_float((X),(Y),871) +#define get_gdat_uint_pos872(X,Y) get_gdat_uint((X),(Y),872) +#define get_gdat_ullong_pos872(X,Y) get_gdat_ullong((X),(Y),872) +#define get_gdat_ip_pos872(X,Y) get_gdat_ip((X),(Y),872) +#define get_gdat_ipv6_pos872(X,Y) get_gdat_ipv6((X),(Y),872) +#define get_gdat_string_pos872(X,Y) get_gdat_string((X),(Y),872) +#define get_gdat_v_str_pos872(X,Y) get_gdat_string((X),(Y),872) +#define get_gdat_bool_pos872(X,Y) get_gdat_bool((X),(Y),872) +#define get_gdat_int_pos872(X,Y) get_gdat_int((X),(Y),872) +#define get_gdat_llong_pos872(X,Y) get_gdat_llong((X),(Y),872) +#define get_gdat_float_pos872(X,Y) get_gdat_float((X),(Y),872) +#define get_gdat_uint_pos873(X,Y) get_gdat_uint((X),(Y),873) +#define get_gdat_ullong_pos873(X,Y) get_gdat_ullong((X),(Y),873) +#define get_gdat_ip_pos873(X,Y) get_gdat_ip((X),(Y),873) +#define get_gdat_ipv6_pos873(X,Y) get_gdat_ipv6((X),(Y),873) +#define get_gdat_string_pos873(X,Y) get_gdat_string((X),(Y),873) +#define get_gdat_v_str_pos873(X,Y) get_gdat_string((X),(Y),873) +#define get_gdat_bool_pos873(X,Y) get_gdat_bool((X),(Y),873) +#define get_gdat_int_pos873(X,Y) get_gdat_int((X),(Y),873) +#define get_gdat_llong_pos873(X,Y) get_gdat_llong((X),(Y),873) +#define get_gdat_float_pos873(X,Y) get_gdat_float((X),(Y),873) +#define get_gdat_uint_pos874(X,Y) get_gdat_uint((X),(Y),874) +#define get_gdat_ullong_pos874(X,Y) get_gdat_ullong((X),(Y),874) +#define get_gdat_ip_pos874(X,Y) get_gdat_ip((X),(Y),874) +#define get_gdat_ipv6_pos874(X,Y) get_gdat_ipv6((X),(Y),874) +#define get_gdat_string_pos874(X,Y) get_gdat_string((X),(Y),874) +#define get_gdat_v_str_pos874(X,Y) get_gdat_string((X),(Y),874) +#define get_gdat_bool_pos874(X,Y) get_gdat_bool((X),(Y),874) +#define get_gdat_int_pos874(X,Y) get_gdat_int((X),(Y),874) +#define get_gdat_llong_pos874(X,Y) get_gdat_llong((X),(Y),874) +#define get_gdat_float_pos874(X,Y) get_gdat_float((X),(Y),874) +#define get_gdat_uint_pos875(X,Y) get_gdat_uint((X),(Y),875) +#define get_gdat_ullong_pos875(X,Y) get_gdat_ullong((X),(Y),875) +#define get_gdat_ip_pos875(X,Y) get_gdat_ip((X),(Y),875) +#define get_gdat_ipv6_pos875(X,Y) get_gdat_ipv6((X),(Y),875) +#define get_gdat_string_pos875(X,Y) get_gdat_string((X),(Y),875) +#define get_gdat_v_str_pos875(X,Y) get_gdat_string((X),(Y),875) +#define get_gdat_bool_pos875(X,Y) get_gdat_bool((X),(Y),875) +#define get_gdat_int_pos875(X,Y) get_gdat_int((X),(Y),875) +#define get_gdat_llong_pos875(X,Y) get_gdat_llong((X),(Y),875) +#define get_gdat_float_pos875(X,Y) get_gdat_float((X),(Y),875) +#define get_gdat_uint_pos876(X,Y) get_gdat_uint((X),(Y),876) +#define get_gdat_ullong_pos876(X,Y) get_gdat_ullong((X),(Y),876) +#define get_gdat_ip_pos876(X,Y) get_gdat_ip((X),(Y),876) +#define get_gdat_ipv6_pos876(X,Y) get_gdat_ipv6((X),(Y),876) +#define get_gdat_string_pos876(X,Y) get_gdat_string((X),(Y),876) +#define get_gdat_v_str_pos876(X,Y) get_gdat_string((X),(Y),876) +#define get_gdat_bool_pos876(X,Y) get_gdat_bool((X),(Y),876) +#define get_gdat_int_pos876(X,Y) get_gdat_int((X),(Y),876) +#define get_gdat_llong_pos876(X,Y) get_gdat_llong((X),(Y),876) +#define get_gdat_float_pos876(X,Y) get_gdat_float((X),(Y),876) +#define get_gdat_uint_pos877(X,Y) get_gdat_uint((X),(Y),877) +#define get_gdat_ullong_pos877(X,Y) get_gdat_ullong((X),(Y),877) +#define get_gdat_ip_pos877(X,Y) get_gdat_ip((X),(Y),877) +#define get_gdat_ipv6_pos877(X,Y) get_gdat_ipv6((X),(Y),877) +#define get_gdat_string_pos877(X,Y) get_gdat_string((X),(Y),877) +#define get_gdat_v_str_pos877(X,Y) get_gdat_string((X),(Y),877) +#define get_gdat_bool_pos877(X,Y) get_gdat_bool((X),(Y),877) +#define get_gdat_int_pos877(X,Y) get_gdat_int((X),(Y),877) +#define get_gdat_llong_pos877(X,Y) get_gdat_llong((X),(Y),877) +#define get_gdat_float_pos877(X,Y) get_gdat_float((X),(Y),877) +#define get_gdat_uint_pos878(X,Y) get_gdat_uint((X),(Y),878) +#define get_gdat_ullong_pos878(X,Y) get_gdat_ullong((X),(Y),878) +#define get_gdat_ip_pos878(X,Y) get_gdat_ip((X),(Y),878) +#define get_gdat_ipv6_pos878(X,Y) get_gdat_ipv6((X),(Y),878) +#define get_gdat_string_pos878(X,Y) get_gdat_string((X),(Y),878) +#define get_gdat_v_str_pos878(X,Y) get_gdat_string((X),(Y),878) +#define get_gdat_bool_pos878(X,Y) get_gdat_bool((X),(Y),878) +#define get_gdat_int_pos878(X,Y) get_gdat_int((X),(Y),878) +#define get_gdat_llong_pos878(X,Y) get_gdat_llong((X),(Y),878) +#define get_gdat_float_pos878(X,Y) get_gdat_float((X),(Y),878) +#define get_gdat_uint_pos879(X,Y) get_gdat_uint((X),(Y),879) +#define get_gdat_ullong_pos879(X,Y) get_gdat_ullong((X),(Y),879) +#define get_gdat_ip_pos879(X,Y) get_gdat_ip((X),(Y),879) +#define get_gdat_ipv6_pos879(X,Y) get_gdat_ipv6((X),(Y),879) +#define get_gdat_string_pos879(X,Y) get_gdat_string((X),(Y),879) +#define get_gdat_v_str_pos879(X,Y) get_gdat_string((X),(Y),879) +#define get_gdat_bool_pos879(X,Y) get_gdat_bool((X),(Y),879) +#define get_gdat_int_pos879(X,Y) get_gdat_int((X),(Y),879) +#define get_gdat_llong_pos879(X,Y) get_gdat_llong((X),(Y),879) +#define get_gdat_float_pos879(X,Y) get_gdat_float((X),(Y),879) +#define get_gdat_uint_pos880(X,Y) get_gdat_uint((X),(Y),880) +#define get_gdat_ullong_pos880(X,Y) get_gdat_ullong((X),(Y),880) +#define get_gdat_ip_pos880(X,Y) get_gdat_ip((X),(Y),880) +#define get_gdat_ipv6_pos880(X,Y) get_gdat_ipv6((X),(Y),880) +#define get_gdat_string_pos880(X,Y) get_gdat_string((X),(Y),880) +#define get_gdat_v_str_pos880(X,Y) get_gdat_string((X),(Y),880) +#define get_gdat_bool_pos880(X,Y) get_gdat_bool((X),(Y),880) +#define get_gdat_int_pos880(X,Y) get_gdat_int((X),(Y),880) +#define get_gdat_llong_pos880(X,Y) get_gdat_llong((X),(Y),880) +#define get_gdat_float_pos880(X,Y) get_gdat_float((X),(Y),880) +#define get_gdat_uint_pos881(X,Y) get_gdat_uint((X),(Y),881) +#define get_gdat_ullong_pos881(X,Y) get_gdat_ullong((X),(Y),881) +#define get_gdat_ip_pos881(X,Y) get_gdat_ip((X),(Y),881) +#define get_gdat_ipv6_pos881(X,Y) get_gdat_ipv6((X),(Y),881) +#define get_gdat_string_pos881(X,Y) get_gdat_string((X),(Y),881) +#define get_gdat_v_str_pos881(X,Y) get_gdat_string((X),(Y),881) +#define get_gdat_bool_pos881(X,Y) get_gdat_bool((X),(Y),881) +#define get_gdat_int_pos881(X,Y) get_gdat_int((X),(Y),881) +#define get_gdat_llong_pos881(X,Y) get_gdat_llong((X),(Y),881) +#define get_gdat_float_pos881(X,Y) get_gdat_float((X),(Y),881) +#define get_gdat_uint_pos882(X,Y) get_gdat_uint((X),(Y),882) +#define get_gdat_ullong_pos882(X,Y) get_gdat_ullong((X),(Y),882) +#define get_gdat_ip_pos882(X,Y) get_gdat_ip((X),(Y),882) +#define get_gdat_ipv6_pos882(X,Y) get_gdat_ipv6((X),(Y),882) +#define get_gdat_string_pos882(X,Y) get_gdat_string((X),(Y),882) +#define get_gdat_v_str_pos882(X,Y) get_gdat_string((X),(Y),882) +#define get_gdat_bool_pos882(X,Y) get_gdat_bool((X),(Y),882) +#define get_gdat_int_pos882(X,Y) get_gdat_int((X),(Y),882) +#define get_gdat_llong_pos882(X,Y) get_gdat_llong((X),(Y),882) +#define get_gdat_float_pos882(X,Y) get_gdat_float((X),(Y),882) +#define get_gdat_uint_pos883(X,Y) get_gdat_uint((X),(Y),883) +#define get_gdat_ullong_pos883(X,Y) get_gdat_ullong((X),(Y),883) +#define get_gdat_ip_pos883(X,Y) get_gdat_ip((X),(Y),883) +#define get_gdat_ipv6_pos883(X,Y) get_gdat_ipv6((X),(Y),883) +#define get_gdat_string_pos883(X,Y) get_gdat_string((X),(Y),883) +#define get_gdat_v_str_pos883(X,Y) get_gdat_string((X),(Y),883) +#define get_gdat_bool_pos883(X,Y) get_gdat_bool((X),(Y),883) +#define get_gdat_int_pos883(X,Y) get_gdat_int((X),(Y),883) +#define get_gdat_llong_pos883(X,Y) get_gdat_llong((X),(Y),883) +#define get_gdat_float_pos883(X,Y) get_gdat_float((X),(Y),883) +#define get_gdat_uint_pos884(X,Y) get_gdat_uint((X),(Y),884) +#define get_gdat_ullong_pos884(X,Y) get_gdat_ullong((X),(Y),884) +#define get_gdat_ip_pos884(X,Y) get_gdat_ip((X),(Y),884) +#define get_gdat_ipv6_pos884(X,Y) get_gdat_ipv6((X),(Y),884) +#define get_gdat_string_pos884(X,Y) get_gdat_string((X),(Y),884) +#define get_gdat_v_str_pos884(X,Y) get_gdat_string((X),(Y),884) +#define get_gdat_bool_pos884(X,Y) get_gdat_bool((X),(Y),884) +#define get_gdat_int_pos884(X,Y) get_gdat_int((X),(Y),884) +#define get_gdat_llong_pos884(X,Y) get_gdat_llong((X),(Y),884) +#define get_gdat_float_pos884(X,Y) get_gdat_float((X),(Y),884) +#define get_gdat_uint_pos885(X,Y) get_gdat_uint((X),(Y),885) +#define get_gdat_ullong_pos885(X,Y) get_gdat_ullong((X),(Y),885) +#define get_gdat_ip_pos885(X,Y) get_gdat_ip((X),(Y),885) +#define get_gdat_ipv6_pos885(X,Y) get_gdat_ipv6((X),(Y),885) +#define get_gdat_string_pos885(X,Y) get_gdat_string((X),(Y),885) +#define get_gdat_v_str_pos885(X,Y) get_gdat_string((X),(Y),885) +#define get_gdat_bool_pos885(X,Y) get_gdat_bool((X),(Y),885) +#define get_gdat_int_pos885(X,Y) get_gdat_int((X),(Y),885) +#define get_gdat_llong_pos885(X,Y) get_gdat_llong((X),(Y),885) +#define get_gdat_float_pos885(X,Y) get_gdat_float((X),(Y),885) +#define get_gdat_uint_pos886(X,Y) get_gdat_uint((X),(Y),886) +#define get_gdat_ullong_pos886(X,Y) get_gdat_ullong((X),(Y),886) +#define get_gdat_ip_pos886(X,Y) get_gdat_ip((X),(Y),886) +#define get_gdat_ipv6_pos886(X,Y) get_gdat_ipv6((X),(Y),886) +#define get_gdat_string_pos886(X,Y) get_gdat_string((X),(Y),886) +#define get_gdat_v_str_pos886(X,Y) get_gdat_string((X),(Y),886) +#define get_gdat_bool_pos886(X,Y) get_gdat_bool((X),(Y),886) +#define get_gdat_int_pos886(X,Y) get_gdat_int((X),(Y),886) +#define get_gdat_llong_pos886(X,Y) get_gdat_llong((X),(Y),886) +#define get_gdat_float_pos886(X,Y) get_gdat_float((X),(Y),886) +#define get_gdat_uint_pos887(X,Y) get_gdat_uint((X),(Y),887) +#define get_gdat_ullong_pos887(X,Y) get_gdat_ullong((X),(Y),887) +#define get_gdat_ip_pos887(X,Y) get_gdat_ip((X),(Y),887) +#define get_gdat_ipv6_pos887(X,Y) get_gdat_ipv6((X),(Y),887) +#define get_gdat_string_pos887(X,Y) get_gdat_string((X),(Y),887) +#define get_gdat_v_str_pos887(X,Y) get_gdat_string((X),(Y),887) +#define get_gdat_bool_pos887(X,Y) get_gdat_bool((X),(Y),887) +#define get_gdat_int_pos887(X,Y) get_gdat_int((X),(Y),887) +#define get_gdat_llong_pos887(X,Y) get_gdat_llong((X),(Y),887) +#define get_gdat_float_pos887(X,Y) get_gdat_float((X),(Y),887) +#define get_gdat_uint_pos888(X,Y) get_gdat_uint((X),(Y),888) +#define get_gdat_ullong_pos888(X,Y) get_gdat_ullong((X),(Y),888) +#define get_gdat_ip_pos888(X,Y) get_gdat_ip((X),(Y),888) +#define get_gdat_ipv6_pos888(X,Y) get_gdat_ipv6((X),(Y),888) +#define get_gdat_string_pos888(X,Y) get_gdat_string((X),(Y),888) +#define get_gdat_v_str_pos888(X,Y) get_gdat_string((X),(Y),888) +#define get_gdat_bool_pos888(X,Y) get_gdat_bool((X),(Y),888) +#define get_gdat_int_pos888(X,Y) get_gdat_int((X),(Y),888) +#define get_gdat_llong_pos888(X,Y) get_gdat_llong((X),(Y),888) +#define get_gdat_float_pos888(X,Y) get_gdat_float((X),(Y),888) +#define get_gdat_uint_pos889(X,Y) get_gdat_uint((X),(Y),889) +#define get_gdat_ullong_pos889(X,Y) get_gdat_ullong((X),(Y),889) +#define get_gdat_ip_pos889(X,Y) get_gdat_ip((X),(Y),889) +#define get_gdat_ipv6_pos889(X,Y) get_gdat_ipv6((X),(Y),889) +#define get_gdat_string_pos889(X,Y) get_gdat_string((X),(Y),889) +#define get_gdat_v_str_pos889(X,Y) get_gdat_string((X),(Y),889) +#define get_gdat_bool_pos889(X,Y) get_gdat_bool((X),(Y),889) +#define get_gdat_int_pos889(X,Y) get_gdat_int((X),(Y),889) +#define get_gdat_llong_pos889(X,Y) get_gdat_llong((X),(Y),889) +#define get_gdat_float_pos889(X,Y) get_gdat_float((X),(Y),889) +#define get_gdat_uint_pos890(X,Y) get_gdat_uint((X),(Y),890) +#define get_gdat_ullong_pos890(X,Y) get_gdat_ullong((X),(Y),890) +#define get_gdat_ip_pos890(X,Y) get_gdat_ip((X),(Y),890) +#define get_gdat_ipv6_pos890(X,Y) get_gdat_ipv6((X),(Y),890) +#define get_gdat_string_pos890(X,Y) get_gdat_string((X),(Y),890) +#define get_gdat_v_str_pos890(X,Y) get_gdat_string((X),(Y),890) +#define get_gdat_bool_pos890(X,Y) get_gdat_bool((X),(Y),890) +#define get_gdat_int_pos890(X,Y) get_gdat_int((X),(Y),890) +#define get_gdat_llong_pos890(X,Y) get_gdat_llong((X),(Y),890) +#define get_gdat_float_pos890(X,Y) get_gdat_float((X),(Y),890) +#define get_gdat_uint_pos891(X,Y) get_gdat_uint((X),(Y),891) +#define get_gdat_ullong_pos891(X,Y) get_gdat_ullong((X),(Y),891) +#define get_gdat_ip_pos891(X,Y) get_gdat_ip((X),(Y),891) +#define get_gdat_ipv6_pos891(X,Y) get_gdat_ipv6((X),(Y),891) +#define get_gdat_string_pos891(X,Y) get_gdat_string((X),(Y),891) +#define get_gdat_v_str_pos891(X,Y) get_gdat_string((X),(Y),891) +#define get_gdat_bool_pos891(X,Y) get_gdat_bool((X),(Y),891) +#define get_gdat_int_pos891(X,Y) get_gdat_int((X),(Y),891) +#define get_gdat_llong_pos891(X,Y) get_gdat_llong((X),(Y),891) +#define get_gdat_float_pos891(X,Y) get_gdat_float((X),(Y),891) +#define get_gdat_uint_pos892(X,Y) get_gdat_uint((X),(Y),892) +#define get_gdat_ullong_pos892(X,Y) get_gdat_ullong((X),(Y),892) +#define get_gdat_ip_pos892(X,Y) get_gdat_ip((X),(Y),892) +#define get_gdat_ipv6_pos892(X,Y) get_gdat_ipv6((X),(Y),892) +#define get_gdat_string_pos892(X,Y) get_gdat_string((X),(Y),892) +#define get_gdat_v_str_pos892(X,Y) get_gdat_string((X),(Y),892) +#define get_gdat_bool_pos892(X,Y) get_gdat_bool((X),(Y),892) +#define get_gdat_int_pos892(X,Y) get_gdat_int((X),(Y),892) +#define get_gdat_llong_pos892(X,Y) get_gdat_llong((X),(Y),892) +#define get_gdat_float_pos892(X,Y) get_gdat_float((X),(Y),892) +#define get_gdat_uint_pos893(X,Y) get_gdat_uint((X),(Y),893) +#define get_gdat_ullong_pos893(X,Y) get_gdat_ullong((X),(Y),893) +#define get_gdat_ip_pos893(X,Y) get_gdat_ip((X),(Y),893) +#define get_gdat_ipv6_pos893(X,Y) get_gdat_ipv6((X),(Y),893) +#define get_gdat_string_pos893(X,Y) get_gdat_string((X),(Y),893) +#define get_gdat_v_str_pos893(X,Y) get_gdat_string((X),(Y),893) +#define get_gdat_bool_pos893(X,Y) get_gdat_bool((X),(Y),893) +#define get_gdat_int_pos893(X,Y) get_gdat_int((X),(Y),893) +#define get_gdat_llong_pos893(X,Y) get_gdat_llong((X),(Y),893) +#define get_gdat_float_pos893(X,Y) get_gdat_float((X),(Y),893) +#define get_gdat_uint_pos894(X,Y) get_gdat_uint((X),(Y),894) +#define get_gdat_ullong_pos894(X,Y) get_gdat_ullong((X),(Y),894) +#define get_gdat_ip_pos894(X,Y) get_gdat_ip((X),(Y),894) +#define get_gdat_ipv6_pos894(X,Y) get_gdat_ipv6((X),(Y),894) +#define get_gdat_string_pos894(X,Y) get_gdat_string((X),(Y),894) +#define get_gdat_v_str_pos894(X,Y) get_gdat_string((X),(Y),894) +#define get_gdat_bool_pos894(X,Y) get_gdat_bool((X),(Y),894) +#define get_gdat_int_pos894(X,Y) get_gdat_int((X),(Y),894) +#define get_gdat_llong_pos894(X,Y) get_gdat_llong((X),(Y),894) +#define get_gdat_float_pos894(X,Y) get_gdat_float((X),(Y),894) +#define get_gdat_uint_pos895(X,Y) get_gdat_uint((X),(Y),895) +#define get_gdat_ullong_pos895(X,Y) get_gdat_ullong((X),(Y),895) +#define get_gdat_ip_pos895(X,Y) get_gdat_ip((X),(Y),895) +#define get_gdat_ipv6_pos895(X,Y) get_gdat_ipv6((X),(Y),895) +#define get_gdat_string_pos895(X,Y) get_gdat_string((X),(Y),895) +#define get_gdat_v_str_pos895(X,Y) get_gdat_string((X),(Y),895) +#define get_gdat_bool_pos895(X,Y) get_gdat_bool((X),(Y),895) +#define get_gdat_int_pos895(X,Y) get_gdat_int((X),(Y),895) +#define get_gdat_llong_pos895(X,Y) get_gdat_llong((X),(Y),895) +#define get_gdat_float_pos895(X,Y) get_gdat_float((X),(Y),895) +#define get_gdat_uint_pos896(X,Y) get_gdat_uint((X),(Y),896) +#define get_gdat_ullong_pos896(X,Y) get_gdat_ullong((X),(Y),896) +#define get_gdat_ip_pos896(X,Y) get_gdat_ip((X),(Y),896) +#define get_gdat_ipv6_pos896(X,Y) get_gdat_ipv6((X),(Y),896) +#define get_gdat_string_pos896(X,Y) get_gdat_string((X),(Y),896) +#define get_gdat_v_str_pos896(X,Y) get_gdat_string((X),(Y),896) +#define get_gdat_bool_pos896(X,Y) get_gdat_bool((X),(Y),896) +#define get_gdat_int_pos896(X,Y) get_gdat_int((X),(Y),896) +#define get_gdat_llong_pos896(X,Y) get_gdat_llong((X),(Y),896) +#define get_gdat_float_pos896(X,Y) get_gdat_float((X),(Y),896) +#define get_gdat_uint_pos897(X,Y) get_gdat_uint((X),(Y),897) +#define get_gdat_ullong_pos897(X,Y) get_gdat_ullong((X),(Y),897) +#define get_gdat_ip_pos897(X,Y) get_gdat_ip((X),(Y),897) +#define get_gdat_ipv6_pos897(X,Y) get_gdat_ipv6((X),(Y),897) +#define get_gdat_string_pos897(X,Y) get_gdat_string((X),(Y),897) +#define get_gdat_v_str_pos897(X,Y) get_gdat_string((X),(Y),897) +#define get_gdat_bool_pos897(X,Y) get_gdat_bool((X),(Y),897) +#define get_gdat_int_pos897(X,Y) get_gdat_int((X),(Y),897) +#define get_gdat_llong_pos897(X,Y) get_gdat_llong((X),(Y),897) +#define get_gdat_float_pos897(X,Y) get_gdat_float((X),(Y),897) +#define get_gdat_uint_pos898(X,Y) get_gdat_uint((X),(Y),898) +#define get_gdat_ullong_pos898(X,Y) get_gdat_ullong((X),(Y),898) +#define get_gdat_ip_pos898(X,Y) get_gdat_ip((X),(Y),898) +#define get_gdat_ipv6_pos898(X,Y) get_gdat_ipv6((X),(Y),898) +#define get_gdat_string_pos898(X,Y) get_gdat_string((X),(Y),898) +#define get_gdat_v_str_pos898(X,Y) get_gdat_string((X),(Y),898) +#define get_gdat_bool_pos898(X,Y) get_gdat_bool((X),(Y),898) +#define get_gdat_int_pos898(X,Y) get_gdat_int((X),(Y),898) +#define get_gdat_llong_pos898(X,Y) get_gdat_llong((X),(Y),898) +#define get_gdat_float_pos898(X,Y) get_gdat_float((X),(Y),898) +#define get_gdat_uint_pos899(X,Y) get_gdat_uint((X),(Y),899) +#define get_gdat_ullong_pos899(X,Y) get_gdat_ullong((X),(Y),899) +#define get_gdat_ip_pos899(X,Y) get_gdat_ip((X),(Y),899) +#define get_gdat_ipv6_pos899(X,Y) get_gdat_ipv6((X),(Y),899) +#define get_gdat_string_pos899(X,Y) get_gdat_string((X),(Y),899) +#define get_gdat_v_str_pos899(X,Y) get_gdat_string((X),(Y),899) +#define get_gdat_bool_pos899(X,Y) get_gdat_bool((X),(Y),899) +#define get_gdat_int_pos899(X,Y) get_gdat_int((X),(Y),899) +#define get_gdat_llong_pos899(X,Y) get_gdat_llong((X),(Y),899) +#define get_gdat_float_pos899(X,Y) get_gdat_float((X),(Y),899) +#define get_gdat_uint_pos900(X,Y) get_gdat_uint((X),(Y),900) +#define get_gdat_ullong_pos900(X,Y) get_gdat_ullong((X),(Y),900) +#define get_gdat_ip_pos900(X,Y) get_gdat_ip((X),(Y),900) +#define get_gdat_ipv6_pos900(X,Y) get_gdat_ipv6((X),(Y),900) +#define get_gdat_string_pos900(X,Y) get_gdat_string((X),(Y),900) +#define get_gdat_v_str_pos900(X,Y) get_gdat_string((X),(Y),900) +#define get_gdat_bool_pos900(X,Y) get_gdat_bool((X),(Y),900) +#define get_gdat_int_pos900(X,Y) get_gdat_int((X),(Y),900) +#define get_gdat_llong_pos900(X,Y) get_gdat_llong((X),(Y),900) +#define get_gdat_float_pos900(X,Y) get_gdat_float((X),(Y),900) +#define get_gdat_uint_pos901(X,Y) get_gdat_uint((X),(Y),901) +#define get_gdat_ullong_pos901(X,Y) get_gdat_ullong((X),(Y),901) +#define get_gdat_ip_pos901(X,Y) get_gdat_ip((X),(Y),901) +#define get_gdat_ipv6_pos901(X,Y) get_gdat_ipv6((X),(Y),901) +#define get_gdat_string_pos901(X,Y) get_gdat_string((X),(Y),901) +#define get_gdat_v_str_pos901(X,Y) get_gdat_string((X),(Y),901) +#define get_gdat_bool_pos901(X,Y) get_gdat_bool((X),(Y),901) +#define get_gdat_int_pos901(X,Y) get_gdat_int((X),(Y),901) +#define get_gdat_llong_pos901(X,Y) get_gdat_llong((X),(Y),901) +#define get_gdat_float_pos901(X,Y) get_gdat_float((X),(Y),901) +#define get_gdat_uint_pos902(X,Y) get_gdat_uint((X),(Y),902) +#define get_gdat_ullong_pos902(X,Y) get_gdat_ullong((X),(Y),902) +#define get_gdat_ip_pos902(X,Y) get_gdat_ip((X),(Y),902) +#define get_gdat_ipv6_pos902(X,Y) get_gdat_ipv6((X),(Y),902) +#define get_gdat_string_pos902(X,Y) get_gdat_string((X),(Y),902) +#define get_gdat_v_str_pos902(X,Y) get_gdat_string((X),(Y),902) +#define get_gdat_bool_pos902(X,Y) get_gdat_bool((X),(Y),902) +#define get_gdat_int_pos902(X,Y) get_gdat_int((X),(Y),902) +#define get_gdat_llong_pos902(X,Y) get_gdat_llong((X),(Y),902) +#define get_gdat_float_pos902(X,Y) get_gdat_float((X),(Y),902) +#define get_gdat_uint_pos903(X,Y) get_gdat_uint((X),(Y),903) +#define get_gdat_ullong_pos903(X,Y) get_gdat_ullong((X),(Y),903) +#define get_gdat_ip_pos903(X,Y) get_gdat_ip((X),(Y),903) +#define get_gdat_ipv6_pos903(X,Y) get_gdat_ipv6((X),(Y),903) +#define get_gdat_string_pos903(X,Y) get_gdat_string((X),(Y),903) +#define get_gdat_v_str_pos903(X,Y) get_gdat_string((X),(Y),903) +#define get_gdat_bool_pos903(X,Y) get_gdat_bool((X),(Y),903) +#define get_gdat_int_pos903(X,Y) get_gdat_int((X),(Y),903) +#define get_gdat_llong_pos903(X,Y) get_gdat_llong((X),(Y),903) +#define get_gdat_float_pos903(X,Y) get_gdat_float((X),(Y),903) +#define get_gdat_uint_pos904(X,Y) get_gdat_uint((X),(Y),904) +#define get_gdat_ullong_pos904(X,Y) get_gdat_ullong((X),(Y),904) +#define get_gdat_ip_pos904(X,Y) get_gdat_ip((X),(Y),904) +#define get_gdat_ipv6_pos904(X,Y) get_gdat_ipv6((X),(Y),904) +#define get_gdat_string_pos904(X,Y) get_gdat_string((X),(Y),904) +#define get_gdat_v_str_pos904(X,Y) get_gdat_string((X),(Y),904) +#define get_gdat_bool_pos904(X,Y) get_gdat_bool((X),(Y),904) +#define get_gdat_int_pos904(X,Y) get_gdat_int((X),(Y),904) +#define get_gdat_llong_pos904(X,Y) get_gdat_llong((X),(Y),904) +#define get_gdat_float_pos904(X,Y) get_gdat_float((X),(Y),904) +#define get_gdat_uint_pos905(X,Y) get_gdat_uint((X),(Y),905) +#define get_gdat_ullong_pos905(X,Y) get_gdat_ullong((X),(Y),905) +#define get_gdat_ip_pos905(X,Y) get_gdat_ip((X),(Y),905) +#define get_gdat_ipv6_pos905(X,Y) get_gdat_ipv6((X),(Y),905) +#define get_gdat_string_pos905(X,Y) get_gdat_string((X),(Y),905) +#define get_gdat_v_str_pos905(X,Y) get_gdat_string((X),(Y),905) +#define get_gdat_bool_pos905(X,Y) get_gdat_bool((X),(Y),905) +#define get_gdat_int_pos905(X,Y) get_gdat_int((X),(Y),905) +#define get_gdat_llong_pos905(X,Y) get_gdat_llong((X),(Y),905) +#define get_gdat_float_pos905(X,Y) get_gdat_float((X),(Y),905) +#define get_gdat_uint_pos906(X,Y) get_gdat_uint((X),(Y),906) +#define get_gdat_ullong_pos906(X,Y) get_gdat_ullong((X),(Y),906) +#define get_gdat_ip_pos906(X,Y) get_gdat_ip((X),(Y),906) +#define get_gdat_ipv6_pos906(X,Y) get_gdat_ipv6((X),(Y),906) +#define get_gdat_string_pos906(X,Y) get_gdat_string((X),(Y),906) +#define get_gdat_v_str_pos906(X,Y) get_gdat_string((X),(Y),906) +#define get_gdat_bool_pos906(X,Y) get_gdat_bool((X),(Y),906) +#define get_gdat_int_pos906(X,Y) get_gdat_int((X),(Y),906) +#define get_gdat_llong_pos906(X,Y) get_gdat_llong((X),(Y),906) +#define get_gdat_float_pos906(X,Y) get_gdat_float((X),(Y),906) +#define get_gdat_uint_pos907(X,Y) get_gdat_uint((X),(Y),907) +#define get_gdat_ullong_pos907(X,Y) get_gdat_ullong((X),(Y),907) +#define get_gdat_ip_pos907(X,Y) get_gdat_ip((X),(Y),907) +#define get_gdat_ipv6_pos907(X,Y) get_gdat_ipv6((X),(Y),907) +#define get_gdat_string_pos907(X,Y) get_gdat_string((X),(Y),907) +#define get_gdat_v_str_pos907(X,Y) get_gdat_string((X),(Y),907) +#define get_gdat_bool_pos907(X,Y) get_gdat_bool((X),(Y),907) +#define get_gdat_int_pos907(X,Y) get_gdat_int((X),(Y),907) +#define get_gdat_llong_pos907(X,Y) get_gdat_llong((X),(Y),907) +#define get_gdat_float_pos907(X,Y) get_gdat_float((X),(Y),907) +#define get_gdat_uint_pos908(X,Y) get_gdat_uint((X),(Y),908) +#define get_gdat_ullong_pos908(X,Y) get_gdat_ullong((X),(Y),908) +#define get_gdat_ip_pos908(X,Y) get_gdat_ip((X),(Y),908) +#define get_gdat_ipv6_pos908(X,Y) get_gdat_ipv6((X),(Y),908) +#define get_gdat_string_pos908(X,Y) get_gdat_string((X),(Y),908) +#define get_gdat_v_str_pos908(X,Y) get_gdat_string((X),(Y),908) +#define get_gdat_bool_pos908(X,Y) get_gdat_bool((X),(Y),908) +#define get_gdat_int_pos908(X,Y) get_gdat_int((X),(Y),908) +#define get_gdat_llong_pos908(X,Y) get_gdat_llong((X),(Y),908) +#define get_gdat_float_pos908(X,Y) get_gdat_float((X),(Y),908) +#define get_gdat_uint_pos909(X,Y) get_gdat_uint((X),(Y),909) +#define get_gdat_ullong_pos909(X,Y) get_gdat_ullong((X),(Y),909) +#define get_gdat_ip_pos909(X,Y) get_gdat_ip((X),(Y),909) +#define get_gdat_ipv6_pos909(X,Y) get_gdat_ipv6((X),(Y),909) +#define get_gdat_string_pos909(X,Y) get_gdat_string((X),(Y),909) +#define get_gdat_v_str_pos909(X,Y) get_gdat_string((X),(Y),909) +#define get_gdat_bool_pos909(X,Y) get_gdat_bool((X),(Y),909) +#define get_gdat_int_pos909(X,Y) get_gdat_int((X),(Y),909) +#define get_gdat_llong_pos909(X,Y) get_gdat_llong((X),(Y),909) +#define get_gdat_float_pos909(X,Y) get_gdat_float((X),(Y),909) +#define get_gdat_uint_pos910(X,Y) get_gdat_uint((X),(Y),910) +#define get_gdat_ullong_pos910(X,Y) get_gdat_ullong((X),(Y),910) +#define get_gdat_ip_pos910(X,Y) get_gdat_ip((X),(Y),910) +#define get_gdat_ipv6_pos910(X,Y) get_gdat_ipv6((X),(Y),910) +#define get_gdat_string_pos910(X,Y) get_gdat_string((X),(Y),910) +#define get_gdat_v_str_pos910(X,Y) get_gdat_string((X),(Y),910) +#define get_gdat_bool_pos910(X,Y) get_gdat_bool((X),(Y),910) +#define get_gdat_int_pos910(X,Y) get_gdat_int((X),(Y),910) +#define get_gdat_llong_pos910(X,Y) get_gdat_llong((X),(Y),910) +#define get_gdat_float_pos910(X,Y) get_gdat_float((X),(Y),910) +#define get_gdat_uint_pos911(X,Y) get_gdat_uint((X),(Y),911) +#define get_gdat_ullong_pos911(X,Y) get_gdat_ullong((X),(Y),911) +#define get_gdat_ip_pos911(X,Y) get_gdat_ip((X),(Y),911) +#define get_gdat_ipv6_pos911(X,Y) get_gdat_ipv6((X),(Y),911) +#define get_gdat_string_pos911(X,Y) get_gdat_string((X),(Y),911) +#define get_gdat_v_str_pos911(X,Y) get_gdat_string((X),(Y),911) +#define get_gdat_bool_pos911(X,Y) get_gdat_bool((X),(Y),911) +#define get_gdat_int_pos911(X,Y) get_gdat_int((X),(Y),911) +#define get_gdat_llong_pos911(X,Y) get_gdat_llong((X),(Y),911) +#define get_gdat_float_pos911(X,Y) get_gdat_float((X),(Y),911) +#define get_gdat_uint_pos912(X,Y) get_gdat_uint((X),(Y),912) +#define get_gdat_ullong_pos912(X,Y) get_gdat_ullong((X),(Y),912) +#define get_gdat_ip_pos912(X,Y) get_gdat_ip((X),(Y),912) +#define get_gdat_ipv6_pos912(X,Y) get_gdat_ipv6((X),(Y),912) +#define get_gdat_string_pos912(X,Y) get_gdat_string((X),(Y),912) +#define get_gdat_v_str_pos912(X,Y) get_gdat_string((X),(Y),912) +#define get_gdat_bool_pos912(X,Y) get_gdat_bool((X),(Y),912) +#define get_gdat_int_pos912(X,Y) get_gdat_int((X),(Y),912) +#define get_gdat_llong_pos912(X,Y) get_gdat_llong((X),(Y),912) +#define get_gdat_float_pos912(X,Y) get_gdat_float((X),(Y),912) +#define get_gdat_uint_pos913(X,Y) get_gdat_uint((X),(Y),913) +#define get_gdat_ullong_pos913(X,Y) get_gdat_ullong((X),(Y),913) +#define get_gdat_ip_pos913(X,Y) get_gdat_ip((X),(Y),913) +#define get_gdat_ipv6_pos913(X,Y) get_gdat_ipv6((X),(Y),913) +#define get_gdat_string_pos913(X,Y) get_gdat_string((X),(Y),913) +#define get_gdat_v_str_pos913(X,Y) get_gdat_string((X),(Y),913) +#define get_gdat_bool_pos913(X,Y) get_gdat_bool((X),(Y),913) +#define get_gdat_int_pos913(X,Y) get_gdat_int((X),(Y),913) +#define get_gdat_llong_pos913(X,Y) get_gdat_llong((X),(Y),913) +#define get_gdat_float_pos913(X,Y) get_gdat_float((X),(Y),913) +#define get_gdat_uint_pos914(X,Y) get_gdat_uint((X),(Y),914) +#define get_gdat_ullong_pos914(X,Y) get_gdat_ullong((X),(Y),914) +#define get_gdat_ip_pos914(X,Y) get_gdat_ip((X),(Y),914) +#define get_gdat_ipv6_pos914(X,Y) get_gdat_ipv6((X),(Y),914) +#define get_gdat_string_pos914(X,Y) get_gdat_string((X),(Y),914) +#define get_gdat_v_str_pos914(X,Y) get_gdat_string((X),(Y),914) +#define get_gdat_bool_pos914(X,Y) get_gdat_bool((X),(Y),914) +#define get_gdat_int_pos914(X,Y) get_gdat_int((X),(Y),914) +#define get_gdat_llong_pos914(X,Y) get_gdat_llong((X),(Y),914) +#define get_gdat_float_pos914(X,Y) get_gdat_float((X),(Y),914) +#define get_gdat_uint_pos915(X,Y) get_gdat_uint((X),(Y),915) +#define get_gdat_ullong_pos915(X,Y) get_gdat_ullong((X),(Y),915) +#define get_gdat_ip_pos915(X,Y) get_gdat_ip((X),(Y),915) +#define get_gdat_ipv6_pos915(X,Y) get_gdat_ipv6((X),(Y),915) +#define get_gdat_string_pos915(X,Y) get_gdat_string((X),(Y),915) +#define get_gdat_v_str_pos915(X,Y) get_gdat_string((X),(Y),915) +#define get_gdat_bool_pos915(X,Y) get_gdat_bool((X),(Y),915) +#define get_gdat_int_pos915(X,Y) get_gdat_int((X),(Y),915) +#define get_gdat_llong_pos915(X,Y) get_gdat_llong((X),(Y),915) +#define get_gdat_float_pos915(X,Y) get_gdat_float((X),(Y),915) +#define get_gdat_uint_pos916(X,Y) get_gdat_uint((X),(Y),916) +#define get_gdat_ullong_pos916(X,Y) get_gdat_ullong((X),(Y),916) +#define get_gdat_ip_pos916(X,Y) get_gdat_ip((X),(Y),916) +#define get_gdat_ipv6_pos916(X,Y) get_gdat_ipv6((X),(Y),916) +#define get_gdat_string_pos916(X,Y) get_gdat_string((X),(Y),916) +#define get_gdat_v_str_pos916(X,Y) get_gdat_string((X),(Y),916) +#define get_gdat_bool_pos916(X,Y) get_gdat_bool((X),(Y),916) +#define get_gdat_int_pos916(X,Y) get_gdat_int((X),(Y),916) +#define get_gdat_llong_pos916(X,Y) get_gdat_llong((X),(Y),916) +#define get_gdat_float_pos916(X,Y) get_gdat_float((X),(Y),916) +#define get_gdat_uint_pos917(X,Y) get_gdat_uint((X),(Y),917) +#define get_gdat_ullong_pos917(X,Y) get_gdat_ullong((X),(Y),917) +#define get_gdat_ip_pos917(X,Y) get_gdat_ip((X),(Y),917) +#define get_gdat_ipv6_pos917(X,Y) get_gdat_ipv6((X),(Y),917) +#define get_gdat_string_pos917(X,Y) get_gdat_string((X),(Y),917) +#define get_gdat_v_str_pos917(X,Y) get_gdat_string((X),(Y),917) +#define get_gdat_bool_pos917(X,Y) get_gdat_bool((X),(Y),917) +#define get_gdat_int_pos917(X,Y) get_gdat_int((X),(Y),917) +#define get_gdat_llong_pos917(X,Y) get_gdat_llong((X),(Y),917) +#define get_gdat_float_pos917(X,Y) get_gdat_float((X),(Y),917) +#define get_gdat_uint_pos918(X,Y) get_gdat_uint((X),(Y),918) +#define get_gdat_ullong_pos918(X,Y) get_gdat_ullong((X),(Y),918) +#define get_gdat_ip_pos918(X,Y) get_gdat_ip((X),(Y),918) +#define get_gdat_ipv6_pos918(X,Y) get_gdat_ipv6((X),(Y),918) +#define get_gdat_string_pos918(X,Y) get_gdat_string((X),(Y),918) +#define get_gdat_v_str_pos918(X,Y) get_gdat_string((X),(Y),918) +#define get_gdat_bool_pos918(X,Y) get_gdat_bool((X),(Y),918) +#define get_gdat_int_pos918(X,Y) get_gdat_int((X),(Y),918) +#define get_gdat_llong_pos918(X,Y) get_gdat_llong((X),(Y),918) +#define get_gdat_float_pos918(X,Y) get_gdat_float((X),(Y),918) +#define get_gdat_uint_pos919(X,Y) get_gdat_uint((X),(Y),919) +#define get_gdat_ullong_pos919(X,Y) get_gdat_ullong((X),(Y),919) +#define get_gdat_ip_pos919(X,Y) get_gdat_ip((X),(Y),919) +#define get_gdat_ipv6_pos919(X,Y) get_gdat_ipv6((X),(Y),919) +#define get_gdat_string_pos919(X,Y) get_gdat_string((X),(Y),919) +#define get_gdat_v_str_pos919(X,Y) get_gdat_string((X),(Y),919) +#define get_gdat_bool_pos919(X,Y) get_gdat_bool((X),(Y),919) +#define get_gdat_int_pos919(X,Y) get_gdat_int((X),(Y),919) +#define get_gdat_llong_pos919(X,Y) get_gdat_llong((X),(Y),919) +#define get_gdat_float_pos919(X,Y) get_gdat_float((X),(Y),919) +#define get_gdat_uint_pos920(X,Y) get_gdat_uint((X),(Y),920) +#define get_gdat_ullong_pos920(X,Y) get_gdat_ullong((X),(Y),920) +#define get_gdat_ip_pos920(X,Y) get_gdat_ip((X),(Y),920) +#define get_gdat_ipv6_pos920(X,Y) get_gdat_ipv6((X),(Y),920) +#define get_gdat_string_pos920(X,Y) get_gdat_string((X),(Y),920) +#define get_gdat_v_str_pos920(X,Y) get_gdat_string((X),(Y),920) +#define get_gdat_bool_pos920(X,Y) get_gdat_bool((X),(Y),920) +#define get_gdat_int_pos920(X,Y) get_gdat_int((X),(Y),920) +#define get_gdat_llong_pos920(X,Y) get_gdat_llong((X),(Y),920) +#define get_gdat_float_pos920(X,Y) get_gdat_float((X),(Y),920) +#define get_gdat_uint_pos921(X,Y) get_gdat_uint((X),(Y),921) +#define get_gdat_ullong_pos921(X,Y) get_gdat_ullong((X),(Y),921) +#define get_gdat_ip_pos921(X,Y) get_gdat_ip((X),(Y),921) +#define get_gdat_ipv6_pos921(X,Y) get_gdat_ipv6((X),(Y),921) +#define get_gdat_string_pos921(X,Y) get_gdat_string((X),(Y),921) +#define get_gdat_v_str_pos921(X,Y) get_gdat_string((X),(Y),921) +#define get_gdat_bool_pos921(X,Y) get_gdat_bool((X),(Y),921) +#define get_gdat_int_pos921(X,Y) get_gdat_int((X),(Y),921) +#define get_gdat_llong_pos921(X,Y) get_gdat_llong((X),(Y),921) +#define get_gdat_float_pos921(X,Y) get_gdat_float((X),(Y),921) +#define get_gdat_uint_pos922(X,Y) get_gdat_uint((X),(Y),922) +#define get_gdat_ullong_pos922(X,Y) get_gdat_ullong((X),(Y),922) +#define get_gdat_ip_pos922(X,Y) get_gdat_ip((X),(Y),922) +#define get_gdat_ipv6_pos922(X,Y) get_gdat_ipv6((X),(Y),922) +#define get_gdat_string_pos922(X,Y) get_gdat_string((X),(Y),922) +#define get_gdat_v_str_pos922(X,Y) get_gdat_string((X),(Y),922) +#define get_gdat_bool_pos922(X,Y) get_gdat_bool((X),(Y),922) +#define get_gdat_int_pos922(X,Y) get_gdat_int((X),(Y),922) +#define get_gdat_llong_pos922(X,Y) get_gdat_llong((X),(Y),922) +#define get_gdat_float_pos922(X,Y) get_gdat_float((X),(Y),922) +#define get_gdat_uint_pos923(X,Y) get_gdat_uint((X),(Y),923) +#define get_gdat_ullong_pos923(X,Y) get_gdat_ullong((X),(Y),923) +#define get_gdat_ip_pos923(X,Y) get_gdat_ip((X),(Y),923) +#define get_gdat_ipv6_pos923(X,Y) get_gdat_ipv6((X),(Y),923) +#define get_gdat_string_pos923(X,Y) get_gdat_string((X),(Y),923) +#define get_gdat_v_str_pos923(X,Y) get_gdat_string((X),(Y),923) +#define get_gdat_bool_pos923(X,Y) get_gdat_bool((X),(Y),923) +#define get_gdat_int_pos923(X,Y) get_gdat_int((X),(Y),923) +#define get_gdat_llong_pos923(X,Y) get_gdat_llong((X),(Y),923) +#define get_gdat_float_pos923(X,Y) get_gdat_float((X),(Y),923) +#define get_gdat_uint_pos924(X,Y) get_gdat_uint((X),(Y),924) +#define get_gdat_ullong_pos924(X,Y) get_gdat_ullong((X),(Y),924) +#define get_gdat_ip_pos924(X,Y) get_gdat_ip((X),(Y),924) +#define get_gdat_ipv6_pos924(X,Y) get_gdat_ipv6((X),(Y),924) +#define get_gdat_string_pos924(X,Y) get_gdat_string((X),(Y),924) +#define get_gdat_v_str_pos924(X,Y) get_gdat_string((X),(Y),924) +#define get_gdat_bool_pos924(X,Y) get_gdat_bool((X),(Y),924) +#define get_gdat_int_pos924(X,Y) get_gdat_int((X),(Y),924) +#define get_gdat_llong_pos924(X,Y) get_gdat_llong((X),(Y),924) +#define get_gdat_float_pos924(X,Y) get_gdat_float((X),(Y),924) +#define get_gdat_uint_pos925(X,Y) get_gdat_uint((X),(Y),925) +#define get_gdat_ullong_pos925(X,Y) get_gdat_ullong((X),(Y),925) +#define get_gdat_ip_pos925(X,Y) get_gdat_ip((X),(Y),925) +#define get_gdat_ipv6_pos925(X,Y) get_gdat_ipv6((X),(Y),925) +#define get_gdat_string_pos925(X,Y) get_gdat_string((X),(Y),925) +#define get_gdat_v_str_pos925(X,Y) get_gdat_string((X),(Y),925) +#define get_gdat_bool_pos925(X,Y) get_gdat_bool((X),(Y),925) +#define get_gdat_int_pos925(X,Y) get_gdat_int((X),(Y),925) +#define get_gdat_llong_pos925(X,Y) get_gdat_llong((X),(Y),925) +#define get_gdat_float_pos925(X,Y) get_gdat_float((X),(Y),925) +#define get_gdat_uint_pos926(X,Y) get_gdat_uint((X),(Y),926) +#define get_gdat_ullong_pos926(X,Y) get_gdat_ullong((X),(Y),926) +#define get_gdat_ip_pos926(X,Y) get_gdat_ip((X),(Y),926) +#define get_gdat_ipv6_pos926(X,Y) get_gdat_ipv6((X),(Y),926) +#define get_gdat_string_pos926(X,Y) get_gdat_string((X),(Y),926) +#define get_gdat_v_str_pos926(X,Y) get_gdat_string((X),(Y),926) +#define get_gdat_bool_pos926(X,Y) get_gdat_bool((X),(Y),926) +#define get_gdat_int_pos926(X,Y) get_gdat_int((X),(Y),926) +#define get_gdat_llong_pos926(X,Y) get_gdat_llong((X),(Y),926) +#define get_gdat_float_pos926(X,Y) get_gdat_float((X),(Y),926) +#define get_gdat_uint_pos927(X,Y) get_gdat_uint((X),(Y),927) +#define get_gdat_ullong_pos927(X,Y) get_gdat_ullong((X),(Y),927) +#define get_gdat_ip_pos927(X,Y) get_gdat_ip((X),(Y),927) +#define get_gdat_ipv6_pos927(X,Y) get_gdat_ipv6((X),(Y),927) +#define get_gdat_string_pos927(X,Y) get_gdat_string((X),(Y),927) +#define get_gdat_v_str_pos927(X,Y) get_gdat_string((X),(Y),927) +#define get_gdat_bool_pos927(X,Y) get_gdat_bool((X),(Y),927) +#define get_gdat_int_pos927(X,Y) get_gdat_int((X),(Y),927) +#define get_gdat_llong_pos927(X,Y) get_gdat_llong((X),(Y),927) +#define get_gdat_float_pos927(X,Y) get_gdat_float((X),(Y),927) +#define get_gdat_uint_pos928(X,Y) get_gdat_uint((X),(Y),928) +#define get_gdat_ullong_pos928(X,Y) get_gdat_ullong((X),(Y),928) +#define get_gdat_ip_pos928(X,Y) get_gdat_ip((X),(Y),928) +#define get_gdat_ipv6_pos928(X,Y) get_gdat_ipv6((X),(Y),928) +#define get_gdat_string_pos928(X,Y) get_gdat_string((X),(Y),928) +#define get_gdat_v_str_pos928(X,Y) get_gdat_string((X),(Y),928) +#define get_gdat_bool_pos928(X,Y) get_gdat_bool((X),(Y),928) +#define get_gdat_int_pos928(X,Y) get_gdat_int((X),(Y),928) +#define get_gdat_llong_pos928(X,Y) get_gdat_llong((X),(Y),928) +#define get_gdat_float_pos928(X,Y) get_gdat_float((X),(Y),928) +#define get_gdat_uint_pos929(X,Y) get_gdat_uint((X),(Y),929) +#define get_gdat_ullong_pos929(X,Y) get_gdat_ullong((X),(Y),929) +#define get_gdat_ip_pos929(X,Y) get_gdat_ip((X),(Y),929) +#define get_gdat_ipv6_pos929(X,Y) get_gdat_ipv6((X),(Y),929) +#define get_gdat_string_pos929(X,Y) get_gdat_string((X),(Y),929) +#define get_gdat_v_str_pos929(X,Y) get_gdat_string((X),(Y),929) +#define get_gdat_bool_pos929(X,Y) get_gdat_bool((X),(Y),929) +#define get_gdat_int_pos929(X,Y) get_gdat_int((X),(Y),929) +#define get_gdat_llong_pos929(X,Y) get_gdat_llong((X),(Y),929) +#define get_gdat_float_pos929(X,Y) get_gdat_float((X),(Y),929) +#define get_gdat_uint_pos930(X,Y) get_gdat_uint((X),(Y),930) +#define get_gdat_ullong_pos930(X,Y) get_gdat_ullong((X),(Y),930) +#define get_gdat_ip_pos930(X,Y) get_gdat_ip((X),(Y),930) +#define get_gdat_ipv6_pos930(X,Y) get_gdat_ipv6((X),(Y),930) +#define get_gdat_string_pos930(X,Y) get_gdat_string((X),(Y),930) +#define get_gdat_v_str_pos930(X,Y) get_gdat_string((X),(Y),930) +#define get_gdat_bool_pos930(X,Y) get_gdat_bool((X),(Y),930) +#define get_gdat_int_pos930(X,Y) get_gdat_int((X),(Y),930) +#define get_gdat_llong_pos930(X,Y) get_gdat_llong((X),(Y),930) +#define get_gdat_float_pos930(X,Y) get_gdat_float((X),(Y),930) +#define get_gdat_uint_pos931(X,Y) get_gdat_uint((X),(Y),931) +#define get_gdat_ullong_pos931(X,Y) get_gdat_ullong((X),(Y),931) +#define get_gdat_ip_pos931(X,Y) get_gdat_ip((X),(Y),931) +#define get_gdat_ipv6_pos931(X,Y) get_gdat_ipv6((X),(Y),931) +#define get_gdat_string_pos931(X,Y) get_gdat_string((X),(Y),931) +#define get_gdat_v_str_pos931(X,Y) get_gdat_string((X),(Y),931) +#define get_gdat_bool_pos931(X,Y) get_gdat_bool((X),(Y),931) +#define get_gdat_int_pos931(X,Y) get_gdat_int((X),(Y),931) +#define get_gdat_llong_pos931(X,Y) get_gdat_llong((X),(Y),931) +#define get_gdat_float_pos931(X,Y) get_gdat_float((X),(Y),931) +#define get_gdat_uint_pos932(X,Y) get_gdat_uint((X),(Y),932) +#define get_gdat_ullong_pos932(X,Y) get_gdat_ullong((X),(Y),932) +#define get_gdat_ip_pos932(X,Y) get_gdat_ip((X),(Y),932) +#define get_gdat_ipv6_pos932(X,Y) get_gdat_ipv6((X),(Y),932) +#define get_gdat_string_pos932(X,Y) get_gdat_string((X),(Y),932) +#define get_gdat_v_str_pos932(X,Y) get_gdat_string((X),(Y),932) +#define get_gdat_bool_pos932(X,Y) get_gdat_bool((X),(Y),932) +#define get_gdat_int_pos932(X,Y) get_gdat_int((X),(Y),932) +#define get_gdat_llong_pos932(X,Y) get_gdat_llong((X),(Y),932) +#define get_gdat_float_pos932(X,Y) get_gdat_float((X),(Y),932) +#define get_gdat_uint_pos933(X,Y) get_gdat_uint((X),(Y),933) +#define get_gdat_ullong_pos933(X,Y) get_gdat_ullong((X),(Y),933) +#define get_gdat_ip_pos933(X,Y) get_gdat_ip((X),(Y),933) +#define get_gdat_ipv6_pos933(X,Y) get_gdat_ipv6((X),(Y),933) +#define get_gdat_string_pos933(X,Y) get_gdat_string((X),(Y),933) +#define get_gdat_v_str_pos933(X,Y) get_gdat_string((X),(Y),933) +#define get_gdat_bool_pos933(X,Y) get_gdat_bool((X),(Y),933) +#define get_gdat_int_pos933(X,Y) get_gdat_int((X),(Y),933) +#define get_gdat_llong_pos933(X,Y) get_gdat_llong((X),(Y),933) +#define get_gdat_float_pos933(X,Y) get_gdat_float((X),(Y),933) +#define get_gdat_uint_pos934(X,Y) get_gdat_uint((X),(Y),934) +#define get_gdat_ullong_pos934(X,Y) get_gdat_ullong((X),(Y),934) +#define get_gdat_ip_pos934(X,Y) get_gdat_ip((X),(Y),934) +#define get_gdat_ipv6_pos934(X,Y) get_gdat_ipv6((X),(Y),934) +#define get_gdat_string_pos934(X,Y) get_gdat_string((X),(Y),934) +#define get_gdat_v_str_pos934(X,Y) get_gdat_string((X),(Y),934) +#define get_gdat_bool_pos934(X,Y) get_gdat_bool((X),(Y),934) +#define get_gdat_int_pos934(X,Y) get_gdat_int((X),(Y),934) +#define get_gdat_llong_pos934(X,Y) get_gdat_llong((X),(Y),934) +#define get_gdat_float_pos934(X,Y) get_gdat_float((X),(Y),934) +#define get_gdat_uint_pos935(X,Y) get_gdat_uint((X),(Y),935) +#define get_gdat_ullong_pos935(X,Y) get_gdat_ullong((X),(Y),935) +#define get_gdat_ip_pos935(X,Y) get_gdat_ip((X),(Y),935) +#define get_gdat_ipv6_pos935(X,Y) get_gdat_ipv6((X),(Y),935) +#define get_gdat_string_pos935(X,Y) get_gdat_string((X),(Y),935) +#define get_gdat_v_str_pos935(X,Y) get_gdat_string((X),(Y),935) +#define get_gdat_bool_pos935(X,Y) get_gdat_bool((X),(Y),935) +#define get_gdat_int_pos935(X,Y) get_gdat_int((X),(Y),935) +#define get_gdat_llong_pos935(X,Y) get_gdat_llong((X),(Y),935) +#define get_gdat_float_pos935(X,Y) get_gdat_float((X),(Y),935) +#define get_gdat_uint_pos936(X,Y) get_gdat_uint((X),(Y),936) +#define get_gdat_ullong_pos936(X,Y) get_gdat_ullong((X),(Y),936) +#define get_gdat_ip_pos936(X,Y) get_gdat_ip((X),(Y),936) +#define get_gdat_ipv6_pos936(X,Y) get_gdat_ipv6((X),(Y),936) +#define get_gdat_string_pos936(X,Y) get_gdat_string((X),(Y),936) +#define get_gdat_v_str_pos936(X,Y) get_gdat_string((X),(Y),936) +#define get_gdat_bool_pos936(X,Y) get_gdat_bool((X),(Y),936) +#define get_gdat_int_pos936(X,Y) get_gdat_int((X),(Y),936) +#define get_gdat_llong_pos936(X,Y) get_gdat_llong((X),(Y),936) +#define get_gdat_float_pos936(X,Y) get_gdat_float((X),(Y),936) +#define get_gdat_uint_pos937(X,Y) get_gdat_uint((X),(Y),937) +#define get_gdat_ullong_pos937(X,Y) get_gdat_ullong((X),(Y),937) +#define get_gdat_ip_pos937(X,Y) get_gdat_ip((X),(Y),937) +#define get_gdat_ipv6_pos937(X,Y) get_gdat_ipv6((X),(Y),937) +#define get_gdat_string_pos937(X,Y) get_gdat_string((X),(Y),937) +#define get_gdat_v_str_pos937(X,Y) get_gdat_string((X),(Y),937) +#define get_gdat_bool_pos937(X,Y) get_gdat_bool((X),(Y),937) +#define get_gdat_int_pos937(X,Y) get_gdat_int((X),(Y),937) +#define get_gdat_llong_pos937(X,Y) get_gdat_llong((X),(Y),937) +#define get_gdat_float_pos937(X,Y) get_gdat_float((X),(Y),937) +#define get_gdat_uint_pos938(X,Y) get_gdat_uint((X),(Y),938) +#define get_gdat_ullong_pos938(X,Y) get_gdat_ullong((X),(Y),938) +#define get_gdat_ip_pos938(X,Y) get_gdat_ip((X),(Y),938) +#define get_gdat_ipv6_pos938(X,Y) get_gdat_ipv6((X),(Y),938) +#define get_gdat_string_pos938(X,Y) get_gdat_string((X),(Y),938) +#define get_gdat_v_str_pos938(X,Y) get_gdat_string((X),(Y),938) +#define get_gdat_bool_pos938(X,Y) get_gdat_bool((X),(Y),938) +#define get_gdat_int_pos938(X,Y) get_gdat_int((X),(Y),938) +#define get_gdat_llong_pos938(X,Y) get_gdat_llong((X),(Y),938) +#define get_gdat_float_pos938(X,Y) get_gdat_float((X),(Y),938) +#define get_gdat_uint_pos939(X,Y) get_gdat_uint((X),(Y),939) +#define get_gdat_ullong_pos939(X,Y) get_gdat_ullong((X),(Y),939) +#define get_gdat_ip_pos939(X,Y) get_gdat_ip((X),(Y),939) +#define get_gdat_ipv6_pos939(X,Y) get_gdat_ipv6((X),(Y),939) +#define get_gdat_string_pos939(X,Y) get_gdat_string((X),(Y),939) +#define get_gdat_v_str_pos939(X,Y) get_gdat_string((X),(Y),939) +#define get_gdat_bool_pos939(X,Y) get_gdat_bool((X),(Y),939) +#define get_gdat_int_pos939(X,Y) get_gdat_int((X),(Y),939) +#define get_gdat_llong_pos939(X,Y) get_gdat_llong((X),(Y),939) +#define get_gdat_float_pos939(X,Y) get_gdat_float((X),(Y),939) +#define get_gdat_uint_pos940(X,Y) get_gdat_uint((X),(Y),940) +#define get_gdat_ullong_pos940(X,Y) get_gdat_ullong((X),(Y),940) +#define get_gdat_ip_pos940(X,Y) get_gdat_ip((X),(Y),940) +#define get_gdat_ipv6_pos940(X,Y) get_gdat_ipv6((X),(Y),940) +#define get_gdat_string_pos940(X,Y) get_gdat_string((X),(Y),940) +#define get_gdat_v_str_pos940(X,Y) get_gdat_string((X),(Y),940) +#define get_gdat_bool_pos940(X,Y) get_gdat_bool((X),(Y),940) +#define get_gdat_int_pos940(X,Y) get_gdat_int((X),(Y),940) +#define get_gdat_llong_pos940(X,Y) get_gdat_llong((X),(Y),940) +#define get_gdat_float_pos940(X,Y) get_gdat_float((X),(Y),940) +#define get_gdat_uint_pos941(X,Y) get_gdat_uint((X),(Y),941) +#define get_gdat_ullong_pos941(X,Y) get_gdat_ullong((X),(Y),941) +#define get_gdat_ip_pos941(X,Y) get_gdat_ip((X),(Y),941) +#define get_gdat_ipv6_pos941(X,Y) get_gdat_ipv6((X),(Y),941) +#define get_gdat_string_pos941(X,Y) get_gdat_string((X),(Y),941) +#define get_gdat_v_str_pos941(X,Y) get_gdat_string((X),(Y),941) +#define get_gdat_bool_pos941(X,Y) get_gdat_bool((X),(Y),941) +#define get_gdat_int_pos941(X,Y) get_gdat_int((X),(Y),941) +#define get_gdat_llong_pos941(X,Y) get_gdat_llong((X),(Y),941) +#define get_gdat_float_pos941(X,Y) get_gdat_float((X),(Y),941) +#define get_gdat_uint_pos942(X,Y) get_gdat_uint((X),(Y),942) +#define get_gdat_ullong_pos942(X,Y) get_gdat_ullong((X),(Y),942) +#define get_gdat_ip_pos942(X,Y) get_gdat_ip((X),(Y),942) +#define get_gdat_ipv6_pos942(X,Y) get_gdat_ipv6((X),(Y),942) +#define get_gdat_string_pos942(X,Y) get_gdat_string((X),(Y),942) +#define get_gdat_v_str_pos942(X,Y) get_gdat_string((X),(Y),942) +#define get_gdat_bool_pos942(X,Y) get_gdat_bool((X),(Y),942) +#define get_gdat_int_pos942(X,Y) get_gdat_int((X),(Y),942) +#define get_gdat_llong_pos942(X,Y) get_gdat_llong((X),(Y),942) +#define get_gdat_float_pos942(X,Y) get_gdat_float((X),(Y),942) +#define get_gdat_uint_pos943(X,Y) get_gdat_uint((X),(Y),943) +#define get_gdat_ullong_pos943(X,Y) get_gdat_ullong((X),(Y),943) +#define get_gdat_ip_pos943(X,Y) get_gdat_ip((X),(Y),943) +#define get_gdat_ipv6_pos943(X,Y) get_gdat_ipv6((X),(Y),943) +#define get_gdat_string_pos943(X,Y) get_gdat_string((X),(Y),943) +#define get_gdat_v_str_pos943(X,Y) get_gdat_string((X),(Y),943) +#define get_gdat_bool_pos943(X,Y) get_gdat_bool((X),(Y),943) +#define get_gdat_int_pos943(X,Y) get_gdat_int((X),(Y),943) +#define get_gdat_llong_pos943(X,Y) get_gdat_llong((X),(Y),943) +#define get_gdat_float_pos943(X,Y) get_gdat_float((X),(Y),943) +#define get_gdat_uint_pos944(X,Y) get_gdat_uint((X),(Y),944) +#define get_gdat_ullong_pos944(X,Y) get_gdat_ullong((X),(Y),944) +#define get_gdat_ip_pos944(X,Y) get_gdat_ip((X),(Y),944) +#define get_gdat_ipv6_pos944(X,Y) get_gdat_ipv6((X),(Y),944) +#define get_gdat_string_pos944(X,Y) get_gdat_string((X),(Y),944) +#define get_gdat_v_str_pos944(X,Y) get_gdat_string((X),(Y),944) +#define get_gdat_bool_pos944(X,Y) get_gdat_bool((X),(Y),944) +#define get_gdat_int_pos944(X,Y) get_gdat_int((X),(Y),944) +#define get_gdat_llong_pos944(X,Y) get_gdat_llong((X),(Y),944) +#define get_gdat_float_pos944(X,Y) get_gdat_float((X),(Y),944) +#define get_gdat_uint_pos945(X,Y) get_gdat_uint((X),(Y),945) +#define get_gdat_ullong_pos945(X,Y) get_gdat_ullong((X),(Y),945) +#define get_gdat_ip_pos945(X,Y) get_gdat_ip((X),(Y),945) +#define get_gdat_ipv6_pos945(X,Y) get_gdat_ipv6((X),(Y),945) +#define get_gdat_string_pos945(X,Y) get_gdat_string((X),(Y),945) +#define get_gdat_v_str_pos945(X,Y) get_gdat_string((X),(Y),945) +#define get_gdat_bool_pos945(X,Y) get_gdat_bool((X),(Y),945) +#define get_gdat_int_pos945(X,Y) get_gdat_int((X),(Y),945) +#define get_gdat_llong_pos945(X,Y) get_gdat_llong((X),(Y),945) +#define get_gdat_float_pos945(X,Y) get_gdat_float((X),(Y),945) +#define get_gdat_uint_pos946(X,Y) get_gdat_uint((X),(Y),946) +#define get_gdat_ullong_pos946(X,Y) get_gdat_ullong((X),(Y),946) +#define get_gdat_ip_pos946(X,Y) get_gdat_ip((X),(Y),946) +#define get_gdat_ipv6_pos946(X,Y) get_gdat_ipv6((X),(Y),946) +#define get_gdat_string_pos946(X,Y) get_gdat_string((X),(Y),946) +#define get_gdat_v_str_pos946(X,Y) get_gdat_string((X),(Y),946) +#define get_gdat_bool_pos946(X,Y) get_gdat_bool((X),(Y),946) +#define get_gdat_int_pos946(X,Y) get_gdat_int((X),(Y),946) +#define get_gdat_llong_pos946(X,Y) get_gdat_llong((X),(Y),946) +#define get_gdat_float_pos946(X,Y) get_gdat_float((X),(Y),946) +#define get_gdat_uint_pos947(X,Y) get_gdat_uint((X),(Y),947) +#define get_gdat_ullong_pos947(X,Y) get_gdat_ullong((X),(Y),947) +#define get_gdat_ip_pos947(X,Y) get_gdat_ip((X),(Y),947) +#define get_gdat_ipv6_pos947(X,Y) get_gdat_ipv6((X),(Y),947) +#define get_gdat_string_pos947(X,Y) get_gdat_string((X),(Y),947) +#define get_gdat_v_str_pos947(X,Y) get_gdat_string((X),(Y),947) +#define get_gdat_bool_pos947(X,Y) get_gdat_bool((X),(Y),947) +#define get_gdat_int_pos947(X,Y) get_gdat_int((X),(Y),947) +#define get_gdat_llong_pos947(X,Y) get_gdat_llong((X),(Y),947) +#define get_gdat_float_pos947(X,Y) get_gdat_float((X),(Y),947) +#define get_gdat_uint_pos948(X,Y) get_gdat_uint((X),(Y),948) +#define get_gdat_ullong_pos948(X,Y) get_gdat_ullong((X),(Y),948) +#define get_gdat_ip_pos948(X,Y) get_gdat_ip((X),(Y),948) +#define get_gdat_ipv6_pos948(X,Y) get_gdat_ipv6((X),(Y),948) +#define get_gdat_string_pos948(X,Y) get_gdat_string((X),(Y),948) +#define get_gdat_v_str_pos948(X,Y) get_gdat_string((X),(Y),948) +#define get_gdat_bool_pos948(X,Y) get_gdat_bool((X),(Y),948) +#define get_gdat_int_pos948(X,Y) get_gdat_int((X),(Y),948) +#define get_gdat_llong_pos948(X,Y) get_gdat_llong((X),(Y),948) +#define get_gdat_float_pos948(X,Y) get_gdat_float((X),(Y),948) +#define get_gdat_uint_pos949(X,Y) get_gdat_uint((X),(Y),949) +#define get_gdat_ullong_pos949(X,Y) get_gdat_ullong((X),(Y),949) +#define get_gdat_ip_pos949(X,Y) get_gdat_ip((X),(Y),949) +#define get_gdat_ipv6_pos949(X,Y) get_gdat_ipv6((X),(Y),949) +#define get_gdat_string_pos949(X,Y) get_gdat_string((X),(Y),949) +#define get_gdat_v_str_pos949(X,Y) get_gdat_string((X),(Y),949) +#define get_gdat_bool_pos949(X,Y) get_gdat_bool((X),(Y),949) +#define get_gdat_int_pos949(X,Y) get_gdat_int((X),(Y),949) +#define get_gdat_llong_pos949(X,Y) get_gdat_llong((X),(Y),949) +#define get_gdat_float_pos949(X,Y) get_gdat_float((X),(Y),949) +#define get_gdat_uint_pos950(X,Y) get_gdat_uint((X),(Y),950) +#define get_gdat_ullong_pos950(X,Y) get_gdat_ullong((X),(Y),950) +#define get_gdat_ip_pos950(X,Y) get_gdat_ip((X),(Y),950) +#define get_gdat_ipv6_pos950(X,Y) get_gdat_ipv6((X),(Y),950) +#define get_gdat_string_pos950(X,Y) get_gdat_string((X),(Y),950) +#define get_gdat_v_str_pos950(X,Y) get_gdat_string((X),(Y),950) +#define get_gdat_bool_pos950(X,Y) get_gdat_bool((X),(Y),950) +#define get_gdat_int_pos950(X,Y) get_gdat_int((X),(Y),950) +#define get_gdat_llong_pos950(X,Y) get_gdat_llong((X),(Y),950) +#define get_gdat_float_pos950(X,Y) get_gdat_float((X),(Y),950) +#define get_gdat_uint_pos951(X,Y) get_gdat_uint((X),(Y),951) +#define get_gdat_ullong_pos951(X,Y) get_gdat_ullong((X),(Y),951) +#define get_gdat_ip_pos951(X,Y) get_gdat_ip((X),(Y),951) +#define get_gdat_ipv6_pos951(X,Y) get_gdat_ipv6((X),(Y),951) +#define get_gdat_string_pos951(X,Y) get_gdat_string((X),(Y),951) +#define get_gdat_v_str_pos951(X,Y) get_gdat_string((X),(Y),951) +#define get_gdat_bool_pos951(X,Y) get_gdat_bool((X),(Y),951) +#define get_gdat_int_pos951(X,Y) get_gdat_int((X),(Y),951) +#define get_gdat_llong_pos951(X,Y) get_gdat_llong((X),(Y),951) +#define get_gdat_float_pos951(X,Y) get_gdat_float((X),(Y),951) +#define get_gdat_uint_pos952(X,Y) get_gdat_uint((X),(Y),952) +#define get_gdat_ullong_pos952(X,Y) get_gdat_ullong((X),(Y),952) +#define get_gdat_ip_pos952(X,Y) get_gdat_ip((X),(Y),952) +#define get_gdat_ipv6_pos952(X,Y) get_gdat_ipv6((X),(Y),952) +#define get_gdat_string_pos952(X,Y) get_gdat_string((X),(Y),952) +#define get_gdat_v_str_pos952(X,Y) get_gdat_string((X),(Y),952) +#define get_gdat_bool_pos952(X,Y) get_gdat_bool((X),(Y),952) +#define get_gdat_int_pos952(X,Y) get_gdat_int((X),(Y),952) +#define get_gdat_llong_pos952(X,Y) get_gdat_llong((X),(Y),952) +#define get_gdat_float_pos952(X,Y) get_gdat_float((X),(Y),952) +#define get_gdat_uint_pos953(X,Y) get_gdat_uint((X),(Y),953) +#define get_gdat_ullong_pos953(X,Y) get_gdat_ullong((X),(Y),953) +#define get_gdat_ip_pos953(X,Y) get_gdat_ip((X),(Y),953) +#define get_gdat_ipv6_pos953(X,Y) get_gdat_ipv6((X),(Y),953) +#define get_gdat_string_pos953(X,Y) get_gdat_string((X),(Y),953) +#define get_gdat_v_str_pos953(X,Y) get_gdat_string((X),(Y),953) +#define get_gdat_bool_pos953(X,Y) get_gdat_bool((X),(Y),953) +#define get_gdat_int_pos953(X,Y) get_gdat_int((X),(Y),953) +#define get_gdat_llong_pos953(X,Y) get_gdat_llong((X),(Y),953) +#define get_gdat_float_pos953(X,Y) get_gdat_float((X),(Y),953) +#define get_gdat_uint_pos954(X,Y) get_gdat_uint((X),(Y),954) +#define get_gdat_ullong_pos954(X,Y) get_gdat_ullong((X),(Y),954) +#define get_gdat_ip_pos954(X,Y) get_gdat_ip((X),(Y),954) +#define get_gdat_ipv6_pos954(X,Y) get_gdat_ipv6((X),(Y),954) +#define get_gdat_string_pos954(X,Y) get_gdat_string((X),(Y),954) +#define get_gdat_v_str_pos954(X,Y) get_gdat_string((X),(Y),954) +#define get_gdat_bool_pos954(X,Y) get_gdat_bool((X),(Y),954) +#define get_gdat_int_pos954(X,Y) get_gdat_int((X),(Y),954) +#define get_gdat_llong_pos954(X,Y) get_gdat_llong((X),(Y),954) +#define get_gdat_float_pos954(X,Y) get_gdat_float((X),(Y),954) +#define get_gdat_uint_pos955(X,Y) get_gdat_uint((X),(Y),955) +#define get_gdat_ullong_pos955(X,Y) get_gdat_ullong((X),(Y),955) +#define get_gdat_ip_pos955(X,Y) get_gdat_ip((X),(Y),955) +#define get_gdat_ipv6_pos955(X,Y) get_gdat_ipv6((X),(Y),955) +#define get_gdat_string_pos955(X,Y) get_gdat_string((X),(Y),955) +#define get_gdat_v_str_pos955(X,Y) get_gdat_string((X),(Y),955) +#define get_gdat_bool_pos955(X,Y) get_gdat_bool((X),(Y),955) +#define get_gdat_int_pos955(X,Y) get_gdat_int((X),(Y),955) +#define get_gdat_llong_pos955(X,Y) get_gdat_llong((X),(Y),955) +#define get_gdat_float_pos955(X,Y) get_gdat_float((X),(Y),955) +#define get_gdat_uint_pos956(X,Y) get_gdat_uint((X),(Y),956) +#define get_gdat_ullong_pos956(X,Y) get_gdat_ullong((X),(Y),956) +#define get_gdat_ip_pos956(X,Y) get_gdat_ip((X),(Y),956) +#define get_gdat_ipv6_pos956(X,Y) get_gdat_ipv6((X),(Y),956) +#define get_gdat_string_pos956(X,Y) get_gdat_string((X),(Y),956) +#define get_gdat_v_str_pos956(X,Y) get_gdat_string((X),(Y),956) +#define get_gdat_bool_pos956(X,Y) get_gdat_bool((X),(Y),956) +#define get_gdat_int_pos956(X,Y) get_gdat_int((X),(Y),956) +#define get_gdat_llong_pos956(X,Y) get_gdat_llong((X),(Y),956) +#define get_gdat_float_pos956(X,Y) get_gdat_float((X),(Y),956) +#define get_gdat_uint_pos957(X,Y) get_gdat_uint((X),(Y),957) +#define get_gdat_ullong_pos957(X,Y) get_gdat_ullong((X),(Y),957) +#define get_gdat_ip_pos957(X,Y) get_gdat_ip((X),(Y),957) +#define get_gdat_ipv6_pos957(X,Y) get_gdat_ipv6((X),(Y),957) +#define get_gdat_string_pos957(X,Y) get_gdat_string((X),(Y),957) +#define get_gdat_v_str_pos957(X,Y) get_gdat_string((X),(Y),957) +#define get_gdat_bool_pos957(X,Y) get_gdat_bool((X),(Y),957) +#define get_gdat_int_pos957(X,Y) get_gdat_int((X),(Y),957) +#define get_gdat_llong_pos957(X,Y) get_gdat_llong((X),(Y),957) +#define get_gdat_float_pos957(X,Y) get_gdat_float((X),(Y),957) +#define get_gdat_uint_pos958(X,Y) get_gdat_uint((X),(Y),958) +#define get_gdat_ullong_pos958(X,Y) get_gdat_ullong((X),(Y),958) +#define get_gdat_ip_pos958(X,Y) get_gdat_ip((X),(Y),958) +#define get_gdat_ipv6_pos958(X,Y) get_gdat_ipv6((X),(Y),958) +#define get_gdat_string_pos958(X,Y) get_gdat_string((X),(Y),958) +#define get_gdat_v_str_pos958(X,Y) get_gdat_string((X),(Y),958) +#define get_gdat_bool_pos958(X,Y) get_gdat_bool((X),(Y),958) +#define get_gdat_int_pos958(X,Y) get_gdat_int((X),(Y),958) +#define get_gdat_llong_pos958(X,Y) get_gdat_llong((X),(Y),958) +#define get_gdat_float_pos958(X,Y) get_gdat_float((X),(Y),958) +#define get_gdat_uint_pos959(X,Y) get_gdat_uint((X),(Y),959) +#define get_gdat_ullong_pos959(X,Y) get_gdat_ullong((X),(Y),959) +#define get_gdat_ip_pos959(X,Y) get_gdat_ip((X),(Y),959) +#define get_gdat_ipv6_pos959(X,Y) get_gdat_ipv6((X),(Y),959) +#define get_gdat_string_pos959(X,Y) get_gdat_string((X),(Y),959) +#define get_gdat_v_str_pos959(X,Y) get_gdat_string((X),(Y),959) +#define get_gdat_bool_pos959(X,Y) get_gdat_bool((X),(Y),959) +#define get_gdat_int_pos959(X,Y) get_gdat_int((X),(Y),959) +#define get_gdat_llong_pos959(X,Y) get_gdat_llong((X),(Y),959) +#define get_gdat_float_pos959(X,Y) get_gdat_float((X),(Y),959) +#define get_gdat_uint_pos960(X,Y) get_gdat_uint((X),(Y),960) +#define get_gdat_ullong_pos960(X,Y) get_gdat_ullong((X),(Y),960) +#define get_gdat_ip_pos960(X,Y) get_gdat_ip((X),(Y),960) +#define get_gdat_ipv6_pos960(X,Y) get_gdat_ipv6((X),(Y),960) +#define get_gdat_string_pos960(X,Y) get_gdat_string((X),(Y),960) +#define get_gdat_v_str_pos960(X,Y) get_gdat_string((X),(Y),960) +#define get_gdat_bool_pos960(X,Y) get_gdat_bool((X),(Y),960) +#define get_gdat_int_pos960(X,Y) get_gdat_int((X),(Y),960) +#define get_gdat_llong_pos960(X,Y) get_gdat_llong((X),(Y),960) +#define get_gdat_float_pos960(X,Y) get_gdat_float((X),(Y),960) +#define get_gdat_uint_pos961(X,Y) get_gdat_uint((X),(Y),961) +#define get_gdat_ullong_pos961(X,Y) get_gdat_ullong((X),(Y),961) +#define get_gdat_ip_pos961(X,Y) get_gdat_ip((X),(Y),961) +#define get_gdat_ipv6_pos961(X,Y) get_gdat_ipv6((X),(Y),961) +#define get_gdat_string_pos961(X,Y) get_gdat_string((X),(Y),961) +#define get_gdat_v_str_pos961(X,Y) get_gdat_string((X),(Y),961) +#define get_gdat_bool_pos961(X,Y) get_gdat_bool((X),(Y),961) +#define get_gdat_int_pos961(X,Y) get_gdat_int((X),(Y),961) +#define get_gdat_llong_pos961(X,Y) get_gdat_llong((X),(Y),961) +#define get_gdat_float_pos961(X,Y) get_gdat_float((X),(Y),961) +#define get_gdat_uint_pos962(X,Y) get_gdat_uint((X),(Y),962) +#define get_gdat_ullong_pos962(X,Y) get_gdat_ullong((X),(Y),962) +#define get_gdat_ip_pos962(X,Y) get_gdat_ip((X),(Y),962) +#define get_gdat_ipv6_pos962(X,Y) get_gdat_ipv6((X),(Y),962) +#define get_gdat_string_pos962(X,Y) get_gdat_string((X),(Y),962) +#define get_gdat_v_str_pos962(X,Y) get_gdat_string((X),(Y),962) +#define get_gdat_bool_pos962(X,Y) get_gdat_bool((X),(Y),962) +#define get_gdat_int_pos962(X,Y) get_gdat_int((X),(Y),962) +#define get_gdat_llong_pos962(X,Y) get_gdat_llong((X),(Y),962) +#define get_gdat_float_pos962(X,Y) get_gdat_float((X),(Y),962) +#define get_gdat_uint_pos963(X,Y) get_gdat_uint((X),(Y),963) +#define get_gdat_ullong_pos963(X,Y) get_gdat_ullong((X),(Y),963) +#define get_gdat_ip_pos963(X,Y) get_gdat_ip((X),(Y),963) +#define get_gdat_ipv6_pos963(X,Y) get_gdat_ipv6((X),(Y),963) +#define get_gdat_string_pos963(X,Y) get_gdat_string((X),(Y),963) +#define get_gdat_v_str_pos963(X,Y) get_gdat_string((X),(Y),963) +#define get_gdat_bool_pos963(X,Y) get_gdat_bool((X),(Y),963) +#define get_gdat_int_pos963(X,Y) get_gdat_int((X),(Y),963) +#define get_gdat_llong_pos963(X,Y) get_gdat_llong((X),(Y),963) +#define get_gdat_float_pos963(X,Y) get_gdat_float((X),(Y),963) +#define get_gdat_uint_pos964(X,Y) get_gdat_uint((X),(Y),964) +#define get_gdat_ullong_pos964(X,Y) get_gdat_ullong((X),(Y),964) +#define get_gdat_ip_pos964(X,Y) get_gdat_ip((X),(Y),964) +#define get_gdat_ipv6_pos964(X,Y) get_gdat_ipv6((X),(Y),964) +#define get_gdat_string_pos964(X,Y) get_gdat_string((X),(Y),964) +#define get_gdat_v_str_pos964(X,Y) get_gdat_string((X),(Y),964) +#define get_gdat_bool_pos964(X,Y) get_gdat_bool((X),(Y),964) +#define get_gdat_int_pos964(X,Y) get_gdat_int((X),(Y),964) +#define get_gdat_llong_pos964(X,Y) get_gdat_llong((X),(Y),964) +#define get_gdat_float_pos964(X,Y) get_gdat_float((X),(Y),964) +#define get_gdat_uint_pos965(X,Y) get_gdat_uint((X),(Y),965) +#define get_gdat_ullong_pos965(X,Y) get_gdat_ullong((X),(Y),965) +#define get_gdat_ip_pos965(X,Y) get_gdat_ip((X),(Y),965) +#define get_gdat_ipv6_pos965(X,Y) get_gdat_ipv6((X),(Y),965) +#define get_gdat_string_pos965(X,Y) get_gdat_string((X),(Y),965) +#define get_gdat_v_str_pos965(X,Y) get_gdat_string((X),(Y),965) +#define get_gdat_bool_pos965(X,Y) get_gdat_bool((X),(Y),965) +#define get_gdat_int_pos965(X,Y) get_gdat_int((X),(Y),965) +#define get_gdat_llong_pos965(X,Y) get_gdat_llong((X),(Y),965) +#define get_gdat_float_pos965(X,Y) get_gdat_float((X),(Y),965) +#define get_gdat_uint_pos966(X,Y) get_gdat_uint((X),(Y),966) +#define get_gdat_ullong_pos966(X,Y) get_gdat_ullong((X),(Y),966) +#define get_gdat_ip_pos966(X,Y) get_gdat_ip((X),(Y),966) +#define get_gdat_ipv6_pos966(X,Y) get_gdat_ipv6((X),(Y),966) +#define get_gdat_string_pos966(X,Y) get_gdat_string((X),(Y),966) +#define get_gdat_v_str_pos966(X,Y) get_gdat_string((X),(Y),966) +#define get_gdat_bool_pos966(X,Y) get_gdat_bool((X),(Y),966) +#define get_gdat_int_pos966(X,Y) get_gdat_int((X),(Y),966) +#define get_gdat_llong_pos966(X,Y) get_gdat_llong((X),(Y),966) +#define get_gdat_float_pos966(X,Y) get_gdat_float((X),(Y),966) +#define get_gdat_uint_pos967(X,Y) get_gdat_uint((X),(Y),967) +#define get_gdat_ullong_pos967(X,Y) get_gdat_ullong((X),(Y),967) +#define get_gdat_ip_pos967(X,Y) get_gdat_ip((X),(Y),967) +#define get_gdat_ipv6_pos967(X,Y) get_gdat_ipv6((X),(Y),967) +#define get_gdat_string_pos967(X,Y) get_gdat_string((X),(Y),967) +#define get_gdat_v_str_pos967(X,Y) get_gdat_string((X),(Y),967) +#define get_gdat_bool_pos967(X,Y) get_gdat_bool((X),(Y),967) +#define get_gdat_int_pos967(X,Y) get_gdat_int((X),(Y),967) +#define get_gdat_llong_pos967(X,Y) get_gdat_llong((X),(Y),967) +#define get_gdat_float_pos967(X,Y) get_gdat_float((X),(Y),967) +#define get_gdat_uint_pos968(X,Y) get_gdat_uint((X),(Y),968) +#define get_gdat_ullong_pos968(X,Y) get_gdat_ullong((X),(Y),968) +#define get_gdat_ip_pos968(X,Y) get_gdat_ip((X),(Y),968) +#define get_gdat_ipv6_pos968(X,Y) get_gdat_ipv6((X),(Y),968) +#define get_gdat_string_pos968(X,Y) get_gdat_string((X),(Y),968) +#define get_gdat_v_str_pos968(X,Y) get_gdat_string((X),(Y),968) +#define get_gdat_bool_pos968(X,Y) get_gdat_bool((X),(Y),968) +#define get_gdat_int_pos968(X,Y) get_gdat_int((X),(Y),968) +#define get_gdat_llong_pos968(X,Y) get_gdat_llong((X),(Y),968) +#define get_gdat_float_pos968(X,Y) get_gdat_float((X),(Y),968) +#define get_gdat_uint_pos969(X,Y) get_gdat_uint((X),(Y),969) +#define get_gdat_ullong_pos969(X,Y) get_gdat_ullong((X),(Y),969) +#define get_gdat_ip_pos969(X,Y) get_gdat_ip((X),(Y),969) +#define get_gdat_ipv6_pos969(X,Y) get_gdat_ipv6((X),(Y),969) +#define get_gdat_string_pos969(X,Y) get_gdat_string((X),(Y),969) +#define get_gdat_v_str_pos969(X,Y) get_gdat_string((X),(Y),969) +#define get_gdat_bool_pos969(X,Y) get_gdat_bool((X),(Y),969) +#define get_gdat_int_pos969(X,Y) get_gdat_int((X),(Y),969) +#define get_gdat_llong_pos969(X,Y) get_gdat_llong((X),(Y),969) +#define get_gdat_float_pos969(X,Y) get_gdat_float((X),(Y),969) +#define get_gdat_uint_pos970(X,Y) get_gdat_uint((X),(Y),970) +#define get_gdat_ullong_pos970(X,Y) get_gdat_ullong((X),(Y),970) +#define get_gdat_ip_pos970(X,Y) get_gdat_ip((X),(Y),970) +#define get_gdat_ipv6_pos970(X,Y) get_gdat_ipv6((X),(Y),970) +#define get_gdat_string_pos970(X,Y) get_gdat_string((X),(Y),970) +#define get_gdat_v_str_pos970(X,Y) get_gdat_string((X),(Y),970) +#define get_gdat_bool_pos970(X,Y) get_gdat_bool((X),(Y),970) +#define get_gdat_int_pos970(X,Y) get_gdat_int((X),(Y),970) +#define get_gdat_llong_pos970(X,Y) get_gdat_llong((X),(Y),970) +#define get_gdat_float_pos970(X,Y) get_gdat_float((X),(Y),970) +#define get_gdat_uint_pos971(X,Y) get_gdat_uint((X),(Y),971) +#define get_gdat_ullong_pos971(X,Y) get_gdat_ullong((X),(Y),971) +#define get_gdat_ip_pos971(X,Y) get_gdat_ip((X),(Y),971) +#define get_gdat_ipv6_pos971(X,Y) get_gdat_ipv6((X),(Y),971) +#define get_gdat_string_pos971(X,Y) get_gdat_string((X),(Y),971) +#define get_gdat_v_str_pos971(X,Y) get_gdat_string((X),(Y),971) +#define get_gdat_bool_pos971(X,Y) get_gdat_bool((X),(Y),971) +#define get_gdat_int_pos971(X,Y) get_gdat_int((X),(Y),971) +#define get_gdat_llong_pos971(X,Y) get_gdat_llong((X),(Y),971) +#define get_gdat_float_pos971(X,Y) get_gdat_float((X),(Y),971) +#define get_gdat_uint_pos972(X,Y) get_gdat_uint((X),(Y),972) +#define get_gdat_ullong_pos972(X,Y) get_gdat_ullong((X),(Y),972) +#define get_gdat_ip_pos972(X,Y) get_gdat_ip((X),(Y),972) +#define get_gdat_ipv6_pos972(X,Y) get_gdat_ipv6((X),(Y),972) +#define get_gdat_string_pos972(X,Y) get_gdat_string((X),(Y),972) +#define get_gdat_v_str_pos972(X,Y) get_gdat_string((X),(Y),972) +#define get_gdat_bool_pos972(X,Y) get_gdat_bool((X),(Y),972) +#define get_gdat_int_pos972(X,Y) get_gdat_int((X),(Y),972) +#define get_gdat_llong_pos972(X,Y) get_gdat_llong((X),(Y),972) +#define get_gdat_float_pos972(X,Y) get_gdat_float((X),(Y),972) +#define get_gdat_uint_pos973(X,Y) get_gdat_uint((X),(Y),973) +#define get_gdat_ullong_pos973(X,Y) get_gdat_ullong((X),(Y),973) +#define get_gdat_ip_pos973(X,Y) get_gdat_ip((X),(Y),973) +#define get_gdat_ipv6_pos973(X,Y) get_gdat_ipv6((X),(Y),973) +#define get_gdat_string_pos973(X,Y) get_gdat_string((X),(Y),973) +#define get_gdat_v_str_pos973(X,Y) get_gdat_string((X),(Y),973) +#define get_gdat_bool_pos973(X,Y) get_gdat_bool((X),(Y),973) +#define get_gdat_int_pos973(X,Y) get_gdat_int((X),(Y),973) +#define get_gdat_llong_pos973(X,Y) get_gdat_llong((X),(Y),973) +#define get_gdat_float_pos973(X,Y) get_gdat_float((X),(Y),973) +#define get_gdat_uint_pos974(X,Y) get_gdat_uint((X),(Y),974) +#define get_gdat_ullong_pos974(X,Y) get_gdat_ullong((X),(Y),974) +#define get_gdat_ip_pos974(X,Y) get_gdat_ip((X),(Y),974) +#define get_gdat_ipv6_pos974(X,Y) get_gdat_ipv6((X),(Y),974) +#define get_gdat_string_pos974(X,Y) get_gdat_string((X),(Y),974) +#define get_gdat_v_str_pos974(X,Y) get_gdat_string((X),(Y),974) +#define get_gdat_bool_pos974(X,Y) get_gdat_bool((X),(Y),974) +#define get_gdat_int_pos974(X,Y) get_gdat_int((X),(Y),974) +#define get_gdat_llong_pos974(X,Y) get_gdat_llong((X),(Y),974) +#define get_gdat_float_pos974(X,Y) get_gdat_float((X),(Y),974) +#define get_gdat_uint_pos975(X,Y) get_gdat_uint((X),(Y),975) +#define get_gdat_ullong_pos975(X,Y) get_gdat_ullong((X),(Y),975) +#define get_gdat_ip_pos975(X,Y) get_gdat_ip((X),(Y),975) +#define get_gdat_ipv6_pos975(X,Y) get_gdat_ipv6((X),(Y),975) +#define get_gdat_string_pos975(X,Y) get_gdat_string((X),(Y),975) +#define get_gdat_v_str_pos975(X,Y) get_gdat_string((X),(Y),975) +#define get_gdat_bool_pos975(X,Y) get_gdat_bool((X),(Y),975) +#define get_gdat_int_pos975(X,Y) get_gdat_int((X),(Y),975) +#define get_gdat_llong_pos975(X,Y) get_gdat_llong((X),(Y),975) +#define get_gdat_float_pos975(X,Y) get_gdat_float((X),(Y),975) +#define get_gdat_uint_pos976(X,Y) get_gdat_uint((X),(Y),976) +#define get_gdat_ullong_pos976(X,Y) get_gdat_ullong((X),(Y),976) +#define get_gdat_ip_pos976(X,Y) get_gdat_ip((X),(Y),976) +#define get_gdat_ipv6_pos976(X,Y) get_gdat_ipv6((X),(Y),976) +#define get_gdat_string_pos976(X,Y) get_gdat_string((X),(Y),976) +#define get_gdat_v_str_pos976(X,Y) get_gdat_string((X),(Y),976) +#define get_gdat_bool_pos976(X,Y) get_gdat_bool((X),(Y),976) +#define get_gdat_int_pos976(X,Y) get_gdat_int((X),(Y),976) +#define get_gdat_llong_pos976(X,Y) get_gdat_llong((X),(Y),976) +#define get_gdat_float_pos976(X,Y) get_gdat_float((X),(Y),976) +#define get_gdat_uint_pos977(X,Y) get_gdat_uint((X),(Y),977) +#define get_gdat_ullong_pos977(X,Y) get_gdat_ullong((X),(Y),977) +#define get_gdat_ip_pos977(X,Y) get_gdat_ip((X),(Y),977) +#define get_gdat_ipv6_pos977(X,Y) get_gdat_ipv6((X),(Y),977) +#define get_gdat_string_pos977(X,Y) get_gdat_string((X),(Y),977) +#define get_gdat_v_str_pos977(X,Y) get_gdat_string((X),(Y),977) +#define get_gdat_bool_pos977(X,Y) get_gdat_bool((X),(Y),977) +#define get_gdat_int_pos977(X,Y) get_gdat_int((X),(Y),977) +#define get_gdat_llong_pos977(X,Y) get_gdat_llong((X),(Y),977) +#define get_gdat_float_pos977(X,Y) get_gdat_float((X),(Y),977) +#define get_gdat_uint_pos978(X,Y) get_gdat_uint((X),(Y),978) +#define get_gdat_ullong_pos978(X,Y) get_gdat_ullong((X),(Y),978) +#define get_gdat_ip_pos978(X,Y) get_gdat_ip((X),(Y),978) +#define get_gdat_ipv6_pos978(X,Y) get_gdat_ipv6((X),(Y),978) +#define get_gdat_string_pos978(X,Y) get_gdat_string((X),(Y),978) +#define get_gdat_v_str_pos978(X,Y) get_gdat_string((X),(Y),978) +#define get_gdat_bool_pos978(X,Y) get_gdat_bool((X),(Y),978) +#define get_gdat_int_pos978(X,Y) get_gdat_int((X),(Y),978) +#define get_gdat_llong_pos978(X,Y) get_gdat_llong((X),(Y),978) +#define get_gdat_float_pos978(X,Y) get_gdat_float((X),(Y),978) +#define get_gdat_uint_pos979(X,Y) get_gdat_uint((X),(Y),979) +#define get_gdat_ullong_pos979(X,Y) get_gdat_ullong((X),(Y),979) +#define get_gdat_ip_pos979(X,Y) get_gdat_ip((X),(Y),979) +#define get_gdat_ipv6_pos979(X,Y) get_gdat_ipv6((X),(Y),979) +#define get_gdat_string_pos979(X,Y) get_gdat_string((X),(Y),979) +#define get_gdat_v_str_pos979(X,Y) get_gdat_string((X),(Y),979) +#define get_gdat_bool_pos979(X,Y) get_gdat_bool((X),(Y),979) +#define get_gdat_int_pos979(X,Y) get_gdat_int((X),(Y),979) +#define get_gdat_llong_pos979(X,Y) get_gdat_llong((X),(Y),979) +#define get_gdat_float_pos979(X,Y) get_gdat_float((X),(Y),979) +#define get_gdat_uint_pos980(X,Y) get_gdat_uint((X),(Y),980) +#define get_gdat_ullong_pos980(X,Y) get_gdat_ullong((X),(Y),980) +#define get_gdat_ip_pos980(X,Y) get_gdat_ip((X),(Y),980) +#define get_gdat_ipv6_pos980(X,Y) get_gdat_ipv6((X),(Y),980) +#define get_gdat_string_pos980(X,Y) get_gdat_string((X),(Y),980) +#define get_gdat_v_str_pos980(X,Y) get_gdat_string((X),(Y),980) +#define get_gdat_bool_pos980(X,Y) get_gdat_bool((X),(Y),980) +#define get_gdat_int_pos980(X,Y) get_gdat_int((X),(Y),980) +#define get_gdat_llong_pos980(X,Y) get_gdat_llong((X),(Y),980) +#define get_gdat_float_pos980(X,Y) get_gdat_float((X),(Y),980) +#define get_gdat_uint_pos981(X,Y) get_gdat_uint((X),(Y),981) +#define get_gdat_ullong_pos981(X,Y) get_gdat_ullong((X),(Y),981) +#define get_gdat_ip_pos981(X,Y) get_gdat_ip((X),(Y),981) +#define get_gdat_ipv6_pos981(X,Y) get_gdat_ipv6((X),(Y),981) +#define get_gdat_string_pos981(X,Y) get_gdat_string((X),(Y),981) +#define get_gdat_v_str_pos981(X,Y) get_gdat_string((X),(Y),981) +#define get_gdat_bool_pos981(X,Y) get_gdat_bool((X),(Y),981) +#define get_gdat_int_pos981(X,Y) get_gdat_int((X),(Y),981) +#define get_gdat_llong_pos981(X,Y) get_gdat_llong((X),(Y),981) +#define get_gdat_float_pos981(X,Y) get_gdat_float((X),(Y),981) +#define get_gdat_uint_pos982(X,Y) get_gdat_uint((X),(Y),982) +#define get_gdat_ullong_pos982(X,Y) get_gdat_ullong((X),(Y),982) +#define get_gdat_ip_pos982(X,Y) get_gdat_ip((X),(Y),982) +#define get_gdat_ipv6_pos982(X,Y) get_gdat_ipv6((X),(Y),982) +#define get_gdat_string_pos982(X,Y) get_gdat_string((X),(Y),982) +#define get_gdat_v_str_pos982(X,Y) get_gdat_string((X),(Y),982) +#define get_gdat_bool_pos982(X,Y) get_gdat_bool((X),(Y),982) +#define get_gdat_int_pos982(X,Y) get_gdat_int((X),(Y),982) +#define get_gdat_llong_pos982(X,Y) get_gdat_llong((X),(Y),982) +#define get_gdat_float_pos982(X,Y) get_gdat_float((X),(Y),982) +#define get_gdat_uint_pos983(X,Y) get_gdat_uint((X),(Y),983) +#define get_gdat_ullong_pos983(X,Y) get_gdat_ullong((X),(Y),983) +#define get_gdat_ip_pos983(X,Y) get_gdat_ip((X),(Y),983) +#define get_gdat_ipv6_pos983(X,Y) get_gdat_ipv6((X),(Y),983) +#define get_gdat_string_pos983(X,Y) get_gdat_string((X),(Y),983) +#define get_gdat_v_str_pos983(X,Y) get_gdat_string((X),(Y),983) +#define get_gdat_bool_pos983(X,Y) get_gdat_bool((X),(Y),983) +#define get_gdat_int_pos983(X,Y) get_gdat_int((X),(Y),983) +#define get_gdat_llong_pos983(X,Y) get_gdat_llong((X),(Y),983) +#define get_gdat_float_pos983(X,Y) get_gdat_float((X),(Y),983) +#define get_gdat_uint_pos984(X,Y) get_gdat_uint((X),(Y),984) +#define get_gdat_ullong_pos984(X,Y) get_gdat_ullong((X),(Y),984) +#define get_gdat_ip_pos984(X,Y) get_gdat_ip((X),(Y),984) +#define get_gdat_ipv6_pos984(X,Y) get_gdat_ipv6((X),(Y),984) +#define get_gdat_string_pos984(X,Y) get_gdat_string((X),(Y),984) +#define get_gdat_v_str_pos984(X,Y) get_gdat_string((X),(Y),984) +#define get_gdat_bool_pos984(X,Y) get_gdat_bool((X),(Y),984) +#define get_gdat_int_pos984(X,Y) get_gdat_int((X),(Y),984) +#define get_gdat_llong_pos984(X,Y) get_gdat_llong((X),(Y),984) +#define get_gdat_float_pos984(X,Y) get_gdat_float((X),(Y),984) +#define get_gdat_uint_pos985(X,Y) get_gdat_uint((X),(Y),985) +#define get_gdat_ullong_pos985(X,Y) get_gdat_ullong((X),(Y),985) +#define get_gdat_ip_pos985(X,Y) get_gdat_ip((X),(Y),985) +#define get_gdat_ipv6_pos985(X,Y) get_gdat_ipv6((X),(Y),985) +#define get_gdat_string_pos985(X,Y) get_gdat_string((X),(Y),985) +#define get_gdat_v_str_pos985(X,Y) get_gdat_string((X),(Y),985) +#define get_gdat_bool_pos985(X,Y) get_gdat_bool((X),(Y),985) +#define get_gdat_int_pos985(X,Y) get_gdat_int((X),(Y),985) +#define get_gdat_llong_pos985(X,Y) get_gdat_llong((X),(Y),985) +#define get_gdat_float_pos985(X,Y) get_gdat_float((X),(Y),985) +#define get_gdat_uint_pos986(X,Y) get_gdat_uint((X),(Y),986) +#define get_gdat_ullong_pos986(X,Y) get_gdat_ullong((X),(Y),986) +#define get_gdat_ip_pos986(X,Y) get_gdat_ip((X),(Y),986) +#define get_gdat_ipv6_pos986(X,Y) get_gdat_ipv6((X),(Y),986) +#define get_gdat_string_pos986(X,Y) get_gdat_string((X),(Y),986) +#define get_gdat_v_str_pos986(X,Y) get_gdat_string((X),(Y),986) +#define get_gdat_bool_pos986(X,Y) get_gdat_bool((X),(Y),986) +#define get_gdat_int_pos986(X,Y) get_gdat_int((X),(Y),986) +#define get_gdat_llong_pos986(X,Y) get_gdat_llong((X),(Y),986) +#define get_gdat_float_pos986(X,Y) get_gdat_float((X),(Y),986) +#define get_gdat_uint_pos987(X,Y) get_gdat_uint((X),(Y),987) +#define get_gdat_ullong_pos987(X,Y) get_gdat_ullong((X),(Y),987) +#define get_gdat_ip_pos987(X,Y) get_gdat_ip((X),(Y),987) +#define get_gdat_ipv6_pos987(X,Y) get_gdat_ipv6((X),(Y),987) +#define get_gdat_string_pos987(X,Y) get_gdat_string((X),(Y),987) +#define get_gdat_v_str_pos987(X,Y) get_gdat_string((X),(Y),987) +#define get_gdat_bool_pos987(X,Y) get_gdat_bool((X),(Y),987) +#define get_gdat_int_pos987(X,Y) get_gdat_int((X),(Y),987) +#define get_gdat_llong_pos987(X,Y) get_gdat_llong((X),(Y),987) +#define get_gdat_float_pos987(X,Y) get_gdat_float((X),(Y),987) +#define get_gdat_uint_pos988(X,Y) get_gdat_uint((X),(Y),988) +#define get_gdat_ullong_pos988(X,Y) get_gdat_ullong((X),(Y),988) +#define get_gdat_ip_pos988(X,Y) get_gdat_ip((X),(Y),988) +#define get_gdat_ipv6_pos988(X,Y) get_gdat_ipv6((X),(Y),988) +#define get_gdat_string_pos988(X,Y) get_gdat_string((X),(Y),988) +#define get_gdat_v_str_pos988(X,Y) get_gdat_string((X),(Y),988) +#define get_gdat_bool_pos988(X,Y) get_gdat_bool((X),(Y),988) +#define get_gdat_int_pos988(X,Y) get_gdat_int((X),(Y),988) +#define get_gdat_llong_pos988(X,Y) get_gdat_llong((X),(Y),988) +#define get_gdat_float_pos988(X,Y) get_gdat_float((X),(Y),988) +#define get_gdat_uint_pos989(X,Y) get_gdat_uint((X),(Y),989) +#define get_gdat_ullong_pos989(X,Y) get_gdat_ullong((X),(Y),989) +#define get_gdat_ip_pos989(X,Y) get_gdat_ip((X),(Y),989) +#define get_gdat_ipv6_pos989(X,Y) get_gdat_ipv6((X),(Y),989) +#define get_gdat_string_pos989(X,Y) get_gdat_string((X),(Y),989) +#define get_gdat_v_str_pos989(X,Y) get_gdat_string((X),(Y),989) +#define get_gdat_bool_pos989(X,Y) get_gdat_bool((X),(Y),989) +#define get_gdat_int_pos989(X,Y) get_gdat_int((X),(Y),989) +#define get_gdat_llong_pos989(X,Y) get_gdat_llong((X),(Y),989) +#define get_gdat_float_pos989(X,Y) get_gdat_float((X),(Y),989) +#define get_gdat_uint_pos990(X,Y) get_gdat_uint((X),(Y),990) +#define get_gdat_ullong_pos990(X,Y) get_gdat_ullong((X),(Y),990) +#define get_gdat_ip_pos990(X,Y) get_gdat_ip((X),(Y),990) +#define get_gdat_ipv6_pos990(X,Y) get_gdat_ipv6((X),(Y),990) +#define get_gdat_string_pos990(X,Y) get_gdat_string((X),(Y),990) +#define get_gdat_v_str_pos990(X,Y) get_gdat_string((X),(Y),990) +#define get_gdat_bool_pos990(X,Y) get_gdat_bool((X),(Y),990) +#define get_gdat_int_pos990(X,Y) get_gdat_int((X),(Y),990) +#define get_gdat_llong_pos990(X,Y) get_gdat_llong((X),(Y),990) +#define get_gdat_float_pos990(X,Y) get_gdat_float((X),(Y),990) +#define get_gdat_uint_pos991(X,Y) get_gdat_uint((X),(Y),991) +#define get_gdat_ullong_pos991(X,Y) get_gdat_ullong((X),(Y),991) +#define get_gdat_ip_pos991(X,Y) get_gdat_ip((X),(Y),991) +#define get_gdat_ipv6_pos991(X,Y) get_gdat_ipv6((X),(Y),991) +#define get_gdat_string_pos991(X,Y) get_gdat_string((X),(Y),991) +#define get_gdat_v_str_pos991(X,Y) get_gdat_string((X),(Y),991) +#define get_gdat_bool_pos991(X,Y) get_gdat_bool((X),(Y),991) +#define get_gdat_int_pos991(X,Y) get_gdat_int((X),(Y),991) +#define get_gdat_llong_pos991(X,Y) get_gdat_llong((X),(Y),991) +#define get_gdat_float_pos991(X,Y) get_gdat_float((X),(Y),991) +#define get_gdat_uint_pos992(X,Y) get_gdat_uint((X),(Y),992) +#define get_gdat_ullong_pos992(X,Y) get_gdat_ullong((X),(Y),992) +#define get_gdat_ip_pos992(X,Y) get_gdat_ip((X),(Y),992) +#define get_gdat_ipv6_pos992(X,Y) get_gdat_ipv6((X),(Y),992) +#define get_gdat_string_pos992(X,Y) get_gdat_string((X),(Y),992) +#define get_gdat_v_str_pos992(X,Y) get_gdat_string((X),(Y),992) +#define get_gdat_bool_pos992(X,Y) get_gdat_bool((X),(Y),992) +#define get_gdat_int_pos992(X,Y) get_gdat_int((X),(Y),992) +#define get_gdat_llong_pos992(X,Y) get_gdat_llong((X),(Y),992) +#define get_gdat_float_pos992(X,Y) get_gdat_float((X),(Y),992) +#define get_gdat_uint_pos993(X,Y) get_gdat_uint((X),(Y),993) +#define get_gdat_ullong_pos993(X,Y) get_gdat_ullong((X),(Y),993) +#define get_gdat_ip_pos993(X,Y) get_gdat_ip((X),(Y),993) +#define get_gdat_ipv6_pos993(X,Y) get_gdat_ipv6((X),(Y),993) +#define get_gdat_string_pos993(X,Y) get_gdat_string((X),(Y),993) +#define get_gdat_v_str_pos993(X,Y) get_gdat_string((X),(Y),993) +#define get_gdat_bool_pos993(X,Y) get_gdat_bool((X),(Y),993) +#define get_gdat_int_pos993(X,Y) get_gdat_int((X),(Y),993) +#define get_gdat_llong_pos993(X,Y) get_gdat_llong((X),(Y),993) +#define get_gdat_float_pos993(X,Y) get_gdat_float((X),(Y),993) +#define get_gdat_uint_pos994(X,Y) get_gdat_uint((X),(Y),994) +#define get_gdat_ullong_pos994(X,Y) get_gdat_ullong((X),(Y),994) +#define get_gdat_ip_pos994(X,Y) get_gdat_ip((X),(Y),994) +#define get_gdat_ipv6_pos994(X,Y) get_gdat_ipv6((X),(Y),994) +#define get_gdat_string_pos994(X,Y) get_gdat_string((X),(Y),994) +#define get_gdat_v_str_pos994(X,Y) get_gdat_string((X),(Y),994) +#define get_gdat_bool_pos994(X,Y) get_gdat_bool((X),(Y),994) +#define get_gdat_int_pos994(X,Y) get_gdat_int((X),(Y),994) +#define get_gdat_llong_pos994(X,Y) get_gdat_llong((X),(Y),994) +#define get_gdat_float_pos994(X,Y) get_gdat_float((X),(Y),994) +#define get_gdat_uint_pos995(X,Y) get_gdat_uint((X),(Y),995) +#define get_gdat_ullong_pos995(X,Y) get_gdat_ullong((X),(Y),995) +#define get_gdat_ip_pos995(X,Y) get_gdat_ip((X),(Y),995) +#define get_gdat_ipv6_pos995(X,Y) get_gdat_ipv6((X),(Y),995) +#define get_gdat_string_pos995(X,Y) get_gdat_string((X),(Y),995) +#define get_gdat_v_str_pos995(X,Y) get_gdat_string((X),(Y),995) +#define get_gdat_bool_pos995(X,Y) get_gdat_bool((X),(Y),995) +#define get_gdat_int_pos995(X,Y) get_gdat_int((X),(Y),995) +#define get_gdat_llong_pos995(X,Y) get_gdat_llong((X),(Y),995) +#define get_gdat_float_pos995(X,Y) get_gdat_float((X),(Y),995) +#define get_gdat_uint_pos996(X,Y) get_gdat_uint((X),(Y),996) +#define get_gdat_ullong_pos996(X,Y) get_gdat_ullong((X),(Y),996) +#define get_gdat_ip_pos996(X,Y) get_gdat_ip((X),(Y),996) +#define get_gdat_ipv6_pos996(X,Y) get_gdat_ipv6((X),(Y),996) +#define get_gdat_string_pos996(X,Y) get_gdat_string((X),(Y),996) +#define get_gdat_v_str_pos996(X,Y) get_gdat_string((X),(Y),996) +#define get_gdat_bool_pos996(X,Y) get_gdat_bool((X),(Y),996) +#define get_gdat_int_pos996(X,Y) get_gdat_int((X),(Y),996) +#define get_gdat_llong_pos996(X,Y) get_gdat_llong((X),(Y),996) +#define get_gdat_float_pos996(X,Y) get_gdat_float((X),(Y),996) +#define get_gdat_uint_pos997(X,Y) get_gdat_uint((X),(Y),997) +#define get_gdat_ullong_pos997(X,Y) get_gdat_ullong((X),(Y),997) +#define get_gdat_ip_pos997(X,Y) get_gdat_ip((X),(Y),997) +#define get_gdat_ipv6_pos997(X,Y) get_gdat_ipv6((X),(Y),997) +#define get_gdat_string_pos997(X,Y) get_gdat_string((X),(Y),997) +#define get_gdat_v_str_pos997(X,Y) get_gdat_string((X),(Y),997) +#define get_gdat_bool_pos997(X,Y) get_gdat_bool((X),(Y),997) +#define get_gdat_int_pos997(X,Y) get_gdat_int((X),(Y),997) +#define get_gdat_llong_pos997(X,Y) get_gdat_llong((X),(Y),997) +#define get_gdat_float_pos997(X,Y) get_gdat_float((X),(Y),997) +#define get_gdat_uint_pos998(X,Y) get_gdat_uint((X),(Y),998) +#define get_gdat_ullong_pos998(X,Y) get_gdat_ullong((X),(Y),998) +#define get_gdat_ip_pos998(X,Y) get_gdat_ip((X),(Y),998) +#define get_gdat_ipv6_pos998(X,Y) get_gdat_ipv6((X),(Y),998) +#define get_gdat_string_pos998(X,Y) get_gdat_string((X),(Y),998) +#define get_gdat_v_str_pos998(X,Y) get_gdat_string((X),(Y),998) +#define get_gdat_bool_pos998(X,Y) get_gdat_bool((X),(Y),998) +#define get_gdat_int_pos998(X,Y) get_gdat_int((X),(Y),998) +#define get_gdat_llong_pos998(X,Y) get_gdat_llong((X),(Y),998) +#define get_gdat_float_pos998(X,Y) get_gdat_float((X),(Y),998) +#define get_gdat_uint_pos999(X,Y) get_gdat_uint((X),(Y),999) +#define get_gdat_ullong_pos999(X,Y) get_gdat_ullong((X),(Y),999) +#define get_gdat_ip_pos999(X,Y) get_gdat_ip((X),(Y),999) +#define get_gdat_ipv6_pos999(X,Y) get_gdat_ipv6((X),(Y),999) +#define get_gdat_string_pos999(X,Y) get_gdat_string((X),(Y),999) +#define get_gdat_v_str_pos999(X,Y) get_gdat_string((X),(Y),999) +#define get_gdat_bool_pos999(X,Y) get_gdat_bool((X),(Y),999) +#define get_gdat_int_pos999(X,Y) get_gdat_int((X),(Y),999) +#define get_gdat_llong_pos999(X,Y) get_gdat_llong((X),(Y),999) +#define get_gdat_float_pos999(X,Y) get_gdat_float((X),(Y),999) +#define get_gdat_uint_pos1000(X,Y) get_gdat_uint((X),(Y),1000) +#define get_gdat_ullong_pos1000(X,Y) get_gdat_ullong((X),(Y),1000) +#define get_gdat_ip_pos1000(X,Y) get_gdat_ip((X),(Y),1000) +#define get_gdat_ipv6_pos1000(X,Y) get_gdat_ipv6((X),(Y),1000) +#define get_gdat_string_pos1000(X,Y) get_gdat_string((X),(Y),1000) +#define get_gdat_v_str_pos1000(X,Y) get_gdat_string((X),(Y),1000) +#define get_gdat_bool_pos1000(X,Y) get_gdat_bool((X),(Y),1000) +#define get_gdat_int_pos1000(X,Y) get_gdat_int((X),(Y),1000) +#define get_gdat_llong_pos1000(X,Y) get_gdat_llong((X),(Y),1000) +#define get_gdat_float_pos1000(X,Y) get_gdat_float((X),(Y),1000) +#endif diff --git a/include/lfta/gencsvinclude.pl b/include/lfta/gencsvinclude.pl new file mode 100644 index 0000000..9b5421b --- /dev/null +++ b/include/lfta/gencsvinclude.pl @@ -0,0 +1,35 @@ +#! /usr/bin/perl + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +open(I,"cat ../packet.h | grep '#define CSVELEMENTS' | cut -f 3 -d ' ' |"); +$num=; +close(I); +chomp $num; +printf("#ifndef CSV_MACRO_H\n#define CSV_MACRO_H\n"); +for($x=1;$x<=$num;$x++) { + printf "#define get_csv_uint_pos$x(X,Y) get_csv_uint((X),(Y),$x)\n"; + printf "#define get_csv_ullong_pos$x(X,Y) get_csv_ullong((X),(Y),$x)\n"; + printf "#define get_csv_ip_pos$x(X,Y) get_csv_ip((X),(Y),$x)\n"; + printf "#define get_csv_ipv6_pos$x(X,Y) get_csv_ipv6((X),(Y),$x)\n"; + printf "#define get_csv_string_pos$x(X,Y) get_csv_string((X),(Y),$x)\n"; + printf "#define get_csv_v_str_pos$x(X,Y) get_csv_string((X),(Y),$x)\n"; + printf "#define get_csv_bool_pos$x(X,Y) get_csv_bool((X),(Y),$x)\n"; + printf "#define get_csv_int_pos$x(X,Y) get_csv_int((X),(Y),$x)\n"; + printf "#define get_csv_llong_pos$x(X,Y) get_csv_llong((X),(Y),$x)\n"; + printf "#define get_csv_float_pos$x(X,Y) get_csv_float((X),(Y),$x)\n"; +} +print("#endif\n"); diff --git a/include/lfta/gengdatinclude.pl b/include/lfta/gengdatinclude.pl new file mode 100644 index 0000000..6678a1e --- /dev/null +++ b/include/lfta/gengdatinclude.pl @@ -0,0 +1,35 @@ +#! /usr/bin/perl + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +open(I,"cat ../packet.h | grep '#define GDATELEMENTS' | cut -f 3 -d ' ' |"); +$num=; +close(I); +chomp $num; +printf("#ifndef GDAT_MACRO_H\n#define GDAT_MACRO_H\n"); +for($x=1;$x<=$num;$x++) { + printf "#define get_gdat_uint_pos$x(X,Y) get_gdat_uint((X),(Y),$x)\n"; + printf "#define get_gdat_ullong_pos$x(X,Y) get_gdat_ullong((X),(Y),$x)\n"; + printf "#define get_gdat_ip_pos$x(X,Y) get_gdat_ip((X),(Y),$x)\n"; + printf "#define get_gdat_ipv6_pos$x(X,Y) get_gdat_ipv6((X),(Y),$x)\n"; + printf "#define get_gdat_string_pos$x(X,Y) get_gdat_string((X),(Y),$x)\n"; + printf "#define get_gdat_v_str_pos$x(X,Y) get_gdat_string((X),(Y),$x)\n"; + printf "#define get_gdat_bool_pos$x(X,Y) get_gdat_bool((X),(Y),$x)\n"; + printf "#define get_gdat_int_pos$x(X,Y) get_gdat_int((X),(Y),$x)\n"; + printf "#define get_gdat_llong_pos$x(X,Y) get_gdat_llong((X),(Y),$x)\n"; + printf "#define get_gdat_float_pos$x(X,Y) get_gdat_float((X),(Y),$x)\n"; +} +print("#endif\n"); diff --git a/include/lfta/md_stdlib.h b/include/lfta/md_stdlib.h new file mode 100644 index 0000000..1735c46 --- /dev/null +++ b/include/lfta/md_stdlib.h @@ -0,0 +1,23 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include +#include + +/* + * macro adaptor + */ +#define mod(a,b) ((a) % (b)) + diff --git a/include/lfta/rts.h b/include/lfta/rts.h new file mode 100644 index 0000000..f0bf616 --- /dev/null +++ b/include/lfta/rts.h @@ -0,0 +1,123 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + * rts.h: ethernet card run-time system dfns + */ +#ifndef RTS_H +#define RTS_H +#include "gstypes.h" +#include "gsconfig.h" +#include "byteswap.h" +#include "rts_external.h" + +struct gs_string; /* forward decl. */ + +#ifndef NULL +#define NULL 0 +#endif + +#include "fta.h" + + +/* + * dynamic memory allocation for FTAs (so they can store state, etc.). + * note that the allocator keeps track of which FTA owns what blocks and + * can free all allocated blocks for a given FTA in one go. + */ + +void *fta_alloc(struct FTA *, gs_int32_t size); +void fta_free(struct FTA *, void *mem); +void fta_free_all(struct FTA *); + +/* memory allocation for scratchpad */ + +#define sp_fta_alloc fta_alloc +#define sp_fta_free fta_free +#define sp_fta_free_all fta_free_all + + +/* functions used to parse packet (list is not complete)*/ +#include "schema_prototypes.h" + +/* + * FTA output: FTAs output tuples to the host using the post_tuple RTS function. + * Before the tuple can be output a tuple memory block has to be allocated + * in the tuple memory space. The allocate_tuple function is used for this. + * If an FTA is removed before post_tuple is called all allocated memory + * in the FTA's tuple space is reclaimed. If the FTA is removed after + * post_tuple is called the tuple will be deliverd to the host. + * If 0 is returned at no none suspended ringbuffer has not enough memory to + * allocate the tuple + */ + +void * allocate_tuple(struct FTA *, gs_int32_t size); + +/* post tuple posts the tuple if the atomic reingbuffer set can not suceed -1 is returned and the tuple is not + posted otherwise 0 is returned*/ + +gs_retval_t post_tuple(void *tuple); + + +/* the following function fills in the FTAID array r with the FTAIDs of processes receiving + * tuplese from the FTA specified in f. The space array indicates how many tuples of tuplesz + * can still fit in the ringbuffer corresponding to the FTAID of the process with the same index + * in r. The return values indicates how many ring buffers are valid in r. szr indicates the memory + * length (in elements) of r and space. The function will fill at most szr elements into these array. + * If the return value is larger then szr it is an indication that not enough memory in r and space + * were provided to hold all results. A return value of -1 indicates an error. + */ + +gs_retval_t get_ringbuf_space(struct FTA * f, FTAID * r, gs_int32_t * space, gs_int32_t szr, gs_int32_t tuplesz); + + +/* the following function can be used to put a ringbuffer to a process identified by the FTAID + * process into one of the following 3 modes. ATOMIC makes the ringbuffer part of the atomic set. + * A post to the atomic set either succeed or fails entirely. BESTEFORT is the besteffort set + * posts to BESTEFORT ringbuffers might fail quitely. SUSPEND will prevent any tuples of being + * posted to that proccess from the specified FTA. NOTE: Calling set_ringbuf_space between + * allocate_tuple and post_tuple might have unpredictable results for the tuple already + * allocated. + */ + +#define LFTA_RINGBUF_ATOMIC 1 +#define LFTA_RINGBUF_BESTEFFORT 2 +#define LFTA_RINGBUF_SUSPEND 3 + +gs_retval_t set_ringbuf_type(struct FTA * f, FTAID process, gs_int32_t state); + +/* The following function returns TRUE if there is enough room in the post tuple + * queue for a speedy posting of the tuple. It should be used by FTAs which could + * possibly delay the posting of a tuple if FALSE is returned. + */ + +gs_retval_t post_ready(void); + +/* + * the following function gives hints to the heap for binning + */ + +void fta_add_alloc_bin_size(struct FTA *, gs_int32_t sz, gs_int32_t maxcnt); +void fta_remove_alloc_bin_size(struct FTA *, gs_int32_t sz, gs_int32_t maxcnt); + + +gs_retval_t print_error(char *string); /* XXXCDC: right place? */ + +/* Function to get the attributes of interfaces in an lfta */ + +gs_sp_t get_iface_properties (const gs_sp_t iface_name, const gs_sp_t property_name); + + +#endif diff --git a/include/lfta/rts_external.h b/include/lfta/rts_external.h new file mode 100644 index 0000000..0f0127c --- /dev/null +++ b/include/lfta/rts_external.h @@ -0,0 +1,153 @@ +#ifndef RTS_STRING_H +#define RTS_STRING_H + +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include + +#include "gsconfig.h" +#include "gstypes.h" + +#define IS_BIG_ENDIAN (*(uint16_t *)"\0\xff" < 0x100) + +// struct string32 matches vstring32, its the packed record format. +// struct gs_string is the in-memory format. + +struct string32{ + gs_int32_t length; + gs_int32_t offset; + gs_int32_t reserved; +}; + + +/* struct gs_string has to match definition in host.h however, the data + types differ */ + +struct gs_string { + gs_int32_t length; + gs_sp_t data; + struct FTA * owner; +}; + +#include "fta.h" +#include "rts.h" + + +/* Basic string operation */ + +gs_retval_t str_assign_with_copy(struct FTA *, struct gs_string * dest, struct gs_string * src); + +gs_retval_t str_assign_with_copy_in_tuple(struct string32 * dest, struct gs_string * src, + gs_sp_t start, gs_sp_t buf); + +#define str_destroy(s) {if ((s)->owner!=0) fta_free((s)->owner,(s)->data);} + +gs_retval_t str_replace(struct FTA *, struct gs_string * dest, struct gs_string * src ); + +#define str_length(s) (s)->length + +/* Searching within a string */ + +gs_retval_t str_exists_substr( struct gs_string * str1, struct gs_string * str2); + +/* String comparison */ + +gs_retval_t str_compare( struct gs_string * str1, struct gs_string * str2); + + +/* Construct a string constant */ + +gs_retval_t str_constructor(struct gs_string *s, gs_sp_t l); + + +/* External Function definitions */ + +#define LLMIN(x,y) ((x)<(y)?(x):(y)) +#define LLMAX(x,y) ((x)<(y)?(y):(x)) +#define UMIN(x,y) ((x)<(y)?(x):(y)) +#define UMAX(x,y) ((x)<(y)?(y):(x)) +// type conversion +#define INT(c) ((int)(c)) +#define UINT(c) ((unsigned int)(c)) +#define ULLONG(c) ((unsigned long long)(c)) +#define FLOAT(c) ((double)(c)) + +// Cast away temporality +#define non_temporal(x)(x) + + + +gs_uint32_t str_match_offset( gs_uint32_t offset, struct gs_string * s1, struct gs_string * s2); +gs_uint32_t byte_match_offset( gs_uint32_t offset, gs_uint32_t val, struct gs_string * s2); +gs_param_handle_t register_handle_for_str_regex_match_slot_1(struct FTA * f, + struct gs_string* pattern); +gs_uint32_t str_regex_match(struct gs_string* str, gs_param_handle_t pattern_handle); +gs_retval_t deregister_handle_for_str_regex_match_slot_1(gs_param_handle_t handle); + +gs_param_handle_t register_handle_for_str_partial_regex_match_slot_1(struct FTA * f, + struct gs_string* pattern); +gs_uint32_t str_partial_regex_match(struct gs_string* str, + gs_param_handle_t pattern_handle, + gs_uint32_t maxlen); +gs_retval_t deregister_handle_for_str_partial_regex_match_slot_1( + gs_param_handle_t + handle); + +inline static gs_retval_t str_truncate(struct gs_string * result, struct gs_string *str, gs_uint32_t length) { + result->data=str->data; + result->length=(str->lengthlength:length; + return 0; +} + +// constant string conversions +gs_param_handle_t register_handle_for_strtoi_c_slot_0(struct FTA * f, struct gs_string* istr) ; +gs_retval_t deregister_handle_for_strtoi_c_slot_0(gs_param_handle_t h) ; +#define strtoi_c(h) ((unsigned int)(h)) + +gs_param_handle_t register_handle_for_strtoip_c_slot_0(struct FTA * f, struct gs_string* istr) ; +gs_retval_t deregister_handle_for_strtoip_c_slot_0(gs_param_handle_t h) ; +#define strtoip_c(h) ((unsigned int)(h)) + + + +//////////////////////////////////////////////// +/// IPV6 + +#ifndef IPV6_STR +#define IPV6_STR +struct ipv6_str{ + gs_uint32_t v[4]; +}; +#endif + +gs_int32_t ipv6_compare( struct ipv6_str i1, struct ipv6_str i2); +gs_int32_t Ipv6_Constructor(struct ipv6_str *s, char *l); +struct ipv6_str And_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2); +struct ipv6_str Or_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2); +struct ipv6_str hton_ipv6(struct ipv6_str s); +struct ipv6_str ntoh_ipv6(struct ipv6_str s); + + +//////////////////////////////////////////////// +/// Regex pattern extraction based on signature library for VideoNOC +gs_param_handle_t register_handle_for_signaturelib_get_content_id_slot_2(struct FTA * f, struct gs_string* signature_file); +gs_uint32_t signaturelib_get_content_id(struct gs_string* result, struct gs_string* url, gs_uint32_t content_length, gs_param_handle_t handle); +gs_retval_t deregister_handle_for_signaturelib_get_content_id_slot_2(gs_param_handle_t handle); + +gs_uint32_t signaturelib_get_fqdn(struct gs_string* result); +gs_uint32_t signaturelib_get_channel_type(struct gs_string* result); + +#endif diff --git a/include/lfta/rts_udaf.h b/include/lfta/rts_udaf.h new file mode 100644 index 0000000..fc6bae3 --- /dev/null +++ b/include/lfta/rts_udaf.h @@ -0,0 +1,84 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef _RTS_UDAF_H_INCLUDED_ +#define _RTS_UDAF_H_INCLUDED_ + +#include "gsconfig.h" +#include "gstypes.h" +#include "rts_external.h" + + +// avg_udaf +void avg_udaf_lfta_LFTA_AGGR_INIT_(gs_sp_t); +void avg_udaf_lfta_LFTA_AGGR_UPDATE_(gs_sp_t,gs_uint32_t); +gs_retval_t avg_udaf_lfta_LFTA_AGBGR_FLUSHME_(gs_sp_t); +void avg_udaf_lfta_LFTA_AGGR_OUTPUT_(struct gs_string *,gs_sp_t); +void avg_udaf_lfta_LFTA_AGGR_DESTROY_(gs_sp_t); + +// moving sum +void moving_sum_lfta_LFTA_AGGR_INIT_(gs_sp_t b); +void moving_sum_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v, gs_uint32_t N); +gs_retval_t moving_sum_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b); +void moving_sum_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t *r, gs_sp_t b); +gs_retval_t moving_sum_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b); + + +// first aggregate +void FIRST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch); +void FIRST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val); +gs_retval_t FIRST_lfta_LFTA_AGGR_FLUSHME_(gs_uint32_t* scratch); +void FIRST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch); +void FIRST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch); + +void FIRST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch); +void FIRST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val); +gs_retval_t FIRST_ULL_lfta_LFTA_AGGR_FLUSHME_(gs_uint64_t* scratch); +void FIRST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch); +void FIRST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch); + +void FIRST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch); +void FIRST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val); +gs_retval_t FIRST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch); +void FIRST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch); +void FIRST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch); + +// last aggregate +void LAST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch); +void LAST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val); +gs_retval_t LAST_lfta_LFTA_AGGR_FLUSHME_(gs_uint32_t* scratch); +void LAST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch); +void LAST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch); + +void LAST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch); +void LAST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val); +gs_retval_t LAST_ULL_lfta_LFTA_AGGR_FLUSHME_(gs_uint64_t* scratch); +void LAST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch); +void LAST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch); + +void LAST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch); +void LAST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val); +gs_retval_t LAST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch); +void LAST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch); +void LAST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch); + +// running_array_aggr aggregate +void running_array_aggr_lfta_LFTA_AGGR_INIT_(char* scratch); +void running_array_aggr_lfta_LFTA_AGGR_UPDATE_(char* scratch, gs_uint32_t val); +gs_retval_t running_array_aggr_lfta_LFTA_AGGR_FLUSHME_(char* scratch); +void running_array_aggr_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, char* scratch); +void running_array_aggr_lfta_LFTA_AGGR_DESTROY_(char* scratch); + + +#endif diff --git a/include/lfta/schema_prototypes.h b/include/lfta/schema_prototypes.h new file mode 100644 index 0000000..7a02b4c --- /dev/null +++ b/include/lfta/schema_prototypes.h @@ -0,0 +1,513 @@ +#ifndef __SCHEMA_PROTOTYPES__ +#define __SCHEMA_PROTOTYPES__ + +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +#define PRECOMP +#include "gsconfig.h" +#include "gstypes.h" + +#include "fta.h" +#include "rts_external.h" +#include "packet.h" +#include "md_stdlib.h" +#include "schemaparser.h" + + +// *** SAMPLING RELATED CONSTANTS +// ****************************** + +// Make sure the hash table sizes are powers of 2-1 since they are used to compute the module with an and. +// collions on the flow hash are handled properly so they are not that bad +#define MAX_FLOWRECORD_HASH 0x1fffff +// keep the collision rate low on denies +#define MAX_DENY_HASH 0x7fffff +// one out of SAMPLING_RATE+1 sampling +#define SAMPLING_RATE 19 +// sampling probability +#define FLOWSAMPPROB (((gs_float_t)1)/((gs_float_t)SAMPLING_RATE+1)) +// wait for SAMPLED_FLOW_TIMEOUT seconds idle time to time a flow out +#define SAMPLED_FLOW_TIMEOUT 30 +// check if we haven't seen that flow in SAMPLED_FLOW_IDLE_TIME seconds to make sure we don't catch it in the midle +#define SAMPLED_FLOW_IDLE_TIME 30 + +// PACKET SAMPLING RATE one in SAMPLED_PACKETS will be sampled +#define SAMPLED_PACKETS 200 +// SAMPLING probability +#define PACKETSAMPPROB (((gs_float_t)1)/((gs_float_t)SAMPLED_PACKETS)) + +// COMBINE probability +#define COMBINEDPROB (((gs_float_t)1)-(((gs_float_t)1)-FLOWSAMPPROB)*(((gs_float_t)1)-PACKETSAMPPROB)) + +/* General packet access functions */ + +static inline gs_retval_t get_system_time(struct packet * p, gs_uint32_t * t) +{ + *t=(gs_uint32_t) p->systemTime; + return 0; +} + +/* CSV access function using position as 3rd argument */ + +static inline gs_retval_t get_csv_uint(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + *t = strtoul((const char*)p->record.csv.fields[pos-1], NULL, 10); + return 0; +} + +static inline gs_retval_t get_csv_ullong(struct packet * p, gs_uint64_t * t,gs_uint32_t pos) +{ + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + *t = strtoull((const char*)p->record.csv.fields[pos-1], NULL, 10); + return 0; +} + +static inline gs_retval_t get_csv_ip(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + unsigned ip1,ip2,ip3,ip4; + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + sscanf((const char*) p->record.csv.fields[pos-1],"%u.%u.%u.%u",&ip1,&ip2,&ip3,&ip4); + *t=(ip1<<24)|(ip2<<16)|(ip3<<8)|ip4; + return 0; +} +static inline gs_retval_t get_csv_ipv6(struct packet * p, struct ipv6_str * t,gs_uint32_t pos) +{ + gs_uint32_t v[8]; + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + sscanf((const char*) p->record.csv.fields[pos-1],"%x:%x:%x:%x:%x:%x:%x:%x",&v[0],&v[1],&v[2],&v[3],&v[4],&v[5],&v[6],&v[7]); + t->v[0]=htonl(v[0]<<16|v[1]); + t->v[1]=htonl(v[2]<<16|v[3]); + t->v[2]=htonl(v[4]<<16|v[5]); + t->v[3]=htonl(v[6]<<16|v[7]); + + return 0; +} +static inline gs_retval_t get_csv_string(struct packet * p, struct gs_string * t,gs_uint32_t pos) +{ + + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + t->data=(gs_sp_t)p->record.csv.fields[pos-1]; + if (pos == p->record.csv.numberfields) + t->length=strlen((const char*)p->record.csv.fields[pos-1]); + else + t->length=p->record.csv.fields[pos] - p->record.csv.fields[pos-1] - 1; + t->owner=0; + return 0; +} +static inline gs_retval_t get_csv_bool(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + *t=0; + if ((strlen((const char*)p->record.csv.fields[pos-1])==4) && + (strncasecmp("TRUE",(const char*)p->record.csv.fields[pos-1],4) ==0) ) { + *t=1; + } + return 0; +} +static inline gs_retval_t get_csv_int(struct packet * p, gs_int32_t * t,gs_uint32_t pos) +{ + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + *t = strtol((const char*)p->record.csv.fields[pos-1], NULL, 10); + return 0; +} +static inline gs_retval_t get_csv_llong(struct packet * p, gs_int64_t * t,gs_uint32_t pos) +{ + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + *t = strtoll((const char*)p->record.csv.fields[pos-1], NULL, 10); + return 0; +} +static inline gs_retval_t get_csv_float(struct packet * p, gs_float_t * t,gs_uint32_t pos) +{ + if (p->ptype != PTYPE_CSV) return -1; + if (p->record.csv.numberfields < pos) return -1; + *t = strtod((const char*)p->record.csv.fields[pos-1], NULL); + return 0; +} + +#include + +static inline __attribute__((always_inline)) unsigned int gs_strtoul (const char *str, size_t len) { + unsigned int value = 0; + + switch (len) { // handle up to 10 digits, assume we're 32-bit + case 10: value += (str[len-10] - '0') * 1000000000; + case 9: value += (str[len- 9] - '0') * 100000000; + case 8: value += (str[len- 8] - '0') * 10000000; + case 7: value += (str[len- 7] - '0') * 1000000; + case 6: value += (str[len- 6] - '0') * 100000; + case 5: value += (str[len- 5] - '0') * 10000; + case 4: value += (str[len- 4] - '0') * 1000; + case 3: value += (str[len- 3] - '0') * 100; + case 2: value += (str[len- 2] - '0') * 10; + case 1: value += (str[len- 1] - '0'); + return value; + default: + return 0; + } +} + +static inline __attribute__((always_inline)) unsigned long long gs_strtoull (const char *str, size_t len) { + unsigned long long value = 0; + + switch (len) { // handle up to 10 digits, assume we're 32-bit + case 20: value += (str[len-20] - '0') * 10000000000000000000UL; + case 19: value += (str[len-19] - '0') * 1000000000000000000UL; + case 18: value += (str[len-18] - '0') * 100000000000000000UL; + case 17: value += (str[len-17] - '0') * 10000000000000000UL; + case 16: value += (str[len-16] - '0') * 1000000000000000UL; + case 15: value += (str[len-15] - '0') * 100000000000000UL; + case 14: value += (str[len-14] - '0') * 10000000000000UL; + case 13: value += (str[len-13] - '0') * 1000000000000UL; + case 12: value += (str[len-12] - '0') * 100000000000UL; + case 11: value += (str[len-11] - '0') * 10000000000UL; + case 10: value += (str[len-10] - '0') * 1000000000UL; + case 9: value += (str[len- 9] - '0') * 100000000UL; + case 8: value += (str[len- 8] - '0') * 10000000UL; + case 7: value += (str[len- 7] - '0') * 1000000UL; + case 6: value += (str[len- 6] - '0') * 100000UL; + case 5: value += (str[len- 5] - '0') * 10000UL; + case 4: value += (str[len- 4] - '0') * 1000UL; + case 3: value += (str[len- 3] - '0') * 100UL; + case 2: value += (str[len- 2] - '0') * 10UL; + case 1: value += (str[len- 1] - '0'); + return value; + default: + return 0; + } +} + +static inline gs_retval_t get_csv2_uint(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ +// *t = strtoul((const char*)p->record.csv2.fields[pos-1], NULL, 10); + *t = gs_strtoul((const char*)p->record.csv2.fields[pos-1], p->record.csv2.field_lens[pos-1]); + + return 0; +} + +static inline gs_retval_t get_csv2_ullong(struct packet * p, gs_uint64_t * t,gs_uint32_t pos) +{ +// *t = strtoull((const char*)p->record.csv2.fields[pos-1], NULL, 10); + *t = gs_strtoull((const char*)p->record.csv2.fields[pos-1], p->record.csv2.field_lens[pos-1]); + return 0; +} + +static inline gs_retval_t get_csv2_ip(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + unsigned ip1,ip2,ip3,ip4; + sscanf((const char*) p->record.csv2.fields[pos-1],"%u.%u.%u.%u",&ip1,&ip2,&ip3,&ip4); + *t=(ip1<<24)|(ip2<<16)|(ip3<<8)|ip4; + return 0; +} +static inline gs_retval_t get_csv2_ipv6(struct packet * p, struct ipv6_str * t,gs_uint32_t pos) +{ + gs_uint32_t v[8]; + sscanf((const char*) p->record.csv2.fields[pos-1],"%x:%x:%x:%x:%x:%x:%x:%x",&v[0],&v[1],&v[2],&v[3],&v[4],&v[5],&v[6],&v[7]); + t->v[0]=htonl(v[0]<<16|v[1]); + t->v[1]=htonl(v[2]<<16|v[3]); + t->v[2]=htonl(v[4]<<16|v[5]); + t->v[3]=htonl(v[6]<<16|v[7]); + + return 0; +} +static inline gs_retval_t get_csv2_string(struct packet * p, struct gs_string * t,gs_uint32_t pos) +{ + t->data=(gs_sp_t)p->record.csv2.fields[pos-1]; + /* + if (pos == p->record.csv2.numberfields) + t->length=strlen((const char*)p->record.csv2.fields[pos-1]); + else + t->length=p->record.csv2.fields[pos] - p->record.csv2.fields[pos-1] - 1; + */ + t->length=p->record.csv2.field_lens[pos-1]; + t->owner=0; + return 0; +} +static inline gs_retval_t get_csv2_bool(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + *t=0; + if ((strlen((const char*)p->record.csv2.fields[pos-1])==4) && + (strncasecmp("TRUE",(const char*)p->record.csv2.fields[pos-1],4) ==0) ) { + *t=1; + } + return 0; +} +static inline gs_retval_t get_csv2_int(struct packet * p, gs_int32_t * t,gs_uint32_t pos) +{ + *t = strtol((const char*)p->record.csv2.fields[pos-1], NULL, 10); + return 0; +} +static inline gs_retval_t get_csv2_llong(struct packet * p, gs_int64_t * t,gs_uint32_t pos) +{ + *t = strtoll((const char*)p->record.csv2.fields[pos-1], NULL, 10); + return 0; +} +static inline gs_retval_t get_csv2_float(struct packet * p, gs_float_t * t,gs_uint32_t pos) +{ + *t = strtod((const char*)p->record.csv2.fields[pos-1], NULL); + return 0; +} + +#include + +/* GDAT access function using position as 3rd argument */ + +//#define GDATDEBUG + +static inline gs_retval_t get_gdat_uint(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + struct access_result ar; +#ifdef GDATDEBUG + fprintf(stderr,"Decode uint"); +#endif + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=UINT_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + *t=ar.r.ui; + return 0; +} + +static inline gs_retval_t get_gdat_ullong(struct packet * p, gs_uint64_t * t,gs_uint32_t pos) +{ + struct access_result ar; +#ifdef GDATDEBUG + fprintf(stderr,"Decode ullong"); +#endif + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=ULLONG_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + *t=ar.r.ul; + return 0; +} + +static inline gs_retval_t get_gdat_ip(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + struct access_result ar; + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"Decode ip"); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=IP_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + *t=ar.r.ui; + return 0; +} +static inline gs_retval_t get_gdat_ipv6(struct packet * p, struct ipv6_str * t,gs_uint32_t pos) +{ + struct access_result ar; + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"Decode ipv6"); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=IPV6_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + t->v[0]=ar.r.ip6.v[0]; + t->v[1]=ar.r.ip6.v[1]; + t->v[2]=ar.r.ip6.v[2]; + t->v[3]=ar.r.ip6.v[3]; + return 0; +} +static inline gs_retval_t get_gdat_string(struct packet * p, struct gs_string * t,gs_uint32_t pos) +{ + struct access_result ar; +#ifdef GDATDEBUG + fprintf(stderr,"Decode string"); +#endif + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=VSTR_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + t->data=(gs_sp_t)ar.r.vs.offset; + t->length=ar.r.vs.length; + return 0; +} +static inline gs_retval_t get_gdat_bool(struct packet * p, gs_uint32_t * t,gs_uint32_t pos) +{ + struct access_result ar; +#ifdef GDATDEBUG + fprintf(stderr,"Decode bool"); +#endif + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=BOOL_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + *t=ar.r.ui; + return 0; +} +static inline gs_retval_t get_gdat_int(struct packet * p, gs_int32_t * t,gs_uint32_t pos) +{ + struct access_result ar; +#ifdef GDATDEBUG + fprintf(stderr,"Decode int"); +#endif + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=INT_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + *t=ar.r.i; + return 0; +} +static inline gs_retval_t get_gdat_llong(struct packet * p, gs_int64_t * t,gs_uint32_t pos) +{ + struct access_result ar; +#ifdef GDATDEBUG + fprintf(stderr,"Decode llong"); +#endif + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=LLONG_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + *t=ar.r.l; + return 0; +} +static inline gs_retval_t get_gdat_float(struct packet * p, gs_float_t * t,gs_uint32_t pos) +{ + struct access_result ar; +#ifdef GDATDEBUG + fprintf(stderr,"Decode float"); +#endif + if (p->ptype != PTYPE_GDAT) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (p->record.gdat.numfieldsrecord.gdat.schema,pos-1,p->record.gdat.data,p->record.gdat.datasz); +#ifdef GDATDEBUG + fprintf(stderr,"."); +#endif + if (ar.field_data_type!=FLOAT_TYPE) return -1; +#ifdef GDATDEBUG + fprintf(stderr,"DONE\n"); +#endif + *t=ar.r.f; + return 0; +} + +#include + +// External functions + + + + +#endif + diff --git a/include/packet.h b/include/packet.h new file mode 100644 index 0000000..8f91891 --- /dev/null +++ b/include/packet.h @@ -0,0 +1,65 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef PACKET_H +#define PACKET_H + +#include "gsconfig.h" +#include "gstypes.h" + +#ifndef IPV6_STR +#define IPV6_STR +struct ipv6_str{ + gs_uint32_t v[4]; +}; +#endif + +#define PTYPE_CSV 1 +#define PTYPE_GDAT 2 + +#define CSVELEMENTS 1000 +#define GDATELEMENTS 1000 + +struct csv { + gs_uint32_t numberfields; + gs_sp_t fields[CSVELEMENTS]; +}; + +struct csv2 { // SSE accelerated CSV processor + gs_uint32_t numberfields; + gs_sp_t fields[CSVELEMENTS]; + gs_uint32_t field_lens[CSVELEMENTS]; + gs_uint8_t parsed[CSVELEMENTS]; +}; + +struct gdat { + gs_schemahandle_t schema; + gs_uint32_t numfields; + gs_uint32_t datasz; + gs_uint8_t data[MAXTUPLESZ]; +}; + +struct packet { + gs_uint32_t systemTime; + gs_uint32_t ptype; /* type of record e.g. PTYPE_CSV */ + union { + struct csv csv; /* content of CSV record being processed */ + struct csv2 csv2; + struct gdat gdat; + } record; + +}; + + +#endif diff --git a/include/rdtsc.h b/include/rdtsc.h new file mode 100644 index 0000000..346f5d4 --- /dev/null +++ b/include/rdtsc.h @@ -0,0 +1,36 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __RDTSC_H__ +#define __RDTSC_H__ + +#include "gsconfig.h" +#include "gstypes.h" + +#if defined(__i386__) || defined(__x86_64__) + +static __inline__ gs_uint64_t rdtsc(void) +{ + gs_uint64_t x=0; + gs_uint32_t low; + gs_uint32_t high; + __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high)); + x=((gs_uint64_t)high)<<32; + x=x|((gs_uint64_t)low); + return x; +} +#endif + +#endif // __RDTSC_H__ + diff --git a/include/schemaparser.h b/include/schemaparser.h new file mode 100644 index 0000000..7d13a4c --- /dev/null +++ b/include/schemaparser.h @@ -0,0 +1,317 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __INTERFACE_LIB_INCLUDED__ +#define __INTERFACE_LIB_INCLUDED__ +#include "gsconfig.h" +#include "gstypes.h" + +#include +#include "byteswap.h" +#include "type_indicators.h" +#include "fta.h" +#include +/* #include"type_objects.h" */ +/* #include"parse_fta.h" */ + + +/*////////////////////////////////////////////////////// +//// Include data type definitions. */ + +/* Include vstring.h to get the vstring definition. */ + +/* XXXX OS This data definitions and prototypes are mirrored in schemaparser.h + * any changes have to be reflected there !! + */ + +#include"vstring.h" + +#include +/* +#ifndef _TIMEVAL_T +#define _TIMEVAL_T +struct timeval { + long tv_sec; + long tv_usec; +}; +#endif +*/ + +struct fstring_str{ + gs_int32_t size; + gs_sp_t data; // gs_int8_t * +}; + +/* Universal result holder. */ +#ifndef _struct_access_result_defined_ +#define _struct_access_result_defined_ +struct access_result { + int field_data_type; // as defined + union { + gs_int32_t i; + gs_uint32_t ui; + gs_int64_t l; + gs_uint64_t ul; + gs_float_t f; + struct timeval t; // defined in sys/time.h + struct vstring vs; + struct fstring_str fs; + struct hfta_ipv6_str ip6; + } r; +}; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + +/*////////////////////////////////////// +//// Version functions */ + +gs_int32_t get_schemaparser_version(); +gs_int32_t *get_schemaparser_accepted_versions(); // returns zero-terminated array +gs_int32_t schemaparser_accepts_version(gs_int32_t v); // 1 if true, 0 o'wise. + + +/*///////////////////////////////////////////////// +//// Helper functions */ + +// int fta_field_size(int dt, int *is_udef); + + +/*/////////////////////////////////////////////////// +//// Interface functions */ + + +/*/// FTA management ////////////// */ + +/* Create a new schema representation, return + an integer handle. + Input is a char array with the stream schema. + returns -1 on error. + Diagnostics written to stderr. + use the _prot version to also to accept a PROTOCOL (table) +*/ + +gs_schemahandle_t ftaschema_parse_string(gs_csp_t f); // gs_csp_t is const char * +gs_schemahandle_t ftaschema_parse_string_prot(gs_csp_t f); // gs_csp_t is const char * + +/* Create a new schema representation, return + an integer handle. + Input is a STREAM schema in a file. + use the _prot version to also to accept a PROTOCOL (table) + returns -1 on error. + Diagnostics written to stderr. +*/ +gs_schemahandle_t ftaschema_parse_file(FILE *f); +gs_schemahandle_t ftaschema_parse_file_prot(FILE *f); + +/* Release memory used by the schema representation. + return non-zero on error. +*/ +gs_int32_t ftaschema_free(gs_schemahandle_t sh); // gs_sp_t is char * + +/* name of fta schema null terminated */ +/* Returns NULL if sh is out of bounds. */ +/* NO ALLOCATION IS PERFORMED! Must treat result as const. */ +gs_sp_t ftaschema_name(gs_schemahandle_t sh); + +/* key of fta + This function is omitted because we are using name only. +FTAkey * ftaschema_key(schema_handle sh); +*/ + +/*///// Tuple management //////////////////// */ + +/* number of entries in a tuple */ +/* Return -1 if the schema handle is out of range. */ +gs_int32_t ftaschema_tuple_len(gs_schemahandle_t sh); + + +/* tuple entry name */ +/* Returns NULL if sh or index is out of bounds. */ +/* NO ALLOCATION IS PERFORMED! Must treat result as const. */ +gs_sp_t ftaschema_field_name(gs_schemahandle_t sh, gs_uint32_t index); + + +/* returns field offset by name (for direct access) */ +/* if sh is out of bounds, or if fieldname is not the name of a field, + or len is too small, + return value is -1 (field_offset) / UNDEFINED_TYPE (field_type) + gs_sp_t is char * +*/ +gs_int32_t ftaschema_get_field_offset_by_name(gs_schemahandle_t sh, gs_csp_t fieldname); +gs_int32_t ftaschema_get_field_type_by_name(gs_schemahandle_t sh, gs_csp_t fieldname); + +/* get field_offset, field_type bu index instead of name */ +gs_int32_t ftaschema_get_field_offset_by_index(gs_schemahandle_t sh, gs_int32_t index); +gs_int32_t ftaschema_get_field_type_by_index(gs_schemahandle_t sh, gs_int32_t index); + + +/* returns field value based on name */ +/* if sh is out of bounds, or if fieldname is not the name of a field, + or len is too small, + return value is of type UNDEFINED_TYPE + NO COPYING IS PERFORMED FOR vstring TYPES. + gs_sp_t is char * +*/ +struct access_result ftaschema_get_field_by_name(gs_schemahandle_t sh, + gs_csp_t fieldname, void * data, gs_int32_t len); + +/* return field value by index */ +/* if sh is out of bounds, or if fieldname is not the name of a field, + or len is too small, + return value is of type UNDEFINED_TYPE + NO COPYING IS PERFORMED FOR vstring TYPES. +*/ +struct access_result ftaschema_get_field_by_index(gs_schemahandle_t sh, + gs_uint32_t index, void * data, gs_uint32_t len); + +/* The following functions deals with temporal status tuples */ + +// Get location of eof, temporal-tuple metadata. +gs_int32_t ftaschema_get_tuple_metadata_offset(gs_schemahandle_t sh); + +/* checks whether tuple is temporal + return value 1 indicates that tuple istemporal, 0 - not temporal +*/ +gs_int32_t ftaschema_is_temporal_tuple(gs_int32_t schema_handle, void *data); +//gs_int32_t ftaschema_is_temporal_tuple_offset(int metadata_offset, void *data) ; +#define ftaschema_is_temporal_tuple_offset(metadata_offset,data) (*((gs_sp_t)(data) + (metadata_offset)) == TEMPORAL_TUPLE) + +/* checks whether tuple is special end-of_file tuple + return value 1 indicates that tuple is eof_tuple, 0 - otherwise +*/ +gs_int32_t ftaschema_is_eof_tuple(gs_int32_t schema_handle, void *data); +gs_int32_t ftaschema_is_eof_tuple_offset(int metadata_offset, void *data) ; + + + + + +/* extracts the trace from the temporal tuple */ +gs_int32_t ftaschema_get_trace(gs_int32_t schema_handle, void* data, + gs_int32_t len, + gs_uint64_t * trace_id, gs_uint32_t* sz, fta_stat** trace ); + + +/* The following functions operate directly on the tuple + to return field values. Problem set to 1 if the len is too small. + unpack_vstr does not make a copy of the buffer. + Neither does unpack_fstring +*/ +gs_uint32_t fta_unpack_uint(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_uint32_t fta_unpack_ushort(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_uint32_t fta_unpack_bool(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_int32_t fta_unpack_int(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_uint64_t fta_unpack_ullong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_int64_t fta_unpack_llong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_float_t fta_unpack_float(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +struct timeval fta_unpack_timeval(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +struct vstring fta_unpack_vstr(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +struct hfta_ipv6_str fta_unpack_ipv6(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_sp_t fta_unpack_fstring(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); + +gs_uint32_t fta_unpack_uint_nocheck(void *data, gs_uint32_t offset); +gs_uint32_t fta_unpack_ushort_nocheck(void *data, gs_uint32_t offset); +gs_uint32_t fta_unpack_bool_nocheck(void *data, gs_uint32_t offset); +gs_int32_t fta_unpack_int_nocheck(void *data, gs_uint32_t offset); +gs_uint64_t fta_unpack_ullong_nocheck(void *data, gs_uint32_t offset); +gs_int64_t fta_unpack_llong_nocheck(void *data, gs_uint32_t offset); +gs_float_t fta_unpack_float_nocheck(void *data, gs_uint32_t offset); +struct timeval fta_unpack_timeval_nocheck(void *data, gs_uint32_t offset); +struct hfta_ipv6_str fta_unpack_ipv6_nocheck(void *data, gs_uint32_t offset); + +// THe same as above, but no ntoh xform +gs_uint32_t fta_unpack_uint_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_uint32_t fta_unpack_ushort_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_uint32_t fta_unpack_bool_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_int32_t fta_unpack_int_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_uint64_t fta_unpack_ullong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_int64_t fta_unpack_llong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_float_t fta_unpack_float_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +struct timeval fta_unpack_timeval_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +struct hfta_ipv6_str fta_unpack_ipv6_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +struct vstring fta_unpack_vstr_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); +gs_sp_t fta_unpack_fstring_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem); + +gs_uint32_t fta_unpack_uint_noxf_nocheck(void *data, gs_uint32_t offset); +gs_uint32_t fta_unpack_ushort_noxf_nocheck(void *data, gs_uint32_t offset); +gs_uint32_t fta_unpack_bool_noxf_nocheck(void *data, gs_uint32_t offset); +gs_int32_t fta_unpack_int_noxf_nocheck(void *data, gs_uint32_t offset); +gs_uint64_t fta_unpack_ullong_noxf_nocheck(void *data, gs_uint32_t offset); +gs_int64_t fta_unpack_llong_noxf_nocheck(void *data, gs_uint32_t offset); +gs_float_t fta_unpack_float_noxf_nocheck(void *data, gs_uint32_t offset); +struct timeval fta_unpack_timeval_noxf_nocheck(void *data, gs_uint32_t offset); +struct hfta_ipv6_str fta_unpack_ipv6_noxf_nocheck(void *data, gs_uint32_t offset); + + + +/*/////// Param block management ///////////////*/ + + +/* number of parameters */ +/* Return -1 if sh is out of bounds */ +gs_int32_t ftaschema_parameter_len(gs_schemahandle_t sh); + +/* parameter entry name */ +/* Return NULL if sh or index is out of bounds. */ +/* NO COPYING IS PERFORMED */ +gs_sp_t ftaschema_parameter_name(gs_schemahandle_t sh, gs_uint32_t index); + +/* + No need to create param handles, it is done at schema parse time. + (downside: must be careful to set all parameters if + the user sends param blocks to multiple instances) + + creates a parameter structure handle for a particular schema +paramhandle ftaschema_create_paramhandle(schema_handle sh); + + frees a parameter structure handle +int ftaschema_free_paramhandle(paramhandle ph); +*/ + + +/* set parameter value for parameter handle */ +/* Pass in the parameter in its char string representation. */ +/* Return value is -1 on error, else 0 */ +gs_int32_t ftaschema_setparam_by_name(gs_schemahandle_t sh, gs_sp_t param_name, + gs_sp_t param_val, gs_int32_t len); + +/* set parameter value for parameter handle */ +/* Pass in the parameter in its char string representation. */ +/* Return value is -1 on error, else 0 */ +gs_int32_t ftaschema_setparam_by_index(gs_schemahandle_t sh, gs_int32_t index, + gs_sp_t param_val, gs_int32_t len); + +/* creates the parameter block which can be passed in control and + init operations. The function allocates the memory returned and + the caller is responsible to free it. + Return value is -1 on error, else 0. + ALL VALUES CONVERTED TO NETWORK BYTE ORDER + */ + +gs_int32_t ftaschema_create_param_block(gs_schemahandle_t sh, void ** block, gs_int32_t * size); + +//void ftaschema_debugdump(int handle); + +#ifdef __cplusplus +} +#endif + + +#endif + diff --git a/include/simple_http.h b/include/simple_http.h new file mode 100644 index 0000000..ed001f0 --- /dev/null +++ b/include/simple_http.h @@ -0,0 +1,36 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "gstypes.h" +#include "gshub.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// perform HTTP GET. Non-zero return value indicates an error +int http_get_request(endpoint addr, gs_csp_t url, gs_uint32_t* http_code, gs_sp_t json_response); + +// perform HTTP POST. Non-zero return value indicates an error +int http_post_request(endpoint addr, gs_csp_t url, gs_sp_t json_request, gs_uint32_t* http_code); + +// perform HTTP POST. Non-zero return value indicates an error +// THis version lets you pass in additional headers, which must +// be properly formatted. Some differences in default header. +int http_post_request_hdr(endpoint addr, gs_csp_t url, gs_sp_t json_request, gs_uint32_t* http_code, gs_sp_t extra_headers); + +#ifdef __cplusplus +} +#endif diff --git a/include/stringhash.h b/include/stringhash.h new file mode 100644 index 0000000..40f4725 --- /dev/null +++ b/include/stringhash.h @@ -0,0 +1,874 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef _STRINGHASH_H +#define _STRINGHASH_H +#include +#include +#include +#include +#include + +//Provides 5-universal hash functions. +//Both a direct polynomial based one, +//and the much faster tabulation based one. +// +//It also provides 2-universal string hashing. +//For most applicatoins, introdcing a slight error, +//if you want almost 5-uninversal hashing for strings, +//you can do a 2-universal hashing into 32-bit integer +//getting very few collissoins, and then use the above +//5-universal one. + + + +typedef gs_uint8_t INT8; +typedef gs_uint16_t INT16; +typedef gs_uint32_t INT32; +typedef gs_uint64_t INT64; + +typedef INT64 * Hash61bit5univID; +typedef INT32** HashTab32bit5univID; +typedef INT32** HashTab32bitLPID; +typedef INT64** HashTab64bitLPID; +typedef INT64 * Hash32bit2univID; +typedef INT32 Hash32bitUnivID; + +const INT32 MAX_INT32 = UINT_MAX; + +typedef struct { + INT64 str_compr_hid[16]; + INT64 string_hid; + INT64 length_factor; + // INT64 last_compr_hid; +} VISHID; + +typedef VISHID * VarINT32StringHash32bit2univID; + + +typedef struct { + INT32 int_str[16]; + INT64 str_compr_hid[16]; + INT64 string_hid; + INT64 length_factor; + // INT64 last_compr_hid; +} VSHID; + +typedef VSHID * VarStringHash32bit2univID; + + + + + +// different views of a 64-bit double word +typedef union { + INT64 as_int64; + INT32 as_int32s[2]; + INT16 as_int16s[4]; +} int64views; + +const INT64 LowOnes = (((INT64)1)<<32)-1; + +#define LOW(x) ((x)&LowOnes) // extract lower 32 bits from INT64 +#define HIGH(x) ((x)>>32) // extract higher 32 bits from INT64 + +const INT64 Prime61 = (((INT64)1)<<61) - 1; + + +//Random numbers from random.org based on atmostpheric noise. +INT64 Random64[200]= {0x285eb7722a62ce6eull, + 0xa84c7463e2b7856bull, + 0xb29100d6abcc8666ull, + 0xf9bfca5b7461fb1full, + 0x51c8dafc30c88dadull, + 0x0687468c365ec51dull, + 0x2bf2cd3ad64b6218ull, + 0xc20565a4d1f00f9eull, + 0x7d533575d313c658ull, + 0xbf2fba6b00725b85ull, + 0x4cfc2f6557e722beull, + 0xedbce818556dfb2bull, + 0xd9df508027db1bbeull, + 0x21f2d922f712f48bull, + 0xcd8b289d83a65804ull, + 0x4a19cfb02445a6d2ull, + 0xc95e56b1e19a4f94ull, + 0xcfeeeaccaf477248ull, + 0x4eec3378b73bb25cull, + 0x18a3f38d1c48b2beull, + 0x71b79ab5cb1e3730ull, + 0x79cdb30e2f38309dull, + 0xb41d4983bdbc8d6full, + 0xba9f57c01b66b7e3ull, + 0xe400503c95c16568ull, + 0x5977bfd4630294f1ull, + 0x57d4d7940099676full, + 0xd945de9268f4b191ull, + 0x4034711421eaf806ull, + 0x6d8108a4a6d58c22ull, + 0x5c421818ddbdd4eeull, + 0xbd9b7e4071713c13ull, + 0xa60d1d6e793e5eb2ull, + 0x7443fb031b8ec6c7ull, + 0xd8290c7120e05d4aull, + 0x797fb1d9a6a8d27full, + 0x543ec268ab1f2e45ull, + 0xcaf2a6139701f320ull, + 0x9519611d130bee47ull, + 0x19bbc533f018be1aull, + 0xdbfacdfeb573133dull, + 0x3255dacc4c7bfe12ull, + 0xbc6c9228e5518f6eull, + 0xb5c1681037347178ull, + 0xbaaa2cfef186bfadull, + 0x1834b8ab0f9e876eull, + 0x9d7b7f228433e0f7ull, + 0xa99cc292d003dd09ull, + 0xc0cb8037046b5295ull, + 0xa6ffa3d4671aa3d2ull, + 0xc27023fbee2862e6ull, + 0x5a9877bcc4bd3172ull, + 0xfcb0da3caf9fcfe0ull, + 0xc35ef57e1866ceaeull, + 0xd4f7c927d169a115ull, + 0x699054518fc74756ull, + 0xa75cbf617fc9db8dull, + 0x7f3adf4369665a9cull, + 0x6b98eeeb4c517f42ull, + 0xa12e44f5de954f24ull, + 0x5789ded4dced978eull, + 0xe4dd20ed27cd3567ull, + 0x9b4e90c365b8790bull, + 0xd486ed6e099f499bull, + 0x3f3d0ccfeaa0c0dcull, + 0x548c746cdb192adaull, + 0x8ce636d8469fe2dcull, + 0xca59ec929549a6a1ull, + 0x647b9878deaba1f0ull, + 0xebbb4b2641c54d34ull, + 0x7be6d2918b680abdull, + 0x02ad265fb4733490ull, + 0xfe1053044faf3486ull, + 0x539ea358ff6b6df3ull, + 0x025d73224a2b5826ull, + 0x7daad302451f41b3ull, + 0x6038455ddb535976ull, + 0x8d6d00a9a728a067ull, + 0xe9f03d61d4965d59ull, + 0x38314b8102daff3bull, + 0x56b335e7893a76f1ull, + 0x1048ca2f415712abull, + 0xa9bc989a891dc173ull, + 0xb741df3ae02836c2ull, + 0x7711e6c6f5830783ull, + 0x8edbf2be9226e24bull, + 0xe4a4b8ba310fc2e2ull, + 0xbc7b67f4a02f23c8ull, + 0x5669b1a9d6d8df17ull, + 0xdd3ebf2e3c516e26ull, + 0x77bdd6def5236c4full, + 0x9aeb54bdffacd65eull, + 0xab676483404a21b8ull, + 0xf7270f77a9d1b3a3ull, + 0x3794e1cdcc7de433ull, + 0x8e2b74d3a06aa56aull, + 0x572698d05b901d40ull, + 0x7bd6c265c1dd5cdfull, + 0xd2f68a53970db82eull, + 0x0e1d5f5dd9bd23bdull, + 0x48814c6813505051ull, + 0x8f2d21a7d4e4a481ull, + 0x144531c871920cf3ull, + 0x45c6f81c7fbc3b2full, + 0xc562f1fc7f07a944ull, + 0xaabdf3d0aa9872e4ull, + 0x8db1f9d827c8df98ull, + 0xea787210e13c16c7ull, + 0xd43f6f582629ff39ull, + 0x6ec7599da4cb298dull, + 0xfa99d7196097dd94ull, + 0xbe3a8a172a62f40dull, + 0x07477bc03d9d5471ull, + 0x03777d1ee44c0fa6ull, + 0x5c6df847b0ae6fd1ull, + 0xc1fc3bc2352d8125ull, + 0x6800e3321d35b697ull, + 0x51cc735e1b0920a8ull, + 0x93dc60a2430c11acull, + 0x13b6bf8ffc4e9e30ull, + 0xada08114e6a01701ull, + 0x1459b7a4254da4cdull, + 0xf7575cd7ededcdfdull, + 0x1e43675ed5ed33eeull, + 0x639f5ff579cc30d4ull, + 0x8f4f75d7eea7e300ull, + 0x518939accd43dadeull, + 0x989a77577fac24e2ull, + 0x86c5e3998c819d51ull, + 0xb84770f9cc15d139ull, + 0x11544010174c2c99ull, + 0xfb238b962405a579ull, + 0xca5bddde9b80cb7bull, + 0xbbe71928190dfab4ull, + 0x0ec620294742b8c8ull, + 0x90bc7a703ed63900ull, + 0x2c8a80e1e85f72bbull, + 0xf19ab262ed2ad914ull, + 0xa233e89fab33793cull, + 0x75b6f59568a958f5ull, + 0x31fb15af9a41aca2ull, + 0xf89db05aa21b3d1cull, + 0x0023d08c52147f63ull, + 0x8e0e3c2aba81e8fdull, + 0xdb2efd057c157e71ull, + 0x1a1797a83e39dfe4ull, + 0x3afc43e1979f507dull, + 0x0e647a8d8abe0936ull, + 0xc8e03f27082eb0daull, + 0xc1b0c11db52da528ull, + 0xadeb52a144f497ceull, + 0x046fc2f53bd97c9bull, + 0x2d587fdf5fae80d5ull, + 0x14036c3fb77fd73eull, + 0x883f768734d14676ull, + 0x212df988a83caffeull, + 0x36b41dac32387e17ull, + 0x9dbee8d7cf804bccull, + 0x34d9a58fb9a35794ull, + 0xda82beba879e3576ull, + 0x0366148280e5adf1ull, + 0x634085dcdba7b174ull, + 0x8451523252446534ull, + 0xc74ce8b4d5175b9aull, + 0x40afebd30a9a4837ull, + 0x7232952ce84e90beull, + 0x7443a6e37b87992dull, + 0xace8a33649218d9aull, + 0x9ad8af9614b75655ull, + 0xd518d9a700179ac2ull, + 0xc7f906d90fd36259ull, + 0xe2c47ec3abd8a12dull, + 0xca05e96fcbbb76c1ull, + 0x7186661c9ddf4973ull, + 0x0146f5f47d5f42c2ull, + 0x74a7c485608ea178ull, + 0x8cb5e3e5f84f3040ull, + 0xb330869dc366037dull, + 0x0dbc4d22f932bbd4ull, + 0xa8460b43946a5ecbull, + 0xcee72c72fe5ddea6ull, + 0x9f953cc7859b2a4eull, + 0x95ea396619e60182ull, + 0xfe9890efa6aa8c3eull, + 0x3c9a5691d1e25799ull, + 0xa54eeb19aa718b62ull, + 0x69907b2ec11d82b7ull, + 0x408c5405984caa65ull, + 0x6f11a21711640470ull, + 0x20b9227a8f53f9aeull, + 0x42df63b7ec442178ull, + 0xbec247f79407d00aull, + 0x2946c31558eab2bcull, + 0x84d045ffa174048eull, + 0x28bad532ba4a450cull, + 0x93ccf0cbaa274d7aull, + 0xff30008411d25158ull, + 0x3845ce6dcc30080aull, + 0xcf5925239b6f3dbaull, + 0x1f148649ed53660dull}; + + + + + + +gs_int32_t nextrandom = 0; +gs_int32_t endrandom = 100; + + +// The first "endrandom" numbers returned are truely random INT64. +// They are perfect for bases of new hash functions, and currently +// we have just enough such random numbers for tabulation based +// 5-universal hashing, or one of the other schemes provided. +// The remaining ones are based on the pseudo-random mrand48() which +// returns a signed 32-bit number. We do not use the unsigned lrand48() +// which only returns 31-bit. +inline static INT64 RandINT64() { + INT64 r,r1; + if (nextrandom>32)+a1; + c = (c0&Prime61)+(c1>>29)+b; + return c; +} // 12 instructions + +/* CWtrick for 32-bit key x with prime 2^61-1 */ +inline static INT64 Hash61bit5univ(INT32 x, Hash61bit5univID index) { + INT64 h; + gs_int32_t i; + + h = index[0]; + for (i=1;i<5;i++) h = MultAddPrime(x,h,index[i]); + h = (h&Prime61)+(h>>61); + if (h>=Prime61) h-=Prime61; + return h; +} + + + +inline static INT64* InitHash61bit5univ() { + gs_int32_t i; + + Hash61bit5univID hid = (INT64*) malloc(5*sizeof(INT64)); + for (i=0;i<5;i++) { + hid[i]=RandINT64(); + hid[i] = (hid[i]&Prime61)+(hid[i]>>61); + if (hid[i]>=Prime61) hid[i]-=Prime61; + } + return hid; +} + +inline static HashTab32bit5univID InitHashTab32bit5univ() { + gs_uint32_t i,j; + HashTab32bit5univID htab; + Hash61bit5univID h61id; + + + htab = (HashTab32bit5univID) malloc(3*sizeof(INT32*)); + for (i=0;i<3;i++) { + htab[i] = (INT32*) malloc(65538*sizeof(INT32)); + h61id = InitHash61bit5univ(); + for (j=0;j<65538;j++) htab[i][j]=Hash61bit5univ(j,h61id); + } + return htab; +} + +/* tabulation based hashing for 32-bit key x using 16-bit characters.*/ +inline INT64 HashTab32bit5univ(INT32 x, HashTab32bit5univID htab) { + INT32 x0, x1, x2; + x0 = x&65535; + x1 = x>>16; + x2 = x0 + x1; + x2 = 2 - (x2>>16) + (x2&65535); // optional compression + return htab[0][x0]^htab[1][x1]^htab[2][x2]; +} // 8 + 4 = 12 instructions + + +/* Tabulation based hashing for 32-bit keys using 16-bit characters.*/ +/* Uses 500KB tables and makes 2 lookups per hash. */ + +inline static HashTab32bitLPID InitHashShortTab32bitLP() { + gs_uint32_t i,j; + HashTab32bitLPID htab; + Hash61bit5univID h61id; + + + htab = (HashTab32bitLPID) malloc(2*sizeof(INT32*)); + for (i=0;i<2;i++) { + htab[i] = (INT32*) malloc(65536*sizeof(INT32)); + h61id = InitHash61bit5univ(); + for (j=0;j<65536;j++) htab[i][j]=Hash61bit5univ(j,h61id); + } + return htab; +} + +/* tabulation based hashing for 32-bit key x using 16-bit characters.*/ +inline INT64 HashShortTab32bitLP(INT32 x, HashTab32bitLPID htab) { + INT32 x0, x1; + x0 = x&65535; + x1 = x>>16; + return htab[0][x0]^htab[1][x1]; +} + + +/* Tabulation based hashing for 32-bit keys using 8-bit characters.*/ +/* Uses 4KB tables and makes 4 lookups per hash. */ + +inline static HashTab32bitLPID InitHashCharTab32bitLP() { + gs_uint32_t i,j; + HashTab32bitLPID htab; + Hash61bit5univID h61id; + + + htab = (HashTab32bitLPID) malloc(4*sizeof(INT32*)); + for (i=0;i<4;i++) { + htab[i] = (INT32*) malloc(256*sizeof(INT32)); + h61id = InitHash61bit5univ(); + for (j=0;j<256;j++) htab[i][j]=Hash61bit5univ(j,h61id); + } + return htab; +} + +inline INT32 HashCharTab32bitLP(INT32 x, HashTab32bitLPID htab) { + INT8 c; + INT32 h; + gs_int32_t i; + + c=x; + h=htab[0][c]; + for (i=1;i<4;i++) { + x>>=8; + c=x; + h=h^htab[i][c]; + } + return h; +} + + +/* Tabulation based hashing for 64-bit keys using 16-bit characters.*/ +/* Uses 2MB tables and makes 4 lookups per hash. */ + + +inline static HashTab64bitLPID InitHashShortTab64bitLP() { + gs_int32_t i,j; + HashTab64bitLPID htab; + Hash61bit5univID h61id; + + + htab = (HashTab64bitLPID) malloc(4*sizeof(INT64*)); + for (i=0;i<4;i++) { + htab[i] = (INT64*) malloc(65536*sizeof(INT64)); + h61id = InitHash61bit5univ(); + for (j=0;j<65536;j++) htab[i][j]=Hash61bit5univ(j,h61id); + h61id = InitHash61bit5univ(); + for (j=0;j<65536;j++) htab[i][j]+=Hash61bit5univ(j,h61id)<<32; + } + return htab; +} + +inline INT64 HashShortTab64bitLP(INT64 x, HashTab64bitLPID htab) { + INT16 c; + INT64 h; + gs_int32_t i; + + c=x; + h=htab[0][c]; + for (i=1;i<4;i++) { + x>>=16; + c=x; + h=h^htab[i][c]; + } + return h; +} + +/* Tabulation based hashing for 64-bit keys using 8-bit characters.*/ +/* Uses 14KB tables and makes 8 lookups per hash. */ + +inline static HashTab64bitLPID InitHashCharTab64bitLP() { + gs_int32_t i,j; + HashTab64bitLPID htab; + Hash61bit5univID h61id; + + + htab = (HashTab64bitLPID) malloc(8*sizeof(INT64*)); + for (i=0;i<8;i++) { + htab[i] = (INT64*) malloc(256*sizeof(INT64)); + h61id = InitHash61bit5univ(); + for (j=0;j<256;j++) htab[i][j]=Hash61bit5univ(j,h61id); + h61id = InitHash61bit5univ(); + for (j=0;j<256;j++) htab[i][j]+=Hash61bit5univ(j,h61id)<<32; + } + return htab; +} + +inline INT64 HashCharTab64bitLP(INT64 x, HashTab64bitLPID htab) { + INT8 c; + INT64 h; + gs_int32_t i; + + c=x; + h=htab[0][c]; + for (i=1;i<8;i++) { + x>>=8; + c=x; + h=h^htab[i][c]; + } + return h; +} + + +/* Tabulation based hashing for 34-bit keys using 10-11-bit characters.*/ +/* Uses 20KB tables and makes 3 lookups per hash. */ + +inline static HashTab32bitLPID InitHashMipTab32bitLP() { + gs_int32_t i,j; + HashTab32bitLPID htab; + Hash61bit5univID h61id; + + + htab = (HashTab32bitLPID) malloc(6*sizeof(INT32*)); + for (i=0;i<2;i++) { + htab[i] = (INT32*) malloc(0x800*sizeof(INT32)); + h61id = InitHash61bit5univ(); + for (j=0;j<0x800;j++) htab[i][j]=(INT32) Hash61bit5univ(j,h61id); + } + for (i=2;i<3;i++) { + htab[i] = (INT32*) malloc(0x400*sizeof(INT32)); + h61id = InitHash61bit5univ(); + for (j=0;j<0x400;j++) htab[i][j]=(INT32) Hash61bit5univ(j,h61id); + } + return htab; +} + +inline INT32 HashMipTab32bitLP(INT32 x, HashTab32bitLPID htab) { + INT32 c; + INT32 h; + gs_int32_t i; + + h=0; + for (i=0;i<2;i++) { + c= x & 0x7FFull; + h=h^htab[i][c]; + x>>=11; + } + c= x & 0x3FFull; + h=h^htab[2][c]; + return h; +} + +/* Tabulation based hashing for 64-bit keys using 10-11-bit characters.*/ +/* Uses 80KB tables and makes 6 lookups per hash. */ + +inline static HashTab64bitLPID InitHashMipTab64bitLP() { + gs_int32_t i,j; + HashTab64bitLPID htab; + Hash61bit5univID h61id; + + + htab = (HashTab64bitLPID) malloc(6*sizeof(INT64*)); + for (i=0;i<4;i++) { + htab[i] = (INT64*) malloc(0x800*sizeof(INT64)); + h61id = InitHash61bit5univ(); + for (j=0;j<0x800;j++) htab[i][j]=Hash61bit5univ(j,h61id); + h61id = InitHash61bit5univ(); + for (j=0;j<0x800;j++) htab[i][j]+=Hash61bit5univ(j,h61id)<<32; + } + for (i=4;i<6;i++) { + htab[i] = (INT64*) malloc(0x400*sizeof(INT64)); + h61id = InitHash61bit5univ(); + for (j=0;j<0x400;j++) htab[i][j]=Hash61bit5univ(j,h61id); + h61id = InitHash61bit5univ(); + for (j=0;j<0x400;j++) htab[i][j]+=Hash61bit5univ(j,h61id)<<32; + } + return htab; +} + +inline INT64 HashMipTab64bitLP(INT64 x, HashTab64bitLPID htab) { + INT64 c; + INT64 h; + gs_int32_t i; + + h=0; + for (i=0;i<4;i++) { + c= x & 0x7FFull; + h=h^htab[i][c]; + x>>=11; + } + for (i=4;i<6;i++) { + c= x & 0x3FFull; + h=h^htab[i][c]; + x>>=10; + } + return h; +} + + + +inline static Hash32bit2univID InitHash32bit2univ() { + Hash32bit2univID hid = (INT64*) malloc(2*sizeof(INT64)); + hid[0]=RandINT64(); + hid[1]=RandINT64(); + return hid; +} + +inline INT32 Hash32bit2univ(INT32 x, Hash32bit2univID hid) { + INT64 H; + INT32 h; + H = (x*hid[0])+hid[1]; + h = H >> 32; + return h; +} + + +// For the string hashing below is for string of 32bit integers, and +// the output is a 2-universal 32-bit number. + +inline static Hash32bit2univID InitStringHash32bit2univ(gs_int32_t length) { + gs_int32_t i; + Hash32bit2univID hid = (INT64*) malloc((length+1)*sizeof(INT64)); + for (i=0;i<=length;i++) hid[i]=RandINT64(); + return hid; +} + + + +//assumes string length even +inline INT32 EvenStringHash32bit2univ(INT32 * x, gs_int32_t length, + Hash32bit2univID hid) { + gs_int32_t i; + INT64 H; + INT32 h; + INT64 xh1,xh2,y; + + H=0; + for (i=0;i> 32; + return h; +} + +//assumes string length odd +inline INT32 OddStringHash32bit2univ(INT32 * x, gs_int32_t length, + Hash32bit2univID hid) { + gs_int32_t i; + INT64 H; + INT32 h; + INT64 xh1,xh2,y; + + H = x[0]*hid[0]; + for (i=1;i> 32; + return h; +} + +//Below we have the generic algorithm for fixed length string hashing +//For shorter strings of length < 6, it is worthwhile using +//specialized versions with fewer tests. +//All versions rely on the some initialization above. +inline INT32 StringHash32bit2univ(INT32 * x, gs_int32_t length, Hash32bit2univID hid) { +// gs_int32_t i; +// INT64 H=0; +// INT32 h; +// for (i=0;i> 32; +// return h; + if (length&1) return OddStringHash32bit2univ(x,length,hid); + else return EvenStringHash32bit2univ(x,length,hid); +} + + +//string of length 2 +inline INT32 String2Hash32bit2univ(INT32 * x,Hash32bit2univID hid) { + INT64 H; + INT32 h; + INT64 xh1,xh2; + + xh1=x[0]+hid[1]; + xh2=x[1]+hid[0]; + H=xh1*xh2; + H=H^hid[2]; + h = H >> 32; + return h; +} + +//string of length 3 +inline INT32 String3Hash32bit2univ(INT32 * x,Hash32bit2univID hid) { + INT64 H; + INT32 h; + INT64 xh1,xh2,y; + + H = x[0]*hid[0]; + xh1=x[1]+hid[2]; + xh2=x[2]+hid[1]; + y=xh1*xh2; + H = H^y; + H=H^hid[3]; + h = H >> 32; + return h; +} + + +inline static VarINT32StringHash32bit2univID InitVarINT32StringHash32bitUniv() { + gs_int32_t i; + VarINT32StringHash32bit2univID hid; + + hid = (VarINT32StringHash32bit2univID) malloc(sizeof(VISHID)); + for (i=0;i<16;i++) hid->str_compr_hid[i]=RandINT64(); + hid->string_hid = RandINT64() & Prime61; + // hid->last_compr_hid = RandINT64() | 0x1ull; + return hid; + } + +inline INT32 VarINT32StringHash32bitUniv(INT32 * x, gs_int32_t length, VarINT32StringHash32bit2univID hid) { + + INT32 h,i,j,d; + gs_int32_t e; + INT64 C,H,M; + INT64 xh1,xh2,y; + INT64 HxM00,HxM01,HxM10,HxM11,C0,C1,C2,CC; + + if (length<16) return StringHash32bit2univ(x,length,hid->str_compr_hid); + H=0; + i=0; + for (;;) { + d=length-i; + C = 0; + j=0; + if (d>16) d=16; + else if (d&1) { + C = x[i]*hid->str_compr_hid[j]; + i++; + j++; + } + for (e=((int) (d>>1));e>0;e--) { + xh1=x[i]+hid->str_compr_hid[j+1]; + xh2=x[i+1]+hid->str_compr_hid[j]; + y=xh1*xh2; + C = C^y; + i+=2; + j+=2; + } + if (i==(INT32) length) { + H<<=4; + H+=C; + H+=((INT64) length)*hid->length_factor; + h=(H>>32); + return h; + } + C>>=4; + H+=C; + M=hid->string_hid; + //Multiply H*M mod Prime61, possibly plus Prime, + //exploiting the structure of Prime61. + //We assume H<2*Prime61 and M<=Prime61, e.g., + //H*M <2^123. + HxM00 = LOW(H)*LOW(M); + HxM01 = LOW(H)*HIGH(M); + HxM10 = HIGH(H)*LOW(M); + HxM11 = HIGH(H)*HIGH(M); //has at most 60 bits + C0 = HxM00+(HxM01<<32)+(HxM10<<32);//overflow doesn't matter here. + C0 = C0&Prime61; //Has at most 61 bits. + C1 = (HxM00>>32)+HxM01+HxM10; //Overflow impossible each <=62 bits + C1 = C1>>29; //Has at most 33 bits. + C2 = HxM11<<3; //Has at most 123-64+3=62 bits. + CC = C0+C1+C2; //At most 63 bits. + H = (CC&Prime61)+(CC>>61); //<2*Prime + } +} + +inline static VarStringHash32bit2univID InitVarStringHash32bitUniv() { + gs_int32_t i; + VarStringHash32bit2univID hid; + + hid = (VarStringHash32bit2univID) malloc(sizeof(VSHID)); + for (i=0;i<16;i++) { + hid->int_str[i]=0; + hid->str_compr_hid[i]=RandINT64(); + } + hid->string_hid = RandINT64() & Prime61; + // hid->last_compr_hid = RandINT64() | 0x1ull; + return hid; + } + +inline INT32 VarStringHash32bitUniv(char * x, gs_int32_t length, + VarStringHash32bit2univID hid) { + + INT32 h,i,l,d,str_ix; + INT64 C,H,M; + INT64 xh1,xh2,y; + INT64 HxM00,HxM01,HxM10,HxM11,C0,C1,C2,CC; + + // Assumes hid->int_str[*]==0 + + if (length<=60) { + memcpy(hid->int_str,x,length); + d=(length+3)>>2; //<16 + h=StringHash32bit2univ(hid->int_str,d,hid->str_compr_hid); + for (i=0;iint_str[i]=0; + return h; + } + H=0; + str_ix=0; + for (;;) { + C = 0; + l=length-str_ix; + if (l>64) l=64; + memcpy(hid->int_str,x+str_ix,l); + str_ix+=l; + d=(l+3)>>2; + i=0; + if (d&1) { + C = hid->int_str[i]*hid->str_compr_hid[i]; + i++; + } + while (iint_str[i]+hid->str_compr_hid[i+1]; + xh2=hid->int_str[i+1]+hid->str_compr_hid[i]; + y=xh1*xh2; + C = C^y; + i+=2; + } + for (i=0;iint_str[i]=0; + if (str_ix==(INT32) length) { + H<<=4; + H+=C; + H+=((INT64) length)*hid->length_factor; + h=(H>>32); + return h; + } + C>>=4; + H+=C; + M=hid->string_hid; + //Multiply H*M mod Prime61, possibly plus Prime, + //exploiting the structure of Prime61. + //We assume H<2*Prime61 and M<=Prime61, e.g., + //H*M <2^123. + HxM00 = LOW(H)*LOW(M); + HxM01 = LOW(H)*HIGH(M); + HxM10 = HIGH(H)*LOW(M); + HxM11 = HIGH(H)*HIGH(M); //has at most 60 bits + C0 = HxM00+(HxM01<<32)+(HxM10<<32);//overflow doesn't matter here. + C0 = C0&Prime61; //Has at most 61 bits. + C1 = (HxM00>>32)+HxM01+HxM10; //Overflow impossible each <=62 bits + C1 = C1>>29; //Has at most 33 bits. + C2 = HxM11<<3; //Has at most 123-64+3=62 bits. + CC = C0+C1+C2; //At most 63 bits. + H = (CC&Prime61)+(CC>>61); //<2*Prime + } +} + + +#endif + diff --git a/include/systat.h b/include/systat.h new file mode 100644 index 0000000..2e4f634 --- /dev/null +++ b/include/systat.h @@ -0,0 +1,25 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef SYSTAT_H +#define SYSTAT_H + +struct systemstat { + gs_int32_t process_priority_level; + gs_int32_t resource_priority_level; + /* ... */ +}; + +#endif diff --git a/include/type_indicators.h b/include/type_indicators.h new file mode 100644 index 0000000..b54581f --- /dev/null +++ b/include/type_indicators.h @@ -0,0 +1,41 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef _TYPE_INDICATORS_DEFINED__ +#define _TYPE_INDICATORS_DEFINED__ + +// WARNING! +// This file replicated in gscpv2/src/ftacmp +// These files must be synched! + + +#define UINT_TYPE 0 +#define INT_TYPE 1 +#define ULLONG_TYPE 2 +#define LLONG_TYPE 3 +#define USHORT_TYPE 4 +#define FLOAT_TYPE 5 +#define BOOL_TYPE 6 +#define VSTR_TYPE 7 +#define TIMEVAL_TYPE 8 +#define IP_TYPE 9 +#define FSTRING_TYPE 10 +#define IPV6_TYPE 11 +#define UNDEFINED_TYPE 12 + + + +#endif + diff --git a/include/vstring.h b/include/vstring.h new file mode 100644 index 0000000..5d0d0e3 --- /dev/null +++ b/include/vstring.h @@ -0,0 +1,51 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + * vstring.h: definition of vstring struct for use in applications and hfta + */ +#ifndef VSTRING_H +#define VSTRING_H + +#include "gsconfig.h" +#include "gstypes.h" + +/* vstring32 has to match string32 definition in rts_string.h however, the data + types differ */ + +struct vstring32 { + gs_uint32_t length; + gs_uint32_t offset; + gs_uint32_t reserved; +}; + +// vstring is the unpacked version of a string, +// vstring32 is its repreentation in a gs record. +// This complication is necessary to support +// old gsdat files. + + +struct vstring { + gs_uint32_t length; + gs_p_t offset; + gs_uint32_t reserved; +}; + +struct hfta_ipv6_str{ + gs_uint32_t v[4]; +}; + + +#endif diff --git a/lib/.keep b/lib/.keep new file mode 100644 index 0000000..e69de29 diff --git a/qlib/CSVEXAMPLELIB/ex2_src.gsql b/qlib/CSVEXAMPLELIB/ex2_src.gsql new file mode 100644 index 0000000..ae84e7d --- /dev/null +++ b/qlib/CSVEXAMPLELIB/ex2_src.gsql @@ -0,0 +1,17 @@ +// Copyright 2014 AT&T Intellectual Property +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// ------------------------------------------- + +select systemTime,uintInPosition1,ullongInPosition2,ipInPosition3,count(*) as Cnt +from [csv].CSV_EXAMPLE +group by systemTime,uintInPosition1,ullongInPosition2,ipInPosition3 diff --git a/qlib/CSVEXAMPLELIB/output_spec.cfg b/qlib/CSVEXAMPLELIB/output_spec.cfg new file mode 100644 index 0000000..4274cf2 --- /dev/null +++ b/qlib/CSVEXAMPLELIB/output_spec.cfg @@ -0,0 +1 @@ +ex2_src,stream,,,,, diff --git a/src/Makefile b/src/Makefile new file mode 100644 index 0000000..fd6b5d4 --- /dev/null +++ b/src/Makefile @@ -0,0 +1,36 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +all: install + +libs: + cd lib ; make + +compiler: + cd ftacmp ; make + +btools: + cd tools ; make + +clean: + cd lib ; make clean + cd ftacmp ; make clean + cd tools ; make clean + rm -ff ../lib/*.a + +install: libs compiler btools + cd lib ; make install + cd ftacmp ; make install + cd tools ; make install diff --git a/src/ftacmp/Makefile b/src/ftacmp/Makefile new file mode 100644 index 0000000..856dd31 --- /dev/null +++ b/src/ftacmp/Makefile @@ -0,0 +1,163 @@ +#!/bin/make + +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +#SHELL = /bin/sh + +.SUFFIXES:.cpp .cc + +CXX=g++ + +INCLUDES = -I../../include -I../../include/hfta +LDLIBS = -L../../lib -lm # -lgscphostaux +C++OPTS = -ggdb -D_BSD_SIGNALS $(INCLUDES) -DPREFILTER_OK -std=c++11 +C++LDOPTS = -ggdb + +# For Driver +CC_ARGS = \ + -g +#CC_OBJECT_FLAG = -o +#CC_COMPILE_FLAG = -c +#CC_EXECUTABLE_FLAG = -o + +CPPFLAGS= $(C++OPTS) + +TARGETS = translate_fta gen_tuple_access +SRCS = $(TARGETS:=.cpp) + +# we need to suppress writable strings warnings on Mac for flex/bison generated C++ code +OS= $(shell uname -s) +ifeq ($(OS),Darwin) + WARN=-Wno-deprecated-writable-strings +endif +ifeq ($(OS),Linux) + WARN=-Wno-write-strings +endif + +all: translate_fta gen_tuple_access interfacelib.a + cp interfacelib.a ../../lib/libgscpinterface.a ; ranlib ../../lib/libgscpinterface.a + +default_targets: $(TARGETS) + +%.tab.o: %.tab.cc + $(CXX) $(CPPFLAGS) $(WARN) $(INCLUDES) -c $< -o $@ + +%lexer.o: %lexer.cc + $(CXX) $(CPPFLAGS) $(WARN) $(INCLUDES) -c $< -o $@ + +%.o: %.cc + $(CXX) $(CPPFLAGS) $(INCLUDES) -c $< -o $@ + +#FTA_OBJECTS:=analyze_fta.o ext_fcns.tab.o ext_fcnslexer.o fta.tab.o ftalexer.o generate_lfta_code.o generate_utils.o parse_schema.o query_plan.o stream_query.o translate_fta.o type_objects.o iface_q.o ifq.tab.o ifqlexer.o res.tab.o reslexer.o niclexer.o nic_def.o nic.tab.o generate_nic_code.o partn.tab.o partnlexer.o niclexer.o parse_partn.o xmllexer.o xml.tab.o field_list.o + +# without niclexer.o +FTA_OBJECTS:=analyze_fta.o ext_fcns.tab.o ext_fcnslexer.o fta.tab.o ftalexer.o generate_lfta_code.o generate_utils.o parse_schema.o query_plan.o stream_query.o translate_fta.o type_objects.o iface_q.o ifq.tab.o ifqlexer.o res.tab.o reslexer.o nic_def.o nic.tab.o generate_nic_code.o partn.tab.o partnlexer.o niclexer.o parse_partn.o xmllexer.o xml.tab.o field_list.o + + +GEN_OBJECTS:=fta.tab.o ftalexer.o generate_utils.o parse_schema.o gen_tuple_access.o type_objects.o + +LIB_OBJECTS:=fta.tab.o ftalexer.o parse_schema.o type_objects.o schemaparser.o + +translate_fta: $(FTA_OBJECTS) + $(CXX) $(CC_ARGS) $(LDLIBS) $(CC_EXECUTABLE_FLAG) $(FTA_OBJECTS) -o $@ + +gen_tuple_access: $(GEN_OBJECTS) + $(CXX) $(CC_ARGS) $(LDLIBS) $(CC_EXECUTABLE_FLAG) $(GEN_OBJECTS) -o $@ + +interfacelib.a: $(LIB_OBJECTS) + ar -r $@ $(LIB_OBJECTS) + +#interfacelib.a: fta.tab.o ftalexer.o parse_schema.o type_objects.o schemaparser.o +# ar -r $@ $? + + +test_interfacelib: test_interfacelib.o interfacelib.a + $(CXX) $(CC_ARGS) $(LDLIBS) $(CC_EXECUTABLE_FLAG) $(LIB_OBJECTS) $@ + +test_interfacelib.cc : schemaparser.h schemaparser_impl.h + +# translate_fta source files +translate_fta.cc : parse_fta.h parse_schema.h parse_ext_fcns.h analyze_fta.h query_plan.h generate_lfta_code.h stream_query.h generate_utils.h nic_def.h generate_nic_code.h parse_partn.h print_plan.h + +analyze_fta.cc : parse_fta.h parse_schema.h parse_ext_fcns.h analyze_fta.h type_objects.h + +ext_fcnslexer.cc : parse_ext_fcns.h ext_fcns.tab.cc.h + +fta.tab.cc : parse_fta.h parse_schema.h + +ftalexer.cc : parse_fta.h parse_schema.h fta.tab.cc.h + +generate_lfta_code.cc : parse_fta.h parse_schema.h analyze_fta.h generate_utils.h query_plan.h generate_lfta_code.h generate_nic_code.h + +generate_utils.cc : generate_utils.h ../../include/lapp.h + +parse_schema.cc : parse_fta.h parse_schema.h type_objects.h + +query_plan.cc : query_plan.h analyze_fta.h generate_utils.h + +stream_query.cc : stream_query.h generate_utils.h analyze_fta.h + +type_objects.cc : type_objects.h + +iface_q.cc : iface_q.h + +ifq.tab.cc : parse_fta.h + +ifqlexer.cc : parse_fta.h ifq.tab.cc.h + +res.tab.cc : iface_q.h + +reslexer.cc : parse_fta.h res.tab.cc.h + +niclexer.cc : nic_def.h nic.tab.cc.h + +nic_def.cc : nic_def.h + +nic.tab.cc : nic_def.h + +generate_nic_code.cc : parse_fta.h parse_schema.h analyze_fta.h generate_utils.h query_plan.h generate_nic_code.h analyze_fta.h + +partn.tab.cc : parse_partn.h + +partnlexer.cc : parse_partn.h partn.tab.cc.h + +niclexer.cc : nic_def.h nic.tab.cc.h + +parse_partn.cc : parse_partn.h parse_schema.h analyze_fta.h + +xmllexer.cc : parse_fta.h xml.tab.hh + +xml.tab.cc : xml_t.h + +field_list.cc : xml_t.h field_list.h + +# gen_tuple_access source files +schemaparser.cc : schemaparser_impl.h ../../include/schemaparser.h parse_fta.h parse_schema.h generate_utils.h ../../include/hfta/host_tuple.h ../../include/lapp.h + +clean: + rm -f *.o core $(TARGETS) ./ii_files/*.ii interfacelib.a ../../bin/gen_tuple_access ../../bin/translate_fta + +del: + rm -f core $(TARGETS) + +cleandrive: + rm -f *.o *.a core driver ./ii_files/*.ii + +install: all + cp translate_fta ../../bin/ ; cp gen_tuple_access ../../bin/ ; cp interfacelib.a ../../lib/libgscpinterface.a ; ranlib ../../lib/libgscpinterface.a + +# DO NOT DELETE THIS LINE -- make depend depends on it. + diff --git a/src/ftacmp/analyze_fta.cc b/src/ftacmp/analyze_fta.cc new file mode 100644 index 0000000..8c9fd3b --- /dev/null +++ b/src/ftacmp/analyze_fta.cc @@ -0,0 +1,5897 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include + +#include "parse_fta.h" +#include "parse_schema.h" +#include "parse_ext_fcns.h" + + +#include"analyze_fta.h" + +#include"type_objects.h" + +#include +#include + +using namespace std; + +extern string hostname; // name of the current host + +// Utility function + +string int_to_string(int i){ + string ret; + char tmpstr[100]; + sprintf(tmpstr,"%d",i); + ret=tmpstr; + return(ret); +} + + +// Globals + +// These represent derived information from the +// query analysis stage. I extract them from a class, +// perhaps this is dangerous. + +static gb_table *gb_tbl=NULL; // Table of all group-by attributes. +static aggregate_table *aggr_tbl=NULL; // Table of all referenced aggregates. + +// static cplx_lit_table *complex_literals=NULL; // Table of literals with constructors. +static param_table *param_tbl=NULL; // Table of all referenced parameters. + +vector partial_fcns_list; +int wh_partial_start, wh_partial_end; +int gb_partial_start, gb_partial_end; +int aggr_partial_start, aggr_partial_end; +int sl_partial_start, sl_partial_end; + + +// Infer the table of a column refrence and return the table ref. +// First, extract the +// field name and table name. If no table name is used, +// search all tables to try to find a unique match. +// Of course, plenty of error checking. + +// Return the set of tablevar indices in the FROM clause +// which contain a field with the same name. +vector find_source_tables(string field, tablevar_list_t *fm, table_list *Schema){ + int i; + vector tv; +// vector tn = fm->get_schema_names(); + vector tn = fm->get_schema_refs(); +// printf("Calling find_source_tables on field %s\n",field.c_str()); + for(i=0;icontains_field(Schema->find_tbl(tn[i]), field) ){ + if(Schema->contains_field(tn[i], field) ){ + tv.push_back(i); +// printf("\tfound in table %s\n",tn[i].c_str()); + } + } + return(tv); +} + +int infer_tablevar_from_ifpref(ifpref_t *ir, tablevar_list_t *fm){ + int i; + string tname = ir->get_tablevar(); + if(tname ==""){ + if(fm->size()==1) return 0; + fprintf(stderr,"ERROR, interface parameter %s has no tablevar specified and there is more than one table variable in the FROM clause.\n",ir->to_string().c_str()); + return -1; + } + for(i=0;isize();++i){ + if(tname == fm->get_tablevar_name(i)) + return i; + } + fprintf(stderr,"ERROR, interface parameter %s has no matching table variable in the FROM clause.\n",ir->to_string().c_str()); + return -1; +} + + +// compute the index of the tablevar in the from clause that the +// colref is in. +// return -1 if no tablevar can be imputed. +int infer_tablevar_from_colref(colref_t *cr, tablevar_list_t *fm, table_list *schema){ + int i; + string table_name; + int table_ref; + vector tv; + vector fm_tbls = fm->get_table_list(); + + string field = cr->get_field(); + +// printf("Calling infer_tablevar_from_colref on field %s.\n",field.c_str()); + if(cr->uses_default_table() ){ + tv = find_source_tables(field, fm, schema); + if(tv.size() > 1){ + fprintf(stderr,"ERROR, line %d, character %d : field %s exists in multiple table variables: ", + cr->get_lineno(), cr->get_charno(),field.c_str() ); + for(i=0;ito_string().c_str() ); + } + fprintf(stderr,"\n\tYou must specify one of these.\n"); + return(-1); + } + if(tv.size() == 0){ + fprintf(stderr,"ERROR, line %d, character %d: field %s does not exist in any table.\n", + cr->get_lineno(), cr->get_charno(),field.c_str() ); + return(-1); + } + + return(tv[0]); + } + +// The table source is named -- but is it a schema name +// or a var name? + + string interface = cr->get_interface(); + table_name = cr->get_table_name(); + +// if interface is not specified, prefer to look at the tablevar names +// Check for duplicates. + if(interface==""){ + for(i=0;iget_var_name()) + tv.push_back(i); + } + if(tv.size() > 1){ + fprintf(stderr,"ERROR, there are two or more table variables for column ref %s.%s (line %d, char %d).\n",table_name.c_str(), field.c_str(), cr->get_lineno(), cr->get_charno() ); + return(-1); + } + if(tv.size() == 1) return(tv[0]); + } + +// Tableref not found by looking at tableref vars, or an interface +// was specified. Try to match on schema and interface. +// Check for duplicates. + for(i=0;iget_var_name() && interface == fm_tbls[i]->get_interface()) + tv.push_back(i); + } + if(tv.size() > 1){ + fprintf(stderr,"ERROR, (line %d, char %d) there are two or more table variables whose schemas match for column ref \n", + cr->get_lineno(), cr->get_charno() ); + if(interface != "") fprintf(stderr,"%s.",interface.c_str()); + fprintf(stderr,"%s.%s\n",table_name.c_str(), field.c_str()); + return(-1); + } + + if(tv.size() == 0 ){ + fprintf(stderr,"ERROR, line %d, character %d : no table reference found for column ref ", cr->get_lineno(), cr->get_charno()); + if(interface != "") fprintf(stderr,"%s.",interface.c_str()); + fprintf(stderr,"%s.%s\n",table_name.c_str(), field.c_str()); + return(-1) ; + } + + return(tv[0]); +} + + +// Reset temporal properties of a scalar expression +void reset_temporal(scalarexp_t *se){ + col_id ci; + vector operands; + int o; + + se->get_data_type()->reset_temporal(); + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + case SE_COLREF: + return; + case SE_UNARY_OP: + reset_temporal(se->get_left_se()); + return; + case SE_BINARY_OP: + reset_temporal(se->get_left_se()); + reset_temporal(se->get_right_se()); + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: + reset_temporal(se->get_left_se()); + return; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } +} + +// Verify that column references exist in their +// declared tables. As a side effect, assign +// their data types. Other side effects : +// +// return -1 on error + +int verify_colref(scalarexp_t *se, tablevar_list_t *fm, + table_list *schema, gb_table *gtbl){ + int l_ret, r_ret; + int gb_ref; + colref_t *cr; + ifpref_t *ir; + string field, table_source, type_name; + data_type *dt; + vector tn; + vector tv; + int table_var; + int o; + vector operands; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + return(1); + case SE_IFACE_PARAM: + ir = se->get_ifpref(); + table_var = infer_tablevar_from_ifpref(ir, fm); + if(table_var < 0) return(table_var); + ir->set_tablevar_ref(table_var); + return(1); + case SE_UNARY_OP: + return( verify_colref(se->get_left_se(), fm, schema, gtbl) ); + case SE_BINARY_OP: + l_ret = verify_colref(se->get_left_se(), fm, schema, gtbl); + r_ret = verify_colref(se->get_right_se(), fm, schema, gtbl); + if( (l_ret < 0 ) || (r_ret < 0) ) return(-1); + return(1); + case SE_COLREF: + cr = se->get_colref(); + field = cr->get_field(); + +// Determine if this is really a GB ref. +// (the parser can only see that its a colref). + if(gtbl != NULL){ + gb_ref = gtbl->find_gb(cr, fm, schema); + }else{ + gb_ref = -1; + } + + se->set_gb_ref(gb_ref); + + if(gb_ref < 0){ +// Its a colref, verify its existance and +// record the data type. + table_var = infer_tablevar_from_colref(cr,fm,schema); + if(table_var < 0) return(table_var); + + // Store the table ref in the colref. + cr->set_tablevar_ref(table_var); + cr->set_schema_ref(fm->get_schema_ref(table_var)); + cr->set_interface(""); + cr->set_table_name(fm->get_tablevar_name(table_var)); + + + type_name = schema->get_type_name(cr->get_schema_ref(), field); + param_list *modifiers = schema->get_modifier_list(cr->get_schema_ref(), field); + dt = new data_type(type_name, modifiers); + se->set_data_type(dt); + }else{ +// Else, its a gbref, use the GB var's data type. + se->set_data_type(gtbl->get_data_type(gb_ref)); + } + + return(1); + case SE_AGGR_STAR: + return(1); + case SE_AGGR_SE: + return( verify_colref(se->get_left_se(), fm, schema, gtbl) ); + case SE_FUNC: + operands = se->get_operands(); + r_ret = 1; + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + return(-1); + } + return(-1); +} + + +int verify_predicate_colref(predicate_t *pr, tablevar_list_t *fm, table_list *schema, gb_table *gtbl){ + int l_ret, r_ret; + std::vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + return(verify_colref(pr->get_left_se(),fm,schema, gtbl) ); + case PRED_COMPARE: + l_ret = verify_colref(pr->get_left_se(),fm,schema, gtbl) ; + r_ret = verify_colref(pr->get_right_se(),fm,schema, gtbl) ; + if( (l_ret < 0) || (r_ret < 0) ) return(-1); + return(1); + case PRED_UNARY_OP: + return(verify_predicate_colref(pr->get_left_pr(),fm,schema, gtbl)); + case PRED_BINARY_OP: + l_ret = verify_predicate_colref(pr->get_left_pr(),fm,schema, gtbl) ; + r_ret = verify_predicate_colref(pr->get_right_pr(),fm,schema, gtbl) ; + if( (l_ret < 0) || (r_ret < 0) ) return(-1); + return(1); + case PRED_FUNC: + op_list = pr->get_op_list(); + l_ret = 0; + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } + + return(-1); +} + + +bool literal_only_se(scalarexp_t *se){ // really only literals. + int o; + vector operands; + + if(se == NULL) return(1); + switch(se->get_operator_type()){ + case SE_LITERAL: + return(true); + case SE_PARAM: + return(false); + case SE_IFACE_PARAM: + return(false); + case SE_UNARY_OP: + return( literal_only_se(se->get_left_se()) ); + case SE_BINARY_OP: + return( literal_only_se(se->get_left_se()) && + literal_only_se(se->get_right_se()) ); + case SE_COLREF: + return false; + case SE_AGGR_STAR: + return false; + case SE_AGGR_SE: + return false; + return(1); + case SE_FUNC: + return false; + default: + return false; + } + return false; +} + + + + +// Verify that column references exist in their +// declared tables. As a side effect, assign +// their data types. Other side effects : +// + +int bind_to_schema_se(scalarexp_t *se, tablevar_list_t *fm, table_list *schema){ + int l_ret, r_ret; + int gb_ref; + colref_t *cr; + string field, table_source, type_name; + data_type *dt; + vector tn; + vector tv; + int tablevar_ref; + int o; + vector operands; + + if(se == NULL) return(1); + + switch(se->get_operator_type()){ + case SE_LITERAL: + return(1); + case SE_PARAM: + return(1); + case SE_IFACE_PARAM: + return(1); + case SE_UNARY_OP: + return( bind_to_schema_se(se->get_left_se(), fm, schema) ); + case SE_BINARY_OP: + l_ret = bind_to_schema_se(se->get_left_se(), fm, schema); + r_ret = bind_to_schema_se(se->get_right_se(), fm, schema); + if( (l_ret < 0 ) || (r_ret < 0) ) return(-1); + return(1); + case SE_COLREF: + if(se->is_gb()) return(1); // gb ref not a colref. + + cr = se->get_colref(); + field = cr->get_field(); + + tablevar_ref = infer_tablevar_from_colref(cr,fm,schema); + if(tablevar_ref < 0){ + return(tablevar_ref); + }else{ + // Store the table ref in the colref. + cr->set_tablevar_ref(tablevar_ref); + cr->set_schema_ref(fm->get_schema_ref(tablevar_ref)); + cr->set_interface(""); + cr->set_table_name(fm->get_tablevar_name(tablevar_ref)); + +// Check the data type + type_name = schema->get_type_name(cr->get_schema_ref(), field); + param_list *modifiers = schema->get_modifier_list(cr->get_schema_ref(), field); + data_type dt(type_name, modifiers); +// if(! dt.equals(se->get_data_type()) ){ +// if(! dt.subsumes_type(se->get_data_type()) ){ + if(! se->get_data_type()->subsumes_type(&dt) ){ + fprintf(stderr,"INTERNAL ERROR in bind_to_schema_se: se's type is %d, table's is %d, colref is %s.\n", + dt.type_indicator(), se->get_data_type()->type_indicator(), cr->to_string().c_str()); + return(-1); + } + } + return(1); + case SE_AGGR_STAR: + return(1); + case SE_AGGR_SE: // Probably I should just return, + // aggregate se's are explicitly bound to the schema. +// return( bind_to_schema_se(se->get_left_se(), fm, schema, gtbl) ); + return(1); + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return 1; + + operands = se->get_operands(); + r_ret = 1; + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + return(-1); + } + return(-1); +} + + +int bind_to_schema_pr(predicate_t *pr, tablevar_list_t *fm, table_list *schema){ + int l_ret, r_ret; + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + return(bind_to_schema_se(pr->get_left_se(),fm,schema) ); + case PRED_COMPARE: + l_ret = bind_to_schema_se(pr->get_left_se(),fm,schema) ; + r_ret = bind_to_schema_se(pr->get_right_se(),fm,schema) ; + if( (l_ret < 0) || (r_ret < 0) ) return(-1); + return(1); + case PRED_UNARY_OP: + return(bind_to_schema_pr(pr->get_left_pr(),fm,schema)); + case PRED_BINARY_OP: + l_ret = bind_to_schema_pr(pr->get_left_pr(),fm,schema) ; + r_ret = bind_to_schema_pr(pr->get_right_pr(),fm,schema) ; + if( (l_ret < 0) || (r_ret < 0) ) return(-1); + return(1); + case PRED_FUNC: + op_list = pr->get_op_list(); + l_ret = 0; + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } + + return(-1); +} + + + + + + +// verify_colref assigned data types to the column refs. +// Now assign data types to all other nodes in the +// scalar expression. +// +// return -1 on error + +temporal_type compute_se_temporal(scalarexp_t *se, map &tcol){ + int l_ret, r_ret; + data_type *dt; + bool bret; + vector operands; + vector odt; + int o, fcn_id; + vector handle_ind; + + switch(se->get_operator_type()){ + case SE_LITERAL: + return(constant_t); + case SE_PARAM: + return(varying_t); + case SE_IFACE_PARAM: + return(varying_t); // actually, this should not be called. + case SE_UNARY_OP: + return data_type::compute_temporal_type( + compute_se_temporal(se->get_left_se(), tcol), se->get_op() + ); + case SE_BINARY_OP: + return data_type::compute_temporal_type( + compute_se_temporal(se->get_left_se(), tcol), + compute_se_temporal(se->get_right_se(), tcol), + se->get_left_se()->get_data_type()->get_type(), + se->get_right_se()->get_data_type()->get_type(), + se->get_op() + ); + case SE_COLREF: + { + col_id cid(se->get_colref() ); + if(tcol.count(cid) > 0){ return tcol[cid]; + }else{ return varying_t;} + } + case SE_AGGR_STAR: + case SE_AGGR_SE: + case SE_FUNC: + default: + return varying_t; + } + return(varying_t); +} + + + +// verify_colref assigned data types to the column refs. +// Now assign data types to all other nodes in the +// scalar expression. +// +// return -1 on error + +int assign_data_types(scalarexp_t *se, table_list *schema, + table_exp_t *fta_tree, ext_fcn_list *Ext_fcns){ + int l_ret, r_ret; + data_type *dt; + bool bret; + vector operands; + vector odt; + int o, fcn_id; + vector handle_ind; + vector constant_ind; + + switch(se->get_operator_type()){ + case SE_LITERAL: + dt = new data_type( se->get_literal()->get_type() ); + se->set_data_type(dt); + if( ! dt->is_defined() ){ + fprintf(stderr,"ERROR, Literal type is undefined, line =%d, char = %d, literal=%s\n", + se->get_literal()->get_lineno(),se->get_literal()->get_charno(), se->get_literal()->to_string().c_str() ); + return(-1); + }else{ + return(1); + } + case SE_PARAM: + { + string pname = se->get_param_name(); + dt = param_tbl->get_data_type(pname); +// A SE_PARRAM can change its value mid-query so using one +// to set a window is dangerous. TODO check for this and issue a warning. + dt->set_temporal(constant_t); + se->set_data_type(dt); + if( ! dt->is_defined() ){ + fprintf(stderr,"ERROR, parameter %s has undefined type, line =%d, char = %d\n", + pname.c_str(), se->get_lineno(),se->get_charno() ); + return(-1); + } + return(1); + } + case SE_IFACE_PARAM: + dt = new data_type( "STRING" ); + se->set_data_type(dt); + return(1); + case SE_UNARY_OP: + l_ret = assign_data_types(se->get_left_se(), schema, fta_tree, Ext_fcns); + if(l_ret < 0) return -1; + + dt = new data_type(se->get_left_se()->get_data_type(),se->get_op() ); + se->set_data_type(dt); + if( ! dt->is_defined() ){ + fprintf(stderr,"ERROR, unary operator %s not defined for type %s, line=%d, char = %d\n", + se->get_op().c_str(), se->get_left_se()->get_data_type()->to_string().c_str(), + se->get_lineno(), se->get_charno() ); + return(-1); + }else{ + return(1); + } + case SE_BINARY_OP: + l_ret = assign_data_types(se->get_left_se(), schema, fta_tree, Ext_fcns); + r_ret = assign_data_types(se->get_right_se(), schema, fta_tree, Ext_fcns); + if( (l_ret < 0 ) || (r_ret < 0) ) return(-1); + + dt = new data_type(se->get_left_se()->get_data_type(),se->get_right_se()->get_data_type(),se->get_op() ); + se->set_data_type(dt); + if( ! dt->is_defined() ){ + fprintf(stderr,"ERROR, Binary operator %s not defined for type %s, %s line=%d, char = %d\n", + se->get_op().c_str(), se->get_left_se()->get_data_type()->to_string().c_str(), + se->get_right_se()->get_data_type()->to_string().c_str(), + se->get_lineno(), se->get_charno() ); + return(-1); + }else{ + return(1); + } + case SE_COLREF: + dt = se->get_data_type(); + bret = dt->is_defined(); + if( bret ){ + return(1); + }else{ + fprintf(stderr,"ERROR, column reference type is undefined, line =%d, char = %d, colref=%s\n", + se->get_colref()->get_lineno(),se->get_colref()->get_charno(), se->get_colref()->to_string().c_str() ); + return(-1); + } + case SE_AGGR_STAR: + dt = new data_type("Int"); // changed Uint to Int + se->set_data_type(dt); + return(1); + case SE_AGGR_SE: + l_ret = assign_data_types(se->get_left_se(), schema, fta_tree, Ext_fcns); + if(l_ret < 0) return -1; + + dt = new data_type(); + dt->set_aggr_data_type(se->get_op(), se->get_left_se()->get_data_type()); + se->set_data_type(dt); + + if( ! dt->is_defined() ){ + fprintf(stderr,"ERROR, aggregate %s not defined for type %s, line=%d, char = %d\n", + se->get_op().c_str(), se->get_left_se()->get_data_type()->to_string().c_str(), + se->get_lineno(), se->get_charno() ); + return(-1); + }else{ + return(1); + } + case SE_FUNC: + + operands = se->get_operands(); + r_ret = 1; + for(o=0;oget_data_type()); + if(l_ret < 0) r_ret = -1; + } + if(r_ret < 0) return(r_ret); + +// Is it an aggregate extraction function? + fcn_id = Ext_fcns->lookup_extr(se->get_op(), odt); + if(fcn_id >= 0){ + int actual_fcn_id = Ext_fcns->get_actual_fcn_id(fcn_id); + int subaggr_id = Ext_fcns->get_subaggr_id(fcn_id); + int n_fcn_params = Ext_fcns->get_nparams(actual_fcn_id); +// Construct a se for the subaggregate. + vector op_a; + int n_aggr_oprs = operands.size()-n_fcn_params+1; + for(o=0;o handle_a = Ext_fcns->get_handle_indicators(subaggr_id); + for(o=0;oget_operator_type() != SE_LITERAL && + op_a[o]->get_operator_type() != SE_IFACE_PARAM && + op_a[o]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of UDAF %s (extractor %s) must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, Ext_fcns->get_fcn_name(subaggr_id).c_str(), se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + vector is_const_a=Ext_fcns->get_const_indicators(subaggr_id); + for(o=0;oget_data_type()->get_temporal() != constant_t){ + fprintf(stderr,"ERROR, the %d-th parameter of UDAF %s (extractor %s) must be constant.\n Line=%d, char=%d.\n", + o+1, Ext_fcns->get_fcn_name(subaggr_id).c_str(), se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + + scalarexp_t *se_a = new scalarexp_t(Ext_fcns->get_fcn_name(subaggr_id).c_str(), op_a); + se_a->set_fcn_id(subaggr_id); + se_a->set_data_type(Ext_fcns->get_fcn_dt(subaggr_id)); + se_a->set_aggr_id(0); // label this as a UDAF. + + +// Change this se to be the actual function + vector op_f; + op_f.push_back(se_a); + for(o=n_aggr_oprs;o handle_f = Ext_fcns->get_handle_indicators(actual_fcn_id); + for(o=0;oget_operator_type() != SE_LITERAL && + op_f[o]->get_operator_type() != SE_IFACE_PARAM && + op_f[o]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of fcn %s (extractor %s) must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, Ext_fcns->get_fcn_name(actual_fcn_id).c_str(), se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + vector is_const_f=Ext_fcns->get_const_indicators(actual_fcn_id); + for(o=0;oget_data_type()->get_temporal() != constant_t){ + fprintf(stderr,"ERROR, the %d-th parameter of fcn %s (extractor %s) must be constant.\n Line=%d, char=%d.\n", + o+1, Ext_fcns->get_fcn_name(actual_fcn_id).c_str(), se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + + se->param_list = op_f; + se->op = Ext_fcns->get_fcn_name(actual_fcn_id); + se->set_fcn_id(actual_fcn_id); + se->set_data_type(Ext_fcns->get_fcn_dt(actual_fcn_id)); + return(1); + } + if(fcn_id == -2){ + fprintf(stderr,"Warning: multiple subsuming aggregate extractors found for %s\n",se->get_op().c_str()); + } + +// Is it a UDAF? + fcn_id = Ext_fcns->lookup_udaf(se->get_op(), odt); + if(fcn_id >= 0){ + se->set_fcn_id(fcn_id); + se->set_data_type(Ext_fcns->get_fcn_dt(fcn_id)); + se->set_aggr_id(0); // label this as a UDAF. +// Finally, verify that all HANDLE parameters are literals or params. + handle_ind = Ext_fcns->get_handle_indicators(se->get_fcn_id() ); + for(o=0;oget_operator_type() != SE_LITERAL && + operands[o]->get_operator_type() != SE_IFACE_PARAM && + operands[o]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of UDAF %s must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + constant_ind = Ext_fcns->get_const_indicators(se->get_fcn_id()); + for(o=0;oget_data_type()->get_temporal() != constant_t){ + fprintf(stderr,"ERROR, the %d-th parameter of UDAF %s must be constant.\n Line=%d, char=%d.\n", + o+1, se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + +// UDAFS as superaggregates not yet supported. +if(se->is_superaggr()){ +fprintf(stderr,"WARNING: UDAF superagggregates (%s) are not yet supported, ignored.\n Line=%d, char=%d.\n", se->get_op().c_str(),se->get_lineno(), se->get_charno()); +se->set_superaggr(false); +} + return(1); + } + if(fcn_id == -2){ + fprintf(stderr,"Warning: multiple subsuming UDAFs found for %s\n",se->get_op().c_str()); + } + +// Is it a stateful fcn? + fcn_id = Ext_fcns->lookup_sfun(se->get_op(), odt); + if(fcn_id >= 0){ + se->set_fcn_id(fcn_id); + se->set_data_type(Ext_fcns->get_fcn_dt(fcn_id)); + se->set_storage_state(Ext_fcns->get_storage_state(fcn_id)); // label as sfun +// Finally, verify that all HANDLE parameters are literals or params. + handle_ind = Ext_fcns->get_handle_indicators(se->get_fcn_id() ); + for(o=0;oget_operator_type() != SE_LITERAL && + operands[o]->get_operator_type() != SE_IFACE_PARAM && + operands[o]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of UDAF %s must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + constant_ind = Ext_fcns->get_const_indicators(se->get_fcn_id()); + for(o=0;oget_data_type()->get_temporal() != constant_t){ + fprintf(stderr,"ERROR, the %d-th parameter of UDAF %s must be constant.\n Line=%d, char=%d.\n", + o+1, se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + + if(se->is_superaggr()){ + fprintf(stderr,"WARNING: stateful function %s cannot be marked as a superaggregate, ignored.\n Line=%d, char=%d.\n", se->get_op().c_str(),se->get_lineno(), se->get_charno()); + } + return(1); + } + if(fcn_id == -2){ + fprintf(stderr,"Warning: multiple stateful fcns found for %s\n",se->get_op().c_str()); + } + + +// Is it a regular function? + fcn_id = Ext_fcns->lookup_fcn(se->get_op(), odt); + if( fcn_id < 0 ){ + fprintf(stderr,"ERROR, no external function %s(",se->get_op().c_str()); + for(o=0;o0) fprintf(stderr,", "); + fprintf(stderr,"%s",operands[o]->get_data_type()->to_string().c_str()); + } + fprintf(stderr,") is defined, line %d, char %d\n", se->get_lineno(), se->get_charno() ); + if(fcn_id == -2) fprintf(stderr,"(multiple subsuming functions found)\n"); + + return(-1); + } + + se->set_fcn_id(fcn_id); + dt = Ext_fcns->get_fcn_dt(fcn_id); + + if(! dt->is_defined() ){ + fprintf(stderr,"ERROR, external function %s(",se->get_op().c_str()); + for(o=0;o0) fprintf(stderr,", "); + fprintf(stderr,"%s",operands[o]->get_data_type()->to_string().c_str()); + } + fprintf(stderr,") has undefined type, line %d, char %d\n", se->get_lineno(), se->get_charno() ); + return(-1); + } + +// Finally, verify that all HANDLE parameters are literals or params. + handle_ind = Ext_fcns->get_handle_indicators(se->get_fcn_id() ); + for(o=0;oget_operator_type() != SE_LITERAL && + operands[o]->get_operator_type() != SE_IFACE_PARAM && + operands[o]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of function %s must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + constant_ind = Ext_fcns->get_const_indicators(se->get_fcn_id()); + for(o=0;oget_data_type()->get_temporal() != constant_t){ + fprintf(stderr,"ERROR, the %d-th parameter of function %s must be constant.\n Line=%d, char=%d.\n", + o+1, se->get_op().c_str(),se->get_lineno(), se->get_charno()); + return(-1); + } + } + } + + + if(se->is_superaggr()){ + fprintf(stderr,"WARNING: function %s cannot be marked as a superaggregate, ignored.\n Line=%d, char=%d.\n", se->get_op().c_str(),se->get_lineno(), se->get_charno()); + } + + se->set_data_type(dt); + return(1); + default: + fprintf(stderr,"INTERNAL ERROR in assign_data_types, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + return(-1); + } + return(-1); +} + + +int assign_predicate_data_types(predicate_t *pr, table_list *schema, + table_exp_t *fta_tree, ext_fcn_list *Ext_fcns){ + int l_ret, r_ret; + int i; + data_type *dt, *dtl; + vector odt; + vector litl; + vector operands; + vector handle_ind; + vector constant_ind; + int o, fcn_id; + + switch(pr->get_operator_type()){ + case PRED_IN: + l_ret = assign_data_types(pr->get_left_se(),schema, fta_tree, Ext_fcns); // , ext_fcn_set); + litl = pr->get_lit_vec(); + dt = pr->get_left_se()->get_data_type(); + + for(i=0;iget_type() ); + if( ! dt->is_comparable(dtl,pr->get_op()) ){ + fprintf(stderr,"ERROR line %d, char %d: IS_IN types must be comparable (lhs type is %s, rhs type is %s).\n", + litl[i]->get_lineno(), litl[i]->get_charno(), dt->to_string().c_str(),dtl->to_string().c_str() ); + delete dtl; + return(-1); + } + delete dtl; + } + return(1); + case PRED_COMPARE: + l_ret = assign_data_types(pr->get_left_se(),schema, fta_tree, Ext_fcns); // , ext_fcn_set) ; + r_ret = assign_data_types(pr->get_right_se(),schema, fta_tree, Ext_fcns); // , ext_fcn_set) ; + if( (l_ret < 0) || (r_ret < 0) ) return(-1); + + if( !(pr->get_left_se()->get_data_type()->is_comparable(pr->get_right_se()->get_data_type(), pr->get_op() ) )){ + fprintf(stderr,"ERROR line %d, char %d, operands of comparison must have comparable types (%s %s %s).\n", + pr->get_lineno(), pr->get_charno(), pr->get_left_se()->get_data_type()->to_string().c_str(), + pr->get_right_se()->get_data_type()->to_string().c_str(), pr->get_op().c_str() ); + return(-1); + }else{ + return(1); + } + case PRED_UNARY_OP: + return(assign_predicate_data_types(pr->get_left_pr(),schema,fta_tree, Ext_fcns)); // , ext_fcn_set)); + case PRED_BINARY_OP: + l_ret = assign_predicate_data_types(pr->get_left_pr(),schema,fta_tree, Ext_fcns); // , ext_fcn_set); + r_ret = assign_predicate_data_types(pr->get_right_pr(),schema,fta_tree, Ext_fcns); // , ext_fcn_set); + if( (l_ret < 0) || (r_ret < 0) ) return(-1); + return(1); + case PRED_FUNC: + operands = pr->get_op_list(); + r_ret = 1; + for(o=0;oget_data_type()); + if(l_ret < 0) r_ret = -1; + } + if(r_ret < 0) return(r_ret); + + fcn_id = Ext_fcns->lookup_pred(pr->get_op(), odt); + if( fcn_id < 0 ){ + fprintf(stderr,"ERROR, no external predicate %s(",pr->get_op().c_str()); + for(o=0;o0) fprintf(stderr,", "); + fprintf(stderr,"%s",operands[o]->get_data_type()->to_string().c_str()); + } + fprintf(stderr,") is defined, line %d, char %d\n", pr->get_lineno(), pr->get_charno() ); + if(fcn_id == -2) fprintf(stderr,"(multiple subsuming predicates found)\n"); + return(-1); + } + +// ext_fcn_set.insert(fcn_id); + pr->set_fcn_id(fcn_id); + +// Finally, verify that all HANDLE parameters are literals or params. + handle_ind = Ext_fcns->get_handle_indicators(pr->get_fcn_id() ); + for(o=0;oget_operator_type() != SE_LITERAL && + operands[o]->get_operator_type() != SE_IFACE_PARAM && + operands[o]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of predicate %s must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, pr->get_op().c_str(),pr->get_lineno(), pr->get_charno()); + exit(1); + } + } + } + constant_ind = Ext_fcns->get_const_indicators(pr->get_fcn_id()); + for(o=0;oget_data_type()->get_temporal() != constant_t){ + fprintf(stderr,"ERROR, the %d-th parameter of predicate %s must be constant.\n Line=%d, char=%d.\n", + o+1, pr->get_op().c_str(),pr->get_lineno(), pr->get_charno()); + exit(1); + } + } + } + + +// Check if this predicate function is special sampling function + pr->is_sampling_fcn = Ext_fcns->is_sampling_fcn(pr->get_fcn_id()); + + + return(l_ret); + default: + fprintf(stderr,"INTERNAL ERROR in assign_predicate_data_types, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + } + + return(-1); +} + + + +///////////////////////////////////////////////////////////////////// +//////////////// Make a deep copy of a se / pred tree +///////////////////////////////////////////////////////////////////// + + +// duplicate a select element +select_element *dup_select(select_element *sl, aggregate_table *aggr_tbl){ + return new select_element(dup_se(sl->se,aggr_tbl),sl->name.c_str()); +} + +// duplicate a scalar expression. +scalarexp_t *dup_se(scalarexp_t *se, + aggregate_table *aggr_tbl + ){ + int p; + vector operand_list; + vector dt_signature; + scalarexp_t *ret_se, *l_se, *r_se; + + switch(se->get_operator_type()){ + case SE_LITERAL: + ret_se = new scalarexp_t(se->get_literal()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_PARAM: + ret_se = scalarexp_t::make_param_reference(se->get_op().c_str()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_IFACE_PARAM: + ret_se = scalarexp_t::make_iface_param_reference(se->get_ifpref()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_COLREF: + ret_se = new scalarexp_t(se->get_colref()->duplicate()); + ret_se->rhs.scalarp = se->rhs.scalarp; // carry along notation + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_UNARY_OP: + l_se = dup_se(se->get_left_se(), aggr_tbl); + ret_se = new scalarexp_t(se->get_op().c_str(), l_se); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_BINARY_OP: + l_se = dup_se(se->get_left_se(), aggr_tbl); + r_se = dup_se(se->get_right_se(), aggr_tbl); + + ret_se = new scalarexp_t(se->get_op().c_str(), l_se, r_se); + ret_se->use_decorations_of(se); + + return(ret_se); + + case SE_AGGR_STAR: + ret_se = scalarexp_t::make_star_aggr(se->get_op().c_str()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_AGGR_SE: + l_se = dup_se(se->get_left_se(), aggr_tbl); + ret_se = scalarexp_t::make_se_aggr(se->get_op().c_str(), l_se); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_FUNC: + { + operand_list = se->get_operands(); + vector new_operands; + for(p=0;pget_op().c_str(), new_operands); + ret_se->use_decorations_of(se); + return(ret_se); + } + + default: + printf("INTERNAL ERROR in dup_se: operator type %d\n",se->get_operator_type()); + exit(1); + break; + } + return(NULL); + +} + + + +predicate_t *dup_pr(predicate_t *pr, + aggregate_table *aggr_tbl + ){ + + vector llist; + scalarexp_t *se_l, *se_r; + predicate_t *pr_l, *pr_r, *ret_pr; + vector op_list, new_op_list; + int o; + + + switch(pr->get_operator_type()){ + case PRED_IN: + se_l = dup_se(pr->get_left_se(), aggr_tbl); + ret_pr = new predicate_t(se_l, pr->get_lit_vec()); + return(ret_pr); + + case PRED_COMPARE: + se_l = dup_se(pr->get_left_se(), aggr_tbl); + se_r = dup_se(pr->get_right_se(), aggr_tbl); + ret_pr = new predicate_t(se_l, pr->get_op().c_str(), se_r); + return(ret_pr); + + case PRED_UNARY_OP: + pr_l = dup_pr(pr->get_left_pr(), aggr_tbl); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l); + return(ret_pr); + + case PRED_BINARY_OP: + pr_l = dup_pr(pr->get_left_pr(), aggr_tbl); + pr_r = dup_pr(pr->get_right_pr(), aggr_tbl); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l, pr_r); + return(ret_pr); + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_op().c_str(), new_op_list); + ret_pr->set_fcn_id(pr->get_fcn_id()); + ret_pr->is_sampling_fcn = pr->is_sampling_fcn; + return(ret_pr); + + default: + fprintf(stderr,"INTERNAL ERROR in dup_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); + +} + +table_exp_t *dup_table_exp(table_exp_t *te){ + int i; + table_exp_t *ret = new table_exp_t(); + + ret->query_type = te->query_type; + + ss_map::iterator ss_i; + for(ss_i=te->nmap.begin();ss_i!=te->nmap.end();++ss_i){ + ret->nmap[(*ss_i).first] = (*ss_i).second; + } + + for(i=0;iquery_params.size();++i){ + ret->query_params.push_back(new + var_pair_t(te->query_params[i]->name,te->query_params[i]->val) ); + } + + if(te->sl){ + ret->sl = new select_list_t(); + ret->sl->lineno = te->sl->lineno; ret->sl->charno = te->sl->charno; + vector select_list = te->sl->get_select_list(); + for(i=0;ise,NULL); + ret->sl->append(se,select_list[i]->name); + } + } + + ret->fm = te->fm->duplicate(); + + if(te->wh) ret->wh = dup_pr(te->wh,NULL); + if(te->hv) ret->hv = dup_pr(te->hv,NULL); + if(te->cleaning_when) ret->cleaning_when = dup_pr(te->cleaning_when,NULL); + if(te->cleaning_by) ret->cleaning_by = dup_pr(te->cleaning_by,NULL); + if(te->closing_when) ret->closing_when = dup_pr(te->closing_when,NULL); + + for(i=0;igb.size();++i){ + extended_gb_t *tmp_g = te->gb[i]->duplicate(); + ret->gb.push_back(tmp_g); + } + + ret->mergevars = te->mergevars; + if(te->slack) + ret->slack = dup_se(te->slack,NULL); + ret->lineno = te->lineno; + ret->charno = te->charno; + + return(ret); +} + + + + + + + +///////////////////////////////////////////////////////////////////////// +// Bind colrefs to a member of their FROM list + +void bind_colref_se(scalarexp_t *se, + vector &fm, + int prev_ref, int new_ref + ){ + int p; + vector operand_list; + colref_t *cr; + ifpref_t *ir; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + return; + case SE_IFACE_PARAM: + ir = se->get_ifpref(); + if(ir->get_tablevar_ref() == prev_ref){ + ir->set_tablevar_ref(new_ref); + ir->set_tablevar(fm[new_ref]->get_var_name()); + } + return; + + case SE_COLREF: + cr=se->get_colref(); + if(cr->get_tablevar_ref() == prev_ref){ + cr->set_tablevar_ref(new_ref); +// cr->set_interface(fm[new_ref]->get_interface()); + cr->set_table_name(fm[new_ref]->get_var_name()); + } + return; + + case SE_UNARY_OP: + bind_colref_se(se->get_left_se(), fm, prev_ref, new_ref); + return; + + case SE_BINARY_OP: + bind_colref_se(se->get_left_se(), fm, prev_ref, new_ref); + bind_colref_se(se->get_right_se(), fm, prev_ref, new_ref); + return; + + case SE_AGGR_STAR: + case SE_AGGR_SE: + return; + + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return; + + operand_list = se->get_operands(); + for(p=0;pget_operator_type()); + exit(1); + break; + } + return; + +} + + + + +void bind_colref_pr(predicate_t *pr, + vector &fm, + int prev_ref, int new_ref + ){ + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + bind_colref_se(pr->get_left_se(), fm, prev_ref, new_ref); + return; + + case PRED_COMPARE: + bind_colref_se(pr->get_left_se(), fm, prev_ref, new_ref); + bind_colref_se(pr->get_right_se(), fm, prev_ref, new_ref); + return; + + case PRED_UNARY_OP: + bind_colref_pr(pr->get_left_pr(), fm, prev_ref, new_ref); + return; + + case PRED_BINARY_OP: + bind_colref_pr(pr->get_left_pr(), fm, prev_ref, new_ref); + bind_colref_pr(pr->get_right_pr(), fm, prev_ref, new_ref); + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; + +} + + +///////////////////////////////////////////////////////////////////// +// verify that the se refs only literals and params. +// (use to verify that the expression should stay in the hfta +// during a split) +///////////////////////////////////////////////////////////////////// + +bool is_literal_or_param_only(scalarexp_t *se){ + int o; + vector operands; + bool sum = true; + + if(se == NULL) return(true); + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + return(true); + case SE_IFACE_PARAM: + return(false); // need to treat as colref + case SE_UNARY_OP: + return(is_literal_or_param_only(se->get_left_se()) ); + case SE_BINARY_OP: + return( + is_literal_or_param_only(se->get_left_se()) && + is_literal_or_param_only(se->get_right_se()) + ); + case SE_COLREF: + return(false); + case SE_AGGR_STAR: + case SE_AGGR_SE: + return(false); + case SE_FUNC: +// The fcn might have special meaning at the lfta ... + return(false); + + default: + fprintf(stderr,"INTERNAL ERROR in is_literal_or_param_only, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return(0); +} + + + +///////////////////////////////////////////////////////////////////// +// Search for gb refs. +// (use to verify that no gbrefs in a gb def.) +///////////////////////////////////////////////////////////////////// + + +int count_gb_se(scalarexp_t *se){ + int o; + vector operands; + int sum = 0; + + if(se == NULL) return(0); + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return(0); + case SE_UNARY_OP: + return(count_gb_se(se->get_left_se()) ); + case SE_BINARY_OP: + return( + count_gb_se(se->get_left_se()) + + count_gb_se(se->get_right_se()) + ); + case SE_COLREF: + if(se->get_gb_ref() < 0) return(0); + return(1); + case SE_AGGR_STAR: + case SE_AGGR_SE: + return(0); + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return(0); +} + + +///////////////////////////////////////////////////////////////////// +//////////////// Search for stateful fcns. +///////////////////////////////////////////////////////////////////// + + +int se_refs_sfun(scalarexp_t *se){ + int o; + vector operands; + int sum = 0; + + if(se == NULL) return(0); + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return(0); + case SE_UNARY_OP: + return(se_refs_sfun(se->get_left_se()) ); + case SE_BINARY_OP: + return( + se_refs_sfun(se->get_left_se()) + + se_refs_sfun(se->get_right_se()) + ); + case SE_COLREF: + return(0); + case SE_AGGR_STAR: + case SE_AGGR_SE: + return(0); + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_aggr_ref()>=0) sum++; // is it tagged as a UDAF? + +// for now, stateful functions count as aggregates. + if(se->get_storage_state() != "") + sum++; + + return(sum); + + default: + fprintf(stderr,"INTERNAL ERROR in se_refs_sfun, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return(0); +} + + +// Return a count of the number of stateful fcns in this predicate. +int pred_refs_sfun(predicate_t *pr){ + vector op_list; + int o, aggr_sum; + + switch(pr->get_operator_type()){ + case PRED_IN: + return(se_refs_sfun(pr->get_left_se()) ); + case PRED_COMPARE: + return( + se_refs_sfun(pr->get_left_se()) + + se_refs_sfun(pr->get_right_se()) + ); + case PRED_UNARY_OP: + return(pred_refs_sfun(pr->get_left_pr()) ); + case PRED_BINARY_OP: + return( + pred_refs_sfun(pr->get_left_pr()) + + pred_refs_sfun(pr->get_right_pr()) + ); + case PRED_FUNC: + op_list = pr->get_op_list(); + aggr_sum = 0; + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); +} + +////////////////////////////////////////////////// + +///////////////////////////////////////////////////////////////////// +//////////////// Search for aggregates. +///////////////////////////////////////////////////////////////////// + + +int count_aggr_se(scalarexp_t *se, bool strict){ + int o; + vector operands; + int sum = 0; + + if(se == NULL) return(0); + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return(0); + case SE_UNARY_OP: + return(count_aggr_se(se->get_left_se(), strict) ); + case SE_BINARY_OP: + return( + count_aggr_se(se->get_left_se(), strict) + + count_aggr_se(se->get_right_se(), strict) + ); + case SE_COLREF: + return(0); + case SE_AGGR_STAR: + case SE_AGGR_SE: + return(1); + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_aggr_ref()>=0) sum++; // is it tagged as a UDAF? + +// now, stateful functions can count as aggregates. +// if we are being strict. + if(! strict && se->get_storage_state() != "") + sum++; + + return(sum); + + default: + fprintf(stderr,"INTERNAL ERROR in count_aggr_se, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return(0); +} + + +// Return a count of the number of aggregate fcns in this predicate. +int count_aggr_pred(predicate_t *pr, bool strict){ + vector op_list; + int o, aggr_sum; + + switch(pr->get_operator_type()){ + case PRED_IN: + return(count_aggr_se(pr->get_left_se(), strict) ); + case PRED_COMPARE: + return( + count_aggr_se(pr->get_left_se(), strict) + + count_aggr_se(pr->get_right_se(), strict) + ); + case PRED_UNARY_OP: + return(count_aggr_pred(pr->get_left_pr(), strict) ); + case PRED_BINARY_OP: + return( + count_aggr_pred(pr->get_left_pr(), strict) + + count_aggr_pred(pr->get_right_pr(), strict) + ); + case PRED_FUNC: + op_list = pr->get_op_list(); + aggr_sum = 0; + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); +} + +////////////////////////////////////////////////// +/// Analyze tablevar refs + +void get_tablevar_ref_se(scalarexp_t *se, vector &reflist){ + int o; + vector operands; + int vref; + colref_t *cr; + ifpref_t *ir; + + if(se == NULL) return; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + return; + case SE_IFACE_PARAM: + ir = se->get_ifpref(); + vref = ir->get_tablevar_ref(); + for(o=0;oget_left_se(), reflist); + return; + case SE_BINARY_OP: + get_tablevar_ref_se(se->get_left_se(), reflist); + get_tablevar_ref_se(se->get_right_se(), reflist); + return; + case SE_COLREF: + if(se->is_gb()) return; + cr = se->get_colref(); + vref = cr->get_tablevar_ref(); + for(o=0;oget_aggr_ref() >= 0) return; + + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return; +} + + +void get_tablevar_ref_pr(predicate_t *pr, vector &reflist){ + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + get_tablevar_ref_se(pr->get_left_se(),reflist); + return; + case PRED_COMPARE: + get_tablevar_ref_se(pr->get_left_se(),reflist); + get_tablevar_ref_se(pr->get_right_se(),reflist); + return; + case PRED_UNARY_OP: + get_tablevar_ref_pr(pr->get_left_pr(),reflist); + return; + case PRED_BINARY_OP: + get_tablevar_ref_pr(pr->get_left_pr(),reflist); + get_tablevar_ref_pr(pr->get_right_pr(),reflist); + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } + + return; +} + + +// Walk SE tree and gather STATES ref'd by STATEFUL fcns. + +void gather_fcn_states_se(scalarexp_t *se, set &states_refd, ext_fcn_list *Ext_fcns){ + int agg_id; + int o; + vector operands; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_UNARY_OP: + gather_fcn_states_se(se->get_left_se(), states_refd, Ext_fcns) ; + return; + case SE_BINARY_OP: + gather_fcn_states_se(se->get_left_se(), states_refd, Ext_fcns); + gather_fcn_states_se(se->get_right_se(), states_refd,Ext_fcns); + return; + case SE_COLREF: + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: + gather_fcn_states_se(se->get_left_se(), states_refd, Ext_fcns); + return; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_storage_state() != ""){ + states_refd.insert(se->get_storage_state()); + } + return; + + default: + fprintf(stderr,"INTERNAL ERROR in gather_fcn_states_se, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return; +} + + +// Walk SE tree and gather STATES ref'd by STATEFUL fcns. + +void gather_fcn_states_pr(predicate_t *pr, set &states_refd, ext_fcn_list *Ext_fcns){ + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + gather_fcn_states_se(pr->get_left_se(),states_refd, Ext_fcns) ; + return; + case PRED_COMPARE: + gather_fcn_states_se(pr->get_left_se(),states_refd, Ext_fcns) ; + gather_fcn_states_se(pr->get_right_se(),states_refd, Ext_fcns) ; + return; + case PRED_UNARY_OP: + gather_fcn_states_pr(pr->get_left_pr(),states_refd, Ext_fcns); + return; + case PRED_BINARY_OP: + gather_fcn_states_pr(pr->get_left_pr(),states_refd, Ext_fcns) ; + gather_fcn_states_pr(pr->get_right_pr(),states_refd, Ext_fcns) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + + + +// walk se tree and collect aggregates into aggregate table. +// duplicate aggregates receive the same idx to the table. + +void build_aggr_tbl_fm_se(scalarexp_t *se, aggregate_table *aggregate_table, ext_fcn_list *Ext_fcns){ + int agg_id; + int o; + vector operands; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_UNARY_OP: + build_aggr_tbl_fm_se(se->get_left_se(), aggregate_table, Ext_fcns) ; + return; + case SE_BINARY_OP: + build_aggr_tbl_fm_se(se->get_left_se(), aggregate_table, Ext_fcns); + build_aggr_tbl_fm_se(se->get_right_se(), aggregate_table,Ext_fcns); + return; + case SE_COLREF: + return; + case SE_AGGR_STAR: + agg_id = aggregate_table->add_aggr(se->get_op(),NULL,se->is_superaggr()); + se->set_aggr_id(agg_id); + return; + case SE_AGGR_SE: + agg_id = aggregate_table->add_aggr(se->get_op(),se->get_left_se(),se->is_superaggr()); + se->set_aggr_id(agg_id); + return; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_aggr_ref() >= 0){ // it's been tagged as a UDAF + agg_id = aggregate_table->add_aggr(se->get_op(), se->get_fcn_id(), operands, Ext_fcns->get_storage_dt(se->get_fcn_id()), se->is_superaggr(), Ext_fcns->is_running_aggr(se->get_fcn_id()),Ext_fcns->has_lfta_bailout(se->get_fcn_id())); + se->set_aggr_id(agg_id); + } + return; + + default: + fprintf(stderr,"INTERNAL ERROR in build_aggr_tbl_fm_se, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return; +} + + +// walk se tree and collect aggregates into aggregate table. +// duplicate aggregates receive the same idx to the table. + +void build_aggr_tbl_fm_pred(predicate_t *pr, aggregate_table *aggregate_table,ext_fcn_list *Ext_fcns){ + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + build_aggr_tbl_fm_se(pr->get_left_se(),aggregate_table, Ext_fcns) ; + return; + case PRED_COMPARE: + build_aggr_tbl_fm_se(pr->get_left_se(),aggregate_table, Ext_fcns) ; + build_aggr_tbl_fm_se(pr->get_right_se(),aggregate_table, Ext_fcns) ; + return; + case PRED_UNARY_OP: + build_aggr_tbl_fm_pred(pr->get_left_pr(),aggregate_table, Ext_fcns); + return; + case PRED_BINARY_OP: + build_aggr_tbl_fm_pred(pr->get_left_pr(),aggregate_table, Ext_fcns) ; + build_aggr_tbl_fm_pred(pr->get_right_pr(),aggregate_table, Ext_fcns) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + +// Return true if the two scalar expressions +// represent the same value (e.g., use to eliminate +// duplicate aggregates). +bool is_equivalent_se(scalarexp_t *se1, scalarexp_t *se2){ + vector operands1; + vector operands2; + int o; + +// First handle the case of nulls (e.g. COUNT aggrs) + if(se1 == NULL && se2 == NULL) return(true); + if(se1 == NULL || se2 == NULL) return(false); + +// In all cases, must be the same oeprator type and same operator. + if(se1->get_operator_type() != se2->get_operator_type()) + return(false); + if(se1->get_op() != se2->get_op() ) + return(false); + + switch(se1->get_operator_type()){ + case SE_LITERAL: + return(se1->get_literal()->is_equivalent(se2->get_literal()) ); + case SE_PARAM: + return(se1->get_param_name() == se2->get_param_name() ); + case SE_IFACE_PARAM: + return(se1->get_ifpref()->is_equivalent(se2->get_ifpref()) ); + case SE_UNARY_OP: + return(is_equivalent_se(se1->get_left_se(), se2->get_left_se()) ); + case SE_BINARY_OP: + if(is_equivalent_se(se1->get_left_se(), se2->get_left_se()) ) + return(is_equivalent_se(se1->get_right_se(), se2->get_right_se()) ); + return(false); + case SE_COLREF: + if(se1->is_gb() && se2->is_gb()) + return( se1->get_gb_ref() == se2->get_gb_ref() ); + if(se1->is_gb() || se2->is_gb()) + return(false); + return(se1->get_colref()->is_equivalent(se2->get_colref()) ); + case SE_AGGR_STAR: + return(true); + case SE_AGGR_SE: + return(is_equivalent_se(se1->get_left_se(), se2->get_left_se()) ); + case SE_FUNC: + if(se1->get_op() != se2->get_op()) return(false); + + operands1 = se1->get_operands(); + operands2 = se2->get_operands(); + if(operands1.size() != operands2.size()) return(false); + + for(o=0;oget_lineno(), se1->get_charno(),se1->get_operator_type()); + exit(1); + } + return(false); +} + + +// Similar to is_equivalent_se, but with a looser definition +// of equivalence of colrefs. Here, say they are equivalent +// if their base table is the same. Use to find equivalent +// predicates on base tables. +bool is_equivalent_se_base(scalarexp_t *se1, scalarexp_t *se2, table_list *Schema){ + vector operands1; + vector operands2; + int o; + + if(se1->get_operator_type() == SE_COLREF && se1->is_gb()){ + se1 = se1->get_right_se(); + } + if(se2->get_operator_type() == SE_COLREF && se2->is_gb()){ + se2 = se2->get_right_se(); + } + +// First handle the case of nulls (e.g. COUNT aggrs) + if(se1 == NULL && se2 == NULL) return(true); + if(se1 == NULL || se2 == NULL) return(false); + +// In all cases, must be the same oeprator type and same operator. + if(se1->get_operator_type() != se2->get_operator_type()) + return(false); + if(se1->get_op() != se2->get_op() ) + return(false); + + switch(se1->get_operator_type()){ + case SE_LITERAL: + return(se1->get_literal()->is_equivalent(se2->get_literal()) ); + case SE_PARAM: + return(se1->get_param_name() == se2->get_param_name() ); + case SE_IFACE_PARAM: + return(se1->get_ifpref()->is_equivalent(se2->get_ifpref()) ); + case SE_UNARY_OP: + return(is_equivalent_se_base(se1->get_left_se(), se2->get_left_se(), Schema) ); + case SE_BINARY_OP: + if(is_equivalent_se_base(se1->get_left_se(), se2->get_left_se(), Schema) ) + return(is_equivalent_se_base(se1->get_right_se(), se2->get_right_se(), Schema) ); + return(false); + case SE_COLREF: +/* + if(se1->is_gb() && se2->is_gb()) + return( se1->get_gb_ref() == se2->get_gb_ref() ); + if(se1->is_gb() || se2->is_gb()) + return(false); +*/ + return(se1->get_colref()->is_equivalent_base(se2->get_colref(), Schema) ); + case SE_AGGR_STAR: + return(true); + case SE_AGGR_SE: + return(is_equivalent_se_base(se1->get_left_se(), se2->get_left_se(), Schema) ); + case SE_FUNC: + if(se1->get_op() != se2->get_op()) return(false); + + operands1 = se1->get_operands(); + operands2 = se2->get_operands(); + if(operands1.size() != operands2.size()) return(false); + + for(o=0;oget_lineno(), se1->get_charno(),se1->get_operator_type()); + exit(1); + } + return(false); +} + + +// Find predicates which are equivalent when +// looking at the base tables. Use to find +// common prefilter. +bool is_equivalent_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema){ +int i, o; + +// First handle the case of nulls + if(p1 == NULL && p2 == NULL) return(true); + if(p1 == NULL || p2 == NULL) return(false); + + + if(p1->get_operator_type() != p2->get_operator_type()) + return(false); + if(p1->get_op() != p2->get_op()) + return(false); + + vector ll1; + vector ll2; + vector op_list1, op_list2; + + + switch(p2->get_operator_type()){ + case PRED_COMPARE: + if( ! is_equivalent_se_base(p1->get_left_se(),p2->get_left_se(), Schema) ) + return(false); + return( is_equivalent_se_base(p1->get_right_se(),p2->get_right_se(), Schema) ); + break; + case PRED_IN: + if( ! is_equivalent_se_base(p1->get_left_se(),p2->get_left_se(), Schema) ) + return(false); + ll1 = p1->get_lit_vec(); + ll2 = p2->get_lit_vec(); + if(ll1.size() != ll2.size()) + return(false); + for(i=0;iis_equivalent( ll2[i] ) ) + return(false); + } + return(true); + break; + case PRED_UNARY_OP: + return(is_equivalent_pred_base(p1->get_left_pr(), p2->get_left_pr(), Schema) ); + break; + case PRED_BINARY_OP: + if(! is_equivalent_pred_base(p1->get_left_pr(), p2->get_left_pr(), Schema)) + return(false); + return(is_equivalent_pred_base(p1->get_right_pr(), p2->get_right_pr(), Schema) ); + break; + case PRED_FUNC: + op_list1 = p1->get_op_list(); + op_list2 = p2->get_op_list(); + if(op_list1.size() != op_list2.size()) return(false); + for(o=0;oget_operator_type()!=PRED_FUNC)||(p2->get_operator_type()!=PRED_FUNC)) + return(false); + if(p1->get_fcn_id() != p2->get_fcn_id()) + return false; + vector cl_op = Ext_fcns->get_class_indicators(p1->get_fcn_id()); + int o; + vector op_list1 = p1->get_op_list(); + vector op_list2 = p2->get_op_list(); + if(op_list1.size() != op_list2.size()) return(false); + for(o=0;o operands; + int o; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return(true ); + case SE_UNARY_OP: + return(verify_aggr_query_se(se->get_left_se() ) ); + case SE_BINARY_OP: + return(verify_aggr_query_se(se->get_left_se() ) && + verify_aggr_query_se(se->get_right_se() ) ); + case SE_COLREF: + if(se->is_gb() ) return(true); + fprintf(stderr,"ERROR: the select clause in an aggregate query can " + "only reference constants, group-by attributes, and " + "aggregates, (%s) line %d, character %d.\n", + se->get_colref()->to_string().c_str(), + se->get_lineno(), se->get_charno() ); + return(false); + case SE_AGGR_STAR: + case SE_AGGR_SE: +// colrefs and gbrefs allowed. +// check for nested aggregation elsewhere, so just return TRUE + return(true); + case SE_FUNC: +// If its a UDAF, just return true + if(se->get_aggr_ref() >= 0) return true; + + operands = se->get_operands(); + + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return(false); +} + + + + +// Find complex literals. +// NOTE : This analysis should be deferred to +// code generation time. +// This analysis drills into aggr se specs. +// Shouldn't this be done at the aggregate table? +// But, its not a major loss of efficiency. +// UPDATE : drilling into aggr se's is causnig a problem +// so I've eliminated it. + +bool find_complex_literal_se(scalarexp_t *se, ext_fcn_list *Ext_fcns, + cplx_lit_table *complex_literals){ + literal_t *l; + vector operands; + int o; + scalarexp_t *param_se; + data_type *dt; + + switch(se->get_operator_type()){ + case SE_LITERAL: + l = se->get_literal(); + if(l->constructor_name() != ""){ + int cl_idx = complex_literals->add_cpx_lit(l, false); + l->set_cpx_lit_ref(cl_idx); + } + return(true); + case SE_PARAM: + return(true ); +// SE_IFACE_PARAM should not exist when this is called. + case SE_UNARY_OP: + return(find_complex_literal_se(se->get_left_se(), Ext_fcns, complex_literals ) ); + case SE_BINARY_OP: + return(find_complex_literal_se(se->get_left_se(), Ext_fcns, complex_literals ) && + find_complex_literal_se(se->get_right_se(), Ext_fcns, complex_literals ) ); + case SE_COLREF: + return(true); + case SE_AGGR_STAR: + return(true); + case SE_AGGR_SE: + return true; +// return(find_complex_literal_se(se->get_left_se(), Ext_fcns, complex_literals ) ); + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return true; + + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return(false); +} + + + + +void find_complex_literal_pr(predicate_t *pr, ext_fcn_list *Ext_fcns, + cplx_lit_table *complex_literals){ + int i,o; + vector litl; + vector op_list; + + + switch(pr->get_operator_type()){ + case PRED_IN: + find_complex_literal_se(pr->get_left_se(), Ext_fcns, complex_literals) ; + litl = pr->get_lit_vec(); + for(i=0;iconstructor_name() != ""){ + int cl_idx = complex_literals->add_cpx_lit(litl[i],false); + litl[i]->set_cpx_lit_ref(cl_idx); + } + } + return; + case PRED_COMPARE: + find_complex_literal_se(pr->get_left_se(), Ext_fcns, complex_literals) ; + find_complex_literal_se(pr->get_right_se(), Ext_fcns, complex_literals) ; + return; + case PRED_UNARY_OP: + find_complex_literal_pr(pr->get_left_pr(), Ext_fcns, complex_literals); + return; + case PRED_BINARY_OP: + find_complex_literal_pr(pr->get_left_pr(), Ext_fcns, complex_literals) ; + find_complex_literal_pr(pr->get_right_pr(), Ext_fcns, complex_literals) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + +// Find all things which are passed as handle parameters to functions +// (query parameters, (simple) literals, complex literals) +// These expressions MUST be processed with find_complex_literal_?? +// first. +// TODO: this analysis drills into the aggregate SEs. +// Shouldn't this be done on the aggr table SEs instead? +// to avoid duplication. THe handle registration +// might be expensive ... +// REVISED : drilling into aggr se's is causing problems, eliminated. + +void find_param_handles_se(scalarexp_t *se, ext_fcn_list *Ext_fcns, + vector &handle_tbl){ + vector operands; + vector handle_ind; + int o; + scalarexp_t *param_se; + data_type *dt; + literal_t *l; + + switch(se->get_operator_type()){ + case SE_LITERAL: + return; + case SE_PARAM: + return; +// case SE_IFACE_PARAM: SHOULD NOT EXIST when this is called + case SE_UNARY_OP: + find_param_handles_se(se->get_left_se(), Ext_fcns, handle_tbl ) ; + return; + case SE_BINARY_OP: + find_param_handles_se(se->get_left_se(), Ext_fcns , handle_tbl) ; + find_param_handles_se(se->get_right_se(), Ext_fcns, handle_tbl ) ; + return; + case SE_COLREF: + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: +// find_param_handles_se(se->get_left_se(), Ext_fcns, handle_tbl ) ; + return; + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return ; + + operands = se->get_operands(); + handle_ind = Ext_fcns->get_handle_indicators(se->get_fcn_id() ); + for(o=0;oget_operator_type() != SE_LITERAL && + param_se->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of function %s must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, se->get_op().c_str(),se->get_lineno(), se->get_charno()); + exit(1); + } + + if(param_se->get_operator_type() == SE_PARAM){ + he = new handle_param_tbl_entry( + se->get_op(), o, param_se->get_param_name(), + param_se->get_data_type()->get_type_str()); + }else{ + l = param_se->get_literal(); + if(l->is_cpx_lit()){ + he = new handle_param_tbl_entry( + se->get_op(), o, l->get_cpx_lit_ref(), + param_se->get_data_type()->get_type_str()); + }else{ + he = new handle_param_tbl_entry( + se->get_op(), o, l, + param_se->get_data_type()->get_type_str()); + } + } + param_se->set_handle_ref(handle_tbl.size()); + handle_tbl.push_back(he); + }else{ + find_param_handles_se(operands[o], Ext_fcns, handle_tbl ) ; + } + } + return; + default: + fprintf(stderr,"INTERNAL ERROR in find_param_handles, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return; +} + + +void find_param_handles_pr(predicate_t *pr, ext_fcn_list *Ext_fcns, + vector &handle_tbl){ + vector litl; + vector op_list; + scalarexp_t *param_se; + vector handle_ind; + int o; + literal_t *l; + + switch(pr->get_operator_type()){ + case PRED_IN: + find_param_handles_se(pr->get_left_se(), Ext_fcns, handle_tbl) ; + return; + case PRED_COMPARE: + find_param_handles_se(pr->get_left_se(), Ext_fcns, handle_tbl) ; + find_param_handles_se(pr->get_right_se(), Ext_fcns, handle_tbl) ; + return; + case PRED_UNARY_OP: + find_param_handles_pr(pr->get_left_pr(), Ext_fcns, handle_tbl); + return; + case PRED_BINARY_OP: + find_param_handles_pr(pr->get_left_pr(), Ext_fcns, handle_tbl) ; + find_param_handles_pr(pr->get_right_pr(), Ext_fcns, handle_tbl) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + handle_ind = Ext_fcns->get_handle_indicators(pr->get_fcn_id() ); + for(o=0;oget_operator_type() != SE_LITERAL && + param_se->get_operator_type() != SE_PARAM){ + fprintf(stderr,"ERROR, the %d-th parameter of predicate %s must be a literal or query parameter (because it is a pass-by-HANDLE parameter).\n Line=%d, char=%d.\n", + o+1, pr->get_op().c_str(),pr->get_lineno(), pr->get_charno()); + exit(1); + } + + if(param_se->get_operator_type() == SE_PARAM){ + he = new handle_param_tbl_entry( + pr->get_op(), o, param_se->get_param_name(), + param_se->get_data_type()->get_type_str()); + }else{ + l = param_se->get_literal(); + if(l->is_cpx_lit()){ + he = new handle_param_tbl_entry( + pr->get_op(), o, l->get_cpx_lit_ref(), + param_se->get_data_type()->get_type_str()); + }else{ + he = new handle_param_tbl_entry( + pr->get_op(), o, l, + param_se->get_data_type()->get_type_str()); + } + } + param_se->set_handle_ref(handle_tbl.size()); + handle_tbl.push_back(he); + }else{ + find_param_handles_se(op_list[o], Ext_fcns, handle_tbl ) ; + } + } + return; + default: + fprintf(stderr,"INTERNAL ERROR in find_param_handles_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + +// Verify the HAVING predicate : it +// can access gb vars, aggregates, and constants, +// but not colrefs. +// return 1 if OK, -1 if bad. +// Perhaps replace by a pair of fcns which counts non-gb colrefs? + +// Extended to deal with cleaning_by, cleaning_when : +// verify that any aggregate function +// has the multiple output property. + +int verify_having_se(scalarexp_t *se, const char *clause, ext_fcn_list *Ext_fcns){ + int l_ret, r_ret; + vector operands; + vector odt; + int o; + + switch(se->get_operator_type()){ + case SE_LITERAL: + return(1); + case SE_PARAM: + case SE_IFACE_PARAM: + return(1); + case SE_UNARY_OP: + return(verify_having_se(se->get_left_se(), clause, Ext_fcns) ); + case SE_BINARY_OP: + l_ret = verify_having_se(se->get_left_se(), clause, Ext_fcns); + r_ret = verify_having_se(se->get_right_se(), clause, Ext_fcns); + if( (l_ret < 0 ) || (r_ret < 0) ) return(-1); + return(1); + case SE_COLREF: + if(se->is_gb()) return 1; + fprintf(stderr,"ERROR, %s clause references a non-group by attribute line =%d, char = %d, colref=%s\n", clause, + se->get_colref()->get_lineno(),se->get_colref()->get_charno(), se->get_colref()->to_string().c_str() ); + return(-1); + case SE_AGGR_STAR: + case SE_AGGR_SE: +// colrefs and gbrefs allowed. +// check for nested aggregation elsewhere, so just return TRUE + if(!se->is_superaggr() && !strcmp(clause,"CLEANING_WHEN")){ + fprintf(stderr,"ERROR, %s clause references a superaggregate, line =%d, char = %d, op=%s\n", clause, + se->get_lineno(),se->get_charno(), se->get_op().c_str() ); + return(-1); + } + +// Ensure that aggregate refs allow multiple outputs +// in CLEANING_WHEN, CLEANING_BY + if(!strcmp(clause,"CLEANING_WHEN") || !strcmp(clause,"CLEANING_BY")){ + if(! aggr_table_entry::multiple_return_allowed(true,Ext_fcns,se->get_fcn_id())){ + fprintf(stderr,"ERROR, the %s clause references aggregate %s, which does not allow multiple outputs, line=%d, char=%d\n",clause, + se->get_op().c_str(),se->get_lineno(),se->get_charno() ); + return(-1); + } + } + + + return(1); + case SE_FUNC: + if(se->get_aggr_ref() >= 0 && !se->is_superaggr() && !strcmp(clause,"CLEANING_WHEN")){ + fprintf(stderr,"ERROR, %s clause references a superaggregate, line =%d, char = %d, op=%s\n", clause, + se->get_colref()->get_lineno(),se->get_colref()->get_charno(), se->get_op().c_str() ); + return(-1); + } + + if(!strcmp(clause,"CLEANING_WHEN") || !strcmp(clause,"CLEANING_BY")){ + if(se->get_aggr_ref() >= 0 && ! aggr_table_entry::multiple_return_allowed(true,Ext_fcns,se->get_fcn_id())){ + fprintf(stderr,"ERROR, the %s clause references aggregate %s, which does not allow multiple outputs, line=%d, char=%d\n",clause, + se->get_op().c_str(),se->get_lineno(),se->get_charno() ); + return(-1); + } + } + + if(se->get_aggr_ref() >= 0) // don't descent into aggregates. + return 1; + + operands = se->get_operands(); + r_ret = 1; + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + return(-1); + } + return(-1); +} + + +// Verify the HAVING predicate : it +// can access gb vars, aggregates, and constants, +// but not colrefs. +// return 1 if OK, -1 if bad. +// Perhaps replace by a pair of fcns which counts non-gb colrefs? + + +int verify_having_pred(predicate_t *pr, const char *clause, ext_fcn_list *Ext_fcns){ + int l_ret, r_ret; + vector litl; + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + return(verify_having_se(pr->get_left_se(), clause, Ext_fcns)); + case PRED_COMPARE: + l_ret = verify_having_se(pr->get_left_se(), clause, Ext_fcns) ; + r_ret = verify_having_se(pr->get_right_se(), clause, Ext_fcns) ; + if( (l_ret < 0) || (r_ret < 0) ) return(-1); else return(1); + case PRED_UNARY_OP: + return(verify_having_pred(pr->get_left_pr(), clause, Ext_fcns)); + case PRED_BINARY_OP: + l_ret = verify_having_pred(pr->get_left_pr(), clause, Ext_fcns); + r_ret = verify_having_pred(pr->get_right_pr(), clause, Ext_fcns); + if( (l_ret < 0) || (r_ret < 0) ) return(-1); + return(1); + case PRED_FUNC: + op_list = pr->get_op_list(); + l_ret = 1; + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } + + return(-1); +} + + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +/////// cnf and pred analysis and manipulation + +// ---------------------------------------------------------------------- +//  Convert the predicates to a list of conjuncts +//  (not actually cnf). Do some analysis +//  on their properties. +// ---------------------------------------------------------------------- + + +//  Put into list clist the predicates that +//  are AND'ed together. + +void make_cnf_from_pr(predicate_t *pr, vector &clist){ + + if(pr == NULL) return; + + switch(pr->get_operator_type()){ + case PRED_COMPARE: + clist.push_back(new cnf_elem(pr)); + return; + break; + case PRED_IN: + clist.push_back(new cnf_elem(pr)); + return; + break; + case PRED_UNARY_OP: + clist.push_back(new cnf_elem(pr)); + return; + break; + case PRED_BINARY_OP: + if(pr->get_op() == "OR"){ + clist.push_back(new cnf_elem(pr)); + return; + } + if(pr->get_op() =="AND"){ + make_cnf_from_pr(pr->get_left_pr(),clist); + make_cnf_from_pr(pr->get_right_pr(),clist); + return; + } + case PRED_FUNC: + clist.push_back(new cnf_elem(pr)); + return; + break; + default: + fprintf(stderr,"INTERNAL ERROR in make_cnf_from_pr: I don't recognize predicate operator %s\n",pr->get_op().c_str()); + exit(1); + break; + } +} + + + +//  Find out what things are referenced in a se, +//  to use for analyzing a predicate. +//  Currently, is it simple (no operators), does it +//  reference a group-by column, does it reference an +//  attribute of a table. +// +// analyze_cnf_se and analyze_cnf_pr are called by analyze_cnf + + +void analyze_cnf_se(scalarexp_t *se, int &s, int &g, int &a, int &agr){ + int p; + vector operand_list; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_COLREF: + if(se->is_gb() ) g=1; + else a=1; + return; + case SE_UNARY_OP: + s=0; + analyze_cnf_se(se->get_left_se(),s,g,a,agr); + return; + case SE_BINARY_OP: + s=0; + analyze_cnf_se(se->get_left_se(),s,g,a,agr); + analyze_cnf_se(se->get_right_se(),s,g,a,agr); + return; + case SE_AGGR_STAR: + case SE_AGGR_SE: + agr = 1; + return; + case SE_FUNC: + if(se->get_aggr_ref() >= 0){ + agr = 1; + return; + } + s = 0; + operand_list = se->get_operands(); + for(p=0;p op_list; + + + switch(pr->get_operator_type()){ + case PRED_COMPARE: + analyze_cnf_se(pr->get_left_se(),dum_simple,g,a,agr); + analyze_cnf_se(pr->get_right_se(),dum_simple,g,a,agr); + return; + case PRED_IN: + analyze_cnf_se(pr->get_left_se(),dum_simple,g,a,agr); + return; + case PRED_UNARY_OP: + analyze_cnf_pr(pr->get_left_pr(),g,a,agr); + return; + case PRED_BINARY_OP: + analyze_cnf_pr(pr->get_left_pr(),g,a,agr); + analyze_cnf_pr(pr->get_right_pr(),g,a,agr); + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } +} + + + +//  analyze a conjunct of a predicate. +//  Is it atomic (e.g., a single predicate), +//  and if so do a further analysis. + +void analyze_cnf(cnf_elem *c){ + +//  analyze the predicate. + analyze_cnf_pr(c->pr, c->pr_gb, c->pr_attr, c->pr_aggr); + + if((c->pr->get_operator_type()!= PRED_COMPARE) && (c->pr->get_operator_type()!= PRED_IN)){ + return; + } + + +//  its an atomic predicate -- get more info + c->is_atom = 1; + + if(c->pr->get_op() == "=") + c->eq_pred = 1; + else + c->eq_pred = 0; + + if(c->pr->get_operator_type() == PRED_IN) + c->in_pred = 1; + else + c->in_pred = 0; + + c->l_simple = 1; c->l_gb = c->l_attr = c->l_aggr = 0; + analyze_cnf_se(c->pr->get_left_se(),c->l_simple,c->l_gb,c->l_attr, c->l_aggr); + + if(c->pr->get_operator_type() == PRED_COMPARE){ + c->r_simple = 1; c->r_gb = c->r_attr = c->r_aggr = 0; + analyze_cnf_se(c->pr->get_left_se(),c->r_simple,c->r_gb,c->r_attr, c->r_aggr); + } +} + +void analyze_constraint_se(scalarexp_t *se, + int &n_agr, int &n_gb, int &n_par, int &n_func, int &n_op, ext_fcn_list *Ext_fcns, bool enter_gb){ + int l_agr, l_gb, l_par, l_func, l_op; + int r_agr, r_gb, r_par, r_func, r_op; + int p; + vector operand_list; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_IFACE_PARAM: + n_agr=0; n_gb = 0; n_par = 0; n_func = 0; n_op = 0; + return; + case SE_PARAM: + n_agr=0; n_gb = 0; n_par = 1; n_func = 0; n_op = 0; + return; + case SE_COLREF: + n_agr=0; n_gb = 0; n_par = 0; n_func = 0; n_op = 0; + if(se->is_gb() ){ + if(enter_gb){ + analyze_constraint_se(se->get_right_se(),n_agr,n_gb,n_par,n_func,n_op,Ext_fcns,enter_gb); + }else{ + n_gb=1; + } + } + return; + case SE_UNARY_OP: + analyze_constraint_se(se->get_left_se(),n_agr,n_gb,n_par,n_func,n_op,Ext_fcns,enter_gb); + n_op++; + return; + case SE_BINARY_OP: + analyze_constraint_se(se->get_left_se(),l_agr,l_gb,l_par,l_func,l_op,Ext_fcns,enter_gb); + analyze_constraint_se(se->get_right_se(),r_agr,r_gb,r_par, r_func,r_op,Ext_fcns,enter_gb); + n_agr=l_agr+r_agr; + n_gb=l_gb+r_gb; + n_par=l_par+r_par; + n_func=l_func+r_func; + n_op=l_op+r_op+1; + return; + case SE_AGGR_STAR: + case SE_AGGR_SE: + n_agr=1; n_gb = 0; n_par = 0; n_func = 0; n_op = 0; + return; + case SE_FUNC: + if(se->get_aggr_ref() >= 0){ + n_agr=1; n_gb = 0; n_par = 0; n_op = 0; + if(Ext_fcns) + n_func = Ext_fcns->estimate_fcn_cost(se->get_fcn_id()); + else + n_func = 1; + return; + } + n_agr=0; n_gb = 0; n_par = 0; n_op = 0; + if(Ext_fcns) + n_func = Ext_fcns->estimate_fcn_cost(se->get_fcn_id()); + else + n_func = 1; + operand_list = se->get_operands(); + for(p=0;p op_list; + + + switch(pr->get_operator_type()){ + case PRED_COMPARE: + analyze_constraint_se(pr->get_left_se(),l_agr,l_gb,l_par,l_func, l_op,Ext_fcns,enter_gb); + analyze_constraint_se(pr->get_right_se(),r_agr,r_gb,r_par,r_func,r_op,Ext_fcns,enter_gb); + n_agr=l_agr+r_agr; n_gb=l_gb+r_gb; n_par=l_par+r_par; + n_func=l_func+r_func; n_op=l_op+r_op; + if(pr->get_left_se()->get_data_type()->complex_comparison( + pr->get_right_se()->get_data_type()) + ){ + n_cmp_s = 0; n_cmp_c=1; + }else{ + n_cmp_s = 1; n_cmp_c=0; + } + n_in = 0; n_pred = 0; n_bool = 0; + return; + case PRED_IN: +// Tread IN predicate as sequence of comparisons + analyze_constraint_se(pr->get_left_se(),n_agr,n_gb,n_par,n_func,n_op,Ext_fcns,enter_gb); + if(pr->get_left_se()->get_data_type()->complex_comparison( + pr->get_right_se()->get_data_type()) + ){ + n_cmp_s = 0; n_cmp_c=pr->get_lit_vec().size(); + }else{ + n_cmp_s = pr->get_lit_vec().size(); n_cmp_c=0; + } + n_in = 0; n_pred = 0; n_bool = 0; + return; + case PRED_UNARY_OP: + analyze_constraint_pr(pr->get_left_pr(),n_agr,n_gb,n_par,n_func,n_op,n_cmp_s,n_cmp_c,n_in,n_pred,n_bool,Ext_fcns,enter_gb); + n_bool++; + return; + case PRED_BINARY_OP: + analyze_constraint_pr(pr->get_left_pr(),l_agr,l_gb,l_par,l_func,l_op,l_cmp_s,l_cmp_c,l_in,l_pred,l_bool,Ext_fcns,enter_gb); + analyze_constraint_pr(pr->get_right_pr(),r_agr,r_gb,r_par,r_func,r_op,r_cmp_s,r_cmp_c,r_in,r_pred,r_bool,Ext_fcns,enter_gb); + n_agr=l_agr+r_agr; n_gb=l_gb+r_gb; n_par=l_par+r_par; + n_func=l_func+r_func; n_op=l_op+r_op; + n_cmp_s=l_cmp_s+r_cmp_s; n_cmp_c=l_cmp_c+r_cmp_c; + n_in=l_in+r_in; n_pred=l_pred+r_pred; n_bool=l_bool+r_bool+1; + return; + case PRED_FUNC: + n_agr=n_gb=n_par=n_func=n_op=n_cmp_s=n_cmp_c=n_in=n_bool=0; + if(Ext_fcns) + n_pred = Ext_fcns->estimate_fcn_cost(pr->get_fcn_id()); + else + n_pred = 1; + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } +} + +void compute_cnf_cost(cnf_elem *c, ext_fcn_list *Ext_fcns){ + int n_agr, n_gb, n_par, n_func, n_op, n_cmp_s, n_cmp_c, n_in, n_pred,n_bool; + analyze_constraint_pr(c->pr,n_agr, n_gb, n_par, n_func, n_op, + n_cmp_s, n_cmp_c, n_in, n_pred,n_bool, Ext_fcns,false); + +//printf("nfunc=%d n_pred=%d, n_cmp_c=%d, n_op=%d, n_cmp_s=%d,n_bool=%d\n", n_func, n_pred, n_cmp_c, n_op, n_cmp_s, n_bool); + c->cost = (n_func+n_pred)+10*n_cmp_c+n_op+n_cmp_s+n_bool; +} + +bool prefilter_compatible(cnf_elem *c, ext_fcn_list *Ext_fcns){ + int n_agr, n_gb, n_par, n_func, n_op, n_cmp_s, n_cmp_c, n_in, n_pred,n_bool; + analyze_constraint_pr(c->pr,n_agr, n_gb, n_par, n_func, n_op, + n_cmp_s, n_cmp_c, n_in, n_pred,n_bool, Ext_fcns,true); +//printf("prefilter_compatible, n_par=%d, n_gb=%d, n_agr=%d, n_func=%d, n_pred=%d, n_comp_c=%d, n_cmp_s=%d, n_bool=%d\n",n_gb,n_par,n_agr,n_func,n_pred,n_cmp_c,n_cmp_s,n_bool); + if(n_par || n_agr) + return false; + int cost = (n_func+n_pred)+10*n_cmp_c+n_op+n_cmp_s+n_bool; +//printf("cost=%d\n",cost); + return cost<10; +} + +// The prefilter needs to translate constraints on +// gbvars into constraints involving their underlying SEs. +// The following two routines attach GB def info. + +void insert_gb_def_se(scalarexp_t *se, gb_table *gtbl){ + int p; + vector operand_list; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_IFACE_PARAM: + case SE_PARAM: + case SE_AGGR_STAR: + return; + case SE_COLREF: + if(se->is_gb() ){ + se->rhs.scalarp = gtbl->get_def(se->get_gb_ref()); + } + return; + case SE_UNARY_OP: + insert_gb_def_se(se->get_left_se(),gtbl); + return; + case SE_BINARY_OP: + insert_gb_def_se(se->get_left_se(),gtbl); + insert_gb_def_se(se->get_right_se(),gtbl); + return; + case SE_AGGR_SE: + insert_gb_def_se(se->get_left_se(),gtbl); + return; + case SE_FUNC: + operand_list = se->get_operands(); + for(p=0;p op_list; +int o; + + switch(pr->get_operator_type()){ + case PRED_COMPARE: + insert_gb_def_se(pr->get_left_se(),gtbl); + insert_gb_def_se(pr->get_right_se(),gtbl); + return; + case PRED_IN: + insert_gb_def_se(pr->get_left_se(),gtbl); + return; + case PRED_UNARY_OP: + insert_gb_def_pr(pr->get_left_pr(),gtbl); + return; + case PRED_BINARY_OP: + insert_gb_def_pr(pr->get_left_pr(),gtbl); + insert_gb_def_pr(pr->get_right_pr(),gtbl); + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } +} + +// Substitute gbrefs with their definitions +void subs_gbrefs_se(scalarexp_t *se, table_list *Schema){ + int p; + vector operand_list; + scalarexp_t *lse,*rse; + colref_t *cr; + string b_tbl; + int b_idx; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_IFACE_PARAM: + case SE_PARAM: + case SE_AGGR_STAR: + return; + case SE_COLREF: + cr = se->get_colref(); + b_tbl = Schema->get_basetbl_name(cr->schema_ref,cr->field); + b_idx = Schema->get_table_ref(b_tbl); + cr->tablevar_ref = b_idx; + return; + case SE_UNARY_OP: + lse=se->get_left_se(); + if(lse->get_operator_type()==SE_COLREF && lse->is_gb()){ + se->lhs.scalarp = lse->get_right_se(); + subs_gbrefs_se(se,Schema); + return; + } + subs_gbrefs_se(se->get_left_se(),Schema); + return; + case SE_BINARY_OP: + lse=se->get_left_se(); + if(lse->get_operator_type()==SE_COLREF && lse->is_gb()){ + se->lhs.scalarp = lse->get_right_se(); + subs_gbrefs_se(se,Schema); + return; + } + rse=se->get_right_se(); + if(rse->get_operator_type()==SE_COLREF && rse->is_gb()){ + se->rhs.scalarp = rse->get_right_se(); + subs_gbrefs_se(se,Schema); + return; + } + subs_gbrefs_se(se->get_left_se(),Schema); + subs_gbrefs_se(se->get_right_se(),Schema); + return; + case SE_AGGR_SE: + lse=se->get_left_se(); + if(lse->get_operator_type()==SE_COLREF && lse->is_gb()){ + se->lhs.scalarp = lse->get_right_se(); + subs_gbrefs_se(se,Schema); + return; + } + subs_gbrefs_se(se->get_left_se(),Schema); + return; + case SE_FUNC: + operand_list = se->get_operands(); + for(p=0;pget_operator_type()==SE_COLREF && lse->is_gb()){ + se->param_list[p] = lse->get_right_se(); + subs_gbrefs_se(se,Schema); + return; + } + } + for(p=0;p op_list; +int o; +scalarexp_t *lse,*rse; + + switch(pr->get_operator_type()){ + case PRED_COMPARE: + lse=pr->get_left_se(); + if(lse->get_operator_type()==SE_COLREF && lse->is_gb()){ + pr->lhs.sexp = lse->get_right_se(); + subs_gbrefs_pr(pr,Schema); + return; + } + rse=pr->get_right_se(); + if(rse->get_operator_type()==SE_COLREF && rse->is_gb()){ + pr->rhs.sexp = rse->get_right_se(); + subs_gbrefs_pr(pr,Schema); + return; + } + subs_gbrefs_se(pr->get_left_se(),Schema); + subs_gbrefs_se(pr->get_right_se(),Schema); + return; + case PRED_IN: + lse=pr->get_left_se(); + if(lse->get_operator_type()==SE_COLREF && lse->is_gb()){ + pr->lhs.sexp = lse->get_right_se(); + subs_gbrefs_pr(pr,Schema); + return; + } + subs_gbrefs_se(pr->get_left_se(),Schema); + return; + case PRED_UNARY_OP: + subs_gbrefs_pr(pr->get_left_pr(),Schema); + return; + case PRED_BINARY_OP: + subs_gbrefs_pr(pr->get_left_pr(),Schema); + subs_gbrefs_pr(pr->get_right_pr(),Schema); + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_operator_type()==SE_COLREF && lse->is_gb()){ + pr->param_list[o] = lse->get_right_se(); + subs_gbrefs_pr(pr,Schema); + return; + } + subs_gbrefs_se(op_list[o],Schema); + } + return; + default: + fprintf(stderr,"INTERNAL ERROR in subs_gbrefs_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } +} + + +// Search for references to "expensive" fields. +int expensive_refs_se(scalarexp_t *se, table_list *Schema){ + int p; + vector operand_list; + int cnt=0; +table_def *td; +param_list *plist; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_IFACE_PARAM: + case SE_PARAM: + case SE_AGGR_STAR: + case SE_AGGR_SE: + return 0; + case SE_COLREF: + if(se->is_gb()) + return expensive_refs_se(se->rhs.scalarp,Schema); + td = Schema->get_table(se->lhs.colref->schema_ref); + plist = td->get_modifier_list(se->lhs.colref->field); + if(plist->contains_key("expensive")) + return 1; + return 0; + case SE_UNARY_OP: + return expensive_refs_se(se->get_left_se(),Schema); + case SE_BINARY_OP: + cnt += expensive_refs_se(se->get_left_se(),Schema); + cnt += expensive_refs_se(se->get_right_se(),Schema); + return cnt; + case SE_FUNC: + operand_list = se->get_operands(); + for(p=0;p op_list; +int o; +int cnt=0; + + switch(pr->get_operator_type()){ + case PRED_COMPARE: + cnt += expensive_refs_se(pr->get_left_se(),Schema); + cnt += expensive_refs_se(pr->get_right_se(),Schema); + return cnt; + case PRED_IN: + return expensive_refs_se(pr->get_left_se(),Schema); + case PRED_UNARY_OP: + return expensive_refs_pr(pr->get_left_pr(),Schema); + case PRED_BINARY_OP: + cnt += expensive_refs_pr(pr->get_left_pr(),Schema); + cnt += expensive_refs_pr(pr->get_right_pr(),Schema); + return cnt; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } +} + + +// TODO: allow "cheap" functions and predicates. +bool simple_field_constraint(cnf_elem *c){ + vector ll; + int l; + predicate_t *p = c->pr; + int l_agr, l_gb, l_par, l_func, l_op; + int r_agr, r_gb, r_par, r_func, r_op; + col_id_set left_colids, right_colids; + +// Verify that it is a simple atom + switch(p->get_operator_type()){ + case PRED_COMPARE: +// Must be an equality predicate which references +// which referecnes no aggregates, parameters, functions, or +// group-by variables, and should be a constraint of +// a single colref. +// AND should not require a complex comparison. + if(p->get_op() != "=") return(false); + analyze_constraint_se(p->get_left_se(),l_agr, l_gb, l_par, l_func,l_op,NULL,false); + analyze_constraint_se(p->get_right_se(),r_agr, r_gb, r_par, r_func,l_op,NULL,false); + if(l_agr>0 || l_gb>0 || l_par>0 || l_func>0 || + r_agr>0 || r_gb>0 || r_par>0 || r_func>0 ) return(false); +// I will count on there being no gbvars in the constraint. +// TODO: allow gbvars which are colrefs. + gather_se_col_ids(p->get_left_se(), left_colids, NULL); + gather_se_col_ids(p->get_right_se(), right_colids, NULL); + if(left_colids.size()+right_colids.size() != 1) return(false); + + +// Normalize : the colref should be on the lhs. + if(right_colids.size() > 0){ + p->swap_scalar_operands(); + } + +// Disallow complex (and therefore expensive) comparisons. + if(p->get_left_se()->get_data_type()->complex_comparison( + p->get_right_se()->get_data_type() ) ) + return(false); + +// passed all the tests. + return(true); + case PRED_IN: +// LHS must be a non-gbvar colref. + analyze_constraint_se(p->get_left_se(),l_agr, l_gb, l_par, l_func,l_op,NULL,false); + if(l_agr>0 || l_gb>0 || l_par>0 || l_func>0 ) return(false); +// I will count on there being no gbvars in the constraint. +// TODO: allow gbvars which are colrefs. + gather_se_col_ids(p->get_left_se(), left_colids, NULL); + if(left_colids.size() != 1) return(false); +// Disallow complex (and therefore expensive) comparisons. + if(p->get_left_se()->get_data_type()->complex_comparison( + p->get_left_se()->get_data_type() ) ) + return(false); + + +// All entries in the IN list must be literals +// Currently, this is the only possibility. + return(true); + break; + case PRED_UNARY_OP: + return(false); + case PRED_BINARY_OP: + return(false); + case PRED_FUNC: + return(false); + default: + fprintf(stderr,"INTERNAL ERROR in simple_field_cosntraint, line %d, character %d, unknown predicate operator type %d\n", + p->get_lineno(), p->get_charno(), p->get_operator_type() ); + exit(1); + } + + return(false); +} + +// As the name implies, return the colref constrained by the +// cnf elem. I will be counting on the LHS being a SE pointing +// to a colref. + +// This fcn assumes that in fact exactly +// one colref is constrained. +colref_t *get_constrained_colref(scalarexp_t *se){ + int p; + vector operand_list; +colref_t *ret; + + switch(se->get_operator_type()){ + case SE_LITERAL: + return(NULL); + case SE_PARAM: + case SE_IFACE_PARAM: + return(NULL); + case SE_COLREF: + return(se->get_colref()); + case SE_UNARY_OP: + return(get_constrained_colref(se->get_left_se())); + case SE_BINARY_OP: + ret=get_constrained_colref(se->get_left_se()); + if(ret == NULL) return(get_constrained_colref(se->get_right_se())); + else return ret; + case SE_AGGR_STAR: + case SE_AGGR_SE: + return(NULL); + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return NULL; + + operand_list = se->get_operands(); + for(p=0;pget_left_se())); +} +colref_t *get_constrained_colref(cnf_elem *c){ + return get_constrained_colref(c->pr->get_left_se()); +} + + + + +/* +void add_colref_constraint_to_cnf(cnf_elem *dst, predicate_t *src_p, + string target_fld, string target_tbl, int tblref){ + +// Make a copy of the predicate to be added. +// ASSUME no aggregates. + predicate_t *pr = dup_pr(src_p,NULL); + +// Modify the ref to the base table. +// ASSUME lhs is the colref + pr->get_left_se()->get_colref()->set_table_name(target_tbl); + pr->get_left_se()->get_colref()->set_table_ref(tblref); + + if(dst->pr == NULL) dst->pr = pr; + else dst->pr = new predicate_t("OR", dst->pr, pr); + +} +*/ + + +////////////////////////////////////////////////////// +/////////////// Represent a node in a predicate tree +struct common_pred_node{ + set lftas; + predicate_t *pr; + vector predecessor_preds; + vector children; + + string target_tbl; + string target_fld; + int target_ref; + + common_pred_node(){ + pr = NULL; + } +}; + + +predicate_t *make_common_pred(common_pred_node *pn){ + int n; + + if(pn->children.size() == 0){ + if(pn->pr == NULL){ + fprintf(stderr,"INTERNAL ERROR in make_common_pred, pred node ahs no children and no predicate.\n"); + exit(1); + } + return( dup_pr(pn->pr,NULL) ); + } + + predicate_t *curr_pr = make_common_pred( pn->children[0] ); + for(n=1;nchildren.size();++n){ + curr_pr = new predicate_t("OR", make_common_pred(pn->children[n]),curr_pr); + } + + if(pn->pr != NULL) + curr_pr = new predicate_t("AND", dup_pr(pn->pr,NULL), curr_pr); + + return(curr_pr); +} + + +bool operator<(const cnf_set &c1, const cnf_set &c2){ + if(c1.lfta_id.size() < c2.lfta_id.size()) + return true; + return false; +} + + +// Compute the predicates for the prefilter. +// the prefilter preds are returned in prefilter_preds. +// pred_ids is the set of predicates used in the prefilter. +// the encoding is the lfta index, in the top 16 bits, +// then the index of the cnf element in the bottom 16 bits. +// This set of for identifying which preds do not need +// to be generated in the lftas. +void find_common_filter(vector< vector > &where_list, table_list *Schema, ext_fcn_list *Ext_fcns, vector &prefilter_preds, set &pred_ids){ + int p, p2, l, c; + + vector pred_list, sort_list; + +// Create list of tagged, prefilter-safe CNFs. + for(l=0;lpr,Schema)==0) + pred_list.push_back(new cnf_set(where_list[l][c]->pr,l,c)); + } + } + } + +// Eliminate duplicates + for(p=0;ppr, pred_list[p2]->pr,Schema)){ + pred_list[p]->subsume(pred_list[p2]); + delete pred_list[p2]; + pred_list[p2] = NULL; + } + } + } + } + } + +// combine preds that occur in the exact same lftas. + for(p=0;plfta_id == pred_list[p2]->lfta_id){ + pred_list[p]->combine_pred(pred_list[p2]); + delete pred_list[p2]; + pred_list[p2] = NULL; + } + } + } + } + } + +// Compress the list + for(p=0;padd_pred_ids(pred_ids); + } + +// Substitute gb refs with their defs +// While I'm at it, substitute base table sch ref for tblref. + for(p=0;ppr,Schema); + } + +} + + + + + +/////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +// Find partial functions and register them. +// Do a DFS so that nested partial fcn calls +// get evaluated in the right order. +// Don't drill down into aggregates -- their arguments are evaluated +// earlier than the select list is. +// +// Modification for function caching: +// Pass in a ref counter, and partial fcn indicator. +// Cache fcns ref'd at least once. +// pass in NULL for fcn_ref_cnt to turn off fcn caching analysis + + +void find_partial_fcns(scalarexp_t *se, vector *pf_list, + vector *fcn_ref_cnt, vector *is_partial_fcn, + ext_fcn_list *Ext_fcns){ + vector operands; + int o, f; + + if(se == NULL) return; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_UNARY_OP: + find_partial_fcns(se->get_left_se(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns) ; + return; + case SE_BINARY_OP: + find_partial_fcns(se->get_left_se(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns); + find_partial_fcns(se->get_right_se(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns); + return; + case SE_COLREF: + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: +// find_partial_fcns(se->get_left_se(), pf_list, Ext_fcns) ; + return; + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return; + + operands = se->get_operands(); + for(o=0;ois_partial(se->get_fcn_id()) || Ext_fcns->get_fcn_cost(se->get_fcn_id()) >= COST_HIGH){ + if(fcn_ref_cnt){ + for(f=0;fsize();++f){ + if(is_equivalent_se(se,(*pf_list)[f])){ + se->set_partial_ref(f); + (*fcn_ref_cnt)[f]++; + break; + } + } + }else{ + f=pf_list->size(); + } + if(f==pf_list->size() && (Ext_fcns->is_partial(se->get_fcn_id()) || fcn_ref_cnt)){ + se->set_partial_ref(pf_list->size()); + pf_list->push_back(se); + if(fcn_ref_cnt){ + fcn_ref_cnt->push_back(1); + is_partial_fcn->push_back(Ext_fcns->is_partial(se->get_fcn_id())); + } + } + } + return; + default: + fprintf(stderr,"INTERNAL ERROR in find_partial_fcns, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return; +} + + +void find_partial_fcns_pr(predicate_t *pr, vector *pf_list, + vector *fcn_ref_cnt, vector *is_partial_fcn, + ext_fcn_list *Ext_fcns){ + vector litl; + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + find_partial_fcns(pr->get_left_se(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns) ; + return; + case PRED_COMPARE: + find_partial_fcns(pr->get_left_se(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns) ; + find_partial_fcns(pr->get_right_se(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns) ; + return; + case PRED_UNARY_OP: + find_partial_fcns_pr(pr->get_left_pr(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns); + return; + case PRED_BINARY_OP: + find_partial_fcns_pr(pr->get_left_pr(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns) ; + find_partial_fcns_pr(pr->get_right_pr(), pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + + +void find_combinable_preds(predicate_t *pr, vector *pr_list, + table_list *Schema, ext_fcn_list *Ext_fcns){ + vector litl; + vector op_list; + int f,o; + + switch(pr->get_operator_type()){ + case PRED_IN: + return; + case PRED_COMPARE: + return; + case PRED_UNARY_OP: + find_combinable_preds(pr->get_left_pr(), pr_list, Schema, Ext_fcns); + return; + case PRED_BINARY_OP: + find_combinable_preds(pr->get_left_pr(), pr_list, Schema, Ext_fcns) ; + find_combinable_preds(pr->get_right_pr(), pr_list, Schema, Ext_fcns) ; + return; + case PRED_FUNC: + if(Ext_fcns->is_combinable(pr->get_fcn_id())){ + for(f=0;fsize();++f){ + if(is_equivalent_pred_base(pr,(*pr_list)[f],Schema)){ + pr->set_combinable_ref(f); + break; + } + } + if(f == pr_list->size()){ + pr->set_combinable_ref(pr_list->size()); + pr_list->push_back(pr); + } + } + return; + default: + fprintf(stderr,"INTERNAL ERROR in find_partial_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + +//-------------------------------------------------------------------- +// Collect refs to aggregates. + + +void collect_agg_refs(scalarexp_t *se, set &agg_refs){ + vector operands; + int o; + + if(se == NULL) return; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_UNARY_OP: + collect_agg_refs(se->get_left_se(), agg_refs) ; + return; + case SE_BINARY_OP: + collect_agg_refs(se->get_left_se(), agg_refs); + collect_agg_refs(se->get_right_se(), agg_refs); + return; + case SE_COLREF: + return; + case SE_AGGR_STAR: + case SE_AGGR_SE: + agg_refs.insert(se->get_aggr_ref()); + return; + case SE_FUNC: + if(se->get_aggr_ref() >= 0) agg_refs.insert(se->get_aggr_ref()); + + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return; +} + + +void collect_aggr_refs_pr(predicate_t *pr, set &agg_refs){ + vector litl; + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + collect_agg_refs(pr->get_left_se(), agg_refs) ; + return; + case PRED_COMPARE: + collect_agg_refs(pr->get_left_se(), agg_refs) ; + collect_agg_refs(pr->get_right_se(), agg_refs) ; + return; + case PRED_UNARY_OP: + collect_aggr_refs_pr(pr->get_left_pr(), agg_refs); + return; + case PRED_BINARY_OP: + collect_aggr_refs_pr(pr->get_left_pr(), agg_refs) ; + collect_aggr_refs_pr(pr->get_right_pr(), agg_refs) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + +//-------------------------------------------------------------------- +// Collect previously registered partial fcn refs. +// Do a DFS so that nested partial fcn calls +// get evaluated in the right order. +// Don't drill down into aggregates -- their arguments are evaluated +// earlier than the select list is. +// ------------->>> THEN WHY AM I DRILLING DOWN INTO AGGREGATES? + +void collect_partial_fcns(scalarexp_t *se, set &pfcn_refs){ + vector operands; + int o; + + if(se == NULL) return; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_UNARY_OP: + collect_partial_fcns(se->get_left_se(), pfcn_refs) ; + return; + case SE_BINARY_OP: + collect_partial_fcns(se->get_left_se(), pfcn_refs); + collect_partial_fcns(se->get_right_se(), pfcn_refs); + return; + case SE_COLREF: + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: +// collect_partial_fcns(se->get_left_se(), pfcn_refs) ; + return; + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return; + + operands = se->get_operands(); + for(o=0;ois_partial()){ + pfcn_refs.insert(se->get_partial_ref()); + } + + return; + default: + fprintf(stderr,"INTERNAL ERROR in collect_partial_fcns, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return; +} + + +void collect_partial_fcns_pr(predicate_t *pr, set &pfcn_refs){ + vector litl; + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + collect_partial_fcns(pr->get_left_se(), pfcn_refs) ; + return; + case PRED_COMPARE: + collect_partial_fcns(pr->get_left_se(), pfcn_refs) ; + collect_partial_fcns(pr->get_right_se(), pfcn_refs) ; + return; + case PRED_UNARY_OP: + collect_partial_fcns_pr(pr->get_left_pr(), pfcn_refs); + return; + case PRED_BINARY_OP: + collect_partial_fcns_pr(pr->get_left_pr(), pfcn_refs) ; + collect_partial_fcns_pr(pr->get_right_pr(), pfcn_refs) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return; +} + + + + +/////////////////////////////////////////////////////////////// +//////////// Exported Functions /////////////////////////// +/////////////////////////////////////////////////////////////// + + +// Count and collect refs to interface parameters. + +int count_se_ifp_refs(scalarexp_t *se, set &ifpnames){ + vector operands; + int o; + int ret = 0; + + if(se == NULL) return 0; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + return 0; + case SE_IFACE_PARAM: + ifpnames.insert(se->get_ifpref()->to_string()); + return 1; + case SE_UNARY_OP: + return count_se_ifp_refs(se->get_left_se(), ifpnames) ; + case SE_BINARY_OP: + ret = count_se_ifp_refs(se->get_left_se(), ifpnames); + ret += count_se_ifp_refs(se->get_right_se(), ifpnames); + return ret; + case SE_COLREF: + return 0; + case SE_AGGR_STAR: + return 0; + case SE_AGGR_SE: +// collect_partial_fcns(se->get_left_se(), pfcn_refs) ; + return 0; + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return 0; + + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return 0; +} + + +int count_pr_ifp_refs(predicate_t *pr, set &ifpnames){ + vector litl; + vector op_list; + int o; + int ret = 0; + if(pr == NULL) return 0; + + switch(pr->get_operator_type()){ + case PRED_IN: + return count_se_ifp_refs(pr->get_left_se(), ifpnames) ; + case PRED_COMPARE: + ret = count_se_ifp_refs(pr->get_left_se(), ifpnames) ; + ret += count_se_ifp_refs(pr->get_right_se(), ifpnames) ; + return ret; + case PRED_UNARY_OP: + return count_pr_ifp_refs(pr->get_left_pr(), ifpnames); + case PRED_BINARY_OP: + ret = count_pr_ifp_refs(pr->get_left_pr(), ifpnames) ; + ret += count_pr_ifp_refs(pr->get_right_pr(), ifpnames) ; + return ret; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return 0; +} + +// Resolve ifp refs, convert them to string literals. + +int resolve_se_ifp_refs(scalarexp_t *se, string ifm, string ifn, ifq_t *ifdb, string &err){ + vector operands; + vector ifvals; + int o; + int ierr; + string serr; + int ret = 0; + literal_t *tmp_l; + ifpref_t *ir; + + if(se == NULL) return 0; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + return 0; + case SE_IFACE_PARAM: + ir = se->get_ifpref(); + ifvals = ifdb->get_iface_vals(ifm, ifn, ir->get_pname(), ierr, serr); + if(ierr){ + err += "ERROR looking for parameter "+ir->get_pname()+" in interface "+ifm+"."+ifn+", "+serr+"\n"; + return 1; + } + if(ifvals.size() == 0){ + err += "ERROR looking for parameter "+ir->get_pname()+" in interface "+ifm+"."+ifn+", no parameter values.\n"; + return 1; + } + if(ifvals.size() > 1){ + err += "ERROR looking for parameter "+ir->get_pname()+" in interface "+ifm+"."+ifn+", multiple parameter values ("+int_to_string(ifvals.size())+").\n"; + return 1; + } + tmp_l = new literal_t( ifvals[0]); + se->convert_to_literal(tmp_l); + return 0; + case SE_UNARY_OP: + return resolve_se_ifp_refs( se->get_left_se(), ifm, ifn,ifdb,err) ; + case SE_BINARY_OP: + ret = resolve_se_ifp_refs( se->get_left_se(), ifm, ifn,ifdb,err); + ret += resolve_se_ifp_refs( se->get_right_se(), ifm, ifn,ifdb,err); + return ret; + case SE_COLREF: + return 0; + case SE_AGGR_STAR: + return 0; + case SE_AGGR_SE: +// collect_partial_fcns(se->get_left_se(), pfcn_refs) ; + return 0; + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return 0; + + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return 0; +} + + +int resolve_pr_ifp_refs(predicate_t *pr, string ifm, string ifn, ifq_t *ifdb, string &err){ + vector litl; + vector op_list; + int o; + int ret = 0; + + switch(pr->get_operator_type()){ + case PRED_IN: + return resolve_se_ifp_refs(pr->get_left_se(), ifm, ifn, ifdb, err) ; + case PRED_COMPARE: + ret = resolve_se_ifp_refs(pr->get_left_se(), ifm, ifn, ifdb, err) ; + ret += resolve_se_ifp_refs(pr->get_right_se(), ifm, ifn, ifdb, err) ; + return ret; + case PRED_UNARY_OP: + return resolve_pr_ifp_refs(pr->get_left_pr(), ifm, ifn, ifdb, err); + case PRED_BINARY_OP: + ret = resolve_pr_ifp_refs(pr->get_left_pr(), ifm, ifn, ifdb, err) ; + ret += resolve_pr_ifp_refs(pr->get_right_pr(), ifm, ifn, ifdb, err) ; + return ret; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return 0; +} + + +string impute_query_name(table_exp_t *fta_tree, string default_nm){ + string retval = fta_tree->get_val_of_name("query_name"); + if(retval == "") retval = default_nm; + if(retval == "") retval = "default_query"; + return(retval); +} + +// Convert the parse tree into an intermediate form, +// which admits analysis better. +// +// TODO : rationalize the error return policy. +// +// TODO : the query_summary_class object contains +// the parse tree. +// TODO: revisit the issue when nested subqueries are implemented. +// One possibility: implement accessor methods to hide the +// complexity +// For now: this class contains data structures not in table_exp_t +// (with a bit of duplication) + +// Return NULL on error. +// print error messages to stderr. + + +query_summary_class *analyze_fta(table_exp_t *fta_tree, table_list *schema, + ext_fcn_list *Ext_fcns, string default_name){ + int i,j, k, retval; + +// Create the summary struct -- no analysis is done here. + query_summary_class *qs = new query_summary_class(fta_tree); + qs->query_type = fta_tree->query_type; + +////////////// Do common analysis + +// Extract query name. Already imputed for the qnodes. +// qs->query_name = impute_query_name(fta_tree, default_name); + qs->query_name = default_name; +//printf("query name is %s\n",qs->query_name.c_str()); + +// extract definitions. Don't grab the query name. + + map nmap = fta_tree->get_name_map(); + map::iterator nmi; + for(nmi=nmap.begin(); nmi!=nmap.end(); ++nmi){ + string pname = (*nmi).first; + if(pname != "query_name" ) + (qs->definitions)[pname] = (*nmi).second; + } + +/// +/// FROM analysis + +// First, verify that all the referenced tables are defined. +// Then, bind the tablerefs in the FROM list to schemas in +// the schema list. + tablevar_list_t *tlist = fta_tree->get_from(); + vector tbl_vec = tlist->get_table_list(); + + bool found_error = false; + for(i=0;ifind_tbl(tbl_vec[i]->get_schema_name()); + if(sch_no < 0) { + fprintf(stderr,"Error, table <%s> not found in the schema file\n", + tbl_vec[i]->get_schema_name().c_str() ); + fprintf(stderr,"\tline=%d, char=%d\n",tbl_vec[i]->get_lineno(), + tbl_vec[i]->get_charno() ); + return(NULL); + } + + tbl_vec[i]->set_schema_ref(sch_no); + +// If accessing a UDOP, mangle the name +// This needs to be done in translate_fta.cc, not here. +/* + if(schema->get_schema_type(sch_no) == OPERATOR_VIEW_SCHEMA){ + string mngl_name = tbl_vec[i]->get_schema_name() + silo_nm; + tbl_vec[i]->set_schema_name(mngl_name); + } +*/ + +// No FTA schema should have an interface defined on it. + if(tbl_vec[i]->get_interface()!="" && schema->get_schema_type(sch_no) != PROTOCOL_SCHEMA){ + fprintf(stderr,"WARNING: interface %s specified for schema %s, but this schema is a STREAM and does not have an interface.\n",tbl_vec[i]->get_interface().c_str(), tbl_vec[i]->get_schema_name().c_str()); + } +// Fill in default interface + if(tbl_vec[i]->get_interface()=="" && schema->get_schema_type(sch_no) == PROTOCOL_SCHEMA){ + tbl_vec[i]->set_interface("default"); + tbl_vec[i]->set_ifq(true); + } +// Fill in default machine + if(tbl_vec[i]->get_interface()!="" && tbl_vec[i]->get_machine()=="" && schema->get_schema_type(sch_no) == PROTOCOL_SCHEMA && (! tbl_vec[i]->get_ifq())){ + tbl_vec[i]->set_machine(hostname); + } + + if(schema->get_schema_type(sch_no) == PROTOCOL_SCHEMA){ +// Record the set of interfaces accessed + string ifstr; + if(tbl_vec[i]->get_ifq()){ + ifstr = "["+tbl_vec[i]->get_interface()+"]"; + }else{ + if(tbl_vec[i]->get_machine() != "localhost"){ + ifstr = "'"+tbl_vec[i]->get_machine()+"'."+tbl_vec[i]->get_interface(); + }else{ + ifstr = tbl_vec[i]->get_interface(); + } + } +//printf("ifstr is %s, i=%d, machine=%s, interface=%s\n",ifstr.c_str(),i,tbl_vec[i]->get_machine().c_str(),tbl_vec[i]->get_interface().c_str()); + if(qs->definitions.count("_referenced_ifaces")){ + ifstr = qs->definitions["_referenced_ifaces"]+","+ifstr; + } + qs->definitions["_referenced_ifaces"] = ifstr; + } + + } + if(found_error) return(NULL); + +// Ensure that all tablevars have are named +// and that no two tablevars have the same name. + int tblvar_no = 0; +// First, gather the set of variable + set tblvar_names; + for(i=0;iget_var_name() != ""){ + if(tblvar_names.count(tbl_vec[i]->get_var_name()) > 0){ + fprintf(stderr,"ERROR, query has two table variables named %s. line=%d, char=%d\n", tbl_vec[i]->get_var_name().c_str(), tbl_vec[i]->get_lineno(), tbl_vec[i]->get_charno()); + return(NULL); + } + tblvar_names.insert(tbl_vec[i]->get_var_name()); + } + } +// Now generate variable names for unnamed tablevars + for(i=0;iget_var_name() == ""){ + char tmpstr[200]; + sprintf(tmpstr,"_t%d",tblvar_no); + string newvar = tmpstr; + while(tblvar_names.count(newvar) > 0){ + tblvar_no++; + sprintf(tmpstr,"_t%d",tblvar_no); + newvar = tmpstr; + } + tbl_vec[i]->set_range_var(newvar); + tblvar_names.insert(newvar); + } + } + +// Process inner/outer join properties + int jprop = fta_tree->get_from()->get_properties(); +// Require explicit INNER_JOIN, ... specification for join queries. + if(jprop < 0){ + if(qs->query_type != MERGE_QUERY && tbl_vec.size() > 1){ + fprintf(stderr,"ERROR, a join query must specify one of INNER_JOIM, OUTER_JOIN, LEFT_OUTER_JOIN, RIGHT_OUTER_JOIN, FILTER_JOIN.\n"); + return(NULL); + } + } + + if(jprop == OUTER_JOIN_PROPERTY){ + for(i=0;iset_property(1); + } + if(jprop == LEFT_OUTER_JOIN_PROPERTY) + tbl_vec[0]->set_property(1); + if(jprop == RIGHT_OUTER_JOIN_PROPERTY) + tbl_vec[tbl_vec.size()-1]->set_property(1); + if(jprop == FILTER_JOIN_PROPERTY){ + if(fta_tree->get_from()->get_temporal_range() == 0){ + fprintf(stderr,"ERROR, a filter join must have a non-zero tempoal range.\n"); + return NULL; + } + if(tbl_vec.size() != 2){ + fprintf(stderr,"ERROR, a filter join must be between two table variables.\n"); + return NULL; + } + colref_t *cr = fta_tree->get_from()->get_colref(); + string field = cr->get_field(); + + int fi0 = schema->get_field_idx(tbl_vec[0]->get_schema_name(), field); + if(fi0 < 0){ + fprintf(stderr,"ERROR, temporal attribute %s for a filter join can't be found in schema %s\n",field.c_str(), tbl_vec[0]->get_schema_name().c_str()); + return NULL; + } + cr->set_schema_ref(tbl_vec[0]->get_schema_ref()); + cr->set_tablevar_ref(0); + string type_name = schema->get_type_name(tbl_vec[0]->get_schema_ref(),field); + param_list *modifiers = schema->get_modifier_list(cr->get_schema_ref(), field); + data_type *dt0 = new data_type(type_name, modifiers); + if(dt0->get_type_str() != "UINT"){ + fprintf(stderr,"ERROR, the temporal attribute in a filter join must be a UINT.\n"); + return NULL; + } + if(! dt0->is_increasing()){ + fprintf(stderr,"ERROR, the temporal attribtue in a filter join must be temporal increasing.\n"); + return NULL; + } + } + + + +///////////////////// +/// Build the query param table + vector query_params = fta_tree->query_params; + int p; + for(p=0;pname; + string dtname = query_params[p]->val; + + if(pname == ""){ + fprintf(stderr,"ERROR parameter has empty name.\n"); + found_error = true; + } + if(dtname == ""){ + fprintf(stderr,"ERROR parameter %s has empty type.\n",pname.c_str()); + found_error = true; + } + data_type *dt = new data_type(dtname); + if(!(dt->is_defined())){ + fprintf(stderr,"ERROR parameter %s has invalid type (%s).\n",pname.c_str(), dtname.c_str()); + found_error = true; + } + + qs->add_query_param(pname, dt, false); + } + if(found_error) return(NULL); +// unpack the param table to a global for easier analysis. + param_tbl=qs->param_tbl; + +////////////////// MERGE specialized analysis + + if(qs->query_type == MERGE_QUERY){ +// Verify that +// 1) there are two *different* streams ref'd in the FROM clause +// However, only emit a warning. +// (can't detect a problem if one of the interfaces is the +// default interface). +// 2) They have the same layout (e.g. same types but the +// names can be different +// 3) the two columns can unambiguously be mapped to +// fields of the two tables, one per table. Exception: +// the column names are the same and exist in both tables. +// FURTHERMORE the positions must be the same +// 4) after mapping, verify that both colrefs are temporal +// and in the same direction. + if(tbl_vec.size() < 2){ + fprintf(stderr,"ERROR, a MERGE query operates over at least 2 tables, %lu were supplied.\n",tbl_vec.size() ); + return(NULL); + } + + vector fev0 = schema->get_fields( + tbl_vec[0]->get_schema_name() + ); + + + int cv; + for(cv=1;cv fev1 = schema->get_fields( + tbl_vec[cv]->get_schema_name() + ); + + if(fev0.size() != fev1.size()){ + fprintf(stderr,"ERROR, the input stream %s to the merge operator has different schema than input stream %s.\n",tbl_vec[cv]->get_schema_name().c_str(), tbl_vec[0]->get_schema_name().c_str()); + return(NULL); + } + +// Only need to ensure that the list of types are the same. +// THe first table supplies the output colnames, +// and all temporal properties are lost, except for the +// merge-by columns. + int f; + for(f=0;fget_type(),fev0[f]->get_modifier_list()); + data_type dt1(fev1[f]->get_type(),fev1[f]->get_modifier_list()); + if(! dt0.equal_subtypes(&dt1) ){ + fprintf(stderr,"ERROR, the input stream %s to the merge operator has different schema than input stream %s.\n",tbl_vec[cv]->get_schema_name().c_str(), tbl_vec[0]->get_schema_name().c_str()); + return(NULL); + } + } + } + +// copy over the merge-by cols. + qs->mvars = fta_tree->mergevars; + + if(qs->mvars.size() == 0){ // need to discover the merge vars. + int mergevar_pos = -1; + int f; + for(f=0;fget_type(),fev0[f]->get_modifier_list()); + if(dt0.is_temporal()){ + mergevar_pos = f; + break; + } + } + if(mergevar_pos >= 0){ + for(cv=0;cv fev1 = schema->get_fields(tbl_vec[cv]->get_schema_name()); + qs->mvars.push_back(new colref_t(tbl_vec[cv]->get_var_name().c_str(),fev1[mergevar_pos]->get_name().c_str() )); + } + }else{ + fprintf(stderr,"ERROR, no merge-by column found.\n"); + return(NULL); + } + } + +// Ensure same number of tables, merge cols. + if(tbl_vec.size() != qs->mvars.size()){ + fprintf(stderr,"ERROR, merge query has different numbers of table variables (%lu) and merge columns (%lu)\n",tbl_vec.size(), qs->mvars.size()); + return(NULL); + } + +// Ensure that the merge-by are from different tables +// also, sort colrefs so that they align with the FROM list using tmp_crl + set refd_sources; + vector tmp_crl(qs->mvars.size(),NULL); + for(cv=0;cvmvars.size();++cv){ + int tblvar=infer_tablevar_from_colref(qs->mvars[cv],fta_tree->fm,schema); + if(tblvar<0){ + fprintf(stderr,"ERROR, Merge column %d (%s) was not found in any of the tables.\n",cv,qs->mvars[cv]->to_string().c_str()); + } + refd_sources.insert(tblvar); + tmp_crl[tblvar] = qs->mvars[cv]; + } + if(refd_sources.size() != qs->mvars.size()){ + fprintf(stderr,"ERROR, The %lu merge columns reference only %lu table variables.\n",qs->mvars.size(), refd_sources.size()); + return(NULL); + } + +// 1-1 mapping, so use tmp_crl as the merge column list. + qs->mvars = tmp_crl; + + + +// Look up the colrefs in their schemas, verify that +// they are at the same place, that they are both temporal +// in the same way. +// It seems that this should be done more in the schema objects. + int fi0 = schema->get_field_idx(tbl_vec[0]->get_schema_name(), qs->mvars[0]->get_field()); + if(fi0 < 0){ + fprintf(stderr,"ERROR, Merge temporal field %s not found.\n",qs->mvars[0]->get_field().c_str()); + exit(1); + } + for(cv=1;cvmvars.size();++cv){ + int fi1 = schema->get_field_idx(tbl_vec[cv]->get_schema_name(), qs->mvars[0]->get_field()); + if(fi0!=fi1){ + fprintf(stderr,"ERROR, the merge columns for table variables %s and %s must be in the same position.\n",tbl_vec[0]->get_var_name().c_str(), tbl_vec[cv]->get_var_name().c_str()); + return NULL; + } + } + + field_entry *fe0 = schema->get_field(tbl_vec[0]->get_schema_name(),fi0); + data_type dt0(fe0->get_type(),fe0->get_modifier_list()); + if( (!dt0.is_temporal()) ){ + fprintf(stderr,"ERROR, merge column %d must be temporal.\n",0); + return(NULL); + } + for(cv=0;cvmvars.size();++cv){ + field_entry *fe1 = schema->get_field(tbl_vec[cv]->get_schema_name(),fi0); + data_type dt1(fe1->get_type(),fe1->get_modifier_list()); + if( (!dt1.is_temporal()) ){ + fprintf(stderr,"ERROR, merge column %d must be temporal.\n",cv); + return(NULL); + } + + + if( dt0.get_temporal() != dt1.get_temporal()){ + fprintf(stderr,"ERROR, the merge columns (0 and %d) must be temporal in the same direction.\n",cv); + return(NULL); + } + } + +// If there is a SLACK specification, verify +// that it is literal-only and that its type is compatible +// with that of the merge columns + qs->slack = fta_tree->slack; + if(qs->slack){ + if(! literal_only_se(qs->slack)){ + fprintf(stderr,"ERROR, the SLACK expression is not literal-only.\n"); + return NULL; + } + + assign_data_types(qs->slack, schema, fta_tree, Ext_fcns ); + data_type sdt(&dt0, qs->slack->get_data_type(), string("+")); + if(sdt.get_type() == undefined_t){ + fprintf(stderr,"ERROR, the SLACK expression data type is not compatible with the data type of the merge columns.\n"); + return NULL; + } + } + + +// All the tests have passed, there is nothing +// else to fill in. + + } + +////////////////// SELECT specialized analysis + + if(qs->query_type == SELECT_QUERY){ +// unpack the gb_tbl, aggr_tbl, param_tbl, and complex_literals +// objects into globals, for easier syntax. + gb_tbl = qs->gb_tbl; + aggr_tbl = qs->aggr_tbl; + + +// Build the table of group-by attributes. +// (se processing done automatically). +// NOTE : Doing the SE processing here is getting cumbersome, +// I should process these individually. +// NOTE : I should check for duplicate names. +// NOTE : I should ensure that the def of one GB does not +// refrence the value of another. + vector gb_list = fta_tree->get_groupby(); + int n_temporal = 0; + string temporal_gbvars = ""; + map gset_gbnames; + +// For generating the set of GB patterns for this aggregation query. + vector inner_pattern; + vector > pattern_set; + vector > > pattern_components; + + vector r_gbs, c_gbs, g_gbs; + int n_patterns; + + for(i=0;itype){ + case gb_egb_type: + retval = gb_tbl->add_gb_attr( + gb_list[i]->gb, fta_tree->fm, schema,fta_tree, Ext_fcns + ); + if(retval < 0){ + return NULL; // nothing added to gb_tbl, so this can trigger a segfault 2 lines below + }else{ + if(gb_tbl->get_data_type(i)->is_temporal()){ + n_temporal++; + if(temporal_gbvars != "") temporal_gbvars+=" "; + temporal_gbvars += gb_tbl->get_name(i); + } + } + + inner_pattern.clear(); + pattern_set.clear(); + inner_pattern.push_back(true); + pattern_set.push_back(inner_pattern); + pattern_components.push_back(pattern_set); + + gb_tbl->gb_entry_type.push_back(""); + gb_tbl->gb_entry_count.push_back(1); + gb_tbl->pattern_components.push_back(pattern_set); + + break; + case rollup_egb_type: + r_gbs = gb_list[i]->gb_lists[0]->get_gb_list(); + for(j=0;jadd_gb_attr( + r_gbs[j], fta_tree->fm, schema,fta_tree, Ext_fcns + ); + if(retval < 0){ + found_error = true; + }else{ // rollup gb can't be temporal + gb_tbl->reset_temporal(gb_tbl->size()-1); + } + } + + inner_pattern.resize(r_gbs.size()); + pattern_set.clear(); + for(j=0;j<=r_gbs.size();++j){ + for(k=0;kgb_entry_type.push_back("ROLLUP"); + gb_tbl->gb_entry_count.push_back(r_gbs.size()); + gb_tbl->pattern_components.push_back(pattern_set); + break; + case cube_egb_type: + c_gbs = gb_list[i]->gb_lists[0]->get_gb_list(); + for(j=0;jadd_gb_attr( + c_gbs[j], fta_tree->fm, schema,fta_tree, Ext_fcns + ); + if(retval < 0){ + found_error = true; + }else{ // cube gb can't be temporal + gb_tbl->reset_temporal(gb_tbl->size()-1); + } + } + + inner_pattern.resize(c_gbs.size()); + pattern_set.clear(); + n_patterns = 1 << c_gbs.size(); + for(j=0;jgb_entry_type.push_back("CUBE"); + gb_tbl->gb_entry_count.push_back(c_gbs.size()); + gb_tbl->pattern_components.push_back(pattern_set); + break; + case gsets_egb_type: + { + gset_gbnames.clear(); + for(j=0;jgb_lists.size();++j){ + g_gbs = gb_list[i]->gb_lists[j]->get_gb_list(); + for(k=0;ktype != GB_COLREF){ + fprintf(stderr,"Error, group-by fields in a GROUPING_SETS clause must be table references, not computed values (field is %s\n",g_gbs[k]->name.c_str()); + found_error = true; + }else{ + if(gset_gbnames.count(g_gbs[k]->name) == 0){ + retval = gb_tbl->add_gb_attr( + g_gbs[k], fta_tree->fm, schema,fta_tree, Ext_fcns + ); + if(retval < 0){ + found_error = true; + }else{ // gsets gb can't be temporal + gb_tbl->reset_temporal(gb_tbl->size()-1); + } + int pos = gset_gbnames.size(); + gset_gbnames[g_gbs[k]->name] = pos; + } + } + } + } + + if(gset_gbnames.size() > 63){ + fprintf(stderr,"Error, at most 63 distinct fields can be referenced in a GROUPING_SETS clause.\n"); + found_error = true; + } + + inner_pattern.resize(gset_gbnames.size()); + pattern_set.clear(); + set signatures; + for(j=0;jgb_lists.size();++j){ + g_gbs = gb_list[i]->gb_lists[j]->get_gb_list(); + set refd_gbs; + for(k=0;kname); + } + fill(inner_pattern.begin(),inner_pattern.end(),false); + unsigned long long int signature = 0; + set::iterator ssi; + for(ssi = refd_gbs.begin(); ssi != refd_gbs.end(); ++ssi){ + inner_pattern[gset_gbnames[(*ssi)]] = true; + signature |= (1 << gset_gbnames[(*ssi)]); + } + if(signatures.count(signature)){ + fprintf(stderr,"Warning, duplicate GROUPING_SETS pattern found, ignoring:\n\t"); + set::iterator ssi; + for(ssi = refd_gbs.begin(); ssi != refd_gbs.end(); ++ssi){ + fprintf(stderr," %s",(*ssi).c_str()); + } + fprintf(stderr,"\n"); + }else{ + signatures.insert(signature); + pattern_set.push_back(inner_pattern); + } + } + pattern_components.push_back(pattern_set); + + gb_tbl->gb_entry_type.push_back("GROUPING_SETS"); + gb_tbl->gb_entry_count.push_back(gset_gbnames.size()); + gb_tbl->pattern_components.push_back(pattern_set); + } + break; + default: + break; + } + } + if(found_error) return(NULL); + if(n_temporal > 1){ + fprintf(stderr,"ERROR, query has multiple temporal group-by variables (%s). Cast away the temporality of all but one of these.\n", temporal_gbvars.c_str()); + return NULL; + } + +// Compute the set of patterns. Take the cross product of all pattern components. + vector > gb_patterns; + int n_components = pattern_components.size(); + vector pattern_pos(n_components,0); + bool done = false; + while(! done){ + vector pattern; + for(j=0;j= pattern_components[j].size()) + pattern_pos[j] = 0; + else + break; + } + if(j >= n_components) + done = true; + } + gb_tbl->gb_patterns = gb_patterns; + + +// Process the supergroup, if any. + vector sgb = fta_tree->get_supergb(); + for(i=0;ifind_gb(sgb[i],fta_tree->fm, schema); + if(gbr < 0){ + fprintf(stderr, "ERROR, supergroup attribute %s is not defined as a group-by variable.\n",sgb[i]->to_string().c_str()); + found_error = true; + } + if(qs->sg_tbl.count(gbr)){ + fprintf(stderr,"WARNING, duplicate supergroup attribute %s.\n",sgb[i]->to_string().c_str()); + } + qs->sg_tbl.insert(gbr); + } + if(found_error) return(NULL); + + if(qs->sg_tbl.size() > 0 && gb_tbl->gb_patterns.size()>0){ + fprintf(stderr,"Error, SUPERGROUP incompatible with CUBE, ROLLUP, and GROUPING_SETS.\n"); + return NULL; + } + + + + predicate_t *wh = fta_tree->get_where(); + predicate_t *hv = fta_tree->get_having(); + predicate_t *cw = fta_tree->get_cleaning_when(); + predicate_t *cb = fta_tree->get_cleaning_by(); + predicate_t *closew = fta_tree->get_closing_when(); + + if(closew != NULL && gb_tbl->gb_patterns.size()>1){ + fprintf(stderr,"Error, CLOSING_WHEN incompatible with CUBE, ROLLUP, and GROUPING_SETS.\n"); + return NULL; + } + + + +// Verify that all column references are valid, and if so assign +// the data type. + + vector sl_list = fta_tree->get_sl_vec(); + for(i=0;ise, fta_tree->fm, schema, gb_tbl); + if(retval < 0) found_error = true; + } + if(wh != NULL) + retval = verify_predicate_colref(wh, fta_tree->fm, schema, gb_tbl); + if(retval < 0) found_error = true; + if(hv != NULL) + retval = verify_predicate_colref(hv, fta_tree->fm, schema, gb_tbl); + if(retval < 0) found_error = true; + if(cw != NULL) + retval = verify_predicate_colref(cw, fta_tree->fm, schema, gb_tbl); + if(retval < 0) found_error = true; + if(cb != NULL) + retval = verify_predicate_colref(cb, fta_tree->fm, schema, gb_tbl); + if(retval < 0) found_error = true; + if(closew != NULL) + retval = verify_predicate_colref(closew, fta_tree->fm, schema, gb_tbl); + if(retval < 0) found_error = true; + + if(found_error) return(NULL); + +// Verify that all of the scalar expressions +// and comparison predicates have compatible types. + + n_temporal = 0; + string temporal_output_fields; + for(i=0;ise, schema, fta_tree, Ext_fcns ); + if(retval < 0){ + found_error = true; + }else{ + if(sl_list[i]->se->get_data_type()->is_temporal()){ + n_temporal++; + temporal_output_fields += " "+int_to_string(i); + } + } + } + if(n_temporal > 1){ + fprintf(stderr,"ERROR, query has multiple temporal output fields (positions%s). Cast away the temporality of all but one of these.\n", temporal_output_fields.c_str()); + found_error=true; + } + if(wh != NULL) + retval = assign_predicate_data_types(wh, schema, fta_tree, Ext_fcns); + if(retval < 0) found_error = true; + if(hv != NULL) + retval = assign_predicate_data_types(hv, schema, fta_tree, Ext_fcns); + if(retval < 0) found_error = true; + if(cw != NULL) + retval = assign_predicate_data_types(cw, schema, fta_tree, Ext_fcns); + if(retval < 0) found_error = true; + if(cb != NULL) + retval = assign_predicate_data_types(cb, schema, fta_tree, Ext_fcns); + if(retval < 0) found_error = true; + if(closew != NULL) + retval = assign_predicate_data_types(closew, schema, fta_tree, Ext_fcns); + if(retval < 0) found_error = true; + + if(found_error) return(NULL); + +// Impute names for the unnamed columns. + set curr_names; + int s; + for(s=0;sname); + } + for(s=0;sname == "") + sl_list[s]->name = impute_colname(curr_names, sl_list[s]->se); + } + + +// Check the aggregates. +// No aggrs allowed in the WHERE predicate. +// (no aggrs in the GB defs, but that is examined elsewhere) +// Therefore, aggregates are allowed only the select clause. +// +// The query is an aggregation query if there is a group-by clause, or +// if any aggregate is referenced. If there is a group-by clause, +// at least one aggregate must be referenced. +// If the query is an aggregate query, the scalar expressions in +// the select clause can reference only constants, aggregates, or group-by +// attributes. +// Also, if the query is an aggregate query, build a table referencing +// the aggregates. +// +// No nested aggregates allowed. +// + +// First, count references in the WHERE predicate. +// (if there are any references, report an error). +// can ref group vars, tuple fields, and stateful fcns. + + if(wh != NULL){ + retval = count_aggr_pred(wh, true); + if(retval > 0){ + fprintf(stderr,"ERROR, no aggregate references are allowed in the WHERE clause.\n"); + return(NULL); + } + } + +// NOTE : Here I need an analysis of the having clause +// to verify that it only refs GB attrs and aggregates. +// (also, superaggregates, stateful fcns) + if(hv!=NULL){ + retval = verify_having_pred(hv, "HAVING", Ext_fcns); + if(retval < 0) return(NULL); + } + +// Cleaning by has same reference rules as Having + if(cb!=NULL){ + retval = verify_having_pred(cb, "CLEANING_BY", Ext_fcns); + if(retval < 0) return(NULL); + } + +// Cleaning when has same reference rules as Having, +// except that references to non-superaggregates are not allowed. +// This is tested for when "CLEANING_BY" is passed in as the clause. + if(cw!=NULL){ + retval = verify_having_pred(cw, "CLEANING_WHEN", Ext_fcns); + if(retval < 0) return(NULL); + } + +// CLOSING_WHEN : same rules as HAVING + if(closew!=NULL){ + retval = verify_having_pred(closew, "CLOSING_WHEN", Ext_fcns); + if(retval < 0) return(NULL); + } + + +// Collect aggregates in the HAVING and CLEANING clauses + if(hv != NULL){ + build_aggr_tbl_fm_pred(hv, aggr_tbl, Ext_fcns); + } + if(cw != NULL){ + build_aggr_tbl_fm_pred(cw, aggr_tbl, Ext_fcns); + } + if(cb != NULL){ + build_aggr_tbl_fm_pred(cb, aggr_tbl, Ext_fcns); + } + if(closew != NULL){ + build_aggr_tbl_fm_pred(closew, aggr_tbl, Ext_fcns); + } + +// Collect aggregate refs in the SELECT clause. + + for(i=0;ise, aggr_tbl, Ext_fcns); + + +// Collect references to states of stateful functions + if(wh != NULL){ + gather_fcn_states_pr(wh, qs->states_refd, Ext_fcns); + } + if(hv != NULL){ + gather_fcn_states_pr(hv, qs->states_refd, Ext_fcns); + } + if(cw != NULL){ + gather_fcn_states_pr(cw, qs->states_refd, Ext_fcns); + } + if(cb != NULL){ + gather_fcn_states_pr(cb, qs->states_refd, Ext_fcns); + } + if(closew != NULL){ // should be no stateful fcns here ... + gather_fcn_states_pr(closew, qs->states_refd, Ext_fcns); + } + for(i=0;ise, qs->states_refd, Ext_fcns); + + +// If this is an aggregate query, it had normally references +// some aggregates. Its not necessary though, just emit a warning. +// (acts as SELECT DISTINCT) + + bool is_aggr_query = gb_tbl->size() > 0 || aggr_tbl->size() > 0; + if(is_aggr_query && aggr_tbl->size() == 0){ + fprintf(stderr,"Warning, query contains a group-by clause but does not reference aggregates..\n"); + } + +// If this is an aggregate query, +// 1) verify that the SEs in the SELECT clause reference +// only constants, aggregates, and group-by attributes. +// 2) No aggregate scalar expression references an aggregate +// or any stateful function. +// 3) either it references both CLEANING clauses or neither. +// 4) all superaggregates must have the superaggr_allowed property. +// 5) all aggregates ref'd in the CLEANING_WHEN ad CLEANING_BY +// clauses must have the multiple_output property. + + + if(is_aggr_query){ + if(gb_list.size() == 0){ + fprintf(stderr,"ERROR, aggregation queries must have at least one group-by variable (which should be temporal).\n"); + return NULL; + } +// Ensure that at least one gbvar is temporal + if(! fta_tree->name_exists("no_temporal_aggr")){ + bool found_temporal = false; + for(i=0;isize();i++){ + if(gb_tbl->get_data_type(i)->is_temporal()){ + found_temporal = true; + } + } + if(! found_temporal){ + fprintf(stderr,"ERROR, at least one of the group-by variables must be temporal (unless no_temporal_aggr is set)\n"); + exit(1); + } + } + + if((!cb && cw) || (cb && !cw)){ + fprintf(stderr,"ERROR, an aggregate query must either include both a CLEANING_WHEN and a CLEANING_BY clause, or neither.\n"); + return(NULL); + } + + bool refs_running = false; + int a; + for(a=0; asize(); ++a){ + refs_running |= aggr_tbl->is_running_aggr(a); + } + + if(closew){ + if(cb || cw){ + fprintf(stderr, "ERROR, cannot reference both CLOSING_WHEN and either CLEANING_WHEN or CLEANING_BY.\n"); + return(NULL); + } + if(!refs_running){ + fprintf(stderr, "ERROR, if you reference CLOSING_WHEN you must reference at least one running window aggregate.\n"); + return(NULL); + } + } + + if(refs_running && !closew){ + fprintf(stderr, "ERROR, if you reference a running window aggregate you must reference a CLOSING_WHEN clause.\n"); + return(NULL); + } + + bool st_ok = true; + for(i=0;ise); + st_ok = st_ok && ret_bool; + } + if(! st_ok) + return(NULL); + + for(i=0;isize();i++){ + if(aggr_tbl->is_superaggr(i)){ + if(! aggr_tbl->superaggr_allowed(i)){ + fprintf(stderr,"ERROR, aggregate %s cannot be a superaggregate\n",aggr_tbl->get_op(i).c_str()); + return NULL; + } + } + if(aggr_tbl->is_builtin(i)){ + if(count_aggr_se(aggr_tbl->get_aggr_se(i), true) > 0){ + fprintf(stderr,"ERROR no nested aggregation allowed.\n"); + return(NULL); + } + }else{ + vector opl = aggr_tbl->get_operand_list(i); + int o; + for(o=0;o 0){ + fprintf(stderr,"ERROR no nested aggregation allowed.\n"); + return(NULL); + } + } + } + } + }else{ +// Ensure that non-aggregate query doesn't reference some things + if(cb || cw){ + fprintf(stderr,"ERROR, a non-aggregate query may not reference a CLEANING_WHEN or a CLEANING_BY clause.\n"); + return(NULL); + } + if(closew){ + fprintf(stderr,"ERROR, a non-aggregate query may not reference a CLOSING_WHEN clause.\n"); + return(NULL); + } + if(qs->states_refd.size()){ + fprintf(stderr,"ERROR, a non-aggregate query may not refernece stateful functions.\n"); + return(NULL); + } + } + + + +// Convert the predicates into CNF. OK to pass NULL ptr. + make_cnf_from_pr(wh, qs->wh_cnf); + make_cnf_from_pr(hv, qs->hav_cnf); + make_cnf_from_pr(cb, qs->cb_cnf); + make_cnf_from_pr(cw, qs->cw_cnf); + make_cnf_from_pr(closew, qs->closew_cnf); + +// Analyze the predicates. + + for(i=0;iwh_cnf.size();i++) + analyze_cnf(qs->wh_cnf[i]); + for(i=0;ihav_cnf.size();i++) + analyze_cnf(qs->hav_cnf[i]); + for(i=0;icb_cnf.size();i++) + analyze_cnf(qs->cb_cnf[i]); + for(i=0;icw_cnf.size();i++) + analyze_cnf(qs->cw_cnf[i]); + for(i=0;iclosew_cnf.size();i++) + analyze_cnf(qs->closew_cnf[i]); + + +// At this point, the old analysis program +// gathered all refs to partial functions, +// complex literals, and parameters accessed via a handle. +// I think its better to delay this +// until code generation time, as the query will be +// in general split. + + } + + return(qs); +} + +/////////////////////////////////////////////////////////////////////// + +// Expand gbvars with their definitions. + +scalarexp_t *expand_gbvars_se(scalarexp_t *se, gb_table &gb_tbl){ + int o; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return se; + case SE_UNARY_OP: + se->lhs.scalarp = expand_gbvars_se(se->get_left_se(),gb_tbl); + return se; + case SE_BINARY_OP: + se->lhs.scalarp = expand_gbvars_se(se->get_left_se(),gb_tbl); + se->rhs.scalarp = expand_gbvars_se(se->get_right_se(),gb_tbl); + return se; + case SE_COLREF: + if( se->is_gb() ){ + return( dup_se(gb_tbl.get_def(se->get_gb_ref()),NULL) ); + } + return se; +// don't descend into aggr defs. + case SE_AGGR_STAR: + return se; + case SE_AGGR_SE: + return se; + case SE_FUNC: + for(o=0;oparam_list.size();o++){ + se->param_list[o] = expand_gbvars_se(se->param_list[o], gb_tbl); + } + return se; + default: + fprintf(stderr,"INTERNAL ERROR in expand_gbvars, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return se; +} + +void expand_gbvars_pr(predicate_t *pr, gb_table &gb_tbl){ + vector op_list; + int o; + bool found = false; + + switch(pr->get_operator_type()){ + case PRED_IN: + pr->lhs.sexp = expand_gbvars_se(pr->get_left_se(), gb_tbl); + return; + case PRED_COMPARE: + pr->lhs.sexp = expand_gbvars_se(pr->get_left_se(),gb_tbl) ; + pr->rhs.sexp = expand_gbvars_se(pr->get_right_se(),gb_tbl) ; + return; + case PRED_UNARY_OP: + expand_gbvars_pr(pr->get_left_pr(),gb_tbl) ; + return; + case PRED_BINARY_OP: + expand_gbvars_pr(pr->get_left_pr(),gb_tbl) ; + expand_gbvars_pr(pr->get_right_pr(),gb_tbl) ; + return; + case PRED_FUNC: + for(o=0;oparam_list.size();++o){ + pr->param_list[o] = expand_gbvars_se(pr->param_list[o],gb_tbl) ; + } + return; + default: + fprintf(stderr,"INTERNAL ERROR in expand_gbvars_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + } + return; +} + + + + +// return true if the se / pr contains any gbvar on the list. + + +bool contains_gb_se(scalarexp_t *se, set &gref_set){ + vector operands; + int o; + bool found = false; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return false; + case SE_UNARY_OP: + return contains_gb_se(se->get_left_se(),gref_set); + case SE_BINARY_OP: + return( contains_gb_se(se->get_left_se(),gref_set) || + contains_gb_se(se->get_right_se(),gref_set) ); + case SE_COLREF: + if( se->is_gb() ){ + return( gref_set.count(se->get_gb_ref()) > 0); + } + return false; +// don't descend into aggr defs. + case SE_AGGR_STAR: + return false; + case SE_AGGR_SE: + return false; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } + return false; +} + + +bool contains_gb_pr(predicate_t *pr, set &gref_set){ + vector op_list; + int o; + bool found = false; + + switch(pr->get_operator_type()){ + case PRED_IN: + return contains_gb_se(pr->get_left_se(), gref_set); + case PRED_COMPARE: + return (contains_gb_se(pr->get_left_se(),gref_set) + || contains_gb_se(pr->get_right_se(),gref_set) ); + case PRED_UNARY_OP: + return contains_gb_pr(pr->get_left_pr(),gref_set) ; + case PRED_BINARY_OP: + return (contains_gb_pr(pr->get_left_pr(),gref_set) + || contains_gb_pr(pr->get_right_pr(),gref_set) ); + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } + + return found; +} + + +// Gather the set of columns accessed in this se. +// Descend into aggregate functions. + +void gather_se_col_ids(scalarexp_t *se, col_id_set &cid_set, gb_table *gtbl){ + col_id ci; + vector operands; + int o; + + if(! se) + return; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_UNARY_OP: + gather_se_col_ids(se->get_left_se(),cid_set,gtbl); + return; + case SE_BINARY_OP: + gather_se_col_ids(se->get_left_se(),cid_set,gtbl); + gather_se_col_ids(se->get_right_se(),cid_set,gtbl); + return; + case SE_COLREF: + if(! se->is_gb() ){ + ci.load_from_colref(se->get_colref() ); + if(ci.tblvar_ref < 0){ + fprintf(stderr,"INTERNAL WARNING: unbound colref (%s) accessed.\n",ci.field.c_str()); + } + cid_set.insert(ci); + }else{ + if(gtbl==NULL){ + fprintf(stderr,"INTERNAL ERROR: gbvar ref in gather_se_col_ids, but gtbl is NULL.\n"); + exit(1); + } + gather_se_col_ids(gtbl->get_def(se->get_gb_ref()),cid_set,gtbl); + } + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: + gather_se_col_ids(se->get_left_se(),cid_set,gtbl); + return; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } +} + + +// Gather the set of columns accessed in this se. + +void gather_pr_col_ids(predicate_t *pr, col_id_set &cid_set, gb_table *gtbl){ + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + gather_se_col_ids(pr->get_left_se(), cid_set,gtbl); + return; + case PRED_COMPARE: + gather_se_col_ids(pr->get_left_se(),cid_set,gtbl) ; + gather_se_col_ids(pr->get_right_se(),cid_set,gtbl) ; + return; + case PRED_UNARY_OP: + gather_pr_col_ids(pr->get_left_pr(),cid_set,gtbl) ; + return; + case PRED_BINARY_OP: + gather_pr_col_ids(pr->get_left_pr(),cid_set,gtbl) ; + gather_pr_col_ids(pr->get_right_pr(),cid_set,gtbl) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } +} + + + + +// Gather the set of special operator or comparison functions referenced by this se. + +void gather_se_opcmp_fcns(scalarexp_t *se, set &fcn_set){ + col_id ci; + data_type *ldt, *rdt; + int o; + vector operands; + + switch(se->get_operator_type()){ + case SE_LITERAL: + if( se->get_literal()->constructor_name() != "") + fcn_set.insert( se->get_literal()->constructor_name() ); + return; + case SE_PARAM: + return; +// SE_IFACE_PARAM should not exist when this is called. + case SE_UNARY_OP: + ldt = se->get_left_se()->get_data_type(); + if(ldt->complex_operator(se->get_op()) ){ + fcn_set.insert( ldt->get_complex_operator(se->get_op()) ); + } + gather_se_opcmp_fcns(se->get_left_se(),fcn_set); + return; + case SE_BINARY_OP: + ldt = se->get_left_se()->get_data_type(); + rdt = se->get_right_se()->get_data_type(); + + if(ldt->complex_operator(rdt, se->get_op()) ){ + fcn_set.insert( ldt->get_complex_operator(rdt, se->get_op()) ); + } + gather_se_opcmp_fcns(se->get_left_se(),fcn_set); + gather_se_opcmp_fcns(se->get_right_se(),fcn_set); + return; + case SE_COLREF: + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: + gather_se_opcmp_fcns(se->get_left_se(),fcn_set); + return; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } +} + + +// Gather the set of special operator or comparison functions referenced by this se. + +void gather_pr_opcmp_fcns(predicate_t *pr, set &fcn_set){ + data_type *ldt, *rdt; + vector operands; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + ldt = pr->get_left_se()->get_data_type(); + if(ldt->complex_comparison(ldt) ){ + fcn_set.insert( ldt->get_comparison_fcn(ldt) ); + } + gather_se_opcmp_fcns(pr->get_left_se(), fcn_set); + return; + case PRED_COMPARE: + ldt = pr->get_left_se()->get_data_type(); + rdt = pr->get_right_se()->get_data_type(); + if(ldt->complex_comparison(rdt) ){ + fcn_set.insert( ldt->get_comparison_fcn(rdt) ); + } + gather_se_opcmp_fcns(pr->get_left_se(),fcn_set) ; + gather_se_opcmp_fcns(pr->get_right_se(),fcn_set) ; + return; + case PRED_UNARY_OP: + gather_pr_opcmp_fcns(pr->get_left_pr(),fcn_set) ; + return; + case PRED_BINARY_OP: + gather_pr_opcmp_fcns(pr->get_left_pr(),fcn_set) ; + gather_pr_opcmp_fcns(pr->get_right_pr(),fcn_set) ; + return; + case PRED_FUNC: + operands = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } +} + + + + +// find the temporal variable divisor if any. +// Only forms allowed : temporal_colref, temporal_colref/const +// temporal_colref/const + const + + +long long int find_temporal_divisor(scalarexp_t *se, gb_table *gbt,string &fnm){ + long long int retval = 0; + data_type *ldt, *rdt; + int o; + vector operands; + scalarexp_t *t_se, *c_se; + string the_op; + + switch(se->get_operator_type()){ + case SE_LITERAL: + return(-1); + case SE_PARAM: + return(-1); +// SE_IFACE_PARAM should not exist when this is called. + case SE_UNARY_OP: + return(-1); + case SE_BINARY_OP: + ldt = se->get_left_se()->get_data_type(); + if(ldt->is_temporal()){ + t_se = se->get_left_se(); + c_se = se->get_right_se(); + }else{ + t_se = se->get_left_se(); + c_se = se->get_right_se(); + } + if((! t_se->get_data_type()->is_temporal()) || c_se->get_data_type()->is_temporal()) + return -1; + + the_op = se->get_op(); + if(the_op == "+" || the_op == "-") + return find_temporal_divisor(t_se, gbt,fnm); + if(the_op == "/"){ + if(t_se->get_operator_type() == SE_COLREF && c_se->get_operator_type() == SE_LITERAL){ + fnm = t_se->get_colref()->get_field(); + string lits = c_se->get_literal()->to_string(); + sscanf(lits.c_str(),"%qd",&retval); + return retval; + } + } + + return -1; + case SE_COLREF: + if(se->is_gb()){ + return find_temporal_divisor(gbt->get_def(se->get_gb_ref()), gbt,fnm); + } + if(se->get_data_type()->is_temporal()){ + fnm = se->get_colref()->get_field(); + return 1; + } + return 0; + case SE_AGGR_STAR: + return -1; + case SE_AGGR_SE: + return -1; + case SE_FUNC: + return -1; + default: + fprintf(stderr,"INTERNAL ERROR in find_temporal_divisor, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } +} + + +// impute_colnames: +// Create meaningful but unique names for the columns. +string impute_colname(vector &sel_list, scalarexp_t *se){ + set curr_names; + int s; + for(s=0;sname); + } + return impute_colname(curr_names, se); +} + +string impute_colname(set &curr_names, scalarexp_t *se){ +string ret; +scalarexp_t *seo; +vector operand_list; +string opstr; + + switch(se->get_operator_type()){ + case SE_LITERAL: + ret = "Literal"; + break; + case SE_PARAM: + ret = "Param_" + se->get_param_name(); + break; + case SE_IFACE_PARAM: + ret = "Iparam_" + se->get_ifpref()->get_pname(); + break; + case SE_COLREF: + ret = se->get_colref()->get_field() ; + break; + case SE_UNARY_OP: + case SE_BINARY_OP: + ret = "Field"; + break; + case SE_AGGR_STAR: + ret = "Cnt"; + break; + case SE_AGGR_SE: + ret = se->get_op(); + seo = se->get_left_se(); + switch(se->get_left_se()->get_operator_type()){ + case SE_PARAM: + ret += "_PARAM_"+seo->get_param_name(); + break; + case SE_IFACE_PARAM: + ret += "_IPARAM_"+seo->get_ifpref()->get_pname(); + break; + case SE_COLREF: + opstr = seo->get_colref()->get_field(); + if(strncmp(ret.c_str(), opstr.c_str(),ret.size())){ + ret += "_" + opstr; + }else{ + ret = opstr; + } + break; + case SE_AGGR_STAR: + case SE_AGGR_SE: + opstr = seo->get_op(); + if(strncmp(ret.c_str(), opstr.c_str(),ret.size())){ + ret += "_" + seo->get_op(); + }else{ + ret = opstr; + } + break; + case SE_FUNC: + opstr = seo->get_op(); + ret += "_" + seo->get_op(); + break; + case SE_UNARY_OP: + case SE_BINARY_OP: + ret += "_SE"; + break; + default: + ret += "_"; + break; + } + break; + case SE_FUNC: + ret = se->get_op(); + operand_list = se->get_operands(); + if(operand_list.size() > 0){ + seo = operand_list[0]; + switch(seo->get_operator_type()){ + case SE_PARAM: + ret += "_PARAM_"+seo->get_param_name(); + break; + case SE_IFACE_PARAM: + ret += "_IPARAM_"+seo->get_ifpref()->get_pname(); + break; + case SE_COLREF: + ret += "_" + seo->get_colref()->get_field(); + break; + case SE_AGGR_STAR: + case SE_AGGR_SE: + case SE_FUNC: + ret += "_" + seo->get_op(); + break; + case SE_UNARY_OP: + case SE_BINARY_OP: + ret += "_SE"; + break; + default: + ret += "_"; + break; + } + }else{ + ret += "_func"; + } + break; + } + + if(ret == "Field"){ + if(curr_names.count("Field0") == 0) + ret = "Field0"; + } + int iter = 1; + string base = ret; + while(curr_names.count(ret) > 0){ + char tmpstr[500]; + sprintf(tmpstr,"%s%d",base.c_str(),iter); + ret = tmpstr; + iter++; + } + + + curr_names.insert(ret); + return(ret); + +} + + + +////////////////////////////////////////////////////////////////////// +////////////// Methods of defined classes /////////////////////// +////////////////////////////////////////////////////////////////////// + +// helper fcn to enable col_id as map key. + + bool operator<(const col_id &cr1, const col_id &cr2){ + if(cr1.tblvar_ref < cr2.tblvar_ref) return(true); + if(cr1.tblvar_ref == cr2.tblvar_ref) + return (cr1.field < cr2.field); + return(false); + } + + +// Process the GB variables. +// At parse time, GB vars are either GB_COLREF, +// or GB_COMPUTED if the AS keyword is used. +// Cast GB vars as named entities with a SE as +// their definition (the colref in the case of GB_COLREF). +// +// TODO: if there is a gbref in a gbdef, +// then I won't be able to compute the value without +// a complex dependence analysis. So verify that there is no +// gbref in any of the GBdefs. +// BUT: a GBVAR_COLREF should be converted to a regular colref, +// which is not yet done. +// +// TODO : sort out issue of GBVAR naming and identification. +// Determine where it is advantageous to convert GV_COLREF +// GBVARS to colrefs -- e.g. in group definition, in the WHERE clause, +// etc. +// +// return -1 if there is a problem. + +int gb_table::add_gb_attr( + gb_t *gb, + tablevar_list_t *fm, + table_list *schema, + table_exp_t *fta_tree, + ext_fcn_list *Ext_fcns + ){ + colref_t *cr; + int retval; + gb_table_entry *entry; + + if(gb->type == GB_COLREF){ + if(gb->table != "") + cr = new colref_t( + gb->interface.c_str(),gb->table.c_str(), gb->name.c_str() + ); + else + cr = new colref_t(gb->name.c_str()); + + int tablevar_ref = infer_tablevar_from_colref(cr, fm, schema); + if(tablevar_ref < 0) return(tablevar_ref); + + cr->set_tablevar_ref(tablevar_ref); + cr->set_schema_ref(fm->get_schema_ref(tablevar_ref)); + cr->set_interface(""); + cr->set_table_name(fm->get_tablevar_name(tablevar_ref)); + + entry = new gb_table_entry(); + entry->name.field = cr->get_field(); + entry->name.tblvar_ref = tablevar_ref; + entry->definition = new scalarexp_t(cr); + entry->ref_type = GBVAR_COLREF; + }else{ + entry = new gb_table_entry(); + entry->name.field = gb->name; + entry->name.tblvar_ref = -1; + entry->definition = gb->def; + entry->ref_type = GBVAR_SE; + } + + retval = verify_colref(entry->definition, fm, schema, NULL); + if(retval < 0) return(retval); + + retval = assign_data_types(entry->definition, schema, fta_tree, Ext_fcns); + if(retval < 0) return(retval); + +// Verify that the gbvar def references no aggregates and no gbvars. + if(count_gb_se(entry->definition) > 0){ + fprintf(stderr,"ERROR, group-by variable %s references other group-by variables in its definition.\n",entry->name.field.c_str() ); + return(-1); + } + if(count_aggr_se(entry->definition, true) > 0){ + fprintf(stderr,"ERROR, group-by variable %s references aggregates in its definition.\n",entry->name.field.c_str() ); + return(-1); + } + +// Check for duplicates + int i; + for(i=0;iname.field == gtbl[i]->name.field){ + fprintf(stderr,"ERROR, duplicate group-by variable name %s, positions %d and %lu.\n",entry->name.field.c_str(),i,gtbl.size()); + return -1; + } + } + + + gtbl.push_back(entry); + + return(1); +} + + +// Try to determine if the colref is actually +// a gbvar ref. +// a) if no tablename associated with the colref, +// 1) try to find a matching GB_COMPUTED gbvar. +// 2) failing that, try to match to a single tablevar +// 3) if successful, search among GB_COLREF +// b) else, try to match the tablename to a single tablevar +// if successful, search among GB_COLREF +int gb_table::find_gb(colref_t *cr, tablevar_list_t *fm, table_list *schema){ + string c_field = cr->get_field(); + int c_tblref; + int n_tbl; + int i; + vector candidates; + + if(cr->uses_default_table()){ + for(i=0;iref_type==GBVAR_SE && c_field == gtbl[i]->name.field){ + return(i); + } + } + candidates = find_source_tables(c_field, fm, schema); + if(candidates.size() != 1) return(-1); // can't find unique tablevar + for(i=0;iref_type==GBVAR_COLREF && + c_field == gtbl[i]->name.field && + candidates[0] == gtbl[i]->name.tblvar_ref){ + return(i); + } + } + return(-1); // colref is not in gb table. + } + +// A table name must have been given. + vector fm_tbls = fm->get_table_list(); + string interface = cr->get_interface(); + string table_name = cr->get_table_name(); + + +// if no interface name is given, try to search for the table +// name among the tablevar names first. + if(interface==""){ + for(i=0;iget_var_name() && interface == fm_tbls[i]->get_interface()) + candidates.push_back(i); + } + if(candidates.size()>1) return(-1); + if(candidates.size()==1){ + for(i=0;iref_type==GBVAR_COLREF && + c_field == gtbl[i]->name.field && + candidates[0] == gtbl[i]->name.tblvar_ref){ + return(i); + } + } + return(-1); // match semantics of bind to tablevar name first + } + } + +// Interface name given, or no interface but no +// no tablevar match. Try to match on schema name. + for(i=0;iget_var_name() && interface == fm_tbls[i]->get_interface()) + candidates.push_back(i); + } + if(candidates.size() != 1) return(-1); + for(i=0;iref_type==GBVAR_COLREF && + c_field == gtbl[i]->name.field && + candidates[0] == gtbl[i]->name.tblvar_ref){ + return(i); + } + } + +// No match found. + return(-1); + +} + + + +bool aggr_table_entry::fta_legal(ext_fcn_list *Ext_fcns){ + if(is_builtin()){ + if( (op == "COUNT") || (op == "SUM") || (op == "MIN") || + (op == "MAX") || (op == "AND_AGGR") || (op == "OR_AGGR") || + (op == "XOR_AGGR") ) + return(true); + }else{ + return Ext_fcns->fta_legal(fcn_id); + } + return(false); +} + + +// Return the set of subaggregates required to compute +// the desired aggregate. THe operand of the subaggregates +// can only be * or the scalarexp used in the superaggr. +// This is indicated by the use_se vector. + +// Is this code generation specific? + +vector aggr_table_entry::get_subaggr_fcns(vector &use_se){ + vector ret; + + if(op == "COUNT"){ + ret.push_back("COUNT"); + use_se.push_back(false); + } + if(op == "SUM"){ + ret.push_back("SUM"); + use_se.push_back(true); + } + if(op == "AVG"){ + ret.push_back("SUM"); + ret.push_back("COUNT"); + use_se.push_back(true); + use_se.push_back(false); + } + if(op == "MIN"){ + ret.push_back("MIN"); + use_se.push_back(true); + } + if(op == "MAX"){ + ret.push_back("MAX"); + use_se.push_back(true); + } + if(op == "AND_AGGR"){ + ret.push_back("AND_AGGR"); + use_se.push_back(true); + } + if(op == "OR_AGGR"){ + ret.push_back("OR_AGGR"); + use_se.push_back(true); + } + if(op == "XOR_AGGR"){ + ret.push_back("XOR_AGGR"); + use_se.push_back(true); + } + + return(ret); +} + +// Code generation specific? + +vector aggr_table_entry::get_subaggr_dt(){ + vector ret; + data_type *dt; + + if(op == "COUNT"){ + dt = new data_type("Int"); // was Uint + ret.push_back( dt ); + } + if(op == "SUM"){ + dt = new data_type(); + dt->set_aggr_data_type( "SUM",operand->get_data_type() ); + ret.push_back(dt); + } + if(op == "AVG"){ + dt = new data_type(); + dt->set_aggr_data_type( "SUM",operand->get_data_type() ); + ret.push_back( dt ); + dt = new data_type("Int"); + ret.push_back( dt ); + } + if(op == "MIN"){ + dt = new data_type(); + dt->set_aggr_data_type( "MIN",operand->get_data_type() ); + ret.push_back( dt ); + } + if(op == "MAX"){ + dt = new data_type(); + dt->set_aggr_data_type( "MAX",operand->get_data_type() ); + ret.push_back( dt ); + } + if(op == "AND_AGGR"){ + dt = new data_type(); + dt->set_aggr_data_type( "AND_AGGR",operand->get_data_type() ); + ret.push_back( dt ); + } + if(op == "OR_AGGR"){ + dt = new data_type(); + dt->set_aggr_data_type( "OR_AGGR",operand->get_data_type() ); + ret.push_back( dt ); + } + if(op == "XOR_AGGR"){ + dt = new data_type(); + dt->set_aggr_data_type( "XOR_AGGR",operand->get_data_type() ); + ret.push_back( dt ); + } + + return(ret); +} + +// Code generation specific? + +scalarexp_t *aggr_table_entry::make_superaggr_se(vector se_refs){ + scalarexp_t *se_l, *se_r, *ret_se = NULL; + + if(op == "COUNT"){ + ret_se = scalarexp_t::make_se_aggr("SUM", se_refs[0]); + return(ret_se); + } + if(op == "SUM"){ + ret_se = scalarexp_t::make_se_aggr("SUM", se_refs[0]); + return(ret_se); + } + if(op == "AVG"){ + se_l = scalarexp_t::make_se_aggr("SUM", se_refs[0]); + se_r = scalarexp_t::make_se_aggr("SUM", se_refs[1]); + + ret_se = new scalarexp_t("/", se_l, se_r); + return(ret_se); + } + if(op == "MIN"){ + ret_se = scalarexp_t::make_se_aggr("MIN", se_refs[0]); + return(ret_se); + } + if(op == "MAX"){ + ret_se = scalarexp_t::make_se_aggr("MAX", se_refs[0]); + return(ret_se); + } + if(op == "AND_AGGR"){ + ret_se = scalarexp_t::make_se_aggr("AND_AGGR", se_refs[0]); + return(ret_se); + } + if(op == "OR_AGGR"){ + ret_se = scalarexp_t::make_se_aggr("OR_AGGR", se_refs[0]); + return(ret_se); + } + if(op == "XOR_AGGR"){ + ret_se = scalarexp_t::make_se_aggr("XOR_AGGR", se_refs[0]); + return(ret_se); + } + + return(ret_se); + +} + + +// Add a built-in aggr. +int aggregate_table::add_aggr(string op, scalarexp_t *se, bool is_super){ + int i; + + for(i=0;iis_builtin() && op == agr_tbl[i]->op + && is_equivalent_se(se,agr_tbl[i]->operand) ){ +// && is_super == agr_tbl[i]->is_superaggr()) + if(is_super) agr_tbl[i]->set_super(true); + return(i); + } + } + + aggr_table_entry *ate = new aggr_table_entry(op, se, is_super); + agr_tbl.push_back(ate); + return(agr_tbl.size() - 1); +} + +// add a UDAF +int aggregate_table::add_aggr(string op, int fcn_id, vector opl, data_type *sdt, bool is_super, bool is_running, bool has_lfta_bailout){ + int i,o; + + for(i=0;iis_builtin()) && fcn_id == agr_tbl[i]->fcn_id + && opl.size() == agr_tbl[i]->oplist.size() ){ +// && is_super == agr_tbl[i]->is_superaggr() ){ + for(o=0;ooplist[o]) ) + break; + } + if(o == opl.size()){ + if(is_super) agr_tbl[i]->set_super(true); + return i; + } + } + } + + aggr_table_entry *ate = new aggr_table_entry(op, fcn_id, opl, sdt,is_super,is_running, has_lfta_bailout); + agr_tbl.push_back(ate); + return(agr_tbl.size() - 1); +} + + +int cplx_lit_table::add_cpx_lit(literal_t *l, bool is_handle_ref){ + int i; + + for(i=0;iis_equivalent(cplx_lit_tbl[i])){ + hdl_ref_tbl[i] = hdl_ref_tbl[i] | is_handle_ref; + return(i); + } + } + + cplx_lit_tbl.push_back(l); + hdl_ref_tbl.push_back(is_handle_ref); + return(cplx_lit_tbl.size() - 1); +} + + + +//------------------------------------------------------------ +// parse_fta code + + +gb_t *gb_t::duplicate(){ + gb_t *ret = new gb_t(interface.c_str(), table.c_str(), name.c_str()); + ret->type = type; + ret->lineno = lineno; + ret->charno = charno; + if(def != NULL) + ret->def = dup_se(def,NULL); + return ret; +} diff --git a/src/ftacmp/analyze_fta.h b/src/ftacmp/analyze_fta.h new file mode 100644 index 0000000..32833c5 --- /dev/null +++ b/src/ftacmp/analyze_fta.h @@ -0,0 +1,784 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __ANALYZE_FTA_H_DEFINED__ +#define __ANALYZE_FTA_H_DEFINED__ + + + +#include "parse_fta.h" +#include "parse_schema.h" +#include"type_objects.h" +#include "parse_ext_fcns.h" +#include "iface_q.h" + + +#include +#include +using namespace std; + + +// Represent a component of a predicate, +// these components are ANDed together. +// Often they are simple enough to analyze. +class cnf_elem{ +public: + int is_atom; // i.e., is an atomic predicate + int eq_pred; // And, it is a test for equality + int in_pred; // Or, it is a an IN predicate + + int pr_gb; // the predicate refs a gb column. + int pr_attr; // the predicate refs a table column. + int pr_aggr; // the predicate refs an aggregate + + int l_simple; // the lhs is simple (just a colref) + int l_gb; // the lhs refs a gb var + int l_attr; // the lhs refs a table column + int l_aggr; // the lhs refs an aggregate. + + int r_simple; // the rhs is simple (just a colref) + int r_gb; // the rhs refs a gb var + int r_attr; // the rhs refs a table column + int r_aggr; // the rhs refs an aggregate. + + int cost; // an estiamte of the evaluation cost. + + predicate_t *pr; + + cnf_elem(predicate_t *p){ + is_atom = 0; + eq_pred = 0; in_pred = 0; + pr_gb = pr_attr = pr_aggr = 0; + l_simple = l_gb = l_attr = l_aggr = 0; + r_simple = r_gb = r_attr = r_aggr = 0; + pr = p; + }; + + cnf_elem(){ is_atom = 0; + eq_pred = 0; in_pred = 0; + pr_gb = pr_attr = pr_aggr = 0; + l_simple = l_gb = l_attr = l_aggr = 0; + r_simple = r_gb = r_attr = r_aggr = 0; + pr = NULL; + }; + + + + void swap_scalar_operands(){ + int tmp; + if(in_pred) return; // can't swap IN predicates, se list always on right. + if(! is_atom) return; // can only swap scalar expressions. + + tmp = l_simple; l_simple = r_simple; r_simple = tmp; + tmp = l_gb; l_gb = r_gb; r_gb = tmp; + tmp = l_attr; l_attr = r_attr; r_attr = tmp; + tmp = l_aggr; l_aggr = r_aggr; r_aggr = tmp; + + pr->swap_scalar_operands(); + } +}; + + +// A GB variable is identified by its name and +// its source table variable -- so that joins can be expressed. +// GB Vars defined AS a scalar expression have a null tableref. + +struct col_id{ + std::string field; + int tblvar_ref; +// Also carry the schema ref -- used to get data type info +// when defining variables. + int schema_ref; + + col_id(){tblvar_ref = -1;}; + col_id(colref_t *cr){ + field = cr->field; + tblvar_ref = cr-> get_tablevar_ref(); + schema_ref = cr->get_schema_ref(); + }; + + + + void load_from_colref(colref_t *cr){ + field = cr->field; + tblvar_ref = cr-> get_tablevar_ref(); + schema_ref = cr->get_schema_ref(); + }; +}; + +struct lt_col_id{ + bool operator()(const col_id &cr1, const col_id &cr2) const{ + if(cr1.tblvar_ref < cr2.tblvar_ref) return(1); + if(cr1.tblvar_ref == cr2.tblvar_ref) + return (cr1.field < cr2.field); + return(0); + } +}; + + bool operator<(const col_id &cr1, const col_id &cr2); + + +// Every GB variable is represented by its name +// (defined above) and the scalar expression which +// defines its value. If the GB var is devlared as a +// colref, the add_gb_attr method of gb_table will +// create an SE consisting of the colref. +// NOTE : using col_id is dangerous when the +// agregation operator is defiend over a self-join + +#define GBVAR_COLREF 1 +#define GBVAR_SE 2 + +struct gb_table_entry{ + col_id name; // tblref in col_id refers to the tablevar. + scalarexp_t *definition; + int ref_type; + + gb_table_entry(){ + definition = NULL; + }; + data_type *get_data_type(){ + return(definition->get_data_type()); + }; + void reset_temporal(){ + if(definition) definition->reset_temporal(); + } +}; + + +// The GB table is the symbol table containing +// the GB vars. This object puts a wrapper around +// access to the table. + +class gb_table{ +private: + std::vector gtbl; + +public: + std::vector > gb_patterns; +// rollup, cube, and grouping_sets cannot be readily reconstructed by +// analyzing the patterns, so explicitly record them here. +// used only so that sgah_qpn::to_query_string produces +// something meaningful. + std::vector gb_entry_type; + std::vector gb_entry_count; + std::vector > > pattern_components; + + gb_table(){}; + + int add_gb_attr(gb_t *c, tablevar_list_t *fm, table_list *schema, + table_exp_t *fta_tree, ext_fcn_list *Ext_fcns); + + void add_gb_var(std::string n, int t, scalarexp_t *d, int rt){ + gb_table_entry *entry = new gb_table_entry(); + entry->name.field = n; + entry->name.tblvar_ref = t; + entry->definition = d; + entry->ref_type = rt; + gtbl.push_back(entry); + }; + data_type *get_data_type(int g){return(gtbl[g]->get_data_type()); }; + int find_gb(colref_t *c, tablevar_list_t *fm, table_list *schema); + scalarexp_t *get_def(int i){return gtbl[i]->definition; }; + std::string get_name(int i){return gtbl[i]->name.field; }; + int get_tblvar_ref(int i){return gtbl[i]->name.tblvar_ref; }; + int get_reftype(int i){return gtbl[i]->ref_type; }; + int size(){return(gtbl.size()); }; + void set_pattern_info(gb_table *g){ + gb_patterns = g->gb_patterns; + gb_entry_type = g->gb_entry_type; + gb_entry_count = g->gb_entry_count; + pattern_components = g->pattern_components; + } + void reset_temporal(int i){ + gtbl[i]->reset_temporal(); + } +}; + + + +// Represent an aggregate to be calculated. +// The unique identifier is the aggregate fcn, and the +// expression aggregated over. +// TODO: unify udaf with built-in better +// (but then again, the core dumps help with debugging) + +struct aggr_table_entry{ + std::string op; + scalarexp_t *operand; + std::vector oplist; + int fcn_id; // -1 for built-in aggrs. + data_type *sdt; // storage data type. + data_type *rdt; // return value data type. + bool is_superag; + bool is_running; + bool bailout; + + aggr_table_entry(){ sdt = NULL; rdt = NULL; is_superag = false;}; + aggr_table_entry(std::string o, scalarexp_t *se, bool s){ + op = o; operand = se; fcn_id = -1; sdt = NULL; + if(se){ + rdt = new data_type(); + rdt->set_aggr_data_type(o,se->get_data_type()); + }else{ + rdt = new data_type("INT"); + } + is_superag = s; + is_running = false; + bailout = false; + }; + aggr_table_entry(std::string o, int f, std::vector s, data_type *st, bool spr, bool r, bool b_o){ + op = o; + fcn_id = f; + operand = NULL; + oplist = s; + sdt = st; + rdt = NULL; + is_superag = spr; + is_running = r; + bailout = b_o; + } + + bool fta_legal(ext_fcn_list *Ext_fcns); + bool is_star_aggr(){return operand==NULL;}; + bool is_builtin(){return fcn_id < 0;}; + int get_fcn_id(){return fcn_id;}; + bool is_superaggr(){return is_superag;}; + bool is_running_aggr(){return is_running;}; + bool has_bailout(){return bailout;}; + void set_super(bool s){is_superag = s;}; + + std::vector get_subaggr_fcns(std::vector &use_se); + std::vector get_subaggr_dt(); + scalarexp_t *make_superaggr_se(std::vector se_refs); + data_type *get_storage_type(){return sdt;}; + std::vector get_operand_list(){return oplist;}; + + aggr_table_entry *duplicate(){ + aggr_table_entry *dup = new aggr_table_entry(); + dup->op = op; + dup->operand = operand; + dup->oplist = oplist; + dup->fcn_id = fcn_id; + dup->sdt = sdt; + dup->rdt = rdt; + dup->is_superag = is_superag; + dup->is_running = is_running; + dup->bailout = bailout; + return dup; + } + + static bool superaggr_allowed(std::string op, ext_fcn_list *Ext_fcns){ + if(op == "SUM" || op == "COUNT" || op == "MIN" || op=="MAX") + return true; + return false; + } + + bool superaggr_allowed(){ + if(is_builtin()) + return aggr_table_entry::superaggr_allowed(op,NULL); +// Currently, no UDAFS allowed as superaggregates + return false; + } + + static bool multiple_return_allowed(bool is_built_in, ext_fcn_list *Ext_fcns, int fcn_id){ + if(is_built_in) + return true; +// Currently, no UDAFS allowed as stateful fcn params. +// in cleaning_when, cleaning_by clauses. + if(Ext_fcns->is_running_aggr(fcn_id) || Ext_fcns->multiple_returns(fcn_id)) + return true; + return false; + } + +}; + + +class aggregate_table{ +public: + std::vector agr_tbl; + + aggregate_table(){}; + + int add_aggr(std::string op, scalarexp_t *se, bool is_spr); + int add_aggr(std::string op, int fcn_id, std::vector opl, data_type *sdt, bool is_spr, bool is_running, bool has_lfta_bailout); + int add_aggr(aggr_table_entry *a){agr_tbl.push_back(a); return agr_tbl.size(); }; + int size(){return(agr_tbl.size()); }; + scalarexp_t *get_aggr_se(int i){return agr_tbl[i]->operand; }; + + data_type *get_data_type(int i){ +// if(agr_tbl[i]->op == "COUNT") +// return new data_type("uint"); +// else + if(! agr_tbl[i]->rdt){ + fprintf(stderr,"INTERNAL ERROR in aggregate_table::get_data_type : rdt is NULL.\n"); + exit(1); + } + return agr_tbl[i]->rdt; + }; + + std::string get_op(int i){return agr_tbl[i]->op;}; + + bool fta_legal(int i,ext_fcn_list *Ext_fcns){return agr_tbl[i]->fta_legal(Ext_fcns); }; + bool is_star_aggr(int i){return agr_tbl[i]->is_star_aggr(); }; + bool is_builtin(int i){return agr_tbl[i]->is_builtin(); }; + int get_fcn_id(int i){return agr_tbl[i]->get_fcn_id();}; + bool is_superaggr(int i){return agr_tbl[i]->is_superaggr();}; + bool is_running_aggr(int i){return agr_tbl[i]->is_running_aggr();}; + bool has_bailout(int i){return agr_tbl[i]->has_bailout();}; +// bool multiple_return_allowed(int i){ +// return agr_tbl[i]->multiple_return_allowed(agr_tbl[i]->is_builtin(),NULL); +// }; + bool superaggr_allowed(int i){return agr_tbl[i]->superaggr_allowed();}; + std::vector get_operand_list(int i){ + return agr_tbl[i]->get_operand_list(); + } + + std::vector get_subaggr_fcns(int i, std::vector &use_se){ + return(agr_tbl[i]->get_subaggr_fcns(use_se) ); + }; + + std::vector get_subaggr_dt(int i){ + return(agr_tbl[i]->get_subaggr_dt() ); + } + data_type *get_storage_type(int i){ + return( agr_tbl[i]->get_storage_type()); + } + + aggr_table_entry *duplicate(int i){ + return agr_tbl[i]->duplicate(); + }; + + scalarexp_t *make_superaggr_se(int i, std::vector se_refs){ + return(agr_tbl[i]->make_superaggr_se(se_refs) ); + }; +}; + + +class cplx_lit_table{ + std::vector cplx_lit_tbl; + std::vector hdl_ref_tbl; + +public: + cplx_lit_table(){}; + + int add_cpx_lit(literal_t *, bool); + int size(){return cplx_lit_tbl.size();}; + literal_t *get_literal(int i){return cplx_lit_tbl[i];}; + bool is_handle_ref(int i){return hdl_ref_tbl[i];}; + +}; + +enum param_handle_type { cplx_lit_e, litval_e, param_e}; + +class handle_param_tbl_entry{ +private: + +public: + std::string fcn_name; + int param_slot; + literal_t *litval; + int complex_literal_idx; + std::string param_name; + param_handle_type val_type; + std::string type_name; + + handle_param_tbl_entry(std::string fname, int slot, + literal_t *l, std::string tnm){ + fcn_name = fname; param_slot = slot; + val_type = litval_e; + litval = l; + type_name = tnm; + }; + handle_param_tbl_entry(std::string fname, int slot, std::string p, std::string tnm){ + fcn_name = fname; param_slot = slot; + val_type = param_e; + param_name = p; + type_name = tnm; + }; + handle_param_tbl_entry(std::string fname, int slot, int ci, std::string tnm){ + fcn_name = fname; param_slot = slot; + val_type = cplx_lit_e; + complex_literal_idx = ci; + type_name = tnm; + }; + + std::string lfta_registration_fcn(){ + char tmps[500]; + sprintf(tmps,"register_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot); + return(tmps); + }; + std::string hfta_registration_fcn(){return lfta_registration_fcn();}; + + std::string lfta_deregistration_fcn(){ + char tmps[500]; + sprintf(tmps,"deregister_handle_for_%s_slot_%d",fcn_name.c_str(),param_slot); + return(tmps); + }; + std::string hfta_rdeegistration_fcn(){return lfta_registration_fcn();}; + +}; + + +class param_table{ +// Store the data in vectors to preserve +// listing order. + std::vector pname; + std::vector pdtype; + std::vector phandle; + + int find_name(std::string n){ + int p; + for(p=0;p get_param_names(){ + return(pname); + }; + + data_type *get_data_type(std::string pnm){ + int p = find_name(pnm); + if(p >= 0){ + return(pdtype[p]); + } + return(new data_type("undefined_type")); + }; + + bool handle_access(std::string pnm){ + int p = find_name(pnm); + if(p >= 0){ + return(phandle[p]); + } + return(false); + }; + +}; + + +// Two columns are the same if they come from the +// same source, and have the same field name. +// (use to determine which fields must be unpacked). +// NOTE : dangerous in the presence of self-joins. +typedef std::set col_id_set; + +bool contains_gb_pr(predicate_t *pr, std::set &gref_set); +bool contains_gb_se(scalarexp_t *se, std::set &gref_set); + + +void gather_se_col_ids(scalarexp_t *se, col_id_set &cid_set, gb_table *gtbl); +void gather_pr_col_ids(predicate_t *pr, col_id_set &cid_set, gb_table *gtbl); + +void gather_se_opcmp_fcns(scalarexp_t *se, std::set &fcn_set); +void gather_pr_opcmp_fcns(predicate_t *pr, std::set &fcn_set); + +//////////////////////////////////////////// +// Structures to record usage of operator views. + +class opview_entry{ +public: + std::string parent_qname; + std::string root_name; + std::string view_name; + std::string exec_fl; // name of executable file (if any) + std::string udop_alias; // unique ID of the UDOP + std::string mangler; + int liveness_timeout; // maximum delay between hearbeats from udop + int pos; + std::vector subq_names; + + opview_entry(){mangler="";}; +}; + +class opview_set{ +public: + std::vector opview_list; + + int append(opview_entry *opv){opview_list.push_back(opv); + return opview_list.size()-1;}; + int size(){return opview_list.size();}; + opview_entry *get_entry(int i){ return opview_list[i];}; +}; + +///////////////////////////////////////////////////////////////// +// Wrap up all of the analysis of the FTA into this package. +// +// There is some duplication between query_summary_class, +// but I'd rather avoid pushing analysis structures +// into the parse modules. +// +// TODO: revisit the issue when nested subqueries are implemented. +// One possibility: implement accessor methods to hide the +// complexity +// For now: this class contains data structures not in table_exp_t +// (with a bit of duplication) + +struct query_summary_class{ + std::string query_name; // the name of the query, becomes the name + // of the output. + int query_type; // e.g. SELECT, MERGE, etc. + + gb_table *gb_tbl; // Table of all group-by attributes. + std::set sg_tbl; // Names of the superGB attributes + aggregate_table *aggr_tbl; // Table of all referenced aggregates. + std::set states_refd; // states ref'd by stateful fcns. + + +// copied from parse tree, then into query node. +// interpret the string representation of data type into a type_object + param_table *param_tbl; // Table of all query parameters. + +// There is stuff that is not copied over by analyze_fta, +// it still resides in fta_tree. + table_exp_t *fta_tree; // The (decorated) parse tree. + + +// This is copied from the parse tree (except for "query_name") +// then copied to the query node in query_plan.cc:145 + std::map definitions; // additional definitions. + + +// CNF representation of the where and having predicates. + std::vector wh_cnf; + std::vector hav_cnf; + std::vector cb_cnf; + std::vector cw_cnf; + std::vector closew_cnf; + + + + +// For MERGE type queries. + std::vector mvars; + scalarexp_t *slack; + +//////// Constructors + query_summary_class(){ + init(); + } + + query_summary_class(table_exp_t *f){ + fta_tree = f; + init(); + } + +///// Methods + + bool add_query_param(std::string pnm, data_type *pdt, bool use_handle){ + return( param_tbl->add_param(pnm,pdt,use_handle)); + }; + + +private: + void init(){ +// Create the gb_tbl, aggr_tbl, and param_tbl objects + gb_tbl = new gb_table(); + aggr_tbl = new aggregate_table(); + param_tbl = new param_table(); + + } +}; + +int verify_colref(scalarexp_t *se, tablevar_list_t *fm, + table_list *schema, gb_table *gtbl); +std::string impute_query_name(table_exp_t *fta_tree, std::string default_nm); + +query_summary_class *analyze_fta(table_exp_t *fta_tree, table_list *schema, ext_fcn_list *Ext_fcns, std::string qname); +bool is_equivalent_se(scalarexp_t *se1, scalarexp_t *se2); +bool is_equivalent_se_base(scalarexp_t *se1, scalarexp_t *se2, table_list *Schema); +bool is_equivalent_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema); + +bool is_equivalent_class_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema,ext_fcn_list *Ext_fcns); +void analyze_cnf(cnf_elem *c); + +void find_partial_fcns(scalarexp_t *se, std::vector *pf_list, std::vector *fcn_ref_cnt, std::vector *is_partial_fcn, ext_fcn_list *Ext_fcns); +void find_partial_fcns_pr(predicate_t *pr, std::vector *pf_list,std::vector *fcn_ref_cnt, std::vector *is_partial_fcn, ext_fcn_list *Ext_fcns); +void collect_partial_fcns(scalarexp_t *se, std::set &pfcn_refs); +void collect_partial_fcns_pr(predicate_t *pr, std::set &pfcn_refs); + +void find_combinable_preds(predicate_t *pr, vector *pr_list, + table_list *Schema, ext_fcn_list *Ext_fcns); + +void collect_agg_refs(scalarexp_t *se, std::set &agg_refs); +void collect_aggr_refs_pr(predicate_t *pr, std::set &agg_refs); + +int bind_to_schema_pr(predicate_t *pr, tablevar_list_t *fm, table_list *schema); +int bind_to_schema_se(scalarexp_t *se, tablevar_list_t *fm, table_list *schema); + +temporal_type compute_se_temporal(scalarexp_t *se, std::map &tcol); + + +bool find_complex_literal_se(scalarexp_t *se, ext_fcn_list *Ext_fcns, + cplx_lit_table *complex_literals); +void find_complex_literal_pr(predicate_t *pr, ext_fcn_list *Ext_fcns, + cplx_lit_table *complex_literals); +void find_param_handles_se(scalarexp_t *se, ext_fcn_list *Ext_fcns, + std::vector &handle_tbl); +void find_param_handles_pr(predicate_t *pr, ext_fcn_list *Ext_fcns, + std::vector &handle_tbl); + +// Copy a scalar expression / predicate tree +scalarexp_t *dup_se(scalarexp_t *se, aggregate_table *aggr_tbl); +select_element *dup_select(select_element *sl, aggregate_table *aggr_tbl); +predicate_t *dup_pr(predicate_t *pr, aggregate_table *aggr_tbl); + +// Expand gbvars +void expand_gbvars_pr(predicate_t *pr, gb_table &gb_tbl); +scalarexp_t *expand_gbvars_se(scalarexp_t *se, gb_table &gb_tbl); + + +// copy a query +table_exp_t *dup_table_exp(table_exp_t *te); + + +// Tie colrefs to a new range var +void bind_colref_se(scalarexp_t *se, + std::vector &fm, + int prev_ref, int new_ref + ); +void bind_colref_pr(predicate_t *pr, + std::vector &fm, + int prev_ref, int new_ref + ); + + +std::string impute_colname(std::vector &sel_list, scalarexp_t *se); +std::string impute_colname(std::set &curr_names, scalarexp_t *se); + +bool is_literal_or_param_only(scalarexp_t *se); + + +void build_aggr_tbl_fm_pred(predicate_t *pr, aggregate_table *agr_tbl); +void build_aggr_tbl_fm_se(scalarexp_t *se, aggregate_table *agr_tbl); + +void compute_cnf_cost(cnf_elem *cm, ext_fcn_list *Ext_fcns); +struct compare_cnf_cost{ + bool operator()(const cnf_elem *c1, const cnf_elem *c2) const{ + if(c1->cost < c2->cost) return(true); + return(false); + } +}; + +void get_tablevar_ref_se(scalarexp_t *se, std::vector &reflist); +void get_tablevar_ref_pr(predicate_t *pr, std::vector &reflist); + +long long int find_temporal_divisor(scalarexp_t *se, gb_table *gbt, std::string &fnm); + + +int count_se_ifp_refs(scalarexp_t *se, std::set &ifpnames); +int count_pr_ifp_refs(predicate_t *pr, std::set &ifpnames); +int resolve_se_ifp_refs(scalarexp_t *se, std::string ifm, std::string ifn, ifq_t *ifdb, std::string &err); +int resolve_pr_ifp_refs(predicate_t *pr, std::string ifm, std::string ifn, ifq_t *ifdb, std::string &err); + +int pred_refs_sfun(predicate_t *pr); +int se_refs_sfun(scalarexp_t *se); + + +// Represent preds for the prefilter, and +// the LFTAs which reference them. +struct cnf_set{ + predicate_t *pr; + std::set lfta_id; + std::set pred_id; + + cnf_set(){}; + cnf_set(predicate_t *p, unsigned int l, unsigned int i){ + pr = dup_pr(p,NULL); // NEED TO UPDATE dup_se TO PROPAGATE + lfta_id.insert(l); + pred_id.insert((l << 16)+i); + } + void subsume(cnf_set *c){ + std::set::iterator ssi; + for(ssi=c->lfta_id.begin();ssi!=c->lfta_id.end();++ssi){ + lfta_id.insert((*ssi)); + } + std::set::iterator spi; + for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){ + pred_id.insert((*spi)); + } + } + void combine_pred(cnf_set *c){ + pr = new predicate_t("AND",pr,c->pr); + std::set::iterator spi; + for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){ + pred_id.insert((*spi)); + } + } + + void add_pred_ids(set &pred_set){ + std::set::iterator spi; + for(spi=pred_id.begin();spi!=pred_id.end();++spi){ + pred_set.insert((*spi)); + } + } + + static unsigned int make_lfta_key(unsigned int l){ + return l << 16; + } + + + ~cnf_set(){}; +}; +struct compare_cnf_set{ + bool operator()(const cnf_set *c1, const cnf_set *c2) const{ + if(c1->lfta_id.size() > c2->lfta_id.size()) return(true); + return(false); + } +}; + +bool operator<(const cnf_set &c1, const cnf_set &c2); + + +void find_common_filter(std::vector< std::vector > &where_list, table_list *Schema, ext_fcn_list *Ext_fcns, std::vector &prefilter_preds, std::set &pred_ids); + + +cnf_elem *find_common_filter(std::vector< std::vector > &where_list, table_list *Schema); + +std::string int_to_string(int i); +void insert_gb_def_pr(predicate_t *pr, gb_table *gtbl); +void insert_gb_def_se(scalarexp_t *se, gb_table *gtbl); + + + + +#endif + diff --git a/src/ftacmp/ext_fcns.l b/src/ftacmp/ext_fcns.l new file mode 100644 index 0000000..084ae3a --- /dev/null +++ b/src/ftacmp/ext_fcns.l @@ -0,0 +1,170 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +/* + MUST COMPILE WITH + flex -PExt_fcnsParser -oext_fcnslexer.cc ext_fcns.l + (or equivalent). +*/ + +%{ +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_ext_fcns.h" + #include + + + +#include "ext_fcns.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int Ext_fcnsParserwrap(){return(1);} + +extern int Ext_fcnsParserdebug; + + +/* + These variables are used for error reporting: + flex_lineno : the line currently being parsed when the error occurs. + flexch : the character on the line where the error occurs + flex_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_ext_fcns_lineno = 1; +int flex_ext_fcns_ch = 0; +char flex_ext_fcns_linebuf[20000]; + +//void Ext_fcnsParsererror(char *s); + +void Ext_fcnsParsererror(char *s){ + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_ext_fcns_lineno, flex_ext_fcns_ch, s, Ext_fcnsParsertext, flex_ext_fcns_linebuf ); + fprintf(stderr,"%*s\n",1+flex_ext_fcns_ch,"^"); +} + + +%} + /* MKS needs the next line to increase the NFA table */ +%e 1200 +%option noyywrap + +%% + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + +FUN { flex_ext_fcns_ch+=Ext_fcnsParserleng; return FUN; } +PRED { flex_ext_fcns_ch+=Ext_fcnsParserleng; return PRED; } +UDAF { flex_ext_fcns_ch+=Ext_fcnsParserleng; return UDAF; } +EXTR { flex_ext_fcns_ch+=Ext_fcnsParserleng; return EXTR; } +STATE { flex_ext_fcns_ch+=Ext_fcnsParserleng; return STATE; } +SFUN { flex_ext_fcns_ch+=Ext_fcnsParserleng; return SFUN; } +HANDLE { flex_ext_fcns_ch+=Ext_fcnsParserleng; return HANDLE; } +CONST { flex_ext_fcns_ch+=Ext_fcnsParserleng; return CONST; } +CLASS { flex_ext_fcns_ch+=Ext_fcnsParserleng; return CLASS; } +; {flex_ext_fcns_ch+=Ext_fcnsParserleng; return SEMICOLON;} + +[(),\[\]] { flex_ext_fcns_ch+=Ext_fcnsParserleng; return yytext[0]; } + + + /* names */ + +[A-Za-z][A-Za-z0-9_]* { flex_ext_fcns_ch+=Ext_fcnsParserleng; Ext_fcnsParserlval.strval = strdup(yytext); return NAME; } + + /* numbers */ + +[0-9]+ | +[0-9]+UL { flex_ext_fcns_ch+=Ext_fcnsParserleng; Ext_fcnsParserlval.strval = strdup(yytext); return INTNUM; } + + /* strings */ + +'[^'\n]*' { + + int c; + + Ext_fcnsParserlval.strval = strdup(Ext_fcnsParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_ext_fcns_ch+=Ext_fcnsParserleng; + Ext_fcnsParserlval.strval[Ext_fcnsParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + +'[^'\n]*$ { flex_ext_fcns_ch+=Ext_fcnsParserleng; Ext_fcnsParsererror("Unterminated string"); } + + + + /* */ + /* Newline : advance the error reporting line number */ + /* and grab the next line into flex_linebuf */ + /* */ + +\n.* {flex_ext_fcns_ch=0; flex_ext_fcns_lineno++; + strcpy(flex_ext_fcns_linebuf,Ext_fcnsParsertext+1); + yyless(1); + } + +[ \t\r]+ {flex_ext_fcns_ch+=Ext_fcnsParserleng; } /* white space */ + +"--".*$ {flex_ext_fcns_ch+=Ext_fcnsParserleng; }; /* comment */ +"//".*$ {flex_ext_fcns_ch+=Ext_fcnsParserleng; }; /* comment */ + + /* Parse error on anything else. */ +.|\n {fprintf(stderr,"Warning: unknown token (ignored)\n"); Ext_fcnsParsererror(yytext);} + + +%% + + diff --git a/src/ftacmp/ext_fcns.tab.cc b/src/ftacmp/ext_fcns.tab.cc new file mode 100644 index 0000000..168c7b3 --- /dev/null +++ b/src/ftacmp/ext_fcns.tab.cc @@ -0,0 +1,1493 @@ +/* A Bison parser, made from ext_fcns.y, by GNU bison 1.75. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +/* If NAME_PREFIX is specified substitute the variables and functions + names. */ +#define yyparse Ext_fcnsParserparse +#define yylex Ext_fcnsParserlex +#define yyerror Ext_fcnsParsererror +#define yylval Ext_fcnsParserlval +#define yychar Ext_fcnsParserchar +#define yydebug Ext_fcnsParserdebug +#define yynerrs Ext_fcnsParsernerrs + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259, + INTNUM = 260, + SEMICOLON = 261, + HANDLE = 262, + CONST = 263, + CLASS = 264, + FUN = 265, + PRED = 266, + EXTR = 267, + UDAF = 268, + STATE = 269, + SFUN = 270 + }; +#endif +#define NAME 258 +#define STRING_TOKEN 259 +#define INTNUM 260 +#define SEMICOLON 261 +#define HANDLE 262 +#define CONST 263 +#define CLASS 264 +#define FUN 265 +#define PRED 266 +#define EXTR 267 +#define UDAF 268 +#define STATE 269 +#define SFUN 270 + + + + +/* Copy the first part of user declarations. */ +#line 8 "ext_fcns.y" + + + +#include + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_ext_fcns.h" + +/* Interface to ext_fcns parser */ + int yyparse(); + void yyerror(char *s); + int yylex(); +extern int flex_ext_fcns_lineno, flex_ext_fcns_ch; + +/* Return value */ +extern ext_fcn_list *Ext_fcns; + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#ifndef YYSTYPE +#line 40 "ext_fcns.y" +typedef union { + char* strval; + ext_fcn_list *ext_fcn_list_t; + ext_fcn_def *ext_fcn_t; + ext_fcn_param_list *plist_t; + param_list *tplist_t; + ext_fcn_param *param_t; + ext_fcn_modifier_list *modif_t; + } yystype; +/* Line 193 of /usr/local/share/bison/yacc.c. */ +#line 151 "ext_fcns.tab.cc" +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +#ifndef YYLTYPE +typedef struct yyltype +{ + int first_line; + int first_column; + int last_line; + int last_column; +} yyltype; +# define YYLTYPE yyltype +# define YYLTYPE_IS_TRIVIAL 1 +#endif + +/* Copy the second part of user declarations. */ + + +/* Line 213 of /usr/local/share/bison/yacc.c. */ +#line 172 "ext_fcns.tab.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 11 +#define YYLAST 136 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 21 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 10 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 39 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 117 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 270 + +#define YYTRANSLATE(X) \ + ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 18, 19, 2, 2, 20, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 16, 2, 17, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 5, 7, 10, 22, 31, 41, 48, + 61, 71, 85, 96, 109, 119, 124, 125, 127, 129, + 132, 136, 141, 143, 147, 151, 155, 159, 164, 169, + 172, 173, 177, 179, 182, 185, 188, 192, 197, 202 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 22, 0, -1, 23, -1, 24, -1, 23, 24, -1, + 3, 29, 10, 16, 26, 17, 3, 18, 25, 19, + 6, -1, 3, 29, 10, 3, 18, 25, 19, 6, + -1, 11, 16, 26, 17, 3, 16, 25, 17, 6, + -1, 11, 3, 16, 25, 17, 6, -1, 3, 29, + 13, 16, 26, 17, 3, 3, 18, 25, 19, 6, + -1, 3, 29, 13, 3, 3, 18, 25, 19, 6, + -1, 3, 29, 12, 16, 26, 17, 3, 3, 3, + 18, 25, 19, 6, -1, 3, 29, 12, 3, 3, + 3, 18, 25, 19, 6, -1, 3, 29, 15, 16, + 26, 17, 3, 3, 18, 25, 19, 6, -1, 3, + 29, 15, 3, 3, 18, 25, 19, 6, -1, 3, + 14, 3, 6, -1, -1, 27, -1, 3, -1, 3, + 3, -1, 26, 20, 3, -1, 26, 20, 3, 3, + -1, 28, -1, 27, 20, 28, -1, 3, 29, 7, + -1, 3, 29, 8, -1, 3, 29, 9, -1, 3, + 29, 7, 9, -1, 3, 29, 8, 9, -1, 3, + 29, -1, -1, 18, 30, 19, -1, 3, -1, 3, + 3, -1, 3, 4, -1, 3, 5, -1, 30, 20, + 3, -1, 30, 20, 3, 3, -1, 30, 20, 3, + 4, -1, 30, 20, 3, 5, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned char yyrline[] = +{ + 0, 75, 75, 78, 79, 82, 84, 86, 88, 90, + 92, 94, 96, 98, 100, 102, 107, 109, 112, 114, + 115, 116, 119, 121, 124, 126, 127, 128, 129, 130, + 134, 136, 139, 141, 142, 143, 144, 145, 146, 147 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "INTNUM", + "SEMICOLON", "HANDLE", "CONST", "CLASS", "FUN", "PRED", "EXTR", "UDAF", + "STATE", "SFUN", "'['", "']'", "'('", "')'", "','", "$accept", "result", + "fcn_list", "fcn_def", "opt_param_commalist", "modifier_list", + "param_commalist", "param", "opt_type_param_commalist", + "type_param_commalist", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 91, 93, 40, 41, + 44 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 21, 22, 23, 23, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 25, 25, 26, 26, + 26, 26, 27, 27, 28, 28, 28, 28, 28, 28, + 29, 29, 30, 30, 30, 30, 30, 30, 30, 30 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 1, 1, 2, 11, 8, 9, 6, 12, + 9, 13, 10, 12, 9, 4, 0, 1, 1, 2, + 3, 4, 1, 3, 3, 3, 3, 4, 4, 2, + 0, 3, 1, 2, 2, 2, 3, 4, 4, 4 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 30, 0, 0, 2, 3, 0, 0, 0, 0, + 0, 1, 4, 0, 32, 0, 0, 0, 0, 0, + 16, 18, 0, 15, 33, 34, 35, 31, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 30, 0, 17, + 22, 19, 0, 0, 36, 16, 0, 0, 0, 0, + 0, 0, 0, 29, 0, 0, 0, 20, 37, 38, + 39, 0, 0, 0, 0, 16, 0, 16, 0, 24, + 25, 26, 8, 23, 16, 21, 0, 0, 16, 0, + 0, 0, 0, 0, 27, 28, 0, 6, 16, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 16, 14, 16, 7, 0, 12, 16, 0, 0, 5, + 0, 0, 0, 0, 9, 13, 11 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = +{ + -1, 3, 4, 5, 38, 22, 39, 40, 8, 15 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -46 +static const yysigned_char yypact[] = +{ + 8, -5, -2, 7, 8, -46, 25, 35, 11, 9, + 50, -46, -46, 48, 41, 22, -1, 0, 1, 2, + 53, 55, 10, -46, -46, -46, -46, -46, 56, 42, + 50, 59, 50, 60, 50, 61, 50, 47, 49, 51, + -46, -46, 64, 65, 44, 53, 14, 66, 15, 52, + 19, 54, 20, 43, 67, 53, 58, 72, -46, -46, + -46, 57, 74, 62, 75, 53, 76, 53, 78, 73, + 77, -46, -46, -46, 53, -46, 79, 69, 53, 80, + 70, 81, 71, 85, -46, -46, 82, -46, 53, 83, + 88, 86, 87, 89, 90, 91, 84, 92, 93, -46, + 53, -46, 53, -46, 94, -46, 53, 95, 96, -46, + 97, 98, 100, 101, -46, -46, -46 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = +{ + -46, -46, -46, 105, -45, -24, -46, 38, 99, -46 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, parse error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = +{ + 61, 9, 29, 31, 33, 35, 46, 11, 48, 6, + 50, 1, 52, 7, 10, 30, 32, 34, 36, 2, + 80, 16, 82, 17, 18, 20, 19, 42, 13, 86, + 43, 62, 64, 89, 43, 43, 66, 68, 14, 43, + 43, 27, 28, 96, 24, 25, 26, 58, 59, 60, + 69, 70, 71, 21, 23, 107, 37, 108, 41, 44, + 45, 110, 47, 49, 51, 7, 54, 56, 57, 63, + 65, 55, 67, 72, 74, 75, 76, 77, 79, 81, + 78, 83, 84, 90, 92, 87, 85, 88, 94, 91, + 93, 98, 99, 73, 0, 101, 0, 103, 105, 95, + 109, 0, 97, 104, 114, 100, 115, 116, 102, 12, + 0, 106, 0, 0, 111, 112, 113, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 53 +}; + +static const yysigned_char yycheck[] = +{ + 45, 3, 3, 3, 3, 3, 30, 0, 32, 14, + 34, 3, 36, 18, 16, 16, 16, 16, 16, 11, + 65, 10, 67, 12, 13, 16, 15, 17, 3, 74, + 20, 17, 17, 78, 20, 20, 17, 17, 3, 20, + 20, 19, 20, 88, 3, 4, 5, 3, 4, 5, + 7, 8, 9, 3, 6, 100, 3, 102, 3, 3, + 18, 106, 3, 3, 3, 18, 17, 3, 3, 3, + 18, 20, 18, 6, 16, 3, 19, 3, 3, 3, + 18, 3, 9, 3, 3, 6, 9, 18, 3, 19, + 19, 3, 6, 55, -1, 6, -1, 6, 6, 17, + 6, -1, 19, 19, 6, 18, 6, 6, 18, 4, + -1, 18, -1, -1, 19, 19, 19, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 37 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 3, 11, 22, 23, 24, 14, 18, 29, 3, + 16, 0, 24, 3, 3, 30, 10, 12, 13, 15, + 16, 3, 26, 6, 3, 4, 5, 19, 20, 3, + 16, 3, 16, 3, 16, 3, 16, 3, 25, 27, + 28, 3, 17, 20, 3, 18, 26, 3, 26, 3, + 26, 3, 26, 29, 17, 20, 3, 3, 3, 4, + 5, 25, 17, 3, 17, 18, 17, 18, 17, 7, + 8, 9, 6, 28, 16, 3, 19, 3, 18, 3, + 25, 3, 25, 3, 9, 9, 25, 6, 18, 25, + 3, 19, 3, 19, 3, 17, 25, 19, 3, 6, + 18, 6, 18, 6, 19, 6, 18, 25, 25, 6, + 25, 19, 19, 19, 6, 6, 6 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.first_line = Rhs[1].first_line; \ + Current.first_column = Rhs[1].first_column; \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#define YYLEX yylex () + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +# define YYDSYMPRINT(Args) \ +do { \ + if (yydebug) \ + yysymprint Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YYDSYMPRINT(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*-----------------------------. +| Print this symbol on YYOUT. | +`-----------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue) +#else +yysymprint (yyout, yytype, yyvalue) + FILE* yyout; + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyout, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyout, yytoknum[yytype], yyvalue); +# endif + } + else + YYFPRINTF (yyout, "nterm %s (", yytname[yytype]); + + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyout, ")"); +} +#endif /* YYDEBUG. */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yydestruct (int yytype, YYSTYPE yyvalue) +#else +yydestruct (yytype, yyvalue) + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + switch (yytype) + { + default: + break; + } +} + + + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +# ifdef YYPARSE_PARAM +int yyparse (void *); +# else +int yyparse (void); +# endif +#endif + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of parse errors so far. */ +int yynerrs; + + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + goto yyoverflowlab; + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with. */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more. */ + + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yychar1 = YYTRANSLATE (yychar); + + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ + YYDPRINTF ((stderr, "Next token is ")); + YYDSYMPRINT ((stderr, yychar1, yylval)); + YYDPRINTF ((stderr, "\n")); + } + + /* If the proper action on seeing token YYCHAR1 is to reduce or to + detect an error, take that action. */ + yyn += yychar1; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + int yyi; + + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn - 1, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + switch (yyn) + { + case 2: +#line 75 "ext_fcns.y" + {Ext_fcns = yyvsp[0].ext_fcn_list_t;} + break; + + case 3: +#line 78 "ext_fcns.y" + {yyval.ext_fcn_list_t = new ext_fcn_list(yyvsp[0].ext_fcn_t);} + break; + + case 4: +#line 79 "ext_fcns.y" + {yyval.ext_fcn_list_t = yyvsp[-1].ext_fcn_list_t->append_ext_fcn_def(yyvsp[0].ext_fcn_t);} + break; + + case 5: +#line 82 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-10].strval,yyvsp[-9].tplist_t,yyvsp[-6].modif_t,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-6].modif_t; delete yyvsp[-2].plist_t; } + break; + + case 6: +#line 84 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-7].strval,yyvsp[-6].tplist_t,NULL,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; } + break; + + case 7: +#line 86 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-6].modif_t,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-6].modif_t; delete yyvsp[-2].plist_t; } + break; + + case 8: +#line 88 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(NULL,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; } + break; + + case 9: +#line 90 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-11].strval,yyvsp[-10].tplist_t,yyvsp[-7].modif_t,yyvsp[-5].strval,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-7].modif_t; delete yyvsp[-2].plist_t; } + break; + + case 10: +#line 92 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-8].strval,yyvsp[-7].tplist_t,NULL,yyvsp[-5].strval,yyvsp[-4].strval, yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; } + break; + + case 11: +#line 94 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-12].strval,yyvsp[-11].tplist_t,yyvsp[-8].modif_t,yyvsp[-6].strval,yyvsp[-5].strval, yyvsp[-4].strval, yyvsp[-2].plist_t); delete yyvsp[-8].modif_t; delete yyvsp[-2].plist_t; } + break; + + case 12: +#line 96 "ext_fcns.y" + { + yyval.ext_fcn_t=new ext_fcn_def(yyvsp[-9].strval,yyvsp[-8].tplist_t,NULL,yyvsp[-6].strval,yyvsp[-5].strval, yyvsp[-4].strval, yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; } + break; + + case 13: +#line 98 "ext_fcns.y" + { + yyval.ext_fcn_t=ext_fcn_def::make_sfun_def(yyvsp[-11].strval,yyvsp[-10].tplist_t,yyvsp[-7].modif_t,yyvsp[-5].strval,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; } + break; + + case 14: +#line 100 "ext_fcns.y" + { + yyval.ext_fcn_t=ext_fcn_def::make_sfun_def(yyvsp[-8].strval,yyvsp[-7].tplist_t,NULL,yyvsp[-5].strval,yyvsp[-4].strval,yyvsp[-2].plist_t); delete yyvsp[-2].plist_t; } + break; + + case 15: +#line 102 "ext_fcns.y" + { + yyval.ext_fcn_t=ext_fcn_def::make_state_def(yyvsp[-3].strval,yyvsp[-1].strval); } + break; + + case 16: +#line 108 "ext_fcns.y" + {yyval.plist_t = NULL;} + break; + + case 17: +#line 109 "ext_fcns.y" + {yyval.plist_t = yyvsp[0].plist_t;} + break; + + case 18: +#line 113 "ext_fcns.y" + {yyval.modif_t = new ext_fcn_modifier_list(yyvsp[0].strval);} + break; + + case 19: +#line 114 "ext_fcns.y" + {yyval.modif_t = new ext_fcn_modifier_list(yyvsp[-1].strval, yyvsp[0].strval);} + break; + + case 20: +#line 115 "ext_fcns.y" + {yyval.modif_t = yyvsp[-2].modif_t->append(yyvsp[0].strval); } + break; + + case 21: +#line 116 "ext_fcns.y" + {yyval.modif_t = yyvsp[-3].modif_t->append(yyvsp[-1].strval, yyvsp[0].strval); } + break; + + case 22: +#line 120 "ext_fcns.y" + {yyval.plist_t = new ext_fcn_param_list(yyvsp[0].param_t);} + break; + + case 23: +#line 121 "ext_fcns.y" + {yyval.plist_t = yyvsp[-2].plist_t->append(yyvsp[0].param_t);} + break; + + case 24: +#line 125 "ext_fcns.y" + { yyval.param_t = new ext_fcn_param(yyvsp[-2].strval,yyvsp[-1].tplist_t,1,0,0);} + break; + + case 25: +#line 126 "ext_fcns.y" + { yyval.param_t = new ext_fcn_param(yyvsp[-2].strval,yyvsp[-1].tplist_t,0,1,0);} + break; + + case 26: +#line 127 "ext_fcns.y" + { yyval.param_t = new ext_fcn_param(yyvsp[-2].strval,yyvsp[-1].tplist_t,0,0,1);} + break; + + case 27: +#line 128 "ext_fcns.y" + { yyval.param_t = new ext_fcn_param(yyvsp[-3].strval,yyvsp[-2].tplist_t,1,0,1);} + break; + + case 28: +#line 129 "ext_fcns.y" + { yyval.param_t = new ext_fcn_param(yyvsp[-3].strval,yyvsp[-2].tplist_t,0,1,1);} + break; + + case 29: +#line 131 "ext_fcns.y" + { yyval.param_t = new ext_fcn_param(yyvsp[-1].strval,yyvsp[0].tplist_t,0,0,0);} + break; + + case 30: +#line 135 "ext_fcns.y" + {yyval.tplist_t = NULL;} + break; + + case 31: +#line 136 "ext_fcns.y" + {yyval.tplist_t = yyvsp[-1].tplist_t;} + break; + + case 32: +#line 140 "ext_fcns.y" + {yyval.tplist_t = new param_list(yyvsp[0].strval);} + break; + + case 33: +#line 141 "ext_fcns.y" + {yyval.tplist_t = new param_list(yyvsp[-1].strval,yyvsp[0].strval);} + break; + + case 34: +#line 142 "ext_fcns.y" + {yyval.tplist_t = new param_list(yyvsp[-1].strval,yyvsp[0].strval);} + break; + + case 35: +#line 143 "ext_fcns.y" + {yyval.tplist_t = new param_list(yyvsp[-1].strval,yyvsp[0].strval);} + break; + + case 36: +#line 144 "ext_fcns.y" + {yyval.tplist_t = yyvsp[-2].tplist_t->append(yyvsp[0].strval);} + break; + + case 37: +#line 145 "ext_fcns.y" + {yyval.tplist_t = yyvsp[-3].tplist_t->append(yyvsp[-1].strval,yyvsp[0].strval);} + break; + + case 38: +#line 146 "ext_fcns.y" + {yyval.tplist_t = yyvsp[-3].tplist_t->append(yyvsp[-1].strval,yyvsp[0].strval);} + break; + + case 39: +#line 147 "ext_fcns.y" + {yyval.tplist_t = yyvsp[-3].tplist_t->append(yyvsp[-1].strval,yyvsp[0].strval);} + break; + + + } + +/* Line 1016 of /usr/local/share/bison/yacc.c. */ +#line 1272 "ext_fcns.tab.cc" + + yyvsp -= yylen; + yyssp -= yylen; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[yytype]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("parse error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("parse error"); + } + goto yyerrlab1; + + +/*----------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action. | +`----------------------------------------------------*/ +yyerrlab1: + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + /* Return failure if at end of input. */ + if (yychar == YYEOF) + { + /* Pop the error token. */ + YYPOPSTACK; + /* Pop the rest of the stack. */ + while (yyssp > yyss) + { + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], + *yyvsp)); + YYDPRINTF ((stderr, "\n")); + yydestruct (yystos[*yyssp], *yyvsp); + YYPOPSTACK; + } + YYABORT; + } + + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); + yydestruct (yychar1, yylval); + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], *yyvsp)); + YYDPRINTF ((stderr, "\n")); + + yydestruct (yystos[yystate], *yyvsp); + yyvsp--; + yystate = *--yyssp; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + } + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; + + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 152 "ext_fcns.y" + + + diff --git a/src/ftacmp/ext_fcns.tab.cc.h b/src/ftacmp/ext_fcns.tab.cc.h new file mode 100644 index 0000000..19c07ff --- /dev/null +++ b/src/ftacmp/ext_fcns.tab.cc.h @@ -0,0 +1,87 @@ +/* A Bison parser, made from ext_fcns.y, by GNU bison 1.75. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +#ifndef BISON_EXT_FCNS_TAB_CC_H +# define BISON_EXT_FCNS_TAB_CC_H + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259, + INTNUM = 260, + SEMICOLON = 261, + HANDLE = 262, + CONST = 263, + CLASS = 264, + FUN = 265, + PRED = 266, + EXTR = 267, + UDAF = 268, + STATE = 269, + SFUN = 270 + }; +#endif +#define NAME 258 +#define STRING_TOKEN 259 +#define INTNUM 260 +#define SEMICOLON 261 +#define HANDLE 262 +#define CONST 263 +#define CLASS 264 +#define FUN 265 +#define PRED 266 +#define EXTR 267 +#define UDAF 268 +#define STATE 269 +#define SFUN 270 + + + + +#ifndef YYSTYPE +#line 40 "ext_fcns.y" +typedef union { + char* strval; + ext_fcn_list *ext_fcn_list_t; + ext_fcn_def *ext_fcn_t; + ext_fcn_param_list *plist_t; + param_list *tplist_t; + ext_fcn_param *param_t; + ext_fcn_modifier_list *modif_t; + } yystype; +/* Line 1281 of /usr/local/share/bison/yacc.c. */ +#line 80 "ext_fcns.tab.cc.h" +# define YYSTYPE yystype +#endif + +extern YYSTYPE Ext_fcnsParserlval; + + +#endif /* not BISON_EXT_FCNS_TAB_CC_H */ + diff --git a/src/ftacmp/ext_fcns.y b/src/ftacmp/ext_fcns.y new file mode 100644 index 0000000..0713293 --- /dev/null +++ b/src/ftacmp/ext_fcns.y @@ -0,0 +1,168 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + bison --verbose --defines=ext_fcns.tab.cc.h -p Ext_fcnsParser -o ext_fcns.tab.cc ext_fcns.y + + (or equivalent). +*/ + +%{ + + +#include + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_ext_fcns.h" + +/* Interface to ext_fcns parser */ + int yyparse(); + void yyerror(char *s); + int yylex(); +extern int flex_ext_fcns_lineno, flex_ext_fcns_ch; + +/* Return value */ +extern ext_fcn_list *Ext_fcns; + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + char* strval; + ext_fcn_list *ext_fcn_list_t; + ext_fcn_def *ext_fcn_t; + ext_fcn_param_list *plist_t; + param_list *tplist_t; + ext_fcn_param *param_t; + ext_fcn_modifier_list *modif_t; + } + + +%token NAME +%token STRING_TOKEN +%token INTNUM + + +%type fcn_def +%type fcn_list +%type param_commalist +%type opt_param_commalist +%type type_param_commalist +%type opt_type_param_commalist +%type param +%type modifier_list + /* operators */ + + + /* literal keyword tokens */ + +%token SEMICOLON HANDLE CONST CLASS FUN PRED +%token EXTR UDAF STATE SFUN + + +%% + +result: fcn_list {Ext_fcns = $1;} + ; + +fcn_list: fcn_def {$$ = new ext_fcn_list($1);} + | fcn_list fcn_def {$$ = $1->append_ext_fcn_def($2);} + ; + +fcn_def: NAME opt_type_param_commalist FUN '[' modifier_list ']' NAME '(' opt_param_commalist ')' SEMICOLON { + $$=new ext_fcn_def($1,$2,$5,$7,$9); delete $5; delete $9; } + | NAME opt_type_param_commalist FUN NAME '(' opt_param_commalist ')' SEMICOLON { + $$=new ext_fcn_def($1,$2,NULL,$4,$6); delete $6; } + | PRED '[' modifier_list ']' NAME '[' opt_param_commalist ']' SEMICOLON { + $$=new ext_fcn_def($3,$5,$7); delete $3; delete $7; } + | PRED NAME '[' opt_param_commalist ']' SEMICOLON { + $$=new ext_fcn_def(NULL,$2,$4); delete $4; } + | NAME opt_type_param_commalist UDAF '[' modifier_list ']' NAME NAME '(' opt_param_commalist ')' SEMICOLON { + $$=new ext_fcn_def($1,$2,$5,$7,$8,$10); delete $5; delete $10; } + | NAME opt_type_param_commalist UDAF NAME NAME '(' opt_param_commalist ')' SEMICOLON { + $$=new ext_fcn_def($1,$2,NULL,$4,$5, $7); delete $7; } + | NAME opt_type_param_commalist EXTR '[' modifier_list ']' NAME NAME NAME '(' opt_param_commalist ')' SEMICOLON { + $$=new ext_fcn_def($1,$2,$5,$7,$8, $9, $11); delete $5; delete $11; } + | NAME opt_type_param_commalist EXTR NAME NAME NAME '(' opt_param_commalist ')' SEMICOLON { + $$=new ext_fcn_def($1,$2,NULL,$4,$5, $6, $8); delete $8; } + | NAME opt_type_param_commalist SFUN '[' modifier_list ']' NAME NAME '(' opt_param_commalist ')' SEMICOLON { + $$=ext_fcn_def::make_sfun_def($1,$2,$5,$7,$8,$10); delete $10; } + | NAME opt_type_param_commalist SFUN NAME NAME '(' opt_param_commalist ')' SEMICOLON { + $$=ext_fcn_def::make_sfun_def($1,$2,NULL,$4,$5,$7); delete $7; } + | NAME STATE NAME SEMICOLON { + $$=ext_fcn_def::make_state_def($1,$3); } + + ; + +opt_param_commalist: + /* empty */ {$$ = NULL;} + | param_commalist {$$ = $1;} + ; + +modifier_list: + NAME {$$ = new ext_fcn_modifier_list($1);} + | NAME NAME {$$ = new ext_fcn_modifier_list($1, $2);} + | modifier_list ',' NAME {$$ = $1->append($3); } + | modifier_list ',' NAME NAME {$$ = $1->append($3, $4); } + ; + +param_commalist: + param {$$ = new ext_fcn_param_list($1);} + | param_commalist ',' param {$$ = $1->append($3);} + ; + +param: + NAME opt_type_param_commalist HANDLE { $$ = new ext_fcn_param($1,$2,1,0,0);} + | NAME opt_type_param_commalist CONST { $$ = new ext_fcn_param($1,$2,0,1,0);} + | NAME opt_type_param_commalist CLASS { $$ = new ext_fcn_param($1,$2,0,0,1);} + | NAME opt_type_param_commalist HANDLE CLASS { $$ = new ext_fcn_param($1,$2,1,0,1);} + | NAME opt_type_param_commalist CONST CLASS { $$ = new ext_fcn_param($1,$2,0,1,1);} + | NAME opt_type_param_commalist + { $$ = new ext_fcn_param($1,$2,0,0,0);} + ; + +opt_type_param_commalist: + /* empty */ {$$ = NULL;} + | '(' type_param_commalist ')' {$$ = $2;} + ; + +type_param_commalist: + NAME {$$ = new param_list($1);} + | NAME NAME {$$ = new param_list($1,$2);} + | NAME STRING_TOKEN {$$ = new param_list($1,$2);} + | NAME INTNUM {$$ = new param_list($1,$2);} + | type_param_commalist ',' NAME {$$ = $1->append($3);} + | type_param_commalist ',' NAME NAME {$$ = $1->append($3,$4);} + | type_param_commalist ',' NAME STRING_TOKEN {$$ = $1->append($3,$4);} + | type_param_commalist ',' NAME INTNUM {$$ = $1->append($3,$4);} + ; + + + +%% + diff --git a/src/ftacmp/ext_fcnslexer.cc b/src/ftacmp/ext_fcnslexer.cc new file mode 100644 index 0000000..a1848c3 --- /dev/null +++ b/src/ftacmp/ext_fcnslexer.cc @@ -0,0 +1,1781 @@ +#define yy_create_buffer Ext_fcnsParser_create_buffer +#define yy_delete_buffer Ext_fcnsParser_delete_buffer +#define yy_scan_buffer Ext_fcnsParser_scan_buffer +#define yy_scan_string Ext_fcnsParser_scan_string +#define yy_scan_bytes Ext_fcnsParser_scan_bytes +#define yy_flex_debug Ext_fcnsParser_flex_debug +#define yy_init_buffer Ext_fcnsParser_init_buffer +#define yy_flush_buffer Ext_fcnsParser_flush_buffer +#define yy_load_buffer_state Ext_fcnsParser_load_buffer_state +#define yy_switch_to_buffer Ext_fcnsParser_switch_to_buffer +#define yyin Ext_fcnsParserin +#define yyleng Ext_fcnsParserleng +#define yylex Ext_fcnsParserlex +#define yyout Ext_fcnsParserout +#define yyrestart Ext_fcnsParserrestart +#define yytext Ext_fcnsParsertext + +#line 19 "ext_fcnslexer.cc" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/ftacmp/ext_fcnslexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yytext_ptr -= yy_more_len; \ + yyleng = (int) (yy_cp - yytext_ptr); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 22 +#define YY_END_OF_BUFFER 23 +static yyconst short int yy_accept[68] = + { 0, + 0, 0, 23, 21, 18, 17, 21, 11, 21, 21, + 13, 10, 12, 12, 12, 12, 12, 12, 12, 12, + 18, 17, 0, 16, 15, 0, 0, 13, 0, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, + 19, 0, 20, 14, 12, 12, 12, 1, 12, 12, + 12, 12, 12, 12, 12, 4, 12, 2, 6, 12, + 3, 9, 8, 12, 5, 7, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 4, 5, + 5, 1, 1, 5, 6, 1, 7, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 1, 9, 1, + 1, 1, 1, 1, 10, 11, 12, 13, 14, 15, + 11, 16, 11, 11, 11, 17, 11, 18, 19, 20, + 11, 21, 22, 23, 24, 11, 11, 25, 11, 11, + 5, 1, 5, 1, 26, 1, 11, 11, 11, 11, + + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[27] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 3, 1, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[73] = + { 0, + 0, 0, 87, 88, 84, 0, 24, 88, 79, 77, + 21, 88, 0, 13, 58, 58, 71, 59, 16, 66, + 76, 0, 30, 88, 88, 74, 73, 27, 58, 0, + 64, 55, 49, 53, 52, 55, 44, 57, 56, 62, + 88, 61, 88, 88, 31, 28, 28, 0, 35, 34, + 28, 21, 28, 20, 18, 0, 23, 0, 0, 24, + 0, 0, 0, 23, 0, 0, 88, 51, 54, 33, + 57, 60 + } ; + +static yyconst short int yy_def[73] = + { 0, + 67, 1, 67, 67, 67, 68, 69, 67, 67, 67, + 67, 67, 70, 70, 70, 70, 70, 70, 70, 70, + 67, 68, 69, 67, 67, 71, 72, 67, 67, 70, + 70, 70, 70, 70, 70, 70, 70, 70, 70, 71, + 67, 72, 67, 67, 70, 70, 70, 70, 70, 70, + 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, + 70, 70, 70, 70, 70, 70, 0, 67, 67, 67, + 67, 67 + } ; + +static yyconst short int yy_nxt[115] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 13, 14, 13, 15, 16, 17, 13, 13, 13, 18, + 13, 19, 13, 20, 13, 4, 24, 25, 28, 31, + 37, 32, 24, 25, 28, 30, 66, 65, 38, 64, + 63, 62, 61, 60, 29, 59, 58, 57, 56, 55, + 29, 22, 54, 22, 23, 23, 23, 40, 40, 40, + 42, 42, 42, 43, 41, 53, 52, 51, 50, 49, + 48, 47, 46, 45, 44, 43, 41, 21, 39, 36, + 35, 34, 33, 27, 26, 21, 67, 3, 67, 67, + 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, + + 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, + 67, 67, 67, 67 + } ; + +static yyconst short int yy_chk[115] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 7, 7, 11, 14, + 19, 14, 23, 23, 28, 70, 64, 60, 19, 57, + 55, 54, 53, 52, 11, 51, 50, 49, 47, 46, + 28, 68, 45, 68, 69, 69, 69, 71, 71, 71, + 72, 72, 72, 42, 40, 39, 38, 37, 36, 35, + 34, 33, 32, 31, 29, 27, 26, 21, 20, 18, + 17, 16, 15, 10, 9, 5, 3, 67, 67, 67, + 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, + + 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, + 67, 67, 67, 67 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() (yy_more_flag = 1) +#define YY_MORE_ADJ yy_more_len +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "ext_fcns.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PExt_fcnsParser -oext_fcnslexer.cc ext_fcns.l + (or equivalent). +*/ +#line 9 "ext_fcns.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_ext_fcns.h" + #include + + + +#include "ext_fcns.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int Ext_fcnsParserwrap(){return(1);} + +extern int Ext_fcnsParserdebug; + + +/* + These variables are used for error reporting: + flex_lineno : the line currently being parsed when the error occurs. + flexch : the character on the line where the error occurs + flex_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_ext_fcns_lineno = 1; +int flex_ext_fcns_ch = 0; +char flex_ext_fcns_linebuf[20000]; + +//void Ext_fcnsParsererror(char *s); + +void Ext_fcnsParsererror(char *s){ + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_ext_fcns_lineno, flex_ext_fcns_ch, s, Ext_fcnsParsertext, flex_ext_fcns_linebuf ); + fprintf(stderr,"%*s\n",1+flex_ext_fcns_ch,"^"); +} + + +/* MKS needs the next line to increase the NFA table */ +#line 498 "ext_fcnslexer.cc" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 72 "ext_fcns.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + +#line 666 "ext_fcnslexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + if ( yy_more_flag ) + { + yy_more_len = yy_c_buf_p - yytext_ptr; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 68 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 88 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 88 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return FUN; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 89 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return PRED; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 90 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return UDAF; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 91 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return EXTR; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 92 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return STATE; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 93 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return SFUN; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 94 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return HANDLE; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 95 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return CONST; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 96 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return CLASS; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 97 "ext_fcns.l" +{flex_ext_fcns_ch+=Ext_fcnsParserleng; return SEMICOLON;} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 99 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 12: +YY_RULE_SETUP +#line 104 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; Ext_fcnsParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* numbers */ +case 13: +#line 109 "ext_fcns.l" +case 14: +YY_RULE_SETUP +#line 109 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; Ext_fcnsParserlval.strval = strdup(yytext); return INTNUM; } + YY_BREAK +/* strings */ +case 15: +YY_RULE_SETUP +#line 113 "ext_fcns.l" +{ + + int c; + + Ext_fcnsParserlval.strval = strdup(Ext_fcnsParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_ext_fcns_ch+=Ext_fcnsParserleng; + Ext_fcnsParserlval.strval[Ext_fcnsParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + YY_BREAK +case 16: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 130 "ext_fcns.l" +{ flex_ext_fcns_ch+=Ext_fcnsParserleng; Ext_fcnsParsererror("Unterminated string"); } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_linebuf */ +/* */ +case 17: +YY_RULE_SETUP +#line 139 "ext_fcns.l" +{flex_ext_fcns_ch=0; flex_ext_fcns_lineno++; + strcpy(flex_ext_fcns_linebuf,Ext_fcnsParsertext+1); + yyless(1); + } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 144 "ext_fcns.l" +{flex_ext_fcns_ch+=Ext_fcnsParserleng; } /* white space */ + YY_BREAK +case 19: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 146 "ext_fcns.l" +{flex_ext_fcns_ch+=Ext_fcnsParserleng; }; /* comment */ + YY_BREAK +case 20: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 147 "ext_fcns.l" +{flex_ext_fcns_ch+=Ext_fcnsParserleng; }; /* comment */ + YY_BREAK +/* Parse error on anything else. */ +case 21: +YY_RULE_SETUP +#line 150 "ext_fcns.l" +{fprintf(stderr,"Warning: unknown token (ignored)\n"); Ext_fcnsParsererror(yytext);} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 153 "ext_fcns.l" +ECHO; + YY_BREAK +#line 897 "ext_fcnslexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 68 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 68 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 67); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 153 "ext_fcns.l" + + + diff --git a/src/ftacmp/field_list.cc b/src/ftacmp/field_list.cc new file mode 100644 index 0000000..2d71e28 --- /dev/null +++ b/src/ftacmp/field_list.cc @@ -0,0 +1,139 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include +#include + +#include +#include +#include + +#include"xml_t.h" +#include"field_list.h" + +using namespace std; + +struct type_map_t{ + std::string from; + std::string to; +}; + +static struct type_map_t type_map[] = { + "BOOL", "BOOLEAN", + "Bool", "BOOLEAN", + "bool", "BOOLEAN", + "BOOLEAN", "BOOLEAN", + "INT", "INT", + "Int", "INT", + "int", "INT", + "INTEGER", "INT", + "INT(_huge_)", "INT(_huge_)", + "LLONG", "INT(_huge_)", + "Llong", "INT(_huge_)", + "llong", "INT(_huge_)", + "INTEGER(_huge_)", "INT(_huge_)", + "UINT", "UINT", + "Uint", "UINT", + "uint", "UINT", + "USHORT", "UINT", + "Ushort", "UINT", + "ushort", "UINT", + "UINT(_huge_)", "UINT(_huge_)", + "ULLONG", "UINT(_huge_)", + "Ullong", "UINT(_huge_)", + "ullong", "UINT(_huge_)", + "STR", "STRING", + "STRING", "STRING", + "FLT", "FLOAT", + "FLOAT", "FLOAT", + "Float", "FLOAT", + "float", "FLOAT", + "DATE", "DATE", + "CLOCK", "CLOCK", + "DATE_CLOCK", "DATE_CLOCK", + "TIME", "TIME", + "IP", "IP2", + "IP2", "IP2", + "STRING", "STRING", + "STR", "STRING", + "String", "STRING", + "string", "STRING", + "V_STR", "STRING", + "V_str", "STRING", + "v_str", "STRING", + "IPV6", "IP6z", + "IP6", "IP6z", + "IP6z", "IP6z", + "", "" +}; + + + +field_list::field_list(xml_t *x){ + int i,j,pos; + for(i=0;type_map[i].from != ""; i++){ + type_verifier[type_map[i].from] = type_map[i].to; + } + type_verifier[""] = ""; + + for(i=0;ileaves.size();i++){ + if(x->leaves[i]->name != "field"){ + fprintf(stderr,"WARNING, unrecognized leaf element %s in field list file, ignoring.\n",x->leaves[i]->name.c_str()); + continue; + } + + std::string fname, ftype; + for(j=0;jleaves[i]->attrs.size();j++){ + if(x->leaves[i]->attrs[j] == "name"){ + if(fname != ""){ + fprintf(stderr,"WARNING, found duplicate name property for a field (#%d, %s) in the field list, ignoring second name %s.\n",i,fname.c_str(), x->leaves[i]->vals[j].c_str()); + }else{ + fname = x->leaves[i]->vals[j]; + } + } + } + if(fname == ""){ + fprintf(stderr,"WARNING, field %d has an empty name, ignoring\n",i); + continue; + } + + for(j=0;jleaves[i]->attrs.size();j++){ + if(x->leaves[i]->attrs[j] == "type"){ + if(ftype != ""){ + fprintf(stderr,"WARNING, found duplicate type property for field %s in the field list, ignoring.\n",fname.c_str()); + }else{ + ftype = x->leaves[i]->vals[j]; + } + } + } + + if(fields.count(fname)){ + fprintf(stderr,"WARNING, duplicate field list name %s, ignoring repeat entry.\n",fname.c_str()); + continue; + } + if(type_verifier.count(ftype) == 0){ + fprintf(stderr,"WARNING, field %s in the field list has unrecognized type %s, ignoring the type.\n",fname.c_str(),ftype.c_str()); + ftype = ""; + } + + string::size_type ix = fname.rfind("/"); + if(ix != string::npos){ + fname = fname.substr(ix+1); + } + + fields[fname] = ftype; + } +} + + diff --git a/src/ftacmp/field_list.h b/src/ftacmp/field_list.h new file mode 100644 index 0000000..9b0e1d6 --- /dev/null +++ b/src/ftacmp/field_list.h @@ -0,0 +1,49 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __FIELD_LIST_H_ +#define __FIELD_LIST_H_ + +#include +#include +#include"xml_t.h" + + +class field_list{ +public: + std::map type_verifier; + std::map fields; + + field_list(xml_t *x); + + int verify_field(std::string name, std::string type, std::string &err){ + if(fields.count(name) == 0){ + err += "\tCould not find field "+name+" in the field list\n"; + return 1; + } + if(fields[name] == "") + return 0; + if(type_verifier[fields[name]] != type_verifier[type]){ + err += "\tfield "+name+" has type "+type+", which isn't compatible with field list type "+fields[name]+"\n"; + return 2; + } + return 0; + } + +}; + + +#endif + diff --git a/src/ftacmp/fta.l b/src/ftacmp/fta.l new file mode 100644 index 0000000..062fd6d --- /dev/null +++ b/src/ftacmp/fta.l @@ -0,0 +1,313 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +/* + MUST COMPILE WITH + flex -PFtaParser -oftalexer.cc fta.l + (or equivalent). +*/ + +%{ +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_fta.h" + #include "parse_schema.h" + #include + + + +#include "fta.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int FtaParserwrap(){return(1);} + +extern int FtaParserdebug; + + +/* + These variables are used for error reporting: + flex_fta_lineno : the line currently being parsed when the error occurs. + flex_fta_ch : the character on the line where the error occurs + flex_fta_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_fta_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_fta_lineno = 1; +int flex_fta_ch = 0; +char flex_fta_linebuf[200000]; + +char *flex_fta_stringinput = NULL; +int flex_fta_stringinput_ptr = 0; +FILE *flex_fta_fileinput = NULL; +int my_FtaParser_yyinput(char *buf, int max_size); + + + +void FtaParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_fta_lineno, flex_fta_ch, s, FtaParsertext, flex_fta_linebuf ); + for(i=0;i>" { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return SHIFT_OP; } + +"=" | +"<>" | +"<" | +">" | +"<=" | +">=" { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return COMPARISON; } + +[%&|!+*/:(),.\[\]$@#] { flex_fta_ch+=FtaParserleng; return yytext[0]; } +"-" { flex_fta_ch+=FtaParserleng; return yytext[0]; } +"~" { flex_fta_ch+=FtaParserleng; return yytext[0]; } + + /* names */ + +[A-Za-z_][A-Za-z0-9_]* { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return NAME; } + + /* numbers */ + +[0-9]+ | +[0-9]+UL { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return INTNUM; } + +[0-9]+ULL { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return LONGINTNUM; } + +[0-9]+"."[0-9]* | +"."[0-9]* | +[0-9]+[eE][+-]?[0-9]+ | +[0-9]+"."[0-9]*[eE][+-]?[0-9]+ | +"."[0-9]*[eE][+-]?[0-9]+ { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return APPROXNUM; } + + /* strings */ + +'[^'\n]*' { + + int c; + + FtaParserlval.strval = strdup(FtaParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_fta_ch+=FtaParserleng; + FtaParserlval.strval[FtaParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + +'[^'\n]*$ { flex_fta_ch+=FtaParserleng; FtaParsererror("Unterminated string"); } + + /* */ + /* Newline : advance the error reporting line number */ + /* and grab the next line into flex_fta_linebuf */ + /* */ + +\n.* {flex_fta_ch=0; flex_fta_lineno++; + strcpy(flex_fta_linebuf,FtaParsertext+1); + yyless(1); + } + +[ \t\r]+ {flex_fta_ch+=FtaParserleng; } /* white space */ + +"--".*$ {flex_fta_ch+=FtaParserleng; }; /* comment */ +"//".*$ {flex_fta_ch+=FtaParserleng; }; /* comment */ + +.|\n {flex_fta_ch+=FtaParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); FtaParsererror(yytext);} + +%% + +int my_FtaParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_fta_stringinput != NULL){ + while(c + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_fta.h" +#include "parse_schema.h" + + +extern fta_parse_t *fta_parse_result; +extern var_defs_t *fta_parse_defines; + + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 37 "fta.y" +{ + int intval; + double floatval; + char *strval; + int subtok; + + string_t *stringval; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + select_list_t *select_listval; + table_exp_t *tblp; + predicate_t *predp; + literal_list_t *lit_l; + tablevar_t *table; + tablevar_list_t *tbl_list; + colref_t *colref; + ifpref_t *ifpref; + colref_list_t *clist; + var_defs_t *var_defs; + var_pair_t *var_pair; + gb_t *gb_val; + gb_list_t *gb_list; + list_of_gb_list_t *list_of_gb_list; + extended_gb_t *extended_gb; + extended_gb_list_t *extended_gb_list; + + query_list_t *q_list; + +/* For table definition */ + field_entry *field_t; + field_entry_list *field_list_t; + table_def *table_def_t; + table_list *table_list_schema; + param_list *plist_t; + name_vec *namevec_t; + subquery_spec *subq_spec_t; + subqueryspec_list *subqueryspec_list_t; + unpack_fcn *ufcn; + unpack_fcn_list *ufcnl; + +} +/* Line 193 of yacc.c. */ +#line 295 "fta.tab.cc" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ + + +/* Line 216 of yacc.c. */ +#line 308 "fta.tab.cc" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if YYENABLE_NLS +# if ENABLE_NLS +# include /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int i) +#else +static int +YYID (i) + int i; +#endif +{ + return i; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined _STDLIB_H \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 57 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 708 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 80 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 59 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 176 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 377 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 315 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 74, 2, 77, 76, 19, 13, 2, + 68, 70, 17, 15, 69, 16, 71, 18, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 79, 2, + 2, 2, 2, 2, 78, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 72, 2, 73, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 12, 2, 75, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 14, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint16 yyprhs[] = +{ + 0, 0, 3, 5, 7, 13, 17, 21, 24, 27, + 29, 33, 37, 40, 43, 45, 47, 51, 56, 60, + 65, 69, 71, 74, 78, 82, 86, 90, 96, 98, + 107, 110, 114, 118, 122, 126, 135, 137, 141, 143, + 146, 148, 152, 158, 164, 170, 172, 176, 177, 179, + 182, 183, 186, 187, 190, 191, 194, 195, 197, 200, + 204, 208, 211, 215, 217, 219, 221, 225, 230, 234, + 240, 242, 246, 250, 254, 258, 262, 266, 270, 274, + 278, 281, 284, 287, 290, 292, 295, 297, 299, 303, + 308, 313, 318, 322, 328, 334, 340, 345, 347, 351, + 355, 361, 363, 367, 369, 371, 373, 375, 377, 379, + 382, 385, 388, 391, 394, 397, 398, 402, 403, 406, + 410, 416, 418, 423, 428, 433, 435, 439, 441, 445, + 447, 451, 457, 461, 464, 469, 471, 475, 481, 485, + 489, 491, 495, 499, 501, 504, 512, 519, 536, 541, + 543, 547, 551, 553, 557, 562, 564, 567, 574, 579, + 580, 584, 586, 589, 592, 595, 599, 604, 609, 614, + 615, 619, 620, 624, 626, 630, 634 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int16 yyrhs[] = +{ + 81, 0, -1, 83, -1, 125, -1, 61, 22, 125, + 82, 23, -1, 85, 84, 88, -1, 84, 85, 88, + -1, 84, 88, -1, 85, 88, -1, 88, -1, 85, + 84, 89, -1, 84, 85, 89, -1, 84, 89, -1, + 85, 89, -1, 89, -1, 82, -1, 83, 21, 82, + -1, 57, 22, 86, 23, -1, 57, 22, 23, -1, + 56, 22, 86, 23, -1, 56, 22, 23, -1, 87, + -1, 86, 87, -1, 3, 4, 21, -1, 3, 3, + 21, -1, 36, 90, 91, -1, 54, 122, 92, -1, + 54, 122, 55, 109, 92, -1, 110, -1, 92, 97, + 113, 114, 102, 99, 100, 101, -1, 27, 93, -1, + 28, 27, 93, -1, 30, 27, 93, -1, 32, 27, + 93, -1, 31, 27, 93, -1, 29, 68, 121, 69, + 5, 70, 27, 93, -1, 94, -1, 93, 69, 94, + -1, 95, -1, 95, 3, -1, 96, -1, 3, 71, + 96, -1, 3, 71, 3, 71, 96, -1, 4, 71, + 3, 71, 96, -1, 72, 3, 73, 71, 96, -1, + 3, -1, 96, 18, 3, -1, -1, 98, -1, 37, + 104, -1, -1, 39, 104, -1, -1, 40, 104, -1, + -1, 41, 104, -1, -1, 103, -1, 34, 104, -1, + 104, 8, 104, -1, 104, 9, 104, -1, 10, 104, + -1, 68, 104, 70, -1, 105, -1, 106, -1, 107, + -1, 3, 72, 73, -1, 3, 72, 111, 73, -1, + 109, 11, 109, -1, 109, 35, 72, 108, 73, -1, + 112, -1, 108, 69, 112, -1, 109, 15, 109, -1, + 109, 16, 109, -1, 109, 12, 109, -1, 109, 17, + 109, -1, 109, 18, 109, -1, 109, 13, 109, -1, + 109, 19, 109, -1, 109, 14, 109, -1, 15, 109, + -1, 16, 109, -1, 74, 109, -1, 75, 109, -1, + 112, -1, 76, 3, -1, 120, -1, 121, -1, 68, + 109, 70, -1, 26, 68, 17, 70, -1, 26, 68, + 109, 70, -1, 3, 68, 111, 70, -1, 3, 68, + 70, -1, 26, 76, 68, 17, 70, -1, 26, 76, + 68, 109, 70, -1, 3, 76, 68, 111, 70, -1, + 3, 76, 68, 70, -1, 109, -1, 109, 25, 3, + -1, 110, 69, 109, -1, 110, 69, 109, 25, 3, + -1, 109, -1, 111, 69, 109, -1, 4, -1, 5, + -1, 6, -1, 7, -1, 47, -1, 48, -1, 49, + 4, -1, 50, 4, -1, 51, 4, -1, 52, 4, + -1, 53, 4, -1, 77, 3, -1, -1, 33, 24, + 117, -1, -1, 38, 124, -1, 68, 118, 70, -1, + 115, 69, 68, 118, 70, -1, 119, -1, 45, 68, + 118, 70, -1, 44, 68, 118, 70, -1, 46, 68, + 115, 70, -1, 116, -1, 117, 69, 116, -1, 119, + -1, 118, 69, 119, -1, 3, -1, 3, 71, 3, + -1, 3, 71, 3, 71, 3, -1, 109, 25, 3, + -1, 78, 3, -1, 3, 71, 78, 3, -1, 3, + -1, 3, 71, 3, -1, 3, 71, 3, 71, 3, + -1, 121, 79, 121, -1, 122, 79, 121, -1, 3, + -1, 123, 69, 123, -1, 124, 69, 123, -1, 126, + -1, 125, 126, -1, 58, 3, 136, 135, 22, 131, + 23, -1, 60, 96, 136, 22, 131, 23, -1, 64, + 3, 22, 63, 133, 65, 22, 131, 23, 66, 22, + 129, 23, 67, 133, 23, -1, 62, 22, 127, 23, + -1, 128, -1, 127, 21, 128, -1, 3, 3, 5, + -1, 130, -1, 129, 21, 130, -1, 3, 68, 138, + 70, -1, 132, -1, 131, 132, -1, 3, 3, 3, + 133, 135, 21, -1, 3, 3, 133, 21, -1, -1, + 68, 134, 70, -1, 3, -1, 3, 3, -1, 3, + 4, -1, 3, 5, -1, 134, 69, 3, -1, 134, + 69, 3, 3, -1, 134, 69, 3, 4, -1, 134, + 69, 3, 5, -1, -1, 72, 137, 73, -1, -1, + 68, 137, 70, -1, 3, -1, 137, 69, 3, -1, + 3, 3, 133, -1, 138, 69, 3, 3, 133, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint16 yyrline[] = +{ + 0, 189, 189, 194, 201, 215, 220, 225, 230, 234, + 237, 242, 247, 251, 255, 260, 261, 265, 266, 270, + 271, 275, 276, 280, 281, 285, 289, 291, 299, 303, + 315, 316, 317, 318, 319, 320, 324, 325, 329, 330, + 334, 335, 336, 337, 338, 342, 343, 348, 349, 353, + 357, 358, 362, 363, 367, 368, 372, 373, 377, 384, + 385, 386, 387, 388, 392, 393, 394, 395, 399, 403, + 407, 408, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 438, 443, 444, 445, + 446, 450, 451, 455, 456, 457, 458, 459, 460, 461, + 462, 463, 464, 465, 466, 472, 473, 477, 478, 482, + 483, 487, 488, 489, 490, 494, 495, 499, 500, 504, + 505, 506, 507, 518, 519, 523, 524, 525, 529, 530, + 534, 538, 539, 554, 555, 558, 560, 562, 564, 568, + 569, 573, 577, 578, 582, 585, 586, 590, 591, 595, + 596, 600, 601, 602, 603, 604, 605, 606, 607, 611, + 612, 616, 617, 621, 622, 626, 627 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "INTNUM", + "LONGINTNUM", "APPROXNUM", "OR", "AND", "NOT", "COMPARISON", "'|'", + "'&'", "SHIFT_OP", "'+'", "'-'", "'*'", "'/'", "'%'", "UMINUS", + "SEMICOLON", "LEFTBRACE", "RIGHTBRACE", "BY", "AS", "AGGR", "FROM", + "INNER_JOIN", "FILTER_JOIN", "OUTER_JOIN", "LEFT_OUTER_JOIN", + "RIGHT_OUTER_JOIN", "GROUP", "HAVING", "IN", "SELECT", "WHERE", + "SUPERGROUP", "CLEANING_WHEN", "CLEANING_BY", "CLOSING_WHEN", "SUCH", + "THAT", "CUBE", "ROLLUP", "GROUPING_SETS", "TRUE_V", "FALSE_V", + "TIMEVAL_L", "HEX_L", "LHEX_L", "IP_L", "IPV6_L", "MERGE", "SLACK", + "DEFINE_SEC", "PARAM_SEC", "PROTOCOL", "TABLE", "STREAM", "FTA", + "UNPACK_FCNS", "OPERATOR", "OPERATOR_VIEW", "FIELDS", "SUBQUERIES", + "SELECTION_PUSHDOWN", "'('", "','", "')'", "'.'", "'['", "']'", "'!'", + "'~'", "'$'", "'#'", "'@'", "':'", "$accept", "parse_result", "gsql", + "query_list", "params_def", "variable_def", "variable_list", + "variable_assign", "select_statement", "merge_statement", "selection", + "table_exp", "from_clause", "table_ref_commalist", "table_ref", "table", + "qname", "opt_where_clause", "where_clause", "opt_cleaning_when_clause", + "opt_cleaning_by_clause", "opt_closing_when_clause", "opt_having_clause", + "having_clause", "search_condition", "predicate", "comparison_predicate", + "in_predicate", "literal_commalist", "scalar_exp", "select_commalist", + "scalar_exp_commalist", "literal", "opt_group_by_clause", + "opt_supergroup_clause", "list_of_gb_commalist", "extended_gb", + "extended_gb_commalist", "gb_commalist", "gb", "ifparam", "column_ref", + "column_ref_list", "gb_ref", "gb_ref_list", "table_list", "table_def", + "unpack_func_list", "unpack_func", "subqueryspec_list", "subq_spec", + "field_list", "field", "opt_param_commalist", "param_commalist", + "opt_singleparam_commalist_bkt", "opt_singleparam_commalist", + "singleparam_commalist", "namevec_commalist", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 124, 38, 267, 43, 45, 42, 47, 37, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 40, 44, + 41, 46, 91, 93, 33, 126, 36, 35, 64, 58 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = +{ + 0, 80, 81, 81, 81, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 83, 83, 84, 84, 85, + 85, 86, 86, 87, 87, 88, 89, 89, 90, 91, + 92, 92, 92, 92, 92, 92, 93, 93, 94, 94, + 95, 95, 95, 95, 95, 96, 96, 97, 97, 98, + 99, 99, 100, 100, 101, 101, 102, 102, 103, 104, + 104, 104, 104, 104, 105, 105, 105, 105, 106, 107, + 108, 108, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, + 109, 109, 109, 109, 109, 109, 109, 110, 110, 110, + 110, 111, 111, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 113, 113, 114, 114, 115, + 115, 116, 116, 116, 116, 117, 117, 118, 118, 119, + 119, 119, 119, 120, 120, 121, 121, 121, 122, 122, + 123, 124, 124, 125, 125, 126, 126, 126, 126, 127, + 127, 128, 129, 129, 130, 131, 131, 132, 132, 133, + 133, 134, 134, 134, 134, 134, 134, 134, 134, 135, + 135, 136, 136, 137, 137, 138, 138 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 1, 5, 3, 3, 2, 2, 1, + 3, 3, 2, 2, 1, 1, 3, 4, 3, 4, + 3, 1, 2, 3, 3, 3, 3, 5, 1, 8, + 2, 3, 3, 3, 3, 8, 1, 3, 1, 2, + 1, 3, 5, 5, 5, 1, 3, 0, 1, 2, + 0, 2, 0, 2, 0, 2, 0, 1, 2, 3, + 3, 2, 3, 1, 1, 1, 3, 4, 3, 5, + 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 2, 2, 2, 2, 1, 2, 1, 1, 3, 4, + 4, 4, 3, 5, 5, 5, 4, 1, 3, 3, + 5, 1, 3, 1, 1, 1, 1, 1, 1, 2, + 2, 2, 2, 2, 2, 0, 3, 0, 2, 3, + 5, 1, 4, 4, 4, 1, 3, 1, 3, 1, + 3, 5, 3, 2, 4, 1, 3, 5, 3, 3, + 1, 3, 3, 1, 2, 7, 6, 16, 4, 1, + 3, 3, 1, 3, 4, 1, 2, 6, 4, 0, + 3, 1, 2, 2, 2, 3, 4, 4, 4, 0, + 3, 0, 3, 1, 3, 3, 5 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint8 yydefact[] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 2, 0, 0, 9, 14, 3, 143, 135, + 103, 104, 105, 106, 0, 0, 0, 107, 108, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 97, 28, 84, 86, 87, 135, 0, 0, 0, + 0, 171, 45, 171, 0, 0, 0, 1, 0, 0, + 7, 12, 0, 8, 13, 144, 0, 0, 0, 80, + 81, 0, 0, 109, 110, 111, 112, 113, 0, 82, + 83, 85, 114, 133, 0, 0, 0, 0, 0, 0, + 25, 47, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 26, 0, 20, 0, + 21, 18, 0, 0, 169, 0, 0, 0, 0, 0, + 149, 0, 16, 6, 11, 5, 10, 92, 101, 0, + 136, 0, 0, 0, 0, 0, 88, 45, 0, 0, + 30, 36, 38, 40, 0, 0, 0, 0, 0, 0, + 115, 48, 74, 77, 79, 72, 73, 75, 76, 78, + 98, 99, 138, 0, 139, 0, 0, 19, 22, 17, + 173, 0, 0, 0, 46, 0, 0, 0, 0, 148, + 159, 0, 91, 0, 134, 96, 0, 89, 90, 0, + 0, 0, 0, 0, 0, 39, 31, 0, 32, 34, + 33, 135, 0, 0, 49, 63, 64, 65, 0, 0, + 117, 0, 27, 24, 23, 0, 172, 0, 0, 0, + 0, 155, 4, 151, 150, 0, 0, 102, 137, 95, + 93, 94, 45, 41, 0, 0, 37, 0, 0, 61, + 0, 0, 0, 0, 0, 0, 0, 0, 56, 100, + 174, 170, 0, 159, 146, 156, 161, 0, 0, 0, + 0, 0, 0, 66, 0, 62, 59, 60, 68, 0, + 129, 0, 0, 0, 0, 125, 116, 121, 140, 0, + 118, 0, 50, 57, 145, 159, 0, 162, 163, 164, + 0, 160, 0, 42, 43, 44, 0, 67, 0, 70, + 0, 0, 0, 0, 0, 0, 0, 0, 58, 0, + 52, 169, 158, 165, 0, 0, 0, 69, 130, 0, + 127, 0, 0, 0, 132, 126, 141, 142, 51, 0, + 54, 0, 166, 167, 168, 0, 35, 71, 0, 0, + 123, 122, 0, 0, 124, 53, 0, 29, 157, 0, + 131, 128, 119, 0, 55, 0, 0, 0, 0, 152, + 120, 0, 0, 0, 0, 0, 153, 159, 159, 0, + 154, 0, 175, 0, 147, 159, 176 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int16 yydefgoto[] = +{ + -1, 10, 11, 12, 13, 14, 109, 110, 15, 16, + 40, 90, 91, 140, 141, 142, 143, 150, 151, 310, + 330, 347, 282, 283, 204, 205, 206, 207, 298, 208, + 42, 129, 43, 210, 248, 323, 275, 276, 319, 320, + 44, 45, 48, 279, 280, 17, 18, 119, 120, 358, + 359, 220, 221, 226, 257, 173, 114, 171, 365 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -247 +static const yytype_int16 yypact[] = +{ + 121, 535, 76, 6, 60, 85, 115, 111, 132, 123, + 165, -247, 147, -9, 117, -247, -247, 178, -247, 87, + -247, -247, -247, -247, 535, 535, -24, -247, -247, 207, + 219, 223, 235, 242, 535, 535, 535, 198, 222, 266, + 261, 554, 230, -247, -247, -247, 243, 238, 360, 104, + 107, 252, -247, 18, 178, 319, 329, -247, -14, 163, + -247, -247, 163, -247, -247, -247, 200, 12, 295, -247, + -247, 279, 301, -247, -247, -247, -247, -247, 294, -247, + -247, -247, -247, -247, 13, 366, 326, 373, 374, 397, + -247, 359, 535, 535, 535, 535, 535, 535, 535, 535, + 423, 535, 424, 76, 535, 76, -247, 63, -247, 113, + -247, -247, 153, 425, 362, 432, 414, 422, 435, 30, + -247, 377, -247, -247, -247, -247, -247, -247, 689, 197, + 370, 439, 355, 383, 327, 369, -247, 385, 386, 451, + 390, -247, 464, 450, 13, 76, 13, 13, 13, 445, + 436, -247, 486, 395, 318, 191, 191, -247, -247, -247, + -247, 645, -247, 624, -247, 449, 452, -247, -247, -247, + -247, 210, 425, 455, -247, 469, 458, 478, 319, -247, + 419, 535, -247, 485, -247, -247, 228, -247, -247, 420, + 616, 488, 511, 416, 13, -247, 390, 446, 390, 390, + 390, 247, 445, 445, 205, -247, -247, -247, 126, 492, + 479, 515, -247, -247, -247, 521, -247, -19, 469, 522, + 161, -247, -247, -247, -247, 523, 463, 689, -247, -247, + -247, -247, 460, 450, 472, 473, -247, 524, 459, -247, + 11, 246, 445, 445, 535, 474, 144, 527, 513, -247, + -247, -247, 164, 15, -247, -247, 268, 233, 526, 115, + 115, 115, 475, -247, 59, -247, 540, -247, 689, 25, + 43, 489, 490, 491, 659, -247, 493, -247, -247, 494, + 505, 445, 537, -247, -247, 419, 539, -247, -247, -247, + 574, -247, 469, 450, 450, 450, 551, -247, 93, -247, + 23, 549, 549, 512, 578, 144, 527, 527, 205, 445, + 550, 362, -247, 345, 221, 13, 25, -247, 216, 255, + -247, 296, 549, 298, -247, -247, -247, -247, 205, 445, + 548, 570, -247, -247, -247, 528, 390, -247, 589, 549, + -247, -247, 308, 525, -247, 205, 445, -247, -247, 573, + 675, -247, -247, 549, 205, 601, 310, 538, 177, -247, + -247, 602, 601, 541, 604, 313, -247, 419, 419, 611, + -247, 592, -247, 613, -247, 419, -247 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int16 yypgoto[] = +{ + -247, -247, -37, -247, 605, 607, 568, -71, 50, 110, + -247, -247, -38, -142, 427, -247, -5, -247, -247, -247, + -247, -247, -247, -247, -194, -247, -247, -247, -247, -1, + -247, -121, -232, -247, -247, -247, 317, -247, -233, -234, + -247, 1, -247, 92, -247, 590, -4, -247, 467, -247, + 284, -193, -206, -246, -247, 336, 595, 477, -247 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -138 +static const yytype_int16 yytable[] = +{ + 41, 53, 196, 47, 198, 199, 200, 286, 239, 240, + 106, 186, 277, 65, 255, 130, 137, 138, 285, 242, + 243, 122, 1, 69, 70, 252, 318, 1, 49, 20, + 21, 22, 23, 78, 79, 80, 115, 299, 168, 311, + 2, 168, 3, 4, 71, 2, 255, 3, 266, 267, + 215, 178, 72, 179, 251, -135, -135, -135, -135, -135, + -135, -135, -135, 60, 63, 128, 165, 166, -135, 321, + 134, 277, 27, 28, 29, 30, 31, 32, 33, 46, + 176, 265, 50, 225, 337, 139, 113, 308, 51, 342, + 131, 152, 153, 154, 155, 156, 157, 158, 159, 314, + 161, 131, 38, 163, 162, 351, 164, 107, 255, 123, + 107, 66, 125, 65, 300, 328, 107, 264, 52, 68, + 356, 371, 372, 61, 64, 212, 56, 108, 181, 376, + 111, 128, 297, 54, 190, 345, 167, 244, 92, 93, + 94, 95, 96, 97, 98, 99, 197, 270, 20, 21, + 22, 23, 354, 1, 55, 66, 107, 1, 67, 24, + 25, 245, 316, 68, 219, 57, 317, 219, 58, 124, + 26, 2, 126, 336, 4, 2, 169, 3, 4, 5, + 227, 6, 7, 8, 254, 9, 233, 284, 271, 272, + 273, 27, 28, 29, 30, 31, 32, 33, 362, 1, + 363, 81, 241, 19, 20, 21, 22, 23, 97, 98, + 99, 73, 34, 242, 243, 24, 25, 2, 35, 36, + 37, 38, 39, 74, 219, 82, 26, 75, -136, -136, + -136, -136, -136, -136, -136, -136, 5, 128, 6, 76, + 8, -136, 9, 268, 335, 274, 77, 27, 28, 29, + 30, 31, 32, 33, 293, 294, 295, 244, 92, 93, + 94, 95, 96, 97, 98, 99, 181, 182, 34, 83, + 127, 287, 288, 289, 35, 36, 37, 38, 39, 215, + 216, 245, 19, 20, 21, 22, 23, 338, 84, 85, + 86, 87, 88, 89, 24, 25, 133, 181, 229, 101, + 274, 274, 290, 291, 274, 26, 92, 93, 94, 95, + 96, 97, 98, 99, 102, 66, 136, 103, 67, 238, + 113, 274, 118, 68, 339, 340, 27, 28, 29, 30, + 31, 32, 33, 95, 96, 97, 98, 99, 274, 92, + 93, 94, 95, 96, 97, 98, 99, 34, 332, 333, + 334, 121, 274, 35, 36, 37, 38, 39, 19, 20, + 21, 22, 23, 132, 136, 339, 341, 343, 344, 135, + 24, 25, 19, 20, 21, 22, 23, 339, 352, 339, + 360, 26, 369, 370, 24, 25, 189, 84, 85, 86, + 87, 88, 89, 144, 145, 26, 149, 188, 326, 327, + 146, 147, 27, 28, 29, 30, 31, 32, 33, 94, + 95, 96, 97, 98, 99, 104, 27, 28, 29, 30, + 31, 32, 33, 34, 148, 185, 160, 130, 170, 35, + 36, 37, 38, 39, 172, 174, 175, 34, 177, 105, + 180, 183, 184, 35, 36, 37, 38, 39, 201, 20, + 21, 22, 23, 187, 193, 202, 191, 192, 1, 194, + 24, 25, 19, 20, 21, 22, 23, 195, 115, 209, + 213, 26, 219, 214, 24, 25, 2, 218, 3, 4, + 5, 222, 6, 223, 8, 26, 9, 225, 228, 235, + 230, 232, 27, 28, 29, 30, 31, 32, 33, 93, + 94, 95, 96, 97, 98, 99, 27, 28, 29, 30, + 31, 32, 33, 203, 234, 237, 246, 247, 249, 35, + 36, 37, 38, 39, 250, 253, 256, 34, 258, 262, + 278, 259, 263, 35, 36, 37, 38, 39, 19, 20, + 21, 22, 23, 260, 261, 296, 269, 281, 292, 243, + 24, 25, 270, 20, 21, 22, 23, 301, 302, 303, + 312, 26, 305, 306, 24, 25, 92, 93, 94, 95, + 96, 97, 98, 99, 307, 26, 309, 313, 315, 100, + 322, 324, 27, 28, 29, 30, 31, 32, 33, 346, + 329, 348, 350, 353, 349, 355, 27, 28, 29, 30, + 31, 32, 33, 34, 357, 364, 361, 368, 367, 35, + 36, 37, 38, 39, 373, 374, 375, 34, 112, 62, + 59, 236, 325, 35, 36, 37, 38, 39, 92, 93, + 94, 95, 96, 97, 98, 99, 92, 93, 94, 95, + 96, 97, 98, 99, 117, 224, 366, 331, 116, 217, + 0, 84, 85, 86, 87, 88, 89, 92, 93, 94, + 95, 96, 97, 98, 99, 0, 0, 0, 0, 0, + 211, 92, 93, 94, 95, 96, 97, 98, 99, 0, + 0, 0, 0, 0, 304, 0, 231, -137, -137, -137, + -137, -137, -137, -137, -137, 0, 0, 0, 0, 0, + -137, 92, 93, 94, 95, 96, 97, 98, 99 +}; + +static const yytype_int16 yycheck[] = +{ + 1, 6, 144, 2, 146, 147, 148, 253, 202, 203, + 48, 132, 246, 17, 220, 3, 3, 4, 3, 8, + 9, 58, 36, 24, 25, 218, 3, 36, 22, 4, + 5, 6, 7, 34, 35, 36, 18, 269, 109, 285, + 54, 112, 56, 57, 68, 54, 252, 56, 242, 243, + 69, 21, 76, 23, 73, 12, 13, 14, 15, 16, + 17, 18, 19, 13, 14, 66, 3, 4, 25, 302, + 71, 305, 47, 48, 49, 50, 51, 52, 53, 3, + 117, 70, 22, 68, 316, 72, 68, 281, 3, 322, + 78, 92, 93, 94, 95, 96, 97, 98, 99, 292, + 101, 78, 77, 104, 103, 339, 105, 3, 314, 59, + 3, 68, 62, 117, 71, 309, 3, 238, 3, 76, + 353, 367, 368, 13, 14, 163, 3, 23, 69, 375, + 23, 132, 73, 22, 135, 329, 23, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 145, 3, 4, 5, + 6, 7, 346, 36, 22, 68, 3, 36, 71, 15, + 16, 35, 69, 76, 3, 0, 73, 3, 21, 59, + 26, 54, 62, 315, 57, 54, 23, 56, 57, 58, + 181, 60, 61, 62, 23, 64, 191, 23, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 21, 36, + 23, 3, 203, 3, 4, 5, 6, 7, 17, 18, + 19, 4, 68, 8, 9, 15, 16, 54, 74, 75, + 76, 77, 78, 4, 3, 3, 26, 4, 12, 13, + 14, 15, 16, 17, 18, 19, 58, 238, 60, 4, + 62, 25, 64, 244, 23, 246, 4, 47, 48, 49, + 50, 51, 52, 53, 259, 260, 261, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 69, 70, 68, 3, + 70, 3, 4, 5, 74, 75, 76, 77, 78, 69, + 70, 35, 3, 4, 5, 6, 7, 71, 27, 28, + 29, 30, 31, 32, 15, 16, 17, 69, 70, 69, + 301, 302, 69, 70, 305, 26, 12, 13, 14, 15, + 16, 17, 18, 19, 71, 68, 70, 79, 71, 72, + 68, 322, 3, 76, 69, 70, 47, 48, 49, 50, + 51, 52, 53, 15, 16, 17, 18, 19, 339, 12, + 13, 14, 15, 16, 17, 18, 19, 68, 3, 4, + 5, 22, 353, 74, 75, 76, 77, 78, 3, 4, + 5, 6, 7, 68, 70, 69, 70, 69, 70, 68, + 15, 16, 3, 4, 5, 6, 7, 69, 70, 69, + 70, 26, 69, 70, 15, 16, 17, 27, 28, 29, + 30, 31, 32, 27, 68, 26, 37, 70, 306, 307, + 27, 27, 47, 48, 49, 50, 51, 52, 53, 14, + 15, 16, 17, 18, 19, 55, 47, 48, 49, 50, + 51, 52, 53, 68, 27, 70, 3, 3, 3, 74, + 75, 76, 77, 78, 72, 3, 22, 68, 3, 79, + 63, 71, 3, 74, 75, 76, 77, 78, 3, 4, + 5, 6, 7, 70, 3, 10, 71, 71, 36, 69, + 15, 16, 3, 4, 5, 6, 7, 3, 18, 33, + 21, 26, 3, 21, 15, 16, 54, 22, 56, 57, + 58, 23, 60, 5, 62, 26, 64, 68, 3, 73, + 70, 3, 47, 48, 49, 50, 51, 52, 53, 13, + 14, 15, 16, 17, 18, 19, 47, 48, 49, 50, + 51, 52, 53, 68, 3, 69, 24, 38, 3, 74, + 75, 76, 77, 78, 3, 3, 3, 68, 65, 5, + 3, 71, 73, 74, 75, 76, 77, 78, 3, 4, + 5, 6, 7, 71, 71, 70, 72, 34, 22, 9, + 15, 16, 3, 4, 5, 6, 7, 68, 68, 68, + 21, 26, 69, 69, 15, 16, 12, 13, 14, 15, + 16, 17, 18, 19, 69, 26, 39, 3, 27, 25, + 68, 3, 47, 48, 49, 50, 51, 52, 53, 41, + 40, 21, 3, 68, 66, 22, 47, 48, 49, 50, + 51, 52, 53, 68, 3, 3, 68, 3, 67, 74, + 75, 76, 77, 78, 3, 23, 3, 68, 50, 14, + 13, 194, 305, 74, 75, 76, 77, 78, 12, 13, + 14, 15, 16, 17, 18, 19, 12, 13, 14, 15, + 16, 17, 18, 19, 54, 178, 362, 311, 53, 172, + -1, 27, 28, 29, 30, 31, 32, 12, 13, 14, + 15, 16, 17, 18, 19, -1, -1, -1, -1, -1, + 25, 12, 13, 14, 15, 16, 17, 18, 19, -1, + -1, -1, -1, -1, 25, -1, 70, 12, 13, 14, + 15, 16, 17, 18, 19, -1, -1, -1, -1, -1, + 25, 12, 13, 14, 15, 16, 17, 18, 19 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 36, 54, 56, 57, 58, 60, 61, 62, 64, + 81, 82, 83, 84, 85, 88, 89, 125, 126, 3, + 4, 5, 6, 7, 15, 16, 26, 47, 48, 49, + 50, 51, 52, 53, 68, 74, 75, 76, 77, 78, + 90, 109, 110, 112, 120, 121, 3, 121, 122, 22, + 22, 3, 3, 96, 22, 22, 3, 0, 21, 85, + 88, 89, 84, 88, 89, 126, 68, 71, 76, 109, + 109, 68, 76, 4, 4, 4, 4, 4, 109, 109, + 109, 3, 3, 3, 27, 28, 29, 30, 31, 32, + 91, 92, 12, 13, 14, 15, 16, 17, 18, 19, + 25, 69, 71, 79, 55, 79, 92, 3, 23, 86, + 87, 23, 86, 68, 136, 18, 136, 125, 3, 127, + 128, 22, 82, 88, 89, 88, 89, 70, 109, 111, + 3, 78, 68, 17, 109, 68, 70, 3, 4, 72, + 93, 94, 95, 96, 27, 68, 27, 27, 27, 37, + 97, 98, 109, 109, 109, 109, 109, 109, 109, 109, + 3, 109, 121, 109, 121, 3, 4, 23, 87, 23, + 3, 137, 72, 135, 3, 22, 82, 3, 21, 23, + 63, 69, 70, 71, 3, 70, 111, 70, 70, 17, + 109, 71, 71, 3, 69, 3, 93, 121, 93, 93, + 93, 3, 10, 68, 104, 105, 106, 107, 109, 33, + 113, 25, 92, 21, 21, 69, 70, 137, 22, 3, + 131, 132, 23, 5, 128, 68, 133, 109, 3, 70, + 70, 70, 3, 96, 3, 73, 94, 69, 72, 104, + 104, 109, 8, 9, 11, 35, 24, 38, 114, 3, + 3, 73, 131, 3, 23, 132, 3, 134, 65, 71, + 71, 71, 5, 73, 111, 70, 104, 104, 109, 72, + 3, 44, 45, 46, 109, 116, 117, 119, 3, 123, + 124, 34, 102, 103, 23, 3, 133, 3, 4, 5, + 69, 70, 22, 96, 96, 96, 70, 73, 108, 112, + 71, 68, 68, 68, 25, 69, 69, 69, 104, 39, + 99, 133, 21, 3, 131, 27, 69, 73, 3, 118, + 119, 118, 68, 115, 3, 116, 123, 123, 104, 40, + 100, 135, 3, 4, 5, 23, 93, 112, 71, 69, + 70, 70, 118, 69, 70, 104, 41, 101, 21, 66, + 3, 119, 70, 68, 104, 22, 118, 3, 129, 130, + 70, 68, 21, 23, 3, 138, 130, 67, 3, 69, + 70, 133, 133, 3, 23, 3, 133 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) +#else +static void +yy_stack_print (bottom, top) + yytype_int16 *bottom; + yytype_int16 *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +#else +static void +yy_reduce_print (yyvsp, yyrule) + YYSTYPE *yyvsp; + int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + fprintf (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + ); + fprintf (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into YYRESULT an error message about the unexpected token + YYCHAR while in state YYSTATE. Return the number of bytes copied, + including the terminating null byte. If YYRESULT is null, do not + copy anything; just return the number of bytes that would be + copied. As a special case, return 0 if an ordinary "syntax error" + message will do. Return YYSIZE_MAXIMUM if overflow occurs during + size calculation. */ +static YYSIZE_T +yysyntax_error (char *yyresult, int yystate, int yychar) +{ + int yyn = yypact[yystate]; + + if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) + return 0; + else + { + int yytype = YYTRANSLATE (yychar); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + int yysize_overflow = 0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + int yyx; + +# if 0 + /* This is so xgettext sees the translatable formats that are + constructed on the fly. */ + YY_("syntax error, unexpected %s"); + YY_("syntax error, unexpected %s, expecting %s"); + YY_("syntax error, unexpected %s, expecting %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +# endif + char *yyfmt; + char const *yyf; + static char const yyunexpected[] = "syntax error, unexpected %s"; + static char const yyexpecting[] = ", expecting %s"; + static char const yyor[] = " or %s"; + char yyformat[sizeof yyunexpected + + sizeof yyexpecting - 1 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) + * (sizeof yyor - 1))]; + char const *yyprefix = yyexpecting; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 1; + + yyarg[0] = yytname[yytype]; + yyfmt = yystpcpy (yyformat, yyunexpected); + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + yyformat[sizeof yyunexpected - 1] = '\0'; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + yyfmt = yystpcpy (yyfmt, yyprefix); + yyprefix = yyor; + } + + yyf = YY_(yyformat); + yysize1 = yysize + yystrlen (yyf); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + + if (yysize_overflow) + return YYSIZE_MAXIMUM; + + if (yyresult) + { + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + char *yyp = yyresult; + int yyi = 0; + while ((*yyp = *yyf) != '\0') + { + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyf += 2; + } + else + { + yyp++; + yyf++; + } + } + } + return yysize; + } +} +#endif /* YYERROR_VERBOSE */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + YYUSE (yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + +/* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + int yystate; + int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss = yyssa; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp; + + + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + look-ahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to look-ahead token. */ + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a look-ahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: +#line 189 "fta.y" + { + fta_parse_result->parse_tree_list = (yyvsp[(1) - (1)].q_list); + fta_parse_result->tables = NULL; + fta_parse_result->parse_type = QUERY_PARSE; + ;} + break; + + case 3: +#line 194 "fta.y" + { + fta_parse_result->parse_tree_list = NULL; + fta_parse_result->fta_parse_tree = NULL; + fta_parse_result->tables = (yyvsp[(1) - (1)].table_list_schema); + fta_parse_result->parse_type = TABLE_PARSE; + ;} + break; + + case 4: +#line 201 "fta.y" + { + fta_parse_result->parse_tree_list = NULL; + fta_parse_result->fta_parse_tree = (yyvsp[(4) - (5)].tblp); + fta_parse_result->tables = (yyvsp[(3) - (5)].table_list_schema); + fta_parse_result->parse_type = STREAM_PARSE; + ;} + break; + + case 5: +#line 215 "fta.y" + { + (yyvsp[(3) - (3)].tblp)->add_nmap((yyvsp[(1) - (3)].var_defs)); // Memory leak : plug it. + (yyvsp[(3) - (3)].tblp)->add_param_list((yyvsp[(2) - (3)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(3) - (3)].tblp); + ;} + break; + + case 6: +#line 220 "fta.y" + { + (yyvsp[(3) - (3)].tblp)->add_nmap((yyvsp[(2) - (3)].var_defs)); // Memory leak : plug it. + (yyvsp[(3) - (3)].tblp)->add_param_list((yyvsp[(1) - (3)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(3) - (3)].tblp); + ;} + break; + + case 7: +#line 225 "fta.y" + { + (yyvsp[(2) - (2)].tblp)->add_nmap(NULL); // Memory leak : plug it. + (yyvsp[(2) - (2)].tblp)->add_param_list((yyvsp[(1) - (2)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(2) - (2)].tblp); + ;} + break; + + case 8: +#line 230 "fta.y" + { + (yyvsp[(2) - (2)].tblp)->add_nmap((yyvsp[(1) - (2)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(2) - (2)].tblp); + ;} + break; + + case 9: +#line 234 "fta.y" + { + (yyval.tblp) = (yyvsp[(1) - (1)].tblp); + ;} + break; + + case 10: +#line 237 "fta.y" + { + (yyvsp[(3) - (3)].tblp)->add_nmap((yyvsp[(1) - (3)].var_defs)); // Memory leak : plug it. + (yyvsp[(3) - (3)].tblp)->add_param_list((yyvsp[(2) - (3)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(3) - (3)].tblp); + ;} + break; + + case 11: +#line 242 "fta.y" + { + (yyvsp[(3) - (3)].tblp)->add_nmap((yyvsp[(2) - (3)].var_defs)); // Memory leak : plug it. + (yyvsp[(3) - (3)].tblp)->add_param_list((yyvsp[(1) - (3)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(3) - (3)].tblp); + ;} + break; + + case 12: +#line 247 "fta.y" + { + (yyvsp[(2) - (2)].tblp)->add_param_list((yyvsp[(1) - (2)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(2) - (2)].tblp); + ;} + break; + + case 13: +#line 251 "fta.y" + { + (yyvsp[(2) - (2)].tblp)->add_nmap((yyvsp[(1) - (2)].var_defs)); // Memory leak : plug it. + (yyval.tblp) = (yyvsp[(2) - (2)].tblp); + ;} + break; + + case 14: +#line 255 "fta.y" + { + (yyval.tblp) = (yyvsp[(1) - (1)].tblp); + ;} + break; + + case 15: +#line 260 "fta.y" + {(yyval.q_list) = new query_list_t((yyvsp[(1) - (1)].tblp));;} + break; + + case 16: +#line 261 "fta.y" + {(yyval.q_list) = (yyvsp[(1) - (3)].q_list)->append((yyvsp[(3) - (3)].tblp));;} + break; + + case 17: +#line 265 "fta.y" + {(yyval.var_defs)=(yyvsp[(3) - (4)].var_defs);;} + break; + + case 18: +#line 266 "fta.y" + {(yyval.var_defs)=NULL;;} + break; + + case 19: +#line 270 "fta.y" + {(yyval.var_defs)=(yyvsp[(3) - (4)].var_defs);fta_parse_defines=(yyvsp[(3) - (4)].var_defs);;} + break; + + case 20: +#line 271 "fta.y" + {(yyval.var_defs)=NULL;fta_parse_defines = NULL;;} + break; + + case 21: +#line 275 "fta.y" + {(yyval.var_defs) = new var_defs_t((yyvsp[(1) - (1)].var_pair));;} + break; + + case 22: +#line 276 "fta.y" + {(yyval.var_defs) = (yyvsp[(1) - (2)].var_defs)->add_var_pair((yyvsp[(2) - (2)].var_pair));;} + break; + + case 23: +#line 280 "fta.y" + {(yyval.var_pair) = new var_pair_t((yyvsp[(1) - (3)].strval),(yyvsp[(2) - (3)].strval));;} + break; + + case 24: +#line 281 "fta.y" + {(yyval.var_pair) = new var_pair_t((yyvsp[(1) - (3)].strval),(yyvsp[(2) - (3)].strval));;} + break; + + case 25: +#line 285 "fta.y" + {(yyval.tblp) = (yyvsp[(3) - (3)].tblp)->add_selection((yyvsp[(2) - (3)].select_listval));;} + break; + + case 26: +#line 290 "fta.y" + {(yyval.tblp) = new table_exp_t((yyvsp[(2) - (3)].clist),(yyvsp[(3) - (3)].tbl_list));;} + break; + + case 27: +#line 292 "fta.y" + {(yyval.tblp) = new table_exp_t((yyvsp[(2) - (5)].clist),(yyvsp[(4) - (5)].scalarval),(yyvsp[(5) - (5)].tbl_list));;} + break; + + case 28: +#line 299 "fta.y" + { (yyval.select_listval) = (yyvsp[(1) - (1)].select_listval);;} + break; + + case 29: +#line 311 "fta.y" + {(yyval.tblp)=new table_exp_t((yyvsp[(1) - (8)].tbl_list),(yyvsp[(2) - (8)].predp),(yyvsp[(3) - (8)].extended_gb_list),(yyvsp[(4) - (8)].clist),(yyvsp[(5) - (8)].predp),(yyvsp[(6) - (8)].predp),(yyvsp[(7) - (8)].predp), (yyvsp[(8) - (8)].predp));;} + break; + + case 30: +#line 315 "fta.y" + {(yyval.tbl_list) = (yyvsp[(2) - (2)].tbl_list); (yyval.tbl_list)->set_properties(-1);;} + break; + + case 31: +#line 316 "fta.y" + {(yyval.tbl_list) = (yyvsp[(3) - (3)].tbl_list); (yyval.tbl_list)->set_properties(INNER_JOIN_PROPERTY);;} + break; + + case 32: +#line 317 "fta.y" + {(yyval.tbl_list) = (yyvsp[(3) - (3)].tbl_list); (yyval.tbl_list)->set_properties(OUTER_JOIN_PROPERTY);;} + break; + + case 33: +#line 318 "fta.y" + {(yyval.tbl_list) = (yyvsp[(3) - (3)].tbl_list); (yyval.tbl_list)->set_properties(RIGHT_OUTER_JOIN_PROPERTY);;} + break; + + case 34: +#line 319 "fta.y" + {(yyval.tbl_list) = (yyvsp[(3) - (3)].tbl_list); (yyval.tbl_list)->set_properties(LEFT_OUTER_JOIN_PROPERTY);;} + break; + + case 35: +#line 320 "fta.y" + {(yyval.tbl_list) = (yyvsp[(8) - (8)].tbl_list); (yyval.tbl_list)->set_properties(FILTER_JOIN_PROPERTY); (yyval.tbl_list)->set_colref((yyvsp[(3) - (8)].colref)); (yyval.tbl_list)->set_temporal_range((yyvsp[(5) - (8)].strval));;} + break; + + case 36: +#line 324 "fta.y" + {(yyval.tbl_list) = new tablevar_list_t((yyvsp[(1) - (1)].table));;} + break; + + case 37: +#line 325 "fta.y" + {(yyval.tbl_list)= (yyvsp[(1) - (3)].tbl_list)->append_table((yyvsp[(3) - (3)].table));;} + break; + + case 38: +#line 329 "fta.y" + { (yyval.table) = (yyvsp[(1) - (1)].table);;} + break; + + case 39: +#line 330 "fta.y" + { (yyval.table)= (yyvsp[(1) - (2)].table)->set_range_var((yyvsp[(2) - (2)].strval));;} + break; + + case 40: +#line 334 "fta.y" + {(yyval.table) = new tablevar_t((yyvsp[(1) - (1)].stringval)->c_str());;} + break; + + case 41: +#line 335 "fta.y" + {(yyval.table) = new tablevar_t((yyvsp[(1) - (3)].strval),(yyvsp[(3) - (3)].stringval)->c_str(),0);;} + break; + + case 42: +#line 336 "fta.y" + {(yyval.table) = new tablevar_t((yyvsp[(1) - (5)].strval),(yyvsp[(3) - (5)].strval),(yyvsp[(5) - (5)].stringval)->c_str());;} + break; + + case 43: +#line 337 "fta.y" + {(yyval.table) = new tablevar_t((yyvsp[(1) - (5)].strval),(yyvsp[(3) - (5)].strval),(yyvsp[(5) - (5)].stringval)->c_str());;} + break; + + case 44: +#line 338 "fta.y" + {(yyval.table) = new tablevar_t((yyvsp[(2) - (5)].strval),(yyvsp[(5) - (5)].stringval)->c_str(),1);;} + break; + + case 45: +#line 342 "fta.y" + {(yyval.stringval) = new string_t((yyvsp[(1) - (1)].strval));;} + break; + + case 46: +#line 343 "fta.y" + {(yyval.stringval) = (yyval.stringval)->append("/",(yyvsp[(3) - (3)].strval));;} + break; + + case 47: +#line 348 "fta.y" + {(yyval.predp)=NULL;;} + break; + + case 48: +#line 349 "fta.y" + {(yyval.predp)=(yyvsp[(1) - (1)].predp);;} + break; + + case 49: +#line 353 "fta.y" + {(yyval.predp) = (yyvsp[(2) - (2)].predp);;} + break; + + case 50: +#line 357 "fta.y" + {(yyval.predp)=NULL;;} + break; + + case 51: +#line 358 "fta.y" + {(yyval.predp)=(yyvsp[(2) - (2)].predp); ;} + break; + + case 52: +#line 362 "fta.y" + {(yyval.predp)=NULL;;} + break; + + case 53: +#line 363 "fta.y" + {(yyval.predp)=(yyvsp[(2) - (2)].predp); ;} + break; + + case 54: +#line 367 "fta.y" + {(yyval.predp)=NULL;;} + break; + + case 55: +#line 368 "fta.y" + {(yyval.predp)=(yyvsp[(2) - (2)].predp); ;} + break; + + case 56: +#line 372 "fta.y" + {(yyval.predp)=NULL;;} + break; + + case 57: +#line 373 "fta.y" + {(yyval.predp)=(yyvsp[(1) - (1)].predp);;} + break; + + case 58: +#line 377 "fta.y" + {(yyval.predp) = (yyvsp[(2) - (2)].predp);;} + break; + + case 59: +#line 384 "fta.y" + {(yyval.predp)=new predicate_t("OR",(yyvsp[(1) - (3)].predp),(yyvsp[(3) - (3)].predp));;} + break; + + case 60: +#line 385 "fta.y" + {(yyval.predp)=new predicate_t("AND",(yyvsp[(1) - (3)].predp),(yyvsp[(3) - (3)].predp));;} + break; + + case 61: +#line 386 "fta.y" + {(yyval.predp) = new predicate_t("NOT", (yyvsp[(2) - (2)].predp) );;} + break; + + case 62: +#line 387 "fta.y" + {(yyval.predp) = (yyvsp[(2) - (3)].predp);;} + break; + + case 63: +#line 388 "fta.y" + {(yyval.predp) = (yyvsp[(1) - (1)].predp);;} + break; + + case 64: +#line 392 "fta.y" + { (yyval.predp)=(yyvsp[(1) - (1)].predp);;} + break; + + case 65: +#line 393 "fta.y" + { (yyval.predp) = (yyvsp[(1) - (1)].predp);;} + break; + + case 66: +#line 394 "fta.y" + {(yyval.predp) = predicate_t::make_paramless_fcn_predicate((yyvsp[(1) - (3)].strval)); ;} + break; + + case 67: +#line 395 "fta.y" + {(yyval.predp) = new predicate_t((yyvsp[(1) - (4)].strval), (yyvsp[(3) - (4)].se_listval)->get_se_list()); ;} + break; + + case 68: +#line 399 "fta.y" + {(yyval.predp) = new predicate_t((yyvsp[(1) - (3)].scalarval),(yyvsp[(2) - (3)].strval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 69: +#line 403 "fta.y" + { (yyval.predp) = new predicate_t((yyvsp[(1) - (5)].scalarval),(yyvsp[(4) - (5)].lit_l)); ;} + break; + + case 70: +#line 407 "fta.y" + {(yyval.lit_l) = new literal_list_t((yyvsp[(1) - (1)].litval));;} + break; + + case 71: +#line 408 "fta.y" + {(yyval.lit_l) = (yyvsp[(1) - (3)].lit_l)->append_literal((yyvsp[(3) - (3)].litval));;} + break; + + case 72: +#line 414 "fta.y" + { (yyval.scalarval)=new scalarexp_t("+",(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 73: +#line 415 "fta.y" + { (yyval.scalarval)=new scalarexp_t("-",(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 74: +#line 416 "fta.y" + { (yyval.scalarval)=new scalarexp_t("|",(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 75: +#line 417 "fta.y" + { (yyval.scalarval)=new scalarexp_t("*",(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 76: +#line 418 "fta.y" + { (yyval.scalarval)=new scalarexp_t("/",(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 77: +#line 419 "fta.y" + { (yyval.scalarval)=new scalarexp_t("&",(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 78: +#line 420 "fta.y" + { (yyval.scalarval)=new scalarexp_t("%",(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 79: +#line 421 "fta.y" + { (yyval.scalarval)=new scalarexp_t((yyvsp[(2) - (3)].strval),(yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].scalarval));;} + break; + + case 80: +#line 422 "fta.y" + { (yyval.scalarval) = new scalarexp_t("+",(yyvsp[(2) - (2)].scalarval));;} + break; + + case 81: +#line 423 "fta.y" + { (yyval.scalarval) = new scalarexp_t("-",(yyvsp[(2) - (2)].scalarval));;} + break; + + case 82: +#line 424 "fta.y" + { (yyval.scalarval) = new scalarexp_t("!",(yyvsp[(2) - (2)].scalarval));;} + break; + + case 83: +#line 425 "fta.y" + { (yyval.scalarval) = new scalarexp_t("~",(yyvsp[(2) - (2)].scalarval));;} + break; + + case 84: +#line 426 "fta.y" + { (yyval.scalarval)= new scalarexp_t((yyvsp[(1) - (1)].litval));;} + break; + + case 85: +#line 427 "fta.y" + {(yyval.scalarval) = scalarexp_t::make_param_reference((yyvsp[(2) - (2)].strval));;} + break; + + case 86: +#line 428 "fta.y" + {(yyval.scalarval) = scalarexp_t::make_iface_param_reference((yyvsp[(1) - (1)].ifpref));;} + break; + + case 87: +#line 429 "fta.y" + { (yyval.scalarval) = new scalarexp_t((yyvsp[(1) - (1)].colref));;} + break; + + case 88: +#line 430 "fta.y" + {(yyval.scalarval) = (yyvsp[(2) - (3)].scalarval);;} + break; + + case 89: +#line 431 "fta.y" + { (yyval.scalarval) = scalarexp_t::make_star_aggr((yyvsp[(1) - (4)].strval)); ;} + break; + + case 90: +#line 432 "fta.y" + { (yyval.scalarval) = scalarexp_t::make_se_aggr((yyvsp[(1) - (4)].strval),(yyvsp[(3) - (4)].scalarval)); ;} + break; + + case 91: +#line 433 "fta.y" + {(yyval.scalarval) = new scalarexp_t((yyvsp[(1) - (4)].strval), (yyvsp[(3) - (4)].se_listval)->get_se_list()); ;} + break; + + case 92: +#line 434 "fta.y" + {(yyval.scalarval) = scalarexp_t::make_paramless_fcn((yyvsp[(1) - (3)].strval)); ;} + break; + + case 93: +#line 435 "fta.y" + { (yyval.scalarval) = scalarexp_t::make_star_aggr((yyvsp[(1) - (5)].strval)); (yyval.scalarval)->set_superaggr(true); ;} + break; + + case 94: +#line 436 "fta.y" + { (yyval.scalarval) = scalarexp_t::make_se_aggr((yyvsp[(1) - (5)].strval),(yyvsp[(4) - (5)].scalarval)); (yyval.scalarval)->set_superaggr(true); ;} + break; + + case 95: +#line 437 "fta.y" + {(yyval.scalarval) = new scalarexp_t((yyvsp[(1) - (5)].strval), (yyvsp[(4) - (5)].se_listval)->get_se_list()); (yyval.scalarval)->set_superaggr(true); ;} + break; + + case 96: +#line 438 "fta.y" + {(yyval.scalarval) = scalarexp_t::make_paramless_fcn((yyvsp[(1) - (4)].strval)); (yyval.scalarval)->set_superaggr(true); ;} + break; + + case 97: +#line 443 "fta.y" + { (yyval.select_listval)= new select_list_t((yyvsp[(1) - (1)].scalarval)); ;} + break; + + case 98: +#line 444 "fta.y" + { (yyval.select_listval)= new select_list_t((yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].strval)); ;} + break; + + case 99: +#line 445 "fta.y" + { (yyval.select_listval)=(yyvsp[(1) - (3)].select_listval)->append((yyvsp[(3) - (3)].scalarval)); ;} + break; + + case 100: +#line 446 "fta.y" + { (yyval.select_listval)=(yyvsp[(1) - (5)].select_listval)->append((yyvsp[(3) - (5)].scalarval),(yyvsp[(5) - (5)].strval)); ;} + break; + + case 101: +#line 450 "fta.y" + { (yyval.se_listval)= new se_list_t((yyvsp[(1) - (1)].scalarval)); ;} + break; + + case 102: +#line 451 "fta.y" + { (yyval.se_listval)=(yyvsp[(1) - (3)].se_listval)->append((yyvsp[(3) - (3)].scalarval)); ;} + break; + + case 103: +#line 455 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(1) - (1)].strval),LITERAL_STRING);;} + break; + + case 104: +#line 456 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(1) - (1)].strval),LITERAL_INT);;} + break; + + case 105: +#line 457 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(1) - (1)].strval),LITERAL_LONGINT);;} + break; + + case 106: +#line 458 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(1) - (1)].strval),LITERAL_FLOAT);;} + break; + + case 107: +#line 459 "fta.y" + {(yyval.litval) = new literal_t("TRUE",LITERAL_BOOL);;} + break; + + case 108: +#line 460 "fta.y" + {(yyval.litval) = new literal_t("FALSE",LITERAL_BOOL);;} + break; + + case 109: +#line 461 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(2) - (2)].strval),LITERAL_TIMEVAL);;} + break; + + case 110: +#line 462 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(2) - (2)].strval),LITERAL_HEX);;} + break; + + case 111: +#line 463 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(2) - (2)].strval),LITERAL_LONGHEX);;} + break; + + case 112: +#line 464 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(2) - (2)].strval),LITERAL_IP);;} + break; + + case 113: +#line 465 "fta.y" + {(yyval.litval) = new literal_t((yyvsp[(2) - (2)].strval),LITERAL_IPV6);;} + break; + + case 114: +#line 466 "fta.y" + {(yyval.litval) = literal_t::make_define_literal((yyvsp[(2) - (2)].strval),fta_parse_defines);;} + break; + + case 115: +#line 472 "fta.y" + {(yyval.extended_gb_list) = NULL;;} + break; + + case 116: +#line 473 "fta.y" + {(yyval.extended_gb_list) = (yyvsp[(3) - (3)].extended_gb_list);;} + break; + + case 117: +#line 477 "fta.y" + {(yyval.clist) = NULL;;} + break; + + case 118: +#line 478 "fta.y" + {(yyval.clist) = (yyvsp[(2) - (2)].clist);;} + break; + + case 119: +#line 482 "fta.y" + { (yyval.list_of_gb_list) = new list_of_gb_list_t((yyvsp[(2) - (3)].gb_list));;} + break; + + case 120: +#line 483 "fta.y" + {(yyval.list_of_gb_list) = (yyvsp[(1) - (5)].list_of_gb_list)->append((yyvsp[(4) - (5)].gb_list));;} + break; + + case 121: +#line 487 "fta.y" + {(yyval.extended_gb) = extended_gb_t::create_from_gb((yyvsp[(1) - (1)].gb_val));;} + break; + + case 122: +#line 488 "fta.y" + {(yyval.extended_gb) = extended_gb_t::extended_create_from_rollup((yyvsp[(3) - (4)].gb_list));;} + break; + + case 123: +#line 489 "fta.y" + {(yyval.extended_gb) = extended_gb_t::extended_create_from_cube((yyvsp[(3) - (4)].gb_list));;} + break; + + case 124: +#line 490 "fta.y" + {(yyval.extended_gb) = extended_gb_t::extended_create_from_gsets((yyvsp[(3) - (4)].list_of_gb_list));;} + break; + + case 125: +#line 494 "fta.y" + { (yyval.extended_gb_list) = new extended_gb_list_t((yyvsp[(1) - (1)].extended_gb));;} + break; + + case 126: +#line 495 "fta.y" + { (yyval.extended_gb_list)=(yyvsp[(1) - (3)].extended_gb_list)->append((yyvsp[(3) - (3)].extended_gb));;} + break; + + case 127: +#line 499 "fta.y" + { (yyval.gb_list) = new gb_list_t((yyvsp[(1) - (1)].gb_val));;} + break; + + case 128: +#line 500 "fta.y" + { (yyval.gb_list)=(yyvsp[(1) - (3)].gb_list)->append((yyvsp[(3) - (3)].gb_val));;} + break; + + case 129: +#line 504 "fta.y" + {(yyval.gb_val) = new gb_t((yyvsp[(1) - (1)].strval)); ;} + break; + + case 130: +#line 505 "fta.y" + {(yyval.gb_val) = new gb_t((yyvsp[(1) - (3)].strval),(yyvsp[(3) - (3)].strval)); ;} + break; + + case 131: +#line 506 "fta.y" + {(yyval.gb_val) = new gb_t((yyvsp[(1) - (5)].strval),(yyvsp[(3) - (5)].strval),(yyvsp[(5) - (5)].strval)); ;} + break; + + case 132: +#line 507 "fta.y" + {(yyval.gb_val) = new gb_t((yyvsp[(1) - (3)].scalarval),(yyvsp[(3) - (3)].strval)); ;} + break; + + case 133: +#line 518 "fta.y" + {(yyval.ifpref) = new ifpref_t((yyvsp[(2) - (2)].strval));;} + break; + + case 134: +#line 519 "fta.y" + {(yyval.ifpref) = new ifpref_t((yyvsp[(1) - (4)].strval), (yyvsp[(4) - (4)].strval));;} + break; + + case 135: +#line 523 "fta.y" + {(yyval.colref) = new colref_t((yyvsp[(1) - (1)].strval)); ;} + break; + + case 136: +#line 524 "fta.y" + {(yyval.colref) = new colref_t((yyvsp[(1) - (3)].strval),(yyvsp[(3) - (3)].strval)); ;} + break; + + case 137: +#line 525 "fta.y" + {(yyval.colref) = new colref_t((yyvsp[(1) - (5)].strval),(yyvsp[(3) - (5)].strval),(yyvsp[(5) - (5)].strval)); ;} + break; + + case 138: +#line 529 "fta.y" + {(yyval.clist)=new colref_list_t((yyvsp[(1) - (3)].colref)); (yyval.clist)->append((yyvsp[(3) - (3)].colref));;} + break; + + case 139: +#line 530 "fta.y" + {(yyval.clist) = (yyvsp[(1) - (3)].clist)->append((yyvsp[(3) - (3)].colref));;} + break; + + case 140: +#line 534 "fta.y" + {(yyval.colref) = new colref_t((yyvsp[(1) - (1)].strval)); ;} + break; + + case 141: +#line 538 "fta.y" + {(yyval.clist)=new colref_list_t((yyvsp[(1) - (3)].colref)); (yyval.clist)->append((yyvsp[(3) - (3)].colref));;} + break; + + case 142: +#line 539 "fta.y" + {(yyval.clist) = (yyvsp[(1) - (3)].clist)->append((yyvsp[(3) - (3)].colref));;} + break; + + case 143: +#line 554 "fta.y" + {(yyval.table_list_schema) = new table_list((yyvsp[(1) - (1)].table_def_t));;} + break; + + case 144: +#line 555 "fta.y" + {(yyval.table_list_schema) = (yyvsp[(1) - (2)].table_list_schema)->append_table((yyvsp[(2) - (2)].table_def_t));;} + break; + + case 145: +#line 558 "fta.y" + { + (yyval.table_def_t)=new table_def((yyvsp[(2) - (7)].strval),(yyvsp[(3) - (7)].plist_t),(yyvsp[(4) - (7)].plist_t), (yyvsp[(6) - (7)].field_list_t), PROTOCOL_SCHEMA); delete (yyvsp[(6) - (7)].field_list_t);;} + break; + + case 146: +#line 560 "fta.y" + { + (yyval.table_def_t)=new table_def((yyvsp[(2) - (6)].stringval)->c_str(),(yyvsp[(3) - (6)].plist_t),NULL,(yyvsp[(5) - (6)].field_list_t), STREAM_SCHEMA); delete (yyvsp[(5) - (6)].field_list_t);;} + break; + + case 147: +#line 562 "fta.y" + { + (yyval.table_def_t) = new table_def((yyvsp[(2) - (16)].strval), (yyvsp[(5) - (16)].plist_t), (yyvsp[(8) - (16)].field_list_t), (yyvsp[(12) - (16)].subqueryspec_list_t), (yyvsp[(15) - (16)].plist_t)); ;} + break; + + case 148: +#line 564 "fta.y" + { (yyval.table_def_t) = new table_def((yyvsp[(3) - (4)].ufcnl)); ;} + break; + + case 149: +#line 568 "fta.y" + {(yyval.ufcnl) = new unpack_fcn_list((yyvsp[(1) - (1)].ufcn));;} + break; + + case 150: +#line 569 "fta.y" + {(yyval.ufcnl) = (yyvsp[(1) - (3)].ufcnl) -> append((yyvsp[(3) - (3)].ufcn));;} + break; + + case 151: +#line 573 "fta.y" + {(yyval.ufcn) = new unpack_fcn((yyvsp[(1) - (3)].strval),(yyvsp[(2) - (3)].strval),(yyvsp[(3) - (3)].strval));;} + break; + + case 152: +#line 577 "fta.y" + {(yyval.subqueryspec_list_t) = new subqueryspec_list((yyvsp[(1) - (1)].subq_spec_t));;} + break; + + case 153: +#line 578 "fta.y" + {(yyval.subqueryspec_list_t) = (yyvsp[(1) - (3)].subqueryspec_list_t)->append((yyvsp[(3) - (3)].subq_spec_t));;} + break; + + case 154: +#line 582 "fta.y" + {(yyval.subq_spec_t)=new subquery_spec((yyvsp[(1) - (4)].strval), (yyvsp[(3) - (4)].namevec_t)); delete (yyvsp[(3) - (4)].namevec_t);;} + break; + + case 155: +#line 585 "fta.y" + {(yyval.field_list_t) = new field_entry_list((yyvsp[(1) - (1)].field_t));;} + break; + + case 156: +#line 586 "fta.y" + {(yyval.field_list_t) = (yyvsp[(1) - (2)].field_list_t)->append_field((yyvsp[(2) - (2)].field_t));;} + break; + + case 157: +#line 590 "fta.y" + {(yyval.field_t) = new field_entry((yyvsp[(1) - (6)].strval),(yyvsp[(2) - (6)].strval),(yyvsp[(3) - (6)].strval),(yyvsp[(4) - (6)].plist_t),(yyvsp[(5) - (6)].plist_t));;} + break; + + case 158: +#line 591 "fta.y" + {(yyval.field_t) = new field_entry((yyvsp[(1) - (4)].strval),(yyvsp[(2) - (4)].strval),"",(yyvsp[(3) - (4)].plist_t),NULL);;} + break; + + case 159: +#line 595 "fta.y" + {(yyval.plist_t) = NULL;;} + break; + + case 160: +#line 596 "fta.y" + {(yyval.plist_t) = (yyvsp[(2) - (3)].plist_t);;} + break; + + case 161: +#line 600 "fta.y" + {(yyval.plist_t) = new param_list((yyvsp[(1) - (1)].strval));;} + break; + + case 162: +#line 601 "fta.y" + {(yyval.plist_t) = new param_list((yyvsp[(1) - (2)].strval),(yyvsp[(2) - (2)].strval));;} + break; + + case 163: +#line 602 "fta.y" + {(yyval.plist_t) = new param_list((yyvsp[(1) - (2)].strval),(yyvsp[(2) - (2)].strval));;} + break; + + case 164: +#line 603 "fta.y" + {(yyval.plist_t) = new param_list((yyvsp[(1) - (2)].strval),(yyvsp[(2) - (2)].strval));;} + break; + + case 165: +#line 604 "fta.y" + {(yyval.plist_t) = (yyvsp[(1) - (3)].plist_t)->append((yyvsp[(3) - (3)].strval));;} + break; + + case 166: +#line 605 "fta.y" + {(yyval.plist_t) = (yyvsp[(1) - (4)].plist_t)->append((yyvsp[(3) - (4)].strval),(yyvsp[(4) - (4)].strval));;} + break; + + case 167: +#line 606 "fta.y" + {(yyval.plist_t) = (yyvsp[(1) - (4)].plist_t)->append((yyvsp[(3) - (4)].strval),(yyvsp[(4) - (4)].strval));;} + break; + + case 168: +#line 607 "fta.y" + {(yyval.plist_t) = (yyvsp[(1) - (4)].plist_t)->append((yyvsp[(3) - (4)].strval),(yyvsp[(4) - (4)].strval));;} + break; + + case 169: +#line 611 "fta.y" + {(yyval.plist_t) = NULL;;} + break; + + case 170: +#line 612 "fta.y" + {(yyval.plist_t) = (yyvsp[(2) - (3)].plist_t);;} + break; + + case 171: +#line 616 "fta.y" + {(yyval.plist_t) = NULL;;} + break; + + case 172: +#line 617 "fta.y" + {(yyval.plist_t) = (yyvsp[(2) - (3)].plist_t);;} + break; + + case 173: +#line 621 "fta.y" + {(yyval.plist_t) = new param_list((yyvsp[(1) - (1)].strval));;} + break; + + case 174: +#line 622 "fta.y" + {(yyval.plist_t) = (yyvsp[(1) - (3)].plist_t)->append((yyvsp[(3) - (3)].strval));;} + break; + + case 175: +#line 626 "fta.y" + {(yyval.namevec_t) = new name_vec((yyvsp[(1) - (3)].strval),(yyvsp[(2) - (3)].strval),(yyvsp[(3) - (3)].plist_t));;} + break; + + case 176: +#line 627 "fta.y" + {(yyval.namevec_t) = (yyvsp[(1) - (5)].namevec_t)->append((yyvsp[(3) - (5)].strval),(yyvsp[(4) - (5)].strval), (yyvsp[(5) - (5)].plist_t));;} + break; + + +/* Line 1267 of yacc.c. */ +#line 2843 "fta.tab.cc" + default: break; + } + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (YY_("syntax error")); +#else + { + YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); + if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) + { + YYSIZE_T yyalloc = 2 * yysize; + if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) + yyalloc = YYSTACK_ALLOC_MAXIMUM; + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yyalloc); + if (yymsg) + yymsg_alloc = yyalloc; + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + } + + if (0 < yysize && yysize <= yymsg_alloc) + { + (void) yysyntax_error (yymsg, yystate, yychar); + yyerror (yymsg); + } + else + { + yyerror (YY_("syntax error")); + if (yysize != 0) + goto yyexhaustedlab; + } + } +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse look-ahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse look-ahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEOF && yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + +#line 630 "fta.y" + + + diff --git a/src/ftacmp/fta.tab.cc.h b/src/ftacmp/fta.tab.cc.h new file mode 100644 index 0000000..f75c6b1 --- /dev/null +++ b/src/ftacmp/fta.tab.cc.h @@ -0,0 +1,221 @@ +/* A Bison parser, made by GNU Bison 2.3. */ + +/* Skeleton interface for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259, + INTNUM = 260, + LONGINTNUM = 261, + APPROXNUM = 262, + OR = 263, + AND = 264, + NOT = 265, + COMPARISON = 266, + SHIFT_OP = 267, + UMINUS = 268, + SEMICOLON = 269, + LEFTBRACE = 270, + RIGHTBRACE = 271, + BY = 272, + AS = 273, + AGGR = 274, + FROM = 275, + INNER_JOIN = 276, + FILTER_JOIN = 277, + OUTER_JOIN = 278, + LEFT_OUTER_JOIN = 279, + RIGHT_OUTER_JOIN = 280, + GROUP = 281, + HAVING = 282, + IN = 283, + SELECT = 284, + WHERE = 285, + SUPERGROUP = 286, + CLEANING_WHEN = 287, + CLEANING_BY = 288, + CLOSING_WHEN = 289, + SUCH = 290, + THAT = 291, + CUBE = 292, + ROLLUP = 293, + GROUPING_SETS = 294, + TRUE_V = 295, + FALSE_V = 296, + TIMEVAL_L = 297, + HEX_L = 298, + LHEX_L = 299, + IP_L = 300, + IPV6_L = 301, + MERGE = 302, + SLACK = 303, + DEFINE_SEC = 304, + PARAM_SEC = 305, + PROTOCOL = 306, + TABLE = 307, + STREAM = 308, + FTA = 309, + UNPACK_FCNS = 310, + OPERATOR = 311, + OPERATOR_VIEW = 312, + FIELDS = 313, + SUBQUERIES = 314, + SELECTION_PUSHDOWN = 315 + }; +#endif +/* Tokens. */ +#define NAME 258 +#define STRING_TOKEN 259 +#define INTNUM 260 +#define LONGINTNUM 261 +#define APPROXNUM 262 +#define OR 263 +#define AND 264 +#define NOT 265 +#define COMPARISON 266 +#define SHIFT_OP 267 +#define UMINUS 268 +#define SEMICOLON 269 +#define LEFTBRACE 270 +#define RIGHTBRACE 271 +#define BY 272 +#define AS 273 +#define AGGR 274 +#define FROM 275 +#define INNER_JOIN 276 +#define FILTER_JOIN 277 +#define OUTER_JOIN 278 +#define LEFT_OUTER_JOIN 279 +#define RIGHT_OUTER_JOIN 280 +#define GROUP 281 +#define HAVING 282 +#define IN 283 +#define SELECT 284 +#define WHERE 285 +#define SUPERGROUP 286 +#define CLEANING_WHEN 287 +#define CLEANING_BY 288 +#define CLOSING_WHEN 289 +#define SUCH 290 +#define THAT 291 +#define CUBE 292 +#define ROLLUP 293 +#define GROUPING_SETS 294 +#define TRUE_V 295 +#define FALSE_V 296 +#define TIMEVAL_L 297 +#define HEX_L 298 +#define LHEX_L 299 +#define IP_L 300 +#define IPV6_L 301 +#define MERGE 302 +#define SLACK 303 +#define DEFINE_SEC 304 +#define PARAM_SEC 305 +#define PROTOCOL 306 +#define TABLE 307 +#define STREAM 308 +#define FTA 309 +#define UNPACK_FCNS 310 +#define OPERATOR 311 +#define OPERATOR_VIEW 312 +#define FIELDS 313 +#define SUBQUERIES 314 +#define SELECTION_PUSHDOWN 315 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 37 "fta.y" +{ + int intval; + double floatval; + char *strval; + int subtok; + + string_t *stringval; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + select_list_t *select_listval; + table_exp_t *tblp; + predicate_t *predp; + literal_list_t *lit_l; + tablevar_t *table; + tablevar_list_t *tbl_list; + colref_t *colref; + ifpref_t *ifpref; + colref_list_t *clist; + var_defs_t *var_defs; + var_pair_t *var_pair; + gb_t *gb_val; + gb_list_t *gb_list; + list_of_gb_list_t *list_of_gb_list; + extended_gb_t *extended_gb; + extended_gb_list_t *extended_gb_list; + + query_list_t *q_list; + +/* For table definition */ + field_entry *field_t; + field_entry_list *field_list_t; + table_def *table_def_t; + table_list *table_list_schema; + param_list *plist_t; + name_vec *namevec_t; + subquery_spec *subq_spec_t; + subqueryspec_list *subqueryspec_list_t; + unpack_fcn *ufcn; + unpack_fcn_list *ufcnl; + +} +/* Line 1529 of yacc.c. */ +#line 214 "fta.tab.cc.h" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +extern YYSTYPE FtaParserlval; + diff --git a/src/ftacmp/fta.y b/src/ftacmp/fta.y new file mode 100644 index 0000000..cab9546 --- /dev/null +++ b/src/ftacmp/fta.y @@ -0,0 +1,646 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + bison --verbose --defines=fta.tab.cc.h -p FtaParser -o fta.tab.cc fta.y + + (or equivalent). +*/ + +%{ + + +#include + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_fta.h" +#include "parse_schema.h" + + +extern fta_parse_t *fta_parse_result; +extern var_defs_t *fta_parse_defines; + + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + int intval; + double floatval; + char *strval; + int subtok; + + string_t *stringval; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + select_list_t *select_listval; + table_exp_t *tblp; + predicate_t *predp; + literal_list_t *lit_l; + tablevar_t *table; + tablevar_list_t *tbl_list; + colref_t *colref; + ifpref_t *ifpref; + colref_list_t *clist; + var_defs_t *var_defs; + var_pair_t *var_pair; + gb_t *gb_val; + gb_list_t *gb_list; + list_of_gb_list_t *list_of_gb_list; + extended_gb_t *extended_gb; + extended_gb_list_t *extended_gb_list; + + query_list_t *q_list; + +/* For table definition */ + field_entry *field_t; + field_entry_list *field_list_t; + table_def *table_def_t; + table_list *table_list_schema; + param_list *plist_t; + name_vec *namevec_t; + subquery_spec *subq_spec_t; + subqueryspec_list *subqueryspec_list_t; + unpack_fcn *ufcn; + unpack_fcn_list *ufcnl; + +} + +%token NAME +%token STRING_TOKEN +%token INTNUM +%token LONGINTNUM +%token APPROXNUM + +/* for FTA definition. */ +%type query_list +%type gsql +%type select_statement +%type merge_statement +%type opt_where_clause +%type opt_having_clause +%type selection +%type table_exp +%type from_clause +%type table_ref_commalist +%type table_ref +%type qname +%type where_clause +%type having_clause +%type search_condition +%type predicate +%type comparison_predicate +%type in_predicate +%type opt_cleaning_when_clause +%type opt_cleaning_by_clause +%type opt_closing_when_clause +%type literal +%type column_ref +%type gb_ref +%type ifparam +%type column_ref_list +%type gb_ref_list +%type
table +%type scalar_exp +%type scalar_exp_commalist +%type select_commalist +%type literal_commalist +%type opt_group_by_clause +%type opt_supergroup_clause +%type gb_commalist +%type extended_gb +%type extended_gb_commalist +%type list_of_gb_commalist +%type gb +/* for PARAM, DEFINE block */ +%type variable_def +%type params_def +%type variable_list +%type variable_assign + +/* For table definition */ +%type field +%type field_list +%type table_def +%type table_list +%type param_commalist +%type opt_param_commalist +%type singleparam_commalist +%type opt_singleparam_commalist +%type opt_singleparam_commalist_bkt +%type namevec_commalist +%type subq_spec +%type subqueryspec_list +%type unpack_func +%type unpack_func_list + + /* operators */ + +%left OR +%left AND +%left NOT +%left COMPARISON /* = <> < > <= >= */ +%left '|' +%left '&' +%left SHIFT_OP /* << >> */ +%left '+' '-' +%left '*' '/' '%' +%nonassoc UMINUS + + /* literal keyword tokens */ +%token SEMICOLON LEFTBRACE RIGHTBRACE +/* For query definition */ +%token BY AS +%token AGGR +%token FROM INNER_JOIN FILTER_JOIN OUTER_JOIN LEFT_OUTER_JOIN RIGHT_OUTER_JOIN +%token GROUP HAVING IN +%token SELECT +%token WHERE SUPERGROUP CLEANING_WHEN CLEANING_BY CLOSING_WHEN +%token SUCH THAT +%token CUBE ROLLUP GROUPING_SETS + +%token TRUE_V FALSE_V +%token TIMEVAL_L HEX_L LHEX_L IP_L IPV6_L +%token MERGE SLACK + +%token DEFINE_SEC PARAM_SEC + +/* For table definition */ +%token PROTOCOL TABLE STREAM FTA UNPACK_FCNS +%token OPERATOR OPERATOR_VIEW FIELDS SUBQUERIES SELECTION_PUSHDOWN + + +%% + +/* Union of possible results */ +parse_result: query_list { + fta_parse_result->parse_tree_list = $1; + fta_parse_result->tables = NULL; + fta_parse_result->parse_type = QUERY_PARSE; + } + | table_list { + fta_parse_result->parse_tree_list = NULL; + fta_parse_result->fta_parse_tree = NULL; + fta_parse_result->tables = $1; + fta_parse_result->parse_type = TABLE_PARSE; + } +// table_list should contain a single STREAM_SCHEMA table. + | FTA LEFTBRACE table_list gsql RIGHTBRACE { + fta_parse_result->parse_tree_list = NULL; + fta_parse_result->fta_parse_tree = $4; + fta_parse_result->tables = $3; + fta_parse_result->parse_type = STREAM_PARSE; + } + ; + + + +/* Query definition. + WARNING: there might be some relics. +*/ + +gsql: variable_def params_def select_statement { + $3->add_nmap($1); // Memory leak : plug it. + $3->add_param_list($2); // Memory leak : plug it. + $$ = $3; + } + | params_def variable_def select_statement { + $3->add_nmap($2); // Memory leak : plug it. + $3->add_param_list($1); // Memory leak : plug it. + $$ = $3; + } + | params_def select_statement { + $2->add_nmap(NULL); // Memory leak : plug it. + $2->add_param_list($1); // Memory leak : plug it. + $$ = $2; + } + | variable_def select_statement { + $2->add_nmap($1); // Memory leak : plug it. + $$ = $2; + } + | select_statement { + $$ = $1; + } + | variable_def params_def merge_statement{ + $3->add_nmap($1); // Memory leak : plug it. + $3->add_param_list($2); // Memory leak : plug it. + $$ = $3; + } + | params_def variable_def merge_statement{ + $3->add_nmap($2); // Memory leak : plug it. + $3->add_param_list($1); // Memory leak : plug it. + $$ = $3; + } + | params_def merge_statement{ + $2->add_param_list($1); // Memory leak : plug it. + $$ = $2; + } + | variable_def merge_statement{ + $2->add_nmap($1); // Memory leak : plug it. + $$ = $2; + } + | merge_statement{ + $$ = $1; + } + ; + +query_list: gsql {$$ = new query_list_t($1);} + | query_list SEMICOLON gsql {$$ = $1->append($3);} + ; + +params_def: + PARAM_SEC LEFTBRACE variable_list RIGHTBRACE {$$=$3;} + | PARAM_SEC LEFTBRACE RIGHTBRACE {$$=NULL;} + ; + +variable_def: + DEFINE_SEC LEFTBRACE variable_list RIGHTBRACE {$$=$3;fta_parse_defines=$3;} + | DEFINE_SEC LEFTBRACE RIGHTBRACE {$$=NULL;fta_parse_defines = NULL;} + ; + +variable_list: + variable_assign {$$ = new var_defs_t($1);} + | variable_list variable_assign {$$ = $1->add_var_pair($2);} + ; + +variable_assign: + NAME STRING_TOKEN SEMICOLON {$$ = new var_pair_t($1,$2);} + | NAME NAME SEMICOLON {$$ = new var_pair_t($1,$2);} + ; + +select_statement: + SELECT selection table_exp {$$ = $3->add_selection($2);} + ; + +merge_statement: + MERGE column_ref_list + from_clause {$$ = new table_exp_t($2,$3);} + | MERGE column_ref_list SLACK scalar_exp + from_clause {$$ = new table_exp_t($2,$4,$5);} + ; + + /* query expressions */ + + +selection: + select_commalist { $$ = $1;} + ; + +table_exp: + from_clause + opt_where_clause + opt_group_by_clause + opt_supergroup_clause + opt_having_clause + opt_cleaning_when_clause + opt_cleaning_by_clause + opt_closing_when_clause + {$$=new table_exp_t($1,$2,$3,$4,$5,$6,$7, $8);} + ; + +from_clause: + FROM table_ref_commalist {$$ = $2; $$->set_properties(-1);} + | INNER_JOIN FROM table_ref_commalist {$$ = $3; $$->set_properties(INNER_JOIN_PROPERTY);} + | OUTER_JOIN FROM table_ref_commalist {$$ = $3; $$->set_properties(OUTER_JOIN_PROPERTY);} + | RIGHT_OUTER_JOIN FROM table_ref_commalist {$$ = $3; $$->set_properties(RIGHT_OUTER_JOIN_PROPERTY);} + | LEFT_OUTER_JOIN FROM table_ref_commalist {$$ = $3; $$->set_properties(LEFT_OUTER_JOIN_PROPERTY);} + | FILTER_JOIN '(' column_ref ',' INTNUM ')' FROM table_ref_commalist {$$ = $8; $$->set_properties(FILTER_JOIN_PROPERTY); $$->set_colref($3); $$->set_temporal_range($5);} + ; + +table_ref_commalist: + table_ref {$$ = new tablevar_list_t($1);} + | table_ref_commalist ',' table_ref {$$= $1->append_table($3);} + ; + +table_ref: + table { $$ = $1;} + | table NAME { $$= $1->set_range_var($2);} + ; + +table: + qname {$$ = new tablevar_t($1->c_str());} + | NAME '.' qname {$$ = new tablevar_t($1,$3->c_str(),0);} + | NAME '.' NAME '.' qname {$$ = new tablevar_t($1,$3,$5->c_str());} + | STRING_TOKEN '.' NAME '.' qname {$$ = new tablevar_t($1,$3,$5->c_str());} + | '[' NAME ']' '.' qname {$$ = new tablevar_t($2,$5->c_str(),1);} + ; + +qname: + NAME {$$ = new string_t($1);} + | qname '/' NAME {$$ = $$->append("/",$3);} + ; + + +opt_where_clause: + /* empty */ {$$=NULL;} + | where_clause {$$=$1;} + ; + +where_clause: + WHERE search_condition {$$ = $2;} + ; + +opt_cleaning_when_clause: + /* empty */ {$$=NULL;} + | CLEANING_WHEN search_condition {$$=$2; } + ; + +opt_cleaning_by_clause: + /* empty */ {$$=NULL;} + | CLEANING_BY search_condition {$$=$2; } + ; + +opt_closing_when_clause: + /* empty */ {$$=NULL;} + | CLOSING_WHEN search_condition {$$=$2; } + ; + +opt_having_clause: + /* empty */ {$$=NULL;} + | having_clause {$$=$1;} + ; + +having_clause: + HAVING search_condition {$$ = $2;} + ; + + + /* search conditions */ + +search_condition: + search_condition OR search_condition {$$=new predicate_t("OR",$1,$3);} + | search_condition AND search_condition {$$=new predicate_t("AND",$1,$3);} + | NOT search_condition {$$ = new predicate_t("NOT", $2 );} + | '(' search_condition ')' {$$ = $2;} + | predicate {$$ = $1;} + ; + +predicate: + comparison_predicate { $$=$1;} + | in_predicate { $$ = $1;} + | NAME '[' ']' {$$ = predicate_t::make_paramless_fcn_predicate($1); } + | NAME '[' scalar_exp_commalist ']' {$$ = new predicate_t($1, $3->get_se_list()); } + ; + +comparison_predicate: + scalar_exp COMPARISON scalar_exp {$$ = new predicate_t($1,$2,$3);} + ; + +in_predicate: + scalar_exp IN '[' literal_commalist ']' { $$ = new predicate_t($1,$4); } + ; + +literal_commalist: + literal {$$ = new literal_list_t($1);} + | literal_commalist ',' literal {$$ = $1->append_literal($3);} + ; + + /* scalar expressions */ + +scalar_exp: + scalar_exp '+' scalar_exp { $$=new scalarexp_t("+",$1,$3);} + | scalar_exp '-' scalar_exp { $$=new scalarexp_t("-",$1,$3);} + | scalar_exp '|' scalar_exp { $$=new scalarexp_t("|",$1,$3);} + | scalar_exp '*' scalar_exp { $$=new scalarexp_t("*",$1,$3);} + | scalar_exp '/' scalar_exp { $$=new scalarexp_t("/",$1,$3);} + | scalar_exp '&' scalar_exp { $$=new scalarexp_t("&",$1,$3);} + | scalar_exp '%' scalar_exp { $$=new scalarexp_t("%",$1,$3);} + | scalar_exp SHIFT_OP scalar_exp { $$=new scalarexp_t($2,$1,$3);} + | '+' scalar_exp %prec UMINUS { $$ = new scalarexp_t("+",$2);} + | '-' scalar_exp %prec UMINUS { $$ = new scalarexp_t("-",$2);} + | '!' scalar_exp %prec UMINUS { $$ = new scalarexp_t("!",$2);} + | '~' scalar_exp %prec UMINUS { $$ = new scalarexp_t("~",$2);} + | literal { $$= new scalarexp_t($1);} + | '$' NAME {$$ = scalarexp_t::make_param_reference($2);} + | ifparam {$$ = scalarexp_t::make_iface_param_reference($1);} + | column_ref { $$ = new scalarexp_t($1);} + | '(' scalar_exp ')' {$$ = $2;} + | AGGR '(' '*' ')' { $$ = scalarexp_t::make_star_aggr($1); } + | AGGR '(' scalar_exp ')' { $$ = scalarexp_t::make_se_aggr($1,$3); } + | NAME '(' scalar_exp_commalist ')' {$$ = new scalarexp_t($1, $3->get_se_list()); } + | NAME '(' ')' {$$ = scalarexp_t::make_paramless_fcn($1); } + | AGGR '$' '(' '*' ')' { $$ = scalarexp_t::make_star_aggr($1); $$->set_superaggr(true); } + | AGGR '$' '(' scalar_exp ')' { $$ = scalarexp_t::make_se_aggr($1,$4); $$->set_superaggr(true); } + | NAME '$' '(' scalar_exp_commalist ')' {$$ = new scalarexp_t($1, $4->get_se_list()); $$->set_superaggr(true); } + | NAME '$' '(' ')' {$$ = scalarexp_t::make_paramless_fcn($1); $$->set_superaggr(true); } + ; + + +select_commalist: + scalar_exp { $$= new select_list_t($1); } + | scalar_exp AS NAME { $$= new select_list_t($1,$3); } + | select_commalist ',' scalar_exp { $$=$1->append($3); } + | select_commalist ',' scalar_exp AS NAME { $$=$1->append($3,$5); } + ; + +scalar_exp_commalist: + scalar_exp { $$= new se_list_t($1); } + | scalar_exp_commalist ',' scalar_exp { $$=$1->append($3); } + ; + +literal: + STRING_TOKEN {$$ = new literal_t($1,LITERAL_STRING);} + | INTNUM {$$ = new literal_t($1,LITERAL_INT);} + | LONGINTNUM {$$ = new literal_t($1,LITERAL_LONGINT);} + | APPROXNUM {$$ = new literal_t($1,LITERAL_FLOAT);} + | TRUE_V {$$ = new literal_t("TRUE",LITERAL_BOOL);} + | FALSE_V {$$ = new literal_t("FALSE",LITERAL_BOOL);} + | TIMEVAL_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_TIMEVAL);} + | HEX_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_HEX);} + | LHEX_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_LONGHEX);} + | IP_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_IP);} + | IPV6_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_IPV6);} + | '#' NAME {$$ = literal_t::make_define_literal($2,fta_parse_defines);} + ; + + + +opt_group_by_clause: + /* empty */ {$$ = NULL;} + | GROUP BY extended_gb_commalist {$$ = $3;} + ; + +opt_supergroup_clause: + /* empty */ {$$ = NULL;} + | SUPERGROUP gb_ref_list {$$ = $2;} + ; + +list_of_gb_commalist: + '(' gb_commalist ')' { $$ = new list_of_gb_list_t($2);} + | list_of_gb_commalist ',' '(' gb_commalist ')' {$$ = $1->append($4);} + ; + +extended_gb: + gb {$$ = extended_gb_t::create_from_gb($1);} + | ROLLUP '(' gb_commalist ')' {$$ = extended_gb_t::extended_create_from_rollup($3);} + | CUBE '(' gb_commalist ')' {$$ = extended_gb_t::extended_create_from_cube($3);} + | GROUPING_SETS '(' list_of_gb_commalist ')' {$$ = extended_gb_t::extended_create_from_gsets($3);} + ; + +extended_gb_commalist: + extended_gb { $$ = new extended_gb_list_t($1);} + | extended_gb_commalist ',' extended_gb { $$=$1->append($3);} + ; + +gb_commalist: + gb { $$ = new gb_list_t($1);} + | gb_commalist ',' gb { $$=$1->append($3);} + ; + +gb: + NAME {$$ = new gb_t($1); } + | NAME '.' NAME {$$ = new gb_t($1,$3); } + | NAME '.' NAME '.' NAME {$$ = new gb_t($1,$3,$5); } + | scalar_exp AS NAME {$$ = new gb_t($1,$3); } + ; + + /* miscellaneous */ + + +/* + I do not currently use 3 part column refs +*/ + +ifparam: + '@' NAME {$$ = new ifpref_t($2);} + | NAME '.' '@' NAME {$$ = new ifpref_t($1, $4);} + ; + +column_ref: + NAME {$$ = new colref_t($1); } + | NAME '.' NAME {$$ = new colref_t($1,$3); } + | NAME '.' NAME '.' NAME {$$ = new colref_t($1,$3,$5); } + ; + +column_ref_list: + column_ref ':' column_ref {$$=new colref_list_t($1); $$->append($3);} + | column_ref_list ':' column_ref {$$ = $1->append($3);} + ; + +gb_ref: + NAME {$$ = new colref_t($1); } + ; + +gb_ref_list: + gb_ref ',' gb_ref {$$=new colref_list_t($1); $$->append($3);} + | gb_ref_list ',' gb_ref {$$ = $1->append($3);} + ; + + /* data types */ + + + /* the various things you can name */ + + + + + +/* Table definition section */ + + +table_list: table_def {$$ = new table_list($1);} + | table_list table_def {$$ = $1->append_table($2);} + ; + +table_def: PROTOCOL NAME opt_singleparam_commalist opt_singleparam_commalist_bkt LEFTBRACE field_list RIGHTBRACE { + $$=new table_def($2,$3,$4, $6, PROTOCOL_SCHEMA); delete $6;} + | STREAM qname opt_singleparam_commalist LEFTBRACE field_list RIGHTBRACE { + $$=new table_def($2->c_str(),$3,NULL,$5, STREAM_SCHEMA); delete $5;} + | OPERATOR_VIEW NAME LEFTBRACE OPERATOR opt_param_commalist FIELDS LEFTBRACE field_list RIGHTBRACE SUBQUERIES LEFTBRACE subqueryspec_list RIGHTBRACE SELECTION_PUSHDOWN opt_param_commalist RIGHTBRACE { + $$ = new table_def($2, $5, $8, $12, $15); } + | UNPACK_FCNS LEFTBRACE unpack_func_list RIGHTBRACE { $$ = new table_def($3); } + ; + +unpack_func_list: + unpack_func {$$ = new unpack_fcn_list($1);} + | unpack_func_list SEMICOLON unpack_func {$$ = $1 -> append($3);} + ; + +unpack_func: + NAME NAME INTNUM {$$ = new unpack_fcn($1,$2,$3);} + ; + +subqueryspec_list: + subq_spec {$$ = new subqueryspec_list($1);} + | subqueryspec_list SEMICOLON subq_spec {$$ = $1->append($3);} + ; + +subq_spec: + NAME '(' namevec_commalist ')' {$$=new subquery_spec($1, $3); delete $3;} + ; + +field_list: field {$$ = new field_entry_list($1);} + | field_list field {$$ = $1->append_field($2);} + ; + +field: + NAME NAME NAME opt_param_commalist opt_singleparam_commalist_bkt SEMICOLON {$$ = new field_entry($1,$2,$3,$4,$5);} + | NAME NAME opt_param_commalist SEMICOLON {$$ = new field_entry($1,$2,"",$3,NULL);} + ; + +opt_param_commalist: + /* empty */ {$$ = NULL;} + | '(' param_commalist ')' {$$ = $2;} + ; + +param_commalist: + NAME {$$ = new param_list($1);} + | NAME NAME {$$ = new param_list($1,$2);} + | NAME STRING_TOKEN {$$ = new param_list($1,$2);} + | NAME INTNUM {$$ = new param_list($1,$2);} + | param_commalist ',' NAME {$$ = $1->append($3);} + | param_commalist ',' NAME NAME {$$ = $1->append($3,$4);} + | param_commalist ',' NAME STRING_TOKEN {$$ = $1->append($3,$4);} + | param_commalist ',' NAME INTNUM {$$ = $1->append($3,$4);} + ; + +opt_singleparam_commalist_bkt: + /* empty */ {$$ = NULL;} + | '[' singleparam_commalist ']' {$$ = $2;} + ; + +opt_singleparam_commalist: + /* empty */ {$$ = NULL;} + | '(' singleparam_commalist ')' {$$ = $2;} + ; + +singleparam_commalist: + NAME {$$ = new param_list($1);} + | singleparam_commalist ',' NAME {$$ = $1->append($3);} + ; + +namevec_commalist: + NAME NAME opt_param_commalist {$$ = new name_vec($1,$2,$3);} + | namevec_commalist ',' NAME NAME opt_param_commalist {$$ = $1->append($3,$4, $5);} + ; + +%% + diff --git a/src/ftacmp/ftalexer.cc b/src/ftacmp/ftalexer.cc new file mode 100644 index 0000000..0b40c39 --- /dev/null +++ b/src/ftacmp/ftalexer.cc @@ -0,0 +1,2505 @@ +#define yy_create_buffer FtaParser_create_buffer +#define yy_delete_buffer FtaParser_delete_buffer +#define yy_scan_buffer FtaParser_scan_buffer +#define yy_scan_string FtaParser_scan_string +#define yy_scan_bytes FtaParser_scan_bytes +#define yy_flex_debug FtaParser_flex_debug +#define yy_init_buffer FtaParser_init_buffer +#define yy_flush_buffer FtaParser_flush_buffer +#define yy_load_buffer_state FtaParser_load_buffer_state +#define yy_switch_to_buffer FtaParser_switch_to_buffer +#define yyin FtaParserin +#define yyleng FtaParserleng +#define yylex FtaParserlex +#define yyout FtaParserout +#define yyrestart FtaParserrestart +#define yytext FtaParsertext + +#line 19 "ftalexer.cc" +/* A lexical scanner generated by flex*/ + +/* Scanner skeleton version: + * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* Some routines like yy_flex_realloc() are emitted as static but are + not called by all lexers. This generates warnings in some compilers, + notably GCC. Arrange to suppress these. */ +#ifdef __GNUC__ +#define YY_MAY_BE_UNUSED __attribute__((unused)) +#else +#define YY_MAY_BE_UNUSED +#endif + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED; +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yytext_ptr -= yy_more_len; \ + yyleng = (int) (yy_cp - yytext_ptr); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 85 +#define YY_END_OF_BUFFER 86 +static yyconst short int yy_accept[655] = + { 0, + 0, 0, 86, 84, 81, 80, 66, 84, 67, 66, + 66, 70, 57, 62, 60, 63, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 45, 46, 68, 81, 80, 0, 79, 78, + 0, 74, 0, 0, 73, 70, 0, 0, 58, 64, + 61, 65, 59, 69, 69, 26, 69, 69, 69, 10, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 27, 69, + + 27, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 29, 69, 29, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 27, 69, + 69, 69, 69, 69, 29, 69, 69, 69, 69, 69, + 69, 69, 69, 0, 82, 0, 77, 0, 83, 73, + 0, 0, 75, 71, 1, 5, 1, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 50, 69, 69, 69, 69, 69, 39, 69, 69, 69, + + 69, 69, 69, 69, 69, 69, 7, 69, 6, 69, + 28, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 8, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 1, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 0, 76, 72, 69, 69, 69, + 69, 69, 19, 69, 69, 69, 69, 69, 69, 69, + 11, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 40, 69, 69, 69, 69, 69, 69, 69, + + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 32, 69, 69, 69, 69, 33, 69, 36, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 9, 69, 69, 69, + 37, 69, 69, 69, 17, 17, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 34, 69, 69, 69, 69, + 69, 44, 69, 69, 69, 69, 69, 69, 35, 69, + 69, 69, 69, 69, 47, 69, 69, 31, 69, 69, + 69, 69, 69, 69, 17, 69, 69, 69, 69, 69, + + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 43, 54, 69, 69, 69, 69, 25, 69, 69, + 41, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 18, 69, 30, 49, 69, 69, 30, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 3, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 38, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 2, 69, + + 69, 69, 69, 69, 69, 69, 69, 69, 42, 69, + 69, 69, 52, 69, 69, 48, 69, 69, 69, 69, + 69, 69, 69, 4, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 12, 69, 69, 69, 13, 69, + 69, 69, 55, 21, 69, 69, 69, 69, 69, 69, + 69, 69, 23, 69, 69, 69, 69, 16, 69, 69, + + 69, 69, 69, 69, 69, 69, 51, 69, 69, 69, + 69, 69, 69, 24, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 69, 69, 69, 22, 20, 69, + 69, 53, 69, 69, 69, 69, 69, 69, 69, 69, + 69, 69, 69, 69, 15, 69, 69, 69, 69, 14, + 69, 69, 56, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 1, 4, 4, 4, 4, 5, 4, + 4, 4, 6, 4, 7, 8, 9, 10, 10, 10, + 10, 10, 10, 11, 10, 10, 10, 4, 12, 13, + 14, 15, 1, 4, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 4, 1, 4, 1, 42, 1, 43, 44, 45, 46, + + 47, 48, 49, 50, 51, 52, 41, 53, 54, 55, + 56, 57, 41, 58, 59, 60, 61, 62, 63, 64, + 65, 41, 66, 4, 67, 68, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[69] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 3, + 3, 1, 1, 1, 1, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 1, 1, 1 + } ; + +static yyconst short int yy_base[660] = + { 0, + 0, 0, 777, 778, 774, 0, 778, 66, 768, 62, + 765, 66, 778, 65, 778, 69, 56, 30, 61, 753, + 0, 65, 54, 76, 70, 83, 104, 75, 96, 88, + 109, 114, 119, 743, 87, 106, 104, 706, 92, 113, + 712, 726, 713, 720, 125, 710, 109, 122, 47, 715, + 714, 707, 778, 778, 778, 760, 0, 135, 778, 778, + 758, 169, 175, 757, 173, 186, 181, 732, 778, 778, + 778, 778, 778, 0, 739, 0, 735, 710, 706, 0, + 126, 718, 736, 143, 691, 707, 729, 722, 175, 718, + 731, 693, 689, 714, 687, 705, 702, 678, 710, 161, + + 683, 716, 716, 687, 695, 700, 703, 667, 672, 674, + 693, 667, 706, 683, 689, 681, 662, 688, 690, 697, + 691, 668, 663, 688, 698, 680, 183, 659, 164, 694, + 694, 681, 672, 664, 675, 685, 657, 670, 644, 655, + 651, 157, 638, 654, 644, 640, 639, 632, 638, 644, + 627, 632, 634, 628, 645, 626, 636, 631, 630, 170, + 639, 634, 622, 676, 778, 197, 215, 675, 778, 218, + 224, 226, 229, 650, 634, 0, 633, 658, 639, 643, + 651, 627, 610, 613, 620, 642, 631, 637, 628, 634, + 0, 601, 606, 623, 597, 633, 0, 605, 635, 643, + + 616, 641, 604, 615, 610, 588, 0, 625, 0, 597, + 0, 612, 628, 623, 626, 594, 624, 604, 615, 610, + 586, 582, 614, 615, 612, 599, 607, 0, 609, 581, + 577, 579, 598, 589, 603, 602, 561, 604, 586, 560, + 575, 574, 573, 571, 554, 557, 564, 550, 555, 547, + 556, 559, 545, 555, 560, 555, 551, 547, 552, 548, + 550, 536, 537, 552, 231, 233, 778, 577, 576, 562, + 566, 554, 0, 533, 536, 526, 556, 564, 564, 562, + 0, 534, 549, 522, 549, 522, 543, 533, 558, 531, + 514, 529, 0, 528, 549, 521, 551, 544, 532, 515, + + 505, 534, 531, 525, 523, 498, 496, 538, 529, 538, + 517, 0, 519, 506, 492, 529, 0, 511, 0, 529, + 526, 498, 528, 527, 499, 486, 489, 479, 491, 480, + 481, 477, 492, 486, 483, 473, 470, 468, 483, 469, + 479, 482, 502, 474, 498, 492, 0, 469, 464, 498, + 0, 483, 483, 457, 490, 462, 490, 462, 468, 472, + 481, 470, 464, 475, 474, 0, 468, 480, 459, 451, + 457, 0, 480, 455, 465, 453, 437, 458, 0, 464, + 471, 468, 429, 439, 0, 471, 460, 0, 463, 435, + 434, 431, 426, 422, 428, 429, 435, 420, 426, 432, + + 431, 415, 411, 421, 420, 446, 418, 437, 443, 409, + 414, 0, 0, 420, 419, 431, 404, 0, 433, 441, + 0, 440, 430, 418, 392, 422, 418, 425, 391, 423, + 417, 416, 0, 415, 420, 0, 410, 409, 0, 383, + 413, 397, 416, 388, 387, 380, 385, 391, 377, 379, + 369, 371, 376, 371, 368, 376, 391, 365, 400, 379, + 371, 377, 393, 392, 394, 366, 384, 386, 385, 355, + 375, 349, 375, 0, 377, 350, 378, 368, 342, 372, + 377, 370, 343, 0, 377, 364, 338, 337, 345, 351, + 340, 342, 334, 329, 332, 326, 330, 327, 0, 342, + + 345, 340, 343, 350, 323, 336, 335, 352, 0, 324, + 354, 326, 330, 347, 319, 0, 334, 308, 338, 346, + 329, 303, 345, 0, 320, 298, 304, 317, 307, 310, + 305, 295, 293, 215, 330, 228, 302, 327, 299, 315, + 314, 318, 291, 312, 286, 306, 313, 286, 320, 292, + 296, 303, 305, 278, 305, 63, 283, 281, 272, 275, + 271, 273, 280, 269, 285, 301, 303, 257, 271, 273, + 290, 263, 297, 269, 0, 273, 272, 289, 0, 279, + 253, 279, 0, 0, 275, 243, 257, 259, 250, 257, + 261, 244, 0, 281, 271, 252, 243, 0, 262, 236, + + 270, 269, 273, 250, 249, 254, 0, 242, 233, 227, + 234, 243, 255, 0, 228, 248, 222, 250, 223, 37, + 119, 133, 140, 122, 146, 154, 160, 0, 0, 193, + 168, 0, 216, 191, 225, 198, 194, 222, 197, 230, + 204, 237, 202, 207, 0, 230, 205, 231, 207, 0, + 225, 235, 0, 778, 266, 269, 265, 272, 275 + } ; + +static yyconst short int yy_def[660] = + { 0, + 654, 1, 654, 654, 654, 655, 654, 656, 654, 654, + 654, 654, 654, 654, 654, 654, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 654, 654, 654, 654, 655, 656, 654, 654, + 658, 654, 654, 659, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 658, 654, 654, 654, 659, 654, 654, + 654, 654, 654, 654, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 654, 654, 654, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 657, 657, 657, 657, 657, 657, 657, + 657, 657, 657, 0, 654, 654, 654, 654, 654 + } ; + +static yyconst short int yy_nxt[847] = + { 0, + 4, 5, 6, 7, 8, 7, 9, 10, 11, 12, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 21, 21, 26, 27, 28, 29, + 30, 21, 31, 32, 33, 34, 21, 35, 36, 21, + 21, 21, 37, 38, 39, 21, 21, 40, 41, 42, + 43, 21, 44, 45, 46, 47, 21, 48, 49, 50, + 21, 21, 51, 52, 21, 53, 54, 55, 59, 80, + 60, 62, 62, 65, 632, 66, 66, 69, 70, 71, + 88, 63, 72, 73, 75, 67, 94, 81, 89, 76, + 82, 96, 77, 159, 80, 97, 83, 90, 99, 91, + + 100, 68, 102, 118, 111, 103, 586, 160, 63, 136, + 78, 95, 67, 84, 76, 92, 85, 79, 98, 105, + 119, 86, 93, 106, 101, 587, 113, 107, 114, 104, + 112, 115, 120, 124, 130, 138, 137, 59, 121, 60, + 125, 131, 132, 633, 142, 178, 108, 143, 126, 127, + 109, 133, 144, 116, 110, 179, 117, 634, 140, 122, + 128, 139, 76, 145, 123, 141, 155, 151, 134, 156, + 146, 152, 157, 635, 129, 153, 628, 158, 62, 62, + 166, 166, 170, 170, 167, 167, 172, 172, 63, 182, + 173, 173, 171, 65, 188, 66, 66, 200, 183, 226, + + 227, 189, 201, 244, 629, 67, 167, 167, 231, 636, + 228, 637, 245, 229, 260, 63, 638, 228, 639, 171, + 232, 68, 202, 228, 167, 167, 261, 170, 170, 265, + 265, 565, 67, 266, 266, 173, 173, 171, 173, 173, + 266, 266, 266, 266, 568, 640, 641, 642, 643, 644, + 645, 645, 566, 646, 647, 648, 645, 649, 650, 650, + 651, 650, 652, 653, 171, 569, 57, 74, 57, 58, + 58, 58, 164, 164, 164, 168, 168, 168, 631, 630, + 629, 629, 628, 628, 627, 626, 625, 614, 624, 623, + 622, 621, 620, 619, 618, 617, 616, 614, 615, 614, + + 613, 612, 611, 610, 598, 609, 608, 593, 607, 606, + 605, 604, 603, 602, 601, 600, 599, 598, 598, 597, + 596, 593, 595, 594, 593, 584, 592, 579, 591, 575, + 590, 589, 588, 585, 584, 584, 583, 582, 581, 580, + 579, 579, 578, 577, 576, 575, 575, 574, 573, 572, + 571, 570, 567, 564, 563, 562, 561, 560, 559, 558, + 557, 556, 555, 554, 553, 552, 551, 550, 549, 548, + 547, 546, 545, 544, 543, 542, 541, 540, 539, 538, + 537, 536, 535, 534, 524, 533, 532, 531, 530, 529, + 528, 527, 526, 525, 499, 524, 524, 523, 522, 521, + + 520, 519, 518, 517, 516, 515, 514, 513, 512, 511, + 510, 509, 509, 508, 507, 506, 505, 504, 503, 502, + 501, 500, 499, 499, 498, 497, 496, 495, 474, 494, + 493, 492, 491, 490, 489, 488, 487, 486, 485, 484, + 483, 482, 481, 480, 479, 478, 477, 476, 474, 475, + 474, 473, 472, 471, 470, 469, 468, 467, 466, 465, + 464, 463, 462, 461, 460, 459, 458, 457, 456, 455, + 439, 433, 454, 453, 452, 451, 450, 418, 449, 448, + 447, 446, 445, 444, 443, 442, 441, 440, 439, 438, + 437, 436, 435, 433, 434, 433, 432, 431, 430, 429, + + 428, 427, 426, 425, 424, 423, 422, 421, 420, 419, + 418, 418, 417, 416, 415, 414, 413, 412, 411, 410, + 409, 408, 407, 406, 405, 388, 404, 403, 402, 401, + 400, 399, 366, 398, 397, 396, 395, 394, 347, 393, + 392, 391, 390, 389, 388, 388, 387, 386, 385, 384, + 383, 382, 381, 380, 379, 378, 377, 376, 375, 374, + 373, 372, 371, 370, 369, 368, 367, 366, 366, 365, + 364, 363, 362, 361, 360, 359, 358, 357, 356, 355, + 354, 353, 352, 351, 350, 347, 349, 348, 347, 346, + 345, 344, 343, 342, 341, 317, 340, 312, 339, 338, + + 337, 336, 335, 334, 333, 332, 331, 330, 281, 329, + 273, 328, 327, 326, 325, 324, 323, 322, 321, 320, + 317, 319, 318, 317, 316, 315, 312, 314, 313, 312, + 311, 310, 309, 308, 307, 306, 305, 304, 303, 302, + 301, 300, 299, 298, 297, 296, 295, 294, 293, 292, + 291, 290, 289, 288, 287, 286, 285, 284, 283, 281, + 282, 281, 280, 279, 278, 277, 273, 276, 275, 274, + 273, 272, 271, 270, 269, 268, 267, 169, 165, 264, + 263, 262, 259, 258, 257, 256, 255, 211, 209, 254, + 207, 253, 252, 251, 250, 249, 248, 247, 246, 176, + + 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, + 233, 230, 225, 224, 223, 222, 221, 220, 219, 218, + 217, 216, 215, 214, 213, 212, 211, 211, 209, 210, + 207, 209, 208, 207, 206, 205, 204, 203, 199, 198, + 197, 196, 195, 194, 193, 192, 191, 190, 187, 186, + 185, 184, 181, 180, 176, 177, 176, 175, 174, 169, + 165, 56, 163, 162, 161, 154, 150, 149, 148, 147, + 80, 135, 87, 64, 61, 56, 654, 3, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654 + } ; + +static yyconst short int yy_chk[847] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 8, 18, + 8, 10, 10, 12, 620, 12, 12, 14, 14, 14, + 22, 10, 16, 16, 17, 12, 23, 19, 22, 17, + 19, 24, 17, 49, 18, 24, 19, 22, 25, 22, + + 25, 12, 26, 30, 28, 26, 556, 49, 10, 35, + 17, 23, 12, 19, 17, 22, 19, 17, 24, 27, + 30, 19, 22, 27, 25, 556, 29, 27, 29, 26, + 28, 29, 31, 32, 33, 36, 35, 58, 31, 58, + 32, 33, 33, 621, 39, 81, 27, 39, 32, 32, + 27, 33, 39, 29, 27, 81, 29, 622, 37, 31, + 32, 36, 37, 40, 31, 37, 47, 45, 33, 47, + 40, 45, 48, 623, 32, 45, 624, 48, 62, 62, + 63, 63, 65, 65, 63, 63, 67, 67, 62, 84, + 67, 67, 65, 66, 89, 66, 66, 100, 84, 127, + + 127, 89, 100, 142, 625, 66, 166, 166, 129, 626, + 127, 627, 142, 127, 160, 62, 630, 129, 631, 65, + 129, 66, 100, 160, 167, 167, 160, 170, 170, 171, + 171, 534, 66, 171, 171, 172, 172, 170, 173, 173, + 265, 265, 266, 266, 536, 633, 634, 635, 636, 637, + 638, 639, 534, 640, 641, 642, 643, 644, 646, 647, + 648, 649, 651, 652, 170, 536, 655, 657, 655, 656, + 656, 656, 658, 658, 658, 659, 659, 659, 619, 618, + 617, 616, 615, 613, 612, 611, 610, 609, 608, 606, + 605, 604, 603, 602, 601, 600, 599, 597, 596, 595, + + 594, 592, 591, 590, 589, 588, 587, 586, 585, 582, + 581, 580, 578, 577, 576, 574, 573, 572, 571, 570, + 569, 568, 567, 566, 565, 564, 563, 562, 561, 560, + 559, 558, 557, 555, 554, 553, 552, 551, 550, 549, + 548, 547, 546, 545, 544, 543, 542, 541, 540, 539, + 538, 537, 535, 533, 532, 531, 530, 529, 528, 527, + 526, 525, 523, 522, 521, 520, 519, 518, 517, 515, + 514, 513, 512, 511, 510, 508, 507, 506, 505, 504, + 503, 502, 501, 500, 498, 497, 496, 495, 494, 493, + 492, 491, 490, 489, 488, 487, 486, 485, 483, 482, + + 481, 480, 479, 478, 477, 476, 475, 473, 472, 471, + 470, 469, 468, 467, 466, 465, 464, 463, 462, 461, + 460, 459, 458, 457, 456, 455, 454, 453, 452, 451, + 450, 449, 448, 447, 446, 445, 444, 443, 442, 441, + 440, 438, 437, 435, 434, 432, 431, 430, 429, 428, + 427, 426, 425, 424, 423, 422, 420, 419, 417, 416, + 415, 414, 411, 410, 409, 408, 407, 406, 405, 404, + 403, 402, 401, 400, 399, 398, 397, 396, 395, 394, + 393, 392, 391, 390, 389, 387, 386, 384, 383, 382, + 381, 380, 378, 377, 376, 375, 374, 373, 371, 370, + + 369, 368, 367, 365, 364, 363, 362, 361, 360, 359, + 358, 357, 356, 355, 354, 353, 352, 350, 349, 348, + 346, 345, 344, 343, 342, 341, 340, 339, 338, 337, + 336, 335, 334, 333, 332, 331, 330, 329, 328, 327, + 326, 325, 324, 323, 322, 321, 320, 318, 316, 315, + 314, 313, 311, 310, 309, 308, 307, 306, 305, 304, + 303, 302, 301, 300, 299, 298, 297, 296, 295, 294, + 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, + 282, 280, 279, 278, 277, 276, 275, 274, 272, 271, + 270, 269, 268, 264, 263, 262, 261, 260, 259, 258, + + 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, + 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, + 237, 236, 235, 234, 233, 232, 231, 230, 229, 227, + 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, + 216, 215, 214, 213, 212, 210, 208, 206, 205, 204, + 203, 202, 201, 200, 199, 198, 196, 195, 194, 193, + 192, 190, 189, 188, 187, 186, 185, 184, 183, 182, + 181, 180, 179, 178, 177, 175, 174, 168, 164, 163, + 162, 161, 159, 158, 157, 156, 155, 154, 153, 152, + 151, 150, 149, 148, 147, 146, 145, 144, 143, 141, + + 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, + 130, 128, 126, 125, 124, 123, 122, 121, 120, 119, + 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, + 108, 107, 106, 105, 104, 103, 102, 101, 99, 98, + 97, 96, 95, 94, 93, 92, 91, 90, 88, 87, + 86, 85, 83, 82, 79, 78, 77, 75, 68, 64, + 61, 56, 52, 51, 50, 46, 44, 43, 42, 41, + 38, 34, 20, 11, 9, 5, 3, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654, 654, 654, 654, 654, + 654, 654, 654, 654, 654, 654 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() (yy_more_flag = 1) +#define YY_MORE_ADJ yy_more_len +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "fta.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PFtaParser -oftalexer.cc fta.l + (or equivalent). +*/ +#line 9 "fta.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_fta.h" + #include "parse_schema.h" + #include + + + +#include "fta.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int FtaParserwrap(){return(1);} + +extern int FtaParserdebug; + + +/* + These variables are used for error reporting: + flex_fta_lineno : the line currently being parsed when the error occurs. + flex_fta_ch : the character on the line where the error occurs + flex_fta_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_fta_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_fta_lineno = 1; +int flex_fta_ch = 0; +char flex_fta_linebuf[200000]; + +char *flex_fta_stringinput = NULL; +int flex_fta_stringinput_ptr = 0; +FILE *flex_fta_fileinput = NULL; +int my_FtaParser_yyinput(char *buf, int max_size); + + + +void FtaParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_fta_lineno, flex_fta_ch, s, FtaParsertext, flex_fta_linebuf ); + for(i=0;i +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 89 "fta.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + +#line 1051 "ftalexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + if ( yy_more_flag ) + { + yy_more_len = yy_c_buf_p - yytext_ptr; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 655 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 778 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 107 "fta.l" +{ flex_fta_ch+=FtaParserleng; return AND; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 108 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("AND_AGGR"); return AGGR; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 109 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("OR_AGGR"); return AGGR; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 110 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("XOR_AGGR"); return AGGR; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 111 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("AVG"); return AGGR; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 112 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("MIN"); return AGGR; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 113 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("MAX"); return AGGR; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 114 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("SUM"); return AGGR; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 115 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("COUNT"); return AGGR; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 116 "fta.l" +{ flex_fta_ch+=FtaParserleng; return BY; } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 117 "fta.l" +{ flex_fta_ch+=FtaParserleng; return FROM; } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 118 "fta.l" +{ flex_fta_ch+=FtaParserleng; return INNER_JOIN; } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 119 "fta.l" +{ flex_fta_ch+=FtaParserleng; return OUTER_JOIN; } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 120 "fta.l" +{ flex_fta_ch+=FtaParserleng; return RIGHT_OUTER_JOIN; } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 121 "fta.l" +{ flex_fta_ch+=FtaParserleng; return LEFT_OUTER_JOIN; } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 122 "fta.l" +{ flex_fta_ch+=FtaParserleng; return FILTER_JOIN; } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 123 "fta.l" +{ flex_fta_ch+=FtaParserleng; return GROUP; } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 124 "fta.l" +{ flex_fta_ch+=FtaParserleng; return ROLLUP; } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 125 "fta.l" +{ flex_fta_ch+=FtaParserleng; return CUBE; } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 126 "fta.l" +{ flex_fta_ch+=FtaParserleng; return GROUPING_SETS; } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 127 "fta.l" +{ flex_fta_ch+=FtaParserleng; return SUPERGROUP; } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 128 "fta.l" +{ flex_fta_ch+=FtaParserleng; return CLEANING_WHEN; } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 129 "fta.l" +{ flex_fta_ch+=FtaParserleng; return CLEANING_BY; } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 130 "fta.l" +{ flex_fta_ch+=FtaParserleng; return CLOSING_WHEN; } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 131 "fta.l" +{ flex_fta_ch+=FtaParserleng; return HAVING; } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 132 "fta.l" +{ flex_fta_ch+=FtaParserleng; return AS; } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 133 "fta.l" +{ flex_fta_ch+=FtaParserleng; return IN; } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 134 "fta.l" +{ flex_fta_ch+=FtaParserleng; return NOT; } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 135 "fta.l" +{ flex_fta_ch+=FtaParserleng; return OR; } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 137 "fta.l" +{ flex_fta_ch+=FtaParserleng; return SELECT; } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 138 "fta.l" +{ flex_fta_ch+=FtaParserleng; return WHERE; } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 139 "fta.l" +{ flex_fta_ch+=FtaParserleng; return SUCH;} + YY_BREAK +case 33: +YY_RULE_SETUP +#line 140 "fta.l" +{ flex_fta_ch+=FtaParserleng; return THAT;} + YY_BREAK +case 34: +YY_RULE_SETUP +#line 141 "fta.l" +{flex_fta_ch+=FtaParserleng; return MERGE;} + YY_BREAK +case 35: +YY_RULE_SETUP +#line 142 "fta.l" +{flex_fta_ch+=FtaParserleng; return SLACK;} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 144 "fta.l" +{ flex_fta_ch+=FtaParserleng; return TRUE_V;} + YY_BREAK +case 37: +YY_RULE_SETUP +#line 145 "fta.l" +{ flex_fta_ch+=FtaParserleng; return FALSE_V;} + YY_BREAK +case 38: +YY_RULE_SETUP +#line 146 "fta.l" +{ flex_fta_ch+=FtaParserleng; return TIMEVAL_L;} + YY_BREAK +case 39: +YY_RULE_SETUP +#line 147 "fta.l" +{ flex_fta_ch+=FtaParserleng; return HEX_L;} + YY_BREAK +case 40: +YY_RULE_SETUP +#line 148 "fta.l" +{ flex_fta_ch+=FtaParserleng; return LHEX_L;} + YY_BREAK +case 41: +YY_RULE_SETUP +#line 149 "fta.l" +{ flex_fta_ch+=FtaParserleng; return IP_L;} + YY_BREAK +case 42: +YY_RULE_SETUP +#line 150 "fta.l" +{ flex_fta_ch+=FtaParserleng; return IPV6_L;} + YY_BREAK +case 43: +YY_RULE_SETUP +#line 152 "fta.l" +{ flex_fta_ch+=FtaParserleng; return DEFINE_SEC;} + YY_BREAK +case 44: +YY_RULE_SETUP +#line 153 "fta.l" +{ flex_fta_ch+=FtaParserleng; return PARAM_SEC;} + YY_BREAK +case 45: +YY_RULE_SETUP +#line 155 "fta.l" +{flex_fta_ch+=FtaParserleng; return LEFTBRACE;} + YY_BREAK +case 46: +YY_RULE_SETUP +#line 156 "fta.l" +{flex_fta_ch+=FtaParserleng; return RIGHTBRACE;} + YY_BREAK +/* + Table definition keywords + */ +case 47: +YY_RULE_SETUP +#line 161 "fta.l" +{ flex_fta_ch+=FtaParserleng; return TABLE; } + YY_BREAK +case 48: +YY_RULE_SETUP +#line 162 "fta.l" +{ flex_fta_ch+=FtaParserleng; return PROTOCOL; } + YY_BREAK +case 49: +YY_RULE_SETUP +#line 163 "fta.l" +{ flex_fta_ch+=FtaParserleng; return STREAM; } + YY_BREAK +case 50: +YY_RULE_SETUP +#line 164 "fta.l" +{ flex_fta_ch+=FtaParserleng; return FTA; } + YY_BREAK +case 51: +YY_RULE_SETUP +#line 165 "fta.l" +{ flex_fta_ch+=FtaParserleng; return UNPACK_FCNS; } + YY_BREAK +case 52: +YY_RULE_SETUP +#line 167 "fta.l" +{ flex_fta_ch+=FtaParserleng; return OPERATOR; } + YY_BREAK +case 53: +YY_RULE_SETUP +#line 168 "fta.l" +{ flex_fta_ch+=FtaParserleng; return OPERATOR_VIEW; } + YY_BREAK +case 54: +YY_RULE_SETUP +#line 169 "fta.l" +{ flex_fta_ch+=FtaParserleng; return FIELDS; } + YY_BREAK +case 55: +YY_RULE_SETUP +#line 170 "fta.l" +{ flex_fta_ch+=FtaParserleng; return SUBQUERIES; } + YY_BREAK +case 56: +YY_RULE_SETUP +#line 171 "fta.l" +{ flex_fta_ch+=FtaParserleng; return SELECTION_PUSHDOWN; } + YY_BREAK +case 57: +YY_RULE_SETUP +#line 172 "fta.l" +{flex_fta_ch+=FtaParserleng; return SEMICOLON;} + YY_BREAK +/* punctuation */ +case 58: +#line 177 "fta.l" +case 59: +YY_RULE_SETUP +#line 177 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return SHIFT_OP; } + YY_BREAK +case 60: +#line 180 "fta.l" +case 61: +#line 181 "fta.l" +case 62: +#line 182 "fta.l" +case 63: +#line 183 "fta.l" +case 64: +#line 184 "fta.l" +case 65: +YY_RULE_SETUP +#line 184 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return COMPARISON; } + YY_BREAK +case 66: +YY_RULE_SETUP +#line 186 "fta.l" +{ flex_fta_ch+=FtaParserleng; return yytext[0]; } + YY_BREAK +case 67: +YY_RULE_SETUP +#line 187 "fta.l" +{ flex_fta_ch+=FtaParserleng; return yytext[0]; } + YY_BREAK +case 68: +YY_RULE_SETUP +#line 188 "fta.l" +{ flex_fta_ch+=FtaParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 69: +YY_RULE_SETUP +#line 192 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* numbers */ +case 70: +#line 197 "fta.l" +case 71: +YY_RULE_SETUP +#line 197 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return INTNUM; } + YY_BREAK +case 72: +YY_RULE_SETUP +#line 199 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return LONGINTNUM; } + YY_BREAK +case 73: +#line 202 "fta.l" +case 74: +#line 203 "fta.l" +case 75: +#line 204 "fta.l" +case 76: +#line 205 "fta.l" +case 77: +YY_RULE_SETUP +#line 205 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return APPROXNUM; } + YY_BREAK +/* strings */ +case 78: +YY_RULE_SETUP +#line 209 "fta.l" +{ + + int c; + + FtaParserlval.strval = strdup(FtaParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_fta_ch+=FtaParserleng; + FtaParserlval.strval[FtaParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + YY_BREAK +case 79: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 226 "fta.l" +{ flex_fta_ch+=FtaParserleng; FtaParsererror("Unterminated string"); } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_fta_linebuf */ +/* */ +case 80: +YY_RULE_SETUP +#line 233 "fta.l" +{flex_fta_ch=0; flex_fta_lineno++; + strcpy(flex_fta_linebuf,FtaParsertext+1); + yyless(1); + } + YY_BREAK +case 81: +YY_RULE_SETUP +#line 238 "fta.l" +{flex_fta_ch+=FtaParserleng; } /* white space */ + YY_BREAK +case 82: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 240 "fta.l" +{flex_fta_ch+=FtaParserleng; }; /* comment */ + YY_BREAK +case 83: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 241 "fta.l" +{flex_fta_ch+=FtaParserleng; }; /* comment */ + YY_BREAK +case 84: +YY_RULE_SETUP +#line 243 "fta.l" +{flex_fta_ch+=FtaParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); FtaParsererror(yytext);} + YY_BREAK +case 85: +YY_RULE_SETUP +#line 245 "fta.l" +ECHO; + YY_BREAK +#line 1570 "ftalexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 655 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 655 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 654); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 245 "fta.l" + + +int my_FtaParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_fta_stringinput != NULL){ + while(c +#include + +#include +#include +#include + +#include + +#define TMPSTRLEN 1000 + +#ifndef PATH_DELIM + #define PATH_DELIM '/' +#endif + +char tmp_schema_str[10000]; + +// Interface to FTA definition lexer and parser ... + +extern int FtaParserparse(void); +extern FILE *FtaParserin; +extern int FtaParserdebug; + +fta_parse_t *fta_parse_result; +var_defs_t *fta_parse_defines; + + + +using namespace std; + + + + +int main(int argc, char **argv){ + int s,t,f; + char tmpstr[TMPSTRLEN]; + + + +// set these to 1 to debug the parser + FtaParserdebug = 0; + + FILE *table_schemas_in; // source tables definition file + + // ------------------------------- + // Handling of Input Arguments + // ------------------------------- + const char *optstr = "C:"; + const char *usage_str = "Usage: %s [-C ] schema_file [operator name ...]\n" + "\t[-C] : use for definition files\n"; + + +// parameters gathered from command line processing + string config_dir_path; + set operator_names; + string schema_file_name; + + char chopt; + while((chopt = getopt(argc,argv,optstr)) != -1){ + switch(chopt){ + case 'C': + if(optarg != NULL) + config_dir_path = string(optarg) + string("/"); + break; + case '?': + fprintf(stderr,"Error, argument %c not recognized.\n",optopt); + fprintf(stderr,"%s\n", usage_str); + exit(1); + default: + fprintf(stderr,"Invalid arguments\n"); + fprintf(stderr,"%s\n", usage_str); + exit(1); + } + } + argc -= optind; + argv += optind; + for (int i = 0; i < argc; ++i) { + if(schema_file_name == ""){ + schema_file_name = argv[i]; + }else{ + operator_names.insert(argv[i]); + } + } + + if(schema_file_name == ""){ + fprintf(stderr,"%s\n", usage_str); + exit(1); + } + + +// Open globally used file names. + + // prepend config directory to schema file + schema_file_name = config_dir_path + schema_file_name; + + if((table_schemas_in = fopen(schema_file_name.c_str(), "r")) == NULL) { + fprintf(stderr,"Can't open schema file %s\n%s\n",schema_file_name.c_str(),strerror(errno)); + exit(1); + } + + + + +// Get an initial Schema + table_list *Schema; +// Parse the table schema definitions. + fta_parse_result = new fta_parse_t(); + FtaParser_setfileinput(table_schemas_in); + if(FtaParserparse()){ + fprintf(stderr,"Table schema parse failed.\n"); + exit(1); + } + if(fta_parse_result->parse_type != TABLE_PARSE){ + fprintf(stderr,"ERROR, file %s is not a table definition file.\n",schema_file_name.c_str()); + exit(1); + } + Schema = fta_parse_result->tables; + +// Process schema field inheritance + string err_str; + int retval; + retval = Schema->unroll_tables(err_str); + if(retval){ + fprintf(stderr,"Error processing schema filed inheritance:\n %s\n", err_str.c_str() ); + exit(1); + } + +// Open header, code files + + FILE *hdr_fl = fopen("operator_tuple_pack.h", "w"); + if(hdr_fl == NULL){ + fprintf(stderr,"Can't open output header file operator_tuple_pack.h\n%s\n",strerror(errno)); + exit(1); + } + FILE *code_fl = fopen("operator_tuple_pack.cc", "w"); + if(code_fl == NULL){ + fprintf(stderr,"Can't open output code file operator_tuple_pack.c\n%s\n",strerror(errno)); + exit(1); + } + + + + + +// Generate code for the accessing the operator tuples. + + string header = +"#ifndef __OPERATOR_TUPLE_PACK__\n" +"#define __OPERATOR_TUPLE_PACK__\n" +"\n" +"#include \"host_tuple.h\"\n" +"#include \"vstring.h\"\n" +"#include \"byteswap.h\"" +"\n" +"void *unpack_operator_params(void *buf, int buflen, char **param_list, int plist_len, int *params_found);\n" +"\n" +"\n"; + + string code = +"#include \"operator_tuple_pack.h\"\n" +"#include \n" +"#include \"fta.h\"\n" +"#include \"lapp.h\"\n" +"#include \"hfta_runtime_library.h\"\n" +"\n" +"void *unpack_operator_params(void *buf, int buflen, char **param_list, int plist_len, int *params_found){\n" +" char *c=(char *)buf;\n" +" int pno=0, pos=0;\n" +" *params_found = 0;\n" +"\n" +" for(pos=0;pos ufcns; + vector tbl_names = Schema->get_table_names(); + for(t=0;t0){ + int tid = Schema->find_tbl(tbl_names[t]); + if(Schema->get_schema_type(tid) == OPERATOR_VIEW_SCHEMA){ + table_def *optbl = Schema->get_table(tid); + header += generate_host_name_tuple_struct(optbl); + header += "int pack_"+tbl_names[t]+"_tuple(host_tuple *tup, char *buf, int len, struct "+generate_tuple_name(tbl_names[t])+" *s, unsigned char tuple_type);\n\n"; + code += generate_host_tuple_pack(optbl); + + header += "extern char *"+tbl_names[t]+"_Schema_def_;\n\n"; + code += "\tchar *"+tbl_names[t]+"_Schema_def_ = \n"; + string schema_str = "FTA{\n\n"; + schema_str += optbl->to_stream_string(); + schema_str += +"DEFINE{\n" +"\tquery_name '"+tbl_names[t]+"';\n" +"}\n" +"\n" +"Select"; + vector flds = optbl->get_fields(); + for(f=0;f0) schema_str+=","; + schema_str += " " + flds[f]->get_name(); + } + schema_str += "\nFrom "+tbl_names[t]+"\n}\n\n"; + code += make_C_embedded_string(schema_str)+";\n\n"; + + + vector subq = Schema->get_subqueryspecs(tid); + for(s=0;stypes.size();++f){ + fel.append_field(new field_entry(sqs->types[f].c_str(), sqs->names[f].c_str(), "", sqs->modifiers[f],ufcns)); + } + string subq_name = tbl_names[t]+"_subq_"+sqs->name; + table_def std(subq_name.c_str(),NULL,NULL,&fel, STREAM_SCHEMA); + header += generate_host_name_tuple_struct(&std); + header += "struct "+subq_name+"_tuple *unpack_"+subq_name+"_tuple(host_tuple *tup);\n\n"; + code += generate_host_tuple_unpack(&std); + } + }else{ + if(operator_names.size()>0) + fprintf(stderr,"WARNING: %s is not an operator, skipping.\n",tbl_names[t].c_str()); + } + } + } + + header += "\n#endif\n"; + + + fprintf(hdr_fl,"%s\n",header.c_str()); + fprintf(code_fl,"%s\n",code.c_str()); + +/////////////////////////////////////////////////////////////////////// + + return(0); +} + diff --git a/src/ftacmp/generate_lfta_code.cc b/src/ftacmp/generate_lfta_code.cc new file mode 100644 index 0000000..06bfc9b --- /dev/null +++ b/src/ftacmp/generate_lfta_code.cc @@ -0,0 +1,4505 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include +#include +#include +//#include +#include + +#include "parse_fta.h" +#include "parse_schema.h" +#include "analyze_fta.h" +#include "generate_utils.h" +#include "query_plan.h" +#include "generate_lfta_code.h" +#include "generate_nic_code.h" + +using namespace std; + +extern int DEFAULT_LFTA_HASH_TABLE_SIZE; + +// default value for correlation between the interface card and +// the system clock +#define DEFAULT_TIME_CORR 16 + + +// For fast hashing +//#define NRANDS 100 +extern string hash_nums[NRANDS]; +/* += { +"12916008961267169387ull", "13447227858232756685ull", +"15651770379918602919ull", "1154671861688431608ull", +"6777078091984849858ull", "14217205709582564356ull", +"4955408621820609982ull", "15813680319165523695ull", +"9897969721407807129ull", "5799700135519793083ull", +"3446529189623437397ull", "2766403683465910630ull", +"3759321430908793328ull", "6569396511892890354ull", +"11124853911180290924ull", "17425412145238035549ull", +"6879931585355039943ull", "16598635011539670441ull", +"9615975578494811651ull", "4378135509538422740ull", +"741282195344332574ull", "17368612862906255584ull", +"17294299200556814618ull", "518343398779663051ull", +"3861893449302272757ull", "8951107288843549591ull", +"15785139392894559409ull", "5917810836789601602ull", +"16169988133001117004ull", "9792861259254509262ull", +"5089058010244872136ull", "2130075224835397689ull", +"844136788226150435ull", "1303298091153875333ull", +"3579898206894361183ull", "7529542662845336496ull", +"13151949992653382522ull", "2145333536541545660ull", +"11258221828939586934ull", "3741808146124570279ull", +"16272841626371307089ull", "12174572036188391283ull", +"9749343496254107661ull", "9141275584134508830ull", +"10134192232065698216ull", "12944268412561423018ull", +"17499725811865666340ull", "5281482378159088661ull", +"13254803486023572607ull", "4526762838498717025ull", +"15990846379668494011ull", "10680949816169027468ull", +"7116154096012931030ull", "5296740689865236632ull", +"5222427027515795922ull", "6893215299448261251ull", +"10164707755932877485ull", "15325979189512082255ull", +"3713267224148573289ull", "12292682741753167354ull", +"4098115959960163588ull", "16095675565885113990ull", +"11391590846210510720ull", "8432889531466002673ull", +"7146668520368482523ull", "7678169991822407997ull", +"9882712513525031447ull", "13904414563513869160ull", +"1080076724395768626ull", "8448147843172150388ull", +"17633093729608185134ull", "10044622457050142303ull", +"4128911859292425737ull", "30642269109444395ull", +"16124215396922640581ull", "15444089895060081110ull", +"16437006538696302944ull", "800338649777443426ull", +"5355794945275091932ull", "11656354278827687117ull", +"1110873718944691255ull", "10829576045617693977ull", +"3846916616884579955ull", "17055821716837625668ull", +"13418968402643535758ull", "11671612594828802128ull", +"11597298928184328586ull", "13196028510862205499ull", +"16539578557089782373ull", "3182048322921507591ull", +"10016080431267550241ull", "148751875162592690ull", +"10400930266590768572ull", "4023803397139127870ull", +"17766462746879108920ull", "14807761432134600873ull", +"13521540421053792403ull", "13980983198941385205ull", +"16257584414193564367ull", "1760484796451765024ull" +}; +*/ + + +// ---------------------------------------------- +// Data extracted from the query plan node +// for use by code generation. + +static cplx_lit_table *complex_literals; //Table of literals with constructors. +static vector param_handle_table; +static param_table *param_tbl; // Table of all referenced parameters. + +static vector sl_list; +static vector where; + +static gb_table *gb_tbl; // Table of all group-by attributes. +static aggregate_table *aggr_tbl; // Table of all referenced aggregates. + +static bool packed_return; // unpack using structyure, not fcns +static nic_property *nicprop; // nic properties for this interface. +static int global_id; + + +// The partial_fcns vector can now refer to +// partial functions, or expensive functions +// which can be cached (if there are multiple refs). A couple +// of int vectors distinguish the cases. +static vector partial_fcns; +static vector fcn_ref_cnt; +static vector is_partial_fcn; +int sl_fcns_start = 0, sl_fcns_end = 0; +int wh_fcns_start = 0, wh_fcns_end = 0; +int gb_fcns_start = 0, gb_fcns_end = 0; +int ag_fcns_start = 0, ag_fcns_end = 0; + + +// These vectors are for combinable predicates. +static vector pred_class; // identifies the group +static vector pred_pos; // position in the group. + + + +static char tmpstr[1000]; + +////////////////////////////////////////////////////////////////////// +/// Various utilities + +string generate_fta_name(string node_name){ + string ret = normalize_name(node_name); + if(ret == ""){ + ret = "default"; + } + ret += "_fta"; + + return(ret); +} + + +string generate_aggr_struct_name(string node_name){ + string ret = normalize_name(node_name); + if(ret == ""){ + ret = "default"; + } + ret += "_aggr_struct"; + + return(ret); +} + +string generate_fj_struct_name(string node_name){ + string ret = normalize_name(node_name); + if(ret == ""){ + ret = "default"; + } + ret += "_fj_struct"; + + return(ret); +} + +string generate_unpack_code(int tblref, int schref, string field, table_list *schema, string node_name, string end_goto = string("end")){ + string ret; + if(! packed_return){ + sprintf(tmpstr,"\tretval = %s(p, &unpack_var_%s_%d);\n", + schema->get_fcn(schref,field).c_str(), field.c_str(), tblref); + ret += tmpstr; + if(!schema->get_modifier_list(schref,field)->contains_key("required")) + ret += "\tif(retval) goto "+end_goto+";\n"; + + }else{ +// TODO: ntoh xforms (aug 2010 : removing ntoh, hton) + data_type dt(schema->get_type_name(schref,field), schema->get_modifier_list(schref,field)); + if(dt.is_buffer_type()){ + if(dt.get_type() != v_str_t){ + ret += "\tif(sizeof(struct "+node_name+"_input_struct)+"+node_name+"_input_struct_var->unpack_var_"+field+".length+int("+node_name+"_input_struct_var->unpack_var_"+field+".data) > sz)\n"; + ret += "\t\tgoto "+end_goto+";\n"; + ret+= "\t\t"+node_name+"_input_struct_var->unpack_var_"+field+".data += "+node_name+"_input_struct_var->unpack_var_"+field+".length;\n"; + ret += "\tunpack_var_"+field+"_"+int_to_string(tblref)+ + " = "+node_name+"_input_struct_var->unpack_var_"+field+";+\n"; + }else{ + fprintf(stderr,"INTERNAL ERROR buffer type not string type in generate_lfta_code.cc:generate_unpack_code\n"); + exit(1); + } + }else{ + ret += "\tunpack_var_"+field+"_"+int_to_string(tblref)+ + " = "+node_name+"_input_struct_var->unpack_var_"+field+";\n"; + } + } + return ret; +} + +string generate_aggr_struct(string node_name, gb_table *gb_tbl, aggregate_table *aggr_tbl){ + string ret = "struct " + generate_aggr_struct_name(node_name) + "{\n"; + + int g; + for(g=0;gsize();g++){ + sprintf(tmpstr,"gb_var%d",g); + ret += "\t"+gb_tbl->get_data_type(g)->make_cvar(tmpstr)+";\n"; + } + + int a; + for(a=0;asize();a++){ + ret += "\t"; + sprintf(tmpstr,"aggr_var%d",a); + if(aggr_tbl->is_builtin(a)) + ret+="\t"+aggr_tbl->get_data_type(a)->make_cvar(tmpstr)+";\n"; + else + ret+="\t"+aggr_tbl->get_storage_type(a)->make_cvar(tmpstr)+";\n"; + } + +/* + ret += "\tstruct "+generate_aggr_struct_name(node_name)+" *next;\n"; +*/ + + ret += "};\n\n"; + + return(ret); +} + + +string generate_fj_struct(filter_join_qpn *fs, string node_name ){ + string ret; + + if(fs->use_bloom == false){ // uses hash table instead + ret = "struct " + generate_fj_struct_name(node_name) + "{\n"; + int k; + for(k=0;khash_eq.size();++k){ + sprintf(tmpstr,"key_var%d",k); + ret += "\t"+fs->hash_eq[k]->pr->get_left_se()->get_data_type()->make_cvar(tmpstr)+";\n"; + } + ret += "\tlong long int ts;\n"; + ret += "};\n\n"; + } + + return(ret); +} + + + + +string generate_fta_struct(string node_name, gb_table *gb_tbl, + aggregate_table *aggr_tbl, param_table *param_tbl, + cplx_lit_table *complex_literals, + vector ¶m_handle_table, + bool is_aggr_query, bool is_fj, bool uses_bloom, + table_list *schema){ + + string ret = "struct " + generate_fta_name(node_name) + "{\n"; + ret += "\tstruct FTA f;\n"; + +//------------------------------------------------------------- +// Aggregate-specific fields + + if(is_aggr_query){ +/* + ret += "\tstruct "+generate_aggr_struct_name(node_name)+" *aggr_head, *flush_head;\n"; +*/ + ret+="\tstruct "+generate_aggr_struct_name(node_name)+" *aggr_table; // the groups\n"; + ret+="\tgs_uint32_t *aggr_table_hashmap; // hash val, plus control info.\n"; +// ret+="\tint bitmap_size;\n"; + ret += "\tint n_aggrs; // # of non-empty slots in aggr_table\n"; + ret += "\tint max_aggrs; // size of aggr_table and its hashmap.\n"; + ret += "\tint max_windows; // max number of open windows.\n"; + ret += "\tunsigned int generation; // initially zero, increment on\n"; + ret += "\t // every hash table flush - whether regular or induced.\n"; + ret += "\t // Old groups are identified by a generation mismatch.\n"; + ret += "\tunsigned int flush_pos; // next aggr_table entry to examine\n"; + ret += "\tunsigned int flush_ctr; // control slow flushing\n"; + + + + int g; + bool uses_temporal_flush = false; + for(g=0;gsize();g++){ + data_type *dt = gb_tbl->get_data_type(g); + if(dt->is_temporal()){ +/* + fprintf(stderr,"group by attribute %s is temporal, ", + gb_tbl->get_name(g).c_str()); + if(dt->is_increasing()){ + fprintf(stderr,"increasing.\n"); + }else{ + fprintf(stderr,"decreasing.\n"); + } +*/ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_buffer_type()){ + fprintf(stderr, "\t but temporal BUFFER types are not supported, skipping.\n"); + }else{ + sprintf(tmpstr,"\t%s last_gb_%d;\n",gdt->get_cvar_type().c_str(),g); + ret += tmpstr; + sprintf(tmpstr,"\t%s flush_start_gb_%d;\n",gdt->get_cvar_type().c_str(),g); + ret += tmpstr; + sprintf(tmpstr,"\t%s last_flushed_gb_%d;\n",gdt->get_cvar_type().c_str(),g); + ret += tmpstr; + uses_temporal_flush = true; + } + + } + + } + if(! uses_temporal_flush){ + fprintf(stderr,"Warning: no temporal flush.\n"); + } + } + +// --------------------------------------------------------- +// Filter-join specific fields + + if(is_fj){ + if(uses_bloom){ + ret += +"\tunsigned char * bf_table; //array of bloom filters with layout \n" +"\t\t// bit 0 bf 0| bit 0 bf 1| bit 0 bf 2| bit 1 bf 0| bit 1 bf 1|.....\n" +"\tint first_exec;\n" +"\tlong long int last_bin;\n" +"\tint last_bloom_pos;\n" +"\n" +; + }else{ // limited hash table + ret += +" struct "+generate_fj_struct_name(node_name)+" *join_table;\n" +"\n" +; + } + + } + +//-------------------------------------------------------- +// Common fields + +// Create places to hold the parameters. + int p; + vector param_vec = param_tbl->get_param_names(); + for(p=0;pget_data_type(param_vec[p]); + sprintf(tmpstr,"\t%s param_%s;\n",dt->get_cvar_type().c_str(), + param_vec[p].c_str()); + ret += tmpstr; + if(param_tbl->handle_access(param_vec[p])){ + ret += "\tstruct search_handle *param_handle_"+param_vec[p]+";\n"; + } + } + +// Create places to hold complex literals. + int cl; + for(cl=0;clsize();cl++){ + literal_t *l = complex_literals->get_literal(cl); + data_type *dtl = new data_type( l->get_type() ); + sprintf(tmpstr,"\t%s complex_literal_%d;\n",dtl->get_cvar_type().c_str(),cl); + ret += tmpstr; + } + +// Create places to hold the pass-by-handle parameters. + for(p=0;pget_data_type(); + if (sdt->is_temporal()) { + gather_se_col_ids(sl_list[s],temp_cids, gb_tbl); + } + } + + for(csi=temp_cids.begin(); csi != temp_cids.end();++csi){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field), schema->get_modifier_list(schref,field)); + sprintf(tmpstr,"\t%s last_%s_%d;\n", dt.get_cvar_type().c_str(), field.c_str(), tblref); + ret += tmpstr; + } + + ret += "\tgs_uint64_t trace_id;\n\n"; + +// Fields to store the runtime stats + + ret += "\tgs_uint32_t in_tuple_cnt;\n"; + ret += "\tgs_uint32_t out_tuple_cnt;\n"; + ret += "\tgs_uint32_t out_tuple_sz;\n"; + ret += "\tgs_uint32_t accepted_tuple_cnt;\n"; + ret += "\tgs_uint64_t cycle_cnt;\n"; + ret += "\tgs_uint32_t collision_cnt;\n"; + ret += "\tgs_uint32_t eviction_cnt;\n"; + ret += "\tgs_float_t sampling_rate;\n"; + + + + ret += "};\n\n"; + + return(ret); +} + +//------------------------------------------------------------ +// Set colref tblvars to 0.. +// (special processing for join-like operators in an lfta). + +void reset_se_col_ids_tblvars(scalarexp_t *se, gb_table *gtbl){ + vector operands; + int o; + + if(! se) + return; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return; + case SE_UNARY_OP: + reset_se_col_ids_tblvars(se->get_left_se(),gtbl); + return; + case SE_BINARY_OP: + reset_se_col_ids_tblvars(se->get_left_se(),gtbl); + reset_se_col_ids_tblvars(se->get_right_se(),gtbl); + return; + case SE_COLREF: + if(! se->is_gb() ){ + se->get_colref()->set_tablevar_ref(0); + }else{ + if(gtbl==NULL){ + fprintf(stderr,"INTERNAL ERROR: gbvar ref in gather_se_col_ids, but gtbl is NULL.\n"); + exit(1); + } + reset_se_col_ids_tblvars(gtbl->get_def(se->get_gb_ref()),gtbl); + } + return; + case SE_AGGR_STAR: + return; + case SE_AGGR_SE: + reset_se_col_ids_tblvars(se->get_left_se(),gtbl); + return; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;oget_lineno(), se->get_charno(),se->get_operator_type()); + exit(1); + } +} + + +// reset column tblvars accessed in this pr. + +void reset_pr_col_ids_tblvars(predicate_t *pr, gb_table *gtbl){ + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + reset_se_col_ids_tblvars(pr->get_left_se(), gtbl); + return; + case PRED_COMPARE: + reset_se_col_ids_tblvars(pr->get_left_se(),gtbl) ; + reset_se_col_ids_tblvars(pr->get_right_se(),gtbl) ; + return; + case PRED_UNARY_OP: + reset_pr_col_ids_tblvars(pr->get_left_pr(),gtbl) ; + return; + case PRED_BINARY_OP: + reset_pr_col_ids_tblvars(pr->get_left_pr(),gtbl) ; + reset_pr_col_ids_tblvars(pr->get_right_pr(),gtbl) ; + return; + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_lineno(), pr->get_charno(), pr->get_operator_type() ); + } +} + + + + +// Generate code that makes reference +// to the tuple, and not to any aggregates. +static string generate_se_code(scalarexp_t *se,table_list *schema){ + string ret; + data_type *ldt, *rdt; + int o; + vector operands; + + + switch(se->get_operator_type()){ + case SE_LITERAL: + if(se->is_handle_ref()){ + sprintf(tmpstr,"t->handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + if(se->get_literal()->is_cpx_lit()){ + sprintf(tmpstr,"t->complex_literal_%d",se->get_literal()->get_cpx_lit_ref() ); + ret = tmpstr; + return(ret); + } + return(se->get_literal()->to_C_code("")); // not complex, no constructor + case SE_PARAM: + if(se->is_handle_ref()){ + sprintf(tmpstr,"t->handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + ret += "t->param_"; + ret += se->get_param_name(); + return(ret); + case SE_UNARY_OP: + ldt = se->get_left_se()->get_data_type(); + if(ldt->complex_operator(se->get_op()) ){ + ret += ldt->get_complex_operator(se->get_op()); + ret += "("; + ret += generate_se_code(se->get_left_se(),schema); + ret += ")"; + }else{ + ret += "("; + ret += se->get_op(); + ret += generate_se_code(se->get_left_se(),schema); + ret += ")"; + } + return(ret); + case SE_BINARY_OP: + ldt = se->get_left_se()->get_data_type(); + rdt = se->get_right_se()->get_data_type(); + + if(ldt->complex_operator(rdt, se->get_op()) ){ + ret += ldt->get_complex_operator(rdt, se->get_op()); + ret += "("; + ret += generate_se_code(se->get_left_se(),schema); + ret += ", "; + ret += generate_se_code(se->get_right_se(),schema); + ret += ")"; + }else{ + ret += "("; + ret += generate_se_code(se->get_left_se(),schema); + ret += se->get_op(); + ret += generate_se_code(se->get_right_se(),schema); + ret += ")"; + } + return(ret); + case SE_COLREF: + if(se->is_gb()){ // OK to ref gb attrs, but they're not yet unpacked ... + // so return the defining code. + ret = generate_se_code(gb_tbl->get_def(se->get_gb_ref()), schema ); + + }else{ + sprintf(tmpstr,"unpack_var_%s_%d", + se->get_colref()->get_field().c_str(), se->get_colref()->get_tablevar_ref() ); + ret = tmpstr; + } + return(ret); + case SE_FUNC: +// Should not be ref'ing any aggr here. + if(se->get_aggr_ref() >= 0){ + fprintf(stderr,"INTERNAL ERROR, UDAF reference in generate_se_code.\n"); + return("ERROR in generate_se_code"); + } + + if(se->is_partial()){ + sprintf(tmpstr,"partial_fcn_result_%d",se->get_partial_ref()); + ret = tmpstr; + }else{ + ret += se->op + "("; + operands = se->get_operands(); + for(o=0;o0) ret += ", "; + if(operands[o]->get_data_type()->is_buffer_type() && (! (operands[o]->is_handle_ref()) ) ) + ret += "&"; + ret += generate_se_code(operands[o], schema); + } + ret += ")"; + } + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_se_code (lfta), line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + return("ERROR in generate_se_code"); + } +} + +// generate code that refers only to aggregate data and constants. +static string generate_se_code_fm_aggr(scalarexp_t *se, string var, table_list *schema){ + + string ret; + data_type *ldt, *rdt; + int o; + vector operands; + + + switch(se->get_operator_type()){ + case SE_LITERAL: + if(se->is_handle_ref()){ + sprintf(tmpstr,"t->handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + if(se->get_literal()->is_cpx_lit()){ + sprintf(tmpstr,"t->complex_literal_%d",se->get_literal()->get_cpx_lit_ref() ); + ret = tmpstr; + return(ret); + } + return(se->get_literal()->to_C_code("")); // not complex no constructor + case SE_PARAM: + if(se->is_handle_ref()){ + sprintf(tmpstr,"t->handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + ret += "t->param_"; + ret += se->get_param_name(); + return(ret); + case SE_UNARY_OP: + ldt = se->get_left_se()->get_data_type(); + if(ldt->complex_operator(se->get_op()) ){ + ret += ldt->get_complex_operator(se->get_op()); + ret += "("; + ret += generate_se_code_fm_aggr(se->get_left_se(),var,schema); + ret += ")"; + }else{ + ret += "("; + ret += se->get_op(); + ret += generate_se_code_fm_aggr(se->get_left_se(),var,schema); + ret += ")"; + } + return(ret); + case SE_BINARY_OP: + ldt = se->get_left_se()->get_data_type(); + rdt = se->get_right_se()->get_data_type(); + + if(ldt->complex_operator(rdt, se->get_op()) ){ + ret += ldt->get_complex_operator(rdt, se->get_op()); + ret += "("; + ret += generate_se_code_fm_aggr(se->get_left_se(),var,schema); + ret += ", "; + ret += generate_se_code_fm_aggr(se->get_right_se(),var,schema); + ret += ")"; + }else{ + ret += "("; + ret += generate_se_code_fm_aggr(se->get_left_se(),var,schema); + ret += se->get_op(); + ret += generate_se_code_fm_aggr(se->get_right_se(),var,schema); + ret += ")"; + } + return(ret); + case SE_COLREF: + if(se->is_gb()){ // OK to ref gb attrs, but they're not yet + // unpacked ... so return the defining code. + sprintf(tmpstr,"%sgb_var%d",var.c_str(),se->get_gb_ref()); + ret = tmpstr; + + }else{ + fprintf(stderr,"ERROR reference to non-GB column ref not permitted here," + "error in generate_se_code_fm_aggr, line %d, character %d.\n", + se->get_lineno(), se->get_charno()); + ret = tmpstr; + } + return(ret); + case SE_AGGR_STAR: + case SE_AGGR_SE: + sprintf(tmpstr,"%saggr_var%d",var.c_str(),se->get_aggr_ref()); + ret = tmpstr; + return(ret); + case SE_FUNC: +// Is it a UDAF? + if(se->get_aggr_ref() >= 0){ + sprintf(tmpstr,"udaf_ret%d",se->get_aggr_ref()); + ret = tmpstr; + return(ret); + } + + if(se->is_partial()){ + sprintf(tmpstr,"partial_fcn_result_%d",se->get_partial_ref()); + ret = tmpstr; + }else{ + ret += se->op + "("; + operands = se->get_operands(); + for(o=0;o0) ret += ", "; + if(operands[o]->get_data_type()->is_buffer_type() && (! (operands[o]->is_handle_ref()) ) ) + ret += "&"; + ret += generate_se_code_fm_aggr(operands[o], var, schema); + } + ret += ")"; + } + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_lfta_code.cc::generate_se_code_fm_aggr, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + return("ERROR in generate_se_code"); + } + +} + + +static string unpack_partial_fcn_fm_aggr(scalarexp_t *se, int pfn_id, string var, table_list *schema){ + string ret; + int o; + vector operands; + + + if(se->get_operator_type() != SE_FUNC || se->get_aggr_ref() >= 0){ + fprintf(stderr,"INTERNAL ERROR, non-function SE passed to unpack_partial_fcn_fm_aggr. line %d, character %d\n", + se->get_lineno(), se->get_charno()); + return("ERROR in generate_se_code"); + } + + ret = "\tretval = " + se->get_op() + "( "; + sprintf(tmpstr, "&partial_fcn_result_%d",pfn_id); + ret += tmpstr; + + operands = se->get_operands(); + for(o=0;oget_data_type()->is_buffer_type() && (! (operands[o]->is_handle_ref()) ) ) + ret += "&"; + ret += generate_se_code_fm_aggr(operands[o], var, schema); + } + ret += ");\n"; + + return(ret); +} + +static string generate_cached_fcn(scalarexp_t *se, table_list *schema){ + string ret; + int o; + vector operands; + + if(se->get_operator_type() != SE_FUNC || se->get_aggr_ref() >= 0){ + fprintf(stderr,"INTERNAL ERROR, non-function SE passed to generate_cached_fcn. line %d, character %d\n", + se->get_lineno(), se->get_charno()); + return("ERROR in generate_se_code"); + } + + ret = se->get_op() + "( "; + + operands = se->get_operands(); + for(o=0;oget_data_type()->is_buffer_type() && (! (operands[o]->is_handle_ref()) ) ) + ret += "&"; + ret += generate_se_code(operands[o], schema); + } + ret += ");\n"; + + return(ret); +} + + + +static string unpack_partial_fcn(scalarexp_t *se, int pfn_id, table_list *schema){ + string ret; + int o; + vector operands; + + + if(se->get_operator_type() != SE_FUNC || se->get_aggr_ref() >= 0){ + fprintf(stderr,"INTERNAL ERROR, non-function SE passed to unpack_partial_fcn. line %d, character %d\n", + se->get_lineno(), se->get_charno()); + return("ERROR in generate_se_code"); + } + + ret = "\tretval = " + se->get_op() + "( ", + sprintf(tmpstr, "&partial_fcn_result_%d",pfn_id); + ret += tmpstr; + + operands = se->get_operands(); + for(o=0;oget_data_type()->is_buffer_type() && (! (operands[o]->is_handle_ref()) ) ) + ret += "&"; + ret += generate_se_code(operands[o], schema); + } + ret += ");\n"; + + return(ret); +} + + + + + +static string generate_C_comparison_op(string op){ + if(op == "=") return("=="); + if(op == "<>") return("!="); + return(op); +} + +static string generate_C_boolean_op(string op){ + if( (op == "AND") || (op == "And") || (op == "and") ){ + return("&&"); + } + if( (op == "OR") || (op == "Or") || (op == "or") ){ + return("||"); + } + if( (op == "NOT") || (op == "Not") || (op == "not") ){ + return("!"); + } + + fprintf(stderr,"INTERNAL ERROR: unknown boolean operator %s\n",op.c_str()); + return("ERROR UNKNOWN BOOLEAN OPERATOR :"+op); +} + + +static string generate_predicate_code(predicate_t *pr,table_list *schema){ + string ret; + vector litv; + int i; + data_type *ldt, *rdt; + vector op_list; + int o,cref,ppos; + unsigned int bitmask; + + switch(pr->get_operator_type()){ + case PRED_IN: + ldt = pr->get_left_se()->get_data_type(); + + ret += "( "; + litv = pr->get_lit_vec(); + for(i=0;i0) ret += " || "; + ret += "( "; + + if(ldt->complex_comparison(ldt) ){ + ret += ldt->get_comparison_fcn(ldt) ; + ret += "( "; + if(ldt->is_buffer_type() ) ret += "&"; + ret += generate_se_code(pr->get_left_se(), schema); + ret += ", "; + if(ldt->is_buffer_type() ) ret += "&"; + if(litv[i]->is_cpx_lit()){ + sprintf(tmpstr,"t->complex_literal_%d",litv[i]->get_cpx_lit_ref() ); + ret += tmpstr; + }else{ + ret += litv[i]->to_C_code(""); + } + ret += ") == 0"; + }else{ + ret += generate_se_code(pr->get_left_se(), schema); + ret += " == "; + ret += litv[i]->to_C_code(""); + } + + ret += " )"; + } + ret += " )"; + return(ret); + + case PRED_COMPARE: + ldt = pr->get_left_se()->get_data_type(); + rdt = pr->get_right_se()->get_data_type(); + + ret += "( "; + if(ldt->complex_comparison(rdt) ){ + ret += ldt->get_comparison_fcn(rdt); + ret += "("; + if(ldt->is_buffer_type() ) ret += "&"; + ret += generate_se_code(pr->get_left_se(),schema); + ret += ", "; + if(rdt->is_buffer_type() ) ret += "&"; + ret += generate_se_code(pr->get_right_se(),schema); + ret += ") "; + ret += generate_C_comparison_op(pr->get_op()); + ret += "0"; + }else{ + ret += generate_se_code(pr->get_left_se(),schema); + ret += generate_C_comparison_op(pr->get_op()); + ret += generate_se_code(pr->get_right_se(),schema); + } + ret += " )"; + return(ret); + case PRED_UNARY_OP: + ret += "( "; + ret += generate_C_boolean_op(pr->get_op()); + ret += generate_predicate_code(pr->get_left_pr(),schema); + ret += " )"; + return(ret); + case PRED_BINARY_OP: + ret += "( "; + ret += generate_predicate_code(pr->get_left_pr(),schema); + ret += generate_C_boolean_op(pr->get_op()); + ret += generate_predicate_code(pr->get_right_pr(),schema); + ret += " )"; + return(ret); + case PRED_FUNC: + op_list = pr->get_op_list(); + cref = pr->get_combinable_ref(); + if(cref >= 0){ // predicate is a combinable pred reference + // Trust, but verify + if(pred_class.size() >= cref && pred_class[cref] >= 0){ + ppos = pred_pos[cref]; + bitmask = 1 << ppos % 32; + sprintf(tmpstr,"(pref_common_pred_val_%d_%d & %u)",pred_class[cref],ppos/32,bitmask); + ret = tmpstr; + return ret; + } + } + + ret = pr->get_op() + "("; + if (pr->is_sampling_fcn) { + ret += "t->sampling_rate"; + if (!op_list.empty()) + ret += ", "; + } + for(o=0;o0) ret += ", "; + if(op_list[o]->get_data_type()->is_buffer_type() && (! (op_list[o]->is_handle_ref()) ) ) + ret += "&"; + ret += generate_se_code(op_list[o],schema); + } + ret += " )"; + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_predicate_code, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + return("ERROR in generate_predicate_code"); + } +} + + +static string generate_equality_test(string &lhs_op, string &rhs_op, data_type *dt){ + string ret; + + if(dt->complex_comparison(dt) ){ + ret += dt->get_comparison_fcn(dt); + ret += "("; + if(dt->is_buffer_type() ) ret += "&"; + ret += lhs_op; + ret += ", "; + if(dt->is_buffer_type() ) ret += "&"; + ret += rhs_op; + ret += ") == 0"; + }else{ + ret += lhs_op; + ret += " == "; + ret += rhs_op; + } + + return(ret); +} + +static string generate_comparison(string &lhs_op, string &rhs_op, data_type *dt){ + string ret; + + if(dt->complex_comparison(dt) ){ + ret += dt->get_comparison_fcn(dt); + ret += "("; + if(dt->is_buffer_type() ) ret += "&"; + ret += lhs_op; + ret += ", "; + if(dt->is_buffer_type() ) ret += "&"; + ret += rhs_op; + ret += ") == 0"; + }else{ + ret += lhs_op; + ret += " == "; + ret += rhs_op; + } + + return(ret); +} + +// Here I assume that only MIN and MAX aggregates can be computed +// over BUFFER data types. + +static string generate_aggr_update(string var, aggregate_table *atbl,int aidx, table_list *schema){ + string retval = "\t\t"; + string op = atbl->get_op(aidx); + +// Is it a UDAF + if(! atbl->is_builtin(aidx)) { + int o; + retval += op+"_LFTA_AGGR_UPDATE_("; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+")"; + vector opl = atbl->get_operand_list(aidx); + for(o=0;oget_data_type()->is_buffer_type() && (! (opl[o]->is_handle_ref()) ) ) + retval.append("&"); + retval += generate_se_code(opl[o], schema); + } + retval += ");\n"; + + return retval; + } + +// Built-in aggregate processing. + + data_type *dt = atbl->get_data_type(aidx); + + if(op == "COUNT"){ + retval.append(var); + retval.append("++;\n"); + return(retval); + } + if(op == "SUM"){ + retval.append(var); + retval.append(" += "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + if(op == "MIN"){ + sprintf(tmpstr,"aggr_tmp_%d = %s;\n",aidx,generate_se_code(atbl->get_aggr_se(aidx), schema ).c_str() ); + retval.append(tmpstr); + if(dt->complex_comparison(dt)){ + if(dt->is_buffer_type()) + sprintf(tmpstr,"\t\tif(%s(&aggr_tmp_%d,&(%s)) < 0)\n",dt->get_comparison_fcn(dt).c_str(), aidx, var.c_str()); + else + sprintf(tmpstr,"\t\tif(%s(aggr_tmp_%d,%s) < 0)\n",dt->get_comparison_fcn(dt).c_str(), aidx, var.c_str()); + }else{ + sprintf(tmpstr,"\t\tif(aggr_tmp_%d < %s)\n",aidx,var.c_str()); + } + retval.append(tmpstr); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(f,&(%s),&aggr_tmp_%d);\n",dt->get_buffer_replace().c_str(),var.c_str(),aidx); + }else{ + sprintf(tmpstr,"\t\t\t%s = aggr_tmp_%d;\n",var.c_str(),aidx); + } + retval.append(tmpstr); + + return(retval); + } + if(op == "MAX"){ + sprintf(tmpstr,"aggr_tmp_%d = %s;\n",aidx,generate_se_code(atbl->get_aggr_se(aidx), schema ).c_str() ); + retval.append(tmpstr); + if(dt->complex_comparison(dt)){ + if(dt->is_buffer_type()) + sprintf(tmpstr,"\t\tif(%s(&aggr_tmp_%d,&(%s)) > 0)\n",dt->get_comparison_fcn(dt).c_str(), aidx, var.c_str()); + else + sprintf(tmpstr,"\t\tif(%s(aggr_tmp_%d,%s) > 0)\n",dt->get_comparison_fcn(dt).c_str(), aidx, var.c_str()); + }else{ + sprintf(tmpstr,"\t\tif(aggr_tmp_%d > %s)\n",aidx,var.c_str()); + } + retval.append(tmpstr); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(f,&(%s),&aggr_tmp_%d);\n",dt->get_buffer_replace().c_str(),var.c_str(),aidx); + }else{ + sprintf(tmpstr,"\t\t\t%s = aggr_tmp_%d;\n",var.c_str(),aidx); + } + retval.append(tmpstr); + + return(retval); + + } + if(op == "AND_AGGR"){ + retval.append(var); + retval.append(" &= "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + if(op == "OR_AGGR"){ + retval.append(var); + retval.append(" |= "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + if(op == "XOR_AGGR"){ + retval.append(var); + retval.append(" ^= "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + fprintf(stderr,"INTERNAL ERROR : aggregate %s not recognized in generate_aggr_update.\n",op.c_str()); + return("ERROR: aggregate not recognized: "+op); + +} + + + +static string generate_aggr_init(string var, aggregate_table *atbl,int aidx, table_list *schema){ + string retval; + string op = atbl->get_op(aidx); + +// Is it a UDAF + if(! atbl->is_builtin(aidx)) { + int o; + retval += "\t\t"+op+"_LFTA_AGGR_INIT_("; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+"));\n"; +// Add 1st tupl + retval += "\t"+atbl->get_op(aidx)+"_LFTA_AGGR_UPDATE_("; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+")"; + vector opl = atbl->get_operand_list(aidx); + for(o=0;oget_data_type()->is_buffer_type() && (! (opl[o]->is_handle_ref()) ) ) + retval.append("&"); + retval += generate_se_code(opl[o],schema); + } + retval += ");\n"; + return(retval); + } + +// Built-in aggregate processing. + + + data_type *dt = atbl->get_data_type(aidx); + + if(op == "COUNT"){ + retval = "\t\t"+var; + retval.append(" = 1;\n"); + return(retval); + } + + if(op == "SUM" || op == "MIN" || op == "MAX" || op == "AND_AGGR" || + op == "OR_AGGR" || op == "XOR_AGGR"){ + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t\taggr_tmp_%d = %s;\n",aidx,generate_se_code(atbl->get_aggr_se(aidx), schema ).c_str() ); + retval.append(tmpstr); + sprintf(tmpstr,"\t\t%s(f,&(%s),&aggr_tmp_%d);\n",dt->get_buffer_assign_copy().c_str(),var.c_str(),aidx); + retval.append(tmpstr); + }else{ + retval = "\t\t"+var; + retval += " = "; + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema)); + retval.append(";\n"); + } + return(retval); + } + + fprintf(stderr,"INTERNAL ERROR : aggregate %s not recognized in generate_aggr_init.\n",op.c_str()); + return("ERROR: aggregate not recognized: "+op); +} + + +//////////////////////////////////////////////////////////// + + +string generate_preamble(table_list *schema, //map &int_fcn_defs, + std::string &node_name, std::string &schema_embed_str){ +// Include these only once, not once per lfta +// string ret = "#include \"rts.h\"\n"; +// ret += "#include \"fta.h\"\n\n"); + + string ret = "#ifndef LFTA_IN_NIC\n"; + ret += "char *"+generate_schema_string_name(node_name)+" = " +schema_embed_str+";\n"; + ret += "#include\n"; + ret += "#include \n"; + ret += "#include \n"; + ret += "#include \"rdtsc.h\"\n"; + ret += "#endif\n"; + + + + return(ret); +} + + +string generate_tuple_from_aggr(string node_name, table_list *schema, string idx){ + int a,p,s; +// need to create and output the tuple. + string ret = "/*\t\tCreate an output tuple for the aggregate being kicked out \t*/\n"; +// Check for any UDAFs with LFTA_BAILOUT + ret += "\tlfta_bailout = 0;\n"; + for(a=0;asize();a++){ + if(aggr_tbl->has_bailout(a)){ + ret += "\tlfta_bailout+="+aggr_tbl->get_op(a)+"_LFTA_AGGR_BAILOUT_("; + if(aggr_tbl->get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(t->aggr_table["+idx+"].aggr_var"+int_to_string(a)+"));\n"; + } + } + ret += "\tif(! lfta_bailout){\n"; + +// First, compute the size of the tuple. + +// Unpack UDAF return values + for(a=0;asize();a++){ + if(! aggr_tbl->is_builtin(a)){ + ret += "\t"+aggr_tbl->get_op(a)+"_LFTA_AGGR_OUTPUT_(&(udaf_ret"+int_to_string(a)+"),"; + if(aggr_tbl->get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(t->aggr_table["+idx+"].aggr_var"+int_to_string(a)+"));\n"; + + } + } + + +// Unpack partial fcns ref'd by the select clause. + if(sl_fcns_start != sl_fcns_end){ + ret += "\t\tunpack_failed = 0;\n"; + for(p=sl_fcns_start;paggr_table["+idx+"].",schema); + ret += "\t\tif(retval) unpack_failed = 1;\n"; + } + } + // BEGIN don't allocate tuple if + ret += "\t\tif( unpack_failed == 0 ){\n"; // unpack failed. + } + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. + + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\tselvar_%d = ",s); + ret += tmpstr; + ret += generate_se_code_fm_aggr(sl_list[s],"t->aggr_table["+idx+"].",schema); + ret += ";\n"; + } + } + + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + ret += "\t\t\ttuple_size = sizeof( struct "; + ret += generate_tuple_name(node_name); + ret += ")"; + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr," + %s(&selvar_%d)", sdt->get_buffer_size().c_str(),s); + ret += tmpstr; + } + } + ret += ";\n"; + + + ret += "\t\t\ttuple = allocate_tuple(f, tuple_size );\n"; + ret += "\t\t\tif( tuple != NULL){\n"; + + +// Test passed, make assignments to the tuple. + + ret += "\t\t\t\ttuple_pos = sizeof( struct "; + ret += generate_tuple_name(node_name) ; + ret += ");\n"; + +// Mark tuple as REGULAR_TUPLE + ret += "\n\t\t\t\ttuple->tuple_type = REGULAR_TUPLE;\n"; + + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t\t%s(&(tuple->tuple_var%d), &selvar_%d, (char *)tuple, ((char *)tuple)+tuple_pos);\n", sdt->get_buffer_tuple_copy().c_str(),s, s); + ret += tmpstr; + sprintf(tmpstr,"\t\t\t\ttuple_pos += %s(&selvar_%d);\n", sdt->get_buffer_size().c_str(), s); + ret += tmpstr; + }else{ + sprintf(tmpstr,"\t\t\t\ttuple->tuple_var%d = ",s); + ret += tmpstr; +// if(sdt->needs_hn_translation()) +// ret += sdt->hton_translation() +"( "; + ret += generate_se_code_fm_aggr(sl_list[s],"t->aggr_table["+idx+"].",schema); +// if(sdt->needs_hn_translation()) +// ret += ") "; + ret += ";\n"; + } + } + +// Generate output. + ret += "\t\t\t\tpost_tuple(tuple);\n"; + ret += "\t\t\t\t#ifdef LFTA_STATS\n"; + ret+="\t\t\t\tt->out_tuple_cnt++;\n"; + ret+="\t\t\t\tt->out_tuple_sz+=tuple_size;\n"; + ret += "\t\t\t\t#endif\n\n"; + ret += "\t\t\t}\n"; + + if(sl_fcns_start != sl_fcns_end) // END don't allocate tuple if + ret += "\t\t}\n"; // unpack failed. + ret += "\t}\n"; + +// Need to release memory held by BUFFER types. + int g; + + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(&(t->aggr_table[%s].gb_var%d));\n",gdt->get_buffer_destroy().c_str(),idx.c_str(),g); + ret += tmpstr; + } + } + for(a=0;asize();a++){ + if(aggr_tbl->is_builtin(a)){ + data_type *adt = aggr_tbl->get_data_type(a); + if(adt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(&(t->aggr_table[%s].aggr_var%d));\n",adt->get_buffer_destroy().c_str(),idx.c_str(),a); + ret += tmpstr; + } + }else{ + ret += "\t\t"+aggr_tbl->get_op(a)+"_LFTA_AGGR_DESTROY_("; + if(aggr_tbl->get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(t->aggr_table["+idx+"].aggr_var"+int_to_string(a)+"));\n"; + } + } + + ret += "\t\tt->n_aggrs--;\n"; + + return(ret); + +} + +string generate_gb_match_test(string idx){ + int g; + string ret="\tif (IS_FILLED(t->aggr_table_bitmap, "+idx+") && IS_NEW(t->aggr_table_bitmap,"+idx+")"; + if(gb_tbl->size()>0){ + ret+="\n\t/* \t\tcheck if the grouping variables are equal */\n"; + ret+="\t\t"; + +// Next, scan list for a match on the group-by attributes. + string rhs_op, lhs_op; + for(g=0;gsize();g++){ + ret += " && "; + ret += "("; + sprintf(tmpstr,"gb_attr_%d",g); lhs_op = tmpstr; + sprintf(tmpstr,"t->aggr_table[%s].gb_var%d",idx.c_str(),g); rhs_op = tmpstr; + ret += generate_equality_test(lhs_op, rhs_op, gb_tbl->get_data_type(g) ); + ret += ")"; + } + } + + ret += "){\n"; + + return ret; +} + +string generate_gb_update(string node_name, table_list *schema, string idx, bool has_udaf){ + int g; + string ret; + + ret += "/*\t\tMatch found : update in place.\t*/\n"; + int a; + has_udaf = false; + for(a=0;asize();a++){ + sprintf(tmpstr,"t->aggr_table[%s].aggr_var%d",idx.c_str(),a); + ret += generate_aggr_update(tmpstr,aggr_tbl,a, schema); + if(! aggr_tbl->is_builtin(a)) has_udaf = true; + } + +// garbage collect copied buffer type gb attrs. + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(&(gb_attr_%d));\n",gdt->get_buffer_destroy().c_str(),g); + ret+=tmpstr; + } + } + + + + bool first_udaf = true; + if(has_udaf){ + ret += "\t\tif("; + for(a=0;asize();a++){ + if(! aggr_tbl->is_builtin(a)){ + if(! first_udaf)ret += " || "; + else first_udaf = false; + ret += aggr_tbl->get_op(a)+"_LFTA_AGGR_FLUSHME_("; + if(aggr_tbl->get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(t->aggr_table["+idx+"].aggr_var"+int_to_string(a)+"))"; + } + } + ret+="){\n"; + ret+=" fta_aggr_flush_old_"+node_name+"(f,t->max_aggrs);\n"; + ret += generate_tuple_from_aggr(node_name,schema,idx); + ret += "\t\tt->aggr_table_hashmap["+idx+"] &= ~SLOT_FILLED;\n"; + ret+="\t\t}\n"; + } + return ret; +} + + +string generate_init_group( table_list *schema, string idx){ + int g,a; + string ret="\t\t\tt->aggr_table_hashmap["+idx+"] = hash2 | SLOT_FILLED | gen_val;\n"; +// Fill up the aggregate block. + for(g=0;gsize();g++){ + sprintf(tmpstr,"\t\t\tt->aggr_table[%s].gb_var%d = gb_attr_%d;\n",idx.c_str(),g,g); + ret += tmpstr; + } + for(a=0;asize();a++){ + sprintf(tmpstr,"t->aggr_table[%s].aggr_var%d",idx.c_str(),a); + ret += generate_aggr_init(tmpstr, aggr_tbl,a, schema); + } + ret+="\t\tt->n_aggrs++;\n"; + return ret; +} + + +string generate_fta_flush(string node_name, table_list *schema, + ext_fcn_list *Ext_fcns){ + + string ret; + string select_var_defs ; + int s, p; + +// Flush from previous epoch + + ret+="static void fta_aggr_flush_old_"+node_name+"(struct FTA *f, unsigned int nflush){\n"; + + ret += "\tgs_int32_t tuple_size, tuple_pos;\n"; + ret += "\tstruct "+generate_tuple_name(node_name)+" *tuple;\n"; + ret += "\tint i, lfta_bailout;\n"; + ret += "\tunsigned int gen_val;\n"; + + ret += "\tstruct "+generate_fta_name(node_name)+" * t = (struct "; + ret += generate_fta_name(node_name)+" *) f;\n"; + + ret += "\n"; + + +// Variables needed to store selected attributes of BUFFER type +// temporarily, in order to compute their size for storage +// in an output tuple. + + select_var_defs = ""; + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\t%s selvar_%d;\n",sdt->get_cvar_type().c_str(),s); + select_var_defs.append(tmpstr); + } + } + if(select_var_defs != ""){ + ret += "/*\t\tTemporaries for computing buffer sizes.\t*/\n"; + ret += select_var_defs; + } + + +// Variables to store results of partial functions. + if(sl_fcns_start != sl_fcns_end){ + ret += "/*\t\tVariables to store the results of partial functions.\t*/\n"; + for(p=sl_fcns_start;pget_data_type()->get_cvar_type().c_str(), p); + ret += tmpstr; + } + ret += "\tgs_retval_t retval = 0;\n\tint unpack_failed = 0;\n;"; + } + +// Variables for udaf output temporaries + bool no_udaf = true; + int a; + for(a=0;asize();a++){ + if(! aggr_tbl->is_builtin(a)){ + if(no_udaf){ + ret+="/*\t\tUDAF output vars.\t*/\n"; + no_udaf = false; + } + int afcn_id = aggr_tbl->get_fcn_id(a); + data_type *adt = Ext_fcns->get_fcn_dt(afcn_id); + sprintf(tmpstr,"udaf_ret%d", a); + ret+="\t"+adt->make_cvar(tmpstr)+";\n"; + } + } + + +// ret+="\tt->flush_finished=1; /* flush will be completed */\n"; + ret+="\n"; + ret+="\tgen_val = t->generation & SLOT_GEN_BITS;\n"; + ret+="\tfor (i=t->flush_pos; (i < t->max_aggrs) && t->n_aggrs && nflush>0; ++i){\n"; + ret+="\t\tif ( (t->aggr_table_hashmap[i] & SLOT_FILLED) && (((t->aggr_table_hashmap[i] & SLOT_GEN_BITS) != gen_val ) || ("; + bool first_g=true; + int g; + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_temporal()){ + if(first_g) first_g=false; else ret+=" || "; + ret += "t->last_gb_"+int_to_string(g)+" > t->aggr_table[i].gb_var"+int_to_string(g)+" "; + } + } + ret += "))) {\n"; + ret+="\t\t\tt->aggr_table_hashmap[i] = 0;\n"; + ret+= +"#ifdef LFTA_STATS\n" +"\t\t\tt->eviction_cnt++;\n" +"#endif\n" +; + + + ret+=generate_tuple_from_aggr(node_name,schema,"i"); + +// ret+="\t\t\tt->n_aggrs--;\n"; // done in generate_tuple_from_aggr + ret+="\t\t\tnflush--;\n"; + ret+="\t\t}\n"; + ret+="\t}\n"; + ret+="\tt->flush_pos=i;\n"; + ret+="\tif(t->n_aggrs == 0) {\n"; + ret+="\t\tt->flush_pos = t->max_aggrs;\n"; + ret += "\t}\n\n"; + + ret+="\tif(t->flush_pos == t->max_aggrs) {\n"; + + for(int g=0;gsize();g++){ + data_type *dt = gb_tbl->get_data_type(g); + if(dt->is_temporal()){ + data_type *gdt = gb_tbl->get_data_type(g); + if(!gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\tt->last_flushed_gb_%d = t->flush_start_gb_%d;\n",g,g); + ret += tmpstr; + } + } + } + ret += "\t}\n}\n\n"; + + return(ret); +} + +// TODO Remove sprintf to perform string catenation +string generate_fta_load_params(string node_name){ + int p; + vector param_names = param_tbl->get_param_names(); + + string ret = "static int load_params_"+node_name+"(struct "+generate_fta_name(node_name); + ret += " *t, int sz, void *value, int initial_call){\n"; + ret += "\tint pos=0;\n"; + ret += "\tint data_pos;\n"; + + for(p=0;pget_data_type(param_names[p]); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t%s tmp_var_%s;\n",dt->get_cvar_type().c_str(), param_names[p].c_str() ); + ret += tmpstr; + sprintf(tmpstr,"\t%s access_var_%s;\n",dt->get_tuple_cvar_type().c_str(), param_names[p].c_str() ); + ret += tmpstr; + } + } + + + + ret += "\n\tdata_pos = "; + for(p=0;p0) ret += " + "; + data_type *dt = param_tbl->get_data_type(param_names[p]); + ret += "sizeof( "; + ret += dt->get_tuple_cvar_type(); + ret += " )"; + } + ret += ";\n"; + ret += "\tif(data_pos > sz) return 1;\n\n"; + + + for(p=0;pget_data_type(param_names[p]); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\taccess_var_%s = *( (%s *)((char *)value+pos) );\n",param_names[p].c_str(), dt->get_tuple_cvar_type().c_str() ); + ret += tmpstr; + switch( dt->get_type() ){ + case v_str_t: +// ret += "\ttmp_var_"+param_names[p]+".data = ntohl( tmp_var_"+param_names[p]+".data );\n"; // ntoh conversion +// ret += "\ttmp_var_"+param_names[p]+".length = ntohl( tmp_var_"+param_names[p]+".length );\n"; // ntoh conversion + sprintf(tmpstr,"\tif( (access_var_%s.offset) + access_var_%s.length > sz) return 1;\n",param_names[p].c_str(), param_names[p].c_str() ); + ret += tmpstr; + sprintf(tmpstr,"\ttmp_var_%s.data = (gs_sp_t)(value) + access_var_%s.offset ;\n",param_names[p].c_str(), param_names[p].c_str() ); + ret += tmpstr; + sprintf(tmpstr,"\ttmp_var_%s.length = access_var_%s.length ;\n",param_names[p].c_str(), param_names[p].c_str() ); + ret += tmpstr; + break; + default: + fprintf(stderr,"ERROR: parameter %s is of type %s, a buffered type, but I don't know how to unpack it as a parameter.\n",param_names[p].c_str(), dt->get_type_str().c_str() ); + exit(1); + break; + } +// First, destroy the old + ret += "\tif(! initial_call)\n"; + sprintf(tmpstr,"\t\t%s(&(t->param_%s));\n",dt->get_buffer_destroy().c_str(),param_names[p].c_str()); + ret += tmpstr; +// Next, create the new. + sprintf(tmpstr,"\t%s((struct FTA *)t, &(t->param_%s), &tmp_var_%s);\n", dt->get_buffer_assign_copy().c_str(), param_names[p].c_str(), param_names[p].c_str() ); + ret += tmpstr; + }else{ +// if(dt->needs_hn_translation()){ +// sprintf(tmpstr,"\tt->param_%s = %s( *( (%s *)( (char *)value+pos) ) );\n", +// param_names[p].c_str(), dt->ntoh_translation().c_str(), dt->get_cvar_type().c_str() ); +// }else{ + sprintf(tmpstr,"\tt->param_%s = *( (%s *)( (char *)value+pos) );\n", + param_names[p].c_str(), dt->get_cvar_type().c_str() ); +// } + ret += tmpstr; + } + sprintf(tmpstr,"\tpos += sizeof( %s );\n",dt->get_cvar_type().c_str() ); + ret += tmpstr; + } + +// Register the pass-by-handle parameters + + ret += "/* register and de-register the pass-by-handle parameters */\n"; + + int ph; + for(ph=0;phtype_name); + switch(param_handle_table[ph]->val_type){ + case cplx_lit_e: + break; + case litval_e: + break; + case param_e: + ret += "\tif(! initial_call)\n"; + sprintf(tmpstr, "\t\t%s(t->handle_param_%d);\n", + param_handle_table[ph]->lfta_deregistration_fcn().c_str(),ph); + ret += tmpstr; + sprintf(tmpstr,"\tt->handle_param_%d = %s((struct FTA *)t,",ph,param_handle_table[ph]->lfta_registration_fcn().c_str()); + ret += tmpstr; + + if(pdt.is_buffer_type()) ret += "&("; + ret += "t->param_"+param_handle_table[ph]->param_name; + if(pdt.is_buffer_type()) ret += ")"; + ret += ");\n"; + break; + default: + sprintf(tmpstr, "INTERNAL ERROR unknown case (%d) found when processing pass-by-handle parameter table.",param_handle_table[ph]->val_type); + fprintf(stderr,"%s\n",tmpstr); + ret+=tmpstr; + } + } + + ret+="\treturn 0;\n"; + ret += "}\n\n"; + + return(ret); +} + + + + +string generate_fta_free(string node_name, bool is_aggr_query){ + + string ret="static gs_retval_t free_fta_"+node_name+"(struct FTA *f, gs_uint32_t recursive){\n"; + ret+= "\tstruct "+generate_fta_name(node_name)+ + " * t = (struct "+generate_fta_name(node_name)+" *) f;\n"; + ret += "\tint i;\n"; + + if(is_aggr_query){ + ret+="\tfta_aggr_flush_old_" + node_name+"(f,t->max_aggrs);\n"; + ret+="\t/* \t\tmark all groups as old */\n"; + ret+="\tt->generation++;\n"; + ret+="\tt->flush_pos = 0;\n"; + ret+="\tfta_aggr_flush_old_" + node_name+"(f,t->max_aggrs);\n"; + } + +// Deregister the pass-by-handle parameters + ret += "/* de-register the pass-by-handle parameters */\n"; + int ph; + for(ph=0;phhandle_param_%d);\n", + param_handle_table[ph]->lfta_deregistration_fcn().c_str(),ph); + ret += tmpstr; + } + + + ret += "\treturn 0;\n}\n\n"; + return(ret); +} + + +string generate_fta_control(string node_name, table_list *schema, bool is_aggr_query){ + string ret="static gs_retval_t control_fta_"+node_name+"(struct FTA *f, gs_int32_t command, gs_int32_t sz, void *value){\n"; + ret += "\tstruct "+generate_fta_name(node_name)+" * t = (struct "; + ret += generate_fta_name(node_name)+" *) f;\n\n"; + ret+="\tint i;\n"; + + + ret += "\t/* temp status tuple */\n"; + ret += "\tstruct "+generate_tuple_name(node_name)+" *tuple;\n"; + ret += "\tgs_int32_t tuple_size;\n"; + + + if(is_aggr_query){ + ret+="\tif(command == FTA_COMMAND_FLUSH){\n"; + + ret+="\t\tif (!t->n_aggrs) {\n"; + ret+="\t\t\ttuple = allocate_tuple(f, 0);\n"; + ret+="\t\t\tif( tuple != NULL)\n"; + ret+="\t\t\t\tpost_tuple(tuple);\n"; + + ret+="\t\t}else{\n"; + + ret+="\t\t\tfta_aggr_flush_old_" + node_name+"(f,t->max_aggrs);\n"; + ret+="\t\t\t/* \t\tmark all groups as old */\n"; + ret +="\t\tt->generation++;\n"; + ret += "//\tmarking groups old should happen implicitly by advancing the generation.\n"; + ret+="//\t\t\tfor (i = 0; i < t->bitmap_size; ++i)\n"; + ret+="//\t\t\t\tt->aggr_table_bitmap[i] &= 0xAAAAAAAA;\n"; + ret+="\t\t\tt->flush_pos = 0;\n"; + ret+="\t\t\tfta_aggr_flush_old_" + node_name+"(f,t->max_aggrs);\n"; + ret+="\t\t}\n"; + + ret+="\t}\n"; + } + if(param_tbl->size() > 0){ + ret+= +"\tif(command == FTA_COMMAND_LOAD_PARAMS){\n" +"\t\tif(load_params_"+node_name+"(t, sz, value, 0))\n" +"#ifndef LFTA_IN_NIC\n" +"\t\t\tfprintf(stderr,\"WARNING: parameter passed to lfta "+node_name+" is too small, ignored.\\n\");\n" +"#else\n" +"\t\t{}\n" +"#endif\n" +"\t}\n"; + } + ret+= +"\tif(command == FTA_COMMAND_SET_SAMPLING_RATE){\n" +"\t\tmemcpy(&t->sampling_rate, value, sizeof(gs_float_t));\n" +"\t}\n\n"; + + + ret += "\tif(command == FTA_COMMAND_FILE_DONE ){\n"; + + if(is_aggr_query){ + ret+="\t\tif (t->n_aggrs) {\n"; + ret+="\t\t\tfta_aggr_flush_old_" + node_name+"(f,t->max_aggrs);\n"; + ret+="\t\t\t/* \t\tmark all groups as old */\n"; + ret +="\t\tt->generation++;\n"; + ret += "//\tmarking groups old should happen implicitly by advancing the generation.\n"; + ret+="//\t\t\tfor (i = 0; i < t->bitmap_size; ++i)\n"; + ret+="//\t\t\t\tt->aggr_table_bitmap[i] &= 0xAAAAAAAA;\n"; + ret+="\t\t\tt->flush_pos = 0;\n"; + ret+="\t\t\tfta_aggr_flush_old_" + node_name+"(f,t->max_aggrs);\n"; + ret+="\t\t}\n"; + } + + ret += "\t\ttuple_size = sizeof( struct "+generate_tuple_name(node_name)+");\n"; + ret += "\t\ttuple = allocate_tuple(f, tuple_size );\n"; + ret += "\t\tif( tuple == NULL)\n\t\treturn 1;\n"; + + /* mark tuple as EOF_TUPLE */ + ret += "\n\t\t/* Mark tuple as eof_tuple */\n"; + ret += "\t\ttuple->tuple_type = EOF_TUPLE;\n"; + ret += "\t\tpost_tuple(tuple);\n"; + ret += "\t}\n"; + + ret += "\treturn 0;\n}\n\n"; + + return(ret); +} + +string generate_fta_clock(string node_name, table_list *schema, unsigned time_corr, bool is_aggr_query){ + string ret="static gs_retval_t clock_fta_"+node_name+"(struct FTA *f){\n"; + ret += "\tstruct "+generate_fta_name(node_name)+" * t = (struct "; + ret += generate_fta_name(node_name)+" *) f;\n\n"; + + ret += "\t/* Create a temp status tuple */\n"; + ret += "\tstruct "+generate_tuple_name(node_name)+" *tuple;\n"; + ret += "\tgs_int32_t tuple_size;\n"; + ret += "\tunsigned int i;\n"; + ret += "\ttime_t cur_time;\n"; + ret += "\tint time_advanced;\n"; + ret += "\tstruct fta_stat stats;\n"; + + + + /* copy the last seen values of temporal attributes */ + col_id_set temp_cids; // col ids of temp attributes in select clause + + + /* HACK: in order to reuse the SE generation code, we need to copy + * the last values of the temp attributes into new variables + * which have names unpack_var_XXX_XXX + */ + + int s, g; + col_id_set::iterator csi; + + for(s=0;sget_data_type(); + if (sdt->is_temporal()) { + gather_se_col_ids(sl_list[s],temp_cids, gb_tbl); + } + } + + for(csi=temp_cids.begin(); csi != temp_cids.end();++csi){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field), schema->get_modifier_list(schref,field)); + sprintf(tmpstr,"\t%s unpack_var_%s_%d;\n", dt.get_cvar_type().c_str(), field.c_str(), tblref); + ret += tmpstr; + } + + if (is_aggr_query) { + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_temporal()){ + sprintf(tmpstr,"\t%s gb_attr_%d;\n",gb_tbl->get_data_type(g)->get_cvar_type().c_str(),g); + ret += tmpstr; + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t%s gb_attr_tmp%d;\n",gb_tbl->get_data_type(g)->get_cvar_type().c_str(),g); + ret += tmpstr; + } + } + } + } + ret += "\n"; + + ret += "\ttime_advanced = 0;\n"; + + for(csi=temp_cids.begin(); csi != temp_cids.end();++csi){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field), schema->get_modifier_list(schref,field)); + + // update last seen value with the value seen + ret += "\t#ifdef PREFILTER_DEFINED\n"; + sprintf(tmpstr,"\tif (prefilter_temp_vars.unpack_var_%s_%d > t->last_%s_%d) {\n\t\tt->last_%s_%d = prefilter_temp_vars.unpack_var_%s_%d;\n", + field.c_str(), tblref, field.c_str(), tblref, field.c_str(), tblref, field.c_str(), tblref); + ret += tmpstr; + ret += "\t\ttime_advanced = 1;\n\t}\n"; + ret += "\t#endif\n"; + + // we need to pay special attention to time fields + if (field == "time" || field == "timestamp"){ + ret += "\tcur_time = time(&cur_time);\n"; + + if (field == "time") { + sprintf(tmpstr,"\tif (!gscp_blocking_mode() && (t->last_time_%d < (cur_time - %d))) {\n", + tblref, time_corr); + ret += tmpstr; + sprintf(tmpstr,"\t\tunpack_var_%s_%d = t->last_%s_%d = cur_time - %d;\n", + field.c_str(), tblref, field.c_str(), tblref, time_corr); + } else { + sprintf(tmpstr,"\tif (!gscp_blocking_mode() && ((gs_uint32_t)(t->last_%s_%d>>32) < (cur_time - %d))) {\n", + field.c_str(), tblref, time_corr); + ret += tmpstr; + sprintf(tmpstr,"\t\tunpack_var_%s_%d = t->last_%s_%d = ((gs_uint64_t)(cur_time - %d))<<32;\n", + field.c_str(), tblref, field.c_str(), tblref, time_corr); + } + ret += tmpstr; + + ret += "\t\ttime_advanced = 1;\n"; + ret += "\t}\n"; + + sprintf(tmpstr,"\telse\n\t\tunpack_var_%s_%d = t->last_%s_%d;\n", + field.c_str(), tblref, field.c_str(), tblref); + ret += tmpstr; + } else { + sprintf(tmpstr,"\tunpack_var_%s_%d = t->last_%s_%d;\n", + field.c_str(), tblref, field.c_str(), tblref); + ret += tmpstr; + } + } + + // for aggregation lftas we need to check if the time was advanced beyond the current epoch + if (is_aggr_query) { + + string change_test; + bool first_one = true; + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_temporal()){ +// To perform the test, first need to compute the value +// of the temporal gb attrs. + if(gdt->is_buffer_type()){ + // NOTE : if the SE defining the gb is anything + // other than a ref to a variable, this will generate + // illegal code. To be resolved with Spatch. + sprintf(tmpstr,"\tgb_attr_tmp%d = %s;\n", + g, generate_se_code(gb_tbl->get_def(g),schema).c_str() ); + ret+=tmpstr; + sprintf(tmpstr,"\t%s(f, &gb_attr_%d, &gb_attr_tmp%d);\n", + gdt->get_buffer_assign_copy().c_str(), g, g); + }else{ + sprintf(tmpstr,"\tgb_attr_%d = %s;\n",g,generate_se_code(gb_tbl->get_def(g),schema).c_str()); + } + ret += tmpstr; + + sprintf(tmpstr,"t->last_gb_%d",g); string lhs_op = tmpstr; + sprintf(tmpstr,"gb_attr_%d",g); string rhs_op = tmpstr; + if(first_one){first_one = false;} else {change_test.append(") && (");} + change_test.append(generate_equality_test(lhs_op, rhs_op, gdt)); + } + } + + ret += "\n\tif( time_advanced && !( ("; + ret += change_test; + ret += ") ) ){\n"; + + ret += "\n/*\t\tFlush the aggregates if the temporal gb attrs have changed.\t*/\n"; + ret += "\t\tif(t->flush_posmax_aggrs) \n"; + ret += "\t\t\tfta_aggr_flush_old_"+node_name+"(f,t->max_aggrs);\n"; + + ret += "\t\t/* \t\tmark all groups as old */\n"; + ret +="\t\tt->generation++;\n"; + ret += "//\tmarking groups old should happen implicitly by advancing the generation.\n"; + ret += "//\t\tfor (i = 0; i < t->bitmap_size; ++i)\n"; + ret += "//\t\t\tt->aggr_table_bitmap[i] &= 0xAAAAAAAA;\n"; + ret += "\t\tt->flush_pos = 0;\n"; + + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_temporal()){ + sprintf(tmpstr,"\t\tt->flush_start_gb_%d = gb_attr_%d;\n",g,g); ret += tmpstr; + sprintf(tmpstr,"\t\tt->last_gb_%d = gb_attr_%d;\n",g,g); ret += tmpstr; + } + } + ret += "\t}\n\n"; + + } + + ret += "\ttuple_size = sizeof( struct "+generate_tuple_name(node_name)+") + sizeof(gs_uint64_t) + sizeof(struct fta_stat);\n"; + ret += "\ttuple = allocate_tuple(f, tuple_size );\n"; + ret += "\tif( tuple == NULL)\n\t\treturn 1;\n"; + + + for(s=0;sget_data_type(); + if(sdt->is_temporal()){ + + if (sl_list[s]->is_gb()) { + sprintf(tmpstr,"\tt->last_flushed_gb_%d = (t->n_aggrs) ? t->last_flushed_gb_%d : %s;\n",sl_list[s]->get_gb_ref(), sl_list[s]->get_gb_ref(), generate_se_code(sl_list[s],schema).c_str()); + ret += tmpstr; + } + + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret += tmpstr; +// if(sdt->needs_hn_translation()) +// ret += sdt->hton_translation() +"( "; + if (sl_list[s]->is_gb()) { + sprintf(tmpstr, "t->last_flushed_gb_%d",sl_list[s]->get_gb_ref()); + ret += tmpstr; + } else{ + ret += generate_se_code(sl_list[s],schema); + } +// if(sdt->needs_hn_translation()) +// ret += " )"; + ret += ";\n"; + } + } + + /* mark tuple as temporal */ + ret += "\n\t/* Mark tuple as temporal */\n"; + ret += "\ttuple->tuple_type = TEMPORAL_TUPLE;\n"; + + ret += "\n\t/* Copy trace id */\n"; + ret += "\tmemcpy((gs_sp_t)tuple+sizeof( struct "+generate_tuple_name(node_name)+"), &t->trace_id, sizeof(gs_uint64_t));\n\n"; + + ret += "\n\t/* Populate runtime stats */\n"; + ret += "\tstats.ftaid = f->ftaid;\n"; + ret += "\tstats.in_tuple_cnt = t->in_tuple_cnt;\n"; + ret += "\tstats.out_tuple_cnt = t->out_tuple_cnt;\n"; + ret += "\tstats.out_tuple_sz = t->out_tuple_sz;\n"; + ret += "\tstats.accepted_tuple_cnt = t->accepted_tuple_cnt;\n"; + ret += "\tstats.cycle_cnt = t->cycle_cnt;\n"; + ret += "\tstats.collision_cnt = t->collision_cnt;\n"; + ret += "\tstats.eviction_cnt = t->eviction_cnt;\n"; + ret += "\tstats.sampling_rate = t->sampling_rate;\n"; + + ret += "\n#ifdef LFTA_PROFILE\n"; + ret += "\n\t/* Print stats */\n"; + ret += "\tfprintf(stderr, \"STATS " + node_name + " \");\n"; + ret += "\tfprintf(stderr, \"in_tuple_cnt= %u \", t->in_tuple_cnt);\n"; + ret += "\tfprintf(stderr, \"out_tuple_cnt= %u \", t->out_tuple_cnt);\n"; + ret += "\tfprintf(stderr, \"out_tuple_sz= %u \", t->out_tuple_sz);\n"; + ret += "\tfprintf(stderr, \"accepted_tuple_cnt= %u \", t->accepted_tuple_cnt);\n"; + ret += "\tfprintf(stderr, \"cycle_cnt= %llu \", t->cycle_cnt);\n"; + ret += "\tfprintf(stderr, \"cycle_per_in_tuple= %lf \", ((double)t->cycle_cnt)/((double)t->in_tuple_cnt));\n"; + ret += "\tfprintf(stderr, \"collision_cnt= %d\\n\", t->collision_cnt);\n\n"; + ret += "\tfprintf(stderr, \"eviction_cnt= %d\\n\", t->eviction_cnt);\n\n"; + ret += "\n#endif\n"; + + + ret += "\n\t/* Copy stats */\n"; + ret += "\tmemcpy((gs_sp_t)tuple+sizeof( struct "+generate_tuple_name(node_name)+") + sizeof(gs_uint64_t), &stats, sizeof(fta_stat));\n\n"; + ret+="\tpost_tuple(tuple);\n"; + + ret += "\n\t/* Send a heartbeat message to clearinghouse */\n"; + ret += "\tfta_heartbeat(f->ftaid, t->trace_id++, 1, &stats);\n"; + + ret += "\n\t/* Reset runtime stats */\n"; + ret += "\tt->in_tuple_cnt = 0;\n"; + ret += "\tt->out_tuple_cnt = 0;\n"; + ret += "\tt->out_tuple_sz = 0;\n"; + ret += "\tt->accepted_tuple_cnt = 0;\n"; + ret += "\tt->cycle_cnt = 0;\n"; + ret += "\tt->collision_cnt = 0;\n"; + ret += "\tt->eviction_cnt = 0;\n"; + + ret += "\treturn 0;\n}\n\n"; + + return(ret); +} + + +// accept processing before the where clause, +// do flush processwing. +string generate_aggr_accept_prelim(qp_node *fs, string node_name, table_list *schema, col_id_set &unpacked_cids, string &temporal_flush){ + int s; + +// Slow flush + string ret="\n/*\tslow flush\t*/\n"; + string slow_flush_str = fs->get_val_of_def("slow_flush"); + int n_slow_flush = atoi(slow_flush_str.c_str()); + if(n_slow_flush <= 0) n_slow_flush = 2; + if(n_slow_flush > 1){ + ret += "\tt->flush_ctr++;\n"; + ret += "\tif(t->flush_ctr >= "+int_to_string(n_slow_flush)+"){\n"; + ret += "\t\tt->flush_ctr = 0;\n"; + ret+="\t\tif(t->flush_posmax_aggrs) fta_aggr_flush_old_"+node_name+"(f,1);\n"; + ret += "\t}\n\n"; + }else{ + ret+="\tif(t->flush_posmax_aggrs) fta_aggr_flush_old_"+node_name+"(f,1);\n\n"; + } + + + string change_test; + bool first_one = true; + int g; + col_id_set flush_cids; // col ids accessed when computing flush variables. + // unpack them at temporal flush test time. + temporal_flush = ""; + + + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_temporal()){ + gather_se_col_ids(gb_tbl->get_def(g), flush_cids, gb_tbl); + +// To perform the test, first need to compute the value +// of the temporal gb attrs. + if(gdt->is_buffer_type()){ + // NOTE : if the SE defining the gb is anything + // other than a ref to a variable, this will generate + // illegal code. To be resolved with Spatch. + sprintf(tmpstr,"\tgb_attr_tmp%d = %s;\n", + g, generate_se_code(gb_tbl->get_def(g),schema).c_str() ); + temporal_flush += tmpstr; + sprintf(tmpstr,"\t%s(f, &gb_attr_%d, &gb_attr_tmp%d);\n", + gdt->get_buffer_assign_copy().c_str(), g, g); + }else{ + sprintf(tmpstr,"\tgb_attr_%d = %s;\n",g,generate_se_code(gb_tbl->get_def(g),schema).c_str()); + } + temporal_flush += tmpstr; +// END computing the value of the temporal GB attr. + + + sprintf(tmpstr,"t->last_gb_%d",g); string lhs_op = tmpstr; + sprintf(tmpstr,"gb_attr_%d",g); string rhs_op = tmpstr; + if(first_one){first_one = false;} else {change_test.append(") && (");} + change_test += generate_equality_test(lhs_op, rhs_op, gdt); + } + } + if(!first_one){ // will be false iff. there is a temporal GB attribute + temporal_flush += "\n/*\t\tFlush the aggregates if the temporal gb attrs have changed.\t*/\n"; + temporal_flush += "\tif( !( ("; + temporal_flush += change_test; + temporal_flush += ") ) ){\n"; + +// temporal_flush+="\t\tif(t->flush_posmax_aggrs) fta_aggr_flush_old_"+node_name+"(f,t->max_aggrs);\n"; + temporal_flush+="\t\tif(t->flush_posmax_aggrs){ \n"; + temporal_flush+="\t\t\tfta_aggr_flush_old_"+node_name+"(f,t->max_aggrs);\n"; + temporal_flush+="\t\t}\n"; + temporal_flush+="\t\t/* \t\tmark all groups as old */\n"; + temporal_flush+="\t\tt->generation++;\n"; + temporal_flush+="\t\tt->flush_pos = 0;\n"; + + +// Now set the saved temporal value of the gb to the +// current value of the gb. Only for simple types, +// not for buffer types -- but the strings are not +// temporal in any case. + + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_temporal()){ + if(gdt->is_buffer_type()){ + + fprintf(stderr,"ERROR : can't handle temporal buffer types, ignoring in buffer flush control.\n"); + }else{ + sprintf(tmpstr,"\t\tt->flush_start_gb_%d = gb_attr_%d;\n",g,g); + temporal_flush += tmpstr; + sprintf(tmpstr,"\t\tt->last_gb_%d = gb_attr_%d;\n",g,g); + temporal_flush += tmpstr; + } + } + } + temporal_flush += "\t}\n\n"; + } + +// Unpack all the temporal attributes referenced in select clause +// and update the last value of the attribute + col_id_set temp_cids; // col ids of temp attributes in select clause + col_id_set::iterator csi; + + for(s=0;sget_data_type(); + if (sdt->is_temporal()) { + gather_se_col_ids(sl_list[s],temp_cids, gb_tbl); + } + } + + for(csi=temp_cids.begin(); csi != temp_cids.end();++csi){ + if(unpacked_cids.count((*csi)) == 0){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name); +/* + data_type dt(schema->get_type_name(schref,field), schema->get_modifier_list(schref,field)); + sprintf(tmpstr,"\tretval = %s(p, &unpack_var_%s_%d);\n", + schema->get_fcn(schref,field).c_str(), field.c_str(), tblref); + ret += tmpstr; + ret += "\tif(retval) return 1;\n"; +*/ + sprintf(tmpstr,"\tt->last_%s_%d = unpack_var_%s_%d;\n", field.c_str(), tblref, field.c_str(), tblref); + ret += tmpstr; + + unpacked_cids.insert( (*csi) ); + } + } + + +// Do the flush here if this is a real_time query + string rt_level = fs->get_val_of_def("real_time"); + if(rt_level != "" && temporal_flush != ""){ + for(csi=flush_cids.begin(); csi != flush_cids.end();++csi){ + if(unpacked_cids.count((*csi)) == 0){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name); +/* + sprintf(tmpstr,"\tretval = %s(p, &unpack_var_%s_%d);\n", + schema->get_fcn(schref,field).c_str(), field.c_str(), tblref); + ret += tmpstr; + ret += "\tif(retval) return 1;\n"; +*/ + unpacked_cids.insert( (*csi) ); + } + } + ret += temporal_flush; + } + + return ret; + } + +string generate_sel_accept_body(qp_node *fs, string node_name, table_list *schema){ + +int p,s; +string ret; + +/////////////// Processing for filter-only query + +// test passed : create the tuple, then assign to it. + ret += "/*\t\tCreate and post the tuple\t*/\n"; + +// Unpack partial fcns ref'd by the select clause. +// Its a kind of a WHERE clause ... + for(p=sl_fcns_start;p 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string(p)+"==0){\n"; + } + if(is_partial_fcn[p]){ + ret += unpack_partial_fcn(partial_fcns[p], p, schema); + ret += "\tif(retval) goto end;\n"; + } + if(fcn_ref_cnt[p] > 1){ + if(!is_partial_fcn[p]){ + ret += "\t\tpartial_fcn_result_"+int_to_string(p)+"="+generate_cached_fcn(partial_fcns[p],schema)+";\n"; + } + ret += "\t\tfcn_ref_cnt_"+int_to_string(p)+"=1;\n"; + ret += "\t}\n"; + } + } + + // increment the counter of accepted tuples + ret += "\n\t#ifdef LFTA_STATS\n"; + ret += "\n\tt->accepted_tuple_cnt++;\n\n"; + ret += "\t#endif\n\n"; + +// First, compute the size of the tuple. + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. + + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\tselvar_%d = ",s); + ret += tmpstr; + ret += generate_se_code(sl_list[s],schema); + ret += ";\n"; + } + } + + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + ret+="\ttuple_size = sizeof( struct "+generate_tuple_name(node_name)+")"; + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr," + %s(&selvar_%d)", sdt->get_buffer_size().c_str(),s); + ret += tmpstr; + } + } + ret += ";\n"; + + + ret += "\ttuple = allocate_tuple(f, tuple_size );\n"; + ret += "\tif( tuple == NULL)\n\t\tgoto end;\n"; + +// Test passed, make assignments to the tuple. + + ret += "\ttuple_pos = sizeof( struct "+generate_tuple_name(node_name)+");\n"; + +// Mark tuple as REGULAR_TUPLE + ret += "\ttuple->tuple_type = REGULAR_TUPLE;\n"; + + + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &selvar_%d, (char *)tuple, ((char *)tuple)+tuple_pos);\n", sdt->get_buffer_tuple_copy().c_str(),s, s); + ret += tmpstr; + sprintf(tmpstr,"\ttuple_pos += %s(&selvar_%d);\n", sdt->get_buffer_size().c_str(), s); + ret += tmpstr; + }else{ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret += tmpstr; +// if(sdt->needs_hn_translation()) +// ret += sdt->hton_translation() +"( "; + ret += generate_se_code(sl_list[s],schema); +// if(sdt->needs_hn_translation()) +// ret += ") "; + ret += ";\n"; + } + } + +// Generate output. + + ret += "\tpost_tuple(tuple);\n"; + +// Increment the counter of posted tuples + ret += "\n\t#ifdef LFTA_STATS\n"; + ret += "\tt->out_tuple_cnt++;\n"; + ret+="\tt->out_tuple_sz+=tuple_size;\n"; + ret += "\t#endif\n\n"; + + + + return ret; +} + +string generate_fj_accept_body(filter_join_qpn *fs, string node_name,col_id_set &unpacked_cids,ext_fcn_list *Ext_fcns, table_list *schema){ + +int p,s,w; +string ret; + +// Get parameters + unsigned int window_len = fs->temporal_range; + unsigned int n_bloom = 11; + string n_bloom_str = fs->get_val_of_def("num_bloom"); + int tmp_n_bloom = atoi(n_bloom_str.c_str()); + if(tmp_n_bloom>0) + n_bloom = tmp_n_bloom+1; + float bloom_width = (window_len+1.0)/(1.0*n_bloom-1); + sprintf(tmpstr,"%f",bloom_width); + string bloom_width_str = tmpstr; + + if(window_len < n_bloom){ + n_bloom = window_len+1; + bloom_width_str = "1"; + } + + +// Grab the current window time + scalarexp_t winvar(fs->temporal_var); + ret += "\tcurr_fj_ts = "+generate_se_code(&winvar,schema)+";\n"; + + int bf_exp_size = 12; // base-2 log of number of bits + string bloom_len_str = fs->get_val_of_def("bloom_size"); + int tmp_bf_exp_size = atoi(bloom_len_str.c_str()); + if(tmp_bf_exp_size > 3 && tmp_bf_exp_size < 32){ + bf_exp_size = tmp_bf_exp_size; + } + int bf_bit_size = 1 << bf_exp_size; + int bf_byte_size = bf_bit_size / (8*sizeof(char)); + + unsigned int ht_size = 4096; + string ht_size_s = fs->get_val_of_def("aggregate_slots"); + int tmp_ht_size = atoi(ht_size_s.c_str()); + if(tmp_ht_size > 1024){ + unsigned int hs = 1; // make it power of 2 + while(tmp_ht_size){ + hs =hs << 1; + tmp_ht_size = tmp_ht_size >> 1; + } + ht_size = hs; + } + + int i, bf_mask = 0; + if(fs->use_bloom){ + for(i=0;i1;i=i>>1) + bf_mask = (bf_mask << 1) | 1; + } + +/* +printf("n_bloom=%d, window_len=%d, bloom_width=%s, bf_exp_size=%d, bf_bit_size=%d, bf_byte_size=%d, ht_size=%d, ht_size_s=%s, bf_mask=%d\n", + n_bloom, + window_len, + bloom_width_str.c_str(), + bf_exp_size, + bf_bit_size, + bf_byte_size, + ht_size, + ht_size_s.c_str(), + bf_mask); +*/ + + + + +// If this is a bloom-filter fj, first test if the +// bloom filter needs to be advanced. +// SET_BF_EMPTY(table,number of bloom filters,bloom filter index,bit index) +// t->bf_size : number of bits in bloom filter + if(fs->use_bloom){ + ret += +"// Clean out old bloom filters if needed.\n" +" if(t->first_exec){\n" +" t->first_exec = 0;\n" +" t->last_bin = (long long int)(curr_fj_ts/"+bloom_width_str+");\n" +" t->last_bloom_pos = t->last_bin % "+int_to_string(n_bloom)+";\n" +" }else{\n" +" curr_bin = (long long int)(curr_fj_ts/"+bloom_width_str+");\n" +" if(curr_bin != t->last_bin){\n" +" for(the_bin=t->last_bin+1;the_bin<=curr_bin;the_bin++){\n" +" t->last_bloom_pos++;\n" +" if(t->last_bloom_pos >= "+int_to_string(n_bloom)+")\n" +" t->last_bloom_pos = 0;\n" +" tmp_i = t->last_bloom_pos;\n" +" for(j=0;j<"+int_to_string(bf_bit_size)+";j++){\n" +" SET_BF_EMPTY(t->bf_table, "+int_to_string(n_bloom)+", tmp_i,j);\n" +" }\n" +" }\n" +" }\n" +" t->last_bin = curr_bin;\n" +" }\n" +; + } + + +//----------------------------------------------------------------- +// First, determine whether to do S (filter stream) processing. + + ret += +"// S (filtering stream) predicate, should it be processed?\n" +"\n" +; +// Sort S preds based on cost. + vector s_filt = fs->pred_t1; + col_id_set::iterator csi; + if(s_filt.size() > 0){ + +// Unpack fields ref'd in the S pred + for(w=0;wpr, this_pred_cids, gb_tbl); + for(csi=this_pred_cids.begin();csi!=this_pred_cids.end();++csi){ + if(unpacked_cids.count( (*csi) ) == 0){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name,"end_s"); + unpacked_cids.insert( (*csi) ); + } + } + } + + +// Sort by evaluation cost. +// First, estimate evaluation costs +// Eliminate predicates covered by the prefilter (those in s_pids). +// I need to do it before the sort becuase the indices refer +// to the position in the unsorted list. + vector tmp_wh; + for(w=0;wcost); + ret += tmpstr; + +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(s_filt[w]->pr, pfcn_refs); +// Since set<..> is a "Sorted Associative Container", +// we can walk through it in sorted order by walking from +// begin() to end(). (and the partial fcns must be +// evaluated in this order). + set::iterator si; + string pf_preds; + for(si=pfcn_refs.begin();si!=pfcn_refs.end();++si){ + if(fcn_ref_cnt[(*si)] > 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string((*si))+"==0){\n"; + } + if(is_partial_fcn[(*si)]){ + ret += "\t"+unpack_partial_fcn(partial_fcns[(*si)], (*si), schema); + ret += "\t\tif(retval) goto end_s;\n"; + } + if(fcn_ref_cnt[(*si)] > 1){ + if(!is_partial_fcn[(*si)]){ + ret += "\t\tpartial_fcn_result_"+int_to_string((*si))+"="+generate_cached_fcn(partial_fcns[(*si)],schema)+";\n"; +// Testing for S is a side branch. +// I don't want a cacheable partial function to be +// marked as evaluated. Therefore I mark the function +// as evalauted ONLY IF it is not partial. + ret += "\t\tfcn_ref_cnt_"+int_to_string((*si))+"=1;\n"; + } + ret += "\t}\n"; + } + } + + ret += "\tif( !("+generate_predicate_code(s_filt[w]->pr,schema)+ + ") ) goto end_s;\n"; + } + }else{ + ret += "\n\n/*\t\t (no predicate to test)\t*/\n\n"; + } + + for(p=0;phash_eq.size();++p) + ret += "\t\ts_equijoin_"+int_to_string(p)+" = "+generate_se_code(fs->hash_eq[p]->pr->get_right_se(),schema)+";\n"; + + if(fs->use_bloom){ +// First, generate the S scalar expressions in the hash_eq + +// Iterate over the bloom filters + for(i=0;i<3;i++){ + ret += "\t\tbucket=0;\n"; + for(p=0;phash_eq.size();++p){ + ret += +" bucket ^= (("+hash_nums[(i*fs->hash_eq.size()+p)%NRANDS]+" * lfta_"+ + fs->hash_eq[p]->pr->get_right_se()->get_data_type()->get_type_str()+ + +"_to_hash(s_equijoin_"+int_to_string(p)+"))>>32);\n"; + } +// SET_BF_BIT(table,number of bloom filters,bloom filter index,bit index) + ret += +" bucket &= "+int_to_string(bf_mask)+";\n" +" SET_BF_BIT(t->bf_table,"+int_to_string(n_bloom)+",t->last_bloom_pos,bucket);\n" +"\n" +; + } + }else{ + ret += "\t\tbucket=0;\n"; + for(p=0;phash_eq.size();++p){ + ret += +" bucket ^= (("+hash_nums[(i*fs->hash_eq.size()+p)%NRANDS]+" * lfta_"+ + fs->hash_eq[p]->pr->get_right_se()->get_data_type()->get_type_str()+ + +"_to_hash(s_equijoin_"+int_to_string(p)+"))>>32);\n"; + } + ret += +" bucket &= "+int_to_string(bf_mask)+";\n" +" bucket1 = (bucket + 1) & "+int_to_string(bf_mask)+";\n" +; +// Try the first bucket + ret += "\t\tif("; + for(p=0;phash_eq.size();++p){ + if(p>0) ret += " && "; +// ret += "t->join_table[bucket].key_var"+int_to_string(p)+ +// " == s_equijoin_"+int_to_string(p); + data_type *hdt = fs->hash_eq[p]->pr->get_right_se()->get_data_type(); + string lhs_op = "t->join_table[bucket].key_var"+int_to_string(p); + string rhs_op = "s_equijoin_"+int_to_string(p); + ret += generate_equality_test(lhs_op,rhs_op,hdt); + } + ret += "){\n\t\t\tthe_bucket = bucket;\n"; + ret += "\t\t}else {if("; + for(p=0;phash_eq.size();++p){ + if(p>0) ret += " && "; +// ret += "t->join_table[bucket1].key_var"+int_to_string(p)+ +// " == s_equijoin_"+int_to_string(p); + data_type *hdt = fs->hash_eq[p]->pr->get_right_se()->get_data_type(); + string lhs_op = "t->join_table[bucket].key_var"+int_to_string(p); + string rhs_op = "s_equijoin_"+int_to_string(p); + ret += generate_equality_test(lhs_op,rhs_op,hdt); + } + ret += "){\n\t\t\tthe_bucket = bucket1;\n"; + ret += "\t\t}else{ if(t->join_table[bucket].ts <= t->join_table[bucket1].ts)\n"; + ret+="\t\t\tthe_bucket = bucket;\n\t\t\telse the_bucket=bucket1;\n"; + ret += "\t\t}}\n"; + for(p=0;phash_eq.size();++p){ + data_type *hdt = fs->hash_eq[p]->pr->get_right_se()->get_data_type(); + if(hdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(f, &(t->join_table[the_bucket].key_var%d), &s_equijoin_%d);\n", hdt->get_buffer_assign_copy().c_str(), p, p); + ret += tmpstr; + }else{ + ret += "\t\tt->join_table[the_bucket].key_var"+int_to_string(p)+ + " = s_equijoin_"+int_to_string(p)+";\n"; + } + } + ret+="\t\tt->join_table[the_bucket].ts = curr_fj_ts;\n"; + } + ret += "\tend_s:\n"; + +// ------------------------------------------------------------ +// Next, determine if the R record should be processed. + + + ret += +"// R (main stream) cheap predicate\n" +"\n" +; + +// Unpack r_filt fields + vector r_filt = fs->pred_t0; + for(w=0;wpr, this_pred_cids, gb_tbl); + for(csi=this_pred_cids.begin();csi!=this_pred_cids.end();++csi){ + if(unpacked_cids.count( (*csi) ) == 0){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name); + unpacked_cids.insert( (*csi) ); + } + } + } + +// Sort S preds based on cost. + + vector tmp_wh; + for(w=0;wcost <= 20;cheap_rpos++) + +// Test the cheap filters on R. + if(cheap_rpos >0){ + +// Now generate the predicates. + for(w=0;wcost); + ret += tmpstr; + +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(r_filt[w]->pr, pfcn_refs); +// Since set<..> is a "Sorted Associative Container", +// we can walk through it in sorted order by walking from +// begin() to end(). (and the partial fcns must be +// evaluated in this order). + set::iterator si; + for(si=pfcn_refs.begin();si!=pfcn_refs.end();++si){ + if(fcn_ref_cnt[(*si)] > 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string((*si))+"==0){\n"; + } + if(is_partial_fcn[(*si)]){ + ret += "\t"+unpack_partial_fcn(partial_fcns[(*si)], (*si), schema); + ret += "\t\tif(retval) goto end;\n"; + } + if(fcn_ref_cnt[(*si)] > 1){ + if(!is_partial_fcn[(*si)]){ + ret += "\t\tpartial_fcn_result_"+int_to_string((*si))+"="+generate_cached_fcn(partial_fcns[(*si)],schema)+";\n"; + } + ret += "\t\tfcn_ref_cnt_"+int_to_string((*si))+"=1;\n"; + ret += "\t}\n"; + } + } + + ret += "\tif( !("+generate_predicate_code(r_filt[w]->pr,schema)+ + ") ) goto end;\n"; + } + }else{ + ret += "\n\n/*\t\t (no predicate to test)\t*/\n\n"; + } + + ret += "\n// Do the join\n\n"; + for(p=0;phash_eq.size();++p) + ret += "\t\tr_equijoin_"+int_to_string(p)+" = "+generate_se_code(fs->hash_eq[p]->pr->get_left_se(),schema)+";\n"; + + +// Passed the cheap pred, now test the join with S. + if(fs->use_bloom){ + for(i=0;i<3;i++){ + ret += "\t\tbucket"+int_to_string(i)+"=0;\n"; + for(p=0;phash_eq.size();++p){ + ret += +" bucket"+int_to_string(i)+ + " ^= (("+hash_nums[(i*fs->hash_eq.size()+p)%NRANDS]+" * lfta_"+ + fs->hash_eq[p]->pr->get_right_se()->get_data_type()->get_type_str()+ + +"_to_hash(r_equijoin_"+int_to_string(p)+"))>>32);\n"; + } + ret += +" bucket"+int_to_string(i)+" &= "+int_to_string(bf_mask)+";\n"; + } + ret += "\tfound = 0;\n"; + ret += "\tfor(b=0;b<"+int_to_string(n_bloom)+" && !found; b++){\n"; + ret += +"\t\tif(IS_BF_SET(t->bf_table,"+int_to_string(n_bloom)+",t->last_bloom_pos,bucket0) && " +"IS_BF_SET(t->bf_table,"+int_to_string(n_bloom)+",t->last_bloom_pos,bucket1) && " +"IS_BF_SET(t->bf_table,"+int_to_string(n_bloom)+",t->last_bloom_pos,bucket2))\n " +"\t\t\tfound=1;\n" +"\t}\n" +; + ret += +" if(!found)\n" +" goto end;\n" +; + }else{ + ret += "\tfound = 0;\n"; + ret += "\t\tbucket=0;\n"; + for(p=0;phash_eq.size();++p){ + ret += +" bucket ^= (("+hash_nums[(i*fs->hash_eq.size()+p)%NRANDS]+" * lfta_"+ + fs->hash_eq[p]->pr->get_right_se()->get_data_type()->get_type_str()+ + +"_to_hash(r_equijoin_"+int_to_string(p)+"))>>32);\n"; + } + ret += +" bucket &= "+int_to_string(bf_mask)+";\n" +" bucket1 = (bucket + 1) & "+int_to_string(bf_mask)+";\n" +; +// Try the first bucket + ret += "\t\tif("; + for(p=0;phash_eq.size();++p){ + if(p>0) ret += " && "; +// ret += "t->join_table[bucket].key_var"+int_to_string(p)+ +// " == r_equijoin_"+int_to_string(p); + data_type *hdt = fs->hash_eq[p]->pr->get_right_se()->get_data_type(); + string lhs_op = "t->join_table[bucket].key_var"+int_to_string(p); + string rhs_op = "s_equijoin_"+int_to_string(p); + ret += generate_equality_test(lhs_op,rhs_op,hdt); + } + if(p>0) ret += " && "; + ret += "t->join_table[bucket].ts+"+int_to_string(fs->temporal_range)+" <= curr_fj_ts"; + ret += "){\n\t\t\tfound = 1;\n"; + ret += "\t\t}else {if("; + for(p=0;phash_eq.size();++p){ + if(p>0) ret += " && "; +// ret += "t->join_table[bucket1].key_var"+int_to_string(p)+ +// " == r_equijoin_"+int_to_string(p); + data_type *hdt = fs->hash_eq[p]->pr->get_right_se()->get_data_type(); + string lhs_op = "t->join_table[bucket].key_var"+int_to_string(p); + string rhs_op = "s_equijoin_"+int_to_string(p); + ret += generate_equality_test(lhs_op,rhs_op,hdt); + } + if(p>0) ret += " && "; + ret += "t->join_table[bucket1].ts+"+int_to_string(fs->temporal_range)+" <= curr_fj_ts"; + ret += ")\n\t\t\tfound=1;\n"; + ret+="\t\t}\n"; + ret += +" if(!found)\n" +" goto end;\n" +; + } + + +// Test the expensive filters on R. + if(cheap_rpos < r_filt.size()){ + +// Now generate the predicates. + for(w=cheap_rpos;wcost); + ret += tmpstr; + +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(r_filt[w]->pr, pfcn_refs); +// Since set<..> is a "Sorted Associative Container", +// we can walk through it in sorted order by walking from +// begin() to end(). (and the partial fcns must be +// evaluated in this order). + set::iterator si; + for(si=pfcn_refs.begin();si!=pfcn_refs.end();++si){ + if(fcn_ref_cnt[(*si)] > 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string((*si))+"==0){\n"; + } + if(is_partial_fcn[(*si)]){ + ret += "\t"+unpack_partial_fcn(partial_fcns[(*si)], (*si), schema); + ret += "\t\tif(retval) goto end;\n"; + } + if(fcn_ref_cnt[(*si)] > 1){ + if(!is_partial_fcn[(*si)]){ + ret += "\t\tpartial_fcn_result_"+int_to_string((*si))+"="+generate_cached_fcn(partial_fcns[(*si)],schema)+";\n"; + } + ret += "\t\tfcn_ref_cnt_"+int_to_string((*si))+"=1;\n"; + ret += "\t}\n"; + } + } + + ret += "\tif( !("+generate_predicate_code(r_filt[w]->pr,schema)+ + ") ) goto end;\n"; + } + }else{ + ret += "\n\n/*\t\t (no predicate to test)\t*/\n\n"; + } + + + +/////////////// post the tuple + +// test passed : create the tuple, then assign to it. + ret += "/*\t\tCreate and post the tuple\t*/\n"; + +// Unpack r_filt fields + for(s=0;s 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string(p)+"==0){\n"; + } + if(is_partial_fcn[p]){ + ret += unpack_partial_fcn(partial_fcns[p], p, schema); + ret += "\tif(retval) goto end;\n"; + } + if(fcn_ref_cnt[p] > 1){ + if(!is_partial_fcn[p]){ + ret += "\t\tpartial_fcn_result_"+int_to_string(p)+"="+generate_cached_fcn(partial_fcns[p],schema)+";\n"; + } + ret += "\t\tfcn_ref_cnt_"+int_to_string(p)+"=1;\n"; + ret += "\t}\n"; + } + } + + // increment the counter of accepted tuples + ret += "\n\t#ifdef LFTA_STATS\n"; + ret += "\n\tt->accepted_tuple_cnt++;\n\n"; + ret += "\t#endif\n\n"; + +// First, compute the size of the tuple. + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. + + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\tselvar_%d = ",s); + ret += tmpstr; + ret += generate_se_code(sl_list[s],schema); + ret += ";\n"; + } + } + + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + ret+="\ttuple_size = sizeof( struct "+generate_tuple_name(node_name)+")"; + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr," + %s(&selvar_%d)", sdt->get_buffer_size().c_str(),s); + ret += tmpstr; + } + } + ret += ";\n"; + + + ret += "\ttuple = allocate_tuple(f, tuple_size );\n"; + ret += "\tif( tuple == NULL)\n\t\tgoto end;\n"; + +// Test passed, make assignments to the tuple. + + ret += "\ttuple_pos = sizeof( struct "+generate_tuple_name(node_name)+");\n"; + +// Mark tuple as REGULAR_TUPLE + ret += "\ttuple->tuple_type = REGULAR_TUPLE;\n"; + + + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &selvar_%d, (char *)tuple, ((char *)tuple)+tuple_pos);\n", sdt->get_buffer_tuple_copy().c_str(),s, s); + ret += tmpstr; + sprintf(tmpstr,"\ttuple_pos += %s(&selvar_%d);\n", sdt->get_buffer_size().c_str(), s); + ret += tmpstr; + }else{ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret += tmpstr; +// if(sdt->needs_hn_translation()) +// ret += sdt->hton_translation() +"( "; + ret += generate_se_code(sl_list[s],schema); +// if(sdt->needs_hn_translation()) +// ret += ") "; + ret += ";\n"; + } + } + +// Generate output. + + ret += "\tpost_tuple(tuple);\n"; + +// Increment the counter of posted tuples + ret += "\n\t#ifdef LFTA_STATS\n"; + ret += "\n\tt->out_tuple_cnt++;\n\n"; + ret+="\t\t\t\tt->out_tuple_sz+=tuple_size;\n"; + ret += "\t#endif\n\n"; + + + return ret; +} + +string generate_aggr_accept_body(qp_node *fs,string node_name,table_list *schema, string &temporal_flush){ + string ret; + int a,p,g; + +////////////// Processing for aggregtion query + +// First, search for a match. Start by unpacking the group-by attributes. + +// One complication : if a real-time aggregate flush occurs, +// the GB attr has already been calculated. So don't compute +// it again if 1) its temporal and 2) it will be computed in the +// agggregate flush code. + +// Unpack the partial fcns ref'd by the gb's and the aggr defs. + for(p=gb_fcns_start;psize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if((! gdt->is_temporal()) || temporal_flush == ""){ + + if(gdt->is_buffer_type()){ + // NOTE : if the SE defining the gb is anything + // other than a ref to a variable, this will generate + // illegal code. To be resolved with Spatch. + sprintf(tmpstr,"\tgb_attr_tmp%d = %s;\n", + g, generate_se_code(gb_tbl->get_def(g),schema).c_str() ); + ret += tmpstr; + sprintf(tmpstr,"\t%s(f, &gb_attr_%d, &gb_attr_tmp%d);\n", + gdt->get_buffer_assign_copy().c_str(), g, g); + }else{ + sprintf(tmpstr,"\tgb_attr_%d = %s;\n",g,generate_se_code(gb_tbl->get_def(g),schema).c_str()); + } + ret += tmpstr; + } + } + ret += "\n"; + +// A quick aside : if any of the GB attrs are temporal, +// test for change and flush if any change occurred. +// We've already computed the flush code, +// Put it here if this is not a real time query. +// We've already unpacked all column refs, so no need to +// do it again here. + + string rt_level = fs->get_val_of_def("real_time"); + if(rt_level == "" && temporal_flush != ""){ + ret += temporal_flush; + } + +// Compute the hash bucket + if(gb_tbl->size() > 0){ + ret += "\thashval = ";\ + for(g=0;gsize();g++){ + if(g>0) ret += " ^ "; + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"((%s * lfta_%s_to_hash(gb_attr_%d)))",hash_nums[g%NRANDS].c_str(), + gdt->get_type_str().c_str(), g); + }else{ + sprintf(tmpstr,"((%s * lfta_%s_to_hash(gb_attr_%d)))",hash_nums[g%NRANDS].c_str(), + gdt->get_type_str().c_str(), g); + } + ret += tmpstr; + } + ret += ";\n"; + ret += "\thash2 = ((hashval * "+hash_nums[g%NRANDS]+") >> 32) & SLOT_HASH_BITS;\n"; + ret+="\tprobe = (hashval >> 32) & (t->max_aggrs-1);\n"; + }else{ + ret+="\tprobe = 0;\n"; + ret+="\thash2 = 0;\n\n"; + } + +// Does the lfta reference a udaf? + bool has_udaf = false; + for(a=0;asize();a++){ + if(! aggr_tbl->is_builtin(a)) has_udaf = true; + } + +// Scan for a match, or alternatively the best slot. +// Currently, hardcode 5 tests. + ret += +" gen_val = t->generation & SLOT_GEN_BITS;\n" +" match_found = 0;\n" +" best_slot = probe;\n" +" for(i=0;i<5 && match_found == 0;i++){\n" +" if((t->aggr_table_hashmap[probe] & SLOT_FILLED) && (t->aggr_table_hashmap[probe] & SLOT_GEN_BITS) == gen_val && (t->aggr_table_hashmap[probe] & SLOT_HASH_BITS) == hash2 ){\n" +; + if(gb_tbl->size()>0){ + ret+="\n\t/* \t\tcheck if the grouping variables are equal */\n"; + ret+="\t\tif("; + string rhs_op, lhs_op; + for(g=0;gsize();g++){ + if(g>0) ret += " && "; + ret += "("; + sprintf(tmpstr,"gb_attr_%d",g); lhs_op = tmpstr; + sprintf(tmpstr,"t->aggr_table[probe].gb_var%d",g); rhs_op = tmpstr; + ret += generate_equality_test(lhs_op,rhs_op,gb_tbl->get_data_type(g)); + ret += ")"; + } + } + ret += "){\n" +" match_found = 1;\n" +" best_slot = probe;\n" +" }\n" +" }\n" +"// Rate slots in case no match found: prefer empty, then full but old slots\n" +" if(t->aggr_table_hashmap[best_slot] & SLOT_FILLED){\n" +" if((t->aggr_table_hashmap[probe] & SLOT_FILLED)==0)\n" +" best_slot = probe;\n" +" }else{\n" +" if((t->aggr_table_hashmap[best_slot] & SLOT_GEN_BITS) == gen_val && (t->aggr_table_hashmap[probe] & SLOT_GEN_BITS) != gen_val){\n" +" best_slot = probe;\n" +" }\n" +" }\n" +" probe++;\n" +" if(probe >= t->max_aggrs)\n" +" probe=0;\n" +" }\n" +" if(match_found){\n" +; + ret += generate_gb_update(node_name, schema, "best_slot",has_udaf); + ret += +" }else{\n" +" if(t->aggr_table_hashmap[best_slot] & SLOT_FILLED){\n" +; +printf("sgah_qpn name is %s, disorder is %d\n",fs->node_name.c_str(),((sgah_qpn *)fs)->lfta_disorder); + if(((sgah_qpn *)fs)->lfta_disorder <= 1){ + ret += +" if((t->aggr_table_hashmap[best_slot] & SLOT_GEN_BITS)==gen_val){\n" +" if(("; + bool first_g = true; + for(int g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_temporal()){ + if(first_g) first_g = false; else ret+=" + "; + ret += "(gb_attr_"+int_to_string(g)+" - t->aggr_table[best_slot].gb_var"+int_to_string(g)+")"; + } + } + ret += ") == 0 ){\n"; + + ret += +" fta_aggr_flush_old_"+ node_name+"(f,t->max_aggrs);\n" +" }\n" +" }\n" +; + } + + ret += generate_tuple_from_aggr(node_name,schema,"best_slot"); + ret += +"\t\t\t#ifdef LFTA_STATS\n" +"\t\t\tif((t->aggr_table_hashmap[best_slot] & SLOT_GEN_BITS) == gen_val)\n" +"\t\t\t\tt->collision_cnt++;\n\n" +"\t\t\t#endif\n\n" +"\t\t}\n" +; + ret += generate_init_group(schema,"best_slot"); + + + ret += "\t}\n"; + + return ret; +} + + + +string generate_fta_accept(qp_node *fs, string node_name, table_list *schema, ext_fcn_list *Ext_fcns, bool is_aggr_query, bool is_fj, set &s_pids){ + + string ret="static gs_retval_t accept_packet_"+node_name+ + "(struct FTA *f, FTAID * ftaid, void *pkt, gs_int32_t sz){\n"; + ret += "\tstruct packet *p = (struct packet *)pkt;\n"; + + int a; + +// Define all of the variables needed by this +// procedure. + + +// Gather all column references, need to define unpacking variables. + int w,s; + col_id_set cid_set; + col_id_set::iterator csi; + +// If its a filter join, rebind all colrefs +// to the first range var, to avoid double unpacking. + + if(is_fj){ + for(w=0;wpr, gb_tbl); + for(s=0;spr,cid_set, gb_tbl); + } + for(s=0;ssize();g++) + gather_se_col_ids(gb_tbl->get_def(g),cid_set, gb_tbl); + } + + // Variables for unpacking attributes. + ret += "/*\t\tVariables for unpacking attributes\t*/\n"; + for(csi=cid_set.begin(); csi!=cid_set.end();++csi){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field)); + sprintf(tmpstr,"\t%s unpack_var_%s_%d;\n",dt.get_cvar_type().c_str(), + field.c_str(), tblref); + ret += tmpstr; + } + + ret += "\n\n"; + +// Variables that are always needed + ret += "/*\t\tVariables which are always needed\t*/\n"; + ret += "\tgs_retval_t retval;\n"; + ret += "\tgs_int32_t tuple_size, tuple_pos, lfta_bailout;\n"; + ret += "\tstruct "+generate_tuple_name(node_name)+" *tuple;\n"; + + ret+="\tstruct "+generate_fta_name(node_name)+" *t = (struct "+generate_fta_name(node_name)+"*) f;\n\n"; + + +// Variables needed for aggregation queries. + if(is_aggr_query){ + ret += "\n/*\t\tVariables for aggregation\t*/\n"; + ret+="\tunsigned int i, probe;\n"; + ret+="\tunsigned int gen_val, match_found, best_slot;\n"; + ret+="\tgs_uint64_t hashval, hash2;\n"; +// Variables for storing group-by attribute values. + if(gb_tbl->size() > 0) + ret += "/*\t\tGroup-by attributes\t*/\n"; + for(g=0;gsize();g++){ + sprintf(tmpstr,"\t%s gb_attr_%d;\n",gb_tbl->get_data_type(g)->get_cvar_type().c_str(),g); + ret += tmpstr; + data_type *gdt = gb_tbl->get_data_type(g); + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t%s gb_attr_tmp%d;\n",gb_tbl->get_data_type(g)->get_cvar_type().c_str(),g); + ret += tmpstr; + } + } + ret += "\n"; +// Temporaries for min/max + string aggr_tmp_str = ""; + for(a=0;asize();a++){ + string aggr_op = aggr_tbl->get_op(a); + if(aggr_op == "MIN" || aggr_op == "MAX"){ + sprintf(tmpstr,"\t%s aggr_tmp_%d;\n",aggr_tbl->get_data_type(a)->get_cvar_type().c_str(),a); + aggr_tmp_str.append(tmpstr); + } + } + if(aggr_tmp_str != ""){ + ret += "/*\t\tTemp vars for BUFFER aggregates\t*/\n"; + ret += aggr_tmp_str; + ret += "\n"; + } +// Variables for udaf output temporaries + bool no_udaf = true; + for(a=0;asize();a++){ + if(! aggr_tbl->is_builtin(a)){ + if(no_udaf){ + ret+="/*\t\tUDAF output vars.\t*/\n"; + no_udaf = false; + } + int afcn_id = aggr_tbl->get_fcn_id(a); + data_type *adt = Ext_fcns->get_fcn_dt(afcn_id); + sprintf(tmpstr,"udaf_ret%d", a); + ret+="\t"+adt->make_cvar(tmpstr)+";\n"; + } + } + } + +// Variables needed for a filter join query + if(fs->node_type() == "filter_join"){ + filter_join_qpn *fjq = (filter_join_qpn *)fs; + bool uses_bloom = fjq->use_bloom; + ret += "/*\t\tJoin fields\t*/\n"; + for(g=0;ghash_eq.size();g++){ + sprintf(tmpstr,"\t%s s_equijoin_%d, r_equijoin_%d;\n",fjq->hash_eq[g]->pr->get_left_se()->get_data_type()->get_cvar_type().c_str(),g,g); + ret += tmpstr; + } + if(uses_bloom){ + ret += +" /* Variables for fj bloom filter */ \n" +"\tunsigned int i=0,j=0,k=0, b, bf_clean = 0, tmp_i, found; \n" +"\tunsigned int bucket, bucket0, bucket1, bucket2;\n" +"\tlong long int curr_fj_ts;\n" +"\tunsigned int curr_bin, the_bin;\n" +"\n" +; + }else{ + ret += +" /* Variables for fj join table */ \n" +"\tunsigned int i, bucket, found; \n" +"\tunsigned int bucket1, the_bucket;\n" +" long long int curr_fj_ts;\n" +"\n" +; + } + } + + +// Variables needed to store selected attributes of BUFFER type +// temporarily, in order to compute their size for storage +// in an output tuple. + + string select_var_defs = ""; + for(s=0;sget_data_type(); + if(sdt->is_buffer_type()){ + sprintf(tmpstr,"\t%s selvar_%d;\n",sdt->get_cvar_type().c_str(),s); + select_var_defs.append(tmpstr); + } + } + if(select_var_defs != ""){ + ret += "/*\t\tTemporaries for computing buffer sizes.\t*/\n"; + ret += select_var_defs; + } + +// Variables to store results of partial functions. + int p; + if(partial_fcns.size()>0){ + ret += "/*\t\tVariables for storing results of partial functions. \t*/\n"; + for(p=0;p1)){ + sprintf(tmpstr,"\t%s partial_fcn_result_%d;\n", + partial_fcns[p]->get_data_type()->get_cvar_type().c_str(), p); + ret += tmpstr; + if(!is_aggr_query && fcn_ref_cnt[p] >1){ + ret += "\tint fcn_ref_cnt_"+int_to_string(p)+" = 0;\n"; + } + } + } + + if(is_aggr_query) ret += "\tint unpack_failed = 0;\n"; + ret += "\n"; + } + +// variable to hold packet struct // + if(packed_return){ + ret += "\t struct "+node_name+"_input_struct *"+node_name+"_input_struct_var;\n"; + } + + + ret += "\t#ifdef LFTA_STATS\n"; +// variable to store counter of cpu cycles spend in accept_tuple + ret += "\tgs_uint64_t start_cycle = rdtsc();\n"; +// increment counter of received tuples + ret += "\tt->in_tuple_cnt++;\n"; + ret += "\t#endif\n"; + + +// ------------------------------------------------- +// If the packet is "packet", test if its for this lfta, +// and if so load it into its struct + + if(packed_return){ + ret+="\n/* packed tuple : test and load. \t*/\n"; + ret+="\t"+node_name+"_input_struct_var = (struct "+node_name+"_input_struct *) pkt;\n"; + ret+="\tif("+node_name+"_input_struct_var->__lfta_id_fm_nic__ != "+int_to_string(global_id) + ")\n"; + ret+="\t\tgoto end;\n\n"; + } + + + + col_id_set unpacked_cids; // Keep track of the cols that have been unpacked. + + string temporal_flush; + if(is_aggr_query) + ret += generate_aggr_accept_prelim(fs, node_name, schema, unpacked_cids, temporal_flush); + else { // non-aggregation operators + +// Unpack all the temporal attributes referenced in select clause +// and update the last value of the attribute + col_id_set temp_cids; // col ids of temp attributes in select clause + + for(s=0;sget_data_type(); + if (sdt->is_temporal()) { + gather_se_col_ids(sl_list[s],temp_cids, gb_tbl); + } + } +// If this is a filter join, +// ensure that the temporal range field is unpacked. + if(is_fj){ + col_id window_var_cid(((filter_join_qpn *)fs)->temporal_var); + if(temp_cids.count(window_var_cid)==0) + temp_cids.insert(window_var_cid); + } + + for(csi=temp_cids.begin(); csi != temp_cids.end();++csi){ + if(unpacked_cids.count((*csi)) == 0){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name); + sprintf(tmpstr,"\tt->last_%s_%d = unpack_var_%s_%d;\n", field.c_str(), tblref, field.c_str(), tblref); + ret += tmpstr; + + unpacked_cids.insert( (*csi) ); + } + } + + } + + vector filter = fs->get_filter_clause(); +// Test the filter predicate (some query types have additional preds). + if(filter.size() > 0){ + +// Sort by evaluation cost. +// First, estimate evaluation costs +// Eliminate predicates covered by the prefilter (those in s_pids). +// I need to do it before the sort becuase the indices refer +// to the position in the unsorted list./ + vector tmp_wh; + for(w=0;wcost); + ret += tmpstr; +// Find the set of variables accessed in this CNF elem, +// but in no previous element. + col_id_set this_pred_cids; + gather_pr_col_ids(filter[w]->pr, this_pred_cids, gb_tbl); + for(csi=this_pred_cids.begin();csi!=this_pred_cids.end();++csi){ + if(unpacked_cids.count( (*csi) ) == 0){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name); + unpacked_cids.insert( (*csi) ); + } + } +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(filter[w]->pr, pfcn_refs); +// Since set<..> is a "Sorted Associative Container", +// we can walk through it in sorted order by walking from +// begin() to end(). (and the partial fcns must be +// evaluated in this order). + set::iterator si; + for(si=pfcn_refs.begin();si!=pfcn_refs.end();++si){ + if(fcn_ref_cnt[(*si)] > 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string((*si))+"==0){\n"; + } + if(is_partial_fcn[(*si)]){ + ret += "\t"+unpack_partial_fcn(partial_fcns[(*si)], (*si), schema); + ret += "\t\tif(retval) goto end;\n"; + } + if(fcn_ref_cnt[(*si)] > 1){ + if(!is_partial_fcn[(*si)]){ + ret += "\t\tpartial_fcn_result_"+int_to_string((*si))+"="+generate_cached_fcn(partial_fcns[(*si)],schema)+";\n"; + } + ret += "\t\tfcn_ref_cnt_"+int_to_string((*si))+"=1;\n"; + ret += "\t}\n"; + } + } + + ret += "\tif( !("+generate_predicate_code(filter[w]->pr,schema)+ + ") ) goto end;\n"; + } + }else{ + ret += "\n\n/*\t\t (no predicate to test)\t*/\n\n"; + } + + +// We've passed the WHERE clause, +// unpack the remainder of the accessed fields. + if(is_fj){ + ret += "\n/*\tPassed the WHERE clause, unpack the hash fields. */\n"; + vector h_eq = ((filter_join_qpn *)fs)-> hash_eq; + for(w=0;wpr, this_pred_cids, gb_tbl); + for(csi=this_pred_cids.begin();csi!=this_pred_cids.end();++csi){ + if(unpacked_cids.count( (*csi) ) == 0){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name); + unpacked_cids.insert( (*csi) ); + } + } + } + }else{ + ret += "\n/*\tPassed the WHERE clause, unpack the rest of the accessed fields. */\n"; + + for(csi=cid_set.begin();csi!=cid_set.end();++csi){ + if(unpacked_cids.count( (*csi) ) == 0){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + ret += generate_unpack_code(tblref,schref,field,schema,node_name); + unpacked_cids.insert( (*csi) ); + } + } + } + + +////////////////// +////////////////// After this, the query types +////////////////// are processed differently. + + if(!is_aggr_query && !is_fj) + ret += generate_sel_accept_body(fs, node_name, schema); + else if(is_aggr_query) + ret += generate_aggr_accept_body(fs, node_name, schema, temporal_flush); + else + ret += generate_fj_accept_body((filter_join_qpn *)fs, node_name, unpacked_cids, Ext_fcns, schema); + + +// Finish up. + + ret += "\n\tend:\n"; + ret += "\t#ifdef LFTA_STATS\n"; + ret+= "\tt->cycle_cnt += rdtsc() - start_cycle;\n"; + ret += "\t#endif\n"; + ret += "\n\treturn 1;\n}\n\n"; + + return(ret); +} + + +string generate_fta_alloc(qp_node *fs, string node_name, table_list *schema, bool is_aggr_query, bool is_fj, bool uses_bloom){ + int g, cl; + + string ret = "struct FTA * "+generate_alloc_name(node_name) + + "(struct FTAID ftaid, gs_uint32_t reusable, gs_int32_t command, gs_int32_t sz, void *value){\n"; + + ret+="\tstruct "+generate_fta_name(node_name)+"* f;\n"; + ret+="\tint i;\n"; + ret += "\n"; + ret+="\tif((f=fta_alloc(0,sizeof(struct "+generate_fta_name(node_name)+")))==0){\n\t\treturn(0);\n\t}\n"; + +// assign a streamid to fta instance + ret+="\t/* assign a streamid */\n"; + ret+="\tf->f.ftaid = ftaid;\n"; + ret+="\tf->f.ftaid.streamid = (gs_p_t)f;\n"; + ret+="\tgslog(LOG_INFO,\"Lfta "+node_name+" has FTAID {ip=%u,port=%u,index=%u,streamid=%u}\\n\",f->f.ftaid.ip,f->f.ftaid.port,f->f.ftaid.index,f->f.ftaid.streamid);\n"; + + if(is_aggr_query){ + ret += "\tf->n_aggrs = 0;\n"; + + ret += "\tf->max_aggrs = "; + +// Computing the number of aggregate blocks is a little +// tricky. If there are no GB attrs, or if all GB attrs +// are temporal, then use a single aggregate block, else +// use a default value (10). A user specification overrides +// this logic. + bool single_group = true; + for(g=0;gsize();g++){ + data_type *gdt = gb_tbl->get_data_type(g); + if(! gdt->is_temporal() ){ + single_group = false; + } + } + string max_aggr_str = fs->get_val_of_def("aggregate_slots"); + int max_aggr_i = atoi(max_aggr_str.c_str()); + if(max_aggr_i <= 0){ + if(single_group) + ret += "2"; + else + ret += int_to_string(DEFAULT_LFTA_HASH_TABLE_SIZE); + }else{ + unsigned int naggrs = 1; // make it power of 2 + unsigned int nones = 0; + while(max_aggr_i){ + if(max_aggr_i&1) + nones++; + naggrs = naggrs << 1; + max_aggr_i = max_aggr_i >> 1; + } + if(nones==1) // in case it was already a power of 2. + naggrs/=2; + ret += int_to_string(naggrs); + } + ret += ";\n"; + + ret+="\tif ((f->aggr_table = sp_fta_alloc((struct FTA *)f,sizeof(struct "+generate_aggr_struct_name(node_name)+") * f->max_aggrs))==0) {\n"; + ret+="\t\treturn(0);\n"; + ret+="\t}\n\n"; +// ret+="/* compute how many integers we need to store the hashmap */\n"; +// ret+="\tf->bitmap_size = (f->max_aggrs % (sizeof(gs_uint32_t) * 4)) ? (f->max_aggrs / (sizeof(gs_uint32_t) * 4) + 1) : (f->max_aggrs / (sizeof(gs_uint32_t) * 4));\n\n"; + ret+="\tif ((f->aggr_table_hashmap = sp_fta_alloc((struct FTA *)f,sizeof(gs_uint32_t) * f->max_aggrs))==0) {\n"; + ret+="\t\treturn(0);\n"; + ret+="\t}\n"; + ret+="/*\t\tfill bitmap with zero \t*/\n"; + ret+="\tfor (i = 0; i < f->max_aggrs; ++i)\n"; + ret+="\t\tf->aggr_table_hashmap[i] = 0;\n"; + ret+="\tf->generation=0;\n"; + ret+="\tf->flush_pos = f->max_aggrs;\n"; + + ret += "\tf->flush_ctr = 0;\n"; + + } + + if(is_fj){ + if(uses_bloom){ + ret+="\tf->first_exec = 1;\n"; + unsigned int n_bloom = 11; + string n_bloom_str = fs->get_val_of_def("num_bloom"); + int tmp_n_bloom = atoi(n_bloom_str.c_str()); + if(tmp_n_bloom>0) + n_bloom = tmp_n_bloom+1; + + unsigned int window_len = ((filter_join_qpn *)fs)->temporal_range; + if(window_len < n_bloom){ + n_bloom = window_len+1; + } + + int bf_exp_size = 12; // base-2 log of number of bits + string bloom_len_str = fs->get_val_of_def("bloom_size"); + int tmp_bf_exp_size = atoi(bloom_len_str.c_str()); + if(tmp_bf_exp_size > 3 && tmp_bf_exp_size < 32){ + bf_exp_size = tmp_bf_exp_size; + } + int bf_bit_size = 1 << 12; + int bf_byte_size = bf_bit_size / (8*sizeof(char)); + + int bf_tot = n_bloom*bf_byte_size; + ret+="\tif ((f->bf_table = sp_fta_alloc((struct FTA *)f,"+int_to_string(bf_tot)+"))==0) {\n"; + ret+="\t\treturn(0);\n"; + ret+="\t}\n"; + ret += +" for(i=0;i<"+int_to_string(bf_tot)+";i++)\n" +" f->bf_table[i] = 0;\n" +; + }else{ + unsigned int ht_size = 4096; + string ht_size_s = fs->get_val_of_def("aggregate_slots"); + int tmp_ht_size = atoi(ht_size_s.c_str()); + if(tmp_ht_size > 1024){ + unsigned int hs = 1; // make it power of 2 + while(tmp_ht_size){ + hs =hs << 1; + tmp_ht_size = tmp_ht_size >> 1; + } + ht_size = hs; + } + ret+="\tif ((f->join_table = sp_fta_alloc((struct FTA *)f,sizeof(struct "+generate_fj_struct_name(node_name)+") * "+int_to_string(ht_size)+"))==0) {\n"; + ret+="\t\treturn(0);\n"; + ret+="\t}\n\n"; + ret += +" for(i=0;i<"+int_to_string(ht_size)+";i++)\n" +" f->join_table[i].ts = 0;\n" +; + } + } + +// Initialize the complex literals (which might be handles). + + for(cl=0;clsize();cl++){ + literal_t *l = complex_literals->get_literal(cl); +// sprintf(tmpstr,"\tf->complex_literal_%d = ",cl); +// ret += tmpstr + l->to_C_code() + ";\n"; + sprintf(tmpstr,"&(f->complex_literal_%d)",cl); + ret += "\t" + l->to_C_code(tmpstr) + ";\n"; + } + + ret += "\n"; + +// Initialize the last seen values of temporal attributes to min(max) value of +// their respective type +// Create places to hold the last values of temporal attributes referenced in select clause + + + col_id_set temp_cids; // col ids of temp attributes in select clause + + int s; + col_id_set::iterator csi; + + for(s=0;sget_data_type(); + if (sdt->is_temporal()) { + gather_se_col_ids(sl_list[s],temp_cids, gb_tbl); + } + } + + for(csi=temp_cids.begin(); csi != temp_cids.end();++csi){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field), schema->get_modifier_list(schref,field)); + if (dt.is_increasing()) { + sprintf(tmpstr,"\tf->last_%s_%d = %s;\n", field.c_str(), tblref, dt.get_min_literal().c_str()); + ret += tmpstr; + } else if (dt.is_decreasing()) { + sprintf(tmpstr,"\tf->last_%s_%d = %s;\n", field.c_str(), tblref, dt.get_max_literal().c_str()); + ret += tmpstr; + } + } + +// initialize last seen values of temporal groubpy variables + if(is_aggr_query){ + for(g=0;gsize();g++){ + data_type *dt = gb_tbl->get_data_type(g); + if(dt->is_temporal()){ +/* + fprintf(stderr,"group by attribute %s is temporal, ", + gb_tbl->get_name(g).c_str()); +*/ + if(dt->is_increasing()){ + sprintf(tmpstr,"\tf->last_gb_%d = f->last_flushed_gb_%d = %s;\n",g, g, dt->get_min_literal().c_str()); + }else{ + sprintf(tmpstr,"\tf->last_gb_%d = f->last_flushed_gb_%d = %s;\n",g, g, dt->get_max_literal().c_str()); + } + ret += tmpstr; + } + } + } + + ret += "\tf->f.alloc_fta="+generate_alloc_name(node_name)+";\n"; + ret+="\tf->f.free_fta=free_fta_"+node_name+";\n"; + ret+="\tf->f.control_fta=control_fta_"+node_name+";\n"; + ret+="\tf->f.accept_packet=accept_packet_"+node_name+";\n"; + ret+="\tf->f.clock_fta=clock_fta_"+node_name+";\n\n"; + +// Initialize runtime stats + ret+="\tf->in_tuple_cnt = 0;\n"; + ret+="\tf->out_tuple_cnt = 0;\n"; + ret+="\tf->out_tuple_sz = 0;\n"; + ret+="\tf->accepted_tuple_cnt = 0;\n"; + ret+="\tf->cycle_cnt = 0;\n"; + ret+="\tf->collision_cnt = 0;\n"; + ret+="\tf->eviction_cnt = 0;\n"; + ret+="\tf->sampling_rate = 1.0;\n"; + + ret+="\tf->trace_id = 0;\n\n"; + if(param_tbl->size() > 0){ + ret+= +"\tif(load_params_"+node_name+"(f, sz, value, 1)){\n" +"#ifndef LFTA_IN_NIC\n" +"\t\t\tfprintf(stderr,\"WARNING: parameter passed to lfta "+node_name+" is too small (%d). This query does not have valid parameters, bailing out.\\n\",sz);\n" +"#else\n" +"\t\t}\n" +"#endif\n" +"\t\t\treturn 0;\n" +"\t\t}\n"; + } + +// Register the pass-by-handle parameters + int ph; + for(ph=0;phtype_name); + sprintf(tmpstr,"\tf->handle_param_%d = %s((struct FTA *)f,",ph,param_handle_table[ph]->lfta_registration_fcn().c_str()); + switch(param_handle_table[ph]->val_type){ + case cplx_lit_e: + ret += tmpstr; + if(pdt.is_buffer_type()) ret += "&("; + sprintf(tmpstr,"f->complex_literal_%d",param_handle_table[ph]->complex_literal_idx); + ret += tmpstr ; + if(pdt.is_buffer_type()) ret += ")"; + ret += ");\n"; + break; + case litval_e: +// not complex, no constructor + ret += tmpstr; + ret += param_handle_table[ph]->litval->to_C_code("") + ");\n"; + break; + case param_e: +// query parameter handles are regstered/deregistered in the +// load_params function. +// ret += "t->param_"+param_handle_table[ph]->param_name; + break; + default: + fprintf(stderr, "INTERNAL ERROR unknown case found when processing pass-by-handle parameter table.\n"); + exit(1); + } + } + + ret += "\treturn (struct FTA *) f;\n"; + ret += "}\n\n"; + + return(ret); +} + + + + +////////////////////////////////////////////////////////////////// + +string generate_lfta_block(qp_node *fs, table_list *schema, int gid, +// map &int_fcn_defs, + ext_fcn_list *Ext_fcns, string &schema_embed_str, ifq_t *ifdb, nic_property *nicp, set &s_pids){ + bool is_aggr_query; + int s,p,g; + string retval; + +///////////////////////////////////////////////////////////// +/// Do operator-generic processing, such as +/// gathering the set of referenced columns, +/// generating structures, etc. + +// Initialize globals to empty. + gb_tbl = NULL; aggr_tbl = NULL; + global_id = -1; nicprop = NULL; + param_tbl = fs->get_param_tbl(); + sl_list.clear(); where.clear(); + partial_fcns.clear(); + fcn_ref_cnt.clear(); is_partial_fcn.clear(); + pred_class.clear(); pred_pos.clear(); + sl_fcns_start=sl_fcns_end=wh_fcns_start=wh_fcns_end=0; + gb_fcns_start=gb_fcns_end=ag_fcns_start=ag_fcns_end=0; + + +// Does the lfta read packed results from the NIC? + nicprop = nicp; // load into global + global_id = gid; + packed_return = false; + if(nicp && nicp->option_exists("Return")){ + if(nicp->option_value("Return") == "Packed"){ + packed_return = true; + }else{ + fprintf(stderr,"Warning, nic option value of Return=%s is not recognized, ignoring\n",nicp->option_value("Return").c_str()); + } + } + + +// Extract data which defines the query. +// complex literals gathered now. + complex_literals = fs->get_cplx_lit_tbl(Ext_fcns); + param_handle_table = fs->get_handle_param_tbl(Ext_fcns); + string node_name = fs->get_node_name(); + bool is_fj = false, uses_bloom = false; + + + if(fs->node_type() == "spx_qpn"){ + is_aggr_query = false; + spx_qpn *spx_node = (spx_qpn *)fs; + sl_list = spx_node->get_select_se_list(); + where = spx_node->get_where_clause(); + gb_tbl = NULL; + aggr_tbl = NULL; + } else + if(fs->node_type() == "sgah_qpn"){ + is_aggr_query = true; + sgah_qpn *sgah_node = (sgah_qpn *)fs; + sl_list = sgah_node->get_select_se_list(); + where = sgah_node->get_where_clause(); + gb_tbl = sgah_node->get_gb_tbl(); + aggr_tbl = sgah_node->get_aggr_tbl(); + + if((sgah_node->get_having_clause()).size() > 0){ + fprintf(stderr,"Warning in LFTA %s: HAVING clause will be ignored.\n", fs->get_node_name().c_str()); + } + } else + if(fs->node_type() == "filter_join"){ + is_aggr_query = false; + is_fj = true; + filter_join_qpn *fj_node = (filter_join_qpn *)fs; + sl_list = fj_node->get_select_se_list(); + where = fj_node->get_where_clause(); + uses_bloom = fj_node->use_bloom; + gb_tbl = NULL; + aggr_tbl = NULL; + } else { + fprintf(stderr,"INTERNAL ERROR, unrecognized node type %s in generate_lfta_block\n", fs->node_type().c_str()); + exit(1); + } + +// Build list of "partial functions", by clause. +// NOTE : partial fcns are not handles well. +// The act of searching for them associates the fcn call +// in the SE with an index to an array. Refs to the +// fcn value are replaced with refs to the variable they are +// unpacked into. A more general tagging mechanism would be better. + + int i; + vector *pfunc_ptr = NULL; + vector *ref_cnt_ptr = NULL; + if(!is_aggr_query){ // don't collect cacheable fcns on aggr query. + ref_cnt_ptr = &fcn_ref_cnt; + pfunc_ptr = &is_partial_fcn; + } + + sl_fcns_start = 0; + for(i=0;ipr, &partial_fcns, ref_cnt_ptr, pfunc_ptr, Ext_fcns); + } + gb_fcns_start = wh_fcns_end = partial_fcns.size(); + if(gb_tbl != NULL){ + for(i=0;isize();i++){ + find_partial_fcns(gb_tbl->get_def(i), &partial_fcns, NULL, NULL, Ext_fcns); + } + } + ag_fcns_start = gb_fcns_end = partial_fcns.size(); + if(aggr_tbl != NULL){ + for(i=0;isize();i++){ + find_partial_fcns(aggr_tbl->get_aggr_se(i), NULL, NULL, &is_partial_fcn, Ext_fcns); + } + } + ag_fcns_end = partial_fcns.size(); + +// Fill up the is_partial_fcn and fcn_ref_cnt arrays. + if(is_aggr_query){ + for(i=0; iset_partial_ref(-1); + } + } + + node_name = normalize_name(node_name); + + retval += generate_preamble(schema, /*int_fcn_defs,*/ node_name, schema_embed_str); + + if(packed_return){ // generate unpack struct + vector input_tbls = fs->get_input_tbls(); + int schref = input_tbls[0]->get_schema_ref(); + vector refd_cols; + for(s=0;spr,refd_cols, nicp, gb_tbl); + } + if(gb_tbl){ + for(g=0;gsize();++g){ + gather_nicsafe_cols(gb_tbl->get_def(g),refd_cols, nicp, gb_tbl); + } + } + sort(refd_cols.begin(), refd_cols.end()); + retval += "struct "+node_name+"_input_struct{\n"; + retval += "\tint __lfta_id_fm_nic__;\n"; + int vsi; + for(vsi=0;vsiget_type_name(schref,refd_cols[vsi])); + retval+="\t"+dt.get_cvar_type()+" unpack_var_"+refd_cols[vsi]+";\n"; + } + retval+="};\n\n"; + } + + +///////////////////////////////////////////////////// +// Common stuff unpacked, do some generation + + if(is_aggr_query) + retval += generate_aggr_struct(node_name, gb_tbl, aggr_tbl); + if(is_fj) + retval += generate_fj_struct((filter_join_qpn *)fs, node_name); + + retval += generate_fta_struct(node_name, gb_tbl, aggr_tbl, param_tbl, complex_literals, param_handle_table, is_aggr_query, is_fj, uses_bloom, schema); + retval += generate_tuple_struct(node_name, sl_list) ; + + if(is_aggr_query) + retval += generate_fta_flush(node_name, schema, Ext_fcns) ; + if(param_tbl->size() > 0) + retval += generate_fta_load_params(node_name) ; + retval += generate_fta_free(node_name, is_aggr_query) ; + retval += generate_fta_control(node_name, schema, is_aggr_query) ; + retval += generate_fta_accept(fs, node_name, schema, Ext_fcns, is_aggr_query, is_fj, s_pids) ; + + + /* extract the value of Time_Correlation from interface definition */ + int e,v; + string es; + unsigned time_corr; + vector tvec = fs->get_input_tbls(); + vector time_corr_vec = ifdb->get_iface_vals(tvec[0]->get_machine(), tvec[0]->get_interface(),"Time_Correlation",e,es); + if (time_corr_vec.empty()) + time_corr = DEFAULT_TIME_CORR; + else + time_corr = atoi(time_corr_vec[0].c_str()); + + retval.append( generate_fta_clock(node_name, schema, time_corr, is_aggr_query) ); + retval.append( generate_fta_alloc(fs, node_name, schema, is_aggr_query, is_fj, uses_bloom) ); + + return(retval); +} + + + +int compute_snap_len(qp_node *fs, table_list *schema){ + +// Initialize global vars + gb_tbl = NULL; + sl_list.clear(); where.clear(); + + if(fs->node_type() == "spx_qpn"){ + spx_qpn *spx_node = (spx_qpn *)fs; + sl_list = spx_node->get_select_se_list(); + where = spx_node->get_where_clause(); + } + else if(fs->node_type() == "sgah_qpn"){ + sgah_qpn *sgah_node = (sgah_qpn *)fs; + sl_list = sgah_node->get_select_se_list(); + where = sgah_node->get_where_clause(); + gb_tbl = sgah_node->get_gb_tbl(); + } + else if(fs->node_type() == "filter_join"){ + filter_join_qpn *fj_node = (filter_join_qpn *)fs; + sl_list = fj_node->get_select_se_list(); + where = fj_node->get_where_clause(); + } else{ + fprintf(stderr,"INTERNAL ERROR, node type %s not recognized in compute_snap_len\n",fs->node_type().c_str()); + exit(1); + } + +// Gather all column references, need to define unpacking variables. + int w,s; + col_id_set cid_set; + col_id_set::iterator csi; + + for(w=0;wpr,cid_set, gb_tbl); + for(s=0;ssize();g++) + gather_se_col_ids(gb_tbl->get_def(g),cid_set, gb_tbl); + } + + // compute snap length + int snap_len = -1; + int n_snap=0; + for(csi=cid_set.begin(); csi!=cid_set.end();++csi){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + + param_list *field_params = schema->get_modifier_list(schref, field); + if(field_params->contains_key("snap_len")){ + string fld_snap_str = field_params->val_of("snap_len"); + int fld_snap; + if(sscanf(fld_snap_str.c_str(),"%d",&fld_snap)>0){ + if(fld_snap > snap_len) snap_len = fld_snap; + n_snap++; + }else{ + fprintf(stderr,"CONFIGURATION ERROR: field %s has a non-numeric snap length (%s), ignoring\n",field.c_str(), fld_snap_str.c_str() ); + } + } + } + + if(n_snap == cid_set.size()){ + return (snap_len); + }else{ + return -1; + } + + +} + +// Function which computes an optimal +// set of unpacking functions. + +void find_optimal_unpack_fcns(col_id_set &upref_cids, table_list *Schema, map &ucol_fcn_map){ + map pfcn_count; + map::iterator msii; + col_id_set::iterator cisi; + set::iterator ssi; + string best_fcn; + + while(ucol_fcn_map.size() < upref_cids.size()){ + +// Gather unpack functions referenced by unaccounted-for +// columns, and increment their reference count. + pfcn_count.clear(); + for(cisi=upref_cids.begin();cisi!=upref_cids.end();++cisi){ + if(ucol_fcn_map.count((*cisi)) == 0){ + set ufcns = Schema->get_field((*cisi).schema_ref, (*cisi).field)->get_unpack_fcns(); + for(ssi=ufcns.begin();ssi!=ufcns.end();++ssi) + pfcn_count[(*ssi)]++; + } + } + +// Get the lowest cost per field function. + float min_cost = 0.0; + string best_fcn = ""; + for(msii=pfcn_count.begin();msii!=pfcn_count.end();++msii){ + int fcost = Schema->get_ufcn_cost((*msii).first); + if(fcost < 0){ + fprintf(stderr,"CONFIGURATION ERROR, unpack function %s either has negative cost or is not defined.\n",(*msii).first.c_str()); + exit(1); + } + float this_cost = (1.0*fcost)/(*msii).second; + if(msii == pfcn_count.begin() || this_cost < min_cost){ + min_cost = this_cost; + best_fcn = (*msii).first; + } + } + if(best_fcn == ""){ + fprintf(stderr,"ERROR, could not find a best field unpqacking function.\n"); + exit(1); + } + +// Assign this function to the unassigned fcns which use it. + for(cisi=upref_cids.begin();cisi!=upref_cids.end();++cisi){ + if(ucol_fcn_map.count((*cisi)) == 0){ + set ufcns = Schema->get_field((*cisi).schema_ref, (*cisi).field)->get_unpack_fcns(); + if(ufcns.count(best_fcn)>0) + ucol_fcn_map[(*cisi)] = best_fcn; + } + } + } +} + + + +// Generate an initial test test for the lfta +// Assume that the predicate references no external functions, +// and especially no partial functions, +// aggregates, internal functions. +string generate_lfta_prefilter(vector &pred_list, + col_id_set &temp_cids, table_list *Schema, ext_fcn_list *Ext_fcns, + vector &lfta_cols, vector &lfta_sigs, + vector &lfta_snap_lens, string iface){ + col_id_set tmp_cid_set, cid_set,upref_cids,upall_cids; + col_id_set::iterator csi; + int o,p,q; + string ret; + +// Gather complex literals in the prefilter. + cplx_lit_table *complex_literals = new cplx_lit_table(); + for(p=0;ppr,Ext_fcns, complex_literals); + } + + +// Find the combinable predicates + vector pr_list; + for(p=0;ppr,&pr_list, Schema, Ext_fcns); + } + +// Analyze the combinable predicates to find the predicate classes. + pred_class.clear(); // idx to equiv pred in equiv_list + pred_pos.clear(); // idx to returned bitmask. + vector equiv_list; + vector num_equiv; + + + for(p=0;psize() == 0) + ret += "\tint no_variable;\n"; + int cl; + for(cl=0;clsize();cl++){ + literal_t *l = complex_literals->get_literal(cl); + data_type *dtl = new data_type( l->get_type() ); + sprintf(tmpstr,"\t%s complex_literal_%d;\n",dtl->get_cvar_type().c_str(),cl); + ret += tmpstr; + } + ret += "} prefilter_complex_lits_"+iface+";\n\n"; + + +// Generate the prefilter initialziation code + ret += "void init_lfta_prefilter_"+iface+"(){\n"; + +// First initialize complex literals, if any. + ret += "\tstruct prefilter_complex_lit_struct_"+iface+" *t = &prefilter_complex_lits_"+iface+";\n"; + for(cl=0;clsize();cl++){ + literal_t *l = complex_literals->get_literal(cl); + sprintf(tmpstr,"&(t->complex_literal_%d)",cl); + ret += "\t" + l->to_C_code(tmpstr) + ";\n"; + } + + + set epred_seen; + for(p=0;p0){ + ret += "\tregister_commonpred_handles_"+equiv_list[q]->get_op()+"("; + vector cl_op = Ext_fcns->get_class_indicators(equiv_list[q]->get_fcn_id()); + vector op_list = pr_list[p]->get_op_list(); + for(o=0;oget_op()+"("; + vector cl_op = Ext_fcns->get_class_indicators(equiv_list[q]->get_fcn_id()); + vector op_list = pr_list[p]->get_op_list(); + for(o=0;opr,tmp_cid_set, gb_tbl); + } + +// make the col_ids refer to the base tables, and +// grab the col_ids with at least one unpacking function. + for(csi=tmp_cid_set.begin();csi!=tmp_cid_set.end();++csi){ + string c_tbl = Schema->get_basetbl_name((*csi).schema_ref,(*csi).field); + col_id tmp_col_id; + tmp_col_id.field = (*csi).field; + tmp_col_id.tblvar_ref = (*csi).tblvar_ref; + tmp_col_id.schema_ref = Schema->get_table_ref(c_tbl); + cid_set.insert(tmp_col_id); + field_entry *fe = Schema->get_field(tmp_col_id.schema_ref, tmp_col_id.field); + if(fe->get_unpack_fcns().size()>0) + upref_cids.insert(tmp_col_id); + + + } + +// Find the set of unpacking programs needed for the +// prefilter fields. + map ucol_fcn_map; + find_optimal_unpack_fcns(upref_cids, Schema, ucol_fcn_map); + set pref_ufcns; + map::iterator mcis; + for(mcis=ucol_fcn_map.begin(); mcis!=ucol_fcn_map.end(); mcis++){ + pref_ufcns.insert((*mcis).second); + } + + + +// Variables for unpacking attributes. + body += "/*\t\tVariables for unpacking attributes\t*/\n"; + for(csi=cid_set.begin(); csi!=cid_set.end();++csi){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(Schema->get_type_name(schref,field)); + sprintf(tmpstr,"\t%s unpack_var_%s_%d;\n",dt.get_cvar_type().c_str(), + field.c_str(), tblref); + body += tmpstr; + sprintf(tmpstr,"\tgs_retval_t ret_%s_%d;\n", field.c_str(),tblref); + body += tmpstr; + } +// Variables for unpacking temporal attributes. + body += "/*\t\tVariables for unpacking temporal attributes\t*/\n"; + for(csi=temp_cids.begin(); csi!=temp_cids.end();++csi){ + if (cid_set.count(*csi) == 0) { + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(Schema->get_type_name(schref,field)); + sprintf(tmpstr,"\t%s unpack_var_%s_%d;\n",dt.get_cvar_type().c_str(), + field.c_str(), tblref); + body += tmpstr; + + } + } + body += "\n\n"; + +// Variables for combinable predicate evaluation + body += "/*\t\tVariables for common prdicate evaluation\t*/\n"; + for(q=0;q 0) + body += "\n/*\t\tcall field unpacking functions\t*/\n"; + set::iterator ssi; + for(ssi=pref_ufcns.begin(); ssi!=pref_ufcns.end(); ++ssi){ + body += "\t"+Schema->get_ufcn_fcn((*ssi))+"(p);\n"; + } + + +// Unpack the accessed attributes + body += "\n/*\t\tUnpack the accessed attributes.\t*/\n"; + for(csi=cid_set.begin();csi!=cid_set.end();++csi){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + sprintf(tmpstr,"\tret_%s_%d = (%s(p, &unpack_var_%s_%d) == 0);\n", + field.c_str(),tblref,Schema->get_fcn(schref,field).c_str(), field.c_str(), tblref); + body += tmpstr; + } + +// next unpack the temporal attributes and ignore the errors +// We are assuming here that failed unpack of temporal attributes +// is not going to overwrite the last stored value +// Failed upacks are ignored + for(csi=temp_cids.begin();csi!=temp_cids.end();++csi){ + int tblref = (*csi).tblvar_ref; + int schref = (*csi).schema_ref; + string field = (*csi).field; + sprintf(tmpstr,"\t%s(p, &prefilter_temp_vars.unpack_var_%s_%d);\n", + Schema->get_fcn(schref,field).c_str(), field.c_str(), tblref); + body += tmpstr; + } + +// Evaluate the combinable predicates + if(equiv_list.size()>0) + body += "/*\t\tEvaluate the combinable predicates.\t*/\n"; + for(q=0;q0){ + body += "\tif("; + for(cpi=pred_cids.begin();cpi!=pred_cids.end();++cpi){ + if(cpi != pred_cids.begin()) + body += " && "; + string field = (*cpi).field; + int tblref = (*cpi).tblvar_ref; + body += "ret_"+field+"_"+int_to_string(tblref); + } + body+=")\n"; + } + + body += "\t\tpref_common_pred_val_"+int_to_string(q)+"_"+int_to_string(p)+" = eval_commonpred_"+equiv_list[q]->get_op()+"(pref_common_pred_hdl_"+int_to_string(q)+"_"+int_to_string(p)+"_"+iface; + vector op_list = equiv_list[q]->get_op_list(); + vector cl_op = Ext_fcns->get_class_indicators(equiv_list[q]->get_fcn_id()); + for(o=0;opr,pred_cids, gb_tbl); + if(pred_cids.size()>0){ + body += "\tif("; + for(cpi=pred_cids.begin();cpi!=pred_cids.end();++cpi){ + if(cpi != pred_cids.begin()) + body += " && "; + string field = (*cpi).field; + int tblref = (*cpi).tblvar_ref; + body += "ret_"+field+"_"+int_to_string(tblref); + } + body+=")\n"; + } + body += "\t\tif("+generate_predicate_code(pred_list[p]->pr,Schema)+")\n\t\t\tretval |= bitpos;\n"; + body+="\tbitpos = bitpos << 1;\n"; + } + +// --------------------------------------------------------------- +// Finished with the body of the prefilter +// -------------------------------------------------------------- + + ret += body; + +// Collect fields referenced by an lfta but not +// already unpacked for the prefilter. + +//printf("upref_cids is:\n"); +//for(csi=upref_cids.begin();csi!=upref_cids.end();csi++) +//printf("\t%s %d\n",(*csi).field.c_str(), (*csi).schema_ref); +//printf("pref_ufcns is:\n"); +//for(ssi=pref_ufcns.begin();ssi!=pref_ufcns.end();++ssi) +//printf("\t%s\n",(*ssi).c_str()); + + int l; + for(l=0;lget_basetbl_name((*csi).schema_ref,(*csi).field); + col_id tmp_col_id; + tmp_col_id.field = (*csi).field; + tmp_col_id.tblvar_ref = (*csi).tblvar_ref; + tmp_col_id.schema_ref = Schema->get_table_ref(c_tbl); + field_entry *fe = Schema->get_field(tmp_col_id.schema_ref, tmp_col_id.field); + set fld_ufcns = fe->get_unpack_fcns(); +//printf("tmpcol is (%s, %d), ufcns size is %d, upref_cids cnt is %d\n",tmp_col_id.field.c_str(),tmp_col_id.schema_ref,fld_ufcns.size(), upref_cids.count(tmp_col_id)); + if(fld_ufcns.size()>0 && upref_cids.count(tmp_col_id) == 0){ +// Ensure that this field not already unpacked. + bool found = false; + for(ssi=fld_ufcns.begin();ssi!=fld_ufcns.end();++ssi){ +//printf("\tField has unpacking fcn %s\n",(*ssi).c_str()); + if(pref_ufcns.count((*ssi))){ +//printf("Field already unpacked.\n"); + found = true;; + } + } + if(! found){ +//printf("\tadding to unpack list\n"); + upall_cids.insert(tmp_col_id); + } + } + } + } + +//printf("upall_cids is:\n"); +//for(csi=upall_cids.begin();csi!=upall_cids.end();csi++) +//printf("\t%s %d\n",(*csi).field.c_str(), (*csi).schema_ref); + +// Get the set of unpacking programs for these. + map uall_fcn_map; + find_optimal_unpack_fcns(upall_cids, Schema, uall_fcn_map); + set pall_ufcns; + for(mcis=uall_fcn_map.begin(); mcis!=uall_fcn_map.end(); mcis++){ +//printf("uall_fcn_map[%s %d] = %s\n",(*mcis).first.field.c_str(),(*mcis).first.schema_ref,(*mcis).second.c_str()); + pall_ufcns.insert((*mcis).second); + } + +// Iterate through the remaining set of unpacking function + if(pall_ufcns.size() > 0) + ret += "//\t\tcall all remaining field unpacking functions.\n"; + for(ssi=pall_ufcns.begin(); ssi!=pall_ufcns.end(); ++ssi){ +// gather the set of columns unpacked by this ufcn + col_id_set fcol_set; + for(csi=upall_cids.begin();csi!=upall_cids.end();++csi){ + if(uall_fcn_map[(*csi)] == (*ssi)) + fcol_set.insert((*csi)); + } + +// gather the set of lftas which access a field unpacked by the fcn + set clfta; + for(l=0;l 0) + break; + } + if(csi != fcol_set.end()) + clfta.insert(lfta_sigs[l]); + } + +// generate the unpacking code + ret += "\tif("; + set::iterator sii; + for(sii=clfta.begin();sii!=clfta.end();++sii){ + if(sii!=clfta.begin()) + ret += " || "; + sprintf(tmpstr,"((retval & %lluull) == %lluull)",(*sii),(*sii)); + ret += tmpstr; + } + ret += ")\n\t\t"+Schema->get_ufcn_fcn((*ssi))+"(p);\n"; + } + + + ret += "\treturn(retval);\n\n"; + ret += "}\n\n"; + + +// -------------------------------------------------------- +// reuse prefilter body for snaplen calculator +// +// This is dummy code, so I'm commenting it out. + +/* + ret+="gs_uint32_t lfta_pkt_snaplen(void *pkt){\n"; + + ret += body; + + int i; + vector s_snaps = lfta_snap_lens; + sort(s_snaps.begin(), s_snaps.end()); + + if(s_snaps[0] == -1){ + set sigset; + for(i=0;i::iterator sulli; + for(sulli=sigset.begin();sulli!=sigset.end();++sulli){ + if(sulli!=sigset.begin()) + ret += " || "; + sprintf(tmpstr,"((retval & %lluull) == %lluull)",(*sulli),(*sulli)); + ret += tmpstr; + } + ret += ") return -1;\n"; + } + + int nextpos = lfta_snap_lens.size()-1; + int nextval = lfta_snap_lens[nextpos]; + while(nextval >= 0){ + set sigset; + for(i=0;i::iterator sulli; + for(sulli=sigset.begin();sulli!=sigset.end();++sulli){ + if(sulli!=sigset.begin()) + ret += " || "; + sprintf(tmpstr,"((retval & %lluull) == %lluull)",(*sulli),(*sulli)); + ret += tmpstr; + } + ret += ") return "+int_to_string(nextval)+";\n"; + + for(nextpos--;nextpos>0 && lfta_snap_lens[nextpos] == nextval;nextpos--); + if(nextpos>0) + nextval = lfta_snap_lens[nextpos]; + else + nextval = -1; + } + ret += "\treturn 0;\n"; + ret += "}\n\n"; +*/ + + + return(ret); +} + + + + +// Generate the struct which will store the the values of +// temporal attributesunpacked by prefilter +string generate_lfta_prefilter_struct(col_id_set &cid_set, table_list *Schema) { + + col_id_set::iterator csi; + +// printf("generate_lfta_prefilter_struct : %d vars\n",cid_set.size()); + + string ret="struct prefilter_unpacked_temp_vars {\n"; + ret += "\t/*\tVariables for unpacking temporal attributes\t*/\n"; + + string init_code; + + for(csi=cid_set.begin(); csi!=cid_set.end();++csi){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(Schema->get_type_name(schref,field), Schema->get_modifier_list(schref,field)); + sprintf(tmpstr,"\t%s unpack_var_%s_%d;\n",dt.get_cvar_type().c_str(), + field.c_str(), tblref); + ret += tmpstr; + + if (init_code != "") + init_code += ", "; + if (dt.is_increasing()) + init_code += dt.get_min_literal(); + else + init_code += dt.get_max_literal(); + + } + ret += "};\n\n"; + + ret += "struct prefilter_unpacked_temp_vars prefilter_temp_vars = {" + init_code + "};\n\n"; + + return(ret); +} diff --git a/src/ftacmp/generate_lfta_code.h b/src/ftacmp/generate_lfta_code.h new file mode 100644 index 0000000..a1dbe4e --- /dev/null +++ b/src/ftacmp/generate_lfta_code.h @@ -0,0 +1,37 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __GENERATE_FTA_CODE_H_DEFINED__ +#define __GENERATE_FTA_CODE_H_DEFINED__ + +#include +#include +#include "parse_fta.h" +#include "parse_schema.h" +#include "query_plan.h" +#include"nic_def.h" + + +std::string generate_lfta_block(qp_node *fs, table_list *schema, int gid, +// std::map &int_fcn_defs, + ext_fcn_list *Ext_fcns, std::string &schema_embed_str, ifq_t *ifdb, nic_property *nicp, set &s_pids); + +std::string generate_lfta_prefilter(std::vector &pred_list, col_id_set &temp_cids, table_list *Schema, ext_fcn_list *Ext_fcns, std::vector &lfta_cols, std::vector &lfta_sigs, vector &lfta_snap_lens, std::string iface); +std::string generate_lfta_prefilter_struct(col_id_set &temp_cids, table_list *Schema); + +int compute_snap_len(qp_node *fs, table_list *schema); + + +#endif + diff --git a/src/ftacmp/generate_nic_code.cc b/src/ftacmp/generate_nic_code.cc new file mode 100644 index 0000000..77de31a --- /dev/null +++ b/src/ftacmp/generate_nic_code.cc @@ -0,0 +1,543 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include +#include +#include +#include + +#include "parse_fta.h" +#include "parse_schema.h" +#include "analyze_fta.h" +#include "generate_utils.h" +#include "query_plan.h" +#include "generate_nic_code.h" +#include"analyze_fta.h" + +#define LEFT 1 +#define RIGHT 2 + +using namespace std; + +static const char *fcn_for_op[] = { + "+", "plus", + "-", "minus", + "|", "bitwise_or", + "*", "multiply", + "/", "divide", + "&", "bitwise_and", + "%", "modulo", + ">>", "shift_right", + "<<", "shift_left", + "AND", "AND", + "OR", "OR", + "=", "equal", + ">", "greater", + "<", "less", + ">=", "greater_equal", + "<=", "less_equal", + "<>", "not_equal", + "END" +}; + +static const char *fcn_for_unary_op[]= { + "+", "unary_plus", + "-", "unary_minus", + "!", "integer_not", + "~", "bitwise_not", + "NOT", "logical_not", + "END" +}; + +static string nic_fcn(string op){ +int i = 0; +bool done = false; + + while(!done){ + if(string(fcn_for_op[i]) == string("END")){ + done = true; + break; + } + if(string(fcn_for_op[i]) == op){ + return string(fcn_for_op[i+1]); + } + i++; + } + fprintf(stderr,"INTERNAL ERROR, operator %s not found in nic_fcn\n",op.c_str()); + return string("ERROR"); +} + + +static string unary_nic_fcn(string op){ +int i = 0; +bool done = false; + + while(!done){ + if(string(fcn_for_unary_op[i]) == string("END")){ + done = true; + break; + } + if(string(fcn_for_unary_op[i]) == op){ + return string(fcn_for_unary_op[i+1]); + } + i++; + } + fprintf(stderr,"INTERNAL ERROR, operator %s not found in unary_nic_fcn\n",op.c_str()); + return string("ERROR"); +} + + + + +// Generate code that makes reference +// to the tuple, and not to any aggregates. +static string generate_nic_se_code(scalarexp_t *se, + map &constants, + int ©_var_cnt, + set &no_copy_vars, + string *retvar, int lr, + gb_table *gbt ){ + + string ret = ""; + string l,cid; + data_type *ldt, *rdt; + int o; + vector operands; + string lvar, rvar; + int gbref; + + string op = se->get_op(); +//printf("op_type=%d op=%s\n",se->get_operator_type(),op.c_str()); + + switch(se->get_operator_type()){ + case SE_LITERAL: + l = se->get_literal()->to_query_string(); + if(constants.count(l)){ + cid = constants[l]; + }else{ + cid = "constant"+int_to_string(constants.size()); + constants[cid] = l; + } + *retvar = cid; + if(lr == LEFT){ + *retvar = "copyvar_"+int_to_string(copy_var_cnt); + copy_var_cnt++; + ret += "load_with_copy("+*retvar+","+cid+")\n"; + } + return(ret); + case SE_PARAM: + fprintf(stderr,"INTERNAL ERROR, param ref'd in generate_nic_se_code\n"); + *retvar = "error"; + return("ERROR in generate_nic_se_code"); + case SE_UNARY_OP: + ret += generate_nic_se_code(se->get_left_se(), + constants, copy_var_cnt, no_copy_vars, &lvar,LEFT,gbt); + ret += unary_nic_fcn(op)+"("+lvar+")\n"; + *retvar = lvar; + return(ret); + case SE_BINARY_OP: + ret += generate_nic_se_code(se->get_left_se(), + constants, copy_var_cnt, no_copy_vars, &lvar,LEFT,gbt); + ret += generate_nic_se_code(se->get_right_se(), + constants, copy_var_cnt, no_copy_vars, &rvar,RIGHT,gbt); + ret += nic_fcn(op)+"("+lvar+","+rvar+")\n"; + *retvar = lvar; +//printf("op %s; lvar=%s, rvar=%s, retvar=%s\n",op.c_str(), lvar.c_str(), rvar.c_str(), retvar->c_str()); + return(ret); + case SE_COLREF: + if(se->is_gb()){ + gbref = se->get_gb_ref(); +/* + if(gbt->get_reftype(gbref) != GBVAR_COLREF){ + fprintf(stderr,"INTERNAL ERROR, non-colref gbvar in generate_nic_se_code\n"); + exit(1); + } +*/ + ret = generate_nic_se_code(gbt->get_def(gbref),constants,copy_var_cnt, no_copy_vars, &lvar,LEFT,gbt); + *retvar = lvar; + return ret; + } + if(lr == LEFT){ + *retvar = "copyvar_"+int_to_string(copy_var_cnt); + copy_var_cnt++; + ret += "load_with_copy("+*retvar+","+se->get_colref()->get_field()+")\n"; + }else{ + *retvar = "nocopyvar_"+se->get_colref()->get_field(); + if(no_copy_vars.count(*retvar) == 0){ + no_copy_vars.insert(*retvar); + ret += "load("+*retvar+","+se->get_colref()->get_field()+")\n"; + } + } + return ret; + + case SE_FUNC: + fprintf(stderr,"CONFIG ERROR, fcn reference in generate_nic_se_code, not yet implemented.\n"); + *retvar = "error"; + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_nic_se_code (lfta), line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + *retvar = "error"; + return("ERROR in generate_nic_se_code"); + } +} + + +static string generate_nic_predicate_code(predicate_t *pr, + map &constants, + int ©_var_cnt, + set &no_copy_vars, + string *retvar, gb_table *gbt ){ + string ret; + vector litv; + int i; + data_type *ldt, *rdt; + vector op_list; + int o; + string lvar, rvar; + string l,cid; + string op = pr->get_op(); + + switch(pr->get_operator_type()){ + case PRED_IN: + fprintf(stderr,"CONFIG ERROR: IN not supported in generate_nic_predicate_code\n"); + *retvar = "error"; + return("ERROR in generate_nic_predicate_code"); + + case PRED_COMPARE: + ret += generate_nic_se_code(pr->get_left_se(), + constants, copy_var_cnt, no_copy_vars, &lvar,LEFT,gbt); + ret += generate_nic_se_code(pr->get_right_se(), + constants, copy_var_cnt, no_copy_vars, &rvar,RIGHT,gbt); + ret += nic_fcn(op)+"("+lvar+","+rvar+")\n"; + *retvar = lvar; + return(ret); + case PRED_UNARY_OP: + ret += generate_nic_predicate_code(pr->get_left_pr(), + constants, copy_var_cnt, no_copy_vars, &lvar,gbt); + ret += unary_nic_fcn(op)+"("+lvar+")\n"; + *retvar = lvar; + return(ret); + case PRED_BINARY_OP: + ret += generate_nic_predicate_code(pr->get_left_pr(), + constants, copy_var_cnt, no_copy_vars, &lvar,gbt); + ret += generate_nic_predicate_code(pr->get_right_pr(), + constants, copy_var_cnt, no_copy_vars, &rvar,gbt); + ret += nic_fcn(op)+"("+lvar+","+rvar+")\n"; + *retvar = lvar; + return(ret); + case PRED_FUNC: + fprintf(stderr,"CONFIG ERROR, fcn reference in generate_nic_pred_code, not yet implemented.\n"); + *retvar = "error"; + return(ret); + ret += " )"; + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_predicate_nic_code, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + return("ERROR in generate_nic_predicate_code"); + } +} + + +bool se_is_nic_safe(scalarexp_t *se, nic_property *nicp, gb_table *gbt){ + string dts, colname; + bool rs, ls; + int gbref; + + switch(se->get_operator_type()){ + case SE_LITERAL: + dts = se->get_data_type()->get_type_str(); + if(nicp->legal_type(dts)) + return true; + return false; + break; + case SE_PARAM: + return false; + break; + case SE_UNARY_OP: + if(!se_is_nic_safe(se->get_left_se(), nicp, gbt)) return false; + return(nicp->legal_unary_op(se->get_op())); + break; + case SE_BINARY_OP: + if(!se_is_nic_safe(se->get_left_se(), nicp, gbt)) return false; + if(!se_is_nic_safe(se->get_right_se(), nicp, gbt)) return false; + return(nicp->legal_binary_op(se->get_op())); + break; + case SE_COLREF: + if(se->is_gb()){ + gbref = se->get_gb_ref(); +/* + if(gbt->get_reftype(gbref) != GBVAR_COLREF){ + return false; + } +*/ + return se_is_nic_safe(gbt->get_def(gbref),nicp,gbt); + } + dts = se->get_data_type()->get_type_str(); + if(! nicp->legal_type(dts)) + return false; + colname = se->get_colref()->get_field(); + if(! nicp->illegal_field(colname)) + return true; + return false; + break; + case SE_FUNC: + return false; + default: + return false; + } + + return false; +} + + +bool pr_is_nic_safe(predicate_t *pr, nic_property *nicp, gb_table *gbt){ + string dts, colname; + bool rs, ls; + switch(pr->get_operator_type()){ + case PRED_IN: + return false; + case PRED_COMPARE: + if(!se_is_nic_safe(pr->get_left_se(), nicp, gbt)) return false; + if(!se_is_nic_safe(pr->get_right_se(), nicp, gbt)) return false; + return(nicp->legal_binary_op(pr->get_op())); + case PRED_UNARY_OP: + if(!pr_is_nic_safe(pr->get_left_pr(),nicp, gbt)) return false; + return(nicp->legal_unary_op(pr->get_op())); + case PRED_BINARY_OP: + if(!pr_is_nic_safe(pr->get_left_pr(),nicp, gbt)) return false; + if(!pr_is_nic_safe(pr->get_right_pr(),nicp, gbt)) return false; + return(nicp->legal_binary_op(pr->get_op())); + case PRED_FUNC: + return false; + default: + return false; + } + + return false; +} + + +void gather_nicsafe_cols(scalarexp_t *se, vector &cols, nic_property *nicp, gb_table *gbt){ + int i, gbref; + string colname; + vector operands; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + return; + case SE_UNARY_OP: + gather_nicsafe_cols(se->get_left_se(),cols,nicp, gbt); + return; + case SE_BINARY_OP: + gather_nicsafe_cols(se->get_left_se(),cols,nicp, gbt); + gather_nicsafe_cols(se->get_right_se(),cols,nicp, gbt); + return; + case SE_COLREF: + if(se->is_gb()){ + gbref = se->get_gb_ref(); + return gather_nicsafe_cols(gbt->get_def(gbref),cols,nicp, gbt); + } + colname = se->get_colref()->get_field(); + if(! nicp->illegal_field(colname)){ + for(i=0;iget_operands(); + for(i=0;i &cols, nic_property *nicp, gb_table *gbt){ + string dts, colname; + bool rs, ls; + vector operands; + int i; + + switch(pr->get_operator_type()){ + case PRED_IN: + gather_nicsafe_cols(pr->get_left_se(), cols, nicp, gbt); + return ; + case PRED_COMPARE: + gather_nicsafe_cols(pr->get_left_se(), cols, nicp, gbt); + gather_nicsafe_cols(pr->get_right_se(), cols, nicp, gbt); + return; + case PRED_UNARY_OP: + gather_nicsafe_cols(pr->get_left_pr(),cols, nicp, gbt); + return; + case PRED_BINARY_OP: + gather_nicsafe_cols(pr->get_left_pr(),cols, nicp, gbt); + gather_nicsafe_cols(pr->get_right_pr(),cols, nicp, gbt); + return; + case PRED_FUNC: + operands = pr->get_op_list(); + for(i=0;i lftas, nic_property *nicp){ + int i,p,s,g; + string ret = ""; + string vars = ""; + gb_table *gbtbl; + + bool packed_return = false; + + if(nicp->option_exists("Return")){ + if(nicp->option_value("Return") == "Packed"){ +//printf("val of Return is %s\n",nicp->option_value("Return").c_str()); + packed_return = true; + }else{ + fprintf(stderr,"Warning, nic option value of Return=%s is not recognized, ignoring\n",nicp->option_value("Return").c_str()); + } + } + + vector > nicsafe_preds; + vector empty_list; + for(i=0;iget_query_head(); + if(qpn->node_type() == "sgah_qpn"){ + gbtbl = ((sgah_qpn *)(qpn))->get_gb_tbl(); + }else{ + gbtbl = NULL; + } + nicsafe_preds.push_back(empty_list); + vector lfta_cnfs = qpn->get_filter_clause(); + for(p=0;ppr,nicp,gbtbl)){ + nicsafe_preds[i].push_back(lfta_cnfs[p]->pr); + } + } + } + + map consts; + int n_copyvar = 0; + set nocopy_vars; + string retvar; + + if(packed_return){ +//printf("dping packed return\n"); + for(i=0;iget_query_head(); + ret += "comment( lfta "+qpn->get_node_name() + " )\n"; + if(qpn->node_type() == "sgah_qpn"){ + gbtbl = ((sgah_qpn *)(qpn))->get_gb_tbl(); + }else{ + gbtbl = NULL; + } + ret += "\nlabel(lfta"+int_to_string(i)+")\n"; + for(p=0;p se_list; + if(qpn->node_type() == "sgah_qpn"){ + se_list =((sgah_qpn *)(qpn))->get_select_se_list(); + }else{ + se_list =((spx_qpn *)(qpn))->get_select_se_list(); + } + + vector refd_cols; + for(s=0;s lfta_cnfs = qpn->get_where_clause(); + for(p=0;ppr,refd_cols, nicp, gbtbl); + } + if(gbtbl){ + for(g=0;gsize();++g){ +//printf("gathering gbvar %d\n",g); + gather_nicsafe_cols(gbtbl->get_def(g),refd_cols, nicp, gbtbl); + } + } + sort(refd_cols.begin(), refd_cols.end()); + + ret += "pack_and_send(const_id"+int_to_string(i); + consts["const_id"+int_to_string(i)] = int_to_string(lftas[i]->get_gid()); + for(s=0;sget_query_head(); + ret += "comment( lfta "+qpn->get_node_name() + " )\n"; + if(qpn->node_type() == "sgah_qpn"){ + gbtbl = ((sgah_qpn *)(qpn))->get_gb_tbl(); + }else{ + gbtbl = NULL; + } + ret += "\nlabel(lfta"+int_to_string(i)+")\n"; + for(p=0;p::iterator mssi; + for(mssi=consts.begin();mssi!=consts.end();++mssi){ + vars += "constant( "+(*mssi).first+" , "+(*mssi).second+")\n"; + } + for(i=0;i::iterator ssi; + for(ssi=nocopy_vars.begin(); ssi!=nocopy_vars.end(); ++ssi){ + vars += "variable( "+(*ssi)+" )\n"; + } + + ret = "BEGIN\n"+vars + "\n"+ret + "END\n"; + + return ret; + +} + + diff --git a/src/ftacmp/generate_nic_code.h b/src/ftacmp/generate_nic_code.h new file mode 100644 index 0000000..a41cbc0 --- /dev/null +++ b/src/ftacmp/generate_nic_code.h @@ -0,0 +1,30 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef _generate_nic_code_h__ +#define _generate_nic_code_h__ + +#include"nic_def.h" +#include"stream_query.h" +#include +#include + + +std::string generate_nic_code(std::vector lftas, nic_property *nicp); +void gather_nicsafe_cols(scalarexp_t *se, std::vector &cols, nic_property *nicp, gb_table *gbt); +void gather_nicsafe_cols(predicate_t *pr, std::vector &cols, nic_property *nicp, gb_table *gbt); + + + +#endif diff --git a/src/ftacmp/generate_utils.cc b/src/ftacmp/generate_utils.cc new file mode 100644 index 0000000..8285d74 --- /dev/null +++ b/src/ftacmp/generate_utils.cc @@ -0,0 +1,391 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +// This file contains functions used by more than one +// code generation system. + + +#include"generate_utils.h" +#include"lapp.h" + + +using namespace std; + + +static char tmpstr[1000]; + + +// Replace dots in node name with underscore to prevent generating variable +// and structure names with dots inside +string normalize_name(string name) { + string ret = name; + int pos = ret.find('.'); + while (pos >=0) { + ret = ret.replace(pos, 1, "_"); + pos = ret.find('.', pos + 1); + } + pos = ret.find('/'); + while (pos >=0) { + ret = ret.replace(pos, 1, "_XX_"); + pos = ret.find('/', pos + 1); + } + return ret; +} + + +// name of tuple struct + +string generate_tuple_name(string node_name){ + string ret = normalize_name(node_name); + if(ret == ""){ + ret = "default"; + } + ret.append("_tuple"); + + return(ret); +} + + +// LFTA allocation function name. + +string generate_alloc_name(string node_name){ + string ret = normalize_name(node_name); + if(ret == ""){ + ret = "default"; + } + ret.append("_fta_alloc"); + + return(ret); +} + + +// The name of the schema definition string. + +string generate_schema_string_name(string node_name){ + string ret = normalize_name(node_name); + if(ret == ""){ + ret = "default"; + } + ret += "_schema_definition"; + + return(ret); +} + + + +// Generate representations of a tuple. +// LFTA and HFTA use slightly different names. + +string generate_tuple_struct(string node_name, vector sl_list){ + string ret = "struct "+generate_tuple_name(normalize_name(node_name))+"{\n"; + + int s; + for(s=0;sget_data_type()->make_tuple_cvar(tmpstr)+";\n"; + } + ret.append("\tgs_int8_t tuple_type;\n"); + ret.append("} __attribute__ ((__packed__));\n\n"); + + return(ret); +} + + +// generate_host_tuple_struct uses numbered fields, +// while generate_host_name_tuple_struct uses the filed names themselves. +// TODO: change over from generate_host_tuple_struct +// to generate_host_name_tuple_struct +string generate_host_name_tuple_struct(table_def *td){ + string ret = "struct "+generate_tuple_name(normalize_name(td->get_tbl_name()))+"{\n"; + + vector flds = td->get_fields(); + + int f; + for(f=0;fget_type()); +//fprintf(stderr,"tbl=%s, fld=%s, type=%s, dt.type=%d, dt.schema_type=%s\n",td->get_tbl_name().c_str(), flds[f]->get_name().c_str(),flds[f]->get_fcn().c_str(), dt.get_type(),dt.get_type_str().c_str()); + ret+="\t"+dt.make_host_cvar(flds[f]->get_name())+";\n"; + } + ret.append("\tgs_int8_t tuple_type;\n"); + ret.append("} __attribute__ ((__packed__));\n\n"); + + return(ret); +} + +string generate_host_tuple_struct(table_def *td){ + string ret = "struct "+generate_tuple_name(normalize_name(td->get_tbl_name()))+"{\n"; + + vector flds = td->get_fields(); + + int f; + for(f=0;fget_type()); +//fprintf(stderr,"tbl=%s, fld=%s, type=%s, dt.type=%d, dt.schema_type=%s out=%s\n",td->get_tbl_name().c_str(), flds[f]->get_name().c_str(),flds[f]->get_type().c_str(), dt.get_type(),dt.get_type_str().c_str(),dt.make_host_cvar(tmpstr).c_str()); + sprintf(tmpstr,"tuple_var%d",f); + ret+="\t"+dt.make_host_tuple_cvar(tmpstr)+";\n"; + } + ret.append("} __attribute__ ((__packed__));\n\n"); + + return(ret); +} + + +// convert internal tuple format to exteral tuple format. +// mostly, perform htonl conversions. + +string generate_hfta_finalize_tuple(table_def *td){ + string ret = "void finalize_tuple(host_tuple &tup){\n"; + ret += "\tstruct "+generate_tuple_name(normalize_name(td->get_tbl_name()))+" *tuple = ("+ + generate_tuple_name(td->get_tbl_name())+" *)(tup.data);\n"; + + + vector flds = td->get_fields(); + +/* + int f; + for(f=0;fget_type()); + if(dt.get_type() == v_str_t){ + sprintf(tmpstr,"\ttuple->tuple_var%d.offset = htonl(tuple->tuple_var%d.offset);\n",f,f); + ret += tmpstr; + sprintf(tmpstr,"\ttuple->tuple_var%d.length = htonl(tuple->tuple_var%d.length);\n",f,f); + ret += tmpstr; + sprintf(tmpstr,"\ttuple->tuple_var%d.reserved = htonl(tuple->tuple_var%d.reserved);\n",f,f); + ret += tmpstr; + }else{ + if(dt.needs_hn_translation()){ + sprintf(tmpstr,"\ttuple->tuple_var%d = %s(tuple->tuple_var%d);\n", + f, dt.hton_translation().c_str(), f); + ret += tmpstr; + } + } + } +*/ + ret.append("};\n\n"); + + return(ret); +} + + + + +// make code translation so that it embeds +// as a C-string -- escape the escape characters. + +string make_C_embedded_string(string &instr){ + string outstr = "\""; + int i; + for(i=0;iget_tbl_name())+"_tuple(host_tuple *tup, char *buf, int len, struct "+generate_tuple_name(normalize_name(td->get_tbl_name()))+" *s, gs_int8_t tuple_type){\n"; + ret += +"\tstruct "+generate_tuple_name(td->get_tbl_name())+" *d;\n"; + + vector flds = td->get_fields(); + + ret+="\tif (tuple_type == TEMPORAL_TUPLE) {\n"; + ret+="\t\td=(struct "+generate_tuple_name(td->get_tbl_name())+" *)buf;\n"; + ret+="\t\ttup->data = (char *)d;\n"; + ret+="\t\ttup->heap_resident=false;\n"; + for(f=0;fget_type(),flds[f]->get_modifier_list()); + if (dt.is_temporal()) { + string fldnm = flds[f]->get_name(); +// if(dt.needs_hn_translation()) +// ret+="\t\td->"+fldnm+"="+dt.hton_translation()+"(s->"+fldnm+");\n"; +// else + ret+="\t\td->"+fldnm+"=s->"+fldnm+";\n"; + } + } + ret += "\t\td->tuple_type = TEMPORAL_TUPLE;\n"; + ret += "\t\ttup->tuple_size=sizeof(struct "+generate_tuple_name(td->get_tbl_name())+");\n"; + ret += "\t\treturn 0;\n}\n"; + + + bool uses_buffer_type = false; + for(f=0;fget_type()); + if(dt.is_buffer_type()) uses_buffer_type = true; + } + + if(!uses_buffer_type){ + ret+="\td=s;\n"; + ret+="\ttup->data = (char *)d;\n"; + ret+="\ttup->heap_resident=false;\n"; + for(f=0;fget_type()); + string fldnm = flds[f]->get_name(); +// if(dt.needs_hn_translation()) +// ret+="\td->"+fldnm+"="+dt.hton_translation()+"(s->"+fldnm+");\n"; +// else + ret+="\td->"+fldnm+"=s->"+fldnm+";\n"; + } + ret+= +"\ttup->tuple_size=sizeof(struct "+generate_tuple_name(td->get_tbl_name())+");\n"; + }else{ + ret+="\tint pos=sizeof(struct "+generate_tuple_name(td->get_tbl_name())+");\n"; + ret+="\td=(struct "+generate_tuple_name(td->get_tbl_name())+" *)buf;\n"; + ret+="\ttup->data = (char *)d;\n"; + ret+="\ttup->heap_resident=false;\n"; + for(f=0;fget_type()); + string fldnm = flds[f]->get_name(); + if(dt.is_buffer_type()){ + ret+="\tif(pos+"+dt.get_hfta_buffer_size()+"(&(s->"+fldnm+"))>len) return 1;\n"; + ret+="\t"+dt.get_hfta_buffer_tuple_copy()+"(&(d->"+fldnm+"),&(s->"+fldnm+"), buf+pos, pos);\n"; + ret+="\tpos+="+dt.get_hfta_buffer_size()+"(&(s->"+fldnm+"));\n"; +// ret+="\td->"+fldnm+".length = htonl(d->"+fldnm+".length);\n"; +// ret+="\td->"+fldnm+".offset = htonl(d->"+fldnm+".offset);\n"; +// ret+="\td->"+fldnm+".reserved = htonl(d->"+fldnm+".reserved);\n"; + }else{ +// if(dt.needs_hn_translation()) +// ret+="\td->"+fldnm+"="+dt.hton_translation()+"(s->"+fldnm+");\n"; +// else + ret+="\td->"+fldnm+"=s->"+fldnm+";\n"; + } + } + ret+="\ttup->tuple_size=pos;\n"; + } + + ret+= "\td->tuple_type = REGULAR_TUPLE;\n"; + + ret += "\treturn 0;\n"; + ret+="}\n\n"; + + return(ret); +} + + +string generate_host_tuple_unpack(table_def *td){ + int f; + string ret = "struct "+generate_tuple_name(normalize_name(td->get_tbl_name())) +" *unpack_"+normalize_name(td->get_tbl_name())+"_tuple(host_tuple *tup){\n"; + ret += "\tstruct "+generate_tuple_name(normalize_name(td->get_tbl_name()))+" *d;\n"; + ret+="\td=(struct "+generate_tuple_name(normalize_name(td->get_tbl_name()))+" *)(tup->data);\n"; + ret+="\tif(tup->tuple_sizeget_tbl_name())) +")) return NULL;\n"; + + vector flds = td->get_fields(); + + for(f=0;fget_type()); + string fldnm = flds[f]->get_name(); + if(dt.is_buffer_type()){ +// ret+="\td->"+fldnm+".length = ntohl(d->"+fldnm+".length);\n"; +// ret+="\td->"+fldnm+".offset = ntohl(d->"+fldnm+".offset);\n"; + ret+="\td->"+fldnm+".reserved = SHALLOW_COPY;\n"; + ret+="\tif(d->"+fldnm+".offset+d->"+fldnm+".length>tup->tuple_size) return NULL;\n"; + ret+="\td->"+fldnm+".offset+=(unsigned int)(tup->data);\n"; + }else{ +// if(dt.needs_hn_translation()) +// ret+="\td->"+fldnm+"="+dt.ntoh_translation()+"(d->"+fldnm+");\n"; + } + } + + ret += "\treturn d;\n"; + ret+="}\n\n"; + + return(ret); +} +// Functions related to parsing. + + int split_string(char *instr,char sep, char **words,int max_words){ + char *loc; + char *str; + int nwords = 0; + + str = instr; + words[nwords++] = str; + while( (loc = strchr(str,sep)) != NULL){ + *loc = '\0'; + str = loc+1; + if(nwords >= max_words){ + fprintf(stderr,"Error in split_string, too many words discovered (max is %d)\n",max_words); + nwords = max_words-1; + } + words[nwords++] = str; + } + + return(nwords); +} + +// For fast hashing +string hash_nums[NRANDS] = { +"12916008961267169387ull", "13447227858232756685ull", +"15651770379918602919ull", "1154671861688431608ull", +"6777078091984849858ull", "14217205709582564356ull", +"4955408621820609982ull", "15813680319165523695ull", +"9897969721407807129ull", "5799700135519793083ull", +"3446529189623437397ull", "2766403683465910630ull", +"3759321430908793328ull", "6569396511892890354ull", +"11124853911180290924ull", "17425412145238035549ull", +"6879931585355039943ull", "16598635011539670441ull", +"9615975578494811651ull", "4378135509538422740ull", +"741282195344332574ull", "17368612862906255584ull", +"17294299200556814618ull", "518343398779663051ull", +"3861893449302272757ull", "8951107288843549591ull", +"15785139392894559409ull", "5917810836789601602ull", +"16169988133001117004ull", "9792861259254509262ull", +"5089058010244872136ull", "2130075224835397689ull", +"844136788226150435ull", "1303298091153875333ull", +"3579898206894361183ull", "7529542662845336496ull", +"13151949992653382522ull", "2145333536541545660ull", +"11258221828939586934ull", "3741808146124570279ull", +"16272841626371307089ull", "12174572036188391283ull", +"9749343496254107661ull", "9141275584134508830ull", +"10134192232065698216ull", "12944268412561423018ull", +"17499725811865666340ull", "5281482378159088661ull", +"13254803486023572607ull", "4526762838498717025ull", +"15990846379668494011ull", "10680949816169027468ull", +"7116154096012931030ull", "5296740689865236632ull", +"5222427027515795922ull", "6893215299448261251ull", +"10164707755932877485ull", "15325979189512082255ull", +"3713267224148573289ull", "12292682741753167354ull", +"4098115959960163588ull", "16095675565885113990ull", +"11391590846210510720ull", "8432889531466002673ull", +"7146668520368482523ull", "7678169991822407997ull", +"9882712513525031447ull", "13904414563513869160ull", +"1080076724395768626ull", "8448147843172150388ull", +"17633093729608185134ull", "10044622457050142303ull", +"4128911859292425737ull", "30642269109444395ull", +"16124215396922640581ull", "15444089895060081110ull", +"16437006538696302944ull", "800338649777443426ull", +"5355794945275091932ull", "11656354278827687117ull", +"1110873718944691255ull", "10829576045617693977ull", +"3846916616884579955ull", "17055821716837625668ull", +"13418968402643535758ull", "11671612594828802128ull", +"11597298928184328586ull", "13196028510862205499ull", +"16539578557089782373ull", "3182048322921507591ull", +"10016080431267550241ull", "148751875162592690ull", +"10400930266590768572ull", "4023803397139127870ull", +"17766462746879108920ull", "14807761432134600873ull", +"13521540421053792403ull", "13980983198941385205ull", +"16257584414193564367ull", "1760484796451765024ull" +}; + + diff --git a/src/ftacmp/generate_utils.h b/src/ftacmp/generate_utils.h new file mode 100644 index 0000000..ba8e1a8 --- /dev/null +++ b/src/ftacmp/generate_utils.h @@ -0,0 +1,82 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __GENERATE_UTILS_H_DEFINED__ +#define __GENERATE_UTILS_H_DEFINED__ + +#include +#include + +#include "parse_fta.h" +#include "analyze_fta.h" +#include "nic_def.h" + +// This file contains functions used by more than one +// code generation system. + + +// replaces dots in node names with undescores - dots are illegal in C variable names +std::string normalize_name(std::string name); + + +// name of tuple struct + +std::string generate_tuple_name(std::string node_name); + + +// LFTA allocation function name. + +std::string generate_alloc_name(std::string node_name); + + +// The name of the schema definition string. + +std::string generate_schema_string_name(std::string node_name); + + +// Generate representations of a tuple. +// LFTA and HFTA use slightly different names. + +std::string generate_tuple_struct(std::string node_name, + std::vector sl_list); + +std::string generate_host_tuple_struct(table_def *td); +std::string generate_host_name_tuple_struct(table_def *td); + + +// convert internal tuple format to exteral tuple format. +// mostly, perform htonl conversions. + +std::string generate_hfta_finalize_tuple(table_def *td); + + + +// make code translation so that it embeds +// as a C-string -- escape the escape characters. + +std::string make_C_embedded_string(std::string &instr); + +// pack, unpack tuple struct for use by user defined operators. +std::string generate_host_tuple_pack(table_def *td); +std::string generate_host_tuple_unpack(table_def *td); + +int split_string(char *instr,char sep, char **words,int max_words); + + +// # random numbers for hashing +#define NRANDS 100 + + +#endif + diff --git a/src/ftacmp/iface_q.cc b/src/ftacmp/iface_q.cc new file mode 100644 index 0000000..3b74acd --- /dev/null +++ b/src/ftacmp/iface_q.cc @@ -0,0 +1,649 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include "iface_q.h" +#include +#include +#include +#include + + +using namespace std; + +extern string hostname; // namne of the current host + +static string int_to_string(int i){ + string ret; + char tmpstr[100]; + sprintf(tmpstr,"%d",i); + ret=tmpstr; + return(ret); +} + + +// Interface for the res parser +extern int ResParserparse(void); +extern FILE *ResParserin; +extern int ResParserdebug; +void ResParser_setfileinput(FILE *f); +void ResParser_setstringinput(char *s); +extern int flex_res_lineno; + +resparse_data *rpd_ptr; +vector res_val_vec, res_attr_vec; +string res_a, res_v; + +/////////////////////////////////////// +/// iface_t methods + + void iface_t::add_property(const char *name, const char *att){ + string nm(name); + std::transform(nm.begin(), nm.end(), nm.begin(), (int(*)(int))std::tolower); + vals[nm].push_back(att); + } + + void iface_t::add_property(const char *name, const char **atts){ + string val = ""; + string nm = name; + std::transform(nm.begin(), nm.end(), nm.begin(), (int(*)(int))std::tolower); + if(atts[0]) val = atts[1]; + + vals[nm].push_back(val); + } + + void iface_t::add_property(const char *name, vector &val_vec){ + string val = ""; + string nm = name; + std::transform(nm.begin(), nm.end(), nm.begin(), (int(*)(int))std::tolower); + if(val_vec.size()) val = val_vec[0]; + + vals[nm].push_back(val); + } + + int iface_t::finalize(string &errs){ + string tag ="ERROR in interface starting at line "+int_to_string(lineno)+", "; + string e; + if(vals.count("name") == 0){ + e += "Name not specified. "; + }else{ + if(vals["name"].size() > 1){ + e+="More than one name specified. "; + } + } + + if(e != ""){ + errs += tag + e + "\n"; + return(1); + } + return(0); + } + + string iface_t::to_string(){ + int i; + string ret = "Interface "+vals["name"][0]+":\n"; + map >::iterator svmi; + for(svmi=vals.begin();svmi!=vals.end();++svmi){ + ret += "\t"+(*svmi).first + " : "; + for(i=0;i<((*svmi).second).size();++i){ + if(i>0) ret+=", "; + ret += (*svmi).second[i]; + } + ret += "\n"; + } + + return ret; + } + + string iface_t::get_name(){ + if(vals.count("name") == 0) return (string)""; + return (vals["name"])[0]; + } + + string iface_t::get_host(){ + if(vals.count("host") == 0) return (string)""; + return (vals["host"])[0]; + } + + + bool iface_t::eval_Contains(string prop, string val){ + // convert to lowercase + std::transform(prop.begin(), prop.end(), prop.begin(), (int(*)(int))std::tolower); + + if(vals.count(prop) == 0) return false; + int i; + for(i=0;i &val_vec){ + string val = ""; + string nm = name; + std::transform(nm.begin(), nm.end(), nm.begin(), (int(*)(int))std::tolower); + if(val_vec.size()) val = val_vec[0]; + + vals[nm].push_back(val); + } + + int gs_host_t::finalize(string &errs){ + string tag ="ERROR in host starting at line "+int_to_string(lineno)+", "; + string e; + if(vals.count("name") == 0){ + e += "Name not specified. "; + }else{ + if(vals["name"].size() > 1){ + e+="More than one name specified. "; + } + } + + if(e != ""){ + errs += tag + e + "\n"; + return(1); + } + return(0); + } + + +///////////////////////////////////////////////////////////////// +/// reparse_data methods + + int resparse_data::finalize_iface(string &errs){ + int ret = curr_iface->finalize(errs); + if(ret) { + delete curr_iface; + failure = true; + }else{ + curr_host->add_interface(curr_iface); + } + return ret; + } + + + int resparse_data::finalize_host(string &errs){ + int ret = curr_host->finalize(errs); + if(ret) { + delete curr_host; + failure = true; + }else{ + + string host = curr_host->vals["name"][0]; + // in non-distributed case we will ignore all other hosts + if (!distributed_mode) { + char buf[1000]; + if (host != hostname) + return ret; + } + // we need to exclude failed hosts + if (!use_live_hosts_file || live_hosts->count(hostname)) { + hosts.push_back(curr_host); + + // push the host name to every interface + curr_host->propagate_name(); + + // add all interfaces into interface list + for(int i=0;iifaces.size();i++) + ifaces.push_back(curr_host->ifaces[i]); + } + } + return ret; + } + + string resparse_data::to_string(){ + string ret; + int i; + for(i=0;ito_string(); + return ret; + } + + vector > resparse_data::find_ifaces(predicate_t *pr){ + int i; + vector > ret; + for(i=0;ieval_pred(i,pr)){ + pair p(ifaces[i]->get_host(), ifaces[i]->get_name()); + ret.push_back(p); + } + } + return ret; + } + + + vector resparse_data::get_ifaces_by_Name(std::string host_name, std::string if_name){ + int i; + vector ret; + for(i=0;iget_host() == host_name && ifaces[i]->get_name() == if_name) + ret.push_back(i); + + } + return ret; + } + + + bool resparse_data::eval_pred(int i, predicate_t *pr){ + vector op_list; + string prop, val; + + switch(pr->get_operator_type()){ + case PRED_IN: + fprintf(stderr,"INTERNAL ERROR in reparse_date::eval_pred, line %d, character %d, IN not supported. %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + case PRED_COMPARE: + fprintf(stderr,"INTERNAL ERROR in reparse_date::eval_pred, line %d, character %d, IN not supported. %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + case PRED_UNARY_OP: + if(pr->get_op() == "NOT") + return(! eval_pred(i, pr->get_left_pr()) ); + fprintf(stderr,"INTERNAL ERROR in reparse_date::eval_pred, line %d, character %d, unknown unary pred operator %s.\n", + pr->get_lineno(), pr->get_charno(), pr->get_op().c_str() ); + exit(1); + case PRED_BINARY_OP: + if(pr->get_op() == "AND"){ + if(! eval_pred(i, pr->get_left_pr()) ) return false; + return eval_pred(i, pr->get_right_pr()) ; + } + if(pr->get_op() == "OR"){ + if( eval_pred(i, pr->get_left_pr()) ) return true; + return eval_pred(i, pr->get_right_pr()) ; + } + fprintf(stderr,"INTERNAL ERROR in reparse_date::eval_pred, line %d, character %d, unknown binary pred operator %s.\n", + pr->get_lineno(), pr->get_charno(), pr->get_op().c_str() ); + exit(1); + case PRED_FUNC: + op_list = pr->get_op_list(); + if(op_list[0]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"INTERNAL ERROR : ifq parameters are supposed to be of type SE_PARAM, found %s at position 0\n",op_list[0]->get_op().c_str()); + exit(1); + }else{ + prop=op_list[0]->get_op(); + } + if(op_list.size() > 1){ + if(op_list[1]->get_operator_type() != SE_PARAM){ + fprintf(stderr,"INTERNAL ERROR : ifq parameters are supposed to be of type SE_PARAM, found %s at position 1\n",op_list[0]->get_op().c_str()); + exit(1); + }else{ + val=op_list[1]->get_op(); + } + } + + if(pr->get_op() == "Contains"){ + if(op_list.size() != 2){ + fprintf(stderr,"INTERNAL ERROR : predicate Contains expects 2 parameters, received %lu\n",op_list.size()); + exit(1); + } + return ifaces[i]->eval_Contains(prop,val); + } + + if(pr->get_op() == "Equals"){ + if(op_list.size() != 2){ + fprintf(stderr,"INTERNAL ERROR : predicate Equals expects 2 parameters, received %lu\n",op_list.size()); + exit(1); + } + return ifaces[i]->eval_Equals(prop,val); + } + + if(pr->get_op() == "Exists"){ + if(op_list.size() != 1){ + fprintf(stderr,"INTERNAL ERROR : predicate Exists expects 1 parameter, received %lu\n",op_list.size()); + exit(1); + } + return ifaces[i]->eval_Exists(prop); + } + + fprintf(stderr,"INTERNAL ERROR : Unknown predicate %s in reparse_date::eval_pred.\n",pr->get_op().c_str()); + exit(1); + + default: + fprintf(stderr,"INTERNAL ERROR in reparse_date::eval_pred, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(false); + + } + + +/////////////////////////////////////////// +/// XML parser callbacks for parsing interface resources + +void startElement(void *userData, const char *name, const char **atts) { + int i; + + resparse_data *rpd = (resparse_data *)userData; + rpd->level.push_back(name); + + if(rpd->level.size() == 1 && rpd->level[0] == "Resources") + rpd->in_Resources = true; + + if(rpd->in_Resources && rpd->level.size() == 2 && rpd->level[1] == "Interface"){ +// rpd->new_iface(XML_GetCurrentLineNumber(rpd->parser)); + rpd->new_iface(1); + rpd->in_Iface = true; + } + + if(rpd->in_Iface && rpd->level.size() == 3){ + rpd->add_property(name, atts); + } + + +// for(i=0;ilevel.size();++i) printf("%s, ",rpd->level[i].c_str()); +// printf("\n"); +} + +void startElement(void *userData, const char *name, vector &attr_vec, vector &val_vec){ + int i; + + resparse_data *rpd = (resparse_data *)userData; + rpd->level.push_back(name); + + if(rpd->level.size() == 1 && rpd->level[0] == "Resources") + rpd->in_Resources = true; + + if(rpd->in_Resources && rpd->level.size() == 2 && rpd->level[1] == "Host"){ +// rpd->new_iface(XML_GetCurrentLineNumber(rpd->parser)); + + rpd->new_host(flex_res_lineno); + for (int i = 0; i < attr_vec.size(); ++i) + rpd->curr_host->add_property(attr_vec[i].c_str(), val_vec[i].c_str()); + rpd->in_Host = true; + } + + if(rpd->in_Host && rpd->level.size() == 3) { + if ( rpd->level[2] == "Interface"){ + // rpd->new_iface(XML_GetCurrentLineNumber(rpd->parser)); + rpd->new_iface(flex_res_lineno); + for (int i = 0; i < attr_vec.size(); ++i) + rpd->add_property(attr_vec[i].c_str(), val_vec[i].c_str()); + rpd->in_Iface = true; + } else { + rpd->curr_host->add_property(name, val_vec); + } + } + + if(rpd->in_Iface && rpd->level.size() == 4){ + rpd->add_property(name, val_vec); + } + + +// for(i=0;ilevel.size();++i) printf("%s, ",rpd->level[i].c_str()); +// printf("\n"); +} + + +void endElement(void *userData, const char *name) { + resparse_data *rpd = (resparse_data *)userData; + + if(rpd->in_Iface && rpd->level.size() == 3){ + string err_msg; + int err = rpd->finalize_iface(err_msg); + if(err) fprintf(stderr,"%s\n",err_msg.c_str()); + } else if (rpd->in_Host && rpd->level.size() == 2) { + string err_msg; + int err = rpd->finalize_host(err_msg); + if(err) fprintf(stderr,"%s\n",err_msg.c_str()); + } + + rpd->level.pop_back(); +} + + +// Interface to ifq definition lexer and parser ... + +extern int IfqParserparse(void); +extern FILE *IfqParserin; +extern int IfqParserdebug; +void IfqParser_setfileinput(FILE *f); +void IfqParser_setstringinput(char *s); + + +fta_parse_t *ifq_parse_result; + +int ifq_t::load_ifaces(string fname, bool use_live_hosts_file, bool disributed_mode, string &err){ + char buf[1000], errbuf[1000]; +// XML_Parser parser = XML_ParserCreate(NULL); + + int done; + int depth = 0; + err=""; + + // open the list of failed hosts + set live_hosts; + if (use_live_hosts_file) { + FILE* live_hosts_file = fopen("live_hosts.txt", "r"); + if (!live_hosts_file) { + err="Error, can't open live_hosts.txt, error is "; + err+=strerror(errno); err+="\n"; + return(1); + } + + while(fgets(buf, 1000, live_hosts_file)) { + char* host = strtok(buf, " \t\n\r"); // strip the line + if (host) + live_hosts.insert(host); + } + + fclose(live_hosts_file); + } + + + +// IfqParserdebug = 1; + + FILE *resfile = fopen(fname.c_str(),"r"); + if(resfile == NULL){ + err="Error, can't open "+fname+", error is "; + err+=strerror(errno); err+="\n"; + return(1); + } + +// rpd = new resparse_data(parser); + rpd = new resparse_data(use_live_hosts_file, &live_hosts, disributed_mode); + rpd_ptr = rpd; + + ResParser_setfileinput(resfile); + if(ResParserparse()){ + err = "ERROR, interface query parse failed.\n"; + return(1); + } + +/* + XML_SetUserData(parser, rpd); + XML_SetElementHandler(parser, startElement, endElement); + do { + size_t len = fread(buf, 1, sizeof(buf), resfile); + done = len < sizeof(buf); + if (!XML_Parse(parser, buf, len, done)) { + sprintf(errbuf, + "%s at line %d\n", + XML_ErrorString(XML_GetErrorCode(parser)), + XML_GetCurrentLineNumber(parser)); + err=errbuf; + return 1; + } + } while (!done); + XML_ParserFree(parser); + + if(rpd->failed()){ + err = "Interface resource parse failed, exiting.\n"; + } +*/ + + fclose(resfile); + + return(0); + +} + +int ifq_t::load_ifqs(string fname, string &err){ + char err_buf[1000]; + err=""; + + FILE *qfile = fopen(fname.c_str(),"r"); + if(qfile == NULL){ + sprintf(err_buf, "ERROR, can't open %s, error is %s\n",fname.c_str(),strerror(errno)); + err=err_buf; + return(1); + } + + ifq_parse_result = new fta_parse_t(); + IfqParser_setfileinput(qfile); + if(IfqParserparse()){ + err = "ERROR, interface query parse failed.\n"; + return(1); + } + + vector ifqlist = ifq_parse_result->parse_tree_list->qlist; + int i; + bool dup = false; + for(i=0;inmap["name"]; + if(ifq_map.count(nm)){ + err += "ERROR, Duplicate interface query "+nm+"\n"; + dup = true; + } + ifq_map[nm] = ifqlist[i]->wh; + } + + + if(dup) return(1); + return(0); +} + + +vector > ifq_t::eval(string qname, int &err_no){ + vector > retval; + err_no = 0; + + if(ifq_map.count(qname) == 0){ + err_no = 1; + return retval; + } + if(rpd->failed()){ + err_no = 2; + return retval; + } + + return rpd->find_ifaces(ifq_map[qname]); + +} + +vector ifq_t::get_iface_vals(string host_name, string basic_if_name, string property, int &err_no, string &err_str){ + vector retval; + err_no = 0; + + char *cdat = strdup(basic_if_name.c_str()); + int pos; + string virtual_iface = "0"; + string iface_name = basic_if_name; + for(pos=strlen(cdat)-1;pos>=0 && isdigit(cdat[pos]);--pos); + if(pos>0 && cdat[pos] == 'X' && pos<=strlen(cdat)-2){ + cdat[pos] = '\0'; + virtual_iface = cdat+pos+1; + iface_name = cdat; + } + free(cdat); + + if(property == "virtual_interface_id"){ + retval.push_back(virtual_iface); + return retval; + } + + + if(rpd->failed()){ + err_no = 1; err_str = "interface resource parse failed."; + return retval; + } + + vector ifi = rpd->get_ifaces_by_Name(host_name, iface_name); + if(ifi.size() == 0){ + err_no = 1; err_str="interface not found."; + return retval; + } + if(ifi.size()>1){ + err_no = 1; err_str="multiple interfaces found."; + return retval; + } + + return rpd->get_property(ifi[0], property); + +} + +vector ifq_t::get_iface_properties(string host_name, string basic_if_name, int &err_no, string &err_str){ + vector retval; + err_no = 0; + + char *cdat = strdup(basic_if_name.c_str()); + int pos; + string virtual_iface = "0"; + string iface_name = basic_if_name; + for(pos=strlen(cdat)-1;pos>=0 && isdigit(cdat[pos]);--pos); + if(pos>0 && cdat[pos] == 'X' && pos<=strlen(cdat)-2){ + cdat[pos] = '\0'; + virtual_iface = cdat+pos+1; + iface_name = cdat; + } + free(cdat); + + if(rpd->failed()){ + err_no = 1; err_str = "interface resource parse failed."; + return retval; + } + + vector ifi = rpd->get_ifaces_by_Name(host_name, iface_name); + if(ifi.size() == 0){ + err_no = 1; err_str="interface not found."; + return retval; + } + if(ifi.size()>1){ + err_no = 1; err_str="multiple interfaces found."; + return retval; + } + + return rpd->get_properties(ifi[0]); + +} diff --git a/src/ftacmp/iface_q.h b/src/ftacmp/iface_q.h new file mode 100644 index 0000000..6b35021 --- /dev/null +++ b/src/ftacmp/iface_q.h @@ -0,0 +1,208 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __IFACE_Q_DEFINED_ +#define __IFACE_Q_DEFINED_ + +#include +//#include "xmlparse.h" +#include +#include +#include +#include +#include + +#include"parse_fta.h" + + +// Represent an interface. +class iface_t{ +public: + int lineno; + std::map > vals; + + iface_t(int l){ + lineno = l; + } + + void add_property(const char *name, const char *att); + void add_property(const char *name, const char **atts); + void add_property(const char *name, std::vector &val_vec); + + std::vector get_property(std::string p){ + std::vector ret; + + /* convert property name to lcase */ + std::transform(p.begin(), p.end(), p.begin(), (int(*)(int))std::tolower); + +/* +printf("get_property %s :\n",p.c_str()); +std::map >::iterator msvsi; +for(msvsi=vals.begin(); msvsi!=vals.end();++msvsi){ + printf("\t%s : ",(*msvsi).first.c_str()); + std::vector vs = (*msvsi).second; + int i; + for(i=0;i get_properties(){ + std::vector ret; + + std::map >::iterator iter; + for (iter = vals.begin(); iter != vals.end(); iter++) { + ret.push_back((*iter).first); + } + return ret; + } + + int finalize(std::string &errs); + std::string to_string(); + std::string get_name(); + std::string get_host(); + bool eval_Contains(std::string prop, std::string val); + bool eval_Equals(std::string prop, std::string val); + bool eval_Exists(std::string prop); +}; + +// Represent an interface. +class gs_host_t{ +public: + int lineno; + std::map > vals; + + gs_host_t(int l){ + lineno = l; + } + + void add_property(const char *name, const char *att); + void add_property(const char *name, std::vector &val_vec); + std::vector get_property(std::string p){ + std::vector ret; + if(vals.count(p)) return vals[p]; + else return ret; + } + int finalize(std::string &errs); + + void add_interface(iface_t* it) {ifaces.push_back(it);} + + void propagate_name() { + for(int i=0;iadd_property("host", vals["name"]); + } + + std::string to_string(); + std::string get_name(); + + std::vector ifaces; +}; + + + +// A collection of resources (interfaces) + +class resparse_data{ +public: + std::vector level; + bool in_Resources, in_Iface, in_Host; + iface_t *curr_iface; + gs_host_t *curr_host; + bool failure; + std::vector ifaces; + std::vector hosts; + bool use_live_hosts_file; + std::set *live_hosts; + bool distributed_mode; + +// XML_Parser parser; + +// resparse_data(XML_Parser p){ +// parser = p; + resparse_data(bool use_live_hosts_file, std::set *live_hosts, bool distributed_mode){ + in_Resources = false; + in_Iface = false; + curr_iface = NULL; + failure = false; + this->use_live_hosts_file = use_live_hosts_file; + this->live_hosts = live_hosts; + this->distributed_mode = distributed_mode; + }; + + void new_iface(int l){ + curr_iface = new iface_t(l); + }; + void new_host(int l){ + curr_host = new gs_host_t(l); + }; + void add_property(const char *name, const char *att){ + curr_iface->add_property(name, att); + }; + void add_property(const char *name, const char **atts){ + curr_iface->add_property(name, atts); + }; + void add_property(const char *name, std::vector &val_vec){ + curr_iface->add_property(name, val_vec); + }; + + + std::vector get_property(int i, std::string property){ + return ifaces[i]->get_property(property); + }; + std::vector get_properties(int i){ + return ifaces[i]->get_properties(); + }; + + int finalize_iface(std::string &errs); + int finalize_host(std::string &errs); + bool failed(){return failure;}; + std::string to_string(); + std::vector > find_ifaces(predicate_t *pr); + std::vector get_ifaces_by_Name(std::string host_name, std::string if_name); +private: + bool eval_pred(int i, predicate_t *pr); +}; + + +class ifq_t{ +public: + resparse_data *rpd; + std::map ifq_map; + + ifq_t(){ rpd = NULL;}; + + int load_ifaces(std::string fname, bool use_live_hosts_file, bool distributed_mode, std::string &err); + int load_ifqs(std::string fname, std::string &err); + + std::vector > eval(std::string qname, int &errnbr); + std::vector get_iface_vals(std::string host_name, std::string if_name, std::string property, int &errnbr, std::string &err_str); + std::vector get_iface_properties(std::string host_name, std::string basic_if_name, int &err_no, std::string &err_str); +}; + + +///////////////////////// +// for resource parser + +void startElement(void *userData, const char *name, std::vector &attr_vec, std::vector &val_vec); +void endElement(void *userData, const char *name) ; + + + + +#endif diff --git a/src/ftacmp/ifq.l b/src/ftacmp/ifq.l new file mode 100644 index 0000000..52092d7 --- /dev/null +++ b/src/ftacmp/ifq.l @@ -0,0 +1,246 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +/* + MUST COMPILE WITH + flex -PIfqParser -oifqlexer.cc ifq.l + (or equivalent). +*/ + +%{ +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_fta.h" + #include + + + +#include "ifq.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int IfqParserwrap(){return(1);} + +extern int IfqParserdebug; + + +/* + These variables are used for error reporting: + flex_ifq_lineno : the line currently being parsed when the error occurs. + flex_ifq_ch : the character on the line where the error occurs + flex_ifq_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_ifq_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_ifq_lineno = 1; +int flex_ifq_ch = 0; +char flex_ifq_linebuf[20000]; + +char *flex_ifq_stringinput = NULL; +int flex_ifq_stringinput_ptr = 0; +FILE *flex_ifq_fileinput = NULL; +int my_IfqParser_yyinput(char *buf, int max_size); + + + +void IfqParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_ifq_lineno, flex_ifq_ch, s, IfqParsertext, flex_ifq_linebuf ); + for(i=0;i + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_fta.h" + + +extern fta_parse_t *ifq_parse_result; + + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#ifndef YYSTYPE +#line 35 "ifq.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + select_list_t *select_listval; + table_exp_t *tblp; + predicate_t *predp; + literal_list_t *lit_l; + tablevar_t *table; + tablevar_list_t *tbl_list; + colref_t *colref; + colref_list_t *clist; + var_defs_t *var_defs; + var_pair_t *var_pair; + gb_t *gb_val; + gb_list_t *gb_list; + + query_list_t *q_list; + + +} yystype; +/* Line 193 of /usr/local/share/bison/yacc.c. */ +#line 230 "ifq.tab.cc" +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +#ifndef YYLTYPE +typedef struct yyltype +{ + int first_line; + int first_column; + int last_line; + int last_column; +} yyltype; +# define YYLTYPE yyltype +# define YYLTYPE_IS_TRIVIAL 1 +#endif + +/* Copy the second part of user declarations. */ + + +/* Line 213 of /usr/local/share/bison/yacc.c. */ +#line 251 "ifq.tab.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 6 +#define YYLAST 46 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 55 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 12 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 28 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 46 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 303 + +#define YYTRANSLATE(X) \ + ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 50, 51, 2, 2, 54, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 49, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 52, 2, 53, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 5, 9, 11, 15, 17, 19, 21, + 25, 29, 32, 36, 38, 43, 45, 47, 49, 53, + 55, 57, 59, 61, 63, 65, 68, 71, 74 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 56, 0, -1, 58, -1, 3, 49, 59, -1, 57, + -1, 58, 12, 57, -1, 60, -1, 61, -1, 62, + -1, 62, 9, 62, -1, 62, 10, 62, -1, 11, + 62, -1, 50, 62, 51, -1, 63, -1, 4, 52, + 65, 53, -1, 66, -1, 3, -1, 64, -1, 65, + 54, 64, -1, 5, -1, 6, -1, 7, -1, 8, + -1, 30, -1, 31, -1, 32, 5, -1, 33, 5, + -1, 34, 5, -1, 35, 5, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned char yyrline[] = +{ + 0, 117, 117, 130, 135, 136, 140, 149, 155, 163, + 165, 166, 167, 168, 171, 178, 180, 184, 186, 189, + 191, 192, 193, 194, 195, 196, 197, 198, 199 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "PRED", "STRING_TOKEN", "INTNUM", + "LONGINTNUM", "APPROXNUM", "OR", "AND", "NOT", "SEMICOLON", "LEFTBRACE", + "RIGHTBRACE", "BY", "AS", "AGGR", "FROM", "INNER_JOIN", "OUTER_JOIN", + "LEFT_OUTER_JOIN", "RIGHT_OUTER_JOIN", "GROUP", "HAVING", "IN", + "SELECT", "WHERE", "SUCH", "THAT", "TRUE_V", "FALSE_V", "TIMEVAL_L", + "HEX_L", "LHEX_L", "IP_L", "MERGE", "SLACK", "DEFINE_SEC", "PARAM_SEC", + "PROTOCOL", "TABLE", "STREAM", "FTA", "OPERATOR", "OPERATOR_VIEW", + "FIELDS", "SUBQUERIES", "SELECTION_PUSHDOWN", "':'", "'('", "')'", + "'['", "']'", "','", "$accept", "parse_result", "gsql", "query_list", + "select_statement", "table_exp", "where_clause", "search_condition", + "predicate", "scalar_exp", "scalar_exp_commalist", "literal", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 58, + 40, 41, 91, 93, 44 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 55, 56, 57, 58, 58, 59, 60, 61, 62, + 62, 62, 62, 62, 63, 64, 64, 65, 65, 66, + 66, 66, 66, 66, 66, 66, 66, 66, 66 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 1, 3, 1, 3, 1, 1, 1, 3, + 3, 2, 3, 1, 4, 1, 1, 1, 3, 1, + 1, 1, 1, 1, 1, 2, 2, 2, 2 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 0, 0, 4, 2, 0, 1, 0, 0, 0, + 0, 3, 6, 7, 8, 13, 5, 0, 11, 0, + 0, 0, 16, 19, 20, 21, 22, 23, 24, 0, + 0, 0, 0, 17, 0, 15, 12, 9, 10, 25, + 26, 27, 28, 14, 0, 18 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = +{ + -1, 2, 3, 4, 11, 12, 13, 14, 15, 33, + 34, 35 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -42 +static const yysigned_char yypact[] = +{ + 2, -31, 19, -42, 8, -4, -42, 2, -30, -4, + -4, -42, -42, -42, 7, -42, -42, 3, -42, -8, + -4, -4, -42, -42, -42, -42, -42, -42, -42, 16, + 18, 20, 21, -42, -41, -42, -42, 14, -42, -42, + -42, -42, -42, -42, 3, -42 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = +{ + -42, -42, 22, -42, -42, -42, -42, -6, -42, -17, + -42, -42 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, parse error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = +{ + 8, 20, 21, 18, 19, 1, 22, 9, 23, 24, + 25, 26, 43, 44, 37, 38, 20, 21, 5, 6, + 7, 39, 17, 40, 21, 41, 42, 45, 0, 16, + 0, 0, 0, 27, 28, 29, 30, 31, 32, 0, + 0, 0, 0, 36, 0, 0, 10 +}; + +static const yysigned_char yycheck[] = +{ + 4, 9, 10, 9, 10, 3, 3, 11, 5, 6, + 7, 8, 53, 54, 20, 21, 9, 10, 49, 0, + 12, 5, 52, 5, 10, 5, 5, 44, -1, 7, + -1, -1, -1, 30, 31, 32, 33, 34, 35, -1, + -1, -1, -1, 51, -1, -1, 50 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 3, 56, 57, 58, 49, 0, 12, 4, 11, + 50, 59, 60, 61, 62, 63, 57, 52, 62, 62, + 9, 10, 3, 5, 6, 7, 8, 30, 31, 32, + 33, 34, 35, 64, 65, 66, 51, 62, 62, 5, + 5, 5, 5, 53, 54, 64 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.first_line = Rhs[1].first_line; \ + Current.first_column = Rhs[1].first_column; \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#define YYLEX yylex () + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +# define YYDSYMPRINT(Args) \ +do { \ + if (yydebug) \ + yysymprint Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YYDSYMPRINT(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*-----------------------------. +| Print this symbol on YYOUT. | +`-----------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue) +#else +yysymprint (yyout, yytype, yyvalue) + FILE* yyout; + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyout, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyout, yytoknum[yytype], yyvalue); +# endif + } + else + YYFPRINTF (yyout, "nterm %s (", yytname[yytype]); + + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyout, ")"); +} +#endif /* YYDEBUG. */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yydestruct (int yytype, YYSTYPE yyvalue) +#else +yydestruct (yytype, yyvalue) + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + switch (yytype) + { + default: + break; + } +} + + + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +# ifdef YYPARSE_PARAM +int yyparse (void *); +# else +int yyparse (void); +# endif +#endif + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of parse errors so far. */ +int yynerrs; + + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + goto yyoverflowlab; + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with. */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more. */ + + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yychar1 = YYTRANSLATE (yychar); + + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ + YYDPRINTF ((stderr, "Next token is ")); + YYDSYMPRINT ((stderr, yychar1, yylval)); + YYDPRINTF ((stderr, "\n")); + } + + /* If the proper action on seeing token YYCHAR1 is to reduce or to + detect an error, take that action. */ + yyn += yychar1; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + int yyi; + + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn - 1, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + switch (yyn) + { + case 2: +#line 117 "ifq.y" + { + ifq_parse_result->parse_tree_list = yyvsp[0].q_list; + ifq_parse_result->tables = NULL; + ifq_parse_result->parse_type = QUERY_PARSE; + } + break; + + case 3: +#line 130 "ifq.y" + { + yyval.tblp = yyvsp[0].tblp; yyval.tblp->nmap["name"] = yyvsp[-2].strval; + } + break; + + case 4: +#line 135 "ifq.y" + {yyval.q_list = new query_list_t(yyvsp[0].tblp);} + break; + + case 5: +#line 136 "ifq.y" + {yyval.q_list = yyvsp[-2].q_list->append(yyvsp[0].tblp);} + break; + + case 6: +#line 141 "ifq.y" + {yyval.tblp = yyvsp[0].tblp;} + break; + + case 7: +#line 150 "ifq.y" + {yyval.tblp=new table_exp_t(NULL,yyvsp[0].predp,NULL,NULL,NULL,NULL,NULL,NULL);} + break; + + case 8: +#line 156 "ifq.y" + {yyval.predp = yyvsp[0].predp;} + break; + + case 9: +#line 164 "ifq.y" + {yyval.predp=new predicate_t("OR",yyvsp[-2].predp,yyvsp[0].predp);} + break; + + case 10: +#line 165 "ifq.y" + {yyval.predp=new predicate_t("AND",yyvsp[-2].predp,yyvsp[0].predp);} + break; + + case 11: +#line 166 "ifq.y" + {yyval.predp = new predicate_t("NOT", yyvsp[0].predp );} + break; + + case 12: +#line 167 "ifq.y" + {yyval.predp = yyvsp[-1].predp;} + break; + + case 13: +#line 168 "ifq.y" + {yyval.predp = yyvsp[0].predp;} + break; + + case 14: +#line 172 "ifq.y" + {yyval.predp = new predicate_t(yyvsp[-3].strval, yyvsp[-1].se_listval->get_se_list()); } + break; + + case 15: +#line 179 "ifq.y" + { yyval.scalarval= scalarexp_t::make_param_reference(yyvsp[0].litval->to_string().c_str());} + break; + + case 16: +#line 180 "ifq.y" + {yyval.scalarval = scalarexp_t::make_param_reference(yyvsp[0].strval);} + break; + + case 17: +#line 185 "ifq.y" + { yyval.se_listval= new se_list_t(yyvsp[0].scalarval); } + break; + + case 18: +#line 186 "ifq.y" + { yyval.se_listval=yyvsp[-2].se_listval->append(yyvsp[0].scalarval); } + break; + + case 19: +#line 190 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_STRING);} + break; + + case 20: +#line 191 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_INT);} + break; + + case 21: +#line 192 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_LONGINT);} + break; + + case 22: +#line 193 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_FLOAT);} + break; + + case 23: +#line 194 "ifq.y" + {yyval.litval = new literal_t("TRUE",LITERAL_BOOL);} + break; + + case 24: +#line 195 "ifq.y" + {yyval.litval = new literal_t("FALSE",LITERAL_BOOL);} + break; + + case 25: +#line 196 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_TIMEVAL);} + break; + + case 26: +#line 197 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_HEX);} + break; + + case 27: +#line 198 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_LONGHEX);} + break; + + case 28: +#line 199 "ifq.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_IP);} + break; + + + } + +/* Line 1016 of /usr/local/share/bison/yacc.c. */ +#line 1248 "ifq.tab.cc" + + yyvsp -= yylen; + yyssp -= yylen; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[yytype]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("parse error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("parse error"); + } + goto yyerrlab1; + + +/*----------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action. | +`----------------------------------------------------*/ +yyerrlab1: + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + /* Return failure if at end of input. */ + if (yychar == YYEOF) + { + /* Pop the error token. */ + YYPOPSTACK; + /* Pop the rest of the stack. */ + while (yyssp > yyss) + { + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], + *yyvsp)); + YYDPRINTF ((stderr, "\n")); + yydestruct (yystos[*yyssp], *yyvsp); + YYPOPSTACK; + } + YYABORT; + } + + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); + yydestruct (yychar1, yylval); + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], *yyvsp)); + YYDPRINTF ((stderr, "\n")); + + yydestruct (yystos[yystate], *yyvsp); + yyvsp--; + yystate = *--yyssp; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + } + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; + + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 204 "ifq.y" + + + diff --git a/src/ftacmp/ifq.tab.cc.h b/src/ftacmp/ifq.tab.cc.h new file mode 100644 index 0000000..bccb871 --- /dev/null +++ b/src/ftacmp/ifq.tab.cc.h @@ -0,0 +1,171 @@ +/* A Bison parser, made from ifq.y, by GNU bison 1.75. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +#ifndef BISON_IFQ_TAB_CC_H +# define BISON_IFQ_TAB_CC_H + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + PRED = 259, + STRING_TOKEN = 260, + INTNUM = 261, + LONGINTNUM = 262, + APPROXNUM = 263, + OR = 264, + AND = 265, + NOT = 266, + SEMICOLON = 267, + LEFTBRACE = 268, + RIGHTBRACE = 269, + BY = 270, + AS = 271, + AGGR = 272, + FROM = 273, + INNER_JOIN = 274, + OUTER_JOIN = 275, + LEFT_OUTER_JOIN = 276, + RIGHT_OUTER_JOIN = 277, + GROUP = 278, + HAVING = 279, + IN = 280, + SELECT = 281, + WHERE = 282, + SUCH = 283, + THAT = 284, + TRUE_V = 285, + FALSE_V = 286, + TIMEVAL_L = 287, + HEX_L = 288, + LHEX_L = 289, + IP_L = 290, + MERGE = 291, + SLACK = 292, + DEFINE_SEC = 293, + PARAM_SEC = 294, + PROTOCOL = 295, + TABLE = 296, + STREAM = 297, + FTA = 298, + OPERATOR = 299, + OPERATOR_VIEW = 300, + FIELDS = 301, + SUBQUERIES = 302, + SELECTION_PUSHDOWN = 303 + }; +#endif +#define NAME 258 +#define PRED 259 +#define STRING_TOKEN 260 +#define INTNUM 261 +#define LONGINTNUM 262 +#define APPROXNUM 263 +#define OR 264 +#define AND 265 +#define NOT 266 +#define SEMICOLON 267 +#define LEFTBRACE 268 +#define RIGHTBRACE 269 +#define BY 270 +#define AS 271 +#define AGGR 272 +#define FROM 273 +#define INNER_JOIN 274 +#define OUTER_JOIN 275 +#define LEFT_OUTER_JOIN 276 +#define RIGHT_OUTER_JOIN 277 +#define GROUP 278 +#define HAVING 279 +#define IN 280 +#define SELECT 281 +#define WHERE 282 +#define SUCH 283 +#define THAT 284 +#define TRUE_V 285 +#define FALSE_V 286 +#define TIMEVAL_L 287 +#define HEX_L 288 +#define LHEX_L 289 +#define IP_L 290 +#define MERGE 291 +#define SLACK 292 +#define DEFINE_SEC 293 +#define PARAM_SEC 294 +#define PROTOCOL 295 +#define TABLE 296 +#define STREAM 297 +#define FTA 298 +#define OPERATOR 299 +#define OPERATOR_VIEW 300 +#define FIELDS 301 +#define SUBQUERIES 302 +#define SELECTION_PUSHDOWN 303 + + + + +#ifndef YYSTYPE +#line 35 "ifq.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + select_list_t *select_listval; + table_exp_t *tblp; + predicate_t *predp; + literal_list_t *lit_l; + tablevar_t *table; + tablevar_list_t *tbl_list; + colref_t *colref; + colref_list_t *clist; + var_defs_t *var_defs; + var_pair_t *var_pair; + gb_t *gb_val; + gb_list_t *gb_list; + + query_list_t *q_list; + + +} yystype; +/* Line 1281 of /usr/local/share/bison/yacc.c. */ +#line 164 "ifq.tab.cc.h" +# define YYSTYPE yystype +#endif + +extern YYSTYPE IfqParserlval; + + +#endif /* not BISON_IFQ_TAB_CC_H */ + diff --git a/src/ftacmp/ifq.y b/src/ftacmp/ifq.y new file mode 100644 index 0000000..ebddc9f --- /dev/null +++ b/src/ftacmp/ifq.y @@ -0,0 +1,220 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + bison --verbose --defines=ifq.tab.cc.h -p IfqParser -o ifq.tab.cc ifq.y + + (or equivalent). +*/ + +%{ + + +#include + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_fta.h" + + +extern fta_parse_t *ifq_parse_result; + + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + int intval; + double floatval; + char *strval; + int subtok; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + select_list_t *select_listval; + table_exp_t *tblp; + predicate_t *predp; + literal_list_t *lit_l; + tablevar_t *table; + tablevar_list_t *tbl_list; + colref_t *colref; + colref_list_t *clist; + var_defs_t *var_defs; + var_pair_t *var_pair; + gb_t *gb_val; + gb_list_t *gb_list; + + query_list_t *q_list; + + +} + +%token NAME +%token PRED +%token STRING_TOKEN +%token INTNUM +%token LONGINTNUM +%token APPROXNUM + +/* for FTA definition. */ +%type query_list +%type gsql +%type select_statement +%type table_exp +%type where_clause +%type search_condition +%type predicate +%type literal +%type scalar_exp +%type scalar_exp_commalist + + + + + + /* operators */ + +%left OR +%left AND +%left NOT + + /* literal keyword tokens */ +%token SEMICOLON LEFTBRACE RIGHTBRACE +/* For query definition */ +%token BY AS +%token AGGR +%token FROM INNER_JOIN OUTER_JOIN LEFT_OUTER_JOIN RIGHT_OUTER_JOIN +%token GROUP HAVING IN +%token SELECT +%token WHERE +%token SUCH THAT + +%token TRUE_V FALSE_V +%token TIMEVAL_L HEX_L LHEX_L IP_L +%token MERGE SLACK + +%token DEFINE_SEC PARAM_SEC + +/* For table definition */ +%token RIGHTBRACE PROTOCOL TABLE STREAM FTA +%token OPERATOR OPERATOR_VIEW FIELDS SUBQUERIES SELECTION_PUSHDOWN + + +%% + +/* Union of possible results */ +parse_result: query_list { + ifq_parse_result->parse_tree_list = $1; + ifq_parse_result->tables = NULL; + ifq_parse_result->parse_type = QUERY_PARSE; + } + ; + + + +/* Query definition. + WARNING: there might be some relics. +*/ + +gsql: NAME ':' select_statement { + $$ = $3; $$->nmap["name"] = $1; + } + ; + +query_list: gsql {$$ = new query_list_t($1);} + | query_list SEMICOLON gsql {$$ = $1->append($3);} + ; + + +select_statement: + table_exp {$$ = $1;} + ; + + + /* query expressions */ + + + +table_exp: + where_clause {$$=new table_exp_t(NULL,$1,NULL,NULL,NULL,NULL,NULL,NULL);} + ; + + + +where_clause: + search_condition {$$ = $1;} + ; + + + + /* search conditions */ + +search_condition: + search_condition OR search_condition {$$=new predicate_t("OR",$1,$3);} + | search_condition AND search_condition {$$=new predicate_t("AND",$1,$3);} + | NOT search_condition {$$ = new predicate_t("NOT", $2 );} + | '(' search_condition ')' {$$ = $2;} + | predicate {$$ = $1;} + ; + +predicate: + PRED '[' scalar_exp_commalist ']' {$$ = new predicate_t($1, $3->get_se_list()); } + ; + + + /* scalar expressions */ + +scalar_exp: + literal { $$= scalarexp_t::make_param_reference($1->to_string().c_str());} + | NAME {$$ = scalarexp_t::make_param_reference($1);} + ; + + +scalar_exp_commalist: + scalar_exp { $$= new se_list_t($1); } + | scalar_exp_commalist ',' scalar_exp { $$=$1->append($3); } + ; + +literal: + STRING_TOKEN {$$ = new literal_t($1,LITERAL_STRING);} + | INTNUM {$$ = new literal_t($1,LITERAL_INT);} + | LONGINTNUM {$$ = new literal_t($1,LITERAL_LONGINT);} + | APPROXNUM {$$ = new literal_t($1,LITERAL_FLOAT);} + | TRUE_V {$$ = new literal_t("TRUE",LITERAL_BOOL);} + | FALSE_V {$$ = new literal_t("FALSE",LITERAL_BOOL);} + | TIMEVAL_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_TIMEVAL);} + | HEX_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_HEX);} + | LHEX_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_LONGHEX);} + | IP_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_IP);} + ; + + + +%% + diff --git a/src/ftacmp/ifqlexer.cc b/src/ftacmp/ifqlexer.cc new file mode 100644 index 0000000..53ce50c --- /dev/null +++ b/src/ftacmp/ifqlexer.cc @@ -0,0 +1,1879 @@ +#define yy_create_buffer IfqParser_create_buffer +#define yy_delete_buffer IfqParser_delete_buffer +#define yy_scan_buffer IfqParser_scan_buffer +#define yy_scan_string IfqParser_scan_string +#define yy_scan_bytes IfqParser_scan_bytes +#define yy_flex_debug IfqParser_flex_debug +#define yy_init_buffer IfqParser_init_buffer +#define yy_flush_buffer IfqParser_flush_buffer +#define yy_load_buffer_state IfqParser_load_buffer_state +#define yy_switch_to_buffer IfqParser_switch_to_buffer +#define yyin IfqParserin +#define yyleng IfqParserleng +#define yylex IfqParserlex +#define yyout IfqParserout +#define yyrestart IfqParserrestart +#define yytext IfqParsertext + +#line 19 "ifqlexer.cc" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/ftacmp/ifqlexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yytext_ptr -= yy_more_len; \ + yyleng = (int) (yy_cp - yytext_ptr); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 27 +#define YY_END_OF_BUFFER 28 +static yyconst short int yy_accept[86] = + { 0, + 0, 0, 28, 26, 23, 22, 8, 26, 9, 8, + 8, 12, 7, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 10, 23, 22, 0, 21, 20, + 0, 16, 0, 0, 15, 12, 0, 0, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 3, 11, 11, + 11, 0, 24, 0, 19, 0, 25, 15, 0, 0, + 17, 13, 1, 11, 11, 11, 11, 2, 11, 0, + 18, 14, 11, 11, 11, 11, 4, 11, 11, 11, + 5, 11, 6, 11, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 1, 1, 4, 1, 4, 5, 4, + 4, 4, 6, 4, 7, 8, 9, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 4, 11, 1, + 1, 1, 1, 1, 12, 13, 14, 15, 16, 17, + 13, 13, 13, 13, 13, 18, 13, 19, 20, 13, + 13, 21, 22, 23, 24, 13, 13, 13, 13, 13, + 4, 1, 4, 1, 13, 1, 25, 13, 13, 26, + + 27, 13, 13, 13, 28, 13, 13, 29, 13, 30, + 31, 13, 32, 33, 34, 35, 36, 13, 13, 37, + 13, 13, 1, 4, 1, 38, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[39] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 3, + 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 1 + } ; + +static yyconst short int yy_base[91] = + { 0, + 0, 0, 141, 142, 138, 0, 142, 36, 132, 30, + 129, 34, 142, 24, 0, 106, 15, 124, 25, 27, + 114, 104, 102, 99, 142, 129, 0, 46, 142, 142, + 127, 43, 56, 126, 55, 59, 66, 110, 0, 112, + 100, 95, 88, 95, 104, 98, 85, 0, 95, 92, + 82, 113, 142, 105, 104, 110, 142, 58, 71, 102, + 101, 92, 0, 74, 83, 73, 84, 0, 89, 94, + 93, 142, 77, 72, 65, 83, 0, 60, 50, 46, + 0, 49, 0, 30, 142, 86, 89, 52, 92, 95 + } ; + +static yyconst short int yy_def[91] = + { 0, + 85, 1, 85, 85, 85, 86, 85, 87, 85, 85, + 85, 85, 85, 88, 88, 88, 88, 88, 88, 88, + 88, 88, 88, 88, 85, 85, 86, 87, 85, 85, + 89, 85, 85, 90, 85, 85, 85, 85, 88, 88, + 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, + 88, 89, 85, 85, 85, 90, 85, 85, 85, 85, + 85, 85, 88, 88, 88, 88, 88, 88, 88, 85, + 85, 85, 88, 88, 88, 88, 88, 88, 88, 88, + 88, 88, 88, 88, 0, 85, 85, 85, 85, 85 + } ; + +static yyconst short int yy_nxt[181] = + { 0, + 4, 5, 6, 7, 8, 7, 9, 10, 11, 12, + 13, 14, 15, 16, 15, 17, 18, 15, 19, 20, + 15, 15, 21, 15, 22, 15, 15, 15, 15, 23, + 24, 15, 15, 15, 15, 15, 15, 25, 29, 32, + 30, 35, 40, 36, 46, 33, 43, 48, 29, 37, + 30, 44, 32, 41, 39, 47, 33, 38, 33, 48, + 37, 54, 54, 83, 58, 55, 35, 58, 36, 33, + 59, 60, 60, 59, 37, 61, 70, 70, 84, 83, + 71, 59, 38, 83, 59, 37, 27, 82, 27, 28, + 28, 28, 52, 52, 52, 56, 56, 56, 81, 80, + + 79, 78, 71, 71, 77, 76, 75, 74, 73, 72, + 61, 61, 57, 55, 55, 53, 68, 63, 69, 68, + 68, 67, 66, 65, 64, 63, 63, 62, 57, 53, + 26, 48, 51, 50, 49, 45, 42, 34, 31, 26, + 85, 3, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 + } ; + +static yyconst short int yy_chk[181] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 8, 10, + 8, 12, 14, 12, 19, 10, 17, 20, 28, 12, + 28, 17, 32, 14, 88, 19, 10, 12, 32, 20, + 12, 33, 33, 84, 35, 33, 36, 58, 36, 32, + 35, 37, 37, 58, 36, 37, 59, 59, 82, 80, + 59, 35, 36, 79, 58, 36, 86, 78, 86, 87, + 87, 87, 89, 89, 89, 90, 90, 90, 76, 75, + + 74, 73, 71, 70, 69, 67, 66, 65, 64, 62, + 61, 60, 56, 55, 54, 52, 51, 50, 49, 47, + 46, 45, 44, 43, 42, 41, 40, 38, 34, 31, + 26, 24, 23, 22, 21, 18, 16, 11, 9, 5, + 3, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() (yy_more_flag = 1) +#define YY_MORE_ADJ yy_more_len +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "ifq.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PIfqParser -oifqlexer.cc ifq.l + (or equivalent). +*/ +#line 9 "ifq.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_fta.h" + #include + + + +#include "ifq.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int IfqParserwrap(){return(1);} + +extern int IfqParserdebug; + + +/* + These variables are used for error reporting: + flex_ifq_lineno : the line currently being parsed when the error occurs. + flex_ifq_ch : the character on the line where the error occurs + flex_ifq_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_ifq_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_ifq_lineno = 1; +int flex_ifq_ch = 0; +char flex_ifq_linebuf[20000]; + +char *flex_ifq_stringinput = NULL; +int flex_ifq_stringinput_ptr = 0; +FILE *flex_ifq_fileinput = NULL; +int my_IfqParser_yyinput(char *buf, int max_size); + + + +void IfqParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_ifq_lineno, flex_ifq_ch, s, IfqParsertext, flex_ifq_linebuf ); + for(i=0;i +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 88 "ifq.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + +#line 701 "ifqlexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + if ( yy_more_flag ) + { + yy_more_len = yy_c_buf_p - yytext_ptr; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 86 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 142 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 106 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return AND; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 107 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return NOT; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 108 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return OR; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 110 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return TRUE_V;} + YY_BREAK +case 5: +YY_RULE_SETUP +#line 111 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return FALSE_V;} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 113 "ifq.l" +{flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return PRED; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 115 "ifq.l" +{flex_ifq_ch+=IfqParserleng; return SEMICOLON;} + YY_BREAK +case 8: +YY_RULE_SETUP +#line 119 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return yytext[0]; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 120 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return yytext[0]; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 121 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 11: +YY_RULE_SETUP +#line 125 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* numbers */ +case 12: +#line 130 "ifq.l" +case 13: +YY_RULE_SETUP +#line 130 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return INTNUM; } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 132 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return LONGINTNUM; } + YY_BREAK +case 15: +#line 135 "ifq.l" +case 16: +#line 136 "ifq.l" +case 17: +#line 137 "ifq.l" +case 18: +#line 138 "ifq.l" +case 19: +YY_RULE_SETUP +#line 138 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return APPROXNUM; } + YY_BREAK +/* strings */ +case 20: +YY_RULE_SETUP +#line 142 "ifq.l" +{ + + int c; + + IfqParserlval.strval = strdup(IfqParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_ifq_ch+=IfqParserleng; + IfqParserlval.strval[IfqParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + YY_BREAK +case 21: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 159 "ifq.l" +{ flex_ifq_ch+=IfqParserleng; IfqParsererror("Unterminated string"); } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_ifq_linebuf */ +/* */ +case 22: +YY_RULE_SETUP +#line 166 "ifq.l" +{flex_ifq_ch=0; flex_ifq_lineno++; + strcpy(flex_ifq_linebuf,IfqParsertext+1); + yyless(1); + } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 171 "ifq.l" +{flex_ifq_ch+=IfqParserleng; } /* white space */ + YY_BREAK +case 24: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 173 "ifq.l" +{flex_ifq_ch+=IfqParserleng; }; /* comment */ + YY_BREAK +case 25: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 174 "ifq.l" +{flex_ifq_ch+=IfqParserleng; }; /* comment */ + YY_BREAK +case 26: +YY_RULE_SETUP +#line 176 "ifq.l" +{flex_ifq_ch+=IfqParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); IfqParsererror(yytext);} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 178 "ifq.l" +ECHO; + YY_BREAK +#line 944 "ifqlexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 86 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 86 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 85); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 178 "ifq.l" + + +int my_IfqParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_ifq_stringinput != NULL){ + while(c + + + +#include "nic.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int NicParserwrap(){return(1);} + +extern int NicParserdebug; + + +/* + These variables are used for error reporting: + flex_nic_lineno : the line currently being parsed when the error occurs. + flex_nic_ch : the character on the line where the error occurs + flex_nic_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_nic_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_nic_lineno = 1; +int flex_nic_ch = 0; +char flex_nic_linebuf[20000]; + +char *flex_nic_stringinput = NULL; +int flex_nic_stringinput_ptr = 0; +FILE *flex_nic_fileinput = NULL; +int my_NicParser_yyinput(char *buf, int max_size); + + + +void NicParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_nic_lineno, flex_nic_ch, s, NicParsertext, flex_nic_linebuf ); + for(i=0;i + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "nic_def.h" + +extern int NicParserlex(); +void NicParsererror(char *s); + + +extern nic_property *nicp; +extern std::vector nic_attr_vec; +extern std::vector nic_val_vec; +extern std::string nic_a, nic_v; + + + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#ifndef YYSTYPE +#line 42 "nic.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} yystype; +/* Line 193 of /usr/local/share/bison/yacc.c. */ +#line 143 "nic.tab.cc" +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +#ifndef YYLTYPE +typedef struct yyltype +{ + int first_line; + int first_column; + int last_line; + int last_column; +} yyltype; +# define YYLTYPE yyltype +# define YYLTYPE_IS_TRIVIAL 1 +#endif + +/* Copy the second part of user declarations. */ + + +/* Line 213 of /usr/local/share/bison/yacc.c. */ +#line 164 "nic.tab.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 8 +#define YYLAST 30 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 14 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 13 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 20 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 41 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 265 + +#define YYTRANSLATE(X) \ + ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 12, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 11, + 2, 13, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 10, 14, 18, 22, 26, 30, 34, + 36, 37, 39, 41, 45, 49, 51, 52, 54, 58, + 62 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 15, 0, -1, 16, 17, 18, 19, 20, 21, -1, + 10, 24, 11, -1, 6, 22, 11, -1, 7, 22, + 11, -1, 8, 22, 11, -1, 9, 22, 11, -1, + 5, 22, 11, -1, 23, -1, -1, 3, -1, 4, + -1, 23, 12, 3, -1, 23, 12, 4, -1, 25, + -1, -1, 26, -1, 25, 12, 26, -1, 3, 13, + 4, -1, 3, 13, 3, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned char yyrline[] = +{ + 0, 61, 61, 65, 69, 73, 77, 81, 85, 89, + 91, 94, 96, 97, 98, 101, 103, 106, 109, 113, + 115 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "FUNC", "TYPES", + "UNARY_OPS", "BINARY_OPS", "FIELDS", "OPTIONS", "';'", "','", "'='", + "$accept", "parse_result", "opts", "types", "unary_ops", "binary_ops", + "fields", "fcns", "opt_attr_list", "attr_list", "opt_val_list", + "val_list", "val", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 59, 44, 61 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 22, 23, 23, 23, 23, 24, 24, 25, 25, 26, + 26 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 6, 3, 3, 3, 3, 3, 3, 1, + 0, 1, 1, 3, 3, 1, 0, 1, 3, 3, + 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 16, 0, 0, 0, 0, 15, 17, 1, 10, + 0, 0, 3, 0, 11, 12, 0, 9, 10, 0, + 20, 19, 18, 4, 0, 0, 10, 0, 13, 14, + 5, 0, 10, 0, 6, 0, 10, 2, 7, 0, + 8 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = +{ + -1, 2, 3, 10, 19, 27, 33, 37, 16, 17, + 5, 6, 7 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -19 +static const yysigned_char yypact[] = +{ + -3, 6, 10, 5, -1, 4, 1, -19, -19, -2, + 9, 0, -19, 6, -19, -19, 8, 11, -2, 12, + -19, -19, -19, -19, 2, 13, -2, 16, -19, -19, + -19, 15, -2, 17, -19, 18, -2, -19, -19, 19, + -19 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = +{ + -19, -19, -19, -19, -19, -19, -19, -19, -18, -19, + -19, -19, 14 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, parse error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = +{ + 25, 14, 15, 20, 21, 28, 29, 1, 31, 4, + 8, 9, 11, 13, 35, 12, 18, 0, 39, 23, + 26, 0, 36, 24, 30, 32, 34, 22, 0, 38, + 40 +}; + +static const yysigned_char yycheck[] = +{ + 18, 3, 4, 3, 4, 3, 4, 10, 26, 3, + 0, 6, 13, 12, 32, 11, 7, -1, 36, 11, + 8, -1, 5, 12, 11, 9, 11, 13, -1, 11, + 11 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 10, 15, 16, 3, 24, 25, 26, 0, 6, + 17, 13, 11, 12, 3, 4, 22, 23, 7, 18, + 3, 4, 26, 11, 12, 22, 8, 19, 3, 4, + 11, 22, 9, 20, 11, 22, 5, 21, 11, 22, + 11 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.first_line = Rhs[1].first_line; \ + Current.first_column = Rhs[1].first_column; \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#define YYLEX yylex () + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +# define YYDSYMPRINT(Args) \ +do { \ + if (yydebug) \ + yysymprint Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YYDSYMPRINT(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*-----------------------------. +| Print this symbol on YYOUT. | +`-----------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue) +#else +yysymprint (yyout, yytype, yyvalue) + FILE* yyout; + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyout, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyout, yytoknum[yytype], yyvalue); +# endif + } + else + YYFPRINTF (yyout, "nterm %s (", yytname[yytype]); + + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyout, ")"); +} +#endif /* YYDEBUG. */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yydestruct (int yytype, YYSTYPE yyvalue) +#else +yydestruct (yytype, yyvalue) + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + switch (yytype) + { + default: + break; + } +} + + + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +# ifdef YYPARSE_PARAM +int yyparse (void *); +# else +int yyparse (void); +# endif +#endif + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of parse errors so far. */ +int yynerrs; + + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + goto yyoverflowlab; + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with. */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more. */ + + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yychar1 = YYTRANSLATE (yychar); + + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ + YYDPRINTF ((stderr, "Next token is ")); + YYDSYMPRINT ((stderr, yychar1, yylval)); + YYDPRINTF ((stderr, "\n")); + } + + /* If the proper action on seeing token YYCHAR1 is to reduce or to + detect an error, take that action. */ + yyn += yychar1; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + int yyi; + + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn - 1, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + switch (yyn) + { + case 3: +#line 66 "nic.y" + {nicp->opta=nic_attr_vec; nicp->optv=nic_val_vec;} + break; + + case 4: +#line 70 "nic.y" + {nicp->typea=nic_attr_vec;} + break; + + case 5: +#line 74 "nic.y" + {nicp->opua=nic_attr_vec;} + break; + + case 6: +#line 78 "nic.y" + {nicp->opba=nic_attr_vec;} + break; + + case 7: +#line 82 "nic.y" + {nicp->fieldsa=nic_attr_vec;} + break; + + case 8: +#line 86 "nic.y" + {nicp->funca=nic_attr_vec;} + break; + + case 10: +#line 91 "nic.y" + {nic_attr_vec.clear(); } + break; + + case 11: +#line 95 "nic.y" + {nic_attr_vec.clear(); nic_attr_vec.push_back(yyvsp[0].strval); } + break; + + case 12: +#line 96 "nic.y" + {nic_attr_vec.clear(); nic_attr_vec.push_back(yyvsp[0].strval); } + break; + + case 13: +#line 97 "nic.y" + {nic_attr_vec.push_back(yyvsp[0].strval);} + break; + + case 14: +#line 98 "nic.y" + {nic_attr_vec.push_back(yyvsp[0].strval);} + break; + + case 16: +#line 103 "nic.y" + {nic_attr_vec.clear(); nic_val_vec.clear();} + break; + + case 17: +#line 107 "nic.y" + {nic_attr_vec.clear(); nic_attr_vec.push_back(nic_a); + nic_val_vec.clear(); nic_val_vec.push_back(nic_v); } + break; + + case 18: +#line 109 "nic.y" + {nic_attr_vec.push_back(nic_a); + nic_val_vec.push_back(nic_v); } + break; + + case 19: +#line 114 "nic.y" + {nic_a = yyvsp[-2].strval; nic_v = yyvsp[0].strval;} + break; + + case 20: +#line 115 "nic.y" + {nic_a = yyvsp[-2].strval; nic_v = yyvsp[0].strval;} + break; + + + } + +/* Line 1016 of /usr/local/share/bison/yacc.c. */ +#line 1085 "nic.tab.cc" + + yyvsp -= yylen; + yyssp -= yylen; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[yytype]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("parse error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("parse error"); + } + goto yyerrlab1; + + +/*----------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action. | +`----------------------------------------------------*/ +yyerrlab1: + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + /* Return failure if at end of input. */ + if (yychar == YYEOF) + { + /* Pop the error token. */ + YYPOPSTACK; + /* Pop the rest of the stack. */ + while (yyssp > yyss) + { + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], + *yyvsp)); + YYDPRINTF ((stderr, "\n")); + yydestruct (yystos[*yyssp], *yyvsp); + YYPOPSTACK; + } + YYABORT; + } + + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); + yydestruct (yychar1, yylval); + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], *yyvsp)); + YYDPRINTF ((stderr, "\n")); + + yydestruct (yystos[yystate], *yyvsp); + yyvsp--; + yystate = *--yyssp; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + } + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; + + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 122 "nic.y" + + + diff --git a/src/ftacmp/nic.tab.cc.h b/src/ftacmp/nic.tab.cc.h new file mode 100644 index 0000000..b44f522 --- /dev/null +++ b/src/ftacmp/nic.tab.cc.h @@ -0,0 +1,77 @@ +/* A Bison parser, made from nic.y, by GNU bison 1.75. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +#ifndef BISON_NIC_TAB_CC_H +# define BISON_NIC_TAB_CC_H + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259, + FUNC = 260, + TYPES = 261, + UNARY_OPS = 262, + BINARY_OPS = 263, + FIELDS = 264, + OPTIONS = 265 + }; +#endif +#define NAME 258 +#define STRING_TOKEN 259 +#define FUNC 260 +#define TYPES 261 +#define UNARY_OPS 262 +#define BINARY_OPS 263 +#define FIELDS 264 +#define OPTIONS 265 + + + + +#ifndef YYSTYPE +#line 42 "nic.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} yystype; +/* Line 1281 of /usr/local/share/bison/yacc.c. */ +#line 70 "nic.tab.cc.h" +# define YYSTYPE yystype +#endif + +extern YYSTYPE NicParserlval; + + +#endif /* not BISON_NIC_TAB_CC_H */ + diff --git a/src/ftacmp/nic.y b/src/ftacmp/nic.y new file mode 100644 index 0000000..39026c5 --- /dev/null +++ b/src/ftacmp/nic.y @@ -0,0 +1,138 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + bison --verbose --defines=nic.tab.cc.h -p NicParser -o nic.tab.cc nic.y + + (or equivalent). +*/ + +%{ + + +#include + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "nic_def.h" + +extern int NicParserlex(); +void NicParsererror(char *s); + + +extern nic_property *nicp; +extern std::vector nic_attr_vec; +extern std::vector nic_val_vec; +extern std::string nic_a, nic_v; + + + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} + +%token NAME +%token STRING_TOKEN +%token FUNC TYPES UNARY_OPS BINARY_OPS FIELDS OPTIONS + + + + +%% + +parse_result: + opts types unary_ops binary_ops fields fcns + ; + +opts: + OPTIONS opt_val_list ';' {nicp->opta=nic_attr_vec; nicp->optv=nic_val_vec;} + ; + +types: + TYPES opt_attr_list ';' {nicp->typea=nic_attr_vec;} + ; + +unary_ops: + UNARY_OPS opt_attr_list ';' {nicp->opua=nic_attr_vec;} + ; + +binary_ops: + BINARY_OPS opt_attr_list ';' {nicp->opba=nic_attr_vec;} + ; + +fields: + FIELDS opt_attr_list ';' {nicp->fieldsa=nic_attr_vec;} + ; + +fcns: + FUNC opt_attr_list ';' {nicp->funca=nic_attr_vec;} + ; + +opt_attr_list: + attr_list + | {nic_attr_vec.clear(); } + ; + +attr_list: + NAME {nic_attr_vec.clear(); nic_attr_vec.push_back($1); } + | STRING_TOKEN {nic_attr_vec.clear(); nic_attr_vec.push_back($1); } + | attr_list ',' NAME {nic_attr_vec.push_back($3);} + | attr_list ',' STRING_TOKEN {nic_attr_vec.push_back($3);} + ; + +opt_val_list: + val_list + | {nic_attr_vec.clear(); nic_val_vec.clear();} + ; + +val_list: + val {nic_attr_vec.clear(); nic_attr_vec.push_back(nic_a); + nic_val_vec.clear(); nic_val_vec.push_back(nic_v); } + | val_list ',' val {nic_attr_vec.push_back(nic_a); + nic_val_vec.push_back(nic_v); } + ; + +val: + NAME '=' STRING_TOKEN {nic_a = $1; nic_v = $3;} + | NAME '=' NAME {nic_a = $1; nic_v = $3;} + ; + + + + + +%% + diff --git a/src/ftacmp/nic_def.cc b/src/ftacmp/nic_def.cc new file mode 100644 index 0000000..e613c3a --- /dev/null +++ b/src/ftacmp/nic_def.cc @@ -0,0 +1,128 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include +#include + +#include"nic_def.h" + +extern int NicParserparse(void); +extern FILE *NicParserin; +extern int NicParserdebug; + + +nic_property *nicp; +std::vector nic_attr_vec; +std::vector nic_val_vec; +std::string nic_a, nic_v; + +using namespace std; + +nic_property *load_nic_property(std::string dir, std::string name){ + + string fname; + if(dir != "") + fname = dir + "/nic_property_"+name+".def"; + else + fname = "nic_property_"+name+".def"; + + FILE *nicf = fopen(fname.c_str(),"r"); + if(! nicf){ + fprintf(stderr,"ERROR, can't open nic property file %s\n",fname.c_str()); + return NULL; + } + +NicParserdebug = 0; + nicp = new nic_property(); + NicParser_setfileinput(nicf); + if(NicParserparse()){ + fprintf(stderr,"could not parse nic property file %s\n",fname.c_str()); + return NULL; + } + + return nicp; +} + +bool nic_property::legal_type(string t){ +int i; + for(i=0;i +#include +#include + +class nic_property{ +public: + std::vector opta; // option args + std::vector optv; // val of option args + std::vector typea; // legal types + std::vector opba; // legal binary ops + std::vector opua; // legal unary ops + std::vector fieldsa; // illegal fields + std::vector funca; // legal functions + + nic_property(){}; + + bool legal_type(std::string t); + bool legal_unary_op(std::string t); + bool legal_binary_op(std::string t); + bool illegal_field(std::string t); + bool option_exists(std::string t); + std::string option_value(std::string t); +}; + + +nic_property *load_nic_property(std::string dir, std::string name); + + +class nic_prop_db{ +public: + std::string dir; + std::map ndb; + + nic_prop_db(std::string d){dir=d;}; + + + nic_property *get_nic_property(std::string nics, int &err_no){ + if(ndb.count(nics)) + return ndb[nics]; + nic_property *ret = load_nic_property(dir, nics); + if(ret) + ndb[nics] = ret; + return ret; + }; + + + std::string get_nic_prop_val(std::string nics, std::string prop,int &err_no){ + nic_property *nicp = this->get_nic_property(nics, err_no); + if(!nicp){ + fprintf(stderr,"ERROR cannot load nic properties %s for nic type %s in get_nic_prop_val\n",nics.c_str(), prop.c_str()); + exit(1); + } + if(nicp->option_exists(prop)){ + return nicp->option_value("Return"); + }else{ + return ""; + } + + } +}; + + +void NicParser_setfileinput(FILE *f); + + + +#endif diff --git a/src/ftacmp/niclexer.cc b/src/ftacmp/niclexer.cc new file mode 100644 index 0000000..fa1eb2e --- /dev/null +++ b/src/ftacmp/niclexer.cc @@ -0,0 +1,1829 @@ +#define yy_create_buffer NicParser_create_buffer +#define yy_delete_buffer NicParser_delete_buffer +#define yy_scan_buffer NicParser_scan_buffer +#define yy_scan_string NicParser_scan_string +#define yy_scan_bytes NicParser_scan_bytes +#define yy_flex_debug NicParser_flex_debug +#define yy_init_buffer NicParser_init_buffer +#define yy_flush_buffer NicParser_flush_buffer +#define yy_load_buffer_state NicParser_load_buffer_state +#define yy_switch_to_buffer NicParser_switch_to_buffer +#define yyin NicParserin +#define yyleng NicParserleng +#define yylex NicParserlex +#define yyout NicParserout +#define yyrestart NicParserrestart +#define yytext NicParsertext + +#line 19 "niclexer.cc" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/ftacmp/niclexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yytext_ptr -= yy_more_len; \ + yyleng = (int) (yy_cp - yytext_ptr); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 16 +#define YY_END_OF_BUFFER 17 +static yyconst short int yy_accept[85] = + { 0, + 0, 0, 17, 15, 12, 11, 15, 7, 15, 15, + 8, 8, 8, 8, 8, 8, 8, 12, 11, 0, + 10, 9, 0, 0, 8, 8, 8, 8, 8, 8, + 8, 0, 13, 0, 14, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 3, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 1, 8, 8, + 8, 8, 8, 8, 2, 8, 4, 5, 8, 8, + 8, 8, 6, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 4, 1, + 1, 1, 1, 5, 6, 1, 7, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 9, 5, 1, + 5, 1, 1, 1, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 17, 17, 19, 20, 21, 22, 23, + 17, 24, 25, 26, 27, 17, 17, 17, 28, 17, + 1, 1, 1, 1, 29, 1, 17, 17, 17, 17, + + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[30] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 3, 1, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[90] = + { 0, + 0, 0, 108, 109, 105, 0, 27, 109, 100, 98, + 0, 86, 76, 84, 78, 72, 78, 96, 0, 29, + 109, 109, 94, 93, 0, 74, 73, 68, 66, 68, + 80, 86, 109, 85, 109, 77, 74, 60, 66, 69, + 58, 57, 54, 61, 56, 52, 48, 47, 56, 52, + 51, 62, 41, 40, 46, 51, 41, 109, 43, 42, + 42, 33, 52, 37, 36, 33, 42, 109, 31, 30, + 45, 35, 43, 42, 109, 36, 109, 109, 30, 35, + 22, 37, 109, 109, 33, 36, 32, 39, 42 + } ; + +static yyconst short int yy_def[90] = + { 0, + 84, 1, 84, 84, 84, 85, 86, 84, 84, 84, + 87, 87, 87, 87, 87, 87, 87, 84, 85, 86, + 84, 84, 88, 89, 87, 87, 87, 87, 87, 87, + 87, 88, 84, 89, 84, 87, 87, 87, 87, 87, + 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, + 87, 87, 87, 87, 87, 87, 87, 84, 87, 87, + 87, 87, 87, 87, 87, 87, 87, 84, 87, 87, + 87, 87, 87, 87, 84, 87, 84, 84, 87, 87, + 87, 87, 84, 0, 84, 84, 84, 84, 84 + } ; + +static yyconst short int yy_nxt[139] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 4, 4, 11, + 12, 11, 11, 11, 13, 11, 11, 11, 11, 14, + 11, 15, 11, 11, 11, 16, 17, 11, 11, 21, + 22, 21, 22, 19, 25, 19, 20, 20, 20, 32, + 32, 32, 34, 34, 34, 83, 82, 81, 80, 79, + 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, + 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, + 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, + 48, 47, 46, 45, 44, 43, 42, 35, 33, 41, + 40, 39, 38, 37, 36, 35, 33, 18, 31, 30, + + 29, 28, 27, 26, 24, 23, 18, 84, 3, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84 + } ; + +static yyconst short int yy_chk[139] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, + 7, 20, 20, 85, 87, 85, 86, 86, 86, 88, + 88, 88, 89, 89, 89, 82, 81, 80, 79, 76, + 74, 73, 72, 71, 70, 69, 67, 66, 65, 64, + 63, 62, 61, 60, 59, 57, 56, 55, 54, 53, + 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, + 42, 41, 40, 39, 38, 37, 36, 34, 32, 31, + 30, 29, 28, 27, 26, 24, 23, 18, 17, 16, + + 15, 14, 13, 12, 10, 9, 5, 3, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, + 84, 84, 84, 84, 84, 84, 84, 84 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() (yy_more_flag = 1) +#define YY_MORE_ADJ yy_more_len +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "nic.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PNicParser -oniclexer.cc nic.l + (or equivalent). +*/ +#line 9 "nic.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "nic_def.h" + #include + + + +#include "nic.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int NicParserwrap(){return(1);} + +extern int NicParserdebug; + + +/* + These variables are used for error reporting: + flex_nic_lineno : the line currently being parsed when the error occurs. + flex_nic_ch : the character on the line where the error occurs + flex_nic_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_nic_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_nic_lineno = 1; +int flex_nic_ch = 0; +char flex_nic_linebuf[20000]; + +char *flex_nic_stringinput = NULL; +int flex_nic_stringinput_ptr = 0; +FILE *flex_nic_fileinput = NULL; +int my_NicParser_yyinput(char *buf, int max_size); + + + +void NicParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_nic_lineno, flex_nic_ch, s, NicParsertext, flex_nic_linebuf ); + for(i=0;i +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 88 "nic.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + +#line 692 "niclexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + if ( yy_more_flag ) + { + yy_more_len = yy_c_buf_p - yytext_ptr; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 85 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 109 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 106 "nic.l" +{ flex_nic_ch+=NicParserleng; return OPTIONS; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 107 "nic.l" +{ flex_nic_ch+=NicParserleng; return FUNC; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 108 "nic.l" +{ flex_nic_ch+=NicParserleng; return TYPES; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 109 "nic.l" +{ flex_nic_ch+=NicParserleng; return UNARY_OPS; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 110 "nic.l" +{ flex_nic_ch+=NicParserleng; return BINARY_OPS; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 111 "nic.l" +{ flex_nic_ch+=NicParserleng; return FIELDS; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 113 "nic.l" +{ flex_nic_ch+=NicParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 8: +YY_RULE_SETUP +#line 117 "nic.l" +{ flex_nic_ch+=NicParserleng; NicParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* strings */ +case 9: +YY_RULE_SETUP +#line 122 "nic.l" +{ + + int c; + + NicParserlval.strval = strdup(NicParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_nic_ch+=NicParserleng; + NicParserlval.strval[NicParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + YY_BREAK +case 10: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 139 "nic.l" +{ flex_nic_ch+=NicParserleng; NicParsererror("Unterminated string"); } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_nic_linebuf */ +/* */ +case 11: +YY_RULE_SETUP +#line 146 "nic.l" +{flex_nic_ch=0; flex_nic_lineno++; + strcpy(flex_nic_linebuf,NicParsertext+1); + yyless(1); + } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 151 "nic.l" +{flex_nic_ch+=NicParserleng; } /* white space */ + YY_BREAK +case 13: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 153 "nic.l" +{flex_nic_ch+=NicParserleng; }; /* comment */ + YY_BREAK +case 14: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 154 "nic.l" +{flex_nic_ch+=NicParserleng; }; /* comment */ + YY_BREAK +case 15: +YY_RULE_SETUP +#line 156 "nic.l" +{flex_nic_ch+=NicParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); NicParsererror(yytext);} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 158 "nic.l" +ECHO; + YY_BREAK +#line 894 "niclexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 85 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 85 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 84); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 158 "nic.l" + + +int my_NicParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_nic_stringinput != NULL){ + while(c +#include + +#include "type_objects.h" +#include "parse_schema.h" + +class ext_fcn_param{ +private: + std::string type_name; + bool handle; + bool constant; + bool classifier; + data_type *dt; + +public: + ext_fcn_param(){handle = false; dt=NULL; }; + ext_fcn_param(char *t, param_list *plist, int h, int cnst, int clss){ + type_name = t; + if(h == 0) handle = false; + else handle = true; + if(cnst == 1 ) constant = true; + else constant = false; + if(clss == 1) classifier = true; + else classifier = false; + + + dt = new data_type(type_name,plist); + }; + + data_type *get_dt(){return(dt);}; + + bool use_handle(){return handle;}; + bool is_constant(){return constant;}; + bool is_classifier(){return classifier;}; + +}; + + +class ext_fcn_param_list{ +private: + std::vector plist; + +public: + ext_fcn_param_list(){}; + ext_fcn_param_list(ext_fcn_param *val){ + plist.push_back(val); + }; + + ext_fcn_param_list *append(ext_fcn_param *val){ + plist.push_back(val); + return(this); + }; + + int size(){return plist.size();}; + std::vector get_param_list(){return plist;}; +}; + +class ext_fcn_modifier_list{ +public: + std::vector modifiers; + std::vector vals; + + ext_fcn_modifier_list(char *s){ + modifiers.push_back(s); + vals.push_back(""); + }; + + ext_fcn_modifier_list(char *s, char *v){ + modifiers.push_back(s); + vals.push_back(v); + }; + + ext_fcn_modifier_list *append(char *s){ + modifiers.push_back(s); + vals.push_back(""); + return(this); + }; + + ext_fcn_modifier_list *append(char *s, char *v){ + modifiers.push_back(s); + vals.push_back(v); + return(this); + }; +}; + +#define EXT_FCN_ 1 +#define EXT_PRED_ 2 +#define EXT_AGGR_ 3 +#define EXT_EXTR_ 4 +#define EXT_STATE_ 5 +#define EXT_SFUN_ 6 + +class ext_fcn_def{ +private: + int fcn_type; + std::string type_name; // return type name + data_type *fdt; // return type + std::string storage_type_name; // storage type name + data_type *sdt; // storage type + std::string fcn_name; // name for calling this fcn. + std::string udaf_name; // if an extraction function, its udaf. + std::string actual_fcn_name; // if extr. the mapped-to function. + std::vector ef_param_list; + std::vector modifiers; // keyword modifiers of the fcn + std::vector vals; // optional vals of the keywords + bool partial; +// pre-compute these during validation + int subaggr_id, superaggr_id, hfta_subaggr_id, hfta_superaggr_id, actual_fcn_id; + +public: + + ext_fcn_def(){ + fdt=NULL; + sdt = NULL; + fcn_type=-1; + }; + + ext_fcn_def(char *t, param_list *p, ext_fcn_modifier_list *m, + char *f, ext_fcn_param_list *plist){ + subaggr_id=superaggr_id=hfta_subaggr_id=hfta_superaggr_id=actual_fcn_id=-1; + if(plist != NULL) + ef_param_list = plist->get_param_list(); + if(m != NULL){ + modifiers = m->modifiers; + vals = m->vals; + } + type_name = t; + fdt = new data_type(type_name,p); + storage_type_name = ""; + sdt = NULL; + udaf_name = ""; + actual_fcn_name = ""; + fcn_type = EXT_FCN_; + fcn_name = f; + }; + + ext_fcn_def(ext_fcn_modifier_list *m, + char *f, ext_fcn_param_list *plist){ + subaggr_id=superaggr_id=hfta_subaggr_id=hfta_superaggr_id=actual_fcn_id=-1; + if(plist != NULL) + ef_param_list = plist->get_param_list(); + if(m != NULL){ + modifiers = m->modifiers; + vals = m->vals; + } + type_name = ""; + fdt = NULL; + storage_type_name = ""; + sdt = NULL; + udaf_name = ""; + actual_fcn_name = ""; + fcn_type = EXT_PRED_; + fcn_name = f; + }; + + ext_fcn_def(char *t, param_list *p, ext_fcn_modifier_list *m, + char *f, char *st, ext_fcn_param_list *plist){ + subaggr_id=superaggr_id=hfta_subaggr_id=hfta_superaggr_id=actual_fcn_id=-1; + if(plist != NULL) + ef_param_list = plist->get_param_list(); + if(m != NULL){ + modifiers = m->modifiers; + vals = m->vals; + } + type_name = t; + fdt = new data_type(type_name,p); + storage_type_name = st; + sdt = new data_type(st); + udaf_name = ""; + actual_fcn_name = ""; + fcn_type = EXT_AGGR_; + fcn_name = f; + }; + + + ext_fcn_def(char *t, param_list *p, ext_fcn_modifier_list *m, + char *f, char *sa, char *af, ext_fcn_param_list *plist){ + subaggr_id=superaggr_id=hfta_subaggr_id=hfta_superaggr_id=actual_fcn_id=-1; + if(plist != NULL) + ef_param_list = plist->get_param_list(); + if(m != NULL){ + modifiers = m->modifiers; + vals = m->vals; + } + type_name = t; + fdt = new data_type(type_name,p); + storage_type_name = ""; + sdt = NULL; + udaf_name = sa; + actual_fcn_name = af; + fcn_type = EXT_EXTR_; + fcn_name = f; + }; + + static ext_fcn_def *make_state_def(char *t, char *n){ + ext_fcn_def *retval = new ext_fcn_def(); + retval->fcn_type = EXT_STATE_; + retval->storage_type_name = t; + retval->sdt = new data_type(retval->storage_type_name); + retval->fcn_name = n; + + return retval; + } + + static ext_fcn_def *make_sfun_def(char *t, param_list *p, + ext_fcn_modifier_list *m, + char *n, char *s, ext_fcn_param_list *plist){ + ext_fcn_def *retval = new ext_fcn_def(); + retval->fcn_type = EXT_SFUN_; + retval->type_name = t; + retval->fdt = new data_type(retval->type_name,p); + retval->storage_type_name = s; + retval->fcn_name = n; + if(plist != NULL) + retval->ef_param_list = plist->get_param_list(); + if(m != NULL){ + retval->modifiers = m->modifiers; + retval->vals= m->vals; + } + + return retval; + } + + data_type *get_fcn_dt(){return(fdt);}; + data_type *get_storage_dt(){return sdt;}; + std::string get_storage_state(){return storage_type_name;}; + std::string get_fcn_name(){return fcn_name;}; + + std::vector get_operand_dt(){ + int o; + std::vector ret; + for(o=0;oget_dt()); + } + return(ret); + }; + int get_nparams(){return ef_param_list.size();}; + + bool is_pred(){return fcn_type == EXT_PRED_;}; + bool is_fcn(){return fcn_type == EXT_FCN_;}; + bool is_udaf(){return fcn_type == EXT_AGGR_;}; + bool is_extr(){return fcn_type == EXT_EXTR_;}; + bool is_state(){return fcn_type == EXT_STATE_;}; + bool is_sfun(){return fcn_type == EXT_SFUN_;}; + int get_fcn_type(){return fcn_type;}; + + void set_subaggr_id(int i){subaggr_id = i;}; + void set_superaggr_id(int i){superaggr_id = i;}; + void set_hfta_subaggr_id(int i){hfta_subaggr_id = i;}; + void set_hfta_superaggr_id(int i){hfta_superaggr_id = i;}; + void set_actual_fcnid(int i){actual_fcn_id = i;}; + int get_subaggr_id(){return subaggr_id;}; + int get_superaggr_id(){return superaggr_id;}; + int get_hfta_subaggr_id(){return hfta_subaggr_id;}; + int get_hfta_superaggr_id(){return hfta_superaggr_id;}; + int get_actual_fcn_id(){return actual_fcn_id;}; + + std::string get_udaf_name(){return udaf_name;}; + std::string get_actual_fcn(){return actual_fcn_name;}; + + + bool is_partial(){ + int m; + for(m=0;mis_buffer_type()){ + return true; + } + return(false); + }; + + bool is_combinable(){ + int m; + for(m=0;m get_handle_indicators(){ + std::vector ret; + int o; + for(o=0;ouse_handle()) + ret.push_back(true); + else + ret.push_back(false); + } + return(ret); + }; + + std::vector get_const_indicators(){ + std::vector ret; + int o; + for(o=0;ois_constant()) + ret.push_back(true); + else + ret.push_back(false); + } + return(ret); + } + + std::vector get_class_indicators(){ + std::vector ret; + int o; + for(o=0;ois_classifier()) + ret.push_back(true); + else + ret.push_back(false); + } + return(ret); + } + + bool validate_types(std::string &err){ + int o; + + bool ret = false; + if(fdt){ + if(fdt->get_type() == undefined_t){ + err += "ERROR, unknown type "+type_name+" as return type of function "+fcn_name+"\n"; + ret = true; + } + if(fdt->get_type() == fstring_t){ + err += "ERROR, type "+type_name+" as not supported as return type, of function "+fcn_name+"\n"; + ret = true; + } + } + + if(sdt){ + if(sdt->get_type() == undefined_t){ + err += "ERROR, unknown type "+type_name+" as storage type of function "+fcn_name+"\n"; + ret = true; + } + } + + std::vector odt = this->get_operand_dt(); + for(o=0;oget_type() == undefined_t){ + err += "ERROR, unknown type "+odt[o]->get_type_str()+" as operand type of function "+fcn_name+"\n"; + ret = true; + } + if(odt[o]->get_type() == fstring_t){ + err += "ERROR, type "+odt[o]->get_type_str()+" as not supported as operand type, of function "+fcn_name+"\n"; + ret = true; + } + } + + return(ret); + } + + +}; + +class ext_fcn_list{ +private: + std::vector fl; + +public: + ext_fcn_list(){}; + ext_fcn_list(ext_fcn_def *f){ + fl.push_back(f); + }; + + ext_fcn_list *append_ext_fcn_def(ext_fcn_def *f){ + fl.push_back(f); + return(this); + }; + + int lookup_ext_fcn(std::string fname, const std::vector odt, int type){ + int f, o; + int subsumer = -1; + int subsume_cnt; + for(f=0;fget_fcn_type() != type) continue; + if(fname == fl[f]->get_fcn_name()){ + subsume_cnt = 0; + std::vector fdt = fl[f]->get_operand_dt(); + if(fdt.size() != odt.size()) + continue; + for(o=0;osubsumes_type(odt[o]) ) + break; + if(! fdt[o]->equals(odt[o])) subsume_cnt++; + } + if(o == odt.size()){ + if(subsume_cnt == 0) + return(f); + if(subsumer != -1) return -2; + subsumer = f; + } + } + } + return(subsumer); // -1 if no subsumer found. + }; + + + int lookup_pred(std::string fname, const std::vector odt){ + return lookup_ext_fcn(fname,odt,EXT_PRED_); + }; + int lookup_fcn(std::string fname, const std::vector odt){ + return lookup_ext_fcn(fname,odt,EXT_FCN_); + }; + int lookup_udaf(std::string fname, const std::vector odt){ + return lookup_ext_fcn(fname,odt,EXT_AGGR_); + }; + int lookup_extr(std::string fname, const std::vector odt){ + return lookup_ext_fcn(fname,odt,EXT_EXTR_); + }; + int lookup_state(std::string fname){ + std::vector dum; + return lookup_ext_fcn(fname,dum,EXT_STATE_); + }; + int lookup_sfun(std::string fname, const std::vector odt){ + return lookup_ext_fcn(fname,odt,EXT_SFUN_); + }; + + + + + + data_type *get_fcn_dt(int f){ + return(fl[f]->get_fcn_dt() ); + }; + data_type *get_storage_dt(int f){ + return(fl[f]->get_storage_dt() ); + }; + + bool is_partial(int f){ + return(fl[f]->is_partial()); + }; + + bool is_combinable(int f){ + return(fl[f]->is_combinable()); + }; + + bool is_running_aggr(int f){ + return(fl[f]->is_running_aggr()); + }; + + bool has_lfta_bailout(int f){ + return(fl[f]->has_lfta_bailout()); + }; + + bool multiple_returns(int f){ + return(fl[f]->multiple_returns()); + }; + + bool fta_legal(int f){ + return(fl[f]->fta_legal()); + }; + + bool is_sampling_fcn(int f) { + return(fl[f]->is_sampling_fcn()); + }; + + int get_fcn_cost(int f) { + return(fl[f]->get_fcn_cost()); + }; + + int estimate_fcn_cost(int f) { + return(fl[f]->estimate_fcn_cost()); + }; + + int get_actual_fcn_id(int i){ return(fl[i]->get_actual_fcn_id());}; + int get_subaggr_id(int i){ return(fl[i]->get_subaggr_id());}; + int get_superaggr_id(int i){ return(fl[i]->get_superaggr_id());}; + int get_hfta_subaggr_id(int i){ return(fl[i]->get_hfta_subaggr_id());}; + int get_hfta_superaggr_id(int i){ return(fl[i]->get_hfta_superaggr_id());}; + int get_nparams(int i){ return(fl[i]->get_nparams());}; + std::string get_fcn_name(int i){ + return fl[i]->get_fcn_name(); + } + std::string get_storage_state(int i){return fl[i]->get_storage_state();}; + + + + std::vector get_handle_indicators(int f){ + return(fl[f]->get_handle_indicators()); + }; + std::vector get_const_indicators(int f){ + return(fl[f]->get_const_indicators()); + }; + std::vector get_class_indicators(int f){ + return(fl[f]->get_class_indicators()); + }; + + bool validate_fcns(std::string &err){ + int e, f; + int subaggr_id, superaggr_id, hfta_subaggr_id, hfta_superaggr_id; + +// First, validate that all data types exist and are valid. + + int retval = 0; + for(e=0;evalidate_types(err)) retval = 1; + } + if(retval) return(true); + +// validate combinable predicates + for(e=0;eis_pred() && fl[e]->is_combinable()){ + std::vector hlv = fl[e]->get_handle_indicators(); + std::vector cov = fl[e]->get_const_indicators(); + std::vector clv = fl[e]->get_class_indicators(); + int i; + for(i=0;iget_fcn_name()+", there is a parameter that is not a CLASS-ification parameter, but neither is it CONST nor HANDLE.\n"; + retval = 1; + for(i=0;iis_sfun()){ + std::string sstate = fl[e]->get_storage_state(); + if(lookup_state(sstate) < 0){ + err += "ERROR, stateful function "+fl[e]->get_fcn_name()+" has state "+sstate+", which is not defined.\n"; + retval = 1; + continue; + } + } + } + +// Validate subaggregates and superaggregates of udafs + + for(e=0;eis_udaf()){ + std::string subaggr = fl[e]->get_subaggr(); + std::string superaggr = fl[e]->get_superaggr(); + if(subaggr != "" || superaggr != ""){ + if(subaggr == "" || superaggr == ""){ + err += "ERROR, aggregate "+fl[e]->get_fcn_name()+" has a sub or superaggregate specified, but not both.\n"; + retval = 1; + continue; + } + subaggr_id=lookup_udaf(subaggr, fl[e]->get_operand_dt()); + if(subaggr_id < 0){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a subaggregate specified, but it can't be found.\n"; + if(subaggr_id == -2) err+="(multiple subsuming subaggrs found)\n"; + retval=1; + continue; + } + std::vector dtv; + dtv.push_back( fl[subaggr_id]->get_fcn_dt() ); + superaggr_id=lookup_udaf(superaggr, dtv); + if(superaggr_id < 0){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a superaggregate specified, but it can't be found.\n"; + if(subaggr_id == -2) err+="(multiple subsuming superaggrs found)\n"; + retval=1; + continue; + } + + if( fl[e]->is_running_aggr() != fl[superaggr_id]->is_running_aggr()){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a superaggregate specified, but one is a running aggregate and the other isn't\n"; +//printf("e=%d (%u), superaggr_id=%d (%u)\n",e, fl[e]->is_running_aggr(),superaggr_id,fl[superaggr_id]->is_running_aggr()); + retval=1; + continue; + } + + if(! fl[e]->get_fcn_dt()->equals(fl[superaggr_id]->get_fcn_dt())){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a superaggregate specified, but they have different return types.\n"; + retval=1; + continue; + } + + if(fl[subaggr_id]->get_subaggr()!="" || fl[subaggr_id]->get_superaggr() != ""){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a subaggregate specified, but it also has sub/super aggregates\n"; + retval=1; + continue; + } + if(fl[superaggr_id]->get_subaggr()!="" || fl[superaggr_id]->get_superaggr() != ""){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a subaggregate specified, but it also has sub/super aggregates\n"; + retval=1; + continue; + } + + fl[e]->set_subaggr_id(subaggr_id); + fl[e]->set_superaggr_id(superaggr_id); + } + } + } + +// Validate high level subaggregates and superaggregates of udafs (hfta_subaggregate and hfta_supeaggregate) + + for(e=0;eis_udaf()){ + std::string hfta_subaggr = fl[e]->get_hfta_subaggr(); + std::string hfta_superaggr = fl[e]->get_hfta_superaggr(); + if(hfta_subaggr != "" || hfta_superaggr != ""){ + if(hfta_subaggr == "" || hfta_superaggr == ""){ + err += "ERROR, aggregate "+fl[e]->get_fcn_name()+" has a hfta_sub or hfta_superaggregate specified, but not both.\n"; + retval = 1; + continue; + } + hfta_subaggr_id=lookup_udaf(hfta_subaggr, fl[e]->get_operand_dt()); + if(hfta_subaggr_id < 0){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a hfta_subaggregate specified, but it can't be found.\n"; + if(subaggr_id == -2) err+="(multiple subsuming hfta_subaggrs found)\n"; + retval=1; + continue; + } + std::vector dtv; + dtv.push_back( fl[hfta_subaggr_id]->get_fcn_dt() ); + hfta_superaggr_id=lookup_udaf(hfta_superaggr, dtv); + if(hfta_superaggr_id < 0){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a hfta_superaggregate specified, but it can't be found.\n"; + if(hfta_subaggr_id == -2) err+="(multiple subsuming hfta_superaggrs found)\n"; + retval=1; + continue; + } + + if(! fl[e]->get_fcn_dt()->equals(fl[hfta_superaggr_id]->get_fcn_dt())){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a hfta_superaggregate specified, but they have different return types.\n"; + retval=1; + continue; + } + + /* + + if(fl[hfta_subaggr_id]->get_hfta_subaggr()!="" || fl[hfta_subaggr_id]->get_hfta_superaggr() != ""){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a hfta_subaggregate specified, but it also has hfta sub/super aggregates\n"; + retval=1; + continue; + } + if(fl[hfta_superaggr_id]->get_hfta_subaggr()!="" || fl[hfta_superaggr_id]->get_hfta_superaggr() != ""){ + err+="ERROR, aggregate "+fl[e]->get_fcn_name()+" has a hfta_subaggregate specified, but it also has hfta sub/super aggregates\n"; + retval=1; + continue; + } + */ + + fl[e]->set_hfta_subaggr_id(hfta_subaggr_id); + fl[e]->set_hfta_superaggr_id(hfta_superaggr_id); + } + } + } + +// Verify the extraction functions + for(e=0;eis_extr()){ +//printf("Verifying extractor %d\n",e); + std::vector ope = fl[e]->get_operand_dt(); +// Find the subaggregate + int a; + for(a=0;ais_udaf() && fl[e]->get_udaf_name() == fl[a]->get_fcn_name()){ +//printf("matching to subaggregagte %d\n",a); + std::vector opa = fl[a]->get_operand_dt(); + if(opa.size() > ope.size()) continue; + int o; + bool match_ops = true; + for(o=0;oequals(opa[o])) match_ops = false; +//else printf("\tmatched operand %d\n",o); + } + if(match_ops) break; +//else printf("subaggregate match failed.\n"); + } + } + if(a>=fl.size()){ + err+="ERROR, aggregate extractor "+fl[e]->get_fcn_name()+" has a subaggregate "+ fl[e]->get_udaf_name()+" specified, but it can't be found.\n"; + retval=1; + continue; + } + +// Found the subaggregate + subaggr_id = a; + std::vector opa = fl[a]->get_operand_dt(); + +// Find the actual function + for(f=0;fis_fcn() && fl[e]->get_actual_fcn() == fl[f]->get_fcn_name()){ +//printf("Matching to extraction function %d\n",f); + std::vector opf = fl[f]->get_operand_dt(); + if(opf.size() + opa.size() -1 != ope.size()) continue; +//else printf("Operand sizes match (%d + %d -1 = %d)\n",opf.size(),opa.size(),ope.size() ); + int o; + bool match_ops = true; + if(! fl[a]->get_fcn_dt()->equals(opf[0])) match_ops=false; +//if(!match_ops) printf("aggr return val doesn't match 1st param\n"); + for(o=1;oequals(opf[o])) + match_ops = false; +//else printf("\tmatched operand e[%d] to f[%d]\n",o+opa.size()-1,o); + } + if(match_ops) break; +//else printf("Match failed.\n"); + } + } + if(f>=fl.size()){ + err+="ERROR, aggregate extractor "+fl[e]->get_fcn_name()+" uses function "+ fl[e]->get_actual_fcn()+", but it can't be found.\n"; + retval=1; + continue; + } + if(! fl[e]->get_fcn_dt()->equals(fl[f]->get_fcn_dt()) ){ + err+="ERROR, aggregate extractor "+fl[e]->get_fcn_name()+" uses function "+ fl[e]->get_actual_fcn()+", but they have different return value types.\n"; + retval=1; + continue; + } + +// Found the extractor fcn, record them in the ext fcn struct. + fl[e]->set_subaggr_id(subaggr_id); + fl[e]->set_actual_fcnid(f); + } + } + + if(retval) return(true); else return(false); + }; + + +}; + + +#endif diff --git a/src/ftacmp/parse_fta.h b/src/ftacmp/parse_fta.h new file mode 100644 index 0000000..c1ea6ed --- /dev/null +++ b/src/ftacmp/parse_fta.h @@ -0,0 +1,1889 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef _FTA_PARSE_H_INCLUDED__ +#define _FTA_PARSE_H_INCLUDED__ + +#include +#include + + int yyparse(); + void yyerror(char *s); + int yylex(); +extern int flex_fta_lineno, flex_fta_ch; + +/* Interface to FTA Parser */ +void FtaParser_setfileinput(FILE *f); +void FtaParser_setstringinput(char *s); + + +/* Get type defines. */ +#include"type_objects.h" +#include"literal_types.h" +#include"type_indicators.h" + +#include +#include +#include +#include +#include +#include +#include + + +// colref_t::is_equivalent needs to understand the schema +#include"parse_schema.h" +class colref_t; + + + +class var_pair_t{ +public: + std::string name; + std::string val; + + var_pair_t(char *n, char *v){ + name=n; val=v; +//printf("NEW var_pair_t(%s, %s)\n",n,v); + }; + + var_pair_t(const std::string n, const std::string v){ + name=n; val=v; + }; +}; + +typedef std::map< std::string, std::string > ss_map; + +class var_defs_t{ +private: + std::vector namevec; + +public: + var_defs_t(var_pair_t *vp){ + namevec.push_back(vp); + }; + + var_defs_t *add_var_pair(var_pair_t *vp){ + namevec.push_back(vp); + return(this); + }; + + std::vector get_nvec(){return namevec;}; + + int size(){return namevec.size();}; + + int find_name(std::string n){ + int i; + for(i=0;iname == n) + return i; + } + return -1; + } + std::string get_name(int i){ + if(i>=0 && iname); + }else{ + return(""); + } + } + + std::string get_def(int i){ + if(i>=0 && ival); + }else{ + return(""); + } + } + + std::string dump(){ + int i; + std::string ret; + for(i=0;iname+" = "+namevec[i]->val+"\n"; + } + return ret; + } + +}; + + + + +// literal type constants are defined in literal_types.h +// (must share this info with type_objects.h) + +// Represents a literal, as expected +// NOTE: this class contains some code generation methods. + +class literal_t{ +private: + +public: + std::string lstring; /* literal value */ + short int ltype; /* literal type */ + int lineno, charno; + + int complex_literal_id; // if this literal has a complex constructor, + // there is a function which constructs it) + //set to the idx in the complex literal + // table. (Must store this here (instead of in SE) + // because of bare literals in the IN predicate). + + + literal_t(std::string v){ + lstring = v; + ltype = LITERAL_STRING; + complex_literal_id = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + } + static literal_t *make_define_literal(const char *s, var_defs_t *d){ + int i; + i=d->find_name(s); + if(i<0){ + fprintf(stderr,"ERROR at line %d, char %d; DEFINE'd literal %s referenced but not in DEFINE block.\n",flex_fta_lineno, flex_fta_ch, s); + exit(1); + } + return new literal_t(d->get_def(i)); + } + + literal_t(const char *lit, int t){lstring = lit; ltype = t; + lineno = flex_fta_lineno; charno = flex_fta_ch; + complex_literal_id = -1; + +// For some datatypes we need to modify literal so make a copy of the string + char v[100]; + strcpy(v, lit); + +// Remove UL, ULL suffix from INT constants. + if(ltype == LITERAL_INT || ltype == LITERAL_LONGINT){ + int i; + int len=strlen(v); + for(i=0;i= '0' && (*c) <= '9') || (tolower(*c) >= 'a' && tolower(*c) <= 'f') ) ){ + fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not a HEX constant.\n", + lineno, charno, v); + exit(1); + } + } + sscanf(v,"%lx",&tmp_l); + sprintf(ltmpstr,"%lu",tmp_l); + lstring = ltmpstr; + ltype = LITERAL_INT; + } + if(ltype == LITERAL_LONGHEX){ + char *c,ltmpstr[100]; + unsigned long long tmp_ll; + for(c=v; (*c)!='\0';++c){ + if(! ( ((*c) >= '0' && (*c) <= '9') || (tolower(*c) >= 'a' && tolower(*c) <= 'f') ) ){ + fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not a LHEX constant.\n", + lineno, charno, v); + exit(1); + } + } + sscanf(v,"%llx",&tmp_ll); + sprintf(ltmpstr,"%llu",tmp_ll); + lstring = ltmpstr; + ltype = LITERAL_LONGINT; + } +// Convert IP to uint + if(ltype == LITERAL_IP){ + char ltmpstr[100]; + unsigned int o1,o2,o3,o4,tmp_l; + if(sscanf(v,"%u.%u.%u.%u",&o1,&o2,&o3,&o4) != 4){ + fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not an IP constant.\n", + lineno, charno, v); + exit(1); + } + if( (o1>255) || (o2>255) || (o3>255) || (o4>255) ){ + fprintf(stderr,"Syntax Error, line=%d, character=%d. The literal %s is not an IP constant.\n", + lineno, charno, v); + exit(1); + } + tmp_l = (o1<<24)+(o2<<16)+(o3<<8)+o4; + sprintf(ltmpstr,"%u",tmp_l); + lstring = ltmpstr; + ltype = LITERAL_IP; + } + }; + +// used to create literals with a default or initial value. + literal_t(int type_indicator){ + lineno=-1; charno=-1; + complex_literal_id = -1; + + switch(type_indicator){ + case UINT_TYPE: + case INT_TYPE: + case USHORT_TYPE: + ltype = LITERAL_INT; + lstring = "0"; + break; + case ULLONG_TYPE: + case LLONG_TYPE: + ltype = LITERAL_LONGINT; + lstring = "0"; + break; + case FLOAT_TYPE: + ltype = LITERAL_FLOAT; + lstring = "0.0"; + break; + case BOOL_TYPE: + ltype = LITERAL_BOOL; + lstring = "FALSE"; + break; + case VSTR_TYPE: + ltype = LITERAL_STRING; + lstring = ""; complex_literal_id = 0; // unregistred complex lit + break; + case TIMEVAL_TYPE: + ltype = LITERAL_TIMEVAL; + lstring = "0.0"; + break; + case IPV6_TYPE: + ltype = LITERAL_IPV6; + lstring = "0000:0000:0000:0000:0000:0000:0000:0000"; + complex_literal_id = 0; // unregistered complex literal + break; + case IP_TYPE: + ltype = LITERAL_IP; + lstring = "0"; + break; + default: + ltype = LITERAL_UDEF; + lstring=" INTERNAL ERROR, UNKNOWN TYPE INDICATOR IN literal_t::literal_t(int) "; + } + }; + + std::string to_string(){return lstring;}; + + int get_type(){return ltype; }; + int get_lineno(){return lineno; }; + int get_charno(){return charno; }; + + bool is_equivalent(literal_t *l2){ + if(ltype != l2->ltype) + return(false); + if(lstring != l2->lstring) + return(false); + + return(true); + }; + +// Internal function to unescape control characters. + static std::string gsqlstr_to_cstr(std::string s){ + std::string retval; + unsigned char c, prev_c='\0'; + int i; + + for(i=0;ihfta_constructor_name() ); + retval.append("("+param+",\""); + retval.append(gsqlstr_to_cstr(lstring)); + retval.append("\")"); + return(retval); + case LITERAL_INT: + case LITERAL_IP: + return("((gs_uint32_t)"+lstring+")"); + case LITERAL_LONGINT: + return("((gs_uint64_t)"+lstring+")"); + case LITERAL_FLOAT: + return(lstring); +// case LITERAL_HEX: +// return("0x"+lstring); + case LITERAL_BOOL: + if(lstring == "TRUE"){ + return("1"); + }else{ + return("0"); + } + case LITERAL_TIMEVAL: + retval.append(this->hfta_constructor_name() ); + tmp_f = atof(lstring.c_str()); + secs = (int)floor(tmp_f); + millisecs = (int) rint((tmp_f - secs)*1000); + sprintf(tmpstr,"(%d, %d)",secs,millisecs); + retval.append(tmpstr); + return(retval); + case LITERAL_IPV6: + retval = this->hfta_constructor_name(); + retval += "("+param+",\""+lstring+"\")"; + return retval; + } + + return("ERROR UNKNOWN LITERAL"); + }; + + +/// for LFTA code generation + std::string to_C_code(std::string param){ + std::string retval; + double tmp_f; + int secs, millisecs; + char tmpstr[100]; + + switch(ltype){ + case LITERAL_STRING: + retval = this->constructor_name()+"("+param+",\""+gsqlstr_to_cstr(lstring)+"\")"; + return(retval); + case LITERAL_INT: + case LITERAL_IP: + return("((gs_uint32_t)"+lstring+")"); + case LITERAL_LONGINT: + return("((gs_uint64_t)"+lstring+")"); + case LITERAL_FLOAT: + return(lstring); +// case LITERAL_HEX: +// return("0x"+lstring); + case LITERAL_BOOL: + if(lstring == "TRUE"){ + return("1"); + }else{ + return("0"); + } + case LITERAL_IPV6: + retval = this->constructor_name()+"("+param+",\""+lstring+"\")"; + return(retval); + case LITERAL_TIMEVAL: + retval.append(this->constructor_name() ); + tmp_f = atof(lstring.c_str()); + secs = (int)floor(tmp_f); + millisecs = (int) rint((tmp_f - secs)*1000); + sprintf(tmpstr,"(%d, %d)",secs,millisecs); + retval.append(tmpstr); + return(retval); + } + + return("ERROR UNKNOWN LITERAL"); + }; + + + std::string to_query_string(){ + std::string retval; + + switch(ltype){ + case LITERAL_IP: + { + unsigned int v; + sscanf(lstring.c_str(),"%u",&v); + int d1 = v & 0xff; + int d2 = (v & 0xff00) >> 8; + int d3 = (v & 0xff0000) >> 16; + int d4 = (v & 0xff000000) >> 24; + char ret[200]; + sprintf(ret,"IP_VAL'%u.%u.%u.%u'",d4,d3,d2,d1); + return ret; + } + case LITERAL_STRING: + retval = "'"+lstring+"'"; + return(retval); + case LITERAL_INT: + case LITERAL_FLOAT: + case LITERAL_TIMEVAL: + case LITERAL_IPV6: + case LITERAL_BOOL: + return(lstring); + case LITERAL_LONGINT: + return(lstring+"ULL"); + } + + return("ERROR UNKNOWN LITERAL in literal_t::to_query_string"); + }; + +// TODO : Use definition files instead of hardwiring these. + +// constructor in LFTA code + std::string constructor_name(){ + + switch(ltype){ + case LITERAL_TIMEVAL: + return("Timeval_Constructor"); + case LITERAL_IPV6: + return("Ipv6_Constructor"); + case LITERAL_STRING: + return("str_constructor"); + case LITERAL_INT: + case LITERAL_IP: + case LITERAL_LONGINT: + case LITERAL_BOOL: + case LITERAL_FLOAT: + return(""); + } + return("ERROR UNKNOWN LITERAL"); + }; + + std::string hfta_constructor_name(){ + + switch(ltype){ + case LITERAL_TIMEVAL: + return("HFTA_Timeval_Constructor"); + case LITERAL_IPV6: + return("HFTA_Ipv6_Constructor"); + case LITERAL_STRING: + return("Vstring_Constructor"); + case LITERAL_INT: + case LITERAL_IP: + case LITERAL_LONGINT: + case LITERAL_BOOL: + case LITERAL_FLOAT: + return(""); + } + return("ERROR UNKNOWN LITERAL"); + }; + + std::string hfta_empty_literal_name(){ + + switch(ltype){ + case LITERAL_TIMEVAL: + return("EmptyTimeval"); + case LITERAL_IPV6: + return("EmptyIp6"); + case LITERAL_STRING: + return("EmptyString"); + } + return("ERROR_NOT_A_COMPLEX_LITERAL"); + }; + + + void set_cpx_lit_ref(int g){complex_literal_id = g; }; + int get_cpx_lit_ref(){return (complex_literal_id ); }; + bool is_cpx_lit(){return(complex_literal_id >= 0); }; + +}; + + +/* + A (null terminated) list of literals. + Used for the IN clause +*/ + +class literal_list_t{ +private: + +public: + std::vector lit_list; + int lineno, charno; + + literal_list_t(literal_t *l){ + lit_list.push_back(l); + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + literal_list_t(std::vector lvec){ + lineno = charno = 0; + lit_list = lvec; + }; + + literal_list_t *append_literal(literal_t *l){ + lit_list.push_back(l); + return(this); + }; + + std::string to_string(){ + int i; + std::string retval; + for(i=0;i0) retval.append(", "); + retval.append(lit_list[i]->to_query_string()); + } + return(retval); + }; + + std::vector get_literal_vector(){return(lit_list);}; + +}; + + +class string_t{ +public: + std::string val; + string_t(char *s){ + val = s; + } + string_t *append(char *s){ + val += s; + return this; + } + string_t *append(char *sep, char *s){ + val += sep; + val += s; + return this; + } + const char *c_str(){ + return val.c_str(); + } +}; + +// A tablevar is a data source in a GSQL query. +// Every column ref must be bound to a tablevar, +// either explicitly or via imputation. + + +class tablevar_t{ +public: +// A tablevar is a variable which binds to a named data source. +// the variable name might be explicit in the query, or it might be +// implicit in which case the variable name is imputed. In either case +// the variable name is set via the set_range_var method. +// +// The data source is the name of either a STREAM or a PROTOCOL. +// All STREAMS are unique, but a PROTOCOL must be bound to an +// interface. If the interface is not given, it is imputed to be +// the default interface. + + std::string machine; + std::string interface; + std::string schema_name; + std::string variable_name; + std::string udop_alias; // record UDOP ID for of UDOP + // for use by cluster manager + + int schema_ref; // index of the table in the schema (table_list) + int opview_idx; // index in list of operator views (if any) + bool iface_is_query; // true if iface resolves to query + // instead of specific interface. + + int properties; // inner (0) or outer (1) join; + // labeled using FROM clause, + // determines join algorithm. + + int lineno, charno; + + tablevar_t(){ opview_idx = -1; schema_ref=-1; iface_is_query = false; + lineno=-1; charno=-1;}; + tablevar_t(const char *t){schema_name=t; interface=""; + opview_idx = -1; schema_ref = -1; + variable_name=""; properties = 0; + iface_is_query = false; + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + + tablevar_t(const char *i, const char *s, int iq){interface=i; schema_name=s; + opview_idx = -1; schema_ref = -1; + variable_name=""; properties = 0; + if(iq) iface_is_query = true; else iface_is_query = false; + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + + tablevar_t(const char *m, const char *i, const char *s){ + machine = m; interface=i; schema_name=s; + opview_idx = -1; schema_ref = -1; + variable_name=""; properties = 0; + iface_is_query = false; + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + + tablevar_t *duplicate(){ + tablevar_t *ret = new tablevar_t(); + ret->lineno = lineno; ret->charno = charno; + ret->schema_ref = schema_ref; + ret->opview_idx = opview_idx; + ret->machine = machine; + ret->interface = interface; + ret->schema_name = schema_name; + ret->variable_name = variable_name; + ret->properties = properties; + ret->iface_is_query = iface_is_query; + return(ret); + }; + + tablevar_t *set_range_var(const char *r){ + variable_name = r; + return(this); + }; + tablevar_t *set_range_var(std::string r){ + variable_name = r; + return(this); + }; + + void set_schema(std::string s){schema_name = s;}; + void set_interface(std::string i){interface=i;}; + void set_machine(std::string m){machine = m;}; + void set_udop_alias(std::string u){udop_alias = u;}; + + void set_schema_ref(int r){schema_ref = r;}; + int get_schema_ref(){return schema_ref;}; + + void set_opview_idx(int i){opview_idx = i;}; + int get_opview_idx(){return opview_idx;}; + + void set_property(int p){properties = p;}; + int get_property(){return properties;}; + + bool get_ifq(){return iface_is_query;}; + void set_ifq(bool b){iface_is_query = b;}; + + std::string to_string(){ + std::string retval; + + if(machine != "" && !iface_is_query) + retval += "'"+machine+"'."; + if(interface != ""){ + if(iface_is_query){ + retval += '['+interface+"]."; + }else{ + retval += interface+"."; + } + } + retval += schema_name; + if(variable_name != "") retval+=" "+variable_name; + + return(retval); + }; + + std::string get_schema_name(){return schema_name;}; + void set_schema_name(std::string n){schema_name=n;}; + std::string get_var_name(){return variable_name;}; + std::string get_interface(){return interface;}; + std::string get_machine(){return machine;}; + std::string get_udop_alias(){return udop_alias;}; + + int get_lineno(){return(lineno); }; + int get_charno(){return(charno); }; + +}; + +#define INNER_JOIN_PROPERTY 0 +#define LEFT_OUTER_JOIN_PROPERTY 1 +#define RIGHT_OUTER_JOIN_PROPERTY 2 +#define OUTER_JOIN_PROPERTY 3 +#define FILTER_JOIN_PROPERTY 4 + +// tablevar_list_t is the list of tablevars in a FROM clause + +struct tablevar_list_t{ +public: + std::vector tlist; + int properties; + int lineno, charno; +// For filter join + colref_t *temporal_var; + unsigned int temporal_range; + + tablevar_list_t(){properties = -1; temporal_var = NULL;} + tablevar_list_t(tablevar_t *t){tlist.push_back(t); properties=-1; temporal_var = NULL; + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + tablevar_list_t(std::vector t){tlist = t; properties=-1; temporal_var = NULL; + lineno = 0; charno = 0;}; + + tablevar_list_t *duplicate(){ + tablevar_list_t *ret = new tablevar_list_t(); + ret->lineno = lineno; ret->charno = charno; + ret->properties = properties; + ret->temporal_var = temporal_var; + ret->temporal_range = temporal_range; + int i; + for(i=0;iappend_table(tlist[i]->duplicate()); + } + return(ret); + } + + + + tablevar_list_t *append_table(tablevar_t *t){ + tlist.push_back(t); + return(this); + }; + + std::string to_string(){ + int i; + std::string retval; + + for(i=0;i0) retval.append(", "); + retval.append(tlist[i]->to_string()); + } + return(retval); + }; + + std::vector get_table_list(){return(tlist); }; + + std::vector get_table_names(){ + std::vector ret; + int t; + for(t=0;tget_schema_name(); + ret.push_back(tbl_name); + } + return(ret); + } + + std::vector get_src_tbls(table_list *Schema){ + std::vector ret; + int t, sq; + for(t=0;tget_schema_name(); + int sid = Schema->find_tbl(tbl_name); + if(sid < 0){ ret.push_back(tbl_name); + }else + if(Schema->get_schema_type(sid) != OPERATOR_VIEW_SCHEMA){ + ret.push_back(tbl_name); + }else{ + std::vector sqspec = Schema->get_subqueryspecs(sid); + for(sq=0;sqname); + } + } + } + return(ret); + }; + + int size(){ + return tlist.size(); + }; + +// Some accessor functions. + + std::vector get_schema_names(){ + int i; + std::vector retval; + for(i=0;iget_schema_name()); + } + return(retval); + } + + std::vector get_schema_refs(){ + int i; + std::vector retval; + for(i=0;iget_schema_ref()); + } + return(retval); + } + + + int get_schema_ref(int i){ + if(i<0 || i>=tlist.size()) return(-1); + return tlist[i]->get_schema_ref(); + }; + + std::string get_tablevar_name(int i){ + if(i<0 || i>=tlist.size()) return(""); + return tlist[i]->get_var_name(); + }; + + void set_properties(int p){properties = p;}; + int get_properties(){return properties;}; + + void set_colref(colref_t *c){temporal_var = c;}; + void set_temporal_range(unsigned int t){temporal_range = t;}; + void set_temporal_range(const char *t){temporal_range= atoi(t);}; + colref_t *get_colref(){return temporal_var;}; + unsigned int get_temporal_range(){return temporal_range;}; + +}; + +// A reference to an interface parameter. +// (I need to be able to record the source +// tablevar, else this would be a lot simpler). +class ifpref_t{ +public: + std::string tablevar; + std::string pname; + int tablevar_ref; + int lineno, charno; + + ifpref_t(const char *p){ + tablevar=""; + pname = p; + tablevar_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + ifpref_t(const char *t, const char *p){ + tablevar=t; + pname = p; + tablevar_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + void set_tablevar_ref(int i){tablevar_ref = i;}; + int get_tablevar_ref(){return tablevar_ref;}; + std::string get_tablevar(){return tablevar;} + void set_tablevar(std::string t){tablevar = t;}; + std::string get_pname(){return pname;} + std::string to_string(){ + std::string ret; + if(tablevar != "") + ret += tablevar + "."; + ret += "@"+pname; + return ret; + }; + bool is_equivalent(ifpref_t *i){ + return (tablevar_ref == i->tablevar_ref) && (pname == i->pname); + }; +}; + + + + +// A representation of a reference to a field of a +// stream (or table). This reference must be bound +// to a particular schema (schema_ref) and to a +// particular table variable in the FROM clause (tablevar_ref) +// If the column reference was generated by the parser, +// it will contain some binding text wich might need +// interpretation to do the actual binding. +class colref_t{ +public: + std::string interface; // specified interface, if any. + std::string table_name; // specified table name or range var, if any. + std::string field; // field name + bool default_table; // true iff. no table or range var given. + int schema_ref; // ID of the source schema. + int tablevar_ref; // ID of the tablevar (in FROM clause). + int lineno, charno; + + colref_t(const char *f){ + field = f; default_table = true; + schema_ref = -1; tablevar_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + colref_t(const char *t, const char *f){ + table_name = t; field=f; default_table = false; + schema_ref = -1; tablevar_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + colref_t(const char *i, const char *t, const char *f){ + interface=i; + table_name = t; field=f; default_table = false; + schema_ref = -1; tablevar_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + colref_t *duplicate(){ + colref_t *retval = new colref_t(interface.c_str(), table_name.c_str(), field.c_str()); + retval->schema_ref = schema_ref; + retval->tablevar_ref = tablevar_ref; + retval->lineno = lineno; + retval->charno = charno; + retval->default_table = default_table; + return(retval); + } + + std::string to_string(){ + if(default_table){ + return field; + }else{ + if(interface != "") return(interface+"."+table_name+"."+field); + return(table_name + "." + field); + } + }; + + std::string to_query_string(){ + if(default_table){ + return field; + }else{ + if(interface != "") return(interface+"."+table_name+"."+field); + if(table_name != "") return(table_name + "." + field); + return(field); + } + }; + + int get_lineno(){return lineno; }; + int get_charno(){return charno; }; + + bool uses_default_table(){return default_table; }; + + std::string get_field(){return(field); }; + void set_field(std::string f){field=f;}; + std::string get_table_name(){return(table_name);}; + std::string get_interface(){return(interface);}; + void set_table_name(std::string t){table_name = t; default_table=false;}; + void set_interface(std::string i){interface=i;}; + + int get_schema_ref(){return schema_ref;} + void set_schema_ref(int s){schema_ref = s;}; + int get_tablevar_ref(){return tablevar_ref;} + void set_tablevar_ref(int s){tablevar_ref = s;}; + +// Should equivalence be based on tablevar_ref or schema_ref? + bool is_equivalent(colref_t *c2){ + if(schema_ref == c2->schema_ref){ + return(field == c2->field); + } + return(false); + }; + + bool is_equivalent_base(colref_t *c2, table_list *Schema){ + if(Schema->get_basetbl_name(schema_ref,field) == + Schema->get_basetbl_name(c2->schema_ref,c2->field)){ + return(field == c2->field); + } + return(false); + }; +}; + +class colref_list_t{ +public: + std::vector clist; + +// colref_list_t(){}; + + colref_list_t(colref_t *c){ + clist.push_back(c); + } + + colref_list_t *append(colref_t *c){ + clist.push_back(c); + return this; + } + + std::vector get_clist(){ + return clist; + } +}; + + + + + + +/* + A tree containing a scalar expression. + Used for + atom : a parameter or a literal + scalar_exp (see the scalar_exp: rule in emf.l for details) + function_ref (a function that has a value, e.g. an aggregate + function). + operator_type defines the contents of the node. If its a non-terminal, + then op has a meaning and defines the operation. See the list of + #define'd constants following the structure definition. + + +*/ + +#define SE_LITERAL 1 +#define SE_PARAM 2 +#define SE_COLREF 3 +#define SE_UNARY_OP 4 +#define SE_BINARY_OP 5 +#define SE_AGGR_STAR 6 +#define SE_AGGR_SE 7 +#define SE_FUNC 8 +#define SE_IFACE_PARAM 9 + + +class scalarexp_t{ +public: + int operator_type; + std::string op; + union{ + scalarexp_t *scalarp; + literal_t *litp; + colref_t *colref; + ifpref_t *ifp; + } lhs; + union{ + scalarexp_t *scalarp; + } rhs; + std::vector param_list; + +// SE node decorations -- results of query analysis. + data_type *dt; + int gb_ref; // set to the gb attr tbl ref, else -1 + int aggr_id; // set to the aggr tbl ref, else -1 + int fcn_id; // external function table ref, else -1 + int partial_ref; // partial fcn table ref, else -1 + int fcn_cache_ref; // function cache ref, else -1 + int handle_ref; // Entry in pass-by-handle parameter table, else -1. + // (might be a literal or a query param). + bool is_superagg; // true if is aggregate and associated with supergroup. + std::string storage_state; // storage state of stateful fcn, + // empty o'wise. + + int lineno, charno; + + void default_init(){ + operator_type = 0; + gb_ref = -1; aggr_id = -1; fcn_id = -1; + partial_ref = -1; fcn_cache_ref=-1; + handle_ref = -1; + dt = NULL; lineno = flex_fta_lineno; charno = flex_fta_ch; + is_superagg = false; + }; + + scalarexp_t(){ + default_init();}; + + scalarexp_t(colref_t *c){ + default_init(); + operator_type = SE_COLREF; + lhs.colref = c; + }; + + scalarexp_t(literal_t *l){ + default_init(); + operator_type = SE_LITERAL; + lhs.litp = l; + }; + + void convert_to_literal(literal_t *l){ +// default_init(); + if(operator_type != SE_IFACE_PARAM){ + fprintf(stderr,"INTERNAL ERROR in literal_t::convert_to_literal, operator type isn't SE_IFACE_PARAM.\n"); + exit(1); + } + operator_type = SE_LITERAL; + lhs.litp = l; + } + + scalarexp_t(const char *o, scalarexp_t *operand){ + default_init(); + operator_type = SE_UNARY_OP; + op = o; + lhs.scalarp = operand; + }; + + scalarexp_t(const char *o, scalarexp_t *l_op, scalarexp_t *r_op){ + default_init(); + operator_type = SE_BINARY_OP; + op = o; + lhs.scalarp = l_op; + rhs.scalarp = r_op; + }; + + scalarexp_t(const char *o, std::vector op_list){ + default_init(); + operator_type = SE_FUNC; + op = o; + param_list = op_list; + }; + + static scalarexp_t *make_paramless_fcn(const char *o){ + scalarexp_t *ret = new scalarexp_t(); + ret->operator_type = SE_FUNC; + ret->op = o; + return(ret); + }; + + static scalarexp_t *make_star_aggr(const char *ag){ + scalarexp_t *ret = new scalarexp_t(); + ret->operator_type = SE_AGGR_STAR; + ret->op = ag; + return(ret); + }; + + static scalarexp_t *make_se_aggr(const char *ag, scalarexp_t *l_op){ + scalarexp_t *ret = new scalarexp_t(); + ret->operator_type = SE_AGGR_SE; + ret->op = ag; + ret->lhs.scalarp = l_op; + return(ret); + }; + + static scalarexp_t *make_param_reference(const char *param){ + scalarexp_t *ret = new scalarexp_t(); + ret->operator_type = SE_PARAM; + ret->op = param; + return(ret); + }; + + static scalarexp_t *make_iface_param_reference(ifpref_t *i){ + scalarexp_t *ret = new scalarexp_t(); + ret->operator_type = SE_IFACE_PARAM; + ret->lhs.ifp = i; + return(ret); + }; + + + std::string to_string(){ + if(operator_type == SE_COLREF){ + return lhs.colref->to_string(); + } + if(operator_type == SE_LITERAL){ + return lhs.litp->to_string(); + } + if(operator_type == SE_UNARY_OP){ + return op + " (" + lhs.scalarp->to_string() + ")"; + } + if(operator_type == SE_BINARY_OP){ + return "(" + lhs.scalarp->to_string() + " " + op + " " + rhs.scalarp->to_string() + ")"; + } + return(""); + }; + + scalarexp_t *get_left_se(){return lhs.scalarp; }; + scalarexp_t *get_right_se(){return rhs.scalarp; }; + int get_operator_type(){return operator_type; }; + std::string & get_op(){return op; }; + std::string & get_param_name(){return op; }; +// std::string & get_iface_param_name(){return op; }; + colref_t *get_colref(){return lhs.colref; }; + ifpref_t *get_ifpref(){return lhs.ifp; }; + literal_t *get_literal(){return lhs.litp; }; + + int get_lineno(){return lineno; }; + int get_charno(){return charno; }; + + void set_data_type(data_type *d){dt=d; }; + data_type *get_data_type(){return dt; }; + void reset_temporal(){if(dt!=NULL) dt->reset_temporal();} + + void set_gb_ref(int g){gb_ref = g; }; + int get_gb_ref(){return (gb_ref); }; + bool is_gb(){return(gb_ref >= 0); }; + + void set_aggr_id(int a){aggr_id = a;}; + int get_aggr_ref(){return(aggr_id); }; + + void set_storage_state(std::string s){storage_state = s;}; + std::string get_storage_state(){return storage_state;}; + + std::vector get_operands(){return param_list;}; + void set_fcn_id(int f){fcn_id = f; }; + int get_fcn_id(){return fcn_id; }; + + void set_partial_ref(int p){partial_ref = p; }; + int get_partial_ref(){return partial_ref; }; + bool is_partial(){return partial_ref >= 0; }; + + void set_fcncache_ref(int p){fcn_cache_ref = p; }; + int get_fcncache_ref(){return fcn_cache_ref; }; + bool is_fcncached(){return fcn_cache_ref >= 0; }; + + void set_handle_ref(int tf){handle_ref = tf; }; + int get_handle_ref(){return handle_ref; }; + bool is_handle_ref(){return handle_ref>=0; }; + + void set_superaggr(bool b){is_superagg=b;}; + bool is_superaggr(){return is_superagg;}; + + void use_decorations_of(scalarexp_t *se){ + if(se->get_data_type() != NULL) + dt = se->get_data_type()->duplicate(); + gb_ref = se->gb_ref; + aggr_id = se->aggr_id; + fcn_id = se->fcn_id; + partial_ref = se->partial_ref; + handle_ref = se->handle_ref; + lineno = se->lineno; + charno = se->charno; + is_superagg = se->is_superagg; + }; +}; + + +/* + A (null terminated) list of scalar expressions. + Used for + selection, scalar_exp_commalist +*/ + +class se_list_t{ +public: + std::vector se_list; + int lineno, charno; + + se_list_t(scalarexp_t *s){se_list.push_back(s); + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + + se_list_t *append(scalarexp_t *s){ + se_list.push_back(s); + return(this); + }; + + std::string to_string(){ + int i; + std::string retval; + for(i=0;i0) retval.append(", "); + retval.append(se_list[i]->to_string()); + } + return(retval); + }; + + std::vector get_se_list(){return se_list; }; + + +}; + +/* + select_commalist : collect some additional info about + the selected things -- mostly the name. +*/ + +struct select_element{ + scalarexp_t *se; + std::string name; + + select_element(){se=NULL; name="";}; + select_element(scalarexp_t *s){se=s; name="";}; + select_element(scalarexp_t *s, std::string n){se=s; name=n;}; +}; + +class select_list_t{ +public: + std::vector select_list; + int lineno, charno; + + select_list_t(){lineno = -1; charno = -1;}; + select_list_t(scalarexp_t *s){select_list.push_back(new select_element(s)); + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + select_list_t(scalarexp_t *s, std::string n){ + select_list.push_back(new select_element(s,n)); + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + select_list_t *append(scalarexp_t *s){ + select_list.push_back(new select_element(s)); + return(this); + }; + select_list_t *append(scalarexp_t *s, std::string n){ + select_list.push_back(new select_element(s,n)); + return(this); + }; + + std::string to_string(){ + int i; + std::string retval; + for(i=0;i0) retval.append(", "); + retval.append(select_list[i]->se->to_string()); + if(select_list[i]->name != "") + retval += " AS " + select_list[i]->name; + + } + return(retval); + }; + + std::vector get_select_list(){return select_list; }; + std::vector get_select_se_list(){ + std::vector ret; + int i; + for(i=0; ise); + return ret; + }; +}; + + + +#define GB_COLREF 1 +#define GB_COMPUTED 2 + +class gb_t{ +public: + std::string name; + std::string table; + std::string interface; + scalarexp_t *def; + int type; + int lineno, charno; + + gb_t(const char *field_name){ + interface=""; + name = field_name; table=""; def=NULL; type=GB_COLREF; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + gb_t(const char *table_name, const char *field_name){ + interface=""; + name = field_name; table=""; def=NULL; type=GB_COLREF; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + gb_t(const char *iface, const char *table_name, const char *field_name){ + interface=iface; + name = field_name; table=""; def=NULL; type=GB_COLREF; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + gb_t( scalarexp_t *s, const char *gname){ + name = gname; table = ""; def = s; type = GB_COMPUTED; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + std::string to_string(){ + std::string retval; + if(type == GB_COLREF){ + if(table != ""){ + retval = table; + retval.append("."); + } + retval.append(name); + } + if(type == GB_COMPUTED){ + retval = "(scalarexp) AS "; + retval.append(name); + } + return(retval); + }; + + gb_t *duplicate(); + +}; + +/* + A (null terminated) list of group by attributes +*/ + +class gb_list_t{ +public: + std::vector gb_list; + int lineno, charno; + + gb_list_t(gb_t *g){gb_list.push_back(g); + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + + gb_list_t *append(gb_t *s){ + gb_list.push_back(s); + return(this); + }; + gb_list_t(int l, int c) : lineno(l), charno(c){ } + + std::string to_string(){ + int i; + std::string retval; + for(i=0;i0) retval.append(", "); + retval.append(gb_list[i]->to_string()); + } + return(retval); + }; + + std::vector get_gb_list(){return gb_list; }; + + gb_list_t *duplicate(){ + gb_list_t *ret = new gb_list_t(lineno, charno); + int i; + for(i=0;iappend(gb_list[i]->duplicate()); + } + + return ret; + } + + +}; + +class list_of_gb_list_t{ +public: + std::vector gb_lists; + + list_of_gb_list_t(gb_list_t *gl){ + gb_lists.push_back(gl); + } + + list_of_gb_list_t *append(gb_list_t *gl){ + gb_lists.push_back(gl); + return this; + } +}; + + +enum extended_gb_type {no_egb_type, gb_egb_type, rollup_egb_type, + cube_egb_type, gsets_egb_type}; +class extended_gb_t{ +public: + + extended_gb_type type; + gb_t *gb; + std::vector gb_lists; + + extended_gb_t(){ + gb = NULL; + type = no_egb_type; + } + + ~extended_gb_t(){ + } + + static extended_gb_t *create_from_gb(gb_t *g){ + extended_gb_t *ret = new extended_gb_t(); + ret->type = gb_egb_type; + ret->gb = g; + return ret; + } + + static extended_gb_t *extended_create_from_rollup(gb_list_t *gl){ + extended_gb_t *ret = new extended_gb_t(); + ret->type = rollup_egb_type; + ret->gb_lists.push_back(gl); + return ret; + } + + static extended_gb_t *extended_create_from_cube(gb_list_t *gl){ + extended_gb_t *ret = new extended_gb_t(); + ret->type = cube_egb_type; + ret->gb_lists.push_back(gl); + return ret; + } + + static extended_gb_t *extended_create_from_gsets(list_of_gb_list_t *lgl){ + extended_gb_t *ret = new extended_gb_t(); + ret->type = gsets_egb_type; + ret->gb_lists = lgl->gb_lists; + return ret; + } + + extended_gb_t *duplicate(){ + extended_gb_t *ret = new extended_gb_t(); + ret->type = type; + if(gb != NULL) + ret->gb = gb->duplicate(); + int i; + for(i=0;igb_lists.push_back(gb_lists[i]->duplicate()); + } + return ret; + } + + + std::string to_string(){ + std::string ret; + int i; + + switch(type){ + case no_egb_type: + return "Error, undefined extended gb type."; + case gb_egb_type: + return gb->to_string(); + case rollup_egb_type: + return "ROLLUP("+gb_lists[0]->to_string()+")"; + case cube_egb_type: + return "CUBE("+gb_lists[0]->to_string()+")"; + case gsets_egb_type: + ret = "GROUPING_SETS("; + for(i=0;i0) ret+=", "; + ret += "(" +gb_lists[i]->to_string()+")"; + } + ret += ")"; + return ret; + default: + break; + } + return "Error, unknown extended gb type."; + } + +}; + +class extended_gb_list_t{ +public: + std::vector gb_list; + int lineno, charno; + + extended_gb_list_t(extended_gb_t *g){gb_list.push_back(g); + lineno = flex_fta_lineno; charno = flex_fta_ch;}; + + extended_gb_list_t *append(extended_gb_t *s){ + gb_list.push_back(s); + return(this); + }; + + std::string to_string(){ + int i; + std::string retval; + for(i=0;i0) retval.append(", "); + retval.append(gb_list[i]->to_string()); + } + return(retval); + }; + + std::vector get_gb_list(){return gb_list; }; +}; + + + +/* + A predicate tree. Structure is similar to + a scalar expression tree but the type is always boolean. + Used by + opt_where_clause, where_clause, opt_having_clause, + search_condition, predicate, comparison_predicate, repl_predicate +*/ + +#define PRED_COMPARE 1 +#define PRED_UNARY_OP 2 +#define PRED_BINARY_OP 3 +#define PRED_FUNC 4 +#define PRED_IN 5 + +class predicate_t{ +public: + int operator_type; + std::string op; + union { + predicate_t *predp; + scalarexp_t *sexp; + }lhs; + union { + predicate_t *predp; + scalarexp_t *sexp; + literal_list_t *ll; + }rhs; + std::vector param_list; /// pred fcn params + int fcn_id; /// external pred fcn id + int combinable_ref; + bool is_sampling_fcn; + int lineno, charno; + + predicate_t(scalarexp_t *s, literal_list_t *litl){ + operator_type = PRED_IN; + op = "in"; + lhs.sexp = s; + rhs.ll = litl; + fcn_id = -1; + combinable_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + predicate_t(scalarexp_t *s, std::vector litv){ + operator_type = PRED_IN; + op = "in"; + lhs.sexp = s; + rhs.ll = new literal_list_t(litv); + fcn_id = -1; + combinable_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + + predicate_t(scalarexp_t *l_op, const char *o, scalarexp_t *r_op){ + operator_type = PRED_COMPARE; + op = o; + lhs.sexp = l_op; + rhs.sexp = r_op; + fcn_id = -1; + combinable_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + predicate_t(const char *o, predicate_t *p){ + operator_type = PRED_UNARY_OP; + op = o; + lhs.predp = p; + fcn_id = -1; + combinable_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + predicate_t(const char *o, predicate_t *l_p, predicate_t *r_p){ + operator_type = PRED_BINARY_OP; + op = o; + lhs.predp = l_p; + rhs.predp = r_p; + fcn_id = -1; + combinable_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + predicate_t(const char *o, std::vector op_list){ + operator_type = PRED_FUNC; + op = o; + param_list = op_list; + fcn_id = -1; + combinable_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + predicate_t(const char *o){ + op = o; + fcn_id = -1; + combinable_ref = -1; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + + static predicate_t *make_paramless_fcn_predicate(const char *o){ + predicate_t *ret = new predicate_t(o); + ret->operator_type = PRED_FUNC; + ret->fcn_id = -1; + ret->combinable_ref = -1; + return(ret); + }; + + std::string to_string(){ + if(operator_type == PRED_IN){ + return( lhs.sexp->to_string() + " " + op + " [ " + rhs.ll->to_string() +" ]"); + } + if(operator_type == PRED_COMPARE){ + return( lhs.sexp->to_string() + " " + op + " " + rhs.sexp->to_string() ); + } + if(operator_type == PRED_UNARY_OP){ + return( op + " (" + lhs.predp->to_string() + ")" ); + } + if(operator_type == PRED_BINARY_OP){ + return( "(" + lhs.predp->to_string() + " " + op + " " + rhs.predp->to_string() + ")" ); + } + if(operator_type == PRED_FUNC){ + std::string ret = op + "[ "; + int i; + for(i=0;i0) ret += ", "; + ret += param_list[i]->to_string(); + } + ret += "] "; + return(ret); + } + return(""); + }; + + std::vector get_op_list(){return param_list; }; + int get_operator_type(){return operator_type; }; + std::string get_op(){return op; }; + int get_lineno(){return lineno; }; + int get_charno(){return charno; }; + int get_combinable_ref(){return combinable_ref;} + void set_combinable_ref(int f){combinable_ref = f;}; + predicate_t *get_left_pr(){return(lhs.predp); }; + predicate_t *get_right_pr(){return(rhs.predp); }; + scalarexp_t *get_left_se(){return(lhs.sexp); }; + scalarexp_t *get_right_se(){return(rhs.sexp); }; + std::vector get_lit_vec(){return(rhs.ll->get_literal_vector()); }; + + void swap_scalar_operands(){ + if(operator_type != PRED_COMPARE){ + fprintf(stderr,"INTERNAL ERROR: swap_scalar_operands called on predicate of type %d\n",operator_type); + exit(1); + } + scalarexp_t *tmp; + tmp = lhs.sexp; lhs.sexp = rhs.sexp; rhs.sexp = tmp; + if(op == ">"){op = "<"; return;} + if(op == ">="){op = "<="; return;} + if(op == "<"){op = ">"; return;} + if(op == "<="){op = ">="; return;} + }; + void set_fcn_id(int i){fcn_id = i;}; + int get_fcn_id(){return fcn_id;}; + + +}; + + +/* + A structure that holds the components of a query. + This is the root type. + Used by manipulative_statement, select_statement, table_exp +*/ + +#define SELECT_QUERY 1 +#define MERGE_QUERY 2 + +class table_exp_t{ +public: + int query_type; // roughly, the type of the query. + ss_map nmap; // DEFINE block + std::vector query_params; // PARAM block (uninterpreted) + select_list_t *sl; // SELECT + tablevar_list_t *fm; // FROM + predicate_t *wh; // WHERE + predicate_t *hv; // HAVING + predicate_t *cleaning_when; // CLEANING WHEN + predicate_t *cleaning_by; // CLEANING BY + predicate_t *closing_when; // CLOSING WHEN + std::vector gb; // GROUP BY + std::vector mergevars; // merge colrefs. + std::vector supergb; // supergroup. + scalarexp_t *slack; // merge slack + bool exernal_visible; // true iff. it can be subscribed to. + int lineno, charno; + + + table_exp_t(tablevar_list_t *f, predicate_t *p, extended_gb_list_t *g, colref_list_t *sg, predicate_t *h, predicate_t *cw, predicate_t *cb, predicate_t *closew) + {fm = f; wh = p; hv = h; + cleaning_when = cw; cleaning_by = cb; + closing_when = closew; + if(g != NULL) + gb = g->gb_list; + if(sg != NULL) + supergb = sg->get_clist(); + slack = NULL; + query_type = SELECT_QUERY; + exernal_visible = true; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + table_exp_t(colref_list_t *mv, tablevar_list_t *f) + {fm = f; mergevars=mv->get_clist(); + slack = NULL; + query_type = MERGE_QUERY; + exernal_visible = true; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + + table_exp_t(colref_list_t *mv, scalarexp_t *sl, tablevar_list_t *f) + {fm = f; mergevars=mv->get_clist(); + slack = sl; + query_type = MERGE_QUERY; + exernal_visible = true; + lineno = flex_fta_lineno; charno = flex_fta_ch; + }; + +// Figure out the temporal merge field at analyze_fta time. + static table_exp_t *make_deferred_merge(std::vector src_tbls){ + table_exp_t *ret = new table_exp_t(); + ret->query_type = MERGE_QUERY; + ret->fm = new tablevar_list_t(); + int t; + for(t=0;tfm->append_table(new tablevar_t(src_tbls[t].c_str())); + } + ret->lineno = 0; ret->charno = 0; + return ret; + } + + table_exp_t(){ + fm = NULL; sl = NULL; wh=NULL; hv=NULL; + slack = NULL; + cleaning_when=NULL; cleaning_by = NULL; + closing_when = NULL; + exernal_visible = true; + }; + + table_exp_t *add_selection(select_list_t *s){ + sl = s; + return(this); + }; + + void add_nmap(var_defs_t *vd){ + int n; + if(vd != NULL){ + for(n=0;nsize();++n){ + nmap[vd->get_name(n)] = vd->get_def(n); +//printf("Adding (%s, %s) to name map.\n",vd->get_name(n).c_str(), vd->get_def(n).c_str()); + } + } + }; + + void add_param_list(var_defs_t *vd){ + int n; + if(vd != NULL){ + query_params = vd->get_nvec(); + } + }; + + + std::string to_string(){ + std::string retval; + if(sl != NULL){ + retval.append("Select " + sl->to_string() + "\n"); + } + if(fm != NULL){ + retval.append("From " + fm->to_string() + "\n"); + } + if(wh != NULL){ + retval.append("Where "+ wh->to_string() + "\n"); + } + if(hv != NULL){ + retval.append("Having "+hv->to_string() + "\n"); + } + return(retval); + }; + + tablevar_list_t *get_from(){return fm; }; + select_list_t *get_select(){return sl; }; + std::vector get_sl_vec(){return sl->get_select_list(); }; + predicate_t *get_where(){return wh; }; + predicate_t *get_having(){return hv; }; + predicate_t *get_cleaning_by(){return cleaning_by; }; + predicate_t *get_cleaning_when(){return cleaning_when; }; + predicate_t *get_closing_when(){return closing_when; }; + std::vector get_groupby(){return(gb); }; + std::vector get_supergb(){return supergb;}; + + ss_map get_name_map(){return nmap;}; + + bool name_exists(std::string nm){ + return(nmap.count(nm) > 0); + }; + + std::string get_val_of_name(std::string nm){ + if(nmap.count(nm) == 0) return(""); + else return nmap[nm]; + }; + + void set_val_of_name(const std::string n, const std::string v){ + nmap[n]=v; + } + + void set_visible(bool v){exernal_visible=v;}; + bool get_visible(){return exernal_visible;}; +}; + +struct query_list_t{ + std::vector qlist; + + query_list_t(table_exp_t *t){ + qlist.push_back(t); + }; + query_list_t *append(table_exp_t *t){ + qlist.push_back(t); + return(this); + }; +}; + + +#define TABLE_PARSE 1 +#define QUERY_PARSE 2 +#define STREAM_PARSE 3 + +struct fta_parse_t{ + query_list_t *parse_tree_list; + table_exp_t *fta_parse_tree; + table_list *tables; + int parse_type; +}; + + + + + + extern table_exp_t *fta_parse_tree; + + + + + +#endif + diff --git a/src/ftacmp/parse_partn.cc b/src/ftacmp/parse_partn.cc new file mode 100644 index 0000000..c0235e5 --- /dev/null +++ b/src/ftacmp/parse_partn.cc @@ -0,0 +1,546 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include"parse_partn.h" +#include "parse_schema.h" +#include"analyze_fta.h" + + +using namespace std; + + +int find_field(scalarexp_t *se, string &fld){ + vector operands; + int o,ret=0; + + switch(se->get_operator_type()){ + case SE_LITERAL: + return 0; + case SE_PARAM: + case SE_IFACE_PARAM: + return 100; // force failure, but no error message. + case SE_UNARY_OP: + return find_field(se->get_left_se(), fld); + case SE_BINARY_OP: + return find_field(se->get_left_se(), fld)+find_field(se->get_right_se(), fld); + case SE_COLREF: + fld = se->get_colref()->get_field(); + return 1; + case SE_AGGR_STAR: + case SE_AGGR_SE: +// Should be no aggregates + return 0; + case SE_FUNC: + return 100; // force failure, but no error message. + default: + fprintf(stderr,"INTERNAL ERROR in find_field, unknown operator type %d\n", se->get_operator_type()); + return(-100); + } + return(-100); +} + + +int partn_def_t::verify(table_list *schema, string &err_msg){ + if(schema->find_tbl(protocol) < 0){ + err_msg += "ERROR, partition definition "+name+" uses source "+protocol+", but its not in the schema.\n"; + return 1; + } + if(schema->get_schema_type(schema->find_tbl(protocol)) != PROTOCOL_SCHEMA){ + err_msg += "ERROR, partition definition "+name+" uses source "+protocol+", but its not a PROTOCOL.\n"; + return 1; + } + + tablevar_t *fme = new tablevar_t(protocol.c_str()); + tablevar_list_t fm(fme); + +// Validate the SE and assign data types. + int i; + int retval = 0; + for(i=0;iget_data_type(); + string type_s = dt->get_type_str(); + if(! ( type_s=="UINT" || type_s=="INT" || type_s=="ULLONG" || type_s=="LLONG") ){ + err_msg += "ERROR, entry "+int_to_string(i)+" of partition definition "+name+" has type "+type_s+", but it must be one of UINT, INT, ULLONG, LLONG.\n"; + retval=1; + } + } + if(retval) + return 1; + +// Ensure that each SE ref's a field only once. + for(i=0;i &se_stack){ + vector operands; + int o,ret=0; + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_IFACE_PARAM: + return ; + case SE_UNARY_OP: + find_colref_path(se->get_left_se(), se_stack); + if(se_stack.size()>0) + se_stack.push_back(se); + return; + case SE_BINARY_OP: + find_colref_path(se->get_left_se(), se_stack); + if(se_stack.size()>0){ + se_stack.push_back(se); + return; + } + find_colref_path(se->get_right_se(), se_stack); + if(se_stack.size()>0) + se_stack.push_back(se); + return; + case SE_COLREF: + se_stack.push_back(se); + return; + case SE_AGGR_STAR: + case SE_AGGR_SE: +// Should be no aggregates + return; + case SE_FUNC: + operands = se->get_operands(); + for(o=0;o0){ + se_stack.push_back(se); + return; + } + } + return; + default: + fprintf(stderr,"INTERNAL ERROR in find_colref_path, unknown operator type %d\n", se->get_operator_type()); + return; + } + return; +} + +struct param_int{ + union{ + long int li; + unsigned long int uli; + long long int lli; + unsigned long long int ulli; + } v; + dtype d; + + void convert_to_final() {}; + + void load_val(dtype dt, const char *val){ + d=dt; + switch(dt){ + case u_int_t: + sscanf(val,"%llu",&(v.ulli)); + break; + case int_t: + sscanf(val,"%lld",&(v.lli)); + break; + case u_llong_t: + sscanf(val,"%llu",&(v.ulli)); + break; + case llong_t: + sscanf(val,"%lld",&(v.lli)); + break; + default: + fprintf(stderr,"INTERNAL ERROR, data type %d passed to param_int::load_val.\n",dt); + exit(1); + } + } + + void add(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli+r.v.lli; else v.lli = l.v.lli+r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli+r.v.lli; else v.lli = l.v.ulli+r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli+r.v.lli; else v.ulli = l.v.lli+r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli+r.v.lli; else v.ulli = l.v.ulli+r.v.ulli; + } + void subtract(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli-r.v.lli; else v.lli = l.v.lli-r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli-r.v.lli; else v.lli = l.v.ulli-r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli-r.v.lli; else v.ulli = l.v.lli-r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli-r.v.lli; else v.ulli = l.v.ulli-r.v.ulli; + } + void mult(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli*r.v.lli; else v.lli = l.v.lli*r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli*r.v.lli; else v.lli = l.v.ulli*r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli*r.v.lli; else v.ulli = l.v.lli*r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli*r.v.lli; else v.ulli = l.v.ulli*r.v.ulli; + } + void div(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli/r.v.lli; else v.lli = l.v.lli/r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli/r.v.lli; else v.lli = l.v.ulli/r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli/r.v.lli; else v.ulli = l.v.lli/r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli/r.v.lli; else v.ulli = l.v.ulli/r.v.ulli; + } + void bit_and(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli&r.v.lli; else v.lli = l.v.lli&r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli&r.v.lli; else v.lli = l.v.ulli&r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli&r.v.lli; else v.ulli = l.v.lli&r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli&r.v.lli; else v.ulli = l.v.ulli&r.v.ulli; + } + void bit_or(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli|r.v.lli; else v.lli = l.v.lli|r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli|r.v.lli; else v.lli = l.v.ulli|r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli|r.v.lli; else v.ulli = l.v.lli|r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli|r.v.lli; else v.ulli = l.v.ulli|r.v.ulli; + } + void modulo(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli%r.v.lli; else v.lli = l.v.lli%r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli%r.v.lli; else v.lli = l.v.ulli%r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli%r.v.lli; else v.ulli = l.v.lli%r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli%r.v.lli; else v.ulli = l.v.ulli%r.v.ulli; + } + void shift_left(dtype dt, param_int &l, param_int &r){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.lli = l.v.lli<>r.v.lli; else v.lli = l.v.lli>>r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.lli = l.v.ulli>>r.v.lli; else v.lli = l.v.ulli>>r.v.ulli; + else + if(l.d==int_t || l.d==llong_t) + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.lli>>r.v.lli; else v.ulli = l.v.lli>>r.v.ulli; + else + if(r.d==int_t || r.d==llong_t) v.ulli = l.v.ulli>>r.v.lli; else v.ulli = l.v.ulli>>r.v.ulli; + } + + void plus(dtype dt, param_int &l){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + v.lli = l.v.ulli; + else + v.lli = l.v.lli; + else + if(l.d==int_t || l.d==llong_t) + v.ulli = l.v.ulli; + else + v.ulli = l.v.lli; + } + void minus(dtype dt, param_int &l){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + v.lli = -l.v.ulli; + else + v.lli = -l.v.lli; + else + if(l.d==int_t || l.d==llong_t) + v.ulli = -l.v.ulli; + else + v.ulli = -l.v.lli; + } + void abs_not(dtype dt, param_int &l){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + v.lli = !l.v.ulli; + else + v.lli = !l.v.lli; + else + if(l.d==int_t || l.d==llong_t) + v.ulli = !l.v.ulli; + else + v.ulli = !l.v.lli; + } + void bit_not(dtype dt, param_int &l){ + d=dt; + if(dt==int_t || dt==llong_t) + if(l.d==int_t || l.d==llong_t) + v.lli = ~l.v.ulli; + else + v.lli = ~l.v.lli; + else + if(l.d==int_t || l.d==llong_t) + v.ulli = ~l.v.ulli; + else + v.ulli = ~l.v.lli; + } +}; + + +bool int_operand_divides(param_int &lp, param_int &rp){ + if( (lp.d==int_t || lp.d==llong_t)){ + if(lp.v.lli < 0) + lp.v.ulli = -lp.v.lli; + else + lp.v.ulli = lp.v.lli; + } + if( (rp.d==int_t || rp.d==llong_t)){ + if(rp.v.lli < 0) + rp.v.ulli = -rp.v.lli; + else + rp.v.ulli = rp.v.lli; + } + unsigned long long int d = rp.v.ulli / lp.v.ulli; + unsigned long long int r = rp.v.ulli - d * lp.v.ulli; + return d==0; +} + +bool int_operand_implies(param_int &lp, param_int &rp){ + unsigned long long int d = (lp.v.ulli & rp.v.ulli) | (!lp.v.ulli); + return (~d)==0; +} + + + + +void extract_param_int(scalarexp_t *se, param_int &p_int) { +param_int lp, rp; +string op_str; +dtype dt = se->get_data_type()->get_type(); + switch(se->get_operator_type()){ + case SE_LITERAL: + p_int.load_val(se->get_data_type()->get_type(),se->to_string().c_str()); + return; + case SE_UNARY_OP: + extract_param_int(se->get_left_se(), lp); + op_str = se->get_op(); + if(op_str=="+") p_int.plus(dt,lp); + if(op_str=="-") p_int.minus(dt,lp); + if(op_str=="!") p_int.abs_not(dt,lp); + if(op_str=="~") p_int.bit_not(dt,lp); + return; + case SE_BINARY_OP: + extract_param_int(se->get_left_se(), lp); + extract_param_int(se->get_right_se(), rp); + op_str = se->get_op(); + if(op_str=="+") p_int.add(dt,lp,rp); + if(op_str=="-") p_int.subtract(dt,lp,rp); + if(op_str=="*") p_int.mult(dt,lp,rp); + if(op_str=="/") p_int.div(dt,lp,rp); + if(op_str=="&") p_int.bit_and(dt,lp,rp); + if(op_str=="|") p_int.bit_or(dt,lp,rp); + if(op_str=="%") p_int.modulo(dt,lp,rp); + if(op_str=="<<") p_int.shift_left(dt,lp,rp); + if(op_str==">>") p_int.shift_right(dt,lp,rp); + return; + default: + fprintf(stderr,"INTERNAL ERROR in find_field, invalid operator type %d\n", se->get_operator_type()); + exit(1); + } + return; + +} + + +void get_int_operand(scalarexp_t *parent, scalarexp_t *child, param_int &p_int){ + if(parent->get_operator_type() != SE_BINARY_OP){ + fprintf(stderr,"INTERNAL ERROR, operator type %d in get_int_operand.\n", +parent->get_operator_type()); + exit(1); + } + if(parent->get_right_se() == child){ + extract_param_int(parent->get_left_se(), p_int); + p_int.convert_to_final(); + }else{ + extract_param_int(parent->get_right_se(), p_int); + p_int.convert_to_final(); + } +} + + +bool partition_compatible(scalarexp_t *pse, scalarexp_t *gse){ + vector pstack, gstack; + + find_colref_path(pse, pstack); + find_colref_path(gse, gstack); + + int ppos=0, gpos=0; + string p_op, g_op; + param_int p_int, g_int; + + while(pposget_op(); + g_op = gstack[gpos+1]->get_op(); + if(p_op==g_op){ + if(p_op=="/"){ + get_int_operand(pstack[ppos+1],pstack[ppos],p_int); + get_int_operand(gstack[gpos+1],gstack[gpos],g_int); + if(int_operand_divides(g_int, p_int)){ + ppos++; + gpos++; + continue; + }else{ + return false; + } + } + if(p_op=="&"){ + get_int_operand(pstack[ppos+1],pstack[ppos],p_int); + get_int_operand(gstack[gpos+1],gstack[gpos],g_int); + if(int_operand_implies(p_int, g_int)){ + ppos++; + gpos++; + continue; + }else{ + return false; + } + } + if(p_op=="|"){ + get_int_operand(pstack[ppos+1],pstack[ppos],p_int); + get_int_operand(gstack[gpos+1],gstack[gpos],g_int); + if(int_operand_implies(g_int, p_int)){ + ppos++; + gpos++; + continue; + }else{ + return false; + } + } + } + } + if(pposget_op(); + if(p_op=="+" || p_op=="-" || p_op=="*" || p_op=="/" || p_op=="&" || p_op=="|"){ + ppos++; + continue; + } + } + if(gposget_op(); + if(g_op=="+" || g_op=="-" || g_op=="*" || g_op=="/" || g_op=="&" || g_op=="|"){ + gpos++; + continue; + } + } + + return false; // no reduction rule applies + } + + return true; // reduced both stacks. +} + + +bool partn_def_t::is_compatible(gb_table *gb_tbl){ + vector gb_flds; + int i,p,g; + + for(i=0;isize();++i){ + string gfld; + if(find_field(gb_tbl->get_def(i),gfld)==1){ + gb_flds.push_back(gfld); + }else{ + gb_flds.push_back(""); + } + } + + for(p=p;psize();++g){ + if(partition_compatible(se_list[p], gb_tbl->get_def(g))) + break; + } + if(g==gb_tbl->size()){ + return false; + } + } + return true; +} diff --git a/src/ftacmp/parse_partn.h b/src/ftacmp/parse_partn.h new file mode 100644 index 0000000..36e92d6 --- /dev/null +++ b/src/ftacmp/parse_partn.h @@ -0,0 +1,78 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef _PARTN_PARSE_H_INCLUDED__ +#define _PARTN_PARSE_H_INCLUDED__ + +#include +#include"parse_fta.h" +#include"analyze_fta.h" + +/* Interface to FTA Parser */ +void PartnParser_setfileinput(FILE *f); +void PartnParser_setstringinput(char *s); + +class partn_def_t{ +public: + std::string name; + std::string protocol; + std::vector se_list; + std::vector field_list; + + partn_def_t(const char *n, const char *p, se_list_t *sl){ + name=n; + protocol=p; + se_list = sl->se_list; + } + + int verify(table_list *schema, std::string &err_msg); + bool is_compatible(gb_table *gb_tbl); +}; + +class partn_def_list_t{ +public: + std::map partn_map; + + partn_def_list_t(partn_def_t *pd){ + partn_map[pd->name] = pd; + } + partn_def_list_t *append(partn_def_t *pd){ + if(partn_map.count(pd->name)){ + fprintf(stderr,"Warning, duplicate entry named %s in partition definitions, ignored.\n",pd->name.c_str()); + }else{ + partn_map[pd->name] = pd; + } + return this; + } + + partn_def_t *get_partn_def(std::string n){ + if(partn_map.count(n)) + return partn_map[n]; + return NULL; + } + + int verify(table_list *schema, std::string &err_msg){ + int retval=0; + std::map::iterator mspi; + for(mspi=partn_map.begin(); mspi!=partn_map.end();++mspi){ + if((*mspi).second->verify(schema, err_msg)) + retval=1; + } + return retval; + } + + +}; + +#endif diff --git a/src/ftacmp/parse_schema.cc b/src/ftacmp/parse_schema.cc new file mode 100644 index 0000000..a9bc60c --- /dev/null +++ b/src/ftacmp/parse_schema.cc @@ -0,0 +1,524 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include +#include"parse_fta.h" +#include "parse_schema.h" +#include "type_objects.h" +#include +#include +// #include +#include + +using namespace std; + +table_list *Schema; + +table_def::table_def(const char *name, param_list *oprop, field_entry_list *fel, + subqueryspec_list *ql, param_list *selp){ + table_name =name; + fields = fel->get_list(); + schema_type = OPERATOR_VIEW_SCHEMA; + qspec_list = ql->spec_list; + + if(oprop == NULL) op_properties = new param_list(); + else op_properties = oprop; + if(selp == NULL) selpush = new param_list(); + else selpush = selp; + base_tables = new param_list(); +}; + +table_def *table_def::make_shallow_copy(string n){ + table_def *ret = new table_def(); + ret->table_name = n; + ret->fields = fields; + ret->schema_type = schema_type; + ret->base_tables = base_tables; + ret->op_properties = op_properties; + ret->qspec_list = qspec_list; + ret->selpush = selpush; + + return ret; +} + +void table_def::mangle_subq_names(std::string mngl){ + int i; + for(i=0;iduplicate(); + s->name += mngl; + qspec_list[i] = s; + } +} + + + +bool table_def::contains_field(string f){ + int i; + + for(i=0;iget_name() == f){ + return(true); + } + } + return(false); + +} + +int table_def::get_field_idx(std::string f){ + int i; + for(i=0;iget_name() == f){ + return(i); + } + } + return(-1); +} + + +string table_def::get_type_name(std::string f){ + int i; + for(i=0;iget_name() == f){ + return(fields[i]->get_type()); + } + } + return("INTERNAL ERROR undefined field " + f); +} + +param_list *table_def::get_modifier_list(std::string f){ + int i; + for(i=0;iget_name() == f){ + return(fields[i]->get_modifier_list()); + } + } + fprintf(stderr,"INTERNAL ERROR, no field %s in table %s, call is get_modifier_list.\n", + f.c_str(), table_name.c_str() ); + exit(1); + return(NULL); +} + + +string table_def::get_fcn(std::string f){ + int i; + for(i=0;iget_name() == f){ + return(fields[i]->get_fcn()); + } + } + return("INTERNAL ERROR undefined field " + f); + +} + + +string table_def::get_field_basetable(std::string f){ + int i; + for(i=0;iget_name() == f){ + return(fields[i]->get_basetable()); + } + } + return("INTERNAL ERROR undefined field " + f); + +} + +int table_def::verify_no_duplicates(std::string &err){ + + int f1, f2; + for(f1=0;f1get_name(); + for(f2=f1+1;f2get_name()){ + err.append("Error, table "); + err.append(table_name); + err.append(" has a duplicate field :"); + err.append(f1_name); + err.append("\n"); + return(1); + } + } + } + return(0); +} + +int table_def::verify_access_fcns(std::string &err){ + int retval = 0, f; + + for(f=0;fget_fcn() == ""){ + err += "Error, PROTOCOL field "+table_name+"."+fields[f]->get_name()+" has an empty access function.\n"; + retval = 1; + } + } + + return(retval); +} + +int table_def::add_field(field_entry *fe){ + string fe_name = fe->get_name(); + int f; + + for(f=0;fget_name()){ + return(-1); + } + } + fields.push_back(fe); + return(0); +} + + +vector table_list::get_table_names(){ + vector retval; + int i; + for(i=0;iget_tbl_name()); + } + return(retval); +} + + +int table_list::find_tbl(string t){ + int i; + for(i=0;iget_tbl_name() == t) + return(i); +// fprintf(stderr,"INTERNAL ERROR: Could not find table %s in table_list::find_tbl\n",t.c_str()); + return(-1); +} + +vector table_list::get_fields(string t){ + int pos = find_tbl(t); + if(pos<0){ + vector r; + return(r); + } + return(tbl_list[pos]->get_fields()); +} + +field_entry *table_list::get_field(string t, int i){ + int pos = find_tbl(t); + if(pos<0){ + return(NULL); + } + return(tbl_list[pos]->get_field(i)); +} + +int table_list::get_field_idx(string t, string f){ + int pos = find_tbl(t); + if(pos<0){ + return(-1); + } + return(tbl_list[pos]->get_field_idx(f)); +} + + +vector table_list::get_tblref_of_field(string f){ + int i; + vector retval; + + for(i=0;icontains_field(f) ){ + retval.push_back(i); + } + } + return(retval); +} + +// TODO: this seems to duplicate find_tbl +int table_list::get_table_ref(string t){ + int i; + for(i=0;iget_tbl_name() == t ){ + return(i); + } + } + return(-1); +} + + +// Use to unroll hierarchically defined +// tables. Used for source tables. +// Also, do some sanity checking, better +// to find the errors now when its easy to report +// than later when its obscure. +// +// Also, process the unpacking functions. +// and verify that all field unpacking functions +// are listed in the schema. +int table_list::unroll_tables(string &err){ +// First, verify there are no repeat field names in any +// of the tables. + + int f, tref, p, t, ret, retval; + + for(t=0;tget_schema_type() == UNPACK_FCNS_SCHEMA){ + for(f=0;fufcn_list.size();f++){ + ufcn_fcn[ tbl_list[t]->ufcn_list[f]->name ] = tbl_list[t]->ufcn_list[f]->fcn; + ufcn_cost[ tbl_list[t]->ufcn_list[f]->name ] = tbl_list[t]->ufcn_list[f]->cost; + + } + } + } + + for(t=0;tget_schema_type() != UNPACK_FCNS_SCHEMA){ +// No duplicate field names + ret = tbl_list[t]->verify_no_duplicates(err); + if(ret) retval = ret; + +// every field has an access function + if(tbl_list[t]->get_schema_type() == PROTOCOL_SCHEMA){ + retval = tbl_list[t]->verify_access_fcns(err); + if(ret) retval = ret; + } + +// Every type can be parsed + vector flds = tbl_list[t]->get_fields(); + for(f=0;fget_type()); + if(dt.get_type() == undefined_t){ + err += "ERROR, field "+flds[f]->get_name()+" of table "+tbl_list[t]->get_tbl_name()+" has unrecognized type "+flds[f]->get_type()+"\n"; + retval = 1; + } + if(dt.get_type() == fstring_t){ + err += "ERROR, field "+flds[f]->get_name()+" of table "+tbl_list[t]->get_tbl_name()+" has unsupported type "+flds[f]->get_type()+"\n"; + retval = 1; + } + } + +// Ensure that the unpack functions, if any, exist. + for(f=0;f ufcns = flds[f]->get_unpack_fcns(); + set::iterator ssi; + for(ssi=ufcns.begin();ssi!=ufcns.end();ssi++){ + if(ufcn_fcn.count((*ssi))==0){ + err += "ERROR, field "+flds[f]->get_name()+" of table "+tbl_list[t]->get_tbl_name()+" has unrecognized unpacking function "+(*ssi)+"\n"; + retval = 1; + } + } + } + +// annote the original source of the field -- for prefilter + string tbl_name = tbl_list[t]->get_tbl_name(); + vector fev = tbl_list[t]->get_fields(); + for(f=0;fset_basetable(tbl_name); + } + } + + if(retval) return(retval); + +// Next, build a predecessors graph. +// Verify that all referenced tables exist. + + vector< vector > predecessors; // list of tables inherited from. + vector n_pred; // number of (remaining) predecessors. + // -1 indicates a processed table. + + for(t=0;tget_schema_type() != UNPACK_FCNS_SCHEMA){ + vector pred_tbls = tbl_list[t]->get_pred_tbls(); + vector pred_ref; + for(p=0;pget_table_ref(pred_tbls[p]); + if(tref < 0){ + err.append("Error: table "); + err.append(tbl_list[t]->get_tbl_name()); + err.append(" referenced non-existent table "); + err.append(pred_tbls[p]); + err.append("\n"); + return(2); + }else{ + pred_ref.push_back(tref); + } + } + predecessors.push_back(pred_ref); + n_pred.push_back(pred_ref.size()); + }else{ + vector tmp_iv; + predecessors.push_back(tmp_iv); + n_pred.push_back(0); + } + } + + + int n_remaining = predecessors.size(); + int n_total = n_remaining; + +// Run through the DAG and pull off one root at a time (n_pred == 0). +// there might be a cycle, so iterate until n_remaining == 0. + + while(n_remaining > 0){ + +// Find a root + int root; + for(root=0;root < n_total;root++){ + if(n_pred[root] == 0) + break; + } + if(root == n_total){ // didn't find a root. + err.append("Error : cycle in inheritance among the following tables:"); + int r; + for(r=0;r 0){ + err.append(" "); + err.append(tbl_list[r]->get_tbl_name()); + } + } + return(3); + } + +// I'd adding fields from the root table to the + vector pred_fields = tbl_list[root]->get_fields(); + + +// Scan for all successors of the root. + int s, f; + for(s=0;sadd_field(pred_fields[f]); + if(retval < 0){ + err.append("Warning: field "); + err.append(pred_fields[f]->get_name()); + err.append(" already exists in table "); + err.append(tbl_list[s]->get_tbl_name()); + err.append(" (inheriting from table "); + err.append(tbl_list[root]->get_tbl_name()); + err.append(").\n"); + } + } + +// s has one less predecessor. + n_pred[s]--; + } + } + +// Indicate that the root has been processed. + n_pred[root] = -1; + n_remaining--; + } + + +// Done! + return(0); +} + +int table_list::add_table(table_def *td){ + int tref = get_table_ref(td->get_tbl_name()); + if(tref >= 0) return(tref); + tbl_list.push_back(td); + return(tbl_list.size() - 1); +} + + + +////////////////////////////////////////////////////// +////////// Serialize functions. +////////// The deserialize fcn is the parser. + + +string param_list::to_string(){ + string retval; + map::iterator mssi; + bool first_exec=true; + for(mssi=pmap.begin();mssi!=pmap.end();++mssi){ + if(first_exec){ first_exec=false; } + else{ retval+=","; } + retval += (*mssi).first + " "; + retval += (*mssi).second; + } + return(retval); +} + +string field_entry::to_string(){ + string retval = type + " " + name + " " + function; + if(mod_list->size() > 0){ + retval += " ( " + mod_list->to_string() + " ) "; + } + + return(retval); +} + + + + +string table_def::to_string(){ + int q; + string retval; + switch(schema_type){ + case PROTOCOL_SCHEMA: + retval = "TABLE "; + break; + case STREAM_SCHEMA: + retval = "STREAM "; + break; + case OPERATOR_VIEW_SCHEMA: + retval += "OPERATOR_VIEW "; + break; + default: + retval = "ERROR UNKNOWN TABLE TYPE "; + break; + } + + retval += table_name + " "; + + if(base_tables->size() > 0){ + retval += "( "+base_tables->to_string() + " ) "; + } + + retval += "{\n"; + + if(schema_type == OPERATOR_VIEW_SCHEMA){ + retval += "\tOPERATOR ("+op_properties->to_string()+")\n"; + retval += "\tFIELDS{\n"; + } + + int f; + for(f=0;fto_string() + ";\n"; + } + + if(schema_type == OPERATOR_VIEW_SCHEMA){ + retval += "\tSUBQUERIES{\n"; + for(q=0;q0) retval += ";\n"; + retval += qspec_list[q]->to_string(); + } + retval += "\t}\n"; + retval += "\tSELECTION_PUSHDOWN ("+selpush->to_string()+")\n"; + } + + + + retval += "}\n"; + + return(retval); +} + +string table_list::to_string(){ + string retval; + int t; + for(t=0;tto_string(); + retval += "\n"; + } + return(retval); +} diff --git a/src/ftacmp/parse_schema.h b/src/ftacmp/parse_schema.h new file mode 100644 index 0000000..3c009ba --- /dev/null +++ b/src/ftacmp/parse_schema.h @@ -0,0 +1,555 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __SCHEMA_DEF_H_INCLUDED__ +#define __SCHEMA_DEF_H_INCLUDED__ + +#include +#include +#include +#include + +#include +#include + + +// A param_list is used to represent a list of +// parameters with optional values. + +class param_list{ +private: + std::map< std::string, std::string > pmap; + +public: + param_list(){}; + param_list(const char *key){ + pmap[key]=""; + }; + param_list(const char *key, const char *val){ + pmap[key]=val; + }; + + param_list *append(const char *key){ + pmap[key]=""; + return(this); + }; + param_list *append(const char *key, const char *val){ + pmap[key]=val; + return(this); + }; + param_list *append( std::string key){ + pmap[key]=""; + return(this); + }; + + int size(){return pmap.size();}; + + + bool contains_key(std::string key){ + return(pmap.count(key)>0); + } + + int delete_key(std::string k){ + return pmap.erase(k); + } + + std::string val_of(std::string key){ + if(pmap.count(key)>0) + return(pmap[key]); + return(std::string("")); + } + + std::vector get_key_vec(){ + std::vector retval; + std::map::iterator mssi; + for(mssi=pmap.begin();mssi!=pmap.end();++mssi){ + retval.push_back( (*mssi).first ); + } + return(retval); + } + + std::string to_string(); +}; + + +// list of names, order matters. +class name_vec{ +public: + std::vector svec; + std::vector nvec; + std::vector pvec; + + name_vec(char *c, char *n, param_list *p){ + svec.push_back(c); + nvec.push_back(n); + if(p) pvec.push_back(p); + else pvec.push_back(new param_list()); + }; + + name_vec *append(char *c, char *n, param_list *p){ + svec.push_back(c); + nvec.push_back(n); + if(p) pvec.push_back(p); + else pvec.push_back(new param_list()); + return this; + }; +}; + + + +// A field in a STREAM or PROTOCOL + + +class field_entry{ +private: + std::string type; // data type + std::string name; // name in a query + std::string function; // access function, if any (PROTOCOL only). + param_list *mod_list; // special properties. + std::set ufcns; // unpacking functions, if any. + + std::string base_table; // for hierarchically structured data sources, + // the bast table where the field is defined. + // mostly used for computing the LFTA prefilter. +public: + + field_entry(const char *t, const char *n, const char *f, param_list *plist, param_list *ulist){ + if(plist == NULL) + mod_list = new param_list(); + else + mod_list = plist; + if(ulist){ + int u; + std::vector tmp_ufl = ulist->get_key_vec(); + for(u=0;u &ulist){ + if(plist == NULL) + mod_list = new param_list(); + else + mod_list = plist; + ufcns = ulist; + type=t; name=n; function=f; + base_table = ""; + }; + + field_entry(std::string n, std::string t){ + name = n; + type = t; + mod_list = new param_list(); + } + + void add_unpack_fcns(param_list *ufl){ + std::vector new_ufl = ufl->get_key_vec(); + int u; + for(u=0;u get_unpack_fcns(){ + return ufcns; + } + + void set_basetable(std::string b){base_table=b;}; + std::string get_basetable(){return base_table;}; + + std::string to_string(); + + int delete_modifier(std::string k){ + return mod_list->delete_key(k); + } + void add_modifier(const char *k, const char *v){ + mod_list->append(k,v); + } + void add_modifier(const char *k){ + mod_list->append(k); + } + +}; + + +// list of fields. An intermediate parse structure. +// it gets loaded into table_def.fields + +class field_entry_list{ +private: + std::vector fl; + +public: + field_entry_list(){}; + + field_entry_list(field_entry *f){ + fl.push_back(f); + }; + + field_entry_list *append_field(field_entry *f){ + fl.push_back(f); + return(this); + }; + + std::vector get_list(){return fl; }; +}; + +class subquery_spec{ +public: + std::string name; + std::vector types; + std::vector names; + std::vector modifiers; + + + subquery_spec(){} + + subquery_spec(const char *n, name_vec *t){ + name = n; + types = t->svec; + names = t->nvec; + modifiers = t->pvec; + }; + + std::string to_string(){ + std::string ret = name+" ("; + int i; + for(i=0;i0) ret+=", "; + ret += types[i] + " " + names[i]; + if(modifiers[i]->size() >0){ + ret+=" ("+modifiers[i]->to_string()+") "; + } + } + ret += ") "; + return(ret); + }; + + subquery_spec *duplicate(){ + subquery_spec *ret = new subquery_spec(); + ret->name = name; + ret->types = types; + ret->names = names; + + return ret; + } + + + +}; + +class subqueryspec_list{ +public: + std::vector spec_list; + + subqueryspec_list(subquery_spec *ss){ + spec_list.push_back(ss); + }; + subqueryspec_list *append(subquery_spec *ss){ + spec_list.push_back(ss); + return this; + }; +}; + +class unpack_fcn{ +public: + std::string name; + std::string fcn; + int cost; + + unpack_fcn(const char *n, const char *f, const char *c){ + name = n; + fcn = f; + cost = atoi(c); + }; +}; + +class unpack_fcn_list{ +public: + std::vector ufcn_v; + + unpack_fcn_list(unpack_fcn *u){ + ufcn_v.push_back(u); + }; + + unpack_fcn_list *append(unpack_fcn *u){ + ufcn_v.push_back(u); + return this; + }; +}; + + + + +// forward definition, needed for table_def +class table_exp_t; +struct query_list_t; + +/* ============================================ + The schema can support several different + flavors of table. + PROTOCOL : the base data that an FTA can retrieve. + STREAM : Data created by an FTA or a stream operator. + More to come. Perhaps this is better handled by + annotations in the schema def. + ============================================= */ + +#define PROTOCOL_SCHEMA 1 +#define STREAM_SCHEMA 2 +#define OPERATOR_VIEW_SCHEMA 3 +#define UNPACK_FCNS_SCHEMA 4 + +// Represent a STREAM, PROTOCOL, OPERATOR_VIEW, or UNPACK_FCN list. + +class table_def{ +private: + std::string table_name; + std::vector fields; + param_list *base_tables; // if PROTOCOL, the PROTOCOLS that + // this PROTOCOL inherits fields from. + int schema_type; // STREAM_SCHEMA, PROTOCOL_SCHEMA, OPERATOR_VIEW_SCHEMA +// For operator_view tables + param_list *op_properties; + std::vector qspec_list; + param_list *selpush; + +public: +// for unpacking function group specs. + std::vector ufcn_list; + + + +// Unpack functions defined at the PROTOCOL level are added to +// PROTOCOL fields here ... implying that ony those fields +// explicitly defined in the PROTOCOL (as opposed to inherited) +// get the PROTOCOL-wide unpack functions. + table_def(const char *name, param_list *plist, param_list *ufcn_l, field_entry_list *fel, int sch_t){ + int f; + if(plist == NULL) + base_tables = new param_list(); + else + base_tables = plist; + table_name =name; + fields = fel->get_list(); + schema_type = sch_t; + +// fields inherit table-level unpacking functions, if any. + if(ufcn_l){ + for(f=0;fadd_unpack_fcns(ufcn_l); + } + + op_properties = new param_list(); + selpush = new param_list(); + }; + + table_def(const char *name, param_list *oprop, field_entry_list *fel, + subqueryspec_list *ql, param_list *selp); + + table_def(unpack_fcn_list *ufcn_l){ + schema_type = UNPACK_FCNS_SCHEMA; + ufcn_list = ufcn_l->ufcn_v; + } + + table_def(){}; + + table_def *make_shallow_copy(std::string n); + + void mangle_subq_names(std::string mngl); + + std::string get_tbl_name(){return table_name; }; + std::vector get_fields(){return(fields); }; + + field_entry *get_field(int i){ + if(i>=0 && i=0 && iget_name()); + return ""; + }; + + bool contains_field(std::string f); + bool contains_field(int f); + + int get_field_idx(std::string f); + std::string get_type_name(std::string f); + param_list *get_modifier_list(std::string f); + std::string get_fcn(std::string f); + + std::string get_op_prop(std::string s){ + return op_properties->val_of(s); + }; + +// Used in generating the LFTA prefilter + std::string get_field_basetable(std::string f); + + + int verify_no_duplicates(std::string &err); + int verify_access_fcns(std::string &err); + + + std::vector get_pred_tbls(){ + return base_tables->get_key_vec() ; + }; + + int add_field(field_entry *fe); + + int get_schema_type(){return schema_type;}; + + std::vector get_subqueryspecs(){return qspec_list;}; + + std::string to_string(); + std::string to_stream_string(){ + int tmp_sch = schema_type; + schema_type = STREAM_SCHEMA; + std::string ret = this->to_string(); + schema_type = tmp_sch; + return ret; + } +}; + + +// A Schema -- a collection of stream layout definitions. + +class table_list{ +private: + std::vector tbl_list; + // for an unpack_fcn_list, collect from the set of + // UNPACK_FCNS_SCHEMA in the table list. + std::map ufcn_fcn; + std::map ufcn_cost; + + +public: + table_list(table_def *td){tbl_list.push_back(td); }; + table_list(){}; + + table_list *append_table(table_def *td){ + tbl_list.push_back(td); + return(this); + }; + + int add_table(table_def *td); + table_def *get_table(int t){ + if(t<0 || t>tbl_list.size()) return(NULL); + return(tbl_list[t]); + }; + + int add_duplicate_table(std::string src, std::string dest){ + int src_pos = this->find_tbl(src); + if(src_pos<0) + return src_pos; + table_def *dest_tbl = tbl_list[src_pos]->make_shallow_copy(dest); + tbl_list.push_back(dest_tbl); + return tbl_list.size()-1; + } + + void mangle_subq_names(int pos, std::string mngl){ + tbl_list[pos]->mangle_subq_names(mngl); + } + + + int size(){return tbl_list.size();}; + +///////////// +// Accessor methods : get table and field info without +// descending into the underlying data structures. +// Can specify a table by name (string), or by index (int) +// (e.g. returned by get_table_ref) + + int get_ufcn_cost(std::string fname){ + if(ufcn_cost.count(fname)) + return ufcn_cost[fname]; + else + return -1; + } + std::string get_ufcn_fcn(std::string fname){ + if(ufcn_fcn.count(fname)) + return ufcn_fcn[fname]; + else + return "ERROR_ufcn_fcn_of_"+fname+"_not_found"; + } + + std::string get_table_name(int i){ + if(i>tbl_list.size()) return(""); + else return tbl_list[i]->get_tbl_name(); + }; + std::vector get_table_names(); + + std::vector get_fields(std::string t); + field_entry *get_field(std::string t, int i); + field_entry *get_field(int t, std::string f){ + return tbl_list[t]->get_field(tbl_list[t]->get_field_idx(f)); + } + int get_field_idx(std::string t, std::string f); + + int find_tbl(std::string t); + + std::vector get_tblref_of_field(std::string f); + + int get_table_ref(std::string t); + + std::string get_type_name(int t, std::string f){ + return(tbl_list[t]->get_type_name(f)); + }; + + param_list *get_modifier_list(int t, std::string f){ + return(tbl_list[t]->get_modifier_list(f)); + }; + + std::string get_fcn(int t, std::string f){ + return(tbl_list[t]->get_fcn(f)); + }; + + int get_schema_type(int t){ + return(tbl_list[t]->get_schema_type()); + }; + + std::string get_op_prop(int t, std::string s){ + return(tbl_list[t]->get_op_prop(s)); + }; + + std::vector get_subqueryspecs(int t){ + return tbl_list[t]->get_subqueryspecs(); + }; + + +// Used in generating the LFTA prefilter + std::string get_basetbl_name(int t, std::string f){ + return(tbl_list[t]->get_field_basetable(f)); + }; + + bool contains_field(int t, std::string f){ + return(tbl_list[t]->contains_field(f)); + }; + + +////////////// +// Additional methods + +// Process field inheritance for PROTOCOL tables. + int unroll_tables(std::string &err); + + std::string to_string(); +}; +#endif diff --git a/src/ftacmp/partn.l b/src/ftacmp/partn.l new file mode 100644 index 0000000..ab8a883 --- /dev/null +++ b/src/ftacmp/partn.l @@ -0,0 +1,217 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +/* + MUST COMPILE WITH + flex -PPartnParser -opartnlexer.cc partn.l + (or equivalent). +*/ + +%{ +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_partn.h" + #include + + + +#include "partn.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int PartnParserwrap(){return(1);} + +extern int PartnParserdebug; + + +/* + These variables are used for error reporting: + flex_partn_lineno : the line currently being parsed when the error occurs. + flex_partn_ch : the character on the line where the error occurs + flex_partn_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_partn_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_partn_lineno = 1; +int flex_partn_ch = 0; +char flex_partn_linebuf[20000]; + +char *flex_partn_stringinput = NULL; +int flex_partn_stringinput_ptr = 0; +FILE *flex_partn_fileinput = NULL; +int my_PartnParser_yyinput(char *buf, int max_size); + + + +void PartnParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_partn_lineno, flex_partn_ch, s, PartnParsertext, flex_partn_linebuf ); + for(i=0;i + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_partn.h" + +extern partn_def_list_t *partn_parse_result; + + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#ifndef YYSTYPE +#line 34 "partn.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + colref_t *colref; + partn_def_list_t *pdl; + partn_def_t *pd; +} yystype; +/* Line 193 of /usr/local/share/bison/yacc.c. */ +#line 140 "partn.tab.cc" +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +#ifndef YYLTYPE +typedef struct yyltype +{ + int first_line; + int first_column; + int last_line; + int last_column; +} yyltype; +# define YYLTYPE yyltype +# define YYLTYPE_IS_TRIVIAL 1 +#endif + +/* Copy the second part of user declarations. */ + + +/* Line 213 of /usr/local/share/bison/yacc.c. */ +#line 161 "partn.tab.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 6 +#define YYLAST 55 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 23 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 8 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 24 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 47 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 265 + +#define YYTRANSLATE(X) \ + ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, + 20, 21, 11, 9, 22, 10, 2, 12, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 19, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 17, 2, 18, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 7, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 13, 14, 15, 16 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 5, 7, 10, 19, 23, 27, 31, + 35, 39, 43, 46, 49, 51, 53, 57, 59, 63, + 65, 67, 70, 73, 76 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 24, 0, -1, 25, -1, 26, -1, 25, 26, -1, + 3, 17, 3, 18, 19, 20, 28, 21, -1, 27, + 9, 27, -1, 27, 10, 27, -1, 27, 7, 27, + -1, 27, 11, 27, -1, 27, 12, 27, -1, 27, + 8, 27, -1, 9, 27, -1, 10, 27, -1, 29, + -1, 30, -1, 20, 27, 21, -1, 27, -1, 28, + 22, 27, -1, 5, -1, 6, -1, 14, 4, -1, + 15, 4, -1, 16, 4, -1, 3, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned char yyrline[] = +{ + 0, 75, 75, 81, 83, 86, 91, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 105, 107, 110, + 112, 113, 114, 115, 119 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "INTNUM", + "LONGINTNUM", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'", "UMINUS", + "HEX_L", "LHEX_L", "IP_L", "'['", "']'", "':'", "'('", "')'", "','", + "$accept", "parse_result", "partn_def_list", "partn_def", "scalar_exp", + "scalar_exp_commalist", "literal", "column_ref", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 124, 38, 43, + 45, 42, 47, 262, 263, 264, 265, 91, 93, 58, + 40, 41, 44 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 23, 24, 25, 25, 26, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 28, 28, 29, + 29, 29, 29, 29, 30 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 1, 1, 2, 8, 3, 3, 3, 3, + 3, 3, 2, 2, 1, 1, 3, 1, 3, 1, + 1, 2, 2, 2, 1 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 0, 0, 2, 3, 0, 1, 4, 0, 0, + 0, 0, 24, 19, 20, 0, 0, 0, 0, 0, + 0, 17, 0, 14, 15, 12, 13, 21, 22, 23, + 0, 0, 0, 0, 0, 0, 0, 5, 0, 16, + 8, 11, 6, 7, 9, 10, 18 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = +{ + -1, 2, 3, 4, 21, 22, 23, 24 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -20 +static const yysigned_char yypact[] = +{ + 1, 13, 31, 1, -20, 29, -20, -20, 18, 32, + 17, 19, -20, -20, -20, 19, 19, 34, 48, 49, + 19, -1, -19, -20, -20, -20, -20, -20, -20, -20, + 33, 19, 19, 19, 19, 19, 19, -20, 19, -20, + 38, 3, 15, 15, -20, -20, -1 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = +{ + -20, -20, -20, 52, -15, -20, -20, -20 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, parse error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = +{ + 25, 26, 37, 38, 1, 30, 31, 32, 33, 34, + 35, 36, 33, 34, 35, 36, 40, 41, 42, 43, + 44, 45, 12, 46, 13, 14, 35, 36, 15, 16, + 5, 6, 8, 17, 18, 19, 9, 11, 27, 20, + 31, 32, 33, 34, 35, 36, 32, 33, 34, 35, + 36, 10, 28, 29, 39, 7 +}; + +static const unsigned char yycheck[] = +{ + 15, 16, 21, 22, 3, 20, 7, 8, 9, 10, + 11, 12, 9, 10, 11, 12, 31, 32, 33, 34, + 35, 36, 3, 38, 5, 6, 11, 12, 9, 10, + 17, 0, 3, 14, 15, 16, 18, 20, 4, 20, + 7, 8, 9, 10, 11, 12, 8, 9, 10, 11, + 12, 19, 4, 4, 21, 3 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 3, 24, 25, 26, 17, 0, 26, 3, 18, + 19, 20, 3, 5, 6, 9, 10, 14, 15, 16, + 20, 27, 28, 29, 30, 27, 27, 4, 4, 4, + 27, 7, 8, 9, 10, 11, 12, 21, 22, 21, + 27, 27, 27, 27, 27, 27, 27 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.first_line = Rhs[1].first_line; \ + Current.first_column = Rhs[1].first_column; \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#define YYLEX yylex () + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +# define YYDSYMPRINT(Args) \ +do { \ + if (yydebug) \ + yysymprint Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YYDSYMPRINT(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*-----------------------------. +| Print this symbol on YYOUT. | +`-----------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue) +#else +yysymprint (yyout, yytype, yyvalue) + FILE* yyout; + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyout, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyout, yytoknum[yytype], yyvalue); +# endif + } + else + YYFPRINTF (yyout, "nterm %s (", yytname[yytype]); + + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyout, ")"); +} +#endif /* YYDEBUG. */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yydestruct (int yytype, YYSTYPE yyvalue) +#else +yydestruct (yytype, yyvalue) + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + switch (yytype) + { + default: + break; + } +} + + + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +# ifdef YYPARSE_PARAM +int yyparse (void *); +# else +int yyparse (void); +# endif +#endif + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of parse errors so far. */ +int yynerrs; + + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + goto yyoverflowlab; + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with. */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more. */ + + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yychar1 = YYTRANSLATE (yychar); + + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ + YYDPRINTF ((stderr, "Next token is ")); + YYDSYMPRINT ((stderr, yychar1, yylval)); + YYDPRINTF ((stderr, "\n")); + } + + /* If the proper action on seeing token YYCHAR1 is to reduce or to + detect an error, take that action. */ + yyn += yychar1; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + int yyi; + + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn - 1, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + switch (yyn) + { + case 2: +#line 75 "partn.y" + { + partn_parse_result = yyvsp[0].pdl; + } + break; + + case 3: +#line 82 "partn.y" + {yyval.pdl = new partn_def_list_t(yyvsp[0].pd);} + break; + + case 4: +#line 83 "partn.y" + {yyval.pdl=yyvsp[-1].pdl->append(yyvsp[0].pd);} + break; + + case 5: +#line 88 "partn.y" + {yyval.pd = new partn_def_t(yyvsp[-7].strval,yyvsp[-5].strval,yyvsp[-1].se_listval);} + break; + + case 6: +#line 92 "partn.y" + { yyval.scalarval=new scalarexp_t("+",yyvsp[-2].scalarval,yyvsp[0].scalarval);} + break; + + case 7: +#line 93 "partn.y" + { yyval.scalarval=new scalarexp_t("-",yyvsp[-2].scalarval,yyvsp[0].scalarval);} + break; + + case 8: +#line 94 "partn.y" + { yyval.scalarval=new scalarexp_t("|",yyvsp[-2].scalarval,yyvsp[0].scalarval);} + break; + + case 9: +#line 95 "partn.y" + { yyval.scalarval=new scalarexp_t("*",yyvsp[-2].scalarval,yyvsp[0].scalarval);} + break; + + case 10: +#line 96 "partn.y" + { yyval.scalarval=new scalarexp_t("/",yyvsp[-2].scalarval,yyvsp[0].scalarval);} + break; + + case 11: +#line 97 "partn.y" + { yyval.scalarval=new scalarexp_t("&",yyvsp[-2].scalarval,yyvsp[0].scalarval);} + break; + + case 12: +#line 98 "partn.y" + { yyval.scalarval = new scalarexp_t("+",yyvsp[0].scalarval);} + break; + + case 13: +#line 99 "partn.y" + { yyval.scalarval = new scalarexp_t("-",yyvsp[0].scalarval);} + break; + + case 14: +#line 100 "partn.y" + { yyval.scalarval= new scalarexp_t(yyvsp[0].litval);} + break; + + case 15: +#line 101 "partn.y" + { yyval.scalarval = new scalarexp_t(yyvsp[0].colref);} + break; + + case 16: +#line 102 "partn.y" + {yyval.scalarval = yyvsp[-1].scalarval;} + break; + + case 17: +#line 106 "partn.y" + { yyval.se_listval= new se_list_t(yyvsp[0].scalarval); } + break; + + case 18: +#line 107 "partn.y" + { yyval.se_listval=yyvsp[-2].se_listval->append(yyvsp[0].scalarval); } + break; + + case 19: +#line 111 "partn.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_INT);} + break; + + case 20: +#line 112 "partn.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_LONGINT);} + break; + + case 21: +#line 113 "partn.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_HEX);} + break; + + case 22: +#line 114 "partn.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_LONGHEX);} + break; + + case 23: +#line 115 "partn.y" + {yyval.litval = new literal_t(yyvsp[0].strval,LITERAL_IP);} + break; + + case 24: +#line 120 "partn.y" + {yyval.colref = new colref_t(yyvsp[0].strval); } + break; + + + } + +/* Line 1016 of /usr/local/share/bison/yacc.c. */ +#line 1121 "partn.tab.cc" + + yyvsp -= yylen; + yyssp -= yylen; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[yytype]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("parse error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("parse error"); + } + goto yyerrlab1; + + +/*----------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action. | +`----------------------------------------------------*/ +yyerrlab1: + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + /* Return failure if at end of input. */ + if (yychar == YYEOF) + { + /* Pop the error token. */ + YYPOPSTACK; + /* Pop the rest of the stack. */ + while (yyssp > yyss) + { + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], + *yyvsp)); + YYDPRINTF ((stderr, "\n")); + yydestruct (yystos[*yyssp], *yyvsp); + YYPOPSTACK; + } + YYABORT; + } + + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); + yydestruct (yychar1, yylval); + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], *yyvsp)); + YYDPRINTF ((stderr, "\n")); + + yydestruct (yystos[yystate], *yyvsp); + yyvsp--; + yystate = *--yyssp; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + } + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; + + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 124 "partn.y" + + + diff --git a/src/ftacmp/partn.tab.cc.h b/src/ftacmp/partn.tab.cc.h new file mode 100644 index 0000000..1daa3bc --- /dev/null +++ b/src/ftacmp/partn.tab.cc.h @@ -0,0 +1,82 @@ +/* A Bison parser, made from partn.y, by GNU bison 1.75. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +#ifndef BISON_PARTN_TAB_CC_H +# define BISON_PARTN_TAB_CC_H + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259, + INTNUM = 260, + LONGINTNUM = 261, + UMINUS = 262, + HEX_L = 263, + LHEX_L = 264, + IP_L = 265 + }; +#endif +#define NAME 258 +#define STRING_TOKEN 259 +#define INTNUM 260 +#define LONGINTNUM 261 +#define UMINUS 262 +#define HEX_L 263 +#define LHEX_L 264 +#define IP_L 265 + + + + +#ifndef YYSTYPE +#line 34 "partn.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + colref_t *colref; + partn_def_list_t *pdl; + partn_def_t *pd; +} yystype; +/* Line 1281 of /usr/local/share/bison/yacc.c. */ +#line 75 "partn.tab.cc.h" +# define YYSTYPE yystype +#endif + +extern YYSTYPE PartnParserlval; + + +#endif /* not BISON_PARTN_TAB_CC_H */ + diff --git a/src/ftacmp/partn.y b/src/ftacmp/partn.y new file mode 100644 index 0000000..d394b1d --- /dev/null +++ b/src/ftacmp/partn.y @@ -0,0 +1,140 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + bison --verbose --defines=partn.tab.cc.h -p PartnParser -o partn.tab.cc partn.y + + (or equivalent). +*/ + +%{ + + +#include + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_partn.h" + +extern partn_def_list_t *partn_parse_result; + + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + int intval; + double floatval; + char *strval; + int subtok; + +/* for FTA definition. */ + literal_t *litval; + scalarexp_t *scalarval; + se_list_t *se_listval; + colref_t *colref; + partn_def_list_t *pdl; + partn_def_t *pd; +} + +%token NAME +%token STRING_TOKEN +%token INTNUM +%token LONGINTNUM + +/* for FTA definition. */ +%type literal +%type column_ref +%type scalar_exp +%type scalar_exp_commalist +%type partn_def_list +%type partn_def + +%left '|' +%left '&' +%left '+' '-' +%left '*' '/' +%nonassoc UMINUS + + /* literal keyword tokens */ +%token HEX_L LHEX_L IP_L + + +%% + +/* Union of possible results */ +parse_result: partn_def_list { + partn_parse_result = $1; + } + ; + + +partn_def_list: + partn_def {$$ = new partn_def_list_t($1);} + | partn_def_list partn_def {$$=$1->append($2);} + ; + +partn_def: + NAME '[' NAME ']' ':' '(' scalar_exp_commalist ')' + {$$ = new partn_def_t($1,$3,$7);} + ; + +scalar_exp: + scalar_exp '+' scalar_exp { $$=new scalarexp_t("+",$1,$3);} + | scalar_exp '-' scalar_exp { $$=new scalarexp_t("-",$1,$3);} + | scalar_exp '|' scalar_exp { $$=new scalarexp_t("|",$1,$3);} + | scalar_exp '*' scalar_exp { $$=new scalarexp_t("*",$1,$3);} + | scalar_exp '/' scalar_exp { $$=new scalarexp_t("/",$1,$3);} + | scalar_exp '&' scalar_exp { $$=new scalarexp_t("&",$1,$3);} + | '+' scalar_exp %prec UMINUS { $$ = new scalarexp_t("+",$2);} + | '-' scalar_exp %prec UMINUS { $$ = new scalarexp_t("-",$2);} + | literal { $$= new scalarexp_t($1);} + | column_ref { $$ = new scalarexp_t($1);} + | '(' scalar_exp ')' {$$ = $2;} + ; + +scalar_exp_commalist: + scalar_exp { $$= new se_list_t($1); } + | scalar_exp_commalist ',' scalar_exp { $$=$1->append($3); } + ; + +literal: + INTNUM {$$ = new literal_t($1,LITERAL_INT);} + | LONGINTNUM {$$ = new literal_t($1,LITERAL_LONGINT);} + | HEX_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_HEX);} + | LHEX_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_LONGHEX);} + | IP_L STRING_TOKEN {$$ = new literal_t($2,LITERAL_IP);} + ; + + +column_ref: + NAME {$$ = new colref_t($1); } + ; + + +%% + diff --git a/src/ftacmp/partnlexer.cc b/src/ftacmp/partnlexer.cc new file mode 100644 index 0000000..7ad3487 --- /dev/null +++ b/src/ftacmp/partnlexer.cc @@ -0,0 +1,1773 @@ +#define yy_create_buffer PartnParser_create_buffer +#define yy_delete_buffer PartnParser_delete_buffer +#define yy_scan_buffer PartnParser_scan_buffer +#define yy_scan_string PartnParser_scan_string +#define yy_scan_bytes PartnParser_scan_bytes +#define yy_flex_debug PartnParser_flex_debug +#define yy_init_buffer PartnParser_init_buffer +#define yy_flush_buffer PartnParser_flush_buffer +#define yy_load_buffer_state PartnParser_load_buffer_state +#define yy_switch_to_buffer PartnParser_switch_to_buffer +#define yyin PartnParserin +#define yyleng PartnParserleng +#define yylex PartnParserlex +#define yyout PartnParserout +#define yyrestart PartnParserrestart +#define yytext PartnParsertext + +#line 19 "partnlexer.cc" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/ftacmp/partnlexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 16 +#define YY_END_OF_BUFFER 17 +static yyconst short int yy_accept[40] = + { 0, + 0, 0, 17, 15, 12, 11, 4, 5, 4, 8, + 7, 7, 7, 7, 6, 12, 11, 0, 0, 8, + 0, 7, 7, 7, 7, 0, 13, 0, 14, 9, + 1, 7, 7, 10, 7, 2, 7, 3, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 1, 4, 4, 4, 4, 1, 4, + 4, 4, 4, 4, 5, 4, 6, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 4, 4, 1, + 1, 1, 1, 4, 8, 9, 9, 9, 10, 9, + 9, 11, 12, 9, 9, 13, 9, 9, 9, 14, + 9, 9, 9, 9, 15, 16, 9, 17, 9, 9, + 4, 1, 4, 1, 18, 1, 9, 9, 9, 9, + + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 1, 4, 1, 19, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[20] = + { 0, + 1, 1, 2, 1, 1, 1, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 1 + } ; + +static yyconst short int yy_base[44] = + { 0, + 0, 0, 53, 54, 50, 0, 54, 46, 44, 13, + 0, 39, 34, 36, 54, 44, 0, 42, 41, 14, + 30, 0, 25, 23, 30, 36, 54, 28, 54, 14, + 0, 10, 8, 54, 16, 0, 10, 0, 54, 29, + 19, 32, 35 + } ; + +static yyconst short int yy_def[44] = + { 0, + 39, 1, 39, 39, 39, 40, 39, 39, 39, 39, + 41, 41, 41, 41, 39, 39, 40, 42, 43, 39, + 39, 41, 41, 41, 41, 42, 39, 43, 39, 39, + 41, 41, 41, 39, 41, 41, 41, 41, 0, 39, + 39, 39, 39 + } ; + +static yyconst short int yy_nxt[74] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 11, 11, + 12, 13, 14, 11, 11, 11, 11, 11, 15, 20, + 20, 22, 38, 37, 36, 35, 34, 21, 21, 17, + 29, 17, 26, 26, 26, 28, 28, 28, 27, 33, + 32, 31, 30, 29, 27, 16, 25, 24, 23, 19, + 18, 16, 39, 3, 39, 39, 39, 39, 39, 39, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39 + } ; + +static yyconst short int yy_chk[74] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 10, + 20, 41, 37, 35, 33, 32, 30, 10, 20, 40, + 28, 40, 42, 42, 42, 43, 43, 43, 26, 25, + 24, 23, 21, 19, 18, 16, 14, 13, 12, 9, + 8, 5, 3, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "partn.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PPartnParser -opartnlexer.cc partn.l + (or equivalent). +*/ +#line 9 "partn.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_partn.h" + #include + + + +#include "partn.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int PartnParserwrap(){return(1);} + +extern int PartnParserdebug; + + +/* + These variables are used for error reporting: + flex_partn_lineno : the line currently being parsed when the error occurs. + flex_partn_ch : the character on the line where the error occurs + flex_partn_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_partn_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_partn_lineno = 1; +int flex_partn_ch = 0; +char flex_partn_linebuf[20000]; + +char *flex_partn_stringinput = NULL; +int flex_partn_stringinput_ptr = 0; +FILE *flex_partn_fileinput = NULL; +int my_PartnParser_yyinput(char *buf, int max_size); + + + +void PartnParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_partn_lineno, flex_partn_ch, s, PartnParsertext, flex_partn_linebuf ); + for(i=0;i +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 88 "partn.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + +#line 661 "partnlexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 40 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 54 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 106 "partn.l" +{ flex_partn_ch+=PartnParserleng; return HEX_L;} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 107 "partn.l" +{ flex_partn_ch+=PartnParserleng; return LHEX_L;} + YY_BREAK +case 3: +YY_RULE_SETUP +#line 108 "partn.l" +{ flex_partn_ch+=PartnParserleng; return IP_L;} + YY_BREAK +/* punctuation */ +case 4: +YY_RULE_SETUP +#line 114 "partn.l" +{ flex_partn_ch+=PartnParserleng; return yytext[0]; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 115 "partn.l" +{ flex_partn_ch+=PartnParserleng; return yytext[0]; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 116 "partn.l" +{ flex_partn_ch+=PartnParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 7: +YY_RULE_SETUP +#line 120 "partn.l" +{ flex_partn_ch+=PartnParserleng; PartnParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* numbers */ +case 8: +#line 125 "partn.l" +case 9: +YY_RULE_SETUP +#line 125 "partn.l" +{ flex_partn_ch+=PartnParserleng; PartnParserlval.strval = strdup(yytext); return INTNUM; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 127 "partn.l" +{ flex_partn_ch+=PartnParserleng; PartnParserlval.strval = strdup(yytext); return LONGINTNUM; } + YY_BREAK +/* strings */ +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_partn_linebuf */ +/* */ +case 11: +YY_RULE_SETUP +#line 137 "partn.l" +{flex_partn_ch=0; flex_partn_lineno++; + strcpy(flex_partn_linebuf,PartnParsertext+1); + yyless(1); + } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 142 "partn.l" +{flex_partn_ch+=PartnParserleng; } /* white space */ + YY_BREAK +case 13: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 144 "partn.l" +{flex_partn_ch+=PartnParserleng; }; /* comment */ + YY_BREAK +case 14: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 145 "partn.l" +{flex_partn_ch+=PartnParserleng; }; /* comment */ + YY_BREAK +case 15: +YY_RULE_SETUP +#line 147 "partn.l" +{flex_partn_ch+=PartnParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); PartnParsererror(yytext);} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 149 "partn.l" +ECHO; + YY_BREAK +#line 838 "partnlexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 40 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 40 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 39); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 149 "partn.l" + + +int my_PartnParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_partn_stringinput != NULL){ + while(c +#include +#include +#include +using namespace std; + + +int print_qp_node(FILE* fd, int i, stream_query* query, map& lfta_names, map& fta_names) { + + int j; + + qp_node* node = query->query_plan[i]; + + string ntype = node->node_type(); + + fprintf(fd, "\tNODE %s, type %s\n", node->node_name.c_str(), ntype.c_str()); + + if (!node->predecessors.empty()) { + for (j = 0; j < node->predecessors.size(); ++j) + fprintf(fd, "\t\tCHILD_NODE %s\n", query->query_plan[query->query_plan[i]->predecessors[j]]->node_name.c_str()); + } + + + + // print input tables + vector input_tables = node->get_input_tbls(); + + for (j = 0; j < input_tables.size(); ++j) { + tablevar_t * table = input_tables[j]; + + if (lfta_names.count(table->schema_name)) + fprintf(fd, "\t\tSOURCE_LFTA %s\n", table->schema_name.c_str()); + else if (fta_names.count(table->schema_name)) + fprintf(fd, "\t\tSOURCE_HFTA %s\n", table->schema_name.c_str()); + } + + fprintf(fd, "\n"); + + + + return 0; + +} + +int print_query(FILE* fd, stream_query* query, map& lfta_names) { + + fprintf(fd, "HFTA %s\n", query->query_name.c_str()); + + + vector tmp_tv = query->get_input_tables(); + int itv; + map fta_names; + + for(itv=0;itvget_schema_name()] = 0; + } + + for (int i = 0; i < query->query_plan.size(); ++i) { + if (query->query_plan[i]) + print_qp_node(fd, i, query, lfta_names, fta_names); + } + + return 0; + +} + +int print_hftas(const char* fname, vector& hfta_list, map& lfta_names, vector& query_names, vector& interface_names) { + + FILE* f = fopen(fname, "w"); + for (int i = 0; i < hfta_list.size(); ++i) { + print_query(f, hfta_list[i], lfta_names); + } + + + for (int mi = 0; mi < query_names.size(); ++mi) { + fprintf(f,"LFTA %s\n",query_names[mi].c_str()); + fprintf(f,"\tINTERFACE %s\n",interface_names[mi].c_str()); + + } + + fclose(f); + + + return 0; + +} + +#endif // __PRINT_PLAN_H diff --git a/src/ftacmp/query_plan.cc b/src/ftacmp/query_plan.cc new file mode 100644 index 0000000..c84edb9 --- /dev/null +++ b/src/ftacmp/query_plan.cc @@ -0,0 +1,13571 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +// Create, manipulate, and dump query plans. + +#include "query_plan.h" +#include "analyze_fta.h" +#include "generate_utils.h" + +#include + +using namespace std; + +extern string hash_nums[NRANDS]; // for fast hashing + + +char tmpstr[1000]; + +void untaboo(string &s){ + int c; + for(c=0;c &sources, std::vector > &ifaces, ifq_t *ifdb){ + param_tbl = spx->param_tbl; + int i; + node_name = n_name; + field_entry_list *fel = new field_entry_list(); + merge_fieldpos = -1; + + disorder = 1; + + for(i=0;iselect_list.size();++i){ + data_type *dt = spx->select_list[i]->se->get_data_type()->duplicate(); + if(dt->is_temporal()){ + if(merge_fieldpos < 0){ + merge_fieldpos = i; + }else{ + fprintf(stderr,"Warning: Merge subquery %s found two temporal fields (%s, %s), using %s\n", n_name.c_str(), spx->select_list[merge_fieldpos]->name.c_str(), spx->select_list[i]->name.c_str(), spx->select_list[merge_fieldpos]->name.c_str() ); + dt->reset_temporal(); + } + } + + field_entry *fe = dt->make_field_entry(spx->select_list[i]->name); + fel->append_field(fe); + delete dt; + } + if(merge_fieldpos<0){ + fprintf(stderr,"ERROR, no temporal attribute for merge subquery %s\n",n_name.c_str()); + exit(1); + } + table_layout = new table_def( n_name.c_str(), NULL, NULL, fel, STREAM_SCHEMA); + +// NEED TO HANDLE USER_SPECIFIED SLACK + this->resolve_slack(spx->select_list[merge_fieldpos]->se, + spx->select_list[merge_fieldpos]->name, ifaces, ifdb,NULL); +// if(this->slack == NULL) +// fprintf(stderr,"Zero slack.\n"); +// else +// fprintf(stderr,"slack is %s\n",slack->to_string().c_str()); + + for(i=0;iselect_list[merge_fieldpos]->name.c_str())); + mvars[i]->set_tablevar_ref(i); + fm.push_back(new tablevar_t(sources[i].c_str())); + fm[i]->set_range_var(rvar); + } + + param_tbl = new param_table(); + std::vector param_names = spx->param_tbl->get_param_names(); + int pi; + for(pi=0;piparam_tbl->get_data_type(param_names[pi]); + param_tbl->add_param(param_names[pi],dt->duplicate(), + spx->param_tbl->handle_access(param_names[pi])); + } + definitions = spx->definitions; + +} + + + +// This function translates an analyzed parse tree +// into one or more query nodes (qp_node). +// Currently only one node is created, but some query +// fragments might create more than one query node, +// e.g. aggregation over a joim, or nested subqueries +// in the FROM clause (unless this is handles at parse tree +// analysis time). At this stage, they will be linked +// by the names in the FROM clause. +// INVARIANT : if mroe than one query node is returned, +// the last one represents the output of the query. +vector create_query_nodes(query_summary_class *qs,table_list *Schema){ + +// Classify the query. + + vector local_plan; + qp_node *plan_root; + +// TODO +// I should probably move a lot of this code +// into the qp_node constructors, +// and have this code focus on building the query plan tree. + +// MERGE node + if(qs->query_type == MERGE_QUERY){ + mrg_qpn *merge_node = new mrg_qpn(qs,Schema); + +// Done + plan_root = merge_node; + local_plan.push_back(merge_node); + + /* + Do not split sources until we are done with optimizations + vector split_merge = merge_node->split_sources(); + local_plan.insert(local_plan.begin(), split_merge.begin(), split_merge.end()); + */ +// If children are created, add them to the schema. +/* + int i; +printf("split_merge size is %d\n",split_merge.size()); + for(i=1;iadd_table(split_merge[i]->get_fields()); +printf("Adding split merge table %d\n",i); + } +*/ + +/* +printf("Did split sources on %s:\n",qs->query_name.c_str()); +int ss; +for(ss=0;ssto_string().c_str()); +} +printf("\n"); +} +*/ + + + } else{ + +// Select / Aggregation / Join + if(qs->gb_tbl->size() == 0 && qs->aggr_tbl->size() == 0){ + + if(qs->fta_tree->get_from()->size() == 1){ + spx_qpn *spx_node = new spx_qpn(qs,Schema); + + plan_root = spx_node; + local_plan.push_back(spx_node); + }else{ + if(qs->fta_tree->get_from()->get_properties() == FILTER_JOIN_PROPERTY){ + filter_join_qpn *join_node = new filter_join_qpn(qs,Schema); + plan_root = join_node; + local_plan.push_back(join_node); + }else{ + join_eq_hash_qpn *join_node = new join_eq_hash_qpn(qs,Schema); + plan_root = join_node; + local_plan.push_back(join_node); + } + } + }else{ +// aggregation + + if(qs->states_refd.size() || qs->sg_tbl.size() || qs->cb_cnf.size()){ + sgahcwcb_qpn *sgahcwcb_node = new sgahcwcb_qpn(qs,Schema); + plan_root = sgahcwcb_node; + local_plan.push_back(sgahcwcb_node); + }else{ + if(qs->closew_cnf.size()){ + rsgah_qpn *rsgah_node = new rsgah_qpn(qs,Schema); + plan_root = rsgah_node; + local_plan.push_back(rsgah_node); + }else{ + sgah_qpn *sgah_node = new sgah_qpn(qs,Schema); + plan_root = sgah_node; + local_plan.push_back(sgah_node); + } + } + } + } + + +// Get the query name and other definitions. + plan_root->set_node_name( qs->query_name); + plan_root->set_definitions( qs->definitions) ; + + +// return(plan_root); + return(local_plan); + +} + + +string se_to_query_string(scalarexp_t *se, aggregate_table *aggr_tbl){ + string l_str; + string r_str; + string ret; + int p; + vector operand_list; + string su_ind = ""; + + if(se->is_superaggr()) + su_ind = "$"; + + switch(se->get_operator_type()){ + case SE_LITERAL: + l_str = se->get_literal()->to_query_string(); + return l_str; + case SE_PARAM: + l_str = "$" + se->get_op(); + return l_str; + case SE_COLREF: + l_str = se->get_colref()->to_query_string() ; + return l_str; + case SE_UNARY_OP: + l_str = se_to_query_string(se->get_left_se(),aggr_tbl); + + return se->get_op()+"( "+l_str+" )";; + case SE_BINARY_OP: + l_str = se_to_query_string(se->get_left_se(),aggr_tbl); + r_str = se_to_query_string(se->get_right_se(),aggr_tbl); + return( "("+l_str+")"+se->get_op()+"("+r_str+")" ); + case SE_AGGR_STAR: + return( se->get_op() + su_ind + "(*)"); + case SE_AGGR_SE: + l_str = se_to_query_string(aggr_tbl->get_aggr_se(se->get_aggr_ref()),aggr_tbl); + return( se->get_op() + su_ind + "(" + l_str + ")" ); + case SE_FUNC: + if(se->get_aggr_ref() >= 0) + operand_list = aggr_tbl->get_operand_list(se->get_aggr_ref()); + else + operand_list = se->get_operands(); + + ret = se->get_op() + su_ind + "("; + for(p=0;p0) ret += ", "; + ret += l_str; + } + ret += ")"; + return(ret); + break; + } + return "ERROR SE op type not recognized in se_to_query_string.\n"; +} + + +string pred_to_query_str(predicate_t *pr, aggregate_table *aggr_tbl){ + string l_str; + string r_str; + string ret; + int o,l; + vector llist; + vector op_list; + + switch(pr->get_operator_type()){ + case PRED_IN: + l_str = se_to_query_string(pr->get_left_se(),aggr_tbl); + ret = l_str + " IN ["; + llist = pr->get_lit_vec(); + for(l=0;l0) ret += ", "; + ret += llist[l]->to_query_string(); + } + ret += "]"; + + return(ret); + case PRED_COMPARE: + l_str = se_to_query_string(pr->get_left_se(),aggr_tbl); + r_str = se_to_query_string(pr->get_right_se(),aggr_tbl); + return( l_str + " " + pr->get_op() + " " + r_str ); + case PRED_UNARY_OP: + l_str = pred_to_query_str(pr->get_left_pr(),aggr_tbl); + return(pr->get_op() + "( " + l_str + " )"); + case PRED_BINARY_OP: + l_str = pred_to_query_str(pr->get_left_pr(),aggr_tbl); + r_str = pred_to_query_str(pr->get_right_pr(),aggr_tbl); + return("( " + r_str + " )" + pr->get_op() + "( " + l_str + " )"); + case PRED_FUNC: + ret = pr->get_op()+"["; + op_list = pr->get_op_list(); + for(o=0;o0) ret += ", "; + ret += se_to_query_string(op_list[o],aggr_tbl); + } + ret += "]"; + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in pred_to_query_str, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); +} + + + +// Build a selection list, +// but avoid adding duplicate SEs. + + +int add_select_list_nodup(vector &lfta_select_list, scalarexp_t *se, + bool &new_element){ + new_element = false; + int s; + for(s=0;sse, se)){ + return(s); + } + } + new_element = true; + lfta_select_list.push_back(new select_element(se,"NoNameIn:add_select_list_nodup")); + return(lfta_select_list.size()-1); +} + + + +// TODO: The generated colref should be tied to the tablevar +// representing the lfta output. For now, always 0. + +scalarexp_t *make_fta_se_ref(vector &lfta_select_list, scalarexp_t *se, int h_tvref){ + bool new_element; + int fta_se_nbr = add_select_list_nodup(lfta_select_list, se, new_element); + string colname; + if(!new_element){ + colname = lfta_select_list[fta_se_nbr]->name; + }else{ + colname = impute_colname(lfta_select_list, se); + lfta_select_list[fta_se_nbr]->name = colname; + } +// +// TODO: fill in the tablevar and schema of the colref here. + colref_t *new_cr = new colref_t(colname.c_str()); + new_cr->set_tablevar_ref(h_tvref); + + + scalarexp_t *new_se= new scalarexp_t(new_cr); + new_se->use_decorations_of(se); + + return(new_se); +} + + +// Build a selection list, +// but avoid adding duplicate SEs. + + +int add_select_list_nodup(vector *lfta_select_list, scalarexp_t *se, + bool &new_element){ + new_element = false; + int s; + for(s=0;ssize();s++){ + if(is_equivalent_se((*lfta_select_list)[s]->se, se)){ + return(s); + } + } + new_element = true; + lfta_select_list->push_back(new select_element(se,"NoNameIn:add_select_list_nodup")); + return(lfta_select_list->size()-1); +} + + + +// TODO: The generated colref should be tied to the tablevar +// representing the lfta output. For now, always 0. + +scalarexp_t *make_fta_se_ref(vector *> &lfta_select_list, scalarexp_t *se, int h_tvref){ + bool new_element; + vector *the_sel_list = lfta_select_list[h_tvref]; + int fta_se_nbr = add_select_list_nodup(the_sel_list, se, new_element); + string colname; + if(!new_element){ + colname = (*the_sel_list)[fta_se_nbr]->name; + }else{ + colname = impute_colname(*the_sel_list, se); + (*the_sel_list)[fta_se_nbr]->name = colname; + } +// +// TODO: fill in the tablevar and schema of the colref here. + colref_t *new_cr = new colref_t(colname.c_str()); + new_cr->set_tablevar_ref(h_tvref); + + + scalarexp_t *new_se= new scalarexp_t(new_cr); + new_se->use_decorations_of(se); + + return(new_se); +} + + + + +// +// Test if a se can be evaluated at the fta. +// check forbidden types (e.g. float), forbidden operations +// between types (e.g. divide a long long), forbidden operations +// (too expensive, not implemented). +// +// Return true if not forbidden, false if forbidden +// +// TODO: the parameter aggr_tbl is not used, delete it. + +bool check_fta_forbidden_se(scalarexp_t *se, + aggregate_table *aggr_tbl, + ext_fcn_list *Ext_fcns + ){ + + int p, fcn_id; + vector operand_list; + vector dt_signature; + data_type *dt = se->get_data_type(); + + + + switch(se->get_operator_type()){ + case SE_LITERAL: + case SE_PARAM: + case SE_COLREF: + return( se->get_data_type()->fta_legal_type() ); + case SE_IFACE_PARAM: + return true; + case SE_UNARY_OP: + if(!check_fta_forbidden_se(se->get_left_se(), aggr_tbl, Ext_fcns)) + return(false); + return( + dt->fta_legal_operation(se->get_left_se()->get_data_type(), se->get_op()) + ); + case SE_BINARY_OP: + if(!check_fta_forbidden_se(se->get_left_se(),aggr_tbl, Ext_fcns)) + return(false); + if(!check_fta_forbidden_se(se->get_right_se(),aggr_tbl, Ext_fcns)) + return(false); + return(dt->fta_legal_operation(se->get_left_se()->get_data_type(), + se->get_right_se()->get_data_type(), + se->get_op() + ) + ); + +// return true, aggregate fta-safeness is determined elsewhere. + case SE_AGGR_STAR: + return(true); + case SE_AGGR_SE: + return(true); + + case SE_FUNC: + if(se->get_aggr_ref() >= 0) return true; + + operand_list = se->get_operands(); + for(p=0;pget_data_type() ); + } + fcn_id = Ext_fcns->lookup_fcn(se->get_op(), dt_signature); + if( fcn_id < 0 ){ + fprintf(stderr,"ERROR, no external function %s(",se->get_op().c_str()); + int o; + for(o=0;o0) fprintf(stderr,", "); + fprintf(stderr,"%s",operand_list[o]->get_data_type()->to_string().c_str()); + } + fprintf(stderr,") is defined, line %d, char %d\n", se->get_lineno(), se->get_charno() ); + if(fcn_id == -2) fprintf(stderr,"(multiple subsuming functions found)\n"); + return(false); + } + + return(Ext_fcns->fta_legal(fcn_id) ); + default: + printf("INTERNAL ERROR in check_fta_forbidden_se: operator type %d\n",se->get_operator_type()); + exit(1); + break; + } + return(false); + +} + + +// test if a pr can be executed at the fta. +// +// Return true if not forbidden, false if forbidden + +bool check_fta_forbidden_pr(predicate_t *pr, + aggregate_table *aggr_tbl, + ext_fcn_list *Ext_fcns + ){ + + vector llist; + data_type *dt; + int l,o, fcn_id; + vector op_list; + vector dt_signature; + + + + switch(pr->get_operator_type()){ + case PRED_IN: + if(! check_fta_forbidden_se(pr->get_left_se(), aggr_tbl, Ext_fcns) ) + return(false); + llist = pr->get_lit_vec(); + for(l=0;lget_type()); + if(! dt->fta_legal_type()){ + delete dt; + return(false); + } + delete dt; + } + return(true); + case PRED_COMPARE: + if(! check_fta_forbidden_se(pr->get_left_se(), aggr_tbl, Ext_fcns)) + return(false); + if(! check_fta_forbidden_se(pr->get_right_se(), aggr_tbl, Ext_fcns)) + return(false); + return(true); + case PRED_UNARY_OP: + return( check_fta_forbidden_pr(pr->get_left_pr(), aggr_tbl, Ext_fcns) ); + case PRED_BINARY_OP: + if(! check_fta_forbidden_pr(pr->get_left_pr(), aggr_tbl, Ext_fcns)) + return(false); + if(! check_fta_forbidden_pr(pr->get_right_pr(), aggr_tbl, Ext_fcns)) + return(false); + return(true); + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_data_type() ); + } + fcn_id = Ext_fcns->lookup_pred(pr->get_op(), dt_signature); + if( fcn_id < 0 ){ + fprintf(stderr,"ERROR, no external predicate %s(",pr->get_op().c_str()); + int o; + for(o=0;o0) fprintf(stderr,", "); + fprintf(stderr,"%s",op_list[o]->get_data_type()->to_string().c_str()); + } + fprintf(stderr,") is defined, line %d, char %d\n", pr->get_lineno(), pr->get_charno() ); + if(fcn_id == -2) fprintf(stderr,"(multiple subsuming predicates found)\n"); + return(false); + } + + return(Ext_fcns->fta_legal(fcn_id) ); + default: + fprintf(stderr,"INTERNAL ERROR in check_fta_forbidden_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); + +} + + +// Split the aggregates in orig_aggr_tbl, into superaggregates and +// subaggregates. +// (the value of the HFTA aggregate might be a SE of several LFTA +// subaggregates, e.g. avg : sum / count ) +// Register the superaggregates in hfta_aggr_tbl, and the +// subaggregates in lfta_aggr_tbl. +// Insert references to the subaggregates into lfta_select_list. +// (and record their names in the currnames list) +// Create a SE for the superaggregate, put it in hfta_aggr_se, +// keyed on agr_id. + +void split_fta_aggr(aggregate_table *orig_aggr_tbl, int agr_id, + aggregate_table *hfta_aggr_tbl, + aggregate_table *lfta_aggr_tbl, + vector &lfta_select_list, + map &hfta_aggr_se, + ext_fcn_list *Ext_fcns + ){ + bool new_element; + scalarexp_t *subaggr_se; + int fta_se_nbr; + string colname; + int ano; + colref_t *new_cr; + scalarexp_t *new_se, *l_se; + vector subaggr_ref_se; + +// UDAF processing + if(! orig_aggr_tbl->is_builtin(agr_id)){ +// Construct the subaggregate + int fcn_id = orig_aggr_tbl->get_fcn_id(agr_id); + vector opl = orig_aggr_tbl->get_operand_list(agr_id); + vector subopl; + int o; + for(o=0;oget_subaggr_id(fcn_id); + subaggr_se = new scalarexp_t(Ext_fcns->get_fcn_name(sub_id).c_str(), subopl); + subaggr_se->set_fcn_id(sub_id); + subaggr_se->set_data_type(Ext_fcns->get_fcn_dt(sub_id)); +// Add it to the lfta select list. + fta_se_nbr = add_select_list_nodup(lfta_select_list, subaggr_se,new_element); + if(!new_element){ + colname = lfta_select_list[fta_se_nbr]->name; + }else{ + colname = impute_colname(lfta_select_list, subaggr_se); + lfta_select_list[fta_se_nbr]->name = colname; + ano = lfta_aggr_tbl->add_aggr(Ext_fcns->get_fcn_name(sub_id), sub_id, subopl,Ext_fcns->get_storage_dt(sub_id), false, false,Ext_fcns->has_lfta_bailout(sub_id)); + subaggr_se->set_aggr_id(ano); + } + +// Construct a reference to the subaggregate + new_cr = new colref_t(colname.c_str()); + new_se = new scalarexp_t(new_cr); +// I'm not certain what the types should be .... +// This will need to be filled in by later analysis. +// NOTE: this might not capture all the meaning of data_type ... + new_se->set_data_type(Ext_fcns->get_fcn_dt(sub_id)); + subaggr_ref_se.push_back(new_se); + +// Construct the superaggregate + int super_id = Ext_fcns->get_superaggr_id(fcn_id); + scalarexp_t *ret_se = new scalarexp_t(Ext_fcns->get_fcn_name(super_id).c_str(), subaggr_ref_se); + ret_se->set_fcn_id(super_id); + ret_se->set_data_type(Ext_fcns->get_fcn_dt(super_id)); +// Register it in the hfta aggregate table + ano = hfta_aggr_tbl->add_aggr(ret_se->get_op(), super_id, subaggr_ref_se,Ext_fcns->get_storage_dt(super_id), false, Ext_fcns->is_running_aggr(sub_id),false); + ret_se->set_aggr_id(ano); + hfta_aggr_se[agr_id] = ret_se; + + return; + } + + +// builtin aggregate processing + bool l_forbid; + + vector use_se; + vector subaggr_names = orig_aggr_tbl->get_subaggr_fcns(agr_id, use_se); + vector subaggr_dt = orig_aggr_tbl->get_subaggr_dt(agr_id); + int sa; + + if(orig_aggr_tbl->is_star_aggr(agr_id)){ + for(sa=0;saset_data_type(subaggr_dt[sa]); + +// The following sequence is similar to the code in make_fta_se_ref, +// but there is special processing for the aggregate tables. + int fta_se_nbr = add_select_list_nodup(lfta_select_list, subaggr_se,new_element); + if(!new_element){ + colname = lfta_select_list[fta_se_nbr]->name; + }else{ + colname = impute_colname(lfta_select_list, subaggr_se); + lfta_select_list[fta_se_nbr]->name = colname; + ano = lfta_aggr_tbl->add_aggr(subaggr_names[sa].c_str(),NULL, false); + subaggr_se->set_aggr_id(ano); + } + new_cr = new colref_t(colname.c_str()); + new_cr->set_tablevar_ref(0); + new_se = new scalarexp_t(new_cr); + +// I'm not certain what the types should be .... +// This will need to be filled in by later analysis. +// Actually, this is causing a problem. +// I will assume a UINT data type. / change to INT +// (consistent with assign_data_types in analyze_fta.cc) +// TODO: why can't I use subaggr_dt, as I do in the other IF branch? + data_type *ndt = new data_type("Int"); // used to be Uint + new_se->set_data_type(ndt); + + subaggr_ref_se.push_back(new_se); + } + }else{ + for(sa=0;saget_aggr_se(agr_id); + l_se = dup_se(aggr_operand, NULL); + subaggr_se = scalarexp_t::make_se_aggr(subaggr_names[sa].c_str(),l_se); + }else{ + subaggr_se = scalarexp_t::make_star_aggr(subaggr_names[sa].c_str()); + } + subaggr_se->set_data_type(subaggr_dt[sa]); + +// again, similar to make_fta_se_ref. + fta_se_nbr = add_select_list_nodup(lfta_select_list, subaggr_se,new_element); + if(!new_element){ + colname = lfta_select_list[fta_se_nbr]->name; + }else{ + colname = impute_colname(lfta_select_list, subaggr_se); + lfta_select_list[fta_se_nbr]->name = colname; + if(use_se[sa]) + ano = lfta_aggr_tbl->add_aggr(subaggr_names[sa].c_str(),l_se, false); + else + ano = lfta_aggr_tbl->add_aggr(subaggr_names[sa].c_str(),NULL,false); + subaggr_se->set_aggr_id(ano); + } + new_cr = new colref_t(colname.c_str()); + new_se = new scalarexp_t(new_cr); +// I'm not certain what the types should be .... +// This will need to be filled in by later analysis. +// NOTE: this might not capture all the meaning of data_type ... + new_se->set_data_type(subaggr_dt[sa]); + subaggr_ref_se.push_back(new_se); + } + } + scalarexp_t *ret_se = orig_aggr_tbl->make_superaggr_se(agr_id, subaggr_ref_se); + ret_se->set_data_type(orig_aggr_tbl->get_data_type(agr_id)); + +// ASSUME either the return value is an aggregation, +// or a binary_op between two aggregations + if(ret_se->get_operator_type() == SE_AGGR_SE || ret_se->get_operator_type() == SE_AGGR_SE){ + ano = hfta_aggr_tbl->add_aggr(ret_se->get_op(), ret_se->get_left_se(), false ); + ret_se->set_aggr_id(ano); + }else{ +// Basically processing for AVG. +// set the data type of the superagg to that of the subagg. + scalarexp_t *left_se = ret_se->get_left_se(); + left_se->set_data_type(subaggr_dt[0]); + ano = hfta_aggr_tbl->add_aggr(left_se->get_op(), left_se->get_left_se(), false ); + left_se->set_aggr_id(ano); + + scalarexp_t *right_se = ret_se->get_right_se(); + right_se->set_data_type(subaggr_dt[1]); + ano = hfta_aggr_tbl->add_aggr(right_se->get_op(), right_se->get_left_se(), false ); + right_se->set_aggr_id(ano); + } + + hfta_aggr_se[agr_id] = ret_se; + +} + + +// Split the aggregates in orig_aggr_tbl, into hfta_superaggregates and +// hfta_subaggregates. +// Register the superaggregates in hi_aggr_tbl, and the +// subaggregates in loq_aggr_tbl. +// Insert references to the subaggregates into low_select_list. +// (and record their names in the currnames list) +// Create a SE for the superaggregate, put it in hfta_aggr_se, +// keyed on agr_id. + +void split_hfta_aggr(aggregate_table *orig_aggr_tbl, int agr_id, + aggregate_table *hi_aggr_tbl, + aggregate_table *low_aggr_tbl, + vector &low_select_list, + map &hi_aggr_se, + ext_fcn_list *Ext_fcns + ){ + bool new_element; + scalarexp_t *subaggr_se; + int fta_se_nbr; + string colname; + int ano; + colref_t *new_cr; + scalarexp_t *new_se, *l_se; + vector subaggr_ref_se; + +// UDAF processing + if(! orig_aggr_tbl->is_builtin(agr_id)){ +// Construct the subaggregate + int fcn_id = orig_aggr_tbl->get_fcn_id(agr_id); + vector opl = orig_aggr_tbl->get_operand_list(agr_id); + vector subopl; + int o; + for(o=0;oget_hfta_subaggr_id(fcn_id); + subaggr_se = new scalarexp_t(Ext_fcns->get_fcn_name(sub_id).c_str(), subopl); + subaggr_se->set_fcn_id(sub_id); + subaggr_se->set_data_type(Ext_fcns->get_fcn_dt(sub_id)); +// Add it to the low select list. + fta_se_nbr = add_select_list_nodup(low_select_list, subaggr_se,new_element); + if(!new_element){ + colname = low_select_list[fta_se_nbr]->name; + }else{ + colname = impute_colname(low_select_list, subaggr_se); + low_select_list[fta_se_nbr]->name = colname; + ano = low_aggr_tbl->add_aggr(Ext_fcns->get_fcn_name(sub_id), sub_id, subopl,Ext_fcns->get_storage_dt(sub_id), false, false,false); + subaggr_se->set_aggr_id(ano); + } + +// Construct a reference to the subaggregate + new_cr = new colref_t(colname.c_str()); + new_se = new scalarexp_t(new_cr); +// I'm not certain what the types should be .... +// This will need to be filled in by later analysis. +// NOTE: this might not capture all the meaning of data_type ... + new_se->set_data_type(Ext_fcns->get_fcn_dt(sub_id)); + subaggr_ref_se.push_back(new_se); + +// Construct the superaggregate + int super_id = Ext_fcns->get_hfta_superaggr_id(fcn_id); + scalarexp_t *ret_se = new scalarexp_t(Ext_fcns->get_fcn_name(super_id).c_str(), subaggr_ref_se); + ret_se->set_fcn_id(super_id); + ret_se->set_data_type(Ext_fcns->get_fcn_dt(super_id)); +// Register it in the high aggregate table + ano = hi_aggr_tbl->add_aggr(ret_se->get_op(), super_id, subaggr_ref_se,Ext_fcns->get_storage_dt(super_id), false, false,false); + ret_se->set_aggr_id(ano); + hi_aggr_se[agr_id] = ret_se; + + return; + } + + +// builtin aggregate processing + bool l_forbid; + + vector use_se; + vector subaggr_names = orig_aggr_tbl->get_subaggr_fcns(agr_id, use_se); + vector subaggr_dt = orig_aggr_tbl->get_subaggr_dt(agr_id); + int sa; + + if(orig_aggr_tbl->is_star_aggr(agr_id)){ + for(sa=0;saset_data_type(subaggr_dt[sa]); + +// The following sequence is similar to the code in make_fta_se_ref, +// but there is special processing for the aggregate tables. + int fta_se_nbr = add_select_list_nodup(low_select_list, subaggr_se,new_element); + if(!new_element){ + colname = low_select_list[fta_se_nbr]->name; + }else{ + colname = impute_colname(low_select_list, subaggr_se); + low_select_list[fta_se_nbr]->name = colname; + ano = low_aggr_tbl->add_aggr(subaggr_names[sa].c_str(),NULL, false); + subaggr_se->set_aggr_id(ano); + } + new_cr = new colref_t(colname.c_str()); + new_cr->set_tablevar_ref(0); + new_se = new scalarexp_t(new_cr); + +// I'm not certain what the types should be .... +// This will need to be filled in by later analysis. +// Actually, this is causing a problem. +// I will assume a UINT data type. +// (consistent with assign_data_types in analyze_fta.cc) +// TODO: why can't I use subaggr_dt, as I do in the other IF branch? + data_type *ndt = new data_type("Int"); // was Uint + new_se->set_data_type(ndt); + + subaggr_ref_se.push_back(new_se); + } + }else{ + for(sa=0;saget_aggr_se(agr_id); + l_se = dup_se(aggr_operand, NULL); + subaggr_se = scalarexp_t::make_se_aggr(subaggr_names[sa].c_str(),l_se); + }else{ + subaggr_se = scalarexp_t::make_star_aggr(subaggr_names[sa].c_str()); + } + subaggr_se->set_data_type(subaggr_dt[sa]); + +// again, similar to make_fta_se_ref. + fta_se_nbr = add_select_list_nodup(low_select_list, subaggr_se,new_element); + if(!new_element){ + colname = low_select_list[fta_se_nbr]->name; + }else{ + colname = impute_colname(low_select_list, subaggr_se); + low_select_list[fta_se_nbr]->name = colname; + if(use_se[sa]) + ano = low_aggr_tbl->add_aggr(subaggr_names[sa].c_str(),l_se, false); + else + ano = low_aggr_tbl->add_aggr(subaggr_names[sa].c_str(),NULL,false); + subaggr_se->set_aggr_id(ano); + } + new_cr = new colref_t(colname.c_str()); + new_se = new scalarexp_t(new_cr); +// I'm not certain what the types should be .... +// This will need to be filled in by later analysis. +// NOTE: this might not capture all the meaning of data_type ... + new_se->set_data_type(subaggr_dt[sa]); + subaggr_ref_se.push_back(new_se); + } + } + scalarexp_t *ret_se = orig_aggr_tbl->make_superaggr_se(agr_id, subaggr_ref_se); +// ASSUME either the return value is an aggregation, +// or a binary_op between two aggregations + if(ret_se->get_operator_type() == SE_AGGR_SE || ret_se->get_operator_type() == SE_AGGR_SE){ + ret_se->set_data_type(orig_aggr_tbl->get_data_type(agr_id)); + ano = hi_aggr_tbl->add_aggr(ret_se->get_op(), ret_se->get_left_se(), false ); + }else{ +// Basically processing for AVG. +// set the data type of the superagg to that of the subagg. + scalarexp_t *left_se = ret_se->get_left_se(); + left_se->set_data_type(subaggr_dt[0]); + ano = hi_aggr_tbl->add_aggr(left_se->get_op(), left_se->get_left_se(), false ); + left_se->set_aggr_id(ano); + + scalarexp_t *right_se = ret_se->get_right_se(); + right_se->set_data_type(subaggr_dt[1]); + ano = hi_aggr_tbl->add_aggr(right_se->get_op(), right_se->get_left_se(), false ); + right_se->set_aggr_id(ano); + } + + ret_se->set_aggr_id(ano); + hi_aggr_se[agr_id] = ret_se; + +} + + + + + +// Split a scalar expression into one part which executes +// at the stream and another set of parts which execute +// at the FTA. +// Because I'm actually modifying the SEs, I will make +// copies. But I will assume that literals, params, and +// colrefs are immutable at this point. +// (if there is ever a need to change one, must make a +// new value). +// NOTE : if se is constant (only refrences literals), +// avoid making the fta compute it. +// +// NOTE : This will need to be generalized to +// handle join expressions, namely to handle a vector +// of lftas. +// +// Return value is the HFTA se. +// Add lftas select_elements to the fta_select_list. +// set fta_forbidden if this node or any child cannot +// execute at the lfta. + +/* + +scalarexp_t *split_fta_se(scalarexp_t *se, + bool &fta_forbidden, + vector &lfta_select_list, + ext_fcn_list *Ext_fcns + ){ + + int p, fcn_id; + vector operand_list; + vector dt_signature; + scalarexp_t *ret_se, *l_se, *r_se; + bool l_forbid, r_forbid, this_forbid; + colref_t *new_cr; + scalarexp_t *new_se; + data_type *dt = se->get_data_type(); + + switch(se->get_operator_type()){ + case SE_LITERAL: + fta_forbidden = ! se->get_data_type()->fta_legal_type(); + ret_se = new scalarexp_t(se->get_literal()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_PARAM: + fta_forbidden = ! se->get_data_type()->fta_legal_type(); + ret_se = scalarexp_t::make_param_reference(se->get_op().c_str()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_COLREF: +// No colref should be forbidden, +// the schema is wrong, the fta_legal_type() fcn is wrong, +// or the source table is actually a stream. +// Issue a warning, but proceed with processing. +// Also, should not be a ref to a gbvar. +// (a gbvar ref only occurs in an aggregation node, +// and these SEs are rehomed, not split. + fta_forbidden = ! se->get_data_type()->fta_legal_type(); + + if(fta_forbidden){ + fprintf(stderr,"WARNING, a colref is a forbidden data type in split_fta_se," + " colref is %s," + " type is %s, line=%d, col=%d\n", + se->get_colref()->to_string().c_str(), + se->get_data_type()->get_type_str().c_str(), + se->lineno, se->charno + ); + } + + if(se->is_gb()){ + fprintf(stderr,"INTERNAL ERROR, a colref is a gbvar ref in split_fta_se," + " type is %s, line=%d, col=%d\n", + se->get_data_type()->get_type_str().c_str(), + se->lineno, se->charno + ); + exit(1); + } + + ret_se = new scalarexp_t(se->get_colref()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_UNARY_OP: + l_se = split_fta_se(se->get_left_se(), l_forbid, lfta_select_list, Ext_fcns); + + this_forbid = ! dt->fta_legal_operation(l_se->get_data_type(), se->get_op()); + +// If this operation is forbidden but the child SE is not, +// put the child se on the lfta_select_list, create a colref +// which accesses this se, and make it the child of this op. +// Exception : the child se is constant (only literal refs). + if(this_forbid && !l_forbid){ + if(!is_literal_or_param_only(l_se)){ + new_se = make_fta_se_ref(lfta_select_list, l_se,0); + ret_se = new scalarexp_t(se->get_op().c_str(), new_se); + } + }else{ + ret_se = new scalarexp_t(se->get_op().c_str(), l_se); + } + ret_se->use_decorations_of(se); + fta_forbidden = this_forbid | l_forbid; + return(ret_se); + + case SE_BINARY_OP: + l_se = split_fta_se(se->get_left_se(), l_forbid, lfta_select_list, Ext_fcns); + r_se = split_fta_se(se->get_right_se(), r_forbid, lfta_select_list, Ext_fcns); + + this_forbid = ! dt->fta_legal_operation(l_se->get_data_type(), r_se->get_data_type(), se->get_op()); + +// Replace the left se if it is not forbidden, but something else is. + if((this_forbid || r_forbid) & !l_forbid){ + if(!is_literal_or_param_only(l_se)){ + new_se = make_fta_se_ref(lfta_select_list, l_se,0); + l_se = new_se; + } + } + +// Replace the right se if it is not forbidden, but something else is. + if((this_forbid || l_forbid) & !r_forbid){ + if(!is_literal_or_param_only(r_se)){ + new_se = make_fta_se_ref(lfta_select_list, r_se,0); + r_se = new_se; + } + } + + ret_se = new scalarexp_t(se->get_op().c_str(), l_se, r_se); + ret_se->use_decorations_of(se); + fta_forbidden = this_forbid || r_forbid || l_forbid; + + return(ret_se); + + case SE_AGGR_STAR: + case SE_AGGR_SE: + + fprintf(stderr,"INTERNAL ERROR, aggregate ref (%s) in split_fta_se." + " line=%d, col=%d\n", + se->get_op().c_str(), + se->lineno, se->charno + ); + exit(1); + break; + + case SE_FUNC: + { + fta_forbidden = false; + operand_list = se->get_operands(); + vector new_operands; + vector forbidden_op; + for(p=0;pget_data_type() ); + } + + fcn_id = Ext_fcns->lookup_fcn(se->get_op(), dt_signature); + if( fcn_id < 0 ){ + fprintf(stderr,"ERROR, no external function %s(",se->get_op().c_str()); + int o; + for(o=0;o0) fprintf(stderr,", "); + fprintf(stderr,"%s",operand_list[o]->get_data_type()->get_type_str().c_str()); + } + fprintf(stderr,") is defined, line %d, char %d\n", se->get_lineno(), se->get_charno() ); + if(fcn_id == -2) fprintf(stderr,"(multiple subsuming functions found)\n"); + return(false); + } + + fta_forbidden |= (! Ext_fcns->fta_legal(fcn_id)); + +// Replace the non-forbidden operands. +// the forbidden ones are already replaced. + if(fta_forbidden){ + for(p=0;pget_data_type()->get_temporal() != constant_t){ + if(!is_literal_or_param_only(new_operands[p])){ + new_se = make_fta_se_ref(lfta_select_list, new_operands[p],0); + new_operands[p] = new_se; + } + } + } + } + + ret_se = new scalarexp_t(se->get_op().c_str(), new_operands); + ret_se->use_decorations_of(se); + + return(ret_se); + + } + default: + printf("INTERNAL ERROR in check_fta_forbidden_se: operator type %d\n",se->get_operator_type()); + exit(1); + break; + } + return(false); + +} + +*/ + + +// The predicates have already been +// broken into conjunctions. +// If any part of a conjunction is fta-forbidden, +// it must be executed in the stream operator. +// Else it is executed in the FTA. +// A pre-analysis should determine whether this +// predicate is fta-safe. This procedure will +// assume that it is fta-forbidden and will +// prepare it for execution in the stream. + +/* + +predicate_t *split_fta_pr(predicate_t *pr, + vector &lfta_select_list, + ext_fcn_list *Ext_fcns + ){ + + vector llist; + scalarexp_t *se_l, *se_r; + bool l_forbid, r_forbid; + predicate_t *ret_pr, *pr_l, *pr_r; + vector op_list, new_op_list; + int o; + vector dt_signature; + + + switch(pr->get_operator_type()){ + case PRED_IN: + se_l = split_fta_se(pr->get_left_se(), l_forbid, lfta_select_list, Ext_fcns); + + if(!l_forbid){ + if(!is_literal_or_param_only(se_l)){ + scalarexp_t *new_se = make_fta_se_ref(lfta_select_list, se_l,0); + se_l = new_se; + } + } + ret_pr = new predicate_t(se_l, pr->get_lit_vec()); + + return(ret_pr); + + case PRED_COMPARE: + se_l = split_fta_se(pr->get_left_se(), l_forbid, lfta_select_list, Ext_fcns); + if(!l_forbid){ + if(!is_literal_or_param_only(se_l)){ + scalarexp_t *new_se = make_fta_se_ref(lfta_select_list, se_l,0); + se_l = new_se; + } + } + + se_r = split_fta_se(pr->get_right_se(), r_forbid, lfta_select_list, Ext_fcns); + if(!r_forbid){ + if(!is_literal_or_param_only(se_r)){ + scalarexp_t *new_se = make_fta_se_ref(lfta_select_list, se_r,0); + se_r = new_se; + } + } + + ret_pr = new predicate_t(se_l, pr->get_op().c_str(), se_r); + return(ret_pr); + + case PRED_UNARY_OP: + pr_l = split_fta_pr(pr->get_left_pr(), lfta_select_list, Ext_fcns); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l); + return(ret_pr); + + case PRED_BINARY_OP: + pr_l = split_fta_pr(pr->get_left_pr(), lfta_select_list, Ext_fcns); + pr_r = split_fta_pr(pr->get_right_pr(), lfta_select_list, Ext_fcns); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l, pr_r); + return(ret_pr); + + case PRED_FUNC: +// I can't push the predicate into the lfta, except by +// returning a bool value, and that is not worth the trouble, + op_list = pr->get_op_list(); + for(o=0;oget_op().c_str(), new_op_list); + ret_pr->set_fcn_id(pr->get_fcn_id()); + return(ret_pr); + default: + fprintf(stderr,"INTERNAL ERROR in split_fta_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); + +} + +*/ + + +//-------------------------------------------------------------------- + + + +// Split a scalar expression into one part which executes +// at the stream and another set of parts which execute +// at the FTA. +// Because I'm actually modifying the SEs, I will make +// copies. But I will assume that literals, params, and +// colrefs are immutable at this point. +// (if there is ever a need to change one, must make a +// new value). +// NOTE : if se is constant (only refrences literals), +// avoid making the fta compute it. +// +// NOTE : This will need to be generalized to +// handle join expressions, namely to handle a vector +// of lftas. +// +// Return value is the HFTA se. +// Add lftas select_elements to the fta_select_list. +// set fta_forbidden if this node or any child cannot +// execute at the lfta. + +#define SPLIT_FTAVEC_NOTBLVAR -1 +#define SPLIT_FTAVEC_MIXED -2 + +bool is_PROTOCOL_source(int colref_source, + vector< vector *> &lfta_select_list){ + if(colref_source>=0 && lfta_select_list[colref_source]!=NULL) return true; + return false; +} + +int combine_colref_source(int s1, int s2){ + if(s1==s2) return(s1); + if(s1==SPLIT_FTAVEC_NOTBLVAR) return s2; + if(s2==SPLIT_FTAVEC_NOTBLVAR) return s1; + return SPLIT_FTAVEC_MIXED; +} + +scalarexp_t *split_ftavec_se( + scalarexp_t *se, // the SE to split + bool &fta_forbidden, // return true if some part of se + // is fta-unsafe + int &colref_source, // the tblvar which sources the + // colref, or NOTBLVAR, or MIXED + vector< vector *> &lfta_select_list, + // NULL if the tblvar is not PROTOCOL, + // else build the select list. + ext_fcn_list *Ext_fcns // is the fcn lfta-safe? + ){ +// Return value is the HFTA SE, unless fta_forbidden is true and +// colref_source>=0 and the indicated source is PROTOCOL. +// In that case no split was done, the make_fta_se_ref must +// be done by the caller. + + int p, fcn_id; + vector operand_list; + vector dt_signature; + scalarexp_t *ret_se, *l_se, *r_se; + bool l_forbid, r_forbid, this_forbid; + int l_csource, r_csource, this_csource; + colref_t *new_cr; + scalarexp_t *new_se; + data_type *dt = se->get_data_type(); + + switch(se->get_operator_type()){ + case SE_LITERAL: + fta_forbidden = ! se->get_data_type()->fta_legal_type(); + colref_source = SPLIT_FTAVEC_NOTBLVAR; + ret_se = new scalarexp_t(se->get_literal()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_PARAM: + fta_forbidden = ! se->get_data_type()->fta_legal_type(); + colref_source = SPLIT_FTAVEC_NOTBLVAR; + ret_se = scalarexp_t::make_param_reference(se->get_op().c_str()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_IFACE_PARAM: + fta_forbidden = false; + colref_source = se->get_ifpref()->get_tablevar_ref(); + ret_se = scalarexp_t::make_iface_param_reference(se->get_ifpref()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_COLREF: +// No colref should be forbidden, +// the schema is wrong, the fta_legal_type() fcn is wrong, +// or the source table is actually a stream. +// Issue a warning, but proceed with processing. +// Also, should not be a ref to a gbvar. +// (a gbvar ref only occurs in an aggregation node, +// and these SEs are rehomed, not split. + fta_forbidden = ! se->get_data_type()->fta_legal_type(); + colref_source = se->get_colref()->get_tablevar_ref(); + + if(fta_forbidden && is_PROTOCOL_source(colref_source, lfta_select_list)){ + fprintf(stderr,"WARNING, a PROTOCOL colref is a forbidden data type in split_ftavec_se," + " colref is %s," + " type is %s, line=%d, col=%d\n", + se->get_colref()->to_string().c_str(), + se->get_data_type()->to_string().c_str(), + se->lineno, se->charno + ); + } + + if(se->is_gb()){ + fta_forbidden = true; // eval in hfta. ASSUME make copy as below. + } + + ret_se = new scalarexp_t(se->get_colref()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_UNARY_OP: + l_se = split_ftavec_se(se->get_left_se(), l_forbid, colref_source, lfta_select_list, Ext_fcns); + + this_forbid = ! dt->fta_legal_operation(l_se->get_data_type(), se->get_op()); + +// If this operation is forbidden but the child SE is not, +// AND the colref source in the se is a single PROTOCOL source +// put the child se on the lfta_select_list, create a colref +// which accesses this se, and make it the child of this op. +// Exception : the child se is constant (only literal refs). +// TODO: I think the exception is expressed by is_PROTOCOL_source + if(this_forbid && !l_forbid && is_PROTOCOL_source(colref_source, lfta_select_list)){ + if(!is_literal_or_param_only(l_se)){ + new_se = make_fta_se_ref(lfta_select_list, l_se,colref_source); + ret_se = new scalarexp_t(se->get_op().c_str(), new_se); + } + }else{ + ret_se = new scalarexp_t(se->get_op().c_str(), l_se); + } + ret_se->use_decorations_of(se); + fta_forbidden = this_forbid | l_forbid; + return(ret_se); + + case SE_BINARY_OP: + l_se = split_ftavec_se(se->get_left_se(), l_forbid, l_csource, lfta_select_list, Ext_fcns); + r_se = split_ftavec_se(se->get_right_se(), r_forbid, r_csource, lfta_select_list, Ext_fcns); + + this_forbid = ! dt->fta_legal_operation(l_se->get_data_type(), r_se->get_data_type(), se->get_op()); + colref_source=combine_colref_source(l_csource, r_csource); + +// Replace the left se if the parent must be hfta but the child can +// be lfta. This translates to +// a) result is PROTOCOL and forbidden, but left SE is not forbidden +// OR b) if result is mixed but the left se is PROTOCOL, not forbidden + if( ((this_forbid || r_forbid) && !l_forbid && is_PROTOCOL_source(colref_source, lfta_select_list) ) || + (colref_source==SPLIT_FTAVEC_MIXED && !l_forbid && + is_PROTOCOL_source(l_csource, lfta_select_list)) ){ + if(!is_literal_or_param_only(l_se)){ + new_se = make_fta_se_ref(lfta_select_list, l_se,l_csource); + l_se = new_se; + } + } + +// same logic as for right se. + if( ((this_forbid || l_forbid) && !r_forbid && is_PROTOCOL_source(colref_source, lfta_select_list) ) || + (colref_source==SPLIT_FTAVEC_MIXED && !r_forbid && + is_PROTOCOL_source(r_csource, lfta_select_list)) ){ + if(!is_literal_or_param_only(r_se)){ + new_se = make_fta_se_ref(lfta_select_list, r_se,r_csource); + r_se = new_se; + } + } + + ret_se = new scalarexp_t(se->get_op().c_str(), l_se, r_se); + ret_se->use_decorations_of(se); + fta_forbidden = this_forbid || r_forbid || l_forbid; + + return(ret_se); + + case SE_AGGR_STAR: + case SE_AGGR_SE: + + fprintf(stderr,"INTERNAL ERROR, aggregate ref (%s) in split_ftavec_se." + " line=%d, col=%d\n", + se->get_op().c_str(), + se->lineno, se->charno + ); + exit(1); + break; + + case SE_FUNC: + { + operand_list = se->get_operands(); + vector new_operands; + vector forbidden_op; + vector csource; + + fta_forbidden = false; + colref_source = SPLIT_FTAVEC_NOTBLVAR; + for(p=0;pget_data_type() ); + } + + fcn_id = Ext_fcns->lookup_fcn(se->get_op(), dt_signature); + if( fcn_id < 0 ){ + fprintf(stderr,"ERROR, no external function %s(",se->get_op().c_str()); + int o; + for(o=0;o0) fprintf(stderr,", "); + fprintf(stderr,"%s",operand_list[o]->get_data_type()->to_string().c_str()); + } + fprintf(stderr,") is defined, line %d, char %d\n", se->get_lineno(), se->get_charno() ); + if(fcn_id == -2) fprintf(stderr,"(multiple subsuming functions found)\n"); + return NULL; + } + + fta_forbidden |= (! Ext_fcns->fta_legal(fcn_id)); + +// Replace the non-forbidden operands. +// the forbidden ones are already replaced. + if(fta_forbidden || colref_source == SPLIT_FTAVEC_MIXED){ + for(p=0;pget_op().c_str(), new_operands); + ret_se->use_decorations_of(se); + + return(ret_se); + + } + default: + printf("INTERNAL ERROR in split_ftavec_se: operator type %d\n",se->get_operator_type()); + exit(1); + break; + } + return(NULL); + +} + + +// The predicates have already been +// broken into conjunctions. +// If any part of a conjunction is fta-forbidden, +// it must be executed in the stream operator. +// Else it is executed in the FTA. +// A pre-analysis should determine whether this +// predicate is fta-safe. This procedure will +// assume that it is fta-forbidden and will +// prepare it for execution in the stream. + +predicate_t *split_ftavec_pr(predicate_t *pr, + vector< vector *> &lfta_select_list, + ext_fcn_list *Ext_fcns + ){ + + vector llist; + scalarexp_t *se_l, *se_r; + bool l_forbid, r_forbid; + int l_csource, r_csource; + predicate_t *ret_pr, *pr_l, *pr_r; + vector op_list, new_op_list; + int o; + vector dt_signature; + + + switch(pr->get_operator_type()){ + case PRED_IN: + se_l = split_ftavec_se(pr->get_left_se(), l_forbid, l_csource, lfta_select_list, Ext_fcns); + +// TODO: checking that the se is a PROTOCOL source should +// take care of literal_or_param_only. + if(!l_forbid && is_PROTOCOL_source(l_csource, lfta_select_list)){ + if(!is_literal_or_param_only(se_l)){ + scalarexp_t *new_se = make_fta_se_ref(lfta_select_list, se_l,l_csource); + se_l = new_se; + } + } + ret_pr = new predicate_t(se_l, pr->get_lit_vec()); + + return(ret_pr); + + case PRED_COMPARE: + se_l = split_ftavec_se(pr->get_left_se(), l_forbid, l_csource, lfta_select_list, Ext_fcns); + if(!l_forbid && is_PROTOCOL_source(l_csource, lfta_select_list)){ + if(!is_literal_or_param_only(se_l)){ + scalarexp_t *new_se = make_fta_se_ref(lfta_select_list, se_l,l_csource); + se_l = new_se; + } + } + + se_r = split_ftavec_se(pr->get_right_se(), r_forbid, r_csource, lfta_select_list, Ext_fcns); + if(!r_forbid && is_PROTOCOL_source(r_csource, lfta_select_list)){ + if(!is_literal_or_param_only(se_r)){ + scalarexp_t *new_se = make_fta_se_ref(lfta_select_list, se_r,r_csource); + se_r = new_se; + } + } + + ret_pr = new predicate_t(se_l, pr->get_op().c_str(), se_r); + return(ret_pr); + + case PRED_UNARY_OP: + pr_l = split_ftavec_pr(pr->get_left_pr(), lfta_select_list, Ext_fcns); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l); + return(ret_pr); + + case PRED_BINARY_OP: + pr_l = split_ftavec_pr(pr->get_left_pr(), lfta_select_list, Ext_fcns); + pr_r = split_ftavec_pr(pr->get_right_pr(), lfta_select_list, Ext_fcns); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l, pr_r); + return(ret_pr); + + case PRED_FUNC: +// I can't push the predicate into the lfta, except by +// returning a bool value, and that is not worth the trouble, + op_list = pr->get_op_list(); + for(o=0;oget_op().c_str(), new_op_list); + ret_pr->set_fcn_id(pr->get_fcn_id()); + return(ret_pr); + default: + fprintf(stderr,"INTERNAL ERROR in split_fta_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); + +} + + + +//////////////////////////////////////////////////////////////////////// +/// rehome_hfta_se rehome_hfta_pr +/// This is use to split an sgah operator (aggregation), +/// I just need to make gb, aggr references point to the +/// new gb, aggr table entries. + + +scalarexp_t *rehome_fta_se(scalarexp_t *se, + map< int, scalarexp_t * > *aggr_map + ){ + + int p, fcn_id; + int agr_id; + vector operand_list; + scalarexp_t *ret_se, *l_se, *r_se; + colref_t *new_cr; + scalarexp_t *new_se; + data_type *dt = se->get_data_type(); + vector new_operands; + + switch(se->get_operator_type()){ + case SE_LITERAL: + ret_se = new scalarexp_t(se->get_literal()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_PARAM: + ret_se = scalarexp_t::make_param_reference(se->get_op().c_str()); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_IFACE_PARAM: + ret_se = scalarexp_t::make_iface_param_reference(se->get_ifpref()); + ret_se->use_decorations_of(se); + return(ret_se); + + + + case SE_COLREF: +// Must be a GB REF ... +// I'm assuming that the hfta gbvar table has the +// same sequence of entries as the input query's gbvar table. +// Else I'll need some kind of translation table. + + if(! se->is_gb()){ + fprintf(stderr,"WARNING, a colref is not a gbver ref in rehome_hfta_se" + " type is %s, line=%d, col=%d\n", + se->get_data_type()->to_string().c_str(), + se->lineno, se->charno + ); + } + + ret_se = new scalarexp_t(se->get_colref()); + ret_se->use_decorations_of(se); // just inherit the gbref + return(ret_se); + + case SE_UNARY_OP: + l_se = rehome_fta_se(se->get_left_se(), aggr_map); + + ret_se = new scalarexp_t(se->get_op().c_str(), l_se); + ret_se->use_decorations_of(se); + return(ret_se); + + case SE_BINARY_OP: + l_se = rehome_fta_se(se->get_left_se(), aggr_map); + r_se = rehome_fta_se(se->get_right_se(), aggr_map); + + ret_se = new scalarexp_t(se->get_op().c_str(), l_se, r_se); + ret_se->use_decorations_of(se); + + return(ret_se); + + case SE_AGGR_STAR: + case SE_AGGR_SE: + agr_id = se->get_aggr_ref(); + return (*aggr_map)[agr_id]; + break; + + case SE_FUNC: + agr_id = se->get_aggr_ref(); + if(agr_id >= 0) return (*aggr_map)[agr_id]; + + operand_list = se->get_operands(); + for(p=0;pget_op().c_str(), new_operands); + ret_se->use_decorations_of(se); + + return(ret_se); + + default: + printf("INTERNAL ERROR in rehome_fta_se: operator type %d\n",se->get_operator_type()); + exit(1); + break; + } + return(NULL); + +} + + +// The predicates have already been +// broken into conjunctions. +// If any part of a conjunction is fta-forbidden, +// it must be executed in the stream operator. +// Else it is executed in the FTA. +// A pre-analysis should determine whether this +// predicate is fta-safe. This procedure will +// assume that it is fta-forbidden and will +// prepare it for execution in the stream. + +predicate_t *rehome_fta_pr(predicate_t *pr, + map *aggr_map + ){ + + vector llist; + scalarexp_t *se_l, *se_r; + predicate_t *ret_pr, *pr_l, *pr_r; + vector op_list, new_op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + se_l = rehome_fta_se(pr->get_left_se(), aggr_map); + ret_pr = new predicate_t(se_l, pr->get_lit_vec()); + return(ret_pr); + + case PRED_COMPARE: + se_l = rehome_fta_se(pr->get_left_se(), aggr_map); + se_r = rehome_fta_se(pr->get_right_se(), aggr_map); + ret_pr = new predicate_t(se_l, pr->get_op().c_str(), se_r); + return(ret_pr); + + case PRED_UNARY_OP: + pr_l = rehome_fta_pr(pr->get_left_pr(), aggr_map); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l); + return(ret_pr); + + case PRED_BINARY_OP: + pr_l = rehome_fta_pr(pr->get_left_pr(), aggr_map); + pr_r = rehome_fta_pr(pr->get_right_pr(), aggr_map); + ret_pr = new predicate_t(pr->get_op().c_str(), pr_l, pr_r); + return(ret_pr); + + case PRED_FUNC: + op_list = pr->get_op_list(); + for(o=0;oget_op().c_str(), new_op_list); + ret_pr->set_fcn_id(pr->get_fcn_id()); + return(ret_pr); + + default: + fprintf(stderr,"INTERNAL ERROR in rehome_fta_pr, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + exit(1); + } + + return(0); + +} + + +//////////////////////////////////////////////////////////////////// +///////////////// Create a STREAM table to represent the FTA output. + +table_def *create_attributes(string tname, vector &select_list){ + int s; + + +// Create a new STREAM schema for the output of the FTA. + + field_entry_list *fel = new field_entry_list(); + set ufcns; + for(s=0;sse; + data_type *dt = sel_se->get_data_type(); + +// Grab the annotations of the field. +// As of this writing, the only meaningful annotations +// are whether or not the attribute is temporal. +// There can be an annotation of constant_t, but +// I'll ignore this, it feels like an unsafe assumption + param_list *plist = new param_list(); +// if(dt->is_temporal()){ + vector param_strings = dt->get_param_keys(); + int p; + for(p=0;pget_param_val(param_strings[p]); + if(v != "") + plist->append(param_strings[p].c_str(),v.c_str()); + else + plist->append(param_strings[p].c_str()); + } +// } + +// char access_fcn_name[500]; + string colname = select_list[s]->name; +// sprintf(access_fcn_name,"get_field_%s",colname.c_str()); + string access_fcn_name = "get_field_"+colname; + field_entry *fe = new field_entry( + dt->get_type_str(), colname, access_fcn_name, plist, ufcns + ); + + fel->append_field(fe); + } + + table_def *fta_tbl = new table_def( + tname.c_str(), NULL, NULL, fel, STREAM_SCHEMA + ); + + return(fta_tbl); + +} + +//------------------------------------------------------------------ +// Textual representation of the query node. + + + +string spx_qpn::to_query_string(){ + + string ret = "Select "; + int s; + for(s=0;s0) ret+=", "; + ret += se_to_query_string(select_list[s]->se, NULL); + if(select_list[s]->name != "") ret += " AS "+select_list[s]->name; + } + ret += "\n"; + + ret += "From "+table_name->to_string()+"\n"; + + if(where.size() > 0){ + ret += "Where "; + int w; + for(w=0;w0) ret += " AND "; + ret += "(" + pred_to_query_str(where[w]->pr,NULL) + ")"; + } + ret += "\n"; + } + + return(ret); +} + + + + +string sgah_qpn::to_query_string(){ + + string ret = "Select "; + int s; + for(s=0;s0) ret+=", "; + ret += se_to_query_string(select_list[s]->se, &aggr_tbl); + if(select_list[s]->name != "") ret += " AS "+select_list[s]->name; + } + ret += "\n"; + + ret += "From "+table_name->to_string()+"\n"; + + if(where.size() > 0){ + ret += "Where "; + int w; + for(w=0;w0) ret += " AND "; + ret += "(" + pred_to_query_str(where[w]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + if(gb_tbl.size() > 0){ + ret += "Group By "; + int g; + if(gb_tbl.gb_patterns.size() <= 1 || gb_tbl.gb_entry_type.size()==0){ + for(g=0;g0) ret += ", "; +// if(gb_tbl.get_reftype(g) == GBVAR_SE){ + ret += se_to_query_string(gb_tbl.get_def(g), &aggr_tbl) + " AS "; +// } + ret += gb_tbl.get_name(g); + } + }else{ + int gb_pos = 0; + for(g=0;g0) ret += ", "; + if(gb_tbl.gb_entry_type[g] == ""){ + ret += se_to_query_string(gb_tbl.get_def(gb_pos),&aggr_tbl)+ + " AS "+ gb_tbl.get_name(gb_pos); + gb_pos++; + } + if(gb_tbl.gb_entry_type[g] == "CUBE" || + gb_tbl.gb_entry_type[g] == "ROLLUP"){ + ret += gb_tbl.gb_entry_type[g] + "("; + int gg = 0; + for(gg=0;gg0) ret += ", "; + ret += se_to_query_string(gb_tbl.get_def(gb_pos),&aggr_tbl)+ " AS "+ gb_tbl.get_name(gb_pos); + gb_pos++; + } + ret += ")"; + } + if(gb_tbl.gb_entry_type[g] == "GROUPING_SETS"){ + ret += gb_tbl.gb_entry_type[g] + "("; + int g1, g2; + vector > &local_components = gb_tbl.pattern_components[g]; + for(g1=0;g10) ret+=","; + bool first_field = true; + ret += "\n\t\t("; + for(g2=0;g2<=gb_tbl.gb_entry_count[g];g2++){ + if(local_components[g1][g2]){ + if(!first_field) ret+=", "; + else first_field = false; + ret += gb_tbl.get_name(gb_pos+g2); + } + } + ret += ")"; + } + ret += ") "; + gb_pos += gb_tbl.gb_entry_count[g]; + } + } + } + ret += "\n"; + } + + if(having.size() > 0){ + ret += "Having "; + int h; + for(h=0;h0) ret += " AND "; + ret += "(" + pred_to_query_str(having[h]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + return(ret); +} + + +string rsgah_qpn::to_query_string(){ + + string ret = "Select "; + int s; + for(s=0;s0) ret+=", "; + ret += se_to_query_string(select_list[s]->se, &aggr_tbl); + if(select_list[s]->name != "") ret += " AS "+select_list[s]->name; + } + ret += "\n"; + + ret += "From "+table_name->to_string()+"\n"; + + if(where.size() > 0){ + ret += "Where "; + int w; + for(w=0;w0) ret += " AND "; + ret += "(" + pred_to_query_str(where[w]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + if(gb_tbl.size() > 0){ + ret += "Group By "; + int g; + for(g=0;g0) ret += ", "; +// if(gb_tbl.get_reftype(g) == GBVAR_SE){ + ret += se_to_query_string(gb_tbl.get_def(g), &aggr_tbl)+" AS "; +// } + ret += gb_tbl.get_name(g); + } + ret += "\n"; + } + + if(having.size() > 0){ + ret += "Having "; + int h; + for(h=0;h0) ret += " AND "; + ret += "(" + pred_to_query_str(having[h]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + if(closing_when.size() > 0){ + ret += "Closing_When "; + int h; + for(h=0;h0) ret += " AND "; + ret += "(" + pred_to_query_str(closing_when[h]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + return(ret); +} + + +string sgahcwcb_qpn::to_query_string(){ + + string ret = "Select "; + int s; + for(s=0;s0) ret+=", "; + ret += se_to_query_string(select_list[s]->se, &aggr_tbl); + if(select_list[s]->name != "") ret += " AS "+select_list[s]->name; + } + ret += "\n"; + + ret += "From "+table_name->to_string()+"\n"; + + if(where.size() > 0){ + ret += "Where "; + int w; + for(w=0;w0) ret += " AND "; + ret += "(" + pred_to_query_str(where[w]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + if(gb_tbl.size() > 0){ + ret += "Group By "; + int g; + for(g=0;g0) ret += ", "; +// if(gb_tbl.get_reftype(g) == GBVAR_SE){ + ret += se_to_query_string(gb_tbl.get_def(g), &aggr_tbl) + " AS "; +// } + ret += gb_tbl.get_name(g); + } + ret += "\n"; + } + + if(sg_tbl.size() > 0){ + ret += "Supergroup "; + int g; + bool first_elem = true; + for(g=0;g 0){ + ret += "Having "; + int h; + for(h=0;h0) ret += " AND "; + ret += "(" + pred_to_query_str(having[h]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + + if(cleanwhen.size() > 0){ + ret += "Cleaning_When "; + int h; + for(h=0;h0) ret += " AND "; + ret += "(" + pred_to_query_str(cleanwhen[h]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + if(cleanby.size() > 0){ + ret += "Cleaning_By "; + int h; + for(h=0;h0) ret += " AND "; + ret += "(" + pred_to_query_str(cleanby[h]->pr,&aggr_tbl) + ")"; + } + ret += "\n"; + } + + return(ret); +} + + +string mrg_qpn::to_query_string(){ + + string ret="Merge "; + ret += mvars[0]->to_query_string() + " : " + mvars[1]->to_query_string(); + if(slack != NULL){ + ret += " SLACK "+se_to_query_string(slack, NULL); + } + + ret += "\nFrom "; + int t; + for(t=0;t0) ret += ", "; + ret += fm[t]->to_string(); + } + ret += "\n"; + + return(ret); +} + +string join_eq_hash_qpn::to_query_string(){ + + string ret = "Select "; + int s; + for(s=0;s0) ret+=", "; + ret += se_to_query_string(select_list[s]->se, NULL); + if(select_list[s]->name != "") ret += " AS "+select_list[s]->name; + } + ret += "\n"; + +// NOTE: assuming binary join. + int properties = from[0]->get_property()+2*from[1]->get_property(); + switch(properties){ + case 0: + ret += "INNER_JOIN "; + break; + case 1: + ret += "LEFT_OUTER_JOIN "; + break; + case 2: + ret += "RIGHT_OUTER_JOIN "; + break; + case 3: + ret += "OUTER_JOIN "; + break; + } + + ret += "From "; + int f; + for(f=0;f0) ret+=", "; + ret += from[f]->to_string(); + } + ret += "\n"; + + if(where.size() > 0){ + ret += "Where "; + int w; + for(w=0;w0) ret += " AND "; + ret += "(" + pred_to_query_str(where[w]->pr,NULL) + ")"; + } + ret += "\n"; + } + + return(ret); +} + +string filter_join_qpn::to_query_string(){ + + string ret = "Select "; + int s; + for(s=0;s0) ret+=", "; + ret += se_to_query_string(select_list[s]->se, NULL); + if(select_list[s]->name != "") ret += " AS "+select_list[s]->name; + } + ret += "\n"; + +// NOTE: assuming binary join. + ret += "FILTER_JOIN("+temporal_var->field+","+int_to_string(temporal_range)+") "; + + ret += "From "; + int f; + for(f=0;f0) ret+=", "; + ret += from[f]->to_string(); + } + ret += "\n"; + + if(where.size() > 0){ + ret += "Where "; + int w; + for(w=0;w0) ret += " AND "; + ret += "(" + pred_to_query_str(where[w]->pr,NULL) + ")"; + } + ret += "\n"; + } + + return(ret); +} + + +// ----------------------------------------------------------------- +// Query node subclass specific processing. + + +vector mrg_qpn::split_sources(){ + vector ret; + int i; + +// sanity check + if(fm.size() != mvars.size()){ + fprintf(stderr,"INTERNAL ERROR in mrg_qpn::split_sources. fm.size() = %lu, mvars.size() = %lu\n",fm.size(),mvars.size()); + exit(1); + } + if(fm.size() == 1){ + fprintf(stderr,"INTERNAL ERROR in mrg_qpn::split_sources, fm size is 1.\n"); + exit(1); + } + +/* +int ff; +printf("spliting sources merge node, name = %s, %d sources.\n\t",node_name.c_str(), fm.size()); +for(ff=0;ffto_string().c_str()); +} +printf("\n"); +*/ + +// Handle special cases. + if(fm.size() == 2){ + ret.push_back(this); + return ret; + } + + if(fm.size() == 3){ + mrg_qpn *new_mrg = (mrg_qpn *)this->make_copy("_cH1"); + new_mrg->fm.push_back(this->fm[0]); + new_mrg->fm.push_back(this->fm[1]); + new_mrg->mvars.push_back(this->mvars[0]); + new_mrg->mvars.push_back(this->mvars[1]); + + this->fm.erase(this->fm.begin()); + this->mvars.erase(this->mvars.begin()); + string vname = fm[0]->get_var_name(); + this->fm[0] = new tablevar_t(new_mrg->node_name.c_str()); + this->fm[0]->set_range_var(vname); + this->mvars[0]->set_field(table_layout->get_field_name(merge_fieldpos)); + this->mvars[0]->set_tablevar_ref(0); + this->mvars[1]->set_tablevar_ref(1); + + ret.push_back(new_mrg); + ret.push_back(this); + +/* +printf("split sources %s (%s %s)\n",node_name.c_str(),new_mrg->node_name.c_str(),this->node_name.c_str()); +for(i=0;ifm.size();++i) +printf("\tsource %s var %d (%s, %s) \n",new_mrg->node_name.c_str(),i,new_mrg->fm[i]->to_string().c_str(), new_mrg->mvars[i]->to_string().c_str()); +for(i=0;ifm.size();++i) +printf("\tsource %s var %d (%s, %s) \n",this->node_name.c_str(),i,this->fm[i]->to_string().c_str(), this->mvars[i]->to_string().c_str()); +*/ + + return ret; + } + +// General case. +// divide up the sources between two children. +// Then, recurse on the children. + + mrg_qpn *new_mrg1 = (mrg_qpn *)this->make_copy("_cH1"); + mrg_qpn *new_mrg2 = (mrg_qpn *)this->make_copy("_cH2"); + for(i=0;ifm.size()/2;++i){ + new_mrg1->fm.push_back(this->fm[i]); + new_mrg1->mvars.push_back(this->mvars[i]); +//printf("Pushing %d (%s, %s) to new_mrg1\n",i,fm[i]->to_string().c_str(), mvars[i]->to_string().c_str()); + } + for(;ifm.size();++i){ + new_mrg2->fm.push_back(this->fm[i]); + new_mrg2->mvars.push_back(this->mvars[i]); +//printf("Pushing %d (%s, %s) to new_mrg2\n",i,fm[i]->to_string().c_str(), mvars[i]->to_string().c_str()); + } + for(i=0;imvars.size();++i) + new_mrg1->mvars[i]->set_tablevar_ref(i); + for(i=0;imvars.size();++i) + new_mrg2->mvars[i]->set_tablevar_ref(i); + +// Children created, make this merge them. + fm.clear(); + mvars.clear(); +// var 1 + tablevar_t *tmp_tblvar = new tablevar_t(new_mrg1->node_name.c_str()); + tmp_tblvar->set_range_var("_mrg_var_1"); + fm.push_back(tmp_tblvar); + colref_t *tmp_cref = new colref_t("_mrg_var_1",table_layout->get_field_name(merge_fieldpos).c_str()); + tmp_cref->set_tablevar_ref(0); + mvars.push_back(tmp_cref); +// var 2 + tmp_tblvar = new tablevar_t(new_mrg2->node_name.c_str()); + tmp_tblvar->set_range_var("_mrg_var_2"); + fm.push_back(tmp_tblvar); + tmp_cref = new colref_t("_mrg_var_2",table_layout->get_field_name(merge_fieldpos).c_str()); + tmp_cref->set_tablevar_ref(1); + mvars.push_back(tmp_cref); + + +/* +printf("split sources %s (%s %s)\n",node_name.c_str(),new_mrg1->node_name.c_str(),new_mrg2->node_name.c_str()); +for(i=0;ifm.size();++i) +printf("\tsource %s var %d (%s, %s) \n",new_mrg1->node_name.c_str(),i,new_mrg1->fm[i]->to_string().c_str(), new_mrg1->mvars[i]->to_string().c_str()); +for(i=0;ifm.size();++i) +printf("\tsource %s var %d (%s, %s) \n",new_mrg2->node_name.c_str(),i,new_mrg2->fm[i]->to_string().c_str(), new_mrg2->mvars[i]->to_string().c_str()); +*/ + +// Recurse and put them together + vector st1 = new_mrg1->split_sources(); + ret.insert(ret.end(), st1.begin(), st1.end()); + vector st2 = new_mrg2->split_sources(); + ret.insert(ret.end(), st2.begin(), st2.end()); + + ret.push_back(this); + + return(ret); + +} + + + +//////// Split helper function : resolve interfaces + +vector > get_ifaces(tablevar_t *table, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + vector > basic_ifaces; + int ierr; + if(table->get_ifq()){ + basic_ifaces= ifdb->eval(table->get_interface(),ierr); + if(ierr==1){ + fprintf(stderr,"ERROR, Interface set %s not found.\n",table->get_interface().c_str()); + } + if(ierr==2){ + fprintf(stderr,"ERROR, interface definition file didn't parse.\n"); + } + }else{ + basic_ifaces.push_back(make_pair(table->get_machine(), table->get_interface())); + } + + if(n_virtual_ifaces == 1) + return basic_ifaces; + + int stride = n_virtual_ifaces / hfta_parallelism; + int i,s; + vector > ifaces; + + for(i=0;i(mach,iface+"X"+int_to_string(2*s))); + } + } + + return ifaces; +} + + +///////// Split helper function : compute slack in a generated +///////// merge. + +void mrg_qpn::resolve_slack(scalarexp_t *t_se, string fname, vector > &sources, ifq_t *ifdb, gb_table *gbt){ + int s,e,v; + string es; + +// Find slack divisor, if any. + string fnm; + long long int slack_divisor = find_temporal_divisor(t_se,gbt, fnm); + if(slack_divisor <= 0){ + slack = NULL; + return; + } + +// find max slack in the iface spec + long long int max_slacker = 0, this_slacker; + string rname = "Slack_"+fnm; + for(s=0;s slack_vec = ifdb->get_iface_vals(src_machine, src_iface,rname,e,es); + for(v=0;v max_slacker) + max_slacker = this_slacker; + } + } + } + + if(max_slacker <= 0){ + slack = NULL; + return; + } + +// convert to SE + long long int the_slack=(long long int)(ceil(((double)max_slacker)/((double)slack_divisor))); + char tmps[256]; + sprintf(tmps,"%lld",the_slack); + literal_t *slack_lit = new literal_t(tmps, LITERAL_LONGINT); + slack = new scalarexp_t(slack_lit); +} + + +//------------------------------------------------------------------ +// split a node to extract LFTA components. + + +vector mrg_qpn::split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + // nothing to do, nothing to split, return copy of self. + + hfta_returned = 1; + + vector ret_vec; + + ret_vec.push_back(this); + return(ret_vec); + +} + +vector filter_join_qpn::split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + vector ret_vec; + +// First check if the query can be pushed to the FTA. + bool fta_ok = true; + int s; + for(s=0;sse,NULL, Ext_fcns); + } + int p; + for(p=0;ppr,NULL, Ext_fcns); + } + + if(!fta_ok){ + fprintf(stderr,"ERROR, filter join %s is fta-unsafe.\n",node_name.c_str()); + exit(1); + } + +// Can it be done in a single lfta? +// Get the set of interfaces it accesses. + int ierr; + int si; + vector sel_names; + vector > ifaces = get_ifaces(from[0], ifdb, n_virtual_ifaces, hfta_parallelism, hfta_idx); + if (ifaces.empty()) { + fprintf(stderr,"INTERNAL ERROR in filter_join_qpn::split_node_for_fta - empty interface set\n"); + exit(1); + } + + if(ifaces.size() == 1){ +// Single interface, no need to merge. + hfta_returned = 0; + ret_vec.push_back(this); + int i; + for(i=0;iset_machine(ifaces[0].first); + from[i]->set_interface(ifaces[0].second); + from[i]->set_ifq(false); + } + return(ret_vec); + }else{ +// Multiple interfaces, generate the interface-specific queries plus +// the merge. + hfta_returned = 1; + + vector sel_names; + for(si=0;siset_node_name( node_name ); + else{ + string new_name = "_"+node_name+"_"+ifaces[si].first+"_"+ifaces[si].second; + untaboo(new_name); + fta_node->set_node_name(new_name); + } + sel_names.push_back(fta_node->get_node_name()); + +// Assign the table + int f; + for(f=0;ffrom.push_back(from[f]->duplicate()); + fta_node->from[f]->set_machine(ifaces[si].first); + fta_node->from[f]->set_interface(ifaces[si].second); + fta_node->from[f]->set_ifq(false); + } + fta_node->temporal_var = temporal_var; + fta_node->temporal_range = temporal_range; + + fta_node->use_bloom = use_bloom; + + for(s=0;sselect_list.push_back( dup_select(select_list[s], NULL) ); + } + + for(p=0;ppr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + fta_node->shared_pred.push_back(new_cnf); + fta_node->where.push_back(new_cnf); + } + for(p=0;ppr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + fta_node->pred_t0.push_back(new_cnf); + fta_node->where.push_back(new_cnf); + } + for(p=0;ppr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + fta_node->pred_t1.push_back(new_cnf); + fta_node->where.push_back(new_cnf); + } + for(p=0;ppr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + fta_node->hash_eq.push_back(new_cnf); + fta_node->where.push_back(new_cnf); + } + for(p=0;ppr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + fta_node->postfilter.push_back(new_cnf); + fta_node->where.push_back(new_cnf); + } + +// Xfer all of the parameters. +// Use existing handle annotations. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + fta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + fta_node->definitions = definitions; + if(fta_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + + ret_vec.push_back(fta_node); + } + + mrg_qpn *mrg_node = new mrg_qpn((filter_join_qpn *)ret_vec[0], + node_name, sel_names,ifaces, ifdb); + ret_vec.push_back(mrg_node); + + return(ret_vec); + } + +} + +// Use to search for unresolved interface param refs in an hfta. + +int spx_qpn::count_ifp_refs(set &ifpnames){ + int ret = 0; + int i; + for(i=0;ise,ifpnames); + for(i=0;ipr,ifpnames); + return ret; +} + +int sgah_qpn::count_ifp_refs(set &ifpnames){ + int ret = 0; + int i,j; + for(i=0;ise,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;j &ifpnames){ + int ret = 0; + int i,j; + for(i=0;ise,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;j &ifpnames){ + return 0; +} + +int join_eq_hash_qpn::count_ifp_refs(set &ifpnames){ + int ret = 0; + int i; + for(i=0;ise,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;ipr,ifpnames); + for(i=0;ipr,ifpnames); + return ret; +} + +int filter_join_qpn::count_ifp_refs(set &ifpnames){ + int ret = 0; + int i; + for(i=0;ise,ifpnames); + for(i=0;ipr,ifpnames); + return ret; +} + + +// Resolve interface params to string literals +int filter_join_qpn::resolve_if_params( ifq_t *ifdb, string &err){ + int ret = 0; + int i; + string ifname = from[0]->get_interface(); + string ifmach = from[0]->get_machine(); + for(i=0;ise,ifmach, ifname, ifdb, err) ) + ret = 1; + for(i=0;ipr,ifmach, ifname, ifdb, err)) + ret = 1; + return ret; +} + + +int spx_qpn::resolve_if_params( ifq_t *ifdb, string &err){ + int ret = 0; + int i; + string ifname = table_name->get_interface(); + string ifmach = table_name->get_machine(); + for(i=0;ise,ifmach, ifname, ifdb, err) ) + ret = 1; + for(i=0;ipr,ifmach, ifname, ifdb, err)) + ret = 1; + return ret; +} + +int sgah_qpn::resolve_if_params( ifq_t *ifdb, string &err){ + int ret = 0; + int i,j; + string ifname = table_name->get_interface(); + string ifmach = table_name->get_machine(); + +//printf("Select list has %d elements\n",select_list.size()); + for(i=0;ise,ifmach, ifname, ifdb, err) ){ + ret = 1; + } + } + for(i=0;ipr,ifmach, ifname, ifdb, err) ) + ret = 1; + } + for(i=0;ipr,ifmach, ifname, ifdb, err) ) + ret = 1; + } +//printf("aggr list has %d elements\n",select_list.size()); + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;j spx_qpn::split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + + int i; + vector ret_vec; + +// If the node reads from a stream, don't split. +// int t = Schema->get_table_ref(table_name->get_schema_name()); + int t = table_name->get_schema_ref(); + if(Schema->get_schema_type(t) != PROTOCOL_SCHEMA){ + hfta_returned = 1; + ret_vec.push_back(this); + return(ret_vec); + } + + +// Get the set of interfaces it accesses. + int ierr; + int si; + vector sel_names; + vector > ifaces = get_ifaces(table_name, ifdb, n_virtual_ifaces, hfta_parallelism, hfta_idx); + if (ifaces.empty()) { + fprintf(stderr,"INTERNAL ERROR in spx_qpn::split_node_for_fta - empty interface set\n"); + exit(1); + } + + +// The FTA node, it is always returned. + + spx_qpn *fta_node = new spx_qpn(); + fta_node->table_name = table_name; + +// for colname imputation +// vector fta_flds, stream_flds; + + +// First check if the query can be pushed to the FTA. + bool fta_ok = true; + int s; + for(s=0;sse,NULL, Ext_fcns); + } + int p; + for(p=0;ppr,NULL, Ext_fcns); + } + + if(fta_ok){ +//////////////////////////////////////////////////////////// +// The query can be executed entirely in the FTA. + hfta_returned = 0; + + for(si=0;siset_node_name( node_name ); + else{ + string new_name = "_"+node_name+"_"+ifaces[si].first+"_"+ifaces[si].second; + untaboo(new_name); + fta_node->set_node_name(new_name); + } + sel_names.push_back(fta_node->get_node_name()); + +// Assign the table + fta_node->table_name = table_name->duplicate(); + fta_node->table_name->set_machine(ifaces[si].first); + fta_node->table_name->set_interface(ifaces[si].second); + fta_node->table_name->set_ifq(false); + + for(s=0;sselect_list.push_back( dup_select(select_list[s], NULL) ); + } + for(p=0;ppr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + fta_node->where.push_back(new_cnf); + } + +// Xfer all of the parameters. +// Use existing handle annotations. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + fta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + fta_node->definitions = definitions; + if(fta_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + + ret_vec.push_back(fta_node); + } + + if(ifaces.size() > 1){ + spx_qpn *tmp_spx = (spx_qpn *)(ret_vec[0]); + mrg_qpn *mrg_node = new mrg_qpn(tmp_spx, + node_name, sel_names,ifaces, ifdb); + /* + Do not split sources until we are done with optimizations + vector split_merge = mrg_node->split_sources(); + for(i=0;ito_query_string().c_str() ); + + return(ret_vec); + } + +//////////////////////////////////////////////////// +// The fta must be split. Create a stream node. +// NOTE : I am counting on the single +// table in the from list. (Joins handled in a different operator). + + hfta_returned = 1; + + spx_qpn *stream_node = new spx_qpn(); + stream_node->set_node_name( node_name ); +// Create the tablevar in the stream's FROM clause. +// set the schema name to the name of the LFTA, +// and use the same tablevar name. + stream_node->table_name = new tablevar_t( + ("_fta_"+node_name).c_str() + ); + stream_node->table_name->set_range_var(table_name->get_var_name()); + +// Name the fta + fta_node->set_node_name( "_fta_"+node_name ); + +// table var names of fta, stream. + string fta_var = fta_node->table_name->get_var_name(); + string stream_var = stream_node->table_name->get_var_name(); + +// Set up select list vector + vector< vector *> select_vec; + select_vec.push_back(&(fta_node->select_list)); // only one child + + +// Split the select list into its FTA and stream parts. +// If any part of the SE is fta-unsafe, it will return +// a SE to execute at the stream ref'ing SE's evaluated +// at the fta (which are put on the FTA's select list as a side effect). +// If the SE is fta-safe, put it on the fta select list, make +// a ref to it and put the ref on the stream select list. + for(s=0;sse,fta_forbidden, fta_node->select_list, Ext_fcns +// ); + scalarexp_t *root_se = split_ftavec_se( select_list[s]->se, + fta_forbidden, se_src, select_vec, Ext_fcns + ); +// if(fta_forbidden){ + if(fta_forbidden || se_src == SPLIT_FTAVEC_NOTBLVAR){ + stream_node->select_list.push_back( + new select_element(root_se, select_list[s]->name) + ); + }else{ + scalarexp_t *new_se=make_fta_se_ref(fta_node->select_list,root_se,0); + stream_node->select_list.push_back( + new select_element(new_se, select_list[s]->name) + ); + } + } + + +// The WHERE clause has already been split into a set of clauses +// that are ANDED together. For each clause, check if its FTA-safe. +// If not, split its SE's into fta-safe and stream-executing parts, +// then put a clause which ref's the SEs into the stream. +// Else put it into the LFTA. + predicate_t *pr_root; + bool fta_forbidden; + for(p=0;ppr, NULL, Ext_fcns) ){ + pr_root = split_ftavec_pr(where[p]->pr,select_vec,Ext_fcns); +// pr_root = split_fta_pr( where[p]->pr, fta_node->select_list, Ext_fcns); + fta_forbidden = true; + }else{ + pr_root = dup_pr(where[p]->pr, NULL); + fta_forbidden = false; + } + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + if(fta_forbidden){ + stream_node->where.push_back(cnf_root); + }else{ + fta_node->where.push_back(cnf_root); + } + } + + + +// Divide the parameters among the stream, FTA. +// Currently : assume that the stream receives all parameters +// and parameter updates, incorporates them, then passes +// all of the parameters to the FTA. +// This will need to change (tables, fta-unsafe types. etc.) + +// I will pass on the use_handle_access marking, even +// though the fcn call that requires handle access might +// exist in only one of the parts of the query. +// Parameter manipulation and handle access determination will +// need to be revisited anyway. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + fta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + stream_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + + fta_node->definitions = definitions; fta_node->definitions.erase("_referenced_ifaces"); + stream_node->definitions = definitions; + +// Now split by interfaces + if(ifaces.size() > 1){ + for(si=0;siset_node_name( new_name) ; + sel_names.push_back(subq_node->get_node_name()); + +// Assign the table + subq_node->table_name = fta_node->table_name->duplicate(); + subq_node->table_name->set_machine(ifaces[si].first); + subq_node->table_name->set_interface(ifaces[si].second); + subq_node->table_name->set_ifq(false); + + for(s=0;sselect_list.size();s++){ + subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) ); + } + for(p=0;pwhere.size();p++){ + predicate_t *new_pr = dup_pr(fta_node->where[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + subq_node->where.push_back(new_cnf); + } +// Xfer all of the parameters. +// Use existing handle annotations. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + subq_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + if(subq_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + subq_node->definitions = definitions; subq_node->definitions.erase("_referenced_ifaces"); + + ret_vec.push_back(subq_node); + } + + mrg_qpn *mrg_node = new mrg_qpn((spx_qpn *)(ret_vec[0]), + fta_node->node_name, sel_names, ifaces, ifdb); + /* + Do not split sources until we are done with optimizations + vector split_merge = mrg_node->split_sources(); + for(i=0;itable_name->set_machine(ifaces[0].first); + fta_node->table_name->set_interface(ifaces[0].second); + fta_node->table_name->set_ifq(false); + if(fta_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + ret_vec.push_back(fta_node); + ret_vec.push_back(stream_node); + hfta_returned = 1; + } + +// printf("FTA node is:\n%s\n\n",fta_node->to_query_string().c_str() ); +// printf("Stream node is:\n%s\n\n",stream_node->to_query_string().c_str() ); + + + return(ret_vec); +} + + +/* + Splitting a aggregation+sampling operator. + right now, return an error if any splitting is required. +*/ + +vector sgahcwcb_qpn::split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + + hfta_returned = 1; + + vector ret_vec; + int s, p, g, a, o, i; + int si; + + vector fta_flds, stream_flds; + +// If the node reads from a stream, don't split. +// int t = Schema->get_table_ref(table_name->get_schema_name()); + int t = table_name->get_schema_ref(); + if(Schema->get_schema_type(t) != PROTOCOL_SCHEMA){ + ret_vec.push_back(this); + return(ret_vec); + } + + fprintf(stderr,"ERROR : cannot split a sampling operator (not yet implemented).\n"); + exit(1); + + return ret_vec; + + +} + + +/* + Splitting a running aggregation operator. + The code is almost identical to that of the the sgah operator + except that + - there is no lfta-only option. + - the stream node is rsagh_qpn (lfta is sgah or spx) + - need to handle the closing when (similar to having) +*/ + +vector rsgah_qpn::split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + + hfta_returned = 1; + + vector ret_vec; + int s, p, g, a, o, i; + int si; + + vector fta_flds, stream_flds; + +// If the node reads from a stream, don't split. +// int t = Schema->get_table_ref(table_name->get_schema_name()); + int t = table_name->get_schema_ref(); + if(Schema->get_schema_type(t) != PROTOCOL_SCHEMA){ + ret_vec.push_back(this); + return(ret_vec); + } + +// Get the set of interfaces it accesses. + int ierr; + vector sel_names; + vector > ifaces = get_ifaces(table_name, ifdb, n_virtual_ifaces, hfta_parallelism, hfta_idx); + if (ifaces.empty()) { + fprintf(stderr,"INTERNAL ERROR in rsgah_qpn::split_node_for_fta - empty interface set\n"); + exit(1); + } + + + + +////////////////////////////////////////////////////////////// +/// Split into lfta, hfta. + +// A rsgah node must always be split, +// if for no other reason than to complete the +// partial aggregation. + +// First, determine if the query can be spit into aggr/aggr, +// or if it must be selection/aggr. +// Splitting into selection/aggr is allowed only +// if select_lfta is set. + + + bool select_allowed = definitions.count("select_lfta")>0; + bool select_rqd = false; + + set unsafe_gbvars; // for processing where clause + for(g=0;gerror_code = 1; + this->err_str = tmpstr; + return(ret_vec); + }else{ + select_rqd = true; + unsafe_gbvars.insert(g); + } + } + } + +// Verify that the SEs in the aggregate definitions are fta-safe + for(a=0;aerror_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } + }else{ + select_rqd = true; + } + } + } + +// Verify that all of the ref'd UDAFs can be split. + + for(a=0;aget_superaggr_id(afcn); + int sub_id = Ext_fcns->get_subaggr_id(afcn); + if(super_id < 0 || sub_id < 0){ + if(!select_allowed){ + this->err_str += "ERROR in rsgah_qpn::split_node_for_fta : UDAF "+aggr_tbl.get_op(a)+" doesn't have sub/super UDAFS so it can't be split, but select_lfta is not enabled.\n"; + this->error_code = 1; + return(ret_vec); + }else{ + select_rqd = true; + } + } + } + } + + for(p=0;ppr, &aggr_tbl, Ext_fcns) ){ + if(!select_allowed){ + sprintf(tmpstr,"ERROR in rsgah_qpn::split_node_for_fta : all of the WHERE predicate must be FTA-safe, but select_lfta is not enabled (%s).\n", + pred_to_query_str(where[p]->pr,&aggr_tbl).c_str() + ); + this->error_code = 1; + this->err_str = tmpstr; + return(ret_vec); + }else{ + select_rqd = true; + } + } + } + + + if(! select_rqd){ + +///////////////////////////////////////////////////// +// Split into aggr/aggr. + + + + + + sgah_qpn *fta_node = new sgah_qpn(); + fta_node->table_name = table_name; + fta_node->set_node_name( "_fta_"+node_name ); + fta_node->table_name->set_range_var(table_name->get_var_name()); + + + rsgah_qpn *stream_node = new rsgah_qpn(); + stream_node->table_name = new tablevar_t( ("_fta_"+node_name).c_str()); + stream_node->set_node_name( node_name ); + stream_node->table_name->set_range_var(table_name->get_var_name()); + +// First, process the group-by variables. +// The fta must supply the values of all the gbvars. +// If a gb is computed, the computation must be +// performed at the FTA, so the SE must be FTA-safe. +// Nice side effect : the gbvar table contains +// matching entries for the original query, the lfta query, +// and the hfta query. So gbrefs in the new queries are set +// correctly just by inheriting the gbrefs from the old query. +// If this property changed, I'll need translation tables. + + + for(g=0;ggb_tbl.add_gb_var( + gb_tbl.get_name(g), gb_tbl.get_tblvar_ref(g), gbvar_def, gb_tbl.get_reftype(g) + ); + +// Insert a ref to the value of the gbvar into the lfta select list. + colref_t *new_cr = new colref_t(gb_tbl.get_name(g).c_str() ); + scalarexp_t *gbvar_fta = new scalarexp_t(new_cr); + gbvar_fta->set_gb_ref(g); + gbvar_fta->set_data_type( gb_tbl.get_def(g)->get_data_type() ); + scalarexp_t *gbvar_stream = make_fta_se_ref(fta_node->select_list, gbvar_fta,0); + +// Insert the corresponding gbvar ref (gbvar_stream) into the stream. + gbvar_stream->set_gb_ref(-1); // used as GBvar def + stream_node->gb_tbl.add_gb_var( + gbvar_stream->get_colref()->get_field(), -1, gbvar_stream, gb_tbl.get_reftype(g) + ); + + } + +// SEs in the aggregate definitions. +// They are all safe, so split them up for later processing. + map hfta_aggr_se; + for(a=0;aaggr_tbl), &(fta_node->aggr_tbl) , + fta_node->select_list, + hfta_aggr_se, + Ext_fcns + ); + } + + +// Next, the select list. + + for(s=0;sse, &hfta_aggr_se); + stream_node->select_list.push_back( + new select_element(root_se, select_list[s]->name)); + } + + + +// All the predicates in the where clause must execute +// in the fta. + + for(p=0;ppr, &aggr_tbl); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + fta_node->where.push_back(new_cnf); + } + +// All of the predicates in the having clause must +// execute in the stream node. + + for(p=0;ppr, &hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + stream_node->having.push_back(cnf_root); + } + +// All of the predicates in the closing when clause must +// execute in the stream node. + + for(p=0;ppr,&hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + stream_node->closing_when.push_back(cnf_root); + } + + +// Divide the parameters among the stream, FTA. +// Currently : assume that the stream receives all parameters +// and parameter updates, incorporates them, then passes +// all of the parameters to the FTA. +// This will need to change (tables, fta-unsafe types. etc.) + +// I will pass on the use_handle_access marking, even +// though the fcn call that requires handle access might +// exist in only one of the parts of the query. +// Parameter manipulation and handle access determination will +// need to be revisited anyway. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + fta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + stream_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + fta_node->definitions = definitions; fta_node->definitions.erase("_referenced_ifaces"); + stream_node->definitions = definitions; + +// Now split by interfaces XXXX + if(ifaces.size() > 1){ + for(si=0;siset_node_name( new_name) ; + sel_names.push_back(subq_node->get_node_name()); + +// Assign the table + subq_node->table_name = fta_node->table_name->duplicate(); + subq_node->table_name->set_machine(ifaces[si].first); + subq_node->table_name->set_interface(ifaces[si].second); + subq_node->table_name->set_ifq(false); + +// the GB vars. + for(g=0;ggb_tbl.size();g++){ +// Insert the gbvar into the lfta. + scalarexp_t *gbvar_def = dup_se(fta_node->gb_tbl.get_def(g), NULL); + subq_node->gb_tbl.add_gb_var( + fta_node->gb_tbl.get_name(g), fta_node->gb_tbl.get_tblvar_ref(g), gbvar_def, fta_node->gb_tbl.get_reftype(g) + ); + } + +// Insert the aggregates + for(a=0;aaggr_tbl.size();++a){ + subq_node->aggr_tbl.add_aggr(fta_node->aggr_tbl.duplicate(a)); + } + + for(s=0;sselect_list.size();s++){ + subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) ); + } + for(p=0;pwhere.size();p++){ + predicate_t *new_pr = dup_pr(fta_node->where[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + subq_node->where.push_back(new_cnf); + } + for(p=0;phaving.size();p++){ + predicate_t *new_pr = dup_pr(fta_node->having[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + subq_node->having.push_back(new_cnf); + } +// Xfer all of the parameters. +// Use existing handle annotations. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + subq_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + subq_node->definitions = definitions; subq_node->definitions.erase("_referenced_ifaces"); + if(subq_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + + ret_vec.push_back(subq_node); + } + + mrg_qpn *mrg_node = new mrg_qpn((sgah_qpn *)(ret_vec[0]), + fta_node->node_name, sel_names, ifaces, ifdb); + + /* + Do not split sources until we are done with optimizations + vector split_merge = mrg_node->split_sources(); + for(i=0;itable_name->set_machine(ifaces[0].first); + fta_node->table_name->set_interface(ifaces[0].second); + fta_node->table_name->set_ifq(false); + if(fta_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + ret_vec.push_back(fta_node); + ret_vec.push_back(stream_node); + hfta_returned = 1; + } + + +// ret_vec.push_back(fta_node); +// ret_vec.push_back(stream_node); + + + return(ret_vec); + + } + +///////////////////////////////////////////////////////////////////// +/// Split into selection LFTA, aggregation HFTA. + + spx_qpn *fta_node = new spx_qpn(); + fta_node->table_name = table_name; + fta_node->set_node_name( "_fta_"+node_name ); + fta_node->table_name->set_range_var(table_name->get_var_name()); + + + rsgah_qpn *stream_node = new rsgah_qpn(); + stream_node->table_name = new tablevar_t( ("_fta_"+node_name).c_str()); + stream_node->set_node_name( node_name ); + stream_node->table_name->set_range_var(table_name->get_var_name()); + + + vector< vector *> select_vec; + select_vec.push_back(&(fta_node->select_list)); // only one child + +// Process the gbvars. Split their defining SEs. + for(g=0;ggb_tbl.add_gb_var( + gb_tbl.get_name(g),gb_tbl.get_tblvar_ref(g),gbvar_se,gb_tbl.get_reftype(g) + ); + }else{ + scalarexp_t *new_se=make_fta_se_ref(fta_node->select_list,gbvar_se,0); + stream_node->gb_tbl.add_gb_var( + gb_tbl.get_name(g),gb_tbl.get_tblvar_ref(g),new_se,gb_tbl.get_reftype(g) + ); + } + } + +// Process the aggregate table. +// Copy to stream, split the SEs. + map hfta_aggr_se; // for rehome + for(a=0;aaggr_tbl.add_aggr(aggr_tbl.get_op(a),NULL, false); + hse=scalarexp_t::make_star_aggr(aggr_tbl.get_op(a).c_str()); + }else{ + bool fta_forbidden = false; + int se_src = SPLIT_FTAVEC_NOTBLVAR; + + scalarexp_t *agg_se = split_ftavec_se( aggr_tbl.get_aggr_se(a), + fta_forbidden, se_src, select_vec, Ext_fcns + ); +// if(fta_forbidden) ( + if(fta_forbidden || se_src == SPLIT_FTAVEC_NOTBLVAR){ + stream_node->aggr_tbl.add_aggr(aggr_tbl.get_op(a), agg_se,false); + hse=scalarexp_t::make_se_aggr(aggr_tbl.get_op(a).c_str(),agg_se); + }else{ + scalarexp_t *new_se=make_fta_se_ref(fta_node->select_list,agg_se,0); + stream_node->aggr_tbl.add_aggr(aggr_tbl.get_op(a), new_se,false); + hse=scalarexp_t::make_se_aggr(aggr_tbl.get_op(a).c_str(),new_se); + } + } + hse->set_data_type(aggr_tbl.get_data_type(a)); + hse->set_aggr_id(a); + hfta_aggr_se[a]=hse; + }else{ + vector opl = aggr_tbl.get_operand_list(a); + vector new_opl; + for(o=0;oselect_list,agg_se,0); + new_opl.push_back(new_se); + } + } + stream_node->aggr_tbl.add_aggr(aggr_tbl.get_op(a), aggr_tbl.get_fcn_id(a), new_opl, aggr_tbl.get_storage_type(a),false, false,aggr_tbl.has_bailout(a)); + hse = new scalarexp_t(aggr_tbl.get_op(a).c_str(),new_opl); + hse->set_data_type(Ext_fcns->get_fcn_dt(aggr_tbl.get_fcn_id(a))); + hse->set_fcn_id(aggr_tbl.get_fcn_id(a)); + hse->set_aggr_id(a); + hfta_aggr_se[a]=hse; + } + } + + +// Process the WHERE clause. +// If it is fta-safe AND it refs only fta-safe gbvars, +// then expand the gbvars and put it into the lfta. +// Else, split it into an hfta predicate ref'ing +// se's computed partially in the lfta. + + predicate_t *pr_root; + bool fta_forbidden; + for(p=0;ppr, NULL, Ext_fcns) || contains_gb_pr(where[p]->pr, unsafe_gbvars) ){ + pr_root = split_ftavec_pr(where[p]->pr,select_vec,Ext_fcns); + fta_forbidden = true; + }else{ + pr_root = dup_pr(where[p]->pr, NULL); + expand_gbvars_pr(pr_root, gb_tbl); + fta_forbidden = false; + } + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + if(fta_forbidden){ + stream_node->where.push_back(cnf_root); + }else{ + fta_node->where.push_back(cnf_root); + } + } + + +// Process the Select clause, rehome it on the +// new defs. + for(s=0;sse, &hfta_aggr_se); + stream_node->select_list.push_back( + new select_element(root_se, select_list[s]->name)); + } + + +// Process the Having clause + +// All of the predicates in the having clause must +// execute in the stream node. + + for(p=0;ppr, &hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + stream_node->having.push_back(cnf_root); + } +// Same for closing when + for(p=0;ppr,&hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + stream_node->closing_when.push_back(cnf_root); + } + + +// Handle parameters and a few last details. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + fta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + stream_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + + fta_node->definitions = definitions; fta_node->definitions.erase("_referenced_ifaces"); + stream_node->definitions = definitions; + +// Now split by interfaces YYYY + if(ifaces.size() > 1){ + for(si=0;siset_node_name( new_name) ; + sel_names.push_back(subq_node->get_node_name()); + +// Assign the table + subq_node->table_name = fta_node->table_name->duplicate(); + subq_node->table_name->set_machine(ifaces[si].first); + subq_node->table_name->set_interface(ifaces[si].second); + subq_node->table_name->set_ifq(false); + + for(s=0;sselect_list.size();s++){ + subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) ); + } + for(p=0;pwhere.size();p++){ + predicate_t *new_pr = dup_pr(fta_node->where[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + subq_node->where.push_back(new_cnf); + } +// Xfer all of the parameters. +// Use existing handle annotations. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + subq_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + subq_node->definitions = definitions; subq_node->definitions.erase("_referenced_ifaces"); + if(subq_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + + ret_vec.push_back(subq_node); + } + + mrg_qpn *mrg_node = new mrg_qpn((spx_qpn *)(ret_vec[0]), + fta_node->node_name, sel_names, ifaces, ifdb); + /* + Do not split sources until we are done with optimizations + vector split_merge = mrg_node->split_sources(); + for(i=0;itable_name->set_machine(ifaces[0].first); + fta_node->table_name->set_interface(ifaces[0].second); + fta_node->table_name->set_ifq(false); + if(fta_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + ret_vec.push_back(fta_node); + ret_vec.push_back(stream_node); + hfta_returned = 1; + } + + return(ret_vec); + +} + + +/* + Splitting an aggregation operator + + An aggregation operator can reference + literals, parameters, colrefs, group-by vars, aggregates, + operators, functions + + an aggregation contains + A selection list of SEs + A where list of predicates + A list group-by variable definition + A list of aggregates to be computed + A HAVING list of predicates. + + Aggregation involves two phases: + 1) given an input tuple, determine if it satisfies all of + the WHERE predicates. If so, compute the group. + Look up the group, update its aggregates. + 2) given a closed group and its aggregates, determine + if these values satisfy all of the HAVING predicates. + If so, evaluate the SEs on the selection list from the + group and its aggregates. + The two-phase nature of aggregation places restrictions on + what can be referenced by different components of the operator + (in addition to functions and operators). + - group-by variables : literals, parameters, colrefs + - WHERE predicates : group-by vars, literals, params, colrefs + - HAVING predicates : group-by vars, literals, params, aggregates + - Selection list SEs : group-by vars, literals, params, aggregates + + Splitting an aggregation operator into an LFTA/HFTA part + involves performing partial aggregation at the LFTA and + completing the aggregation at the HFTA. + - given a tuple, the LFTA part evaluates the WHERE clause, + and if it is satisfied, computes the group. lookup the group + and update the aggregates. output the group and its partial + aggregates + - Given a partial aggregate from the LFTA, look up the group and + update its aggregates. When the group is closed, evalute + the HAVING clause and the SEs on the selection list. + THEREFORE the selection list of the LFTA must consist of the + group-by variables and the set of (bare) subaggregate values + necessary to compute the super aggregates. + Unlike the case with the SPX operator, the SE splitting point + is at the GBvar and the aggregate value level. + + ALGORITHM: + For each group-by variable + Put the GB variable definition in the LFTA GBVAR list. + Put the GBVAR in the LFTA selection list (as an SE). + Put a reference to that GBVAR in the HFTA GBVAR list. + For each aggregate + Split the aggregate into a superaggregate and a subaggregate. + The SE of the superaggregate references the subaggregate value. + (this will need modifications for MF aggregation) + For each SE in the selection list, HAVING predicate + Make GBVAR references point to the new GBVAR + make the aggregate value references point to the new aggregates. + + SEs are not so much split as their ref's are changed. + + TODO: insert tablevar names into the colrefs. +*/ + + + +vector sgah_qpn::split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + + hfta_returned = 1; + + vector ret_vec; + int s, p, g, a, o, i; + int si; + + vector fta_flds, stream_flds; + +// If the node reads from a stream, don't split. +// int t = Schema->get_table_ref(table_name->get_schema_name()); + int t = table_name->get_schema_ref(); + if(Schema->get_schema_type(t) != PROTOCOL_SCHEMA){ + ret_vec.push_back(this); + return(ret_vec); + } + +// Get the set of interfaces it accesses. + int ierr; + vector sel_names; + vector > ifaces = get_ifaces(table_name, ifdb, n_virtual_ifaces, hfta_parallelism, hfta_idx); + if (ifaces.empty()) { + fprintf(stderr,"INTERNAL ERROR in sgah_qpn::split_node_for_fta - empty interface set\n"); + exit(1); + } + + + +////////////////////////////////////////////// +// Is this LFTA-only? + if(definitions.count("lfta_aggregation")>0){ +// Yes. Ensure that everything is lfta-safe. + +// Check only one interface is accessed. + if(ifaces.size()>1){ + this->err_str = "ERROR, group-by query "+node_name+" is lfta-only, but it accesses more than one interface:\n"; + for(si=0;sierr_str += "\t"+ifaces[si].first+"."+ifaces[si].second+"\n"; + this->error_code = 2; + return(ret_vec); + } + +// Check the group-by attributes + for(g=0;gerror_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } + } + +// Verify that the SEs in the aggregate definitions are fta-safe + for(a=0;aerror_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } + } + if(! aggr_tbl.fta_legal(a,Ext_fcns)){ + if(! check_fta_forbidden_se(aggr_tbl.get_aggr_se(a), &aggr_tbl, Ext_fcns)){ + sprintf(tmpstr,"ERROR in sgah_qpn::split_node_for_fta : aggregate (%s) has LFTA-unsafe aggregate and the query is lfta-only (%s).\n", + aggr_tbl.get_op(a).c_str(), se_to_query_string(aggr_tbl.get_aggr_se(a), &aggr_tbl).c_str() + ); + this->error_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } + } + } + +// Ensure that all the aggregates are fta-safe .... + +// select list + + for(s=0;sse,NULL, Ext_fcns)){ + sprintf(tmpstr,"ERROR in sgah_qpn::split_node_for_fta : all of the WHERE predicate must be LFTA-safe and the query is lfta-only (%s).\n", + pred_to_query_str(where[p]->pr,&aggr_tbl).c_str() + ); + this->error_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } + } + +// where predicate + + for(p=0;ppr, &aggr_tbl, Ext_fcns) ){ + sprintf(tmpstr,"ERROR in sgah_qpn::split_node_for_fta : all of the WHERE predicate must be LFTA-safe and the query is lfta-only (%s).\n", + pred_to_query_str(where[p]->pr,&aggr_tbl).c_str() + ); + this->error_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } + } + + +// having predicate + if(having.size()>0){ + sprintf(tmpstr,"ERROR in sgah_qpn::split_node_for_fta : the query is lfta-only, so it can't have a HAVING clause.(%s).\n", + pred_to_query_str(where[p]->pr,&aggr_tbl).c_str() + ); + this->error_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } +// The query is lfta safe, return it. + + hfta_returned = 0; + ret_vec.push_back(this); + return(ret_vec); + } + +////////////////////////////////////////////////////////////// +/// Split into lfta, hfta. + +// A sgah node must always be split, +// if for no other reason than to complete the +// partial aggregation. + +// First, determine if the query can be spit into aggr/aggr, +// or if it must be selection/aggr. +// Splitting into selection/aggr is allowed only +// if select_lfta is set. + + + bool select_allowed = definitions.count("select_lfta")>0; + bool select_rqd = false; + + set unsafe_gbvars; // for processing where clause + for(g=0;gerror_code = 1; + this->err_str = tmpstr; + return(ret_vec); + }else{ + select_rqd = true; + unsafe_gbvars.insert(g); + } + } + } + +// Verify that the SEs in the aggregate definitions are fta-safe + for(a=0;aerror_code = 1; + this->err_str = tmpstr; + return(ret_vec); + } + }else{ + select_rqd = true; + } + } + } + +// Verify that all of the ref'd UDAFs can be split. + + for(a=0;aget_superaggr_id(afcn); + int sub_id = Ext_fcns->get_subaggr_id(afcn); + if(super_id < 0 || sub_id < 0){ + if(!select_allowed){ + this->err_str += "ERROR in sgah_qpn::split_node_for_fta : UDAF "+aggr_tbl.get_op(a)+" doesn't have sub/super UDAFS so it can't be split, but select_lfta is not enabled.\n"; + this->error_code = 1; + return(ret_vec); + }else{ + select_rqd = true; + } + } + } + } + + for(p=0;ppr, &aggr_tbl, Ext_fcns) ){ + if(!select_allowed){ + sprintf(tmpstr,"ERROR in sgah_qpn::split_node_for_fta : all of the WHERE predicate must be FTA-safe, but select_lfta is not enabled (%s).\n", + pred_to_query_str(where[p]->pr,&aggr_tbl).c_str() + ); + this->error_code = 1; + this->err_str = tmpstr; + return(ret_vec); + }else{ + select_rqd = true; + } + } + } + + + if(! select_rqd){ + +///////////////////////////////////////////////////// +// Split into aggr/aggr. + + + + + + sgah_qpn *fta_node = new sgah_qpn(); + fta_node->table_name = table_name; + fta_node->set_node_name( "_fta_"+node_name ); + fta_node->table_name->set_range_var(table_name->get_var_name()); + + + sgah_qpn *stream_node = new sgah_qpn(); + stream_node->table_name = new tablevar_t( ("_fta_"+node_name).c_str()); + stream_node->set_node_name( node_name ); + stream_node->table_name->set_range_var(table_name->get_var_name()); + +// allowed stream disorder. Default is 2, +// can override with max_lfta_disorder setting. +// Also limit the hfta disorder, set to lfta disorder + 1. +// can override with max_hfta_disorder. + + fta_node->lfta_disorder = 2; + if(this->get_val_of_def("max_lfta_disorder") != ""){ + int d = atoi(this->get_val_of_def("max_lfta_disorder").c_str() ); + if(d<1){ + fprintf(stderr,"Warning, max_lfta_disorder in node %s is %d, must be at least 1, ignoring.\n",node_name.c_str(), d); + }else{ + fta_node->lfta_disorder = d; +printf("node %s setting lfta_disorder = %d\n",node_name.c_str(),fta_node->lfta_disorder); + } + } + if(fta_node->lfta_disorder > 1) + stream_node->hfta_disorder = fta_node->lfta_disorder + 1; + else + stream_node->hfta_disorder = 1; + + if(this->get_val_of_def("max_hfta_disorder") != ""){ + int d = atoi(this->get_val_of_def("max_hfta_disorder").c_str() ); + if(dlfta_disorder){ + fprintf(stderr,"Warning, max_hfta_disorder in node %s is %d, must be at least the max lfta disorder %d, ignoring.\n",node_name.c_str(), d,fta_node->lfta_disorder); + }else{ + fta_node->lfta_disorder = d; + } + if(fta_node->lfta_disorder < fta_node->hfta_disorder){ + fta_node->hfta_disorder = fta_node->lfta_disorder + 1; + } + } + +// First, process the group-by variables. +// The fta must supply the values of all the gbvars. +// If a gb is computed, the computation must be +// performed at the FTA, so the SE must be FTA-safe. +// Nice side effect : the gbvar table contains +// matching entries for the original query, the lfta query, +// and the hfta query. So gbrefs in the new queries are set +// correctly just by inheriting the gbrefs from the old query. +// If this property changed, I'll need translation tables. + + + for(g=0;ggb_tbl.add_gb_var( + gb_tbl.get_name(g), gb_tbl.get_tblvar_ref(g), gbvar_def, gb_tbl.get_reftype(g) + ); + +// Insert a ref to the value of the gbvar into the lfta select list. + colref_t *new_cr = new colref_t(gb_tbl.get_name(g).c_str() ); + scalarexp_t *gbvar_fta = new scalarexp_t(new_cr); + gbvar_fta->set_gb_ref(g); + gbvar_fta->set_data_type( gb_tbl.get_def(g)->get_data_type() ); + scalarexp_t *gbvar_stream = make_fta_se_ref(fta_node->select_list, gbvar_fta,0); + +// Insert the corresponding gbvar ref (gbvar_stream) into the stream. + gbvar_stream->set_gb_ref(-1); // used as GBvar def + stream_node->gb_tbl.add_gb_var( + gbvar_stream->get_colref()->get_field(), -1, gbvar_stream, gb_tbl.get_reftype(g) + ); + } +// multiple aggregation patterns, if any, go with the hfta + stream_node->gb_tbl.set_pattern_info( &gb_tbl); + +// SEs in the aggregate definitions. +// They are all safe, so split them up for later processing. + map hfta_aggr_se; + for(a=0;aaggr_tbl), &(fta_node->aggr_tbl) , + fta_node->select_list, + hfta_aggr_se, + Ext_fcns + ); +/* +// OLD TRACING CODE + +int ii; +for(ii=0;iiselect_list.size();++ii){ + if(iiselect_list.size()) + printf("%s\n",fta_node->select_list[ii]->to_string().c_str()); + else + printf(".\n"); +} +printf("hfta aggregates are:"); +for(ii=0;iiaggr_tbl.size();++ii){ + printf(" %s",stream_node->aggr_tbl.get_op(ii).c_str()); +} +printf("\nlfta aggregates are:"); +for(ii=0;iiaggr_tbl.size();++ii){ + printf(" %s",fta_node->aggr_tbl.get_op(ii).c_str()); +} +printf("\n\n"); +*/ + + } + + +// Next, the select list. + + for(s=0;sse, &hfta_aggr_se); + stream_node->select_list.push_back( + new select_element(root_se, select_list[s]->name)); + } + + + +// All the predicates in the where clause must execute +// in the fta. + + for(p=0;ppr, &aggr_tbl); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + fta_node->where.push_back(new_cnf); + } + +// All of the predicates in the having clause must +// execute in the stream node. + + for(p=0;ppr, &hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + stream_node->having.push_back(cnf_root); + } + + +// Divide the parameters among the stream, FTA. +// Currently : assume that the stream receives all parameters +// and parameter updates, incorporates them, then passes +// all of the parameters to the FTA. +// This will need to change (tables, fta-unsafe types. etc.) + +// I will pass on the use_handle_access marking, even +// though the fcn call that requires handle access might +// exist in only one of the parts of the query. +// Parameter manipulation and handle access determination will +// need to be revisited anyway. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + fta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + stream_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + fta_node->definitions = definitions; fta_node->definitions.erase("_referenced_ifaces"); + stream_node->definitions = definitions; + +// Now split by interfaces XXXX + if(ifaces.size() > 1){ + for(si=0;siset_node_name( new_name) ; + sel_names.push_back(subq_node->get_node_name()); + +// Assign the table + subq_node->table_name = fta_node->table_name->duplicate(); + subq_node->table_name->set_machine(ifaces[si].first); + subq_node->table_name->set_interface(ifaces[si].second); + subq_node->table_name->set_ifq(false); + +// the GB vars. + for(g=0;ggb_tbl.size();g++){ +// Insert the gbvar into the lfta. + scalarexp_t *gbvar_def = dup_se(fta_node->gb_tbl.get_def(g), NULL); + subq_node->gb_tbl.add_gb_var( + fta_node->gb_tbl.get_name(g), fta_node->gb_tbl.get_tblvar_ref(g), gbvar_def, fta_node->gb_tbl.get_reftype(g) + ); + } + +// Insert the aggregates + for(a=0;aaggr_tbl.size();++a){ + subq_node->aggr_tbl.add_aggr(fta_node->aggr_tbl.duplicate(a)); + } + + for(s=0;sselect_list.size();s++){ + subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) ); + } + for(p=0;pwhere.size();p++){ + predicate_t *new_pr = dup_pr(fta_node->where[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + subq_node->where.push_back(new_cnf); + } + for(p=0;phaving.size();p++){ + predicate_t *new_pr = dup_pr(fta_node->having[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + subq_node->having.push_back(new_cnf); + } +// Xfer all of the parameters. +// Use existing handle annotations. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + subq_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + subq_node->definitions = definitions; subq_node->definitions.erase("_referenced_ifaces"); + if(subq_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + +// THe disorder + subq_node->lfta_disorder = fta_node->lfta_disorder; + + ret_vec.push_back(subq_node); + } + + mrg_qpn *mrg_node = new mrg_qpn((sgah_qpn *)(ret_vec[0]), + fta_node->node_name, sel_names, ifaces, ifdb); + mrg_node->set_disorder(fta_node->lfta_disorder); + + /* + Do not split sources until we are done with optimizations + vector split_merge = mrg_node->split_sources(); + for(i=0;itable_name->set_machine(ifaces[0].first); + fta_node->table_name->set_interface(ifaces[0].second); + fta_node->table_name->set_ifq(false); + if(fta_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + ret_vec.push_back(fta_node); + ret_vec.push_back(stream_node); + hfta_returned = 1; + } + + +// ret_vec.push_back(fta_node); +// ret_vec.push_back(stream_node); + + + return(ret_vec); + + } + +///////////////////////////////////////////////////////////////////// +/// Split into selection LFTA, aggregation HFTA. + + spx_qpn *fta_node = new spx_qpn(); + fta_node->table_name = table_name; + fta_node->set_node_name( "_fta_"+node_name ); + fta_node->table_name->set_range_var(table_name->get_var_name()); + + + sgah_qpn *stream_node = new sgah_qpn(); + stream_node->table_name = new tablevar_t( ("_fta_"+node_name).c_str()); + stream_node->set_node_name( node_name ); + stream_node->table_name->set_range_var(table_name->get_var_name()); + + + vector< vector *> select_vec; + select_vec.push_back(&(fta_node->select_list)); // only one child + +// Process the gbvars. Split their defining SEs. + for(g=0;ggb_tbl.add_gb_var( + gb_tbl.get_name(g),gb_tbl.get_tblvar_ref(g),gbvar_se,gb_tbl.get_reftype(g) + ); + }else{ + scalarexp_t *new_se=make_fta_se_ref(fta_node->select_list,gbvar_se,0); + stream_node->gb_tbl.add_gb_var( + gb_tbl.get_name(g),gb_tbl.get_tblvar_ref(g),new_se,gb_tbl.get_reftype(g) + ); + } + } + stream_node->gb_tbl.set_pattern_info( &gb_tbl); + +// Process the aggregate table. +// Copy to stream, split the SEs. + map hfta_aggr_se; // for rehome + for(a=0;aaggr_tbl.add_aggr(aggr_tbl.get_op(a),NULL, false); + hse=scalarexp_t::make_star_aggr(aggr_tbl.get_op(a).c_str()); + }else{ + bool fta_forbidden = false; + int se_src = SPLIT_FTAVEC_NOTBLVAR; + + scalarexp_t *agg_se = split_ftavec_se( aggr_tbl.get_aggr_se(a), + fta_forbidden, se_src, select_vec, Ext_fcns + ); +// if(fta_forbidden) ( + if(fta_forbidden || se_src == SPLIT_FTAVEC_NOTBLVAR){ + stream_node->aggr_tbl.add_aggr(aggr_tbl.get_op(a), agg_se,false); + hse=scalarexp_t::make_se_aggr(aggr_tbl.get_op(a).c_str(),agg_se); + }else{ + scalarexp_t *new_se=make_fta_se_ref(fta_node->select_list,agg_se,0); + stream_node->aggr_tbl.add_aggr(aggr_tbl.get_op(a), new_se,false); + hse=scalarexp_t::make_se_aggr(aggr_tbl.get_op(a).c_str(),new_se); + } + } + hse->set_data_type(aggr_tbl.get_data_type(a)); + hse->set_aggr_id(a); + hfta_aggr_se[a]=hse; + }else{ + vector opl = aggr_tbl.get_operand_list(a); + vector new_opl; + for(o=0;oselect_list,agg_se,0); + new_opl.push_back(new_se); + } + } + stream_node->aggr_tbl.add_aggr(aggr_tbl.get_op(a), aggr_tbl.get_fcn_id(a), new_opl, aggr_tbl.get_storage_type(a),false, false,aggr_tbl.has_bailout(a)); + hse = new scalarexp_t(aggr_tbl.get_op(a).c_str(),new_opl); + hse->set_data_type(Ext_fcns->get_fcn_dt(aggr_tbl.get_fcn_id(a))); + hse->set_fcn_id(aggr_tbl.get_fcn_id(a)); + hse->set_aggr_id(a); + hfta_aggr_se[a]=hse; + } + } + + +// Process the WHERE clause. +// If it is fta-safe AND it refs only fta-safe gbvars, +// then expand the gbvars and put it into the lfta. +// Else, split it into an hfta predicate ref'ing +// se's computed partially in the lfta. + + predicate_t *pr_root; + bool fta_forbidden; + for(p=0;ppr, NULL, Ext_fcns) || contains_gb_pr(where[p]->pr, unsafe_gbvars) ){ + pr_root = split_ftavec_pr(where[p]->pr,select_vec,Ext_fcns); + fta_forbidden = true; + }else{ + pr_root = dup_pr(where[p]->pr, NULL); + expand_gbvars_pr(pr_root, gb_tbl); + fta_forbidden = false; + } + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + if(fta_forbidden){ + stream_node->where.push_back(cnf_root); + }else{ + fta_node->where.push_back(cnf_root); + } + } + + +// Process the Select clause, rehome it on the +// new defs. + for(s=0;sse, &hfta_aggr_se); + stream_node->select_list.push_back( + new select_element(root_se, select_list[s]->name)); + } + + +// Process the Having clause + +// All of the predicates in the having clause must +// execute in the stream node. + + for(p=0;ppr, &hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + stream_node->having.push_back(cnf_root); + } + +// Handle parameters and a few last details. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + fta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + stream_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + + fta_node->definitions = definitions; fta_node->definitions.erase("_referenced_ifaces"); + stream_node->definitions = definitions; + +// Now split by interfaces YYYY + if(ifaces.size() > 1){ + for(si=0;siset_node_name( new_name) ; + sel_names.push_back(subq_node->get_node_name()); + +// Assign the table + subq_node->table_name = fta_node->table_name->duplicate(); + subq_node->table_name->set_machine(ifaces[si].first); + subq_node->table_name->set_interface(ifaces[si].second); + subq_node->table_name->set_ifq(false); + + for(s=0;sselect_list.size();s++){ + subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) ); + } + for(p=0;pwhere.size();p++){ + predicate_t *new_pr = dup_pr(fta_node->where[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + subq_node->where.push_back(new_cnf); + } +// Xfer all of the parameters. +// Use existing handle annotations. + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + subq_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + subq_node->definitions = definitions; subq_node->definitions.erase("_referenced_ifaces"); + if(subq_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + + ret_vec.push_back(subq_node); + } + + mrg_qpn *mrg_node = new mrg_qpn((spx_qpn *)(ret_vec[0]), + fta_node->node_name, sel_names, ifaces, ifdb); + /* + Do not split sources until we are done with optimizations + vector split_merge = mrg_node->split_sources(); + for(i=0;itable_name->set_machine(ifaces[0].first); + fta_node->table_name->set_interface(ifaces[0].second); + fta_node->table_name->set_ifq(false); + if(fta_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + ret_vec.push_back(fta_node); + ret_vec.push_back(stream_node); + hfta_returned = 1; + } + + +// ret_vec.push_back(fta_node); +// ret_vec.push_back(stream_node); + + + return(ret_vec); + +} + + +/* + SPLITTING A EQ-TEMPORAL, HASH JOIN OPERATOR + + An JOIN_EQ_HASH_QPN node may reference: + literals, parameters, colrefs, functions, operators + An JOIN_EQ_HASH_QPN node may not reference: + group-by variables, aggregates + + An JOIN_EQ_HASH_QPN node contains + selection list of SEs + where list of CNF predicates, broken into: + prefilter[2] + temporal_eq + hash_eq + postfilter + + Algorithm: + For each tablevar whose source is a PROTOCOL + Create a LFTA for that tablevar + Push as many prefilter[..] predicates to that tablevar as is + possible. + Split the SEs in the select list, and the predicates not + pushed to the LFTA. + +*/ + +vector join_eq_hash_qpn::split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + + vector ret_vec; + int f,p,s; + +// If the node reads from streams only, don't split. + bool stream_only = true; + for(f=0;fget_table_ref(from[f]->get_schema_name()); + int t = from[f]->get_schema_ref(); + if(Schema->get_schema_type(t) == PROTOCOL_SCHEMA) stream_only = false; + } + if(stream_only){ + hfta_returned = 1; + ret_vec.push_back(this); + return(ret_vec); + } + + +// The HFTA node, it is always returned. + + join_eq_hash_qpn *stream_node = new join_eq_hash_qpn(); + for(f=0;fget_interface().c_str(), from[f]->get_schema_name().c_str()); + tablevar_t *tmp_tblvar = from[f]->duplicate(); +// tmp_tblvar->set_range_var(from[f]->get_var_name()); + + stream_node->from.push_back(tmp_tblvar); + } + stream_node->set_node_name(node_name); + +// Create spx (selection) children for each PROTOCOL source. + vector child_vec; + vector< vector *> select_vec; + for(f=0;fget_table_ref(from[f]->get_schema_name()); + int t = from[f]->get_schema_ref(); + if(Schema->get_schema_type(t) == PROTOCOL_SCHEMA){ + spx_qpn *child_qpn = new spx_qpn(); + sprintf(tmpstr,"_fta_%d_%s",f,node_name.c_str()); + child_qpn->set_node_name(string(tmpstr)); + child_qpn->table_name = new tablevar_t( + from[f]->get_interface().c_str(), from[f]->get_schema_name().c_str(), from[f]->get_ifq()); + child_qpn->table_name->set_range_var(from[f]->get_var_name()); + + child_vec.push_back(child_qpn); + select_vec.push_back(&(child_qpn->select_list)); + +// Update the stream's FROM clause to read from this child + stream_node->from[f]->set_interface(""); + stream_node->from[f]->set_schema(tmpstr); + }else{ + child_vec.push_back(NULL); + select_vec.push_back(NULL); + } + } + +// Push lfta-safe prefilter to the lfta +// TODO: I'm not copying the preds, I dont *think* it will be a problem. + predicate_t *pr_root; + + for(f=0;f pred_vec = prefilter[f]; + if(child_vec[f] != NULL){ + for(p=0;ppr,NULL, Ext_fcns)){ + child_vec[f]->where.push_back(pred_vec[p]); + }else{ + pr_root = split_ftavec_pr(pred_vec[p]->pr,select_vec,Ext_fcns); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + stream_node->prefilter[f].push_back(cnf_root); + } + } + }else{ + for(p=0;pprefilter[f].push_back(pred_vec[p]); + } + } + + } + +// Process the other predicates + for(p=0;ppr,select_vec,Ext_fcns); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + stream_node->temporal_eq.push_back(cnf_root); + } + for(p=0;ppr,select_vec,Ext_fcns); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + stream_node->hash_eq.push_back(cnf_root); + } + for(p=0;ppr,select_vec,Ext_fcns); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + stream_node->postfilter.push_back(cnf_root); + } + +// Process the SEs + for(s=0;sse, + fta_forbidden, se_src, select_vec, Ext_fcns + ); + if(fta_forbidden || !is_PROTOCOL_source(se_src, select_vec)){ + stream_node->select_list.push_back( + new select_element(root_se, select_list[s]->name) ); + }else{ + scalarexp_t *new_se=make_fta_se_ref(select_vec,root_se,se_src); + stream_node->select_list.push_back( + new select_element(new_se, select_list[s]->name) + ); + } + } + + +// I need to "rehome" the colrefs -- make the annotations in the colrefs +// agree with their tablevars. + for(f=0;f fm; fm.push_back(child_vec[f]->table_name); + + for(s=0;sselect_list.size();++s) + bind_colref_se(child_vec[f]->select_list[s]->se, fm,0,0); + for(p=0;pwhere.size();++p) +// bind_colref_pr(child_vec[f]->where[p]->pr, fm,f,0); + bind_colref_pr(child_vec[f]->where[p]->pr, fm,0,0); + } + } + +// rehome the colrefs in the hfta node. + for(f=0;ffrom.size();++f){ + stream_node->where.clear(); + for(s=0;sfrom.size();++s){ + for(p=0;pprefilter[s].size();++p){ + bind_colref_pr((stream_node->prefilter[s])[p]->pr,stream_node->from,f,f); + } + } + for(p=0;ptemporal_eq.size();++p){ + bind_colref_pr(stream_node->temporal_eq[p]->pr,stream_node->from,f,f); + } + for(p=0;phash_eq.size();++p){ + bind_colref_pr(stream_node->hash_eq[p]->pr,stream_node->from,f,f); + } + for(p=0;ppostfilter.size();++p){ + bind_colref_pr(stream_node->postfilter[p]->pr,stream_node->from,f,f); + } + for(s=0;sselect_list.size();++s){ + bind_colref_se(stream_node->select_list[s]->se,stream_node->from,f,f); + } + } + +// Rebuild the WHERE clause + stream_node->where.clear(); + for(s=0;sfrom.size();++s){ + for(p=0;pprefilter[s].size();++p){ + stream_node->where.push_back((stream_node->prefilter[s])[p]); + } + } + for(p=0;ptemporal_eq.size();++p){ + stream_node->where.push_back(stream_node->temporal_eq[p]); + } + for(p=0;phash_eq.size();++p){ + stream_node->where.push_back(stream_node->hash_eq[p]); + } + for(p=0;ppostfilter.size();++p){ + stream_node->where.push_back(stream_node->postfilter[p]); + } + + +// Build the return list + vector hfta_nodes; + hfta_returned = 1; + for(f=0;f > ifaces = get_ifaces(c_node->table_name, ifdb, n_virtual_ifaces, hfta_parallelism, hfta_idx); + if (ifaces.empty()) { + fprintf(stderr,"INTERNAL ERROR in join_eq_hash_qpn::split_node_for_fta - empty interface set\n"); + exit(1); + } + + if(ifaces.size() == 1){ + c_node->table_name->set_machine(ifaces[0].first); + c_node->table_name->set_interface(ifaces[0].second); + c_node->table_name->set_ifq(false); + if(c_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + ret_vec.push_back(c_node); + }else{ + vector sel_names; + int si; + for(si=0;sinode_name+"_"+ifaces[si].first+"_"+ifaces[si].second; + untaboo(new_name); + subq_node->set_node_name( new_name) ; + sel_names.push_back(subq_node->get_node_name()); + +// Assign the table + subq_node->table_name = c_node->table_name->duplicate(); + subq_node->table_name->set_machine(ifaces[si].first); + subq_node->table_name->set_interface(ifaces[si].second); + subq_node->table_name->set_ifq(false); + + for(s=0;sselect_list.size();s++){ + subq_node->select_list.push_back(dup_select(c_node->select_list[s], NULL)); + } + for(p=0;pwhere.size();p++){ + predicate_t *new_pr = dup_pr(c_node->where[p]->pr, NULL); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + +printf("table name is %s\n",subq_node->table_name->to_string().c_str()); + subq_node->where.push_back(new_cnf); + } +// Xfer all of the parameters. +// Use existing handle annotations. +// vector param_names = param_tbl->get_param_names(); +// int pi; +// for(pi=0;piget_data_type(param_names[pi]); +// subq_node->param_tbl->add_param(param_names[pi],dt->duplicate(), +// param_tbl->handle_access(param_names[pi])); +// } +// subq_node->definitions = definitions; + + if(subq_node->resolve_if_params(ifdb, this->err_str)){ + this->error_code = 3; + return ret_vec; + } + + ret_vec.push_back(subq_node); + } + int lpos = ret_vec.size()-1 ; + mrg_qpn *mrg_node = new mrg_qpn((spx_qpn *)(ret_vec[lpos]),c_node->node_name,sel_names, ifaces, ifdb); + /* + Do not split sources until we are done with optimizations + vector split_merge = mrg_node->split_sources(); + int i; + for(i=0;i param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + for(ri=0;riparam_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + ret_vec[ri]->definitions = definitions; ret_vec[ri]->definitions.erase("_referenced_ifaces"); + } + } + + + + return(ret_vec); + +} + + +///////////////////////////////////////////////////////////// +//// extract_opview + +// Common processing +int process_opview(tablevar_t *fmtbl, int pos, string node_name, + table_list *Schema, + vector &qnodes, + opview_set &opviews, + vector &ret, string rootnm, string silo_nm){ + + int s,f,q,m; + + int schref = fmtbl->get_schema_ref(); + if(schref <= 0) + return 0; + + if(Schema->get_schema_type(schref) == OPERATOR_VIEW_SCHEMA){ + opview_entry *opv = new opview_entry(); + opv->parent_qname = node_name; + opv->root_name = rootnm; + opv->view_name = fmtbl->get_schema_name(); + opv->pos = pos; + sprintf(tmpstr,"%s_UDOP%d_%s",node_name.c_str(),pos,opv->view_name.c_str()); + opv->udop_alias = tmpstr; + fmtbl->set_udop_alias(opv->udop_alias); + + opv->exec_fl = Schema->get_op_prop(schref, string("file")); + opv->liveness_timeout = atoi(Schema->get_op_prop(schref, string("liveness_timeout")).c_str()); + + vector subq = Schema->get_subqueryspecs(schref); + for(s=0;s flds = Schema->get_fields(sqs->name+silo_nm); + if(flds.size() == 0){ + fprintf(stderr,"INTERNAL ERROR: subquery %s of view %s not found in Schema.\n",sqs->name.c_str(), opv->view_name.c_str()); + return(1); + } + if(flds.size() < sqs->types.size()){ + fprintf(stderr,"ERROR: subquery %s of view %s does not have enough fields (%lu found, %lu expected).\n",sqs->name.c_str(), opv->view_name.c_str(),flds.size(), sqs->types.size()); + return(1); + } + bool failed = false; + for(f=0;ftypes.size();++f){ + data_type dte(sqs->types[f],sqs->modifiers[f]); + data_type dtf(flds[f]->get_type(),flds[f]->get_modifier_list()); + if(! dte.subsumes_type(&dtf) ){ + fprintf(stderr,"ERROR: subquery %s of view %s does not have the correct type for field %d (%s found, %s expected).\n",sqs->name.c_str(), opv->view_name.c_str(),f,dtf.to_string().c_str(), dte.to_string().c_str()); + failed = true; + } +/* + if(dte.is_temporal() && (dte.get_temporal() != dtf.get_temporal()) ){ + string pstr = dte.get_temporal_string(); + fprintf(stderr,"ERROR: subquery %s of view %s does not have the expected temporal value %s of field %d.\n",sqs->name.c_str(), opv->view_name.c_str(),pstr.c_str(),f); + failed = true; + } +*/ + } + if(failed) + return(1); +/// Validation done, find the subquery, make a copy of the +/// parse tree, and add it to the return list. + for(q=0;qname == sqs->name) + break; + if(q==qnodes.size()){ + fprintf(stderr,"INTERNAL ERROR: subquery %s of view %s not found in list of query names.\n",sqs->name.c_str(), opv->view_name.c_str()); + return(1); + } + + table_exp_t *newq = dup_table_exp(qnodes[q]->parse_tree); + sprintf(tmpstr,"%s_OP%d_%s_SUBQ%d",node_name.c_str(),pos,opv->view_name.c_str(),s); + string newq_name = tmpstr; + newq->nmap["query_name"] = newq_name; + ret.push_back(newq); + opv->subq_names.push_back(newq_name); + } + fmtbl->set_opview_idx(opviews.append(opv)); + } + + return 0; +} + +vector spx_qpn::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string rootnm, string silo_name){ + vector ret; + + int retval = process_opview(table_name,0,node_name, + Schema,qnodes,opviews,ret, rootnm, silo_name); + if(retval) exit(1); + return(ret); +} + + +vector sgah_qpn::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string rootnm, string silo_name){ + vector ret; + + int retval = process_opview(table_name,0,node_name, + Schema,qnodes,opviews,ret, rootnm, silo_name); + if(retval) exit(1); + return(ret); +} + +vector rsgah_qpn::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string rootnm, string silo_name){ + vector ret; + + int retval = process_opview(table_name,0,node_name, + Schema,qnodes,opviews,ret, rootnm, silo_name); + if(retval) exit(1); + return(ret); +} + + +vector sgahcwcb_qpn::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string rootnm, string silo_name){ + vector ret; + + int retval = process_opview(table_name,0,node_name, + Schema,qnodes,opviews,ret, rootnm, silo_name); + if(retval) exit(1); + return(ret); +} + + + +vector mrg_qpn::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string rootnm, string silo_name){ + vector ret; + int f; + for(f=0;f join_eq_hash_qpn::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string rootnm, string silo_name){ + vector ret; + int f; + for(f=0;f filter_join_qpn::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string rootnm, string silo_name){ + vector ret; + int f; + for(f=0;f temporal_cids; + vector temporal_se; + for(h=0;hpr->get_left_se(); + scalarexp_t *ser = temporal_eq[h]->pr->get_right_se(); + + if(sel->get_operator_type() == SE_COLREF){ + col_id tcol(sel->get_colref()); + if(temporal_cids.count(tcol) == 0){ + temporal_cids[tcol] = sel->get_data_type()->get_temporal(); + } + }else{ + temporal_se.push_back(sel); + } + + if(ser->get_operator_type() == SE_COLREF){ + col_id tcol(ser->get_colref()); + if(temporal_cids.count(tcol) == 0){ + temporal_cids[tcol] = ser->get_data_type()->get_temporal(); + } + }else{ + temporal_se.push_back(ser); + } + } + +// Mark select elements as nontemporal, then deduce which +// ones are temporal. + for(s=0;sse->get_data_type()->set_temporal( + compute_se_temporal(select_list[s]->se, temporal_cids) + ); +// Second chance if it is an exact match to an SE. +// for(s=0;sse->get_data_type()->is_temporal() ){ + for(t=0;tse)){ + select_list[s]->se->get_data_type()->set_temporal( + temporal_se[t]->get_data_type()->get_temporal() + ); + } + } + } +// } + } + +// If there is an outer join, verify that +// the temporal attributes are actually temporal. +// NOTE: this code must be synchronized with the +// equivalence finding in join_eq_hash_qpn::generate_functor +// (and also, the join_eq_hash_qpn constructor) + if(from[0]->get_property() || from[1]->get_property()){ + set l_equiv, r_equiv; + for(i=0;ipr->get_left_se(); + scalarexp_t *rse = temporal_eq[i]->pr->get_right_se(); + if(lse->get_operator_type()==SE_COLREF){ + l_equiv.insert(lse->get_colref()->get_field()); + } + if(rse->get_operator_type()==SE_COLREF){ + r_equiv.insert(rse->get_colref()->get_field()); + } + } + + for(s=0;sse->get_data_type()->is_temporal()){ + col_id_set cid_set; + col_id_set::iterator ci; + bool failed = false; + gather_se_col_ids(select_list[s]->se,cid_set, NULL); + for(ci=cid_set.begin();ci!=cid_set.end();++ci){ + if((*ci).tblvar_ref == 0){ + if(from[0]->get_property()){ + if(l_equiv.count((*ci).field) == 0){ + failed = true; + } + } + }else{ + if(from[1]->get_property()){ + if(r_equiv.count((*ci).field) == 0){ + failed = true; + } + } + } + } + if(failed){ + select_list[s]->se->get_data_type()->reset_temporal(); + } + } + } + } + + + return create_attributes(node_name, select_list); +} + + + +//----------------------------------------------------------------- +// get output tables + + +// Get tablevar_t names of input and output tables + +// output_file_qpn::output_file_qpn(){source_op_name = ""; } + vector output_file_qpn::get_input_tbls(){ + return(fm); + } + + vector mrg_qpn::get_input_tbls(){ + return(fm); + } + + vector spx_qpn::get_input_tbls(){ + vector retval(1,table_name); + return(retval); + } + + vector sgah_qpn::get_input_tbls(){ + vector retval(1,table_name); + return(retval); + } + + vector rsgah_qpn::get_input_tbls(){ + vector retval(1,table_name); + return(retval); + } + + vector sgahcwcb_qpn::get_input_tbls(){ + vector retval(1,table_name); + return(retval); + } + + vector join_eq_hash_qpn::get_input_tbls(){ + return(from); + } + + vector filter_join_qpn::get_input_tbls(){ + return(from); + } + +//----------------------------------------------------------------- +// get output tables + + +// This does not make sense, this fcn returns the output table *name*, +// not its schema, and then there is another fcn to rturn the schema. + vector output_file_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + vector mrg_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + vector spx_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + vector sgah_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + vector rsgah_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + vector sgahcwcb_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + vector join_eq_hash_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + vector filter_join_qpn::get_output_tbls(){ + vector retval(1,new tablevar_t(node_name.c_str())); + return(retval); + } + + + +//----------------------------------------------------------------- +// Bind to schema + +// Associate colrefs with this schema. +// Also, use this opportunity to create table_layout (the output schema). +// If the output schema is ever needed before +void mrg_qpn::bind_to_schema(table_list *Schema){ + int t; + for(t=0;tget_table_ref(fm[t]->get_schema_name()); + if(tblref>=0) + fm[t]->set_schema_ref(tblref ); + } + +// Here I assume that the colrefs have been reorderd +// during analysis so that mvars line up with fm. + mvars[0]->set_schema_ref(fm[0]->get_schema_ref()); + mvars[1]->set_schema_ref(fm[1]->get_schema_ref()); + + +} + + + +// Associate colrefs in SEs with this schema. +void spx_qpn::bind_to_schema(table_list *Schema){ +// Bind the tablevars in the From clause to the Schema +// (it might have changed from analysis time) + int t = Schema->get_table_ref(table_name->get_schema_name() ); + if(t>=0) + table_name->set_schema_ref(t ); + +// Get the "from" clause + tablevar_list_t fm(table_name); + +// Bind all SEs to this schema + int p; + for(p=0;ppr, &fm, Schema); + } + int s; + for(s=0;sse, &fm, Schema); + } + +// Collect set of tuples referenced in this HFTA +// input, internal, or output. + +} + +col_id_set spx_qpn::get_colrefs(bool ext_fcns_only,table_list *Schema){ + col_id_set retval, tmp_cset; + int p; + for(p=0;ppr, tmp_cset, NULL); + } + int s; + for(s=0;sse, tmp_cset, NULL); + } + col_id_set::iterator cisi; + if(ext_fcns_only){ + for(cisi=tmp_cset.begin();cisi!=tmp_cset.end();++cisi){ + field_entry *fe = Schema->get_field((*cisi).schema_ref, (*cisi).field); + if(fe->get_unpack_fcns().size()>0) + retval.insert((*cisi)); + } + return retval; + } + + return tmp_cset; +} + +col_id_set filter_join_qpn::get_colrefs(bool ext_fcns_only,table_list *Schema){ + col_id_set retval, tmp_cset; + int p; + for(p=0;ppr, tmp_cset, NULL); + } + int s; + for(s=0;sse, tmp_cset, NULL); + } + col_id_set::iterator cisi; + if(ext_fcns_only){ + for(cisi=tmp_cset.begin();cisi!=tmp_cset.end();++cisi){ + field_entry *fe = Schema->get_field((*cisi).schema_ref, (*cisi).field); + if(fe->get_unpack_fcns().size()>0) + retval.insert((*cisi)); + } + return retval; + } + + return tmp_cset; +} + + + +// Associate colrefs in SEs with this schema. +void join_eq_hash_qpn::bind_to_schema(table_list *Schema){ +// Bind the tablevars in the From clause to the Schema +// (it might have changed from analysis time) + int f; + for(f=0;fget_schema_name(); + int tbl_ref = Schema->get_table_ref(snm); + if(tbl_ref >= 0) + from[f]->set_schema_ref(tbl_ref); + } + +// Bind all SEs to this schema + tablevar_list_t fm(from); + + int p; + for(p=0;ppr, &fm, Schema); + } + int s; + for(s=0;sse, &fm, Schema); + } + +// Collect set of tuples referenced in this HFTA +// input, internal, or output. + +} + +void filter_join_qpn::bind_to_schema(table_list *Schema){ +// Bind the tablevars in the From clause to the Schema +// (it might have changed from analysis time) + int f; + for(f=0;fget_schema_name(); + int tbl_ref = Schema->get_table_ref(snm); + if(tbl_ref >= 0) + from[f]->set_schema_ref(tbl_ref); + } + +// Bind all SEs to this schema + tablevar_list_t fm(from); + + int p; + for(p=0;ppr, &fm, Schema); + } + int s; + for(s=0;sse, &fm, Schema); + } + +// Collect set of tuples referenced in this HFTA +// input, internal, or output. + +} + + + + +void sgah_qpn::bind_to_schema(table_list *Schema){ +// Bind the tablevars in the From clause to the Schema +// (it might have changed from analysis time) + + + int t = Schema->get_table_ref(table_name->get_schema_name() ); + if(t>=0) + table_name->set_schema_ref(t ); + +// Get the "from" clause + tablevar_list_t fm(table_name); + + + +// Bind all SEs to this schema + int p; + for(p=0;ppr, &fm, Schema); + } + for(p=0;ppr, &fm, Schema); + } + int s; + for(s=0;sse, &fm, Schema); + } + int g; + for(g=0;g opl = aggr_tbl.get_operand_list(a); + int o; + for(o=0;opr, tmp_cset, &gb_tbl); + } + int g; + for(g=0;g opl = aggr_tbl.get_operand_list(a); + int o; + for(o=0;oget_field((*cisi).schema_ref, (*cisi).field); + if(fe->get_unpack_fcns().size()>0) + retval.insert((*cisi)); + } + return retval; + } + + return tmp_cset; +} + + +void rsgah_qpn::bind_to_schema(table_list *Schema){ +// Bind the tablevars in the From clause to the Schema +// (it might have changed from analysis time) + int t = Schema->get_table_ref(table_name->get_schema_name() ); + if(t>=0) + table_name->set_schema_ref(t ); + +// Get the "from" clause + tablevar_list_t fm(table_name); + +// Bind all SEs to this schema + int p; + for(p=0;ppr, &fm, Schema); + } + for(p=0;ppr, &fm, Schema); + } + for(p=0;ppr, &fm, Schema); + } + int s; + for(s=0;sse, &fm, Schema); + } + int g; + for(g=0;g opl = aggr_tbl.get_operand_list(a); + int o; + for(o=0;oget_table_ref(table_name->get_schema_name() ); + if(t>=0) + table_name->set_schema_ref(t ); + +// Get the "from" clause + tablevar_list_t fm(table_name); + +// Bind all SEs to this schema + int p; + for(p=0;ppr, &fm, Schema); + } + for(p=0;ppr, &fm, Schema); + } + for(p=0;ppr, &fm, Schema); + } + for(p=0;ppr, &fm, Schema); + } + int s; + for(s=0;sse, &fm, Schema); + } + int g; + for(g=0;g opl = aggr_tbl.get_operand_list(a); + int o; + for(o=0;ose, Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + + return(complex_literals); +} + +cplx_lit_table *sgah_qpn::get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){ + int i,j; + cplx_lit_table *complex_literals = new cplx_lit_table(); + + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;jse, Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + + return(complex_literals); +} + + +cplx_lit_table *rsgah_qpn::get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){ + int i,j; + cplx_lit_table *complex_literals = new cplx_lit_table(); + + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;jse, Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + + return(complex_literals); +} + + +cplx_lit_table *sgahcwcb_qpn::get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){ + int i,j; + cplx_lit_table *complex_literals = new cplx_lit_table(); + + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;jse, Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + + return(complex_literals); +} + +cplx_lit_table *join_eq_hash_qpn::get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){ + int i; + cplx_lit_table *complex_literals = new cplx_lit_table(); + + for(i=0;ise, Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + + return(complex_literals); +} + +cplx_lit_table *filter_join_qpn::get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){ + int i; + cplx_lit_table *complex_literals = new cplx_lit_table(); + + for(i=0;ise, Ext_fcns, complex_literals); + } + for(i=0;ipr,Ext_fcns, complex_literals); + } + + return(complex_literals); +} + + + + +//----------------------------------------------------------------- +// get_handle_param_tbl + +vector mrg_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){ + vector retval; + return(retval); +} + + +vector spx_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){ + int i; + vector retval; + + for(i=0;ise, Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + + return(retval); +} + + +vector sgah_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){ + int i,j; + vector retval; + + + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;jse, Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + + return(retval); +} + + +vector rsgah_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){ + int i,j; + vector retval; + + + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;jse, Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + + return(retval); +} + + +vector sgahcwcb_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){ + int i,j; + vector retval; + + + for(i=0;i opl = aggr_tbl.get_operand_list(i); + for(j=0;jse, Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + + return(retval); +} + +vector join_eq_hash_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){ + int i; + vector retval; + + for(i=0;ise, Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + + return(retval); +} + + +vector filter_join_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){ + int i; + vector retval; + + for(i=0;ise, Ext_fcns, retval); + } + for(i=0;ipr,Ext_fcns, retval); + } + + return(retval); +} + +/////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////// +/// Functions for operator output rates estimations + + +//----------------------------------------------------------------- +// get_rate_estimate + +double spx_qpn::get_rate_estimate() { + + // dummy method for now + return SPX_SELECTIVITY * DEFAULT_INTERFACE_RATE; +} + +double sgah_qpn::get_rate_estimate() { + + // dummy method for now + return SGAH_SELECTIVITY * DEFAULT_INTERFACE_RATE; +} + +double rsgah_qpn::get_rate_estimate() { + + // dummy method for now + return RSGAH_SELECTIVITY * DEFAULT_INTERFACE_RATE; +} + +double sgahcwcb_qpn::get_rate_estimate() { + + // dummy method for now + return SGAHCWCB_SELECTIVITY * DEFAULT_INTERFACE_RATE; +} + +double mrg_qpn::get_rate_estimate() { + + // dummy method for now + return MRG_SELECTIVITY * DEFAULT_INTERFACE_RATE; +} + +double join_eq_hash_qpn::get_rate_estimate() { + + // dummy method for now + return JOIN_EQ_HASH_SELECTIVITY * DEFAULT_INTERFACE_RATE; +} + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +///// Generate functors + + + + +//------------------------------------------------------------------------- +// Code generation utilities. +//------------------------------------------------------------------------- + +// Globals referenced by generate utilities + +static gb_table *segen_gb_tbl; // Table of all group-by attributes. + + + +// Generate code that makes reference +// to the tuple, and not to any aggregates. +// NEW : it might reference a stateful function. +static string generate_se_code(scalarexp_t *se,table_list *schema){ + string ret; + data_type *ldt, *rdt; + int o; + vector operands; + + + switch(se->get_operator_type()){ + case SE_LITERAL: + if(se->is_handle_ref()){ + sprintf(tmpstr,"handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + if(se->get_literal()->is_cpx_lit()){ + sprintf(tmpstr,"complex_literal_%d",se->get_literal()->get_cpx_lit_ref() ); + ret = tmpstr; + return(ret); + } + return(se->get_literal()->to_hfta_C_code("")); // not complex no constr. + case SE_PARAM: + if(se->is_handle_ref()){ + sprintf(tmpstr,"handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + ret.append("param_"); + ret.append(se->get_param_name()); + return(ret); + case SE_UNARY_OP: + ldt = se->get_left_se()->get_data_type(); + if(ldt->complex_operator(se->get_op()) ){ + ret.append( ldt->get_complex_operator(se->get_op()) ); + ret.append("("); + ret.append(generate_se_code(se->get_left_se(),schema)); + ret.append(")"); + }else{ + ret.append("("); + ret.append(se->get_op()); + ret.append(generate_se_code(se->get_left_se(),schema)); + ret.append(")"); + } + return(ret); + case SE_BINARY_OP: + ldt = se->get_left_se()->get_data_type(); + rdt = se->get_right_se()->get_data_type(); + + if(ldt->complex_operator(rdt, se->get_op()) ){ + ret.append( ldt->get_complex_operator(rdt, se->get_op()) ); + ret.append("("); + ret.append(generate_se_code(se->get_left_se(),schema)); + ret.append(", "); + ret.append(generate_se_code(se->get_right_se(),schema)); + ret.append(")"); + }else{ + ret.append("("); + ret.append(generate_se_code(se->get_left_se(),schema)); + ret.append(se->get_op()); + ret.append(generate_se_code(se->get_right_se(),schema)); + ret.append(")"); + } + return(ret); + case SE_COLREF: + if(se->is_gb()){ // OK to ref gb attrs, but they're not yet unpacked ... + // so return the defining code. + int gref = se->get_gb_ref(); + scalarexp_t *gdef_se = segen_gb_tbl->get_def(gref); + ret = generate_se_code(gdef_se, schema ); + + }else{ + sprintf(tmpstr,"unpack_var_%s_%d", + se->get_colref()->get_field().c_str(), se->get_colref()->get_tablevar_ref() ); + ret = tmpstr; + } + return(ret); + case SE_FUNC: + if(se->is_partial()){ + sprintf(tmpstr,"partial_fcn_result_%d",se->get_partial_ref()); + ret = tmpstr; + }else{ + ret += se->op + "("; + operands = se->get_operands(); + bool first_elem = true; + if(se->get_storage_state() != ""){ + ret += "&(stval->state_var_"+se->get_storage_state()+"),cd"; + first_elem = false; + } + for(o=0;oget_data_type()->is_buffer_type() && + (! (operands[o]->is_handle_ref()) ) ) + ret.append("&"); + ret += generate_se_code(operands[o], schema); + } + ret += ")"; + } + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_se_code (hfta), line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + return("ERROR in generate_se_code"); + } +} + +// generate code that refers only to aggregate data and constants. +// NEW : modified to handle superaggregates and stateful fcn refs. +// Assume that the state is in *stval +static string generate_se_code_fm_aggr(scalarexp_t *se, string gbvar, string aggvar, table_list *schema){ + + string ret; + data_type *ldt, *rdt; + int o; + vector operands; + + + switch(se->get_operator_type()){ + case SE_LITERAL: + if(se->is_handle_ref()){ + sprintf(tmpstr,"handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + if(se->get_literal()->is_cpx_lit()){ + sprintf(tmpstr,"complex_literal_%d",se->get_literal()->get_cpx_lit_ref() ); + ret = tmpstr; + return(ret); + } + return(se->get_literal()->to_hfta_C_code("")); // not complex no constr. + case SE_PARAM: + if(se->is_handle_ref()){ + sprintf(tmpstr,"handle_param_%d",se->get_handle_ref() ); + ret = tmpstr; + return(ret); + } + ret.append("param_"); + ret.append(se->get_param_name()); + return(ret); + case SE_UNARY_OP: + ldt = se->get_left_se()->get_data_type(); + if(ldt->complex_operator(se->get_op()) ){ + ret.append( ldt->get_complex_operator(se->get_op()) ); + ret.append("("); + ret.append(generate_se_code_fm_aggr(se->get_left_se(),gbvar,aggvar,schema)); + ret.append(")"); + }else{ + ret.append("("); + ret.append(se->get_op()); + ret.append(generate_se_code_fm_aggr(se->get_left_se(),gbvar,aggvar,schema)); + ret.append(")"); + } + return(ret); + case SE_BINARY_OP: + ldt = se->get_left_se()->get_data_type(); + rdt = se->get_right_se()->get_data_type(); + + if(ldt->complex_operator(rdt, se->get_op()) ){ + ret.append( ldt->get_complex_operator(rdt, se->get_op()) ); + ret.append("("); + ret.append(generate_se_code_fm_aggr(se->get_left_se(),gbvar,aggvar,schema)); + ret.append(", "); + ret.append(generate_se_code_fm_aggr(se->get_right_se(),gbvar,aggvar,schema)); + ret.append(")"); + }else{ + ret.append("("); + ret.append(generate_se_code_fm_aggr(se->get_left_se(),gbvar,aggvar,schema)); + ret.append(se->get_op()); + ret.append(generate_se_code_fm_aggr(se->get_right_se(),gbvar,aggvar,schema)); + ret.append(")"); + } + return(ret); + case SE_COLREF: + if(se->is_gb()){ // OK to ref gb attrs, but they're not yet unpacked ... + // so return the defining code. + sprintf(tmpstr,"%s%d",gbvar.c_str(),se->get_gb_ref()); + ret = tmpstr; + + }else{ + fprintf(stderr,"ERROR reference to non-GB column ref not permitted here," + "error in query_plan.cc:generate_se_code_fm_aggr, line %d, character %d.\n", + se->get_lineno(), se->get_charno()); + ret = tmpstr; + } + return(ret); + case SE_AGGR_STAR: + case SE_AGGR_SE: + if(se->is_superaggr()){ + sprintf(tmpstr,"stval->aggr_var%d",se->get_aggr_ref()); + }else{ + sprintf(tmpstr,"%saggr_var%d",aggvar.c_str(),se->get_aggr_ref()); + } + ret = tmpstr; + return(ret); + case SE_FUNC: +// Is it a UDAF? + if(se->get_aggr_ref() >= 0){ + sprintf(tmpstr,"udaf_ret_%d",se->get_aggr_ref()); + ret = tmpstr; + return(ret); + } + + if(se->is_partial()){ + sprintf(tmpstr,"partial_fcn_result_%d",se->get_partial_ref()); + ret = tmpstr; + }else{ + ret += se->op + "("; + bool first_elem = true; + if(se->get_storage_state() != ""){ + ret += "&(stval->state_var_"+se->get_storage_state()+"),cd"; + first_elem = false; + } + operands = se->get_operands(); + for(o=0;oget_data_type()->is_buffer_type() && + (! (operands[o]->is_handle_ref()) ) ) + ret.append("&"); + ret += generate_se_code_fm_aggr(operands[o], gbvar,aggvar, schema); + } + ret += ")"; + } + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in query_plan.cc::generate_se_code_fm_aggr, line %d, character %d: unknown operator type %d\n", + se->get_lineno(), se->get_charno(),se->get_operator_type()); + return("ERROR in generate_se_code_fm_aggr"); + } + +} + + +static string unpack_partial_fcn_fm_aggr(scalarexp_t *se, int pfn_id, string gbvar, string aggvar, table_list *schema){ + string ret; + int o; + vector operands; + + + if(se->get_operator_type() != SE_FUNC){ + fprintf(stderr,"INTERNAL ERROR, non-function SE passed to unpack_partial_fcn_fm_aggr. line %d, character %d\n", + se->get_lineno(), se->get_charno()); + return("ERROR in unpack_partial_fcn_fm_aggr"); + } + + ret = "\tretval = " + se->get_op() + "( ", + sprintf(tmpstr, "&partial_fcn_result_%d",pfn_id); + ret += tmpstr; + + if(se->get_storage_state() != ""){ + ret += ",&(stval->state_var_"+se->get_storage_state()+"),cd"; + } + + operands = se->get_operands(); + for(o=0;oget_data_type()->is_buffer_type() && + (! (operands[o]->is_handle_ref()) ) ) + ret.append("&"); + ret += generate_se_code_fm_aggr(operands[o], gbvar,aggvar, schema); + } + ret += ");\n"; + + return(ret); +} + + +static string unpack_partial_fcn(scalarexp_t *se, int pfn_id, table_list *schema){ + string ret; + int o; + vector operands; + + if(se->get_operator_type() != SE_FUNC){ + fprintf(stderr,"INTERNAL ERROR, non-function SE passed to unpack_partial_fcn. line %d, character %d\n", + se->get_lineno(), se->get_charno()); + return("ERROR in unpack_partial_fcn"); + } + + ret = "\tretval = " + se->get_op() + "( ", + sprintf(tmpstr, "&partial_fcn_result_%d",pfn_id); + ret += tmpstr; + + if(se->get_storage_state() != ""){ + ret += ",&(stval->state_var_"+se->get_storage_state()+"),cd"; + } + + operands = se->get_operands(); + for(o=0;oget_data_type()->is_buffer_type() && + (! (operands[o]->is_handle_ref()) ) ) + ret.append("&"); + ret += generate_se_code(operands[o], schema); + } + ret += ");\n"; + + return(ret); +} + +static string generate_cached_fcn(scalarexp_t *se, int pfn_id, table_list *schema){ + string ret; + int o; + vector operands; + + if(se->get_operator_type() != SE_FUNC){ + fprintf(stderr,"INTERNAL ERROR, non-function SE passed to generate_cached_fcn. line %d, character %d\n", + se->get_lineno(), se->get_charno()); + return("ERROR in generate_cached_fcn"); + } + + ret = se->get_op()+"("; + + if(se->get_storage_state() != ""){ + ret += "&(stval->state_var_"+se->get_storage_state()+"),cd,"; + } + + operands = se->get_operands(); + for(o=0;oget_data_type()->is_buffer_type() && + (! (operands[o]->is_handle_ref()) ) ) + ret.append("&"); + ret += generate_se_code(operands[o], schema); + } + ret += ");\n"; + + return(ret); +} + + + + + +static string generate_C_comparison_op(string op){ + if(op == "=") return("=="); + if(op == "<>") return("!="); + return(op); +} + +static string generate_C_boolean_op(string op){ + if( (op == "AND") || (op == "And") || (op == "and") ){ + return("&&"); + } + if( (op == "OR") || (op == "Or") || (op == "or") ){ + return("||"); + } + if( (op == "NOT") || (op == "Not") || (op == "not") ){ + return("!"); + } + + return("ERROR UNKNOWN BOOLEAN OPERATOR"); +} + + +static string generate_predicate_code(predicate_t *pr,table_list *schema){ + string ret; + vector litv; + int i; + data_type *ldt, *rdt; + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + ldt = pr->get_left_se()->get_data_type(); + + ret.append("( "); + litv = pr->get_lit_vec(); + for(i=0;i0) ret.append(" || "); + ret.append("( "); + + if(ldt->complex_comparison(ldt) ){ + ret.append( ldt->get_hfta_comparison_fcn(ldt) ); + ret.append("( "); + if(ldt->is_buffer_type() ) + ret.append("&"); + ret.append(generate_se_code(pr->get_left_se(), schema)); + ret.append(", "); + if(ldt->is_buffer_type() ) + ret.append("&"); + if(litv[i]->is_cpx_lit()){ + sprintf(tmpstr,"complex_literal_%d",litv[i]->get_cpx_lit_ref() ); + ret += tmpstr; + }else{ + ret.append(litv[i]->to_C_code("")); + } + ret.append(") == 0"); + }else{ + ret.append(generate_se_code(pr->get_left_se(), schema)); + ret.append(" == "); + ret.append(litv[i]->to_hfta_C_code("")); + } + + ret.append(" )"); + } + ret.append(" )"); + return(ret); + + case PRED_COMPARE: + ldt = pr->get_left_se()->get_data_type(); + rdt = pr->get_right_se()->get_data_type(); + + ret.append("( "); + if(ldt->complex_comparison(rdt) ){ + ret.append(ldt->get_hfta_comparison_fcn(rdt)); + ret.append("("); + if(ldt->is_buffer_type() ) + ret.append("&"); + ret.append(generate_se_code(pr->get_left_se(),schema) ); + ret.append(", "); + if(rdt->is_buffer_type() ) + ret.append("&"); + ret.append(generate_se_code(pr->get_right_se(),schema) ); + ret.append(") "); + ret.append( generate_C_comparison_op(pr->get_op())); + ret.append("0"); + }else{ + ret.append(generate_se_code(pr->get_left_se(),schema) ); + ret.append( generate_C_comparison_op(pr->get_op())); + ret.append(generate_se_code(pr->get_right_se(),schema) ); + } + ret.append(" )"); + return(ret); + case PRED_UNARY_OP: + ret.append("( "); + ret.append( generate_C_boolean_op(pr->get_op()) ); + ret.append(generate_predicate_code(pr->get_left_pr(),schema) ); + ret.append(" )"); + return(ret); + case PRED_BINARY_OP: + ret.append("( "); + ret.append(generate_predicate_code(pr->get_left_pr(),schema) ); + ret.append( generate_C_boolean_op(pr->get_op()) ); + ret.append(generate_predicate_code(pr->get_right_pr(),schema) ); + ret.append(" )"); + return(ret); + case PRED_FUNC: + ret += pr->get_op() + "( "; + op_list = pr->get_op_list(); + for(o=0;o0) ret += ", "; + if(op_list[o]->get_data_type()->is_buffer_type() && (! (op_list[o]->is_handle_ref()) ) ) + ret.append("&"); + ret += generate_se_code(op_list[o], schema); + } + ret += " )"; + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_predicate_code, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + return("ERROR in generate_predicate_code"); + } +} + +static string generate_predicate_code_fm_aggr(predicate_t *pr, string gbvar, string aggvar,table_list *schema){ + string ret; + vector litv; + int i; + data_type *ldt, *rdt; + vector op_list; + int o; + + switch(pr->get_operator_type()){ + case PRED_IN: + ldt = pr->get_left_se()->get_data_type(); + + ret.append("( "); + litv = pr->get_lit_vec(); + for(i=0;i0) ret.append(" || "); + ret.append("( "); + + if(ldt->complex_comparison(ldt) ){ + ret.append( ldt->get_hfta_comparison_fcn(ldt) ); + ret.append("( "); + if(ldt->is_buffer_type() ) + ret.append("&"); + ret.append(generate_se_code_fm_aggr(pr->get_left_se(), gbvar, aggvar, schema)); + ret.append(", "); + if(ldt->is_buffer_type() ) + ret.append("&"); + if(litv[i]->is_cpx_lit()){ + sprintf(tmpstr,"complex_literal_%d",litv[i]->get_cpx_lit_ref() ); + ret += tmpstr; + }else{ + ret.append(litv[i]->to_C_code("")); + } + ret.append(") == 0"); + }else{ + ret.append(generate_se_code_fm_aggr(pr->get_left_se(), gbvar, aggvar, schema)); + ret.append(" == "); + ret.append(litv[i]->to_hfta_C_code("")); + } + + ret.append(" )"); + } + ret.append(" )"); + return(ret); + + case PRED_COMPARE: + ldt = pr->get_left_se()->get_data_type(); + rdt = pr->get_right_se()->get_data_type(); + + ret.append("( "); + if(ldt->complex_comparison(rdt) ){ + ret.append(ldt->get_hfta_comparison_fcn(rdt)); + ret.append("("); + if(ldt->is_buffer_type() ) + ret.append("&"); + ret.append(generate_se_code_fm_aggr(pr->get_left_se(), gbvar, aggvar,schema) ); + ret.append(", "); + if(rdt->is_buffer_type() ) + ret.append("&"); + ret.append(generate_se_code_fm_aggr(pr->get_right_se(), gbvar, aggvar,schema) ); + ret.append(") "); + ret.append( generate_C_comparison_op(pr->get_op())); + ret.append("0"); + }else{ + ret.append(generate_se_code_fm_aggr(pr->get_left_se(), gbvar, aggvar,schema) ); + ret.append( generate_C_comparison_op(pr->get_op())); + ret.append(generate_se_code_fm_aggr(pr->get_right_se(), gbvar, aggvar,schema) ); + } + ret.append(" )"); + return(ret); + case PRED_UNARY_OP: + ret.append("( "); + ret.append( generate_C_boolean_op(pr->get_op()) ); + ret.append(generate_predicate_code_fm_aggr(pr->get_left_pr(), gbvar, aggvar,schema) ); + ret.append(" )"); + return(ret); + case PRED_BINARY_OP: + ret.append("( "); + ret.append(generate_predicate_code_fm_aggr(pr->get_left_pr(), gbvar, aggvar,schema) ); + ret.append( generate_C_boolean_op(pr->get_op()) ); + ret.append(generate_predicate_code_fm_aggr(pr->get_right_pr(), gbvar, aggvar,schema) ); + ret.append(" )"); + return(ret); + case PRED_FUNC: + ret += pr->get_op() + "( "; + op_list = pr->get_op_list(); + for(o=0;o0) ret += ", "; + if(op_list[o]->get_data_type()->is_buffer_type() && (! (op_list[o]->is_handle_ref()) ) ) + ret.append("&"); + ret += generate_se_code_fm_aggr(op_list[o], gbvar, aggvar, schema); + } + ret += " )"; + return(ret); + default: + fprintf(stderr,"INTERNAL ERROR in generate_predicate_code, line %d, character %d, unknown predicate operator type %d\n", + pr->get_lineno(), pr->get_charno(), pr->get_operator_type() ); + return("ERROR in generate_predicate_code"); + } +} + + +// Aggregation code + + +static string generate_equality_test(string &lhs_op, string &rhs_op, data_type *dt){ + string ret; + + if(dt->complex_comparison(dt) ){ + ret.append(dt->get_hfta_comparison_fcn(dt)); + ret.append("("); + if(dt->is_buffer_type() ) + ret.append("&"); + ret.append(lhs_op); + ret.append(", "); + if(dt->is_buffer_type() ) + ret.append("&"); + ret.append(rhs_op ); + ret.append(") == 0"); + }else{ + ret.append(lhs_op ); + ret.append(" == "); + ret.append(rhs_op ); + } + + return(ret); +} + +static string generate_comparison(string &lhs_op, string &rhs_op, data_type *dt){ + string ret; + + if(dt->complex_comparison(dt) ){ + ret.append(dt->get_hfta_comparison_fcn(dt)); + ret.append("("); + if(dt->is_buffer_type() ) + ret.append("&"); + ret.append(lhs_op); + ret.append(", "); + if(dt->is_buffer_type() ) + ret.append("&"); + ret.append(rhs_op ); + ret.append(") == 0"); + }else{ + ret.append(lhs_op ); + ret.append(" == "); + ret.append(rhs_op ); + } + + return(ret); +} + + +// Here I assume that only MIN and MAX aggregates can be computed +// over BUFFER data types. + +static string generate_aggr_update(string var, aggregate_table *atbl,int aidx, table_list *schema){ + string retval = "\t\t"; + string op = atbl->get_op(aidx); + +// Is it a UDAF + if(! atbl->is_builtin(aidx)) { + int o; + retval += op+"_HFTA_AGGR_UPDATE_("; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+")"; + vector opl = atbl->get_operand_list(aidx); + for(o=0;oget_data_type()->is_buffer_type() && (! (opl[o]->is_handle_ref()) ) ) + retval.append("&"); + retval += generate_se_code(opl[o], schema); + } + } + retval += ");\n"; + + return retval; + } + + +// builtin processing + data_type *dt = atbl->get_data_type(aidx); + + if(op == "COUNT"){ + retval.append(var); + retval.append("++;\n"); + return(retval); + } + if(op == "SUM"){ + retval.append(var); + retval.append(" += "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + if(op == "MIN"){ + sprintf(tmpstr,"aggr_tmp_%d",aidx); + retval += dt->make_host_cvar(tmpstr); + retval += " = "; + retval += generate_se_code(atbl->get_aggr_se(aidx), schema )+";\n"; + if(dt->complex_comparison(dt)){ + if(dt->is_buffer_type()) + sprintf(tmpstr,"\t\tif(%s(&aggr_tmp_%d,&(%s)) < 0)\n",dt->get_hfta_comparison_fcn(dt).c_str(), aidx, var.c_str()); + else + sprintf(tmpstr,"\t\tif(%s(aggr_tmp_%d,%s) < 0)\n",dt->get_hfta_comparison_fcn(dt).c_str(), aidx, var.c_str()); + }else{ + sprintf(tmpstr,"\t\tif(aggr_tmp_%d < %s)\n",aidx,var.c_str()); + } + retval.append(tmpstr); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(&(%s),&aggr_tmp_%d);\n",dt->get_hfta_buffer_replace().c_str(),var.c_str(),aidx); + }else{ + sprintf(tmpstr,"\t\t\t%s = aggr_tmp_%d;\n",var.c_str(),aidx); + } + retval.append(tmpstr); + + return(retval); + } + if(op == "MAX"){ + sprintf(tmpstr,"aggr_tmp_%d",aidx); + retval+=dt->make_host_cvar(tmpstr); + retval+=" = "; + retval+=generate_se_code(atbl->get_aggr_se(aidx), schema )+";\n"; + if(dt->complex_comparison(dt)){ + if(dt->is_buffer_type()) + sprintf(tmpstr,"\t\tif(%s(&aggr_tmp_%d,&(%s)) > 0)\n",dt->get_hfta_comparison_fcn(dt).c_str(), aidx, var.c_str()); + else + sprintf(tmpstr,"\t\tif(%s(aggr_tmp_%d,%s) > 0)\n",dt->get_hfta_comparison_fcn(dt).c_str(), aidx, var.c_str()); + }else{ + sprintf(tmpstr,"\t\tif(aggr_tmp_%d > %s)\n",aidx,var.c_str()); + } + retval.append(tmpstr); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(&(%s),&aggr_tmp_%d);\n",dt->get_hfta_buffer_replace().c_str(),var.c_str(),aidx); + }else{ + sprintf(tmpstr,"\t\t\t%s = aggr_tmp_%d;\n",var.c_str(),aidx); + } + retval.append(tmpstr); + + return(retval); + + } + if(op == "AND_AGGR"){ + retval.append(var); + retval.append(" &= "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + if(op == "OR_AGGR"){ + retval.append(var); + retval.append(" |= "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + if(op == "XOR_AGGR"){ + retval.append(var); + retval.append(" ^= "); + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema) ); + retval.append(";\n"); + return(retval); + } + if(op=="AVG"){ + retval += var+"_sum += "+generate_se_code(atbl->get_aggr_se(aidx), schema)+";\n"; + retval += "\t\t"+var+"_cnt += 1;\n"; + retval += "\t\t"+var+" = "+var+"_sum / "+var+"_cnt;\n"; + return retval; + } + + fprintf(stderr,"INTERNAL ERROR : aggregate %s not recognized in query_plan::generate_aggr_update.\n",op.c_str()); + exit(1); + return(retval); + +} + + +// superaggr minus. + +static string generate_superaggr_minus(string var, string supervar, aggregate_table *atbl,int aidx, table_list *schema){ + string retval = "\t\t"; + string op = atbl->get_op(aidx); + +// Is it a UDAF + if(! atbl->is_builtin(aidx)) { + int o; + retval += op+"_HFTA_AGGR_MINUS_("; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+supervar+"),"; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+");\n"; + + return retval; + } + + + if(op == "COUNT" || op == "SUM"){ + retval += supervar + "-=" +var + ";\n"; + return(retval); + } + + if(op == "XOR_AGGR"){ + retval += supervar + "^=" +var + ";\n"; + return(retval); + } + + if(op=="MIN" || op == "MAX") + return ""; + + fprintf(stderr,"INTERNAL ERROR : aggregate %s not recognized in generate_superaggr_minus.\n",op.c_str()); + exit(1); + return(retval); + +} + + + + +static string generate_aggr_init(string var, aggregate_table *atbl,int aidx, table_list *schema){ + string retval; + string op = atbl->get_op(aidx); + +// UDAF processing + if(! atbl->is_builtin(aidx)){ +// initialize + retval += "\t"+atbl->get_op(aidx)+"_HFTA_AGGR_INIT_("; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+"));\n"; +// Add 1st tupl + retval += "\t"+atbl->get_op(aidx)+"_HFTA_AGGR_UPDATE_("; + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+")"; + vector opl = atbl->get_operand_list(aidx); + int o; + for(o=0;oget_data_type()->is_buffer_type() && (! (opl[o]->is_handle_ref()) ) ) + retval.append("&"); + retval += generate_se_code(opl[o],schema); + } + retval += ");\n"; + return(retval); + } + +// builtin aggregate processing + data_type *dt = atbl->get_data_type(aidx); + + if(op == "COUNT"){ + retval = var; + retval.append(" = 1;\n"); + return(retval); + } + + if(op == "SUM" || op == "MIN" || op == "MAX" || op == "AND_AGGR" || + op=="AVG" || op == "OR_AGGR" || op == "XOR_AGGR"){ + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t\taggr_tmp_%d = %s;\n",aidx,generate_se_code(atbl->get_aggr_se(aidx), schema ).c_str() ); + retval.append(tmpstr); + sprintf(tmpstr,"\t\t%s(&(%s),&aggr_tmp_%d);\n",dt->get_hfta_buffer_assign_copy().c_str(),var.c_str(),aidx); + retval.append(tmpstr); + }else{ + if(op=="AVG"){ + retval += var+"_sum = "+generate_se_code(atbl->get_aggr_se(aidx), schema)+";\n"; + retval += "\t"+var+"_cnt = 1;\n"; + retval += "\t"+var+" = "+var+"_sum;\n"; + }else{ + retval = var; + retval += " = "; + retval.append(generate_se_code(atbl->get_aggr_se(aidx), schema)); + retval.append(";\n"); + } + } + return(retval); + } + + fprintf(stderr,"INTERNAL ERROR : aggregate %s not recognized in query_plan::generate_aggr_init.\n",op.c_str()); + exit(1); + return(retval); + +} + + + +static string generate_aggr_reinitialize(string var, aggregate_table *atbl,int aidx, table_list *schema){ + string retval; + string op = atbl->get_op(aidx); + +// UDAF processing + if(! atbl->is_builtin(aidx)){ +// initialize + retval += "\t"+atbl->get_op(aidx); + if(atbl->is_running_aggr(aidx)){ + retval += "_HFTA_AGGR_REINIT_("; + }else{ + retval += "_HFTA_AGGR_INIT_("; + } + if(atbl->get_storage_type(aidx)->get_type() != fstring_t) retval+="&"; + retval+="("+var+"));\n"; + return(retval); + } + +// builtin aggregate processing + data_type *dt = atbl->get_data_type(aidx); + + if(op == "COUNT"){ + retval = var; + retval.append(" = 0;\n"); + return(retval); + } + + if(op == "SUM" || op == "AND_AGGR" || + op == "OR_AGGR" || op == "XOR_AGGR"){ + if(dt->is_buffer_type()){ + return("ERROR, cannot yet handle reinitialization of builtin aggregates over strings."); + }else{ + retval = var; + retval += " = "; + literal_t l(dt->type_indicator()); + retval.append(l.to_string()); + retval.append(";\n"); + } + return(retval); + } + + if(op == "MIN"){ + if(dt->is_buffer_type()){ + return("ERROR, cannot yet handle reinitialization of builtin aggregates over strings."); + }else{ + retval = var; + retval += " = "; + retval.append(dt->get_max_literal()); + retval.append(";\n"); + } + return(retval); + } + + if(op == "MAX"){ + if(dt->is_buffer_type()){ + return("ERROR, cannot yet handle reinitialization of builtin aggregates over strings."); + }else{ + retval = var; + retval += " = "; + retval.append(dt->get_min_literal()); + retval.append(";\n"); + } + return(retval); + } + + fprintf(stderr,"INTERNAL ERROR : aggregate %s not recognized in generate_aggr_reinitialize.\n",op.c_str()); + exit(1); + return(retval); + +} + + +// Generate parameter holding vars from a param table. +static string generate_param_vars(param_table *param_tbl){ + string ret; + int p; + vector param_vec = param_tbl->get_param_names(); + for(p=0;pget_data_type(param_vec[p]); + sprintf(tmpstr,"param_%s;\n", param_vec[p].c_str()); + ret += "\t"+dt->make_host_cvar(tmpstr)+";\n"; + if(param_tbl->handle_access(param_vec[p])){ + ret += "\tstruct search_handle *param_handle_"+param_vec[p]+";\n"; + } + } + return(ret); +} + +// Parameter manipulation routines +static string generate_load_param_block(string functor_name, + param_table *param_tbl, + vector param_handle_table + ){ + int p; + vector param_names = param_tbl->get_param_names(); + + string ret = "int load_params_"+functor_name+"(gs_int32_t sz, void *value){\n"; + ret.append("\tint pos=0;\n"); + ret.append("\tint data_pos;\n"); + + for(p=0;pget_data_type(param_names[p]); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"tmp_var_%s;\n", param_names[p].c_str()); + ret += "\t"+dt->make_host_cvar(tmpstr)+";\n"; + } + } + + +// Verify that the block is of minimum size + if(param_names.size() > 0){ + ret += "//\tVerify that the value block is large enough */\n"; + ret.append("\n\tdata_pos = "); + for(p=0;p0) ret.append(" + "); + data_type *dt = param_tbl->get_data_type(param_names[p]); + ret.append("sizeof( "); + ret.append( dt->get_host_cvar_type() ); + ret.append(" )"); + } + ret.append(";\n"); + ret.append("\tif(data_pos > sz) return 1;\n\n"); + } + +/////////////////////// +/// Verify that all strings can be unpacked. + + ret += "//\tVerify that the strings can be unpacked */\n"; + for(p=0;pget_data_type(param_names[p]); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\ttmp_var_%s = *( (%s *)((gs_sp_t )value+pos) );\n",param_names[p].c_str(), dt->get_host_cvar_type().c_str() ); + ret.append(tmpstr); + switch( dt->get_type() ){ + case v_str_t: +// ret += "\ttmp_var_"+param_names[p]+".offset = ntohl( tmp_var_"+param_names[p]+".offset );\n"; // ntoh conversion +// ret += "\ttmp_var_"+param_names[p]+".length = ntohl( tmp_var_"+param_names[p]+".length );\n"; // ntoh conversion + sprintf(tmpstr,"\tif( (int)(tmp_var_%s.offset) + tmp_var_%s.length > sz) return 1;\n",param_names[p].c_str(), param_names[p].c_str() ); + ret.append(tmpstr); + sprintf(tmpstr,"\ttmp_var_%s.offset = (gs_p_t)( (gs_sp_t )value + (gs_p_t)(tmp_var_%s.offset) );\n",param_names[p].c_str(), param_names[p].c_str() ); + ret.append(tmpstr); + break; + default: + fprintf(stderr,"ERROR: parameter %s is of type %s, a buffered type, but I don't know how to unpack it as a parameter.\n",param_names[p].c_str(), dt->to_string().c_str() ); + exit(1); + break; + } + } + ret += "\tpos += sizeof( "+dt->get_host_cvar_type()+" );\n"; + } + + +///////////////////////// + + ret += "/*\tThe block is OK, do the unpacking. */\n"; + ret += "\tpos = 0;\n"; + + for(p=0;pget_data_type(param_names[p]); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t%s(¶m_%s, &tmp_var_%s);\n", dt->get_hfta_buffer_assign_copy().c_str(),param_names[p].c_str(),param_names[p].c_str() ); + ret.append(tmpstr); + }else{ +// if(dt->needs_hn_translation()){ +// sprintf(tmpstr,"\tparam_%s = %s( *( (%s *)( (gs_sp_t )value+pos) ) );\n", +// param_names[p].c_str(), dt->ntoh_translation().c_str(), dt->get_host_cvar_type().c_str() ); +// }else{ + sprintf(tmpstr,"\tparam_%s = *( (%s *)( (gs_sp_t )value+pos) );\n", + param_names[p].c_str(), dt->get_host_cvar_type().c_str() ); +// } + ret.append(tmpstr); + } + ret += "\tpos += sizeof( "+dt->get_host_cvar_type()+" );\n"; + } + +// TODO: I think this method of handle registration is obsolete +// and should be deleted. +// some examination reveals that handle_access is always false. + for(p=0;phandle_access(param_names[p]) ){ + data_type *pdt = param_tbl->get_data_type(param_names[p]); +// create the new. + ret += "\tt->param_handle_"+param_names[p]+" = " + + pdt->handle_registration_name() + + "((struct FTA *)t, &(t->param_"+param_names[p]+"));\n"; + } + } +// Register the pass-by-handle parameters + + ret += "/* register the pass-by-handle parameters */\n"; + + int ph; + for(ph=0;phtype_name); + switch(param_handle_table[ph]->val_type){ + case cplx_lit_e: + break; + case litval_e: + break; + case param_e: + sprintf(tmpstr,"\thandle_param_%d = %s(",ph,param_handle_table[ph]->lfta_registration_fcn().c_str()); + ret += tmpstr; + if(pdt.is_buffer_type()) ret += "&("; + ret += "param_"+param_handle_table[ph]->param_name; + if(pdt.is_buffer_type()) ret += ")"; + ret += ");\n"; + break; + default: + fprintf(stderr, "INTERNAL ERROR unknown case found when processing pass-by-handle parameter table.\n"); + exit(1); + } + } + + + ret += "\treturn(0);\n"; + ret.append("}\n\n"); + + return(ret); + +} + +static string generate_delete_param_block(string functor_name, + param_table *param_tbl, + vector param_handle_table + ){ + + int p; + vector param_names = param_tbl->get_param_names(); + + string ret = "void destroy_params_"+functor_name+"(){\n"; + + for(p=0;pget_data_type(param_names[p]); + if(dt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(¶m_%s);\n",dt->get_hfta_buffer_destroy().c_str(),param_names[p].c_str()); + ret.append(tmpstr); + } + if(param_tbl->handle_access(param_names[p]) ){ + ret += "\t\t" + dt->get_handle_destructor() + + "(t->param_handle_" + param_names[p] + ");\n"; + } + } + + ret += "//\t\tDeregister handles.\n"; + int ph; + for(ph=0;phval_type == param_e){ + sprintf(tmpstr, "\t\t%s(handle_param_%d);\n", + param_handle_table[ph]->lfta_deregistration_fcn().c_str(),ph); + ret += tmpstr; + } + } + + ret += "}\n\n"; + return ret; +} + +// --------------------------------------------------------------------- +// functions for creating functor variables. + +static string generate_access_vars(col_id_set &cid_set, table_list *schema){ + string ret; + col_id_set::iterator csi; + + for(csi=cid_set.begin(); csi!=cid_set.end();++csi){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field)); + sprintf(tmpstr,"unpack_var_%s_%d", field.c_str(), tblref); + ret+="\t"+dt.make_host_cvar(tmpstr)+";\n"; + sprintf(tmpstr,"\tgs_int32_t unpack_offset_%s_%d;\n", field.c_str(), tblref); + ret.append(tmpstr); + } + return(ret); +} + +static string generate_partial_fcn_vars(vector &partial_fcns, + vector &ref_cnt, vector &is_partial, bool gen_fcn_cache){ + string ret; + int p; + + + for(p=0;p1){ + sprintf(tmpstr,"partial_fcn_result_%d", p); + ret+="\t"+partial_fcns[p]->get_data_type()->make_host_cvar(tmpstr)+";\n"; + if(gen_fcn_cache && ref_cnt[p]>1){ + ret+="\tint fcn_ref_cnt_"+int_to_string(p)+";\n"; + } + } + } + return(ret); +} + + +static string generate_complex_lit_vars(cplx_lit_table *complex_literals){ + string ret; + int cl; + for(cl=0;clsize();cl++){ + literal_t *l = complex_literals->get_literal(cl); + data_type *dtl = new data_type( l->get_type() ); + sprintf(tmpstr,"complex_literal_%d",cl); + ret += "\t"+dtl->make_host_cvar(tmpstr)+";\n"; + if(complex_literals->is_handle_ref(cl)){ + sprintf(tmpstr,"\tstruct search_handle *lit_handle_%d;\n",cl); + ret.append(tmpstr); + } + } + return(ret); +} + + +static string generate_pass_by_handle_vars( + vector ¶m_handle_table){ + string ret; + int p; + + for(p=0;psize();cl++){ + literal_t *l = complex_literals->get_literal(cl); +// sprintf(tmpstr,"\tcomplex_literal_%d = ",cl); +// ret += tmpstr + l->to_hfta_C_code() + ";\n"; + sprintf(tmpstr,"&(complex_literal_%d)",cl); + ret += "\t" + l->to_hfta_C_code(tmpstr) + ";\n"; +// I think that the code below is obsolete +// TODO: it is obsolete. add_cpx_lit is always +// called with the handle indicator being false. +// This entire structure should be cleansed. + if(complex_literals->is_handle_ref(cl)){ + data_type *dt = new data_type( l->get_type() ); + sprintf(tmpstr,"\tlit_handle_%d = %s(&(f->complex_literal_%d));\n", + cl, dt->hfta_handle_registration_name().c_str(), cl); + ret += tmpstr; + delete dt; + } + } + return(ret); +} + + +static string gen_partial_fcn_init(vector &partial_fcns){ + string ret; + + int p; + for(p=0;pget_data_type(); + literal_t empty_lit(pdt->type_indicator()); + if(pdt->is_buffer_type()){ +// sprintf(tmpstr,"\tpartial_fcn_result_%d = %s;\n", +// p, empty_lit.to_hfta_C_code().c_str()); + sprintf(tmpstr,"&(partial_fcn_result_%d)",p); + ret += "\t"+empty_lit.to_hfta_C_code(tmpstr)+";\n"; + } + } + return(ret); +} + +static string gen_pass_by_handle_init( + vector ¶m_handle_table){ + string ret; + + int ph; + for(ph=0;phtype_name); + sprintf(tmpstr,"\thandle_param_%d = %s(",ph,param_handle_table[ph]->lfta_registration_fcn().c_str()); + switch(param_handle_table[ph]->val_type){ + case cplx_lit_e: + ret += tmpstr; + if(pdt.is_buffer_type()) ret += "&("; + sprintf(tmpstr,"complex_literal_%d",param_handle_table[ph]->complex_literal_idx); + ret += tmpstr; + if(pdt.is_buffer_type()) ret += ")"; + ret += ");\n"; + break; + case litval_e: + ret += tmpstr; + ret += param_handle_table[ph]->litval->to_hfta_C_code("") + ");\n"; +// ret += ");\n"; + break; + case param_e: +// query parameter handles are regstered/deregistered in the +// load_params function. +// ret += "t->param_"+param_handle_table[ph]->param_name; + break; + default: + fprintf(stderr, "INTERNAL ERROR unknown case found when processing pass-by-handle parameter table.\n"); + exit(1); + } + } + return(ret); +} + +//------------------------------------------------------------ +// functions for destructor and deregistration code + +static string gen_complex_lit_dtr(cplx_lit_table *complex_literals){ + string ret; + + int cl; + for(cl=0;clsize();cl++){ + literal_t *l = complex_literals->get_literal(cl); + data_type ldt( l->get_type() ); + if(ldt.is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&complex_literal_%d);\n", + ldt.get_hfta_buffer_destroy().c_str(), cl ); + ret += tmpstr; + } + } + return(ret); +} + + +static string gen_pass_by_handle_dtr( + vector ¶m_handle_table){ + string ret; + + int ph; + for(ph=0;phlfta_deregistration_fcn().c_str(),ph); + ret += tmpstr; + } + return(ret); +} + +// Destroy all previous results +static string gen_partial_fcn_dtr(vector &partial_fcns){ + string ret; + + int p; + for(p=0;pget_data_type(); + if(pdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&partial_fcn_result_%d);\n", + pdt->get_hfta_buffer_destroy().c_str(), p ); + ret += tmpstr; + } + } + return(ret); +} + +// Destroy previsou results of fcns in pfcn_set +static string gen_partial_fcn_dtr(vector &partial_fcns, set &pfcn_set){ + string ret; + set::iterator si; + + for(si=pfcn_set.begin(); si!=pfcn_set.end(); ++si){ + data_type *pdt =partial_fcns[(*si)]->get_data_type(); + if(pdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&partial_fcn_result_%d);\n", + pdt->get_hfta_buffer_destroy().c_str(), (*si) ); + ret += tmpstr; + } + } + return(ret); +} + + +//------------------------------------------------------------------------- +// Functions related to se generation bookkeeping. + +static void get_new_pred_cids(predicate_t *pr, col_id_set &found_cids, + col_id_set &new_cids, gb_table *gtbl){ + col_id_set this_pred_cids; + col_id_set::iterator csi; + +// get colrefs in predicate not already found. + gather_pr_col_ids(pr,this_pred_cids,gtbl); + set_difference(this_pred_cids.begin(), this_pred_cids.end(), + found_cids.begin(), found_cids.end(), + inserter(new_cids,new_cids.begin()) ); + +// We've found these cids, so update found_cids + for(csi=new_cids.begin(); csi!=new_cids.end(); ++csi) + found_cids.insert((*csi)); + +} + +// after the call, new_cids will have the colrefs in se but not found_cids. +// update found_cids with the new cids. +static void get_new_se_cids(scalarexp_t *se, col_id_set &found_cids, + col_id_set &new_cids, gb_table *gtbl){ + col_id_set this_se_cids; + col_id_set::iterator csi; + +// get colrefs in se not already found. + gather_se_col_ids(se,this_se_cids,gtbl); + set_difference(this_se_cids.begin(), this_se_cids.end(), + found_cids.begin(), found_cids.end(), + inserter(new_cids,new_cids.begin()) ); + +// We've found these cids, so update found_cids + for(csi=new_cids.begin(); csi!=new_cids.end(); ++csi) + found_cids.insert((*csi)); + +} + +static string gen_unpack_cids(table_list *schema, col_id_set &new_cids, string on_problem, vector &needs_xform){ + string ret; + col_id_set::iterator csi; + + for(csi=new_cids.begin(); csi!=new_cids.end(); ++csi){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field)); + string unpack_fcn; + if(needs_xform[tblref]){ + unpack_fcn = dt.get_hfta_unpack_fcn(); + }else{ + unpack_fcn = dt.get_hfta_unpack_fcn_noxf(); + } + if(dt.is_buffer_type()){ + sprintf(tmpstr,"\t unpack_var_%s_%d = %s(tup%d.data, tup%d.tuple_size, unpack_offset_%s_%d, &problem);\n",field.c_str(), tblref, unpack_fcn.c_str(), tblref, tblref, field.c_str(), tblref); + }else{ + sprintf(tmpstr,"\t unpack_var_%s_%d = %s_nocheck(tup%d.data, unpack_offset_%s_%d);\n",field.c_str(), tblref, unpack_fcn.c_str(), tblref, field.c_str(), tblref); + } + ret += tmpstr; + if(dt.is_buffer_type()){ + ret += "\tif(problem) return "+on_problem+" ;\n"; + } + } + return(ret); +} + +// generates the declaration of all the variables related to +// temp tuples generation +static string gen_decl_temp_vars(){ + string ret; + + ret += "\t// variables related to temp tuple generation\n"; + ret += "\tbool temp_tuple_received;\n"; + + return(ret); +} + +// generates initialization code for variables related to temp tuple processing +static string gen_init_temp_vars(table_list *schema, vector& select_list, gb_table *gtbl){ + string ret; + col_id_set::iterator csi; + int s; + +// Initialize internal state + ret += "\ttemp_tuple_received = false;\n"; + + col_id_set temp_cids; // colrefs unpacked thus far. + + for(s=0;sse->get_data_type()->is_temporal()) { +// Find the set of attributes accessed in this SE + col_id_set new_cids; + get_new_se_cids(select_list[s]->se,temp_cids, new_cids, gtbl); + + // init these vars + for(csi=new_cids.begin(); csi!=new_cids.end(); ++csi){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field), schema->get_modifier_list(schref,field)); + + sprintf(tmpstr,"\t unpack_var_%s_%d = %s;\n", field.c_str(), tblref, + dt.is_increasing() ? dt.get_min_literal().c_str() : dt.get_max_literal().c_str()); + ret += tmpstr; + } + } + } + return(ret); +} + + + +// generates a check if tuple is temporal +static string gen_temp_tuple_check(string node_name, int channel) { + string ret; + + char tmpstr[256]; + sprintf(tmpstr, "tup%d", channel); + string tup_name = tmpstr; + sprintf(tmpstr, "schema_handle%d", channel); + string schema_handle_name = tmpstr; + string tuple_offset_name = "tuple_metadata_offset"+int_to_string(channel); + +// check if it is a temporary status tuple + ret += "\t// check if tuple is temp status tuple\n"; +// ret += "\tif (ftaschema_is_temporal_tuple(" + schema_handle_name + ", " + tup_name + ".data)) {\n"; + ret += "\tif (ftaschema_is_temporal_tuple_offset(" + tuple_offset_name + ", " + tup_name + ".data)) {\n"; + ret += "\t\ttemp_tuple_received = true;\n"; + ret += "\t}\n"; + ret += "\telse\n\t\ttemp_tuple_received = false;\n\n"; + + return(ret); +} + +// generates unpacking code for all temporal attributes referenced in select +static string gen_unpack_temp_vars(table_list *schema, col_id_set& found_cids, vector& select_list, gb_table *gtbl, vector &needs_xform) { + string ret; + int s; + +// Unpack all the temporal attributes references in select list +// we need it to be able to generate temp status tuples + for(s=0;sse->get_data_type()->is_temporal()) { +// Find the set of attributes accessed in this SE + col_id_set new_cids; + get_new_se_cids(select_list[s]->se,found_cids, new_cids, gtbl); +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "false", needs_xform); + } + } + + return(ret); +} + + +// Generates temporal tuple generation code (except attribute packing) +static string gen_init_temp_status_tuple(string node_name) { + string ret; + + ret += "\t// create temp status tuple\n"; + ret += "\tresult.tuple_size = sizeof("+generate_tuple_name( node_name)+") + sizeof(gs_uint8_t);\n"; + ret += "\tresult.data = (gs_sp_t )malloc(result.tuple_size);\n"; + ret += "\tresult.heap_resident = true;\n"; + ret += "\t// Mark tuple as temporal\n"; + ret += "\t*((gs_sp_t )result.data + sizeof("+generate_tuple_name( node_name)+")) = TEMPORAL_TUPLE;\n"; + + ret += "\t"+generate_tuple_name( node_name)+" *tuple = ("+ + generate_tuple_name( node_name) +" *)(result.data);\n"; + + return(ret); +} + + +// Assume that all colrefs unpacked already ... +static string gen_unpack_partial_fcn(table_list *schema, + vector &partial_fcns,set &pfcn_refs, + string on_problem){ + string ret; + set::iterator si; + +// Since set<..> is a "Sorted Associative Container", +// we can walk through it in sorted order by walking from +// begin() to end(). (and the partial fcns must be +// evaluated in this order). + for(si=pfcn_refs.begin();si!=pfcn_refs.end();++si){ + ret += unpack_partial_fcn(partial_fcns[(*si)], (*si), schema); + ret += "\tif(retval) return "+on_problem+" ;\n"; + } + return(ret); +} + +// Assume that all colrefs unpacked already ... +// this time with cached functions. +static string gen_unpack_partial_fcn(table_list *schema, + vector &partial_fcns,set &pfcn_refs, + vector &fcn_ref_cnt, vector &is_partial_fcn, + string on_problem){ + string ret; + set::iterator si; + +// Since set<..> is a "Sorted Associative Container", +// we can walk through it in sorted order by walking from +// begin() to end(). (and the partial fcns must be +// evaluated in this order). + for(si=pfcn_refs.begin();si!=pfcn_refs.end();++si){ + if(fcn_ref_cnt[(*si)] > 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string((*si))+"==0){\n"; + } + if(is_partial_fcn[(*si)]){ + ret += unpack_partial_fcn(partial_fcns[(*si)], (*si), schema); + ret += "\tif(retval) return "+on_problem+" ;\n"; + } + if(fcn_ref_cnt[(*si)] > 1){ + if(!is_partial_fcn[(*si)]){ + ret += "\t\tpartial_fcn_result_"+int_to_string((*si))+"="+generate_cached_fcn(partial_fcns[(*si)],(*si),schema)+";\n"; + } + ret += "\t\tfcn_ref_cnt_"+int_to_string((*si))+"=1;\n"; + ret += "\t}\n"; + } + } + + return(ret); +} + + +// This version finds and unpacks new colrefs. +// found_cids gets updated with the newly unpacked cids. +static string gen_full_unpack_partial_fcn(table_list *schema, + vector &partial_fcns,set &pfcn_refs, + col_id_set &found_cids, gb_table *gtbl, string on_problem, + vector &needs_xform){ + string ret; + set::iterator slsi; + + for(slsi=pfcn_refs.begin(); slsi!=pfcn_refs.end(); ++slsi){ +// find all new fields ref'd by this partial fcn. + col_id_set new_cids; + get_new_se_cids(partial_fcns[(*slsi)], found_cids, new_cids, gtbl); +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, on_problem, needs_xform); + +// Now evaluate the partial fcn. + ret += unpack_partial_fcn(partial_fcns[(*slsi)], (*slsi), schema); + ret += "\tif(retval) return "+on_problem+" ;\n"; + } + return(ret); +} + +// This version finds and unpacks new colrefs. +// found_cids gets updated with the newly unpacked cids. +// BUT : only for the partial functions. +static string gen_full_unpack_partial_fcn(table_list *schema, + vector &partial_fcns,set &pfcn_refs, + vector &fcn_ref_cnt, vector &is_partial_fcn, + col_id_set &found_cids, gb_table *gtbl, string on_problem, + vector &needs_xform){ + string ret; + set::iterator slsi; + + for(slsi=pfcn_refs.begin(); slsi!=pfcn_refs.end(); ++slsi){ + if(is_partial_fcn[(*slsi)]){ +// find all new fields ref'd by this partial fcn. + col_id_set new_cids; + get_new_se_cids(partial_fcns[(*slsi)], found_cids, new_cids, gtbl); +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, on_problem, needs_xform); + +// Now evaluate the partial fcn. + if(fcn_ref_cnt[(*slsi)] > 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string((*slsi))+"==0){\n"; + } + if(is_partial_fcn[(*slsi)]){ + ret += unpack_partial_fcn(partial_fcns[(*slsi)], (*slsi), schema); + ret += "\tif(retval) return "+on_problem+" ;\n"; + } + if(fcn_ref_cnt[(*slsi)] > 1){ + ret += "\t\tfcn_ref_cnt_"+int_to_string((*slsi))+"=1;\n"; + ret += "\t}\n"; + } + + } + } + return(ret); +} + +static string gen_remaining_cached_fcns(table_list *schema, + vector &partial_fcns,set &pfcn_refs, + vector &fcn_ref_cnt, vector &is_partial_fcn){ + string ret; + set::iterator slsi; + + for(slsi=pfcn_refs.begin(); slsi!=pfcn_refs.end(); ++slsi){ + if(!is_partial_fcn[(*slsi)] && fcn_ref_cnt[(*slsi)] > 1){ + + if(fcn_ref_cnt[(*slsi)] > 1){ + ret += "\tif(fcn_ref_cnt_"+int_to_string((*slsi))+"==0){\n"; + ret += "\t\tpartial_fcn_result_"+int_to_string((*slsi))+"="+generate_cached_fcn(partial_fcns[(*slsi)],(*slsi),schema)+";\n"; + ret += "\t\tfcn_ref_cnt_"+int_to_string((*slsi))+"=1;\n"; + ret += "\t}\n"; + } + } + } + return(ret); +} + + +// unpack the colrefs in cid_set not in found_cids +static string gen_remaining_colrefs(table_list *schema, + col_id_set &cid_set, col_id_set &found_cids, string on_problem, + vector &needs_xform){ + string ret; + col_id_set::iterator csi; + + for(csi=cid_set.begin(); csi!=cid_set.end();csi++){ + if(found_cids.count( (*csi) ) == 0){ + int schref = (*csi).schema_ref; + int tblref = (*csi).tblvar_ref; + string field = (*csi).field; + data_type dt(schema->get_type_name(schref,field)); + string unpack_fcn; + if(needs_xform[tblref]){ + unpack_fcn = dt.get_hfta_unpack_fcn(); + }else{ + unpack_fcn = dt.get_hfta_unpack_fcn_noxf(); + } + if(dt.is_buffer_type()){ + sprintf(tmpstr,"\t unpack_var_%s_%d = %s(tup%d.data, tup%d.tuple_size, unpack_offset_%s_%d, &problem);\n",field.c_str(), tblref, unpack_fcn.c_str(), tblref, tblref, field.c_str(), tblref); + }else{ + sprintf(tmpstr,"\t unpack_var_%s_%d = %s_nocheck(tup%d.data, unpack_offset_%s_%d);\n",field.c_str(), tblref, unpack_fcn.c_str(), tblref, field.c_str(), tblref); + } + ret += tmpstr; + if(dt.is_buffer_type()){ + ret.append("\tif(problem) return "+on_problem+" ;\n"); + } + } + } + return(ret); +} + +static string gen_buffer_selvars(table_list *schema, + vector &select_list){ + string ret; + int s; + + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type() && + !( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"selvar_%d",s); + ret+="\t"+sdt->make_host_cvar(tmpstr)+" = "; + ret += generate_se_code(se,schema) +";\n"; + } + } + return(ret); +} + +static string gen_buffer_selvars_size(vector &select_list,table_list *schema){ + string ret; + int s; + + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type()){ + if( !( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr," + %s(&selvar_%d)", sdt->get_hfta_buffer_size().c_str(),s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr," + %s(&%s)", sdt->get_hfta_buffer_size().c_str(), + generate_se_code(se,schema).c_str()); + ret.append(tmpstr); + } + } + } + return(ret); +} + +static string gen_buffer_selvars_dtr(vector &select_list){ + string ret; + int s; + + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type() && + !( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"\t\t%s(&selvar_%d);\n", + sdt->get_hfta_buffer_destroy().c_str(), s ); + ret += tmpstr; + } + } + return(ret); +} + + +static string gen_pack_tuple(table_list *schema, vector &select_list, string node_name, bool temporal_only){ + string ret; + int s; + + ret += "\tint tuple_pos = sizeof("+generate_tuple_name(node_name)+") + sizeof(gs_uint8_t);\n"; + for(s=0;sse; + data_type *sdt = se->get_data_type(); + + if(!temporal_only && sdt->is_buffer_type()){ + if( !( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_FUNC && se->is_partial())) + ){ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &selvar_%d, ((gs_sp_t )tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, s); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&selvar_%d);\n", sdt->get_hfta_buffer_size().c_str(), s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &%s, ((gs_sp_t )tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, generate_se_code(se,schema).c_str()); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&%s);\n", sdt->get_hfta_buffer_size().c_str(), generate_se_code(se,schema).c_str()); + ret.append(tmpstr); + } + }else if (!temporal_only || sdt->is_temporal()) { + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret.append(tmpstr); + ret.append(generate_se_code(se,schema) ); + ret.append(";\n"); + } + } + return(ret); +} + + +//------------------------------------------------------------------------- +// functor generation methods +//------------------------------------------------------------------------- + +///////////////////////////////////////////////////////// +//// File Output Operator +string output_file_qpn::generate_functor_name(){ + return("output_file_functor_" + normalize_name(get_node_name())); +} + + +string output_file_qpn::generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, vector &needs_xform){ + string ret = "class " + this->generate_functor_name() + "{\n"; + +// Find the temporal field + int temporal_field_idx; + data_type *tdt = NULL; + for(temporal_field_idx=0;temporal_field_idxget_type(), fields[temporal_field_idx]->get_modifier_list()); + if(tdt->is_temporal()){ + break; + }else{ + delete tdt; + } + } + + if(temporal_field_idx == fields.size()){ + fprintf(stderr,"ERROR, no temporal field for file output operator %s\n",node_name.c_str()); + exit(1); + } + + ret += "private:\n"; + + // var to save the schema handle + ret += "\tint schema_handle0;\n"; +// tuple metadata offset + ret += "\tint tuple_metadata_offset0;\n"; + sprintf(tmpstr,"\tgs_int32_t unpack_offset_%s_0;\n", fields[temporal_field_idx]->get_name().c_str()); + ret.append(tmpstr); + +// For unpacking the hashing fields, if any + int h; + for(h=0;hget_name().c_str()); + data_type *hdt = new data_type(fields[hash_flds[h]]->get_type(), fields[hash_flds[h]]->get_modifier_list()); + ret+="\t"+hdt->make_host_cvar(tmpstr)+";\n"; + if(hash_flds[h]!=temporal_field_idx){ + sprintf(tmpstr,"\tgs_int32_t unpack_offset_%s_0;\n", fields[hash_flds[h]]->get_name().c_str()); + ret.append(tmpstr); + } + } +// Specail case for output file hashing + if(n_streams>1 && hash_flds.size()==0){ + ret+="\tgs_uint32_t outfl_cnt;\n"; + } + + ret += "//\t\tRemember the last posted timestamp.\n"; + ret+="\t"+tdt->make_host_cvar("timestamp")+";\n"; + ret+="\t"+tdt->make_host_cvar("last_bucket")+";\n"; + ret+="\t"+tdt->make_host_cvar("slack")+";\n"; + ret += "\tbool first_execution;\n"; + ret += "\tbool temp_tuple_received;\n"; + ret += "\tbool is_eof;\n"; + + ret += "\tgs_int32_t bucketwidth;\n"; + + ret += "public:\n"; +//------------------- +// The functor constructor +// pass in a schema handle (e.g. for the 1st input stream), +// use it to determine how to unpack the merge variable. +// ASSUME that both streams have the same layout, +// just duplicate it. + +// unpack vars + ret += "//\t\tFunctor constructor.\n"; + ret += this->generate_functor_name()+"(int schema_hndl){\n"; + + ret += "\tschema_handle0 = schema_hndl;\n"; +// tuple metadata offset + ret += "\ttuple_metadata_offset0 = ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + + if(output_spec->bucketwidth == 0) + ret += "\tbucketwidth = 60;\n"; + else + ret += "\tbucketwidth = "+int_to_string(output_spec->bucketwidth)+";\n"; + ret += "//\t\tGet offsets for unpacking fields from input tuple.\n"; + + sprintf(tmpstr,"\tunpack_offset_%s_0 = ftaschema_get_field_offset_by_name(schema_handle0, \"%s\");\n", fields[temporal_field_idx]->get_name().c_str(), fields[temporal_field_idx]->get_name().c_str()); + ret.append(tmpstr); +// Hashing field unpacking, if any + for(h=0;hget_name().c_str(),fields[hash_flds[h]]->get_name().c_str()); + ret.append(tmpstr); + } + } + + ret+="\tfirst_execution = true;\n"; + +// Initialize internal state + ret += "\ttemp_tuple_received = false;\n"; + + // Init last timestamp values to minimum value for their type + if (tdt->is_increasing()){ + ret+="\ttimestamp = " + tdt->get_min_literal() + ";\n"; + ret+="\tlast_bucket = " + tdt->get_min_literal() + ";\n"; + }else{ + ret+="\ttimestamp = " + tdt->get_max_literal() + ";\n"; + ret+="\tlast_bucket = " + tdt->get_max_literal() + ";\n"; + } + + + ret += "};\n\n"; + + ret += "//\t\tFunctor destructor.\n"; + ret += "~"+this->generate_functor_name()+"(){\n"; + ret+="};\n\n"; + + + ret += "int load_params_"+this->generate_functor_name()+"(gs_int32_t sz, void *value){return 0;}\n"; + ret += "void destroy_params_"+this->generate_functor_name()+"(){}\n"; + +// Register new parameter block + ret += "int set_param_block(gs_int32_t sz, void* value){\n"; + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + ret += "\treturn this->load_params_"+this->generate_functor_name()+ + "(sz, value);\n"; + ret += "};\n\n"; + + ret+="\nbool temp_status_received(const host_tuple& tup0)/* const*/ {\n"; + ret+="\tgs_int32_t problem;\n"; + + ret += "\tvoid *tup_ptr = (void *)(&tup0);\n"; + ret += "\tis_eof = ftaschema_is_eof_tuple(schema_handle0,tup_ptr);\n"; + + ret += gen_temp_tuple_check(this->node_name, 0); + + sprintf(tmpstr,"\ttimestamp = %s_nocheck(tup0.data, unpack_offset_%s_%d);\n", tdt->get_hfta_unpack_fcn_noxf().c_str(), fields[temporal_field_idx]->get_name().c_str(), 0); + ret += tmpstr; + + for(h=0;hget_type(), fields[hash_flds[h]]->get_modifier_list()); + sprintf(tmpstr,"\tunpack_var_%s = %s_nocheck(tup0.data, unpack_offset_%s_%d);\n", fields[hash_flds[h]]->get_name().c_str(), hdt->get_hfta_unpack_fcn_noxf().c_str(), fields[hash_flds[h]]->get_name().c_str(), 0); + ret += tmpstr; + } + ret += +" return temp_tuple_received;\n" +"}\n" +"\n" +; + + ret += +"bool new_epoch(){\n" +" if(first_execution || (last_bucket + 1) * bucketwidth <= timestamp){\n" +" last_bucket = timestamp / bucketwidth;\n" +" first_execution = false;\n" +" return true;\n" +" }\n" +" return false;\n" +"}\n" +"\n" +; + + if(n_streams <= 1){ + ret+= +"inline gs_uint32_t output_hash(){return 0;}\n\n"; + }else{ + if(hash_flds.size()==0){ + ret += +"gs_uint32_t output_hash(){\n" +" outfl_cnt++;\n" +" if(outfl_cnt >= "+int_to_string(n_streams)+")\n" +" outfl_cnt = 0;\n" +" return outfl_cnt;\n" +"}\n" +"\n" +; + }else{ + ret += +"gs_uint32_t output_hash(){\n" +" gs_uint32_t ret = " +; + for(h=0;h0) ret += "^"; + data_type *hdt = new data_type(fields[hash_flds[h]]->get_type(), fields[hash_flds[h]]->get_modifier_list()); + if(hdt->use_hashfunc()){ + sprintf(tmpstr,"%s(&(unpack_var_%s))",hdt->get_hfta_hashfunc().c_str(),fields[hash_flds[h]]->get_name().c_str()); + }else{ + sprintf(tmpstr,"unpack_var_%s",fields[hash_flds[h]]->get_name().c_str()); + } + ret += tmpstr; + } + ret += +";\n" +" return ret % "+int_to_string(hash_flds.size())+";\n" +"}\n\n" +; + } + } + +ret += +"gs_uint32_t num_file_streams(){\n" +" return("+int_to_string(n_streams)+");\n" +"}\n\n" +; + + ret += +"string get_filename_base(){\n" +" char tmp_fname[500];\n"; + + string output_filename_base = hfta_query_name+filestream_id; +/* + if(n_hfta_clones > 1){ + output_filename_base += "_"+int_to_string(parallel_idx); + } +*/ + + + + if(output_spec->output_directory == "") + ret += +" sprintf(tmp_fname,\""+output_filename_base+"_%lld\",(gs_int64_t)(last_bucket*bucketwidth));\n"; + else ret += +" sprintf(tmp_fname,\""+output_spec->output_directory+"/"+output_filename_base+"_%lld\",(gs_int64_t)(last_bucket*bucketwidth));\n"; +ret += +" return (string)(tmp_fname);\n" +"}\n" +"\n"; + + +ret+= +"bool do_compression(){\n"; + if(do_gzip) + ret += " return true;\n"; + else + ret += " return false;\n"; +ret+= +"}\n" +"\n" +"bool is_eof_tuple(){\n" +" return is_eof;\n" +"}\n" +"\n" +"bool propagate_tuple(){\n" +; +if(eat_input) + ret+="\treturn false;\n"; +else + ret+="\treturn true;\n"; +ret+="}\n\n"; +// create a temp status tuple + ret += "int create_temp_status_tuple(host_tuple& result) {\n\n"; + + ret += gen_init_temp_status_tuple(this->hfta_query_name); + + sprintf(tmpstr,"\ttuple->tuple_var%d = timestamp;\n",temporal_field_idx); + + + ret += tmpstr; + + ret += "\treturn 0;\n"; + ret += "}\n\n"; + ret += "};\n\n"; + + return ret; +} + + +string output_file_qpn::generate_operator(int i, string params){ + string optype = "file_output_operator"; + switch(compression_type){ + case regular: + optype = "file_output_operator"; + break; + case gzip: + optype = "zfile_output_operator"; + break; + case bzip: + optype = "bfile_output_operator"; + break; + } + + return(" "+optype+"<" + + generate_functor_name() + + "> *op"+int_to_string(i)+" = new "+optype+"<"+ + generate_functor_name() +">("+params+", \"" + hfta_query_name + "\"" + + "," + hfta_query_name + "_schema_definition);\n"); +} + +///////////////////////////////////////////////////////// +////// SPX functor + + +string spx_qpn::generate_functor_name(){ + return("spx_functor_" + normalize_name(normalize_name(this->get_node_name()))); +} + +string spx_qpn::generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, vector &needs_xform){ +// Initialize generate utility globals + segen_gb_tbl = NULL; + + string ret = "class " + this->generate_functor_name() + "{\n"; + +// Find variables referenced in this query node. + + col_id_set cid_set; + col_id_set::iterator csi; + + int w, s, p; + for(w=0;wpr,cid_set,NULL); + for(s=0;sse,cid_set,NULL); + } + + +// Private variables : store the state of the functor. +// 1) variables for unpacked attributes +// 2) offsets of the upacked attributes +// 3) storage of partial functions +// 4) storage of complex literals (i.e., require a constructor) + + ret += "private:\n"; + ret += "\tbool first_execution;\t// internal processing state \n"; + ret += "\tint schema_handle0;\n"; + + // generate the declaration of all the variables related to + // temp tuples generation + ret += gen_decl_temp_vars(); + + +// unpacked attribute storage, offsets + ret += "//\t\tstorage and offsets of accessed fields.\n"; + ret += generate_access_vars(cid_set,schema); +// tuple metadata management + ret += "\tint tuple_metadata_offset0;\n"; + +// Variables to store results of partial functions. +// WARNING find_partial_functions modifies the SE +// (it marks the partial function id). + ret += "//\t\tParital function result storage\n"; + vector partial_fcns; + vector fcn_ref_cnt; + vector is_partial_fcn; + for(s=0;sse, &partial_fcns,&fcn_ref_cnt,&is_partial_fcn, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, &fcn_ref_cnt,&is_partial_fcn,Ext_fcns); + } +// Unmark non-partial expensive functions referenced only once. + for(p=0; pset_partial_ref(-1); + } + } + if(partial_fcns.size()>0){ + ret += generate_partial_fcn_vars(partial_fcns,fcn_ref_cnt,is_partial_fcn,true); + } + +// Complex literals (i.e., they need constructors) + ret += "//\t\tComplex literal storage.\n"; + cplx_lit_table *complex_literals = this->get_cplx_lit_tbl(Ext_fcns); + ret += generate_complex_lit_vars(complex_literals); + +// Pass-by-handle parameters + ret += "//\t\tPass-by-handle storage.\n"; + vector param_handle_table = this->get_handle_param_tbl(Ext_fcns); + ret += generate_pass_by_handle_vars(param_handle_table); + +// Variables to hold parameters + ret += "//\tfor query parameters\n"; + ret += generate_param_vars(param_tbl); + + +// The publicly exposed functions + + ret += "\npublic:\n"; + + +//------------------- +// The functor constructor +// pass in the schema handle. +// 1) make assignments to the unpack offset variables +// 2) initialize the complex literals +// 3) Set the initial values of the temporal attributes +// referenced in select clause (in case we need to emit +// temporal tuple before receiving first tuple ) + + ret += "//\t\tFunctor constructor.\n"; + ret += this->generate_functor_name()+"(int schema_handle0){\n"; + +// save schema handle + ret += "this->schema_handle0 = schema_handle0;\n"; + +// unpack vars + ret += "//\t\tGet offsets for unpacking fields from input tuple.\n"; + ret += gen_access_var_init(cid_set); +// tuple metadata + ret += "\ttuple_metadata_offset0 = ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + +// complex literals + ret += "//\t\tInitialize complex literals.\n"; + ret += gen_complex_lit_init(complex_literals); + +// Initialize partial function results so they can be safely GC'd + ret += gen_partial_fcn_init(partial_fcns); + +// Initialize non-query-parameter parameter handles + ret += gen_pass_by_handle_init(param_handle_table); + +// Init temporal attributes referenced in select list + ret += gen_init_temp_vars(schema, select_list, NULL); + + ret += "};\n\n"; + + +//------------------- +// Functor destructor + ret += "//\t\tFunctor destructor.\n"; + ret += "~"+this->generate_functor_name()+"(){\n"; + +// clean up buffer-type complex literals. + ret += gen_complex_lit_dtr(complex_literals); + +// Deregister the pass-by-handle parameters + ret += "/* register and de-register the pass-by-handle parameters */\n"; + ret += gen_pass_by_handle_dtr(param_handle_table); + +// Reclaim buffer space for partial fucntion results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns); + + +// Destroy the parameters, if any need to be destroyed + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + + ret += "};\n\n"; + + +//------------------- +// Parameter manipulation routines + ret += generate_load_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table ); + ret += generate_delete_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + + +//------------------- +// Register new parameter block + ret += "int set_param_block(gs_int32_t sz, void* value){\n"; + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + ret += "\treturn this->load_params_"+this->generate_functor_name()+ + "(sz, value);\n"; + ret += "};\n\n"; + + +//------------------- +// The selection predicate. +// Unpack variables for 1 cnf element +// at a time, return false immediately if the +// predicate fails. +// optimization : evaluate the cheap cnf elements +// first, the expensive ones last. + + ret += "bool predicate(host_tuple &tup0){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure +// Initialize cached function indicators. + for(p=0;p1){ + ret+="\tfcn_ref_cnt_"+int_to_string(p)+"=0;\n"; + } + } + + + ret += gen_temp_tuple_check(this->node_name, 0); + + if(partial_fcns.size()>0){ // partial fcn access failure + ret += "\tgs_retval_t retval = 0;\n"; + ret += "\n"; + } + +// Reclaim buffer space for partial fucntion results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns); + + col_id_set found_cids; // colrefs unpacked thus far. + ret += gen_unpack_temp_vars(schema, found_cids, select_list, NULL, needs_xform); + +// For temporal status tuple we don't need to do anything else + ret += "\tif (temp_tuple_received) return false;\n\n"; + + + for(w=0;wpr,found_cids, new_cids, NULL); +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "false", needs_xform); +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(where[w]->pr, pfcn_refs); + ret += gen_unpack_partial_fcn(schema,partial_fcns,pfcn_refs,fcn_ref_cnt, is_partial_fcn, "false"); + + ret += "\tif( !("+generate_predicate_code(where[w]->pr,schema)+ + +") ) return(false);\n"; + } + +// The partial functions ref'd in the select list +// must also be evaluated. If one returns false, +// then implicitly the predicate is false. + set sl_pfcns; + for(s=0;sse, sl_pfcns); + } + if(sl_pfcns.size() > 0) + ret += "//\t\tUnpack remaining partial fcns.\n"; + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, sl_pfcns, + fcn_ref_cnt, is_partial_fcn, + found_cids, NULL, "false", needs_xform); + +// Unpack remaining fields + ret += "//\t\tunpack any remaining fields from the input tuple.\n"; + ret += gen_remaining_colrefs(schema, cid_set, found_cids, "false", needs_xform); + + + ret += "\treturn(true);\n"; + ret += "};\n\n"; + + +//------------------- +// The output tuple function. +// Unpack the remaining attributes into +// the placeholder variables, unpack the +// partial fcn refs, then pack up the tuple. + + ret += "host_tuple create_output_tuple() {\n"; + ret += "\thost_tuple tup;\n"; + ret += "\tgs_retval_t retval = 0;\n"; + +// Unpack any remaining cached functions. + ret += gen_remaining_cached_fcns(schema, partial_fcns, sl_pfcns, + fcn_ref_cnt, is_partial_fcn); + + +// Now, compute the size of the tuple. + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. + + ret += "//\t\tCompute the size of the tuple.\n"; + ret += "//\t\t\tNote: buffer storage packed at the end of the tuple.\n"; + +// Unpack all buffer type selections, to be able to compute their size + ret += gen_buffer_selvars(schema, select_list); + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + + ret+="\ttup.tuple_size = sizeof(" + generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t)"; + ret += gen_buffer_selvars_size(select_list,schema); + ret.append(";\n"); + +// Allocate tuple data block. + ret += "//\t\tCreate the tuple block.\n"; + ret += "\ttup.data = malloc(tup.tuple_size);\n"; + ret += "\ttup.heap_resident = true;\n"; +// Mark tuple as regular + ret += "\t*((gs_sp_t )tup.data + sizeof(" + generate_tuple_name( this->get_node_name()) +")) = REGULAR_TUPLE;\n"; + +// ret += "\ttup.channel = 0;\n"; + ret += "\t"+generate_tuple_name( this->get_node_name())+" *tuple = ("+ + generate_tuple_name( this->get_node_name())+" *)(tup.data);\n"; + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + ret += gen_pack_tuple(schema,select_list,this->get_node_name(), false ); + +// Delete string temporaries + ret += gen_buffer_selvars_dtr(select_list); + + ret += "\treturn tup;\n"; + ret += "};\n"; + +//------------------------------------------------------------------- +// Temporal update functions + + ret += "bool temp_status_received(){return temp_tuple_received;};\n\n"; + + +// create a temp status tuple + ret += "int create_temp_status_tuple(host_tuple& result) {\n\n"; + + ret += gen_init_temp_status_tuple(this->get_node_name()); + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + ret += gen_pack_tuple(schema,select_list,this->get_node_name(), true ); + + ret += "\treturn 0;\n"; + ret += "};};\n\n"; + + return(ret); +} + + +string spx_qpn::generate_operator(int i, string params){ + + return(" select_project_operator<" + + generate_functor_name() + + "> *op"+int_to_string(i)+" = new select_project_operator<"+ + generate_functor_name() +">("+params+", \"" + get_node_name() + "\");\n"); +} + + +//////////////////////////////////////////////////////////////// +//// SGAH functor + + + +string sgah_qpn::generate_functor_name(){ + return("sgah_functor_" + normalize_name(this->get_node_name())); +} + + +string sgah_qpn::generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, vector &needs_xform){ + int a,g,w,s; + + +// Initialize generate utility globals + segen_gb_tbl = &(gb_tbl); + +// Might need to generate empty values for cube processing. + map structured_types; + for(g=0;gis_structured_type()){ + structured_types[gb_tbl.get_data_type(g)->type_indicator()] = gb_tbl.get_data_type(g)->get_type_str(); + } + } + +//-------------------------------- +// group definition class + string ret = "class " + generate_functor_name() + "_groupdef{\n"; + ret += "public:\n"; + for(g=0;ggb_tbl.size();g++){ + sprintf(tmpstr,"gb_var%d",g); + ret+="\t"+this->gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + } +// empty strucutred literals + map::iterator sii; + for(sii=structured_types.begin();sii!=structured_types.end();++sii){ + data_type dt(sii->second); + literal_t empty_lit(sii->first); + ret += "\t"+dt.make_host_cvar(empty_lit.hfta_empty_literal_name())+";\n"; + } +// Constructors + if(structured_types.size()==0){ + ret += "\t"+generate_functor_name() + "_groupdef(){};\n"; + }else{ + ret += "\t"+generate_functor_name() + "_groupdef(){}\n"; + } + + + ret += "\t"+generate_functor_name() + "_groupdef("+ + this->generate_functor_name() + "_groupdef *gd){\n"; + for(g=0;gis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&gb_var%d, &(gd->gb_var%d));\n", + gdt->get_hfta_buffer_assign_copy().c_str(),g,g ); + ret += tmpstr; + }else{ + sprintf(tmpstr,"\t\tgb_var%d = gd->gb_var%d;\n",g,g); + ret += tmpstr; + } + } + ret += "\t}\n"; + ret += "\t"+generate_functor_name() + "_groupdef("+ + this->generate_functor_name() + "_groupdef *gd, bool *pattern){\n"; + for(sii=structured_types.begin();sii!=structured_types.end();++sii){ + literal_t empty_lit(sii->first); + ret += "\t\t"+empty_lit.to_hfta_C_code("&"+empty_lit.hfta_empty_literal_name())+";\n"; + } + for(g=0;gis_buffer_type()){ + sprintf(tmpstr,"\t\t\t%s(&gb_var%d, &(gd->gb_var%d));\n", + gdt->get_hfta_buffer_assign_copy().c_str(),g,g ); + ret += tmpstr; + }else{ + sprintf(tmpstr,"\t\t\tgb_var%d = gd->gb_var%d;\n",g,g); + ret += tmpstr; + } + ret += "\t\t}else{\n"; + literal_t empty_lit(gdt->type_indicator()); + if(empty_lit.is_cpx_lit()){ + ret +="\t\t\tgb_var"+int_to_string(g)+"= "+empty_lit.hfta_empty_literal_name()+";\n"; + }else{ + ret +="\t\t\tgb_var"+int_to_string(g)+"="+empty_lit.to_hfta_C_code("")+";\n"; + } + ret += "\t\t}\n"; + } + ret += "\t};\n"; +// destructor + ret += "\t~"+ generate_functor_name() + "_groupdef(){\n"; + for(g=0;gis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&gb_var%d);\n", + gdt->get_hfta_buffer_destroy().c_str(), g ); + ret += tmpstr; + } + } + ret += "\t};\n"; + + data_type *tgdt; + for(g=0;gis_temporal()){ + tgdt = gdt; + break; + } + } + ret += tgdt->get_host_cvar_type()+" get_curr_gb(){\n"; + ret+="\treturn gb_var"+int_to_string(g)+";\n"; + ret+="}\n"; + + ret +="};\n\n"; + +//-------------------------------- +// aggr definition class + ret += "class " + this->generate_functor_name() + "_aggrdef{\n"; + ret += "public:\n"; + for(a=0;amake_host_cvar(tmpstr)+";\n"; + if(aggr_tbl.get_op(a) == "AVG"){ // HACK! + data_type cnt_type = data_type("ullong"); + ret+="\t"+cnt_type.make_host_cvar(string(tmpstr)+"_cnt")+";\n"; + ret+="\t"+ aggr_tbl.get_data_type(a)->make_host_cvar(string(tmpstr)+"_sum")+";\n"; + } + }else{ + ret+="\t"+ aggr_tbl.get_storage_type(a)->make_host_cvar(tmpstr)+";\n"; + } + } +// Constructors + ret += "\t"+this->generate_functor_name() + "_aggrdef(){};\n"; +// destructor + ret += "\t~"+this->generate_functor_name() + "_aggrdef(){\n"; + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&aggr_var%d);\n", + adt->get_hfta_buffer_destroy().c_str(), a ); + ret += tmpstr; + } + }else{ + ret+="\t\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_DESTROY_("; + if(aggr_tbl.get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(aggr_var"+int_to_string(a)+"));\n"; + } + } + ret += "\t};\n"; + ret +="};\n\n"; + +//------------------------------------------- +// group-by patterns for the functor, +// initialization within the class is cumbersome. + int n_patterns = gb_tbl.gb_patterns.size(); + int i,j; + ret += "bool "+this->generate_functor_name()+"_gb_patterns["+int_to_string(n_patterns)+ + "]["+int_to_string(gb_tbl.size())+"] = {\n"; + if(n_patterns == 0){ + for(i=0;i0) ret += ","; + ret += "true"; + } + }else{ + for(i=0;i0) ret += ",\n"; + ret += "\t{"; + for(j=0;j0) ret += ", "; + if(gb_tbl.gb_patterns[i][j]){ + ret += "true"; + }else{ + ret += "false"; + } + } + ret += "}"; + } + ret += "\n"; + } + ret += "};\n"; + + +//-------------------------------- +// gb functor class + ret += "class " + this->generate_functor_name() + "{\n"; + +// Find variables referenced in this query node. + + col_id_set cid_set; + col_id_set::iterator csi; + + for(w=0;wpr,cid_set,segen_gb_tbl); + for(w=0;wpr,cid_set,segen_gb_tbl); + for(g=0;gse,cid_set,segen_gb_tbl); // descends into aggregates + } + + +// Private variables : store the state of the functor. +// 1) variables for unpacked attributes +// 2) offsets of the upacked attributes +// 3) storage of partial functions +// 4) storage of complex literals (i.e., require a constructor) + + ret += "private:\n"; + + // var to save the schema handle + ret += "\tint schema_handle0;\n"; + // metadata from schema handle + ret += "\tint tuple_metadata_offset0;\n"; + + // generate the declaration of all the variables related to + // temp tuples generation + ret += gen_decl_temp_vars(); + +// unpacked attribute storage, offsets + ret += "//\t\tstorage and offsets of accessed fields.\n"; + ret += generate_access_vars(cid_set, schema); + +// Variables to store results of partial functions. +// WARNING find_partial_functions modifies the SE +// (it marks the partial function id). + ret += "//\t\tParital function result storage\n"; + vector partial_fcns; + vector fcn_ref_cnt; + vector is_partial_fcn; + for(s=0;sse, &partial_fcns,NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns,NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns,NULL,NULL, Ext_fcns); + } + for(g=0;g0){ + ret += "/*\t\tVariables for storing results of partial functions. \t*/\n"; + ret += generate_partial_fcn_vars(partial_fcns,fcn_ref_cnt,is_partial_fcn,false); + } + +// Complex literals (i.e., they need constructors) + ret += "//\t\tComplex literal storage.\n"; + cplx_lit_table *complex_literals = this->get_cplx_lit_tbl(Ext_fcns); + ret += generate_complex_lit_vars(complex_literals); + +// Pass-by-handle parameters + ret += "//\t\tPass-by-handle storage.\n"; + vector param_handle_table = this->get_handle_param_tbl(Ext_fcns); + ret += generate_pass_by_handle_vars(param_handle_table); + + +// variables to hold parameters. + ret += "//\tfor query parameters\n"; + ret += generate_param_vars(param_tbl); + +// Is there a temporal flush? If so create flush temporaries, +// create flush indicator. + bool uses_temporal_flush = false; + for(g=0;gis_temporal()) + uses_temporal_flush = true; + } + + if(uses_temporal_flush){ + ret += "//\t\tFor temporal flush\n"; + for(g=0;gis_temporal()){ + sprintf(tmpstr,"last_gb%d",g); + ret+="\t"+gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + sprintf(tmpstr,"last_flushed_gb%d",g); + ret+="\t"+gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + } + } + ret += "\tbool needs_temporal_flush;\n"; + } + + +// The publicly exposed functions + + ret += "\npublic:\n"; + + +//------------------- +// The functor constructor +// pass in the schema handle. +// 1) make assignments to the unpack offset variables +// 2) initialize the complex literals + + ret += "//\t\tFunctor constructor.\n"; + ret += this->generate_functor_name()+"(int schema_handle0){\n"; + + // save the schema handle + ret += "\t\tthis->schema_handle0 = schema_handle0;\n"; + +// unpack vars + ret += "//\t\tGet offsets for unpacking fields from input tuple.\n"; + ret += gen_access_var_init(cid_set); +// tuple metadata + ret += "tuple_metadata_offset0 = ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + +// complex literals + ret += "//\t\tInitialize complex literals.\n"; + ret += gen_complex_lit_init(complex_literals); + +// Initialize partial function results so they can be safely GC'd + ret += gen_partial_fcn_init(partial_fcns); + +// Initialize non-query-parameter parameter handles + ret += gen_pass_by_handle_init(param_handle_table); + +// temporal flush variables +// ASSUME that structured values won't be temporal. + if(uses_temporal_flush){ + ret += "//\t\tInitialize temporal flush variables.\n"; + for(g=0;gis_temporal()){ + literal_t gl(gdt->type_indicator()); + sprintf(tmpstr,"\tlast_gb%d = %s;\n",g, gl.to_hfta_C_code("").c_str()); + ret.append(tmpstr); + sprintf(tmpstr,"\tlast_flushed_gb%d = %s;\n",g, gl.to_hfta_C_code("").c_str()); + ret.append(tmpstr); + } + } + ret += "\tneeds_temporal_flush = false;\n"; + } + + // Init temporal attributes referenced in select list + ret += gen_init_temp_vars(schema, select_list, segen_gb_tbl); + + ret += "}\n\n"; + +//------------------- +// Functor destructor + ret += "//\t\tFunctor destructor.\n"; + ret += "~"+this->generate_functor_name()+"(){\n"; + +// clean up buffer type complex literals + ret += gen_complex_lit_dtr(complex_literals); + +// Deregister the pass-by-handle parameters + ret += "/* register and de-register the pass-by-handle parameters */\n"; + ret += gen_pass_by_handle_dtr(param_handle_table); + +// clean up partial function results. + ret += "/* clean up partial function storage */\n"; + ret += gen_partial_fcn_dtr(partial_fcns); + +// Destroy the parameters, if any need to be destroyed + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + + ret += "};\n\n"; + + +//------------------- +// Parameter manipulation routines + ret += generate_load_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + ret += generate_delete_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + +//------------------- +// Register new parameter block + + ret += "int set_param_block(gs_int32_t sz, void* value){\n"; + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + ret += "\treturn this->load_params_"+this->generate_functor_name()+ + "(sz, value);\n"; + ret += "};\n\n"; + +// ----------------------------------- +// group-by pattern support + + ret += +"int n_groupby_patterns(){\n" +" return "+int_to_string(gb_tbl.gb_patterns.size())+";\n" +"}\n" +"bool *get_pattern(int p){\n" +" return "+this->generate_functor_name()+"_gb_patterns[p];\n" +"}\n\n" +; + + + + +//------------------- +// the create_group method. +// This method creates a group in a buffer passed in +// (to allow for creation on the stack). +// There are also a couple of side effects: +// 1) evaluate the WHERE clause (and therefore, unpack all partial fcns) +// 2) determine if a temporal flush is required. + + ret += this->generate_functor_name()+"_groupdef *create_group(host_tuple &tup0, gs_sp_t buffer){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + + if(partial_fcns.size()>0){ // partial fcn access failure + ret += "\tgs_retval_t retval = 0;\n"; + ret += "\n"; + } +// return value + ret += "\t"+generate_functor_name()+"_groupdef *gbval = ("+generate_functor_name()+ + "_groupdef *) buffer;\n"; + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + set w_pfcns; // partial fcns in where clause + for(w=0;wpr, w_pfcns); + + set ag_gb_pfcns; // partial fcns in gbdefs, aggr se's + for(g=0;gnode_name, 0); + col_id_set found_cids; // colrefs unpacked thus far. + ret += gen_unpack_temp_vars(schema, found_cids, select_list, segen_gb_tbl, needs_xform); + + +// Save temporal group-by variables + + + ret.append("\n\t//\t\tCompute temporal groupby attributes\n\n"); + + for(g=0;gis_temporal()){ + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); + ret.append(tmpstr); + } + } + ret.append("\n"); + + + +// Compare the temporal GB vars with the stored ones, +// set flush indicator and update stored GB vars if there is any change. + +ret += "// hfta_disorder = "+int_to_string(hfta_disorder)+"\n"; + if(hfta_disorder < 2){ + if(uses_temporal_flush){ + ret+= "\tif( !( ("; + bool first_one = true; + for(g=0;gis_temporal()){ + sprintf(tmpstr,"last_gb%d",g); string lhs_op = tmpstr; + sprintf(tmpstr,"gbval->gb_var%d",g); string rhs_op = tmpstr; + if(first_one){first_one = false;} else {ret += ") && (";} + ret += generate_equality_test(lhs_op, rhs_op, gdt); + } + } + ret += ") ) ){\n"; + for(g=0;gis_temporal()){ + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&(gbval->gb_var%d),&last_gb%d);\n",gdt->get_hfta_buffer_replace().c_str(),g,g); + }else{ + sprintf(tmpstr,"\t\tlast_flushed_gb%d = last_gb%d;\n",g,g); + ret += tmpstr; + sprintf(tmpstr,"\t\tlast_gb%d = gbval->gb_var%d;\n",g,g); + } + ret += tmpstr; + } + } + ret += "\t\tneeds_temporal_flush=true;\n"; + ret += "\t\t}else{\n" + "\t\t\tneeds_temporal_flush=false;\n" + "\t\t}\n"; + } + }else{ + ret+= "\tif(temp_tuple_received && !( ("; + bool first_one = true; + for(g=0;gis_temporal()){ + sprintf(tmpstr,"last_gb%d",g); string lhs_op = tmpstr; + sprintf(tmpstr,"gbval->gb_var%d",g); string rhs_op = tmpstr; + if(first_one){first_one = false;} else {ret += ") && (";} + ret += generate_equality_test(lhs_op, rhs_op, gdt); + break; + } + } + ret += ") ) ){\n"; + int temporal_g = 0; + for(g=0;gis_temporal()){ + temporal_g = g; + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&(gbval->gb_var%d),&last_gb%d);\n",gdt->get_hfta_buffer_replace().c_str(),g,g); + }else{ + sprintf(tmpstr,"\t\tlast_flushed_gb%d = last_gb%d;\n",g,g); + ret += tmpstr; + sprintf(tmpstr,"\t\tlast_gb%d = gbval->gb_var%d;\n",g,g); + } + ret += tmpstr; + break; + } + } + data_type *tgdt = gb_tbl.get_data_type(temporal_g); + literal_t gl(tgdt->type_indicator()); + ret += "\t\tif(last_flushed_gb"+int_to_string(temporal_g)+">"+gl.to_hfta_C_code("")+")\n"; + ret += "\t\t\tneeds_temporal_flush=true;\n"; + ret += "\t\t}else{\n" + "\t\t\tneeds_temporal_flush=false;\n" + "\t\t}\n"; + } + + +// For temporal status tuple we don't need to do anything else + ret += "\tif (temp_tuple_received) return NULL;\n\n"; + + for(w=0;wpr, found_cids, new_cids, segen_gb_tbl); + +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "NULL", needs_xform); +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(where[w]->pr, pfcn_refs); + ret += gen_unpack_partial_fcn(schema, partial_fcns, pfcn_refs,"NULL"); + + ret += "\tif( !("+generate_predicate_code(where[w]->pr,schema)+ + +") ) return(NULL);\n"; + } + +// The partial functions ref'd in the group-by var and aggregate +// definitions must also be evaluated. If one returns false, +// then implicitly the predicate is false. + set::iterator pfsi; + + if(ag_gb_pfcns.size() > 0) + ret += "//\t\tUnpack remaining partial fcns.\n"; + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, ag_gb_pfcns, + found_cids, segen_gb_tbl, "NULL", needs_xform); + +// Unpack the group-by variables + + for(g=0;gis_temporal()){ +// Find the new fields ref'd by this GBvar def. + col_id_set new_cids; + get_new_se_cids(gb_tbl.get_def(g), found_cids, new_cids, segen_gb_tbl); +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "NULL", needs_xform); + + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); +/* +// There seems to be no difference between the two +// branches of the IF statement. + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->is_buffer_type()){ +// Create temporary copy. + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); + }else{ + scalarexp_t *gse = gb_tbl.get_def(g); + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g,generate_se_code(gse,schema).c_str()); + } +*/ + + ret.append(tmpstr); + } + } + ret.append("\n"); + + ret+= "\treturn gbval;\n"; + ret += "};\n\n\n"; + +//-------------------------------------------------------- +// Create and initialize an aggregate object + + ret += this->generate_functor_name()+"_aggrdef *create_aggregate(host_tuple &tup0, gs_sp_t buffer){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// return value + ret += "\t"+generate_functor_name()+"_aggrdef *aggval = ("+generate_functor_name()+ + "_aggrdef *)buffer;\n"; + + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"aggr_tmp_%d", a); + ret+=adt->make_host_cvar(tmpstr)+";\n"; + } + } + } + +// Unpack all remaining attributes + ret += gen_remaining_colrefs(schema, cid_set, found_cids, "NULL", needs_xform); + for(a=0;aaggr_var%d",a); + string assignto_var = tmpstr; + ret += "\t"+generate_aggr_init(assignto_var,&aggr_tbl,a, schema); + } + + ret += "\treturn aggval;\n"; + ret += "};\n\n"; + +//-------------------------------------------------------- +// update an aggregate object + + ret += "void update_aggregate(host_tuple &tup0, " + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// use of temporaries depends on the aggregate, +// generate them in generate_aggr_update + + +// Unpack all remaining attributes + ret += gen_remaining_colrefs(schema, cid_set, found_cids, "", needs_xform); + for(a=0;aaggr_var%d",a); + string varname = tmpstr; + ret.append(generate_aggr_update(varname,&aggr_tbl,a, schema)); + } + + ret += "\treturn;\n"; + ret += "};\n"; + +//--------------------------------------------------- +// Flush test + + ret += "\tbool flush_needed(){\n"; + if(uses_temporal_flush){ + ret += "\t\treturn needs_temporal_flush;\n"; + }else{ + ret += "\t\treturn false;\n"; + } + ret += "\t};\n"; + +//--------------------------------------------------- +// create output tuple +// Unpack the partial functions ref'd in the where clause, +// select clause. Evaluate the where clause. +// Finally, pack the tuple. + +// I need to use special code generation here, +// so I'll leave it in longhand. + + ret += "host_tuple create_output_tuple(" + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval, bool &failed){\n"; + + ret += "\thost_tuple tup;\n"; + ret += "\tfailed = false;\n"; + ret += "\tgs_retval_t retval = 0;\n"; + + string gbvar = "gbval->gb_var"; + string aggvar = "aggval->"; + +// Create cached temporaries for UDAF return values. + for(a=0;aget_fcn_dt(afcn_id); + sprintf(tmpstr,"udaf_ret_%d", a); + ret+="\t"+adt->make_host_cvar(tmpstr)+";\n"; + } + } + + +// First, get the return values from the UDAFS + for(a=0;aget_type() != fstring_t) ret+="&"; + ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n"; + } + } + + set hv_sl_pfcns; + for(w=0;wpr, hv_sl_pfcns); + } + for(s=0;sse, hv_sl_pfcns); + } + +// clean up the partial fcn results from any previous execution + ret += gen_partial_fcn_dtr(partial_fcns,hv_sl_pfcns); + +// Unpack them now + for(pfsi=hv_sl_pfcns.begin();pfsi!=hv_sl_pfcns.end();++pfsi){ + ret += unpack_partial_fcn_fm_aggr(partial_fcns[(*pfsi)], (*pfsi), gbvar, aggvar, schema); + ret += "\tif(retval){ failed = true; return(tup);}\n"; + } + +// Evalaute the HAVING clause +// TODO: this seems to have a ++ operator rather than a + operator. + for(w=0;wpr,gbvar, aggvar, schema) +") ) { failed = true; return(tup);}\n"; + } + +// Now, compute the size of the tuple. + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. +// TODO: should I be using the selvar generation routine? + + ret += "//\t\tCompute the size of the tuple.\n"; + ret += "//\t\t\tNote: buffer storage packed at the end of the tuple.\n"; + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type() && + !( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"selvar_%d",s); + ret+="\t"+sdt->make_host_cvar(tmpstr)+" = "; + ret += generate_se_code_fm_aggr(se,gbvar, aggvar, schema) +";\n"; + } + } + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + ret+="\ttup.tuple_size = sizeof(" + generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t)"; + for(s=0;s0) ret += "+"; + scalarexp_t *se = select_list[s]->se; + data_type *sdt = select_list[s]->se->get_data_type(); + if(sdt->is_buffer_type()){ + if(!( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr," + %s(&selvar_%d)", sdt->get_hfta_buffer_size().c_str(),s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr," + %s(&%s)", sdt->get_hfta_buffer_size().c_str(),generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + } + } + } + ret.append(";\n"); + +// Allocate tuple data block. + ret += "//\t\tCreate the tuple block.\n"; + ret += "\ttup.data = malloc(tup.tuple_size);\n"; + ret += "\ttup.heap_resident = true;\n"; + +// Mark tuple as regular + ret += "\t*((gs_sp_t )tup.data + sizeof(" + generate_tuple_name( this->get_node_name()) +")) = REGULAR_TUPLE;\n"; + +// ret += "\ttup.channel = 0;\n"; + ret += "\t"+generate_tuple_name( this->get_node_name())+" *tuple = ("+ + generate_tuple_name( this->get_node_name())+" *)(tup.data);\n"; + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + ret += "\tint tuple_pos = sizeof("+generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t);\n"; + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type()){ + if(!( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &selvar_%d, ((gs_sp_t)tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, s); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&selvar_%d);\n", sdt->get_hfta_buffer_size().c_str(), s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &%s, ((gs_sp_t)tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&%s);\n", sdt->get_hfta_buffer_size().c_str(), generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + } + }else{ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret.append(tmpstr); + ret.append(generate_se_code_fm_aggr(se,gbvar, aggvar, schema) ); + ret.append(";\n"); + } + } + +// Destroy string temporaries + ret += gen_buffer_selvars_dtr(select_list); +// Destroy string return vals of UDAFs + for(a=0;aget_fcn_dt(afcn_id); + if(adt->is_buffer_type()){ + sprintf(tmpstr,"\t%s(&udaf_ret_%d);\n", + adt->get_hfta_buffer_destroy().c_str(), a ); + ret += tmpstr; + } + } + } + + + ret += "\treturn tup;\n"; + ret += "};\n"; + + +//------------------------------------------------------------------- +// Temporal update functions + + ret+="bool temp_status_received(){return temp_tuple_received;};\n\n"; + + for(g=0;gis_temporal()){ + tgdt = gdt; + break; + } + } + ret += tgdt->get_host_cvar_type()+" get_last_flushed_gb(){\n"; + ret+="\treturn last_flushed_gb"+int_to_string(g)+";\n"; + ret+="}\n"; + ret += tgdt->get_host_cvar_type()+" get_last_gb(){\n"; + ret+="\treturn last_gb"+int_to_string(g)+";\n"; + ret+="}\n"; + + + + +// create a temp status tuple + ret += "int create_temp_status_tuple(host_tuple& result, bool flush_finished) {\n\n"; + + ret += gen_init_temp_status_tuple(this->get_node_name()); + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + for(s=0;sse->get_data_type(); + if(sdt->is_temporal()){ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret += tmpstr; + + sprintf(tmpstr,"(flush_finished) ? %s : %s ", generate_se_code(select_list[s]->se,schema).c_str(), generate_se_code_fm_aggr(select_list[s]->se,"last_flushed_gb", "", schema).c_str()); + ret += tmpstr; + ret += ";\n"; + } + } + + + ret += "\treturn 0;\n"; + ret += "};};\n\n\n"; + + +//---------------------------------------------------------- +// The hash function + + ret += "struct "+generate_functor_name()+"_hash_func{\n"; + ret += "\tgs_uint32_t operator()(const "+generate_functor_name()+ + "_groupdef *grp) const{\n"; + ret += "\t\treturn( ("; + for(g=0;g0) ret += "^"; + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->use_hashfunc()){ + if(gdt->is_buffer_type()) + sprintf(tmpstr,"(%s*%s(&(grp->gb_var%d)))",hash_nums[g%NRANDS].c_str(),gdt->get_hfta_hashfunc().c_str(),g); + else + sprintf(tmpstr,"(%s*%s(grp->gb_var%d))",hash_nums[g%NRANDS].c_str(),gdt->get_hfta_hashfunc().c_str(),g); + }else{ + sprintf(tmpstr,"(%s*grp->gb_var%d)",hash_nums[g%NRANDS].c_str(),g); + } + ret += tmpstr; + } + ret += ") >> 32);\n"; + ret += "\t}\n"; + ret += "};\n\n"; + +//---------------------------------------------------------- +// The comparison function + + ret += "struct "+generate_functor_name()+"_equal_func{\n"; + ret += "\tbool operator()(const "+generate_functor_name()+"_groupdef *grp1, "+ + generate_functor_name()+"_groupdef *grp2) const{\n"; + ret += "\t\treturn( ("; + + for(g=0;g0) ret += ") && ("; + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->complex_comparison(gdt)){ + if(gdt->is_buffer_type()) + sprintf(tmpstr,"(%s(&(grp1->gb_var%d), &(grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + else + sprintf(tmpstr,"(%s((grp1->gb_var%d), (grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + }else{ + sprintf(tmpstr,"grp1->gb_var%d == grp2->gb_var%d",g,g); + } + ret += tmpstr; + } + ret += ") );\n"; + ret += "\t}\n"; + ret += "};\n\n"; + + + return(ret); +} + +string sgah_qpn::generate_operator(int i, string params){ + + if(hfta_disorder < 2){ + return( + " groupby_operator<" + + generate_functor_name()+","+ + generate_functor_name() + "_groupdef, " + + generate_functor_name() + "_aggrdef, " + + generate_functor_name()+"_hash_func, "+ + generate_functor_name()+"_equal_func " + "> *op"+int_to_string(i)+" = new groupby_operator<"+ + generate_functor_name()+","+ + generate_functor_name() + "_groupdef, " + + generate_functor_name() + "_aggrdef, " + + generate_functor_name()+"_hash_func, "+ + generate_functor_name()+"_equal_func " + ">("+params+", \"" + get_node_name() + +"\");\n" + ); + } + data_type *tgdt; + for(int g=0;gis_temporal()){ + tgdt = gdt; + break; + } + } + + return( + " groupby_operator_oop<" + + generate_functor_name()+","+ + generate_functor_name() + "_groupdef, " + + generate_functor_name() + "_aggrdef, " + + generate_functor_name()+"_hash_func, "+ + generate_functor_name()+"_equal_func, " + + tgdt->get_host_cvar_type() + + "> *op"+int_to_string(i)+" = new groupby_operator_oop<"+ + generate_functor_name()+","+ + generate_functor_name() + "_groupdef, " + + generate_functor_name() + "_aggrdef, " + + generate_functor_name()+"_hash_func, "+ + generate_functor_name()+"_equal_func, " + + tgdt->get_host_cvar_type() + + ">("+params+", \"" + get_node_name() + +"\");\n" + ); +} + + +//////////////////////////////////////////////// +/// MERGE operator +/// MRG functor +//////////////////////////////////////////// + +string mrg_qpn::generate_functor_name(){ + return("mrg_functor_" + normalize_name(this->get_node_name())); +} + +string mrg_qpn::generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, vector &needs_xform){ + int tblref; + + +// Sanity check + if(fm.size() != mvars.size()){ + fprintf(stderr,"INTERNAL ERROR in mrg_qpn::generate_functor fm.size=%lu, mvars.size=%lu\n",fm.size(),mvars.size()); + exit(1); + } + if(fm.size() != 2){ + fprintf(stderr,"INTERNAL ERROR in mrg_qpn::generate_functor fm.size=mvars.size=%lu\n",fm.size()); + exit(1); + } + + +// Initialize generate utility globals + segen_gb_tbl = NULL; + + string ret = "class " + this->generate_functor_name() + "{\n"; + +// Private variable: +// 1) Vars for unpacked attrs. +// 2) offsets ofthe unpakced attrs +// 3) last_posted_timestamp + + data_type dta( + schema->get_type_name(mvars[0]->get_schema_ref(), mvars[0]->get_field()), + schema->get_modifier_list(mvars[0]->get_schema_ref(), mvars[0]->get_field()) + ); + data_type dtb( + schema->get_type_name(mvars[1]->get_schema_ref(), mvars[1]->get_field()), + schema->get_modifier_list(mvars[1]->get_schema_ref(), mvars[1]->get_field()) + ); + + ret += "private:\n"; + + // var to save the schema handle + ret += "\tint schema_handle0;\n"; + + // generate the declaration of all the variables related to + // temp tuples generation + ret += gen_decl_temp_vars(); + +// unpacked attribute storage, offsets + ret += "//\t\tstorage and offsets of accessed fields.\n"; + ret += "\tint tuple_metadata_offset0, tuple_metadata_offset1;\n"; + tblref = 0; + sprintf(tmpstr,"unpack_var_%s_%d", mvars[0]->get_field().c_str(), tblref); + ret+="\t"+dta.make_host_cvar(tmpstr)+";\n"; + sprintf(tmpstr,"\tgs_int32_t unpack_offset_%s_%d;\n", mvars[0]->get_field().c_str(), tblref); + ret.append(tmpstr); + tblref = 1; + sprintf(tmpstr,"unpack_var_%s_%d", mvars[1]->get_field().c_str(), tblref); + ret+="\t"+dtb.make_host_cvar(tmpstr)+";\n"; + sprintf(tmpstr,"\tgs_int32_t unpack_offset_%s_%d;\n", mvars[1]->get_field().c_str(), tblref); + ret.append(tmpstr); + + ret += "//\t\tRemember the last posted timestamp.\n"; + ret+="\t"+dta.make_host_cvar("last_posted_timestamp_0")+";\n"; + ret+="\t"+dta.make_host_cvar("last_posted_timestamp_1")+";\n"; + ret+="\t"+dta.make_host_cvar("timestamp")+";\n"; + ret+="\t"+dta.make_host_cvar("slack")+";\n"; +// ret += "\t bool first_execution_0, first_execution_1;\n"; + +// variables to hold parameters. + ret += "//\tfor query parameters\n"; + ret += generate_param_vars(param_tbl); + + ret += "public:\n"; +//------------------- +// The functor constructor +// pass in a schema handle (e.g. for the 1st input stream), +// use it to determine how to unpack the merge variable. +// ASSUME that both streams have the same layout, +// just duplicate it. + +// unpack vars + ret += "//\t\tFunctor constructor.\n"; + ret += this->generate_functor_name()+"(int schema_handle0){\n"; + + // var to save the schema handle + ret += "\tthis->schema_handle0 = schema_handle0;\n"; + ret += "\ttuple_metadata_offset0=ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + ret += "\ttuple_metadata_offset1=ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + + ret += "//\t\tGet offsets for unpacking fields from input tuple.\n"; + + sprintf(tmpstr,"\tunpack_offset_%s_%d = ftaschema_get_field_offset_by_name(schema_handle0, \"%s\");\n", mvars[0]->get_field().c_str(), 0,mvars[0]->get_field().c_str()); + ret.append(tmpstr); + sprintf(tmpstr,"\tunpack_offset_%s_%d = unpack_offset_%s_%d;\n",mvars[1]->get_field().c_str(), 1,mvars[0]->get_field().c_str(), 0); + ret.append(tmpstr); +// ret+="\tfirst_execution_0 = first_execution_1 = true;\n"; + if(slack) + ret+="\tslack = "+generate_se_code(slack,schema)+";\n"; + else + ret+="\tslack = 0;\n"; + +// Initialize internal state + ret += "\ttemp_tuple_received = false;\n"; + + // Init last timestamp values to minimum value for their type + if (dta.is_increasing()) + ret+="\tlast_posted_timestamp_0 = last_posted_timestamp_1 = " + dta.get_min_literal() + ";\n"; + else + ret+="\tlast_posted_timestamp_0 = last_posted_timestamp_1 = " + dta.get_max_literal() + ";\n"; + + + ret += "};\n\n"; + + ret += "//\t\tFunctor destructor.\n"; + ret += "~"+this->generate_functor_name()+"(){\n"; + +// Destroy the parameters, if any need to be destroyed + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + + ret+="};\n\n"; + + +// no pass-by-handle params. + vector param_handle_table; + +// Parameter manipulation routines + ret += generate_load_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + ret += generate_delete_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + +// Register new parameter block + + ret += "int set_param_block(gs_int32_t sz, void* value){\n"; + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + ret += "\treturn this->load_params_"+this->generate_functor_name()+ + "(sz, value);\n"; + ret += "};\n\n"; + + +// ----------------------------------- +// Compare method + + string unpack_fcna; + if(needs_xform[0]) unpack_fcna = dta.get_hfta_unpack_fcn(); + else unpack_fcna = dta.get_hfta_unpack_fcn_noxf(); + string unpack_fcnb; + if(needs_xform[1]) unpack_fcnb = dtb.get_hfta_unpack_fcn(); + else unpack_fcnb = dtb.get_hfta_unpack_fcn_noxf(); + +/* + ret+="\tint compare(const host_tuple& tup1, const host_tuple& tup2) const{ \n"; + ret+="\t"+dta.make_host_cvar("timestamp1")+";\n"; + ret+="\t"+dta.make_host_cvar("timestamp2")+";\n"; + ret+="\tgs_int32_t problem;\n"; + ret+="\tif (tup1.channel == 0) {\n"; + sprintf(tmpstr,"\t\ttimestamp1 = %s(tup1.data, tup1.tuple_size, unpack_offset_%s_%d, &problem);\n", unpack_fcna.c_str(), mvars[0]->get_field().c_str(), 0); + ret += tmpstr; + sprintf(tmpstr,"\t\ttimestamp2 = %s(tup2.data, tup2.tuple_size, unpack_offset_%s_%d, &problem);\n", unpack_fcnb.c_str(), mvars[1]->get_field().c_str(), 1); + ret += tmpstr; + ret+="\t}else{\n"; + sprintf(tmpstr,"\t\ttimestamp1 = %s(tup1.data, tup1.tuple_size, unpack_offset_%s_%d, &problem);\n", unpack_fcna.c_str(), mvars[0]->get_field().c_str(), 1); + ret += tmpstr; + sprintf(tmpstr,"\t\ttimestamp2 = %s(tup2.data, tup2.tuple_size, unpack_offset_%s_%d, &problem);\n", unpack_fcnb.c_str(), mvars[1]->get_field().c_str(), 0); + ret += tmpstr; + ret+="\t}\n"; + ret+= +" if (timestamp1 > timestamp2+slack)\n" +" return 1;\n" +" else if (timestamp1 < timestamp2)\n" +" return -1;\n" +" else\n" +" return 0;\n" +"\n" +" }\n\n"; +*/ + +ret += +" void get_timestamp(const host_tuple& tup0){\n" +" gs_int32_t problem;\n" +; + sprintf(tmpstr,"\t\ttimestamp = %s_nocheck(tup0.data, unpack_offset_%s_%d);\n", unpack_fcna.c_str(), mvars[0]->get_field().c_str(), 0); + ret += tmpstr; +ret += +" }\n" +"\n" +; + + + +// Compare to temp status. + ret+= +" int compare_with_temp_status(int channel) {\n" +" // check if tuple is temp status tuple\n" +"\n" +" if (channel == 0) {\n" +//" if(first_execution_0) return 1;\n" +" if (timestamp == last_posted_timestamp_0)\n" +" return 0;\n" +" else if (timestamp < last_posted_timestamp_0)\n" +" return -1;\n" +" else\n" +" return 1;\n" +" }\n" +//" if(first_execution_1) return 1;\n" +" if (timestamp == last_posted_timestamp_1)\n" +" return 0;\n" +" else if (timestamp < last_posted_timestamp_1)\n" +" return -1;\n" +" else\n" +" return 1;\n" +"\n" +" }\n" +; + + ret += +" int compare_stored_with_temp_status(const host_tuple& tup0, int channel)/* const*/ {\n" +; + ret+="\t"+dta.make_host_cvar("l_timestamp")+";\n"; + ret+="\tgs_int32_t problem;\n"; + + sprintf(tmpstr,"\t\tl_timestamp = %s_nocheck(tup0.data, unpack_offset_%s_%d);\n", unpack_fcna.c_str(), mvars[0]->get_field().c_str(), 0); + ret += tmpstr; + ret+="\tif (channel == 0) {\n"; +// ret+="\tif(first_execution_0) return 1;\n"; + ret+= +" if (l_timestamp == last_posted_timestamp_0)\n" +" return 0;\n" +" else if (l_timestamp < last_posted_timestamp_0)\n" +" return -1;\n" +" else\n" +" return 1;\n" +" }\n"; +// ret+="\tif(first_execution_1) return 1;\n"; + ret+= +" if (l_timestamp == last_posted_timestamp_1)\n" +" return 0;\n" +" else if (l_timestamp < last_posted_timestamp_1)\n" +" return -1;\n" +" else\n" +" return 1;\n" +"\n" +" }\n\n"; + + +// update temp status. + ret+= +" int update_temp_status(const host_tuple& tup) {\n" +" if (tup.channel == 0) {\n" +" last_posted_timestamp_0=timestamp;\n" +//" first_execution_0 = false;\n" +" }else{\n" +" last_posted_timestamp_1=timestamp;\n" +//" first_execution_1 = false;\n" +" }\n" +" return 0;\n" +" }\n" +; + ret+= +" int update_stored_temp_status(const host_tuple& tup, int channel) {\n" +; + ret+="\t"+dta.make_host_cvar("l_timestamp")+";\n"; + ret+="\tgs_int32_t problem;\n"; + sprintf(tmpstr,"\t\tl_timestamp = %s_nocheck(tup.data, unpack_offset_%s_%d);\n", unpack_fcna.c_str(), mvars[0]->get_field().c_str(), 0); + ret += tmpstr; +ret+= +" if (tup.channel == 0) {\n" +" last_posted_timestamp_0=l_timestamp;\n" +//" first_execution_0 = false;\n" +" }else{\n" +" last_posted_timestamp_1=l_timestamp;\n" +//" first_execution_1 = false;\n" +" }\n" +" return 0;\n" +" }\n" +; +/* + ret+="\t"+dta.make_host_cvar("timestamp")+";\n"; + ret+="\tgs_int32_t problem;\n"; + ret+="\tif (tup.channel == 0) {\n"; + sprintf(tmpstr,"\t\ttimestamp = %s(tup.data, tup.tuple_size, unpack_offset_%s_%d, &problem);\n", unpack_fcna.c_str(), mvars[0]->get_field().c_str(), 0); + ret += tmpstr; + ret+="\t}else{\n"; + sprintf(tmpstr,"\t\ttimestamp = %s(tup.data, tup.tuple_size, unpack_offset_%s_%d, &problem);\n", unpack_fcnb.c_str(), mvars[1]->get_field().c_str(), 1); + ret += tmpstr; + ret+="\t}\n"; + ret+="\tif (tup.channel == 0) {\n"; + ret+="\tlast_posted_timestamp_0=timestamp;\n"; + ret +="\tfirst_execution_0 = false;\n"; + ret+="\t}else{\n"; + ret+="\tlast_posted_timestamp_1=timestamp;\n"; + ret +="\tfirst_execution_1 = false;\n"; + ret+="\t}\n"; + ret+= +" }\n\n"; +*/ + + +// update temp status modulo slack. + ret+="\tint update_temp_status_by_slack(const host_tuple& tup, int channel) {\n"; + if(slack){ + ret+="\t"+dta.make_host_cvar("timestamp")+";\n"; + ret+="\tgs_int32_t problem;\n"; + ret+="\tif (tup.channel == 0) {\n"; + sprintf(tmpstr,"\t\ttimestamp = %s_nocheck(tup.data, unpack_offset_%s_%d);\n", unpack_fcna.c_str(), mvars[0]->get_field().c_str(), 0); + ret += tmpstr; + ret+="\t}else{\n"; + sprintf(tmpstr,"\t\ttimestamp = %s_nocheck(tup.data, unpack_offset_%s_%d);\n", unpack_fcnb.c_str(), mvars[1]->get_field().c_str(), 1); + ret += tmpstr; + ret+="\t}\n"; +ret += +" if (channel == 0) {\n" +" if(first_execution_0){\n" +" last_posted_timestamp_0=timestamp - slack;\n" +" first_execution_0 = false;\n" +" }else{\n" +" if(last_posted_timestamp_0 < timestamp-slack)\n" +" last_posted_timestamp_0 = timestamp-slack;\n" +" }\n" +" }else{\n" +" if(first_execution_1){\n" +" last_posted_timestamp_1=timestamp - slack;\n" +" first_execution_1 = false;\n" +" }else{\n" +" if(last_posted_timestamp_1 < timestamp-slack)\n" +" last_posted_timestamp_1 = timestamp-slack;\n" +" }\n" +" }\n" +" return 0;\n" +" }\n\n"; + }else{ + ret += +" return 0;\n" +" }\n\n"; + } + + +// + ret+= +"bool temp_status_received(const host_tuple& tup0){\n" +" return ftaschema_is_temporal_tuple_offset(tuple_metadata_offset0, tup0.data);\n" +"};\n" +; +//"bool temp_status_received(){return temp_tuple_received;};\n\n"; + + +// create a temp status tuple + ret += "int create_temp_status_tuple(host_tuple& result) {\n\n"; + + ret += gen_init_temp_status_tuple(this->get_node_name()); + +// Start packing. + ret += "//\t\tPack the fields into the tuple.\n"; + + string fld_name = mvars[0]->get_field(); + int idx = table_layout->get_field_idx(fld_name); + field_entry* fld = table_layout->get_field(idx); + data_type dt(fld->get_type()); + +// if (needs_xform[0] && needs_xform[1] && dt.needs_hn_translation()) +// sprintf(tmpstr,"\ttuple->tuple_var%d = %s((last_posted_timestamp_0 < last_posted_timestamp_1) ? last_posted_timestamp_0 : last_posted_timestamp_1);\n",idx, dt.hton_translation().c_str()); +// else + sprintf(tmpstr,"\ttuple->tuple_var%d = (last_posted_timestamp_0 < last_posted_timestamp_1 ? last_posted_timestamp_0 : last_posted_timestamp_1);\n",idx); + + ret += tmpstr; + + ret += "\treturn 0;\n"; + ret += "}\n\n"; + +// Transform tuple (before output) + + + ret += "void xform_tuple(host_tuple &tup){\n"; + if((needs_xform[0] && !needs_xform[1]) || (needs_xform[1] && !needs_xform[0])){ + ret += "\tstruct "+generate_tuple_name(this->get_node_name())+" *tuple = ("+ + generate_tuple_name(this->get_node_name())+" *)(tup.data);\n"; + + vector flds = table_layout->get_fields(); + + ret+="\tif(tup.channel == 0){\n"; + if(needs_xform[0] && !needs_xform[1]){ + int f; + for(f=0;fget_type()); + if(dt.get_type() == v_str_t){ +// sprintf(tmpstr,"\ttuple->tuple_var%d.offset = htonl(tuple->tuple_var%d.offset);\n",f,f); +// ret += tmpstr; +// sprintf(tmpstr,"\ttuple->tuple_var%d.length = htonl(tuple->tuple_var%d.length);\n",f,f); +// ret += tmpstr; +// sprintf(tmpstr,"\ttuple->tuple_var%d.reserved = htonl(tuple->tuple_var%d.reserved);\n",f,f); +// ret += tmpstr; + }else{ + if(dt.needs_hn_translation()){ +// sprintf(tmpstr,"\ttuple->tuple_var%d = %s(tuple->tuple_var%d);\n", +// f, dt.hton_translation().c_str(), f); +// ret += tmpstr; + } + } + } + }else{ + ret += "\t\treturn;\n"; + } + ret.append("\t}\n"); + + + ret+="\tif(tup.channel == 1){\n"; + if(needs_xform[1] && !needs_xform[0]){ + int f; + for(f=0;fget_type()); + if(dt.get_type() == v_str_t){ +// sprintf(tmpstr,"\ttuple->tuple_var%d.offset = htonl(tuple->tuple_var%d.offset);\n",f,f); +// ret += tmpstr; +// sprintf(tmpstr,"\ttuple->tuple_var%d.length = htonl(tuple->tuple_var%d.length);\n",f,f); +// ret += tmpstr; +// sprintf(tmpstr,"\ttuple->tuple_var%d.reserved = htonl(tuple->tuple_var%d.reserved);\n",f,f); +// ret += tmpstr; + }else{ + if(dt.needs_hn_translation()){ +// sprintf(tmpstr,"\ttuple->tuple_var%d = %s(tuple->tuple_var%d);\n", +// f, dt.hton_translation().c_str(), f); +// ret += tmpstr; + } + } + } + }else{ + ret += "\t\treturn;\n"; + } + ret.append("\t}\n"); + } + + ret.append("};\n\n"); + +// print_warnings() : tell the functor if the user wants to print warnings. + ret += "bool print_warnings(){\n"; + if(definitions.count("print_warnings") && ( + definitions["print_warnings"] == "yes" || + definitions["print_warnings"] == "Yes" || + definitions["print_warnings"] == "YES" )) { + ret += "return true;\n"; + }else{ + ret += "return false;\n"; + } + ret.append("};\n\n"); + + +// Done with methods. + ret+="\n};\n\n"; + + + return(ret); +} + +string mrg_qpn::generate_operator(int i, string params){ + + if(disorder < 2){ + return( + " merge_operator<" + + generate_functor_name()+ + "> *op"+int_to_string(i)+" = new merge_operator<"+ + generate_functor_name()+ + ">("+params+",10000,\"" + get_node_name() + "\");\n" + ); + } + return( + " merge_operator_oop<" + + generate_functor_name()+ + "> *op"+int_to_string(i)+" = new merge_operator_oop<"+ + generate_functor_name()+ + ">("+params+",10000,\"" + get_node_name() + "\");\n" + ); +} + + +///////////////////////////////////////////////////////// +////// JOIN_EQ_HASH functor + + +string join_eq_hash_qpn::generate_functor_name(){ + return("join_eq_hash_functor_" + normalize_name(this->get_node_name())); +} + +string join_eq_hash_qpn::generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, vector &needs_xform){ + int p,s; + vector hashkey_dt; // data types in the hash key + vector temporal_dt; // data types in the temporal key + map l_equiv, r_equiv; // field equivalences + set pfcn_refs; + col_id_set new_cids, local_cids; + +//-------------------------------- +// Global init + + string plus_op = "+"; + +//-------------------------------- +// key definition class + string ret = "class " + generate_functor_name() + "_keydef{\n"; + ret += "public:\n"; +// Collect attributes from hash join predicates. +// ASSUME equality predicate. +// Use the upwardly compatible data type +// (infer from '+' operator if possible, else use left type) + for(p=0;phash_eq.size();++p){ + scalarexp_t *lse = hash_eq[p]->pr->get_left_se(); + scalarexp_t *rse = hash_eq[p]->pr->get_right_se(); + data_type *hdt = new data_type( + lse->get_data_type(), rse->get_data_type(), plus_op ); + if(hdt->get_type() == undefined_t){ + hashkey_dt.push_back(lse->get_data_type()->duplicate()); + delete hdt; + }else{ + hashkey_dt.push_back(hdt); + } + sprintf(tmpstr,"hashkey_var%d",p); + ret+="\t"+hashkey_dt[p]->make_host_cvar(tmpstr)+";\n"; + +// find equivalences +// NOTE: this code needs to be synched with the temporality +// checking done at join_eq_hash_qpn::get_fields + if(lse->get_operator_type()==SE_COLREF){ + l_equiv[lse->get_colref()->get_field()] = rse; + } + if(rse->get_operator_type()==SE_COLREF){ + r_equiv[rse->get_colref()->get_field()] = lse; + } + } + ret += "\tbool touched;\n"; + +// Constructors + ret += "\t"+generate_functor_name() + "_keydef(){touched=false;};\n"; +// destructor + ret += "\t~"+ generate_functor_name() + "_keydef(){\n"; + for(p=0;pis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&hashkey_var%d);\n", + hashkey_dt[p]->get_hfta_buffer_destroy().c_str(), p ); + ret += tmpstr; + } + } + ret += "\t};\n"; + ret+="\tvoid touch(){touched = true;};\n"; + ret+="\tbool is_touched(){return touched;};\n"; + ret +="};\n\n"; + + +//-------------------------------- +// temporal equality definition class + ret += "class " + generate_functor_name() + "_tempeqdef{\n"; + ret += "public:\n"; +// Collect attributes from hash join predicates. +// ASSUME equality predicate. +// Use the upwardly compatible date type +// (infer from '+' operator if possible, else use left type) + for(p=0;ptemporal_eq.size();++p){ + scalarexp_t *lse = temporal_eq[p]->pr->get_left_se(); + scalarexp_t *rse = temporal_eq[p]->pr->get_right_se(); + data_type *hdt = new data_type( + lse->get_data_type(), rse->get_data_type(), plus_op ); + if(hdt->get_type() == undefined_t){ + temporal_dt.push_back(hash_eq[p]->pr->get_left_se()->get_data_type()->duplicate()); + delete hdt; + }else{ + temporal_dt.push_back(hdt); + } + sprintf(tmpstr,"tempeq_var%d",p); + ret+="\t"+temporal_dt[p]->make_host_cvar(tmpstr)+";\n"; +// find equivalences + if(lse->get_operator_type()==SE_COLREF){ + l_equiv[lse->get_colref()->get_field()] = rse; + } + if(rse->get_operator_type()==SE_COLREF){ + r_equiv[rse->get_colref()->get_field()] = lse; + } + } + +// Constructors + ret += "\t"+generate_functor_name() + "_tempeqdef(){};\n"; +// destructor + ret += "\t~"+ generate_functor_name() + "_tempeqdef(){\n"; + for(p=0;pis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&tempeq_var%d);\n", + temporal_dt[p]->get_hfta_buffer_destroy().c_str(), p ); + ret += tmpstr; + } + } + ret += "\t};\n"; + ret +="};\n\n"; + + +//-------------------------------- +// temporal eq, hash join functor class + ret += "class " + this->generate_functor_name() + "{\n"; + +// Find variables referenced in this query node. + + col_id_set cid_set; + col_id_set::iterator csi; + + for(p=0;ppr,cid_set,NULL); + for(s=0;sse,cid_set,NULL); + +// Private variables : store the state of the functor. +// 1) variables for unpacked attributes +// 2) offsets of the upacked attributes +// 3) storage of partial functions +// 4) storage of complex literals (i.e., require a constructor) + + ret += "private:\n"; + + // var to save the schema handles + ret += "\tint schema_handle0;\n"; + ret += "\tint schema_handle1;\n"; + + // generate the declaration of all the variables related to + // temp tuples generation + ret += gen_decl_temp_vars(); + // tuple metadata offsets + ret += "\tint tuple_metadata_offset0, tuple_metadata_offset1;\n"; + +// unpacked attribute storage, offsets + ret += "//\t\tstorage and offsets of accessed fields.\n"; + ret += generate_access_vars(cid_set, schema); + + +// Variables to store results of partial functions. +// WARNING find_partial_functions modifies the SE +// (it marks the partial function id). + ret += "//\t\tParital function result storage\n"; + vector partial_fcns; + vector fcn_ref_cnt; + vector is_partial_fcn; + for(s=0;sse, &partial_fcns,NULL,NULL, Ext_fcns); + } + for(p=0;ppr, &partial_fcns,NULL,NULL, Ext_fcns); + } + if(partial_fcns.size()>0){ + ret += "/*\t\tVariables for storing results of partial functions. \t*/\n"; + ret += generate_partial_fcn_vars(partial_fcns,fcn_ref_cnt,is_partial_fcn,false); + } + +// Complex literals (i.e., they need constructors) + ret += "//\t\tComplex literal storage.\n"; + cplx_lit_table *complex_literals = this->get_cplx_lit_tbl(Ext_fcns); + ret += generate_complex_lit_vars(complex_literals); +// We need the following to handle strings in outer joins. +// NEED AN EMPTY LITERAL FOR EAcH STRUCTURED LITERAL + ret += "\tstruct vstring EmptyString;\n"; + ret += "\tstruct hfta_ipv6_str EmptyIp6;\n"; + +// Pass-by-handle parameters + ret += "//\t\tPass-by-handle storage.\n"; + vector param_handle_table = this->get_handle_param_tbl(Ext_fcns); + ret += generate_pass_by_handle_vars(param_handle_table); + + +// variables to hold parameters. + ret += "//\tfor query parameters\n"; + ret += generate_param_vars(param_tbl); + + + ret += "\npublic:\n"; +//------------------- +// The functor constructor +// pass in the schema handle. +// 1) make assignments to the unpack offset variables +// 2) initialize the complex literals + + ret += "//\t\tFunctor constructor.\n"; + ret += this->generate_functor_name()+"(int schema_handle0, int schema_handle1){\n"; + + ret += "\t\tthis->schema_handle0 = schema_handle0;\n"; + ret += "\t\tthis->schema_handle1 = schema_handle1;\n"; +// metadata offsets + ret += "\ttuple_metadata_offset0 = ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + ret += "\ttuple_metadata_offset1 = ftaschema_get_tuple_metadata_offset(schema_handle1);\n"; + +// unpack vars + ret += "//\t\tGet offsets for unpacking fields from input tuple.\n"; + ret += gen_access_var_init(cid_set); + +// complex literals + ret += "//\t\tInitialize complex literals.\n"; + ret += gen_complex_lit_init(complex_literals); +// Initialize EmptyString to the ... empty string +// NEED AN EMPTY LITERAL FOR EAcH STRUCTURED LITERAL + literal_t mtstr_lit(""); + ret += "\t" + mtstr_lit.to_hfta_C_code("&EmptyString")+";\n"; + literal_t mip6_lit("0:0:0:0:0:0:0:0",LITERAL_IPV6); + ret += "\t" + mip6_lit.to_hfta_C_code("&EmptyIp6")+";\n"; + +// Initialize partial function results so they can be safely GC'd + ret += gen_partial_fcn_init(partial_fcns); + +// Initialize non-query-parameter parameter handles + ret += gen_pass_by_handle_init(param_handle_table); + +// Init temporal attributes referenced in select list + ret += gen_init_temp_vars(schema, select_list, NULL); + + + ret += "};\n"; + + + +//------------------- +// Functor destructor + ret += "//\t\tFunctor destructor.\n"; + ret += "~"+this->generate_functor_name()+"(){\n"; + +// clean up buffer type complex literals + ret += gen_complex_lit_dtr(complex_literals); + +// Deregister the pass-by-handle parameters + ret += "/* register and de-register the pass-by-handle parameters */\n"; + ret += gen_pass_by_handle_dtr(param_handle_table); + +// clean up partial function results. + ret += "/* clean up partial function storage */\n"; + ret += gen_partial_fcn_dtr(partial_fcns); + +// Destroy the parameters, if any need to be destroyed + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + + ret += "};\n\n"; + + +//------------------- +// Parameter manipulation routines + ret += generate_load_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + ret += generate_delete_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + +//------------------- +// Register new parameter block + + ret += "int set_param_block(gs_int32_t sz, void* value){\n"; + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + ret += "\treturn this->load_params_"+this->generate_functor_name()+ + "(sz, value);\n"; + ret += "};\n\n"; + + +//------------------- +// The create_key method. +// Perform heap allocation. +// ASSUME : the LHS of the preds reference channel 0 attributes +// NOTE : it may fail if a partial function fails. + + ret += this->generate_functor_name()+"_keydef *create_key(host_tuple &tup, bool &failed){\n"; +// Variables for execution of the function. + ret+="\t"+this->generate_functor_name()+"_keydef *retval = NULL;\n"; + ret+="\tgs_int32_t problem = 0;\n"; + +// Assume unsuccessful completion + ret+= "\tfailed = true;\n"; + +// Switch the processing based on the channel + ret+="\tif(tup.channel == 0){\n"; + ret+="// ------------ processing for channel 0\n"; + ret+="\t\thost_tuple &tup0 = tup;\n"; +// Gather partial fcns and colids ref'd by this branch + pfcn_refs.clear(); + new_cids.clear(); local_cids.clear(); + for(p=0;ppr->get_left_se(), pfcn_refs); + gather_se_col_ids(hash_eq[p]->pr->get_left_se(),local_cids,NULL); + } + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns,pfcn_refs); + +// Evaluate the partial functions + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, pfcn_refs, + new_cids, NULL, "NULL", needs_xform); +// test passed -- unpack remaining cids. + ret += gen_remaining_colrefs(schema, local_cids, new_cids, "NULL", needs_xform); + +// Alloc and load a key object + ret += "\t\tretval = new "+this->generate_functor_name()+"_keydef();\n"; + for(p=0;ppr->get_left_se()->get_data_type(); + if(hdt->is_buffer_type()){ + string vname = "tmp_keyvar"+int_to_string(p); + ret += "\t\t"+hdt->make_host_cvar(vname)+" = "+generate_se_code(hash_eq[p]->pr->get_left_se(),schema)+";\n"; + ret += "\t\t"+hdt->get_hfta_buffer_assign_copy()+"(&(retval->hashkey_var"+int_to_string(p)+"),&"+vname+");\n"; + }else{ + sprintf(tmpstr,"\t\tretval->hashkey_var%d = %s;\n", + p,generate_se_code(hash_eq[p]->pr->get_left_se(),schema).c_str() ); + ret += tmpstr; + } + } + ret += "\t}else{\n"; + + ret+="// ------------ processing for channel 1\n"; + ret+="\t\thost_tuple &tup1 = tup;\n"; +// Gather partial fcns and colids ref'd by this branch + pfcn_refs.clear(); + new_cids.clear(); local_cids.clear(); + for(p=0;ppr->get_right_se(), pfcn_refs); + gather_se_col_ids(hash_eq[p]->pr->get_right_se(),local_cids,NULL); + } + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns,pfcn_refs); + +// Evaluate the partial functions + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, pfcn_refs, + new_cids, NULL, "NULL", needs_xform); + +// test passed -- unpack remaining cids. + ret += gen_remaining_colrefs(schema, local_cids, new_cids, "NULL", needs_xform); + +// Alloc and load a key object + ret += "\t\tretval = new "+this->generate_functor_name()+"_keydef();\n"; + for(p=0;ppr->get_right_se()->get_data_type(); + if(hdt->is_buffer_type()){ + string vname = "tmp_keyvar"+int_to_string(p); + ret += "\t\t"+hdt->make_host_cvar(vname)+" = "+generate_se_code(hash_eq[p]->pr->get_right_se(),schema)+";\n"; + ret += "\t\t"+hdt->get_hfta_buffer_assign_copy()+"(&(retval->hashkey_var"+int_to_string(p)+"),&"+vname+");\n"; + }else{ + sprintf(tmpstr,"\t\tretval->hashkey_var%d = %s;\n", + p,generate_se_code(hash_eq[p]->pr->get_right_se(),schema).c_str() ); + ret += tmpstr; + } + } + ret += "\t}\n"; + + ret += "\tfailed = false;\n"; + ret += "\t return retval;\n"; + ret += "}\n"; + + +//------------------- +// The load_ts method. +// load into an allocated buffer. +// ASSUME : the LHS of the preds reference channel 0 attributes +// NOTE : it may fail if a partial function fails. +// NOTE : cann't handle buffer attributes + + ret += "bool load_ts_from_tup("+this->generate_functor_name()+"_tempeqdef *ts, host_tuple &tup){\n"; +// Variables for execution of the function. + ret+="\tgs_int32_t problem = 0;\n"; + +// Switch the processing based on the channel + ret+="\tif(tup.channel == 0){\n"; + ret+="// ------------ processing for channel 0\n"; + ret+="\t\thost_tuple &tup0 = tup;\n"; + +// Gather partial fcns and colids ref'd by this branch + pfcn_refs.clear(); + new_cids.clear(); local_cids.clear(); + for(p=0;ppr->get_left_se(), pfcn_refs); + gather_se_col_ids(temporal_eq[p]->pr->get_left_se(),local_cids,NULL); + } + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns,pfcn_refs); + +// Evaluate the partial functions + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, pfcn_refs, + new_cids, NULL, "false", needs_xform); + +// test passed -- unpack remaining cids. + ret += gen_remaining_colrefs(schema, local_cids, new_cids, "false", needs_xform); + +// load the temporal key object + for(p=0;ptempeq_var%d = %s;\n", + p,generate_se_code(temporal_eq[p]->pr->get_left_se(),schema).c_str() ); + ret += tmpstr; + } + + ret += "\t}else{\n"; + + ret+="// ------------ processing for channel 1\n"; + ret+="\t\thost_tuple &tup1 = tup;\n"; + +// Gather partial fcns and colids ref'd by this branch + pfcn_refs.clear(); + new_cids.clear(); local_cids.clear(); + for(p=0;ppr->get_right_se(), pfcn_refs); + gather_se_col_ids(temporal_eq[p]->pr->get_right_se(),local_cids,NULL); + } + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns,pfcn_refs); + +// Evaluate the partial functions + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, pfcn_refs, + new_cids, NULL, "false", needs_xform); + +// test passed -- unpack remaining cids. + ret += gen_remaining_colrefs(schema, local_cids, new_cids, "false", needs_xform); + +// load the key object + for(p=0;ptempeq_var%d = %s;\n", + p,generate_se_code(temporal_eq[p]->pr->get_right_se(),schema).c_str() ); + ret += tmpstr; + } + + ret += "\t}\n"; + + ret += "\t return true;\n"; + ret += "}\n"; + + +// ------------------------------ +// Load ts from ts +// (i.e make a copy) + + ret += "bool load_ts_from_ts("+this->generate_functor_name()+"_tempeqdef *lts,"+this->generate_functor_name()+"_tempeqdef *rts){\n"; + for(p=0;ptempeq_var%d = rts->tempeq_var%d;\n",p,p); + ret += tmpstr; + } + ret += "}\n"; + +// ------------------------------------- +// compare_ts_to_ts +// There should be only one variable to compare. +// If there is more, assume an arbitrary lexicographic order. + + ret += "int compare_ts_with_ts("+this->generate_functor_name()+"_tempeqdef *lts,"+this->generate_functor_name()+"_tempeqdef *rts){\n"; + for(p=0;ptempeq_var%d < rts->tempeq_var%d) return(-1);\n",p,p); + ret += tmpstr; + sprintf(tmpstr,"\tif(lts->tempeq_var%d > rts->tempeq_var%d) return(1);\n",p,p); + ret += tmpstr; + } + ret += "\treturn(0);\n"; + ret += "}\n"; + +// ------------------------------------------ +// apply_prefilter +// apply the prefilter + + ret += "bool apply_prefilter(host_tuple &tup){\n"; + +// Variables for this procedure + ret+="\tgs_int32_t problem = 0;\n"; + ret+="\tgs_retval_t retval;\n"; + +// Switch the processing based on the channel + ret+="\tif(tup.channel == 0){\n"; + ret+="// ------------ processing for channel 0\n"; + ret+="\t\thost_tuple &tup0 = tup;\n"; +// Gather partial fcns and colids ref'd by this branch + pfcn_refs.clear(); + new_cids.clear(); local_cids.clear(); + for(p=0;ppr, pfcn_refs); + } + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns,pfcn_refs); + + for(p=0;p<(prefilter[0]).size();++p){ + sprintf(tmpstr,"//\t\tPredicate clause %d.\n",p); + ret += tmpstr; +// Find the set of variables accessed in this CNF elem, +// but in no previous element. + col_id_set new_pr_cids; + get_new_pred_cids((prefilter[0])[p]->pr,local_cids,new_pr_cids, NULL); +// Unpack these values. + ret += gen_unpack_cids(schema, new_pr_cids, "false", needs_xform); +// Find partial fcns ref'd in this cnf element + set pr_pfcn_refs; + collect_partial_fcns_pr((prefilter[0])[p]->pr, pr_pfcn_refs); + ret += gen_unpack_partial_fcn(schema,partial_fcns,pr_pfcn_refs,"false"); + + ret += "\t\tif( !("+generate_predicate_code((prefilter[0])[p]->pr,schema)+") ) return(false);\n"; + } + ret += "\t}else{\n"; + ret+="// ------------ processing for channel 1\n"; + ret+="\t\thost_tuple &tup1 = tup;\n"; +// Gather partial fcns and colids ref'd by this branch + pfcn_refs.clear(); + new_cids.clear(); local_cids.clear(); + for(p=0;ppr, pfcn_refs); + } + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + ret += gen_partial_fcn_dtr(partial_fcns,pfcn_refs); + + for(p=0;p<(prefilter[1]).size();++p){ + sprintf(tmpstr,"//\t\tPredicate clause %d.\n",p); + ret += tmpstr; +// Find the set of variables accessed in this CNF elem, +// but in no previous element. + col_id_set pr_new_cids; + get_new_pred_cids((prefilter[1])[p]->pr,local_cids, pr_new_cids, NULL); +// Unpack these values. + ret += gen_unpack_cids(schema, pr_new_cids, "false", needs_xform); +// Find partial fcns ref'd in this cnf element + set pr_pfcn_refs; + collect_partial_fcns_pr((prefilter[1])[p]->pr, pr_pfcn_refs); + ret += gen_unpack_partial_fcn(schema,partial_fcns,pr_pfcn_refs,"false"); + + ret += "\t\tif( !("+generate_predicate_code((prefilter[1])[p]->pr,schema)+ ") ) return(false);\n"; + } + + ret += "\t}\n"; + ret+="\treturn true;\n"; + ret += "}\n"; + + +// ------------------------------------- +// create_output_tuple +// If the postfilter on the pair of tuples passes, +// create an output tuple from the combined information. +// (Plus, outer join processing) + + ret += "host_tuple create_output_tuple(const host_tuple &tup0, const host_tuple &tup1, bool &failed){\n"; + + ret += "\thost_tuple tup;\n"; + ret += "\tfailed = true;\n"; + ret += "\tgs_retval_t retval = 0;\n"; + ret += "\tgs_int32_t problem = 0;\n"; + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + pfcn_refs.clear(); + new_cids.clear(); local_cids.clear(); + for(p=0;ppr, pfcn_refs); + } + for(s=0;sse, pfcn_refs); + } + ret += gen_partial_fcn_dtr(partial_fcns,pfcn_refs); + + + ret+="\tif(tup0.data && tup1.data){\n"; +// Evaluate the postfilter + new_cids.clear(); local_cids.clear(); + for(p=0;ppr,local_cids, pr_new_cids, NULL); +// Unpack these values. + ret += gen_unpack_cids(schema, pr_new_cids, "tup", needs_xform); +// Find partial fcns ref'd in this cnf element + set pr_pfcn_refs; + collect_partial_fcns_pr(postfilter[p]->pr, pr_pfcn_refs); + ret += gen_unpack_partial_fcn(schema,partial_fcns,pr_pfcn_refs,"tup"); + + ret += "\t\tif( !("+generate_predicate_code(postfilter[p]->pr,schema)+ ") ) return(tup);\n"; + } + + +// postfilter passed, evaluate partial functions for select list + + set sl_pfcns; + col_id_set se_cids; + for(s=0;sse, sl_pfcns); + } + + if(sl_pfcns.size() > 0) + ret += "//\t\tUnpack remaining partial fcns.\n"; + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, sl_pfcns, + local_cids, NULL, "tup", needs_xform); + +// Unpack remaining fields + ret += "//\t\tunpack any remaining fields from the input tuples.\n"; + for(s=0;sse, local_cids,se_cids,NULL); + ret += gen_unpack_cids(schema, se_cids,"tup", needs_xform); + + +// Deal with outer join stuff + col_id_set l_cids, r_cids; + col_id_set::iterator ocsi; + for(ocsi=local_cids.begin();ocsi!=local_cids.end();++ocsi){ + if((*ocsi).tblvar_ref == 0) l_cids.insert((*ocsi)); + else r_cids.insert((*ocsi)); + } + for(ocsi=se_cids.begin();ocsi!=se_cids.end();++ocsi){ + if((*ocsi).tblvar_ref == 0) l_cids.insert((*ocsi)); + else r_cids.insert((*ocsi)); + } + + ret += "\t}else if(tup0.data){\n"; + string unpack_null = ""; col_id_set extra_cids; + for(ocsi=r_cids.begin();ocsi!=r_cids.end();++ocsi){ + string field = (*ocsi).field; + if(r_equiv.count(field)){ + unpack_null+="\t\tunpack_var_"+field+"_1="+generate_se_code(r_equiv[field],schema)+";\n"; + get_new_se_cids(r_equiv[field],l_cids,new_cids,NULL); + }else{ + int schref = (*ocsi).schema_ref; + data_type dt(schema->get_type_name(schref,field)); + literal_t empty_lit(dt.type_indicator()); + if(empty_lit.is_cpx_lit()){ +// sprintf(tmpstr,"&(unpack_var_%s_1)",field.c_str()); +// unpack_null += "\t"+empty_lit.to_hfta_C_code(tmpstr)+";\n"; +// NB : works for string type only +// NNB: installed fix for ipv6, more of this should be pushed +// into the literal_t code. + unpack_null+="\tunpack_var_"+field+"_1= "+empty_lit.hfta_empty_literal_name()+";\n"; + }else{ + unpack_null+="\tunpack_var_"+field+"_1="+empty_lit.to_hfta_C_code("")+";\n"; + } + } + } + ret += gen_unpack_cids(schema, l_cids, "tup", needs_xform); + ret += gen_unpack_cids(schema, extra_cids, "tup", needs_xform); + ret += unpack_null; + ret += gen_unpack_partial_fcn(schema, partial_fcns, sl_pfcns, "tup"); + + ret+="\t}else{\n"; + unpack_null = ""; extra_cids.clear(); + for(ocsi=l_cids.begin();ocsi!=l_cids.end();++ocsi){ + string field = (*ocsi).field; + if(l_equiv.count(field)){ + unpack_null+="\t\tunpack_var_"+field+"_0="+generate_se_code(l_equiv[field],schema)+";\n"; + get_new_se_cids(l_equiv[field],r_cids,new_cids,NULL); + }else{ + int schref = (*ocsi).schema_ref; + data_type dt(schema->get_type_name(schref,field)); + literal_t empty_lit(dt.type_indicator()); + if(empty_lit.is_cpx_lit()){ +// sprintf(tmpstr,"&(unpack_var_%s_0)",field.c_str()); +// unpack_null += "\t"+empty_lit.to_hfta_C_code(tmpstr)+";\n"; +// NB : works for string type only +// NNB: installed fix for ipv6, more of this should be pushed +// into the literal_t code. + unpack_null+="\tunpack_var_"+field+"_0= "+empty_lit.hfta_empty_literal_name()+";\n"; + }else{ + unpack_null+="\tunpack_var_"+field+"_0="+empty_lit.to_hfta_C_code("")+";\n"; + } + } + } + ret += gen_unpack_cids(schema, r_cids, "tup", needs_xform); + ret += gen_unpack_cids(schema, extra_cids, "tup", needs_xform); + ret += unpack_null; + ret += gen_unpack_partial_fcn(schema, partial_fcns, sl_pfcns, "tup"); + ret+="\t}\n"; + + + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. + + ret += "//\t\tCompute the size of the tuple.\n"; + ret += "//\t\t\tNote: buffer storage packed at the end of the tuple.\n"; + +// Unpack all buffer type selections, to be able to compute their size + ret += gen_buffer_selvars(schema, select_list); + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + ret+="\ttup.tuple_size = sizeof(" + generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t)"; + ret += gen_buffer_selvars_size(select_list,schema); + ret.append(";\n"); + +// Allocate tuple data block. + ret += "//\t\tCreate the tuple block.\n"; + ret += "\ttup.data = malloc(tup.tuple_size);\n"; + ret += "\ttup.heap_resident = true;\n"; +// ret += "\ttup.channel = 0;\n"; + +// Mark tuple as regular + ret += "\t*((gs_sp_t )tup.data + sizeof(" + generate_tuple_name( this->get_node_name()) +")) = REGULAR_TUPLE;\n"; + + + ret += "\t"+generate_tuple_name( this->get_node_name())+" *tuple = ("+ + generate_tuple_name( this->get_node_name())+" *)(tup.data);\n"; + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + ret += gen_pack_tuple(schema,select_list,this->get_node_name(), false ); + +// Delete string temporaries + ret += gen_buffer_selvars_dtr(select_list); + + ret += "\tfailed = false;\n"; + ret += "\treturn tup;\n"; + ret += "};\n"; + + + +//----------------------------- +// Method for checking whether tuple is temporal + + ret += "bool temp_status_received(host_tuple &tup){\n"; + +// Switch the processing based on the channel + ret+="\tif(tup.channel == 0){\n"; + ret+="\t\thost_tuple &tup0 = tup;\n"; + ret += gen_temp_tuple_check(this->node_name, 0); + ret += "\t}else{\n"; + ret+="\t\thost_tuple &tup1 = tup;\n"; + ret += gen_temp_tuple_check(this->node_name, 1); + ret += "\t}\n"; + ret += "\treturn temp_tuple_received;\n};\n\n"; + + +//------------------------------------------------------------------- +// Temporal update functions + + +// create a temp status tuple + ret += "int create_temp_status_tuple(const host_tuple &tup0, const host_tuple &tup1, host_tuple& result) {\n\n"; + + ret += "\tgs_retval_t retval = 0;\n"; + ret += "\tgs_int32_t problem = 0;\n"; + + ret += "\tif(tup0.data){\n"; + +// Unpack all the temporal attributes references in select list + col_id_set found_cids; + + for(s=0;sse->get_data_type()->is_temporal()) { +// Find the set of attributes accessed in this SE + col_id_set new_cids; + get_new_se_cids(select_list[s]->se,found_cids, new_cids, NULL); + } + } + + // Deal with outer join stuff + l_cids.clear(), r_cids.clear(); + for(ocsi=found_cids.begin();ocsi!=found_cids.end();++ocsi){ + if((*ocsi).tblvar_ref == 0) l_cids.insert((*ocsi)); + else r_cids.insert((*ocsi)); + } + unpack_null = ""; + extra_cids.clear(); + for(ocsi=r_cids.begin();ocsi!=r_cids.end();++ocsi){ + string field = (*ocsi).field; + if(r_equiv.count(field)){ + unpack_null+="\t\tunpack_var_"+field+"_1="+generate_se_code(r_equiv[field],schema)+";\n"; + col_id_set addnl_cids; + get_new_se_cids(r_equiv[field],l_cids,addnl_cids,NULL); + }else{ + int schref = (*ocsi).schema_ref; + data_type dt(schema->get_type_name(schref,field)); + literal_t empty_lit(dt.type_indicator()); + if(empty_lit.is_cpx_lit()){ + sprintf(tmpstr,"&(unpack_var_%s_1)",field.c_str()); + unpack_null += "\t"+empty_lit.to_hfta_C_code(tmpstr)+";\n"; + }else{ + unpack_null+="\tunpack_var_"+field+"_1="+empty_lit.to_hfta_C_code("")+";\n"; + } + } + } + ret += gen_unpack_cids(schema, l_cids, "1", needs_xform); + ret += gen_unpack_cids(schema, extra_cids, "1", needs_xform); + ret += unpack_null; + + ret+="\t}else if (tup1.data) {\n"; + unpack_null = ""; extra_cids.clear(); + for(ocsi=l_cids.begin();ocsi!=l_cids.end();++ocsi){ + string field = (*ocsi).field; + if(l_equiv.count(field)){ + unpack_null+="\t\tunpack_var_"+field+"_0="+generate_se_code(l_equiv[field],schema)+";\n"; + col_id_set addnl_cids; + get_new_se_cids(l_equiv[field],r_cids,addnl_cids,NULL); + }else{ + int schref = (*ocsi).schema_ref; + data_type dt(schema->get_type_name(schref,field)); + literal_t empty_lit(dt.type_indicator()); + if(empty_lit.is_cpx_lit()){ + sprintf(tmpstr,"&(unpack_var_%s_0)",field.c_str()); + unpack_null += "\t"+empty_lit.to_hfta_C_code(tmpstr)+";\n"; + }else{ + unpack_null+="\tunpack_var_"+field+"_0="+empty_lit.to_hfta_C_code("")+";\n"; + } + } + } + ret += gen_unpack_cids(schema, r_cids, "1", needs_xform); + ret += gen_unpack_cids(schema, extra_cids, "1", needs_xform); + ret += unpack_null; + ret+="\t}\n"; + + ret += gen_init_temp_status_tuple(this->get_node_name()); + +// Start packing. + ret += "//\t\tPack the fields into the tuple.\n"; + ret += gen_pack_tuple(schema,select_list,this->get_node_name(), true ); + + + ret += "\treturn 0;\n"; + ret += "};\n\n"; + + + ret += "};\n\n\n"; + +//---------------------------------------------------------- +// The hash function + + ret += "struct "+generate_functor_name()+"_hash_func{\n"; + ret += "\tgs_uint32_t operator()(const "+generate_functor_name()+ + "_keydef *key) const{\n"; + ret += "\t\treturn( ("; + if(hashkey_dt.size() > 0){ + for(p=0;p0) ret += "^"; + if(hashkey_dt[p]->use_hashfunc()){ +// sprintf(tmpstr,"%s(&(key->hashkey_var%d))",hashkey_dt[p]->get_hfta_hashfunc().c_str(),p); + if(hashkey_dt[p]->is_buffer_type()) + sprintf(tmpstr,"(%s*%s(&(key->hashkey_var%d)))",hash_nums[p%NRANDS].c_str(),hashkey_dt[p]->get_hfta_hashfunc().c_str(),p); + else + sprintf(tmpstr,"(%s*%s(key->hashkey_var%d))",hash_nums[p%NRANDS].c_str(),hashkey_dt[p]->get_hfta_hashfunc().c_str(),p); + }else{ + sprintf(tmpstr,"(%s*key->hashkey_var%d)",hash_nums[p%NRANDS].c_str(),p); + } + ret += tmpstr; + } + }else{ + ret += "0"; + } + ret += ") >> 32);\n"; + ret += "\t}\n"; + ret += "};\n\n"; + +//---------------------------------------------------------- +// The comparison function + + ret += "struct "+generate_functor_name()+"_equal_func{\n"; + ret += "\tbool operator()(const "+generate_functor_name()+"_keydef *key1, "+ + generate_functor_name()+"_keydef *key2) const{\n"; + ret += "\t\treturn( ("; + if(hashkey_dt.size() > 0){ + for(p=0;p0) ret += ") && ("; + if(hashkey_dt[p]->complex_comparison(hashkey_dt[p])){ + if(hashkey_dt[p]->is_buffer_type()) + sprintf(tmpstr,"(%s(&(key1->hashkey_var%d), &(key2->hashkey_var%d))==0)", + hashkey_dt[p]->get_hfta_comparison_fcn(hashkey_dt[p]).c_str(),p,p); + else + sprintf(tmpstr,"(%s((key1->hashkey_var%d), (key2->hashkey_var%d))==0)", + hashkey_dt[p]->get_hfta_comparison_fcn(hashkey_dt[p]).c_str(),p,p); + }else{ + sprintf(tmpstr,"key1->hashkey_var%d == key2->hashkey_var%d",p,p); + } + ret += tmpstr; + } + }else{ + ret += "1"; + } + ret += ") );\n"; + ret += "\t}\n"; + ret += "};\n\n"; + + + return(ret); +} + + + +string join_eq_hash_qpn::generate_operator(int i, string params){ + + return( + " join_eq_hash_operator<" + + generate_functor_name()+ ","+ + generate_functor_name() + "_tempeqdef,"+ + generate_functor_name() + "_keydef,"+ + generate_functor_name()+"_hash_func,"+ + generate_functor_name()+"_equal_func" + "> *op"+int_to_string(i)+" = new join_eq_hash_operator<"+ + generate_functor_name()+","+ + generate_functor_name() + "_tempeqdef,"+ + generate_functor_name() + "_keydef,"+ + generate_functor_name()+"_hash_func,"+ + generate_functor_name()+"_equal_func" + ">("+params+", "+ + int_to_string(from[0]->get_property()+2*from[1]->get_property())+", \"" + get_node_name() + +"\");\n" + ); +} + + + +//////////////////////////////////////////////////////////////// +//// SGAHCWCB functor + + + +string sgahcwcb_qpn::generate_functor_name(){ + return("sgahcwcb_functor_" + normalize_name(this->get_node_name())); +} + + +string sgahcwcb_qpn::generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, vector &needs_xform){ + int a,g,w,s; + + +// Initialize generate utility globals + segen_gb_tbl = &(gb_tbl); + + +//-------------------------------- +// group definition class + string ret = "class " + generate_functor_name() + "_groupdef{\n"; + ret += "public:\n"; + ret += "\tbool valid;\n"; + for(g=0;ggb_tbl.size();g++){ + sprintf(tmpstr,"gb_var%d",g); + ret+="\t"+this->gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + } +// Constructors + ret += "\t"+generate_functor_name() + "_groupdef(){valid=true;};\n"; + ret += "\t"+generate_functor_name() + "_groupdef("+ + this->generate_functor_name() + "_groupdef *gd){\n"; + for(g=0;gis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&gb_var%d, &(gd->gb_var%d));\n", + gdt->get_hfta_buffer_assign_copy().c_str(),g,g ); + ret += tmpstr; + }else{ + sprintf(tmpstr,"\t\tgb_var%d = gd->gb_var%d;\n",g,g); + ret += tmpstr; + } + } + ret += "\tvalid=true;\n"; + ret += "\t};\n"; +// destructor + ret += "\t~"+ generate_functor_name() + "_groupdef(){\n"; + for(g=0;gis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&gb_var%d);\n", + gdt->get_hfta_buffer_destroy().c_str(), g ); + ret += tmpstr; + } + } + ret += "\t};\n"; + ret +="};\n\n"; + +//-------------------------------- +// aggr definition class + ret += "class " + this->generate_functor_name() + "_aggrdef{\n"; + ret += "public:\n"; + for(a=0;amake_host_cvar(tmpstr)+";\n"; + else + ret+="\t"+ aggr_tbl.get_storage_type(a)->make_host_cvar(tmpstr)+";\n"; + } +// Constructors + ret += "\t"+this->generate_functor_name() + "_aggrdef(){};\n"; +// destructor + ret += "\t~"+this->generate_functor_name() + "_aggrdef(){\n"; + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&aggr_var%d);\n", + adt->get_hfta_buffer_destroy().c_str(), a ); + ret += tmpstr; + } + }else{ + ret+="\t\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_DESTROY_("; + if(aggr_tbl.get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(aggr_var"+int_to_string(a)+"));\n"; + } + } + ret += "\t};\n"; + ret +="};\n\n"; + +//-------------------------------- +// superaggr definition class + ret += "class " + this->generate_functor_name() + "_statedef{\n"; + ret += "public:\n"; + for(a=0;ais_superaggr()){ + sprintf(tmpstr,"aggr_var%d",a); + if(aggr_tbl.is_builtin(a)) + ret+="\t"+ aggr_tbl.get_data_type(a)->make_host_cvar(tmpstr)+";\n"; + else + ret+="\t"+ aggr_tbl.get_storage_type(a)->make_host_cvar(tmpstr)+";\n"; + } + } + set::iterator ssi; + for(ssi=states_refd.begin(); ssi!=states_refd.end(); ++ssi){ + string state_nm = (*ssi); + int state_id = Ext_fcns->lookup_state(state_nm); + data_type *dt = Ext_fcns->get_storage_dt(state_id); + string state_var = "state_var_"+state_nm; + ret += "\t"+dt->make_host_cvar(state_var)+";\n"; + } +// Constructors + ret += "\t"+this->generate_functor_name() + "_statedef(){};\n"; +// destructor + ret += "\t~"+this->generate_functor_name() + "_statedef(){\n"; + for(a=0;ais_superaggr()){ + if(aggr_tbl.is_builtin(a)){ + data_type *adt = aggr_tbl.get_data_type(a); + if(adt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&aggr_var%d);\n", + adt->get_hfta_buffer_destroy().c_str(), a ); + ret += tmpstr; + } + }else{ + ret+="\t\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_DESTROY_("; + if(aggr_tbl.get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(aggr_var"+int_to_string(a)+"));\n"; + } + } + } + for(ssi=states_refd.begin(); ssi!=states_refd.end(); ++ssi){ + string state_nm = (*ssi); + int state_id = Ext_fcns->lookup_state(state_nm); + string state_var = "state_var_"+state_nm; + ret += "\t_sfun_state_destroy_"+state_nm+"(&"+state_var+");\n"; + } + + ret += "\t};\n"; + ret +="};\n\n"; + + +//-------------------------------- +// gb functor class + ret += "class " + this->generate_functor_name() + "{\n"; + +// Find variables referenced in this query node. + + col_id_set cid_set; + col_id_set::iterator csi; + + for(w=0;wpr,cid_set,segen_gb_tbl); + for(w=0;wpr,cid_set,segen_gb_tbl); + for(w=0;wpr,cid_set,segen_gb_tbl); + for(w=0;wpr,cid_set,segen_gb_tbl); + for(g=0;gse,cid_set,segen_gb_tbl); // descends into aggregates + } + + +// Private variables : store the state of the functor. +// 1) variables for unpacked attributes +// 2) offsets of the upacked attributes +// 3) storage of partial functions +// 4) storage of complex literals (i.e., require a constructor) + + ret += "private:\n"; + + // var to save the schema handle + ret += "\tint schema_handle0;\n"; + + // generate the declaration of all the variables related to + // temp tuples generation + ret += gen_decl_temp_vars(); + +// unpacked attribute storage, offsets + ret += "//\t\tstorage and offsets of accessed fields.\n"; + ret += generate_access_vars(cid_set, schema); +// tuple metadata offset + ret += "\ttuple_metadata_offset0;\n"; + +// Variables to store results of partial functions. +// WARNING find_partial_functions modifies the SE +// (it marks the partial function id). + ret += "//\t\tParital function result storage\n"; + vector partial_fcns; + vector fcn_ref_cnt; + vector is_partial_fcn; + for(s=0;sse, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(g=0;g0){ + ret += "/*\t\tVariables for storing results of partial functions. \t*/\n"; + ret += generate_partial_fcn_vars(partial_fcns,fcn_ref_cnt,is_partial_fcn,false); + } + +// Complex literals (i.e., they need constructors) + ret += "//\t\tComplex literal storage.\n"; + cplx_lit_table *complex_literals = this->get_cplx_lit_tbl(Ext_fcns); + ret += generate_complex_lit_vars(complex_literals); + +// Pass-by-handle parameters + ret += "//\t\tPass-by-handle storage.\n"; + vector param_handle_table = this->get_handle_param_tbl(Ext_fcns); + ret += generate_pass_by_handle_vars(param_handle_table); + +// Create cached temporaries for UDAF return values. + ret += "//\t\tTemporaries for UDAF return values.\n"; + for(a=0;aget_fcn_dt(afcn_id); + sprintf(tmpstr,"udaf_ret_%d", a); + ret+="\t"+adt->make_host_cvar(tmpstr)+";\n"; + } + } + + + +// variables to hold parameters. + ret += "//\tfor query parameters\n"; + ret += generate_param_vars(param_tbl); + +// Is there a temporal flush? If so create flush temporaries, +// create flush indicator. + bool uses_temporal_flush = false; + for(g=0;gis_temporal()) + uses_temporal_flush = true; + } + + if(uses_temporal_flush){ + ret += "//\t\tFor temporal flush\n"; + for(g=0;gis_temporal()){ + sprintf(tmpstr,"last_gb%d",g); + ret+="\t"+gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + sprintf(tmpstr,"last_flushed_gb%d",g); + ret+="\t"+gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + } + } + ret += "\tbool needs_temporal_flush;\n"; + } + +// The publicly exposed functions + + ret += "\npublic:\n"; + + +//------------------- +// The functor constructor +// pass in the schema handle. +// 1) make assignments to the unpack offset variables +// 2) initialize the complex literals + + ret += "//\t\tFunctor constructor.\n"; + ret += this->generate_functor_name()+"(int schema_handle0){\n"; + + // save the schema handle + ret += "\t\tthis->schema_handle0 = schema_handle0;\n"; +// tuple metadata offset + ret += "\ttuple_metadata_offset0 = ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + +// unpack vars + ret += "//\t\tGet offsets for unpacking fields from input tuple.\n"; + ret += gen_access_var_init(cid_set); + +// aggregate return vals : refd in both final_sample +// and create_output_tuple +// Create cached temporaries for UDAF return values. + for(a=0;aget_fcn_dt(afcn_id); + sprintf(tmpstr,"udaf_ret_%d", a); + ret+="\t"+adt->make_host_cvar(tmpstr)+";\n"; + } + } + +// complex literals + ret += "//\t\tInitialize complex literals.\n"; + ret += gen_complex_lit_init(complex_literals); + +// Initialize partial function results so they can be safely GC'd + ret += gen_partial_fcn_init(partial_fcns); + +// Initialize non-query-parameter parameter handles + ret += gen_pass_by_handle_init(param_handle_table); + +// temporal flush variables +// ASSUME that structured values won't be temporal. + if(uses_temporal_flush){ + ret += "//\t\tInitialize temporal flush variables.\n"; + for(g=0;gis_temporal()){ + literal_t gl(gdt->type_indicator()); + sprintf(tmpstr,"\tlast_gb%d = %s;\n",g, gl.to_hfta_C_code("").c_str()); + ret.append(tmpstr); + } + } + ret += "\tneeds_temporal_flush = false;\n"; + } + + // Init temporal attributes referenced in select list + ret += gen_init_temp_vars(schema, select_list, segen_gb_tbl); + + ret += "};\n"; + + +//------------------- +// Functor destructor + ret += "//\t\tFunctor destructor.\n"; + ret += "~"+this->generate_functor_name()+"(){\n"; + +// clean up buffer type complex literals + ret += gen_complex_lit_dtr(complex_literals); + +// Deregister the pass-by-handle parameters + ret += "/* register and de-register the pass-by-handle parameters */\n"; + ret += gen_pass_by_handle_dtr(param_handle_table); + +// clean up partial function results. + ret += "/* clean up partial function storage */\n"; + ret += gen_partial_fcn_dtr(partial_fcns); + +// Destroy the parameters, if any need to be destroyed + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + + ret += "};\n\n"; + + +//------------------- +// Parameter manipulation routines + ret += generate_load_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + ret += generate_delete_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + +//------------------- +// Register new parameter block + + ret += "int set_param_block(gs_int32_t sz, void* value){\n"; + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + ret += "\treturn this->load_params_"+this->generate_functor_name()+ + "(sz, value);\n"; + ret += "};\n\n"; + +//------------------- +// the create_group method. +// This method creates a group in a buffer passed in +// (to allow for creation on the stack). +// There are also a couple of side effects: +// 1) evaluate the WHERE clause (and therefore, unpack all partial fcns) +// 2) determine if a temporal flush is required. + + ret += this->generate_functor_name()+"_groupdef *create_group(host_tuple &tup0, gs_sp_t buffer){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + + if(partial_fcns.size()>0){ // partial fcn access failure + ret += "\tgs_retval_t retval = 0;\n"; + ret += "\n"; + } +// return value + ret += "\t"+generate_functor_name()+"_groupdef *gbval = ("+generate_functor_name()+ + "_groupdef *) buffer;\n"; + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + + set gb_pfcns; // partial fcns in gbdefs, aggr se's + for(g=0;gnode_name, 0); + col_id_set found_cids; // colrefs unpacked thus far. + ret += gen_unpack_temp_vars(schema, found_cids, select_list, segen_gb_tbl, needs_xform); + + + +// Save temporal group-by variables + + + ret.append("\n\t//\t\tCompute temporal groupby attributes\n\n"); + + for(g=0;gis_temporal()){ + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); + ret.append(tmpstr); + } + } + ret.append("\n"); + + + +// Compare the temporal GB vars with the stored ones, +// set flush indicator and update stored GB vars if there is any change. + + if(uses_temporal_flush){ + ret+= "\tif( !( ("; + bool first_one = true; + for(g=0;gis_temporal()){ + sprintf(tmpstr,"last_gb%d",g); string lhs_op = tmpstr; + sprintf(tmpstr,"gbval->gb_var%d",g); string rhs_op = tmpstr; + if(first_one){first_one = false;} else {ret += ") && (";} + ret += generate_equality_test(lhs_op, rhs_op, gdt); + } + } + ret += ") ) ){\n"; + for(g=0;gis_temporal()){ + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&(gbval->gb_var%d),&last_gb%d);\n",gdt->get_hfta_buffer_replace().c_str(),g,g); + }else{ + sprintf(tmpstr,"\t\tlast_flushed_gb%d = last_gb%d;\n",g,g); + ret += tmpstr; + sprintf(tmpstr,"\t\tlast_gb%d = gbval->gb_var%d;\n",g,g); + } + ret += tmpstr; + } + } +/* + if(uses_temporal_flush){ + for(g=0;gis_temporal()){ + ret+="if(last_flushed_gb"+int_to_string(g)+">0)\n"; + break; + } + } + } +*/ + ret += "\t\tneeds_temporal_flush=true;\n"; + ret += "\t\t}else{\n" + "\t\t\tneeds_temporal_flush=false;\n" + "\t\t}\n"; + } + + +// For temporal status tuple we don't need to do anything else + ret += "\tif (temp_tuple_received) return NULL;\n\n"; + + +// The partial functions ref'd in the group-by var +// definitions must be evaluated. If one returns false, +// then implicitly the predicate is false. + set::iterator pfsi; + + if(gb_pfcns.size() > 0) + ret += "//\t\tUnpack partial fcns.\n"; + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, gb_pfcns, + found_cids, segen_gb_tbl, "NULL", needs_xform); + +// Unpack the group-by variables + + for(g=0;ggb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); +/* +// There seems to be no difference between the two +// branches of the IF statement. + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->is_buffer_type()){ +// Create temporary copy. + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); + }else{ + scalarexp_t *gse = gb_tbl.get_def(g); + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g,generate_se_code(gse,schema).c_str()); + } +*/ + ret.append(tmpstr); + } + ret.append("\n"); + + + ret+= "\treturn gbval;\n"; + ret += "};\n\n\n"; + + + +//------------------- +// the create_group method. +// This method creates a group in a buffer passed in +// (to allow for creation on the stack). +// There are also a couple of side effects: +// 1) evaluate the WHERE clause (and therefore, unpack all partial fcns) +// 2) determine if a temporal flush is required. + + ret += "bool evaluate_predicate(host_tuple &tup0, "+generate_functor_name()+"_groupdef *gbval, "+generate_functor_name()+"_statedef *stval, int cd){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + + if(partial_fcns.size()>0){ // partial fcn access failure + ret += "\tgs_retval_t retval = 0;\n"; + ret += "\n"; + } + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + set w_pfcns; // partial fcns in where clause + for(w=0;wpr, w_pfcns); + + set ag_pfcns; // partial fcns in gbdefs, aggr se's + for(a=0;apr)){ + sprintf(tmpstr,"//\t\tPredicate clause %d.\n",w); + ret += tmpstr; +// Find the set of variables accessed in this CNF elem, +// but in no previous element. + col_id_set new_cids; + get_new_pred_cids(where[w]->pr, found_cids, new_cids, segen_gb_tbl); + +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "false", needs_xform); +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(where[w]->pr, pfcn_refs); + ret += gen_unpack_partial_fcn(schema, partial_fcns, pfcn_refs,"false"); + + ret += "\tif( !("+generate_predicate_code(where[w]->pr,schema)+ + +") ) return(false);\n"; + } + } + + +// The partial functions ref'd in the and aggregate +// definitions must also be evaluated. If one returns false, +// then implicitly the predicate is false. +// ASSUME that aggregates cannot reference stateful fcns. + + if(ag_pfcns.size() > 0) + ret += "//\t\tUnpack remaining partial fcns.\n"; + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, ag_pfcns, + found_cids, segen_gb_tbl, "false", needs_xform); + + ret+="//\t\tEvaluate all remaining where clauses.\n"; + ret+="\tbool retval = true;\n"; + for(w=0;wpr)){ + sprintf(tmpstr,"//\t\tPredicate clause %d.\n",w); + ret += tmpstr; +// Find the set of variables accessed in this CNF elem, +// but in no previous element. + col_id_set new_cids; + get_new_pred_cids(where[w]->pr, found_cids, new_cids, segen_gb_tbl); + +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "false", needs_xform); +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(where[w]->pr, pfcn_refs); + ret += gen_unpack_partial_fcn(schema, partial_fcns, pfcn_refs,"false"); + + ret += "\tif( !("+generate_predicate_code(where[w]->pr,schema)+ + +") ) retval = false;\n"; + } + } + + ret+="// Unpack all remaining attributes\n"; + ret += gen_remaining_colrefs(schema, cid_set, found_cids, "false", needs_xform); + + ret += "\n\treturn retval;\n"; + ret += "};\n\n\n"; + +//-------------------------------------------------------- +// Create and initialize an aggregate object + + ret += this->generate_functor_name()+"_aggrdef *create_aggregate(host_tuple &tup0, "+generate_functor_name()+"_groupdef *gbval, gs_sp_t a,"+generate_functor_name()+"_statedef *stval, int cd){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// return value + ret += "\t"+generate_functor_name()+"_aggrdef *aggval = ("+generate_functor_name()+ "_aggrdef *)a;\n"; + + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"aggr_tmp_%d", a); + ret+=adt->make_host_cvar(tmpstr)+";\n"; + } + } + } + + for(a=0;aaggr_var%d",a); + string assignto_var = tmpstr; + ret += "\t"+generate_aggr_init(assignto_var,&aggr_tbl,a, schema); + } + + ret += "\treturn aggval;\n"; + ret += "};\n\n"; + + +//-------------------------------------------------------- +// initialize an aggregate object inplace + + ret += "void create_aggregate(host_tuple &tup0, "+this->generate_functor_name()+"_aggrdef *aggval,"+generate_functor_name()+"_statedef *stval, int cd){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// return value + + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"aggr_tmp_%d", a); + ret+=adt->make_host_cvar(tmpstr)+";\n"; + } + } + } + + for(a=0;aaggr_var%d",a); + string assignto_var = tmpstr; + ret += "\t"+generate_aggr_init(assignto_var,&aggr_tbl,a, schema); + } + + ret += "};\n\n"; + + +//-------------------------------------------------------- +// Create and clean-initialize an state object + + ret += "void initialize_state(host_tuple &tup0, "+generate_functor_name()+"_groupdef *gbval, "+generate_functor_name()+"_statedef *stval){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// return value +// ret += "\t"+generate_functor_name()+"_statedef *stval = ("+generate_functor_name()+ "_statedef *)s;\n"; + + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"aggr_tmp_%d", a); + ret+=adt->make_host_cvar(tmpstr)+";\n"; + } + } + } + } + + for(a=0;aaggr_var%d",a); + string assignto_var = tmpstr; + ret += "\t"+generate_aggr_init(assignto_var,&aggr_tbl,a, schema); + } + } + + for(ssi=states_refd.begin(); ssi!=states_refd.end();++ssi){ + string state_nm = (*ssi); + ret += "_sfun_state_clean_init_"+state_nm+"(&(stval->state_var_"+state_nm+"));\n"; + } + + ret += "};\n\n"; + + +//-------------------------------------------------------- +// Create and dirty-initialize an state object + + ret += "void reinitialize_state(host_tuple &tup0, "+generate_functor_name()+"_groupdef *gbval, "+generate_functor_name()+"_statedef *stval, "+generate_functor_name()+"_statedef *old_stval, int cd){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// return value +// ret += "\t"+generate_functor_name()+"_statedef *stval = ("+generate_functor_name()+ "_statedef *)s;\n"; + + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"aggr_tmp_%d", a); + ret+=adt->make_host_cvar(tmpstr)+";\n"; + } + } + } + } + +// initialize superaggregates + for(a=0;aaggr_var%d",a); + string assignto_var = tmpstr; + ret += "\t"+generate_aggr_init(assignto_var,&aggr_tbl,a, schema); + } + } + + for(ssi=states_refd.begin(); ssi!=states_refd.end();++ssi){ + string state_nm = (*ssi); + ret += "_sfun_state_dirty_init_"+state_nm+"(&(stval->state_var_"+state_nm+"),&(old_stval->state_var_"+state_nm+"), cd );\n"; + } + + ret += "};\n\n"; + +//-------------------------------------------------------- +// Finalize_state : call the finalize fcn on all states + + + ret += "void finalize_state( "+generate_functor_name()+"_statedef *stval, int cd){\n"; + + for(ssi=states_refd.begin(); ssi!=states_refd.end();++ssi){ + string state_nm = (*ssi); + ret += "_sfun_state_final_init_"+state_nm+"(&(stval->state_var_"+state_nm+"), cd);\n"; + } + + ret += "};\n\n"; + + + + +//-------------------------------------------------------- +// update (plus) a superaggregate object + + ret += "void update_plus_superaggr(host_tuple &tup0, " + + generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_statedef *stval){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// use of temporaries depends on the aggregate, +// generate them in generate_aggr_update + + + for(a=0;aaggr_var%d",a); + string varname = tmpstr; + ret.append(generate_aggr_update(varname,&aggr_tbl,a, schema)); + } + } + + ret += "\treturn;\n"; + ret += "};\n"; + + + +//-------------------------------------------------------- +// update (minus) a superaggregate object + + ret += "void update_minus_superaggr( "+ + generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval,"+ + generate_functor_name()+"_statedef *stval"+ + "){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// use of temporaries depends on the aggregate, +// generate them in generate_aggr_update + + + for(a=0;aaggr_var%d",a); + string super_varname = tmpstr; + sprintf(tmpstr,"aggval->aggr_var%d",a); + string sub_varname = tmpstr; + ret.append(generate_superaggr_minus(sub_varname, super_varname,&aggr_tbl,a, schema)); + } + } + + ret += "\treturn;\n"; + ret += "};\n"; + + +//-------------------------------------------------------- +// update an aggregate object + + ret += "void update_aggregate(host_tuple &tup0, " + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval,"+generate_functor_name()+"_statedef *stval, int cd){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// use of temporaries depends on the aggregate, +// generate them in generate_aggr_update + + + for(a=0;aaggr_var%d",a); + string varname = tmpstr; + ret.append(generate_aggr_update(varname,&aggr_tbl,a, schema)); + } + + ret += "\treturn;\n"; + ret += "};\n"; + +//--------------------------------------------------- +// Flush test + + ret += "\tbool flush_needed(){\n"; + if(uses_temporal_flush){ + ret += "\t\treturn needs_temporal_flush;\n"; + }else{ + ret += "\t\treturn false;\n"; + } + ret += "\t};\n"; + + +//------------------------------------------------------ +// THe cleaning_when predicate + + string gbvar = "gbval->gb_var"; + string aggvar = "aggval->"; + + ret += "bool need_to_clean( " + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_statedef *stval, int cd"+ + "){\n"; + + if(cleanwhen.size()>0) + ret += "\tbool predval = true;\n"; + else + ret += "\tbool predval = false;\n"; + +// Find the udafs ref'd in the having clause + set cw_aggs; + for(w=0;wpr, cw_aggs); + + +// get the return values from the UDAFS + for(a=0;aget_type() != fstring_t) ret+="&"; + ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n"; + } + } + + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + set cw_pfcns; // partial fcns in where clause + for(w=0;wpr, cw_pfcns); + + ret += gen_partial_fcn_dtr(partial_fcns,cw_pfcns); + + + for(w=0;w pfcn_refs; + collect_partial_fcns_pr(cleanwhen[w]->pr, pfcn_refs); + for(pfsi=pfcn_refs.begin();pfsi!=pfcn_refs.end();++pfsi){ + ret += unpack_partial_fcn_fm_aggr(partial_fcns[(*pfsi)], (*pfsi), gbvar, aggvar, schema); + ret += "\tif(retval){ return false;}\n"; + } +// ret += unpack_partial_fcn_fm_aggr(schema, partial_fcns, pfcn_refs,"false"); + + ret += "\tif( !("+generate_predicate_code_fm_aggr(cleanwhen[w]->pr,gbvar, aggvar, schema)+ + ") ) predval = false;\n"; + } + + ret += "\treturn predval;\n"; + ret += "\t};\n"; + +//------------------------------------------------------ +// THe cleaning_by predicate + + ret += "bool sample_group(" + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval,"+ + generate_functor_name()+"_statedef *stval, int cd"+ + "){\n"; + + if(cleanby.size()>0) + ret += "\tbool retval = true;\n"; + else + ret += "\tbool retval = false;\n"; + +// Find the udafs ref'd in the having clause + set cb_aggs; + for(w=0;wpr, cb_aggs); + + +// get the return values from the UDAFS + for(a=0;aget_type() != fstring_t) ret+="&"; + ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n"; + } + } + + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + set cb_pfcns; // partial fcns in where clause + for(w=0;wpr, cb_pfcns); + + ret += gen_partial_fcn_dtr(partial_fcns,cb_pfcns); + + + for(w=0;wpr, found_cids, new_cids, segen_gb_tbl); + +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "false", needs_xform); +*/ + +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(cleanby[w]->pr, pfcn_refs); + for(pfsi=pfcn_refs.begin();pfsi!=pfcn_refs.end();++pfsi){ + ret += unpack_partial_fcn_fm_aggr(partial_fcns[(*pfsi)], (*pfsi), gbvar, aggvar, schema); + ret += "\tif(retval){ return false;}\n"; + } +// ret += gen_unpack_partial_fcn(schema, partial_fcns, pfcn_refs,"false"); + + ret += "\tif( !("+generate_predicate_code_fm_aggr(cleanby[w]->pr,gbvar, aggvar, schema)+ + +") ) retval = false;\n"; + } + + ret += "\treturn retval;\n"; + ret += "\t};\n"; + + +//----------------------------------------------------- +// + ret += "bool final_sample_group(" + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval,"+ + generate_functor_name()+"_statedef *stval,"+ + "int cd){\n"; + + ret += "\tgs_retval_t retval = 0;\n"; + +// Find the udafs ref'd in the having clause + set hv_aggs; + for(w=0;wpr, hv_aggs); + + +// get the return values from the UDAFS + for(a=0;aget_type() != fstring_t) ret+="&"; + ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n"; + } + } + + + set hv_sl_pfcns; + for(w=0;wpr, hv_sl_pfcns); + } + +// clean up the partial fcn results from any previous execution + ret += gen_partial_fcn_dtr(partial_fcns,hv_sl_pfcns); + +// Unpack them now + for(pfsi=hv_sl_pfcns.begin();pfsi!=hv_sl_pfcns.end();++pfsi){ + ret += unpack_partial_fcn_fm_aggr(partial_fcns[(*pfsi)], (*pfsi), gbvar, aggvar, schema); + ret += "\tif(retval){ return false;}\n"; + } + +// Evalaute the HAVING clause +// TODO: this seems to have a ++ operator rather than a + operator. + for(w=0;wpr,gbvar, aggvar, schema) +") ) { return false;}\n"; + } + + ret += "\treturn true;\n"; + ret+="}\n\n"; + +//--------------------------------------------------- +// create output tuple +// Unpack the partial functions ref'd in the where clause, +// select clause. Evaluate the where clause. +// Finally, pack the tuple. + +// I need to use special code generation here, +// so I'll leave it in longhand. + + ret += "host_tuple create_output_tuple(" + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval,"+ + generate_functor_name()+"_statedef *stval,"+ + "int cd, bool &failed){\n"; + + ret += "\thost_tuple tup;\n"; + ret += "\tfailed = false;\n"; + ret += "\tgs_retval_t retval = 0;\n"; + + +// Find the udafs ref'd in the select clause + set sl_aggs; + for(s=0;sse, sl_aggs); + + +// get the return values from the UDAFS + for(a=0;aget_type() != fstring_t) ret+="&"; + ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n"; + } + } + + +// I can't cache partial fcn results from the having +// clause because evaluation is separated. + set sl_pfcns; + for(s=0;sse, sl_pfcns); + } +// Unpack them now + for(pfsi=sl_pfcns.begin();pfsi!=sl_pfcns.end();++pfsi){ + ret += unpack_partial_fcn_fm_aggr(partial_fcns[(*pfsi)], (*pfsi), gbvar, aggvar, schema); + ret += "\tif(retval){ failed=true; return tup;}\n"; + } + + +// Now, compute the size of the tuple. + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. +// TODO: should I be using the selvar generation routine? + + ret += "//\t\tCompute the size of the tuple.\n"; + ret += "//\t\t\tNote: buffer storage packed at the end of the tuple.\n"; + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type() && + !( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"selvar_%d",s); + ret+="\t"+sdt->make_host_cvar(tmpstr)+" = "; + ret += generate_se_code_fm_aggr(se,gbvar, aggvar, schema) +";\n"; + } + } + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + ret+="\ttup.tuple_size = sizeof(" + generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t)"; + for(s=0;s0) ret += "+"; + scalarexp_t *se = select_list[s]->se; + data_type *sdt = select_list[s]->se->get_data_type(); + if(sdt->is_buffer_type()){ + if(!( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr," + %s(&selvar_%d)", sdt->get_hfta_buffer_size().c_str(),s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr," + %s(&%s)", sdt->get_hfta_buffer_size().c_str(),generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + } + } + } + ret.append(";\n"); + +// Allocate tuple data block. + ret += "//\t\tCreate the tuple block.\n"; + ret += "\ttup.data = malloc(tup.tuple_size);\n"; + ret += "\ttup.heap_resident = true;\n"; + +// Mark tuple as regular + ret += "\t*((gs_sp_t )tup.data + sizeof(" + generate_tuple_name( this->get_node_name()) +")) = REGULAR_TUPLE;\n"; + +// ret += "\ttup.channel = 0;\n"; + ret += "\t"+generate_tuple_name( this->get_node_name())+" *tuple = ("+ + generate_tuple_name( this->get_node_name())+" *)(tup.data);\n"; + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + ret += "\tint tuple_pos = sizeof("+generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t);\n"; + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type()){ + if(!( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &selvar_%d, ((gs_sp_t )tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, s); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&selvar_%d);\n", sdt->get_hfta_buffer_size().c_str(), s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &%s, ((gs_sp_t )tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&%s);\n", sdt->get_hfta_buffer_size().c_str(), generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + } + }else{ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret.append(tmpstr); + ret.append(generate_se_code_fm_aggr(se,gbvar, aggvar, schema) ); + ret.append(";\n"); + } + } + +// Destroy string temporaries + ret += gen_buffer_selvars_dtr(select_list); +// Destroy string return vals of UDAFs + for(a=0;aget_fcn_dt(afcn_id); + if(adt->is_buffer_type()){ + sprintf(tmpstr,"\t%s(&udaf_ret_%d);\n", + adt->get_hfta_buffer_destroy().c_str(), a ); + ret += tmpstr; + } + } + } + + + ret += "\treturn tup;\n"; + ret += "};\n"; + + +//------------------------------------------------------------------- +// Temporal update functions + + ret+="bool temp_status_received(){return temp_tuple_received;};\n\n"; + +// create a temp status tuple + ret += "int create_temp_status_tuple(host_tuple& result, bool flush_finished) {\n\n"; + + ret += gen_init_temp_status_tuple(this->get_node_name()); + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + for(s=0;sse->get_data_type(); + if(sdt->is_temporal()){ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret += tmpstr; + sprintf(tmpstr,"(flush_finished) ? %s : %s ", generate_se_code(select_list[s]->se,schema).c_str(), generate_se_code_fm_aggr(select_list[s]->se,"last_flushed_gb", "", schema).c_str()); + ret += tmpstr; + ret += ";\n"; + } + } + + ret += "\treturn 0;\n"; + ret += "};};\n\n\n"; + + +//---------------------------------------------------------- +// The hash function + + ret += "struct "+generate_functor_name()+"_hash_func{\n"; + ret += "\tgs_uint32_t operator()(const "+generate_functor_name()+ + "_groupdef *grp) const{\n"; + ret += "\t\treturn("; + for(g=0;g0) ret += "^"; + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->use_hashfunc()){ + if(gdt->is_buffer_type()) + sprintf(tmpstr,"(%s*%s(&)grp->gb_var%d)))",hash_nums[g%NRANDS].c_str(),gdt->get_hfta_hashfunc().c_str(),g); + else + sprintf(tmpstr,"(%s*%s(grp->gb_var%d))",hash_nums[g%NRANDS].c_str(),gdt->get_hfta_hashfunc().c_str(),g); + }else{ + sprintf(tmpstr,"(%s*grp->gb_var%d)",hash_nums[g%NRANDS].c_str(),g); + } + ret += tmpstr; + } + ret += ") >> 32);\n"; + ret += "\t}\n"; + ret += "};\n\n"; + +//---------------------------------------------------------- +// The superhash function + + ret += "struct "+generate_functor_name()+"_superhash_func{\n"; + ret += "\tgs_uint32_t operator()(const "+generate_functor_name()+ + "_groupdef *grp) const{\n"; + ret += "\t\treturn(0"; + + for(g=0;g0){ + ret += "^"; + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->use_hashfunc()){ + sprintf(tmpstr,"(%s*%s(&(grp->gb_var%d)))",hash_nums[g%NRANDS].c_str(),gdt->get_hfta_hashfunc().c_str(),g); + }else{ + sprintf(tmpstr,"(%s*grp->gb_var%d)",hash_nums[g%NRANDS].c_str(),g); + } + ret += tmpstr; + } + } + ret += ") >> 32);\n"; + + ret += "\t}\n"; + ret += "};\n\n"; + +//---------------------------------------------------------- +// The comparison function + + ret += "struct "+generate_functor_name()+"_equal_func{\n"; + ret += "\tbool operator()(const "+generate_functor_name()+"_groupdef *grp1, "+ + generate_functor_name()+"_groupdef *grp2) const{\n"; + ret += "\t\treturn( ("; + for(g=0;g0) ret += ") && ("; + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->complex_comparison(gdt)){ + if(gdt->is_buffer_type()) + sprintf(tmpstr,"(%s(&(grp1->gb_var%d), &(grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + else + sprintf(tmpstr,"(%s((grp1->gb_var%d), (grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + }else{ + sprintf(tmpstr,"grp1->gb_var%d == grp2->gb_var%d",g,g); + } + ret += tmpstr; + } + ret += ") );\n"; + ret += "\t}\n"; + ret += "};\n\n"; + + +//---------------------------------------------------------- +// The superhashcomparison function + + ret += "struct "+generate_functor_name()+"_superequal_func{\n"; + ret += "\tbool operator()(const "+generate_functor_name()+"_groupdef *grp1, "+ + generate_functor_name()+"_groupdef *grp2) const{\n"; + ret += "\t\treturn( ("; + if(sg_tbl.size()){ + bool first_elem = true; + for(g=0;gcomplex_comparison(gdt)){ + if(gdt->is_buffer_type()) + sprintf(tmpstr,"(%s(&(grp1->gb_var%d), &(grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + else + sprintf(tmpstr,"(%s((grp1->gb_var%d), (grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + }else{ + sprintf(tmpstr,"grp1->gb_var%d == grp2->gb_var%d",g,g); + } + ret += tmpstr; + } + } + }else{ + ret += "true"; + } + + ret += ") );\n"; + ret += "\t}\n"; + + + ret += "};\n\n"; + return(ret); +} + +string sgahcwcb_qpn::generate_operator(int i, string params){ + + return( + " clean_operator<" + + generate_functor_name()+",\n\t"+ + generate_functor_name() + "_groupdef, \n\t" + + generate_functor_name() + "_aggrdef, \n\t" + + generate_functor_name() + "_statedef, \n\t" + + generate_functor_name()+"_hash_func, \n\t"+ + generate_functor_name()+"_equal_func ,\n\t"+ + generate_functor_name()+"_superhash_func,\n\t "+ + generate_functor_name()+"_superequal_func \n\t"+ + "> *op"+int_to_string(i)+" = new clean_operator<"+ + generate_functor_name()+",\n\t"+ + generate_functor_name() + "_groupdef,\n\t " + + generate_functor_name() + "_aggrdef, \n\t" + + generate_functor_name() + "_statedef, \n\t" + + generate_functor_name()+"_hash_func, \n\t"+ + generate_functor_name()+"_equal_func, \n\t"+ + generate_functor_name()+"_superhash_func, \n\t"+ + generate_functor_name()+"_superequal_func\n\t " + ">("+params+", \"" + get_node_name() + "\");\n" + ); +} + +//////////////////////////////////////////////////////////////// +//// RSGAH functor + + + +string rsgah_qpn::generate_functor_name(){ + return("rsgah_functor_" + normalize_name(this->get_node_name())); +} + + +string rsgah_qpn::generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, vector &needs_xform){ + int a,g,w,s; + + +// Initialize generate utility globals + segen_gb_tbl = &(gb_tbl); + + +//-------------------------------- +// group definition class + string ret = "class " + generate_functor_name() + "_groupdef{\n"; + ret += "public:\n"; + for(g=0;ggb_tbl.size();g++){ + sprintf(tmpstr,"gb_var%d",g); + ret+="\t"+this->gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + } +// Constructors + ret += "\t"+generate_functor_name() + "_groupdef(){};\n"; + ret += "\t"+generate_functor_name() + "_groupdef("+ + this->generate_functor_name() + "_groupdef *gd){\n"; + for(g=0;gis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&gb_var%d, &(gd->gb_var%d));\n", + gdt->get_hfta_buffer_assign_copy().c_str(),g,g ); + ret += tmpstr; + }else{ + sprintf(tmpstr,"\t\tgb_var%d = gd->gb_var%d;\n",g,g); + ret += tmpstr; + } + } + ret += "\t};\n"; +// destructor + ret += "\t~"+ generate_functor_name() + "_groupdef(){\n"; + for(g=0;gis_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&gb_var%d);\n", + gdt->get_hfta_buffer_destroy().c_str(), g ); + ret += tmpstr; + } + } + ret += "\t};\n"; + ret +="};\n\n"; + +//-------------------------------- +// aggr definition class + ret += "class " + this->generate_functor_name() + "_aggrdef{\n"; + ret += "public:\n"; + for(a=0;amake_host_cvar(tmpstr)+";\n"; + else + ret+="\t"+ aggr_tbl.get_storage_type(a)->make_host_cvar(tmpstr)+";\n"; + } +// Constructors + ret += "\t"+this->generate_functor_name() + "_aggrdef(){};\n"; +// destructor + ret += "\t~"+this->generate_functor_name() + "_aggrdef(){\n"; + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&aggr_var%d);\n", + adt->get_hfta_buffer_destroy().c_str(), a ); + ret += tmpstr; + } + }else{ + ret+="\t\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_DESTROY_("; + if(aggr_tbl.get_storage_type(a)->get_type() != fstring_t) ret+="&"; + ret+="(aggr_var"+int_to_string(a)+"));\n"; + } + } + ret += "\t};\n"; + ret +="};\n\n"; + +//-------------------------------- +// gb functor class + ret += "class " + this->generate_functor_name() + "{\n"; + +// Find variables referenced in this query node. + + col_id_set cid_set; + col_id_set::iterator csi; + + for(w=0;wpr,cid_set,segen_gb_tbl); + for(w=0;wpr,cid_set,segen_gb_tbl); + for(w=0;wpr,cid_set,segen_gb_tbl); + for(g=0;gse,cid_set,segen_gb_tbl); // descends into aggregates + } + + +// Private variables : store the state of the functor. +// 1) variables for unpacked attributes +// 2) offsets of the upacked attributes +// 3) storage of partial functions +// 4) storage of complex literals (i.e., require a constructor) + + ret += "private:\n"; + + // var to save the schema handle + ret += "\tint schema_handle0;\n"; + + // generate the declaration of all the variables related to + // temp tuples generation + ret += gen_decl_temp_vars(); + +// unpacked attribute storage, offsets + ret += "//\t\tstorage and offsets of accessed fields.\n"; + ret += generate_access_vars(cid_set, schema); +// tuple metadata offset + ret += "\tint tuple_metadata_offset0;\n"; + +// Variables to store results of partial functions. +// WARNING find_partial_functions modifies the SE +// (it marks the partial function id). + ret += "//\t\tParital function result storage\n"; + vector partial_fcns; + vector fcn_ref_cnt; + vector is_partial_fcn; + for(s=0;sse, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(w=0;wpr, &partial_fcns, NULL,NULL, Ext_fcns); + } + for(g=0;g0){ + ret += "/*\t\tVariables for storing results of partial functions. \t*/\n"; + ret += generate_partial_fcn_vars(partial_fcns,fcn_ref_cnt,is_partial_fcn,false); + } + +// Create cached temporaries for UDAF return values. + for(a=0;aget_fcn_dt(afcn_id); + sprintf(tmpstr,"udaf_ret_%d", a); + ret+="\t"+adt->make_host_cvar(tmpstr)+";\n"; + } + } + + +// Complex literals (i.e., they need constructors) + ret += "//\t\tComplex literal storage.\n"; + cplx_lit_table *complex_literals = this->get_cplx_lit_tbl(Ext_fcns); + ret += generate_complex_lit_vars(complex_literals); + +// Pass-by-handle parameters + ret += "//\t\tPass-by-handle storage.\n"; + vector param_handle_table = this->get_handle_param_tbl(Ext_fcns); + ret += generate_pass_by_handle_vars(param_handle_table); + + +// variables to hold parameters. + ret += "//\tfor query parameters\n"; + ret += generate_param_vars(param_tbl); + +// Is there a temporal flush? If so create flush temporaries, +// create flush indicator. + bool uses_temporal_flush = false; + for(g=0;gis_temporal()) + uses_temporal_flush = true; + } + + if(uses_temporal_flush){ + ret += "//\t\tFor temporal flush\n"; + for(g=0;gis_temporal()){ + sprintf(tmpstr,"last_gb%d",g); + ret+="\t"+gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + sprintf(tmpstr,"last_flushed_gb%d",g); + ret+="\t"+gb_tbl.get_data_type(g)->make_host_cvar(tmpstr)+";\n"; + } + } + ret += "\tbool needs_temporal_flush;\n"; + } + +// The publicly exposed functions + + ret += "\npublic:\n"; + + +//------------------- +// The functor constructor +// pass in the schema handle. +// 1) make assignments to the unpack offset variables +// 2) initialize the complex literals + + ret += "//\t\tFunctor constructor.\n"; + ret += this->generate_functor_name()+"(int schema_handle0){\n"; + + // save the schema handle + ret += "\t\tthis->schema_handle0 = schema_handle0;\n"; +// metadata offset + ret += "\ttuple_metadata_offset0 = ftaschema_get_tuple_metadata_offset(schema_handle0);\n"; + +// unpack vars + ret += "//\t\tGet offsets for unpacking fields from input tuple.\n"; + ret += gen_access_var_init(cid_set); + +// complex literals + ret += "//\t\tInitialize complex literals.\n"; + ret += gen_complex_lit_init(complex_literals); + +// Initialize partial function results so they can be safely GC'd + ret += gen_partial_fcn_init(partial_fcns); + +// Initialize non-query-parameter parameter handles + ret += gen_pass_by_handle_init(param_handle_table); + +// temporal flush variables +// ASSUME that structured values won't be temporal. + if(uses_temporal_flush){ + ret += "//\t\tInitialize temporal flush variables.\n"; + for(g=0;gis_temporal()){ + literal_t gl(gdt->type_indicator()); + sprintf(tmpstr,"\tlast_gb%d = %s;\n",g, gl.to_hfta_C_code("").c_str()); + ret.append(tmpstr); + } + } + ret += "\tneeds_temporal_flush = false;\n"; + } + + // Init temporal attributes referenced in select list + ret += gen_init_temp_vars(schema, select_list, segen_gb_tbl); + + ret += "};\n"; + + +//------------------- +// Functor destructor + ret += "//\t\tFunctor destructor.\n"; + ret += "~"+this->generate_functor_name()+"(){\n"; + +// clean up buffer type complex literals + ret += gen_complex_lit_dtr(complex_literals); + +// Deregister the pass-by-handle parameters + ret += "/* register and de-register the pass-by-handle parameters */\n"; + ret += gen_pass_by_handle_dtr(param_handle_table); + +// clean up partial function results. + ret += "/* clean up partial function storage */\n"; + ret += gen_partial_fcn_dtr(partial_fcns); + +// Destroy the parameters, if any need to be destroyed + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + + ret += "};\n\n"; + + +//------------------- +// Parameter manipulation routines + ret += generate_load_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + ret += generate_delete_param_block(this->generate_functor_name(), + this->param_tbl,param_handle_table); + +//------------------- +// Register new parameter block + + ret += "int set_param_block(gs_int32_t sz, void* value){\n"; + ret += "\tthis->destroy_params_"+this->generate_functor_name()+"();\n"; + ret += "\treturn this->load_params_"+this->generate_functor_name()+ + "(sz, value);\n"; + ret += "};\n\n"; + + +//------------------- +// the create_group method. +// This method creates a group in a buffer passed in +// (to allow for creation on the stack). +// There are also a couple of side effects: +// 1) evaluate the WHERE clause (and therefore, unpack all partial fcns) +// 2) determine if a temporal flush is required. + + ret += this->generate_functor_name()+"_groupdef *create_group(host_tuple &tup0, gs_sp_t buffer){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + + if(partial_fcns.size()>0){ // partial fcn access failure + ret += "\tgs_retval_t retval = 0;\n"; + ret += "\n"; + } +// return value + ret += "\t"+generate_functor_name()+"_groupdef *gbval = ("+generate_functor_name()+ + "_groupdef *) buffer;\n"; + +// Start by cleaning up partial function results + ret += "//\t\tcall destructors for partial fcn storage vars of buffer type\n"; + set w_pfcns; // partial fcns in where clause + for(w=0;wpr, w_pfcns); + + set ag_gb_pfcns; // partial fcns in gbdefs, aggr se's + for(g=0;gnode_name, 0); + col_id_set found_cids; // colrefs unpacked thus far. + ret += gen_unpack_temp_vars(schema, found_cids, select_list, segen_gb_tbl, needs_xform); + + +// Save temporal group-by variables + + + ret.append("\n\t//\t\tCompute temporal groupby attributes\n\n"); + + for(g=0;gis_temporal()){ + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); + ret.append(tmpstr); + } + } + ret.append("\n"); + + + +// Compare the temporal GB vars with the stored ones, +// set flush indicator and update stored GB vars if there is any change. + + if(uses_temporal_flush){ + ret+= "\tif( !( ("; + bool first_one = true; + for(g=0;gis_temporal()){ + sprintf(tmpstr,"last_gb%d",g); string lhs_op = tmpstr; + sprintf(tmpstr,"gbval->gb_var%d",g); string rhs_op = tmpstr; + if(first_one){first_one = false;} else {ret += ") && (";} + ret += generate_equality_test(lhs_op, rhs_op, gdt); + } + } + ret += ") ) ){\n"; + for(g=0;gis_temporal()){ + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&(gbval->gb_var%d),&last_gb%d);\n",gdt->get_hfta_buffer_replace().c_str(),g,g); + }else{ + sprintf(tmpstr,"\t\tlast_flushed_gb%d = last_gb%d;\n",g,g); + ret += tmpstr; + sprintf(tmpstr,"\t\tlast_gb%d = gbval->gb_var%d;\n",g,g); + } + ret += tmpstr; + } + } + ret += "\t\tneeds_temporal_flush=true;\n"; + ret += "\t\t}else{\n" + "\t\t\tneeds_temporal_flush=false;\n" + "\t\t}\n"; + } + + +// For temporal status tuple we don't need to do anything else + ret += "\tif (temp_tuple_received) return NULL;\n\n"; + + for(w=0;wpr, found_cids, new_cids, segen_gb_tbl); + +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "NULL", needs_xform); +// Find partial fcns ref'd in this cnf element + set pfcn_refs; + collect_partial_fcns_pr(where[w]->pr, pfcn_refs); + ret += gen_unpack_partial_fcn(schema, partial_fcns, pfcn_refs,"NULL"); + + ret += "\tif( !("+generate_predicate_code(where[w]->pr,schema)+ + +") ) return(NULL);\n"; + } + +// The partial functions ref'd in the group-by var and aggregate +// definitions must also be evaluated. If one returns false, +// then implicitly the predicate is false. + set::iterator pfsi; + + if(ag_gb_pfcns.size() > 0) + ret += "//\t\tUnpack remaining partial fcns.\n"; + ret += gen_full_unpack_partial_fcn(schema, partial_fcns, ag_gb_pfcns, + found_cids, segen_gb_tbl, "NULL", needs_xform); + +// Unpack the group-by variables + + for(g=0;gis_temporal()){ // temproal gbs already computed +// Find the new fields ref'd by this GBvar def. + col_id_set new_cids; + get_new_se_cids(gb_tbl.get_def(g), found_cids, new_cids, segen_gb_tbl); +// Unpack these values. + ret += gen_unpack_cids(schema, new_cids, "NULL", needs_xform); + + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); +/* +// There seems to be no difference between the two +// branches of the IF statement. + data_type *gdt = gb_tbl.get_data_type(g); + if(gdt->is_buffer_type()){ +// Create temporary copy. + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g, generate_se_code(gb_tbl.get_def(g),schema).c_str() ); + }else{ + scalarexp_t *gse = gb_tbl.get_def(g); + sprintf(tmpstr,"\tgbval->gb_var%d = %s;\n", + g,generate_se_code(gse,schema).c_str()); + } +*/ + ret.append(tmpstr); + } + } + ret.append("\n"); + + + ret+= "\treturn gbval;\n"; + ret += "};\n\n\n"; + +//-------------------------------------------------------- +// Create and initialize an aggregate object + + ret += this->generate_functor_name()+"_aggrdef *create_aggregate(host_tuple &tup0, gs_sp_t buffer){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// return value + ret += "\t"+generate_functor_name()+"_aggrdef *aggval = ("+generate_functor_name()+ + "_aggrdef *)buffer;\n"; + + for(a=0;ais_buffer_type()){ + sprintf(tmpstr,"aggr_tmp_%d", a); + ret+=adt->make_host_cvar(tmpstr)+";\n"; + } + } + } + +// Unpack all remaining attributes + ret += gen_remaining_colrefs(schema, cid_set, found_cids, "NULL", needs_xform); + for(a=0;aaggr_var%d",a); + string assignto_var = tmpstr; + ret += "\t"+generate_aggr_init(assignto_var,&aggr_tbl,a, schema); + } + + ret += "\treturn aggval;\n"; + ret += "};\n\n"; + +//-------------------------------------------------------- +// update an aggregate object + + ret += "void update_aggregate(host_tuple &tup0, " + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// use of temporaries depends on the aggregate, +// generate them in generate_aggr_update + + +// Unpack all remaining attributes + ret += gen_remaining_colrefs(schema, cid_set, found_cids, "", needs_xform); + for(a=0;aaggr_var%d",a); + string varname = tmpstr; + ret.append(generate_aggr_update(varname,&aggr_tbl,a, schema)); + } + + ret += "\treturn;\n"; + ret += "};\n"; + +//-------------------------------------------------------- +// reinitialize an aggregate object + + ret += "void reinit_aggregates( "+ + generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval){\n"; + // Variables for execution of the function. + ret += "\tgs_int32_t problem = 0;\n"; // return unpack failure + +// use of temporaries depends on the aggregate, +// generate them in generate_aggr_update + + for(g=0;gis_temporal()){ + if(gdt->is_buffer_type()){ + sprintf(tmpstr,"\t\t%s(&(gbval->gb_var%d),&last_gb%d);\n",gdt->get_hfta_buffer_replace().c_str(),g,g); + }else{ + sprintf(tmpstr,"\t\t gbval->gb_var%d =last_gb%d;\n",g,g); + } + ret += tmpstr; + } + } + +// Unpack all remaining attributes + for(a=0;aaggr_var%d",a); + string varname = tmpstr; + ret.append(generate_aggr_reinitialize(varname,&aggr_tbl,a, schema)); + } + + ret += "\treturn;\n"; + ret += "};\n"; + + + + + +//--------------------------------------------------- +// Flush test + + ret += "\tbool flush_needed(){\n"; + if(uses_temporal_flush){ + ret += "\t\treturn needs_temporal_flush;\n"; + }else{ + ret += "\t\treturn false;\n"; + } + ret += "\t};\n"; + +//--------------------------------------------------- +// create output tuple +// Unpack the partial functions ref'd in the where clause, +// select clause. Evaluate the where clause. +// Finally, pack the tuple. + +// I need to use special code generation here, +// so I'll leave it in longhand. + + ret += "host_tuple create_output_tuple(" + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval, bool &failed){\n"; + + ret += "\thost_tuple tup;\n"; + ret += "\tfailed = false;\n"; + ret += "\tgs_retval_t retval = 0;\n"; + + string gbvar = "gbval->gb_var"; + string aggvar = "aggval->"; + + +// First, get the return values from the UDAFS + for(a=0;aget_type() != fstring_t) ret+="&"; + ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n"; + } + } + + set hv_sl_pfcns; + for(w=0;wpr, hv_sl_pfcns); + } + for(s=0;sse, hv_sl_pfcns); + } + +// clean up the partial fcn results from any previous execution + ret += gen_partial_fcn_dtr(partial_fcns,hv_sl_pfcns); + +// Unpack them now + for(pfsi=hv_sl_pfcns.begin();pfsi!=hv_sl_pfcns.end();++pfsi){ + ret += unpack_partial_fcn_fm_aggr(partial_fcns[(*pfsi)], (*pfsi), gbvar, aggvar, schema); + ret += "\tif(retval){ failed = true; return(tup);}\n"; + } + +// Evalaute the HAVING clause +// TODO: this seems to have a ++ operator rather than a + operator. + for(w=0;wpr,gbvar, aggvar, schema) +") ) { failed = true; return(tup);}\n"; + } + +// Now, compute the size of the tuple. + +// Unpack any BUFFER type selections into temporaries +// so that I can compute their size and not have +// to recompute their value during tuple packing. +// I can use regular assignment here because +// these temporaries are non-persistent. +// TODO: should I be using the selvar generation routine? + + ret += "//\t\tCompute the size of the tuple.\n"; + ret += "//\t\t\tNote: buffer storage packed at the end of the tuple.\n"; + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type() && + !( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"selvar_%d",s); + ret+="\t"+sdt->make_host_cvar(tmpstr)+" = "; + ret += generate_se_code_fm_aggr(se,gbvar, aggvar, schema) +";\n"; + } + } + +// The size of the tuple is the size of the tuple struct plus the +// size of the buffers to be copied in. + + ret+="\ttup.tuple_size = sizeof(" + generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t)"; + for(s=0;s0) ret += "+"; + scalarexp_t *se = select_list[s]->se; + data_type *sdt = select_list[s]->se->get_data_type(); + if(sdt->is_buffer_type()){ + if(!( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr," + %s(&selvar_%d)", sdt->get_hfta_buffer_size().c_str(),s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr," + %s(&%s)", sdt->get_hfta_buffer_size().c_str(),generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + } + } + } + ret.append(";\n"); + +// Allocate tuple data block. + ret += "//\t\tCreate the tuple block.\n"; + ret += "\ttup.data = malloc(tup.tuple_size);\n"; + ret += "\ttup.heap_resident = true;\n"; + +// Mark tuple as regular + ret += "\t*((gs_sp_t )tup.data + sizeof(" + generate_tuple_name( this->get_node_name()) +")) = REGULAR_TUPLE;\n"; + +// ret += "\ttup.channel = 0;\n"; + ret += "\t"+generate_tuple_name( this->get_node_name())+" *tuple = ("+ + generate_tuple_name( this->get_node_name())+" *)(tup.data);\n"; + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + ret += "\tint tuple_pos = sizeof("+generate_tuple_name( this->get_node_name()) +") + sizeof(gs_uint8_t);\n"; + for(s=0;sse; + data_type *sdt = se->get_data_type(); + if(sdt->is_buffer_type()){ + if(!( (se->get_operator_type() == SE_COLREF) || + (se->get_operator_type() == SE_AGGR_STAR) || + (se->get_operator_type() == SE_AGGR_SE) || + (se->get_operator_type() == SE_FUNC && se->is_partial()) || + (se->get_operator_type() == SE_FUNC && se->get_aggr_ref() >= 0)) + ){ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &selvar_%d, ((gs_sp_t )tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, s); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&selvar_%d);\n", sdt->get_hfta_buffer_size().c_str(), s); + ret.append(tmpstr); + }else{ + sprintf(tmpstr,"\t%s(&(tuple->tuple_var%d), &%s, ((gs_sp_t )tuple)+tuple_pos, tuple_pos);\n", sdt->get_hfta_buffer_tuple_copy().c_str(),s, generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + sprintf(tmpstr,"\ttuple_pos += %s(&%s);\n", sdt->get_hfta_buffer_size().c_str(), generate_se_code_fm_aggr(se,gbvar, aggvar, schema).c_str()); + ret.append(tmpstr); + } + }else{ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret.append(tmpstr); + ret.append(generate_se_code_fm_aggr(se,gbvar, aggvar, schema) ); + ret.append(";\n"); + } + } + +// Destroy string temporaries + ret += gen_buffer_selvars_dtr(select_list); + + ret += "\treturn tup;\n"; + ret += "};\n"; + +//------------------------------------------------------------------ +// Cleaning_when : evaluate the cleaning_when clause. +// ASSUME that the udaf return values have already +// been unpacked. delete the string udaf return values at the end. + + ret += "bool cleaning_when(" + +generate_functor_name()+"_groupdef *gbval, "+ + generate_functor_name()+"_aggrdef *aggval){\n"; + + ret += "\tbool retval = true;\n"; + + + gbvar = "gbval->gb_var"; + aggvar = "aggval->"; + + + set clw_pfcns; + for(w=0;wpr, clw_pfcns); + } + +// clean up the partial fcn results from any previous execution + ret += gen_partial_fcn_dtr(partial_fcns,clw_pfcns); + +// Unpack them now + for(pfsi=clw_pfcns.begin();pfsi!=clw_pfcns.end();++pfsi){ + ret += unpack_partial_fcn_fm_aggr(partial_fcns[(*pfsi)], (*pfsi), gbvar, aggvar, schema); + ret += "\tif(retval){ return false;}\n"; + } + +// Evalaute the Closing When clause +// TODO: this seems to have a ++ operator rather than a + operator. + for(w=0;wpr,gbvar, aggvar, schema) +") ) { return false;}\n"; + } + + +// Destroy string return vals of UDAFs + for(a=0;aget_fcn_dt(afcn_id); + if(adt->is_buffer_type()){ + sprintf(tmpstr,"\t%s(&udaf_ret_%d);\n", + adt->get_hfta_buffer_destroy().c_str(), a ); + ret += tmpstr; + } + } + } + + ret += "\treturn retval;\n"; + ret += "};\n"; + + + + +//------------------------------------------------------------------- +// Temporal update functions + + ret+="bool temp_status_received(){return temp_tuple_received;};\n\n"; + +// create a temp status tuple + ret += "int create_temp_status_tuple(host_tuple& result, bool flush_finished) {\n\n"; + + ret += gen_init_temp_status_tuple(this->get_node_name()); + +// Start packing. +// (Here, offsets are hard-wired. is this a problem?) + + ret += "//\t\tPack the fields into the tuple.\n"; + for(s=0;sse->get_data_type(); + if(sdt->is_temporal()){ + sprintf(tmpstr,"\ttuple->tuple_var%d = ",s); + ret += tmpstr; + sprintf(tmpstr,"(flush_finished) ? %s : %s ", generate_se_code(select_list[s]->se,schema).c_str(), generate_se_code_fm_aggr(select_list[s]->se,"last_flushed_gb", "", schema).c_str()); + ret += tmpstr; + ret += ";\n"; + } + } + + ret += "\treturn 0;\n"; + ret += "};};\n\n\n"; + + +//---------------------------------------------------------- +// The hash function + + ret += "struct "+generate_functor_name()+"_hash_func{\n"; + ret += "\tgs_uint32_t operator()(const "+generate_functor_name()+ + "_groupdef *grp) const{\n"; + ret += "\t\treturn(0"; + for(g=0;gis_temporal()){ + ret += "^"; + if(gdt->use_hashfunc()){ + if(gdt->is_buffer_type()) + sprintf(tmpstr,"(%s*%s(&(grp->gb_var%d)))",hash_nums[g%NRANDS].c_str(),gdt->get_hfta_hashfunc().c_str(),g); + else + sprintf(tmpstr,"(%s*%s(grp->gb_var%d))",hash_nums[g%NRANDS].c_str(),gdt->get_hfta_hashfunc().c_str(),g); + }else{ + sprintf(tmpstr,"(%s*grp->gb_var%d)",hash_nums[g%NRANDS].c_str(),g); + } + ret += tmpstr; + } + } + ret += " >> 32);\n"; + ret += "\t}\n"; + ret += "};\n\n"; + +//---------------------------------------------------------- +// The comparison function + + ret += "struct "+generate_functor_name()+"_equal_func{\n"; + ret += "\tbool operator()(const "+generate_functor_name()+"_groupdef *grp1, "+ + generate_functor_name()+"_groupdef *grp2) const{\n"; + ret += "\t\treturn( ("; + + string hcmpr = ""; + bool first_exec = true; + for(g=0;gis_temporal()){ + if(first_exec){first_exec=false;}else{ hcmpr += ") && (";} + if(gdt->complex_comparison(gdt)){ + if(gdt->is_buffer_type()) + sprintf(tmpstr,"(%s(&(grp1->gb_var%d), &(grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + else + sprintf(tmpstr,"(%s((grp1->gb_var%d), (grp2->gb_var%d))==0)", + gdt->get_hfta_comparison_fcn(gdt).c_str(),g,g); + }else{ + sprintf(tmpstr,"grp1->gb_var%d == grp2->gb_var%d",g,g); + } + hcmpr += tmpstr; + } + } + if(hcmpr == "") + hcmpr = "true"; + ret += hcmpr; + + ret += ") );\n"; + ret += "\t}\n"; + ret += "};\n\n"; + + + return(ret); +} + +string rsgah_qpn::generate_operator(int i, string params){ + + return( + " running_agg_operator<" + + generate_functor_name()+","+ + generate_functor_name() + "_groupdef, " + + generate_functor_name() + "_aggrdef, " + + generate_functor_name()+"_hash_func, "+ + generate_functor_name()+"_equal_func " + "> *op"+int_to_string(i)+" = new running_agg_operator<"+ + generate_functor_name()+","+ + generate_functor_name() + "_groupdef, " + + generate_functor_name() + "_aggrdef, " + + generate_functor_name()+"_hash_func, "+ + generate_functor_name()+"_equal_func " + ">("+params+", \"" + get_node_name() + "\");\n" + ); +} + + + +// Split aggregation into two HFTA components - sub and superaggregation +// If unable to split the aggreagates, empty vector will be returned +vector sgah_qpn::split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema){ + + vector ret_vec; + int s, p, g, a, o, i; + int si; + + vector fta_flds, stream_flds; + int t = table_name->get_schema_ref(); + +// Get the set of interfaces it accesses. + int ierr; + vector sel_names; + +// Verify that all of the ref'd UDAFs can be split. + + for(a=0;aget_hfta_superaggr_id(afcn); + int hfta_sub_id = Ext_fcns->get_hfta_subaggr_id(afcn); + if(hfta_super_id < 0 || hfta_sub_id < 0){ + return(ret_vec); + } + } + } + +///////////////////////////////////////////////////// +// Split into aggr/aggr. + + + sgah_qpn *low_hfta_node = new sgah_qpn(); + low_hfta_node->table_name = table_name; + low_hfta_node->set_node_name( "_"+node_name ); + low_hfta_node->table_name->set_range_var(table_name->get_var_name()); + + + sgah_qpn *hi_hfta_node = new sgah_qpn(); + hi_hfta_node->table_name = new tablevar_t( ("_"+node_name).c_str()); + hi_hfta_node->set_node_name( node_name ); + hi_hfta_node->table_name->set_range_var(table_name->get_var_name()); + +// First, process the group-by variables. +// both low and hi level queries duplicate group-by variables of original query + + + for(g=0;ggb_tbl.add_gb_var( + gb_tbl.get_name(g), gb_tbl.get_tblvar_ref(g), gbvar_def, gb_tbl.get_reftype(g) + ); + +// Insert a ref to the value of the gbvar into the low-level hfta select list. + colref_t *new_cr = new colref_t(gb_tbl.get_name(g).c_str() ); + scalarexp_t *gbvar_fta = new scalarexp_t(new_cr); + gbvar_fta->set_gb_ref(g); + gbvar_fta->set_data_type( gb_tbl.get_def(g)->get_data_type() ); + scalarexp_t *gbvar_stream = make_fta_se_ref(low_hfta_node->select_list, gbvar_fta,0); + +// Insert the corresponding gbvar ref (gbvar_stream) into the stream. + gbvar_stream->set_gb_ref(-1); // used as GBvar def + hi_hfta_node->gb_tbl.add_gb_var( + gbvar_stream->get_colref()->get_field(), -1, gbvar_stream, gb_tbl.get_reftype(g) + ); + + } +// hi_hfta_node->gb_tbl.gb_patterns = gb_tbl.gb_patterns; // pattern processing at higtest level + hi_hfta_node->gb_tbl.set_pattern_info( &gb_tbl); // pattern processing at higtest level + +// SEs in the aggregate definitions. +// They are all safe, so split them up for later processing. + map hfta_aggr_se; + for(a=0;aaggr_tbl), &(low_hfta_node->aggr_tbl) , + low_hfta_node->select_list, + hfta_aggr_se, + Ext_fcns + ); + } + + +// Next, the select list. + + for(s=0;sse, &hfta_aggr_se); + hi_hfta_node->select_list.push_back( + new select_element(root_se, select_list[s]->name)); + } + + + +// All the predicates in the where clause must execute +// in the low-level hfta. + + for(p=0;ppr, &aggr_tbl); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + low_hfta_node->where.push_back(new_cnf); + } + +// All of the predicates in the having clause must +// execute in the high-level hfta node. + + for(p=0;ppr, &hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + hi_hfta_node->having.push_back(cnf_root); + } + + +// Copy parameters to both nodes + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + low_hfta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + hi_hfta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + low_hfta_node->definitions = definitions; + hi_hfta_node->definitions = definitions; + + + low_hfta_node->table_name->set_machine(table_name->get_machine()); + low_hfta_node->table_name->set_interface(table_name->get_interface()); + low_hfta_node->table_name->set_ifq(false); + + hi_hfta_node->table_name->set_machine(table_name->get_machine()); + hi_hfta_node->table_name->set_interface(table_name->get_interface()); + hi_hfta_node->table_name->set_ifq(false); + + ret_vec.push_back(low_hfta_node); + ret_vec.push_back(hi_hfta_node); + + + return(ret_vec); + + + // TODO: add splitting into selection/aggregation +} + + +// Split aggregation into two HFTA components - sub and superaggregation +// If unable to split the aggreagates, empty vector will be returned +// Similar to sgah, but super aggregate is rsgah, subaggr is sgah +vector rsgah_qpn::split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema){ + + vector ret_vec; + int s, p, g, a, o, i; + int si; + + vector fta_flds, stream_flds; + int t = table_name->get_schema_ref(); + +// Get the set of interfaces it accesses. + int ierr; + vector sel_names; + +// Verify that all of the ref'd UDAFs can be split. + + for(a=0;aget_hfta_superaggr_id(afcn); + int hfta_sub_id = Ext_fcns->get_hfta_subaggr_id(afcn); + if(hfta_super_id < 0 || hfta_sub_id < 0){ + return(ret_vec); + } + } + } + +///////////////////////////////////////////////////// +// Split into aggr/aggr. + + + sgah_qpn *low_hfta_node = new sgah_qpn(); + low_hfta_node->table_name = table_name; + low_hfta_node->set_node_name( "_"+node_name ); + low_hfta_node->table_name->set_range_var(table_name->get_var_name()); + + + rsgah_qpn *hi_hfta_node = new rsgah_qpn(); + hi_hfta_node->table_name = new tablevar_t( ("_"+node_name).c_str()); + hi_hfta_node->set_node_name( node_name ); + hi_hfta_node->table_name->set_range_var(table_name->get_var_name()); + +// First, process the group-by variables. +// both low and hi level queries duplicate group-by variables of original query + + + for(g=0;ggb_tbl.add_gb_var( + gb_tbl.get_name(g), gb_tbl.get_tblvar_ref(g), gbvar_def, gb_tbl.get_reftype(g) + ); + +// Insert a ref to the value of the gbvar into the low-level hfta select list. + colref_t *new_cr = new colref_t(gb_tbl.get_name(g).c_str() ); + scalarexp_t *gbvar_fta = new scalarexp_t(new_cr); + gbvar_fta->set_gb_ref(g); + gbvar_fta->set_data_type( gb_tbl.get_def(g)->get_data_type() ); + scalarexp_t *gbvar_stream = make_fta_se_ref(low_hfta_node->select_list, gbvar_fta,0); + +// Insert the corresponding gbvar ref (gbvar_stream) into the stream. + gbvar_stream->set_gb_ref(-1); // used as GBvar def + hi_hfta_node->gb_tbl.add_gb_var( + gbvar_stream->get_colref()->get_field(), -1, gbvar_stream, gb_tbl.get_reftype(g) + ); + + } + +// SEs in the aggregate definitions. +// They are all safe, so split them up for later processing. + map hfta_aggr_se; + for(a=0;aaggr_tbl), &(low_hfta_node->aggr_tbl) , + low_hfta_node->select_list, + hfta_aggr_se, + Ext_fcns + ); + } + + +// Next, the select list. + + for(s=0;sse, &hfta_aggr_se); + hi_hfta_node->select_list.push_back( + new select_element(root_se, select_list[s]->name)); + } + + + +// All the predicates in the where clause must execute +// in the low-level hfta. + + for(p=0;ppr, &aggr_tbl); + cnf_elem *new_cnf = new cnf_elem(new_pr); + analyze_cnf(new_cnf); + + low_hfta_node->where.push_back(new_cnf); + } + +// All of the predicates in the having clause must +// execute in the high-level hfta node. + + for(p=0;ppr, &hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + hi_hfta_node->having.push_back(cnf_root); + } + +// Similar for closing when + for(p=0;ppr, &hfta_aggr_se); + cnf_elem *cnf_root = new cnf_elem(pr_root); + analyze_cnf(cnf_root); + + hi_hfta_node->closing_when.push_back(cnf_root); + } + + +// Copy parameters to both nodes + vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + low_hfta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + hi_hfta_node->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + low_hfta_node->definitions = definitions; + hi_hfta_node->definitions = definitions; + + + low_hfta_node->table_name->set_machine(table_name->get_machine()); + low_hfta_node->table_name->set_interface(table_name->get_interface()); + low_hfta_node->table_name->set_ifq(false); + + hi_hfta_node->table_name->set_machine(table_name->get_machine()); + hi_hfta_node->table_name->set_interface(table_name->get_interface()); + hi_hfta_node->table_name->set_ifq(false); + + ret_vec.push_back(low_hfta_node); + ret_vec.push_back(hi_hfta_node); + + + return(ret_vec); + + + // TODO: add splitting into selection/aggregation +} + +//--------------------------------------------------------------- +// Code for propagating Protocol field source information + + +scalarexp_t *resolve_protocol_se(scalarexp_t *se, vector *> &src_vec, gb_table *gb_tbl, table_list *Schema){ + scalarexp_t *rse, *lse,*p_se, *gb_se; + int tno, schema_type; + map *pse_map; + + switch(se->get_operator_type()){ + case SE_LITERAL: + return new scalarexp_t(se->get_literal()); + case SE_PARAM: + return scalarexp_t::make_param_reference(se->get_op().c_str()); + case SE_COLREF: + if(se->is_gb()){ + if(gb_tbl == NULL) + fprintf(stderr,"INTERNAL ERROR, in resolve_protocol_se, se->gb_ref=%d, but gb_tbl is NULL\n",se->get_gb_ref()); + gb_se = gb_tbl->get_def(se->get_gb_ref()); + return resolve_protocol_se(gb_se,src_vec,gb_tbl,Schema); + } + + schema_type = Schema->get_schema_type(se->get_colref()->get_schema_ref()); + if(schema_type == PROTOCOL_SCHEMA) + return dup_se(se,NULL); + + tno = se->get_colref()->get_tablevar_ref(); + if(tno >= src_vec.size()){ + fprintf(stderr,"INTERNAL ERROR, in resolve_protocol_se, tno=%d, src_vec.size()=%lu\n",tno,src_vec.size()); + } + if(src_vec[tno] == NULL) + return NULL; + + pse_map =src_vec[tno]; + p_se = (*pse_map)[se->get_colref()->get_field()]; + if(p_se == NULL) + return NULL; + return dup_se(p_se,NULL); + case SE_UNARY_OP: + lse = resolve_protocol_se(se->get_left_se(),src_vec,gb_tbl,Schema); + if(lse == NULL) + return NULL; + else + return new scalarexp_t(se->get_op().c_str(),lse); + case SE_BINARY_OP: + lse = resolve_protocol_se(se->get_left_se(),src_vec,gb_tbl,Schema); + if(lse == NULL) + return NULL; + rse = resolve_protocol_se(se->get_right_se(),src_vec,gb_tbl,Schema); + if(rse == NULL) + return NULL; + return new scalarexp_t(se->get_op().c_str(),lse,rse); + case SE_AGGR_STAR: + return( NULL ); + case SE_AGGR_SE: + return( NULL ); + case SE_FUNC: + return(NULL); + default: + return(NULL); + break; + } + +} + +void spx_qpn::create_protocol_se(vector q_sources, table_list *Schema){ + int i; + vector *> src_vec; + + for(i=0;iget_protocol_se()); + else + src_vec.push_back(NULL); + } + + for(i=0;iname] = resolve_protocol_se(select_list[i]->se,src_vec,NULL,Schema); + } +} + +void join_eq_hash_qpn::create_protocol_se(vector q_sources, table_list *Schema){ + int i; + vector *> src_vec; + + for(i=0;iget_protocol_se()); + else + src_vec.push_back(NULL); + } + + for(i=0;iname] = resolve_protocol_se(select_list[i]->se,src_vec,NULL,Schema); + } + + for(i=0;ipr->get_left_se(),src_vec,NULL,Schema)); + hash_src_r.push_back(resolve_protocol_se(hash_eq[i]->pr->get_right_se(),src_vec,NULL,Schema)); + } +} + +void filter_join_qpn::create_protocol_se(vector q_sources, table_list *Schema){ + int i; + vector *> src_vec; + + for(i=0;iget_protocol_se()); + else + src_vec.push_back(NULL); + } + + for(i=0;iname] = resolve_protocol_se(select_list[i]->se,src_vec,NULL,Schema); + } + + for(i=0;ipr->get_left_se(),src_vec,NULL,Schema)); + hash_src_r.push_back(resolve_protocol_se(hash_eq[i]->pr->get_right_se(),src_vec,NULL,Schema)); + } +} + +void sgah_qpn::create_protocol_se(vector q_sources, table_list *Schema){ + int i; + vector *> src_vec; + + for(i=0;iget_protocol_se()); + else + src_vec.push_back(NULL); + } + + for(i=0;iname] = resolve_protocol_se(select_list[i]->se,src_vec,&gb_tbl,Schema); + } + + for(i=0;i q_sources, table_list *Schema){ + int i; + vector *> src_vec; + + for(i=0;iget_protocol_se()); + else + src_vec.push_back(NULL); + } + + for(i=0;iname] = resolve_protocol_se(select_list[i]->se,src_vec,&gb_tbl,Schema); + } + + for(i=0;i q_sources, table_list *Schema){ + int i; + vector *> src_vec; + + for(i=0;iget_protocol_se()); + else + src_vec.push_back(NULL); + } + + for(i=0;iname] = resolve_protocol_se(select_list[i]->se,src_vec,&gb_tbl,Schema); + } + + for(i=0;i q_sources, table_list *Schema){ + int f,s,i; + scalarexp_t *first_se; + + vector *> src_vec; + map *pse_map; + + for(i=0;iget_protocol_se()); + else + src_vec.push_back(NULL); + } + + if(q_sources.size() == 0){ + fprintf(stderr,"INTERNAL ERROR in mrg_qpn::create_protocol_se, q_sources.size() == 0\n"); + exit(1); + } + + vector tbl_flds = table_layout->get_fields(); + for(f=0;fget_name(); + pse_map = src_vec[0]; + first_se = (*pse_map)[fld_nm]; + if(first_se == NULL) + match = false; + for(s=1;s +#include +#include +using namespace std; + +#include"analyze_fta.h" +#include"iface_q.h" +#include"parse_partn.h" +#include"generate_utils.h" + +// Identify the format of the input, output streams. +#define UNKNOWNFORMAT 0 +#define NETFORMAT 1 +#define HOSTFORMAT 2 + +/////////////////////////////////////////////////// +// representation of an output operator specification + +struct ospec_str{ + string query; + string operator_type; + string operator_param; + string output_directory; + int bucketwidth; + string partitioning_flds; + int n_partitions; +}; + + +//////////////////////////////////////////////////// +// Input representation of a query + +struct query_node{ + int idx; + std::set reads_from; + std::set sources_to; + std::vector refd_tbls; + std::vector params; + std::string name; + std::string file; + std::string mangler; // for UDOPs + bool touched; + table_exp_t *parse_tree; + int n_consumers; + bool is_udop; + bool is_externally_visible; + bool inferred_visible_node; + + set subtree_roots; + + query_node(){ + idx = -1; + touched = false; + parse_tree = NULL; + n_consumers = 0; + is_externally_visible = false; + inferred_visible_node = false; + mangler=""; + }; + query_node(int i, std::string qnm, std::string flnm, table_exp_t *pt){ + idx = i; + touched = false; + name = qnm; + file = flnm; + parse_tree = pt; + n_consumers = 0; + is_udop = false; + is_externally_visible = pt->get_visible(); + inferred_visible_node = false; + mangler=""; + + tablevar_list_t *fm = parse_tree->get_from(); + refd_tbls = fm->get_table_names(); + + params = pt->query_params; + }; + query_node(int ix, std::string udop_name,table_list *Schema){ + idx = ix; + touched = false; + name = udop_name; + file = udop_name; + parse_tree = NULL; + n_consumers = 0; + is_udop = true; + is_externally_visible = true; + inferred_visible_node = false; + mangler=""; + + int sid = Schema->find_tbl(udop_name); + std::vector subq = Schema->get_subqueryspecs(sid); + int i; + for(i=0;iname); + } + }; +}; + +struct hfta_node{ + std::string name; + std::string source_name; + std::vector query_node_indices; + std::set reads_from; + std::set sources_to; + bool is_udop; + bool inferred_visible_node; + int n_parallel; + int parallel_idx; + bool do_generation; // false means, ignore it. + + hfta_node(){ + is_udop = false; + inferred_visible_node = false; + n_parallel = 1; + parallel_idx = 0; + do_generation = true; + } +}; + + + + + + +#define SPX_QUERY 1 +#define SGAH_QUERY 2 + +// the following selectivity estimates are used by our primitive rate estimators +#define SPX_SELECTIVITY 1.0 +#define SGAH_SELECTIVITY 0.1 +#define RSGAH_SELECTIVITY 0.1 +#define SGAHCWCB_SELECTIVITY 0.1 +#define MRG_SELECTIVITY 1.0 +#define JOIN_EQ_HASH_SELECTIVITY 1.0 + +// the the output rate of the interface is not given we are going to use +// this default value +#define DEFAULT_INTERFACE_RATE 100 + + +// Define query plan nodes +// These nodes are intended for query modeling +// and transformation rather than for code generation. + + +// Query plan node base class. +// It has an ID, can return its type, +// and can be linked into lists with the predecessors +// and successors. +// To add : serialize, unserialize? + +class qp_node{ +public: + int id; + std::vector predecessors; + std::vector successors; + std::string node_name; + +// For error reporting without exiting the program. + int error_code; + std::string err_str; + +// These should be moved to the containing stream_query object. + std::map definitions; + param_table *param_tbl; + +// The value of a field in terms of protocol fields (if any). + std::map protocol_map; + + qp_node(){ + error_code = 0; + id = -1; + param_tbl = new param_table(); + }; + qp_node(int i){ + error_code = 0; + id = i; + param_tbl = new param_table(); + }; + + int get_id(){return(id);}; + void set_id(int i){id = i; }; + + int get_error_code(){return error_code;}; + std::string get_error_str(){return err_str;}; + + virtual std::string node_type() = 0; + +// For code generation, does the operator xform its input. + virtual bool makes_transform() = 0; + +// For linking, what external libraries does the operator depend on? + virtual std::vector external_libs() = 0; + + void set_node_name(std::string n){node_name = n;}; + std::string get_node_name(){return node_name;}; + + void set_definitions(std::map &def){ + definitions = def; + }; + std::map get_definitions(){return definitions;}; + + +// call to create the mapping from field name to se in protocol fields. +// Pass in qp_node of data sources, in order. + virtual void create_protocol_se(std::vector q_sources,table_list *Schema)=0; +// get the protocol map. the parameter is the return value. + std::map *get_protocol_se(){return &protocol_map;} + +// Each qp node must be able to return a description +// of the tuples it creates. +// TODO: the get_output_tls method should subsume the get_fields +// method, but in fact it really just returns the +// operator name. + virtual table_def *get_fields() = 0; // Should be vector? +// Get the from clause + virtual std::vector get_input_tbls() = 0; +// this is a confused function, it acutally return the output +// table name. + virtual std::vector get_output_tbls() = 0; + + std::string get_val_of_def(std::string def){ + if(definitions.count(def) > 0) return definitions[def]; + return(""); + }; + void set_definition(std::string def, std::string val){ + definitions[def]=val; + } + +// Associate colrefs in SEs with tables +// at code generation time. + virtual void bind_to_schema(table_list *Schema) = 0; + +// Get colrefs of the operator, currently only meaningful for lfta +// operators, and only interested in colrefs with extraction fcns + virtual col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema)=0; + + virtual std::string to_query_string() = 0; + virtual std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform) = 0; + virtual std::string generate_functor_name() = 0; + + virtual std::string generate_operator(int i, std::string params) = 0; + virtual std::string get_include_file() = 0; + + virtual cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns) = 0; + virtual std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns) = 0; + +// Split this node into LFTA and HFTA nodes. +// Four possible outcomes: +// 1) the qp_node reads from a protocol, but does not need to +// split (can be evaluated as an LFTA). +// The lfta node is the only element in the return vector, +// and hfta_returned is false. +// 2) the qp_node reads from no protocol, and therefore cannot be split. +// THe hfta node is the only element in the return vector, +// and hfta_returned is true. +// 3) reads from at least one protocol, but cannot be split : failure. +// return vector is empty, the error conditions are written +// in the qp_node. +// 4) The qp_node splits into an hfta node and one or more LFTA nodes. +// the return vector has two or more elements, and hfta_returned +// is true. The last element is the HFTA. + virtual std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx) = 0; + + +// Ensure that any refs to interface params have been split away. + virtual int count_ifp_refs(std::set &ifpnames)=0; + + + +// Tag the data sources which are views, +// return the (optimized) source queries and +// record the view access in opview_set + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm) = 0; + + param_table *get_param_tbl(){return param_tbl;}; + +// The "where" clause is a pre-filter + virtual std::vector get_where_clause() = 0; +// To be more explicit, use get_filter_preds + virtual std::vector get_filter_clause() = 0; + + void add_predecessor(int i){predecessors.push_back(i);}; + void remove_predecessor(int i){ + std::vector::iterator vi; + for(vi=predecessors.begin(); vi!=predecessors.end();++vi){ + if((*vi) == i){ + predecessors.erase(vi); + return; + } + } + }; + void add_successor(int i){successors.push_back(i);}; + std::vector get_predecessors(){return predecessors;}; + int n_predecessors(){return predecessors.size();}; + std::vector get_successors(){return successors;}; + int n_successors(){return successors.size();}; + void clear_predecessors(){predecessors.clear();}; + void clear_successors(){successors.clear();}; + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + + // used for cloning query nodes + virtual qp_node* make_copy(std::string suffix) = 0; +}; + + + +// Select, project, transform (xform) query plan node. +// represent the following query fragment +// select scalar_expression_1, ..., scalar_expression_k +// from S +// where predicate +// +// the predicates and the scalar expressions can reference +// attributes of S and also functions. +class spx_qpn: public qp_node{ +public: + tablevar_t *table_name; // Source table + std::vector where; // selection predicate + std::vector select_list; // Select list + + + + std::string node_type(){return("spx_qpn"); }; + bool makes_transform(){return true;}; + std::vector external_libs(){ + std::vector ret; + return ret; + } + + void bind_to_schema(table_list *Schema); + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema); + + std::string to_query_string(); + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform); + std::string generate_functor_name(); + std::string generate_operator(int i, std::string params); + std::string get_include_file(){return("#include \n");}; + + std::vector get_select_list(){return select_list;}; + std::vector get_select_se_list(){ + std::vector ret; + int i; + for(i=0;ise); + return ret; + }; + std::vector get_where_clause(){return where;}; + std::vector get_filter_clause(){return where;}; + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns); + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns); + + table_def *get_fields(); + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm); +// Ensure that any refs to interface params have been split away. + int count_ifp_refs(std::set &ifpnames); + int resolve_if_params(ifq_t *ifdb, std::string &err); + + spx_qpn(){ + }; + spx_qpn(query_summary_class *qs,table_list *Schema){ +// Get the table name. +// NOTE the colrefs have the table ref (an int) +// embedded in them. Would it make sense +// to grab the whole table list? + tablevar_list_t *fm = qs->fta_tree->get_from(); + std::vector tbl_vec = fm->get_table_list(); + if(tbl_vec.size() != 1){ + char tmpstr[200]; + sprintf(tmpstr,"INTERNAL ERROR building SPX node: query defined over %lu tables.\n",tbl_vec.size() ); + err_str = tmpstr; + error_code = 1; + } + table_name = (tbl_vec[0]); + +// Get the select list. + select_list = qs->fta_tree->get_sl_vec(); + +// Get the selection predicate. + where = qs->wh_cnf; + + +// Get the parameters + param_tbl = qs->param_tbl; + + + + }; + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + + qp_node* make_copy(std::string suffix){ + spx_qpn *ret = new spx_qpn(); + + ret->param_tbl = new param_table(); + std::vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + ret->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + ret->definitions = definitions; + ret->node_name = node_name + suffix; + + // make shallow copy of all fields + ret->where = where; + ret->select_list = select_list; + + return ret; + }; + void create_protocol_se(vector q_sources, table_list *Schema); + +}; + + + +// Select, group-by, aggregate. +// Representing +// Select SE_1, ..., SE_k +// From T +// Where predicate +// Group By gb1, ..., gb_n +// Having predicate +// +// NOTE : the samlping operator is sgahcwcb_qpn. +// +// For now, must have group-by variables and aggregates. +// The scalar expressions which are output must be a function +// of the groub-by variables and the aggregates. +// The group-by variables can be references to columsn of T, +// or they can be scalar expressions. +class sgah_qpn: public qp_node{ +public: + tablevar_t *table_name; // source table + std::vector where; // selection predicate + std::vector having; // post-aggregation predicate + std::vector select_list; // se's of output + gb_table gb_tbl; // Table of all group-by attributes. + aggregate_table aggr_tbl; // Table of all referenced aggregates. + + std::vector gb_sources; // pre-compute for partitioning. + + int lfta_disorder; // maximum disorder in the steam between lfta, hfta + int hfta_disorder; // maximum disorder in the hfta + +// rollup, cube, and grouping_sets cannot be readily reconstructed by +// analyzing the patterns, so explicitly record them here. +// used only so that to_query_string produces something meaningful. + std::vector gb_entry_type; + std::vector gb_entry_count; + + std::vector get_gb_sources(){return gb_sources;} + + std::string node_type(){return("sgah_qpn"); }; + bool makes_transform(){return true;}; + std::vector external_libs(){ + std::vector ret; + return ret; + } + + void bind_to_schema(table_list *Schema); + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema); + + std::string to_query_string(); + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform); + std::string generate_functor_name(); + + std::string generate_operator(int i, std::string params); + std::string get_include_file(){ + if(hfta_disorder <= 1){ + return("#include \n"); + }else{ + return("#include \n"); + } + }; + + std::vector get_select_list(){return select_list;}; + std::vector get_select_se_list(){ + std::vector ret; + int i; + for(i=0;ise); + return ret; + }; + std::vector get_where_clause(){return where;}; + std::vector get_filter_clause(){return where;}; + std::vector get_having_clause(){return having;}; + gb_table *get_gb_tbl(){return &gb_tbl;}; + aggregate_table *get_aggr_tbl(){return &aggr_tbl;}; + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns); + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns); + +// table which represents output tuple. + table_def *get_fields(); + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + + sgah_qpn(){ + lfta_disorder = 1; + hfta_disorder = 1; + }; + sgah_qpn(query_summary_class *qs,table_list *Schema){ + lfta_disorder = 1; + hfta_disorder = 1; + +// Get the table name. +// NOTE the colrefs have the tablevar ref (an int) +// embedded in them. Would it make sense +// to grab the whole table list? + tablevar_list_t *fm = qs->fta_tree->get_from(); + std::vector tbl_vec = fm->get_table_list(); + if(tbl_vec.size() != 1){ + char tmpstr[200]; + sprintf(tmpstr,"INTERNAL ERROR building SGAH node: query defined over %lu tables.\n",tbl_vec.size() ); + err_str=tmpstr; + error_code = 1; + } + table_name = (tbl_vec[0]); + +// Get the select list. + select_list = qs->fta_tree->get_sl_vec(); + +// Get the selection and having predicates. + where = qs->wh_cnf; + having = qs->hav_cnf; + +// Build a new GB var table (don't share, might need to modify) + int g; + for(g=0;ggb_tbl->size();g++){ + gb_tbl.add_gb_var(qs->gb_tbl->get_name(g), + qs->gb_tbl->get_tblvar_ref(g), qs->gb_tbl->get_def(g), + qs->gb_tbl->get_reftype(g) + ); + } + gb_tbl.set_pattern_info(qs->gb_tbl); +// gb_tbl.gb_entry_type = qs->gb_tbl->gb_entry_type; +// gb_tbl.gb_entry_count = qs->gb_tbl->gb_entry_count; +// gb_tbl.pattern_components = qs->gb_tbl->pattern_components; + +// Build a new aggregate table. (don't share, might need +// to modify). + int a; + for(a=0;aaggr_tbl->size();a++){ + aggr_tbl.add_aggr( +// qs->aggr_tbl->get_op(a), qs->aggr_tbl->get_aggr_se(a) + qs->aggr_tbl->duplicate(a) + ); + } + + +// Get the parameters + param_tbl = qs->param_tbl; + + }; + + + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm); +// Ensure that any refs to interface params have been split away. + int count_ifp_refs(std::set &ifpnames); + int resolve_if_params(ifq_t *ifdb, std::string &err); + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + + qp_node* make_copy(std::string suffix){ + sgah_qpn *ret = new sgah_qpn(); + + ret->param_tbl = new param_table(); + std::vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + ret->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + ret->definitions = definitions; + + ret->node_name = node_name + suffix; + + // make shallow copy of all fields + ret->where = where; + ret->having = having; + ret->select_list = select_list; + ret->gb_tbl = gb_tbl; + ret->aggr_tbl = aggr_tbl; + + return ret; + }; + +// Split aggregation into two HFTA components - sub and superaggregation +// If unable to split the aggreagates, split into selection and aggregation +// If resulting low-level query is empty (e.g. when aggregates cannot be split and +// where clause is empty) empty vector willb e returned + virtual std::vector split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema); + + void create_protocol_se(vector q_sources, table_list *Schema); + +}; + + + + +// Select, group-by, aggregate. with running aggregates +// Representing +// Select SE_1, ..., SE_k +// From T +// Where predicate +// Group By gb1, ..., gb_n +// Closing When predicate +// Having predicate +// +// NOTE : the sampling operator is sgahcwcb_qpn. +// +// For now, must have group-by variables and aggregates. +// The scalar expressions which are output must be a function +// of the groub-by variables and the aggregates. +// The group-by variables can be references to columsn of T, +// or they can be scalar expressions. +class rsgah_qpn: public qp_node{ +public: + tablevar_t *table_name; // source table + std::vector where; // selection predicate + std::vector having; // post-aggregation predicate + std::vector closing_when; // group closing predicate + std::vector select_list; // se's of output + gb_table gb_tbl; // Table of all group-by attributes. + aggregate_table aggr_tbl; // Table of all referenced aggregates. + + std::vector gb_sources; // pre-compute for partitioning. + + int lfta_disorder; // maximum disorder allowed in stream between lfta, hfta + int hfta_disorder; // maximum disorder allowed in hfta + + std::vector get_gb_sources(){return gb_sources;} + + + std::string node_type(){return("rsgah_qpn"); }; + bool makes_transform(){return true;}; + std::vector external_libs(){ + std::vector ret; + return ret; + } + + void bind_to_schema(table_list *Schema); + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema){ + fprintf(stderr,"INTERNAL ERROR, calling rsgah_qpn::get_colrefs\n"); + exit(1); + } + + std::string to_query_string(); + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform); + std::string generate_functor_name(); + + std::string generate_operator(int i, std::string params); + std::string get_include_file(){return("#include \n");}; + + std::vector get_select_list(){return select_list;}; + std::vector get_select_se_list(){ + std::vector ret; + int i; + for(i=0;ise); + return ret; + }; + std::vector get_where_clause(){return where;}; + std::vector get_filter_clause(){return where;}; + std::vector get_having_clause(){return having;}; + std::vector get_closing_when_clause(){return closing_when;}; + gb_table *get_gb_tbl(){return &gb_tbl;}; + aggregate_table *get_aggr_tbl(){return &aggr_tbl;}; + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns); + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns); + +// table which represents output tuple. + table_def *get_fields(); + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + + rsgah_qpn(){ + lfta_disorder = 1; + hfta_disorder = 1; + }; + rsgah_qpn(query_summary_class *qs,table_list *Schema){ + lfta_disorder = 1; + hfta_disorder = 1; + +// Get the table name. +// NOTE the colrefs have the tablevar ref (an int) +// embedded in them. Would it make sense +// to grab the whole table list? + tablevar_list_t *fm = qs->fta_tree->get_from(); + std::vector tbl_vec = fm->get_table_list(); + if(tbl_vec.size() != 1){ + char tmpstr[200]; + sprintf(tmpstr,"INTERNAL ERROR buildingR SGAH node: query defined over %lu tables.\n",tbl_vec.size() ); + err_str=tmpstr; + error_code = 1; + } + table_name = (tbl_vec[0]); + +// Get the select list. + select_list = qs->fta_tree->get_sl_vec(); + +// Get the selection and having predicates. + where = qs->wh_cnf; + having = qs->hav_cnf; + closing_when = qs->closew_cnf; + +// Build a new GB var table (don't share, might need to modify) + int g; + for(g=0;ggb_tbl->size();g++){ + gb_tbl.add_gb_var(qs->gb_tbl->get_name(g), + qs->gb_tbl->get_tblvar_ref(g), qs->gb_tbl->get_def(g), + qs->gb_tbl->get_reftype(g) + ); + } + +// Build a new aggregate table. (don't share, might need +// to modify). + int a; + for(a=0;aaggr_tbl->size();a++){ + aggr_tbl.add_aggr( +// qs->aggr_tbl->get_op(a), qs->aggr_tbl->get_aggr_se(a) + qs->aggr_tbl->duplicate(a) + ); + } + + +// Get the parameters + param_tbl = qs->param_tbl; + + }; + + + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + std::vector split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema); + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm); +// Ensure that any refs to interface params have been split away. + int count_ifp_refs(std::set &ifpnames); + int resolve_if_params(ifq_t *ifdb, std::string &err){ return 0;} + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + qp_node* make_copy(std::string suffix){ + rsgah_qpn *ret = new rsgah_qpn(); + + ret->param_tbl = new param_table(); + std::vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + ret->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + ret->definitions = definitions; + + ret->node_name = node_name + suffix; + + // make shallow copy of all fields + ret->where = where; + ret->having = having; + ret->closing_when = closing_when; + ret->select_list = select_list; + ret->gb_tbl = gb_tbl; + ret->aggr_tbl = aggr_tbl; + + return ret; + }; + void create_protocol_se(vector q_sources, table_list *Schema); +}; + + +// forward reference +class filter_join_qpn; + + +// (temporal) Merge query plan node. +// represent the following query fragment +// Merge c1:c2 +// from T1 _t1, T2 _t2 +// +// T1 and T2 must have compatible schemas, +// that is the same types in the same slots. +// c1 and c2 must be colrefs from T1 and T2, +// both ref'ing the same slot. Their types +// must be temporal and the same kind of temporal. +// in the output, no other field is temporal. +// the field names ofthe output are drawn from T1. +class mrg_qpn: public qp_node{ +public: + std::vector fm; // Source table + std::vector mvars; // the merge-by columns. + scalarexp_t *slack; + + table_def *table_layout; // the output schema + int merge_fieldpos; // position of merge field, + // convenience for manipulation. + + int disorder; // max disorder seen in the input / allowed in the output + + + // partition definition for merges that combine streams partitioned over multiple interfaces + partn_def_t* partn_def; + + + + std::string node_type(){return("mrg_qpn"); }; + bool makes_transform(){return false;}; + std::vector external_libs(){ + std::vector ret; + return ret; + } + + void bind_to_schema(table_list *Schema); + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema){ + fprintf(stderr,"INTERNAL ERROR, calling mrg_qpn::get_colrefs\n"); + exit(1); + } + + std::string to_query_string(); + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform); + std::string generate_functor_name(); + std::string generate_operator(int i, std::string params); + std::string get_include_file(){ + if(disorder>1) + return("#include \n"); + return("#include \n"); + }; + + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns); + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns); + + table_def *get_fields(); + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm); +// Ensure that any refs to interface params have been split away. + int count_ifp_refs(std::set &ifpnames); + +// No predicates, return an empty clause + std::vector get_where_clause(){ + std::vector t; + return(t); + }; + std::vector get_filter_clause(){ + return get_where_clause(); + } + + mrg_qpn(){ + partn_def = NULL; + }; + + void set_disorder(int d){ + disorder = d; + } + + mrg_qpn(query_summary_class *qs,table_list *Schema){ + disorder = 1; + +// Grab the elements of the query node. + fm = qs->fta_tree->get_from()->get_table_list(); + mvars = qs->mvars; + slack = qs->slack; + +// sanity check + if(fm.size() != mvars.size()){ + fprintf(stderr,"INTERNAL ERROR in mrg_qpn::mrg_qpn. fm.size() = %lu, mvars.size() = %lu\n",fm.size(),mvars.size()); + exit(1); + } + +// Get the parameters + param_tbl = qs->param_tbl; + +// Need to set the node name now, so that the +// schema (table_layout) can be properly named. +// TODO: Setting the name of the table might best be done +// via the set_node_name method, because presumably +// thats when the node name is really known. +// This should propogate to the table_def table_layout + node_name=qs->query_name; + +/* +int ff; +printf("instantiating merge node, name = %s, %d sources.\n\t",node_name.c_str(), fm.size()); +for(ff=0;ffto_string().c_str()); +} +printf("\n"); +*/ + + +// Create the output schema. +// strip temporal properites form all fields except the merge field. + std::vector flva = Schema->get_fields(fm[0]->get_schema_name()); + field_entry_list *fel = new field_entry_list(); + int f; + for(f=0;fget_type().c_str(), flva[f]->get_modifier_list()); + if(flva[f]->get_name() == mvars[0]->get_field()){ + merge_fieldpos = f; +// if(slack != NULL) dt.reset_temporal(); + }else{ + dt.reset_temporal(); + } + + param_list *plist = new param_list(); + std::vector param_strings = dt.get_param_keys(); + int p; + for(p=0;pappend(param_strings[p].c_str(),v.c_str()); + else + plist->append(param_strings[p].c_str()); + } + + + fe=new field_entry( + dt.get_type_str().c_str(), flva[f]->get_name().c_str(),"",plist, flva[f]->get_unpack_fcns()); + fel->append_field(fe); + } + + + + + table_layout = new table_def( + node_name.c_str(), NULL, NULL, fel, STREAM_SCHEMA + ); + + partn_def = NULL; + }; + + +///////////////////////////////////////////// +/// Created for de-siloing. to be removed? or is it otherwise useful? +// Merge existing set of sources (de-siloing) + mrg_qpn(std::string n_name, std::vector &src_names,table_list *Schema){ + int i,f; + + disorder = 1; + +// Construct the fm list + for(f=0;fget_table_ref(src_names[f]); + if(tbl_ref < 0){ + fprintf(stderr,"INTERNAL ERROR, can't find %s in the schema when constructing no-silo merge node %s\n",src_names[f].c_str(), n_name.c_str()); + exit(1); + } + table_def *src_tbl = Schema->get_table(tbl_ref); + tablevar_t *fm_t = new tablevar_t(src_names[f].c_str()); + string range_name = "_t" + int_to_string(f); + fm_t->set_range_var(range_name); + fm_t->set_schema_ref(tbl_ref); + fm.push_back(fm_t); + } + +// Create the output schema. +// strip temporal properites form all fields except the merge field. + std::vector flva = Schema->get_fields(fm[0]->get_schema_name()); + field_entry_list *fel = new field_entry_list(); + bool temporal_found = false; + for(f=0;fget_type().c_str(), flva[f]->get_modifier_list()); + if(dt.is_temporal() && !temporal_found){ + merge_fieldpos = f; + temporal_found = true; + }else{ + dt.reset_temporal(); + } + + param_list *plist = new param_list(); + std::vector param_strings = dt.get_param_keys(); + int p; + for(p=0;pappend(param_strings[p].c_str(),v.c_str()); + else + plist->append(param_strings[p].c_str()); + } + + fe=new field_entry( + dt.get_type_str().c_str(), flva[f]->get_name().c_str(),"",plist, + flva[f]->get_unpack_fcns() + ); + fel->append_field(fe); + } + + if(! temporal_found){ + fprintf(stderr,"ERROR, can't find temporal field of the sources when constructing no-silo merge node %s\n",n_name.c_str()); + exit(1); + } + + node_name=n_name; + table_layout = new table_def( + node_name.c_str(), NULL, NULL, fel, STREAM_SCHEMA + ); + + partn_def = NULL; + param_tbl = new param_table(); + +// Construct mvars + for(f=0;f flv_f = Schema->get_fields(fm[f]->get_schema_name()); + data_type dt_f(flv_f[merge_fieldpos]->get_type().c_str(), + flva[merge_fieldpos]->get_modifier_list()); + + colref_t *mcr = new colref_t(fm[f]->get_var_name().c_str(), + flv_f[merge_fieldpos]->get_name().c_str()); + mvars.push_back(mcr); + } + +// literal_t *s_lit = new literal_t("5",LITERAL_INT); +// slack = new scalarexp_t(s_lit); + slack = NULL; + + }; +// end de-siloing +//////////////////////////////////////// + + void resolve_slack(scalarexp_t *t_se, std::string fname, std::vector > &sources,ifq_t *ifdb, gb_table *gbt); + + +// Merge filter_join LFTAs. + + mrg_qpn(filter_join_qpn *spx, std::string n_name, std::vector &sources, std::vector > &ifaces, ifq_t *ifdb); + +// Merge selection LFTAs. + + mrg_qpn(spx_qpn *spx, std::string n_name, std::vector &sources, std::vector > &ifaces, ifq_t *ifdb){ + + disorder = 1; + + param_tbl = spx->param_tbl; + int i; + node_name = n_name; + field_entry_list *fel = new field_entry_list(); + merge_fieldpos = -1; + + + + + for(i=0;iselect_list.size();++i){ + data_type *dt = spx->select_list[i]->se->get_data_type()->duplicate(); + if(dt->is_temporal()){ + if(merge_fieldpos < 0){ + merge_fieldpos = i; + }else{ + fprintf(stderr,"Warning: Merge subquery %s found two temporal fields (%s, %s), using %s\n", n_name.c_str(), spx->select_list[merge_fieldpos]->name.c_str(), spx->select_list[i]->name.c_str(), spx->select_list[merge_fieldpos]->name.c_str() ); + dt->reset_temporal(); + } + } + + field_entry *fe = dt->make_field_entry(spx->select_list[i]->name); + fel->append_field(fe); + delete dt; + } + if(merge_fieldpos<0){ + fprintf(stderr,"ERROR, no temporal attribute for merge subquery %s\n",n_name.c_str()); + exit(1); + } + table_layout = new table_def( n_name.c_str(), NULL, NULL, fel, STREAM_SCHEMA); + +// NEED TO HANDLE USER_SPECIFIED SLACK + this->resolve_slack(spx->select_list[merge_fieldpos]->se, + spx->select_list[merge_fieldpos]->name, ifaces, ifdb,NULL); +// if(this->slack == NULL) +// fprintf(stderr,"Zero slack.\n"); +// else +// fprintf(stderr,"slack is %s\n",slack->to_string().c_str()); + + for(i=0;iselect_list[merge_fieldpos]->name.c_str())); + mvars[i]->set_tablevar_ref(i); + fm.push_back(new tablevar_t(sources[i].c_str())); + fm[i]->set_range_var(rvar); + } + + param_tbl = new param_table(); + std::vector param_names = spx->param_tbl->get_param_names(); + int pi; + for(pi=0;piparam_tbl->get_data_type(param_names[pi]); + param_tbl->add_param(param_names[pi],dt->duplicate(), + spx->param_tbl->handle_access(param_names[pi])); + } + definitions = spx->definitions; + + } + +// Merge aggregation LFTAs + + mrg_qpn(sgah_qpn *sgah, std::string n_name, std::vector &sources, std::vector > &ifaces, ifq_t *ifdb){ + + disorder = 1; + + param_tbl = sgah->param_tbl; + int i; + node_name = n_name; + field_entry_list *fel = new field_entry_list(); + merge_fieldpos = -1; + for(i=0;iselect_list.size();++i){ + data_type *dt = sgah->select_list[i]->se->get_data_type()->duplicate(); + if(dt->is_temporal()){ + if(merge_fieldpos < 0){ + merge_fieldpos = i; + }else{ + fprintf(stderr,"Warning: Merge subquery %s found two temporal fields (%s, %s), using %s\n", n_name.c_str(), sgah->select_list[merge_fieldpos]->name.c_str(), sgah->select_list[i]->name.c_str(), sgah->select_list[merge_fieldpos]->name.c_str() ); + dt->reset_temporal(); + } + } + + field_entry *fe = dt->make_field_entry(sgah->select_list[i]->name); + fel->append_field(fe); + delete dt; + } + if(merge_fieldpos<0){ + fprintf(stderr,"ERROR, no temporal attribute for merge subquery %s\n",n_name.c_str()); + exit(1); + } + table_layout = new table_def( n_name.c_str(), NULL, NULL, fel, STREAM_SCHEMA); + +// NEED TO HANDLE USER_SPECIFIED SLACK + this->resolve_slack(sgah->select_list[merge_fieldpos]->se, + sgah->select_list[merge_fieldpos]->name, ifaces, ifdb, + &(sgah->gb_tbl)); + if(this->slack == NULL) + fprintf(stderr,"Zero slack.\n"); + else + fprintf(stderr,"slack is %s\n",slack->to_string().c_str()); + + + for(i=0;iselect_list[merge_fieldpos]->name.c_str())); + mvars[i]->set_tablevar_ref(i); + fm.push_back(new tablevar_t(sources[i].c_str())); + fm[i]->set_range_var(rvar); + } + + param_tbl = new param_table(); + std::vector param_names = sgah->param_tbl->get_param_names(); + int pi; + for(pi=0;piparam_tbl->get_data_type(param_names[pi]); + param_tbl->add_param(param_names[pi],dt->duplicate(), + sgah->param_tbl->handle_access(param_names[pi])); + } + definitions = sgah->definitions; + + } + + qp_node *make_copy(std::string suffix){ + mrg_qpn *ret = new mrg_qpn(); + ret->slack = slack; + ret->disorder = disorder; + + ret->param_tbl = new param_table(); + std::vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + ret->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + ret->definitions = definitions; + + ret->node_name = node_name + suffix; + ret->table_layout = table_layout->make_shallow_copy(ret->node_name); + ret->merge_fieldpos = merge_fieldpos; + + return ret; + }; + + std::vector split_sources(); + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + + // get partition definition for merges that combine streams partitioned over multiple interfaces + // return NULL for regular merges + partn_def_t* get_partn_definition(map lfta_names, vector interface_names, vector machine_names, ifq_t *ifaces_db, partn_def_list_t *partn_parse_result) { + if (partn_def) + return partn_def; + + int err; + string err_str; + string partn_name; + + vector input_tables = get_input_tbls(); + for (int i = 0; i < input_tables.size(); ++i) { + tablevar_t * table = input_tables[i]; + + vector partn_names = ifaces_db->get_iface_vals(table->get_machine(), table->get_interface(),"iface_partition",err,err_str); + if (partn_names.size() != 1) // can't have more than one value of partition attribute + return NULL; + string new_partn_name = partn_names[0]; + + // need to make sure that all ifaces belong to the same partition + if (!i) + partn_name = new_partn_name; + else if (new_partn_name != partn_name) + return NULL; + } + + // now find partition definition corresponding to partn_name + partn_def = partn_parse_result->get_partn_def(partn_name); + return partn_def; + }; + + void set_partn_definition(partn_def_t* def) { + partn_def = def; + } + + bool is_multihost_merge() { + + bool is_multihost = false; + + // each input table must be have machine attribute be non-empty + // and there should be at least 2 different values of machine attributes + vector input_tables = get_input_tbls(); + string host = input_tables[0]->get_machine(); + for (int i = 1; i < input_tables.size(); ++i) { + string new_host = input_tables[i]->get_machine(); + if (new_host == "") + return false; + if (new_host != host) + is_multihost = true; + } + return is_multihost; + } + + void create_protocol_se(vector q_sources, table_list *Schema); +}; + + +// eq_temporal, hash join query plan node. +// represent the following query fragment +// select scalar_expression_1, ..., scalar_expression_k +// from T0 t0, T1 t1 +// where predicate +// +// the predicates and the scalar expressions can reference +// attributes of t0 and t1 and also functions. +// The predicate must contain CNF elements to enable the +// efficient evaluation of the query. +// 1) at least one predicate of the form +// (temporal se in t0) = (temporal se in t1) +// 2) at least one predicate of the form +// (non-temporal se in t0) = (non-temporal se in t1) +// +class join_eq_hash_qpn: public qp_node{ +public: + std::vector from; // Source tables + std::vector select_list; // Select list + std::vector prefilter[2]; // source prefilters + std::vector temporal_eq; // define temporal window + std::vector hash_eq; // define hash key + std::vector postfilter; // final filter on hash matches. + + std::vector where; // all the filters + // useful for summary analysis + + std::vector hash_src_r, hash_src_l; + + std::vector get_hash_r(){return hash_src_r;} + std::vector get_hash_l(){return hash_src_l;} + + std::string node_type(){return("join_eq_hash_qpn"); }; + bool makes_transform(){return true;}; + std::vector external_libs(){ + std::vector ret; + return ret; + } + + void bind_to_schema(table_list *Schema); + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema){ + fprintf(stderr,"INTERNAL ERROR, calling join_eq_hash_qpn::get_colrefs\n"); + exit(1); + } + + std::string to_query_string(); + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform); + std::string generate_functor_name(); + std::string generate_operator(int i, std::string params); + std::string get_include_file(){return("#include \n");}; + + std::vector get_select_list(){return select_list;}; + std::vector get_select_se_list(){ + std::vector ret; + int i; + for(i=0;ise); + return ret; + }; +// Used for LFTA only + std::vector get_where_clause(){ + std::vector t; + return(t); + }; + std::vector get_filter_clause(){ + return get_where_clause(); + } + + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns); + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns); + + table_def *get_fields(); + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm); +// Ensure that any refs to interface params have been split away. + int count_ifp_refs(std::set &ifpnames); + + join_eq_hash_qpn(){ + }; + join_eq_hash_qpn(query_summary_class *qs,table_list *Schema){ + int w; +// Get the table name. +// NOTE the colrefs have the table ref (an int) +// embedded in them. Would it make sense +// to grab the whole table list? + from = qs->fta_tree->get_from()->get_table_list(); + if(from.size() != 2){ + char tmpstr[200]; + sprintf(tmpstr,"ERROR building join_eq_hash node: query defined over %lu tables, but joins must be between two sources.\n",from.size() ); + err_str = tmpstr; + error_code = 1; + } + +// Get the select list. + select_list = qs->fta_tree->get_sl_vec(); + +// Get the selection predicate. + where = qs->wh_cnf; + for(w=0;w pred_tbls; + get_tablevar_ref_pr(where[w]->pr,pred_tbls); +// Prefilter if refs only one tablevar + if(pred_tbls.size()==1){ + prefilter[pred_tbls[0]].push_back(where[w]); + continue; + } +// refs nothing -- might be sampling, do it as postfilter. + if(pred_tbls.size()==0){ + postfilter.push_back(where[w]); + continue; + } +// See if it can be a hash or temporal predicate. +// NOTE: synchronize with the temporality checking +// done at join_eq_hash_qpn::get_fields + if(where[w]->is_atom && where[w]->eq_pred){ + std::vector sel_tbls, ser_tbls; + get_tablevar_ref_se(where[w]->pr->get_left_se(),sel_tbls); + get_tablevar_ref_se(where[w]->pr->get_right_se(),ser_tbls); + if(sel_tbls.size()==1 && ser_tbls.size()==1 && sel_tbls[0] != ser_tbls[0]){ +// make channel 0 SE on LHS. + if(sel_tbls[0] != 0) + where[w]->pr->swap_scalar_operands(); + + data_type *dtl=where[w]->pr->get_left_se()->get_data_type(); + data_type *dtr=where[w]->pr->get_right_se()->get_data_type(); + if( (dtl->is_increasing() && dtr->is_increasing()) || + (dtl->is_decreasing() && dtr->is_decreasing()) ) + temporal_eq.push_back(where[w]); + else + hash_eq.push_back(where[w]); + continue; + + } + } +// All tests failed, fallback is postfilter. + postfilter.push_back(where[w]); + } + + if(temporal_eq.size()==0){ + err_str = "ERROR in join query: can't find temporal equality predicate to define a join window.\n"; + error_code = 1; + } + +// Get the parameters + param_tbl = qs->param_tbl; + + }; + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + + qp_node* make_copy(std::string suffix){ + join_eq_hash_qpn *ret = new join_eq_hash_qpn(); + + ret->param_tbl = new param_table(); + std::vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + ret->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + ret->definitions = definitions; + + ret->node_name = node_name + suffix; + + // make shallow copy of all fields + ret->where = where; + ret->from = from; + ret->select_list = select_list; + ret->prefilter[0] = prefilter[0]; + ret->prefilter[1] = prefilter[1]; + ret->postfilter = postfilter; + ret->temporal_eq = temporal_eq; + ret->hash_eq = hash_eq; + + return ret; + }; + void create_protocol_se(vector q_sources, table_list *Schema); + +}; + + +// --------------------------------------------- +// eq_temporal, hash join query plan node. +// represent the following query fragment +// select scalar_expression_1, ..., scalar_expression_k +// FILTER_JOIN(col, range) from T0 t0, T1 t1 +// where predicate +// +// t0 is the output range variable, t1 is the filtering range +// variable. Both must alias a PROTOCOL. +// The scalar expressions in the select clause may +// reference t0 only. +// The predicates are classified as follows +// prefilter predicates: +// a cheap predicate in t0 such that there is an equivalent +// predicate in t1. Cost decisions about pushing to +// lfta prefilter made later. +// t0 predicates (other than prefilter predicates) +// -- cheap vs. expensive sorted out at genereate time, +// the constructor isn't called with the function list. +// t1 predicates (other than prefiler predicates). +// equi-join predicates of the form: +// (se in t0) = (se in t1) +// +// There must be at least one equi-join predicate. +// No join predicates other than equi-join predicates +// are allowed. +// Warn on temporal equi-join predicates. +// t1 predicates should not be expensive ... warn? +// +class filter_join_qpn: public qp_node{ +public: + std::vector from; // Source tables + colref_t *temporal_var; // join window in FROM + unsigned int temporal_range; // metadata. + std::vector select_list; // Select list + std::vector shared_pred; // prefilter preds + std::vector pred_t0; // main (R) preds + std::vector pred_t1; // filtering (S) preds + std::vector hash_eq; // define hash key + std::vector postfilter; // ref's no table. + + std::vector where; // all the filters + // useful for summary analysis + + std::vector hash_src_r, hash_src_l; + std::vector get_hash_r(){return hash_src_r;} + std::vector get_hash_l(){return hash_src_l;} + + + bool use_bloom; // true => bloom filter, false => limited hash + + std::string node_type(){return("filter_join"); }; + bool makes_transform(){return true;}; + std::vector external_libs(){ + std::vector ret; + return ret; + } + + void bind_to_schema(table_list *Schema); + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema); + + std::string to_query_string(); + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform){ + fprintf(stderr,"INTERNAL ERROR, filter_join_qpn::generate_functor called\n"); + exit(1); + } + std::string generate_functor_name(){ + fprintf(stderr,"INTERNAL ERROR, filter_join_qpn::generate_functor_name called\n"); + exit(1); + } + std::string generate_operator(int i, std::string params){ + fprintf(stderr,"INTERNAL ERROR, filter_join_qpn::generate_operator called\n"); + exit(1); + } + std::string get_include_file(){return("#include \n");}; + + std::vector get_select_list(){return select_list;}; + std::vector get_select_se_list(){ + std::vector ret; + int i; + for(i=0;ise); + return ret; + }; +// Used for LFTA only + std::vector get_where_clause(){return where;} + std::vector get_filter_clause(){return shared_pred;} + + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns); + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns); + + table_def *get_fields(); + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + int resolve_if_params(ifq_t *ifdb, std::string &err); + + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm); +// Ensure that any refs to interface params have been split away. + int count_ifp_refs(std::set &ifpnames); + + + filter_join_qpn(){ + }; + filter_join_qpn(query_summary_class *qs,table_list *Schema){ + int i,w; +// Get the table name. +// NOTE the colrefs have the table ref (an int) +// embedded in them. Would it make sense +// to grab the whole table list? + from = qs->fta_tree->get_from()->get_table_list(); + temporal_var = qs->fta_tree->get_from()->get_colref(); + temporal_range = qs->fta_tree->get_from()->get_temporal_range(); + if(from.size() != 2){ + char tmpstr[200]; + sprintf(tmpstr,"ERROR building filter_join_qpn node: query defined over %lu tables, but joins must be between two sources.\n",from.size() ); + err_str += tmpstr; + error_code = 1; + } + +// Get the select list. + select_list = qs->fta_tree->get_sl_vec(); +// Verify that only t0 is referenced. + bool bad_ref = false; + for(i=0;i sel_tbls; + get_tablevar_ref_se(select_list[i]->se,sel_tbls); + if((sel_tbls.size() == 2) || (sel_tbls.size()==1 && sel_tbls[0]==1)) + bad_ref = true; + } + if(bad_ref){ + err_str += "ERROR building filter_join_qpn node: query references range variable "+from[1]->variable_name+", but only the first range variable ("+from[0]->variable_name+" can be referenced.\n"; + error_code = 1; + } + + +// Get the selection predicate. + where = qs->wh_cnf; + std::vector t0_only, t1_only; + for(w=0;w pred_tbls; + get_tablevar_ref_pr(where[w]->pr,pred_tbls); +// Collect the list of preds by src var, +// extract the shared preds later. + if(pred_tbls.size()==1){ + if(pred_tbls[0] == 0){ + t0_only.push_back(where[w]); + }else{ + t1_only.push_back(where[w]); + } + continue; + } +// refs nothing -- might be sampling, do it as postfilter. + if(pred_tbls.size()==0){ + postfilter.push_back(where[w]); + continue; + } +// See if it can be a hash or temporal predicate. +// NOTE: synchronize with the temporality checking +// done at join_eq_hash_qpn::get_fields + if(where[w]->is_atom && where[w]->eq_pred){ + std::vector sel_tbls, ser_tbls; + get_tablevar_ref_se(where[w]->pr->get_left_se(),sel_tbls); + get_tablevar_ref_se(where[w]->pr->get_right_se(),ser_tbls); + if(sel_tbls.size()==1 && ser_tbls.size()==1 && sel_tbls[0] != ser_tbls[0]){ +// make channel 0 SE on LHS. + if(sel_tbls[0] != 0) + where[w]->pr->swap_scalar_operands(); + + hash_eq.push_back(where[w]); + + data_type *dtl=where[w]->pr->get_left_se()->get_data_type(); + data_type *dtr=where[w]->pr->get_right_se()->get_data_type(); + if( (dtl->is_increasing() && dtr->is_increasing()) || + (dtl->is_decreasing() && dtr->is_decreasing()) ) + err_str += "Warning, a filter join should not have join predicates on temporal fields.\n"; + continue; + + } + } +// All tests failed, fallback is postfilter. + err_str += "ERROR, join predicates in a filter join should have the form (scalar expression in "+from[0]->variable_name+") = (scalar expression in "+from[1]->variable_name+").\n"; + error_code = 3; + } +// Classify the t0_only and t1_only preds. + set matched_pred; + int v; + for(w=0;wpr,t1_only[v]->pr,Schema)) + break; + if(vparam_tbl; + definitions = qs->definitions; + +// Determine the algorithm + if(this->get_val_of_def("algorithm") == "hash"){ + use_bloom = false; + }else{ + use_bloom = true; + } + }; + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + + qp_node* make_copy(std::string suffix){ + filter_join_qpn *ret = new filter_join_qpn(); + + ret->param_tbl = new param_table(); + std::vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + ret->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + ret->definitions = definitions; + + ret->node_name = node_name + suffix; + + // make shallow copy of all fields + ret->where = where; + ret->from = from; + ret->temporal_range = temporal_range; + ret->temporal_var = temporal_var; + ret->select_list = select_list; + ret->shared_pred = shared_pred; + ret->pred_t0 = pred_t0; + ret->pred_t1 = pred_t1; + ret->postfilter = postfilter; + ret->hash_eq = hash_eq; + + return ret; + }; + void create_protocol_se(vector q_sources, table_list *Schema); + +}; + + +enum output_file_type_enum {regular, gzip, bzip}; + +class output_file_qpn: public qp_node{ +public: + std::string source_op_name; // Source table + std::vector fields; + ospec_str *output_spec; + vector fm; + std::string hfta_query_name; + std::string filestream_id; + bool eat_input; + std::vector params; + bool do_gzip; + output_file_type_enum compression_type; + + int n_streams; // Number of output streams + int n_hfta_clones; // number of hfta clones + int parallel_idx; // which close this produces output for. + std::vector hash_flds; // fields used to hash the output. + + std::string node_type(){return("output_file_qpn"); }; + bool makes_transform(){return false;}; + std::vector external_libs(){ + std::vector ret; + switch(compression_type){ + case gzip: + ret.push_back("-lz"); + break; + case bzip: + ret.push_back("-lbz2"); + break; + default: + break; + } + return ret; + } + + void bind_to_schema(table_list *Schema){} + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema){ + col_id_set ret; + return ret; + } + + std::string to_query_string(){return "// output_file_operator \n";} + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform); + std::string generate_functor_name(); + std::string generate_operator(int i, std::string params); + std::string get_include_file(){ + switch(compression_type){ + case gzip: + return("#include \n"); + default: + return("#include \n"); + } + return("#include \n"); + }; + + std::vector get_where_clause(){std::vector ret; return ret;}; + std::vector get_filter_clause(){std::vector ret; return ret;}; + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){cplx_lit_table *ret = new cplx_lit_table(); return ret;} + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns){std::vector ret; return ret;} + + table_def *get_fields(){ + field_entry_list *fel = new field_entry_list(); + int i; + for(i=0;iappend_field(fields[i]); + return new table_def(node_name.c_str(), NULL, NULL, fel, STREAM_SCHEMA); + } + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + std::vector ret; ret.push_back(this); hfta_returned = true; return ret; + } + std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm){ + std::vector ret; return ret; + } +// Ensure that any refs to interface params have been split away. + int count_ifp_refs(std::set &ifpnames){return 0;} + int resolve_if_params(ifq_t *ifdb, std::string &err){return 0;}; + + + output_file_qpn(std::string src_op, std::string qn, std::string fs_id, table_def *src_tbl_def, ospec_str *ospec, bool ei){ + source_op_name = src_op; + node_name = source_op_name + "_output"; + filestream_id = fs_id; + fields = src_tbl_def->get_fields(); + output_spec = ospec; + fm.push_back(new tablevar_t(source_op_name.c_str())); + hfta_query_name = qn; + eat_input = ei; + + do_gzip = false; + compression_type = regular; + if(ospec->operator_type == "zfile") + compression_type = gzip; + + n_streams = 1; + parallel_idx = 0; + n_hfta_clones = 1; + + char buf[1000]; + strncpy(buf, output_spec->operator_param.c_str(),1000); + buf[999] = '\0'; + char *words[100]; + int nwords = split_string(buf, ':', words,100); + int i; + for(i=0;iget_name() == target){ + hash_flds.push_back(j); + break; + } + } + if(j==fields.size()){ + err_flds += " "+target; + } + } + if(err_flds != ""){ + err_report += "ERROR in "+hfta_query_name+", a file output operator needs to split the output but these splitting fileds are not part of the output:"+err_flds; + return true; + } + } + return false; + } + + // the following method is used for distributed query optimization + double get_rate_estimate(){return 1.0;} + + + qp_node* make_copy(std::string suffix){ +// output_file_qpn *ret = new output_file_qpn(); + output_file_qpn *ret = new output_file_qpn(source_op_name, hfta_query_name, filestream_id, this->get_fields(), output_spec, eat_input); + return ret; + } + + void create_protocol_se(vector q_sources, table_list *Schema){} + +}; + + + +// + +// --------------------------------------------- + + +// Select, group-by, aggregate, sampling. +// Representing +// Select SE_1, ..., SE_k +// From T +// Where predicate +// Group By gb1, ..., gb_n +// [Subgroup gb_i1, .., gb_ik] +// Cleaning_when predicate +// Cleaning_by predicate +// Having predicate +// +// For now, must have group-by variables and aggregates. +// The scalar expressions which are output must be a function +// of the groub-by variables and the aggregates. +// The group-by variables can be references to columsn of T, +// or they can be scalar expressions. +class sgahcwcb_qpn: public qp_node{ +public: + tablevar_t *table_name; // source table + std::vector where; // selection predicate + std::vector having; // post-aggregation predicate + std::vector select_list; // se's of output + gb_table gb_tbl; // Table of all group-by attributes. + std::set sg_tbl; // Names of the superGB attributes + aggregate_table aggr_tbl; // Table of all referenced aggregates. + std::set states_refd; // states ref'd by stateful fcns. + std::vector cleanby; + std::vector cleanwhen; + + std::vector gb_sources; // pre-compute for partitioning. + + std::vector get_gb_sources(){return gb_sources;} + + std::string node_type(){return("sgahcwcb_qpn"); }; + bool makes_transform(){return true;}; + std::vector external_libs(){ + std::vector ret; + return ret; + } + + void bind_to_schema(table_list *Schema); + col_id_set get_colrefs(bool ext_fcns_only,table_list *Schema){ + fprintf(stderr,"INTERNAL ERROR, calling sgahcwcb_qpn::get_colrefs\n"); + exit(1); + } + + std::string to_query_string(); + std::string generate_functor(table_list *schema, ext_fcn_list *Ext_fcns, std::vector &needs_xform); + std::string generate_functor_name(); + + std::string generate_operator(int i, std::string params); + std::string get_include_file(){return("#include \n");}; + + std::vector get_select_list(){return select_list;}; + std::vector get_select_se_list(){ + std::vector ret; + int i; + for(i=0;ise); + return ret; + }; + std::vector get_where_clause(){return where;}; + std::vector get_filter_clause(){return where;}; + std::vector get_having_clause(){return having;}; + gb_table *get_gb_tbl(){return &gb_tbl;}; + aggregate_table *get_aggr_tbl(){return &aggr_tbl;}; + cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns); + std::vector get_handle_param_tbl(ext_fcn_list *Ext_fcns); + +// table which represents output tuple. + table_def *get_fields(); + std::vector get_input_tbls(); + std::vector get_output_tbls(); + + + sgahcwcb_qpn(){ + }; + sgahcwcb_qpn(query_summary_class *qs,table_list *Schema){ +// Get the table name. +// NOTE the colrefs have the tablevar ref (an int) +// embedded in them. Would it make sense +// to grab the whole table list? + tablevar_list_t *fm = qs->fta_tree->get_from(); + std::vector tbl_vec = fm->get_table_list(); + if(tbl_vec.size() != 1){ + char tmpstr[200]; + sprintf(tmpstr,"INTERNAL ERROR building SGAHCWCB node: query defined over %lu tables.\n",tbl_vec.size() ); + err_str=tmpstr; + error_code = 1; + } + table_name = (tbl_vec[0]); + +// Get the select list. + select_list = qs->fta_tree->get_sl_vec(); + +// Get the selection and having predicates. + where = qs->wh_cnf; + having = qs->hav_cnf; + cleanby = qs->cb_cnf; + cleanwhen = qs->cw_cnf; + +// Build a new GB var table (don't share, might need to modify) + int g; + for(g=0;ggb_tbl->size();g++){ + gb_tbl.add_gb_var(qs->gb_tbl->get_name(g), + qs->gb_tbl->get_tblvar_ref(g), qs->gb_tbl->get_def(g), + qs->gb_tbl->get_reftype(g) + ); + } + +// Build a new aggregate table. (don't share, might need +// to modify). + int a; + for(a=0;aaggr_tbl->size();a++){ + aggr_tbl.add_aggr( +// qs->aggr_tbl->get_op(a), qs->aggr_tbl->get_aggr_se(a) + qs->aggr_tbl->duplicate(a) + ); + } + + sg_tbl = qs->sg_tbl; + states_refd = qs->states_refd; + + +// Get the parameters + param_tbl = qs->param_tbl; + + }; + + + + std::vector split_node_for_fta(ext_fcn_list *Ext_fcns, table_list *Schema, int &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + virtual std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm); +// Ensure that any refs to interface params have been split away. +// CURRENTLY not allowed by split_node_for_fta + int count_ifp_refs(std::set &ifpnames){return 0;} + int resolve_if_params(ifq_t *ifdb, std::string &err){return 0;} + + // the following method is used for distributed query optimization + double get_rate_estimate(); + + qp_node* make_copy(std::string suffix){ + sgahcwcb_qpn *ret = new sgahcwcb_qpn(); + + ret->param_tbl = new param_table(); + std::vector param_names = param_tbl->get_param_names(); + int pi; + for(pi=0;piget_data_type(param_names[pi]); + ret->param_tbl->add_param(param_names[pi],dt->duplicate(), + param_tbl->handle_access(param_names[pi])); + } + ret->definitions = definitions; + + ret->node_name = node_name + suffix; + + // make shallow copy of all fields + ret->where = where; + ret->having = having; + ret->select_list = select_list; + ret->gb_tbl = gb_tbl; + ret->aggr_tbl = aggr_tbl; + ret->sg_tbl = sg_tbl; + ret->states_refd = states_refd; + ret->cleanby = cleanby; + ret->cleanwhen = cleanwhen; + + return ret; + }; + + void create_protocol_se(vector q_sources, table_list *Schema); +}; + + +std::vector create_query_nodes(query_summary_class *qs,table_list *Schema); + + + +void untaboo(string &s); + +table_def *create_attributes(string tname, vector &select_list); + + + +#endif diff --git a/src/ftacmp/res.l b/src/ftacmp/res.l new file mode 100644 index 0000000..a9036c2 --- /dev/null +++ b/src/ftacmp/res.l @@ -0,0 +1,223 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +/* + MUST COMPILE WITH + flex -PResParser -oreslexer.cc res.l + (or equivalent). +*/ + +%{ +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_fta.h" + #include + + + +#include "res.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int ResParserwrap(){return(1);} + +extern int ResParserdebug; + + +/* + These variables are used for error reporting: + flex_res_lineno : the line currently being parsed when the error occurs. + flex_res_ch : the character on the line where the error occurs + flex_res_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_res_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_res_lineno = 1; +int flex_res_ch = 0; +char flex_res_linebuf[20000]; + +char *flex_res_stringinput = NULL; +int flex_res_stringinput_ptr = 0; +FILE *flex_res_fileinput = NULL; +int my_ResParser_yyinput(char *buf, int max_size); + + + +void ResParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_res_lineno, flex_res_ch, s, ResParsertext, flex_res_linebuf ); + for(i=0;i=/] { flex_res_ch+=ResParserleng; return yytext[0]; } + + /* names */ + +[A-Za-z_][A-Za-z0-9_]* { flex_res_ch+=ResParserleng; ResParserlval.strval = strdup(yytext); return NAME; } + + + /* strings */ + +'[^'\n]*' { + + int c; + + ResParserlval.strval = strdup(ResParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_res_ch+=ResParserleng; + ResParserlval.strval[ResParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + +'[^'\n]*$ { flex_res_ch+=ResParserleng; ResParsererror("Unterminated string"); } + + /* */ + /* Newline : advance the error reporting line number */ + /* and grab the next line into flex_res_linebuf */ + /* */ + +\n.* {flex_res_ch=0; flex_res_lineno++; + strcpy(flex_res_linebuf,ResParsertext+1); + yyless(1); + } + +[ \t\r]+ {flex_res_ch+=ResParserleng; } /* white space */ + +"--".*$ {flex_res_ch+=ResParserleng; }; /* comment */ +"//".*$ {flex_res_ch+=ResParserleng; }; /* comment */ +" + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "iface_q.h" + + +extern resparse_data *rpd_ptr; +extern std::vector res_attr_vec; +extern std::vector res_val_vec; +extern std::string res_a, res_v; + + + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#ifndef YYSTYPE +#line 39 "res.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} yystype; +/* Line 193 of /usr/local/share/bison/yacc.c. */ +#line 128 "res.tab.cc" +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +#ifndef YYLTYPE +typedef struct yyltype +{ + int first_line; + int first_column; + int last_line; + int last_column; +} yyltype; +# define YYLTYPE yyltype +# define YYLTYPE_IS_TRIVIAL 1 +#endif + +/* Copy the second part of user declarations. */ + + +/* Line 213 of /usr/local/share/bison/yacc.c. */ +#line 149 "res.tab.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 6 +#define YYLAST 25 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 9 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 9 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 14 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 26 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 259 + +#define YYTRANSLATE(X) \ + ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 6, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 5, 8, 7, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 5, 9, 12, 18, 23, 28, 30, + 33, 35, 36, 38, 41 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 10, 0, -1, 11, -1, 12, 14, 13, -1, 12, + 13, -1, 5, 3, 15, 6, 7, -1, 5, 3, + 15, 7, -1, 5, 6, 3, 7, -1, 11, -1, + 14, 11, -1, 16, -1, -1, 17, -1, 16, 17, + -1, 3, 8, 4, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned char yyrline[] = +{ + 0, 57, 57, 60, 62, 63, 69, 73, 78, 80, + 83, 85, 88, 91, 95 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "'<'", "'/'", + "'>'", "'='", "$accept", "parse_result", "resource", "start_tag", + "end_tag", "res_list", "opt_val_list", "val_list", "val", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short yytoknum[] = +{ + 0, 256, 257, 258, 259, 60, 47, 62, 61 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 9, 10, 11, 11, 11, 12, 13, 14, 14, + 15, 15, 16, 16, 17 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 1, 3, 2, 5, 4, 4, 1, 2, + 1, 0, 1, 2, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 0, 0, 2, 0, 11, 1, 0, 8, 4, + 0, 0, 0, 10, 12, 0, 9, 3, 0, 0, + 6, 13, 0, 14, 5, 7 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = +{ + -1, 2, 3, 4, 9, 10, 12, 13, 14 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -5 +static const yysigned_char yypact[] = +{ + -3, 0, 5, -5, 4, 7, -5, -2, -5, -5, + 4, 3, 1, 7, -5, 9, -5, -5, 10, 6, + -5, -5, 8, -5, -5, -5 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = +{ + -5, -5, -4, -5, 11, -5, -5, -5, 12 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, parse error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = +{ + 8, 5, 1, 5, 15, 6, 16, 19, 20, 7, + 11, 18, 22, 24, 23, 25, 0, 0, 0, 0, + 0, 17, 0, 0, 0, 21 +}; + +static const yysigned_char yycheck[] = +{ + 4, 3, 5, 3, 6, 0, 10, 6, 7, 5, + 3, 8, 3, 7, 4, 7, -1, -1, -1, -1, + -1, 10, -1, -1, -1, 13 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 5, 10, 11, 12, 3, 0, 5, 11, 13, + 14, 3, 15, 16, 17, 6, 11, 13, 8, 6, + 7, 17, 3, 4, 7, 7 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.first_line = Rhs[1].first_line; \ + Current.first_column = Rhs[1].first_column; \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#define YYLEX yylex () + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +# define YYDSYMPRINT(Args) \ +do { \ + if (yydebug) \ + yysymprint Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YYDSYMPRINT(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*-----------------------------. +| Print this symbol on YYOUT. | +`-----------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue) +#else +yysymprint (yyout, yytype, yyvalue) + FILE* yyout; + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyout, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyout, yytoknum[yytype], yyvalue); +# endif + } + else + YYFPRINTF (yyout, "nterm %s (", yytname[yytype]); + + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyout, ")"); +} +#endif /* YYDEBUG. */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +#if defined (__STDC__) || defined (__cplusplus) +yydestruct (int yytype, YYSTYPE yyvalue) +#else +yydestruct (yytype, yyvalue) + int yytype; + YYSTYPE yyvalue; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvalue; + + switch (yytype) + { + default: + break; + } +} + + + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +# ifdef YYPARSE_PARAM +int yyparse (void *); +# else +int yyparse (void); +# endif +#endif + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of parse errors so far. */ +int yynerrs; + + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + goto yyoverflowlab; + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with. */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more. */ + + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yychar1 = YYTRANSLATE (yychar); + + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ + YYDPRINTF ((stderr, "Next token is ")); + YYDSYMPRINT ((stderr, yychar1, yylval)); + YYDPRINTF ((stderr, "\n")); + } + + /* If the proper action on seeing token YYCHAR1 is to reduce or to + detect an error, take that action. */ + yyn += yychar1; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + int yyi; + + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn - 1, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + switch (yyn) + { + case 5: +#line 64 "res.y" + {startElement(rpd_ptr, yyvsp[-3].strval, res_attr_vec, res_val_vec); + endElement(rpd_ptr, yyvsp[-3].strval); + } + break; + + case 6: +#line 70 "res.y" + {startElement(rpd_ptr, yyvsp[-2].strval, res_attr_vec, res_val_vec);} + break; + + case 7: +#line 74 "res.y" + {endElement(rpd_ptr, yyvsp[-1].strval);} + break; + + case 11: +#line 85 "res.y" + {res_attr_vec.clear(); res_val_vec.clear();} + break; + + case 12: +#line 89 "res.y" + {res_attr_vec.clear(); res_attr_vec.push_back(res_a); + res_val_vec.clear(); res_val_vec.push_back(res_v); } + break; + + case 13: +#line 91 "res.y" + {res_attr_vec.push_back(res_a); + res_val_vec.push_back(res_v); } + break; + + case 14: +#line 96 "res.y" + {res_a = yyvsp[-2].strval; res_v = yyvsp[0].strval;} + break; + + + } + +/* Line 1016 of /usr/local/share/bison/yacc.c. */ +#line 1007 "res.tab.cc" + + yyvsp -= yylen; + yyssp -= yylen; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[yytype]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("parse error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("parse error"); + } + goto yyerrlab1; + + +/*----------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action. | +`----------------------------------------------------*/ +yyerrlab1: + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + /* Return failure if at end of input. */ + if (yychar == YYEOF) + { + /* Pop the error token. */ + YYPOPSTACK; + /* Pop the rest of the stack. */ + while (yyssp > yyss) + { + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], + *yyvsp)); + YYDPRINTF ((stderr, "\n")); + yydestruct (yystos[*yyssp], *yyvsp); + YYPOPSTACK; + } + YYABORT; + } + + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); + yydestruct (yychar1, yylval); + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + YYDPRINTF ((stderr, "Error: popping ")); + YYDSYMPRINT ((stderr, + yystos[*yyssp], *yyvsp)); + YYDPRINTF ((stderr, "\n")); + + yydestruct (yystos[yystate], *yyvsp); + yyvsp--; + yystate = *--yyssp; + + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + } + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; + + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 103 "res.y" + + + diff --git a/src/ftacmp/res.tab.cc.h b/src/ftacmp/res.tab.cc.h new file mode 100644 index 0000000..2bc5371 --- /dev/null +++ b/src/ftacmp/res.tab.cc.h @@ -0,0 +1,65 @@ +/* A Bison parser, made from res.y, by GNU bison 1.75. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +#ifndef BISON_RES_TAB_CC_H +# define BISON_RES_TAB_CC_H + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259 + }; +#endif +#define NAME 258 +#define STRING_TOKEN 259 + + + + +#ifndef YYSTYPE +#line 39 "res.y" +typedef union { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} yystype; +/* Line 1281 of /usr/local/share/bison/yacc.c. */ +#line 58 "res.tab.cc.h" +# define YYSTYPE yystype +#endif + +extern YYSTYPE ResParserlval; + + +#endif /* not BISON_RES_TAB_CC_H */ + diff --git a/src/ftacmp/res.y b/src/ftacmp/res.y new file mode 100644 index 0000000..eca5341 --- /dev/null +++ b/src/ftacmp/res.y @@ -0,0 +1,119 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + bison --verbose --defines=res.tab.cc.h -p ResParser -o res.tab.cc res.y + + (or equivalent). +*/ + +%{ + + +#include + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "iface_q.h" + + +extern resparse_data *rpd_ptr; +extern std::vector res_attr_vec; +extern std::vector res_val_vec; +extern std::string res_a, res_v; + + + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} + +%token NAME +%token STRING_TOKEN + + + + +%% + +parse_result: resource + ; + +resource: + start_tag res_list end_tag + | start_tag end_tag + | '<' NAME opt_val_list '/' '>' + {startElement(rpd_ptr, $2, res_attr_vec, res_val_vec); + endElement(rpd_ptr, $2); + } + ; + +start_tag: + '<' NAME opt_val_list '>' {startElement(rpd_ptr, $2, res_attr_vec, res_val_vec);} + ; + +end_tag: + '<' '/' NAME '>' {endElement(rpd_ptr, $3);} + ; + + +res_list: + resource + | res_list resource + ; + +opt_val_list: + val_list + | {res_attr_vec.clear(); res_val_vec.clear();} + ; + +val_list: + val {res_attr_vec.clear(); res_attr_vec.push_back(res_a); + res_val_vec.clear(); res_val_vec.push_back(res_v); } + | val_list val {res_attr_vec.push_back(res_a); + res_val_vec.push_back(res_v); } + ; + +val: + NAME '=' STRING_TOKEN {res_a = $1; res_v = $3;} + ; + + + + + +%% + diff --git a/src/ftacmp/reslexer.cc b/src/ftacmp/reslexer.cc new file mode 100644 index 0000000..890c8eb --- /dev/null +++ b/src/ftacmp/reslexer.cc @@ -0,0 +1,1778 @@ +#define yy_create_buffer ResParser_create_buffer +#define yy_delete_buffer ResParser_delete_buffer +#define yy_scan_buffer ResParser_scan_buffer +#define yy_scan_string ResParser_scan_string +#define yy_scan_bytes ResParser_scan_bytes +#define yy_flex_debug ResParser_flex_debug +#define yy_init_buffer ResParser_init_buffer +#define yy_flush_buffer ResParser_flush_buffer +#define yy_load_buffer_state ResParser_load_buffer_state +#define yy_switch_to_buffer ResParser_switch_to_buffer +#define yyin ResParserin +#define yyleng ResParserleng +#define yylex ResParserlex +#define yyout ResParserout +#define yyrestart ResParserrestart +#define yytext ResParsertext + +#line 19 "reslexer.cc" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/ftacmp/reslexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yytext_ptr -= yy_more_len; \ + yyleng = (int) (yy_cp - yytext_ptr); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 11 +#define YY_END_OF_BUFFER 12 +static yyconst short int yy_accept[32] = + { 0, + 0, 0, 12, 10, 6, 5, 10, 10, 1, 1, + 1, 2, 6, 5, 0, 4, 3, 0, 0, 0, + 2, 0, 7, 0, 8, 0, 0, 0, 0, 9, + 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 4, 1, + 1, 1, 1, 1, 5, 1, 6, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 1, 1, 8, + 9, 9, 10, 1, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 1, 1, 1, 1, 11, 1, 11, 11, 11, 11, + + 11, 11, 11, 11, 11, 11, 11, 12, 13, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 14, + 11, 11, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[15] = + { 0, + 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, + 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[38] = + { 0, + 0, 0, 48, 49, 45, 0, 12, 41, 39, 34, + 49, 0, 41, 0, 14, 49, 49, 39, 38, 26, + 0, 36, 49, 35, 49, 24, 24, 32, 31, 49, + 49, 18, 21, 17, 24, 27, 30 + } ; + +static yyconst short int yy_def[38] = + { 0, + 31, 1, 31, 31, 31, 32, 33, 31, 31, 31, + 31, 34, 31, 32, 33, 31, 31, 35, 36, 31, + 34, 35, 31, 36, 31, 31, 31, 37, 37, 31, + 0, 31, 31, 31, 31, 31, 31 + } ; + +static yyconst short int yy_nxt[64] = + { 0, + 4, 5, 6, 7, 8, 9, 4, 10, 11, 4, + 12, 12, 12, 12, 16, 17, 16, 17, 14, 21, + 14, 15, 15, 15, 22, 22, 22, 24, 24, 24, + 29, 29, 29, 30, 30, 28, 27, 25, 23, 26, + 25, 23, 13, 20, 19, 18, 13, 31, 3, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31 + } ; + +static yyconst short int yy_chk[64] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 7, 7, 15, 15, 32, 34, + 32, 33, 33, 33, 35, 35, 35, 36, 36, 36, + 37, 37, 37, 29, 28, 27, 26, 24, 22, 20, + 19, 18, 13, 10, 9, 8, 5, 3, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() (yy_more_flag = 1) +#define YY_MORE_ADJ yy_more_len +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "res.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PResParser -oreslexer.cc res.l + (or equivalent). +*/ +#line 9 "res.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_fta.h" + #include + + + +#include "res.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int ResParserwrap(){return(1);} + +extern int ResParserdebug; + + +/* + These variables are used for error reporting: + flex_res_lineno : the line currently being parsed when the error occurs. + flex_res_ch : the character on the line where the error occurs + flex_res_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_res_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_res_lineno = 1; +int flex_res_ch = 0; +char flex_res_linebuf[20000]; + +char *flex_res_stringinput = NULL; +int flex_res_stringinput_ptr = 0; +FILE *flex_res_fileinput = NULL; +int my_ResParser_yyinput(char *buf, int max_size); + + + +void ResParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_res_lineno, flex_res_ch, s, ResParsertext, flex_res_linebuf ); + for(i=0;i +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 88 "res.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + + + + +#line 663 "reslexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + if ( yy_more_flag ) + { + yy_more_len = yy_c_buf_p - yytext_ptr; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 49 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 109 "res.l" +{ flex_res_ch+=ResParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 2: +YY_RULE_SETUP +#line 113 "res.l" +{ flex_res_ch+=ResParserleng; ResParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* strings */ +case 3: +YY_RULE_SETUP +#line 118 "res.l" +{ + + int c; + + ResParserlval.strval = strdup(ResParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_res_ch+=ResParserleng; + ResParserlval.strval[ResParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + YY_BREAK +case 4: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 135 "res.l" +{ flex_res_ch+=ResParserleng; ResParsererror("Unterminated string"); } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_res_linebuf */ +/* */ +case 5: +YY_RULE_SETUP +#line 142 "res.l" +{flex_res_ch=0; flex_res_lineno++; + strcpy(flex_res_linebuf,ResParsertext+1); + yyless(1); + } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 147 "res.l" +{flex_res_ch+=ResParserleng; } /* white space */ + YY_BREAK +case 7: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 149 "res.l" +{flex_res_ch+=ResParserleng; }; /* comment */ + YY_BREAK +case 8: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 150 "res.l" +{flex_res_ch+=ResParserleng; }; /* comment */ + YY_BREAK +case 9: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 151 "res.l" +{flex_res_ch+=ResParserleng; }; /* comment */ + YY_BREAK +case 10: +YY_RULE_SETUP +#line 153 "res.l" +{flex_res_ch+=ResParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); ResParsererror(yytext);} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 155 "res.l" +ECHO; + YY_BREAK +#line 843 "reslexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 31); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 155 "res.l" + + +int my_ResParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_res_stringinput != NULL){ + while(c + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include + +/* prototypes for the parser callbacks. +*/ + +#include "parse_schema.h" + +/* Interface to schemalexer */ + int yyparse(); + void yyerror(char *s); + int yylex(); +extern int flex_schema_lineno, flex_schema_ch; + +/* Return value */ +extern table_list *Schema; + +#define YYDEBUG 1 + + +#line 40 "schema.y" +typedef union { + char* strval; + field_entry *field_t; + field_entry_list *field_list_t; + table_def *table_def_t; + table_list *table_list_t; + param_list *plist_t; + } YYSTYPE; +#include + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 31 +#define YYFLAG -32768 +#define YYNTBASE 12 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 263 ? yytranslate[x] : 19) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, + 10, 2, 2, 11, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, + 6, 7, 8 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 4, 7, 14, 21, 23, 26, 32, 33, + 37, 39 +}; + +static const short yyrhs[] = { 13, + 0, 14, 0, 13, 14, 0, 7, 3, 17, 5, + 15, 6, 0, 8, 3, 17, 5, 15, 6, 0, + 16, 0, 15, 16, 0, 3, 3, 3, 17, 4, + 0, 0, 9, 18, 10, 0, 3, 0, 18, 11, + 3, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 68, 70, 71, 74, 76, 80, 81, 84, 88, 90, + 93, 95 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","NAME","SEMICOLON", +"LEFTBRACE","RIGHTBRACE","TABLE","STREAM","'('","')'","','","result","table_list", +"table_def","field_list","field","opt_param_commalist","param_commalist", NULL +}; +#endif + +static const short yyr1[] = { 0, + 12, 13, 13, 14, 14, 15, 15, 16, 17, 17, + 18, 18 +}; + +static const short yyr2[] = { 0, + 1, 1, 2, 6, 6, 1, 2, 5, 0, 3, + 1, 3 +}; + +static const short yydefact[] = { 0, + 0, 0, 1, 2, 9, 9, 3, 0, 0, 0, + 11, 0, 0, 0, 10, 0, 0, 0, 6, 0, + 12, 0, 4, 7, 5, 9, 0, 8, 0, 0, + 0 +}; + +static const short yydefgoto[] = { 29, + 3, 4, 18, 19, 9, 12 +}; + +static const short yypact[] = { 2, + 0, 4, 2,-32768, 5, 5,-32768, 10, 11, 12, +-32768, 1, 15, 15,-32768, 16, 18, -2,-32768, -1, +-32768, 19,-32768,-32768,-32768, 5, 20,-32768, 23, 25, +-32768 +}; + +static const short yypgoto[] = {-32768, +-32768, 24, 14, -12, -6,-32768 +}; + + +#define YYLAST 28 + + +static const short yytable[] = { 10, + 17, 17, 5, 23, 25, 24, 6, 24, 1, 2, + 15, 16, 11, 8, 0, 13, 14, 17, 21, 27, + 22, 26, 30, 28, 31, 0, 7, 20 +}; + +static const short yycheck[] = { 6, + 3, 3, 3, 6, 6, 18, 3, 20, 7, 8, + 10, 11, 3, 9, -1, 5, 5, 3, 3, 26, + 3, 3, 0, 4, 0, -1, 3, 14 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "bison.simple" + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +#ifndef alloca +#ifdef __GNUC__ +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) +#include +#else /* not sparc */ +#if defined (MSDOS) && !defined (__TURBOC__) +#include +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +#include + #pragma alloca +#else /* not MSDOS, __TURBOC__, or _AIX */ +#ifdef __hpux +#ifdef __cplusplus +extern "C" { +void *alloca (unsigned int); +}; +#else /* not __cplusplus */ +void *alloca (); +#endif /* not __cplusplus */ +#endif /* __hpux */ +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc. */ +#endif /* not GNU C. */ +#endif /* alloca not defined. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT return(0) +#define YYABORT return(1) +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +int yyparse (void); +#endif + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, int count) +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 196 "bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + yyss = (short *) alloca (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp)); + yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 1: +#line 68 "schema.y" +{Schema = yyvsp[0].table_list_t;; + break;} +case 2: +#line 70 "schema.y" +{yyval.table_list_t = new table_list(yyvsp[0].table_def_t);; + break;} +case 3: +#line 71 "schema.y" +{yyval.table_list_t = yyvsp[-1].table_list_t->append_table(yyvsp[0].table_def_t);; + break;} +case 4: +#line 74 "schema.y" +{ + yyval.table_def_t=new table_def(yyvsp[-4].strval,yyvsp[-3].plist_t,yyvsp[-1].field_list_t, TABLE_SCHEMA); delete yyvsp[-1].field_list_t;; + break;} +case 5: +#line 76 "schema.y" +{ + yyval.table_def_t=new table_def(yyvsp[-4].strval,yyvsp[-3].plist_t,yyvsp[-1].field_list_t, STREAM_SCHEMA); delete yyvsp[-1].field_list_t;; + break;} +case 6: +#line 80 "schema.y" +{yyval.field_list_t = new field_entry_list(yyvsp[0].field_t);; + break;} +case 7: +#line 81 "schema.y" +{yyval.field_list_t = yyvsp[-1].field_list_t->append_field(yyvsp[0].field_t);; + break;} +case 8: +#line 85 "schema.y" +{yyval.field_t = new field_entry(yyvsp[-4].strval,yyvsp[-3].strval,yyvsp[-2].strval,yyvsp[-1].plist_t);; + break;} +case 9: +#line 89 "schema.y" +{yyval.plist_t = NULL;; + break;} +case 10: +#line 90 "schema.y" +{yyval.plist_t = yyvsp[-1].plist_t;; + break;} +case 11: +#line 94 "schema.y" +{yyval.plist_t = new param_list(yyvsp[0].strval);; + break;} +case 12: +#line 95 "schema.y" +{yyval.plist_t = yyvsp[-2].plist_t->append(yyvsp[0].strval);; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 498 "bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; +} +#line 98 "schema.y" + + diff --git a/src/ftacmp/schema.tab.cc.h b/src/ftacmp/schema.tab.cc.h new file mode 100644 index 0000000..55157f0 --- /dev/null +++ b/src/ftacmp/schema.tab.cc.h @@ -0,0 +1,17 @@ +typedef union { + char* strval; + field_entry *field_t; + field_entry_list *field_list_t; + table_def *table_def_t; + table_list *table_list_t; + param_list *plist_t; + } YYSTYPE; +#define NAME 258 +#define SEMICOLON 259 +#define LEFTBRACE 260 +#define RIGHTBRACE 261 +#define TABLE 262 +#define STREAM 263 + + +extern YYSTYPE SchemaParserlval; diff --git a/src/ftacmp/schemalexer.cc b/src/ftacmp/schemalexer.cc new file mode 100644 index 0000000..2f08b3b --- /dev/null +++ b/src/ftacmp/schemalexer.cc @@ -0,0 +1,1694 @@ +#define yy_create_buffer SchemaParser_create_buffer +#define yy_delete_buffer SchemaParser_delete_buffer +#define yy_scan_buffer SchemaParser_scan_buffer +#define yy_scan_string SchemaParser_scan_string +#define yy_scan_bytes SchemaParser_scan_bytes +#define yy_flex_debug SchemaParser_flex_debug +#define yy_init_buffer SchemaParser_init_buffer +#define yy_flush_buffer SchemaParser_flush_buffer +#define yy_load_buffer_state SchemaParser_load_buffer_state +#define yy_switch_to_buffer SchemaParser_switch_to_buffer +#define yyin SchemaParserin +#define yyleng SchemaParserleng +#define yylex SchemaParserlex +#define yyout SchemaParserout +#define yyrestart SchemaParserrestart +#define yytext SchemaParsertext +#define yywrap SchemaParserwrap + +#line 20 "schemalexer.cc" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/ftacmp/schemalexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 12 +#define YY_END_OF_BUFFER 13 +static yyconst short int yy_accept[31] = + { 0, + 0, 0, 13, 11, 9, 8, 6, 11, 3, 7, + 7, 7, 4, 5, 9, 8, 0, 7, 7, 7, + 0, 10, 7, 7, 7, 7, 7, 1, 2, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 4, + 4, 1, 1, 4, 5, 1, 1, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 1, 7, 1, + 1, 1, 1, 1, 8, 9, 10, 10, 11, 10, + 10, 10, 10, 10, 10, 12, 13, 10, 10, 10, + 10, 14, 15, 16, 10, 10, 10, 10, 10, 10, + 1, 1, 1, 1, 6, 1, 10, 10, 10, 10, + + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 17, 1, 18, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[19] = + { 0, + 1, 1, 2, 1, 1, 3, 1, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 1, 1 + } ; + +static yyconst short int yy_base[34] = + { 0, + 0, 0, 39, 40, 36, 0, 40, 32, 40, 0, + 20, 27, 40, 40, 32, 0, 30, 0, 18, 22, + 27, 40, 18, 16, 19, 15, 12, 0, 0, 40, + 18, 17, 21 + } ; + +static yyconst short int yy_def[34] = + { 0, + 30, 1, 30, 30, 30, 31, 30, 30, 30, 32, + 32, 32, 30, 30, 30, 31, 33, 32, 32, 32, + 33, 30, 32, 32, 32, 32, 32, 32, 32, 0, + 30, 30, 30 + } ; + +static yyconst short int yy_nxt[59] = + { 0, + 4, 5, 6, 7, 8, 4, 9, 10, 10, 10, + 10, 10, 10, 10, 11, 12, 13, 14, 16, 18, + 16, 21, 21, 21, 29, 28, 27, 26, 25, 22, + 24, 23, 22, 15, 20, 19, 17, 15, 30, 3, + 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, + 30, 30, 30, 30, 30, 30, 30, 30 + } ; + +static yyconst short int yy_chk[59] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 31, 32, + 31, 33, 33, 33, 27, 26, 25, 24, 23, 21, + 20, 19, 17, 15, 12, 11, 8, 5, 3, 30, + 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, + 30, 30, 30, 30, 30, 30, 30, 30 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "schema.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PSchemaParser -oschemalexer.cc schema.l + (or equivalent). +*/ +#line 9 "schema.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + #include "parse_schema.h" + #include + + + +#include "schema.tab.cc.h" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include +#include + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int SchemaParserwrap(){return(1);} + +extern int SchemaParserdebug; + + +/* + These variables are used for error reporting: + flex_lineno : the line currently being parsed when the error occurs. + flexch : the character on the line where the error occurs + flex_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_schema_lineno = 1; +int flex_schema_ch = 0; +char flex_schema_linebuf[1000]; + +//void SchemaParsererror(char *s); + +void SchemaParsererror(char *s){ + printf("On line %d, char %d: %s (token %s):\n%s\n", + flex_schema_lineno, flex_schema_ch, s, SchemaParsertext, flex_schema_linebuf ); + printf("%*s\n",1+flex_schema_ch,"^"); +} + + +/* MKS needs the next line to increase the NFA table */ +#line 466 "schemalexer.cc" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 71 "schema.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + +#line 634 "schemalexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 31 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 40 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 87 "schema.l" +{ flex_schema_ch+=SchemaParserleng; return TABLE; } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 88 "schema.l" +{ flex_schema_ch+=SchemaParserleng; return STREAM; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 90 "schema.l" +{flex_schema_ch+=SchemaParserleng; return SEMICOLON;} + YY_BREAK +case 4: +YY_RULE_SETUP +#line 91 "schema.l" +{flex_schema_ch+=SchemaParserleng; return LEFTBRACE;} + YY_BREAK +case 5: +YY_RULE_SETUP +#line 92 "schema.l" +{flex_schema_ch+=SchemaParserleng; return RIGHTBRACE;} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 94 "schema.l" +{ flex_schema_ch+=SchemaParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 7: +YY_RULE_SETUP +#line 99 "schema.l" +{ flex_schema_ch+=SchemaParserleng; SchemaParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_linebuf */ +/* */ +case 8: +YY_RULE_SETUP +#line 107 "schema.l" +{flex_schema_ch=0; flex_schema_lineno++; + strcpy(flex_schema_linebuf,SchemaParsertext+1); + yyless(1); + } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 112 "schema.l" +{flex_schema_ch+=SchemaParserleng; } /* white space */ + YY_BREAK +case 10: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 114 "schema.l" +{flex_schema_ch+=SchemaParserleng; }; /* comment */ + YY_BREAK +/* Parse error on anything else. */ +case 11: +YY_RULE_SETUP +#line 117 "schema.l" +{fprintf(stderr,"Warning: unknown token (ignored)\n"); SchemaParsererror(yytext);} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 120 "schema.l" +ECHO; + YY_BREAK +#line 789 "schemalexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 31 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 31 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 30); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + static int _xpg = -1; + + if (_xpg == -1) + { + char *_xpgenv = getenv("_XPG"); + if (_xpgenv == NULL) + _xpg = 0; + else + { + _xpg = atoi(_xpgenv); + if (_xpg < 0) + _xpg = 0; + } + } + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + if (_xpg) + return 0; + else + { + if ( yywrap() ) + return 0; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 120 "schema.l" + + + diff --git a/src/ftacmp/schemaparser.cc b/src/ftacmp/schemaparser.cc new file mode 100644 index 0000000..246aae3 --- /dev/null +++ b/src/ftacmp/schemaparser.cc @@ -0,0 +1,1189 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include"schemaparser_impl.h" +#include"schemaparser.h" +#include +#include "parse_fta.h" +#include "parse_schema.h" +#include"generate_utils.h" + +#include"host_tuple.h" +#include"lapp.h" + +#include +#include +#include + + +// Interface to FTA definition lexer and parser ... + +extern int FtaParserparse(void); +extern FILE *FtaParserin; +extern int FtaParserdebug; + +// This will need to be moved to a parse_fta.cc file. +fta_parse_t *fta_parse_result; +var_defs_t *fta_parse_defines; + + + +using namespace std; +extern int errno; + +static gs_int8_t tmpstr[20000]; // for returning const char* values. + +vector schema_list; // The schemas parsed thus far. + +///////////////////////////////////////////////////////////// +/// Version functions + +static gs_int32_t curr_version = 4; +static gs_int32_t accepted_versions[] = { 4, 3, 2, 1, 0 }; // must end with zero. + +gs_int32_t get_schemaparser_version(){ return curr_version; } + +gs_int32_t *get_schemaparser_accepted_versions(){return accepted_versions;} + +gs_int32_t schemaparser_accepts_version(gs_int32_t v){ + int i; + for(i=0;accepted_versions[i]>0;++i){ + if(accepted_versions[i] == v) return 1; + } + return 0; +} + + +///////////////////////////////////////////////////////////////////// +//////////// Utility Functions + +/* +int fta_field_size(int dt, int *is_udef){ + switch(dt){ + case INT_TYPE: + return(sizeof(int)); + case UINT_TYPE: + case USHORT_TYPE: + case BOOL_TYPE: + return(sizeof(unsigned int)); + case ULLONG_TYPE: + return(sizeof(unsigned long long int)); + case LLONG_TYPE: + return(sizeof(long long int)); + case FLOAT_TYPE: + return(sizeof(double)); + case TIMEVAL_TYPE: + return(sizeof(timeval)); + case VSTR_TYPE: + return(sizeof(vstring)); + default: + *is_udef = 1; + return(0); + } + return(0); +}; +*/ + + +///////////////////////////////////////////////////////////// +/// Interface fcns + + +//////////// Schema management + +static gs_schemahandle_t ftaschema_parse(int prot_ok); + +gs_schemahandle_t ftaschema_parse_string(gs_csp_t f){ + // prot_ok is by default false in schemaparser.h + + fta_parse_result = new fta_parse_t(); + gs_sp_t schema = strdup(f); + +// FtaParserin = f; + FtaParser_setstringinput(schema); + + if(FtaParserparse()){ + fprintf(stderr,"FTA parse failed.\n"); + free (schema); + return(-1); + } + free (schema); + + return ftaschema_parse(false); +} +gs_schemahandle_t ftaschema_parse_string_prot(gs_csp_t f){ + // prot_ok is by default false in schemaparser.h + + fta_parse_result = new fta_parse_t(); + gs_sp_t schema = strdup(f); + +// FtaParserin = f; + FtaParser_setstringinput(schema); + + if(FtaParserparse()){ + fprintf(stderr,"FTA parse failed.\n"); + free (schema); + return(-1); + } + free (schema); + + return ftaschema_parse(true); +} + +gs_schemahandle_t ftaschema_parse_file(FILE *f){ + // prot_ok is by default false in schemaparser.h + + fta_parse_result = new fta_parse_t(); + +// FtaParserin = f; + FtaParser_setfileinput(f); + + if(FtaParserparse()){ + fprintf(stderr,"FTA parse failed.\n"); + return(-1); + } + + return ftaschema_parse(false); +} +gs_schemahandle_t ftaschema_parse_file_prot(FILE *f){ + // prot_ok is by default false in schemaparser.h + + fta_parse_result = new fta_parse_t(); + +// FtaParserin = f; + FtaParser_setfileinput(f); + + if(FtaParserparse()){ + fprintf(stderr,"FTA parse failed.\n"); + return(-1); + } + + return ftaschema_parse(true); +} + + + + + +static gs_schemahandle_t ftaschema_parse(int prot_ok){ + + if(fta_parse_result->parse_type != STREAM_PARSE){ + if(!(fta_parse_result->parse_type == TABLE_PARSE && prot_ok!=0)){ + fprintf(stderr,"ERROR, input is not a stream file.\n"); + return(-1); + } + } + + +// Get the tuple information. + if(fta_parse_result->tables->size() != 1){ + fprintf(stderr,"ERROR parsing schema file: %d tables, expecting 1.\n", + fta_parse_result->tables->size() ); + return(-1); + } + + string table_name = fta_parse_result->tables->get_table_name(0); + vector tuple_flds = fta_parse_result->tables->get_fields(table_name); + int n_tuples = tuple_flds.size(); + +// get the parameter info. + int n_params = 0; + string query_name = table_name; + vector query_params; + if(fta_parse_result->fta_parse_tree){ + query_params = fta_parse_result->fta_parse_tree->query_params; + n_params = query_params.size(); + +// Get the query name + if(fta_parse_result->fta_parse_tree->nmap.count("query_name") == 0){ + fprintf(stderr,"WARNING: query name is empty. using default_query.\n"); + query_name = "default_query"; + }else{ + query_name = fta_parse_result->fta_parse_tree->nmap["query_name"]; + } + + if(query_name != table_name){ + fprintf(stderr,"WARNING table name (%s) is different than query name (%s).\n", + table_name.c_str(), query_name.c_str() ); + } + + } + +// Construct the query representation. + + query_rep *qrep = new query_rep(query_name, n_tuples, n_params); + +// Pack the tuple information. + int fi; + for(fi=0;fiset_field_info(fi,tuple_flds[fi])) == UNDEFINED_TYPE){ + fprintf(stderr,"ERROR tuple field %s (number %d) has undefined type %s.\n", + tuple_flds[fi]->get_name().c_str(), fi, tuple_flds[fi]->get_type().c_str()); + } + } + if(qrep->finalize_field_info()){ + fprintf(stderr,"ERROR undefined type in tuple.\n"); + return(-1); + } + +// Pack the param info + int pi; + for(pi=0;piset_param_info(pi, query_params[pi])) == UNDEFINED_TYPE){ + fprintf(stderr,"ERROR parameter %s (number %d) has undefined type %s.\n", + query_params[pi]->name.c_str(), pi, query_params[pi]->val.c_str()); + } + } + if(qrep->finalize_param_info()){ + fprintf(stderr,"ERROR undefined type in parameter block.\n"); + return(-1); + } + +// finish up + + schema_list.push_back(qrep); + + return(schema_list.size()-1); +} + + +/* Release memory used by the schema representation. + return non-zero on error. +*/ +// Currently, do nothing. I'll need to +// systematically plug memory leaks and write destructors +// to make implementing this function worth while. +gs_int32_t ftaschema_free(gs_schemahandle_t sh){ + return(0); +} + + +/* name of fta schema null terminated */ +/* Returns NULL if sh is out of bounds. */ +/* NO ALLOCATION IS PERFORMED! Must treat result as const. */ +gs_sp_t ftaschema_name(gs_schemahandle_t sh){ + if(sh < 0 || sh >= schema_list.size()){ + return(NULL); + } + strcpy(tmpstr,schema_list[sh]->name.c_str()); + return(tmpstr); +} + + +///////////// Tuple management + + +/* number of entries in a tuple */ +/* Return -1 if the schema handle is out of range. */ +gs_int32_t ftaschema_tuple_len(gs_schemahandle_t sh){ + if(sh < 0 || sh >= schema_list.size()){ + return(-1); + } + return(schema_list[sh]->field_info.size()); +} + +/* field entry name */ +/* Returns NULL if sh or index is out of bounds. */ +/* NO ALLOCATION IS PERFORMED! Must treat result as const. */ +gs_sp_t ftaschema_field_name(gs_schemahandle_t sh, gs_uint32_t index){ + if(sh < 0 || sh >= schema_list.size()){ + return(NULL); + } + if(index >= schema_list[sh]->field_info.size()){ + return(NULL); + } + strcpy(tmpstr,schema_list[sh]->field_info[index].field_name.c_str()); + return( tmpstr); +} + +/* Direct tuple access functions. +*/ +gs_uint32_t fta_unpack_uint(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_uint32_t retval; + if(offset+sizeof(gs_uint32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); +// return(htonl(retval)); + return(retval); +} +gs_uint32_t fta_unpack_uint_nocheck(void *data, gs_uint32_t offset){ + gs_uint32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} + +gs_uint32_t fta_unpack_ushort(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_uint32_t retval; + if(offset+sizeof(gs_uint32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); +// return(htonl(retval)); + return(retval); +} +gs_uint32_t fta_unpack_ushort_nocheck(void *data, gs_uint32_t offset){ + gs_uint32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} + +gs_uint32_t fta_unpack_bool(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_uint32_t retval; + if(offset+sizeof(gs_uint32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); +// return(htonl(retval)); + return(retval); +} +gs_uint32_t fta_unpack_bool_nocheck(void *data, gs_uint32_t offset){ + gs_uint32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); +// return(htonl(retval)); + return(retval); +} + +gs_int32_t fta_unpack_int(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_int32_t retval; + if(offset+sizeof(gs_int32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t)); +// return(htonl(retval)); + return(retval); +} +gs_int32_t fta_unpack_int_nocheck(void *data, gs_uint32_t offset){ + gs_int32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t)); + return(retval); +} + +gs_uint64_t fta_unpack_ullong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_uint64_t retval; + if(offset+sizeof(gs_uint64_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t)); +// return(htonll(retval)); + return(retval); +} +gs_uint64_t fta_unpack_ullong_nocheck(void *data, gs_uint32_t offset){ + gs_uint64_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t)); + return(retval); +} + +gs_int64_t fta_unpack_llong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_int64_t retval; + if(offset+sizeof( gs_int64_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t)); +// return(htonl(retval)); + return(retval); +} +gs_int64_t fta_unpack_llong_nocheck(void *data, gs_uint32_t offset){ + gs_int64_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t)); + return(retval); +} + +gs_float_t fta_unpack_float(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_float_t retval; + if(offset+sizeof( gs_float_t) > len){ + *problem = 1; + return(0.0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t)); +// return(ntohf(retval)); + return(retval); +} +gs_float_t fta_unpack_float_nocheck(void *data, gs_uint32_t offset){ + gs_float_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t)); + return(retval); +} + +timeval fta_unpack_timeval(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + timeval retval; + if(offset+sizeof( timeval) > len){ + *problem = 1; + return(retval); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval)); +// retval.tv_sec = htonl(retval.tv_sec); +// retval.tv_usec = htonl(retval.tv_usec); + retval.tv_sec = retval.tv_sec; + retval.tv_usec = retval.tv_usec; + return(retval); +} +timeval fta_unpack_timeval_nocheck(void *data, gs_uint32_t offset){ + timeval retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval)); + retval.tv_sec = retval.tv_sec; + retval.tv_usec = retval.tv_usec; + return(retval); +} + +vstring fta_unpack_vstr(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + vstring retval; + vstring32 unpack_s; + + if(offset+sizeof( vstring32) > len){ + *problem = 1; + return(retval); + } + + memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32)); + +// retval.length = htonl(unpack_s.length); +// unpack_s.offset = htonl(unpack_s.offset); + retval.length = unpack_s.length; + unpack_s.offset = unpack_s.offset; + retval.reserved = SHALLOW_COPY; + + if(unpack_s.offset + retval.length > len){ + *problem = 1; + return(retval); + } + retval.offset = (gs_p_t)data + unpack_s.offset; + return(retval); +} + +gs_sp_t fta_unpack_fstring(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + return( (gs_sp_t)(data)+offset); +} + +struct hfta_ipv6_str fta_unpack_ipv6(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + struct hfta_ipv6_str retval; + if(offset+sizeof(hfta_ipv6_str) > len){ + *problem = 1; + return(retval); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str)); +// htonl(retval.v[0]); +// htonl(retval.v[1]); +// htonl(retval.v[2]); +// htonl(retval.v[3]); + return(retval); +} +struct hfta_ipv6_str fta_unpack_ipv6_nocheck(void *data, gs_uint32_t offset){ + struct hfta_ipv6_str retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str)); + return(retval); +} + + +/* + Direct tuple access functions, but no ntoh xform. +*/ +gs_uint32_t fta_unpack_uint_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_uint32_t retval; + if(offset+sizeof(gs_uint32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} +gs_uint32_t fta_unpack_uint_noxf_nocheck(void *data, gs_uint32_t offset){ + gs_uint32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} + +gs_uint32_t fta_unpack_ushort_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_uint32_t retval; + if(offset+sizeof(gs_uint32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} +gs_uint32_t fta_unpack_ushort_noxf_nocheck(void *data, gs_uint32_t offset){ + gs_uint32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} + +gs_uint32_t fta_unpack_bool_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_uint32_t retval; + if(offset+sizeof(gs_uint32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} +gs_uint32_t fta_unpack_bool_noxf_nocheck(void *data, gs_uint32_t offset){ + gs_uint32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t)); + return(retval); +} + +gs_int32_t fta_unpack_int_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_int32_t retval; + if(offset+sizeof(gs_int32_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t)); + return(retval); +} +gs_int32_t fta_unpack_int_noxf_nocheck(void *data, gs_uint32_t offset){ + gs_int32_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t)); + return(retval); +} + +gs_uint64_t fta_unpack_ullong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_int64_t retval; + if(offset+sizeof( gs_uint64_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t)); + return(retval); +} +gs_uint64_t fta_unpack_ullong_noxf_nocheck(void *data, gs_uint32_t offset){ + gs_uint64_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t)); + return(retval); +} + +gs_int64_t fta_unpack_llong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_int64_t retval; + if(offset+sizeof( gs_int64_t) > len){ + *problem = 1; + return(0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t)); + return(retval); +} +gs_int64_t fta_unpack_llong_noxf_nocheck(void *data, gs_uint32_t offset){ + gs_int64_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t)); + return(retval); +} + +gs_float_t fta_unpack_float_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + gs_float_t retval; + if(offset+sizeof( gs_float_t) > len){ + *problem = 1; + return(0.0); + } + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t)); + return(retval); +} +gs_float_t fta_unpack_float_noxf_nocheck(void *data, gs_uint32_t offset){ + gs_float_t retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t)); + return(retval); +} + +timeval fta_unpack_timeval_noxf_nocheck(void *data, gs_uint32_t offset){ + timeval retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval)); + return(retval); +} + +vstring fta_unpack_vstr_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + vstring retval; + vstring32 unpack_s; + + if(offset+sizeof( vstring32) > len){ + *problem = 1; + return(retval); + } + + memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32)); + + retval.length = unpack_s.length; + retval.reserved = SHALLOW_COPY; + + if(unpack_s.offset + unpack_s.length > len){ + *problem = 1; + return(retval); + } + retval.offset = (gs_p_t)data + unpack_s.offset; + return(retval); +} + +gs_sp_t fta_unpack_fstring_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){ + return( (gs_sp_t)(data)+offset); +} + +struct hfta_ipv6_str fta_unpack_ipv6_noxf_nocheck(void *data, gs_uint32_t offset){ + struct hfta_ipv6_str retval; + memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str)); + return(retval); +} + + +/* returns fields offset by name */ +/* if sh is out of bounds, or if fieldname is not the name of a field, + or len is too small, + return value is -1 +*/ +gs_int32_t ftaschema_get_field_offset_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){ + if(sh < 0 || sh >= schema_list.size()){ + return(-1); + } + + int f; + for(f=0;ffield_info.size();++f){ + if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0) + return(schema_list[sh]->field_info[f].offset); + } + +// Nothing found + return(-1); + +} +/* field offset by index, return -1 if sh or idx is out-of-bounds */ +gs_int32_t ftaschema_get_field_offset_by_index(gs_schemahandle_t sh, gs_int32_t idx){ + if(sh < 0 || sh >= schema_list.size()){ + return(-1); + } + if(idx < 0 || idx >= schema_list[sh]->field_info.size()){ + return(-1); + } + + return(schema_list[sh]->field_info[idx].offset); + +} + + +/* returns fields type by name */ +/* if sh is out of bounds, or if fieldname is not the name of a field, + or len is too small, + return value is UNDEFINED_TYPE +*/ +gs_int32_t ftaschema_get_field_type_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){ + if(sh < 0 || sh >= schema_list.size()){ + return(UNDEFINED_TYPE); + } + + int f; + for(f=0;ffield_info.size();++f){ + if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0) + return(schema_list[sh]->field_info[f].pdt->type_indicator()); + } + +// Nothing found + return( UNDEFINED_TYPE); +} +/* field type by index, rteturn value is UNDEFINED_TYPE if sh or idx + * is out of bounds +*/ +gs_int32_t ftaschema_get_field_type_by_index(gs_schemahandle_t sh, gs_int32_t idx){ + if(sh < 0 || sh >= schema_list.size()){ + return(UNDEFINED_TYPE); + } + if(idx < 0 || idx >= schema_list[sh]->field_info.size()){ + return(UNDEFINED_TYPE); + } + + return(schema_list[sh]->field_info[idx].pdt->type_indicator()); +} + + +/* returns tuple value based on name */ +/* if sh is out of bounds, or if fieldname is not the name of a field, + or len is too small, + return value is of type UNDEFINED_TYPE +*/ +access_result ftaschema_get_field_by_name(gs_schemahandle_t sh, gs_csp_t fieldname, + void * data, gs_uint32_t len){ + access_result retval; + retval.field_data_type = UNDEFINED_TYPE; + + if(sh < 0 || sh >= schema_list.size()){ + return(retval); + } + + int f; + for(f=0;ffield_info.size();++f){ + if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0) + return(ftaschema_get_field_by_index(sh,f,data,len)); + } + +// Nothing found + return(retval); + +} + +/* return tuple value by index */ +/* if sh is out of bounds, or if fieldname is not the name of a field, + or len is too small, + return value is of type UNDEFINED_TYPE +*/ +access_result ftaschema_get_field_by_index(gs_schemahandle_t sh, gs_uint32_t index, + void * data, gs_uint32_t len){ + access_result retval; + retval.field_data_type = UNDEFINED_TYPE; + gs_int32_t problem = 0; + + if(sh < 0 || sh >= schema_list.size()){ + return(retval); + } + if(index >= schema_list[sh]->field_info.size()){ + return(retval); + } + + switch(schema_list[sh]->field_info[index].pdt->get_type()){ + case u_int_t: + retval.r.ui = fta_unpack_uint(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = UINT_TYPE; + break; + case ip_t: + retval.r.ui = fta_unpack_uint(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = IP_TYPE; + break; + case int_t: + retval.r.i = fta_unpack_int(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = INT_TYPE; + break; + case u_llong_t: + retval.r.ul = fta_unpack_ullong(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = ULLONG_TYPE; + break; + case llong_t: + retval.r.l = fta_unpack_llong(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = LLONG_TYPE; + break; + case u_short_t: + retval.r.ui = fta_unpack_ushort(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = USHORT_TYPE; + break; + case floating_t: + retval.r.f = fta_unpack_float(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = FLOAT_TYPE; + break; + case bool_t: + retval.r.ui = fta_unpack_bool(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = BOOL_TYPE; + break; + case v_str_t: + retval.r.vs = fta_unpack_vstr(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = VSTR_TYPE; + break; + case fstring_t: + retval.r.fs.data = fta_unpack_fstring(data, len, + schema_list[sh]->field_info[index].offset, &problem); + retval.r.fs.size = schema_list[sh]->field_info[index].pdt->type_size(); + if(!problem) retval.field_data_type = FSTRING_TYPE; + case timeval_t: + retval.r.t = fta_unpack_timeval(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = TIMEVAL_TYPE; + break; + case ipv6_t: + retval.r.ip6 = fta_unpack_ipv6(data, len, + schema_list[sh]->field_info[index].offset, &problem); + if(!problem) retval.field_data_type = IPV6_TYPE; + break; + case undefined_t: + break; + } + return(retval); +} + + +// Get location of eof, temporal-tuple metadata. +gs_int32_t ftaschema_get_tuple_metadata_offset(gs_schemahandle_t sh){ + if(sh < 0 || sh >= schema_list.size()) + return 0; // probably need to return a error instead of just telling its not eof tuple + + return ( schema_list[sh]->min_tuple_size); +} + + +/* checks whether tuple is temporal + return value 1 indicates that tuple istemporal, 0 - not temporal +*/ +gs_int32_t ftaschema_is_temporal_tuple(gs_schemahandle_t sh, void *data) { + + if(sh < 0 || sh >= schema_list.size()) + return 0; // probably need to return a error instead of just telling its not temporal + + return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == TEMPORAL_TUPLE); +} +//inline gs_int32_t ftaschema_is_temporal_tuple_offset(int metadata_offset, void *data) { +// return (*((gs_sp_t)data + metadata_offset) == TEMPORAL_TUPLE); +//} + + + +/* checks whether tuple is special end-of_file tuple + return value 1 indicates that tuple is eof_tuple, 0 - otherwise +*/ +gs_int32_t ftaschema_is_eof_tuple(gs_schemahandle_t sh, void *data) { + if(sh < 0 || sh >= schema_list.size()) + return 0; // probably need to return a error instead of just telling its not eof tuple + + return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == EOF_TUPLE); + +} +inline gs_int32_t ftaschema_is_eof_tuple_offset(int metadata_offset, void *data) { + return (*((gs_sp_t)data + metadata_offset) == EOF_TUPLE); +} + + +/* extracts the trace from the temporal tuple + return value 0 indicates success, non-zero - error +*/ +gs_int32_t ftaschema_get_trace(gs_schemahandle_t sh, void* data, gs_int32_t len, + gs_uint64_t* trace_id, gs_uint32_t* sz, fta_stat** trace ) { + + if(sh < 0 || sh >= schema_list.size() || *((gs_sp_t)data + schema_list[sh]->min_tuple_size) != TEMPORAL_TUPLE) + return 1; + + memcpy(trace_id, (gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t), sizeof(gs_uint64_t)); + *trace = (fta_stat*)((gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t) + sizeof(gs_uint64_t)); + *sz = (len - schema_list[sh]->min_tuple_size - sizeof(gs_int8_t)- sizeof(gs_uint64_t)) / sizeof(fta_stat); + + return 0; +} + + +//////////// Param block management + +/* number of parameters */ +/* Return -1 if sh is out of bounds */ +gs_int32_t ftaschema_parameter_len(gs_schemahandle_t sh){ + if(sh < 0 || sh >= schema_list.size()){ + return(-1); + } + return(schema_list[sh]->param_info.size()); +} + +/* parameter entry name */ +/* Return NULL if sh or index is out of bounds. */ +/* NO COPYING IS PERFORMED */ +gs_sp_t ftaschema_parameter_name(gs_schemahandle_t sh, gs_uint32_t index){ + if(sh < 0 || sh >= schema_list.size()){ + return(NULL); + } + if(index >= schema_list[sh]->param_info.size()){ + return(NULL); + } + strcpy(tmpstr,schema_list[sh]->param_info[index].param_name.c_str()); + return(tmpstr); +} + +/* set parameter value for parameter handle */ +/* Pass in the parameter in its char string representation. */ +/* Return value is -1 on error, else 0 */ +gs_int32_t ftaschema_setparam_by_name(gs_schemahandle_t sh, gs_sp_t param_name, + gs_sp_t param_val, gs_int32_t len){ + if(sh < 0 || sh >= schema_list.size()){ + return(-1); + } + + int f; + for(f=0;fparam_info.size();++f){ + if(strcmp(param_name, schema_list[sh]->param_info[f].param_name.c_str()) == 0) + return(ftaschema_setparam_by_index(sh,f,param_val,len)); + } + +// not found + return(-1); +} + +/* set parameter value for parameter handle */ +/* Pass in the parameter in its char string representation. */ +/* Return value is -1 on error, else 0 */ +gs_int32_t ftaschema_setparam_by_index(gs_schemahandle_t sh, gs_int32_t index, + gs_sp_t param_val, gs_int32_t len){ + + void *tmp_ptr; + unsigned int ui,d1,d2,d3,d4; + int i; + unsigned long long int ulli; + long long int lli; + double f; + + + if(sh < 0 || sh >= schema_list.size()){ + return(-1); + } + if(index >= schema_list[sh]->param_info.size()){ + return(-1); + } + + param_block_info *pb = &(schema_list[sh]->param_info[index]); + switch(pb->pdt->get_type()){ + case int_t: + if(sscanf(param_val,"%d",&i) == 1){ + pb->value.r.i=i; + pb->value_set = true; + return(0); + }else + return(-1); + break; + case u_int_t: + case u_short_t: + case bool_t: + if(sscanf(param_val,"%u",&ui) == 1){ + pb->value.r.ui=ui; + pb->value_set = true; + return(0); + }else + return(-1); + break; + case ip_t: + if(sscanf(param_val,"%d.%d.%d.%d",&d1,&d2,&d3,&d4) == 4){ + pb->value.r.ui = (d1 << 24)+(d2 << 16)+(d3 << 8)+d4; + pb->value_set = true; + return(0); + }else + return(-1); + case u_llong_t: + if(sscanf(param_val,"%llu",&ulli) == 1){ + pb->value.r.ul=ulli; + pb->value_set = true; + return(0); + }else + return(-1); + break; + case llong_t: + if(sscanf(param_val,"%lld",&lli) == 1){ + pb->value.r.l=lli; + pb->value_set = true; + return(0); + }else + return(-1); + break; + case floating_t: + if(sscanf(param_val,"%lf",&f) == 1){ + pb->value.r.f=f; + pb->value_set = true; + return(0); + }else + return(-1); + break; + case timeval_t: + if(sscanf(param_val,"(%d,%d)",&d1, &d2) == 2){ + pb->value.r.t.tv_sec = d1; + pb->value.r.t.tv_usec = d2; + pb->value_set = true; + return(0); + }else + return(-1); + break; + case v_str_t: + if(pb->value.r.vs.offset != 0){ + tmp_ptr = (void *)(pb->value.r.vs.offset); + free(tmp_ptr); + } + tmp_ptr = malloc(len); + pb->value.r.vs.offset = (gs_p_t)tmp_ptr; + memcpy(tmp_ptr,param_val, len); + pb->value.r.vs.length = len; +// pb->value.r.vs.reserved = 0; + pb->value.r.vs.reserved = INTERNAL; + pb->value_set = true; + return(0); + break; + case fstring_t: + fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n"); + exit(1); + break; + case ipv6_t: + fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n"); + exit(1); + break; + case undefined_t: + fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n"); + exit(1); + default: + fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_setparam_by_index\n"); + exit(1); + } + + return(-1); +} + +gs_int32_t ftaschema_create_param_block(gs_schemahandle_t sh, void ** block, gs_int32_t * size){ + if(sh < 0 || sh >= schema_list.size()){ + return(-1); + } + + *size = schema_list[sh]->min_param_size; + int p; + + for(p=0;pparam_info.size();++p){ + if(! schema_list[sh]->param_info[p].value_set) return 1; + + switch(schema_list[sh]->param_info[p].pdt->get_type()){ + case v_str_t: + *size += schema_list[sh]->param_info[p].value.r.vs.length; + break; + case fstring_t: + fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n"); + exit(1); + break; + case undefined_t: + return(-1); + break; + default: + break; + } + } + + *block = malloc(*size); + if(*block == NULL) return(-1); + + int data_pos = schema_list[sh]->min_param_size; + + gs_int32_t tmp_int; + gs_uint32_t tmp_uint; + gs_int64_t tmp_ll; + gs_uint64_t tmp_ull; + gs_float_t tmp_f; + timeval tmp_tv; + vstring32 tmp_vstr; + void *tmp_ptr; + + for(p=0;pparam_info.size();++p){ + param_block_info *pb = &(schema_list[sh]->param_info[p]); + switch(pb->pdt->get_type()){ + case int_t: +// tmp_int = htonl(pb->value.r.i); + tmp_int = pb->value.r.i; + memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_int,sizeof(gs_int32_t)); + break; + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: +// tmp_uint = htonl(pb->value.r.ui); + tmp_uint = pb->value.r.ui; + memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_uint,sizeof(gs_uint32_t)); + break; + case u_llong_t: +// tmp_ull = htonll(pb->value.r.ul); + tmp_ull = pb->value.r.ul; + memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ull,sizeof(gs_uint64_t)); + break; + case llong_t: +// tmp_ll = htonll(pb->value.r.l); + tmp_ll = pb->value.r.l; + memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ll,sizeof(gs_int64_t)); + break; + case floating_t: +// tmp_f = ntohf(pb->value.r.f); + tmp_f = pb->value.r.f; + memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_f,sizeof(gs_float_t)); + break; + case timeval_t: +// tmp_tv.tv_sec = htonl(pb->value.r.t.tv_sec); +// tmp_tv.tv_usec = htonl(pb->value.r.t.tv_usec); + tmp_tv.tv_sec = pb->value.r.t.tv_sec; + tmp_tv.tv_usec =pb->value.r.t.tv_usec; + memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_tv,sizeof(timeval)); + break; + case v_str_t: +// tmp_vstr.offset = htonl(data_pos); +// tmp_vstr.length = htonl(pb->value.r.vs.length); + tmp_vstr.offset = data_pos; + tmp_vstr.length = pb->value.r.vs.length; +// tmp_vstr.reserved = htonl(pb->value.r.vs.reserved); +// tmp_vstr.reserved = htonl(PACKED); + tmp_vstr.reserved = PACKED; + memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_vstr,sizeof(vstring32)); + tmp_ptr = (void *)(pb->value.r.vs.offset); + memcpy(((gs_sp_t)(*block))+data_pos, tmp_ptr, pb->value.r.vs.length); + data_pos += pb->value.r.vs.length; + break; + case fstring_t: + fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n"); + exit(1); + break; + case ipv6_t: + fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n"); + exit(1); + break; + case undefined_t: + fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n"); + exit(1); + default: + fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_create_param_block\n"); + exit(1); + } + } + return(0); + +} + + +/////////////////////////////////////////////////////////////// +// Diagnostic functions + +void ftaschema_debugdump(gs_int32_t handle){ + if(handle<0){ + printf("ftaschema_debugdump: handle is negative.\n"); + return; + } + if(handle >= schema_list.size()){ + printf("ftaschema_debugdump: handle out of bounds (%d, max is %lu)\n", + handle, schema_list.size()); + } + + query_rep *q = schema_list[handle]; + + printf("Handle is %d, query name is <%s>\n",handle,q->name.c_str()); + printf("Output tuple has %lu fields:\n",q->field_info.size()); + int f; + for(f=0;ffield_info.size();++f){ + printf("\t%s (%s) : %d\n",q->field_info[f].field_name.c_str(), + (q->field_info[f].pdt->get_type_str()).c_str(), + q->field_info[f].offset + ); + } + printf("Min tuple size is %d\n\n",q->min_tuple_size); + printf("Param block is:\n"); + int p; + for(p=0;pparam_info.size();++p){ + printf("\t%s (%s) : %d\n",q->param_info[p].param_name.c_str(), + (q->param_info[p].pdt->get_type_str()).c_str(), + q->param_info[p].offset + ); + } + printf("Min param block size is %d\n\n",q->min_param_size); + + + +} + + diff --git a/src/ftacmp/schemaparser_impl.h b/src/ftacmp/schemaparser_impl.h new file mode 100644 index 0000000..dad02a1 --- /dev/null +++ b/src/ftacmp/schemaparser_impl.h @@ -0,0 +1,160 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __INTERFACE_IMPL_INCLUDED__ +#define __INTERFACE_IMPL_INCLUDED__ + +#include"schemaparser.h" + + + #include"type_indicators.h" + #include"type_objects.h" + #include"parse_fta.h" + #include "gstypes.h" + + + + +// access_result (access_fcn)(char *tuple, int offset); +class tuple_access_info{ +public: + std::string field_name; + int offset; + data_type *pdt; + + + tuple_access_info(){ + pdt = NULL; + offset = 0; + }; + + int init(field_entry *fe){ + field_name = fe->get_name(); + pdt = new data_type(fe->get_type()); + return(pdt->type_indicator()); + }; +}; + +class param_block_info{ +public: + std::string param_name; + access_result value; + data_type *pdt; + unsigned int offset; + bool value_set; + + param_block_info(){ + pdt = NULL; + offset = 0; + value_set = false; + }; + + int init(var_pair_t *vp){ + value_set = false; + param_name = vp->name; + pdt = new data_type(vp->val); + switch(pdt->get_type()){ + case int_t: + value.r.i=0; break; + case u_int_t: + case u_short_t: + case bool_t: + value.r.ui=0; break; + case floating_t: + value.r.f = 0.0; break; + case u_llong_t: + value.r.ul = 0; break; + case llong_t: + value.r.l=0; break; + case timeval_t: + value.r.t.tv_sec=0; value.r.t.tv_usec=0; break; + case v_str_t: + value.r.vs.length = 0; value.r.vs.offset = 0; value.r.vs.reserved=0; break; + case fstring_t: + value.r.fs.data = NULL; + value.r.fs.size = 0; + break; + default: + break; + } + return(pdt->type_indicator()); + }; +}; + + + +class query_rep{ +public: + std::string name; + + std::vector field_info; + int min_tuple_size; + + std::vector param_info; + int min_param_size; + + query_rep(std::string nm, int ntuples, int nparams) : + name(nm), field_info(ntuples), param_info(nparams) { + min_tuple_size = 0; + min_param_size = 0; + }; + + int set_field_info(int f, field_entry *fe){ + if(f<0 || f>=field_info.size()) return(-1); + return(field_info[f].init(fe)); + }; + + int finalize_field_info(){ + int f; + int curr_pos = 0; + int fld_undefined = 0; + for(f=0;ftype_size(); + if(sz==0) fld_undefined = 1; + curr_pos += sz; + } + min_tuple_size = curr_pos; + if(fld_undefined) return(-1); + else return(0); + }; + + int set_param_info(int p, var_pair_t *vp){ + if(p<0 || p>=param_info.size()) return(-1); + return(param_info[p].init(vp)); + }; + + int finalize_param_info(){ + int p; + int curr_pos = 0; + int fld_undefined = 0; + for(p=0;ptype_size(); + if(sz==0) fld_undefined = 1; + curr_pos += sz; + } + min_param_size = curr_pos; + if(fld_undefined) return(-1); + else return(0); + }; + + +}; + +// Diagnostic tool. +void ftaschema_debugdump(int sch_handle); + +#endif + diff --git a/src/ftacmp/stream_query.cc b/src/ftacmp/stream_query.cc new file mode 100644 index 0000000..aacf1b6 --- /dev/null +++ b/src/ftacmp/stream_query.cc @@ -0,0 +1,1957 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include"stream_query.h" +#include"generate_utils.h" +#include"analyze_fta.h" +#include +#include +#include + +static char tmpstr[500]; + +using namespace std; + + +// Create a query plan from a query node and an existing +// query plan. Use for lfta queries, the parent query plan provides +// the annotations. +stream_query::stream_query(qp_node *qnode, stream_query *parent){ + query_plan.push_back(qnode); + qhead = 0; + qtail.push_back(0); + attributes = qnode->get_fields(); + parameters = qnode->get_param_tbl(); + defines = parent->defines; + query_name = qnode->get_node_name(); +} + +// Copy the query plan. +stream_query::stream_query(stream_query &src){ + query_plan = src.query_plan; + qhead = src.qhead; + qtail = src.qtail; + attributes = src.attributes; + parameters = src.parameters; + defines = src.defines; + query_name = src.query_name; + gid = src.gid; +} + + +// Create a query plan from an analyzed parse tree. +// Perform analyses to find the output node, input nodes, etc. + +stream_query::stream_query(query_summary_class *qs,table_list *Schema){ +// Generate the query plan nodes from the analyzed parse tree. +// There is only one for now, so just assign the return value +// of create_query_nodes to query_plan + error_code = 0; + query_plan = create_query_nodes(qs,Schema); + int i; +if(query_plan.size() == 0){ + fprintf(stderr,"INTERNAL ERROR, zero-size query plan in stream_query::stream_query\n"); + exit(1); +} + for(i=0;iget_error_code() != 0){ + error_code = query_plan[i]->get_error_code(); + err_str += query_plan[i]->get_error_str(); + } + } + } + qhead = query_plan.size()-1; + gid = -1; + +} + + +stream_query * stream_query::add_query(query_summary_class *qs,table_list *Schema){ +// Add another query block to the query plan + error_code = 0; + vector new_nodes = create_query_nodes(qs, Schema); + query_plan.insert(query_plan.end(),new_nodes.begin(), new_nodes.end()); + return this; +} + +stream_query * stream_query::add_query(stream_query &src){ +// Add another query block to the query plan + error_code = 0; + query_plan.insert(query_plan.end(),src.query_plan.begin(), src.query_plan.end()); + return this; +} + + +void stream_query::generate_protocol_se(map &sq_map, table_list *Schema){ + int i,n; + +// Mapping fields to protocol fields requires schema binding. +// First ensure all nodes are in the schema. + for(n=0;nadd_table(query_plan[n]->get_fields()); + } + } +// Now do schema binding + for(n=0;nbind_to_schema(Schema); + } + } + +// create name-to-index map + map name_to_node; + for(n=0;nget_node_name()] = n; + } + } + +// Create a list of the nodes to process, in order. +// Search from the root down. +// ASSUME tree plan. + + list search_q; + list work_list; + + search_q.push_back(qhead); + while(! search_q.empty()){ + int the_q = search_q.front(); + search_q.pop_front(); work_list.push_front(the_q); + vector the_pred = query_plan[the_q]->get_predecessors(); + for(i=0;i q_sources; + vector q_input_tbls = query_plan[the_q]->get_input_tbls(); + for(i=0;iget_schema_name(); + if(name_to_node.count(itbl_nm)>0){ + q_sources.push_back(query_plan[name_to_node[itbl_nm]]); + }else if(sq_map.count(itbl_nm)>0){ + q_sources.push_back(sq_map[itbl_nm]->get_query_head()); + }else{ + q_sources.push_back(NULL); + } + } + query_plan[the_q]->create_protocol_se(q_sources, Schema); + } + +////////////////////////////////////////////////////////// +// trust but verify + + +/* + for(i=0;iget_node_name().c_str(), + query_plan[i]->node_type().c_str()); + map *pse_map = query_plan[i]->get_protocol_se(); + map::iterator mssi; + for(mssi=pse_map->begin();mssi!=pse_map->end();++mssi){ + if((*mssi).second) + printf("\t%s : %s\n",(*mssi).first.c_str(), (*mssi).second->to_string().c_str()); + else + printf("\t%s : NULL\n",(*mssi).first.c_str()); + } + if(query_plan[i]->node_type() == "filter_join" || query_plan[i]->node_type() == "join_eq_hash_qpn"){ + vector pse_l; + vector pse_r; + if(query_plan[i]->node_type() == "filter_join"){ + pse_l = ((filter_join_qpn *)query_plan[i])->get_hash_l(); + pse_r = ((filter_join_qpn *)query_plan[i])->get_hash_r(); + } + if(query_plan[i]->node_type() == "join_eq_hash_qpn"){ + pse_l = ((join_eq_hash_qpn *)query_plan[i])->get_hash_l(); + pse_r = ((join_eq_hash_qpn *)query_plan[i])->get_hash_r(); + } + int p; + for(p=0;pto_string().c_str()); + else + printf("NULL\n"); + } + } + if(query_plan[i]->node_type() == "sgah_qpn" || query_plan[i]->node_type() == "rsgah_qpn" || query_plan[i]->node_type() == "sgahcwcb_qpn"){ + vector pseg; + if(query_plan[i]->node_type() == "sgah_qpn") + pseg = ((sgah_qpn *)query_plan[i])->get_gb_sources(); + if(query_plan[i]->node_type() == "rsgah_qpn") + pseg = ((rsgah_qpn *)query_plan[i])->get_gb_sources(); + if(query_plan[i]->node_type() == "sgahcwcb_qpn") + pseg = ((sgahcwcb_qpn *)query_plan[i])->get_gb_sources(); + int g; + for(g=0;gto_string().c_str()); + else + printf("\t\tgb %d = NULL\n",g); + } + } + } + } +*/ + +} + +bool stream_query::generate_linkage(){ + bool create_failed = false; + int n, f,s; + +// Clear any leftover linkages + for(n=0;nclear_predecessors(); + query_plan[n]->clear_successors(); + } + } + qtail.clear(); + +// create name-to-index map + map name_to_node; + for(n=0;nget_node_name()] = n; + } + } + +// Do the 2-way linkage. + for(n=0;n fm = query_plan[n]->get_input_tbls(); + for(f=0;fget_schema_name(); + if(name_to_node.count(src_tbl)>0){ + int s = name_to_node[src_tbl]; + query_plan[n]->add_predecessor(s); + query_plan[s]->add_successor(n); + } + } + } + } + +// Find the head (no successors) and the tails (at least one +// predecessor is external). +// Verify that there is only one head, +// and that all other nodes have one successor (because +// right now I can only handle trees). + + qhead = -1; // no head yet found. + for(n=0;n succ = query_plan[n]->get_successors(); +/* + if(succ.size() > 1){ + fprintf(stderr,"ERROR, query node %s supplies data to multiple nodes, but currently only tree query plans are supported:\n",query_plan[n]->get_node_name().c_str()); + for(s=0;sget_node_name().c_str()); + } + fprintf(stderr,"\n"); + create_failed = true; + } +*/ + if(succ.size() == 0){ + if(qhead >= 0){ + fprintf(stderr,"ERROR, query nodes %s and %s both have zero successors.\n",query_plan[n]->get_node_name().c_str(), query_plan[qhead]->get_node_name().c_str()); + create_failed = true; + }else{ + qhead = n; + } + } + if(query_plan[n]->n_predecessors() < query_plan[n]->get_input_tbls().size()){ + qtail.push_back(n); + } + } + } + + return create_failed; +} + +// After the collection of query plan nodes is generated, +// analyze their structure to link them up into a tree (or dag?). +// Verify that the structure is acceptable. +// Do some other analysis and verification tasks (?) +// then gather summar information. +int stream_query::generate_plan(table_list *Schema){ + +// The first thing to do is verify that the query plan +// nodes were successfully created. + bool create_failed = false; + int n,f,s; + for(n=0;nget_error_code()){ + fprintf(stderr,"%s",query_plan[n]->get_error_str().c_str()); + create_failed = true; + } + } +/* +for(n=0;nget_node_name(); +printf("In generate_plan, node %d is %s, reads from:\n\t",n,nstr.c_str()); +vector inv = query_plan[n]->get_input_tbls(); +int nn; +for(nn=0;nnto_string().c_str(),inv[nn]->get_schema_ref()); +} +printf("\n"); +} +} +*/ + + if(create_failed) return(1); + +// Here, link up the query nodes, then verify that the +// structure is acceptable (single root, no cycles, no stranded +// nodes, etc.) + create_failed = generate_linkage(); + if(create_failed) return -1; + + +// Here, do optimizations such as predicate pushing, +// join rearranging, etc. +// Nothing to do yet. + +/* +for(n=0;nget_node_name(); +printf("B generate_plan, node %d is %s, reads from:\n\t",n,nstr.c_str()); +vector inv = query_plan[n]->get_input_tbls(); +int nn; +for(nn=0;nnto_string().c_str(),inv[nn]->get_schema_ref()); +} +printf("\n"); +} +} +printf("qhead=%d, qtail = ",qhead); +int nn; +for(nn=0;nnget_node_name(); + attributes = query_plan[qhead]->get_fields(); +// TODO: The params and defines require a lot more thought. + parameters = query_plan[qhead]->get_param_tbl(); + defines = query_plan[qhead]->get_definitions(); + + return(0); + }; + +void stream_query::add_output_operator(ospec_str *o){ + output_specs.push_back(o); +} + + +void stream_query::get_external_libs(set &libset){ + + int qn,i; + for(qn=0;qn op_libs = query_plan[qn]->external_libs(); + for(i=0;i op_libs = output_operators[qn]->external_libs(); + for(i=0;i stream_query::split_query(ext_fcn_list *Ext_fcns, table_list *Schema, bool &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){ + vector queries; + int l,q,s; + int qp_hfta; + + hfta_returned = false; // assume until proven otherwise + + for(l=0;l qnodes = query_plan[leaf]->split_node_for_fta(Ext_fcns, Schema, qp_hfta, ifdb, n_virtual_ifaces, hfta_parallelism, hfta_idx); + + + if(qnodes.size() == 0 || query_plan[leaf]->get_error_code()){ // error +//printf("error\n"); + error_code = query_plan[leaf]->get_error_code(); + err_str = query_plan[leaf]->get_error_str(); + vector null_result; + return(null_result); + } + if(qnodes.size() == 1 && qp_hfta){ // nothing happened +//printf("no change\n"); + query_plan[leaf] = qnodes[0]; + } + if(qnodes.size() == 1 && !qp_hfta){ // push to lfta +//printf("lfta only\n"); + queries.push_back(new stream_query(qnodes[0], this)); + vector succ = query_plan[leaf]->get_successors(); + for(s=0;sremove_predecessor(leaf); + } + query_plan[leaf] = NULL; // delete it? + } + if(qnodes.size() > 1){ // actual splitting occurred. + if(!qp_hfta){ // internal consistency check. + error_code = 1; + err_str = "INTERNAL ERROR: mulitple nodes returned by split_node_for_fta, but none are hfta nodes.\n"; + vector null_result; + return(null_result); + } + + for(q=0;qget_node_name().c_str()); + queries.push_back(new stream_query(qnodes[q], this)); + } +// Use new hfta node + query_plan[leaf] = qnodes[qnodes.size()-1]; +// Add in any extra hfta nodes + for(q=qnodes.size()-qp_hfta;q ifps; + for(q=0;qcount_ifp_refs(ifps); + hfta_returned = true; + } + } + + if(n_ifprefs){ + set::iterator ssi; + err_str += "ERROR, unresolved interface parameters in HFTA:\n"; + for(ssi=ifps.begin();ssi!=ifps.end();++ssi){ + err_str += (*ssi)+" "; + } + err_str += "\n"; + error_code = 3; + vector null_result; + return(null_result); + } + + + if(hfta_returned){ + if(generate_linkage()){ + fprintf(stderr,"INTERNAL ERROR, generate_linkage failed in split_query.\n"); + exit(1); + } + queries.push_back(this); + } + + return(queries); +} + + + +vector stream_query::extract_opview(table_list *Schema, vector &qnodes, opview_set &opviews, string silo_nm){ + vector subqueries; + int l,q; + + string root_name = this->get_output_tabledef()->get_tbl_name(); + + + for(l=0;l new_qnodes = query_plan[leaf]->extract_opview(Schema, qnodes, opviews, root_name, silo_nm); + + for(q=0;qget_fields()->to_string(); + + ret += "DEFINE{\n"; + ret += "\tquery_name '"+query_plan[q]->get_node_name()+"';\n"; + + map defs = query_plan[q]->get_definitions(); + map::iterator dfi; + for(dfi=defs.begin(); dfi!=defs.end(); ++dfi){ + ret += "\t"+ (*dfi).first + " '" + (*dfi).second + "';\n"; + } + ret += "}\n\n"; + + ret += "PARAM{\n"; + param_table *params = query_plan[q]->get_param_tbl(); + vector param_names = params->get_param_names(); + int p; + for(p=0;pget_data_type( param_names[p] ); + ret += "\t" + param_names[p] + " '" + dt->get_type_str() + "';\n"; + } + ret += "}\n"; + + ret += query_plan[q]->to_query_string(); + ret += "\n}\n\n"; + + return(ret); + +} + +string stream_query::collect_refd_ifaces(){ + string ret=""; + int q; + for(q=0;q defs = query_plan[q]->get_definitions(); + if(defs.count("_referenced_ifaces")){ + if(ret != "") ret += ","; + ret += defs["_referenced_ifaces"]; + } + } + } + + return ret; +} + + +bool stream_query::stream_input_only(table_list *Schema){ + vector input_tbls = this->get_input_tables(); + int i; + for(i=0;iget_table_ref(input_tbls[i]->get_schema_name()); + if(Schema->get_schema_type(t) == PROTOCOL_SCHEMA) return(false); + } + return(true); +} + +// Return input tables. No duplicate removal performed. +vector stream_query::get_input_tables(){ + vector retval; + +// create name-to-index map + int n; + map name_to_node; + for(n=0;nget_node_name()] = n; + } + } + + int l; + for(l=0;l tmp_v = query_plan[leaf]->get_input_tbls(); + int i; + for(i=0;iget_schema_name()) == 0) + retval.push_back(tmp_v[i]); + } + } + return(retval); +} + + +void stream_query::compute_node_format(int q, vector &nfmt, map &op_idx){ + int netcnt = 0, hostcnt = 0; + int i; + + vector itbls = query_plan[q]->get_input_tbls(); + for(i=0;iget_schema_name(); + if(op_idx.count(tname)){ + int o = op_idx[tname]; + if(nfmt[o] == UNKNOWNFORMAT) + compute_node_format(o,nfmt,op_idx); + if(nfmt[o] == NETFORMAT) netcnt++; + else hostcnt++; + }else{ + netcnt++; + } + } + if(query_plan[q]->makes_transform()){ + nfmt[q] = HOSTFORMAT; + }else{ + if(hostcnt>0){ + nfmt[q] = HOSTFORMAT; + }else{ + nfmt[q] = NETFORMAT; + } + } +//printf("query plan %d (%s) is ",q,query_plan[q]->get_node_name().c_str()); +//if(nfmt[q] == HOSTFORMAT) printf(" host format.\n"); +//else printf("net format\n"); +} + + +string stream_query::generate_hfta(table_list *Schema, ext_fcn_list *Ext_fcns, opview_set &opviews, bool distributed_mode){ + int schref, ov_ix, i, q, param_sz; + bool dag_graph = false; + + +// Bind the SEs in all query plan nodes to this schema, and +// Add all tables used by this query to the schema. +// Question: Will I be polluting the global schema by adding all +// query node schemas? + +// First ensure all nodes are in the schema. + int qn; + for(qn=0;qnadd_table(query_plan[qn]->get_fields()); + } + } +// Now do binding. + for(qn=0;qnbind_to_schema(Schema); + } + } + +// Is it a DAG plan? + set qsources; + int n; + for(n=0;n tmp_v = query_plan[n]->get_input_tbls(); + int i; + for(i=0;iget_schema_name()) > 0) + dag_graph = true; + qsources.insert(tmp_v[i]->get_schema_name()); + } + } + } + + + +// Collect set of tables ref'd in this HFTA + set tbl_set; + for(qn=0;qn input_tbls = query_plan[qn]->get_input_tbls(); + vector output_tbls = query_plan[qn]->get_output_tbls(); +// Convert to tblrefs, add to set of ref'd tables + int i; + for(i=0;iget_table_ref(input_tbls[i]->get_schema_name()); + int t = input_tbls[i]->get_schema_ref(); + if(t < 0){ + fprintf(stderr,"INTERNAL ERROR in generate_hfta. " + "query plan node %s references input table %s, which is not in schema.\n", + query_name.c_str(), input_tbls[i]->get_schema_name().c_str()); + exit(1); + } + tbl_set.insert(t); + } + + for(i=0;iget_table_ref(output_tbls[i]->get_schema_name()); + if(t < 0){ + fprintf(stderr,"INTERNAL ERROR in generate_hfta." + "query plan node %s references output table %s, which is not in schema.\n", + query_name.c_str(), output_tbls[i]->get_schema_name().c_str()); + exit(1); + } + tbl_set.insert(t); + } + } + } + +// Collect map of lftas, query nodes + map op_idx; + for(q=0;qget_node_name()] = q; + } + } + +// map of input tables must include query id and input +// source (0,1) becuase several queries might reference the same source + vector input_tbls = this->get_input_tables(); + vector input_tbl_free; + for(i=0;i lfta_idx; +//fprintf(stderr,"%d input tables, %d query nodes\n",input_tbls.size(), query_plan.size()); + for(q=0;q itbls = query_plan[q]->get_input_tbls(); + int it; + for(it=0;itget_schema_name()+"-"+int_to_string(q)+"-"+int_to_string(it); + string src_tblname = itbls[it]->get_schema_name(); + bool src_is_external = false; + for(i=0;iget_schema_name()){ + src_is_external = true; + if(input_tbl_free[i]){ + lfta_idx[tname] = i; + input_tbl_free[i] = false; +//fprintf(stderr,"Adding %s (src_tblname=%s, q=%d, it=%d) to %d.\n",tname.c_str(), src_tblname.c_str(), q, it, i); + break; + } + } + } + if(i==input_tbls.size() && src_is_external){ + fprintf(stderr,"INTERNAL ERROR in stream_query::generate_hfta, can't find free entry in input_tbls for query %d, intput %d (%s)\n",q,it,src_tblname.c_str()); + exit(1); + } + } + } + } +/* + for(i=0;iget_schema_name(); + lfta_idx[src_tblname] = i; + } +*/ + +// Compute the output formats of the operators. + vector node_fmt(query_plan.size(),UNKNOWNFORMAT); + compute_node_format(qhead, node_fmt, op_idx); + + +// Generate the schema strings for the outputs. + string schema_str; + for(i=0;imake_schema(i); + schema_str += "gs_csp_t node"+int_to_string(i)+"_schema = "+make_C_embedded_string(schema_tmpstr)+";\n"; + } + } + + attributes = query_plan[qhead]->get_fields(); + + + string schema_tmpstr = this->make_schema(); + schema_str += "gs_csp_t "+generate_schema_string_name(query_name)+" = "+make_C_embedded_string(schema_tmpstr)+";\n"; + +// Generate the collection of tuple defs. + + string tuple_defs = "\n/*\tDefine tuple structures \t*/\n\n"; + set::iterator si; + for(si=tbl_set.begin(); si!=tbl_set.end(); ++si){ + tuple_defs += generate_host_tuple_struct( Schema->get_table( (*si) )); + tuple_defs += "\n\n"; + } + +// generate the finalize tuple function + string finalize_str = generate_hfta_finalize_tuple(attributes); + +// Analyze and make the output operators + bool eat_input = false; + string src_op = query_name; + string pred_op = src_op; + int last_op = -1; + if(output_specs.size()>0) + eat_input = true; + if(n_successors>0) + eat_input = false; // must create stream output for successor HFTAs. + int n_filestreams = 0; + for(i=0;ioperator_type == "stream" ){ + eat_input = false; + } + if(output_specs[i]->operator_type == "file" || output_specs[i]->operator_type == "zfile" ){ + last_op = i; + n_filestreams++; + } + } + int filestream_id = 0; + for(i=0;ioperator_type == "file" || output_specs[i]->operator_type == "zfile"){ + + int n_fstreams = output_specs[i]->n_partitions / n_parallel; + if(n_fstreams * n_parallel < output_specs[i]->n_partitions){ + n_fstreams++; + if(n_parallel == 1 || query_name.find("__copy1") != string::npos){ + fprintf(stderr,"WARNING, in query %s, %d streams requested for %s output, but it must be a multiple of the hfta parallelism (%d), increasing number of output streams to %d.\n",query_name.c_str(), output_specs[i]->n_partitions, output_specs[i]->operator_type.c_str(), n_parallel, n_fstreams*n_parallel); + } + } +// output_file_qpn *new_ofq = new output_file_qpn(); + string filestream_tag = ""; + if(n_filestreams>1){ + filestream_tag = "_fileoutput"+int_to_string(filestream_id); + filestream_id++; + } + output_file_qpn *new_ofq = new output_file_qpn(pred_op, src_op, filestream_tag, query_plan[qhead]->get_fields(), output_specs[i], (i==last_op ? eat_input : false) ); +// if(n_fstreams > 1){ + if(n_fstreams > 0){ + string err_str; + bool err_ret = new_ofq->set_splitting_params(n_parallel,parallel_idx,n_fstreams,output_specs[i]->partitioning_flds,err_str); + if(err_ret){ + fprintf(stderr,"%s",err_str.c_str()); + exit(1); + } + } + output_operators.push_back(new_ofq ); + pred_op = output_operators.back()->get_node_name(); + }else if(! (output_specs[i]->operator_type == "stream" || output_specs[i]->operator_type == "Stream" || output_specs[i]->operator_type == "STREAM") ){ + fprintf(stderr,"WARNING, output operator type %s (on query %s) is not supported, ignoring\n",output_specs[i]->operator_type.c_str(),query_name.c_str() ); + } + } + + + +// Generate functors for the query nodes. + + string functor_defs = "\n/*\tFunctor definitions\t*/\n\n"; + for(qn=0;qn needs_xform; + vector itbls = query_plan[qn]->get_input_tbls(); + for(i=0;iget_schema_name(); +// if(query_plan[qn]->makes_transform()){ + if(op_idx.count(tname)>0){ + if(node_fmt[ op_idx[tname] ] == NETFORMAT){ + needs_xform.push_back(true); + }else{ + needs_xform.push_back(false); + } + }else{ + needs_xform.push_back(true); + } +// }else{ +// if(op_idx.count(tname)>0){ +// if(node_fmt[qn] != node_fmt[ op_idx[tname] ]){ +// needs_xform.push_back(true); +// }else{ +// needs_xform.push_back(false); +// } +// }else{ +// if(node_fmt[qn] == HOSTFORMAT){ +// needs_xform.push_back(true); +// }else{ +// needs_xform.push_back(false); +// } +// } +// } + } + + functor_defs += query_plan[qn]->generate_functor(Schema, Ext_fcns, needs_xform); + } + } + +// Generate output operator functors + + vector needs_xform; + for(i=0;igenerate_functor(Schema, Ext_fcns, needs_xform); + + string ret = +"extern \"C\" {\n" +"#include \n" +"#include \n" +"#include \n" +"#include \n" +"#include \n" +"#include \n" +"}\n" +; + if(dag_graph) + ret += +"#define PLAN_DAG\n" +; + ret += +"#include \n" +"#include\n" +"\n" +"#include \n" +"#include \n" +"#include \n" +"#include \n" +"\n" +//"#define MAXSCHEMASZ 16384\n" +"#include \n\n" +; + +// Get include file for each of the operators. +// avoid duplicate inserts. + set include_fls; + for(qn=0;qnget_include_file()); + } + for(i=0;iget_include_file()); + set::iterator ssi; + for(ssi=include_fls.begin();ssi!=include_fls.end();++ssi) + ret += (*ssi); + +// Add defines for hash functions + ret += +"\n" +"#define hfta_BOOL_to_hash(x) (x)\n" +"#define hfta_USHORT_to_hash(x) (x)\n" +"#define hfta_UINT_to_hash(x) (x)\n" +"#define hfta_IP_to_hash(x) (x)\n" +"#define hfta_IPV6_to_hash(x) ( (x.v[0]) ^ (x.v[1]) ^ (x.v[2]) ^ (x.v[3]))\n" +"#define hfta_INT_to_hash(x) (gs_uint32_t)(x)\n" +"#define hfta_ULLONG_to_hash(x) ( (( (x) >>32)&0xffffffff) ^ ((x)&0xffffffff) )\n" +"#define hfta_LLONG_to_hash(x) ( (( (x) >>32)&0xffffffff) ^ ((x)&0xffffffff) )\n" +"#define hfta_FLOAT_to_hash(x) ( (( ((gs_uint64_t)(x)) >>32)&0xffffffff) ^ (((gs_uint64_t)(x))&0xffffffff) )\n" +"\n" +; + +// ret += "#define SERIOUS_LFTA \""+input_tbls[0]->get_schema_name()+"\"\n"; + ret += "#define OUTPUT_HFTA \""+query_name+"\"\n\n"; + +// HACK ALERT: I know for now that all query plans are +// single operator plans, but while SPX and SGAH can use the +// UNOP template, the merge operator must use the MULTOP template. +// WORSE HACK ALERT : merge does not translate its input, +// so don't apply finalize to the output. +// TODO: clean this up. + +// string node_type = query_plan[0]->node_type(); + + ret += schema_str; + ret += tuple_defs; + +// Need to work on the input, output xform logic. +// For now, just add it in. +// ret += finalize_str; + + if(node_fmt[qhead] == NETFORMAT){ + ret += +"void finalize_tuple(host_tuple &tup){\n" +"return;\n" +"}\n" +"\n"; + }else{ + ret += finalize_str; + } + + ret += functor_defs; + +// Parameter block management +// The proper parameter block must be transmitted to each +// external stream source. +// There is a 1-1 mapping between the param blocks returned +// by this list and the registered data sources ... +// TODO: make this more manageable, but for now +// there is no parameter block manipulation so I just +// need to have the same number. + + ret += +"int get_lfta_params(gs_int32_t sz, void * value,list& lst){\n" +" // for now every lfta receive the full copy of hfta parameters\n" +" struct param_block pb;\n"; + + set lfta_seen; + for(i=0;iget_schema_name(); + if(lfta_seen.count(src_tblname) == 0){ + lfta_seen.insert(src_tblname); + schref = input_tbls[i]->get_schema_ref(); + if(Schema->get_schema_type(schref) == OPERATOR_VIEW_SCHEMA){ + ov_ix = input_tbls[i]->get_opview_idx(); + opview_entry *opv = opviews.get_entry(ov_ix); + string op_param = "SUBQ:"; + int q; + for(q=0;qsubq_names.size();++q){ + if(q>0) op_param+=","; + op_param+=opv->subq_names[q]; + } + op_param+="\\n"; + param_sz = op_param.size()-1; + + sprintf(tmpstr,"\t\tpb.block_length = %d;\n",param_sz); ret+=tmpstr; + ret+= +" pb.data = malloc(pb.block_length);\n"; + ret+="\t\tmemcpy(pb.data,\""+op_param+"\",pb.block_length);\n" +" lst.push_back(pb);\n\n"; + }else{ + ret+= +" pb.block_length = sz;\n" +" pb.data = malloc(pb.block_length);\n" +" memcpy(pb.data, value, pb.block_length);\n" +" lst.push_back(pb);\n\n"; + } + } + } + + ret += +" return 0;\n" +"}\n" +"\n"; + + ret+= +"struct FTA* alloc_hfta (struct FTAID ftaid, gs_uint32_t reusable, gs_int32_t command, gs_int32_t sz, void * value ) {\n" +"\n" +" // find the lftas\n" +" list *lfta_list = new list;\n" +"\n" +" FTAID f;\n" +" char schemabuf[MAXSCHEMASZ];\n" +" gs_schemahandle_t schema_handle;\n" +"\n"; + +// Register the input data sources. +// Register a source only once. + +// vector ext_reg_txt; + map input_tbl_srcid; + for(i=0;iget_schema_name(); +// Use UDOP alias when in distributed mode. +// the cluster manager will make the translation +// using infr from qtree.xml + if(distributed_mode && input_tbls[i]->get_udop_alias() != "") + src_tblname = input_tbls[i]->get_udop_alias(); + if(input_tbl_srcid.count(src_tblname) == 0){ + int srcid = input_tbl_srcid.size(); + input_tbl_srcid[src_tblname] = srcid; + string tmp_s= +"\n // find "+src_tblname+"\n" +" if (fta_find(\""+src_tblname+"\",1,&f,schemabuf,MAXSCHEMASZ)!=0) {\n" +" fprintf(stderr,\"HFTA::error:could not find LFTA \\n\");\n" +" return 0;\n" +" }\n" +" //fprintf(stderr,\"HFTA::FTA found at %u[%u]\\n\",ftamsgid,ftaindex);\n" +"\n" +" // parse the schema and get the schema handle\n" +" schema_handle = ftaschema_parse_string(schemabuf);\n" +" lfta_info* inf"+int_to_string(srcid)+" = new lfta_info();\n" +" inf"+int_to_string(srcid)+"->f = f;\n" +" inf"+int_to_string(srcid)+"->fta_name = strdup(\""+src_tblname+"\");\n" +" inf"+int_to_string(srcid)+"->schema = strdup(schemabuf);\n" +" inf"+int_to_string(srcid)+"->schema_handle = schema_handle;\n" +" lfta_list->push_back(inf"+int_to_string(srcid)+");\n\n"; +// ext_reg_txt.push_back(tmp_s); + ret += tmp_s; + } + } + + ret+="\n"; + ret += "\tgs_schemahandle_t root_schema_handle = ftaschema_parse_string("+generate_schema_string_name(query_name)+");\n"; + for(i=0;iget_node_name()+") \n"; + +// Create parameters for operator construction. + string op_params; + vector itbls = query_plan[q]->get_input_tbls(); + string tname = itbls[0]->get_schema_name(); +// string li_tname = tname +"-"+int_to_string(q)+"-0"; +// if(lfta_idx.count(li_tname)>0) + if(input_tbl_srcid.count(tname)>0){ +// ret += ext_reg_txt[lfta_idx[li_tname]]; +// op_params += "inf"+int_to_string( lfta_idx[li_tname] )+"->schema_handle"; + op_params += "inf"+int_to_string( input_tbl_srcid[tname] )+"->schema_handle"; + }else if(op_idx.count(tname)>0){ + op_params += "op"+int_to_string( op_idx[tname] )+"_schema_handle"; + }else{ + fprintf(stderr,"INTERNAL ERROR, can't identify input table %s when creating operator (3) %d (%s)\n",tname.c_str(),q,query_plan[q]->get_node_name().c_str()); + exit(1); + } + if(itbls.size()>1){ + string tname = itbls[1]->get_schema_name(); +// string li_tname = tname +"-"+int_to_string(q)+"-1"; +// if(lfta_idx.count(li_tname)>0) + if(input_tbl_srcid.count(tname)>0){ +// ret += ext_reg_txt[lfta_idx[li_tname]]; +// op_params += ",inf"+int_to_string( lfta_idx[li_tname] )+"->schema_handle"; + op_params += ",inf"+int_to_string( input_tbl_srcid[tname] )+"->schema_handle"; + }else if(op_idx.count(tname)>0){ + op_params += ",op"+int_to_string( op_idx[tname] )+"_schema_handle"; + }else{ + fprintf(stderr,"INTERNAL ERROR, can't identify input table %s when creating operator (4) %d (%s)\n",tname.c_str(),q,query_plan[q]->get_node_name().c_str()); + exit(1); + } + } + ret += query_plan[q]->generate_operator(q,op_params); + ret += +" operator_node* node"+int_to_string(q)+" = new operator_node(op"+int_to_string(q)+");\n"; + + n_basic_ops = q; + } + } + n_basic_ops++; +// Next for the output operators if any + for(i=0;igenerate_operator(n_basic_ops+i,"root_schema_handle"); + ret += +" operator_node* node"+int_to_string(n_basic_ops+i)+" = new operator_node(op"+int_to_string(n_basic_ops+i)+");\n"; + } + + +// Link up operators. + for(q=0;q itbls = query_plan[q]->get_input_tbls(); + string tname = itbls[0]->get_schema_name(); +// string li_tname = tname +"-"+int_to_string(q)+"-0"; +// if(lfta_idx.count(li_tname)>0) + if(input_tbl_srcid.count(tname)>0){ +// ret += "\tnode"+int_to_string(q)+"->set_left_lfta(inf"+int_to_string( lfta_idx[li_tname] )+");\n"; + ret += "\tnode"+int_to_string(q)+"->set_left_lfta(inf"+int_to_string( input_tbl_srcid[tname] )+");\n"; + }else if(op_idx.count(tname)>0){ + ret += "\tnode"+int_to_string(q)+"->set_left_child_node(node"+int_to_string( op_idx[tname] )+");\n"; + }else{ + fprintf(stderr,"INTERNAL ERROR, can't identify input table %s when linking operator (1) %d (%s)\n",tname.c_str(),q,query_plan[q]->get_node_name().c_str()); + exit(1); + } + if(itbls.size()>1){ + string tname = itbls[1]->get_schema_name(); +// string li_tname = tname +"-"+int_to_string(q)+"-1"; +// if(lfta_idx.count(li_tname)>0) + if(input_tbl_srcid.count(tname)>0){ +// ret += "\tnode"+int_to_string(q)+"->set_right_lfta(inf"+int_to_string( lfta_idx[li_tname] )+");\n"; + ret += "\tnode"+int_to_string(q)+"->set_right_lfta(inf"+int_to_string( input_tbl_srcid[tname] )+");\n"; + }else if(op_idx.count(tname)>0){ + ret += "\tnode"+int_to_string(q)+"->set_right_child_node(node"+int_to_string( op_idx[tname] )+");\n"; + }else{ + fprintf(stderr,"INTERNAL ERROR, can't identify input table %s (%s) when linking operator (2) %d (%s)\n",tname.c_str(), tname.c_str(),q,query_plan[q]->get_node_name().c_str()); + exit(1); + } + } + } + } + for(i=0;iset_left_child_node(node"+int_to_string( qhead )+");\n"; + else + ret += "\tnode"+int_to_string(n_basic_ops+i)+"->set_left_child_node(node"+int_to_string( n_basic_ops+i-1 )+");\n"; + } + + // FTA is reusable if reusable option is set explicitly or it doesn't have any parameters + + bool fta_reusable = false; + if (query_plan[qhead]->get_val_of_def("reusable") == "yes" || + query_plan[qhead]->get_param_tbl()->size() == 0) { + fta_reusable = 1; + } + + int root_node = qhead; + if(output_operators.size()>0) + root_node = n_basic_ops+i-1; + + ret+= +"\n" +"\n" +" MULTOP_HFTA* ftap = new MULTOP_HFTA(ftaid, OUTPUT_HFTA, command, sz, value, root_schema_handle, node"+int_to_string(root_node)+", lfta_list, " + (fta_reusable ?"true":"false") + ", reusable);\n" +" if(ftap->init_failed()){ delete ftap; return 0;}\n" +" return (FTA*)ftap;\n" +"}\n" +"\n" +"\n"; + + + string comm_bufsize = "16*1024*1024"; + if(defines.count("hfta_comm_buf")>0){ + comm_bufsize = defines["hfta_comm_buf"]; + } + + ret+= +"\n" +"int main(int argc, char * argv[]) {\n" +"\n" +"\n" +" /* parse the arguments */\n" +"\n" +" gs_int32_t tip1,tip2,tip3,tip4;\n" +" endpoint gshub;\n" +" gs_sp_t instance_name;\n" +" if (argc<3) {\n" +" gslog(LOG_EMERG,\"Wrong arguments at startup\");\n" +" exit(1);\n" +" }\n" +"\n" +" if ((sscanf(argv[1],\"%u.%u.%u.%u:%hu\",&tip1,&tip2,&tip3,&tip4,&(gshub.port)) != 5)) {\n" +" gslog(LOG_EMERG,\"HUB IP NOT DEFINED\");\n" +" exit(1);\n" +" }\n" +" gshub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4);\n" +" gshub.port=htons(gshub.port);\n" +" instance_name=strdup(argv[2]);\n" +" if (set_hub(gshub)!=0) {\n" +" gslog(LOG_EMERG,\"Could not set hub\");\n" +" exit(1);\n" +" }\n" +" if (set_instance_name(instance_name)!=0) {\n" +" gslog(LOG_EMERG,\"Could not set instance name\");\n" +" exit(1);\n" +" }\n" +"\n" +"\n" +" /* initialize host library */\n" +"\n" +//" fprintf(stderr,\"Initializing gscp\\n\");\n" +" gsopenlog(argv[0]);\n" +"\n" +" if (hostlib_init(HFTA, "+comm_bufsize+", DEFAULTDEV, 0, 0)!=0) {\n" +" fprintf(stderr,\"%s::error:could not initialize gscp\\n\",\n" +" argv[0]);\n" +" exit(1);\n" +" }\n" +"\n" +"\n" +"\n" +" FTAID ret = fta_register(OUTPUT_HFTA, " + (fta_reusable?"1":"0") + ", DEFAULTDEV, alloc_hfta, "+generate_schema_string_name(query_name)+", -1, 0ull);\n" +" fta_start_service(-1);\n" +"\n" +" return 0;\n" +"\n" +"}\n" +"\n"; +//////////////////// + return(ret); +} + + +// Checks if the node i is compatible with interface partitioning +// (can be pushed below the merge that combines partitioned stream) +// i - index of the query node in a query plan +bool stream_query::is_partn_compatible(int index, map lfta_names, vector interface_names, vector machine_names, ifq_t *ifaces_db, partn_def_list_t *partn_parse_result) { + int i; + qp_node* node = query_plan[index]; + qp_node* child_node = NULL; + + if (node->predecessors.empty()) + return false; + + // all the node predecessors must be partition merges with the same partition definition + partn_def_t* partn_def = NULL; + for (i = 0; i < node->predecessors.size(); ++i) { + child_node = query_plan[node->predecessors[i]]; + if (child_node->node_type() != "mrg_qpn") + return false; + + // merge must have only one parent for this optimization to work + // check that all its successors are the same + for (int j = 1; j < child_node->successors.size(); ++j) { + if (child_node->successors[j] != child_node->successors[0]) + return false; + } + + partn_def_t* new_partn_def = ((mrg_qpn*)child_node)->get_partn_definition(lfta_names, interface_names, machine_names, ifaces_db, partn_parse_result); + if (!new_partn_def) + return false; + if (!i) + partn_def = new_partn_def; + else if (new_partn_def != partn_def) + return false; + + } + + if (node->node_type() == "spx_qpn") // spx nodes are always partition compatible + return true; + else if (node->node_type() == "sgah_qpn") { + gb_table gb_tbl = ((sgah_qpn*)node)->gb_tbl; + return true; //partn_def->is_compatible(&gb_tbl); + } + else if (node->node_type() == "rsgah_qpn") { + gb_table gb_tbl = ((rsgah_qpn*)node)->gb_tbl; + return partn_def->is_compatible(&gb_tbl); + } + else if (node->node_type() == "sgahcwcb_qpn") { + gb_table gb_tbl = ((sgahcwcb_qpn*)node)->gb_tbl; + return partn_def->is_compatible(&gb_tbl); + } + else if (node->node_type() == "join_eq_hash_qpn") { + return true; + } + else + return false; +} + +// Push the operator below the merge that combines +void stream_query::pushdown_partn_operator(int index) { + qp_node* node = query_plan[index]; + int i; + char node_index[128]; + +// fprintf(stderr, "Partn pushdown, query %s of type %s\n", node->get_node_name().c_str(), node->node_type().c_str()); + + + // HACK ALERT: When reordering merges we screw up slack computation + // since slack should no longer be used, it is not an issue + + + // we can safely reorder nodes that have one and only one temporal atribute in select list + table_def* table_layout = node->get_fields(); + vector fields = table_layout->get_fields(); + int merge_fieldpos = -1; + + data_type* dt; + for (i = 0; i < fields.size(); ++i) { + data_type dt(fields[i]->get_type(),fields[i]->get_modifier_list()); + if(dt.is_temporal()) { + if (merge_fieldpos != -1) // more that one temporal field found + return; + merge_fieldpos = i; + } + } + + if (merge_fieldpos == -1) // if no temporal fieldf found + return; + + std::vector mvars; // the merge-by columns. + + // reodring procedure is different for unary operators and joins + if (node->node_type() == "join_eq_hash_qpn") { + vector new_nodes; + + tablevar_t *left_table_name; + tablevar_t *right_table_name; + mrg_qpn* left_mrg = (mrg_qpn*)query_plan[node->predecessors[0]]; + mrg_qpn* right_mrg = (mrg_qpn*)query_plan[node->predecessors[1]]; + + // for now we will only consider plans where both child merges + // merge the same set of streams + + if (left_mrg->fm.size() != right_mrg->fm.size()) + return; + + // maping of interface names to table definitions + map iface_map; + for (i = 0; i < left_mrg->fm.size(); i++) { + left_table_name = left_mrg->fm[i]; + iface_map[left_table_name->get_machine() + left_table_name->get_interface()] = left_table_name; + } + + for (i = 0; i < right_mrg->fm.size(); i++) { + right_table_name = right_mrg->fm[i]; + + // find corresponding left tabke + if (!iface_map.count(right_table_name->get_machine() + right_table_name->get_interface())) + return; + + left_table_name = iface_map[right_table_name->get_machine() + right_table_name->get_interface()]; + + // create new join nodes + sprintf(node_index, "_%d", i); + join_eq_hash_qpn* new_node = (join_eq_hash_qpn*)node->make_copy(node_index); + + // make a copy of right_table_name + right_table_name = right_table_name->duplicate(); + left_table_name->set_range_var(((join_eq_hash_qpn*)node)->from[0]->get_var_name()); + right_table_name->set_range_var(((join_eq_hash_qpn*)node)->from[1]->get_var_name()); + new_node->from[0] = left_table_name; + new_node->from[1] = right_table_name; + new_nodes.push_back(new_node); + } + + // make right_mrg a new root + right_mrg->set_node_name(node->get_node_name()); + right_mrg->table_layout = table_layout; + right_mrg->merge_fieldpos = merge_fieldpos; + + for (i = 0; i < right_mrg->fm.size(); i++) { + // make newly create joins children of merge + sprintf(node_index, "_%d", i); + right_mrg->fm[i] = new tablevar_t(right_mrg->fm[i]->get_machine().c_str(), right_mrg->fm[i]->get_interface().c_str(), (node->get_node_name() + string(node_index)).c_str()); + sprintf(node_index, "_m%d", i); + right_mrg->fm[i]->set_range_var(node_index); + right_mrg->mvars[i]->set_field(table_layout->get_field_name(merge_fieldpos)); + + } + + if (left_mrg != right_mrg) + query_plan[node->predecessors[0]] = NULL; // remove left merge from the plan + + query_plan.insert(query_plan.end(), new_nodes.begin(), new_nodes.end()); + + } else { // unary operator + // get the child merge node + mrg_qpn* child_mrg = (mrg_qpn*)query_plan[node->predecessors[0]]; + + child_mrg->set_node_name(node->get_node_name()); + child_mrg->table_layout = table_layout; + child_mrg->merge_fieldpos = merge_fieldpos; + + // create new nodes for every source stream + for (i = 0; i < child_mrg->fm.size(); i++) { + tablevar_t *table_name = child_mrg->fm[i]; + sprintf(node_index, "_%d", i); + qp_node* new_node = node->make_copy(node_index); + + if (node->node_type() == "spx_qpn") + ((spx_qpn*)new_node)->table_name = table_name; + else if (node->node_type() == "sgah_qpn") + ((sgah_qpn*)new_node)->table_name = table_name; + else if (node->node_type() == "rsgah_qpn") + ((rsgah_qpn*)new_node)->table_name = table_name; + else if (node->node_type() == "sgahcwcb_qpn") + ((sgahcwcb_qpn*)new_node)->table_name = table_name; + table_name->set_range_var("_t0"); + + child_mrg->fm[i] = new tablevar_t(table_name->get_machine().c_str(), table_name->get_interface().c_str(), new_node->get_node_name().c_str()); + sprintf(node_index, "_m%d", i); + child_mrg->fm[i]->set_range_var(node_index); + child_mrg->mvars[i]->set_field(table_layout->get_field_name(merge_fieldpos)); + + // add new node to query plan + query_plan.push_back(new_node); + } + } + query_plan[index] = NULL; + generate_linkage(); +} + + +// Checks if the node i can be pushed below the merge + bool stream_query::is_pushdown_compatible(int index, map lfta_names, vector interface_names, vector machine_names) { + + int i; + qp_node* node = query_plan[index]; + qp_node* child_node = NULL; + + if (node->predecessors.size() != 1) + return false; + + // node predecessor must be merge that combine streams from multiple hosts + child_node = query_plan[node->predecessors[0]]; + if (child_node->node_type() != "mrg_qpn") + return false; + + if (!((mrg_qpn*)child_node)->is_multihost_merge()) + return false; + + // merge must have only one parent for this optimization to work + // check that all its successors are the same + for (int j = 1; j < child_node->successors.size(); ++j) { + if (child_node->successors[j] != child_node->successors[0]) + return false; + } + + // selections can always be pushed down, aggregations can always be split into selection/aggr or aggr/aggr pair + // and pushed down + if (node->node_type() == "spx_qpn") + return true; + else if (node->node_type() == "sgah_qpn") + return true; + else + return false; + + } + +// Push the operator below the merge + void stream_query::pushdown_operator(int index, ext_fcn_list *Ext_fcns, table_list *Schema) { + qp_node* node = query_plan[index]; + int i; + char node_suffix[128]; + + // we can only safely push down queries that have one and only one temporal atribute in select list + table_def* table_layout = node->get_fields(); + vector fields = table_layout->get_fields(); + int merge_fieldpos = -1; + + data_type* dt; + for (i = 0; i < fields.size(); ++i) { + data_type dt(fields[i]->get_type(),fields[i]->get_modifier_list()); + if(dt.is_temporal()) { + if (merge_fieldpos != -1) // more that one temporal field found + return; + merge_fieldpos = i; + } + } + + if (merge_fieldpos == -1) // if no temporal field found + return; + + std::vector mvars; // the merge-by columns. + + fprintf(stderr, "Regular pushdown, query %s of type %s\n", node->get_node_name().c_str(), node->node_type().c_str()); + + // get the child merge node + mrg_qpn* child_mrg = (mrg_qpn*)query_plan[node->predecessors[0]]; + + tablevar_t *table_name = NULL; + + + if (node->node_type() == "spx_qpn") { + // get the child merge node + + // create new nodes for every source stream + for (i = 0; i < child_mrg->fm.size(); i++) { + table_name = child_mrg->fm[i]; + sprintf(node_suffix, "_%d", i); + qp_node* new_node = node->make_copy(node_suffix); + + ((spx_qpn*)new_node)->table_name = table_name; + table_name->set_range_var("_t0"); + + child_mrg->fm[i] = new tablevar_t(table_name->get_machine().c_str(), table_name->get_interface().c_str(), new_node->get_node_name().c_str()); + sprintf(node_suffix, "_m%d", i); + child_mrg->fm[i]->set_range_var(node_suffix); + child_mrg->mvars[i]->set_field(table_layout->get_field_name(merge_fieldpos)); + + // add new node to query plan + query_plan.push_back(new_node); + } + child_mrg->table_layout = table_layout; + child_mrg->merge_fieldpos = merge_fieldpos; + + } else { // aggregation node + + vector new_nodes; + + // split aggregations into high and low-level part + vector split_nodes = ((sgah_qpn*)node)->split_node_for_hfta(Ext_fcns, Schema); + if (split_nodes.size() != 2) + return; + + sgah_qpn* super_aggr = (sgah_qpn*)split_nodes[1]; + super_aggr->table_name = ((sgah_qpn*)node)->table_name; + + // group all the sources by host + map > host_map; + for (i = 0; i < child_mrg->fm.size(); i++) { + tablevar_t *table_name = child_mrg->fm[i]; + if (host_map.count(table_name->get_machine())) + host_map[table_name->get_machine()].push_back(i); + else { + vector tables; + tables.push_back(i); + host_map[table_name->get_machine()] = tables; + } + } + + // create a new merge and low-level aggregation for each host + map >::iterator iter; + for (iter = host_map.begin(); iter != host_map.end(); iter++) { + string host_name = (*iter).first; + vector tables = (*iter).second; + + sprintf(node_suffix, "_%s", host_name.c_str()); + string suffix(node_suffix); + untaboo(suffix); + mrg_qpn *new_mrg = (mrg_qpn *)child_mrg->make_copy(suffix); + for (i = 0; i < tables.size(); ++i) { + sprintf(node_suffix, "_m%d", i); + new_mrg->fm.push_back(child_mrg->fm[tables[i]]); + new_mrg->mvars.push_back(child_mrg->mvars[i]); + new_mrg->fm[i]->set_range_var(node_suffix); + } + qp_node* new_node = split_nodes[0]->make_copy(suffix); + + if (new_node->node_type() == "spx_qpn") { + ((spx_qpn*)new_node)->table_name = new tablevar_t(host_name.c_str(), "IFACE", new_mrg->get_node_name().c_str()); + ((spx_qpn*)new_node)->table_name->set_range_var("_t0"); + } else { + ((sgah_qpn*)new_node)->table_name = new tablevar_t(host_name.c_str(), "IFACE", new_mrg->get_node_name().c_str()); + ((sgah_qpn*)new_node)->table_name->set_range_var("_t0"); + } + query_plan.push_back(new_mrg); + new_nodes.push_back(new_node); + } + + child_mrg->merge_fieldpos = merge_fieldpos; + if (split_nodes[0]->node_type() == "spx_qpn") + child_mrg->table_layout = create_attributes(child_mrg->get_node_name(), ((spx_qpn*)split_nodes[0])->select_list); + else + child_mrg->table_layout = create_attributes(child_mrg->get_node_name(), ((sgah_qpn*)split_nodes[0])->select_list); + + + // connect newly created nodes with parent multihost merge + for (i = 0; i < new_nodes.size(); ++i) { + if (new_nodes[i]->node_type() == "spx_qpn") + child_mrg->fm[i] = new tablevar_t(((spx_qpn*)new_nodes[i])->table_name->get_machine().c_str(), "IFACE", new_nodes[i]->get_node_name().c_str()); + else { + child_mrg->fm[i] = new tablevar_t(((sgah_qpn*)new_nodes[i])->table_name->get_machine().c_str(), "IFACE", new_nodes[i]->get_node_name().c_str()); + + } + child_mrg->mvars[i]->set_field(child_mrg->table_layout->get_field_name(merge_fieldpos)); + + sprintf(node_suffix, "_m%d", i); + child_mrg->fm[i]->set_range_var(node_suffix); + query_plan.push_back(new_nodes[i]); + } + child_mrg->fm.resize(new_nodes.size()); + child_mrg->mvars.resize(new_nodes.size()); + + // push the new high-level aggregation + query_plan.push_back(super_aggr); + + } + query_plan[index] = NULL; + generate_linkage(); + + } + +// Extract subtree rooted at node i into separate hfta +stream_query* stream_query::extract_subtree(int index) { + + vector nodes; + stream_query* new_query = new stream_query(query_plan[index], this); + + nodes.push_back(index); + for (int i = 0; i < nodes.size(); ++i) { + qp_node* node = query_plan[nodes[i]]; + if (!node) + continue; + + // add all children to nodes list + for (int j = 0; j < node->predecessors.size(); ++j) + nodes.push_back(node->predecessors[j]); + if (i) + new_query->query_plan.push_back(node); + + query_plan[nodes[i]] = NULL; + } + + return new_query; +} + +// Splits query that combines data from multiple hosts into separate hftas. +vector stream_query::split_multihost_query() { + + vector ret; + char node_suffix[128]; + int i; + + // find merges combining multiple hosts into per-host groups + int plan_size = query_plan.size(); + vector new_nodes; + + for (i = 0; i < plan_size; ++i) { + qp_node* node = query_plan[i]; + if (node && node->node_type() == "mrg_qpn") { + mrg_qpn* mrg = (mrg_qpn*)node; + if (mrg->is_multihost_merge()) { + + // group all the sources by host + map > host_map; + for (int j = 0; j < mrg->fm.size(); j++) { + tablevar_t *table_name = mrg->fm[j]; + if (host_map.count(table_name->get_machine())) + host_map[table_name->get_machine()].push_back(j); + else { + vector tables; + tables.push_back(j); + host_map[table_name->get_machine()] = tables; + } + } + + // create a new merge for each host + map >::iterator iter; + for (iter = host_map.begin(); iter != host_map.end(); iter++) { + string host_name = (*iter).first; + vector tables = (*iter).second; + + if (tables.size() == 1) + continue; + + sprintf(node_suffix, "_%s", host_name.c_str()); + string suffix(node_suffix); + untaboo(suffix); + mrg_qpn *new_mrg = (mrg_qpn *)mrg->make_copy(suffix); + for (int j = 0; j < tables.size(); ++j) { + new_mrg->fm.push_back(mrg->fm[tables[j]]); + new_mrg->mvars.push_back(mrg->mvars[j]); + sprintf(node_suffix, "m_%d", j); + new_mrg->fm[j]->set_range_var(node_suffix); + } + new_nodes.push_back(new_mrg); + } + + if (!new_nodes.empty()) { + // connect newly created merge nodes with parent multihost merge + for (int j = 0; j < new_nodes.size(); ++j) { + mrg->fm[j] = new tablevar_t(new_nodes[j]->fm[0]->get_machine().c_str(), "IFACE", new_nodes[j]->get_node_name().c_str()); + query_plan.push_back(new_nodes[j]); + } + mrg->fm.resize(new_nodes.size()); + mrg->mvars.resize(new_nodes.size()); + generate_linkage(); + } + + + // now externalize the sources + for (int j = 0; j < node->predecessors.size(); ++j) { + // Extract subtree rooted at node i into separate hfta + stream_query* q = extract_subtree(node->predecessors[j]); + if (q) { + q->generate_linkage(); + ret.push_back(q); + } + + } + generate_linkage(); + } + } + } + + return ret; +} + + +// Perform local FTA optimizations +void stream_query::optimize(vector& hfta_list, map lfta_names, vector interface_names, vector machine_names, ext_fcn_list *Ext_fcns, table_list *Schema, ifq_t *ifaces_db, partn_def_list_t *partn_parse_result){ + + // Topologically sort the nodes in query plan (leaf-first) + int i = 0, j = 0; + vector sorted_nodes; + + int num_nodes = query_plan.size(); + bool* leaf_flags = new bool[num_nodes]; + memset(leaf_flags, 0, num_nodes * sizeof(bool)); + + // run topological sort + bool done = false; + + // add all leafs to sorted_nodes + while (!done) { + done = true; + for (i = 0; i < num_nodes; ++i) { + if (!query_plan[i]) + continue; + + if (!leaf_flags[i] && query_plan[i]->predecessors.empty()) { + leaf_flags[i] = true; + sorted_nodes.push_back(i); + done = false; + + // remove the node from its parents predecessor lists + // since we only care about number of predecessors, it is sufficient just to remove + // one element from the parent's predecessors list + for (int j = query_plan[i]->successors.size() - 1; j >= 0; --j) + query_plan[query_plan[i]->successors[j]]->predecessors.pop_back(); + } + } + } + delete[] leaf_flags; + num_nodes = sorted_nodes.size(); + generate_linkage(); // rebuild the recently destroyed predecessor lists. + + // collect the information about interfaces nodes read from + for (i = 0; i < num_nodes; ++i) { + qp_node* node = query_plan[sorted_nodes[i]]; + vector input_tables = node->get_input_tbls(); + for (j = 0; j < input_tables.size(); ++j) { + tablevar_t * table = input_tables[j]; + if (lfta_names.count(table->schema_name)) { + int index = lfta_names[table->schema_name]; + table->set_machine(machine_names[index]); + table->set_interface(interface_names[index]); + } + } + } + + /* + + // push eligible operators down in the query plan + for (i = 0; i < num_nodes; ++i) { + if (partn_parse_result && is_partn_compatible(sorted_nodes[i], lfta_names, interface_names, machine_names, ifaces_db, partn_parse_result)) { + pushdown_partn_operator(sorted_nodes[i]); + } else if (is_pushdown_compatible(sorted_nodes[i], lfta_names, interface_names, machine_names)) { + pushdown_operator(sorted_nodes[i], Ext_fcns, Schema); + } + } + + // split the query into multiple hftas if it combines the data from multiple hosts + vector hftas = split_multihost_query(); + hfta_list.insert(hfta_list.end(), hftas.begin(), hftas.end()); + */ + + num_nodes = query_plan.size(); + // also split multi-way merges into two-way merges + for (i = 0; i < num_nodes; ++i) { + qp_node* node = query_plan[i]; + if (node && node->node_type() == "mrg_qpn") { + vector split_merge = ((mrg_qpn *)node)->split_sources(); + + query_plan.insert(query_plan.end(), split_merge.begin(), split_merge.end()); + // delete query_plan[sorted_nodes[i]]; + query_plan[i] = NULL; + } + } + + generate_linkage(); +} + + + +table_def *stream_query::get_output_tabledef(){ + return( query_plan[qhead]->get_fields() ); +} + + + +////////////////////////////////////////////////////////// +//// De-siloing. TO BE REMOVED + +void stream_query::desilo_lftas(map &lfta_names,vector &silo_names,table_list *Schema){ + int i,t,s; + + int suffix_len = silo_names.back().size(); + + for(i=0;i itbls = query_plan[qtail[i]]->get_input_tbls(); + for(t=0;tget_schema_name(); + if(lfta_names.count(itbl_name)>0){ +//printf("Query %s input %d references lfta input %s\n",query_plan[qtail[i]]->get_node_name().c_str(),t,itbl_name.c_str()); + vector src_names; + string lfta_base = itbl_name.substr(0,itbl_name.size()-suffix_len); + for(s=0;sget_node_name()+ + "_input_"+int_to_string(t); + mrg_qpn *merge_node = new mrg_qpn(merge_node_name,src_names,Schema); + int m_op_pos = Schema->add_table(merge_node->table_layout); + itbls[t]->set_schema(merge_node_name); + itbls[t]->set_schema_ref(m_op_pos); + query_plan.push_back(merge_node); + } + } + } + + generate_linkage(); +} +//////////////////////////////////////// +/// End de-siloing + + + +// Given a collection of LFTA stream queries, +// extract their WHERE predicates +// and pass them to an analysis routine which will extract +// common elements +// +void get_common_lfta_filter(std::vector lfta_list,table_list *Schema,ext_fcn_list *Ext_fcns, vector &prefilter_preds, set &pred_ids){ + int s; + std::vector< std::vector > where_list; + +// still safe to assume that LFTA queries have a single +// query node, which is at position 0. + for(s=0;s cnf_list = lfta_list[s]->query_plan[0]->get_filter_clause(); + if(lfta_list[s]->query_plan[0]->node_type() == "sgah_qpn"){ + gb_table *gtbl = ((sgah_qpn *)(lfta_list[s]->query_plan[0]))->get_gb_tbl(); + int c; + for(c=0;cpr,gtbl); + } + } + where_list.push_back(lfta_list[s]->query_plan[0]->get_filter_clause()); + } + + find_common_filter(where_list,Schema,Ext_fcns,prefilter_preds, pred_ids); +} + + + + + +// Given a collection of LFTA stream queries, +// extract the union of all temporal attributes referenced in select clauses +// those attributes will need to be unpacked in prefilter +// +void get_prefilter_temporal_cids(std::vector lfta_list, col_id_set &temp_cids){ + int s, sl; + vector sl_list; + gb_table *gb_tbl = NULL; + + +// still safe to assume that LFTA queries have a single +// query node, which is at position 0. + for(s=0;squery_plan[0]->node_type() == "spx_qpn"){ + spx_qpn *spx_node = (spx_qpn *)lfta_list[s]->query_plan[0]; + sl_list = spx_node->get_select_se_list(); + } + if(lfta_list[s]->query_plan[0]->node_type() == "sgah_qpn"){ + sgah_qpn *sgah_node = (sgah_qpn *)lfta_list[s]->query_plan[0]; + sl_list = sgah_node->get_select_se_list(); + gb_tbl = sgah_node->get_gb_tbl(); + } + + for(sl=0;slget_data_type(); + if (sdt->is_temporal()) { + gather_se_col_ids(sl_list[sl],temp_cids, gb_tbl); + } + } + } +} + + diff --git a/src/ftacmp/stream_query.h b/src/ftacmp/stream_query.h new file mode 100644 index 0000000..075d143 --- /dev/null +++ b/src/ftacmp/stream_query.h @@ -0,0 +1,170 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __STREAM_QUERY_H_ +#define __STREAM_QUERY_H_ + +#include +#include +#include + +#include"parse_schema.h" +#include"parse_fta.h" +#include"analyze_fta.h" +#include"query_plan.h" +#include"parse_partn.h" + + +class stream_query{ +public: +// query_plan contains the query nodes, which form a query tree (dag?) +// by linking to each other via indices into this vector. +// NOTE: there might be holes (NULLs) in this list due to shifting +// around operators for optimization. + std::vector query_plan; + std::vector output_specs; + vector output_operators; + + int qhead; + std::vector qtail; + + table_def *attributes; + param_table *parameters; + std::map defines; + std::string query_name; + + int n_parallel; // If the HFTA has been parallelized, # of copies. + int parallel_idx; // which of the cloned hftas this one is. + // needed for output splitting. + + int n_successors; // # of hftas which read from this one. + + int gid; // global id + +// For error reporting. + int error_code; + std::string err_str; + + stream_query(){ + error_code = 0; + attributes = NULL; + parameters = NULL; + }; + +// Create stream query for split-off lfta. +// The parent stream query provides annotations. + stream_query(qp_node *qnode, stream_query *parent); + +// Create stream query from analyzed parse tree. + stream_query(query_summary_class *qs,table_list *Schema); + +// Make a copy. + stream_query(stream_query &source); +// used after making the copy + void set_nparallel(int n, int i){n_parallel = n; parallel_idx = i;} + + qp_node *get_query_head(){return query_plan[qhead];}; + std::string get_sq_name(){return query_plan[qhead]->get_node_name();}; + +// Add a parse tree to the query plan. + stream_query *add_query(query_summary_class *qs,table_list *Schema); + stream_query *add_query(stream_query &sc); + + bool generate_linkage(); + int generate_plan(table_list *Schema); + + +// Create a map of fields to scalar expression in Protocol fields +// for each query node in the stream. For partitioning optimizations. + void generate_protocol_se(map &sq_map, table_list *Schema); + + +// Checks if the operator i is compatible with interface partitioning +// (can be pushed below the merge that combines partitioned stream) + bool is_partn_compatible(int i, map lfta_names, vector interface_names, vector machine_names, ifq_t *ifaces_db, partn_def_list_t *partn_parse_result); + +// Checks if the node i can be pushed below the merge + bool is_pushdown_compatible(int i, map lfta_names, vector interface_names, vector machine_names); + +// Push the operator below the merge that combines partitioned stream + void pushdown_partn_operator(int i); + +// Push the operator below the merge that combines regular (non-partitioned streams) + void pushdown_operator(int i, ext_fcn_list *Ext_fcns, table_list *Schema); + +// Splits query that combines data from multiple hosts into separate hftas + std::vector split_multihost_query(); + +// Extract subtree rooted at node i into separate hfta + stream_query* extract_subtree(int i); + +// Extract any external libraries needed by the oeprators in this hfta + void get_external_libs(std::set &libset); + + +// Perform local FTA optimizations + void optimize(vector& hfta_list, map lfta_names, vector interface_names, vector machine_names, ext_fcn_list *Ext_fcns, table_list *Schema, ifq_t *ifaces_db, partn_def_list_t *partn_parse_result); + + int get_error_code(){return error_code;}; + std::string get_error_str(){return err_str;}; + + void set_gid(int i){gid=i;}; + int get_gid(){return gid;}; + + + bool stream_input_only(table_list *Schema); + + std::vector get_input_tables(); + + table_def *get_output_tabledef(); + +// Extract lfta components of the query + std::vector split_query(ext_fcn_list *Ext_fcns, table_list *Schema, bool &hfta_returned, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx); + +// Process and register opertor views + std::vector extract_opview(table_list *Schema, std::vector &qnodes, opview_set &opviews, std::string silo_nm); + + std::string collect_refd_ifaces(); + +// The serialization function + std::string make_schema(); + std::string make_schema(int i); + +// hfta generation. Schema must contain the table_def's +// of all source tables (but extra tables will not hurt). + std::string generate_hfta(table_list *Schema, ext_fcn_list *Ext_fcns, opview_set &opviews, bool distributed_mode); + +// De-silo an hfta by replacing refs to lfta inputs with a +// merge over all silo'ed lftas. +// TO BE REMOVED +void desilo_lftas(std::map &lfta_names,std::vector &ifq_names,table_list *Schema); + +void add_output_operator(ospec_str *); + +private: +// Helper function for generate_hfta +void compute_node_format(int q, std::vector &nfmt, std::map &op_idx); + + + +}; + +/////////////////////////////////////////////////////////////////////// +//// Related functions +void get_common_lfta_filter(std::vector lfta_list,table_list *Schema,ext_fcn_list *Ext_fcns, std::vector &prefilter_preds, std::set &pred_ids); +void get_prefilter_temporal_cids(std::vector lfta_list, col_id_set &temp_cids); + + + +#endif diff --git a/src/ftacmp/test_interfacelib.cc b/src/ftacmp/test_interfacelib.cc new file mode 100644 index 0000000..1532142 --- /dev/null +++ b/src/ftacmp/test_interfacelib.cc @@ -0,0 +1,154 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include + +#include +#include + +#include "schemaparser.h" +#include "schemaparser_impl.h" + +// Interface to FTA definition lexer and parser ... + + +//double htonf(double f){return f;} +//long long int htonll(long long int l){return l;} + + +using namespace std; +extern int errno; + +// ./test_interfacelib test_param1.q_0.sch test_param4.q_1.sch + + + +int main(int argc, char **argv){ + int i; + char tmpstr[1000]; + void * pblock; + int block_size; + + if(argc < 2){ + fprintf(stderr,"Usage: %s schema_file [schema_file ... ]\n",argv[0]); + exit(1); + } + + int nfiles = argc-1; + int f; + for(f=0;f // for gethostname + +#include +#include "parse_fta.h" +#include "parse_schema.h" +#include "parse_ext_fcns.h" +#include"analyze_fta.h" +#include"query_plan.h" +#include"generate_lfta_code.h" +#include"stream_query.h" +#include"generate_utils.h" +#include"nic_def.h" +#include"generate_nic_code.h" + +#include +#include +#include + +#include + +// for the scandir + #include + #include + + +#include + +// to verify that some files exist. + #include + #include + +#include "parse_partn.h" + +#include "print_plan.h" + +// Interface to the xml parser + +#include"xml_t.h" +#include"field_list.h" + +extern int xmlParserparse(void); +extern FILE *xmlParserin; +extern int xmlParserdebug; + +std::vector xml_attr_vec; +std::vector xml_val_vec; +std::string xml_a, xml_v; +xml_t *xml_leaves = NULL; + +// Interface to the field list verifier +field_list *field_verifier = NULL; + +#define TMPSTRLEN 1000 + +#ifndef PATH_DELIM + #define PATH_DELIM '/' +#endif + +char tmp_schema_str[10000]; + +// maximum delay between two hearbeats produced +// by UDOP. Used when its not explicity +// provided in udop definition +#define DEFAULT_UDOP_LIVENESS_TIMEOUT 5 + +// Default lfta hash table size, must be power of 2. +int DEFAULT_LFTA_HASH_TABLE_SIZE = 4096; + +// Interface to FTA definition lexer and parser ... + +extern int FtaParserparse(void); +extern FILE *FtaParserin; +extern int FtaParserdebug; + +fta_parse_t *fta_parse_result; +var_defs_t *fta_parse_defines; + + + +// Interface to external function lexer and parser ... + +extern int Ext_fcnsParserparse(void); +extern FILE *Ext_fcnsParserin; +extern int Ext_fcnsParserdebug; + +ext_fcn_list *Ext_fcns; + + +// Interface to partition definition parser +extern int PartnParserparse(); +partn_def_list_t *partn_parse_result = NULL; + + + +using namespace std; +//extern int errno; + + +// forward delcaration of local utility function +void generate_makefile(vector &input_file_names, int nfiles, + vector &hfta_names, opview_set &opviews, + vector &machine_names, + string schema_file_name, + vector &interface_names, + ifq_t *ifdb, string &config_dir_path, + bool use_pads, + string extra_libs, + map > &rts_hload + ); + +//static int split_string(char *instr,char sep, char **words,int max_words); +#define MAXFLDS 100 + + FILE *schema_summary_output = NULL; // query names + +// Dump schema summary +void dump_summary(stream_query *str){ + fprintf(schema_summary_output,"%s\n",str->query_name.c_str()); + + table_def *sch = str->get_output_tabledef(); + + vector flds = sch->get_fields(); + int f; + for(f=0;f0) fprintf(schema_summary_output,"|"); + fprintf(schema_summary_output,"%s",flds[f]->get_name().c_str()); + } + fprintf(schema_summary_output,"\n"); + for(f=0;f0) fprintf(schema_summary_output,"|"); + fprintf(schema_summary_output,"%s",flds[f]->get_type().c_str()); + } + fprintf(schema_summary_output,"\n"); +} + +// Globals +string hostname; // name of current host. +int hostname_len; +bool generate_stats = false; +string root_path = "../.."; + + +int main(int argc, char **argv){ + char tmpstr[TMPSTRLEN]; + string err_str; + int q,s,h,f; + + set::iterator si; + + vector query_names; // for lfta.c registration + map > mach_query_names; // list queries of machine + vector snap_lengths; // for lfta.c registration + vector interface_names; // for lfta.c registration + vector machine_names; // machine of interface + vector lfta_reuse_options; // for lfta.c registration + vector lfta_liveness_timeouts; // fot qtree.xml generation + vector hfta_names; // hfta cource code names, for + // creating make file. + vector qnames; // ensure unique names + map lfta_names; // keep track of unique lftas. + + +// set these to 1 to debug the parser + FtaParserdebug = 0; + Ext_fcnsParserdebug = 0; + + FILE *lfta_out; // lfta.c output. + FILE *fta_in; // input file + FILE *table_schemas_in; // source tables definition file + FILE *query_name_output; // query names + FILE *qtree_output; // interconnections of query nodes + + // ------------------------------- + // Handling of Input Arguments + // ------------------------------- + char optstr[] = "BDpLC:l:HNQMf:PSh:n:cR:"; + const char *usage_str = "Usage: %s [-B] [-D] [-p] [-L] [-N] [-H] [-Q] [-M] [-C ] [-l ] [-f] [-P] [-S] [-n n_virtual_interfaces] [-h hostname] [-R root_path] [schema_file] input_file [input file ...]\n" + "\t[-B] : debug only (don't create output files)\n" + "\t[-D] : distributed mode (will use cluster.ifq instead of local .ifq file)\n" + "\t[-p] : partitioned mode (will use partition information in partition.txt to drive query optimization)\n" + "\t[-L] : use live_hosts.txt file to restrict queries to a set of live hosts\n" + "\t[-C] : use for definition files\n" + "\t[-l] : use for library queries\n" + "\t[-N] : output query names in query_names.txt\n" + "\t[-H] : create HFTA only (no schema_file)\n" + "\t[-Q] : use query name for hfta suffix\n" + "\t[-M] : generate make file and runit, stopit scripts\n" + "\t[-S] : enable LFTA statistics (alters Makefile).\n" + "\t[-f] : Output schema summary to schema_summary.txt\n" + "\t[-P] : link with PADS\n" + "\t[-h] : override host name.\n" + "\t[-c] : clean out Makefile and hfta_*.cc first.\n" + "\t[-R] : path to root of GS-lite\n" +; + +// parameters gathered from command line processing + string external_fcns_path; +// string internal_fcn_path; + string config_dir_path; + string library_path = "./"; + vector input_file_names; + string schema_file_name; + bool debug_only = false; + bool hfta_only = false; + bool output_query_names = false; + bool output_schema_summary=false; + bool numeric_hfta_flname = true; + bool create_makefile = false; + bool distributed_mode = false; + bool partitioned_mode = false; + bool use_live_hosts_file = false; + bool use_pads = false; + bool clean_make = false; + int n_virtual_interfaces = 1; + + char chopt; + while((chopt = getopt(argc,argv,optstr)) != -1){ + switch(chopt){ + case 'B': + debug_only = true; + break; + case 'D': + distributed_mode = true; + break; + case 'p': + partitioned_mode = true; + break; + case 'L': + use_live_hosts_file = true; + break; + case 'C': + if(optarg != NULL) + config_dir_path = string(optarg) + string("/"); + break; + case 'l': + if(optarg != NULL) + library_path = string(optarg) + string("/"); + break; + case 'N': + output_query_names = true; + break; + case 'Q': + numeric_hfta_flname = false; + break; + case 'H': + if(schema_file_name == ""){ + hfta_only = true; + } + break; + case 'f': + output_schema_summary=true; + break; + case 'M': + create_makefile=true; + break; + case 'S': + generate_stats=true; + break; + case 'P': + use_pads = true; + break; + case 'c': + clean_make = true; + break; + case 'h': + if(optarg != NULL) + hostname = optarg; + break; + case 'R': + if(optarg != NULL) + root_path = optarg; + break; + case 'n': + if(optarg != NULL){ + n_virtual_interfaces = atoi(optarg); + if(n_virtual_interfaces < 1 || n_virtual_interfaces > 128){ + fprintf(stderr,"Warning, %d virtual interfaces specified, valid values are between 1 and 128 inclusive\n",n_virtual_interfaces); + n_virtual_interfaces = 1; + } + } + break; + case '?': + fprintf(stderr,"Error, argument %c not recognized.\n",optopt); + fprintf(stderr,"%s\n", usage_str); + exit(1); + default: + fprintf(stderr, "Argument was %c\n", optopt); + fprintf(stderr,"Invalid arguments\n"); + fprintf(stderr,"%s\n", usage_str); + exit(1); + } + } + argc -= optind; + argv += optind; + for (int i = 0; i < argc; ++i) { + if((schema_file_name == "") && !hfta_only){ + schema_file_name = argv[i]; + }else{ + input_file_names.push_back(argv[i]); + } + } + + if(input_file_names.size() == 0){ + fprintf(stderr,"%s\n", usage_str); + exit(1); + } + + if(clean_make){ + string clean_cmd = "rm Makefile hfta_*.cc"; + int clean_ret = system(clean_cmd.c_str()); + if(clean_ret){ + fprintf(stderr,"Warning, return value %d when trying to clean out old source files.\n", clean_ret); + } + } + + + nic_prop_db *npdb = new nic_prop_db(config_dir_path); + +// Open globally used file names. + + // prepend config directory to schema file + schema_file_name = config_dir_path + schema_file_name; + external_fcns_path = config_dir_path + string("external_fcns.def"); + string ifx_fname = config_dir_path + string("ifres.xml"); + +// Find interface query file(s). + if(hostname == ""){ + gethostname(tmpstr,TMPSTRLEN); + hostname = tmpstr; + } + hostname_len = strlen(tmpstr); + string ifq_fname = config_dir_path + (distributed_mode ? "cluster" : hostname) + string(".ifq"); + vector ifq_fls; + + ifq_fls.push_back(ifq_fname); + + +// Get the field list, if it exists + string flist_fl = config_dir_path + "field_list.xml"; + FILE *flf_in = NULL; + if((flf_in = fopen(flist_fl.c_str(), "r")) != NULL) { + fprintf(stderr,"Found field list file %s\n",flist_fl.c_str()); + xml_leaves = new xml_t(); + xmlParser_setfileinput(flf_in); + if(xmlParserparse()){ + fprintf(stderr,"WARNING, could not parse field list file %s\n",flist_fl.c_str()); + }else{ + field_verifier = new field_list(xml_leaves); + } + } + + if(!hfta_only){ + if((table_schemas_in = fopen(schema_file_name.c_str(), "r")) == NULL) { + fprintf(stderr,"Can't open schema file %s\n%s\n",schema_file_name.c_str(),strerror(errno)); + exit(1); + } + } + +/* + if(!(debug_only || hfta_only)){ + if((lfta_out = fopen("lfta.c","w")) == NULL){ + fprintf(stderr,"Can't open output file %s\n%s\n","lfta.c",strerror(errno)); + exit(1); + } + } +*/ + +// Get the output specification file. +// format is +// query, operator, operator_param, directory, bucketwidth, partitioning_se, n_partitions + string ospec_fl = "output_spec.cfg"; + FILE *osp_in = NULL; + vector output_specs; + multimap qname_to_ospec; + if((osp_in = fopen(ospec_fl.c_str(), "r")) != NULL) { + char *flds[MAXFLDS]; + int o_lineno = 0; + while(fgets(tmpstr,TMPSTRLEN,osp_in)){ + o_lineno++; + int nflds = split_string(tmpstr,',',flds,MAXFLDS); + if(nflds == 7){ +// make operator type lowercase + char *tmpc; + for(tmpc=flds[1];*tmpc!='\0';++tmpc) + *tmpc = tolower(*tmpc); + + ospec_str *tmp_ospec = new ospec_str(); + tmp_ospec->query = flds[0]; + tmp_ospec->operator_type = flds[1]; + tmp_ospec->operator_param = flds[2]; + tmp_ospec->output_directory = flds[3]; + tmp_ospec->bucketwidth = atoi(flds[4]); + tmp_ospec->partitioning_flds = flds[5]; + tmp_ospec->n_partitions = atoi(flds[6]); + qname_to_ospec.insert(pair(tmp_ospec->query,output_specs.size())); + output_specs.push_back(tmp_ospec); + }else{ + fprintf(stderr,"Warning, line %d corrupted in output_spec.cfg, has %d fields.\n",o_lineno,nflds); + } + } + fclose(osp_in); + }else{ + fprintf(stderr,"output_spec.cfg not found. The query set has no output. exiting.\n"); + exit(1); + } + +// hfta parallelism + string pspec_fl = "hfta_parallelism.cfg"; + FILE *psp_in = NULL; + map hfta_parallelism; + if((psp_in = fopen(pspec_fl.c_str(), "r")) != NULL){ + char *flds[MAXFLDS]; + int o_lineno = 0; + while(fgets(tmpstr,TMPSTRLEN,psp_in)){ + bool good_entry = true; + o_lineno++; + int nflds = split_string(tmpstr,',',flds,MAXFLDS); + if(nflds == 2){ + string hname = flds[0]; + int par = atoi(flds[1]); + if(par <= 0 || par > n_virtual_interfaces){ + fprintf(stderr,"Warning, line %d of %s is incorrectly formatted, parallelism is %d, must be between 1 and %d\n",o_lineno,pspec_fl.c_str(),par,n_virtual_interfaces); + good_entry = false; + } + if(good_entry && n_virtual_interfaces % par != 0){ + fprintf(stderr,"Warning, line %d of %s is incorrectly formatted, parallelism is %d, must divide the number of virtual interfaces (%d), ignoring.\n",o_lineno,pspec_fl.c_str(),par,n_virtual_interfaces); + good_entry = false; + } + if(good_entry) + hfta_parallelism[hname] = par; + } + } + }else{ + fprintf(stderr,"WARNING, no file %s found, using single copies of hftas.\n",pspec_fl.c_str()); + } + + +// LFTA hash table sizes + string htspec_fl = "lfta_htsize.cfg"; + FILE *htsp_in = NULL; + map lfta_htsize; + if((htsp_in = fopen(htspec_fl.c_str(), "r")) != NULL){ + char *flds[MAXFLDS]; + int o_lineno = 0; + while(fgets(tmpstr,TMPSTRLEN,htsp_in)){ + bool good_entry = true; + o_lineno++; + int nflds = split_string(tmpstr,',',flds,MAXFLDS); + if(nflds == 2){ + string lfta_name = flds[0]; + int htsz = atoi(flds[1]); + if(htsz>0){ + lfta_htsize[lfta_name] = htsz; + }else{ + fprintf(stderr,"Warning, line %d of %s is incorrectly formatted, htsize is %d, must be larger than 0.\n",o_lineno,htspec_fl.c_str(),htsz); + } + } + } + }else{ + fprintf(stderr,"WARNING, no file %s found, using default LFTA hash table sizes.\n",htspec_fl.c_str()); + } + +// LFTA vitual interface hash split + string rtlspec_fl = "rts_load.cfg"; + FILE *rtl_in = NULL; + map > rts_hload; + if((rtl_in = fopen(rtlspec_fl.c_str(), "r")) != NULL){ + char *flds[MAXFLDS]; + int r_lineno = 0; + string iface_name; + vector hload; + while(fgets(tmpstr,TMPSTRLEN,rtl_in)){ + bool good_entry = true; + r_lineno++; + iface_name = ""; + hload.clear(); + int nflds = split_string(tmpstr,',',flds,MAXFLDS); + if(nflds >1){ + iface_name = flds[0]; + int cumm_h = 0; + int j; + for(j=1;j\n"); + fprintf(qtree_output,"\n"); + fprintf(qtree_output,"\n"); + + +// Get an initial Schema + table_list *Schema; + if(!hfta_only){ +// Parse the table schema definitions. + fta_parse_result = new fta_parse_t(); + FtaParser_setfileinput(table_schemas_in); + if(FtaParserparse()){ + fprintf(stderr,"Table schema parse failed.\n"); + exit(1); + } + if(fta_parse_result->parse_type != TABLE_PARSE){ + fprintf(stderr,"ERROR, file %s is not a table definition file.\n",schema_file_name.c_str()); + exit(1); + } + Schema = fta_parse_result->tables; + +// Process schema field inheritance + int retval; + retval = Schema->unroll_tables(err_str); + if(retval){ + fprintf(stderr,"Error processing schema filed inheritance:\n %s\n", err_str.c_str() ); + exit(1); + } + }else{ +// hfta only => we will try to fetch schemas from the registry. +// therefore, start off with an empty schema. + Schema = new table_list(); + } + + +// Open and parse the external functions file. + Ext_fcnsParserin = fopen(external_fcns_path.c_str(),"r"); + if(Ext_fcnsParserin == NULL){ + fprintf(stderr,"Warning, can't find external functions definition file (external_fcns.def).\n"); + Ext_fcns = new ext_fcn_list(); + }else{ + if(Ext_fcnsParserparse()){ + fprintf(stderr,"Warning, error parsing external functions definition file (external_fcns.def).\n"); + Ext_fcns = new ext_fcn_list(); + } + } + if(Ext_fcns->validate_fcns(err_str)){ + fprintf(stderr,"Error processing external functions definition file (external_fcns.def):\n%s\n",err_str.c_str()); + exit(1); + } + +// Open and parse the interface resources file. +// ifq_t *ifaces_db = new ifq_t(); +// string ierr; +// if(ifaces_db->load_ifaces(ifx_fname,use_live_hosts_file,distributed_mode,ierr)){ +// fprintf(stderr,"ERROR, can't load interface resource file %s :\n%s", +// ifx_fname.c_str(), ierr.c_str()); +// exit(1); +// } +// if(ifaces_db->load_ifqs(ifq_fname, ierr)){ +// fprintf(stderr,"ERROR, can't load interface query file %s :\n%s", +// ifq_fname.c_str(), ierr.c_str()); +// exit(1); +// } + + +// The LFTA code string. +// Put the standard preamble here. +// NOTE: the hash macros, fcns should go into the run time + map lfta_val; + map lfta_prefilter_val; + + string lfta_header = +"#include \n\n" +"#include \"rts.h\"\n" +"#include \"fta.h\"\n" +"#include \"lapp.h\"\n" +"#include \"rts_udaf.h\"\n\n" +/* +"#define IS_FILLED(bitmap,bucket) (bitmap[bucket >> 4] & (0x80000000 >> ((bucket & 15)<<1)))\n" +"#define IS_NEW(bitmap,bucket) (bitmap[bucket >> 4] & (0x80000000 >> (((bucket & 15) << 1) + 1)))\n" +"#define SET_EMPTY(bitmap,bucket) (bitmap[bucket >> 4] &= (~(0x80000000 >> ((bucket & 15)<<1))))\n" +"#define SET_FILLED_AND_NEW(bitmap,bucket) (bitmap[bucket >> 4] |= (0xC0000000 >> ((bucket & 15)<<1)))\n" +*/ +"\n" +"gs_uint64_t (*lfta_prefilter)(void *pkt) = NULL; // set at fta_init\n" +"\n" +"#define SLOT_FILLED 0x04\n" +"#define SLOT_GEN_BITS 0x03\n" +"#define SLOT_HASH_BITS 0xfffffff8\n" +"#define SET_BF_BIT(bf_table, bf_num, bf_index, bucket) (bf_table[(((bucket) * (bf_num)) + (bf_index)) >> 3] |= (0x80 >> ((((bucket) * (bf_num)) + (bf_index)) & 7)))\n" +"#define IS_BF_SET(bf_table, bf_num, bf_index, bucket) (bf_table[(((bucket) * (bf_num))+(bf_index)) >> 3] & (0x80 >> ((((bucket) * (bf_num))+(bf_index)) & 7)))\n" +"#define SET_BF_EMPTY(bf_table, bf_num, bf_index, bucket) (bf_table[((bucket * bf_num)+bf_index) >> 3] &= (~0x80 >> (((bucket * bf_num)+bf_index) & 7)))\n" +"\n\n" + +"#define lfta_BOOL_to_hash(x) (x)\n" +"#define lfta_USHORT_to_hash(x) (x)\n" +"#define lfta_UINT_to_hash(x) (x)\n" +"#define lfta_IP_to_hash(x) (x)\n" +"#define lfta_IPV6_to_hash(x) ( (x.v[0]) ^ (x.v[1]) ^ (x.v[2]) ^ (x.v[3]))\n" +"#define lfta_INT_to_hash(x) (gs_uint32_t)(x)\n" +"#define lfta_ULLONG_to_hash(x) ( (( (x) >>32)&0xffffffff) ^ ((x)&0xffffffff) )\n" +"#define lfta_LLONG_to_hash(x) ( (( (x) >>32)&0xffffffff) ^ ((x)&0xffffffff) )\n" +"#define lfta_FLOAT_to_hash(x) ( (( ((gs_uint64_t)(x)) >>32)&0xffffffff) ^ (((gs_uint64_t)(x))&0xffffffff) )\n" +"static gs_uint32_t lfta_V_STR_to_hash(struct gs_string x){\n" +" gs_uint32_t i,ret=0,tmp_sum = 0;\n" +" for(i=0;i > lfta_mach_lists; + int nfiles = input_file_names.size(); + vector hfta_list; // list of hftas. + map sq_map; // map from query name to stream query. + + +////////////////////////////////////////// + +// Open and parse the interface resources file. + ifq_t *ifaces_db = new ifq_t(); + string ierr; + if(ifaces_db->load_ifaces(ifx_fname,use_live_hosts_file,distributed_mode,ierr)){ + fprintf(stderr,"ERROR, can't load interface resource file %s :\n%s", + ifx_fname.c_str(), ierr.c_str()); + exit(1); + } + if(ifaces_db->load_ifqs(ifq_fls[0], ierr)){ + fprintf(stderr,"ERROR, can't load interface query file %s :\n%s", + ifq_fls[0].c_str(), ierr.c_str()); + exit(1); + } + + map qname_to_flname; // for detecting duplicate query names + + + +// Parse the files to create a vector of parse trees. +// Load qnodes with information to perform a topo sort +// based on query dependencies. + vector qnodes; // for topo sort. + map name_node_map; // map query name to qnodes entry + for(i=0;iparse_type != QUERY_PARSE){ + fprintf(stderr,"ERROR, file %s is not a query file.\n",input_file_names[i].c_str()); + exit(1); + } + +// returns a list of parse trees + vector qlist = fta_parse_result->parse_tree_list->qlist; + for(p=0;p0) + fta_parse_tree->set_visible(true); + else + fta_parse_tree->set_visible(false); + + +// Create a manipulable repesentation of the parse tree. +// the qnode inherits the visibility assigned to the parse tree. + int pos = qnodes.size(); + qnodes.push_back( new query_node(pos, imputed_qname, input_file_names[i], fta_parse_tree )); + name_node_map[ qnodes[pos]->name ] = pos; +//printf("name_node_map[ %s ] = %d\n",qnodes[pos]->name.c_str(),pos); +// qnames.push_back(impute_query_name(fta_parse_tree, qname_str)); +// qfiles.push_back(i); + +// Check for duplicate query names +// NOTE : in hfta-only generation, I should +// also check with the names of the registered queries. + if(qname_to_flname.count(qnodes[pos]->name) > 0){ + fprintf(stderr,"ERROR duplicate query name %s in files %s and %s.\n", + qnodes[pos]->name.c_str(), (qname_to_flname[qnodes[pos]->name]).c_str(), input_file_names[i].c_str()); + exit(1); + } + if(Schema->find_tbl(qnodes[pos]->name) >= 0){ + fprintf(stderr,"ERROR duplicate query name %s (file %s) was already defined as a PROTOCOL.\n", + qnodes[pos]->name.c_str(), input_file_names[i].c_str()); + exit(1); + } + qname_to_flname[qnodes[pos]->name] = input_file_names[i].c_str(); + + + } + } + +// Add the library queries + + int pos; + for(pos=0;posrefd_tbls.size();++fi){ + string src_tbl = qnodes[pos]->refd_tbls[fi]; + if(qname_to_flname.count(src_tbl) == 0){ + int last_sep = src_tbl.find_last_of('/'); + if(last_sep != string::npos){ +fprintf(stderr,"Finding library query %s for query %s\n",src_tbl.c_str(),qnodes[pos]->name.c_str()); + string target_qname = src_tbl.substr(last_sep+1); + string qpathname = library_path + src_tbl + ".gsql"; + if((fta_in = fopen(qpathname.c_str(), "r")) == NULL) { + fprintf(stderr,"Can't open library file %s, referenced by query %s in file %s\n\t%s\n",qpathname.c_str(),qnodes[pos]->name.c_str(), qname_to_flname[qnodes[pos]->name].c_str(), strerror(errno)); + exit(1); + fprintf(stderr,"After exit\n"); + } +fprintf(stderr,"Parsing file %s\n",qpathname.c_str()); +// Parse the FTA query + fta_parse_result = new fta_parse_t(); + FtaParser_setfileinput(fta_in); + if(FtaParserparse()){ + fprintf(stderr,"FTA parse failed.\n"); + exit(1); + } + if(fta_parse_result->parse_type != QUERY_PARSE){ + fprintf(stderr,"ERROR, file %s is not a query file.\n",input_file_names[i].c_str()); + exit(1); + } + + map local_query_map; + vector local_query_names; + vector qlist = fta_parse_result->parse_tree_list->qlist; + for(p=0;pset_visible(false); // assumed to not produce output + string imputed_qname = impute_query_name(fta_parse_tree, target_qname); + if(imputed_qname == target_qname) + imputed_qname = src_tbl; + if(local_query_map.count(imputed_qname)>0){ + fprintf(stderr,"ERROR, multiple queries named %s in library file %s\n",imputed_qname.c_str(), qpathname.c_str()); + exit(1); + } + local_query_map[ imputed_qname ] = p; + local_query_names.push_back(imputed_qname); + } + + if(local_query_map.count(src_tbl)==0){ + fprintf(stderr,"ERROR, library query file %s has no query named %s\n",qpathname.c_str(),target_qname.c_str()); + exit(1); + } + + vector worklist; + set added_queries; + vector new_qnodes; + worklist.push_back(local_query_map[target_qname]); + added_queries.insert(local_query_map[target_qname]); + int qq; + int qpos = qnodes.size(); + for(qq=0;qq refd_tbls = new_qnode->refd_tbls; + int ff; + for(ff = 0;ff0 && added_queries.count(local_query_map[refd_tbls[ff]])==0){ + + if(name_node_map.count(refd_tbls[ff])>0){ + fprintf(stderr,"ERROR, query %s occurs both in the regular query set, file %s, and in library file %s\n",refd_tbls[ff].c_str(), qname_to_flname[refd_tbls[ff]].c_str(), qpathname.c_str() ); + exit(1); + }else{ + worklist.push_back(local_query_map[refd_tbls[ff]]); + } + } + } + } + + for(qq=0;qqname ] = qpos; + qname_to_flname[qnodes[qpos]->name ] = qpathname; + } + } + } + } + } + + + + + + + + +//--------------------------------------- + + +// Add the UDOPS. + + string udop_missing_sources; + for(i=0;irefd_tbls.size();++fi){ + int sid = Schema->find_tbl(qnodes[i]->refd_tbls[fi]); + if(sid >= 0){ + if(Schema->get_schema_type(sid) == OPERATOR_VIEW_SCHEMA){ + if(name_node_map.count(qnodes[i]->refd_tbls[fi]) == 0){ + int pos = qnodes.size(); + qnodes.push_back( new query_node(pos, qnodes[i]->refd_tbls[fi], Schema)); + name_node_map[ qnodes[pos]->name ] = pos; + qnodes[pos]->is_externally_visible = false; // its visible + // Need to mark the source queries as visible. + int si; + string missing_sources = ""; + for(si=0;sirefd_tbls.size();++si){ + string src_tbl = qnodes[pos]->refd_tbls[si]; + if(name_node_map.count(src_tbl)==0){ + missing_sources += src_tbl + " "; + } + } + if(missing_sources != ""){ + udop_missing_sources += "\tUDOP "+qnodes[pos]->name+" references undefined tables "+missing_sources+"\n"; + } + } + } + } + } + } + if(udop_missing_sources != ""){ + fprintf(stderr,"ERROR, User Defined OPerators reference source tables that are not part of the query set:\n%s",udop_missing_sources.c_str()); + exit(1); + } + + + +//////////////////////////////////////////////////////////////////// +/// Check parse trees to verify that some +/// global properties are met : +/// if q1 reads from q2, then +/// q2 is processed before q1 +/// q1 can supply q2's parameters +/// Verify there is no cycle in the reads-from graph. + +// Compute an order in which to process the +// queries. + +// Start by building the reads-from lists. +// + + for(i=0;i refd_tbls = qnodes[i]->refd_tbls; + for(fi = 0;fi0){ +//printf("query %d (%s) reads from %s (%d)\n", i, qnodes[i]->name.c_str(),refd_tbls[fi].c_str(),name_node_map[refd_tbls[fi]]); + (qnodes[i]->reads_from).insert(name_node_map[refd_tbls[fi]]); + } + } + } + + +// If one query reads the result of another, +// check for parameter compatibility. Currently it must +// be an exact match. I will move to requiring +// containment after re-ordering, but will require +// some analysis for code generation which is not +// yet in place. +//printf("There are %d query nodes.\n",qnodes.size()); + + + for(i=0;i target_params = qnodes[i]->params; + for(si=qnodes[i]->reads_from.begin();si!=qnodes[i]->reads_from.end();++si){ + vector source_params = qnodes[(*si)]->params; + if(target_params.size() != source_params.size()){ + fprintf(stderr,"ERROR, query %s (in file %s) reads from %s (in file %s), but they do not have identical parameters.\n",qnodes[i]->name.c_str(), qnodes[i]->file.c_str(), qnodes[(*si)]->name.c_str(), qnodes[(*si)]->file.c_str()); + exit(1); + } + int p; + for(p=0;pname == source_params[p]->name && + target_params[p]->val == source_params[p]->val ) ){ + fprintf(stderr,"ERROR, query %s (in file %s) reads from %s (in file %s), but they do not have identical parameters.\n",qnodes[i]->name.c_str(), qnodes[i]->file.c_str(), qnodes[(*si)]->name.c_str(), qnodes[(*si)]->file.c_str()); + exit(1); + } + } + } + } + + +// Find the roots. +// Start by counting inedges. + for(i=0;ireads_from.begin();si!=qnodes[i]->reads_from.end();++si){ + qnodes[(*si)]->n_consumers++; + } + } + +// The roots are the nodes with indegree zero. + set roots; + for(i=0;in_consumers == 0){ + if(qnodes[i]->is_externally_visible == false){ + fprintf(stderr,"WARNING: query %s (file %s) is a root query but it isn't visible. Ignored.\n",qnodes[i]->name.c_str(), qnodes[i]->file.c_str()); + } + roots.insert(i); + } + } + +// Remove the parts of the subtree that produce no output. + set valid_roots; + set discarded_nodes; + set candidates; + while(roots.size() >0){ + for(si=roots.begin();si!=roots.end();++si){ + if(qnodes[(*si)]->is_externally_visible){ + valid_roots.insert((*si)); + }else{ + discarded_nodes.insert((*si)); + set::iterator sir; + for(sir=qnodes[(*si)]->reads_from.begin(); sir!=qnodes[(*si)]->reads_from.end();++sir){ + qnodes[(*sir)]->n_consumers--; + if(qnodes[(*sir)]->n_consumers == 0) + candidates.insert( (*sir)); + } + } + } + roots = candidates; + candidates.clear(); + } + roots = valid_roots; + if(discarded_nodes.size()>0){ + fprintf(stderr,"Warning, the following queries were discarded because they produce no output:\n"); + int di = 0; + for(si=discarded_nodes.begin();si!=discarded_nodes.end();++si){ + if(di>0 && (di%8)==0) fprintf(stderr,"\n"); + di++; + fprintf(stderr," %s",qnodes[(*si)]->name.c_str()); + } + fprintf(stderr,"\n"); + } + +// Compute the sources_to set, ignoring discarded nodes. + for(i=0;ireads_from.begin();si!=qnodes[i]->reads_from.end();++si){ + qnodes[(*si)]->sources_to.insert(i); + } + } + + +// Find the nodes that are shared by multiple visible subtrees. +// THe roots become inferred visible nodes. + +// Find the visible nodes. + vector visible_nodes; + for(i=0;iis_externally_visible){ + visible_nodes.push_back(i); + } + } + +// Find UDOPs referenced by visible nodes. + list workq; + for(i=0;i::iterator children; + if(qnodes[node]->is_udop && qnodes[node]->is_externally_visible == false){ + qnodes[node]->is_externally_visible = true; + visible_nodes.push_back(node); + for(children=qnodes[node]->reads_from.begin();children!=qnodes[node]->reads_from.end();++children){ + if(qnodes[(*children)]->is_externally_visible == false){ + qnodes[(*children)]->is_externally_visible = true; + visible_nodes.push_back((*children)); + } + } + } + for(children=qnodes[node]->reads_from.begin();children!=qnodes[node]->reads_from.end();++children){ + workq.push_back((*children)); + } + } + + bool done = false; + while(!done){ +// reset the nodes + for(i=0;isubtree_roots.clear(); + } + +// Walk the tree defined by a visible node, not descending into +// subtrees rooted by a visible node. Mark the node visited with +// the visible node ID. + for(i=0;i vroots; + vroots.insert(visible_nodes[i]); + while(vroots.size()>0){ + for(si=vroots.begin();si!=vroots.end();++si){ + qnodes[(*si)]->subtree_roots.insert(visible_nodes[i]); + + set::iterator sir; + for(sir=qnodes[(*si)]->reads_from.begin(); sir!=qnodes[(*si)]->reads_from.end();++sir){ + if(! qnodes[(*sir)]->is_externally_visible){ + candidates.insert( (*sir)); + } + } + } + vroots = candidates; + candidates.clear(); + } + } +// Find the nodes in multiple visible node subtrees, but with no parent +// that has is in multile visible node subtrees. Mark these as inferred visible nodes. + done = true; // until proven otherwise + for(i=0;isubtree_roots.size()>1){ + bool is_new_root = true; + set::iterator sir; + for(sir=qnodes[i]->sources_to.begin(); sir!=qnodes[i]->sources_to.end();++sir){ + if(qnodes[(*sir)]->subtree_roots.size()>1) + is_new_root = false; + } + if(is_new_root){ + qnodes[i]->is_externally_visible = true; + qnodes[i]->inferred_visible_node = true; + visible_nodes.push_back(i); + done = false; + } + } + } + } + + + + + +// get visible nodes in topo ordering. +// for(i=0;in_consumers = qnodes[i]->sources_to.size(); +// } + vector process_order; + while(roots.size() >0){ + for(si=roots.begin();si!=roots.end();++si){ + if(discarded_nodes.count((*si))==0){ + process_order.push_back( (*si) ); + } + set::iterator sir; + for(sir=qnodes[(*si)]->reads_from.begin(); sir!=qnodes[(*si)]->reads_from.end();++sir){ + qnodes[(*sir)]->n_consumers--; + if(qnodes[(*sir)]->n_consumers == 0) + candidates.insert( (*sir)); + } + } + roots = candidates; + candidates.clear(); + } + + +//printf("process_order.size() =%d\n",process_order.size()); + +// Search for cyclic dependencies + string found_dep; + for(i=0;in_consumers > 0){ + if(found_dep.size() != 0) found_dep += ", "; + found_dep += "query "+qnodes[i]->name+" (file "+qnodes[i]->file+")"; + } + } + if(found_dep.size()>0){ + fprintf(stderr,"ERROR, the following queries contain a cyclic reads-from dependency:\n%s\n",found_dep.c_str()); + exit(1); + } + +// Get a list of query sets, in the order to be processed. +// Start at visible root and do bfs. +// The query set includes queries referenced indirectly, +// as sources for user-defined operators. These are needed +// to ensure that they are added to the schema, but are not part +// of the query tree. + +// stream_node_sets contains queries reachable only through the +// FROM clause, so I can tell which queries to add to the stream +// query. (DISABLED, UDOPS are integrated, does this cause problems?) + +// NOTE: this code works because in order for data to be +// read by multiple hftas, the node must be externally visible. +// But visible nodes define roots of process sets. +// internally visible nodes can feed data only +// to other nodes in the same query file. +// Therefore, any access can be restricted to a file, +// hfta output sharing is done only on roots +// never on interior nodes. + + + + +// Conpute the base collection of hftas. + vector hfta_sets; + map hfta_name_map; +// vector< vector > process_sets; +// vector< set > stream_node_sets; + reverse(process_order.begin(), process_order.end()); // get listing in reverse order. + // i.e. process leaves 1st. + for(i=0;iis_externally_visible == true){ +//printf("Visible.\n"); + int root = process_order[i]; + hfta_node *hnode = new hfta_node(); + hnode->name = qnodes[root]-> name; + hnode->source_name = qnodes[root]-> name; + hnode->is_udop = qnodes[root]->is_udop; + hnode->inferred_visible_node = qnodes[root]->inferred_visible_node; + + vector proc_list; proc_list.push_back(root); +// Ensure that nodes are added only once. + set proc_set; proc_set.insert(root); + roots.clear(); roots.insert(root); + candidates.clear(); + while(roots.size()>0){ + for(si=roots.begin();si!=roots.end();++si){ +//printf("Processing root %d\n",(*si)); + set::iterator sir; + for(sir=qnodes[(*si)]->reads_from.begin(); sir!=qnodes[(*si)]->reads_from.end();++sir){ +//printf("reads fom %d\n",(*sir)); + if(qnodes[(*sir)]->is_externally_visible==false){ + candidates.insert( (*sir) ); + if(proc_set.count( (*sir) )==0){ + proc_set.insert( (*sir) ); + proc_list.push_back( (*sir) ); + } + } + } + } + roots = candidates; + candidates.clear(); + } + + reverse(proc_list.begin(), proc_list.end()); + hnode->query_node_indices = proc_list; + hfta_name_map[hnode->name] = hfta_sets.size(); + hfta_sets.push_back(hnode); + } + } + +// Compute the reads_from / sources_to graphs for the hftas. + + for(i=0;iquery_node_indices.size();q++){ + query_node *qnode = qnodes[hnode->query_node_indices[q]]; + for(s=0;srefd_tbls.size();++s){ + if(hfta_name_map.count(qnode->refd_tbls[s])){ + int other_hfta = hfta_name_map[qnode->refd_tbls[s]]; + hnode->reads_from.insert(other_hfta); + hfta_sets[other_hfta]->sources_to.insert(i); + } + } + } + } + +// Compute a topological sort of the hfta_sets. + + vector hfta_topsort; + workq.clear(); + int hnode_srcs[hfta_sets.size()]; + for(i=0;isources_to.size() == 0) + workq.push_back(i); + } + + while(! workq.empty()){ + int node = workq.front(); + workq.pop_front(); + hfta_topsort.push_back(node); + set::iterator stsi; + for(stsi=hfta_sets[node]->reads_from.begin();stsi!=hfta_sets[node]->reads_from.end();++stsi){ + int parent = (*stsi); + hnode_srcs[parent]++; + if(hnode_srcs[parent] == hfta_sets[parent]->sources_to.size()){ + workq.push_back(parent); + } + } + } + +// Decorate hfta nodes with the level of parallelism given as input. + + map::iterator msii; + for(msii=hfta_parallelism.begin();msii!=hfta_parallelism.end();++msii){ + string hfta_name = (*msii).first; + int par = (*msii).second; + if(hfta_name_map.count(hfta_name) > 0){ + hfta_sets[ hfta_name_map[hfta_name] ]->n_parallel = par; + }else{ + fprintf(stderr,"Warning, hfta_parallelism.cfg has an entry for %s, but its not a hfta.\n",hfta_name.c_str()); + } + } + +// Propagate levels of parallelism: children should have a level of parallelism +// as large as any of its parents. Adjust children upwards to compensate. +// Start at parents and adjust children, auto-propagation will occur. + + for(i=hfta_sets.size()-1;i>=0;i--){ + set::iterator stsi; + for(stsi=hfta_sets[i]->reads_from.begin();stsi!=hfta_sets[i]->reads_from.end();++stsi){ + if(hfta_sets[i]->n_parallel > hfta_sets[ (*stsi) ]->n_parallel){ + hfta_sets[ (*stsi) ]->n_parallel = hfta_sets[i]->n_parallel; + } + } + } + +// Before all the name mangling, check if therey are any output_spec.cfg +// or hfta_parallelism.cfg entries that do not have a matching query. + + string dangling_ospecs = ""; + for(msii=qname_to_ospec.begin();msii!=qname_to_ospec.end();++msii){ + string oq = (*msii).first; + if(hfta_name_map.count(oq) == 0){ + dangling_ospecs += " "+(*msii).first; + } + } + if(dangling_ospecs!=""){ + fprintf(stderr,"WARNING, the following entries in output_spec.cfg don't have a matching query: %s\n",dangling_ospecs.c_str()); + } + + string dangling_par = ""; + for(msii=hfta_parallelism.begin();msii!=hfta_parallelism.end();++msii){ + string oq = (*msii).first; + if(hfta_name_map.count(oq) == 0){ + dangling_par += " "+(*msii).first; + } + } + if(dangling_par!=""){ + fprintf(stderr,"WARNING, the following entries in hfta_parallelism.cfg don't have a matching query: %s\n",dangling_par.c_str()); + } + + + +// Replicate parallelized hftas. Do __copyX name mangling. Adjust +// FROM clauses: retarget any name which is an internal node, and +// any which is in hfta_sets (and which is parallelized). Add Merge nodes +// when the source hfta has more parallelism than the target node. +// Add new nodes to qnodes and hfta_nodes wth the appropriate linkages. + + + int n_original_hfta_sets = hfta_sets.size(); + for(i=0;in_parallel > 1){ + hfta_sets[i]->do_generation =false; // set the deletion flag for this entry. + set local_nodes; // names of query nodes in the hfta. + for(h=0;hquery_node_indices.size();++h){ + local_nodes.insert(qnodes[ hfta_sets[i]->query_node_indices[h] ]->name); + } + + for(p=0;pn_parallel;++p){ + string mangler = "__copy"+int_to_string(p); + hfta_node *par_hfta = new hfta_node(); + par_hfta->name = hfta_sets[i]->name + mangler; + par_hfta->source_name = hfta_sets[i]->name; + par_hfta->is_udop = hfta_sets[i]->is_udop; + par_hfta->inferred_visible_node = hfta_sets[i]->inferred_visible_node; + par_hfta->n_parallel = hfta_sets[i]->n_parallel; + par_hfta->parallel_idx = p; + + map par_qnode_map; // qnode name-to-idx, aids dependency tracking. + +// Is it a UDOP? + if(hfta_sets[i]->is_udop){ + int root = hfta_sets[i]->query_node_indices[0]; + + string unequal_par_sources; + set::iterator rfsii; + for(rfsii=hfta_sets[i]->reads_from.begin();rfsii!=hfta_sets[i]->reads_from.end();++rfsii){ + if(hfta_sets[(*rfsii)]->n_parallel != par_hfta->n_parallel){ + unequal_par_sources = hfta_sets[(*rfsii)]->name+" ("+int_to_string(hfta_sets[(*rfsii)]->n_parallel)+") "; + } + } + if(unequal_par_sources != ""){ + fprintf(stderr,"ERROR, UDOP %s has parallelism %d, but some of its sources have a different parallelism: %s\n",hfta_sets[i]->name.c_str(), hfta_sets[i]->n_parallel, unequal_par_sources.c_str()); + exit(1); + } + + int rti; + vector new_sources; + for(rti=0;rtirefd_tbls.size();++rti){ + new_sources.push_back(qnodes[root]->refd_tbls[rti]+mangler); + } + + query_node *new_qn = new query_node(qnodes.size(), qnodes[root]->name, Schema); + new_qn->name += mangler; + new_qn->mangler = mangler; + new_qn->refd_tbls = new_sources; + par_hfta->query_node_indices.push_back(qnodes.size()); + par_qnode_map[new_qn->name] = qnodes.size(); + name_node_map[ new_qn->name ] = qnodes.size(); + qnodes.push_back(new_qn); + }else{ +// regular query node + for(h=0;hquery_node_indices.size();++h){ + int hqn_idx = hfta_sets[i]->query_node_indices[h]; + table_exp_t *dup_pt = dup_table_exp(qnodes[hqn_idx]->parse_tree); +// rehome the from clause on mangled names. +// create merge nodes as needed for external sources. + for(f=0;ffm->tlist.size();++f){ + if(local_nodes.count(dup_pt->fm->tlist[f]->schema_name)>0){ + dup_pt->fm->tlist[f]->schema_name += mangler; + }else if(hfta_name_map.count(dup_pt->fm->tlist[f]->schema_name)>0){ +// Ref's an external HFTA. No parallelism => leave as is. Else, if level of parallelism of the two hftas is the same, rename by the mangler. Else, there mnust be more sources, so create a merge node. + int other_hidx = hfta_name_map[dup_pt->fm->tlist[f]->schema_name]; + if(par_hfta->n_parallel == hfta_sets[other_hidx]->n_parallel){ + dup_pt->fm->tlist[f]->schema_name += mangler; + }else{ + vector src_tbls; + int stride = hfta_sets[other_hidx]->n_parallel / par_hfta->n_parallel; + if(stride == 0){ + fprintf(stderr,"INTERNAL ERROR, parent hfta %s has a larger parallelism than its child %s\n",par_hfta->name.c_str(), hfta_sets[other_hidx]->name.c_str()); + exit(1); + } + for(s=0;sname+"__copy"+int_to_string(s+stride*p); + src_tbls.push_back(ext_src_name); + } + table_exp_t *merge_pt = table_exp_t::make_deferred_merge(src_tbls); + string merge_node_name = qnodes[hqn_idx]->name+"__copy"+int_to_string(p)+"__merge"+int_to_string(f); + dup_pt->fm->tlist[f]->schema_name = merge_node_name; +// Make a qnode to represent the new merge node + query_node *qn_pt = new query_node(qnodes.size(),merge_node_name, qnodes[hqn_idx]->file,merge_pt); + qn_pt->refd_tbls = src_tbls; + qn_pt->is_udop = false; + qn_pt->is_externally_visible = false; + qn_pt->inferred_visible_node = false; + par_hfta->query_node_indices.push_back(qnodes.size()); + par_qnode_map[merge_node_name] = qnodes.size(); + name_node_map[ merge_node_name ] = qnodes.size(); + qnodes.push_back(qn_pt); + } + } + } + query_node *new_qn = new query_node(qnodes.size(),qnodes[hqn_idx]->name+"__copy"+int_to_string(p),qnodes[hqn_idx]->file,dup_pt); + for(f=0;ffm->tlist.size();++f){ + new_qn->refd_tbls.push_back(dup_pt->fm->tlist[f]->schema_name); + } + new_qn->params = qnodes[hqn_idx]->params; + new_qn->is_udop = false; + new_qn->is_externally_visible = qnodes[hqn_idx]->is_externally_visible; + new_qn->inferred_visible_node = qnodes[hqn_idx]->inferred_visible_node; + par_hfta->query_node_indices.insert(par_hfta->query_node_indices.begin(),qnodes.size()); + par_qnode_map[new_qn->name] = qnodes.size(); + name_node_map[ new_qn->name ] = qnodes.size(); + qnodes.push_back(new_qn); + } + } + hfta_name_map[par_hfta->name] = hfta_sets.size(); + hfta_sets.push_back(par_hfta); + } + }else{ +// This hfta isn't being parallelized, but add merge nodes for any parallelized +// hfta sources. + if(!hfta_sets[i]->is_udop){ + for(h=0;hquery_node_indices.size();++h){ + int hqn_idx = hfta_sets[i]->query_node_indices[h]; + for(f=0;fparse_tree->fm->tlist.size();++f){ + if(hfta_name_map.count(qnodes[hqn_idx]->parse_tree->fm->tlist[f]->schema_name)>0){ +// Ref's an external HFTA. No parallelism => leave as is. Else, if level of parallelism of the two hftas is the same, rename by the mangler. Else, there mnust be more sources, so create a merge node. + int other_hidx = hfta_name_map[qnodes[hqn_idx]->parse_tree->fm->tlist[f]->schema_name]; + if(hfta_sets[i]->n_parallel != hfta_sets[other_hidx]->n_parallel){ + vector src_tbls; + for(s=0;sn_parallel;++s){ + string ext_src_name = hfta_sets[other_hidx]->name+"__copy"+int_to_string(s); + src_tbls.push_back(ext_src_name); + } + table_exp_t *merge_pt = table_exp_t::make_deferred_merge(src_tbls); + string merge_node_name = qnodes[hqn_idx]->name+"__merge"+int_to_string(f); + qnodes[hqn_idx]->parse_tree->fm->tlist[f]->schema_name = merge_node_name; +// Make a qnode to represent the new merge node + query_node *qn_pt = new query_node(qnodes.size(),merge_node_name, qnodes[hqn_idx]->file,merge_pt); + qn_pt->refd_tbls = src_tbls; + qn_pt->is_udop = false; + qn_pt->is_externally_visible = false; + qn_pt->inferred_visible_node = false; + hfta_sets[i]->query_node_indices.insert(hfta_sets[i]->query_node_indices.begin(),qnodes.size()); + name_node_map[ merge_node_name ] = qnodes.size(); + qnodes.push_back(qn_pt); + } + } + } + } + } + } + } + +// Rebuild the reads_from / sources_to lists in the qnodes + for(q=0;qreads_from.clear(); + qnodes[q]->sources_to.clear(); + } + for(q=0;qrefd_tbls.size();++s){ + if(name_node_map.count(qnodes[q]->refd_tbls[s])>0){ + int rf = name_node_map[qnodes[q]->refd_tbls[s]]; + qnodes[q]->reads_from.insert(rf); + qnodes[rf]->sources_to.insert(q); + } + } + } + +// Rebuild the reads_from / sources_to lists in hfta_sets + for(q=0;qreads_from.clear(); + hfta_sets[q]->sources_to.clear(); + } + for(q=0;qquery_node_indices.size();++s){ + int node = hfta_sets[q]->query_node_indices[s]; + set::iterator rfsii; + for(rfsii=qnodes[node]->reads_from.begin();rfsii!=qnodes[node]->reads_from.end();++rfsii){ + if(hfta_name_map.count(qnodes[(*rfsii)]->name)>0){ + hfta_sets[q]->reads_from.insert(hfta_name_map[qnodes[(*rfsii)]->name]); + hfta_sets[hfta_name_map[qnodes[(*rfsii)]->name]]->sources_to.insert(q); + } + } + } + } + +/* +for(q=0;qreads_from.size()); + set::iterator rsii; + for(rsii=qnodes[q]->reads_from.begin();rsii!=qnodes[q]->reads_from.end();++rsii) + printf(" %d",(*rsii)); + printf(", and sources-to %d:",qnodes[q]->sources_to.size()); + for(rsii=qnodes[q]->sources_to.begin();rsii!=qnodes[q]->sources_to.end();++rsii) + printf(" %d",(*rsii)); + printf("\n"); +} + +for(q=0;qdo_generation==false) + continue; + printf("hfta %d (%s) reads-from %d:",q,hfta_sets[q]->name.c_str(),hfta_sets[q]->reads_from.size()); + set::iterator rsii; + for(rsii=hfta_sets[q]->reads_from.begin();rsii!=hfta_sets[q]->reads_from.end();++rsii) + printf(" %d",(*rsii)); + printf(", and sources-to %d:",hfta_sets[q]->sources_to.size()); + for(rsii=hfta_sets[q]->sources_to.begin();rsii!=hfta_sets[q]->sources_to.end();++rsii) + printf(" %d",(*rsii)); + printf("\n"); +} +*/ + + + +// Re-topo sort the hftas + hfta_topsort.clear(); + workq.clear(); + int hnode_srcs_2[hfta_sets.size()]; + for(i=0;isources_to.size() == 0 && hfta_sets[i]->do_generation){ + workq.push_back(i); + } + } + + while(workq.empty() == false){ + int node = workq.front(); + workq.pop_front(); + hfta_topsort.push_back(node); + set::iterator stsii; + for(stsii=hfta_sets[node]->reads_from.begin();stsii!=hfta_sets[node]->reads_from.end();++stsii){ + int child = (*stsii); + hnode_srcs_2[child]++; + if(hnode_srcs_2[child] == hfta_sets[child]->sources_to.size()){ + workq.push_back(child); + } + } + } + +// Ensure that all of the query_node_indices in hfta_sets are topologically +// sorted, don't rely on assumptions that all transforms maintain some kind of order. + for(i=0;ido_generation){ + map n_accounted; + vector new_order; + workq.clear(); + vector::iterator vii; + for(vii=hfta_sets[i]->query_node_indices.begin();vii!=hfta_sets[i]->query_node_indices.end();++vii){ + n_accounted[(*vii)]= 0; + } + for(vii=hfta_sets[i]->query_node_indices.begin();vii!=hfta_sets[i]->query_node_indices.end();++vii){ + set::iterator rfsii; + for(rfsii=qnodes[(*vii)]->reads_from.begin();rfsii!=qnodes[(*vii)]->reads_from.end();++rfsii){ + if(n_accounted.count((*rfsii)) == 0){ + n_accounted[(*vii)]++; + } + } + if(n_accounted[(*vii)] == qnodes[(*vii)]->reads_from.size()){ + workq.push_back((*vii)); + } + } + + while(workq.empty() == false){ + int node = workq.front(); + workq.pop_front(); + new_order.push_back(node); + set::iterator stsii; + for(stsii=qnodes[node]->sources_to.begin();stsii!=qnodes[node]->sources_to.end();++stsii){ + if(n_accounted.count((*stsii))){ + n_accounted[(*stsii)]++; + if(n_accounted[(*stsii)] == qnodes[(*stsii)]->reads_from.size()){ + workq.push_back((*stsii)); + } + } + } + } + hfta_sets[i]->query_node_indices = new_order; + } + } + + + + + +/// Global checkng is done, start the analysis and translation +/// of the query parse tree in the order specified by process_order + + +// Get a list of the LFTAs for global lfta optimization +// TODO: separate building operators from spliting lftas, +// that will make optimizations such as predicate pushing easier. + vector lfta_list; + + stream_query *rootq; + + int qi,qj; + + for(qi=hfta_topsort.size()-1;qi>=0;--qi){ + + int hfta_id = hfta_topsort[qi]; + vector curr_list = hfta_sets[hfta_id]->query_node_indices; + + + +// Two possibilities, either its a UDOP, or its a collection of queries. +// if(qnodes[curr_list.back()]->is_udop) + if(hfta_sets[hfta_id]->is_udop){ + int node_id = curr_list.back(); + int udop_schref = Schema->find_tbl(qnodes[node_id]->file); + opview_entry *opv = new opview_entry(); + +// Many of the UDOP properties aren't currently used. + opv->parent_qname = "no_parent"; + opv->root_name = qnodes[node_id]->name; + opv->view_name = qnodes[node_id]->file; + opv->pos = qi; + sprintf(tmpstr,"%s_UDOP%d_%s",qnodes[node_id]->name.c_str(),qi,opv->view_name.c_str()); + opv->udop_alias = tmpstr; + opv->mangler = qnodes[node_id]->mangler; + + if(opv->mangler != ""){ + int new_udop_schref = Schema->add_duplicate_table(opv->view_name,opv->root_name); + Schema->mangle_subq_names(new_udop_schref,opv->mangler); + } + +// This piece of code makes each hfta which referes to the same udop +// reference a distinct running udop. Do this at query optimization time? +// fmtbl->set_udop_alias(opv->udop_alias); + + opv->exec_fl = Schema->get_op_prop(udop_schref, string("file")); + opv->liveness_timeout = atoi(Schema->get_op_prop(udop_schref, string("liveness_timeout")).c_str()); + + vector subq = Schema->get_subqueryspecs(udop_schref); + int s,f,q; + for(s=0;sname + opv->mangler; + vector flds = Schema->get_fields(subq_name); + if(flds.size() == 0){ + fprintf(stderr,"INTERNAL ERROR: the subquery %s of view %s not found in Schema.\n",subq_name.c_str(), opv->view_name.c_str()); + return(1); + } + if(flds.size() < sqs->types.size()){ + fprintf(stderr,"ERROR: subquery %s of view %s does not have enough fields (%lu found, %lu expected).\n",subq_name.c_str(), opv->view_name.c_str(),flds.size(), sqs->types.size()); + return(1); + } + bool failed = false; + for(f=0;ftypes.size();++f){ + data_type dte(sqs->types[f],sqs->modifiers[f]); + data_type dtf(flds[f]->get_type(),flds[f]->get_modifier_list()); + if(! dte.subsumes_type(&dtf) ){ + fprintf(stderr,"ERROR: subquery %s of view %s does not have the correct type for field %d (%s found, %s expected).\n",subq_name.c_str(), opv->view_name.c_str(),f,dtf.to_string().c_str(), dte.to_string().c_str()); + failed = true; + } +/* + if(dte.is_temporal() && (dte.get_temporal() != dtf.get_temporal()) ){ + string pstr = dte.get_temporal_string(); + fprintf(stderr,"ERROR: subquery %s of view %s does not have the expected temporal value %s of field %d.\n",sqs->name.c_str(), opv->view_name.c_str(),pstr.c_str(),f); + failed = true; + } +*/ + } + if(failed) + return(1); +/// Validation done, find the subquery, make a copy of the +/// parse tree, and add it to the return list. + for(q=0;qname == subq_name) + break; + if(q==qnodes.size()){ + fprintf(stderr,"INTERNAL ERROR: subquery %s of view %s not found in list of query names.\n",subq_name.c_str(), opv->view_name.c_str()); + return(1); + } + + } + +// Cross-link to from entry(s) in all sourced-to tables. + set::iterator sii; + for(sii=qnodes[curr_list.back()]->sources_to.begin() ;sii!=qnodes[curr_list.back()]->sources_to.end();++sii){ +//printf("\tUDOP %s sources_to %d (%s)\n",hfta_sets[hfta_id]->name.c_str(),(*sii),hfta_sets[(*sii)]->name.c_str()); + vector tblvars = qnodes[(*sii)]->parse_tree->get_from()->get_table_list(); + int ii; + for(ii=0;iischema_name == opv->root_name){ + tblvars[ii]->set_opview_idx(opviews.size()); + } + + } + } + + opviews.append(opv); + }else{ + +// Analyze the parse trees in this query, +// put them in rootq +// vector curr_list = process_sets[qi]; + + +//////////////////////////////////////// + + rootq = NULL; +//printf("Process set %d, has %d queries\n",qi,curr_list.size()); + for(qj=0;qjname.c_str(), qnodes[i]->file.c_str(),qnodes[i]->is_udop); + +// Select the current query parse tree + table_exp_t *fta_parse_tree = qnodes[i]->parse_tree; + +// if hfta only, try to fetch any missing schemas +// from the registry (using the print_schema program). +// Here I use a hack to avoid analyzing the query -- all referenced +// tables must be in the from clause +// If there is a problem loading any table, just issue a warning, +// + tablevar_list_t *fm = fta_parse_tree->get_from(); + vector refd_tbls = fm->get_src_tbls(Schema); +// iterate over all referenced tables + int t; + for(t=0;tget_table_ref(refd_tbls[t]); + + if(tbl_ref < 0){ // if this table is not in the Schema + + if(hfta_only){ + string cmd="print_schema "+refd_tbls[t]; + FILE *schema_in = popen(cmd.c_str(), "r"); + if(schema_in == NULL){ + fprintf(stderr,"ERROR: cannot execute command %s\n",cmd.c_str()); + }else{ + string schema_instr; + while(fgets(tmpstr,TMPSTRLEN,schema_in)){ + schema_instr += tmpstr; + } + fta_parse_result = new fta_parse_t(); + strcpy(tmp_schema_str,schema_instr.c_str()); + FtaParser_setstringinput(tmp_schema_str); + if(FtaParserparse()){ + fprintf(stderr,"FTA parse failed on result from command %s.\n",cmd.c_str()); + }else{ + if( fta_parse_result->tables != NULL){ + int tl; + for(tl=0;tltables->size();++tl){ + Schema->add_table(fta_parse_result->tables->get_table(tl)); + } + }else{ + fprintf(stderr,"ERROR command %s returned no tables.\n",cmd.c_str()); + } + } + } + }else{ + fprintf(stderr,"ERROR, query %s (file %s) references stream %s, which is neither a PROTOCOL nor an externally visible query stream.\n", qnodes[i]->name.c_str(), qnodes[i]->file.c_str(), refd_tbls[t].c_str()); + exit(1); + } + + } + } + + +// Analyze the query. + query_summary_class *qs = analyze_fta(fta_parse_tree, Schema, Ext_fcns, qnodes[i]->name); + if(qs == NULL){ + fprintf(stderr,"analyze_fta failed on query %s (file %s) \n",qnodes[i]->name.c_str(),qnodes[i]->file.c_str()); + exit(1); + } + + stream_query new_sq(qs, Schema); + if(new_sq.error_code){ + fprintf(stderr,"ERROR, can't create query node for query %s (file %s):\n%s\n",qnodes[i]->name.c_str(),qnodes[i]->file.c_str(),new_sq.err_str.c_str()); + exit(1); + } + +// Add it to the Schema + table_def *output_td = new_sq.get_output_tabledef(); + Schema->add_table(output_td); + +// Create a query plan from the analyzed parse tree. +// If its a query referneced via FROM, add it to the stream query. + if(rootq){ + rootq->add_query(new_sq); + }else{ + rootq = new stream_query(new_sq); +// have the stream query object inherit properties form the analyzed +// hfta_node object. + rootq->set_nparallel(hfta_sets[hfta_id]->n_parallel,hfta_sets[hfta_id]->parallel_idx); + rootq->n_successors = hfta_sets[hfta_id]->sources_to.size(); + } + + + } + +// This stream query has all its parts +// Build and optimize it. +//printf("translate_fta: generating plan.\n"); + if(rootq->generate_plan(Schema)){ + fprintf(stderr,"INTERNAL ERROR: Can't generate query plan for query %s.\n",rootq->query_name.c_str()); + continue; + } + +// If we've found the query plan head, so now add the output operators + if(qname_to_ospec.count(hfta_sets[hfta_id]->source_name)){ + pair< multimap::iterator, multimap::iterator > oset; + multimap::iterator mmsi; + oset = qname_to_ospec.equal_range(hfta_sets[hfta_id]->source_name); + for(mmsi=oset.first; mmsi!=oset.second; ++mmsi){ + rootq->add_output_operator(output_specs[(*mmsi).second]); + } + } + + + +// Perform query splitting if necessary. + bool hfta_returned; + vector split_queries = rootq->split_query(Ext_fcns, Schema, hfta_returned, ifaces_db, n_virtual_interfaces, hfta_sets[hfta_id]->n_parallel, hfta_sets[hfta_id]->parallel_idx); + + int l; +//for(l=0;lq`uery_name.c_str()); +//} + + + + + if(split_queries.size() > 0){ // should be at least one component. + +// Compute the number of LFTAs. + int n_lfta = split_queries.size(); + if(hfta_returned) n_lfta--; + + +// Process the LFTA components. + for(l=0;lquery_name) == 0){ +// Grab the lfta for global optimization. + vector tvec = split_queries[l]->query_plan[0]->get_input_tbls(); + string liface = tvec[0]->get_interface(); + string lmach = tvec[0]->get_machine(); + if (lmach == "") + lmach = hostname; + interface_names.push_back(liface); + machine_names.push_back(lmach); +//printf("Machine is %s\n",lmach.c_str()); + +// Set the ht size from the recommendation, if there is one in the rec file + if(lfta_htsize.count(split_queries[l]->query_name)>0){ + split_queries[l]->query_plan[0]->set_definition("aggregate_slots",int_to_string(lfta_htsize[split_queries[l]->query_name])); + } + + + lfta_names[split_queries[l]->query_name] = lfta_list.size(); + split_queries[l]->set_gid(lfta_list.size()); // set lfta global id + lfta_list.push_back(split_queries[l]); + lfta_mach_lists[lmach].push_back(split_queries[l]); + +// THe following is a hack, +// as I should be generating LFTA code through +// the stream_query object. + split_queries[l]->query_plan[0]->bind_to_schema(Schema); +// split_queries[l]->query_plan[0]->definitions = split_queries[l]->defines; + +/* +// Create query description to embed in lfta.c + string lfta_schema_str = split_queries[l]->make_schema(); + string lfta_schema_embed = make_C_embedded_string(lfta_schema_str); + +// get NIC capabilities. + int erri; + nic_property *nicprop = NULL; + vector iface_codegen_type = ifaces_db->get_iface_vals(lmach,liface,"iface_codegen_type",erri,err_str); + if(iface_codegen_type.size()){ + nicprop = npdb->get_nic_property(iface_codegen_type[0],erri); + if(!nicprop){ + fprintf(stderr,"ERROR cannot load nic properties %s for interface %s of machine %s for lfta codegen\n",iface_codegen_type[0].c_str(), liface.c_str(), lmach.c_str()); + exit(1); + } + } + + lfta_val[lmach] += generate_lfta_block(split_queries[l]->query_plan[0], Schema, split_queries[l]->get_gid(), Ext_fcns, lfta_schema_embed, ifaces_db,nicprop); +*/ + + snap_lengths.push_back(compute_snap_len(split_queries[l]->query_plan[0], Schema)); + query_names.push_back(split_queries[l]->query_name); + mach_query_names[lmach].push_back(query_names.size()-1); +// NOTE: I will assume a 1-1 correspondance between +// mach_query_names[lmach] and lfta_mach_lists[lmach] +// where mach_query_names[lmach][i] contains the index into +// query_names, which names the lfta, and +// mach_query_names[lmach][i] is the stream_query * of the +// corresponding lfta. +// Later, lfta_iface_qnames are the query names matching lfta_iface_lists + + + + // check if lfta is reusable + // FTA is reusable if reusable option is set explicitly or it doesn't have any parameters + + bool lfta_reusable = false; + if (split_queries[l]->query_plan[0]->get_val_of_def("reusable") == "yes" || + split_queries[l]->query_plan[0]->get_param_tbl()->size() == 0) { + lfta_reusable = true; + } + lfta_reuse_options.push_back(lfta_reusable); + + // LFTA will inherit the liveness timeout specification from the containing query + // it is too conservative as lfta are expected to spend less time per tuple + // then full query + + // extract liveness timeout from query definition + int liveness_timeout = atoi(split_queries[l]->query_plan[0]->get_val_of_def("liveness_timeout").c_str()); + if (!liveness_timeout) { +// fprintf(stderr, "WARNING: No liveness timeout specified for lfta %s, using default value of %d\n", +// split_queries[l]->query_name.c_str(), DEFAULT_UDOP_LIVENESS_TIMEOUT); + liveness_timeout = DEFAULT_UDOP_LIVENESS_TIMEOUT; + } + lfta_liveness_timeouts.push_back(liveness_timeout); + +// Add it to the schema + table_def *td = split_queries[l]->get_output_tabledef(); + Schema->append_table(td); +//printf("added lfta %d (%s)\n",l,split_queries[l]->query_name.c_str()); + + } + } + +// If the output is lfta-only, dump out the query name. + if(split_queries.size() == 1 && !hfta_returned){ + if(output_query_names ){ + fprintf(query_name_output,"%s L\n",split_queries[0]->query_name.c_str()); + } +/* +else{ + fprintf(stderr,"query name is %s\n",split_queries[0]->query_name.c_str()); + } +*/ + +/* +// output schema summary + if(output_schema_summary){ + dump_summary(split_queries[0]); + } +*/ + } + + + if(hfta_returned){ // query also has an HFTA component + int hfta_nbr = split_queries.size()-1; + + hfta_list.push_back(split_queries[hfta_nbr]); + +// report on generated query names + if(output_query_names){ + string hfta_name =split_queries[hfta_nbr]->query_name; + fprintf(query_name_output,"%s H\n",hfta_name.c_str()); + for(l=0;lquery_name; + fprintf(query_name_output,"%s L\n",lfta_name.c_str()); + } + } +// else{ +// fprintf(stderr,"query names are "); +// for(l=0;l0) fprintf(stderr,","); +// string fta_name =split_queries[l]->query_name; +// fprintf(stderr," %s",fta_name.c_str()); +// } +// fprintf(stderr,"\n"); +// } + } + + }else{ + fprintf(stderr,"ERROR, query in file %s has a bug.\n",qnodes[i]->file.c_str()); + fprintf(stderr,"%s\n",rootq->get_error_str().c_str()); + exit(1); + } + } +} + + +//----------------------------------------------------------------- +// Compute and propagate the SE in PROTOCOL fields compute a field. +//----------------------------------------------------------------- + +for(i=0;igenerate_protocol_se(sq_map, Schema); + sq_map[lfta_list[i]->get_sq_name()] = lfta_list[i]; +} +for(i=0;igenerate_protocol_se(sq_map, Schema); + sq_map[hfta_list[i]->get_sq_name()] = hfta_list[i]; +} + + + +//------------------------------------------------------------------------ +// Perform individual FTA optimizations +//----------------------------------------------------------------------- + +if (partitioned_mode) { + + // open partition definition file + string part_fname = config_dir_path + "partition.txt"; + + FILE* partfd = fopen(part_fname.c_str(), "r"); + if (!partfd) { + fprintf(stderr,"ERROR, unable to open partition definition file %s\n",part_fname.c_str()); + exit(1); + } + PartnParser_setfileinput(partfd); + if (PartnParserparse()) { + fprintf(stderr,"ERROR, unable to parse partition definition file %s\n",part_fname.c_str()); + exit(1); + } + fclose(partfd); +} + + +print_hftas("preopt_hfta_info.txt", hfta_list, lfta_names, query_names, interface_names); + +int num_hfta = hfta_list.size(); +for(i=0; i < hfta_list.size(); ++i){ + hfta_list[i]->optimize(hfta_list, lfta_names, interface_names, machine_names, Ext_fcns, Schema, ifaces_db, partn_parse_result); +} + +// Add all new hftas to schema +for(i=num_hfta; i < hfta_list.size(); ++i){ + table_def *td = hfta_list[i]->get_output_tabledef(); + Schema->append_table(td); +} + +print_hftas("postopt_hfta_info.txt", hfta_list, lfta_names, query_names, interface_names); + + + +//------------------------------------------------------------------------ +// Do global (cross-fta) optimization +//----------------------------------------------------------------------- + + + + + + +set extra_external_libs; + +for(i=0;iquery_name.c_str()); + hfta_names.push_back(tmpstr); + sprintf(tmpstr,"hfta_%s.cc",hfta_list[i]->query_name.c_str()); + } + FILE *hfta_fl = fopen(tmpstr,"w"); + if(hfta_fl == NULL){ + fprintf(stderr,"ERROR can't open fta output file %s\n",tmpstr); + exit(1); + } + fprintf(hfta_fl,"%s\n\n",hfta_list[i]->generate_hfta(Schema, Ext_fcns, opviews, distributed_mode).c_str()); + +// If there is a field verifier, warn about +// lack of compatability +// NOTE : this code assumes that visible non-lfta queries +// are those at the root of a stream query. + string hfta_comment; + string hfta_title; + string hfta_namespace; + if(hfta_list[i]->defines.count("comment")>0) + hfta_comment = hfta_list[i]->defines["comment"]; + if(hfta_list[i]->defines.count("Comment")>0) + hfta_comment = hfta_list[i]->defines["Comment"]; + if(hfta_list[i]->defines.count("COMMENT")>0) + hfta_comment = hfta_list[i]->defines["COMMENT"]; + if(hfta_list[i]->defines.count("title")>0) + hfta_title = hfta_list[i]->defines["title"]; + if(hfta_list[i]->defines.count("Title")>0) + hfta_title = hfta_list[i]->defines["Title"]; + if(hfta_list[i]->defines.count("TITLE")>0) + hfta_title = hfta_list[i]->defines["TITLE"]; + if(hfta_list[i]->defines.count("namespace")>0) + hfta_namespace = hfta_list[i]->defines["namespace"]; + if(hfta_list[i]->defines.count("Namespace")>0) + hfta_namespace = hfta_list[i]->defines["Namespace"]; + if(hfta_list[i]->defines.count("Namespace")>0) + hfta_namespace = hfta_list[i]->defines["Namespace"]; + + if(field_verifier != NULL){ + string warning_str; + if(hfta_comment == "") + warning_str += "\tcomment not found.\n"; + if(hfta_title == "") + warning_str += "\ttitle not found.\n"; + if(hfta_namespace == "") + warning_str += "\tnamespace not found.\n"; + + vector flds = hfta_list[i]->get_output_tabledef()->get_fields(); + int fi; + for(fi=0;fiverify_field(flds[fi]->get_name(),flds[fi]->get_type(),warning_str); + } + if(warning_str != "") + fprintf(stderr,"Warning, in HFTA stream %s:\n%s", + hfta_list[i]->get_output_tabledef()->get_tbl_name().c_str(),warning_str.c_str()); + } + + fprintf(qtree_output,"\t\n",hfta_list[i]->get_output_tabledef()->get_tbl_name().c_str()); + if(hfta_comment != "") + fprintf(qtree_output,"\t\t\n",hfta_comment.c_str()); + if(hfta_title != "") + fprintf(qtree_output,"\t\t\n",hfta_title.c_str()); + if(hfta_namespace != "") + fprintf(qtree_output,"\t\t<Namespace value='%s' />\n",hfta_namespace.c_str()); + fprintf(qtree_output,"\t\t<FileName value='%s' />\n",tmpstr); + fprintf(qtree_output,"\t\t<Rate value='100' />\n"); + +// write info about fields to qtree.xml + vector<field_entry *> flds = hfta_list[i]->get_output_tabledef()->get_fields(); + int fi; + for(fi=0;fi<flds.size();fi++){ + fprintf(qtree_output,"\t\t<Field name='%s' pos='%d' type='%s' ",flds[fi]->get_name().c_str(), fi, flds[fi]->get_type().c_str()); + if(flds[fi]->get_modifier_list()->size()){ + fprintf(qtree_output,"mods='%s' ", flds[fi]->get_modifier_list()->to_string().c_str()); + } + fprintf(qtree_output," />\n"); + } + + // extract liveness timeout from query definition + int liveness_timeout = atoi(hfta_list[i]->query_plan[hfta_list[i]->qhead]->get_val_of_def("liveness_timeout").c_str()); + if (!liveness_timeout) { +// fprintf(stderr, "WARNING: No liveness timeout specified for hfta %s, using default value of %d\n", +// hfta_list[i]->get_output_tabledef()->get_tbl_name().c_str(), DEFAULT_UDOP_LIVENESS_TIMEOUT); + liveness_timeout = DEFAULT_UDOP_LIVENESS_TIMEOUT; + } + fprintf(qtree_output,"\t\t<LivenessTimeout value='%d' />\n", liveness_timeout); + + vector<tablevar_t *> tmp_tv = hfta_list[i]->get_input_tables(); + int itv; + for(itv=0;itv<tmp_tv.size();++itv){ + fprintf(qtree_output,"\t\t<ReadsFrom value='%s' />\n",tmp_tv[itv]->get_schema_name().c_str()); + } + string ifrs = hfta_list[i]->collect_refd_ifaces(); + if(ifrs != ""){ + fprintf(qtree_output,"\t\t<Ifaces_referenced value='%s'/>\n",ifrs.c_str()); + } + fprintf(qtree_output,"\t</HFTA>\n"); + + fclose(hfta_fl); + }else{ +// debug only -- do code generation to catch generation-time errors. + hfta_list[i]->generate_hfta(Schema, Ext_fcns,opviews, distributed_mode); + } + + hfta_count++; // for hfta file names with numeric suffixes + + hfta_list[i]->get_external_libs(extra_external_libs); + + } + +string ext_lib_string; +set<string>::iterator ssi_el; +for(ssi_el=extra_external_libs.begin();ssi_el!=extra_external_libs.end();++ssi_el) + ext_lib_string += (*ssi_el)+" "; + + + +// Report on the set of operator views + for(i=0;i<opviews.size();++i){ + opview_entry *opve = opviews.get_entry(i); + fprintf(qtree_output,"\t<UDOP name='%s' >\n",opve->view_name.c_str()); + fprintf(qtree_output,"\t\t<FileName value='%s' />\n",opve->exec_fl.c_str()); + fprintf(qtree_output,"\t\t<Parent value='%s' />\n",opve->root_name.c_str()); + fprintf(qtree_output,"\t\t<Alias value='%s' />\n",opve->udop_alias.c_str()); + fprintf(qtree_output,"\t\t<Rate value='100' />\n"); + + if (!opve->liveness_timeout) { +// fprintf(stderr, "WARNING: No liveness timeout specified for view %s, using default value of %d\n", +// opve->view_name.c_str(), DEFAULT_UDOP_LIVENESS_TIMEOUT); + opve->liveness_timeout = DEFAULT_UDOP_LIVENESS_TIMEOUT; + } + fprintf(qtree_output,"\t\t<LivenessTimeout value='%d' />\n", opve->liveness_timeout); + int j; + for(j=0;j<opve->subq_names.size();j++) + fprintf(qtree_output,"\t\t<ReadsFrom value='%s' />\n",opve->subq_names[j].c_str()); + fprintf(qtree_output,"\t</UDOP>\n"); + } + + +//----------------------------------------------------------------- + +// Create interface-specific meta code files. +// first, open and parse the interface resources file. + ifaces_db = new ifq_t(); + ierr = ""; + if(ifaces_db->load_ifaces(ifx_fname,use_live_hosts_file,distributed_mode,ierr)){ + fprintf(stderr,"ERROR, can't load interface resource file %s :\n%s", + ifx_fname.c_str(), ierr.c_str()); + exit(1); + } + + map<string, vector<stream_query *> >::iterator svsi; + for(svsi=lfta_mach_lists.begin(); svsi!=lfta_mach_lists.end(); ++svsi){ + string lmach = (*svsi).first; + + // For this machine, create a set of lftas per interface. + vector<stream_query *> mach_lftas = (*svsi).second; + map<string, vector<stream_query *> > lfta_iface_lists; + int li; + for(li=0;li<mach_lftas.size();++li){ + vector<tablevar_t *> tvec = mach_lftas[li]->query_plan[0]->get_input_tbls(); + string lfta_iface = tvec[0]->get_interface(); + lfta_iface_lists[lfta_iface].push_back(mach_lftas[li]); + } + + map<string, vector<stream_query *> >::iterator lsvsi; + for(lsvsi=lfta_iface_lists.begin(); lsvsi!=lfta_iface_lists.end(); ++lsvsi){ + int erri; + string liface = (*lsvsi).first; + vector<stream_query *> iface_lftas = (*lsvsi).second; + vector<string> iface_codegen_type = ifaces_db->get_iface_vals(lmach,liface,"iface_codegen_type",erri,err_str); + if(iface_codegen_type.size()){ + nic_property *nicprop = npdb->get_nic_property(iface_codegen_type[0],erri); + if(!nicprop){ + fprintf(stderr,"ERROR cannot load nic properties %s for interface %s of machine %s\n",iface_codegen_type[0].c_str(), liface.c_str(), lmach.c_str()); + exit(1); + } + string mcs = generate_nic_code(iface_lftas, nicprop); + string mcf_flnm; + if(lmach != "") + mcf_flnm = lmach + "_"+liface+".mcf"; + else + mcf_flnm = hostname + "_"+liface+".mcf"; + FILE *mcf_fl ; + if((mcf_fl = fopen(mcf_flnm.c_str(),"w")) == NULL){ + fprintf(stderr,"Can't open output file %s\n%s\n",mcf_flnm.c_str(),strerror(errno)); + exit(1); + } + fprintf(mcf_fl,"%s",mcs.c_str()); + fclose(mcf_fl); +//printf("mcs of machine %s, iface %s of type %s is \n%s\n", +//lmach.c_str(), liface.c_str(),iface_codegen_type[0].c_str(), mcs.c_str()); + } + } + + + } + + + +//----------------------------------------------------------------- + + +// Find common filter predicates in the LFTAs. +// in addition generate structs to store the temporal attributes unpacked by prefilter + + map<string, vector<stream_query *> >::iterator ssqi; + for(ssqi=lfta_mach_lists.begin(); ssqi!=lfta_mach_lists.end(); ++ssqi){ + + string lmach = (*ssqi).first; + bool packed_return = false; + int li, erri; + + +// The LFTAs of this machine. + vector<stream_query *> mach_lftas = (*ssqi).second; +// break up on a per-interface basis. + map<string, vector<stream_query *> > lfta_iface_lists; + map<string, vector<int> > lfta_iface_qname_ix; // need the query name + // for fta_init + for(li=0;li<mach_lftas.size();++li){ + vector<tablevar_t *> tvec = mach_lftas[li]->query_plan[0]->get_input_tbls(); + string lfta_iface = tvec[0]->get_interface(); + lfta_iface_lists[lfta_iface].push_back(mach_lftas[li]); + lfta_iface_qname_ix[lfta_iface].push_back(mach_query_names[lmach][li]); + } + + +// Are the return values "packed"? +// This should be done on a per-interface basis. +// But this is defunct code for gs-lite + for(li=0;li<mach_lftas.size();++li){ + vector<tablevar_t *> tvec = mach_lftas[li]->query_plan[0]->get_input_tbls(); + string liface = tvec[0]->get_interface(); + vector<string> iface_codegen_type = ifaces_db->get_iface_vals(lmach,liface,"iface_codegen_type",erri,err_str); + if(iface_codegen_type.size()){ + if(npdb->get_nic_prop_val(iface_codegen_type[0],"Return",erri) == "Packed"){ + packed_return = true; + } + } + } + + +// Separate lftas by interface, collect results on a per-interface basis. + + vector<cnf_set *> no_preds; // fallback if there is no prefilter + map<string, vector<cnf_set *> > prefilter_preds; + set<unsigned int> pred_ids; // this can be global for all interfaces + for(auto mvsi=lfta_iface_lists.begin(); mvsi!=lfta_iface_lists.end(); ++mvsi){ + string liface = (*mvsi).first; + vector<cnf_set *> empty_list; + prefilter_preds[liface] = empty_list; + if(! packed_return){ + get_common_lfta_filter(lfta_iface_lists[liface], Schema,Ext_fcns, prefilter_preds[liface], pred_ids); + } + +// get NIC capabilities. (Is this needed?) + nic_property *nicprop = NULL; + vector<string> iface_codegen_type = ifaces_db->get_iface_vals(lmach,liface,"iface_codegen_type",erri,err_str); + if(iface_codegen_type.size()){ + nicprop = npdb->get_nic_property(iface_codegen_type[0],erri); + if(!nicprop){ + fprintf(stderr,"ERROR cannot load nic properties %s for interface %s of machine %s for lfta codegen\n",iface_codegen_type[0].c_str(), liface.c_str(), lmach.c_str()); + exit(1); + } + } + } + + +// Now that we know the prefilter preds, generate the lfta code. +// Do this for all lftas in this machine. + for(li=0;li<mach_lftas.size();++li){ + set<unsigned int> subsumed_preds; + set<unsigned int>::iterator sii; +#ifdef PREFILTER_OK + for(sii=pred_ids.begin();sii!=pred_ids.end();++sii){ + int pid = (*sii); + if((pid>>16) == li){ + subsumed_preds.insert(pid & 0xffff); + } + } +#endif + string lfta_schema_str = mach_lftas[li]->make_schema(); + string lfta_schema_embed = make_C_embedded_string(lfta_schema_str); + nic_property *nicprop = NULL; // no NIC properties? + lfta_val[lmach] += generate_lfta_block(mach_lftas[li]->query_plan[0], Schema, mach_lftas[li]->get_gid(), Ext_fcns, lfta_schema_embed, ifaces_db,nicprop,subsumed_preds); + } + + +// generate structs to store the temporal attributes +// unpacked by prefilter + col_id_set temp_cids; + get_prefilter_temporal_cids(lfta_mach_lists[lmach], temp_cids); + lfta_prefilter_val[lmach] = generate_lfta_prefilter_struct(temp_cids, Schema); + +// Compute the lfta bit signatures and the lfta colrefs +// do this on a per-interface basis +#ifdef PREFILTER_OK + lfta_prefilter_val[lmach] += "#define PREFILTER_DEFINED 1;\n\n"; +#endif + map<string, vector<long long int> > lfta_sigs; // used again later + for(auto mvsi=lfta_iface_lists.begin(); mvsi!=lfta_iface_lists.end(); ++mvsi){ + string liface = (*mvsi).first; + vector<long long int> empty_list; + lfta_sigs[liface] = empty_list; + + vector<col_id_set> lfta_cols; + vector<int> lfta_snap_length; + for(li=0;li<lfta_iface_lists[liface].size();++li){ + unsigned long long int mask=0, bpos=1; + int f_pos; + for(f_pos=0;f_pos<prefilter_preds[liface].size();++f_pos){ + if(prefilter_preds[liface][f_pos]->lfta_id.count(li)) + mask |= bpos; + bpos = bpos << 1; + } + lfta_sigs[liface].push_back(mask); + lfta_cols.push_back(lfta_iface_lists[liface][li]->query_plan[0]->get_colrefs(true,Schema)); + lfta_snap_length.push_back(compute_snap_len(lfta_iface_lists[liface][li]->query_plan[0], Schema)); + } + +//for(li=0;li<mach_lftas.size();++li){ +//printf("lfta %d, msak is %llu\n",li,lfta_sigs[li]); +//col_id_set::iterator tcisi; +//for(tcisi=lfta_cols[li].begin(); tcisi!=lfta_cols[li].end();++tcisi){ +//printf("\t%s %d (%d)\n",(*tcisi).field.c_str(),(*tcisi).schema_ref, (*tcisi).tblvar_ref); +//} +//} + + +// generate the prefilter +// Do this on a per-interface basis, except for the #define +#ifdef PREFILTER_OK +// lfta_prefilter_val[lmach] += "#define PREFILTER_DEFINED 1;\n\n"; + lfta_val[lmach] += generate_lfta_prefilter(prefilter_preds[liface], temp_cids, Schema, Ext_fcns, lfta_cols, lfta_sigs[liface], lfta_snap_length, liface); +#else + lfta_val[lmach] += generate_lfta_prefilter(no_preds, temp_cids, Schema,Ext_fcns, lfta_cols, lfta_sigs[liface], lfta_snap_length, liface); + +#endif + } + +// Generate interface parameter lookup function + lfta_val[lmach] += "// lookup interface properties by name\n"; + lfta_val[lmach] += "// mulitple values of given property returned in the same string separated by commas\n"; + lfta_val[lmach] += "// returns NULL if given property does not exist\n"; + lfta_val[lmach] += "gs_sp_t get_iface_properties (const gs_sp_t iface_name, const gs_sp_t property_name) {\n"; + +// collect a lit of interface names used by queries running on this host + set<std::string> iface_names; + for(i=0;i<mach_query_names[lmach].size();i++){ + int mi = mach_query_names[lmach][i]; + stream_query *lfta_sq = lfta_mach_lists[lmach][i]; + + if(interface_names[mi]=="") + iface_names.insert("DEFAULTDEV"); + else + iface_names.insert(interface_names[mi]); + } + +// generate interface property lookup code for every interface + set<std::string>::iterator sir; + for (sir = iface_names.begin(); sir != iface_names.end(); sir++) { + if (sir == iface_names.begin()) + lfta_val[lmach] += "\tif (!strcmp(iface_name, \"" + *sir + "\")) {\n"; + else + lfta_val[lmach] += "\t} else if (!strcmp(iface_name, \"" + *sir + "\")) {\n"; + + // iterate through interface properties + vector<string> iface_properties = ifaces_db->get_iface_properties(lmach,*sir,erri,err_str); + if (erri) { + fprintf(stderr,"ERROR cannot retrieve interface properties for %s.%s, %s\n",lmach.c_str(), sir->c_str(), err_str.c_str()); + exit(1); + } + if (iface_properties.empty()) + lfta_val[lmach] += "\t\treturn NULL;\n"; + else { + for (int i = 0; i < iface_properties.size(); ++i) { + if (i == 0) + lfta_val[lmach] += "\t\tif (!strcmp(property_name, \"" + iface_properties[i] + "\")) {\n"; + else + lfta_val[lmach] += "\t\t} else if (!strcmp(property_name, \"" + iface_properties[i] + "\")) {\n"; + + // combine all values for the interface property using comma separator + vector<string> vals = ifaces_db->get_iface_vals(lmach,*sir,iface_properties[i],erri,err_str); + for (int j = 0; j < vals.size(); ++j) { + lfta_val[lmach] += "\t\t\treturn \"" + vals[j]; + if (j != vals.size()-1) + lfta_val[lmach] += ","; + } + lfta_val[lmach] += "\";\n"; + } + lfta_val[lmach] += "\t\t} else\n"; + lfta_val[lmach] += "\t\t\treturn NULL;\n"; + } + } + lfta_val[lmach] += "\t} else\n"; + lfta_val[lmach] += "\t\treturn NULL;\n"; + lfta_val[lmach] += "}\n\n"; + + +// Generate a full list of FTAs for clearinghouse reference + lfta_val[lmach] += "// list of FTAs clearinghouse expects to register themselves\n"; + lfta_val[lmach] += "const gs_sp_t fta_names[] = {"; + + for (i = 0; i < query_names.size(); ++i) { + if (i) + lfta_val[lmach] += ", "; + lfta_val[lmach] += "\"" + query_names[i] + "\""; + } + for (i = 0; i < hfta_list.size(); ++i) { + lfta_val[lmach] += ", \"" + hfta_list[i]->query_name + "\""; + } + lfta_val[lmach] += ", NULL};\n\n"; + + +// Add the initialization function to lfta.c +// Change to accept the interface name, and +// set the prefilter function accordingly. +// see the example in demo/err2 + lfta_val[lmach] += "void fta_init(gs_sp_t device){\n"; + +// for(i=0;i<mach_query_names[lmach].size();i++) +// int mi = mach_query_names[lmach][i]; +// stream_query *lfta_sq = lfta_mach_lists[lmach][i]; + + for(auto mvsi=lfta_iface_lists.begin(); mvsi!=lfta_iface_lists.end(); ++mvsi){ + string liface = (*mvsi).first; + vector<stream_query *> lfta_list = (*mvsi).second; + for(i=0;i<lfta_list.size();i++){ + stream_query *lfta_sq = lfta_list[i]; + int mi = lfta_iface_qname_ix[liface][i]; + + fprintf(stderr,"interface %s, LFTA %d, snap length is %d\n",liface.c_str(),mi,snap_lengths[mi]); + + lfta_val[lmach] += "\tfta_register(\""+query_names[mi]+"\", " + (lfta_reuse_options[mi]?"1":"0") + ", "; + if(interface_names[mi]=="") + lfta_val[lmach]+="DEFAULTDEV"; + else + lfta_val[lmach]+='"'+interface_names[mi]+'"'; + + lfta_val[lmach] += ", "+generate_alloc_name(query_names[mi]) + +"\n#ifndef LFTA_IN_NIC\n\t,"+generate_schema_string_name(query_names[mi]) + +"\n#endif\n"; + sprintf(tmpstr,",%d",snap_lengths[mi]); + lfta_val[lmach] += tmpstr; + +// unsigned long long int mask=0, bpos=1; +// int f_pos; +// for(f_pos=0;f_pos<prefilter_preds.size();++f_pos){ +// if(prefilter_preds[f_pos]->lfta_id.count(i)) +// mask |= bpos; +// bpos = bpos << 1; +// } + +#ifdef PREFILTER_OK +// sprintf(tmpstr,",%lluull",mask); + sprintf(tmpstr,",%lluull",lfta_sigs[liface][i]); + lfta_val[lmach]+=tmpstr; +#else + lfta_val[lmach] += ",0ull"; +#endif + + lfta_val[lmach] += ");\n"; + + + +// End of lfta prefilter stuff +// -------------------------------------------------- + +// If there is a field verifier, warn about +// lack of compatability + string lfta_comment; + string lfta_title; + string lfta_namespace; + map<string,string> ldefs = lfta_sq->query_plan[0]->get_definitions(); + if(ldefs.count("comment")>0) + lfta_comment = lfta_sq->defines["comment"]; + if(ldefs.count("Comment")>0) + lfta_comment = lfta_sq->defines["Comment"]; + if(ldefs.count("COMMENT")>0) + lfta_comment = lfta_sq->defines["COMMENT"]; + if(ldefs.count("title")>0) + lfta_title = lfta_sq->defines["title"]; + if(ldefs.count("Title")>0) + lfta_title = lfta_sq->defines["Title"]; + if(ldefs.count("TITLE")>0) + lfta_title = lfta_sq->defines["TITLE"]; + if(ldefs.count("NAMESPACE")>0) + lfta_namespace = lfta_sq->defines["NAMESPACE"]; + if(ldefs.count("Namespace")>0) + lfta_namespace = lfta_sq->defines["Namespace"]; + if(ldefs.count("namespace")>0) + lfta_namespace = lfta_sq->defines["namespace"]; + + string lfta_ht_size; + if(lfta_sq->query_plan[0]->node_type()== "sgah_qpn" || lfta_sq->query_plan[0]->node_type()== "rsgah_qpn") + lfta_ht_size = int_to_string(DEFAULT_LFTA_HASH_TABLE_SIZE); + if(ldefs.count("aggregate_slots")>0){ + lfta_ht_size = ldefs["aggregate_slots"]; + } + +// NOTE : I'm assuming that visible lftas do not start with _fta. +// -- will fail for non-visible simple selection queries. + if(field_verifier != NULL && query_names[mi].substr(0,1) != "_"){ + string warning_str; + if(lfta_comment == "") + warning_str += "\tcomment not found.\n"; + if(lfta_title == "") + warning_str += "\ttitle not found.\n"; + if(lfta_namespace == "") + warning_str += "\tnamespace not found.\n"; + + vector<field_entry *> flds = lfta_sq->get_output_tabledef()->get_fields(); + int fi; + for(fi=0;fi<flds.size();fi++){ + field_verifier->verify_field(flds[fi]->get_name(),flds[fi]->get_type(),warning_str); + } + if(warning_str != "") + fprintf(stderr,"Warning, in LFTA stream %s:\n%s", + query_names[mi].c_str(),warning_str.c_str()); + } + + +// Create qtree output + fprintf(qtree_output,"\t<LFTA name='%s' >\n",query_names[mi].c_str()); + if(lfta_comment != "") + fprintf(qtree_output,"\t\t<Description value='%s' />\n",lfta_comment.c_str()); + if(lfta_title != "") + fprintf(qtree_output,"\t\t<Title value='%s' />\n",lfta_title.c_str()); + if(lfta_namespace != "") + fprintf(qtree_output,"\t\t<Namespace value='%s' />\n",lfta_namespace.c_str()); + if(lfta_ht_size != "") + fprintf(qtree_output,"\t\t<HtSize value='%s' />\n",lfta_ht_size.c_str()); + if(lmach != "") + fprintf(qtree_output,"\t\t<Host value='%s' />\n",lmach.c_str()); + else + fprintf(qtree_output,"\t\t<Host value='%s' />\n",hostname.c_str()); + fprintf(qtree_output,"\t\t<Interface value='%s' />\n",interface_names[mi].c_str()); + fprintf(qtree_output,"\t\t<ReadsFrom value='%s' />\n",interface_names[mi].c_str()); + fprintf(qtree_output,"\t\t<Rate value='100' />\n"); + fprintf(qtree_output,"\t\t<LivenessTimeout value='%d' />\n", lfta_liveness_timeouts[mi]); +// write info about fields to qtree.xml + vector<field_entry *> flds = lfta_sq->get_output_tabledef()->get_fields(); + int fi; + for(fi=0;fi<flds.size();fi++){ + fprintf(qtree_output,"\t\t<Field name='%s' pos='%d' type='%s' ",flds[fi]->get_name().c_str(), fi, flds[fi]->get_type().c_str()); + if(flds[fi]->get_modifier_list()->size()){ + fprintf(qtree_output,"mods='%s' ", flds[fi]->get_modifier_list()->to_string().c_str()); + } + fprintf(qtree_output," />\n"); + } + fprintf(qtree_output,"\t</LFTA>\n"); + + + } + } + + for(auto mvsi=lfta_iface_lists.begin(); mvsi!=lfta_iface_lists.end(); ++mvsi){ + string liface = (*mvsi).first; + lfta_val[lmach] += +" if (!strcmp(device, \""+liface+"\")) \n" +" lfta_prefilter = &lfta_prefilter_"+liface+"; \n" +; + } + lfta_val[lmach] += +" if(lfta_prefilter == NULL){\n" +" fprintf(stderr, \"Error, interface %s not found in fta_init.\\n\",device);\n" +" exit(1);\n" +" }\n" +; + + + + lfta_val[lmach] += "}\n\n"; + + if(!(debug_only || hfta_only) ){ + string lfta_flnm; + if(lmach != "") + lfta_flnm = lmach + "_lfta.c"; + else + lfta_flnm = hostname + "_lfta.c"; + if((lfta_out = fopen(lfta_flnm.c_str(),"w")) == NULL){ + fprintf(stderr,"Can't open output file %s\n%s\n","lfta.c",strerror(errno)); + exit(1); + } + fprintf(lfta_out,"%s",lfta_header.c_str()); + fprintf(lfta_out,"%s",lfta_prefilter_val[lmach].c_str()); + fprintf(lfta_out,"%s",lfta_val[lmach].c_str()); + fclose(lfta_out); + } + } + +// Say what are the operators which must execute + if(opviews.size()>0) + fprintf(stderr,"The queries use the following external operators:\n"); + for(i=0;i<opviews.size();++i){ + opview_entry *opv = opviews.get_entry(i); + fprintf(stderr,"\t%s\n",opv->view_name.c_str()); + } + + if(create_makefile) + generate_makefile(input_file_names, nfiles, hfta_names, opviews, + machine_names, schema_file_name, + interface_names, + ifaces_db, config_dir_path,use_pads,ext_lib_string, rts_hload); + + + fprintf(qtree_output,"</QueryNodes>\n"); + + return(0); +} + +//////////////////////////////////////////////////////////// + +void generate_makefile(vector<string> &input_file_names, int nfiles, + vector<string> &hfta_names, opview_set &opviews, + vector<string> &machine_names, + string schema_file_name, + vector<string> &interface_names, + ifq_t *ifdb, string &config_dir_path, + bool use_pads, + string extra_libs, + map<string, vector<int> > &rts_hload + ){ + int i,j; + + if(config_dir_path != ""){ + config_dir_path = "-C "+config_dir_path; + } + + struct stat sb; + bool libz_exists = stat((root_path+"/lib/libz.a").c_str(),&sb) >= 0; + bool libast_exists = stat((root_path+"/lib/libast.a").c_str(),&sb) >= 0; + +// if(libz_exists && !libast_exists){ +// fprintf(stderr,"Configuration ERROR: ../../lib/libz.a exists but ../../lib/libast.a dows not.\n"); +// exit(1); +// } + +// Get set of operator executable files to run + set<string> op_fls; + set<string>::iterator ssi; + for(i=0;i<opviews.size();++i){ + opview_entry *opv = opviews.get_entry(i); + if(opv->exec_fl != "") op_fls.insert(opv->exec_fl); + } + + FILE *outfl = fopen("Makefile", "w"); + if(outfl==NULL){ + fprintf(stderr,"Can't open Makefile for write, exiting.\n"); + exit(0); + } + + fputs( +("CPP= g++ -O3 -g -I "+root_path+"/include -I "+root_path+"/include/hfta\n" +"CC= gcc -O3 -g -I . -I "+root_path+"/include -I "+root_path+"/include/lfta" +).c_str(), outfl +); + if(generate_stats) + fprintf(outfl," -DLFTA_STATS"); + + fprintf(outfl, +"\n" +"\n" +"all: rts"); + for(i=0;i<hfta_names.size();++i) + fprintf(outfl," %s",hfta_names[i].c_str()); + fputs( +("\n" +"\n" +"rts: lfta.o "+root_path+"/lib/libgscphost.a "+root_path+"/lib/libgscplftaaux.a "+root_path+"/lib/libgscprts.a "+root_path+"/lib/libclearinghouse.a\n" +"\tg++ -O3 -g -o rts lfta.o ").c_str(), outfl); + if(use_pads) + fprintf(outfl,"-L. "); + fputs( +("-L"+root_path+"/lib -lgscplftaaux ").c_str(), outfl); + if(use_pads) + fprintf(outfl,"-lgscppads -lpads "); + fprintf(outfl, +"-lgscprts -lgscphost -lm -lgscpaux -lgscplftaaux -lclearinghouse -lresolv -lpthread -lgscpinterface -lz"); + if(use_pads) + fprintf(outfl, "-lpz -lz -lbz "); + if(libz_exists && libast_exists) + fprintf(outfl,"-last "); + if(use_pads) + fprintf(outfl, "-ldll -ldl "); + fprintf(outfl," -lgscpaux"); +#ifdef GCOV + fprintf(outfl," -fprofile-arcs"); +#endif + fprintf(outfl, +"\n" +"\n" +"lfta.o: %s_lfta.c\n" +"\t$(CC) -o lfta.o -c %s_lfta.c\n" +"\n" +"%s_lfta.c: external_fcns.def %s ",hostname.c_str(), hostname.c_str(), hostname.c_str(),schema_file_name.c_str()); + for(i=0;i<nfiles;++i) + fprintf(outfl," %s",input_file_names[i].c_str()); + if(hostname == ""){ + fprintf(outfl,"\n\t%s/bin/translate_fta %s %s ",root_path.c_str(), config_dir_path.c_str(),schema_file_name.c_str()); + }else{ + fprintf(outfl,"\n\t%s/bin/translate_fta -h %s %s %s ", root_path.c_str(), hostname.c_str(), config_dir_path.c_str(),schema_file_name.c_str()); + } + for(i=0;i<nfiles;++i) + fprintf(outfl," %s",input_file_names[i].c_str()); + fprintf(outfl,"\n"); + + for(i=0;i<hfta_names.size();++i) + fprintf(outfl, +("%s: %s.o\n" +"\t$(CPP) -o %s %s.o -L"+root_path+"/lib -lgscpapp -lgscphostaux -lgscphost -lgscpinterface -lgscphftaaux -lgscphostaux -lm -lgscpaux -lclearinghouse -lresolv -lpthread -lgscpaux -lgscphftaaux -lgscpaux %s\n" +"\n" +"%s.o: %s.cc\n" +"\t$(CPP) -o %s.o -c %s.cc\n" +"\n" +"\n").c_str(), + hfta_names[i].c_str(), hfta_names[i].c_str(), + hfta_names[i].c_str(), hfta_names[i].c_str(), extra_libs.c_str(), + hfta_names[i].c_str(), hfta_names[i].c_str(), + hfta_names[i].c_str(), hfta_names[i].c_str() + ); + + fprintf(outfl, +("\n" +"packet_schema.txt:\n" +"\tln -s "+root_path+"/cfg/packet_schema.txt .\n" +"\n" +"external_fcns.def:\n" +"\tln -s "+root_path+"/cfg/external_fcns.def .\n" +"\n" +"clean:\n" +"\trm -rf core rts *.o %s_lfta.c external_fcns.def packet_schema.txt").c_str(),hostname.c_str()); + for(i=0;i<hfta_names.size();++i) + fprintf(outfl," %s %s.cc",hfta_names[i].c_str(),hfta_names[i].c_str()); + fprintf(outfl,"\n"); + + fclose(outfl); + + + +// Gather the set of interfaces +// TODO : must update to hanndle machines +// TODO : lookup interface attributes and add them as a parameter to rts process + outfl = fopen("runit", "w"); + if(outfl==NULL){ + fprintf(stderr,"Can't open runit for write, exiting.\n"); + exit(0); + } + +// Gather the set of interfaces +// Also, gather "base interface names" for use in computing +// the hash splitting to virtual interfaces. +// TODO : must update to hanndle machines + set<string> ifaces; + set<string> base_vifaces; // base interfaces of virtual interfaces + map<string, string> ifmachines; + map<string, string> ifattrs; + for(i=0;i<interface_names.size();++i){ + ifaces.insert(interface_names[i]); + ifmachines[interface_names[i]] = machine_names[i]; + + size_t Xpos = interface_names[i].find_last_of("X"); + if(Xpos!=string::npos){ + string iface = interface_names[i].substr(0,Xpos); + base_vifaces.insert(iface); + } + // get interface attributes and add them to the list + } + + fputs( +("#!/bin/sh\n" +"./stopit\n" ++root_path+"/bin/gshub.py> /dev/null 2>&1 &\n" +"sleep 5\n" +"if [ ! -f gshub.log ]\n" +"then\n" +"\techo \"Failed to start bin/gshub.py\"\n" +"\texit -1\n" +"fi\n" +"ADDR=`cat gshub.log`\n" +"ps opgid= $! >> gs.pids\n" +"./rts $ADDR default ").c_str(), outfl); + int erri; + string err_str; + for(ssi=ifaces.begin();ssi!=ifaces.end();++ssi){ + string ifnm = (*ssi); + fprintf(outfl, "%s ",ifnm.c_str()); + vector<string> ifv = ifdb->get_iface_vals(ifmachines[ifnm],ifnm, "Command", erri, err_str); + for(j=0;j<ifv.size();++j) + fprintf(outfl, "%s ",ifv[j].c_str()); + } + fprintf(outfl, " &\n"); + fprintf(outfl, "echo $! >> gs.pids\n"); + for(i=0;i<hfta_names.size();++i) + fprintf(outfl,"./%s $ADDR default &\n",hfta_names[i].c_str()); + + for(j=0;j<opviews.opview_list.size();++j){ + fprintf(outfl,"%s/views/%s %s &\n",root_path.c_str(),opviews.opview_list[j]->exec_fl.c_str(), opviews.opview_list[j]->mangler.c_str()); + } + + fclose(outfl); + system("chmod +x runit"); + + outfl = fopen("stopit", "w"); + if(outfl==NULL){ + fprintf(stderr,"Can't open stopit for write, exiting.\n"); + exit(0); + } + + fprintf(outfl,"#!/bin/sh\n" +"rm -f gshub.log\n" +"if [ ! -f gs.pids ]\n" +"then\n" +"exit\n" +"fi\n" +"for pgid in `cat gs.pids`\n" +"do\n" +"kill -TERM -$pgid\n" +"done\n" +"sleep 1\n" +"for pgid in `cat gs.pids`\n" +"do\n" +"kill -9 -$pgid\n" +"done\n" +"rm gs.pids\n"); + + fclose(outfl); + system("chmod +x stopit"); + +//----------------------------------------------- + +/* For now disable support for virtual interfaces + outfl = fopen("set_vinterface_hash.bat", "w"); + if(outfl==NULL){ + fprintf(stderr,"Can't open set_vinterface_hash.bat for write, exiting.\n"); + exit(0); + } + +// The format should be determined by an entry in the ifres.xml file, +// but for now hardcode the only example I have. + for(ssi=base_vifaces.begin();ssi!=base_vifaces.end();++ssi){ + if(rts_hload.count((*ssi))){ + string iface_name = (*ssi); + string iface_number = ""; + for(j=iface_name.size()-1; j>0 && iface_number == ""; j--){ + if(isdigit(iface_name[j])){ + iface_number = iface_name[j]; + if(j>0 && isdigit(iface_name[j-1])) + iface_number = iface_name[j-1] + iface_number; + } + } + + fprintf(outfl,"dagconfig -d%s -S hat_range=",iface_number.c_str()); + vector<int> halloc = rts_hload[iface_name]; + int prev_limit = 0; + for(j=0;j<halloc.size();++j){ + if(j>0) + fprintf(outfl,":"); + fprintf(outfl,"%d-%d",prev_limit,halloc[j]); + prev_limit = halloc[j]; + } + fprintf(outfl,"\n"); + } + } + fclose(outfl); + system("chmod +x set_vinterface_hash.bat"); +*/ +} + +// Code for implementing a local schema +/* + table_list qpSchema; + +// Load the schemas of any LFTAs. + int l; + for(l=0;l<hfta_nbr;++l){ + stream_query *sq0 = split_queries[l]; + table_def *td = sq0->get_output_tabledef(); + qpSchema.append_table(td); + } +// load the schemas of any other ref'd tables. +// (e.g., hftas) + vector<tablevar_t *> input_tbl_names = split_queries[hfta_nbr]->get_input_tables(); + int ti; + for(ti=0;ti<input_tbl_names.size();++ti){ + int tbl_ref = qpSchema.get_table_ref(input_tbl_names[ti]->get_schema_name()); + if(tbl_ref < 0){ + tbl_ref = Schema->get_table_ref(input_tbl_names[ti]->get_schema_name()); + if(tbl_ref < 0){ + fprintf(stderr,"ERROR file %s references table %s, which is not in the schema.\n",input_file_names[i].c_str(), (input_tbl_names[ti]->get_schema_name()).c_str()); + exit(1); + } + qpSchema.append_table(Schema->get_table(tbl_ref)); + } + } +*/ + +// Functions related to parsing. + +/* +static int split_string(char *instr,char sep, char **words,int max_words){ + char *loc; + char *str; + int nwords = 0; + + str = instr; + words[nwords++] = str; + while( (loc = strchr(str,sep)) != NULL){ + *loc = '\0'; + str = loc+1; + if(nwords >= max_words){ + fprintf(stderr,"Error in split_string, too many words discovered (max is %d)\n",max_words); + nwords = max_words-1; + } + words[nwords++] = str; + } + + return(nwords); +} + +*/ + diff --git a/src/ftacmp/type_indicators.h b/src/ftacmp/type_indicators.h new file mode 100644 index 0000000..1160db1 --- /dev/null +++ b/src/ftacmp/type_indicators.h @@ -0,0 +1,37 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef _TYPE_INDICATORS_DEFINED__ +#define _TYPE_INDICATORS_DEFINED__ + +// WARNING! +// This file replicated in gscpv2/include +// These files must be synched! + +#define UINT_TYPE 0 +#define INT_TYPE 1 +#define ULLONG_TYPE 2 +#define LLONG_TYPE 3 +#define USHORT_TYPE 4 +#define FLOAT_TYPE 5 +#define BOOL_TYPE 6 +#define VSTR_TYPE 7 +#define TIMEVAL_TYPE 8 +#define IP_TYPE 9 +#define FSTRING_TYPE 10 +#define IPV6_TYPE 11 +#define UNDEFINED_TYPE 12 + +#endif + diff --git a/src/ftacmp/type_objects.cc b/src/ftacmp/type_objects.cc new file mode 100644 index 0000000..04f5c86 --- /dev/null +++ b/src/ftacmp/type_objects.cc @@ -0,0 +1,1903 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include"type_objects.h" + +#include <stdio.h> + +using namespace std; + +void data_type::assign_schema_type(){ + char tmps[100]; + switch(type){ + case bool_t: + schema_type = "BOOL"; + break; + case u_short_t: + schema_type = "USHORT"; + break; + case u_int_t: + schema_type = "UINT"; + break; + case int_t: + schema_type = "INT"; + break; + case u_llong_t: + schema_type = "ULLONG"; + break; + case llong_t: + schema_type = "LLONG"; + break; + case floating_t: + schema_type = "FLOAT"; + break; + case v_str_t: + schema_type = "V_STR"; + break; + case timeval_t: + schema_type = "TIMEVAL"; + break; + case ip_t: + schema_type = "IP"; + break; + case ipv6_t: + schema_type = "IPV6"; + break; + case fstring_t: + sprintf(tmps,"FSTRING%d",size); + schema_type = tmps; + break; + default: + schema_type = "UNDEFINED_TYPE"; + break; + } +} + + +data_type::data_type(string st){ + size=0; + temporal = varying_t; + subtype = ""; + assign_type_from_string(st); +} + + +// Assign data type of a colref using information about +// modifiers as well as data type. This should be made robust. +data_type::data_type(string st, param_list *modifiers){ + size=0; + temporal = varying_t; + subtype=""; + assign_type_from_string(st); + + if(modifiers != NULL){ + int i; + for(i=0;i<modifiers->size();i++){ + if( modifiers->contains_key("increasing") || + modifiers->contains_key("Increasing") || + modifiers->contains_key("INCREASING")){ + temporal = increasing_t; + } + if( modifiers->contains_key("decreasing") || + modifiers->contains_key("Decreasing") || + modifiers->contains_key("DECREASING")){ + temporal = decreasing_t; + } + if(modifiers->contains_key("subtype")){ + subtype = modifiers->val_of("subtype"); + } + } + } +} + + +void data_type::assign_type_from_string(string st){ + if(st == "bool" || st == "Bool" || st == "BOOL"){ + type = bool_t; + assign_schema_type(); + return; + } + if(st == "ushort" || st == "Ushort" || st == "USHORT"){ + type = u_short_t; + assign_schema_type(); + return; + } + if(st == "uint" || st == "Uint" || st == "UINT"){ + type = u_int_t; + assign_schema_type(); + return; + } + if(st == "int" || st == "Int" || st == "INT"){ + type = int_t; + assign_schema_type(); + return; + } + if(st == "ullong" || st == "Ullong" || st == "ULLONG"){ + type = u_llong_t; + assign_schema_type(); + return; + } + if(st == "llong" || st == "llong" || st == "LLONG"){ + type = llong_t; + assign_schema_type(); + return; + } + if(st == "float" || st == "Float" || st == "FLOAT"){ + type = floating_t; + assign_schema_type(); + return; + } + if(st == "string" || st == "String" || st == "STRING" || + st == "v_str" || st == "V_str" || st == "V_STR"){ + type = v_str_t; + assign_schema_type(); + return; + } + if(st == "timeval" || st == "Timeval" || st == "TIMEVAL"){ + type = timeval_t; + assign_schema_type(); + return; + } + if(st == "IP"){ + type = ip_t; + assign_schema_type(); + return; + } + if(st == "IPV6" || st == "IPv6"){ + type = ipv6_t; + assign_schema_type(); + return; + } + if(sscanf(st.c_str(),"fstring%d",&size)>0){ + type = fstring_t; + assign_schema_type(); + return; + } + if(sscanf(st.c_str(),"Fstring%d",&size)>0){ + type = fstring_t; + assign_schema_type(); + return; + } + if(sscanf(st.c_str(),"FSTRING%d",&size)>0){ + type = fstring_t; + assign_schema_type(); + return; + } + + type = undefined_t; + assign_schema_type(); +} + + +data_type::data_type(data_type *lhs, string &op){ + +// type = undefined_t; +// temporal_type l_tempo = lhs->get_temporal();; +// if(l_tempo == constant_t) temporal = constant_t; +// else temporal = varying_t; + size=0; + temporal = compute_temporal_type(lhs->get_temporal(),op); + + if(op == "-"){ + switch(lhs->get_type()){ + case int_t: + type = int_t; + break; + case u_int_t: + case u_short_t: + type = int_t; +// if(l_tempo == increasing_t) temporal = decreasing_t; +// if(l_tempo == decreasing_t) temporal = increasing_t; + break; + case u_llong_t: + case llong_t: + type = llong_t; +// if(l_tempo == increasing_t) temporal = decreasing_t; +// if(l_tempo == decreasing_t) temporal = increasing_t; + break; + case floating_t: + type = floating_t; +// if(l_tempo == increasing_t) temporal = decreasing_t; +// if(l_tempo == decreasing_t) temporal = increasing_t; + break; + default: + break; + } + } + + if(op == "!"){ + switch(lhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + case u_llong_t: + case llong_t: + case bool_t: + case ip_t: + type = lhs->get_type(); + break; + default: + break; + } + } + + if(op == "~"){ + switch(lhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + case u_llong_t: + case llong_t: + case ip_t: + type = lhs->get_type(); + break; + default: + break; + } + } + + subtype = lhs->subtype; + assign_schema_type(); +} + +temporal_type data_type::compute_temporal_type(temporal_type l_tempo, string &op){ + temporal_type ret; + + if(l_tempo == constant_t) ret = constant_t; + else ret = varying_t; + + if(op == "-"){ + if(l_tempo == increasing_t) ret = decreasing_t; + else if(l_tempo == decreasing_t) ret = increasing_t; + } + return ret; + +} + +data_type::data_type(data_type *lhs, data_type *rhs, const string &op){ + size=0; + + type = undefined_t; + dtype l_type = lhs->get_type(); + dtype r_type = rhs->get_type(); + +// First, deduce the type of the result. + if( (op=="-")||(op=="+")||(op=="/")||(op=="*")||(op=="%")||(op==">>")||(op=="<<") ){ + switch(lhs->get_type()){ + case u_short_t: + switch(rhs->get_type()){ + case u_short_t: + case u_int_t: + case int_t: + type = rhs->get_type(); + break; + case llong_t: + case u_llong_t: + if(op != ">>" && op != "<<") + type = rhs->get_type(); + break; + case floating_t: + if(op != "%" && op != ">>" && op != "<<") + type = floating_t; + break; + case timeval_t: + if(op == "+") type = timeval_t; + break; + default: + break; + } + break; + case u_int_t: + switch(rhs->get_type()){ + case u_short_t: + case int_t: + case u_int_t: + type = u_int_t; + break; + case llong_t: + case u_llong_t: + if(op != ">>" && op != "<<") + type = rhs->get_type(); + break; + case floating_t: + if(op != "%" && op != ">>" && op != "<<") + type = floating_t; + break; + case timeval_t: + if(op == "+") type = timeval_t; + break; + default: + break; + } + break; + case int_t: + switch(rhs->get_type()){ + case int_t: + case u_short_t: + type = int_t; + break; + case u_int_t: + type = rhs->get_type(); + break; + case llong_t: + case u_llong_t: + if(op != ">>" && op != "<<") + type = rhs->get_type(); + break; + case floating_t: + if(op != "%" && op != ">>" && op != "<<") + type = floating_t; + break; + case timeval_t: + if(op == "+") type = timeval_t; + break; + default: + break; + } + break; + case llong_t: + switch(rhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + type = llong_t; + break; + case llong_t: + if(op != ">>" && op != "<<") + type = llong_t; + break; + case u_llong_t: + if(op != ">>" && op != "<<") + type = u_llong_t; + break; + case floating_t: + if(op != "%" && op != ">>" && op != "<<") + type = floating_t; + break; + default: + break; + } + break; + case u_llong_t: + switch(rhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + type = u_llong_t; + break; + case u_llong_t: + case llong_t: + if(op != ">>" && op != "<<") + type = u_llong_t; + break; + case floating_t: + if(op != "%" && op != ">>" && op != "<<") + type = floating_t; + break; + default: + break; + } + break; + case floating_t: + if(op != "%" && op != ">>" && op != "<<"){ + switch(rhs->get_type()){ + case int_t: + case floating_t: + case u_int_t: + case u_short_t: + case llong_t: + case u_llong_t: + type = floating_t; + break; + default: + break; + } + } + break; + + case timeval_t: + switch(rhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + if(op == "+" || op == "-" || op == "/"){ + type = timeval_t; + } + break; + case timeval_t: + if(op == "-"){ + type = int_t; + } + break; + default: + break; + } + default: + break; + + } + } + + if( (op == "|") || (op == "&") ){ + switch(lhs->get_type()){ + case u_short_t: + switch(rhs->get_type()){ + case u_short_t: + case u_int_t: + case int_t: + case llong_t: + case u_llong_t: + type = rhs->get_type(); + break; + case bool_t: + type = bool_t; + break; + default: + break; + } + break; + case u_int_t: + switch(rhs->get_type()){ + case u_short_t: + case u_int_t: + case int_t: + type = u_int_t; + break; + case llong_t: + case u_llong_t: + type = rhs->get_type(); + break; + case bool_t: + type = bool_t; + break; + case ip_t: + type = ip_t; + break; + default: + break; + } + break; + case int_t: + switch(rhs->get_type()){ + case int_t: + case u_short_t: + type = int_t; + break; + case bool_t: + type = bool_t; + break; + case u_int_t: + case llong_t: + case u_llong_t: + type = rhs->get_type(); + break; + case ip_t: + type = ip_t; + break; + default: + break; + } + break; + case llong_t: + switch(rhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + case llong_t: + type = llong_t; + break; + case u_llong_t: + type = rhs->get_type(); + break; + case bool_t: + type = bool_t; + break; + default: + break; + } + break; + case u_llong_t: + switch(rhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + case llong_t: + case u_llong_t: + type = u_llong_t; + break; + case bool_t: + type = bool_t; + break; + default: + break; + } + break; + case bool_t: + switch(rhs->get_type()){ + case int_t: + case u_int_t: + case u_short_t: + case llong_t: + case u_llong_t: + case bool_t: + type = bool_t; + break; + default: + break; + } + break; + case ip_t: + switch(rhs->get_type()){ + case int_t: + case u_int_t: + case ip_t: + type = ip_t; + break; + default: + break; + } + break; + case ipv6_t: + if(rhs->get_type() == ipv6_t) + type = ipv6_t; + break; + default: + break; + } + } + assign_schema_type(); + temporal = compute_temporal_type(lhs->get_temporal(),rhs->get_temporal(),lhs->get_type(), rhs->get_type(), op); + if(lhs->subtype == rhs->subtype){ + subtype = lhs->subtype; + }else{ + subtype = ""; + } +} + + +temporal_type data_type::compute_temporal_type(temporal_type l_tempo, temporal_type r_tempo, dtype l_type, dtype r_type, const string &op){ + temporal_type ret; + +// Next, deduce the temporalness of the result. +// One complication : if the value of the RHS or LHS is +// negative, we can't deduce anything about the temporality +// of the result. + ret = varying_t; +// temporal_type l_tempo = lhs->get_temporal(); +// temporal_type r_tempo = rhs->get_temporal(); +// dtype l_type = lhs->get_type(); +// dtype r_type = rhs->get_type(); + + if(op == "+"){ + if(l_tempo == constant_t) ret = r_tempo; + if(r_tempo == constant_t) ret = l_tempo; + if(l_tempo == r_tempo) ret = r_tempo; + } + if(op == "-"){ + if(l_tempo == constant_t && r_tempo == constant_t) ret = constant_t; + if((l_tempo == constant_t || l_tempo ==decreasing_t) && + r_tempo == increasing_t && + (r_type != int_t && r_type != floating_t) ) ret = decreasing_t; + if((l_tempo == constant_t || l_tempo ==increasing_t) && + r_tempo == decreasing_t && + (r_type != int_t && r_type != floating_t) ) ret = increasing_t; + } + +// If the value might be negative, can't deduce anything +// However Java doesn't have unsigned types so the logic which forbids int has to be relaxed. + if(op == "*"){ +// if((l_type!=int_t && l_type!=floating_t && l_type!=llong_t) && (r_type!=int_t && r_type!=floating_t && r_type!=llong_t)){ + if(!((l_type==int_t || l_type==floating_t || l_type==llong_t) && (r_type==int_t || r_type==floating_t || r_type==llong_t))){ + if(l_tempo == constant_t) ret = r_tempo; + if(r_tempo == constant_t) ret = l_tempo; + if(l_tempo == r_tempo) ret = r_tempo; + } + } + if(op == "/"){ +// if((l_type!=int_t && l_type!=floating_t && l_type!=llong_t) && (r_type!=int_t && r_type!=floating_t && r_type!=llong_t)){ + if(!((l_type==int_t || l_type==floating_t || l_type==llong_t) && (r_type==int_t || r_type==floating_t || r_type==llong_t))){ + if((l_tempo == constant_t || l_tempo ==decreasing_t) && + (r_tempo == increasing_t)) ret = decreasing_t; + if((l_tempo == constant_t || l_tempo ==increasing_t) && + (r_tempo == decreasing_t )) ret = increasing_t; + if(r_tempo == constant_t) ret = l_tempo; + } + } + + return(ret); + +} + + +data_type *data_type::duplicate(){ + data_type *ret = new data_type(); + ret->schema_type = schema_type; + ret->size = size; + ret->type = type; + ret->temporal = temporal; + ret->subtype = subtype; + + return(ret); +} + +field_entry *data_type::make_field_entry(string n){ + field_entry *fe = new field_entry(n, schema_type); + if(temporal == increasing_t) + fe->add_modifier("INCREASING"); + if(temporal == decreasing_t) + fe->add_modifier("DECREASING"); + if(subtype != "") fe->add_modifier("subtype",subtype.c_str()); + return fe; +} + +bool data_type::fta_legal_operation( + data_type *lhs, data_type *rhs, string &op){ + + dtype l_type = lhs->get_type(); + dtype r_type = rhs->get_type(); + + +// Currently, anything goes. Should be controlled by +// a config file. + + return(true); + +// Only +, -, *, /, |, & are legal in the fta. +// The only ops on a llong or ullong are +, - +// no ops on float, timeval permitted, but these +// are illegal data types in the FTA and are handled elsewhere. + + if(!( (op == "-") || (op == "+") || (op == "/") || (op == "*") || (op == "|") || (op == "&"))) + return(false); + + if( (l_type == llong_t) || (l_type == u_llong_t) || (r_type == llong_t) || (r_type == u_llong_t)){ + if(op == "*" || op == "/") + return(false); + } + + return(true); + +} + + +bool data_type::fta_legal_operation(data_type *lhs, string &op){ + + +// negation and not are as legal at the fta on all fta-legal types +// as at the user level. + return(true); +} + +bool data_type::fta_legal_type(){ + +// Currently, anything goes. +// Should control by a config file. +// Currently, only the float and the timeval are not legal at the fta. +// if(type == floating_t || type == timeval_t) return(false); + + return(true); +} + + +// The data type of a literal + +data_type::data_type(int it){ + temporal = constant_t; + subtype = ""; + switch(it){ + case LITERAL_INT: + type = u_int_t; + break; + case LITERAL_LONGINT: + type = u_llong_t; + break; + case LITERAL_FLOAT: + type = floating_t; + break; + case LITERAL_STRING: + type = v_str_t; + break; + case LITERAL_BOOL: + type = bool_t; + break; + case LITERAL_TIMEVAL: + type = timeval_t; + break; + case LITERAL_IP: + type = ip_t; + break; + case LITERAL_IPV6: + type = ipv6_t; + break; + default: + type = undefined_t; + break; + } + + assign_schema_type(); +} + +void data_type::set_aggr_data_type(const string &op, data_type *dt){ + dtype se_type = dt->type; + type = undefined_t; + temporal = varying_t; + + if(op == "AVG"){ + if((se_type == u_int_t)||(se_type == u_short_t)||(se_type == int_t)|| + (se_type == u_llong_t)||(se_type == llong_t)||(se_type == floating_t)) + type = floating_t; + } + + + if(op == "SUM"){ + if((se_type == u_int_t) || (se_type == u_short_t) || (se_type == bool_t)) + type = u_int_t; + if((se_type == int_t) || (se_type == u_llong_t) || + (se_type == llong_t) || (se_type == floating_t) ) + type = se_type; +// temporal = dt->temporal; // temporal not preserved by sum. + subtype = dt->subtype; + } + if(op == "MIN" || op == "MAX"){ + type = se_type; +// temporal = dt->temporal; // temporal not preserved by min or max. + subtype = dt->subtype; + } + if(op == "AND_AGGR" || op == "OR_AGGR" || op == "XOR_AGGR"){ + if( (se_type == u_int_t) || (se_type == u_short_t) || + (se_type == int_t) || (se_type == llong_t) || + (se_type == u_llong_t) || (se_type == bool_t) ) + type = se_type; + subtype = dt->subtype; + } + assign_schema_type(); +} + + + + +bool data_type::is_comparable(data_type *rhs, string op){ + + switch(type){ + case u_short_t: + case int_t: + case u_int_t: + case u_llong_t: + case llong_t: + case floating_t: + case ip_t: + switch(rhs->type){ + case int_t: + case floating_t: + case u_short_t: + case u_int_t: + case u_llong_t: + case llong_t: + case ip_t: + return(true); + default: + return(false); + } + + case v_str_t: + switch(rhs->type){ + case v_str_t: + return(true); + default: + return(false); + } + + case bool_t: + switch(rhs->type){ + case bool_t: + return(true); + default: + return(false); + } + case timeval_t: + switch(rhs->type){ + case timeval_t: + return(true); + default: + return(false); + } + case ipv6_t: + if(rhs->type == ipv6_t) + return true; + else + return false; + default: + return(false); + } + + return(false); +} + + +// type string to get val from pass-by-ref fcn. +// (Does not seem to be used ?) +string data_type::get_CC_accessor_type(){ + switch(type){ + case int_t: + return("gs_int32_t *"); + case bool_t: + case u_short_t: + case u_int_t: + case ip_t: + return("gs_uint32_t *"); + case u_llong_t: + return("gs_uint64_t *"); + case llong_t: + return("gs_int64_t *"); + case floating_t: + return("gs_float_t *"); + case v_str_t: + return("struct gs_string *"); + case fstring_t: + return("gs_int8_t *"); + case timeval_t: + return("struct timeval *"); + case ipv6_t: + return("struct ipv6_str *"); + default: + return("ERROR: Unknown type in data_type::get_CC_accessor_type\n"); + } +} + +// type of a variable holding this value. +string data_type::get_cvar_type(){ + char tmps[100]; + switch(type){ + case int_t: + return("gs_int32_t "); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("gs_uint32_t "); + case u_llong_t: + return("gs_uint64_t "); + case llong_t: + return("gs_int64_t "); + case floating_t: + return("gs_float_t "); + case v_str_t: + return("struct gs_string"); + case ipv6_t: + return("struct ipv6_str"); + case fstring_t: + sprintf(tmps,"gs_int8_t[%d] ",size); + return(tmps); + case timeval_t: + return("struct timeval "); + default: + return("ERROR: Unknown type in data_type::get_cvar_type\n"); + } +} + +// type of a variable holding this value. +string data_type::get_tuple_cvar_type(){ + char tmps[100]; + switch(type){ + case int_t: + return("gs_int32_t "); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("gs_uint32_t "); + case u_llong_t: + return("gs_uint64_t "); + case llong_t: + return("gs_int64_t "); + case floating_t: + return("gs_float_t "); + case v_str_t: + return("struct string32"); + case ipv6_t: + return("struct ipv6_str"); + case fstring_t: + sprintf(tmps,"gs_int8_t[%d] ",size); + return(tmps); + case timeval_t: + return("struct timeval "); + default: + return("ERROR: Unknown type in data_type::get_cvar_type\n"); + } +} + + + +// type of an in-memory variable holding this value. +// TODO: use get_cvar_type as a subroutine +string data_type::make_cvar(std::string v){ + char tmps[100]; + switch(type){ + case int_t: + return("gs_int32_t "+v); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("gs_uint32_t "+v); + case u_llong_t: + return("gs_uint64_t "+v); + case llong_t: + return("gs_int64_t "+v); + case floating_t: + return("gs_float_t "+v); + case v_str_t: + return("struct gs_string "+v); + case ipv6_t: + return("struct ipv6_str "+v); + case fstring_t: + sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size); + return(tmps); + case timeval_t: + return("struct timeval "+v); + default: + return("ERROR: Unknown type in data_type::make_cvar\n"); + } +} + +// type of a tuple variable holding this value. +// TODO: use get_tuple_cvar_type as a subroutine +string data_type::make_tuple_cvar(std::string v){ + char tmps[100]; + switch(type){ + case int_t: + return("gs_int32_t "+v); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("gs_uint32_t "+v); + case u_llong_t: + return("gs_uint64_t "+v); + case llong_t: + return("gs_int64_t "+v); + case floating_t: + return("gs_float_t "+v); + case v_str_t: + return("struct string32 "+v); + case ipv6_t: + return("struct ipv6_str "+v); + case fstring_t: + sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size); + return(tmps); + case timeval_t: + return("struct timeval "+v); + default: + return("ERROR: Unknown type in data_type::make_cvar\n"); + } +} + + +// type of a variable holding this value. +// The type at the host might be different (esp. string vs. vstring) +string data_type::get_host_cvar_type(){ + char tmps[100]; + switch(type){ + case int_t: + return("gs_int32_t "); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("gs_uint32_t "); + case u_llong_t: + return("gs_uint64_t "); + case llong_t: + return("gs_int64_t "); + case floating_t: + return("gs_float_t "); + case v_str_t: + return("struct vstring"); + case ipv6_t: + return("struct hfta_ipv6_str"); + case fstring_t: + sprintf(tmps,"gs_int8_t[%d] ",size); + return(tmps); + case timeval_t: + return("struct timeval "); + default: + return("ERROR: Unknown type in data_type::get_host_cvar_type\n"); + } +} + + +// type of a variable holding this value. +// The type at the host might be different (esp. string vs. vstring) +string data_type::make_host_cvar(std::string v){ + char tmps[100]; + switch(type){ + case int_t: + return("gs_int32_t "+v); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("gs_uint32_t "+v); + case u_llong_t: + return("gs_uint64_t "+v); + case llong_t: + return("gs_int64_t "+v); + case floating_t: + return("gs_float_t "+v); + case v_str_t: + return("struct vstring "+v); + case ipv6_t: + return("struct hfta_ipv6_str "+v); + case fstring_t: + sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size); + return(tmps); + case timeval_t: + return("struct timeval "+v); + default: + return("ERROR: Unknown type in data_type::make_host_cvar\n"); + } +} + +string data_type::make_host_tuple_cvar(std::string v){ + char tmps[100]; + switch(type){ + case int_t: + return("gs_int32_t "+v); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("gs_uint32_t "+v); + case u_llong_t: + return("gs_uint64_t "+v); + case llong_t: + return("gs_int64_t "+v); + case floating_t: + return("gs_float_t "+v); + case v_str_t: + return("struct vstring32 "+v); + case ipv6_t: + return("struct hfta_ipv6_str "+v); + case fstring_t: + sprintf(tmps,"gs_int8_t %s[%d] ",v.c_str(),size); + return(tmps); + case timeval_t: + return("struct timeval "+v); + default: + return("ERROR: Unknown type in data_type::make_host_cvar\n"); + } +} + + + +string data_type::get_hfta_unpack_fcn(){ + switch(type){ + case int_t: + return("fta_unpack_int"); + case u_int_t: + case ip_t: + return("fta_unpack_uint"); + case u_short_t: + return("fta_unpack_ushort"); + case bool_t: + return("fta_unpack_bool"); + case u_llong_t: + return("fta_unpack_ullong"); + case llong_t: + return("fta_unpack_llong"); + case floating_t: + return("fta_unpack_float"); + case v_str_t: + return("fta_unpack_vstr"); + case fstring_t: + return("fta_unpack_fstring"); + case timeval_t: + return("fta_unpack_timeval"); + case ipv6_t: + return("fta_unpack_ipv6"); + default: + return("ERROR: Unknown type in dtype::get_hfta_unpack_fcn\n"); + } +} + +string data_type::get_hfta_unpack_fcn_noxf(){ + switch(type){ + case int_t: + return("fta_unpack_int_noxf"); + case u_int_t: + case ip_t: + return("fta_unpack_uint_noxf"); + case u_short_t: + return("fta_unpack_ushort_noxf"); + case bool_t: + return("fta_unpack_bool_noxf"); + case u_llong_t: + return("fta_unpack_ullong_noxf"); + case llong_t: + return("fta_unpack_llong_noxf"); + case floating_t: + return("fta_unpack_float_noxf"); + case v_str_t: + return("fta_unpack_vstr_noxf"); + case fstring_t: + return("fta_unpack_fstring_noxf"); + case timeval_t: + return("fta_unpack_timeval_noxf"); + case ipv6_t: + return("fta_unpack_ipv6_noxf"); + default: + return("ERROR: Unknown type in dtype::get_hfta_unpack_fcn_noxf\n"); + } +} + + +// Return true if comparing these types requires +// a special function. +// Note: +// 1) the function should act like strcmp (-1, 0, 1) +// 2) this fcn assumes that type checking +// has already been done. +bool data_type::complex_comparison(data_type *dt){ + switch(type){ + case timeval_t: + case ipv6_t: + case v_str_t: + case fstring_t: + return(true); + default: + return(false); + } +} + +string data_type::get_comparison_fcn(data_type *dt){ + switch(type){ + case timeval_t: + return("Compare_Timeval"); + case v_str_t: + return("str_compare"); + case ipv6_t: + return("ipv6_compare"); + default: + return("ERROR_NO_SUCH_COMPARISON_FCN"); + } + + +} + +string data_type::get_hfta_comparison_fcn(data_type *dt){ + switch(type){ + case timeval_t: + return("hfta_Compare_Timeval"); + case v_str_t: + return("hfta_vstr_compare"); + case ipv6_t: + return("hfta_ipv6_compare"); + default: + return("ERROR_NO_SUCH_COMPARISON_FCN"); + } +} + +// Return true if operating on these types requires +// a special function for this operator. +// Note: +// 1) the function should act like +// int operator_fcn(*retun_val, *lhs, *rhs) +// 2) this fcn assumes that type checking +// has already been done. +bool data_type::complex_operator(data_type *dt, string &op){ + switch(type){ + case int_t: + switch(dt->type){ + case timeval_t: + if(op == "+") + return(true); + break; + default: + break; + } + break; + case timeval_t: + switch(dt->type){ + case int_t: + case u_int_t: + case u_short_t: + if(op == "+" || op == "-" || op == "/") + return(true); + break; + case timeval_t: + if(op == "-") + return(true); + break; + default: + break; + } + case ipv6_t: + if((op=="&" || op=="|") && dt->type == ipv6_t) + return true; + break; + default: + break; + } + + return(false); +} + +bool data_type::complex_operator(string &op){ + return(false); +} + +string data_type::get_complex_operator(data_type *dt, string &op){ + switch(type){ + case int_t: + switch(dt->type){ + case timeval_t: + if(op == "+") + return("Add_Int_Timeval"); + break; + default: + break; + } + break; + case timeval_t: + switch(dt->type){ + case int_t: + case u_int_t: + case u_short_t: + if(op == "+") + return("Add_Timeval_Int"); + if(op == "-") + return("Subtract_Timeval_Int"); + if(op == "/") + return("Divide_Timeval_Int"); + break; + case timeval_t: + if(op == "-") + return("Subtract_Timeval_Timeval"); + break; + default: + break; + } + break; + case ipv6_t: + if(dt->type == ipv6_t){ + if(op == "&") + return("And_Ipv6"); + if(op == "|") + return("Or_Ipv6"); + } + break; + default: + break; + } + + return("ERROR_NO_COMPLEX_BINARY_OPERATOR"); +} + +string data_type::get_complex_operator(string &op){ + + return("ERROR_NO_COMPLEX_UNARY_OPERATOR"); +} + + +bool data_type::use_hashfunc(){ + switch(type){ + case int_t: + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return(false); + case u_llong_t: + case llong_t: + case floating_t: + case timeval_t: + case ipv6_t: + case v_str_t: + return(true); + default: + fprintf(stderr,"ERROR: Unknown type in data_type::use_hashfunc\n"); + exit(1); + return(false); + } +} +string data_type::get_hfta_hashfunc(){ + switch(type){ + case int_t: + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("ERROR NO HFTA HASHFUNC"); + + case u_llong_t: + //return("hfta_ullong_hashfunc"); + return("hfta_ULLONG_to_hash"); + case llong_t: + //return("hfta_ullong_hashfunc"); + return("hfta_LLONG_to_hash"); + case floating_t: + //return("hfta_float_hashfunc"); + return("hfta_FLOAT_to_hash"); + + case ipv6_t: + return("hfta_IPV6_to_hash"); + case timeval_t: + return("hfta_timeval_hashfunc"); + case v_str_t: + return("hfta_vstr_hashfunc"); + default: + fprintf(stderr,"ERROR: Unknown type in data_type::get_hfta_hashfunc\n"); + exit(1); + return("false"); // to make compiler happy + } +} + +// Return true if the data type contains a ptr to a +// memory buffer. (copying sometimes requires special cate). +// ASSUMPTION: +bool data_type::is_buffer_type(){ + switch(type){ + case int_t: + case u_int_t: + case u_short_t: + case bool_t: + case u_llong_t: + case llong_t: + case floating_t: + case timeval_t: + case ipv6_t: + case ip_t: + case fstring_t: + return(false); + case v_str_t: + return(true); + default: + fprintf(stderr,"ERROR: Unknown type in dtype::is_buffer_type\n"); + exit(1); + return(false); + } +} + +// Fcns which return the names of functions for +// handling complex types. + +//----------------------------- +// LFTA functions + +string data_type::get_buffer_assign_copy(){ + switch(type){ + case v_str_t: + return("str_assign_with_copy"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_assign_copy_FCN"); +} + +string data_type::get_buffer_tuple_copy(){ + switch(type){ + case v_str_t: + return("str_assign_with_copy_in_tuple"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_tuple_copy_FCN"); +} + +string data_type::get_buffer_replace(){ + switch(type){ + case v_str_t: + return("str_replace"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_replace_FCN"); +} + +string data_type::get_buffer_size(){ + switch(type){ + case v_str_t: + return("str_length"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_size_FCN"); +} + +string data_type::get_buffer_destroy(){ + switch(type){ + case v_str_t: + return("str_destroy"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_destroy_FCN"); +} + +//----------------------------- +// HFTA fcns + +string data_type::get_hfta_buffer_assign_copy(){ + switch(type){ + case v_str_t: + return("hfta_vstr_assign_with_copy"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_assign_copy_FCN"); +} + +string data_type::get_hfta_buffer_tuple_copy(){ + switch(type){ + case v_str_t: + return("hfta_vstr_assign_with_copy_in_tuple"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_tuple_copy_FCN"); +} + +string data_type::get_hfta_buffer_replace(){ + switch(type){ + case v_str_t: + return("hfta_vstr_replace"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_replace_FCN"); +} + +string data_type::get_hfta_buffer_size(){ + switch(type){ + case v_str_t: + return("hfta_vstr_length"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_size_FCN"); +} + +string data_type::get_hfta_buffer_destroy(){ + switch(type){ + case v_str_t: + return("hfta_vstr_destroy"); + default: + break; + } + + return("ERROR_NO_SUCH_buffer_destroy_FCN"); +} +//----------------------------- + + +// Return true if the data type is represented by a strucutre. +bool data_type::is_structured_type(){ + switch(type){ + case int_t: + case u_int_t: + case u_short_t: + case bool_t: + case u_llong_t: + case llong_t: + case floating_t: + case ip_t: + return(false); + case timeval_t: + case ipv6_t: + case v_str_t: + case fstring_t: + return(true); + default: + fprintf(stderr,"ERROR: Unknown type in dtype::is_structured_type\n"); + exit(1); + return(false); + } +} + + +// type of a variable holding this value. +// Seems to be a relic +/* +string data_type::get_interface_type(){ + char tmps[100]; + switch(type){ + case int_t: + return("int "); + case u_int_t: + return("unsigned int "); + case u_short_t: + return("unsigned short int "); + case bool_t: + return("int "); + case u_llong_t: + return("unsigned long long int "); + case llong_t: + return("long long int "); + case floating_t: + return("double "); + case v_str_t: + return("ERROR"); + case fstring_t: + sprintf(tmps,"char[%d] ",size); + return(tmps); + case timeval_t: + return("ERROR "); + case ipv6_t: + return "ERROR"; + default: + return("ERROR: Unknown type in dtype::get_interface_type\n"); + } +} +*/ + + +// This type of handle registration is obsolete + +string data_type::handle_registration_name(){ + + switch(type){ + case v_str_t: + return("str_register_search_string"); + default: + return(""); + } + return("ERROR UNKNOWN LITERAL"); + }; + +string data_type::hfta_handle_registration_name(){ + + switch(type){ + case v_str_t: + return("vstr_register_search_string"); + default: + return(""); + } + return("ERROR UNKNOWN LITERAL"); + }; + + +string data_type::get_handle_destructor(){ + + switch(type){ + case v_str_t: + return("str_release_search_string"); + default: + return(""); + } + return("ERROR UNKNOWN LITERAL"); + }; + + +// should be the inverse of +// data_type::data_type(string st, param_list *modifiers) +vector<string> data_type::get_param_keys(){ + vector<string> retval; + + if(temporal == increasing_t) + retval.push_back("INCREASING"); + if(temporal == decreasing_t) + retval.push_back("DECREASING"); + if(subtype != "") retval.push_back("subtype"); + + return(retval); +} + +string data_type::get_param_val(string k){ + if(k=="subtype") return subtype; + return ""; +} + +std::string data_type::get_temporal_string(){ + if(temporal == increasing_t) + return("INCREASING"); + if(temporal == decreasing_t) + return("DECREASING"); + return(""); +} + + +bool data_type::needs_hn_translation(){ + switch(type){ + case int_t: + case u_int_t: + case u_short_t: + case bool_t: + case u_llong_t: + case llong_t: + case floating_t: + case timeval_t: + case ipv6_t: + case v_str_t: + case ip_t: + return(true); + case fstring_t: + return(false); + default: + fprintf(stderr,"INTERNAL ERROR: Unknown type in dtype::needs_hn_translation\n"); + exit(1); + return(false); + } +} + +std::string data_type::hton_translation(){ +fprintf(stderr,"INTERNAL ERROR, hton_translation called.\n"); +return(""); + + switch(type){ + case int_t: + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("htonl"); + break; + case u_llong_t: + case llong_t: + return("htonll"); + break; + case floating_t: + return("htonf"); + break; + case timeval_t: + return("htontv"); + break; + case ipv6_t: + return("hton_ipv6"); + break; + case v_str_t: + return("INTERNAL ERROR, net translation for buffered types needs special handling.\n"); + default: + fprintf(stderr,"INTERNAL ERROR: Unknown type in dtype::hton_translation\n"); + exit(1); + return("INTERNAL ERROR: NO SUCH TYPE IN hton_translation"); + } +} + +std::string data_type::ntoh_translation(){ +fprintf(stderr,"INTERNAL ERROR, ntoh_translation called.\n"); +return(""); + + switch(type){ + case int_t: + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return("ntohl"); + break; + case u_llong_t: + case llong_t: + return("ntohll"); + break; + case floating_t: + return("ntohf"); + break; + case timeval_t: + return("ntohtv"); + break; + case ipv6_t: + return("ntoh_ipv6"); + break; + case v_str_t: + return("INTERNAL ERROR, net translation for buffered types needs special handling.\n"); + default: + fprintf(stderr,"INTERNAL ERROR: Unknown type in dtype::ntoh_translation\n"); + exit(1); + return("INTERNAL ERROR: NO SUCH TYPE IN ntoh_translation"); + } +} + +int data_type::type_indicator(){ + switch(type){ + case int_t: + return(INT_TYPE); + case u_int_t: + return(UINT_TYPE); + case u_short_t: + return(USHORT_TYPE); + case bool_t: + return(BOOL_TYPE); + case u_llong_t: + return(ULLONG_TYPE); + case llong_t: + return(LLONG_TYPE); + case floating_t: + return(FLOAT_TYPE); + case timeval_t: + return(TIMEVAL_TYPE); + case ipv6_t: + return(IPV6_TYPE); + case ip_t: + return(IP_TYPE); + case v_str_t: + return(VSTR_TYPE); + case fstring_t: + return(FSTRING_TYPE); + default: + return(UNDEFINED_TYPE); + } + return(UNDEFINED_TYPE); +} + +// for schemaparser + +int data_type::type_size(){ + switch(type){ + case int_t: + return(sizeof(gs_int32_t)); + case u_int_t: + case u_short_t: + case bool_t: + case ip_t: + return(sizeof(gs_uint32_t)); + case u_llong_t: + return(sizeof(gs_uint64_t)); + case llong_t: + return(sizeof(gs_int64_t)); + case floating_t: + return(sizeof(gs_float_t)); + case timeval_t: + return(sizeof(timeval)); // IMPLEMENTATION DEPENDENT + case ipv6_t: + return(sizeof(hfta_ipv6_str)); // IMPLEMENTATION DEPENDENT + case v_str_t: + return(sizeof(vstring32)); // IMPLEMENTATION DEPENDENT + case fstring_t: + return(size); + default: + return(0); + } + return(0); +} + +// for external functions and predicates + +/* +bool data_type::call_compatible(data_type *o){ + if(type != o->get_type()) return(false); + if(type == fstring_t){ + if(size != 0 && size != o->type_size()) return(false); + } + return(true); +} + +// test for equality : used by bind_to_schema and by testing for +// mergability. + +bool data_type::equal(data_type *o){ + if(type != o->get_type()) return(false); + if(type == fstring_t){ + if(size != o->type_size()) return(false); + } + return(true); +} +*/ + +bool data_type::subsumes_type(data_type *o){ + if(type != o->get_type()) return(false); + if(type == fstring_t){ + if(size != o->type_size()) return(false); + } + if(this->is_temporal() && temporal != o->get_temporal()) return false; + if(subtype != "" && subtype != o->subtype) return false; + + return(true); +} + +bool data_type::equals(data_type *o){ + if(type != o->get_type()) return(false); + if(type == fstring_t){ + if(size != o->type_size()) return(false); + } + if(temporal != o->get_temporal()) return false; + if(subtype != o->subtype) return false; + + return(true); +} + +bool data_type::equal_subtypes(data_type *o){ + if(type != o->get_type()) return(false); + if(type == fstring_t){ + if(size != o->type_size()) return(false); + } + if(subtype != o->subtype) return false; + + return(true); +} + + +string data_type::to_string(){ + string ret = schema_type; + if(this->is_temporal() || subtype != ""){ + ret += " ("; + if(temporal == increasing_t) + ret += "INCREASING"; + if(temporal == decreasing_t) + ret += "DECREASING"; + if(this->is_temporal() && subtype != "") + ret += ", "; + if(subtype != "") + ret += "subtype "+subtype; + ret += ")"; + } + return ret; +} + + + +string data_type::get_min_literal() { + switch(type){ + case int_t: + return("INT_MIN"); + case bool_t: + case u_short_t: + case u_int_t: + case ip_t: + return("0"); + case u_llong_t: + return("0"); + case llong_t: + return("LLONG_MIN"); + case floating_t: + return("DBL_MIN"); + case timeval_t: + return("{0,0}"); + case ipv6_t: + return("0000:0000:0000:0000:0000:0000:0000:0000"); + case v_str_t: + case fstring_t: + return("ERROR: Min literal is undefined for strings\n"); + default: + return("ERROR: Unknown type in data_type::get_min_literal\n"); + } +} + +string data_type::get_max_literal() { + switch(type){ + case int_t: + return("INT_MAX"); + case bool_t: + case u_short_t: + case u_int_t: + case ip_t: + return("UINT_MAX"); + case u_llong_t: + return("ULLONG_MAX"); + case llong_t: + return("LLONG_MAX"); + case floating_t: + return("DBL_MAX"); + case timeval_t: + return("{UINT_MAX,UINT_MAX}"); + case ipv6_t: + return("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + case v_str_t: + case fstring_t: + return("ERROR: Max literal is undefined for strings\n"); + default: + return("ERROR: Unknown type in data_type::get_max_literal\n"); + } + +} + diff --git a/src/ftacmp/type_objects.h b/src/ftacmp/type_objects.h new file mode 100644 index 0000000..2f73026 --- /dev/null +++ b/src/ftacmp/type_objects.h @@ -0,0 +1,162 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __TYPE_OBJECTS_H_DEFINED__ +#define __TYPE_OBJECTS_H_DEFINED__ + +#include <string> +#include<vector> + +#include"literal_types.h" +#include"parse_schema.h" +#include"type_indicators.h" +#include"gstypes.h" +#include"vstring.h" + +enum dtype {u_int_t, int_t, u_llong_t, llong_t, u_short_t, floating_t, + bool_t, v_str_t, timeval_t, ip_t, ipv6_t, fstring_t, undefined_t}; + +enum temporal_type {increasing_t, decreasing_t, constant_t, varying_t}; + // varying_t means I don't know. + // constant_t MUST MEAN THAT ALL VALUES IN THE SE TREE ARE LITERALS! + + +class data_type{ +private: + std::string schema_type; // String representation of the data type. + dtype type; // Internal representation of the data type. + std::string subtype; // specialization of the type. + // use to restrict access and provide annotation + temporal_type temporal; // How does the value change over time. + int size; // # bytes, it it can't be readily determined + + void assign_schema_type(); + void assign_type_from_string(std::string st); + +public: + data_type(){type = undefined_t; assign_schema_type(); size=0; temporal=varying_t;}; + data_type(std::string st); + data_type(std::string st, param_list *modifiers); + data_type(int it); + data_type(data_type *lhs, std::string &op); + data_type(data_type *lhs, data_type *rhs, const std::string &op); + + static temporal_type compute_temporal_type(temporal_type l_tempo, std::string &op); + static temporal_type compute_temporal_type(temporal_type l_tempo, temporal_type r_tempo, dtype l_type, dtype r_type, const std::string &op); + + data_type *duplicate(); + field_entry *make_field_entry(std::string n); + + void set_aggr_data_type(const std::string &op, data_type *dt); + + int type_indicator(); + + dtype get_type(){return type; }; + std::string get_type_str(){return schema_type; }; + std::string to_string(); + + temporal_type get_temporal(){return temporal; }; + void set_temporal(temporal_type t){temporal = t; }; + void reset_temporal(){ if(this->is_temporal()) temporal = varying_t;}; + bool is_temporal(){return( temporal == increasing_t || temporal == decreasing_t);}; + bool is_increasing(){return( temporal == increasing_t );}; + bool is_decreasing(){return( temporal == decreasing_t );}; + + std::string get_temporal_string(); + std::vector<std::string> get_param_keys(); + std::string get_param_val(std::string k); + + bool is_defined(){return(type != undefined_t); }; + + bool is_comparable(data_type *rhs, std::string op); + + std::string get_CC_accessor_type(); + std::string get_cvar_type(); + std::string get_tuple_cvar_type(); + std::string make_cvar(std::string v); + std::string make_tuple_cvar(std::string v); + std::string get_host_cvar_type(); + std::string make_host_cvar(std::string v); + std::string make_host_tuple_cvar(std::string v); + std::string get_hfta_unpack_fcn(); + std::string get_hfta_unpack_fcn_noxf(); + + bool complex_comparison(data_type *dt); + std::string get_comparison_fcn(data_type *dt); + std::string get_hfta_comparison_fcn(data_type *dt); + + bool complex_operator(data_type *dt, std::string &op); + std::string get_complex_operator(data_type *dt, std::string &op); + + bool complex_operator(std::string &op); + std::string get_complex_operator(std::string &op); + + bool use_hashfunc(); + std::string get_hfta_hashfunc(); + + bool needs_hn_translation(); + std::string hton_translation(); + std::string ntoh_translation(); + + bool is_buffer_type(); +// LFTA functions + std::string get_buffer_assign_copy(); + std::string get_buffer_tuple_copy(); + std::string get_buffer_replace(); + std::string get_buffer_size(); + std::string get_buffer_destroy(); +// HFTA functions + std::string get_hfta_buffer_assign_copy(); + std::string get_hfta_buffer_tuple_copy(); + std::string get_hfta_buffer_replace(); + std::string get_hfta_buffer_size(); + std::string get_hfta_buffer_destroy(); + + bool is_structured_type(); +// std::string get_interface_type(); + +// These functions are obsolete + std::string handle_registration_name(); + std::string hfta_handle_registration_name(); + std::string get_handle_destructor(); + + bool fta_legal_type(); + static bool fta_legal_operation(data_type *lhs, data_type *rhs, std::string &op); + static bool fta_legal_operation(data_type *lhs, std::string &op); + +// for schemaparser + int type_size(); + +/* +// for external functions and predicates +bool call_compatible(data_type *o); + +// test for equality : used by bind_to_schema and by testing for +// mergability. +bool equal(data_type *o); +*/ + + bool subsumes_type(data_type *o); + bool equals(data_type *o); + bool equal_subtypes(data_type *o); + +// literals corresponding to minimum and maximum values + std::string get_min_literal(); + std::string get_max_literal(); + + +}; + + +#endif diff --git a/src/ftacmp/xml.l b/src/ftacmp/xml.l new file mode 100644 index 0000000..d394d27 --- /dev/null +++ b/src/ftacmp/xml.l @@ -0,0 +1,224 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +/* + MUST COMPILE WITH + flex -PxmlParser -oxmllexer.cc xml.l + (or equivalent). +*/ + +%{ +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + // #include "parse_fta.h" + #include <string.h> + + + +#include "xml.tab.hh" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include <stdlib.h> +#include <string.h> + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int xmlParserwrap(){return(1);} + +extern int xmlParserdebug; + + +/* + These variables are used for error reporting: + flex_xml_lineno : the line currently being parsed when the error occurs. + flex_xml_ch : the character on the line where the error occurs + flex_xml_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_xml_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_xml_lineno = 1; +int flex_xml_ch = 0; +char flex_xml_linebuf[20000]; + +char *flex_xml_stringinput = NULL; +int flex_xml_stringinput_ptr = 0; +FILE *flex_xml_fileinput = NULL; +int my_xmlParser_yyinput(char *buf, int max_size); + + + +void xmlParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_xml_lineno, flex_xml_ch, s, xmlParsertext, flex_xml_linebuf ); + for(i=0;i<flex_xml_ch;i++){ + if(flex_xml_linebuf[i] == '\t'){ + fprintf(stderr,"\t"); + }else{ + fprintf(stderr," "); + } + } + fprintf(stderr,"^\n"); + // fprintf(stderr,"%*s\n",1+flex_xml_ch,"^"); +} + +#undef YY_INPUT +#define YY_INPUT(b, r, ms) (r = my_xmlParser_yyinput(b,ms)) + +%} + /* MKS needs the next line to increase the NFA table */ +%e 1200 +%option noyywrap + +%% + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + + + + +[<>=/] { flex_xml_ch+=xmlParserleng; return yytext[0]; } + + /* names */ + +[A-Za-z_][A-Za-z0-9_:]* { flex_xml_ch+=xmlParserleng; xmlParserlval.strval = strdup(yytext); return NAME; } + + + /* strings */ + +\"[^\"\n]*\" { + + int c; + + xmlParserlval.strval = strdup(xmlParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_xml_ch+=xmlParserleng; + xmlParserlval.strval[xmlParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + +\"[^\"\n]*$ { flex_xml_ch+=xmlParserleng; xmlParsererror("Unterminated string"); } + + /* */ + /* Newline : advance the error reporting line number */ + /* and grab the next line into flex_xml_linebuf */ + /* */ + +\n.* {flex_xml_ch=0; flex_xml_lineno++; + strcpy(flex_xml_linebuf,xmlParsertext+1); + yyless(1); + } + +[ \t\r]+ {flex_xml_ch+=xmlParserleng; } /* white space */ + +"--".*$ {flex_xml_ch+=xmlParserleng; }; /* comment */ +"//".*$ {flex_xml_ch+=xmlParserleng; }; /* comment */ +"<?xml".*$ {flex_xml_ch+=xmlParserleng; }; /* comment */ + +.|\n {flex_xml_ch+=xmlParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); xmlParsererror(yytext);} + +%% + +int my_xmlParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_xml_stringinput != NULL){ + while(c<max_size){ + if(flex_xml_stringinput[flex_xml_stringinput_ptr] != '\0'){ + buf[c++] = flex_xml_stringinput[flex_xml_stringinput_ptr++]; + }else{ + break; + } + } + return(c); + } + + if(flex_xml_fileinput != NULL){ + while(c < max_size){ + inchar = getc(flex_xml_fileinput); + if(inchar != EOF){ + buf[c++] = inchar; + }else{ + break; + } + } + return(c); + } + + return(0); +} + +void xmlParser_setfileinput(FILE *f){ + xmlParserrestart(NULL); + + flex_xml_fileinput = f; + flex_xml_stringinput = NULL; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + +void xmlParser_setstringinput(char *s){ + xmlParserrestart(NULL); + + flex_xml_fileinput = NULL; + flex_xml_stringinput = s; + flex_xml_stringinput_ptr = 0; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + + + + + diff --git a/src/ftacmp/xml.tab.cc b/src/ftacmp/xml.tab.cc new file mode 100644 index 0000000..0167d88 --- /dev/null +++ b/src/ftacmp/xml.tab.cc @@ -0,0 +1,1282 @@ +/* A Bison parser, made by GNU Bison 1.875c. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +/* If NAME_PREFIX is specified substitute the variables and functions + names. */ +#define yyparse xmlParserparse +#define yylex xmlParserlex +#define yyerror xmlParsererror +#define yylval xmlParserlval +#define yychar xmlParserchar +#define yydebug xmlParserdebug +#define yynerrs xmlParsernerrs + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259 + }; +#endif +#define NAME 258 +#define STRING_TOKEN 259 + + + + +/* Copy the first part of user declarations. */ +#line 8 "xml.y" + + + +#include <stdio.h> + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include <stdlib.h> + +/* prototypes for the parser callbacks. +*/ + +#include "xml_t.h" + + +extern std::vector<std::string> xml_attr_vec; +extern std::vector<std::string> xml_val_vec; +extern std::string xml_a, xml_v; +extern xml_t *xml_leaves; + +extern int xmlParserdebug; +extern void xmlParsererror(char *s); +extern int xmlParserlex(); + + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 42 "xml.y" +typedef union YYSTYPE { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} YYSTYPE; +/* Line 191 of yacc.c. */ +#line 134 "xml.tab.cc" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ + + +/* Line 214 of yacc.c. */ +#line 146 "xml.tab.cc" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# endif +# else +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined (__GNUC__) && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 6 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 25 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 9 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 9 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 14 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 26 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 259 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 6, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 5, 8, 7, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 5, 9, 12, 18, 23, 28, 30, + 33, 35, 36, 38, 41 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 10, 0, -1, 11, -1, 12, 14, 13, -1, 12, + 13, -1, 5, 3, 15, 6, 7, -1, 5, 3, + 15, 7, -1, 5, 6, 3, 7, -1, 11, -1, + 14, 11, -1, 16, -1, -1, 17, -1, 16, 17, + -1, 3, 8, 4, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned char yyrline[] = +{ + 0, 60, 60, 64, 65, 66, 72, 76, 81, 82, + 86, 87, 91, 93, 98 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "'<'", "'/'", + "'>'", "'='", "$accept", "parse_result", "resource", "start_tag", + "end_tag", "xml_list", "opt_val_list", "val_list", "val", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short yytoknum[] = +{ + 0, 256, 257, 258, 259, 60, 47, 62, 61 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 9, 10, 11, 11, 11, 12, 13, 14, 14, + 15, 15, 16, 16, 17 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 1, 3, 2, 5, 4, 4, 1, 2, + 1, 0, 1, 2, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 0, 0, 2, 0, 11, 1, 0, 8, 4, + 0, 0, 0, 10, 12, 0, 9, 3, 0, 0, + 6, 13, 0, 14, 5, 7 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = +{ + -1, 2, 3, 4, 9, 10, 12, 13, 14 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -5 +static const yysigned_char yypact[] = +{ + -3, 0, 5, -5, 4, 7, -5, -2, -5, -5, + 4, 3, 1, 7, -5, 9, -5, -5, 10, 6, + -5, -5, 8, -5, -5, -5 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = +{ + -5, -5, -4, -5, 11, -5, -5, -5, 12 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = +{ + 8, 5, 1, 5, 15, 6, 16, 19, 20, 7, + 11, 18, 22, 24, 23, 25, 0, 0, 0, 0, + 0, 17, 0, 0, 0, 21 +}; + +static const yysigned_char yycheck[] = +{ + 4, 3, 5, 3, 6, 0, 10, 6, 7, 5, + 3, 8, 3, 7, 4, 7, -1, -1, -1, -1, + -1, 10, -1, -1, -1, 13 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 5, 10, 11, 12, 3, 0, 5, 11, 13, + 14, 3, 15, 16, 17, 6, 11, 13, 8, 6, + 7, 17, 3, 4, 7, 7 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up");\ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + ((Current).first_line = (Rhs)[1].first_line, \ + (Current).first_column = (Rhs)[1].first_column, \ + (Current).last_line = (Rhs)[N].last_line, \ + (Current).last_column = (Rhs)[N].last_column) +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +# define YYDSYMPRINT(Args) \ +do { \ + if (yydebug) \ + yysymprint Args; \ +} while (0) + +# define YYDSYMPRINTF(Title, Token, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Token, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short *bottom, short *top) +#else +static void +yy_stack_print (bottom, top) + short *bottom; + short *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; +#endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YYDSYMPRINT(Args) +# define YYDSYMPRINTF(Title, Token, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + } + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yytype, yyvaluep) + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM); +# else +int yyparse (); +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yytoken = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyoverflowlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 5: +#line 67 "xml.y" + {xml_leaves->add_leaf(new xml_leaf_t(yyvsp[-3].strval, xml_attr_vec, xml_val_vec)); + ;} + break; + + case 11: +#line 87 "xml.y" + {xml_attr_vec.clear(); xml_val_vec.clear();;} + break; + + case 12: +#line 91 "xml.y" + {xml_attr_vec.clear(); xml_attr_vec.push_back(xml_a); + xml_val_vec.clear(); xml_val_vec.push_back(xml_v); ;} + break; + + case 13: +#line 93 "xml.y" + {xml_attr_vec.push_back(xml_a); + xml_val_vec.push_back(xml_v); ;} + break; + + case 14: +#line 98 "xml.y" + {xml_a = yyvsp[-2].strval; xml_v = yyvsp[0].strval;;} + break; + + + } + +/* Line 993 of yacc.c. */ +#line 1054 "xml.tab.cc" + + yyvsp -= yylen; + yyssp -= yylen; + + + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; + char *yymsg; + int yyx; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yyp = yystpcpy (yyp, yyprefix); + yyp = yystpcpy (yyp, yytname[yyx]); + yyprefix = " or "; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("syntax error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[*yyssp], yyvsp); + } + } + else + { + YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); + yydestruct (yytoken, &yylval); + yychar = YYEMPTY; + + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; +#endif + + yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; + + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 105 "xml.y" + + + + diff --git a/src/ftacmp/xml.tab.hh b/src/ftacmp/xml.tab.hh new file mode 100644 index 0000000..74de19a --- /dev/null +++ b/src/ftacmp/xml.tab.hh @@ -0,0 +1,63 @@ +/* A Bison parser, made by GNU Bison 1.875c. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259 + }; +#endif +#define NAME 258 +#define STRING_TOKEN 259 + + + + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 42 "xml.y" +typedef union YYSTYPE { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} YYSTYPE; +/* Line 1268 of yacc.c. */ +#line 55 "xml.tab.hh" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +extern YYSTYPE xmlParserlval; + + + diff --git a/src/ftacmp/xml.y b/src/ftacmp/xml.y new file mode 100644 index 0000000..cf45ff4 --- /dev/null +++ b/src/ftacmp/xml.y @@ -0,0 +1,122 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + bison --verbose -d -p xmlParser -o xml.tab.cc xml.y + + (or equivalent). +*/ + +%{ + + +#include <stdio.h> + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include <stdlib.h> + +/* prototypes for the parser callbacks. +*/ + +#include "xml_t.h" + + +extern std::vector<std::string> xml_attr_vec; +extern std::vector<std::string> xml_val_vec; +extern std::string xml_a, xml_v; +extern xml_t *xml_leaves; + +extern int xmlParserdebug; +extern void xmlParsererror(char *s); +extern int xmlParserlex(); + + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + int intval; + double floatval; + char *strval; + int subtok; + + /* for FTA definition. */ + +} + +%token <strval> NAME +%token <strval> STRING_TOKEN + + + + +%% + +parse_result: resource + ; + +resource: + start_tag xml_list end_tag + | start_tag end_tag + | '<' NAME opt_val_list '/' '>' + {xml_leaves->add_leaf(new xml_leaf_t($2, xml_attr_vec, xml_val_vec)); + } + ; + +start_tag: + '<' NAME opt_val_list '>' + ; + +end_tag: + '<' '/' NAME '>' + ; + + +xml_list: + resource + | xml_list resource + ; + +opt_val_list: + val_list + | {xml_attr_vec.clear(); xml_val_vec.clear();} + ; + +val_list: + val {xml_attr_vec.clear(); xml_attr_vec.push_back(xml_a); + xml_val_vec.clear(); xml_val_vec.push_back(xml_v); } + | val_list val {xml_attr_vec.push_back(xml_a); + xml_val_vec.push_back(xml_v); } + ; + +val: + NAME '=' STRING_TOKEN {xml_a = $1; xml_v = $3;} + ; + + + + + +%% + + diff --git a/src/ftacmp/xml_t.h b/src/ftacmp/xml_t.h new file mode 100644 index 0000000..392f476 --- /dev/null +++ b/src/ftacmp/xml_t.h @@ -0,0 +1,56 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef __XML_T_DEFINED_ +#define __XML_T_DEFINED_ + +#include <stdio.h> +#include<vector> +#include<string> +#include<map> +#include<set> +#include<algorithm> + + +void xmlParser_setfileinput(FILE *f); +void xmlParser_setstringinput(char *s); + + +// Represent leaf-level xml nodes +class xml_leaf_t{ +public: + std::string name; + std::vector<std::string> attrs; + std::vector<std::string> vals; + + xml_leaf_t(const char *n, std::vector<std::string> &a, std::vector<std::string> &v){ + name = n; + attrs = a; + vals = v; + } +}; + +class xml_t{ +public: + std::vector<xml_leaf_t *> leaves; + + xml_t(){} + + void add_leaf(xml_leaf_t *l){ + leaves.push_back(l); + } +}; + +#endif + diff --git a/src/ftacmp/xmllexer.cc b/src/ftacmp/xmllexer.cc new file mode 100644 index 0000000..a763ec5 --- /dev/null +++ b/src/ftacmp/xmllexer.cc @@ -0,0 +1,1779 @@ +#define yy_create_buffer xmlParser_create_buffer +#define yy_delete_buffer xmlParser_delete_buffer +#define yy_scan_buffer xmlParser_scan_buffer +#define yy_scan_string xmlParser_scan_string +#define yy_scan_bytes xmlParser_scan_bytes +#define yy_flex_debug xmlParser_flex_debug +#define yy_init_buffer xmlParser_init_buffer +#define yy_flush_buffer xmlParser_flush_buffer +#define yy_load_buffer_state xmlParser_load_buffer_state +#define yy_switch_to_buffer xmlParser_switch_to_buffer +#define yyin xmlParserin +#define yyleng xmlParserleng +#define yylex xmlParserlex +#define yyout xmlParserout +#define yyrestart xmlParserrestart +#define yytext xmlParsertext + +#line 19 "xmllexer.cc" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/ftacmp/xmllexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> +#include <unistd.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yytext_ptr -= yy_more_len; \ + yyleng = (int) (yy_cp - yytext_ptr); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 11 +#define YY_END_OF_BUFFER 12 +static yyconst short int yy_accept[32] = + { 0, + 0, 0, 12, 10, 6, 5, 10, 10, 1, 1, + 1, 2, 6, 5, 0, 4, 3, 0, 0, 0, + 2, 0, 7, 0, 8, 0, 0, 0, 0, 9, + 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 4, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 5, 1, 6, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 1, 8, + 9, 9, 10, 1, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 1, 1, 1, 1, 11, 1, 11, 11, 11, 11, + + 11, 11, 11, 11, 11, 11, 11, 12, 13, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 14, + 11, 11, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[15] = + { 0, + 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, + 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[38] = + { 0, + 0, 0, 48, 49, 45, 0, 12, 41, 39, 34, + 49, 0, 41, 0, 14, 49, 49, 39, 38, 26, + 0, 36, 49, 35, 49, 24, 24, 32, 31, 49, + 49, 18, 21, 17, 24, 27, 30 + } ; + +static yyconst short int yy_def[38] = + { 0, + 31, 1, 31, 31, 31, 32, 33, 31, 31, 31, + 31, 34, 31, 32, 33, 31, 31, 35, 36, 31, + 34, 35, 31, 36, 31, 31, 31, 37, 37, 31, + 0, 31, 31, 31, 31, 31, 31 + } ; + +static yyconst short int yy_nxt[64] = + { 0, + 4, 5, 6, 7, 8, 9, 4, 10, 11, 4, + 12, 12, 12, 12, 16, 17, 16, 17, 14, 21, + 14, 15, 15, 15, 22, 22, 22, 24, 24, 24, + 29, 29, 29, 30, 30, 28, 27, 25, 23, 26, + 25, 23, 13, 20, 19, 18, 13, 31, 3, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31 + } ; + +static yyconst short int yy_chk[64] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 7, 7, 15, 15, 32, 34, + 32, 33, 33, 33, 35, 35, 35, 36, 36, 36, + 37, 37, 37, 29, 28, 27, 26, 24, 22, 20, + 19, 18, 13, 10, 9, 8, 5, 3, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() (yy_more_flag = 1) +#define YY_MORE_ADJ yy_more_len +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "xml.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PxmlParser -oxmllexer.cc xml.l + (or equivalent). +*/ +#line 9 "xml.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + // #include "parse_fta.h" + #include <string.h> + + + +#include "xml.tab.hh" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include <stdlib.h> +#include <string.h> + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int xmlParserwrap(){return(1);} + +extern int xmlParserdebug; + + +/* + These variables are used for error reporting: + flex_xml_lineno : the line currently being parsed when the error occurs. + flex_xml_ch : the character on the line where the error occurs + flex_xml_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_xml_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_xml_lineno = 1; +int flex_xml_ch = 0; +char flex_xml_linebuf[20000]; + +char *flex_xml_stringinput = NULL; +int flex_xml_stringinput_ptr = 0; +FILE *flex_xml_fileinput = NULL; +int my_xmlParser_yyinput(char *buf, int max_size); + + + +void xmlParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_xml_lineno, flex_xml_ch, s, xmlParsertext, flex_xml_linebuf ); + for(i=0;i<flex_xml_ch;i++){ + if(flex_xml_linebuf[i] == '\t'){ + fprintf(stderr,"\t"); + }else{ + fprintf(stderr," "); + } + } + fprintf(stderr,"^\n"); + // fprintf(stderr,"%*s\n",1+flex_xml_ch,"^"); +} + +#undef YY_INPUT +#define YY_INPUT(b, r, ms) (r = my_xmlParser_yyinput(b,ms)) + +/* MKS needs the next line to increase the NFA table */ +#line 490 "xmllexer.cc" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 88 "xml.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + + + + +#line 663 "xmllexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + if ( yy_more_flag ) + { + yy_more_len = yy_c_buf_p - yytext_ptr; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 49 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 109 "xml.l" +{ flex_xml_ch+=xmlParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 2: +YY_RULE_SETUP +#line 113 "xml.l" +{ flex_xml_ch+=xmlParserleng; xmlParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* strings */ +case 3: +YY_RULE_SETUP +#line 118 "xml.l" +{ + + int c; + + xmlParserlval.strval = strdup(xmlParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_xml_ch+=xmlParserleng; + xmlParserlval.strval[xmlParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + YY_BREAK +case 4: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 135 "xml.l" +{ flex_xml_ch+=xmlParserleng; xmlParsererror("Unterminated string"); } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_xml_linebuf */ +/* */ +case 5: +YY_RULE_SETUP +#line 142 "xml.l" +{flex_xml_ch=0; flex_xml_lineno++; + strcpy(flex_xml_linebuf,xmlParsertext+1); + yyless(1); + } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 147 "xml.l" +{flex_xml_ch+=xmlParserleng; } /* white space */ + YY_BREAK +case 7: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 149 "xml.l" +{flex_xml_ch+=xmlParserleng; }; /* comment */ + YY_BREAK +case 8: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 150 "xml.l" +{flex_xml_ch+=xmlParserleng; }; /* comment */ + YY_BREAK +case 9: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 151 "xml.l" +{flex_xml_ch+=xmlParserleng; }; /* comment */ + YY_BREAK +case 10: +YY_RULE_SETUP +#line 153 "xml.l" +{flex_xml_ch+=xmlParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); xmlParsererror(yytext);} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 155 "xml.l" +ECHO; + YY_BREAK +#line 843 "xmllexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 31); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 155 "xml.l" + + +int my_xmlParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_xml_stringinput != NULL){ + while(c<max_size){ + if(flex_xml_stringinput[flex_xml_stringinput_ptr] != '\0'){ + buf[c++] = flex_xml_stringinput[flex_xml_stringinput_ptr++]; + }else{ + break; + } + } + return(c); + } + + if(flex_xml_fileinput != NULL){ + while(c < max_size){ + inchar = getc(flex_xml_fileinput); + if(inchar != EOF){ + buf[c++] = inchar; + }else{ + break; + } + } + return(c); + } + + return(0); +} + +void xmlParser_setfileinput(FILE *f){ + xmlParserrestart(NULL); + + flex_xml_fileinput = f; + flex_xml_stringinput = NULL; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + +void xmlParser_setstringinput(char *s){ + xmlParserrestart(NULL); + + flex_xml_fileinput = NULL; + flex_xml_stringinput = s; + flex_xml_stringinput_ptr = 0; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + + + + + diff --git a/src/lib/Makefile b/src/lib/Makefile new file mode 100644 index 0000000..8e1936e --- /dev/null +++ b/src/lib/Makefile @@ -0,0 +1,56 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +all: mgscphost mgscphostaux mgscplftaaux mgscphftaaux mgscprts mgscpapp mgscpaux + +clean: + cd gscphost ; make clean + cd gscphostaux ; make clean + cd gscplftaaux ; make clean + cd gscphftaaux ; make clean + cd gscprts ; make clean + cd gscpapp; make clean + cd gscpaux; make clean + +install: + cd gscphost ; make install + cd gscphostaux ; make install + cd gscplftaaux ; make install + cd gscphftaaux ; make install + cd gscprts ; make install + cd gscpapp; make install + cd gscpaux; make install + +mgscphost: + cd gscphost ; make + +mgscphostaux: + cd gscphostaux ; make + +mgscplftaaux: + cd gscplftaaux ; make + +mgscphftaaux: + cd gscphftaaux ; make + +mgscprts: + cd gscprts ; make + +mgscpapp: + cd gscpapp; make + +mgscpaux: + cd gscpaux; make + diff --git a/src/lib/gscpapp/Makefile b/src/lib/gscpapp/Makefile new file mode 100644 index 0000000..55c2cbb --- /dev/null +++ b/src/lib/gscpapp/Makefile @@ -0,0 +1,36 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CC=gcc -O3 -fexpensive-optimizations -I ../../../include + +SOURCE = appinterface.c + +OBJECTS = $(SOURCE:.c=.o) + +all: libgscpapp.a + cp libgscpapp.a ../../../lib; ranlib ../../../lib/libgscpapp.a + +libgscpapp.a: $(OBJECTS) Makefile + ar rc libgscpapp.a $(OBJECTS) + +INCDIR=../../../include + +appinterface.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(INCDIR/app.h) $(INCDIR/fta.h) $(INCDIR/lapp.h) + +install: all + +clean: + rm -f *.o *.a core + diff --git a/src/lib/gscpapp/appinterface.c b/src/lib/gscpapp/appinterface.c new file mode 100644 index 0000000..961926f --- /dev/null +++ b/src/lib/gscpapp/appinterface.c @@ -0,0 +1,372 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include "gsconfig.h" +#include "gstypes.h" +#include "app.h" +#include "fta.h" +#include "lapp.h" +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "schemaparser.h" +#include "gshub.h" + + +// Defined here to avoid link errors as this array is auto generated for the lfta and referenced in the clearinghouse library which gets linked against the hfta +gs_sp_t fta_names[]={0}; + + +/* HIGH LEVEL APPLICATION INTERFACE */ +/* ================================ */ + +struct fta_instance { + gs_sp_t name; + FTAID ftaid; + gs_int32_t used; + gs_schemahandle_t schema; +}; + + +struct fta_instance * instance_array=0; +gs_int32_t instance_array_sz=0; + +static gs_retval_t +add_fta(gs_sp_t name, FTAID ftaid, + gs_schemahandle_t schema) +{ + gs_int32_t x; + if ( instance_array_sz == 0) { + if ((instance_array = malloc(sizeof(struct fta_instance)*STARTSZ))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + memset(instance_array,0,sizeof(struct fta_instance)*STARTSZ); + instance_array_sz = STARTSZ; + } + for(x=0;(x<instance_array_sz)&&(instance_array[x].used!=0);x++); + if (x == instance_array_sz) { + gs_int32_t y; + instance_array_sz = 2*instance_array_sz; + if ((instance_array = + realloc(instance_array,instance_array_sz* + sizeof(struct fta_instance)))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + for (y=x;y<instance_array_sz;x++) + instance_array[y].used=0; + } + instance_array[x].name=strdup(name); + instance_array[x].ftaid=ftaid; + instance_array[x].schema=schema; + instance_array[x].used=1; + return 0; +} + +static gs_retval_t +rm_fta(FTAID ftaid) +{ + gs_int32_t x; + for (x=0;x<instance_array_sz;x++) { + if ( (instance_array[x].ftaid.ip=ftaid.ip) + && (instance_array[x].ftaid.port==ftaid.port) + && (instance_array[x].ftaid.index==ftaid.index) + && (instance_array[x].ftaid.streamid==ftaid.streamid)){ + instance_array[x].used=0; + } + } + return 0; +} + + +static struct fta_instance * +get_fta(FTAID ftaid) +{ + gs_int32_t x; + for (x=0;x<instance_array_sz;x++) { + if (( instance_array[x].used!=0 ) + && (instance_array[x].ftaid.ip==ftaid.ip) + && (instance_array[x].ftaid.port==ftaid.port) + && (instance_array[x].ftaid.index==ftaid.index) + && (instance_array[x].ftaid.streamid==ftaid.streamid)) + { + return &instance_array[x]; + } + } + return 0; +} + + + +gs_retval_t +ftaapp_init(gs_uint32_t bufsz) +{ + + endpoint gshub; + FTAID myftaid; + gs_sp_t name = "app\0"; + if (hostlib_init(APP,bufsz,DEFAULTDEV,0,0)!=0) { + gslog(LOG_EMERG,"ftaap_init::error:could not initialize hostlib\n"); + return -1; + } + if (get_hub(&gshub)!=0) { + gslog(LOG_EMERG,"ERROR:could not find gshub in appinterface init"); + return -1; + } + myftaid=gscpipc_getftaid(); + if (set_ftainstance(gshub,get_instance_name(),(gs_sp_t)name,&myftaid)!=0) { + gslog(LOG_EMERG,"ERROR:could not set_ftainstance"); + return -1; + } + return 0; +} + +/* this should be used before exiting to make sure everything gets + cleaned up + */ +gs_retval_t +ftaapp_exit() +{ + gs_int32_t x; + for (x=0;x<instance_array_sz;x++) { + if (instance_array[x].used!=0) { + ftaapp_remove_fta(instance_array[x].ftaid,1); + } + } + hostlib_free(); + return 0; +} + +/* adds an FTA by key returns unique streamid which can be used to reference FTA*/ + + +FTAID +ftaapp_add_fta(FTAname name, gs_uint32_t reuse, gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data) +{ + gs_int8_t schemabuf[MAXSCHEMASZ]; + gs_schemahandle_t schema; + FTAID f; + FTAID ferr; + ferr.ip=0; + ferr.port=0; + ferr.index=0; + ferr.streamid=0; + + + if (fta_find(name,reuse,&f,schemabuf,MAXSCHEMASZ)!=0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could not find FTA\n"); + return ferr; + } + + + if ((schema=ftaschema_parse_string(schemabuf))<0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could not parse schema\n"); + fprintf(stderr,"/n%s\n",schemabuf); + return ferr; + } + + if ((fta_alloc_instance(gscpipc_getftaid(),&f,name,schemabuf,reusable, + command,sz,data))!=0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could instantiate a FTA\n"); + ftaschema_free(schema); + return ferr; + } + + if (f.streamid==0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could instantiate a FTA\n"); + ftaschema_free(schema); + return ferr; + } + + //gslog(LOG_EMERG,"apptrace adding fta %u %u %u %u\n",f.ip,f.port,f.index,f.streamid); + if (add_fta((gs_sp_t)name,f,schema)<0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could not add fta to internal db\n"); + fta_free_instance(gscpipc_getftaid(),f,1); + ftaschema_free(schema); + return ferr; + } + + return f; +} + +FTAID ftaapp_add_fta_print(FTAname name, gs_uint32_t reuse, gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, + void * data,gs_sp_t path, + gs_sp_t basename, gs_sp_t temporal_field, gs_sp_t split_field, + gs_uint32_t delta, gs_uint32_t split) { + gs_int8_t schemabuf[MAXSCHEMASZ]; + gs_schemahandle_t schema; + FTAID f; + FTAID ferr; + ferr.ip=0; + ferr.port=0; + ferr.index=0; + ferr.streamid=0; + + + if (fta_find(name,reuse,&f,schemabuf,MAXSCHEMASZ)!=0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could not find FTA\n"); + return ferr; + } + + if ((schema=ftaschema_parse_string(schemabuf))<0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could not parse schema\n"); + return ferr; + } + + if ((fta_alloc_print_instance(gscpipc_getftaid(), + &f,name,schemabuf,reusable, + command,sz,data,path, + basename,temporal_field,split_field,delta,split))!=0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could instantiate a FTA\n"); + ftaschema_free(schema); + return ferr; + } + + if (f.streamid==0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could instantiate a FTA\n"); + ftaschema_free(schema); + return ferr; + } + + if (add_fta((gs_sp_t)name,f,schema)<0) { + gslog(LOG_EMERG,"ftaapp_add_fta::error:could not add fta to internal db\n"); + fta_free_instance(gscpipc_getftaid(),f,1); + ftaschema_free(schema); + return ferr; + } + + return f; +} + +/* get the schema definition of an FTA */ +gs_schemahandle_t +ftaapp_get_fta_schema(FTAID ftaid) +{ + struct fta_instance * fi; + + //gslog(LOG_EMERG,"apptrace checking fta %u %u %u %u\n",ftaid.ip,ftaid.port,ftaid.index,ftaid.streamid); + + if ((fi=get_fta(ftaid))==0) { + gslog(LOG_EMERG,"ftaapp_get_fta_schema::error:unknown streamid\n"); + return -1; + } + return fi->schema; +} + +/* get the asci schema definition for the FTA associated with the FTA name */ +gs_schemahandle_t ftaapp_get_fta_schema_by_name(gs_sp_t name) +{ + FTAID f; + gs_int8_t schemabuf[MAXSCHEMASZ]; + gs_schemahandle_t schema; + if (fta_find(name,0,&f,schemabuf,MAXSCHEMASZ)!=0) { + gslog(LOG_EMERG,"ftaapp_get_fta_schema_by_name::error:could not find FTA\n"); + return -1; + } + if ((schema=ftaschema_parse_string(schemabuf))<0) { + gslog(LOG_EMERG,"ftaapp_get_fta_schema_by_name::error:could not parse schema\n"); + return -1; + } + return schema; +} + +/* get the asci schema definition for the FTA associated with the FTA name */ +gs_sp_t ftaapp_get_fta_ascii_schema_by_name(gs_sp_t name) +{ + FTAID f; + static gs_int8_t schemabuf[MAXSCHEMASZ]; + if (fta_find(name,0,&f,schemabuf,MAXSCHEMASZ)!=0) { + gslog(LOG_EMERG,"ftaapp_get_fta_schema_by_name::error:could not find FTA\n"); + return 0; + } + return schemabuf; +} + +/* control operations keyed of one to one mapping of stream id */ +gs_retval_t +ftaapp_control(FTAID f, gs_int32_t command, gs_int32_t sz, void * data) +{ + struct fta_instance * fi; + if ((fi=get_fta(f))<0) { + gslog(LOG_EMERG,"ftaapp_control::error:unknown streamid\n"); + return -1; + } + return fta_control(gscpipc_getftaid(),fi->ftaid,command,sz,data); +} + +/* remove FTA keyed of stream id */ +gs_retval_t +ftaapp_remove_fta(FTAID f, gs_uint32_t recursive) +{ + struct fta_instance * fi; + if ((fi=get_fta(f))<0) { + gslog(LOG_EMERG,"ftaapp_control::error:unknown streamid\n"); + return -1; + } + + fta_free_instance(gscpipc_getftaid(),fi->ftaid,recursive); + ftaschema_free(fi->schema); + rm_fta(f); + + return 0; +} + +/* same as sgroup_get_buffer just repeated to have a complet ftapp interface and remove + the heartbeat tuples*/ +gs_retval_t +ftaapp_get_tuple(FTAID * ftaid, gs_uint32_t * size, void *tbuffer, + gs_int32_t tbuf_size, gs_int32_t timeout) +{ + gs_uint64_t trace_id; + gs_uint32_t sz; + fta_stat * trace; + gs_sp_t trace_buffer; + gs_retval_t res; + +get_tuple_again: + res=gscp_get_buffer(ftaid,(gs_int32_t *)size,tbuffer,tbuf_size,timeout); + + if ((res==0) && (ftaschema_is_temporal_tuple(get_fta(*ftaid)->schema, tbuffer))) { + FTAID myftaid; + myftaid=gscpipc_getftaid(); + /* extract trace */ + if (ftaschema_get_trace(get_fta(*ftaid)->schema, + tbuffer, *size, &trace_id, &sz, &trace)) + { + gslog(LOG_EMERG, "ftaapp_get_tuple:Error: temporal tuple with no trace\n"); + goto get_tuple_again; + } + + if ((trace_buffer=(gs_sp_t)malloc((sz+1)*sizeof(fta_stat)))==0) { + gslog(LOG_EMERG,"ftaapp_get_tuple::Error: allocation for trace tuple failed\n"); + goto get_tuple_again; + } + + /* generate a heartbeat */ + memcpy(trace_buffer, trace, sz * sizeof(fta_stat)); + /* append producers fta_stat to the trace */ + /* for now we will just fill the FTAID part with 0 of fta_stat, the rest will be cleared */ + memset(trace_buffer + (sz * sizeof(fta_stat)), 0, sizeof(fta_stat)); + + memcpy(trace_buffer + (sz * sizeof(fta_stat)), &myftaid, sizeof(FTAID)); + + fta_heartbeat(gscpipc_getftaid(), trace_id, sz+1, (fta_stat *)trace_buffer); + free(trace_buffer); + res=2; //indicate that it is a temporal tuple + } + return res; +} diff --git a/src/lib/gscpaux/Makefile b/src/lib/gscpaux/Makefile new file mode 100644 index 0000000..d266fe9 --- /dev/null +++ b/src/lib/gscpaux/Makefile @@ -0,0 +1,36 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CPPFLAGS = -DNDEBUG -DSTAND_ALONE -I. -I../../../include/ +CC = gcc -O4 -g +CPP = g++ -O4 -g + +all: libgscpaux.a + +install : all + cp libgscpaux.a ../../../lib/ + +libgscpaux.a : gshub.o simple_http.o json.o block_allocator.o + ar cr $@ $? + ( ranlib $@ ) 2>/dev/null || true + cp libgscpaux.a ../../../lib/ + +INCDIR=../../../include +LFTA_DIR=$(INCDIR/lfta) +HFTA_DIR=$(INCDIR/hfta) + + +clean: + rm -f */*.o */*/*.o *.o libgscpaux.a diff --git a/src/lib/gscpaux/block_allocator.cpp b/src/lib/gscpaux/block_allocator.cpp new file mode 100644 index 0000000..5d0fbdc --- /dev/null +++ b/src/lib/gscpaux/block_allocator.cpp @@ -0,0 +1,52 @@ +// Distributed under the MIT license. Copyright (c) 2010, Ivan Vashchaev + +#include <stdlib.h> +#include <algorithm> +#include "block_allocator.h" + +block_allocator::block_allocator(size_t blocksize): m_head(0), m_blocksize(blocksize) +{ +} + +block_allocator::~block_allocator() +{ + while (m_head) + { + block *temp = m_head->next; + ::free(m_head); + m_head = temp; + } +} + +void block_allocator::swap(block_allocator &rhs) +{ + std::swap(m_blocksize, rhs.m_blocksize); + std::swap(m_head, rhs.m_head); +} + +void *block_allocator::malloc(size_t size) +{ + if ((m_head && m_head->used + size > m_head->size) || !m_head) + { + // calc needed size for allocation + size_t alloc_size = std::max(sizeof(block) + size, m_blocksize); + + // create new block + char *buffer = (char *)::malloc(alloc_size); + block *b = reinterpret_cast<block *>(buffer); + b->size = alloc_size; + b->used = sizeof(block); + b->buffer = buffer; + b->next = m_head; + m_head = b; + } + + void *ptr = m_head->buffer + m_head->used; + m_head->used += size; + return ptr; +} + +void block_allocator::free() +{ + block_allocator(0).swap(*this); +} diff --git a/src/lib/gscpaux/block_allocator.h b/src/lib/gscpaux/block_allocator.h new file mode 100644 index 0000000..ae9fc4f --- /dev/null +++ b/src/lib/gscpaux/block_allocator.h @@ -0,0 +1,37 @@ +// Distributed under the MIT license. Copyright (c) 2010, Ivan Vashchaev + +#ifndef BLOCK_ALLOCATOR_H +#define BLOCK_ALLOCATOR_H + +class block_allocator +{ +private: + struct block + { + size_t size; + size_t used; + char *buffer; + block *next; + }; + + block *m_head; + size_t m_blocksize; + + block_allocator(const block_allocator &); + block_allocator &operator=(block_allocator &); + +public: + block_allocator(size_t blocksize); + ~block_allocator(); + + // exchange contents with rhs + void swap(block_allocator &rhs); + + // allocate memory + void *malloc(size_t size); + + // free all allocated blocks + void free(); +}; + +#endif diff --git a/src/lib/gscpaux/gshub.cpp b/src/lib/gscpaux/gshub.cpp new file mode 100644 index 0000000..b21ca0f --- /dev/null +++ b/src/lib/gscpaux/gshub.cpp @@ -0,0 +1,294 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "gshub.h" +#include "gslog.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <arpa/inet.h> +#include <unistd.h> + +#include "simple_http.h" +#include "json.h" + +// maximum length of URL for http requests +#define MAX_URL_LEN 64 * 1024 + +// maximu length of JSON response +#define MAX_JSON_LEN 64 * 1024 + +// sleep time between HTTP request retries +#define HTTP_RETRY_INTERVAL 5 + +// GSHUB endpoint +endpoint hub; + +// GSHUB instance_name +gs_sp_t instance_name=0; + + +// retrieve the endpoint of gs instance, source or sink identified by url +gs_retval_t get_service_endpoint (endpoint gshub, gs_csp_t url, endpoint* instance, gs_bool_t block) { + int res, ret; + gs_uint32_t http_code; + char json[MAX_JSON_LEN]; + + while (true) { + res = http_get_request(gshub, url, &http_code, json); + if(res) { + fprintf(stderr, "http_get_request() failed\n"); + ret = -1; + } + else { + // in blocking mode we will keep retrying + if (http_code == 400) { + if (block) { + sleep(HTTP_RETRY_INTERVAL); + continue; + } else { + ret = 1; + break; + } + + } + if (http_code == 200 ) { + // if instance is NULL there is no need to parse json + if (!instance) { + ret = 0; + break; + } + + // now parse json response + char *errorPos = 0; + char *errorDesc = 0; + int errorLine = 0; + block_allocator allocator(1 << 10); // 1 KB per block + + json_value *root = json_parse(json, &errorPos, (const char**)&errorDesc, &errorLine, &allocator); + if (!root) { + fprintf(stderr, "GSHUB returned invalid json response, error description - %s, error line - %d\n", errorDesc, errorLine); + ret = -1; + } else { + unsigned long json_ip = 0; + bool ip_set = false; + unsigned json_port = 0; + bool port_set = false; + for (json_value *it = root->first_child; it; it = it->next_sibling) { + if (it->name) { + if (!strcmp(it->name, "ip") && it->type == JSON_STRING) { + inet_pton(AF_INET, it->string_value, &json_ip); + ip_set = true; + } else if (!strcmp(it->name, "port") && it->type == JSON_INT) { + json_port = htons(it->int_value); + port_set = true; + } + } + } + + if (!ip_set || !port_set) { + fprintf(stderr, "GSHUB returned json response with missing ip or port fields"); + ret = -1; + } + instance->ip = json_ip; + instance->port = json_port; + + ret = 0; + } + } else + ret = -1; + } + break; + } + + return ret; + +} + +// announce gs instance/sink/source to gshub. GSHUB is identified by URL, instance/sink/source information is in application/json +gs_retval_t set_endpoint_info (endpoint gshub, gs_csp_t url, char* info) { + int res; + gs_uint32_t http_code; + + res = http_post_request(gshub, url, info, &http_code); + if (res) { + fprintf(stderr, "http_post_request() failed\n"); + return -1; + } + + if (http_code == 200) + return 0; + else + return -1; +} + +extern "C" gs_retval_t set_instance_name(gs_sp_t instancename){ + instance_name=strdup(instancename); + + return 0; +} + +extern "C" gs_sp_t get_instance_name() { + return instance_name; +} + +// save gshub endpoint +extern "C" gs_retval_t set_hub(endpoint gshub) { + hub.ip = gshub.ip; + hub.port = gshub.port; + + return 0; +} + +// retrieve gsbub endpoint +extern "C" gs_retval_t get_hub(endpoint* gshub) { + + if (hub.ip==0) + return -1; + gshub->ip = hub.ip; + gshub->port = hub.port; + + return 0; +} + +// Discover gs instance endpoint by name. +extern "C" gs_retval_t get_instance(endpoint gshub, gs_sp_t instance_name, endpoint* instance, gs_bool_t block) { + char url[MAX_URL_LEN]; + + sprintf(url, "%s/%s", DISCOVER_INSTANCE_URL, instance_name); + + return get_service_endpoint(gshub, url, instance, block); +} + +// Discover initialized gs instance endpoint by name. +extern "C" gs_retval_t get_initinstance(endpoint gshub, gs_sp_t instance_name, endpoint* instance, gs_bool_t block) { + char url[MAX_URL_LEN]; + + sprintf(url, "%s/%s", DISCOVER_INITINSTANCE_URL, instance_name); + + return get_service_endpoint(gshub, url, instance, block); +} + +// Discover stream source endpoint by name. +extern "C" gs_retval_t get_streamsource(endpoint gshub, gs_sp_t source_name, endpoint* source, gs_bool_t block) { + char url[MAX_URL_LEN]; + + sprintf(url, "%s/%s", DISCOVER_SOURCE_URL, source_name); + + return get_service_endpoint(gshub, url, source, block); +} + +// Discover stream sink endpoint by name. +extern "C" gs_retval_t get_streamsink(endpoint gshub, gs_sp_t sink_name, endpoint* sink, gs_bool_t block) { + char url[MAX_URL_LEN]; + + sprintf(url, "%s/%s", DISCOVER_SINK_URL, sink_name); + + return get_service_endpoint(gshub, url, sink, block); +} + +// Discover if an isntance should start processing +gs_retval_t get_startprocessing(endpoint gshub, gs_sp_t instance_name, gs_bool_t block) { + char url[MAX_URL_LEN]; + + sprintf(url, "%s/%s", DISCOVER_STARTPROCESSING_URL, instance_name); + + return get_service_endpoint(gshub, url, NULL, block); +} + +// Announce gs instance endpoint to gshub +extern "C" gs_retval_t set_instance(endpoint gshub, gs_sp_t instance_name, endpoint instance) { + char ipstr[16]; + char info[MAX_JSON_LEN]; + + inet_ntop(AF_INET, &instance.ip, ipstr, INET_ADDRSTRLEN); + sprintf(info, "{\"name\": \"%s\", \"ip\": \"%s\", \"port\": %d}", instance_name, ipstr, ntohs(instance.port)); + + return set_endpoint_info(gshub, ANNOUNCE_INSTANCE_URL, info); +} + +// Announce initialized gs instance endpoint to gshub +extern "C" gs_retval_t set_initinstance(endpoint gshub, gs_sp_t instance_name) { + char info[MAX_JSON_LEN]; + + sprintf(info, "{\"name\": \"%s\"}", instance_name); + + return set_endpoint_info(gshub, ANNOUNCE_INITINSTANCE_URL, info); +} + +// Announce stream source endpoint to gshub +extern "C" gs_retval_t set_streamsource(endpoint gshub, gs_sp_t source_name, endpoint source) { + char ipstr[16]; + char info[MAX_JSON_LEN]; + + inet_ntop(AF_INET, &source.ip, ipstr, INET_ADDRSTRLEN); + sprintf(info, "{\"name\": \"%s\", \"ip\": \"%s\", \"port\": %d}", source_name, ipstr, ntohs(source.port)); + + return set_endpoint_info(gshub, ANNOUNCE_SOURCE_URL, info); +} + +// Announce stream source endpoint to gshub +extern "C" gs_retval_t set_streamsink(endpoint gshub, gs_sp_t sink_name, endpoint sink) { + char ipstr[16]; + char info[MAX_JSON_LEN]; + + inet_ntop(AF_INET, &sink.ip, ipstr, INET_ADDRSTRLEN); + sprintf(info, "{\"name\": \"%s\", \"ip\": \"%s\", \"port\": %d}", sink_name, ipstr, ntohs(sink.port)); + + return set_endpoint_info(gshub, ANNOUNCE_SINK_URL, info); +} + +// Announce to gshub that an instance can start processin +extern "C" gs_retval_t set_startprocessing(endpoint gshub, gs_sp_t instance_name) { + char info[MAX_JSON_LEN]; + + sprintf(info, "{\"name\": \"%s\"}", instance_name); + + return set_endpoint_info(gshub, ANNOUNCE_STARTPROCESSING_URL, info); +} + +// Announce stream subscriptino to gshub +extern "C" gs_retval_t set_streamsubscription(endpoint gshub, gs_sp_t instance_name, gs_sp_t sink_name) { + char info[MAX_JSON_LEN]; + + sprintf(info, "{\"name\": \"%s\", \"sink\": \"%s\"}", instance_name, sink_name); + + return set_endpoint_info(gshub, ANNOUNCE_STREAM_SUBSCRIPTION, info); +} + +// Announce new fta instantiation to gshub +extern "C" gs_retval_t set_ftainstance(endpoint gshub, gs_sp_t instance_name, gs_sp_t ftainstance_name, FTAID* id) { + char info[MAX_JSON_LEN]; + + sprintf(info, "{\"name\": \"%s\", \"fta_name\": \"%s\", \"ftaid\": {\"ip\": %u, \"port\": %u, \"index\": %u, \"streamid\": %lli}}", + instance_name, ftainstance_name, id->ip, id->port, id->index, id->streamid); + + return set_endpoint_info(gshub, ANNOUNCE_FTA_INSTANCE, info); +} + +// Announce fta instance stats to gshub +extern "C" gs_retval_t set_instancestats(endpoint gshub, gs_sp_t instance_name, fta_stat* stats) { + char url[MAX_URL_LEN]; + char info[MAX_JSON_LEN]; + + sprintf(info, "{\"name\": \"%s\", \"ftaid\": {\"ip\": %u, \"port\": %u, \"index\": %u, \"streamid\": %llu}, " + "\"metrics\": {\"in_tuple_cnt\": %u, \"out_tuple_cnt\": %u, \"out_tuple_sz\": %u, \"accepted_tuple_cnt\": %u, \"cycle_cnt\": %llu, \"collision_cnt\": %u, \"eviction_cnt\": %u, \"sampling_rate\": %f}}", + instance_name, stats->ftaid.ip, stats->ftaid.port, stats->ftaid.index, stats->ftaid.streamid, + stats->in_tuple_cnt, stats->out_tuple_cnt, stats->out_tuple_sz, stats->accepted_tuple_cnt, stats->cycle_cnt, stats->collision_cnt, stats->eviction_cnt, stats->sampling_rate); + + return set_endpoint_info(gshub, ANNOUNCE_METRICS, info); +} + diff --git a/src/lib/gscpaux/json.cpp b/src/lib/gscpaux/json.cpp new file mode 100644 index 0000000..149c4c5 --- /dev/null +++ b/src/lib/gscpaux/json.cpp @@ -0,0 +1,475 @@ +// Distributed under the MIT license. Copyright (c) 2010, Ivan Vashchaev + +#include <string.h> +#include "json.h" + +// true if character represent a digit +#define IS_DIGIT(c) (c >= '0' && c <= '9') + +// convert string to integer +static char *atoi(char *first, char *last, int *out) +{ + int sign = 1; + if (first != last) + { + if (*first == '-') + { + sign = -1; + ++first; + } + else if (*first == '+') + { + ++first; + } + } + + int result = 0; + for (; first != last && IS_DIGIT(*first); ++first) + { + result = 10 * result + (*first - '0'); + } + *out = result * sign; + + return first; +} + +// convert hexadecimal string to unsigned integer +static char *hatoui(char *first, char *last, unsigned int *out) +{ + unsigned int result = 0; + for (; first != last; ++first) + { + int digit; + if (IS_DIGIT(*first)) + { + digit = *first - '0'; + } + else if (*first >= 'a' && *first <= 'f') + { + digit = *first - 'a' + 10; + } + else if (*first >= 'A' && *first <= 'F') + { + digit = *first - 'A' + 10; + } + else + { + break; + } + result = 16 * result + (unsigned int)digit; + } + *out = result; + + return first; +} + +// convert string to floating point +static char *atof(char *first, char *last, float *out) +{ + // sign + float sign = 1; + if (first != last) + { + if (*first == '-') + { + sign = -1; + ++first; + } + else if (*first == '+') + { + ++first; + } + } + + // integer part + float result = 0; + for (; first != last && IS_DIGIT(*first); ++first) + { + result = 10 * result + (float)(*first - '0'); + } + + // fraction part + if (first != last && *first == '.') + { + ++first; + + float inv_base = 0.1f; + for (; first != last && IS_DIGIT(*first); ++first) + { + result += (float)(*first - '0') * inv_base; + inv_base *= 0.1f; + } + } + + // result w\o exponent + result *= sign; + + // exponent + bool exponent_negative = false; + int exponent = 0; + if (first != last && (*first == 'e' || *first == 'E')) + { + ++first; + + if (*first == '-') + { + exponent_negative = true; + ++first; + } + else if (*first == '+') + { + ++first; + } + + for (; first != last && IS_DIGIT(*first); ++first) + { + exponent = 10 * exponent + (*first - '0'); + } + } + + if (exponent) + { + float power_of_ten = 10; + for (; exponent > 1; exponent--) + { + power_of_ten *= 10; + } + + if (exponent_negative) + { + result /= power_of_ten; + } + else + { + result *= power_of_ten; + } + } + + *out = result; + + return first; +} + +static inline json_value *json_alloc(block_allocator *allocator) +{ + json_value *value = (json_value *)allocator->malloc(sizeof(json_value)); + memset(value, 0, sizeof(json_value)); + return value; +} + +static inline void json_append(json_value *lhs, json_value *rhs) +{ + rhs->parent = lhs; + if (lhs->last_child) + { + lhs->last_child = lhs->last_child->next_sibling = rhs; + } + else + { + lhs->first_child = lhs->last_child = rhs; + } +} + +#define ERROR(it, desc)\ + *error_pos = it;\ + *error_desc = desc;\ + *error_line = 1 - escaped_newlines;\ + for (char *c = it; c != source; --c)\ + if (*c == '\n') ++*error_line;\ + return 0 + +#define CHECK_TOP() if (!top) {ERROR(it, "Unexpected character");} + +json_value *json_parse(char *source, char **error_pos, const char **error_desc, int *error_line, block_allocator *allocator) +{ + json_value *root = 0; + json_value *top = 0; + + char *name = 0; + char *it = source; + + int escaped_newlines = 0; + + while (*it) + { + // skip white space + while (*it == '\x20' || *it == '\x9' || *it == '\xD' || *it == '\xA') + { + ++it; + } + + switch (*it) + { + case '\0': + break; + case '{': + case '[': + { + // create new value + json_value *object = json_alloc(allocator); + + // name + object->name = name; + name = 0; + + // type + object->type = (*it == '{') ? JSON_OBJECT : JSON_ARRAY; + + // skip open character + ++it; + + // set top and root + if (top) + { + json_append(top, object); + } + else if (!root) + { + root = object; + } + else + { + ERROR(it, "Second root. Only one root allowed"); + } + top = object; + } + break; + + case '}': + case ']': + { + if (!top || top->type != ((*it == '}') ? JSON_OBJECT : JSON_ARRAY)) + { + ERROR(it, "Mismatch closing brace/bracket"); + } + + // skip close character + ++it; + + // set top + top = top->parent; + } + break; + + case ':': + if (!top || top->type != JSON_OBJECT) + { + ERROR(it, "Unexpected character"); + } + ++it; + break; + + case ',': + CHECK_TOP(); + ++it; + break; + + case '"': + { + CHECK_TOP(); + + // skip '"' character + ++it; + + char *first = it; + char *last = it; + while (*it) + { + if ((unsigned char)*it < '\x20') + { + ERROR(first, "Control characters not allowed in strings"); + } + else if (*it == '\\') + { + switch (it[1]) + { + case '"': + *last = '"'; + break; + case '\\': + *last = '\\'; + break; + case '/': + *last = '/'; + break; + case 'b': + *last = '\b'; + break; + case 'f': + *last = '\f'; + break; + case 'n': + *last = '\n'; + ++escaped_newlines; + break; + case 'r': + *last = '\r'; + break; + case 't': + *last = '\t'; + break; + case 'u': + { + unsigned int codepoint; + if (hatoui(it + 2, it + 6, &codepoint) != it + 6) + { + ERROR(it, "Bad unicode codepoint"); + } + + if (codepoint <= 0x7F) + { + *last = (char)codepoint; + } + else if (codepoint <= 0x7FF) + { + *last++ = (char)(0xC0 | (codepoint >> 6)); + *last = (char)(0x80 | (codepoint & 0x3F)); + } + else if (codepoint <= 0xFFFF) + { + *last++ = (char)(0xE0 | (codepoint >> 12)); + *last++ = (char)(0x80 | ((codepoint >> 6) & 0x3F)); + *last = (char)(0x80 | (codepoint & 0x3F)); + } + } + it += 4; + break; + default: + ERROR(first, "Unrecognized escape sequence"); + } + + ++last; + it += 2; + } + else if (*it == '"') + { + *last = 0; + ++it; + break; + } + else + { + *last++ = *it++; + } + } + + if (!name && top->type == JSON_OBJECT) + { + // field name in object + name = first; + } + else + { + // new string value + json_value *object = json_alloc(allocator); + + object->name = name; + name = 0; + + object->type = JSON_STRING; + object->string_value = first; + + json_append(top, object); + } + } + break; + + case 'n': + case 't': + case 'f': + { + CHECK_TOP(); + + // new null/bool value + json_value *object = json_alloc(allocator); + + object->name = name; + name = 0; + + // null + if (it[0] == 'n' && it[1] == 'u' && it[2] == 'l' && it[3] == 'l') + { + object->type = JSON_NULL; + it += 4; + } + // true + else if (it[0] == 't' && it[1] == 'r' && it[2] == 'u' && it[3] == 'e') + { + object->type = JSON_BOOL; + object->int_value = 1; + it += 4; + } + // false + else if (it[0] == 'f' && it[1] == 'a' && it[2] == 'l' && it[3] == 's' && it[4] == 'e') + { + object->type = JSON_BOOL; + object->int_value = 0; + it += 5; + } + else + { + ERROR(it, "Unknown identifier"); + } + + json_append(top, object); + } + break; + + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + CHECK_TOP(); + + // new number value + json_value *object = json_alloc(allocator); + + object->name = name; + name = 0; + + object->type = JSON_INT; + + char *first = it; + while (*it != '\x20' && *it != '\x9' && *it != '\xD' && *it != '\xA' && *it != ',' && *it != ']' && *it != '}') + { + if (*it == '.' || *it == 'e' || *it == 'E') + { + object->type = JSON_FLOAT; + } + ++it; + } + + if (object->type == JSON_INT && atoi(first, it, &object->int_value) != it) + { + ERROR(first, "Bad integer number"); + } + + if (object->type == JSON_FLOAT && atof(first, it, &object->float_value) != it) + { + ERROR(first, "Bad float number"); + } + + json_append(top, object); + } + break; + + default: + ERROR(it, "Unexpected character"); + } + } + + if (top) + { + ERROR(it, "Not all objects/arrays have been properly closed"); + } + + return root; +} diff --git a/src/lib/gscpaux/json.h b/src/lib/gscpaux/json.h new file mode 100644 index 0000000..b8bed06 --- /dev/null +++ b/src/lib/gscpaux/json.h @@ -0,0 +1,39 @@ +// Distributed under the MIT license. Copyright (c) 2010, Ivan Vashchaev + +#ifndef JSON_H +#define JSON_H + +#include "block_allocator.h" + +enum json_type +{ + JSON_NULL, + JSON_OBJECT, + JSON_ARRAY, + JSON_STRING, + JSON_INT, + JSON_FLOAT, + JSON_BOOL, +}; + +struct json_value +{ + json_value *parent; + json_value *next_sibling; + json_value *first_child; + json_value *last_child; + + char *name; + union + { + char *string_value; + int int_value; + float float_value; + }; + + json_type type; +}; + +json_value *json_parse(char *source, char **error_pos, const char **error_desc, int *error_line, block_allocator *allocator); + +#endif diff --git a/src/lib/gscpaux/simple_http.cpp b/src/lib/gscpaux/simple_http.cpp new file mode 100644 index 0000000..92107b6 --- /dev/null +++ b/src/lib/gscpaux/simple_http.cpp @@ -0,0 +1,241 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include <arpa/inet.h> +#include <netinet/in.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/wait.h> +#include <netdb.h> +#include <unistd.h> + +#include "simple_http.h" + +#define MAX_HTTP_REQUEST 64 * 1024 + + +// perform HTTP GET and retrieve the json response +int http_get_request(endpoint addr, gs_csp_t url, gs_uint32_t* http_code, gs_sp_t json_response) { + + int sockfd; + struct sockaddr_in servaddr; + char request_buf[MAX_HTTP_REQUEST]; + char response_buf[MAX_HTTP_REQUEST]; + char temp_buf[MAX_HTTP_REQUEST]; + char content_type[MAX_HTTP_REQUEST]; + int n; + + char ipstr[16]; + inet_ntop(AF_INET, &addr.ip, ipstr, INET_ADDRSTRLEN); + + sockfd = socket(AF_INET, SOCK_STREAM, 0); + if (!sockfd) { + fprintf(stderr, "Unable to create socket for HTTP connection\n"); + return -1; + } + + bzero(&servaddr, sizeof(servaddr)); + servaddr.sin_family = AF_INET; + servaddr.sin_port = addr.port; + servaddr.sin_addr.s_addr = addr.ip; + + if (connect(sockfd, (sockaddr*)&servaddr, sizeof(servaddr))) { + fprintf(stderr, "Unable to connect to HTTP server\n"); + return -1; + } + + // construct HTTP request + sprintf(request_buf, "GET %s HTTP/1.0\r\n" + "Host: %s\r\n" + "Accept: application/json\r\n" + "Connection: close\r\n\r\n", + url, ipstr); + + write(sockfd, request_buf, strlen(request_buf)); + + // retrive HTTP response + char* write_pos = response_buf; + while ((n = read(sockfd, write_pos, MAX_HTTP_REQUEST)) > 0) + write_pos += n; + *write_pos = '\0'; + close(sockfd); + + // split HTTP response into header and the main body + char* header_end = strstr(response_buf, "\r\n\r\n"); + *header_end = 0; + strcpy(json_response, header_end + 4); + + // parse HTTP header + char* header_line = strtok(response_buf, "\r\n"); + int ver1, ver2; + + // extract http response code + sscanf (header_line, "HTTP/%d.%d %d %s", &ver1, &ver2, http_code, temp_buf); + + // extract content-type + *content_type = 0; + while ((header_line = strtok(NULL, "\r\n"))) { + if (!strncmp(header_line, "Content-Type: ", strlen("Content-Type: "))) { + strcpy(content_type, header_line + strlen("Content-Type: ")); + if (strcmp(content_type, "application/json")) { + fprintf(stderr, "Invalid Content-Type %s, application/json expected\n", content_type); + return -1; + } + break; // we only care about Content-Type headers + } + } + + if ((*http_code == 200) && (*content_type == 0)) { + fprintf(stderr, "Missing Content-Type in server response, application/json expected\n"); + return -1; + } + + + return 0; +} + +// perform HTTP POST request ignoring the response +int http_post_request(endpoint addr, gs_csp_t url, gs_sp_t json_request, gs_uint32_t* http_code) { + int sockfd; + struct sockaddr_in servaddr; + char request_buf[MAX_HTTP_REQUEST]; + char response_buf[MAX_HTTP_REQUEST]; + char temp_buf[MAX_HTTP_REQUEST]; + int n; + + char ipstr[16]; + inet_ntop(AF_INET, &addr.ip, ipstr, INET_ADDRSTRLEN); + + sockfd = socket(AF_INET, SOCK_STREAM, 0); + if (!sockfd) { + fprintf(stderr, "Unable to create socket for HTTP connection\n"); + return -1; + } + + bzero(&servaddr, sizeof(servaddr)); + servaddr.sin_family = AF_INET; + servaddr.sin_port = addr.port; + servaddr.sin_addr.s_addr = addr.ip; + + if (connect(sockfd, (sockaddr*)&servaddr, sizeof(servaddr))) { + fprintf(stderr, "Unable to connect to HTTP server\n"); + return -1; + } + + // construct HTTP request + sprintf(request_buf, "POST %s HTTP/1.0\r\n" + "Host: %s\r\n" + "Content-Type: application/json\r\n" + "Content-Length: %lu\r\n" + "Connection: close\r\n\r\n" + "%s", + url, ipstr, strlen(json_request), json_request); + + write(sockfd, request_buf, strlen(request_buf)); + + // retrive HTTP response + char* write_pos = response_buf; + while ((n = read(sockfd, write_pos, MAX_HTTP_REQUEST)) > 0) + write_pos += n; + *write_pos = '\0'; + close(sockfd); + + // parse HTTP header + char* header_line = strtok(response_buf, "\r\n"); + int ver1, ver2; + + // extract http response code + sscanf (header_line, "HTTP/%d.%d %d %s", &ver1, &ver2, http_code, temp_buf); + + return 0; +} + + +// perform HTTP POST request ignoring the response +int http_post_request_hdr(endpoint addr, gs_csp_t url, gs_sp_t json_request, gs_uint32_t* http_code, gs_sp_t extra_headers) { + int sockfd; + struct sockaddr_in servaddr; + char request_buf[MAX_HTTP_REQUEST]; + char response_buf[MAX_HTTP_REQUEST]; + char temp_buf[MAX_HTTP_REQUEST]; + int n; + + char ipstr[16]; + inet_ntop(AF_INET, &addr.ip, ipstr, INET_ADDRSTRLEN); + + sockfd = socket(AF_INET, SOCK_STREAM, 0); + if (!sockfd) { + fprintf(stderr, "Unable to create socket for HTTP connection\n"); + return -1; + } + + bzero(&servaddr, sizeof(servaddr)); + servaddr.sin_family = AF_INET; + servaddr.sin_port = addr.port; + servaddr.sin_addr.s_addr = addr.ip; + + if (connect(sockfd, (sockaddr*)&servaddr, sizeof(servaddr))) { + fprintf(stderr, "Unable to connect to HTTP server\n"); + return -1; + } + + // construct HTTP request + if(strlen(extra_headers)==0){ + sprintf(request_buf, "POST %s HTTP/1.0\r\n" + "Host: %s\r\n" + "Content-Type: application/json\r\n" + "Content-Length: %lu\r\n" + "\r\n" + "%s", + url, ipstr, strlen(json_request), json_request); + }else{ + sprintf(request_buf, "POST %s HTTP/1.0\r\n" + "Host: %s\r\n" + "Content-Type: application/json\r\n" + "Content-Length: %lu\r\n" + "%s\r\n\r\n" + "%s", + url, ipstr, strlen(json_request), extra_headers, json_request); + } + + write(sockfd, request_buf, strlen(request_buf)); + + // retrive HTTP response + char* write_pos = response_buf; + while ((n = read(sockfd, write_pos, MAX_HTTP_REQUEST)) > 0) + write_pos += n; + *write_pos = '\0'; + close(sockfd); + if(write_pos==response_buf){ + fprintf(stderr,"Empty response from HTTP server.\n"); + return -1; + } + + // parse HTTP header + char* header_line = strtok(response_buf, "\r\n"); + if(header_line==NULL){ + fprintf(stderr,"unparseable response from HTTP server.\n"); + return -1; + } + int ver1, ver2; + + // extract http response code + sscanf (header_line, "HTTP/%d.%d %d %s", &ver1, &ver2, http_code, temp_buf); + + return 0; +} diff --git a/src/lib/gscphftaaux/Makefile b/src/lib/gscphftaaux/Makefile new file mode 100644 index 0000000..a6e87b1 --- /dev/null +++ b/src/lib/gscphftaaux/Makefile @@ -0,0 +1,48 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CXX= g++ -O3 -fexpensive-optimizations -g -I ../gscpaux/ -I ../../../include -I ../../../include/hfta -I ../../../include/lfta +CC= gcc -fexpensive-optimizations -O3 -I ../../../include -I ../../../include/lfta + +INCDIR=../../../include +HFTA_DIR=$(INCDIR/hfta) +LFTA_DIR=$(INCDIR/lfta) + +all: libgscphftaaux.a + +install: all + cp libgscphftaaux.a ../../../lib ; ranlib ../../../lib/libgscphftaaux.a + +libgscphftaaux.a: SSstateful_count_distinct.o Manku_HH.o hfta_runtime_library.o Makefile hfta_udaf.o + ar rc libgscphftaaux.a SSstateful_count_distinct.o Manku_HH.o hfta_runtime_library.o hfta_udaf.o + +hfta_runtime_library.o: hfta_runtime_library.cc + +hfta_runtime_library.cc : $(HFTA_DIR/host_tuple.h) $(INCDIR/fta.h) + +hfta_udaf.o: hfta_udaf.cc + +hfta_udaf.cc : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(HFTA_DIR/hfta_udaf.h) $(LFTA_DIR/rts_udaf.h) + +Manku_HH.o: Manku_HH.cc + $(CXX) -c -o Manku_HH.o Manku_HH.cc + +SSstateful_count_distinct.o: SSstateful_count_distinct.cc + $(CXX) -c -o SSstateful_count_distinct.o SSstateful_count_distinct.cc + + +clean: + rm -f *.o *.a core + diff --git a/src/lib/gscphftaaux/Manku_HH.cc b/src/lib/gscphftaaux/Manku_HH.cc new file mode 100644 index 0000000..24c3393 --- /dev/null +++ b/src/lib/gscphftaaux/Manku_HH.cc @@ -0,0 +1,73 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +//######################################### +// Stateful functions for Manku and Motwani +// heavy hitters algorithm +//######################################## + +#include <iostream> +#define max(x,y) ((x)>(y)?(x):(y)) + +struct MankuHHstate { + unsigned int count; + unsigned int count_bucket; + unsigned int need_to_clean; +}; + +void _sfun_state_clean_init_manku_hh_state(void *s){ + struct MankuHHstate *state = (struct MankuHHstate *)s; + + state->count = 0; + state->count_bucket = 1; + state->need_to_clean = 0; + +} + +void _sfun_state_dirty_init_manku_hh_state(void *s_new, void *s_old, int curr_num_samples){ + struct MankuHHstate *state_new = (struct MankuHHstate *)s_new; + struct MankuHHstate *state_old = (struct MankuHHstate *)s_old; + + state_new->count = 0; + state_new->count_bucket = 1; +} + +void _sfun_state_final_init_manku_hh_state(void *s, int curr_num_samples){ + struct MankuHHstate *state = (struct MankuHHstate *)s; +} + +int local_count(void *s,int curr_num_samples, unsigned int bucket_size){ + struct MankuHHstate *state = (struct MankuHHstate *)s; + + state->count++; + if(state->count >= bucket_size){ + //cout << "bucket_size: " << bucket_size << "\n"; + state->count_bucket++; + state->need_to_clean = 1; + //cout << "bucket_count: " << state->count_bucket << "\n"; + //cout << "packet count: " << state->count << "\n"; + state->count = 0; + return 1; + } + return 0; +} + +unsigned int current_bucket(void *s, int curr_num_samples){ + struct MankuHHstate *state = (struct MankuHHstate *)s; + if(state->need_to_clean == 1){ + state->need_to_clean = 0; + return (state->count_bucket)-1; + } + return state->count_bucket; +} diff --git a/src/lib/gscphftaaux/SSstateful_count_distinct.cc b/src/lib/gscphftaaux/SSstateful_count_distinct.cc new file mode 100644 index 0000000..0adec27 --- /dev/null +++ b/src/lib/gscphftaaux/SSstateful_count_distinct.cc @@ -0,0 +1,623 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +/////////////////////////////////////////////// +//// State, functions for adaptive smart sampling +/// written by Irina Rozenbaum + +#include <iostream> +#define max(x,y) ((x)>(y)?(x):(y)) +#define _BURST_SOOTHING_FACTOR 10.0 + +struct SSstate { + //unsigned long long int count; // count to sample small packets with certain probability + double count; + double gcount; // count for clean_with() function + double fcount; // count for final_clean() function + double z; //z is the threshold for a size of the packet + double z_prev; // value of threshold from the previos cleaning phase + double gamma; //tolerance parameter for emergency control over the + //number of samples, should be >= 1 + int do_clean; // trigger cleaning phase + int bcount; //count for number of packets that exceed threshold , + //need it for one of the variations of algorithms for + //threshold adjustment + int s_size; //need to remember sample size for _sfun_state_init() + int final_z; //bool that indicated if z was adjusted to its filnal value + //before the final clean + int time; //timestamp from previously processed packet + //used in detecting frequency of the clening phases with aggregation + + int packet_count; //count for number of packets per time window + int do_clean_count; //count number of cleaning phases per time window + bool do_sooth; //turn on _BURST_SOOTHING_FACTOR + + // flow sampling + int count_closed; //bool indicates that counting phase is being triggered + int count_closed_flows; //count for closed flows + int count_notsampled_new; //count for the number of new groups that were not sampled during + // the final sampling phase will be used in next time window to compute resonable + // approximation for threshold before final sampling phase + + // for reporting + int delay; //interval within which there was no packets that belong to the current flow + //thus flow is considered to be closed. + //parameter specified by the query + int closing_now; //count for groups that are closing at the final cleraning phase + //or were closed during the most recent counting phase (newly closed) + + //for debugging + int how_many_cleaned; +}; + + +// the function is called once at the initial initialization of the state +void _sfun_state_clean_init_smart_sampling_state(void *s){ + struct SSstate *state = (struct SSstate *)s; + + state->count = 0; + state->gcount = 0; + state->fcount = 0; + state->z = 200; //need to figure out good initial value for z + // cout << "clean init Z: " << state->z << "\n"; + state->z_prev = 0; + // cout << "clean init Z prev: " << state->z << "\n"; + state->gamma = 2; + state->do_clean = 0; + state->bcount = 0; + state->s_size = 0; + state->final_z = 0; + state->time = 0; + state->count_closed = 0; + state->count_closed_flows = 0; + state->count_notsampled_new = 0; + + state->packet_count = 0; + state->do_clean_count = 0; + state->do_sooth = true; + + state->how_many_cleaned = 0; + state->delay = 0; + state->closing_now = 0; +}; + + +// the function will be called at the beginning of every time window +void _sfun_state_dirty_init_smart_sampling_state(void *s_new, void *s_old, int curr_num_samples){ + struct SSstate *state_new = (struct SSstate *)s_new; + struct SSstate *state_old = (struct SSstate *)s_old; + + // cout << "**flows were sampled: " << state_old->how_many_cleaned << "\n"; + // cout << "***dirty current num of samples: " << curr_num_samples << "\n"; + // cout << "dirty init Z old: " << state_old->z << "\n"; + if(curr_num_samples < state_old->s_size){ + // state_new->z = state_old->z*((max((double)curr_num_samples-(double)state_old->bcount,1))/((double)state_old->s_size-(double)state_old->bcount)); + + //temp fix for early aggregation + state_new->z = (state_old->z)/2; + + if(state_old->do_sooth) + state_new->z = state_old->z / _BURST_SOOTHING_FACTOR; + } + else { + if(curr_num_samples >= state_old->s_size){ + //cout << "yes\n"; + state_new->z = state_old->z*((double)curr_num_samples/(double)state_old->s_size); + + if(state_old->do_sooth) + state_new->z = state_old->z / _BURST_SOOTHING_FACTOR; + } + } + + if(state_new->z <= 1.0) + state_new->z = 1; + // cout << "dirty init Z new: " << state_new->z << "\n"; + + state_new->gamma = state_old->gamma; + state_new->do_clean = state_old->do_clean; + state_new->s_size = state_old->s_size; + state_new->bcount = 0; + state_new->gcount = 0; + state_new->count = 0; + state_new->fcount = 0; + state_new->final_z = 0; + state_new->time = 0; + state_new->count_closed = 0; + state_new->count_closed_flows = 0; + state_new->count_notsampled_new = state_old->count_notsampled_new; + + state_new->packet_count = 0; + state_new->do_clean_count = 0; + state_new->do_sooth = true; + + state_new->how_many_cleaned = 0; + state_new->delay = 0; + state_new->closing_now = 0; + + // cout << "dirty init gamma: " << state_new->gamma << "\n"; + // cout << "dirty init do_clean: " << state_new->do_clean << "\n"; + // cout << "dirty init s_size: " << state_new->s_size << "\n"; + // cout << "dirty init bcount: " << state_new->bcount << "\n"; + // cout << "dirty init gcount: " << state_new->gcount << "\n"; + // cout << "dirty init count: " << state_new->count << "\n"; + // cout << "dirty init fcount: " << state_new->fcount << "\n"; + // cout << "dirty init final_z: " << state_new->final_z << "\n"; + // cout << "dirty init time " << state_new->time << "\n"; + // cout << "dirty init count_closed: " << state_new->count_closed << "\n"; + // cout << "dirty init count_closed_flows: " << state_new->count_closed_flows << "\n"; + + // cout << "dirty init packet count: " << state_new->packet_count << "\n"; + // cout << "dirty init do_clean_count: " << state_new->do_clean_count << "\n"; + +}; + +// function is called in two cases: +// adjustment of threshold before the cleaning phase is being triggered +// adjustment of threshold at the window border for the old state, this new +// threshold will be used by partial_flush() and flush() functions (final_clean()) + +void _sfun_state_final_init_smart_sampling_state(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + + // cout << "final init Z old: " << state->z << "\n"; + + if(state->final_z == 0){ + + // just returned from the counting phase + // case when the time window is changed right after the counting phase + if(state->count_closed == 1){ + state->count_closed = 0; + state->count_closed_flows = 0; + state->how_many_cleaned = 0; + } + + state->z_prev = state->z; + // cout << "final current num of samples: " << curr_num_samples << "\n"; + // cout << "final count not sampled new: " << state->count_notsampled_new << "\n"; + // adjust count for current number of sampled based on statistics + // gathered in the previous time window + // otherwise we overestimate it + if(state->count_notsampled_new != 0) + curr_num_samples -= state->count_notsampled_new; + + if(curr_num_samples < state->s_size){ + //state->z = state->z*((max((double)curr_num_samples-(double)state->bcount,1))/((double)state->s_size-(double)state->bcount)); + + //temp fix for early aggregation + state->z = state->z/2; + } + else { + if(curr_num_samples >= state->s_size){ + state->z = state->z*((double)curr_num_samples/(double)state->s_size); + } + } + + if(state->z <= 0) + state->z = 1; + // cout << "final init Z new: " << state->z << "\n"; + + state->bcount = 0; + state->final_z = 1; + state->do_clean_count++; + state->count_notsampled_new = 0; + + } + + // cout << "final init gamma: " << state->gamma << "\n"; + // cout << "final init do_clean: " << state->do_clean << "\n"; + // cout << "final init s_size: " << state->s_size << "\n"; + // cout << "final init bcount: " << state->bcount << "\n"; + // cout << "final init gcount: " << state->gcount << "\n"; + // cout << "final init count: " << state->count << "\n"; + // cout << "final init fcount: " << state->fcount << "\n"; + // cout << "final init final_z: " << state->final_z << "\n"; + // cout << "final init time " << state->time << "\n"; + // cout << "final init count_closed: " << state->count_closed << "\n"; + // cout << "final init count_closed_flows: " << state->count_closed_flows << "\n"; + + // cout << "final init packet count: " << state->packet_count << "\n"; + // cout << "final init do_clean_count: " << state->do_clean_count << "\n"; + +}; + +int ssample(void *s,int curr_num_samples, unsigned long long int len, unsigned int sample_size){ + struct SSstate *state = (struct SSstate *)s; + + state->packet_count++; + + state->s_size = sample_size; + int sampled = 0; + + //just returned from the cleaning phase + if(state->do_clean == 1){ + state->gcount = 0; + state->do_clean = 0; + } + + //sampling + if(len > state->z){ + state->bcount++; + sampled=1; + } + else{ + state->count += len; + if(state->count >= state->z){ + sampled=1; + state->count -= state->z; + } + } + return sampled; + +}; + +int flow_ssample(void *s,int curr_num_samples, unsigned int sample_size){ + struct SSstate *state = (struct SSstate *)s; + + state->packet_count++; + + state->s_size = sample_size; + int sampled = 0; + + //just returned from the counting phase + if(state->count_closed == 1) + // cout << "closed flows after counting phase: " << state->count_closed_flows << "\n"; + + //just returned from the cleaning phase + if(state->do_clean == 1){ + // cout << "flows were sampled: " << state->how_many_cleaned << "\n"; + state->how_many_cleaned = 0; + state->gcount = 0; + state->do_clean = 0; + } + + return 1; + +}; + + +int ssfinal_clean(void *s, int curr_num_samples, unsigned long long int glen){ + struct SSstate *state = (struct SSstate *)s; + + state->do_sooth = true; + + // for ssample() where just returned from the clening phase + state->do_clean = 1; + + int sampled = 0; + double new_len = 0; + + if (glen < state->z_prev) + new_len = state->z_prev; + else + new_len = glen; + + //no need to clean + if(curr_num_samples <= state->s_size){ + return 1; + } + else{ + if(new_len > state->z){ + sampled = 1; + state->bcount++; + } + else{ + state->fcount += new_len; + if(state->fcount >= state->z){ + sampled = 1; + state->fcount -= state->z; + } + //else{ + //state->scount--; + //} + } + + return sampled; + } + +}; + +int flow_ssfinal_clean(void *s, int curr_num_samples, unsigned int ccondition, unsigned int delay, unsigned int maxtime, unsigned long long int glen){ + struct SSstate *state = (struct SSstate *)s; + + state->do_sooth = true; + // only for reporting + state->delay = delay; + + //for ssample() where just returned from the clening phase + state->do_clean = 1; + + int sampled = 0; + double new_len = 0; + // group is newly closed or not closed yet + int new_group = 1; + + // the flow is closed + if((ccondition == 1)||((state->time-maxtime)>=delay)){ + + new_group = 0; + + // TF case or TT case for ccondition and delay + if(ccondition == 1){ + if((state->time-maxtime) <= 1){ // 1 is time interval for count of closed flows + // the flow was closed in the previous counting slot + new_group = 1; + } + } + //FT case for ccondition and delay + else{ + if((state->time-maxtime) <= (delay+1)){ // 1 is time interval for count of closed flows + // the flow was closed in the previous counting slot + new_group = 1; + } + } + // the flow was closed earlier than previous counting slot + // it is closed and old and new_group = 0 + } + + //adjust size only for old closed groups + if(new_group == 0){ + if (glen < state->z_prev) + new_len = state->z_prev; + else + new_len = glen; + } + // newly closed group + else{ + state->closing_now++; + new_len = glen; + } + + + //no need to clean + if(curr_num_samples <= state->s_size){ + state->count_notsampled_new = 0; + return 1; + } + else{ + if(new_len > state->z){ + sampled = 1; + state->bcount++; + } + else{ + state->fcount += new_len; + if(state->fcount >= state->z){ + sampled = 1; + state->fcount -= state->z; + } + //count number of not sampled newly closed groups + //will use in the next time window at the final cleaning phase + else{ + if(new_group == 1) + state->count_notsampled_new++; + } + + } + + state->how_many_cleaned += sampled; + + return sampled; + } + +}; + + +int ssdo_clean(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + + //emergency control + //bcount will be different after the cleaning phase + if(curr_num_samples > (state->gamma*state->s_size)){ + state->z_prev = state->z; + state->z=(double)state->gamma*state->z; + state->do_clean = 1; + state->bcount = 0; + state->count = 0; + state->gcount = 0; + + state->do_clean_count++; + } + + return state->do_clean; +}; + +int flow_ssdo_clean(void *s, int curr_num_samples, unsigned int maxtime){ + struct SSstate *state = (struct SSstate *)s; + + // initialize timestamp with first seen packet from the current timewindow + if(state->time == 0) + state->time = maxtime; + + // detect next counting time slot + if(state->time != maxtime){ + // cout << "need to count\n"; + state->time = maxtime; + state->count_closed = 1; + return 1; + } + + //emergency control + //bcount will be different after the cleaning phase + //if(curr_num_samples > (state->gamma*state->s_size)){ + if(state->count_closed_flows > (state->gamma*state->s_size)){ + // cout << "need to clean, num closed flows: " << state->count_closed_flows << "\n"; + state->z_prev = state->z; + // cout << "do clean Z old: " << state->z << "\n"; + state->z=(((double)state->count_closed_flows)/((double)state->s_size))*state->z; + // cout << "do clean Z new: " << state->z << "\n"; + state->do_clean = 1; + state->bcount = 0; + state->count = 0; + state->gcount = 0; + + state->do_clean_count++; + } + + //just returned from the counting iteration + if(state->count_closed == 1){ + state->count_closed = 0; + // cout << "number of closed flows: " << state->count_closed_flows << "\n"; + state->count_closed_flows = 0; + //initialize gcount since was used for sampling of new closed flows during counting phase + state->gcount = 0; + } + + return state->do_clean; +}; + +double ssthreshold(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + + return state->z; +}; + +int count_distinct(void *s, int curr_num_samples){ + return curr_num_samples; +}; + +int ssclean_with(void *s,int curr_num_samples, unsigned long long int glen){ + struct SSstate *state = (struct SSstate *)s; + + //cleaning condition + int sampled = 0; + double new_len = 0; + + if (glen < state->z_prev) + new_len = state->z_prev; + else + new_len = glen; + + if(new_len > state->z){ + state->bcount++; + sampled = 1; + } + else{ + state->gcount += new_len; + if(state->gcount >= state->z){ + sampled = 1; + state->gcount -= state->z; + } + //else{ + //state->scount--; + //} + } + + return sampled; +}; + +int flow_ssclean_with(void *s,int curr_num_samples, unsigned int ccondition, unsigned int delay, unsigned int maxtime, unsigned long long int glen){ + struct SSstate *state = (struct SSstate *)s; + + //cleaning condition + int sampled = 0; + double new_len = 0; + int new_group = 0; + + //need to count closed flows + if(state->count_closed == 1){ + //the flow is closed + if((ccondition == 1)||((state->time-maxtime)>=delay)){ + state->count_closed_flows++; + // TF case or TT case for ccondition and delay + if(ccondition == 1){ + if((state->time-maxtime) <= 1) //1 is time interval for count of closed flows + new_group = 1; + } + //FT case for ccondition and delay + else{ + if((state->time-maxtime) <= (delay+1)) //1 is time interval for count of closed flows + new_group = 1; + } + } + + // if flow is closed but old, no need to subsample it + if (new_group == 0) + return true; + + } + + // clean only closed flows FF case + // the flow is still open + if((ccondition == 0)&&((state->time-maxtime)<delay)){ + return true; + } + + // use glen for a new group and z_prev for old one + if(new_group == 0){ + if (glen < state->z_prev) + new_len = state->z_prev; + else + new_len = glen; + } + //the group is new + else{ + new_len = glen; + } + + // at this point either flow is closed and old and we are at the cleaning phase + // or flow is closed and new and we are at the counting phase + if(new_len > state->z){ + state->bcount++; + sampled = 1; + } + else{ + state->gcount += new_len; + if(state->gcount >= state->z){ + sampled = 1; + state->gcount -= state->z; + } + //new_group is not sampled during counting phase + else{ + if(state->count_closed == 1) + state->count_closed_flows--; + } + + } + + if(state->do_clean == 1) + state->how_many_cleaned += sampled; + + return sampled; +}; + +int packet_count(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + return state->packet_count; +}; + +double gamma(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + return state->gamma; +}; + +int do_clean_count(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + return state->do_clean_count; +}; + +int delay(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + return state->delay; +}; + +// number of groups which are newly closed (in the most recent +// counting phase or not closed at all during the final +// cleaning phase +int newly_closed(void *s, int curr_num_samples){ + struct SSstate *state = (struct SSstate *)s; + return state->closing_now; +}; + + + + diff --git a/src/lib/gscphftaaux/hfta_runtime_library.cc b/src/lib/gscphftaaux/hfta_runtime_library.cc new file mode 100644 index 0000000..ab94a01 --- /dev/null +++ b/src/lib/gscphftaaux/hfta_runtime_library.cc @@ -0,0 +1,520 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include <sys/types.h> +#include <iostream> +extern "C" { +#include "gsconfig.h" +#include "gstypes.h" +#include <regex.h> +#include <rdtsc.h> +#include <stringhash.h> +#include <errno.h> +#include <unistd.h> +} +#include <stdio.h> +#include <string.h> + +#include <vstring.h> +#include <host_tuple.h> +#include <fta.h> + +// for htonl,ntohl +#include <netinet/in.h> + +#define MAX_PATTERN_LEN 1024 + +// Defined here to avoid link errors as this array is auto generated for the lfta and referenced in the clearinghouse library which gets linked against the hfta +extern "C" gs_sp_t fta_names[]={0}; + + +// Only used to construct constant strings ... +gs_retval_t Vstring_Constructor(vstring *tmp, gs_csp_t str) { + tmp->length = strlen(str); + if(tmp->length) + tmp->offset = (gs_p_t)strdup(str); + tmp->reserved = SHALLOW_COPY; + return 0; +} + +// Assume str is INTERNAL or SHALLOW_COPY. +void hfta_vstr_destroy(vstring * str) { + if (str->length && str->reserved == INTERNAL) { + free((gs_sp_t)str->offset); + } + str->length = 0; +} + + +gs_retval_t hfta_vstr_length(vstring *str) { + return str->length; +} + +// Assume that SRC is either INTERNAL or SHALLOW_COPY +void hfta_vstr_assign_with_copy_in_tuple(vstring32 * target, vstring * src, + gs_sp_t data_offset, gs_retval_t int_offset) { + target->length = src->length; + target->offset = int_offset; + target->reserved = PACKED; + if ( src->length) + memcpy(data_offset, (gs_sp_t)src->offset, src->length); +} + +// Ted wrote the following function. +// make deep copy of src. Assume that dst is already empty. +// Assume that SRC is either INTERNAL or SHALLOW_COPY +void hfta_vstr_assign_with_copy(vstring *dst, vstring *src){ + dst->length=src->length; + if(src->length){ + dst->offset=(gs_p_t)malloc(dst->length); + memcpy((gs_sp_t)(dst->offset),(gs_sp_t)(src->offset),dst->length); + } + dst->reserved=INTERNAL; +} + +// Ted wrote the following function. +// Make a deep copy of src. garbage collect dst if needed. +// Assume that SRC is either INTERNAL or SHALLOW_COPY +void hfta_vstr_replace(vstring *dst, vstring *src){ + hfta_vstr_destroy(dst); + hfta_vstr_assign_with_copy(dst,src); +} + +#define HFTA_VSTR_HASHFUNC_PRIME 2995999 +gs_uint32_t hfta_vstr_hashfunc(const vstring *s) { + gs_uint32_t hash_code; + gs_int32_t n_steps; + gs_int32_t substr_len; + gs_int32_t j; + gs_uint32_t k, sub_hash; + gs_sp_t sv; + + + sv=(gs_sp_t)(s->offset); + hash_code = 0; + n_steps = s->length / 4; + if(4*n_steps < s->length) n_steps++; + + for (j = 0; j < n_steps; j++) { + if(4*(j+1) < s->length) substr_len = 4; + else substr_len = s->length - 4*j; + + sub_hash = 0; + for(k=0;k<4;k++){ + if(k < substr_len) + sub_hash = (sub_hash << 4) + *sv; + else + sub_hash = (sub_hash << 4); + sv++; + } + + hash_code = (sub_hash + hash_code * HFTA_VSTR_HASHFUNC_PRIME); + } + + return(hash_code); +} + +// return negative if s1 < s2, 0 if s1==s2, positive if s1>s2 +gs_retval_t hfta_vstr_compare(const vstring * s1, const vstring * s2) { + gs_int32_t minlen,cmp_ret; + minlen=(s1->length<s2->length?s1->length:s2->length); + cmp_ret=memcmp((void *)s1->offset,(void *)s2->offset,minlen); + + if(cmp_ret) return cmp_ret; + return(s1->length - s2->length); +} + + + +gs_param_handle_t register_handle_for_str_regex_match_slot_1(vstring* pattern) { + regex_t * reg; + gs_int32_t res; + + if ((reg=(regex_t *) malloc(sizeof(regex_t)))==0) { + gslog(LOG_EMERG, "No memory for regular expression %s\n", + (gs_sp_t)(pattern->offset)); + return 0; + } + + if (regcomp(reg,(char*)(pattern->offset), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) { + gslog(LOG_EMERG, "Illegal regular expression %s\n", + (gs_sp_t)(pattern->offset)); + return 0; + } + return (gs_param_handle_t) reg; +} + +gs_uint32_t str_regex_match(vstring* str, gs_param_handle_t pattern_handle) { + regex_t * reg = (regex_t *) pattern_handle ; + gs_int32_t res; + static gs_sp_t d=0; + static gs_uint32_t dlen=0; + // grow our static buffer to the longest string we ever see + if ((str->length+1) >= dlen) { + if (d!=0) free((void*)d); + dlen=0; + d=0; + if ((d=(gs_sp_t)malloc(str->length+1))==0) return 0; + dlen=str->length+1; + } + + if (str->length==0) return 0; + + // copy the string and 0 terminate it + memcpy((void *)d,(void *) str->offset, str->length); + d[str->length]=0; + + res = REG_NOMATCH; + res = regexec(reg, d, 0, NULL, 0); + return (res==REG_NOMATCH)?0:1; +} + +gs_retval_t deregister_handle_for_str_regex_match_slot_1(gs_param_handle_t handle) { + regex_t * x = (regex_t *) handle; + regfree(x); + if (x!=0) free(x); + return 0; +} + +gs_param_handle_t register_handle_for_str_partial_regex_match_slot_1(vstring* pattern) { + regex_t * reg; + gs_int32_t res; + + if ((reg=(regex_t *) malloc(sizeof(regex_t)))==0) { + gslog(LOG_EMERG, "No memory for regular expression %s\n", + (gs_sp_t)(pattern->offset)); + return 0; + } + + if (regcomp(reg,(gs_sp_t)(pattern->offset), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) { + gslog(LOG_EMERG, "Illegal regular expression %s\n", + (gs_sp_t)(pattern->offset)); + return 0; + } + return (gs_param_handle_t) reg; +} + +gs_uint32_t str_partial_regex_match(vstring* str, gs_param_handle_t pattern_handle, + uint maxlen) { + regex_t * reg = (regex_t *) pattern_handle ; + gs_int32_t res; + gs_int32_t end; + static gs_sp_t d=0; + static gs_uint32_t dlen=0; + // grow our static buffer to the longest string we ever see + if ((str->length+1) >= dlen) { + if (d!=0) free((void*)d); + dlen=0; + d=0; + if ((d=(gs_sp_t)malloc(str->length+1))==0) return 0; + dlen=str->length+1; + } + + if (str->length==0) return 0; + + end=(maxlen>(str->length))?(str->length):maxlen; + + // copy the string and 0 terminate it + memcpy((void *)d,(void *) str->offset, end); + d[end]=0; + + res = REG_NOMATCH; + res = regexec(reg, d,0, NULL, 0); + return (res==REG_NOMATCH)?0:1; +} + + +gs_retval_t deregister_handle_for_str_partial_regex_match_slot_1( + gs_param_handle_t handle) { + regex_t * x = (regex_t *) handle; + regfree(x); + if (x!=0) free(x); + return 0; +} + +gs_param_handle_t register_handle_for_str_extract_regex_slot_1(vstring* pattern) { + regex_t * reg; + + if ((reg=(regex_t *) malloc(sizeof(regex_t)))==0) { + gslog(LOG_EMERG, "No memory for regular expression %s\n", + (gs_sp_t)(pattern->offset)); + return 0; + } + if (regcomp(reg,(gs_sp_t)(pattern->offset), REG_EXTENDED)!=0) { + gslog(LOG_EMERG, "Illegal regular expression %s\n", + (gs_sp_t)(pattern->offset)); + return 0; + } + return (gs_param_handle_t) reg; +} + + +/* partial function return 0 if the value is valid */ +gs_retval_t str_extract_regex( vstring * result, vstring * str, gs_param_handle_t handle) { + regex_t * reg = (regex_t *) handle ; + gs_sp_t source = (gs_sp_t)(str->offset); + gs_retval_t res; + regmatch_t match; + static gs_sp_t d=0; + static gs_uint32_t dlen=0; + // grow our static buffer to the longest string we ever see + if ((str->length+1) >= dlen) { + if (d!=0) free((void*)d); + dlen=0; + d=0; + if ((d=(gs_sp_t)malloc(str->length+1))==0) return 1; + dlen=str->length+1; + } + + if (str->length==0) return 1; + + // copy the string and 0 terminate it + memcpy((void *)d,(void *) str->offset, str->length); + d[str->length]=0; + + res = REG_NOMATCH; + res = regexec(reg, d, 1, &match, 0); + if (res==REG_NOMATCH) return 1; + result->offset= (gs_p_t) &source[match.rm_so]; + result->length=match.rm_eo-match.rm_so; + result->reserved = SHALLOW_COPY; + return 0; +} + +gs_retval_t deregister_handle_for_str_extract_regex_slot_1(gs_param_handle_t handle) { + regex_t * x = (regex_t *) handle; + regfree(x); + if (x!=0) free(x); + return 0; +} + + +static gs_uint32_t nextint(struct vstring *str , gs_uint32_t * offset, gs_uint32_t *res) { + gs_uint8_t * s = (gs_uint8_t *)(str->offset); + int v = 0; + *res = 0; + while(*offset<str->length) { + if ((s[*offset]>='0') && (s[*offset]<='9')) { + v=1; + *res= (*res*10) + (gs_uint32_t) (s[*offset]-'0'); + } else { + if (v!=0) { // got some valid result + return 1; + } // otherwise skip leading grabage + } + (*offset)++; + } + return v; +} + +gs_uint32_t strtoi(gs_uint32_t * r, struct vstring * s) +{ + gs_uint32_t offset; + offset=0; + if (nextint(s,&offset,r)==0) return 1; + return 0; +} + +gs_param_handle_t register_handle_for_strtoi_c_slot_0(vstring* istr) { + gs_uint32_t offset,r; + offset=0; + if (nextint(istr,&offset,&r)!=0) + return (gs_param_handle_t) r; + return (gs_param_handle_t) 0; +} +gs_retval_t deregister_handle_for_strtoi_c_slot_0(gs_param_handle_t h) { + return 0; +} + + +gs_uint32_t strtoip(gs_uint32_t * r, struct vstring * s) +{ + gs_uint32_t ip1,ip2,ip3,ip4,offset; + offset=0; + if (nextint(s,&offset,&ip1)==0) return 1; + //fprintf (stderr, "1 %u %u\n",ip1,offset); + if (nextint(s,&offset,&ip2)==0) return 1; + //fprintf (stderr, "2 %u %u\n",ip2,offset); + if (nextint(s,&offset,&ip3)==0) return 1; + //fprintf (stderr, "3 %u %u\n",ip3,offset); + if (nextint(s,&offset,&ip4)==0) return 1; + //fprintf (stderr, "4 %u %u\n",ip4,offset); + *r=ip1<<24|ip2<<16|ip3<<8|ip4; + return 0; +} + +gs_param_handle_t register_handle_for_strtoip_c_slot_0(vstring* istr) { + gs_uint32_t ip1,ip2,ip3,ip4,offset,r; + offset=0; + if (nextint(istr,&offset,&ip1)==0) return (gs_param_handle_t)0; + if (nextint(istr,&offset,&ip2)==0) return (gs_param_handle_t)0; + if (nextint(istr,&offset,&ip3)==0) return (gs_param_handle_t)0; + if (nextint(istr,&offset,&ip4)==0) return (gs_param_handle_t)0; + r=ip1<<24|ip2<<16|ip3<<8|ip4; + return (gs_param_handle_t)r; +} +gs_retval_t deregister_handle_for_strtoip_c_slot_0(gs_param_handle_t h) { + return 0; +} + +gs_uint32_t partn_hash( gs_uint32_t ip1, gs_uint32_t ip2) { + return (ip1^ip2); +} + +gs_uint32_t rand_hash() { + return rand(); +} + +/////////////////////////////////////// +// IPv6 fcns. +// return negative if s1 < s2, 0 if s1==s2, positive if s1>s2 +gs_retval_t hfta_ipv6_compare(const hfta_ipv6_str &i1, const hfta_ipv6_str &i2) { + if(i1.v[0] > i2.v[0]) + return 1; + if(i1.v[0] < i2.v[0]) + return -1; + if(i1.v[1] > i2.v[1]) + return 1; + if(i1.v[1] < i2.v[1]) + return -1; + if(i1.v[2] > i2.v[2]) + return 1; + if(i1.v[2] < i2.v[2]) + return -1; + if(i1.v[3] > i2.v[3]) + return 1; + if(i1.v[3] < i2.v[3]) + return -1; + + return 0; +} + +hfta_ipv6_str And_Ipv6(const hfta_ipv6_str &i1, const hfta_ipv6_str &i2){ + hfta_ipv6_str ret; + ret.v[0] = i1.v[0] & i2.v[0]; + ret.v[1] = i1.v[1] & i2.v[1]; + ret.v[2] = i1.v[2] & i2.v[2]; + ret.v[3] = i1.v[3] & i2.v[3]; + return ret; +} + +hfta_ipv6_str Or_Ipv6(const hfta_ipv6_str &i1, const hfta_ipv6_str &i2){ + hfta_ipv6_str ret; + ret.v[0] = i1.v[0] | i2.v[0]; + ret.v[1] = i1.v[1] | i2.v[1]; + ret.v[2] = i1.v[2] | i2.v[2]; + ret.v[3] = i1.v[3] | i2.v[3]; + return ret; +} + +gs_uint32_t hfta_ipv6_hashfunc(const hfta_ipv6_str *s) { + return s->v[0] ^ s->v[1] ^ s->v[2] ^ s->v[3]; +} + +hfta_ipv6_str hton_ipv6(hfta_ipv6_str s){ + hfta_ipv6_str ret; + +// ret.v[0] = htonl(s.v[0]); +// ret.v[1] = htonl(s.v[1]); +// ret.v[2] = htonl(s.v[2]); +// ret.v[3] = htonl(s.v[3]); + ret.v[0] = s.v[0]; + ret.v[1] = s.v[1]; + ret.v[2] = s.v[2]; + ret.v[3] = s.v[3]; + return ret; +} + +hfta_ipv6_str ntoh_ipv6(hfta_ipv6_str s){ + hfta_ipv6_str ret; +// ret.v[0] = ntohl(s.v[0]); +// ret.v[1] = ntohl(s.v[1]); +// ret.v[2] = ntohl(s.v[2]); +// ret.v[3] = ntohl(s.v[3]); + ret.v[0] = s.v[0]; + ret.v[1] = s.v[1]; + ret.v[2] = s.v[2]; + ret.v[3] = s.v[3]; + return ret; +} + +int HFTA_Ipv6_Constructor(hfta_ipv6_str *s, gs_csp_t l) { + gs_uint32_t i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0; + sscanf(l,"%x:%x:%x:%x:%x:%x:%x:%x",&i0,&i1,&i2,&i3,&i4,&i5,&i6,&i7); + s->v[0] = ((i0 & 0xffff) << 16) | (i1 & 0xffff); + s->v[1] = ((i2 & 0xffff) << 16) | (i3 & 0xffff); + s->v[2] = ((i4 & 0xffff) << 16) | (i5 & 0xffff); + s->v[3] = ((i6 & 0xffff) << 16) | (i7 & 0xffff); + return(0); +} + +gs_retval_t str_exists_substr(vstring * s1,vstring * s2) +{ + gs_uint8_t *st1 = (gs_uint8_t *)s1->offset; + gs_uint8_t *st2 = (gs_uint8_t *)s2->offset; + gs_uint8_t *s2f = (gs_uint8_t *)s2->offset; + gs_uint8_t len1 = s1->length-s2->length; + gs_uint8_t len2 = s2->length; + gs_uint8_t x,y; + + for (x=0; x<len1 ; x++) + { + if (st1[x]== *s2f) + { + for (y=0; y<len2 && st1[x+y]==st2[y];y++); + if (y==len2) + return 1; + } + } + return 0; +} + +gs_retval_t str_compare(vstring *s1,vstring *s2) +{ + return hfta_vstr_compare(s1,s2); +} + +gs_uint32_t str_match_offset( gs_uint32_t offset, vstring *s1, vstring *s2) +{ + gs_uint8_t *st1 = (gs_uint8_t *)s1->offset; + gs_uint8_t *st2 = &(((gs_uint8_t *)s2->offset)[offset]); + gs_int32_t x; + gs_int32_t len2 = s2->length-offset; + gs_int32_t len1 = s1->length; + + if (len2 < len1) + return 0; + + for(x = 0; x < len1; x++) + { + if (st1[x] != st2[x]) + return 0; + } + return 1; +} + +gs_uint32_t byte_match_offset( gs_uint32_t offset, gs_uint32_t val,vstring *s2) +{ + gs_uint8_t *st2 = (gs_uint8_t *)s2->offset; + gs_uint8_t v = (unsigned char) val; + +// if ((s2->length <= offset)||(offset<0)) + if (s2->length <= offset) + return 0; + + return (st2[offset]==v)?1:0; +} + + diff --git a/src/lib/gscphftaaux/hfta_udaf.cc b/src/lib/gscphftaaux/hfta_udaf.cc new file mode 100644 index 0000000..fb0f1d5 --- /dev/null +++ b/src/lib/gscphftaaux/hfta_udaf.cc @@ -0,0 +1,434 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +#include "gsconfig.h" +#include "gstypes.h" +#include "hfta_udaf.h" +#include "rts_udaf.h" +#include <stdio.h> +#include <limits.h> +#include <math.h> +//#include <memory.h> +#include <string.h> +#include <sys/time.h> +#include <iostream> + +#include "hfta_runtime_library.h" + + +#define max(a,b) ((a) > (b) ? (a) : (b)) +#define min(x,y) ((x) < (y) ? (x) : (y)) +#define lg(x) (log(x) / log(2)) + +using namespace std; + + +// ------------------------------------------------------------------- +// moving sum over N intervals + +struct moving_sum_udaf_str{ + gs_uint32_t N; + gs_uint32_t pos; + gs_uint32_t *sums; +}; + +void moving_sum_udaf_HFTA_AGGR_INIT_(gs_sp_t buf){ + struct moving_sum_udaf_str * u = (struct moving_sum_udaf_str *) buf; + u->N=0; u->pos=0; u->sums=NULL; +} + +void moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s, gs_uint32_t N) { + struct moving_sum_udaf_str * u = (struct moving_sum_udaf_str *) buf; + if(u->sums == NULL){ + u->sums = (gs_uint32_t *)malloc(N*sizeof(gs_uint32_t)); + for(gs_int32_t i=0;i<N;i++) + u->sums[i] = 0; + u->N = N; + } + u->sums[u->pos] += s; +} + +void super_moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint64_t sub_sum) { + struct moving_sum_udaf_str * u = (struct moving_sum_udaf_str *) buf; + gs_uint32_t s = (gs_uint32_t)(sub_sum & 0xffffffff); + if(u->sums == NULL){ + gs_uint32_t N = (gs_uint32_t)((sub_sum & 0xffffffff00000000ull) >> 32); + u->sums = (gs_uint32_t *)malloc(N*sizeof(gs_uint32_t)); + for(gs_int32_t i=0;i<N;i++) + u->sums[i] = 0; + u->N = N; + } + u->sums[u->pos] += s; +} + +void moving_sum_udaf_HFTA_AGGR_OUTPUT_(gs_p_t *result, gs_sp_t buf){ + *result = (gs_p_t)(buf); +} + +void moving_sum_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf){ + struct moving_sum_udaf_str * u = (struct moving_sum_udaf_str *) buf; + if(u->sums != NULL) + free(u->sums); +} + +void moving_sum_udaf_HFTA_AGGR_REINIT_( gs_sp_t buf){ + struct moving_sum_udaf_str * u = (struct moving_sum_udaf_str *) buf; + u->pos++; + if(u->pos >= u->N) + u->pos = 0; + u->sums[u->pos] = 0; +} + +gs_uint32_t moving_sum_extract(gs_p_t result){ + struct moving_sum_udaf_str * u = (struct moving_sum_udaf_str *) result; + gs_uint32_t s=0, i=0; + for(i=0; i<u->N;i++){ + s += u->sums[i]; + } + return s; +} + +gs_float_t moving_sum_extract_exp(gs_p_t result, gs_float_t alpha){ + struct moving_sum_udaf_str * u = (struct moving_sum_udaf_str *) result; + gs_uint32_t p=0, i=0; + gs_float_t s=0.0, m=1.0; + p=u->pos; + for(i=0; i<u->N;i++){ + s += u->sums[i]*m; + if(p==0) + p=u->N - 1; + else + p--; + m *= alpha; + } + return s; +} + + +// ------------------------------------------------------------------- +// sum over 3 intervals : test rUDAF + +struct sum3_udaf_str{ + gs_uint32_t s_2; + gs_uint32_t s_1; + gs_uint32_t s_0; +}; + +void sum3_HFTA_AGGR_INIT_(gs_sp_t buf) { + struct sum3_udaf_str * u = (struct sum3_udaf_str *) buf; + u->s_0 = 0; u->s_1 = 0; u->s_2 = 0; + return; +} + +void sum3_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s) { + struct sum3_udaf_str * u = (struct sum3_udaf_str *) buf; + u->s_0 += s; + return; +} + +void sum3_HFTA_AGGR_OUTPUT_(gs_uint32_t *result, gs_sp_t buf) { + struct sum3_udaf_str * u = (struct sum3_udaf_str *) buf; + *result = u->s_0 + u->s_1 + u->s_2; + return; +} + +void sum3_HFTA_AGGR_DESTROY_(gs_sp_t buf) { + return; +} + +void sum3_HFTA_AGGR_REINIT_( gs_sp_t buf) { + struct sum3_udaf_str * u = (struct sum3_udaf_str *) buf; + u->s_2 = u->s_1; + u->s_1 = u->s_0; + u->s_0 = 0; + return; +} + + +#define HISTORY_LENGTH 1024 + +///////////////////////////////////////////////////////////////////////// +///// Calculate the average of all positive gs_float_t numbers + +struct posavg_struct{ + gs_float_t sum; + gs_float_t cnt; +}; + +void POSAVG_HFTA_AGGR_INIT_(gs_sp_t buf) { + struct posavg_struct * a = (struct posavg_struct *) buf; + a->sum=0; + a->cnt=0; + return; +} + +void POSAVG_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_float_t v) { + struct posavg_struct * a = (struct posavg_struct *) buf; + if (v>=0) { + a->sum=a->sum+v; + a->cnt=a->cnt+1; + } + return; +} + +void POSAVG_HFTA_AGGR_OUTPUT_(gs_float_t * v, gs_sp_t buf) { + struct posavg_struct * a = (struct posavg_struct *) buf; + if (a->cnt>0) { + *v=(a->sum/a->cnt); + } else { + *v=-1; + } + return; +} + +void POSAVG_HFTA_AGGR_DESTROY_(gs_sp_t buf) { + return; +} + +///////////////////////////////////////////////////////////////////////// +///// avg_udaf (simple example) + +// struct received from subaggregate +struct avg_udaf_lfta_struct_t{ + gs_int64_t sum; + gs_uint32_t cnt; +}; + +// sctarchpad struct +struct avg_udaf_hfta_struct_t{ + gs_int64_t sum; + gs_uint32_t cnt; +}; + +// avg_udaf functions +void avg_udaf_HFTA_AGGR_INIT_(gs_sp_t b){ + avg_udaf_hfta_struct_t *s = (avg_udaf_hfta_struct_t *) b; + s->sum = 0; + s->cnt = 0; +} + +void avg_udaf_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v){ + avg_udaf_hfta_struct_t *s = (avg_udaf_hfta_struct_t *) b; + s->sum += v; + s->cnt ++; +} + +void avg_udaf_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b){ + r->length = 12; + r->offset = (gs_p_t)(b); + r->reserved = SHALLOW_COPY; +} + +void avg_udaf_HFTA_AGGR_DESTROY_(gs_sp_t b){ + return; +} + + +// avg_udaf superaggregate functions +void avg_udaf_hfta_HFTA_AGGR_INIT_(gs_sp_t b){ + avg_udaf_hfta_struct_t *s = (avg_udaf_hfta_struct_t *) b; + s->sum = 0; + s->cnt = 0; +} + +void avg_udaf_hfta_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v){ + if(v->length != 12) return; + avg_udaf_hfta_struct_t *s = (avg_udaf_hfta_struct_t *) b; + avg_udaf_lfta_struct_t *vs = (avg_udaf_lfta_struct_t *)(v->offset); + s->sum += vs->sum; + s->cnt += vs->cnt; +} + +void avg_udaf_hfta_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b){ + r->length = 12; + r->offset = (gs_p_t)(b); + r->reserved = SHALLOW_COPY; +} + +void avg_udaf_hfta_HFTA_AGGR_DESTROY_(gs_sp_t b){ + return; +} + +// Extraction function +gs_float_t extr_avg_fcn(vstring *v){ + if(v->length != 12) return 0; + avg_udaf_hfta_struct_t *vs = (avg_udaf_hfta_struct_t *)(v->offset); + gs_float_t r = (gs_float_t)(vs->sum) / vs->cnt; + return r; +} + +///////////////////////////////////////////////////////// +// FIRST aggregate + +void FIRST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch) { + *scratch = UINT_MAX; // we will encode uninitialized value of UINT_MAX +} + +void FIRST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch) { } + +void FIRST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) { + if (*scratch == UINT_MAX) + *scratch = val; +} + +void FIRST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) { + *res = *scratch; +} + +void FIRST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { } + +void FIRST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch) { + *scratch = UINT_MAX; // we will encode uninitialized value of UINT_MAX +} + +void FIRST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch) { } + +void FIRST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) { + if (*scratch == UINT_MAX) + *scratch = val; +} + +void FIRST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) { + *res = *scratch; +} + +void FIRST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { } + + +void FIRST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch) { + scratch->offset= 0; +} + +void FIRST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch) { } + +void FIRST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val) { + if (!scratch->offset) { + scratch->length = val->length; + scratch->offset = val->offset; + scratch->reserved = SHALLOW_COPY; + } +} + +void FIRST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch) { + *res = *scratch; +} + +void FIRST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch) { } + +///////////////////////////////////////////////////////// +// LAST aggregate + +void LAST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch) { } + +void LAST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch) { } + +void LAST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) { + *scratch = val; +} + +void LAST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) { + *res = *scratch; +} + +void LAST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { } + +void LAST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch) { } + +void LAST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch) { } + +void LAST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) { + *scratch = val; +} + +void LAST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) { + *res = *scratch; +} + +void LAST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { } + + +void LAST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch) { + scratch->offset= 0; +} + +void LAST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch) { } + +void LAST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val) { + scratch->length = val->length; + scratch->offset = val->offset; + scratch->reserved = SHALLOW_COPY; +} + +void LAST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch) { + *res = *scratch; +} + +void LAST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch) { } + + +///////////////////////////////////////////////////////// +// running_array_aggr aggregate + +void running_array_aggr_hfta_HFTA_AGGR_INIT_(vstring* scratch) { + scratch->offset = NULL; + scratch->length = 0; +} + +void running_array_aggr_hfta_HFTA_AGGR_REINIT_(vstring* scratch) { } + +void running_array_aggr_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val) { + char buffer[100]; + + gs_uint32_t* ints = (gs_uint32_t*)val->offset; + switch (val->length / sizeof (gs_uint32_t)) { + case 4: + sprintf(buffer, "%u,%u,%u,%u", ints[0], ints[1], ints[2], ints[3]); + break; + case 3: + sprintf(buffer, "%u,%u,%u", ints[0], ints[1], ints[2]); + break; + case 2: + sprintf(buffer, "%u,%u", ints[0], ints[1]); + break; + case 1: + sprintf(buffer, "%u", ints[0]); + break; + case 0: + return; + } + int buf_len = strlen(buffer); + + // append the content of buffer to scratch + if (!scratch->offset) { + Vstring_Constructor(scratch, buffer); + } else { + scratch->offset = (gs_p_t)realloc((void*)scratch->offset, scratch->length + buf_len + 1); + *((char*)scratch->offset + scratch->length) = ','; + memcpy((void*)(scratch->offset + scratch->length + 1), (void*)buffer, buf_len); + scratch->length += buf_len + 1; + scratch->reserved = INTERNAL; + } +} + +void running_array_aggr_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch) { + *res = *scratch; + res->reserved = SHALLOW_COPY; +} + +void running_array_aggr_hfta_HFTA_AGGR_DESTROY_(vstring* scratch) { + hfta_vstr_destroy(scratch); + } + diff --git a/src/lib/gscphost/Makefile b/src/lib/gscphost/Makefile new file mode 100644 index 0000000..436a386 --- /dev/null +++ b/src/lib/gscphost/Makefile @@ -0,0 +1,52 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CC=gcc -O3 -fexpensive-optimizations -g -I ./include/ -I ../../../include/ -DCLEARINGHOUSE_HEARTBEAT + +SOURCE = callbackinterface.c callbackregistries.c lappinterface.c lappregistries.c lfta.c gscpipc.c + +OBJECTS = $(SOURCE:.c=.o) + +all: install + +INCDIR=../../../include + +libgscphost.a: $(OBJECTS) Makefile + ar rc libgscphost.a $(OBJECTS) + +libclearinghouse.a: clearinghouseregistries.o + ar rc libclearinghouse.a clearinghouseregistries.o + +clearinghouseregistries.o: clearinghouseregistries.c + +callbackinterface.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(INCDIR/rdtsc.h) + +callbackregistries.c : include/callbackregistries.h $(INCDIR/lapp.h) include/gscpipc.h $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +lappinterface.c : include/gscpipc.h $(INCDIR/rdtsc.h) $(INCDIR/lapp.h) + +lappregistries.c : include/lappregistries.h + +lfta.c :$(INCDIR/gsconfig.h) $(INCDIR/fta.h) $(INCDIR/rdtsc.h) $(INCDIR/packet.h) + +gscpipc.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +clearinghouseregistries.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) include/gscpipc.h + +install: libgscphost.a libclearinghouse.a + cp libgscphost.a libclearinghouse.a ../../../lib/ ; ranlib ../../../lib/libclearinghouse.a ; ranlib ../../../lib/libgscphost.a + +clean: + rm -f *.o *.a core diff --git a/src/lib/gscphost/callbackinterface.c b/src/lib/gscphost/callbackinterface.c new file mode 100644 index 0000000..9d21d73 --- /dev/null +++ b/src/lib/gscphost/callbackinterface.c @@ -0,0 +1,932 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include "gsconfig.h" +#include "gstypes.h" +#include <gscpipc.h> +#include <ipcencoding.h> +#include <callbackregistries.h> +#include <clearinghouseregistries.h> +#include <lappregistries.h> +#include <stdlib.h> +#include <stdio.h> +#include <lapp.h> +#include <string.h> +#include "rdtsc.h" + +gs_uint64_t shared_memory_full_warning =0; + +static gs_int32_t maxsnaplen = 0; + +struct FTAID clearinghouseftaid; + +gs_uint64_t intupledrop=0; +gs_uint64_t outtupledrop=0; +gs_uint64_t intuple=0; +gs_uint64_t outtuple=0; +gs_uint64_t inbytes=0; +gs_uint64_t outbytes=0; +gs_uint64_t cycles=0; + + + +/* following function is internal and defined in lappinterface.c */ +gs_retval_t ipc_call_and_wait(FTAID f, gs_sp_t msg, gs_sp_t result); + +gs_retval_t gscp_blocking_mode() { +#ifdef BLOCKRINGBUFFER + return 1; +#else + return 0; +#endif +} + +static void clock_signal_check() { + struct FTA * fa; + static gs_int32_t t=0; + if (t==0) { + t=time(0); + } else { + if (time(0)>t) { + if (ftaexec_start()<0) { + gslog(LOG_EMERG,"GSCPRTS::error::could not init check of " + "FTA list\n"); + return; + } + while ((fa=ftaexec_next())!=0) { + if (fa->clock_fta!=0) { + fa->clock_fta(fa); + } + } + t=time(0); + if (t%GSLOGINTERVAL==0) gsstats();// log all the stats + } + } +} + +static gs_retval_t send_standard_reply(FTAID f, gs_int32_t result) { + struct standard_result r; + r.h.callid=STANDARD_RESULT; + r.h.size=sizeof(struct standard_result); + r.result=result; + if (gscpipc_send(f, FTACALLBACK, (gs_sp_t) &r,r.h.size,1)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + return -1; + } + return 0 ; +} + +static gs_retval_t send_lookup_reply(FTAID f, gs_int32_t result, + FTAID * ftaid, + gs_sp_t* schema) { + struct ftafind_result r; + r.h.callid=FTAFIND_RESULT; + r.h.size=sizeof(struct ftafind_result); + r.result=result; + r.f=*ftaid; + if (result >=0) { + if (strlen(*schema)>=(MAXSCHEMASZ-1)) { + gslog(LOG_EMERG,"ERROR:FTA schema (%s) to large\n",(unsigned char *)schema); + r.result=-1; + } else { + strcpy(r.schema,*schema); + } + } + if (gscpipc_send(f, FTACALLBACK, (gs_sp_t) &r,r.h.size,1)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + return -1; + } + return 0 ; +} + + +static gs_retval_t send_fta_result(FTAID f, + FTAID * ftaid, gs_int32_t result) { + struct fta_result r; + r.h.callid=FTA_RESULT; + r.h.size=sizeof(struct fta_result); + r.result=result; + if (ftaid!=0) { + r.f=*ftaid; + } + if (gscpipc_send(f, FTACALLBACK,(gs_sp_t)&r,r.h.size,1)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + return -1; + } + return 0 ; +} + + +// Is also used by the lfta rts enviroment on a post. So make it none +// static. +gs_retval_t send_wakeup(FTAID f) +{ + struct wakeup_result a; + + a.h.callid=WAKEUP; + a.h.size=sizeof(struct wakeup_result); + if (gscpipc_send(f, FTACALLBACK, (gs_sp_t)&a,a.h.size,0)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + return -1; + } + return 0; +} + +static gs_retval_t fta_register_instance(FTAID subscriber, + FTAID f,gs_uint32_t reusable, + FTAname name, + gs_csp_t schema) { + gs_int8_t rb[MAXRES]; + struct fta_register_arg a; + struct standard_result * sr = (struct standard_result *)rb; + + if (curprocess.type != CLEARINGHOUSE) { + a.h.callid = FTA_REGISTER; + a.h.size = sizeof(struct fta_register_arg); + if (strlen(name)>=(MAXFTANAME-1)) { + gslog(LOG_EMERG,"ERROR:FTA name (%s) to large\n",name); + return -1; + } + if (strlen(schema)>=(MAXSCHEMASZ-1)) { + gslog(LOG_EMERG,"ERROR:FTA schema (%s) to large\n",schema); + return -1; + } + strcpy(a.name,name); + strcpy(a.schema,schema); + a.f=f; + a.subscriber=subscriber; /* consumer is the same as f for an FTA*/ + a.reusable=reusable; + ipc_call_and_wait(clearinghouseftaid,(gs_sp_t )&a,rb); + if (sr->h.callid != STANDARD_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + if (sr->result != 0) { + return -1; + } + } else { + if (ftalookup_register_fta(subscriber,f,name,reusable,schema)<0) { + return -1; + } + } + return 0; +} + +static gs_retval_t fta_unregister_instance(FTAID subscriber, + FTAID f) { + gs_int8_t rb[MAXRES]; + struct fta_unregister_arg a; + struct standard_result * sr = (struct standard_result *)rb; + + if (curprocess.type != CLEARINGHOUSE) { + a.h.callid = FTA_UNREGISTER; + a.h.size = sizeof(struct fta_register_arg); + a.f=f; + a.subscriber=subscriber; /* consumer is the same as f for an FTA*/ + ipc_call_and_wait(clearinghouseftaid,(gs_sp_t )&a,rb); + if (sr->h.callid != STANDARD_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + return -1; + } else { + if (ftalookup_unregister_fta(f,subscriber)<0) { + return -1; + } + } + return 0; +} + +gs_retval_t fta_start_service(gs_int32_t number) +{ + gs_int8_t buf[MAXMSGSZ]; + FTAID from; + gs_int32_t length; + struct hostcall * h= (struct hostcall *) buf; + gs_int32_t forever=0; + gs_int32_t endtime=0; + gs_int32_t block=1; + gs_int32_t res; + struct ringbuf * r; + FTAID ftaid; + FTAID * ftaidp; + struct FTA * fta; + gs_int32_t lopp; + gs_int32_t preemptq; + gs_int32_t endq; + gs_uint64_t s1; + gs_uint64_t s2; + + if (number == 0) { + block=0; + forever=1; + } + if (number < 0) { + forever=1; + } + if (number > 0) { + block=1; + endtime=time(0)+number; + } + + while((forever!=0)|| + (endtime==0)||(endtime>time(0))) { + /* check if we need to give the FTAs there clock signal */ + if ((curprocess.type == LFTA) + ||(curprocess.type == HFTA)) { + clock_signal_check(); + } + +#ifdef POLLING + poll: +#endif + preemptq=0; + /* first empty out sidequeu then read from messagequeue */ + if (sidequeue_pop(&from,buf,&length)<0) { + /* empty out the sidequeue before processing the shared + memory */ + if (curprocess.type == HFTA) { + /* process all the shared memory regions and register + for callbacks */ + s1=rdtsc(); + endq=time(0)+2; + streamregistry_getactiveringbuf_reset(); + while ((r=streamregistry_getactiveringbuf())>0) { + while (UNREAD(r)) { + struct FTA * fa; + if (ftaexec_start()<0) { + gslog(LOG_EMERG,"GSCPRTS::error::could not init check of " + "FTA list\n"); + return -1; + } + while ((fa=ftaexec_next())!=0) { + gs_int32_t x; + for(x=0;x<fa->stream_subscribed_cnt;x++) { + if ((fa->stream_subscribed[x].streamid + ==CURREAD(r)->f.streamid) + && (fa->stream_subscribed[x].ip + ==CURREAD(r)->f.ip) + && (fa->stream_subscribed[x].port + ==CURREAD(r)->f.port)) { + fa->accept_packet(fa,&(CURREAD(r)->f), + &(CURREAD(r)->data[0]), + CURREAD(r)->sz); + } + } + } + intuple++; + inbytes+=CURREAD(r)->sz; + ADVANCEREAD(r); + if (endq <= time(0)) { + preemptq=1; + goto processmsg; + } + } + } + s2=rdtsc(); + cycles+=(s2-s1); +#ifndef POLLING + /* register wakeups all arround to make sure we don't sleep + * for ever, + */ + streamregistry_getactiveftaid_reset(); + while ((ftaidp=streamregistry_getactiveftaid())>0) { + struct gscp_get_buffer_arg a; + a.h.callid = GSCP_GET_BUFFER; + a.h.size = sizeof(struct gscp_get_buffer_arg); + a.timeout = 0; + if (gscpipc_send(*ftaidp,FTACALLBACK,(gs_sp_t )&a,a.h.size,1)<0) { + return -1; + } + } +#endif + } + processmsg: + do { + /* even if we block we return every 100msec to be able to generate the clock signal to + * the HFTAs + */ + if ((res=gscpipc_read(&from,&lopp,buf,&length,((block==1)&&(preemptq==0))?2:0))<0) { + gslog(LOG_EMERG,"GSCPRTS::error::reading from messagequeue\n"); + return -1; + } + /* check if we need to give the FTAs there clock signal */ + if ((curprocess.type == LFTA) + ||(curprocess.type == HFTA)) { + clock_signal_check(); + } + if ((res==0) && (block==0)) { + /* nonblocking and nothing to do so return */ + return 0; + } + if ((res==0) && (endtime!=0) && (endtime<time(0))) { + /* timeout reached so return */ + return 0; + } +#ifdef POLLING + if ((res==0)&&(curprocess.type == HFTA)) { + goto poll; + } +#endif + } while (res==0); + if ((lopp)!=FTACALLBACK) { + gslog(LOG_EMERG,"GSCPRTS::error::unknown lowlevel opp\n"); + return -1; + } + } + +#ifdef PRINTMSG + gslog(LOG_EMERG, "HFTA message from %u of type %u of length %u\n",from, + h->callid,h->size); +#endif + switch (h->callid) { + + case FTA_LOOKUP: { + if (curprocess.type == CLEARINGHOUSE) { + struct fta_find_arg * n; + FTAID rf; + gs_csp_t schema; + n = (struct fta_find_arg *) buf; + /* Note: Side effect of ftalookup_lookup_fta_index is to + fill msgid and index */ + if (send_lookup_reply(from, + ftalookup_lookup_fta_index(from, + n->name, + n->reuse, + &rf, + &schema), + &rf, + (gs_sp_t *)&schema)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } else { + if (send_standard_reply(from,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + gslog(LOG_EMERG,"GSCPRTS::error: Non clearinghouse proccess got" + "contacted for clearinghouse processing\n"); + } + } + break; + case FTA_REGISTER: { + if (curprocess.type == CLEARINGHOUSE) { + struct fta_register_arg * n; + n = (struct fta_register_arg *) buf; + if (send_standard_reply(from, + ftalookup_register_fta(n->subscriber, + n->f, + n->name, + n->reusable, + n->schema))<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } else { + if (send_standard_reply(from,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + gslog(LOG_EMERG,"GSCPRTS::error: Non clearinghouse proccess got" + "contacted for clearinghouse processing\n"); + } + } + break; + case FTA_UNREGISTER: { + if (curprocess.type == CLEARINGHOUSE) { + struct fta_unregister_arg * n; + n = (struct fta_unregister_arg *) buf; + if (send_standard_reply(from, + ftalookup_unregister_fta(n->subscriber, + n->f))<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } else { + if (send_standard_reply(from,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + gslog(LOG_EMERG,"GSCPRTS::error: Non clearinghouse proccess got" + "contacted for clearinghouse processing\n"); + } + } + break; + case FTA_ALLOC_INSTANCE: + case FTA_ALLOC_PRINT_INSTANCE: + if ((curprocess.type == LFTA) + ||(curprocess.type == HFTA)) { + struct ringbuf * r; + struct fta_alloc_instance_arg * n; + n = (struct fta_alloc_instance_arg *) buf; + if ((fta=ftaexec_alloc_instance(n->f.index, + (struct FTA *)n->f.streamid, + n->reusable, + n->command, + n->sz, + &(n->data[0])))==0) { + gslog(LOG_EMERG,"GSCPRTS::warning::could not allocate" + "FTA\n"); + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } else { + /* shared memory is only required if data is beeing transfered */ + if ((h->callid!=FTA_ALLOC_PRINT_INSTANCE)&& + ((r=gscpipc_getshm(from))==0)) { + gslog(LOG_EMERG,"GSCPRTS::warning::could not get" + "shared memory\n"); + ftaexec_remove(fta); + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } else { + /* no callback to register for print function */ + if ((h->callid!=FTA_ALLOC_PRINT_INSTANCE)&&(ftacallback_add_streamid(r,fta->ftaid.streamid)!=0)) { + gslog(LOG_EMERG,"GSCPRTS::warning::could not add" + "streamid to ringbuffer\n"); + ftaexec_free_instance(fta,1); + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } else { + if (ftaexec_insert(0,fta)<0) { + gslog(LOG_EMERG,"GSCPRTS::warning::could not" + "insert FTA\n"); + ftacallback_rm_streamid(r,fta->ftaid.streamid); + ftaexec_free_instance(fta,1); + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } else { + if (fta_register_instance(n->subscriber,fta->ftaid, + n->reusable, + n->name, + n->schema)!=0) { + gslog(LOG_EMERG,"GSCPRTS::warning::could not register" + " instance\n"); + ftaexec_remove(fta); + ftacallback_rm_streamid(r,fta->ftaid.streamid); + ftaexec_free_instance(fta,1); + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } else { + if (h->callid==FTA_ALLOC_PRINT_INSTANCE) { + if (curprocess.type == LFTA) { + gslog(LOG_EMERG,"GSCPRTS::error:: alloc print instance not " + "implemented for LFTA.\n"); + ftaexec_remove(fta); + ftaexec_free_instance(fta,1); + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } else { + if (add_printfunction_to_stream(fta, n->schema, n->path, n->basename, + n->temporal_field, n->split_field, n->delta, n->split) < 0) { + ftaexec_remove(fta); + ftaexec_free_instance(fta,1); + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } + } + } + if (send_fta_result(from,&fta->ftaid,0)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } + } + } + } + } + } else { + if (send_fta_result(from,0,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard " + "reply faild\n"); + return -1; + } + } + break; + case FTA_FREE_INSTANCE:{ + if ((curprocess.type == LFTA) + ||(curprocess.type == HFTA)) { + struct fta_free_instance_arg * n; + n = (struct fta_free_instance_arg *) buf; + if (((r=gscpipc_getshm(from))!=0) + && ( ftaexec_remove((struct FTA *) n->f.streamid)==0) + && ( ftacallback_rm_streamid(r,n->f.streamid)==0) + && (ftaexec_free_instance((struct FTA *)n->f.streamid, + n->recursive) + ==0) + && (fta_unregister_instance(n->subscriber,n->f)<0)) { + if (send_standard_reply(from,0)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } else { + if (send_standard_reply(from,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } + } else { + if (send_standard_reply(from,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } + } + break; + case FTA_CONTROL:{ + if ((curprocess.type == LFTA) + ||(curprocess.type == HFTA)) { + struct fta_control_arg * n; + n = (struct fta_control_arg *) buf; + if (send_standard_reply(from, + ftaexec_control((struct FTA *) + n->f.streamid, + n->command, + n->sz, + &(n->data[0])))<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } else { + if (send_standard_reply(from,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + gslog(LOG_EMERG,"GSCPRTS::error: Non clearinghouse or HFTA proccess got" + "contacted for clearinghouse or HFTA processing\n"); + } + } + break; + case FTA_PRODUCER_FAILURE: { + if (curprocess.type == CLEARINGHOUSE) { + struct fta_notify_producer_failure_arg * n; + n = (struct fta_notify_producer_failure_arg *) buf; + ftalookup_producer_failure(n->sender,n->producer); + } + } + break; + case FTA_HEARTBEAT: { + if (curprocess.type == CLEARINGHOUSE) { + struct fta_heartbeat_arg * n; + n = (struct fta_heartbeat_arg *) buf; + ftalookup_heartbeat(n->sender,n->trace_id, + n->sz,&(n->data[0])); + } + } + break; + case GSCP_GET_BUFFER:{ + struct sgroup_get_buffer_arg * n; + gs_int32_t res; + struct ringbuf * r; + n = (struct sgroup_get_buffer_arg *) buf; + + if ((r=gscpipc_getshm(from))==0) { + gslog(LOG_EMERG,"GSCPRTS::error::proccess blocked without" + "sharedmemory\n"); + } else { + if (UNREAD(r)) { + /* something arrived in the meantime so wakeup + right away */ + if (send_wakeup(from)<0) { + gslog(LOG_EMERG,"ERROR:Could not send wakeup\n"); + return -1; + } + } else { +#ifndef POLLING + if (ftacallback_add_wakeup(from,r)<0) { + gslog(LOG_EMERG,"ERROR:Could not add wakeup\n"); + return -1; + } +#else + gslog(LOG_EMERG,"Received wakeup request on polling systems\n"); +#endif + } + } + } + break; + case PROCESS_CONTROL:{ + if ((curprocess.type == LFTA) + ||(curprocess.type == HFTA)) { + struct process_control_arg * n; + n = (struct process_control_arg *) buf; + if (send_standard_reply(from, + ftaexec_process_control(n->command, + n->sz, + &(n->data[0])))<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + } else { + if (send_standard_reply(from,-1)<0) { + gslog(LOG_EMERG,"GSCPRTS::error::send standard reply faild\n"); + return -1; + } + gslog(LOG_EMERG,"GSCPRTS::error: Non clearinghouse or HFTA proccess got" + "contacted for clearinghouse or HFTA processing\n"); + } + } + break; + case WAKEUP: + case TIMEOUT: + break; + default: + gslog(LOG_EMERG,"GSCPRTS::error::illegal message queue type %u\n",h->callid); + return -1; + } + /* use this occation to cleanup the messagequeue we can't afford + a backlog in the real message queue since it is limited in + size */ + while (gscpipc_read(&from,&lopp,buf,&length,0)>0) { +#ifdef PRINTMSG + gslog(LOG_EMERG, "request from %u of type %u with length %u\n",from, + h->callid,h->size); +#endif + if ((lopp == FTACALLBACK) && (h->callid < RESULT_OPCODE_IGNORE)) { + if (sidequeue_append(from,buf,length)<0) { + gslog(LOG_EMERG,"ERROR:: Could not add to sidequeue\n"); + return -1; + } + } + + } + } + return 0; +} + +static gs_retval_t map_match(gs_csp_t dev) { + gs_int32_t x; + for(x=0;x<curprocess.mapcnt;x++){ + if (strcmp(dev,curprocess.map[x])==0) { + return 1; + } + } + return 0; +} + +gs_retval_t fta_max_snaplen() +{ + return maxsnaplen; +} + +FTAID fta_register(FTAname name,gs_uint32_t reusable, DEVname dev, + alloc_fta fta_alloc_functionptr, + gs_csp_t schema, gs_int32_t snaplen, gs_uint64_t prefilter) +{ + gs_int8_t rb[MAXRES]; + struct fta_register_arg a; + struct standard_result * sr = (struct standard_result *)rb; + gs_int32_t index; + FTAID res; + FTAID reserr; + res.ip=0; + res.port=0; + res.index=0; + res.streamid=0; + reserr=res; + + /* check if the device matches for the registration */ + if (((dev==0) && (curprocess.deviceid==0)) + || ((dev!=0)&&(map_match(dev)==1))) { + if (dev!=0) { + gslog(LOG_INFO,"Register %s on device %s\n",name,dev); + } else { + gslog(LOG_INFO,"Register %s on default device\n",name); + } + if ((index=ftacallback_add_alloc(name,fta_alloc_functionptr,prefilter))<0) { + gslog(LOG_EMERG,"ERROR could not register callback\n"); + return res; + } + + if (snaplen<0) { + maxsnaplen=-1; + } else { + if (maxsnaplen!=-1) { + maxsnaplen=(snaplen>maxsnaplen)?snaplen:maxsnaplen; + } + } + + res=gscpipc_getftaid(); + res.index=index; + if (curprocess.type != CLEARINGHOUSE) { + a.h.callid = FTA_REGISTER; + a.h.size = sizeof(struct fta_register_arg); + if (strlen(name)>=(MAXFTANAME-1)) { + gslog(LOG_EMERG,"ERROR:FTA name (%s) to large\n",name); + return reserr; + } + if (strlen(schema)>=(MAXSCHEMASZ-1)) { + gslog(LOG_EMERG,"ERROR:FTA schema (%s) to large\n",schema); + return reserr; + } + strcpy(a.name,name); + strcpy(a.schema,schema); + a.f=res; + a.subscriber=res; /* consumer is the same as f for an FTA*/ + a.reusable=reusable; + ipc_call_and_wait(clearinghouseftaid,(gs_sp_t )&a,rb); + if (sr->h.callid != STANDARD_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return reserr; + } + if (sr->result != 0 ) { + gslog(LOG_EMERG,"ERROR:Error in registration\n"); + return reserr; + } + } else { + if (ftalookup_register_fta(gscpipc_getftaid(), + res,name,reusable,schema)!=0) { + return res; + } + } + } + return res; +} + +gs_retval_t fta_unregister(FTAID ftaid) +{ + gs_int8_t rb[MAXRES]; + struct fta_unregister_arg a; + struct standard_result * sr = (struct standard_result *)rb; + if (ftacallback_rm_alloc(ftaid.index)<0) { + gslog(LOG_EMERG,"ERROR could not unregister callback\n"); + return -1; + } + + if (curprocess.type != CLEARINGHOUSE) { + a.h.callid = FTA_UNREGISTER; + a.h.size = sizeof(struct fta_register_arg); + a.f=ftaid; + ipc_call_and_wait(clearinghouseftaid,(gs_sp_t) &a,rb); + if (sr->h.callid != STANDARD_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + return sr->result; + } else { + return ftalookup_unregister_fta(gscpipc_getftaid(),ftaid); + } + return 0; +} + +gs_retval_t hfta_post_tuple(struct FTA * self, gs_int32_t sz, void *tuple) +{ + struct ringbuf * r; + gs_uint32_t msgid; + struct wakeup_result a; + FTAID * f; + gs_int32_t state; + + if (sz>MAXTUPLESZ) { + gslog(LOG_EMERG,"Maximum tuple size is %u\n",MAXTUPLESZ); + return -1; + } + + if (self->printfunc.in_use==1) { + return print_stream(self,sz,tuple); + } + + if (ftacallback_start_streamid((gs_p_t )self)<0) { + gslog(LOG_EMERG,"ERROR:Post for unkown streamid\n"); + return -1; + } + /* now make sure we have space to write in all atomic ringbuffer */ + while((r=ftacallback_next_streamid(&state))!=0) { + if (state == HFTA_RINGBUF_ATOMIC) { +#ifdef BLOCKRINGBUFFER + while (!SPACETOWRITE(r)) { + usleep(100); + } +#endif + if (! SPACETOWRITE(r)) { + /* atomic ring buffer and no space so post nothing */ + return -1; + } + } + } + + + if (ftacallback_start_streamid((gs_p_t )self)<0) { + gslog(LOG_EMERG,"ERROR:Post for unkown streamid\n"); + return -1; + } + + while((r=ftacallback_next_streamid(&state))!=0) { + if (state != HFTA_RINGBUF_SUSPEND) { + if (!SPACETOWRITE(r)) { + //since memory is full we set a warning + shared_memory_full_warning++; + // give receiver a chance to clean up + usleep(0); + } + if (SPACETOWRITE(r)) { + CURWRITE(r)->f=self->ftaid; + CURWRITE(r)->sz=sz; + memcpy(&(CURWRITE(r)->data[0]),tuple,sz); + outtuple++; + outbytes=outbytes+CURWRITE(r)->sz; + ADVANCEWRITE(r); +#ifdef PRINTMSG + gslog(LOG_EMERG,"Wrote in ringpuffer %p [%p:%u]" + "(%u %u) \n",r,&r->start,r->end,r->reader,r->writer); + gslog(LOG_EMERG,"\t%u %u\n",CURREAD(r)->next, + CURREAD(r)->sz); +#endif + } else { + outtupledrop++; + } + if (HOWFULL(r) > 500) { + // buffer is at least half full + shared_memory_full_warning++; +#ifdef PRINTMSG + gslog(LOG_EMERG,"\t\t buffer full\n"); +#endif + } + } + } +#ifndef POLLING + if (ftacallback_start_wakeup((gs_p_t ) self)<0) { + gslog(LOG_EMERG,"ERROR:Wakeup for unkown streamid\n"); + return -1; + } + a.h.callid=WAKEUP; + a.h.size=sizeof(struct wakeup_result); + while((f=ftacallback_next_wakeup())!=0) { + if (send_wakeup(*f)<0) { + gslog(LOG_EMERG,"ERROR:Could not send wakeup\n"); + return -1; + } + } +#endif + return 0; +} + +gs_retval_t hfta_get_ringbuf_space(struct FTA * f, FTAID * r, gs_int32_t * space, gs_int32_t szr, gs_int32_t tuplesz) +{ + gs_int32_t x=0; + gs_int32_t state; + struct ringbuf * ru; + + if (f->printfunc.in_use==1) { + // XXX WHAT TO DO??? + gslog(LOG_INFO,"Checking space for printfunc"); + return 0; + } + + if (ftacallback_start_streamid(f->ftaid.streamid)<0) { + gslog(LOG_EMERG,"ERROR:Space check for unkown streamid in HFTA\n"); + return -1; + } + + while ((ru=ftacallback_next_streamid(&state))!=0) { + if (szr > x ) { + r[x]=ru->destid; + space[x]=TUPLEFIT(ru,tuplesz); + } + x++; + } + return x; +} + + +gs_retval_t hfta_set_ringbuf_type(struct FTA * f, FTAID process, gs_int32_t state) +{ + + if (ftacallback_state_streamid(f->ftaid.streamid,process,state)<0) { + gslog(LOG_EMERG,"ERROR:state change for unkown streamid\n"); + return -1; + } + return 0; +} diff --git a/src/lib/gscphost/callbackregistries.c b/src/lib/gscphost/callbackregistries.c new file mode 100644 index 0000000..8bd0957 --- /dev/null +++ b/src/lib/gscphost/callbackregistries.c @@ -0,0 +1,727 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "callbackregistries.h" +#include "lapp.h" +#include "gscpipc.h" +#include "stdlib.h" +#include "stdio.h" +#include "string.h" +#include <unistd.h> +#include <signal.h> +#include <sys/mman.h> +#include "schemaparser.h" +#include "errno.h" + +#include "gsconfig.h" +#include "gstypes.h" + +struct ftacallbackalloc { + gs_int32_t used; + gs_sp_t name; + alloc_fta fta_alloc_functionptr; + gs_uint64_t prefilter; +}; + +static struct ftacallbackalloc * falloc =0; +static gs_int32_t lalloc=0; + +struct ftacallbackstreamid { + gs_int32_t refcnt; + gs_uint32_t streamid; + gs_uint32_t state; + struct ringbuf * r; +}; + +static struct ftacallbackstreamid * fstreamid =0; +static gs_int32_t lstreamid=0; +static gs_uint32_t cstreamid; +static gs_int32_t nstreamid; + +struct ftacallbackwakeup { + gs_int32_t used; + FTAID ftaid; + struct ringbuf * r; +}; + +static struct ftacallbackwakeup * fwakeup =0; +static gs_int32_t lwakeup=0; +static gs_uint32_t swakeup; +static gs_int32_t nwakeup; + +/* XXX memory of fta list has no owner struct */ + +struct fta_list { + struct fta_list * prev; + struct fta_list * next; + struct FTA * fta; +}; + +static struct fta_list * process=0; +static struct fta_list * created=0; + +static struct fta_list * itteration=0; + +// Side queue datastructures + +struct sq { + FTAID from; + gs_int8_t buf[MAXMSGSZ]; + gs_int32_t length; + struct sq * next; +}; + +static struct sq * sqtop=0; +static struct sq * sqtail=0; + + +/* HFTA internal print function*/ + +gs_retval_t add_printfunction_to_stream( struct FTA * ftaid, gs_sp_t schema, gs_sp_t path, gs_sp_t basename, + gs_sp_t temporal_field, gs_sp_t split_field, gs_uint32_t delta, gs_uint32_t split) { + gs_uint32_t parserversion; + gs_int32_t schemaid; + gs_uint32_t x; + gs_int8_t temp[50000]; + if (ftaid->printfunc.in_use==1) { + gslog(LOG_EMERG,"ERROR:Printfunction::only allow one print function per HFTA instance\n"); + return -1; + } + ftaid->printfunc.path=strdup(path); + ftaid->printfunc.basename=strdup(basename); + ftaid->printfunc.nexttime=0; + ftaid->printfunc.split=(split%1000); + ftaid->printfunc.itt=(split/1000)%1000; + ftaid->printfunc.base=(split/1000000)%1000; + ftaid->printfunc.delta=delta; + ftaid->printfunc.in_use=1; + if (ftaid->printfunc.split > MAXPRINTFILES) { + gslog(LOG_EMERG,"ERROR:Printfunction SPLIT to large\n"); + return -1; + } + for (x=0;x<ftaid->printfunc.split;x++) ftaid->printfunc.fa[x]=0; + + if ((ftaid->printfunc.schemaid=ftaschema_parse_string(schema))<0) { + gslog(LOG_EMERG,"ERROR:could not parse schema in HFTA print function"); + return -1; + } + if ((ftaid->printfunc.temporal_field=ftaschema_get_field_offset_by_name( + ftaid->printfunc.schemaid,temporal_field))<0) { + gslog(LOG_EMERG,"ERROR:could not get " + "offset for timefield %s in HFTA print function\n", + temporal_field); + return -1; + } + + if (ftaschema_get_field_type_by_name( + ftaid->printfunc.schemaid,temporal_field)!=UINT_TYPE) { + gslog(LOG_EMERG,"ERROR: illegal type for timefield " + "%s in HFTA print function UINT expected\n", + temporal_field); + return -1; + } + if ((ftaid->printfunc.split_field=ftaschema_get_field_offset_by_name( + ftaid->printfunc.schemaid,split_field))<0) { + gslog(LOG_EMERG,"ERROR:could not get " + "offset for splitfield %s in HFTA print function\n", + split_field); + return -1; + } + + if (ftaschema_get_field_type_by_name( + ftaid->printfunc.schemaid,split_field)!=UINT_TYPE) { + gslog(LOG_EMERG,"ERROR: illegal type for splitfield" + "%s in HFTA print function UINT expected\n", + split_field); + return -1; + } + parserversion=get_schemaparser_version(); + sprintf(temp,"GDAT\nVERSION:%u\nSCHEMALENGTH:%lu\n%s",parserversion,strlen(schema)+1,schema); + ftaid->printfunc.header=strdup(temp); + gslog(LOG_INFO,"Established print function for %s",basename); + return 0; +} + +gs_retval_t print_stream(struct FTA * self, gs_int32_t sz, void *tuple) +{ + gs_int32_t problem; + gs_uint32_t timeval; + gs_uint32_t splitval; + gs_uint32_t x; + gs_uint32_t nsz; + timeval=fta_unpack_uint(tuple,sz,self->printfunc.temporal_field,&problem); + if (timeval==0) return 0; // ignore heartbeats till we see a real timestamp + if (timeval>= self->printfunc.nexttime) { + gs_int8_t oldname[1024]; + gs_int8_t newname[1024]; + if (self->printfunc.split==0) { + if (self->printfunc.fa[0] != 0) { + sprintf(oldname,"%s/%u%s.tmp",self->printfunc.path,self->printfunc.nexttime-self->printfunc.delta,self->printfunc.basename); + sprintf(newname,"%s/%u%s",self->printfunc.path,self->printfunc.nexttime-self->printfunc.delta,self->printfunc.basename); + fclose(self->printfunc.fa[0]); + rename(oldname,newname); + } + if (self->printfunc.nexttime==0) { + self->printfunc.nexttime=(timeval/self->printfunc.delta)*self->printfunc.delta; + } + sprintf(oldname,"%s/%u%s.tmp",self->printfunc.path,self->printfunc.nexttime,self->printfunc.basename); + if ((self->printfunc.fa[0]=fopen(oldname,"w"))==0) { + gslog(LOG_EMERG,"ERROR:Could not open file in HFTA print function\n"); + return -1; + } + if (setvbuf(self->printfunc.fa[0],0,_IOFBF,16000000)!=0) { + gslog(LOG_EMERG,"ERROR:Could not setvbuf\n"); + } + if (fwrite(self->printfunc.header,strlen(self->printfunc.header)+1,1,self->printfunc.fa[0])!=1) { + gslog(LOG_EMERG,"ERROR:fwrite:xfgh1:%s:%u",self->printfunc.basename,errno); + } + gslog(LOG_INFO,"Opened file %s",oldname); + } else { + for(x=self->printfunc.base;x<self->printfunc.split;x=x+self->printfunc.itt) { + if (self->printfunc.fa[x] != 0) { + sprintf(oldname,"%s/%u_s%u%s.tmp",self->printfunc.path,self->printfunc.nexttime-self->printfunc.delta,x+1,self->printfunc.basename); + sprintf(newname,"%s/%u_s%u%s",self->printfunc.path,self->printfunc.nexttime-self->printfunc.delta,x+1,self->printfunc.basename); + fclose(self->printfunc.fa[x]); + rename(oldname,newname); + } + if (self->printfunc.nexttime==0) { + self->printfunc.nexttime=(timeval/self->printfunc.delta)*self->printfunc.delta; + } + sprintf(oldname,"%s/%u_s%u%s.tmp",self->printfunc.path,self->printfunc.nexttime,x+1,self->printfunc.basename); + if ((self->printfunc.fa[x]=fopen(oldname,"w"))==0) { + gslog(LOG_EMERG,"ERROR:Could not open file in HFTA print function\n"); + return -1; + } + if (setvbuf(self->printfunc.fa[x],0,_IOFBF,16000000)!=0) { + gslog(LOG_EMERG,"ERROR:Could not setvbuf\n"); + } + if (fwrite(self->printfunc.header,strlen(self->printfunc.header)+1,1,self->printfunc.fa[x])!=1) { + gslog(LOG_EMERG,"ERROR:fwrite:xfgh2:%s:%u",self->printfunc.basename,errno); + } + gslog(LOG_INFO,"Opened file %s",oldname); + } + } + self->printfunc.nexttime=self->printfunc.nexttime+self->printfunc.delta; + } + // don't write temporal tuples to file but use them to advance file name. + if (ftaschema_is_temporal_tuple(self->printfunc.schemaid, tuple)) return 0; + if (self->printfunc.split!=0) { + splitval=fta_unpack_uint(tuple,sz,self->printfunc.split_field,&problem)%(self->printfunc.split); + if (self->printfunc.fa[splitval]==0) { + gslog(LOG_EMERG,"Inconsistent rangehash in print %u\n", splitval); + exit(0); + } + } else { + splitval=0; + } + nsz=htonl(sz); + if (fwrite(&nsz,sizeof(gs_uint32_t),1,self->printfunc.fa[splitval])!=1) { + gslog(LOG_EMERG,"Could not write to output in HFTA print\"%s\":%u.. EXITING\n", + self->printfunc.basename,errno); + exit(0); + } + if (fwrite(tuple,sz,1,self->printfunc.fa[splitval])!=1) { + gslog(LOG_EMERG,"Could not write to output in HFTA print\"%s\"%u.. EXITING\n", + self->printfunc.basename,errno); + exit(0); + } + return 0; +} + +/* registers an alloc function of an FTA and returns a unique index */ +gs_retval_t ftacallback_add_alloc(FTAname name, alloc_fta fta_alloc_functionptr,gs_uint64_t prefilter) +{ + gs_int32_t x; + gslog(LOG_INFO,"Register prefilter %llu for %s\n",prefilter,name); + if (lalloc == 0) { + if ((falloc = malloc(sizeof(struct ftacallbackalloc)*STARTSZ))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + memset(falloc,0,sizeof(struct ftacallbackalloc)*STARTSZ); + lalloc = STARTSZ; + } + for(x=0;(x<lalloc)&&(falloc[x].used!=0);x++); + if (x == lalloc) { + gs_int32_t y; + lalloc = 2*lalloc; + if ((falloc = realloc(falloc,lalloc*sizeof(struct ftacallbackalloc)))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + for (y=x;y<lalloc;y++) + falloc[y].used=0; + } + falloc[x].name=strdup(name); + falloc[x].fta_alloc_functionptr=fta_alloc_functionptr; + falloc[x].prefilter=prefilter; + falloc[x].used=1; + return x; +} + +/* unregisters an alloc function of an FTA and makes the index available + * for reuse + */ + +gs_retval_t ftacallback_rm_alloc(gs_uint32_t index) +{ + falloc[index].used=0; + free(falloc[index].name); + return 0; +} +/* returns the prefilter for a given + * index + */ + +gs_uint64_t ftacallback_get_prefilter(gs_int32_t index) +{ + if ((index<lalloc) && (falloc[index].used!=0)) { + return falloc[index].prefilter; + } + return 0; +} + +/* returns the function pointer of the callback function for a given + * index + */ + +alloc_fta ftacallback_get_alloc(gs_int32_t index) +{ + if ((index<lalloc) && (falloc[index].used!=0)) { + return falloc[index].fta_alloc_functionptr; + } + return 0; +} + + + + + +/* associate ringbuffer with streamid (using refcounting) */ +gs_retval_t ftacallback_add_streamid(struct ringbuf * r, gs_uint32_t streamid) { + gs_int32_t x; + if (lstreamid == 0) { + if ((fstreamid = malloc(sizeof(struct ftacallbackstreamid)*STARTSZ))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + memset(fstreamid,0,sizeof(struct ftacallbackstreamid)*STARTSZ); + lstreamid = STARTSZ; + } + /* first try to increment refcnt */ + for(x=0;(x<lstreamid)&&( + (fstreamid[x].streamid!=streamid) + ||(fstreamid[x].r!=r) + ||(fstreamid[x].refcnt<=0)) ;x++); + if (x>=lstreamid) { + /* now try to find empty slot */ + for(x=0;(x<lstreamid)&&(fstreamid[x].refcnt!=0);x++); + if (x >= lstreamid) { + gs_int32_t y; + lstreamid = 2*lstreamid; + if ((fstreamid = + realloc(fstreamid,sizeof(struct ftacallbackstreamid)*lstreamid))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + for (y=x;y<lstreamid;y++) { + fstreamid[y].refcnt=0; + fstreamid[y].streamid=0; + } + } + fstreamid[x].state=HFTA_RINGBUF_ATOMIC; + fstreamid[x].streamid=streamid; + fstreamid[x].r=r; + } + fstreamid[x].refcnt+=1; + return 0; +} + + +/* unassosciate a ringbuffer from a streamid */ + +gs_retval_t ftacallback_rm_streamid(struct ringbuf * r, gs_uint32_t streamid) +{ + gs_int32_t x; + for(x=0;x<lstreamid;x++) { + if ((fstreamid[x].streamid == streamid) + && (fstreamid[x].r == r) + && (fstreamid[x].refcnt > 0)) + fstreamid[x].refcnt--; + } + return 0; +} + +/* set the state for a given streamid and destination process */ +gs_retval_t ftacallback_state_streamid(gs_int32_t streamid,FTAID process, gs_int32_t state) +{ + gs_int32_t x; + for(x=0;x<lstreamid;x++) { + if ((fstreamid[x].streamid == streamid) + && (fstreamid[x].r->destid.ip == process.ip ) + && (fstreamid[x].r->destid.port == process.port ) + && (fstreamid[x].refcnt > 0)) + fstreamid[x].state=state; + return 0; + } + return -1; +} + +/* starts an itteration through all ringbuffers for a particular streamid */ + +gs_retval_t ftacallback_start_streamid(gs_int32_t streamid) +{ + cstreamid=streamid; + nstreamid=0; + return 0; +} + +/* returns all the ringbuffer associated with the streamid passed in + * ftacallback_start_streamid + */ +struct ringbuf * ftacallback_next_streamid(gs_int32_t* state) +{ + for(;(nstreamid<lstreamid) + &&(fstreamid[nstreamid].streamid != cstreamid); + nstreamid++); + if (nstreamid<lstreamid) { + nstreamid++; + *state=fstreamid[nstreamid-1].state; + return fstreamid[nstreamid-1].r; + } + return 0; +} + + +/* associate msgid with ringbuf */ +gs_retval_t ftacallback_add_wakeup(FTAID ftaid, struct ringbuf * r) +{ + gs_int32_t x; + if (lwakeup == 0) { + if ((fwakeup = malloc(sizeof(struct ftacallbackwakeup)*STARTSZ))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + memset(fwakeup,0,sizeof(struct ftacallbackwakeup)*STARTSZ); + lwakeup = STARTSZ; + } + /* first try to find one for the same process */ + for(x=0;(x<lwakeup)&&( + ((fwakeup[x].ftaid.ip!=ftaid.ip) + || (fwakeup[x].ftaid.port!=ftaid.port)) + ||(fwakeup[x].used==0)) ;x++); + if (x==lwakeup) { + /* now try to find empty slot */ + for(x=0;(x<lwakeup)&&(fwakeup[x].used!=0);x++); + if (x == lwakeup) { + gs_int32_t y; + lwakeup = 2*lwakeup; + if ((fwakeup = + realloc(fwakeup,sizeof(struct ftacallbackwakeup)*lwakeup))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + for (y=x;y<lwakeup;y++) + fwakeup[y].used=0; + } + } + fwakeup[x].used=1; + fwakeup[x].ftaid=ftaid; + fwakeup[x].r=r; + return x; +} + +/* starts an itteration through all msgids associated with + a streamid. This also uses data kept in the fstreamid + registry + */ +gs_retval_t ftacallback_start_wakeup(gs_uint32_t streamid) +{ + swakeup=streamid; + nwakeup=0; + return 0; +} + +/* returns all the msgid blocked on the streamid passed in + * ftacallback_start_streamid and removes the msgid from + * the wakeup list + */ +FTAID * ftacallback_next_wakeup() +{ + for(;(nwakeup<lstreamid) + &&(fstreamid[nwakeup].streamid != swakeup); + nwakeup++); + if (nwakeup<lstreamid) { + gs_int32_t x; + for(x=0;x<lwakeup;x++) + if ((fwakeup[x].r==fstreamid[nwakeup].r) && + (fwakeup[x].used==1)) { + fwakeup[x].used=0; + nwakeup++; + return & fwakeup[x].ftaid; + } + } + nwakeup ++; + return (FTAID *) 0; +} + + + +static gs_retval_t fta_list_add(struct fta_list ** root, struct FTA * after, + struct FTA * fta) { + struct fta_list * new; + struct fta_list * tmp; + + if ((new=(struct fta_list *)malloc(sizeof(struct fta_list)))==0) { + gslog(LOG_EMERG,"fta_list_add:: can't allocate memory\n"); + return -1; + } + + new->fta=fta; + + + if (after==0) { + new->next=*root; + new->prev=0; + *root=new; + if (new->next) { + new->next->prev=new; + } + } else { + tmp=*root; + while((tmp)&&(tmp->fta!=after)) { + tmp=tmp->next; + } + if (tmp==0) { + gslog(LOG_EMERG,"fta_list_add:: can't find after fta\n"); + return -1; + } + new->next=tmp->next; + new->prev=tmp; + tmp->next=new; + if (new->next) { + new->next->prev=new; + } + } + return 0; +} + +static gs_retval_t fta_list_rm(struct fta_list ** root, struct FTA * fta) { + struct fta_list * tmp; + tmp=*root; + while((tmp)&&(tmp->fta!=fta)) { + tmp=tmp->next; + } + if (tmp==0) { + gslog(LOG_EMERG,"fta_list_rm:: can't find fta\n"); + return -1; + } + if (tmp == (*root)) { + *root=tmp->next; + if (tmp->next) { + tmp->next->prev=0; + } + } else { + tmp->prev->next=tmp->next; + if (tmp->next) { + tmp->next->prev=tmp->prev; + } + } + + free(tmp); + return 0; +} + + +static gs_retval_t fta_list_check(struct fta_list ** root, struct FTA * fta) { + struct fta_list * tmp; + tmp=*root; + while((tmp)&&(tmp->fta!=fta)) { + tmp=tmp->next; + } + if (tmp==0) { + return -1; + } + return 0; +} + +gs_retval_t ftaexec_insert(struct FTA * after, struct FTA * new) +{ + + if ((after!=0) && (fta_list_check(&process,after)<0)) { + gslog(LOG_EMERG,"fta_insert:: ilegal adapter for after\n"); + return -1; + } + + if (fta_list_check(&created,new)<0) { + gslog(LOG_EMERG,"fta_insert:: ilegal adapter for new\n"); + return -1; + } + + if (fta_list_check(&process,new)==0) { + new->runrefcnt++; + gslog(LOG_INFO,"fta_insert:: new already in process list reusing entry with streamid %d\n",new->ftaid.streamid); + return 0; + } + + if (fta_list_add(&process,after,new)<0) { + gslog(LOG_EMERG,"fta_insert:: new can not be added to process list\n"); + return -1; + } + + new->runrefcnt++; + + return 0; + +} + +gs_retval_t ftaexec_remove(struct FTA * id){ + + if (fta_list_check(&process,id)<0) { + gslog(LOG_EMERG,"fta_remove:: id not in process list\n"); + return -1; + } + id->runrefcnt--; + if (id->runrefcnt<=0) { + if (fta_list_rm(&process,id)<0) { + gslog(LOG_EMERG,"fta_remove:: id could not be removed from process list\n"); + return -1; + } + } + return 0; +} + + +struct FTA * ftaexec_alloc_instance(gs_uint32_t index, struct FTA * reuse, + gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data){ + struct FTA * f; + FTAID ftaid; + ftaid=gscpipc_getftaid(); + ftaid.index=index; + ftaid.streamid=0; + if (fta_list_check(&created,reuse)==0) { + reuse->refcnt++; + return reuse; + } + if (ftacallback_get_alloc(index)==0) return 0; + f=ftacallback_get_alloc(index)(ftaid,reusable,command, sz, data); + f->prefilter=ftacallback_get_prefilter(index); + gslog(LOG_INFO,"Using prefilter %llu for fta %x\n",f->prefilter,f); + if (fta_list_add(&created,0,f)<0) { + gslog(LOG_EMERG,"fta_alloc_instance:: new fta can not be added to created list\n"); + return 0; + } + f->refcnt=1; + return f; +} + + + +gs_retval_t ftaexec_free_instance(struct FTA * id, gs_uint32_t recursive){ + id->refcnt --; + if (id->refcnt==0) { + if (fta_list_rm(&created,id)<0) { + gslog(LOG_EMERG,"fta_free_instance:: fta could not be removed from created list\n"); + return -1; + } + /* just to make sure remove it form process list too */ + if (fta_list_check(&process,id)>=0) { + fta_list_rm(&process,id); + } + + id->free_fta(id,recursive); + } + return 0; +} + +gs_retval_t ftaexec_control(struct FTA * id, gs_int32_t command, gs_int32_t sz, void * value){ + if (fta_list_check(&created,id)<0) { + gslog(LOG_EMERG,"fta_control:: id not found in adapter's created list\n"); + return -1; + } + return id->control_fta(id,command,sz,value); +} + +gs_retval_t ftaexec_process_control(gs_int32_t command, gs_int32_t sz, void * value){ + struct FTA * f; + ftaexec_start(); + while((f=ftaexec_next())!=0) { + f->control_fta(f,command,sz,value); + } + return 1; +} + + +/* Start itteration through list of active FTA */ + +gs_retval_t ftaexec_start() +{ + itteration=process; + return 0; +} + +/* get one FTA at a time */ + +struct FTA * ftaexec_next() +{ + struct FTA * fta=0; + if (itteration) { + fta=itteration->fta; + itteration=itteration->next; + } + return fta; +} + + +/* adds a buffer to the end of the sidequeue*/ +gs_retval_t sidequeue_append(FTAID from, gs_sp_t buf, gs_int32_t length) +{ + struct sq * s; + if ((s=malloc(sizeof(struct sq)))==0) { + gslog(LOG_EMERG,"Could not allocate memory for sidequeue"); + return -1; + } + s->from=from; + memcpy(&s->buf[0],buf,MAXMSGSZ); + s->length=length; + s->next=0; + if (sqtail) { + sqtail->next=s; + sqtail=s; + } else { + sqtop = s; + sqtail = s; + } + return 0; +} + +/* removes a buffer from the top of the sidequeue*/ +gs_retval_t sidequeue_pop(FTAID * from, gs_sp_t buf, gs_int32_t* length) +{ + struct sq * s; + + if (sqtop) { + *from=sqtop->from; + memcpy(buf,&sqtop->buf[0],MAXMSGSZ); + *length=sqtop->length; + s=sqtop; + sqtop=sqtop->next; + if (sqtop==0) sqtail=0; + free(s); + return 0; + } + return -1; +} diff --git a/src/lib/gscphost/clearinghouseregistries.c b/src/lib/gscphost/clearinghouseregistries.c new file mode 100644 index 0000000..84dd266 --- /dev/null +++ b/src/lib/gscphost/clearinghouseregistries.c @@ -0,0 +1,201 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "gsconfig.h" +#include "gstypes.h" +#include <lapp.h> +#include <clearinghouseregistries.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "gshub.h" + +extern const gs_sp_t fta_names[]; + + +/* fta lookup registry in the clearinghouse */ + + +struct ftalookup { + gs_int32_t used; + gs_sp_t name; + FTAID ftaid; + gs_uint32_t reusable; + gs_sp_t schema; +}; + +struct ftalookup * flookup =0; +gs_int32_t llookup=0; + + +/* Adds a FTA to the lookup table */ +gs_retval_t ftalookup_register_fta( FTAID subscriber, FTAID f, + FTAname name, gs_uint32_t reusable, + gs_csp_t schema) +{ + gs_int32_t x; + static gs_int32_t registered_ftas=0; + endpoint gshub; + if (get_hub(&gshub)!=0) { + gslog(LOG_EMERG,"ERROR:could not find gshub to announce fta/instance"); + return -1; + } + if (llookup == 0) { + if ((flookup = malloc(sizeof(struct ftalookup)*STARTSZ))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftalookup\n"); + return -1; + } + memset(flookup,0,sizeof(struct ftalookup)*STARTSZ); + llookup = STARTSZ; + } + for(x=0;(x<llookup)&&(flookup[x].used!=0);x++); + if (x == llookup) { + gs_int32_t y; + llookup = 2*llookup; + if ((flookup = realloc(flookup,llookup*sizeof(struct ftalookup)))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory ftacallback\n"); + return -1; + } + for (y=x;y<llookup;y++) + flookup[y].used=0; + } + if (f.streamid==0) { + gslog(LOG_INFO,"Basic FTA can not be reusable\n"); + reusable=0; + if (registered_ftas>=0) + registered_ftas++; // count them to know when everybody is in + } else { + // register none basic FTA's with GSHUB + if (set_ftainstance(gshub,get_instance_name(),(gs_sp_t)name,&f)!=0) { + gslog(LOG_EMERG,"ERROR:could not set_ftainstance"); + return -1; + } + } + gslog(LOG_INFO,"Adding fta to registry %s reuseable %u\n",name,reusable); + flookup[x].name=strdup(name); + flookup[x].ftaid=f; + flookup[x].reusable=reusable; + flookup[x].schema=strdup(schema); + flookup[x].used=1; + + if (registered_ftas>=0) { + for(x=0; fta_names[x]!=0;x++ ); + if (x<=registered_ftas) { + if (set_initinstance(gshub,get_instance_name())!=0) { + gslog(LOG_EMERG,"hostlib::error::could not init instance"); + return -1; + } + registered_ftas=-1; + } + } + return 0; +} + +/* Removes the FTA from the lookup table */ +gs_retval_t ftalookup_unregister_fta(FTAID subscriber,FTAID f) +{ + gs_int32_t x; + for(x=0;x<llookup;x++) { + if ((flookup[x].used==1) + && (flookup[x].ftaid.streamid) + && (flookup[x].ftaid.ip) + && (flookup[x].ftaid.port) + && (flookup[x].ftaid.index)) { + flookup[x].used=0; + free(flookup[x].name); + free(flookup[x].schema); + } + } + return 0; +} + +/* Looks an FTA up by name */ +gs_retval_t ftalookup_lookup_fta_index(FTAID caller, + FTAname name, gs_uint32_t reuse, FTAID * ftaid, + gs_csp_t * schema) +{ + gs_int32_t x; +#ifdef PRINTMSG + fprintf(stderr,"Name %s reusable %u\n",name,reuse); +#endif + if (reuse==1) { + /* grep the firs reusable instance */ + for(x=0;x<llookup;x++) { + if ((flookup[x].used==1)&&(strcmp(flookup[x].name,name)==0) + && (flookup[x].reusable>=1) + && (flookup[x].ftaid.streamid!=0)) { + *ftaid=flookup[x].ftaid; + *schema=flookup[x].schema; +#ifdef PRINTMSG + fprintf(stderr,"\tREUSE FTA\n"); +#endif + return 0; + } + } + } + /* grep the first fta with the name not an instance */ + for(x=0;x<llookup;x++) { + if ((flookup[x].used==1)&&(strcmp(flookup[x].name,name)==0) + && (flookup[x].ftaid.streamid==0)) { + *ftaid=flookup[x].ftaid; + *schema=flookup[x].schema; +#ifdef PRINTMSG + fprintf(stderr,"\tNEW FTA\n"); +#endif + + gslog(LOG_DEBUG,"Lookup of FTA %s with FTAID {ip=%u,port=%u,index=%u,streamid=%u}\n",name,ftaid->ip,ftaid->port,ftaid->index,ftaid->streamid); + return 0; + } + } +#ifdef PRINTMSG + fprintf(stderr,"NO MATCH\n"); +#endif + return -1; +} + +gs_retval_t ftalookup_producer_failure(FTAID caller,FTAID producer) { + return 0; +} + +gs_retval_t ftalookup_heartbeat(FTAID caller_id, gs_uint64_t trace_id, + gs_uint32_t sz, fta_stat * trace){ + + gs_uint32_t i = 0; + endpoint gshub; + if (get_hub(&gshub)!=0) { + gslog(LOG_EMERG,"ERROR:could not find gshub to announce fta"); + return -1; + } + + // to avoid sending redundant FTA instance stats to GSHUB we will only send statistics that have trace size of 1 + // for application heartbeats (streamid=0) we will only send last stat in their traces + if ((sz == 1) || (trace[sz-1].ftaid.streamid == 0)) { + if (set_instancestats(gshub,get_instance_name(),&trace[sz-1])!=0) { + gslog(LOG_EMERG,"ERROR:could not set instancestats"); + return -1; + } + + } + + #ifdef PRINTMSG + gslog(LOG_DEBUG,"Heartbeat trace from FTA {ip=%u,port=%u,index=%u,streamid=%u}, trace_id=%llu ntrace=%d\n", caller_id.ip,caller_id.port,caller_id.index,caller_id.streamid, trace_id,sz); + for (i = 0; i < sz; ++i) { + gslog(LOG_DEBUG,"trace_id=%llu, trace[%u].ftaid={ip=%u,port=%u,index=%u,streamid=%u}, fta_stat={in_tuple_cnt=%u,out_tuple_cnt=%u,out_tuple_sz=%u,accepted_tuple_cnt=%u,cycle_cnt=%llu,collision_cnt=%u,eviction_cnt=%u,sampling_rate=%f}\n", trace_id, i, + trace[i].ftaid.ip,trace[i].ftaid.port,trace[i].ftaid.index,trace[i].ftaid.streamid, + trace[i].in_tuple_cnt, trace[i].out_tuple_cnt, trace[i].out_tuple_sz, trace[i].accepted_tuple_cnt, trace[i].cycle_cnt, trace[i].collision_cnt, trace[i].eviction_cnt, trace[i].sampling_rate); + } + #endif + return 0; +} diff --git a/src/lib/gscphost/gscpipc.c b/src/lib/gscphost/gscpipc.c new file mode 100644 index 0000000..502c54c --- /dev/null +++ b/src/lib/gscphost/gscpipc.c @@ -0,0 +1,1344 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include "gsconfig.h" +#include "gstypes.h" +#include "gscpipc.h" +#include "gshub.h" +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/ipc.h> +#include <sys/shm.h> +#include <stdlib.h> +#include <stdio.h> +#include <fcntl.h> +#include <errno.h> +#include <sys/socket.h> +#include <netinet/in.h> + +#ifdef __linux__ +#include <sys/ioctl.h> +#include <netinet/tcp.h> +#include <linux/sockios.h> +#endif + +#ifndef socklen_t +#define socklen_t gs_uint32_t +#endif + + +struct FTAID clearinghouseftaid; + + + +struct connection { + gs_int32_t socket; /* socket for connection */ + gs_int32_t used; /* 1 if the entry is in use */ + FTAID remoteid; /* remoteid of connection */ +}; + +struct connection connectionhash[SOCKET_HASH_SZ]; + +gs_int32_t clearinghouse=0; + +#define SHMTYPE 's' +#define SHM_RECV 1 +#define SHM_SEND 2 + +struct shmlistentry { + FTAID msgid; + gs_int32_t type; + key_t shmtoken; + gs_int32_t shmid; + struct ringbuf * buf; + gs_int32_t buffsize; +}; + +gs_int32_t shmlistlen=0; +struct shmlistentry shmlist[MAX_NUMBER_OF_SHM]; + +struct sq { + gs_int8_t buf[MAXMSGSZ]; + gs_int32_t length; + struct sq * next; +}; + +static struct sq * sqtop=0; +static struct sq * sqtail=0; + +/* adds a buffer to the end of the sidequeue*/ +gs_retval_t gscpipc_sidequeue_append(gs_sp_t buf, gs_int32_t length) +{ + struct sq * s; + if ((s=malloc(sizeof(struct sq)))==0) { + gslog(LOG_EMERG,"Could not allocate memory for sidequeue"); + return -1; + } + memcpy(&s->buf[0],buf,MAXMSGSZ); + s->length=length; + s->next=0; + if (sqtail) { + sqtail->next=s; + sqtail=s; + } else { + sqtop = s; + sqtail = s; + } + return 0; +} + +/* removes a buffer from the top of the sidequeue*/ +gs_retval_t gscpipc_sidequeue_pop(gs_sp_t buf, gs_int32_t * length, gs_int32_t buflen) +{ + struct sq * s; + if (sqtop) { + if (sqtop->length > buflen) { + return -2; + } + memcpy(buf,&sqtop->buf[0],sqtop->length); + *length=sqtop->length; + s=sqtop; + sqtop=sqtop->next; + if (sqtop==0) sqtail=0; + free(s); + return 0; + } + return -1; +} + +struct ipc_message { + FTAID receiver; + FTAID sender; + gs_int32_t operation; +#ifdef PRINTMSG + gs_int32_t pmsgid; +#endif + gs_int32_t size; + gs_int8_t data[4]; +}; + +#define LOWLEVELOP_ACK 0 +#define LOWLEVELOP_NACK 1 +#define LOWLEVELOP_REGISTER 2 +#define LOWLEVELOP_UNREGISTER 3 +#define LOWLEVELOP_SHM_REGISTER 4 +#define LOWLEVELOP_SHM_FREE 5 +#define LOWLEVELOP_SHM_REMOTE_REGISTER 6 +#define LOWLEVELOP_SHM_REMOTE_FREE 7 +#define LOWLEVELOP_REMOTE_TUPLE 8 + +struct internal_message{ + struct ipc_message im; + int lowlevelop; + key_t shmtoken; + int shmsz; + int result; +}; + +struct internal_remote_tuple{ + struct ipc_message im; + int lowlevelop; + int size; + gs_int8_t data[4]; +}; + +FTAID myid; +int listen_socket; + +#ifdef PRINTMSG +int pmsgid=0; +#endif + + +struct shmlistentry * shmlist_find(FTAID msgid, int type) +{ + int x; + for (x=0; x<shmlistlen; x++) { + if ((shmlist[x].msgid.ip == msgid.ip) + && (shmlist[x].msgid.port == msgid.port) + && (shmlist[x].type == type)) { + return &(shmlist[x]); + } + } + return 0; +} + +gs_retval_t shmlist_add(FTAID msgid, int type, key_t shmtoken, + int shmid, struct ringbuf * buf, int buffsize) +{ + if (shmlist_find(msgid, type) !=0) { + return -1; + } + if (shmlistlen>=MAX_NUMBER_OF_SHM) { + gslog(LOG_EMERG,"GSCPTR::error::could not register shm to many" + "shm registered\n"); + return -1; + } + shmlist[shmlistlen].msgid=msgid; + shmlist[shmlistlen].type=type; + shmlist[shmlistlen].shmtoken=shmtoken; + shmlist[shmlistlen].shmid=shmid; + shmlist[shmlistlen].buf=buf; + shmlist[shmlistlen].buffsize=buffsize; + shmlistlen++; + return 0; +} + +static gs_retval_t shmlist_rm(FTAID msgid, gs_int32_t type) +{ + gs_int32_t x; + gs_int32_t move=0; + for (x=0;x<shmlistlen;x++) { + if ((shmlist[x].msgid.ip == msgid.ip) + && (shmlist[x].msgid.port == msgid.port) + &&(shmlist[x].type==type)) { + shmlistlen--; + move=1; + } + if ((move==1)&&(x<shmlistlen)) { + shmlist[x]=shmlist[x+1]; + } + } + return 0; +} + + +/* starts the listen socket for the current proccess + if the listen_port is 0 then a random port is assigned + this function also sets myid + */ +static gs_retval_t msg_init(gs_uint32_t clearinghouse) { + struct sockaddr_in sin; + gs_int32_t x; + FILE *f; + socklen_t sin_sz; + + /* mark all entries in the connection hash as unused */ + for(x=0;x<SOCKET_HASH_SZ;x++) { + connectionhash[x].used=0; + } + + myid.index=0; + myid.streamid=0; + + bzero(&sin, sizeof(sin)); + sin.sin_family = AF_INET; +#ifdef __NetBSD__ + sin.sin_len = sizeof(sin); +#endif + sin.sin_addr.s_addr = 0; + sin.sin_port = 0; + + if ((listen_socket = socket(PF_INET, SOCK_STREAM, 0)) < 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not create listen socket\n"); + return -1; + } + + if (bind(listen_socket, (struct sockaddr *) &sin, sizeof(sin)) < 0 ) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not bind to socket for ip %x port %u with error %u \n", + ntohl(sin.sin_addr.s_addr), ntohs(sin.sin_port),errno); + return -1; + } + + if (listen(listen_socket, 64) < 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not listen to socket for port %u \n",ntohs(sin.sin_port)); + close(listen_socket); + return -1; + } + sin_sz=sizeof(sin); + if (getsockname(listen_socket, (struct sockaddr *) &sin, &sin_sz) < 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not get local port number of listen socket\n"); + return -1; + } + + myid.port=ntohs(sin.sin_port); + myid.ip=ntohl(sin.sin_addr.s_addr); + + return 0; +} + +static void closeconnection(gs_int32_t x) { + if (connectionhash[x].used==1) { + close(connectionhash[x].socket); + connectionhash[x].used=0; + } +} + +static gs_retval_t writeall(gs_int32_t socket, void * b, gs_int32_t sz) { + gs_int32_t rv; + gs_sp_t buf = (gs_sp_t )b; + gs_int32_t res=sz; + while(sz>0) { + if ((rv=write(socket,buf,sz))<0) { + if (errno == EINTR) + continue; + else if (rv == EAGAIN || rv == EWOULDBLOCK) // CHECK THIS XXXOS + return 0; + else + return -1; + } + sz-=rv; + buf+=rv; + } + return res; +} + +static gs_retval_t msg_send(FTAID id, gs_sp_t buf, gs_uint32_t len, gs_uint32_t block) { + struct sockaddr_in sin; + gs_int32_t x; + gs_int32_t u; + gs_int32_t sz; + gs_int32_t ret; + +try_send_again: + u=-1; + for(x=0;x<SOCKET_HASH_SZ;x++) { + if (connectionhash[x].used==1) { + if ((connectionhash[x].remoteid.ip==id.ip) + && (connectionhash[x].remoteid.port==id.port)) { + sz=htonl(len); + if (block==0) { +#ifdef __linux__ + gs_int32_t datainbuffer; + if (ioctl(connectionhash[x].socket,SIOCOUTQ,&datainbuffer)<1) { + gslog(LOG_EMERG, + "GSCMSGQ::error::could not determin free " + "space in write buffer errno %u\n",errno); + return -1; + } + if ((SOCK_BUF_SZ-datainbuffer) < (len+sizeof(gs_uint32_t))) { + return 1; + } + +#else + // low water mark in setsockoption is supported + fd_set fs; + gs_int32_t n; + struct timeval tv; + /* since we set the SNDLOWAT to MAXSZ+4 we know that if the write + * select call returns with a 1 for that file descriptor at least that + * much memory is available in the send buffer and we therefore + * won't block sending + */ + FD_ZERO(&fs); + FD_SET(connectionhash[x].socket,&fs); + n=connectionhash[x].socket+1; + tv.tv_sec = 0; + tv.tv_usec = 0; + if(select(n,0,&fs,0,&tv)!=1) { + return 1; + } +#endif + } +#ifdef PRINTMSG + gslog(LOG_EMERG,"\twriting %u",ntohl(sz)); +#endif + ret = writeall(connectionhash[x].socket,&sz,sizeof(gs_uint32_t)); + if (!ret) + return 1; + else if (ret != sizeof(gs_uint32_t)) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not write length\n"); + return -1; + } + ret = writeall(connectionhash[x].socket,buf,len); + if (!ret) + return 1; + else if (ret != len) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not write message\n"); + return -1; + } +#ifdef PRINTMSG + gslog(LOG_EMERG,"...done\n"); +#endif + return 0; + } + } else { + if (u==-1) { u=x; } + } + } + /* ok we don't have a connection make one */ + if ((u>=SOCKET_HASH_SZ) || (u<0)) { + gslog(LOG_EMERG,"GSCMSGQ::error::reached the maximum" + " TCP connection limit sending %d\n",u); + return -1; + } + connectionhash[u].remoteid=id; + connectionhash[u].remoteid.index=0; + connectionhash[u].remoteid.streamid=0; + sin.sin_family = AF_INET; +#ifdef __NetBSD__ + sin.sin_len = sizeof(sin); +#endif + sin.sin_addr.s_addr = htonl(id.ip); + sin.sin_port = htons(id.port); + if ((connectionhash[u].socket = socket(PF_INET, SOCK_STREAM, 0)) < 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not create socket\n"); + return -1; + } + if (connect(connectionhash[u].socket,(struct sockaddr* )&sin,sizeof(sin)) < 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not connect\n"); + return -1; + } + sz=SOCK_BUF_SZ; + if (setsockopt(connectionhash[u].socket, SOL_SOCKET, SO_SNDBUF, + (gs_sp_t )&sz, sizeof(sz)) != 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not set send buffer size\n"); + return -1; + } + sz=SOCK_BUF_SZ; + if (setsockopt(connectionhash[u].socket, SOL_SOCKET, SO_RCVBUF, + (gs_sp_t )&sz, sizeof(sz)) != 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not set receive buffer size\n"); + return -1; + } +#ifndef __linux__ + // Linux does not support low watermarks on sockets so we use ioctl SIOCOUTQ instead + sz=MAXSZ+4; + if (setsockopt(connectionhash[u].socket, SOL_SOCKET, SO_SNDLOWAT, + (gs_sp_t )&sz, sizeof(sz)) != 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not set send buffer low watermark errorn %u\n",errno); + return -1; + } +#endif + sz=1; + if (setsockopt(connectionhash[u].socket, SOL_SOCKET, SO_KEEPALIVE, + (gs_sp_t )&sz, sizeof(sz)) != 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not set keepalive\n"); + return -1; + } + connectionhash[u].used=1; + goto try_send_again; + return -1; +} + +static gs_retval_t readall(gs_int32_t socket, void * b, gs_int32_t sz) { + gs_int32_t rv; + gs_sp_t buf = (gs_sp_t )b; + gs_int32_t res=sz; + while(sz>0) { + if ((rv=read(socket,buf,sz))<0) { + if (errno == EINTR) + continue; + gslog(LOG_EMERG,"read with error number %u \n",errno); + return -1; + } + if (rv==0) { + return 0; + } + sz-=rv; + buf+=rv; + } + return res; +} + +/* msg_recv return len if data is available -1 for a timeout and -2 for an error */ +static gs_retval_t msg_recv(gs_sp_t buf, gs_uint32_t buflen, gs_uint32_t block, gs_uint32_t check_sideque) { + struct sockaddr_in sin; + socklen_t sl; + fd_set fs; + gs_int32_t x,y; + gs_int32_t n; + gs_int32_t length; + struct timeval tv; + gs_int32_t sret; + static gs_int32_t last=0; + gs_uint32_t sz; + + if (check_sideque==1) { + if ((x=gscpipc_sidequeue_pop(buf, &length,buflen))==0) { + return length; + } + if (x==-2) { + gslog(LOG_EMERG,"GSCMSGQ::error::message in side queue to long\n"); + return -2; + } + } + +read_again: + if (block==0) { + tv.tv_sec = 0; + tv.tv_usec = 0; + } else { + tv.tv_sec = 0; + tv.tv_usec = 100000; + } + FD_ZERO(&fs); + FD_SET(listen_socket,&fs); + n=listen_socket; + for(x=0;x<SOCKET_HASH_SZ;x++) { + if (connectionhash[x].used==1) { + FD_SET(connectionhash[x].socket,&fs); + if (n<connectionhash[x].socket) { + n=connectionhash[x].socket; + } + } + } + n=n+1; + // now block + sret=select(n,&fs,0,0,&tv); + if ((sret<0) && (errno!=EINTR)) { + gslog(LOG_EMERG,"Select with error %u\n",errno); + return -2; + } + if (sret<=0) { + return -1; + } + if (FD_ISSET(listen_socket,&fs)) { + for (x=0;(x<SOCKET_HASH_SZ) && (connectionhash[x].used !=0) ;x++); + if (x>=SOCKET_HASH_SZ) { + gslog(LOG_EMERG,"GSCMSGQ::error::reached the maximum" + "TCP connection limit accepting\n"); + goto read_again; + } + sl=sizeof(sin); + if ((connectionhash[x].socket=accept(listen_socket,(struct sockaddr *)&(sin),&sl)) + < 0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not accept new connection\n"); + goto read_again; + } + + sz=SOCK_BUF_SZ; + if (setsockopt(connectionhash[x].socket, SOL_SOCKET, SO_SNDBUF, + (gs_sp_t )&sz, sizeof(sz)) != 0) { + fprintf(stderr,"GSCMSGQ::error::could not set send buffer size\n"); + return -1; + } + sz=SOCK_BUF_SZ; + if (setsockopt(connectionhash[x].socket, SOL_SOCKET, SO_RCVBUF, + (gs_sp_t )&sz, sizeof(sz)) != 0) { + fprintf(stderr,"GSCMSGQ::error::could not set receive buffer size\n"); + return -1; + } + + sl=sizeof(sin); + if (getpeername(connectionhash[x].socket,(struct sockaddr *)&(sin),&sl)<0) { + gslog(LOG_EMERG,"GSCMSGQ::error::could not get peername on new connection\n"); + close(connectionhash[x].socket); + goto read_again; + } + connectionhash[x].remoteid.ip=ntohl(sin.sin_addr.s_addr); + connectionhash[x].remoteid.port=ntohs(sin.sin_port); + connectionhash[x].remoteid.index=0; + connectionhash[x].remoteid.streamid=0; + connectionhash[x].used=1; +#ifdef PRINTMSG + gslog(LOG_EMERG,"Accepted from %u\n",connectionhash[x].remoteid.port); +#endif + goto read_again; + } + for(x=0;x<SOCKET_HASH_SZ;x++) { + last=(last+1)%SOCKET_HASH_SZ; + if ((connectionhash[last].used==1) && (FD_ISSET(connectionhash[last].socket,&fs))){ + gs_int32_t rsz; +#ifdef PRINTMSG + gslog(LOG_EMERG,"reading sret:%d block:%u...",sret,block); +#endif + if ((rsz=readall(connectionhash[last].socket,&length,sizeof(gs_uint32_t)))!=sizeof(gs_uint32_t)) { + closeconnection(last); + gslog(LOG_EMERG,"GSCMSGQ::error::connection is closing %u res %d\n", + connectionhash[last].remoteid.port,rsz); + continue; + } + length=ntohl(length); + if (buflen<length) { + gs_int8_t d; + gslog(LOG_EMERG,"GSCMSGQ::error::message to long (%u) for receive buffer (%u)\n",length, + buflen); + /* remove the data */ + for(y=0;y<length;y++) + if (readall(connectionhash[last].socket,&d,1)!=1) { + closeconnection(last); + gslog(LOG_EMERG,"GSCMSGQ::error::connection is closing for receive buffer mismatch\n"); + return -2; + } + return -2; + } + if (readall(connectionhash[last].socket,buf,length)!=length) { + closeconnection(last); + gslog(LOG_EMERG,"GSCMSGQ::error::connection is closing on data read\n"); + continue; + } +#ifdef PRINTMSG + gslog(LOG_EMERG,"reading done\n"); +#endif + return length; + } + } + return -1; +} + +static gs_retval_t send_nack(FTAID recid) { + struct internal_message i; + i.im.receiver = recid; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_NACK; + if (msg_send(recid,(gs_sp_t )&i,i.im.size,1) == 0) { + return 0; + } else { + return -1; + } + return -1; +} + +static gs_retval_t send_ack(FTAID recid) { + struct internal_message i; + i.im.receiver = recid; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_ACK; + if (msg_send(recid,(gs_sp_t )&i,i.im.size,1) == 0) { + return 0; + } else { + return -1; + } + return -1; +} + +static gs_retval_t wait_for_lowlevel_ack() { + gs_int8_t b[MAXMSGSZ]; + struct internal_message * i; + gs_int32_t res; + i=(struct internal_message *)b; + + /* this is bussy waiting if there is another + message waiting to be processed so make sure it is only + used where bussy waiting is OK. If that becomes + a probelm add a local queue + */ + + while( 1==1) { + if ((res=msg_recv(b, MAXMSGSZ,1,0))>0) { + if ((i->im.operation == RESERVED_FOR_LOW_LEVEL) + && (( i->lowlevelop == LOWLEVELOP_ACK) + || ( i->lowlevelop == LOWLEVELOP_NACK))) { + if ( i->lowlevelop == LOWLEVELOP_ACK) { + return 0; + } else { + return 1; + } + } + if (i->lowlevelop==LOWLEVELOP_REMOTE_TUPLE) { + struct internal_remote_tuple * it; + struct shmlistentry * s; + it=(struct internal_remote_tuple *)b; + + if ((s=shmlist_find(it->im.sender, SHM_RECV))!=0) { +#ifdef PRINTMSG + gslog(LOG_EMERG,"Received remote ringbuf message " + "for message of size %u\n", + it->size,it->im.size); +#endif +#ifdef BLOCKRINGBUFFER + while (SPACETOWRITE(s->buf)==0) { + usleep(1000); + gslog(LOG_ERR,"Dead in the water we can't " + "drain the ringbuffer we wait for."); + } + memcpy(CURWRITE(s->buf),&(it->data[0]),it->size); + ADVANCEWRITE(s->buf); +#else + if (SPACETOWRITE(s->buf)) { + memcpy(CURWRITE(s->buf),&(it->data[0]),it->size); + ADVANCEWRITE(s->buf); + } else { + // gslog(LOG_EMERG,"r+"); + } +#endif + } else { + gslog(LOG_EMERG,"Received tuple on msq for none existing remote ringbuffer\n"); + } + } else { + gscpipc_sidequeue_append(b, res); + } + } else { + if (res < -1) { + /* got an error here */ + gslog(LOG_EMERG,"hostlib::error::received error " + "during wait for low level ack\n"); + return -1; + } + } + } + /* never reached */ + return -1; +} + +void shmlist_drain_remote() +{ + gs_int32_t x; + gs_int8_t buf[MAXSZ]; + struct internal_remote_tuple * it; + it = (struct internal_remote_tuple *) buf; + for (x=0; x<shmlistlen; x++) { + if ((shmlist[x].msgid.ip != myid.ip)&& (shmlist[x].type==SHM_SEND)) { + while (UNREAD(shmlist[x].buf)) { + it->im.receiver = shmlist[x].msgid; + it->im.sender = myid; + it->im.operation = RESERVED_FOR_LOW_LEVEL; + it->lowlevelop = LOWLEVELOP_REMOTE_TUPLE; + it->size=UP64(CURREAD(shmlist[x].buf)->sz)+sizeof(struct tuple)-1; + it->im.size = sizeof(struct internal_remote_tuple)-4+it->size; + memcpy(&(it->data[0]),CURREAD(shmlist[x].buf),it->size); +#ifdef PRINTMSG + gslog(LOG_EMERG,"Sending remote ringbuffer message of size %u %u\n", + it->size, it->im.size); +#endif + if (msg_send(shmlist[x].msgid,(gs_sp_t )it,it->im.size,0)==1) { + break; + } + ADVANCEREAD(shmlist[x].buf); + } + } + } +} + +/* + *used to contact the clearinghouse process returns the MSGID of + * the current process + */ +gs_retval_t gscpipc_init(gs_int32_t clearinghouse) +{ + struct internal_message i; + key_t msqtoken=0; + gs_int32_t x; + endpoint gshub; + endpoint tmpclearinghouse; + + /* make sure priveleges can be set */ + umask(0); + + clearinghouseftaid.index=0; + clearinghouseftaid.streamid=0; + + if (get_hub(&gshub)!=0) { + gslog(LOG_EMERG,"hostlib::error::could get hub\n"); + return -1; + } + + if (clearinghouse!=0) { + // This is the clearinghouse + gs_int8_t buf[MAXMSGSZ]; + + if (msg_init(1)<0) { + gslog(LOG_EMERG,"hostlib::error::could not init msgq\n"); + return -1; + } + + clearinghouseftaid.ip=myid.ip; + clearinghouseftaid.port=myid.port; + + tmpclearinghouse.ip=htonl(clearinghouseftaid.ip); + tmpclearinghouse.port=htons(clearinghouseftaid.port); + + if (set_instance(gshub, get_instance_name(), tmpclearinghouse)!=0) { + gslog(LOG_EMERG,"hostlib::error::clearinghouse could not set instance"); + return -1; + } + + return 0; + + } else { + // This is an lfta/hfta/app + gs_int32_t res; + + if (get_instance(gshub,get_instance_name(),&tmpclearinghouse,1) < 0) { + gslog(LOG_EMERG,"hostlib::error::could not find clearinghouse\n"); + return -1; + } + + clearinghouseftaid.ip=ntohl(tmpclearinghouse.ip); + clearinghouseftaid.port=ntohs(tmpclearinghouse.port); + + + if (msg_init(0)<0) { + gslog(LOG_EMERG,"hostlib::error::could not init msgq\n"); + return -1; + } + + i.im.receiver = clearinghouseftaid; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_REGISTER; +#ifdef PRINTMSG + i.im.pmsgid=pmsgid; + pmsgid++; + gslog(LOG_EMERG,"send a message (%d.%u) to %u with op " + "%u with size %u\n", + i.im.pmsgid,i.im.receiver.port,i.im.operation, + i.im.size); +#endif + if ((res=msg_send(clearinghouseftaid,(gs_sp_t )&i,i.im.size,1)) == 0) { + /* we can wait her for an ack since nobody should know + about us yet */ + init_read_again: + if ((res=msg_recv((gs_sp_t )&i, + sizeof(struct internal_message), + 1,0))>=0) { + if (i.lowlevelop == LOWLEVELOP_ACK) { + return 0; + } else { + gslog(LOG_EMERG,"hostlib::error::received unexpected message " + "during initalization\n"); + return -1; + } + } else { + if (res<-1) { + /* got an error here */ + gslog(LOG_EMERG,"hostlib::error::received error message " + "during initalization\n"); + return -1; + } else { + goto init_read_again; + } + } + } + gslog(LOG_EMERG,"hostlib::error::could not send on msgqueue\n"); + return -1; + } + return 0; +} + + +static gs_retval_t gscpdetachshm(FTAID target) +{ + struct internal_message i; + + i.im.receiver = target; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_SHM_FREE; + if (msg_send(target,(gs_sp_t )&i,i.im.size,1)<0) { + /* no reason to wait here won't be acked anyway */ + return -1; + } + return 0; +} + +static gs_retval_t gscpdetachsocket(FTAID target) +{ + struct internal_message i; + + i.im.receiver = target; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_UNREGISTER; + if (msg_send(target,(gs_sp_t )&i,i.im.size,1) <0) { + /* no reason to wait here won't be acked anyway */ + return -1; + } + return -1; +} + + +/* used to disassociate process from clearinghouse */ +gs_retval_t gscpipc_free() +{ + gs_int32_t x; + /* XXX OS if this function is called when there are still + subscribed FTAs for this process the clearinghouse will + crash + */ + + if (clearinghouse!=0) { + return 0; + } else { + gs_int32_t x; + for (x=0; x<shmlistlen; x++) { + if (shmlist[x].type==SHM_RECV) { + gscpdetachshm(shmlist[x].msgid); + if (shmdt((gs_sp_t )shmlist[x].buf)!=0) { + gslog(LOG_EMERG,"hostlib::error::could not " + "detach shared memory\n"); + } + } else { + gslog(LOG_EMERG,"hostlib::error::porccess freed while still " + "attached to sending shared memory\n"); + } + } + } + /* remove connection */ + for(x=0;x<SOCKET_HASH_SZ;x++) { + if (connectionhash[x].used==1) { + //XXX detach does not work due to interleaved messages + // gscpdetachsocket(connectionhash[x].remoteid); + close(connectionhash[x].socket); + } + } + close(listen_socket); + return 0; +} + +/* returns MSGID of current process */ +FTAID gscpipc_getftaid() +{ + return myid; +} + + +/* sends a message to a process */ +gs_retval_t gscpipc_send(FTAID f, gs_int32_t operation, gs_sp_t buf, gs_int32_t length, gs_int32_t block) +{ + gs_int8_t b[MAXMSGSZ]; + struct ipc_message * i; + struct shmlistentry * s; + if (length > MAXMSGSZ) { + gslog(LOG_EMERG,"hostlib::error::gscpipc_send msg to long\n"); + return -1; + } + i = (struct ipc_message *) b; + i->receiver=f; + i->sender=myid; + i->operation=operation; + i->size=length+sizeof(struct ipc_message); + memcpy(&i->data[0],buf,length); +#ifdef PRINTMSG + i->pmsgid=pmsgid; + pmsgid++; + gslog(LOG_EMERG,"send a message (%d.%u) to %u with op %u with size %u\n", + i->pmsgid,f.ip,i->receiver.ip,i->operation,i->size,length); +#endif + if ((s=shmlist_find(f, SHM_RECV))!=0) { + // set the hint in the ringbuffer that there is something on the shared memory queue + s->buf->mqhint=1; + } + if (msg_send(f,(gs_sp_t )i,i->size,block) < 0) { + gslog(LOG_EMERG,"hostlib::error::gscpipc_send msgsnd failed errno (%u)\n",errno); + return -1; + } + return 0; +} + +/* retrieve a message buf has to be at least of size MAXMSGSZ*/ +gs_retval_t gscpipc_read(FTAID * f, gs_int32_t * operation, gs_sp_t buf, gs_int32_t * size, gs_int32_t block) +{ + gs_int32_t w; + gs_int32_t x; + gs_int8_t b[MAXSZ]; + gs_int32_t y; + + struct internal_message * i; + struct internal_remote_tuple * it; + gs_int32_t length; + + struct shmlistentry * s; + + i=(struct internal_message *)b; + it=(struct internal_remote_tuple *)b; + + for(y=0;(y < 10) || (block==1);y++) { + shmlist_drain_remote(); + length=msg_recv((gs_sp_t )b, MAXMSGSZ, block,1); + if (length < -1) { + /* problem */ + return -1; + } + if (length < 0) { + /* we are nonblocking and have nothing to do */ + if (block==1) { + // we are expected to block for ever if it is 0 or 2 we return + continue; + } + return 0; + } +#ifdef PRINTMSG + gslog(LOG_EMERG,"got a message (%d.%u) from %u with op %u with size %u\n", + i->im.pmsgid, i->im.sender, i->im.sender,i->im.operation,i->im.size); +#endif + if (length <0) { + gslog(LOG_EMERG,"gscpipc::Error receiving message %u\n",errno); + return -1; + } + if (i->im.operation != RESERVED_FOR_LOW_LEVEL) { + memcpy(buf,&(i->im.data[0]),i->im.size); + *size=i->im.size-sizeof(struct ipc_message); + *operation=i->im.operation; + *f=i->im.sender; + if ((s=shmlist_find(*f, SHM_SEND))!=0) { + // clear the hint in the ringbuffer to indicate we got the message + s->buf->mqhint=0; + } + return 1; + } + switch (i->lowlevelop) { + case LOWLEVELOP_REGISTER: + /* this should only get called if the process is the clearinghouse */ +#ifdef PRINTMSG + gslog(LOG_EMERG,"request to register %u\n",i->im.sender.port); +#endif + send_ack(i->im.sender); + break; + case LOWLEVELOP_UNREGISTER: +#ifdef PRINTMSG + gslog(LOG_EMERG,"request to unregister %u\n",i->im.sender.port); +#endif /* remove connection */ + for(x=0;x<SOCKET_HASH_SZ;x++) { + if ( (connectionhash[x].used==1) + && (connectionhash[x].remoteid.ip==i->im.sender.ip) + && (connectionhash[x].remoteid.port==i->im.sender.port)) { + gslog(LOG_EMERG,"Close by remote request %u\n", + connectionhash[x].remoteid.port); + // XXX closed when the other process dies + // can't close it yet since we might have + // some more messages + // close(connectionhash[x].socket); + connectionhash[x].used=0; + } + } + break; + case LOWLEVELOP_SHM_REGISTER: + { + gs_int32_t shmid; + struct ringbuf * r; + struct shmid_ds sms; +#ifdef PRINTMSG + gslog(LOG_EMERG,"request to get shm %u token 0x%x size %u\n", + i->im.sender.port, + i->shmtoken,i->shmsz); +#endif + if ((shmid = shmget(i->shmtoken,i->shmsz,IPC_RALL|IPC_WALL))!=-1) { + if (((gs_p_t)(r=(struct ringbuf *)shmat(shmid,0,0)))==(gs_p_t)(-1)) { + gslog(LOG_EMERG,"hostlib::error::could not attach send shm errno (%u)\n",errno); + send_nack(i->im.sender); + } else { + // Make sure all the momory gets mapped now + for(x=0;x<length;x=x+1024) { + ((gs_uint8_t *) r)[x]=0; + } + +#ifdef PRINTMSG + gslog(LOG_EMERG,"Got a ring buffer at address %p (%u %u %u %u)\n" + ,(void *)r,r->reader,r->writer,r->length,i->shmtoken); +#endif + if (shmlist_add(i->im.sender,SHM_SEND,i->shmtoken, + shmid,r,i->shmsz)<0) { + shmdt((gs_sp_t )r); + shmctl(shmid,IPC_RMID,&sms); + gslog(LOG_EMERG,"hostlib::error::could not add shm internally\n"); + send_nack(i->im.sender); + } else { + send_ack(i->im.sender); + } + } + } else { + gslog(LOG_EMERG,"hostlib::error::could not access send shm %u\n",errno); + send_nack(i->im.sender); + } + } + break; + case LOWLEVELOP_SHM_REMOTE_REGISTER: + { + gs_int32_t shmid; + struct ringbuf * r; + struct shmid_ds sms; +#ifdef PRINTMSG + gslog(LOG_EMERG,"request to get remote shm %u size %u\n", + i->im.sender.port,i->shmsz); +#endif + if ((r=(struct ringbuf *)malloc(i->shmsz))==0) { + gslog(LOG_EMERG,"hostlib::error::could not allocat send remote shm errno (%u)\n",errno); + send_nack(i->im.sender); + } else { + // make sure all the memory gets mapped now + for(x=0;x<length;x=x+1024) { + ((gs_uint8_t *) r)[x]=0; + } + r->reader=0; + r->writer=0; + r->length=i->shmsz; + r->end= i->shmsz-MAXTUPLESZ; + r->destid=i->im.receiver; + r->srcid=i->im.sender; +#ifdef PRINTMSG + gslog(LOG_EMERG,"Got a remote ring buffer at address %p (%u %u %u %u)\n" + ,(void *)r,r->reader,r->writer,r->length,i->shmtoken); +#endif + if (shmlist_add(i->im.sender,SHM_SEND,0, + 0,r,i->shmsz)<0) { + gslog(LOG_EMERG,"hostlib::error::could not add remote shm internally\n"); + send_nack(i->im.sender); + } else { + send_ack(i->im.sender); + } + } + } + break; + case LOWLEVELOP_SHM_FREE: + { + struct shmlistentry * sm; + struct shmid_ds sms; +#ifdef PRINTMSG + gslog(LOG_EMERG,"request to free shm %u\n",i->im.sender); +#endif + if ((sm=shmlist_find(i->im.sender,SHM_SEND)) !=0) { +#ifdef PRINTMSG + gslog(LOG_EMERG,"freeing %u",sm->shmid); +#endif + shmdt((gs_sp_t )sm->buf); + shmctl(sm->shmid,IPC_RMID,&sms); + shmlist_rm(i->im.sender,SHM_SEND); + } + } + break; + case LOWLEVELOP_SHM_REMOTE_FREE: + { + struct shmlistentry * sm; + struct shmid_ds sms; +#ifdef PRINTMSG + gslog(LOG_EMERG,"request to free shm %u\n",i->im.sender); +#endif + if ((sm=shmlist_find(i->im.sender,SHM_SEND)) !=0) { +#ifdef PRINTMSG + gslog(LOG_EMERG,"freeing %u",sm->shmid); +#endif + free((gs_sp_t ) sm->buf); + shmlist_rm(i->im.sender,SHM_SEND); + } + } + break; + case LOWLEVELOP_REMOTE_TUPLE: + { + if ((s=shmlist_find(it->im.sender, SHM_RECV))!=0) { +#ifdef PRINTMSG + gslog(LOG_EMERG,"Received remote ringbuf message " + "for message of size %u\n", + it->size,it->im.size); +#endif +#ifdef BLOCKRINGBUFFER + while (SPACETOWRITE(s->buf)==0) { + usleep(1000); + gslog(LOG_EMERG,"Dead in the water we can't drain the ringbuffer we wait for."); + } + memcpy(CURWRITE(s->buf),&(it->data[0]),it->size); + ADVANCEWRITE(s->buf); +#else + if (SPACETOWRITE(s->buf)) { + memcpy(CURWRITE(s->buf),&(it->data[0]),it->size); + ADVANCEWRITE(s->buf); + } else { + // gslog(LOG_EMERG,"r+"); + } +#endif + } else { + gslog(LOG_EMERG,"Received tuple on msq for none existing remote ringbuffer\n"); + } + } + break; + default: + gslog(LOG_EMERG,"hostlib::error::unexpected message received\n"); + return -1; + } + } + return 0; +} + +/* allocate a ringbuffer which allows receiving data from + * the other process. returns 0 if didn't succeed and + * returns an existing buffer if it exists */ +struct ringbuf * gscpipc_createshm(FTAID f, gs_int32_t length) +{ + struct shmid_ds sms; + struct shmlistentry * se; + gs_int8_t keybuf[1024]; + key_t shmtoken=0; + gs_int32_t shmid=0; + struct ringbuf * r; + struct internal_message i; + gs_int32_t x; + + se = shmlist_find(f, SHM_RECV); + if (se) { + return se->buf; + } + + if (length<(4*MAXTUPLESZ)) { + gslog(LOG_EMERG, + "ERROR:buffersize in gscpipc_createshm has to be " + "at least %u Bytes long\n", + 4*MAXTUPLESZ); + return 0; + } + + if (myid.ip == f.ip) { + sprintf(keybuf,"/tmp/gscpapp_%u_%u.pid",myid.port,f.port); + if ((x=open(keybuf,O_CREAT,S_IRWXU|S_IRWXG|S_IRWXO)) ==-1) { + gslog(LOG_EMERG,"hostlib::error::could not create shared memory id\n"); + return 0; + } + close(x); + + if ((shmtoken = ftok(keybuf,SHMTYPE))==-1) { + gslog(LOG_EMERG,"hostlib::error::could not determin shm receive queue id\n"); + return 0; + } + + if ((gs_int32_t)(shmid = shmget(shmtoken,length,IPC_RALL|IPC_WALL| + IPC_CREAT|IPC_EXCL))==-1) { + gslog(LOG_EMERG,"hostlib::error::could not access receive shm %u\n",errno); + return 0; + } + if ((gs_p_t)(r=(struct ringbuf *)shmat(shmid,0,0))==(gs_p_t)(-1)) { + gslog(LOG_EMERG,"hostlib::error::could not attach receive shm\n"); + return 0; + } + /* touch all memory once to map/reserve it now */ + for(x=0;x<length;x=x+1024) { + ((gs_uint8_t *) r)[x]=0; + } + r->reader=0; + r->writer=0; + r->length=length; + r->end= r->length-MAXTUPLESZ; + r->destid=f; + r->srcid=myid; + i.im.receiver = f; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_SHM_REGISTER; + i.shmtoken = shmtoken; + i.shmsz=length; + if (msg_send(f,(gs_sp_t )&i,i.im.size,1) == 0) { + if (wait_for_lowlevel_ack()<0) { + shmdt((gs_sp_t )r); + shmctl(shmid,IPC_RMID,&sms); + return 0; + } + } + shmctl(shmid,IPC_RMID,&sms); /* this will destroy the shm automatically after all processes detach */ + if (shmlist_add(f, SHM_RECV, shmtoken, + shmid, r, length) <0) { + shmdt((gs_sp_t )r); + shmctl(shmid,IPC_RMID,&sms); + i.im.receiver = f; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_SHM_FREE; + i.shmtoken = shmtoken; + msg_send(f,(gs_sp_t )&i,i.im.size,1); + return 0; + } + } else { + /* remote shared memory */ + if ((r=(struct ringbuf *)malloc(length))==0) { + gslog(LOG_EMERG,"hostlib::error::could not malloc local part of remote ringbuffer\n"); + return 0; + } + /* touch all memory once to map/reserve it now */ + for(x=0;x<length;x=x+1024) { + ((gs_uint8_t *) r)[x]=0; + } + r->reader=0; + r->writer=0; + r->length=length; + r->end= r->length-MAXTUPLESZ; + r->destid=f; + r->srcid=myid; + i.im.receiver = f; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_SHM_REMOTE_REGISTER; + i.shmtoken = shmtoken; + i.shmsz=length; + if (msg_send(f,(gs_sp_t )&i,i.im.size,1) == 0) { + if (wait_for_lowlevel_ack()<0) { + free(r); + return 0; + } + } + if (shmlist_add(f, SHM_RECV, 0, + 0, r, length) <0) { + free(r); + i.im.receiver = f; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_SHM_REMOTE_FREE; + msg_send(f,(gs_sp_t )&i,i.im.size,1); + return 0; + } + } + return r; + +} + +/* finds a ringbuffer to send which was allocated by + * gscpipc_creatshm and return 0 on an error */ + +struct ringbuf * gscpipc_getshm(FTAID f) +{ + struct shmlistentry * se; + gs_int32_t recmsgid; + se = shmlist_find(f, SHM_SEND); + if (se) { + return se->buf; + } + return 0; +} + +/* frees shared memory to a particular proccess identified + * by MSGID + */ +gs_retval_t gscpipc_freeshm(FTAID f) +{ + struct internal_message i; + struct shmlistentry * sm; + struct shmid_ds sms; + if (myid.ip == f.ip) { + if ((sm=shmlist_find(f, SHM_RECV)) <0) { + shmdt((gs_sp_t )sm->buf); + shmctl(sm->shmid,IPC_RMID,&sms); + i.im.receiver = f; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_SHM_FREE; + i.shmtoken = sm->shmtoken; + msg_send(f,(gs_sp_t )&i,i.im.size,1); + shmlist_rm(f, SHM_RECV); + } + } else { + if ((sm=shmlist_find(f, SHM_RECV)) <0) { + free((gs_sp_t )sm->buf); + i.im.receiver = f; + i.im.sender = myid; + i.im.operation = RESERVED_FOR_LOW_LEVEL; + i.im.size = sizeof(struct internal_message); + i.lowlevelop = LOWLEVELOP_SHM_REMOTE_FREE; + msg_send(f,(gs_sp_t )&i,i.im.size,1); + shmlist_rm(f, SHM_RECV); + } + } + return 0; +} + +gs_retval_t gscpipc_mqhint() +{ + gs_int32_t x; + for (x=0; x<shmlistlen; x++) { + if (shmlist[x].type == SHM_SEND) { + if (shmlist[x].buf->mqhint) { + return 1; + } + } + } + return 0; +} diff --git a/src/lib/gscphost/include/callbackregistries.h b/src/lib/gscphost/include/callbackregistries.h new file mode 100644 index 0000000..8f3edc7 --- /dev/null +++ b/src/lib/gscphost/include/callbackregistries.h @@ -0,0 +1,143 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef CALLBACKREGISTRIES_H +#define CALLBACKREGISTRIES_H +#include "gsconfig.h" +#include "gstypes.h" + +#include "fta.h" +#include "gscpipc.h" + + +/* This registry is used to keep track of FTAswithin the current process + * they are registerd when they are initiated and unregisterd if + * they are freed + */ + +/* registers an alloc function of an FTA and returns a unique index */ +gs_retval_t ftacallback_add_alloc(FTAname name, alloc_fta fta_alloc_functionptr, gs_uint64_t prefilter); + +/* unregisters an alloc function of an FTA and makes the index available + * for reuse + */ + +gs_retval_t ftacallback_rm_alloc(gs_uint32_t index); + +/* returns the function pointer of the callback function for a given + * index + */ + +alloc_fta ftacallback_get_alloc(gs_int32_t index); + +/* returns the prefilter for a given + * index + */ + +gs_uint64_t ftacallback_get_prefilter(gs_int32_t index); + +/* The second registry is used to keep track of to which process a particular + stream ID should be posted too. + */ + +/* associate ringbuffer with streamid (using refcounting) */ +gs_retval_t ftacallback_add_streamid(struct ringbuf * r, gs_uint32_t streamid); + +/* unassosciate a ringbuffer from a streamid */ + +gs_retval_t ftacallback_rm_streamid(struct ringbuf * r, gs_uint32_t streamid); + +/* starts an itteration through all ringbuffers for a particular streamid */ + +gs_retval_t ftacallback_start_streamid(gs_int32_t streamid); + +/* returns all the ringbuffer associated with the streamid passed in + * ftacallback_start_streamid + */ +struct ringbuf * ftacallback_next_streamid(gs_int32_t * state); + +/* set the state for a given streamid and destination process */ + +gs_retval_t ftacallback_state_streamid(gs_int32_t streamid,FTAID process, gs_int32_t state); + +/* The third registry is used to keep track of which process is blocked + on which ringbuf + */ + +/* associate msgid with ringbuf */ +gs_retval_t ftacallback_add_wakeup(FTAID ftaid, struct ringbuf * r); + +/* starts an itteration through all msgids associated with + a streamid. This also uses data kept in the second + registry + */ +gs_retval_t ftacallback_start_wakeup(gs_uint32_t streamid); + +/* returns all the msgid blocked on the streamid passed in + * ftacallback_start_streamid and removes the msgid from + * the wakeup list + */ +FTAID * ftacallback_next_wakeup(); + + +/* + * the following two functions insert and remove an instance + * of an FTA from the active list. + */ + +gs_retval_t ftaexec_insert(struct FTA * after, struct FTA * new); +gs_retval_t ftaexec_remove(struct FTA * id); + +/* + * FTA's cannot be dynamically installed (since we currently don't + * have a run-time linker in the card). however, new parameterized + * instances of previously installed FTAs can be created. The FTA + * template IDs have to defined in an include file. the following + * call will result in a call to the FTA's alloc_fta function. + */ + +struct FTA * ftaexec_alloc_instance(gs_uint32_t index, struct FTA * reuse, + gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data); + + +/* + * the next two functions result in callouts to the corresponding FTA + * functions (fta_free, control_fta). + */ + +gs_retval_t ftaexec_free_instance(struct FTA * FTA_id, gs_uint32_t recursive); + +gs_retval_t ftaexec_control(struct FTA * FTA_id, gs_int32_t command, gs_int32_t sz, void * value); + +gs_retval_t ftaexec_process_control(gs_int32_t command, gs_int32_t sz, void * value); + +/* Start itteration through list of active FTA */ + +gs_retval_t ftaexec_start(); + +/* get one FTA at a time */ + +struct FTA * ftaexec_next(); + + +/* HFTA internal print function*/ + +gs_retval_t add_printfunction_to_stream(struct FTA * ftaid, gs_sp_t schema, gs_sp_t path, gs_sp_t basename, + gs_sp_t temporal_field, gs_sp_t split_field, gs_uint32_t delta, gs_uint32_t split); + +gs_retval_t print_stream(struct FTA * self, gs_int32_t sz, void *tuple); + + +#endif diff --git a/src/lib/gscphost/include/gscpipc.h b/src/lib/gscphost/include/gscpipc.h new file mode 100644 index 0000000..44b79ea --- /dev/null +++ b/src/lib/gscphost/include/gscpipc.h @@ -0,0 +1,142 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +/* + * gscpipc.h:: defines the interface of the IPC channels used in + * the GS-lite framework to communicate tuples between different + * processes + */ + +#ifndef GSCPIPC_H +#define GSCPIPC_H + +#include "gsconfig.h" +#include "gstypes.h" +#include "fta.h" + +#define RESERVED_FOR_LOW_LEVEL 0 + +#define FTACALLBACK 1 + +extern gs_uint64_t intupledrop; +extern gs_uint64_t outtupledrop; +extern gs_uint64_t intuple; +extern gs_uint64_t outtuple; +extern gs_uint64_t inbytes; +extern gs_uint64_t outbytes; +extern gs_uint64_t cycles; + + +/* shared ringbuffer data structure used */ + +#if defined(__sparc__) && defined(__sun__) +#define ALIGN64 +#endif + +struct tuple { + FTAID f; + gs_int32_t sz; + gs_uint32_t next; +#ifdef ALIGN64 + gs_uint32_t alignment; +#endif + gs_int8_t data[1]; +}__attribute__ ((__packed__)); + +struct ringbuf { + gs_uint32_t mqhint; + gs_uint32_t writer; + gs_uint32_t reader; + gs_uint32_t end; + gs_int32_t length; +#ifdef ALIGN64 + gs_uint32_t alignment; +#endif + FTAID srcid; + FTAID destid; + gs_int8_t start[1]; +}__attribute__ ((__packed__)); + +/* adds a buffer to the end of the sidequeue*/ +gs_retval_t sidequeue_append(FTAID ftaid, gs_sp_t buf, gs_int32_t length); + +/* removes a buffer from the top of the sidequeue*/ +gs_retval_t sidequeue_pop(FTAID * ftaid, gs_sp_t buf, gs_int32_t * length); + +/* + *used to contact the clearinghouse process returns the MSGID of + * the current process negative result indicates a problem + */ + +gs_retval_t gscpipc_init(gs_int32_t clearinghouse); + +/* used to disassociate process from clearinghouse */ +gs_retval_t gscpipc_free(); + +/* sends a message to a process */ +gs_retval_t gscpipc_send(FTAID f, gs_int32_t operation, gs_sp_t buf, gs_int32_t length, gs_int32_t block); + +/* retrieve a message buf has to be at least of size MAXMSGSZ returns 0 + if no message is available -1 on an error and 1 on sucess*/ +gs_retval_t gscpipc_read(FTAID * f, gs_int32_t * operation, gs_sp_t buf, gs_int32_t * lenght, gs_int32_t block); + +/* allocate a ringbuffer which allows receiving data from + * the other process returns 0 if didn't succeed. + * returns an existing buffer if it exists and increments the refcnt*/ + +struct ringbuf * gscpipc_createshm(FTAID f, gs_int32_t length); + +/* finds a ringbuffer to send which was allocated by + * gscpipc_creatshm and return 0 on an error */ + +struct ringbuf * gscpipc_getshm(FTAID f); + +/* frees shared memory to a particular proccess identified + * by ftaid if reference counter reaches 0 + */ +gs_retval_t gscpipc_freeshm(FTAID f); + + +/* returns true if on any sending ringbuffer the mqhint bit is true + * can be used in lfta rts to indicate that the message queue should + * be checked. + */ + +gs_retval_t gscpipc_mqhint(); + +/* Access macros for ringbuffer */ + +#ifdef ALIGN64 +#define UP64(x) ((((x)+7)/8)*8) +#else +#define UP64(x) x +#endif + +#define CURWRITE(buf) ((struct tuple *)(&((buf)->start[(buf)->writer]))) +#define ADVANCEWRITE(buf) CURWRITE(buf)->next=\ +((buf)->end > ((buf)->writer+UP64(CURWRITE(buf)->sz))+sizeof(struct tuple)-1)\ +? ((buf)->writer+UP64(CURWRITE(buf)->sz)+sizeof(struct tuple)-1) : 0; \ +(buf)->writer=CURWRITE(buf)->next; +#define CURREAD(buf) ((struct tuple *)(&((buf)->start[(buf)->reader]))) +#define ADVANCEREAD(buf) (buf)->reader=\ +CURREAD(buf)->next +#define UNREAD(buf) ((buf)->reader != (buf)->writer) +#define SPACETOWRITE(buf) ((((buf)->reader <= (buf)->writer) \ +&& ((buf)->reader+(buf)->end-(buf)->writer) > MAXTUPLESZ)\ +|| (((buf)->reader > (buf)->writer) && (((buf)->reader-(buf)->writer)>MAXTUPLESZ))) +#define HOWFULL(buf) (((((buf)->writer)-(buf)->reader)%((buf)->end)*1000)/((buf)->end)) +/* conservative estimate of how many tuples of size tuplesz fit in a ringbuffer */ +#define TUPLEFIT(buf,tuplesz) ((((((buf)->writer)-(buf)->reader)%((buf)->end))-MAXTUPLESZ)/ \ +((UP64(tuplesz))+sizeof(struct tuple)-1)) +#endif diff --git a/src/lib/gscphost/include/gscpmsgq.h b/src/lib/gscphost/include/gscpmsgq.h new file mode 100644 index 0000000..6d2be84 --- /dev/null +++ b/src/lib/gscphost/include/gscpmsgq.h @@ -0,0 +1,39 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +/* gscpmsgq.h defines the interface to a socket based message + * queue implementation for MacOSX which does not provide + * a System V message queueu but shared memory. + */ + +#ifndef GSCPMSGQ_H +#define GSCPMSGQ_H +#ifdef NOMSGQ + +#include <sys/types.h> +#include <sys/ipc.h> + +struct gscp_msgbuf { + long mtype; /* message type, must be > 0 */ + char mtext[1]; /* message data */ +}; + + +int gscp_msgget(key_t key, int msgflg); +ssize_t gscp_msgrcv(int msqid, struct gscp_msgbuf *msgp, size_t msgsz, long msgtyp, int msgflg); +int gscp_msgsnd(int msqid, struct gscp_msgbuf *msgp, size_t msgsz, int msgflg); + + +#endif +#endif diff --git a/src/lib/gscphost/include/ipcencoding.h b/src/lib/gscphost/include/ipcencoding.h new file mode 100644 index 0000000..822097f --- /dev/null +++ b/src/lib/gscphost/include/ipcencoding.h @@ -0,0 +1,188 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef IPCENCODING_H +#define IPCENCODING_H +#include "gsconfig.h" +#include "gstypes.h" + +#include <fta.h> +#include <systat.h> +#include <gscpipc.h> +#include <fta_stat.h> + + +#define FTA_LOOKUP 1 +#define FTA_ALLOC_INSTANCE 2 +#define FTA_ALLOC_PRINT_INSTANCE 3 +#define FTA_FREE_INSTANCE 4 +#define FTA_CONTROL 5 +#define FTA_PRODUCER_FAILURE 6 +#define FTA_HEARTBEAT 7 + +#define GSCP_GET_BUFFER 8 + +#define FTA_REGISTER 9 +#define FTA_UNREGISTER 10 + +#define PROCESS_CONTROL 11 + +#define RESULT_OPCODE_BASE 128 +#define STANDARD_RESULT 129 +#define FTAFIND_RESULT 130 +#define FTA_RESULT 131 + +/* the following result codes are ignored in standard + * processing they are only used when blocking for them + * directly + */ + +#define RESULT_OPCODE_IGNORE 256 +#define WAKEUP 266 +#define TIMEOUT 267 + +struct processtate { + gs_int32_t active; + gs_int32_t type; + gs_int32_t buffersize; + gs_int32_t deviceid; + gs_int32_t mapcnt; + gs_sp_t *map; +}; + +extern struct processtate curprocess; + +struct hostcall { + gs_int32_t callid; + gs_int32_t size; +}; + + +struct fta_find_arg { + struct hostcall h; + gs_int8_t name[MAXFTANAME]; + gs_uint32_t reuse; +}; + +struct fta_alloc_instance_arg { + struct hostcall h; + FTAID subscriber; + FTAID f; + gs_int8_t name[MAXFTANAME]; + gs_int8_t schema[MAXSCHEMASZ]; + gs_uint32_t reusable; + gs_int32_t command; + gs_int32_t sz; + gs_int8_t path[MAXPRINTSTRING]; + gs_int8_t basename[MAXPRINTSTRING]; + gs_int8_t temporal_field[MAXPRINTSTRING]; + gs_int8_t split_field[MAXPRINTSTRING]; + gs_uint32_t split; + gs_uint32_t delta; + gs_int8_t data[1]; +}; + +struct fta_free_instance_arg { + struct hostcall h; + FTAID subscriber; + FTAID f; + gs_uint32_t recursive; +}; + +struct fta_control_arg { + struct hostcall h; + FTAID subscriber; + FTAID f; + gs_int32_t command; + gs_int32_t sz; + gs_int8_t data[1]; +}; + + +struct fta_notify_producer_failure_arg { + struct hostcall h; + FTAID sender; + FTAID producer; +}; + +struct fta_heartbeat_arg { + struct hostcall h; + FTAID sender; + gs_uint64_t trace_id; + gs_int32_t sz; + fta_stat data[1]; +}; + +struct gscp_get_buffer_arg { + struct hostcall h; + gs_int32_t timeout; +}; + +struct fta_register_arg { + struct hostcall h; + gs_uint32_t reusable; + gs_int8_t name[MAXFTANAME]; + gs_int8_t schema[MAXSCHEMASZ]; + FTAID f; + FTAID subscriber; +}; + +struct fta_unregister_arg { + struct hostcall h; + FTAID f; + FTAID subscriber; +}; + +struct tuple_post_arg { + struct hostcall h; + gs_int32_t stream_id; + gs_int32_t sz; + void * tuple; +}; + +struct process_control_arg { + struct hostcall h; + gs_int32_t command; + gs_int32_t sz; + gs_int8_t data[1]; +}; + +struct standard_result { + struct hostcall h; + gs_int32_t result; +}; + +struct wakeup_result { + struct hostcall h; +}; + +struct timeout_result { + struct hostcall h; +}; + + +struct fta_result { + struct hostcall h; + gs_int32_t result; + FTAID f; +}; + +struct ftafind_result { + struct hostcall h; + gs_int32_t result; + FTAID f; + gs_int8_t schema[MAXSCHEMASZ]; +}; + +#endif diff --git a/src/lib/gscphost/include/lappregistries.h b/src/lib/gscphost/include/lappregistries.h new file mode 100644 index 0000000..db258d7 --- /dev/null +++ b/src/lib/gscphost/include/lappregistries.h @@ -0,0 +1,41 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#ifndef LAPPREGISTRIES_H +#define LAPPREGISTRIES_H +#include "gsconfig.h" +#include "gstypes.h" +#include <fta.h> +#include <gscpipc.h> + +/* adds the remote streamid with its associated msgid and ringbuf + */ +gs_retval_t streamregistry_add(FTAID f,struct ringbuf * r); + +/* removes streamid from registry for specific msgid */ +void streamregistry_remove(FTAID f); + +/* the following two functions are used to cycle + through all ringbuffers + */ +gs_retval_t streamregistry_getactiveringbuf_reset(); +struct ringbuf * streamregistry_getactiveringbuf(); + +/* the following two functions are used to cycle + through all msgids + */ +gs_retval_t streamregistry_getactiveftaid_reset(); +FTAID * streamregistry_getactiveftaid(); + +#endif diff --git a/src/lib/gscphost/lappinterface.c b/src/lib/gscphost/lappinterface.c new file mode 100644 index 0000000..99196b8 --- /dev/null +++ b/src/lib/gscphost/lappinterface.c @@ -0,0 +1,608 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <gscpipc.h> +#include <ipcencoding.h> +#include <stdlib.h> +#include <stdio.h> +#include <lapp.h> +#include <lappregistries.h> +#include <string.h> +#include <unistd.h> +#include <signal.h> +#include <sys/mman.h> +#include "rdtsc.h" +// If POLLING is defined applications poll every 100 msec instead of blocking +#define POLLING + +struct processtate curprocess = {0,0,0,255,0}; +struct FTAID clearinghouseftaid = {0,0,0,0}; + +/* + * sends the message passed in buf and waits for a result + * if a message returned is not a result it is put in the + * request queue. The resultsbuf has to be large enough + * for the largest result + */ +gs_retval_t ipc_call_and_wait(FTAID f, gs_sp_t msg, gs_sp_t result) +{ + struct hostcall * h = (struct hostcall *) msg; + gs_int8_t buf[MAXMSGSZ]; + FTAID from; + gs_int32_t length; + gs_int32_t lowop; +#ifdef PRINTMSG + fprintf(stderr, "HOST sending to %u.%u.%u.%u:%u of " + "type %u with length %u\n", + (f.ip>>24)&0xff, + (f.ip>>16)&0xff, + (f.ip>>8)&0xff, + (f.ip)&0xff, + f.port,h->callid,h->size); +#endif + if (gscpipc_send(f,FTACALLBACK,msg,h->size,1)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + return -1; + } + h=(struct hostcall *) buf; + while (gscpipc_read(&from,&lowop,buf,&length,1)>0) { +#ifdef PRINTMSG + fprintf(stderr, "HOST response from %u.%u.%u.%u:%u" + " of type %u with length %u\n", + (from.ip>>24)&0xff, + (from.ip>>16)&0xff, + (from.ip>>8)&0xff, + (from.ip)&0xff, + from.port, + h->callid,h->size); +#endif + if ((lowop == FTACALLBACK) && (h->callid < RESULT_OPCODE_IGNORE)) { + h=(struct hostcall *) buf; + if (h->callid > RESULT_OPCODE_BASE) { + memcpy(result,buf,length); + return 0; + } + if (sidequeue_append(from,buf,length)<0) { + gslog(LOG_EMERG,"ERROR:: Could not add to sidequeue\n"); + return -1; + } + } + } + gslog(LOG_EMERG, "ERROR::gscipc_read failed in ipc_call_and_wait\n"); + return -1; +} + + +gs_retval_t hostlib_init(gs_int32_t type, gs_int32_t buffersize, gs_int32_t deviceid, gs_int32_t mapcnt, gs_sp_t map[]) +{ + FILE * f; + + if (curprocess.active != 0 ) { + return -1; + } + + switch (type) { + case CLEARINGHOUSE: + if (gscpipc_init(1) < 0) { + gslog(LOG_EMERG,"ERROR:Could not initalize comm layer for " + "clearinghouse process\n"); + return -1; + } + break; + case LFTA: +#ifdef __linux__ + mlockall(MCL_CURRENT|MCL_FUTURE); +#endif + case APP: + case HFTA: + if (gscpipc_init(0) < 0) { + gslog(LOG_EMERG,"ERROR:Could not initalize comm layer for " + "non clearinghouse process\n"); + return -1; + } + break; + default: + gslog(LOG_EMERG,"ERROR:Unknown process type\n"); + return -1; + } + + // if the buffersize is zero then allocating shared memory + // will fail. So only use it for the clearinghouse and LFTAs + if ((buffersize<(4*MAXTUPLESZ)) && (buffersize!=0)) { + gslog(LOG_EMERG, + "ERROR:buffersize in hostlib_init has to " + "be at least %u Bytes long\n", + 4*MAXTUPLESZ); + return -1; + } + + curprocess.type=type; + curprocess.buffersize=buffersize; + curprocess.active = 1; + curprocess.deviceid=deviceid; + curprocess.mapcnt=mapcnt; + curprocess.map=map; + return 0; +} + +void hostlib_free() +{ + if (curprocess.active != 1 ) { + return; + } + curprocess.active = 0; + gscpipc_free(); +} + + +gs_retval_t fta_find(FTAname name, gs_uint32_t reuse, FTAID *ftaid, + gs_sp_t schema, gs_int32_t schemasz) +{ + gs_int8_t rb[MAXRES]; + struct fta_find_arg a; + struct ftafind_result * sr = (struct ftafind_result *)rb; + + a.h.callid = FTA_LOOKUP; + a.h.size = sizeof(struct fta_find_arg); + a.reuse=reuse; + if (strlen(name)>=(MAXFTANAME-1)) { + gslog(LOG_EMERG,"ERROR:FTA name (%s) to large\n",name); + return -1; + } + strcpy(a.name,name); + ipc_call_and_wait(clearinghouseftaid,(gs_sp_t )&a,rb); + if (sr->h.callid != FTAFIND_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received in fta_find\n"); + return -1; + } + if (sr->result >= 0) { + if (schema !=0) { + if (strlen(sr->schema) >= schemasz) { + gslog(LOG_EMERG,"Could not fit schema into schema buffer fta_find\n"); + return -1; + } else { + strcpy(schema,sr->schema); + } + } + *ftaid=sr->f; + } + return sr->result; +} + +gs_retval_t fta_alloc_instance(FTAID subscriber, + FTAID * ftaid, FTAname name, gs_sp_t schema, + gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data) +{ + gs_int8_t rb[MAXRES]; + struct fta_alloc_instance_arg * a; + struct fta_result * fr = (struct fta_result *)rb; + struct ringbuf *r; + + /* make sure we have the share memory required */ + if ((r=gscpipc_createshm(*ftaid,curprocess.buffersize))==0) { + gslog(LOG_EMERG,"ERROR:could not allocate shared memory" + "for FTA %s\n",name); + return -1; + } + + if (strlen(name)>=(MAXFTANAME-1)) { + gslog(LOG_EMERG,"ERROR:FTA name (%s) to large\n",name); + return -1; + } + + if (strlen(schema)>=(MAXSCHEMASZ-1)) { + gslog(LOG_EMERG,"ERROR:FTA name (%s) to large\n",name); + return -1; + } + + a = alloca(sizeof(struct fta_alloc_instance_arg) + sz); + + a->h.callid = FTA_ALLOC_INSTANCE; + a->h.size = sizeof(struct fta_alloc_instance_arg)+ sz; + a->f=*ftaid; + a->subscriber=subscriber; + a->reusable=reusable; + a->command = command; + a->sz = sz; + memcpy(&a->data[0],data,sz); + strcpy(a->name,name); + strcpy(a->schema,schema); + + ipc_call_and_wait(*ftaid,(gs_sp_t )a,rb); + + if (fr->h.callid != FTA_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + + *ftaid=fr->f; + + if (fr->result==0) { + gslog(LOG_INFO,"Allocated fta instance %s with FTAID {ip=%u,port=%u,index=%u,streamid=%u}\n",name,ftaid->ip,ftaid->port,ftaid->index,ftaid->streamid); + return streamregistry_add(*ftaid,r); + } + + return fr->result; +} + +gs_retval_t fta_alloc_print_instance(FTAID subscriber, + FTAID * ftaid, + FTAname name, gs_sp_t schema, gs_uint32_t reusable, + gs_int32_t command, gs_int32_t sz, void * data, + gs_sp_t path,gs_sp_t basename, + gs_sp_t temporal_field, gs_sp_t split_field, + gs_uint32_t delta, gs_uint32_t split) +{ + gs_int8_t rb[MAXRES]; + struct fta_alloc_instance_arg * a; + struct fta_result * fr = (struct fta_result *)rb; + + if ((strlen(path)>=MAXPRINTSTRING-1) + || (strlen(basename)>=MAXPRINTSTRING-1) + || (strlen(temporal_field)>=MAXPRINTSTRING-1)) { + gslog(LOG_EMERG,"INTERNAL ERROR:fta_alloc_print_instance string" + " arguments to long\n"); + return -1; + } + if (strlen(name)>=(MAXFTANAME-1)) { + gslog(LOG_EMERG,"ERROR:FTA name (%s) to large\n",name); + return -1; + } + + if (strlen(schema)>=(MAXSCHEMASZ-1)) { + gslog(LOG_EMERG,"ERROR:FTA name (%s) to large\n",name); + return -1; + } + + a = alloca(sizeof(struct fta_alloc_instance_arg) + sz); + + a->h.callid = FTA_ALLOC_PRINT_INSTANCE; + a->h.size = sizeof(struct fta_alloc_instance_arg)+ sz; + a->f=*ftaid; + a->subscriber=subscriber; + a->reusable=reusable; + a->split=split; + strcpy(a->name,name); + strcpy(a->schema,schema); + a->command = command; + a->sz = sz; + strcpy(a->path,path); + strcpy(a->basename,basename); + strcpy(a->temporal_field,temporal_field); + strcpy(a->split_field,split_field); + a->delta=delta; + memcpy(&a->data[0],data,sz); + + ipc_call_and_wait(*ftaid,(gs_sp_t )a,rb); + + if (fr->h.callid != FTA_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + + *ftaid=fr->f; + + return fr->result; +} + +gs_retval_t fta_free_instance(FTAID subscriber, FTAID ftaid, gs_uint32_t recursive) +{ + gs_int8_t rb[MAXRES]; + struct fta_free_instance_arg a; + struct standard_result * sr = (struct standard_result *)rb; + struct ringbuf *r; + + a.h.callid = FTA_FREE_INSTANCE; + a.h.size = sizeof(struct fta_free_instance_arg); + a.subscriber=subscriber; + a.f=ftaid; + a.recursive=recursive; + ipc_call_and_wait(ftaid,(gs_sp_t )&a,rb); + if (sr->h.callid != STANDARD_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + + /* make sure we remove the mapping*/ + streamregistry_remove(ftaid); + + return sr->result; +} + +gs_retval_t fta_control(FTAID subscriber, + FTAID ftaid, gs_int32_t command, gs_int32_t sz, void * value) +{ + gs_int8_t rb[MAXRES]; + struct fta_control_arg * a; + struct standard_result * sr = (struct standard_result *)rb; + + a = alloca(sizeof(struct fta_control_arg) + sz); + + a->h.callid = FTA_CONTROL; + a->h.size = sizeof(struct fta_control_arg)+ sz; + a->subscriber=subscriber; + a->f=ftaid; + a->command = command; + a->sz = sz; + memcpy(&a->data[0],value,sz); + + ipc_call_and_wait(ftaid,(gs_sp_t )a,rb); + + if (sr->h.callid != STANDARD_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + + return sr->result; +} + +gs_retval_t fta_heartbeat(FTAID self,gs_uint64_t trace_id, + gs_uint32_t sz, fta_stat * trace){ +#ifdef CLEARINGHOUSE_HEARTBEAT + struct fta_heartbeat_arg * a; + a = alloca(sizeof(struct fta_heartbeat_arg) + (sz*sizeof(fta_stat))); + a->h.callid = FTA_HEARTBEAT; + a->h.size = sizeof(struct fta_heartbeat_arg)+(sz*sizeof(fta_stat)); + a->sender=self; + a->trace_id=trace_id; + a->sz=sz; + if (sz!=0) { + memcpy(&a->data[0],trace,(sz*sizeof(fta_stat))); + } +#ifdef PRINTMSG + fprintf(stderr, "HOST sending heartbeat to %u.%u.%u.%u:%u of " + "type %u with length %u\n", + (clearinghouseftaid.ip>>24)&0xff, + (clearinghouseftaid.ip>>16)&0xff, + (clearinghouseftaid.ip>>8)&0xff, + (clearinghouseftaid.ip)&0xff, + clearinghouseftaid.port,a->h.callid,a->h.size); +#endif + if (gscpipc_send(clearinghouseftaid,FTACALLBACK,(gs_sp_t)a,a->h.size,1)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + return -1; + } +#endif + return 0; +} + +gs_retval_t fta_notify_producer_failure(FTAID self, FTAID producer){ + struct fta_notify_producer_failure_arg a; + a.h.callid = FTA_PRODUCER_FAILURE; + a.h.size = sizeof(struct fta_notify_producer_failure_arg); + a.sender=self; + a.producer=producer; +#ifdef PRINTMSG + fprintf(stderr, "HOST sending producer failure to %u.%u.%u.%u:%u of " + "type %u with length %u\n", + (clearinghouseftaid.ip>>24)&0xff, + (clearinghouseftaid.ip>>16)&0xff, + (clearinghouseftaid.ip>>8)&0xff, + (clearinghouseftaid.ip)&0xff, + clearinghouseftaid.port,a.h.callid,a.h.size); +#endif + if (gscpipc_send(clearinghouseftaid,FTACALLBACK,(gs_sp_t)&a,a.h.size,1)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + return -1; + } + return 0; +} + +gs_retval_t process_control(FTAID ftaid, gs_int32_t command, gs_int32_t sz, void * value) +{ + gs_int8_t rb[MAXRES]; + struct process_control_arg * a; + struct standard_result * sr = (struct standard_result *)rb; + + + a = alloca(sizeof(struct process_control_arg) + sz); + + a->h.callid = PROCESS_CONTROL; + a->h.size = sizeof(struct process_control_arg)+ sz; + a->command = command; + a->sz = sz; + memcpy(&a->data[0],value,sz); + + ipc_call_and_wait(ftaid,(gs_sp_t )a,rb); + + if (sr->h.callid != STANDARD_RESULT) { + gslog(LOG_EMERG,"ERROR:Wrong result code received\n"); + return -1; + } + + return sr->result; +} + + +static void timeouthandler () +{ + struct timeout_result a; + + a.h.callid=TIMEOUT; + a.h.size=sizeof(struct timeout_result); + if (gscpipc_send(gscpipc_getftaid(), FTACALLBACK, (gs_sp_t )&a,a.h.size,1)<0) { + gslog(LOG_EMERG,"ERROR:Could not send on message queue\n"); + } +} + +gs_retval_t gscp_get_buffer(FTAID * ftaid, gs_int32_t * size, void *tbuffer, + gs_int32_t tbuf_size, gs_int32_t timeout) +{ + struct ringbuf * r; + FTAID from; + gs_int32_t length; + gs_int8_t buf[MAXMSGSZ]; + gs_int32_t lopp; + FTAID * f; + static gs_uint64_t s1=0; + static gs_uint64_t s2; + if (s1==0) { + s1=rdtsc(); + } + s2=rdtsc(); + cycles+=(s2-s1); +start: +#ifdef PRINTMSG + fprintf(stderr,"CHECK RINGBUFS\n"); +#endif +#ifndef POLLING + /* use chance to cleanout message queue no reason + to keep anything else */ + while (gscpipc_read(&from,&lopp,buf,&length,0)>0); +#endif + + streamregistry_getactiveringbuf_reset(); + while ((r=streamregistry_getactiveringbuf())>0) { +#ifdef PRINTMSG + fprintf(stderr,"Reading from ringpuffer %p [%p:%u]" + "(%u %u %u) \n",r,&r->start,r->end,r->reader,r->writer, + r->length); + if (UNREAD(r)) { + fprintf(stderr,"\t%u %u.%u.%u.%u:%u-%p %u\n",CURREAD(r)->next, + (CURREAD(r)->f.ip>>24)&0xff, + (CURREAD(r)->f.ip>>16)&0xff, + (CURREAD(r)->f.ip>>8)&0xff, + (CURREAD(r)->f.ip)&0xff, + CURREAD(r)->f.port, + CURREAD(r)->f.streamid, + CURREAD(r)->sz); + } + +#endif + if (UNREAD(r)) { + *ftaid=(CURREAD(r)->f); + *size=CURREAD(r)->sz; + memcpy(tbuffer,&(CURREAD(r)->data[0]),(tbuf_size>(*size))?(*size):tbuf_size); + intuple++; + inbytes+=CURREAD(r)->sz; + ADVANCEREAD(r); + s1=rdtsc(); + return 0; + } + } + if (timeout == -1) { + *size=0; + s1=rdtsc(); + return 1; + } + if (timeout !=0) { + signal(SIGALRM, timeouthandler); + alarm(timeout); + } + +#ifndef POLLING +#ifdef PRINTMSG + fprintf(stderr,"START BLOCKCALLS\n"); +#endif + streamregistry_getactiveftaid_reset(); + while ((f=streamregistry_getactiveftaid())!=0) { + struct gscp_get_buffer_arg a; + a.h.callid = GSCP_GET_BUFFER; + a.h.size = sizeof(struct gscp_get_buffer_arg); + a.timeout = timeout; +#ifdef PRINTMSG + fprintf(stderr,"Waiting for %u.%u.%u.%u:%u\n", + (f->ip>>24)&0xff, + (f->ip>>16)&0xff, + (f->ip>>8)&0xff, + (f->ip)&0xff, + f->port + ); +#endif + if (gscpipc_send(*f,FTACALLBACK,(gs_sp_t )&a,a.h.size,1)<0) { + s1=rdtsc(); + return -1; + } + } +#ifdef PRINTMSG + fprintf(stderr,"BLOCK\n"); +#endif + while (gscpipc_read(&from,&lopp,buf,&length,1)>0) { +#else // If we poll we return after 100 msec + sleepagain: + while (gscpipc_read(&from,&lopp,buf,&length,2)>0) { +#endif + struct standard_result * sr = (struct standard_result *) buf; +#ifdef PRINTMSG + fprintf(stderr,"Got return code %u\n",sr->h.callid); +#endif + if (lopp==FTACALLBACK) { + if (timeout != 0) { + signal(SIGALRM, SIG_IGN); + } + if (sr->h.callid == WAKEUP) { + /* use chance to cleanout message queue no reason + to keep anything else */ + while (gscpipc_read(&from,&lopp,buf,&length,0)>0); + goto start; + } + if (sr->h.callid == TIMEOUT) { + /* use chance to cleanout message queue no reason + to keep anything else */ + while (gscpipc_read(&from,&lopp,buf,&length,0)>0); + *size=0; + s1=rdtsc(); + return 1; + } + if (sidequeue_append(from,buf,length)<0) { + gslog(LOG_EMERG,"ERROR:: Could not add to sidequeue\n"); + s1=rdtsc(); + return -1; + } + } + } +#ifdef POLLING + streamregistry_getactiveringbuf_reset(); + while ((r=streamregistry_getactiveringbuf())>0) { +#ifdef PRINTMSG + fprintf(stderr,"Reading from ringpuffer %p [%p:%u]" + "(%u %u %u) \n",r,&r->start,r->end,r->reader,r->writer, + r->length); + if (UNREAD(r)) { + fprintf(stderr,"\t%u %u.%u.%u.%u:%u-%p %u\n",CURREAD(r)->next, + (CURREAD(r)->f.ip>>24)&0xff, + (CURREAD(r)->f.ip>>16)&0xff, + (CURREAD(r)->f.ip>>8)&0xff, + (CURREAD(r)->f.ip)&0xff, + CURREAD(r)->f.port, + CURREAD(r)->f.streamid, + CURREAD(r)->sz); + } + +#endif + if (UNREAD(r)) { + *ftaid=(CURREAD(r)->f); + *size=CURREAD(r)->sz; + memcpy(tbuffer,&(CURREAD(r)->data[0]),(tbuf_size>(*size))?(*size):tbuf_size); + intuple++; + inbytes+=CURREAD(r)->sz; + ADVANCEREAD(r); + if (timeout != 0) { + signal(SIGALRM, SIG_IGN); + } + s1=rdtsc(); + return 0; + } + } + goto sleepagain; // Try again +#endif + gslog(LOG_EMERG,"Unexpected code reached in: gscp_get_buffer \n"); + /* we should never get here */ + s1=rdtsc(); + return -1; + } + + + diff --git a/src/lib/gscphost/lappregistries.c b/src/lib/gscphost/lappregistries.c new file mode 100644 index 0000000..0ef78bd --- /dev/null +++ b/src/lib/gscphost/lappregistries.c @@ -0,0 +1,159 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include <lappregistries.h> +#include <stdio.h> +#include <stdlib.h> + +/* datastructure to keep track of streamids used by the lapp */ +struct streamregistry { + gs_int32_t used; + FTAID ftaid; + struct ringbuf * r; +}; + +struct streamregistry * sreg =0; +gs_int32_t lsreg=0; + +struct ringbuf ** rbr=0; +gs_int32_t lrbr=0; + +FTAID ** rms=0; +gs_int32_t lrms=0; + +/* adds the remote streamid with its associated msgid and ringbuf + */ +gs_retval_t streamregistry_add(FTAID ftaid,struct ringbuf * r) +{ + gs_int32_t x; + if (lsreg == 0) { + if ((sreg = malloc(sizeof(struct streamregistry)*STARTSZ))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory streanregistry\n"); + return -1; + } + memset(sreg,0,sizeof(struct streamregistry)*STARTSZ); + lsreg = STARTSZ; + } + for(x=0;(x<lsreg)&&(sreg[x].used!=0);x++); + if (x == lsreg) { + gs_int32_t y; + lsreg = 2*lsreg; + if ((sreg = realloc(sreg,lsreg*sizeof(struct streamregistry)))==0) { + gslog(LOG_EMERG,"ERROR:Out of memory streamregistry\n"); + return -1; + } + for (y=x;y<lsreg;y++) + sreg[y].used=0; + } + sreg[x].ftaid=ftaid; + sreg[x].r=r; + sreg[x].used=1; + return 0; +} + +/* removes streamid from registry for specific msgid and ringbuf */ +void streamregistry_remove(FTAID ftaid) +{ + gs_int32_t x; + for(x=0;x<lsreg;x++) { + if ((sreg[x].ftaid.ip==ftaid.ip) + && (sreg[x].ftaid.port==ftaid.port) + && (sreg[x].ftaid.index==ftaid.index) + && (sreg[x].ftaid.streamid==ftaid.streamid)) { + sreg[x].used=0; + } + } + return; +} + + + +/* the following two functions are used to cycle + through all ringbuffers + */ +gs_retval_t streamregistry_getactiveringbuf_reset() +{ + gs_int32_t x,y; + /* XXXOS this is not the most effective way of doing + this needs improvment. */ + /* Build a list of all ringbufs make sure they + are unique since multiple entrys could share + a ringbuf + */ + if (rbr!=0) (free(rbr)); + if ((rbr=malloc(sizeof(struct ringbuf *)*lsreg))==0) { + gslog(LOG_EMERG,"Can't allocate memory in ftaregistry\n"); + return -1; + } + memset(rbr,0,sizeof(struct ringbuf *)*lsreg); + lrbr=0; + for(x=0;x<lsreg;x++) { + if (sreg[x].used) { + for(y=0;(y<lrbr)&&(rbr[y]!=sreg[x].r);y++); + if (y>=lrbr) { + rbr[y]=sreg[x].r; + lrbr++; + } + } + } + return 0; +} + +struct ringbuf * streamregistry_getactiveringbuf() +{ + if (lrbr>0) { + lrbr --; + return rbr[lrbr]; + } + return 0; +} + + +gs_retval_t streamregistry_getactiveftaid_reset() +{ + gs_int32_t x,y; + /* XXXOS this is not the most effective way of doing + this needs improvment. */ + /* Build a list of at least one ftaid per process + */ + if (rms!=0) (free(rms)); + if ((rms=malloc(sizeof(FTAID *)*lsreg))==0) { + gslog(LOG_EMERG,"Can't allocate memory in ftaregistry\n"); + return -1; + } + memset(rms,0,sizeof(gs_int32_t *)*lsreg); + lrms=0; + for(x=0;x<lsreg;x++) { + if (sreg[x].used) { + for(y=0;(y<lrms) + &&(rms[y]->ip!=sreg[x].ftaid.ip) + &&(rms[y]->port!=sreg[x].ftaid.port);y++); + if (y>=lrms) { + rms[y]=&(sreg[x].ftaid); + lrms++; + } + } + } + return 0; +} + +FTAID * streamregistry_getactiveftaid() +{ + if (lrms>0) { + lrms --; + return rms[lrms]; + } + return 0; +} diff --git a/src/lib/gscphost/lfta.c b/src/lib/gscphost/lfta.c new file mode 100644 index 0000000..d32232a --- /dev/null +++ b/src/lib/gscphost/lfta.c @@ -0,0 +1,72 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <gsconfig.h> +#include <fta.h> +#include <callbackregistries.h> +#include <ipcencoding.h> +#include <stdio.h> +#include "rdtsc.h" +#include "packet.h" +#include "gscpipc.h" + +// new +//gs_uint64_t lfta_prefilter(struct packet * p); +extern gs_uint64_t (*lfta_prefilter)(void *pkt); + +struct pr_stats { + gs_uint64_t process; + gs_uint64_t packets; +}; + +void rts_fta_process_packet(struct packet * p) +{ + struct FTA * f; + gs_uint64_t prefilter; + static gs_uint32_t t=0; + static struct pr_stats s = {0}; + gs_uint64_t s1; + gs_uint64_t s2; + prefilter=(*lfta_prefilter)(p); + + if (ftaexec_start()<0) { + gslog(LOG_EMERG,"GSCPRTS::error::could not init " + "FTA list itteration\n"); + return; + } + s1=rdtsc(); + while ((f=ftaexec_next())!=0) { + // fprintf(stderr,"%llu %llu %llu\n",f->prefilter,prefilter,~( (prefilter&(f->prefilter)) | (~(f->prefilter)) )); + if (~( (prefilter&(f->prefilter)) | (~(f->prefilter)) ) == 0) + f->accept_packet(f,0,p,0); + } + s2=rdtsc(); + s.process+=(s2-s1); + s.packets++; + intuple++; + cycles+=(s2-s1); +} + +void rts_fta_done() +{ + struct FTA * f; + if (ftaexec_start()<0) { + gslog(LOG_EMERG,"GSCPRTS::error::could not init " + "FTA list itteration\n"); + return; + } + while ((f=ftaexec_next())!=0) { + f->control_fta(f,FTA_COMMAND_FILE_DONE,0,0); + } +} diff --git a/src/lib/gscphostaux/Makefile b/src/lib/gscphostaux/Makefile new file mode 100644 index 0000000..c2dbc03 --- /dev/null +++ b/src/lib/gscphostaux/Makefile @@ -0,0 +1,38 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CC=gcc -O3 -fexpensive-optimizations -I ../../../include + +SOURCE = byteswap.c + +OBJECTS = $(SOURCE:.c=.o) + +all: install + +install: libgscphostaux.a + cp libgscphostaux.a ../../../lib ; ranlib ../../../lib/libgscphostaux.a + +INCDIR=../../../include + +byteswap.c : $(INCDIR/gstypes.h) $(INCDIR/gsconfig.h) + +libgscphostaux.a: $(OBJECTS) Makefile + ar rc libgscphostaux.a $(OBJECTS) + +clean: + rm -f *.o *.a core + + +$(OBJECTS): diff --git a/src/lib/gscphostaux/byteswap.c b/src/lib/gscphostaux/byteswap.c new file mode 100644 index 0000000..af016fc --- /dev/null +++ b/src/lib/gscphostaux/byteswap.c @@ -0,0 +1,40 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include "gsconfig.h" +#include "gstypes.h" + +gs_uint16_t gscpbswap16(gs_uint16_t x){ + return ((x << 8) & 0xff00) | ((x >> 8) & 0x00ff); +} + +gs_uint32_t gscpbswap32(gs_uint32_t x ) { + return ((x << 24) & 0xff000000 ) | + ((x << 8) & 0x00ff0000 ) | + ((x >> 8) & 0x0000ff00 ) | + ((x >> 24) & 0x000000ff ); +} + + +gs_uint64_t gscpbswap64(gs_uint64_t x) { + gs_uint64_t t1; + gs_uint64_t t2; + t1=x>>32; + t1 = gscpbswap32(t1); + t2=x & 0xffffffff; + t2 = gscpbswap32(t2); + x = t2<<32; + x = x|t1; + return x; +} diff --git a/src/lib/gscplftaaux/Makefile b/src/lib/gscplftaaux/Makefile new file mode 100644 index 0000000..3ce94ef --- /dev/null +++ b/src/lib/gscplftaaux/Makefile @@ -0,0 +1,48 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CC=gcc -g -O3 -fexpensive-optimizations -I ../gscpaux/acl/ -I ../gscpaux/ -I ../../../include/lfta/ -I ../../../include/ + +SOURCE = rts_string.c rts_byteswap.c rts_sample.c rts_udaf.c + +OBJECTS = $(SOURCE:.c=.o) + +INCDIR=../../../include +HFTA_DIR=$(INCDIR/hfta) +LFTA_DIR=$(INCDIR/lfta) + +all: libgscplftaaux.a + cp libgscplftaaux.a ../../../lib/ ; ranlib ../../../lib/libgscplftaaux.a + +libgscplftaaux.a: $(OBJECTS) Makefile + ar rc libgscplftaaux.a $(OBJECTS) + +rts_string.c : $(LFTA_DIR/rts_external.h) $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +rts_byteswap.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +rts_sample.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(LFTA_DIR/rts_external.h) + +rts_udaf.c : $(LFTA_DIR/rts_udaf.h) $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +lpm.c : $(LFTA_DIR/rts_external.h) $(INCDIR/fta.h) $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +flip_udaf.c : $(LFTA_DIR/rts_udaf.h) $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +install: all + +clean: + rm -f *.o *.a core + diff --git a/src/lib/gscplftaaux/rts_byteswap.c b/src/lib/gscplftaaux/rts_byteswap.c new file mode 100644 index 0000000..cae7ea2 --- /dev/null +++ b/src/lib/gscplftaaux/rts_byteswap.c @@ -0,0 +1,42 @@ +#include "gsconfig.h" +#include "gstypes.h" + +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +gs_int16_t gscpbswap16(gs_int16_t x){ + return ((x << 8) & 0xff00) | ((x >> 8) & 0x00ff); +} + +gs_int32_t gscpbswap32(gs_int32_t x ) { + return ((x << 24) & 0xff000000 ) | + ((x << 8) & 0x00ff0000 ) | + ((x >> 8) & 0x0000ff00 ) | + ((x >> 24) & 0x000000ff ); +} + + +gs_int64_t gscpbswap64(gs_int64_t x) { + gs_uint64_t t1; + gs_uint64_t t2; + t1=x>>32; + t1 = gscpbswap32(t1); + t2=x & 0xffffffff; + t2 = gscpbswap32(t2); + x = t2<<32; + x = x|t1; + return x; +} diff --git a/src/lib/gscplftaaux/rts_options.c b/src/lib/gscplftaaux/rts_options.c new file mode 100644 index 0000000..44a0ed9 --- /dev/null +++ b/src/lib/gscplftaaux/rts_options.c @@ -0,0 +1,58 @@ +#include "md_stdlib.h" +#include "gsconfig.h" +#include "gstypes.h" +#include "rts_external.h" + +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +gs_retval_t has_ipv4_option( struct gs_string * s, gs_uint32_t ipoption) { + gs_int32_t x=0; + gs_int32_t on; + gs_int32_t len; + + if (s->length==0) return 0; /* no match */ + + while(0==0) { + if ((on=s->data[x]&0x1f)==ipoption) return 1; /* got a match */ + switch (on) { + case 0: + return 0; /* no match and end of list */ + case 1: + x++; /* one byte options */ + break; + case 2: /* 11 byte security option */ + x+=11; + break; + case 8: + x+=4; /* stream id option */ + break; + case 3: + case 9: + case 7: + case 4: + if (x+1>=s->length) return 0; /* run out of data no match */ + len=s->data[x+1]; + x+=len; + break; + default: + return 0; /* don't undestand the option */ + } + if (x>=s->length) return 0; /* run out of data no match */ + } + + return 0; /* should never be reached */ +} diff --git a/src/lib/gscplftaaux/rts_sample.c b/src/lib/gscplftaaux/rts_sample.c new file mode 100644 index 0000000..61c051e --- /dev/null +++ b/src/lib/gscplftaaux/rts_sample.c @@ -0,0 +1,44 @@ +#include "gsconfig.h" +#include "gstypes.h" +#include "rts_external.h" + +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +//#define FILTERDEBUG 100000 +#ifdef FILTERDEBUG +#include "stdio.h" +#include "stdlib.h" +#endif + +#define OFFSET 17 +#define PRIME 2997913 + + +static gs_uint32_t rval; + +#define MAX_TRIGGER 16 + + +void set_seed(gs_uint32_t s){rval=s;} + +gs_uint32_t lc_rand(){ + rval = (rval+OFFSET)*PRIME; + return(rval & 0xffffffff); +} + + + diff --git a/src/lib/gscplftaaux/rts_string.c b/src/lib/gscplftaaux/rts_string.c new file mode 100644 index 0000000..8c31657 --- /dev/null +++ b/src/lib/gscplftaaux/rts_string.c @@ -0,0 +1,367 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "rts_external.h" +#include <stdio.h> +#include <regex.h> +#include "gsconfig.h" +#include "gstypes.h" + + +#include "stdlib.h" + + +gs_retval_t str_assign_with_copy(struct FTA * f, struct gs_string * dest, struct gs_string * src) +{ + if ((dest->data = fta_alloc(f,src->length))==0) { + return -1; + } + dest->length=src->length; + dest->owner=f; + memcpy(dest->data,src->data,src->length); + return 0; +} + +gs_retval_t str_assign_with_copy_in_tuple(struct string32 * dest, struct gs_string * src, + gs_sp_t start, gs_sp_t buf) +{ + gs_uint32_t st; + st=(unsigned int)(buf-start); +// dest->length=htonl(src->length); +// dest->reserved=htonl(0); +// dest->offset=htonl(st); + dest->length=src->length; + dest->reserved=0; + dest->offset=st; + memcpy(buf,src->data,src->length); + return 0; +} + + + +gs_retval_t str_replace( struct FTA * f, struct gs_string * dest, struct gs_string * src ) +{ + str_destroy(dest); + return str_assign_with_copy(f, dest, src); +} + +/* Searching within a string */ + + +gs_retval_t str_exists_substr( struct gs_string * s1, struct gs_string * s2) +{ + register gs_uint8_t * st1 = (gs_uint8_t *)(s1->data); + register gs_uint8_t * st2 = (gs_uint8_t *)(s2->data); + register gs_uint8_t s2f=st2[0]; + register gs_int32_t len1 = s1->length-s2->length; /* the lates point I have to find + a match of the first char */ + register gs_int32_t len2 = s2->length; + register gs_int32_t x,y; + + + for (x=0; x<len1 ; x++) + { + if (st1[x]==s2f) { + for (y=0; y<len2 && st1[x+y]==st2[y];y++); + if (y==len2) { + return 1; + } + } + } + return 0; +} + + +gs_uint32_t str_match_offset( gs_uint32_t offset, struct gs_string * s1, struct gs_string * s2) { + register gs_uint8_t * st1 = (gs_uint8_t *)(s1->data); + register gs_uint8_t * st2 = (gs_uint8_t *)(&s2->data[offset]); + register gs_int32_t x; + register gs_int32_t len2 = s2->length-offset; + register gs_int32_t len1 = s1->length; + if (len2<len1) return 0; + for(x=0; x<len1; x++) { + if (st1[x]!=st2[x]) return 0; + } + return 1; +} + + +gs_uint32_t byte_match_offset( gs_uint32_t offset, gs_uint32_t val, struct gs_string * s2) { + register gs_uint8_t * st2 = (gs_uint8_t *)(s2->data); + register gs_uint8_t v = (unsigned char) val; +// if ((s2->length <= offset)||(offset<0)) return 0; + if (s2->length <= offset) return 0; + return (st2[offset]==v)?1:0; +} + + +gs_retval_t str_compare( struct gs_string * str1, struct gs_string * str2) +{ + gs_int32_t len; + gs_int32_t x; + len = (str1->length>str2->length)?str2->length:str1->length; + for(x=0;x<len;x++) { + if (str1->data[x]>str2->data[x]) { + return 1; + } + if (str1->data[x]<str2->data[x]) { + return -1; + } + } + + if (str1->length>str2->length) { + return 1; + } + if (str2->length>str1->length) { + return -1; + } + return 0; +} + +gs_retval_t str_constructor(struct gs_string *s, gs_sp_t l){ + s->data = l; + s->length = 0; + while(l[s->length] != '\0') s->length++; + s->owner = NULL; + return(0); +} + + +gs_param_handle_t register_handle_for_str_regex_match_slot_1(struct FTA * f, + struct gs_string* pattern) { + regex_t * reg; + if ((reg=(regex_t *) fta_alloc(0,sizeof(regex_t)))==0) { + return 0; + } + if (regcomp(reg,(gs_sp_t)(pattern->data), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) { + return 0; + } + return (gs_param_handle_t) reg; +} + +gs_uint32_t str_regex_match(struct gs_string* str, gs_param_handle_t pattern_handle) { + regex_t * reg = (regex_t *) pattern_handle ; + gs_sp_t source = (gs_sp_t)(str->data); + int res; + static gs_sp_t d=0; + static gs_uint32_t dlen=0; + // grow our static buffer to the longest string we ever see + if ((str->length+1) >= dlen) { + if (d!=0) fta_free(0,(void*)d); + dlen=0; + d=0; + if ((d=(gs_sp_t)fta_alloc(0,str->length+1))==0) return 0; + dlen=str->length+1; + } + + if (str->length==0) return 0; + + // copy the string and 0 terminate it + memcpy((void *)d,(void *) str->data, str->length); + d[str->length]=0; + + res = REG_NOMATCH; + res = regexec(reg, d, 0, NULL, 0); + return (res==REG_NOMATCH)?0:1; +} + + +gs_retval_t deregister_handle_for_str_regex_match_slot_1(gs_param_handle_t handle) { + regex_t * x = (regex_t *) handle; + regfree(x); + if (x!=0) fta_free(0,(void *)x); + return 0; +} + +gs_param_handle_t register_handle_for_str_partial_regex_match_slot_1(struct FTA * f, + struct gs_string* pattern) { + regex_t * reg; + if ((reg=(regex_t *) fta_alloc(0,sizeof(regex_t)))==0) { + return 0; + } + if (regcomp(reg,(gs_sp_t)(pattern->data), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) { + return 0; + } + return (gs_param_handle_t) reg; +} + +gs_uint32_t str_partial_regex_match(struct gs_string* str, + gs_param_handle_t pattern_handle, + gs_uint32_t maxlen) { + regex_t * reg = (regex_t *) pattern_handle ; + gs_sp_t source = (gs_sp_t)(str->data); + gs_int32_t res; + gs_int32_t end; + static gs_sp_t d=0; + static gs_uint32_t dlen=0; + // grow our static buffer to the longest string we ever see + if ((str->length+1) >= dlen) { + if (d!=0) fta_free(0,d); + dlen=0; + d=0; + if ((d=(gs_sp_t)fta_alloc(0,str->length+1))==0) return 0; + dlen=str->length+1; + } + + if (str->length==0) return 0; + + end=(maxlen>(str->length))?(str->length):maxlen; + + // copy the string and 0 terminate it + memcpy((void *)d,(void *) str->data, end); + d[str->length]=0; + + /* HACK ALERT: commented out regnexec invocations to unbreak the build */ + res = REG_NOMATCH; + res = regexec(reg,d, 0, NULL, 0); + return (res==REG_NOMATCH)?0:1; +} + + +gs_retval_t deregister_handle_for_str_partial_regex_match_slot_1( + gs_param_handle_t handle) { + regex_t * x = (regex_t *) handle; + regfree(x); + if (x!=0) fta_free(0,(void *)x); + return 0; +} + + + +static gs_uint32_t nextint(struct gs_string *str , gs_uint32_t * offset, gs_uint32_t *res) { + gs_uint8_t * s = (gs_uint8_t *)(str->data); + gs_int32_t v = 0; + *res = 0; + while(*offset<str->length) { + if ((s[*offset]>='0') && (s[*offset]<='9')) { + v=1; + *res= (*res*10) + (gs_uint32_t) (s[*offset]-'0'); + } else { + if (v!=0) { // got some valid result + return 1; + } // otherwise skip leading grabage + } + (*offset)++; + } + return v; +} + + +gs_param_handle_t register_handle_for_strtoi_c_slot_0(struct FTA * f, struct gs_string* istr) { + gs_uint32_t offset,r; + offset=0; + if (nextint(istr,&offset,&r)!=0) + return (gs_param_handle_t) r; + return (gs_param_handle_t) 0; +} +gs_retval_t deregister_handle_for_strtoi_c_slot_0(gs_param_handle_t h) { + return 0; +} + +gs_param_handle_t register_handle_for_strtoip_c_slot_0(struct FTA * f, struct gs_string* istr) { + gs_uint32_t ip1,ip2,ip3,ip4,offset,r; + offset=0; + if (nextint(istr,&offset,&ip1)==0) return (gs_param_handle_t)0; + if (nextint(istr,&offset,&ip2)==0) return (gs_param_handle_t)0; + if (nextint(istr,&offset,&ip3)==0) return (gs_param_handle_t)0; + if (nextint(istr,&offset,&ip4)==0) return (gs_param_handle_t)0; + r=ip1<<24|ip2<<16|ip3<<8|ip4; + return (gs_param_handle_t)r; +} +gs_retval_t deregister_handle_for_strtoip_c_slot_0(gs_param_handle_t h) { + return 0; +} + + +/////////////////////////////////////////////////// +// ipv6 procedures + + + +gs_retval_t ipv6_compare( struct ipv6_str i1, struct ipv6_str i2){ + if(i1.v[0] > i2.v[0]) + return 1; + if(i1.v[0] < i2.v[0]) + return -1; + if(i1.v[1] > i2.v[1]) + return 1; + if(i1.v[1] < i2.v[1]) + return -1; + if(i1.v[2] > i2.v[2]) + return 1; + if(i1.v[2] < i2.v[2]) + return -1; + if(i1.v[3] > i2.v[3]) + return 1; + if(i1.v[3] < i2.v[3]) + return -1; + + return 0; +} + +gs_retval_t Ipv6_Constructor(struct ipv6_str *s, gs_sp_t l){ + gs_uint32_t i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0; + sscanf(l,"%x:%x:%x:%x:%x:%x:%x:%x",&i0,&i1,&i2,&i3,&i4,&i5,&i6,&i7); + s->v[0] = ((i0 & 0xffff) << 16) | (i1 & 0xffff); + s->v[1] = ((i2 & 0xffff) << 16) | (i3 & 0xffff); + s->v[2] = ((i4 & 0xffff) << 16) | (i5 & 0xffff); + s->v[3] = ((i6 & 0xffff) << 16) | (i7 & 0xffff); + return(0); +} + +struct ipv6_str And_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2){ + struct ipv6_str ret; + ret.v[0] = i1.v[0] & i2.v[0]; + ret.v[1] = i1.v[1] & i2.v[1]; + ret.v[2] = i1.v[2] & i2.v[2]; + ret.v[3] = i1.v[3] & i2.v[3]; + return ret; +} + +struct ipv6_str Or_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2){ + struct ipv6_str ret; + ret.v[0] = i1.v[0] | i2.v[0]; + ret.v[1] = i1.v[1] | i2.v[1]; + ret.v[2] = i1.v[2] | i2.v[2]; + ret.v[3] = i1.v[3] | i2.v[3]; + return ret; +} +struct ipv6_str hton_ipv6(struct ipv6_str s){ + struct ipv6_str ret; +// ret.v[0] = htonl(s.v[0]); +// ret.v[1] = htonl(s.v[1]); +// ret.v[2] = htonl(s.v[2]); +// ret.v[3] = htonl(s.v[3]); + ret.v[0] = s.v[0]; + ret.v[1] = s.v[1]; + ret.v[2] = s.v[2]; + ret.v[3] = s.v[3]; + return ret; +} + +struct ipv6_str ntoh_ipv6(struct ipv6_str s){ + struct ipv6_str ret; +// ret.v[0] = ntohl(s.v[0]); +// ret.v[1] = ntohl(s.v[1]); +// ret.v[2] = ntohl(s.v[2]); +// ret.v[3] = ntohl(s.v[3]); + ret.v[0] = s.v[0]; + ret.v[1] = s.v[1]; + ret.v[2] = s.v[2]; + ret.v[3] = s.v[3]; + return ret; +} + + diff --git a/src/lib/gscplftaaux/rts_udaf.c b/src/lib/gscplftaaux/rts_udaf.c new file mode 100644 index 0000000..7cad1b4 --- /dev/null +++ b/src/lib/gscplftaaux/rts_udaf.c @@ -0,0 +1,256 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "rts_udaf.h" +#include "gsconfig.h" +#include "gstypes.h" +#include <stdio.h> +#include <limits.h> +#include <math.h> + + +#define max(a,b) ((a) > (b) ? (a) : (b)) +#define MAX_BUFSIZE 128 + + +/****************************************************************/ +/* LFTA functions */ +/****************************************************************/ + + +//////////////////////////////////////////////////////////////////////// +//// avg_udaf + +typedef struct avg_udaf_lfta_struct_t{ + gs_int64_t sum; + gs_uint32_t cnt; +} avg_udaf_lfta_struct_t; + +void avg_udaf_lfta_LFTA_AGGR_INIT_(gs_sp_t b){ + avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b; + s->sum = 0; + s->cnt = 0; +} + +void avg_udaf_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b,gs_uint32_t v){ + avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b; + s->sum += v; + s->cnt++; +} + +gs_retval_t avg_udaf_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){ + return 0; +} + +void avg_udaf_lfta_LFTA_AGGR_OUTPUT_(struct gs_string *r,gs_sp_t b){ + r->length = 12; + r->data = b; +} + +void avg_udaf_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){ + return; +} + +///////////////////////////////////////////////////////// +// Moving sum + +typedef struct moving_sum_lfta_struct{ + gs_uint32_t sum; + gs_uint32_t N; +} moving_sum_lfta_struct; + +void moving_sum_lfta_LFTA_AGGR_INIT_(gs_sp_t b){ + moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b; + s->sum = 0; + s->N = 0; +} + +void moving_sum_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v, gs_uint32_t N){ + moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b; + s->sum += v; + s->N = N; +} + +gs_retval_t moving_sum_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){ + return 0; +} + +void moving_sum_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t *r, gs_sp_t b){ + moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b; + *r = ((gs_uint64_t)(s->N) << 32) | (gs_uint64_t)(s->sum); +} + +gs_retval_t moving_sum_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){ + return 0; +} + +///////////////////////////////////////////////////////// +// FIRST and LAST aggregates + +void FIRST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) { + *scratch = UINT_MAX; // we will encode uninitialized value of UINT_MAX + return; +} + +void FIRST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) { + if (*scratch == UINT_MAX) + *scratch = val; + return; +} + +gs_retval_t FIRST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; } + +void FIRST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) { + *res = *scratch; +} + +void FIRST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; } + +void FIRST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) { + *scratch = ULLONG_MAX; // we will encode uninitialized value of ULLONG_MAX + return; +} + +void FIRST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) { + if (*scratch == ULLONG_MAX) + *scratch = val; + return; +} + +gs_retval_t FIRST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; } + +void FIRST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) { + *res = *scratch; +} + +void FIRST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; } + + + +void FIRST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) { + scratch->data = NULL; + return; +} + +void FIRST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) { + if (!scratch->data) { + str_assign_with_copy(NULL, scratch, val); + } + return; +} + +gs_retval_t FIRST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; } + +void FIRST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) { + *res = *scratch; +} + +void FIRST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) { + if (scratch->data) + fta_free(NULL, scratch->data); +} + +void LAST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) { } + +void LAST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) { + *scratch = val; + return; +} + +gs_retval_t LAST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; } + +void LAST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) { + *res = *scratch; +} + +void LAST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; } + +void LAST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) { } + +void LAST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) { + *scratch = val; + return; +} + +gs_retval_t LAST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; } + +void LAST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) { + *res = *scratch; +} + +void LAST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; } + + + +void LAST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) { + scratch->data = NULL; + return; +} + +void LAST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) { + if (!scratch->data) { + str_assign_with_copy(NULL, scratch, val); + } else { + if (!str_compare(scratch, val)) { + fta_free(NULL, scratch->data); + str_assign_with_copy(NULL, scratch, val); + } + } + return; +} + +gs_retval_t LAST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; } + +void LAST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) { + *res = *scratch; +} + +void LAST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) { + if (scratch->data) + fta_free(NULL, scratch->data); +} + + +///////////////////////////////////////////////////////// +// running_array_aggr aggregate + +struct running_array_aggr_str{ + gs_uint32_t num_list[4]; + gs_uint8_t n_num; +}; + +void running_array_aggr_lfta_LFTA_AGGR_INIT_(char* scratch) { + struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch; + aggr->n_num = 0; +} + +void running_array_aggr_lfta_LFTA_AGGR_UPDATE_(char* scratch, gs_uint32_t val) { + struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch; + aggr->num_list[aggr->n_num++] = val; +} + +gs_retval_t running_array_aggr_lfta_LFTA_AGGR_FLUSHME_(char* scratch) { + struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch; + return (aggr->n_num == 4); +} +void running_array_aggr_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, char* scratch) { + struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch; + res->data = scratch; + res->length = aggr->n_num * sizeof(gs_uint32_t); + res->owner = NULL; +} + +void running_array_aggr_lfta_LFTA_AGGR_DESTROY_(char* scratch) { } + diff --git a/src/lib/gscprts/Makefile b/src/lib/gscprts/Makefile new file mode 100644 index 0000000..545db5d --- /dev/null +++ b/src/lib/gscprts/Makefile @@ -0,0 +1,49 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CC=gcc -g -O3 -msse4.2 -fexpensive-optimizations -I libdag/include -I ../../../include/lfta/ -I ../../../include/ -I ./include/ -I ../gscphost/include +CXX=g++ -g -O3 -msse4.2 -fexpensive-optimizations -I libdag/include -I ../../../include/lfta/ -I ../../../include/ -I ./include/ -I ../gscphost/include + +SOURCE_C = rts_main.c rts_env.c rts_csv.c rts_gdat.c +SOURCE_CC = rts_csv2.cc +SOURCE = $(SOURCE_C) $(SOURCE_CC) + + +OBJECTS = $(SOURCE_C:.c=.o) $(SOURCE_CC:.cc=.o) + + +all: libgscprts.a + +INCDIR=../../../include +LFTA_DIR=$(INCDIR/lfta) + +libgscprts.a: $(OBJECTS) Makefile + ar rc libgscprts.a $(OBJECTS) + +rts_main.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(INCDIR/lapp.h) $(INCDIR/fta.h) + +rts_env.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(INCDIR/lapp.h) $(INCDIR/fta.h) $(LFTA_DIR/rts.h) + +rts_csv.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(INCDIR/lapp.h) $(INCDIR/fta.h) $(LFTA_DIR/rts.h) $(INCDIR/packet.h) + +rts_csv2.cc : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(INCDIR/lapp.h) $(INCDIR/fta.h) $(LFTA_DIR/rts.h) $(INCDIR/packet.h) + +rts_gdat.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) $(INCDIR/lapp.h) $(INCDIR/fta.h) $(LFTA_DIR/rts.h) $(INCDIR/packet.h) + +install: all + cp libgscprts.a ../../../lib/ ; ranlib ../../../lib/libgscprts.a + +clean: + rm -f *.o *.a core diff --git a/src/lib/gscprts/rts_csv.c b/src/lib/gscprts/rts_csv.c new file mode 100644 index 0000000..98c84c1 --- /dev/null +++ b/src/lib/gscprts/rts_csv.c @@ -0,0 +1,404 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <time.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include "errno.h" + +#include "gsconfig.h" +#include "gshub.h" +#include "gstypes.h" +#include "lapp.h" +#include "fta.h" +#include "stdio.h" +#include "stdlib.h" +#include "packet.h" +#include "schemaparser.h" +#include "lfta/rts.h" + +void rts_fta_process_packet(struct packet * p); +void rts_fta_done(); +void fta_init(gs_sp_t device); + + +#define CSVMAXLINE 1000000 + +static FILE *pd; +static int listensockfd=-1; +static int fd=-1; +static struct packet cur_packet; +static gs_sp_t name; +static gs_uint8_t line[CSVMAXLINE]; +static gs_uint32_t lineend=0; +static gs_uint8_t csvdel=','; +static gs_uint32_t verbose=0; +static gs_uint32_t startupdelay=0; +static gs_uint32_t singlefile=0; +static gs_uint32_t gshub=0; +static int socket_desc=0; + +static void csv_replay_check_messages() { + if (fta_start_service(0)<0) { + print_error("Error:in processing the msg queue for a replay file"); + exit(9); + } +} + +static gs_uint32_t gs_read_line(gs_uint8_t * buffer, gs_uint32_t length){ + gs_uint32_t used=0; + gs_uint32_t cur; + fd_set socket_rset; + fd_set socket_eset; + struct timeval socket_timeout; + int retval; + + FD_ZERO(&socket_rset); + FD_SET(socket_desc,&socket_rset); + FD_ZERO(&socket_eset); + FD_SET(socket_desc,&socket_eset); + // timeout in one millisecon + socket_timeout.tv_sec=0; + socket_timeout.tv_usec=1000; + + if ((retval=select(socket_desc+1,&socket_rset,0,&socket_eset,&socket_timeout))<=0) { + if (retval==0) { + // caught a timeout + return -1; + } + return -2; + } + + while((used < (length-1)) && ((used==0)|| (buffer[used-1]!='\n'))) { + if ((cur=read(socket_desc,&(buffer[used]),1))<=0) { + print_error("ERROR:could not read data from gdat stream"); + return -2; + } + used+=cur; + } + buffer[used]=0; + return 0; +} + +static void init_socket() { + endpoint gshub; + endpoint srcinfo; + struct sockaddr_in server; + gs_int32_t parserversion; + gs_uint32_t schemalen; + static char * asciischema=0; + gs_int8_t buf[1024]; + + if (get_hub(&gshub)!=0) { + print_error("ERROR:could not find gshub for data source"); + exit(0); + } + + if (get_streamsource(gshub,name,&srcinfo,1) !=0) { + print_error("ERROR:could not find data source for stream\n"); + exit(0); + } + + socket_desc = socket(AF_INET , SOCK_STREAM , 0); + if (socket_desc == -1) + { + print_error("ERROR:could not create socket for data stream"); + exit(0); + } + server.sin_addr.s_addr = srcinfo.ip; + server.sin_family = AF_INET; + server.sin_port = srcinfo.port; + + if (connect(socket_desc , (struct sockaddr *)&server , sizeof(server)) < 0) + { + print_error("ERROR: could not open connection to data source"); + exit(0); + } + +} + +static void next_file() { + struct stat s; + if (verbose) { + fprintf(stderr,"Opening %s\n",name); + } + if (singlefile==0) { + while (lstat(name,&s)!=0) { + if (errno!=ENOENT) { + print_error("csv::lstat unexpected return value"); + exit(10); + } + csv_replay_check_messages(); + usleep(10000); + } + if (pd!=0) { + fclose(pd); + } + } + if ((pd=fopen(name,"r"))==0) { + print_error("csv::open failed "); + exit(10); + } + if (singlefile==0) { + unlink(name); + } +} + + +static gs_retval_t csv_replay_init(gs_sp_t device) +{ + gs_sp_t verbosetmp; + gs_sp_t delaytmp; + gs_sp_t gshubtmp; + gs_sp_t tempdel; + gs_sp_t singlefiletmp; + + if ((name=get_iface_properties(device,"filename"))==0) { + print_error("csv_init::No CSV \"Filename\" defined"); + exit(0); + } + tempdel=get_iface_properties(device,"csvseparator"); + if (tempdel != 0 ) { + csvdel=(gs_uint8_t) tempdel[0]; + } + + if ((verbosetmp=get_iface_properties(device,"verbose"))!=0) { + if (strncmp(verbosetmp,"TRUE",4)==0) { + verbose=1; + fprintf(stderr,"VERBOSE ENABLED\n"); + } else { + fprintf(stderr,"VERBOSE DISABLED\n"); + } + } + if ((singlefiletmp=get_iface_properties(device,"singlefile"))!=0) { + if (strncmp(singlefiletmp,"TRUE",4)==0) { + singlefile=1; + if (verbose) + fprintf(stderr,"SINGLEFILE ENABLED\n"); + } else { + if (verbose) + fprintf(stderr,"SINGLEFILE DISABLED\n"); + } + } + + if ((delaytmp=get_iface_properties(device,"startupdelay"))!=0) { + if (verbose) { + fprintf(stderr,"Startup delay of %u seconds\n",atoi(get_iface_properties(device,"startupdelay"))); + } + startupdelay=atoi(get_iface_properties(device,"startupdelay")); + } + if ((gshubtmp=get_iface_properties(device,"gshub"))!=0) { + if (verbose) { + fprintf(stderr,"GDAT format using gshub\n"); + } + gshub=1; + } + + cur_packet.ptype=PTYPE_CSV; + return 0; +} + +static gs_retval_t csv_read_socket() +{ + gs_uint32_t i; + gs_uint32_t p; + gs_uint32_t x; + gs_int32_t r; + gs_retval_t ret; + gs_uint32_t done; + + if ((ret=gs_read_line(line,CSVMAXLINE-1))<0) { return ret;} + cur_packet.systemTime=time(0); + p=0; + i=0; + done=0; + while((done==0)&&(i<CSVMAXLINE)&&(line[i]!=0)&&(p<CSVELEMENTS)){ + cur_packet.record.csv.fields[p]=&line[i]; + p++; + while((line[i] != 0) && (line[i] != csvdel)) { + i++; + } + if (line[i]==0) done=1; + line[i]=0; + i++; + } + cur_packet.record.csv.numberfields=p; + //fprintf(stderr,"XX,%s,%s,%u,%u\n",cur_packet.record.csv.fields[0],cur_packet.record.csv.fields[1],x,lineend); + rts_fta_process_packet(&cur_packet); + if (lineend>x+1) { + memcpy(&(line[0]),&(line[x+1]),lineend-x-1); + lineend=lineend-x-1; + } else { + lineend=0; + } + line[lineend]=0; + return 0; + } + + static void csv_read_tuple() + { + gs_uint32_t i=0; + gs_uint32_t p=0; + gs_uint32_t flen=0; + if (pd==0) next_file(); + while(fgets((char *)&(line[0]),CSVMAXLINE,pd)==0) { + if (singlefile==1) { + if(verbose) { + fprintf(stderr,"SINGLEFILE PROCESSING DONE!\n"); + } + rts_fta_done(); + if (verbose) { + fprintf(stderr,"RTS SAYS BY\n"); + } + while(1==1) sleep(1); + } else { + next_file(); + } + } + cur_packet.systemTime=time(0); + while((i<CSVMAXLINE)&&(line[i]!=0)&&(p<CSVELEMENTS)){ + cur_packet.record.csv.fields[p]=&line[i]; + p++; + while((line[i] != 0) && (line[i] != csvdel)) { + i++; + } + if(line[i] != 0){ + line[i]=0; + i++; + } + } + // Get rid of trailing \n and \r. + while(i>0 && (line[i-1] == '\n' || line[i-1] == '\r')){ + i--; + line[i] = '\0'; + } + cur_packet.record.csv.numberfields=p; + rts_fta_process_packet(&cur_packet); + } + + + + + + static gs_retval_t csv_process_file() + { + unsigned cnt=0; + static unsigned totalcnt=0; + for(cnt=0;cnt<50000;cnt++) { + if (gshub!=0) { + gs_retval_t retval; + retval=csv_read_socket(); + if (retval==-1) return 0; // got a timeout so service message queue + if ((retval==-2) || (ftaschema_is_eof_tuple(cur_packet.record.gdat.schema,(void *)cur_packet.record.gdat.data))) { + // we signal that everything is done if we either see an EOF tuple OR the socket is closed by the peer + if (verbose) + fprintf(stderr,"Done processing waiting for things to shut down\n"); + rts_fta_done(); + // now just service message queue until we get killed or loose connectivity + while (0==0) { + fta_start_service(0); // service all waiting messages + usleep(1000); // sleep a millisecond + } + } + } else { + csv_read_tuple(); + } + } + totalcnt=totalcnt+cnt; + if (verbose) { + fprintf(stderr,"Processesd %u tuple\n",totalcnt); + } + return 0; + } + + gs_retval_t main_csv(gs_int32_t devicenum, gs_sp_t device, gs_int32_t mapcnt, gs_sp_t map[]) { + gs_uint32_t cont; + endpoint mygshub; + + csv_replay_init(device); + + /* initalize host_lib */ + if (verbose) { + fprintf(stderr,"Init LFTAs for %s\n",device); + } + + if (hostlib_init(LFTA,0,devicenum,mapcnt,map)<0) { + fprintf(stderr,"%s::error:could not initiate host lib for clearinghouse\n", + device); + exit(7); + } + + fta_init(device); /*xxx probably should get error code back put Ted doesn't give me one*/ + + cont=startupdelay+time(0); + + if (verbose) { fprintf(stderr,"Start startup delay"); } + + while (cont>time(NULL)) { + if (fta_start_service(0)<0) { + fprintf(stderr,"%s::error:in processing the msg queue\n", + device); + exit(9); + } + usleep(1000); /* sleep for one millisecond */ + } + + if (verbose) { fprintf(stderr,"... Done\n"); } + + // open the connection to the data source + if (gshub!=0) { init_socket();} + + // wait to process till we get the signal from GSHUB + if (get_hub(&mygshub)!=0) { + print_error("ERROR:could not find gshub for data source"); + exit(0); + } + while(get_startprocessing(mygshub,get_instance_name(),0)!=0) { + usleep(100); + if (fta_start_service(0)<0) { + fprintf(stderr,"%s::error:in processing the msg queue\n", + device); + exit(9); + } + } + + /* now we enter an endless loop to process data */ + if (verbose) { + fprintf(stderr,"Start processing %s\n",device); + } + + while (1==1) { + if (csv_process_file()<0) { + fprintf(stderr,"%s::error:in processing packets\n", + device); + exit(8); + } + /* process all messages on the message queue*/ + if (fta_start_service(0)<0) { + fprintf(stderr,"%s::error:in processing the msg queue\n", + device); + exit(9); + } + } + return 0; + } + + diff --git a/src/lib/gscprts/rts_csv2.cc b/src/lib/gscprts/rts_csv2.cc new file mode 100644 index 0000000..e69de29 diff --git a/src/lib/gscprts/rts_env.c b/src/lib/gscprts/rts_env.c new file mode 100644 index 0000000..b674ae8 --- /dev/null +++ b/src/lib/gscprts/rts_env.c @@ -0,0 +1,265 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include "gsconfig.h" +#include "gstypes.h" +#include "lapp.h" +#include <ipcencoding.h> +#include <callbackregistries.h> +#include "fta.h" +#include "stdio.h" +#include "stdlib.h" +#include "rts.h" + +#define POLLING + +static struct ringbuf * ru=0; + +gs_retval_t print_error(gs_sp_t c) { + gslog(LOG_EMERG,"%s",c); + return 0; +} + +void *fta_alloc(struct FTA * owner, gs_int32_t size) +{ + gs_uint8_t * c; + gs_uint32_t x; + if ((c=(gs_uint8_t *)malloc(size))==0) return 0; + /* touch all memory once to map/reserve it now */ + for(x=0;x<size;x=x+1024) { + c[x]=0; + } + + return (void *) c; +} + +void fta_free(struct FTA * owner , void * mem) { + free(mem); +} + + +void fta_free_all(struct FTA * owner) { + gslog(LOG_ERR,"fta_free_all not available "); +} + +/* It is assumed that there is no write activity on all ringbuffers between an alloccate_tuple and + * a post_tuple. If there is any the result is unpredictable + */ + +void * allocate_tuple(struct FTA * owner, gs_int32_t size) +{ + gs_int32_t state; + if (ru!=0) { + gslog(LOG_ALERT,"Can't allocate multiple tuples at the same time before posting them"); + return 0; + } + + if (size>MAXTUPLESZ) { + gslog(LOG_ALERT,"Maximum tuple size is %u",MAXTUPLESZ); + ru=0; + return 0; + } + + if (ftacallback_start_streamid(owner->ftaid.streamid)<0) { + gslog(LOG_ALERT,"Post for unkown streamid\n"); + ru=0; + return 0; + } + + /* we grep memory in the first none suspended ringbuffer. Note that if there is no such ringbuffer we might + not find any memory*/ + while ((ru=ftacallback_next_streamid(&state))!=0) { +#ifdef PRINTMSG + fprintf(stderr,"Allocating in ringpuffer %p [%p:%u]" + "(%u %u %u) \n",ru,&ru->start,ru->end,ru->reader,ru->writer, + ru->length); + fprintf(stderr,"Pointer to current writer %p\n",CURWRITE(ru)); +#endif + if (state != LFTA_RINGBUF_SUSPEND) { +#ifdef BLOCKRINGBUFFER + if (state == LFTA_RINGBUF_ATOMIC) { + while (!SPACETOWRITE(ru)) { + usleep(100); + } + } +#endif + if (SPACETOWRITE(ru)) { + CURWRITE(ru)->f=owner->ftaid; + CURWRITE(ru)->sz=size; + return &(CURWRITE(ru)->data[0]); + } else { + shared_memory_full_warning++; + } + } + } + ru=0; + outtupledrop++; + + return 0; +} + +void free_tuple(void * data) { + ru=0; +} + +gs_retval_t post_tuple(void * tuple) { + struct ringbuf * r; + FTAID * ftaidp; + gs_uint32_t stream_id; + struct wakeup_result a; + gs_int32_t state; + + if (ru==0) { + gslog(LOG_ALERT,"lfta post tuple posted tupple was never allocated\n"); + return -1; + } + + + if (tuple != ((void*) &(CURWRITE(ru)->data[0]))) { + gslog(LOG_ALERT,"lfta post tuple posted tupple which was not allocated" + "immediatly before\n"); + ru=0; + return -1; + } + + stream_id=CURWRITE(ru)->f.streamid; + + if (ftacallback_start_streamid(stream_id)<0) { + gslog(LOG_ALERT,"ERROR:Post for unkown streamid\n"); + ru=0; + return -1; + } + /* now make sure we have space to write in all atomic ringbuffer */ + while((r=ftacallback_next_streamid(&state))!=0) { + if ((state == LFTA_RINGBUF_ATOMIC) && (r!=ru)) { +#ifdef BLOCKRINGBUFFER + while (!SPACETOWRITE(r)) { + usleep(10000); + } +#endif + if (! SPACETOWRITE(r)) { + /* atomic ring buffer and no space so post nothing */ + outtupledrop++; + ru=0; + return -1; + } + } + } + + if (ftacallback_start_streamid(stream_id)<0) { + gslog(LOG_ALERT,"Post for unkown streamid\n"); + ru=0; + return -1; + } + + while((r=ftacallback_next_streamid(&state))!=0) { +#ifdef PRINTMSG + fprintf(stderr,"Found additional ring buffer make a copy to rb%p\n", + r); +#endif + /* try to post in all none suspended ringbuffer for atomic once + * we know we will succeed + */ + if ((r!=ru)&&(state != LFTA_RINGBUF_SUSPEND)) { + if (SPACETOWRITE(r)) { + CURWRITE(r)->f=CURWRITE(ru)->f; + CURWRITE(r)->sz=CURWRITE(ru)->sz; + memcpy(&(CURWRITE(r)->data[0]),&(CURWRITE(ru)->data[0]), + CURWRITE(ru)->sz); + outtuple++; + outbytes=outbytes+CURWRITE(ru)->sz; + ADVANCEWRITE(r); +#ifdef PRINTMSG + fprintf(stderr,"Wrote in ringpuffer %p [%p:%u]" + "(%u %u %u) \n",r,&r->start,r->end,r->reader,r->writer, + r->length); + fprintf(stderr,"\t%u %u %u\n",CURREAD(r)->next, + CURREAD(r)->f.streamid,CURREAD(r)->sz); +#endif + } else { + outtupledrop++; + } + } + if (HOWFULL(r) > 500) { + // buffer is at least half full + shared_memory_full_warning++; +#ifdef PRINTMSG + fprintf(stderr,"\t\t buffer full\n"); +#endif + } + } + + if (HOWFULL(ru) > 500) { + // buffer is at least half full + shared_memory_full_warning++; +#ifdef PRINTMSG + fprintf(stderr,"\t\t buffer full\n"); +#endif + } + outtuple++; + outbytes=outbytes+CURWRITE(ru)->sz; + ADVANCEWRITE(ru); + ru=0; +#ifndef POLLING + if (ftacallback_start_wakeup(stream_id)<0) { + gslog(LOG_ALERT,"Wakeup for unkown streamid\n"); + return -1; + } + a.h.callid=WAKEUP; + a.h.size=sizeof(struct wakeup_result); + while((ftaidp=ftacallback_next_wakeup())!=0) { + if (send_wakeup(*ftaidp)<0) { + gslog(LOG_ALERT,"Could not send wakeup\n"); + return -1; + } + } +#endif + return 0; +} + +gs_retval_t get_ringbuf_space(struct FTA * f, FTAID * r, gs_int32_t* space, gs_int32_t szr, gs_int32_t tuplesz) +{ + gs_int32_t x=0; + gs_int32_t state; + struct ringbuf * ru; + if (ftacallback_start_streamid(f->ftaid.streamid)<0) { + gslog(LOG_ALERT,"Space check for unkown streamid\n"); + return -1; + } + + while ((ru=ftacallback_next_streamid(&state))!=0) { + if (szr > x ) { + r[x]=ru->destid; + space[x]=TUPLEFIT(ru,tuplesz); + } + x++; + } + return x; +} + +gs_retval_t set_ringbuf_type(struct FTA * f, FTAID process, gs_int32_t state) +{ + + if (ftacallback_state_streamid(f->ftaid.streamid,process, state)<0) { + gslog(LOG_ALERT,"state change for unkown streamid\n"); + return -1; + } + return 0; +} + + +gs_retval_t tpost_ready() { + return 1; +} + diff --git a/src/lib/gscprts/rts_gdat.c b/src/lib/gscprts/rts_gdat.c new file mode 100644 index 0000000..7cd4afe --- /dev/null +++ b/src/lib/gscprts/rts_gdat.c @@ -0,0 +1,479 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <time.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include "errno.h" + +#include "gsconfig.h" +#include "gshub.h" +#include "gstypes.h" +#include "lapp.h" +#include "fta.h" +#include "stdio.h" +#include "stdlib.h" +#include "packet.h" +#include "schemaparser.h" +#include "lfta/rts.h" + + +void rts_fta_process_packet(struct packet * p); +void rts_fta_done(); +void fta_init(gs_sp_t device); + +#define CSVMAXLINE 1000000 + +static FILE *pd; +static struct packet cur_packet; +static gs_sp_t name; +static gs_uint32_t verbose=0; +static gs_uint32_t startupdelay=0; +static gs_uint32_t gshub=0; +static int socket_desc=0; +static gs_uint32_t singlefile=0; + +static void gdat_replay_check_messages() { + if (fta_start_service(0)<0) { + print_error("Error:in processing the msg queue for a replay file"); + exit(9); + } +} + +static gs_retval_t gs_read(gs_sp_t buffer, gs_uint32_t length){ + gs_uint32_t used=0; + gs_uint32_t cur; + fd_set socket_rset; + fd_set socket_eset; + struct timeval socket_timeout; + int retval; + + FD_ZERO(&socket_rset); + FD_SET(socket_desc,&socket_rset); + FD_ZERO(&socket_eset); + FD_SET(socket_desc,&socket_eset); + // timeout in one millisecon + socket_timeout.tv_sec=0; + socket_timeout.tv_usec=1000; + + if ((retval=select(socket_desc+1,&socket_rset,0,&socket_eset,&socket_timeout))<=0) { + if (retval==0) { + // caught a timeout + return -1; + } + print_error("ERROR:select error in reading data from socket"); + exit(0); + } + + while(used < length) { + if ((cur=read(socket_desc,&(buffer[used]),length-used))<=0) { + if (errno==115) return -2; // error code we get if the server closes the connection on us + print_error("ERROR:could not read data from gdat stream"); + exit(0); + } + used+=cur; + } + return 1; +} + +static gs_uint32_t gs_read_line(gs_sp_t buffer, gs_uint32_t length){ + gs_uint32_t used=0; + gs_uint32_t cur; + + while((used < (length-1)) && ((used==0)|| (buffer[used-1]!='\n'))) { + if ((cur=read(socket_desc,&(buffer[used]),1))<=0) { + print_error("ERROR:could not read data from gdat stream"); + exit(0); + } + used+=cur; + } + buffer[used]=0; + return 1; +} + + +static void init_socket() { + endpoint gshub; + endpoint srcinfo; + struct sockaddr_in server; + gs_int32_t parserversion; + gs_uint32_t schemalen; + static char * asciischema=0; + gs_int8_t buf[1024]; + + if (get_hub(&gshub)!=0) { + print_error("ERROR:could not find gshub for data source"); + exit(0); + } + + if (get_streamsource(gshub,name,&srcinfo,1) !=0) { + print_error("ERROR:could not find data source for stream\n"); + exit(0); + } + + socket_desc = socket(AF_INET , SOCK_STREAM , 0); + if (socket_desc == -1) + { + print_error("ERROR:could not create socket for data stream"); + exit(0); + } + server.sin_addr.s_addr = srcinfo.ip; + server.sin_family = AF_INET; + server.sin_port = srcinfo.port; + + if (connect(socket_desc , (struct sockaddr *)&server , sizeof(server)) < 0) + { + print_error("ERROR: could not open connection to data source"); + exit(0); + } + + + gs_read_line(buf,1024); + if (strncmp(buf,"GDAT",4)!=0) { + print_error("ERROR: not a GDAT stream\n"); + exit(0); + } + gs_read_line(buf,1024); + if (sscanf(buf,"VERSION:%u\n",&parserversion)!=1) { + print_error("ERROR: no GDAT VERSION given\n"); + exit(0); + } + gs_read_line(buf,1024); + if (sscanf(buf,"SCHEMALENGTH:%u\n",&schemalen)!=1) { + print_error("ERROR: no GDAT SCHEMALENGTH given\n"); + exit(0); + } + if (schemaparser_accepts_version(parserversion)!=1) { + print_error("gdatinput::wrong gdat version\n"); + exit(0); + } + if ((asciischema=malloc(schemalen))==0) { + print_error("gdatinput::could not allocate memory for schema\n"); + exit(0); + } + if (gs_read(asciischema,schemalen)!=1) { + print_error("gdatinput::could not read schema from file\n"); + exit(0); + } + if ((cur_packet.record.gdat.schema=ftaschema_parse_string(asciischema))<0) { + print_error("gdatinput::could not parse schema\n"); + exit(0); + } + cur_packet.record.gdat.numfields=ftaschema_tuple_len(cur_packet.record.gdat.schema); +} + + +static void next_file() { + struct stat s; + gs_int32_t parserversion; + gs_uint32_t schemalen; + static char * asciischema=0; + + if (verbose) { + fprintf(stderr,"Opening %s\n",name); + } + while (lstat(name,&s)!=0) { + if (errno!=ENOENT) { + print_error("gdat::lstat unexpected return value"); + exit(10); + } + gdat_replay_check_messages(); + usleep(10000); + } + + + if (pd!=0) { + fclose(pd); + if (asciischema!=0) free(asciischema); + if (cur_packet.record.gdat.schema>=0) { + ftaschema_free(cur_packet.record.gdat.schema); + } + } + + if ((pd=fopen(name,"r"))==0) return; + if (singlefile==0) { + unlink(name); + } + + if (fscanf(pd,"GDAT\nVERSION:%u\nSCHEMALENGTH:%u\n",&parserversion,&schemalen)!=2) { + if (verbose) fprintf(stderr,"gdatinput::could not parse GDAT header\n"); + fclose(pd); + pd=0; + return; + } + if (schemaparser_accepts_version(parserversion)!=1) { + if (verbose) fprintf(stderr,"gdatinput::wrong gdat version\n"); + fclose(pd); + pd=0; + return; + } + if ((asciischema=malloc(schemalen))==0) { + if (verbose) fprintf(stderr,"gdatinput::could not allocate memory for schema\n"); + fclose(pd); + pd=0; + return; + } + if (fread(asciischema,schemalen,1,pd)!=1) { + if (verbose) fprintf(stderr,"gdatinput::could not read schema from file\n"); + fclose(pd); + pd=0; + return; + } + if ((cur_packet.record.gdat.schema=ftaschema_parse_string(asciischema))<0) { + if (verbose) fprintf(stderr,"gdatinput::could not parse schema\n"); + fclose(pd); + pd=0; + return; + } + cur_packet.record.gdat.numfields=ftaschema_tuple_len(cur_packet.record.gdat.schema); +} + +static gs_retval_t gdat_replay_init(gs_sp_t device) +{ + gs_sp_t verbosetmp; + gs_sp_t delaytmp; + gs_sp_t gshubtmp; + gs_sp_t singlefiletmp; + + if ((name=get_iface_properties(device,"filename"))==0) { + print_error("csv_init::No GDAT \"Filename\" defined"); + exit(0); + } + + if ((verbosetmp=get_iface_properties(device,"verbose"))!=0) { + if (strncmp(verbosetmp,"TRUE",4)==0) { + verbose=1; + fprintf(stderr,"VERBOSE ENABLED\n"); + } else { + fprintf(stderr,"VERBOSE DISABLED\n"); + } + } + if ((singlefiletmp=get_iface_properties(device,"singlefile"))!=0) { + if (strncmp(singlefiletmp,"TRUE",4)==0) { + singlefile=1; + if (verbose) + fprintf(stderr,"SINGLEFILE ENABLED\n"); + } else { + if (verbose) + fprintf(stderr,"SINGLEFILE DISABLED\n"); + } + } + + if ((delaytmp=get_iface_properties(device,"startupdelay"))!=0) { + if (verbose) { + fprintf(stderr,"Startup delay of %u seconds\n",atoi(get_iface_properties(device,"startupdelay"))); + } + startupdelay=atoi(get_iface_properties(device,"startupdelay")); + } + if ((gshubtmp=get_iface_properties(device,"gshub"))!=0) { + if (verbose) { + fprintf(stderr,"GDAT format using gshub\n"); + } + gshub=1; + } + + cur_packet.ptype=PTYPE_GDAT; + return 0; +} + +static gs_retval_t gdat_read_socket(){ + gs_uint32_t nsz,sz; + gs_retval_t retval; + if ((retval=gs_read((gs_sp_t)&nsz,sizeof(gs_uint32_t)))<0) { + return retval; + } + sz=ntohl(nsz); + if (sz>MAXTUPLESZ) { + if (verbose) { + fprintf(stderr,"INTERNAL ERROR tuple to long for fixed buffer. Tuple sz %u\n", + (sz)); + } + print_error("Error::Illegal tuple received"); + exit(0); + } + + cur_packet.record.gdat.datasz=sz; + + if (gs_read((gs_sp_t)cur_packet.record.gdat.data,(sz))!=1) { + if (verbose){ + fprintf(stderr,"UNEXPECTED END OF FILE. Tryed to read tuple of size %u\n", + (sz)); + } + print_error("Error::Illegal tuple received"); + exit(0); + } + cur_packet.systemTime=time(0); + return 0; +} + +static gs_retval_t gdat_read_tuple(){ + gs_uint32_t nsz,sz; + + if (pd==0) next_file(); +again: + while((pd==0) || (fread(&nsz,sizeof(gs_uint32_t),1,pd)!=1)) { + if (singlefile==1) { + if(verbose) { + fprintf(stderr,"SINGLEFILE PROCESSING DONE!\n"); + } + rts_fta_done(); + if (verbose) { + fprintf(stderr,"RTS SAYS BY\n"); + } + while(1==1) sleep(1); + } else { + next_file(); + } + } + sz=ntohl(nsz); + if (sz>MAXTUPLESZ) { + if (verbose) { + fprintf(stderr,"INTERNAL ERROR tuple to long for fixed buffer. Tuple sz %u\n", + (sz)); + } + fclose(pd); + pd=0; + goto again; + } + + cur_packet.record.gdat.datasz=sz; + + if (fread(cur_packet.record.gdat.data,(sz),1,pd)!=1) { + if (verbose){ + fprintf(stderr,"UNEXPECTED END OF FILE. Tryed to read tuple of size %u\n", + (sz)); + } + fclose(pd); + pd=0; + goto again; + } + cur_packet.systemTime=time(0); + return 0; +} + +static gs_retval_t gdat_process_file() +{ + unsigned cnt=0; + static unsigned totalcnt=0; + for(cnt=0;cnt<50000;cnt++) { + if (gshub!=0) { + gs_retval_t retval; + retval=gdat_read_socket(); + if (retval==-1) return 0; // got a timeout so service message queue + if ((retval==-2) || (ftaschema_is_eof_tuple(cur_packet.record.gdat.schema,(void *)cur_packet.record.gdat.data))) { + // we signal that everything is done if we either see an EOF tuple OR the socket is closed by the peer + if (verbose) + fprintf(stderr,"Done processing waiting for things to shut down\n"); + rts_fta_done(); + // now just service message queue until we get killed or loose connectivity + while (0==0) { + fta_start_service(0); // service all waiting messages + usleep(1000); // sleep a millisecond + } + } + } else { + gdat_read_tuple(); + } + rts_fta_process_packet(&cur_packet); + } + totalcnt=totalcnt+cnt; + if (verbose) { + fprintf(stderr,"Processesd %u tuple\n",totalcnt); + } + return 0; +} + +gs_retval_t main_gdat(gs_int32_t devicenum, gs_sp_t device, gs_int32_t mapcnt, gs_sp_t map[]) { + gs_uint32_t cont; + endpoint mygshub; + + gdat_replay_init(device); + + /* initalize host_lib */ + if (verbose) { + fprintf(stderr,"Init LFTAs for %s\n",device); + } + + if (hostlib_init(LFTA,0,devicenum,mapcnt,map)<0) { + fprintf(stderr,"%s::error:could not initiate host lib for clearinghouse\n", + device); + exit(7); + } + + fta_init(device); + + cont=startupdelay+time(0); + + if (verbose) { fprintf(stderr,"Start startup delay"); } + + while (cont>time(NULL)) { + if (fta_start_service(0)<0) { + fprintf(stderr,"%s::error:in processing the msg queue\n", + device); + exit(9); + } + usleep(1); /* sleep for one millisecond */ + } + + if (verbose) { fprintf(stderr,"... Done\n"); } + + // open the connection to the data source + + if (gshub!=0) { init_socket();} + + // wait to process till we get the signal from GSHUB + if (get_hub(&mygshub)!=0) { + print_error("ERROR:could not find gshub for data source"); + exit(0); + } + while(get_startprocessing(mygshub,get_instance_name(),0)!=0) { + usleep(100); + if (fta_start_service(0)<0) { + fprintf(stderr,"%s::error:in processing the msg queue\n", + device); + exit(9); + } + } + + /* now we enter an endless loop to process data */ + if (verbose) { + fprintf(stderr,"Start processing %s\n",device); + } + + while (1==1) { + /* proess packets data stream*/ + if (gdat_process_file()<0) { + fprintf(stderr,"%s::error:in processing packets\n", + device); + exit(8); + } + /* process all messages on the message queue*/ + if (fta_start_service(0)<0) { + fprintf(stderr,"%s::error:in processing the msg queue\n", + device); + exit(9); + } + } + return 0; +} + + + diff --git a/src/lib/gscprts/rts_main.c b/src/lib/gscprts/rts_main.c new file mode 100644 index 0000000..97126c7 --- /dev/null +++ b/src/lib/gscprts/rts_main.c @@ -0,0 +1,192 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "gsconfig.h" +#include "gstypes.h" +#include "gshub.h" + +#include "lapp.h" +#include "fta.h" +#include "lfta/rts.h" + +#include "stdio.h" +#include "stdlib.h" +#include <sys/types.h> +#include <unistd.h> + +#include <sys/ipc.h> +#include <sys/shm.h> +#include <fcntl.h> +#include <errno.h> +#include <sys/socket.h> + +gs_retval_t main_csv(gs_int32_t devicenum, gs_sp_t device, gs_int32_t mapcnt, gs_sp_t map[]); +gs_retval_t main_csv2(gs_int32_t devicenum, gs_sp_t device, gs_int32_t mapcnt, gs_sp_t map[]); +gs_retval_t main_gdat(gs_int32_t devicenum, gs_sp_t device, gs_int32_t mapcnt, gs_sp_t map[]); + +int main (int argc, char* argv[]) { + gs_int32_t pid; + gs_int32_t x; + gs_int32_t y; + gs_sp_t* device; + gs_int32_t devcnt=0; + gs_sp_t* mappings; + gs_int32_t mapcnt=0; + gs_sp_t* lmap; + gs_int32_t lmapcnt=0; + FILE * cfg_file; + gs_int32_t tip1,tip2,tip3,tip4; + endpoint gshub; + gs_sp_t instance_name; + + + gsopenlog(argv[0]); + + if (setpgid(0,0)<0) { + gslog(LOG_EMERG,"Could not set process group id of rts"); + exit(1); + } + + if (argc<4) { + gslog(LOG_EMERG,"Wrong arguments at startup"); + exit(1); + } + + /* allocate more than enough for each array */ + if ((device=(gs_sp_t*)malloc(sizeof(gs_sp_t*) * argc))==0) { + gslog(LOG_EMERG,"malloc error"); + exit(1); + } + if ((mappings=(gs_sp_t*)malloc(sizeof(gs_sp_t*) * argc))==0) { + gslog(LOG_EMERG,"malloc error"); + exit(1); + } + if ((lmap=(gs_sp_t*)malloc(sizeof(gs_sp_t*) * argc))==0) { + gslog(LOG_EMERG,"malloc error"); + exit(1); + } + + /* parse the arguments */ + + if ((sscanf(argv[1],"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(gshub.port))!=5)) { + gslog(LOG_EMERG,"HUB IP NOT DEFINED"); + exit(1); + } + gshub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + gshub.port=htons(gshub.port); + instance_name=strdup(argv[2]); + if (set_hub(gshub)!=0) { + gslog(LOG_EMERG,"Could not set hub"); + exit(1); + } + if (set_instance_name(instance_name)!=0) { + gslog(LOG_EMERG,"Could not set instance name"); + exit(1); + } + + for(x=3;x<argc;x++) { + if (strncmp("-D",argv[x],2)==0) { + /* macro definition */ + y=2; + while((y<(strlen(argv[x])-1))&&(argv[x][y]!='=')) y++; + + + if (y<(strlen(argv[x])-1)) { + /* if that is not true the define is empty and + we ignore it otherwise we set the = to 0 to + make two strings out of it*/ + argv[x][y]=0; + mappings[mapcnt]=&(argv[x][2]); + mapcnt++; + } + } else { + /* device definition */ + device[devcnt]=argv[x]; + devcnt++; + } + } + + if (devcnt==0) { + gslog(LOG_EMERG,"at least one device has to be specified"); + exit(1); + } + + + /* now startup all the device dependend processes. */ + + for (x=0;x<devcnt;x++) { + if ((pid=fork())==-1) { + gslog(LOG_EMERG,"fork error"); + exit(1); + } + + if (pid==0) { + gs_sp_t interfacetype; + /* wait for clearinghouse to finish startup */ + sleep(2); + for(y=0;y<mapcnt;y++) { + if (strcmp(device[x],&mappings[y][strlen(mappings[y])+1])==0) { + /* point to the second string */ + lmap[lmapcnt]=mappings[y]; + lmapcnt++; + } + } + /* the devicename always matches */ + lmap[lmapcnt]=device[x]; + lmapcnt++; + + if ((interfacetype=get_iface_properties(device[x],(gs_sp_t)"interfacetype"))==0) { + gslog(LOG_EMERG,"Interface Type not configured but required"); + exit(1); + } + + if (strcmp(interfacetype,"CSV")==0) { + main_csv(x,device[x],lmapcnt,lmap); + } else { + if (strncmp(interfacetype,"GDAT",4)==0) { + main_gdat(x,device[x],lmapcnt,lmap); + } else { + gslog(LOG_ERR,"UNKNOWN InterfaceType\n"); + exit(0); + } + } + + /* should never return */ + gslog(LOG_EMERG,"lfta init returned"); + exit(1); + } + } + + /* initalize host_lib */ + + gslog(LOG_INFO,"Init host lib in clearinghouse"); + + if (hostlib_init(CLEARINGHOUSE,0,DEFAULTDEV,0,0)<0) { + gslog(LOG_EMERG,"%s::error:could not initiate host lib for clearinghouse\n", + argv[0]); + exit(7); + } + + + + /* start processing messages should never return*/ + if (fta_start_service(-1)<0) { + gslog(LOG_EMERG,"error in processing the msg queue"); + exit(9); + } + gslog(LOG_EMERG,"%s::error:start service returned"); + return 0; +} + diff --git a/src/tools/Makefile b/src/tools/Makefile new file mode 100644 index 0000000..500e0b2 --- /dev/null +++ b/src/tools/Makefile @@ -0,0 +1,110 @@ +# ------------------------------------------------ +# Copyright 2014 AT&T Intellectual Property +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ------------------------------------------- + +CC= gcc -O4 -g -I ../../include -D_FILE_OFFSET_BITS=64 + +INCDIR=../../include + +# we need to suppress writable strings warnings on Mac for flex/bison generated C++ code +OS= $(shell uname -s) +ifeq ($(OS),Darwin) + WARN=-Wno-deprecated-writable-strings +endif +ifeq ($(OS),Linux) + WARN=-Wno-write-strings +endif + +all: gdatcat gsprintconsole gsprintconsole_ves gsgdatprint gdat2ascii gsexit gssinksim process_logs ascii2gdat + +install: all + cp gsprintconsole gsprintconsole_ves gsgdatprint gdat2ascii process_logs gsexit ascii2gdat ../../bin/ + +gsgdatprint: gsgdatprint.o ../../lib/libgscphostaux.a ../../lib/libgscphost.a ../../lib/libgscpinterface.a ../../lib/libgscpapp.a + g++ -g -o gsgdatprint gsgdatprint.o -L../../lib -lgscpapp -lgscphostaux -lgscphost -lgscpinterface -lgscplftaaux -lclearinghouse -lgscpaux + +gsgdatprint.o: gsgdatprint.c + + +gsexit: gsexit.o ../../lib/libgscphostaux.a ../../lib/libgscphost.a ../../lib/libgscpinterface.a ../../lib/libgscpapp.a + g++ -g -o gsexit gsexit.o -L../../lib -lgscpapp -lgscphostaux -lgscphost -lgscpinterface -lgscplftaaux -lclearinghouse -lgscpaux + +gsexit.o: gsexit.c + + +gsgdatprint.c: $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +gdat2ascii: gdat2ascii.o ../../lib/libgscphostaux.a ../../lib/libgscpinterface.a + g++ -g -o gdat2ascii gdat2ascii.o -L../../lib -lgscphostaux -lgscpinterface -lgscpaux + +gdat2ascii.o: gdat2ascii.c + +gdat2ascii.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +gsprintconsole: gsprintconsole.o ../../lib/libgscphostaux.a ../../lib/libgscphost.a ../../lib/libgscpinterface.a ../../lib/libgscpapp.a + g++ -g -o gsprintconsole gsprintconsole.o -L../../lib -lgscpapp -lgscphostaux -lgscphost -lgscpinterface -lgscplftaaux -lclearinghouse -lgscpaux + +gsprintconsole_ves: gsprintconsole_ves.o ../../lib/libgscphostaux.a ../../lib/libgscphost.a ../../lib/libgscpinterface.a ../../lib/libgscpapp.a + g++ -g -o gsprintconsole_ves gsprintconsole_ves.o -L../../lib -lgscpapp -lgscphostaux -lgscphost -lgscpinterface -lgscplftaaux -lclearinghouse -lgscpaux + +gsprintconsole.o: gsprintconsole.c + +gsprintconsole.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +gsprintconsole_ves.o: gsprintconsole_ves.c + +gsprintconsole_ves.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +gssinksim: gssinksim.o ../../lib/libgscphostaux.a ../../lib/libgscphost.a ../../lib/libgscpinterface.a ../../lib/libgscpapp.a + g++ -g -o gssinksim gssinksim.o -L../../lib -lgscpapp -lgscphostaux -lgscphost -lgscpinterface -lgscplftaaux -lclearinghouse -lgscpaux + +gssinksim.o: gssinksim.c + +gssource: gssource.o + g++ -g -o gssource gssource.o -L../../lib -lgscpaux + +gssource.o: gssource.c + +gdatcat: gdatcat.o + $(CC) -o gdatcat gdatcat.o + +process_logs: process_logs.o xml.tab.o xmllexer.o xml_t.o + g++ -g -o process_logs process_logs.o xml.tab.o xmllexer.o xml_t.o + +xml.tab.o: xml.tab.cc + g++ $(WARN) -g -o xml.tab.o -c xml.tab.cc + +xmllexer.o: xmllexer.cc + g++ $(WARN) -g -o xmllexer.o -c xmllexer.cc + +xml_t.o: xml_t.cc + g++ -g -o xml_t.o -c xml_t.cc + +process_logs.o: process_logs.cc + g++ -g -o process_logs.o -c process_logs.cc + +ascii2gdat: ascii2gdat.o ../../lib/libgscpinterface.a + g++ -g -o ascii2gdat ascii2gdat.o -L../../lib -lgscphostaux -lgscpinterface -lgscpaux + +ascii2gdat.o: ascii2gdat.c + +ascii2gdat.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +gdatcat.o: gdatcat.c + +gdatcat.c : $(INCDIR/gsconfig.h) $(INCDIR/gstypes.h) + +clean: + rm -ff ../../bin/gsprintconsole ../../bin/gsprintconsole_ves ../../bin/gsgdatprint ../../bin/gdat2ascii ../../bin/process_logs ../../bin/gsexit ../../bin/ascii2gdat gsprintconsole gsprintconsole_ves gsgdatprint gdat2ascii gdat2hex process_logs gsexit gssinksim gdatcat ascii2gdat *.o + diff --git a/src/tools/ascii2gdat.c b/src/tools/ascii2gdat.c new file mode 100644 index 0000000..367c652 --- /dev/null +++ b/src/tools/ascii2gdat.c @@ -0,0 +1,268 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <schemaparser.h> +#include "gsconfig.h" +#include "gstypes.h" +#include <math.h> + + +FILE * ifd; +FILE * ofd; +FILE * sfd; + +#define MAX_GDAT_HEADER 10000 + +gs_int8_t buf[2*MAXTUPLESZ]; +gs_int8_t schema_buf[MAX_GDAT_HEADER]; +gs_int8_t header_buf[MAX_GDAT_HEADER]; + + +gs_retval_t read_tuple(gs_uint32_t * sz, gs_sp_t data, gs_int32_t maxlen) { + gs_uint32_t nsz; + static gs_uint32_t read=0; +again: + if (fread(&nsz,sizeof(gs_uint32_t),1,ifd)!=1) { + + exit(0); + } + read=read+sizeof(gs_uint32_t); + *sz=ntohl(nsz); + if ((*sz)>maxlen) { + fprintf(stderr,"INTERNAL ERROR tuple to long for fixed buffer. Tuple sz %u\n", + (*sz)); + *sz=0; + return 0; + } + if (*sz==0) goto again; + if (fread(data,(*sz),1,ifd)!=1) { + fprintf(stderr,"UNEXPECTED END OF FILE. Tried to read tuple of size %u\n", + (*sz)); + exit(0); + } + read=read+*sz; + return 0; +} + +int main(int argc, char** argv) { + gs_schemahandle_t schema; + + gs_uint32_t rsize; + gs_int8_t rbuf[2*MAXTUPLESZ]; + gs_int8_t wbuf[2*MAXTUPLESZ]; + + gs_int32_t numberoffields; + gs_int32_t verbose=0; + gs_int32_t y; + gs_int32_t parserversion; + gs_uint32_t schemalen; + gs_sp_t me; + gs_int32_t ch; + + me=argv[0]; + + if (argc<2) { + fprintf(stderr, + "%s::usage: %s -v -x <schema_file_name> <input_file_name> <output_file_name>\n", + me,me); + exit(1); + } + + while ((ch = getopt(argc, argv, "vx")) != -1) { + switch(ch) { + case 'v': + verbose=1; + break; + case 'x': + verbose=2; + } + } + argc -= optind; + if (argc < 1) { + fprintf(stderr,"%s::usage: %s -v -x <schema_file_name> <input_file_name> <output_file_name>\n", + me,me); + exit(1); + } + argv += optind; + + if ((sfd=fopen(argv[0],"r"))==0) { + fprintf(stderr,"%s::error:could not open schema file %s\n", + me,argv[0]); + exit(1); + } + + schemalen = fread(schema_buf, 1, MAX_GDAT_HEADER, sfd); + schema_buf[schemalen] = 0; + schema = ftaschema_parse_string_prot(schema_buf); + if (schema < 0) { + fprintf(stderr,"%s::error:unable to parse schema file %s\n", + me,argv[0]); + exit(1); + } + fclose(sfd); + + argv++; + + if ((strcmp(argv[0],"-")!=0)&&(strcmp(argv[0],"stdin")!=0)) { + if ((ifd=fopen(argv[0],"r"))==0) { + fprintf(stderr,"%s::error:could not open input file %s\n", + me,argv[0]); + exit(1); + } + } else { + ifd = stdin; + } + + argv++; + + if ((ofd=fopen(argv[0],"wb"))==0) { + fprintf(stderr,"%s::error:could not open output file %s\n", + me,argv[0]); + exit(1); + } + + parserversion = get_schemaparser_version(); + + // write GDAT header + sprintf(header_buf,"GDAT\nVERSION:%u\nSCHEMALENGTH:%lu\n", + parserversion,schemalen+1); + // need to get ASCII version of schema + fwrite(header_buf,strlen(header_buf),1,ofd); + fwrite(schema_buf,schemalen+1,1,ofd); + + ///////////////////////////////////////////// + + + if ((numberoffields=ftaschema_tuple_len(schema))<0) { + fprintf(stderr,"%s::error:could not get number of fields in schema\n", + me); + exit(1); + } + if (verbose==1) { + for(y=0; y<numberoffields;y++) { + printf("%s",ftaschema_field_name(schema,y)); + if (y<numberoffields-1) printf("|"); + } + printf("\n"); + } + + unsigned long long tup_cnt = 0; + + while(!feof(ifd)) { + fgets(rbuf,2*MAXTUPLESZ,ifd); + + gs_uint32_t tuple_pos = ftaschema_get_tuple_metadata_offset(schema) + 1; // position to copy string payload + + char* field = strtok(rbuf, ","); + y = 0; + do { + gs_int32_t field_type = ftaschema_get_field_type_by_index(schema, y); + gs_int32_t field_offset = ftaschema_get_field_offset_by_index(schema, y); + + gs_int32_t i; + gs_uint32_t ui; + gs_uint64_t ul; + gs_uint64_t l; + gs_float_t f,intpart,fractpart; + struct timeval t; + struct vstring32 vs; + struct hfta_ipv6_str ip6; + gs_uint32_t v[8]; + unsigned ip1,ip2,ip3,ip4; + + switch (field_type) { + case BOOL_TYPE: + ui=(strncasecmp("TRUE",field,4)==0); + memcpy(wbuf+field_offset,&ui,sizeof(ui)); + break; + case INT_TYPE: + sscanf(field,"%d",&i); + memcpy(wbuf+field_offset,&i,sizeof(i)); + break; + case UINT_TYPE: + case USHORT_TYPE: + sscanf(field,"%u",&ui); + memcpy(wbuf+field_offset,&ui,sizeof(ui)); + break; + case ULLONG_TYPE: + sscanf(field,"%llu",&ul); + memcpy(wbuf+field_offset,&ul,sizeof(ul)); + break; + case LLONG_TYPE: + sscanf(field,"%ldu",&l); + memcpy(wbuf+field_offset,&l,sizeof(l)); + break; + case FLOAT_TYPE: + sscanf(field,"%f",&f); + memcpy(wbuf+field_offset,&f,sizeof(f)); + break; + case VSTR_TYPE: + { + if (!strcmp(field, " ")) + field[0] = 0; + vs.length = strlen(field); + vs.offset = tuple_pos; + vs.reserved = 0; + memcpy(wbuf+vs.offset, field, vs.length); + memcpy(wbuf+field_offset,&vs,sizeof(vs)); + tuple_pos += vs.length; + } + break; + case IP_TYPE: + sscanf(field,"%u.%u.%u.%u",&ip1,&ip2,&ip3,&ip4); + ui=(ip1<<24)|(ip2<<16)|(ip3<<8)|ip4; + memcpy(wbuf+field_offset,&ui,sizeof(ui)); + break; + case IPV6_TYPE: + sscanf(field,"%x:%x:%x:%x:%x:%x:%x:%x",&v[0],&v[1],&v[2],&v[3],&v[4],&v[5],&v[6],&v[7]); + ip6.v[0]=htonl(v[0]<<16|v[1]); + ip6.v[1]=htonl(v[2]<<16|v[3]); + ip6.v[2]=htonl(v[4]<<16|v[5]); + ip6.v[3]=htonl(v[6]<<16|v[7]); + memcpy(wbuf+field_offset,&ip6,sizeof(ip6)); + break; + case TIMEVAL_TYPE: + sscanf(field,"%lf sec",&f); + fractpart=modf(f,&intpart); + t.tv_sec = intpart; + t.tv_usec = fractpart * 1000000; + memcpy(wbuf+field_offset,&t,sizeof(t)); + break; + default: + break; + } + y++; + field = strtok(NULL, ","); + } while (y < numberoffields); + gs_uint32_t tup_len = htonl(tuple_pos); + fwrite(&tup_len,sizeof(gs_uint32_t),1,ofd); + fwrite(wbuf,tuple_pos,1,ofd); + tup_cnt++; + + if (tup_cnt % 1000000 == 0) + printf("dumped %llu tuples\n", tup_cnt); + } + + fclose(ifd); + fclose(ofd); + if (verbose!=0) fflush(stdout); + + exit(0); +} + diff --git a/src/tools/gdat2ascii.c b/src/tools/gdat2ascii.c new file mode 100644 index 0000000..8381ed0 --- /dev/null +++ b/src/tools/gdat2ascii.c @@ -0,0 +1,275 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <schemaparser.h> +#include "gsconfig.h" +#include "gstypes.h" + +FILE * ifd; + +gs_retval_t read_tuple(gs_uint32_t * sz, gs_sp_t data, gs_int32_t maxlen) { + gs_uint32_t nsz; + static gs_uint32_t read=0; +again: + if (fread(&nsz,sizeof(gs_uint32_t),1,ifd)!=1) { + + exit(0); + } + read=read+sizeof(gs_uint32_t); + *sz=ntohl(nsz); + if ((*sz)>maxlen) { + fprintf(stderr,"INTERNAL ERROR tuple to long for fixed buffer. Tuple sz %u\n", + (*sz)); + *sz=0; + return 0; + } + if (*sz==0) goto again; + if (fread(data,(*sz),1,ifd)!=1) { + fprintf(stderr,"UNEXPECTED END OF FILE. Tryed to read tuple of size %u\n", + (*sz)); + exit(0); + } + read=read+*sz; + return 0; +} + +int main(int argc, char** argv) { + gs_uint32_t streamid; + gs_schemahandle_t schema; + + gs_uint32_t rstreamid; + gs_uint32_t rsize; + gs_int8_t rbuf[2*MAXTUPLESZ]; + + gs_int32_t numberoffields; + gs_int32_t verbose=0; + gs_int32_t truncate=-1; + gs_int32_t y; + gs_int32_t parserversion; + gs_uint32_t schemalen; + gs_sp_t asciischema; + gs_sp_t me; + gs_int32_t ch; + gs_uint32_t scramble =0; + gs_uint32_t schema_only =0; + + /* initialize host library and the sgroup */ + + me=argv[0]; + + if (argc<2) { + fprintf(stderr, + "%s::usage: %s -v -x -t <int> -s <int> <uncompressed_file_name>\n", + me,me); + exit(1); + } + + while ((ch = getopt(argc, argv, "ps:t:vx")) != -1) { + switch(ch) { + case 'p': + schema_only=1; + break; + case 'v': + verbose=1; + break; + case 'x': + verbose=2; + break; + case 't': + truncate=atoi(optarg); + break; + case 's': + sscanf(optarg,"%u",&scramble); + } + } + argc -= optind; + if (argc < 1) { + fprintf(stderr,"%s::usage: %s -v -x -t <int> <uncompressed_file_name>\n", + me,me); + exit(1); + } + argv += optind; + + if ((strcmp(argv[0],"-")!=0)&&(strcmp(argv[0],"stdin")!=0)) { + if ((ifd=fopen(argv[0],"r"))==0) { + fprintf(stderr,"%s::error:could not open input file %s\n", + me,argv[0]); + exit(1); + } + } else { + ifd = stdin; + } + + if (fscanf(ifd,"GDAT\nVERSION:%u\nSCHEMALENGTH:%u\n",&parserversion,&schemalen)!=2) { + fprintf(stderr,"%s::error:unknown file type for file %s\n", + me,argv[0]); + exit(1); + } + + if (schemaparser_accepts_version(parserversion)!=1) { + fprintf(stderr,"%s::error: wrong parser version %u for file %s\n", + me,parserversion,argv[0]); + exit(1); + } + + if ((asciischema=malloc(schemalen))==0) { + fprintf(stderr,"%s::error: could not allocate schema buffer of sz %u " + "for file %s\n", + me,schemalen,argv[0]); + exit(1); + } + + if (fread(asciischema,schemalen,1,ifd)!=1) { + fprintf(stderr,"%s::error: could not read schema buffer of sz %u " + "for file %s\n", + me,schemalen,argv[0]); + exit(1); + } + if (schema_only==1) { + fprintf(stdout,"%s\n",asciischema); + } + if (verbose==2) { + fprintf(stderr,"%s\n",asciischema); + } + if ((schema=ftaschema_parse_string(asciischema))<0) { + fprintf(stderr,"%s::error: could not parse schema " + "for file %s\n", + me,argv[0]); + exit(1); + } + + if ((numberoffields=ftaschema_tuple_len(schema))<0) { + fprintf(stderr,"%s::error:could not get number of fields in schema\n", + me); + exit(1); + } + if (verbose==1) { + for(y=0; y<numberoffields;y++) { + printf("%s",ftaschema_field_name(schema,y)); + if (y<numberoffields-1) printf("|"); + } + printf("\n"); + } + while(read_tuple(&rsize,rbuf,2*MAXTUPLESZ)==0) { + if ((!rsize) || (schema_only==1)) + continue; + for(y=0; y<numberoffields;y++) { + struct access_result ar; + if (verbose==2) + printf("%s->",ftaschema_field_name(schema,y)); + ar=ftaschema_get_field_by_index(schema,y,rbuf,rsize); + switch (ar.field_data_type) { + case INT_TYPE: + printf("%d",ar.r.i); + break; + case UINT_TYPE: + printf("%u",ar.r.ui); + break; + case IP_TYPE: + if (scramble!=0) { + ar.r.ui=gscpbswap32(ar.r.ui^scramble); + } + printf("%u.%u.%u.%u",ar.r.ui>>24&0xff, + ar.r.ui>>16&0xff, + ar.r.ui>>8&0xff, + ar.r.ui&0xff); + break; + case IPV6_TYPE: + { + unsigned x; + unsigned zc=0; + for(x=0;x<4;x++) { if (ar.r.ip6.v[x]==0) zc++;} + if (zc!=4) { + for(x=0;x<8;x++) { + unsigned char * a = (unsigned char *) &(ar.r.ip6.v[0]); + unsigned y; + y=((unsigned)a[2*x])<<8|((unsigned) a[2*x+1]); + printf("%04x",y); + if (x<7) printf(":"); + } + } else { + printf("::"); + } + } + break; + case USHORT_TYPE: + printf("%u",ar.r.ui); + break; + case BOOL_TYPE: + if (ar.r.ui==0) { + printf("FALSE"); + } else { + printf("TRUE"); + } + break; + case ULLONG_TYPE: + { + gs_uint64_t ul; + gs_uint64_t t1; + gs_uint64_t t2; + ul=ar.r.ul; + printf("%llu",ul); + } + break; + case LLONG_TYPE: + printf("%lld",ar.r.l); + break; + case FLOAT_TYPE: + printf("%f",ar.r.f); + break; + case TIMEVAL_TYPE: + { + gs_float_t t; + t= ar.r.t.tv_usec; + t=t/1000000; + t=t+ar.r.t.tv_sec; + printf("%lf sec",t); + } + break; + case VSTR_TYPE: + { + int x; + int c; + char * src; + src=(gs_sp_t)ar.r.vs.offset; + if ((truncate>=0) && (ar.r.vs.length>truncate)) { + ar.r.vs.length=truncate; + } + if ((ar.r.vs.length>0) && (src[ar.r.vs.length-1]==0)) { + ar.r.vs.length = ar.r.vs.length-1; + } + for(x=0;x<ar.r.vs.length;x++) { + c=src[x]; + if (((c<='~') && (c>=' '))&&(c!='|')) { + printf("%c",c); + } else { + printf("(0x%x)",(gs_uint8_t)c); + } + } + } + break; + default: + break; + } + if (y<numberoffields-1) printf("|"); + } + printf("\n"); + if (verbose!=0) fflush(stdout); + } + exit(0); +} + diff --git a/src/tools/gdatcat.c b/src/tools/gdatcat.c new file mode 100644 index 0000000..83e626c --- /dev/null +++ b/src/tools/gdatcat.c @@ -0,0 +1,143 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "gsconfig.h" +#include "gstypes.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <time.h> +#include <unistd.h> + + + +gs_sp_t me = 0; +gs_sp_t schematext = 0; +gs_int32_t schematextlen = 0; +gs_sp_t schematmp = 0; + +static void do_file(gs_sp_t filename, gs_int32_t fnlen); + +int main(int argc, char** argv) { + gs_int32_t x; + gs_int32_t s=1; + gs_int32_t debug=0; + if (strcmp(argv[s],"-d")==0) { + debug=1; + s++; + } + for(x=s;x<argc;x++) { + if (debug) { + fprintf(stderr,"%s\n",argv[x]); + } + do_file(argv[x], strlen(argv[x])); + } + return 0; +} + + +/* + * do_file: dump the file out + */ + +static void do_file(gs_sp_t filename, gs_int32_t fnlen) { + gs_int32_t pipe, parserversion, schemalen; + FILE *input; + gs_int8_t cmd2[4096 + 128]; + static gs_int8_t *dbuf; + size_t sz; + + if (fnlen > 3 && filename[fnlen - 3] == '.' && + filename[fnlen - 2] == 'g' && + filename[fnlen - 1] == 'z') { + pipe = 1; + snprintf(cmd2, sizeof(cmd2), "gzcat %s", filename); + input = popen(cmd2, "r"); + } else { + if (fnlen > 3 && filename[fnlen - 3] == 'b' && + filename[fnlen - 2] == 'z' && + filename[fnlen - 1] == '2') { + pipe = 1; + snprintf(cmd2, sizeof(cmd2), "bzcat %s", filename); + input = popen(cmd2, "r"); + } else { + input = fopen(filename, "r"); + } + } + + if (!input) { + perror("stream open"); + fprintf(stderr, "%s: cannot open %s\n", me, filename); + return; + } + + if (fscanf(input, "GDAT\nVERSION:%u\nSCHEMALENGTH:%u\n", + &parserversion,&schemalen) != 2) { + fprintf(stderr,"%s: cannot parse GDAT file header in '%s'\n", + me, filename); + exit(1); + } + + /* first time ? */ + if (schematext == 0) { + schematextlen = schemalen; + schematext = malloc(schemalen); + dbuf = malloc(CATBLOCKSZ); + if (!schematext || !dbuf) { + fprintf(stderr,"%s: malloc error reading GDAT file header in '%s'\n", + me, filename); + exit(1); + } + if (fread(schematext, schemalen, 1, input) != 1) { + fprintf(stderr,"%s: cannot parse-read GDAT file header in '%s'\n", + me, filename); + exit(1); + } + printf("GDAT\nVERSION:%u\nSCHEMALENGTH:%u\n", parserversion, schemalen); + fwrite(schematext, schemalen, 1, stdout); + } else { + schematmp = malloc(schemalen); + if (!schematmp ) { + fprintf(stderr,"%s: malloc error reading GDAT file header in '%s'\n", + me, filename); + exit(1); + } + if (fread(schematmp, schemalen, 1, input) != 1) { + fprintf(stderr,"%s: cannot parse-read GDAT file header in '%s'\n", + me, filename); + exit(1); + } + free(schematmp); + // if (memcmp(schematext, schematmp, schematextlen)) { + // fprintf(stderr,"%s: GDAT schema mis-match in file '%s'\n", + // me, filename); + // exit(1); + // } + } + + while ((sz = fread(dbuf, 1, CATBLOCKSZ, input)) > 0) { + fwrite(dbuf, 1, sz, stdout); + } + + if (pipe) { + pclose(input); + } else { + fclose(input); + } + +} diff --git a/src/tools/gsexit.c b/src/tools/gsexit.c new file mode 100644 index 0000000..d5ec24c --- /dev/null +++ b/src/tools/gsexit.c @@ -0,0 +1,285 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <app.h> +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <unistd.h> +#include <signal.h> +#include <time.h> +#include <fcntl.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include "errno.h" + + +#include "gsconfig.h" +#include "gstypes.h" +#include "gshub.h" +#include <schemaparser.h> + + + +#define MAXSTRLEN 256 +#define MAXNUMFIELDS 64 +#define BUFSIZE 16*1024*1024 + + +gs_sp_t me; /* saved copy argv[0] */ + +gs_uint32_t socket_desc; +gs_uint32_t verbose=0; +gs_uint32_t parserversion; +gs_uint32_t withtrace=0; + +struct FTA_state { + FTAID fta_id; + gs_schemahandle_t schema; + gs_sp_t asciischema; + gs_int32_t numfields; +}; + +struct FTA_state fs; + +void hand(int iv) { + ftaapp_exit(); + gslog(LOG_NOTICE, "exiting via signal handler %d...\n", iv); + exit(0); +} + +void timeouthand(int iv) { + ftaapp_exit(); + // if (s->verbose!=0) fprintf(stderr, "exiting because of timeout...\n"); + exit(0); +} + + +static void gs_write(gs_sp_t buffer, gs_uint32_t len) +{ + if (send(socket_desc,buffer,len,0) != len) { + gslog(LOG_EMERG,"could not write on stream socket"); + exit(0); + } +} + +static void print_usage_exit(gs_sp_t reason) { + fprintf(stderr, + "%s::error: %s\n" + "%s::usage: %s -v -t -h <gshub-hostname>:<gshub-port> <gsinstance_name> <query_name> <data_sink_name>\n" + , me, reason, me, me); + exit(1); +} + + + + +static void init(gs_int32_t argc, gs_sp_t argv[]) { + void *pblk; + gs_int32_t x, y, schema, pblklen, lcv; + gs_sp_t c; + gs_int8_t name[1024]; + gs_sp_t instance_name; + gs_sp_t data_sink_name; + gs_sp_t query_name; + endpoint gshub; + endpoint data_sink; + endpoint dummyep; + gs_uint32_t tip1,tip2,tip3,tip4; + struct sockaddr_in server; + + if( (argc!=4) ) { + print_usage_exit("Wrong number of paramters"); + } + sprintf(name,"gsexit: %s %s %s %s ",argv[0],argv[1],argv[2],argv[3]); + + gsopenlog(name); + + + if (sscanf(argv[0],"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(gshub.port))!= 5 ) { + gslog(LOG_EMERG,"HUB IP NOT DEFINED"); + exit(1); + } + + gshub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + gshub.port=htons(gshub.port); + instance_name=strdup(argv[1]); + query_name=strdup(argv[2]); + data_sink_name=strdup(argv[3]); + + if (set_hub(gshub)!=0) { + gslog(LOG_EMERG,"Could not set hub"); + exit(1); + } + if (set_instance_name(instance_name)!=0) { + gslog(LOG_EMERG,"Could not set instance name"); + exit(1); + } + + if (get_initinstance(gshub,instance_name,&dummyep,1)!=0) { + gslog(LOG_EMERG,"Did not receive signal that GS is initiated\n"); + } + + if (get_streamsink(gshub,data_sink_name,&data_sink,1) !=0 ) { + gslog(LOG_EMERG,"Could not find data sink"); + exit(0); + } + + if (ftaapp_init(BUFSIZE)!=0) { + gslog(LOG_EMERG,"%s::error:could not initialize gscp\n", me); + exit(1); + } + + signal(SIGTERM, hand); + signal(SIGINT, hand); + signal(SIGPIPE, hand); + + if (verbose!=0) gslog(LOG_DEBUG,"Initializing FTAs\n"); + + pblk = 0; + pblklen = 0; + + fs.fta_id=ftaapp_add_fta(query_name,pblk?0:1,pblk?0:1,0,pblklen,pblk); + if (fs.fta_id.streamid==0){ + gslog(LOG_EMERG,"%s::error:could not initialize fta %s\n", + me,query_name); + exit(1); + } + + if ((c=ftaapp_get_fta_ascii_schema_by_name(query_name))==0){ + gslog(LOG_EMERG,"%s::error:could not get ascii schema for %s\n", + me,query_name); + exit(1); + } + + //ftaapp_get_fta_ascii_schema_by_name uses static buffer so make a copy + fs.asciischema=strdup(c); + + + // Set parser version here + parserversion=get_schemaparser_version(); + + if ((fs.schema=ftaapp_get_fta_schema(fs.fta_id))<0) { + gslog(LOG_EMERG,"%s::error:could not get schema for query\n", + me,query_name); + exit(1); + } + + // Use all available fields + if ((fs.numfields=ftaschema_tuple_len(fs.schema))<0) { + gslog(LOG_EMERG,"%s::error:could not get number of fields for query %s\n", + me,query_name); + exit(1); + } + + // Important that we only open the socket to the data sink AFTER we have subscribed to the output query as it uses it as a signal + + socket_desc = socket(AF_INET , SOCK_STREAM , 0); + if (socket_desc == -1) + { + gslog(LOG_EMERG,"ERROR:could not create socket for data stream"); + exit(0); + } + server.sin_addr.s_addr = data_sink.ip; + server.sin_family = AF_INET; + server.sin_port = data_sink.port; + + if (connect(socket_desc , (struct sockaddr *)&server , sizeof(server)) < 0) + { + gslog(LOG_EMERG,"ERROR: could not open connection to data source"); + exit(0); + } + if (set_streamsubscription(gshub,instance_name,data_sink_name) !=0 ) { + gslog(LOG_EMERG,"Could not announce streamsubscription for exit process"); + exit(0); + } + + +} + + +static void process_data() +{ + gs_uint32_t nsz; + FTAID rfta_id; + gs_uint32_t rsize; + gs_int32_t code; + gs_int8_t rbuf[2*MAXTUPLESZ]; + gs_int8_t topb[1024]; + + + if (verbose!=0) gslog(LOG_INFO,"Getting Data"); + + sprintf(&topb[0],"GDAT\nVERSION:%u\nSCHEMALENGTH:%u\n", + parserversion,(unsigned int)strlen(fs.asciischema)+1); + gs_write(&topb[0],strlen(topb)); + gs_write(fs.asciischema,strlen(fs.asciischema)+1); + + + + while((code=ftaapp_get_tuple(&rfta_id,&rsize,rbuf,2*MAXTUPLESZ,0))>=0) { + nsz=htonl(rsize); + if ((withtrace==0)&&(code==2)) continue; + if (verbose) { + if (ftaschema_is_eof_tuple(fs.schema, rbuf)) { + /* initiate shutdown or something of that nature */ + gslog(LOG_INFO,"gsexit::All data proccessed\n"); + } + } + gs_write((gs_sp_t)&nsz,sizeof(gs_uint32_t)); + gs_write(rbuf,rsize); + } +} + + + +int main(int argc, char** argv) { + gs_int32_t ch; + me = argv[0]; + + while ((ch = getopt(argc, argv, "hvt")) != -1) { + switch(ch) { + case 'h': + print_usage_exit("help"); + break; + case 'v': + verbose=1; + break; + case 't': + withtrace=1; + break; + default: + break; + } + } + + argc -= optind; + argv += optind; + + /* initialize host library and the sgroup */ + + if (argc<=1) { + print_usage_exit("Not enough arguments"); + } + + init(argc, argv); + + process_data(); + + gslog(LOG_EMERG,"%s::internal error reached unexpected end", me); +} + diff --git a/src/tools/gsgdatprint.c b/src/tools/gsgdatprint.c new file mode 100644 index 0000000..baf64ac --- /dev/null +++ b/src/tools/gsgdatprint.c @@ -0,0 +1,580 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <app.h> +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <unistd.h> +#include <signal.h> +#include <time.h> +#include <string.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> + +#include "gsconfig.h" +#include "gstypes.h" +#include <schemaparser.h> +#include <gshub.h> + +#define MAXSTRLEN 256 +#define MAXNUMFIELDS 64 + +//#define GSBZIP2 + +#ifdef GSBZIP2 +#include "bzlib.h" +#endif + +#ifdef ZLIB +#include "zlib.h" +#endif + +gs_sp_t me; /* saved copy argv[0] */ + +struct FTA_state { + FTAID fta_id; + gs_schemahandle_t schema; + gs_sp_t asciischema; + gs_int32_t numfields; + gs_int32_t timefieldoffset; +}; + +struct gsasciiprint_state { + // configuration state + gs_uint32_t bufsz; + gs_int32_t stream; + gs_int32_t flush; + gs_int32_t parserversion; + gs_int32_t compressed; + gs_int32_t verbose; + gs_int32_t notemp; + gs_sp_t timefield; + gs_int32_t interval; + gs_int32_t quitcnt; + gs_int32_t quittime; + gs_int32_t numfields; + gs_sp_t extension; + gs_sp_t query; + gs_int32_t remote_print; + + + // runtime state + struct FTA_state fs; +}; + + +void hand(int iv) { + ftaapp_exit(); + gslog(LOG_NOTICE, "exiting via signal handler %d...\n", iv); + exit(0); +} + +void timeouthand(int iv) { + ftaapp_exit(); + // if (s->verbose!=0) fprintf(stderr, "exiting because of timeout...\n"); + exit(0); +} + + +static void print_usage_exit(gs_sp_t reason) { + fprintf(stderr, + "%s::error: %s\n" + "%s::usage: %s -r <int> -v -f -s -z -c <int> -q <int> -b <field> -t <int> -e <string> <gshub-hostname>:<gshub-port> <gsinstance_name> <query_name> <parameters>\n" + "\t-v makes output verbose\n" + "\t-f flushes each tuple individually\n" + "\t-h <int> print within the hfta int identifies how many output streams based on the SubInterface field\n" + "\t-r sets the ringbuffer size default is 8MB\n" + "\t-s uses %s in streaming mode cannot be used with -v -z -b -t -e\n" + "\t-c <int> indicates that %s should terminate after <int> tuples.\n" + "\t-q <int> indicates that %s should terminate after <int> seconds.\n" + "\t-z the output is compressed with gzip \n" + "\t-b <field> identifies the field which is increasing and is used to\n" + "\t\tbin output files. Field has to be of type uint.\n" + "\t\tThe default is the UNIX system time\n" + "\t-t <int> specifies the number the <field> specified with -b\n" + "\t\thas to increase before a new output file is used\n" + "\t\tthe default is 60 for 1 minute if the default UNIX time is used\n" + "\t-e <string> identifies the file string extension used for the \n" + "\t\toutput file. The output file always starts with the current value\n" + "\t\tof the b field (or UNIX time) the default extension is .txt \n" + "\t\twithout the -z option and .txt.gz with the -z option\n" + "\t<query_name> specifies the query which will be\n" + "\t\t instanciated.\n" + "\t<parameters> sets the parameters for the query\n" + , me, reason, me, me, me,me,me); + exit(1); +} + + + + +static void init(gs_int32_t argc, gs_sp_t argv[], struct gsasciiprint_state *s) { + void *pblk; + gs_int32_t x, y, schema, pblklen, lcv; + gs_int32_t n_actual_param; + gs_int32_t n_expected_param; + gs_sp_t c; + gs_int8_t name[1024]; + + sprintf(name,"gsgdatprint:%s",argv[0]); + + gsopenlog(name); + + + if (s->verbose!=0) gslog(LOG_DEBUG,"Initializing gscp\n"); + if (ftaapp_init(s->bufsz)!=0) { + gslog(LOG_EMERG,"%s::error:could not initialize gscp\n", me); + exit(1); + } + + signal(SIGTERM, hand); + signal(SIGINT, hand); + signal(SIGPIPE, hand); + + if (s->verbose!=0) gslog(LOG_DEBUG,"Initializing FTAs\n"); + + schema = ftaapp_get_fta_schema_by_name(argv[0]); + if (schema < 0) { + gslog(LOG_EMERG,"%s::error:can't get fta '%s' schema\n", me ,argv[0]); + exit(1); + } + n_expected_param = ftaschema_parameter_len(schema); + if (n_expected_param == 0) { + pblk = 0; + pblklen = 0; + if (s->verbose) gslog(LOG_DEBUG,"[query does not have any params]\n"); + } else { + n_actual_param = argc-1; + if(n_actual_param < n_expected_param){ + gslog(LOG_EMERG,"Error, %d query parameters expected, %d provided.\n",n_expected_param, n_actual_param); + exit(1); + } + /* parse the params */ + for (lcv = 1 ; lcv < argc ; lcv++) { + char *k, *e; + int rv; + k = argv[lcv]; + e = k; + while (*e && *e != '=') e++; + if (*e == 0) { + gslog(LOG_EMERG,"param parse error '%s' (fmt 'key=val')\n", + argv[lcv]); + exit(1); + } + *e = 0; + rv = ftaschema_setparam_by_name(schema, k, e+1, strlen(e+1)); + *e = '='; + if (rv < 0) { + gslog(LOG_EMERG,"param setparam error '%s' (fmt 'key=val')\n", + argv[lcv]); + exit(1); + } + } + if (ftaschema_create_param_block(schema, &pblk, &pblklen) < 0) { + gslog(LOG_EMERG, "ftaschema_create_param_block failed!\n"); + exit(1); + } + } + ftaschema_free(schema); /* XXXCDC */ + + + if (s->remote_print>=0) { + s->fs.fta_id=ftaapp_add_fta_print(s->query,pblk?0:1,pblk?0:1,0,pblklen,pblk,"./data",s->extension,s->timefield,"SubInterface",s->interval,s->remote_print); + if (s->fs.fta_id.streamid==0){ + gslog(LOG_EMERG,"%s::error:could not initialize fta_print %s\n", + me,s->query); + exit(1); + } + again: + // wait forever + sleep(60); + goto again; + } + + + s->fs.fta_id=ftaapp_add_fta(s->query,pblk?0:1,pblk?0:1,0,pblklen,pblk); + if (s->fs.fta_id.streamid==0){ + gslog(LOG_EMERG,"%s::error:could not initialize fta %s\n", + me,s->query); + exit(1); + } + /* XXXCDC: pblk is malloc'd, should we free it? */ + + if ((c=ftaapp_get_fta_ascii_schema_by_name(s->query))==0){ + gslog(LOG_EMERG,"%s::error:could not get ascii schema for %s\n", + me,s->query); + exit(1); + } + + //ftaapp_get_fta_ascii_schema_by_name uses static buffer so make a copy + s->fs.asciischema=strdup(c); + + + // Set parser version here + s->parserversion=get_schemaparser_version(); + + if ((s->fs.schema=ftaapp_get_fta_schema(s->fs.fta_id))<0) { + gslog(LOG_EMERG,"%s::error:could not get schema for query\n", + me,s->query); + exit(1); + } + + // Use all available fields + if ((s->fs.numfields=ftaschema_tuple_len(s->fs.schema))<0) { + gslog(LOG_EMERG,"%s::error:could not get number of fields for query %s\n", + me,s->query); + exit(1); + } + if (s->timefield!=0) { + if ((s->fs.timefieldoffset=ftaschema_get_field_offset_by_name( + s->fs.schema,s->timefield))<0) { + gslog(LOG_EMERG,"%s::error:could not get " + "offset for timefield %s in query %s\n", + me,s->timefield,s->query); + exit(1); + } + + if (ftaschema_get_field_type_by_name( + s->fs.schema,s->timefield)!=UINT_TYPE) { + gslog(LOG_EMERG,"%s::error: illegal type for timefield " + "%s in query %s UINT expected\n", + me,s->timefield,s->query); + exit(1); + } + } +} + + +static void process_data(struct gsasciiprint_state *s) +{ + gs_int32_t x; + gs_int32_t y; + gs_int32_t z; + gs_int32_t tb; + gs_uint32_t nsz; + FTAID rfta_id; + gs_uint32_t rsize; + gs_int8_t rbuf[2*MAXTUPLESZ]; + gs_int32_t problem; + + gs_int32_t ctb=0; + gs_int8_t fname[1024]; + gs_int8_t tmpname[1024]; + gs_int8_t command[1024]; + gs_int8_t topb[1024]; + gs_int32_t rcnt=0; + gs_retval_t code; +#ifdef GSBZIP2 + int bzerror; + BZFILE * b; + int abandon=0; + unsigned int bytes_in; + unsigned int bytes_out; +#endif +#ifdef ZLIB + gzFile of=0; +#else + FILE * of=0; +#endif + + + tmpname[0]=0; + + if (s->verbose!=0) gslog(LOG_INFO,"Getting Data for %s",s->query); + + sprintf(&topb[0],"GDAT\nVERSION:%u\nSCHEMALENGTH:%lu\n", + s->parserversion,strlen(s->fs.asciischema)+1); + if (s->stream!=0) { + of=stdout; + // need to get ASCII version of schema + fwrite(&topb[0],strlen(topb),1,of); + fwrite(s->fs.asciischema,strlen(s->fs.asciischema)+1,1,of); + } + + if (s->quittime !=0 ) { + signal(SIGALRM,timeouthand); + alarm(s->quittime); + } + + + while((code=ftaapp_get_tuple(&rfta_id,&rsize,rbuf,2*MAXTUPLESZ,0))>=0) { + rcnt++; + if ((s->notemp==1) && (code==2)) continue; + if (((s->quitcnt>0) && (rcnt>s->quitcnt))||ftaschema_is_eof_tuple(s->fs.schema, rbuf)) { + if (s->verbose!=0) + gslog(LOG_EMERG, "exiting reached tuple limit or all data has been proccessed\n"); + if (of!=0) { + fclose(of); + + if (s->compressed) { + system(command); + } + rename(tmpname,fname); + } + exit(0); + } + if (((code==0) || (code==2))&&(s->fs.fta_id.streamid==rfta_id.streamid)) { + if (s->stream==0) { + if (s->timefield!=0) { + tb=fta_unpack_uint(rbuf, + rsize, + s->fs.timefieldoffset, + &problem); + } else { + tb=time(0); + } + if ((ctb+s->interval)<=tb) { + gsstats(); + if (of!=0) { +#ifdef GSBZIP2 + BZ2_bzWriteClose(&bzerror, b, abandon, &bytes_in, &bytes_out ); + if (bzerror!=BZ_OK) { + gslog(LOG_EMERG,"Could not bz close file .. EXITING\n"); + exit(0); + } +#endif +#ifdef ZLIB + gzclose(of); +#else + fclose(of); +#endif +#ifndef GSBZIP2 + if (s->compressed) { + system(command); + } +#endif + rename(tmpname,fname); + } + while((ctb+s->interval)<=tb) { + if (ctb==0) { + ctb=(tb/s->interval)*s->interval; + } else { + ctb=ctb+s->interval; + } + } +#ifdef ZLIB + sprintf(tmpname,"%u%s.gz.tmp",ctb,s->extension); + sprintf(fname,"%u%s.gz",ctb,s->extension); +#else + sprintf(tmpname,"%u%s.tmp",ctb,s->extension); + sprintf(fname,"%u%s",ctb,s->extension); +#endif +#ifndef GSBZIP2 + if (s->compressed) { + sprintf(command,"gzip -S .tmpgz %s ; mv %s.tmpgz %s",tmpname,tmpname,tmpname); + } +#endif +#ifdef ZLIB + if ((of=gzopen(tmpname,"wb"))==0) { + gslog(LOG_EMERG,"Could not open file \"%s\".. EXITING\n", + tmpname); + exit(0); + } +#else + if ((of=fopen(tmpname,"w"))==0) { + gslog(LOG_EMERG,"Could not open file \"%s\".. EXITING\n", + tmpname); + exit(0); + } +#endif +#ifdef GSBZIP2 + if (s->compressed) { + b=BZ2_bzWriteOpen(&bzerror,of,5,0,30); + if (bzerror!=BZ_OK) { + gslog(LOG_EMERG,"Could not bz open file \"%s\".. EXITING\n", + tmpname); + exit(0); + } + } +#endif + + if (s->compressed) { +#ifdef GSBZIP2 + BZ2_bzWrite ( &bzerror, b, &topb[0],strlen(topb)); + BZ2_bzWrite ( &bzerror, b, s->fs.asciischema,strlen(s->fs.asciischema)+1); +#endif + } else { + // need to get ASCII version of schema +#ifdef ZLIB + gzwrite(of,&topb[0],strlen(topb)); + gzwrite(of,s->fs.asciischema,strlen(s->fs.asciischema)+1); +#else + fwrite(&topb[0],strlen(topb),1,of); + fwrite(s->fs.asciischema,strlen(s->fs.asciischema)+1,1,of); +#endif + } + } + } + if (code==0) { + nsz=htonl(rsize); + if (s->compressed) { +#ifdef GSBZIP2 + BZ2_bzWrite ( &bzerror, b,&nsz,sizeof(gs_uint32_t) ); + BZ2_bzWrite ( &bzerror, b,rbuf,rsize); +#endif + } else { +#ifdef ZLIB + gzwrite(of,&nsz,sizeof(gs_uint32_t)); + gzwrite(of,rbuf,rsize); + } +#else + if (fwrite(&nsz,sizeof(gs_uint32_t),1,of)!=1) { + ftaapp_exit(); + if (s->verbose!=0) + gslog(LOG_EMERG,"Could not write to output\"%s\".. EXITING\n", + tmpname); + exit(0); + } + + if (fwrite(rbuf,rsize,1,of)!=1) { + ftaapp_exit(); + if (s->verbose!=0) + gslog(LOG_EMERG,"Could not write to output\"%s\".. EXITING\n", + tmpname); + exit(0); + } + if ((s->stream!=0) || (s->flush!=0)) { + fflush(of); + } + } +#endif + } + } +} +} + + + +int main(int argc, char** argv) { + + struct gsasciiprint_state s; + gs_retval_t ch; + endpoint gshub; + endpoint dummyep; + gs_uint32_t tip1,tip2,tip3,tip4; + gs_sp_t instance_name; + + me = argv[0]; + + /* initialize host library and the sgroup */ + + if (argc<=1) { + print_usage_exit("Not enough arguments"); + } + + /* parse args */ + bzero(&s, sizeof(s)); + s.interval = 60; /* default */ + s.quittime=0; + s.quitcnt=-1; + s.remote_print=-1; + s.bufsz=8*1024*1024; + + while ((ch = getopt(argc, argv, "nr:b:e:t:c:q:sfvzmh:")) != -1) { + switch(ch) { + case 'r': + s.bufsz=atoi(optarg); + break; + case 'c': + s.quitcnt = atoi(optarg); + break; + case 'q': + s.quittime = atoi(optarg); + break; + case 'b': + s.timefield = optarg; + break; + case 'e': + s.extension = optarg; + break; + case 'n': + s.notemp=1; + break; + case 't': + s.interval = atoi(optarg); + if (s.interval < 1) { + goto usage; + } + break; + case 's': + s.stream++; + break; + case 'f': + s.flush++; + break; + case 'v': + s.verbose++; + break; + case 'z': + s.compressed++; + break; + case 'h': + s.remote_print=atoi(optarg); + break; + default: + usage: + print_usage_exit("invalid args"); + } + } + + if ((s.stream!=0) & (s.compressed!=0 | s.verbose!=0 | + s.timefield!=0 | s.extension!=0)) { + print_usage_exit("illegal argument combination with -s"); + } + + if (!s.extension) { + s.extension = (s.compressed) ? ".txt.gz" : ".txt"; + } + + argc -= optind; + argv += optind; + if (argc<3) print_usage_exit("must specify hub info and query"); + + if (sscanf(argv[0],"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(gshub.port))!= 5 ) { + gslog(LOG_EMERG,"HUB IP NOT DEFINED"); + exit(1); + } + gshub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + gshub.port=htons(gshub.port); + instance_name=strdup(argv[1]); + if (set_hub(gshub)!=0) { + gslog(LOG_EMERG,"Could not set hub"); + exit(1); + } + if (set_instance_name(instance_name)!=0) { + gslog(LOG_EMERG,"Could not set instance name"); + exit(1); + } + + if (get_initinstance(gshub,instance_name,&dummyep,1)!=0) { + gslog(LOG_EMERG,"Did not receive signal that GS is initiated\n"); + } + + + argc -=2; + argv +=2; + + s.query = argv[0]; + + init(argc, argv, &s); + + process_data(&s); + + gslog(LOG_EMERG,"%s::internal error reached unexpected end", me); +} + diff --git a/src/tools/gsprintconsole.c b/src/tools/gsprintconsole.c new file mode 100644 index 0000000..4b18ab5 --- /dev/null +++ b/src/tools/gsprintconsole.c @@ -0,0 +1,454 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <app.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <signal.h> +#include <time.h> +#include <string.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> + + +#include "gsconfig.h" +#include "gstypes.h" +#include "gshub.h" + +#include <schemaparser.h> + +#define MAXLINE 100000 +static unsigned tcpport=0; +static char linebuf[MAXLINE]; +int listensockfd=0; +int fd=0; + + +// Not all systems have timersub defined so make sure its ther +#ifndef timersub + +#define timersub(tvp, uvp, vvp) \ +do { \ +(vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec; \ +(vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec; \ +if ((vvp)->tv_usec < 0) { \ +(vvp)->tv_sec--; \ +(vvp)->tv_usec += 1000000; \ +} \ +} while (0) + +#endif + +void hand(int iv) { + ftaapp_exit(); + fprintf(stderr, "exiting via signal handler %d...\n", iv); + exit(1); +} + +static void wait_for_client() { + struct sockaddr_in serv_addr,cli_addr; + socklen_t clilen; + if (listensockfd==0) { + gs_int32_t on = 1; + listensockfd=socket(AF_INET, SOCK_STREAM, 0); + if (listensockfd < 0) { + gslog(LOG_EMERG,"Error:Could not create socket for tcp data stream"); + exit(1); + } + bzero((char *) &serv_addr, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = INADDR_ANY; + serv_addr.sin_port = htons(tcpport); +#ifndef __linux__ + /* make sure we can reuse the common port rapidly */ + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEPORT, + (gs_sp_t )&on, sizeof(on)) != 0) { + gslog(LOG_EMERG,"Error::could not set socket option\n"); + exit(1); + } +#endif + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEADDR, + (gs_sp_t )&on, sizeof(on)) != 0) { + gslog(LOG_EMERG,"Error::could not set socket option\n"); + exit(1); + } + + if (bind(listensockfd, (struct sockaddr *) &serv_addr, + sizeof(serv_addr)) < 0) { + gslog(LOG_EMERG,"Error:Could not bind socket for tcp data stream"); + exit(1); + } + } + + do { + listen(listensockfd,5); + clilen = sizeof(cli_addr); + fd=accept(listensockfd, (struct sockaddr *) &cli_addr, &clilen); + if (fd<0) { + gslog(LOG_EMERG,"Error:Could not accept connection on tcp socket"); + } + } while (fd==0); +} + + +static void emit_socket() { + unsigned o,w,l; + o=0; + w=0; + l=strlen(linebuf); + do { + if((w=write(fd,&linebuf[o],l))==0) { + close(fd); + wait_for_client(); + } + o=o+w; + } while (o<l); +} + +static void emit_line() { + + if (tcpport==0) { + printf("%s",linebuf); + } else { + emit_socket(); + } + +} + +int main(int argc, char* argv[]) { + gs_sp_t me = argv[0]; + FTAID fta_id; + gs_int32_t schema, ch; + + FTAID rfta_id; + gs_uint32_t rsize; + gs_uint32_t bufsz=8*1024*1024; + gs_int8_t rbuf[2*MAXTUPLESZ]; + + gs_int32_t numberoffields; + gs_int32_t verbose=0; + gs_int32_t y, lcv; + + void *pblk; + gs_int32_t pblklen; + gs_int32_t n_actual_param; + gs_int32_t n_expected_param; + gs_int32_t xit = 0; + gs_int32_t dump = 0; + struct timeval tvs, tve, tvd; + gs_retval_t code; + endpoint gshub; + endpoint dummyep; + gs_uint32_t tip1,tip2,tip3,tip4; + gs_sp_t instance_name; + + gs_uint32_t tlimit = 0; // time limit in seconds + time_t start_time, curr_time; + + gsopenlog(argv[0]); + + + while ((ch = getopt(argc, argv, "l:p:r:vXD")) != -1) { + switch (ch) { + case 'r': + bufsz=atoi(optarg); + break; + case 'p': + tcpport=atoi(optarg); + break; + case 'v': + verbose++; + break; + case 'X': + xit++; + break; + case 'D': + dump++; + break; + case 'l': + tlimit = atoi(optarg); + break; + default: + usage: + fprintf(stderr, "usage: %s [-r <bufsz>] [-p <port>] [-l <time_limit>] [-v] [-X] [-D] <gshub-hostname>:<gshub-port> <gsinstance_name> query param1 param2...\n", + *argv); + exit(1); + } + } + argc -= optind; + argv += optind; + if (argc<3) goto usage; + + if (sscanf(argv[0],"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(gshub.port))!= 5 ) { + gslog(LOG_EMERG,"HUB IP NOT DEFINED"); + exit(1); + } + gshub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + gshub.port=htons(gshub.port); + instance_name=strdup(argv[1]); + if (set_hub(gshub)!=0) { + gslog(LOG_EMERG,"Could not set hub"); + exit(1); + } + if (set_instance_name(instance_name)!=0) { + gslog(LOG_EMERG,"Could not set instance name"); + exit(1); + } + + if (get_initinstance(gshub,instance_name,&dummyep,1)!=0) { + gslog(LOG_EMERG,"Did not receive signal that GS is initiated\n"); + } + + gettimeofday(&tvs, 0); + argc -=2; + argv +=2; + if (argc < 1) + goto usage; + + /* initialize host library and the sgroup */ + + if (verbose>=2) fprintf(stderr,"Inializin gscp\n"); + + if (ftaapp_init(bufsz)!=0) { + fprintf(stderr,"%s::error:could not initialize gscp\n", me); + exit(1); + } + + signal(SIGTERM, hand); + signal(SIGINT, hand); + + schema = ftaapp_get_fta_schema_by_name(argv[0]); + if (schema < 0) { + fprintf(stderr,"%s::error:could not get fta '%s' schema\n", + me ,argv[0]); + exit(1); + } + n_expected_param = ftaschema_parameter_len(schema); + if (n_expected_param == 0) { + pblk = 0; + pblklen = 0; + } else { + /* parse the params */ + n_actual_param = argc-1; + if(n_actual_param < n_expected_param){ + fprintf(stderr,"Error, %d query parameters expected, %d provided.\n",n_expected_param, n_actual_param); + exit(1); + } + for (lcv = 1 ; lcv < argc ; lcv++) { + char *k, *e; + int rv; + k = argv[lcv]; + e = k; + while (*e && *e != '=') e++; + if (*e == 0) { + fprintf(stderr,"param parse error '%s' (fmt 'key=val')\n", + argv[lcv]); + exit(1); + } + *e = 0; + rv = ftaschema_setparam_by_name(schema, k, e+1, strlen(e+1)); + *e = '='; + if (rv < 0) { + fprintf(stderr,"param setparam error '%s' (fmt 'key=val')\n", + argv[lcv]); + exit(1); + } + } + if (ftaschema_create_param_block(schema, &pblk, &pblklen) < 0) { + fprintf(stderr, "ftaschema_create_param_block failed!\n"); + exit(1); + } + } + ftaschema_free(schema); /* XXXCDC */ + + + if (verbose>=2) fprintf(stderr,"Initalice FTA\n"); + + fta_id=ftaapp_add_fta(argv[0],0,0,0,pblklen,pblk); + if (fta_id.streamid==0) { + fprintf(stderr,"%s::error:could not initialize fta %s\n", + me, argv[0]); + exit(1); + } + /* XXXCDC: pblk is malloc'd, should we free it? */ + + if (verbose>=2) fprintf(stderr,"Get schema handle\n"); + + if ((schema=ftaapp_get_fta_schema(fta_id))<0) { + fprintf(stderr,"%s::error:could not get schema\n", me); + exit(1); + } + + if ((numberoffields=ftaschema_tuple_len(schema))<0) { + fprintf(stderr,"%s::error:could not get number of fields in schema\n", + me); + exit(1); + } + + if (verbose>=1) { + for(y=0; y<numberoffields;y++) { + printf("%s",ftaschema_field_name(schema,y)); + if (y<numberoffields-1) printf("|"); + } + printf("\n"); + } + if (xit) { + gettimeofday(&tve, 0); + timersub(&tve, &tvs, &tvd); + printf("TIME= %ld.%06d sec\n", tvd.tv_sec, tvd.tv_usec); + hand(0); + } + if (tcpport!=0) { + wait_for_client(); + } + + start_time = time(NULL); + + while((code=ftaapp_get_tuple(&rfta_id,&rsize,rbuf,2*MAXTUPLESZ,0))>=0) { + if (dump) + continue; + if (ftaschema_is_eof_tuple(schema, rbuf)) { + /* initiate shutdown or something of that nature */ + printf("#All data proccessed\n"); + exit(0); + } + if (!rsize) + continue; + if (verbose >=2) { + snprintf(linebuf,MAXLINE,"RESULT CODE => %u\n",code); + emit_line(); + } + if ((code==0)&&(rfta_id.streamid == fta_id.streamid)) { + for(y=0; y<numberoffields;y++) { + struct access_result ar; + if (verbose>=2) + printf("%s->",ftaschema_field_name(schema,y)); + ar=ftaschema_get_field_by_index(schema,y,rbuf,rsize); + switch (ar.field_data_type) { + case INT_TYPE: + snprintf(linebuf,MAXLINE,"%d",ar.r.i); + break; + case UINT_TYPE: + snprintf(linebuf,MAXLINE,"%u",ar.r.ui); + break; + case IP_TYPE: + snprintf(linebuf,MAXLINE,"%u.%u.%u.%u",ar.r.ui>>24&0xff, + ar.r.ui>>16&0xff, + ar.r.ui>>8&0xff, + ar.r.ui&0xff); + break; + case IPV6_TYPE: + { + unsigned x; + unsigned zc=0; + for(x=0;x<4;x++) { if (ar.r.ip6.v[x]==0) zc++;} + if (zc!=4) { + snprintf(linebuf,MAXLINE,""); + for(x=0;x<8;x++) { + unsigned char * a = (unsigned char *) &(ar.r.ip6.v[0]); + unsigned y; + y=((unsigned)a[2*x])<<8|((unsigned) a[2*x+1]); + snprintf(&linebuf[strlen(linebuf)],MAXLINE,"%04x",y); + if (x<7) snprintf(&linebuf[strlen(linebuf)],MAXLINE,":"); + } + } else { + snprintf(linebuf,MAXLINE,"::"); + } + } + break; + + case USHORT_TYPE: + snprintf(linebuf,MAXLINE,"%u",ar.r.ui); + break; + case BOOL_TYPE: + if (ar.r.ui==0) { + snprintf(linebuf,MAXLINE,"FALSE"); + } else { + snprintf(linebuf,MAXLINE,"TRUE"); + } + break; + case ULLONG_TYPE: + snprintf(linebuf,MAXLINE,"%llu",ar.r.ul); + break; + case LLONG_TYPE: + snprintf(linebuf,MAXLINE,"%lld",ar.r.l); + break; + case FLOAT_TYPE: + snprintf(linebuf,MAXLINE,"%f",ar.r.f); + break; + case TIMEVAL_TYPE: + { + gs_float_t t; + t= ar.r.t.tv_usec; + t=t/1000000; + t=t+ar.r.t.tv_sec; + snprintf(linebuf,MAXLINE,"%f sec",t); + } + break; + case VSTR_TYPE: + { + int x; + int c; + int d=0; + char * src; + src=(char*)ar.r.vs.offset; + if(d<MAXLINE){ + linebuf[d] = '\0'; + } + for(x=0;x<ar.r.vs.length;x++) { + c=src[x]; + if ((c<='~') && (c>=' ')) { + if (d<MAXLINE-1) { + linebuf[d]=c; + linebuf[d+1]=0; + d++; + } + } else { + if (d<MAXLINE-1) { + linebuf[d]='.'; + linebuf[d+1]=0; + d++; + } + } + } + } + break; + default: + linebuf[0]=0; + break; + } + if (y<numberoffields-1) snprintf(&linebuf[strlen(linebuf)],MAXLINE,"|"); + emit_line(); + } + snprintf(linebuf,MAXLINE,"\n"); + emit_line(); + if (verbose!=0) fflush(stdout); + } else { + if (rfta_id.streamid != fta_id.streamid) + fprintf(stderr,"Got unkown streamid %llu \n",rfta_id.streamid); + } + + // whenever we receive a temp tuple check if we reached time limit + if ((code==2) && tlimit && (time(NULL)-start_time)>=tlimit) { + fprintf(stderr,"Reached time limit of %d seconds\n",tlimit); + ftaapp_exit(); + exit(0); + } + } +} + diff --git a/src/tools/gsprintconsole_ves.c b/src/tools/gsprintconsole_ves.c new file mode 100644 index 0000000..bdaa277 --- /dev/null +++ b/src/tools/gsprintconsole_ves.c @@ -0,0 +1,643 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + +/* + * Print ves formatted records to the console. + * Each line is a json record. + * Based on gsprintconsole.c, just differences in formatting. +*/ + + +#include <app.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <signal.h> +#include <time.h> +#include <string.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> + + +#include "gsconfig.h" +#include "gstypes.h" +#include "gshub.h" +#include "simple_http.h" + +#include <schemaparser.h> + +#define MAXLINE 100000 +static unsigned tcpport=0; +static char linebuf[MAXLINE]; +int listensockfd=0; +int fd=0; + + +// Not all systems have timersub defined so make sure its ther +#ifndef timersub + +#define timersub(tvp, uvp, vvp) \ +do { \ +(vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec; \ +(vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec; \ +if ((vvp)->tv_usec < 0) { \ +(vvp)->tv_sec--; \ +(vvp)->tv_usec += 1000000; \ +} \ +} while (0) + +#endif + +void hand(int iv) { + ftaapp_exit(); + fprintf(stderr, "exiting via signal handler %d...\n", iv); + exit(1); +} + +static void wait_for_client() { + struct sockaddr_in serv_addr,cli_addr; + socklen_t clilen; + if (listensockfd==0) { + gs_int32_t on = 1; + listensockfd=socket(AF_INET, SOCK_STREAM, 0); + if (listensockfd < 0) { + gslog(LOG_EMERG,"Error:Could not create socket for tcp data stream"); + exit(1); + } + bzero((char *) &serv_addr, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = INADDR_ANY; + serv_addr.sin_port = htons(tcpport); +#ifndef __linux__ + /* make sure we can reuse the common port rapidly */ + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEPORT, + (gs_sp_t )&on, sizeof(on)) != 0) { + gslog(LOG_EMERG,"Error::could not set socket option\n"); + exit(1); + } +#endif + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEADDR, + (gs_sp_t )&on, sizeof(on)) != 0) { + gslog(LOG_EMERG,"Error::could not set socket option\n"); + exit(1); + } + + if (bind(listensockfd, (struct sockaddr *) &serv_addr, + sizeof(serv_addr)) < 0) { + gslog(LOG_EMERG,"Error:Could not bind socket for tcp data stream"); + exit(1); + } + } + + do { + listen(listensockfd,5); + clilen = sizeof(cli_addr); + fd=accept(listensockfd, (struct sockaddr *) &cli_addr, &clilen); + if (fd<0) { + gslog(LOG_EMERG,"Error:Could not accept connection on tcp socket"); + } + } while (fd==0); +} + + +static void emit_socket() { + unsigned o,w,l; + o=0; + w=0; + l=strlen(linebuf); + do { + if((w=write(fd,&linebuf[o],l))==0) { + close(fd); + wait_for_client(); + } + o=o+w; + } while (o<l); +} + +static void emit_line() { + + if (tcpport==0) { + printf("%s",linebuf); + } else { + emit_socket(); + } + +} + +int main(int argc, char* argv[]) { + gs_sp_t me = argv[0]; + FTAID fta_id; + gs_int32_t schema, ch; + + FTAID rfta_id; + gs_uint32_t rsize; + gs_uint32_t bufsz=8*1024*1024; + gs_int8_t rbuf[2*MAXTUPLESZ]; + + gs_int32_t numberoffields; + gs_int32_t verbose=0; + gs_int32_t y, lcv; + + void *pblk; + gs_int32_t pblklen; + gs_int32_t n_actual_param; + gs_int32_t n_expected_param; + gs_int32_t xit = 0; + gs_int32_t dump = 0; + struct timeval tvs, tve, tvd; + gs_retval_t code; + endpoint gshub; + endpoint dummyep; + gs_uint32_t tip1,tip2,tip3,tip4; + gs_sp_t instance_name; + + gs_sp_t curl_address = NULL; + endpoint curl_endpoint; + gs_sp_t curl_url = NULL; + gs_sp_t curl_auth = NULL; + gs_uint32_t http_code; + + gs_uint32_t ves_version=5; + + + gs_uint32_t tlimit = 0; // time limit in seconds + time_t start_time, curr_time; + + gsopenlog(argv[0]); + + + while ((ch = getopt(argc, argv, "l:p:r:vXDC:U:A:V:")) != -1) { + switch (ch) { + case 'r': + bufsz=atoi(optarg); + break; + case 'p': + tcpport=atoi(optarg); + break; + case 'v': + verbose++; + break; + case 'X': + xit++; + break; + case 'D': + dump++; + break; + case 'l': + tlimit = atoi(optarg); + break; + case 'V': + ves_version = atoi(optarg); + break; + case 'C': + curl_address = strdup(optarg); + if (sscanf(curl_address,"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(curl_endpoint.port))!= 5 ) { + gslog(LOG_EMERG,"Curl IP NOT DEFINED"); + exit(1); + } + curl_endpoint.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + curl_endpoint.port=htons(curl_endpoint.port); + break; + case 'U': + curl_url = strdup(optarg); + break; + case 'A': + curl_auth = strdup(optarg); + break; + default: + usage: + fprintf(stderr, "usage: %s [-r <bufsz>] [-p <port>] [-l <time_limit>] [-v] [-X] [-D] [-C <curl_dest>:<curl_port>] [-U <curl_url>] [-A <authentication_string>] [-V <ves_version>] <gshub-hostname>:<gshub-port> <gsinstance_name> query param1 param2...\n", + *argv); + exit(1); + } + } + argc -= optind; + argv += optind; + if (argc<3) goto usage; + + if (sscanf(argv[0],"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(gshub.port))!= 5 ) { + gslog(LOG_EMERG,"HUB IP NOT DEFINED"); + exit(1); + } + gshub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + gshub.port=htons(gshub.port); + instance_name=strdup(argv[1]); + if (set_hub(gshub)!=0) { + gslog(LOG_EMERG,"Could not set hub"); + exit(1); + } + if (set_instance_name(instance_name)!=0) { + gslog(LOG_EMERG,"Could not set instance name"); + exit(1); + } + + if (get_initinstance(gshub,instance_name,&dummyep,1)!=0) { + gslog(LOG_EMERG,"Did not receive signal that GS is initiated\n"); + } + + +// If this uses curl output, ensure consistency in the curl args + if(curl_address != NULL){ + if(curl_url == NULL){ + gslog(LOG_EMERG,"Curl IP defined, but there is no url (e.g. /foo/bar"); + exit(1); + } + if(curl_auth==NULL){ + curl_auth = ""; + } + } + + gettimeofday(&tvs, 0); + argc -=2; + argv +=2; + if (argc < 1) + goto usage; + + /* initialize host library and the sgroup */ + + if (verbose>=2) fprintf(stderr,"Initializing gscp\n"); + + if (ftaapp_init(bufsz)!=0) { + fprintf(stderr,"%s::error:could not initialize gscp\n", me); + exit(1); + } + + signal(SIGTERM, hand); + signal(SIGINT, hand); + + schema = ftaapp_get_fta_schema_by_name(argv[0]); + if (schema < 0) { + fprintf(stderr,"%s::error:could not get fta '%s' schema\n", + me ,argv[0]); + exit(1); + } + n_expected_param = ftaschema_parameter_len(schema); + if (n_expected_param == 0) { + pblk = 0; + pblklen = 0; + } else { + n_actual_param = argc-1; + if(n_actual_param < n_expected_param){ + fprintf(stderr,"Error, %d query parameters expected, %d provided.\n",n_expected_param, n_actual_param); + exit(1); + } + /* parse the params */ + for (lcv = 1 ; lcv < argc ; lcv++) { + char *k, *e; + int rv; + k = argv[lcv]; + e = k; + while (*e && *e != '=') e++; + if (*e == 0) { + fprintf(stderr,"param parse error '%s' (fmt 'key=val')\n", + argv[lcv]); + exit(1); + } + *e = 0; + rv = ftaschema_setparam_by_name(schema, k, e+1, strlen(e+1)); + *e = '='; + if (rv < 0) { + fprintf(stderr,"param setparam error '%s' (fmt 'key=val')\n", + argv[lcv]); + exit(1); + } + } + if (ftaschema_create_param_block(schema, &pblk, &pblklen) < 0) { + fprintf(stderr, "ftaschema_create_param_block failed!\n"); + exit(1); + } + } +// ftaschema_free(schema); /* XXXCDC */ // the schema continues to be used + + + if (verbose>=2) fprintf(stderr,"Initalized FTA\n"); + + fta_id=ftaapp_add_fta(argv[0],0,0,0,pblklen,pblk); + if (fta_id.streamid==0) { + fprintf(stderr,"%s::error:could not initialize fta %s\n", + me, argv[0]); + exit(1); + } + /* XXXCDC: pblk is malloc'd, should we free it? */ + + if (verbose>=2) fprintf(stderr,"Get schema handle\n"); + + if ((schema=ftaapp_get_fta_schema(fta_id))<0) { + fprintf(stderr,"%s::error:could not get schema\n", me); + exit(1); + } + + if ((numberoffields=ftaschema_tuple_len(schema))<0) { + fprintf(stderr,"%s::error:could not get number of fields in schema\n", + me); + exit(1); + } + + if (verbose>=1) { + for(y=0; y<numberoffields;y++) { + printf("%s",ftaschema_field_name(schema,y)); + if (y<numberoffields-1) printf("|"); + } + printf("\n"); + } + if (xit) { // -X in command line + gettimeofday(&tve, 0); + timersub(&tve, &tvs, &tvd); + printf("TIME= %ld%06d sec\n", tvd.tv_sec, tvd.tv_usec); + hand(0); // effectively an exit + } + if (tcpport!=0) { + wait_for_client(); + } + + start_time = time(NULL); + + int measurement_interval_pos = -1; // extract measurementInterval if present + char *field_names[numberoffields]; + for(y=0; y<numberoffields;y++) { + field_names[y] = strdup(ftaschema_field_name(schema,y)); + if(strcmp(field_names[y], "measurementInterval")==0) + measurement_interval_pos = y; + } + + + struct timeval tsample; + gettimeofday(&tsample, 0); + char start_ts[100], curr_ts[100]; + sprintf(start_ts,"%ld%06d", tsample.tv_sec, tsample.tv_usec); + + long unsigned int lineno=0; + long unsigned int seqno=0; + unsigned int measurement_interval; + while((code=ftaapp_get_tuple(&rfta_id,&rsize,rbuf,2*MAXTUPLESZ,0))>=0) { + lineno++; + if (dump) // -D in command line + continue; + if (ftaschema_is_eof_tuple(schema, rbuf)) { + /* initiate shutdown or something of that nature */ + printf("#All data proccessed\n"); + exit(0); + } + if (!rsize) + continue; + if (verbose >=2) { + snprintf(linebuf,MAXLINE,"RESULT CODE => %u\n",code); + emit_line(); + } + if ((code==0)&&(rfta_id.streamid == fta_id.streamid)) { + seqno++; + gettimeofday(&tsample, 0); + sprintf(curr_ts,"%ld%06d", tsample.tv_sec, tsample.tv_usec); + int pos; + if(ves_version < 7){ + pos = snprintf(linebuf, MAXLINE, + "{\"event\": { \"commonEventHeader\": { " + "\"domain\": \"measurementsForVfScaling\", " + "\"eventId\": \"%s%u\", " + "\"eventType\": \"%s\", " + "\"eventName\": \"Measurement_MC_%s\", " + "\"lastEpochMicrosec\": %s, " + "\"priority\": \"Normal\", " + "\"reportingEntityName\": \"gs-lite MC\", " + "\"sequence\": %u, " + "\"sourceName\": \"meas_cmpgn_xapp\", " + "\"startEpochMicrosec\": %s, " + "\"version\": 5 " + "}, " + "\"measurementsForVfScalingFields\": { " + "\"additionalFields\": [" + ,argv[0],lineno, argv[0], argv[0], curr_ts, seqno, start_ts + ); + }else{ + pos = snprintf(linebuf, MAXLINE, + "{\"event\": { \"commonEventHeader\": { " + "\"domain\": \"measurement\", " + "\"eventId\": \"%s%u\", " + "\"eventType\": \"%s\", " + "\"eventName\": \"Measurement_MC_%s\", " + "\"lastEpochMicrosec\": %s, " + "\"priority\": \"Normal\", " + "\"reportingEntityName\": \"gs-lite MC\", " + "\"sequence\": %u, " + "\"sourceName\": \"meas_cmpgn_xapp\", " + "\"startEpochMicrosec\": %s, " + "\"version\": \"4.0.1\", " + "\"vesEventListenerVersion\": \"7.0.1\" " + "}, " + "\"measurementFields\": { " + "\"additionalFields\": {" + ,argv[0],lineno, argv[0], argv[0], curr_ts, seqno, start_ts + ); + } + + measurement_interval = 0; + for(y=0; y<numberoffields;y++) { + struct access_result ar; +// if (verbose>=2) +// printf("%s->",ftaschema_field_name(schema,y)); + if(y>0){ + linebuf[pos]=','; + pos++; + } + ar=ftaschema_get_field_by_index(schema,y,rbuf,rsize); + switch (ar.field_data_type) { + case INT_TYPE: + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%d\"}",field_names[y], ar.r.i); + else + pos += snprintf(linebuf+pos,MAXLINE-pos," \"%s\": \"%d\"",field_names[y], ar.r.i); + if(y==measurement_interval_pos) + measurement_interval = (unsigned int)ar.r.i; + break; + case UINT_TYPE: + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%u\"}",field_names[y], ar.r.ui); + else + pos += snprintf(linebuf+pos,MAXLINE-pos," \"%s\": \"%u\"",field_names[y], ar.r.ui); + if(y==measurement_interval_pos) + measurement_interval = (unsigned int)ar.r.ui; + break; + case IP_TYPE: + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%u.%u.%u.%u\"}",field_names[y], ar.r.ui>>24&0xff, + ar.r.ui>>16&0xff, + ar.r.ui>>8&0xff, + ar.r.ui&0xff); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"%u.%u.%u.%u\"",field_names[y], ar.r.ui>>24&0xff, + ar.r.ui>>16&0xff, + ar.r.ui>>8&0xff, + ar.r.ui&0xff); + break; + case IPV6_TYPE: + { + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"",field_names[y]); + else + pos += snprintf(linebuf+pos,MAXLINE-pos," \"%s\": \"",field_names[y]); + unsigned x; + unsigned zc=0; + for(x=0;x<4;x++) { if (ar.r.ip6.v[x]==0) zc++;} + if (zc!=4) { + snprintf(linebuf,MAXLINE,""); + for(x=0;x<8;x++) { + unsigned char * a = (unsigned char *) &(ar.r.ip6.v[0]); + unsigned y; + y=((unsigned)a[2*x])<<8|((unsigned) a[2*x+1]); + pos += snprintf(linebuf+pos,MAXLINE-pos,"%04x",y); + if (x<7){ + pos += snprintf(linebuf+pos,MAXLINE-pos,":"); + } + } + } else { + pos+=snprintf(linebuf+pos,MAXLINE-pos,"::"); + } + if(ves_version < 7) + pos += snprintf(linebuf+pos, MAXLINE-pos,"\"}"); + else + pos += snprintf(linebuf+pos, MAXLINE-pos,"\""); + } + break; + + case USHORT_TYPE: + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%u\"}",field_names[y], ar.r.ui); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"%u\"}",field_names[y], ar.r.ui); + if(y==measurement_interval_pos) + measurement_interval = (unsigned int)ar.r.ui; + break; + case BOOL_TYPE: + if(ves_version < 7){ + if (ar.r.ui==0) { + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"FALSE\"}",field_names[y]); + } else { + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"TRUE\"}",field_names[y]); + } + }else{ + if (ar.r.ui==0) { + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"FALSE\"",field_names[y]); + } else { + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"TRUE\"",field_names[y]); + } + } + break; + case ULLONG_TYPE: + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%llu\"}",field_names[y], ar.r.ul); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"%llu\"",field_names[y], ar.r.ul); + if(y==measurement_interval_pos) + measurement_interval = (unsigned int)ar.r.ul; + break; + case LLONG_TYPE: + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%lld\"}",field_names[y], ar.r.l); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"%lld\"",field_names[y], ar.r.l); + if(y==measurement_interval_pos) + measurement_interval = (unsigned int)ar.r.l; + break; + case FLOAT_TYPE: + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%f\"}",field_names[y], ar.r.f); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"%f\"",field_names[y], ar.r.f); + break; + case TIMEVAL_TYPE: + { + gs_float_t t; + t= ar.r.t.tv_usec; + t=t/1000000; + t=t+ar.r.t.tv_sec; + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"%f\"}",field_names[y], t); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"%f\"",field_names[y], t); + } + break; + case VSTR_TYPE: + { + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"{\"name\": \"%s\", \"value\": \"",field_names[y]); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"%s\": \"",field_names[y]); + int x; + int c; + char * src; + src=(char*)ar.r.vs.offset; + for(x=0;x<ar.r.vs.length;x++){ + c=src[x]; + if ((c<='~') && (c>=' ')) { + if (pos<MAXLINE-1) { + linebuf[pos]=c; + pos++; + } + } else { + if (pos<MAXLINE-1) { + linebuf[pos]='.'; + pos++; + } + } + } + if(ves_version < 7) + pos += snprintf(linebuf+pos,MAXLINE-pos,"\"}"); + else + pos += snprintf(linebuf+pos,MAXLINE-pos,"\""); + } + break; + default: + linebuf[0]=0; + break; + } + } + if(ves_version < 7){ + snprintf(linebuf+pos, MAXLINE-pos, + "], \"measurementInterval\": %u, \"measurementsForVfScalingVersion\": 1" + "}}}\n", measurement_interval + ); + }else{ + snprintf(linebuf+pos, MAXLINE-pos, + "}, \"measurementInterval\": %u, \"measurementFieldsVersion\": \"4.0\"" + "}}}\n", measurement_interval + ); + } + if(curl_address==NULL){ + emit_line(); + }else{ + http_post_request_hdr(curl_endpoint, curl_url, linebuf, &http_code, curl_auth); + if(http_code != 200 && http_code != 202){ + gslog(LOG_WARNING, "http return code is %d\n",http_code); + } + } + if (verbose!=0) fflush(stdout); + } else { + if (rfta_id.streamid != fta_id.streamid) + fprintf(stderr,"Got unkown streamid %llu \n",rfta_id.streamid); + } + + // whenever we receive a temp tuple check if we reached time limit + if ((code==2) && tlimit && (time(NULL)-start_time)>=tlimit) { + fprintf(stderr,"Reached time limit of %d seconds\n",tlimit); + ftaapp_exit(); + exit(0); + } + } +} + diff --git a/src/tools/gssinksim.c b/src/tools/gssinksim.c new file mode 100644 index 0000000..9334ee8 --- /dev/null +++ b/src/tools/gssinksim.c @@ -0,0 +1,404 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <signal.h> +#include <time.h> +#include <string.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> + +#include <schemaparser.h> +#include "gsconfig.h" +#include "gstypes.h" +#include "gshub.h" + +#define MAXLINE 100000 +static unsigned tcpport=0; +static char linebuf[MAXLINE]; +int listensockfd=0; +int fd=0; +gs_int32_t verbose=0; +endpoint hub; +endpoint ds; +gs_sp_t sink_name; + + +static void wait_for_feed() { + struct sockaddr_in serv_addr,cli_addr; + socklen_t clilen; + struct sockaddr_in sin; + socklen_t sin_sz; + if (listensockfd==0) { + gs_int32_t on = 1; + + if (verbose==2) { + fprintf(stderr,"Create listen socket for port %u\n",tcpport); + } + listensockfd=socket(AF_INET, SOCK_STREAM, 0); + if (listensockfd < 0) { + gslog(LOG_EMERG,"Error:Could not create socket for tcp data stream"); + exit(1); + } + bzero((char *) &serv_addr, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = INADDR_ANY; + serv_addr.sin_port = htons(tcpport); +#ifndef __linux__ + /* make sure we can reuse the common port rapidly */ + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEPORT, + (gs_sp_t )&on, sizeof(on)) != 0) { + gslog(LOG_EMERG,"Error::could not set socket option\n"); + exit(1); + } +#endif + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEADDR, + (gs_sp_t )&on, sizeof(on)) != 0) { + gslog(LOG_EMERG,"Error::could not set socket option\n"); + exit(1); + } + + if (bind(listensockfd, (struct sockaddr *) &serv_addr, + sizeof(serv_addr)) < 0) { + gslog(LOG_EMERG,"Error:Could not bind socket for tcp data stream"); + exit(1); + } + } + + if (verbose==2) { + fprintf(stderr,"Socket created waiting for data producer\n"); + } + if (listen(listensockfd,5)< 0) { + fprintf(stderr,"Error::could not listen to socket for port %u \n",ntohs(serv_addr.sin_port)); + close(listensockfd); + exit(1); + } + sin_sz=sizeof(sin); + if (getsockname(listensockfd, (struct sockaddr *) &sin, &sin_sz) < 0) { + fprintf(stderr,"Error::could not get local port number of listen socket\n"); + exit(1); + } + ds.ip=htonl(127<<24|1); + ds.port=sin.sin_port; + if (set_streamsink(hub,sink_name,ds)!=0) { + fprintf(stderr,"Error::could not set sink in GSHUB for %s source name\n",sink_name); + exit(1); + } + + do { + clilen = sizeof(cli_addr); + fd=accept(listensockfd, (struct sockaddr *) &cli_addr, &clilen); + if (fd<0) { + gslog(LOG_EMERG,"Error:Could not accept connection on tcp socket"); + } + } while (fd==0); + if (verbose) { + fprintf(stderr,"Producer found ready to rock!\n"); + } + +} + + +static void gs_read(gs_sp_t buffer, gs_uint32_t length){ + gs_uint32_t used=0; + gs_uint32_t cur; + + while(used < length) { + if (verbose==2) { + fprintf(stderr,"\tread %u out of %u\n",used,length); + } + if ((cur=read(fd,&(buffer[used]),length-used))<=0) { + gslog(LOG_EMERG,"ERROR:could not read data from gdat stream"); + exit(0); + } + used+=cur; + } +} + +static void gs_read_line(gs_sp_t buffer, gs_uint32_t length){ + gs_uint32_t used=0; + gs_uint32_t cur; + + while((used < (length-1)) && ((used==0)|| (buffer[used-1]!='\n'))) { + if ((cur=read(fd,&(buffer[used]),1))<=0) { + gslog(LOG_EMERG,"ERROR:could not read data from gdat stream"); + exit(0); + } + used+=cur; + } + buffer[used]=0; +} + +static gs_uint32_t get_stream_tuple(gs_uint32_t * rsize,gs_sp_t rbuf,gs_uint32_t bufsz){ + + gs_uint32_t nsz,sz; + gs_read((gs_sp_t)&nsz,sizeof(gs_uint32_t)); + sz=ntohl(nsz); + if (sz>MAXTUPLESZ) { + gslog(LOG_EMERG,"Error::Illegal tuple received"); + exit(0); + } + + if (sz>bufsz) { + gslog(LOG_EMERG,"Error::Illegal tuple size received -- to long"); + exit(0); + } + *rsize=sz; + + gs_read(rbuf,(sz)); + return 0; +} + +int main(int argc, char** argv) { + gs_uint32_t streamid; + gs_schemahandle_t schema; + + gs_uint32_t rstreamid; + gs_uint32_t rsize; + gs_int8_t rbuf[2*MAXTUPLESZ]; + + gs_int32_t numberoffields; + gs_int32_t y; + gs_int32_t parserversion; + gs_uint32_t schemalen; + gs_sp_t asciischema; + gs_sp_t me; + gs_int32_t ch; + + gs_int8_t buf[1024]; + gs_uint32_t tip1,tip2,tip3,tip4; + + /* initialize host library and the sgroup */ + + me=argv[0]; + + while ((ch = getopt(argc, argv, "hvxp:")) != -1) { + switch(ch) { + case 'h': + fprintf(stderr,"%s::usage: %s -v -x -p <port> <IP>:<port> <source_name> \n",argv[0],argv[0]); + exit(0); + break; + case 'p': + tcpport=atoi(optarg);; + break; + case 'v': + verbose=1; + break; + case 'x': + verbose=2; + break; + default: + break; + } + } + if (optind+2>argc) { + fprintf(stderr,"Could not find hub and stream source name on command line\n"); + exit(1); + } + if (sscanf(argv[optind],"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(hub.port))!= 5 ) { + fprintf(stderr,"Could not parse hub endpoint\n"); + exit(1); + } + hub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + hub.port=htons(hub.port); + sink_name=strdup(argv[optind+1]); + + wait_for_feed(); + + gs_read_line(buf,1024); + if (strncmp(buf,"GDAT",4)!=0) { + gslog(LOG_EMERG,"ERROR: not a GDAT stream\n"); + exit(0); + } + gs_read_line(buf,1024); + if (sscanf(buf,"VERSION:%u\n",&parserversion)!=1) { + gslog(LOG_EMERG,"ERROR: no GDAT VERSION given\n"); + exit(0); + } + gs_read_line(buf,1024); + if (sscanf(buf,"SCHEMALENGTH:%u\n",&schemalen)!=1) { + gslog(LOG_EMERG,"ERROR: no GDAT SCHEMALENGTH given\n"); + exit(0); + } + + if(verbose==2) { + fprintf (stderr,"GDAT version %u schemalength %u\n",parserversion,schemalen); + } + + if (schemaparser_accepts_version(parserversion)!=1) { + fprintf(stderr,"%s::error: wrong parser version %u for file %s\n", + me,parserversion,argv[0]); + exit(1); + } + + if ((asciischema=malloc(schemalen))==0) { + fprintf(stderr,"%s::error: could not allocate schema buffer of sz %u " + "for file %s\n", + me,schemalen,argv[0]); + exit(1); + } + + if(verbose==2) { + fprintf (stderr,"Reading schema from scocket\n"); + } + + gs_read(asciischema,schemalen); + + if(verbose==2) { + fprintf (stderr,"Received schema\n"); + } + + if (verbose==2) { + fprintf(stderr,"%s\n",asciischema); + } + if ((schema=ftaschema_parse_string(asciischema))<0) { + fprintf(stderr,"%s::error: could not parse schema \n", + me); + exit(1); + } + + if ((numberoffields=ftaschema_tuple_len(schema))<0) { + fprintf(stderr,"%s::error:could not get number of fields in schema\n", + me); + exit(1); + } + if (verbose==1) { + for(y=0; y<numberoffields;y++) { + printf("%s",ftaschema_field_name(schema,y)); + if (y<numberoffields-1) printf("|"); + } + printf("\n"); + } + while(get_stream_tuple(&rsize,rbuf,2*MAXTUPLESZ)==0) { + if (verbose) { + if (ftaschema_is_eof_tuple(schema, rbuf)) { + /* initiate shutdown or something of that nature */ + fprintf(stderr,"%s::All data proccessed\n",me); + } else { + if (ftaschema_is_temporal_tuple(schema, rbuf)) { + /* initiate shutdown or something of that nature */ + fprintf(stderr,"%s:: temporal tuple\n",me); + } else { + fprintf(stderr,"%s:: regular tuple\n",me); + } + } + } + + if ((!rsize) ) + continue; + for(y=0; y<numberoffields;y++) { + struct access_result ar; + if (verbose==2) + printf("%s->",ftaschema_field_name(schema,y)); + ar=ftaschema_get_field_by_index(schema,y,rbuf,rsize); + switch (ar.field_data_type) { + case INT_TYPE: + printf("%d",ar.r.i); + break; + case UINT_TYPE: + printf("%u",ar.r.ui); + break; + case IP_TYPE: + printf("%u.%u.%u.%u",ar.r.ui>>24&0xff, + ar.r.ui>>16&0xff, + ar.r.ui>>8&0xff, + ar.r.ui&0xff); + break; + case IPV6_TYPE: + { + unsigned x; + unsigned zc=0; + for(x=0;x<4;x++) { if (ar.r.ip6.v[x]==0) zc++;} + if (zc!=4) { + for(x=0;x<8;x++) { + unsigned char * a = (unsigned char *) &(ar.r.ip6.v[0]); + unsigned y; + y=((unsigned)a[2*x])<<8|((unsigned) a[2*x+1]); + printf("%04x",y); + if (x<7) printf(":"); + } + } else { + printf("::"); + } + } + break; + case USHORT_TYPE: + printf("%hu",(unsigned short)ar.r.ui); + break; + case BOOL_TYPE: + if (ar.r.ui==0) { + printf("FALSE"); + } else { + printf("TRUE"); + } + break; + case ULLONG_TYPE: + { + gs_uint64_t ul; + gs_uint64_t t1; + gs_uint64_t t2; + ul=ar.r.ul; + printf("%llu",ul); + } + break; + case LLONG_TYPE: + printf("%lld",ar.r.l); + break; + case FLOAT_TYPE: + printf("%f",ar.r.f); + break; + case TIMEVAL_TYPE: + { + gs_float_t t; + t= ar.r.t.tv_usec; + t=t/1000000; + t=t+ar.r.t.tv_sec; + printf("%lf sec",t); + } + break; + case VSTR_TYPE: + { + int x; + int c; + char * src; + src=(gs_sp_t)ar.r.vs.offset; + if ((ar.r.vs.length>0) && (src[ar.r.vs.length-1]==0)) { + ar.r.vs.length = ar.r.vs.length-1; + } + for(x=0;x<ar.r.vs.length;x++) { + c=src[x]; + if (((c<='~') && (c>=' '))&&(c!='|')) { + printf("%c",c); + } else { + printf("(0x%x)",(gs_uint8_t)c); + } + } + } + break; + default: + break; + } + if (y<numberoffields-1) printf("|"); + } + printf("\n"); + if (verbose!=0) fflush(stdout); + } + exit(0); +} + diff --git a/src/tools/gssource.c b/src/tools/gssource.c new file mode 100644 index 0000000..e7adf8f --- /dev/null +++ b/src/tools/gssource.c @@ -0,0 +1,280 @@ +/* ------------------------------------------------ + Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <signal.h> +#include <time.h> +#include <string.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> + +#include "gsconfig.h" +#include "gstypes.h" +#include "gshub.h" + + + + +gs_sp_t me = 0; +gs_sp_t schematext = 0; +gs_int32_t schematextlen = 0; +gs_sp_t schematmp = 0; +gs_int32_t verbose=0; +gs_uint32_t tcpport=0; +int listensockfd=0; +int fd=0; +endpoint hub; +endpoint ds; +gs_sp_t source_name; + +static void gs_write(gs_sp_t buffer, gs_uint32_t len) +{ + if (send(fd,buffer,len,0) != len) { + fprintf(stderr,"could not write on stream socket"); + exit(0); + } +} + +static void wait_for_feed() { + struct sockaddr_in serv_addr,cli_addr; + struct sockaddr_in sin; + socklen_t clilen; + socklen_t sin_sz; + if (listensockfd==0) { + gs_int32_t on = 1; + + if (verbose) { + fprintf(stderr,"Create listen socket for port %u\n",tcpport); + } + listensockfd=socket(AF_INET, SOCK_STREAM, 0); + if (listensockfd < 0) { + fprintf(stderr,"Error:Could not create socket for tcp data stream"); + exit(1); + } + bzero((char *) &serv_addr, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = INADDR_ANY; + serv_addr.sin_port = htons(tcpport); +#ifndef __linux__ + /* make sure we can reuse the common port rapidly */ + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEPORT, + (gs_sp_t )&on, sizeof(on)) != 0) { + fprintf(stderr,"Error::could not set socket option\n"); + exit(1); + } +#endif + if (setsockopt(listensockfd, SOL_SOCKET, SO_REUSEADDR, + (gs_sp_t )&on, sizeof(on)) != 0) { + fprintf(stderr,"Error::could not set socket option\n"); + exit(1); + } + + if (bind(listensockfd, (struct sockaddr *) &serv_addr, + sizeof(serv_addr)) < 0) { + fprintf(stderr,"Error:Could not bind socket for tcp data stream"); + exit(1); + } + } + + if (verbose) { + fprintf(stderr,"Socket created waiting for data producer\n"); + } + if (listen(listensockfd,5)< 0) { + fprintf(stderr,"Error::could not listen to socket for port %u \n",ntohs(serv_addr.sin_port)); + close(listensockfd); + exit(1); + } + sin_sz=sizeof(sin); + if (getsockname(listensockfd, (struct sockaddr *) &sin, &sin_sz) < 0) { + fprintf(stderr,"Error::could not get local port number of listen socket\n"); + exit(1); + } + ds.ip=htonl(127<<24|1); + ds.port=sin.sin_port; + if (set_streamsource(hub,source_name,ds)!=0) { + fprintf(stderr,"Error::could not set source in GSHUB for %s source name\n",source_name); + exit(1); + } + + do { + clilen = sizeof(cli_addr); + fd=accept(listensockfd, (struct sockaddr *) &cli_addr, &clilen); + if (fd<0) { + fprintf(stderr,"Error:Could not accept connection on tcp socket\n"); + } + } while (fd==0); + if (verbose) { + fprintf(stderr,"Sink found ready to rock!\n"); + } + +} + + +static void do_file(gs_sp_t filename, gs_int32_t fnlen); + +int main(int argc, char** argv) { + gs_int32_t x; + gs_int32_t s=0; + gs_int32_t ch; + gs_int32_t endless=0; // repeats files forever + gs_uint32_t tip1,tip2,tip3,tip4; + while ((ch = getopt(argc, argv, "hxep:")) != -1) { + switch(ch) { + case 'h': + fprintf(stderr,"%s::usage: %s -x -v -e -p <portnumber> <IP>:<port> <source_name> <gdatfiles...>\n",argv[0],argv[0]); + exit(0); + break; + case 'p': + tcpport=atoi(optarg);; + break; + case 'v': + verbose=1; + break; + case 'x': + verbose=2; + break; + case 'e': + endless=1; + break; + default: + break; + } + } + s+=optind; + if (s+2>argc) { + fprintf(stderr,"Could not find hub and stream source name on command line\n"); + fprintf(stderr,"%s::usage: %s -x -v -e -p <portnumber> <IP>:<port> <source_name> <gdatfiles...>\n",argv[0],argv[0]); + exit(1); + } + if (sscanf(argv[s],"%u.%u.%u.%u:%hu",&tip1,&tip2,&tip3,&tip4,&(hub.port))!= 5 ) { + fprintf(stderr,"Could not parse hub endpoint\n"); + fprintf(stderr,"%s::usage: %s -x -v -e -p <portnumber> <IP>:<port> <source_name> <gdatfiles...>\n",argv[0],argv[0]); + exit(1); + } + hub.ip=htonl(tip1<<24|tip2<<16|tip3<<8|tip4); + hub.port=htons(hub.port); + source_name=strdup(argv[s+1]); + s+=2; + wait_for_feed(); + do { + for(x=s;x<argc;x++) { + if (verbose) { + fprintf(stderr,"%s\n",argv[x]); + } + do_file(argv[x], strlen(argv[x])); + } + } while (endless !=0); // will run forever if endless option is set + close(fd); // make sure we wait till buffers are empty + return 0; +} + + +/* + * do_file: dump the file out + */ + +static void do_file(gs_sp_t filename, gs_int32_t fnlen) { + gs_int32_t pipe, parserversion, schemalen; + FILE *input; + gs_int8_t cmd2[4096 + 128]; + static gs_int8_t *dbuf; + size_t sz; + + if (fnlen > 3 && filename[fnlen - 3] == '.' && + filename[fnlen - 2] == 'g' && + filename[fnlen - 1] == 'z') { + pipe = 1; + snprintf(cmd2, sizeof(cmd2), "gzcat %s", filename); + input = popen(cmd2, "r"); + } else { + if (fnlen > 3 && filename[fnlen - 3] == 'b' && + filename[fnlen - 2] == 'z' && + filename[fnlen - 1] == '2') { + pipe = 1; + snprintf(cmd2, sizeof(cmd2), "bzcat %s", filename); + input = popen(cmd2, "r"); + } else { + pipe=0; + input = fopen(filename, "r"); + } + } + + if (!input) { + perror("stream open"); + fprintf(stderr, "%s: cannot open %s\n", me, filename); + return; + } + + if (fscanf(input, "GDAT\nVERSION:%u\nSCHEMALENGTH:%u\n", + &parserversion,&schemalen) != 2) { + fprintf(stderr,"%s: cannot parse GDAT file header in '%s'\n", + me, filename); + exit(1); + } + + /* first time ? */ + if (schematext == 0) { + gs_uint8_t buf[1024]; + schematextlen = schemalen; + schematext = malloc(schemalen); + dbuf = malloc(CATBLOCKSZ); + if (!schematext || !dbuf) { + fprintf(stderr,"%s: malloc error reading GDAT file header in '%s'\n", + me, filename); + exit(1); + } + if (fread(schematext, schemalen, 1, input) != 1) { + fprintf(stderr,"%s: cannot parse-read GDAT file header in '%s'\n", + me, filename); + exit(1); + } + sprintf((char *)buf,"GDAT\nVERSION:%u\nSCHEMALENGTH:%u\n", parserversion, schemalen); + gs_write((gs_sp_t)buf,strlen((const char*)buf)); + gs_write(schematext, schemalen); + } else { + schematmp = malloc(schemalen); + if (!schematmp ) { + fprintf(stderr,"%s: malloc error reading GDAT file header in '%s'\n", + me, filename); + exit(1); + } + if (fread(schematmp, schemalen, 1, input) != 1) { + fprintf(stderr,"%s: cannot parse-read GDAT file header in '%s'\n", + me, filename); + exit(1); + } + free(schematmp); + // if (memcmp(schematext, schematmp, schematextlen)) { + // fprintf(stderr,"%s: GDAT schema mis-match in file '%s'\n", + // me, filename); + // exit(1); + // } + } + + while ((sz = fread(dbuf, 1, CATBLOCKSZ, input)) > 0) { + gs_write(dbuf,sz); + } + + if (pipe) { + pclose(input); + } else { + fclose(input); + } + +} diff --git a/src/tools/process_logs.cc b/src/tools/process_logs.cc new file mode 100644 index 0000000..2481813 --- /dev/null +++ b/src/tools/process_logs.cc @@ -0,0 +1,1512 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include<stdio.h> +#include<stdlib.h> + +#include<string.h> +#include<string> +#include<vector> +#include<map> +#include<set> +#include<list> +#include<time.h> +#include <unistd.h> + +#include"xml_t.h" + +#include"qnode.h" + +using namespace std; + +extern int xmlParserparse(void); +extern FILE *xmlParserin; +extern int xmlParserdebug; +xml_t *xml_result; + +int init_discard = 12; + +int rts_load_history_len = 3; +double hist_multiplier = 0.8; +bool uniform_rts_alloc = true; + +#define LINEBUF 1000 +#define SPLITBUF 20 + +double min_hfta_insz = 1000000.0; +double min_hfta_cpu = 0.2; + +double cpu_util_threshold = 0.9; +double crate_hi=.01; // upper bound on collision rate +double crate_lo=.002; // lower bound, increase HT size +double erate_hi=.01; // upper bound on eviction ratemsvii +int htmax = 1000; +double xfer_costs[4] = {.1, .1, .3, 1.0}; + + +int split_string(char *instr,char sep, char **words,int max_words){ + char *loc; + char *str; + int nwords = 0; + + str = instr; + words[nwords++] = str; + while( (loc = strchr(str,sep)) != NULL){ + *loc = '\0'; + str = loc+1; + if(nwords >= max_words){ + fprintf(stderr,"Error in split_string, too many words discovered (max is %d)\n",max_words); + nwords = max_words-1; + } + words[nwords++] = str; + } + + return(nwords); +} + +string int_to_string(int i){ + string ret; + char tmpstr[100]; + sprintf(tmpstr,"%d",i); + ret=tmpstr; + return(ret); +} + + + + + +struct fta_addr{ + int ip; + int port; + int streamid; + + fta_addr(int i, int p, int s){ + ip=i; + port=p; + streamid=s; + } +}; + +struct cmpr_fta_addr{ + bool operator()(fta_addr const &a, fta_addr const &b) const{ + if(a.ip < b.ip) + return true; + if(a.ip > b.ip) + return false; + if(a.port < b.port) + return true; + if(a.port > b.port) + return false; + if(a.streamid < b.streamid) + return true; + return false; + } +}; + +bool cmpr_parallel_idx(const qnode *a, const qnode *b){ + return a->par_index < b->par_index; +} + +struct cpu_info_str{ + int processor_id; + int socket_id; + int core_id; + + double assigned_load; + + cpu_info_str(int p, int s, int c){ + processor_id=p; + socket_id=s; + core_id=c; + assigned_load = 0.0; + } + + string to_csv(){ + char buf[200]; + sprintf(buf,"%d,%d,%d",processor_id,socket_id,core_id); + return string(buf); + } + + int distance_from(cpu_info_str *other){ + if(socket_id != other->socket_id) + return 3; + if(core_id != other->core_id) + return 2; + if(processor_id != other->processor_id) + return 1; + return 0; + } +}; + +bool cmpr_cpu_info(cpu_info_str const *a, cpu_info_str const *b){ + if(a->socket_id < b->socket_id) + return true; + if(a->socket_id > b->socket_id) + return false; + if(a->core_id < b->core_id) + return true; + if(a->core_id > b->core_id) + return false; + if(a->processor_id < b->processor_id) + return true; + return false; +} + + + + +int main(int argc, char **argv){ + int i,j,s; + + time_t now = time(NULL); + tm *now_tm = localtime(&now); + int year=now_tm->tm_year; + + +// Options + string src_dir=""; + string trace_file=""; + string resource_log_file = "resource_log.csv"; + + const char *optstr = "d:r:i:l:m:UNu:s:C:c:E:0:1:2:"; + const char *usage_str = +"Usage: %s [options] trace_file\n" +"\t-d source_directory\n" +"\t-r resource_log_file\n" +"\t-i initial discard from the resource log\n" +"\t-s default interface hash table length.\n" +"\t-l rts load history length\n" +"\t-m rts load history multiplier\n" +"\t-U All rts interface hashes are the same.\n" +"\t-N rts interface hashes are processed independently.\n" +"\t-u max cpu utilization threshold\n" +"\t-C upper bound on collision rate.\n" +"\t-c lower bound on collision rate.\n" +"\t-E upper bound on the eviction rate.\n" +"\t-0 communication cost multiplier for 0-distance processes.\n" +"\t-1 communication cost multiplier for 1-distance processes.\n" +"\t-2 communication cost multiplier for 2-distance processes.\n" +; + + char chopt; + while((chopt = getopt(argc,argv,optstr)) != -1){ + switch(chopt){ + case '0': + xfer_costs[0] = atof(optarg); + if(xfer_costs[0] < 0 || xfer_costs[0] > 1){ + fprintf(stderr,"ERROR, 0-distance xfer costs (%f) must be in [0,1].\n",xfer_costs[0]); + exit(1); + } + break; + case '1': + xfer_costs[1] = atof(optarg); + if(xfer_costs[1] < 0 || xfer_costs[1] > 1){ + fprintf(stderr,"ERROR, 1-distance xfer costs (%f) must be in [0,1].\n",xfer_costs[1]); + exit(1); + } + break; + case '2': + xfer_costs[2] = atof(optarg); + if(xfer_costs[2] < 0 || xfer_costs[2] > 1){ + fprintf(stderr,"ERROR, 2-distance xfer costs (%f) must be in [0,1].\n",xfer_costs[2]); + exit(1); + } + break; + case 'C': + crate_hi = atof(optarg); + if(crate_hi < 0 || crate_hi>1){ + fprintf(stderr,"ERROR, request to set crate_hi to %f\n must be in [0,1].\n",hist_multiplier); + exit(1); + } + break; + case 'c': + crate_lo = atof(optarg); + if(crate_lo < 0 || crate_lo>1){ + fprintf(stderr,"ERROR, request to set crate_lo to %f\n must be in [0,1].\n",hist_multiplier); + exit(1); + } + break; + case 'E': + erate_hi = atof(optarg); + if(erate_hi < 0 || erate_hi>1){ + fprintf(stderr,"ERROR, request to set erate_hi to %f\n must be in [0,1].\n",hist_multiplier); + exit(1); + } + break; + case 's': + htmax = atoi(optarg); + if(htmax <= 0){ + fprintf(stderr,"ERROPR, htmax set to %d, must be positive nonzero.\n",htmax); + exit(1); + } + break; + case 'm': + hist_multiplier = atof(optarg); + if(hist_multiplier <= 0){ + fprintf(stderr,"ERROR, request to set hist_multiplier to %f\n must be positive nonzero.\n",hist_multiplier); + exit(1); + } + break; + case 'u': + cpu_util_threshold = atof(optarg); + if(cpu_util_threshold<=0 || cpu_util_threshold>1){ + fprintf(stderr,"ERROR, cpu_threshold set to %f, must be in (0,1].\n",cpu_util_threshold); + exit(1); + } + break; + case 'U': + uniform_rts_alloc=true; + break; + case 'N': + uniform_rts_alloc=false; + break; + case 'd': + src_dir = optarg; + break; + case 'r': + resource_log_file = optarg; + break; + case 'i': + init_discard = atoi(optarg); + if(init_discard < 0){ + init_discard=0; + fprintf(stderr,"ERROR, atttempting to set init_discard to a negative value (%d), setting to zero.\n",init_discard); + } + break; + case 'l': + rts_load_history_len = atoi(optarg); + if(rts_load_history_len < 0){ + rts_load_history_len=0; + fprintf(stderr,"ERROR, atttempting to set rts_load_history_len to a negative value (%d), setting to zero.\n",rts_load_history_len); + } + break; + case '?': + fprintf(stderr,"Error, argument %c not recognized.\n",optopt); + fprintf(stderr,"%s\n", usage_str); + exit(1); + default: + fprintf(stderr,"Invalid arguments\n"); + fprintf(stderr,"%s\n", usage_str); + exit(1); + } + } + argc -= optind; + argv += optind; + if (argc > 0) + trace_file = argv[0]; + + if(trace_file == ""){ + fprintf(stderr, usage_str, argv[0]); + exit(1); + } + +// for month string-to-int conversion + const char *months_str[12] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}; + map<string, int> month_str_to_int; + for(i=0;i<12;++i) + month_str_to_int[months_str[i]] = i; + + + FILE *qtree_fl = NULL; + string qtree_flname = src_dir + "/" + "qtree.xml"; + string actual_qtree_flname; + if(src_dir != ""){ + qtree_fl = fopen(qtree_flname.c_str(),"r"); + actual_qtree_flname = qtree_flname; + } + if(qtree_fl == NULL){ + qtree_fl = fopen("qtree.xml","r"); + actual_qtree_flname = "qtree.xml"; + } + if(qtree_fl == NULL){ + fprintf(stderr,"ERROR, can't open "); + if(src_dir != ""){ + fprintf(stderr,"%s or ",qtree_flname.c_str()); + } + fprintf(stderr,"qtree.xml, exiting.\n"); + exit(1); + } + + +// Parse the qtree.xml file + xmlParser_setfileinput(qtree_fl); + if(xmlParserparse()){ + fprintf(stderr,"ERROR, could not parse query tree file %s\n",actual_qtree_flname.c_str()); + } + +// Get the lfta, hfta nodes + xml_t *xroot = xml_result; + vector<xml_t *> xqnodes; + xroot->get_roots("HFTA",xqnodes); + xroot->get_roots("LFTA",xqnodes); + + map<string,int> qname_to_idx; + map<string,int> exe_to_idx; + vector<qnode *> qnode_list; + +// Build the qnodes + for(i=0;i<xqnodes.size();++i){ + string qname; + if(xqnodes[i]->get_attrib_val("name",qname)){ +//printf("node type = %s, name=%s\n",xqnodes[i]->name.c_str(),qname.c_str()); + qnode *qn = new qnode(xqnodes[i]->name,qname,init_discard); + for(s=0;s<xqnodes[i]->subtrees.size();++s){ + xml_t *xsub = xqnodes[i]->subtrees[s]; + if(xsub->name == "Field"){ + string fname; + bool nret = xsub->get_attrib_val("name",fname); + string fpos; + bool pret = xsub->get_attrib_val("pos",fpos); + string ftype; + bool tret = xsub->get_attrib_val("type",ftype); + string fmods; + bool mret = xsub->get_attrib_val("mods",fmods); + if(nret && pret && tret){ + field_str *fld = new field_str(fname,atoi(fpos.c_str()),ftype,fmods); + qn->add_field(fld); + }else{ + fprintf(stderr,"---> subtree %d of FTA %s has an malformed field.\n",s,qname.c_str()); + } + } + if(xsub->name == "HtSize"){ + string src; + bool sret = xsub->get_attrib_val("value",src); + if(sret){ + int htsize = atoi(src.c_str()); + if(htsize > 0){ + unsigned int naggrs = 1; // make it power of 2 + unsigned int nones = 0; + while(htsize){ + if(htsize&1) + nones++; + naggrs = naggrs << 1; + htsize = htsize >> 1; + } + if(nones==1) // in case it was already a power of 2. + naggrs/=2; + qn->aggr_tbl_size = naggrs; + }else{ + fprintf(stderr,"---> subtree %d of FTA %s has an invalid HtSize (%s).\n",s,qname.c_str(),src.c_str()); + } + }else{ + fprintf(stderr,"---> subtree %d of FTA %s has an malformed HtSize.\n",s,qname.c_str()); + } + } + if(xsub->name == "ReadsFrom"){ + string src; + bool sret = xsub->get_attrib_val("value",src); + if(sret){ + qn->add_source(src); + }else{ + fprintf(stderr,"---> subtree %d of FTA %s has an malformed ReadsFrom.\n",s,qname.c_str()); + } + } + if(xsub->name == "Interface"){ + string iface; + bool sret = xsub->get_attrib_val("value",iface); + if(sret){ + qn->src_interface = iface; + } + } + if(xsub->name == "FileName"){ + string full_fname; + bool sret = xsub->get_attrib_val("value",full_fname); + if(sret){ + size_t dotpos = full_fname.find_first_of('.'); + if(dotpos != string::npos){ + qn->executable_name = full_fname.substr(0,dotpos); + } + } + } + } + qname_to_idx[qname] = qnode_list.size(); + if(qn->executable_name != "" && qn->executable_name != "rts") + exe_to_idx[qn->executable_name] = qnode_list.size(); + qnode_list.push_back(qn); + }else{ + fprintf(stderr,"---> node type %s, no name.\n",xqnodes[i]->name.c_str()); + } + } + + + bool error = false; + for(i=0;i<qnode_list.size();++i){ + if(qnode_list[i]->qnode_type == "HFTA"){ + for(s=0;s<qnode_list[i]->reads_from.size();++s){ + if(qname_to_idx.count(qnode_list[i]->reads_from[s])>0){ + int src_id = qname_to_idx[qnode_list[i]->reads_from[s]]; + qnode_list[i]->reads_from_idx.push_back(src_id); + qnode_list[src_id]->sources_to_idx.push_back(i); + }else{ + fprintf(stderr,"ERROR, hfta %s reads_from %s, but its not in qtree.xml.\n",qnode_list[i]->name.c_str(),qnode_list[i]->reads_from[s].c_str()); + error = true; + } + } + } + } + + if(error) + exit(1); + +/* + for(i=0;i<qnode_list.size();++i){ + printf("node %s reads_from:",qnode_list[i]->name.c_str()); + for(s=0;s<qnode_list[i]->reads_from.size();++s){ + printf(" %s",qnode_list[i]->reads_from[s].c_str()); + } + printf("\nand sources to:\n"); + for(s=0;s<qnode_list[i]->sources_to_idx.size();++s){ + printf(" %s",qnode_list[qnode_list[i]->sources_to_idx[s]]->name.c_str()); + } + printf("\n\n"); + } +*/ + + string tracefilename = trace_file; + if(src_dir != ""){ + tracefilename = src_dir + "/" + trace_file; + } + FILE *trace_fl = NULL; + if((trace_fl = fopen(tracefilename.c_str(),"r"))==NULL){ + fprintf(stderr,"ERROR, can't open trace file %s\n",tracefilename.c_str()); + exit(1); + } + + map<fta_addr,string, cmpr_fta_addr> qnode_map; + map<int, perf_struct *> rts_perf_map; + map<int, string> rts_iface_map; + map<string, int> pid_iface_map; + + tm time_str; + char inp[LINEBUF],line[LINEBUF],*saveptr; + unsigned int hbeat_ip, hbeat_port, hbeat_index, hbeat_streamid, hbeat_trace_id,hbeat_ntraces; + while(fgets(inp,LINEBUF,trace_fl)){ + +// Try to grab the timestamp + time_t tick; + int pid; + strncpy(line,inp,LINEBUF); + char mon_str[4]; + int mon=0,day,hr,mn,sec; + int nret = sscanf(line,"%c%c%c %d %d:%d:%d",mon_str,mon_str+1,mon_str+2,&day,&hr,&mn,&sec); + if(nret >= 7){ + mon_str[3] = '\0'; + if(month_str_to_int.count(mon_str)>0){ + mon = month_str_to_int[mon_str]; + }else{ + fprintf(stderr,"Warning, %s not recognized as a month string.\n",mon_str); + } + time_str.tm_sec = sec; + time_str.tm_min = mn; + time_str.tm_hour = hr; + time_str.tm_mday = day; + time_str.tm_mon = mon; + time_str.tm_year = year; + tick = mktime(&time_str); +//printf("mon=%d, day=%d, hr=%d, mn=%d, sec=%d, tick=%d\n",mon,day,hr,mn,sec,tick); + } + +// Grab the process ID + strncpy(line,inp,LINEBUF); + int tmp_pid; + pid = -1; + char *segment = strtok_r(line,"[",&saveptr); + if(segment!=NULL){ + segment = strtok_r(NULL,"[",&saveptr); + nret = sscanf(segment,"%d]",&tmp_pid); + if(nret>=1){ + pid=tmp_pid; + } + } + +// Grab address-to-hfta mappings + strncpy(line,inp,LINEBUF); + segment = strtok_r(line,"]",&saveptr); + if(segment != NULL){ + segment = strtok_r(NULL," ",&saveptr); + segment = strtok_r(NULL," ",&saveptr); + } +//printf("segmetn=<%s>, comparison=%d\n",segment,strcmp(segment,"Lookup")); + if(segment!=NULL && strcmp(segment,"Lookup")==0){ + int pos=0; + char fta_name[LINEBUF]; + int ip; + int port; + int index; + int streamid; + int nret = 0; + while(segment != NULL){ +//printf("pos=%d, segment = %s\n",pos, segment); + + if(pos==3){ + strncpy(fta_name,segment,LINEBUF); + } + + if(pos==6) + nret = sscanf(segment,"{ip=%d,port=%d,index=%d,streamid=%d}",&ip,&port,&index,&streamid); + + pos++; + segment = strtok_r(NULL," ",&saveptr); + } + if(nret>0){ +//printf("nret=%d, fta_name=%s,ip=%d,port=%d,index=%d,streamid=%d\n",nret,fta_name,ip,port,index,streamid); + fta_addr addr(ip,port,streamid); + qnode_map[addr] = fta_name; +//printf("Adding fta %s, (%d %d %d) to qnode_map\n",fta_name,addr.ip,addr.port,addr.streamid); + continue; + } + } + if(segment!=NULL && strcmp(segment,"Lfta")==0){ + int pos=0; + char fta_name[LINEBUF]; + int ip; + int port; + int index; + int streamid; + int nret = 0; + while(segment != NULL){ +//printf("pos=%d, segment = %s\n",pos, segment); + + if(pos==1){ + strncpy(fta_name,segment,LINEBUF); + } + + if(pos==4) + nret = sscanf(segment,"{ip=%d,port=%d,index=%d,streamid=%d}",&ip,&port,&index,&streamid); + + pos++; + segment = strtok_r(NULL," ",&saveptr); + } + if(nret>0){ +//printf("nret=%d, fta_name=%s,ip=%d,port=%d,index=%d,streamid=%d\n",nret,fta_name,ip,port,index,streamid); + fta_addr addr(ip,port,streamid); + qnode_map[addr] = fta_name; +//printf("Adding lfta %s, (%d %d %d) to qnode_map\n",fta_name,addr.ip,addr.port,addr.streamid); + continue; + } + } + if(segment!=NULL && strcmp(segment,"Init")==0){ + int pos=0; + string iface = ""; + string keywd = ""; + while(segment != NULL){ + if(pos==1) + keywd = segment; + if(pos==3){ + char *cc; + for(cc=segment;*cc!='\0';++cc){ + if(*cc == '\n'){ + *cc = '\0'; + break; + } + } + iface = segment; + } + pos++; + segment = strtok_r(NULL," ",&saveptr); + } + if(iface!="" && keywd == "LFTAs"){ + rts_perf_map[pid] = new perf_struct(init_discard); + rts_iface_map[pid] = iface; + pid_iface_map[iface] = pid; + } + } + if(segment!=NULL && strcmp(segment,"Heartbeat")==0){ + int pos=0; + int nret=0,nret2=0,nret3=0; + unsigned int tmp_hbeat_ip, tmp_hbeat_port, tmp_hbeat_index, tmp_hbeat_streamid, tmp_hbeat_trace_id,tmp_hbeat_ntraces; + while(segment != NULL){ +//printf("pos=%d, segment = %s\n",pos, segment); + if(pos==4) + nret = sscanf(segment,"{ip=%d,port=%d,index=%d,streamid=%d}",&tmp_hbeat_ip,&tmp_hbeat_port,&tmp_hbeat_index,&tmp_hbeat_streamid); + if(pos==5) + nret2 = sscanf(segment,"trace_id=%d",&tmp_hbeat_trace_id); + if(pos==6) + nret3 = sscanf(segment,"ntrace=%d",&tmp_hbeat_ntraces); + pos++; + segment = strtok_r(NULL," ",&saveptr); + } + if(nret>=4 && nret2 >= 1 && nret3 == 1){ + hbeat_ip = tmp_hbeat_ip; + hbeat_port = tmp_hbeat_port; + hbeat_index = tmp_hbeat_index; + hbeat_streamid = tmp_hbeat_streamid; + hbeat_trace_id = tmp_hbeat_trace_id; + hbeat_ntraces = tmp_hbeat_ntraces; +// printf("ip=%d, port=%d, index=%d, streamid=%d hbeat_trace_id=%d\n",hbeat_ip,hbeat_port,hbeat_index,hbeat_streamid,hbeat_trace_id); + fta_addr hb_addr(hbeat_ip,hbeat_port,tmp_hbeat_streamid); + if(qnode_map.count(hb_addr) == 0){ + hb_addr.streamid = 0; // maybe an hfta? + if(qnode_map.count(hb_addr) == 0){ + hbeat_port = 0; +//printf("Hbeat streamid=%d no match (%d,%d), hbeat_trace_id=%d\n",hbeat_streamid,hbeat_ip,hbeat_port,hbeat_trace_id); + } + } else{ +//printf("Hbeat streamid=%d matches %s, hbeat_trace_id=%d\n",hbeat_streamid,qnode_map[hb_addr].c_str(),hbeat_trace_id); + } + }else{ + printf("Couldn't parse as hearbeat %s\n",inp); + } + } + if(segment!=NULL && strncmp(segment,"trace_id=",8)==0){ + int pos=0; + int nret=0,nret2=0,nret3=0; + unsigned long long int trace_id; + unsigned int tr_pos,tr_ip,tr_port,tr_index,tr_streamid; + unsigned int tr_intup,tr_outtup,tr_outsz,tr_acctup,tr_cycles; + unsigned int tr_evictions,tr_collisions; + double tr_sample; + nret = sscanf(segment,"trace_id=%llu",&trace_id); + while(segment != NULL){ +//printf("pos=%d, segment = %s\n",pos, segment); + if(pos==0) + nret = sscanf(segment,"trace_id=%llu",&trace_id); + if(pos==1) + nret2 = sscanf(segment,"trace[%d].ftaid={ip=%u,port=%u,index=%u,streamid=%u}",&tr_pos,&tr_ip,&tr_port,&tr_index,&tr_streamid); + if(pos==2) + nret3 = sscanf(segment,"fta_stat={in_tuple_cnt=%u,out_tuple_cnt=%u,out_tuple_sz=%u,accepted_tuple_cnt=%u,cycle_cnt=%u,collision_cnt=%u,eviction_cnt=%u,sampling_rate=%lf}", + &tr_intup, &tr_outtup, &tr_outsz, &tr_acctup,&tr_cycles, + &tr_collisions,&tr_evictions,&tr_sample); + pos++; + segment = strtok_r(NULL," ",&saveptr); + } + if(nret>=1 && nret2>=5 && nret3>=7){ + fta_addr tr_addr(tr_ip,tr_port,tr_streamid); + if(qnode_map.count(tr_addr)==0) + tr_addr.streamid = 0; // maybe an hfta? + if(qnode_map.count(tr_addr)>0){ +//printf("Trace idx=%d streamid=%d matches %s, trace_id=%d, hbeat_trace_id=%d\n",tr_pos,tr_streamid,qnode_map[tr_addr].c_str(),trace_id,hbeat_trace_id); + if(tr_pos+1 == hbeat_ntraces){ + string qname = qnode_map[tr_addr]; + int qidx = qname_to_idx[qname]; + if(qnode_list[qidx]->start_tick < 0) + qnode_list[qidx]->start_tick = tick; + if(qnode_list[qidx]->end_tick < tick) + qnode_list[qidx]->end_tick = tick; + qnode_list[qidx]->in_tup += tr_intup; + qnode_list[qidx]->out_tup += tr_outtup; + qnode_list[qidx]->out_sz += tr_outsz; + qnode_list[qidx]->accepted_tup += tr_acctup; + qnode_list[qidx]->cycles += tr_cycles; + qnode_list[qidx]->collisions += tr_collisions; + qnode_list[qidx]->evictions += tr_evictions; + } + } +//else{ +//printf("Trace idx=%d streamid=%d no match (%d,%d), trace_id=%d, hbeat_trace_id=%d\n",tr_pos,tr_streamid,tr_ip,tr_port,trace_id,hbeat_trace_id); +//} + } + } + } + +//printf("qnode_map has %d entries\n",qnode_map.size()); + +// Open and process performance log info, if any. + if(src_dir != ""){ + resource_log_file = src_dir + "/" + resource_log_file; + } + FILE *res_fl = NULL; + if((res_fl = fopen(resource_log_file.c_str(),"r"))==NULL){ + fprintf(stderr,"ERROR, can't open trace file %s\n",resource_log_file.c_str()); + exit(1); + } + + char *flds[SPLITBUF]; + int lineno = 0; + while(fgets(inp,LINEBUF,res_fl)){ + int nflds = split_string(inp,',',flds,SPLITBUF); + lineno++; + if(nflds >= 8){ + int ts = atoi(flds[0]); + string procname = flds[1]; + int pid = atoi(flds[2]); + unsigned long long int utime = atoll(flds[3]); + unsigned long long int stime = atoll(flds[4]); + unsigned long long int vm_size = atoll(flds[5]); + unsigned long long int rss_size = atoll(flds[6]); + int pagesize = atoi(flds[7]); + + if(procname == "rts"){ + if(rts_perf_map.count(pid)>0){ + if(rts_perf_map[pid]->update(ts,utime,stime,vm_size,rss_size)){ + fprintf(stderr,"Resource log file is corrupted, line %d\n",lineno); + exit(1); + } + } + }else{ + if(exe_to_idx.count(procname)>0){ + perf_struct *p = qnode_list[exe_to_idx[procname]]->perf; + if(p->update(ts,utime,stime,vm_size,rss_size)){ + fprintf(stderr,"Resource log file is corrupted, line %d\n",lineno); + exit(1); + } + } + } + } + } + + + + FILE *rpt_fl = fopen("performance_report.csv","w"); + if(rpt_fl == NULL){ + fprintf(stderr,"Warning, can't open performance_report.csv, can't save the performance report.\n"); + } + + char tmpstr[10000]; + printf("Performance report:\n"); + if(rpt_fl) fprintf(rpt_fl,"query_name,process_name,in_tup,out_tup,out_sz,accepted_tup,cycles,collisions,evictions,in_tup_rate,out_tup_rate,out_bytes_rate,cycle_consumption_rate"); + if(rpt_fl) fprintf(rpt_fl,",%s",perf_struct::to_csv_hdr().c_str()); + if(rpt_fl) fprintf(rpt_fl,",packets_sent_to_query,fraction_intup_lost,inferred_read_rate"); + if(rpt_fl) fprintf(rpt_fl,"\n"); + + map<fta_addr,string>::iterator mpiisi; + int n_output = 0; + set<string> found_names; + for(mpiisi=qnode_map.begin();mpiisi!=qnode_map.end();++mpiisi){ + string qname = (*mpiisi).second; + if(found_names.count(qname)==0){ + found_names.insert(qname); + int qidx = qname_to_idx[qname]; + string executable = qnode_list[qidx]->executable_name; + if(executable == "") + executable="rts"; +// printf("(%d,%d,%d) -> %s, %d reads-from\n",(*mpiisi).first.ip,(*mpiisi).first.port,(*mpiisi).first.streamid,qname.c_str(),qnode_list[qidx]->reads_from_idx.size()); + printf("query=%s, executable=%s\tintup=%llu, out_tup=%llu, out_sz=%llu, accepted_tup=%llu, cycles=%llu, collisions=%llu, evictions=%llu\n", + qname.c_str(),qnode_list[qidx]->executable_name.c_str(), + qnode_list[qidx]->in_tup, + qnode_list[qidx]->out_tup, + qnode_list[qidx]->out_sz, + qnode_list[qidx]->accepted_tup, + qnode_list[qidx]->cycles, + qnode_list[qidx]->collisions, + qnode_list[qidx]->evictions + ); + if(rpt_fl) fprintf(rpt_fl,"%s,%s,%llu,%llu,%llu,%llu,%llu,%llu,%llu", + qname.c_str(),qnode_list[qidx]->executable_name.c_str(), + qnode_list[qidx]->in_tup, + qnode_list[qidx]->out_tup, + qnode_list[qidx]->out_sz, + qnode_list[qidx]->accepted_tup, + qnode_list[qidx]->cycles, + qnode_list[qidx]->collisions, + qnode_list[qidx]->evictions + ); + double duration = 1.0*(qnode_list[qidx]->end_tick - qnode_list[qidx]->start_tick); + + printf("\tin_tup_rate=%f, out_tup_rate=%f, out_byte_rate=%f, cycle_rate=%f\n",qnode_list[qidx]->in_tup/duration,qnode_list[qidx]->out_tup/duration,qnode_list[qidx]->out_sz/duration,qnode_list[qidx]->cycles/duration); + if(rpt_fl) fprintf(rpt_fl,",%f,%f,%f,%f",qnode_list[qidx]->in_tup/duration,qnode_list[qidx]->out_tup/duration,qnode_list[qidx]->out_sz/duration,qnode_list[qidx]->cycles/duration); + printf("\t%s\n",qnode_list[qidx]->perf->to_string().c_str()); + if(rpt_fl) fprintf(rpt_fl,",%s",qnode_list[qidx]->perf->to_csv().c_str()); +//if(qnode_list[qidx]->aggr_tbl_size>0){ +//printf("\taggregate table size is %d\n",qnode_list[qidx]->aggr_tbl_size); +//} +//if(qnode_list[qidx]->src_interface != ""){ +//printf("\tSource interface is %s\n",qnode_list[qidx]->src_interface.c_str()); +//} + if(qnode_list[qidx]->reads_from_idx.size()>0){ + unsigned long long int total_sent = 0; + for(i=0;i<qnode_list[qidx]->reads_from_idx.size();++i){ + total_sent += qnode_list[qnode_list[qidx]->reads_from_idx[i]]->out_tup; + qnode_list[qidx]->inferred_in_sz += qnode_list[qnode_list[qidx]->reads_from_idx[i]]->out_sz / (qnode_list[qnode_list[qidx]->reads_from_idx[i]]->end_tick-qnode_list[qnode_list[qidx]->reads_from_idx[i]]->start_tick); + } + printf("\t%llu packets sent, %f lost, inferred read rate is %f\n",total_sent,(1.0*total_sent-qnode_list[qidx]->in_tup)/total_sent, qnode_list[qidx]->inferred_in_sz); + if(rpt_fl) fprintf(rpt_fl,",%llu,%f,%f",total_sent,(1.0*total_sent-qnode_list[qidx]->in_tup)/total_sent, qnode_list[qidx]->inferred_in_sz); + } + else{ + if(rpt_fl) fprintf(rpt_fl,",,,"); + } + + if(rpt_fl) fprintf(rpt_fl,"\n"); + n_output++; + } + } + + + +// Collect performance info about RTSs and determine a better hash partitioning. + +// First, grab any existing balancing information + map<string, vector<int> > prev_rts_loads; + FILE *rload_fl = NULL; + rload_fl = fopen("rts_load.cfg","r"); + lineno = 0; + if(rload_fl != NULL){ + while(fgets(line,LINEBUF,rload_fl)){ + lineno++; + int nflds = split_string(line,',',flds,SPLITBUF); + if(nflds>1){ + vector<int> hbounds; + bool invalid_line=false; + int prev_val = 0; + for(i=1;i<nflds;++i){ + int new_val = atoi(flds[i]); + if(new_val < prev_val) + invalid_line = true; + hbounds.push_back(new_val); + } + if(! invalid_line){ + prev_rts_loads[flds[0]] = hbounds; + }else{ + printf("Warning, rts_load.cfg has an invalid entry on line %d, skipping\n",lineno); + } + }else{ + printf("Warning, rts_load.cfg has an invalid entry on line %d, skipping\n",lineno); + } + } + }else{ + fprintf(rload_fl,"Warning, can't open rts_load.cfg, skipping and using defualt allocation estimate.\n"); + } + map<string, vector<int> > new_rts_loads = prev_rts_loads; + fclose(rload_fl); + +// Next, try to grab a history of allocations and resulting cpu loads + FILE *rtrace_fl = NULL; + rtrace_fl = fopen("rts_load.trace.txt","r"); + lineno = 0; + map<string, vector< vector<int> > > iface_alloc_history; + map<string, vector< vector<double> > > iface_load_history; + if(rtrace_fl != NULL){ + vector<int> curr_allocation; + vector<double> curr_load; + while(fgets(line,LINEBUF,rtrace_fl)){ + int nflds = split_string(line,',',flds,SPLITBUF); + if(nflds > 2){ + string iface = flds[0]; + string entry = flds[1]; + if(entry == "Previous allocation"){ + curr_allocation.clear(); + for(i=2;i<nflds;++i){ + curr_allocation.push_back(atoi(flds[i])); + } + } + if(entry == "Previous cpu loads"){ + curr_load.clear(); + for(i=2;i<nflds;++i){ + curr_load.push_back(atof(flds[i])); + } + if(curr_allocation.size() == curr_load.size()){ + iface_alloc_history[iface].push_back(curr_allocation); + iface_load_history[iface].push_back(curr_load); + } + } + } + } + } + +/* +map<string, vector< vector<int> > >::iterator msvvi; +for(msvvi=iface_alloc_history.begin();msvvi!=iface_alloc_history.end();++msvvi){ +string iface = (*msvvi).first; +printf("iface %s past allocations:\n",iface.c_str()); +vector<vector<int> > &alloc = iface_alloc_history[iface]; +printf("alloc size is %d\n",alloc.size()); +for(i=0;i<alloc.size();++i){ +for(j=0;j<alloc[i].size();++j){ +printf("%d ",alloc[i][j]); +} +printf("\n"); +} +printf("\niface %s past loads:\n",iface.c_str()); +vector<vector<double> > &load = iface_load_history[iface]; +printf("load size is %d\n",load.size()); +for(i=0;i<load.size();++i){ +for(j=0;j<load[i].size();++j){ +printf("%f ",load[i][j]); +} +printf("\n"); +} +printf("\n"); +} +*/ + + + map<int, string>::iterator misi; + map<string, vector<int> > rts_iface_indices; + map<string, vector<double> > rts_iface_cpu_load; + for(misi=rts_iface_map.begin();misi!=rts_iface_map.end();++misi){ + int rpid = (*misi).first; + string riface = (*misi).second; + size_t Xpos = riface.find_last_of("X"); + if(Xpos!=string::npos){ + string iface = riface.substr(0,Xpos); +// ifaces_found.insert(iface); + string ifcopy = riface.substr(Xpos+1); + int ifidx = atoi(ifcopy.c_str()); + rts_iface_indices[iface].push_back(ifidx); + } + printf("pid=%d, rts %s, %s\n",rpid,riface.c_str(),rts_perf_map[rpid]->to_string().c_str()); + if(rpt_fl){ + fprintf(rpt_fl,",rts %s,,,,,,,,,,,,%s,,,,\n",riface.c_str(),rts_perf_map[rpid]->to_csv().c_str()); + + } + } + map<string, vector<int> >::iterator msvi; + set<string> ifaces_found; + map<string, vector<double> > ht_cpu_allocs; + map<string, int> total_ht_sizes; + for(msvi=rts_iface_indices.begin();msvi!=rts_iface_indices.end();++msvi){ + string iface = (*msvi).first; + vector<int> &ifindices = (*msvi).second; + sort(ifindices.begin(),ifindices.end()); + + double total_cpu = 0.0; + vector<double> if_cpu; + for(i=0;i<ifindices.size();++i){ + string full_iface = iface + "X" + int_to_string(ifindices[i]); + int pid = pid_iface_map[full_iface]; + total_cpu += rts_perf_map[pid]->avg_cpu_time(); + if_cpu.push_back(rts_perf_map[pid]->avg_cpu_time()); + } + rts_iface_cpu_load[iface] = if_cpu; + + vector<int> current_allocation; + if(new_rts_loads.count(iface) == 0 || new_rts_loads[iface].size() != ifindices.size()){ + int cumm_cpu = 0; + for(i=0;i<ifindices.size();++i){ + int new_cumm = ((i+1)*htmax)/ifindices.size(); + current_allocation.push_back(new_cumm-cumm_cpu); + cumm_cpu=new_cumm; + } + }else{ + current_allocation = new_rts_loads[iface]; + } + int total_ht_allocation = 0; +//printf("Current allocation is:"); + for(i=0;i<current_allocation.size();++i){ + total_ht_allocation += current_allocation[i]; +//printf(" %d",current_allocation[i]); + } + + vector<double> local_alloc(total_ht_allocation,0.0); // estimated cpu per HT slot. + int ht_ptr = 0; + for(i=0;i<if_cpu.size();++i){ + double rate = if_cpu[i]/(current_allocation[i]*total_cpu); + for(j=0;j<current_allocation[i];++j){ + local_alloc[ht_ptr++] = rate; + } + } + + if(iface_alloc_history.count(iface)>0){ + vector<vector<int> > &alloc = iface_alloc_history[iface]; + vector<vector<double> > &load = iface_load_history[iface]; + int n_remaining = rts_load_history_len; + double multiplier = hist_multiplier; + double normalizer = 1.0; + for(i=alloc.size()-1;i>=0 && n_remaining>0;i--){ + int hist_ht_size = 0; + for(j=0;j<alloc[i].size();++j) + hist_ht_size+=alloc[i][j]; + double hist_cpu = 0.0; + for(j=0;j<load[i].size();++j) + hist_cpu += load[i][j]; + if(hist_ht_size == total_ht_allocation){ + int ht_ptr = 0; + for(j=0;j<alloc[i].size();++j){ + double rate = (multiplier*load[i][j])/(alloc[i][j]*hist_cpu); + int k; + for(k=0;k<alloc[i][j];k++){ + local_alloc[ht_ptr++] += rate; + } + } + normalizer += multiplier; + multiplier *= hist_multiplier; + n_remaining--; + } + } + for(i=0;i<total_ht_allocation;i++){ + local_alloc[i] /= normalizer; + } + } + + + total_ht_sizes[iface] = total_ht_allocation; + ht_cpu_allocs[iface] = local_alloc; + } + + if(uniform_rts_alloc){ +// I will require that if this option is true, all HTs +// the same size. + bool same_sizes = true; + int total_alloc = -1; + map<string, int >::iterator msi; + for(msi=total_ht_sizes.begin();msi!=total_ht_sizes.end();++msi){ + if(total_alloc<0){ + total_alloc=(*msi).second; + }else{ + if(total_alloc != (*msi).second){ + same_sizes = false; + } + } + } + if(same_sizes){ + vector<double> local_alloc(total_alloc,0.0); + double normalizer = 0.0; + map<string, vector<double> >::iterator msvdi; + for(msvdi=ht_cpu_allocs.begin();msvdi!=ht_cpu_allocs.end();++msvdi){ + string iface = (*msvdi).first; + for(i=0;i<total_alloc;++i){ + local_alloc[i] += ht_cpu_allocs[iface][i]; + } + normalizer += 1.0; + } + for(i=0;i<total_alloc;++i) + local_alloc[i] /= normalizer; + for(msvdi=ht_cpu_allocs.begin();msvdi!=ht_cpu_allocs.end();++msvdi){ + (*msvdi).second = local_alloc; + } + } + } + + for(msvi=rts_iface_indices.begin();msvi!=rts_iface_indices.end();++msvi){ + string iface = (*msvi).first; + vector<int> &ifindices = (*msvi).second; + sort(ifindices.begin(),ifindices.end()); + + int cumm_ht_alloc = 0; // ht allocated thus far + int current_pos = 0; // idx to the current_allocation, if_cpu arrays + vector<int> new_allocation; + for(i=0;i<ifindices.size()-1;++i){ + double slot_cpu = 1.0/ifindices.size(); // amount of cpu to allocate + int current_alloc = 0; // ht allocated in the curr_pos slot + while(slot_cpu > 0.0){ + slot_cpu -= ht_cpu_allocs[iface][current_pos]; + current_pos++; + current_alloc++; + } + // try to make the allocations even + if(current_alloc>1 && (-slot_cpu) > (ht_cpu_allocs[iface][current_pos-1]/2.0)){ + current_pos--; + current_alloc--; + } + new_allocation.push_back(current_alloc); + } + new_allocation.push_back(total_ht_sizes[iface]-current_pos); + +/* + int cumm_ht_alloc = 0; // ht allocated thus far + int current_pos = 0; // idx to the current_allocation, if_cpu arrays + int current_alloc = 0; // ht allocated in the curr_pos slot + vector<int> new_allocation; + for(i=0;i<ifindices.size()-1;++i){ + double slot_cpu = total_cpu/ifindices.size(); // amount of cpu to allocate + int slot_ht = 0; + while(slot_cpu > 0.0){ + double cpu_rate = if_cpu[current_pos] / current_allocation[current_pos]; + double cpu_remaining = cpu_rate*(current_allocation[current_pos] - current_alloc); + if(slot_cpu <= cpu_remaining){ + double this_cpu_alloc = slot_cpu; + int this_ht_alloc = (int)(this_cpu_alloc / cpu_rate); + slot_ht += this_ht_alloc; + slot_cpu = 0.0; + cumm_ht_alloc += this_ht_alloc; + current_alloc += this_ht_alloc; + if(current_alloc >= current_allocation[current_pos]){ + current_pos++; + current_alloc = 0; + } + }else{ + slot_cpu -= cpu_remaining; + slot_ht += current_allocation[current_pos] - current_alloc; + cumm_ht_alloc += current_allocation[current_pos] - current_alloc; + current_pos++; + current_alloc = 0; + } + } + new_allocation.push_back(slot_ht); + } + new_allocation.push_back(total_ht_allocation - cumm_ht_alloc); +*/ + + new_rts_loads[iface] = new_allocation; + + +/* +printf("Interface %s:",iface.c_str()); +for(i=0;i<ifindices.size();++i){ +string full_iface = iface + "X" + int_to_string(ifindices[i]); +int pid = pid_iface_map[full_iface]; +printf(" %f",rts_perf_map[pid]->avg_cpu_time()/total_cpu); +} +printf("\n\t"); +for(i=0;i<ifindices.size();++i){ +printf(" %d",prev_rts_loads[iface][i]); +} +printf("\n"); +*/ + } + + + FILE *rrec_fl = fopen("rts_load.cfg.recommended","w"); + if(rrec_fl == NULL){ + fprintf(stderr,"Warning, can't open rts_load.cfg.recommended for write, skipping.\n"); + } + + printf("Recommended virtual interface hash allocation:\n"); + map<string, vector<int> >::iterator msvii; + for(msvii=new_rts_loads.begin();msvii!=new_rts_loads.end();++msvii){ + string iface_name = (*msvii).first; + vector<int> iface_alloc = (*msvii).second; + printf("%s",iface_name.c_str()); + if(rrec_fl!=NULL) fprintf(rrec_fl,"%s",iface_name.c_str()); + for(i=0;i<iface_alloc.size();++i){ + printf(",%d",iface_alloc[i]); + if(rrec_fl!=NULL) fprintf(rrec_fl,",%d",iface_alloc[i]); + } + printf("\n"); + if(rrec_fl!=NULL) fprintf(rrec_fl,"\n"); + } + fclose(rrec_fl); + + + rrec_fl = fopen("rts_load.trace.txt","a"); + if(rrec_fl != NULL){ + fprintf(rrec_fl,"\n"); + for(msvii=new_rts_loads.begin();msvii!=new_rts_loads.end();++msvii){ + string iface_name = (*msvii).first; + vector<int> iface_alloc = (*msvii).second; + vector<double> iface_cpu_loads = rts_iface_cpu_load[iface_name]; + vector<int> prev_iface_alloc = prev_rts_loads[iface_name]; + + fprintf(rrec_fl,"Interface %s:\n",iface_name.c_str()); + fprintf(rrec_fl,"%s,Previous allocation,",iface_name.c_str()); + for(i=0;i<prev_iface_alloc.size();++i){ + if(i>0) fprintf(rrec_fl,","); + fprintf(rrec_fl,"%d",prev_iface_alloc[i]); + } + fprintf(rrec_fl,"\n%s,Previous cpu loads,",iface_name.c_str()); + for(i=0;i<iface_cpu_loads.size();++i){ + if(i>0) fprintf(rrec_fl,","); + fprintf(rrec_fl,"%f",iface_cpu_loads[i]); + } + fprintf(rrec_fl,"\n%s,New allocation,",iface_name.c_str()); + for(i=0;i<iface_alloc.size();++i){ + if(i>0) fprintf(rrec_fl,","); + fprintf(rrec_fl,"%d",iface_alloc[i]); + } + fprintf(rrec_fl,"\n\n"); + } + } + fclose(rrec_fl); + + +// ---------------------------------------------------------------- +// Make an hfta parallelism analysis. Start by collecting hftas and grouping +// them by their copies. Count on the __copy%d name mangling. + + set<string>::iterator ssi; + map<string, vector<int> > par_hfta_map; + for(ssi=found_names.begin();ssi!=found_names.end();++ssi){ + string base = (*ssi); + int qidx = qname_to_idx[base]; + if(qnode_list[qidx]->qnode_type == "HFTA"){ + size_t cpos = (*ssi).find("__copy"); + if(cpos!=string::npos){ + base = (*ssi).substr(0,cpos); + string idx_str = (*ssi).substr(cpos+6); + int pidx = atoi(idx_str.c_str()); + qnode_list[qidx]->par_index = pidx; + } + par_hfta_map[base].push_back(qidx); + } + } + +// Coalesce or split hftas. Reduce parallelism until the max cpu utilization +// is in [cpu_util_threshold/2, cpu_util_threshold]. Double parallelism +// if max cpu utilization is > cpu_util_threshold. +// Only recommend parallelism if a resource utilization file was found. + if(res_fl!=NULL){ + map<string, int> recommended_parallelism; + map<string, vector<int> >::iterator msvii; + for(msvii=par_hfta_map.begin();msvii!=par_hfta_map.end();++msvii){ + vector<int> buddy_indices = (*msvii).second; + vector<qnode *> buddies; + int n_valid = 0; + for(i=0;i<buddy_indices.size();i++){ + buddies.push_back(qnode_list[buddy_indices[i]]); + if(qnode_list[buddy_indices[i]]->perf->is_valid()) + n_valid++; + } + + if(n_valid>0){ + sort(buddies.begin(),buddies.end(),cmpr_parallel_idx); + + int level=1; + double max_util = 0.0; + while(level<=buddies.size()){ + for(i=0;i<buddies.size();i+=level){ + double this_util = 0.0; + for(j=0;j<level;j++){ + this_util += buddies[i+j]->perf->avg_cpu_time(); + } + if(this_util > max_util) + max_util = this_util; + } + if(max_util >= cpu_util_threshold/2) + break; + level *= 2; + } + int npar = buddies.size(); + if(max_util > cpu_util_threshold) + level/=2; + if(level>buddies.size()) + level/=2; + if(level==0) + npar *= 2; + else + npar /= level; + + recommended_parallelism[(*msvii).first] = npar; + }else{ + printf("Warning, no resource usage information for %s, skipping.\n",(*msvii).first.c_str()); + } + } + + FILE *hpar_fl = NULL; + hpar_fl=fopen("hfta_parallelism.cfg","r"); + if(hpar_fl==NULL){ + fprintf(stderr,"Warning, can't open hfta_parallelism.cfg, ignoring.\n"); + }else{ + while(fgets(line,LINEBUF,hpar_fl)){ + int nflds = split_string(line,',',flds,SPLITBUF); + if(nflds==2){ + int npar = atoi(flds[1]); + if(npar>0 && recommended_parallelism.count(flds[0])==0){ + recommended_parallelism[flds[0]] = npar; + } + } + } + fclose(hpar_fl); + } + + FILE *recpar_fl = NULL; + recpar_fl=fopen("hfta_parallelism.cfg.recommended","w"); + if(recpar_fl==NULL){ + fprintf(stderr,"Warning, can't open hfta_parallelism.cfg.recommended, can't write the file.\n"); + } + printf("Recommended parallelism:\n"); + map<string, int>::iterator msii; + for(msii=recommended_parallelism.begin();msii!=recommended_parallelism.end();++msii){ + if(recpar_fl!=NULL) + fprintf(recpar_fl,"%s,%d\n",(*msii).first.c_str(),(*msii).second); + printf("%s,%d\n",(*msii).first.c_str(),(*msii).second); + } + fclose(recpar_fl); + }else{ + printf("Can't recommend hfta parallelism, no resource utilization file found.\n"); + } + + FILE *rec_ht_fl = NULL; + rec_ht_fl=fopen("lfta_htsize.cfg.recommended","w"); + if(rec_ht_fl==NULL){ + fprintf(stderr,"Warning, can't open lfta_htsize.cfg.recommended, can't write the file.\n"); + } + printf("Recommended LFTA hash table sizes:\n"); + for(i=0;i<qnode_list.size();++i){ + qnode *this_qn = qnode_list[i]; + if(this_qn->qnode_type=="LFTA" && this_qn->aggr_tbl_size>0 && this_qn->accepted_tup>0){ + int ht_size = this_qn->aggr_tbl_size; + double collision_rate = ((double)this_qn->collisions)/this_qn->accepted_tup; + double eviction_rate = ((double)this_qn->evictions)/this_qn->accepted_tup; + printf("%s htsize=%d collision=%f evictions=%f",this_qn->name.c_str(),ht_size,collision_rate,eviction_rate); +//printf("%d,%f,%f\n",ht_size,collision_rate,eviction_rate); + if(eviction_rate >= erate_hi){ + ht_size /= 2; + }else if(collision_rate >= crate_hi){ + ht_size *= 2; + }else if(collision_rate < crate_lo){ + ht_size /= 2; + } + + printf(" rec ht_size=%d\n",ht_size); + fprintf(rec_ht_fl,"%s,%u\n",this_qn->name.c_str(),ht_size); + + } + } + fclose(rec_ht_fl); + + +// Try to load the cpu configuration info + + vector <cpu_info_str *> cpu_info_list; + FILE *cinfo_fl = NULL; + cinfo_fl=fopen("cpu_info.csv","r"); + if(cinfo_fl==NULL){ + fprintf(stderr,"Warning, can't open cpu_info.csv, skipping process pinning optimization. Run gscpv3/bin/parse_cpuinfo.pl to generate a cpu_info.csv file.\n"); + }else{ + int lineno = 0; + while(fgets(inp,LINEBUF,cinfo_fl)){ + int nflds = split_string(inp,',',flds,SPLITBUF); + lineno++; + if(nflds >= 3){ + cpu_info_list.push_back(new cpu_info_str(atoi(flds[0]),atoi(flds[1]),atoi(flds[2]))); + } + } + + sort(cpu_info_list.begin(),cpu_info_list.end(),cmpr_cpu_info); + +// Spread the LFTAs among the cores. + vector<string> iface_names; + for(msvi=rts_iface_indices.begin();msvi!=rts_iface_indices.end();++msvi){ + string iface = (*msvi).first; + vector<int> ifindices = (*msvi).second; + sort(ifindices.begin(),ifindices.end()); + + for(i=0;i<ifindices.size();++i){ + string full_iface = iface + "X" + int_to_string(ifindices[i]); + iface_names.push_back(full_iface); + } + } + + + map<string, int> rts_assignment; + double stride = ((double)(cpu_info_list.size()))/((double)(iface_names.size())); + double rtspos_f = 0.0; + for(i=0;i<iface_names.size();++i){ + int rtspos = (int)rtspos_f; + rts_assignment[iface_names[i]] = rtspos; + cpu_info_list[rtspos]->assigned_load += rts_perf_map[pid_iface_map[iface_names[i]]]->avg_cpu_time(); + rtspos_f += stride; + } + +//for(i=0;i<iface_names.size();++i){ +//printf("Placing %s at %d\n",iface_names[i].c_str(), rts_assignment[iface_names[i]]); +//} + + set<string> eligible_hftas; + map<string, int> hfta_assignment; + set<string>::iterator ssi; + for(ssi = found_names.begin();ssi!=found_names.end();++ssi){ + int qidx = qname_to_idx[(*ssi)]; +//printf("Considering %s (%d), sz=%f, cpu=%f\n",(*ssi).c_str(),qidx,qnode_list[qidx]->inferred_in_sz,qnode_list[qidx]->perf->avg_cpu_time()); + if(qnode_list[qidx]->inferred_in_sz >= min_hfta_insz || qnode_list[qidx]->perf->avg_cpu_time() > min_hfta_cpu){ +//printf("\tAdding to eligible list\n"); + eligible_hftas.insert((*ssi)); + } + } + + while(eligible_hftas.size()>0){ + int chosen_hfta = -1; + double max_assigned_rate = 0.0; + for(ssi=eligible_hftas.begin();ssi!=eligible_hftas.end();++ssi){ + double assigned_rate = 0.0; + string qname = (*ssi); + int qidx = qname_to_idx[qname]; + vector<int> reads_from = qnode_list[qidx]->reads_from_idx; + for(i=0;i<reads_from.size();++i){ + if(qnode_list[reads_from[i]]->qnode_type == "LFTA" || (qnode_list[reads_from[i]]->qnode_type == "HFTA" && hfta_assignment.count(qnode_list[reads_from[i]]->name) > 0)) + assigned_rate += qnode_list[reads_from[i]]->output_rate(); + } +//printf("hfta %s, assigned rate=%f\n",qname.c_str(),assigned_rate); + if(assigned_rate >= max_assigned_rate){ +//printf("\t picking %s\n",qname.c_str()); + max_assigned_rate = assigned_rate; + chosen_hfta = qidx; + } + } + if(chosen_hfta >= 0){ + vector<int> reads_from = qnode_list[chosen_hfta]->reads_from_idx; + vector<int> src_location; + vector<double> src_volume; + for(i=0;i<reads_from.size();++i){ + int qidx = reads_from[i]; + if(qnode_list[qidx]->qnode_type == "HFTA"){ + if(hfta_assignment.count(qnode_list[qidx]->name)>0){ + src_location.push_back(hfta_assignment[qnode_list[qidx]->name]); + src_volume.push_back(qnode_list[qidx]->output_rate()); + } + } + if(qnode_list[qidx]->qnode_type == "LFTA"){ + if(rts_assignment.count(qnode_list[qidx]->src_interface)>0){ + src_location.push_back(rts_assignment[qnode_list[qidx]->src_interface]); + src_volume.push_back(qnode_list[qidx]->output_rate()); + } + } + } +//printf("chosen hfta is %d (%s), sources are:\n",chosen_hfta,qnode_list[chosen_hfta]->name.c_str()); +//for(i=0;i<src_location.size();++i){ +//printf("\tloc=%d, (%s) volume=%f\n",src_location[i],cpu_info_list[src_location[i]]->to_csv().c_str(),src_volume[i]); +//} + + double hfta_cpu_usage = qnode_list[chosen_hfta]->perf->avg_cpu_time(); + if(hfta_cpu_usage > cpu_util_threshold) // hack for overloaded hftas. + hfta_cpu_usage = cpu_util_threshold * .9999; +printf("hfta %d (%s) has cpu usage %f\n",chosen_hfta,qnode_list[chosen_hfta]->name.c_str(),hfta_cpu_usage); + int best_cpu = -1; + double lowest_cost = 0.0; + for(i=0;i<cpu_info_list.size();++i){ + double curr_cost = 0.0; + for(j=0;j<src_location.size();++j){ + int dist = cpu_info_list[i]->distance_from(cpu_info_list[src_location[j]]); + curr_cost += src_volume[j]*xfer_costs[dist]; + } +//printf("Cpu %s, cost=%f\n",cpu_info_list[i]->to_csv().c_str(),curr_cost); + if((cpu_info_list[i]->assigned_load+hfta_cpu_usage < cpu_util_threshold) && (best_cpu<0 || curr_cost <= lowest_cost)){ + best_cpu = i; + lowest_cost = curr_cost; +//printf("\tpicking %s\n",cpu_info_list[i]->to_csv().c_str()); + } + } + + if(best_cpu>=0) + cpu_info_list[best_cpu]->assigned_load += hfta_cpu_usage; + hfta_assignment[qnode_list[chosen_hfta]->name] = best_cpu; + eligible_hftas.erase(qnode_list[chosen_hfta]->name); + + }else{ + fprintf(stderr,"ERROR, chosen_hfta=-1, bailing out.\n"); + exit(1); + } + } + + FILE *pin_fl = fopen("pinning_info.csv","w"); + if(pin_fl==NULL){ + fprintf(stderr,"Warning, can't open pinning_info.csv, can't write the file.\n"); + } + printf("RTS assignments:\n"); + for(i=0;i<iface_names.size();++i){ + int assigned_cpu = rts_assignment[iface_names[i]]; + if(assigned_cpu>=0){ + printf("Place %s at %d (%s)\n",iface_names[i].c_str(), assigned_cpu, cpu_info_list[assigned_cpu]->to_csv().c_str()); + if(pin_fl != NULL){ + fprintf(pin_fl,"rts %s,%d\n",iface_names[i].c_str(), assigned_cpu); + } + } + } + + printf("HFTA assignments:\n"); + map<string, int>::iterator msii; + for(msii=hfta_assignment.begin();msii!=hfta_assignment.end();++msii){ + int assigned_cpu = (*msii).second; + string qname = (*msii).first; + if(assigned_cpu>=0){ + printf("Place %s (%s) at %d (%s)\n",qname.c_str(),qnode_list[qname_to_idx[qname]]->executable_name.c_str(),assigned_cpu,cpu_info_list[assigned_cpu]->to_csv().c_str()); + if(pin_fl != NULL){ + fprintf(pin_fl,"%s,%d\n",qnode_list[qname_to_idx[qname]]->executable_name.c_str(), assigned_cpu); + } + } + } + + } + +//for(i=0;i<cpu_info_list.size();++i){ +//printf("Cpu %d assigned load %f\n",i,cpu_info_list[i]->assigned_load); +//} + +return 0; +} + + + diff --git a/src/tools/qnode.h b/src/tools/qnode.h new file mode 100644 index 0000000..6e2c7cb --- /dev/null +++ b/src/tools/qnode.h @@ -0,0 +1,231 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __QNODE_H_DEFINED_ +#define __QNODE_H_DEFINED_ + +#include<string> + +struct perf_struct{ + int n_samples; + int init_discard; + int init_time; + int last_update; + unsigned long long int init_stime; + unsigned long long int init_utime; + unsigned long long int total_stime; + unsigned long long int total_utime; + double max_stime; + double max_utime; + double max_time; + unsigned long long int max_vm_size; + unsigned long long int max_rss; + + void init(){ + n_samples = 0; + init_time = 0; + init_stime = 0; + init_utime = 0; + total_stime = 0; + total_utime = 0; + max_stime = 0.0; + max_utime = 0.0; + max_time = 0.0; + max_vm_size = 0; + max_rss = 0; + last_update = -1; + } + + perf_struct(){ + init(); + } + perf_struct(int d){ + init(); + init_discard = d; + } + + bool update(int t, unsigned long long int u, unsigned long long int s, + unsigned long long int v, unsigned long long int r){ + if(init_discard>0){ + init_discard--; + return false;; + } + + + if(v>max_vm_size) + max_vm_size = v; + if(r>max_rss) + max_rss = r; + if(last_update<0){ + init_time = t; + init_stime = s; + init_utime = u; + }else{ + if(t<=last_update || u<total_utime || s<total_stime){ + return true; + } + + double tmps,tmpu,tmpt; + tmps = (double)((s-total_stime))/(t-last_update); + tmpu = (double)((u-total_utime))/(t-last_update); + tmpt = tmps+tmpu; + if(tmps>max_stime) + max_stime = tmps; + if(tmpu>max_utime) + max_utime = tmpu; + if(tmpt>max_time) + max_time = tmpt; + } + total_stime = s; + total_utime = u; + last_update = t; + + return false; + } + + std::string to_string(){ + char ret[1000]; + if(last_update - init_time>0){ + sprintf(ret,"stime=%lf, utime=%lf, time=%lf max_stime=%lf, max_utime=%lf, max_time=%lf, max_vmsize=%lld, max_rss = %lld", + (double)(total_stime-init_stime)/(last_update - init_time), + (double)(total_utime-init_utime)/(last_update - init_time), + (double)(total_stime-init_stime)/(last_update - init_time) + (double)(total_utime-init_utime)/(last_update - init_time), + max_stime,max_utime,max_time, + max_vm_size,max_rss + ); + return ret; + } + return("(no perf results)"); + } + + static std::string to_csv_hdr(){ + return "avg_system_time,avg_user_time,avg_cpu_time,max_sys_time,max_user_time,max_total_time,max_vm_size,max_rss"; + } + + std::string to_csv(){ + char ret[1000]; + if(last_update - init_time>0){ + sprintf(ret,"%lf,%lf,%lf,%lf,%lf,%lf,%lld,%lld", + (double)(total_stime-init_stime)/(last_update - init_time), + (double)(total_utime-init_utime)/(last_update - init_time), + (double)(total_stime-init_stime)/(last_update - init_time) + (double)(total_utime-init_utime)/(last_update - init_time), + max_stime,max_utime,max_time, + max_vm_size,max_rss + ); + return ret; + } + return(",,,,,,"); + } + + double avg_cpu_time(){ + return ((double)((total_stime-init_stime)+(total_utime-init_utime))/(last_update - init_time))/100.0; + } + + bool is_valid(){ + return last_update > 0; + } +}; + + + + +struct field_str{ + std::string name; + int pos; + std::string type; + std::string mods; + + field_str(){}; + field_str(std::string n, int p, std::string t, std::string m){ + name=n; + pos=p; + type=t; + mods=m; + } +}; + + +struct qnode{ + std::string name; + std::string executable_name; + std::string qnode_type; + int aggr_tbl_size; + std::vector<field_str *> fields; + std::vector<std::string> reads_from; + std::vector<int> reads_from_idx; + std::vector<int> sources_to_idx; + std::string src_interface; + int par_index; + int start_tick, end_tick; + + unsigned long long int in_tup,out_tup,out_sz; + unsigned long long int accepted_tup,cycles,collisions,evictions; + double inferred_in_sz; + perf_struct *perf; + + qnode(int d){ + aggr_tbl_size = 0; + in_tup = 0; + out_tup = 0; + accepted_tup = 0; + cycles = 0; + collisions = 0; + evictions = 0; + inferred_in_sz = 0.0; + par_index = 0; + start_tick = end_tick = -1; + perf = new perf_struct(d); + }; + + qnode(std::string type, std::string n,int d){ + qnode_type=type; + name=n; + aggr_tbl_size = 0; + + in_tup = 0; + out_tup = 0; + out_sz = 0; + accepted_tup = 0; + cycles = 0; + collisions = 0; + evictions = 0; + inferred_in_sz = 0.0; + par_index = 0; + start_tick = end_tick = -1; + perf = new perf_struct(d); + } + + double output_rate(){ + if(end_tick == start_tick){ + return 0.0; + } + return( ((double)out_sz)/(end_tick-start_tick) ); + } + + void add_field(field_str *fld){ + fields.push_back(fld); + } + + void add_source(std::string src){ + reads_from.push_back(src); + } + +}; + + + + + +#endif diff --git a/src/tools/xml.l b/src/tools/xml.l new file mode 100644 index 0000000..82dd205 --- /dev/null +++ b/src/tools/xml.l @@ -0,0 +1,223 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +/* + MUST COMPILE WITH + flex -PxmlParser -oxmllexer.cc xml.l + (or equivalent). +*/ + +%{ +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + // #include "parse_fta.h" + #include <string.h> + + + +#include "xml.tab.hh" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include <stdlib.h> +#include <string.h> + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int xmlParserwrap(){return(1);} + +extern int xmlParserdebug; + + +/* + These variables are used for error reporting: + flex_xml_lineno : the line currently being parsed when the error occurs. + flex_xml_ch : the character on the line where the error occurs + flex_xml_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_xml_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_xml_lineno = 1; +int flex_xml_ch = 0; +char flex_xml_linebuf[20000]; + +char *flex_xml_stringinput = NULL; +int flex_xml_stringinput_ptr = 0; +FILE *flex_xml_fileinput = NULL; +int my_xmlParser_yyinput(char *buf, int max_size); + + + +void xmlParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_xml_lineno, flex_xml_ch, s, xmlParsertext, flex_xml_linebuf ); + for(i=0;i<flex_xml_ch;i++){ + if(flex_xml_linebuf[i] == '\t'){ + fprintf(stderr,"\t"); + }else{ + fprintf(stderr," "); + } + } + fprintf(stderr,"^\n"); + // fprintf(stderr,"%*s\n",1+flex_xml_ch,"^"); +} + +#undef YY_INPUT +#define YY_INPUT(b, r, ms) (r = my_xmlParser_yyinput(b,ms)) + +%} + /* MKS needs the next line to increase the NFA table */ +%e 1200 +%option noyywrap + +%% + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + + + + +[<>=/] { flex_xml_ch+=xmlParserleng; return yytext[0]; } + + /* names */ + +[A-Za-z_][A-Za-z0-9_:\-]* { flex_xml_ch+=xmlParserleng; xmlParserlval.strval = strdup(yytext); return NAME; } + + + /* strings */ + +\'[^\'\n]*\' { + + int c; + + xmlParserlval.strval = strdup(xmlParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_xml_ch+=xmlParserleng; + xmlParserlval.strval[xmlParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + +\'[^\'\n]*$ { flex_xml_ch+=xmlParserleng; xmlParsererror("Unterminated string"); } + + /* */ + /* Newline : advance the error reporting line number */ + /* and grab the next line into flex_xml_linebuf */ + /* */ + +\n.* {flex_xml_ch=0; flex_xml_lineno++; + strcpy(flex_xml_linebuf,xmlParsertext+1); + yyless(1); + } + +[ \t\r]+ {flex_xml_ch+=xmlParserleng; } /* white space */ + +"--".*$ {flex_xml_ch+=xmlParserleng; }; /* comment */ +"//".*$ {flex_xml_ch+=xmlParserleng; }; /* comment */ +"<?xml".*$ {flex_xml_ch+=xmlParserleng; }; /* comment */ + +.|\n {flex_xml_ch+=xmlParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); xmlParsererror(yytext);} + +%% + +int my_xmlParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_xml_stringinput != NULL){ + while(c<max_size){ + if(flex_xml_stringinput[flex_xml_stringinput_ptr] != '\0'){ + buf[c++] = flex_xml_stringinput[flex_xml_stringinput_ptr++]; + }else{ + break; + } + } + return(c); + } + + if(flex_xml_fileinput != NULL){ + while(c < max_size){ + inchar = getc(flex_xml_fileinput); + if(inchar != EOF){ + buf[c++] = inchar; + }else{ + break; + } + } + return(c); + } + + return(0); +} + +void xmlParser_setfileinput(FILE *f){ + xmlParserrestart(NULL); + + flex_xml_fileinput = f; + flex_xml_stringinput = NULL; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + +void xmlParser_setstringinput(char *s){ + xmlParserrestart(NULL); + + flex_xml_fileinput = NULL; + flex_xml_stringinput = s; + flex_xml_stringinput_ptr = 0; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + + + + + diff --git a/src/tools/xml.tab.cc b/src/tools/xml.tab.cc new file mode 100644 index 0000000..c589368 --- /dev/null +++ b/src/tools/xml.tab.cc @@ -0,0 +1,1645 @@ +/* A Bison parser, made by GNU Bison 2.3. */ + +/* Skeleton implementation for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Bison version. */ +#define YYBISON_VERSION "2.3" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + +/* Substitute the variable and function names. */ +#define yyparse xmlParserparse +#define yylex xmlParserlex +#define yyerror xmlParsererror +#define yylval xmlParserlval +#define yychar xmlParserchar +#define yydebug xmlParserdebug +#define yynerrs xmlParsernerrs + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259 + }; +#endif +/* Tokens. */ +#define NAME 258 +#define STRING_TOKEN 259 + + + + +/* Copy the first part of user declarations. */ +#line 8 "xml.y" + + + +#include <stdio.h> + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include <stdlib.h> + +/* prototypes for the parser callbacks. +*/ + +#include "xml_t.h" + + +extern xml_t *xml_result; + +extern int xmlParserdebug; +extern void xmlParsererror(char *s); +extern int xmlParserlex(); + + +#define YYDEBUG 1 + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 39 "xml.y" +{ + int intval; + double floatval; + char *strval; + int subtok; + struct name_val_pair_t *nvpt; + struct name_val_list_t *nvpl; + struct tag_t *tg_t; + struct xml_list_t *xlist_t; + struct xml_t *x_t; +} +/* Line 193 of yacc.c. */ +#line 152 "xml.tab.cc" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ + + +/* Line 216 of yacc.c. */ +#line 165 "xml.tab.cc" + +#ifdef short +# undef short +#endif + +#ifdef YYTYPE_UINT8 +typedef YYTYPE_UINT8 yytype_uint8; +#else +typedef unsigned char yytype_uint8; +#endif + +#ifdef YYTYPE_INT8 +typedef YYTYPE_INT8 yytype_int8; +#elif (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +typedef signed char yytype_int8; +#else +typedef short int yytype_int8; +#endif + +#ifdef YYTYPE_UINT16 +typedef YYTYPE_UINT16 yytype_uint16; +#else +typedef unsigned short int yytype_uint16; +#endif + +#ifdef YYTYPE_INT16 +typedef YYTYPE_INT16 yytype_int16; +#else +typedef short int yytype_int16; +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned int +# endif +#endif + +#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) + +#ifndef YY_ +# if YYENABLE_NLS +# if ENABLE_NLS +# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YYUSE(e) ((void) (e)) +#else +# define YYUSE(e) /* empty */ +#endif + +/* Identity function, used to suppress warnings about constant conditions. */ +#ifndef lint +# define YYID(n) (n) +#else +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static int +YYID (int i) +#else +static int +YYID (i) + int i; +#endif +{ + return i; +} +#endif + +#if ! defined yyoverflow || YYERROR_VERBOSE + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined _STDLIB_H \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef _STDLIB_H +# define _STDLIB_H 1 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ + + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yytype_int16 yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (YYID (0)) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (YYID (0)) + +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 6 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 25 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 9 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 9 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 14 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 26 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 259 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const yytype_uint8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 6, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 5, 8, 7, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const yytype_uint8 yyprhs[] = +{ + 0, 0, 3, 5, 9, 12, 18, 23, 28, 30, + 33, 35, 36, 38, 41 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yytype_int8 yyrhs[] = +{ + 10, 0, -1, 11, -1, 12, 14, 13, -1, 12, + 13, -1, 5, 3, 15, 6, 7, -1, 5, 3, + 15, 7, -1, 5, 6, 3, 7, -1, 11, -1, + 14, 11, -1, 16, -1, -1, 17, -1, 16, 17, + -1, 3, 8, 4, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const yytype_uint8 yyrline[] = +{ + 0, 65, 65, 69, 70, 71, 75, 79, 84, 85, + 89, 90, 94, 95, 99 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "NAME", "STRING_TOKEN", "'<'", "'/'", + "'>'", "'='", "$accept", "parse_result", "resource", "start_tag", + "end_tag", "xml_list", "opt_val_list", "val_list", "val", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const yytype_uint16 yytoknum[] = +{ + 0, 256, 257, 258, 259, 60, 47, 62, 61 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const yytype_uint8 yyr1[] = +{ + 0, 9, 10, 11, 11, 11, 12, 13, 14, 14, + 15, 15, 16, 16, 17 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const yytype_uint8 yyr2[] = +{ + 0, 2, 1, 3, 2, 5, 4, 4, 1, 2, + 1, 0, 1, 2, 3 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const yytype_uint8 yydefact[] = +{ + 0, 0, 0, 2, 0, 11, 1, 0, 8, 4, + 0, 0, 0, 10, 12, 0, 9, 3, 0, 0, + 6, 13, 0, 14, 5, 7 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int8 yydefgoto[] = +{ + -1, 2, 3, 4, 9, 10, 12, 13, 14 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -5 +static const yytype_int8 yypact[] = +{ + -3, 0, 5, -5, 4, 7, -5, -2, -5, -5, + 4, 3, 1, 7, -5, 9, -5, -5, 10, 6, + -5, -5, 8, -5, -5, -5 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int8 yypgoto[] = +{ + -5, -5, -4, -5, 11, -5, -5, -5, 12 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -1 +static const yytype_uint8 yytable[] = +{ + 8, 5, 1, 5, 15, 6, 16, 19, 20, 7, + 11, 18, 22, 24, 23, 25, 0, 0, 0, 0, + 0, 17, 0, 0, 0, 21 +}; + +static const yytype_int8 yycheck[] = +{ + 4, 3, 5, 3, 6, 0, 10, 6, 7, 5, + 3, 8, 3, 7, 4, 7, -1, -1, -1, -1, + -1, 10, -1, -1, -1, 13 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const yytype_uint8 yystos[] = +{ + 0, 5, 10, 11, 12, 3, 0, 5, 11, 13, + 14, 3, 15, 16, 17, 6, 11, 13, 8, 6, + 7, 17, 3, 4, 7, 7 +}; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK (1); \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ +while (YYID (0)) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (YYID (N)) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (YYID (0)) +#endif + + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (YYID (0)) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (YYID (0)) + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_value_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (!yyvaluep) + return; +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# else + YYUSE (yyoutput); +# endif + switch (yytype) + { + default: + break; + } +} + + +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else +static void +yy_symbol_print (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE const * const yyvaluep; +#endif +{ + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + yy_symbol_value_print (yyoutput, yytype, yyvaluep); + YYFPRINTF (yyoutput, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) +#else +static void +yy_stack_print (bottom, top) + yytype_int16 *bottom; + yytype_int16 *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (YYID (0)) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yy_reduce_print (YYSTYPE *yyvsp, int yyrule) +#else +static void +yy_reduce_print (yyvsp, yyrule) + YYSTYPE *yyvsp; + int yyrule; +#endif +{ + int yynrhs = yyr2[yyrule]; + int yyi; + unsigned long int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + fprintf (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], + &(yyvsp[(yyi + 1) - (yynrhs)]) + ); + fprintf (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyvsp, Rule); \ +} while (YYID (0)) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static YYSIZE_T +yystrlen (const char *yystr) +#else +static YYSIZE_T +yystrlen (yystr) + const char *yystr; +#endif +{ + YYSIZE_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +# endif + +# ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static char * +yystpcpy (char *yydest, const char *yysrc) +#else +static char * +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +#endif +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +# ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYSIZE_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYSIZE_T yyn = 0; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + /* Fall through. */ + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (! yyres) + return yystrlen (yystr); + + return yystpcpy (yyres, yystr) - yyres; +} +# endif + +/* Copy into YYRESULT an error message about the unexpected token + YYCHAR while in state YYSTATE. Return the number of bytes copied, + including the terminating null byte. If YYRESULT is null, do not + copy anything; just return the number of bytes that would be + copied. As a special case, return 0 if an ordinary "syntax error" + message will do. Return YYSIZE_MAXIMUM if overflow occurs during + size calculation. */ +static YYSIZE_T +yysyntax_error (char *yyresult, int yystate, int yychar) +{ + int yyn = yypact[yystate]; + + if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) + return 0; + else + { + int yytype = YYTRANSLATE (yychar); + YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); + YYSIZE_T yysize = yysize0; + YYSIZE_T yysize1; + int yysize_overflow = 0; + enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; + char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; + int yyx; + +# if 0 + /* This is so xgettext sees the translatable formats that are + constructed on the fly. */ + YY_("syntax error, unexpected %s"); + YY_("syntax error, unexpected %s, expecting %s"); + YY_("syntax error, unexpected %s, expecting %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s"); + YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); +# endif + char *yyfmt; + char const *yyf; + static char const yyunexpected[] = "syntax error, unexpected %s"; + static char const yyexpecting[] = ", expecting %s"; + static char const yyor[] = " or %s"; + char yyformat[sizeof yyunexpected + + sizeof yyexpecting - 1 + + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) + * (sizeof yyor - 1))]; + char const *yyprefix = yyexpecting; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 1; + + yyarg[0] = yytname[yytype]; + yyfmt = yystpcpy (yyformat, yyunexpected); + + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) + { + yycount = 1; + yysize = yysize0; + yyformat[sizeof yyunexpected - 1] = '\0'; + break; + } + yyarg[yycount++] = yytname[yyx]; + yysize1 = yysize + yytnamerr (0, yytname[yyx]); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + yyfmt = yystpcpy (yyfmt, yyprefix); + yyprefix = yyor; + } + + yyf = YY_(yyformat); + yysize1 = yysize + yystrlen (yyf); + yysize_overflow |= (yysize1 < yysize); + yysize = yysize1; + + if (yysize_overflow) + return YYSIZE_MAXIMUM; + + if (yyresult) + { + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + char *yyp = yyresult; + int yyi = 0; + while ((*yyp = *yyf) != '\0') + { + if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yyarg[yyi++]); + yyf += 2; + } + else + { + yyp++; + yyf++; + } + } + } + return yysize; + } +} +#endif /* YYERROR_VERBOSE */ + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +/*ARGSUSED*/ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + YYUSE (yyvaluep); + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +#if defined __STDC__ || defined __cplusplus +int yyparse (void *YYPARSE_PARAM); +#else +int yyparse (); +#endif +#else /* ! YYPARSE_PARAM */ +#if defined __STDC__ || defined __cplusplus +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + +/* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void *YYPARSE_PARAM) +#else +int +yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +#endif +#else /* ! YYPARSE_PARAM */ +#if (defined __STDC__ || defined __C99__FUNC__ \ + || defined __cplusplus || defined _MSC_VER) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + int yystate; + int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; +#if YYERROR_VERBOSE + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYSIZE_T yymsg_alloc = sizeof yymsgbuf; +#endif + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss = yyssa; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp; + + + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + yytype_int16 *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyexhaustedlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyexhaustedlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yytype_int16 *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyexhaustedlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + + /* Do appropriate processing given the current state. Read a + look-ahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to look-ahead token. */ + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a look-ahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the shifted token unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + yystate = yyn; + *++yyvsp = yylval; + + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: +#line 65 "xml.y" + {xml_result = (yyvsp[(1) - (1)].x_t);;} + break; + + case 3: +#line 69 "xml.y" + {(yyval.x_t) = new xml_t((yyvsp[(1) - (3)].tg_t),(yyvsp[(2) - (3)].xlist_t),(yyvsp[(3) - (3)].strval));;} + break; + + case 4: +#line 70 "xml.y" + {(yyval.x_t)=new xml_t((yyvsp[(1) - (2)].tg_t),(yyvsp[(2) - (2)].strval));;} + break; + + case 5: +#line 71 "xml.y" + {(yyval.x_t)=new xml_t((yyvsp[(2) - (5)].strval),(yyvsp[(3) - (5)].nvpl));;} + break; + + case 6: +#line 75 "xml.y" + {(yyval.tg_t) = new tag_t((yyvsp[(2) - (4)].strval), (yyvsp[(3) - (4)].nvpl));;} + break; + + case 7: +#line 79 "xml.y" + {(yyval.strval)=(yyvsp[(3) - (4)].strval);;} + break; + + case 8: +#line 84 "xml.y" + {(yyval.xlist_t)=new xml_list_t((yyvsp[(1) - (1)].x_t));;} + break; + + case 9: +#line 85 "xml.y" + {(yyval.xlist_t)=(yyvsp[(1) - (2)].xlist_t)->append((yyvsp[(2) - (2)].x_t));;} + break; + + case 10: +#line 89 "xml.y" + {(yyval.nvpl)=(yyvsp[(1) - (1)].nvpl);;} + break; + + case 11: +#line 90 "xml.y" + {(yyval.nvpl)=new name_val_list_t();;} + break; + + case 12: +#line 94 "xml.y" + {(yyval.nvpl) = new name_val_list_t((yyvsp[(1) - (1)].nvpt));;} + break; + + case 13: +#line 95 "xml.y" + {(yyval.nvpl) = (yyvsp[(1) - (2)].nvpl)->append((yyvsp[(2) - (2)].nvpt));;} + break; + + case 14: +#line 99 "xml.y" + {(yyval.nvpt) = new name_val_pair_t((yyvsp[(1) - (3)].strval),(yyvsp[(3) - (3)].strval));;} + break; + + +/* Line 1267 of yacc.c. */ +#line 1428 "xml.tab.cc" + default: break; + } + YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if ! YYERROR_VERBOSE + yyerror (YY_("syntax error")); +#else + { + YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); + if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) + { + YYSIZE_T yyalloc = 2 * yysize; + if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) + yyalloc = YYSTACK_ALLOC_MAXIMUM; + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = (char *) YYSTACK_ALLOC (yyalloc); + if (yymsg) + yymsg_alloc = yyalloc; + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + } + } + + if (0 < yysize && yysize <= yymsg_alloc) + { + (void) yysyntax_error (yymsg, yystate, yychar); + yyerror (yymsg); + } + else + { + yyerror (YY_("syntax error")); + if (yysize != 0) + goto yyexhaustedlab; + } + } +#endif + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse look-ahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse look-ahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + + /* Pacify compilers like GCC when the user code never invokes + YYERROR and the label yyerrorlab therefore never appears in user + code. */ + if (/*CONSTCOND*/ 0) + goto yyerrorlab; + + /* Do not reclaim the symbols of the rule which action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + yystos[yystate], yyvsp); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*-------------------------------------------------. +| yyexhaustedlab -- memory exhaustion comes here. | +`-------------------------------------------------*/ +yyexhaustedlab: + yyerror (YY_("memory exhausted")); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: + if (yychar != YYEOF && yychar != YYEMPTY) + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval); + /* Do not reclaim the symbols of the rule which action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + yystos[*yyssp], yyvsp); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif +#if YYERROR_VERBOSE + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); +#endif + /* Make sure YYID is used. */ + return YYID (yyresult); +} + + +#line 106 "xml.y" + + + + diff --git a/src/tools/xml.tab.hh b/src/tools/xml.tab.hh new file mode 100644 index 0000000..b100c6a --- /dev/null +++ b/src/tools/xml.tab.hh @@ -0,0 +1,76 @@ +/* A Bison parser, made by GNU Bison 2.3. */ + +/* Skeleton interface for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + NAME = 258, + STRING_TOKEN = 259 + }; +#endif +/* Tokens. */ +#define NAME 258 +#define STRING_TOKEN 259 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 39 "xml.y" +{ + int intval; + double floatval; + char *strval; + int subtok; + struct name_val_pair_t *nvpt; + struct name_val_list_t *nvpl; + struct tag_t *tg_t; + struct xml_list_t *xlist_t; + struct xml_t *x_t; +} +/* Line 1529 of yacc.c. */ +#line 69 "xml.tab.hh" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +extern YYSTYPE xmlParserlval; + diff --git a/src/tools/xml.y b/src/tools/xml.y new file mode 100644 index 0000000..01f4c46 --- /dev/null +++ b/src/tools/xml.y @@ -0,0 +1,123 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + + /* + MUST COMPILE WITH + bison --verbose -d -p xmlParser -o xml.tab.cc xml.y + + (or equivalent). +*/ + +%{ + + +#include <stdio.h> + +/* Some addn'l includes, necessary but not included by the + bison generated code. +*/ + +#include <stdlib.h> + +/* prototypes for the parser callbacks. +*/ + +#include "xml_t.h" + + +extern xml_t *xml_result; + +extern int xmlParserdebug; +extern void xmlParsererror(char *s); +extern int xmlParserlex(); + + +#define YYDEBUG 1 + +%} + + + /* symbolic tokens */ + +%union { + int intval; + double floatval; + char *strval; + int subtok; + struct name_val_pair_t *nvpt; + struct name_val_list_t *nvpl; + struct tag_t *tg_t; + struct xml_list_t *xlist_t; + struct xml_t *x_t; +} + +%token <strval> NAME +%token <strval> STRING_TOKEN + +%type <nvpt> val +%type <nvpl> val_list +%type <nvpl> opt_val_list +%type <strval> end_tag +%type <tg_t> start_tag +%type <xlist_t> xml_list +%type<x_t> resource + + +%% + +parse_result: resource {xml_result = $1;} + ; + +resource: + start_tag xml_list end_tag {$$ = new xml_t($1,$2,$3);} + | start_tag end_tag {$$=new xml_t($1,$2);} + | '<' NAME opt_val_list '/' '>' {$$=new xml_t($2,$3);} + ; + +start_tag: + '<' NAME opt_val_list '>' {$$ = new tag_t($2, $3);} + ; + +end_tag: + '<' '/' NAME '>' {$$=$3;} + ; + + +xml_list: + resource {$$=new xml_list_t($1);} + | xml_list resource {$$=$1->append($2);} + ; + +opt_val_list: + val_list {$$=$1;} + | {$$=new name_val_list_t();} + ; + +val_list: + val {$$ = new name_val_list_t($1);} + | val_list val {$$ = $1->append($2);} + ; + +val: + NAME '=' STRING_TOKEN {$$ = new name_val_pair_t($1,$3);} + ; + + + + + +%% + + diff --git a/src/tools/xml_t.cc b/src/tools/xml_t.cc new file mode 100644 index 0000000..68941ab --- /dev/null +++ b/src/tools/xml_t.cc @@ -0,0 +1,47 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#include "xml_t.h" + +using namespace std; + +xml_t::xml_t(tag_t *s, xml_list_t *xl,const char *e){ + name=s->name; + attribs = s->nvp_list; + subtrees = xl->xlist; + end_tag_name = e; +} + +void xml_t::get_roots(string type, vector<xml_t *> &ret){ + if(name==type){ + ret.push_back(this); + }else{ + int i; + for(i=0;i<subtrees.size();++i){ + subtrees[i]->get_roots(type,ret); + } + } +} + +void xml_t::get_roots(set<string> type, vector<xml_t *> &ret){ + if(type.count(name)>0){ + ret.push_back(this); + }else{ + int i; + for(i=0;i<subtrees.size();++i){ + subtrees[i]->get_roots(type,ret); + } + } +} diff --git a/src/tools/xml_t.h b/src/tools/xml_t.h new file mode 100644 index 0000000..c17ad68 --- /dev/null +++ b/src/tools/xml_t.h @@ -0,0 +1,148 @@ +/* ------------------------------------------------ +Copyright 2014 AT&T Intellectual Property + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ------------------------------------------- */ + +#ifndef __XML_T_DEFINED_ +#define __XML_T_DEFINED_ + +#include <stdio.h> +#include<vector> +#include<string> +#include<map> +#include<set> +#include<algorithm> + + +void xmlParser_setfileinput(FILE *f); +void xmlParser_setstringinput(char *s); + + + +struct name_val_pair_t{ + std::string name; + std::string val; + + name_val_pair_t(const char *n, const char *v){ + name = n; + val = v; + } +}; + +struct name_val_list_t{ + std::vector<name_val_pair_t *> nvp_list; + + name_val_list_t(){ + } + + name_val_list_t(name_val_pair_t *nvp){ + nvp_list.push_back(nvp); + } + + name_val_list_t *append(name_val_pair_t *nvp){ + nvp_list.push_back(nvp); + return this; + } +}; + +struct tag_t{ + std::string name; + std::vector<name_val_pair_t *> nvp_list; + + tag_t(const char *n, name_val_list_t *nvl){ + name=n; + nvp_list = nvl->nvp_list; + } +}; + + +struct xml_list_t; + +struct xml_t{ + std::string name; + std::string end_tag_name; + std::vector<name_val_pair_t *> attribs; + + std::vector<xml_t *> subtrees; + + xml_t(){} + + xml_t(tag_t *s, xml_list_t *xl,const char *e); + + xml_t(tag_t *s, char *e){ + name=s->name; + attribs = s->nvp_list; + end_tag_name = e; + } + + xml_t(const char *n, name_val_list_t *nvl){ + name=n; + attribs=nvl->nvp_list; + } + + std::string to_string(){ + return to_string(""); + } + std::string to_string(std::string indent){ + std::string ret; + std::string whitespace; + int i; + + ret += indent+"<"+name; + for(i=0;i<attribs.size();++i) + ret += " "+attribs[i]->name+"="+attribs[i]->val; + + if(subtrees.size()>0){ + ret+=">\n"; + for(i=0;i<subtrees.size();++i){ + ret += subtrees[i]->to_string(indent+" "); + } + ret += indent + "</"+name+">\n"; + }else{ + ret+=">\n"; + } + return ret; + } + + void get_roots(std::string type, std::vector<xml_t *> &ret); + void get_roots(std::set<std::string> type, std::vector<xml_t *> &ret); + + bool get_attrib_val(std::string name, std::string &val){ + val=""; + int i; + for(i=0;i<attribs.size();++i){ + if(attribs[i]->name == name){ + val = attribs[i]->val; + return true; + } + } + return false; + } + +}; + +struct xml_list_t{ + std::vector<xml_t *> xlist; + + xml_list_t(xml_t *x){ + xlist.push_back(x); + } + + xml_list_t *append(xml_t *x){ + xlist.push_back(x); + return this; + } +}; + +#endif + diff --git a/src/tools/xmllexer.cc b/src/tools/xmllexer.cc new file mode 100644 index 0000000..deee69e --- /dev/null +++ b/src/tools/xmllexer.cc @@ -0,0 +1,1788 @@ +#define yy_create_buffer xmlParser_create_buffer +#define yy_delete_buffer xmlParser_delete_buffer +#define yy_scan_buffer xmlParser_scan_buffer +#define yy_scan_string xmlParser_scan_string +#define yy_scan_bytes xmlParser_scan_bytes +#define yy_flex_debug xmlParser_flex_debug +#define yy_init_buffer xmlParser_init_buffer +#define yy_flush_buffer xmlParser_flush_buffer +#define yy_load_buffer_state xmlParser_load_buffer_state +#define yy_switch_to_buffer xmlParser_switch_to_buffer +#define yyin xmlParserin +#define yyleng xmlParserleng +#define yylex xmlParserlex +#define yyout xmlParserout +#define yyrestart xmlParserrestart +#define yytext xmlParsertext + +#line 19 "xmllexer.cc" +/* A lexical scanner generated by flex*/ + +/* Scanner skeleton version: + * $Header: /cvsroot/gscpv4/src/tools/xmllexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include <stdio.h> +#include <unistd.h> + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include <stdlib.h> + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include <io.h> +#include <stdlib.h> +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* Some routines like yy_flex_realloc() are emitted as static but are + not called by all lexers. This generates warnings in some compilers, + notably GCC. Arrange to suppress these. */ +#ifdef __GNUC__ +#define YY_MAY_BE_UNUSED __attribute__((unused)) +#else +#define YY_MAY_BE_UNUSED +#endif + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED; +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + + +#define yywrap() 1 +#define YY_SKIP_YYWRAP +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yytext_ptr -= yy_more_len; \ + yyleng = (int) (yy_cp - yytext_ptr); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 11 +#define YY_END_OF_BUFFER 12 +static yyconst short int yy_accept[32] = + { 0, + 0, 0, 12, 10, 6, 5, 10, 10, 1, 1, + 1, 2, 6, 5, 0, 4, 3, 0, 0, 0, + 2, 0, 7, 0, 8, 0, 0, 0, 0, 9, + 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 4, 1, + 1, 1, 1, 1, 5, 1, 6, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 1, 8, + 9, 9, 10, 1, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 1, 1, 1, 1, 11, 1, 11, 11, 11, 11, + + 11, 11, 11, 11, 11, 11, 11, 12, 13, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 14, + 11, 11, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[15] = + { 0, + 1, 1, 2, 1, 3, 1, 3, 1, 1, 1, + 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[38] = + { 0, + 0, 0, 48, 49, 45, 0, 12, 41, 39, 34, + 49, 0, 41, 0, 14, 49, 49, 39, 38, 26, + 0, 36, 49, 35, 49, 24, 24, 32, 31, 49, + 49, 18, 21, 17, 24, 27, 30 + } ; + +static yyconst short int yy_def[38] = + { 0, + 31, 1, 31, 31, 31, 32, 33, 31, 31, 31, + 31, 34, 31, 32, 33, 31, 31, 35, 36, 31, + 34, 35, 31, 36, 31, 31, 31, 37, 37, 31, + 0, 31, 31, 31, 31, 31, 31 + } ; + +static yyconst short int yy_nxt[64] = + { 0, + 4, 5, 6, 7, 8, 9, 4, 10, 11, 4, + 12, 12, 12, 12, 16, 17, 16, 17, 14, 21, + 14, 15, 15, 15, 22, 22, 22, 24, 24, 24, + 29, 29, 29, 30, 30, 28, 27, 25, 23, 26, + 25, 23, 13, 20, 19, 18, 13, 31, 3, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31 + } ; + +static yyconst short int yy_chk[64] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 7, 7, 15, 15, 32, 34, + 32, 33, 33, 33, 35, 35, 35, 36, 36, 36, + 37, 37, 37, 29, 28, 27, 26, 24, 22, 20, + 19, 18, 13, 10, 9, 8, 5, 3, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +static int yy_more_flag = 0; +static int yy_more_len = 0; +#define yymore() (yy_more_flag = 1) +#define YY_MORE_ADJ yy_more_len +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "xml.l" +#define INITIAL 0 +/* + MUST COMPILE WITH + flex -PxmlParser -oxmllexer.cc xml.l + (or equivalent). +*/ +#line 9 "xml.l" +/* + * AT&T lex can't handle this lexer due to lex bugs. It works with flex + * 2.3.7, pclex 2.0.5, and MKS lex 3.1a. + */ + + // #include "parse_fta.h" + #include <string.h> + + + +#include "xml.tab.hh" + +/* + Some includes that flex doesn't include as standard, + but which are needed. +*/ + +#include <stdlib.h> +#include <string.h> + + +// Prevent flex from defining yywrap as extern "C" + +#define YY_SKIP_YYWRAP + +/* No lex lib, supply the yywrap fcn. that normally resides there +*/ + +int xmlParserwrap(){return(1);} + +extern int xmlParserdebug; + + +/* + These variables are used for error reporting: + flex_xml_lineno : the line currently being parsed when the error occurs. + flex_xml_ch : the character on the line where the error occurs + flex_xml_linebuf : store the line for reporting. + + NOTE : 1) the fixed size flex_xml_linebuf buffer is dangerous. + 2) You might get pointed to a place shortly after + where the syntax error occurs. It is close enough + for now. +*/ + +int flex_xml_lineno = 1; +int flex_xml_ch = 0; +char flex_xml_linebuf[20000]; + +char *flex_xml_stringinput = NULL; +int flex_xml_stringinput_ptr = 0; +FILE *flex_xml_fileinput = NULL; +int my_xmlParser_yyinput(char *buf, int max_size); + + + +void xmlParsererror(char *s){ + int i; + fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n", + flex_xml_lineno, flex_xml_ch, s, xmlParsertext, flex_xml_linebuf ); + for(i=0;i<flex_xml_ch;i++){ + if(flex_xml_linebuf[i] == '\t'){ + fprintf(stderr,"\t"); + }else{ + fprintf(stderr," "); + } + } + fprintf(stderr,"^\n"); + // fprintf(stderr,"%*s\n",1+flex_xml_ch,"^"); +} + +#undef YY_INPUT +#define YY_INPUT(b, r, ms) (r = my_xmlParser_yyinput(b,ms)) + +/* MKS needs the next line to increase the NFA table */ +#line 499 "xmllexer.cc" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include <stdlib.h> +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 88 "xml.l" + + + /* literal keyword tokens */ + + /* + The actions associated with each text token are to + keep track of the current location (for syntax error reporting) + and to report any necessary info to the emf.y parse tree builder + + Its likely that there are a number of omissions, inconsistencies + (some keywords do not need to be in caps), and relics + (keywords such as BETWEEN, INDICATOR, etc., are not used + in emf.y) + This parser is somewhat of a work in progress. + */ + + /* Query keywords */ + + + + +#line 672 "xmllexer.cc" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_more_len = 0; + if ( yy_more_flag ) + { + yy_more_len = yy_c_buf_p - yytext_ptr; + yy_more_flag = 0; + } + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 49 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 109 "xml.l" +{ flex_xml_ch+=xmlParserleng; return yytext[0]; } + YY_BREAK +/* names */ +case 2: +YY_RULE_SETUP +#line 113 "xml.l" +{ flex_xml_ch+=xmlParserleng; xmlParserlval.strval = strdup(yytext); return NAME; } + YY_BREAK +/* strings */ +case 3: +YY_RULE_SETUP +#line 118 "xml.l" +{ + + int c; + + xmlParserlval.strval = strdup(xmlParsertext+1); + + c = yyinput(); + + unput(c); /* just peeking */ + if(c != '\'') { + flex_xml_ch+=xmlParserleng; + xmlParserlval.strval[xmlParserleng-2] = '\0'; + return STRING_TOKEN; + } else + yymore(); + } + YY_BREAK +case 4: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 135 "xml.l" +{ flex_xml_ch+=xmlParserleng; xmlParsererror("Unterminated string"); } + YY_BREAK +/* */ +/* Newline : advance the error reporting line number */ +/* and grab the next line into flex_xml_linebuf */ +/* */ +case 5: +YY_RULE_SETUP +#line 142 "xml.l" +{flex_xml_ch=0; flex_xml_lineno++; + strcpy(flex_xml_linebuf,xmlParsertext+1); + yyless(1); + } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 147 "xml.l" +{flex_xml_ch+=xmlParserleng; } /* white space */ + YY_BREAK +case 7: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 149 "xml.l" +{flex_xml_ch+=xmlParserleng; }; /* comment */ + YY_BREAK +case 8: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 150 "xml.l" +{flex_xml_ch+=xmlParserleng; }; /* comment */ + YY_BREAK +case 9: +*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ +yy_c_buf_p = yy_cp -= 1; +YY_DO_BEFORE_ACTION; /* set up yytext again */ +YY_RULE_SETUP +#line 151 "xml.l" +{flex_xml_ch+=xmlParserleng; }; /* comment */ + YY_BREAK +case 10: +YY_RULE_SETUP +#line 153 "xml.l" +{flex_xml_ch+=xmlParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); xmlParsererror(yytext);} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 155 "xml.l" +ECHO; + YY_BREAK +#line 852 "xmllexer.cc" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 32 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 31); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 155 "xml.l" + + +int my_xmlParser_yyinput(char *buf, int max_size){ + int c = 0; + int inchar = 0; + + if(flex_xml_stringinput != NULL){ + while(c<max_size){ + if(flex_xml_stringinput[flex_xml_stringinput_ptr] != '\0'){ + buf[c++] = flex_xml_stringinput[flex_xml_stringinput_ptr++]; + }else{ + break; + } + } + return(c); + } + + if(flex_xml_fileinput != NULL){ + while(c < max_size){ + inchar = getc(flex_xml_fileinput); + if(inchar != EOF){ + buf[c++] = inchar; + }else{ + break; + } + } + return(c); + } + + return(0); +} + +void xmlParser_setfileinput(FILE *f){ + xmlParserrestart(NULL); + + flex_xml_fileinput = f; + flex_xml_stringinput = NULL; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + +void xmlParser_setstringinput(char *s){ + xmlParserrestart(NULL); + + flex_xml_fileinput = NULL; + flex_xml_stringinput = s; + flex_xml_stringinput_ptr = 0; + flex_xml_lineno = 1; + flex_xml_ch = 0; +} + + + + + diff --git a/src/views/README.md b/src/views/README.md new file mode 100644 index 0000000..e69de29 diff --git a/tigon.png b/tigon.png new file mode 100644 index 0000000000000000000000000000000000000000..35b403c655c22e369e10c7243f0b99244f1bea93 GIT binary patch literal 52783 zcma%CgL5U#*N!%}ZQI7i#>TdNb7R}ajkO!wwvA0T*kohd#+Uc^7ko9<)l*Y7)!j3P z&v{Oiijp)EJU%=a7#NbQjD+gfJOc&>&Ik+rbr-W2`}{RQo61W|fPMaV6?B)Td_944 zmeB!z%`*QRQsZ{QU|@k@vJ#@|o`28Yy_zgmH8!F?4)pCVfive$cYgG*!fCcDEZ`6( z-`n~~)wTu{gA~o)qAMDV;<WBJaQA;)zHeKlZ_@T@j7SE7g-{Y?OX13Lo`m6ts;)j7 zm`j-7O~<X}03QtPW*$fX9*)F~MW(V7l~1Lb+7^*JVjP||K4#fXAH4R^U0mqbGq?{M zCLT}vfoq*bcjKQ&?|wacAV2$m&Wt_lIL^a{t1b1@G~_Ig`(37I6H&n7rRjgOz*L6r zYxy;-(P!*dgj|c8?x?7-w3GvKYAsTp&5nbMQzgLmX3(K;_qEUFiTnQ0Gd2&0z^u(y z4lo1nN?*FeR7)v`p{3tthLME@L(JIQ+xy>-8r~`3xtzwihBZzeYWmA+@rQq5+^88c ziSShS<HqDakIiYLSG#~Xo~~`AA>3tP0mBTi#{iI{RW4*yU~HN0it9mhIOWW1{`v7P z__P%wcr!*Jc)zGd$m<+PB;bB!Ch}kwiVD`lJo>8H#1MZ=&xNLAG=;-IAC|_-VaADH z-_$gOp)A<{-(rv`f_?oVFnn$&n09t{dpYG5(In4FB-<yIwZfP8G__vCGpksmURZ0x z17&eh@8c;nd@g%q9gY93`QLim&TalTW%L!%ne`r*h8rIbt!f&7(l8F}R{neI?;fWL zljQt()B-1xbUfkq^(e_<k~H!5yfn%FacTa+(flt?#m0|Inoq|a&I_g3B%Yq@IQ@Y4 z`_oInFtdXe;h}~tx!76@VuUy{vEbPI<L2ytV^>*lrvBF`ug?Rc;zB`1<PlJ;7Gbb! zcvy1d{la76^078GzZbc4hqsnp&p>DUDauR`xJCLXas~Fd;lrXV^3G|MKEvvW&&VeV zL9Q|!8AG<Qvsge%Yl$bp>LKQ_)Aey*dl)Zp(Pq8jI-Hbe_q7l9wOgt)oR68|kMpoz zfpLvIuY=5c)U#`8lHFs-R~@`+6FLl7+G0{v4OBws^?m@voHoiIwjD9lVOEK69A@tB zpv&jH%fjVTgFElq|NejUZWmO`JUF*$KXY@6vOl#dw#x!%4lf`$g2X@L^|CiWs9ePB zhH`Ko7lW!}j$#Y8BpAG#&|2J-5Ivlf?`L~NB}XI@^FSns{u`kr)Oy_4ZbQ}_JI|v- zy1>3pp1#U`fSOYAXXMgB;e=+>DJ#6Vm@1xFXhIxCXy`u)qeu`Oh{B-J*3<jtu;w<3 z4lo^~m76g5hBP=9%aw>amPD5$DLbVVRcSWqn$}i%d~5D9WCr(#k&TOMSYY#6iQ8$z z_uJev#FvhBL2<(ki@~0jPVD($l<Mf|?amd73%=hi2)-Qs61?hz6nx%G$>9Tr=Wy^@ z6{z=c_b5@KCMQ!Z$PJ(oQpuPXAZ1Ie6wfeE+apD_8&5@E$;{-~AXx;KQ#7^l@oacf zIC(E*!;)2*E!6PNF1LJ1H2T_z^Z8UJ$Nv_&n-dp&yBhqT2JpK^?(gs4x=^5zjYMXe zSe}-GI?dqW1_jkB>q$qrgQ`VWN(XW{r)+<cCk?ZOHVba$x%b)BmJ21COQ@8c5<B^w z>a8|f&0<|lBmAd2=oyj5tGLJ!Il_Kfqr?HRK9|QG_Yuf04`(`>T3Y?0A;EQIn2<o0 zG!`%<N{_`t^fIAF+*k+rS91IGp&V-Z@eEqe=h}PW3sg!#;86cMO`<3|ap5$UkH`7J zTJO8TY3cNrH92i%h+kMO=B2@rKVuozvsnXS&?r0atqux4T<xw0d_oFdU4;+|e=ypZ zYjY=al7>SU-UP-Ns}e#o&`4lQvi=lkre83%PX~3gHF8+CSd&Mh%DJQLw*nXf5O$i# z$ZX(ErgnGvKn}6TffX7O9Owia&ov&-e>Aje1*V6+1#w>2zwG92j#au#q-^u4X^b5& zq07-68L`h98?o0OTAuG48gal2Ts)yjP<w$6TulMqVp$aK)=pEuirNr)94>PdzBXxH zU|scueFDQ-tl5F=9e5-q9ag=n{RXNjT_V&EGIQ~Pj9={s<K|81XhB8cZH;~l+&!<I zJuwy0hkki+e5+xby%2+ZR$7EsA&S@|VHW1RFlu-Sqg6FEE>~Nk7ww0{7oC^F$b`Io z^=6~my1G9V<40VQdGV0GyNAZgJ$m5iL+oIM7yhk7#Skd6$j9vrsVkVH!JtH=+?CL+ zWrL7=)$iaKCR4X<2&9I@yUmyeNYDqTf5exgp>BK}v;xn$mTNv=5#;xclsAv{R%>`? zzO~GIQ5&%^F#&G&Wb=G)WdGX)vG0{=p7#k|_#m0$LQZ<$Xh9iX5*QTXScQ2MZafTG za;Di-FtvMBy>i$z8!Jr`DHF4qKA3mLH<#9<q*yuV^g~|0z&5g<oVJK!Td{BnoY7v! zBT&mzx=Qw&Eg>Gghe8U9%K4A0Jeq%)1x;#Kp52E5+$&P%*Ym%mzif_`=iR*Y@~433 z73uCZF0V*VHfj%;nDy8}Z1G4`29*T+0yGdJo8C%V=4^2aJ1mIz#GxHbt06=l#f_#d ztqz&)^HOsT44v8izKu5T%e$0c9ktCy5taegIaYJalG=}TkO}!^J}+t;+Umy6&KMUK z7Vci(?`OHe0}OE+4C+m_$`&xC@e)P|1>93%h&=;eiQDpN@;rkFXNeD<qIP4Y&D5bX z3zEPkXC_&4l1nSUL!es7u?yI&VC0^YHR9%Y<<RjE{z9X}YEIrX+ecZXsbxCs!6t)b zcD^Y6N8qt3os$SjK7*$GwtB)j>y5IEjjEeEk=g@&@@#Wpd6<!#XX)slSFP9DU@?i^ zV*hWTCbx5?#epE3+riY*GQ6T<DQQtFr*x$?XIFovJK&_e^y%zSc=X?wtK&csnHVot z%W;Tka`?&KAM%qKiUGE+N(sBvy&tZ~5e>$JKFG_hC44Gxr9n*(o9(3{67x+PhT>Ey znR)%^WcdVE9s<U(eraV67R>_sM;Is%t_X}RQ5IGyEsUo7K&{$^R!iN{yw<r8(pRn> z5$1ZmyOu&UiVgKNTC`Rf5eoqU;cTTordqG1!EY4V{d~Ruo=1PwZP~!XFypEENMX|@ zzOmj2aI#4EG2Huv^Y%<5EQ(G;EovZNO>cgMNc>%X7Y&9@Qb8V0$AmPq+WaAO>cQ9^ ziIqtzU&56FTvo3ByXQr<d+A`TpC7uyj@W+mafTE-IaWr&P7}293SvG1w9)}F6u4bK zncYZ8Ap{!^41o<Cqy|JVIdvN!Gc^1G9_@2BG%R}iL)Pgt$>->2(ti#`uS4OT>5!LT zvXbQeNc#Ek^DV!z%NImSRqqZ|hs2Y)xT_+Ma*J8akjkX0)8f!GoouPFh@mX`2diTp zvXjE@uEp$bB2*Z0Xk?AE0Ly!6$DW8*nS|@?gcfTb)cH57*Pa37kTs!KKo$|5_^mWF zVk6hNZHqoI_i#puj=hZb!WcPHbw(JHXXAOs<3{;oTtr8j(3gRKrqvwK_m2;-0~K&X z6EJXd!ya6Kj7L$Pg4Km(TRq;Np=w1^C(quwo1xgBi9|vF$c%udizNkas=C-jNWm*d zo+$Ive9z8s`PNUUo-j39Mg|VcN(0)r9j#|^sfiC=oO--X{aW=Wa#XoWAs&7R7gAM} zN+!AEcjo;Y=0J%~R7A3}EzravCRyig7>jSv=1cYF&SAjEVP<x=Pdmxsr0J$=Jjb}x zdM=Cqb<Dco<3EEQ3|9JN-kr?$932%i;GeomU5my(ZZu0kY6HTdU>}<T;w7s|ylEkw zKqo_SXhFuPZ1hbqs|n8jy=Rd~d<M7YR8B+IYy$m-)2lfYTxL>SB>hyovtsSel6U5F z1}t1S9!Q<fY$RDaTu0kY`=Jki0+z~0qXJ3uri64K=mVoa&38-l^|j8{TAd8g4)x9# zpFu7;QMrO%$s#YmL`*F#ieWWi%>gf7WA|y!^3E-`;=Sx8)Z<+OvV<6;O*xcpKcN=M zyrrp*UU=v&`Ux-*bt23*tZ~F?^<%*f4FKOKwxyQXPBI5=`iz={h#eS)Fma^0>f2o$ zRkpEhR#fvXCa`9iN=B*%+<y#Vbrr|4QrAhDPaB)h;KAig*PRULK$JE%o<NjXdsKf# zqrO)mB<8buLcXIOzN3@xGQHamil@9dVv_3ezw^Hde`fY>CB2eRRu+<HFpS3%k#{vN z*R>-UILi>rlPPH9Am*J_D~+R0=(6X;%AffIR3#aD!}2SCDxP@(iLR5|FyJ=C;$>76 z(tpGWrj$J0(cUy^nTM*xWiAg*pR8l&p8rL+kx8~GqxH+XHwcWPs2sq|q(h|hRMWKq zVBljx?O#RTSZ(ZvN=WEV<<dX$x<1i<F28;%w>bTqnr_|j-|+jiY<03dKZ+y7ZA`u* z7V-@hc{vI&b!!qsEu5gDIfmIC(bdkG8=z#xrYqFu<3VN7U^+$}`^`n&8O*G7#GY5P zBFHDy#k(9P`#J2Ab-yq=Nr!%e4<2C~IS$V@edEcowQFV)P!WaqFrMgyBJSU%<m;iJ zKb>(DwPeRR>rrb+$~SD&@hA>}kh1BbjtDKFR%b>WyK@L5C=KIz$hEQi4gvKYy_pte z;}Ny@#jbazP&^{<c9mKt)Jf{K#4QH_Ji9_pDN{M%MosW(ECiLbsQ{ZTH21HI8X<;C z0|=GTh_cDMp2NInsn^Sqc>$f$L?a(StCUqVs^zjp;V@iJc@{k)@DfFW-zRVaI%g+; zN#v46gv`L-`E`$aecG*g%<5J^`K=Ypu~w?9=Fr+!7M8kLov8fj?XY(YM)(R`Q&Te! zINPgpp3Sem_T+)adv|8?akiUp?BEb4Jj^$uv0b&!oGFRNwuG-%w^T04<2ZNva34;N zBVfXeRUyRFOUKJIX$D<_=n&4LyC<KQu@Jtj2*;yE!L1{X+D|zbiB7wJFu^`&ng#H7 z7L~j-{k}Br)&l=t;OSy|lq59Y3R=FWuxfA)sFD2v$A=b}qxbQY@R{NF`f%Oz*zH7A zb30Ag;J3g(6SmY6rR;Z-B6v3kx#%W|E6yM{m|@qnA3h;U&X-!iAYbzE-KW1DxNZ96 z4FtvTjSs)@A7bmvj|I^RDH*S?LB~^iTCo6t)l)Vx$EY!ea&www+GyKXU?rqn+=V1v z1-8UZx>-e*Xb5PdnQ3HBr;7FLa)N0BsFjw21e24KZ%a<^*aGfnTSS+hqdeWWzG`{J zIC<O`GeM9rPYVhDh$IQJpqK?HlfM`qP!^hc$%;RU6{hf_lztY?;ruK%nz|Rv*Iyj& z#bHGQ3AvCiBYIDES-FRKNLYzVL(R&lZ7<Q-N^~Egn1>Ovm(^-*Gh5*B-|qEhKvK_1 z4N`>=oZtaWe5{{ZJ~FD=nad&w3l{(azE7;ZAE&)DW(h(MiV0Qze*|X2U^il9ncD^O z-}Y#{&c<n+gRI4nkvAIjAbEz^R^t@b+@7%X;kBSer&S<}p(|8rckK=tjV8yLi@quJ zz_?DS49lD$nHl1k<Vi3@Y353aib>W5nh$gRBv!#FG7BbO!lGxsDBB3DjNT$JmTW^8 zGQKc((~q+b&RPg(TOJ0rLY0;j4o4C9Q;<*ieI-J*pCe8#J44sE7xT-&d_%?IP$&4& z_LY1UXsRgK1d$J3lGl|{Yc)Mg6Gl={COJ?qG^puY1&OW#7S6fxn9}c1c`3>e9w_BS zj5_Ms00<!?T#s@Uhe0Pyelb?dZ)3q;K@d?m_NzrZJljDX+CjPq88XYMe!}b7Xl(Q_ z)5Teu=~dqZ)!NAonjOjlVK0KVW|)Ky;|(G35$Tlh<t!iCl>?$TpU*c<nlU_joq^d3 zL2E~}wJmiQ8kf8{2t3r-Vg)w%A8)gtIaYaI&~B$I!)WP!J@Agm6a`sb1JAW_Dms+% z34qwW3}*+~8lt$qSp)zx$T^^!H47o&uxoSes-3wQ%)310(e#qXD-IK1*Jg73B$%Aj zyn&n2X517?4H}9QQ&((^OExvH>gK_F>OKoE0{fRJleiM+bmZpepvaEM`!>l!%lV6& zKCQ^TEiu_mg-1@5qIL|<-`xa}85)siSyj16+7eA`a9EzvaDUwNj}d4A7S{=}rtj9@ zxR?sEk;D#C9ydIRaC~xO{N8=@_w5e98@)dEf;0@thJv>=X~GmR^r(%=^1(Dy=H-!h zV8gu&0NRw-@p+9Y0J<vAZ|ZIE@>WW>B*IssJ#YIg`C57YJv$SX<A#6Y8v&!6GWWTH zW%JfU`5(vmH&Yz5u36^au48Cw;AglBEvg7S*$=xtpO?y(=SH~HNA3hw+9AXf<qwf( zTl-k<`3!9nUw{K*9-QC4Uz3(uy;O6oNt`VHN|y(6!I-J@Rb!qs+tFh>5V3NbD03YM zgwz*gQp5IBTm)A%er|ER8TCHc34T27o@%s2&FzfXJxlq1Oghxsj{cV=XIkZ%czHc{ z{ZlCNt&%43OHBxP+da(!%OI1mL^IT~uoTdiN9X6A;JalOz-__`Im1mFR7_CwiVj3K zA!==AQ-8@?43g*lYq9FJ->wUl?y4Ee&0iCB#3U3^#5L;Hm%>)3j>XyRJtBS_VVgXl zNkx&z`lF$BT|2?ck8nPn>>zVu(k2ayxb4&5|9sg$POVg_x-wa*#>vYoGXw^?uBGJx z$w=U{{h{Jy*IqyM*L=q2>-*;zjmR}zjsJA>y6-L17gp1J)@_Rt6O(N{!bI{sCe7=8 zcf?nf#d{F7JT#=iwyTLIh{=VIkilP5K<&AF&z(?2x}K8SYg@>Ds7p}Cf<2n8am@R! zge^)3cQ5r|`9s!D0QwMWQd6#*S+%D%2;tm-N`cN^@fx{m{W&mi5W+QsJ5lLZ-!cNk zzKBPE%p$TWM!$Z39WgF{mG@TDy(hgQfV7&8{Mx~7I9C@3RAvzji#EKD5Vy|39JGWb z(^XT$yE_BvNLlM_7l~QjKI{L`c(&RY(fj!LLCj~B=X)Yc?6<>4?0saC=l_D&^XRiN z`0D=@QD*urG)5E8$mXE}kb{76!4mMy^6WwK@<_;gh3FA*@A$E27BB^>)?4-XW7qZ! z(#y!r+;7Z(Kl8Sj{wGTd%xV*AxwF9wi}d`?v@k+$Xy~Pr(Oy~fXX)xY{#6=a4+<-9 zO9s7%e})mt%!k!oW)j&AJD6P(jZnW7uk1HD)FoPuo0twD8eVWamW?{C3l6S^A<;`( zI?&~(@fK4scBxp*dTM%)y6jEo6-VkU=56E=cv5sd6lhADdsn80ZwnHnHmPfugUlrh z&hcSuK83`t<x?<G48H_5s4<5LXP8rgJ{pXQcY9zst&2|VEJ?KmQqlNIas#el0{XTG zBXo3hwvXSH0dGTS;lHpaonQ9oYI;uSH*P>Y`4PZ1*j2A$zPZY9@D8+n->p9IkMz&| zfNch&ZWxIlPO!KR?#a^7YLN6yd^3BS74+u2Zv9@f#&L35xG_7rAy|iOL6M~Jj$!WZ zk<lW0xt6`($R!`>!b115f|p!u*<-SFR7~WBEGq|;w7B6U9N28eRTp^|gBlLa=xM`c znB&C(saqI579I@>!kwvx(Vipf;}Fb$gY0t{r8vt}FpIw>_eCREaS+Z9H1fHuLrm6G z$^9%=?t?X-3XN8EQ$X&lMBCKj(Jzjw|Hd9HM;)<fVDKF{Bn#zGUVOkta#hMOBU@51 zt!*sS3qGcKv}Phyi;23ww(-XOQTn<3Idowl&_gYFoMv1LKe~$hv%0G4O1}3_{_W%P z(|@@$gYykujnOC1x9(8AEf}9iW9Hm#vWt64*LVxBl!>iZq5)^g>^y0g`t8TUt}#UM zK*zBq7PRJGMgz#))4+BxEsr-QYlWJrQ`}NMG%OKUro>%bV70U=dJn(8g4R!t-oTrC z&#)r*H&W=&Hc?QNQczloEFs$HI3)sN^$uo`8J?2Wp-P_RpIj_<Md{plLstxM&7^hf z%Jndx=r#<YIo$)U5Vp%GGi-*dGb)MWCfH!?3Nbq_ic=tG93Od7#0Zvj8GqBicE#G* zKo3Hy&Y$KG`<xg^Zz~C(O#Tm60pb3=0fzApa=<J{ziw~B(W$5R%}>9NKfNzn|DoOj z{*xJzHa50P8}89*06*dBy`gd36W0CAVcnH*7py47`$Vs}GIMfqm3@i4eFTdAeyQ=S zs3qxPRvWx=#2~hL@P(S!6#3$53Ows(#v0)nFcXXk5SU&i==^V;Y;5^O>bNcKx4)*e z%=Mwhd&tFgqBP$TQzXuVjHwXyv8`6OwbyoeN63Im?Q@=C7E}tZD022%Gi)Bg9yhI+ zp}}F;_2A@4DrA}|ctA6*9ijIjeH<QoRx!T)APT&A^L=a88QiLZ?+F=IuzAi&A0S$t z=vb_OQa^ETfxtJO&vTK3?n}Q*27ZMQE!lXE_Up%WAPUKg2Z^bd7hWJ^{T-pb#P>1i zIB6)@olq4C>ZL(J98%W1F**3N)*-(gh4H|Dt1I~AS{gyeh>tA;;=2$zRSIKS{i%tN zA$4MZ19{!YEsCT94V4z#`@Cbtf(bgD`*Po@LoqYwvmD48g(%(28oy;wagY}Bj#t+y zvIPgZcmFDqY-IA<GuMpQ*^@ygoF2$ztddQTFsY~zKNmZni*_510J5tWZ;>`_kk*qo z&A0{^YH6!Tj6{M2&+0WZ(m~6Q9J}Uc$^>ycZL4?)X>@a1~gNsBB`G?BI_sCmDE= z?r6dDk8FGr3Ji$DE`z@_sf4eBQ2s*{t7j<;4pqAcXyI$4F<^465(u}A-Woqy^53Vd z<Q+-l<)?Z1c<$0YZ%c-vOm?nKrjt0o>{3CPwx-)J4t@CnLjv<l%0z3nqF?;WQ<-z= zpaqci02og3a_ra-+?T**rP{0bFp9V1C`G}Ash|8KLTFXcrzX0DHVwQq0$nk`E>6vO zuad2`k~8OrT1d~-&9bSv%h^!NhR{5uu=!-SVl9-Y4-*yZ?Pu_EK#>a+o??qCz+g9^ zD`qVIG3W9k4SGbbX}JI~q#f__vX$5D0aj0&`t96}yQytm#u)xQVlzIlV$Zy4jy*Zj zuBaszosCDIh$^u722Jw%j1nTc5tX22h^r<GyJcwxCw}?N2_}>tb!uF5rQy>5vGaNK z^NFO<Y&8CmrMx$mHCJmr3Rqu{zk5yJ``Y;#G#hX&55?AS7YN-P?&a`Qe=hx;y_T-c zw!77~Q~!sL*f4&bBgZU&W3Z0yg{jR=*D9zik)JF5FXVwF{W0T=4vxAVM5aOv17+pv zg5EaCnRm1Ya}B!eTRzMIo43ITOJs@LJ7>@>nqcmFawT|}n{87Qaw(I`A~_1ILdwcd zCcTgbQr3oWGd`E0*D6`keQX?-zl%GInzUd+*fd+<>*DFV7C$X!Ad8gf9bKU=?G;`V zA00&oH`lyU1xjGvYL)MJje(Jx5=P(3WucTxTu4He_A!g3d}E`r3Lk3-^P&=CQFD$n z+DZaIYbBcPUbb;|C0eU|tkCrOSlG|Q;y%_wCd3`6f1ckCMP~1pjb=BW1-|0cpdK7O z8kY3#pM-~|u3&-60WXcddxIpF8R*gT@={A<(GnZ2`@EZtZc$Y;q<zz5K;S3krA{cu zGiHPo7Yg&^^TY&WLTo8t8oe&h6j7CwYoJ%56pm~W5|IOt9!K|h;VXBxeN^jma7;_w z63W(mek!*h*3T`bd2ev$uZBo^$}tS}iLp6@pT|QfS0Cdvc3iyJ3gSW$46ECeCwCOq zsF}pzirR|*v3)`r9q6-fM~gMCCn%i^qpwH!>n7H~Rts6qajWFGvCC?k_Z`Y9oA}zp zgJ{c$s4c6}E0CSkMxvU^6$59TtOHGO7h9IR$y_2XkMpcTujUk`-NJpSnnT?EQQAHM zsT<C^P#xfT2~rc}JiFai6A;a%Z!HMA_MEzW-?#+)b6dX7-F(iS)gh>bid|!v0Brdt zr&qXqzCYd)^j@zK^10>E2A?2aP~fNX+@st+wh~$OBgqHL98Gj6Dd%?ATR8o>aagGA znpFliY4mikj}A`iwL8I%W}%h-M#TE|t-xD&sFxAFu#_pl>DB+^<-nqXd1Y0N$9J|R zMbPhi{W^@BON4IE%B?;kG`p#dzE~xtkUo+k9u}47JX9pDlz}-!H|25#ylIna^3iWh zw_vSr-Gu0Ibp53nm(>lm9-zWOvq3yYi8>{ga|nVcH1aN=Tl!9`oE$mrSI9L@zRbtl z(}<cuLUM`*sP!D<AZ}amPTg=Y4l;nlAD79g3;}4Xb{pF`12rbKd3ayVK1F8+!^6}c zG{CgmM|a}g@oUb<S|zLtgU9uRuTq%P+lW)0-7>Rd$8pJR&1+g<5%T9<{>MVVOM_uQ z^cw6UCYn;d@O16RN$t%(i$9)P;Zi6;RruIN+eiTL&%!#Vmc(;WNMEOUD!Im~Ve${G zBbb$<5hgY9jV|Y`RtMdK=69}|)7pB=iSb1ixjf<iu4*;4r+KD`r&^C(6WgELgfSgw z_FM;r`*_H$x9S@OS)$^l_P`m$ZRu9x9j8m)ez%bD=eDVFZuSRoAtxF1@qTM@a_P}d za?wPHg>*O#uw%{wvIB*yfh+xmETL|ykBdBtw-wN@x1*9@q?s(anU@lOSxi>j{ptpk z&-we8=-K8^t59q5WvhyY#0R~kRDalp2_;hoV=DcQ3*mUX&y|0hu9kjc@gUsy;b8*4 z-X$`1D^PtSWgrrPJ)&lsJC}h6KM3Kdt@L%Xh;H=iU@*ZM<^3vBDlRx5=6d|Te4Jf) z%d1LCpEUeY93A(pC>Mni@HFUqqLvTA-jBs0$;Dx3_Hhue*5$?g>%ao56xj$Ho_iQD zgg9P2f1rvVUocdlkEOTK?Ung>!P{>-W^r-QK_73-x1HxTJMiP<l&CagUjM7;E<+=6 zmF2(VgFW;6*Dz&ZDf5}Y=2Q+I*M?y0z~-t~>gUJFpzkusB3VEO{(`CPCts?2ytuo` zS&|gFgOc^kA|JX-FC#yIk<vvbl+pKf3eMkU5^bZSZsNcOx01Di&NLp!jS%ML?@f1h ze1p$iqWpUun2Uaf+WzGwf4|2piF9(X2BiZU+s|4u2Xhaqx1%>ekB@uY@}iQFTwBbK ziXfsJ69@v;XkI^O>0nWIsBH%XaevQKHfUkS^`94f8F(b0PovMfA|Ga1C44ATuP*<o zDt9nO?^PJfRUwLB85r1b2h3clP1@xK=MGFOQK^#>XTMtD#5I^=H~^}gmOf}6;C2+L zYYa8nMlhPyS4;eN8t1E2!qkmacqC0RK@>AGd&$=i>R=VukfTD3@r;(h=<%DBb<EST zJd?tJ&Yih=j)?DUT%xar#9sO7Jo=WXgJ+UuBPL3xZirT8sm6+32`Y%ntQ(0_o9r?> z)v3uAi5sUkl?1Dv2NCL8`b`m7X-;CcF=`XwC5UN#Z&M-A%_yt*$1Ak+FI%guaTi*q zb7Q?o);=yXfAf}cQ`jfDo}r(BJ}60fUUR@ondNFNq7_IjJyxuFVK_uo?Tj(eeYxc& z`BWdvNY_K+Jbw4<c2`f!>+}F?f^-20;m$CK)_W^JvQ^W0(XrPyoIYrn#5c2`EHdr% zap2@~cl1LY@^@URb@l#9JDNznnTXza@p@ExjZb)UmG9FKCX(}Q6X4u9Zo2Th#>86& z@)Ef-Hv$Q7OPq*sPxe&gkumXi<5=g@Gx*QJnvk>VNm9C8QXT<0c4Ag6_oYmd6_-?L z%|}-90+8{*pX+tHFe%OT$vIl4&i&RuRx1nHhx6N<q6}h=*1^d`o|_Le?GF5argELK z2z?IJ7R{(n*P_{wN*=5a6=d3=R0em&-2IZ{P)iuM<bh~Obv3@sAvCpAvFbi{A=$UN z0}4h&LS6VEewr#hG`VulixV1u?@duq9(GR$w^0d^v9Z$cK9Zc30sXY+T6bbIxrx&l z@CsZ!F5Xpo<=B_?R>4_P<mbX_`8$CiiC@-#rkA7g{{aFA?R>o2R^?_fn4_jJM-zy* zc{V=%-7hz$H@ba{E~wzUAczjX3hKT`;v_pguNSAJ_;a>DbadvXl+OjHn$^sX$X&3= z4ize|+7~$9NFr*@m<04r!|hJlT9s>E*3NVsb9BwrSTU)}uOn!1p69L&%(K|vSLp@g zZKhT@SpD6X!D~ojS^Nr<;WYOgHracp9DtK=`<cX|F$eia<`;3`L4`KbY)UfN2PdE} z*=loY%FN^c9R<8&bIerga`O-M{DPm;+5*;GOOTn`u_WYrNiZBU`6o>c;Ne`!4ry^H zId&pt`+K9d^4Mb6N<f~2rs5(VWx<J^LWLoB)~&al&bJDK$`?X?B5OtfPtM7}DebVV zDPD%pha+ao;M<<+QP|x0hu>pf)`VWpHlWw=TfwHKUG>I3vF3r6yc>htQc_w+xwPD( z88?oo-tJS*&znpykP9U`?jAHHaJKvLKgEsAe_zeFaCE$|Kv^~X5uc*EV@C3d`(NEm zmJUsfmWMW-^4V`K;Wig&Rn|<Pw5>_(9#|R?ghKdlW)%|-S2}`&(6Qv{?8FjViBo@B z?_lYeYJ=Y={8#xX46>6+`|*5282|a-#BuwRev$QiM5laP{?zMXMG4Y$+x41`{qF1; z=g(CpOvI2~&8N@5ijjunT&uH4QTP(ONF3tAE)D&RNyQ^Vjda{+(Z$vdx>Bfew8(Xh z!HO4zKx?6`ox70RmsPHk#g3`YP?Jh*0ZO;=VGYu#<n_!Y(B(gOkPsl2vY)<KfidyI z9|X<hXyA$9l<)M^d+rS~^7m$-aZ%h)qU6%pC!EE)6zND4)wgU3@6|Qj``~C4<j69G zqx$h<ACy<qkXrI|FCNondBV7?QNDWt3oh-lC%|2OHFxsE|8YghrE;%=e))Hk@0l6N z?q9pweV8v0Vwva9e|{yNgAn<D(c#GnJy|GF1CwJz*dw*K{Tvn&ker^}=q{eAsk$XX zyfLE{aSMeG$*zb?VMuA14%}j30IoOl4@ZDnFo2XiGhN)A$g=1=1F`fX&AT=qe|Ol~ zJWP*qWFLZRn&2^RruDEvUhi)JVGr-5vi(A(lH7Iyh7AfIyp2%a9p^8oC$GZf)B1a? zF=*vSLdNAQKWA~(+YR^Huf|Sp<W{sFWGSl})qveQ>%j{>TIk9pGa^b-sa=aAX@(?$ z1N;r)R`rQXwqPqttRHUWa>&-d(=M-+Zu_3>^g!Bn9G^E=NLBk;;7D<F3x)f4yjL-= zwH6XvRUVPSq!M<M2WXHR(7{r~hS|H1$W8|&=Ylip7JEn5da2S@g#PxUXvkF>Z^N0> z<`7BP8vFlg^|8Fsj?kqSN@HUq%c-uPBo@reyD-nX^Pm^2t4AsLMUI|nJ@aUzdj(^0 z1b99#*Rb^L*~N$oXKYh~O`IIHCprHjei<d}4Aw71(KL-}75YWpm)|$7tt5vLIO$Or zs5DvgI6OEE-@YNLnb;}3^&R}Oj}pImaSZ}Soz2-&f7>L#0~hdS;z0!2=<}loHc-SL zrzD-ps0w<de3LjH1~GMW@G9NK`fP=NzzbBANZ1gK&}7$T4Zd`+aM=&*uS~HAI4q#G zEVmbQbR+I#HT9WiEXEdFH<qV}wPW;e!?Ykh>j}jFHj}VJdsK1ZqhGo~wA18>Lob$+ zfZO;5&2Fau+GLtBn4h;kWW;#SA7wxn2Emdx*NwH#2?P;Ra8c0PEzSS=s>J{E68AS^ z_L1aM($MJIXL2&}_xFb^BE0Gwtjw0F$w&<=)pdU<!4hugoK}^aYJ%Sww27oMUiwu` zUJg2mM_AaEAt8%G(<vq^q}}X&M-*wf=T&P?>z6CB?zlUr0~@>X`906E$+qBps$U3| zkv>x5+LiL71cP^~SgmkC-(j7f<0nq)62wogPH!f+Qh?>Wd~@A`bu@CPcX;%V)kxhm zy~B~IW&fJ!Lu2OHYJy9KXixJ%j-R8aR$89RZ|Eyf_~yk{RPkYsQndd_jgH$CEY+(? z+hOZJhd_gGR|kXI*09NPX>7RUNX^_C@pXxv!uU`mSfi<+yjrsQ18afNd=@9Ov_Q%U zYZ>@BQ?9|?Uy2#9I&s{H&Jj#{Emtqgy?GrqMi10SUjYl)!};3iG|y&N&>%|MfR@(5 ziU?zLl4ize8^0T?W3Hhnm08x0+9=+VZ`Nfy63WG;A<5#~M&X(O6m!5vvrT6H8X)qy zg6S;K-U0_CpU=C4Y-@dFe7!TJo=LLWlwZz|qZ@?7Cf)?bHQg+KBA+1suMO~mxHd>H zOP&_nZcG28GUv5h|3!*87dMokl1n01iXPi7bFD-<4bC|wFN(Js0Yr{ASabwWY0G_@ zL9*hVIy}eal6yZ(i`(B>5(C16HXSa9NHG=F+2UxvP7z4BeZQ5~7H2D;GlxQKY}<&1 zCbNs7Q+F7OYWfQqYsl)Dtz)Un-f!`4kF#~1<nsBKalUYZC}k-(+p#06vbLw=ZDVqM z(o2%>E3j&78zb^qug`l+E76)%RRcaAf7723b7K-va(!x99jY;ury%8|YND(4{5X{# zCz?ttnSlcK_<2X=uf8H8xbX~HHn=fZ40nC+H0#+u=P2c8M%d$(Oi(yg%BFD+1*W$; zRalG`h%(M6j4buwM8+!mJBSrCV+|<^S@Gk>A-ujYX(7Q!s;w^rYwFWPJHq@8Twz8i zH@JYQ%d@T8b8hd!@~e^oRbipndKR}}{<fQNJ$?_gtGdaWh|P&7^p&vf-*Uc_!RT_r zGR-d~ayx4TjM-T&!9o~f5kV=8k*{~N50+D7YSM!@e}R7oGXj_90Kl~cjHeQ4lwo8& zx1yqLH(p?+$M2Qzq8(N|!583__ot}L%|wFd@$IE!+ik&W{DjiwxXS44ei+rR%-UMe zWqK+xf7K`O^aPr#uVdH9qJgZ}I2&aI#esh~ekB=9P;Dz|psW&CnRSBHzA{eFQi%fg zmaQIlNv_nHym77kvJETZuR0C4R;I+>LnalsR(p1t^F`J&Viw$UT*D8>MT(8ibIh1; zpgFWd!!4SeNI%c{<(`uKr{jOp?G`TzXo7`%#BrATwkJ7qN3^-TQTqexX?>?9$^Zi= zeM~ulTsy$FEBl9w1%??yB*C~mFP?bO@@ciWqoJeaf7(FJv-5IVd-%nhy`XK@t+Tcj z<jgu4{{yay+x9&(N3c4xbtd0}I(FRKW>u^8JA4w_h@CgZ$9$euy9KpJ`$TB&*b4-v z;d)5BndO+Cm2xmFHI=@7mt`tsis7XByi^3w4D$lc3f_`-tXT)0`oF0;V0suI&}6EG z)fE14CUZgJyT1I>UxUjmxL+6Z-aOckL_n)HH~;3jx@n`ulEfGVlnn+{YM%Ws>0>z) z9=os|qn$@v2yIbQ98;xt)zB2XsHcX6zQ=dUG%}Uz8f<h6L*mNQsr2-1R;Fr4MWNb8 z*Cs%IK9Uxh2tg6{97m(tl=(7~$T<kh7hShX-rdBG#T{5fysHmSCld-kOhrj?q-cJ$ z`FW>hpJ1_e?){9+VpBUX-NSLeI6S|d3{^@s^Mgr2KIEqJ>;8^mT;kH>v1a2wL{{Al zHEWK52qg0mmF=Oq;o?!Ws5z;w6Nt}1umGPA(>`UP-<QaYAF1Kp$?C^nR!nE_7;E1N z^aSJpN`q67+`~0CI*%!VSQ!Kdsw#Ud&ZA3P=4yf-#tRpFUJGZD`Ryl^YcJwrjS592 z<nv`U4EJRO)<c5MlUtmvGf2w_Ldgj4U2bi5Ug5hAlvzI#x5IXSRs2U`eVeF#gP#?C zwSTVqVsx9P40kp(43wvoE+zfGz#^Bk%k<H-1&#h4ug5;>j;gEV-r#MOaxgKlxD}hE zwok$Gw|oTu%4@63-aO*j3o!@1Ifrl6f3Y}dmJoKid#8CYF%}lm<8~6_9wI-lb&paq z=~Tt)S!%85^1W-<0Fx1`e>HUij^ANBUor`-w6v=_ar&3M*kNOlbXgu%*)|%SLCZ5p zoza<Mv@*ds__5KV>gN?4Vn-5ki~~N{@wW>C$ZUF|EzK^$o@aONq$$=-CRsykB@y;f zx!PUs>W&zij5k`72vu?<MG^9RM9rN)E@sj{ZdjiGLzB`ChOR6;a^m1Kq%1AkrY=7& z0=AStpOj6`BstVDE~H>5AS+`Cb*m>i^1<NNev)1<O_#2!)|!xi%h=?4?;HEBvMudS zxLxbS$Myq(wvC-7Sq0-d(hbmu(^%*x>(#5-6EMl<K4OuGZ8emPU+pQ4bX0J!d9>h^ z&o_wlo}Ag{=^?aF)u~X7!4rB4UFx}fhxW26KduSY8r(PqJ;*7|O$NDE!FIXk66@cZ z54#c8!@@j;Hd_XQKvE?X;8iDoyFaISN-~g!_lghn9_gZ=A*9f@v=d?`h;~1b_?J&T z5Y!wk9eyi8w996K&0i5oW~lF+gC1~~lyIGd@=2p=%hC=qwDr*;JXF24|JxkC`TF>o z^!WMU<l^d?{NrD;*-51Ku#Qsmgb_1}jIK97HECKQ{ZuxpWa62+XMdZ`2wZ6DQ-AgA zbK$?zjHQNOF;DFmZ<1Q$F;Dh8Wegkq%St@Hqw9F8Jb2!z(K`w@@v1M9g}j5+2zKjr z&Mk?<dtM{J4Ci<IL5CP5Q5v)D&Tsa`5u6Pr#(V2t%Ox249BZj3S-A_(z5pHM93$+a z$xMig0kFf-*4%?vcgFdj+PJ~-ku?%PdK9Q1rfDh*%v$yAA)^ra!UChJ3#C$Uc`9^a zVNzzxhBE3P9X?=mz-vFs&FbviH_H}b?!AHgd)2>_JG=w}Cn>zm4tgI)D4!VtuOFM1 zZNAu47y#4kC?a#Me>UGfOdS}k6b1fdHNeIrLSBlr#ZXLhrZqJ|`{9v8B@1k}?<0z| zzay@7vEs>psxJ=~Pd==QwUe`DeESjrorn8n?dIq|oN;?KO=rbC>_N2-2_x}_^jKUe z@*=(wME$GyM3lQ;<kH%SnDi5Jcpd$D8(-iv-*~F)c>Jq3p|{R0<alUK5~KadGmJp| z&BgTS(jNuA*zXCHL8WTLwInM;+byK?<7iO>HatB|EizJam(&8XaXq-VAREebIJ64& ziZhWX#LLg-$J?X9getASJtdBh7ES3)U(_Qq;EeCxFOvPww`rr@yWch^gk@@Am8`bO z(4i(|Kca4r{vsx@4F4|U+;`Qx{jl=5PU6tRvm1$$(7;!7QQhDT0Dbwkj9j*~-&Qt1 zJUpu=-^V+0=<ppUkQOL5x~~{TM{+FiZ{rh^V^qR*rExB#ij+rCqV-P(qLIb$8dOkg zev@HVsWIy}2qXI*9;mIa%qDhYT=HtobyjsY<S*zolAhJz`<slKY_M{TD3*;iA(rEj z8(!0tdR!G+;b^-^2V>wLUTbV0bCHE|na*T9$dKz}#kD@@TCUp&{q~l0FN_b8CiYD< z3iy2Gb3a>o(S4E9_-ojr;^5czL+*b^H~Kscn6BTIM#V}-h?5v8oNAoXeL*G<vaZYd z%B^nA!;<hweBEgRJncD}t5AoQFm{)G)>%780$RV|qw~Xf7kwpy6xA}U1-JOA{b%RE z^oB;LqnK+0y;&FePf9D*q%!(2q$LDYF}PLzE};G9+)#Jl9wDDX4)f<}s=fLcvfVE6 zGLoj}Yzf94jUS!RXd$*&eb|G%PJ09&uTI$61eY4q=lKPNK8GKu(GabO+6xJrt@7D} z#{Ifeny3CiDf()^_+OQdWC2~PBt$d8vfWOc+av+M-^q8VD04)NU5@-`M3SdI7;OWC z_wWJdufrovl=c6|$@rh~r%}$6Xx@XROAX`9mRiToQRF>v8~5*~HhcSX!YGaLHh=t0 z*wvmx_FI}v3wRo?;*37Y?A2{2vh(Rw9YTQiY)n(OT%Y;HzD2`8AfvPItmMf<hyTtw zf>eW8oht(@bO(954Uh0(QLOq|Ry~g2yAr7Sjs-HACXVKOi|;G-+U)ksI(^M#=01a` zV>cmozF_%$1__Wh^M|TOqwo>%%+}l_JmhWt^-ddMK>d{roiH&*?|*wl{PDKJC_Reh zQT<@kjUp`hJJM_LC;l3yH~WF&pNz^%i3c{av^tLR6xGQHkv9|Jo1_HS!NDH3_}k<d zH+{y7Cgi85Rb{{U&-e6CtXW~74C7+g6R0dXSVS)$i>_*?969HV;M?eu40t;zrDm+p z<Grt{BbiX9bTDTV?V8;#&I8dFQH)g#bEteFT1@)fh+GJn$M@d|POY~)ru#oj4+#Dy zpaKr)ch6SZ{k%gfD2DExt6ZlidqGhW=Pxk^d-t8bmfh?vg)iI?d4@Hfj|WsO8prDi z?*q$6<W({LLkI<;rwvN`pGBS4n=0P=%h*RMMAqY74}Z+CPsu#;&pG6{f}ou_aVy&o zGMmArrMVuf@3oVN=OJ~{j%K+2;J5yPd;Bhfn~fFU?z}WHVha^4v81Wx^-}(>f16dg z+Uax&<Qz1DxAK-HvZ9cF6CBAKH1d65c`6RLmlyOpqElt<Iyxm&4?XKD$G?8aW0Txr zoLHdFfK6g=qHWF`T`s|G5u>WdfI!?sTyPsyb_fW+T<efvQmxQ$ztU~8qdt+iZQt!k z&Fx$aq}ksgCwhW#*a>aeXp{(i=ATE2BI=IyrjwOl9!rZVxm|Y7LUIB)_D{Cg{tKfV za3uu(vzK?((Zcxm<h1<BobC@(DjrzrTH2KJYM&c_Zw?j3n|sw+Rq3J-?pV&?Q=;qr z*JXBsGj0^l5dKf}Lix@(AU{bu*y1}|Eb++c>CjAub4*(w=0p|!tafHUg(_y4Y1MyS zRxrrIgXgWAGbM`IOUs*Kr}e%UpT5%Gvf|AMT)(Lww2WRDJ{~`J)4g0i%_6bex^}e7 zWSY7P9lfkvUzUvfSJbFlWJ+CF;&mX=t*K1$;qsE2!dD~x72b}PLf-C)<nOA**fVfL zlX==g2WF-W6X#MIbZN_s^R028p-$brs;ma$7MQ?Uj>G@%Q5)p(91#{_e?h1c=Z8x5 zIJc&UE_Grwuq9L^MX~OW*4itmE=n5}zw{K87=M^dY{RtXZ982Es)yq&3`RjY9i3*N z$t@Y;W&DYnU<n0vqxV%$K0~1G|FxZ3I|0$1s_f#faxjmC{KpP_f2jq&Jzd8rjdtcd zwWKcsxRDiebA&zqx#9G_P4*5ADhsN*p07pI-=kKd@)&A0cX^#4lHtcKw(;pv*6Sfo z;-Q2kBzFRWW%Q&n>`+i<9-V}Tl<kd7m7+&<qf^bh&DiAD(ti3tW93{D8{`kt{8nXw z=68mhRO%h;Nxdd!rh31cydx&kr%jAv_RPZ+GJF!dj;pRl{-a*xBad8+$BBbybUi?H z1Ltb83!vS~8@u>IXfgC=uZ-*kBzqP2U4UZKWwPdzP3WEE;q^552<E|XQWxf>=$T|5 zcj&EQ3W+6sar~K^_Fo*|mxcfM*8g$9JDCm>T)Xr&TGP9D>i{xyU$Dq9%li(?_1qu| z)(Q-G>sX!Y-#KTXwU-B%r98Jj$B!mNm*$}!T0~6MQEmyS@o>F3H4f8059X??1p(!H zK2_Y*z4&ESxrS<bO+Jd$kY8V-XE_~4xqqi4jaWuu@;jw{h1?H~ha5x)K~<Y&JjqPr z)I(uIVfaFVPE+|Qxpl6tU2BkCoj-w2NVg4+X9b(Xw(qK$bq@zPydf$*s)q}1Yox;c zbY3RgXg}vQ(+UT~hi~w+lP97^2oLnoqy8z(_B2k8`CSVA6`hLiWK~F3Gwnn?g&#Ww zjExFEu(`|}#zh8AF7JBDa=~zWzy8-1$?|!_0{n!0Oovj57B4p55;vrY@_2~ru|kIo z4V4#%4=M;!#9hD@&&f$Eus{r#$zQ^7%J%^Uw4I`^`INtP>HW)^<f0X0b=JBt%s$Y1 zbfUI3mJW!^?GE>I8`PiGuF~VS8Ps=%hWJ;6x{^qy%vsWF$Up#?w}2#bpTj{gJVH$0 z)=|>!mke)JfyqnR>Po~pg~yRKp3Y4}l%M8gP@FC=1X$}|E36$J1E#Yrm2NRQLB|dm z*8l38=i#<yi4=6II6jSM(KJV|GXD@|6v-M8HH#@_xLeHVF;eQX9C>0ytfN;`>zJy< zc@iWQukWhsZE5paiADa`s<-)ZzG?Zzz5fpc^O}hQ^5q;-;hd^y5c@xw_+R4$B)wjA z*6Meea}qFfnL7K(bW!l%V#0dib&;7TKoK?W%$UV-%*ZKEPRS}HlEyLtCXK(K4Zldc z*IjmI6@Fi}R_g(8JUR;SmeHwschI{c5<_;mpjyOKQ_IvSn%-ar6PJBOTIC7W!RgRJ zhlM<0Bb{Xl<Z0YQTvKMUYL1@Z;f?QkvdyXOc#5d<2!g?13^?#{13<rk@MLIPi2-hX z&*>NV?`S^8H=BWYb$$beAq8zU#kcXmw<;0eiWRXYEG;#0Tn`kS2J$~@H%`rkDoC1f z35dnKW~wISSzpLWE1lltjCZr;5S*fkv_9&99+uZda!Mcc2b{2i`OLV873*Xv)C|P{ z#Zx?7IIv=;Bg9-A>@vQ;V=V{@RIi-L|Krkoe!gzbE>-KbKm4^@zTB+b8Dirg4tN9j zKc@#|epRyUg!mfcE0fmSO2R#sCVZ{OenMgBqnpazO^q@1{MLN4;Fy+)>!BGjm&i39 z(fGqI67WaVF(0BHKB4@(ZHGk*^EK!3kigku_!pt9P<_$VRH;c5@Ryus0W+bU0#;Oh z&>U6wz;&!-uCAPBN-M~2$Hx6m>g=T1zLvdFH*ruS4VE7-zH_^KS-jsd%;P)_2fw=d zaQie~PRF?&wo(3ZfPLJFTjl|~Ua^pi%3}MdY-bgdcToZ0qCGJX(df*-%*Ydj^@3O| zZD%3q^Cw85xzaIQcB4#+*J;AZ%kH{nf}5|9OU(^tPO(w)=qg`GV}mE$Q6kbDpWUcI z<{#{3B$EV_JeLoe7#mquVla@yObO-1*CYeayNE^7beZs?<CJ;h^W*Urq4x^Gey!!a z;U~PI>gZQ|iu-x6`9{$5G|U3x63DERL=ry8%J4k=zB+=NZ5_y`O>0J_o)aP6=nLQ+ zv{fj>jeCr2G9JN3dV9+Y>2k2dN`hA#RKqbe*dtcVtJKUC3c<S2%@ysk|M&O&U9_ug z-PPGo8uu`Iw|&QYw@yk_z45yWZm9a0g~nt_9zfA8E7#4`r`kTA30P>N(u(+VVU1N_ zw9}-AWrWhLR1-%1D@tY9r-r1CRnQj4?QkwR2G}CbatFQJL__Y<DRFa6Qfy-;QI!KK z%Nj$PzT05`QW?+CWtSVF+ELIBC2+bz2#xJf$-IhxMic3LWc%3vsMML{fYKc)RH@C@ zzr|^{AWafz&Te6{==;@)ZlHtp>+;HBUb`mZO~XZS6uH@e^SS3Ht=9RgZL-B-&0Xh} zkEML~zt-Zfw&GsFvvC`<@W~82uG{nXA>>EZ;JbKFN%4OVS7m~WQo`xv)v@IcvE!KY zeJUjqPf`Cyy<R~kXqOZiRf$bY^|3g9)~LbPSsOZ6=l{g>J+tx|5RWOT^S&Bm&7F&3 zwO#4!s&vr^eBD>18Lvt^WYjHmbG?Y_xoYa#i5rR!&ya(Ny2%>dEL$%1aWu=qaG<VP zIwrxdyYdEN6?u8%bL_oyY_??x_!jSYe=p|X!yq5>jjZBXQJ{_g<4vVwp}-B{|Dnr? z8LW4msj5$R=1L~3_?;guC2o2F2Xt920`;BosyoIm#|HV@DX%+=nxR=EkRvS)5bIlb z&UQKy=QaQ@l)#u&m9!-$Z@N|4)vc+-E0_|x!k5*FVdg7~U%=w^Md7pllic-x0M0-$ zzljPvqVcxc*&SM1bApt4nyxM69#Nd9njW8MYK{xU8pLZt9+Rlip#1QTL;Q{H$C)CN zM2M+KuNEx2J#W1*0Q>5eT63ZJ`Z)y3xrlDU^`CSmr3?HFH!Ji7FTD*Aq?;OD@~Xs| z87nz*u-SsGRX9+)(T@#PP_F8&@c-QR7}rf3FJ!wGcaVfBgjO-h92^P%zx~^JbiA3N z8AFFe0I$k5N{e(bqez(xs^k(HyAyKZ^*fY~zm?Eyow_Zd%atZ!*F-U4V{G<976lM8 zV$ie5-`uv$>3oFWes(u4P9MXxgq)|W<`Zd5KPvlTr13RGl{OpEgjStaoh_Ew4(!)% ze7!+-r><+Nsw&U&GNK4xa>ogwFi_UZf#zI;v9kipWn^IEEm0!kMv%xe1pcgzoXj-? zO8$YCl0hYj@85o$|9a<9X3el5#9Zb_dM(6>;Kn5$sC3!&wpy90;7lrG|6HECb56SF zWx*JbN|GvNN0ZWsDbO+$)51IH0*j*kMvIcl^fDL5CM-KlOJES>d1ZE=*Q5YdU7(V{ zQ{x3rG!;RGh*5O}KB3dH?kal|vBA<zo)l2di4m$xnG(mjQ$>UlzOrG1S-(RYzyA8K z9aF>%7iFN%PwhC)TC4owiA^Nyqd`#51gSaVHGej4d9PIL(9GBpfzUk@L33c-jiT4w zkYhnChzM0xtvk-;w3oaAYPn04p(_kHwWYFHEnrr5K_?MCuwu?<hsq%jrI~L^jS(z> z5BP!2OZ?pS<IJmd;K;I2qe4im_hByiz@*H7nXfXN;;7{8+ID@5ve*i%vfy*pXJ$@X z8<fN|Nx-B+ydvgMh+17Eu8dr-z-z=K(Lo5fP7%DKHe*k3%og<y>hl8bDHMG+6FijA zbZg99I~Wp#^@(j+6w^c-#uUB80>^2C(*~mnsZ;8-aw2(4a6{eEoVu~56((_=`exm^ zquuFbQVJ5@on9LNL(ktr>L5A@Xvl~=b87s|&J%q9rWH~ZNEWD4h2}(U!lB&f)2qg6 z(__kdxRmNy@Q65=)}5G0E|EbfP4|Ak|LSv`^&s56L;DtG$u<Pka>w^?%CJ>amQX&` z^msDYL@y9~3tGl+Si?IPpXKlDIn0*Wl3dpl?MZc2b%VaxB_5b}InYc@><J^1_q&Jg zCHd8=TNY(bOxd5MW6pO?9ibaNSd{;>mPO?2GtG)PMVSdY$)P|j;o35iie3E`!eoln z3%R9}ydoDtkpNWD*;x-sqzzktAh@iHrk7l#a}4+Lvq^26fE3w5T$~(2*~s#cD(6xi zQ^P}7K6gdED)T=(2Pwme<y`n?Ujwz^rLcib+|Ah18}n1U4)LzpW2iS+6ihQB<ph09 zdVD&S6T9?w6g9yDU>Qvr3lZ@$01Tk6YwEi0?%n0fb-r=5f=d7mH`=Nx_q)=F5ZqBu zh3G|QcfaAMcR$Pa-Wc=HC9f~g9I_gw&a@hP>JcHesE6`?6dmO<k4ifgovx9Kp9flf zp=M~o)OlH^dwMM~ya;r^Px2hPQ?QhVcML{=(z=4@GS0p`A71cn^3LU>K}aM|v>s8) z>C;MuiJ)oBj2oLPrQc~aINC*nF9NmTuzS$*bGr_5{nRQZY5ny)02X+Rnp0{7kCdus zNdYoKyN)qDm!noyMU0m}BY9b-6-;iaT!3res_?oXd^HsrO{F0RBU`3HSxr6qzDg^c zYv#Rxh38TZzJL%y=BBw7Zd^Id;qid8(j$_oyU`Y=lg_uC2OD~^yOvXubR7C>yrw@! zJ1O56dh?VGj^ib7ysEdxRDd-i;^P8SDM=bHbO8r1q1V{72-b^{X|NpeENB=r-*awX zT;aRskMsK3HF`lHIUXi#&`xyZ1-!L)$iW#BmBYxCzIJUdFRyh=P__l|oKOqhz}<py zXr(lAT_zP$r`PMfB%#{N;y9N0>1ZLwj0n&VmP(U*Xcksury5BR{5JzP^g%BI@D z6jyt}r%shS>OgS5YttIn4xZuuwJGj8JK(|9Sq_e8ONmwr-y>S;=7Q>Z4)j7#ow5s- za_{CaW=EA?9MWbTM7iPpRoK(Z%*mKls}bqQWiBr&q!2NJRYX->M>L*rn_^ZoSI?Z~ zO^Zu>+uT`h9E_NctP8c5%ky(+iWm9;#c2#aa&ilg4QETi$QlI2#MxH0+^Ng-Y0Jdy zF08J+DE$-(<kDQ9*v6{b<+NA8e4KM3SMtETw%p!tIW-I<Lb-9$V~p_^%L6`oW)nZY z{Zv;_cwt+%AZ65^8UdJ6=hm4KH%|}wzPZ3Nev-RZd)#$$fydSsIGm~?+~=k3H&JDI zG59Z~6cn;6TdFY&)dXzw!o$9E<2y=7B0*SGXLB5LWHi-riON>2mb;<BFXZ(VlQG#9 zr(##kym9szZ{Kv9TV~eSStTkQBbJNFot8t#vzc&qUg(J<z{6`jK5}Los}jpp23N)! z=y~Gy-U^!)TJNJe!crM%EM2duoz(g^l$~Gwq1pyemb39sSzkYrYl2qX5nA?Z<lz+Q zX&~o@DNQW<G#@;+m)B3NaO+&t?QC*x19qQ4!3uiXE(qt`5lx+Vg_1+b2ZF;~ZQP~} zxAcen@WNU4j}CM9**>3H*~x(w;dtAlk-8IlFADp)TO8Ug5ce{Z)H=0Joe0FE>+>!% zur-bugpMZX`NjBQ`B+^Y#LVcUY#$^Z9Cf*k7=eIH3LKN`3zU)cbTn%3elCu=(0ar@ zGgHB}gJs@6dzyF7uW)rQF$i8t?45+JcoD<)F36$_p?&f|p2um<BbRy!i-%eH@Ucbq z4{J2GR77$c$(p$;7&mJs`hdoSiWbM2$Z=;Nb!WOvN}!YzXCoKva@jY;ah^-j?Nl6@ zpx4V+remCnSvOwW8}n>-R*0w?nLblFamWK7JT}jNH+_=DV3>D{qwB4de#{0~{5d@1 zx*Y2|NYtzwbJ?*lEu+AU8n;f3xn*k1d-GWyUmI}O@+@Cn9q{;Qn&WMc5k<Q#5{k;c z7jgJNgHfZdosM<UHb^2wTAaXD)sU%B21%{I_Y1I%`CZ`;!Jta)u9h(0ic=98B0iu| zC95-)%Yztq?^(IwUeq|j8M{+yVsC$yH%_hc#)W0>oLymO%tQ|b-GPvDfhD;XpeZ8c zP&O%*4piE0VseSYd1Lp-y8B}hzIvw5XHIV-QU<9efm&eTnLBzz7MQ|(L|YeVRc%^E zgs78TXsu94tSeEgD*b-{)$2GHfBGApsboD-K$GDia#d)#DGvB*6FQOg29cVI%*U5@ zbH|C6_iaB@w1urGb)tcgJK{UO-n?8VLTa~AQ$|8A6PUAH67nLzd~n`4Kjd|DYn;r= zW5a14T<Y<~l|}Zi)tqc<Oo}j|tB|GYLc0dd6<O*sKHf57P9@5=L7)fF7RS9Dw1Qe; zZw);rr(TKmT|r%Fyg{p?<=m4DmT;@fz}{%wJhjYsE}r5I^Q&A_Wu`mWfFWeD4OPd| z=(XeoR|rMos+@A=xEJ35)xJn5J%KE(XGG$h8b^Nj_*Ralni-@t#Z?)ra7%z|VojAA zvKUn^joPf|uz!<xDbKn<r$PwlO*pum_Odz7bM{&3C?vr#%gjjP*1F-DRyl4?)JQ8z zFlR-2{D%`exqW(-8|O-7TYSaJNW6{x966UDyLA1JuDYh~NL7w|y+p($*5x=ZY!hSK z^a^k4FY~@FXLw>%@uihTzPvKelWR4rEoA9o2vNpFG9eqmwBV~yrZlr{ka&^g%uC-- zf!+PYKr_o;`Z7v!*x*hMN=9+dtfoM%eRfZs;0?2@e8>C}x6F=Mtej{?pDj!G*|j?t zy3)Lfg9juek~&rP^F!ker+gW!a*>O5ItgGytehC1Ju}7U&u+tGq_IThfmMX*Fy@W5 zF`pWeBrF!@tWpXBlk>~0G=|qVNq1BOgTdgN%W*DlN*j#I6PX^{!x}f$%IQ(B8%0>U z)>UqJa@gbFpV-cSJAH_GbAohLFG^#Tyq-aozk5gTjo?AB<g8fWiKPL()N;%G=%Q61 z>&inCq??4`XcQJ==8gTt>*j|1Xgb3EYXk0Hp633gX&xUha>n{JQqv1#OcEwac9@ML zHr1;@sqDcE?txy?7V0r`)f!99G?f?Vefb2Lp)Y_XwpVAkd7<SEvqRoBcbr`VqpxL3 zc40@C#<F(k@D85V@qo&vL(Ys%d1zQcRBq@EnUPY$H%gUFm=p>wUc8x1Sda)$HIY9& zzMZidwKilCls?%rw^c*->5zmlu1g44O<uK|cIRjrUe)E6>nQkd%24e>bBF@T4AY1Z zs2Oo%uVsJgal|s-!ECD3(pt^OPj2INvrBycmSsZPpd4UUP8nr_Qp92)8RRze)N0`F zm07;9yhv&*etPG@OP5YNR+yW29qICQ?wXJ4uq8O(F*oF0vuhmLdW!ppXSio+nm;?W z$k9BY@-j9zyRfYqv$YzP&iV$X<>j!2x@AW-<iL2UR1hT;3WNl14kvl*{1R_nT;uxb zWwyp#I`4p_vbaqqxV*`c(Fv<FafmV_jQ|pa(OTelp4q{4m3YJa60e_HVQ=55gHEtP zmp)ayM&+t2e|~a-2UlmQq&RO-VQ4LTG;?QgRLh_&cOkY#=C_RyCbSF@%**W4^0jv; z_^>``_j23I<~aTw?xQ1?>A5hDHR=s&6`Moi)_TOzVIOCNd5ub>=MAUxfd6oK2X{=Z za@ACUk$dh2OX!5$1FIf5x)yk7dBCTZxAMeUc*=TgR`@4-4{-b3+9jW_c$X_#huD%* z!3mwZOZgOCk6x7Bz0B_ZX>RDPaQ}+1e>}^;GUA4rvNaluq4c39Qc9Q07NW7eZVNZg zjVzEw*jKOc^Vb~VZG*G)B|umGlL-o;Y|l(;+|mI)3zedLcJ1O}?fj`W=Z%XaPNq}* z(lh(`*y-);smI(ob%r<1pXT=2h8<NZxzdKJd#T1vy0^xGwVFRYK2H`cj9_mGBtn4K zhL)|Nh_<MKCg{14a8ftg<Q!#O&aq>=`w>D|hud6keYKa#aVAH(vp&d)@{p4N*5U%K z2pHTP5|8y-9?KQc45cX8BgXx!i~QcvIez-8GxUQHq;%5Hdf-qu-Rm#U%y9qO3<sM5 z$s$>W&AQA#+IxuaUR)_oaEXSdbn)^=?n#_1feSX&GK!;+?a$;sCsH|WvMa7iV9c(5 zW_nVzn3Ul!(_Nhr*j2ZP*I>)2Kw~xIT(OBY`T@Kx<q}m}r+?GYxYvie`39-M4ZNFz zMD{L%b81(<Z}Sq?9^hXdzKZ?hX^yN7_>-m0?COtrLvNMWFP`Dn{)k<5!=UE8Uc{O! ze{f=f$D3*T-ZB&gO*FY?Z<V;Azt+9^1Xc>8jxif^>D`D3l_iEU#iZcx9?A+6S$7=Z zvg)e6OpfF03w5%yO`2wt2e)w@S5bI_Cl2L`kt?+d$&?u{;vFA3wTIgm#(d}8h{s0C zBWrVfd3m1um#28P?Qs^Ta2FMeiCHrLVEYNad&^lSGiol|>g^WcnX$5#dqnAa9Tte9 zY#ofyNSWO}Q9QgH(OO3v*xXOV&|>t!i(J$&*BoE#!(atbFHPJR`*}qQs=5Hl2`YTo zwlf@2;r$2qVP0Y0WB)ku)NmUgJ-dag;|e#=ta8WvkURP-?CrIL2=|@p^U0I*M6bzi z^n64nPzT}8FlIhPED2F^shVzB@MW3!x~{@{jiM7ubaz4s=b;9^2~M1^^=!_Ev?wjt zsBpbT?(s-VMkrd$#K>Xm@f*+X<IhhuJh@i$Y~!rv8muO2pr@(uGjbq?5r1p(2tT;< z4AbVF>`>??lwFRCFG1+xam6tAh>|GzLZlakJ-wCgvt4H4b1(J%o&6ED4q3B7Y1B$) z)s#cy0r*N;^c|1q#iv)@QJKpLI|KZen@(}66@LHFHJFd7Z9ob_%F09I1s-VT_|r2( zuBz9#c_wq~>}fuAauWyg90MwHG{h1ua9wD)rD|{!qL+dU7fJ9ZIi`!y(&ac40#V2Q z?Dcw=^DeL3%h<=6ptmmd;|<Q^EkPo8*2dFK%jpa~anOo^XQGdJaCL@z*Ai+2kW}XD zgwo^_3A83miSfe=$N5`(PBI+|maFXg`SR@g01ji|K-**N6%|d#9L>yz#I9;sa_)7y z1()x%bJ!V2%!f5rYzpy!NTR_wXg$UVy{^k&^7a?{p?y7ASl1jh$0N*%@Kf8*GERs1 zgHv0Pl&G2_s8LhYX;y5Cd&hkq9KlDA&ok1Br~}kisB%Lalo^!QRYRsiX2l~>8(Qfz z(d&86I`NV&wv&M0&*h$zKF(x4T~2%1M;TsNAh`JBD&x*~#D-h6q2E!el4M$?OfnFt z6f`tcs#G4SQcW*AAqhdpym{-h{8ziqvJg6_bYDN(FPk~6CgI??rd6jX8v@d>rEb|C zOG8p7V9m>V(mC5gW@|rDfcCLyJ|i4#D$aN}AJI1g?_c1vl5^AK%75KQP-jat{=u%J ze9yu%nE)XXr7&e9nVu*5UV1QVI*n#$kk`tD2Cq<4ZqdX(O|(`T;;m9DgU@qSCIzQv z-S2hS=<^)sa@))2IL}GO&jIwFGsn?;&|$=GuZ*oOWbILjl@76vs3b$~71k(YT5VaY zVXZEWvv*A`^9#F<va>%f54zQJ8@|2p-N>G2)eT$aL=(E6QUwSiiN#)Gs;f%n38w2Z zZG?r939~`i(ieo(m82E*$cb@eId_jc%X1Lw`8@F0^L*$Ha35da;1!Z0+1XVaKez2L zZ=O5Dn%77!IZx86G+@n%K;<n#43WaAIa?`nV%%9dJr%?PF_&Deh#FoR-2vy213H=g z<L6h^F1Ni*jx#CXb``btr}*5bRwgGWf|YvKLcPWvy_PB)2_=xoK}jeoMXuE>pj3o3 z!Y%N+sa5{rRY$m{$_1Y`5%OL~mlg)65pgf`EK3Kv?9dq?6gu^ZT=C_lJ_lEomX3+m zb<Vx(f1Jnzj^$Z;Ze*zn(9<ezsE?tsaN)%!l<dpnITJ{pig8uFf*LfTFeg<qC)#<I zniBGOw8Fl%f}&2YJUkY@e747_9GTSJ^JIFQo%0gwI`-c2fS_|8El?)|UNbe~XZIc8 z4TBM5ot$n7k(wO(MJoYe9Oz`hGPS{Nam?m0CP5ieC86Xn8}zj=q;q63Fk_tSqEp>z zTwg55xtzLcFPr0B?CT4IhxNErp;gB`Q>VbSF|j9(3$NY+nv`k-MoZm_n4$K$uD{05 z?|p{XOpkC0Wzv~YkO(5(IEoI&krLt=*HYMY3+pmaPp?M);Mgqx^V2)|i?f><^g4Xn z<mg$i3>wGB!b%d9Ot2OgC1}OYK`zspIal81GCs`7xR9N_aS>CLu81qbI6KEj6NuQP z++2XM8em%pd}3(}|L>>v@%zUYc_vi_+gDg=CFBd`eyJ5?hEE1nWji<0q(fofJ~QHH zu6m4{dMCk0L;><LJsX$F)i_lelv5dDFPR&AVO_kW^kmMbU0iJFa@Tp{95d^jYUqWb z+N+Z~{Wa|QmXCSCNSU^%MYfT-tv6=M4U>xCRRM=~W7$=NY{u375&vlKLGD}_(X*l> z;Oj$Ox?9|JxJ@Bf<%XB$WS}K+->}E8KD(3u`H8*!^Zi$&G4kWvPqVdG`1_^xJ~?%q z?C{LEh`ASW!-nL6z8ZT5-I(*zSv>cUFQcizRlSy;!emCMi;!~S;5d*bP#Evj5HjGx z)@c0Lw&S!O`TrcamjC(jef--)n|X4j6jrhp+PS;oQqTkBG6H0sq}OR2h-5+&__o<G zKe^{HTWV*`dq`E4G47$r+6D_nA5D$dhB4bEUwmym&j|LSspqtQu2Lx7|Ej9`CakJ) z9z}<VbmW9)Fu7qRtbtkrqiS4q*bJ@@nI~i7fh05`5;H(1XoY833pH<=JIdQ;hiKci zYB~sxP2lui<|3n=zO<FRWXa&(m1#b4YL35LUf|d$kaM4RY&ymNu=5$VPX^M$bGT?p zg#F{`A|xdsRz{L+(q*>B#QM|q=dUWhIFqijme~{&%OfRdM5Jse`<p3RS)uY&^1DzL zo?tYp?Cm%F-}gSn|GIxCA79$e{cD@~kH`1%#)Z?oXYmlX493hx2%<%fcA`^lUDy@` z&k-SE(TE1`+B9U;9N>RDx`*X9&_<}NE&$Cq!c5s$XKt*9c+w3*-;-srfrN0uq%|lT zKoX~=Ah|<_@^p;4uD>}Q=OT~&qC2qAA(?X^1*ai0OXjt8=4i?srbi4F!BWRhhbV~$ z&h~k7G{ud*HOxa1%YYKbbR9E`iYd?-hdgrE(hQ$EHpP9T&74frsI+8BylwFm|9I~+ z?5Q%js|-y>5w62I1cnwlG@eGidkd|=U{Afm+(gwzczzt$i?j*cWLBNMy%A53sttEk zI5?hRm`^Yr1j|-VoeumOyQpz*FZ17Ab(r?)n$MkG<Up=Ccx*GDI5o%Z3nzKU!fD<% zJ7iBVf|U))qoAqm{idmKb8_jc^c~)_^(^-f5Ag4gzlNwq13CoAGG>;FH&n(<G{!kH z(F*ulVb#WAQHA|kz@C#mNf7$|J~76ZWSrqE%5gT{l#QoO3Z>Q3Pcw|;xG?`**hRw) zvB&Y8F^kkFjU@;bJ#Tq*)Z=%KZRWq<yT*co<jG<!;6<;L6$1O01D`v+i7%X);=y*2 zaZ-AnQjA#O_4B9s`Mu9_b-yi@p-ECN9SE``ZXvMT2q#B@T8h4!NrmI=?vKj^=t)7u zz%S?B7uKoDl^Q#GL!9Z!k8lxAj{B@NK;PF<<0Vfi<KiWQRdCH9@pF5gX1L$@tI<{l zF|(G1&m7;$U!B>`#|CG3=iDjYy0FaEgSPaBf_39hWWB;y(n)7|SaE2)jbH=ZTB;5- zn<a2f&$*5U%QYUf6jJ=+&U4}S%J`O&v#tkulcJx<Iv3}1kNALZkmFo<t+Jt#c5a6# z341A5b{bz^Za~7x!3r`KBS_-OJjXbVxT(rKks`+&8m%!gddV1v8qD~_i3Q#=y~Ouz zIg5pgAPK`co0YrI_W0zfP29CS$Ft*Uk|`C5er#|x#y-Ux2B-PieFwO8DzQF0)N`2} z9UTY-z}dys$C7c}Av)kaM9P@>U4xb?bRlE;XXjS@3w@TCkXaBbM58)5`+8$g!?dMm zfrg5uq#PeBdj=bLW>P|5kqm*3>J7KgCjQ~x!~Ej@z=OjD>W~<COOq<@US8yZ)hT}e z_?R~?jQQ?ON4afk#C!m8!$UU&I5`&K6H9Y^ab=;5@{mlD5@O9q;ZAAjhfL#v(9t$7 zoSt^6#V#V4w`7YX*D?kqINC{<zEqR~_(q;M=Y94|q{P{ZnhYHeMoTF&nvx^r*n+|S z)Z;U4=IUtN6qVb0EuUShFn7e;QpU7ZB=kA!eg56y&D=b_#*TjC_&9RU**<@AY76(Q z&9iJZSWyhq3bF~}ecD#Ib?O*D{hDLkIh`SwGOSJ-r%ZY|T^`n*B8P_4jIBb{@La$_ zRe<e1qf(zB^}E-Q=PjzqCE`}U*bll&p-|F<o%NV03AEP3XiFIBaHxsgxn3N(;IXWK zPp}+#?Lxyp(u4f7C;L1xo?=SdLYqcOIdH&cdG=`JvnQ_N=IIgNyLgs6=a<<!Xz6wM zzbBR>e{f<Gcp`~1os3p%vW~bp!tSaRa!gA2dmbL`>o^^ZLf4qcN3D<NQDHC`6ba^U z_E0TQCN{O*Fd6BNBsZnX4N3Yul=^(GtvKWG`e4-7a7(2;p@~De^b^J*5Ur2e2xY)m z(-!{ii81pb@ujnyIj}6Oc@IKOa3f07!EcOOTbA3J*Yp~Ge)mz{Hoc0b!rLz!w67Do z3cInZtaY6J{o@5Z2RyV8Ak$-$uClFa%ZJ>cG&(7$ieG#yxu{QF+-FKvt7}FI&h~oD zf+miSYuc)md0TUy9QVLi*TJ+GHFuCq&zv_;kNAaskMqABxQ2tHDTJ1QP$8^&#H$%j zn(!AZiM!Soxa#y8Z=PS`+ZUJE(`)(T)0=sGJl~-QwD7IW*j5>L#G+%@nm`3+7uV9h z)I_yOXgCo;SqBJ9A+ZexgUdQFccZ<69H)djsVnhDqs;h3AQ&kJ?oN?UrO0v`usMv` zN&)xHiSpWB%Zas`HSK|CviFD#>0^u~@P|is74ZyndYu-S`(y`|qR}RariHzOv;5qi zXL-l`8e&2Y-9V*D)3PIZP4vX93q2c@{f*+Zr3~zXW@B5gVKHVVBH@#5UMBI<rRoHi zTG(>&Zw2qJPo3#r%WQANfu^SR0+wuDIXIpn*%^AzBdb*eL=-F&P`-U}$ZETve|=yV zhio&Ij=@@{+e8x-lRhHCD$c!Y^E|dX$LCILVqb5_!@~-L4y;+zRtYoXjwo!84Z}8} zu>ex>bt!`G<9{7A01=WGLBa`ecEa_VIL_p?zKPJ$=eIm3A)2_O*$G72STiE?W$W>m z%@pQNkIZJx%u0(%O(t_))$nBKaW9!V8<9lA6qPC=jj1q_L`0pGt3ra3K#}Nf$S93X zv3W4&XLdc!dlt`jq7qV|AxX+e_l_gvF5T$9u281J=>$h}Cs<(uR0Ju?JzrTK@WgPV zaBoKim*<&RaH${2#lPtYAsacA2CQS$F%hh&&_x%Hv{NiK%C_p#)B^XC7nlUp40Yjq zHV?@h<(HnB=A=zSSR+P|EL4>8ws=h+1Is))oZ|7(Ov&+dNVF+h9pRSQS4D2DtN=uV zkkyH8(I|MH4|vhrASl*_Y9&DNbtuqF#r}ks-ElZ4?y!C{I`IVruWC*MUmZs7YHOOT z#5g3mGOL9vkGHsF`U0=*H$2%C?deuqLhdF?dk@zZ$wF2oXxojMDEWd(Ii<G7hQGh# zFyFgr8SVNl>b_pG$<mEj7XU4S;MT?F>YQwyGou>uj=(06#CT$@&o3U>N20)4+?*ib zo(Xbs0qJ$oi3`40y7L$LeQ|KZT^Wa(xoj+Vv~Llk)zWJ@(JCj}%(gz4E;3+XfuM$K z!SwYd^L?9_S<6rJD+l&*R%-ATv?f~@y3&wc5LHAA6E#zJXzUu3mcB>ctV8CcRMIL< zkc|`qNLxyA&siep_j1lVi8`mrOf)9E>)8qYUjMv*|EeRht@}oIy}={Gm=qlK!W~aq z!ZMLEx}!(rc;kGo4Lpz{LZ6^RQb*_Ap}89$Qp5qxmA%?<bKT?1V<CC~Nn`?1GmV4} z?qaBwX=9^U6HH0cvY?5d*nWf`T0BABiSB9ZMG3!CixlhfnkXIW7+M#OjRTL2XZXTW zpHoc)&6pVGV^jmJ_DEiO6rHSp@kLh>yzmp}62Dt06ke2U0O^Y7MoqMqEXJ8u`N-)_ zjD3Zh24m{z$hxc(NG^RH6)Sw3Q1E(&Pz(HxtxK%<L4NDm?X0<=QYN0cv_v<ANFxf= zsAp7LLaIsH(hA%hoa;l=^^eM;C^LYc%Tc<N)bQl{?v80DrHHv=l8P>bDN3L}=zq=E zda?GhoH%)+SYt)RC?p|Q%0ziSsBplP&x|S_&x&<2L@7A#k)FdQ@h(y-AWYN1lqGIe zcuHW&jU1FJmt;9eE~`Q+TB-58Mr}jfrkGRsFLyq}k8C^3jO22%Xs1oxiAtb`I1B~W zTIHEWcxY*w2i7+8$Y_CQ$C0s1SK>`YW6TZl0z{plsxIJKZ~Wsw)6ONq!L0)(lwc-n zOUMb)z$ybicw!%)Jh93RQ!THZJHs1iSJ~4~%%~IP-25AtlB|~jP$f5;^1zR8J<Tu= z__s&*VU|#75vfVtcnt}TNehXh6(CM4u-RMg=w$+dmaYU2B=5A?zQ&!n*hyg&arq+o zo58h=A?f-!8~@#_KF7&Y1{aA}<dDggl7cYEhG*w7YChdo9L|ES54O$S9Cnz(SO^Nz zcB+<TpsT5|hs5hc%_rSyMX1feYuZ?*17uf}5d)13JrcCxeVd=<Z*M=toED_8i&J%- z{iMd3CU9)r=c#dzdse4-aCMdgqnfp(H1se6L5x6Kbltq_^e;k(?47jdE`N3BYncN5 zq$H1s!jvVl!?Vn>e_8nS%4RmlhU=!z^2XUS+%`Mn>Uzwk=mnVBZBCL)K58K`tHMuh zJ3`|lK6vaZ@EWr*N<c)BuB~7qROYl1GzoW9!fUD_ZJGj_=PBx)3#le2#U*<=6fTZa zrm(r3D+JVa{gPDF;AL{05-KTKp$#p;%RHLwk;n3YPd37-tn?|=d}T5mupH+LV$9;* zC_W_^1TnHWQ5tTng-5*N5r--WbuNi;$W_rYGhyUKRr7CbI?0dkJHvD=^<@Q8>l_>j zkB_H$bY+&uMimc@W;oi+(s;mWs8mpa8V7GWAgW%F@Sh8vUOqgnkf~{6LzYbCksty0 zL?6I1Cz_hW%?`e_w3&r^#Ld04ymqePwKFSR+h1c-?VzEQ<dZ{kX8W0cu>BM(ZI2J1 z-bRoL^%luvqSWM66j(iES}P>Pn|qnMHHM*^d-OFH^@XKpc<$+;4h?i#Y`!jnA{$Pe zm%?5)m76Srd8VIQ>QvKs%~$C0`L<=*`Y1idWK@QQ-7IxU#2vOqr>5;l$y&&3l1Z+N zg0UzKw<kE10<9>-Tqcp3l0~RJFcP?`zswJBJIZ2gIokvdjD>qwr+H#|o=1ktQ)!M- zj+oWpWpsH@6Im+U5?KN+u_VU1AzF)($p|6Tm}%);Pj=0h;ly#AF%2pWxRcs~%nUjz z(;&R`WGczHDJ#Q1pC9%3!g6L)ow<H6;`M`5ykUNYtEP;(sz}h1jl~}P{e4GhP5JZF zdl+h;Dy$GtR07zLjL<jXwyB1NFv4sKVT8!n9=#!#Xojvk5hX)v=@{_dL49ySCr0>E z*~>FnN;>F?36YA^^!Tbp{<2j@CWsoXIF%Ji+g1xfD_H5dYz~S@H^|nM91NrA4R}`6 zN8C^ePrCB3IaxB%l_r$IvMyz^@u@cQ2dC$e(-jXbPjhJ4=On_&r-;@P5uzG7G$>B+ zai?*Z5dv5u=V1|Ck4iPuXVc;=qqPwyPb?E+uOzY3CE%BvL-2K4P$7>33-fd6eBjKP zCB{vSRgs=Hh>tNM7J4WUJz$nOwFX}t&hlkhVD>m%+gs&L^M|-~w&m*nkgYMWFE~HB z_asdgK67Sg5q|Vkz?^PCkG(N-duUONHYhQdfl!wU!7k<`mon)JEE%EluE-!xtm3QJ zaVCgiCLHyycVQjo%R<Wu>+|Kd$5-8GEE8o4^Gx(L@Q6~CS(}n^k4%fR7+Mf5lC7O1 z7@@q4l}guimAEY^2iw5174`ZY617z%tju;v@S&r7$QH4X=y^cI7%)Vn?oNm@1G5O` z4KOmTwMZH<sC#VPvcSGQySVv=*Kp%?SF`V$og6rLjNkddAMwCLPoY&0b0KyTy`mc@ zysfKRUxu6A{hyUtsOFi;px~TWxb>#1`LBNTy=>k*#e)w$#Xa}z=i#Rga_ZD+#wkDy zXeafDE206{2wq-exi#)e(|l>|dbS>GxnXdcJLlH8WwznknK5tLw8UR6&#{ssgCMji zV_MTw=k}19mrO&%DHEe7tj_aG%jGk;K=6c95lD=+lk@FvQ&6WBLp|UaE$0N=CP;#p zQsD+(YR8#~hRLKHNT>ar>4l1CF}^SkJkU5<BdUUR6VOD<QJy?^6Oe^QBHMM$td60( zX(p4(S0qcO6cGYqnLW|Cu6FKOD}*k|g|Ma`2qKs_1R!Vv51kl$#|zSgbu?^q15Y@{ z%uJ7+JNI(a^?SMLhHJU;y4SF4`z99W2h_2sbKdZp?d;mVnP2<O|H$XRbRSNQixz%; zHxFlhgv`3w;eYPEW?e7Myc8yK&X^f*f8%TU$-ny}+;Qt`P+DGh`;Gj-_YQgL&=Kyt z|55I~_c0!M^Z+MLEz@=tDG^ZZAWu?Qnl6bx#&R3@V%ou%&L*~3W3KBDIh}=5+NV;* zQbtr6OX3DKu8T%4QuI^_QuOEakk)%Gq41<eo;j2U>=C6esmL9~h+7NZQlW@PT$<7! z>(<DGSQ}%te&Srt{>{X`L4BO_ca?~7&;y?s^?5SYSTrj0t{X4poQW}FR_5Lmac#jQ zv!Kotfh-*m^nzxfOjKC1G9!W4R*3^aIfhW@9xjG^>cFImN>#WiT3TrCkln~;Xb`6R zfo)qharK^E+;Zd9+;-EoTz%DU<`x5W6;Tw=R+^8kmolpww_LxC|Hps#xB0CPe1t#x z=oeWXC1O={oXs<yGpf0(yuJ7bdTz8Lh03LhnUWf3su%d4?|M5w^>=@e9osgMo0V=D zv@$o}=iBD5;`KLO#oze;@8H0pliYp(6MW^a2YB?!XE}Z5EaPTeJUo<!BGSX#Ol^h) zV;pM^Tg9_yr?9A~WR!-af`!ax8}a&BF%^u)p*D!tH7hT%hz+Cih85}Yg|=o#9`nvY zU`ksW&v;aFuIMGmn#g#We9bvUSVf3cWH1<<TX&b)zF|4eM(25k$YVp{X{o`T+5^Ed ztr#g~wr}6gjW^!Nz4zYB^71m#Act~VZI;BqJGJ@^<;wH#{zT{@u}cy+4h9?_S3tl$ zqk%4zsW2-|(bN>7zFs9PF3z)i_YQ8j{x#fk(+;k_dM~@TZ)0juqn^OpGM+tkBeGoA zORG-lFKJ5bSe)T!f9glswtbNg{f9r}*zpxYRU^bM=lRbQRoj>&ls_vhLrN`MH%;@t zANnqS^l!X}g_%GeudRb<vlTVZWEHB;+%(*J;|^}QX*d7H_q~}X4m`_!_dm?N_dUwv zPaNjhv1P_XkdPsi)&aqZ)|85-I?0sag~*n}|G&Nej<)MM?mY2N)jsFm7m;%y0y7~d zQOrrqq$FB_lq`-YN-fJ0ZAoKyx4V1InqI%|)xR~fX8qjm;MD4|r)^J<)mD#l7>|>z zEJ|X|1PL&KNF<Sg_wGGsSN;Cj``nj703-xJekEN3c<<hGPuR70?W%8mzb&xHhEQ-? z(V_AxrKcTYA@p=Yr<l;Lm6j((xqXzp;uRy6b9Jj=ksEXjk$y%sV#Oge3YA+gP-`AU zS(H;4Zce#=oCzn7@M5<G-a?9$KCaa>*wI+Nd^tb;(?89~$Ow--@<?+(afbn5f!4Vi zK7EeLy&*?;x@xrDIlHKNp>|%k)Ke2Z70LpNdxxPxW%;rtoOQ-J&N*`pXRcetiscJg zG;f$zD>+w;5s!5$)=3H8IBX*|(X{dgVg&J2Q6KDskKJ`W%a$(Tw|@Ii*!0pir06Hr zp0pRb9g9ugL?>WGWbMiYeEPmSx#fmSX$L1(6_T{J!KEksRB1#c6*$QX55uiC7oW41 z3(r~0zT0o))mPu(si!yb_+!uT)TWo&_QpO&tE}80Mo_0q!<w3K?Nw~COh(zzj+7+C zfHm0IESWgdB}Y;#d^AU`#<ZWu>Y4-Mytj<3kpmcqC}=|*pi4!SnNgdrbmjO-7&dlX z9cQMDh-pc%F2O7pt%TZ*^=sDhGxvX<Yp=VGU;gD^W^{Bky+0(;+F^vb!7)vWT#$Lu zCgGQotZq!%76~ki#=AnzH!3F*(%#FHa@v)bUBHJwbS-DDS<1Y5bLnff5&+a4i;=pU zD(-HQ^mPC;&vZy*8`7rb7aYy(FJ>ui+YTkSTzd)27cb&}|1bZY2OfGBv_%L_v-sPX z1vA~NdBRYff8HuS|Cx_+$-B=+EMdP~1aqedPOR%x`^rkr=9(BkRlp+V6?6(D1m^Vj z^R9DO^RDw&bH{C$ux-aq9((E~e(>-MJpcSF?0jPvwHGNwlLL@fv^EtNgvb&)iIjst z%p@NP7BmxKwi82_NI}$sDq2o$w|Su(=|toD_5iEG2&Hu>;{e@IQ)f+58#kbjm!MQ* z$9=__vNQ^qbdlhM=mc-!5iZ<t4)_1;&+wkhE@S`x{k-(jOH@^rd&Uhz8N?XQz(X<b zfiz`O$mXsHH7cngtBtW<YJM0>4#ccEsnG3qnKyq9mtC@fei5QYJQ@|vim!+`>M^$+ zWXBLN3y7qILTXM6`C1d8EfUe7i4mhp3T79aw}yZIPd>-*eC1F0fB*K|jCPGsCSCw( zRDazQ+{eZ;aFZQn4D6XA`^sv91a7?UB7W*qAK~=1i}0$OIN~I)&jD(y(2!P~q#-1k zB_?06HXI@`rQAiZIt}rmfkDn*zmBukpU#~(UC*}d+j!{lXZh+MeVdnG+d*uV)OCSN z&0Iae`c@*|unfX3QEIo`MVp9(rn-$GMEWdnppvXe0aB0BR%Kh&;&0rzrd@D$7(vSe z7@B3;Q>hnATyT8@{h9jf6m^`&c|;^__7Q@Igm)B>0<OILaz6LD&#_^{21JA%J9hB; z>#vVhhjCmAhIN!7iFhnPt2}V0vY@ym1p*OAyr8Qi3~Rw$fqgFYd%=iAEEq4ovXujS z_R*d<2asMuV*D*{`a7CUd`{p1HU=A+@PRa^r%BcDU_@6!G*&Mg<_kY{7t59`;H!W1 zckJ3Xf(A`&m2QY=J_j93jxc^zO-U5dfO(C_n&JKycfRjNKJ~F1Sh!#Tv5Js7`*F(- z?;sRewQl_R+V~4ispu@d((nK#Uy4b1%8b62aK;%cnZI-afBpB5@X{**F(_n|%3BQ4 zX0COJl28<o5FibD!luz&O(C`dZEC6LdLNZ^amqxBNTg8ZO$&T&)Hu*?^X}3JIHNA$ zH7XJ4$HnODZzGddoKr5V);Nu-jw6zD%A(|^n{MLspZ`3kopxI9{ad$gW%usgy`?sh z3`Q0fLWvTksRzyU0CJxOhD$`n=)+hTjF+QQnINtd6l~w|2Cu)dkHrh-<wU{QAbqD0 zwTU~yQmWf)=FV+#&rjaL(q#+zFTed~Y}vXS+7Z*V0;q#qjYvRM)BdX2*qT#h9){6q zEMG8>&-~;a+<E)e3=FiWs=N`;PM7X^gOxk7Ynkbq8<G+?$4%I_{Y|!Q-$_w4-=Rc_ z%nh04$)`W&Oas_^{H~f<YsRDMRZ?jp7VOoM?{;cBHpIE5pq|2SQ_$$BMf%&vk8c2e z1dh`b`zAPzCnANP_=%t3GoSekix)4RFuT6?+G`v<cyR3VDzvO(v8EP+Gz<ijsW6tN zEur_^#4u9x+fuDilu8tJD5PNT-UGb4<qgg~>$C~y`F1lfQ=Lw*%;V<PWuR>FzMHOK z*}?_<#&7)r4?ndTFWM<wiWNaag0^O-X?o{TCAwqXQO;erg3o>WBV2#w1(cHB+c;W7 zi}X%H>3h^X;uy}BEpM>zKoWmSdJKw6#nRxEp-B@@KPG0rx9R62B*b%(6ORd;oAz;S zX>-W?`CeVKCr0*C5~M&Z0yU;i-?;A2<6*}Yc{u*W&Bkbd=FOYOefQnR=RWs27B5~r zMm#9O$jAsUzx*;IBO|?I7)eBGKAmxdelYV4n)}WzxsSQxW-KByASqOkOb*elBQI>; zf}2k`$G5ZEOb284T%^TI#0xMdc;wQH*Yhua;a+aL@p4+Ch?nWH$k^ZtA@nAeXb~fF z^?T0Y|MO4o<>sr-Pf(WJ3J_x?gt6l1+jX3Y*I;=iPj`OP3tQ-PtS5ILQTj0!OHDY8 ze#zkmwB*{{A;3MLxv{OVklN|hh?WZ1X7G#|dr2~w8ZDDAI_<vxDdX>*v>#bIy19sj z3m5X4&wPdteBc8N4h~MK>h9mapVwY{ZNksoVXg{8np&kB?qhZ7)jua7X{FhO=8b4* z6D2Z7oMCqkV2O$<%X`1L`BgfjqqN$su|3Y)aGdEX)rsgm5t*kVXd-_vR5@eqN`C$e z_po@;eE#^)zs|vq5iM=odwW9>s;Z_{D!1ME9{$mNA7t&a#aP|V>3T&)drmff<$OCf z@$;T*XG*uKc=?s>)Dc1vQzFKNxhV7Kl89*&TKtF!Gsbn5kKze!k>^O2#77~yP9}MB z>`E&Ecu6he3Dc+y^bPdx!6{b&9Y27~jP>i+^V!dSmYZ(6iLxvw%<RqIckkZK)~#D7 z_F}j&Hz@s$s4J;`Sj36Qgzpn+ny<arVl0waYT7Q$QP^e)%O#R(Dcg6v&hEYYSg~R` zR(11Yc4Px?CI=gT?e30>W0sHtmNQl&O01KL^5S`e{Pbt;WW}m^{LWYYir3%hAW}`Z zKlA4FbN7dC<(>~;%bYp$=*HwU>QE#A5@QW*>HBq>%-manC?{W2^LE$t9Lo^c_WJ8= zd2L5RD&(!dNV>oM64QR}7-Sk#Uef6{+5U`oj6{Y82k{WtxAzdGDDFn9ZVInSOGl&8 zvcN#QZ%RwTJ83_XCJ}e%!V53t7k=Rvxb@asd%BF{Lz?DcZQs6qLPo9G>@U-bwzaWX zr5Ic2^_h=9R=W9u=agryj$4JfQIa^714T;7x>3?%+pfL5wtaVU!rac=NRS-KwN0MU z#?P?LLo+1d<#GzR$!kQdF(O{q^pyp7-+2R{{OB#c<~`4=Y5+d=!E5-;CvIiV&;VAC zg2kSiLWWF|{$?3O+59>4xlgw7jynE*?uK~@)Ck75?FZSpdl#ZHWe`m$h%C^Gwm6X@ zWi`j$hr<nEk=~tQR4Yb2P+)WuTOwXZHk@}pU%LMboVk82?g`UqV$?x!Rmvy?N@{Uh zeXR*Bp6_&`;J7+YGpH`T^iqD|7k+`uFTeb-%Vvy`&6_tfIyyQoL{VB2nG-@Ht<#Kx z7RfRY6L0?H?;roDS^~>3S_ITuBtU57V5j1xSGN-iN9honx{3#m#3m1jBc0(UhjgAp zvSrJb5yHei9#vue`gOF*azgfRrZDJm?3afd#N&THmas_(up*X;ccFA%dhKNnj&ump zrtpw>B-~k`LR*Sdpgw|q#Y6!yGA)A;Efsbp*R}xW&YjC`x824+`N#j5bIv(u+Use? zTv?W<ZgQX~3a-8OTK?%j{ikf$u;DG=-|cpJ>7|!?H>9a2%#q0aV2QCNcUi*B_4b(t zg?P<8=~B26Nfc3Nq*K*=?OTuV{HARbMLVIT>E^21(Qj}MXEUNH^1eh7>bjZ|pEvso zWNK>nNPFs!{(a3piPXkHq*eCu{7XCe`)@r+w@NFKTf`}770yESUU)WH=<Y}zy!Jqq z#l1375AII8-6n*<RaafbzxWsbg3B(u3}8aW7Sgyop1nA5oE>M~x^;Z<i(ll7GtM|7 zX!pp-2%9%=o;ZV;GoOmV4D%nuh{<6)D#y>p%`4&zv|wJ*#e`nPywrjpKD?3t@XNo) z#!YXgm95Av3P&(Aza5hdnJLPGI;P+=WyQv3Ycs<vQiL$!d?ts3Z*@-7%0$lazOnFG zP)!)O&=OvFWh?*oKYWD;AKILNJ0XHPCdORpGDnTB7_~$aDdSNlC`9O@biK&Vnx1q~ z6wH}3rx)g*fByOW^MC%&x%Jjtdm&kK-i_lN50Z|?j;rIe+iix1h9*3W!`;N4J9n~u z`}PSB5P^jXrF1hJzl^B|9_83I3G@Ri;t0VyKml5yL?i@$@W^xg$N%(uY<y`KXn(Kj zeLSrRCoNinh`8lYY+UG}O3;)on_N^pl8_6SF{EpLH|=>jxtN+{0iWBvoqzjl|CI+G zel|Dyr6$6NfpuA7HN#d@YeXbcSeP*^nEt%e^X|G*HHn=JNDUz{G&Dq+LsfTY&6+iQ z=}TYYBOmz)0|NuS<CbN4YOgrsJ^n~GXD@7efljBBK9gUnfq8|Z+UNmf_zn{{uZOc< z){ekHRL*G?EG)qzm@5h49Fd~nfd`-F-~IAec=ov+l%YLtP>su#zU2fqcAk^rJH0@j zNh|QUSzaV@6?l_YHt(_ci#D*I$&T?3J~w2nTa`2rpMPO9|L#}+E8l<k1*BBaoO1R8 z(ZIZxaAseNft*MPI9fB|K1^QmCMO`8Z?CNp^Ub96xd1#kIM`cVn)|kV`Eox0`OovI zPkoAc^Ah^wcxrz(cHE~_nPCGzS<lhT*tGctx}6%KpaCDZ2`m(&hy{tDCZbU@SoH8q z@%S`%BF%Futyo_i<hFLj(jun#+yf9O=}-ja2amnNFaFB!^7zJ$ltqDfmK~8?|2fPc zO|bTyAu>fQ<%$9chN78S6G>=c!*O+jmb8Q7T5zaN6dT$!XGs8YI?=EIWnV!k5{(t= zJ@9GP>i_~+$WruUnYF1*F%9-DhrXiZHn2QEJCrTwiH)21Uw`GRJn;Cl6gYi#A4Wk{ zBr)P8+U3Un5zdyHZc(QqqzAm1xGGN0qD~>>ki@|@N{dRnsZebtNvBkMjcJpg@!Yv{ zx%b|C`QjJ9$g*Y2XsDrP8iVhIofxu?X=Z@Y(NSJ~<uzjLf+#gYEihlZ3<R6d={X4o z^_IsT_e(?yx&kYyxuMVbddGP!4(36cGFkm)%~MZ5%`g6{^N&A&Hy3PJkJX8QU9`-7 zhSTd+TAF6FNbeXhG?i8q_o63~6BH;?Q}OOSqrCL$7M^(aIllS5r?IFAt%NQXrLLVn z|MPFMfA1d7J8L!T*REskoH;$Dv&V=xP-HPo8=9m9z_f;@b^=dXBON)0{6?UT6=l%^ zQ67EjCH~`=zseI&ZlYbZDJZd+^u8l)R)qsxTMBC=K<rXwRqd#$5G{U$&t}|vy5oQ$ zO;>KKZ1uwa=_cP+tHqsn-buUN=Fk4@&nSxHJG4(2cl6}U(5_v(*tT^??wgN9Y2z4+ z7-d-E#67x<?|+#}BQ#SYqM@;M0>TLE3PBm-Yn{lp+No3suBg{&(dLn-UgqEZ+VAo| z{>(jGa^ZUDcCeTWr#i!a&6_l663I#hPjd0o2_b_$wcx<P5jH>f8jn4(iN_v)f#)~B z#2dT!(CrqqiawAk@f48G`O(K-;HjrxVB!3QoW6b~7hiZ57hQNd>((q~c&LxkOPom6 z6h<jhi-pj0kX~KM43R{dp_*Ej8;1%3GzgDA@e056>%Yg7&%I0;`VcFqiNq4jja78H zuFqLpR7mZN20#j0HDE@qaU99~TaSf|VWnd!C7nxZfYNG>InH#?+CA;VZn@<a)~{dB zvSrJT>-atKr0dzXY}vx@J$uug$}w_b#=N4SEj7GFA#Wz<8UOFppq7=VLy1>4r)kCQ zZR79VdC~jm7A?F=abjOl@#HhF^6!7;EBxHg{tsOC?)A_e$pO^#HJ*YpHH(R(>L4{` zQKAy4s*1e_YhHeJ2ai1QJP$tnB%3$A#-2SRbSj6SsJ19d#k@}892Kesv381fA62Y) zZP#A5zWFBKd-zf2&FSatGuLv_g&Vl|f-^X6)iUM{_fx8*q+ktQ_1>OPvr~&`-hTw3 zl{A1J002x9Nkl<Z?$v8VlHl$S9^J^l|F!?d^P6^1gtYopT4AaXVU3J(bGv3mD>7;o zlpvIpbwW=QQZLhyY%hAxE3YsKr<O#2EjPclTI~r5faY_P$3amPy&BK)v=inylP`Mv z_U#-xxIfhnB;mBwjRR6LLYHAVd|LCZIJ(jvC)G5?YN!J)eFU#q!$Gbc7=)3?=Gei5 z5E_E^b|24e+QKjW>hJLLU%Z$1TyzE+yN5|rS1FN^n(>LQ?Ap7JS6+UTC!TnLM;?Ec z=QnTR_1*h2ZY}Yig_fhib445+#XKZ35YNyVA`&7&C53&Iyt%jLTMumHfd@CUaPAOi zpS6~YE?Cb6=dEMS>P0M?H%zH*VoWJ*q^TJt6uG&lJ%r}fNn1Sd$TR%MU;kY;Zr+A! zfl6x85V`~x))m4{p=Mc8(J@CoA+ZZj8a<str~`yZPkmy#=Qa8HNRA>pxd<A1Y~o70 z)nagP@UUa583W_-hR4fJ_=?k9+}gEkSvYqNhxQ#zV!4{w^<S(byP`8Er!l;lmSpNN z4vWdWU1N7;&(odQwr$(CZCexDo|qHcHYUamez9%am~fIjH~$auyt!+gyN<d~clEBS zUA+h9GWLD6l!gu$#T7DJ-3<#rf}Li)SklB9P~qY|XH{2U?(P1~*Z<S{9LevEuwxSP zl?C$G4<a!k=3)haN^q}7_WW<F5B#4)mU)3TbdHznVg?%Mh2ml&nO#f@=Ou{7A<5)8 zW)3WvG!48M0SoWK#ZS7F(IJ~51m0#lhJONYNP3?KrF2@H5P>FXH{@aFSl~u?u+!ZR zn-EvLNze*xEJ^>+9gDr?<@1?nZ|CbjqK32K+LjnpDsuWP@mowQWoHAslwk>pD`nk% zqsa5h3yz!GXkBaH0<ym*`CmgYOcruo9at^awuqD|wNbt~G!-#2Llh$mHoM@!`G?gC z45!p}KH>JhEqy6E%^V&L1fTLRBh;MIS^GwyIK#qN=g}Z!Ci2)h?4v(C_5i}-p$&yA z5L!V?3d&4nPF>`T07jl*OxpV;lCE|db0aa?JG)xIz((Ze@Za=4yjDwhl&aH9A?EQ3 zrkle;sr<c&1ffAXCdZ>GgZHy#5G06j$T!_YP!*AG#pbGVj}XQX*(txXrn<iU{f>9- zmB2)X2-sd<W0q`5C~OWZbSPQbumMzWnX9Oaf}g4FIF6UA!xtM*_a8*vqc=?W#vh&G z`hI&j`Yv~`HF`ZE9ibMmFlO@ac;Svhx72-4M_<`khTfr?)GW60#Ns3D4P{GvJq%`* zA{Gp?^~`6)x~THbu$@^MYVQIO5v;D6KDPfYIk`%j?qej>rBJ$&&)cT<pu08~#RguF zY^YFfz!*8>(oH1uZ9fb4e#SYLkXDp4PLo2{tKZtL?YUK|*r<hPrSZ%))lINl?~DoA z*$Po64Tv4H{8-2+dGA&*iO|Nib-;;4hXR{9MV6qa;RxZ;Ao{uf1pBqO@`=ad(eYL_ z!QJqT%+%AAJCeUTS)3p+g2vQ0{@L@M=pfz_XGdgFJ<ysxK(_!an2iLdO;L>v_lZpP zH{gU%aGJVxn8v|1X$TwmExNVkOf+*zwA<Jt#_!XRkS_VQI`xA<ZpvAL8s^xI9T^U~ z3LJ#2$@7^c;N_T+FyIj4^ERP(kmo|nWv*-4<rCth+42hZS470iv?t;5%IEXWK`BEQ zHvPKz8LEKABdzT;OtHS&fQv0|Wqw5(wESixvf3Ci<zZ)~73x4^^hgr?b)+)azUurx z68PhNE7u%P-J4@;g@57!@8lP5y#LPYKWU9V&b6r62|KWIcD6?dYE{CLwYgF4#C6e< zAs1Rt6oa1SXvx#kymBsf+qDUEAP7>76`><m^^oqlwgmGU1>ekuoNX(WQCid*E?ao? z@AG1S`{q&M<?l?^Z9!Gm3NJxd6@X04UyD?WCy>X-%>LyB#7dZ?xPL@&2YRK%Kq5IE z&w^mK#O+qL>TM-T%U-34I^CXj&$;IbEshjN9N(UPns6q-H+1P4XPP%EQ+cK17aVI< zL3yKBX%_=@_&p<=XLLuJO69z70aRW`tt&}Q!VHv}8t&((IU39QD=Q`)Jfad>fKu?< zJ6#y?^Cn3JnhSNIXbA<1v=@r_S@j$+m6wAg5yPfrRa;SY+i*R{j_|<0^`A@5QsDTN zx$Ja^<dM@1ZJPsJeXk0J{(qO8vB@peF3qwfH0{XU^u(R{7h|meessttrr|R0urmsG zwYajOTY%N$4|)mg0?R1%O;yO6I`5?9bzK`s&vN+Sl|T5#6KRg945hI#nj+AW!H>L( za*|Fch%AZG1)6N?>Nz`Kl<5dJ#{yzxHCGp`eeC1HS-^dm<wqeBAuY+bSoUhe87!QQ z(kG64rmx$xv843)|CA4VA~K#Vfdva_$Vdc(53AegghvrurqrbrN@%6z`XV+w1XK0r zmn_jH>8sbqggHEEJ1bUC_--Ug7%EqipsL7)tI{`=Ys$hNo2sKmNua|1{`KP(x*gKz zSac+H&UqJJO&JCr0pVE_-^*$YB4JpOb_9g`VUn%mILq$kT&oYZ1h2%6+nORl%RcQ< z>rq2-j`sBJRK*~~i*%quv}!v7H>70^3lwREd4vvf1NmIsj=is<g9CbpP$jQ1S{4H# zc+MDHPBpMrnbN8y?BblWDabO`CtH;^?ObpfL6Q-Fa|Xlp$w@LWVh>e)EN-+ibisfP zchv{9p;2nrBr}4Riqw{xAg!X&+$rT5p74-yXXZaJ3Z(1o5wrJ`ThsD<gT})|aDA}S z-<qWE@^I>4=OC$xVTGVHzpW%&M!Vi(FV>SF3_-5Q+XzL(_Dj?vz-mK!4EFeMiVum& zRD)ZT(a5FiIf}f~daPIs;DBX$bOfrddD5Vm5GucZK~nYqQ7l<-QZK%iGDe6R`OZtW z^?h7*pM#6rG4F+IyEv?H_nekw%ds2*<kKx|0_wxWr>O|m=cvy^z^?j>b4QPTf;RM^ zsQpsv{vb2pFd#M(rvYg(YF>w9RYFsT^D^QjBF<!J$yC!e^vETaigv&$gprPz;I!Az zs7Qow60nzY4V)oEqxi5LtyzR(XpGUiWCkLpaIO3aQc4$=(jj_^wq!=9Npulp=`&mZ z)!9PLB(!+B1PUcwXU{wo+yBucicqI<hBd8|kl3tt)1N>HAl09}b}^`)@I#}OWsfC3 z)>f7$1&~2th|QZ8OB`b|C`zH+kgDz%iO2qkP+FJA{t?wiOxkn3^^5DKR&`Fumah`O zd<@{Y+7L`v-<@2m*LFORf!ci>)aF%&shJKzqNzQ{oGqUZpRxIQL5>(w6hFjDe9Uh| zBXkOFg$ewWsussN){-W&E5;-kD}SMi)cN&N7n7d|B-CS3=MY=bCl?S;o_YWh56}14 z0LJoGDeXnYP%C)WL$iVLZDTp}pJbN^B^5Fl3ue1S?;X$asS{~53i%1uh%vBMb2*4w z@b0U<6@yPIdwXCEgsXjtab$zBnli{M9LV_R%Bo;j<J^7xqow}S{4&0@OXx+E&`P#C z9w@f3$J!Em6nI_J=YplTK*=v8cO*Oxvq1F6TQ7whh4di@H9Lh3(SeUtW~=Gjuo*%m zh>+q&w9<O6S`M(@EeF>P`!-+!)W9XT_rV1RlOAAM7e+!9`=xz`a61_^Cp-fuK4l92 zK2FhG9d0=_Y5q5Ur0%(I0y)Z-tlV3u^Oo@8q!Unp@Je!#oJO_1(9n76-^wdix#L0a z(R;i3DY2Za2<?<AiCJzeLN8B3PSgj=0lsyXoU|gD+0BHO5DLN8k8XN*Wkx2+b}#EN zC5D};FPFE8%|>gz^#d8&_D&kxBwgN|wRrtyBv*{{)q-&|#X_v83U)qU@`C+IxB<Gk zHC(YOE(kzV-RvF_x4=Bcl;JW9o?MAJs<a9=A>p;a$#0T;cU2z5Sf2i02zc#x|KX{5 zP=(ft8@HwMtH2l#d*$4(Rl<KBSeC+@*mwi7HL`DFQ!XDdV}^AI`YXovBclXZOOo}^ z<5iBE^X(v|bjo1>a?&MNqa?OAce{B<-R<=f6X-EnExtp)@9#JEA_DlH(N4p_GZ=z$ zp+FNZ^9HHSlMzHzn9XY4+MDVJLw3O@ezIm2e25ljv$0^%SJ6|)et_ql|2Z`kubkgr z{7*C7Cg!(7wa9`mx#&pvI={bG?=MzxVC2nL^qhljP3DOEAV$|h$L0IWnUBqbi?b`q z8dCmz!sP3O*kk5$9#_qystmz==l$?&L-XRH1%o`Xo<hcG)s=)JU(T2>AST@wDON?x z&~oeOTrx3nYT1y0b~7g|<*Q!`X1dWHWh<7Y#?^@lL-pWeX)gI8aRiR_XE}Js%O58j z32{LS$X=j6tzbspeN)wu1Z}F4EAzXj|C35KK|@Z+%!U16;LZ7G)j^hyl2b9aOr4p; zkMOx`k&-F4pgk-Hnnj$%8gP4?Lt}O%&N~Neif}?NhU%{?U>;9uSOp0k6I%T;A-Md4 zlPrZz)?fY=C%&_J2W+QugP)*q!{x2@xTYvuv>?$Ik!I3KR3c%WMq(SR9V17R@NnHU z%mir>mCedIouuCTbC*Bhqc!#C1ug{4ybwjo8%h=!b!^5%;En#k&b3hryMy_UZsH-_ zrD!=gGk<1z)!=0rP-RJ7jd?*k+7%IYGi0+4$*1Lk-x@Mk7L*$KdD!N$kly<<q&T~k zg>8;(T;oMKA+dsU9`nF~Rf`IYUTu0E#L?@uhTwwKtHdpW&gdEI2^@2y6=JDb6)%Rv zMofCm6_iO-|7x``HZ-9ztY7#nV<gp(hK2dH{}?P;l%VVr6X|4Wm+}AwT10{&2oVdK z#JRK8no)nLJswPcl){SUW6Ccj-J009vvG`MWF&87KozG^OU-W@?ks|RwC_S5uB}?4 z8&6)xx<YxeQc!6z&V_E++%N-k-aUJDV1X6JScVppueQswAn%k~emz47;Agh7&IsNd z@+i9CipzD2XL~))^W65<4|v6}mKGiuLfO4!Th)d$uvan1@tny%-i@Q*BM)E>L$#JU z@1iMgqNWq2BJ>Q^R|=9uqKdVM8?NMM=|oq(y>5tj7=$jR!pN929x5t&9L?|U2<h|l zZ!eG3&)!c{nk{Jy3>=wUkik{>BkxmrZG{9L;Cn)g=yp5{X&Q-*;jXM1<EjB-QBfhG zj92cEmLHt?99_TQ-`LflYzG;IA3HwiF0-;;p_M6PO;0Z;p(567hAnDB!y-sJj_63D zX{GLk3l-}63l;K)+&Sx*SJ4&^8+-SoZ3mD{5mPb6vVdOzlWk|=TN|eT+@OziXA=~D z4P&7vT>=k-qYtr4P+f9OX)cXexv&5jVvS`dK`(+D9aAG?t$|37$SRdE2QQ5LH4>DH zL8fuo=0Sf9_y7u>LyV~V6rv?o)NNOm0NQ`%@QukpcxXcO^;odX;NzDu(vk-6`irNC z;Ow36(o@@Z?xVA)!O9)WTcdg@U^>oMK4tBTXWno;JXF1@Qgo|6AH|nW!mW@)xxj9@ zFk2V(AP!C$SXgaI=Oy}v=Ky#H(Is9rJ$I#Ssd^5CB^8a_F-XiUtmWti9q7EuSUYji zN`IHi`juAlb4WPBmLjxRus{EU+vqMZGdsjNuz#Bk6DKqg71ve)S|p8T;rU;kGdY?+ zO{%)JTY=7Q`Gak_{5g=<5=@JVCX~~srX<{?{hP`>D}!x+n&?Wqf9J+XYy)nQ40GNR zSjwJfn)0_cYh8+3f?5I9ei`KtH`nv36XcT4sw|!8NZg2>Ny1ZkT!33vfAyTSi$+mN zUUe0^N7t=*n}mf-q8xc8A3BNC90b;UV9pX${IVj<h)t{RX2AOuy>5#&XpDvU+M&J2 zVsMCb!w<s(K>@kG$XQl1X5H(h1pF3EUt1r0C@I@Y>(xTkqse_@tyBV72slZs5rs@M zdqN@R(VL$JfNclCHrmGJ3|UMHuZaCt{N;=?WoB4E{~7#%z!TKi=s)h(U7=bT;?oSN zF%zV%5XvDCMeGPjW;iW4G3f^bHWJpp=1K8I$?U2|@etYP>c$%7Ha|#0qp9_k9m!Pp z82R;{o2SMXZS(RQGo6=ptp2wDr$os|fe*Et<2t<uR6T+GZ+@8~si*Pq%z<bwoLFXt z)yp<7Yry58vc3fR1H1sauqv0Ud#iXMH|IEK3}h~{SUs!Y>!eMRyWC(QRr;rfOgyt> zk=yG8*UA0TmMb<1Taqkl_W*dC=P8QUz=*f9ve&h8_Lu7j?Vpv<j>wH7*x+&98t7oU zjdz@T2iw&JkK+mt<_ipKs%P%0LupePZCjg))88c~?EAqAxueo;WyFV9nwr*ViP$tW zcf^;qF^}*v@A;A&R!&Zd8;*VcA*ZWjrsc5*z&xzWf&v$C-AQIqG?RH0pV7`<Img`R zP{B1wtNdvh(r9Fy-iEr*4XtAL=Usg9DoMS}j>@LZE6!Ua8&fNVVA?cn)&?c0GsuIQ zo0#Iu{sgwS(Jqm<gc0K|Ov5$zvn$?*U_7yCAdH~wpAjGC-Q=gpy7;)ZGK{(=i$3j2 z3m^RwN)@Ta@(`&Aeh9Kb!rKHvDJW(%ixK~Xb3X{(e3+!enRN~lMKp3L<@|nTm2p?O z08$o5&?NW!WwZCq-xVUy|FX;))&6td%=PTKFwl2j(!im}#;pMTj}Y!>4V>f_3Wq#c z5f42Ooy+5cj?-xv>uI3K>?@YtTB1u5sD8>(y==x_rt4(ZjEZ*8!D9LjyZhUxSr3`f z7A!-4%&mGhB<ySfH=}z>xACA#f{W(Bmo{U{f4m{{rf{lYMI{UT_n+UV<ufU4B{X+w z0_nU3^j=ZXgpLW9DFbn$TRYl)rw5b*zRLnCbaEp2{`SV9+;%yHtfaz16-nicjf2W8 zV+!sCz%5ptodZRl*25D_X$6K`m%Se^qOg!e@CAU><Z@Ky$^G#%y-KskJr#;aNO-)g z=V&pOOpyskPs0ht#kn-jX>U~;42}ij1Ou(uzlNd5&!X$3{DXn!yo9i4#W=wxdgg&) z?6nAHM@VE(j=mPCs_uKPYGbTX;ic47B;<x>yjX|`!jvi{g>{>~q19N-sKOy%Hd7gQ z0H6EB@u2|PIQsmAbT^`hrQ#bLg91TI!wi!{m?Jk1-W*lbPVrBNAtdV9B>UcAVLbg1 zWT9at5{?#RsG@diP$MRnMY#YxR->>?iB!W06hfM~6|WRrvLShd&cf<9z)q9Tld<>3 z^gGiyd3CC_Llm5g8qXGx;IbEv<uZ(+^#fT$Exk~3JC=b{bDTP9AePj!OzupW8Bqpc z)_5qPU^BhzPCALkeb}&)jO(GKIiQy2&{@d)TlYthin9s#C`756YT1%7uQal3l%MO2 zUqIjnKcWsQxTMTJ*Kb3Yj1~Et9q#!N$G$(&T#^x|BWNRdic+x_Mf&_sL9h7YwfWQ# zj^ThDR&DS|mKg6i8C=NF6WhJU&XQ^nYHZRbak~Goim9k!!$vjX_%Yx{i`usInR3~z z5Q#o-BQk{oKV?#7@Eoa(Zn;A_xO(dA6Zo#%LvQ>}__}-Tuq4tXJYo13FgR1}HLamy zXk5)22Ov20Vn(_|HQ;BBcsMw~NtBhd8`&VI8A)aK1@7eS7-s>C<b(1jt0+=%Cr!$Y zGq8C?8acuW3dqIP<N4S6<NF@F(cbl7<{_KK8CuzG@px**l>esVDfro0CzU}6l)wz8 zGU_q3(vlXOXra<mRx|3B-L*|U+6>d^kzILt8p!^<1Zc35GK6@X>1L-w$54>vju3$< zlNPt$OKYt;QWT-6$W^#`0;NfL89NS>+xW}TY=Cy8e^r71ru(7&ysG+TLFfZ51S%&; zHsV9`{wEaXlT?dS^l1zAstACLz@m>1%z(lxeNHoaeuB3U-os~%q!L?Nyxp5~3c+dt z8DG)U;fLrxeV$p=rfK@$hb#>6xON`@#csflzFrHA!27o!j3g{q-3TKn1*|4^OGOL? zg3+lAMYO6?jEr{Ew6sHVMQPjyswZ-5e52;b$1V1!()-<Lk;^2=t8~Fc|MlB74hM<L z^TpZ%nm{2FVXC~RSdfoOweLl@ik!sGLwMb2E=KoLCptc!HgE_D^9sZRn$~CzxDT=y zAfcc-uKsMieuC{-j689{WJ#0DZ}6+ZSuIjjk4vMM(~U1|an@@>gwvX`06qkWRZzIj zRlOEcda%K;Va3PhdVP_6SQjq2wksD=J8LC@VM0bnt$zkoO)C-9EdxKplC#!r^LW^i z=9obw`1jh`&@IZj3j3*R2E;%bC5xN?)Oc$dDdfYYYDmu-O7ni6qVWLBQy@vb<Y^&s zbua&fMDQ}?)uHZyT8i7T75o=nlsBu+{>O9>1dd+?3qMi#ENNHSJ1RZNuC5~sj;XuB zQ<17V7u6TvI3$k@=t-S852tFCrdd>?z+{L&{mAYFiBc?_rn}~!L(!KVqU*%1B&R^q z&1-U<i}OeE7-~V`7-dd8BiektM}OT>wOB6^ws3Mdb<xmaYxDgPCCSx-Tp5)TrmS2s z^+Fq}<URH86E+nQGiOd&*#{s?)6qGDlZ@*+1``$bPm}Im(*f6#c(i{S=H*EIlAh)_ z53U^HIW&@|?&5MpGB*w_WJYMCx*b0`1q6W>A#$je-BBqo#6TSg5(<aOSQUof?ld0` zHa0hJasnC)q0%D^ek}(Vi^Zyg+1dQC4lq8uVlv+B4&a1ytKDx@%r@8_FlR3>g(ww9 zwykAxUuRMF-32&|aVj<VxJ+=ep-Y<h94i+}4_$dDdOJ<q#W^_yN-UDA%xgi()6GgZ zP!_XKO_X_0rNny-pOR&$dY2f*(T!)NuFJS7;IhC(QgxQ<x?r;-i1tHlnxWn*5cd*V z)~1YtI1`@IB6+@JW6Ugl1!bsm)6>!(N0YXqRib*EUmxPf1&?$xbP`feI>(5o6ftjm zK3wH^UVGaBC2#>eYnLgmId>ia2rMTc14HqYQ60sj<3W9CzwnxvNh6q5NIi-3S}`zC z=;Pz#KsY*T%*B_ZA6O7>N`MUNj87ZDo11>exxBRM<aD^!#i^_6<lN`vqhbP1%Y+6# zOiIXrL6!L;TX9}lpBX^d{G=qMOU;4x=+50GPinA01BuT#hQhyO&`EMQJwr}@iCS5* z3z)+cx@=*#Q)yST3xB1y2QM}CW>%-um)!)@n4?I<ea~|?vulAF!(=l9axuQq-%UI3 z<6V=QWdd6+0zCX}Fp^);jsK1B<$5a}M{XtQ{QelNg<ogMEHp$lNlNgymiA;eSHjL) z?auyep%_kuwHNfySTX)lK}H(hlt%J#ZqY#-%?z4QB{aQ0?<@|E1!;yhlsbo0_z1Bf z-l<JR1c}omU3vbO$Fq<c3XZ=g<n8hVp#Bv4$hM#ck^=Ix8r++LWn3)nB!$A0t}&9T zdxWLKo_ynC8bTbkn}wOPlen@~)G4?+m<2PP_^73i!Yg*`hIf)b@2uhR=R;VF_3$i< zpZmT(s3=-2DfvnXpiWu#{|y`c8|LnSJ|PBGwajZ`%pxH?acmDt2zV@pM?z}0S)c?e zIDb+mLHUR?%nrZiQNx)6I;_h^6?QlX)}B*Dupj<0c3h~dt!l+Is7mSR$0M7@u%@}i zM9QTPP*zbsBQn=2tS=_KXRGes{U|E9uGFGIt06)FghzntTjMRN22+!%-VQp973U^f zGmtOt=BCWGB=06ucZD<$?z!ovln9nK5%#xCG;09jJM;UoQM$UCfytun_wDDrl-aDz z%SCN0B(rbt*Lj41UcbHJnGK~pg&xP6AOu|<1#>ccB0}(yM6*U4(Cz)uev;?=9ixq6 z87xLwU%ZTG=oMO@@rW*VNLL{~3`mPa6F_*BeXls@ywX-Z-ZwD`(N$%Nq3ubx33+~R zssGhZUOwi_RN;<JgA^P;KUM{DJ=Lnvn)!rm8zsOlI}d`3AjYr$_hHaMCVj}YJh=o% z&CbjAiEc5f^=_7A?~YrTfua>V9IoDb>_CNta$u11kpLHW{~H?}ji*vU_)g97pQx>i zhauo`IsuVH?43f4d3<mrIDmgPS@3%SbLc!PBdiB_pX82wmwAMQ$5g_!dpOhCj070o z^^@g_kI^b{$v`p@dJNj;l|W=CQa`tGL)l<NL3chyVimW$Lu1mIO4yjylWL-CqF8!i zG>V!@L}HM5z%<I?*u7O@9)B29*ca6BK`-g;4Bj!>oNN8U7Ju`y9(vuAj;TwH6rYXs zR*>Lp)%B&Stk;Q1gW5J{+`+}*lwh4wOOMM9As`HjCYG47Vd}mWb?AMy6y<gSYRLi= zZANS?Yk6FcohBIC9upT}9y1;-Ho?<JZR|8}=MwyXf}Vv&It?Ol0Vi2^eiJ=1oOl$p zjLz<zc2lG5UZ~G+h=n{eML{fS@$g0x)XTl2A2gBFt!2wUpMz|IZTijMw8YE5Iv{}= zF^t73w^qe|jieOuS<nZ}0~02+48<N15c2juuLJgI=_zZumjHuX;qs|S?C`}7{v7H+ zEXItHR4x7gfI%U*TGZ2u1>pA8m@muLL>ry<e@2qywm4B!wLO~0#m8egXS43e-^)XC z=i?W&Lrr{Ve7D&u1IZCmdV2*0pBfXsT`z^o#5P@q|A`}fTzfumGiA-!7hm(MLi}-u zQpO;qU?~nQH>=2z&1Gjq<1*o5?YI&t>)tH?@_xW&`fm|Ag&k1<awp%%;b4ZwYiKB{ zFi4VO1FWuc`tepehA1{I0}H)mT0<Hi91fFycOm}`{p;T7Q|=pfv(D}aNfI4N7LIeG zeg0v5DZ{v243d>$rY0vP1x8ek^j*d%7F4BjFFj=Wre6|mrgM0{Cr!^<^{YW_QgvNt zG@e6y;R-RwXEW(Ql}2^@P4ByQtL;))1hy!EuI1H4i`&@0CAOyIr`jLEkt#@!meAu` z*wBT>cX>U>Wbz|M+=@-;Mp3bn{>bh9_bnh%T9$V^f@&F}NMf^j!S8Kh(|yH&UhhvV zP@BY2G~IGv8f=bpqsza0kp=}+;;Nk*10x2LVgFmLbUJ4!owK9gziET!iW{xPakJyJ zD2B3z*YZD`^4$Nv1#k9;V|;H2zA`PDT!72V{ar#}w^pm-UkIp_6DPup7UbBpglc8Q zrZLdog|#I3%d<LXQKLx{&CcVD-)n5;@1MNj^t}FxsJ+QqDjET+_III4$){l8wEBEJ zS2aMx=epzn?EJjtxv;Xb;#vX}X2=JEkYC9E>E^fAq2)-1&Hq-zg{T_`HfTfw%K*4t z(j`?Ua8R(lmT|e~zCN5BTmw09-{Kh0gtLdYHu8Z~rE!jZA07_vd%svVF%>81Vlk1H zA@IzS=pJQ=j%zJP$H2TOiI4V>VIq8I_CyCWub0B|JDw}*<v|Gu4)+{lZZseWP{nCv zOTr81aB}z(X8exXzB^Q)+$O&3=Njv`+J?*PQF?-ZI__3c5o1n8lJ??Ir{zc0-|w#s zbejo1M7cAsQap0T?g>c;UQhC8Qnd`DGM&Gd=#yN}d55+UOMo*8;1Go0ahqT8Z>5s+ z)0)*uez|z{Q1TW!|18a#eK7i60#T%3@aBF+B*51ZuMboa;T4?K^I;LA1VkymkBKc; zO6|nOQ=XniJNux;yM^qZQ%QoNeDa(MT?jOpJ7BZp;Z-XC1^iodovLR1ARmy$Vb}ik z`QEV`0+-yxA<JACTPadYI=^D;e9(GhG58BXjr5lq1jmo^_5=1%%YO*@KwpJx$B)f! zrS2%t_uAz3{z#4R{w3A;KDIaD!{__Gf$0QM)0V|s3|{!9X-vA;KTxzvFd@iry6zCF zC>#Ja^Ub>*mmgr!MTW@y<km5ixvJ?IxOa;*1hR0k8BHVnH0pK>WN0W#S9=Hb_T3hu zWsB}KFro)p4PN1%&ItUQ_7Ay=MDNZ+W|X>0d*?vD*~<`>5I`y5AJy4RY!+L1Ft9rb zh2EQmCUmTFCD_GWtSX5sAQbglvo?fY0>+ziZs8Rv%0ZyN-i&~%ef~vC`?>5WCfA!C zIsQ*;`c43d7Twz7yty<6z5jqbP$i)c_QpE3^irsX5QA-tpb!j+qU2I*H4uBb`x|yY zXto@^2P;RSGL(fO1m&Tip+p<&)Pa=wR4~e)u>+pxA?dZdKNV`>_A6bbsYOgFxpUrf z0lB=My_8?5>M6n!SCt&QzPZU&it%(JEUxNcuE&#m+e&^RzSkWQ!NI|UhFWG5=}cB@ zO&0ur7u7D;y4pOy^lCBlfo*OF7B(pHNM-&ke_ER{emI#qiKeSF2HKS#sFErvbU}^} zL88}DDVJ`-<ntepq;A-|0N&dsns8i$dYH$fwN0c2CN?qnn*yD4e%eUM_2p6~Nkme9 ze7%1*0{upA?`x~}&J7O0y|lxr1ldp|+-%{7GF&OwsWD0iZ1&Ize-p;1@f$ur<aSO4 zyhY;N@3W9r0f+g0V}gH8Iy=w&g^Ooh_r2^lE3(<`Y<@c$*rJm>mv7K8GVlD~hMP_$ znfDHm?$!Rht<+?CWIMTFD8+Fn+IRimGv5b3@$3vVfGibL2X{8%)bGCl<z1BmLJDOw zi7`U^2e+-`da1XUjrit9)*`Hm^vmXcLb%LxP8g<+B{rk%(D0V|mZ@Mw4uT@ugoLMu zsigkGRnb$@b%i5h1b9UFTcEwlQS#eI17?s-ETvMstOxdyLEAQ6;PO8%tulcl+~427 z8wfVdmZ~(Ue1P&zPi9zEacy^J$7BdgK11P_^g2ypnqB!)ME)tAe6sx&6rkhVyvh}g zRkK6!l@j%iN42;1Xj~tXB*ca0^;kb^z;-VFcsFdAN)c4hP?KLl$&*qh9l=gSM@wh2 zv$C;)E|_m;CEE;uVXMHy4f5+l_0G|pdW4gL%iF=;m>M!Oa}Rwv&5V5WD!+ZqL;*g1 zsLMkEbLe0oT{*Of8kpxgHpA&~Zn}rYkBiEe<>@bO82eyzJmO{(_$T1|e0yZ{>Hc}j z^cm}LS#moHrmbK^vboI42o1%9Zo9Z3I~ycriEIA5*&;%JO`T536Yh_X3{@c;+eK*z z)tmOj)uvWkr~ZzhxcQF?nr>MHTh_lmB_y=JLv|(6kLId|J*Cz!G0Km0P!v+Fr)OuG zg<cyIT!1EA0sAn*zEW^f_V5~?*DcbZ%cIfdXdLGGN&SzS&}t5Vaz$y|wl%X-n%nVO zU-0cN;qLPI#QQR8gzZLm+~cZj_?a(>A`~KqKZ>}6QkN!4xI*B}q^h_~97Eq07Ocd$ z4=>v^+p3d-uedQk%#9IGMhB$(8s?Cau&qDaU8G!NwoGn|n%;|4frtUYvp5w{*~$&T zsHl|iYJ&CaLgS`ZghO3v0Rt8WBDnw;8|NJ=p*205c(+u+%^RTa?prk{gjkL64{Y_I zf9`LM5(E1{=fVn*;Tw=l0f)JlM=natY&^ZZy0?)!-$-6d%_zg61KKE!-ryjb5<SrM zD7B{y&p*fT`Y;F5>)c>0H^OsBV}U14kQ8a2;ttzf#79DIwR$sPeO@VVW9_((s!CeG z4uM9zt4r>q=S)}+*SlpiR|zLt>}3YyyKLL``l1w&qO|2nG>8M~$`ARH5W3JWggoNi zMM<jf{Y-LopAd_7E6yMz{OM%|xZ2hKorp9VU555|^M_AIK^rM~s0u<d1`>aboC zEW49}fJXRtXKVDKVET~BvTf^ks<bwbg_5=(%mF_V_ShP;vWi0EL=RIL3s%8jhD5Rx zR>@7zuY6<1;i4QdDjP60R{(z~-VX%A8-wvv>w8xtoa(+*wZS)jr(#5=2mi(SeOwqp zp-6_R%~R?gM&yR<sqz@a4UmR=ItkaBr$cfsF>rdOPNiu}$ibu}KVh+yr)|Nz790H0 zZgXI0+YaE<(74O)d(G~tNlWb1^UQAQls3^WbCy!5q=>T0^sGdYy*at7yRUU1dasEq z6Pz0A_@#yp@on(Fky8ej<2DV1FHaKZ1-F#-^)wK$bO8VMI!e`AZMQ+gEHL1q<>0fq zyR{xJ>dh*}tOUJ;Vfce@dl%N~&B1FB(+>Vdt)gWs(-Kjn7@PFjE4W;vGdRVyGxW{9 zX*#0w+K-}o8Q1C^`22YHoy}SYbId5cmPLK-;;n#lm#&2{fN+aEkqmQ;MaRDlvIP&G zk5%D-e0ytuC-b~JQwsE1wuuLdWSlVk6g|-Tm9ptNBk=E@>5JC)=?3y_SCtsmyHxMq zY3``V6j6_F+KkY<=l9!RgV+KX{AiwI0`Y!*nh8uGtuh#I+gISGXU|77|4$Y&tgv>I zIgDHyy~)jXj~Sjj+LL%WU6Qd3f$${D-ywJ8LJBbcHT%22iU5bGN0X?Ih!9=dUmFYo z`=Lbp3;CaJNa%c@K2}$^-(6;W0Hvn3>U+I*@-is&CPq)m8UtFcc~m(kXozAGi2f8) zlvTiRoeW!vsz&z*T9+DcnkOC4u|3nSzT?+|B41n)y^n&m=y|e!hYLkEr#&cZR|U0i z5vrMxY&xwl4w+Z54npDX+FY`ur*S<wU>Eo1FAByLCQ<tX)yt*Q2l@jReTIQeJOJ25 z(DvOAKs$XG<tqdzo67cj*^5BK>3}2sPecnbarAk7(%u+>^uO5C*_EA{H}{KnV8pE* z2>*d~P!JY6iW@BJD=Q=COVuoFA(j?w?oXLb8@lijj1D0fB$e#Yz(^O+60920S*Sb@ z1)J5J-Q1i25%3|K&|jTnCT-@Ub<3;KpUckibDH&rQ&d8)GJhPl#-FY>sOn@pZnak2 z6T${2v4P3ONw%58o*REAu5B+eI?b9>j(}loszv#%*@h+CMj$R4Zz`#?YjFFgqT!L% z)U;I;$pRx5btm6;h^G<L(*k3W8&>T?Ckl+m-1zRizg$`gZP;CAx0*HUjCkXDtXZVr zB_#mGslH_g&CN@+n1AZFi9rux+q7+bW0p<7hbes^7p%sxr}IQPE>s>$)IOlic8L~~ zQGYa^fDg5~3@)`_1g>2p#j^eBPM!YMvTf>`R~a3nkz{Xltr?i$$(`}Pb_F`{%zr0x z_Mwl^Y?|X;W0#qg16~G+j>EAGck932>dRY1up|J$Rea)G?sQ4ZXbR}3K$FP#&&COD zyM;yk06Im+b43zAcX|<0YpNKg@sia0Qv~y(f*lEI*X$rjg1i(a!d2Yg#Hvr&o9U+b z%>MTj_<JB^e;5PWRV+iVU|{jnb9?0s?*;w02kX#%Cz(dC!)g+a^YxmEUN=$?{ct>G z21K3wcSC5EzQ1wREYe}#ONKApg?6yrJy1_q$fGS<nCnlqj-ECgPCnmntbmyhs<%HM ztE)8!_{AL6zp7k-!1~+8xI1DB%mmg*IUmGvJ#l^<cq5dxh$Xzg9%5MeVK134t7FU< zD{)wf%k>)lZ8Sso@Rlh|;w|rz5Z>_L3|N@@H~I1W{AT)J;ByT@*A(ycM#G)*`$b(> z{BR6bv-ue6a-G4(Msqhtrx&Y!VCQWuHSG5w>hJ$S7J(>|Hp*?CG*T0%lPm2m0HRDF z#^E#($91>xyfZUzF;Rx^yS$wTyeG^0;m73dt&`HCr^~|1h6p%UzCn)<hwI7o(JUa; zEC-U?;cpmW!4MQy`&n7`H<I^N{?zfcvgfRIiRDC_THND&mGb>}mv02z=>T}ul=#J= zPkfoyXiIlT{nvMOaE#GEQaY_V{-X*DC5&wM9J7|Yl8A`rHoa6wL0~?@FOAW_XZ1M@ z`Fm2mtmS{K5x#%@^z!ig->fM6?I?tQwK%sfj(8b1ZP;u%73MSJb;1xG0(54Bnf&(P zfMfD4h5VH-6?p#kuQ<=VyTWxZ-!9-!TAusG^54@s;yY6=-z>ZOo-`)^GdTf`=CTUj zu6=x>|GmqZ^dn_GyQ9@oW_K1yjb2-wlmOqS|B8VpfzitVR+&X&rhCr8_b`gih<u#i ziWB4T&0-3;i>Wc_dJ@my7orB<<@YM(N)V8?>idqRaWqa>e<)}4hI+AFn?05H5oy2d ztmuN*=V;ri+mm_(1kk%D0oNzmz?S?3-34F$3G#^ER74FtMgSI`GJHQ2xIS&^onK6@ z-!&5Hi4G8H`TkwfTI&lG0=gaB^iP-I>oo_H>oo+SQ`gRx_RHT!%xc;43LDq~|G$Td z&?myGD-YzPaNMGwUwmfQ$PnsI97S{h1eRdX&1@#S_B;&yArM;q@W>yMB0PhhiRgI` zI}-Exj4WS<iQC=m9=X@QqLB@dTmN+hl_7C?QWLS`?;Y`m%w8P1gQ;Z2xHy9k5`_JL zHWghY$JrN$O)1$r)(Ld$EZ=JfNq$ruyCGDg&%NFRcXo2ehx+~KO=$ymBouyzmy96O z7XB}1NSIb!w>y;VB=Rb(MNv!qmc1tB4!x<HjEkg9N<8?a4=M%s4s-~aOCQu&94myI zGDLEi!#ixqjTW~|h-fBMPv02@K6&vMP6e_In)s*?7bt1GS1#hE#f^02o@qNB^1M^Z zp(5KFx(aR1DT@9>${~2;VOm)MO0gt03hd^ETXhf4sJTI|_^#lVnG+Xr*^HSC2p&bp z^CFVC^Jci|e3&t9kKIMmVuJseJXVen5pzNXxUDnn9NI1?RkSPdvP_XE#BX+cDE=v0 zDR(SHwu&tnY#T&5+bPA-hpyn@6CTYPNQk>2ySLbON~>9%-oYL&*ZnhqUcf)vWc<-H zgy@#h()>aanrfLLdK;gjv!DG9m#w@Dwj=EGB!~`(xC>f`sU)@3@$KeRP*@jRJa=wL z^89?Ns&3iw|HwG&_Ccwy$#o>)krwKe&l;lj3^RuwWbw+JjD0;u&g2b}QFFN^MfPl# z(EX{zQpwuT_JP8DCS^ff?2QiAY#Yuc<?Mq559p}vvV@cI(t}E6&@3_;T?bVaBZutL zxSIk{d6~Xzl_*GSWca_y*W#&0#uk1suKD-Ch&46K=;juc?a+9aB16ZOpCu(gdsYab zRyZL*Lu8ncW~hU&SMZQx#3R$N%vaHSH}FR9fhXC7)<b&_%adpiA+yM$mt;I{f<K@W zlAh^krJx^2!lL>0QmO3xvzmYK1QZ?ME_{eMVd<k|yhb$dFFH{Fl3q7Gs)!_uIZe3b z3yN-uqI15@(1Iz&6nQYV7d<(qNIZGXuw2Z1!nyA0XlxT21KT=BTr8I6ki{2>^b%Jq zKq`z&1&j20^MwXS;I=OzkMN7V%8sAKCqreCjjoDu<MX-{_5X3ssJx3CSu5C0O`{7U zDkMEx9a*Hfjx;9kiyvtzL#e{9Br_$Dah-ENL3VCzYQq7Bjb+N=%bsy(SNVgaC{MGR z9qM&*=7f6#Mg|caYU3~M{rsTJvOZvw8Rlm7vJlZ`L)+wI!ekg?h{qp%etiGkbDznN zuO2pp6dhCK_pdS}CbGH?WP2n9Uq3961a`d(V~nR`&coD*NIkAX$L`qPSJb_~C&q{F z`gTL$MB35x0zy~$ztTxR;7qI&xw{ixK3TD~qZtfCr}ZZ1<SDLUH;e#(_(A#dD0&+q zw*4SH?8ToQ<xV!Tlp1$``T=a+#%xB5Qdh^}OpYMCw-RI~tM?yw@S54=wuTM8;kQ0$ z39|&2)PJ8g+=FU+;BuM-DJ9#HzXlU*hB~}S!n#r!5=h_=r{%=udN|8+??zg!@Pp*I zQ2iQH!&rN9e__fW`y$M4JS5Qm$|}h`CP#c&AtU-y3X5_0Q6O$S;(D8ZBkA`uL;5#O z46)U={9QsosLz>lnv@dW^#I_0rx4N+fLD)9^ddBO(hE`VmtN#r;7M2_!Dy5&dLps< zG0^^7A+*emIHkduAmC$$jLY9)z5KxY_ob;ZglHH66N%7^|A1Pc*y<bd{95+&&qv5o zQsyS4ryh8wW1?R{^!`|#pS+j%U3Uvip+%SBHHzV0NuLz!a=I@7|J(FFXrwO?)Fw8C z00&U<M7=MZ&%(ga^l0fH^$!hlT)zJT*Y3IRkGcx$$_cA~IgK#wRx<^63n`wJqKOT8 ziQ<=M9!ZSu#U&Vg@;MRx7k_F~-0R6E_~tWC&7q_nlhb7X#4d>G37%-%;++$Dw4^+5 zIM5?H)ClW!>^Rr=&uH%mO4W<=RY!5PX>D<0;Sqb1bf2Tw3XQ~LVVrBQb;+=_&y)AI zKQO}ai}HRwRJvxga@=hdW-dXAKQbs=*)b4)>ka#D(r92<NXGp^sTfXCjx8QibXr(4 zA%$B7mR+*M)%uc~_ah7oZnsfrgt0H7;n*M&FDWS6ym9Aojk1z}7iyj@^LXB1EIF>H z-rovxf@M95Dd;UsD1KtEC*6(v?MCGX25d0$!f#FXrKo`09hkoNh1>m=B<)g!R~20s z`56l=Drq>(JVDL*%ww?g;D&OruNfwjz?X;7>K(B9_)i;Ia%si;o>x%6D=eCTn-iKg z0XbwRqzu~q=;))^gBP~I3tuWnhZ3(#B!H@kutJ4Z&2kQ}$3DRcc^kTfZxytSES?tl z<*-yz->Zb*b2ZIU%mE-iK=@Fhj=Kjpnn}kaqfIXP@n!j@!025<)Ke&tRbI+53$Aq+ zWYKQGEb!OISswuDx-5}5{HHFOf|F2Zl!%MZ7SXG}m#Z8sh*+v-w%R7p0dYD$ywsBo z)TC8cE&eMwVD#zu@<fF)<&OLJ478E#1rgv{IIB`a9VHeDOncJe^+g4qXf=2>w1u6s zkV_f3DEtSyPf=lJ`+^o29eD9I{?1K-Iu}dNo%TM0H!}!kG*x-mh&ojHlWN*|lQnE$ zWS4QFC;n7>p{M(~yq&<6-g+Ki)wOW}Mk#=RGZ0StFI5Y9RtfLe;e+h(Q)NBn*HwH* zIn^FYZZl?dVWyJx;Sc^7sMYLjRS`9amK<K}kw8y@YmAXCEf#&(tknfF0K^r(DA7NA zzZ1ER-co6>Odi|?eK9<O;rtgdFMBdkk&KqzoM;C((PS``**%NJiJdsY^>Eosi`vB+ zEDvbJTz}=O>`!6DItorJ7?LuOoB)Ro(|p=v7I@O(er@LmX@(WAp#|L{%SzbK!<9s_ zcj%&5+fH;^0V52VF*2hDOdU5!R%RqmG0`|J3^&O{ZIfJ-8rR5%FOB_E0DA#uO$0MI z_UndABh!-b>L>l%qfuE1BTmAx#y|;&o~7$)c1(RIJWd{1sH;fWsz4b2YUodI)U|ip zPd7u%8p*^Q9rgW->^Z7FNUmH78`-$hsaX|mS#sF@5XV4R@28tvi*hp5GYb`d$`@Tp z`bl`7?0*Sp7Y@MASL{O-{A+=|mMWG*I+LY9%W9k}w#xOz_O_X?WMqsstYwIJ^KPYG zJya5hiUMCu9IYZ5gxPy9Z!6Q9TilqEtGY;v33@kc7`=sua*=$OY-4Kwt2Q(O<gy8g zR4V}0=$_Hf3Hl)jT&#-G4T+=?j0~#rn#6pEb09c(HJHnIt90=r6x~uA+L&c0n-}5y zDm!tjzQm2q`KPcqWK#4&HDefF0Hn|XqTjYCHa5AjSDPpha;Fm&ye(_N%={CoaPJ@G zNILF?<!!?9zG69z7hRK-faboVzRvafbzg-hiPT>lDC2*Z8wNqQU?aB;RjO{$xlt~? zyc@=?Xaec)I>*LDAx21ZTKdWMB5rJ+a=U62OINPMDTT>6yyFhGOh^c<nevrF=r~-1 zxCm)U@M{`}lKn9iiQ2&RXV=$rTH7^-cC>RMvFj`FB?JQ|bBdaj!W87JJbf86I2pHG z8f>06F-W&6zT96i<O3SyEZ$TvFY~TznBeW$gy?PO_Q4S#PO}+hXr`{MqB>(Fk@1Y; zc0{q**Z6z?$g!N5eP;)}Mp3T3@00d&D~jGQuAPE^V{VrZmmD;UvN`=T?{>3oc0w>7 zE035jPmHUTUnU3FL-dK8F)z(26gh5y%nOTaa4XUwgAbK2axGRuMFaphiMA`=1DPOR ztx`|3rNRYIrVFzzSO#02Xp3`=jCds>`80FtS9lsBCj{}3rn&}QSchVFU@a;v2Pt6+ zQ+OGoEpeMADjPxr5nV~)6_q%{v&%A&%{1d@G__ZRWM*XuTa+RQs!B#JE3=0Y?mIBR zz#X?Aoi85!qsY7K$ePinGU###hRk<f*N2`inB1u>k=fEPq5t{w2i{sj2C6>uU5Yk} zP-!wG)sVAj0CGG<Sd1`3G&H(HMQK2WEXgl!GX*jPK`Qa4htdEPj_^+D3OnbJVelKF zUnfl1v@9Z$Srm6pI5kcAZ#C6wgyZkTi|s3sE0uL~;uIzHx^9J%l|vPg-l{fFvM`gT z*vFMV^?y&{pGiqD{<X+KUy*FmO>SghSUcX#QxY#0A;VtQR1>2M3^j}TU@K%R*Hkc+ zuL?NPTZ^uwB!N?4k4_kcp7cqe0~pNR+$S-nbw+r)Ezld=iB)DZX4}&SLB>kOIpl@` zI7sBs7)1uE9YO#x<q<Kg^65O)lDEjWIR<V7{S`2UtC@edcxvfE@CfC>6_q#twcxnm zKwOq=r*9ro6oE4#-<a|y=PVICv;<>1PH$M&tds=cIw2HXvD2WSsfxyCWdBvoR|Jn5 zYU)cDb$sHk+lJeiM=y``{>7pYxE0Y=zU=o$$DZ$f&hf+Q-!5J|Z&vnY%i2W_sfQ^3 zNQvBHG%q(MYYJfn2jF3h<xezm#2S+<<bQZq-5m8OwJ3kXx|c(!K~}(PWeQ%4vzO+7 z(g}#iSH+i3mkUspBTFqompCY4P^cm=C`HnG-G*^3q)bYO*2n1)nUY-bWkE72y$kxs z{7j~{u5f*@!z+{~!3v2a6;VMQT~?7bMf6mIWc_=7xSiwIFUro7I?Z3<51PeG1@1B> z>GPw1@x~nUjv=9#i9ZZ((fcn42z%bC`5MXwj5B^JCj^5mdMZCQOba!1i}h{dJ_(oZ zl<{jB9r<c+2_<N$FgeDhXs>h<<sx^q&eU10aphdBA%oR_zfoPtw3F}-SiyJf8W2rc z+&`X7s}~=a9}zITjeb+2O@uO;%Nu1Req`M*L7E1KY&N5^55Bm=BUZxdDic#foG)*L zMwTu*H?U_W&CR2--)L9{z;Dy5QEF40O!>N`*OD^wfVP0&Y`(+3of4rT5)hYI25<KG zV2cM&z9gWT3So{09|Yp<1VAU<x*V1<N=-(ZRxH|BcUktApbab0D9cs>ygWE(ix9K| z2?;W?vrq1AG11ezvjqR9FER;5%3KdfsD7NGM=b}?<DaNAODNl@M5!*Q`=b}965o>y zznanr_{#2el-T$#Uqb(??SP*C`f+W;z>yx-gggS;aAWaUC?w98yC~zE@v$*xT|S+e zcTPE`A**zVsgf$niWgTRTLt4K&5`N_E09%|1ia8fG(PxswbT<0iyqPyc7oaoy)gwe zedG&!r<di5gdztXWff&3%EtU1$~ucpS2|?nT^h^#Nl#k7FuoW$$2zUxb3!pf!^)L* zh!J5@T0li5Gc+4;wldh!cChnNPhJ$CsJj}znARA`_qnwrD)bfuV_{77OK4a7JK(Y$ z?~ES<mr71shMKsNH`Mn=(Zah*hNz-|!&qzk@6C7bI*@NGN%4^&!}L5a*&&&Qs3^tl zw%4TnabZ*~Fy>|>O;pvc>0kUJ$Nizv-ijZgW_~!v@Z9b1oK-u)IjY;~^}GDs1YD9$ zZI6uIXs;+qF+}?au#Gvejl|H6xevWLuzCQ1V6@QS6>g+0F|VXrX#plnwv*=~<CSc> z6IL;hi4h_r-XJ+hF1Y&+^=XvISQDj+`+-7{8YJiC{nqT5o2pU4`jvv~-0sFx%_w5b zGoP66es6u&I5-W&_vR$Aw{U1SvSjfOT$$n{%3)NWu#s<63kt7Ex~DoYEZyvpQ(Iu@ ziqd^S<q~N*Bp+0f7x~L#LhQ8J=%!X0NDSe%;<YO;>rjD*r@+iD4A+(vA!m|Z<EVi{ z@=tAdTv?^{OWvq-PNUjXOnTWPXQNth?I0~TLc-gY+P7VSH<3N0B8~3*C*XFlQog6o z#{&!w#gE3ju$?0SMiz_l6{KERawo_I&j$NE=kupV%FYG^G3ENzLamv(WA*P%{H~)3 z=cVCMyLv+1lc+w4|B~l|0^i!v;#yl$=OoR~G{YO>zN%>Z74=2L_RRFU!zGVfs2Cd4 z^*xWej7=zng-Y)6k7DX(W1+G&v>+~eTaY^~@A0Aoa&uV_&o#$2%QK%uY-9qVEW-*9 z&fY7x87+0ZUdce?<{xLbXT~{rJ!PlC=?;+T_E>m61>qI=Qw)5ZHGv0D`N^7`evqW^ z2;4a8Pc9T{P+AJWcxL&Y54!)go$&`aoOSML4nOX>tW0VUXd_t3pQy7Mokn)D7`5Dz ze%--JcVYHcnP*(E`CgH{PsG|D$C8!?&2~LVZCcCdk;w~W2;bA0g80fFz<<3uctr^= z$hsfwn|V?f+>FQ^%F^Mw;_r}qSu<q*uJ;@?w)1djihjwjqrlGH9*{@7ZzJi68-%+n z>|pENxnR6M%{SiQqReX<VCmEj0+!@vf-V$MHE>)x-#fZUAr^SC1Th*QIb;gwvEZP9 z!|i5&VFtc^Nsuk#vJ$9~9iT*sRQ@mw!1q3UzT>rIv~;O<eZXpXmAeb}X5Uu{NI~=O zY-$-NiS9sNF@mt_<0>9(j@3xJ<hH2FpCpCap2uB6xf53>fz#^$SIR5~)m*e%jkMqQ zrF5tFMWx+H$nf@mt(|K$6j~d{Cw0Op#VCc;Ou5#WyU9#$2{Ge3Gb&1Fh8SaFrZI9$ z9da9Y1|`?LQ4+c366xZ8BFvEF5+TM(kwW7#XFBiuq4%uyetSRcwbx$z_xzu|_S$=Y zdG@oO<M;bwNr}Yf9n^P>IE1eCgn<pgdc&@n<Q~$WQ8%Ey)YDwZje5OFIdHSMQY?GT zO);ot#FGKub-jrD@RNz3{IyS?lOL{YaoPli1?cAs5PX`*b&E@d(g$cOWPIk=1RqCB z+uszQm=##cG1gD4^e<CY#XAf++TY0Z{C0ea?A_MKD9M?k3LWt2_w1_-!(sLEIvWRj zkv0{P@fJDjj5lA^E_Bp|n@>-j2g|IUkNR<C2a=N4GYqcGQj{Os^C*yv?OrX|l|QzP z_e*QFU$Q);q=64u)LSVQ|I+w9mpZDv!WSqWZ_mk|7g<d9oSI1}#CUfUXHFHOr1Qso zmE0K6lNx@%do9-g>)fs_9Vws;#r{y#LvzW~dgb$xGs&f3{kYgYc0sG<tgH#lNxcTI z4@H%!N{`GY^N;l&SUXTgd)XJ7s&g?6JBp2Feg`***2~LY0tXv3N?yci8g)Lx=B22- zYS4r_OMebBemvFt;OMQOz;ngnI3Jt`BWj(gZrOe0U1$z(OW%_lSA0!39A9ttdaHcu zsVa8ac{ux?9=`d`q$flJ&c~&R{D`y%J0Z=mHSI5bl9D%<)k|Jqv3o&Xa?lbubJ%m2 z_I0{7j$5SaTeRy48svK-<;mQfx5*RKrw40fgR?V}7iB8SpP0rxZ3{><*XupTl{b@R zz@9;$?7Wjbl<8Z{YT7FJdW@!lL=<RQ^^)W*GdUe=+iWZtYcrM|(2kOBu*1o;5LUn8 zitx03peXO<n_M|Y5rIe`T+IE7WNuPj*1J6r=w*dFXn1`*;*DIc)+;9|VnJC~MN@B5 zxRTqT{^{YSy~`#$RKW|9Pj~lY@FqI^S@u$V*#^I=rlVx=EzddYlhfS?m(>^c_W4*X z%x$R?NYW}3!26Rs1NeU)R#yy`RADmxx}DY?0&-1wJMN+dyu@|OJa4%gy)Yb*Z<5`V z+gEMvA;ZhR)A)VcO5o=|Tf{~Q1qFdU+|(w}ox#`rq(e6}TUGvSajh#V0lS=T<@ZgH z%2FKqV!OkK#I%?eng(6oOC9HxK>sySO6v8z^rX`4$38<tm6{xs`m3JkozU=1v2vEL zqKew0Pd-1XGdU@Pkc?OYcRls(Fp$OhY_!Y9m5-q!yfOM_4I9&xfK8E#?jqW7LwhlG zK62z<9aBs5Hj9Y0RoR=;>}Ke9!kM}BMMq4s`u2-r#TN5Vei;t)n2GH=EGA9Uy1O`3 z@f>MMD@kOrLlEKg%4O>T(b4(R`jmF>N}|VJt6OP2UhOfjJO>3G`zQ*c9|`2zzRjyI zaD*>**<4FR&V7wMJ63uvv7{bYlaz%RDZCiDC%)1ne|G;jGJEo7KYn-@<ly4#@y}v0 zzixvT9kMy2r7GeUWj|cXD!SGh+H;o5ZtbeXXyr@}dDLFh%<&@9Ttc%ishU2s;U&yg z*}X;aO$6WZW_Px^qC7MbYqH6~Syk-t&d~!3HRxwwq>%k;DZ|A#NxT;TIwlW=B%Dc~ zy2qpJ0x1c0rF85h=>xG@qw%qBj8`p23xxSO|0e&&xQ|0SM(1>-(YJqNUIqe-C^2GI zO{cp>PR0=T{DW)qk?Gwmk?<o#o87Bh7N9JeGj2Vw23xtUCa<=@F-+NAqW1DEOsEiA z8$28D5V2vTKfReXLK}O)(7}TPBCK48WmBd;j5r`b3(ZcpI<ZrRypz_)OKc~LQ3lfH z2-ti@`0`bioK@eL6RSao*(d`{Gk+c5?acewF8c>1mz;22qxxktMR^`j!NN9v2vdJ) zICxGbc0eoA#>8M-4B_Tgo!uRAILh4Bk5vS|HGzLa;UV!|y>jE4wP#us^$oZ7mzap+ z<mGjPtK;7D*Nx3F>$|IIs>sKCgmES#Lg6_Jzbc4TF_BxnHE-XGp%8d2;4B+_Rb;+$ zOK#?UC9O6x)n10&M<kZwa%W2ywM*APq9)^Kx#F!A{zr_0<SmvbjBp62-FR(jUbS%S z%7y+Z^6BCD(z<B<hH!h;hyueX?%l4(>O$vuDdHGE3W8NNE|ZgULOGghGPhL4r{gB_ zl>Ec`gl8Bq)6%u=jSHVMJvl+KV~eMfeyx&QbQs;21DM8w?+Z{F86?IC$s{s*z%k5i zhWwcG99}eo&*UFEsOx2O!BWsABP)7;Z-A^H;dqk)T<jv)RH`_dnIg=Rgwsk7<phvw zf^^NMER~YSE9vp!x{1#lb(@o2dIs&HBX@6}nFm6?9%smWfHv)cMzt_{LcgOM9QFgB zlWs<01q+a1{py`St_i@GGYPmj6h0RaTDz+8;&w^9CtqEoibB!3H0t~!ML->Nnwh@> z(JqvA$un#IvY#YZ-r$cojt;Sl2jW&u@Su=WMG6CE+QKkTRb2{h$<DvYARjn?Q#&#H z7AWl1Go@J{v##Qr!X8|HDxY;x>^XObomEvaP$z#kdh&jCJJrXw*?@u150v89tfW|g zj2ORT%IgZVGS9q6r#J08QgSf8Kb5qES9j>gll0Uw_XOJ)FC48`P)j~v{YM*cJG>-` zH=TW2F^qm<oGVEMdtbktfVgxQte9Z#JhIr>Os?D)1p78{B(Cu2^t-9fsNj4Kd-u6n z1DANca+~$mg?HJeA1p>SrqnZO$o19dZ7a$_)Bdj2LanqPfxGO(m)Y+9l2Dzkf+Tq8 zB#FY8Ikjaxayqv4|2SL~Z$3VHJ&C8hV+a5MXmHHWa4t|e?l?ELyQBjk;Rv)Y9IK1K zlHq6^QXdCLAA!ShaQMi!L&pDQ;LW^1_Xzyo1`keUUY8hH{P5t*^x*hY+3o-<Zz|2* zhDxKmF+dn728z`^3i`K8lr9_tazJ1}o*WJf2ZQ<h`$OqJXi1aMP$rueDyVFdDDM5C zNcQyecE#b$m~MXF?miqG&R&B00uXn_^{{_1fBVGYJl*LuPYwWug};w!Ym+d0e$x35 zbDDmE;|V}wu+Q_Hl_ZGrPlyfOTT<qR<qr6JRWOzh&A8%}?LTyE$Px;GKqC+c$=^AB zwDr5BA4>-Qq(h<yNeDQcU~0-uuw9ePf_|EHBw7JH=oj53I{@Q&vtTSw)=4_jiiuT6 R-#|-PfR(weS*a-{>@NlYDCYnG literal 0 HcmV?d00001 diff --git a/views/README.md b/views/README.md new file mode 100644 index 0000000..1dedb57 --- /dev/null +++ b/views/README.md @@ -0,0 +1 @@ +This directory should contain the binaries for all views. -- 2.16.6