lua_message.cpp

#include <algorithm>
#include <map>
#include <utility>
#include <vector>

#include <google/protobuf/stubs/hash.h>

#include "lua_message.h"
#include "lua_field.h"
#include "lua_enum.h"
#include "lua_extension.h"
#include "lua_helpers.h"

#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/io/printer.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format.h>
#include <google/protobuf/descriptor.pb.h>

namespace google {
namespace protobuf {
namespace compiler {
namespace mwpb_lua {

	using internal::WireFormat;
	using internal::WireFormatLite;

	namespace {

		void PrintFieldComment(io::Printer* printer, const FieldDescriptor* field) {
			// Print the field's proto-syntax definition as a comment.  We don't want to
			// print group bodies so we cut off after the first line.
			string def = field->DebugString();
			printer->Print("--// $def$\n",
				"def", def.substr(0, def.find_first_of('\n')));
		}

		struct FieldOrderingByNumber {
			inline bool operator()(const FieldDescriptor* a,
				const FieldDescriptor* b) const {
					return a->number() < b->number();
			}
		};

		const char* kWireTypeNames[] = {
			"VARINT",
			"FIXED64",
			"LENGTH_DELIMITED",
			"START_GROUP",
			"END_GROUP",
			"FIXED32",
		};

		// Sort the fields of the given Descriptor by number into a new[]'d array
		// and return it.
		const FieldDescriptor** SortFieldsByNumber(const Descriptor* descriptor) {
			const FieldDescriptor** fields =
				new const FieldDescriptor*[descriptor->field_count()];
			for (int i = 0; i < descriptor->field_count(); i++) {
				fields[i] = descriptor->field(i);
			}
			sort(fields, fields + descriptor->field_count(),
				FieldOrderingByNumber());
			return fields;
		}

		// Functor for sorting extension ranges by their "start" field number.
		struct ExtensionRangeSorter {
			bool operator()(const Descriptor::ExtensionRange* left,
				const Descriptor::ExtensionRange* right) const {
					return left->start < right->start;
			}
		};

		// Returns true if the "required" restriction check should be ignored for the
		// given field.
		inline static bool ShouldIgnoreRequiredFieldCheck(
			const FieldDescriptor* field) {
				return false;
		}

		// Returns true if the message type has any required fields.  If it doesn't,
		// we can optimize out calls to its IsInitialized() method.
		//
		// already_seen is used to avoid checking the same type multiple times
		// (and also to protect against recursion).
		static bool HasRequiredFields(
			const Descriptor* type,
			hash_set<const Descriptor*>* already_seen) {
				if (already_seen->count(type) > 0) {
					// Since the first occurrence of a required field causes the whole
					// function to return true, we can assume that if the type is already
					// in the cache it didn't have any required fields.
					return false;
				}
				already_seen->insert(type);

				// If the type has extensions, an extension with message type could contain
				// required fields, so we have to be conservative and assume such an
				// extension exists.
				if (type->extension_range_count() > 0) return true;

				for (int i = 0; i < type->field_count(); i++) {
					const FieldDescriptor* field = type->field(i);
					if (field->is_required()) {
						return true;
					}
					if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
						!ShouldIgnoreRequiredFieldCheck(field)) {
							if (HasRequiredFields(field->message_type(), already_seen)) {
								return true;
							}
					}
				}

				return false;
		}

		static bool HasRequiredFields(const Descriptor* type) {
			hash_set<const Descriptor*> already_seen;
			return HasRequiredFields(type, &already_seen);
		}

		// This returns an estimate of the compiler's alignment for the field.  This
		// can't guarantee to be correct because the generated code could be compiled on
		// different systems with different alignment rules.  The estimates below assume
		// 64-bit pointers.
		int EstimateAlignmentSize(const FieldDescriptor* field) {
			if (field == NULL) return 0;
			if (field->is_repeated()) return 8;
			switch (field->cpp_type()) {
			case FieldDescriptor::CPPTYPE_BOOL:
				return 1;

			case FieldDescriptor::CPPTYPE_INT32:
			case FieldDescriptor::CPPTYPE_UINT32:
			case FieldDescriptor::CPPTYPE_ENUM:
			case FieldDescriptor::CPPTYPE_FLOAT:
				return 4;

			case FieldDescriptor::CPPTYPE_INT64:
			case FieldDescriptor::CPPTYPE_UINT64:
			case FieldDescriptor::CPPTYPE_DOUBLE:
			case FieldDescriptor::CPPTYPE_STRING:
			case FieldDescriptor::CPPTYPE_MESSAGE:
				return 8;
			}
			GOOGLE_LOG(FATAL) << "Can't get here.";
			return -1;  // Make compiler happy.
		}

		// FieldGroup is just a helper for OptimizePadding below.  It holds a vector of
		// fields that are grouped together because they have compatible alignment, and
		// a preferred location in the final field ordering.
		class FieldGroup {
		public:
			FieldGroup()
				: preferred_location_(0) {}

			// A group with a single field.
			FieldGroup(float preferred_location, const FieldDescriptor* field)
				: preferred_location_(preferred_location),
				fields_(1, field) {}

			// Append the fields in 'other' to this group.
			void Append(const FieldGroup& other) {
				if (other.fields_.empty()) {
					return;
				}
				// Preferred location is the average among all the fields, so we weight by
				// the number of fields on each FieldGroup object.
				preferred_location_ =
					(preferred_location_ * fields_.size() +
					(other.preferred_location_ * other.fields_.size())) /
					(fields_.size() + other.fields_.size());
				fields_.insert(fields_.end(), other.fields_.begin(), other.fields_.end());
			}

			void SetPreferredLocation(float location) { preferred_location_ = location; }
			const vector<const FieldDescriptor*>& fields() const { return fields_; }

			// FieldGroup objects sort by their preferred location.
			bool operator<(const FieldGroup& other) const {
				return preferred_location_ < other.preferred_location_;
			}

		private:
			// "preferred_location_" is an estimate of where this group should go in the
			// final list of fields.  We compute this by taking the average index of each
			// field in this group in the original ordering of fields.  This is very
			// approximate, but should put this group close to where its member fields
			// originally went.
			float preferred_location_;
			vector<const FieldDescriptor*> fields_;
			// We rely on the default copy constructor and operator= so this type can be
			// used in a vector.
		};

		// Reorder 'fields' so that if the fields are output into a c++ class in the new
		// order, the alignment padding is minimized.  We try to do this while keeping
		// each field as close as possible to its original position so that we don't
		// reduce cache locality much for function that access each field in order.
		void OptimizePadding(vector<const FieldDescriptor*>* fields) {
			// First divide fields into those that align to 1 byte, 4 bytes or 8 bytes.
			vector<FieldGroup> aligned_to_1, aligned_to_4, aligned_to_8;
			for (int i = 0; i < fields->size(); ++i) {
				switch (EstimateAlignmentSize((*fields)[i])) {
				case 1: aligned_to_1.push_back(FieldGroup(i, (*fields)[i])); break;
				case 4: aligned_to_4.push_back(FieldGroup(i, (*fields)[i])); break;
				case 8: aligned_to_8.push_back(FieldGroup(i, (*fields)[i])); break;
				default:
					GOOGLE_LOG(FATAL) << "Unknown alignment size.";
				}
			}

			// Now group fields aligned to 1 byte into sets of 4, and treat those like a
			// single field aligned to 4 bytes.
			for (int i = 0; i < aligned_to_1.size(); i += 4) {
				FieldGroup field_group;
				for (int j = i; j < aligned_to_1.size() && j < i + 4; ++j) {
					field_group.Append(aligned_to_1[j]);
				}
				aligned_to_4.push_back(field_group);
			}
			// Sort by preferred location to keep fields as close to their original
			// location as possible.
			sort(aligned_to_4.begin(), aligned_to_4.end());

			// Now group fields aligned to 4 bytes (or the 4-field groups created above)
			// into pairs, and treat those like a single field aligned to 8 bytes.
			for (int i = 0; i < aligned_to_4.size(); i += 2) {
				FieldGroup field_group;
				for (int j = i; j < aligned_to_4.size() && j < i + 2; ++j) {
					field_group.Append(aligned_to_4[j]);
				}
				if (i == aligned_to_4.size() - 1) {
					// Move incomplete 4-byte block to the end.
					field_group.SetPreferredLocation(fields->size() + 1);
				}
				aligned_to_8.push_back(field_group);
			}
			// Sort by preferred location to keep fields as close to their original
			// location as possible.
			sort(aligned_to_8.begin(), aligned_to_8.end());

			// Now pull out all the FieldDescriptors in order.
			fields->clear();
			for (int i = 0; i < aligned_to_8.size(); ++i) {
				fields->insert(fields->end(),
					aligned_to_8[i].fields().begin(),
					aligned_to_8[i].fields().end());
			}
		}

	}

	// ===================================================================

	MessageGenerator::MessageGenerator(const Descriptor* descriptor,
		const Options& options)
		: descriptor_(descriptor),
		classname_(ClassName(descriptor, false)),
		options_(options),
		field_generators_(descriptor, options),
		nested_generators_(new scoped_ptr<MessageGenerator>[
			descriptor->nested_type_count()]),
				enum_generators_(new scoped_ptr<EnumGenerator>[
					descriptor->enum_type_count()]),
						extension_generators_(new scoped_ptr<ExtensionGenerator>[
							descriptor->extension_count()]) {

								for (int i = 0; i < descriptor->nested_type_count(); i++) {
									nested_generators_[i].reset(
										new MessageGenerator(descriptor->nested_type(i), options));
								}

								for (int i = 0; i < descriptor->enum_type_count(); i++) {
									enum_generators_[i].reset(
										new EnumGenerator(descriptor->enum_type(i), options));
								}

								for (int i = 0; i < descriptor->extension_count(); i++) {
									extension_generators_[i].reset(
										new ExtensionGenerator(descriptor->extension(i), options));
								}
							}

							MessageGenerator::~MessageGenerator() {}

							void MessageGenerator::
								GenerateForwardDeclaration(io::Printer* printer) {
									printer->Print("class $classname$;\n",
										"classname", classname_);

									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateForwardDeclaration(printer);
									}
							}

							void MessageGenerator::
								GenerateEnumDefinitions(io::Printer* printer) {
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateEnumDefinitions(printer);
									}

									for (int i = 0; i < descriptor_->enum_type_count(); i++) {
										enum_generators_[i]->GenerateDefinition(printer);
									}
							}

							void MessageGenerator::
								GenerateGetEnumDescriptorSpecializations(io::Printer* printer) {
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateGetEnumDescriptorSpecializations(printer);
									}
									for (int i = 0; i < descriptor_->enum_type_count(); i++) {
										enum_generators_[i]->GenerateGetEnumDescriptorSpecializations(printer);
									}
							}

							void MessageGenerator::
								GenerateFieldAccessorDeclarations(io::Printer* printer) {
									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										PrintFieldComment(printer, field);

										map<string, string> vars;
										SetCommonFieldVariables(field, &vars, options_);
										vars["constant_name"] = FieldConstantName(field);

										if (field->is_repeated()) {
											//printer->Print(vars, "inline int $name$_size() const$deprecation$;\n");
											printer->Print(vars, "$classname$.$name$_size = function()\n");
											printer->Indent();
											printer->Print(vars, "return table.getn($classname$_Member.$name$_)\n");
											printer->Outdent();
											printer->Print("end\n\n");
										} else {
											//printer->Print(vars, "inline bool has_$name$() const$deprecation$;\n");
											printer->Print(vars, "$classname$.has_$name$ = function()\n");
											printer->Indent();
											printer->Print(vars, "return $classname$_Temp.$name$_\n");
											printer->Outdent();
											printer->Print("end\n\n");
										}

										//printer->Print(vars, "inline void clear_$name$()$deprecation$;\n");
										//printer->Print(vars, "static const int $constant_name$ = $number$;\n");
										printer->Print(vars, "$classname$.clear_$name$ = function()\n");
										printer->Indent();
										printer->Print(vars, "$classname$_Temp.$name$_=false\n");
										printer->Outdent();
										printer->Print("end\n\n");

										// Generate type-specific accessor declarations.
										field_generators_.get(field).GenerateAccessorDeclarations(printer);

										printer->Print("\n");
									}

// 									if (descriptor_->extension_range_count() > 0) {
// 										// Generate accessors for extensions.  We just call a macro located in
// 										// extension_set.h since the accessors about 80 lines of static code.
// 										printer->Print(
// 											"GOOGLE_PROTOBUF_EXTENSION_ACCESSORS($classname$)\n",
// 											"classname", classname_);
// 									}
							}

							void MessageGenerator::
								GenerateFieldAccessorDefinitions(io::Printer* printer) {
									printer->Print("// $classname$\n\n", "classname", classname_);

									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										PrintFieldComment(printer, field);

										map<string, string> vars;
										SetCommonFieldVariables(field, &vars, options_);

										// Generate has_$name$() or $name$_size().
										if (field->is_repeated()) {
											printer->Print(vars,
												"inline int $classname$::$name$_size() const {\n"
												"  return $name$_.size();\n"
												"}\n");
										} else {
											// Singular field.
											char buffer[kFastToBufferSize];
											vars["has_array_index"] = SimpleItoa(field->index() / 32);
											vars["has_mask"] = FastHex32ToBuffer(1u << (field->index() % 32), buffer);
											printer->Print(vars,
												"inline bool $classname$::has_$name$() const {\n"
												"  return (_has_bits_[$has_array_index$] & 0x$has_mask$u) != 0;\n"
												"}\n"
												"inline void $classname$::set_has_$name$() {\n"
												"  _has_bits_[$has_array_index$] |= 0x$has_mask$u;\n"
												"}\n"
												"inline void $classname$::clear_has_$name$() {\n"
												"  _has_bits_[$has_array_index$] &= ~0x$has_mask$u;\n"
												"}\n"
												);
										}

										// Generate clear_$name$()
										printer->Print(vars,
											"inline void $classname$::clear_$name$() {\n");

										printer->Indent();
										field_generators_.get(field).GenerateClearingCode(printer);
										printer->Outdent();

										if (!field->is_repeated()) {
											printer->Print(vars,
												"  clear_has_$name$();\n");
										}

										printer->Print("}\n");

										// Generate type-specific accessors.
										field_generators_.get(field).GenerateInlineAccessorDefinitions(printer);

										printer->Print("\n");
									}
							}

							void MessageGenerator::
								GenerateClassDefinition(io::Printer* printer) {
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateClassDefinition(printer);
										printer->Print("\n");
										printer->Print(kThinSeparator);
										printer->Print("\n");
									}

									map<string, string> vars;
									vars["classname"] = classname_;
									vars["field_count"] = SimpleItoa(descriptor_->field_count());
// 									if (options_.dllexport_decl.empty()) {
// 										vars["dllexport"] = "";
// 									} else {
// 										vars["dllexport"] = options_.dllexport_decl + " ";
// 									}
//									vars["superclass"] = SuperClassName(descriptor_);
// 
// 									printer->Print(vars,
// 										"class $dllexport$$classname$ : public $superclass$ {\n"
// 										" public:\n");

									// 定义class table;
									printer->Print(vars,
										"$classname$ = {}\n"
										);

									printer->Print("\n--private: Field members\n");

									// 定义变量;
									printer->Print(vars,
										"local $classname$_Member = {\n"
										);
									printer->Indent();
									//printer->Print(" private:\n");
									// Field members:

									vector<const FieldDescriptor*> fields;
									for (int i = 0; i < descriptor_->field_count(); i++) {
										fields.push_back(descriptor_->field(i));
									}
									OptimizePadding(&fields);
									for (int i = 0; i < fields.size(); ++i) {
										field_generators_.get(fields[i]).GeneratePrivateMembers(printer);
									}
									printer->Outdent();
									printer->Print("}\n");

									printer->Print("\n\n");
									// 打印临时变量,主要保存bool变量，是否被设置过;

									printer->Print(vars,
										"local $classname$_Temp = {\n"
										);
									printer->Indent();

									//vector<const FieldDescriptor*> fields;
									fields.clear();
									for (int i = 0; i < descriptor_->field_count(); i++) {
										fields.push_back(descriptor_->field(i));
									}
									OptimizePadding(&fields);
									for (int i = 0; i < fields.size(); ++i) {
										//field_generators_.get(fields[i]).GeneratePrivateMembers(printer);
										string field_name_temp = fields[i]->name();
										field_name_temp += "_ =  false,\n";
										printer->Print(field_name_temp.c_str());
									}
									printer->Outdent();
									printer->Print("}\n");


									// 打印方法;



									

									printer->Print(
										"--// nested types ----------------------------------------------------\n"
										"\n");

									// Import all nested message classes into this class's scope with typedefs.
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										assert(0);
										const Descriptor* nested_type = descriptor_->nested_type(i);
										printer->Print("typedef $nested_full_name$ $nested_name$;\n",
											"nested_name", nested_type->name(),
											"nested_full_name", ClassName(nested_type, false));
									}

									if (descriptor_->nested_type_count() > 0) {
										printer->Print("\n");
									}

									// Import all nested enums and their values into this class's scope with
									// typedefs and constants.
									for (int i = 0; i < descriptor_->enum_type_count(); i++) {
										enum_generators_[i]->GenerateSymbolImports(printer);
										printer->Print("\n");
									}

									printer->Print(
										"--// accessors -------------------------------------------------------\n"
										"\n");

									// Generate accessor methods for all fields.
									GenerateFieldAccessorDeclarations(printer);

									// 生成数据的decode 与 encode .
									GenerateMergeFromCodedStream(printer);
									
									printer->Print("\n");
									printer->Print("\n");

									GenerateSerializeWithCachedSizes(printer);

// 									// Declare extension identifiers.
// 									for (int i = 0; i < descriptor_->extension_count(); i++) {
// 										extension_generators_[i]->GenerateDeclaration(printer);
// 									}
// 
// 
// 									printer->Print(
// 										"// @@protoc_insertion_point(class_scope:$full_name$)\n",
// 										"full_name", descriptor_->full_name());

									// Generate private members.
//									printer->Outdent();
									//printer->Print(" private:\n");
									//printer->Indent();
// 
// 
// 									for (int i = 0; i < descriptor_->field_count(); i++) {
// 										if (!descriptor_->field(i)->is_repeated()) {
// 											printer->Print(
// 												"inline void set_has_$name$();\n",
// 												"name", FieldName(descriptor_->field(i)));
// 											printer->Print(
// 												"inline void clear_has_$name$();\n",
// 												"name", FieldName(descriptor_->field(i)));
// 										}
// 									}
// 									printer->Print("\n");

// 									// To minimize padding, data members are divided into three sections:
// 									// (1) members assumed to align to 8 bytes
// 									// (2) members corresponding to message fields, re-ordered to optimize
// 									//     alignment.
// 									// (3) members assumed to align to 4 bytes.
// 
// 									// Members assumed to align to 8 bytes:
// 
// 									if (descriptor_->extension_range_count() > 0) {
// 										printer->Print(
// 											"::google::protobuf::internal::ExtensionSet _extensions_;\n"
// 											"\n");
// 									}
// 
// 									if (HasUnknownFields(descriptor_->file())) {
// 										printer->Print(
// 											"::google::protobuf::UnknownFieldSet _unknown_fields_;\n"
// 											"\n");
// 									}

									// Field members:

// 									vector<const FieldDescriptor*> fields;
// 									for (int i = 0; i < descriptor_->field_count(); i++) {
// 										fields.push_back(descriptor_->field(i));
// 									}
// 									OptimizePadding(&fields);
// 									for (int i = 0; i < fields.size(); ++i) {
// 										field_generators_.get(fields[i]).GeneratePrivateMembers(printer);
// 									}
// 
// 									// Members assumed to align to 4 bytes:
// 
// 									// TODO(kenton):  Make _cached_size_ an atomic<int> when C++ supports it.
// 									printer->Print(
// 										"\n"
// 										"mutable int _cached_size_;\n");
// 
// 									// Generate _has_bits_.
// 									if (descriptor_->field_count() > 0) {
// 										printer->Print(vars,
// 											"::google::protobuf::uint32 _has_bits_[($field_count$ + 31) / 32];\n"
// 											"\n");
// 									} else {
// 										// Zero-size arrays aren't technically allowed, and MSVC in particular
// 										// doesn't like them.  We still need to declare these arrays to make
// 										// other code compile.  Since this is an uncommon case, we'll just declare
// 										// them with size 1 and waste some space.  Oh well.
// 										printer->Print(
// 											"::google::protobuf::uint32 _has_bits_[1];\n"
// 											"\n");
// 									}
// 
// 									// Declare AddDescriptors(), BuildDescriptors(), and ShutdownFile() as
// 									// friends so that they can access private static variables like
// 									// default_instance_ and reflection_.
// 									PrintHandlingOptionalStaticInitializers(
// 										descriptor_->file(), printer,
// 										// With static initializers.
// 										"friend void $dllexport_decl$ $adddescriptorsname$();\n",
// 										// Without.
// 										"friend void $dllexport_decl$ $adddescriptorsname$_impl();\n",
// 										// Vars.
// 										"dllexport_decl", options_.dllexport_decl,
// 										"adddescriptorsname",
// 										GlobalAddDescriptorsName(descriptor_->file()->name()));
// 
// 									printer->Print(
// 										"friend void $assigndescriptorsname$();\n"
// 										"friend void $shutdownfilename$();\n"
// 										"\n",
// 										"assigndescriptorsname",
// 										GlobalAssignDescriptorsName(descriptor_->file()->name()),
// 										"shutdownfilename", GlobalShutdownFileName(descriptor_->file()->name()));
// 
// 									printer->Print(
// 										"void InitAsDefaultInstance();\n"
// 										"static $classname$* default_instance_;\n",
// 										"classname", classname_);
// 
// 									printer->Outdent();
// 									printer->Print(vars, "};");
							}

							void MessageGenerator::
								GenerateInlineMethods(io::Printer* printer) {
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateInlineMethods(printer);
										printer->Print(kThinSeparator);
										printer->Print("\n");
									}

									GenerateFieldAccessorDefinitions(printer);
							}

							void MessageGenerator::
								GenerateDescriptorDeclarations(io::Printer* printer) {
									printer->Print(
										"const ::google::protobuf::Descriptor* $name$_descriptor_ = NULL;\n"
										"const ::google::protobuf::internal::GeneratedMessageReflection*\n"
										"  $name$_reflection_ = NULL;\n",
										"name", classname_);

									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateDescriptorDeclarations(printer);
									}

									for (int i = 0; i < descriptor_->enum_type_count(); i++) {
										printer->Print(
											"const ::google::protobuf::EnumDescriptor* $name$_descriptor_ = NULL;\n",
											"name", ClassName(descriptor_->enum_type(i), false));
									}
							}

							void MessageGenerator::
								GenerateDescriptorInitializer(io::Printer* printer, int index) {
									// TODO(kenton):  Passing the index to this method is redundant; just use
									//   descriptor_->index() instead.
									map<string, string> vars;
									vars["classname"] = classname_;
									vars["index"] = SimpleItoa(index);

									// Obtain the descriptor from the parent's descriptor.
									if (descriptor_->containing_type() == NULL) {
										printer->Print(vars,
											"$classname$_descriptor_ = file->message_type($index$);\n");
									} else {
										vars["parent"] = ClassName(descriptor_->containing_type(), false);
										printer->Print(vars,
											"$classname$_descriptor_ = "
											"$parent$_descriptor_->nested_type($index$);\n");
									}

									// Generate the offsets.
									GenerateOffsets(printer);

									// Construct the reflection object.
									printer->Print(vars,
										"$classname$_reflection_ =\n"
										"  new ::google::protobuf::internal::GeneratedMessageReflection(\n"
										"    $classname$_descriptor_,\n"
										"    $classname$::default_instance_,\n"
										"    $classname$_offsets_,\n"
										"    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, _has_bits_[0]),\n"
										"    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET("
										"$classname$, _unknown_fields_),\n");
									if (descriptor_->extension_range_count() > 0) {
										printer->Print(vars,
											"    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET("
											"$classname$, _extensions_),\n");
									} else {
										// No extensions.
										printer->Print(vars,
											"    -1,\n");
									}
									printer->Print(
										"    ::google::protobuf::DescriptorPool::generated_pool(),\n");
									printer->Print(vars,
										"    ::google::protobuf::MessageFactory::generated_factory(),\n");
									printer->Print(vars,
										"    sizeof($classname$));\n");

									// Handle nested types.
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateDescriptorInitializer(printer, i);
									}

									for (int i = 0; i < descriptor_->enum_type_count(); i++) {
										enum_generators_[i]->GenerateDescriptorInitializer(printer, i);
									}
							}

							void MessageGenerator::
								GenerateTypeRegistrations(io::Printer* printer) {
									// Register this message type with the message factory.
									printer->Print(
										"::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(\n"
										"  $classname$_descriptor_, &$classname$::default_instance());\n",
										"classname", classname_);

									// Handle nested types.
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateTypeRegistrations(printer);
									}
							}

							void MessageGenerator::
								GenerateDefaultInstanceAllocator(io::Printer* printer) {
									// Construct the default instances of all fields, as they will be used
									// when creating the default instance of the entire message.
									for (int i = 0; i < descriptor_->field_count(); i++) {
										field_generators_.get(descriptor_->field(i))
											.GenerateDefaultInstanceAllocator(printer);
									}

									// Construct the default instance.  We can't call InitAsDefaultInstance() yet
									// because we need to make sure all default instances that this one might
									// depend on are constructed first.
									printer->Print(
										"$classname$::default_instance_ = new $classname$();\n",
										"classname", classname_);

									// Handle nested types.
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateDefaultInstanceAllocator(printer);
									}

							}

							void MessageGenerator::
								GenerateDefaultInstanceInitializer(io::Printer* printer) {
									printer->Print(
										"$classname$::default_instance_->InitAsDefaultInstance();\n",
										"classname", classname_);

									// Register extensions.
									for (int i = 0; i < descriptor_->extension_count(); i++) {
										extension_generators_[i]->GenerateRegistration(printer);
									}

									// Handle nested types.
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateDefaultInstanceInitializer(printer);
									}
							}

							void MessageGenerator::
								GenerateShutdownCode(io::Printer* printer) {
									printer->Print(
										"delete $classname$::default_instance_;\n",
										"classname", classname_);

									if (HasDescriptorMethods(descriptor_->file())) {
										printer->Print(
											"delete $classname$_reflection_;\n",
											"classname", classname_);
									}

									// Handle default instances of fields.
									for (int i = 0; i < descriptor_->field_count(); i++) {
										field_generators_.get(descriptor_->field(i))
											.GenerateShutdownCode(printer);
									}

									// Handle nested types.
									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateShutdownCode(printer);
									}
							}

							void MessageGenerator::
								GenerateClassMethods(io::Printer* printer) {
									for (int i = 0; i < descriptor_->enum_type_count(); i++) {
										enum_generators_[i]->GenerateMethods(printer);
									}

									for (int i = 0; i < descriptor_->nested_type_count(); i++) {
										nested_generators_[i]->GenerateClassMethods(printer);
										printer->Print("\n");
										printer->Print(kThinSeparator);
										printer->Print("\n");
									}

									// Generate non-inline field definitions.
									for (int i = 0; i < descriptor_->field_count(); i++) {
										field_generators_.get(descriptor_->field(i))
											.GenerateNonInlineAccessorDefinitions(printer);
									}

									// Generate field number constants.
									printer->Print("#ifndef _MSC_VER\n");
									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor *field = descriptor_->field(i);
										printer->Print(
											"const int $classname$::$constant_name$;\n",
											"classname", ClassName(FieldScope(field), false),
											"constant_name", FieldConstantName(field));
									}
									printer->Print(
										"#endif  // !_MSC_VER\n"
										"\n");

									// Define extension identifiers.
									for (int i = 0; i < descriptor_->extension_count(); i++) {
										extension_generators_[i]->GenerateDefinition(printer);
									}

									GenerateStructors(printer);
									printer->Print("\n");

									if (HasGeneratedMethods(descriptor_->file())) {
										GenerateClear(printer);
										printer->Print("\n");

										GenerateMergeFromCodedStream(printer);
										printer->Print("\n");

										GenerateSerializeWithCachedSizes(printer);
										printer->Print("\n");

										if (HasFastArraySerialization(descriptor_->file())) {
											GenerateSerializeWithCachedSizesToArray(printer);
											printer->Print("\n");
										}

										GenerateByteSize(printer);
										printer->Print("\n");

										GenerateMergeFrom(printer);
										printer->Print("\n");

										GenerateCopyFrom(printer);
										printer->Print("\n");

										GenerateIsInitialized(printer);
										printer->Print("\n");
									}

									GenerateSwap(printer);
									printer->Print("\n");

									if (HasDescriptorMethods(descriptor_->file())) {
										printer->Print(
											"::google::protobuf::Metadata $classname$::GetMetadata() const {\n"
											"  protobuf_AssignDescriptorsOnce();\n"
											"  ::google::protobuf::Metadata metadata;\n"
											"  metadata.descriptor = $classname$_descriptor_;\n"
											"  metadata.reflection = $classname$_reflection_;\n"
											"  return metadata;\n"
											"}\n"
											"\n",
											"classname", classname_);
									} else {
										printer->Print(
											"::std::string $classname$::GetTypeName() const {\n"
											"  return \"$type_name$\";\n"
											"}\n"
											"\n",
											"classname", classname_,
											"type_name", descriptor_->full_name());
									}

							}

							void MessageGenerator::
								GenerateOffsets(io::Printer* printer) {
									printer->Print(
										"static const int $classname$_offsets_[$field_count$] = {\n",
										"classname", classname_,
										"field_count", SimpleItoa(max(1, descriptor_->field_count())));
									printer->Indent();

									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);
										printer->Print(
											"GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET($classname$, $name$_),\n",
											"classname", classname_,
											"name", FieldName(field));
									}

									printer->Outdent();
									printer->Print("};\n");
							}

							void MessageGenerator::
								GenerateSharedConstructorCode(io::Printer* printer) {
									printer->Print(
										"void $classname$::SharedCtor() {\n",
										"classname", classname_);
									printer->Indent();

									printer->Print(
										"_cached_size_ = 0;\n");

									for (int i = 0; i < descriptor_->field_count(); i++) {
										field_generators_.get(descriptor_->field(i))
											.GenerateConstructorCode(printer);
									}

									printer->Print(
										"::memset(_has_bits_, 0, sizeof(_has_bits_));\n");

									printer->Outdent();
									printer->Print("}\n\n");
							}

							void MessageGenerator::
								GenerateSharedDestructorCode(io::Printer* printer) {
									printer->Print(
										"void $classname$::SharedDtor() {\n",
										"classname", classname_);
									printer->Indent();
									// Write the destructors for each field.
									for (int i = 0; i < descriptor_->field_count(); i++) {
										field_generators_.get(descriptor_->field(i))
											.GenerateDestructorCode(printer);
									}

									PrintHandlingOptionalStaticInitializers(
										descriptor_->file(), printer,
										// With static initializers.
										"if (this != default_instance_) {\n",
										// Without.
										"if (this != &default_instance()) {\n");

									// We need to delete all embedded messages.
									// TODO(kenton):  If we make unset messages point at default instances
									//   instead of NULL, then it would make sense to move this code into
									//   MessageFieldGenerator::GenerateDestructorCode().
									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (!field->is_repeated() &&
											field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
												printer->Print("  delete $name$_;\n",
													"name", FieldName(field));
										}
									}

									printer->Outdent();
									printer->Print(
										"  }\n"
										"}\n"
										"\n");
							}

							void MessageGenerator::
								GenerateStructors(io::Printer* printer) {
									string superclass = SuperClassName(descriptor_);

									// Generate the default constructor.
									printer->Print(
										"$classname$::$classname$()\n"
										"  : $superclass$() {\n"
										"  SharedCtor();\n"
										"}\n",
										"classname", classname_,
										"superclass", superclass);

									printer->Print(
										"\n"
										"void $classname$::InitAsDefaultInstance() {\n",
										"classname", classname_);

									// The default instance needs all of its embedded message pointers
									// cross-linked to other default instances.  We can't do this initialization
									// in the constructor because some other default instances may not have been
									// constructed yet at that time.
									// TODO(kenton):  Maybe all message fields (even for non-default messages)
									//   should be initialized to point at default instances rather than NULL?
									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (!field->is_repeated() &&
											field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
												PrintHandlingOptionalStaticInitializers(
													descriptor_->file(), printer,
													// With static initializers.
													"  $name$_ = const_cast< $type$*>(&$type$::default_instance());\n",
													// Without.
													"  $name$_ = const_cast< $type$*>(\n"
													"      $type$::internal_default_instance());\n",
													// Vars.
													"name", FieldName(field),
													"type", FieldMessageTypeName(field));
										}
									}
									printer->Print(
										"}\n"
										"\n");

									// Generate the copy constructor.
									printer->Print(
										"$classname$::$classname$(const $classname$& from)\n"
										"  : $superclass$() {\n"
										"  SharedCtor();\n"
										"  MergeFrom(from);\n"
										"}\n"
										"\n",
										"classname", classname_,
										"superclass", superclass);

									// Generate the shared constructor code.
									GenerateSharedConstructorCode(printer);

									// Generate the destructor.
									printer->Print(
										"$classname$::~$classname$() {\n"
										"  SharedDtor();\n"
										"}\n"
										"\n",
										"classname", classname_);

									// Generate the shared destructor code.
									GenerateSharedDestructorCode(printer);

									// Generate SetCachedSize.
									printer->Print(
										"void $classname$::SetCachedSize(int size) const {\n"
										"  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();\n"
										"  _cached_size_ = size;\n"
										"  GOOGLE_SAFE_CONCURRENT_WRITES_END();\n"
										"}\n",
										"classname", classname_);

									// Only generate this member if it's not disabled.
									if (HasDescriptorMethods(descriptor_->file()) &&
										!descriptor_->options().no_standard_descriptor_accessor()) {
											printer->Print(
												"const ::google::protobuf::Descriptor* $classname$::descriptor() {\n"
												"  protobuf_AssignDescriptorsOnce();\n"
												"  return $classname$_descriptor_;\n"
												"}\n"
												"\n",
												"classname", classname_,
												"adddescriptorsname",
												GlobalAddDescriptorsName(descriptor_->file()->name()));
									}

									printer->Print(
										"const $classname$& $classname$::default_instance() {\n",
										"classname", classname_);

									PrintHandlingOptionalStaticInitializers(
										descriptor_->file(), printer,
										// With static initializers.
										"  if (default_instance_ == NULL) $adddescriptorsname$();\n",
										// Without.
										"  $adddescriptorsname$();\n",
										// Vars.
										"adddescriptorsname",
										GlobalAddDescriptorsName(descriptor_->file()->name()));

									printer->Print(
										"  return *default_instance_;\n"
										"}\n"
										"\n"
										"$classname$* $classname$::default_instance_ = NULL;\n"
										"\n"
										"$classname$* $classname$::New() const {\n"
										"  return new $classname$;\n"
										"}\n",
										"classname", classname_,
										"adddescriptorsname",
										GlobalAddDescriptorsName(descriptor_->file()->name()));
							}

							void MessageGenerator::
								GenerateClear(io::Printer* printer) {
									printer->Print("void $classname$::Clear() {\n",
										"classname", classname_);
									printer->Indent();

									int last_index = -1;

									if (descriptor_->extension_range_count() > 0) {
										printer->Print("_extensions_.Clear();\n");
									}

									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (!field->is_repeated()) {
											// We can use the fact that _has_bits_ is a giant bitfield to our
											// advantage:  We can check up to 32 bits at a time for equality to
											// zero, and skip the whole range if so.  This can improve the speed
											// of Clear() for messages which contain a very large number of
											// optional fields of which only a few are used at a time.  Here,
											// we've chosen to check 8 bits at a time rather than 32.
											if (i / 8 != last_index / 8 || last_index < 0) {
												if (last_index >= 0) {
													printer->Outdent();
													printer->Print("}\n");
												}
												printer->Print(
													"if (_has_bits_[$index$ / 32] & (0xffu << ($index$ % 32))) {\n",
													"index", SimpleItoa(field->index()));
												printer->Indent();
											}
											last_index = i;

											// It's faster to just overwrite primitive types, but we should
											// only clear strings and messages if they were set.
											// TODO(kenton):  Let the CppFieldGenerator decide this somehow.
											bool should_check_bit =
												field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ||
												field->cpp_type() == FieldDescriptor::CPPTYPE_STRING;

											if (should_check_bit) {
												printer->Print(
													"if (has_$name$()) {\n",
													"name", FieldName(field));
												printer->Indent();
											}

											field_generators_.get(field).GenerateClearingCode(printer);

											if (should_check_bit) {
												printer->Outdent();
												printer->Print("}\n");
											}
										}
									}

									if (last_index >= 0) {
										printer->Outdent();
										printer->Print("}\n");
									}

									// Repeated fields don't use _has_bits_ so we clear them in a separate
									// pass.
									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (field->is_repeated()) {
											field_generators_.get(field).GenerateClearingCode(printer);
										}
									}

									printer->Print(
										"::memset(_has_bits_, 0, sizeof(_has_bits_));\n");

									if (HasUnknownFields(descriptor_->file())) {
										printer->Print(
											"mutable_unknown_fields()->Clear();\n");
									}

									printer->Outdent();
									printer->Print("}\n");
							}

							void MessageGenerator::
								GenerateSwap(io::Printer* printer) {
									// Generate the Swap member function.
									printer->Print("void $classname$::Swap($classname$* other) {\n",
										"classname", classname_);
									printer->Indent();
									printer->Print("if (other != this) {\n");
									printer->Indent();

									if (HasGeneratedMethods(descriptor_->file())) {
										for (int i = 0; i < descriptor_->field_count(); i++) {
											const FieldDescriptor* field = descriptor_->field(i);
											field_generators_.get(field).GenerateSwappingCode(printer);
										}

										for (int i = 0; i < (descriptor_->field_count() + 31) / 32; ++i) {
											printer->Print("std::swap(_has_bits_[$i$], other->_has_bits_[$i$]);\n",
												"i", SimpleItoa(i));
										}

										if (HasUnknownFields(descriptor_->file())) {
											printer->Print("_unknown_fields_.Swap(&other->_unknown_fields_);\n");
										}
										printer->Print("std::swap(_cached_size_, other->_cached_size_);\n");
										if (descriptor_->extension_range_count() > 0) {
											printer->Print("_extensions_.Swap(&other->_extensions_);\n");
										}
									} else {
										printer->Print("GetReflection()->Swap(this, other);");
									}

									printer->Outdent();
									printer->Print("}\n");
									printer->Outdent();
									printer->Print("}\n");
							}

							void MessageGenerator::
								GenerateMergeFrom(io::Printer* printer) {
									if (HasDescriptorMethods(descriptor_->file())) {
										// Generate the generalized MergeFrom (aka that which takes in the Message
										// base class as a parameter).
										printer->Print(
											"void $classname$::MergeFrom(const ::google::protobuf::Message& from) {\n"
											"  GOOGLE_CHECK_NE(&from, this);\n",
											"classname", classname_);
										printer->Indent();

										// Cast the message to the proper type. If we find that the message is
										// *not* of the proper type, we can still call Merge via the reflection
										// system, as the GOOGLE_CHECK above ensured that we have the same descriptor
										// for each message.
										printer->Print(
											"const $classname$* source =\n"
											"  ::google::protobuf::internal::dynamic_cast_if_available<const $classname$*>(\n"
											"    &from);\n"
											"if (source == NULL) {\n"
											"  ::google::protobuf::internal::ReflectionOps::Merge(from, this);\n"
											"} else {\n"
											"  MergeFrom(*source);\n"
											"}\n",
											"classname", classname_);

										printer->Outdent();
										printer->Print("}\n\n");
									} else {
										// Generate CheckTypeAndMergeFrom().
										printer->Print(
											"void $classname$::CheckTypeAndMergeFrom(\n"
											"    const ::google::protobuf::MessageLite& from) {\n"
											"  MergeFrom(*::google::protobuf::down_cast<const $classname$*>(&from));\n"
											"}\n"
											"\n",
											"classname", classname_);
									}

									// Generate the class-specific MergeFrom, which avoids the GOOGLE_CHECK and cast.
									printer->Print(
										"void $classname$::MergeFrom(const $classname$& from) {\n"
										"  GOOGLE_CHECK_NE(&from, this);\n",
										"classname", classname_);
									printer->Indent();

									// Merge Repeated fields. These fields do not require a
									// check as we can simply iterate over them.
									for (int i = 0; i < descriptor_->field_count(); ++i) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (field->is_repeated()) {
											field_generators_.get(field).GenerateMergingCode(printer);
										}
									}

									// Merge Optional and Required fields (after a _has_bit check).
									int last_index = -1;

									for (int i = 0; i < descriptor_->field_count(); ++i) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (!field->is_repeated()) {
											// See above in GenerateClear for an explanation of this.
											if (i / 8 != last_index / 8 || last_index < 0) {
												if (last_index >= 0) {
													printer->Outdent();
													printer->Print("}\n");
												}
												printer->Print(
													"if (from._has_bits_[$index$ / 32] & (0xffu << ($index$ % 32))) {\n",
													"index", SimpleItoa(field->index()));
												printer->Indent();
											}

											last_index = i;

											printer->Print(
												"if (from.has_$name$()) {\n",
												"name", FieldName(field));
											printer->Indent();

											field_generators_.get(field).GenerateMergingCode(printer);

											printer->Outdent();
											printer->Print("}\n");
										}
									}

									if (last_index >= 0) {
										printer->Outdent();
										printer->Print("}\n");
									}

									if (descriptor_->extension_range_count() > 0) {
										printer->Print("_extensions_.MergeFrom(from._extensions_);\n");
									}

									if (HasUnknownFields(descriptor_->file())) {
										printer->Print(
											"mutable_unknown_fields()->MergeFrom(from.unknown_fields());\n");
									}

									printer->Outdent();
									printer->Print("}\n");
							}

							void MessageGenerator::
								GenerateCopyFrom(io::Printer* printer) {
									if (HasDescriptorMethods(descriptor_->file())) {
										// Generate the generalized CopyFrom (aka that which takes in the Message
										// base class as a parameter).
										printer->Print(
											"void $classname$::CopyFrom(const ::google::protobuf::Message& from) {\n",
											"classname", classname_);
										printer->Indent();

										printer->Print(
											"if (&from == this) return;\n"
											"Clear();\n"
											"MergeFrom(from);\n");

										printer->Outdent();
										printer->Print("}\n\n");
									}

									// Generate the class-specific CopyFrom.
									printer->Print(
										"void $classname$::CopyFrom(const $classname$& from) {\n",
										"classname", classname_);
									printer->Indent();

									printer->Print(
										"if (&from == this) return;\n"
										"Clear();\n"
										"MergeFrom(from);\n");

									printer->Outdent();
									printer->Print("}\n");
							}

							void MessageGenerator::
								GenerateMergeFromCodedStream(io::Printer* printer) {

									// decode.
									printer->Print(
										"$classname$.MergePartialFromCodedStream = function()\n",
										"classname", classname_);
									printer->Indent();
									printer->Print("local tag = MSG:pb_ReadTag();\n");
									printer->Print("while tag~=0 do\n");
									printer->Indent();

									if (descriptor_->field_count() > 0) {
										printer->Print("local index = pb_GetTagFieldNumber(tag);\n\n");
										
										scoped_array<const FieldDescriptor*> ordered_fields(
											SortFieldsByNumber(descriptor_));
																				
										for (int i = 0; i < descriptor_->field_count(); i++) {
											const FieldDescriptor* field = ordered_fields[i];
											const FieldGenerator& field_generator = field_generators_.get(field);

											PrintFieldComment(printer, field);
											
											bool bElseTag = false;
											if (i==0) {
												printer->Print("if $number$==index then\n","number", SimpleItoa(field->number()));
											//} else if (i==(descriptor_->field_count()-1)) {
												//printer->Print("else\n");
												//bElseTag = true;
											} else {
												printer->Print("elseif $number$==index then\n", "number", SimpleItoa(field->number()));
											}

											printer->Indent();
											if (bElseTag) {												
												printer->Print("LuaLOG(\"$classname$ decode Error index = $number$\")\n", "classname", classname_, "number", SimpleItoa(field->number()));
											} else {
												printer->Print("if pb_GetTagWireType(tag) == WireType_PB.WIRETYPE_$wiretype$ then \n", "wiretype", kWireTypeNames[WireFormat::WireTypeForField(field)]);
												
												if (i > 0 || (field->is_repeated() && !field->options().packed())) {
// 													printer->Print(
// 														" ::parse_$name$::\n",
// 														"name", field->name());
												}

												printer->Indent();
												if (field->options().packed()) {
													field_generator.GenerateMergeFromCodedStreamWithPacking(printer);
												} else {
													field_generator.GenerateMergeFromCodedStream(printer);
												}
												printer->Outdent();

												// Emit code to parse unexpectedly packed or unpacked values.
												if (field->is_packable() && field->options().packed()) {
													printer->Print(
														"elseif pb_GetTagWireType(tag)== WireType_PB.WIRETYPE_$wiretype$ then \n",
														"wiretype",
														kWireTypeNames[WireFormat::WireTypeForFieldType(field->type())]);
													printer->Indent();
													field_generator.GenerateMergeFromCodedStream(printer);
													printer->Outdent();
												} else if (field->is_packable() && !field->options().packed()) {
													printer->Print(
														"elseif pb_GetTagWireType(tag)== WireType_PB.WIRETYPE_LENGTH_DELIMITED then\n");
													printer->Indent();
													field_generator.GenerateMergeFromCodedStreamWithPacking(printer);
													printer->Outdent();
												}
												//printer->Print("end \n");

												printer->Print(
													"else\n"
													"  LuaLOG(\" error \");\n"
													"end\n");

//TODO:MIWEI
												//// switch() is slow since it can't be predicted well.  Insert some if()s
												//// here that attempt to predict the next tag.
												//if (field->is_repeated() && !field->options().packed()) {
												//	// Expect repeats of this field.
												//	printer->Print(
												//		"if pb_ExpectTag($tag$) then goto parse_$name$ end;\n",
												//		"tag", SimpleItoa(WireFormat::MakeTag(field)),
												//		"name", field->name());
												//}

												
												if (i + 1 < descriptor_->field_count()) {
//TODO:MIWEI
													//// Expect the next field in order.
													//const FieldDescriptor* next_field = ordered_fields[i + 1];
													//printer->Print(
													//	"if (pb_ExpectTag($next_tag$)) then goto parse_$next_name$; end\n",
													//	"next_tag", SimpleItoa(WireFormat::MakeTag(next_field)),
													//	"next_name", next_field->name());
												} else {
													// Expect EOF.
													// TODO(kenton):  Expect group end-tag?
													printer->Print(
														"if (pb_ExpectAtEnd()) then return true; end;\n");

												}
											}
											printer->Outdent();
										}
										printer->Print("else\n");
										printer->Print("  LuaLOG(\" error decode! \");\n");
										printer->Print("end\n");
										printer->Print("\n");
										printer->Print("tag = MSG:pb_ReadTag();\n");
									}


									printer->Outdent();
									printer->Print("end\n");
									printer->Print("\nreturn true;\n");
									printer->Outdent();									
									printer->Print("end\n");
							}

							void MessageGenerator::GenerateSerializeOneField(
								io::Printer* printer, const FieldDescriptor* field, bool to_array) {
									PrintFieldComment(printer, field);

									if (!field->is_repeated()) {
										printer->Print(
											"if ($classname$.has_$name$()) then\n",
											"classname", classname_,
											"name", FieldName(field));
										printer->Indent();
									}

// 									if (to_array) {
// 										field_generators_.get(field).GenerateSerializeWithCachedSizesToArray(
// 											printer);
// 									} else {
// 										field_generators_.get(field).GenerateSerializeWithCachedSizes(printer);
// 									}
									field_generators_.get(field).GenerateSerializeWithCachedSizes(printer);

									if (!field->is_repeated()) {
										printer->Outdent();
										printer->Print("end\n");
									}
									printer->Print("\n");
							}

							void MessageGenerator::GenerateSerializeOneExtensionRange(
								io::Printer* printer, const Descriptor::ExtensionRange* range,
								bool to_array) {
									map<string, string> vars;
									vars["start"] = SimpleItoa(range->start);
									vars["end"] = SimpleItoa(range->end);
									printer->Print(vars,
										"// Extension range [$start$, $end$)\n");
									if (to_array) {
										printer->Print(vars,
											"target = _extensions_.SerializeWithCachedSizesToArray(\n"
											"    $start$, $end$, target);\n\n");
									} else {
										printer->Print(vars,
											"_extensions_.SerializeWithCachedSizes(\n"
											"    $start$, $end$, output);\n\n");
									}
							}

							void MessageGenerator::
								GenerateSerializeWithCachedSizes(io::Printer* printer) {
// 									if (descriptor_->options().message_set_wire_format()) {
// 										// Special-case MessageSet.
// 										printer->Print(
// 											"void $classname$::SerializeWithCachedSizes(\n"
// 											"    ::google::protobuf::io::CodedOutputStream* output) const {\n"
// 											"  _extensions_.SerializeMessageSetWithCachedSizes(output);\n",
// 											"classname", classname_);
// 										if (HasUnknownFields(descriptor_->file())) {
// 											printer->Print(
// 												"  ::google::protobuf::internal::WireFormat::SerializeUnknownMessageSetItems(\n"
// 												"      unknown_fields(), output);\n");
// 										}
// 										printer->Print(
// 											"}\n");
// 										return;
// 									}
									// encode.
									printer->Print(
										"$classname$.SerializeWithCachedSizes = function()\n",
										"classname", classname_);

// 									printer->Print(
// 										"void $classname$::SerializeWithCachedSizes(\n"
// 										"    ::google::protobuf::io::CodedOutputStream* output) const {\n",
// 										"classname", classname_);
									printer->Indent();

									GenerateSerializeWithCachedSizesBody(printer, false);

									printer->Outdent();
									printer->Print(
										"end\n");
							}

							void MessageGenerator::
								GenerateSerializeWithCachedSizesToArray(io::Printer* printer) {
									if (descriptor_->options().message_set_wire_format()) {
										// Special-case MessageSet.
										printer->Print(
											"::google::protobuf::uint8* $classname$::SerializeWithCachedSizesToArray(\n"
											"    ::google::protobuf::uint8* target) const {\n"
											"  target =\n"
											"      _extensions_.SerializeMessageSetWithCachedSizesToArray(target);\n",
											"classname", classname_);
										if (HasUnknownFields(descriptor_->file())) {
											printer->Print(
												"  target = ::google::protobuf::internal::WireFormat::\n"
												"             SerializeUnknownMessageSetItemsToArray(\n"
												"               unknown_fields(), target);\n");
										}
										printer->Print(
											"  return target;\n"
											"}\n");
										return;
									}

									printer->Print(
										"::google::protobuf::uint8* $classname$::SerializeWithCachedSizesToArray(\n"
										"    ::google::protobuf::uint8* target) const {\n",
										"classname", classname_);
									printer->Indent();

									GenerateSerializeWithCachedSizesBody(printer, true);

									printer->Outdent();
									printer->Print(
										"  return target;\n"
										"}\n");
							}

							void MessageGenerator::
								GenerateSerializeWithCachedSizesBody(io::Printer* printer, bool to_array) {
									scoped_array<const FieldDescriptor*> ordered_fields(
										SortFieldsByNumber(descriptor_));

									vector<const Descriptor::ExtensionRange*> sorted_extensions;
									for (int i = 0; i < descriptor_->extension_range_count(); ++i) {
										sorted_extensions.push_back(descriptor_->extension_range(i));
									}
									sort(sorted_extensions.begin(), sorted_extensions.end(),
										ExtensionRangeSorter());

									// Merge the fields and the extension ranges, both sorted by field number.
									int i, j;
									for (i = 0, j = 0;
										i < descriptor_->field_count() || j < sorted_extensions.size();
										) {
											if (i == descriptor_->field_count()) {
//  												GenerateSerializeOneExtensionRange(printer,
//  													sorted_extensions[j++],
//  													to_array);
											} else if (j == sorted_extensions.size()) {
												GenerateSerializeOneField(printer, ordered_fields[i++], to_array);
											} else if (ordered_fields[i]->number() < sorted_extensions[j]->start) {
												GenerateSerializeOneField(printer, ordered_fields[i++], to_array);
											} else {
// 												GenerateSerializeOneExtensionRange(printer,
// 													sorted_extensions[j++],
// 													to_array);
											}
									}

// 									if (HasUnknownFields(descriptor_->file())) {
// 										printer->Print("if (!unknown_fields().empty()) {\n");
// 										printer->Indent();
// 										if (to_array) {
// 											printer->Print(
// 												"target = "
// 												"::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(\n"
// 												"    unknown_fields(), target);\n");
// 										} else {
// 											printer->Print(
// 												"::google::protobuf::internal::WireFormat::SerializeUnknownFields(\n"
// 												"    unknown_fields(), output);\n");
// 										}
// 										printer->Outdent();
// 
// 										printer->Print(
// 											"}\n");
// 									}
							}

							void MessageGenerator::
								GenerateByteSize(io::Printer* printer) {
									if (descriptor_->options().message_set_wire_format()) {
										// Special-case MessageSet.
										printer->Print(
											"int $classname$::ByteSize() const {\n"
											"  int total_size = _extensions_.MessageSetByteSize();\n",
											"classname", classname_);
										if (HasUnknownFields(descriptor_->file())) {
											printer->Print(
												"  total_size += ::google::protobuf::internal::WireFormat::\n"
												"      ComputeUnknownMessageSetItemsSize(unknown_fields());\n");
										}
										printer->Print(
											"  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();\n"
											"  _cached_size_ = total_size;\n"
											"  GOOGLE_SAFE_CONCURRENT_WRITES_END();\n"
											"  return total_size;\n"
											"}\n");
										return;
									}

									printer->Print(
										"int $classname$::ByteSize() const {\n",
										"classname", classname_);
									printer->Indent();
									printer->Print(
										"int total_size = 0;\n"
										"\n");

									int last_index = -1;

									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (!field->is_repeated()) {
											// See above in GenerateClear for an explanation of this.
											// TODO(kenton):  Share code?  Unclear how to do so without
											//   over-engineering.
											if ((i / 8) != (last_index / 8) ||
												last_index < 0) {
													if (last_index >= 0) {
														printer->Outdent();
														printer->Print("}\n");
													}
													printer->Print(
														"if (_has_bits_[$index$ / 32] & (0xffu << ($index$ % 32))) {\n",
														"index", SimpleItoa(field->index()));
													printer->Indent();
											}
											last_index = i;

											PrintFieldComment(printer, field);

											printer->Print(
												"if (has_$name$()) {\n",
												"name", FieldName(field));
											printer->Indent();

											field_generators_.get(field).GenerateByteSize(printer);

											printer->Outdent();
											printer->Print(
												"}\n"
												"\n");
										}
									}

									if (last_index >= 0) {
										printer->Outdent();
										printer->Print("}\n");
									}

									// Repeated fields don't use _has_bits_ so we count them in a separate
									// pass.
									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);

										if (field->is_repeated()) {
											PrintFieldComment(printer, field);
											field_generators_.get(field).GenerateByteSize(printer);
											printer->Print("\n");
										}
									}

									if (descriptor_->extension_range_count() > 0) {
										printer->Print(
											"total_size += _extensions_.ByteSize();\n"
											"\n");
									}

									if (HasUnknownFields(descriptor_->file())) {
										printer->Print("if (!unknown_fields().empty()) {\n");
										printer->Indent();
										printer->Print(
											"total_size +=\n"
											"  ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(\n"
											"    unknown_fields());\n");
										printer->Outdent();
										printer->Print("}\n");
									}

									// We update _cached_size_ even though this is a const method.  In theory,
									// this is not thread-compatible, because concurrent writes have undefined
									// results.  In practice, since any concurrent writes will be writing the
									// exact same value, it works on all common processors.  In a future version
									// of C++, _cached_size_ should be made into an atomic<int>.
									printer->Print(
										"GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();\n"
										"_cached_size_ = total_size;\n"
										"GOOGLE_SAFE_CONCURRENT_WRITES_END();\n"
										"return total_size;\n");

									printer->Outdent();
									printer->Print("}\n");
							}

							void MessageGenerator::
								GenerateIsInitialized(io::Printer* printer) {
									printer->Print(
										"bool $classname$::IsInitialized() const {\n",
										"classname", classname_);
									printer->Indent();

									// Check that all required fields in this message are set.  We can do this
									// most efficiently by checking 32 "has bits" at a time.
									int has_bits_array_size = (descriptor_->field_count() + 31) / 32;
									for (int i = 0; i < has_bits_array_size; i++) {
										uint32 mask = 0;
										for (int bit = 0; bit < 32; bit++) {
											int index = i * 32 + bit;
											if (index >= descriptor_->field_count()) break;
											const FieldDescriptor* field = descriptor_->field(index);

											if (field->is_required()) {
												mask |= 1 << bit;
											}
										}

										if (mask != 0) {
											char buffer[kFastToBufferSize];
											printer->Print(
												"if ((_has_bits_[$i$] & 0x$mask$) != 0x$mask$) return false;\n",
												"i", SimpleItoa(i),
												"mask", FastHex32ToBuffer(mask, buffer));
										}
									}

									// Now check that all embedded messages are initialized.
									printer->Print("\n");
									for (int i = 0; i < descriptor_->field_count(); i++) {
										const FieldDescriptor* field = descriptor_->field(i);
										if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
											!ShouldIgnoreRequiredFieldCheck(field) &&
											HasRequiredFields(field->message_type())) {
												if (field->is_repeated()) {
													printer->Print(
														"for (int i = 0; i < $name$_size(); i++) {\n"
														"  if (!this->$name$(i).IsInitialized()) return false;\n"
														"}\n",
														"name", FieldName(field));
												} else {
													printer->Print(
														"if (has_$name$()) {\n"
														"  if (!this->$name$().IsInitialized()) return false;\n"
														"}\n",
														"name", FieldName(field));
												}
										}
									}

									if (descriptor_->extension_range_count() > 0) {
										printer->Print(
											"\n"
											"if (!_extensions_.IsInitialized()) return false;");
									}

									printer->Outdent();
									printer->Print(
										"  return true;\n"
										"}\n");
							}



}}}}