--- /dev/null
+ 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
--- /dev/null
+# Tigon
+
+
+
+**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.
--- /dev/null
+# ------------------------------------------------
+# 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
--- /dev/null
+#!/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
+
--- /dev/null
+#!/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
--- /dev/null
+#! /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=<I>){
+ if($line =~ /rts:\[.*\]: Started Logging/){
+ close O;
+ open O,">$outfile";
+ }
+ print O $line;
+}
+close O;
+
+
+
--- /dev/null
+#!/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()
--- /dev/null
+#!/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()
+
--- /dev/null
+#! /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=<I>;
+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=<P>){
+ 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=<I_PROC_STATS>;
+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++;
+}
--- /dev/null
+#! /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=<I>){
+ 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";
+}
--- /dev/null
+#! /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=<I>){
+ 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=<C>){
+ 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);
+}
+
--- /dev/null
+#! /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;
+
+
+
--- /dev/null
+#!/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
+
--- /dev/null
+#!/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 ..
--- /dev/null
+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
--- /dev/null
+default : Contains[InterfaceType,GDAT] and Equals[Host,'example'];
+csv : Contains[InterfaceType,CSV] and Equals[Host,'example'];
+gdat: Contains[InterfaceType,GDAT] and Equals[Host,'example']
--- /dev/null
+ ///////////////////////////////////////////////////////////
+// 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
--- /dev/null
+<doc:Project xmlns:xmi="http://www.omg.org/XMI" xmlns:doc="http://lynx.research.att.com/models/doc" xmi:version="2.0" title="todo" name="gs/fields" description="GS Probe Data Dictionary">
+ <field name="systemTime" type="uint" description="Unix time of system when data is processed"/>
+</doc:Project>
--- /dev/null
+<Resources>
+ <Host Name='localhost'>
+ <Interface Name='GDATO'>
+ <InterfaceType value='GDAT'/><Filename value='exampleGdat'/>
+ <StartupDelay value='10'/>
+ <Verbose value='TRUE'/>
+ </Interface>
+ <Interface Name='CSV0'>
+ <InterfaceType value='CSV'/>
+ <CSVSeparator value='|'/>
+ <Filename value='exampleCsv'/>
+ <StartUpDelay value='10'/>
+ <Verbose value='TRUE'/>
+ </Interface>
+ <Interface Name='CSV0TCP'>
+ <InterfaceType value='CSVTCP'/>
+ <CSVSeparator value='|'/>
+ <TcpPort value='45678'/>
+ <StartUpDelay value='10'/>
+ <Verbose value='TRUE'/>
+ </Interface>
+ </Host>
+</Resources>
--- /dev/null
+
+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
--- /dev/null
+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']
--- /dev/null
+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;
+}
+
+
--- /dev/null
+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
--- /dev/null
+/* ------------------------------------------------
+ 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 <temporal field value> 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+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 */
--- /dev/null
+/* ------------------------------------------------
+ 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 <sys/ioctl.h>
+#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
+
--- /dev/null
+/* ------------------------------------------------
+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 */
--- /dev/null
+ /*------------------------------------------------
+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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+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<host_tuple>& result) = 0;
+// Flush output from the system
+ virtual int flush(list<host_tuple>& 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
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+#include "hash_table.h"
+#include <iostream>
+
+#define _GB_FLUSH_PER_TUPLE_ 1
+
+// #define _C_O_DEBUG 1
+
+using namespace std;
+
+template <class clean_func, class group, class aggregate, class state, class hasher_func, class equal_func, class superhasher_func, class superequal_func> class clean_operator: public base_operator{
+
+ private:
+
+ class superattribute{
+ public:
+ unsigned int count_distinct;
+ list<group*> l;
+
+ superattribute(){
+ count_distinct = 0;
+ };
+ ~superattribute(){};
+ };
+
+ clean_func func;
+ hash_table<group*, aggregate*, hasher_func, equal_func> group_table[2];
+ hash_table<group*, state*, superhasher_func, superequal_func> supergroup_table[2];
+ // maintains count_distinct for every supergroup
+ // also maintains list of groups of this supergroup
+ hash_table<group*, superattribute*, superhasher_func, superequal_func> 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<group*, aggregate*, hasher_func, equal_func>::iterator iter1; //find
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::iterator flush_pos;
+ typename hash_table<group*, state*, superhasher_func, superequal_func>::iterator iter2; //find
+ typename hash_table<group*, state*, superhasher_func, superequal_func>::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<host_tuple>& 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<host_tuple>& 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<group*, state*, superhasher_func, superequal_func>::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<host_tuple>& 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<group*, state*, superhasher_func, superequal_func>::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<group*, superattribute*, superhasher_func, superequal_func>::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<group*>::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
--- /dev/null
+/* ------------------------------------------------
+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 <app.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+
+#include "gsconfig.h"
+#include "gstypes.h"
+#include <schemaparser.h>
+
+#include "host_tuple.h"
+#include "base_operator.h"
+#include <list>
+#include<string>
+#include<vector>
+#include "gsconfig.h"
+#include "gstypes.h"
+#include <schemaparser.h>
+
+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_functor> class file_output_operator :
+ public base_operator
+{
+private :
+ file_output_functor func;
+
+ FILE **output_file;
+ bool do_compression;
+ vector<string> xform_command;
+ vector<string> temp_fname;
+ vector<string> 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<n_file_streams;++i){
+ output_file[i] = NULL;
+ xform_command.push_back("");
+ temp_fname.push_back("");
+ fname.push_back("");
+ }
+ qname = name;
+ schema = sch;
+ sprintf(tmpstr,"GDAT\nVERSION:%u\nSCHEMALENGTH:%lu\n",get_schemaparser_version(),strlen(sch)+1);
+ file_header = tmpstr;
+
+total_written = 0;
+}
+
+
+
+virtual int accept_tuple(host_tuple& tup, list<host_tuple>& 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<n_file_streams;++i){
+ fclose(output_file[i]);
+ output_file[i] = NULL;
+ if(do_compression){
+ system(xform_command[i].c_str());
+ }
+ rename(temp_fname[i].c_str(), fname[i].c_str());
+ }
+ }
+ if(func.propagate_tuple()){
+ tup.channel = output_channel;
+ result.push_back(tup);
+ }
+ return 0;
+ }
+
+ if(func.new_epoch()){
+ if(output_file[0] != 0){
+total_written = 0;
+ for(i=0;i<n_file_streams;++i){
+ fclose(output_file[i]);
+ if(do_compression){
+ system(xform_command[i].c_str());
+ }else{
+ rename(temp_fname[i].c_str(), fname[i].c_str());
+ }
+ }
+ }
+
+ fname_base = func.get_filename_base();
+ for(i=0;i<n_file_streams;++i){
+ if(n_file_streams > 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<host_tuple>& 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
+
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+#include "hash_table.h"
+
+#define _GB_FLUSH_PER_TUPLE_ 1
+
+using namespace std;
+
+template <class groupby_func, class group, class aggregate, class hasher_func, class equal_func>
+class groupby_operator : public base_operator {
+private :
+ groupby_func func;
+ hash_table<group*, aggregate*, hasher_func, equal_func> group_table[2];
+ bool flush_finished;
+ unsigned int curr_table;
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::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<host_tuple>& 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<group*, aggregate*, hasher_func, equal_func>::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<n_patterns;++p){
+ group* new_grp = new group(grp, func.get_pattern(p));
+ aggregate* aggr = new aggregate();
+ aggr = func.create_aggregate(tup, (char*)aggr);
+ group_table[curr_table].insert(new_grp, aggr);
+ }
+ }
+ }
+ tup.free_tuple();
+ return 0;
+ }
+
+ int partial_flush(list<host_tuple>& 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<host_tuple>& result) {
+ host_tuple tup;
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::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<host_tuple>& result) {
+ host_tuple tup;
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::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
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+#include <vector>
+#include "hash_table.h"
+#include <cassert>
+
+// 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_func, class group, class aggregate, class hasher_func, class equal_func, class temporal_type>
+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<hash_table<group*, aggregate*, hasher_func, equal_func>* > 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<group*, aggregate*, hasher_func, equal_func>::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<group*, aggregate*, hasher_func, equal_func>* 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<host_tuple>& 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<group*, aggregate*, hasher_func, equal_func>::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<group*, aggregate*, hasher_func, equal_func>()));
+//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<group*, aggregate*, hasher_func, equal_func>());
+//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<group*, aggregate*, hasher_func, equal_func>* pt;
+ for (temporal_type i = max_wid; i < curr_table; i++) {
+ pt =new hash_table<group*, aggregate*, hasher_func, equal_func>();
+ 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<group*, aggregate*, hasher_func, equal_func>* pt;
+ group_tables[index]->insert(new_grp, aggr);
+ }else{
+ int p;
+ for(p=0;p<n_patterns;++p){
+ group* new_grp = new group(grp, func.get_pattern(p));
+ aggregate* aggr = new aggregate();
+ aggr = func.create_aggregate(tup, (char*)aggr);
+ group_tables[index]->insert(new_grp, aggr);
+ }
+ }
+ }
+ tup.free_tuple();
+ return 0;
+ }
+
+ int partial_flush(list<host_tuple>& 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<group*, aggregate*, hasher_func, equal_func>* 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<host_tuple>& result) {
+ host_tuple tup;
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::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<group*, aggregate*, hasher_func, equal_func>* 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<host_tuple>& result) {
+ host_tuple tup;
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::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<group*, aggregate*, hasher_func, equal_func>* 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;i<group_tables.size();++i)
+ ret += group_tables[i]->get_mem_footprint() ;
+
+ return ret;
+ }
+};
+
+#endif // GROUPBY_OPERATOR_OOP_H
+
--- /dev/null
+/* ------------------------------------------------
+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 <stdlib.h>
+#include <stdio.h>
+
+
+
+#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 key_type, class value_type, class hasher_func, class equal_func>
+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;nb<n_buckets;nb*=2);
+ num_buckets = nb;
+ hash_mask = nb-1;
+ buckets = new hash_bucket[num_buckets];
+
+ _size = 0;
+ _max_size = 0;
+// max_load = 0.0;
+ first_bucket = 0;
+ last_bucket = 0;
+
+ total_memory = num_buckets * sizeof(hash_bucket);
+ }
+
+ int insert(const key_type& key, const value_type& val) {
+ data_item* d = new data_item(key, val);
+ total_memory += sizeof(data_item);
+
+ // 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) {
+ // create new data item
+
+ buckets[bucket_index].data = d;
+ if (!first_bucket){
+ first_bucket = &buckets[bucket_index];
+ }else{
+ last_bucket->next_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 key_type, class hasher_func, class equal_func>
+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;nb<n_buckets;nb*=2);
+ num_buckets = nb;
+ hash_mask = num_buckets-1;
+
+ buckets = new hash_bucket[num_buckets];
+
+ _size = 0;
+ _max_size = 0;
+// max_load = 0.0;
+ first_bucket = 0;
+ last_bucket = 0;
+ }
+
+ int insert(const key_type& key) {
+ data_item* d = new data_item(key);
+
+ // 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) {
+ // create new data item
+
+ buckets[bucket_index].data = d;
+ if (!first_bucket)
+ first_bucket = &buckets[bucket_index];
+ else
+ last_bucket->next_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
--- /dev/null
+/* ------------------------------------------------
+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 <vector>
+#include <map>
+#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 <lapp.h>
+#include <fta.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <schemaparser.h>
+}
+
+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<operator_node*> parent_list;
+ list<unsigned> 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<operator_node*> parent_list;
+ list<unsigned> 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<host_tuple> 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<param_block>& 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<host_tuple> 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_block> 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<host_tuple> res;
+ if (!oper->flush(res)) {
+
+ if (!res.empty()) {
+ // go through the list of returned tuples and finalyze them
+ list<host_tuple>::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_block> 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<host_tuple> 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<host_tuple>::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<operator_node*> sorted_nodes;
+ int num_operators;
+ list<lfta_info*> *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<host_tuple> 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<lfta_info*> *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<operator_node*, int> node_map;
+ vector<operator_node*> 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<int>* adj_lists = new list<int>[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<int>::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_block> param_list;
+ get_lfta_params(sz, value, param_list);
+ list<param_block>::iterator iter1;
+ list<lfta_info*>::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<lfta_info*>::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<host_tuple> res;
+
+ // go through the list of operators in topological order
+ // and flush them
+ list<host_tuple>::iterator iter;
+ list<host_tuple> temp_output_queue;
+
+ for (int i = 0; i < num_operators; ++i) {
+ operator_node* node = sorted_nodes[i];
+
+#ifdef PLAN_DAG
+ list<host_tuple>& 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<host_tuple>& 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<operator_node*>::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<host_tuple>::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<lfta_info*>::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<lfta_info*>::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_block> param_list;
+ get_lfta_params(sz, value, param_list);
+
+ // ask lftas to do the flush and set new parameters
+ list<lfta_info*>::iterator iter;
+ list<param_block>::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<lfta_info*>::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<host_tuple> result;
+ host_tuple tup;
+ int ret;
+ #ifndef PLAN_DAG
+ temp.channel = inf->output_channel;
+ #endif
+ operator_node* current_node = NULL, *child = NULL;
+ list<host_tuple> 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<host_tuple>::iterator iter2;
+
+#ifdef PLAN_DAG
+
+ // push tuple to all parent operators of the lfta
+ list<operator_node*>::iterator node_iter;
+ list<unsigned>::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<host_tuple>& 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<host_tuple>& 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
+
--- /dev/null
+/* ------------------------------------------------
+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->length<length)?str->length: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<len1) return 0;
+ for(x=0; x<len1; x++) {
+ if (st1[x]!=st2[x]) return 0;
+ }
+ return 1;
+}
+
+
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+ 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_SFUN_H_INCLUDED_
+#define _HFTA_SFUN_H_INCLUDED_
+
+#include "vstring.h"
+#include "host_tuple.h"
+
+////////////////////////////////////////////////////////////////
+/// Dummy state and functions, for testing
+////////////////////////////////////////////////////////////////////
+
+void _sfun_state_destroy_Foo(char(*)[20] );
+void _sfun_state_dirty_init_Foo(char(*)[20],char(*)[20], int);
+void _sfun_state_final_init_Foo(char(*)[20], int);
+void _sfun_state_clean_init_Foo(char(*)[20]);
+unsigned int Bar(char(*)[20], int, unsigned int);
+
+int packet_count(void *s, int curr_num_samples);
+double gamma(void *s, int curr_num_samples);
+int init_threshold(void *s, int curr_num_samples);
+int do_clean_count(void *s, int curr_num_samples);
+int delay(void *s, int curr_num_samples);
+int newly_closed(void *s, int curr_num_samples);
+
+////////////////////////////////////////////////////
+/// Adaptive smart sampling
+////////////////////////////////////////////////////////////////////
+void _sfun_state_clean_init_smart_sampling_state(void *s);
+void _sfun_state_dirty_init_smart_sampling_state(void *s_new, void *s_old, int curr_num_samples);
+void _sfun_state_final_init_smart_sampling_state(void *s, int curr_num_samples);
+void _sfun_state_destroy_smart_sampling_state(void *s){};
+
+int ssample(void *s,int curr_num_samples, unsigned long long int len, unsigned int sample_size);
+int ssample(void *s,int curr_num_samples, int len, unsigned int sample_size){
+ return ssample(s,curr_num_samples,(unsigned long long int)len,sample_size);
+}
+int ssample(void *s,int curr_num_samples, unsigned int len, unsigned int sample_size){
+ return ssample(s,curr_num_samples,(unsigned long long int)len,sample_size);
+}
+
+int ssfinal_clean(void *s, int curr_num_sample, unsigned long long int glens);
+int ssfinal_clean(void *s, int curr_num_samples, int glen){
+ return ssfinal_clean(s, curr_num_samples, (unsigned long long int)glen);
+}
+int ssfinal_clean(void *s, int curr_num_samples, unsigned int glen){
+ return ssfinal_clean(s, curr_num_samples, (unsigned long long int)glen);
+}
+
+int ssdo_clean(void *s, int curr_num_samples);
+
+int ssclean_with(void *s,int curr_num_sample, unsigned long long int glens);
+int ssclean_with(void *s,int curr_num_sample, unsigned int glens){
+ return ssclean_with(s, curr_num_sample, (unsigned long long int)glens);
+}
+int ssclean_with(void *s,int curr_num_sample, int glens){
+ return ssclean_with(s, curr_num_sample, (unsigned long long int)glens);
+}
+
+double ssthreshold(void *s, int curr_num_sample);
+int count_distinct(void *s, int curr_num_samples);
+int packet_count(void *s, int curr_num_samples);
+double gamma(void *s, int curr_num_samples);
+int init_threshold(void *s, int curr_num_samples);
+int do_clean_count(void *s, int curr_num_samples);
+int delay(void *s, int curr_num_samples);
+int newly_closed(void *s, int curr_num_samples);
+
+//flow sampling
+int flow_ssdo_clean(void *s, int curr_num_samples,unsigned int maxtime);
+
+int flow_ssample(void *s,int curr_num_samples, unsigned int sample_size);
+
+int flow_ssclean_with(void *s,int curr_num_sample, unsigned int ccondition, unsigned int delay, unsigned int maxtime, unsigned long long int glens);
+int flow_ssclean_with(void *s,int curr_num_sample, unsigned int ccondition, unsigned int delay, unsigned int maxtime, unsigned int glens){
+ return flow_ssclean_with(s, curr_num_sample, ccondition, delay, maxtime, (unsigned long long int)glens);
+}
+int flow_ssclean_with(void *s,int curr_num_sample, unsigned int ccondition, unsigned int delay, unsigned int maxtime, int glens){
+ return flow_ssclean_with(s, curr_num_sample, ccondition, delay, maxtime, (unsigned long long int)glens);
+}
+
+int flow_ssfinal_clean(void *s, int curr_num_sample, unsigned int ccondition, unsigned int delay, unsigned int maxtime, unsigned long long int glens);
+int flow_ssfinal_clean(void *s, int curr_num_samples,unsigned int ccondition, unsigned int delay, unsigned int maxtime, int glen){
+ return flow_ssfinal_clean(s, curr_num_samples, ccondition, delay, maxtime, (unsigned long long int)glen);
+}
+int flow_ssfinal_clean(void *s, int curr_num_samples,unsigned int ccondition, unsigned int delay, unsigned int maxtime, unsigned int glen){
+ return flow_ssfinal_clean(s, curr_num_samples, ccondition, delay, maxtime, (unsigned long long int)glen);
+}
+
+////////////////////////////////////////////////////////////////////
+/// Manku-Motwani Heavy Hitters
+////////////////////////////////////////////////////////////////////
+void _sfun_state_clean_init_manku_hh_state(void *s);
+void _sfun_state_dirty_init_manku_hh_state(void *s_new, void *s_old, int curr_num_samples);
+void _sfun_state_final_init_manku_hh_state(void *s, int curr_num_samples);
+void _sfun_state_destroy_manku_hh_state(void *s){};
+
+/////////////////////////////////////////////////////////////////////
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+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_UDAF_H_INCLUDED_
+#define _HFTA_UDAF_H_INCLUDED_
+
+#include "vstring.h"
+#include "host_tuple.h"
+#include "gsconfig.h"
+
+// -------------------------------------------------------------------
+// sum over 3 intervals : test rUDAF
+void sum3_HFTA_AGGR_INIT_(gs_sp_t buf) ;
+void sum3_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s) ;
+void sum3_HFTA_AGGR_OUTPUT_(gs_uint32_t *result, gs_sp_t buf) ;
+void sum3_HFTA_AGGR_DESTROY_(gs_sp_t buf) ;
+void sum3_HFTA_AGGR_REINIT_( gs_sp_t buf) ;
+
+
+// -------------------------------------------------------------------
+// running sum over arbitrary intervals.
+void moving_sum_udaf_HFTA_AGGR_INIT_(gs_sp_t buf) ;
+void moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s, gs_uint32_t N) ;
+void moving_sum_udaf_HFTA_AGGR_OUTPUT_(gs_uint64_t *result, gs_sp_t buf) ;
+void moving_sum_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf) ;
+void moving_sum_udaf_HFTA_AGGR_REINIT_( gs_sp_t buf) ;
+
+#define super_moving_sum_udaf_HFTA_AGGR_INIT_ moving_sum_udaf_HFTA_AGGR_INIT_
+void super_moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint64_t s) ;
+#define super_moving_sum_udaf_HFTA_AGGR_OUTPUT_ moving_sum_udaf_HFTA_AGGR_OUTPUT_
+#define super_moving_sum_udaf_HFTA_AGGR_DESTROY_ moving_sum_udaf_HFTA_AGGR_DESTROY_
+#define super_moving_sum_udaf_HFTA_AGGR_REINIT_ moving_sum_udaf_HFTA_AGGR_REINIT_
+
+gs_uint32_t moving_sum_extract(gs_uint64_t result);
+gs_float_t moving_sum_extract_exp(gs_uint64_t result, gs_float_t alpha);
+
+
+/////////////////////////////////////////////////////////////////////////
+///// Calculate the average of all positive float numbers
+
+void POSAVG_HFTA_AGGR_INIT_(gs_sp_t buf);
+void POSAVG_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_float_t v);
+void POSAVG_HFTA_AGGR_OUTPUT_(gs_float_t * v, gs_sp_t buf);
+void POSAVG_HFTA_AGGR_DESTROY_(gs_sp_t buf);
+
+
+///////////////////////////////////////////////////////////////////
+///// avg_udaf (simple example)
+
+// hfta avg_udaf
+void avg_udaf_HFTA_AGGR_INIT_(gs_sp_t b);
+void avg_udaf_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v);
+void avg_udaf_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
+void avg_udaf_HFTA_AGGR_DESTROY_(gs_sp_t b);
+
+// avg_udaf superaggregate
+void avg_udaf_hfta_HFTA_AGGR_INIT_(gs_sp_t b);
+void avg_udaf_hfta_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
+void avg_udaf_hfta_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
+void avg_udaf_hfta_HFTA_AGGR_DESTROY_(gs_sp_t b);
+
+// Extraction function
+gs_float_t extr_avg_fcn(vstring *v);
+
+// first aggregate
+void FIRST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
+void FIRST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
+void FIRST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
+void FIRST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
+void FIRST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
+
+void FIRST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
+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);
+void FIRST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
+void FIRST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
+
+void FIRST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
+void FIRST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
+void FIRST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
+void FIRST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* 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);
+void LAST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* 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);
+void LAST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
+void LAST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
+
+void LAST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
+void LAST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
+void LAST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
+void LAST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
+void LAST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
+
+// running_array_aggr aggregate
+void running_array_aggr_hfta_HFTA_AGGR_INIT_(vstring* scratch);
+void running_array_aggr_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
+void running_array_aggr_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
+void running_array_aggr_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
+void running_array_aggr_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
+
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+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 HOST_TUPLE_H
+#define HOST_TUPLE_H
+
+#include <stdlib.h>
+#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
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+#include"hash_table.h"
+using namespace std;
+
+#include <stdio.h>
+
+#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_functor, class timestamp, class hashkey, class hasher_func, class equal_func>
+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<host_tuple> 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<hashkey*, host_tuple, hasher_func, equal_func> 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<host_tuple>& 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<hashkey*, host_tuple, hasher_func, equal_func>::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<host_tuple>& result){
+ int i;
+ bool failed;
+ host_tuple empty_tuple;
+ empty_tuple.tuple_size = 0; empty_tuple.data = NULL;
+
+ hash_empty = true;
+ typename hash_table<hashkey*, host_tuple, hasher_func, equal_func>::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<host_tuple>& 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<host_tuple>& 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
+
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+using namespace std;
+
+#include <stdio.h>
+
+
+//int last_tb = 0;
+
+template <class merge_functor>
+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<host_tuple> 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<host_tuple>& 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<host_tuple>& 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<host_tuple>& result) {
+
+ if (merge_queue.empty())
+ return 0;
+
+ host_tuple top_tuple;
+ list<host_tuple>::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
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+using namespace std;
+
+#include <stdio.h>
+
+
+//int last_tb = 0;
+
+template <class merge_functor>
+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<host_tuple> 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<host_tuple>& 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<host_tuple>& 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<host_tuple>& result) {
+
+ if (merge_queue.empty())
+ return 0;
+
+ host_tuple top_tuple;
+ list<host_tuple>::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
+
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+#include "hash_table.h"
+
+#define _GB_FLUSH_PER_TUPLE_ 1
+
+using namespace std;
+
+template <class groupby_func, class group, class aggregate, class hasher_func, class equal_func>
+class running_agg_operator : public base_operator {
+private :
+ groupby_func func;
+ hash_table<group*, aggregate*, hasher_func, equal_func> group_table;
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::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<host_tuple>& 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<group*, aggregate*, hasher_func, equal_func>::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<host_tuple>& result) {
+ host_tuple tup;
+ typename hash_table<group*, aggregate*, hasher_func, equal_func>::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
--- /dev/null
+/* ------------------------------------------------
+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 <list>
+using namespace std;
+
+template <class select_project_functor> 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<host_tuple>& 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<host_tuple>& 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
--- /dev/null
+/* ------------------------------------------------
+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 <app.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+
+#include "gsconfig.h"
+#include "gstypes.h"
+#include <schemaparser.h>
+
+#include "host_tuple.h"
+#include "base_operator.h"
+#include <list>
+#include<string>
+#include<vector>
+#include "gsconfig.h"
+#include "gstypes.h"
+#include <schemaparser.h>
+
+#include <zlib.h>
+
+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_functor> class zfile_output_operator :
+ public base_operator
+{
+private :
+ file_output_functor func;
+
+ gzFile *output_file;
+ vector<string> xform_command;
+ vector<string> temp_fname;
+ vector<string> 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<n_file_streams;++i){
+ output_file[i] = NULL;
+ xform_command.push_back("");
+ temp_fname.push_back("");
+ fname.push_back("");
+ }
+ qname = name;
+ schema = sch;
+ sprintf(tmpstr,"GDAT\nVERSION:%u\nSCHEMALENGTH:%lu\n",get_schemaparser_version(),strlen(sch)+1);
+ file_header = tmpstr;
+
+total_written = 0;
+}
+
+
+
+virtual int accept_tuple(host_tuple& tup, list<host_tuple>& 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<n_file_streams;++i){
+ gzclose(output_file[i]);
+ output_file[i] = NULL;
+ rename(temp_fname[i].c_str(), fname[i].c_str());
+ }
+ }
+ if(func.propagate_tuple()){
+ tup.channel = output_channel;
+ result.push_back(tup);
+ }
+ return 0;
+ }
+
+ if(func.new_epoch()){
+ if(output_file[0] != 0){
+total_written = 0;
+ for(i=0;i<n_file_streams;++i){
+ gzclose(output_file[i]);
+ rename(temp_fname[i].c_str(), fname[i].c_str());
+ }
+ }
+
+ fname_base = func.get_filename_base();
+ for(i=0;i<n_file_streams;++i){
+ if(n_file_streams > 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<host_tuple>& 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
+
--- /dev/null
+/* ------------------------------------------------
+ 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 <fta.h>
+#include <systat.h>
+#include <fta_stat.h>
+
+#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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+#! /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=<I>;
+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");
--- /dev/null
+#! /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=<I>;
+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");
--- /dev/null
+/* ------------------------------------------------
+ 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 <string.h>
+
+/*
+ * macro adaptor
+ */
+#define mod(a,b) ((a) % (b))
+
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+#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 <stdint.h>
+
+#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->length<length)?str->length: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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+#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 <lfta/csv_macro.h>
+
+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 <lfta/csv2_macro.h>
+
+/* 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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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.numfields<pos) return -1;
+#ifdef GDATDEBUG
+ fprintf(stderr,".");
+#endif
+ ar=ftaschema_get_field_by_index(p->record.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 <lfta/gdat_macro.h>
+
+// External functions
+
+
+
+
+#endif
+
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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__
+
--- /dev/null
+/* ------------------------------------------------
+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<stdio.h>
+#include "byteswap.h"
+#include "type_indicators.h"
+#include "fta.h"
+#include <fta_stat.h>
+/* #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<sys/time.h>
+/*
+#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
+
--- /dev/null
+/* ------------------------------------------------
+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
--- /dev/null
+/* ------------------------------------------------
+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 <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
+#include <stdint.h>
+#include <string.h>
+
+//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<endrandom) r=Random64[nextrandom++];
+ else {
+ if (nextrandom==endrandom)
+ fprintf(stderr,"Switching from random to pseudo-random in Rand64");
+ r =(INT64) mrand48();
+ r1 = (INT64) mrand48();
+ r=r<<32;
+ r=r^r1;
+ }
+ return r;
+}
+
+
+/* Computes ax+b mod Prime, possibly plus Prime,
+ exploiting the structure of Prime. */
+inline static INT64 MultAddPrime(INT32 x, INT64 a, INT64 b) {
+ INT64 a0,a1,c0,c1,c;
+ a0 = LOW(a)*x;
+ a1 = HIGH(a)*x;
+ c0 = a0+(a1<<32);
+ c1 = (a0>>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<length;i+=2) {
+ xh1=x[i]+hid[i+1];
+ xh2=x[i+1]+hid[i];
+ y=xh1*xh2;
+ H = H^y;
+ }
+ H=H^hid[length];
+ h = H >> 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<length;i+=2) {
+ xh1=x[i]+hid[i+1];
+ xh2=x[i+1]+hid[i];
+ y=xh1*xh2;
+ H = H^y;
+ }
+ H=H^hid[length];
+ h = H >> 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<length;i++) H = H^(x[i]*hid[i]);
+// H=H^hid[length];
+// h = H >> 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;i<d;i++) hid->int_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 (i<d) {
+ xh1=hid->int_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;i<d;i++) hid->int_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
+
--- /dev/null
+/* ------------------------------------------------
+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
--- /dev/null
+/* ------------------------------------------------
+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
+
--- /dev/null
+/* ------------------------------------------------
+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
--- /dev/null
+// 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
--- /dev/null
+ex2_src,stream,,,,,
--- /dev/null
+# ------------------------------------------------
+# 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
--- /dev/null
+#!/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.
+
--- /dev/null
+/* ------------------------------------------------
+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<unistd.h>
+
+#include "parse_fta.h"
+#include "parse_schema.h"
+#include "parse_ext_fcns.h"
+
+
+#include"analyze_fta.h"
+
+#include"type_objects.h"
+
+#include <string>
+#include<list>
+
+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<scalarexp_t *> 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<int> find_source_tables(string field, tablevar_list_t *fm, table_list *Schema){
+ int i;
+ vector<int> tv;
+// vector<string> tn = fm->get_schema_names();
+ vector<int> tn = fm->get_schema_refs();
+// printf("Calling find_source_tables on field %s\n",field.c_str());
+ for(i=0;i<tn.size();i++){
+// if(Schema->contains_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;i<fm->size();++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<int> tv;
+ vector<tablevar_t *> 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;i<tv.size();i++){
+ fprintf(stderr,"%s ",fm_tbls[ tv[i] ]->to_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;i<fm_tbls.size();++i){
+ if(table_name == fm_tbls[i]->get_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;i<fm_tbls.size();++i){
+ if(table_name == fm_tbls[i]->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ reset_temporal(operands[o]);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in reset_temporal, line %d, character %d: unknown operator type %d\n",
+ se->get_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<string> tn;
+ vector<int> tv;
+ int table_var;
+ int o;
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ l_ret = verify_colref(operands[o], fm, schema, gtbl);
+ if(l_ret < 0) r_ret = -1;
+ }
+ return(r_ret);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in verify_colref, line %d, character %d: unknown operator type %d\n",
+ se->get_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<scalarexp_t *> 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;o<op_list.size();++o){
+ if(verify_colref(op_list[o],fm,schema,gtbl) < 0) l_ret = -1;
+ }
+ return(l_ret);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in verify_predicate_colref, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_lineno(), pr->get_charno(), pr->get_operator_type() );
+ }
+
+ return(-1);
+}
+
+
+bool literal_only_se(scalarexp_t *se){ // really only literals.
+ int o;
+ vector<scalarexp_t *> 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<string> tn;
+ vector<int> tv;
+ int tablevar_ref;
+ int o;
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ l_ret = bind_to_schema_se(operands[o], fm, schema);
+ if(l_ret < 0) r_ret = -1;
+ }
+ return(r_ret);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in bind_to_schema_se, line %d, character %d: unknown operator type %d\n",
+ se->get_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<scalarexp_t *> 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;o<op_list.size();++o){
+ if(bind_to_schema_se(op_list[o],fm,schema) < 0) l_ret = -1;
+ }
+ return(l_ret);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in bind_to_schema_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<col_id, temporal_type> &tcol){
+ int l_ret, r_ret;
+ data_type *dt;
+ bool bret;
+ vector<scalarexp_t *> operands;
+ vector<data_type *> odt;
+ int o, fcn_id;
+ vector<bool> 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<scalarexp_t *> operands;
+ vector<data_type *> odt;
+ int o, fcn_id;
+ vector<bool> handle_ind;
+ vector<bool> 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;o<operands.size();o++){
+ l_ret = assign_data_types(operands[o], schema, fta_tree, Ext_fcns);
+ odt.push_back(operands[o]->get_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<scalarexp_t *> op_a;
+ int n_aggr_oprs = operands.size()-n_fcn_params+1;
+ for(o=0;o<n_aggr_oprs;++o){
+ op_a.push_back(operands[o]);
+ }
+// check handle params
+ vector<bool> handle_a = Ext_fcns->get_handle_indicators(subaggr_id);
+ for(o=0;o<op_a.size();o++){
+ if(handle_a[o]){
+ if(op_a[o]->get_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<bool> is_const_a=Ext_fcns->get_const_indicators(subaggr_id);
+ for(o=0;o<op_a.size();o++){
+ if(is_const_a[o]){
+ if(op_a[o]->get_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<scalarexp_t *> op_f;
+ op_f.push_back(se_a);
+ for(o=n_aggr_oprs;o<operands.size();++o)
+ op_f.push_back(operands[o]);
+// check handle params
+ vector<bool> handle_f = Ext_fcns->get_handle_indicators(actual_fcn_id);
+ for(o=0;o<op_f.size();o++){
+ if(handle_f[o]){
+ if(op_f[o]->get_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<bool> is_const_f=Ext_fcns->get_const_indicators(actual_fcn_id);
+ for(o=0;o<op_f.size();o++){
+ if(is_const_f[o]){
+ if(op_f[o]->get_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;o<operands.size();o++){
+ if(handle_ind[o]){
+ if(operands[o]->get_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;o<operands.size();o++){
+ if(constant_ind[o]){
+ if(operands[o]->get_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;o<operands.size();o++){
+ if(handle_ind[o]){
+ if(operands[o]->get_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;o<operands.size();o++){
+ if(constant_ind[o]){
+ if(operands[o]->get_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;o<operands.size();o++){
+ if(o>0) 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;o<operands.size();o++){
+ if(o>0) 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;o<operands.size();o++){
+ if(handle_ind[o]){
+ if(operands[o]->get_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;o<operands.size();o++){
+ if(constant_ind[o]){
+ if(operands[o]->get_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<data_type *> odt;
+ vector<literal_t *> litl;
+ vector<scalarexp_t *> operands;
+ vector<bool> handle_ind;
+ vector<bool> 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;i<litl.size();i++){
+ dtl = new data_type( litl[i]->get_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;o<operands.size();o++){
+ l_ret = assign_data_types(operands[o], schema, fta_tree, Ext_fcns); // , ext_fcn_set);
+ odt.push_back(operands[o]->get_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;o<operands.size();o++){
+ if(o>0) 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;o<operands.size();o++){
+ if(handle_ind[o]){
+ if(operands[o]->get_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;o<operands.size();o++){
+ if(constant_ind[o]){
+ if(operands[o]->get_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<scalarexp_t *> operand_list;
+ vector<data_type *> 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<scalarexp_t *> new_operands;
+ for(p=0;p<operand_list.size();p++){
+ l_se = dup_se(operand_list[p], aggr_tbl);
+ new_operands.push_back(l_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 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<literal_t *> llist;
+ scalarexp_t *se_l, *se_r;
+ predicate_t *pr_l, *pr_r, *ret_pr;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ se_l = dup_se(op_list[o], aggr_tbl);
+ new_op_list.push_back(se_l);
+ }
+ ret_pr= new predicate_t(pr->get_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;i<te->query_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_element *> select_list = te->sl->get_select_list();
+ for(i=0;i<select_list.size();++i){
+ scalarexp_t *se = dup_se(select_list[i]->se,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;i<te->gb.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<tablevar_t *> &fm,
+ int prev_ref, int new_ref
+ ){
+ int p;
+ vector<scalarexp_t *> 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;p<operand_list.size();p++){
+ bind_colref_se(operand_list[p], fm, prev_ref, new_ref);
+ }
+ return;
+
+ default:
+ printf("INTERNAL ERROR in bind_colref_se: operator type %d\n",se->get_operator_type());
+ exit(1);
+ break;
+ }
+ return;
+
+}
+
+
+
+
+void bind_colref_pr(predicate_t *pr,
+ vector<tablevar_t *> &fm,
+ int prev_ref, int new_ref
+ ){
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ bind_colref_se(op_list[o], fm, prev_ref, new_ref);
+ }
+ return;
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in bind_colref_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 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<scalarexp_t *> 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<scalarexp_t *> 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;o<operands.size();o++){
+ sum += count_gb_se(operands[o]);
+ }
+ return(sum);
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in count_gb_se, 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 stateful fcns.
+/////////////////////////////////////////////////////////////////////
+
+
+int se_refs_sfun(scalarexp_t *se){
+ int o;
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ sum += se_refs_sfun(operands[o]);
+ }
+ if(se->get_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<scalarexp_t *> 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;o<op_list.size();++o){
+ aggr_sum += se_refs_sfun(op_list[o]);
+ }
+ return(aggr_sum);
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in pred_refs_sfun, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ sum += count_aggr_se(operands[o], strict);
+ }
+ if(se->get_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<scalarexp_t *> 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;o<op_list.size();++o){
+ aggr_sum += count_aggr_se(op_list[o], strict);
+ }
+ return(aggr_sum);
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in count_aggr_pred, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_lineno(), pr->get_charno(), pr->get_operator_type() );
+ exit(1);
+ }
+
+ return(0);
+}
+
+//////////////////////////////////////////////////
+/// Analyze tablevar refs
+
+void get_tablevar_ref_se(scalarexp_t *se, vector<int> &reflist){
+ int o;
+ vector<scalarexp_t *> 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;o<reflist.size();++o){
+ if(vref == reflist[o]) return;
+ }
+ reflist.push_back(vref);
+ return;
+ case SE_UNARY_OP:
+ get_tablevar_ref_se(se->get_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;o<reflist.size();++o){
+ if(vref == reflist[o]) return;
+ }
+ reflist.push_back(vref);
+ return;
+ case SE_AGGR_STAR:
+ case SE_AGGR_SE:
+ return;
+ case SE_FUNC:
+ if(se->get_aggr_ref() >= 0) return;
+
+ operands = se->get_operands();
+ for(o=0;o<operands.size();o++){
+ get_tablevar_ref_se(operands[o], reflist);
+ }
+ return;
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in get_tablevar_ref_se, line %d, character %d: unknown operator type %d\n",
+ se->get_lineno(), se->get_charno(),se->get_operator_type());
+ exit(1);
+ }
+ return;
+}
+
+
+void get_tablevar_ref_pr(predicate_t *pr, vector<int> &reflist){
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ get_tablevar_ref_se(op_list[o],reflist);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in get_tablevar_ref_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<string> &states_refd, ext_fcn_list *Ext_fcns){
+ int agg_id;
+ int o;
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ gather_fcn_states_se(operands[o], states_refd, Ext_fcns);
+ }
+ if(se->get_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<string> &states_refd, ext_fcn_list *Ext_fcns){
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ gather_fcn_states_se(op_list[o],states_refd, Ext_fcns);
+ }
+ return;
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in gather_fcn_states_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ build_aggr_tbl_fm_se(operands[o], aggregate_table, Ext_fcns);
+ }
+ if(se->get_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<scalarexp_t *> 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;o<op_list.size();++o){
+ build_aggr_tbl_fm_se(op_list[o],aggregate_table, Ext_fcns);
+ }
+ return;
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in build_aggr_tbl_fm_pred, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> operands1;
+ vector<scalarexp_t *> 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;o<operands1.size();o++){
+ if(! is_equivalent_se(operands1[o], operands2[o]) )
+ return(false);
+ }
+ return(true);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in is_equivalent_se, line %d, character %d: unknown operator type %d\n",
+ se1->get_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<scalarexp_t *> operands1;
+ vector<scalarexp_t *> 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;o<operands1.size();o++){
+ if(! is_equivalent_se_base(operands1[o], operands2[o], Schema) )
+ return(false);
+ }
+ return(true);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in is_equivalent_se, line %d, character %d: unknown operator type %d\n",
+ se1->get_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<literal_t *> ll1;
+ vector<literal_t *> ll2;
+ vector<scalarexp_t *> 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;i<ll1.size();i++){
+ if(! ll1[i]->is_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;o<op_list1.size();++o){
+ if(! is_equivalent_se_base(op_list1[o],op_list2[o], Schema) ) return(false);
+ }
+ return(true);
+
+ }
+
+ return(false);
+}
+
+
+
+bool is_equivalent_class_pred_base(predicate_t *p1, predicate_t *p2, table_list *Schema,ext_fcn_list *Ext_fcns){
+ if((p1->get_operator_type()!=PRED_FUNC)||(p2->get_operator_type()!=PRED_FUNC))
+ return(false);
+ if(p1->get_fcn_id() != p2->get_fcn_id())
+ return false;
+ vector<bool> cl_op = Ext_fcns->get_class_indicators(p1->get_fcn_id());
+ int o;
+ vector<scalarexp_t *> op_list1 = p1->get_op_list();
+ vector<scalarexp_t *> op_list2 = p2->get_op_list();
+ if(op_list1.size() != op_list2.size()) return(false);
+ for(o=0;o<op_list1.size();++o){
+ if(cl_op[o]){
+ if(! is_equivalent_se_base(op_list1[o],op_list2[o], Schema) )
+ return(false);
+ }
+ }
+ return true;
+
+}
+
+
+
+
+// Verify that the scalar expression (in a such that clause)
+// is acceptable in an aggregation query. No column
+// references allowed outside aggergates, except for
+// references to group-by attributes.
+// return true if OK, false if bad.
+bool verify_aggr_query_se(scalarexp_t *se){
+ vector <scalarexp_t *> 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;o<operands.size();o++){
+ if(! verify_aggr_query_se(operands[o]) )
+ return(false);
+ }
+ return(true);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in verify_aggr_query_se, line %d, character %d: unknown operator type %d\n",
+ se->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ find_complex_literal_se(operands[o], Ext_fcns, complex_literals);
+ }
+ return(true);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in find_complex_literal_se, line %d, character %d: unknown operator type %d\n",
+ se->get_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<literal_t *> litl;
+ vector<scalarexp_t *> 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;i<litl.size();i++){
+ if(litl[i]->constructor_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;o<op_list.size();++o){
+ find_complex_literal_se(op_list[o],Ext_fcns, complex_literals);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in find_complex_literal_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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_param_tbl_entry *> &handle_tbl){
+ vector<scalarexp_t *> operands;
+ vector<bool> 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;o<operands.size();o++){
+ if(handle_ind[o]){
+ handle_param_tbl_entry *he;
+ param_se = operands[o];
+ if(param_se->get_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_param_tbl_entry *> &handle_tbl){
+ vector<literal_t *> litl;
+ vector<scalarexp_t *> op_list;
+ scalarexp_t *param_se;
+ vector<bool> 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;o<op_list.size();++o){
+ if(handle_ind[o]){
+ handle_param_tbl_entry *he;
+ param_se = op_list[o];
+ if(param_se->get_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<scalarexp_t *> operands;
+ vector<data_type *> 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;o<operands.size();o++){
+ l_ret = verify_having_se(operands[o], clause, Ext_fcns);
+ if(l_ret < 0) r_ret = -1;
+ }
+ if(r_ret < 0) return(-1); else return(1);
+ return(1);
+ default:
+ fprintf(stderr,"INTERNAL ERROR in verify_having_se, line %d, character %d: unknown operator type %d\n",
+ se->get_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<literal_t *> litl;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ if( verify_having_se(op_list[o], clause, Ext_fcns) < 0) l_ret = -1;
+ }
+ return(l_ret);
+
+ default:
+ fprintf(stderr,"INTERNAL ERROR in verify_having_pred, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<cnf_elem *> &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<scalarexp_t *> 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<operand_list.size();p++){
+ analyze_cnf_se(operand_list[p],s,g,a,agr);
+ }
+ break;
+ }
+
+ return;
+}
+
+
+
+void analyze_cnf_pr(predicate_t *pr, int &g, int &a, int &agr){
+int dum_simple, o;
+vector<scalarexp_t *> 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;o<op_list.size();++o){
+ analyze_cnf_se(op_list[o],dum_simple,g,a,agr);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in analyze_cnf_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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<operand_list.size();p++){
+ analyze_constraint_se(operand_list[p],l_agr,l_gb,l_par,l_func,l_op,Ext_fcns,enter_gb);
+ n_agr+=l_agr;
+ n_gb+=l_gb;
+ n_par+=l_par;
+ n_func+=l_func;
+ n_op += l_op;
+ }
+ break;
+ }
+
+ return;
+}
+
+// Estimate the cost of a constraint.
+// WARNING a lot of cost assumptions are embedded in the code.
+void analyze_constraint_pr(predicate_t *pr,
+ int &n_agr, int &n_gb, int &n_par, int &n_func, int &n_op,
+ int &n_cmp_s, int &n_cmp_c, int &n_in, int &n_pred, int &n_bool, ext_fcn_list *Ext_fcns, bool enter_gb){
+ int l_agr, l_gb, l_par, l_func, l_op, l_cmp_s, l_cmp_c, l_in, l_pred,l_bool;
+ int r_agr, r_gb, r_par, r_func, r_op, r_cmp_s, r_cmp_c, r_in, r_pred,r_bool;
+
+int o;
+vector<scalarexp_t *> 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;o<op_list.size();++o){
+ analyze_constraint_se(op_list[o],l_agr,l_gb,l_par,l_func,l_op,Ext_fcns,enter_gb);
+ n_agr+=l_agr; n_gb+=l_gb; n_par+=l_par; n_func+=l_func; n_op+=l_op;
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in analyze_cnf_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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<operand_list.size();p++){
+ insert_gb_def_se(operand_list[p],gtbl);
+ }
+ break;
+ }
+
+ return;
+}
+void insert_gb_def_pr(predicate_t *pr, gb_table *gtbl){
+vector<scalarexp_t *> 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;o<op_list.size();++o){
+ insert_gb_def_se(op_list[o],gtbl);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in insert_gb_def_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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;p<operand_list.size();p++){
+ lse=operand_list[p];
+ if(lse->get_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<operand_list.size();p++){
+ subs_gbrefs_se(operand_list[p],Schema);
+ }
+ break;
+ }
+
+ return;
+}
+
+void subs_gbrefs_pr(predicate_t *pr, table_list *Schema){
+vector<scalarexp_t *> 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;o<op_list.size();++o){
+ lse=op_list[o];
+ if(lse->get_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<scalarexp_t *> 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<operand_list.size();p++){
+ cnt += expensive_refs_se(operand_list[p],Schema);
+ }
+ return cnt;
+ break;
+ }
+
+ return 0;
+}
+
+int expensive_refs_pr(predicate_t *pr, table_list *Schema){
+vector<scalarexp_t *> 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;o<op_list.size();++o){
+ cnt += expensive_refs_se(op_list[o],Schema);
+ }
+ return cnt;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in expensive_refs_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_lineno(), pr->get_charno(), pr->get_operator_type() );
+ exit(1);
+ }
+}
+
+
+// TODO: allow "cheap" functions and predicates.
+bool simple_field_constraint(cnf_elem *c){
+ vector<literal_t *> 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<scalarexp_t *> 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;p<operand_list.size();p++){
+ ret=get_constrained_colref(operand_list[p]);
+ if(ret != NULL) return(ret);
+
+ }
+ return(NULL);
+ break;
+ }
+
+ return(NULL);
+}
+
+
+colref_t *get_constrained_colref(predicate_t *p){
+ return(get_constrained_colref(p->get_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<int> lftas;
+ predicate_t *pr;
+ vector<predicate_t *> predecessor_preds;
+ vector<common_pred_node *> 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;n<pn->children.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<cnf_elem *> > &where_list, table_list *Schema, ext_fcn_list *Ext_fcns, vector<cnf_set *> &prefilter_preds, set<unsigned int > &pred_ids){
+ int p, p2, l, c;
+
+ vector<cnf_set *> pred_list, sort_list;
+
+// Create list of tagged, prefilter-safe CNFs.
+ for(l=0;l<where_list.size();++l){
+ for(c=0;c<where_list[l].size();++c){
+ if(prefilter_compatible(where_list[l][c],Ext_fcns)){
+ if(expensive_refs_pr(where_list[l][c]->pr,Schema)==0)
+ pred_list.push_back(new cnf_set(where_list[l][c]->pr,l,c));
+ }
+ }
+ }
+
+// Eliminate duplicates
+ for(p=0;p<pred_list.size();++p){
+ if(pred_list[p]){
+ for(p2=p+1;p2<pred_list.size();++p2){
+ if(pred_list[p2]){
+ if(is_equivalent_pred_base(pred_list[p]->pr, 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;p<pred_list.size();++p){
+ if(pred_list[p]){
+ for(p2=p+1;p2<pred_list.size();++p2){
+ if(pred_list[p2]){
+ if(pred_list[p]->lfta_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;p<pred_list.size();++p){
+ if(pred_list[p]){
+ sort_list.push_back(pred_list[p]);
+ }
+ }
+// Sort it
+ sort(sort_list.begin(), sort_list.end(),compare_cnf_set());
+
+// Return the top preds, up to 64 of them.
+ for(p=0;p<sort_list.size() && p<64;p++){
+ prefilter_preds.push_back(sort_list[p]);
+ sort_list[p]->add_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;p<prefilter_preds.size() ;p++){
+ subs_gbrefs_pr(prefilter_preds[p]->pr,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<scalarexp_t *> *pf_list,
+ vector<int> *fcn_ref_cnt, vector<bool> *is_partial_fcn,
+ ext_fcn_list *Ext_fcns){
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ find_partial_fcns(operands[o], pf_list, fcn_ref_cnt, is_partial_fcn, Ext_fcns);
+ }
+
+ if(Ext_fcns->is_partial(se->get_fcn_id()) || Ext_fcns->get_fcn_cost(se->get_fcn_id()) >= COST_HIGH){
+ if(fcn_ref_cnt){
+ for(f=0;f<pf_list->size();++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<scalarexp_t *> *pf_list,
+ vector<int> *fcn_ref_cnt, vector<bool> *is_partial_fcn,
+ ext_fcn_list *Ext_fcns){
+ vector<literal_t *> litl;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ find_partial_fcns(op_list[o],pf_list,fcn_ref_cnt, is_partial_fcn, Ext_fcns);
+ }
+ 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;
+}
+
+
+
+void find_combinable_preds(predicate_t *pr, vector<predicate_t *> *pr_list,
+ table_list *Schema, ext_fcn_list *Ext_fcns){
+ vector<literal_t *> litl;
+ vector<scalarexp_t *> 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;f<pr_list->size();++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<int> &agg_refs){
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ collect_agg_refs(operands[o], agg_refs);
+ }
+
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in collect_agg_refs, line %d, character %d: unknown operator type %d\n",
+ se->get_lineno(), se->get_charno(),se->get_operator_type());
+ exit(1);
+ }
+ return;
+}
+
+
+void collect_aggr_refs_pr(predicate_t *pr, set<int> &agg_refs){
+ vector<literal_t *> litl;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ collect_agg_refs(op_list[o],agg_refs);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in collect_aggr_refs_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 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<int> &pfcn_refs){
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ collect_partial_fcns(operands[o], pfcn_refs);
+ }
+
+ if(se->is_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<int> &pfcn_refs){
+ vector<literal_t *> litl;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ collect_partial_fcns(op_list[o],pfcn_refs);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in collect_partial_fcns_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<string> &ifpnames){
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ ret += count_se_ifp_refs(operands[o], ifpnames);
+ }
+
+ return ret;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in count_se_ifp_refs, line %d, character %d: unknown operator type %d\n",
+ se->get_lineno(), se->get_charno(),se->get_operator_type());
+ exit(1);
+ }
+ return 0;
+}
+
+
+int count_pr_ifp_refs(predicate_t *pr, set<string> &ifpnames){
+ vector<literal_t *> litl;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ ret += count_se_ifp_refs(op_list[o],ifpnames);
+ }
+ return ret;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in count_pr_ifp_refs, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> operands;
+ vector<string> 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;o<operands.size();o++){
+ ret += resolve_se_ifp_refs(operands[o], ifm, ifn, ifdb,err);
+ }
+
+ return ret;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in resolve_se_ifp_refs, line %d, character %d: unknown operator type %d\n",
+ se->get_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<literal_t *> litl;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ ret += resolve_se_ifp_refs(op_list[o],ifm, ifn, ifdb, err);
+ }
+ return ret;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in resolve_pr_ifp_refs, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<string, string> nmap = fta_tree->get_name_map();
+ map<string, string>::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<tablevar_t *> tbl_vec = tlist->get_table_list();
+
+ bool found_error = false;
+ for(i=0;i<tbl_vec.size();i++){
+ int sch_no = schema->find_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<string> tblvar_names;
+ for(i=0;i<tbl_vec.size();i++){
+ if(tbl_vec[i]->get_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;i<tbl_vec.size();i++){
+ if(tbl_vec[i]->get_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;i<tbl_vec.size();i++) tbl_vec[i]->set_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<var_pair_t *> query_params = fta_tree->query_params;
+ int p;
+ for(p=0;p<query_params.size();++p){
+ string pname = query_params[p]->name;
+ 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<field_entry *> fev0 = schema->get_fields(
+ tbl_vec[0]->get_schema_name()
+ );
+
+
+ int cv;
+ for(cv=1;cv<tbl_vec.size();++cv){
+ vector<field_entry *> 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;f<fev0.size();++f){
+ data_type dt0(fev0[f]->get_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;f<fev0.size();++f){
+ data_type dt0(fev0[f]->get_type(),fev0[f]->get_modifier_list());
+ if(dt0.is_temporal()){
+ mergevar_pos = f;
+ break;
+ }
+ }
+ if(mergevar_pos >= 0){
+ for(cv=0;cv<tbl_vec.size();++cv){
+ vector<field_entry *> 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<int> refd_sources;
+ vector<colref_t *> tmp_crl(qs->mvars.size(),NULL);
+ for(cv=0;cv<qs->mvars.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;cv<qs->mvars.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;cv<qs->mvars.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<extended_gb_t *> gb_list = fta_tree->get_groupby();
+ int n_temporal = 0;
+ string temporal_gbvars = "";
+ map<string, int> gset_gbnames;
+
+// For generating the set of GB patterns for this aggregation query.
+ vector<bool> inner_pattern;
+ vector<vector<bool> > pattern_set;
+ vector<vector<vector<bool> > > pattern_components;
+
+ vector<gb_t *> r_gbs, c_gbs, g_gbs;
+ int n_patterns;
+
+ for(i=0;i<gb_list.size();i++){
+ switch(gb_list[i]->type){
+ 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;j<r_gbs.size();++j){
+ retval = gb_tbl->add_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;k<r_gbs.size();++k){
+ if(k < j)
+ inner_pattern[k] = true;
+ else
+ inner_pattern[k] = false;
+ }
+ pattern_set.push_back(inner_pattern);
+ }
+ pattern_components.push_back(pattern_set);
+
+ gb_tbl->gb_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;j<c_gbs.size();++j){
+ retval = gb_tbl->add_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;j<n_patterns;++j){
+ int test_bit = 1;
+ for(k=0;k<c_gbs.size();++k,test_bit = test_bit << 1){
+ if((j & test_bit) != 0)
+ inner_pattern[k] = true;
+ else
+ inner_pattern[k] = false;
+ }
+ pattern_set.push_back(inner_pattern);
+ }
+ pattern_components.push_back(pattern_set);
+
+ gb_tbl->gb_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;j<gb_list[i]->gb_lists.size();++j){
+ g_gbs = gb_list[i]->gb_lists[j]->get_gb_list();
+ for(k=0;k<g_gbs.size();++k){
+ if(g_gbs[k]->type != 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<unsigned long long int> signatures;
+ for(j=0;j<gb_list[i]->gb_lists.size();++j){
+ g_gbs = gb_list[i]->gb_lists[j]->get_gb_list();
+ set<string> refd_gbs;
+ for(k=0;k<g_gbs.size();++k){
+ refd_gbs.insert(g_gbs[k]->name);
+ }
+ fill(inner_pattern.begin(),inner_pattern.end(),false);
+ unsigned long long int signature = 0;
+ set<string>::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<string>::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<vector<bool> > gb_patterns;
+ int n_components = pattern_components.size();
+ vector<int> pattern_pos(n_components,0);
+ bool done = false;
+ while(! done){
+ vector<bool> pattern;
+ for(j=0;j<n_components;j++){
+ pattern.insert(pattern.end(),pattern_components[j][pattern_pos[j]].begin(),
+ pattern_components[j][pattern_pos[j]].end());
+ }
+ gb_patterns.push_back(pattern);
+ for(j=0;j<n_components;j++){
+ pattern_pos[j]++;
+ if(pattern_pos[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<colref_t *> sgb = fta_tree->get_supergb();
+ for(i=0;i<sgb.size();++i){
+ int gbr = gb_tbl->find_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<select_element *> sl_list = fta_tree->get_sl_vec();
+ for(i=0;i<sl_list.size();i++){
+ retval = verify_colref(sl_list[i]->se, 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;i<sl_list.size();i++){
+ retval = assign_data_types(sl_list[i]->se, 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<string> curr_names;
+ int s;
+ for(s=0;s<sl_list.size();++s){
+ curr_names.insert(sl_list[s]->name);
+ }
+ for(s=0;s<sl_list.size();++s){
+ if(sl_list[s]->name == "")
+ 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;i<sl_list.size();i++)
+ build_aggr_tbl_fm_se(sl_list[i]->se, 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;i<sl_list.size();i++)
+ gather_fcn_states_se(sl_list[i]->se, 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;i<gb_tbl->size();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; a<aggr_tbl->size(); ++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;i<sl_list.size();i++){
+ bool ret_bool = verify_aggr_query_se(sl_list[i]->se);
+ st_ok = st_ok && ret_bool;
+ }
+ if(! st_ok)
+ return(NULL);
+
+ for(i=0;i<aggr_tbl->size();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<scalarexp_t *> opl = aggr_tbl->get_operand_list(i);
+ int o;
+ for(o=0;o<opl.size();++o){
+ if(count_aggr_se(opl[o], true) > 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;i<qs->wh_cnf.size();i++)
+ analyze_cnf(qs->wh_cnf[i]);
+ for(i=0;i<qs->hav_cnf.size();i++)
+ analyze_cnf(qs->hav_cnf[i]);
+ for(i=0;i<qs->cb_cnf.size();i++)
+ analyze_cnf(qs->cb_cnf[i]);
+ for(i=0;i<qs->cw_cnf.size();i++)
+ analyze_cnf(qs->cw_cnf[i]);
+ for(i=0;i<qs->closew_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;o<se->param_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<scalarexp_t *> 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;o<pr->param_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<int> &gref_set){
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ found = found || contains_gb_se(operands[o], gref_set);
+ }
+ return found;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in contains_gb_se, line %d, character %d: unknown operator type %d\n",
+ se->get_lineno(), se->get_charno(),se->get_operator_type());
+ exit(1);
+ }
+ return false;
+}
+
+
+bool contains_gb_pr(predicate_t *pr, set<int> &gref_set){
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ found = found ||contains_gb_se(op_list[o],gref_set) ;
+ }
+ return found;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in contains_gb_pr, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ gather_se_col_ids(operands[o], cid_set,gtbl);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in gather_se_col_ids, line %d, character %d: unknown operator type %d\n",
+ se->get_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<scalarexp_t *> 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;o<op_list.size();++o){
+ gather_se_col_ids(op_list[o],cid_set,gtbl) ;
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in gather_pr_col_ids, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<string> &fcn_set){
+ col_id ci;
+ data_type *ldt, *rdt;
+ int o;
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ gather_se_opcmp_fcns(operands[o], fcn_set);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in gather_se_opcmp_fcns, line %d, character %d: unknown operator type %d\n",
+ se->get_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<string> &fcn_set){
+ data_type *ldt, *rdt;
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ gather_se_opcmp_fcns(operands[o], fcn_set);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in verify_predicate_colref, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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<select_element *> &sel_list, scalarexp_t *se){
+ set<string> curr_names;
+ int s;
+ for(s=0;s<sel_list.size();++s){
+ curr_names.insert(sel_list[s]->name);
+ }
+ return impute_colname(curr_names, se);
+}
+
+string impute_colname(set<string> &curr_names, scalarexp_t *se){
+string ret;
+scalarexp_t *seo;
+vector<scalarexp_t *> 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;i<gtbl.size();++i){
+ if(entry->name.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<int> candidates;
+
+ if(cr->uses_default_table()){
+ for(i=0;i<gtbl.size();i++){
+ if(gtbl[i]->ref_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;i<gtbl.size();i++){
+ if(gtbl[i]->ref_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<tablevar_t *> 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;i<fm_tbls.size();++i){
+ if(table_name == fm_tbls[i]->get_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;i<gtbl.size();i++){
+ if(gtbl[i]->ref_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;i<fm_tbls.size();++i){
+ if(table_name == fm_tbls[i]->get_var_name() && interface == fm_tbls[i]->get_interface())
+ candidates.push_back(i);
+ }
+ if(candidates.size() != 1) return(-1);
+ for(i=0;i<gtbl.size();i++){
+ if(gtbl[i]->ref_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<string> aggr_table_entry::get_subaggr_fcns(vector<bool> &use_se){
+ vector<string> 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<data_type *> aggr_table_entry::get_subaggr_dt(){
+ vector<data_type *> 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<scalarexp_t *> 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;i<agr_tbl.size();i++){
+ if(agr_tbl[i]->is_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<scalarexp_t *> opl, data_type *sdt, bool is_super, bool is_running, bool has_lfta_bailout){
+ int i,o;
+
+ for(i=0;i<agr_tbl.size();i++){
+ if((! agr_tbl[i]->is_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;o<opl.size();++o){
+ if(! is_equivalent_se(opl[o],agr_tbl[i]->oplist[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;i<cplx_lit_tbl.size();i++){
+ if(l->is_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;
+}
--- /dev/null
+/* ------------------------------------------------
+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<set>
+#include<algorithm>
+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<gb_table_entry *> gtbl;
+
+public:
+ std::vector<vector<bool> > 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<std::string> gb_entry_type;
+ std::vector<int> gb_entry_count;
+ std::vector<std::vector<std::vector<bool> > > 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<scalarexp_t *> 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<scalarexp_t *> 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<std::string> get_subaggr_fcns(std::vector<bool> &use_se);
+ std::vector<data_type *> get_subaggr_dt();
+ scalarexp_t *make_superaggr_se(std::vector<scalarexp_t *> se_refs);
+ data_type *get_storage_type(){return sdt;};
+ std::vector<scalarexp_t *> 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<aggr_table_entry *> 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<scalarexp_t *> 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<scalarexp_t *> get_operand_list(int i){
+ return agr_tbl[i]->get_operand_list();
+ }
+
+ std::vector<std::string> get_subaggr_fcns(int i, std::vector<bool> &use_se){
+ return(agr_tbl[i]->get_subaggr_fcns(use_se) );
+ };
+
+ std::vector<data_type *> 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<scalarexp_t *> se_refs){
+ return(agr_tbl[i]->make_superaggr_se(se_refs) );
+ };
+};
+
+
+class cplx_lit_table{
+ std::vector<literal_t *> cplx_lit_tbl;
+ std::vector<bool> 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<std::string> pname;
+ std::vector<data_type *> pdtype;
+ std::vector<bool> phandle;
+
+ int find_name(std::string n){
+ int p;
+ for(p=0;p<pname.size();++p){
+ if(pname[p] == n) break;
+ }
+ if(p == pname.size()) return(-1);
+ return(p);
+ };
+
+public:
+ param_table(){};
+
+// Add the param with the given name and associated
+// data type and handle use.
+// if its a new name, return true.
+// Else, take OR of use_handle, return false.
+// (builds param table and collects handle references).
+ bool add_param(std::string pnm, data_type *pdt, bool use_handle){
+ int p = find_name(pnm);
+ if(p == -1){
+ pname.push_back(pnm);
+ pdtype.push_back(pdt);
+ phandle.push_back(use_handle);
+ return(true);
+ }else{
+ if(use_handle) phandle[p] = use_handle;
+ return(false);
+ }
+
+ };
+
+ int size(){return pname.size(); };
+
+ std::vector<std::string> 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, lt_col_id> col_id_set;
+
+bool contains_gb_pr(predicate_t *pr, std::set<int> &gref_set);
+bool contains_gb_se(scalarexp_t *se, std::set<int> &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<std::string> &fcn_set);
+void gather_pr_opcmp_fcns(predicate_t *pr, std::set<std::string> &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<std::string> subq_names;
+
+ opview_entry(){mangler="";};
+};
+
+class opview_set{
+public:
+ std::vector<opview_entry *> 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<int> sg_tbl; // Names of the superGB attributes
+ aggregate_table *aggr_tbl; // Table of all referenced aggregates.
+ std::set<std::string> 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<std::string, std::string> definitions; // additional definitions.
+
+
+// CNF representation of the where and having predicates.
+ std::vector<cnf_elem *> wh_cnf;
+ std::vector<cnf_elem *> hav_cnf;
+ std::vector<cnf_elem *> cb_cnf;
+ std::vector<cnf_elem *> cw_cnf;
+ std::vector<cnf_elem *> closew_cnf;
+
+
+
+
+// For MERGE type queries.
+ std::vector<colref_t *> 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<scalarexp_t *> *pf_list, std::vector<int> *fcn_ref_cnt, std::vector<bool> *is_partial_fcn, ext_fcn_list *Ext_fcns);
+void find_partial_fcns_pr(predicate_t *pr, std::vector<scalarexp_t *> *pf_list,std::vector<int> *fcn_ref_cnt, std::vector<bool> *is_partial_fcn, ext_fcn_list *Ext_fcns);
+void collect_partial_fcns(scalarexp_t *se, std::set<int> &pfcn_refs);
+void collect_partial_fcns_pr(predicate_t *pr, std::set<int> &pfcn_refs);
+
+void find_combinable_preds(predicate_t *pr, vector<predicate_t *> *pr_list,
+ table_list *Schema, ext_fcn_list *Ext_fcns);
+
+void collect_agg_refs(scalarexp_t *se, std::set<int> &agg_refs);
+void collect_aggr_refs_pr(predicate_t *pr, std::set<int> &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<col_id, temporal_type> &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_param_tbl_entry *> &handle_tbl);
+void find_param_handles_pr(predicate_t *pr, ext_fcn_list *Ext_fcns,
+ std::vector<handle_param_tbl_entry *> &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<tablevar_t *> &fm,
+ int prev_ref, int new_ref
+ );
+void bind_colref_pr(predicate_t *pr,
+ std::vector<tablevar_t *> &fm,
+ int prev_ref, int new_ref
+ );
+
+
+std::string impute_colname(std::vector<select_element *> &sel_list, scalarexp_t *se);
+std::string impute_colname(std::set<std::string> &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<int> &reflist);
+void get_tablevar_ref_pr(predicate_t *pr, std::vector<int> &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<std::string> &ifpnames);
+int count_pr_ifp_refs(predicate_t *pr, std::set<std::string> &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<int> lfta_id;
+ std::set<unsigned int> 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<int>::iterator ssi;
+ for(ssi=c->lfta_id.begin();ssi!=c->lfta_id.end();++ssi){
+ lfta_id.insert((*ssi));
+ }
+ std::set<unsigned int >::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<unsigned int >::iterator spi;
+ for(spi=c->pred_id.begin();spi!=c->pred_id.end();++spi){
+ pred_id.insert((*spi));
+ }
+ }
+
+ void add_pred_ids(set<unsigned int> &pred_set){
+ std::set<unsigned int >::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<cnf_elem *> > &where_list, table_list *Schema, ext_fcn_list *Ext_fcns, std::vector<cnf_set *> &prefilter_preds, std::set<unsigned int> &pred_ids);
+
+
+cnf_elem *find_common_filter(std::vector< std::vector<cnf_elem *> > &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
+
--- /dev/null
+/* ------------------------------------------------
+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 <string.h>
+
+
+
+#include "ext_fcns.tab.cc.h"
+
+/*
+ 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 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);}
+
+
+%%
+
+
--- /dev/null
+/* 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 <stdio.h>
+
+/* Some addn'l includes, necessary but not included by the
+ bison generated code.
+*/
+
+#include <stdlib.h>
+
+/* 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 <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) \
+ || (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 <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 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 <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)
+/* 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
+
+\f
+
+#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 */
+
+\f
+
+#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;
+ }
+}
+
+\f
+
+/* 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"
+\f
+ 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"
+
+
+
--- /dev/null
+/* 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 */
+
--- /dev/null
+/* ------------------------------------------------
+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 <stdio.h>
+
+/* Some addn'l includes, necessary but not included by the
+ bison generated code.
+*/
+
+#include <stdlib.h>
+
+/* 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 <strval> NAME
+%token <strval> STRING_TOKEN
+%token <strval> INTNUM
+
+
+%type <ext_fcn_t> fcn_def
+%type <ext_fcn_list_t> fcn_list
+%type <plist_t> param_commalist
+%type <plist_t> opt_param_commalist
+%type <tplist_t> type_param_commalist
+%type <tplist_t> opt_type_param_commalist
+%type <param_t> param
+%type <modif_t> 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);}
+ ;
+
+
+
+%%
+
--- /dev/null
+#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 <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 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 <string.h>
+
+
+
+#include "ext_fcns.tab.cc.h"
+
+/*
+ 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 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 <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 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"
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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<vector>
+#include<string>
+#include<map>
+
+#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;i<x->leaves.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;j<x->leaves[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;j<x->leaves[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;
+ }
+}
+
+
--- /dev/null
+/* ------------------------------------------------
+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<string>
+#include<map>
+#include"xml_t.h"
+
+
+class field_list{
+public:
+ std::map<std::string, std::string> type_verifier;
+ std::map<std::string, std::string> 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
+
--- /dev/null
+/* ------------------------------------------------
+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 <string.h>
+
+
+
+#include "fta.tab.cc.h"
+
+/*
+ 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 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;i++){
+ if(flex_fta_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_fta_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_FtaParser_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 */
+
+AND|And|and { flex_fta_ch+=FtaParserleng; return AND; }
+AND_AGGR|And_Aggr|and_aggr { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("AND_AGGR"); return AGGR; }
+OR_AGGR|Or_Aggr|or_aggr { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("OR_AGGR"); return AGGR; }
+XOR_AGGR|Xor_Aggr|xor_aggr { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("XOR_AGGR"); return AGGR; }
+AVG|Avg|avg { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("AVG"); return AGGR; }
+MIN|Min|min { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("MIN"); return AGGR; }
+MAX|Max|max { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("MAX"); return AGGR; }
+SUM|Sum|sum { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("SUM"); return AGGR; }
+COUNT|Count|count { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("COUNT"); return AGGR; }
+BY|By|by { flex_fta_ch+=FtaParserleng; return BY; }
+FROM|From|from { flex_fta_ch+=FtaParserleng; return FROM; }
+INNER_JOIN|Inner_Join|inner_join { flex_fta_ch+=FtaParserleng; return INNER_JOIN; }
+OUTER_JOIN|Outer_Join|outer_join { flex_fta_ch+=FtaParserleng; return OUTER_JOIN; }
+RIGHT_OUTER_JOIN|Right_Outer_Join|right_outer_join { flex_fta_ch+=FtaParserleng; return RIGHT_OUTER_JOIN; }
+LEFT_OUTER_JOIN|Left_Outer_Join|left_outer_join { flex_fta_ch+=FtaParserleng; return LEFT_OUTER_JOIN; }
+FILTER_JOIN|Filter_Join|filter_join { flex_fta_ch+=FtaParserleng; return FILTER_JOIN; }
+GROUP|Group|group { flex_fta_ch+=FtaParserleng; return GROUP; }
+ROLLUP|Rollup|rollup { flex_fta_ch+=FtaParserleng; return ROLLUP; }
+CUBE|Cube|cube { flex_fta_ch+=FtaParserleng; return CUBE; }
+GROUPING_SETS|Grouping_Sets|grouping_sets { flex_fta_ch+=FtaParserleng; return GROUPING_SETS; }
+SUPERGROUP|Supergroup|supergroup { flex_fta_ch+=FtaParserleng; return SUPERGROUP; }
+CLEANING_WHEN|Cleaning_When|cleaning_when { flex_fta_ch+=FtaParserleng; return CLEANING_WHEN; }
+CLEANING_BY|Cleaning_By|cleaning_by { flex_fta_ch+=FtaParserleng; return CLEANING_BY; }
+CLOSING_WHEN|Closing_When|closing_when { flex_fta_ch+=FtaParserleng; return CLOSING_WHEN; }
+HAVING|Having|having { flex_fta_ch+=FtaParserleng; return HAVING; }
+AS|As|as { flex_fta_ch+=FtaParserleng; return AS; }
+IN|In|in { flex_fta_ch+=FtaParserleng; return IN; }
+NOT|Not|not { flex_fta_ch+=FtaParserleng; return NOT; }
+OR|Or|or { flex_fta_ch+=FtaParserleng; return OR; }
+
+SELECT|Select|select { flex_fta_ch+=FtaParserleng; return SELECT; }
+WHERE|Where|where { flex_fta_ch+=FtaParserleng; return WHERE; }
+SUCH|Such|such { flex_fta_ch+=FtaParserleng; return SUCH;}
+THAT|That|that { flex_fta_ch+=FtaParserleng; return THAT;}
+MERGE|Merge|merge {flex_fta_ch+=FtaParserleng; return MERGE;}
+SLACK {flex_fta_ch+=FtaParserleng; return SLACK;}
+
+TRUE { flex_fta_ch+=FtaParserleng; return TRUE_V;}
+FALSE { flex_fta_ch+=FtaParserleng; return FALSE_V;}
+TIMEVAL { flex_fta_ch+=FtaParserleng; return TIMEVAL_L;}
+HEX { flex_fta_ch+=FtaParserleng; return HEX_L;}
+LHEX { flex_fta_ch+=FtaParserleng; return LHEX_L;}
+IP_VAL { flex_fta_ch+=FtaParserleng; return IP_L;}
+IPV6_VAL|IPv6_VAL { flex_fta_ch+=FtaParserleng; return IPV6_L;}
+
+DEFINE { flex_fta_ch+=FtaParserleng; return DEFINE_SEC;}
+PARAM { flex_fta_ch+=FtaParserleng; return PARAM_SEC;}
+
+[\{] {flex_fta_ch+=FtaParserleng; return LEFTBRACE;}
+[\}] {flex_fta_ch+=FtaParserleng; return RIGHTBRACE;}
+
+ /*
+ Table definition keywords
+ */
+TABLE { flex_fta_ch+=FtaParserleng; return TABLE; }
+PROTOCOL { flex_fta_ch+=FtaParserleng; return PROTOCOL; }
+STREAM { flex_fta_ch+=FtaParserleng; return STREAM; }
+FTA { flex_fta_ch+=FtaParserleng; return FTA; }
+UNPACK_FCNS { flex_fta_ch+=FtaParserleng; return UNPACK_FCNS; }
+
+OPERATOR { flex_fta_ch+=FtaParserleng; return OPERATOR; }
+OPERATOR_VIEW { flex_fta_ch+=FtaParserleng; return OPERATOR_VIEW; }
+FIELDS { flex_fta_ch+=FtaParserleng; return FIELDS; }
+SUBQUERIES { flex_fta_ch+=FtaParserleng; return SUBQUERIES; }
+SELECTION_PUSHDOWN { flex_fta_ch+=FtaParserleng; return SELECTION_PUSHDOWN; }
+; {flex_fta_ch+=FtaParserleng; return SEMICOLON;}
+
+
+ /* punctuation */
+"<<" |
+">>" { 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<max_size){
+ if(flex_fta_stringinput[flex_fta_stringinput_ptr] != '\0'){
+ buf[c++] = flex_fta_stringinput[flex_fta_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_fta_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_fta_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void FtaParser_setfileinput(FILE *f){
+ FtaParserrestart(NULL);
+
+ flex_fta_fileinput = f;
+ flex_fta_stringinput = NULL;
+ flex_fta_lineno = 1;
+ flex_fta_ch = 0;
+}
+
+void FtaParser_setstringinput(char *s){
+ FtaParserrestart(NULL);
+
+ flex_fta_fileinput = NULL;
+ flex_fta_stringinput = s;
+ flex_fta_stringinput_ptr = 0;
+ flex_fta_lineno = 1;
+ flex_fta_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* 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 FtaParserparse
+#define yylex FtaParserlex
+#define yyerror FtaParsererror
+#define yylval FtaParserlval
+#define yychar FtaParserchar
+#define yydebug FtaParserdebug
+#define yynerrs FtaParsernerrs
+
+
+/* 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
+
+
+
+
+/* Copy the first part of user declarations. */
+#line 8 "fta.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 "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 <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 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 <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
+
+\f
+
+#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 */
+\f
+
+/*-----------------------------------------------.
+| 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;
+ }
+}
+\f
+
+/* 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"
+
+
+
--- /dev/null
+/* 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;
+
--- /dev/null
+/* ------------------------------------------------
+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 <stdio.h>
+
+/* Some addn'l includes, necessary but not included by the
+ bison generated code.
+*/
+
+#include <stdlib.h>
+
+/* 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 <strval> NAME
+%token <strval> STRING_TOKEN
+%token <strval> INTNUM
+%token <strval> LONGINTNUM
+%token <strval> APPROXNUM
+
+/* for FTA definition. */
+%type <q_list> query_list
+%type <tblp> gsql
+%type <tblp> select_statement
+%type <tblp> merge_statement
+%type <predp> opt_where_clause
+%type <predp> opt_having_clause
+%type <select_listval> selection
+%type <tblp> table_exp
+%type <tbl_list> from_clause
+%type <tbl_list> table_ref_commalist
+%type <table> table_ref
+%type <stringval> qname
+%type <predp> where_clause
+%type <predp> having_clause
+%type <predp> search_condition
+%type <predp> predicate
+%type <predp> comparison_predicate
+%type <predp> in_predicate
+%type <predp> opt_cleaning_when_clause
+%type <predp> opt_cleaning_by_clause
+%type <predp> opt_closing_when_clause
+%type <litval> literal
+%type <colref> column_ref
+%type <colref> gb_ref
+%type <ifpref> ifparam
+%type <clist> column_ref_list
+%type <clist> gb_ref_list
+%type <table> table
+%type <scalarval> scalar_exp
+%type <se_listval> scalar_exp_commalist
+%type <select_listval> select_commalist
+%type <lit_l> literal_commalist
+%type <extended_gb_list> opt_group_by_clause
+%type <clist> opt_supergroup_clause
+%type <gb_list> gb_commalist
+%type <extended_gb> extended_gb
+%type <extended_gb_list> extended_gb_commalist
+%type <list_of_gb_list> list_of_gb_commalist
+%type <gb_val> gb
+/* for PARAM, DEFINE block */
+%type <var_defs> variable_def
+%type <var_defs> params_def
+%type <var_defs> variable_list
+%type <var_pair> variable_assign
+
+/* For table definition */
+%type <field_t> field
+%type <field_list_t> field_list
+%type <table_def_t> table_def
+%type <table_list_schema> table_list
+%type <plist_t> param_commalist
+%type <plist_t> opt_param_commalist
+%type <plist_t> singleparam_commalist
+%type <plist_t> opt_singleparam_commalist
+%type <plist_t> opt_singleparam_commalist_bkt
+%type <namevec_t> namevec_commalist
+%type <subq_spec_t> subq_spec
+%type <subqueryspec_list_t> subqueryspec_list
+%type <ufcn> unpack_func
+%type <ufcnl> unpack_func_list
+
+ /* operators */
+
+%left OR
+%left AND
+%left NOT
+%left <strval> COMPARISON /* = <> < > <= >= */
+%left '|'
+%left '&'
+%left <strval> SHIFT_OP /* << >> */
+%left '+' '-'
+%left '*' '/' '%'
+%nonassoc UMINUS
+
+ /* literal keyword tokens */
+%token SEMICOLON LEFTBRACE RIGHTBRACE
+/* For query definition */
+%token BY AS
+%token <strval> 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);}
+ ;
+
+%%
+
--- /dev/null
+#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 <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 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 <string.h>
+
+
+
+#include "fta.tab.cc.h"
+
+/*
+ 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 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;i++){
+ if(flex_fta_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_fta_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_FtaParser_yyinput(b,ms))
+
+/* MKS needs the next line to increase the NFA table */
+#line 881 "ftalexer.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 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<max_size){
+ if(flex_fta_stringinput[flex_fta_stringinput_ptr] != '\0'){
+ buf[c++] = flex_fta_stringinput[flex_fta_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_fta_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_fta_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void FtaParser_setfileinput(FILE *f){
+ FtaParserrestart(NULL);
+
+ flex_fta_fileinput = f;
+ flex_fta_stringinput = NULL;
+ flex_fta_lineno = 1;
+ flex_fta_ch = 0;
+}
+
+void FtaParser_setstringinput(char *s){
+ FtaParserrestart(NULL);
+
+ flex_fta_fileinput = NULL;
+ flex_fta_stringinput = s;
+ flex_fta_stringinput_ptr = 0;
+ flex_fta_lineno = 1;
+ flex_fta_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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_fta.h"
+#include "parse_schema.h"
+#include"generate_utils.h"
+
+#include <string>
+#include<set>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include<errno.h>
+
+#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 <config directory>] schema_file [operator name ...]\n"
+ "\t[-C] : use <config directory> for definition files\n";
+
+
+// parameters gathered from command line processing
+ string config_dir_path;
+ set<string> 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 <sys/param.h>\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<buflen;++pos){\n"
+" if(c[pos]=='\\n' || c[pos]=='\\0') return buf;\n"
+" if(c[pos]==':') break;\n"
+" }\n"
+" if(pos == buflen) return buf;\n"
+"\n"
+" pos++; \n"
+" param_list[pno]=c+pos;\n"
+" pno++;\n"
+" \n"
+" for(;pos<buflen;++pos){\n"
+" if(c[pos]==','){\n"
+" c[pos]='\\0';\n"
+" pos++;\n"
+" param_list[pno]=c+pos;\n"
+" pno++;\n"
+" }\n"
+" if(c[pos]=='\\n'){\n"
+" c[pos]='\\0';\n"
+" pos++;\n"
+" *params_found = pno;\n"
+" return c+pos;\n"
+" }\n"
+" }\n"
+" return buf;\n"
+"}\n"
+"\n"
+"\n";
+
+ set<string> ufcns;
+ vector<string> tbl_names = Schema->get_table_names();
+ for(t=0;t<tbl_names.size();++t){
+ if(operator_names.size()==0 || operator_names.count(tbl_names[t])>0){
+ 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<field_entry *> flds = optbl->get_fields();
+ for(f=0;f<flds.size();++f){
+ if(f>0) 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<subquery_spec *> subq = Schema->get_subqueryspecs(tid);
+ for(s=0;s<subq.size();++s){
+ subquery_spec *sqs = subq[s];
+ field_entry_list fel;
+ for(f=0;f<sqs->types.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);
+}
+
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+#include <stdio.h>
+#include <stdlib.h>
+//#include <algo.h>
+#include<algorithm>
+
+#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<handle_param_tbl_entry *> param_handle_table;
+static param_table *param_tbl; // Table of all referenced parameters.
+
+static vector<scalarexp_t *> sl_list;
+static vector<cnf_elem *> 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<scalarexp_t *> partial_fcns;
+static vector<int> fcn_ref_cnt;
+static vector<bool> 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<int> pred_class; // identifies the group
+static vector<int> 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;g<gb_tbl->size();g++){
+ sprintf(tmpstr,"gb_var%d",g);
+ ret += "\t"+gb_tbl->get_data_type(g)->make_cvar(tmpstr)+";\n";
+ }
+
+ int a;
+ for(a=0;a<aggr_tbl->size();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;k<fs->hash_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<handle_param_tbl_entry *> ¶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;g<gb_tbl->size();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<string> param_vec = param_tbl->get_param_names();
+ for(p=0;p<param_vec.size();p++){
+ data_type *dt = param_tbl->get_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;cl<complex_literals->size();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;p<param_handle_table.size();++p){
+ sprintf(tmpstr,"\tgs_param_handle_t handle_param_%d;\n",p);
+ ret += tmpstr;
+ }
+
+// Create places to hold the last values of temporal
+// attributes referenced in select clause
+// we also need to store values of the temoral attributed
+// of last flushed tuple in aggr queries
+// to make sure we generate the cirrect temporal tuple
+// in the presense of slow flushes
+
+
+ col_id_set temp_cids; // col ids of temp attributes in select clause
+
+ int s;
+ col_id_set::iterator csi;
+
+ for(s=0;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ reset_se_col_ids_tblvars(operands[o], gtbl);
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in reset_se_col_ids_tblvars, line %d, character %d: unknown operator type %d\n",
+ se->get_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<scalarexp_t *> 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;o<op_list.size();++o){
+ reset_se_col_ids_tblvars(op_list[o],gtbl) ;
+ }
+ return;
+ default:
+ fprintf(stderr,"INTERNAL ERROR in reset_pr_col_ids_tblvars, line %d, character %d, unknown predicate operator type %d\n",
+ pr->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ if(o>0) 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<scalarexp_t *> 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;o<operands.size();o++){
+ if(o>0) 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<scalarexp_t *> 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;o<operands.size();o++){
+ 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 += ");\n";
+
+ return(ret);
+}
+
+static string generate_cached_fcn(scalarexp_t *se, table_list *schema){
+ string ret;
+ int o;
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ if(o) ret += ", ";
+ if(operands[o]->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ ret += ", ";
+ if(operands[o]->get_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<literal_t *> litv;
+ int i;
+ data_type *ldt, *rdt;
+ vector<scalarexp_t *> 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;i<litv.size();i++){
+ if(i>0) 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;o<op_list.size();++o){
+ if(o>0) 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<scalarexp_t *> opl = atbl->get_operand_list(aidx);
+ for(o=0;o<opl.size();++o){
+ retval += ",";
+ if(opl[o]->get_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<scalarexp_t *> opl = atbl->get_operand_list(aidx);
+ for(o=0;o<opl.size();++o){
+ retval += ",";
+ if(opl[o]->get_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<string,string> &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<stdio.h>\n";
+ ret += "#include <limits.h>\n";
+ ret += "#include <float.h>\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;a<aggr_tbl->size();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;a<aggr_tbl->size();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;p<sl_fcns_end;p++){
+ if(is_partial_fcn[p]){
+ ret += "\t" + unpack_partial_fcn_fm_aggr(partial_fcns[p], p,
+ "t->aggr_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;g<gb_tbl->size();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;a<aggr_tbl->size();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;g<gb_tbl->size();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;a<aggr_tbl->size();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;g<gb_tbl->size();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;a<aggr_tbl->size();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;g<gb_tbl->size();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;a<aggr_tbl->size();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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;p<sl_fcns_end;p++){
+ sprintf(tmpstr,"\t%s partial_fcn_result_%d;\n",
+ partial_fcns[p]->get_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;a<aggr_tbl->size();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;g<gb_tbl->size();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;g<gb_tbl->size();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<string> 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;p<param_names.size();p++){
+ data_type *dt = param_tbl->get_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;p<param_names.size();p++){
+ if(p>0) 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;p<param_names.size();p++){
+ data_type *dt = param_tbl->get_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;ph<param_handle_table.size();++ph){
+ data_type pdt(param_handle_table[ph]->type_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;ph<param_handle_table.size();++ph){
+ sprintf(tmpstr, "\t%s(t->handle_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;g<gb_tbl->size();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;g<gb_tbl->size();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_pos<t->max_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;g<gb_tbl->size();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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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_pos<t->max_aggrs) fta_aggr_flush_old_"+node_name+"(f,1);\n";
+ ret += "\t}\n\n";
+ }else{
+ ret+="\tif(t->flush_pos<t->max_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;g<gb_tbl->size();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_pos<t->max_aggrs) fta_aggr_flush_old_"+node_name+"(f,t->max_aggrs);\n";
+ temporal_flush+="\t\tif(t->flush_pos<t->max_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;g<gb_tbl->size();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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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<sl_fcns_end;p++){
+ if(fcn_ref_cnt[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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;i<bf_exp_size;i++)
+ bf_mask = (bf_mask << 1) | 1;
+ }else{
+ for(i=ht_size;i>1;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<cnf_elem *> 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;w<s_filt.size();++w){
+ col_id_set this_pred_cids;
+ gather_pr_col_ids(s_filt[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,"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<cnf_elem *> tmp_wh;
+ for(w=0;w<s_filt.size();++w){
+ compute_cnf_cost(s_filt[w],Ext_fcns);
+ tmp_wh.push_back(s_filt[w]);
+ }
+ s_filt = tmp_wh;
+
+ sort(s_filt.begin(), s_filt.end(), compare_cnf_cost());
+
+// Now generate the predicates.
+ for(w=0;w<s_filt.size();++w){
+ sprintf(tmpstr,"//\t\tPredicate clause %d.(cost %d)\n",w,s_filt[w]->cost);
+ ret += tmpstr;
+
+// Find partial fcns ref'd in this cnf element
+ set<int> 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<int>::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;p<fs->hash_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;p<fs->hash_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;p<fs->hash_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;p<fs->hash_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;p<fs->hash_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;p<fs->hash_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<cnf_elem *> r_filt = fs->pred_t0;
+ for(w=0;w<r_filt.size();++w){
+ col_id_set this_pred_cids;
+ gather_pr_col_ids(r_filt[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) );
+ }
+ }
+ }
+
+// Sort S preds based on cost.
+
+ vector<cnf_elem *> tmp_wh;
+ for(w=0;w<r_filt.size();++w){
+ compute_cnf_cost(r_filt[w],Ext_fcns);
+ tmp_wh.push_back(r_filt[w]);
+ }
+ r_filt = tmp_wh;
+
+ sort(r_filt.begin(), r_filt.end(), compare_cnf_cost());
+
+// WARNING! the constant 20 below is a wild-ass guess.
+ int cheap_rpos;
+ for(cheap_rpos=0;cheap_rpos<r_filt.size() && r_filt[cheap_rpos]->cost <= 20;cheap_rpos++)
+
+// Test the cheap filters on R.
+ if(cheap_rpos >0){
+
+// Now generate the predicates.
+ for(w=0;w<cheap_rpos;++w){
+ sprintf(tmpstr,"//\t\tPredicate clause %d.(cost %d)\n",w,r_filt[w]->cost);
+ ret += tmpstr;
+
+// Find partial fcns ref'd in this cnf element
+ set<int> 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<int>::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;p<fs->hash_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;p<fs->hash_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;p<fs->hash_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;p<fs->hash_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;p<fs->hash_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;w<r_filt.size();++w){
+ sprintf(tmpstr,"//\t\tPredicate clause %d.(cost %d)\n",w,r_filt[w]->cost);
+ ret += tmpstr;
+
+// Find partial fcns ref'd in this cnf element
+ set<int> 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<int>::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<sl_list.size();++s){
+ col_id_set this_se_cids;
+ gather_se_col_ids(sl_list[s], this_se_cids, gb_tbl);
+ for(csi=this_se_cids.begin();csi!=this_se_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) );
+ }
+ }
+ }
+
+
+// Unpack partial fcns ref'd by the select clause.
+// Its a kind of a WHERE clause ...
+ for(p=sl_fcns_start;p<sl_fcns_end;p++){
+ if(fcn_ref_cnt[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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;p<gb_fcns_end;p++){
+ if(is_partial_fcn[p]){
+ ret += unpack_partial_fcn(partial_fcns[p], p, schema);
+ ret += "\tif(retval) goto end;\n";
+ }
+ }
+ for(p=ag_fcns_start;p<ag_fcns_end;p++){
+ if(is_partial_fcn[p]){
+ ret += unpack_partial_fcn(partial_fcns[p], p, schema);
+ ret += "\tif(retval) goto end;\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";
+
+ ret += "/*\t\tTest if the group is in the hash table \t*/\n";
+// Compute the values of the group-by variables.
+ for(g=0;g<gb_tbl->size();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;g<gb_tbl->size();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;a<aggr_tbl->size();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;g<gb_tbl->size();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;g<gb_tbl->size();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<unsigned int> &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;w<where.size();++w)
+ reset_pr_col_ids_tblvars(where[w]->pr, gb_tbl);
+ for(s=0;s<sl_list.size();s++)
+ reset_se_col_ids_tblvars(sl_list[s], gb_tbl);
+ }
+
+ for(w=0;w<where.size();++w){
+ if(is_fj || s_pids.count(w) == 0)
+ gather_pr_col_ids(where[w]->pr,cid_set, gb_tbl);
+ }
+ for(s=0;s<sl_list.size();s++){
+ gather_se_col_ids(sl_list[s],cid_set, gb_tbl);
+ }
+
+ int g;
+ if(gb_tbl != NULL){
+ for(g=0;g<gb_tbl->size();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;g<gb_tbl->size();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;a<aggr_tbl->size();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;a<aggr_tbl->size();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;g<fjq->hash_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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;p<partial_fcns.size();++p){
+ if(is_partial_fcn[p] || (!is_aggr_query && fcn_ref_cnt[p] >1)){
+ 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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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<cnf_elem *> 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<cnf_elem *> tmp_wh;
+ for(w=0;w<filter.size();++w){
+ if(s_pids.count(w) == 0){
+ compute_cnf_cost(filter[w],Ext_fcns);
+ tmp_wh.push_back(filter[w]);
+ }
+ }
+ filter = tmp_wh;
+
+ sort(filter.begin(), filter.end(), compare_cnf_cost());
+
+// Now generate the predicates.
+ for(w=0;w<filter.size();++w){
+ sprintf(tmpstr,"//\t\tPredicate clause %d.(cost %d)\n",w,filter[w]->cost);
+ 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<int> 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<int>::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<cnf_elem *> h_eq = ((filter_join_qpn *)fs)-> hash_eq;
+ for(w=0;w<h_eq.size();++w){
+ col_id_set this_pred_cids;
+ gather_pr_col_ids(h_eq[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) );
+ }
+ }
+ }
+ }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;g<gb_tbl->size();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;cl<complex_literals->size();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;s<sl_list.size();s++){
+ data_type *sdt = sl_list[s]->get_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;g<gb_tbl->size();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;ph<param_handle_table.size();++ph){
+ data_type pdt(param_handle_table[ph]->type_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<string,string> &int_fcn_defs,
+ ext_fcn_list *Ext_fcns, string &schema_embed_str, ifq_t *ifdb, nic_property *nicp, set<unsigned int> &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<bool> *pfunc_ptr = NULL;
+ vector<int> *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;i<sl_list.size();i++){
+ find_partial_fcns(sl_list[i], &partial_fcns, ref_cnt_ptr, pfunc_ptr, Ext_fcns);
+ }
+ wh_fcns_start = sl_fcns_end = partial_fcns.size();
+ for(i=0;i<where.size();i++){
+ find_partial_fcns_pr(where[i]->pr, &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;i<gb_tbl->size();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;i<aggr_tbl->size();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; i<partial_fcns.size();i++){
+ fcn_ref_cnt.push_back(1);
+ is_partial_fcn.push_back(true);
+ }
+ }
+
+// Unmark non-partial expensive functions referenced only once.
+ for(i=0; i<partial_fcns.size();i++){
+ if(!is_partial_fcn[i] && fcn_ref_cnt[i] <= 1){
+ partial_fcns[i]->set_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<tablevar_t *> input_tbls = fs->get_input_tbls();
+ int schref = input_tbls[0]->get_schema_ref();
+ vector<string> refd_cols;
+ for(s=0;s<sl_list.size();++s){
+ gather_nicsafe_cols(sl_list[s],refd_cols, nicp, gb_tbl);
+ }
+ for(p=0;p<where.size();++p){
+// I'm not disabling these preds ...
+ gather_nicsafe_cols(where[p]->pr,refd_cols, nicp, gb_tbl);
+ }
+ if(gb_tbl){
+ for(g=0;g<gb_tbl->size();++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;vsi<refd_cols.size();++vsi){
+ data_type dt(schema->get_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<tablevar_t *> tvec = fs->get_input_tbls();
+ vector<string> 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;w<where.size();++w)
+ gather_pr_col_ids(where[w]->pr,cid_set, gb_tbl);
+ for(s=0;s<sl_list.size();s++){
+ gather_se_col_ids(sl_list[s],cid_set, gb_tbl);
+ }
+
+ int g;
+ if(gb_tbl != NULL){
+ for(g=0;g<gb_tbl->size();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<col_id, string,lt_col_id> &ucol_fcn_map){
+ map<string, int> pfcn_count;
+ map<string, int>::iterator msii;
+ col_id_set::iterator cisi;
+ set<string>::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<string> 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<string> 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<cnf_set *> &pred_list,
+ col_id_set &temp_cids, table_list *Schema, ext_fcn_list *Ext_fcns,
+ vector<col_id_set> &lfta_cols, vector<long long int> &lfta_sigs,
+ vector<int> &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;p<pred_list.size();++p){
+ find_complex_literal_pr(pred_list[p]->pr,Ext_fcns, complex_literals);
+ }
+
+
+// Find the combinable predicates
+ vector<predicate_t *> pr_list;
+ for(p=0;p<pred_list.size();++p){
+ find_combinable_preds(pred_list[p]->pr,&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<predicate_t *> equiv_list;
+ vector<int> num_equiv;
+
+
+ for(p=0;p<pr_list.size();++p){
+ for(q=0;q<equiv_list.size();++q){
+ if(is_equivalent_class_pred_base(equiv_list[q],pr_list[p],Schema,Ext_fcns))
+ break;
+ }
+ if(q == equiv_list.size()){ // no equiv : create new
+ pred_class.push_back(equiv_list.size());
+ equiv_list.push_back(pr_list[p]);
+ pred_pos.push_back(0);
+ num_equiv.push_back(1);
+
+ }else{ // pr_list[p] is equivalent to pred q
+ pred_class.push_back(q);
+ pred_pos.push_back(num_equiv[q]);
+ num_equiv[q]++;
+ }
+ }
+
+// Generate the variables which hold the common pred handles
+ ret += "/*\t\tprefilter global vars.\t*/\n";
+ for(q=0;q<equiv_list.size();++q){
+ for(p=0;p<=(num_equiv[q]/32);++p){
+ ret += "void *pref_common_pred_hdl_"+int_to_string(q)+"_"+int_to_string(p)+"_"+iface+";\n";
+ }
+ }
+
+// Struct to hold prefilter complex literals
+ ret += "struct prefilter_complex_lit_struct_"+iface+" {\n";
+ if(complex_literals->size() == 0)
+ ret += "\tint no_variable;\n";
+ int cl;
+ for(cl=0;cl<complex_literals->size();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;cl<complex_literals->size();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<int> epred_seen;
+ for(p=0;p<pr_list.size();++p){
+ int q = pred_class[p];
+//printf("\tq=%d\n",q);
+ if(epred_seen.count(q)>0){
+ ret += "\tregister_commonpred_handles_"+equiv_list[q]->get_op()+"(";
+ vector<bool> cl_op = Ext_fcns->get_class_indicators(equiv_list[q]->get_fcn_id());
+ vector<scalarexp_t *> op_list = pr_list[p]->get_op_list();
+ for(o=0;o<op_list.size();++o){
+ if(! cl_op[o]){
+ ret += generate_se_code(op_list[o],Schema)+", ";
+ }
+ }
+ ret += "pref_common_pred_hdl_"+int_to_string(q)+"_"+int_to_string(pred_pos[p]/32)+"_"+iface+","+int_to_string(pred_pos[p]%32)+");\n";
+ epred_seen.insert(q);
+ }else{
+ ret += "\tpref_common_pred_hdl_"+int_to_string(q)+"_"+int_to_string(pred_pos[p]/32)+"_"+iface+" = (void *)register_commonpred_handles_"+equiv_list[q]->get_op()+"(";
+ vector<bool> cl_op = Ext_fcns->get_class_indicators(equiv_list[q]->get_fcn_id());
+ vector<scalarexp_t *> op_list = pr_list[p]->get_op_list();
+ for(o=0;o<op_list.size();++o){
+ if(! cl_op[o]){
+ ret += generate_se_code(op_list[o],Schema)+", ";
+ }
+ }
+ ret += "NULL,"+int_to_string(pred_pos[p]%32)+");\n";
+ epred_seen.insert(q);
+ }
+ }
+ ret += "}\n\n";
+
+
+
+// Start on main body code generation
+ ret+="gs_uint64_t lfta_prefilter_"+iface+"(void *pkt){\n";
+
+
+///--------------------------------------------------------------
+/// Generate and store the prefilter body,
+/// reuse it for the snap length calculator
+///-------------------------------------------------------------
+ string body;
+
+ body += "\tstruct packet *p = (struct packet *)pkt;\n";
+
+
+
+// Gather the colids to store unpacked variables.
+ for(p=0;p<pred_list.size();++p){
+ gather_pr_col_ids(pred_list[p]->pr,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<col_id, string,lt_col_id> ucol_fcn_map;
+ find_optimal_unpack_fcns(upref_cids, Schema, ucol_fcn_map);
+ set<string> pref_ufcns;
+ map<col_id, string,lt_col_id>::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<equiv_list.size();++q){
+ for(p=0;p<=(num_equiv[q]/32);++p){
+ body += "unsigned long int pref_common_pred_val_"+int_to_string(q)+"_"+int_to_string(p)+" = 0;\n";
+ }
+ }
+
+
+// Variables that are always needed
+ body += "/*\t\tVariables which are always needed\t*/\n";
+ body += "\tgs_uint64_t retval=0, bitpos=1;\n";
+ body += "\tstruct prefilter_complex_lit_struct_"+iface+" *t = &prefilter_complex_lits_"+iface+";\n";
+
+// Call the unpacking functions for the prefilter fields
+ if(pref_ufcns.size() > 0)
+ body += "\n/*\t\tcall field unpacking functions\t*/\n";
+ set<string>::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;q<equiv_list.size();++q){
+ for(p=0;p<=(num_equiv[q]/32);++p){
+
+// Only call the common eval fcn if all ref'd fields present.
+ col_id_set pred_cids;
+ col_id_set::iterator cpi;
+ gather_pr_col_ids(equiv_list[q], 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\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<scalarexp_t *> op_list = equiv_list[q]->get_op_list();
+ vector<bool> cl_op = Ext_fcns->get_class_indicators(equiv_list[q]->get_fcn_id());
+ for(o=0;o<op_list.size();++o){
+ if(cl_op[o]){
+ body += ","+generate_se_code(op_list[o],Schema);
+ }
+ }
+ body += ");\n";
+ }
+ }
+
+
+ for(p=0;p<pred_list.size();++p){
+ col_id_set pred_cids;
+ col_id_set::iterator cpi;
+ gather_pr_col_ids(pred_list[p]->pr,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;l<lfta_cols.size();++l){
+ for(csi=lfta_cols[l].begin();csi!=lfta_cols[l].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);
+ field_entry *fe = Schema->get_field(tmp_col_id.schema_ref, tmp_col_id.field);
+ set<string> 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<col_id, string,lt_col_id> uall_fcn_map;
+ find_optimal_unpack_fcns(upall_cids, Schema, uall_fcn_map);
+ set<string> 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<long long int> clfta;
+ for(l=0;l<lfta_cols.size();l++){
+ for(csi=fcol_set.begin();csi!=fcol_set.end();++csi){
+ if(lfta_cols[l].count((*csi)) > 0)
+ break;
+ }
+ if(csi != fcol_set.end())
+ clfta.insert(lfta_sigs[l]);
+ }
+
+// generate the unpacking code
+ ret += "\tif(";
+ set<long long int>::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<int> s_snaps = lfta_snap_lens;
+ sort(s_snaps.begin(), s_snaps.end());
+
+ if(s_snaps[0] == -1){
+ set<unsigned long long int> sigset;
+ for(i=0;i<lfta_snap_lens.size();++i){
+ if(lfta_snap_lens[i] == -1){
+ sigset.insert(lfta_sigs[i]);
+ }
+ }
+ ret += "\tif( ";
+ set<unsigned long long int>::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<unsigned long long int> sigset;
+ for(i=0;i<lfta_snap_lens.size();++i){
+ if(lfta_snap_lens[i] == nextval){
+ sigset.insert(lfta_sigs[i]);
+ }
+ }
+ ret += "\tif( ";
+ set<unsigned long long int>::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);
+}
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+#include <map>
+#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<std::string,std::string> &int_fcn_defs,
+ ext_fcn_list *Ext_fcns, std::string &schema_embed_str, ifq_t *ifdb, nic_property *nicp, set<unsigned int> &s_pids);
+
+std::string generate_lfta_prefilter(std::vector<cnf_set *> &pred_list, col_id_set &temp_cids, table_list *Schema, ext_fcn_list *Ext_fcns, std::vector<col_id_set> &lfta_cols, std::vector<long long int> &lfta_sigs, vector<int> &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
+
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <algorithm>
+
+#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<string, string> &constants,
+ int ©_var_cnt,
+ set<string> &no_copy_vars,
+ string *retvar, int lr,
+ gb_table *gbt ){
+
+ string ret = "";
+ string l,cid;
+ data_type *ldt, *rdt;
+ int o;
+ vector<scalarexp_t *> 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<string, string> &constants,
+ int ©_var_cnt,
+ set<string> &no_copy_vars,
+ string *retvar, gb_table *gbt ){
+ string ret;
+ vector<literal_t *> litv;
+ int i;
+ data_type *ldt, *rdt;
+ vector<scalarexp_t *> 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<string> &cols, nic_property *nicp, gb_table *gbt){
+ int i, gbref;
+ string colname;
+ vector<scalarexp_t *> 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;i<cols.size();++i){
+ if(colname == cols[i])
+ break;
+ }
+ if(i==cols.size())
+ cols.push_back(colname);
+ }
+ return;
+ case SE_FUNC:
+ operands = se->get_operands();
+ for(i=0;i<operands.size();++i)
+ gather_nicsafe_cols(operands[i],cols,nicp,gbt);
+ return;
+ default:
+ return;
+ }
+ return;
+}
+
+void gather_nicsafe_cols(predicate_t *pr, vector<string> &cols, nic_property *nicp, gb_table *gbt){
+ string dts, colname;
+ bool rs, ls;
+ vector<scalarexp_t *> 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<operands.size();++i)
+ gather_nicsafe_cols(operands[i],cols,nicp, gbt);
+ return ;
+ default:
+ return ;
+ }
+
+ return ;
+}
+
+
+string generate_nic_code(vector<stream_query *> 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<vector<predicate_t *> > nicsafe_preds;
+ vector<predicate_t *> empty_list;
+ for(i=0;i<lftas.size();i++){
+ qp_node *qpn = lftas[i]->get_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<cnf_elem *> lfta_cnfs = qpn->get_filter_clause();
+ for(p=0;p<lfta_cnfs.size();++p){
+ if(pr_is_nic_safe(lfta_cnfs[p]->pr,nicp,gbtbl)){
+ nicsafe_preds[i].push_back(lfta_cnfs[p]->pr);
+ }
+ }
+ }
+
+ map<string, string> consts;
+ int n_copyvar = 0;
+ set<string> nocopy_vars;
+ string retvar;
+
+ if(packed_return){
+//printf("dping packed return\n");
+ for(i=0;i<lftas.size();++i){
+ qp_node *qpn = lftas[i]->get_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<nicsafe_preds[i].size();++p){
+ ret += generate_nic_predicate_code(nicsafe_preds[i][p],
+ consts, n_copyvar, nocopy_vars, &retvar, gbtbl);
+ ret += "jump_if_zero("+retvar+",lfta"+int_to_string(i+1)+")\n";
+ }
+ vector<scalarexp_t *> 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<string> refd_cols;
+ for(s=0;s<se_list.size();++s){
+ gather_nicsafe_cols(se_list[s],refd_cols, nicp, gbtbl);
+ }
+ vector<cnf_elem *> lfta_cnfs = qpn->get_where_clause();
+ for(p=0;p<lfta_cnfs.size();++p){
+ gather_nicsafe_cols(lfta_cnfs[p]->pr,refd_cols, nicp, gbtbl);
+ }
+ if(gbtbl){
+ for(g=0;g<gbtbl->size();++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;s<refd_cols.size();++s){
+ ret += ",";
+ ret += refd_cols[s];
+ }
+ ret += ")\n\n";
+ }
+ ret += "\nlabel(lfta"+int_to_string(i)+")\n";
+ }else{
+ for(i=0;i<lftas.size();++i){
+ qp_node *qpn = lftas[i]->get_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<nicsafe_preds[i].size();++p){
+ ret += generate_nic_predicate_code(nicsafe_preds[i][p],
+ consts, n_copyvar, nocopy_vars, &retvar, gbtbl);
+ if(p<nicsafe_preds[i].size()-1){
+ ret += "jump_if_zero("+retvar+",lfta"+int_to_string(i+1)+")\n\n";
+ }else{
+ ret += "jump_if_notzero("+retvar+",pass)\n\n";
+ }
+ }
+ }
+ ret += "label(pass)\n";
+ ret += "send_packet()\n";
+ ret += "\nlabel(lfta"+int_to_string(i)+")\n";
+ }
+ ret += "label(exit)\n";
+ ret += "exit()\n";
+
+ map<string, string>::iterator mssi;
+ for(mssi=consts.begin();mssi!=consts.end();++mssi){
+ vars += "constant( "+(*mssi).first+" , "+(*mssi).second+")\n";
+ }
+ for(i=0;i<n_copyvar;++i){
+ vars += "variable( copyvar_"+int_to_string(i)+" )\n";
+ }
+ set<string>::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;
+
+}
+
+
--- /dev/null
+/* ------------------------------------------------
+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<string>
+#include<vector>
+
+
+std::string generate_nic_code(std::vector<stream_query *> lftas, nic_property *nicp);
+void gather_nicsafe_cols(scalarexp_t *se, std::vector<std::string> &cols, nic_property *nicp, gb_table *gbt);
+void gather_nicsafe_cols(predicate_t *pr, std::vector<std::string> &cols, nic_property *nicp, gb_table *gbt);
+
+
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+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<scalarexp_t *> sl_list){
+ string ret = "struct "+generate_tuple_name(normalize_name(node_name))+"{\n";
+
+ int s;
+ for(s=0;s<sl_list.size();s++){
+ sprintf(tmpstr,"tuple_var%d",s);
+ ret += "\t" + sl_list[s]->get_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<field_entry *> flds = td->get_fields();
+
+ int f;
+ for(f=0;f<flds.size();f++){
+ data_type dt(flds[f]->get_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<field_entry *> flds = td->get_fields();
+
+ int f;
+ for(f=0;f<flds.size();f++){
+ data_type dt(flds[f]->get_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<field_entry *> flds = td->get_fields();
+
+/*
+ int f;
+ for(f=0;f<flds.size();f++){
+ ret.append("\t");
+ data_type dt(flds[f]->get_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;i<instr.size();++i){
+ if(instr[i] == '\n'){
+ outstr += "\\n\"\n\t\"";
+ }else{
+ if(instr[i] == '\\'){
+ outstr += "\\\\";
+ }else
+ outstr += instr[i];
+ }
+ }
+ outstr += "\"";
+ return(outstr);
+}
+
+string generate_host_tuple_pack(table_def *td){
+ int f;
+ string ret = "int pack_"+normalize_name(td->get_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<field_entry *> 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;f<flds.size();f++){
+ data_type dt(flds[f]->get_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;f<flds.size();f++){
+ data_type dt(flds[f]->get_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;f<flds.size();f++){
+ data_type dt(flds[f]->get_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;f<flds.size();f++){
+ data_type dt(flds[f]->get_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_size<sizeof(struct "+generate_tuple_name(normalize_name(td->get_tbl_name())) +")) return NULL;\n";
+
+ vector<field_entry *> flds = td->get_fields();
+
+ for(f=0;f<flds.size();f++){
+ data_type dt(flds[f]->get_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"
+};
+
+
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+#include <map>
+
+#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<scalarexp_t *> 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
+
--- /dev/null
+/* ------------------------------------------------
+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<errno.h>
+#include <unistd.h>
+#include <algorithm>
+#include <cctype>
+
+
+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<string> 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<string> &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<string, vector<string> >::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<vals[prop].size();++i){
+ if((vals[prop])[i] == val) return true;
+ }
+ return false;
+ }
+
+ bool iface_t::eval_Equals(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;
+ if(vals[prop].size() != 1) return false;
+ int i;
+ for(i=0;i<vals[prop].size();++i){
+ if((vals[prop])[i] == val) return true;
+ }
+ return false;
+ }
+
+ bool iface_t::eval_Exists(string prop){
+ // convert to lowercase
+ std::transform(prop.begin(), prop.end(), prop.begin(), (int(*)(int))std::tolower);
+ if(vals.count(prop) == 0) return false;
+ return true;
+ }
+
+
+///////////////////////////////////////
+/// gs_host_t methods
+
+ void gs_host_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 gs_host_t::add_property(const char *name, vector<string> &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;i<curr_host->ifaces.size();i++)
+ ifaces.push_back(curr_host->ifaces[i]);
+ }
+ }
+ return ret;
+ }
+
+ string resparse_data::to_string(){
+ string ret;
+ int i;
+ for(i=0;i<ifaces.size();i++)
+ ret += ifaces[i]->to_string();
+ return ret;
+ }
+
+ vector<pair<string,string> > resparse_data::find_ifaces(predicate_t *pr){
+ int i;
+ vector<pair<string,string> > ret;
+ for(i=0;i<ifaces.size();++i){
+ if(this->eval_pred(i,pr)){
+ pair<string,string> p(ifaces[i]->get_host(), ifaces[i]->get_name());
+ ret.push_back(p);
+ }
+ }
+ return ret;
+ }
+
+
+ vector<int> resparse_data::get_ifaces_by_Name(std::string host_name, std::string if_name){
+ int i;
+ vector<int> ret;
+ for(i=0;i<ifaces.size();++i){
+ if(ifaces[i]->get_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<scalarexp_t *> 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;i<rpd->level.size();++i) printf("%s, ",rpd->level[i].c_str());
+// printf("\n");
+}
+
+void startElement(void *userData, const char *name, vector<string> &attr_vec, vector<string> &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;i<rpd->level.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<string> 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<table_exp_t *> ifqlist = ifq_parse_result->parse_tree_list->qlist;
+ int i;
+ bool dup = false;
+ for(i=0;i<ifqlist.size();++i){
+ string nm = ifqlist[i]->nmap["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<pair<string,string> > ifq_t::eval(string qname, int &err_no){
+ vector<pair<string,string> > 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<string> ifq_t::get_iface_vals(string host_name, string basic_if_name, string property, int &err_no, string &err_str){
+ vector<string> 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<int> 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<string> ifq_t::get_iface_properties(string host_name, string basic_if_name, int &err_no, string &err_str){
+ vector<string> 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<int> 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]);
+
+}
--- /dev/null
+/* ------------------------------------------------
+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 <stdio.h>
+//#include "xmlparse.h"
+#include<vector>
+#include<string>
+#include<map>
+#include<set>
+#include<algorithm>
+
+#include"parse_fta.h"
+
+
+// Represent an interface.
+class iface_t{
+public:
+ int lineno;
+ std::map<std::string, std::vector<std::string> > 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<std::string> &val_vec);
+
+ std::vector<std::string> get_property(std::string p){
+ std::vector<std::string> 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<std::string, std::vector<std::string> >::iterator msvsi;
+for(msvsi=vals.begin(); msvsi!=vals.end();++msvsi){
+ printf("\t%s : ",(*msvsi).first.c_str());
+ std::vector<std::string> vs = (*msvsi).second;
+ int i;
+ for(i=0;i<vs.size();++i){
+ printf(" %s",vs[i].c_str());
+ }
+ printf("\n");
+}
+*/
+ if(vals.count(p)) return vals[p];
+ else return ret;
+ }
+
+ std::vector<std::string> get_properties(){
+ std::vector<std::string> ret;
+
+ std::map<std::string, std::vector<std::string> >::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<std::string, std::vector<std::string> > 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<std::string> &val_vec);
+ std::vector<std::string> get_property(std::string p){
+ std::vector<std::string> 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;i<ifaces.size();i++)
+ ifaces[i]->add_property("host", vals["name"]);
+ }
+
+ std::string to_string();
+ std::string get_name();
+
+ std::vector<iface_t *> ifaces;
+};
+
+
+
+// A collection of resources (interfaces)
+
+class resparse_data{
+public:
+ std::vector<std::string> level;
+ bool in_Resources, in_Iface, in_Host;
+ iface_t *curr_iface;
+ gs_host_t *curr_host;
+ bool failure;
+ std::vector<iface_t *> ifaces;
+ std::vector<gs_host_t *> hosts;
+ bool use_live_hosts_file;
+ std::set<std::string> *live_hosts;
+ bool distributed_mode;
+
+// XML_Parser parser;
+
+// resparse_data(XML_Parser p){
+// parser = p;
+ resparse_data(bool use_live_hosts_file, std::set<std::string> *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<std::string> &val_vec){
+ curr_iface->add_property(name, val_vec);
+ };
+
+
+ std::vector<std::string> get_property(int i, std::string property){
+ return ifaces[i]->get_property(property);
+ };
+ std::vector<std::string> 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<std::pair<std::string,std::string> > find_ifaces(predicate_t *pr);
+ std::vector<int> 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<std::string, predicate_t *> 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<std::pair<std::string,std::string> > eval(std::string qname, int &errnbr);
+ std::vector<std::string> get_iface_vals(std::string host_name, std::string if_name, std::string property, int &errnbr, std::string &err_str);
+ std::vector<std::string> 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<std::string> &attr_vec, std::vector<std::string> &val_vec);
+void endElement(void *userData, const char *name) ;
+
+
+
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+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 <string.h>
+
+
+
+#include "ifq.tab.cc.h"
+
+/*
+ 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 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<flex_ifq_ch;i++){
+ if(flex_ifq_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_ifq_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_IfqParser_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 */
+
+AND|And|and { flex_ifq_ch+=IfqParserleng; return AND; }
+NOT|Not|not { flex_ifq_ch+=IfqParserleng; return NOT; }
+OR|Or|or { flex_ifq_ch+=IfqParserleng; return OR; }
+
+TRUE { flex_ifq_ch+=IfqParserleng; return TRUE_V;}
+FALSE { flex_ifq_ch+=IfqParserleng; return FALSE_V;}
+
+Contains|Equals|Exists {flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return PRED; }
+
+; {flex_ifq_ch+=IfqParserleng; return SEMICOLON;}
+
+
+
+[&|!+*/:(),.\[\]$] { flex_ifq_ch+=IfqParserleng; return yytext[0]; }
+"-" { flex_ifq_ch+=IfqParserleng; return yytext[0]; }
+"~" { flex_ifq_ch+=IfqParserleng; return yytext[0]; }
+
+ /* names */
+
+[A-Za-z_][A-Za-z0-9_]* { flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return NAME; }
+
+ /* numbers */
+
+[0-9]+ |
+[0-9]+UL { flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return INTNUM; }
+
+[0-9]+ULL { flex_ifq_ch+=IfqParserleng; IfqParserlval.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_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return APPROXNUM; }
+
+ /* strings */
+
+'[^'\n]*' {
+
+ 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();
+ }
+
+'[^'\n]*$ { flex_ifq_ch+=IfqParserleng; IfqParsererror("Unterminated string"); }
+
+ /* */
+ /* Newline : advance the error reporting line number */
+ /* and grab the next line into flex_ifq_linebuf */
+ /* */
+
+\n.* {flex_ifq_ch=0; flex_ifq_lineno++;
+ strcpy(flex_ifq_linebuf,IfqParsertext+1);
+ yyless(1);
+ }
+
+[ \t\r]+ {flex_ifq_ch+=IfqParserleng; } /* white space */
+
+"--".*$ {flex_ifq_ch+=IfqParserleng; }; /* comment */
+"//".*$ {flex_ifq_ch+=IfqParserleng; }; /* comment */
+
+.|\n {flex_ifq_ch+=IfqParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); IfqParsererror(yytext);}
+
+%%
+
+int my_IfqParser_yyinput(char *buf, int max_size){
+ int c = 0;
+ int inchar = 0;
+
+ if(flex_ifq_stringinput != NULL){
+ while(c<max_size){
+ if(flex_ifq_stringinput[flex_ifq_stringinput_ptr] != '\0'){
+ buf[c++] = flex_ifq_stringinput[flex_ifq_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_ifq_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_ifq_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void IfqParser_setfileinput(FILE *f){
+ IfqParserrestart(NULL);
+
+ flex_ifq_fileinput = f;
+ flex_ifq_stringinput = NULL;
+ flex_ifq_lineno = 1;
+ flex_ifq_ch = 0;
+}
+
+void IfqParser_setstringinput(char *s){
+ IfqParserrestart(NULL);
+
+ flex_ifq_fileinput = NULL;
+ flex_ifq_stringinput = s;
+ flex_ifq_stringinput_ptr = 0;
+ flex_ifq_lineno = 1;
+ flex_ifq_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* 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. */
+
+/* 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 IfqParserparse
+#define yylex IfqParserlex
+#define yyerror IfqParsererror
+#define yylval IfqParserlval
+#define yychar IfqParserchar
+#define yydebug IfqParserdebug
+#define yynerrs IfqParsernerrs
+
+
+/* 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
+
+
+
+
+/* Copy the first part of user declarations. */
+#line 8 "ifq.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 "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 <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) \
+ || (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 <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 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 <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)
+/* 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
+
+\f
+
+#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 */
+
+\f
+
+#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;
+ }
+}
+
+\f
+
+/* 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"
+\f
+ 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"
+
+
+
--- /dev/null
+/* 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 */
+
--- /dev/null
+/* ------------------------------------------------
+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 <stdio.h>
+
+/* Some addn'l includes, necessary but not included by the
+ bison generated code.
+*/
+
+#include <stdlib.h>
+
+/* 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 <strval> NAME
+%token <strval> PRED
+%token <strval> STRING_TOKEN
+%token <strval> INTNUM
+%token <strval> LONGINTNUM
+%token <strval> APPROXNUM
+
+/* for FTA definition. */
+%type <q_list> query_list
+%type <tblp> gsql
+%type <tblp> select_statement
+%type <tblp> table_exp
+%type <predp> where_clause
+%type <predp> search_condition
+%type <predp> predicate
+%type <litval> literal
+%type <scalarval> scalar_exp
+%type <se_listval> scalar_exp_commalist
+
+
+
+
+
+ /* operators */
+
+%left OR
+%left AND
+%left NOT
+
+ /* literal keyword tokens */
+%token SEMICOLON LEFTBRACE RIGHTBRACE
+/* For query definition */
+%token BY AS
+%token <strval> 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);}
+ ;
+
+
+
+%%
+
--- /dev/null
+#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 <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 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 <string.h>
+
+
+
+#include "ifq.tab.cc.h"
+
+/*
+ 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 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<flex_ifq_ch;i++){
+ if(flex_ifq_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_ifq_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_IfqParser_yyinput(b,ms))
+
+/* MKS needs the next line to increase the NFA table */
+#line 531 "ifqlexer.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 "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<max_size){
+ if(flex_ifq_stringinput[flex_ifq_stringinput_ptr] != '\0'){
+ buf[c++] = flex_ifq_stringinput[flex_ifq_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_ifq_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_ifq_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void IfqParser_setfileinput(FILE *f){
+ IfqParserrestart(NULL);
+
+ flex_ifq_fileinput = f;
+ flex_ifq_stringinput = NULL;
+ flex_ifq_lineno = 1;
+ flex_ifq_ch = 0;
+}
+
+void IfqParser_setstringinput(char *s){
+ IfqParserrestart(NULL);
+
+ flex_ifq_fileinput = NULL;
+ flex_ifq_stringinput = s;
+ flex_ifq_stringinput_ptr = 0;
+ flex_ifq_lineno = 1;
+ flex_ifq_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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 __LITERAL_TYPES_H_INCLUDED__
+
+
+#define LITERAL_UDEF -1
+#define LITERAL_STRING 1
+#define LITERAL_INT 2
+#define LITERAL_FLOAT 3
+#define LITERAL_BOOL 4
+#define LITERAL_TIMEVAL 5
+#define LITERAL_HEX 6
+#define LITERAL_LONGINT 7
+#define LITERAL_LONGHEX 8
+#define LITERAL_IP 9
+#define LITERAL_IPV6 10
+
+#define __LITERAL_TYPES_H_INCLUDED__
+#endif
--- /dev/null
+/* ------------------------------------------------
+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 -PNicParser -oniclexer.cc nic.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 "nic_def.h"
+ #include <string.h>
+
+
+
+#include "nic.tab.cc.h"
+
+/*
+ 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 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<flex_nic_ch;i++){
+ if(flex_nic_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_nic_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_NicParser_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 */
+
+OPTIONS: { flex_nic_ch+=NicParserleng; return OPTIONS; }
+FUNCTIONS: { flex_nic_ch+=NicParserleng; return FUNC; }
+TYPES: { flex_nic_ch+=NicParserleng; return TYPES; }
+UNARY_OPS: { flex_nic_ch+=NicParserleng; return UNARY_OPS; }
+BINARY_OPS: { flex_nic_ch+=NicParserleng; return BINARY_OPS; }
+MISSING_FIELDS: { flex_nic_ch+=NicParserleng; return FIELDS; }
+
+[;,=] { flex_nic_ch+=NicParserleng; return yytext[0]; }
+
+ /* names */
+
+[A-Za-z_][A-Za-z0-9_]* { flex_nic_ch+=NicParserleng; NicParserlval.strval = strdup(yytext); return NAME; }
+
+
+ /* strings */
+
+'[^'\n]*' {
+
+ 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();
+ }
+
+'[^'\n]*$ { flex_nic_ch+=NicParserleng; NicParsererror("Unterminated string"); }
+
+ /* */
+ /* Newline : advance the error reporting line number */
+ /* and grab the next line into flex_nic_linebuf */
+ /* */
+
+\n.* {flex_nic_ch=0; flex_nic_lineno++;
+ strcpy(flex_nic_linebuf,NicParsertext+1);
+ yyless(1);
+ }
+
+[ \t\r]+ {flex_nic_ch+=NicParserleng; } /* white space */
+
+"--".*$ {flex_nic_ch+=NicParserleng; }; /* comment */
+"//".*$ {flex_nic_ch+=NicParserleng; }; /* comment */
+
+.|\n {flex_nic_ch+=NicParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); NicParsererror(yytext);}
+
+%%
+
+int my_NicParser_yyinput(char *buf, int max_size){
+ int c = 0;
+ int inchar = 0;
+
+ if(flex_nic_stringinput != NULL){
+ while(c<max_size){
+ if(flex_nic_stringinput[flex_nic_stringinput_ptr] != '\0'){
+ buf[c++] = flex_nic_stringinput[flex_nic_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_nic_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_nic_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void NicParser_setfileinput(FILE *f){
+ NicParserrestart(NULL);
+
+ flex_nic_fileinput = f;
+ flex_nic_stringinput = NULL;
+ flex_nic_lineno = 1;
+ flex_nic_ch = 0;
+}
+
+void NicParser_setstringinput(char *s){
+ NicParserrestart(NULL);
+
+ flex_nic_fileinput = NULL;
+ flex_nic_stringinput = s;
+ flex_nic_stringinput_ptr = 0;
+ flex_nic_lineno = 1;
+ flex_nic_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* 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. */
+
+/* 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 NicParserparse
+#define yylex NicParserlex
+#define yyerror NicParsererror
+#define yylval NicParserlval
+#define yychar NicParserchar
+#define yydebug NicParserdebug
+#define yynerrs NicParsernerrs
+
+
+/* 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
+
+
+
+
+/* Copy the first part of user declarations. */
+#line 8 "nic.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 "nic_def.h"
+
+extern int NicParserlex();
+void NicParsererror(char *s);
+
+
+extern nic_property *nicp;
+extern std::vector<std::string> nic_attr_vec;
+extern std::vector<std::string> 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 <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) \
+ || (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 <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 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 <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)
+/* 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
+
+\f
+
+#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 */
+
+\f
+
+#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;
+ }
+}
+
+\f
+
+/* 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"
+\f
+ 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"
+
+
+
--- /dev/null
+/* 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 */
+
--- /dev/null
+/* ------------------------------------------------
+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 <stdio.h>
+
+/* Some addn'l includes, necessary but not included by the
+ bison generated code.
+*/
+
+#include <stdlib.h>
+
+/* prototypes for the parser callbacks.
+*/
+
+#include "nic_def.h"
+
+extern int NicParserlex();
+void NicParsererror(char *s);
+
+
+extern nic_property *nicp;
+extern std::vector<std::string> nic_attr_vec;
+extern std::vector<std::string> 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 <strval> NAME
+%token <strval> 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;}
+ ;
+
+
+
+
+
+%%
+
--- /dev/null
+/* ------------------------------------------------
+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"nic_def.h"
+
+extern int NicParserparse(void);
+extern FILE *NicParserin;
+extern int NicParserdebug;
+
+
+nic_property *nicp;
+std::vector<std::string> nic_attr_vec;
+std::vector<std::string> 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<typea.size();++i){
+ if(t==typea[i])
+ return true;
+ }
+ return false;
+}
+
+
+bool nic_property::legal_unary_op(string t){
+int i;
+ for(i=0;i<opua.size();++i){
+ if(t==opua[i])
+ return true;
+ }
+ return false;
+}
+
+
+
+bool nic_property::legal_binary_op(string t){
+int i;
+ for(i=0;i<opba.size();++i){
+ if(t==opba[i])
+ return true;
+ }
+ return false;
+}
+
+
+bool nic_property::illegal_field(string t){
+int i;
+ for(i=0;i<fieldsa.size();++i){
+ if(t==fieldsa[i])
+ return true;
+ }
+ return false;
+}
+
+
+
+bool nic_property::option_exists(string t){
+int i;
+ for(i=0;i<opta.size();++i){
+ if(t==opta[i])
+ return true;
+ }
+ return false;
+}
+
+
+string nic_property::option_value(string t){
+int i;
+ for(i=0;i<opta.size();++i){
+ if(t==opta[i])
+ return optv[i];
+ }
+ return "";
+}
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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_NIC_DEF_H_INCLUDED__
+#define _FTA_NIC_DEF_H_INCLUDED__
+
+#include<vector>
+#include<string>
+#include<map>
+
+class nic_property{
+public:
+ std::vector<std::string> opta; // option args
+ std::vector<std::string> optv; // val of option args
+ std::vector<std::string> typea; // legal types
+ std::vector<std::string> opba; // legal binary ops
+ std::vector<std::string> opua; // legal unary ops
+ std::vector<std::string> fieldsa; // illegal fields
+ std::vector<std::string> 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<std::string, nic_property *> 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
--- /dev/null
+#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 <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 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 <string.h>
+
+
+
+#include "nic.tab.cc.h"
+
+/*
+ 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 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<flex_nic_ch;i++){
+ if(flex_nic_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_nic_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_NicParser_yyinput(b,ms))
+
+/* MKS needs the next line to increase the NFA table */
+#line 522 "niclexer.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 "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<max_size){
+ if(flex_nic_stringinput[flex_nic_stringinput_ptr] != '\0'){
+ buf[c++] = flex_nic_stringinput[flex_nic_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_nic_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_nic_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void NicParser_setfileinput(FILE *f){
+ NicParserrestart(NULL);
+
+ flex_nic_fileinput = f;
+ flex_nic_stringinput = NULL;
+ flex_nic_lineno = 1;
+ flex_nic_ch = 0;
+}
+
+void NicParser_setstringinput(char *s){
+ NicParserrestart(NULL);
+
+ flex_nic_fileinput = NULL;
+ flex_nic_stringinput = s;
+ flex_nic_stringinput_ptr = 0;
+ flex_nic_lineno = 1;
+ flex_nic_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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 __EXT_FCN_DEF_H_INCLUDED__
+#define __EXT_FCN_DEF_H_INCLUDED__
+
+#include <string>
+#include <vector>
+
+#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<ext_fcn_param *> 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<ext_fcn_param *> get_param_list(){return plist;};
+};
+
+class ext_fcn_modifier_list{
+public:
+ std::vector<std::string> modifiers;
+ std::vector<std::string> 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<ext_fcn_param *> ef_param_list;
+ std::vector<std::string> modifiers; // keyword modifiers of the fcn
+ std::vector<std::string> 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<data_type *> get_operand_dt(){
+ int o;
+ std::vector<data_type *> ret;
+ for(o=0;o<ef_param_list.size();o++){
+ ret.push_back(ef_param_list[o]->get_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;m<modifiers.size();m++){
+ if(modifiers[m] == "PARTIAL")
+ return(true);
+ }
+ if(fdt->is_buffer_type()){
+ return true;
+ }
+ return(false);
+ };
+
+ bool is_combinable(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "COMBINABLE")
+ return(true);
+ }
+ return(false);
+ };
+
+ bool fta_legal(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "LFTA_LEGAL" || modifiers[m] == "LFTA_ONLY" || modifiers[m] == "SAMPLING")
+ return(true);
+ }
+ return(false);
+ };
+
+ bool lfta_only(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "LFTA_ONLY" || modifiers[m] == "SAMPLING")
+ return(true);
+ }
+ return(false);
+ };
+
+// the SAMPLING modifier and the is_sampling_function
+// was aded by Vlad, to support semantic sampling.
+ bool is_sampling_fcn(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "SAMPLING")
+ return(true);
+ }
+ return(false);
+ };
+
+#define COST_FREE 0
+#define COST_LOW 1
+#define COST_HIGH 2
+#define COST_EXPENSIVE 3
+#define COST_TOP 4
+
+ int get_fcn_cost(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "COST"){
+ if(vals[m] == "FREE")
+ return COST_FREE;
+ if(vals[m] == "" || vals[m] == "LOW")
+ return COST_LOW;
+ if(vals[m] == "HIGH")
+ return COST_HIGH;
+ if(vals[m] == "EXPENSIVE")
+ return COST_EXPENSIVE;
+ if(vals[m] == "TOP")
+ return COST_TOP;
+ fprintf(stderr,"Warning, COST %s of function %s not understood, ignoring (options are FREE, LOW, HIGH, EXPENSIVE)\n",vals[m].c_str(), fcn_name.c_str());
+ return COST_LOW;
+ }
+ }
+ return(COST_LOW);
+ };
+
+ int estimate_fcn_cost(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "COST"){
+ if(vals[m] == "FREE")
+ return 1;
+ if(vals[m] == "" || vals[m] == "LOW")
+ return 10;
+ if(vals[m] == "HIGH")
+ return 100;
+ if(vals[m] == "EXPENSIVE")
+ return 1000;
+ if(vals[m] == "TOP")
+ return 10000;
+ fprintf(stderr,"Warning, COST %s of function %s not understood, ignoring (options are FREE, LOW, HIGH, EXPENSIVE)\n",vals[m].c_str(), fcn_name.c_str());
+ return COST_LOW;
+ }
+ }
+ return(COST_LOW);
+ };
+
+ std::string get_subaggr(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "SUBAGGR")
+ return(vals[m]);
+ }
+ return("");
+ };
+
+ std::string get_superaggr(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "SUPERAGGR")
+ return(vals[m]);
+ }
+ return("");
+ };
+
+ std::string get_hfta_subaggr(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "HFTA_SUBAGGR")
+ return(vals[m]);
+ }
+ return("");
+ };
+
+ std::string get_hfta_superaggr(){
+ int m;
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "HFTA_SUPERAGGR")
+ return(vals[m]);
+ }
+ return("");
+ };
+
+
+ bool is_running_aggr(){
+ int m;
+ if(fcn_type != EXT_AGGR_)
+ return false;
+
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "RUNNING")
+ return(true);
+ }
+ return(false);
+ };
+
+// For a special optimization,
+// a UDAF can say that it has no contents
+// worth transferring at tuple output time.
+ bool has_lfta_bailout(){
+ int m;
+ if(fcn_type != EXT_AGGR_)
+ return false;
+
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "LFTA_BAILOUT")
+ return(true);
+ }
+ return(false);
+ };
+
+
+// Conventional aggregation requires only a simple
+// execution of the produce_output callback. The
+// sampling operator might reference the output of (non-running)
+// aggregates multiple times. The MULT_RETURNS keyword
+// indicates that the UDAF doesn't destroy state when the
+// produce_output acllback is evaluated.
+ bool multiple_returns(){
+ int m;
+ if(fcn_type != EXT_AGGR_)
+ return false;
+
+ for(m=0;m<modifiers.size();m++){
+ if(modifiers[m] == "MULT_RETURNS")
+ return(true);
+ }
+ return(false);
+ };
+
+
+ std::vector<bool> get_handle_indicators(){
+ std::vector<bool> ret;
+ int o;
+ for(o=0;o<ef_param_list.size();o++){
+ if(ef_param_list[o]->use_handle())
+ ret.push_back(true);
+ else
+ ret.push_back(false);
+ }
+ return(ret);
+ };
+
+ std::vector<bool> get_const_indicators(){
+ std::vector<bool> ret;
+ int o;
+ for(o=0;o<ef_param_list.size();o++){
+ if(ef_param_list[o]->is_constant())
+ ret.push_back(true);
+ else
+ ret.push_back(false);
+ }
+ return(ret);
+ }
+
+ std::vector<bool> get_class_indicators(){
+ std::vector<bool> ret;
+ int o;
+ for(o=0;o<ef_param_list.size();o++){
+ if(ef_param_list[o]->is_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<data_type *> odt = this->get_operand_dt();
+ for(o=0;o<odt.size();++o){
+ if(odt[o]->get_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<ext_fcn_def *> 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<data_type *> odt, int type){
+ int f, o;
+ int subsumer = -1;
+ int subsume_cnt;
+ for(f=0;f<fl.size();f++){
+ if(fl[f]->get_fcn_type() != type) continue;
+ if(fname == fl[f]->get_fcn_name()){
+ subsume_cnt = 0;
+ std::vector<data_type *> fdt = fl[f]->get_operand_dt();
+ if(fdt.size() != odt.size())
+ continue;
+ for(o=0;o<odt.size();o++){
+ if(! fdt[o]->subsumes_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<data_type *> odt){
+ return lookup_ext_fcn(fname,odt,EXT_PRED_);
+ };
+ int lookup_fcn(std::string fname, const std::vector<data_type *> odt){
+ return lookup_ext_fcn(fname,odt,EXT_FCN_);
+ };
+ int lookup_udaf(std::string fname, const std::vector<data_type *> odt){
+ return lookup_ext_fcn(fname,odt,EXT_AGGR_);
+ };
+ int lookup_extr(std::string fname, const std::vector<data_type *> odt){
+ return lookup_ext_fcn(fname,odt,EXT_EXTR_);
+ };
+ int lookup_state(std::string fname){
+ std::vector<data_type *> dum;
+ return lookup_ext_fcn(fname,dum,EXT_STATE_);
+ };
+ int lookup_sfun(std::string fname, const std::vector<data_type *> 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<bool> get_handle_indicators(int f){
+ return(fl[f]->get_handle_indicators());
+ };
+ std::vector<bool> get_const_indicators(int f){
+ return(fl[f]->get_const_indicators());
+ };
+ std::vector<bool> 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;e<fl.size();++e){
+ if(fl[e]->validate_types(err)) retval = 1;
+ }
+ if(retval) return(true);
+
+// validate combinable predicates
+ for(e=0;e<fl.size();++e){
+ if(fl[e]->is_pred() && fl[e]->is_combinable()){
+ std::vector<bool> hlv = fl[e]->get_handle_indicators();
+ std::vector<bool> cov = fl[e]->get_const_indicators();
+ std::vector<bool> clv = fl[e]->get_class_indicators();
+ int i;
+ for(i=0;i<hlv.size();++i){
+ if( hlv[i] == false && cov[i] == false && clv[i] == false)
+ break;
+ }
+ if(i<hlv.size()){
+ err += "ERROR, in combinable predicate "+fl[e]->get_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;i<hlv.size();++i){
+ printf("\t%d: h=%d, co=%d, cl=%d\n",i,(int)hlv[i],(int)cov[i],(int)clv[i]);
+ }
+ }
+ }
+ }
+
+
+
+// validate the states of the stateful functions.
+ for(e=0;e<fl.size();++e){
+ if(fl[e]->is_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;e<fl.size();++e){
+ if(fl[e]->is_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<data_type *> 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;e<fl.size();++e){
+ if(fl[e]->is_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<data_type *> 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;e<fl.size();++e){
+ if(fl[e]->is_extr()){
+//printf("Verifying extractor %d\n",e);
+ std::vector<data_type *> ope = fl[e]->get_operand_dt();
+// Find the subaggregate
+ int a;
+ for(a=0;a<fl.size();++a){
+ if(fl[a]->is_udaf() && fl[e]->get_udaf_name() == fl[a]->get_fcn_name()){
+//printf("matching to subaggregagte %d\n",a);
+ std::vector<data_type *> opa = fl[a]->get_operand_dt();
+ if(opa.size() > ope.size()) continue;
+ int o;
+ bool match_ops = true;
+ for(o=0;o<opa.size();++o){
+ if(! ope[o]->equals(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<data_type *> opa = fl[a]->get_operand_dt();
+
+// Find the actual function
+ for(f=0;f<fl.size();++f){
+ if(fl[f]->is_fcn() && fl[e]->get_actual_fcn() == fl[f]->get_fcn_name()){
+//printf("Matching to extraction function %d\n",f);
+ std::vector<data_type *> 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;o<opf.size();++o){
+ if(! ope[o+opa.size()-1]->equals(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
--- /dev/null
+/* ------------------------------------------------
+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<stdio.h>
+#include<ctype.h>
+
+ 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 <string>
+#include <vector>
+#include <map>
+#include <math.h>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+// 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<var_pair_t *> 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<var_pair_t *> get_nvec(){return namevec;};
+
+ int size(){return namevec.size();};
+
+ int find_name(std::string n){
+ int i;
+ for(i=0;i<namevec.size();i++){
+ if(namevec[i]->name == n)
+ return i;
+ }
+ return -1;
+ }
+ std::string get_name(int i){
+ if(i>=0 && i<namevec.size()){
+ return(namevec[i]->name);
+ }else{
+ return("");
+ }
+ }
+
+ std::string get_def(int i){
+ if(i>=0 && i<namevec.size()){
+ return(namevec[i]->val);
+ }else{
+ return("");
+ }
+ }
+
+ std::string dump(){
+ int i;
+ std::string ret;
+ for(i=0;i<namevec.size();++i){
+ ret += "\t"+namevec[i]->name+" = "+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<len;++i){
+ if(v[i] == 'U') v[i] = '\0';
+ }
+ lstring = v;
+ }
+
+// HEX and LONGHEX must be converted to uint (long long uint)
+ if(ltype == LITERAL_HEX){
+ char *c,ltmpstr[100];
+ unsigned long tmp_l;
+ 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 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;i<s.size();++i){
+ c = s[i];
+ if(c=='\''){ // || c=='\\'
+ if(prev_c==c){
+ retval += c;
+ prev_c = '\0';
+ }else{
+ prev_c=c;
+ }
+ continue;
+ }
+
+ retval += c;
+ prev_c = c;
+ }
+
+ return retval;
+ }
+
+
+
+ std::string to_hfta_C_code(std::string param){
+ std::string retval;
+ double tmp_f;
+ int secs, millisecs;
+ char tmpstr[100];
+
+ switch(ltype){
+ case LITERAL_STRING:
+ retval.append(this->hfta_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<literal_t *> 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<literal_t *> 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;i<lit_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(lit_list[i]->to_query_string());
+ }
+ return(retval);
+ };
+
+ std::vector<literal_t *> 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<tablevar_t *> 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<tablevar_t *> 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;i<tlist.size();++i){
+ ret->append_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;i<tlist.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(tlist[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<tablevar_t *> get_table_list(){return(tlist); };
+
+ std::vector<std::string> get_table_names(){
+ std::vector<std::string> ret;
+ int t;
+ for(t=0;t<tlist.size();++t){
+ std::string tbl_name = tlist[t]->get_schema_name();
+ ret.push_back(tbl_name);
+ }
+ return(ret);
+ }
+
+ std::vector<std::string> get_src_tbls(table_list *Schema){
+ std::vector<std::string> ret;
+ int t, sq;
+ for(t=0;t<tlist.size();++t){
+ std::string tbl_name = tlist[t]->get_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<subquery_spec *> sqspec = Schema->get_subqueryspecs(sid);
+ for(sq=0;sq<sqspec.size();++sq){
+ ret.push_back(sqspec[sq]->name);
+ }
+ }
+ }
+ return(ret);
+ };
+
+ int size(){
+ return tlist.size();
+ };
+
+// Some accessor functions.
+
+ std::vector<std::string> get_schema_names(){
+ int i;
+ std::vector<std::string > retval;
+ for(i=0;i<tlist.size();i++){
+ retval.push_back(tlist[i]->get_schema_name());
+ }
+ return(retval);
+ }
+
+ std::vector<int> get_schema_refs(){
+ int i;
+ std::vector<int> retval;
+ for(i=0;i<tlist.size();i++){
+ retval.push_back(tlist[i]->get_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<colref_t *> 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<colref_t *> 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<scalarexp_t *> 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<scalarexp_t *> 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<scalarexp_t *> 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<scalarexp_t *> 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;i<se_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(se_list[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<scalarexp_t *> 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_element *> 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;i<select_list.size();i++){
+ if(i>0) 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<select_element *> get_select_list(){return select_list; };
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0; i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ 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_t *> 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;i<gb_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(gb_list[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<gb_t *> 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;i<gb_list.size();++i){
+ ret->append(gb_list[i]->duplicate());
+ }
+
+ return ret;
+ }
+
+
+};
+
+class list_of_gb_list_t{
+public:
+ std::vector<gb_list_t *> 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_list_t *> 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;i<gb_lists.size();++i){
+ ret->gb_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;i<gb_lists.size();++i){
+ if(i>0) 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<extended_gb_t *> 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;i<gb_list.size();i++){
+ if(i>0) retval.append(", ");
+ retval.append(gb_list[i]->to_string());
+ }
+ return(retval);
+ };
+
+ std::vector<extended_gb_t *> 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<scalarexp_t *> 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<literal_t *> 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<scalarexp_t *> 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;i<param_list.size();++i){
+ if(i>0) ret += ", ";
+ ret += param_list[i]->to_string();
+ }
+ ret += "] ";
+ return(ret);
+ }
+ return("");
+ };
+
+ std::vector<scalarexp_t *> 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<literal_t *> 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<var_pair_t *> 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<extended_gb_t *> gb; // GROUP BY
+ std::vector<colref_t *> mergevars; // merge colrefs.
+ std::vector<colref_t *> 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<std::string> 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;t<src_tbls.size();++t){
+ ret->fm->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;n<vd->size();++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<select_element *> 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<extended_gb_t *> get_groupby(){return(gb); };
+ std::vector<colref_t *> 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<table_exp_t *> 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
+
--- /dev/null
+/* ------------------------------------------------
+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<scalarexp_t *> 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;i<se_list.size();++i){
+ int ret = verify_colref(se_list[i],&fm,schema,NULL);
+ if(ret){
+ err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+".\n";
+ retval=1;
+ }
+ }
+ if(retval)
+ return 1;
+
+// Ensure that the data type is an integer type.
+ for(i=0;i<se_list.size();++i){
+ data_type *dt = se_list[i]->get_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_list.size();++i){
+ string fld;
+ int ret = find_field(se_list[i],fld);
+ if(ret<0){
+ err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+".\n";
+ retval=1;
+ }
+ if(ret!=1){
+ err_msg += "ERROR validating entry "+int_to_string(i)+" of partition definition "+name+": the expression references a field "+int_to_string(ret)+" times, but it should reference a field exactly once.\n";
+ retval=1;
+ field_list.push_back("");
+ }else{
+ field_list.push_back(fld);
+ }
+ }
+ if(retval)
+ return 1;
+
+ return 0;
+
+}
+
+void find_colref_path(scalarexp_t *se, vector<scalarexp_t *> &se_stack){
+ vector<scalarexp_t *> 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;o<operands.size();o++){
+ find_colref_path(operands[o], se_stack);
+ if(se_stack.size()>0){
+ 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 shift_right(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<scalarexp_t *> 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(ppos<pstack.size()-1 && gpos<gstack.size()-1){
+
+// first, try to raise both stack pointers.
+ if(ppos<pstack.size()-1 && gpos<gstack.size()-1){
+ p_op = pstack[ppos+1]->get_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(ppos<pstack.size()-1){
+ p_op = pstack[ppos+1]->get_op();
+ if(p_op=="+" || p_op=="-" || p_op=="*" || p_op=="/" || p_op=="&" || p_op=="|"){
+ ppos++;
+ continue;
+ }
+ }
+ if(gpos<gstack.size()-1){
+ g_op = gstack[gpos+1]->get_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<string> gb_flds;
+ int i,p,g;
+
+ for(i=0;i<gb_tbl->size();++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;p<se_list.size();++p){
+ for(g=0;g<gb_tbl->size();++g){
+ if(partition_compatible(se_list[p], gb_tbl->get_def(g)))
+ break;
+ }
+ if(g==gb_tbl->size()){
+ return false;
+ }
+ }
+ return true;
+}
--- /dev/null
+/* ------------------------------------------------
+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<stdio.h>
+#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<scalarexp_t *> se_list;
+ std::vector<std::string> 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<std::string, partn_def_t *> 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<std::string, partn_def_t *>::iterator mspi;
+ for(mspi=partn_map.begin(); mspi!=partn_map.end();++mspi){
+ if((*mspi).second->verify(schema, err_msg))
+ retval=1;
+ }
+ return retval;
+ }
+
+
+};
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+#include"parse_fta.h"
+#include "parse_schema.h"
+#include "type_objects.h"
+#include <stdio.h>
+#include <stdlib.h>
+// #include <algo.h>
+#include<algorithm>
+
+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;i<qspec_list.size();++i){
+ subquery_spec *s = qspec_list[i]->duplicate();
+ s->name += mngl;
+ qspec_list[i] = s;
+ }
+}
+
+
+
+bool table_def::contains_field(string f){
+ int i;
+
+ for(i=0;i<fields.size();i++){
+ if(fields[i]->get_name() == f){
+ return(true);
+ }
+ }
+ return(false);
+
+}
+
+int table_def::get_field_idx(std::string f){
+ int i;
+ for(i=0;i<fields.size();i++){
+ if(fields[i]->get_name() == f){
+ return(i);
+ }
+ }
+ return(-1);
+}
+
+
+string table_def::get_type_name(std::string f){
+ int i;
+ for(i=0;i<fields.size();i++){
+ if(fields[i]->get_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;i<fields.size();i++){
+ if(fields[i]->get_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;i<fields.size();i++){
+ if(fields[i]->get_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;i<fields.size();i++){
+ if(fields[i]->get_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;f1<fields.size()-1;f1++){
+ string f1_name = fields[f1]->get_name();
+ for(f2=f1+1;f2<fields.size();f2++){
+ if(f1_name == fields[f2]->get_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;f<fields.size();++f){
+ if(fields[f]->get_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;f<fields.size();f++){
+ if(fe_name == fields[f]->get_name()){
+ return(-1);
+ }
+ }
+ fields.push_back(fe);
+ return(0);
+}
+
+
+vector<string> table_list::get_table_names(){
+ vector<string> retval;
+ int i;
+ for(i=0;i<tbl_list.size();i++){
+ retval.push_back(tbl_list[i]->get_tbl_name());
+ }
+ return(retval);
+}
+
+
+int table_list::find_tbl(string t){
+ int i;
+ for(i=0;i<tbl_list.size();i++)
+ if(tbl_list[i]->get_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<field_entry *> table_list::get_fields(string t){
+ int pos = find_tbl(t);
+ if(pos<0){
+ vector<field_entry *> 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<int> table_list::get_tblref_of_field(string f){
+ int i;
+ vector<int> retval;
+
+ for(i=0;i<tbl_list.size();i++){
+ if( tbl_list[i]->contains_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;i<tbl_list.size();i++){
+ if(tbl_list[i]->get_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;t<tbl_list.size();t++){
+ if(tbl_list[t]->get_schema_type() == UNPACK_FCNS_SCHEMA){
+ for(f=0;f<tbl_list[t]->ufcn_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;t<tbl_list.size();t++){
+ if(tbl_list[t]->get_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<field_entry *> flds = tbl_list[t]->get_fields();
+ for(f=0;f<flds.size();++f){
+ data_type dt(flds[f]->get_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<flds.size();++f){
+ set<string> ufcns = flds[f]->get_unpack_fcns();
+ set<string>::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<field_entry *> fev = tbl_list[t]->get_fields();
+ for(f=0;f<fev.size();++f)
+ fev[f]->set_basetable(tbl_name);
+ }
+ }
+
+ if(retval) return(retval);
+
+// Next, build a predecessors graph.
+// Verify that all referenced tables exist.
+
+ vector< vector<int> > predecessors; // list of tables inherited from.
+ vector<int> n_pred; // number of (remaining) predecessors.
+ // -1 indicates a processed table.
+
+ for(t=0;t<tbl_list.size();t++){
+ if(tbl_list[t]->get_schema_type() != UNPACK_FCNS_SCHEMA){
+ vector<string> pred_tbls = tbl_list[t]->get_pred_tbls();
+ vector<int> pred_ref;
+ for(p=0;p<pred_tbls.size();p++){
+ tref = this->get_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<int> 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<n_total;r++){
+ if(n_pred[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<field_entry *> pred_fields = tbl_list[root]->get_fields();
+
+
+// Scan for all successors of the root.
+ int s, f;
+ for(s=0;s<n_total;s++){
+ if(find((predecessors[s]).begin(), (predecessors[s]).end(), root) !=
+ (predecessors[s]).end() ){
+
+// s is a successor : add the fields from the root.
+ for(f=0;f<pred_fields.size();f++){
+ retval = tbl_list[s]->add_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<string, string>::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;f<fields.size();f++){
+ retval += "\t" + fields[f]->to_string() + ";\n";
+ }
+
+ if(schema_type == OPERATOR_VIEW_SCHEMA){
+ retval += "\tSUBQUERIES{\n";
+ for(q=0;q<qspec_list.size();++q){
+ if(q>0) 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;t<tbl_list.size();t++){
+ retval += tbl_list[t]->to_string();
+ retval += "\n";
+ }
+ return(retval);
+}
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+#include <vector>
+#include <map>
+#include<set>
+
+#include <string.h>
+#include <stdlib.h>
+
+
+// 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<std::string> get_key_vec(){
+ std::vector<std::string> retval;
+ std::map<std::string, std::string>::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<std::string> svec;
+ std::vector<std::string> nvec;
+ std::vector<param_list *> 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<std::string> 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<std::string> tmp_ufl = ulist->get_key_vec();
+ for(u=0;u<tmp_ufl.size();++u)
+ ufcns.insert(tmp_ufl[u]);
+ }
+
+ type=t; name=n; function=f;
+ base_table = "";
+ };
+
+ field_entry(std::string t, std::string n, std::string f, param_list *plist, const std::set<std::string> &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<std::string> new_ufl = ufl->get_key_vec();
+ int u;
+ for(u=0;u<new_ufl.size();++u)
+ ufcns.insert(new_ufl[u]);
+ }
+
+
+ param_list *get_modifier_list(){return mod_list; };
+ std::string get_type(){return(type);};
+ std::string get_name(){return(name);};
+ std::string get_fcn(){return(function);};
+ std::set<std::string> 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<field_entry *> 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<field_entry *> get_list(){return fl; };
+};
+
+class subquery_spec{
+public:
+ std::string name;
+ std::vector<std::string> types;
+ std::vector<std::string> names;
+ std::vector<param_list *> 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;i<types.size();++i){
+ if(i>0) 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<subquery_spec *> 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<unpack_fcn *> 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<field_entry *> 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<subquery_spec *> qspec_list;
+ param_list *selpush;
+
+public:
+// for unpacking function group specs.
+ std::vector<unpack_fcn *> 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;f<fields.size();++f)
+ fields[f]->add_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<field_entry *> get_fields(){return(fields); };
+
+ field_entry *get_field(int i){
+ if(i>=0 && i<fields.size()) return(fields[i]);
+ return NULL;
+ };
+
+ std::string get_field_name(int i){
+ if(i>=0 && i<fields.size()) return(fields[i]->get_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<std::string> get_pred_tbls(){
+ return base_tables->get_key_vec() ;
+ };
+
+ int add_field(field_entry *fe);
+
+ int get_schema_type(){return schema_type;};
+
+ std::vector<subquery_spec *> 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<table_def *> tbl_list;
+ // for an unpack_fcn_list, collect from the set of
+ // UNPACK_FCNS_SCHEMA in the table list.
+ std::map<std::string, std::string> ufcn_fcn;
+ std::map<std::string, int> 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<std::string> get_table_names();
+
+ std::vector<field_entry *> 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<int> 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<subquery_spec *> 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
--- /dev/null
+/* ------------------------------------------------
+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 <string.h>
+
+
+
+#include "partn.tab.cc.h"
+
+/*
+ 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 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<flex_partn_ch;i++){
+ if(flex_partn_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_partn_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_PartnParser_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 */
+
+HEX { flex_partn_ch+=PartnParserleng; return HEX_L;}
+LHEX { flex_partn_ch+=PartnParserleng; return LHEX_L;}
+IP_VAL { flex_partn_ch+=PartnParserleng; return IP_L;}
+
+
+
+ /* punctuation */
+
+[;%&|!+*/:(),.\[\]$@#] { flex_partn_ch+=PartnParserleng; return yytext[0]; }
+"-" { flex_partn_ch+=PartnParserleng; return yytext[0]; }
+"~" { flex_partn_ch+=PartnParserleng; return yytext[0]; }
+
+ /* names */
+
+[A-Za-z_][A-Za-z0-9_]* { flex_partn_ch+=PartnParserleng; PartnParserlval.strval = strdup(yytext); return NAME; }
+
+ /* numbers */
+
+[0-9]+ |
+[0-9]+UL { flex_partn_ch+=PartnParserleng; PartnParserlval.strval = strdup(yytext); return INTNUM; }
+
+[0-9]+ULL { flex_partn_ch+=PartnParserleng; PartnParserlval.strval = strdup(yytext); return LONGINTNUM; }
+
+
+ /* strings */
+
+ /* */
+ /* Newline : advance the error reporting line number */
+ /* and grab the next line into flex_partn_linebuf */
+ /* */
+
+\n.* {flex_partn_ch=0; flex_partn_lineno++;
+ strcpy(flex_partn_linebuf,PartnParsertext+1);
+ yyless(1);
+ }
+
+[ \t\r]+ {flex_partn_ch+=PartnParserleng; } /* white space */
+
+"--".*$ {flex_partn_ch+=PartnParserleng; }; /* comment */
+"//".*$ {flex_partn_ch+=PartnParserleng; }; /* comment */
+
+.|\n {flex_partn_ch+=PartnParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); PartnParsererror(yytext);}
+
+%%
+
+int my_PartnParser_yyinput(char *buf, int max_size){
+ int c = 0;
+ int inchar = 0;
+
+ if(flex_partn_stringinput != NULL){
+ while(c<max_size){
+ if(flex_partn_stringinput[flex_partn_stringinput_ptr] != '\0'){
+ buf[c++] = flex_partn_stringinput[flex_partn_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_partn_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_partn_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void PartnParser_setfileinput(FILE *f){
+ PartnParserrestart(NULL);
+
+ flex_partn_fileinput = f;
+ flex_partn_stringinput = NULL;
+ flex_partn_lineno = 1;
+ flex_partn_ch = 0;
+}
+
+void PartnParser_setstringinput(char *s){
+ PartnParserrestart(NULL);
+
+ flex_partn_fileinput = NULL;
+ flex_partn_stringinput = s;
+ flex_partn_stringinput_ptr = 0;
+ flex_partn_lineno = 1;
+ flex_partn_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* 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. */
+
+/* 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 PartnParserparse
+#define yylex PartnParserlex
+#define yyerror PartnParsererror
+#define yylval PartnParserlval
+#define yychar PartnParserchar
+#define yydebug PartnParserdebug
+#define yynerrs PartnParsernerrs
+
+
+/* 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
+
+
+
+
+/* Copy the first part of user declarations. */
+#line 8 "partn.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 "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 <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) \
+ || (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 <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 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 <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)
+/* 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
+
+\f
+
+#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 */
+
+\f
+
+#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;
+ }
+}
+
+\f
+
+/* 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"
+\f
+ 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"
+
+
+
--- /dev/null
+/* 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 */
+
--- /dev/null
+/* ------------------------------------------------
+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 <stdio.h>
+
+/* Some addn'l includes, necessary but not included by the
+ bison generated code.
+*/
+
+#include <stdlib.h>
+
+/* 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 <strval> NAME
+%token <strval> STRING_TOKEN
+%token <strval> INTNUM
+%token <strval> LONGINTNUM
+
+/* for FTA definition. */
+%type <litval> literal
+%type <colref> column_ref
+%type <scalarval> scalar_exp
+%type <se_listval> scalar_exp_commalist
+%type <pdl> partn_def_list
+%type <pd> 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); }
+ ;
+
+
+%%
+
--- /dev/null
+#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 <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; \
+ 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 <string.h>
+
+
+
+#include "partn.tab.cc.h"
+
+/*
+ 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 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<flex_partn_ch;i++){
+ if(flex_partn_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_partn_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_PartnParser_yyinput(b,ms))
+
+/* MKS needs the next line to increase the NFA table */
+#line 491 "partnlexer.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 "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<max_size){
+ if(flex_partn_stringinput[flex_partn_stringinput_ptr] != '\0'){
+ buf[c++] = flex_partn_stringinput[flex_partn_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_partn_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_partn_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void PartnParser_setfileinput(FILE *f){
+ PartnParserrestart(NULL);
+
+ flex_partn_fileinput = f;
+ flex_partn_stringinput = NULL;
+ flex_partn_lineno = 1;
+ flex_partn_ch = 0;
+}
+
+void PartnParser_setstringinput(char *s){
+ PartnParserrestart(NULL);
+
+ flex_partn_fileinput = NULL;
+ flex_partn_stringinput = s;
+ flex_partn_stringinput_ptr = 0;
+ flex_partn_lineno = 1;
+ flex_partn_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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 __PRINT_PLAN_H
+#define __PRINT_PLAN_H
+
+
+#include <stdio.h>
+#include <vector>
+#include <set>
+#include <stdlib.h>
+using namespace std;
+
+
+int print_qp_node(FILE* fd, int i, stream_query* query, map<string, int>& lfta_names, map<string, int>& 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<tablevar_t *> 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<string, int>& lfta_names) {
+
+ fprintf(fd, "HFTA %s\n", query->query_name.c_str());
+
+
+ vector<tablevar_t *> tmp_tv = query->get_input_tables();
+ int itv;
+ map<string, int> fta_names;
+
+ for(itv=0;itv<tmp_tv.size();++itv) {
+ fta_names[tmp_tv[itv]->get_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<stream_query *>& hfta_list, map<string, int>& lfta_names, vector<string>& query_names, vector<string>& 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
--- /dev/null
+/* ------------------------------------------------
+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<vector>
+
+using namespace std;
+
+extern string hash_nums[NRANDS]; // for fast hashing
+
+
+char tmpstr[1000];
+
+void untaboo(string &s){
+ int c;
+ for(c=0;c<s.size();++c){
+ if(s[c] == '.'){
+ s[c] = '_';
+ }
+ }
+}
+
+// mrg_qpn constructor, define here to avoid
+// circular references in the .h file
+mrg_qpn::mrg_qpn(filter_join_qpn *spx, std::string n_name, std::vector<std::string> &sources, std::vector<std::pair<std::string, std::string> > &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;i<spx->select_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;i<sources.size();i++){
+ std::string rvar = "_m"+int_to_string(i);
+ mvars.push_back(new colref_t(rvar.c_str(), spx->select_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<std::string> param_names = spx->param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = spx->param_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<qp_node *> create_query_nodes(query_summary_class *qs,table_list *Schema){
+
+// Classify the query.
+
+ vector <qp_node *> 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<mrg_qpn *> 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;i<split_merge.size();++i){
+ Schema->add_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;ss<local_plan.size();ss++){
+printf("node %d, name=%s, sources=",ss,local_plan[ss]->get_node_name().c_str());
+vector<tablevar_t *> inv = local_plan[ss]->get_input_tbls();
+int nn;
+for(nn=0;nn<inv.size();nn++){
+printf("%s ",inv[nn]->to_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<scalarexp_t *> 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;p<operand_list.size();p++){
+ l_str = se_to_query_string(operand_list[p],aggr_tbl);
+ if(p>0) 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<literal_t *> llist;
+ vector<scalarexp_t *> 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;l<llist.size();l++){
+ if(l>0) 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;o<op_list.size();++o){
+ if(o>0) 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<select_element *> &lfta_select_list, scalarexp_t *se,
+ bool &new_element){
+ new_element = false;
+ int s;
+ for(s=0;s<lfta_select_list.size();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<select_element *> &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<select_element *> *lfta_select_list, scalarexp_t *se,
+ bool &new_element){
+ new_element = false;
+ int s;
+ for(s=0;s<lfta_select_list->size();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<vector<select_element *> *> &lfta_select_list, scalarexp_t *se, int h_tvref){
+ bool new_element;
+ vector<select_element *> *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<scalarexp_t *> operand_list;
+ vector<data_type *> 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;p<operand_list.size();p++){
+ if(!check_fta_forbidden_se(operand_list[p],aggr_tbl, Ext_fcns))
+ return(false);
+ dt_signature.push_back(operand_list[p]->get_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;o<operand_list.size();o++){
+ if(o>0) 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<literal_t *> llist;
+ data_type *dt;
+ int l,o, fcn_id;
+ vector<scalarexp_t *> op_list;
+ vector<data_type *> 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;l<llist.size();l++){
+ dt = new data_type(llist[l]->get_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;o<op_list.size();o++){
+ if(!check_fta_forbidden_se(op_list[o],aggr_tbl, Ext_fcns))
+ return(false);
+ dt_signature.push_back(op_list[o]->get_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;o<op_list.size();o++){
+ if(o>0) 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<select_element *> &lfta_select_list,
+ map<int,scalarexp_t *> &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<scalarexp_t *> 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<scalarexp_t *> opl = orig_aggr_tbl->get_operand_list(agr_id);
+ vector<scalarexp_t *> subopl;
+ int o;
+ for(o=0;o<opl.size();++o){
+ subopl.push_back(dup_se(opl[o], NULL));
+ }
+ int sub_id = Ext_fcns->get_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<bool> use_se;
+ vector<string> subaggr_names = orig_aggr_tbl->get_subaggr_fcns(agr_id, use_se);
+ vector<data_type *> subaggr_dt = orig_aggr_tbl->get_subaggr_dt(agr_id);
+ int sa;
+
+ if(orig_aggr_tbl->is_star_aggr(agr_id)){
+ for(sa=0;sa<subaggr_names.size();sa++){
+ subaggr_se = scalarexp_t::make_star_aggr(subaggr_names[sa].c_str());
+ subaggr_se->set_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;sa<subaggr_names.size();sa++){
+ if(use_se[sa]){
+ scalarexp_t *aggr_operand = orig_aggr_tbl->get_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<select_element *> &low_select_list,
+ map<int,scalarexp_t *> &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<scalarexp_t *> 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<scalarexp_t *> opl = orig_aggr_tbl->get_operand_list(agr_id);
+ vector<scalarexp_t *> subopl;
+ int o;
+ for(o=0;o<opl.size();++o){
+ subopl.push_back(dup_se(opl[o], NULL));
+ }
+ int sub_id = Ext_fcns->get_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<bool> use_se;
+ vector<string> subaggr_names = orig_aggr_tbl->get_subaggr_fcns(agr_id, use_se);
+ vector<data_type *> subaggr_dt = orig_aggr_tbl->get_subaggr_dt(agr_id);
+ int sa;
+
+ if(orig_aggr_tbl->is_star_aggr(agr_id)){
+ for(sa=0;sa<subaggr_names.size();sa++){
+ subaggr_se = scalarexp_t::make_star_aggr(subaggr_names[sa].c_str());
+ subaggr_se->set_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;sa<subaggr_names.size();sa++){
+ if(use_se[sa]){
+ scalarexp_t *aggr_operand = orig_aggr_tbl->get_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<select_element *> &lfta_select_list,
+ ext_fcn_list *Ext_fcns
+ ){
+
+ int p, fcn_id;
+ vector<scalarexp_t *> operand_list;
+ vector<data_type *> 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<scalarexp_t *> new_operands;
+ vector<bool> forbidden_op;
+ for(p=0;p<operand_list.size();p++){
+ l_se = split_fta_se(operand_list[p], l_forbid, lfta_select_list, Ext_fcns);
+
+ fta_forbidden |= l_forbid;
+ new_operands.push_back(l_se);
+ forbidden_op.push_back(l_forbid);
+ dt_signature.push_back(operand_list[p]->get_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;o<operand_list.size();o++){
+ if(o>0) 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;p<new_operands.size();p++){
+ if(! forbidden_op[p]){
+// if(new_operands[p]->get_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<select_element *> &lfta_select_list,
+ ext_fcn_list *Ext_fcns
+ ){
+
+ vector<literal_t *> llist;
+ scalarexp_t *se_l, *se_r;
+ bool l_forbid, r_forbid;
+ predicate_t *ret_pr, *pr_l, *pr_r;
+ vector<scalarexp_t *> op_list, new_op_list;
+ int o;
+ vector<data_type *> 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;o<op_list.size();++o){
+ se_l = split_fta_se(op_list[o],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;
+ }
+ }
+ new_op_list.push_back(se_l);
+ }
+
+ ret_pr = new predicate_t(pr->get_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<select_element *> *> &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<select_element *> *> &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<scalarexp_t *> operand_list;
+ vector<data_type *> 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<scalarexp_t *> new_operands;
+ vector<bool> forbidden_op;
+ vector<int> csource;
+
+ fta_forbidden = false;
+ colref_source = SPLIT_FTAVEC_NOTBLVAR;
+ for(p=0;p<operand_list.size();p++){
+ l_se = split_ftavec_se(operand_list[p], l_forbid, l_csource, lfta_select_list, Ext_fcns);
+
+ fta_forbidden |= l_forbid;
+ colref_source = combine_colref_source(colref_source, l_csource);
+ new_operands.push_back(l_se);
+ forbidden_op.push_back(l_forbid);
+ csource.push_back(l_csource);
+ dt_signature.push_back(operand_list[p]->get_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;o<operand_list.size();o++){
+ if(o>0) 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;p<new_operands.size();p++){
+ if(! forbidden_op[p] && is_PROTOCOL_source(csource[p], lfta_select_list)){
+ if(!is_literal_or_param_only(new_operands[p])){
+ new_se = make_fta_se_ref(lfta_select_list, new_operands[p],csource[p]);
+ 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 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<select_element *> *> &lfta_select_list,
+ ext_fcn_list *Ext_fcns
+ ){
+
+ vector<literal_t *> 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<scalarexp_t *> op_list, new_op_list;
+ int o;
+ vector<data_type *> 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;o<op_list.size();++o){
+ se_l = split_ftavec_se(op_list[o],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;
+ }
+ }
+ new_op_list.push_back(se_l);
+ }
+
+ ret_pr = new predicate_t(pr->get_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<scalarexp_t *> 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<scalarexp_t *> 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;p<operand_list.size();p++){
+ l_se = rehome_fta_se(operand_list[p], aggr_map);
+
+ new_operands.push_back(l_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 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<int, scalarexp_t *> *aggr_map
+ ){
+
+ vector<literal_t *> llist;
+ scalarexp_t *se_l, *se_r;
+ predicate_t *ret_pr, *pr_l, *pr_r;
+ vector<scalarexp_t *> 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;o<op_list.size();++o){
+ se_l = rehome_fta_se(op_list[o], aggr_map);
+ new_op_list.push_back(se_l);
+ }
+ ret_pr= new predicate_t(pr->get_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_element *> &select_list){
+ int s;
+
+
+// Create a new STREAM schema for the output of the FTA.
+
+ field_entry_list *fel = new field_entry_list();
+ set<string> ufcns;
+ for(s=0;s<select_list.size();s++){
+ scalarexp_t *sel_se = select_list[s]->se;
+ 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<string> param_strings = dt->get_param_keys();
+ int p;
+ for(p=0;p<param_strings.size();++p){
+ string v = dt->get_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;s<select_list.size();s++){
+ if(s>0) 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;w<where.size();w++){
+ if(w>0) 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;s<select_list.size();s++){
+ if(s>0) 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;w<where.size();w++){
+ if(w>0) 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;g<gb_tbl.size();g++){
+ if(g>0) 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;g<gb_tbl.gb_entry_type.size();++g){
+ if(g>0) 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;gg<gb_tbl.gb_entry_count[g];++gg){
+ if(gg>0) 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<vector<bool> > &local_components = gb_tbl.pattern_components[g];
+ for(g1=0;g1<local_components.size();++g1){
+ if(g1>0) 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;h<having.size();h++){
+ if(h>0) 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;s<select_list.size();s++){
+ if(s>0) 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;w<where.size();w++){
+ if(w>0) 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;g<gb_tbl.size();g++){
+ if(g>0) 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;h<having.size();h++){
+ if(h>0) 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;h<closing_when.size();h++){
+ if(h>0) 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;s<select_list.size();s++){
+ if(s>0) 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;w<where.size();w++){
+ if(w>0) 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;g<gb_tbl.size();g++){
+ if(g>0) 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<gb_tbl.size();g++){
+ if(sg_tbl.count(g)){
+ if(first_elem){
+ ret += ", ";
+ first_elem = false;
+ }
+ ret += gb_tbl.get_name(g);
+ }
+ }
+ ret += "\n";
+ }
+
+ if(having.size() > 0){
+ ret += "Having ";
+ int h;
+ for(h=0;h<having.size();h++){
+ if(h>0) 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;h<cleanwhen.size();h++){
+ if(h>0) 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;h<cleanby.size();h++){
+ if(h>0) 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;t<fm.size();++t){
+ if(t>0) 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;s<select_list.size();s++){
+ if(s>0) 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;f<from.size();++f){
+ if(f>0) ret+=", ";
+ ret += from[f]->to_string();
+ }
+ ret += "\n";
+
+ if(where.size() > 0){
+ ret += "Where ";
+ int w;
+ for(w=0;w<where.size();w++){
+ if(w>0) 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;s<select_list.size();s++){
+ if(s>0) 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;f<from.size();++f){
+ if(f>0) ret+=", ";
+ ret += from[f]->to_string();
+ }
+ ret += "\n";
+
+ if(where.size() > 0){
+ ret += "Where ";
+ int w;
+ for(w=0;w<where.size();w++){
+ if(w>0) ret += " AND ";
+ ret += "(" + pred_to_query_str(where[w]->pr,NULL) + ")";
+ }
+ ret += "\n";
+ }
+
+ return(ret);
+}
+
+
+// -----------------------------------------------------------------
+// Query node subclass specific processing.
+
+
+vector<mrg_qpn *> mrg_qpn::split_sources(){
+ vector<mrg_qpn *> 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;ff<fm.size();++ff){
+printf("%s ",fm[ff]->to_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;i<new_mrg->fm.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;i<this->fm.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;i<this->fm.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(;i<this->fm.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;i<new_mrg1->mvars.size();++i)
+ new_mrg1->mvars[i]->set_tablevar_ref(i);
+ for(i=0;i<new_mrg2->mvars.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;i<new_mrg1->fm.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;i<new_mrg2->fm.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<mrg_qpn *> st1 = new_mrg1->split_sources();
+ ret.insert(ret.end(), st1.begin(), st1.end());
+ vector<mrg_qpn *> 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<pair<string,string> > get_ifaces(tablevar_t *table, ifq_t *ifdb, int n_virtual_ifaces, int hfta_parallelism, int hfta_idx){
+ vector<pair<string,string> > 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<pair<string,string> > ifaces;
+
+ for(i=0;i<basic_ifaces.size();++i){
+ string mach = basic_ifaces[i].first;
+ string iface = basic_ifaces[i].second;
+ for(s=hfta_idx*stride;s<(hfta_idx+1)*stride;++s){
+ ifaces.push_back(pair<string, string>(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<pair<string, string> > &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<sources.size();++s){
+ string src_machine = sources[s].first;
+ string src_iface = sources[s].second;
+ vector<string> slack_vec = ifdb->get_iface_vals(src_machine, src_iface,rname,e,es);
+ for(v=0;v<slack_vec.size();++v){
+ if(sscanf(slack_vec[v].c_str(),"%qd",&this_slacker)){
+ if(this_slacker > 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<qp_node *> 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<qp_node *> ret_vec;
+
+ ret_vec.push_back(this);
+ return(ret_vec);
+
+}
+
+vector<qp_node *> 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<qp_node *> ret_vec;
+
+// First check if the query can be pushed to the FTA.
+ bool fta_ok = true;
+ int s;
+ for(s=0;s<select_list.size();s++){
+ fta_ok &= check_fta_forbidden_se(select_list[s]->se,NULL, Ext_fcns);
+ }
+ int p;
+ for(p=0;p<where.size();p++){
+ fta_ok &= check_fta_forbidden_pr(where[p]->pr,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<string> sel_names;
+ vector<pair<string,string> > 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;i<from.size();i++){
+ from[i]->set_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<string> sel_names;
+ for(si=0;si<ifaces.size();++si){
+ filter_join_qpn *fta_node = new filter_join_qpn();
+
+// Name the fta
+ if(ifaces.size()==1)
+ fta_node->set_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;f<from.size();f++){
+ fta_node->from.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;s<select_list.size();s++){
+ fta_node->select_list.push_back( dup_select(select_list[s], NULL) );
+ }
+
+ for(p=0;p<shared_pred.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, 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;p<pred_t0.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, 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;p<pred_t1.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, 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;p<hash_eq.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, 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;p<postfilter.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, 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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<string> &ifpnames){
+ int ret = 0;
+ int i;
+ for(i=0;i<select_list.size();++i)
+ ret += count_se_ifp_refs(select_list[i]->se,ifpnames);
+ for(i=0;i<where.size();++i)
+ ret += count_pr_ifp_refs(where[i]->pr,ifpnames);
+ return ret;
+}
+
+int sgah_qpn::count_ifp_refs(set<string> &ifpnames){
+ int ret = 0;
+ int i,j;
+ for(i=0;i<select_list.size();++i)
+ ret += count_se_ifp_refs(select_list[i]->se,ifpnames);
+ for(i=0;i<where.size();++i)
+ ret += count_pr_ifp_refs(where[i]->pr,ifpnames);
+ for(i=0;i<having.size();++i)
+ ret += count_pr_ifp_refs(having[i]->pr,ifpnames);
+ for(i=0;i<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ ret += count_se_ifp_refs(aggr_tbl.get_aggr_se(i),ifpnames);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ ret += count_se_ifp_refs(opl[j],ifpnames);
+ }
+ }
+ for(i=0;i<gb_tbl.size();++i){
+ ret += count_se_ifp_refs(gb_tbl.get_def(i), ifpnames);
+ }
+ return ret;
+}
+
+
+int rsgah_qpn::count_ifp_refs(set<string> &ifpnames){
+ int ret = 0;
+ int i,j;
+ for(i=0;i<select_list.size();++i)
+ ret += count_se_ifp_refs(select_list[i]->se,ifpnames);
+ for(i=0;i<where.size();++i)
+ ret += count_pr_ifp_refs(where[i]->pr,ifpnames);
+ for(i=0;i<having.size();++i)
+ ret += count_pr_ifp_refs(having[i]->pr,ifpnames);
+ for(i=0;i<closing_when.size();++i)
+ ret += count_pr_ifp_refs(closing_when[i]->pr,ifpnames);
+ for(i=0;i<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ ret += count_se_ifp_refs(aggr_tbl.get_aggr_se(i),ifpnames);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ ret += count_se_ifp_refs(opl[j],ifpnames);
+ }
+ }
+ for(i=0;i<gb_tbl.size();++i){
+ ret += count_se_ifp_refs(gb_tbl.get_def(i), ifpnames);
+ }
+ return ret;
+}
+
+int mrg_qpn::count_ifp_refs(set<string> &ifpnames){
+ return 0;
+}
+
+int join_eq_hash_qpn::count_ifp_refs(set<string> &ifpnames){
+ int ret = 0;
+ int i;
+ for(i=0;i<select_list.size();++i)
+ ret += count_se_ifp_refs(select_list[i]->se,ifpnames);
+ for(i=0;i<prefilter[0].size();++i)
+ ret += count_pr_ifp_refs(prefilter[0][i]->pr,ifpnames);
+ for(i=0;i<prefilter[1].size();++i)
+ ret += count_pr_ifp_refs(prefilter[1][i]->pr,ifpnames);
+ for(i=0;i<temporal_eq.size();++i)
+ ret += count_pr_ifp_refs(temporal_eq[i]->pr,ifpnames);
+ for(i=0;i<hash_eq.size();++i)
+ ret += count_pr_ifp_refs(hash_eq[i]->pr,ifpnames);
+ for(i=0;i<postfilter.size();++i)
+ ret += count_pr_ifp_refs(postfilter[i]->pr,ifpnames);
+ return ret;
+}
+
+int filter_join_qpn::count_ifp_refs(set<string> &ifpnames){
+ int ret = 0;
+ int i;
+ for(i=0;i<select_list.size();++i)
+ ret += count_se_ifp_refs(select_list[i]->se,ifpnames);
+ for(i=0;i<where.size();++i)
+ ret += count_pr_ifp_refs(where[i]->pr,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;i<select_list.size();++i)
+ if( resolve_se_ifp_refs(select_list[i]->se,ifmach, ifname, ifdb, err) )
+ ret = 1;
+ for(i=0;i<where.size();++i)
+ if( resolve_pr_ifp_refs(where[i]->pr,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;i<select_list.size();++i)
+ if( resolve_se_ifp_refs(select_list[i]->se,ifmach, ifname, ifdb, err) )
+ ret = 1;
+ for(i=0;i<where.size();++i)
+ if( resolve_pr_ifp_refs(where[i]->pr,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;i<select_list.size();++i){
+//printf("\tresolving elemet %d\n",i);
+ if( resolve_se_ifp_refs(select_list[i]->se,ifmach, ifname, ifdb, err) ){
+ ret = 1;
+ }
+ }
+ for(i=0;i<where.size();++i){
+ if( resolve_pr_ifp_refs(where[i]->pr,ifmach, ifname, ifdb, err) )
+ ret = 1;
+ }
+ for(i=0;i<having.size();++i){
+ if( resolve_pr_ifp_refs(having[i]->pr,ifmach, ifname, ifdb, err) )
+ ret = 1;
+ }
+//printf("aggr list has %d elements\n",select_list.size());
+ for(i=0;i<aggr_tbl.size();++i){
+//printf("\tresolving elemet %d\n",i);
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+//printf("\t\t\tbuiltin\n");
+ if( resolve_se_ifp_refs(aggr_tbl.get_aggr_se(i),ifmach, ifname, ifdb, err) )
+ ret = 1;
+ }else{
+//printf("\t\t\tudaf\n");
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ if( resolve_se_ifp_refs(opl[j],ifmach, ifname, ifdb, err) )
+ ret = 1;
+ }
+ }
+ for(i=0;i<gb_tbl.size();++i){
+ if( resolve_se_ifp_refs(gb_tbl.get_def(i), ifmach, ifname, ifdb, err) )
+ ret = 1;
+ }
+ return ret;
+}
+
+
+
+/*
+ SPLITTING A SELECTION_PROJECTION OPERATOR
+
+ An SPX node may reference:
+ literals, parameters, colrefs, functions, operators
+ An SPX node may not reference:
+ group-by variables, aggregates
+
+ An SPX node contains
+ selection list of SEs
+ where list of CNF predicates
+
+ Algorithm:
+ If each selection SE and each where predicate is fta-safe
+ execute entire operator as an LFTA.
+ Else
+ for each predicate in the where clause
+ if it is fta safe, execute it in the lfta
+ else, split each SE in the predicate, evaluate the
+ top-level SEs in the hfta and eval the predicate on that.
+ For each SE in the se list
+ Split the SE, eval the high level part, push onto hfta
+ selection list
+
+ Splitting an SE:
+ A SE represents a value which must be computed. The LFTA
+ must provide sub-values from which the HFTA can compute the
+ desired value.
+ 1) the SE is fta-safe
+ Create an entry in the selection list of the LFTA which is
+ the SE itself. Reference this LFTA selection list entry in
+ the HFTA (via a field name assigned to the lfta selection
+ list entry).
+ 2) The SE is not fta-safe
+ Determine the boundary between the fta-safe and the fta-unsafe
+ portions of the SE. The result is a rooted tree (which is
+ evaluated at the HFTA) which references sub-SEs (which are
+ evaluated at the LFTA). Each of the sub-SEs is placed on
+ the selection list of the LFTA and assigned field names,
+ the top part is evaluated at the HFTA and references the
+ sub-SEs through their assigned field names.
+ The only SEs on the LFTA selection list are those created by
+ the above mechanism. The collection of assigned field names becomes
+ the schema of the LFTA.
+
+ TODO: insert tablevar names into the colrefs.
+
+*/
+
+vector<qp_node *> 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<qp_node *> 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<string> sel_names;
+ vector<pair<string,string> > 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<string> fta_flds, stream_flds;
+
+
+// First check if the query can be pushed to the FTA.
+ bool fta_ok = true;
+ int s;
+ for(s=0;s<select_list.size();s++){
+ fta_ok &= check_fta_forbidden_se(select_list[s]->se,NULL, Ext_fcns);
+ }
+ int p;
+ for(p=0;p<where.size();p++){
+ fta_ok &= check_fta_forbidden_pr(where[p]->pr,NULL, Ext_fcns);
+ }
+
+ if(fta_ok){
+////////////////////////////////////////////////////////////
+// The query can be executed entirely in the FTA.
+ hfta_returned = 0;
+
+ for(si=0;si<ifaces.size();++si){
+ fta_node = new spx_qpn();
+
+// Name the fta
+ if(ifaces.size()==1)
+ fta_node->set_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;s<select_list.size();s++){
+ fta_node->select_list.push_back( dup_select(select_list[s], NULL) );
+ }
+ for(p=0;p<where.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, 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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<mrg_qpn *> split_merge = mrg_node->split_sources();
+ for(i=0;i<split_merge.size();++i){
+ ret_vec.push_back(split_merge[i]);
+ }
+ hfta_returned = split_merge.size();
+ */
+ ret_vec.push_back(mrg_node);
+ hfta_returned = 1;
+ }
+
+
+// printf("OK as FTA.\n");
+// printf("FTA node is:\n%s\n\n",fta_node->to_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_element *> *> 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;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ int se_src = SPLIT_FTAVEC_NOTBLVAR;
+// scalarexp_t *root_se = split_fta_se(
+// select_list[s]->se,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;p<where.size();p++){
+ if(! check_fta_forbidden_pr(where[p]->pr, 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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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;si<ifaces.size();++si){
+ spx_qpn *subq_node = new spx_qpn();
+
+// Name the subquery
+ string new_name = "_"+node_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 = 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;s<fta_node->select_list.size();s++){
+ subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) );
+ }
+ for(p=0;p<fta_node->where.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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<mrg_qpn *> split_merge = mrg_node->split_sources();
+ for(i=0;i<split_merge.size();++i){
+ ret_vec.push_back(split_merge[i]);
+ }
+ */
+ ret_vec.push_back(mrg_node);
+ ret_vec.push_back(stream_node);
+ hfta_returned = 1/*split_merge.size()*/ + 1;
+
+ }else{
+ fta_node->table_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<qp_node *> 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<qp_node *> ret_vec;
+ int s, p, g, a, o, i;
+ int si;
+
+ vector<string> 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<qp_node *> 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<qp_node *> ret_vec;
+ int s, p, g, a, o, i;
+ int si;
+
+ vector<string> 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<string> sel_names;
+ vector<pair<string,string> > 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<int> unsafe_gbvars; // for processing where clause
+ for(g=0;g<gb_tbl.size();g++){
+ if(! check_fta_forbidden_se(gb_tbl.get_def(g), &aggr_tbl, Ext_fcns)){
+ if(!select_allowed){
+ sprintf(tmpstr,"ERROR in rsgah_qpn::split_node_for_fta : group by attribute (%s) has LFTA-unsafe definition but select_lfta is not enabled (%s).\n",
+ gb_tbl.get_name(g).c_str(), se_to_query_string(gb_tbl.get_def(g), &aggr_tbl).c_str()
+ );
+ this->error_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;a<aggr_tbl.size();++a){
+ scalarexp_t *ase = aggr_tbl.get_aggr_se(a);
+ if(ase != NULL){ // COUNT(*) does not have a SE.
+ if(!select_allowed){
+ if(! check_fta_forbidden_se(aggr_tbl.get_aggr_se(a), &aggr_tbl, Ext_fcns)){
+ sprintf(tmpstr,"ERROR in rsgah_qpn::split_node_for_fta : aggregate (%s) has FTA-unsafe scalar expression but select_lfta is not enabled (%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);
+ }
+ }else{
+ select_rqd = true;
+ }
+ }
+ }
+
+// Verify that all of the ref'd UDAFs can be split.
+
+ for(a=0;a<aggr_tbl.size();++a){
+ if(! aggr_tbl.is_builtin(a)){
+ int afcn = aggr_tbl.get_fcn_id(a);
+ int super_id = Ext_fcns->get_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;p<where.size();p++){
+ if(! check_fta_forbidden_pr(where[p]->pr, &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;g<gb_tbl.size();g++){
+// Insert the gbvar into the lfta.
+ scalarexp_t *gbvar_def = dup_se(gb_tbl.get_def(g), &aggr_tbl);
+ fta_node->gb_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<int, scalarexp_t *> hfta_aggr_se;
+ for(a=0;a<aggr_tbl.size();++a){
+ split_fta_aggr( &(aggr_tbl), a,
+ &(stream_node->aggr_tbl), &(fta_node->aggr_tbl) ,
+ fta_node->select_list,
+ hfta_aggr_se,
+ Ext_fcns
+ );
+ }
+
+
+// Next, the select list.
+
+ for(s=0;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ scalarexp_t *root_se = rehome_fta_se(select_list[s]->se, &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;p<where.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, &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;p<having.size();p++){
+ predicate_t *pr_root = rehome_fta_pr( having[p]->pr, &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;p<closing_when.size();p++){
+ predicate_t *pr_root=rehome_fta_pr(closing_when[p]->pr,&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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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;si<ifaces.size();++si){
+ sgah_qpn *subq_node = new sgah_qpn();
+
+// Name the subquery
+ string new_name = "_"+node_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 = 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;g<fta_node->gb_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;a<fta_node->aggr_tbl.size();++a){
+ subq_node->aggr_tbl.add_aggr(fta_node->aggr_tbl.duplicate(a));
+ }
+
+ for(s=0;s<fta_node->select_list.size();s++){
+ subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) );
+ }
+ for(p=0;p<fta_node->where.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;p<fta_node->having.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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<mrg_qpn *> split_merge = mrg_node->split_sources();
+ for(i=0;i<split_merge.size();++i){
+ ret_vec.push_back(split_merge[i]);
+ }
+ */
+ ret_vec.push_back(mrg_node);
+ ret_vec.push_back(stream_node);
+ hfta_returned = 1/*split_merge.size()*/+1;
+
+ }else{
+ fta_node->table_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_element *> *> select_vec;
+ select_vec.push_back(&(fta_node->select_list)); // only one child
+
+// Process the gbvars. Split their defining SEs.
+ for(g=0;g<gb_tbl.size();g++){
+ bool fta_forbidden = false;
+ int se_src = SPLIT_FTAVEC_NOTBLVAR;
+
+ scalarexp_t *gbvar_se = split_ftavec_se( gb_tbl.get_def(g),
+ fta_forbidden, se_src, select_vec, Ext_fcns
+ );
+// if(fta_forbidden) (
+ if(fta_forbidden || se_src == SPLIT_FTAVEC_NOTBLVAR){
+ stream_node->gb_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<int, scalarexp_t *> hfta_aggr_se; // for rehome
+ for(a=0;a<aggr_tbl.size();++a){
+ scalarexp_t *hse;
+ if(aggr_tbl.is_builtin(a)){
+ if(aggr_tbl.is_star_aggr(a)){
+ stream_node->aggr_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<scalarexp_t *> opl = aggr_tbl.get_operand_list(a);
+ vector<scalarexp_t *> new_opl;
+ for(o=0;o<opl.size();++o){
+ bool fta_forbidden = false;
+ int se_src = SPLIT_FTAVEC_NOTBLVAR;
+ scalarexp_t *agg_se = split_ftavec_se( opl[o],
+ fta_forbidden, se_src, select_vec, Ext_fcns
+ );
+// 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){
+ new_opl.push_back(agg_se);
+ }else{
+ scalarexp_t *new_se=make_fta_se_ref(fta_node->select_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;p<where.size();p++){
+ if(! check_fta_forbidden_pr(where[p]->pr, 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;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ scalarexp_t *root_se = rehome_fta_se(select_list[s]->se, &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;p<having.size();p++){
+ predicate_t *pr_root = rehome_fta_pr( having[p]->pr, &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;p<closing_when.size();p++){
+ predicate_t *pr_root=rehome_fta_pr(closing_when[p]->pr,&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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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;si<ifaces.size();++si){
+ spx_qpn *subq_node = new spx_qpn();
+
+// Name the subquery
+ string new_name = "_"+node_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 = 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;s<fta_node->select_list.size();s++){
+ subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) );
+ }
+ for(p=0;p<fta_node->where.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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<mrg_qpn *> split_merge = mrg_node->split_sources();
+ for(i=0;i<split_merge.size();++i){
+ ret_vec.push_back(split_merge[i]);
+ }
+ */
+ ret_vec.push_back(mrg_node);
+ ret_vec.push_back(stream_node);
+ hfta_returned = 1/*split_merge.size()*/+1;
+
+ }else{
+ fta_node->table_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<qp_node *> 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<qp_node *> ret_vec;
+ int s, p, g, a, o, i;
+ int si;
+
+ vector<string> 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<string> sel_names;
+ vector<pair<string,string> > 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;si<ifaces.size();++si)
+ this->err_str += "\t"+ifaces[si].first+"."+ifaces[si].second+"\n";
+ this->error_code = 2;
+ return(ret_vec);
+ }
+
+// Check the group-by attributes
+ for(g=0;g<gb_tbl.size();g++){
+ if(! check_fta_forbidden_se(gb_tbl.get_def(g), &aggr_tbl, Ext_fcns)){
+ sprintf(tmpstr,"ERROR in sgah_qpn::split_node_for_fta : group by attribute (%s) has LFTA-unsafe definition and the query is lfta-only (%s).\n",
+ gb_tbl.get_name(g).c_str(), se_to_query_string(gb_tbl.get_def(g), &aggr_tbl).c_str()
+ );
+ this->error_code = 1;
+ this->err_str = tmpstr;
+ return(ret_vec);
+ }
+ }
+
+// Verify that the SEs in the aggregate definitions are fta-safe
+ for(a=0;a<aggr_tbl.size();++a){
+ scalarexp_t *ase = aggr_tbl.get_aggr_se(a);
+ if(ase != NULL){ // COUNT(*) does not have a SE.
+ 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 scalar expression 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);
+ }
+ }
+ 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;s<select_list.size();s++){
+ if(! check_fta_forbidden_se(select_list[s]->se,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;p<where.size();p++){
+ if(! check_fta_forbidden_pr(where[p]->pr, &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<int> unsafe_gbvars; // for processing where clause
+ for(g=0;g<gb_tbl.size();g++){
+ if(! check_fta_forbidden_se(gb_tbl.get_def(g), &aggr_tbl, Ext_fcns)){
+ if(!select_allowed){
+ sprintf(tmpstr,"ERROR in sgah_qpn::split_node_for_fta : group by attribute (%s) has LFTA-unsafe definition but select_lfta is not enabled (%s).\n",
+ gb_tbl.get_name(g).c_str(), se_to_query_string(gb_tbl.get_def(g), &aggr_tbl).c_str()
+ );
+ this->error_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;a<aggr_tbl.size();++a){
+ scalarexp_t *ase = aggr_tbl.get_aggr_se(a);
+ if(ase != NULL){ // COUNT(*) does not have a SE.
+ if(!select_allowed){
+ 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 FTA-unsafe scalar expression but select_lfta is not enabled (%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);
+ }
+ }else{
+ select_rqd = true;
+ }
+ }
+ }
+
+// Verify that all of the ref'd UDAFs can be split.
+
+ for(a=0;a<aggr_tbl.size();++a){
+ if(! aggr_tbl.is_builtin(a)){
+ int afcn = aggr_tbl.get_fcn_id(a);
+ int super_id = Ext_fcns->get_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;p<where.size();p++){
+ if(! check_fta_forbidden_pr(where[p]->pr, &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(d<fta_node->lfta_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;g<gb_tbl.size();g++){
+// Insert the gbvar into the lfta.
+ scalarexp_t *gbvar_def = dup_se(gb_tbl.get_def(g), &aggr_tbl);
+ fta_node->gb_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<int, scalarexp_t *> hfta_aggr_se;
+ for(a=0;a<aggr_tbl.size();++a){
+ split_fta_aggr( &(aggr_tbl), a,
+ &(stream_node->aggr_tbl), &(fta_node->aggr_tbl) ,
+ fta_node->select_list,
+ hfta_aggr_se,
+ Ext_fcns
+ );
+/*
+// OLD TRACING CODE
+
+int ii;
+for(ii=0;ii<fta_flds.size() || ii < fta_node->select_list.size();++ii){
+ if(ii<fta_flds.size())
+ printf("\t%s : ",fta_flds[ii].c_str());
+ else
+ printf("\t. : ");
+ if(ii<fta_node->select_list.size())
+ printf("%s\n",fta_node->select_list[ii]->to_string().c_str());
+ else
+ printf(".\n");
+}
+printf("hfta aggregates are:");
+for(ii=0;ii<stream_node->aggr_tbl.size();++ii){
+ printf(" %s",stream_node->aggr_tbl.get_op(ii).c_str());
+}
+printf("\nlfta aggregates are:");
+for(ii=0;ii<fta_node->aggr_tbl.size();++ii){
+ printf(" %s",fta_node->aggr_tbl.get_op(ii).c_str());
+}
+printf("\n\n");
+*/
+
+ }
+
+
+// Next, the select list.
+
+ for(s=0;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ scalarexp_t *root_se = rehome_fta_se(select_list[s]->se, &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;p<where.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, &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;p<having.size();p++){
+ predicate_t *pr_root = rehome_fta_pr( having[p]->pr, &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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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;si<ifaces.size();++si){
+ sgah_qpn *subq_node = new sgah_qpn();
+
+// Name the subquery
+ string new_name = "_"+node_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 = 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;g<fta_node->gb_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;a<fta_node->aggr_tbl.size();++a){
+ subq_node->aggr_tbl.add_aggr(fta_node->aggr_tbl.duplicate(a));
+ }
+
+ for(s=0;s<fta_node->select_list.size();s++){
+ subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) );
+ }
+ for(p=0;p<fta_node->where.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;p<fta_node->having.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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<mrg_qpn *> split_merge = mrg_node->split_sources();
+ for(i=0;i<split_merge.size();++i){
+ ret_vec.push_back(split_merge[i]);
+ }
+ */
+ ret_vec.push_back(mrg_node);
+ ret_vec.push_back(stream_node);
+ hfta_returned = 1/*split_merge.size()*/+1;
+
+ }else{
+ fta_node->table_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_element *> *> select_vec;
+ select_vec.push_back(&(fta_node->select_list)); // only one child
+
+// Process the gbvars. Split their defining SEs.
+ for(g=0;g<gb_tbl.size();g++){
+ bool fta_forbidden = false;
+ int se_src = SPLIT_FTAVEC_NOTBLVAR;
+
+ scalarexp_t *gbvar_se = split_ftavec_se( gb_tbl.get_def(g),
+ fta_forbidden, se_src, select_vec, Ext_fcns
+ );
+// if(fta_forbidden) (
+ if(fta_forbidden || se_src == SPLIT_FTAVEC_NOTBLVAR){
+ stream_node->gb_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<int, scalarexp_t *> hfta_aggr_se; // for rehome
+ for(a=0;a<aggr_tbl.size();++a){
+ scalarexp_t *hse;
+ if(aggr_tbl.is_builtin(a)){
+ if(aggr_tbl.is_star_aggr(a)){
+ stream_node->aggr_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<scalarexp_t *> opl = aggr_tbl.get_operand_list(a);
+ vector<scalarexp_t *> new_opl;
+ for(o=0;o<opl.size();++o){
+ bool fta_forbidden = false;
+ int se_src = SPLIT_FTAVEC_NOTBLVAR;
+ scalarexp_t *agg_se = split_ftavec_se( opl[o],
+ fta_forbidden, se_src, select_vec, Ext_fcns
+ );
+// 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){
+ new_opl.push_back(agg_se);
+ }else{
+ scalarexp_t *new_se=make_fta_se_ref(fta_node->select_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;p<where.size();p++){
+ if(! check_fta_forbidden_pr(where[p]->pr, 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;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ scalarexp_t *root_se = rehome_fta_se(select_list[s]->se, &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;p<having.size();p++){
+ predicate_t *pr_root = rehome_fta_pr( having[p]->pr, &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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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;si<ifaces.size();++si){
+ spx_qpn *subq_node = new spx_qpn();
+
+// Name the subquery
+ string new_name = "_"+node_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 = 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;s<fta_node->select_list.size();s++){
+ subq_node->select_list.push_back( dup_select(fta_node->select_list[s], NULL) );
+ }
+ for(p=0;p<fta_node->where.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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<mrg_qpn *> split_merge = mrg_node->split_sources();
+ for(i=0;i<split_merge.size();++i){
+ ret_vec.push_back(split_merge[i]);
+ }
+ */
+ ret_vec.push_back(mrg_node);
+ ret_vec.push_back(stream_node);
+ hfta_returned = 1/*split_merge.size()*/+1;
+
+ }else{
+ fta_node->table_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<qp_node *> 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<qp_node *> ret_vec;
+ int f,p,s;
+
+// If the node reads from streams only, don't split.
+ bool stream_only = true;
+ for(f=0;f<from.size();++f){
+// int t = Schema->get_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;f<from.size();++f){
+// tablevar_t *tmp_tblvar = new tablevar_t( from[f]->get_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<spx_qpn *> child_vec;
+ vector< vector<select_element *> *> select_vec;
+ for(f=0;f<from.size();++f){
+// int t = Schema->get_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<from.size();++f){
+ vector<cnf_elem *> pred_vec = prefilter[f];
+ if(child_vec[f] != NULL){
+ for(p=0;p<pred_vec.size();++p){
+ if(check_fta_forbidden_pr(pred_vec[p]->pr,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;p<pred_vec.size();++p){
+ stream_node->prefilter[f].push_back(pred_vec[p]);
+ }
+ }
+
+ }
+
+// Process the other predicates
+ for(p=0;p<temporal_eq.size();++p){
+ pr_root = split_ftavec_pr(temporal_eq[p]->pr,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;p<hash_eq.size();++p){
+ pr_root = split_ftavec_pr(hash_eq[p]->pr,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;p<postfilter.size();++p){
+ pr_root = split_ftavec_pr(postfilter[p]->pr,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;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ int se_src = SPLIT_FTAVEC_NOTBLVAR;
+ scalarexp_t *root_se = split_ftavec_se( select_list[s]->se,
+ 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<child_vec.size();++f){
+ if(child_vec[f]!=NULL){
+ vector<tablevar_t *> fm; fm.push_back(child_vec[f]->table_name);
+
+ for(s=0;s<child_vec[f]->select_list.size();++s)
+ bind_colref_se(child_vec[f]->select_list[s]->se, fm,0,0);
+ for(p=0;p<child_vec[f]->where.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;f<stream_node->from.size();++f){
+ stream_node->where.clear();
+ for(s=0;s<stream_node->from.size();++s){
+ for(p=0;p<stream_node->prefilter[s].size();++p){
+ bind_colref_pr((stream_node->prefilter[s])[p]->pr,stream_node->from,f,f);
+ }
+ }
+ for(p=0;p<stream_node->temporal_eq.size();++p){
+ bind_colref_pr(stream_node->temporal_eq[p]->pr,stream_node->from,f,f);
+ }
+ for(p=0;p<stream_node->hash_eq.size();++p){
+ bind_colref_pr(stream_node->hash_eq[p]->pr,stream_node->from,f,f);
+ }
+ for(p=0;p<stream_node->postfilter.size();++p){
+ bind_colref_pr(stream_node->postfilter[p]->pr,stream_node->from,f,f);
+ }
+ for(s=0;s<stream_node->select_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;s<stream_node->from.size();++s){
+ for(p=0;p<stream_node->prefilter[s].size();++p){
+ stream_node->where.push_back((stream_node->prefilter[s])[p]);
+ }
+ }
+ for(p=0;p<stream_node->temporal_eq.size();++p){
+ stream_node->where.push_back(stream_node->temporal_eq[p]);
+ }
+ for(p=0;p<stream_node->hash_eq.size();++p){
+ stream_node->where.push_back(stream_node->hash_eq[p]);
+ }
+ for(p=0;p<stream_node->postfilter.size();++p){
+ stream_node->where.push_back(stream_node->postfilter[p]);
+ }
+
+
+// Build the return list
+ vector<qp_node *> hfta_nodes;
+ hfta_returned = 1;
+ for(f=0;f<from.size();++f){
+ if(child_vec[f] != NULL){
+ spx_qpn *c_node = child_vec[f];
+ vector<pair<string, string> > 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<string> sel_names;
+ int si;
+ for(si=0;si<ifaces.size();++si){
+ spx_qpn *subq_node = new spx_qpn();
+
+// Name the subquery
+ string new_name = "_"+c_node->node_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;s<c_node->select_list.size();s++){
+ subq_node->select_list.push_back(dup_select(c_node->select_list[s], NULL));
+ }
+ for(p=0;p<c_node->where.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<string> param_names = param_tbl->get_param_names();
+// int pi;
+// for(pi=0;pi<param_names.size();pi++){
+// data_type *dt = param_tbl->get_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<mrg_qpn *> split_merge = mrg_node->split_sources();
+ int i;
+ for(i=0;i<split_merge.size();++i){
+ hfta_nodes.push_back(split_merge[i]);
+ }
+ */
+ hfta_nodes.push_back(mrg_node);
+ }
+ }
+ }
+ int i;
+ for(i=0;i<hfta_nodes.size();++i) ret_vec.push_back(hfta_nodes[i]);
+ ret_vec.push_back(stream_node);
+ hfta_returned = hfta_nodes.size()+1;
+
+// 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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ int ri;
+ data_type *dt = param_tbl->get_data_type(param_names[pi]);
+ for(ri=0;ri<ret_vec.size();++ri){
+ ret_vec[ri]->param_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<query_node *> &qnodes,
+ opview_set &opviews,
+ vector<table_exp_t *> &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<subquery_spec *> subq = Schema->get_subqueryspecs(schref);
+ for(s=0;s<subq.size();++s){
+// Validate that the fields match.
+ subquery_spec *sqs = subq[s];
+ vector<field_entry *> 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;f<sqs->types.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;q<qnodes.size();++q)
+ if(qnodes[q]->name == 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<table_exp_t *> spx_qpn::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string rootnm, string silo_name){
+ vector<table_exp_t *> ret;
+
+ int retval = process_opview(table_name,0,node_name,
+ Schema,qnodes,opviews,ret, rootnm, silo_name);
+ if(retval) exit(1);
+ return(ret);
+}
+
+
+vector<table_exp_t *> sgah_qpn::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string rootnm, string silo_name){
+ vector<table_exp_t *> ret;
+
+ int retval = process_opview(table_name,0,node_name,
+ Schema,qnodes,opviews,ret, rootnm, silo_name);
+ if(retval) exit(1);
+ return(ret);
+}
+
+vector<table_exp_t *> rsgah_qpn::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string rootnm, string silo_name){
+ vector<table_exp_t *> ret;
+
+ int retval = process_opview(table_name,0,node_name,
+ Schema,qnodes,opviews,ret, rootnm, silo_name);
+ if(retval) exit(1);
+ return(ret);
+}
+
+
+vector<table_exp_t *> sgahcwcb_qpn::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string rootnm, string silo_name){
+ vector<table_exp_t *> ret;
+
+ int retval = process_opview(table_name,0,node_name,
+ Schema,qnodes,opviews,ret, rootnm, silo_name);
+ if(retval) exit(1);
+ return(ret);
+}
+
+
+
+vector<table_exp_t *> mrg_qpn::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string rootnm, string silo_name){
+ vector<table_exp_t *> ret;
+ int f;
+ for(f=0;f<fm.size();++f){
+ int retval = process_opview(fm[f],f,node_name,
+ Schema,qnodes,opviews,ret, rootnm, silo_name);
+ if(retval) exit(1);
+ }
+ return(ret);
+}
+
+
+
+
+vector<table_exp_t *> join_eq_hash_qpn::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string rootnm, string silo_name){
+ vector<table_exp_t *> ret;
+ int f;
+ for(f=0;f<from.size();++f){
+ int retval = process_opview(from[f],f,node_name,
+ Schema,qnodes,opviews,ret, rootnm, silo_name);
+ if(retval) exit(1);
+ }
+ return(ret);
+}
+
+vector<table_exp_t *> filter_join_qpn::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string rootnm, string silo_name){
+ vector<table_exp_t *> ret;
+ int f;
+ for(f=0;f<from.size();++f){
+ int retval = process_opview(from[f],f,node_name,
+ Schema,qnodes,opviews,ret, rootnm, silo_name);
+ if(retval) exit(1);
+ }
+ return(ret);
+}
+
+
+
+//////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////
+/////// Additional methods
+
+
+
+//////////////////////////////////////////////////////////////////
+// Get schema of operator output
+
+table_def *mrg_qpn::get_fields(){
+ return(table_layout);
+}
+
+
+table_def *spx_qpn::get_fields(){
+ return(create_attributes(node_name, select_list));
+}
+
+table_def *sgah_qpn::get_fields(){
+ return(create_attributes(node_name, select_list));
+}
+
+table_def *rsgah_qpn::get_fields(){
+ return(create_attributes(node_name, select_list));
+}
+
+table_def *sgahcwcb_qpn::get_fields(){
+ return(create_attributes(node_name, select_list));
+}
+
+table_def *filter_join_qpn::get_fields(){
+ return(create_attributes(node_name, select_list));
+}
+
+
+table_def *join_eq_hash_qpn::get_fields(){
+ int i, h, s, t;
+
+// First, gather temporal colrefs and SEs.
+ map<col_id, temporal_type> temporal_cids;
+ vector<scalarexp_t *> temporal_se;
+ for(h=0;h<temporal_eq.size();++h){
+ scalarexp_t *sel = temporal_eq[h]->pr->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;s<select_list.size();++s){
+ select_list[s]->se->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;s<select_list.size();++s){
+ if(! select_list[s]->se->get_data_type()->is_temporal() ){
+ for(t=0;t<temporal_se.size();++t){
+ if(is_equivalent_se(temporal_se[t], select_list[s]->se)){
+ 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<string> l_equiv, r_equiv;
+ for(i=0;i<temporal_eq.size();i++){
+ scalarexp_t *lse = temporal_eq[i]->pr->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;s<select_list.size();++s){
+ if(select_list[s]->se->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<tablevar_t *> output_file_qpn::get_input_tbls(){
+ return(fm);
+ }
+
+ vector<tablevar_t *> mrg_qpn::get_input_tbls(){
+ return(fm);
+ }
+
+ vector<tablevar_t *> spx_qpn::get_input_tbls(){
+ vector<tablevar_t *> retval(1,table_name);
+ return(retval);
+ }
+
+ vector<tablevar_t *> sgah_qpn::get_input_tbls(){
+ vector<tablevar_t *> retval(1,table_name);
+ return(retval);
+ }
+
+ vector<tablevar_t *> rsgah_qpn::get_input_tbls(){
+ vector<tablevar_t *> retval(1,table_name);
+ return(retval);
+ }
+
+ vector<tablevar_t *> sgahcwcb_qpn::get_input_tbls(){
+ vector<tablevar_t *> retval(1,table_name);
+ return(retval);
+ }
+
+ vector<tablevar_t *> join_eq_hash_qpn::get_input_tbls(){
+ return(from);
+ }
+
+ vector<tablevar_t *> 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<tablevar_t *> output_file_qpn::get_output_tbls(){
+ vector<tablevar_t *> retval(1,new tablevar_t(node_name.c_str()));
+ return(retval);
+ }
+
+ vector<tablevar_t *> mrg_qpn::get_output_tbls(){
+ vector<tablevar_t *> retval(1,new tablevar_t(node_name.c_str()));
+ return(retval);
+ }
+
+ vector<tablevar_t *> spx_qpn::get_output_tbls(){
+ vector<tablevar_t *> retval(1,new tablevar_t(node_name.c_str()));
+ return(retval);
+ }
+
+ vector<tablevar_t *> sgah_qpn::get_output_tbls(){
+ vector<tablevar_t *> retval(1,new tablevar_t(node_name.c_str()));
+ return(retval);
+ }
+
+ vector<tablevar_t *> rsgah_qpn::get_output_tbls(){
+ vector<tablevar_t *> retval(1,new tablevar_t(node_name.c_str()));
+ return(retval);
+ }
+
+ vector<tablevar_t *> sgahcwcb_qpn::get_output_tbls(){
+ vector<tablevar_t *> retval(1,new tablevar_t(node_name.c_str()));
+ return(retval);
+ }
+
+ vector<tablevar_t *> join_eq_hash_qpn::get_output_tbls(){
+ vector<tablevar_t *> retval(1,new tablevar_t(node_name.c_str()));
+ return(retval);
+ }
+
+ vector<tablevar_t *> filter_join_qpn::get_output_tbls(){
+ vector<tablevar_t *> 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;t<fm.size();++t){
+ int tblref = Schema->get_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;p<where.size();++p){
+ bind_to_schema_pr(where[p]->pr, &fm, Schema);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ bind_to_schema_se(select_list[s]->se, &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;p<where.size();++p){
+ gather_pr_col_ids(where[p]->pr, tmp_cset, NULL);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ gather_se_col_ids(select_list[s]->se, 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;p<where.size();++p){
+ gather_pr_col_ids(where[p]->pr, tmp_cset, NULL);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ gather_se_col_ids(select_list[s]->se, 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;f<from.size();++f){
+ string snm = from[f]->get_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;p<where.size();++p){
+ bind_to_schema_pr(where[p]->pr, &fm, Schema);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ bind_to_schema_se(select_list[s]->se, &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;f<from.size();++f){
+ string snm = from[f]->get_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;p<where.size();++p){
+ bind_to_schema_pr(where[p]->pr, &fm, Schema);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ bind_to_schema_se(select_list[s]->se, &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;p<where.size();++p){
+ bind_to_schema_pr(where[p]->pr, &fm, Schema);
+ }
+ for(p=0;p<having.size();++p){
+ bind_to_schema_pr(having[p]->pr, &fm, Schema);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ bind_to_schema_se(select_list[s]->se, &fm, Schema);
+ }
+ int g;
+ for(g=0;g<gb_tbl.size();++g){
+ bind_to_schema_se(gb_tbl.get_def(g), &fm, Schema);
+ }
+ int a;
+ for(a=0;a<aggr_tbl.size();++a){
+ if(aggr_tbl.is_builtin(a)){
+ bind_to_schema_se(aggr_tbl.get_aggr_se(a), &fm, Schema);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(a);
+ int o;
+ for(o=0;o<opl.size();++o){
+ bind_to_schema_se(opl[o],&fm,Schema);
+ }
+ }
+ }
+}
+
+col_id_set sgah_qpn::get_colrefs(bool ext_fcns_only,table_list *Schema){
+ col_id_set retval, tmp_cset;
+ int p;
+ for(p=0;p<where.size();++p){
+ gather_pr_col_ids(where[p]->pr, tmp_cset, &gb_tbl);
+ }
+ int g;
+ for(g=0;g<gb_tbl.size();++g){
+ gather_se_col_ids(gb_tbl.get_def(g), tmp_cset, &gb_tbl);
+ }
+ int a;
+ for(a=0;a<aggr_tbl.size();++a){
+ if(aggr_tbl.is_builtin(a)){
+ gather_se_col_ids(aggr_tbl.get_aggr_se(a), tmp_cset, &gb_tbl);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(a);
+ int o;
+ for(o=0;o<opl.size();++o){
+ gather_se_col_ids(opl[o], tmp_cset, &gb_tbl);
+ }
+ }
+ }
+
+ 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;
+}
+
+
+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;p<where.size();++p){
+ bind_to_schema_pr(where[p]->pr, &fm, Schema);
+ }
+ for(p=0;p<having.size();++p){
+ bind_to_schema_pr(having[p]->pr, &fm, Schema);
+ }
+ for(p=0;p<closing_when.size();++p){
+ bind_to_schema_pr(closing_when[p]->pr, &fm, Schema);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ bind_to_schema_se(select_list[s]->se, &fm, Schema);
+ }
+ int g;
+ for(g=0;g<gb_tbl.size();++g){
+ bind_to_schema_se(gb_tbl.get_def(g), &fm, Schema);
+ }
+ int a;
+ for(a=0;a<aggr_tbl.size();++a){
+ if(aggr_tbl.is_builtin(a)){
+ bind_to_schema_se(aggr_tbl.get_aggr_se(a), &fm, Schema);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(a);
+ int o;
+ for(o=0;o<opl.size();++o){
+ bind_to_schema_se(opl[o],&fm,Schema);
+ }
+ }
+ }
+}
+
+
+void sgahcwcb_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;p<where.size();++p){
+ bind_to_schema_pr(where[p]->pr, &fm, Schema);
+ }
+ for(p=0;p<having.size();++p){
+ bind_to_schema_pr(having[p]->pr, &fm, Schema);
+ }
+ for(p=0;p<having.size();++p){
+ bind_to_schema_pr(cleanby[p]->pr, &fm, Schema);
+ }
+ for(p=0;p<having.size();++p){
+ bind_to_schema_pr(cleanwhen[p]->pr, &fm, Schema);
+ }
+ int s;
+ for(s=0;s<select_list.size();++s){
+ bind_to_schema_se(select_list[s]->se, &fm, Schema);
+ }
+ int g;
+ for(g=0;g<gb_tbl.size();++g){
+ bind_to_schema_se(gb_tbl.get_def(g), &fm, Schema);
+ }
+ int a;
+ for(a=0;a<aggr_tbl.size();++a){
+ if(aggr_tbl.is_builtin(a)){
+ bind_to_schema_se(aggr_tbl.get_aggr_se(a), &fm, Schema);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(a);
+ int o;
+ for(o=0;o<opl.size();++o){
+ bind_to_schema_se(opl[o],&fm,Schema);
+ }
+ }
+ }
+}
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////
+/// Functions for code generation.
+
+
+//-----------------------------------------------------------------
+// get_cplx_lit_tbl
+
+cplx_lit_table *mrg_qpn::get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){
+ return(new cplx_lit_table());
+}
+
+cplx_lit_table *spx_qpn::get_cplx_lit_tbl(ext_fcn_list *Ext_fcns){
+ int i;
+ cplx_lit_table *complex_literals = new cplx_lit_table();
+
+ for(i=0;i<select_list.size();i++){
+ find_complex_literal_se(select_list[i]->se, Ext_fcns, complex_literals);
+ }
+ for(i=0;i<where.size();++i){
+ find_complex_literal_pr(where[i]->pr,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<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ find_complex_literal_se(aggr_tbl.get_aggr_se(i), Ext_fcns, complex_literals);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ find_complex_literal_se(opl[j], Ext_fcns, complex_literals);
+ }
+ }
+
+ for(i=0;i<select_list.size();i++){
+ find_complex_literal_se(select_list[i]->se, Ext_fcns, complex_literals);
+ }
+ for(i=0;i<gb_tbl.size();i++){
+ find_complex_literal_se(gb_tbl.get_def(i), Ext_fcns, complex_literals);
+ }
+ for(i=0;i<where.size();++i){
+ find_complex_literal_pr(where[i]->pr,Ext_fcns, complex_literals);
+ }
+ for(i=0;i<having.size();++i){
+ find_complex_literal_pr(having[i]->pr,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<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ find_complex_literal_se(aggr_tbl.get_aggr_se(i), Ext_fcns, complex_literals);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ find_complex_literal_se(opl[j], Ext_fcns, complex_literals);
+ }
+ }
+
+ for(i=0;i<select_list.size();i++){
+ find_complex_literal_se(select_list[i]->se, Ext_fcns, complex_literals);
+ }
+ for(i=0;i<gb_tbl.size();i++){
+ find_complex_literal_se(gb_tbl.get_def(i), Ext_fcns, complex_literals);
+ }
+ for(i=0;i<where.size();++i){
+ find_complex_literal_pr(where[i]->pr,Ext_fcns, complex_literals);
+ }
+ for(i=0;i<having.size();++i){
+ find_complex_literal_pr(having[i]->pr,Ext_fcns, complex_literals);
+ }
+ for(i=0;i<closing_when.size();++i){
+ find_complex_literal_pr(closing_when[i]->pr,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<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ find_complex_literal_se(aggr_tbl.get_aggr_se(i), Ext_fcns, complex_literals);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ find_complex_literal_se(opl[j], Ext_fcns, complex_literals);
+ }
+ }
+
+ for(i=0;i<select_list.size();i++){
+ find_complex_literal_se(select_list[i]->se, Ext_fcns, complex_literals);
+ }
+ for(i=0;i<gb_tbl.size();i++){
+ find_complex_literal_se(gb_tbl.get_def(i), Ext_fcns, complex_literals);
+ }
+ for(i=0;i<where.size();++i){
+ find_complex_literal_pr(where[i]->pr,Ext_fcns, complex_literals);
+ }
+ for(i=0;i<having.size();++i){
+ find_complex_literal_pr(having[i]->pr,Ext_fcns, complex_literals);
+ }
+ for(i=0;i<cleanwhen.size();++i){
+ find_complex_literal_pr(cleanwhen[i]->pr,Ext_fcns, complex_literals);
+ }
+ for(i=0;i<cleanby.size();++i){
+ find_complex_literal_pr(cleanby[i]->pr,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;i<select_list.size();i++){
+ find_complex_literal_se(select_list[i]->se, Ext_fcns, complex_literals);
+ }
+ for(i=0;i<where.size();++i){
+ find_complex_literal_pr(where[i]->pr,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;i<select_list.size();i++){
+ find_complex_literal_se(select_list[i]->se, Ext_fcns, complex_literals);
+ }
+ for(i=0;i<where.size();++i){
+ find_complex_literal_pr(where[i]->pr,Ext_fcns, complex_literals);
+ }
+
+ return(complex_literals);
+}
+
+
+
+
+//-----------------------------------------------------------------
+// get_handle_param_tbl
+
+vector<handle_param_tbl_entry *> mrg_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){
+ vector<handle_param_tbl_entry *> retval;
+ return(retval);
+}
+
+
+vector<handle_param_tbl_entry *> spx_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){
+ int i;
+ vector<handle_param_tbl_entry *> retval;
+
+ for(i=0;i<select_list.size();i++){
+ find_param_handles_se(select_list[i]->se, Ext_fcns, retval);
+ }
+ for(i=0;i<where.size();++i){
+ find_param_handles_pr(where[i]->pr,Ext_fcns, retval);
+ }
+
+ return(retval);
+}
+
+
+vector<handle_param_tbl_entry *> sgah_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){
+ int i,j;
+ vector<handle_param_tbl_entry *> retval;
+
+
+ for(i=0;i<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ find_param_handles_se(aggr_tbl.get_aggr_se(i), Ext_fcns, retval);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ find_param_handles_se(opl[j], Ext_fcns, retval);
+ }
+ }
+ for(i=0;i<select_list.size();i++){
+ find_param_handles_se(select_list[i]->se, Ext_fcns, retval);
+ }
+ for(i=0;i<gb_tbl.size();i++){
+ find_param_handles_se(gb_tbl.get_def(i), Ext_fcns, retval);
+ }
+ for(i=0;i<where.size();++i){
+ find_param_handles_pr(where[i]->pr,Ext_fcns, retval);
+ }
+ for(i=0;i<having.size();++i){
+ find_param_handles_pr(having[i]->pr,Ext_fcns, retval);
+ }
+
+ return(retval);
+}
+
+
+vector<handle_param_tbl_entry *> rsgah_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){
+ int i,j;
+ vector<handle_param_tbl_entry *> retval;
+
+
+ for(i=0;i<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ find_param_handles_se(aggr_tbl.get_aggr_se(i), Ext_fcns, retval);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ find_param_handles_se(opl[j], Ext_fcns, retval);
+ }
+ }
+ for(i=0;i<select_list.size();i++){
+ find_param_handles_se(select_list[i]->se, Ext_fcns, retval);
+ }
+ for(i=0;i<gb_tbl.size();i++){
+ find_param_handles_se(gb_tbl.get_def(i), Ext_fcns, retval);
+ }
+ for(i=0;i<where.size();++i){
+ find_param_handles_pr(where[i]->pr,Ext_fcns, retval);
+ }
+ for(i=0;i<having.size();++i){
+ find_param_handles_pr(having[i]->pr,Ext_fcns, retval);
+ }
+ for(i=0;i<closing_when.size();++i){
+ find_param_handles_pr(closing_when[i]->pr,Ext_fcns, retval);
+ }
+
+ return(retval);
+}
+
+
+vector<handle_param_tbl_entry *> sgahcwcb_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){
+ int i,j;
+ vector<handle_param_tbl_entry *> retval;
+
+
+ for(i=0;i<aggr_tbl.size();++i){
+ if(aggr_tbl.is_builtin(i) && !aggr_tbl.is_star_aggr(i)){
+ find_param_handles_se(aggr_tbl.get_aggr_se(i), Ext_fcns, retval);
+ }else{
+ vector<scalarexp_t *> opl = aggr_tbl.get_operand_list(i);
+ for(j=0;j<opl.size();++j)
+ find_param_handles_se(opl[j], Ext_fcns, retval);
+ }
+ }
+ for(i=0;i<select_list.size();i++){
+ find_param_handles_se(select_list[i]->se, Ext_fcns, retval);
+ }
+ for(i=0;i<gb_tbl.size();i++){
+ find_param_handles_se(gb_tbl.get_def(i), Ext_fcns, retval);
+ }
+ for(i=0;i<where.size();++i){
+ find_param_handles_pr(where[i]->pr,Ext_fcns, retval);
+ }
+ for(i=0;i<having.size();++i){
+ find_param_handles_pr(having[i]->pr,Ext_fcns, retval);
+ }
+ for(i=0;i<cleanwhen.size();++i){
+ find_param_handles_pr(cleanwhen[i]->pr,Ext_fcns, retval);
+ }
+ for(i=0;i<cleanby.size();++i){
+ find_param_handles_pr(cleanby[i]->pr,Ext_fcns, retval);
+ }
+
+ return(retval);
+}
+
+vector<handle_param_tbl_entry *> join_eq_hash_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){
+ int i;
+ vector<handle_param_tbl_entry *> retval;
+
+ for(i=0;i<select_list.size();i++){
+ find_param_handles_se(select_list[i]->se, Ext_fcns, retval);
+ }
+ for(i=0;i<where.size();++i){
+ find_param_handles_pr(where[i]->pr,Ext_fcns, retval);
+ }
+
+ return(retval);
+}
+
+
+vector<handle_param_tbl_entry *> filter_join_qpn::get_handle_param_tbl(ext_fcn_list *Ext_fcns){
+ int i;
+ vector<handle_param_tbl_entry *> retval;
+
+ for(i=0;i<select_list.size();i++){
+ find_param_handles_se(select_list[i]->se, Ext_fcns, retval);
+ }
+ for(i=0;i<where.size();++i){
+ find_param_handles_pr(where[i]->pr,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<scalarexp_t *> 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;o<operands.size();o++){
+ if(first_elem) first_elem=false; else ret += ", ";
+ if(operands[o]->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ if(first_elem) first_elem=false; else ret += ", ";
+ if(operands[o]->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ ret += ", ";
+ if(operands[o]->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ ret += ", ";
+ if(operands[o]->get_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<scalarexp_t *> 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;o<operands.size();o++){
+ if(o) ret += ", ";
+ if(operands[o]->get_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<literal_t *> litv;
+ int i;
+ data_type *ldt, *rdt;
+ vector<scalarexp_t *> 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;i<litv.size();i++){
+ if(i>0) 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;o<op_list.size();++o){
+ if(o>0) 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<literal_t *> litv;
+ int i;
+ data_type *ldt, *rdt;
+ vector<scalarexp_t *> 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;i<litv.size();i++){
+ if(i>0) 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;o<op_list.size();++o){
+ if(o>0) 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<scalarexp_t *> opl = atbl->get_operand_list(aidx);
+ for(o=0;o<opl.size();++o){{
+ retval += ",";
+ if(opl[o]->get_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<scalarexp_t *> opl = atbl->get_operand_list(aidx);
+ int o;
+ for(o=0;o<opl.size();++o){
+ retval += ",";
+ if(opl[o]->get_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<string> param_vec = param_tbl->get_param_names();
+ for(p=0;p<param_vec.size();p++){
+ data_type *dt = param_tbl->get_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<handle_param_tbl_entry *> param_handle_table
+ ){
+ int p;
+ vector<string> 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;p<param_names.size();p++){
+ data_type *dt = param_tbl->get_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;p<param_names.size();p++){
+ if(p>0) 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;p<param_names.size();p++){
+ data_type *dt = param_tbl->get_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;p<param_names.size();p++){
+ data_type *dt = param_tbl->get_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;p<param_names.size();p++){
+ if(param_tbl->handle_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;ph<param_handle_table.size();++ph){
+ data_type pdt(param_handle_table[ph]->type_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<handle_param_tbl_entry *> param_handle_table
+ ){
+
+ int p;
+ vector<string> param_names = param_tbl->get_param_names();
+
+ string ret = "void destroy_params_"+functor_name+"(){\n";
+
+ for(p=0;p<param_names.size();p++){
+ data_type *dt = param_tbl->get_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;ph<param_handle_table.size();++ph){
+ if(param_handle_table[ph]->val_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<scalarexp_t *> &partial_fcns,
+ vector<int> &ref_cnt, vector<bool> &is_partial, bool gen_fcn_cache){
+ string ret;
+ int p;
+
+
+ for(p=0;p<partial_fcns.size();++p){
+ if(!gen_fcn_cache || is_partial[p] || ref_cnt[p]>1){
+ 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;cl<complex_literals->size();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<handle_param_tbl_entry *> ¶m_handle_table){
+ string ret;
+ int p;
+
+ for(p=0;p<param_handle_table.size();++p){
+ sprintf(tmpstr,"\tgs_param_handle_t handle_param_%d;\n",p);
+ ret += tmpstr;
+ }
+
+ return(ret);
+}
+
+
+// ------------------------------------------------------------
+// functions for generating initialization code.
+
+static string gen_access_var_init(col_id_set &cid_set){
+ string ret;
+ col_id_set::iterator csi;
+
+ for(csi=cid_set.begin(); csi!=cid_set.end();++csi){
+ int tblref = (*csi).tblvar_ref;
+ string field = (*csi).field;
+ sprintf(tmpstr,"\tunpack_offset_%s_%d = ftaschema_get_field_offset_by_name(schema_handle%d, \"%s\");\n", field.c_str(),tblref,tblref,field.c_str());
+ ret.append(tmpstr);
+ }
+ return ret;
+}
+
+
+static string gen_complex_lit_init(cplx_lit_table *complex_literals){
+ string ret;
+
+ int cl;
+ for(cl=0;cl<complex_literals->size();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<scalarexp_t *> &partial_fcns){
+ string ret;
+
+ int p;
+ for(p=0;p<partial_fcns.size();++p){
+ data_type *pdt =partial_fcns[p]->get_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<handle_param_tbl_entry *> ¶m_handle_table){
+ string ret;
+
+ int ph;
+ for(ph=0;ph<param_handle_table.size();++ph){
+ data_type pdt(param_handle_table[ph]->type_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;cl<complex_literals->size();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<handle_param_tbl_entry *> ¶m_handle_table){
+ string ret;
+
+ int ph;
+ for(ph=0;ph<param_handle_table.size();++ph){
+ sprintf(tmpstr, "\t\t%s(handle_param_%d);\n",
+ param_handle_table[ph]->lfta_deregistration_fcn().c_str(),ph);
+ ret += tmpstr;
+ }
+ return(ret);
+}
+
+// Destroy all previous results
+static string gen_partial_fcn_dtr(vector<scalarexp_t *> &partial_fcns){
+ string ret;
+
+ int p;
+ for(p=0;p<partial_fcns.size();++p){
+ data_type *pdt =partial_fcns[p]->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(), p );
+ ret += tmpstr;
+ }
+ }
+ return(ret);
+}
+
+// Destroy previsou results of fcns in pfcn_set
+static string gen_partial_fcn_dtr(vector<scalarexp_t *> &partial_fcns, set<int> &pfcn_set){
+ string ret;
+ set<int>::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<bool> &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_element *>& 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;s<select_list.size();s++){
+ if (select_list[s]->se->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_element *>& select_list, gb_table *gtbl, vector<bool> &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;s<select_list.size();s++){
+ if (select_list[s]->se->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<scalarexp_t *> &partial_fcns,set<int> &pfcn_refs,
+ string on_problem){
+ string ret;
+ set<int>::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<scalarexp_t *> &partial_fcns,set<int> &pfcn_refs,
+ vector<int> &fcn_ref_cnt, vector<bool> &is_partial_fcn,
+ string on_problem){
+ string ret;
+ set<int>::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<scalarexp_t *> &partial_fcns,set<int> &pfcn_refs,
+ col_id_set &found_cids, gb_table *gtbl, string on_problem,
+ vector<bool> &needs_xform){
+ string ret;
+ set<int>::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<scalarexp_t *> &partial_fcns,set<int> &pfcn_refs,
+ vector<int> &fcn_ref_cnt, vector<bool> &is_partial_fcn,
+ col_id_set &found_cids, gb_table *gtbl, string on_problem,
+ vector<bool> &needs_xform){
+ string ret;
+ set<int>::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<scalarexp_t *> &partial_fcns,set<int> &pfcn_refs,
+ vector<int> &fcn_ref_cnt, vector<bool> &is_partial_fcn){
+ string ret;
+ set<int>::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<bool> &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_element *> &select_list){
+ string ret;
+ int s;
+
+ for(s=0;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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_element *> &select_list,table_list *schema){
+ string ret;
+ int s;
+
+ for(s=0;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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_element *> &select_list){
+ string ret;
+ int s;
+
+ for(s=0;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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_element *> &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;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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<bool> &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_idx<fields.size();temporal_field_idx++){
+ tdt = new data_type(fields[temporal_field_idx]->get_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;h<hash_flds.size();++h){
+ sprintf(tmpstr,"unpack_var_%s", fields[hash_flds[h]]->get_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;h<hash_flds.size();++h){
+ if(hash_flds[h]!=temporal_field_idx){
+ sprintf(tmpstr,"\tunpack_offset_%s_0 = ftaschema_get_field_offset_by_name(schema_handle0, \"%s\");\n", fields[hash_flds[h]]->get_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;h<hash_flds.size();++h){
+ data_type *hdt = new data_type(fields[hash_flds[h]]->get_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;h<hash_flds.size();++h){
+ if(h>0) 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<bool> &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;w<where.size();++w)
+ gather_pr_col_ids(where[w]->pr,cid_set,NULL);
+ for(s=0;s<select_list.size();s++){
+ gather_se_col_ids(select_list[s]->se,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<scalarexp_t *> partial_fcns;
+ vector<int> fcn_ref_cnt;
+ vector<bool> is_partial_fcn;
+ for(s=0;s<select_list.size();s++){
+ find_partial_fcns(select_list[s]->se, &partial_fcns,&fcn_ref_cnt,&is_partial_fcn, Ext_fcns);
+ }
+ for(w=0;w<where.size();w++){
+ find_partial_fcns_pr(where[w]->pr, &partial_fcns, &fcn_ref_cnt,&is_partial_fcn,Ext_fcns);
+ }
+// Unmark non-partial expensive functions referenced only once.
+ for(p=0; p<partial_fcns.size();p++){
+ if(!is_partial_fcn[p] && fcn_ref_cnt[p] <= 1){
+ partial_fcns[p]->set_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<handle_param_tbl_entry *> 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;p<partial_fcns.size();++p){
+ if(fcn_ref_cnt[p]>1){
+ 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;w<where.size();++w){
+ 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, NULL);
+// Unpack these values.
+ ret += gen_unpack_cids(schema, new_cids, "false", needs_xform);
+// Find partial fcns ref'd in this cnf element
+ set<int> 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<int> sl_pfcns;
+ for(s=0;s<select_list.size();s++){
+ collect_partial_fcns(select_list[s]->se, 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<bool> &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<int, string> structured_types;
+ for(g=0;g<gb_tbl.size();++g){
+ if(gb_tbl.get_data_type(g)->is_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;g<this->gb_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<int, string>::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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ ret += "\t\tif(pattern["+int_to_string(g)+"]){\n";
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;a<aggr_tbl.size();a++){
+ aggr_table_entry *ate = aggr_tbl.agr_tbl[a];
+ 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";
+ 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;a<aggr_tbl.size();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%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;i<gb_tbl.size();++i){
+ if(i>0) ret += ",";
+ ret += "true";
+ }
+ }else{
+ for(i=0;i<n_patterns;++i){
+ if(i>0) ret += ",\n";
+ ret += "\t{";
+ for(j=0;j<gb_tbl.size();j++){
+ if(j>0) 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;w<where.size();++w)
+ gather_pr_col_ids(where[w]->pr,cid_set,segen_gb_tbl);
+ for(w=0;w<having.size();++w)
+ gather_pr_col_ids(having[w]->pr,cid_set,segen_gb_tbl);
+ for(g=0;g<gb_tbl.size();g++)
+ gather_se_col_ids(gb_tbl.get_def(g),cid_set,segen_gb_tbl);
+
+ for(s=0;s<select_list.size();s++){
+ gather_se_col_ids(select_list[s]->se,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<scalarexp_t *> partial_fcns;
+ vector<int> fcn_ref_cnt;
+ vector<bool> is_partial_fcn;
+ for(s=0;s<select_list.size();s++){
+ find_partial_fcns(select_list[s]->se, &partial_fcns,NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<where.size();w++){
+ find_partial_fcns_pr(where[w]->pr, &partial_fcns,NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<having.size();w++){
+ find_partial_fcns_pr(having[w]->pr, &partial_fcns,NULL,NULL, Ext_fcns);
+ }
+ for(g=0;g<gb_tbl.size();g++){
+ find_partial_fcns(gb_tbl.get_def(g), &partial_fcns,NULL,NULL, Ext_fcns);
+ }
+ for(a=0;a<aggr_tbl.size();a++){
+ find_partial_fcns(aggr_tbl.get_aggr_se(a), &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);
+
+// Pass-by-handle parameters
+ ret += "//\t\tPass-by-handle storage.\n";
+ vector<handle_param_tbl_entry *> 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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_temporal())
+ uses_temporal_flush = true;
+ }
+
+ if(uses_temporal_flush){
+ ret += "//\t\tFor temporal flush\n";
+ for(g=0;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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<int> w_pfcns; // partial fcns in where clause
+ for(w=0;w<where.size();++w)
+ collect_partial_fcns_pr(where[w]->pr, w_pfcns);
+
+ set<int> ag_gb_pfcns; // partial fcns in gbdefs, aggr se's
+ for(g=0;g<gb_tbl.size();g++){
+ collect_partial_fcns(gb_tbl.get_def(g), ag_gb_pfcns);
+ }
+ for(a=0;a<aggr_tbl.size();a++){
+ collect_partial_fcns(aggr_tbl.get_aggr_se(a), ag_gb_pfcns);
+ }
+ ret += gen_partial_fcn_dtr(partial_fcns,w_pfcns);
+ ret += gen_partial_fcn_dtr(partial_fcns,ag_gb_pfcns);
+// ret += gen_partial_fcn_dtr(partial_fcns);
+
+
+ ret += gen_temp_tuple_check(this->node_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;g<gb_tbl.size();g++){
+
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;w<where.size();++w){
+ 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, "NULL", needs_xform);
+// Find partial fcns ref'd in this cnf element
+ set<int> 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<int>::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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(!gdt->is_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;a<aggr_tbl.size();a++){
+ if(aggr_tbl.is_builtin(a)){
+// Create temporaries for buffer return values
+ data_type *adt = aggr_tbl.get_data_type(a);
+ if(adt->is_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;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ 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_host_cvar(tmpstr)+";\n";
+ }
+ }
+
+
+// First, get the return values from the UDAFS
+ for(a=0;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ ret += "\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_OUTPUT_(&(udaf_ret_"+int_to_string(a)+"),";
+ if(aggr_tbl.get_storage_type(a)->get_type() != fstring_t) ret+="&";
+ ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n";
+ }
+ }
+
+ set<int> hv_sl_pfcns;
+ for(w=0;w<having.size();w++){
+ collect_partial_fcns_pr(having[w]->pr, hv_sl_pfcns);
+ }
+ for(s=0;s<select_list.size();s++){
+ collect_partial_fcns(select_list[s]->se, 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;w<having.size();++w){
+ ret += "\tif( !("+generate_predicate_code_fm_aggr(having[w]->pr,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;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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;s<select_list.size();s++){
+// if(s>0) 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;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ int afcn_id = aggr_tbl.get_fcn_id(a);
+ data_type *adt = Ext_fcns->get_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;s<select_list.size();s++){
+ data_type *sdt = select_list[s]->se->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;g<gb_tbl.size();g++){
+ if(g>0) 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;g<gb_tbl.size();g++){
+ if(g>0) 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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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<bool> &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<handle_param_tbl_entry *> 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<field_entry *> flds = table_layout->get_fields();
+
+ ret+="\tif(tup.channel == 0){\n";
+ if(needs_xform[0] && !needs_xform[1]){
+ int f;
+ for(f=0;f<flds.size();f++){
+ ret.append("\t");
+ data_type dt(flds[f]->get_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;f<flds.size();f++){
+ ret.append("\t");
+ data_type dt(flds[f]->get_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<bool> &needs_xform){
+ int p,s;
+ vector<data_type *> hashkey_dt; // data types in the hash key
+ vector<data_type *> temporal_dt; // data types in the temporal key
+ map<string,scalarexp_t *> l_equiv, r_equiv; // field equivalences
+ set<int> 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;p<this->hash_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;p<hashkey_dt.size();p++){
+ if(hashkey_dt[p]->is_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;p<this->temporal_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;p<temporal_dt.size();p++){
+ if(temporal_dt[p]->is_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;p<where.size();++p)
+ gather_pr_col_ids(where[p]->pr,cid_set,NULL);
+ for(s=0;s<select_list.size();s++)
+ gather_se_col_ids(select_list[s]->se,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<scalarexp_t *> partial_fcns;
+ vector<int> fcn_ref_cnt;
+ vector<bool> is_partial_fcn;
+ for(s=0;s<select_list.size();s++){
+ find_partial_fcns(select_list[s]->se, &partial_fcns,NULL,NULL, Ext_fcns);
+ }
+ for(p=0;p<where.size();p++){
+ find_partial_fcns_pr(where[p]->pr, &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<handle_param_tbl_entry *> 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;p<hash_eq.size();p++){
+ collect_partial_fcns(hash_eq[p]->pr->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;p<hash_eq.size();p++){
+ data_type *hdt = hash_eq[p]->pr->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;p<hash_eq.size();p++){
+ collect_partial_fcns(hash_eq[p]->pr->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;p<hash_eq.size();p++){
+ data_type *hdt = hash_eq[p]->pr->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;p<temporal_eq.size();p++){
+ collect_partial_fcns(temporal_eq[p]->pr->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;p<temporal_eq.size();p++){
+ sprintf(tmpstr,"\t\tts->tempeq_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;p<temporal_eq.size();p++){
+ collect_partial_fcns(temporal_eq[p]->pr->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;p<temporal_eq.size();p++){
+ sprintf(tmpstr,"\t\tts->tempeq_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;p<temporal_eq.size();p++){
+ sprintf(tmpstr,"\tlts->tempeq_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;p<temporal_eq.size();p++){
+ sprintf(tmpstr,"\tif(lts->tempeq_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;p<prefilter[0].size();p++){
+ collect_partial_fcns_pr((prefilter[0])[p]->pr, 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<int> 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;p<prefilter[1].size();p++){
+ collect_partial_fcns_pr((prefilter[1])[p]->pr, 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<int> 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;p<postfilter.size();p++){
+ collect_partial_fcns_pr(postfilter[p]->pr, pfcn_refs);
+ }
+ for(s=0;s<select_list.size();s++){
+ collect_partial_fcns(select_list[s]->se, 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;p<postfilter.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(postfilter[p]->pr,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<int> 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<int> sl_pfcns;
+ col_id_set se_cids;
+ for(s=0;s<select_list.size();s++){
+ collect_partial_fcns(select_list[s]->se, 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;s<select_list.size();s++)
+ get_new_se_cids(select_list[s]->se, 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;s<select_list.size();s++){
+ if (select_list[s]->se->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;p<hashkey_dt.size();p++){
+ if(p>0) 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;p<hashkey_dt.size();p++){
+ if(p>0) 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<bool> &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;g<this->gb_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;a<aggr_tbl.size();a++){
+aggr_table_entry *ate = aggr_tbl.agr_tbl[a];
+ 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";
+ }
+// Constructors
+ ret += "\t"+this->generate_functor_name() + "_aggrdef(){};\n";
+// destructor
+ ret += "\t~"+this->generate_functor_name() + "_aggrdef(){\n";
+ for(a=0;a<aggr_tbl.size();a++){
+aggr_table_entry *ate = aggr_tbl.agr_tbl[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%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;a<aggr_tbl.size();a++){
+aggr_table_entry *ate = aggr_tbl.agr_tbl[a];
+ if(ate->is_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<string>::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;a<aggr_tbl.size();a++){
+aggr_table_entry *ate = aggr_tbl.agr_tbl[a];
+ if(ate->is_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;w<where.size();++w)
+ gather_pr_col_ids(where[w]->pr,cid_set,segen_gb_tbl);
+ for(w=0;w<having.size();++w)
+ gather_pr_col_ids(having[w]->pr,cid_set,segen_gb_tbl);
+ for(w=0;w<cleanby.size();++w)
+ gather_pr_col_ids(cleanby[w]->pr,cid_set,segen_gb_tbl);
+ for(w=0;w<cleanwhen.size();++w)
+ gather_pr_col_ids(cleanwhen[w]->pr,cid_set,segen_gb_tbl);
+ for(g=0;g<gb_tbl.size();g++)
+ gather_se_col_ids(gb_tbl.get_def(g),cid_set,segen_gb_tbl);
+
+ for(s=0;s<select_list.size();s++){
+ gather_se_col_ids(select_list[s]->se,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<scalarexp_t *> partial_fcns;
+ vector<int> fcn_ref_cnt;
+ vector<bool> is_partial_fcn;
+ for(s=0;s<select_list.size();s++){
+ find_partial_fcns(select_list[s]->se, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<where.size();w++){
+ find_partial_fcns_pr(where[w]->pr, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<having.size();w++){
+ find_partial_fcns_pr(having[w]->pr, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<cleanby.size();w++){
+ find_partial_fcns_pr(cleanby[w]->pr, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<cleanwhen.size();w++){
+ find_partial_fcns_pr(cleanwhen[w]->pr, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(g=0;g<gb_tbl.size();g++){
+ find_partial_fcns(gb_tbl.get_def(g), &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(a=0;a<aggr_tbl.size();a++){
+ find_partial_fcns(aggr_tbl.get_aggr_se(a), &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);
+
+// Pass-by-handle parameters
+ ret += "//\t\tPass-by-handle storage.\n";
+ vector<handle_param_tbl_entry *> 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;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ 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_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_temporal())
+ uses_temporal_flush = true;
+ }
+
+ if(uses_temporal_flush){
+ ret += "//\t\tFor temporal flush\n";
+ for(g=0;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ 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_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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<int> gb_pfcns; // partial fcns in gbdefs, aggr se's
+ for(g=0;g<gb_tbl.size();g++){
+ collect_partial_fcns(gb_tbl.get_def(g), gb_pfcns);
+ }
+ ret += gen_partial_fcn_dtr(partial_fcns,gb_pfcns);
+// ret += gen_partial_fcn_dtr(partial_fcns);
+
+
+ ret += gen_temp_tuple_check(this->node_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;g<gb_tbl.size();g++){
+
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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<int>::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;g<gb_tbl.size();g++){
+// 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";
+
+
+
+//-------------------
+// 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<int> w_pfcns; // partial fcns in where clause
+ for(w=0;w<where.size();++w)
+ collect_partial_fcns_pr(where[w]->pr, w_pfcns);
+
+ set<int> ag_pfcns; // partial fcns in gbdefs, aggr se's
+ for(a=0;a<aggr_tbl.size();a++){
+ collect_partial_fcns(aggr_tbl.get_aggr_se(a), ag_pfcns);
+ }
+ ret += gen_partial_fcn_dtr(partial_fcns,w_pfcns);
+ ret += gen_partial_fcn_dtr(partial_fcns,ag_pfcns);
+
+ ret+="//\t\tEvaluate clauses which don't reference stateful fcns first \n";
+ for(w=0;w<where.size();++w){
+ if(! pred_refs_sfun(where[w]->pr)){
+ 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<int> 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;w<where.size();++w){
+ if( pred_refs_sfun(where[w]->pr)){
+ 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<int> 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;a<aggr_tbl.size();a++){
+ if(aggr_tbl.is_builtin(a)){
+// Create temporaries for buffer return values
+ data_type *adt = aggr_tbl.get_data_type(a);
+ if(adt->is_buffer_type()){
+ sprintf(tmpstr,"aggr_tmp_%d", a);
+ ret+=adt->make_host_cvar(tmpstr)+";\n";
+ }
+ }
+ }
+
+ for(a=0;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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;a<aggr_tbl.size();a++){
+ if(aggr_tbl.is_builtin(a)){
+// Create temporaries for buffer return values
+ data_type *adt = aggr_tbl.get_data_type(a);
+ if(adt->is_buffer_type()){
+ sprintf(tmpstr,"aggr_tmp_%d", a);
+ ret+=adt->make_host_cvar(tmpstr)+";\n";
+ }
+ }
+ }
+
+ for(a=0;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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;a<aggr_tbl.size();a++){
+ if( aggr_tbl.is_superaggr(a)){
+ if(aggr_tbl.is_builtin(a)){
+// Create temporaries for buffer return values
+ data_type *adt = aggr_tbl.get_data_type(a);
+ if(adt->is_buffer_type()){
+ sprintf(tmpstr,"aggr_tmp_%d", a);
+ ret+=adt->make_host_cvar(tmpstr)+";\n";
+ }
+ }
+ }
+ }
+
+ for(a=0;a<aggr_tbl.size();a++){
+ if( aggr_tbl.is_superaggr(a)){
+ sprintf(tmpstr,"stval->aggr_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;a<aggr_tbl.size();a++){
+ if( aggr_tbl.is_superaggr(a)){
+ if(aggr_tbl.is_builtin(a)){
+// Create temporaries for buffer return values
+ data_type *adt = aggr_tbl.get_data_type(a);
+ if(adt->is_buffer_type()){
+ sprintf(tmpstr,"aggr_tmp_%d", a);
+ ret+=adt->make_host_cvar(tmpstr)+";\n";
+ }
+ }
+ }
+ }
+
+// initialize superaggregates
+ for(a=0;a<aggr_tbl.size();a++){
+ if( aggr_tbl.is_superaggr(a)){
+ sprintf(tmpstr,"stval->aggr_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;a<aggr_tbl.size();a++){
+ if(aggr_tbl.is_superaggr(a)){
+ sprintf(tmpstr,"stval->aggr_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;a<aggr_tbl.size();a++){
+ if(aggr_tbl.is_superaggr(a)){
+ sprintf(tmpstr,"stval->aggr_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;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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<int> cw_aggs;
+ for(w=0;w<cleanwhen.size();++w)
+ collect_aggr_refs_pr(cleanwhen[w]->pr, cw_aggs);
+
+
+// get the return values from the UDAFS
+ for(a=0;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a) && cw_aggs.count(a)){
+ ret += "\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_OUTPUT_(&(udaf_ret_"+int_to_string(a)+"),";
+ if(aggr_tbl.get_storage_type(a)->get_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<int> cw_pfcns; // partial fcns in where clause
+ for(w=0;w<cleanwhen.size();++w)
+ collect_partial_fcns_pr(cleanwhen[w]->pr, cw_pfcns);
+
+ ret += gen_partial_fcn_dtr(partial_fcns,cw_pfcns);
+
+
+ for(w=0;w<cleanwhen.size();++w){
+ sprintf(tmpstr,"//\t\tPredicate clause %d.\n",w);
+ ret += tmpstr;
+// Find partial fcns ref'd in this cnf element
+ set<int> 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<int> cb_aggs;
+ for(w=0;w<cleanby.size();++w)
+ collect_aggr_refs_pr(cleanby[w]->pr, cb_aggs);
+
+
+// get the return values from the UDAFS
+ for(a=0;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a) && cb_aggs.count(a)){
+ ret += "\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_OUTPUT_(&(udaf_ret_"+int_to_string(a)+"),";
+ if(aggr_tbl.get_storage_type(a)->get_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<int> cb_pfcns; // partial fcns in where clause
+ for(w=0;w<cleanby.size();++w)
+ collect_partial_fcns_pr(cleanby[w]->pr, cb_pfcns);
+
+ ret += gen_partial_fcn_dtr(partial_fcns,cb_pfcns);
+
+
+ for(w=0;w<cleanwhen.size();++w){
+ 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(cleanby[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<int> 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<int> hv_aggs;
+ for(w=0;w<having.size();++w)
+ collect_aggr_refs_pr(having[w]->pr, hv_aggs);
+
+
+// get the return values from the UDAFS
+ for(a=0;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a) && hv_aggs.count(a)){
+ ret += "\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_OUTPUT_(&(udaf_ret_"+int_to_string(a)+"),";
+ if(aggr_tbl.get_storage_type(a)->get_type() != fstring_t) ret+="&";
+ ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n";
+ }
+ }
+
+
+ set<int> hv_sl_pfcns;
+ for(w=0;w<having.size();w++){
+ collect_partial_fcns_pr(having[w]->pr, 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;w<having.size();++w){
+ ret += "\tif( !("+generate_predicate_code_fm_aggr(having[w]->pr,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<int> sl_aggs;
+ for(s=0;s<select_list.size();s++)
+ collect_agg_refs(select_list[s]->se, sl_aggs);
+
+
+// get the return values from the UDAFS
+ for(a=0;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a) && sl_aggs.count(a)){
+ ret += "\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_OUTPUT_(&(udaf_ret_"+int_to_string(a)+"),";
+ if(aggr_tbl.get_storage_type(a)->get_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<int> sl_pfcns;
+ for(s=0;s<select_list.size();s++){
+ collect_partial_fcns(select_list[s]->se, 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;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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;s<select_list.size();s++){
+// if(s>0) 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;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ int afcn_id = aggr_tbl.get_fcn_id(a);
+ data_type *adt = Ext_fcns->get_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;s<select_list.size();s++){
+ data_type *sdt = select_list[s]->se->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;g<gb_tbl.size();g++){
+ if(g>0) 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;g<gb_tbl.size();g++){
+ if(sg_tbl.count(g)>0){
+ 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;g<gb_tbl.size();g++){
+ if(g>0) 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;g<gb_tbl.size();g++){
+ if(sg_tbl.count(g)){
+ if(first_elem) first_elem=false; else 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;
+ }
+ }
+ }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<bool> &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;g<this->gb_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;a<aggr_tbl.size();a++){
+aggr_table_entry *ate = aggr_tbl.agr_tbl[a];
+ 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";
+ }
+// Constructors
+ ret += "\t"+this->generate_functor_name() + "_aggrdef(){};\n";
+// destructor
+ ret += "\t~"+this->generate_functor_name() + "_aggrdef(){\n";
+ for(a=0;a<aggr_tbl.size();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%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;w<where.size();++w)
+ gather_pr_col_ids(where[w]->pr,cid_set,segen_gb_tbl);
+ for(w=0;w<having.size();++w)
+ gather_pr_col_ids(having[w]->pr,cid_set,segen_gb_tbl);
+ for(w=0;w<closing_when.size();++w)
+ gather_pr_col_ids(closing_when[w]->pr,cid_set,segen_gb_tbl);
+ for(g=0;g<gb_tbl.size();g++)
+ gather_se_col_ids(gb_tbl.get_def(g),cid_set,segen_gb_tbl);
+
+ for(s=0;s<select_list.size();s++){
+ gather_se_col_ids(select_list[s]->se,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<scalarexp_t *> partial_fcns;
+ vector<int> fcn_ref_cnt;
+ vector<bool> is_partial_fcn;
+ for(s=0;s<select_list.size();s++){
+ find_partial_fcns(select_list[s]->se, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<where.size();w++){
+ find_partial_fcns_pr(where[w]->pr, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<having.size();w++){
+ find_partial_fcns_pr(having[w]->pr, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(w=0;w<closing_when.size();w++){
+ find_partial_fcns_pr(closing_when[w]->pr, &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(g=0;g<gb_tbl.size();g++){
+ find_partial_fcns(gb_tbl.get_def(g), &partial_fcns, NULL,NULL, Ext_fcns);
+ }
+ for(a=0;a<aggr_tbl.size();a++){
+ find_partial_fcns(aggr_tbl.get_aggr_se(a), &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);
+ }
+
+// Create cached temporaries for UDAF return values.
+ for(a=0;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ 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_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<handle_param_tbl_entry *> 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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_temporal())
+ uses_temporal_flush = true;
+ }
+
+ if(uses_temporal_flush){
+ ret += "//\t\tFor temporal flush\n";
+ for(g=0;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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<int> w_pfcns; // partial fcns in where clause
+ for(w=0;w<where.size();++w)
+ collect_partial_fcns_pr(where[w]->pr, w_pfcns);
+
+ set<int> ag_gb_pfcns; // partial fcns in gbdefs, aggr se's
+ for(g=0;g<gb_tbl.size();g++){
+ collect_partial_fcns(gb_tbl.get_def(g), ag_gb_pfcns);
+ }
+ for(a=0;a<aggr_tbl.size();a++){
+ collect_partial_fcns(aggr_tbl.get_aggr_se(a), ag_gb_pfcns);
+ }
+ ret += gen_partial_fcn_dtr(partial_fcns,w_pfcns);
+ ret += gen_partial_fcn_dtr(partial_fcns,ag_gb_pfcns);
+// ret += gen_partial_fcn_dtr(partial_fcns);
+
+
+ ret += gen_temp_tuple_check(this->node_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;g<gb_tbl.size();g++){
+
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+
+ if(gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;w<where.size();++w){
+ 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, "NULL", needs_xform);
+// Find partial fcns ref'd in this cnf element
+ set<int> 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<int>::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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(!gdt->is_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;a<aggr_tbl.size();a++){
+ if(aggr_tbl.is_builtin(a)){
+// Create temporaries for buffer return values
+ data_type *adt = aggr_tbl.get_data_type(a);
+ if(adt->is_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;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(gdt->is_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;a<aggr_tbl.size();a++){
+ sprintf(tmpstr,"aggval->aggr_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;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ ret += "\t"+aggr_tbl.get_op(a)+"_HFTA_AGGR_OUTPUT_(&(udaf_ret_"+int_to_string(a)+"),";
+ if(aggr_tbl.get_storage_type(a)->get_type() != fstring_t) ret+="&";
+ ret+="("+aggvar+"aggr_var"+int_to_string(a)+"));\n";
+ }
+ }
+
+ set<int> hv_sl_pfcns;
+ for(w=0;w<having.size();w++){
+ collect_partial_fcns_pr(having[w]->pr, hv_sl_pfcns);
+ }
+ for(s=0;s<select_list.size();s++){
+ collect_partial_fcns(select_list[s]->se, 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;w<having.size();++w){
+ ret += "\tif( !("+generate_predicate_code_fm_aggr(having[w]->pr,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;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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;s<select_list.size();s++){
+// if(s>0) 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;s<select_list.size();s++){
+ scalarexp_t *se = select_list[s]->se;
+ 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<int> clw_pfcns;
+ for(w=0;w<closing_when.size();w++){
+ collect_partial_fcns_pr(closing_when[w]->pr, 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;w<closing_when.size();++w){
+ ret += "\tif( !("+generate_predicate_code_fm_aggr(closing_when[w]->pr,gbvar, aggvar, schema) +") ) { return false;}\n";
+ }
+
+
+// Destroy string return vals of UDAFs
+ for(a=0;a<aggr_tbl.size();a++){
+ if(! aggr_tbl.is_builtin(a)){
+ int afcn_id = aggr_tbl.get_fcn_id(a);
+ data_type *adt = Ext_fcns->get_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;s<select_list.size();s++){
+ data_type *sdt = select_list[s]->se->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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(! gdt->is_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;g<gb_tbl.size();g++){
+ data_type *gdt = gb_tbl.get_data_type(g);
+ if(! gdt->is_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<qp_node *> sgah_qpn::split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema){
+
+ vector<qp_node *> ret_vec;
+ int s, p, g, a, o, i;
+ int si;
+
+ vector<string> fta_flds, stream_flds;
+ int t = table_name->get_schema_ref();
+
+// Get the set of interfaces it accesses.
+ int ierr;
+ vector<string> sel_names;
+
+// Verify that all of the ref'd UDAFs can be split.
+
+ for(a=0;a<aggr_tbl.size();++a){
+ if(! aggr_tbl.is_builtin(a)){
+ int afcn = aggr_tbl.get_fcn_id(a);
+ int hfta_super_id = Ext_fcns->get_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;g<gb_tbl.size();g++){
+// Insert the gbvar into both low- and hi level hfta.
+ scalarexp_t *gbvar_def = dup_se(gb_tbl.get_def(g), &aggr_tbl);
+ low_hfta_node->gb_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<int, scalarexp_t *> hfta_aggr_se;
+ for(a=0;a<aggr_tbl.size();++a){
+ split_hfta_aggr( &(aggr_tbl), a,
+ &(hi_hfta_node->aggr_tbl), &(low_hfta_node->aggr_tbl) ,
+ low_hfta_node->select_list,
+ hfta_aggr_se,
+ Ext_fcns
+ );
+ }
+
+
+// Next, the select list.
+
+ for(s=0;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ scalarexp_t *root_se = rehome_fta_se(select_list[s]->se, &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;p<where.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, &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;p<having.size();p++){
+ predicate_t *pr_root = rehome_fta_pr( having[p]->pr, &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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<qp_node *> rsgah_qpn::split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema){
+
+ vector<qp_node *> ret_vec;
+ int s, p, g, a, o, i;
+ int si;
+
+ vector<string> fta_flds, stream_flds;
+ int t = table_name->get_schema_ref();
+
+// Get the set of interfaces it accesses.
+ int ierr;
+ vector<string> sel_names;
+
+// Verify that all of the ref'd UDAFs can be split.
+
+ for(a=0;a<aggr_tbl.size();++a){
+ if(! aggr_tbl.is_builtin(a)){
+ int afcn = aggr_tbl.get_fcn_id(a);
+ int hfta_super_id = Ext_fcns->get_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;g<gb_tbl.size();g++){
+// Insert the gbvar into both low- and hi level hfta.
+ scalarexp_t *gbvar_def = dup_se(gb_tbl.get_def(g), &aggr_tbl);
+ low_hfta_node->gb_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<int, scalarexp_t *> hfta_aggr_se;
+ for(a=0;a<aggr_tbl.size();++a){
+ split_hfta_aggr( &(aggr_tbl), a,
+ &(hi_hfta_node->aggr_tbl), &(low_hfta_node->aggr_tbl) ,
+ low_hfta_node->select_list,
+ hfta_aggr_se,
+ Ext_fcns
+ );
+ }
+
+
+// Next, the select list.
+
+ for(s=0;s<select_list.size();s++){
+ bool fta_forbidden = false;
+ scalarexp_t *root_se = rehome_fta_se(select_list[s]->se, &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;p<where.size();p++){
+ predicate_t *new_pr = dup_pr(where[p]->pr, &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;p<having.size();p++){
+ predicate_t *pr_root = rehome_fta_pr( having[p]->pr, &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;p<closing_when.size();p++){
+ predicate_t *pr_root = rehome_fta_pr( closing_when[p]->pr, &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<string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<map<string, scalarexp_t *> *> &src_vec, gb_table *gb_tbl, table_list *Schema){
+ scalarexp_t *rse, *lse,*p_se, *gb_se;
+ int tno, schema_type;
+ map<string, scalarexp_t *> *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<qp_node *> q_sources, table_list *Schema){
+ int i;
+ vector<map<string, scalarexp_t *> *> src_vec;
+
+ for(i=0;i<q_sources.size();i++){
+ if(q_sources[i] != NULL)
+ src_vec.push_back(q_sources[i]->get_protocol_se());
+ else
+ src_vec.push_back(NULL);
+ }
+
+ for(i=0;i<select_list.size();i++){
+ protocol_map[select_list[i]->name] = resolve_protocol_se(select_list[i]->se,src_vec,NULL,Schema);
+ }
+}
+
+void join_eq_hash_qpn::create_protocol_se(vector<qp_node *> q_sources, table_list *Schema){
+ int i;
+ vector<map<string, scalarexp_t *> *> src_vec;
+
+ for(i=0;i<q_sources.size();i++){
+ if(q_sources[i] != NULL)
+ src_vec.push_back(q_sources[i]->get_protocol_se());
+ else
+ src_vec.push_back(NULL);
+ }
+
+ for(i=0;i<select_list.size();i++){
+ protocol_map[select_list[i]->name] = resolve_protocol_se(select_list[i]->se,src_vec,NULL,Schema);
+ }
+
+ for(i=0;i<hash_eq.size();i++){
+ hash_src_l.push_back(resolve_protocol_se(hash_eq[i]->pr->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<qp_node *> q_sources, table_list *Schema){
+ int i;
+ vector<map<string, scalarexp_t *> *> src_vec;
+
+ for(i=0;i<q_sources.size();i++){
+ if(q_sources[i] != NULL)
+ src_vec.push_back(q_sources[i]->get_protocol_se());
+ else
+ src_vec.push_back(NULL);
+ }
+
+ for(i=0;i<select_list.size();i++){
+ protocol_map[select_list[i]->name] = resolve_protocol_se(select_list[i]->se,src_vec,NULL,Schema);
+ }
+
+ for(i=0;i<hash_eq.size();i++){
+ hash_src_l.push_back(resolve_protocol_se(hash_eq[i]->pr->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<qp_node *> q_sources, table_list *Schema){
+ int i;
+ vector<map<string, scalarexp_t *> *> src_vec;
+
+ for(i=0;i<q_sources.size();i++){
+ if(q_sources[i] != NULL)
+ src_vec.push_back(q_sources[i]->get_protocol_se());
+ else
+ src_vec.push_back(NULL);
+ }
+
+ for(i=0;i<select_list.size();i++){
+ protocol_map[select_list[i]->name] = resolve_protocol_se(select_list[i]->se,src_vec,&gb_tbl,Schema);
+ }
+
+ for(i=0;i<gb_tbl.size();i++)
+ gb_sources.push_back(resolve_protocol_se(gb_tbl.get_def(i),src_vec,&gb_tbl,Schema));
+
+}
+
+void rsgah_qpn::create_protocol_se(vector<qp_node *> q_sources, table_list *Schema){
+ int i;
+ vector<map<string, scalarexp_t *> *> src_vec;
+
+ for(i=0;i<q_sources.size();i++){
+ if(q_sources[i] != NULL)
+ src_vec.push_back(q_sources[i]->get_protocol_se());
+ else
+ src_vec.push_back(NULL);
+ }
+
+ for(i=0;i<select_list.size();i++){
+ protocol_map[select_list[i]->name] = resolve_protocol_se(select_list[i]->se,src_vec,&gb_tbl,Schema);
+ }
+
+ for(i=0;i<gb_tbl.size();i++)
+ gb_sources.push_back(resolve_protocol_se(gb_tbl.get_def(i),src_vec,&gb_tbl,Schema));
+}
+
+void sgahcwcb_qpn::create_protocol_se(vector<qp_node *> q_sources, table_list *Schema){
+ int i;
+ vector<map<string, scalarexp_t *> *> src_vec;
+
+ for(i=0;i<q_sources.size();i++){
+ if(q_sources[i] != NULL)
+ src_vec.push_back(q_sources[i]->get_protocol_se());
+ else
+ src_vec.push_back(NULL);
+ }
+
+ for(i=0;i<select_list.size();i++){
+ protocol_map[select_list[i]->name] = resolve_protocol_se(select_list[i]->se,src_vec,&gb_tbl,Schema);
+ }
+
+ for(i=0;i<gb_tbl.size();i++)
+ gb_sources.push_back(resolve_protocol_se(gb_tbl.get_def(i),src_vec,&gb_tbl,Schema));
+}
+
+void mrg_qpn::create_protocol_se(vector<qp_node *> q_sources, table_list *Schema){
+ int f,s,i;
+ scalarexp_t *first_se;
+
+ vector<map<string, scalarexp_t *> *> src_vec;
+ map<string, scalarexp_t *> *pse_map;
+
+ for(i=0;i<q_sources.size();i++){
+ if(q_sources[i] != NULL)
+ src_vec.push_back(q_sources[i]->get_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<field_entry *> tbl_flds = table_layout->get_fields();
+ for(f=0;f<tbl_flds.size();f++){
+ bool match = true;
+ string fld_nm = tbl_flds[f]->get_name();
+ pse_map = src_vec[0];
+ first_se = (*pse_map)[fld_nm];
+ if(first_se == NULL)
+ match = false;
+ for(s=1;s<src_vec.size() && match;s++){
+ pse_map = src_vec[s];
+ scalarexp_t *match_se = (*pse_map)[fld_nm];
+ if(match_se == false)
+ match = false;
+ else
+ match = is_equivalent_se_base(first_se, match_se, Schema);
+ }
+ if(match)
+ protocol_map[fld_nm] = first_se;
+ else
+ protocol_map[fld_nm] = NULL;
+ }
+}
--- /dev/null
+/* ------------------------------------------------
+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 __QUERY_PLAN_H__
+#define __QUERY_PLAN_H__
+
+#include<vector>
+#include<string>
+#include<map>
+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<int> reads_from;
+ std::set<int> sources_to;
+ std::vector<std::string> refd_tbls;
+ std::vector<var_pair_t *> 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<int> 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<subquery_spec *> subq = Schema->get_subqueryspecs(sid);
+ int i;
+ for(i=0;i<subq.size();++i){
+ refd_tbls.push_back(subq[i]->name);
+ }
+ };
+};
+
+struct hfta_node{
+ std::string name;
+ std::string source_name;
+ std::vector<int> query_node_indices;
+ std::set<int> reads_from;
+ std::set<int> 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<int> predecessors;
+ std::vector<int> 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<std::string, std::string> definitions;
+ param_table *param_tbl;
+
+// The value of a field in terms of protocol fields (if any).
+ std::map<std::string, scalarexp_t *> 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<std::string> 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<std::string, std::string> &def){
+ definitions = def;
+ };
+ std::map<std::string, std::string> 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<qp_node *> q_sources,table_list *Schema)=0;
+// get the protocol map. the parameter is the return value.
+ std::map<std::string, scalarexp_t *> *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<tablevar_t *> get_input_tbls() = 0;
+// this is a confused function, it acutally return the output
+// table name.
+ virtual std::vector<tablevar_t *> 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<bool> &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<handle_param_tbl_entry *> 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<qp_node *> 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<std::string> &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<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<cnf_elem *> get_where_clause() = 0;
+// To be more explicit, use get_filter_preds
+ virtual std::vector<cnf_elem *> get_filter_clause() = 0;
+
+ void add_predecessor(int i){predecessors.push_back(i);};
+ void remove_predecessor(int i){
+ std::vector<int>::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<int> get_predecessors(){return predecessors;};
+ int n_predecessors(){return predecessors.size();};
+ std::vector<int> 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<cnf_elem *> where; // selection predicate
+ std::vector<select_element *> select_list; // Select list
+
+
+
+ std::string node_type(){return("spx_qpn"); };
+ bool makes_transform(){return true;};
+ std::vector<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &needs_xform);
+ std::string generate_functor_name();
+ std::string generate_operator(int i, std::string params);
+ std::string get_include_file(){return("#include <selection_operator.h>\n");};
+
+ std::vector<select_element *> get_select_list(){return select_list;};
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0;i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ return ret;
+ };
+ std::vector<cnf_elem *> get_where_clause(){return where;};
+ std::vector<cnf_elem *> get_filter_clause(){return where;};
+ cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns);
+ std::vector<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns);
+
+ table_def *get_fields();
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> get_output_tbls();
+
+ std::vector<qp_node *> 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<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string> &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<tablevar_t *> 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<std::string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<qp_node *> 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<cnf_elem *> where; // selection predicate
+ std::vector<cnf_elem *> having; // post-aggregation predicate
+ std::vector<select_element *> 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<scalarexp_t *> 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<std::string> gb_entry_type;
+ std::vector<int> gb_entry_count;
+
+ std::vector<scalarexp_t *> get_gb_sources(){return gb_sources;}
+
+ std::string node_type(){return("sgah_qpn"); };
+ bool makes_transform(){return true;};
+ std::vector<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &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 <groupby_operator.h>\n");
+ }else{
+ return("#include <groupby_operator_oop.h>\n");
+ }
+ };
+
+ std::vector<select_element *> get_select_list(){return select_list;};
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0;i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ return ret;
+ };
+ std::vector<cnf_elem *> get_where_clause(){return where;};
+ std::vector<cnf_elem *> get_filter_clause(){return where;};
+ std::vector<cnf_elem *> 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<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns);
+
+// table which represents output tuple.
+ table_def *get_fields();
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> 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<tablevar_t *> 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;g<qs->gb_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;a<qs->aggr_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<qp_node *> 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<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string> &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<std::string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<qp_node *> split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema);
+
+ void create_protocol_se(vector<qp_node *> 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<cnf_elem *> where; // selection predicate
+ std::vector<cnf_elem *> having; // post-aggregation predicate
+ std::vector<cnf_elem *> closing_when; // group closing predicate
+ std::vector<select_element *> 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<scalarexp_t *> 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<scalarexp_t *> get_gb_sources(){return gb_sources;}
+
+
+ std::string node_type(){return("rsgah_qpn"); };
+ bool makes_transform(){return true;};
+ std::vector<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &needs_xform);
+ std::string generate_functor_name();
+
+ std::string generate_operator(int i, std::string params);
+ std::string get_include_file(){return("#include <running_gb_operator.h>\n");};
+
+ std::vector<select_element *> get_select_list(){return select_list;};
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0;i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ return ret;
+ };
+ std::vector<cnf_elem *> get_where_clause(){return where;};
+ std::vector<cnf_elem *> get_filter_clause(){return where;};
+ std::vector<cnf_elem *> get_having_clause(){return having;};
+ std::vector<cnf_elem *> 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<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns);
+
+// table which represents output tuple.
+ table_def *get_fields();
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> 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<tablevar_t *> 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;g<qs->gb_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;a<qs->aggr_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<qp_node *> 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<qp_node *> split_node_for_hfta(ext_fcn_list *Ext_fcns, table_list *Schema);
+ virtual std::vector<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string> &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<std::string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<qp_node *> 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<tablevar_t *> fm; // Source table
+ std::vector<colref_t *> 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<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &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 <merge_operator_oop.h>\n");
+ return("#include <merge_operator.h>\n");
+ };
+
+ cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns);
+ std::vector<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns);
+
+ table_def *get_fields();
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> get_output_tbls();
+
+ std::vector<qp_node *> 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<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string> &ifpnames);
+
+// No predicates, return an empty clause
+ std::vector<cnf_elem *> get_where_clause(){
+ std::vector<cnf_elem *> t;
+ return(t);
+ };
+ std::vector<cnf_elem *> 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;ff<fm.size();++ff){
+printf("%s ",fm[ff]->to_string().c_str());
+}
+printf("\n");
+*/
+
+
+// Create the output schema.
+// strip temporal properites form all fields except the merge field.
+ std::vector<field_entry *> flva = Schema->get_fields(fm[0]->get_schema_name());
+ field_entry_list *fel = new field_entry_list();
+ int f;
+ for(f=0;f<flva.size();++f){
+ field_entry *fe;
+ data_type dt(flva[f]->get_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<std::string> param_strings = dt.get_param_keys();
+ int p;
+ for(p=0;p<param_strings.size();++p){
+ std::string v = dt.get_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());
+ }
+
+
+ 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<std::string> &src_names,table_list *Schema){
+ int i,f;
+
+ disorder = 1;
+
+// Construct the fm list
+ for(f=0;f<src_names.size();++f){
+ int tbl_ref = Schema->get_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<field_entry *> flva = Schema->get_fields(fm[0]->get_schema_name());
+ field_entry_list *fel = new field_entry_list();
+ bool temporal_found = false;
+ for(f=0;f<flva.size();++f){
+ field_entry *fe;
+ data_type dt(flva[f]->get_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<std::string> param_strings = dt.get_param_keys();
+ int p;
+ for(p=0;p<param_strings.size();++p){
+ std::string v = dt.get_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());
+ }
+
+ 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<fm.size();++f){
+ std::vector<field_entry *> 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<std::pair<std::string, std::string> > &sources,ifq_t *ifdb, gb_table *gbt);
+
+
+// Merge filter_join LFTAs.
+
+ mrg_qpn(filter_join_qpn *spx, std::string n_name, std::vector<std::string> &sources, std::vector<std::pair<std::string, std::string> > &ifaces, ifq_t *ifdb);
+
+// Merge selection LFTAs.
+
+ mrg_qpn(spx_qpn *spx, std::string n_name, std::vector<std::string> &sources, std::vector<std::pair<std::string, std::string> > &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;i<spx->select_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;i<sources.size();i++){
+ std::string rvar = "_m"+int_to_string(i);
+ mvars.push_back(new colref_t(rvar.c_str(), spx->select_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<std::string> param_names = spx->param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = spx->param_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<std::string> &sources, std::vector<std::pair< std::string, std::string> > &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;i<sgah->select_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;i<sources.size();i++){
+ std::string rvar = "_m"+int_to_string(i);
+ mvars.push_back(new colref_t(rvar.c_str(), sgah->select_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<std::string> param_names = sgah->param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = sgah->param_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<std::string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<mrg_qpn *> 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<string, int> lfta_names, vector<string> interface_names, vector<string> 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<tablevar_t *> input_tables = get_input_tbls();
+ for (int i = 0; i < input_tables.size(); ++i) {
+ tablevar_t * table = input_tables[i];
+
+ vector<string> 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<tablevar_t *> 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<qp_node *> 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<tablevar_t *> from; // Source tables
+ std::vector<select_element *> select_list; // Select list
+ std::vector<cnf_elem *> prefilter[2]; // source prefilters
+ std::vector<cnf_elem *> temporal_eq; // define temporal window
+ std::vector<cnf_elem *> hash_eq; // define hash key
+ std::vector<cnf_elem *> postfilter; // final filter on hash matches.
+
+ std::vector<cnf_elem *> where; // all the filters
+ // useful for summary analysis
+
+ std::vector<scalarexp_t *> hash_src_r, hash_src_l;
+
+ std::vector<scalarexp_t *> get_hash_r(){return hash_src_r;}
+ std::vector<scalarexp_t *> get_hash_l(){return hash_src_l;}
+
+ std::string node_type(){return("join_eq_hash_qpn"); };
+ bool makes_transform(){return true;};
+ std::vector<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &needs_xform);
+ std::string generate_functor_name();
+ std::string generate_operator(int i, std::string params);
+ std::string get_include_file(){return("#include <join_eq_hash_operator.h>\n");};
+
+ std::vector<select_element *> get_select_list(){return select_list;};
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0;i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ return ret;
+ };
+// Used for LFTA only
+ std::vector<cnf_elem *> get_where_clause(){
+ std::vector<cnf_elem *> t;
+ return(t);
+ };
+ std::vector<cnf_elem *> get_filter_clause(){
+ return get_where_clause();
+ }
+
+ cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns);
+ std::vector<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns);
+
+ table_def *get_fields();
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> get_output_tbls();
+
+ std::vector<qp_node *> 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<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string> &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<where.size();++w){
+ analyze_cnf(where[w]);
+ std::vector<int> 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<int> 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<std::string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<qp_node *> 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<tablevar_t *> from; // Source tables
+ colref_t *temporal_var; // join window in FROM
+ unsigned int temporal_range; // metadata.
+ std::vector<select_element *> select_list; // Select list
+ std::vector<cnf_elem *> shared_pred; // prefilter preds
+ std::vector<cnf_elem *> pred_t0; // main (R) preds
+ std::vector<cnf_elem *> pred_t1; // filtering (S) preds
+ std::vector<cnf_elem *> hash_eq; // define hash key
+ std::vector<cnf_elem *> postfilter; // ref's no table.
+
+ std::vector<cnf_elem *> where; // all the filters
+ // useful for summary analysis
+
+ std::vector<scalarexp_t *> hash_src_r, hash_src_l;
+ std::vector<scalarexp_t *> get_hash_r(){return hash_src_r;}
+ std::vector<scalarexp_t *> 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<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &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 <join_eq_hash_operator.h>\n");};
+
+ std::vector<select_element *> get_select_list(){return select_list;};
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0;i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ return ret;
+ };
+// Used for LFTA only
+ std::vector<cnf_elem *> get_where_clause(){return where;}
+ std::vector<cnf_elem *> get_filter_clause(){return shared_pred;}
+
+ cplx_lit_table *get_cplx_lit_tbl(ext_fcn_list *Ext_fcns);
+ std::vector<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns);
+
+ table_def *get_fields();
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> get_output_tbls();
+
+ std::vector<qp_node *> 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<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string> &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<select_list.size();i++){
+ vector<int> 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<cnf_elem *> t0_only, t1_only;
+ for(w=0;w<where.size();++w){
+ analyze_cnf(where[w]);
+ std::vector<int> 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<int> 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<int> matched_pred;
+ int v;
+ for(w=0;w<t0_only.size();w++){
+ for(v=0;v<t1_only.size();++v)
+ if(is_equivalent_pred_base(t0_only[w]->pr,t1_only[v]->pr,Schema))
+ break;
+ if(v<t1_only.size()){
+ shared_pred.push_back(t0_only[w]);
+ matched_pred.insert(v);
+ }else{
+ pred_t0.push_back(t0_only[w]);
+ }
+ }
+ for(v=0;v<t1_only.size();++v){
+ if(matched_pred.count(v) == 0)
+ pred_t1.push_back(t1_only[v]);
+ }
+
+
+// Get the parameters
+ param_tbl = qs->param_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<std::string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<qp_node *> 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<field_entry *> fields;
+ ospec_str *output_spec;
+ vector<tablevar_t *> fm;
+ std::string hfta_query_name;
+ std::string filestream_id;
+ bool eat_input;
+ std::vector<std::string> 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<int> hash_flds; // fields used to hash the output.
+
+ std::string node_type(){return("output_file_qpn"); };
+ bool makes_transform(){return false;};
+ std::vector<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &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 <zfile_output_operator.h>\n");
+ default:
+ return("#include <file_output_operator.h>\n");
+ }
+ return("#include <file_output_operator.h>\n");
+ };
+
+ std::vector<cnf_elem *> get_where_clause(){std::vector<cnf_elem *> ret; return ret;};
+ std::vector<cnf_elem *> get_filter_clause(){std::vector<cnf_elem *> 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<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns){std::vector<handle_param_tbl_entry *> ret; return ret;}
+
+ table_def *get_fields(){
+ field_entry_list *fel = new field_entry_list();
+ int i;
+ for(i=0;i<fields.size();++i)
+ fel->append_field(fields[i]);
+ return new table_def(node_name.c_str(), NULL, NULL, fel, STREAM_SCHEMA);
+ }
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> get_output_tbls();
+
+ std::vector<qp_node *> 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<qp_node *> ret; ret.push_back(this); hfta_returned = true; return ret;
+ }
+ std::vector<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &qnodes, opview_set &opviews, std::string rootnm, std::string silo_nm){
+ std::vector<table_exp_t *> ret; return ret;
+ }
+// Ensure that any refs to interface params have been split away.
+ int count_ifp_refs(std::set<std::string> &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;i<nwords;i++){
+ params.push_back(words[i]);
+ }
+ for(i=0;i<params.size();i++){
+ if(params[i] == "gzip")
+ do_gzip = true;
+ }
+ }
+
+// Set output splitting parameters
+ bool set_splitting_params(int np, int ix, int ns, std::string split_flds, std::string &err_report){
+ n_streams = ns;
+ n_hfta_clones = np;
+ parallel_idx = ix;
+
+ if(split_flds != ""){
+ string err_flds = "";
+ char *tmpstr = strdup(split_flds.c_str());
+ char *words[100];
+ int nwords = split_string(tmpstr,':',words,100);
+ int i,j;
+ for(i=0;i<nwords;++i){
+ string target = words[i];
+ for(j=0;j<fields.size();++j){
+ if(fields[j]->get_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<qp_node *> 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<cnf_elem *> where; // selection predicate
+ std::vector<cnf_elem *> having; // post-aggregation predicate
+ std::vector<select_element *> select_list; // se's of output
+ gb_table gb_tbl; // Table of all group-by attributes.
+ std::set<int> sg_tbl; // Names of the superGB attributes
+ aggregate_table aggr_tbl; // Table of all referenced aggregates.
+ std::set<std::string> states_refd; // states ref'd by stateful fcns.
+ std::vector<cnf_elem *> cleanby;
+ std::vector<cnf_elem *> cleanwhen;
+
+ std::vector<scalarexp_t *> gb_sources; // pre-compute for partitioning.
+
+ std::vector<scalarexp_t *> get_gb_sources(){return gb_sources;}
+
+ std::string node_type(){return("sgahcwcb_qpn"); };
+ bool makes_transform(){return true;};
+ std::vector<std::string> external_libs(){
+ std::vector<std::string> 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<bool> &needs_xform);
+ std::string generate_functor_name();
+
+ std::string generate_operator(int i, std::string params);
+ std::string get_include_file(){return("#include <clean_operator.h>\n");};
+
+ std::vector<select_element *> get_select_list(){return select_list;};
+ std::vector<scalarexp_t *> get_select_se_list(){
+ std::vector<scalarexp_t *> ret;
+ int i;
+ for(i=0;i<select_list.size();++i) ret.push_back(select_list[i]->se);
+ return ret;
+ };
+ std::vector<cnf_elem *> get_where_clause(){return where;};
+ std::vector<cnf_elem *> get_filter_clause(){return where;};
+ std::vector<cnf_elem *> 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<handle_param_tbl_entry *> get_handle_param_tbl(ext_fcn_list *Ext_fcns);
+
+// table which represents output tuple.
+ table_def *get_fields();
+ std::vector<tablevar_t *> get_input_tbls();
+ std::vector<tablevar_t *> 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<tablevar_t *> 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;g<qs->gb_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;a<qs->aggr_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<qp_node *> 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<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string> &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<std::string> param_names = param_tbl->get_param_names();
+ int pi;
+ for(pi=0;pi<param_names.size();pi++){
+ data_type *dt = param_tbl->get_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<qp_node *> q_sources, table_list *Schema);
+};
+
+
+std::vector<qp_node *> create_query_nodes(query_summary_class *qs,table_list *Schema);
+
+
+
+void untaboo(string &s);
+
+table_def *create_attributes(string tname, vector<select_element *> &select_list);
+
+
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+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 <string.h>
+
+
+
+#include "res.tab.cc.h"
+
+/*
+ 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 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;i++){
+ if(flex_res_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_res_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_ResParser_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_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 */
+"<?xml".*$ {flex_res_ch+=ResParserleng; }; /* comment */
+
+.|\n {flex_res_ch+=ResParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); ResParsererror(yytext);}
+
+%%
+
+int my_ResParser_yyinput(char *buf, int max_size){
+ int c = 0;
+ int inchar = 0;
+
+ if(flex_res_stringinput != NULL){
+ while(c<max_size){
+ if(flex_res_stringinput[flex_res_stringinput_ptr] != '\0'){
+ buf[c++] = flex_res_stringinput[flex_res_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_res_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_res_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void ResParser_setfileinput(FILE *f){
+ ResParserrestart(NULL);
+
+ flex_res_fileinput = f;
+ flex_res_stringinput = NULL;
+ flex_res_lineno = 1;
+ flex_res_ch = 0;
+}
+
+void ResParser_setstringinput(char *s){
+ ResParserrestart(NULL);
+
+ flex_res_fileinput = NULL;
+ flex_res_stringinput = s;
+ flex_res_stringinput_ptr = 0;
+ flex_res_lineno = 1;
+ flex_res_ch = 0;
+}
+
+
+
+
--- /dev/null
+/* 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. */
+
+/* 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 ResParserparse
+#define yylex ResParserlex
+#define yyerror ResParsererror
+#define yylval ResParserlval
+#define yychar ResParserchar
+#define yydebug ResParserdebug
+#define yynerrs ResParsernerrs
+
+
+/* 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 "res.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 "iface_q.h"
+
+
+extern resparse_data *rpd_ptr;
+extern std::vector<std::string> res_attr_vec;
+extern std::vector<std::string> 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 <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) \
+ || (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 <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 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 <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)
+/* 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
+
+\f
+
+#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 */
+
+\f
+
+#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;
+ }
+}
+
+\f
+
+/* 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"
+\f
+ 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"
+
+
+
--- /dev/null
+/* 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 */
+
--- /dev/null
+/* ------------------------------------------------
+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 <stdio.h>
+
+/* Some addn'l includes, necessary but not included by the
+ bison generated code.
+*/
+
+#include <stdlib.h>
+
+/* prototypes for the parser callbacks.
+*/
+
+#include "iface_q.h"
+
+
+extern resparse_data *rpd_ptr;
+extern std::vector<std::string> res_attr_vec;
+extern std::vector<std::string> 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 <strval> NAME
+%token <strval> 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;}
+ ;
+
+
+
+
+
+%%
+
--- /dev/null
+#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 <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, 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 <string.h>
+
+
+
+#include "res.tab.cc.h"
+
+/*
+ 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 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;i++){
+ if(flex_res_linebuf[i] == '\t'){
+ fprintf(stderr,"\t");
+ }else{
+ fprintf(stderr," ");
+ }
+ }
+ fprintf(stderr,"^\n");
+ // fprintf(stderr,"%*s\n",1+flex_res_ch,"^");
+}
+
+#undef YY_INPUT
+#define YY_INPUT(b, r, ms) (r = my_ResParser_yyinput(b,ms))
+
+/* MKS needs the next line to increase the NFA table */
+#line 490 "reslexer.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 "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<max_size){
+ if(flex_res_stringinput[flex_res_stringinput_ptr] != '\0'){
+ buf[c++] = flex_res_stringinput[flex_res_stringinput_ptr++];
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ if(flex_res_fileinput != NULL){
+ while(c < max_size){
+ inchar = getc(flex_res_fileinput);
+ if(inchar != EOF){
+ buf[c++] = inchar;
+ }else{
+ break;
+ }
+ }
+ return(c);
+ }
+
+ return(0);
+}
+
+void ResParser_setfileinput(FILE *f){
+ ResParserrestart(NULL);
+
+ flex_res_fileinput = f;
+ flex_res_stringinput = NULL;
+ flex_res_lineno = 1;
+ flex_res_ch = 0;
+}
+
+void ResParser_setstringinput(char *s){
+ ResParserrestart(NULL);
+
+ flex_res_fileinput = NULL;
+ flex_res_stringinput = s;
+ flex_res_stringinput_ptr = 0;
+ flex_res_lineno = 1;
+ flex_res_ch = 0;
+}
+
+
+
+
--- /dev/null
+
+/* A Bison parser, made from schema.y
+ by GNU Bison version 1.25
+ */
+
+#define YYBISON 1 /* Identify Bison output. */
+
+#define yyparse SchemaParserparse
+#define yylex SchemaParserlex
+#define yyerror SchemaParsererror
+#define yylval SchemaParserlval
+#define yychar SchemaParserchar
+#define yydebug SchemaParserdebug
+#define yynerrs SchemaParsernerrs
+#define NAME 258
+#define SEMICOLON 259
+#define LEFTBRACE 260
+#define RIGHTBRACE 261
+#define TABLE 262
+#define STREAM 263
+
+#line 8 "schema.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 "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 <stdio.h>
+
+#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 <alloca.h>
+#else /* not sparc */
+#if defined (MSDOS) && !defined (__TURBOC__)
+#include <malloc.h>
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+#include <malloc.h>
+ #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
+\f
+#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
+\f
+#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"
+\f
+ 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"
+
+
--- /dev/null
+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;
--- /dev/null
+#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 <stdio.h>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <unistd.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)
+
+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 <string.h>
+
+
+
+#include "schema.tab.cc.h"
+
+/*
+ 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 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 <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, *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"
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+#include "parse_fta.h"
+#include "parse_schema.h"
+#include"generate_utils.h"
+
+#include"host_tuple.h"
+#include"lapp.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+
+// 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<query_rep *> 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<field_entry *> 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<var_pair_t *> 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;fi<n_tuples;++fi){
+ if((qrep->set_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;pi<n_params;++pi){
+ if((qrep->set_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;f<schema_list[sh]->field_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;f<schema_list[sh]->field_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;f<schema_list[sh]->field_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;f<schema_list[sh]->param_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;p<schema_list[sh]->param_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;p<schema_list[sh]->param_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;f<q->field_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;p<q->param_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);
+
+
+
+}
+
+
--- /dev/null
+/* ------------------------------------------------
+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<tuple_access_info> field_info;
+ int min_tuple_size;
+
+ std::vector<param_block_info> 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;f<field_info.size();++f){
+ field_info[f].offset = curr_pos;
+ int sz = field_info[f].pdt->type_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;p<param_info.size();++p){
+ param_info[p].offset = curr_pos;
+ int sz = param_info[p].pdt->type_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
+
--- /dev/null
+/* ------------------------------------------------
+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<algorithm>
+#include<utility>
+#include <list>
+
+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;i<query_plan.size();++i){
+ if(query_plan[i]){
+ if(query_plan[i]->get_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<qp_node *> 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<string,stream_query *> &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;n<query_plan.size();++n){
+ if(query_plan[n] != NULL){
+ Schema->add_table(query_plan[n]->get_fields());
+ }
+ }
+// Now do schema binding
+ for(n=0;n<query_plan.size();++n){
+ if(query_plan[n] != NULL){
+ query_plan[n]->bind_to_schema(Schema);
+ }
+ }
+
+// create name-to-index map
+ map<string, int> name_to_node;
+ for(n=0;n<query_plan.size();++n){
+ if(query_plan[n]){
+ name_to_node[query_plan[n]->get_node_name()] = n;
+ }
+ }
+
+// Create a list of the nodes to process, in order.
+// Search from the root down.
+// ASSUME tree plan.
+
+ list<int> search_q;
+ list<int> 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<int> the_pred = query_plan[the_q]->get_predecessors();
+ for(i=0;i<the_pred.size();i++)
+ search_q.push_back(the_pred[i]);
+ }
+
+// Scan through the work list, from the front,
+// gather the qp_node's ref'd, and call the
+// protocol se generator. Pass NULL for
+// sources not found - presumably user-defined operator
+
+ while(! work_list.empty()){
+ int the_q = work_list.front();
+ work_list.pop_front();
+ vector<qp_node *> q_sources;
+ vector<tablevar_t *> q_input_tbls = query_plan[the_q]->get_input_tbls();
+ for(i=0;i<q_input_tbls.size();++i){
+ string itbl_nm = q_input_tbls[i]->get_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;i<query_plan.size();++i){
+ if(query_plan[i]){
+ printf("query node %s, type=%s:\n",query_plan[i]->get_node_name().c_str(),
+ query_plan[i]->node_type().c_str());
+ map<std::string, scalarexp_t *> *pse_map = query_plan[i]->get_protocol_se();
+ map<std::string, scalarexp_t *>::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<scalarexp_t *> pse_l;
+ vector<scalarexp_t *> 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;p<pse_l.size();++p){
+ if(pse_l[p] != NULL)
+ printf("\t\t%s = ",pse_l[p]->to_string().c_str());
+ else
+ printf("\t\tNULL = ");
+ if(pse_r[p] != NULL)
+ printf("%s\n",pse_r[p]->to_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<scalarexp_t *> 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;g<pseg.size();g++){
+ if(pseg[g] != NULL)
+ printf("\t\tgb %d = %s\n",g,pseg[g]->to_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;n<query_plan.size();++n){
+ if(query_plan[n]){
+ query_plan[n]->clear_predecessors();
+ query_plan[n]->clear_successors();
+ }
+ }
+ qtail.clear();
+
+// create name-to-index map
+ map<string, int> name_to_node;
+ for(n=0;n<query_plan.size();++n){
+ if(query_plan[n]){
+ name_to_node[query_plan[n]->get_node_name()] = n;
+ }
+ }
+
+// Do the 2-way linkage.
+ for(n=0;n<query_plan.size();++n){
+ if(query_plan[n]){
+ vector<tablevar_t *> fm = query_plan[n]->get_input_tbls();
+ for(f=0;f<fm.size();++f){
+ string src_tbl = fm[f]->get_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<query_plan.size();++n){
+ if(query_plan[n]){
+ vector<int> 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;s<succ.size();++s){
+ fprintf(stderr,"%s ",query_plan[succ[s]]->get_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;n<query_plan.size();++n){
+ if(query_plan[n]!=NULL && query_plan[n]->get_error_code()){
+ fprintf(stderr,"%s",query_plan[n]->get_error_str().c_str());
+ create_failed = true;
+ }
+ }
+/*
+for(n=0;n<query_plan.size();++n){
+if(query_plan[n] != NULL){
+string nstr = query_plan[n]->get_node_name();
+printf("In generate_plan, node %d is %s, reads from:\n\t",n,nstr.c_str());
+vector<tablevar_t *> inv = query_plan[n]->get_input_tbls();
+int nn;
+for(nn=0;nn<inv.size();nn++){
+printf("%s (%d) ",inv[nn]->to_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;n<query_plan.size();++n){
+if(query_plan[n] != NULL){
+string nstr = query_plan[n]->get_node_name();
+printf("B generate_plan, node %d is %s, reads from:\n\t",n,nstr.c_str());
+vector<tablevar_t *> inv = query_plan[n]->get_input_tbls();
+int nn;
+for(nn=0;nn<inv.size();nn++){
+printf("%s (%d) ",inv[nn]->to_string().c_str(),inv[nn]->get_schema_ref());
+}
+printf("\n");
+}
+}
+printf("qhead=%d, qtail = ",qhead);
+int nn;
+for(nn=0;nn<qtail.size();++nn)
+printf("%d ",qtail[nn]);
+printf("\n");
+*/
+
+// Collect query summaries. The query is reperesented by its head node.
+ query_name = query_plan[qhead]->get_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<string> &libset){
+
+ int qn,i;
+ for(qn=0;qn<query_plan.size();++qn){
+ if(query_plan[qn] != NULL){
+ vector<string> op_libs = query_plan[qn]->external_libs();
+ for(i=0;i<op_libs.size();++i){
+ libset.insert(op_libs[i]);
+ }
+ }
+ }
+
+ for(qn=0;qn<output_operators.size();++qn){
+ if(output_operators[qn] != NULL){
+ vector<string> op_libs = output_operators[qn]->external_libs();
+ for(i=0;i<op_libs.size();++i){
+ libset.insert(op_libs[i]);
+ }
+ }
+ }
+}
+
+
+
+// Split into LFTA, HFTA components.
+// Split this query into LFTA and HFTA queries.
+// Four possible outcomes:
+// 1) the query reads from a protocol, but does not need to
+// split (can be evaluated as an LFTA).
+// The lfta query is the only element in the return vector,
+// and hfta_returned is false.
+// 2) the query reads from no protocol, and therefore cannot be split.
+// THe hfta query 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 err_str and error_code
+// 4) The query splits into an hfta query and one or more LFTA queries.
+// the return vector has two or more elements, and hfta_returned
+// is true. The last element is the HFTA.
+
+vector<stream_query *> 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<stream_query *> queries;
+ int l,q,s;
+ int qp_hfta;
+
+ hfta_returned = false; // assume until proven otherwise
+
+ for(l=0;l<qtail.size();++l){
+ int leaf = qtail[l];
+
+
+ vector<qp_node *> 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<stream_query *> 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<int> succ = query_plan[leaf]->get_successors();
+ for(s=0;s<succ.size();++s){
+ query_plan[succ[s]]->remove_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<stream_query *> null_result;
+ return(null_result);
+ }
+
+ for(q=0;q<qnodes.size()-qp_hfta;++q){ // process lfta nodes
+//printf("creating lfta %d (%s)\n",q,qnodes[q]->get_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<qnodes.size()-1;++q)
+ query_plan.push_back(qnodes[q]);
+ }
+ }
+
+ int n_ifprefs = 0;
+ set<string> ifps;
+ for(q=0;q<query_plan.size();++q){
+ if(query_plan[q] != NULL){
+ n_ifprefs += query_plan[q]->count_ifp_refs(ifps);
+ hfta_returned = true;
+ }
+ }
+
+ if(n_ifprefs){
+ set<string>::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<stream_query *> 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<table_exp_t *> stream_query::extract_opview(table_list *Schema, vector<query_node *> &qnodes, opview_set &opviews, string silo_nm){
+ vector<table_exp_t *> subqueries;
+ int l,q;
+
+ string root_name = this->get_output_tabledef()->get_tbl_name();
+
+
+ for(l=0;l<qtail.size();++l){
+ int leaf = qtail[l];
+ vector<table_exp_t *> new_qnodes = query_plan[leaf]->extract_opview(Schema, qnodes, opviews, root_name, silo_nm);
+
+ for(q=0;q<new_qnodes.size();++q){ // process lfta nodes
+ subqueries.push_back( new_qnodes[q]);
+ }
+ }
+
+ return(subqueries);
+}
+
+
+
+
+string stream_query::make_schema(){
+ return make_schema(qhead);
+}
+
+string stream_query::make_schema(int q){
+ string ret="FTA{\n\n";
+
+ ret += query_plan[q]->get_fields()->to_string();
+
+ ret += "DEFINE{\n";
+ ret += "\tquery_name '"+query_plan[q]->get_node_name()+"';\n";
+
+ map<string, string> defs = query_plan[q]->get_definitions();
+ map<string, string>::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<string> param_names = params->get_param_names();
+ int p;
+ for(p=0;p<param_names.size();p++){
+ data_type *dt = params->get_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<query_plan.size();++q){
+ if(query_plan[q]){
+ map<string, string> 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<tablevar_t *> input_tbls = this->get_input_tables();
+ int i;
+ for(i=0;i<input_tbls.size();++i){
+ int t = Schema->get_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<tablevar_t *> stream_query::get_input_tables(){
+ vector<tablevar_t *> retval;
+
+// create name-to-index map
+ int n;
+ map<string, int> name_to_node;
+ for(n=0;n<query_plan.size();++n){
+ if(query_plan[n]){
+ name_to_node[query_plan[n]->get_node_name()] = n;
+ }
+ }
+
+ int l;
+ for(l=0;l<qtail.size();++l){
+ int leaf = qtail[l];
+ vector<tablevar_t *> tmp_v = query_plan[leaf]->get_input_tbls();
+ int i;
+ for(i=0;i<tmp_v.size();++i){
+ if(name_to_node.count(tmp_v[i]->get_schema_name()) == 0)
+ retval.push_back(tmp_v[i]);
+ }
+ }
+ return(retval);
+}
+
+
+void stream_query::compute_node_format(int q, vector<int> &nfmt, map<string, int> &op_idx){
+ int netcnt = 0, hostcnt = 0;
+ int i;
+
+ vector<tablevar_t *> itbls = query_plan[q]->get_input_tbls();
+ for(i=0;i<itbls.size();++i){
+ string tname = itbls[i]->get_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;qn<query_plan.size();++qn){
+ if(query_plan[qn] != NULL){
+ Schema->add_table(query_plan[qn]->get_fields());
+ }
+ }
+// Now do binding.
+ for(qn=0;qn<query_plan.size();++qn){
+ if(query_plan[qn] != NULL){
+ query_plan[qn]->bind_to_schema(Schema);
+ }
+ }
+
+// Is it a DAG plan?
+ set<string> qsources;
+ int n;
+ for(n=0;n<query_plan.size();++n){
+ if(query_plan[n]){
+ vector<tablevar_t *> tmp_v = query_plan[n]->get_input_tbls();
+ int i;
+ for(i=0;i<tmp_v.size();++i){
+ if(qsources.count(tmp_v[i]->get_schema_name()) > 0)
+ dag_graph = true;
+ qsources.insert(tmp_v[i]->get_schema_name());
+ }
+ }
+ }
+
+
+
+// Collect set of tables ref'd in this HFTA
+ set<int> tbl_set;
+ for(qn=0;qn<query_plan.size();++qn){
+ if(query_plan[qn]){
+// get names of the tables
+ vector<tablevar_t *> input_tbls = query_plan[qn]->get_input_tbls();
+ vector<tablevar_t *> output_tbls = query_plan[qn]->get_output_tbls();
+// Convert to tblrefs, add to set of ref'd tables
+ int i;
+ for(i=0;i<input_tbls.size();i++){
+// int t = Schema->get_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;i<output_tbls.size();i++){
+ int t = Schema->get_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<string, int> op_idx;
+ for(q=0;q<query_plan.size();q++){
+ if(query_plan[q]){
+ op_idx[query_plan[q]->get_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<tablevar_t *> input_tbls = this->get_input_tables();
+ vector<bool> input_tbl_free;
+ for(i=0;i<input_tbls.size();++i){
+ input_tbl_free.push_back(true);
+ }
+ map<string, int> lfta_idx;
+//fprintf(stderr,"%d input tables, %d query nodes\n",input_tbls.size(), query_plan.size());
+ for(q=0;q<query_plan.size();q++){
+ if(query_plan[q]){
+ vector<tablevar_t *> itbls = query_plan[q]->get_input_tbls();
+ int it;
+ for(it=0;it<itbls.size();it++){
+ string tname = itbls[it]->get_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;i<input_tbls.size();++i){
+ if(src_tblname == input_tbls[i]->get_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;i<input_tbls.size();++i){
+ string src_tblname = input_tbls[i]->get_schema_name();
+ lfta_idx[src_tblname] = i;
+ }
+*/
+
+// Compute the output formats of the operators.
+ vector<int> 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;i<query_plan.size();++i){
+ if(i != qhead && query_plan[i]){
+ string schema_tmpstr = this->make_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<int>::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;i<output_specs.size();++i){
+ if(output_specs[i]->operator_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;i<output_specs.size();++i){
+ if(output_specs[i]->operator_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<query_plan.size();++qn){
+ if(query_plan[qn]!=NULL){
+// Compute whether the input needs a ntoh xform.
+ vector<bool> needs_xform;
+ vector<tablevar_t *> itbls = query_plan[qn]->get_input_tbls();
+ for(i=0;i<itbls.size();++i){
+ string tname = itbls[i]->get_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<bool> needs_xform;
+ for(i=0;i<output_operators.size();++i)
+ functor_defs += output_operators[i]->generate_functor(Schema, Ext_fcns, needs_xform);
+
+ string ret =
+"extern \"C\" {\n"
+"#include <lapp.h>\n"
+"#include <fta.h>\n"
+"#include <gshub.h>\n"
+"#include <stdlib.h>\n"
+"#include <stdio.h>\n"
+"#include <limits.h>\n"
+"}\n"
+;
+ if(dag_graph)
+ ret +=
+"#define PLAN_DAG\n"
+;
+ ret +=
+"#include <schemaparser.h>\n"
+"#include<hfta_runtime_library.h>\n"
+"\n"
+"#include <host_tuple.h>\n"
+"#include <hfta.h>\n"
+"#include <hfta_udaf.h>\n"
+"#include <hfta_sfun.h>\n"
+"\n"
+//"#define MAXSCHEMASZ 16384\n"
+"#include <stdio.h>\n\n"
+;
+
+// Get include file for each of the operators.
+// avoid duplicate inserts.
+ set<string> include_fls;
+ for(qn=0;qn<query_plan.size();++qn){
+ if(query_plan[qn] != NULL)
+ include_fls.insert(query_plan[qn]->get_include_file());
+ }
+ for(i=0;i<output_operators.size();++i)
+ include_fls.insert(output_operators[i]->get_include_file());
+ set<string>::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<param_block>& lst){\n"
+" // for now every lfta receive the full copy of hfta parameters\n"
+" struct param_block pb;\n";
+
+ set<string> lfta_seen;
+ for(i=0;i<input_tbls.size();++i){
+ string src_tblname = input_tbls[i]->get_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;q<opv->subq_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_info*> *lfta_list = new list<lfta_info*>;\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<string> ext_reg_txt;
+ map<string, int> input_tbl_srcid;
+ for(i=0;i<input_tbls.size();++i){
+ string src_tblname = input_tbls[i]->get_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;i<query_plan.size();++i){
+ if(i != qhead && query_plan[i]){
+ ret += "\tgs_schemahandle_t op"+int_to_string(i)+"_schema_handle = ftaschema_parse_string(node"+int_to_string(i)+"_schema);\n";
+ }
+ }
+ ret+="\n";
+
+// Create the operators.
+ int n_basic_ops;
+ for(q=0;q<query_plan.size();q++){
+ if(query_plan[q]){
+ ret+=
+"\n"
+" // create an instance of operator "+int_to_string(q)+" ("+query_plan[q]->get_node_name()+") \n";
+
+// Create parameters for operator construction.
+ string op_params;
+ vector<tablevar_t *> 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;i<output_operators.size();++i){
+ ret += output_operators[i]->generate_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<query_plan.size();++q){
+ if(query_plan[q]){
+// NOTE: this code assume that the operator has at most
+// two inputs. But the template code also makes
+// this assumption. Both will need to be changed.
+ vector<tablevar_t *> 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;i<output_operators.size();++i){
+ if(i==0)
+ ret += "\tnode"+int_to_string(n_basic_ops)+"->set_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<string, int> lfta_names, vector<string> interface_names, vector<string> 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<field_entry*> 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<colref_t *> mvars; // the merge-by columns.
+
+ // reodring procedure is different for unary operators and joins
+ if (node->node_type() == "join_eq_hash_qpn") {
+ vector<qp_node*> 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<string, tablevar_t*> 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<string, int> lfta_names, vector<string> interface_names, vector<string> 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<field_entry*> 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<colref_t *> 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<qp_node*> new_nodes;
+
+ // split aggregations into high and low-level part
+ vector<qp_node *> 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<string, vector<int> > 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<int> tables;
+ tables.push_back(i);
+ host_map[table_name->get_machine()] = tables;
+ }
+ }
+
+ // create a new merge and low-level aggregation for each host
+ map<string, vector<int> >::iterator iter;
+ for (iter = host_map.begin(); iter != host_map.end(); iter++) {
+ string host_name = (*iter).first;
+ vector<int> 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<int> 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*> stream_query::split_multihost_query() {
+
+ vector<stream_query*> ret;
+ char node_suffix[128];
+ int i;
+
+ // find merges combining multiple hosts into per-host groups
+ int plan_size = query_plan.size();
+ vector<mrg_qpn*> 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<string, vector<int> > 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<int> tables;
+ tables.push_back(j);
+ host_map[table_name->get_machine()] = tables;
+ }
+ }
+
+ // create a new merge for each host
+ map<string, vector<int> >::iterator iter;
+ for (iter = host_map.begin(); iter != host_map.end(); iter++) {
+ string host_name = (*iter).first;
+ vector<int> 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<stream_query *>& hfta_list, map<string, int> lfta_names, vector<string> interface_names, vector<string> 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<int> 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<tablevar_t *> 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<stream_query*> 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<mrg_qpn *> 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<string, int> &lfta_names,vector<string> &silo_names,table_list *Schema){
+ int i,t,s;
+
+ int suffix_len = silo_names.back().size();
+
+ for(i=0;i<qtail.size();++i){
+ vector<tablevar_t *> itbls = query_plan[qtail[i]]->get_input_tbls();
+ for(t=0;t<itbls.size();++t){
+ string itbl_name = itbls[t]->get_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<string> src_names;
+ string lfta_base = itbl_name.substr(0,itbl_name.size()-suffix_len);
+ for(s=0;s<silo_names.size();++s){
+ string lfta_subsilo = lfta_base + silo_names[s];
+//printf("\t%s\n",lfta_subsilo.c_str());
+ src_names.push_back(lfta_subsilo);
+ }
+ string merge_node_name = "desilo_"+query_plan[qtail[i]]->get_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<stream_query *> lfta_list,table_list *Schema,ext_fcn_list *Ext_fcns, vector<cnf_set *> &prefilter_preds, set<unsigned int> &pred_ids){
+ int s;
+ std::vector< std::vector<cnf_elem *> > where_list;
+
+// still safe to assume that LFTA queries have a single
+// query node, which is at position 0.
+ for(s=0;s<lfta_list.size();++s){
+ vector<cnf_elem *> 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;c<cnf_list.size();++c){
+ insert_gb_def_pr(cnf_list[c]->pr,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<stream_query *> lfta_list, col_id_set &temp_cids){
+ int s, sl;
+ vector<scalarexp_t *> 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;s<lfta_list.size();++s){
+
+ if(lfta_list[s]->query_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;sl<sl_list.size();sl++){
+ data_type *sdt = sl_list[sl]->get_data_type();
+ if (sdt->is_temporal()) {
+ gather_se_col_ids(sl_list[sl],temp_cids, gb_tbl);
+ }
+ }
+ }
+}
+
+
--- /dev/null
+/* ------------------------------------------------
+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<vector>
+#include<string>
+#include<map>
+
+#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<qp_node *> query_plan;
+ std::vector<ospec_str *> output_specs;
+ vector<qp_node *> output_operators;
+
+ int qhead;
+ std::vector<int> qtail;
+
+ table_def *attributes;
+ param_table *parameters;
+ std::map<std::string, std::string> 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<string,stream_query *> &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<string, int> lfta_names, vector<string> interface_names, vector<string> 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<string, int> lfta_names, vector<string> interface_names, vector<string> 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<stream_query*> 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<std::string> &libset);
+
+
+// Perform local FTA optimizations
+ void optimize(vector<stream_query *>& hfta_list, map<string, int> lfta_names, vector<string> interface_names, vector<string> 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<tablevar_t *> get_input_tables();
+
+ table_def *get_output_tabledef();
+
+// Extract lfta components of the query
+ std::vector<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);
+
+// Process and register opertor views
+ std::vector<table_exp_t *> extract_opview(table_list *Schema, std::vector<query_node *> &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<std::string, int> &lfta_names,std::vector<std::string> &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<int> &nfmt, std::map<std::string, int> &op_idx);
+
+
+
+};
+
+///////////////////////////////////////////////////////////////////////
+//// Related functions
+void get_common_lfta_filter(std::vector<stream_query *> lfta_list,table_list *Schema,ext_fcn_list *Ext_fcns, std::vector<cnf_set *> &prefilter_preds, std::set<unsigned int> &pred_ids);
+void get_prefilter_temporal_cids(std::vector<stream_query *> lfta_list, col_id_set &temp_cids);
+
+
+
+#endif
--- /dev/null
+/* ------------------------------------------------
+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 <string>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#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<nfiles;++f){
+
+ FILE *infl = fopen(argv[f+1],"r");
+ if(infl == NULL){
+ fprintf(stderr,"ERROR can't open schema file %s\n",argv[1]);
+ exit(1);
+ }
+
+ int sch_handle;
+ if(f%2==0){
+ sch_handle = ftaschema_parse_file(infl);
+ }else{
+ string fstr;
+ while(fgets(tmpstr, 1000, infl)){
+ fstr += tmpstr;
+ fstr += "\n";
+ }
+ sch_handle = ftaschema_parse_string( (char *)(fstr.c_str()) );
+ }
+
+ if(sch_handle < 0){
+ fprintf(stderr,"ERROR parsing schema file.\n");
+ exit(1);
+ }
+
+ ftaschema_debugdump(sch_handle);
+
+ fclose(infl);
+ }
+
+ printf("Testing access library.\n");
+
+// test_param1.q_0.sch
+
+ printf("Query %s has %d fields and %d parameters.\n",
+ ftaschema_name(0), ftaschema_tuple_len(0), ftaschema_parameter_len(0));
+ printf("The parameters are named:\n");
+ for(i=0;i<ftaschema_parameter_len(0);++i){
+ printf("%s ",ftaschema_parameter_name(0,i));
+ }
+ printf("\n");
+ printf("Setting parameters by name.\n");
+ sprintf(tmpstr,"%d",1111); printf("min_hdr_length : %s\n",tmpstr);
+ ftaschema_setparam_by_name(0,"min_hdr_length",tmpstr,strlen(tmpstr));
+ sprintf(tmpstr,"%d",2222); printf("unused_param : %s\n",tmpstr);
+ ftaschema_setparam_by_name(0,"unused_param",tmpstr,strlen(tmpstr));
+ printf("Creating param block.\n");
+ ftaschema_create_param_block(0,&pblock, &block_size);
+ printf("Block created, size is %d. Accessing by name.\n",block_size);
+ printf("\t%s=%d (type is %d) %s=%lu (type is %d)\n",
+ "time",
+ (ftaschema_get_field_by_name(0,"time",pblock, block_size)).r.i,
+ (ftaschema_get_field_by_name(0,"time",pblock, block_size)).field_data_type,
+ "hdr_length",
+ (ftaschema_get_field_by_name(0,"hdr_length",pblock, block_size)).r.ul,
+ (ftaschema_get_field_by_name(0,"hdr_length",pblock, block_size)).field_data_type
+ );
+
+ printf("Query %s has %d fields and %d parameters.\n",
+ ftaschema_name(1), ftaschema_tuple_len(1), ftaschema_parameter_len(1));
+ printf("The parameters are named:\n");
+ for(i=0;i<ftaschema_parameter_len(1);++i){
+ printf("%s ",ftaschema_parameter_name(1,i));
+ }
+
+ printf("\n");
+ printf("Setting parameters by index.\n");
+ sprintf(tmpstr,"%d",3333); printf("an_ullong_parameter : %s\n",tmpstr);
+ ftaschema_setparam_by_index(1,0,tmpstr,strlen(tmpstr));
+ sprintf(tmpstr,"%d",2222); printf("ullong_parameter2 : %s\n",tmpstr);
+ ftaschema_setparam_by_index(1,1,tmpstr,strlen(tmpstr));
+ sprintf(tmpstr,"%f",4444.0); printf("min_prec : %s\n",tmpstr);
+ ftaschema_setparam_by_index(1,2,tmpstr,strlen(tmpstr));
+ sprintf(tmpstr,"%s","Foo"); printf("min_str : %s\n",tmpstr);
+ ftaschema_setparam_by_index(1,3,tmpstr,strlen(tmpstr)+1);
+ sprintf(tmpstr,"%s","Bar"); printf("min_str : %s\n",tmpstr);
+ ftaschema_setparam_by_index(1,3,tmpstr,strlen(tmpstr)+1);
+ ftaschema_create_param_block(1,&pblock, &block_size);
+ printf("Block created, size is %d. Accessing by index.\n",block_size);
+ printf("\t%s=%ld, type is %d\n",
+ ftaschema_tuple_name(1,0),
+ (ftaschema_get_field_by_index(1,0,pblock, block_size)).r.ul,
+ (ftaschema_get_field_by_index(1,0,pblock, block_size)).field_data_type
+ );
+ printf("\t%s=%ld, type is %d\n",
+ ftaschema_tuple_name(1,1),
+ (ftaschema_get_field_by_index(1,1,pblock, block_size)).r.ul,
+ (ftaschema_get_field_by_index(1,1,pblock, block_size)).field_data_type
+ );
+ printf("\t%s=%lf, type is %d\n",
+ ftaschema_tuple_name(1,2),
+ (ftaschema_get_field_by_index(1,2,pblock, block_size)).r.f,
+ (ftaschema_get_field_by_index(1,2,pblock, block_size)).field_data_type
+ );
+ printf("\t%s=%s (length=%d), type is %d\n",
+ ftaschema_tuple_name(1,3),
+ (ftaschema_get_field_by_index(1,3,pblock, block_size)).r.vs.offset,
+ (ftaschema_get_field_by_index(1,3,pblock, block_size)).r.vs.length,
+ (ftaschema_get_field_by_index(1,3,pblock, block_size)).field_data_type
+ );
+
+
+
+}
--- /dev/null
+/* ------------------------------------------------
+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<unistd.h> // for gethostname
+
+#include <string>
+#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 <stdlib.h>
+#include <stdio.h>
+#include<ctype.h>
+
+#include<list>
+
+// for the scandir
+ #include <sys/types.h>
+ #include <dirent.h>
+
+
+#include<errno.h>
+
+// to verify that some files exist.
+ #include <sys/types.h>
+ #include <sys/stat.h>
+
+#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<std::string> xml_attr_vec;
+std::vector<std::string> 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<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
+ );
+
+//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<field_entry *> flds = sch->get_fields();
+ int f;
+ for(f=0;f<flds.size();++f){
+ if(f>0) fprintf(schema_summary_output,"|");
+ fprintf(schema_summary_output,"%s",flds[f]->get_name().c_str());
+ }
+ fprintf(schema_summary_output,"\n");
+ for(f=0;f<flds.size();++f){
+ if(f>0) 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<int>::iterator si;
+
+ vector<string> query_names; // for lfta.c registration
+ map<string, vector<int> > mach_query_names; // list queries of machine
+ vector<int> snap_lengths; // for lfta.c registration
+ vector<string> interface_names; // for lfta.c registration
+ vector<string> machine_names; // machine of interface
+ vector<bool> lfta_reuse_options; // for lfta.c registration
+ vector<int> lfta_liveness_timeouts; // fot qtree.xml generation
+ vector<string> hfta_names; // hfta cource code names, for
+ // creating make file.
+ vector<string> qnames; // ensure unique names
+ map<string, int> 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 <config directory>] [-l <library directory>] [-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 <config directory> for definition files\n"
+ "\t[-l] : use <library directory> 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<string> 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<string> 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<ospec_str *> output_specs;
+ multimap<string, int> 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<string,int>(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<string, int> 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<string, int> 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<string, vector<int> > rts_hload;
+ if((rtl_in = fopen(rtlspec_fl.c_str(), "r")) != NULL){
+ char *flds[MAXFLDS];
+ int r_lineno = 0;
+ string iface_name;
+ vector<int> 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<nflds;++j){
+ int h = atoi(flds[j]);
+ if(h<=0)
+ good_entry = false;
+ cumm_h += h;
+ hload.push_back(cumm_h);
+ }
+ }else{
+ good_entry = false;
+ }
+ if(good_entry){
+ rts_hload[iface_name] = hload;
+ }else{
+ fprintf(stderr,"Warning, line %d of %s is malformed, skipping.\n",r_lineno, rtlspec_fl.c_str());
+ }
+ }
+ }
+
+
+
+ if(output_query_names){
+ if((query_name_output = fopen("query_names.txt","w")) == NULL){
+ fprintf(stderr,"Can't open output file %s\n%s\n","query_names.txt",strerror(errno));
+ exit(1);
+ }
+ }
+
+ if(output_schema_summary){
+ if((schema_summary_output = fopen("schema_summary.txt","w")) == NULL){
+ fprintf(stderr,"Can't open output file %s\n%s\n","schema_summary.txt",strerror(errno));
+ exit(1);
+ }
+ }
+
+ if((qtree_output = fopen("qtree.xml","w")) == NULL){
+ fprintf(stderr,"Can't open output file %s\n%s\n","qtree.xml",strerror(errno));
+ exit(1);
+ }
+ fprintf(qtree_output,"<?xml version='1.0' encoding='ISO-8859-1'?>\n");
+ fprintf(qtree_output,"<?xml-stylesheet type='text/xsl' href='qtree.xsl'?>\n");
+ fprintf(qtree_output,"<QueryNodes>\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<string, string> lfta_val;
+ map<string, string> lfta_prefilter_val;
+
+ string lfta_header =
+"#include <limits.h>\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<x.length;++i){\n"
+" tmp_sum |= (x.data[i]) << (8*(i%4));\n"
+" if((i%4) == 3){\n"
+" ret ^= tmp_sum;\n"
+" tmp_sum = 0;\n"
+" }\n"
+" }\n"
+" if((i%4)!=0) ret ^=tmp_sum;\n"
+" return(ret);\n"
+"}\n\n\n";
+
+
+
+//////////////////////////////////////////////////////////////////
+///// Get all of the query parse trees
+
+
+ int i,p;
+ int hfta_count = 0; // for numeric suffixes to hfta .cc files
+
+//---------------------------
+// Global info needed for post processing.
+
+// Set of operator views ref'd in the query set.
+ opview_set opviews;
+// lftas on a per-machine basis.
+ map<string, vector<stream_query *> > lfta_mach_lists;
+ int nfiles = input_file_names.size();
+ vector<stream_query *> hfta_list; // list of hftas.
+ map<string, stream_query *> 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<string, string> 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<query_node *> qnodes; // for topo sort.
+ map<string,int> name_node_map; // map query name to qnodes entry
+ for(i=0;i<input_file_names.size();i++){
+
+ if((fta_in = fopen(input_file_names[i].c_str(), "r")) == NULL) {
+ fprintf(stderr,"Can't open input file %s\n%s",input_file_names[i].c_str(),strerror(errno));
+ continue;
+ }
+fprintf(stderr,"Parsing file %s\n",input_file_names[i].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);
+ }
+
+// returns a list of parse trees
+ vector<table_exp_t *> qlist = fta_parse_result->parse_tree_list->qlist;
+ for(p=0;p<qlist.size();++p){
+ table_exp_t *fta_parse_tree = qlist[p];
+// query_parse_trees.push_back(fta_parse_tree);
+
+// compute the default name -- extract from query name
+ strcpy(tmpstr,input_file_names[i].c_str());
+ char *qname = strrchr(tmpstr,PATH_DELIM);
+ if(qname == NULL)
+ qname = tmpstr;
+ else
+ qname++;
+ char *qname_end = strchr(qname,'.');
+ if(qname_end != NULL) *qname_end = '\0';
+ string qname_str = qname;
+ string imputed_qname = impute_query_name(fta_parse_tree, qname_str);
+
+// Deternmine visibility. Should I be attaching all of the output methods?
+ if(qname_to_ospec.count(imputed_qname)>0)
+ 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;pos<qnodes.size();++pos){
+ int fi;
+ for(fi = 0;fi<qnodes[pos]->refd_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<string, int> local_query_map;
+ vector<string> local_query_names;
+ vector<table_exp_t *> qlist = fta_parse_result->parse_tree_list->qlist;
+ for(p=0;p<qlist.size();++p){
+ table_exp_t *fta_parse_tree = qlist[p];
+ fta_parse_tree->set_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<int> worklist;
+ set<int> added_queries;
+ vector<query_node *> 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<worklist.size();++qq){
+ int q_id = worklist[qq];
+ query_node *new_qnode = new query_node(qpos+qq, local_query_names[q_id], qpathname, qlist[q_id] );
+ new_qnodes.push_back( new_qnode);
+ vector<string> refd_tbls = new_qnode->refd_tbls;
+ int ff;
+ for(ff = 0;ff<refd_tbls.size();++ff){
+ if(local_query_map.count(refd_tbls[ff])>0 && 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;qq<new_qnodes.size();++qq){
+ int qpos = qnodes.size();
+ qnodes.push_back(new_qnodes[qq]);
+ name_node_map[qnodes[qpos]->name ] = qpos;
+ qname_to_flname[qnodes[qpos]->name ] = qpathname;
+ }
+ }
+ }
+ }
+ }
+
+
+
+
+
+
+
+
+//---------------------------------------
+
+
+// Add the UDOPS.
+
+ string udop_missing_sources;
+ for(i=0;i<qnodes.size();++i){
+ int fi;
+ for(fi = 0;fi<qnodes[i]->refd_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;si<qnodes[pos]->refd_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<qnodes.size();++i){
+ int qi, fi;
+ vector<string> refd_tbls = qnodes[i]->refd_tbls;
+ for(fi = 0;fi<refd_tbls.size();++fi){
+ if(name_node_map.count(refd_tbls[fi])>0){
+//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<qnodes.size();++i){
+ vector<var_pair_t *> target_params = qnodes[i]->params;
+ for(si=qnodes[i]->reads_from.begin();si!=qnodes[i]->reads_from.end();++si){
+ vector<var_pair_t *> 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;p<target_params.size();++p){
+ if(! (target_params[p]->name == 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;i<qnodes.size();++i){
+ for(si=qnodes[i]->reads_from.begin();si!=qnodes[i]->reads_from.end();++si){
+ qnodes[(*si)]->n_consumers++;
+ }
+ }
+
+// The roots are the nodes with indegree zero.
+ set<int> roots;
+ for(i=0;i<qnodes.size();++i){
+ if(qnodes[i]->n_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<int> valid_roots;
+ set<int> discarded_nodes;
+ set<int> 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<int>::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;i<qnodes.size();++i){
+ if(discarded_nodes.count(i)==0)
+ for(si=qnodes[i]->reads_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<int> visible_nodes;
+ for(i=0;i<qnodes.size();i++){
+ if(qnodes[i]->is_externally_visible){
+ visible_nodes.push_back(i);
+ }
+ }
+
+// Find UDOPs referenced by visible nodes.
+ list<int> workq;
+ for(i=0;i<visible_nodes.size();++i){
+ workq.push_back(visible_nodes[i]);
+ }
+ while(!workq.empty()){
+ int node = workq.front();
+ workq.pop_front();
+ set<int>::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;i<qnodes.size();i++){
+ qnodes[i]->subtree_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<visible_nodes.size();++i){
+ set<int> 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<int>::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;i<qnodes.size();i++){
+ if(qnodes[i]->subtree_roots.size()>1){
+ bool is_new_root = true;
+ set<int>::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;i<qnodes.size();i++){
+// qnodes[i]->n_consumers = qnodes[i]->sources_to.size();
+// }
+ vector<int> 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<int>::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;i<qnodes.size();++i){
+ if(discarded_nodes.count(i)==0 && qnodes[i]->n_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_node *> hfta_sets;
+ map<string, int> hfta_name_map;
+// vector< vector<int> > process_sets;
+// vector< set<int> > stream_node_sets;
+ reverse(process_order.begin(), process_order.end()); // get listing in reverse order.
+ // i.e. process leaves 1st.
+ for(i=0;i<process_order.size();++i){
+ if(qnodes[process_order[i]]->is_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<int> proc_list; proc_list.push_back(root);
+// Ensure that nodes are added only once.
+ set<int> 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<int>::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;i<hfta_sets.size();++i){
+ hfta_node *hnode = hfta_sets[i];
+ for(q=0;q<hnode->query_node_indices.size();q++){
+ query_node *qnode = qnodes[hnode->query_node_indices[q]];
+ for(s=0;s<qnode->refd_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<int> hfta_topsort;
+ workq.clear();
+ int hnode_srcs[hfta_sets.size()];
+ for(i=0;i<hfta_sets.size();++i){
+ hnode_srcs[i] = 0;
+ if(hfta_sets[i]->sources_to.size() == 0)
+ workq.push_back(i);
+ }
+
+ while(! workq.empty()){
+ int node = workq.front();
+ workq.pop_front();
+ hfta_topsort.push_back(node);
+ set<int>::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<string, int>::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<int>::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;i<n_original_hfta_sets;++i){
+ if(hfta_sets[i]->n_parallel > 1){
+ hfta_sets[i]->do_generation =false; // set the deletion flag for this entry.
+ set<string> local_nodes; // names of query nodes in the hfta.
+ for(h=0;h<hfta_sets[i]->query_node_indices.size();++h){
+ local_nodes.insert(qnodes[ hfta_sets[i]->query_node_indices[h] ]->name);
+ }
+
+ for(p=0;p<hfta_sets[i]->n_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<string, int> 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<int>::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<string> new_sources;
+ for(rti=0;rti<qnodes[root]->refd_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;h<hfta_sets[i]->query_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;f<dup_pt->fm->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<string> 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;s<stride;++s){
+ string ext_src_name = hfta_sets[other_hidx]->name+"__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;f<dup_pt->fm->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;h<hfta_sets[i]->query_node_indices.size();++h){
+ int hqn_idx = hfta_sets[i]->query_node_indices[h];
+ for(f=0;f<qnodes[hqn_idx]->parse_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<string> src_tbls;
+ for(s=0;s<hfta_sets[other_hidx]->n_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;q<qnodes.size();++q){
+ qnodes[q]->reads_from.clear();
+ qnodes[q]->sources_to.clear();
+ }
+ for(q=0;q<qnodes.size();++q){
+ for(s=0;s<qnodes[q]->refd_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;q<hfta_sets.size();++q){
+ hfta_sets[q]->reads_from.clear();
+ hfta_sets[q]->sources_to.clear();
+ }
+ for(q=0;q<hfta_sets.size();++q){
+ for(s=0;s<hfta_sets[q]->query_node_indices.size();++s){
+ int node = hfta_sets[q]->query_node_indices[s];
+ set<int>::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;q<qnodes.size();++q){
+ printf("qnode %d reads-from %d:",q,qnodes[q]->reads_from.size());
+ set<int>::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;q<hfta_sets.size();++q){
+ if(hfta_sets[q]->do_generation==false)
+ continue;
+ printf("hfta %d (%s) reads-from %d:",q,hfta_sets[q]->name.c_str(),hfta_sets[q]->reads_from.size());
+ set<int>::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;i<hfta_sets.size();++i){
+ hnode_srcs_2[i] = 0;
+ if(hfta_sets[i]->sources_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<int>::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;i<hfta_sets.size();++i){
+ if(hfta_sets[i]->do_generation){
+ map<int,int> n_accounted;
+ vector<int> new_order;
+ workq.clear();
+ vector<int>::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<int>::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<int>::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<stream_query *> lfta_list;
+
+ stream_query *rootq;
+
+ int qi,qj;
+
+ for(qi=hfta_topsort.size()-1;qi>=0;--qi){
+
+ int hfta_id = hfta_topsort[qi];
+ vector<int> 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<subquery_spec *> subq = Schema->get_subqueryspecs(udop_schref);
+ int s,f,q;
+ for(s=0;s<subq.size();++s){
+// Validate that the fields match.
+ subquery_spec *sqs = subq[s];
+ string subq_name = sqs->name + opv->mangler;
+ vector<field_entry *> 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;f<sqs->types.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;q<qnodes.size();++q)
+ if(qnodes[q]->name == 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<int>::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<tablevar_t *> tblvars = qnodes[(*sii)]->parse_tree->get_from()->get_table_list();
+ int ii;
+ for(ii=0;ii<tblvars.size();++ii){
+ if(tblvars[ii]->schema_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<int> curr_list = process_sets[qi];
+
+
+////////////////////////////////////////
+
+ rootq = NULL;
+//printf("Process set %d, has %d queries\n",qi,curr_list.size());
+ for(qj=0;qj<curr_list.size();++qj){
+ i = curr_list[qj];
+ fprintf(stderr,"Processing query %s (file %s) is_udop = %d\n",qnodes[i]->name.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<string> refd_tbls = fm->get_src_tbls(Schema);
+// iterate over all referenced tables
+ int t;
+ for(t=0;t<refd_tbls.size();++t){
+ int tbl_ref = Schema->get_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;tl<fta_parse_result->tables->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<string, int>::iterator, multimap<string, int>::iterator > oset;
+ multimap<string, int>::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<stream_query *> 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;l<split_queries.size();++l){
+//printf("split query %d is %s\n",l,split_queries[l]->q`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;l<n_lfta;++l){
+ if(lfta_names.count(split_queries[l]->query_name) == 0){
+// Grab the lfta for global optimization.
+ vector<tablevar_t *> 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<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);
+ }
+ }
+
+ 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;l<hfta_nbr;++l){
+ string lfta_name =split_queries[l]->query_name;
+ fprintf(query_name_output,"%s L\n",lfta_name.c_str());
+ }
+ }
+// else{
+// fprintf(stderr,"query names are ");
+// for(l=0;l<hfta_nbr;++l){
+// if(l>0) 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;i<lfta_list.size();i++){
+ lfta_list[i]->generate_protocol_se(sq_map, Schema);
+ sq_map[lfta_list[i]->get_sq_name()] = lfta_list[i];
+}
+for(i=0;i<hfta_list.size();i++){
+ hfta_list[i]->generate_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<string> extra_external_libs;
+
+for(i=0;i<hfta_list.size();++i){ // query also has an HFTA component
+
+ if(! debug_only){
+// build hfta file name, create output
+ if(numeric_hfta_flname){
+ sprintf(tmpstr,"hfta_%d",hfta_count);
+ hfta_names.push_back(tmpstr);
+ sprintf(tmpstr,"hfta_%d.cc",hfta_count);
+ }else{
+ sprintf(tmpstr,"hfta_%s",hfta_list[i]->query_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<field_entry *> flds = hfta_list[i]->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 HFTA stream %s:\n%s",
+ hfta_list[i]->get_output_tabledef()->get_tbl_name().c_str(),warning_str.c_str());
+ }
+
+ fprintf(qtree_output,"\t<HFTA name='%s'>\n",hfta_list[i]->get_output_tabledef()->get_tbl_name().c_str());
+ if(hfta_comment != "")
+ fprintf(qtree_output,"\t\t<Description value='%s' />\n",hfta_comment.c_str());
+ if(hfta_title != "")
+ fprintf(qtree_output,"\t\t<Title value='%s' />\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);
+}
+
+*/
+
--- /dev/null
+/* ------------------------------------------------
+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
+
--- /dev/null
+/* ------------------------------------------------
+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");
+ }
+
+}
+
--- /dev/null
+/* ------------------------------------------------
+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
--- /dev/null
+/* ------------------------------------------------
+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;
+}
+
+
+
+
+
--- /dev/null
+/* 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
+
+\f
+
+#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 */
+
+\f
+
+#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;
+ }
+}
+\f
+
+/* 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"
+\f
+ 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"
+
+
+
+
--- /dev/null
+/* 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;
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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;}
+ ;
+
+
+
+
+
+%%
+
+
--- /dev/null
+/* ------------------------------------------------
+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
+
--- /dev/null
+#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;
+}
+
+
+
+
+
--- /dev/null
+# ------------------------------------------------
+# 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
+
--- /dev/null
+# ------------------------------------------------
+# 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
+
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+# ------------------------------------------------
+# 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
--- /dev/null
+// 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);
+}
--- /dev/null
+// 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
--- /dev/null
+/* ------------------------------------------------
+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);
+}
+
--- /dev/null
+// 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;
+}
--- /dev/null
+// 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
--- /dev/null
+/* ------------------------------------------------
+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;
+}
--- /dev/null
+# ------------------------------------------------
+# 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
+
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+/* ------------------------------------------------
+ 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;
+};
+
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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;
+}
+
+
--- /dev/null
+/* ------------------------------------------------
+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);
+ }
+
--- /dev/null
+# ------------------------------------------------
+# 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
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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
--- /dev/null
+/* ------------------------------------------------
+ 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;
+ }
+
+
+
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+/* ------------------------------------------------
+ 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);
+ }
+}
--- /dev/null
+# ------------------------------------------------
+# 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):
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
--- /dev/null
+# ------------------------------------------------
+# 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
+
--- /dev/null
+#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;
+}
--- /dev/null
+#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 */
+}
--- /dev/null
+#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);
+}
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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;
+}
+
+
--- /dev/null
+/* ------------------------------------------------
+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) { }
+
--- /dev/null
+# ------------------------------------------------
+# 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
--- /dev/null
+/* ------------------------------------------------
+ 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;
+ }
+
+
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
+
+
+
--- /dev/null
+/* ------------------------------------------------
+ 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;
+}
+
--- /dev/null
+# ------------------------------------------------
+# 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
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+ }
+
+}
--- /dev/null
+/* ------------------------------------------------
+ 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);
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+ }
+ }
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+ }
+ }
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+}
+
--- /dev/null
+/* ------------------------------------------------
+ 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);
+ }
+
+}
--- /dev/null
+/* ------------------------------------------------
+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;
+}
+
+
+
--- /dev/null
+/* ------------------------------------------------
+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
--- /dev/null
+/* ------------------------------------------------
+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;
+}
+
+
+
+
+
--- /dev/null
+/* 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
+
+\f
+
+#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 */
+\f
+
+/*-----------------------------------------------.
+| 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;
+ }
+}
+\f
+
+/* 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"
+
+
+
+
--- /dev/null
+/* 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;
+
--- /dev/null
+/* ------------------------------------------------
+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);}
+ ;
+
+
+
+
+
+%%
+
+
--- /dev/null
+/* ------------------------------------------------
+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);
+ }
+ }
+}
--- /dev/null
+/* ------------------------------------------------
+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
+
--- /dev/null
+#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;
+}
+
+
+
+
+
--- /dev/null
+This directory should contain the binaries for all views.
Code Review / com / gs-lite.git / commitdiff
