forked from BigfootDev/flatbuffers
a1e125af11
* flatc builds and seems to work, some of the extra targets are having linker errors * fix build system * pipeline failures * un-rename files * refactor to use unique_ptr * typo * rm make_unique, add comments * fix cmake --------- Co-authored-by: Wouter van Oortmerssen <aardappel@gmail.com>
130 lines
4.3 KiB
C++
130 lines
4.3 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 "idl_gen_binary.h"
|
|
|
|
#include <limits>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <unordered_set>
|
|
|
|
#include "flatbuffers/base.h"
|
|
#include "flatbuffers/code_generators.h"
|
|
#include "flatbuffers/flatbuffers.h"
|
|
#include "flatbuffers/flatc.h"
|
|
#include "flatbuffers/idl.h"
|
|
#include "flatbuffers/util.h"
|
|
|
|
namespace flatbuffers {
|
|
namespace {
|
|
|
|
static std::string BinaryFileName(const Parser& parser, const std::string& path,
|
|
const std::string& file_name) {
|
|
auto ext = parser.file_extension_.length() ? parser.file_extension_ : "bin";
|
|
return path + file_name + "." + ext;
|
|
}
|
|
|
|
static bool GenerateBinary(const Parser& parser, const std::string& path,
|
|
const std::string& file_name) {
|
|
if (parser.opts.use_flexbuffers) {
|
|
auto data_vec = parser.flex_builder_.GetBuffer();
|
|
auto data_ptr = reinterpret_cast<char*>(data(data_vec));
|
|
return !parser.flex_builder_.GetSize() ||
|
|
parser.opts.file_saver->SaveFile(
|
|
BinaryFileName(parser, path, file_name).c_str(), data_ptr,
|
|
parser.flex_builder_.GetSize(), true);
|
|
}
|
|
return !parser.builder_.GetSize() ||
|
|
parser.opts.file_saver->SaveFile(
|
|
BinaryFileName(parser, path, file_name).c_str(),
|
|
reinterpret_cast<char*>(parser.builder_.GetBufferPointer()),
|
|
parser.builder_.GetSize(), true);
|
|
}
|
|
|
|
static std::string BinaryMakeRule(const Parser& parser, const std::string& path,
|
|
const std::string& file_name) {
|
|
if (!parser.builder_.GetSize()) return "";
|
|
std::string filebase =
|
|
flatbuffers::StripPath(flatbuffers::StripExtension(file_name));
|
|
std::string make_rule =
|
|
BinaryFileName(parser, path, filebase) + ": " + file_name;
|
|
auto included_files =
|
|
parser.GetIncludedFilesRecursive(parser.root_struct_def_->file);
|
|
for (auto it = included_files.begin(); it != included_files.end(); ++it) {
|
|
make_rule += " " + *it;
|
|
}
|
|
return make_rule;
|
|
}
|
|
|
|
class BinaryCodeGenerator : public CodeGenerator {
|
|
public:
|
|
Status GenerateCode(const Parser& parser, const std::string& path,
|
|
const std::string& filename) override {
|
|
if (!GenerateBinary(parser, path, filename)) {
|
|
return Status::ERROR;
|
|
}
|
|
return Status::OK;
|
|
}
|
|
|
|
// Generate code from the provided `buffer` of given `length`. The buffer is a
|
|
// serialized reflection.fbs.
|
|
Status GenerateCode(const uint8_t*, int64_t, const CodeGenOptions&) override {
|
|
return Status::NOT_IMPLEMENTED;
|
|
}
|
|
|
|
Status GenerateMakeRule(const Parser& parser, const std::string& path,
|
|
const std::string& filename,
|
|
std::string& output) override {
|
|
output = BinaryMakeRule(parser, path, filename);
|
|
return Status::OK;
|
|
}
|
|
|
|
Status GenerateGrpcCode(const Parser& parser, const std::string& path,
|
|
const std::string& filename) override {
|
|
(void)parser;
|
|
(void)path;
|
|
(void)filename;
|
|
return Status::NOT_IMPLEMENTED;
|
|
}
|
|
|
|
Status GenerateRootFile(const Parser& parser,
|
|
const std::string& path) override {
|
|
(void)parser;
|
|
(void)path;
|
|
return Status::NOT_IMPLEMENTED;
|
|
}
|
|
|
|
bool IsSchemaOnly() const override { return false; }
|
|
|
|
bool SupportsBfbsGeneration() const override { return false; }
|
|
|
|
bool SupportsRootFileGeneration() const override { return false; }
|
|
|
|
IDLOptions::Language Language() const override { return IDLOptions::kBinary; }
|
|
|
|
std::string LanguageName() const override { return "binary"; }
|
|
};
|
|
|
|
} // namespace
|
|
|
|
std::unique_ptr<CodeGenerator> NewBinaryCodeGenerator() {
|
|
return std::unique_ptr<BinaryCodeGenerator>(new BinaryCodeGenerator());
|
|
}
|
|
|
|
} // namespace flatbuffers
|