blob: 7c498e2f1e49634e59a76937bb7e1aa9597ae07b [file] [log] [blame]
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
// Author: kenton@google.com (Kenton Varda)
#include "google/protobuf/compiler/plugin.h"
#include <iostream>
#include <utility>
#include <vector>
#ifdef _WIN32
#include <fcntl.h>
#else
#include <unistd.h>
#endif
#include "absl/log/absl_check.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "google/protobuf/compiler/code_generator.h"
#include "google/protobuf/compiler/plugin.pb.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/descriptor.pb.h"
#include "google/protobuf/io/io_win32.h"
#include "google/protobuf/io/zero_copy_stream_impl.h"
namespace google {
namespace protobuf {
namespace compiler {
#if defined(_WIN32)
// DO NOT include <io.h>, instead create functions in io_win32.{h,cc} and import
// them like we do below.
using google::protobuf::io::win32::setmode;
#endif
class GeneratorResponseContext : public GeneratorContext {
public:
GeneratorResponseContext(
const Version& compiler_version, CodeGeneratorResponse* response,
const std::vector<const FileDescriptor*>& parsed_files)
: compiler_version_(compiler_version),
response_(response),
parsed_files_(parsed_files) {}
~GeneratorResponseContext() override {}
// implements GeneratorContext --------------------------------------
io::ZeroCopyOutputStream* Open(const std::string& filename) override {
CodeGeneratorResponse::File* file = response_->add_file();
file->set_name(filename);
return new io::StringOutputStream(file->mutable_content());
}
io::ZeroCopyOutputStream* OpenForInsert(
const std::string& filename,
const std::string& insertion_point) override {
CodeGeneratorResponse::File* file = response_->add_file();
file->set_name(filename);
file->set_insertion_point(insertion_point);
return new io::StringOutputStream(file->mutable_content());
}
io::ZeroCopyOutputStream* OpenForInsertWithGeneratedCodeInfo(
const std::string& filename, const std::string& insertion_point,
const google::protobuf::GeneratedCodeInfo& info) override {
CodeGeneratorResponse::File* file = response_->add_file();
file->set_name(filename);
file->set_insertion_point(insertion_point);
*file->mutable_generated_code_info() = info;
return new io::StringOutputStream(file->mutable_content());
}
void ListParsedFiles(std::vector<const FileDescriptor*>* output) override {
*output = parsed_files_;
}
void GetCompilerVersion(Version* version) const override {
*version = compiler_version_;
}
private:
Version compiler_version_;
CodeGeneratorResponse* response_;
const std::vector<const FileDescriptor*>& parsed_files_;
};
bool GenerateCode(const CodeGeneratorRequest& request,
const CodeGenerator& generator,
CodeGeneratorResponse* response, std::string* error_msg) {
DescriptorPool pool;
// Initialize feature set default mapping.
absl::StatusOr<FeatureSetDefaults> defaults =
generator.BuildFeatureSetDefaults();
if (!defaults.ok()) {
*error_msg = absl::StrCat("error generating feature defaults: ",
defaults.status().message());
return false;
}
absl::Status status = pool.SetFeatureSetDefaults(std::move(defaults).value());
ABSL_CHECK(status.ok()) << status.message();
for (int i = 0; i < request.proto_file_size(); i++) {
const FileDescriptor* file = pool.BuildFile(request.proto_file(i));
if (file == nullptr) {
// BuildFile() already wrote an error message.
return false;
}
}
std::vector<const FileDescriptor*> parsed_files;
for (int i = 0; i < request.file_to_generate_size(); i++) {
parsed_files.push_back(pool.FindFileByName(request.file_to_generate(i)));
if (parsed_files.back() == nullptr) {
*error_msg = absl::StrCat(
"protoc asked plugin to generate a file but "
"did not provide a descriptor for the file: ",
request.file_to_generate(i));
return false;
}
}
GeneratorResponseContext context(request.compiler_version(), response,
parsed_files);
std::string error;
bool succeeded = generator.GenerateAll(parsed_files, request.parameter(),
&context, &error);
response->set_supported_features(generator.GetSupportedFeatures());
response->set_minimum_edition(
static_cast<int>(generator.GetMinimumEdition()));
response->set_maximum_edition(
static_cast<int>(generator.GetMaximumEdition()));
if (!succeeded && error.empty()) {
error =
"Code generator returned false but provided no error "
"description.";
}
if (!error.empty()) {
response->set_error(error);
}
return true;
}
int PluginMain(int argc, char* argv[], const CodeGenerator* generator) {
if (argc > 1) {
std::cerr << argv[0] << ": Unknown option: " << argv[1] << std::endl;
return 1;
}
#ifdef _WIN32
setmode(STDIN_FILENO, _O_BINARY);
setmode(STDOUT_FILENO, _O_BINARY);
#endif
CodeGeneratorRequest request;
if (!request.ParseFromFileDescriptor(STDIN_FILENO)) {
std::cerr << argv[0] << ": protoc sent unparseable request to plugin."
<< std::endl;
return 1;
}
std::string error_msg;
CodeGeneratorResponse response;
if (GenerateCode(request, *generator, &response, &error_msg)) {
if (!response.SerializeToFileDescriptor(STDOUT_FILENO)) {
std::cerr << argv[0] << ": Error writing to stdout." << std::endl;
return 1;
}
} else {
if (!error_msg.empty()) {
std::cerr << argv[0] << ": " << error_msg << std::endl;
}
return 1;
}
return 0;
}
} // namespace compiler
} // namespace protobuf
} // namespace google