diff --git a/compiler/cpp/src/generate/t_as3_generator.cc b/compiler/cpp/src/generate/t_as3_generator.cc
index 0364ec1..c0a03dc 100644
--- a/compiler/cpp/src/generate/t_as3_generator.cc
+++ b/compiler/cpp/src/generate/t_as3_generator.cc
@@ -52,8 +52,14 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("bindable");
-    bindable_ = (iter != parsed_options.end());
+    bindable_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("bindable") == 0) {
+        bindable_ = true;
+      } else {
+        throw "unknown option as3:" + iter->first; 
+      }
+    }
 
     out_dir_base_ = "gen-as3";
   }
diff --git a/compiler/cpp/src/generate/t_c_glib_generator.cc b/compiler/cpp/src/generate/t_c_glib_generator.cc
index affaafa..6a349c4 100644
--- a/compiler/cpp/src/generate/t_c_glib_generator.cc
+++ b/compiler/cpp/src/generate/t_c_glib_generator.cc
@@ -57,11 +57,17 @@
                      const map<string, string>& parsed_options,
                      const string& option_string)
     : t_oop_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
     /* set the output directory */
     this->out_dir_base_ = "gen-c_glib";
 
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option c_glib:" + iter->first; 
+    }
+
     /* set the namespace */
     this->nspace = program_->get_namespace("c_glib");
 
diff --git a/compiler/cpp/src/generate/t_cocoa_generator.cc b/compiler/cpp/src/generate/t_cocoa_generator.cc
index 085e0b9..4f135f4 100644
--- a/compiler/cpp/src/generate/t_cocoa_generator.cc
+++ b/compiler/cpp/src/generate/t_cocoa_generator.cc
@@ -52,24 +52,30 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("log_unexpected");
-    log_unexpected_ = (iter != parsed_options.end());
+    log_unexpected_ = false;
+    validate_required_ = false;
+    async_clients_ = false;
+    promise_kit_ = false;
+    debug_descriptions_ = false;
+    pods_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("log_unexpected") == 0) {
+        log_unexpected_ = true;
+      } else if( iter->first.compare("validate_required") == 0) {
+        validate_required_ = true;
+      } else if( iter->first.compare("async_clients") == 0) {
+        async_clients_ = true;
+      } else if( iter->first.compare("promise_kit") == 0) {
+        promise_kit_ = true;
+      } else if( iter->first.compare("debug_descriptions") == 0) {
+        debug_descriptions_ = true;
+      } else if( iter->first.compare("pods") == 0) {
+        pods_ = true;
+      } else {
+        throw "unknown option cocoa:" + iter->first; 
+      }
+    }
 
-    iter = parsed_options.find("validate_required");
-    validate_required_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("async_clients");
-    async_clients_ = (iter != parsed_options.end());
-      
-    iter = parsed_options.find("promise_kit");
-    promise_kit_ = (iter != parsed_options.end());
-      
-    iter = parsed_options.find("debug_descriptions");
-    debug_descriptions_ = (iter != parsed_options.end());
-    
-    iter = parsed_options.find("pods");
-    pods_ = (iter != parsed_options.end());
-      
     out_dir_base_ = "gen-cocoa";
   }
 
@@ -3282,6 +3288,8 @@
     cocoa,
     "Cocoa",
     "    log_unexpected:  Log every time an unexpected field ID or type is encountered.\n"
+    "    debug_descriptions:\n"
+    "                     Allow use of debugDescription so the app can add description via a cateogory/extension\n"
     "    validate_required:\n"
     "                     Throws exception if any required field is not set.\n"
     "    async_clients:   Generate clients which invoke asynchronously via block syntax.\n"
diff --git a/compiler/cpp/src/generate/t_cpp_generator.cc b/compiler/cpp/src/generate/t_cpp_generator.cc
index 5056d87..6c04899 100644
--- a/compiler/cpp/src/generate/t_cpp_generator.cc
+++ b/compiler/cpp/src/generate/t_cpp_generator.cc
@@ -55,28 +55,35 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("pure_enums");
-    gen_pure_enums_ = (iter != parsed_options.end());
 
-    iter = parsed_options.find("include_prefix");
-    use_include_prefix_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("cob_style");
-    gen_cob_style_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("no_client_completion");
-    gen_no_client_completion_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("no_default_operators");
-    gen_no_default_operators_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("templates");
-    gen_templates_ = (iter != parsed_options.end());
-
-    gen_templates_only_ = (iter != parsed_options.end() && iter->second == "only");
-
-    iter = parsed_options.find("moveable_types");
-    gen_moveable_ = (iter != parsed_options.end());
+    gen_pure_enums_ = false;
+    use_include_prefix_ = false;
+    gen_cob_style_ = false;
+    gen_no_client_completion_ = false;
+    gen_no_default_operators_ = false;
+    gen_templates_ = false;
+    gen_templates_only_ = false;
+    gen_moveable_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("pure_enums") == 0) {
+        gen_pure_enums_ = true;
+      } else if( iter->first.compare("include_prefix") == 0) {
+        use_include_prefix_ = true;
+      } else if( iter->first.compare("cob_style") == 0) {
+        gen_cob_style_ = true;
+      } else if( iter->first.compare("no_client_completion") == 0) {
+        gen_no_client_completion_ = true;
+      } else if( iter->first.compare("no_default_operators") == 0) {
+        gen_no_default_operators_ = true;
+      } else if( iter->first.compare("templates") == 0) {
+        gen_templates_ = true;
+        gen_templates_only_ = (iter->second == "only");
+      } else if( iter->first.compare("moveable_types") == 0) {
+        gen_moveable_ = true;
+      } else {
+        throw "unknown option cpp:" + iter->first; 
+      }
+    }
 
     out_dir_base_ = "gen-cpp";
   }
diff --git a/compiler/cpp/src/generate/t_csharp_generator.cc b/compiler/cpp/src/generate/t_csharp_generator.cc
index 9b865f5..d356f26 100644
--- a/compiler/cpp/src/generate/t_csharp_generator.cc
+++ b/compiler/cpp/src/generate/t_csharp_generator.cc
@@ -60,28 +60,31 @@
 
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("async");
-    async_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("nullable");
-    nullable_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("hashcode");
-    hashcode_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("union");
-    union_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("serial");
-    serialize_ = (iter != parsed_options.end());
-    if (serialize_) {
-      wcf_namespace_ = iter->second; // since there can be only one namespace
-    }
-
-    iter = parsed_options.find("wcf");
-    wcf_ = (iter != parsed_options.end());
-    if (wcf_) {
-      wcf_namespace_ = iter->second;
+    async_ = false;
+    nullable_ = false;
+    hashcode_ = false;
+    union_ = false;
+    serialize_ = false;
+    wcf_ = false;
+    wcf_namespace_.clear();
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("async") == 0) {
+        async_ = true;
+      } else if( iter->first.compare("nullable") == 0) {
+        nullable_ = true;
+      } else if( iter->first.compare("hashcode") == 0) {
+        hashcode_ = true;
+      } else if( iter->first.compare("union") == 0) {
+        union_ = true;
+      } else if( iter->first.compare("serial") == 0) {
+        serialize_ = true;
+        wcf_namespace_ = iter->second; // since there can be only one namespace
+      } else if( iter->first.compare("wcf") == 0) {
+        wcf_ = true;
+        wcf_namespace_ = iter->second;
+      } else {
+        throw "unknown option csharp:" + iter->first; 
+      }
     }
 
     out_dir_base_ = "gen-csharp";
diff --git a/compiler/cpp/src/generate/t_d_generator.cc b/compiler/cpp/src/generate/t_d_generator.cc
index 629e71b..1e0af7d 100644
--- a/compiler/cpp/src/generate/t_d_generator.cc
+++ b/compiler/cpp/src/generate/t_d_generator.cc
@@ -59,8 +59,14 @@
                 const std::map<string, string>& parsed_options,
                 const string& option_string)
     : t_oop_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option d:" + iter->first; 
+    }
+
     out_dir_base_ = "gen-d";
   }
 
diff --git a/compiler/cpp/src/generate/t_dart_generator.cc b/compiler/cpp/src/generate/t_dart_generator.cc
index 4faea19..3333d16 100644
--- a/compiler/cpp/src/generate/t_dart_generator.cc
+++ b/compiler/cpp/src/generate/t_dart_generator.cc
@@ -68,27 +68,21 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("library_name");
-    if (iter != parsed_options.end()) {
-      library_name_ = (iter->second);
-    } else {
-      library_name_ = "";
-    }
-
-    iter = parsed_options.find("library_prefix");
-    if (iter != parsed_options.end()) {
-      library_prefix_ = (iter->second) + ".";
-      package_prefix_ = replace_all(library_prefix_, ".", "/");
-    } else {
-      library_prefix_ = "";
-      package_prefix_ = "";
-    }
-
-    iter = parsed_options.find("pubspec_lib");
-    if (iter != parsed_options.end()) {
-      pubspec_lib_ = (iter->second);
-    } else {
-      pubspec_lib_ = "";
+    library_name_ = "";
+    library_prefix_ = "";
+    package_prefix_ = "";
+    pubspec_lib_ = "";
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("library_name") == 0) {
+        library_name_ = (iter->second);
+      } else if( iter->first.compare("library_prefix") == 0) {
+        library_prefix_ = (iter->second) + ".";
+        package_prefix_ = replace_all(library_prefix_, ".", "/");
+      } else if( iter->first.compare("pubspec_lib") == 0) {
+        pubspec_lib_ = (iter->second);
+      } else {
+        throw "unknown option dart:" + iter->first; 
+      }
     }
 
     out_dir_base_ = "gen-dart";
diff --git a/compiler/cpp/src/generate/t_delphi_generator.cc b/compiler/cpp/src/generate/t_delphi_generator.cc
index 2b86d9d..575225b 100644
--- a/compiler/cpp/src/generate/t_delphi_generator.cc
+++ b/compiler/cpp/src/generate/t_delphi_generator.cc
@@ -60,16 +60,26 @@
     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());
+    ansistr_binary_ = false;
+    register_types_ = false;
+    constprefix_ = false;
+    events_ = false;
+    xmldoc_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("ansistr_binary") == 0) {
+        ansistr_binary_ = true;
+      } else if( iter->first.compare("register_types") == 0) {
+        register_types_ = true;
+      } else if( iter->first.compare("constprefix") == 0) {
+        constprefix_ = true;
+      } else if( iter->first.compare("events") == 0) {
+        events_ = true;
+      } else if( iter->first.compare("xmldoc") == 0) {
+        xmldoc_ = true;
+      } else {
+        throw "unknown option delphi:" + iter->first; 
+      }
+    }
 
     out_dir_base_ = "gen-delphi";
     escape_.clear();
diff --git a/compiler/cpp/src/generate/t_erl_generator.cc b/compiler/cpp/src/generate/t_erl_generator.cc
index 78d757e..0e7f7f1 100644
--- a/compiler/cpp/src/generate/t_erl_generator.cc
+++ b/compiler/cpp/src/generate/t_erl_generator.cc
@@ -50,16 +50,29 @@
                   const std::map<std::string, std::string>& parsed_options,
                   const std::string& option_string)
     : t_generator(program) {
-    (void)parsed_options;
     (void)option_string;
-    out_dir_base_ = "gen-erl";
+    std::map<std::string, std::string>::const_iterator iter;
 
-    legacy_names_ = (parsed_options.find("legacynames") != parsed_options.end());
-    maps_ = (parsed_options.find("maps") != parsed_options.end());
-    otp16_ = (parsed_options.find("otp16") != parsed_options.end());
+    legacy_names_ = false;
+    maps_ = false;
+    otp16_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("legacynames") == 0) {
+        legacy_names_ = true;
+      } else if( iter->first.compare("maps") == 0) {
+        maps_ = true;
+      } else if( iter->first.compare("otp16") == 0) {
+        otp16_ = true;
+      } else {
+        throw "unknown option erl:" + iter->first; 
+      }
+    }
+
     if (maps_ && otp16_) {
       throw "argument error: Cannot specify both maps and otp16; maps are not available for Erlang/OTP R16 or older";
     }
+
+    out_dir_base_ = "gen-erl";
   }
 
   /**
diff --git a/compiler/cpp/src/generate/t_go_generator.cc b/compiler/cpp/src/generate/t_go_generator.cc
index 09ab530..b48dc47 100644
--- a/compiler/cpp/src/generate/t_go_generator.cc
+++ b/compiler/cpp/src/generate/t_go_generator.cc
@@ -60,7 +60,7 @@
  */
 bool format_go_output(const string& file_path);
 
-const string default_thrift_import = "git.apache.org/thrift.git/lib/go/thrift";
+const string DEFAULT_THRIFT_IMPORT = "git.apache.org/thrift.git/lib/go/thrift";
 static std::string package_flag;
 
 /**
@@ -74,32 +74,30 @@
     : t_generator(program) {
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
+
+
+    gen_thrift_import_ = DEFAULT_THRIFT_IMPORT;
+    gen_package_prefix_ = "";
+    package_flag = "";
+    read_write_private_ = false;
+    ignore_initialisms_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("package_prefix") == 0) {
+        gen_package_prefix_ = (iter->second);
+      } else if( iter->first.compare("thrift_import") == 0) {
+        gen_thrift_import_ = (iter->second);
+      } else if( iter->first.compare("package") == 0) {
+        package_flag = (iter->second);
+      } else if( iter->first.compare("read_write_private") == 0) {
+        read_write_private_ = true;
+      } else if( iter->first.compare("ignore_initialisms") == 0) {
+        ignore_initialisms_ =  true;
+      } else {
+        throw "unknown option go:" + iter->first; 
+      }
+    }
+
     out_dir_base_ = "gen-go";
-    gen_thrift_import_ = default_thrift_import;
-
-    iter = parsed_options.find("package_prefix");
-
-    if (iter != parsed_options.end()) {
-      gen_package_prefix_ = (iter->second);
-    }
-
-    iter = parsed_options.find("thrift_import");
-
-    if (iter != parsed_options.end()) {
-      gen_thrift_import_ = (iter->second);
-    }
-
-    iter = parsed_options.find("package");
-
-    if (iter != parsed_options.end()) {
-      package_flag = (iter->second);
-    }
-
-    iter = parsed_options.find("read_write_private");
-    read_write_private_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("ignore_initialisms");
-    ignore_initialisms_ = (iter != parsed_options.end());
   }
 
   /**
@@ -3654,7 +3652,7 @@
 
 THRIFT_REGISTER_GENERATOR(go, "Go",
                           "    package_prefix=  Package prefix for generated files.\n" \
-                          "    thrift_import=   Override thrift package import path (default:" + default_thrift_import + ")\n" \
+                          "    thrift_import=   Override thrift package import path (default:" + DEFAULT_THRIFT_IMPORT + ")\n" \
                           "    package=         Package name (default: inferred from thrift file name)\n" \
                           "    ignore_initialisms\n"
                           "                     Disable automatic spelling correction of initialisms (e.g. \"URL\")\n" \
diff --git a/compiler/cpp/src/generate/t_gv_generator.cc b/compiler/cpp/src/generate/t_gv_generator.cc
index b70f2ca..61be8e6 100644
--- a/compiler/cpp/src/generate/t_gv_generator.cc
+++ b/compiler/cpp/src/generate/t_gv_generator.cc
@@ -49,13 +49,19 @@
                  const std::map<std::string, std::string>& parsed_options,
                  const std::string& option_string)
     : t_generator(program) {
-    (void)parsed_options;
     (void)option_string;
-    out_dir_base_ = "gen-gv";
-
     std::map<std::string, std::string>::const_iterator iter;
-    iter = parsed_options.find("exceptions");
-    exception_arrows = (iter != parsed_options.end());
+
+    exception_arrows = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("exceptions") == 0) {
+        exception_arrows = true;
+      } else {
+        throw "unknown option gv:" + iter->first; 
+      }
+    }
+
+    out_dir_base_ = "gen-gv";
   }
 
   /**
diff --git a/compiler/cpp/src/generate/t_haxe_generator.cc b/compiler/cpp/src/generate/t_haxe_generator.cc
index ebaa193..f34a406 100644
--- a/compiler/cpp/src/generate/t_haxe_generator.cc
+++ b/compiler/cpp/src/generate/t_haxe_generator.cc
@@ -52,14 +52,20 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("callbacks");
-    callbacks_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("rtti");
-    rtti_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("buildmacro");
-    buildmacro_ = (iter != parsed_options.end()) ? (iter->second) : "";
+    callbacks_ = false;
+    rtti_ = false;
+    buildmacro_ = "";
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("callbacks") == 0) {
+        callbacks_ = true;
+      } else if( iter->first.compare("rtti") == 0) {
+        rtti_ = true;
+      } else if( iter->first.compare("buildmacro") == 0) {
+        buildmacro_ = (iter->second);
+      } else {
+        throw "unknown option haxe:" + iter->first; 
+      }
+    }
 
     out_dir_base_ = "gen-haxe";
   }
diff --git a/compiler/cpp/src/generate/t_hs_generator.cc b/compiler/cpp/src/generate/t_hs_generator.cc
index 247c9a8..cef8cd0 100644
--- a/compiler/cpp/src/generate/t_hs_generator.cc
+++ b/compiler/cpp/src/generate/t_hs_generator.cc
@@ -51,8 +51,14 @@
                  const map<string, string>& parsed_options,
                  const string& option_string)
     : t_oop_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option hs:" + iter->first; 
+    }
+
     out_dir_base_ = "gen-hs";
   }
 
diff --git a/compiler/cpp/src/generate/t_html_generator.cc b/compiler/cpp/src/generate/t_html_generator.cc
index dc407f3..9594d39 100644
--- a/compiler/cpp/src/generate/t_html_generator.cc
+++ b/compiler/cpp/src/generate/t_html_generator.cc
@@ -53,18 +53,25 @@
                    const std::map<std::string, std::string>& parsed_options,
                    const std::string& option_string)
     : t_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
+    standalone_ = false;
+    unsafe_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("standalone") == 0) {
+        standalone_ = true;
+      } else if( iter->first.compare("noescape") == 0) {
+        unsafe_ = true;
+      } else {
+        throw "unknown option html:" + iter->first; 
+      }
+    }
+
+
     out_dir_base_ = "gen-html";
     input_type_ = INPUT_UNKNOWN;
 
-    std::map<std::string, std::string>::const_iterator iter;
-    iter = parsed_options.find("standalone");
-    standalone_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("noescape");
-    unsafe_ = (iter != parsed_options.end());
-
     escape_.clear();
     escape_['&'] = "&amp;";
     escape_['<'] = "&lt;";
diff --git a/compiler/cpp/src/generate/t_java_generator.cc b/compiler/cpp/src/generate/t_java_generator.cc
index 7c610fb..419a461 100644
--- a/compiler/cpp/src/generate/t_java_generator.cc
+++ b/compiler/cpp/src/generate/t_java_generator.cc
@@ -58,46 +58,54 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("beans");
-    bean_style_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("android");
-    android_style_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("private-members");
-    private_members_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("nocamel");
-    nocamel_style_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("fullcamel");
-    fullcamel_style_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("android_legacy");
-    android_legacy_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("sorted_containers");
-    sorted_containers_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("java5");
-    java5_ = (iter != parsed_options.end());
-    if (java5_) {
-      android_legacy_ = true;
+    bean_style_ = false;
+    android_style_ = false;
+    private_members_ = false;
+    nocamel_style_ = false;
+    fullcamel_style_ = false;
+    android_legacy_ = false;
+    sorted_containers_ = false;
+    java5_ = false;
+    reuse_objects_ = false;
+    use_option_type_ = false;
+    undated_generated_annotations_  = false;
+    suppress_generated_annotations_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("beans") == 0) {
+        bean_style_ = true;
+      } else if( iter->first.compare("android") == 0) {
+        android_style_ = true;
+      } else if( iter->first.compare("private-members") == 0) {
+        private_members_ = true;
+      } else if( iter->first.compare("nocamel") == 0) {
+        nocamel_style_ = true;
+      } else if( iter->first.compare("fullcamel") == 0) {
+        fullcamel_style_ = true;
+      } else if( iter->first.compare("android_legacy") == 0) {
+        android_legacy_ = true;
+      } else if( iter->first.compare("sorted_containers") == 0) {
+        sorted_containers_ = true;
+      } else if( iter->first.compare("java5") == 0) {
+        java5_ = true;
+      } else if( iter->first.compare("reuse-objects") == 0) {
+        reuse_objects_ = true;
+      } else if( iter->first.compare("option_type") == 0) {
+        use_option_type_ = true;
+      } else if( iter->first.compare("generated_annotations") == 0) {
+        if( iter->second.compare("undated") == 0) {
+          undated_generated_annotations_  = true;
+        } else if(iter->second.compare("suppress") == 0) {
+          suppress_generated_annotations_ = true;
+        } else {
+          throw "unknown option java:" + iter->first + "=" + iter->second; 
+        }
+      } else {
+        throw "unknown option java:" + iter->first; 
+      }
     }
 
-    iter = parsed_options.find("reuse-objects");
-    reuse_objects_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("option_type");
-    use_option_type_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("generated_annotations");
-    if (iter != parsed_options.end()) {
-      undated_generated_annotations_  = (iter->second.compare("undated") == 0);
-      suppress_generated_annotations_ = (iter->second.compare("suppress") == 0);
-    } else {
-      undated_generated_annotations_  = false;
-      suppress_generated_annotations_ = false;
+    if (java5_) {
+      android_legacy_ = true;
     }
 
     out_dir_base_ = (bean_style_ ? "gen-javabean" : "gen-java");
diff --git a/compiler/cpp/src/generate/t_javame_generator.cc b/compiler/cpp/src/generate/t_javame_generator.cc
index 219d24c..e9a206b 100644
--- a/compiler/cpp/src/generate/t_javame_generator.cc
+++ b/compiler/cpp/src/generate/t_javame_generator.cc
@@ -52,6 +52,12 @@
     (void)parsed_options;
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
+
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option javame:" + iter->first; 
+    }
+
     out_dir_base_ = "gen-javame";
   }
 
diff --git a/compiler/cpp/src/generate/t_js_generator.cc b/compiler/cpp/src/generate/t_js_generator.cc
index cb0e181..af0f284 100644
--- a/compiler/cpp/src/generate/t_js_generator.cc
+++ b/compiler/cpp/src/generate/t_js_generator.cc
@@ -53,20 +53,25 @@
                  const std::string& option_string)
     : t_oop_generator(program) {
     (void)option_string;
-
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("node");
-    gen_node_ = (iter != parsed_options.end());
+    gen_node_ = false;
+    gen_jquery_ = false;
+    gen_ts_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("node") == 0) {
+        gen_node_ = true;
+      } else if( iter->first.compare("jquery") == 0) {
+        gen_jquery_ = true;
+      } else if( iter->first.compare("ts") == 0) {
+        gen_ts_ = true;
+      } else {
+        throw "unknown option js:" + iter->first; 
+      }
+    }
 
-    iter = parsed_options.find("jquery");
-    gen_jquery_ = (iter != parsed_options.end());
-
-    if (!gen_node_) {
-      iter = parsed_options.find("ts");
-      gen_ts_ = (iter != parsed_options.end());
-    } else {
-      gen_ts_ = false;
+    if (gen_node_ && gen_ts_) {
+      throw "Invalid switch: [-gen js:node,ts] options not compatible";
     }
 
     if (gen_node_ && gen_jquery_) {
diff --git a/compiler/cpp/src/generate/t_json_generator.cc b/compiler/cpp/src/generate/t_json_generator.cc
index 10aaa64..447bc6d 100644
--- a/compiler/cpp/src/generate/t_json_generator.cc
+++ b/compiler/cpp/src/generate/t_json_generator.cc
@@ -53,13 +53,19 @@
                    const std::map<std::string, std::string>& parsed_options,
                    const std::string& option_string)
     : t_generator(program) {
-    (void)parsed_options;
     (void)option_string;
-    out_dir_base_ = "gen-json";
-
     std::map<std::string, std::string>::const_iterator iter;
-    iter = parsed_options.find("merge");
-    should_merge_includes_ = (iter != parsed_options.end());
+
+    should_merge_includes_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("merge") == 0) {
+        should_merge_includes_ = true;
+      } else {
+        throw "unknown option json:" + iter->first; 
+      }
+    }
+
+    out_dir_base_ = "gen-json";
   }
 
   virtual ~t_json_generator() {}
diff --git a/compiler/cpp/src/generate/t_lua_generator.cc b/compiler/cpp/src/generate/t_lua_generator.cc
index 5a674e4..c6fb493 100644
--- a/compiler/cpp/src/generate/t_lua_generator.cc
+++ b/compiler/cpp/src/generate/t_lua_generator.cc
@@ -41,8 +41,14 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("omit_requires");
-    gen_requires_ = (iter == parsed_options.end());
+    gen_requires_ = true;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("omit_requires") == 0) {
+        gen_requires_ = false;
+      } else {
+        throw "unknown option lua:" + iter->first; 
+      }
+    }
 
     out_dir_base_ = "gen-lua";
   }
@@ -1126,4 +1132,7 @@
   throw "INVALID TYPE IN type_to_enum: " + type->get_name();
 }
 
-THRIFT_REGISTER_GENERATOR(lua, "Lua", "")
+THRIFT_REGISTER_GENERATOR(
+    lua,
+    "Lua",
+    "    omit_requires:   Suppress generation of require 'somefile'.\n")
diff --git a/compiler/cpp/src/generate/t_ocaml_generator.cc b/compiler/cpp/src/generate/t_ocaml_generator.cc
index 64e89e7..fc82ebc 100644
--- a/compiler/cpp/src/generate/t_ocaml_generator.cc
+++ b/compiler/cpp/src/generate/t_ocaml_generator.cc
@@ -50,8 +50,14 @@
                     const std::map<std::string, std::string>& parsed_options,
                     const std::string& option_string)
     : t_oop_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option ocaml:" + iter->first; 
+    }
+
     out_dir_base_ = "gen-ocaml";
   }
 
diff --git a/compiler/cpp/src/generate/t_perl_generator.cc b/compiler/cpp/src/generate/t_perl_generator.cc
index 3f247e0..45cfe4b 100644
--- a/compiler/cpp/src/generate/t_perl_generator.cc
+++ b/compiler/cpp/src/generate/t_perl_generator.cc
@@ -49,8 +49,14 @@
                    const std::map<std::string, std::string>& parsed_options,
                    const std::string& option_string)
     : t_oop_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option perl:" + iter->first; 
+    }
+
     out_dir_base_ = "gen-perl";
     escape_['$'] = "\\$";
     escape_['@'] = "\\@";
diff --git a/compiler/cpp/src/generate/t_php_generator.cc b/compiler/cpp/src/generate/t_php_generator.cc
index 0c255ec..9f79337 100644
--- a/compiler/cpp/src/generate/t_php_generator.cc
+++ b/compiler/cpp/src/generate/t_php_generator.cc
@@ -55,29 +55,31 @@
     (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("inlined");
-    binary_inline_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("rest");
-    rest_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("server");
-    phps_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("oop");
-    oop_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("validate");
-    validate_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("json");
-    json_serializable_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("nsglobal");
-    if (iter != parsed_options.end()) {
-      nsglobal_ = iter->second;
-    } else {
-      nsglobal_ = ""; // by default global namespace is empty
+    binary_inline_ = false;
+    rest_ = false;
+    phps_ = false;
+    oop_ = false;
+    validate_ = false;
+    json_serializable_ = false;
+    nsglobal_ = ""; // by default global namespace is empty
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("inlined") == 0) {
+        binary_inline_ = true;
+      } else if( iter->first.compare("rest") == 0) {
+        rest_ = true;
+      } else if( iter->first.compare("server") == 0) {
+        phps_ = true;
+      } else if( iter->first.compare("oop") == 0) {
+        oop_ = true;
+      } else if( iter->first.compare("validate") == 0) {
+        validate_ = true;
+      } else if( iter->first.compare("json") == 0) {
+        json_serializable_ = true;
+      } else if( iter->first.compare("nsglobal") == 0) {
+        nsglobal_ = iter->second;
+      } else {
+        throw "unknown option php:" + iter->first; 
+      }
     }
 
     if (oop_ && binary_inline_) {
diff --git a/compiler/cpp/src/generate/t_py_generator.cc b/compiler/cpp/src/generate/t_py_generator.cc
index d1e2fa3..4ebbe89 100644
--- a/compiler/cpp/src/generate/t_py_generator.cc
+++ b/compiler/cpp/src/generate/t_py_generator.cc
@@ -50,85 +50,76 @@
                  const std::map<std::string, std::string>& parsed_options,
                  const std::string& option_string)
     : t_generator(program) {
-    (void)option_string;
     std::map<std::string, std::string>::const_iterator iter;
 
-    iter = parsed_options.find("new_style");
-    if (iter != parsed_options.end()) {
-      pwarning(0, "new_style is enabled by default, so the option will be removed in the near future.\n");
-    }
-    iter = parsed_options.find("utf8strings");
-    if (iter != parsed_options.end()) {
-      pwarning(0, "utf8strings is enabled by default, so the option will be removed in the near future.\n");
-    }
 
     gen_newstyle_ = true;
-    iter = parsed_options.find("old_style");
-    if (iter != parsed_options.end()) {
-      gen_newstyle_ = false;
-      pwarning(0, "old_style is deprecated and may be removed in the future.\n");
+    gen_utf8strings_ = true;
+    gen_dynbase_ = false;
+    gen_slots_ = false;
+    gen_tornado_ = false;
+    gen_twisted_ = false;
+    gen_dynamic_ = false;
+    coding_ = "";
+    gen_dynbaseclass_ = "";
+    gen_dynbaseclass_exc_ = "";
+    gen_dynbaseclass_frozen_ = "";
+    import_dynbase_ = "";
+    package_prefix_ = "";
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("new_style") == 0) {
+        pwarning(0, "new_style is enabled by default, so the option will be removed in the near future.\n");
+      } else if( iter->first.compare("old_style") == 0) {
+        gen_newstyle_ = false;
+        pwarning(0, "old_style is deprecated and may be removed in the future.\n");
+      } else if( iter->first.compare("utf8strings") == 0) {
+        pwarning(0, "utf8strings is enabled by default, so the option will be removed in the near future.\n");
+      } else if( iter->first.compare("no_utf8strings") == 0) {
+        gen_utf8strings_ = false;
+      } else if( iter->first.compare("slots") == 0) {
+        gen_slots_ = true;
+      } else if( iter->first.compare("package_prefix") == 0) {
+        package_prefix_ = iter->second;
+      } else if( iter->first.compare("dynamic") == 0) {
+        gen_dynamic_ = true;
+        gen_newstyle_ = false; // dynamic is newstyle
+        if( gen_dynbaseclass_.empty()) {
+          gen_dynbaseclass_ = "TBase";
+        }
+        if( gen_dynbaseclass_frozen_.empty()) {
+          gen_dynbaseclass_frozen_ = "TFrozenBase";
+        }
+        if( gen_dynbaseclass_exc_.empty()) {
+          gen_dynbaseclass_exc_ = "TExceptionBase";
+        }
+        if( import_dynbase_.empty()) {
+          import_dynbase_ = "from thrift.protocol.TBase import TBase, TFrozenBase, TExceptionBase, TTransport\n";
+        }
+      } else if( iter->first.compare("dynbase") == 0) {
+        gen_dynbase_ = true;
+        gen_dynbaseclass_ = (iter->second);
+      } else if( iter->first.compare("dynfrozen") == 0) {
+        gen_dynbaseclass_frozen_ = (iter->second);
+      } else if( iter->first.compare("dynexc") == 0) {
+        gen_dynbaseclass_exc_ = (iter->second);
+      } else if( iter->first.compare("dynimport") == 0) {
+        gen_dynbase_ = true;
+        import_dynbase_ = (iter->second);
+      } else if( iter->first.compare("twisted") == 0) {
+        gen_twisted_ = true;
+      } else if( iter->first.compare("tornado") == 0) {
+        gen_tornado_ = true;
+      } else if( iter->first.compare("coding") == 0) {
+        coding_ = iter->second;
+      } else {
+        throw "unknown option py:" + iter->first; 
+      }
     }
 
-    iter = parsed_options.find("slots");
-    gen_slots_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("package_prefix");
-    if (iter != parsed_options.end()) {
-      package_prefix_ = iter->second;
-    }
-
-
-    iter = parsed_options.find("dynamic");
-    gen_dynamic_ = (iter != parsed_options.end());
-
-    if (gen_dynamic_) {
-      gen_newstyle_ = false; // dynamic is newstyle
-      gen_dynbaseclass_ = "TBase";
-      gen_dynbaseclass_frozen_ = "TFrozenBase";
-      gen_dynbaseclass_exc_ = "TExceptionBase";
-      import_dynbase_ = "from thrift.protocol.TBase import TBase, TFrozenBase, TExceptionBase\n";
-    }
-
-    iter = parsed_options.find("dynbase");
-    if (iter != parsed_options.end()) {
-      gen_dynbase_ = true;
-      gen_dynbaseclass_ = (iter->second);
-    }
-
-    iter = parsed_options.find("dynfrozen");
-    if (iter != parsed_options.end()) {
-      gen_dynbaseclass_frozen_ = (iter->second);
-    }
-
-    iter = parsed_options.find("dynexc");
-    if (iter != parsed_options.end()) {
-      gen_dynbaseclass_exc_ = (iter->second);
-    }
-
-    iter = parsed_options.find("dynimport");
-    if (iter != parsed_options.end()) {
-      gen_dynbase_ = true;
-      import_dynbase_ = (iter->second);
-    }
-
-    iter = parsed_options.find("twisted");
-    gen_twisted_ = (iter != parsed_options.end());
-
-    iter = parsed_options.find("tornado");
-    gen_tornado_ = (iter != parsed_options.end());
-
     if (gen_twisted_ && gen_tornado_) {
       throw "at most one of 'twisted' and 'tornado' are allowed";
     }
 
-    iter = parsed_options.find("no_utf8strings");
-    gen_utf8strings_ = (iter == parsed_options.end());
-
-    iter = parsed_options.find("coding");
-    if (iter != parsed_options.end()) {
-        coding_ = iter->second;
-    }
-
     copy_options_ = option_string;
 
     if (gen_twisted_) {
diff --git a/compiler/cpp/src/generate/t_rb_generator.cc b/compiler/cpp/src/generate/t_rb_generator.cc
index 91bb4a9..49bf7e1 100644
--- a/compiler/cpp/src/generate/t_rb_generator.cc
+++ b/compiler/cpp/src/generate/t_rb_generator.cc
@@ -81,10 +81,21 @@
                  const std::string& option_string)
     : t_oop_generator(program) {
     (void)option_string;
-    out_dir_base_ = "gen-rb";
+    std::map<std::string, std::string>::const_iterator iter;
 
-    require_rubygems_ = (parsed_options.find("rubygems") != parsed_options.end());
-    namespaced_ = (parsed_options.find("namespaced") != parsed_options.end());
+    require_rubygems_ = false;
+    namespaced_ = false;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("rubygems") == 0) {
+        require_rubygems_ = true;
+      } else if( iter->first.compare("namespaced") == 0) {
+        namespaced_ = true;
+      } else {
+        throw "unknown option ruby:" + iter->first; 
+      }
+    }
+
+    out_dir_base_ = "gen-rb";
   }
 
   /**
diff --git a/compiler/cpp/src/generate/t_st_generator.cc b/compiler/cpp/src/generate/t_st_generator.cc
index 7df80a2..bc15d24 100644
--- a/compiler/cpp/src/generate/t_st_generator.cc
+++ b/compiler/cpp/src/generate/t_st_generator.cc
@@ -55,8 +55,14 @@
                  const std::map<std::string, std::string>& parsed_options,
                  const std::string& option_string)
     : t_oop_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option st:" + iter->first; 
+    }
+
     out_dir_base_ = "gen-st";
   }
 
diff --git a/compiler/cpp/src/generate/t_swift_generator.cc b/compiler/cpp/src/generate/t_swift_generator.cc
index c3cacd5..4b33993 100644
--- a/compiler/cpp/src/generate/t_swift_generator.cc
+++ b/compiler/cpp/src/generate/t_swift_generator.cc
@@ -52,18 +52,25 @@
     (void)option_string;
     map<string, string>::const_iterator iter;
 
-    iter = parsed_options.find("log_unexpected");
-    log_unexpected_ = (iter != parsed_options.end());
+    log_unexpected_ = false;
+    async_clients_ = false;
+    promise_kit_ = false;
+    debug_descriptions_ = false;
 
-    iter = parsed_options.find("async_clients");
-    async_clients_ = (iter != parsed_options.end());
-      
-    iter = parsed_options.find("promise_kit");
-    promise_kit_ = (iter != parsed_options.end());
-      
-    iter = parsed_options.find("debug_descriptions");
-    debug_descriptions_ = (iter != parsed_options.end());
-    
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("log_unexpected") == 0) {
+        log_unexpected_ = true;
+      } else if( iter->first.compare("async_clients") == 0) {
+        async_clients_ = true;
+      } else if( iter->first.compare("promise_kit") == 0) {
+        promise_kit_ = true;
+      } else if( iter->first.compare("debug_descriptions") == 0) {
+        debug_descriptions_ = true;
+      } else {
+        throw "unknown option swift:" + iter->first; 
+      }
+    }
+
     out_dir_base_ = "gen-swift";
   }
 
@@ -2141,5 +2148,7 @@
     swift,
     "Swift",
     "    log_unexpected:  Log every time an unexpected field ID or type is encountered.\n"
+    "    debug_descriptions:\n"
+    "                     Allow use of debugDescription so the app can add description via a cateogory/extension\n"
     "    async_clients:   Generate clients which invoke asynchronously via block syntax.\n"
     "    promise_kit:     Generate clients which invoke asynchronously via promises.\n")
diff --git a/compiler/cpp/src/generate/t_xml_generator.cc b/compiler/cpp/src/generate/t_xml_generator.cc
index 0b0eb05..4a166c8 100644
--- a/compiler/cpp/src/generate/t_xml_generator.cc
+++ b/compiler/cpp/src/generate/t_xml_generator.cc
@@ -58,19 +58,25 @@
                    const std::map<std::string, std::string>& parsed_options,
                    const std::string& option_string)
     : t_generator(program) {
-    (void)parsed_options;
     (void)option_string;
-    out_dir_base_ = "gen-xml";
-
     std::map<std::string, std::string>::const_iterator iter;
-    iter = parsed_options.find("merge");
-    should_merge_includes_ = (iter != parsed_options.end());
 
-    iter = parsed_options.find("no_default_ns");
-    should_use_default_ns_ = (iter == parsed_options.end());
+    should_merge_includes_ = false;
+    should_use_default_ns_ = true;
+    should_use_namespaces_ = true;
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      if( iter->first.compare("merge") == 0) {
+        should_merge_includes_ = true;
+      } else if( iter->first.compare("no_default_ns") == 0) {
+        should_use_default_ns_ = false;
+      } else if( iter->first.compare("no_namespaces") == 0) {
+        should_use_namespaces_ = false;
+      } else {
+        throw "unknown option xml:" + iter->first; 
+      }
+    }
 
-    iter = parsed_options.find("no_namespaces");
-    should_use_namespaces_ = (iter == parsed_options.end());
+    out_dir_base_ = "gen-xml";
   }
 
   virtual ~t_xml_generator() {}
diff --git a/compiler/cpp/src/generate/t_xsd_generator.cc b/compiler/cpp/src/generate/t_xsd_generator.cc
index cf7937a..2de860a 100644
--- a/compiler/cpp/src/generate/t_xsd_generator.cc
+++ b/compiler/cpp/src/generate/t_xsd_generator.cc
@@ -48,8 +48,14 @@
                   const std::map<std::string, std::string>& parsed_options,
                   const std::string& option_string)
     : t_generator(program) {
-    (void)parsed_options;
     (void)option_string;
+    std::map<std::string, std::string>::const_iterator iter;
+
+    /* no options yet */
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
+      throw "unknown option xsd:" + iter->first; 
+    }
+
     out_dir_base_ = "gen-xsd";
   }
 
diff --git a/contrib/thrift-maven-plugin/src/main/java/org/apache/thrift/maven/AbstractThriftMojo.java b/contrib/thrift-maven-plugin/src/main/java/org/apache/thrift/maven/AbstractThriftMojo.java
index cc319ba..0913c77 100644
--- a/contrib/thrift-maven-plugin/src/main/java/org/apache/thrift/maven/AbstractThriftMojo.java
+++ b/contrib/thrift-maven-plugin/src/main/java/org/apache/thrift/maven/AbstractThriftMojo.java
@@ -93,7 +93,7 @@
      * it will generate Java output. The main reason for this option is to be able to add options
      * to the Java generator - if you generate something else, you're on your own.
      *
-     * @parameter default-value="java:hashcode"
+     * @parameter default-value="java"
      */
     private String generator;
 
diff --git a/contrib/thrift-maven-plugin/src/test/java/org/apache/thrift/maven/TestThrift.java b/contrib/thrift-maven-plugin/src/test/java/org/apache/thrift/maven/TestThrift.java
index 3ecd094..7c7891e 100644
--- a/contrib/thrift-maven-plugin/src/test/java/org/apache/thrift/maven/TestThrift.java
+++ b/contrib/thrift-maven-plugin/src/test/java/org/apache/thrift/maven/TestThrift.java
@@ -73,7 +73,7 @@
 
     @Test
     public void testThriftCompileWithGeneratorOption() throws Exception {
-        builder.setGenerator("java:private-members,hashcode");
+        builder.setGenerator("java:private-members");
         executeThriftCompile();
     }
 
diff --git a/lib/java/build.xml b/lib/java/build.xml
index 2dc7ebe..62680b7 100755
--- a/lib/java/build.xml
+++ b/lib/java/build.xml
@@ -261,25 +261,25 @@
   <target name="generate">
     <!-- Generate the thrift gen-java source -->
     <exec executable="../../compiler/cpp/thrift" failonerror="true">
-      <arg line="--gen java:hashcode ${test.thrift.home}/ThriftTest.thrift"/>
+      <arg line="--gen java ${test.thrift.home}/ThriftTest.thrift"/>
     </exec>
     <exec executable="../../compiler/cpp/thrift" failonerror="true">
-      <arg line="--gen java:hashcode ${test.thrift.home}/DebugProtoTest.thrift"/>
+      <arg line="--gen java ${test.thrift.home}/DebugProtoTest.thrift"/>
     </exec>
     <exec executable="../../compiler/cpp/thrift" failonerror="true">
-      <arg line="--gen java:hashcode ${test.thrift.home}/OptionalRequiredTest.thrift"/>
+      <arg line="--gen java ${test.thrift.home}/OptionalRequiredTest.thrift"/>
     </exec>
     <exec executable="../../compiler/cpp/thrift" failonerror="true">
       <arg line="--gen java:beans,nocamel ${test.thrift.home}/JavaBeansTest.thrift"/>
     </exec>
     <exec executable="../../compiler/cpp/thrift" failonerror="true">
-      <arg line="--gen java:hashcode ${test.thrift.home}/ManyOptionals.thrift"/>
+      <arg line="--gen java ${test.thrift.home}/ManyOptionals.thrift"/>
     </exec>
     <exec executable="mkdir" failonerror="true">
       <arg line="-p ${genfullcamel}"/>
     </exec>
     <exec executable="../../compiler/cpp/thrift" failonerror="true">
-      <arg line="--gen java:hashcode,fullcamel -out ${genfullcamel} ${test.thrift.home}/FullCamelTest.thrift"/>
+      <arg line="--gen java:fullcamel -out ${genfullcamel} ${test.thrift.home}/FullCamelTest.thrift"/>
     </exec>
     <exec executable="mkdir" failonerror="true">
       <arg line="-p ${genreuse}"/>