THRIFT-173. Commit the html generator
git-svn-id: https://svn.apache.org/repos/asf/incubator/thrift/trunk@706466 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/compiler/cpp/Makefile.am b/compiler/cpp/Makefile.am
index 90ef9a4..eb46a53 100644
--- a/compiler/cpp/Makefile.am
+++ b/compiler/cpp/Makefile.am
@@ -71,6 +71,9 @@
if THRIFT_GEN_hs
thrift_SOURCES += src/generate/t_hs_generator.cc
endif
+if THRIFT_GEN_html
+thrift_SOURCES += src/generate/t_html_generator.cc
+endif
thrift_CXXFLAGS = -Wall -I$(srcdir)/src $(BOOST_CPPFLAGS)
thrift_LDFLAGS = -Wall $(BOOST_LDFLAGS)
diff --git a/compiler/cpp/src/generate/t_html_generator.cc b/compiler/cpp/src/generate/t_html_generator.cc
new file mode 100644
index 0000000..a956fc4
--- /dev/null
+++ b/compiler/cpp/src/generate/t_html_generator.cc
@@ -0,0 +1,609 @@
+// Copyright (c) 2008 Evernote Corporation
+// Distributed under the Thrift Software License
+//
+// See accompanying file LICENSE or visit the Thrift site at:
+// http://developers.facebook.com/thrift/
+
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <map>
+
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sstream>
+#include "t_generator.h"
+#include "platform.h"
+using namespace std;
+
+
+/**
+ * HTML code generator
+ *
+ * @author Dave Engberg, although it was
+ * mostly copy/pasting/tweaking from mcslee's work.
+ */
+class t_html_generator : public t_generator {
+ public:
+ t_html_generator(
+ t_program* program,
+ const std::map<std::string, std::string>& parsed_options,
+ const std::string& option_string)
+ : t_generator(program)
+ {
+ out_dir_base_ = "gen-html";
+ }
+
+ void generate_program();
+ void generate_program_toc();
+ void generate_program_toc_row(t_program* tprog);
+ void generate_program_toc_rows(t_program* tprog,
+ std::vector<t_program*>& finished);
+ void generate_index();
+ void generate_css();
+
+ /**
+ * Program-level generation functions
+ */
+
+ void generate_typedef (t_typedef* ttypedef);
+ void generate_enum (t_enum* tenum);
+ void generate_const (t_const* tconst);
+ void generate_struct (t_struct* tstruct);
+ void generate_service (t_service* tservice);
+ void generate_xception(t_struct* txception);
+
+ void print_doc (t_doc* tdoc);
+ int print_type (t_type* ttype);
+ void print_const_value(t_const_value* tvalue);
+
+ std::ofstream f_out_;
+};
+
+/**
+ * Emits the Table of Contents links at the top of the module's page
+ */
+void t_html_generator::generate_program_toc() {
+ f_out_ << "<table><tr><th>Module</th><th>Services</th>"
+ << "<th>Data types</th><th>Constants</th></tr>" << endl;
+ generate_program_toc_row(program_);
+ f_out_ << "</table>" << endl;
+}
+
+
+/**
+ * Recurses through from the provided program and generates a ToC row
+ * for each discovered program exactly once by maintaining the list of
+ * completed rows in 'finished'
+ */
+void t_html_generator::generate_program_toc_rows(t_program* tprog,
+ std::vector<t_program*>& finished) {
+ for (vector<t_program*>::iterator iter = finished.begin();
+ iter != finished.end(); iter++) {
+ if (tprog->get_path() == (*iter)->get_path()) {
+ return;
+ }
+ }
+ finished.push_back(tprog);
+ generate_program_toc_row(tprog);
+ vector<t_program*> includes = tprog->get_includes();
+ for (vector<t_program*>::iterator iter = includes.begin();
+ iter != includes.end(); iter++) {
+ generate_program_toc_rows(*iter, finished);
+ }
+}
+
+/**
+ * Emits the Table of Contents links at the top of the module's page
+ */
+void t_html_generator::generate_program_toc_row(t_program* tprog) {
+ string fname = tprog->get_name() + ".html";
+ f_out_ << "<tr>" << endl << "<td>" << tprog->get_name() << "</td><td>";
+ if (!tprog->get_services().empty()) {
+ vector<t_service*> services = tprog->get_services();
+ vector<t_service*>::iterator sv_iter;
+ for (sv_iter = services.begin(); sv_iter != services.end(); ++sv_iter) {
+ string name = get_service_name(*sv_iter);
+ f_out_ << "<a href=\"" << fname << "#Svc_" << name << "\">" << name
+ << "</a><br/>" << endl;
+ f_out_ << "<ul>" << endl;
+ map<string,string> fn_html;
+ vector<t_function*> functions = (*sv_iter)->get_functions();
+ vector<t_function*>::iterator fn_iter;
+ for (fn_iter = functions.begin(); fn_iter != functions.end(); ++fn_iter) {
+ string fn_name = (*fn_iter)->get_name();
+ string html = "<li><a href=\"" + fname + "#Fn_" + name + "_" +
+ fn_name + "\">" + fn_name + "</a></li>";
+ fn_html.insert(pair<string,string>(fn_name, html));
+ }
+ for (map<string,string>::iterator html_iter = fn_html.begin();
+ html_iter != fn_html.end(); html_iter++) {
+ f_out_ << html_iter->second << endl;
+ }
+ f_out_ << "</ul>" << endl;
+ }
+ }
+ f_out_ << "</td>" << endl << "<td>";
+ map<string,string> data_types;
+ if (!tprog->get_enums().empty()) {
+ vector<t_enum*> enums = tprog->get_enums();
+ vector<t_enum*>::iterator en_iter;
+ for (en_iter = enums.begin(); en_iter != enums.end(); ++en_iter) {
+ string name = (*en_iter)->get_name();
+ // f_out_ << "<a href=\"" << fname << "#Enum_" << name << "\">" << name
+ // << "</a><br/>" << endl;
+ string html = "<a href=\"" + fname + "#Enum_" + name + "\">" + name +
+ "</a>";
+ data_types.insert(pair<string,string>(name, html));
+ }
+ }
+ if (!tprog->get_typedefs().empty()) {
+ vector<t_typedef*> typedefs = tprog->get_typedefs();
+ vector<t_typedef*>::iterator td_iter;
+ for (td_iter = typedefs.begin(); td_iter != typedefs.end(); ++td_iter) {
+ string name = (*td_iter)->get_symbolic();
+ // f_out_ << "<a href=\"" << fname << "#Typedef_" << name << "\">" << name
+ // << "</a><br/>" << endl;
+ string html = "<a href=\"" + fname + "#Typedef_" + name + "\">" + name +
+ "</a>";
+ data_types.insert(pair<string,string>(name, html));
+ }
+ }
+ if (!tprog->get_objects().empty()) {
+ vector<t_struct*> objects = tprog->get_objects();
+ vector<t_struct*>::iterator o_iter;
+ for (o_iter = objects.begin(); o_iter != objects.end(); ++o_iter) {
+ string name = (*o_iter)->get_name();
+ //f_out_ << "<a href=\"" << fname << "#Struct_" << name << "\">" << name
+ //<< "</a><br/>" << endl;
+ string html = "<a href=\"" + fname + "#Struct_" + name + "\">" + name +
+ "</a>";
+ data_types.insert(pair<string,string>(name, html));
+ }
+ }
+ for (map<string,string>::iterator dt_iter = data_types.begin();
+ dt_iter != data_types.end(); dt_iter++) {
+ f_out_ << dt_iter->second << "<br/>" << endl;
+ }
+ f_out_ << "</td>" << endl << "<td><code>";
+ if (!tprog->get_consts().empty()) {
+ map<string,string> const_html;
+ vector<t_const*> consts = tprog->get_consts();
+ vector<t_const*>::iterator con_iter;
+ for (con_iter = consts.begin(); con_iter != consts.end(); ++con_iter) {
+ string name = (*con_iter)->get_name();
+ string html ="<a href=\"" + fname + "#Const_" + name +
+ "\">" + name + "</a>";
+ const_html.insert(pair<string,string>(name, html));
+ }
+ for (map<string,string>::iterator con_iter = const_html.begin();
+ con_iter != const_html.end(); con_iter++) {
+ f_out_ << con_iter->second << "<br/>" << endl;
+ }
+ }
+ f_out_ << "</code></td>" << endl << "</tr>";
+}
+
+/**
+ * Prepares for file generation by opening up the necessary file output
+ * stream.
+ */
+void t_html_generator::generate_program() {
+ // Make output directory
+ MKDIR(get_out_dir().c_str());
+ string fname = get_out_dir() + program_->get_name() + ".html";
+ f_out_.open(fname.c_str());
+ f_out_ << "<html><head>" << endl;
+ f_out_ << "<link href=\"style.css\" rel=\"stylesheet\" type=\"text/css\"/>"
+ << endl;
+ f_out_ << "<title>Thrift module: " << program_->get_name()
+ << "</title></head><body>" << endl << "<h1>Thrift module: "
+ << program_->get_name() << "</h1>" << endl;
+
+ print_doc(program_);
+
+ generate_program_toc();
+
+ if (!program_->get_consts().empty()) {
+ f_out_ << "<hr/><h2 id=\"Constants\">Constants</h2>" << endl;
+ vector<t_const*> consts = program_->get_consts();
+ f_out_ << "<table>";
+ f_out_ << "<tr><th>Constant</th><th>Type</th><th>Value</th></tr>" << endl;
+ generate_consts(consts);
+ f_out_ << "</table>";
+ }
+
+ if (!program_->get_enums().empty()) {
+ f_out_ << "<hr/><h2 id=\"Enumerations\">Enumerations</h2>" << endl;
+ // Generate enums
+ vector<t_enum*> enums = program_->get_enums();
+ vector<t_enum*>::iterator en_iter;
+ for (en_iter = enums.begin(); en_iter != enums.end(); ++en_iter) {
+ generate_enum(*en_iter);
+ }
+ }
+
+ if (!program_->get_typedefs().empty()) {
+ f_out_ << "<hr/><h2 id=\"Typedefs\">Type declarations</h2>" << endl;
+ // Generate typedefs
+ vector<t_typedef*> typedefs = program_->get_typedefs();
+ vector<t_typedef*>::iterator td_iter;
+ for (td_iter = typedefs.begin(); td_iter != typedefs.end(); ++td_iter) {
+ generate_typedef(*td_iter);
+ }
+ }
+
+ if (!program_->get_objects().empty()) {
+ f_out_ << "<hr/><h2 id=\"Structs\">Data structures</h2>" << endl;
+ // Generate structs and exceptions in declared order
+ vector<t_struct*> objects = program_->get_objects();
+ vector<t_struct*>::iterator o_iter;
+ for (o_iter = objects.begin(); o_iter != objects.end(); ++o_iter) {
+ if ((*o_iter)->is_xception()) {
+ generate_xception(*o_iter);
+ } else {
+ generate_struct(*o_iter);
+ }
+ }
+ }
+
+ if (!program_->get_services().empty()) {
+ f_out_ << "<hr/><h2 id=\"Services\">Services</h2>" << endl;
+ // Generate services
+ vector<t_service*> services = program_->get_services();
+ vector<t_service*>::iterator sv_iter;
+ for (sv_iter = services.begin(); sv_iter != services.end(); ++sv_iter) {
+ service_name_ = get_service_name(*sv_iter);
+ generate_service(*sv_iter);
+ }
+ }
+
+ f_out_ << "</body></html>" << endl;
+ f_out_.close();
+
+ generate_index();
+ generate_css();
+}
+
+/**
+ * Emits the index.html file for the recursive set of Thrift programs
+ */
+void t_html_generator::generate_index() {
+ string index_fname = get_out_dir() + "index.html";
+ f_out_.open(index_fname.c_str());
+ f_out_ << "<html><head>" << endl;
+ f_out_ << "<link href=\"style.css\" rel=\"stylesheet\" type=\"text/css\"/>"
+ << endl;
+ f_out_ << "<title>All Thrift declarations</title></head><body>"
+ << endl << "<h1>All Thrift declarations</h1>" << endl;
+ f_out_ << "<table><tr><th>Module</th><th>Services</th><th>Data types</th>"
+ << "<th>Constants</th></tr>" << endl;
+ vector<t_program*> programs;
+ generate_program_toc_rows(program_, programs);
+ f_out_ << "</table>" << endl;
+ f_out_ << "</body></html>" << endl;
+ f_out_.close();
+}
+
+void t_html_generator::generate_css() {
+ string css_fname = get_out_dir() + "style.css";
+ f_out_.open(css_fname.c_str());
+ f_out_ << "/* Auto-generated CSS for generated Thrift docs */" << endl;
+ f_out_ <<
+ "body { font-family: Tahoma, sans-serif; }" << endl;
+ f_out_ <<
+ "pre { background-color: #dddddd; padding: 6px; }" << endl;
+ f_out_ <<
+ "h3,h4 { padding-top: 0px; margin-top: 0px; }" << endl;
+ f_out_ <<
+ "div.definition { border: 1px solid gray; margin: 10px; padding: 10px; }" << endl;
+ f_out_ <<
+ "table { border: 1px solid grey; border-collapse: collapse; }" << endl;
+ f_out_ <<
+ "td { border: 1px solid grey; padding: 1px 6px; vertical-align: top; }" << endl;
+ f_out_ <<
+ "th { border: 1px solid black; background-color: #bbbbbb;" << endl <<
+ " text-align: left; padding: 1px 6px; }" << endl;
+ f_out_.close();
+}
+
+/**
+ * If the provided documentable object has documentation attached, this
+ * will emit it to the output stream in HTML format.
+ */
+void t_html_generator::print_doc(t_doc* tdoc) {
+ if (tdoc->has_doc()) {
+ string doc = tdoc->get_doc();
+ unsigned int index;
+ while ((index = doc.find_first_of("\r\n")) != string::npos) {
+ if (index == 0) {
+ f_out_ << "<p/>" << endl;
+ } else {
+ f_out_ << doc.substr(0, index) << endl;
+ }
+ if (index + 1 < doc.size() && doc.at(index) != doc.at(index + 1) &&
+ (doc.at(index + 1) == '\r' || doc.at(index + 1) == '\n')) {
+ index++;
+ }
+ doc = doc.substr(index + 1);
+ }
+ f_out_ << doc << "<br/>";
+ }
+}
+
+/**
+ * Prints out the provided type in HTML
+ */
+int t_html_generator::print_type(t_type* ttype) {
+ int len = 0;
+ f_out_ << "<code>";
+ if (ttype->is_container()) {
+ if (ttype->is_list()) {
+ f_out_ << "list<";
+ len = 6 + print_type(((t_list*)ttype)->get_elem_type());
+ f_out_ << ">";
+ } else if (ttype->is_set()) {
+ f_out_ << "set<";
+ len = 5 + print_type(((t_set*)ttype)->get_elem_type());
+ f_out_ << ">";
+ } else if (ttype->is_map()) {
+ f_out_ << "map<";
+ len = 5 + print_type(((t_map*)ttype)->get_key_type());
+ f_out_ << ", ";
+ len += print_type(((t_map*)ttype)->get_val_type());
+ f_out_ << ">";
+ }
+ } else if (ttype->is_base_type()) {
+ f_out_ << ttype->get_name();
+ len = ttype->get_name().size();
+ } else {
+ string prog_name = ttype->get_program()->get_name();
+ string type_name = ttype->get_name();
+ f_out_ << "<a href=\"" << prog_name << ".html#";
+ if (ttype->is_typedef()) {
+ f_out_ << "Typedef_";
+ } else if (ttype->is_struct() || ttype->is_xception()) {
+ f_out_ << "Struct_";
+ } else if (ttype->is_enum()) {
+ f_out_ << "Enum_";
+ }
+ f_out_ << type_name << "\">";
+ len = type_name.size();
+ if (ttype->get_program() != program_) {
+ f_out_ << prog_name << ".";
+ len += prog_name.size() + 1;
+ }
+ f_out_ << type_name << "</a>";
+ }
+ f_out_ << "</code>";
+ return len;
+}
+
+/**
+ * Prints out an HTML representation of the provided constant value
+ */
+void t_html_generator::print_const_value(t_const_value* tvalue) {
+ bool first = true;
+ switch (tvalue->get_type()) {
+ case t_const_value::CV_INTEGER:
+ f_out_ << tvalue->get_integer();
+ break;
+ case t_const_value::CV_DOUBLE:
+ f_out_ << tvalue->get_double();
+ break;
+ case t_const_value::CV_STRING:
+ f_out_ << "\"" << tvalue->get_string() << "\"";
+ break;
+ case t_const_value::CV_MAP:
+ {
+ f_out_ << "{ ";
+ map<t_const_value*, t_const_value*> map_elems = tvalue->get_map();
+ map<t_const_value*, t_const_value*>::iterator map_iter;
+ for (map_iter = map_elems.begin(); map_iter != map_elems.end();
+ map_iter++) {
+ if (!first) {
+ f_out_ << ", ";
+ }
+ first = false;
+ print_const_value(map_iter->first);
+ f_out_ << " = ";
+ print_const_value(map_iter->second);
+ }
+ f_out_ << " }";
+ }
+ break;
+ case t_const_value::CV_LIST:
+ {
+ f_out_ << "{ ";
+ vector<t_const_value*> list_elems = tvalue->get_list();;
+ vector<t_const_value*>::iterator list_iter;
+ for (list_iter = list_elems.begin(); list_iter != list_elems.end();
+ list_iter++) {
+ if (!first) {
+ f_out_ << ", ";
+ }
+ first = false;
+ print_const_value(*list_iter);
+ }
+ f_out_ << " }";
+ }
+ break;
+ default:
+ f_out_ << "UNKNOWN";
+ break;
+ }
+}
+
+/**
+ * Generates a typedef.
+ *
+ * @param ttypedef The type definition
+ */
+void t_html_generator::generate_typedef(t_typedef* ttypedef) {
+ string name = ttypedef->get_name();
+ f_out_ << "<div class=\"definition\">";
+ f_out_ << "<h3 id=\"Typedef_" << name << "\">Typedef: " << name
+ << "</h3>" << endl;
+ f_out_ << "<p><strong>Base type:</strong> ";
+ print_type(ttypedef->get_type());
+ f_out_ << "</p>" << endl;
+ print_doc(ttypedef);
+ f_out_ << "</div>" << endl;
+}
+
+/**
+ * Generates code for an enumerated type.
+ *
+ * @param tenum The enumeration
+ */
+void t_html_generator::generate_enum(t_enum* tenum) {
+ string name = tenum->get_name();
+ f_out_ << "<div class=\"definition\">";
+ f_out_ << "<h3 id=\"Enum_" << name << "\">Enumeration: " << name
+ << "</h3>" << endl;
+ print_doc(tenum);
+ vector<t_enum_value*> values = tenum->get_constants();
+ vector<t_enum_value*>::iterator val_iter;
+ f_out_ << "<br/><table>" << endl;
+ for (val_iter = values.begin(); val_iter != values.end(); ++val_iter) {
+ f_out_ << "<tr><td><code>";
+ f_out_ << (*val_iter)->get_name();
+ f_out_ << "</code></td><td><code>";
+ f_out_ << (*val_iter)->get_value();
+ f_out_ << "</code></td></tr>" << endl;
+ }
+ f_out_ << "</table></div>" << endl;
+}
+
+/**
+ * Generates a constant value
+ */
+void t_html_generator::generate_const(t_const* tconst) {
+ string name = tconst->get_name();
+ f_out_ << "<tr id=\"Const_" << name << "\"><td><code>" << name
+ << "</code></td><td><code>";
+ print_type(tconst->get_type());
+ f_out_ << "</code></td><td><code>";
+ print_const_value(tconst->get_value());
+ f_out_ << "</code></td></tr>";
+ if (tconst->has_doc()) {
+ f_out_ << "<tr><td colspan=\"3\"><blockquote>";
+ print_doc(tconst);
+ f_out_ << "</blockquote></td></tr>";
+ }
+}
+
+/**
+ * Generates a struct definition for a thrift data type.
+ *
+ * @param tstruct The struct definition
+ */
+void t_html_generator::generate_struct(t_struct* tstruct) {
+ string name = tstruct->get_name();
+ f_out_ << "<div class=\"definition\">";
+ f_out_ << "<h3 id=\"Struct_" << name << "\">";
+ if (tstruct->is_xception()) {
+ f_out_ << "Exception: ";
+ } else {
+ f_out_ << "Struct: ";
+ }
+ f_out_ << name << "</h3>" << endl;
+ vector<t_field*> members = tstruct->get_members();
+ vector<t_field*>::iterator mem_iter = members.begin();
+ f_out_ << "<table>";
+ f_out_ << "<tr><th>Field</th><th>Type</th><th>Required</th><th>Default value</th></tr>"
+ << endl;
+ for ( ; mem_iter != members.end(); mem_iter++) {
+ f_out_ << "<tr><td>" << (*mem_iter)->get_name() << "</td><td>";
+ print_type((*mem_iter)->get_type());
+ f_out_ << "</td><td>";
+ if ((*mem_iter)->get_req() != t_field::T_OPTIONAL) {
+ f_out_ << "yes";
+ } else {
+ f_out_ << "no";
+ }
+ f_out_ << "</td><td>";
+ t_const_value* default_val = (*mem_iter)->get_value();
+ if (default_val != NULL) {
+ print_const_value(default_val);
+ }
+ f_out_ << "</td></tr>" << endl;
+ }
+ f_out_ << "</table><br/>";
+ print_doc(tstruct);
+ f_out_ << "</div>";
+}
+
+/**
+ * Exceptions are special structs
+ *
+ * @param tstruct The struct definition
+ */
+void t_html_generator::generate_xception(t_struct* txception) {
+ generate_struct(txception);
+}
+
+/**
+ * Generates the HTML block for a Thrift service.
+ *
+ * @param tservice The service definition
+ */
+void t_html_generator::generate_service(t_service* tservice) {
+ f_out_ << "<h3 id=\"Svc_" << service_name_ << "\">Service: "
+ << service_name_ << "</h3>" << endl;
+ print_doc(tservice);
+ vector<t_function*> functions = tservice->get_functions();
+ vector<t_function*>::iterator fn_iter = functions.begin();
+ for ( ; fn_iter != functions.end(); fn_iter++) {
+ string fn_name = (*fn_iter)->get_name();
+ f_out_ << "<div class=\"definition\">";
+ f_out_ << "<h4 id=\"Fn_" << service_name_ << "_" << fn_name
+ << "\">Function: " << service_name_ << "." << fn_name
+ << "</h4>" << endl;
+ f_out_ << "<pre>";
+ int offset = print_type((*fn_iter)->get_returntype());
+ bool first = true;
+ f_out_ << " " << fn_name << "(";
+ offset += fn_name.size() + 2;
+ vector<t_field*> args = (*fn_iter)->get_arglist()->get_members();
+ vector<t_field*>::iterator arg_iter = args.begin();
+ if (arg_iter != args.end()) {
+ for ( ; arg_iter != args.end(); arg_iter++) {
+ if (!first) {
+ f_out_ << "," << endl;
+ for (int i = 0; i < offset; ++i) {
+ f_out_ << " ";
+ }
+ }
+ first = false;
+ print_type((*arg_iter)->get_type());
+ f_out_ << " " << (*arg_iter)->get_name();
+ if ((*arg_iter)->get_value() != NULL) {
+ f_out_ << " = ";
+ print_const_value((*arg_iter)->get_value());
+ }
+ }
+ }
+ f_out_ << ")" << endl;
+ first = true;
+ vector<t_field*> excepts = (*fn_iter)->get_xceptions()->get_members();
+ vector<t_field*>::iterator ex_iter = excepts.begin();
+ if (ex_iter != excepts.end()) {
+ f_out_ << " throws ";
+ for ( ; ex_iter != excepts.end(); ex_iter++) {
+ if (!first) {
+ f_out_ << ", ";
+ }
+ first = false;
+ print_type((*ex_iter)->get_type());
+ }
+ f_out_ << endl;
+ }
+ f_out_ << "</pre>";
+ print_doc(*fn_iter);
+ f_out_ << "</div>";
+ }
+}
+
+THRIFT_REGISTER_GENERATOR(html, "HTML", "");
diff --git a/configure.ac b/configure.ac
index 4ef8d19..e42b8cb 100644
--- a/configure.ac
+++ b/configure.ac
@@ -162,6 +162,8 @@
AM_CONDITIONAL([THRIFT_GEN_ocaml], [test "$ax_thrift_gen_ocaml" = "yes"])
AX_THRIFT_GEN(hs, [Haskell], yes)
AM_CONDITIONAL([THRIFT_GEN_hs], [test "$ax_thrift_gen_hs" = "yes"])
+AX_THRIFT_GEN(html, [HTML], yes)
+AM_CONDITIONAL([THRIFT_GEN_html], [test "$ax_thrift_gen_html" = "yes"])
AC_CONFIG_HEADERS(config.h:config.hin)