mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-02 04:04:19 +00:00
142401f50a
* Eclipse ignore * TypeScript support * Prefixing enums * Test results * Merged JS and TS generators * Fixed AppVeyor build problems * Fixed more AppVeyor build problems * Fixed more AppVeyor build problems * Changed TS flag to options struct * Storing options by value * Removed unneeded const * Re-export support for unions * Uint support * Casting bools to numbers for mutation * TS shell tests * Reverted generates js test file to original version * Backing up js tests and properly generating test data * Not importing flatbuffers for TS test generation * Not overwriting generated js for tests * AppVeyor test fixes * Generating the most strict TS code possible * Not returning null when creating vectors * Not returning null from struct contructors * Vector of unions for ts/js * Sanity check for languages * Indentation fix + output test files * Vectors of unions for php * Fixes to union vector handling + tests * Fix for strictPropertyInitialization
1206 lines
42 KiB
C++
1206 lines
42 KiB
C++
/*
|
|
* Copyright 2014 Google Inc. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
// independent from idl_parser, since this code is not needed for most clients
|
|
#include <unordered_set>
|
|
#include <unordered_map>
|
|
#include <cassert>
|
|
|
|
#include "flatbuffers/flatbuffers.h"
|
|
#include "flatbuffers/idl.h"
|
|
#include "flatbuffers/util.h"
|
|
#include "flatbuffers/code_generators.h"
|
|
|
|
namespace flatbuffers {
|
|
|
|
const std::string kGeneratedFileNamePostfix = "_generated";
|
|
|
|
struct JsLanguageParameters {
|
|
IDLOptions::Language language;
|
|
std::string file_extension;
|
|
};
|
|
|
|
struct ReexportDescription {
|
|
std::string symbol;
|
|
std::string source_namespace;
|
|
std::string target_namespace;
|
|
};
|
|
|
|
const JsLanguageParameters& GetJsLangParams(IDLOptions::Language lang) {
|
|
static JsLanguageParameters js_language_parameters[] = {
|
|
{
|
|
IDLOptions::kJs,
|
|
".js",
|
|
},
|
|
{
|
|
IDLOptions::kTs,
|
|
".ts",
|
|
},
|
|
};
|
|
|
|
if (lang == IDLOptions::kJs) {
|
|
return js_language_parameters[0];
|
|
} else {
|
|
assert(lang == IDLOptions::kTs);
|
|
return js_language_parameters[1];
|
|
}
|
|
}
|
|
|
|
static std::string GeneratedFileName(const std::string &path,
|
|
const std::string &file_name,
|
|
const JsLanguageParameters &lang) {
|
|
return path + file_name + kGeneratedFileNamePostfix + lang.file_extension;
|
|
}
|
|
|
|
namespace js {
|
|
// Iterate through all definitions we haven't generate code for (enums, structs,
|
|
// and tables) and output them to a single file.
|
|
class JsGenerator : public BaseGenerator {
|
|
public:
|
|
typedef std::unordered_set<std::string> imported_fileset;
|
|
typedef std::unordered_multimap<std::string, ReexportDescription>
|
|
reexport_map;
|
|
|
|
JsGenerator(const Parser &parser, const std::string &path,
|
|
const std::string &file_name)
|
|
: BaseGenerator(parser, path, file_name, "", "."),
|
|
lang_(GetJsLangParams(parser_.opts.lang))
|
|
{
|
|
};
|
|
// Iterate through all definitions we haven't generate code for (enums,
|
|
// structs, and tables) and output them to a single file.
|
|
bool generate() {
|
|
imported_fileset imported_files;
|
|
reexport_map reexports;
|
|
|
|
std::string enum_code, struct_code, import_code, exports_code, code;
|
|
generateEnums(&enum_code, &exports_code, reexports);
|
|
generateStructs(&struct_code, &exports_code, imported_files);
|
|
generateImportDependencies(&import_code, imported_files);
|
|
generateReexports(&import_code, reexports, imported_files);
|
|
|
|
code = code + "// " + FlatBuffersGeneratedWarning() + "\n\n";
|
|
|
|
// Generate code for all the namespace declarations.
|
|
GenNamespaces(&code, &exports_code);
|
|
|
|
// Output the main declaration code from above.
|
|
code += import_code;
|
|
|
|
code += enum_code;
|
|
code += struct_code;
|
|
|
|
if (lang_.language == IDLOptions::kJs && !exports_code.empty() &&
|
|
!parser_.opts.skip_js_exports) {
|
|
code += "// Exports for Node.js and RequireJS\n";
|
|
code += exports_code;
|
|
}
|
|
|
|
return SaveFile(GeneratedFileName(path_, file_name_, lang_).c_str(), code,
|
|
false);
|
|
}
|
|
|
|
private:
|
|
JsLanguageParameters lang_;
|
|
|
|
// Generate code for imports
|
|
void generateImportDependencies(std::string *code_ptr,
|
|
const imported_fileset &imported_files) {
|
|
std::string &code = *code_ptr;
|
|
for (auto it = imported_files.begin(); it != imported_files.end(); ++it) {
|
|
const auto &file = *it;
|
|
const auto basename =
|
|
flatbuffers::StripPath(flatbuffers::StripExtension(file));
|
|
if (basename != file_name_) {
|
|
const auto file_name = basename + kGeneratedFileNamePostfix;
|
|
code += GenPrefixedImport(file, file_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate reexports, which might not have been explicitly imported using the
|
|
// "export import" trick
|
|
void generateReexports(std::string *code_ptr,
|
|
const reexport_map &reexports,
|
|
imported_fileset imported_files) {
|
|
if (!parser_.opts.reexport_ts_modules ||
|
|
lang_.language != IDLOptions::kTs) {
|
|
return;
|
|
}
|
|
|
|
std::string &code = *code_ptr;
|
|
for (auto it = reexports.begin(); it != reexports.end(); ++it) {
|
|
const auto &file = *it;
|
|
const auto basename =
|
|
flatbuffers::StripPath(flatbuffers::StripExtension(file.first));
|
|
if (basename != file_name_) {
|
|
const auto file_name = basename + kGeneratedFileNamePostfix;
|
|
|
|
if (imported_files.find(file.first) == imported_files.end()) {
|
|
code += GenPrefixedImport(file.first, file_name);
|
|
imported_files.emplace(file.first);
|
|
}
|
|
|
|
code += "export namespace " + file.second.target_namespace + " { \n";
|
|
code += "export import " + file.second.symbol + " = ";
|
|
code += GenFileNamespacePrefix(file.first) + "." +
|
|
file.second.source_namespace + "." + file.second.symbol +
|
|
"; }\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate code for all enums.
|
|
void generateEnums(std::string *enum_code_ptr,
|
|
std::string *exports_code_ptr,
|
|
reexport_map &reexports) {
|
|
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
|
|
++it) {
|
|
auto &enum_def = **it;
|
|
GenEnum(enum_def, enum_code_ptr, exports_code_ptr, reexports);
|
|
}
|
|
}
|
|
|
|
// Generate code for all structs.
|
|
void generateStructs(std::string *decl_code_ptr,
|
|
std::string *exports_code_ptr,
|
|
imported_fileset &imported_files) {
|
|
for (auto it = parser_.structs_.vec.begin();
|
|
it != parser_.structs_.vec.end(); ++it) {
|
|
auto &struct_def = **it;
|
|
GenStruct(parser_, struct_def, decl_code_ptr, exports_code_ptr,
|
|
imported_files);
|
|
}
|
|
}
|
|
void GenNamespaces(std::string *code_ptr, std::string *exports_ptr) {
|
|
if (lang_.language == IDLOptions::kTs &&
|
|
parser_.opts.skip_flatbuffers_import) {
|
|
return;
|
|
}
|
|
|
|
std::set<std::string> namespaces;
|
|
|
|
for (auto it = parser_.namespaces_.begin();
|
|
it != parser_.namespaces_.end(); ++it) {
|
|
std::string namespace_so_far;
|
|
|
|
// Gather all parent namespaces for this namespace
|
|
for (auto component = (*it)->components.begin();
|
|
component != (*it)->components.end(); ++component) {
|
|
if (!namespace_so_far.empty()) {
|
|
namespace_so_far += '.';
|
|
}
|
|
namespace_so_far += *component;
|
|
namespaces.insert(namespace_so_far);
|
|
}
|
|
}
|
|
|
|
// Make sure parent namespaces come before child namespaces
|
|
std::vector<std::string> sorted_namespaces(
|
|
namespaces.begin(), namespaces.end());
|
|
std::sort(sorted_namespaces.begin(), sorted_namespaces.end());
|
|
|
|
// Emit namespaces in a form that Closure Compiler can optimize
|
|
std::string &code = *code_ptr;
|
|
std::string &exports = *exports_ptr;
|
|
for (auto it = sorted_namespaces.begin();
|
|
it != sorted_namespaces.end(); it++) {
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
if (it->find('.') == std::string::npos) {
|
|
code += "import { flatbuffers } from \"./flatbuffers\"\n";
|
|
break;
|
|
}
|
|
} else {
|
|
code += "/**\n * @const\n * @namespace\n */\n";
|
|
if (it->find('.') == std::string::npos) {
|
|
code += "var ";
|
|
if(parser_.opts.use_goog_js_export_format) {
|
|
exports += "goog.exportSymbol('" + *it + "', " + *it + ");\n";
|
|
} else {
|
|
exports += "this." + *it + " = " + *it + ";\n";
|
|
}
|
|
}
|
|
code += *it + " = " + *it + " || {};\n\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate a documentation comment, if available.
|
|
static void GenDocComment(const std::vector<std::string> &dc,
|
|
std::string *code_ptr,
|
|
const std::string &extra_lines,
|
|
const char *indent = nullptr) {
|
|
if (dc.empty() && extra_lines.empty()) {
|
|
// Don't output empty comment blocks with 0 lines of comment content.
|
|
return;
|
|
}
|
|
|
|
std::string &code = *code_ptr;
|
|
if (indent) code += indent;
|
|
code += "/**\n";
|
|
for (auto it = dc.begin(); it != dc.end(); ++it) {
|
|
if (indent) code += indent;
|
|
code += " *" + *it + "\n";
|
|
}
|
|
if (!extra_lines.empty()) {
|
|
if (!dc.empty()) {
|
|
if (indent) code += indent;
|
|
code += " *\n";
|
|
}
|
|
if (indent) code += indent;
|
|
std::string::size_type start = 0;
|
|
for (;;) {
|
|
auto end = extra_lines.find('\n', start);
|
|
if (end != std::string::npos) {
|
|
code += " * " + extra_lines.substr(start, end - start) + "\n";
|
|
start = end + 1;
|
|
} else {
|
|
code += " * " + extra_lines.substr(start) + "\n";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (indent) code += indent;
|
|
code += " */\n";
|
|
}
|
|
|
|
static void GenDocComment(std::string *code_ptr,
|
|
const std::string &extra_lines) {
|
|
GenDocComment(std::vector<std::string>(), code_ptr, extra_lines);
|
|
}
|
|
|
|
// Generate an enum declaration and an enum string lookup table.
|
|
void GenEnum(EnumDef &enum_def, std::string *code_ptr,
|
|
std::string *exports_ptr, reexport_map &reexports) {
|
|
if (enum_def.generated) return;
|
|
std::string &code = *code_ptr;
|
|
std::string &exports = *exports_ptr;
|
|
GenDocComment(enum_def.doc_comment, code_ptr, "@enum");
|
|
std::string ns = GetNameSpace(enum_def);
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
if (!ns.empty()) {
|
|
code += "export namespace " + ns + "{\n";
|
|
}
|
|
code += "export enum " + enum_def.name + "{\n";
|
|
} else {
|
|
if (enum_def.defined_namespace->components.empty()) {
|
|
code += "var ";
|
|
if(parser_.opts.use_goog_js_export_format) {
|
|
exports += "goog.exportSymbol('" + enum_def.name + "', " +
|
|
enum_def.name + ");\n";
|
|
} else {
|
|
exports += "this." + enum_def.name + " = " + enum_def.name + ";\n";
|
|
}
|
|
}
|
|
code += WrapInNameSpace(enum_def) + " = {\n";
|
|
}
|
|
for (auto it = enum_def.vals.vec.begin();
|
|
it != enum_def.vals.vec.end(); ++it) {
|
|
auto &ev = **it;
|
|
if (!ev.doc_comment.empty()) {
|
|
if (it != enum_def.vals.vec.begin()) {
|
|
code += '\n';
|
|
}
|
|
GenDocComment(ev.doc_comment, code_ptr, "", " ");
|
|
}
|
|
code += " " + ev.name;
|
|
code += lang_.language == IDLOptions::kTs ? "= " : ": ";
|
|
code += NumToString(ev.value);
|
|
code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n";
|
|
|
|
if (ev.union_type.struct_def) {
|
|
ReexportDescription desc = {
|
|
ev.name,
|
|
GetNameSpace(*ev.union_type.struct_def),
|
|
GetNameSpace(enum_def)
|
|
};
|
|
reexports.insert(std::make_pair(ev.union_type.struct_def->file,
|
|
std::move(desc)));
|
|
}
|
|
}
|
|
|
|
if (lang_.language == IDLOptions::kTs && !ns.empty()) {
|
|
code += "}";
|
|
}
|
|
code += "};\n\n";
|
|
}
|
|
|
|
static std::string GenType(const Type &type) {
|
|
switch (type.base_type) {
|
|
case BASE_TYPE_BOOL:
|
|
case BASE_TYPE_CHAR: return "Int8";
|
|
case BASE_TYPE_UTYPE:
|
|
case BASE_TYPE_UCHAR: return "Uint8";
|
|
case BASE_TYPE_SHORT: return "Int16";
|
|
case BASE_TYPE_USHORT: return "Uint16";
|
|
case BASE_TYPE_INT: return "Int32";
|
|
case BASE_TYPE_UINT: return "Uint32";
|
|
case BASE_TYPE_LONG: return "Int64";
|
|
case BASE_TYPE_ULONG: return "Uint64";
|
|
case BASE_TYPE_FLOAT: return "Float32";
|
|
case BASE_TYPE_DOUBLE: return "Float64";
|
|
case BASE_TYPE_STRING: return "String";
|
|
case BASE_TYPE_VECTOR: return GenType(type.VectorType());
|
|
case BASE_TYPE_STRUCT: return type.struct_def->name;
|
|
default: return "Table";
|
|
}
|
|
}
|
|
|
|
std::string GenGetter(const Type &type, const std::string &arguments) {
|
|
switch (type.base_type) {
|
|
case BASE_TYPE_STRING: return GenBBAccess() + ".__string" + arguments;
|
|
case BASE_TYPE_STRUCT: return GenBBAccess() + ".__struct" + arguments;
|
|
case BASE_TYPE_UNION: return GenBBAccess() + ".__union" + arguments;
|
|
case BASE_TYPE_VECTOR: return GenGetter(type.VectorType(), arguments);
|
|
default: {
|
|
auto getter = GenBBAccess() + ".read" + MakeCamel(GenType(type)) + arguments;
|
|
if (type.base_type == BASE_TYPE_BOOL) {
|
|
getter = "!!" + getter;
|
|
}
|
|
if (type.enum_def) {
|
|
getter = "/** @type {" + WrapInNameSpace(*type.enum_def) + "} */ (" +
|
|
getter + ")";
|
|
}
|
|
return getter;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string GenBBAccess() {
|
|
return lang_.language == IDLOptions::kTs ? "this.bb!" : "this.bb";
|
|
}
|
|
|
|
std::string GenDefaultValue(const Value &value, const std::string &context) {
|
|
if (value.type.enum_def) {
|
|
if (auto val = value.type.enum_def->ReverseLookup(
|
|
atoi(value.constant.c_str()), false)) {
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
return GenPrefixedTypeName(WrapInNameSpace(*value.type.enum_def),
|
|
value.type.enum_def->file) + "." + val->name;
|
|
} else {
|
|
return WrapInNameSpace(*value.type.enum_def) + "." + val->name;
|
|
}
|
|
} else {
|
|
return "/** @type {" + WrapInNameSpace(*value.type.enum_def) + "} */ ("
|
|
+ value.constant + ")";
|
|
}
|
|
}
|
|
|
|
switch (value.type.base_type) {
|
|
case BASE_TYPE_BOOL:
|
|
return value.constant == "0" ? "false" : "true";
|
|
|
|
case BASE_TYPE_STRING:
|
|
return "null";
|
|
|
|
case BASE_TYPE_LONG:
|
|
case BASE_TYPE_ULONG: {
|
|
int64_t constant = StringToInt(value.constant.c_str());
|
|
return context + ".createLong(" + NumToString((int32_t)constant) +
|
|
", " + NumToString((int32_t)(constant >> 32)) + ")";
|
|
}
|
|
|
|
default:
|
|
return value.constant;
|
|
}
|
|
}
|
|
|
|
std::string GenTypeName(const Type &type, bool input, bool allowNull = false) {
|
|
if (!input) {
|
|
if (type.base_type == BASE_TYPE_STRING || type.base_type == BASE_TYPE_STRUCT) {
|
|
std::string name;
|
|
if (type.base_type == BASE_TYPE_STRING) {
|
|
name = "string|Uint8Array";
|
|
} else {
|
|
name = WrapInNameSpace(*type.struct_def);
|
|
}
|
|
return (allowNull) ? (name + "|null") : (name);
|
|
}
|
|
}
|
|
|
|
switch (type.base_type) {
|
|
case BASE_TYPE_BOOL: return "boolean";
|
|
case BASE_TYPE_LONG:
|
|
case BASE_TYPE_ULONG: return "flatbuffers.Long";
|
|
default:
|
|
if (IsScalar(type.base_type)) {
|
|
if (type.enum_def) {
|
|
return WrapInNameSpace(*type.enum_def);
|
|
}
|
|
return "number";
|
|
}
|
|
return "flatbuffers.Offset";
|
|
}
|
|
}
|
|
|
|
// Returns the method name for use with add/put calls.
|
|
static std::string GenWriteMethod(const Type &type) {
|
|
// Forward to signed versions since unsigned versions don't exist
|
|
switch (type.base_type) {
|
|
case BASE_TYPE_UTYPE:
|
|
case BASE_TYPE_UCHAR: return GenWriteMethod(Type(BASE_TYPE_CHAR));
|
|
case BASE_TYPE_USHORT: return GenWriteMethod(Type(BASE_TYPE_SHORT));
|
|
case BASE_TYPE_UINT: return GenWriteMethod(Type(BASE_TYPE_INT));
|
|
case BASE_TYPE_ULONG: return GenWriteMethod(Type(BASE_TYPE_LONG));
|
|
default: break;
|
|
}
|
|
|
|
return IsScalar(type.base_type)
|
|
? MakeCamel(GenType(type))
|
|
: (IsStruct(type) ? "Struct" : "Offset");
|
|
}
|
|
|
|
template <typename T>
|
|
static std::string MaybeAdd(T value) {
|
|
return value != 0 ? " + " + NumToString(value) : "";
|
|
}
|
|
|
|
template <typename T>
|
|
static std::string MaybeScale(T value) {
|
|
return value != 1 ? " * " + NumToString(value) : "";
|
|
}
|
|
|
|
static std::string GenFileNamespacePrefix(const std::string &file) {
|
|
return "NS" + std::to_string(
|
|
static_cast<unsigned long long>(std::hash<std::string>()(file)));
|
|
}
|
|
|
|
static std::string GenPrefixedImport(const std::string &full_file_name,
|
|
const std::string &base_file_name) {
|
|
return "import * as "+ GenFileNamespacePrefix(full_file_name) +
|
|
" from \"./" + base_file_name + "\";\n";
|
|
}
|
|
|
|
// Adds a source-dependent prefix, for of import * statements.
|
|
std::string GenPrefixedTypeName(const std::string &typeName,
|
|
const std::string &file) {
|
|
const auto basename =
|
|
flatbuffers::StripPath(flatbuffers::StripExtension(file));
|
|
if (basename == file_name_) {
|
|
return typeName;
|
|
}
|
|
return GenFileNamespacePrefix(file) + "." + typeName;
|
|
}
|
|
|
|
void GenStructArgs(const StructDef &struct_def,
|
|
std::string *annotations,
|
|
std::string *arguments,
|
|
const std::string &nameprefix) {
|
|
for (auto it = struct_def.fields.vec.begin();
|
|
it != struct_def.fields.vec.end(); ++it) {
|
|
auto &field = **it;
|
|
if (IsStruct(field.value.type)) {
|
|
// Generate arguments for a struct inside a struct. To ensure names
|
|
// don't clash, and to make it obvious these arguments are constructing
|
|
// a nested struct, prefix the name with the field name.
|
|
GenStructArgs(*field.value.type.struct_def, annotations, arguments,
|
|
nameprefix + field.name + "_");
|
|
} else {
|
|
*annotations += "@param {" + GenTypeName(field.value.type, true);
|
|
*annotations += "} " + nameprefix + field.name + "\n";
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
*arguments += ", " + nameprefix + field.name + ": " +
|
|
GenTypeName(field.value.type, true);
|
|
} else {
|
|
*arguments += ", " + nameprefix + field.name;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void GenStructBody(const StructDef &struct_def,
|
|
std::string *body,
|
|
const std::string &nameprefix) {
|
|
*body += " builder.prep(";
|
|
*body += NumToString(struct_def.minalign) + ", ";
|
|
*body += NumToString(struct_def.bytesize) + ");\n";
|
|
|
|
for (auto it = struct_def.fields.vec.rbegin();
|
|
it != struct_def.fields.vec.rend(); ++it) {
|
|
auto &field = **it;
|
|
if (field.padding) {
|
|
*body += " builder.pad(" + NumToString(field.padding) + ");\n";
|
|
}
|
|
if (IsStruct(field.value.type)) {
|
|
// Generate arguments for a struct inside a struct. To ensure names
|
|
// don't clash, and to make it obvious these arguments are constructing
|
|
// a nested struct, prefix the name with the field name.
|
|
GenStructBody(*field.value.type.struct_def, body,
|
|
nameprefix + field.name + "_");
|
|
} else {
|
|
*body += " builder.write" + GenWriteMethod(field.value.type) + "(";
|
|
if (field.value.type.base_type == BASE_TYPE_BOOL) {
|
|
*body += "+";
|
|
}
|
|
*body += nameprefix + field.name + ");\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate an accessor struct with constructor for a flatbuffers struct.
|
|
void GenStruct(const Parser &parser, StructDef &struct_def,
|
|
std::string *code_ptr, std::string *exports_ptr,
|
|
imported_fileset &imported_files) {
|
|
if (struct_def.generated) return;
|
|
std::string &code = *code_ptr;
|
|
std::string &exports = *exports_ptr;
|
|
|
|
std::string object_name;
|
|
std::string object_namespace = GetNameSpace(struct_def);
|
|
|
|
// Emit constructor
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
object_name = struct_def.name;
|
|
GenDocComment(struct_def.doc_comment, code_ptr, "@constructor");
|
|
if (!object_namespace.empty()) {
|
|
code += "export namespace " + object_namespace + "{\n";
|
|
}
|
|
code += "export class " + struct_def.name;
|
|
code += " {\n";
|
|
code += " /**\n";
|
|
code += " * @type {flatbuffers.ByteBuffer}\n";
|
|
code += " */\n";
|
|
code += " bb: flatbuffers.ByteBuffer|null = null;\n";
|
|
code += "\n";
|
|
code += " /**\n";
|
|
code += " * @type {number}\n";
|
|
code += " */\n";
|
|
code += " bb_pos:number = 0;\n";
|
|
} else {
|
|
bool isStatement = struct_def.defined_namespace->components.empty();
|
|
object_name = WrapInNameSpace(struct_def);
|
|
GenDocComment(struct_def.doc_comment, code_ptr, "@constructor");
|
|
if (isStatement) {
|
|
if(parser_.opts.use_goog_js_export_format) {
|
|
exports += "goog.exportSymbol('" + struct_def.name + "', " +
|
|
struct_def.name + ");\n";
|
|
} else {
|
|
exports += "this." + struct_def.name + " = " + struct_def.name + ";\n";
|
|
}
|
|
code += "function " + object_name;
|
|
} else {
|
|
code += object_name + " = function";
|
|
}
|
|
code += "() {\n";
|
|
code += " /**\n";
|
|
code += " * @type {flatbuffers.ByteBuffer}\n";
|
|
code += " */\n";
|
|
code += " this.bb = null;\n";
|
|
code += "\n";
|
|
code += " /**\n";
|
|
code += " * @type {number}\n";
|
|
code += " */\n";
|
|
code += " this.bb_pos = 0;\n";
|
|
code += isStatement ? "}\n\n" : "};\n\n";
|
|
}
|
|
|
|
// Generate the __init method that sets the field in a pre-existing
|
|
// accessor object. This is to allow object reuse.
|
|
code += "/**\n";
|
|
code += " * @param {number} i\n";
|
|
code += " * @param {flatbuffers.ByteBuffer} bb\n";
|
|
code += " * @returns {" + object_name + "}\n";
|
|
code += " */\n";
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "__init(i:number, bb:flatbuffers.ByteBuffer):" + object_name +
|
|
" {\n";
|
|
} else {
|
|
code += object_name + ".prototype.__init = function(i, bb) {\n";
|
|
}
|
|
|
|
code += " this.bb_pos = i;\n";
|
|
code += " this.bb = bb;\n";
|
|
code += " return this;\n";
|
|
code += "};\n\n";
|
|
|
|
// Generate a special accessor for the table that when used as the root of a
|
|
// FlatBuffer
|
|
if (!struct_def.fixed) {
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.ByteBuffer} bb\n"
|
|
"@param {" + object_name + "=} obj\n"
|
|
"@returns {" + object_name + "}");
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "static getRootAs" + struct_def.name;
|
|
code += "(bb:flatbuffers.ByteBuffer, obj?:" + object_name + "):" +
|
|
object_name + " {\n";
|
|
} else {
|
|
code += object_name + ".getRootAs" + struct_def.name;
|
|
code += " = function(bb, obj) {\n";
|
|
}
|
|
code += " return (obj || new " + object_name;
|
|
code += ").__init(bb.readInt32(bb.position()) + bb.position(), bb);\n";
|
|
code += "};\n\n";
|
|
|
|
// Generate the identifier check method
|
|
if (parser_.root_struct_def_ == &struct_def &&
|
|
!parser_.file_identifier_.empty()) {
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.ByteBuffer} bb\n"
|
|
"@returns {boolean}");
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code +=
|
|
"static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {\n";
|
|
} else {
|
|
code += object_name + ".bufferHasIdentifier = function(bb) {\n";
|
|
}
|
|
|
|
code += " return bb.__has_identifier('" + parser_.file_identifier_;
|
|
code += "');\n};\n\n";
|
|
}
|
|
}
|
|
|
|
// Emit field accessors
|
|
for (auto it = struct_def.fields.vec.begin();
|
|
it != struct_def.fields.vec.end(); ++it) {
|
|
auto &field = **it;
|
|
if (field.deprecated) continue;
|
|
auto offset_prefix = " var offset = " + GenBBAccess() +
|
|
".__offset(this.bb_pos, " + NumToString(field.value.offset) +
|
|
");\n return offset ? ";
|
|
|
|
// Emit a scalar field
|
|
if (IsScalar(field.value.type.base_type) ||
|
|
field.value.type.base_type == BASE_TYPE_STRING) {
|
|
GenDocComment(field.doc_comment, code_ptr,
|
|
std::string(field.value.type.base_type == BASE_TYPE_STRING ?
|
|
"@param {flatbuffers.Encoding=} optionalEncoding\n" : "") +
|
|
"@returns {" + GenTypeName(field.value.type, false, true) + "}");
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
std::string prefix = MakeCamel(field.name, false) + "(";
|
|
if (field.value.type.base_type == BASE_TYPE_STRING) {
|
|
code += prefix + "):string|null\n";
|
|
code += prefix + "optionalEncoding:flatbuffers.Encoding"+"):" +
|
|
GenTypeName(field.value.type, false, true)+"\n";
|
|
code += prefix + "optionalEncoding?:any";
|
|
} else {
|
|
code += prefix;
|
|
}
|
|
if (field.value.type.enum_def) {
|
|
code += "):" +
|
|
GenPrefixedTypeName(GenTypeName(field.value.type, false, true),
|
|
field.value.type.enum_def->file) + " {\n";
|
|
} else {
|
|
code += "):" + GenTypeName(field.value.type, false, true) + " {\n";
|
|
}
|
|
} else {
|
|
code += object_name + ".prototype." + MakeCamel(field.name, false);
|
|
code += " = function(";
|
|
if (field.value.type.base_type == BASE_TYPE_STRING) {
|
|
code += "optionalEncoding";
|
|
}
|
|
code += ") {\n";
|
|
}
|
|
|
|
if (struct_def.fixed) {
|
|
code += " return " + GenGetter(field.value.type, "(this.bb_pos" +
|
|
MaybeAdd(field.value.offset) + ")") + ";\n";
|
|
} else {
|
|
std::string index = "this.bb_pos + offset";
|
|
if (field.value.type.base_type == BASE_TYPE_STRING) {
|
|
index += ", optionalEncoding";
|
|
}
|
|
code += offset_prefix + GenGetter(field.value.type,
|
|
"(" + index + ")") + " : " + GenDefaultValue(field.value, GenBBAccess());
|
|
code += ";\n";
|
|
}
|
|
}
|
|
|
|
// Emit an object field
|
|
else {
|
|
switch (field.value.type.base_type) {
|
|
case BASE_TYPE_STRUCT: {
|
|
auto type = WrapInNameSpace(*field.value.type.struct_def);
|
|
GenDocComment(field.doc_comment, code_ptr,
|
|
"@param {" + type + "=} obj\n@returns {" + type + "|null}");
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
type = GenPrefixedTypeName(type, field.value.type.struct_def->file);
|
|
code += MakeCamel(field.name, false);
|
|
code += "(obj?:" + type + "):" + type + "|null {\n";
|
|
} else {
|
|
code += object_name + ".prototype." + MakeCamel(field.name, false);
|
|
code += " = function(obj) {\n";
|
|
}
|
|
|
|
if (struct_def.fixed) {
|
|
code += " return (obj || new " + type;
|
|
code += ").__init(this.bb_pos";
|
|
code += MaybeAdd(field.value.offset) + ", " + GenBBAccess() + ");\n";
|
|
} else {
|
|
code += offset_prefix + "(obj || new " + type + ").__init(";
|
|
code += field.value.type.struct_def->fixed
|
|
? "this.bb_pos + offset"
|
|
: GenBBAccess() + ".__indirect(this.bb_pos + offset)";
|
|
code += ", " + GenBBAccess() + ") : null;\n";
|
|
}
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
imported_files.insert(field.value.type.struct_def->file);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case BASE_TYPE_VECTOR: {
|
|
auto vectortype = field.value.type.VectorType();
|
|
auto vectortypename = GenTypeName(vectortype, false);
|
|
auto inline_size = InlineSize(vectortype);
|
|
auto index = GenBBAccess() + ".__vector(this.bb_pos + offset) + index" +
|
|
MaybeScale(inline_size);
|
|
std::string args = "@param {number} index\n";
|
|
std::string ret_type;
|
|
bool is_union = false;
|
|
switch (vectortype.base_type) {
|
|
case BASE_TYPE_STRUCT:
|
|
args += "@param {" + vectortypename + "=} obj\n";
|
|
ret_type = vectortypename;
|
|
break;
|
|
case BASE_TYPE_STRING:
|
|
args += "@param {flatbuffers.Encoding=} optionalEncoding\n";
|
|
ret_type = vectortypename;
|
|
break;
|
|
case BASE_TYPE_UNION:
|
|
args += "@param {flatbuffers.Table=} obj\n";
|
|
ret_type = "?flatbuffers.Table";
|
|
is_union = true;
|
|
break;
|
|
default:
|
|
ret_type = vectortypename;
|
|
}
|
|
GenDocComment(field.doc_comment, code_ptr, args +
|
|
"@returns {" + ret_type + "}");
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
std::string prefix = MakeCamel(field.name, false);
|
|
if (is_union) {
|
|
prefix += "<T extends flatbuffers.Table>";
|
|
}
|
|
prefix += "(index: number";
|
|
if (is_union) {
|
|
vectortypename = "T";
|
|
code += prefix + ", obj:T";
|
|
} else if (vectortype.base_type == BASE_TYPE_STRUCT) {
|
|
vectortypename = GenPrefixedTypeName(vectortypename,
|
|
vectortype.struct_def->file);
|
|
code += prefix + ", obj?:" + vectortypename;
|
|
imported_files.insert(vectortype.struct_def->file);
|
|
} else if (vectortype.base_type == BASE_TYPE_STRING) {
|
|
code += prefix + "):string\n";
|
|
code += prefix + ",optionalEncoding:flatbuffers.Encoding" + "):" +
|
|
vectortypename + "\n";
|
|
code += prefix + ",optionalEncoding?:any";
|
|
} else {
|
|
code += prefix;
|
|
}
|
|
code += "):" + vectortypename + "|null {\n";
|
|
} else {
|
|
code += object_name + ".prototype." + MakeCamel(field.name, false);
|
|
code += " = function(index";
|
|
if (vectortype.base_type == BASE_TYPE_STRUCT || is_union) {
|
|
code += ", obj";
|
|
} else if (vectortype.base_type == BASE_TYPE_STRING) {
|
|
code += ", optionalEncoding";
|
|
}
|
|
code += ") {\n";
|
|
}
|
|
|
|
if (vectortype.base_type == BASE_TYPE_STRUCT) {
|
|
code += offset_prefix + "(obj || new " + vectortypename;
|
|
code += ").__init(";
|
|
code += vectortype.struct_def->fixed
|
|
? index
|
|
: GenBBAccess() + ".__indirect(" + index + ")";
|
|
code += ", " + GenBBAccess() + ")";
|
|
} else {
|
|
if (is_union) {
|
|
index = "obj, " + index;
|
|
} else if (vectortype.base_type == BASE_TYPE_STRING) {
|
|
index += ", optionalEncoding";
|
|
}
|
|
code += offset_prefix + GenGetter(vectortype, "(" + index + ")");
|
|
}
|
|
code += " : ";
|
|
if (field.value.type.element == BASE_TYPE_BOOL) {
|
|
code += "false";
|
|
} else if (field.value.type.element == BASE_TYPE_LONG ||
|
|
field.value.type.element == BASE_TYPE_ULONG) {
|
|
code += GenBBAccess() + ".createLong(0, 0)";
|
|
} else if (IsScalar(field.value.type.element)) {
|
|
if (field.value.type.enum_def) {
|
|
code += "/** @type {" +
|
|
WrapInNameSpace(*field.value.type.enum_def) + "} */ (" +
|
|
field.value.constant + ")";
|
|
} else {
|
|
code += "0";
|
|
}
|
|
} else {
|
|
code += "null";
|
|
}
|
|
code += ";\n";
|
|
break;
|
|
}
|
|
|
|
case BASE_TYPE_UNION:
|
|
GenDocComment(field.doc_comment, code_ptr,
|
|
"@param {flatbuffers.Table} obj\n"
|
|
"@returns {?flatbuffers.Table}");
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += MakeCamel(field.name, false);
|
|
code += "<T extends flatbuffers.Table>(obj:T):T|null {\n";
|
|
} else {
|
|
code += object_name + ".prototype." + MakeCamel(field.name, false);
|
|
code += " = function(obj) {\n";
|
|
}
|
|
|
|
code += offset_prefix + GenGetter(field.value.type,
|
|
"(obj, this.bb_pos + offset)") + " : null;\n";
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
}
|
|
code += "};\n\n";
|
|
|
|
if(parser_.opts.use_goog_js_export_format) {
|
|
exports += "goog.exportProperty(" + object_name + ".prototype, '" +
|
|
MakeCamel(field.name, false) + "', " + object_name + ".prototype." +
|
|
MakeCamel(field.name, false) + ");\n";
|
|
}
|
|
|
|
// Adds the mutable scalar value to the output
|
|
if (IsScalar(field.value.type.base_type) && parser.opts.mutable_buffer) {
|
|
std::string annotations =
|
|
"@param {" + GenTypeName(field.value.type, true) + "} value\n";
|
|
GenDocComment(code_ptr, annotations +
|
|
"@returns {boolean}");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
std::string type;
|
|
if (field.value.type.enum_def) {
|
|
type = GenPrefixedTypeName(GenTypeName(field.value.type, true),
|
|
field.value.type.enum_def->file);
|
|
} else {
|
|
type = GenTypeName(field.value.type, true);
|
|
}
|
|
|
|
code += "mutate_" + field.name + "(value:" + type + "):boolean {\n";
|
|
} else {
|
|
code += object_name + ".prototype.mutate_" + field.name +
|
|
" = function(value) {\n";
|
|
}
|
|
|
|
code += " var offset = " + GenBBAccess() + ".__offset(this.bb_pos, " +
|
|
NumToString(field.value.offset) + ");\n\n";
|
|
code += " if (offset === 0) {\n";
|
|
code += " return false;\n";
|
|
code += " }\n\n";
|
|
|
|
// special case for bools, which are treated as uint8
|
|
code += " " + GenBBAccess() + ".write" +
|
|
MakeCamel(GenType(field.value.type)) + "(this.bb_pos + offset, ";
|
|
if (field.value.type.base_type == BASE_TYPE_BOOL &&
|
|
lang_.language == IDLOptions::kTs) {
|
|
code += "+";
|
|
}
|
|
|
|
code += "value);\n";
|
|
code += " return true;\n";
|
|
code += "};\n\n";
|
|
|
|
if(parser_.opts.use_goog_js_export_format) {
|
|
exports += "goog.exportProperty(" + object_name +
|
|
".prototype, 'mutate_" + field.name + "', " + object_name +
|
|
".prototype.mutate_" + field.name + ");\n";
|
|
}
|
|
}
|
|
|
|
// Emit vector helpers
|
|
if (field.value.type.base_type == BASE_TYPE_VECTOR) {
|
|
// Emit a length helper
|
|
GenDocComment(code_ptr, "@returns {number}");
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += MakeCamel(field.name, false);
|
|
code += "Length():number {\n" + offset_prefix;
|
|
} else {
|
|
code += object_name + ".prototype." + MakeCamel(field.name, false);
|
|
code += "Length = function() {\n" + offset_prefix;
|
|
}
|
|
|
|
code += GenBBAccess() + ".__vector_len(this.bb_pos + offset) : 0;\n};\n\n";
|
|
|
|
if(parser_.opts.use_goog_js_export_format) {
|
|
exports += "goog.exportProperty(" + object_name + ".prototype, '" +
|
|
MakeCamel(field.name, false) + "Length', " + object_name +
|
|
".prototype." + MakeCamel(field.name, false) + "Length);\n";
|
|
}
|
|
|
|
// For scalar types, emit a typed array helper
|
|
auto vectorType = field.value.type.VectorType();
|
|
if (IsScalar(vectorType.base_type) && !IsLong(vectorType.base_type)) {
|
|
GenDocComment(code_ptr, "@returns {" + GenType(vectorType) + "Array}");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += MakeCamel(field.name, false);
|
|
code += "Array():" + GenType(vectorType) + "Array|null {\n" +
|
|
offset_prefix;
|
|
} else {
|
|
code += object_name + ".prototype." + MakeCamel(field.name, false);
|
|
code += "Array = function() {\n" + offset_prefix;
|
|
}
|
|
|
|
code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() +
|
|
".bytes().buffer, " + GenBBAccess() + ".bytes().byteOffset + " +
|
|
GenBBAccess() + ".__vector(this.bb_pos + offset), " +
|
|
GenBBAccess() + ".__vector_len(this.bb_pos + offset)) : null;\n};\n\n";
|
|
|
|
if(parser_.opts.use_goog_js_export_format) {
|
|
exports += "goog.exportProperty(" + object_name + ".prototype, '" +
|
|
MakeCamel(field.name, false) + "Array', " + object_name +
|
|
".prototype." + MakeCamel(field.name, false) + "Array);\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Emit a factory constructor
|
|
if (struct_def.fixed) {
|
|
std::string annotations = "@param {flatbuffers.Builder} builder\n";
|
|
std::string arguments;
|
|
GenStructArgs(struct_def, &annotations, &arguments, "");
|
|
GenDocComment(code_ptr, annotations +
|
|
"@returns {flatbuffers.Offset}");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "static create" + struct_def.name + "(builder:flatbuffers.Builder";
|
|
code += arguments + "):flatbuffers.Offset {\n";
|
|
} else {
|
|
code += object_name + ".create" + struct_def.name + " = function(builder";
|
|
code += arguments + ") {\n";
|
|
}
|
|
|
|
GenStructBody(struct_def, &code, "");
|
|
code += " return builder.offset();\n};\n\n";
|
|
} else {
|
|
// Generate a method to start building a new object
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.Builder} builder");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "static start" + struct_def.name;
|
|
code += "(builder:flatbuffers.Builder) {\n";
|
|
} else {
|
|
code += object_name + ".start" + struct_def.name;
|
|
code += " = function(builder) {\n";
|
|
}
|
|
|
|
code += " builder.startObject(" + NumToString(
|
|
struct_def.fields.vec.size()) + ");\n";
|
|
code += "};\n\n";
|
|
|
|
// Generate a set of static methods that allow table construction
|
|
for (auto it = struct_def.fields.vec.begin();
|
|
it != struct_def.fields.vec.end(); ++it) {
|
|
auto &field = **it;
|
|
if (field.deprecated) continue;
|
|
auto argname = MakeCamel(field.name, false);
|
|
if (!IsScalar(field.value.type.base_type)) {
|
|
argname += "Offset";
|
|
}
|
|
|
|
// Generate the field insertion method
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.Builder} builder\n"
|
|
"@param {" + GenTypeName(field.value.type, true) + "} " +
|
|
argname);
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
std::string argType;
|
|
if (field.value.type.enum_def) {
|
|
argType = GenPrefixedTypeName(GenTypeName(field.value.type, true),
|
|
field.value.type.enum_def->file);
|
|
} else {
|
|
argType = GenTypeName(field.value.type, true);
|
|
}
|
|
|
|
code += "static add" + MakeCamel(field.name);
|
|
code += "(builder:flatbuffers.Builder, " + argname + ":" + argType +
|
|
") {\n";
|
|
} else {
|
|
code += object_name + ".add" + MakeCamel(field.name);
|
|
code += " = function(builder, " + argname + ") {\n";
|
|
}
|
|
|
|
code += " builder.addField" + GenWriteMethod(field.value.type) + "(";
|
|
code += NumToString(it - struct_def.fields.vec.begin()) + ", ";
|
|
if (field.value.type.base_type == BASE_TYPE_BOOL) {
|
|
code += "+";
|
|
}
|
|
code += argname + ", ";
|
|
if (!IsScalar(field.value.type.base_type)) {
|
|
code += "0";
|
|
} else {
|
|
if (field.value.type.base_type == BASE_TYPE_BOOL) {
|
|
code += "+";
|
|
}
|
|
code += GenDefaultValue(field.value, "builder");
|
|
}
|
|
code += ");\n};\n\n";
|
|
|
|
if (field.value.type.base_type == BASE_TYPE_VECTOR) {
|
|
auto vector_type = field.value.type.VectorType();
|
|
auto alignment = InlineAlignment(vector_type);
|
|
auto elem_size = InlineSize(vector_type);
|
|
|
|
// Generate a method to create a vector from a JavaScript array
|
|
if (!IsStruct(vector_type)) {
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.Builder} builder\n"
|
|
"@param {Array.<" + GenTypeName(vector_type, true) +
|
|
">} data\n"
|
|
"@returns {flatbuffers.Offset}");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "static create" + MakeCamel(field.name);
|
|
std::string type = GenTypeName(vector_type, true) + "[]";
|
|
if (type == "number[]") {
|
|
type += " | Uint8Array";
|
|
}
|
|
code += "Vector(builder:flatbuffers.Builder, data:" + type +
|
|
"):flatbuffers.Offset {\n";
|
|
} else {
|
|
code += object_name + ".create" + MakeCamel(field.name);
|
|
code += "Vector = function(builder, data) {\n";
|
|
}
|
|
|
|
code += " builder.startVector(" + NumToString(elem_size);
|
|
code += ", data.length, " + NumToString(alignment) + ");\n";
|
|
code += " for (var i = data.length - 1; i >= 0; i--) {\n";
|
|
code += " builder.add" + GenWriteMethod(vector_type) + "(";
|
|
if (vector_type.base_type == BASE_TYPE_BOOL) {
|
|
code += "+";
|
|
}
|
|
code += "data[i]);\n";
|
|
code += " }\n";
|
|
code += " return builder.endVector();\n";
|
|
code += "};\n\n";
|
|
}
|
|
|
|
// Generate a method to start a vector, data to be added manually after
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.Builder} builder\n"
|
|
"@param {number} numElems");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "static start" + MakeCamel(field.name);
|
|
code += "Vector(builder:flatbuffers.Builder, numElems:number) {\n";
|
|
} else {
|
|
code += object_name + ".start" + MakeCamel(field.name);
|
|
code += "Vector = function(builder, numElems) {\n";
|
|
}
|
|
|
|
code += " builder.startVector(" + NumToString(elem_size);
|
|
code += ", numElems, " + NumToString(alignment) + ");\n";
|
|
code += "};\n\n";
|
|
}
|
|
}
|
|
|
|
// Generate a method to stop building a new object
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.Builder} builder\n"
|
|
"@returns {flatbuffers.Offset}");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "static end" + struct_def.name;
|
|
code += "(builder:flatbuffers.Builder):flatbuffers.Offset {\n";
|
|
} else {
|
|
code += object_name + ".end" + struct_def.name;
|
|
code += " = function(builder) {\n";
|
|
}
|
|
|
|
code += " var offset = builder.endObject();\n";
|
|
for (auto it = struct_def.fields.vec.begin();
|
|
it != struct_def.fields.vec.end(); ++it) {
|
|
auto &field = **it;
|
|
if (!field.deprecated && field.required) {
|
|
code += " builder.requiredField(offset, ";
|
|
code += NumToString(field.value.offset);
|
|
code += "); // " + field.name + "\n";
|
|
}
|
|
}
|
|
code += " return offset;\n";
|
|
code += "};\n\n";
|
|
|
|
// Generate the method to complete buffer construction
|
|
if (parser_.root_struct_def_ == &struct_def) {
|
|
GenDocComment(code_ptr,
|
|
"@param {flatbuffers.Builder} builder\n"
|
|
"@param {flatbuffers.Offset} offset");
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
code += "static finish" + struct_def.name + "Buffer";
|
|
code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n";
|
|
} else {
|
|
code += object_name + ".finish" + struct_def.name + "Buffer";
|
|
code += " = function(builder, offset) {\n";
|
|
}
|
|
|
|
code += " builder.finish(offset";
|
|
if (!parser_.file_identifier_.empty()) {
|
|
code += ", '" + parser_.file_identifier_ + "'";
|
|
}
|
|
code += ");\n";
|
|
code += "};\n\n";
|
|
}
|
|
}
|
|
|
|
if (lang_.language == IDLOptions::kTs) {
|
|
if (!object_namespace.empty()) {
|
|
code += "}\n";
|
|
}
|
|
code += "}\n";
|
|
}
|
|
}
|
|
};
|
|
} // namespace js
|
|
|
|
bool GenerateJS(const Parser &parser, const std::string &path,
|
|
const std::string &file_name) {
|
|
js::JsGenerator generator(parser, path, file_name);
|
|
return generator.generate();
|
|
}
|
|
|
|
std::string JSMakeRule(const Parser &parser,
|
|
const std::string &path,
|
|
const std::string &file_name) {
|
|
assert(parser.opts.lang <= IDLOptions::kMAX);
|
|
const auto &lang = GetJsLangParams(parser.opts.lang);
|
|
|
|
std::string filebase = flatbuffers::StripPath(
|
|
flatbuffers::StripExtension(file_name));
|
|
std::string make_rule = GeneratedFileName(path, filebase, lang) + ": ";
|
|
|
|
auto included_files = parser.GetIncludedFilesRecursive(file_name);
|
|
for (auto it = included_files.begin();
|
|
it != included_files.end(); ++it) {
|
|
make_rule += " " + *it;
|
|
}
|
|
return make_rule;
|
|
}
|
|
|
|
} // namespace flatbuffers
|