Ninja é um sistema de compilação pequeno , com foco na velocidade. Em essência, o Ninja é uma alternativa ao Make . O Ninja é utilizado por diversos projetos, tendo como seu principal cliente o Google Chrome e o Android, e é usado pela maioria dos desenvolvedores que trabalham no LLVM.

Ao contrário do Make , um “gerador de compilação” deve ser usado para gerar arquivos de compilação Ninja. Gyp , CMake , Meson e gn são ferramentas populares de software de gerenciamento de compilação que suportam a criação de arquivos de compilação para o Ninja.

Como compilar com o Ninja?

O processo é bem parecido com o do Make.

Compilando em C, único arquivo:

Supondo que você tenha esse código(Olá, Mundo!) em C: vim main.c . Nesse exemplo utilizamos o comando gcc para compilar um único arquivo, mas logo abaixo veja com múltiplos arquivos em C++, que só muda o comando e a quantidade de arquivos.

#include<stdio.h>

int main(int argc, char **argv) {
  printf("Olá, Mundo!\n");
  return 0;
}

Para compilar com o Ninja, você precisará criar um arquivo build.ninja com o seguinte conteúdo: vim build.ninja

rule cc
  command = gcc -c -o $out $in
  description = CC $out
 
rule link
  command = gcc -o $out $in
  description = LINK $out
 
build src.o: cc main.c
build demo-c: link src.o

Analisando o arquivo acima, de acordo com conhecimentos prévios sobre o Make, por exemplo, conseguimos notar que o arquivo que será compilado definimos como: main.c , o arquivo temporário chamamos de src.o e o arquivo binário final nomeamos como demo-c.

Agora, basta estar no diretório que você salvou e via linha de comando rodar:

ninja

E depois é só rodar o programa:

./demo-c

Existem diversas opções como limpar o(s) arquivo(s) temporários e entre outras opções, para mais detalhes acesse o manual.

Compilando em C++, múltiplos arquivos:

Para esse exemplo vamos utilizar o Dec2Bin , um mini programa que converte decimal para binário em C++ . Nesse exemplo utilizamos o comando g++ para compilar múltiplos arquivos. São 3 arquivos , sendo que 1 é somente uma biblioteca .hpp:

vim main.cpp

#include <iostream>
#include <string>
#include "dectobin.hpp"

int main( int argc , char** argv ) {
  Dectobin db;
  std::cout << ( argc > 1 ? db.dtob( argv[1] ) : db.get_m_help() ) << "\n";
  return 0;
}

vim dectobin.hpp

#ifndef DEC_TO_BIN_H
#define DEC_TO_BIN_H
class Dectobin{
    public:
        std::string dtob( char * num );
        void set_m_help();
        std::string get_m_help();

    private:
        const static int m_max{20};
        int m_number;
        int m_modules[ m_max ];
        int m_i;
        std::string m_output;
        std::string m_help;
};
#endif

vim dectobin.cpp

#include <iostream>
#include <string>
#include "dectobin.hpp"

std::string Dectobin::dtob( char * num ){
      m_number = std::stoi( num );
      if ( m_number == 0 ) {
        m_output = "0";
      }else{
        for (m_i = 0; m_number > 0; m_i++) {
          m_modules[m_i] = m_number % 2;
          m_number = m_number / 2;
        }
        for (m_i = m_i - 1; m_i >= 0; m_i--) {
          m_output += std::to_string( m_modules[m_i] );
        }
      }
    return m_output;
}

void Dectobin::set_m_help(){
    m_help = "Enter a number.";
}

std::string Dectobin::get_m_help(){
    set_m_help();
    return m_help;
}

Salvamos os arquivos dentro do diretório dec2bin:

cd dec2bin/
ls
dectobin.cpp  dectobin.hpp  main.cpp

Da mesma forma que a anterior, vamos criar um arquivo build.ninja, só com as seguintes configurações:

rule cc
  command = g++ -c -o $out $in
  description = CC $out
 
rule link
  command = g++ -o $out $in
  description = LINK $out
 
build source1.o: cc main.cpp
build source2.o: cc dectobin.cpp
build program-cpp: link source1.o source2.o

Depois é só rodar o comando ninja e o arquivo program-cpp ficará pronto no mesmo diretório. Veja a saída na imagem abaixo onde aproveitamos o programinha para converter o número decimal: 9 em binário: 1001:

Simples, né? Abraços!

ninja meson cpp linguagemc compiladores

Marcos Oliveira

Desenvolvedor de software

https://github.com/terroo