OBSERVAÇÃO:este site foi descontinuado. O site será desativado após 31 de janeiro de 2023, e o tráfego será redirecionado para o novo site em https://protobuf.dev. Enquanto isso, as atualizações serão feitas apenas para protobuf.dev.

comando_line_interface.h

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

#include <google/protobuf/compiler/command_line_interface.h>
namespace google::protobuf::compiler

Implementa o front-end do compilador do protocolo para que ele possa ser reutilizado por compiladores personalizados escritos para oferecer suporte a outras linguagens.

Turmas neste arquivo

Essa classe implementa a interface de linha de comando para o compilador de protocolos.

classe CommandLineInterface

#include <google/protobuf/compiler/command_line_interface.h>
namespace google::protobuf::compiler

Essa classe implementa a interface de linha de comando para o compilador de protocolos.

Ele foi criado para facilitar a criação de um compilador de protocolo personalizado com suporte às linguagens de sua escolha. Por exemplo, se você quiser criar um binário de compilador de protocolo personalizado que inclua suporte para C++ regular e suporte para sua própria saída personalizada "Foo", escreva uma classe "FooGenerator" que implemente a interface CodeGenerator e, em seguida, escreva um procedimento main() como este:

int main(int argc, char* argv[[]]) {
  google::protobuf::compiler::CommandLineInterface cli;

  // Support generation of C++ source and headers.
  google::protobuf::compiler::cpp::CppGenerator cpp_generator;
  cli.RegisterGenerator("--cpp_out", &cpp_generator,
    "Generate C++ source and header.");

  // Support generation of Foo code.
  FooGenerator foo_generator;
  cli.RegisterGenerator("--foo_out", &foo_generator,
    "Generate Foo file.");

  return cli.Run(argc, argv);
}

O compilador é invocado com sintaxe como:

protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto

O arquivo .proto a ser compilado pode ser especificado na linha de comando usando o caminho físico ou um caminho virtual relativo a um diretório especificado em –proto_path. Por exemplo, para src/foo.proto, as duas invocações protoc a seguir funcionam da mesma maneira:

1. protoc --proto_path=src src/foo.proto (physical file path)
2. protoc --proto_path=src foo.proto (virtual path relative to src)

Se um caminho de arquivo puder ser interpretado como um caminho de arquivo físico e como um caminho virtual relativo, o caminho do arquivo físico terá precedência.

Para ver uma descrição completa da sintaxe da linha de comando, invoque com "help".

Participantes

const char *const
kPathSeparator
CommandLineInterface()
~CommandLineInterface()
void
RegisterGenerator(const std::string & flag_name, CodeGenerator * generator, const std::string & help_text)
Registrar um gerador de código para uma linguagem mais…
void
RegisterGenerator(const std::string & flag_name, const std::string & option_flag_name, CodeGenerator * generator, const std::string & help_text)
Registrar um gerador de código para uma linguagem mais…
void
AllowPlugins(const std::string & exe_name_prefix)
Ativa "plug-ins". mais…
int
Run(int argc, const char *const argv)
Execute o compilador de protocolo com os parâmetros de linha de comando fornecidos. mais…
void
SetInputsAreProtoPathRelative(bool )
OBSOLETO. mais…
void
SetVersionInfo(const std::string & text)
Fornece um texto que será impresso quando a sinalização –version for usada. mais…

void CommandLineInterface::RegisterGenerator(
        const std::string & flag_name,
        CodeGenerator * generator,
        const std::string & help_text)

Registrar um gerador de código para uma linguagem

Parâmetros:

  • flag_name: a sinalização de linha de comando usada para especificar um arquivo de saída desse tipo. O nome precisa começar com "-". Se o nome tiver mais de uma letra, precisa começar com dois "-".
  • generator: o CodeGenerator que será chamado para gerar arquivos desse tipo.
  • help_text: texto que descreve esta sinalização na saída de –help.

Alguns geradores aceitam parâmetros extras. É possível especificar esse parâmetro na linha de comando colocando-o antes do diretório de saída, separado por dois pontos:

protoc --foo_out=enable_bar:outdir

O texto antes dos dois-pontos é transmitido para CodeGenerator::Generate() como o "parâmetro".


void CommandLineInterface::RegisterGenerator(
        const std::string & flag_name,
        const std::string & option_flag_name,
        CodeGenerator * generator,
        const std::string & help_text)

Registrar um gerador de código para uma linguagem

Além de flag_name, você pode especificar outro option_flag_name que pode ser usado para transmitir parâmetros extras ao gerador de código registrado. Suponha que você tenha registrado um gerador chamando:

command_line_interface.RegisterGenerator("--foo_out", "--foo_opt", ...)

Em seguida, você pode invocar o compilador com um comando como:

protoc --foo_out=enable_bar:outdir --foo_opt=enable_baz

Isso passará "enable_bar,enable_baz" como o parâmetro para o gerador.


void CommandLineInterface::AllowPlugins(
        const std::string & exe_name_prefix)

Ativa "plug-ins".

Nesse modo, se uma sinalização de linha de comando terminar com "_out", mas não corresponder a nenhum gerador registrado, o compilador vai tentar encontrar um "plug-in" para implementar o gerador. Os plug-ins são apenas executáveis. Eles devem residir em algum lugar no PATH.

O compilador determina o nome executável a ser pesquisado concatenando o exe_name_prefix com o nome da sinalização não reconhecido, removendo "_out". Por exemplo, se exe_name_prefix for "protoc-" e você transmitir o sinalizador "foo_out", o compilador tentará executar o programa "protoc-gen-foo".

O programa de plug-ins precisa implementar o seguinte uso:

plugin [[]--out=OUTDIR] [[]--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS

–out indica o diretório de saída (conforme transmitido ao parâmetro –foo_out). Se omitido, o diretório atual será usado. –parâmetro fornece o parâmetro gerador, se houver (veja abaixo). Os PROTO_FILES listam os arquivos .proto que foram fornecidos na linha de comando do compilador. Esses são os arquivos para os quais o plug-in deve gerar o código de saída. Por fim, DESCRIPTORS é um FileDescriptorSet codificado (conforme definido em Descriptor.proto). Isso é canalizado para o stdin do plug-in. O conjunto incluirá descritores para todos os arquivos listados em PROTO_FILES, bem como para todos os arquivos que importarem. O plug-in NÃO PODE ler os PROTO_FILES diretamente. É necessário usar o FileDescriptorSet.

O plug-in gera os arquivos necessários, como os geradores de código normalmente fazem. Ele precisa gravar os nomes de todos os arquivos gerados em stdout. Os nomes precisam ser relativos ao diretório de saída, NÃO a nomes absolutos ou a um diretório atual. Caso ocorram erros, as mensagens de erro devem ser gravadas em stderr. Se um erro for fatal, o plug-in será encerrado com um código de saída diferente de zero.

Os plug-ins podem ter parâmetros de geração semelhantes aos geradores integrados normais. Os parâmetros extras do gerador podem ser transmitidos por um parâmetro "_opt" correspondente. Exemplo:

protoc --plug_out=enable_bar:outdir --plug_opt=enable_baz

Isso passará "enable_bar,enable_baz" como o parâmetro para o plug-in.


int CommandLineInterface::Run(
        int argc,
        const char *const argv)

Execute o compilador de protocolo com os parâmetros de linha de comando fornecidos.

Retorna o código de erro que deve ser retornado por main().

Talvez não seja seguro chamar Run() em um ambiente com várias linhas de execução porque ele chama strerror(). Não tenho certeza por que você faria isso mesmo assim.


void CommandLineInterface::SetInputsAreProtoPathRelative(
        bool )

OBSOLETO.

Chamar esse método não tem efeito. Agora, o compilador de protocolos sempre tenta encontrar o arquivo .proto em relação ao diretório atual. Se o arquivo não for encontrado, ele tratará o caminho de entrada como um caminho virtual.


void CommandLineInterface::SetVersionInfo(
        const std::string & text)

Fornece um texto que será impresso quando a sinalização –version for usada.

A versão de libprotoc também será impressa na próxima linha após esse texto.