Contar linhas de arquivos de origem usando macros?

É possível, usando o pré-processador C / C ++, contar linhas dentro de um arquivo de origem, em uma macro ou em algum tipo de valor disponível no tempo de compilação? Por exemplo, eu pode substituir MAGIC1, MAGIC2e MAGIC3no seguinte, e obter o valor 4 de alguma forma quando se utiliza MAGIC3?

MAGIC1 // can be placed wherever you like before the relevant 
       // lines - either right before them, or in global scope etc.
foo(); MAGIC2
bar(); MAGIC2
baz(); MAGIC2
quux(); MAGIC2
// ... possibly a bunch of code here; not guaranteed to be in same scope ...
MAGIC3

Notas:

• Extensões específicas do compilador para os recursos do pré-processador são aceitáveis, mas indesejáveis.
• Se isso for possível apenas com a ajuda de algumas das construções em C ++, em oposição a C, isso também é aceitável, mas indesejável (ou seja, eu gostaria de algo que funcionasse para C).
• Obviamente, isso pode ser feito executando o arquivo de origem através de algum script de processador externo, mas não é isso que estou perguntando.

Existe a __LINE__macro do pré - processador que fornece um número inteiro para a linha em que é exibida. Você pode pegar seu valor em alguma linha, e depois em outra linha, e comparar.

static const int BEFORE = __LINE__;
foo();
bar();
baz();
quux();
static const int AFTER = __LINE__;
static const int COUNT = AFTER - BEFORE - 1; // 4

Se você deseja contar as ocorrências de algo em vez de linhas de origem, __COUNTER__pode ser uma opção não padrão, suportada por alguns compiladores, como GCC e MSVC.

#define MAGIC2_2(c)
#define MAGIC2(c) MAGIC2_2(c)
static const int BEFORE = __COUNTER__;
void foo(); MAGIC2(__COUNTER__);
void bar(
    int multiple,
    float lines); MAGIC2(__COUNTER__);
void baz(); MAGIC2(__COUNTER__);
void quux(); MAGIC2(__COUNTER__);
static const int AFTER = __COUNTER__;
static const int COUNT = AFTER - BEFORE - 1; // 4

Peguei o valor inicial de __COUNTER__porque ele poderia ter sido usado anteriormente no arquivo de origem ou em algum cabeçalho incluído.

Em C, e não em C ++, há limitações em variáveis ​​constantes; portanto, um enumpode ser usado.

enum MyEnum
{
    FOO = COUNT // C: error: enumerator value for ‘FOO’ is not an integer constant
};

Substituindo a const por enum:

enum {BEFORE = __LINE__};
foo();
bar();
baz();
quux();
enum { COUNT = __LINE__ - BEFORE - 1};
enum MyEnum
{
    FOO = COUNT // OK
};

Sei que a solicitação do OP é usar macros, mas gostaria de adicionar outra maneira de fazer isso que não envolve o uso de macros.

O C ++ 20 apresenta a source_locationclasse que representa certas informações sobre o código-fonte, como nomes de arquivos, números de linhas e nomes de funções. Podemos usar isso com bastante facilidade neste caso.

#include <iostream>
#include <source_location>

static constexpr auto line_number_start = std::source_location::current().line();
void foo();
void bar();
static constexpr auto line_number_end = std::source_location::current().line();

int main() {
    std::cout << line_number_end - line_number_start - 1 << std::endl; // 2

    return 0;
}

E exemplo ao vivo aqui .

Para completar: se você deseja adicionar MAGIC2depois de cada linha, pode usar __COUNTER__:

#define MAGIC2 static_assert(__COUNTER__ + 1, "");

/* some */     MAGIC2
void source(); MAGIC2
void lines();  MAGIC2

constexpr int numberOfLines = __COUNTER__;

int main()
{
    return numberOfLines;
}

https://godbolt.org/z/i8fDLx (retorna 3)

Você pode torná-lo reutilizável armazenando os valores inicial e final de __COUNTER__.

No geral, isso é realmente complicado. Você também não poderá contar linhas que contêm diretivas de pré-processador ou que terminam com //comentários. Eu usaria em __LINE__vez disso, veja a outra resposta.

Uma solução um pouco mais robusta, que permite contadores diferentes (desde que não se misturem e que não sejam utilizados __COUNTER__para outras tarefas):

#define CONCATENATE(s1, s2) s1##s2
#define EXPAND_THEN_CONCATENATE(s1, s2) CONCATENATE(s1, s2)

#define COUNT_THIS_LINE static_assert(__COUNTER__ + 1, "");
#define START_COUNTING_LINES(count_name) \
  enum { EXPAND_THEN_CONCATENATE(count_name, _start) = __COUNTER__ };
#define FINISH_COUNTING_LINES(count_name) \
  enum { count_name = __COUNTER__ - EXPAND_THEN_CONCATENATE(count_name, _start) - 1 };

Isso oculta os detalhes da implementação (embora oculte-os dentro de macros ...). É uma generalização da resposta de @ MaxLanghof. Observe que __COUNTER__pode ter um valor diferente de zero quando iniciamos uma contagem.

Veja como é usado:

START_COUNTING_LINES(ze_count)

int hello(int x) {
    x++;
    /* some */     COUNT_THIS_LINE
    void source(); COUNT_THIS_LINE
    void lines();  COUNT_THIS_LINE
    return x;
}

FINISH_COUNTING_LINES(ze_count)

int main()
{
    return ze_count;
}

Além disso, isso é C válido - se o seu pré-processador suportar __COUNTER__, é isso.

Funciona no GodBolt .

Se você estiver usando C ++, poderá modificar esta solução para não poluir o namespace global - colocando os contadores dentro namespace macro_based_line_counts { ... }ou namespace detailetc.)

Com base no seu comentário, se você quiser especificar um tamanho de matriz (em tempo de compilação) em C ou C ++, poderá fazer

int array[]; //incomplete type
enum{ LINE0 = __LINE__ }; //enum constants are integer constant expressions
/*lines to be counted; may use array (though not sizeof(array)) */
/*...*/
int array[ __LINE__ - LINE0 ]; //complete the definition of int array[]

Se você precisar sizeof(array)nas linhas intermediárias, poderá substituí-lo por uma referência de variável estática (a menos que seja absolutamente necessária uma expressão constante inteira) e um compilador de otimização deve tratá-la da mesma forma (eliminar a necessidade da variável estática ser colocada em memória)

int array[]; static int count;
enum{ LINE0 = __LINE__ }; //enum constants are integer constant expressions
//... possibly use count here
enum { LINEDIFF = __LINE__ - LINE0 }; 
int array[ LINEDIFF ]; /*complete the definition of int array[]*/ 
static int count = LINEDIFF; //fill the count in later

Uma __COUNTER__solução baseada em A (se essa extensão estiver disponível) em oposição a uma solução baseada em A __LINE__funcionará da mesma maneira.

constexprs em C ++ deve funcionar tão bem quanto enum, mas enumtambém funcionará em C simples (minha solução acima é uma solução C simples).