Pular para o conteúdo principal

12 — Relatório da Fase 6: portabilidade, múltiplos compiladores e endurecimento

Regra deste documento. Tudo o que está marcado como executado foi rodado na máquina descrita na §2, e o resultado é o que está escrito. O que não foi rodado está na §8, com o motivo. Nenhum número aqui é estimado.


1. Sumário​

#ComandoO que provaResultado
1make testa suíte completa passa no compilador padrão307 verificações de linguagem + 230 unitárias + 30 de integração
2make test-matriza mesma suíte passa em dois frontends independentesGCC 12.2.0 e Clang 20.1.2: 307 + 230 + 30 em cada
3make test-sanitizenão há UB nem vazamento307 + 30 sob ASan + UBSan + LSan, -fno-sanitize-recover=all
4make test-portabilidadecabeçalhos, padrões, avisos, multi-UO, C++, alvos cruzados70 aprovadas, 2 ignoradas, 0 falhas
5make fuzzo transpilador não cai com entrada malformada2000 mutações, 0 falhas
6make test-checkouta documentação funciona do zero13 comandos/verificações
7make exemplosos 24 exemplos compilam com aviso = erro24 ok
8make coberturatodo construtor documentado tem teste117 nomes, 135 casos, saída determinística

Saída literal das linhas finais:

$ make test
TUDO OK: 307 verificacoes aprovadas
biblioteca: 230 verificacoes aprovadas
TUDO OK: 30 verificacoes da biblioteca aprovadas

$ ./tests/run_checkout_limpo.sh
CHECKOUT LIMPO OK: 13 comandos/verificacoes

$ ./tests/run_portabilidade.sh
PORTABILIDADE OK: 70 verificacoes aprovadas, 2 ignoradas

$ T_CC_ALT=/tmp/bin/clang-zig ./tests/run_matriz.sh
MATRIZ OK: 2 compilador(es): cc /tmp/bin/clang-zig

$ python3 tests/fuzz_basicgolc.py --basicgolc ./basicgolc-asan --iteracoes 2000
fuzz_basicgolc: 2000 mutacoes sem crash, 0 falha(s) [seed=20261106, iteracoes=2000]

2. Ambiente exato​

ItemValor
SistemaLinux 6.1.158+ x86_64, Debian GNU/Linux 12 (bookworm)
libcglibc 2.36-9+deb12u14
Compilador padrãocc = gcc = GCC 12.2.0 (Debian 12.2.0-14+deb12u1)
C++g++ 12.2.0
Frontend ClangClang 20.1.2 (build zig-bootstrap), via zig 0.15.1 (zig cc)
BinutilsGNU ld / ar 2.40
Python (transpilador de teste, fuzz, cobertura)3.11.2
Alvos cruzados executadosx86-linux-musl (i386)
Alvos cruzados só compiladosaarch64-linux-gnu, x86_64-windows-gnu
Ausentesclang/clang++ do LLVM, cl.exe, wine, qemu-aarch64, tcc, icx, pcc, MinGW nativo

Não havia clang do LLVM na máquina e não havia como instalá-lo (o host de release do LLVM não é alcançável daqui). O frontend Clang foi exercitado pelo zig cc. Isso é registrado como frontend Clang, não como "clang testado" — ver 11 §1.

3. O que foi executado, em ordem​

3.1 Suíte da linguagem e da biblioteca (make test)​

307 verificações de linguagem, cada uma compilando o mesmo .c nos dois perfis (M0 = macros, M1 = transpilado) e conferindo a saída; 230 verificações unitárias dos módulos; 30 de integração (incluindo os casos de erro fatal que precisam rodar em processo separado). Nenhuma falha.

3.2 Sanitizers (make test-sanitize)​

build-sanitize/ com -fsanitize=address,undefined -fno-sanitize-recover=all, -O1 -g. A suíte inteira: 307 + 30, sem UB, sem vazamento (LeakSanitizer incluído). Antes das correções desta fase eram 129 falhas de vazamento no transpilador (DF-02) e uma violação de pilha no LEIA (DF-01) — as duas estão em 13.

3.3 Matriz de compiladores (make test-matriz)​

tests/run_matriz.sh roda as três suítes com cada compilador encontrado, em diretório de build próprio (build-matriz/<compilador>/), porque o Makefile não rastreia mudança de flags. Resultado: cc (GCC 12.2.0) e /tmp/bin/clang-zig (Clang 20.1.2), cada um com 307 + 230 + 30, o mesmo número nos dois.

3.4 Portabilidade (make test-portabilidade)​

O runner tem 11 seções e escreve build/relatorio/portabilidade.tsv com uma linha por verificação. Resumo por seção:

SeçãoO que verificaResultado
1cabeçalho e biblioteca em -std=c11/c17/gnu11 com -Wpedantic -Werror, por compiladorok (6 por compilador)
2recusa explícita de C89 e C99ok
3os 7 cabeçalhos são autocontidos (cada um compila sozinho)ok
4os programas de portabilidade (precedencia, controle, entrada, fronteira) compilam e passam, por compiladorok
5M0 e M1 do mesmo .c produzem a mesma saídaok
6saída dourada do entrada.c (contrato de leitura e de falha)ok
7link de 4 unidades de tradução com inclusão múltipla, BG_SEM_APELIDOS, BG_USAR_EXTENSOESok
8auditoria de símbolos globais com nm: nenhum global extra das UOs de testeok
9conjunto estrito de avisos sobre cabeçalho, biblioteca e transpiladorok (11 arquivos)
9bos 24 exemplos do repositório sob -pedantic -Werror, por compilador (M0, ou M1 quando a fonte usa açúcar)ok (GCC e Clang)
10ASan + UBSan + LSan nos programas de portabilidade e no transpiladorok
11C++ e alvos cruzadosok + 2 ignoradas

As duas ignoradas (não "aprovadas", não "falhas"):

  • -std=c23 no frontend Clang via zig — o driver recusa o padrão;
  • execução de binários Windows — não há wine. A compilação e a ligação foram verificadas.

Detalhes de valor que a matriz produziu:

  • nm limpo: as quatro UOs do teste multi-arquivo definem só bg_tu1_resultado, bg_tu2_resultado, bg_tu3_resultado. Nenhum símbolo auxiliar escapa do cabeçalho, o que sustenta a promessa de que incluir basicgol.h em vários .c não gera colisão no linker.
  • C++: g++ -std=c++17 compila os cabeçalhos de módulo, liga e roda (cpp: ok); <basicgol.h> em C++ falha com o #error previsto por D-15.
  • i386: fronteira.c passa com as mesmas 176 verificações no alvo de 32 bits, e precedencia passa. É a evidência de que o mapeamento de tipos não depende de 64 bits.
  • AArch64: biblioteca e fronteira.c compilam limpos (sem execução).
  • Windows (MinGW-w64): ola_mundo.exe e fronteira.exe compilam e ligam (sem execução).

3.5 Fuzz (make fuzz)​

tests/fuzz_basicgolc.py com seed fixa (20261106): 10 estratégias de mutação (truncar, duplicar, apagar, inserir, trocar, CRLF, BOM+CRLF, aninhamento de 300 níveis, remover fechamento, no-op), contrato explícito — não derrubar, não travar, não vazar. Rodado contra o build com ASan+UBSan: 2000 iterações, 0 falhas, 8,9 s. O contrato do transpilador com entrada inválida é: emitir diagnóstico e sair com código ≠ 0, nunca SIGSEGV.

3.6 Checkout limpo (make test-checkout)​

Copia só o que o Git versionaria (git ls-files + não ignorados), roda make, make biblioteca, make test, make test-biblioteca, make exemplos, make cobertura, o comando M0 de uma linha do README, o fluxo M1 de duas etapas, make test-portabilidade e make fuzz. 13 verificações, todas ok — incluindo a de que make cobertura não altera tests/COBERTURA.md.

4. Critérios da fase​

Ver 05 §10. AC-52 a AC-60, todos atendidos, cada um com o comando que o verifica.

5. Defeitos encontrados​

Oito, detalhados em 13-defeitos-e-correcoes.md:

IDResumoGravidade
DF-01LEIA(LOGICO)/LEIA(TEXTO_FIXO) gravava ponteiro no destino (stack-buffer-overflow)alta
DF-02transpilador vazava toda alocação (129 falhas sob LSan)média
DF-03cabeçalhos de módulo não compilavam em C++ (_Noreturn)média
DF-04três conversões descartavam const (-Wcast-qual)baixa
DF-05supressão de -Wimplicit-fallthrough escondia quedas acidentaisbaixa
DF-06make cobertura com data: a checagem de CI falharia todo diamédia
DF-07diretórios de build fora do .gitignorebaixa
DF-08exemplo com protótipo antigo () — o Clang recusa com -Wstrict-prototypesbaixa

O DF-01 é o que justifica a fase: um programa que seguia a documentação compilava, e o binário corrompia a pilha. Não era visível em make test porque o teste de LEIA era feito com -Werror, e o -Wformat transformava o que "deveria" ser erro de compilação em aviso — que a linha de compilação publicada não transforma em erro.

6. Cobertura​

tests/COBERTURA.md (regenerado, determinístico): 117 nomes do cabeçalho, 135 casos de teste. Os casos novos da Fase 6:

  • 06_negativos/n21_leia_texto — LEIA(TEXTO) é erro de compilação (DF-01).
  • 06_negativos/n22_leia_texto_fixo — LEIA(TEXTO_FIXO(...)) idem (DF-01).
  • 06_negativos/n23_tamanho_de_ponteiro — TAMANHO_VETOR(ponteiro) é detectado por -Wsizeof-pointer-div nos dois compiladores (limite C-18 com rede de proteção).
  • 03_controle/c19_escolha_fallthrough — reescrito para provar a queda intencional com o aviso ligado (DF-05).

7. O que mudou no repositório​

ArquivoMudança
include/basicgol.hBG_SFMT sem default (DF-01), com o comentário explicando a assimetria em relação a BG_FMT
include/basicgol/consola.hBG_NORETURN (DF-03)
src/biblioteca/texto.cconversores sem descarte de const (DF-04)
tools/basicgolc.cliberação de buffer, tokens e estado (DF-02)
tools/cobertura.pysaída determinística + --data (DF-06)
Makefiletest-portabilidade[-v], test-sanitize, test-matriz, fuzz, test-checkout, limpar ampliado, COBERTURA_ARGS
tests/portabilidade/8 programas novos (precedência, controle, entrada, fronteira, multi-UO ×4, C++)
tests/run_portabilidade.sh, tests/run_matriz.sh, tests/run_checkout_limpo.sh, tests/fuzz_basicgolc.pyferramentas novas
.github/workflows/testes.ymlCI com matriz de compiladores/standards, sanitizers, portabilidade, cobertura e um job MSVC de avaliação
.gitignorebuild*/, *.o, *.gerado.c, __pycache__/ (DF-07)
docs/exemplos/controle_entrada.cPROCEDIMENTO mostra_media(VAZIO) em vez de () (DF-08)
docs/01, 02, 03, 06LEIA de texto/lógico documentado como erro de compilação; BG_SFMT sem default; PT-H (-pedantic) corrigido com medição

Nada disso muda a gramática nem o comportamento pretendido da linguagem: a Fase 6 não acrescenta construtor. As duas únicas mudanças com efeito para quem escreve BASICGOL são DF-01 (erro onde antes era aviso + corrupção de memória) e DF-03 (cabeçalhos de módulo utilizáveis de C++).

8. O que não foi testado (lacunas declaradas)​

LacunaPor quêOnde está registrado
MSVC (cl.exe)não há Windows nem MSVC; job de CI existe, mas nunca rodou11 §4 — estado "avaliado"
Driver clang/clang-cl do LLVMbinário ausente e inalcançável; o frontend foi testado via zig11 §1, item 9
Execução em AArch64sem qemu-aarch6411 §1, item 4 — "compilado"
Execução em Windowssem wine11 §1, item 5 — "compilado"
-std=c23 no frontend Clango driver do zig recusa o padrãoignorada registrada no .tsv
TCC, icx, PCC, Digital Marsindisponíveis11 §1, item 10
char sem sinal (AArch64) em execuçãodepende de execução em AArch6411 §5
Locale com vírgula decimala suíte roda em C/POSIXD-17 e A-5, 11 §6
CHAR_BIT != 8não há plataforma assim disponível11 §5
Sanitizers no MSVCcl não roda aqui11 §4

Nenhuma dessas lacunas foi preenchida por inferência: as células correspondentes dizem "avaliado", "compilado" ou "não testado", nunca "ok".

9. Como reproduzir​

make limpar
make # transpilador + biblioteca
make test # 307 + 230 + 30
make test-sanitize # idem sob ASan+UBSan+LSan
make test-portabilidade # 70 aprovadas, 2 ignoradas
make test-checkout # 13 verificações, do zero
make fuzz # 300 mutações (2000 com --iteracoes 2000)
make cobertura # deve sair sem diff em tests/COBERTURA.md

Para repetir a matriz em dois compiladores, é preciso ter um segundo compilador visível como clang ou T_CC_ALT:

T_CC_ALT=$(command -v clang || echo /caminho/para/clang) make test-matriz

O zig, quando presente no PATH, habilita as verificações de alvo cruzado; sem ele, elas aparecem como ignoradas.

10. Conclusão​

A Fase 6 fecha com a suíte verde em dois frontends independentes, sem aviso no conjunto adotado, sem UB e sem vazamento sob sanitizers, com 70 verificações de portabilidade aprovadas e os comandos da documentação exercitados a partir de um checkout limpo. Encontrou e corrigiu oito defeitos, um deles de gravidade alta (corrupção de pilha em LEIA).

O que ela não faz é transformar avaliação em fato: MSVC continua "avaliado", Windows e AArch64 continuam "compilado, não executado", e o driver clang do LLVM continua "não testado". Essa é a diferença entre um relatório e um folheto de marketing — e é o critério que o projeto adota desde a Fase 1.

Símbolos citados neste documento​

Nomes que aparecem literalmente no texto acima e que possuem página de referência gerada do fonte:

BG_SFMT, BG_FMT, BG_NORETURN, BG_SEM_APELIDOS, BG_USAR_EXTENSOES.

Perguntas frequentes​

Perguntas frequentes sobre este documento, respondidas a partir do conteúdo versionado e da referência gerada.

Quais números a fase 6 registrou?​

307 verificações de linguagem, 230 unitárias da biblioteca, 30 de integração/falhas fatais, 70 de portabilidade aprovadas (2 ignoradas), 2000 mutações de fuzz sem crash e 24 exemplos compilando com aviso = erro.

O que foi realmente executado?​

GCC 12.2.0 (suíte inteira), frontend Clang via zig cc, sanitizers, matriz de portabilidade e fuzz. MSVC, MinGW nativo e clang do LLVM estavam ausentes do ambiente e aparecem como avaliados/não executados.

Como reproduzir os resultados?​

Os comandos e a saída literal estão no §1 e no §3; o ambiente exato (versões, libc, binutils) está no §2. Números de log não devem ser comparados com contagens estáticas do site.

make test
make test-matriz
make test-portabilidade
make test-sanitize
make fuzz

Quais defeitos a fase encontrou?​

Oito defeitos de produto e de ferramentas, detalhados em 13. O mais grave foi DF-01: LEIA com tipo sem formato escrevia um ponteiro no destino; a correção passou a recusar esses tipos em tempo de compilação.