1 | /* |
2 | * Copyright 2018 Dan Field |
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 | // independent from idl_parser, since this code is not needed for most clients |
18 | #include <cassert> |
19 | |
20 | #include "flatbuffers/code_generators.h" |
21 | #include "flatbuffers/flatbuffers.h" |
22 | #include "flatbuffers/idl.h" |
23 | #include "flatbuffers/util.h" |
24 | |
25 | namespace flatbuffers { |
26 | |
27 | namespace dart { |
28 | |
29 | const std::string _kFb = "fb" ; |
30 | // see https://www.dartlang.org/guides/language/language-tour#keywords |
31 | // yeild*, async*, and sync* shouldn't be problems anyway but keeping them in |
32 | static const char *keywords[] = { |
33 | "abstract" , "deferred" , "if" , "super" , "as" , "do" , |
34 | "implements" , "switch" , "assert" , "dynamic" , "import" , "sync*" , |
35 | "async" , "else" , "in" , "this" , "async*" , "enum" , |
36 | "is" , "throw" , "await" , "export" , "library" , "true" , |
37 | "break" , "external" , "new" , "try" , "case" , "extends" , |
38 | "null" , "typedef" , "catch" , "factory" , "operator" , "var" , |
39 | "class" , "false" , "part" , "void" , "const" , "final" , |
40 | "rethrow" , "while" , "continue" , "finally" , "return" , "with" , |
41 | "covariant" , "for" , "set" , "yield" , "default" , "get" , |
42 | "static" , "yield*" |
43 | }; |
44 | |
45 | // Iterate through all definitions we haven't generate code for (enums, structs, |
46 | // and tables) and output them to a single file. |
47 | class DartGenerator : public BaseGenerator { |
48 | public: |
49 | typedef std::map<std::string, std::string> namespace_code_map; |
50 | |
51 | DartGenerator(const Parser &parser, const std::string &path, |
52 | const std::string &file_name) |
53 | : BaseGenerator(parser, path, file_name, "" , "." , "dart" ) {} |
54 | // Iterate through all definitions we haven't generate code for (enums, |
55 | // structs, and tables) and output them to a single file. |
56 | bool generate() { |
57 | std::string code; |
58 | namespace_code_map namespace_code; |
59 | GenerateEnums(&namespace_code); |
60 | GenerateStructs(&namespace_code); |
61 | |
62 | for (auto kv = namespace_code.begin(); kv != namespace_code.end(); ++kv) { |
63 | code.clear(); |
64 | code = code + "// " + FlatBuffersGeneratedWarning() + "\n" ; |
65 | code = code + |
66 | "// ignore_for_file: unused_import, unused_field, unused_element, " |
67 | "unused_local_variable\n\n" ; |
68 | |
69 | if (!kv->first.empty()) { code += "library " + kv->first + ";\n\n" ; } |
70 | |
71 | code += "import 'dart:typed_data' show Uint8List;\n" ; |
72 | code += "import 'package:flat_buffers/flat_buffers.dart' as " + _kFb + |
73 | ";\n\n" ; |
74 | |
75 | for (auto kv2 = namespace_code.begin(); kv2 != namespace_code.end(); |
76 | ++kv2) { |
77 | if (kv2->first != kv->first) { |
78 | code += |
79 | "import '" + |
80 | GeneratedFileName( |
81 | "./" , |
82 | file_name_ + (!kv2->first.empty() ? "_" + kv2->first : "" ), |
83 | parser_.opts) + |
84 | "' as " + ImportAliasName(kv2->first) + ";\n" ; |
85 | } |
86 | } |
87 | code += "\n" ; |
88 | code += kv->second; |
89 | |
90 | if (!SaveFile( |
91 | GeneratedFileName( |
92 | path_, |
93 | file_name_ + (!kv->first.empty() ? "_" + kv->first : "" ), |
94 | parser_.opts) |
95 | .c_str(), |
96 | code, false)) { |
97 | return false; |
98 | } |
99 | } |
100 | return true; |
101 | } |
102 | |
103 | private: |
104 | static std::string ImportAliasName(const std::string &ns) { |
105 | std::string ret; |
106 | ret.assign(ns); |
107 | size_t pos = ret.find('.'); |
108 | while (pos != std::string::npos) { |
109 | ret.replace(pos, 1, "_" ); |
110 | pos = ret.find('.', pos + 1); |
111 | } |
112 | |
113 | return ret; |
114 | } |
115 | |
116 | static std::string BuildNamespaceName(const Namespace &ns) { |
117 | if (ns.components.empty()) { return "" ; } |
118 | std::stringstream sstream; |
119 | std::copy(ns.components.begin(), ns.components.end() - 1, |
120 | std::ostream_iterator<std::string>(sstream, "." )); |
121 | |
122 | auto ret = sstream.str() + ns.components.back(); |
123 | for (size_t i = 0; i < ret.size(); i++) { |
124 | auto lower = CharToLower(ret[i]); |
125 | if (lower != ret[i]) { |
126 | ret[i] = lower; |
127 | if (i != 0 && ret[i - 1] != '.') { |
128 | ret.insert(i, "_" ); |
129 | i++; |
130 | } |
131 | } |
132 | } |
133 | // std::transform(ret.begin(), ret.end(), ret.begin(), CharToLower); |
134 | return ret; |
135 | } |
136 | |
137 | void GenIncludeDependencies(std::string *code, |
138 | const std::string &the_namespace) { |
139 | for (auto it = parser_.included_files_.begin(); |
140 | it != parser_.included_files_.end(); ++it) { |
141 | if (it->second.empty()) continue; |
142 | |
143 | auto noext = flatbuffers::StripExtension(it->second); |
144 | auto basename = flatbuffers::StripPath(noext); |
145 | |
146 | *code += |
147 | "import '" + |
148 | GeneratedFileName( |
149 | "" , basename + (the_namespace == "" ? "" : "_" + the_namespace), |
150 | parser_.opts) + |
151 | "';\n" ; |
152 | } |
153 | } |
154 | |
155 | static std::string EscapeKeyword(const std::string &name) { |
156 | for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) { |
157 | if (name == keywords[i]) { return MakeCamel(name + "_" , false); } |
158 | } |
159 | |
160 | return MakeCamel(name, false); |
161 | } |
162 | |
163 | void GenerateEnums(namespace_code_map *namespace_code) { |
164 | for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end(); |
165 | ++it) { |
166 | auto &enum_def = **it; |
167 | GenEnum(enum_def, namespace_code); // enum_code_ptr); |
168 | } |
169 | } |
170 | |
171 | void GenerateStructs(namespace_code_map *namespace_code) { |
172 | for (auto it = parser_.structs_.vec.begin(); |
173 | it != parser_.structs_.vec.end(); ++it) { |
174 | auto &struct_def = **it; |
175 | GenStruct(struct_def, namespace_code); |
176 | } |
177 | } |
178 | |
179 | // Generate a documentation comment, if available. |
180 | static void (const std::vector<std::string> &dc, |
181 | std::string *code_ptr, |
182 | const std::string &, |
183 | const char *indent = nullptr) { |
184 | if (dc.empty() && extra_lines.empty()) { |
185 | // Don't output empty comment blocks with 0 lines of comment content. |
186 | return; |
187 | } |
188 | |
189 | auto &code = *code_ptr; |
190 | |
191 | for (auto it = dc.begin(); it != dc.end(); ++it) { |
192 | if (indent) code += indent; |
193 | code += "/// " + *it + "\n" ; |
194 | } |
195 | if (!extra_lines.empty()) { |
196 | if (!dc.empty()) { |
197 | if (indent) code += indent; |
198 | code += "///\n" ; |
199 | } |
200 | if (indent) code += indent; |
201 | std::string::size_type start = 0; |
202 | for (;;) { |
203 | auto end = extra_lines.find('\n', start); |
204 | if (end != std::string::npos) { |
205 | code += "/// " + extra_lines.substr(start, end - start) + "\n" ; |
206 | start = end + 1; |
207 | } else { |
208 | code += "/// " + extra_lines.substr(start) + "\n" ; |
209 | break; |
210 | } |
211 | } |
212 | } |
213 | } |
214 | |
215 | static void (std::string *code_ptr, |
216 | const std::string &) { |
217 | GenDocComment(std::vector<std::string>(), code_ptr, extra_lines); |
218 | } |
219 | |
220 | // Generate an enum declaration and an enum string lookup table. |
221 | void GenEnum(EnumDef &enum_def, namespace_code_map *namespace_code) { |
222 | if (enum_def.generated) return; |
223 | auto ns = BuildNamespaceName(*enum_def.defined_namespace); |
224 | std::string code; |
225 | GenDocComment(enum_def.doc_comment, &code, "" ); |
226 | |
227 | auto name = enum_def.is_union ? enum_def.name + "TypeId" : enum_def.name; |
228 | auto is_bit_flags = enum_def.attributes.Lookup("bit_flags" ); |
229 | |
230 | code += "class " + name + " {\n" ; |
231 | code += " final int value;\n" ; |
232 | code += " const " + name + "._(this.value);\n\n" ; |
233 | code += " factory " + name + ".fromValue(int value) {\n" ; |
234 | code += " final result = values[value];\n" ; |
235 | code += " if (result == null) {\n" ; |
236 | code += " throw StateError('Invalid value $value for bit flag enum " ; |
237 | code += name + "');\n" ; |
238 | code += " }\n" ; |
239 | |
240 | code += " return result;\n" ; |
241 | code += " }\n\n" ; |
242 | |
243 | code += " static " + name + "? _createOrNull(int? value) => \n" ; |
244 | code += " value == null ? null : " + name + ".fromValue(value);\n\n" ; |
245 | |
246 | // this is meaningless for bit_flags |
247 | // however, note that unlike "regular" dart enums this enum can still have |
248 | // holes. |
249 | if (!is_bit_flags) { |
250 | code += " static const int minValue = " + |
251 | enum_def.ToString(*enum_def.MinValue()) + ";\n" ; |
252 | code += " static const int maxValue = " + |
253 | enum_def.ToString(*enum_def.MaxValue()) + ";\n" ; |
254 | } |
255 | |
256 | code += |
257 | " static bool containsValue(int value) =>" |
258 | " values.containsKey(value);\n\n" ; |
259 | |
260 | for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) { |
261 | auto &ev = **it; |
262 | |
263 | if (!ev.doc_comment.empty()) { |
264 | if (it != enum_def.Vals().begin()) { code += '\n'; } |
265 | GenDocComment(ev.doc_comment, &code, "" , " " ); |
266 | } |
267 | code += " static const " + name + " " + ev.name + " = " + name + "._(" + |
268 | enum_def.ToString(ev) + ");\n" ; |
269 | } |
270 | |
271 | code += " static const Map<int, " + name + "> values = {\n" ; |
272 | for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) { |
273 | auto &ev = **it; |
274 | if (it != enum_def.Vals().begin()) code += ",\n" ; |
275 | code += " " + enum_def.ToString(ev) + ": " + ev.name; |
276 | } |
277 | code += "};\n\n" ; |
278 | |
279 | code += " static const " + _kFb + ".Reader<" + name + "> reader = _" + |
280 | name + "Reader();\n\n" ; |
281 | code += " @override\n" ; |
282 | code += " String toString() {\n" ; |
283 | code += " return '" + name + "{value: $value}';\n" ; |
284 | code += " }\n" ; |
285 | code += "}\n\n" ; |
286 | |
287 | GenEnumReader(enum_def, name, &code); |
288 | (*namespace_code)[ns] += code; |
289 | } |
290 | |
291 | void GenEnumReader(EnumDef &enum_def, const std::string &name, |
292 | std::string *code_ptr) { |
293 | auto &code = *code_ptr; |
294 | |
295 | code += "class _" + name + "Reader extends " + _kFb + ".Reader<" + name + |
296 | "> {\n" ; |
297 | code += " const _" + name + "Reader();\n\n" ; |
298 | code += " @override\n" ; |
299 | code += " int get size => 1;\n\n" ; |
300 | code += " @override\n" ; |
301 | code += |
302 | " " + name + " read(" + _kFb + ".BufferContext bc, int offset) =>\n" ; |
303 | code += " " + name + ".fromValue(const " + _kFb + "." + |
304 | GenType(enum_def.underlying_type) + "Reader().read(bc, offset));\n" ; |
305 | code += "}\n\n" ; |
306 | } |
307 | |
308 | static std::string GenType(const Type &type) { |
309 | switch (type.base_type) { |
310 | case BASE_TYPE_BOOL: return "Bool" ; |
311 | case BASE_TYPE_CHAR: return "Int8" ; |
312 | case BASE_TYPE_UTYPE: |
313 | case BASE_TYPE_UCHAR: return "Uint8" ; |
314 | case BASE_TYPE_SHORT: return "Int16" ; |
315 | case BASE_TYPE_USHORT: return "Uint16" ; |
316 | case BASE_TYPE_INT: return "Int32" ; |
317 | case BASE_TYPE_UINT: return "Uint32" ; |
318 | case BASE_TYPE_LONG: return "Int64" ; |
319 | case BASE_TYPE_ULONG: return "Uint64" ; |
320 | case BASE_TYPE_FLOAT: return "Float32" ; |
321 | case BASE_TYPE_DOUBLE: return "Float64" ; |
322 | case BASE_TYPE_STRING: return "String" ; |
323 | case BASE_TYPE_VECTOR: return GenType(type.VectorType()); |
324 | case BASE_TYPE_STRUCT: return type.struct_def->name; |
325 | case BASE_TYPE_UNION: return type.enum_def->name + "TypeId" ; |
326 | default: return "Table" ; |
327 | } |
328 | } |
329 | |
330 | std::string GenReaderTypeName(const Type &type, Namespace *current_namespace, |
331 | const FieldDef &def, |
332 | bool parent_is_vector = false, bool lazy = true, |
333 | bool constConstruct = true) { |
334 | std::string prefix = (constConstruct ? "const " : "" ) + _kFb; |
335 | if (type.base_type == BASE_TYPE_BOOL) { |
336 | return prefix + ".BoolReader()" ; |
337 | } else if (IsVector(type)) { |
338 | if (!type.VectorType().enum_def) { |
339 | if (type.VectorType().base_type == BASE_TYPE_CHAR) { |
340 | return prefix + ".Int8ListReader(" + (lazy ? ")" : "lazy: false)" ); |
341 | } |
342 | if (type.VectorType().base_type == BASE_TYPE_UCHAR) { |
343 | return prefix + ".Uint8ListReader(" + (lazy ? ")" : "lazy: false)" ); |
344 | } |
345 | } |
346 | return prefix + ".ListReader<" + |
347 | GenDartTypeName(type.VectorType(), current_namespace, def) + ">(" + |
348 | GenReaderTypeName(type.VectorType(), current_namespace, def, true, |
349 | true, false) + |
350 | (lazy ? ")" : ", lazy: false)" ); |
351 | } else if (IsString(type)) { |
352 | return prefix + ".StringReader()" ; |
353 | } |
354 | if (IsScalar(type.base_type)) { |
355 | if (type.enum_def && parent_is_vector) { |
356 | return GenDartTypeName(type, current_namespace, def) + ".reader" ; |
357 | } |
358 | return prefix + "." + GenType(type) + "Reader()" ; |
359 | } else { |
360 | return GenDartTypeName(type, current_namespace, def) + ".reader" ; |
361 | } |
362 | } |
363 | |
364 | std::string GenDartTypeName(const Type &type, Namespace *current_namespace, |
365 | const FieldDef &def, |
366 | std::string struct_type_suffix = "" ) { |
367 | if (type.enum_def) { |
368 | if (type.enum_def->is_union && type.base_type != BASE_TYPE_UNION) { |
369 | return type.enum_def->name + "TypeId" ; |
370 | } else if (type.enum_def->is_union) { |
371 | return "dynamic" ; |
372 | } else if (type.base_type != BASE_TYPE_VECTOR) { |
373 | return type.enum_def->name; |
374 | } |
375 | } |
376 | |
377 | switch (type.base_type) { |
378 | case BASE_TYPE_BOOL: return "bool" ; |
379 | case BASE_TYPE_LONG: |
380 | case BASE_TYPE_ULONG: |
381 | case BASE_TYPE_INT: |
382 | case BASE_TYPE_UINT: |
383 | case BASE_TYPE_SHORT: |
384 | case BASE_TYPE_USHORT: |
385 | case BASE_TYPE_CHAR: |
386 | case BASE_TYPE_UCHAR: return "int" ; |
387 | case BASE_TYPE_FLOAT: |
388 | case BASE_TYPE_DOUBLE: return "double" ; |
389 | case BASE_TYPE_STRING: return "String" ; |
390 | case BASE_TYPE_STRUCT: |
391 | return MaybeWrapNamespace(type.struct_def->name + struct_type_suffix, |
392 | current_namespace, def); |
393 | case BASE_TYPE_VECTOR: |
394 | return "List<" + |
395 | GenDartTypeName(type.VectorType(), current_namespace, def, |
396 | struct_type_suffix) + |
397 | ">" ; |
398 | default: assert(0); return "dynamic" ; |
399 | } |
400 | } |
401 | |
402 | std::string GenDartTypeName(const Type &type, Namespace *current_namespace, |
403 | const FieldDef &def, bool nullable, |
404 | std::string struct_type_suffix) { |
405 | std::string typeName = |
406 | GenDartTypeName(type, current_namespace, def, struct_type_suffix); |
407 | if (nullable && typeName != "dynamic" ) typeName += "?" ; |
408 | return typeName; |
409 | } |
410 | |
411 | static const std::string MaybeWrapNamespace(const std::string &type_name, |
412 | Namespace *current_ns, |
413 | const FieldDef &field) { |
414 | auto curr_ns_str = BuildNamespaceName(*current_ns); |
415 | std::string field_ns_str = "" ; |
416 | if (field.value.type.struct_def) { |
417 | field_ns_str += |
418 | BuildNamespaceName(*field.value.type.struct_def->defined_namespace); |
419 | } else if (field.value.type.enum_def) { |
420 | field_ns_str += |
421 | BuildNamespaceName(*field.value.type.enum_def->defined_namespace); |
422 | } |
423 | |
424 | if (field_ns_str != "" && field_ns_str != curr_ns_str) { |
425 | return ImportAliasName(field_ns_str) + "." + type_name; |
426 | } else { |
427 | return type_name; |
428 | } |
429 | } |
430 | |
431 | // Generate an accessor struct with constructor for a flatbuffers struct. |
432 | void GenStruct(const StructDef &struct_def, |
433 | namespace_code_map *namespace_code) { |
434 | if (struct_def.generated) return; |
435 | |
436 | auto object_namespace = BuildNamespaceName(*struct_def.defined_namespace); |
437 | std::string code; |
438 | |
439 | const auto &object_name = struct_def.name; |
440 | |
441 | // Emit constructor |
442 | |
443 | GenDocComment(struct_def.doc_comment, &code, "" ); |
444 | |
445 | auto reader_name = "_" + object_name + "Reader" ; |
446 | auto builder_name = object_name + "Builder" ; |
447 | auto object_builder_name = object_name + "ObjectBuilder" ; |
448 | |
449 | std::string reader_code, builder_code; |
450 | |
451 | code += "class " + object_name + " {\n" ; |
452 | |
453 | code += " " + object_name + "._(this._bc, this._bcOffset);\n" ; |
454 | if (!struct_def.fixed) { |
455 | code += " factory " + object_name + "(List<int> bytes) {\n" ; |
456 | code += |
457 | " final rootRef = " + _kFb + ".BufferContext.fromBytes(bytes);\n" ; |
458 | code += " return reader.read(rootRef, 0);\n" ; |
459 | code += " }\n" ; |
460 | } |
461 | |
462 | code += "\n" ; |
463 | code += " static const " + _kFb + ".Reader<" + object_name + |
464 | "> reader = " + reader_name + "();\n\n" ; |
465 | |
466 | code += " final " + _kFb + ".BufferContext _bc;\n" ; |
467 | code += " final int _bcOffset;\n\n" ; |
468 | |
469 | std::vector<std::pair<int, FieldDef *>> non_deprecated_fields; |
470 | for (auto it = struct_def.fields.vec.begin(); |
471 | it != struct_def.fields.vec.end(); ++it) { |
472 | auto &field = **it; |
473 | if (field.deprecated) continue; |
474 | auto offset = static_cast<int>(it - struct_def.fields.vec.begin()); |
475 | non_deprecated_fields.push_back(std::make_pair(offset, &field)); |
476 | } |
477 | |
478 | GenImplementationGetters(struct_def, non_deprecated_fields, &code); |
479 | |
480 | if (parser_.opts.generate_object_based_api) { |
481 | code += |
482 | "\n" + GenStructObjectAPIUnpack(struct_def, non_deprecated_fields); |
483 | |
484 | code += "\n static int pack(fb.Builder fbBuilder, " + struct_def.name + |
485 | "T? object) {\n" ; |
486 | code += " if (object == null) return 0;\n" ; |
487 | code += " return object.pack(fbBuilder);\n" ; |
488 | code += " }\n" ; |
489 | } |
490 | |
491 | code += "}\n\n" ; |
492 | |
493 | if (parser_.opts.generate_object_based_api) { |
494 | code += GenStructObjectAPI(struct_def, non_deprecated_fields); |
495 | } |
496 | |
497 | GenReader(struct_def, &reader_name, &reader_code); |
498 | GenBuilder(struct_def, non_deprecated_fields, &builder_name, &builder_code); |
499 | GenObjectBuilder(struct_def, non_deprecated_fields, &object_builder_name, |
500 | &builder_code); |
501 | |
502 | code += reader_code; |
503 | code += builder_code; |
504 | |
505 | (*namespace_code)[object_namespace] += code; |
506 | } |
507 | |
508 | // Generate an accessor struct with constructor for a flatbuffers struct. |
509 | std::string GenStructObjectAPI( |
510 | const StructDef &struct_def, |
511 | const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) { |
512 | std::string code; |
513 | GenDocComment(struct_def.doc_comment, &code, "" ); |
514 | |
515 | std::string class_name = struct_def.name + "T" ; |
516 | code += "class " + class_name + " implements " + _kFb + ".Packable {\n" ; |
517 | |
518 | std::string constructor_args; |
519 | for (auto it = non_deprecated_fields.begin(); |
520 | it != non_deprecated_fields.end(); ++it) { |
521 | const FieldDef &field = *it->second; |
522 | |
523 | std::string field_name = MakeCamel(field.name, false); |
524 | std::string defaultValue = getDefaultValue(field.value); |
525 | std::string type_name = |
526 | GenDartTypeName(field.value.type, struct_def.defined_namespace, field, |
527 | defaultValue.empty() && !struct_def.fixed, "T" ); |
528 | |
529 | GenDocComment(field.doc_comment, &code, "" , " " ); |
530 | code += " " + type_name + " " + field_name + ";\n" ; |
531 | |
532 | if (!constructor_args.empty()) constructor_args += ",\n" ; |
533 | constructor_args += " " ; |
534 | constructor_args += (struct_def.fixed ? "required " : "" ); |
535 | constructor_args += "this." + field_name; |
536 | if (!struct_def.fixed && !defaultValue.empty()) { |
537 | if (IsEnum(field.value.type)) { |
538 | auto &enum_def = *field.value.type.enum_def; |
539 | for (auto enumIt = enum_def.Vals().begin(); |
540 | enumIt != enum_def.Vals().end(); ++enumIt) { |
541 | auto &ev = **enumIt; |
542 | if (enum_def.ToString(ev) == defaultValue) { |
543 | constructor_args += " = " + enum_def.name + "." + ev.name; |
544 | break; |
545 | } |
546 | } |
547 | } else { |
548 | constructor_args += " = " + defaultValue; |
549 | } |
550 | } |
551 | } |
552 | |
553 | if (!constructor_args.empty()) { |
554 | code += "\n " + class_name + "({\n" + constructor_args + "});\n\n" ; |
555 | } |
556 | |
557 | code += GenStructObjectAPIPack(struct_def, non_deprecated_fields); |
558 | code += "\n" ; |
559 | code += GenToString(class_name, non_deprecated_fields); |
560 | |
561 | code += "}\n\n" ; |
562 | return code; |
563 | } |
564 | |
565 | // Generate function `StructNameT unpack()` |
566 | std::string GenStructObjectAPIUnpack( |
567 | const StructDef &struct_def, |
568 | const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) { |
569 | std::string constructor_args; |
570 | for (auto it = non_deprecated_fields.begin(); |
571 | it != non_deprecated_fields.end(); ++it) { |
572 | const FieldDef &field = *it->second; |
573 | |
574 | std::string field_name = MakeCamel(field.name, false); |
575 | if (!constructor_args.empty()) constructor_args += ",\n" ; |
576 | constructor_args += " " + field_name + ": " ; |
577 | |
578 | const Type &type = field.value.type; |
579 | std::string defaultValue = getDefaultValue(field.value); |
580 | bool isNullable = defaultValue.empty() && !struct_def.fixed; |
581 | std::string nullableValueAccessOperator = isNullable ? "?" : "" ; |
582 | if (type.base_type == BASE_TYPE_STRUCT) { |
583 | constructor_args += |
584 | field_name + nullableValueAccessOperator + ".unpack()" ; |
585 | } else if (type.base_type == BASE_TYPE_VECTOR) { |
586 | if (type.VectorType().base_type == BASE_TYPE_STRUCT) { |
587 | constructor_args += field_name + nullableValueAccessOperator + |
588 | ".map((e) => e.unpack()).toList()" ; |
589 | } else { |
590 | constructor_args += |
591 | GenReaderTypeName(field.value.type, struct_def.defined_namespace, |
592 | field, false, false); |
593 | constructor_args += ".vTableGet" ; |
594 | std::string offset = NumToString(field.value.offset); |
595 | constructor_args += |
596 | isNullable |
597 | ? "Nullable(_bc, _bcOffset, " + offset + ")" |
598 | : "(_bc, _bcOffset, " + offset + ", " + defaultValue + ")" ; |
599 | } |
600 | } else { |
601 | constructor_args += field_name; |
602 | } |
603 | } |
604 | |
605 | std::string class_name = struct_def.name + "T" ; |
606 | std::string code = " " + class_name + " unpack() => " + class_name + "(" ; |
607 | if (!constructor_args.empty()) code += "\n" + constructor_args; |
608 | code += ");\n" ; |
609 | return code; |
610 | } |
611 | |
612 | // Generate function `StructNameT pack()` |
613 | std::string GenStructObjectAPIPack( |
614 | const StructDef &struct_def, |
615 | const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) { |
616 | std::string code; |
617 | |
618 | code += " @override\n" ; |
619 | code += " int pack(fb.Builder fbBuilder) {\n" ; |
620 | code += GenObjectBuilderImplementation(struct_def, non_deprecated_fields, |
621 | false, true); |
622 | code += " }\n" ; |
623 | return code; |
624 | } |
625 | |
626 | std::string NamespaceAliasFromUnionType(Namespace *root_namespace, |
627 | const Type &type) { |
628 | const std::vector<std::string> qualified_name_parts = |
629 | type.struct_def->defined_namespace->components; |
630 | if (std::equal(root_namespace->components.begin(), |
631 | root_namespace->components.end(), |
632 | qualified_name_parts.begin())) { |
633 | return type.struct_def->name; |
634 | } |
635 | |
636 | std::string ns; |
637 | |
638 | for (auto it = qualified_name_parts.begin(); |
639 | it != qualified_name_parts.end(); ++it) { |
640 | auto &part = *it; |
641 | |
642 | for (size_t i = 0; i < part.length(); i++) { |
643 | if (i && !isdigit(part[i]) && part[i] == CharToUpper(part[i])) { |
644 | ns += "_" ; |
645 | ns += CharToLower(part[i]); |
646 | } else { |
647 | ns += CharToLower(part[i]); |
648 | } |
649 | } |
650 | if (it != qualified_name_parts.end() - 1) { ns += "_" ; } |
651 | } |
652 | |
653 | return ns + "." + type.struct_def->name; |
654 | } |
655 | |
656 | void GenImplementationGetters( |
657 | const StructDef &struct_def, |
658 | std::vector<std::pair<int, FieldDef *>> non_deprecated_fields, |
659 | std::string *code_ptr) { |
660 | auto &code = *code_ptr; |
661 | |
662 | for (auto it = non_deprecated_fields.begin(); |
663 | it != non_deprecated_fields.end(); ++it) { |
664 | auto pair = *it; |
665 | auto &field = *pair.second; |
666 | |
667 | std::string field_name = MakeCamel(field.name, false); |
668 | std::string defaultValue = getDefaultValue(field.value); |
669 | bool isNullable = defaultValue.empty() && !struct_def.fixed; |
670 | std::string type_name = |
671 | GenDartTypeName(field.value.type, struct_def.defined_namespace, field, |
672 | isNullable, "" ); |
673 | |
674 | GenDocComment(field.doc_comment, &code, "" , " " ); |
675 | |
676 | code += " " + type_name + " get " + field_name; |
677 | if (field.value.type.base_type == BASE_TYPE_UNION) { |
678 | code += " {\n" ; |
679 | code += " switch (" + field_name + "Type?.value) {\n" ; |
680 | auto &enum_def = *field.value.type.enum_def; |
681 | for (auto en_it = enum_def.Vals().begin() + 1; |
682 | en_it != enum_def.Vals().end(); ++en_it) { |
683 | auto &ev = **en_it; |
684 | |
685 | auto enum_name = NamespaceAliasFromUnionType( |
686 | enum_def.defined_namespace, ev.union_type); |
687 | code += " case " + enum_def.ToString(ev) + ": return " + |
688 | enum_name + ".reader.vTableGetNullable(_bc, _bcOffset, " + |
689 | NumToString(field.value.offset) + ");\n" ; |
690 | } |
691 | code += " default: return null;\n" ; |
692 | code += " }\n" ; |
693 | code += " }\n" ; |
694 | } else { |
695 | code += " => " ; |
696 | if (field.value.type.enum_def && |
697 | field.value.type.base_type != BASE_TYPE_VECTOR) { |
698 | code += GenDartTypeName(field.value.type, |
699 | struct_def.defined_namespace, field) + |
700 | (isNullable ? "._createOrNull(" : ".fromValue(" ); |
701 | } |
702 | |
703 | code += GenReaderTypeName(field.value.type, |
704 | struct_def.defined_namespace, field); |
705 | if (struct_def.fixed) { |
706 | code += |
707 | ".read(_bc, _bcOffset + " + NumToString(field.value.offset) + ")" ; |
708 | } else { |
709 | code += ".vTableGet" ; |
710 | std::string offset = NumToString(field.value.offset); |
711 | if (isNullable) { |
712 | code += "Nullable(_bc, _bcOffset, " + offset + ")" ; |
713 | } else { |
714 | code += "(_bc, _bcOffset, " + offset + ", " + defaultValue + ")" ; |
715 | } |
716 | } |
717 | if (field.value.type.enum_def && |
718 | field.value.type.base_type != BASE_TYPE_VECTOR) { |
719 | code += ")" ; |
720 | } |
721 | code += ";\n" ; |
722 | } |
723 | } |
724 | |
725 | code += "\n" ; |
726 | code += GenToString(struct_def.name, non_deprecated_fields); |
727 | } |
728 | |
729 | std::string GenToString( |
730 | const std::string &object_name, |
731 | const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) { |
732 | std::string code; |
733 | code += " @override\n" ; |
734 | code += " String toString() {\n" ; |
735 | code += " return '" + object_name + "{" ; |
736 | for (auto it = non_deprecated_fields.begin(); |
737 | it != non_deprecated_fields.end(); ++it) { |
738 | auto pair = *it; |
739 | auto &field = *pair.second; |
740 | code += |
741 | MakeCamel(field.name, false) + ": $" + MakeCamel(field.name, false); |
742 | if (it != non_deprecated_fields.end() - 1) { code += ", " ; } |
743 | } |
744 | code += "}';\n" ; |
745 | code += " }\n" ; |
746 | return code; |
747 | } |
748 | |
749 | std::string getDefaultValue(const Value &value) const { |
750 | if (!value.constant.empty() && value.constant != "0" ) { |
751 | if (IsBool(value.type.base_type)) { |
752 | return "true" ; |
753 | } else if (value.constant == "nan" || value.constant == "+nan" || |
754 | value.constant == "-nan" ) { |
755 | return "double.nan" ; |
756 | } else if (value.constant == "inf" || value.constant == "+inf" ) { |
757 | return "double.infinity" ; |
758 | } else if (value.constant == "-inf" ) { |
759 | return "double.negativeInfinity" ; |
760 | } else { |
761 | return value.constant; |
762 | } |
763 | } else if (IsBool(value.type.base_type)) { |
764 | return "false" ; |
765 | } else if (IsScalar(value.type.base_type) && !IsUnion(value.type)) { |
766 | return "0" ; |
767 | } else { |
768 | return "" ; |
769 | } |
770 | } |
771 | |
772 | void GenReader(const StructDef &struct_def, std::string *reader_name_ptr, |
773 | std::string *code_ptr) { |
774 | auto &code = *code_ptr; |
775 | auto &reader_name = *reader_name_ptr; |
776 | auto &impl_name = struct_def.name; |
777 | |
778 | code += "class " + reader_name + " extends " + _kFb; |
779 | if (struct_def.fixed) { |
780 | code += ".StructReader<" ; |
781 | } else { |
782 | code += ".TableReader<" ; |
783 | } |
784 | code += impl_name + "> {\n" ; |
785 | code += " const " + reader_name + "();\n\n" ; |
786 | |
787 | if (struct_def.fixed) { |
788 | code += " @override\n" ; |
789 | code += " int get size => " + NumToString(struct_def.bytesize) + ";\n\n" ; |
790 | } |
791 | code += " @override\n" ; |
792 | code += " " + impl_name + |
793 | " createObject(fb.BufferContext bc, int offset) => \n " + |
794 | impl_name + "._(bc, offset);\n" ; |
795 | code += "}\n\n" ; |
796 | } |
797 | |
798 | void GenBuilder(const StructDef &struct_def, |
799 | std::vector<std::pair<int, FieldDef *>> non_deprecated_fields, |
800 | std::string *builder_name_ptr, std::string *code_ptr) { |
801 | if (non_deprecated_fields.size() == 0) { return; } |
802 | auto &code = *code_ptr; |
803 | auto &builder_name = *builder_name_ptr; |
804 | |
805 | code += "class " + builder_name + " {\n" ; |
806 | code += " " + builder_name + "(this.fbBuilder);\n\n" ; |
807 | code += " final " + _kFb + ".Builder fbBuilder;\n\n" ; |
808 | |
809 | if (struct_def.fixed) { |
810 | StructBuilderBody(struct_def, non_deprecated_fields, code_ptr); |
811 | } else { |
812 | TableBuilderBody(struct_def, non_deprecated_fields, code_ptr); |
813 | } |
814 | |
815 | code += "}\n\n" ; |
816 | } |
817 | |
818 | void StructBuilderBody( |
819 | const StructDef &struct_def, |
820 | std::vector<std::pair<int, FieldDef *>> non_deprecated_fields, |
821 | std::string *code_ptr) { |
822 | auto &code = *code_ptr; |
823 | |
824 | code += " int finish(" ; |
825 | for (auto it = non_deprecated_fields.begin(); |
826 | it != non_deprecated_fields.end(); ++it) { |
827 | auto pair = *it; |
828 | auto &field = *pair.second; |
829 | |
830 | if (IsStruct(field.value.type)) { |
831 | code += "fb.StructBuilder" ; |
832 | } else { |
833 | code += GenDartTypeName(field.value.type, struct_def.defined_namespace, |
834 | field); |
835 | } |
836 | code += " " + field.name; |
837 | if (it != non_deprecated_fields.end() - 1) { code += ", " ; } |
838 | } |
839 | code += ") {\n" ; |
840 | |
841 | for (auto it = non_deprecated_fields.rbegin(); |
842 | it != non_deprecated_fields.rend(); ++it) { |
843 | auto pair = *it; |
844 | auto &field = *pair.second; |
845 | |
846 | if (field.padding) { |
847 | code += " fbBuilder.pad(" + NumToString(field.padding) + ");\n" ; |
848 | } |
849 | |
850 | if (IsStruct(field.value.type)) { |
851 | code += " " + field.name + "();\n" ; |
852 | } else { |
853 | code += " fbBuilder.put" + GenType(field.value.type) + "(" ; |
854 | code += field.name; |
855 | if (field.value.type.enum_def) { code += ".value" ; } |
856 | code += ");\n" ; |
857 | } |
858 | } |
859 | code += " return fbBuilder.offset;\n" ; |
860 | code += " }\n\n" ; |
861 | } |
862 | |
863 | void TableBuilderBody( |
864 | const StructDef &struct_def, |
865 | std::vector<std::pair<int, FieldDef *>> non_deprecated_fields, |
866 | std::string *code_ptr) { |
867 | auto &code = *code_ptr; |
868 | |
869 | code += " void begin() {\n" ; |
870 | code += " fbBuilder.startTable(" + |
871 | NumToString(non_deprecated_fields.size()) + ");\n" ; |
872 | code += " }\n\n" ; |
873 | |
874 | for (auto it = non_deprecated_fields.begin(); |
875 | it != non_deprecated_fields.end(); ++it) { |
876 | auto pair = *it; |
877 | auto &field = *pair.second; |
878 | auto offset = pair.first; |
879 | |
880 | if (IsScalar(field.value.type.base_type)) { |
881 | code += " int add" + MakeCamel(field.name) + "(" ; |
882 | code += GenDartTypeName(field.value.type, struct_def.defined_namespace, |
883 | field); |
884 | code += "? " + MakeCamel(field.name, false) + ") {\n" ; |
885 | code += " fbBuilder.add" + GenType(field.value.type) + "(" + |
886 | NumToString(offset) + ", " ; |
887 | code += MakeCamel(field.name, false); |
888 | if (field.value.type.enum_def) { code += "?.value" ; } |
889 | code += ");\n" ; |
890 | } else if (IsStruct(field.value.type)) { |
891 | code += " int add" + MakeCamel(field.name) + "(int offset) {\n" ; |
892 | code += |
893 | " fbBuilder.addStruct(" + NumToString(offset) + ", offset);\n" ; |
894 | } else { |
895 | code += " int add" + MakeCamel(field.name) + "Offset(int? offset) {\n" ; |
896 | code += |
897 | " fbBuilder.addOffset(" + NumToString(offset) + ", offset);\n" ; |
898 | } |
899 | code += " return fbBuilder.offset;\n" ; |
900 | code += " }\n" ; |
901 | } |
902 | |
903 | code += "\n" ; |
904 | code += " int finish() {\n" ; |
905 | code += " return fbBuilder.endTable();\n" ; |
906 | code += " }\n" ; |
907 | } |
908 | |
909 | void GenObjectBuilder( |
910 | const StructDef &struct_def, |
911 | std::vector<std::pair<int, FieldDef *>> non_deprecated_fields, |
912 | std::string *builder_name_ptr, std::string *code_ptr) { |
913 | auto &code = *code_ptr; |
914 | auto &builder_name = *builder_name_ptr; |
915 | |
916 | code += "class " + builder_name + " extends " + _kFb + ".ObjectBuilder {\n" ; |
917 | for (auto it = non_deprecated_fields.begin(); |
918 | it != non_deprecated_fields.end(); ++it) { |
919 | auto pair = *it; |
920 | auto &field = *pair.second; |
921 | |
922 | code += " final " + |
923 | GenDartTypeName(field.value.type, struct_def.defined_namespace, |
924 | field, !struct_def.fixed, "ObjectBuilder" ) + |
925 | " _" + MakeCamel(field.name, false) + ";\n" ; |
926 | } |
927 | code += "\n" ; |
928 | code += " " + builder_name + "(" ; |
929 | |
930 | if (non_deprecated_fields.size() != 0) { |
931 | code += "{\n" ; |
932 | for (auto it = non_deprecated_fields.begin(); |
933 | it != non_deprecated_fields.end(); ++it) { |
934 | auto pair = *it; |
935 | auto &field = *pair.second; |
936 | |
937 | code += " " ; |
938 | code += (struct_def.fixed ? "required " : "" ) + |
939 | GenDartTypeName(field.value.type, struct_def.defined_namespace, |
940 | field, !struct_def.fixed, "ObjectBuilder" ) + |
941 | " " + MakeCamel(field.name, false) + ",\n" ; |
942 | } |
943 | code += " })\n" ; |
944 | code += " : " ; |
945 | for (auto it = non_deprecated_fields.begin(); |
946 | it != non_deprecated_fields.end(); ++it) { |
947 | auto pair = *it; |
948 | auto &field = *pair.second; |
949 | |
950 | code += "_" + MakeCamel(field.name, false) + " = " + |
951 | MakeCamel(field.name, false); |
952 | if (it == non_deprecated_fields.end() - 1) { |
953 | code += ";\n\n" ; |
954 | } else { |
955 | code += ",\n " ; |
956 | } |
957 | } |
958 | } else { |
959 | code += ");\n\n" ; |
960 | } |
961 | |
962 | code += " /// Finish building, and store into the [fbBuilder].\n" ; |
963 | code += " @override\n" ; |
964 | code += " int finish(" + _kFb + ".Builder fbBuilder) {\n" ; |
965 | code += GenObjectBuilderImplementation(struct_def, non_deprecated_fields); |
966 | code += " }\n\n" ; |
967 | |
968 | code += " /// Convenience method to serialize to byte list.\n" ; |
969 | code += " @override\n" ; |
970 | code += " Uint8List toBytes([String? fileIdentifier]) {\n" ; |
971 | code += " final fbBuilder = " + _kFb + |
972 | ".Builder(deduplicateTables: false);\n" ; |
973 | code += " fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n" ; |
974 | code += " return fbBuilder.buffer;\n" ; |
975 | code += " }\n" ; |
976 | code += "}\n" ; |
977 | } |
978 | |
979 | std::string GenObjectBuilderImplementation( |
980 | const StructDef &struct_def, |
981 | const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields, |
982 | bool prependUnderscore = true, bool pack = false) { |
983 | std::string code; |
984 | for (auto it = non_deprecated_fields.begin(); |
985 | it != non_deprecated_fields.end(); ++it) { |
986 | const FieldDef &field = *it->second; |
987 | |
988 | if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type)) |
989 | continue; |
990 | |
991 | std::string offset_name = MakeCamel(field.name, false) + "Offset" ; |
992 | std::string field_name = |
993 | (prependUnderscore ? "_" : "" ) + MakeCamel(field.name, false); |
994 | |
995 | // custom handling for fixed-sized struct in pack() |
996 | if (pack && IsVector(field.value.type) && |
997 | field.value.type.VectorType().base_type == BASE_TYPE_STRUCT && |
998 | field.value.type.struct_def->fixed) { |
999 | code += " int? " + offset_name + ";\n" ; |
1000 | code += " if (" + field_name + " != null) {\n" ; |
1001 | code += |
1002 | " for (var e in " + field_name + "!) { e.pack(fbBuilder); }\n" ; |
1003 | code += " " + MakeCamel(field.name, false) + |
1004 | "Offset = fbBuilder.endStructVector(" + field_name + |
1005 | "!.length);\n" ; |
1006 | code += " }\n" ; |
1007 | continue; |
1008 | } |
1009 | |
1010 | code += " final int? " + offset_name; |
1011 | if (IsVector(field.value.type)) { |
1012 | code += " = " + field_name + " == null ? null\n" ; |
1013 | code += " : fbBuilder.writeList" ; |
1014 | switch (field.value.type.VectorType().base_type) { |
1015 | case BASE_TYPE_STRING: |
1016 | code += |
1017 | "(" + field_name + "!.map(fbBuilder.writeString).toList());\n" ; |
1018 | break; |
1019 | case BASE_TYPE_STRUCT: |
1020 | if (field.value.type.struct_def->fixed) { |
1021 | code += "OfStructs(" + field_name + "!);\n" ; |
1022 | } else { |
1023 | code += "(" + field_name + "!.map((b) => b." + |
1024 | (pack ? "pack" : "getOrCreateOffset" ) + |
1025 | "(fbBuilder)).toList());\n" ; |
1026 | } |
1027 | break; |
1028 | default: |
1029 | code += |
1030 | GenType(field.value.type.VectorType()) + "(" + field_name + "!" ; |
1031 | if (field.value.type.enum_def) { |
1032 | code += ".map((f) => f.value).toList()" ; |
1033 | } |
1034 | code += ");\n" ; |
1035 | } |
1036 | } else if (IsString(field.value.type)) { |
1037 | code += " = " + field_name + " == null ? null\n" ; |
1038 | code += " : fbBuilder.writeString(" + field_name + "!);\n" ; |
1039 | } else { |
1040 | code += " = " + field_name + "?." + |
1041 | (pack ? "pack" : "getOrCreateOffset" ) + "(fbBuilder);\n" ; |
1042 | } |
1043 | } |
1044 | |
1045 | if (struct_def.fixed) { |
1046 | code += StructObjectBuilderBody(non_deprecated_fields, prependUnderscore, |
1047 | pack); |
1048 | } else { |
1049 | code += TableObjectBuilderBody(non_deprecated_fields, prependUnderscore, |
1050 | pack); |
1051 | } |
1052 | return code; |
1053 | } |
1054 | |
1055 | std::string StructObjectBuilderBody( |
1056 | const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields, |
1057 | bool prependUnderscore = true, bool pack = false) { |
1058 | std::string code; |
1059 | |
1060 | for (auto it = non_deprecated_fields.rbegin(); |
1061 | it != non_deprecated_fields.rend(); ++it) { |
1062 | auto pair = *it; |
1063 | auto &field = *pair.second; |
1064 | |
1065 | if (field.padding) { |
1066 | code += " fbBuilder.pad(" + NumToString(field.padding) + ");\n" ; |
1067 | } |
1068 | |
1069 | if (IsStruct(field.value.type)) { |
1070 | code += " " ; |
1071 | if (prependUnderscore) { code += "_" ; } |
1072 | code += field.name + (pack ? ".pack" : ".finish" ) + "(fbBuilder);\n" ; |
1073 | } else { |
1074 | code += " fbBuilder.put" + GenType(field.value.type) + "(" ; |
1075 | if (prependUnderscore) { code += "_" ; } |
1076 | code += field.name; |
1077 | if (field.value.type.enum_def) { code += ".value" ; } |
1078 | code += ");\n" ; |
1079 | } |
1080 | } |
1081 | |
1082 | code += " return fbBuilder.offset;\n" ; |
1083 | return code; |
1084 | } |
1085 | |
1086 | std::string TableObjectBuilderBody( |
1087 | const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields, |
1088 | bool prependUnderscore = true, bool pack = false) { |
1089 | std::string code; |
1090 | code += " fbBuilder.startTable(" + |
1091 | NumToString(non_deprecated_fields.size()) + ");\n" ; |
1092 | |
1093 | for (auto it = non_deprecated_fields.begin(); |
1094 | it != non_deprecated_fields.end(); ++it) { |
1095 | auto pair = *it; |
1096 | auto &field = *pair.second; |
1097 | auto offset = pair.first; |
1098 | |
1099 | std::string field_name = |
1100 | (prependUnderscore ? "_" : "" ) + MakeCamel(field.name, false); |
1101 | |
1102 | if (IsScalar(field.value.type.base_type)) { |
1103 | code += " fbBuilder.add" + GenType(field.value.type) + "(" + |
1104 | NumToString(offset) + ", " + field_name; |
1105 | if (field.value.type.enum_def) { |
1106 | bool isNullable = getDefaultValue(field.value).empty(); |
1107 | code += (isNullable || !pack) ? "?.value" : ".value" ; |
1108 | } |
1109 | code += ");\n" ; |
1110 | } else if (IsStruct(field.value.type)) { |
1111 | code += " if (" + field_name + " != null) {\n" ; |
1112 | code += " fbBuilder.addStruct(" + NumToString(offset) + ", " + |
1113 | field_name + (pack ? "!.pack" : "!.finish" ) + "(fbBuilder));\n" ; |
1114 | code += " }\n" ; |
1115 | } else { |
1116 | code += " fbBuilder.addOffset(" + NumToString(offset) + ", " + |
1117 | MakeCamel(field.name, false) + "Offset);\n" ; |
1118 | } |
1119 | } |
1120 | code += " return fbBuilder.endTable();\n" ; |
1121 | return code; |
1122 | } |
1123 | }; |
1124 | } // namespace dart |
1125 | |
1126 | bool GenerateDart(const Parser &parser, const std::string &path, |
1127 | const std::string &file_name) { |
1128 | dart::DartGenerator generator(parser, path, file_name); |
1129 | return generator.generate(); |
1130 | } |
1131 | |
1132 | std::string DartMakeRule(const Parser &parser, const std::string &path, |
1133 | const std::string &file_name) { |
1134 | auto filebase = |
1135 | flatbuffers::StripPath(flatbuffers::StripExtension(file_name)); |
1136 | dart::DartGenerator generator(parser, path, file_name); |
1137 | auto make_rule = |
1138 | generator.GeneratedFileName(path, file_name, parser.opts) + ": " ; |
1139 | |
1140 | auto included_files = parser.GetIncludedFilesRecursive(file_name); |
1141 | for (auto it = included_files.begin(); it != included_files.end(); ++it) { |
1142 | make_rule += " " + *it; |
1143 | } |
1144 | return make_rule; |
1145 | } |
1146 | |
1147 | } // namespace flatbuffers |
1148 | |