1 /* 2 * Copyright 2016 Google Inc. All rights reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "flatbuffers/code_generators.h" 18 #include <assert.h> 19 #include "flatbuffers/util.h" 20 21 namespace flatbuffers { 22 23 void CodeWriter::operator+=(std::string text) { 24 25 while (true) { 26 auto begin = text.find("{{"); 27 if (begin == std::string::npos) { 28 break; 29 } 30 31 auto end = text.find("}}"); 32 if (end == std::string::npos || end < begin) { 33 break; 34 } 35 36 // Write all the text before the first {{ into the stream. 37 stream_.write(text.c_str(), begin); 38 39 // The key is between the {{ and }}. 40 const std::string key = text.substr(begin + 2, end - begin - 2); 41 42 // Find the value associated with the key. If it exists, write the 43 // value into the stream, otherwise write the key itself into the stream. 44 auto iter = value_map_.find(key); 45 if (iter != value_map_.end()) { 46 const std::string &value = iter->second; 47 stream_ << value; 48 } else { 49 assert(false && "could not find key"); 50 stream_ << key; 51 } 52 53 // Update the text to everything after the }}. 54 text = text.substr(end + 2); 55 } 56 if (!text.empty() && text.back() == '\\') { 57 text.pop_back(); 58 stream_ << text; 59 } else { 60 stream_ << text << std::endl; 61 } 62 } 63 64 const char *BaseGenerator::FlatBuffersGeneratedWarning() { 65 return "automatically generated by the FlatBuffers compiler," 66 " do not modify\n\n"; 67 } 68 69 std::string BaseGenerator::NamespaceDir(const Parser &parser, 70 const std::string &path, 71 const Namespace &ns) { 72 EnsureDirExists(path.c_str()); 73 if (parser.opts.one_file) return path; 74 std::string namespace_dir = path; // Either empty or ends in separator. 75 auto &namespaces = ns.components; 76 for (auto it = namespaces.begin(); it != namespaces.end(); ++it) { 77 namespace_dir += *it + kPathSeparator; 78 EnsureDirExists(namespace_dir.c_str()); 79 } 80 return namespace_dir; 81 } 82 83 std::string BaseGenerator::NamespaceDir(const Namespace &ns) const { 84 return BaseGenerator::NamespaceDir(parser_, path_, ns); 85 } 86 87 bool BaseGenerator::IsEverythingGenerated() const { 88 for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); 89 ++it) { 90 if (!(*it)->generated) return false; 91 } 92 for (auto it = parser_.structs_.vec.begin(); 93 it != parser_.structs_.vec.end(); ++it) { 94 if (!(*it)->generated) return false; 95 } 96 return true; 97 } 98 99 std::string BaseGenerator::FullNamespace(const char *separator, 100 const Namespace &ns) { 101 std::string namespace_name; 102 auto &namespaces = ns.components; 103 for (auto it = namespaces.begin(); it != namespaces.end(); ++it) { 104 if (namespace_name.length()) namespace_name += separator; 105 namespace_name += *it; 106 } 107 return namespace_name; 108 } 109 110 std::string BaseGenerator::LastNamespacePart(const Namespace &ns) { 111 if (!ns.components.empty()) 112 return ns.components.back(); 113 else 114 return std::string(""); 115 } 116 117 // Ensure that a type is prefixed with its namespace whenever it is used 118 // outside of its namespace. 119 std::string BaseGenerator::WrapInNameSpace(const Namespace *ns, 120 const std::string &name) const { 121 if (CurrentNameSpace() == ns) return name; 122 std::string qualified_name = qualifying_start_; 123 for (auto it = ns->components.begin(); it != ns->components.end(); ++it) 124 qualified_name += *it + qualifying_separator_; 125 return qualified_name + name; 126 } 127 128 129 std::string BaseGenerator::WrapInNameSpace(const Definition &def) const { 130 return WrapInNameSpace(def.defined_namespace, def.name); 131 } 132 133 // Generate a documentation comment, if available. 134 void GenComment(const std::vector<std::string> &dc, std::string *code_ptr, 135 const CommentConfig *config, const char *prefix) { 136 if (dc.begin() == dc.end()) { 137 // Don't output empty comment blocks with 0 lines of comment content. 138 return; 139 } 140 141 std::string &code = *code_ptr; 142 if (config != nullptr && config->first_line != nullptr) { 143 code += std::string(prefix) + std::string(config->first_line) + "\n"; 144 } 145 std::string line_prefix = std::string(prefix) + 146 ((config != nullptr && config->content_line_prefix != nullptr) ? 147 config->content_line_prefix : "///"); 148 for (auto it = dc.begin(); 149 it != dc.end(); 150 ++it) { 151 code += line_prefix + *it + "\n"; 152 } 153 if (config != nullptr && config->last_line != nullptr) { 154 code += std::string(prefix) + std::string(config->last_line) + "\n"; 155 } 156 } 157 158 } // namespace flatbuffers 159