3675 lines
126 KiB
C++
Executable File
3675 lines
126 KiB
C++
Executable File
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
// https://developers.google.com/protocol-buffers/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include <google/protobuf/compiler/js/js_generator.h>
|
|
|
|
#include <assert.h>
|
|
#include <algorithm>
|
|
#include <limits>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <google/protobuf/stubs/logging.h>
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <google/protobuf/stubs/stringprintf.h>
|
|
#include <google/protobuf/compiler/js/well_known_types_embed.h>
|
|
#include <google/protobuf/io/printer.h>
|
|
#include <google/protobuf/io/zero_copy_stream.h>
|
|
#include <google/protobuf/descriptor.pb.h>
|
|
#include <google/protobuf/descriptor.h>
|
|
#include <google/protobuf/stubs/strutil.h>
|
|
|
|
|
|
namespace google {
|
|
namespace protobuf {
|
|
namespace compiler {
|
|
namespace js {
|
|
|
|
// Sorted list of JavaScript keywords. These cannot be used as names. If they
|
|
// appear, we prefix them with "pb_".
|
|
const char* kKeyword[] = {
|
|
"abstract",
|
|
"boolean",
|
|
"break",
|
|
"byte",
|
|
"case",
|
|
"catch",
|
|
"char",
|
|
"class",
|
|
"const",
|
|
"continue",
|
|
"debugger",
|
|
"default",
|
|
"delete",
|
|
"do",
|
|
"double",
|
|
"else",
|
|
"enum",
|
|
"export",
|
|
"extends",
|
|
"false",
|
|
"final",
|
|
"finally",
|
|
"float",
|
|
"for",
|
|
"function",
|
|
"goto",
|
|
"if",
|
|
"implements",
|
|
"import",
|
|
"in",
|
|
"instanceof",
|
|
"int",
|
|
"interface",
|
|
"long",
|
|
"native",
|
|
"new",
|
|
"null",
|
|
"package",
|
|
"private",
|
|
"protected",
|
|
"public",
|
|
"return",
|
|
"short",
|
|
"static",
|
|
"super",
|
|
"switch",
|
|
"synchronized",
|
|
"this",
|
|
"throw",
|
|
"throws",
|
|
"transient",
|
|
"try",
|
|
"typeof",
|
|
"var",
|
|
"void",
|
|
"volatile",
|
|
"while",
|
|
"with",
|
|
};
|
|
|
|
static const int kNumKeyword = sizeof(kKeyword) / sizeof(char*);
|
|
|
|
namespace {
|
|
|
|
// The mode of operation for bytes fields. Historically JSPB always carried
|
|
// bytes as JS {string}, containing base64 content by convention. With binary
|
|
// and proto3 serialization the new convention is to represent it as binary
|
|
// data in Uint8Array. See b/26173701 for background on the migration.
|
|
enum BytesMode {
|
|
BYTES_DEFAULT, // Default type for getBytesField to return.
|
|
BYTES_B64, // Explicitly coerce to base64 string where needed.
|
|
BYTES_U8, // Explicitly coerce to Uint8Array where needed.
|
|
};
|
|
|
|
bool IsReserved(const string& ident) {
|
|
for (int i = 0; i < kNumKeyword; i++) {
|
|
if (ident == kKeyword[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool StrEndsWith(StringPiece sp, StringPiece x) {
|
|
return sp.size() >= x.size() && sp.substr(sp.size() - x.size()) == x;
|
|
}
|
|
|
|
// Returns a copy of |filename| with any trailing ".protodevel" or ".proto
|
|
// suffix stripped.
|
|
// TODO(haberman): Unify with copy in compiler/cpp/internal/helpers.cc.
|
|
string StripProto(const string& filename) {
|
|
const char* suffix =
|
|
StrEndsWith(filename, ".protodevel") ? ".protodevel" : ".proto";
|
|
return StripSuffixString(filename, suffix);
|
|
}
|
|
|
|
// Given a filename like foo/bar/baz.proto, returns the corresponding JavaScript
|
|
// file foo/bar/baz.js.
|
|
string GetJSFilename(const GeneratorOptions& options, const string& filename) {
|
|
return StripProto(filename) + options.GetFileNameExtension();
|
|
}
|
|
|
|
// Given a filename like foo/bar/baz.proto, returns the root directory
|
|
// path ../../
|
|
string GetRootPath(const string& from_filename, const string& to_filename) {
|
|
if (to_filename.find("google/protobuf") == 0) {
|
|
// Well-known types (.proto files in the google/protobuf directory) are
|
|
// assumed to come from the 'google-protobuf' npm package. We may want to
|
|
// generalize this exception later by letting others put generated code in
|
|
// their own npm packages.
|
|
return "google-protobuf/";
|
|
}
|
|
|
|
size_t slashes = std::count(from_filename.begin(), from_filename.end(), '/');
|
|
if (slashes == 0) {
|
|
return "./";
|
|
}
|
|
string result = "";
|
|
for (size_t i = 0; i < slashes; i++) {
|
|
result += "../";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Returns the alias we assign to the module of the given .proto filename
|
|
// when importing.
|
|
string ModuleAlias(const string& filename) {
|
|
// This scheme could technically cause problems if a file includes any 2 of:
|
|
// foo/bar_baz.proto
|
|
// foo_bar_baz.proto
|
|
// foo_bar/baz.proto
|
|
//
|
|
// We'll worry about this problem if/when we actually see it. This name isn't
|
|
// exposed to users so we can change it later if we need to.
|
|
string basename = StripProto(filename);
|
|
ReplaceCharacters(&basename, "-", '$');
|
|
ReplaceCharacters(&basename, "/", '_');
|
|
ReplaceCharacters(&basename, ".", '_');
|
|
return basename + "_pb";
|
|
}
|
|
|
|
// Returns the fully normalized JavaScript path for the given
|
|
// file descriptor's package.
|
|
string GetFilePath(const GeneratorOptions& options,
|
|
const FileDescriptor* file) {
|
|
if (!options.namespace_prefix.empty()) {
|
|
return options.namespace_prefix;
|
|
} else if (!file->package().empty()) {
|
|
return "proto." + file->package();
|
|
} else {
|
|
return "proto";
|
|
}
|
|
}
|
|
|
|
// Returns the name of the message with a leading dot and taking into account
|
|
// nesting, for example ".OuterMessage.InnerMessage", or returns empty if
|
|
// descriptor is null. This function does not handle namespacing, only message
|
|
// nesting.
|
|
string GetNestedMessageName(const Descriptor* descriptor) {
|
|
if (descriptor == NULL) {
|
|
return "";
|
|
}
|
|
string result =
|
|
StripPrefixString(descriptor->full_name(), descriptor->file()->package());
|
|
// Add a leading dot if one is not already present.
|
|
if (!result.empty() && result[0] != '.') {
|
|
result = "." + result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Returns the path prefix for a message or enumeration that
|
|
// lives under the given file and containing type.
|
|
string GetPrefix(const GeneratorOptions& options,
|
|
const FileDescriptor* file_descriptor,
|
|
const Descriptor* containing_type) {
|
|
string prefix = GetFilePath(options, file_descriptor) +
|
|
GetNestedMessageName(containing_type);
|
|
if (!prefix.empty()) {
|
|
prefix += ".";
|
|
}
|
|
return prefix;
|
|
}
|
|
|
|
// Returns the fully normalized JavaScript path prefix for the given
|
|
// message descriptor.
|
|
string GetMessagePathPrefix(const GeneratorOptions& options,
|
|
const Descriptor* descriptor) {
|
|
return GetPrefix(
|
|
options, descriptor->file(),
|
|
descriptor->containing_type());
|
|
}
|
|
|
|
// Returns the fully normalized JavaScript path for the given
|
|
// message descriptor.
|
|
string GetMessagePath(const GeneratorOptions& options,
|
|
const Descriptor* descriptor) {
|
|
return GetMessagePathPrefix(options, descriptor) + descriptor->name();
|
|
}
|
|
|
|
// Returns the fully normalized JavaScript path prefix for the given
|
|
// enumeration descriptor.
|
|
string GetEnumPathPrefix(const GeneratorOptions& options,
|
|
const EnumDescriptor* enum_descriptor) {
|
|
return GetPrefix(options, enum_descriptor->file(),
|
|
enum_descriptor->containing_type());
|
|
}
|
|
|
|
// Returns the fully normalized JavaScript path for the given
|
|
// enumeration descriptor.
|
|
string GetEnumPath(const GeneratorOptions& options,
|
|
const EnumDescriptor* enum_descriptor) {
|
|
return GetEnumPathPrefix(options, enum_descriptor) + enum_descriptor->name();
|
|
}
|
|
|
|
string MaybeCrossFileRef(const GeneratorOptions& options,
|
|
const FileDescriptor* from_file,
|
|
const Descriptor* to_message) {
|
|
if (options.import_style == GeneratorOptions::kImportCommonJs &&
|
|
from_file != to_message->file()) {
|
|
// Cross-file ref in CommonJS needs to use the module alias instead of
|
|
// the global name.
|
|
return ModuleAlias(to_message->file()->name()) +
|
|
GetNestedMessageName(to_message->containing_type()) + "." +
|
|
to_message->name();
|
|
} else {
|
|
// Within a single file we use a full name.
|
|
return GetMessagePath(options, to_message);
|
|
}
|
|
}
|
|
|
|
string SubmessageTypeRef(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
GOOGLE_CHECK(field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE);
|
|
return MaybeCrossFileRef(options, field->file(), field->message_type());
|
|
}
|
|
|
|
// - Object field name: LOWER_UNDERSCORE -> LOWER_CAMEL, except for group fields
|
|
// (UPPER_CAMEL -> LOWER_CAMEL), with "List" (or "Map") appended if appropriate,
|
|
// and with reserved words triggering a "pb_" prefix.
|
|
// - Getters/setters: LOWER_UNDERSCORE -> UPPER_CAMEL, except for group fields
|
|
// (use the name directly), then append "List" if appropriate, then append "$"
|
|
// if resulting name is equal to a reserved word.
|
|
// - Enums: just uppercase.
|
|
|
|
// Locale-independent version of ToLower that deals only with ASCII A-Z.
|
|
char ToLowerASCII(char c) {
|
|
if (c >= 'A' && c <= 'Z') {
|
|
return (c - 'A') + 'a';
|
|
} else {
|
|
return c;
|
|
}
|
|
}
|
|
|
|
std::vector<string> ParseLowerUnderscore(const string& input) {
|
|
std::vector<string> words;
|
|
string running = "";
|
|
for (int i = 0; i < input.size(); i++) {
|
|
if (input[i] == '_') {
|
|
if (!running.empty()) {
|
|
words.push_back(running);
|
|
running.clear();
|
|
}
|
|
} else {
|
|
running += ToLowerASCII(input[i]);
|
|
}
|
|
}
|
|
if (!running.empty()) {
|
|
words.push_back(running);
|
|
}
|
|
return words;
|
|
}
|
|
|
|
std::vector<string> ParseUpperCamel(const string& input) {
|
|
std::vector<string> words;
|
|
string running = "";
|
|
for (int i = 0; i < input.size(); i++) {
|
|
if (input[i] >= 'A' && input[i] <= 'Z' && !running.empty()) {
|
|
words.push_back(running);
|
|
running.clear();
|
|
}
|
|
running += ToLowerASCII(input[i]);
|
|
}
|
|
if (!running.empty()) {
|
|
words.push_back(running);
|
|
}
|
|
return words;
|
|
}
|
|
|
|
string ToLowerCamel(const std::vector<string>& words) {
|
|
string result;
|
|
for (int i = 0; i < words.size(); i++) {
|
|
string word = words[i];
|
|
if (i == 0 && (word[0] >= 'A' && word[0] <= 'Z')) {
|
|
word[0] = (word[0] - 'A') + 'a';
|
|
} else if (i != 0 && (word[0] >= 'a' && word[0] <= 'z')) {
|
|
word[0] = (word[0] - 'a') + 'A';
|
|
}
|
|
result += word;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
string ToUpperCamel(const std::vector<string>& words) {
|
|
string result;
|
|
for (int i = 0; i < words.size(); i++) {
|
|
string word = words[i];
|
|
if (word[0] >= 'a' && word[0] <= 'z') {
|
|
word[0] = (word[0] - 'a') + 'A';
|
|
}
|
|
result += word;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Based on code from descriptor.cc (Thanks Kenton!)
|
|
// Uppercases the entire string, turning ValueName into
|
|
// VALUENAME.
|
|
string ToEnumCase(const string& input) {
|
|
string result;
|
|
result.reserve(input.size());
|
|
|
|
for (int i = 0; i < input.size(); i++) {
|
|
if ('a' <= input[i] && input[i] <= 'z') {
|
|
result.push_back(input[i] - 'a' + 'A');
|
|
} else {
|
|
result.push_back(input[i]);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
string ToFileName(const string& input) {
|
|
string result;
|
|
result.reserve(input.size());
|
|
|
|
for (int i = 0; i < input.size(); i++) {
|
|
if ('A' <= input[i] && input[i] <= 'Z') {
|
|
result.push_back(input[i] - 'A' + 'a');
|
|
} else {
|
|
result.push_back(input[i]);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// When we're generating one output file per type name, this is the filename
|
|
// that top-level extensions should go in.
|
|
string GetExtensionFileName(const GeneratorOptions& options,
|
|
const FileDescriptor* file) {
|
|
return options.output_dir + "/" + ToFileName(GetFilePath(options, file)) +
|
|
options.GetFileNameExtension();
|
|
}
|
|
|
|
// When we're generating one output file per type name, this is the filename
|
|
// that a top-level message should go in.
|
|
string GetMessageFileName(const GeneratorOptions& options,
|
|
const Descriptor* desc) {
|
|
return options.output_dir + "/" + ToFileName(desc->name()) +
|
|
options.GetFileNameExtension();
|
|
}
|
|
|
|
// When we're generating one output file per type name, this is the filename
|
|
// that a top-level message should go in.
|
|
string GetEnumFileName(const GeneratorOptions& options,
|
|
const EnumDescriptor* desc) {
|
|
return options.output_dir + "/" + ToFileName(desc->name()) +
|
|
options.GetFileNameExtension();
|
|
}
|
|
|
|
// Returns the message/response ID, if set.
|
|
string GetMessageId(const Descriptor* desc) {
|
|
return string();
|
|
}
|
|
|
|
bool IgnoreExtensionField(const FieldDescriptor* field) {
|
|
// Exclude descriptor extensions from output "to avoid clutter" (from original
|
|
// codegen).
|
|
return field->is_extension() &&
|
|
field->containing_type()->file()->name() ==
|
|
"google/protobuf/descriptor.proto";
|
|
}
|
|
|
|
|
|
// Used inside Google only -- do not remove.
|
|
bool IsResponse(const Descriptor* desc) { return false; }
|
|
|
|
bool IgnoreField(const FieldDescriptor* field) {
|
|
return IgnoreExtensionField(field);
|
|
}
|
|
|
|
|
|
// Used inside Google only -- do not remove.
|
|
bool ShouldTreatMapsAsRepeatedFields(const FileDescriptor& descriptor) {
|
|
return false;
|
|
}
|
|
|
|
// Do we ignore this message type?
|
|
bool IgnoreMessage(const GeneratorOptions& options, const Descriptor* d) {
|
|
return d->options().map_entry() &&
|
|
!ShouldTreatMapsAsRepeatedFields(*d->file());
|
|
}
|
|
|
|
bool IsMap(const GeneratorOptions& options, const FieldDescriptor* field) {
|
|
return field->is_map() && !ShouldTreatMapsAsRepeatedFields(*field->file());
|
|
}
|
|
|
|
// Does JSPB ignore this entire oneof? True only if all fields are ignored.
|
|
bool IgnoreOneof(const OneofDescriptor* oneof) {
|
|
for (int i = 0; i < oneof->field_count(); i++) {
|
|
if (!IgnoreField(oneof->field(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
string JSIdent(const GeneratorOptions& options, const FieldDescriptor* field,
|
|
bool is_upper_camel, bool is_map, bool drop_list) {
|
|
string result;
|
|
if (field->type() == FieldDescriptor::TYPE_GROUP) {
|
|
result = is_upper_camel ?
|
|
ToUpperCamel(ParseUpperCamel(field->message_type()->name())) :
|
|
ToLowerCamel(ParseUpperCamel(field->message_type()->name()));
|
|
} else {
|
|
result = is_upper_camel ?
|
|
ToUpperCamel(ParseLowerUnderscore(field->name())) :
|
|
ToLowerCamel(ParseLowerUnderscore(field->name()));
|
|
}
|
|
if (is_map || IsMap(options, field)) {
|
|
// JSPB-style or proto3-style map.
|
|
result += "Map";
|
|
} else if (!drop_list && field->is_repeated()) {
|
|
// Repeated field.
|
|
result += "List";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
string JSObjectFieldName(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
string name = JSIdent(options, field,
|
|
/* is_upper_camel = */ false,
|
|
/* is_map = */ false,
|
|
/* drop_list = */ false);
|
|
if (IsReserved(name)) {
|
|
name = "pb_" + name;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
string JSByteGetterSuffix(BytesMode bytes_mode) {
|
|
switch (bytes_mode) {
|
|
case BYTES_DEFAULT:
|
|
return "";
|
|
case BYTES_B64:
|
|
return "B64";
|
|
case BYTES_U8:
|
|
return "U8";
|
|
default:
|
|
assert(false);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
// Returns the field name as a capitalized portion of a getter/setter method
|
|
// name, e.g. MyField for .getMyField().
|
|
string JSGetterName(const GeneratorOptions& options,
|
|
const FieldDescriptor* field,
|
|
BytesMode bytes_mode = BYTES_DEFAULT,
|
|
bool drop_list = false) {
|
|
string name = JSIdent(options, field,
|
|
/* is_upper_camel = */ true,
|
|
/* is_map = */ false, drop_list);
|
|
if (field->type() == FieldDescriptor::TYPE_BYTES) {
|
|
string suffix = JSByteGetterSuffix(bytes_mode);
|
|
if (!suffix.empty()) {
|
|
name += "_as" + suffix;
|
|
}
|
|
}
|
|
if (name == "Extension" || name == "JsPbMessageId") {
|
|
// Avoid conflicts with base-class names.
|
|
name += "$";
|
|
}
|
|
return name;
|
|
}
|
|
|
|
|
|
|
|
string JSOneofName(const OneofDescriptor* oneof) {
|
|
return ToUpperCamel(ParseLowerUnderscore(oneof->name()));
|
|
}
|
|
|
|
// Returns the index corresponding to this field in the JSPB array (underlying
|
|
// data storage array).
|
|
string JSFieldIndex(const FieldDescriptor* field) {
|
|
// Determine whether this field is a member of a group. Group fields are a bit
|
|
// wonky: their "containing type" is a message type created just for the
|
|
// group, and that type's parent type has a field with the group-message type
|
|
// as its message type and TYPE_GROUP as its field type. For such fields, the
|
|
// index we use is relative to the field number of the group submessage field.
|
|
// For all other fields, we just use the field number.
|
|
const Descriptor* containing_type = field->containing_type();
|
|
const Descriptor* parent_type = containing_type->containing_type();
|
|
if (parent_type != NULL) {
|
|
for (int i = 0; i < parent_type->field_count(); i++) {
|
|
if (parent_type->field(i)->type() == FieldDescriptor::TYPE_GROUP &&
|
|
parent_type->field(i)->message_type() == containing_type) {
|
|
return SimpleItoa(field->number() - parent_type->field(i)->number());
|
|
}
|
|
}
|
|
}
|
|
return SimpleItoa(field->number());
|
|
}
|
|
|
|
string JSOneofIndex(const OneofDescriptor* oneof) {
|
|
int index = -1;
|
|
for (int i = 0; i < oneof->containing_type()->oneof_decl_count(); i++) {
|
|
const OneofDescriptor* o = oneof->containing_type()->oneof_decl(i);
|
|
// If at least one field in this oneof is not JSPB-ignored, count the oneof.
|
|
for (int j = 0; j < o->field_count(); j++) {
|
|
const FieldDescriptor* f = o->field(j);
|
|
if (!IgnoreField(f)) {
|
|
index++;
|
|
break; // inner loop
|
|
}
|
|
}
|
|
if (o == oneof) {
|
|
break;
|
|
}
|
|
}
|
|
return SimpleItoa(index);
|
|
}
|
|
|
|
// Decodes a codepoint in \x0000 -- \xFFFF.
|
|
uint16 DecodeUTF8Codepoint(uint8* bytes, size_t* length) {
|
|
if (*length == 0) {
|
|
return 0;
|
|
}
|
|
size_t expected = 0;
|
|
if ((*bytes & 0x80) == 0) {
|
|
expected = 1;
|
|
} else if ((*bytes & 0xe0) == 0xc0) {
|
|
expected = 2;
|
|
} else if ((*bytes & 0xf0) == 0xe0) {
|
|
expected = 3;
|
|
} else {
|
|
// Too long -- don't accept.
|
|
*length = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (*length < expected) {
|
|
// Not enough bytes -- don't accept.
|
|
*length = 0;
|
|
return 0;
|
|
}
|
|
|
|
*length = expected;
|
|
switch (expected) {
|
|
case 1: return bytes[0];
|
|
case 2: return ((bytes[0] & 0x1F) << 6) |
|
|
((bytes[1] & 0x3F) << 0);
|
|
case 3: return ((bytes[0] & 0x0F) << 12) |
|
|
((bytes[1] & 0x3F) << 6) |
|
|
((bytes[2] & 0x3F) << 0);
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
// Escapes the contents of a string to be included within double-quotes ("") in
|
|
// JavaScript. The input data should be a UTF-8 encoded C++ string of chars.
|
|
// Returns false if |out| was truncated because |in| contained invalid UTF-8 or
|
|
// codepoints outside the BMP.
|
|
// TODO(lukestebbing): Support codepoints outside the BMP.
|
|
bool EscapeJSString(const string& in, string* out) {
|
|
size_t decoded = 0;
|
|
for (size_t i = 0; i < in.size(); i += decoded) {
|
|
uint16 codepoint = 0;
|
|
// Decode the next UTF-8 codepoint.
|
|
size_t have_bytes = in.size() - i;
|
|
uint8 bytes[3] = {
|
|
static_cast<uint8>(in[i]),
|
|
static_cast<uint8>(((i + 1) < in.size()) ? in[i + 1] : 0),
|
|
static_cast<uint8>(((i + 2) < in.size()) ? in[i + 2] : 0),
|
|
};
|
|
codepoint = DecodeUTF8Codepoint(bytes, &have_bytes);
|
|
if (have_bytes == 0) {
|
|
return false;
|
|
}
|
|
decoded = have_bytes;
|
|
|
|
switch (codepoint) {
|
|
case '\'': *out += "\\x27"; break;
|
|
case '"': *out += "\\x22"; break;
|
|
case '<': *out += "\\x3c"; break;
|
|
case '=': *out += "\\x3d"; break;
|
|
case '>': *out += "\\x3e"; break;
|
|
case '&': *out += "\\x26"; break;
|
|
case '\b': *out += "\\b"; break;
|
|
case '\t': *out += "\\t"; break;
|
|
case '\n': *out += "\\n"; break;
|
|
case '\f': *out += "\\f"; break;
|
|
case '\r': *out += "\\r"; break;
|
|
case '\\': *out += "\\\\"; break;
|
|
default:
|
|
// TODO(lukestebbing): Once we're supporting codepoints outside the BMP,
|
|
// use a single Unicode codepoint escape if the output language is
|
|
// ECMAScript 2015 or above. Otherwise, use a surrogate pair.
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals
|
|
if (codepoint >= 0x20 && codepoint <= 0x7e) {
|
|
*out += static_cast<char>(codepoint);
|
|
} else if (codepoint >= 0x100) {
|
|
*out += StringPrintf("\\u%04x", codepoint);
|
|
} else {
|
|
*out += StringPrintf("\\x%02x", codepoint);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
string EscapeBase64(const string& in) {
|
|
static const char* kAlphabet =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
string result;
|
|
|
|
for (size_t i = 0; i < in.size(); i += 3) {
|
|
int value = (in[i] << 16) |
|
|
(((i + 1) < in.size()) ? (in[i + 1] << 8) : 0) |
|
|
(((i + 2) < in.size()) ? (in[i + 2] << 0) : 0);
|
|
result += kAlphabet[(value >> 18) & 0x3f];
|
|
result += kAlphabet[(value >> 12) & 0x3f];
|
|
if ((i + 1) < in.size()) {
|
|
result += kAlphabet[(value >> 6) & 0x3f];
|
|
} else {
|
|
result += '=';
|
|
}
|
|
if ((i + 2) < in.size()) {
|
|
result += kAlphabet[(value >> 0) & 0x3f];
|
|
} else {
|
|
result += '=';
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Post-process the result of SimpleFtoa/SimpleDtoa to *exactly* match the
|
|
// original codegen's formatting (which is just .toString() on java.lang.Double
|
|
// or java.lang.Float).
|
|
string PostProcessFloat(string result) {
|
|
// If inf, -inf or nan, replace with +Infinity, -Infinity or NaN.
|
|
if (result == "inf") {
|
|
return "Infinity";
|
|
} else if (result == "-inf") {
|
|
return "-Infinity";
|
|
} else if (result == "nan") {
|
|
return "NaN";
|
|
}
|
|
|
|
// If scientific notation (e.g., "1e10"), (i) capitalize the "e", (ii)
|
|
// ensure that the mantissa (portion prior to the "e") has at least one
|
|
// fractional digit (after the decimal point), and (iii) strip any unnecessary
|
|
// leading zeroes and/or '+' signs from the exponent.
|
|
string::size_type exp_pos = result.find('e');
|
|
if (exp_pos != string::npos) {
|
|
string mantissa = result.substr(0, exp_pos);
|
|
string exponent = result.substr(exp_pos + 1);
|
|
|
|
// Add ".0" to mantissa if no fractional part exists.
|
|
if (mantissa.find('.') == string::npos) {
|
|
mantissa += ".0";
|
|
}
|
|
|
|
// Strip the sign off the exponent and store as |exp_neg|.
|
|
bool exp_neg = false;
|
|
if (!exponent.empty() && exponent[0] == '+') {
|
|
exponent = exponent.substr(1);
|
|
} else if (!exponent.empty() && exponent[0] == '-') {
|
|
exp_neg = true;
|
|
exponent = exponent.substr(1);
|
|
}
|
|
|
|
// Strip any leading zeroes off the exponent.
|
|
while (exponent.size() > 1 && exponent[0] == '0') {
|
|
exponent = exponent.substr(1);
|
|
}
|
|
|
|
return mantissa + "E" + string(exp_neg ? "-" : "") + exponent;
|
|
}
|
|
|
|
// Otherwise, this is an ordinary decimal number. Append ".0" if result has no
|
|
// decimal/fractional part in order to match output of original codegen.
|
|
if (result.find('.') == string::npos) {
|
|
result += ".0";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
string FloatToString(float value) {
|
|
string result = SimpleFtoa(value);
|
|
return PostProcessFloat(result);
|
|
}
|
|
|
|
string DoubleToString(double value) {
|
|
string result = SimpleDtoa(value);
|
|
return PostProcessFloat(result);
|
|
}
|
|
|
|
// Return true if this is an integral field that should be represented as string
|
|
// in JS.
|
|
bool IsIntegralFieldWithStringJSType(const FieldDescriptor* field) {
|
|
switch (field->cpp_type()) {
|
|
case FieldDescriptor::CPPTYPE_INT64:
|
|
case FieldDescriptor::CPPTYPE_UINT64:
|
|
// The default value of JSType is JS_NORMAL, which behaves the same as
|
|
// JS_NUMBER.
|
|
return field->options().jstype() == google::protobuf::FieldOptions::JS_STRING;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
string MaybeNumberString(const FieldDescriptor* field, const string& orig) {
|
|
return IsIntegralFieldWithStringJSType(field) ? ("\"" + orig + "\"") : orig;
|
|
}
|
|
|
|
string JSFieldDefault(const FieldDescriptor* field) {
|
|
if (field->is_repeated()) {
|
|
return "[]";
|
|
}
|
|
|
|
switch (field->cpp_type()) {
|
|
case FieldDescriptor::CPPTYPE_INT32:
|
|
return MaybeNumberString(
|
|
field, SimpleItoa(field->default_value_int32()));
|
|
case FieldDescriptor::CPPTYPE_UINT32:
|
|
// The original codegen is in Java, and Java protobufs store unsigned
|
|
// integer values as signed integer values. In order to exactly match the
|
|
// output, we need to reinterpret as base-2 signed. Ugh.
|
|
return MaybeNumberString(
|
|
field, SimpleItoa(static_cast<int32>(field->default_value_uint32())));
|
|
case FieldDescriptor::CPPTYPE_INT64:
|
|
return MaybeNumberString(
|
|
field, SimpleItoa(field->default_value_int64()));
|
|
case FieldDescriptor::CPPTYPE_UINT64:
|
|
// See above note for uint32 -- reinterpreting as signed.
|
|
return MaybeNumberString(
|
|
field, SimpleItoa(static_cast<int64>(field->default_value_uint64())));
|
|
case FieldDescriptor::CPPTYPE_ENUM:
|
|
return SimpleItoa(field->default_value_enum()->number());
|
|
case FieldDescriptor::CPPTYPE_BOOL:
|
|
return field->default_value_bool() ? "true" : "false";
|
|
case FieldDescriptor::CPPTYPE_FLOAT:
|
|
return FloatToString(field->default_value_float());
|
|
case FieldDescriptor::CPPTYPE_DOUBLE:
|
|
return DoubleToString(field->default_value_double());
|
|
case FieldDescriptor::CPPTYPE_STRING:
|
|
if (field->type() == FieldDescriptor::TYPE_STRING) {
|
|
string out;
|
|
bool is_valid = EscapeJSString(field->default_value_string(), &out);
|
|
if (!is_valid) {
|
|
// TODO(lukestebbing): Decide whether this should be a hard error.
|
|
GOOGLE_LOG(WARNING) << "The default value for field " << field->full_name()
|
|
<< " was truncated since it contained invalid UTF-8 or"
|
|
" codepoints outside the basic multilingual plane.";
|
|
}
|
|
return "\"" + out + "\"";
|
|
} else { // Bytes
|
|
return "\"" + EscapeBase64(field->default_value_string()) + "\"";
|
|
}
|
|
case FieldDescriptor::CPPTYPE_MESSAGE:
|
|
return "null";
|
|
}
|
|
GOOGLE_LOG(FATAL) << "Shouldn't reach here.";
|
|
return "";
|
|
}
|
|
|
|
string ProtoTypeName(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
switch (field->type()) {
|
|
case FieldDescriptor::TYPE_BOOL:
|
|
return "bool";
|
|
case FieldDescriptor::TYPE_INT32:
|
|
return "int32";
|
|
case FieldDescriptor::TYPE_UINT32:
|
|
return "uint32";
|
|
case FieldDescriptor::TYPE_SINT32:
|
|
return "sint32";
|
|
case FieldDescriptor::TYPE_FIXED32:
|
|
return "fixed32";
|
|
case FieldDescriptor::TYPE_SFIXED32:
|
|
return "sfixed32";
|
|
case FieldDescriptor::TYPE_INT64:
|
|
return "int64";
|
|
case FieldDescriptor::TYPE_UINT64:
|
|
return "uint64";
|
|
case FieldDescriptor::TYPE_SINT64:
|
|
return "sint64";
|
|
case FieldDescriptor::TYPE_FIXED64:
|
|
return "fixed64";
|
|
case FieldDescriptor::TYPE_SFIXED64:
|
|
return "sfixed64";
|
|
case FieldDescriptor::TYPE_FLOAT:
|
|
return "float";
|
|
case FieldDescriptor::TYPE_DOUBLE:
|
|
return "double";
|
|
case FieldDescriptor::TYPE_STRING:
|
|
return "string";
|
|
case FieldDescriptor::TYPE_BYTES:
|
|
return "bytes";
|
|
case FieldDescriptor::TYPE_GROUP:
|
|
return GetMessagePath(options, field->message_type());
|
|
case FieldDescriptor::TYPE_ENUM:
|
|
return GetEnumPath(options, field->enum_type());
|
|
case FieldDescriptor::TYPE_MESSAGE:
|
|
return GetMessagePath(options, field->message_type());
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
string JSIntegerTypeName(const FieldDescriptor* field) {
|
|
return IsIntegralFieldWithStringJSType(field) ? "string" : "number";
|
|
}
|
|
|
|
string JSStringTypeName(const GeneratorOptions& options,
|
|
const FieldDescriptor* field,
|
|
BytesMode bytes_mode) {
|
|
if (field->type() == FieldDescriptor::TYPE_BYTES) {
|
|
switch (bytes_mode) {
|
|
case BYTES_DEFAULT:
|
|
return "(string|Uint8Array)";
|
|
case BYTES_B64:
|
|
return "string";
|
|
case BYTES_U8:
|
|
return "Uint8Array";
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
return "string";
|
|
}
|
|
|
|
string JSTypeName(const GeneratorOptions& options,
|
|
const FieldDescriptor* field,
|
|
BytesMode bytes_mode) {
|
|
switch (field->cpp_type()) {
|
|
case FieldDescriptor::CPPTYPE_BOOL:
|
|
return "boolean";
|
|
case FieldDescriptor::CPPTYPE_INT32:
|
|
return JSIntegerTypeName(field);
|
|
case FieldDescriptor::CPPTYPE_INT64:
|
|
return JSIntegerTypeName(field);
|
|
case FieldDescriptor::CPPTYPE_UINT32:
|
|
return JSIntegerTypeName(field);
|
|
case FieldDescriptor::CPPTYPE_UINT64:
|
|
return JSIntegerTypeName(field);
|
|
case FieldDescriptor::CPPTYPE_FLOAT:
|
|
return "number";
|
|
case FieldDescriptor::CPPTYPE_DOUBLE:
|
|
return "number";
|
|
case FieldDescriptor::CPPTYPE_STRING:
|
|
return JSStringTypeName(options, field, bytes_mode);
|
|
case FieldDescriptor::CPPTYPE_ENUM:
|
|
return GetEnumPath(options, field->enum_type());
|
|
case FieldDescriptor::CPPTYPE_MESSAGE:
|
|
return GetMessagePath(options, field->message_type());
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// Used inside Google only -- do not remove.
|
|
bool UseBrokenPresenceSemantics(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
return false;
|
|
}
|
|
|
|
// Returns true for fields that return "null" from accessors when they are
|
|
// unset. This should normally only be true for non-repeated submessages, but
|
|
// we have legacy users who relied on old behavior where accessors behaved this
|
|
// way.
|
|
bool ReturnsNullWhenUnset(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
field->is_optional()) {
|
|
return true;
|
|
}
|
|
|
|
// TODO(haberman): remove this case and unconditionally return false.
|
|
return UseBrokenPresenceSemantics(options, field) && !field->is_repeated() &&
|
|
!field->has_default_value();
|
|
}
|
|
|
|
// In a sane world, this would be the same as ReturnsNullWhenUnset(). But in
|
|
// the status quo, some fields declare that they never return null/undefined
|
|
// even though they actually do:
|
|
// * required fields
|
|
// * optional enum fields
|
|
// * proto3 primitive fields.
|
|
bool DeclaredReturnTypeIsNullable(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
if (field->is_required() || field->type() == FieldDescriptor::TYPE_ENUM) {
|
|
return false;
|
|
}
|
|
|
|
if (field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3 &&
|
|
field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
return false;
|
|
}
|
|
|
|
return ReturnsNullWhenUnset(options, field);
|
|
}
|
|
|
|
bool SetterAcceptsUndefined(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
if (ReturnsNullWhenUnset(options, field)) {
|
|
return true;
|
|
}
|
|
|
|
// Broken presence semantics always accepts undefined for setters.
|
|
return UseBrokenPresenceSemantics(options, field);
|
|
}
|
|
|
|
bool SetterAcceptsNull(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
if (ReturnsNullWhenUnset(options, field)) {
|
|
return true;
|
|
}
|
|
|
|
// With broken presence semantics, fields with defaults accept "null" for
|
|
// setters, but other fields do not. This is a strange quirk of the old
|
|
// codegen.
|
|
return UseBrokenPresenceSemantics(options, field) &&
|
|
field->has_default_value();
|
|
}
|
|
|
|
// Returns types which are known to by non-nullable by default.
|
|
// The style guide requires that we omit "!" in this case.
|
|
bool IsPrimitive(const string& type) {
|
|
return type == "undefined" || type == "string" || type == "number" ||
|
|
type == "boolean";
|
|
}
|
|
|
|
string JSFieldTypeAnnotation(const GeneratorOptions& options,
|
|
const FieldDescriptor* field,
|
|
bool is_setter_argument,
|
|
bool force_present,
|
|
bool singular_if_not_packed,
|
|
BytesMode bytes_mode = BYTES_DEFAULT) {
|
|
GOOGLE_CHECK(!(is_setter_argument && force_present));
|
|
string jstype = JSTypeName(options, field, bytes_mode);
|
|
|
|
if (field->is_repeated() &&
|
|
(field->is_packed() || !singular_if_not_packed)) {
|
|
if (field->type() == FieldDescriptor::TYPE_BYTES &&
|
|
bytes_mode == BYTES_DEFAULT) {
|
|
jstype = "(Array<!Uint8Array>|Array<string>)";
|
|
} else {
|
|
if (!IsPrimitive(jstype)) {
|
|
jstype = "!" + jstype;
|
|
}
|
|
jstype = "Array<" + jstype + ">";
|
|
}
|
|
}
|
|
|
|
bool is_null_or_undefined = false;
|
|
|
|
if (is_setter_argument) {
|
|
if (SetterAcceptsNull(options, field)) {
|
|
jstype = "?" + jstype;
|
|
is_null_or_undefined = true;
|
|
}
|
|
|
|
if (SetterAcceptsUndefined(options, field)) {
|
|
jstype += "|undefined";
|
|
is_null_or_undefined = true;
|
|
}
|
|
} else if (force_present) {
|
|
// Don't add null or undefined.
|
|
} else {
|
|
if (DeclaredReturnTypeIsNullable(options, field)) {
|
|
jstype = "?" + jstype;
|
|
is_null_or_undefined = true;
|
|
}
|
|
}
|
|
|
|
if (!is_null_or_undefined && !IsPrimitive(jstype)) {
|
|
jstype = "!" + jstype;
|
|
}
|
|
|
|
return jstype;
|
|
}
|
|
|
|
string JSBinaryReaderMethodType(const FieldDescriptor* field) {
|
|
string name = field->type_name();
|
|
if (name[0] >= 'a' && name[0] <= 'z') {
|
|
name[0] = (name[0] - 'a') + 'A';
|
|
}
|
|
return IsIntegralFieldWithStringJSType(field) ? (name + "String") : name;
|
|
}
|
|
|
|
string JSBinaryReadWriteMethodName(const FieldDescriptor* field,
|
|
bool is_writer) {
|
|
string name = JSBinaryReaderMethodType(field);
|
|
if (field->is_packed()) {
|
|
name = "Packed" + name;
|
|
} else if (is_writer && field->is_repeated()) {
|
|
name = "Repeated" + name;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
string JSBinaryReaderMethodName(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
return "jspb.BinaryReader.prototype.read" +
|
|
JSBinaryReadWriteMethodName(field, /* is_writer = */ false);
|
|
}
|
|
|
|
string JSBinaryWriterMethodName(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
return "jspb.BinaryWriter.prototype.write" +
|
|
JSBinaryReadWriteMethodName(field, /* is_writer = */ true);
|
|
}
|
|
|
|
string JSReturnClause(const FieldDescriptor* desc) {
|
|
return "";
|
|
}
|
|
|
|
string JSTypeTag(const FieldDescriptor* desc) {
|
|
switch (desc->type()) {
|
|
case FieldDescriptor::TYPE_DOUBLE:
|
|
case FieldDescriptor::TYPE_FLOAT:
|
|
return "Float";
|
|
case FieldDescriptor::TYPE_INT32:
|
|
case FieldDescriptor::TYPE_UINT32:
|
|
case FieldDescriptor::TYPE_INT64:
|
|
case FieldDescriptor::TYPE_UINT64:
|
|
case FieldDescriptor::TYPE_FIXED32:
|
|
case FieldDescriptor::TYPE_FIXED64:
|
|
case FieldDescriptor::TYPE_SINT32:
|
|
case FieldDescriptor::TYPE_SINT64:
|
|
case FieldDescriptor::TYPE_SFIXED32:
|
|
case FieldDescriptor::TYPE_SFIXED64:
|
|
if (IsIntegralFieldWithStringJSType(desc)) {
|
|
return "StringInt";
|
|
} else {
|
|
return "Int";
|
|
}
|
|
case FieldDescriptor::TYPE_BOOL:
|
|
return "Boolean";
|
|
case FieldDescriptor::TYPE_STRING:
|
|
return "String";
|
|
case FieldDescriptor::TYPE_BYTES:
|
|
return "Bytes";
|
|
case FieldDescriptor::TYPE_ENUM:
|
|
return "Enum";
|
|
default:
|
|
assert(false);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
string JSReturnDoc(const GeneratorOptions& options,
|
|
const FieldDescriptor* desc) {
|
|
return "";
|
|
}
|
|
|
|
bool HasRepeatedFields(const GeneratorOptions& options,
|
|
const Descriptor* desc) {
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (desc->field(i)->is_repeated() && !IsMap(options, desc->field(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static const char* kRepeatedFieldArrayName = ".repeatedFields_";
|
|
|
|
string RepeatedFieldsArrayName(const GeneratorOptions& options,
|
|
const Descriptor* desc) {
|
|
return HasRepeatedFields(options, desc)
|
|
? (GetMessagePath(options, desc) + kRepeatedFieldArrayName)
|
|
: "null";
|
|
}
|
|
|
|
bool HasOneofFields(const Descriptor* desc) {
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (desc->field(i)->containing_oneof()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static const char* kOneofGroupArrayName = ".oneofGroups_";
|
|
|
|
string OneofFieldsArrayName(const GeneratorOptions& options,
|
|
const Descriptor* desc) {
|
|
return HasOneofFields(desc)
|
|
? (GetMessagePath(options, desc) + kOneofGroupArrayName)
|
|
: "null";
|
|
}
|
|
|
|
string RepeatedFieldNumberList(const GeneratorOptions& options,
|
|
const Descriptor* desc) {
|
|
std::vector<string> numbers;
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (desc->field(i)->is_repeated() && !IsMap(options, desc->field(i))) {
|
|
numbers.push_back(JSFieldIndex(desc->field(i)));
|
|
}
|
|
}
|
|
return "[" + Join(numbers, ",") + "]";
|
|
}
|
|
|
|
string OneofGroupList(const Descriptor* desc) {
|
|
// List of arrays (one per oneof), each of which is a list of field indices
|
|
std::vector<string> oneof_entries;
|
|
for (int i = 0; i < desc->oneof_decl_count(); i++) {
|
|
const OneofDescriptor* oneof = desc->oneof_decl(i);
|
|
if (IgnoreOneof(oneof)) {
|
|
continue;
|
|
}
|
|
|
|
std::vector<string> oneof_fields;
|
|
for (int j = 0; j < oneof->field_count(); j++) {
|
|
if (IgnoreField(oneof->field(j))) {
|
|
continue;
|
|
}
|
|
oneof_fields.push_back(JSFieldIndex(oneof->field(j)));
|
|
}
|
|
oneof_entries.push_back("[" + Join(oneof_fields, ",") + "]");
|
|
}
|
|
return "[" + Join(oneof_entries, ",") + "]";
|
|
}
|
|
|
|
string JSOneofArray(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
return OneofFieldsArrayName(options, field->containing_type()) + "[" +
|
|
JSOneofIndex(field->containing_oneof()) + "]";
|
|
}
|
|
|
|
string RelativeTypeName(const FieldDescriptor* field) {
|
|
assert(field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM ||
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE);
|
|
// For a field with an enum or message type, compute a name relative to the
|
|
// path name of the message type containing this field.
|
|
string package = field->file()->package();
|
|
string containing_type = field->containing_type()->full_name() + ".";
|
|
string type = (field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) ?
|
|
field->enum_type()->full_name() : field->message_type()->full_name();
|
|
|
|
// |prefix| is advanced as we find separators '.' past the common package
|
|
// prefix that yield common prefixes in the containing type's name and this
|
|
// type's name.
|
|
int prefix = 0;
|
|
for (int i = 0; i < type.size() && i < containing_type.size(); i++) {
|
|
if (type[i] != containing_type[i]) {
|
|
break;
|
|
}
|
|
if (type[i] == '.' && i >= package.size()) {
|
|
prefix = i + 1;
|
|
}
|
|
}
|
|
|
|
return type.substr(prefix);
|
|
}
|
|
|
|
string JSExtensionsObjectName(const GeneratorOptions& options,
|
|
const FileDescriptor* from_file,
|
|
const Descriptor* desc) {
|
|
if (desc->full_name() == "google.protobuf.bridge.MessageSet") {
|
|
// TODO(haberman): fix this for the kImportCommonJs case.
|
|
return "jspb.Message.messageSetExtensions";
|
|
} else {
|
|
return MaybeCrossFileRef(options, from_file, desc) + ".extensions";
|
|
}
|
|
}
|
|
|
|
static const int kMapKeyField = 1;
|
|
static const int kMapValueField = 2;
|
|
|
|
const FieldDescriptor* MapFieldKey(const FieldDescriptor* field) {
|
|
assert(field->is_map());
|
|
return field->message_type()->FindFieldByNumber(kMapKeyField);
|
|
}
|
|
|
|
const FieldDescriptor* MapFieldValue(const FieldDescriptor* field) {
|
|
assert(field->is_map());
|
|
return field->message_type()->FindFieldByNumber(kMapValueField);
|
|
}
|
|
|
|
string FieldDefinition(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
if (IsMap(options, field)) {
|
|
const FieldDescriptor* key_field = MapFieldKey(field);
|
|
const FieldDescriptor* value_field = MapFieldValue(field);
|
|
string key_type = ProtoTypeName(options, key_field);
|
|
string value_type;
|
|
if (value_field->type() == FieldDescriptor::TYPE_ENUM ||
|
|
value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
|
|
value_type = RelativeTypeName(value_field);
|
|
} else {
|
|
value_type = ProtoTypeName(options, value_field);
|
|
}
|
|
return StringPrintf("map<%s, %s> %s = %d;",
|
|
key_type.c_str(),
|
|
value_type.c_str(),
|
|
field->name().c_str(),
|
|
field->number());
|
|
} else {
|
|
string qualifier = field->is_repeated() ? "repeated" :
|
|
(field->is_optional() ? "optional" : "required");
|
|
string type, name;
|
|
if (field->type() == FieldDescriptor::TYPE_ENUM ||
|
|
field->type() == FieldDescriptor::TYPE_MESSAGE) {
|
|
type = RelativeTypeName(field);
|
|
name = field->name();
|
|
} else if (field->type() == FieldDescriptor::TYPE_GROUP) {
|
|
type = "group";
|
|
name = field->message_type()->name();
|
|
} else {
|
|
type = ProtoTypeName(options, field);
|
|
name = field->name();
|
|
}
|
|
return StringPrintf("%s %s %s = %d;",
|
|
qualifier.c_str(),
|
|
type.c_str(),
|
|
name.c_str(),
|
|
field->number());
|
|
}
|
|
}
|
|
|
|
string FieldComments(const FieldDescriptor* field, BytesMode bytes_mode) {
|
|
string comments;
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_BOOL) {
|
|
comments +=
|
|
" * Note that Boolean fields may be set to 0/1 when serialized from "
|
|
"a Java server.\n"
|
|
" * You should avoid comparisons like {@code val === true/false} in "
|
|
"those cases.\n";
|
|
}
|
|
if (field->type() == FieldDescriptor::TYPE_BYTES && bytes_mode == BYTES_U8) {
|
|
comments +=
|
|
" * Note that Uint8Array is not supported on all browsers.\n"
|
|
" * @see http://caniuse.com/Uint8Array\n";
|
|
}
|
|
return comments;
|
|
}
|
|
|
|
bool ShouldGenerateExtension(const FieldDescriptor* field) {
|
|
return
|
|
field->is_extension() &&
|
|
!IgnoreField(field);
|
|
}
|
|
|
|
bool HasExtensions(const Descriptor* desc) {
|
|
for (int i = 0; i < desc->extension_count(); i++) {
|
|
if (ShouldGenerateExtension(desc->extension(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
for (int i = 0; i < desc->nested_type_count(); i++) {
|
|
if (HasExtensions(desc->nested_type(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool HasExtensions(const FileDescriptor* file) {
|
|
for (int i = 0; i < file->extension_count(); i++) {
|
|
if (ShouldGenerateExtension(file->extension(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
for (int i = 0; i < file->message_type_count(); i++) {
|
|
if (HasExtensions(file->message_type(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool HasMap(const GeneratorOptions& options, const Descriptor* desc) {
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (IsMap(options, desc->field(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
for (int i = 0; i < desc->nested_type_count(); i++) {
|
|
if (HasMap(options, desc->nested_type(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool FileHasMap(const GeneratorOptions& options, const FileDescriptor* desc) {
|
|
for (int i = 0; i < desc->message_type_count(); i++) {
|
|
if (HasMap(options, desc->message_type(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsExtendable(const Descriptor* desc) {
|
|
return desc->extension_range_count() > 0;
|
|
}
|
|
|
|
// Returns the max index in the underlying data storage array beyond which the
|
|
// extension object is used.
|
|
string GetPivot(const Descriptor* desc) {
|
|
static const int kDefaultPivot = 500;
|
|
|
|
// Find the max field number
|
|
int max_field_number = 0;
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (!IgnoreField(desc->field(i)) &&
|
|
desc->field(i)->number() > max_field_number) {
|
|
max_field_number = desc->field(i)->number();
|
|
}
|
|
}
|
|
|
|
int pivot = -1;
|
|
if (IsExtendable(desc) || (max_field_number >= kDefaultPivot)) {
|
|
pivot = ((max_field_number + 1) < kDefaultPivot) ?
|
|
(max_field_number + 1) : kDefaultPivot;
|
|
}
|
|
|
|
return SimpleItoa(pivot);
|
|
}
|
|
|
|
// Whether this field represents presence. For fields with presence, we
|
|
// generate extra methods (clearFoo() and hasFoo()) for this field.
|
|
bool HasFieldPresence(const GeneratorOptions& options,
|
|
const FieldDescriptor* field) {
|
|
if (field->is_repeated() || field->is_map()) {
|
|
// We say repeated fields and maps don't have presence, but we still do
|
|
// generate clearFoo() methods for them through a special case elsewhere.
|
|
return false;
|
|
}
|
|
|
|
if (UseBrokenPresenceSemantics(options, field)) {
|
|
// Proto3 files with broken presence semantics have field presence.
|
|
return true;
|
|
}
|
|
|
|
return field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ||
|
|
field->containing_oneof() != NULL ||
|
|
field->file()->syntax() == FileDescriptor::SYNTAX_PROTO2;
|
|
}
|
|
|
|
// We use this to implement the semantics that same file can be generated
|
|
// multiple times, but the last one wins. We never actually write the files,
|
|
// but we keep a set of which descriptors were the final one for a given
|
|
// filename.
|
|
class FileDeduplicator {
|
|
public:
|
|
explicit FileDeduplicator(const GeneratorOptions& options)
|
|
: error_on_conflict_(options.error_on_name_conflict) {}
|
|
|
|
bool AddFile(const string& filename, const void* desc, string* error) {
|
|
if (descs_by_filename_.find(filename) != descs_by_filename_.end()) {
|
|
if (error_on_conflict_) {
|
|
*error = "Name conflict: file name " + filename +
|
|
" would be generated by two descriptors";
|
|
return false;
|
|
}
|
|
allowed_descs_.erase(descs_by_filename_[filename]);
|
|
}
|
|
|
|
descs_by_filename_[filename] = desc;
|
|
allowed_descs_.insert(desc);
|
|
return true;
|
|
}
|
|
|
|
void GetAllowedSet(std::set<const void*>* allowed_set) {
|
|
*allowed_set = allowed_descs_;
|
|
}
|
|
|
|
private:
|
|
bool error_on_conflict_;
|
|
std::map<string, const void*> descs_by_filename_;
|
|
std::set<const void*> allowed_descs_;
|
|
};
|
|
|
|
void DepthFirstSearch(const FileDescriptor* file,
|
|
std::vector<const FileDescriptor*>* list,
|
|
std::set<const FileDescriptor*>* seen) {
|
|
if (!seen->insert(file).second) {
|
|
return;
|
|
}
|
|
|
|
// Add all dependencies.
|
|
for (int i = 0; i < file->dependency_count(); i++) {
|
|
DepthFirstSearch(file->dependency(i), list, seen);
|
|
}
|
|
|
|
// Add this file.
|
|
list->push_back(file);
|
|
}
|
|
|
|
// A functor for the predicate to remove_if() below. Returns true if a given
|
|
// FileDescriptor is not in the given set.
|
|
class NotInSet {
|
|
public:
|
|
explicit NotInSet(const std::set<const FileDescriptor*>& file_set)
|
|
: file_set_(file_set) {}
|
|
|
|
bool operator()(const FileDescriptor* file) {
|
|
return file_set_.count(file) == 0;
|
|
}
|
|
|
|
private:
|
|
const std::set<const FileDescriptor*>& file_set_;
|
|
};
|
|
|
|
// This function generates an ordering of the input FileDescriptors that matches
|
|
// the logic of the old code generator. The order is significant because two
|
|
// different input files can generate the same output file, and the last one
|
|
// needs to win.
|
|
void GenerateJspbFileOrder(const std::vector<const FileDescriptor*>& input,
|
|
std::vector<const FileDescriptor*>* ordered) {
|
|
// First generate an ordering of all reachable files (including dependencies)
|
|
// with depth-first search. This mimics the behavior of --include_imports,
|
|
// which is what the old codegen used.
|
|
ordered->clear();
|
|
std::set<const FileDescriptor*> seen;
|
|
std::set<const FileDescriptor*> input_set;
|
|
for (int i = 0; i < input.size(); i++) {
|
|
DepthFirstSearch(input[i], ordered, &seen);
|
|
input_set.insert(input[i]);
|
|
}
|
|
|
|
// Now remove the entries that are not actually in our input list.
|
|
ordered->erase(
|
|
std::remove_if(ordered->begin(), ordered->end(), NotInSet(input_set)),
|
|
ordered->end());
|
|
}
|
|
|
|
// If we're generating code in file-per-type mode, avoid overwriting files
|
|
// by choosing the last descriptor that writes each filename and permitting
|
|
// only those to generate code.
|
|
|
|
bool GenerateJspbAllowedSet(const GeneratorOptions& options,
|
|
const std::vector<const FileDescriptor*>& files,
|
|
std::set<const void*>* allowed_set,
|
|
string* error) {
|
|
std::vector<const FileDescriptor*> files_ordered;
|
|
GenerateJspbFileOrder(files, &files_ordered);
|
|
|
|
// Choose the last descriptor for each filename.
|
|
FileDeduplicator dedup(options);
|
|
for (int i = 0; i < files_ordered.size(); i++) {
|
|
for (int j = 0; j < files_ordered[i]->message_type_count(); j++) {
|
|
const Descriptor* desc = files_ordered[i]->message_type(j);
|
|
if (!dedup.AddFile(GetMessageFileName(options, desc), desc, error)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (int j = 0; j < files_ordered[i]->enum_type_count(); j++) {
|
|
const EnumDescriptor* desc = files_ordered[i]->enum_type(j);
|
|
if (!dedup.AddFile(GetEnumFileName(options, desc), desc, error)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Pull out all free-floating extensions and generate files for those too.
|
|
bool has_extension = false;
|
|
|
|
for (int j = 0; j < files_ordered[i]->extension_count(); j++) {
|
|
if (ShouldGenerateExtension(files_ordered[i]->extension(j))) {
|
|
has_extension = true;
|
|
}
|
|
}
|
|
|
|
if (has_extension) {
|
|
if (!dedup.AddFile(GetExtensionFileName(options, files_ordered[i]),
|
|
files_ordered[i], error)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
dedup.GetAllowedSet(allowed_set);
|
|
|
|
return true;
|
|
}
|
|
|
|
// Embeds base64 encoded GeneratedCodeInfo proto in a comment at the end of
|
|
// file.
|
|
void EmbedCodeAnnotations(const GeneratedCodeInfo& annotations,
|
|
io::Printer* printer) {
|
|
// Serialize annotations proto into base64 string.
|
|
string meta_content;
|
|
annotations.SerializeToString(&meta_content);
|
|
string meta_64;
|
|
Base64Escape(meta_content, &meta_64);
|
|
|
|
// Print base64 encoded annotations at the end of output file in
|
|
// a comment.
|
|
printer->Print("\n// Below is base64 encoded GeneratedCodeInfo proto");
|
|
printer->Print("\n// $encoded_proto$\n", "encoded_proto", meta_64);
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
void Generator::GenerateHeader(const GeneratorOptions& options,
|
|
io::Printer* printer) const {
|
|
printer->Print("/**\n"
|
|
" * @fileoverview\n"
|
|
" * @enhanceable\n"
|
|
" * @suppress {messageConventions} JS Compiler reports an "
|
|
"error if a variable or\n"
|
|
" * field starts with 'MSG_' and isn't a translatable "
|
|
"message.\n"
|
|
" * @public\n"
|
|
" */\n"
|
|
"// GENERATED CODE -- DO NOT EDIT!\n"
|
|
"\n");
|
|
}
|
|
|
|
void Generator::FindProvidesForFile(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FileDescriptor* file,
|
|
std::set<string>* provided) const {
|
|
for (int i = 0; i < file->message_type_count(); i++) {
|
|
FindProvidesForMessage(options, printer, file->message_type(i), provided);
|
|
}
|
|
for (int i = 0; i < file->enum_type_count(); i++) {
|
|
FindProvidesForEnum(options, printer, file->enum_type(i), provided);
|
|
}
|
|
}
|
|
|
|
void Generator::FindProvides(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const std::vector<const FileDescriptor*>& files,
|
|
std::set<string>* provided) const {
|
|
for (int i = 0; i < files.size(); i++) {
|
|
FindProvidesForFile(options, printer, files[i], provided);
|
|
}
|
|
|
|
printer->Print("\n");
|
|
}
|
|
|
|
void Generator::FindProvidesForMessage(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc,
|
|
std::set<string>* provided) const {
|
|
if (IgnoreMessage(options, desc)) {
|
|
return;
|
|
}
|
|
|
|
string name = GetMessagePath(options, desc);
|
|
provided->insert(name);
|
|
|
|
for (int i = 0; i < desc->enum_type_count(); i++) {
|
|
FindProvidesForEnum(options, printer, desc->enum_type(i),
|
|
provided);
|
|
}
|
|
for (int i = 0; i < desc->nested_type_count(); i++) {
|
|
FindProvidesForMessage(options, printer, desc->nested_type(i),
|
|
provided);
|
|
}
|
|
}
|
|
|
|
void Generator::FindProvidesForEnum(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const EnumDescriptor* enumdesc,
|
|
std::set<string>* provided) const {
|
|
string name = GetEnumPath(options, enumdesc);
|
|
provided->insert(name);
|
|
}
|
|
|
|
void Generator::FindProvidesForFields(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const std::vector<const FieldDescriptor*>& fields,
|
|
std::set<string>* provided) const {
|
|
for (int i = 0; i < fields.size(); i++) {
|
|
const FieldDescriptor* field = fields[i];
|
|
|
|
if (IgnoreField(field)) {
|
|
continue;
|
|
}
|
|
|
|
string name = GetFilePath(options, field->file()) + "." +
|
|
JSObjectFieldName(options, field);
|
|
provided->insert(name);
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateProvides(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
std::set<string>* provided) const {
|
|
for (std::set<string>::iterator it = provided->begin();
|
|
it != provided->end(); ++it) {
|
|
if (options.import_style == GeneratorOptions::kImportClosure) {
|
|
printer->Print("goog.provide('$name$');\n", "name", *it);
|
|
} else {
|
|
// We aren't using Closure's import system, but we use goog.exportSymbol()
|
|
// to construct the expected tree of objects, eg.
|
|
//
|
|
// goog.exportSymbol('foo.bar.Baz', null, this);
|
|
//
|
|
// // Later generated code expects foo.bar = {} to exist:
|
|
// foo.bar.Baz = function() { /* ... */ }
|
|
printer->Print("goog.exportSymbol('$name$', null, global);\n", "name",
|
|
*it);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateRequiresForMessage(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc,
|
|
std::set<string>* provided) const {
|
|
std::set<string> required;
|
|
std::set<string> forwards;
|
|
bool have_message = false;
|
|
FindRequiresForMessage(options, desc,
|
|
&required, &forwards, &have_message);
|
|
|
|
GenerateRequiresImpl(options, printer, &required, &forwards, provided,
|
|
/* require_jspb = */ have_message,
|
|
/* require_extension = */ HasExtensions(desc),
|
|
/* require_map = */ HasMap(options, desc));
|
|
}
|
|
|
|
void Generator::GenerateRequiresForLibrary(
|
|
const GeneratorOptions& options, io::Printer* printer,
|
|
const std::vector<const FileDescriptor*>& files,
|
|
std::set<string>* provided) const {
|
|
GOOGLE_CHECK_EQ(options.import_style, GeneratorOptions::kImportClosure);
|
|
// For Closure imports we need to import every message type individually.
|
|
std::set<string> required;
|
|
std::set<string> forwards;
|
|
bool have_extensions = false;
|
|
bool have_map = false;
|
|
bool have_message = false;
|
|
|
|
for (int i = 0; i < files.size(); i++) {
|
|
for (int j = 0; j < files[i]->message_type_count(); j++) {
|
|
const Descriptor* desc = files[i]->message_type(j);
|
|
if (!IgnoreMessage(options, desc)) {
|
|
FindRequiresForMessage(options, desc, &required, &forwards,
|
|
&have_message);
|
|
}
|
|
}
|
|
|
|
if (!have_extensions && HasExtensions(files[i])) {
|
|
have_extensions = true;
|
|
}
|
|
|
|
if (!have_map && FileHasMap(options, files[i])) {
|
|
have_map = true;
|
|
}
|
|
|
|
for (int j = 0; j < files[i]->extension_count(); j++) {
|
|
const FieldDescriptor* extension = files[i]->extension(j);
|
|
if (IgnoreField(extension)) {
|
|
continue;
|
|
}
|
|
if (extension->containing_type()->full_name() !=
|
|
"google.protobuf.bridge.MessageSet") {
|
|
required.insert(GetMessagePath(options, extension->containing_type()));
|
|
}
|
|
FindRequiresForField(options, extension, &required, &forwards);
|
|
have_extensions = true;
|
|
}
|
|
}
|
|
|
|
GenerateRequiresImpl(options, printer, &required, &forwards, provided,
|
|
/* require_jspb = */ have_message,
|
|
/* require_extension = */ have_extensions,
|
|
/* require_map = */ have_map);
|
|
}
|
|
|
|
void Generator::GenerateRequiresForExtensions(
|
|
const GeneratorOptions& options, io::Printer* printer,
|
|
const std::vector<const FieldDescriptor*>& fields,
|
|
std::set<string>* provided) const {
|
|
std::set<string> required;
|
|
std::set<string> forwards;
|
|
for (int i = 0; i < fields.size(); i++) {
|
|
const FieldDescriptor* field = fields[i];
|
|
if (IgnoreField(field)) {
|
|
continue;
|
|
}
|
|
FindRequiresForExtension(options, field, &required, &forwards);
|
|
}
|
|
|
|
GenerateRequiresImpl(options, printer, &required, &forwards, provided,
|
|
/* require_jspb = */ false,
|
|
/* require_extension = */ fields.size() > 0,
|
|
/* require_map = */ false);
|
|
}
|
|
|
|
void Generator::GenerateRequiresImpl(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
std::set<string>* required,
|
|
std::set<string>* forwards,
|
|
std::set<string>* provided,
|
|
bool require_jspb, bool require_extension,
|
|
bool require_map) const {
|
|
if (require_jspb) {
|
|
required->insert("jspb.Message");
|
|
required->insert("jspb.BinaryReader");
|
|
required->insert("jspb.BinaryWriter");
|
|
}
|
|
if (require_extension) {
|
|
required->insert("jspb.ExtensionFieldBinaryInfo");
|
|
required->insert("jspb.ExtensionFieldInfo");
|
|
}
|
|
if (require_map) {
|
|
required->insert("jspb.Map");
|
|
}
|
|
|
|
std::set<string>::iterator it;
|
|
for (it = required->begin(); it != required->end(); ++it) {
|
|
if (provided->find(*it) != provided->end()) {
|
|
continue;
|
|
}
|
|
printer->Print("goog.require('$name$');\n",
|
|
"name", *it);
|
|
}
|
|
|
|
printer->Print("\n");
|
|
|
|
for (it = forwards->begin(); it != forwards->end(); ++it) {
|
|
if (provided->find(*it) != provided->end()) {
|
|
continue;
|
|
}
|
|
printer->Print("goog.forwardDeclare('$name$');\n",
|
|
"name", *it);
|
|
}
|
|
}
|
|
|
|
bool NamespaceOnly(const Descriptor* desc) {
|
|
return false;
|
|
}
|
|
|
|
void Generator::FindRequiresForMessage(
|
|
const GeneratorOptions& options,
|
|
const Descriptor* desc,
|
|
std::set<string>* required,
|
|
std::set<string>* forwards,
|
|
bool* have_message) const {
|
|
|
|
|
|
if (!NamespaceOnly(desc)) {
|
|
*have_message = true;
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
const FieldDescriptor* field = desc->field(i);
|
|
if (IgnoreField(field)) {
|
|
continue;
|
|
}
|
|
FindRequiresForField(options, field, required, forwards);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < desc->extension_count(); i++) {
|
|
const FieldDescriptor* field = desc->extension(i);
|
|
if (IgnoreField(field)) {
|
|
continue;
|
|
}
|
|
FindRequiresForExtension(options, field, required, forwards);
|
|
}
|
|
|
|
for (int i = 0; i < desc->nested_type_count(); i++) {
|
|
FindRequiresForMessage(options, desc->nested_type(i), required, forwards,
|
|
have_message);
|
|
}
|
|
}
|
|
|
|
void Generator::FindRequiresForField(const GeneratorOptions& options,
|
|
const FieldDescriptor* field,
|
|
std::set<string>* required,
|
|
std::set<string>* forwards) const {
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM &&
|
|
// N.B.: file-level extensions with enum type do *not* create
|
|
// dependencies, as per original codegen.
|
|
!(field->is_extension() && field->extension_scope() == NULL)) {
|
|
if (options.add_require_for_enums) {
|
|
required->insert(GetEnumPath(options, field->enum_type()));
|
|
} else {
|
|
forwards->insert(GetEnumPath(options, field->enum_type()));
|
|
}
|
|
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
if (!IgnoreMessage(options, field->message_type())) {
|
|
required->insert(GetMessagePath(options, field->message_type()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void Generator::FindRequiresForExtension(const GeneratorOptions& options,
|
|
const FieldDescriptor* field,
|
|
std::set<string>* required,
|
|
std::set<string>* forwards) const {
|
|
if (field->containing_type()->full_name() != "google.protobuf.bridge.MessageSet") {
|
|
required->insert(GetMessagePath(options, field->containing_type()));
|
|
}
|
|
FindRequiresForField(options, field, required, forwards);
|
|
}
|
|
|
|
void Generator::GenerateTestOnly(const GeneratorOptions& options,
|
|
io::Printer* printer) const {
|
|
if (options.testonly) {
|
|
printer->Print("goog.setTestOnly();\n\n");
|
|
}
|
|
printer->Print("\n");
|
|
}
|
|
|
|
void Generator::GenerateClassesAndEnums(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FileDescriptor* file) const {
|
|
for (int i = 0; i < file->message_type_count(); i++) {
|
|
GenerateClass(options, printer, file->message_type(i));
|
|
}
|
|
for (int i = 0; i < file->enum_type_count(); i++) {
|
|
GenerateEnum(options, printer, file->enum_type(i));
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateClass(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
if (IgnoreMessage(options, desc)) {
|
|
return;
|
|
}
|
|
|
|
if (!NamespaceOnly(desc)) {
|
|
printer->Print("\n");
|
|
GenerateClassConstructor(options, printer, desc);
|
|
GenerateClassFieldInfo(options, printer, desc);
|
|
|
|
|
|
GenerateClassToObject(options, printer, desc);
|
|
// These must come *before* the extension-field info generation in
|
|
// GenerateClassRegistration so that references to the binary
|
|
// serialization/deserialization functions may be placed in the extension
|
|
// objects.
|
|
GenerateClassDeserializeBinary(options, printer, desc);
|
|
GenerateClassSerializeBinary(options, printer, desc);
|
|
}
|
|
|
|
// Recurse on nested types. These must come *before* the extension-field
|
|
// info generation in GenerateClassRegistration so that extensions that
|
|
// reference nested types proceed the definitions of the nested types.
|
|
for (int i = 0; i < desc->enum_type_count(); i++) {
|
|
GenerateEnum(options, printer, desc->enum_type(i));
|
|
}
|
|
for (int i = 0; i < desc->nested_type_count(); i++) {
|
|
GenerateClass(options, printer, desc->nested_type(i));
|
|
}
|
|
|
|
if (!NamespaceOnly(desc)) {
|
|
GenerateClassRegistration(options, printer, desc);
|
|
GenerateClassFields(options, printer, desc);
|
|
if (IsExtendable(desc) && desc->full_name() != "google.protobuf.bridge.MessageSet") {
|
|
GenerateClassExtensionFieldInfo(options, printer, desc);
|
|
}
|
|
|
|
if (options.import_style != GeneratorOptions::kImportClosure) {
|
|
for (int i = 0; i < desc->extension_count(); i++) {
|
|
GenerateExtension(options, printer, desc->extension(i));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateClassConstructor(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * Generated by JsPbCodeGenerator.\n"
|
|
" * @param {Array=} opt_data Optional initial data array, typically "
|
|
"from a\n"
|
|
" * server response, or constructed directly in Javascript. The array "
|
|
"is used\n"
|
|
" * in place and becomes part of the constructed object. It is not "
|
|
"cloned.\n"
|
|
" * If no data is provided, the constructed object will be empty, but "
|
|
"still\n"
|
|
" * valid.\n"
|
|
" * @extends {jspb.Message}\n"
|
|
" * @constructor\n"
|
|
" */\n"
|
|
"$classprefix$$classname$ = function(opt_data) {\n",
|
|
"classprefix", GetMessagePathPrefix(options, desc),
|
|
"classname", desc->name());
|
|
printer->Annotate("classname", desc);
|
|
string message_id = GetMessageId(desc);
|
|
printer->Print(
|
|
" jspb.Message.initialize(this, opt_data, $messageId$, $pivot$, "
|
|
"$rptfields$, $oneoffields$);\n",
|
|
"messageId", !message_id.empty() ?
|
|
("'" + message_id + "'") :
|
|
(IsResponse(desc) ? "''" : "0"),
|
|
"pivot", GetPivot(desc),
|
|
"rptfields", RepeatedFieldsArrayName(options, desc),
|
|
"oneoffields", OneofFieldsArrayName(options, desc));
|
|
printer->Print(
|
|
"};\n"
|
|
"goog.inherits($classname$, jspb.Message);\n"
|
|
"if (goog.DEBUG && !COMPILED) {\n"
|
|
" $classname$.displayName = '$classname$';\n"
|
|
"}\n",
|
|
"classname", GetMessagePath(options, desc));
|
|
}
|
|
|
|
void Generator::GenerateClassFieldInfo(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
if (HasRepeatedFields(options, desc)) {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * List of repeated fields within this message type.\n"
|
|
" * @private {!Array<number>}\n"
|
|
" * @const\n"
|
|
" */\n"
|
|
"$classname$$rptfieldarray$ = $rptfields$;\n"
|
|
"\n",
|
|
"classname", GetMessagePath(options, desc),
|
|
"rptfieldarray", kRepeatedFieldArrayName,
|
|
"rptfields", RepeatedFieldNumberList(options, desc));
|
|
}
|
|
|
|
if (HasOneofFields(desc)) {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * Oneof group definitions for this message. Each group defines the "
|
|
"field\n"
|
|
" * numbers belonging to that group. When of these fields' value is "
|
|
"set, all\n"
|
|
" * other fields in the group are cleared. During deserialization, if "
|
|
"multiple\n"
|
|
" * fields are encountered for a group, only the last value seen will "
|
|
"be kept.\n"
|
|
" * @private {!Array<!Array<number>>}\n"
|
|
" * @const\n"
|
|
" */\n"
|
|
"$classname$$oneofgrouparray$ = $oneofgroups$;\n"
|
|
"\n",
|
|
"classname", GetMessagePath(options, desc),
|
|
"oneofgrouparray", kOneofGroupArrayName,
|
|
"oneofgroups", OneofGroupList(desc));
|
|
|
|
for (int i = 0; i < desc->oneof_decl_count(); i++) {
|
|
if (IgnoreOneof(desc->oneof_decl(i))) {
|
|
continue;
|
|
}
|
|
GenerateOneofCaseDefinition(options, printer, desc->oneof_decl(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateClassXid(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
printer->Print(
|
|
"\n"
|
|
"\n"
|
|
"$class$.prototype.messageXid = xid('$class$');\n",
|
|
"class", GetMessagePath(options, desc));
|
|
}
|
|
|
|
void Generator::GenerateOneofCaseDefinition(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const OneofDescriptor* oneof) const {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * @enum {number}\n"
|
|
" */\n"
|
|
"$classname$.$oneof$Case = {\n"
|
|
" $upcase$_NOT_SET: 0",
|
|
"classname", GetMessagePath(options, oneof->containing_type()),
|
|
"oneof", JSOneofName(oneof),
|
|
"upcase", ToEnumCase(oneof->name()));
|
|
|
|
for (int i = 0; i < oneof->field_count(); i++) {
|
|
if (IgnoreField(oneof->field(i))) {
|
|
continue;
|
|
}
|
|
|
|
printer->Print(
|
|
",\n"
|
|
" $upcase$: $number$",
|
|
"upcase", ToEnumCase(oneof->field(i)->name()),
|
|
"number", JSFieldIndex(oneof->field(i)));
|
|
printer->Annotate("upcase", oneof->field(i));
|
|
}
|
|
|
|
printer->Print(
|
|
"\n"
|
|
"};\n"
|
|
"\n"
|
|
"/**\n"
|
|
" * @return {$class$.$oneof$Case}\n"
|
|
" */\n"
|
|
"$class$.prototype.get$oneof$Case = function() {\n"
|
|
" return /** @type {$class$.$oneof$Case} */(jspb.Message."
|
|
"computeOneofCase(this, $class$.oneofGroups_[$oneofindex$]));\n"
|
|
"};\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, oneof->containing_type()),
|
|
"oneof", JSOneofName(oneof),
|
|
"oneofindex", JSOneofIndex(oneof));
|
|
}
|
|
|
|
void Generator::GenerateClassToObject(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
printer->Print(
|
|
"\n"
|
|
"\n"
|
|
"if (jspb.Message.GENERATE_TO_OBJECT) {\n"
|
|
"/**\n"
|
|
" * Creates an object representation of this proto suitable for use in "
|
|
"Soy templates.\n"
|
|
" * Field names that are reserved in JavaScript and will be renamed to "
|
|
"pb_name.\n"
|
|
" * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.\n"
|
|
" * For the list of reserved names please see:\n"
|
|
" * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS.\n"
|
|
" * @param {boolean=} opt_includeInstance Whether to include the JSPB "
|
|
"instance\n"
|
|
" * for transitional soy proto support: http://goto/soy-param-"
|
|
"migration\n"
|
|
" * @return {!Object}\n"
|
|
" */\n"
|
|
"$classname$.prototype.toObject = function(opt_includeInstance) {\n"
|
|
" return $classname$.toObject(opt_includeInstance, this);\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n"
|
|
"/**\n"
|
|
" * Static version of the {@see toObject} method.\n"
|
|
" * @param {boolean|undefined} includeInstance Whether to include the "
|
|
"JSPB\n"
|
|
" * instance for transitional soy proto support:\n"
|
|
" * http://goto/soy-param-migration\n"
|
|
" * @param {!$classname$} msg The msg instance to transform.\n"
|
|
" * @return {!Object}\n"
|
|
" * @suppress {unusedLocalVariables} f is only used for nested messages\n"
|
|
" */\n"
|
|
"$classname$.toObject = function(includeInstance, msg) {\n"
|
|
" var f, obj = {",
|
|
"classname", GetMessagePath(options, desc));
|
|
|
|
bool first = true;
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
const FieldDescriptor* field = desc->field(i);
|
|
if (IgnoreField(field)) {
|
|
continue;
|
|
}
|
|
|
|
if (!first) {
|
|
printer->Print(",\n ");
|
|
} else {
|
|
printer->Print("\n ");
|
|
first = false;
|
|
}
|
|
|
|
GenerateClassFieldToObject(options, printer, field);
|
|
}
|
|
|
|
if (!first) {
|
|
printer->Print("\n };\n\n");
|
|
} else {
|
|
printer->Print("\n\n };\n\n");
|
|
}
|
|
|
|
if (IsExtendable(desc)) {
|
|
printer->Print(
|
|
" jspb.Message.toObjectExtension(/** @type {!jspb.Message} */ (msg), "
|
|
"obj,\n"
|
|
" $extObject$, $class$.prototype.getExtension,\n"
|
|
" includeInstance);\n",
|
|
"extObject", JSExtensionsObjectName(options, desc->file(), desc),
|
|
"class", GetMessagePath(options, desc));
|
|
}
|
|
|
|
printer->Print(
|
|
" if (includeInstance) {\n"
|
|
" obj.$$jspbMessageInstance = msg;\n"
|
|
" }\n"
|
|
" return obj;\n"
|
|
"};\n"
|
|
"}\n"
|
|
"\n"
|
|
"\n",
|
|
"classname", GetMessagePath(options, desc));
|
|
}
|
|
|
|
void Generator::GenerateFieldValueExpression(io::Printer* printer,
|
|
const char *obj_reference,
|
|
const FieldDescriptor* field,
|
|
bool use_default) const {
|
|
bool is_float_or_double =
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT ||
|
|
field->cpp_type() == FieldDescriptor::CPPTYPE_DOUBLE;
|
|
if (use_default) {
|
|
if (is_float_or_double) {
|
|
// Coerce "Nan" and "Infinity" to actual float values.
|
|
//
|
|
// This will change null to 0, but that doesn't matter since we're getting
|
|
// with a default.
|
|
printer->Print("+");
|
|
}
|
|
|
|
printer->Print(
|
|
"jspb.Message.getFieldWithDefault($obj$, $index$, $default$)",
|
|
"obj", obj_reference,
|
|
"index", JSFieldIndex(field),
|
|
"default", JSFieldDefault(field));
|
|
} else {
|
|
if (is_float_or_double) {
|
|
if (field->is_required()) {
|
|
// Use "+" to convert all fields to numeric (including null).
|
|
printer->Print(
|
|
"+jspb.Message.getField($obj$, $index$)",
|
|
"index", JSFieldIndex(field),
|
|
"obj", obj_reference);
|
|
} else {
|
|
// Converts "NaN" and "Infinity" while preserving null.
|
|
printer->Print(
|
|
"jspb.Message.get$cardinality$FloatingPointField($obj$, $index$)",
|
|
"cardinality", field->is_repeated() ? "Repeated" : "Optional",
|
|
"index", JSFieldIndex(field),
|
|
"obj", obj_reference);
|
|
}
|
|
} else {
|
|
printer->Print("jspb.Message.get$cardinality$Field($obj$, $index$)",
|
|
"cardinality", field->is_repeated() ? "Repeated" : "",
|
|
"index", JSFieldIndex(field),
|
|
"obj", obj_reference);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateClassFieldToObject(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FieldDescriptor* field) const {
|
|
printer->Print("$fieldname$: ",
|
|
"fieldname", JSObjectFieldName(options, field));
|
|
|
|
if (IsMap(options, field)) {
|
|
const FieldDescriptor* value_field = MapFieldValue(field);
|
|
// If the map values are of a message type, we must provide their static
|
|
// toObject() method; otherwise we pass undefined for that argument.
|
|
string value_to_object;
|
|
if (value_field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
value_to_object =
|
|
GetMessagePath(options, value_field->message_type()) + ".toObject";
|
|
} else {
|
|
value_to_object = "undefined";
|
|
}
|
|
printer->Print(
|
|
"(f = msg.get$name$()) ? f.toObject(includeInstance, $valuetoobject$) "
|
|
": []",
|
|
"name", JSGetterName(options, field), "valuetoobject", value_to_object);
|
|
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
// Message field.
|
|
if (field->is_repeated()) {
|
|
{
|
|
printer->Print("jspb.Message.toObjectList(msg.get$getter$(),\n"
|
|
" $type$.toObject, includeInstance)",
|
|
"getter", JSGetterName(options, field),
|
|
"type", SubmessageTypeRef(options, field));
|
|
}
|
|
} else {
|
|
printer->Print("(f = msg.get$getter$()) && "
|
|
"$type$.toObject(includeInstance, f)",
|
|
"getter", JSGetterName(options, field),
|
|
"type", SubmessageTypeRef(options, field));
|
|
}
|
|
} else if (field->type() == FieldDescriptor::TYPE_BYTES) {
|
|
// For bytes fields we want to always return the B64 data.
|
|
printer->Print("msg.get$getter$()",
|
|
"getter", JSGetterName(options, field, BYTES_B64));
|
|
} else {
|
|
bool use_default = field->has_default_value();
|
|
|
|
if (field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3 &&
|
|
// Repeated fields get initialized to their default in the constructor
|
|
// (why?), so we emit a plain getField() call for them.
|
|
!field->is_repeated() && !UseBrokenPresenceSemantics(options, field)) {
|
|
// Proto3 puts all defaults (including implicit defaults) in toObject().
|
|
// But for proto2 we leave the existing semantics unchanged: unset fields
|
|
// without default are unset.
|
|
use_default = true;
|
|
}
|
|
|
|
// We don't implement this by calling the accessors, because the semantics
|
|
// of the accessors are changing independently of the toObject() semantics.
|
|
// We are migrating the accessors to return defaults instead of null, but
|
|
// it may take longer to migrate toObject (or we might not want to do it at
|
|
// all). So we want to generate independent code.
|
|
GenerateFieldValueExpression(printer, "msg", field, use_default);
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateClassFromObject(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
printer->Print(
|
|
"if (jspb.Message.GENERATE_FROM_OBJECT) {\n"
|
|
"/**\n"
|
|
" * Loads data from an object into a new instance of this proto.\n"
|
|
" * @param {!Object} obj The object representation of this proto to\n"
|
|
" * load the data from.\n"
|
|
" * @return {!$classname$}\n"
|
|
" */\n"
|
|
"$classname$.fromObject = function(obj) {\n"
|
|
" var f, msg = new $classname$();\n",
|
|
"classname", GetMessagePath(options, desc));
|
|
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
const FieldDescriptor* field = desc->field(i);
|
|
GenerateClassFieldFromObject(options, printer, field);
|
|
}
|
|
|
|
printer->Print(
|
|
" return msg;\n"
|
|
"};\n"
|
|
"}\n");
|
|
}
|
|
|
|
void Generator::GenerateClassFieldFromObject(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FieldDescriptor* field) const {
|
|
if (IsMap(options, field)) {
|
|
const FieldDescriptor* value_field = MapFieldValue(field);
|
|
if (value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
|
|
// Since the map values are of message type, we have to do some extra work
|
|
// to recursively call fromObject() on them before setting the map field.
|
|
printer->Print(
|
|
" goog.isDef(obj.$name$) && jspb.Message.setWrapperField(\n"
|
|
" msg, $index$, jspb.Map.fromObject(obj.$name$, $fieldclass$, "
|
|
"$fieldclass$.fromObject));\n",
|
|
"name", JSObjectFieldName(options, field),
|
|
"index", JSFieldIndex(field),
|
|
"fieldclass", GetMessagePath(options, value_field->message_type()));
|
|
} else {
|
|
// `msg` is a newly-constructed message object that has not yet built any
|
|
// map containers wrapping underlying arrays, so we can simply directly
|
|
// set the array here without fear of a stale wrapper.
|
|
printer->Print(
|
|
" goog.isDef(obj.$name$) && "
|
|
"jspb.Message.setField(msg, $index$, obj.$name$);\n",
|
|
"name", JSObjectFieldName(options, field),
|
|
"index", JSFieldIndex(field));
|
|
}
|
|
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
// Message field (singular or repeated)
|
|
if (field->is_repeated()) {
|
|
{
|
|
printer->Print(
|
|
" goog.isDef(obj.$name$) && "
|
|
"jspb.Message.setRepeatedWrapperField(\n"
|
|
" msg, $index$, goog.array.map(obj.$name$, function(i) {\n"
|
|
" return $fieldclass$.fromObject(i);\n"
|
|
" }));\n",
|
|
"name", JSObjectFieldName(options, field),
|
|
"index", JSFieldIndex(field),
|
|
"fieldclass", SubmessageTypeRef(options, field));
|
|
}
|
|
} else {
|
|
printer->Print(
|
|
" goog.isDef(obj.$name$) && jspb.Message.setWrapperField(\n"
|
|
" msg, $index$, $fieldclass$.fromObject(obj.$name$));\n",
|
|
"name", JSObjectFieldName(options, field),
|
|
"index", JSFieldIndex(field),
|
|
"fieldclass", SubmessageTypeRef(options, field));
|
|
}
|
|
} else {
|
|
// Simple (primitive) field.
|
|
printer->Print(
|
|
" goog.isDef(obj.$name$) && jspb.Message.setField(msg, $index$, "
|
|
"obj.$name$);\n",
|
|
"name", JSObjectFieldName(options, field),
|
|
"index", JSFieldIndex(field));
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateClassRegistration(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
// Register any extensions defined inside this message type.
|
|
for (int i = 0; i < desc->extension_count(); i++) {
|
|
const FieldDescriptor* extension = desc->extension(i);
|
|
if (ShouldGenerateExtension(extension)) {
|
|
GenerateExtension(options, printer, extension);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void Generator::GenerateClassFields(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (!IgnoreField(desc->field(i))) {
|
|
GenerateClassField(options, printer, desc->field(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
void GenerateBytesWrapper(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FieldDescriptor* field,
|
|
BytesMode bytes_mode) {
|
|
string type = JSFieldTypeAnnotation(
|
|
options, field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ false,
|
|
/* singular_if_not_packed = */ false, bytes_mode);
|
|
printer->Print(
|
|
"/**\n"
|
|
" * $fielddef$\n"
|
|
"$comment$"
|
|
" * This is a type-conversion wrapper around `get$defname$()`\n"
|
|
" * @return {$type$}\n"
|
|
" */\n"
|
|
"$class$.prototype.get$name$ = function() {\n"
|
|
" return /** @type {$type$} */ (jspb.Message.bytes$list$As$suffix$(\n"
|
|
" this.get$defname$()));\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"fielddef", FieldDefinition(options, field),
|
|
"comment", FieldComments(field, bytes_mode),
|
|
"type", type,
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"name", JSGetterName(options, field, bytes_mode),
|
|
"list", field->is_repeated() ? "List" : "",
|
|
"suffix", JSByteGetterSuffix(bytes_mode),
|
|
"defname", JSGetterName(options, field, BYTES_DEFAULT));
|
|
}
|
|
|
|
void Generator::GenerateClassField(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FieldDescriptor* field) const {
|
|
if (IsMap(options, field)) {
|
|
const FieldDescriptor* key_field = MapFieldKey(field);
|
|
const FieldDescriptor* value_field = MapFieldValue(field);
|
|
// Map field: special handling to instantiate the map object on demand.
|
|
string key_type =
|
|
JSFieldTypeAnnotation(
|
|
options, key_field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ true,
|
|
/* singular_if_not_packed = */ false);
|
|
string value_type =
|
|
JSFieldTypeAnnotation(
|
|
options, value_field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ true,
|
|
/* singular_if_not_packed = */ false);
|
|
|
|
printer->Print(
|
|
"/**\n"
|
|
" * $fielddef$\n"
|
|
" * @param {boolean=} opt_noLazyCreate Do not create the map if\n"
|
|
" * empty, instead returning `undefined`\n"
|
|
" * @return {!jspb.Map<$keytype$,$valuetype$>}\n"
|
|
" */\n",
|
|
"fielddef", FieldDefinition(options, field),
|
|
"keytype", key_type,
|
|
"valuetype", value_type);
|
|
printer->Print(
|
|
"$class$.prototype.$gettername$ = function(opt_noLazyCreate) {\n"
|
|
" return /** @type {!jspb.Map<$keytype$,$valuetype$>} */ (\n",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"gettername", "get" + JSGetterName(options, field),
|
|
"keytype", key_type,
|
|
"valuetype", value_type);
|
|
printer->Annotate("gettername", field);
|
|
printer->Print(
|
|
" jspb.Message.getMapField(this, $index$, opt_noLazyCreate",
|
|
"index", JSFieldIndex(field));
|
|
|
|
if (value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
|
|
printer->Print(
|
|
",\n"
|
|
" $messageType$",
|
|
"messageType", GetMessagePath(options, value_field->message_type()));
|
|
} else {
|
|
printer->Print(",\n"
|
|
" null");
|
|
}
|
|
|
|
printer->Print(
|
|
"));\n");
|
|
|
|
printer->Print(
|
|
"};\n"
|
|
"\n"
|
|
"\n");
|
|
} else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
// Message field: special handling in order to wrap the underlying data
|
|
// array with a message object.
|
|
|
|
printer->Print(
|
|
"/**\n"
|
|
" * $fielddef$\n"
|
|
"$comment$"
|
|
" * @return {$type$}\n"
|
|
" */\n",
|
|
"fielddef", FieldDefinition(options, field),
|
|
"comment", FieldComments(field, BYTES_DEFAULT),
|
|
"type", JSFieldTypeAnnotation(options, field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ false,
|
|
/* singular_if_not_packed = */ false));
|
|
printer->Print(
|
|
"$class$.prototype.$gettername$ = function() {\n"
|
|
" return /** @type{$type$} */ (\n"
|
|
" jspb.Message.get$rpt$WrapperField(this, $wrapperclass$, "
|
|
"$index$$required$));\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"gettername", "get" + JSGetterName(options, field),
|
|
"type", JSFieldTypeAnnotation(options, field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ false,
|
|
/* singular_if_not_packed = */ false),
|
|
"rpt", (field->is_repeated() ? "Repeated" : ""),
|
|
"index", JSFieldIndex(field),
|
|
"wrapperclass", SubmessageTypeRef(options, field),
|
|
"required", (field->label() == FieldDescriptor::LABEL_REQUIRED ?
|
|
", 1" : ""));
|
|
printer->Annotate("gettername", field);
|
|
printer->Print(
|
|
"/** @param {$optionaltype$} value$returndoc$ */\n"
|
|
"$class$.prototype.$settername$ = function(value) {\n"
|
|
" jspb.Message.set$oneoftag$$repeatedtag$WrapperField(",
|
|
"optionaltype",
|
|
JSFieldTypeAnnotation(options, field,
|
|
/* is_setter_argument = */ true,
|
|
/* force_present = */ false,
|
|
/* singular_if_not_packed = */ false),
|
|
"returndoc", JSReturnDoc(options, field),
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"settername", "set" + JSGetterName(options, field),
|
|
"oneoftag", (field->containing_oneof() ? "Oneof" : ""),
|
|
"repeatedtag", (field->is_repeated() ? "Repeated" : ""));
|
|
printer->Annotate("settername", field);
|
|
|
|
printer->Print(
|
|
"this, $index$$oneofgroup$, value);$returnvalue$\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"index", JSFieldIndex(field),
|
|
"oneofgroup", (field->containing_oneof() ?
|
|
(", " + JSOneofArray(options, field)) : ""),
|
|
"returnvalue", JSReturnClause(field));
|
|
|
|
if (field->is_repeated()) {
|
|
GenerateRepeatedMessageHelperMethods(options, printer, field);
|
|
}
|
|
|
|
} else {
|
|
bool untyped =
|
|
false;
|
|
|
|
// Simple (primitive) field, either singular or repeated.
|
|
|
|
// TODO(b/26173701): Always use BYTES_DEFAULT for the getter return type;
|
|
// at this point we "lie" to non-binary users and tell the return
|
|
// type is always base64 string, pending a LSC to migrate to typed getters.
|
|
BytesMode bytes_mode =
|
|
field->type() == FieldDescriptor::TYPE_BYTES && !options.binary ?
|
|
BYTES_B64 : BYTES_DEFAULT;
|
|
string typed_annotation = JSFieldTypeAnnotation(
|
|
options, field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ false,
|
|
/* singular_if_not_packed = */ false,
|
|
/* bytes_mode = */ bytes_mode);
|
|
if (untyped) {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * @return {?} Raw field, untyped.\n"
|
|
" */\n");
|
|
} else {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * $fielddef$\n"
|
|
"$comment$"
|
|
" * @return {$type$}\n"
|
|
" */\n",
|
|
"fielddef", FieldDefinition(options, field),
|
|
"comment", FieldComments(field, bytes_mode),
|
|
"type", typed_annotation);
|
|
}
|
|
|
|
printer->Print(
|
|
"$class$.prototype.$gettername$ = function() {\n",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"gettername", "get" + JSGetterName(options, field));
|
|
printer->Annotate("gettername", field);
|
|
|
|
if (untyped) {
|
|
printer->Print(
|
|
" return ");
|
|
} else {
|
|
printer->Print(
|
|
" return /** @type {$type$} */ (",
|
|
"type", typed_annotation);
|
|
}
|
|
|
|
bool use_default = !ReturnsNullWhenUnset(options, field);
|
|
|
|
// Raw fields with no default set should just return undefined.
|
|
if (untyped && !field->has_default_value()) {
|
|
use_default = false;
|
|
}
|
|
|
|
// Repeated fields get initialized to their default in the constructor
|
|
// (why?), so we emit a plain getField() call for them.
|
|
if (field->is_repeated()) {
|
|
use_default = false;
|
|
}
|
|
|
|
GenerateFieldValueExpression(printer, "this", field, use_default);
|
|
|
|
if (untyped) {
|
|
printer->Print(
|
|
";\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n");
|
|
} else {
|
|
printer->Print(
|
|
");\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n");
|
|
}
|
|
|
|
if (field->type() == FieldDescriptor::TYPE_BYTES && !untyped) {
|
|
GenerateBytesWrapper(options, printer, field, BYTES_B64);
|
|
GenerateBytesWrapper(options, printer, field, BYTES_U8);
|
|
}
|
|
|
|
if (untyped) {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * @param {*} value$returndoc$\n"
|
|
" */\n",
|
|
"returndoc", JSReturnDoc(options, field));
|
|
} else {
|
|
printer->Print(
|
|
"/** @param {$optionaltype$} value$returndoc$ */\n", "optionaltype",
|
|
JSFieldTypeAnnotation(
|
|
options, field,
|
|
/* is_setter_argument = */ true,
|
|
/* force_present = */ false,
|
|
/* singular_if_not_packed = */ false),
|
|
"returndoc", JSReturnDoc(options, field));
|
|
}
|
|
|
|
if (field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3 &&
|
|
!field->is_repeated() && !field->is_map() &&
|
|
!HasFieldPresence(options, field)) {
|
|
// Proto3 non-repeated and non-map fields without presence use the
|
|
// setProto3*Field function.
|
|
printer->Print(
|
|
"$class$.prototype.$settername$ = function(value) {\n"
|
|
" jspb.Message.setProto3$typetag$Field(this, $index$, "
|
|
"value);$returnvalue$\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"settername", "set" + JSGetterName(options, field), "typetag",
|
|
JSTypeTag(field), "index", JSFieldIndex(field), "returnvalue",
|
|
JSReturnClause(field));
|
|
printer->Annotate("settername", field);
|
|
} else {
|
|
// Otherwise, use the regular setField function.
|
|
printer->Print(
|
|
"$class$.prototype.$settername$ = function(value) {\n"
|
|
" jspb.Message.set$oneoftag$Field(this, $index$",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"settername", "set" + JSGetterName(options, field), "oneoftag",
|
|
(field->containing_oneof() ? "Oneof" : ""), "index",
|
|
JSFieldIndex(field));
|
|
printer->Annotate("settername", field);
|
|
printer->Print(
|
|
"$oneofgroup$, $type$value$rptvalueinit$$typeclose$);$returnvalue$\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"type",
|
|
untyped ? "/** @type{string|number|boolean|Array|undefined} */(" : "",
|
|
"typeclose", untyped ? ")" : "", "oneofgroup",
|
|
(field->containing_oneof() ? (", " + JSOneofArray(options, field))
|
|
: ""),
|
|
"returnvalue", JSReturnClause(field), "rptvalueinit",
|
|
(field->is_repeated() ? " || []" : ""));
|
|
}
|
|
|
|
if (untyped) {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * Clears the value.$returndoc$\n"
|
|
" */\n",
|
|
"returndoc", JSReturnDoc(options, field));
|
|
}
|
|
|
|
|
|
if (field->is_repeated()) {
|
|
GenerateRepeatedPrimitiveHelperMethods(options, printer, field, untyped);
|
|
}
|
|
}
|
|
|
|
// Generate clearFoo() method for map fields, repeated fields, and other
|
|
// fields with presence.
|
|
if (IsMap(options, field)) {
|
|
printer->Print(
|
|
"$class$.prototype.$clearername$ = function() {\n"
|
|
" this.$gettername$().clear();$returnvalue$\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"clearername", "clear" + JSGetterName(options, field),
|
|
"gettername", "get" + JSGetterName(options, field),
|
|
"returnvalue", JSReturnClause(field));
|
|
printer->Annotate("clearername", field);
|
|
} else if (field->is_repeated() ||
|
|
(field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
!field->is_required())) {
|
|
// Fields where we can delegate to the regular setter.
|
|
printer->Print(
|
|
"$class$.prototype.$clearername$ = function() {\n"
|
|
" this.$settername$($clearedvalue$);$returnvalue$\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"clearername", "clear" + JSGetterName(options, field),
|
|
"settername", "set" + JSGetterName(options, field),
|
|
"clearedvalue", (field->is_repeated() ? "[]" : "undefined"),
|
|
"returnvalue", JSReturnClause(field));
|
|
printer->Annotate("clearername", field);
|
|
} else if (HasFieldPresence(options, field)) {
|
|
// Fields where we can't delegate to the regular setter because it doesn't
|
|
// accept "undefined" as an argument.
|
|
printer->Print(
|
|
"$class$.prototype.$clearername$ = function() {\n"
|
|
" jspb.Message.set$maybeoneof$Field(this, "
|
|
"$index$$maybeoneofgroup$, ",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"clearername", "clear" + JSGetterName(options, field),
|
|
"maybeoneof", (field->containing_oneof() ? "Oneof" : ""),
|
|
"maybeoneofgroup", (field->containing_oneof() ?
|
|
(", " + JSOneofArray(options, field)) : ""),
|
|
"index", JSFieldIndex(field));
|
|
printer->Annotate("clearername", field);
|
|
printer->Print(
|
|
"$clearedvalue$);$returnvalue$\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"clearedvalue", (field->is_repeated() ? "[]" : "undefined"),
|
|
"returnvalue", JSReturnClause(field));
|
|
}
|
|
|
|
if (HasFieldPresence(options, field)) {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * Returns whether this field is set.\n"
|
|
" * @return {!boolean}\n"
|
|
" */\n"
|
|
"$class$.prototype.$hasername$ = function() {\n"
|
|
" return jspb.Message.getField(this, $index$) != null;\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"hasername", "has" + JSGetterName(options, field),
|
|
"index", JSFieldIndex(field));
|
|
printer->Annotate("hasername", field);
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateRepeatedPrimitiveHelperMethods(
|
|
const GeneratorOptions& options, io::Printer* printer,
|
|
const FieldDescriptor* field, bool untyped) const {
|
|
// clang-format off
|
|
printer->Print(
|
|
"/**\n"
|
|
" * @param {!$optionaltype$} value\n"
|
|
" * @param {number=} opt_index$returndoc$\n"
|
|
" */\n"
|
|
"$class$.prototype.$addername$ = function(value, opt_index) {\n"
|
|
" jspb.Message.addToRepeatedField(this, $index$",
|
|
"class", GetMessagePath(options, field->containing_type()), "addername",
|
|
"add" + JSGetterName(options, field, BYTES_DEFAULT,
|
|
/* drop_list = */ true),
|
|
"optionaltype", JSTypeName(options, field, BYTES_DEFAULT),
|
|
"index", JSFieldIndex(field),
|
|
"returndoc", JSReturnDoc(options, field));
|
|
printer->Annotate("addername", field);
|
|
printer->Print(
|
|
"$oneofgroup$, $type$value$rptvalueinit$$typeclose$, "
|
|
"opt_index);$returnvalue$\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"type", untyped ? "/** @type{string|number|boolean|!Uint8Array} */(" : "",
|
|
"typeclose", untyped ? ")" : "", "oneofgroup",
|
|
(field->containing_oneof() ? (", " + JSOneofArray(options, field)) : ""),
|
|
"rptvalueinit", "",
|
|
"returnvalue", JSReturnClause(field));
|
|
// clang-format on
|
|
}
|
|
|
|
void Generator::GenerateRepeatedMessageHelperMethods(
|
|
const GeneratorOptions& options, io::Printer* printer,
|
|
const FieldDescriptor* field) const {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * @param {!$optionaltype$=} opt_value\n"
|
|
" * @param {number=} opt_index\n"
|
|
" * @return {!$optionaltype$}\n"
|
|
" */\n"
|
|
"$class$.prototype.add$name$ = function(opt_value, opt_index) {\n"
|
|
" return jspb.Message.addTo$repeatedtag$WrapperField(",
|
|
"optionaltype", JSTypeName(options, field, BYTES_DEFAULT),
|
|
"class", GetMessagePath(options, field->containing_type()),
|
|
"name", JSGetterName(options, field, BYTES_DEFAULT,
|
|
/* drop_list = */ true),
|
|
"repeatedtag", (field->is_repeated() ? "Repeated" : ""));
|
|
|
|
printer->Print(
|
|
"this, $index$$oneofgroup$, opt_value, $ctor$, opt_index);\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n",
|
|
"index", JSFieldIndex(field), "oneofgroup",
|
|
(field->containing_oneof() ? (", " + JSOneofArray(options, field)) : ""),
|
|
"ctor", GetMessagePath(options, field->message_type()));
|
|
}
|
|
|
|
void Generator::GenerateClassExtensionFieldInfo(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
if (IsExtendable(desc)) {
|
|
printer->Print(
|
|
"\n"
|
|
"/**\n"
|
|
" * The extensions registered with this message class. This is a "
|
|
"map of\n"
|
|
" * extension field number to fieldInfo object.\n"
|
|
" *\n"
|
|
" * For example:\n"
|
|
" * { 123: {fieldIndex: 123, fieldName: {my_field_name: 0}, "
|
|
"ctor: proto.example.MyMessage} }\n"
|
|
" *\n"
|
|
" * fieldName contains the JsCompiler renamed field name property "
|
|
"so that it\n"
|
|
" * works in OPTIMIZED mode.\n"
|
|
" *\n"
|
|
" * @type {!Object<number, jspb.ExtensionFieldInfo>}\n"
|
|
" */\n"
|
|
"$class$.extensions = {};\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, desc));
|
|
|
|
printer->Print(
|
|
"\n"
|
|
"/**\n"
|
|
" * The extensions registered with this message class. This is a "
|
|
"map of\n"
|
|
" * extension field number to fieldInfo object.\n"
|
|
" *\n"
|
|
" * For example:\n"
|
|
" * { 123: {fieldIndex: 123, fieldName: {my_field_name: 0}, "
|
|
"ctor: proto.example.MyMessage} }\n"
|
|
" *\n"
|
|
" * fieldName contains the JsCompiler renamed field name property "
|
|
"so that it\n"
|
|
" * works in OPTIMIZED mode.\n"
|
|
" *\n"
|
|
" * @type {!Object<number, jspb.ExtensionFieldBinaryInfo>}\n"
|
|
" */\n"
|
|
"$class$.extensionsBinary = {};\n"
|
|
"\n",
|
|
"class", GetMessagePath(options, desc));
|
|
}
|
|
}
|
|
|
|
|
|
void Generator::GenerateClassDeserializeBinary(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
// TODO(cfallin): Handle lazy decoding when requested by field option and/or
|
|
// by default for 'bytes' fields and packed repeated fields.
|
|
|
|
printer->Print(
|
|
"/**\n"
|
|
" * Deserializes binary data (in protobuf wire format).\n"
|
|
" * @param {jspb.ByteSource} bytes The bytes to deserialize.\n"
|
|
" * @return {!$class$}\n"
|
|
" */\n"
|
|
"$class$.deserializeBinary = function(bytes) {\n"
|
|
" var reader = new jspb.BinaryReader(bytes);\n"
|
|
" var msg = new $class$;\n"
|
|
" return $class$.deserializeBinaryFromReader(msg, reader);\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n"
|
|
"/**\n"
|
|
" * Deserializes binary data (in protobuf wire format) from the\n"
|
|
" * given reader into the given message object.\n"
|
|
" * @param {!$class$} msg The message object to deserialize into.\n"
|
|
" * @param {!jspb.BinaryReader} reader The BinaryReader to use.\n"
|
|
" * @return {!$class$}\n"
|
|
" */\n"
|
|
"$class$.deserializeBinaryFromReader = function(msg, reader) {\n"
|
|
" while (reader.nextField()) {\n"
|
|
" if (reader.isEndGroup()) {\n"
|
|
" break;\n"
|
|
" }\n"
|
|
" var field = reader.getFieldNumber();\n"
|
|
" switch (field) {\n",
|
|
"class", GetMessagePath(options, desc));
|
|
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (!IgnoreField(desc->field(i))) {
|
|
GenerateClassDeserializeBinaryField(options, printer, desc->field(i));
|
|
}
|
|
}
|
|
|
|
printer->Print(
|
|
" default:\n");
|
|
if (IsExtendable(desc)) {
|
|
printer->Print(
|
|
" jspb.Message.readBinaryExtension(msg, reader, $extobj$Binary,\n"
|
|
" $class$.prototype.getExtension,\n"
|
|
" $class$.prototype.setExtension);\n"
|
|
" break;\n",
|
|
"extobj", JSExtensionsObjectName(options, desc->file(), desc),
|
|
"class", GetMessagePath(options, desc));
|
|
} else {
|
|
printer->Print(
|
|
" reader.skipField();\n"
|
|
" break;\n");
|
|
}
|
|
|
|
printer->Print(
|
|
" }\n"
|
|
" }\n"
|
|
" return msg;\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n");
|
|
}
|
|
|
|
void Generator::GenerateClassDeserializeBinaryField(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FieldDescriptor* field) const {
|
|
|
|
printer->Print(" case $num$:\n",
|
|
"num", SimpleItoa(field->number()));
|
|
|
|
if (IsMap(options, field)) {
|
|
const FieldDescriptor* key_field = MapFieldKey(field);
|
|
const FieldDescriptor* value_field = MapFieldValue(field);
|
|
printer->Print(
|
|
" var value = msg.get$name$();\n"
|
|
" reader.readMessage(value, function(message, reader) {\n",
|
|
"name", JSGetterName(options, field));
|
|
|
|
printer->Print(" jspb.Map.deserializeBinary(message, reader, "
|
|
"$keyReaderFn$, $valueReaderFn$",
|
|
"keyReaderFn", JSBinaryReaderMethodName(options, key_field),
|
|
"valueReaderFn", JSBinaryReaderMethodName(options, value_field));
|
|
|
|
if (value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
|
|
printer->Print(", $messageType$.deserializeBinaryFromReader",
|
|
"messageType", GetMessagePath(options, value_field->message_type()));
|
|
} else {
|
|
printer->Print(", null");
|
|
}
|
|
printer->Print(", $defaultKey$",
|
|
"defaultKey", JSFieldDefault(key_field)
|
|
);
|
|
printer->Print(");\n");
|
|
printer->Print(" });\n");
|
|
} else {
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
printer->Print(
|
|
" var value = new $fieldclass$;\n"
|
|
" reader.read$msgOrGroup$($grpfield$value,"
|
|
"$fieldclass$.deserializeBinaryFromReader);\n",
|
|
"fieldclass", SubmessageTypeRef(options, field),
|
|
"msgOrGroup", (field->type() == FieldDescriptor::TYPE_GROUP) ?
|
|
"Group" : "Message",
|
|
"grpfield", (field->type() == FieldDescriptor::TYPE_GROUP) ?
|
|
(SimpleItoa(field->number()) + ", ") : "");
|
|
} else {
|
|
printer->Print(
|
|
" var value = /** @type {$fieldtype$} */ "
|
|
"(reader.read$reader$());\n",
|
|
"fieldtype", JSFieldTypeAnnotation(options, field, false, true,
|
|
/* singular_if_not_packed */ true,
|
|
BYTES_U8),
|
|
"reader",
|
|
JSBinaryReadWriteMethodName(field, /* is_writer = */ false));
|
|
}
|
|
|
|
if (field->is_repeated() && !field->is_packed()) {
|
|
printer->Print(
|
|
" msg.add$name$(value);\n", "name",
|
|
JSGetterName(options, field, BYTES_DEFAULT, /* drop_list = */ true));
|
|
} else {
|
|
// Singular fields, and packed repeated fields, receive a |value| either
|
|
// as the field's value or as the array of all the field's values; set
|
|
// this as the field's value directly.
|
|
printer->Print(
|
|
" msg.set$name$(value);\n",
|
|
"name", JSGetterName(options, field));
|
|
}
|
|
}
|
|
|
|
printer->Print(" break;\n");
|
|
}
|
|
|
|
void Generator::GenerateClassSerializeBinary(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const Descriptor* desc) const {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * Serializes the message to binary data (in protobuf wire format).\n"
|
|
" * @return {!Uint8Array}\n"
|
|
" */\n"
|
|
"$class$.prototype.serializeBinary = function() {\n"
|
|
" var writer = new jspb.BinaryWriter();\n"
|
|
" $class$.serializeBinaryToWriter(this, writer);\n"
|
|
" return writer.getResultBuffer();\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n"
|
|
"/**\n"
|
|
" * Serializes the given message to binary data (in protobuf wire\n"
|
|
" * format), writing to the given BinaryWriter.\n"
|
|
" * @param {!$class$} message\n"
|
|
" * @param {!jspb.BinaryWriter} writer\n"
|
|
" * @suppress {unusedLocalVariables} f is only used for nested messages\n"
|
|
" */\n"
|
|
"$class$.serializeBinaryToWriter = function(message, "
|
|
"writer) {\n"
|
|
" var f = undefined;\n",
|
|
"class", GetMessagePath(options, desc));
|
|
|
|
for (int i = 0; i < desc->field_count(); i++) {
|
|
if (!IgnoreField(desc->field(i))) {
|
|
GenerateClassSerializeBinaryField(options, printer, desc->field(i));
|
|
}
|
|
}
|
|
|
|
if (IsExtendable(desc)) {
|
|
printer->Print(
|
|
" jspb.Message.serializeBinaryExtensions(message, writer,\n"
|
|
" $extobj$Binary, $class$.prototype.getExtension);\n",
|
|
"extobj", JSExtensionsObjectName(options, desc->file(), desc),
|
|
"class", GetMessagePath(options, desc));
|
|
}
|
|
|
|
printer->Print(
|
|
"};\n"
|
|
"\n"
|
|
"\n");
|
|
}
|
|
|
|
void Generator::GenerateClassSerializeBinaryField(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FieldDescriptor* field) const {
|
|
if (HasFieldPresence(options, field) &&
|
|
field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
|
|
string typed_annotation = JSFieldTypeAnnotation(
|
|
options, field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ false,
|
|
/* singular_if_not_packed = */ false,
|
|
/* bytes_mode = */ BYTES_DEFAULT);
|
|
printer->Print(
|
|
" f = /** @type {$type$} */ "
|
|
"(jspb.Message.getField(message, $index$));\n",
|
|
"index", JSFieldIndex(field),
|
|
"type", typed_annotation);
|
|
} else {
|
|
printer->Print(
|
|
" f = message.get$name$($nolazy$);\n",
|
|
"name", JSGetterName(options, field, BYTES_U8),
|
|
// No lazy creation for maps containers -- fastpath the empty case.
|
|
"nolazy", IsMap(options, field) ? "true" : "");
|
|
}
|
|
|
|
// Print an `if (condition)` statement that evaluates to true if the field
|
|
// goes on the wire.
|
|
if (IsMap(options, field)) {
|
|
printer->Print(
|
|
" if (f && f.getLength() > 0) {\n");
|
|
} else if (field->is_repeated()) {
|
|
printer->Print(
|
|
" if (f.length > 0) {\n");
|
|
} else {
|
|
if (HasFieldPresence(options, field)) {
|
|
printer->Print(
|
|
" if (f != null) {\n");
|
|
} else {
|
|
// No field presence: serialize onto the wire only if value is
|
|
// non-default. Defaults are documented here:
|
|
// https://goto.google.com/lhdfm
|
|
switch (field->cpp_type()) {
|
|
case FieldDescriptor::CPPTYPE_INT32:
|
|
case FieldDescriptor::CPPTYPE_INT64:
|
|
case FieldDescriptor::CPPTYPE_UINT32:
|
|
case FieldDescriptor::CPPTYPE_UINT64: {
|
|
if (IsIntegralFieldWithStringJSType(field)) {
|
|
// We can use `parseInt` here even though it will not be precise for
|
|
// 64-bit quantities because we are only testing for zero/nonzero,
|
|
// and JS numbers (64-bit floating point values, i.e., doubles) are
|
|
// integer-precise in the range that includes zero.
|
|
printer->Print(" if (parseInt(f, 10) !== 0) {\n");
|
|
} else {
|
|
printer->Print(" if (f !== 0) {\n");
|
|
}
|
|
break;
|
|
}
|
|
|
|
case FieldDescriptor::CPPTYPE_ENUM:
|
|
case FieldDescriptor::CPPTYPE_FLOAT:
|
|
case FieldDescriptor::CPPTYPE_DOUBLE:
|
|
printer->Print(
|
|
" if (f !== 0.0) {\n");
|
|
break;
|
|
case FieldDescriptor::CPPTYPE_BOOL:
|
|
printer->Print(
|
|
" if (f) {\n");
|
|
break;
|
|
case FieldDescriptor::CPPTYPE_STRING:
|
|
printer->Print(
|
|
" if (f.length > 0) {\n");
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write the field on the wire.
|
|
if (IsMap(options, field)) {
|
|
const FieldDescriptor* key_field = MapFieldKey(field);
|
|
const FieldDescriptor* value_field = MapFieldValue(field);
|
|
printer->Print(
|
|
" f.serializeBinary($index$, writer, "
|
|
"$keyWriterFn$, $valueWriterFn$",
|
|
"index", SimpleItoa(field->number()),
|
|
"keyWriterFn", JSBinaryWriterMethodName(options, key_field),
|
|
"valueWriterFn", JSBinaryWriterMethodName(options, value_field));
|
|
|
|
if (value_field->type() == FieldDescriptor::TYPE_MESSAGE) {
|
|
printer->Print(", $messageType$.serializeBinaryToWriter",
|
|
"messageType", GetMessagePath(options, value_field->message_type()));
|
|
}
|
|
|
|
printer->Print(");\n");
|
|
} else {
|
|
printer->Print(
|
|
" writer.write$method$(\n"
|
|
" $index$,\n"
|
|
" f",
|
|
"method", JSBinaryReadWriteMethodName(field, /* is_writer = */ true),
|
|
"index", SimpleItoa(field->number()));
|
|
|
|
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
|
|
!IsMap(options, field)) {
|
|
printer->Print(
|
|
",\n"
|
|
" $submsg$.serializeBinaryToWriter\n",
|
|
"submsg", SubmessageTypeRef(options, field));
|
|
} else {
|
|
printer->Print("\n");
|
|
}
|
|
|
|
printer->Print(
|
|
" );\n");
|
|
}
|
|
|
|
// Close the `if`.
|
|
printer->Print(
|
|
" }\n");
|
|
}
|
|
|
|
void Generator::GenerateEnum(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const EnumDescriptor* enumdesc) const {
|
|
printer->Print(
|
|
"/**\n"
|
|
" * @enum {number}\n"
|
|
" */\n"
|
|
"$enumprefix$$name$ = {\n",
|
|
"enumprefix", GetEnumPathPrefix(options, enumdesc),
|
|
"name", enumdesc->name());
|
|
printer->Annotate("name", enumdesc);
|
|
|
|
for (int i = 0; i < enumdesc->value_count(); i++) {
|
|
const EnumValueDescriptor* value = enumdesc->value(i);
|
|
printer->Print(
|
|
" $name$: $value$$comma$\n",
|
|
"name", ToEnumCase(value->name()),
|
|
"value", SimpleItoa(value->number()),
|
|
"comma", (i == enumdesc->value_count() - 1) ? "" : ",");
|
|
printer->Annotate("name", value);
|
|
}
|
|
|
|
printer->Print(
|
|
"};\n"
|
|
"\n");
|
|
}
|
|
|
|
void Generator::GenerateExtension(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FieldDescriptor* field) const {
|
|
string extension_scope =
|
|
(field->extension_scope()
|
|
? GetMessagePath(options, field->extension_scope())
|
|
: GetFilePath(options, field->file()));
|
|
|
|
const string extension_object_name = JSObjectFieldName(options, field);
|
|
printer->Print(
|
|
"\n"
|
|
"/**\n"
|
|
" * A tuple of {field number, class constructor} for the extension\n"
|
|
" * field named `$nameInComment$`.\n"
|
|
" * @type {!jspb.ExtensionFieldInfo<$extensionType$>}\n"
|
|
" */\n"
|
|
"$class$.$name$ = new jspb.ExtensionFieldInfo(\n",
|
|
"nameInComment", extension_object_name,
|
|
"name", extension_object_name,
|
|
"class", extension_scope,
|
|
"extensionType", JSFieldTypeAnnotation(
|
|
options, field,
|
|
/* is_setter_argument = */ false,
|
|
/* force_present = */ true,
|
|
/* singular_if_not_packed = */ false));
|
|
printer->Annotate("name", field);
|
|
printer->Print(
|
|
" $index$,\n"
|
|
" {$name$: 0},\n"
|
|
" $ctor$,\n"
|
|
" /** @type {?function((boolean|undefined),!jspb.Message=): "
|
|
"!Object} */ (\n"
|
|
" $toObject$),\n"
|
|
" $repeated$);\n",
|
|
"index", SimpleItoa(field->number()),
|
|
"name", extension_object_name,
|
|
"ctor", (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ?
|
|
SubmessageTypeRef(options, field) : string("null")),
|
|
"toObject", (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ?
|
|
(SubmessageTypeRef(options, field) + ".toObject") :
|
|
string("null")),
|
|
"repeated", (field->is_repeated() ? "1" : "0"));
|
|
|
|
printer->Print(
|
|
"\n"
|
|
"$extendName$Binary[$index$] = new jspb.ExtensionFieldBinaryInfo(\n"
|
|
" $class$.$name$,\n"
|
|
" $binaryReaderFn$,\n"
|
|
" $binaryWriterFn$,\n"
|
|
" $binaryMessageSerializeFn$,\n"
|
|
" $binaryMessageDeserializeFn$,\n",
|
|
"extendName",
|
|
JSExtensionsObjectName(options, field->file(), field->containing_type()),
|
|
"index", SimpleItoa(field->number()), "class", extension_scope, "name",
|
|
extension_object_name, "binaryReaderFn",
|
|
JSBinaryReaderMethodName(options, field), "binaryWriterFn",
|
|
JSBinaryWriterMethodName(options, field), "binaryMessageSerializeFn",
|
|
(field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE)
|
|
? (SubmessageTypeRef(options, field) + ".serializeBinaryToWriter")
|
|
: "undefined",
|
|
"binaryMessageDeserializeFn",
|
|
(field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE)
|
|
? (SubmessageTypeRef(options, field) + ".deserializeBinaryFromReader")
|
|
: "undefined");
|
|
|
|
printer->Print(" $isPacked$);\n", "isPacked",
|
|
(field->is_packed() ? "true" : "false"));
|
|
|
|
printer->Print(
|
|
"// This registers the extension field with the extended class, so that\n"
|
|
"// toObject() will function correctly.\n"
|
|
"$extendName$[$index$] = $class$.$name$;\n"
|
|
"\n",
|
|
"extendName", JSExtensionsObjectName(options, field->file(),
|
|
field->containing_type()),
|
|
"index", SimpleItoa(field->number()),
|
|
"class", extension_scope,
|
|
"name", extension_object_name);
|
|
}
|
|
|
|
bool GeneratorOptions::ParseFromOptions(
|
|
const std::vector< std::pair< string, string > >& options,
|
|
string* error) {
|
|
for (int i = 0; i < options.size(); i++) {
|
|
if (options[i].first == "add_require_for_enums") {
|
|
if (options[i].second != "") {
|
|
*error = "Unexpected option value for add_require_for_enums";
|
|
return false;
|
|
}
|
|
add_require_for_enums = true;
|
|
} else if (options[i].first == "binary") {
|
|
if (options[i].second != "") {
|
|
*error = "Unexpected option value for binary";
|
|
return false;
|
|
}
|
|
binary = true;
|
|
} else if (options[i].first == "testonly") {
|
|
if (options[i].second != "") {
|
|
*error = "Unexpected option value for testonly";
|
|
return false;
|
|
}
|
|
testonly = true;
|
|
} else if (options[i].first == "error_on_name_conflict") {
|
|
if (options[i].second != "") {
|
|
*error = "Unexpected option value for error_on_name_conflict";
|
|
return false;
|
|
}
|
|
error_on_name_conflict = true;
|
|
} else if (options[i].first == "output_dir") {
|
|
output_dir = options[i].second;
|
|
} else if (options[i].first == "namespace_prefix") {
|
|
namespace_prefix = options[i].second;
|
|
} else if (options[i].first == "library") {
|
|
library = options[i].second;
|
|
} else if (options[i].first == "import_style") {
|
|
if (options[i].second == "closure") {
|
|
import_style = kImportClosure;
|
|
} else if (options[i].second == "commonjs") {
|
|
import_style = kImportCommonJs;
|
|
} else if (options[i].second == "browser") {
|
|
import_style = kImportBrowser;
|
|
} else if (options[i].second == "es6") {
|
|
import_style = kImportEs6;
|
|
} else {
|
|
*error = "Unknown import style " + options[i].second + ", expected " +
|
|
"one of: closure, commonjs, browser, es6.";
|
|
}
|
|
} else if (options[i].first == "extension") {
|
|
extension = options[i].second;
|
|
} else if (options[i].first == "one_output_file_per_input_file") {
|
|
if (!options[i].second.empty()) {
|
|
*error = "Unexpected option value for one_output_file_per_input_file";
|
|
return false;
|
|
}
|
|
one_output_file_per_input_file = true;
|
|
} else if (options[i].first == "annotate_code") {
|
|
if (!options[i].second.empty()) {
|
|
*error = "Unexpected option value for annotate_code";
|
|
return false;
|
|
}
|
|
annotate_code = true;
|
|
} else {
|
|
// Assume any other option is an output directory, as long as it is a bare
|
|
// `key` rather than a `key=value` option.
|
|
if (options[i].second != "") {
|
|
*error = "Unknown option: " + options[i].first;
|
|
return false;
|
|
}
|
|
output_dir = options[i].first;
|
|
}
|
|
}
|
|
|
|
if (import_style != kImportClosure &&
|
|
(add_require_for_enums || testonly || !library.empty() ||
|
|
error_on_name_conflict || extension != ".js" ||
|
|
one_output_file_per_input_file)) {
|
|
*error =
|
|
"The add_require_for_enums, testonly, library, error_on_name_conflict, "
|
|
"extension, and one_output_file_per_input_file options should only be "
|
|
"used for import_style=closure";
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
GeneratorOptions::OutputMode GeneratorOptions::output_mode() const {
|
|
// We use one output file per input file if we are not using Closure or if
|
|
// this is explicitly requested.
|
|
if (import_style != kImportClosure || one_output_file_per_input_file) {
|
|
return kOneOutputFilePerInputFile;
|
|
}
|
|
|
|
// If a library name is provided, we put everything in that one file.
|
|
if (!library.empty()) {
|
|
return kEverythingInOneFile;
|
|
}
|
|
|
|
// Otherwise, we create one output file per type.
|
|
return kOneOutputFilePerType;
|
|
}
|
|
|
|
void Generator::GenerateFilesInDepOrder(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const std::vector<const FileDescriptor*>& files) const {
|
|
// Build a std::set over all files so that the DFS can detect when it recurses
|
|
// into a dep not specified in the user's command line.
|
|
std::set<const FileDescriptor*> all_files(files.begin(), files.end());
|
|
// Track the in-progress set of files that have been generated already.
|
|
std::set<const FileDescriptor*> generated;
|
|
for (int i = 0; i < files.size(); i++) {
|
|
GenerateFileAndDeps(options, printer, files[i], &all_files, &generated);
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateFileAndDeps(
|
|
const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FileDescriptor* root,
|
|
std::set<const FileDescriptor*>* all_files,
|
|
std::set<const FileDescriptor*>* generated) const {
|
|
// Skip if already generated.
|
|
if (generated->find(root) != generated->end()) {
|
|
return;
|
|
}
|
|
generated->insert(root);
|
|
|
|
// Generate all dependencies before this file's content.
|
|
for (int i = 0; i < root->dependency_count(); i++) {
|
|
const FileDescriptor* dep = root->dependency(i);
|
|
GenerateFileAndDeps(options, printer, dep, all_files, generated);
|
|
}
|
|
|
|
// Generate this file's content. Only generate if the file is part of the
|
|
// original set requested to be generated; i.e., don't take all transitive
|
|
// deps down to the roots.
|
|
if (all_files->find(root) != all_files->end()) {
|
|
GenerateClassesAndEnums(options, printer, root);
|
|
}
|
|
}
|
|
|
|
void Generator::GenerateFile(const GeneratorOptions& options,
|
|
io::Printer* printer,
|
|
const FileDescriptor* file) const {
|
|
GenerateHeader(options, printer);
|
|
|
|
// Generate "require" statements.
|
|
if (options.import_style == GeneratorOptions::kImportCommonJs) {
|
|
printer->Print("var jspb = require('google-protobuf');\n");
|
|
printer->Print("var goog = jspb;\n");
|
|
printer->Print("var global = Function('return this')();\n\n");
|
|
|
|
for (int i = 0; i < file->dependency_count(); i++) {
|
|
const string& name = file->dependency(i)->name();
|
|
printer->Print(
|
|
"var $alias$ = require('$file$');\n",
|
|
"alias", ModuleAlias(name),
|
|
"file",
|
|
GetRootPath(file->name(), name) + GetJSFilename(options, name));
|
|
}
|
|
}
|
|
|
|
std::set<string> provided;
|
|
std::set<const FieldDescriptor*> extensions;
|
|
for (int i = 0; i < file->extension_count(); i++) {
|
|
// We honor the jspb::ignore option here only when working with
|
|
// Closure-style imports. Use of this option is discouraged and so we want
|
|
// to avoid adding new support for it.
|
|
if (options.import_style == GeneratorOptions::kImportClosure &&
|
|
IgnoreField(file->extension(i))) {
|
|
continue;
|
|
}
|
|
provided.insert(GetFilePath(options, file) + "." +
|
|
JSObjectFieldName(options, file->extension(i)));
|
|
extensions.insert(file->extension(i));
|
|
}
|
|
|
|
FindProvidesForFile(options, printer, file, &provided);
|
|
GenerateProvides(options, printer, &provided);
|
|
std::vector<const FileDescriptor*> files;
|
|
files.push_back(file);
|
|
if (options.import_style == GeneratorOptions::kImportClosure) {
|
|
GenerateRequiresForLibrary(options, printer, files, &provided);
|
|
}
|
|
|
|
GenerateClassesAndEnums(options, printer, file);
|
|
|
|
// Generate code for top-level extensions. Extensions nested inside messages
|
|
// are emitted inside GenerateClassesAndEnums().
|
|
for (std::set<const FieldDescriptor*>::const_iterator it = extensions.begin();
|
|
it != extensions.end(); ++it) {
|
|
GenerateExtension(options, printer, *it);
|
|
}
|
|
|
|
if (options.import_style == GeneratorOptions::kImportCommonJs) {
|
|
printer->Print("goog.object.extend(exports, $package$);\n",
|
|
"package", GetFilePath(options, file));
|
|
}
|
|
|
|
// Emit well-known type methods.
|
|
for (FileToc* toc = well_known_types_js; toc->name != NULL; toc++) {
|
|
string name = string("google/protobuf/") + toc->name;
|
|
if (name == StripProto(file->name()) + ".js") {
|
|
printer->Print(toc->data);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Generator::GenerateAll(const std::vector<const FileDescriptor*>& files,
|
|
const string& parameter,
|
|
GeneratorContext* context,
|
|
string* error) const {
|
|
std::vector< std::pair< string, string > > option_pairs;
|
|
ParseGeneratorParameter(parameter, &option_pairs);
|
|
GeneratorOptions options;
|
|
if (!options.ParseFromOptions(option_pairs, error)) {
|
|
return false;
|
|
}
|
|
|
|
|
|
if (options.output_mode() == GeneratorOptions::kEverythingInOneFile) {
|
|
// All output should go in a single file.
|
|
string filename = options.output_dir + "/" + options.library +
|
|
options.GetFileNameExtension();
|
|
std::unique_ptr<io::ZeroCopyOutputStream> output(context->Open(filename));
|
|
GOOGLE_CHECK(output.get());
|
|
io::Printer printer(output.get(), '$');
|
|
|
|
// Pull out all extensions -- we need these to generate all
|
|
// provides/requires.
|
|
std::vector<const FieldDescriptor*> extensions;
|
|
for (int i = 0; i < files.size(); i++) {
|
|
for (int j = 0; j < files[i]->extension_count(); j++) {
|
|
const FieldDescriptor* extension = files[i]->extension(j);
|
|
extensions.push_back(extension);
|
|
}
|
|
}
|
|
|
|
GenerateHeader(options, &printer);
|
|
|
|
std::set<string> provided;
|
|
FindProvides(options, &printer, files, &provided);
|
|
FindProvidesForFields(options, &printer, extensions, &provided);
|
|
GenerateProvides(options, &printer, &provided);
|
|
GenerateTestOnly(options, &printer);
|
|
GenerateRequiresForLibrary(options, &printer, files, &provided);
|
|
|
|
GenerateFilesInDepOrder(options, &printer, files);
|
|
|
|
for (int i = 0; i < extensions.size(); i++) {
|
|
if (ShouldGenerateExtension(extensions[i])) {
|
|
GenerateExtension(options, &printer, extensions[i]);
|
|
}
|
|
}
|
|
|
|
if (printer.failed()) {
|
|
return false;
|
|
}
|
|
} else if (options.output_mode() == GeneratorOptions::kOneOutputFilePerType) {
|
|
std::set<const void*> allowed_set;
|
|
if (!GenerateJspbAllowedSet(options, files, &allowed_set, error)) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < files.size(); i++) {
|
|
const FileDescriptor* file = files[i];
|
|
for (int j = 0; j < file->message_type_count(); j++) {
|
|
const Descriptor* desc = file->message_type(j);
|
|
if (allowed_set.count(desc) == 0) {
|
|
continue;
|
|
}
|
|
|
|
string filename = GetMessageFileName(options, desc);
|
|
std::unique_ptr<io::ZeroCopyOutputStream> output(
|
|
context->Open(filename));
|
|
GOOGLE_CHECK(output.get());
|
|
io::Printer printer(output.get(), '$');
|
|
|
|
GenerateHeader(options, &printer);
|
|
|
|
std::set<string> provided;
|
|
FindProvidesForMessage(options, &printer, desc, &provided);
|
|
GenerateProvides(options, &printer, &provided);
|
|
GenerateTestOnly(options, &printer);
|
|
GenerateRequiresForMessage(options, &printer, desc, &provided);
|
|
|
|
GenerateClass(options, &printer, desc);
|
|
|
|
if (printer.failed()) {
|
|
return false;
|
|
}
|
|
}
|
|
for (int j = 0; j < file->enum_type_count(); j++) {
|
|
const EnumDescriptor* enumdesc = file->enum_type(j);
|
|
if (allowed_set.count(enumdesc) == 0) {
|
|
continue;
|
|
}
|
|
|
|
string filename = GetEnumFileName(options, enumdesc);
|
|
std::unique_ptr<io::ZeroCopyOutputStream> output(
|
|
context->Open(filename));
|
|
GOOGLE_CHECK(output.get());
|
|
io::Printer printer(output.get(), '$');
|
|
|
|
GenerateHeader(options, &printer);
|
|
|
|
std::set<string> provided;
|
|
FindProvidesForEnum(options, &printer, enumdesc, &provided);
|
|
GenerateProvides(options, &printer, &provided);
|
|
GenerateTestOnly(options, &printer);
|
|
|
|
GenerateEnum(options, &printer, enumdesc);
|
|
|
|
if (printer.failed()) {
|
|
return false;
|
|
}
|
|
}
|
|
// File-level extensions (message-level extensions are generated under
|
|
// the enclosing message).
|
|
if (allowed_set.count(file) == 1) {
|
|
string filename = GetExtensionFileName(options, file);
|
|
|
|
std::unique_ptr<io::ZeroCopyOutputStream> output(
|
|
context->Open(filename));
|
|
GOOGLE_CHECK(output.get());
|
|
io::Printer printer(output.get(), '$');
|
|
|
|
GenerateHeader(options, &printer);
|
|
|
|
std::set<string> provided;
|
|
std::vector<const FieldDescriptor*> fields;
|
|
|
|
for (int j = 0; j < files[i]->extension_count(); j++) {
|
|
if (ShouldGenerateExtension(files[i]->extension(j))) {
|
|
fields.push_back(files[i]->extension(j));
|
|
}
|
|
}
|
|
|
|
FindProvidesForFields(options, &printer, fields, &provided);
|
|
GenerateProvides(options, &printer, &provided);
|
|
GenerateTestOnly(options, &printer);
|
|
GenerateRequiresForExtensions(options, &printer, fields, &provided);
|
|
|
|
for (int j = 0; j < files[i]->extension_count(); j++) {
|
|
if (ShouldGenerateExtension(files[i]->extension(j))) {
|
|
GenerateExtension(options, &printer, files[i]->extension(j));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else /* options.output_mode() == kOneOutputFilePerInputFile */ {
|
|
// Generate one output file per input (.proto) file.
|
|
|
|
for (int i = 0; i < files.size(); i++) {
|
|
const google::protobuf::FileDescriptor* file = files[i];
|
|
|
|
string filename =
|
|
options.output_dir + "/" + GetJSFilename(options, file->name());
|
|
std::unique_ptr<io::ZeroCopyOutputStream> output(context->Open(filename));
|
|
GOOGLE_CHECK(output.get());
|
|
GeneratedCodeInfo annotations;
|
|
io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
|
|
&annotations);
|
|
io::Printer printer(output.get(), '$',
|
|
options.annotate_code ? &annotation_collector : NULL);
|
|
|
|
|
|
GenerateFile(options, &printer, file);
|
|
|
|
if (printer.failed()) {
|
|
return false;
|
|
}
|
|
|
|
if (options.annotate_code) {
|
|
EmbedCodeAnnotations(annotations, &printer);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace js
|
|
} // namespace compiler
|
|
} // namespace protobuf
|
|
} // namespace google
|