InglêsFrancêsEspanhol

Executar servidores | Ubuntu > | Fedora > |


favicon do OnWorks

icheck - Online na nuvem

Execute o icheck no provedor de hospedagem gratuita OnWorks no Ubuntu Online, Fedora Online, emulador online do Windows ou emulador online do MAC OS

Este é o comando icheck que pode ser executado no provedor de hospedagem gratuita OnWorks usando uma de nossas várias estações de trabalho online gratuitas, como Ubuntu Online, Fedora Online, emulador online do Windows ou emulador online do MAC OS

PROGRAMA:

NOME


icheck - verificador de interface C ABI / API

SINOPSE


eu verifico --canonificar [[--linha de base ARQUIVO] ...] [OPÇÕES] [GCC_OPTIONS] [-] arquivos

eu verifico --comparar [OPÇÕES] arquivo_antigo novo arquivo

DESCRIÇÃO


Uma ferramenta para verificar estaticamente as interfaces C para alterações de API e ABI. Todas as mudanças de tipo
declarações que podem causar alterações de ABI devem ser detectadas, junto com a maioria das alterações de API.

O icheck deve ser usado com bibliotecas, como um método de prevenção de desvios de ABI.

COMANDOS


Reduza um conjunto de arquivos de origem para um arquivo de interface canônico com --canonify, em seguida, compare
dois desses arquivos de interface com --compare. Se houver mudanças de interface entre eles,
Icheck irá descrever as mudanças e falhar.

--canonificar [[--linha de base ARQUIVO] ...] [OPÇÕES] [GCC_OPTIONS] [-] arquivos

Canonifique os arquivos de código-fonte (normalmente cabeçalhos .h) para serem comparados posteriormente com
--comparar. Normalmente usado com o -o opção para salvar o resumo em um arquivo.

--comparar [OPÇÕES] arquivo_antigo novo arquivo

Lê dois arquivos de interface canônica gerados com --canonificar e compara o
estrutura do código-fonte para as mudanças na interface pública do aplicativo
(a interface do desenvolvedor ou API) e a Interface Binária do Aplicativo (ABI) usada para
vincular a outros programas ou bibliotecas.

OPÇÕES


EU VERIFICO OPÇÕES
-o, --resultado ARQUIVO

Emita a saída para FILE, em vez de stdout.

--depurar N

Despeje as informações de depuração.

--só COISA

Processe apenas a COISA fornecida.

--skip-from ARQUIVO

Pule coisas desnecessárias de ARQUIVO.

--skip-from-re regexp

Pule coisas desnecessárias dos arquivos que correspondem à expressão regular.

--Apenas de ARQUIVO

Só pegue coisas de ARQUIVO.

--só-de-re regexp

Apenas pegue coisas de arquivos que correspondam à expressão regular.

GCC_OPTIONS

GCC_OPTIONS são passados ​​para gcc -E

AJUDA OPÇÕES
--Socorro
Exibir a sinopse de ajuda para eu verifico.

EXEMPLOS


Todos os arquivos de origem são pré-processados ​​com gcc, então canonify precisa das mesmas informações de inclusão
como o código-fonte - siga a sintaxe do Makefile para incluir opções -I para cpp ou
gcc) para que todos os cabeçalhos necessários possam ser localizados. eu verifico abortará se for necessário
cabeçalhos não podem ser encontrados. A fonte deve ser compilável; Icheck não pode processar arquivos que
não pode ser compilado diretamente. Se um cabeçalho estiver faltando #include instruções ou de outra forma
requer ser usado de uma maneira especial, então não pode ser processado diretamente com o icheck.
Em vez disso, escreva um arquivo stub C que configure as coisas apropriadamente e, em seguida, #inclui o
cabeçalho.

eu verifico --canonificar -o ~ / icheck / versão antiga -I / usr / include / foo-2.0 /usr/src/bar/src/foobar.h

Prepare um resumo de texto do arquivo foobar.h e de todos os arquivos que ele inclui. O resumo é
escrito para ~ / icheck / versão antiga. Repita para /usr/src/bar1/src/foobar.h - o mesmo arquivo
no diretório de origem mais recente, gerando um novo arquivo, por exemplo ~ / icheck / newversion.

eu verifico --comparar -o ~ / icheck / results.txt ~ / icheck / versão antiga ~ / icheck / newversion

Grava o relatório da comparação dos dois arquivos de resumo. O relatório indica todos os
mudanças na ABI e / ou API encontradas durante a comparação.

eu verifico --canonificar -o debian / icheck.canonical -Idebian / foo-dev / usr / include debian / foo-
dev / usr / include / foobar.h

eu verifico --comparar debian / icheck.manifest debian / icheck.canonical

Essas duas declarações, incluídas em um debian / rules arquivo, fará com que o pacote seja construído
falhará se a API ou ABI mudou de maneiras inesperadas, em que icheck.manifest é uma cópia de
a interface esperada, incluída no pacote.

Observe que os argumentos para --compare são eles próprios arquivos C válidos que são pré-processados,
portanto, icheck.manifest pode conter a lógica do pré-processador C. Isso pode ser útil quando um pacote
exporta interfaces diferentes dependendo da arquitetura do host. Neste caso, você não pode
substitua-o por uma nova cópia de icheck.canonical quando a interface mudar e você precisar
atualize o manifesto. Em vez de atualizar todo o manifesto manualmente, coloque a mão
descrições de interface escritas em um arquivo (icheck.static-manifest) e, em seguida, use:

eu verifico --canonificar --linha de base debian / icheck.static-manifest -o debian / icheck.dynamic-
manifestar

Por último, crie icheck.manifest contendo:
#include "icheck.static-manifest"
#include "icheck.dynamic-manifest"
Isso permite que você atualize algumas partes do manifesto manualmente, enquanto ainda automaticamente
gerando o resto.

SAÍDA


Icheck gera uma descrição extensa de cada alteração possível de API ou ABI, com base no tipo
em formação. Ele não investiga o código do programa real e, portanto, é possível que
algumas alterações de tipo detectadas não são alterações reais de ABI ou API. No entanto, isso normalmente
só acontece quando o código do programa foi explicitamente escrito para ele. Em caso de dúvida, assuma que é
alterado.

No final, o icheck fornece um resumo das mudanças. Observe que as instruções aqui são
dependente da ordem dos argumentos para --compare: a interface mais antiga deve vir primeiro,
ou as instruções serão ao contrário. Os significados dos vários termos são como
segue:

ABI A ABI é compatível se as coisas compiladas contra uma versão do
interface funcionará quando executado usando a outra versão.

API A API é compatível se coisas compiladas em uma versão do
interface pode ser compilada em relação à outra.

compatível com versões futuras
Uma interface é compatível com versões futuras se as coisas compiladas com o antigo
versão funcionará com o novo. Este é o recurso importante para soname
alterações.

compatível com versões anteriores
Uma interface é compatível com versões anteriores se as coisas compiladas com o novo
versão funcionará com o antigo. Este é o recurso importante para shlibs
versão alterar. Se você não está construindo pacotes Debian, provavelmente não
preocupam-se com as mudanças que não são compatíveis com versões anteriores.

Use icheck online usando serviços onworks.net


Ad


Ad