You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hawq.apache.org by es...@apache.org on 2016/09/08 05:21:18 UTC
[39/54] [partial] incubator-hawq git commit: HAWQ-959. revert thrift
build commands.
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/928eade3/depends/thirdparty/thrift/compiler/cpp/src/generate/t_delphi_generator.cc
----------------------------------------------------------------------
diff --git a/depends/thirdparty/thrift/compiler/cpp/src/generate/t_delphi_generator.cc b/depends/thirdparty/thrift/compiler/cpp/src/generate/t_delphi_generator.cc
deleted file mode 100644
index cdf49c6..0000000
--- a/depends/thirdparty/thrift/compiler/cpp/src/generate/t_delphi_generator.cc
+++ /dev/null
@@ -1,3900 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
- * Contains some contributions under the Thrift Software License.
- * Please see doc/old-thrift-license.txt in the Thrift distribution for
- * details.
- */
-
-#include <cassert>
-
-#include <string>
-#include <fstream>
-#include <iostream>
-#include <vector>
-#include <list>
-
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sstream>
-#include <cctype>
-
-#include "platform.h"
-#include "t_oop_generator.h"
-
-using std::map;
-using std::ofstream;
-using std::ostream;
-using std::ostringstream;
-using std::string;
-using std::stringstream;
-using std::vector;
-
-static const string endl = "\n"; // avoid ostream << std::endl flushes
-
-class t_delphi_generator : public t_oop_generator {
-public:
- t_delphi_generator(t_program* program,
- const std::map<std::string, std::string>& parsed_options,
- const std::string& option_string)
- : t_oop_generator(program) {
- (void)option_string;
- indent_impl_ = 0;
- has_forward = false;
- has_enum = false;
- has_const = false;
- std::map<std::string, std::string>::const_iterator iter;
-
- iter = parsed_options.find("ansistr_binary");
- ansistr_binary_ = (iter != parsed_options.end());
- iter = parsed_options.find("register_types");
- register_types_ = (iter != parsed_options.end());
- iter = parsed_options.find("constprefix");
- constprefix_ = (iter != parsed_options.end());
- iter = parsed_options.find("events");
- events_ = (iter != parsed_options.end());
- iter = parsed_options.find("xmldoc");
- xmldoc_ = (iter != parsed_options.end());
-
- out_dir_base_ = "gen-delphi";
- escape_.clear();
- escape_['\''] = "''";
- }
-
- void init_generator();
- void close_generator();
-
- void generate_consts(std::vector<t_const*> consts);
-
- void generate_typedef(t_typedef* ttypedef);
- void generate_enum(t_enum* tenum);
- void generate_forward_declaration(t_struct* tstruct);
- void generate_struct(t_struct* tstruct);
- void generate_xception(t_struct* txception);
- void generate_service(t_service* tservice);
- void generate_property(ostream& out, t_field* tfield, bool isPublic, bool is_xception);
- void generate_property_writer_(ostream& out, t_field* tfield, bool isPublic);
-
- void generate_delphi_property(ostream& out,
- bool struct_is_exception,
- t_field* tfield,
- bool isPublic,
- std::string fieldPrefix = "");
- void generate_delphi_isset_reader_definition(ostream& out, t_field* tfield, bool is_xception);
- void generate_delphi_property_reader_definition(ostream& out,
- t_field* tfield,
- bool is_xception_class);
- void generate_delphi_property_writer_definition(ostream& out,
- t_field* tfield,
- bool is_xception_class);
- void generate_delphi_property_reader_impl(ostream& out,
- std::string cls_prefix,
- std::string name,
- t_type* type,
- t_field* tfield,
- std::string fieldPrefix,
- bool is_xception_class);
- void generate_delphi_property_writer_impl(ostream& out,
- std::string cls_prefix,
- std::string name,
- t_type* type,
- t_field* tfield,
- std::string fieldPrefix,
- bool is_xception_class,
- bool is_union,
- bool is_xception_factory,
- std::string xception_factroy_name);
- void generate_delphi_clear_union_value(ostream& out,
- std::string cls_prefix,
- std::string name,
- t_type* type,
- t_field* tfield,
- std::string fieldPrefix,
- bool is_xception_class,
- bool is_union,
- bool is_xception_factory,
- std::string xception_factroy_name);
- void generate_delphi_isset_reader_impl(ostream& out,
- std::string cls_prefix,
- std::string name,
- t_type* type,
- t_field* tfield,
- std::string fieldPrefix,
- bool is_xception);
- void generate_delphi_struct_writer_impl(ostream& out,
- std::string cls_prefix,
- t_struct* tstruct,
- bool is_exception);
- void generate_delphi_struct_result_writer_impl(ostream& out,
- std::string cls_prefix,
- t_struct* tstruct,
- bool is_exception);
-
- void generate_delphi_struct_tostring_impl(ostream& out,
- std::string cls_prefix,
- t_struct* tstruct,
- bool is_exception,
- bool is_x_factory);
-
- void add_delphi_uses_list(string unitname);
-
- void generate_delphi_struct_reader_impl(ostream& out,
- std::string cls_prefix,
- t_struct* tstruct,
- bool is_exception);
- void generate_delphi_create_exception_impl(ostream& out,
- string cls_prefix,
- t_struct* tstruct,
- bool is_exception);
-
- bool const_needs_var(t_type* type);
- void print_const_prop(std::ostream& out, string name, t_type* type, t_const_value* value);
- void print_private_field(std::ostream& out, string name, t_type* type, t_const_value* value);
- void print_const_value(std::ostream& vars,
- std::ostream& out,
- std::string name,
- t_type* type,
- t_const_value* value);
- void initialize_field(std::ostream& vars,
- std::ostream& out,
- std::string name,
- t_type* type,
- t_const_value* value);
- void finalize_field(std::ostream& out,
- std::string name,
- t_type* type,
- t_const_value* value,
- std::string cls_nm = "");
- std::string render_const_value(std::ostream& local_vars,
- std::ostream& out,
- std::string name,
- t_type* type,
- t_const_value* value);
- void print_const_def_value(std::ostream& vars,
- std::ostream& out,
- std::string name,
- t_type* type,
- t_const_value* value,
- std::string cls_nm = "");
- std::string make_constants_classname();
-
- void generate_delphi_struct(t_struct* tstruct, bool is_exception);
- void generate_delphi_struct_impl(ostream& out,
- std::string cls_prefix,
- t_struct* tstruct,
- bool is_exception,
- bool is_result = false,
- bool is_x_factory = false);
- void print_delphi_struct_type_factory_func(ostream& out, t_struct* tstruct);
- void generate_delphi_struct_type_factory(ostream& out,
- std::string cls_prefix,
- t_struct* tstruct,
- bool is_exception,
- bool is_result = false,
- bool is_x_factory = false);
- void generate_delphi_struct_type_factory_registration(ostream& out,
- std::string cls_prefix,
- t_struct* tstruct,
- bool is_exception,
- bool is_result = false,
- bool is_x_factory = false);
- void generate_delphi_struct_definition(std::ostream& out,
- t_struct* tstruct,
- bool is_xception = false,
- bool in_class = false,
- bool is_result = false,
- bool is_x_factory = false);
- void generate_delphi_struct_reader(std::ostream& out, t_struct* tstruct);
- void generate_delphi_struct_result_writer(std::ostream& out, t_struct* tstruct);
- void generate_delphi_struct_writer(std::ostream& out, t_struct* tstruct);
- void generate_delphi_struct_tostring(std::ostream& out, t_struct* tstruct);
-
- void generate_function_helpers(t_function* tfunction);
- void generate_service_interface(t_service* tservice);
- void generate_service_helpers(t_service* tservice);
- void generate_service_client(t_service* tservice);
- void generate_service_server(t_service* tservice);
- void generate_process_function(t_service* tservice, t_function* function);
-
- void generate_deserialize_field(std::ostream& out,
- bool is_xception,
- t_field* tfield,
- std::string prefix,
- std::ostream& local_vars);
- void generate_deserialize_struct(std::ostream& out,
- t_struct* tstruct,
- std::string name,
- std::string prefix);
- void generate_deserialize_container(ostream& out,
- bool is_xception,
- t_type* ttype,
- string name,
- std::ostream& local_vars);
-
- void generate_deserialize_set_element(std::ostream& out,
- bool is_xception,
- t_set* tset,
- std::string prefix,
- std::ostream& local_vars);
- void generate_deserialize_map_element(std::ostream& out,
- bool is_xception,
- t_map* tmap,
- std::string prefix,
- std::ostream& local_vars);
- void generate_deserialize_list_element(std::ostream& out,
- bool is_xception,
- t_list* list,
- std::string prefix,
- std::ostream& local_vars);
-
- void generate_serialize_field(std::ostream& out,
- bool is_xception,
- t_field* tfield,
- std::string prefix,
- std::ostream& local_vars);
- void generate_serialize_struct(std::ostream& out,
- t_struct* tstruct,
- std::string prefix,
- std::ostream& local_vars);
- void generate_serialize_container(std::ostream& out,
- bool is_xception,
- t_type* ttype,
- std::string prefix,
- std::ostream& local_vars);
- void generate_serialize_map_element(std::ostream& out,
- bool is_xception,
- t_map* tmap,
- std::string iter,
- std::string map,
- std::ostream& local_vars);
- void generate_serialize_set_element(std::ostream& out,
- bool is_xception,
- t_set* tmap,
- std::string iter,
- std::ostream& local_vars);
- void generate_serialize_list_element(std::ostream& out,
- bool is_xception,
- t_list* tlist,
- std::string iter,
- std::ostream& local_vars);
-
- void delphi_type_usings(std::ostream& out);
- std::string delphi_thrift_usings();
-
- std::string type_name(t_type* ttype,
- bool b_cls = false,
- bool b_no_postfix = false,
- bool b_exception_factory = false,
- bool b_full_exception_factory = false);
- std::string normalize_clsnm(std::string name,
- std::string prefix,
- bool b_no_check_keyword = false);
- std::string make_valid_delphi_identifier(std::string const& fromName);
- std::string input_arg_prefix(t_type* ttype);
-
- std::string base_type_name(t_base_type* tbase);
- std::string declare_field(t_field* tfield,
- bool init = false,
- std::string prefix = "",
- bool is_xception_class = false);
- std::string function_signature(t_function* tfunction,
- std::string full_cls = "",
- bool is_xception = false);
- std::string argument_list(t_struct* tstruct);
- std::string constructor_argument_list(t_struct* tstruct, std::string current_indent);
- std::string type_to_enum(t_type* ttype);
- std::string prop_name(t_field* tfield, bool is_xception = false);
- std::string prop_name(std::string name, bool is_xception = false);
- std::string constructor_param_name(string name);
-
- void write_enum(std::string line);
- void write_forward_decr(std::string line);
- void write_const(std::string line);
- void write_struct(std::string line);
- void write_service(std::string line);
-
- virtual std::string autogen_comment() {
- return std::string("(**\n") + " * Autogenerated by Thrift Compiler (" + THRIFT_VERSION + ")\n"
- + " *\n" + " * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING\n"
- + " *)\n";
- }
-
- string replace_all(string contents, string search, string replace);
- string xml_encode(string contents);
- string xmldoc_encode(string contents);
- string xmlattrib_encode(string contents);
- void generate_delphi_doc(std::ostream& out, t_field* field);
- void generate_delphi_doc(std::ostream& out, t_doc* tdoc);
- void generate_delphi_doc(std::ostream& out, t_function* tdoc);
- void generate_delphi_docstring_comment(std::ostream& out, string contents);
-
- bool type_can_be_null(t_type* ttype) {
- while (ttype->is_typedef()) {
- ttype = ((t_typedef*)ttype)->get_type();
- }
-
- return ttype->is_container() || ttype->is_struct() || ttype->is_xception();
- }
-
-private:
- std::string namespace_name_;
- std::ostringstream s_forward_decr;
- std::ostringstream s_enum;
- std::ostringstream s_const;
- std::ostringstream s_struct;
- std::ostringstream s_service;
- std::ostringstream s_const_impl;
- std::ostringstream s_struct_impl;
- std::ostringstream s_service_impl;
- std::ostringstream s_type_factory_registration;
- std::ostringstream s_type_factory_funcs;
- bool has_forward;
- bool has_enum;
- bool has_const;
- std::string namespace_dir_;
- std::map<std::string, int> delphi_keywords;
- std::map<std::string, int> delphi_reserved_method;
- std::map<std::string, int> delphi_reserved_method_exception;
- std::map<std::string, int> types_known;
- std::list<t_typedef*> typedefs_pending;
- std::vector<std::string> uses_list;
- void create_keywords();
- bool find_keyword(std::map<std::string, int>& keyword_map, std::string name);
- std::string normalize_name(std::string name,
- bool b_method = false,
- bool b_exception_method = false);
- std::string empty_value(t_type* type);
- bool is_fully_defined_type(t_type* ttype);
- void add_defined_type(t_type* ttype);
- void init_known_types_list();
- bool is_void(t_type* type);
- int indent_impl_;
- bool ansistr_binary_;
- bool register_types_;
- bool constprefix_;
- bool events_;
- bool xmldoc_;
- void indent_up_impl() { ++indent_impl_; };
- void indent_down_impl() { --indent_impl_; };
- std::string indent_impl() {
- std::string ind = "";
- int i;
- for (i = 0; i < indent_impl_; ++i) {
- ind += " ";
- }
- return ind;
- };
- std::ostream& indent_impl(std::ostream& os) { return os << indent_impl(); };
-};
-
-string t_delphi_generator::replace_all(string contents, string search, string repl) {
- string str(contents);
-
- size_t slen = search.length();
- size_t rlen = repl.length();
- size_t incr = (rlen > 0) ? rlen : 1;
-
- if (slen > 0) {
- size_t found = str.find(search);
- while ((found != string::npos) && (found < str.length())) {
- str.replace(found, slen, repl);
- found = str.find(search, found + incr);
- }
- }
-
- return str;
-}
-
-// XML encoding
-string t_delphi_generator::xml_encode(string contents) {
- string str(contents);
-
- // escape the escape
- str = replace_all(str, "&", "&");
-
- // other standard XML entities
- str = replace_all(str, "<", "<");
- str = replace_all(str, ">", ">");
-
- return str;
-}
-
-// XML attribute encoding
-string t_delphi_generator::xmlattrib_encode(string contents) {
- string str(xml_encode(contents));
-
- // our attribs are enclosed in "
- str = replace_all(str, "\"", "\\\"");
-
- return str;
-}
-
-// XML encoding for doc comments
-string t_delphi_generator::xmldoc_encode(string contents) {
- string str(xml_encode(contents));
-
- // XMLDoc specific: convert linebreaks into <para>graphs</para>
- str = replace_all(str, "\r\n", "\r");
- str = replace_all(str, "\n", "\r");
- str = replace_all(str, "\r", "</para>\n<para>");
-
- return str;
-}
-
-void t_delphi_generator::generate_delphi_docstring_comment(ostream& out, string contents) {
- if (xmldoc_) {
- generate_docstring_comment(out,
- "{$REGION 'XMLDoc'}/// <summary>\n",
- "/// ",
- "<para>" + contents + "</para>",
- "/// </summary>\n{$ENDREGION}\n");
- }
-}
-
-void t_delphi_generator::generate_delphi_doc(ostream& out, t_field* field) {
- if (xmldoc_) {
- if (field->get_type()->is_enum()) {
- string combined_message = xmldoc_encode(field->get_doc()) + "\n<seealso cref=\""
- + xmldoc_encode(type_name(field->get_type())) + "\"/>";
- generate_delphi_docstring_comment(out, combined_message);
- } else {
- generate_delphi_doc(out, (t_doc*)field);
- }
- }
-}
-
-void t_delphi_generator::generate_delphi_doc(ostream& out, t_doc* tdoc) {
- if (tdoc->has_doc() && xmldoc_) {
- generate_delphi_docstring_comment(out, xmldoc_encode(tdoc->get_doc()));
- }
-}
-
-void t_delphi_generator::generate_delphi_doc(ostream& out, t_function* tfunction) {
- if (tfunction->has_doc() && xmldoc_) {
- stringstream ps;
- const vector<t_field*>& fields = tfunction->get_arglist()->get_members();
- vector<t_field*>::const_iterator p_iter;
- for (p_iter = fields.begin(); p_iter != fields.end(); ++p_iter) {
- t_field* p = *p_iter;
- ps << "\n<param name=\"" << xmlattrib_encode(p->get_name()) << "\">";
- if (p->has_doc()) {
- std::string str = p->get_doc();
- str.erase(std::remove(str.begin(), str.end(), '\n'),
- str.end()); // remove the newlines that appear from the parser
- ps << xmldoc_encode(str);
- }
- ps << "</param>";
- }
- generate_docstring_comment(out,
- "{$REGION 'XMLDoc'}",
- "/// ",
- "<summary><para>" + xmldoc_encode(tfunction->get_doc())
- + "</para></summary>" + ps.str(),
- "{$ENDREGION}\n");
- }
-}
-
-bool t_delphi_generator::find_keyword(std::map<std::string, int>& keyword_map, std::string name) {
- std::string::size_type len = name.length();
-
- if (len <= 0) {
- return false;
- }
-
- std::string::size_type nlast = name.find_last_of('_');
-
- if (nlast >= 1) {
- if (nlast == (len - 1)) {
- string new_name(name, 0, nlast);
- return find_keyword(keyword_map, new_name);
- }
- }
- return (keyword_map[name] == 1);
-}
-
-std::string t_delphi_generator::normalize_name(std::string name,
- bool b_method,
- bool b_exception_method) {
- string tmp(name);
- std::transform(tmp.begin(), tmp.end(), tmp.begin(), static_cast<int (*)(int)>(std::tolower));
-
- bool b_found = false;
-
- if (find_keyword(delphi_keywords, tmp)) {
- b_found = true;
- } else if (b_method && find_keyword(delphi_reserved_method, tmp)) {
- b_found = true;
- } else if (b_exception_method && find_keyword(delphi_reserved_method_exception, tmp)) {
- b_found = true;
- }
-
- if (b_found) {
- return name + "_";
- } else {
- return name;
- }
-}
-
-void t_delphi_generator::create_keywords() {
- delphi_keywords["and"] = 1;
- delphi_keywords["end"] = 1;
- delphi_keywords["interface"] = 1;
- delphi_keywords["raise"] = 1;
- delphi_keywords["uses"] = 1;
- delphi_keywords["array"] = 1;
- delphi_keywords["except"] = 1;
- delphi_keywords["is"] = 1;
- delphi_keywords["record"] = 1;
- delphi_keywords["var"] = 1;
- delphi_keywords["as"] = 1;
- delphi_keywords["exports"] = 1;
- delphi_keywords["label"] = 1;
- delphi_keywords["repeat"] = 1;
- delphi_keywords["while"] = 1;
- delphi_keywords["asm"] = 1;
- delphi_keywords["file"] = 1;
- delphi_keywords["library"] = 1;
- delphi_keywords["resourcestring"] = 1;
- delphi_keywords["with"] = 1;
- delphi_keywords["begin"] = 1;
- delphi_keywords["finalization"] = 1;
- delphi_keywords["mod"] = 1;
- delphi_keywords["set"] = 1;
- delphi_keywords["xor"] = 1;
- delphi_keywords["case"] = 1;
- delphi_keywords["finally"] = 1;
- delphi_keywords["nil"] = 1;
- delphi_keywords["shl"] = 1;
- delphi_keywords["class"] = 1;
- delphi_keywords["for"] = 1;
- delphi_keywords["not"] = 1;
- delphi_keywords["shr"] = 1;
- delphi_keywords["const"] = 1;
- delphi_keywords["function"] = 1;
- delphi_keywords["object"] = 1;
- delphi_keywords["string"] = 1;
- delphi_keywords["constructor"] = 1;
- delphi_keywords["goto"] = 1;
- delphi_keywords["of"] = 1;
- delphi_keywords["then"] = 1;
- delphi_keywords["destructor"] = 1;
- delphi_keywords["if"] = 1;
- delphi_keywords["or"] = 1;
- delphi_keywords["threadvar"] = 1;
- delphi_keywords["dispinterface"] = 1;
- delphi_keywords["implementation"] = 1;
- delphi_keywords["out"] = 1;
- delphi_keywords["to"] = 1;
- delphi_keywords["div"] = 1;
- delphi_keywords["in"] = 1;
- delphi_keywords["packed"] = 1;
- delphi_keywords["try"] = 1;
- delphi_keywords["do"] = 1;
- delphi_keywords["inherited"] = 1;
- delphi_keywords["procedure"] = 1;
- delphi_keywords["type"] = 1;
- delphi_keywords["downto"] = 1;
- delphi_keywords["initialization"] = 1;
- delphi_keywords["program"] = 1;
- delphi_keywords["unit"] = 1;
- delphi_keywords["else"] = 1;
- delphi_keywords["inline"] = 1;
- delphi_keywords["property"] = 1;
- delphi_keywords["until"] = 1;
- delphi_keywords["private"] = 1;
- delphi_keywords["protected"] = 1;
- delphi_keywords["public"] = 1;
- delphi_keywords["published"] = 1;
- delphi_keywords["automated"] = 1;
- delphi_keywords["at"] = 1;
- delphi_keywords["on"] = 1;
-
- // reserved/predefined variables and types (lowercase!)
- delphi_keywords["result"] = 1;
- delphi_keywords["tbytes"] = 1;
- delphi_keywords["tobject"] = 1;
- delphi_keywords["tclass"] = 1;
- delphi_keywords["tinterfacedobject"] = 1;
-
- delphi_reserved_method["create"] = 1;
- delphi_reserved_method["free"] = 1;
- delphi_reserved_method["initinstance"] = 1;
- delphi_reserved_method["cleanupinstance"] = 1;
- delphi_reserved_method["classtype"] = 1;
- delphi_reserved_method["classname"] = 1;
- delphi_reserved_method["classnameis"] = 1;
- delphi_reserved_method["classparent"] = 1;
- delphi_reserved_method["classinfo"] = 1;
- delphi_reserved_method["instancesize"] = 1;
- delphi_reserved_method["inheritsfrom"] = 1;
- delphi_reserved_method["methodaddress"] = 1;
- delphi_reserved_method["methodaddress"] = 1;
- delphi_reserved_method["methodname"] = 1;
- delphi_reserved_method["fieldaddress"] = 1;
- delphi_reserved_method["fieldaddress"] = 1;
- delphi_reserved_method["getinterface"] = 1;
- delphi_reserved_method["getinterfaceentry"] = 1;
- delphi_reserved_method["getinterfacetable"] = 1;
- delphi_reserved_method["unitname"] = 1;
- delphi_reserved_method["equals"] = 1;
- delphi_reserved_method["gethashcode"] = 1;
- delphi_reserved_method["tostring"] = 1;
- delphi_reserved_method["safecallexception"] = 1;
- delphi_reserved_method["afterconstruction"] = 1;
- delphi_reserved_method["beforedestruction"] = 1;
- delphi_reserved_method["dispatch"] = 1;
- delphi_reserved_method["defaulthandler"] = 1;
- delphi_reserved_method["newinstance"] = 1;
- delphi_reserved_method["freeinstance"] = 1;
- delphi_reserved_method["destroy"] = 1;
- delphi_reserved_method["read"] = 1;
- delphi_reserved_method["write"] = 1;
-
- delphi_reserved_method_exception["setinnerexception"] = 1;
- delphi_reserved_method_exception["setstackinfo"] = 1;
- delphi_reserved_method_exception["getstacktrace"] = 1;
- delphi_reserved_method_exception["raisingexception"] = 1;
- delphi_reserved_method_exception["createfmt"] = 1;
- delphi_reserved_method_exception["createres"] = 1;
- delphi_reserved_method_exception["createresfmt"] = 1;
- delphi_reserved_method_exception["createhelp"] = 1;
- delphi_reserved_method_exception["createfmthelp"] = 1;
- delphi_reserved_method_exception["createreshelp"] = 1;
- delphi_reserved_method_exception["createresfmthelp"] = 1;
- delphi_reserved_method_exception["getbaseexception"] = 1;
- delphi_reserved_method_exception["baseexception"] = 1;
- delphi_reserved_method_exception["helpcontext"] = 1;
- delphi_reserved_method_exception["innerexception"] = 1;
- delphi_reserved_method_exception["message"] = 1;
- delphi_reserved_method_exception["stacktrace"] = 1;
- delphi_reserved_method_exception["stackinfo"] = 1;
- delphi_reserved_method_exception["getexceptionstackinfoproc"] = 1;
- delphi_reserved_method_exception["getstackinfostringproc"] = 1;
- delphi_reserved_method_exception["cleanupstackinfoproc"] = 1;
- delphi_reserved_method_exception["raiseouterexception"] = 1;
- delphi_reserved_method_exception["throwouterexception"] = 1;
-}
-
-void t_delphi_generator::add_delphi_uses_list(string unitname) {
- vector<std::string>::const_iterator s_iter;
- bool found = false;
- for (s_iter = uses_list.begin(); s_iter != uses_list.end(); ++s_iter) {
- if ((*s_iter) == unitname) {
- found = true;
- break;
- }
- }
- if (!found) {
- uses_list.push_back(unitname);
- }
-}
-
-void t_delphi_generator::init_generator() {
- indent_impl_ = 0;
- namespace_name_ = program_->get_namespace("delphi");
- has_forward = false;
- has_enum = false;
- has_const = false;
- create_keywords();
- add_delphi_uses_list("Classes");
- add_delphi_uses_list("SysUtils");
- add_delphi_uses_list("Generics.Collections");
- add_delphi_uses_list("Thrift");
- add_delphi_uses_list("Thrift.Utils");
- add_delphi_uses_list("Thrift.Collections");
- add_delphi_uses_list("Thrift.Protocol");
- add_delphi_uses_list("Thrift.Transport");
-
- if (register_types_) {
- add_delphi_uses_list("Thrift.TypeRegistry");
- }
-
- init_known_types_list();
-
- string unitname, nsname;
- const vector<t_program*>& includes = program_->get_includes();
- for (size_t i = 0; i < includes.size(); ++i) {
- unitname = includes[i]->get_name();
- nsname = includes[i]->get_namespace("delphi");
- if ("" != nsname) {
- unitname = nsname;
- }
- add_delphi_uses_list(unitname);
- }
-
- MKDIR(get_out_dir().c_str());
-}
-
-void t_delphi_generator::close_generator() {
- std::string unitname = program_name_;
- if ("" != namespace_name_) {
- unitname = namespace_name_;
- }
-
- for (int i = 0; i < (int)unitname.size(); i++) {
- if (unitname[i] == ' ') {
- unitname.replace(i, 1, "_");
- }
- }
-
- std::string f_name = get_out_dir() + "/" + unitname + ".pas";
- std::ofstream f_all;
-
- f_all.open(f_name.c_str());
-
- f_all << autogen_comment() << endl;
- generate_delphi_doc(f_all, program_);
- f_all << "unit " << unitname << ";" << endl << endl;
- f_all << "interface" << endl << endl;
- f_all << "uses" << endl;
-
- indent_up();
-
- vector<std::string>::const_iterator s_iter;
- for (s_iter = uses_list.begin(); s_iter != uses_list.end(); ++s_iter) {
- if (s_iter != uses_list.begin()) {
- f_all << ",";
- f_all << endl;
- }
- indent(f_all) << *s_iter;
- }
-
- f_all << ";" << endl << endl;
-
- indent_down();
-
- string tmp_unit(unitname);
- for (int i = 0; i < (int)tmp_unit.size(); i++) {
- if (tmp_unit[i] == '.') {
- tmp_unit.replace(i, 1, "_");
- }
- }
-
- f_all << "const" << endl;
- indent_up();
- indent(f_all) << "c" << tmp_unit
- << "_Option_AnsiStr_Binary = " << (ansistr_binary_ ? "True" : "False") << ";"
- << endl;
- indent(f_all) << "c" << tmp_unit
- << "_Option_Register_Types = " << (register_types_ ? "True" : "False") << ";"
- << endl;
- indent(f_all) << "c" << tmp_unit
- << "_Option_ConstPrefix = " << (constprefix_ ? "True" : "False") << ";" << endl;
- indent(f_all) << "c" << tmp_unit << "_Option_Events = " << (events_ ? "True" : "False")
- << ";" << endl;
- indent(f_all) << "c" << tmp_unit << "_Option_XmlDoc = " << (xmldoc_ ? "True" : "False")
- << ";" << endl;
- indent_down();
-
- f_all << endl;
- f_all << "type" << endl;
- if (has_forward) {
- f_all << s_forward_decr.str() << endl;
- }
- if (has_enum) {
- indent(f_all) << endl;
- indent(f_all) << "{$SCOPEDENUMS ON}" << endl << endl;
- f_all << s_enum.str();
- indent(f_all) << "{$SCOPEDENUMS OFF}" << endl << endl;
- }
- f_all << s_struct.str();
- f_all << s_service.str();
- f_all << s_const.str();
- f_all << "implementation" << endl << endl;
- f_all << s_struct_impl.str();
- f_all << s_service_impl.str();
- f_all << s_const_impl.str();
-
- if (register_types_) {
- f_all << endl;
- f_all << "// Type factory methods and registration" << endl;
- f_all << s_type_factory_funcs.str();
- f_all << "procedure RegisterTypeFactories;" << endl;
- f_all << "begin" << endl;
- f_all << s_type_factory_registration.str();
- f_all << "end;" << endl;
- }
- f_all << endl;
-
- string constants_class = make_constants_classname();
-
- f_all << "initialization" << endl;
- if (has_const) {
- f_all << "{$IF CompilerVersion < 21.0} // D2010" << endl;
- f_all << " " << constants_class.c_str() << "_Initialize;" << endl;
- f_all << "{$IFEND}" << endl;
- }
- if (register_types_) {
- f_all << " RegisterTypeFactories;" << endl;
- }
- f_all << endl;
-
- f_all << "finalization" << endl;
- if (has_const) {
- f_all << "{$IF CompilerVersion < 21.0} // D2010" << endl;
- f_all << " " << constants_class.c_str() << "_Finalize;" << endl;
- f_all << "{$IFEND}" << endl;
- }
- f_all << endl << endl;
-
- f_all << "end." << endl;
- f_all.close();
-
- if (!typedefs_pending.empty()) {
- pwarning(0, "%d typedefs with unresolved type references left:\n", typedefs_pending.size());
- for (std::list<t_typedef*>::iterator iter = typedefs_pending.begin();
- typedefs_pending.end() != iter;
- ++iter) {
- pwarning(0, "- %s\n", (*iter)->get_symbolic().c_str());
- }
- }
-}
-
-void t_delphi_generator::delphi_type_usings(ostream& out) {
- indent_up();
- indent(out) << "Classes, SysUtils, Generics.Collections, Thrift.Collections, Thrift.Protocol,"
- << endl;
- indent(out) << "Thrift.Transport;" << endl << endl;
- indent_down();
-}
-
-void t_delphi_generator::generate_forward_declaration(t_struct* tstruct) {
- // Forward declare struct def
- has_forward = true;
- pverbose("forward declaration of %s\n", type_name(tstruct).c_str());
-
- string what = tstruct->is_xception() ? "class" : "interface";
-
- indent_up();
- indent(s_forward_decr) << type_name(tstruct, tstruct->is_xception(), true) << " = " << what << ";"
- << endl;
- indent_down();
-
- add_defined_type(tstruct);
-}
-
-void t_delphi_generator::generate_typedef(t_typedef* ttypedef) {
- t_type* type = ttypedef->get_type();
-
- // write now or save for later?
- if (!is_fully_defined_type(type)) {
- pverbose("typedef %s: unresolved dependencies found\n", type_name(ttypedef).c_str());
- typedefs_pending.push_back(ttypedef);
- return;
- }
-
- indent_up();
- generate_delphi_doc(s_struct, ttypedef);
- indent(s_struct) << type_name(ttypedef) << " = ";
-
- // commented out: the benefit is not big enough to risk breaking existing code
- // bool container = type->is_list() || type->is_map() || type->is_set();
- // if( ! container)
- // s_struct << "type "; //the "type A = type B" syntax leads to E2574 with generics
-
- s_struct << type_name(ttypedef->get_type()) << ";" << endl << endl;
- indent_down();
-
- add_defined_type(ttypedef);
-}
-
-bool t_delphi_generator::is_fully_defined_type(t_type* ttype) {
- if ((NULL != ttype->get_program()) && (ttype->get_program() != program_)) {
- t_scope* scope = ttype->get_program()->scope();
- if (NULL != scope->get_type(ttype->get_name())) {
- // printf("type %s found in included scope %s\n", ttype->get_name().c_str(),
- // ttype->get_program()->get_name().c_str());
- return true;
- }
- }
-
- if (ttype->is_typedef()) {
- return (1 == types_known[type_name(ttype)]);
- }
-
- if (ttype->is_base_type()) {
- return (1 == types_known[base_type_name((t_base_type*)ttype)]);
- } else if (ttype->is_enum()) {
- return true; // enums are written first, before all other types
- } else if (ttype->is_map()) {
- t_map* tmap = (t_map*)ttype;
- return is_fully_defined_type(tmap->get_key_type())
- && is_fully_defined_type(tmap->get_val_type());
- } else if (ttype->is_set()) {
- t_set* tset = (t_set*)ttype;
- return is_fully_defined_type(tset->get_elem_type());
- } else if (ttype->is_list()) {
- t_list* tlist = (t_list*)ttype;
- return is_fully_defined_type(tlist->get_elem_type());
- }
-
- return (1 == types_known[type_name(ttype)]);
-}
-
-void t_delphi_generator::add_defined_type(t_type* ttype) {
- // mark as known type
- types_known[type_name(ttype)] = 1;
-
- // check all pending typedefs
- std::list<t_typedef*>::iterator iter;
- bool more = true;
- while (more && (!typedefs_pending.empty())) {
- more = false;
-
- for (iter = typedefs_pending.begin(); typedefs_pending.end() != iter; ++iter) {
- t_typedef* ttypedef = (*iter);
- if (is_fully_defined_type(ttypedef->get_type())) {
- pverbose("typedef %s: all pending references are now resolved\n",
- type_name(ttypedef).c_str());
- typedefs_pending.erase(iter);
- generate_typedef(ttypedef);
- more = true;
- break;
- }
- }
- }
-}
-
-void t_delphi_generator::init_known_types_list() {
- // known base types
- types_known[type_name(g_type_string)] = 1;
- types_known[type_name(g_type_binary)] = 1;
- types_known[type_name(g_type_bool)] = 1;
- types_known[type_name(g_type_byte)] = 1;
- types_known[type_name(g_type_i16)] = 1;
- types_known[type_name(g_type_i32)] = 1;
- types_known[type_name(g_type_i64)] = 1;
- types_known[type_name(g_type_double)] = 1;
-}
-
-void t_delphi_generator::generate_enum(t_enum* tenum) {
- has_enum = true;
- indent_up();
- generate_delphi_doc(s_enum, tenum);
- indent(s_enum) << type_name(tenum, true, true) << " = "
- << "(" << endl;
- indent_up();
- vector<t_enum_value*> constants = tenum->get_constants();
- if (constants.empty()) {
- indent(s_enum) << "dummy = 0 // empty enums are not allowed";
- } else {
- vector<t_enum_value*>::iterator c_iter;
- for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
- int value = (*c_iter)->get_value();
- if (c_iter != constants.begin()) {
- s_enum << ",";
- s_enum << endl;
- }
- generate_delphi_doc(s_enum, *c_iter);
- indent(s_enum) << normalize_name((*c_iter)->get_name()) << " = " << value;
- }
- }
- s_enum << endl;
- indent_down();
- indent(s_enum) << ");" << endl << endl;
- indent_down();
-}
-
-std::string t_delphi_generator::make_valid_delphi_identifier(std::string const& fromName) {
- std::string str = fromName;
- if (str.empty()) {
- return str;
- }
-
- // tests rely on this
- assert(('A' < 'Z') && ('a' < 'z') && ('0' < '9'));
-
- // if the first letter is a number, we add an additional underscore in front of it
- char c = str.at(0);
- if (('0' <= c) && (c <= '9')) {
- str = "_" + str;
- }
-
- // following chars: letter, number or underscore
- for (size_t i = 0; i < str.size(); ++i) {
- c = str.at(i);
- if ((('A' > c) || (c > 'Z')) && (('a' > c) || (c > 'z')) && (('0' > c) || (c > '9'))
- && ('_' != c)) {
- str.replace(i, 1, "_");
- }
- }
-
- return str;
-}
-
-std::string t_delphi_generator::make_constants_classname() {
- if (constprefix_) {
- return make_valid_delphi_identifier("T" + program_name_ + "Constants");
- } else {
- return "TConstants"; // compatibility
- }
-}
-
-void t_delphi_generator::generate_consts(std::vector<t_const*> consts) {
- if (consts.empty()) {
- return;
- }
-
- has_const = true;
- string constants_class = make_constants_classname();
-
- indent_up();
- indent(s_const) << constants_class.c_str() << " = class" << endl;
- indent(s_const) << "private" << endl;
- indent_up();
- vector<t_const*>::iterator c_iter;
- for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
- if (const_needs_var((*c_iter)->get_type())) {
- print_private_field(s_const,
- normalize_name((*c_iter)->get_name()),
- (*c_iter)->get_type(),
- (*c_iter)->get_value());
- }
- }
- indent_down();
- indent(s_const) << "public" << endl;
- indent_up();
- for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
- generate_delphi_doc(s_const, *c_iter);
- print_const_prop(s_const,
- normalize_name((*c_iter)->get_name()),
- (*c_iter)->get_type(),
- (*c_iter)->get_value());
- }
- indent(s_const) << "{$IF CompilerVersion >= 21.0}" << endl;
- indent(s_const) << "class constructor Create;" << endl;
- indent(s_const) << "class destructor Destroy;" << endl;
- indent(s_const) << "{$IFEND}" << endl;
- indent_down();
- indent(s_const) << "end;" << endl << endl;
- indent_down();
-
- std::ostringstream vars, code;
-
- indent_up_impl();
- for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
- initialize_field(vars,
- code,
- "F" + prop_name((*c_iter)->get_name()),
- (*c_iter)->get_type(),
- (*c_iter)->get_value());
- }
- indent_down_impl();
-
- indent_impl(s_const_impl) << "{$IF CompilerVersion >= 21.0}" << endl;
- indent_impl(s_const_impl) << "class constructor " << constants_class.c_str() << ".Create;"
- << endl;
-
- if (!vars.str().empty()) {
- indent_impl(s_const_impl) << "var" << endl;
- s_const_impl << vars.str();
- }
- indent_impl(s_const_impl) << "begin" << endl;
- if (!code.str().empty()) {
- s_const_impl << code.str();
- }
- indent_impl(s_const_impl) << "end;" << endl << endl;
- indent_impl(s_const_impl) << "class destructor " << constants_class.c_str() << ".Destroy;"
- << endl;
- indent_impl(s_const_impl) << "begin" << endl;
- indent_up_impl();
- for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
- if (const_needs_var((*c_iter)->get_type())) {
- finalize_field(s_const_impl,
- normalize_name((*c_iter)->get_name()),
- (*c_iter)->get_type(),
- (*c_iter)->get_value());
- }
- }
- indent_impl(s_const_impl) << "inherited;" << endl;
- indent_down_impl();
- indent_impl(s_const_impl) << "end;" << endl;
- indent_impl(s_const_impl) << "{$ELSE}" << endl;
-
- vars.str("");
- code.str("");
-
- indent_up_impl();
- for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
- if (const_needs_var((*c_iter)->get_type())) {
- initialize_field(vars,
- code,
- constants_class + ".F" + prop_name((*c_iter)->get_name()),
- (*c_iter)->get_type(),
- (*c_iter)->get_value());
- }
- }
- indent_down_impl();
-
- indent_impl(s_const_impl) << "procedure " << constants_class.c_str() << "_Initialize;" << endl;
- if (!vars.str().empty()) {
- indent_impl(s_const_impl) << "var" << endl;
- s_const_impl << vars.str();
- }
- indent_impl(s_const_impl) << "begin" << endl;
- if (!code.str().empty()) {
- s_const_impl << code.str();
- }
- indent_impl(s_const_impl) << "end;" << endl << endl;
-
- indent_impl(s_const_impl) << "procedure " << constants_class.c_str() << "_Finalize;" << endl;
- indent_impl(s_const_impl) << "begin" << endl;
- indent_up_impl();
- for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
- finalize_field(s_const_impl,
- normalize_name((*c_iter)->get_name()),
- (*c_iter)->get_type(),
- (*c_iter)->get_value(),
- constants_class);
- }
- indent_down_impl();
- indent_impl(s_const_impl) << "end;" << endl;
- indent_impl(s_const_impl) << "{$IFEND}" << endl << endl;
-}
-
-void t_delphi_generator::print_const_def_value(std::ostream& vars,
- std::ostream& out,
- string name,
- t_type* type,
- t_const_value* value,
- string cls_nm) {
-
- string cls_prefix;
-
- if (cls_nm == "") {
- cls_prefix = "";
- } else {
- cls_prefix = cls_nm + ".";
- }
-
- if (type->is_struct() || type->is_xception()) {
- const vector<t_field*>& fields = ((t_struct*)type)->get_members();
- vector<t_field*>::const_iterator f_iter;
- const map<t_const_value*, t_const_value*>& val = value->get_map();
- map<t_const_value*, t_const_value*>::const_iterator v_iter;
- for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
- t_type* field_type = NULL;
- for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
- if ((*f_iter)->get_name() == v_iter->first->get_string()) {
- field_type = (*f_iter)->get_type();
- }
- }
- if (field_type == NULL) {
- throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
- }
- string val = render_const_value(vars, out, name, field_type, v_iter->second);
- indent_impl(out) << cls_prefix << normalize_name(name) << "."
- << prop_name(v_iter->first->get_string(), type->is_xception())
- << " := " << val << ";" << endl;
- }
- } else if (type->is_map()) {
- t_type* ktype = ((t_map*)type)->get_key_type();
- t_type* vtype = ((t_map*)type)->get_val_type();
- const map<t_const_value*, t_const_value*>& val = value->get_map();
- map<t_const_value*, t_const_value*>::const_iterator v_iter;
- for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
- string key = render_const_value(vars, out, name, ktype, v_iter->first);
- string val = render_const_value(vars, out, name, vtype, v_iter->second);
- indent_impl(out) << cls_prefix << normalize_name(name) << "[" << key << "]"
- << " := " << val << ";" << endl;
- }
- } else if (type->is_list() || type->is_set()) {
- t_type* etype;
- if (type->is_list()) {
- etype = ((t_list*)type)->get_elem_type();
- } else {
- etype = ((t_set*)type)->get_elem_type();
- }
-
- const vector<t_const_value*>& val = value->get_list();
- vector<t_const_value*>::const_iterator v_iter;
- for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
- string val = render_const_value(vars, out, name, etype, *v_iter);
- indent_impl(out) << cls_prefix << normalize_name(name) << ".Add(" << val << ");" << endl;
- }
- }
-}
-
-void t_delphi_generator::print_private_field(std::ostream& out,
- string name,
- t_type* type,
- t_const_value* value) {
- (void)value;
- indent(out) << "class var F" << name << ": " << type_name(type) << ";" << endl;
-}
-
-bool t_delphi_generator::const_needs_var(t_type* type) {
- t_type* truetype = type;
- while (truetype->is_typedef()) {
- truetype = ((t_typedef*)truetype)->get_type();
- }
- return (!truetype->is_base_type());
-}
-
-void t_delphi_generator::print_const_prop(std::ostream& out,
- string name,
- t_type* type,
- t_const_value* value) {
- (void)value;
- if (const_needs_var(type)) {
- indent(out) << "class property " << name << ": " << type_name(type) << " read F" << name << ";"
- << endl;
- } else {
- std::ostringstream vars; // dummy
- string v2 = render_const_value(vars, out, name, type, value);
- indent(out) << "const " << name << " = " << v2 << ";" << endl;
- }
-}
-
-void t_delphi_generator::print_const_value(std::ostream& vars,
- std::ostream& out,
- string name,
- t_type* type,
- t_const_value* value) {
- t_type* truetype = type;
- while (truetype->is_typedef()) {
- truetype = ((t_typedef*)truetype)->get_type();
- }
-
- if (truetype->is_base_type()) {
- // already done
- // string v2 = render_const_value( vars, out, name, type, value);
- // indent_impl(out) << name << " := " << v2 << ";" << endl;
- } else if (truetype->is_enum()) {
- indent_impl(out) << name << " := " << type_name(type) << "." << value->get_identifier_name()
- << ";" << endl;
- } else {
- string typname;
- typname = type_name(truetype, true, false, type->is_xception(), type->is_xception());
- indent_impl(out) << name << " := " << typname << ".Create;" << endl;
- print_const_def_value(vars, out, name, truetype, value);
- }
-}
-
-void t_delphi_generator::initialize_field(std::ostream& vars,
- std::ostream& out,
- string name,
- t_type* type,
- t_const_value* value) {
- print_const_value(vars, out, name, type, value);
-}
-
-void t_delphi_generator::finalize_field(std::ostream& out,
- string name,
- t_type* type,
- t_const_value* value,
- string cls_nm) {
- (void)out;
- (void)name;
- (void)type;
- (void)value;
- (void)cls_nm;
-}
-
-string t_delphi_generator::render_const_value(ostream& vars,
- ostream& out,
- string name,
- t_type* type,
- t_const_value* value) {
- (void)name;
-
- t_type* truetype = type;
- while (truetype->is_typedef()) {
- truetype = ((t_typedef*)truetype)->get_type();
- }
-
- std::ostringstream render;
-
- if (truetype->is_base_type()) {
- t_base_type::t_base tbase = ((t_base_type*)truetype)->get_base();
- switch (tbase) {
- case t_base_type::TYPE_STRING:
- render << "'" << get_escaped_string(value) << "'";
- break;
- case t_base_type::TYPE_BOOL:
- render << ((value->get_integer() > 0) ? "True" : "False");
- break;
- case t_base_type::TYPE_BYTE:
- render << "ShortInt( " << value->get_integer() << ")";
- break;
- case t_base_type::TYPE_I16:
- render << "SmallInt( " << value->get_integer() << ")";
- break;
- case t_base_type::TYPE_I32:
- render << "LongInt( " << value->get_integer() << ")";
- break;
- case t_base_type::TYPE_I64:
- render << "Int64( " << value->get_integer() << ")";
- break;
- case t_base_type::TYPE_DOUBLE:
- if (value->get_type() == t_const_value::CV_INTEGER) {
- render << value->get_integer() << ".0"; // make it a double constant by adding ".0"
- } else {
- render << value->get_double();
- }
- break;
- default:
- throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
- }
- } else if (truetype->is_enum()) {
- render << type_name(type, false) << "." << value->get_identifier_name();
- } else {
- string t = tmp("tmp");
- vars << " " << t << " : " << type_name(type) << ";" << endl;
- print_const_value(vars, out, t, type, value);
- render << t;
- }
-
- return render.str();
-}
-
-void t_delphi_generator::generate_struct(t_struct* tstruct) {
- generate_delphi_struct(tstruct, false);
-}
-
-void t_delphi_generator::generate_xception(t_struct* txception) {
- generate_delphi_struct(txception, true);
-}
-
-void t_delphi_generator::generate_delphi_struct(t_struct* tstruct, bool is_exception) {
- indent_up();
- generate_delphi_struct_definition(s_struct, tstruct, is_exception);
- indent_down();
-
- add_defined_type(tstruct);
-
- generate_delphi_struct_impl(s_struct_impl, "", tstruct, is_exception);
- if (register_types_) {
- generate_delphi_struct_type_factory(s_type_factory_funcs, "", tstruct, is_exception);
- generate_delphi_struct_type_factory_registration(s_type_factory_registration,
- "",
- tstruct,
- is_exception);
- }
-}
-
-void t_delphi_generator::generate_delphi_struct_impl(ostream& out,
- string cls_prefix,
- t_struct* tstruct,
- bool is_exception,
- bool is_result,
- bool is_x_factory) {
-
- if (is_exception && (!is_x_factory)) {
- generate_delphi_struct_impl(out, cls_prefix, tstruct, is_exception, is_result, true);
- }
-
- string cls_nm;
-
- string exception_factory_name;
-
- if (is_exception) {
- exception_factory_name = normalize_clsnm(tstruct->get_name(), "", true) + "Factory";
- }
-
- if (is_exception) {
- cls_nm = type_name(tstruct, true, (!is_x_factory), is_x_factory, true);
- } else {
- cls_nm = type_name(tstruct, true, false);
- }
-
- std::ostringstream vars, code;
-
- const vector<t_field*>& members = tstruct->get_members();
- vector<t_field*>::const_iterator m_iter;
-
- indent_up_impl();
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- t_type* t = (*m_iter)->get_type();
- while (t->is_typedef()) {
- t = ((t_typedef*)t)->get_type();
- }
- if ((*m_iter)->get_value() != NULL) {
- initialize_field(vars,
- code,
- "F" + prop_name((*m_iter)->get_name(), is_exception),
- t,
- (*m_iter)->get_value());
- if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
- indent_impl(code) << "F__isset_" << prop_name((*m_iter), is_exception) << " := True;"
- << endl;
- }
- }
- }
- indent_down_impl();
-
- indent_impl(out) << "constructor " << cls_prefix << cls_nm << "."
- << "Create;" << endl;
-
- if (!vars.str().empty()) {
- out << "var" << endl;
- out << vars.str();
- }
-
- indent_impl(out) << "begin" << endl;
- indent_up_impl();
- if (is_exception && (!is_x_factory)) {
- indent_impl(out) << "inherited Create('');" << endl;
- indent_impl(out) << "F" << exception_factory_name << " := T" << exception_factory_name
- << "Impl.Create;" << endl;
- } else {
- indent_impl(out) << "inherited;" << endl;
- }
-
- if (!code.str().empty()) {
- out << code.str();
- }
-
- indent_down_impl();
- indent_impl(out) << "end;" << endl << endl;
-
- if ((members.size() > 0) && is_exception && (!is_x_factory)) {
- indent_impl(out) << "constructor " << cls_prefix << cls_nm << "."
- << "Create(" << constructor_argument_list(tstruct, indent_impl()) << ");"
- << endl;
- indent_impl(out) << "begin" << endl;
- indent_up_impl();
- indent_impl(out) << "Create;" << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- string propname = prop_name((*m_iter)->get_name(), is_exception);
- string param_name = constructor_param_name((*m_iter)->get_name());
- indent_impl(out) << propname << " := " << param_name << ";" << endl;
- }
- indent_impl(out) << "UpdateMessageProperty;" << endl;
- indent_down_impl();
- indent_impl(out) << "end;" << endl << endl;
- }
-
- indent_impl(out) << "destructor " << cls_prefix << cls_nm << "."
- << "Destroy;" << endl;
- indent_impl(out) << "begin" << endl;
- indent_up_impl();
-
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- t_type* t = (*m_iter)->get_type();
- while (t->is_typedef()) {
- t = ((t_typedef*)t)->get_type();
- }
- finalize_field(out, prop_name(*m_iter, is_exception), t, (*m_iter)->get_value());
- }
-
- indent_impl(out) << "inherited;" << endl;
- indent_down_impl();
- indent_impl(out) << "end;" << endl << endl;
-
- if (tstruct->is_union()) {
- indent_impl(out) << "procedure " << cls_prefix << cls_nm << "."
- << "ClearUnionValues;" << endl;
- indent_impl(out) << "begin" << endl;
- indent_up_impl();
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- t_type* t = (*m_iter)->get_type();
- while (t->is_typedef()) {
- t = ((t_typedef*)t)->get_type();
- }
-
- generate_delphi_clear_union_value(out,
- cls_prefix,
- cls_nm,
- t,
- *m_iter,
- "F",
- is_exception,
- tstruct->is_union(),
- is_x_factory,
- exception_factory_name);
- }
- indent_down_impl();
- indent_impl(out) << "end;" << endl << endl;
- }
-
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- t_type* t = (*m_iter)->get_type();
- while (t->is_typedef()) {
- t = ((t_typedef*)t)->get_type();
- }
- generate_delphi_property_reader_impl(out, cls_prefix, cls_nm, t, *m_iter, "F", is_exception);
- generate_delphi_property_writer_impl(out,
- cls_prefix,
- cls_nm,
- t,
- *m_iter,
- "F",
- is_exception,
- tstruct->is_union(),
- is_x_factory,
- exception_factory_name);
- if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
- generate_delphi_isset_reader_impl(out, cls_prefix, cls_nm, t, *m_iter, "F", is_exception);
- }
- }
-
- if ((!is_exception) || is_x_factory) {
- generate_delphi_struct_reader_impl(out, cls_prefix, tstruct, is_exception);
- if (is_result) {
- generate_delphi_struct_result_writer_impl(out, cls_prefix, tstruct, is_exception);
- } else {
- generate_delphi_struct_writer_impl(out, cls_prefix, tstruct, is_exception);
- }
- }
- generate_delphi_struct_tostring_impl(out, cls_prefix, tstruct, is_exception, is_x_factory);
-
- if (is_exception && is_x_factory) {
- generate_delphi_create_exception_impl(out, cls_prefix, tstruct, is_exception);
- }
-}
-
-void t_delphi_generator::print_delphi_struct_type_factory_func(ostream& out, t_struct* tstruct) {
- string struct_intf_name = type_name(tstruct);
- out << "Create_";
- out << struct_intf_name;
- out << "_Impl";
-}
-
-void t_delphi_generator::generate_delphi_struct_type_factory(ostream& out,
- string cls_prefix,
- t_struct* tstruct,
- bool is_exception,
- bool is_result,
- bool is_x_factory) {
- (void)cls_prefix;
- if (is_exception)
- return;
- if (is_result)
- return;
- if (is_x_factory)
- return;
-
- string struct_intf_name = type_name(tstruct);
- string cls_nm = type_name(tstruct, true, false);
-
- out << "function ";
- print_delphi_struct_type_factory_func(out, tstruct);
- out << ": ";
- out << struct_intf_name;
- out << ";" << endl;
- out << "begin" << endl;
- indent_up();
- indent(out) << "Result := " << cls_nm << ".Create;" << endl;
- indent_down();
- out << "end;" << endl << endl;
-}
-
-void t_delphi_generator::generate_delphi_struct_type_factory_registration(ostream& out,
- string cls_prefix,
- t_struct* tstruct,
- bool is_exception,
- bool is_result,
- bool is_x_factory) {
- (void)cls_prefix;
- if (is_exception)
- return;
- if (is_result)
- return;
- if (is_x_factory)
- return;
-
- string struct_intf_name = type_name(tstruct);
-
- indent(out) << " TypeRegistry.RegisterTypeFactory<" << struct_intf_name << ">(";
- print_delphi_struct_type_factory_func(out, tstruct);
- out << ");";
- out << endl;
-}
-
-void t_delphi_generator::generate_delphi_struct_definition(ostream& out,
- t_struct* tstruct,
- bool is_exception,
- bool in_class,
- bool is_result,
- bool is_x_factory) {
- bool is_final = (tstruct->annotations_.find("final") != tstruct->annotations_.end());
- string struct_intf_name;
- string struct_name;
- string isset_name;
- const vector<t_field*>& members = tstruct->get_members();
- vector<t_field*>::const_iterator m_iter;
-
- string exception_factory_name = normalize_clsnm(tstruct->get_name(), "", true) + "Factory";
-
- if (is_exception) {
- struct_intf_name = type_name(tstruct, false, false, true);
- } else {
- struct_intf_name = type_name(tstruct);
- }
-
- if (is_exception) {
- struct_name = type_name(tstruct, true, (!is_x_factory), is_x_factory);
- } else {
- struct_name = type_name(tstruct, true);
- }
-
- if ((!is_exception) || is_x_factory) {
-
- generate_delphi_doc(out, tstruct);
- indent(out) << struct_intf_name << " = interface(IBase)" << endl;
- indent_up();
-
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- generate_delphi_property_reader_definition(out, *m_iter, is_exception);
- generate_delphi_property_writer_definition(out, *m_iter, is_exception);
- }
-
- if (is_x_factory) {
- out << endl;
- indent(out) << "// Create Exception Object" << endl;
- indent(out) << "function CreateException: " << type_name(tstruct, true, true) << ";" << endl;
- }
-
- if (members.size() > 0) {
- out << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- generate_property(out, *m_iter, true, is_exception);
- }
- }
-
- if (members.size() > 0) {
- out << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
- generate_delphi_isset_reader_definition(out, *m_iter, is_exception);
- }
- }
- }
-
- if (members.size() > 0) {
- out << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
- isset_name = "__isset_" + prop_name(*m_iter, is_exception);
- indent(out) << "property " << isset_name << ": Boolean read Get" << isset_name << ";"
- << endl;
- }
- }
- }
-
- indent_down();
- indent(out) << "end;" << endl << endl;
- }
-
- generate_delphi_doc(out, tstruct);
- indent(out) << struct_name << " = ";
- if (is_final) {
- out << "sealed ";
- }
- out << "class(";
- if (is_exception && (!is_x_factory)) {
- out << "TException";
- } else {
- out << "TInterfacedObject, IBase, " << struct_intf_name;
- }
- out << ")" << endl;
-
- if (is_exception && (!is_x_factory)) {
- indent(out) << "public" << endl;
- indent_up();
- indent(out) << "type" << endl;
- indent_up();
- generate_delphi_struct_definition(out, tstruct, is_exception, in_class, is_result, true);
- indent_down();
- indent_down();
- }
-
- indent(out) << "private" << endl;
- indent_up();
-
- if (is_exception && (!is_x_factory)) {
- indent(out) << "F" << exception_factory_name << " :" << struct_intf_name << ";" << endl << endl;
- }
-
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- indent(out) << declare_field(*m_iter, false, "F", is_exception) << endl;
- }
-
- if (members.size() > 0) {
- indent(out) << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
- isset_name = "F__isset_" + prop_name(*m_iter, is_exception);
- indent(out) << isset_name << ": Boolean;" << endl;
- }
- }
- }
-
- indent(out) << endl;
-
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- generate_delphi_property_reader_definition(out, *m_iter, is_exception);
- generate_delphi_property_writer_definition(out, *m_iter, is_exception);
- }
-
- if (tstruct->is_union()) {
- out << endl;
- indent(out) << "// Clear values(for union's property setter)" << endl;
- indent(out) << "procedure ClearUnionValues;" << endl;
- }
-
- if (members.size() > 0) {
- out << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
- isset_name = "__isset_" + prop_name(*m_iter, is_exception);
- indent(out) << "function Get" << isset_name << ": Boolean;" << endl;
- }
- }
- }
-
- indent_down();
-
- indent(out) << "public" << endl;
- indent_up();
-
- if ((members.size() > 0) && is_exception && (!is_x_factory)) {
- indent(out) << "constructor Create; overload;" << endl;
- indent(out) << "constructor Create(" << constructor_argument_list(tstruct, indent())
- << "); overload;" << endl;
- } else {
- indent(out) << "constructor Create;" << endl;
- }
-
- indent(out) << "destructor Destroy; override;" << endl;
-
- out << endl;
- indent(out) << "function ToString: string; override;" << endl;
-
- if (is_exception && (!is_x_factory)) {
- out << endl;
- indent(out) << "// Exception Factory" << endl;
- indent(out) << "property " << exception_factory_name << ": " << struct_intf_name << " read F"
- << exception_factory_name << " write F" << exception_factory_name << ";" << endl;
- }
-
- if ((!is_exception) || is_x_factory) {
- out << endl;
- indent(out) << "// IBase" << endl;
- indent(out) << "procedure Read( const iprot: IProtocol);" << endl;
- indent(out) << "procedure Write( const oprot: IProtocol);" << endl;
- }
-
- if (is_exception && is_x_factory) {
- out << endl;
- indent(out) << "// Create Exception Object" << endl;
- indent(out) << "function CreateException: " << type_name(tstruct, true, true) << ";" << endl;
- }
-
- if (members.size() > 0) {
- out << endl;
- indent(out) << "// Properties" << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- generate_property(out, *m_iter, true, is_exception);
- }
- }
-
- if (members.size() > 0) {
- out << endl;
- indent(out) << "// isset" << endl;
- for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
- if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
- isset_name = "__isset_" + prop_name(*m_iter, is_exception);
- indent(out) << "property " << isset_name << ": Boolean read Get" << isset_name << ";"
- << endl;
- }
- }
- }
-
- indent_down();
- indent(out) << "end;" << endl << endl;
-}
-
-void t_delphi_generator::generate_service(t_service* tservice) {
- indent_up();
- generate_delphi_doc(s_service, tservice);
- indent(s_service) << normalize_clsnm(service_name_, "T") << " = class" << endl;
- indent(s_service) << "public" << endl;
- indent_up();
- indent(s_service) << "type" << endl;
- generate_service_interface(tservice);
- generate_service_client(tservice);
- generate_service_server(tservice);
- generate_service_helpers(tservice);
- indent_down();
- indent_down();
- indent(s_service) << "end;" << endl;
- indent(s_service) << endl;
- indent_down();
-}
-
-void t_delphi_generator::generate_service_interface(t_service* tservice) {
- string extends = "";
- string extends_iface = "";
-
- indent_up();
-
- generate_delphi_doc(s_service, tservice);
- if (tservice->get_extends() != NULL) {
- extends = type_name(tservice->get_extends(), true, true);
- extends_iface = extends + ".Iface";
- generate_delphi_doc(s_service, tservice);
- indent(s_service) << "Iface = interface(" << extends_iface << ")" << endl;
- } else {
- indent(s_service) << "Iface = interface" << endl;
- }
-
- indent_up();
- vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
- for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
- generate_delphi_doc(s_service, *f_iter);
- indent(s_service) << function_signature(*f_iter) << endl;
- }
- indent_down();
- indent(s_service) << "end;" << endl << endl;
-
- indent_down();
-}
-
-void t_delphi_generator::generate_service_helpers(t_service* tservice) {
- vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
-
- for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
- t_struct* ts = (*f_iter)->get_arglist();
- generate_delphi_struct_definition(s_service, ts, false, true);
- generate_delphi_struct_impl(s_service_impl,
- normalize_clsnm(service_name_, "T") + ".",
- ts,
- false);
- generate_function_helpers(*f_iter);
- }
-}
-
-void t_delphi_generator::generate_service_client(t_service* tservice) {
- indent_up();
- string extends = "";
- string extends_client = "";
- if (tservice->get_extends() != NULL) {
- extends = type_name(tservice->get_extends());
- extends_client = extends + ".Client, ";
- }
-
- generate_delphi_doc(s_service, tservice);
- if (tservice->get_extends() != NULL) {
- extends = type_name(tservice->get_extends(), true, true);
- extends_client = extends + ".TClient";
- indent(s_service) << "TClient = class(" << extends_client << ", Iface)" << endl;
- } else {
- indent(s_service) << "TClient = class( TInterfacedObject, Iface)" << endl;
- }
-
- indent(s_service) << "public" << endl;
- indent_up();
-
- indent(s_service) << "constructor Create( prot: IProtocol); overload;" << endl;
-
- indent_impl(s_service_impl) << "constructor " << normalize_clsnm(service_name_, "T")
- << ".TClient.Create( prot: IProtocol);" << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "Create( prot, prot );" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl << endl;
-
- indent(s_service)
- << "constructor Create( const iprot: IProtocol; const oprot: IProtocol); overload;" << endl;
-
- indent_impl(s_service_impl) << "constructor " << normalize_clsnm(service_name_, "T")
- << ".TClient.Create( const iprot: IProtocol; const oprot: IProtocol);"
- << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "inherited Create;" << endl;
- indent_impl(s_service_impl) << "iprot_ := iprot;" << endl;
- indent_impl(s_service_impl) << "oprot_ := oprot;" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl << endl;
-
- indent_down();
-
- if (extends.empty()) {
- indent(s_service) << "protected" << endl;
- indent_up();
- indent(s_service) << "iprot_: IProtocol;" << endl;
- indent(s_service) << "oprot_: IProtocol;" << endl;
- indent(s_service) << "seqid_: Integer;" << endl;
- indent_down();
-
- indent(s_service) << "public" << endl;
- indent_up();
- indent(s_service) << "property InputProtocol: IProtocol read iprot_;" << endl;
- indent(s_service) << "property OutputProtocol: IProtocol read oprot_;" << endl;
- indent_down();
- }
-
- vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::const_iterator f_iter;
-
- indent(s_service) << "protected" << endl;
- indent_up();
- indent(s_service) << "// Iface" << endl;
- for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
- string funname = (*f_iter)->get_name();
- generate_delphi_doc(s_service, *f_iter);
- indent(s_service) << function_signature(*f_iter) << endl;
- }
- indent_down();
-
- indent(s_service) << "public" << endl;
- indent_up();
-
- string full_cls = normalize_clsnm(service_name_, "T") + ".TClient";
-
- for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
- string funname = (*f_iter)->get_name();
-
- indent_impl(s_service_impl) << function_signature(*f_iter, full_cls) << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "send_" << funname << "(";
-
- t_struct* arg_struct = (*f_iter)->get_arglist();
-
- const vector<t_field*>& fields = arg_struct->get_members();
- vector<t_field*>::const_iterator fld_iter;
- bool first = true;
- for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
- if (first) {
- first = false;
- } else {
- s_service_impl << ", ";
- }
- s_service_impl << normalize_name((*fld_iter)->get_name());
- }
- s_service_impl << ");" << endl;
-
- if (!(*f_iter)->is_oneway()) {
- s_service_impl << indent_impl();
- if (!(*f_iter)->get_returntype()->is_void()) {
- s_service_impl << "Result := ";
- }
- s_service_impl << "recv_" << funname << "();" << endl;
- }
-
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl << endl;
-
- t_function send_function(g_type_void,
- string("send_") + (*f_iter)->get_name(),
- (*f_iter)->get_arglist());
-
- string argsname = (*f_iter)->get_name() + "_args";
- string args_clsnm = normalize_clsnm(argsname, "T");
- string args_intfnm = normalize_clsnm(argsname, "I");
-
- string argsvar = tmp("_args");
- string msgvar = tmp("_msg");
-
- indent(s_service) << function_signature(&send_function) << endl;
- indent_impl(s_service_impl) << function_signature(&send_function, full_cls) << endl;
- indent_impl(s_service_impl) << "var" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << argsvar << " : " << args_intfnm << ";" << endl;
- indent_impl(s_service_impl) << msgvar << " : Thrift.Protocol.IMessage;" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
-
- indent_impl(s_service_impl) << "seqid_ := seqid_ + 1;" << endl;
- indent_impl(s_service_impl) << msgvar << " := Thrift.Protocol.TMessageImpl.Create('" << funname
- << "', " << ((*f_iter)->is_oneway() ? "TMessageType.Oneway"
- : "TMessageType.Call")
- << ", seqid_);" << endl;
-
- indent_impl(s_service_impl) << "oprot_.WriteMessageBegin( " << msgvar << " );" << endl;
- indent_impl(s_service_impl) << argsvar << " := " << args_clsnm << "Impl.Create();" << endl;
-
- for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
- indent_impl(s_service_impl) << argsvar << "." << prop_name(*fld_iter)
- << " := " << normalize_name((*fld_iter)->get_name()) << ";"
- << endl;
- }
- indent_impl(s_service_impl) << argsvar << ".Write(oprot_);" << endl;
- for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
- indent_impl(s_service_impl) << argsvar << "." << prop_name(*fld_iter)
- << " := " << empty_value((*fld_iter)->get_type()) << ";" << endl;
- }
-
- indent_impl(s_service_impl) << "oprot_.WriteMessageEnd();" << endl;
- indent_impl(s_service_impl) << "oprot_.Transport.Flush();" << endl;
-
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl << endl;
-
- if (!(*f_iter)->is_oneway()) {
- string org_resultname = (*f_iter)->get_name() + "_result";
- string result_clsnm = normalize_clsnm(org_resultname, "T");
- string result_intfnm = normalize_clsnm(org_resultname, "I");
-
- t_struct noargs(program_);
- t_function recv_function((*f_iter)->get_returntype(),
- string("recv_") + (*f_iter)->get_name(),
- &noargs,
- (*f_iter)->get_xceptions());
-
- t_struct* xs = (*f_iter)->get_xceptions();
- const std::vector<t_field*>& xceptions = xs->get_members();
-
- string exceptvar = tmp("_ex");
- string appexvar = tmp("_ax");
- string retvar = tmp("_ret");
-
- indent(s_service) << function_signature(&recv_function) << endl;
- indent_impl(s_service_impl) << function_signature(&recv_function, full_cls) << endl;
- indent_impl(s_service_impl) << "var" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << msgvar << " : Thrift.Protocol.IMessage;" << endl;
- if (xceptions.size() > 0) {
- indent_impl(s_service_impl) << exceptvar << " : Exception;" << endl;
- }
- indent_impl(s_service_impl) << appexvar << " : TApplicationException;" << endl;
- indent_impl(s_service_impl) << retvar << " : " << result_intfnm << ";" << endl;
-
- indent_down_impl();
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << msgvar << " := iprot_.ReadMessageBegin();" << endl;
- indent_impl(s_service_impl) << "if (" << msgvar << ".Type_ = TMessageType.Exception) then"
- << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << appexvar << " := TApplicationException.Read(iprot_);" << endl;
- indent_impl(s_service_impl) << "iprot_.ReadMessageEnd();" << endl;
- indent_impl(s_service_impl) << "raise " << appexvar << ";" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl;
-
- indent_impl(s_service_impl) << retvar << " := " << result_clsnm << "Impl.Create();" << endl;
- indent_impl(s_service_impl) << retvar << ".Read(iprot_);" << endl;
- indent_impl(s_service_impl) << "iprot_.ReadMessageEnd();" << endl;
-
- if (!(*f_iter)->get_returntype()->is_void()) {
- indent_impl(s_service_impl) << "if (" << retvar << ".__isset_success) then" << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "Result := " << retvar << ".Success;" << endl;
- t_type* type = (*f_iter)->get_returntype();
- if (type->is_struct() || type->is_xception() || type->is_map() || type->is_list()
- || type->is_set()) {
- indent_impl(s_service_impl) << retvar << ".Success := nil;" << endl;
- }
- indent_impl(s_service_impl) << "Exit;" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl;
- }
-
- vector<t_field*>::const_iterator x_iter;
- for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
- indent_impl(s_service_impl) << "if (" << retvar << ".__isset_" << prop_name(*x_iter)
- << ") then" << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << exceptvar << " := " << retvar << "." << prop_name(*x_iter)
- << ".CreateException;" << endl;
- indent_impl(s_service_impl) << "raise " << exceptvar << ";" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl;
- }
-
- if (!(*f_iter)->get_returntype()->is_void()) {
- indent_impl(s_service_impl)
- << "raise "
- "TApplicationException.Create(TApplicationException.TExceptionType.MissingResult, '"
- << (*f_iter)->get_name() << " failed: unknown result');" << endl;
- }
-
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl << endl;
- }
- }
-
- indent_down();
- indent(s_service) << "end;" << endl << endl;
-}
-
-void t_delphi_generator::generate_service_server(t_service* tservice) {
- vector<t_function*> functions = tservice->get_functions();
- vector<t_function*>::iterator f_iter;
-
- string extends = "";
- string extends_processor = "";
-
- string full_cls = normalize_clsnm(service_name_, "T") + ".TProcessorImpl";
-
- if (tservice->get_extends() != NULL) {
- extends = type_name(tservice->get_extends(), true, true);
- extends_processor = extends + ".TProcessorImpl";
- indent(s_service) << "TProcessorImpl = class(" << extends_processor << ", IProcessor)" << endl;
- } else {
- indent(s_service) << "TProcessorImpl = class( TInterfacedObject, IProcessor)" << endl;
- }
-
- indent(s_service) << "public" << endl;
- indent_up();
- indent(s_service) << "constructor Create( iface_: Iface );" << endl;
- indent(s_service) << "destructor Destroy; override;" << endl;
- indent_down();
-
- indent_impl(s_service_impl) << "constructor " << full_cls << ".Create( iface_: Iface );" << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- if (tservice->get_extends() != NULL) {
- indent_impl(s_service_impl) << "inherited Create( iface_);" << endl;
- } else {
- indent_impl(s_service_impl) << "inherited Create;" << endl;
- }
- indent_impl(s_service_impl) << "Self.iface_ := iface_;" << endl;
- if (tservice->get_extends() != NULL) {
- indent_impl(s_service_impl) << "ASSERT( processMap_ <> nil); // inherited" << endl;
- } else {
- indent_impl(s_service_impl)
- << "processMap_ := TThriftDictionaryImpl<string, TProcessFunction>.Create;" << endl;
- }
-
- for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
- indent_impl(s_service_impl) << "processMap_.AddOrSetValue( '" << (*f_iter)->get_name() << "', "
- << (*f_iter)->get_name() << "_Process);" << endl;
- }
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl << endl;
-
- indent_impl(s_service_impl) << "destructor " << full_cls << ".Destroy;" << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "inherited;" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl << endl;
-
- indent(s_service) << "private" << endl;
- indent_up();
- indent(s_service) << "iface_: Iface;" << endl;
- indent_down();
-
- if (tservice->get_extends() == NULL) {
- indent(s_service) << "protected" << endl;
- indent_up();
- indent(s_service) << "type" << endl;
- indent_up();
- indent(s_service) << "TProcessFunction = reference to procedure( seqid: Integer; const iprot: "
- "IProtocol; const oprot: IProtocol"
- << (events_ ? "; const events : IRequestEvents" : "") << ");" << endl;
- indent_down();
- indent_down();
- indent(s_service) << "protected" << endl;
- indent_up();
- indent(s_service) << "processMap_: IThriftDictionary<string, TProcessFunction>;" << endl;
- indent_down();
- }
-
- indent(s_service) << "public" << endl;
- indent_up();
- if (extends.empty()) {
- indent(s_service) << "function Process( const iprot: IProtocol; const oprot: IProtocol; const "
- "events : IProcessorEvents): Boolean;" << endl;
- } else {
- indent(s_service) << "function Process( const iprot: IProtocol; const oprot: IProtocol; const "
- "events : IProcessorEvents): Boolean; reintroduce;" << endl;
- }
-
- indent_impl(s_service_impl) << "function " << full_cls << ".Process( const iprot: IProtocol; "
- "const oprot: IProtocol; const events "
- ": IProcessorEvents): Boolean;" << endl;
- ;
- indent_impl(s_service_impl) << "var" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "msg : Thrift.Protocol.IMessage;" << endl;
- indent_impl(s_service_impl) << "fn : TProcessFunction;" << endl;
- indent_impl(s_service_impl) << "x : TApplicationException;" << endl;
- if (events_) {
- indent_impl(s_service_impl) << "context : IRequestEvents;" << endl;
- }
- indent_down_impl();
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "try" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "msg := iprot.ReadMessageBegin();" << endl;
- indent_impl(s_service_impl) << "fn := nil;" << endl;
- indent_impl(s_service_impl) << "if not processMap_.TryGetValue(msg.Name, fn)" << endl;
- indent_impl(s_service_impl) << "or not Assigned(fn) then" << endl;
- indent_impl(s_service_impl) << "begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "TProtocolUtil.Skip(iprot, TType.Struct);" << endl;
- indent_impl(s_service_impl) << "iprot.ReadMessageEnd();" << endl;
- indent_impl(s_service_impl) << "x := "
- "TApplicationException.Create(TApplicationException."
- "TExceptionType.UnknownMethod, 'Invalid method name: ''' + "
- "msg.Name + '''');" << endl;
- indent_impl(s_service_impl)
- << "msg := Thrift.Protocol.TMessageImpl.Create(msg.Name, TMessageType.Exception, msg.SeqID);"
- << endl;
- indent_impl(s_service_impl) << "oprot.WriteMessageBegin( msg);" << endl;
- indent_impl(s_service_impl) << "x.Write(oprot);" << endl;
- indent_impl(s_service_impl) << "oprot.WriteMessageEnd();" << endl;
- indent_impl(s_service_impl) << "oprot.Transport.Flush();" << endl;
- indent_impl(s_service_impl) << "Result := True;" << endl;
- indent_impl(s_service_impl) << "Exit;" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl;
- if (events_) {
- indent_impl(s_service_impl) << "if events <> nil" << endl;
- indent_impl(s_service_impl) << "then context := events.CreateRequestContext(msg.Name)" << endl;
- indent_impl(s_service_impl) << "else context := nil;" << endl;
- indent_impl(s_service_impl) << "try" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "fn(msg.SeqID, iprot, oprot, context);" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "finally" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "if context <> nil then begin" << endl;
- indent_up_impl();
- indent_impl(s_service_impl) << "context.CleanupContext;" << endl;
- indent_impl(s_service_impl) << "context := nil;" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl;
- indent_down_impl();
- indent_impl(s_service_impl) << "end;" << endl;
- } else {
- indent_impl(s_service_impl) << "fn(msg.SeqID, iprot, oprot);" << endl;
- }
-
<TRUNCATED>