/*

* 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");

if (lang_.language == IDLOptions::kTs) {

code += "export namespace " + GetNameSpace(enum_def) + "{\n" +

"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) {

code += "}};\n\n";

} else {

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 "this.bb.__string" + arguments;

case BASE_TYPE_STRUCT: return "this.bb.__struct" + arguments;

case BASE_TYPE_UNION: return "this.bb.__union" + arguments;

case BASE_TYPE_VECTOR: return GenGetter(type.VectorType(), arguments);

default: {

auto getter = "this.bb.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 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;

// Emit constructor

if (lang_.language == IDLOptions::kTs) {

object_name = struct_def.name;

std::string object_namespace = GetNameSpace(struct_def);

GenDocComment(struct_def.doc_comment, code_ptr, "@constructor");

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;\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 = this.bb.__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, "this.bb");

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) + ", this.bb);\n";

} else {

code += offset_prefix + "(obj || new " + type + ").__init(";

code += field.value.type.struct_def->fixed

? "this.bb_pos + offset"

: "this.bb.__indirect(this.bb_pos + offset)";

code += ", this.bb) : 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 = "this.bb.__vector(this.bb_pos + offset) + index" +

MaybeScale(inline_size);

std::string args = "@param {number} index\n";

if (vectortype.base_type == BASE_TYPE_STRUCT) {

args += "@param {" + vectortypename + "=} obj\n";

} else if (vectortype.base_type == BASE_TYPE_STRING) {

args += "@param {flatbuffers.Encoding=} optionalEncoding\n";

}

GenDocComment(field.doc_comment, code_ptr, args +

"@returns {" + vectortypename + "}");

if (lang_.language == IDLOptions::kTs) {

std::string prefix = MakeCamel(field.name, false);

prefix += "(index: number";

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) {

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

: "this.bb.__indirect(" + index + ")";

code += ", this.bb)";

} 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 += "this.bb.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 = this.bb.__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 += " this.bb.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 += "this.bb.__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(this.bb.bytes().buffer, "

"this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), "

"this.bb.__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;