• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc.  All rights reserved.
3 // http://code.google.com/p/protobuf/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 //     * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 //     * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 //     * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31 // Author: kenton@google.com (Kenton Varda)
32 //  Based on original Protocol Buffers design by
33 //  Sanjay Ghemawat, Jeff Dean, and others.
34 
35 #include <limits>
36 #include <unordered_set>
37 #include <vector>
38 
39 #include <google/protobuf/compiler/javanano/javanano_helpers.h>
40 #include <google/protobuf/compiler/javanano/javanano_params.h>
41 #include <google/protobuf/descriptor.pb.h>
42 #include <google/protobuf/stubs/strutil.h>
43 #include <google/protobuf/stubs/substitute.h>
44 
45 namespace google {
46 namespace protobuf {
47 namespace compiler {
48 namespace javanano {
49 
50 const char kThickSeparator[] =
51   "// ===================================================================\n";
52 const char kThinSeparator[] =
53   "// -------------------------------------------------------------------\n";
54 
55 class RenameKeywords {
56  private:
57   std::unordered_set<string> java_keywords_set_;
58 
59  public:
RenameKeywords()60   RenameKeywords() {
61     static const char* kJavaKeywordsList[] = {
62       // Reserved Java Keywords
63       "abstract", "assert", "boolean", "break", "byte", "case", "catch",
64       "char", "class", "const", "continue", "default", "do", "double", "else",
65       "enum", "extends", "final", "finally", "float", "for", "goto", "if",
66       "implements", "import", "instanceof", "int", "interface", "long",
67       "native", "new", "package", "private", "protected", "public", "return",
68       "short", "static", "strictfp", "super", "switch", "synchronized",
69       "this", "throw", "throws", "transient", "try", "void", "volatile", "while",
70 
71       // Reserved Keywords for Literals
72       "false", "null", "true"
73     };
74 
75     for (int i = 0; i < GOOGLE_ARRAYSIZE(kJavaKeywordsList); i++) {
76       java_keywords_set_.insert(kJavaKeywordsList[i]);
77     }
78   }
79 
80   // Used to rename the a field name if it's a java keyword.  Specifically
81   // this is used to rename the ["name"] or ["capitalized_name"] field params.
82   // (http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html)
RenameJavaKeywordsImpl(const string & input)83   string RenameJavaKeywordsImpl(const string& input) {
84     string result = input;
85 
86     if (java_keywords_set_.find(result) != java_keywords_set_.end()) {
87       result += "_";
88     }
89 
90     return result;
91   }
92 
93 };
94 
95 static RenameKeywords sRenameKeywords;
96 
97 namespace {
98 
99 const char* kDefaultPackage = "";
100 
FieldName(const FieldDescriptor * field)101 const string& FieldName(const FieldDescriptor* field) {
102   // Groups are hacky:  The name of the field is just the lower-cased name
103   // of the group type.  In Java, though, we would like to retain the original
104   // capitalization of the type name.
105   if (field->type() == FieldDescriptor::TYPE_GROUP) {
106     return field->message_type()->name();
107   } else {
108     return field->name();
109   }
110 }
111 
UnderscoresToCamelCaseImpl(const string & input,bool cap_next_letter)112 string UnderscoresToCamelCaseImpl(const string& input, bool cap_next_letter) {
113   string result;
114   // Note:  I distrust ctype.h due to locales.
115   for (int i = 0; i < input.size(); i++) {
116     if ('a' <= input[i] && input[i] <= 'z') {
117       if (cap_next_letter) {
118         result += input[i] + ('A' - 'a');
119       } else {
120         result += input[i];
121       }
122       cap_next_letter = false;
123     } else if ('A' <= input[i] && input[i] <= 'Z') {
124       if (i == 0 && !cap_next_letter) {
125         // Force first letter to lower-case unless explicitly told to
126         // capitalize it.
127         result += input[i] + ('a' - 'A');
128       } else {
129         // Capital letters after the first are left as-is.
130         result += input[i];
131       }
132       cap_next_letter = false;
133     } else if ('0' <= input[i] && input[i] <= '9') {
134       result += input[i];
135       cap_next_letter = true;
136     } else {
137       cap_next_letter = true;
138     }
139   }
140   return result;
141 }
142 
143 }  // namespace
144 
UnderscoresToCamelCase(const FieldDescriptor * field)145 string UnderscoresToCamelCase(const FieldDescriptor* field) {
146   return UnderscoresToCamelCaseImpl(FieldName(field), false);
147 }
148 
UnderscoresToCapitalizedCamelCase(const FieldDescriptor * field)149 string UnderscoresToCapitalizedCamelCase(const FieldDescriptor* field) {
150   return UnderscoresToCamelCaseImpl(FieldName(field), true);
151 }
152 
UnderscoresToCamelCase(const MethodDescriptor * method)153 string UnderscoresToCamelCase(const MethodDescriptor* method) {
154   return UnderscoresToCamelCaseImpl(method->name(), false);
155 }
156 
UnderscoresToCamelCase(const OneofDescriptor * oneof)157 string UnderscoresToCamelCase(const OneofDescriptor* oneof) {
158   return UnderscoresToCamelCaseImpl(oneof->name(), false);
159 }
160 
UnderscoresToCapitalizedCamelCase(const OneofDescriptor * oneof)161 string UnderscoresToCapitalizedCamelCase(const OneofDescriptor* oneof) {
162   return UnderscoresToCamelCaseImpl(oneof->name(), true);
163 }
164 
RenameJavaKeywords(const string & input)165 string RenameJavaKeywords(const string& input) {
166   return sRenameKeywords.RenameJavaKeywordsImpl(input);
167 }
168 
StripProto(const string & filename)169 string StripProto(const string& filename) {
170   if (HasSuffixString(filename, ".protodevel")) {
171     return StripSuffixString(filename, ".protodevel");
172   } else {
173     return StripSuffixString(filename, ".proto");
174   }
175 }
176 
FileClassName(const Params & params,const FileDescriptor * file)177 string FileClassName(const Params& params, const FileDescriptor* file) {
178   if (params.has_java_outer_classname(file->name())) {
179     return params.java_outer_classname(file->name());
180   } else {
181     // Use the filename itself with underscores removed
182     // and a CamelCase style name.
183     string basename;
184     string::size_type last_slash = file->name().find_last_of('/');
185     if (last_slash == string::npos) {
186       basename = file->name();
187     } else {
188       basename = file->name().substr(last_slash + 1);
189     }
190     return UnderscoresToCamelCaseImpl(StripProto(basename), true);
191   }
192 }
193 
FileJavaPackage(const Params & params,const FileDescriptor * file)194 string FileJavaPackage(const Params& params, const FileDescriptor* file) {
195   if (params.has_java_package(file->name())) {
196     return params.java_package(file->name());
197   } else {
198     string result = kDefaultPackage;
199     if (!file->package().empty()) {
200       if (!result.empty()) result += '.';
201       result += file->package();
202     }
203 
204     if (!result.empty()) {
205       result += ".";
206     }
207     result += "nano";
208 
209     return result;
210   }
211 }
212 
IsOuterClassNeeded(const Params & params,const FileDescriptor * file)213 bool IsOuterClassNeeded(const Params& params, const FileDescriptor* file) {
214   // If java_multiple_files is false, the outer class is always needed.
215   if (!params.java_multiple_files(file->name())) {
216     return true;
217   }
218 
219   // File-scope extensions need the outer class as the scope.
220   if (file->extension_count() != 0) {
221     return true;
222   }
223 
224   // If container interfaces are not generated, file-scope enums need the
225   // outer class as the scope.
226   if (file->enum_type_count() != 0 && !params.java_enum_style()) {
227     return true;
228   }
229 
230   return false;
231 }
232 
ToJavaName(const Params & params,const string & name,bool is_class,const Descriptor * parent,const FileDescriptor * file)233 string ToJavaName(const Params& params, const string& name, bool is_class,
234     const Descriptor* parent, const FileDescriptor* file) {
235   string result;
236   if (parent != NULL) {
237     result.append(ClassName(params, parent));
238   } else if (is_class && params.java_multiple_files(file->name())) {
239     result.append(FileJavaPackage(params, file));
240   } else {
241     result.append(ClassName(params, file));
242   }
243   if (!result.empty()) result.append(1, '.');
244   result.append(RenameJavaKeywords(name));
245   return result;
246 }
247 
ClassName(const Params & params,const FileDescriptor * descriptor)248 string ClassName(const Params& params, const FileDescriptor* descriptor) {
249   string result = FileJavaPackage(params, descriptor);
250   if (!result.empty()) result += '.';
251   result += FileClassName(params, descriptor);
252   return result;
253 }
254 
ClassName(const Params & params,const EnumDescriptor * descriptor)255 string ClassName(const Params& params, const EnumDescriptor* descriptor) {
256   const Descriptor* parent = descriptor->containing_type();
257   // When using Java enum style, an enum's class name contains the enum name.
258   // Use the standard ToJavaName translation.
259   if (params.java_enum_style()) {
260     return ToJavaName(params, descriptor->name(), true, parent,
261                       descriptor->file());
262   }
263   // Otherwise the enum members are accessed from the enclosing class.
264   if (parent != NULL) {
265     return ClassName(params, parent);
266   } else {
267     return ClassName(params, descriptor->file());
268   }
269 }
270 
FieldConstantName(const FieldDescriptor * field)271 string FieldConstantName(const FieldDescriptor *field) {
272   string name = field->name() + "_FIELD_NUMBER";
273   UpperString(&name);
274   return name;
275 }
276 
FieldDefaultConstantName(const FieldDescriptor * field)277 string FieldDefaultConstantName(const FieldDescriptor *field) {
278   return "_" + RenameJavaKeywords(UnderscoresToCamelCase(field)) + "Default";
279 }
280 
PrintFieldComment(io::Printer * printer,const FieldDescriptor * field)281 void PrintFieldComment(io::Printer* printer, const FieldDescriptor* field) {
282   // We don't want to print group bodies so we cut off after the first line
283   // (the second line for extensions).
284   string def = field->DebugString();
285   string::size_type first_line_end = def.find_first_of('\n');
286   printer->Print("// $def$\n",
287     "def", def.substr(0, first_line_end));
288   if (field->is_extension()) {
289     string::size_type second_line_start = first_line_end + 1;
290     string::size_type second_line_length =
291         def.find('\n', second_line_start) - second_line_start;
292     printer->Print("// $def$\n",
293       "def", def.substr(second_line_start, second_line_length));
294   }
295 }
296 
GetJavaType(FieldDescriptor::Type field_type)297 JavaType GetJavaType(FieldDescriptor::Type field_type) {
298   switch (field_type) {
299     case FieldDescriptor::TYPE_INT32:
300     case FieldDescriptor::TYPE_UINT32:
301     case FieldDescriptor::TYPE_SINT32:
302     case FieldDescriptor::TYPE_FIXED32:
303     case FieldDescriptor::TYPE_SFIXED32:
304       return JAVATYPE_INT;
305 
306     case FieldDescriptor::TYPE_INT64:
307     case FieldDescriptor::TYPE_UINT64:
308     case FieldDescriptor::TYPE_SINT64:
309     case FieldDescriptor::TYPE_FIXED64:
310     case FieldDescriptor::TYPE_SFIXED64:
311       return JAVATYPE_LONG;
312 
313     case FieldDescriptor::TYPE_FLOAT:
314       return JAVATYPE_FLOAT;
315 
316     case FieldDescriptor::TYPE_DOUBLE:
317       return JAVATYPE_DOUBLE;
318 
319     case FieldDescriptor::TYPE_BOOL:
320       return JAVATYPE_BOOLEAN;
321 
322     case FieldDescriptor::TYPE_STRING:
323       return JAVATYPE_STRING;
324 
325     case FieldDescriptor::TYPE_BYTES:
326       return JAVATYPE_BYTES;
327 
328     case FieldDescriptor::TYPE_ENUM:
329       return JAVATYPE_ENUM;
330 
331     case FieldDescriptor::TYPE_GROUP:
332     case FieldDescriptor::TYPE_MESSAGE:
333       return JAVATYPE_MESSAGE;
334 
335     // No default because we want the compiler to complain if any new
336     // types are added.
337   }
338 
339   GOOGLE_LOG(FATAL) << "Can't get here.";
340   return JAVATYPE_INT;
341 }
342 
PrimitiveTypeName(JavaType type)343 string PrimitiveTypeName(JavaType type) {
344   switch (type) {
345     case JAVATYPE_INT    : return "int";
346     case JAVATYPE_LONG   : return "long";
347     case JAVATYPE_FLOAT  : return "float";
348     case JAVATYPE_DOUBLE : return "double";
349     case JAVATYPE_BOOLEAN: return "boolean";
350     case JAVATYPE_STRING : return "java.lang.String";
351     case JAVATYPE_BYTES  : return "byte[]";
352     case JAVATYPE_ENUM   : return "int";
353     case JAVATYPE_MESSAGE: return "";
354 
355     // No default because we want the compiler to complain if any new
356     // JavaTypes are added.
357   }
358 
359   GOOGLE_LOG(FATAL) << "Can't get here.";
360   return "";
361 }
362 
BoxedPrimitiveTypeName(JavaType type)363 string BoxedPrimitiveTypeName(JavaType type) {
364   switch (type) {
365     case JAVATYPE_INT    : return "java.lang.Integer";
366     case JAVATYPE_LONG   : return "java.lang.Long";
367     case JAVATYPE_FLOAT  : return "java.lang.Float";
368     case JAVATYPE_DOUBLE : return "java.lang.Double";
369     case JAVATYPE_BOOLEAN: return "java.lang.Boolean";
370     case JAVATYPE_STRING : return "java.lang.String";
371     case JAVATYPE_BYTES  : return "byte[]";
372     case JAVATYPE_ENUM   : return "java.lang.Integer";
373     case JAVATYPE_MESSAGE: return "";
374 
375     // No default because we want the compiler to complain if any new
376     // JavaTypes are added.
377   }
378 
379   GOOGLE_LOG(FATAL) << "Can't get here.";
380   return "";
381 }
382 
EmptyArrayName(const Params & params,const FieldDescriptor * field)383 string EmptyArrayName(const Params& params, const FieldDescriptor* field) {
384   switch (GetJavaType(field)) {
385     case JAVATYPE_INT    : return "com.google.protobuf.nano.WireFormatNano.EMPTY_INT_ARRAY";
386     case JAVATYPE_LONG   : return "com.google.protobuf.nano.WireFormatNano.EMPTY_LONG_ARRAY";
387     case JAVATYPE_FLOAT  : return "com.google.protobuf.nano.WireFormatNano.EMPTY_FLOAT_ARRAY";
388     case JAVATYPE_DOUBLE : return "com.google.protobuf.nano.WireFormatNano.EMPTY_DOUBLE_ARRAY";
389     case JAVATYPE_BOOLEAN: return "com.google.protobuf.nano.WireFormatNano.EMPTY_BOOLEAN_ARRAY";
390     case JAVATYPE_STRING : return "com.google.protobuf.nano.WireFormatNano.EMPTY_STRING_ARRAY";
391     case JAVATYPE_BYTES  : return "com.google.protobuf.nano.WireFormatNano.EMPTY_BYTES_ARRAY";
392     case JAVATYPE_ENUM   : return "com.google.protobuf.nano.WireFormatNano.EMPTY_INT_ARRAY";
393     case JAVATYPE_MESSAGE: return ClassName(params, field->message_type()) + ".EMPTY_ARRAY";
394 
395     // No default because we want the compiler to complain if any new
396     // JavaTypes are added.
397   }
398 
399   GOOGLE_LOG(FATAL) << "Can't get here.";
400   return "";
401 }
402 
DefaultValue(const Params & params,const FieldDescriptor * field)403 string DefaultValue(const Params& params, const FieldDescriptor* field) {
404   if (field->label() == FieldDescriptor::LABEL_REPEATED) {
405     return EmptyArrayName(params, field);
406   }
407 
408   if (params.use_reference_types_for_primitives()) {
409     if (params.reftypes_primitive_enums()
410           && field->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) {
411       return "Integer.MIN_VALUE";
412     }
413     return "null";
414   }
415 
416   // Switch on cpp_type since we need to know which default_value_* method
417   // of FieldDescriptor to call.
418   switch (field->cpp_type()) {
419     case FieldDescriptor::CPPTYPE_INT32:
420       return SimpleItoa(field->default_value_int32());
421     case FieldDescriptor::CPPTYPE_UINT32:
422       // Need to print as a signed int since Java has no unsigned.
423       return SimpleItoa(static_cast<int32>(field->default_value_uint32()));
424     case FieldDescriptor::CPPTYPE_INT64:
425       return SimpleItoa(field->default_value_int64()) + "L";
426     case FieldDescriptor::CPPTYPE_UINT64:
427       return SimpleItoa(static_cast<int64>(field->default_value_uint64())) +
428              "L";
429     case FieldDescriptor::CPPTYPE_DOUBLE: {
430       double value = field->default_value_double();
431       if (value == std::numeric_limits<double>::infinity()) {
432         return "Double.POSITIVE_INFINITY";
433       } else if (value == -std::numeric_limits<double>::infinity()) {
434         return "Double.NEGATIVE_INFINITY";
435       } else if (value != value) {
436         return "Double.NaN";
437       } else {
438         return SimpleDtoa(value) + "D";
439       }
440     }
441     case FieldDescriptor::CPPTYPE_FLOAT: {
442       float value = field->default_value_float();
443       if (value == std::numeric_limits<float>::infinity()) {
444         return "Float.POSITIVE_INFINITY";
445       } else if (value == -std::numeric_limits<float>::infinity()) {
446         return "Float.NEGATIVE_INFINITY";
447       } else if (value != value) {
448         return "Float.NaN";
449       } else {
450         return SimpleFtoa(value) + "F";
451       }
452     }
453     case FieldDescriptor::CPPTYPE_BOOL:
454       return field->default_value_bool() ? "true" : "false";
455     case FieldDescriptor::CPPTYPE_STRING:
456       if (!field->default_value_string().empty()) {
457         // Point it to the static final in the generated code.
458         return FieldDefaultConstantName(field);
459       } else {
460         if (field->type() == FieldDescriptor::TYPE_BYTES) {
461           return "com.google.protobuf.nano.WireFormatNano.EMPTY_BYTES";
462         } else {
463           return "\"\"";
464         }
465       }
466 
467     case FieldDescriptor::CPPTYPE_ENUM:
468       return ClassName(params, field->enum_type()) + "." +
469              RenameJavaKeywords(field->default_value_enum()->name());
470 
471     case FieldDescriptor::CPPTYPE_MESSAGE:
472       return "null";
473 
474     // No default because we want the compiler to complain if any new
475     // types are added.
476   }
477 
478   GOOGLE_LOG(FATAL) << "Can't get here.";
479   return "";
480 }
481 
482 
483 static const char* kBitMasks[] = {
484   "0x00000001",
485   "0x00000002",
486   "0x00000004",
487   "0x00000008",
488   "0x00000010",
489   "0x00000020",
490   "0x00000040",
491   "0x00000080",
492 
493   "0x00000100",
494   "0x00000200",
495   "0x00000400",
496   "0x00000800",
497   "0x00001000",
498   "0x00002000",
499   "0x00004000",
500   "0x00008000",
501 
502   "0x00010000",
503   "0x00020000",
504   "0x00040000",
505   "0x00080000",
506   "0x00100000",
507   "0x00200000",
508   "0x00400000",
509   "0x00800000",
510 
511   "0x01000000",
512   "0x02000000",
513   "0x04000000",
514   "0x08000000",
515   "0x10000000",
516   "0x20000000",
517   "0x40000000",
518   "0x80000000",
519 };
520 
GetBitFieldName(int index)521 string GetBitFieldName(int index) {
522   string var_name = "bitField";
523   var_name += SimpleItoa(index);
524   var_name += "_";
525   return var_name;
526 }
527 
GetBitFieldNameForBit(int bit_index)528 string GetBitFieldNameForBit(int bit_index) {
529   return GetBitFieldName(bit_index / 32);
530 }
531 
GenerateGetBit(int bit_index)532 string GenerateGetBit(int bit_index) {
533   string var_name = GetBitFieldNameForBit(bit_index);
534   int bit_in_var_index = bit_index % 32;
535 
536   string mask = kBitMasks[bit_in_var_index];
537   string result = "((" + var_name + " & " + mask + ") != 0)";
538   return result;
539 }
540 
GenerateSetBit(int bit_index)541 string GenerateSetBit(int bit_index) {
542   string var_name = GetBitFieldNameForBit(bit_index);
543   int bit_in_var_index = bit_index % 32;
544 
545   string mask = kBitMasks[bit_in_var_index];
546   string result = var_name + " |= " + mask;
547   return result;
548 }
549 
GenerateClearBit(int bit_index)550 string GenerateClearBit(int bit_index) {
551   string var_name = GetBitFieldNameForBit(bit_index);
552   int bit_in_var_index = bit_index % 32;
553 
554   string mask = kBitMasks[bit_in_var_index];
555   string result = var_name + " = (" + var_name + " & ~" + mask + ")";
556   return result;
557 }
558 
GenerateDifferentBit(int bit_index)559 string GenerateDifferentBit(int bit_index) {
560   string var_name = GetBitFieldNameForBit(bit_index);
561   int bit_in_var_index = bit_index % 32;
562 
563   string mask = kBitMasks[bit_in_var_index];
564   string result = "((" + var_name + " & " + mask
565       + ") != (other." + var_name + " & " + mask + "))";
566   return result;
567 }
568 
SetBitOperationVariables(const string name,int bitIndex,std::map<string,string> * variables)569 void SetBitOperationVariables(const string name,
570     int bitIndex, std::map<string, string>* variables) {
571   (*variables)["get_" + name] = GenerateGetBit(bitIndex);
572   (*variables)["set_" + name] = GenerateSetBit(bitIndex);
573   (*variables)["clear_" + name] = GenerateClearBit(bitIndex);
574   (*variables)["different_" + name] = GenerateDifferentBit(bitIndex);
575 }
576 
HasMapField(const Descriptor * descriptor)577 bool HasMapField(const Descriptor* descriptor) {
578   for (int i = 0; i < descriptor->field_count(); ++i) {
579     const FieldDescriptor* field = descriptor->field(i);
580     if (field->type() == FieldDescriptor::TYPE_MESSAGE &&
581         IsMapEntry(field->message_type())) {
582       return true;
583     }
584   }
585   return false;
586 }
587 
588 }  // namespace javanano
589 }  // namespace compiler
590 }  // namespace protobuf
591 }  // namespace google
592