Compreendendo o formato de arquivo `CTAGS -E` (CTAGs para EMACS)

Question

Estou usando "exuberantctags" também conhecido como "ctags -e", também conhecido como apenas "etags"

E estou tentando entender o formato de arquivo de tags que é gerado pelo comando ETAGS, em particular eu quero entender a linha nº 2 do arquivo de tags.

Wikipedia diz Essa linha nº 2 é descrita assim:

{src_file},{size_of_tag_definition_data_in_bytes}

Em termos práticos, embora tags linha de arquivo: 2 para "foo.c" se parece com isso

foo.c,1683

Meu dilema é como exatamente ele encontra este número: 1683

Eu sei que é o tamanho da "tag_definition", então o que eu quero saber é o que é a "tag_definition"?

Eu tentei olhar através do Código -fonte CTAGS, mas talvez alguém melhor em C do que eu tenha mais sucesso para descobrir isso.

Obrigado!

Editar #2:

^L^J
hello.c,79^J
float foo (float x) {^?foo^A3,20^J
float bar () {^?bar^A7,59^J
int main() {^?main^A11,91^J

Tudo bem, então, se eu entendi corretamente, "79" refere -se ao número de bytes no arquivo de tags de após 79 até e incluindo "91^j".

Faz todo o sentido.

Agora, os números 20, 59, 91 neste exemplo da Wikipedia diz que consulte o {byte_offset}

De que é o deslocamento {byte_offset}?

Obrigado por toda a ajuda Ken!

Answer 1

É o número de bytes de dados de tags seguindo a nova linha após o número.

EDIT: Ele também não inclui o caractere ^l entre os dados da tag de arquivo. Lembre -se de que o ETAGS vem de um tempo atrás, onde ler um arquivo de 500kb era uma operação cara. ;)

Aqui está um arquivo de tags completo. Estou mostrando duas maneiras, o primeiro com caracteres de controle como ^x e sem caracteres invisíveis. Os personagens de final de linha implícitos em seu exemplo estão ^J aqui:

^L^J
hello.cc,45^J
int main(^?5,41^J
int foo(^?9,92^J
int bar(^?13,121^J
^L^J
hello.h,15^J
#define X ^?2,1^J

Aqui está o mesmo arquivo exibido em hexadecimal:

0000000    0c  0a  68  65  6c  6c  6f  2e  63  63  2c  34  35  0a  69  6e
          ff  nl   h   e   l   l   o   .   c   c   ,   4   5  nl   i   n
0000020    74  20  6d  61  69  6e  28  7f  35  2c  34  31  0a  69  6e  74
           t  sp   m   a   i   n   ( del   5   ,   4   1  nl   i   n   t
0000040    20  66  6f  6f  28  7f  39  2c  39  32  0a  69  6e  74  20  62
          sp   f   o   o   ( del   9   ,   9   2  nl   i   n   t  sp   b
0000060    61  72  28  7f  31  33  2c  31  32  31  0a  0c  0a  68  65  6c
           a   r   ( del   1   3   ,   1   2   1  nl  ff  nl   h   e   l
0000100    6c  6f  2e  68  2c  31  35  0a  23  64  65  66  69  6e  65  20
           l   o   .   h   ,   1   5  nl   #   d   e   f   i   n   e  sp
0000120    58  20  7f  32  2c  31  0a                                    
           X  sp del   2   ,   1  nl

Existem dois conjuntos de dados de tag neste exemplo: 45 bytes de dados para hello.cc e 15 bytes para hello.h.

Os dados do hello.cc iniciam na linha após "hello.cc, 45^j" e é executado para 45 bytes-eles também são linhas completas. O motivo pelo qual os bytes são dados são, portanto, a leitura de código do arquivo pode apenas alocar sala para uma string de 45 bytes e ler 45 bytes. A linha "^l^j" é após os 45 bytes de dados de tags. Você usa isso como um marcador de que há mais arquivos restantes e também para verificar se o arquivo é formatado corretamente.

Os dados hello.h iniciam na linha após "Hello.h, 15^j" e executa para 15 bytes.

Answer 2

O {byte_offset} para uma entrada de tag é o número de bytes desde o início do arquivo em que a função é definida. O número antes do deslocamento do byte é o número da linha. No seu exemplo:

hello.c,79^J
float foo (float x) {^?foo^A3,20^J

A função Foo começa 20 bytes desde o início do hello.c. Você pode verificar isso com um editor de texto que mostra sua posição de cursor no arquivo. Você também pode usar o comando Unix Tail para exibir um arquivo vários bytes em:

tail -c +20 hello.c