BG_ESCREVAL · ESCREVAL
Gerada por tools/gerar_documentacao.py. Definição: include/basicgol.h:282.
Imprime um valor e acrescenta newline.
Tipo: macro com argumentos · Módulo/categoria: Entrada e saída.
Nomes equivalentes: ESCREVAL. Os testes de qualquer um desses nomes são reunidos nesta página.
Assinatura e expansão
#define BG_ESCREVAL(x) (printf(BG_FMT(x), (x)), fputc('\n', stdout))
Parâmetros formais: x.
Corpo da macro:
(printf(BG_FMT(x), (x)), fputc('\n', stdout))
Como funciona
Usa o operador vírgula para executar printf formatado e fputc de LF. O resultado da expressão é o de fputc, não uma contagem de caracteres.
- Windows pode representar LF como CRLF no stdout em modo texto.
Nomes internos referenciados: BG_FMT.
Como este símbolo aparece nos testes
502 ocorrência(s) em 137 arquivo(s) de teste. Os links apontam para linhas exatas; os trechos mostram o contexto local. Uma menção não prova que todos os ramos foi executado.
tests/casos/02_basico/b01_ola/programa.c
Contexto: b01_ola. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–6 · abrir contexto
INICIO
ESCREVAL("Ola, mundo!");
FIM
tests/casos/02_basico/b02_aritmetica/programa.c
Contexto: b02_aritmetica. Linhas: 6, 7, 8, 9, 10, 11, 12, 13. Tipo de evidência: código; via ESCREVAL.
Linhas 4–14 · abrir contexto
INICIO
ESCREVAL(7 / 2);
ESCREVAL(-7 / 2);
ESCREVAL(7 MOD 2);
ESCREVAL(-7 MOD 2);
ESCREVAL(2 + 3 * 4);
ESCREVAL((2 + 3) * 4);
ESCREVAL(10 MOD 10);
ESCREVAL(1 + 2 + 3 + 4 + 5);
FIM
tests/casos/02_basico/b03_real/programa.c
Contexto: b03_real. Linhas: 20, 22, 28, 30. Tipo de evidência: código; via ESCREVAL.
Linhas 18–24 · abrir contexto
// 0.1 + 0.2 != 0.3 em binario: a comparacao correta usa tolerancia
SE perto(0.1 + 0.2, 0.3, 1e-9) ENTAO
ESCREVAL("soma ok");
SENAO
ESCREVAL("soma estranha");
FIM_SE
Linhas 26–32 · abrir contexto
* that implementation-defined evaluation, so record both outcomes. */
SE 0.1 + 0.2 == 0.3 ENTAO
ESCREVAL("igualdade exata (precisao excedente)");
SENAO
ESCREVAL("igualdade exata falha (esperado)");
FIM_SE
FIM
tests/casos/02_basico/b04_tipos/programa.c
Contexto: b04_tipos. Linhas: 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25. Tipo de evidência: código; via ESCREVAL.
Linhas 11–26 · abrir contexto
// verificacoes portaveis (imprimem 1 quando verdadeiras)
ESCREVAL(sizeof(INTEIRO8) == 1);
ESCREVAL(sizeof(INTEIRO16) == 2);
ESCREVAL(sizeof(INTEIRO32) == 4);
ESCREVAL(sizeof(INTEIRO64) == 8);
ESCREVAL(sizeof(CARACTERE) == 1);
ESCREVAL(sizeof(INTEIRO) >= 2);
ESCREVAL(sizeof(REAL) >= sizeof(REAL_CURTO));
ESCREVAL(pequeno);
ESCREVAL(medio);
ESCREVAL(exato);
ESCREVAL(grande);
ESCREVAL(byte);
FIM
tests/casos/02_basico/b05_caractere/programa.c
Contexto: b05_caractere. Linhas: 10, 11, 12, 13, 14, 15, 16, 18. Tipo de evidência: código; via ESCREVAL.
Linhas 8–20 · abrir contexto
TEXTO nome = "BASICGOL";
ESCREVAL(letra);
ESCREVAL((INTEIRO) letra);
ESCREVAL((INTEIRO) 'A');
ESCREVAL((INTEIRO) quebra);
ESCREVAL(TAMANHO_TEXTO(nome));
ESCREVAL(nome[0]);
ESCREVAL(nome[7]);
SE letra == 'B' ENTAO
ESCREVAL("letra ok");
FIM_SE
FIM
tests/casos/02_basico/b06_variavel_antes_do_se/programa.c
Contexto: b06_variavel_antes_do_se. Linhas: 15. Tipo de evidência: código; via ESCREVAL.
Linhas 13–16 · abrir contexto
FIM_SE
ESCREVAL(resultado);
FIM
tests/casos/02_basico/b07_tipos_e_utilitarios/programa.c
Contexto: b07_tipos_e_utilitarios. Linhas: 10, 11, 12, 13, 16, 17, 18, 19, 22, 23, 24, 25, 31, 33. Tipo de evidência: código; via ESCREVAL.
Linhas 8–27 · abrir contexto
NATURAL64 a64 = 1234567890123;
ESCREVAL(curto);
ESCREVAL(a16);
ESCREVAL(a32);
ESCREVAL(a64);
// PISO/TETO respeitam o sinal
ESCREVAL(PISO(3.7));
ESCREVAL(TETO(3.2));
ESCREVAL(PISO(-3.2));
ESCREVAL(TETO(-3.7));
// DIFERENTE e TEXTOS_DIFERENTES (formas prefixadas)
ESCREVAL(DIFERENTE(3, 4));
ESCREVAL(DIFERENTE(3, 3));
ESCREVAL(TEXTOS_DIFERENTES("a", "b"));
ESCREVAL(TEXTOS_DIFERENTES("a", "a"));
// sorteio: só a faixa é previsível, o valor não
Linhas 29–35 · abrir contexto
INTEIRO s = SORTEIA(100);
SE s >= 0 E s < 100 ENTAO
ESCREVAL("sorteio na faixa");
SENAO
ESCREVAL("sorteio fora da faixa");
FIM_SE
FIM
tests/casos/03_controle/c01_se_simples/programa.c
Contexto: c01_se_simples. Linhas: 6, 9. Tipo de evidência: código; via ESCREVAL.
Linhas 4–11 · abrir contexto
INTEIRO x = 10;
SE x > 5 ENTAO
ESCREVAL("maior");
FIM_SE
SE x > 50 ENTAO
ESCREVAL("nunca");
FIM_SE
FIM
tests/casos/03_controle/c02_se_senao/programa.c
Contexto: c02_se_senao. Linhas: 6, 8. Tipo de evidência: código; via ESCREVAL.
Linhas 4–10 · abrir contexto
INTEIRO x = 3;
SE x MOD 2 == 0 ENTAO
ESCREVAL("par");
SENAO
ESCREVAL("impar");
FIM_SE
FIM
tests/casos/03_controle/c04_aninhado/programa.c
Contexto: c04_aninhado. Linhas: 13, 15, 18, 21. Tipo de evidência: código; via ESCREVAL.
Linhas 11–23 · abrir contexto
SE b == 2 ENTAO
SE c == 3 ENTAO
ESCREVAL("tres niveis");
SENAO
ESCREVAL("c errado");
FIM_SE
SENAO
ESCREVAL("b errado");
FIM_SE
SENAO
ESCREVAL("a errado");
FIM_SE
FIM
tests/casos/03_controle/c05_se_vazio/programa.c
Contexto: c05_se_vazio. Linhas: 11. Tipo de evidência: código; via ESCREVAL.
Linhas 9–12 · abrir contexto
SENAO
FIM_SE
ESCREVAL("vazio ok");
FIM
tests/casos/03_controle/c06_enquanto_zero/programa.c
Contexto: c06_enquanto_zero. Linhas: 6, 9. Tipo de evidência: código; via ESCREVAL.
Linhas 4–10 · abrir contexto
INTEIRO i = 10;
ENQUANTO i < 5 FACA
ESCREVAL("nunca");
i = i + 1;
FIM_ENQUANTO
ESCREVAL(i);
FIM
tests/casos/03_controle/c07_enquanto_pare/programa.c
Contexto: c07_enquanto_pare. Linhas: 11. Tipo de evidência: código; via ESCREVAL.
Linhas 9–12 · abrir contexto
FIM_SE
FIM_ENQUANTO
ESCREVAL(i);
FIM
tests/casos/03_controle/c08_enquanto_prossiga/programa.c
Contexto: c08_enquanto_prossiga. Linhas: 15. Tipo de evidência: código; via ESCREVAL.
Linhas 13–16 · abrir contexto
soma = soma + i;
FIM_ENQUANTO
ESCREVAL(soma); // 1+2+4+5+7+8+10 = 37
FIM
tests/casos/03_controle/c09_repita_uma_vez/programa.c
Contexto: c09_repita_uma_vez. Linhas: 8. Tipo de evidência: código; via ESCREVAL.
Linhas 6–9 · abrir contexto
n = n + 1;
ATE_QUE(n > 0);
ESCREVAL(n);
FIM
tests/casos/03_controle/c10_repita_ate_que/programa.c
Contexto: c10_repita_ate_que. Linhas: 11. Tipo de evidência: código; via ESCREVAL.
Linhas 9–12 · abrir contexto
ATE_QUE(n >= 3);
ESCREVA_LINHA();
ESCREVAL(n);
FIM
tests/casos/03_controle/c11_para_basico/programa.c
Contexto: c11_para_basico. Linhas: 10. Tipo de evidência: código; via ESCREVAL.
Linhas 8–11 · abrir contexto
}
ESCREVA_LINHA();
ESCREVAL(i); // depois do laco vale 6 (foi incrementado)
FIM
tests/casos/03_controle/c12_para_vazio/programa.c
Contexto: c12_para_vazio. Linhas: 7, 9. Tipo de evidência: código; via ESCREVAL.
Linhas 5–10 · abrir contexto
INTEIRO i = 0;
PARA (i, 5, 1) {
ESCREVAL("nunca");
}
ESCREVAL(i);
FIM
tests/casos/03_controle/c18_escolha_pare/programa.c
Contexto: c18_escolha_pare. Linhas: 7, 10, 13. Tipo de evidência: código; via ESCREVAL.
Linhas 5–15 · abrir contexto
ESCOLHA (opcao)
CASO 1:
ESCREVAL("novo");
PARE;
CASO 2:
ESCREVAL("abrir");
PARE;
CONTRARIO:
ESCREVAL("invalido");
FIM_ESCOLHA
}
tests/casos/03_controle/c20_escolha_bloco/programa.c
Contexto: c20_escolha_bloco. Linhas: 9, 13. Tipo de evidência: código; via ESCREVAL.
Linhas 7–15 · abrir contexto
CASO 3: {
INTEIRO quadrado = 3 * 3;
ESCREVAL(quadrado);
PARE;
}
CONTRARIO:
ESCREVAL("outro");
FIM_ESCOLHA
FIM
tests/casos/03_controle/c21_laco_com_condicoes/programa.c
Contexto: c21_laco_com_condicoes. Linhas: 17, 18. Tipo de evidência: código; via ESCREVAL.
Linhas 15–19 · abrir contexto
FIM_SE
FIM_ENQUANTO
ESCREVAL(i); // 51
ESCREVAL(achados); // 14,21,28,35,42,49 = 6
FIM
tests/casos/03_controle/c22_escolha_com_chamada/programa.c
Contexto: c22_escolha_com_chamada. Linhas: 10, 13, 18, 21. Tipo de evidência: código; via ESCREVAL.
Linhas 8–23 · abrir contexto
ESCOLHA (soma(1, 2))
CASO 3:
ESCREVAL("tres");
PARE;
CONTRARIO:
ESCREVAL("outro");
FIM_ESCOLHA
ESCOLHA (soma(2, 2) * 2)
CASO 8:
ESCREVAL("oito");
PARE;
CONTRARIO:
ESCREVAL("outro");
FIM_ESCOLHA
FIM
tests/casos/03_controle/c23_para_passo_negativo/programa.c
Contexto: c23_para_passo_negativo. Linhas: 18, 20. Tipo de evidência: código; via ESCREVAL.
Linhas 16–21 · abrir contexto
// passo negativo que nunca alcança o limite: nenhuma iteração
PARA_PASSO (i, 1, 5, -1) {
ESCREVAL("nao deveria aparecer");
}
ESCREVAL("fim");
FIM
tests/casos/03_controle/c24_zero_iteracoes/programa.c
Contexto: c24_zero_iteracoes. Linhas: 12, 17, 22, 28. Tipo de evidência: código; via ESCREVAL.
Linhas 10–24 · abrir contexto
n = n + 1;
}
ESCREVAL(n); // 0
PARA_PASSO (i, 1, 5, -1) { // passo negativo sem alcançar o fim
n = n + 1;
}
ESCREVAL(n); // 0
ENQUANTO n > 100 FACA // condição falsa logo na entrada
n = n + 1;
FIM_ENQUANTO
ESCREVAL(n); // 0
INTEIRO um = 1;
Linhas 26–29 · abrir contexto
n = n + 1;
ATE_QUE(um == 1);
ESCREVAL(n); // 1
FIM
tests/casos/03_controle/c25_limites_inclusivos/programa.c
Contexto: c25_limites_inclusivos. Linhas: 11, 39. Tipo de evidência: código; via ESCREVAL.
Linhas 9–13 · abrir contexto
PARA (i, 4, 4) { // um único valor
n = n + 1;
ESCREVAL(i); // 4
}
Linhas 37–40 · abrir contexto
ESCREVA_LINHA(); // -2 -1 0 1
ESCREVAL(n); // 1
FIM
tests/casos/03_controle/c26_passo_zero_erro/programa.c
Contexto: c26_passo_zero_erro. Linhas: 8, 10, 12. Tipo de evidência: código; via ESCREVAL.
Linhas 6–13 · abrir contexto
INTEIRO i = 0;
INTEIRO passo = 0;
ESCREVAL("antes");
PARA_PASSO (i, 1, 10, passo) {
ESCREVAL("nao deveria aparecer");
}
ESCREVAL("depois");
FIM
tests/casos/03_controle/c27_passo_zero_intervalo_vazio/programa.c
Contexto: c27_passo_zero_intervalo_vazio. Linhas: 8, 10, 12. Tipo de evidência: código; via ESCREVAL.
Linhas 6–13 · abrir contexto
INTEIRO i = 0;
INTEIRO passo = 0;
ESCREVAL("antes");
PARA_PASSO (i, 5, 1, passo) {
ESCREVAL("nao deveria aparecer");
}
ESCREVAL("depois");
FIM
tests/casos/03_controle/c28_aninhados_pare_prossiga/programa.c
Contexto: c28_aninhados_pare_prossiga. Linhas: 19, 32. Tipo de evidência: código; via ESCREVAL.
Linhas 17–21 · abrir contexto
total = total + 100;
}
ESCREVAL(total); // 3*2 + 3*100 = 306
// PROSSIGA: pula só o j par, dentro de cada i; o +10 externo roda 3 vezes.
Linhas 30–33 · abrir contexto
total = total + 10;
}
ESCREVAL(total); // 3*2 + 3*10 = 36
FIM
tests/casos/03_controle/c29_saida_de_dois_lacos/programa.c
Contexto: c29_saida_de_dois_lacos. Linhas: 25, 26, 41. Tipo de evidência: código; via ESCREVAL.
Linhas 23–28 · abrir contexto
FIM_SE
}
ESCREVAL(ai); // 2 (primeiro par com produto 6)
ESCREVAL(aj); // 3
// sem par que dê 7: a bandeira nunca liga e os dois laços terminam sozinhos
Linhas 39–42 · abrir contexto
FIM_SE
}
ESCREVAL(achou); // 0
FIM
tests/casos/03_controle/c30_repita_prossiga/programa.c
Contexto: c30_repita_prossiga. Linhas: 15, 16. Tipo de evidência: código; via ESCREVAL.
Linhas 13–17 · abrir contexto
pares = pares + 1;
ATE_QUE(i >= 6);
ESCREVAL(i); // 6
ESCREVAL(pares); // 3
FIM
tests/casos/03_controle/c31_enquanto_prossiga/programa.c
Contexto: c31_enquanto_prossiga. Linhas: 15. Tipo de evidência: código; via ESCREVAL.
Linhas 13–16 · abrir contexto
soma = soma + i;
FIM_ENQUANTO
ESCREVAL(soma); // 1..10 = 55, menos 5 = 50
FIM
tests/casos/03_controle/c32_para_prossiga_avanca/programa.c
Contexto: c32_para_prossiga_avanca. Linhas: 14, 15. Tipo de evidência: código; via ESCREVAL.
Linhas 12–16 · abrir contexto
vistos = vistos + 1;
}
ESCREVAL(vistos); // 1 (só o 5)
ESCREVAL(i); // 6
FIM
tests/casos/03_controle/c33_condicoes_aninhadas/programa.c
Contexto: c33_condicoes_aninhadas. Linhas: 13, 15, 18. Tipo de evidência: código; via ESCREVAL.
Linhas 11–20 · abrir contexto
SE a == 1 ENTAO
SE b == 1 ENTAO
ESCREVAL("a e b");
SENAO
ESCREVAL("so a"); // SENAO do SE interno (b)
FIM_SE
SENAO
ESCREVAL("nem a"); // SENAO do SE externo (a)
FIM_SE
}
tests/casos/03_controle/c34_faixas_senao_se/programa.c
Contexto: c34_faixas_senao_se. Linhas: 9, 11, 13, 15. Tipo de evidência: código; via ESCREVAL.
Linhas 7–17 · abrir contexto
ESCREVA_FMT("%d: ", nota);
SE nota < 5 ENTAO
ESCREVAL("reprovado");
SENAO_SE nota < 7 ENTAO
ESCREVAL("recuperacao");
SENAO_SE nota == 9 OU nota == 10 ENTAO
ESCREVAL("excelente");
SENAO
ESCREVAL("aprovado");
FIM_SE
}
tests/casos/03_controle/c35_escolha_no_laco/programa.c
Contexto: c35_escolha_no_laco. Linhas: 25. Tipo de evidência: código; via ESCREVAL.
Linhas 23–26 · abrir contexto
total = total + 1000; // i = 1..5
}
ESCREVAL(total); // 5221
FIM
tests/casos/03_controle/c36_laco_entrada_sentinela/programa.c
Contexto: c36_laco_entrada_sentinela. Linhas: 12, 35, 37, 39, 41, 43, 55. Tipo de evidência: código; via ESCREVAL.
Linhas 10–14 · abrir contexto
INTEIRO minimo = 0;
ESCREVAL("Rodada 1");
SE NAO LEIA_INTEIRO(valor) ENTAO
ERRO("entrada invalida");
Linhas 33–45 · abrir contexto
FIM_ENQUANTO
ESCREVA("quantidade: ");
ESCREVAL(qtd);
ESCREVA("soma: ");
ESCREVAL(soma);
ESCREVA("maximo: ");
ESCREVAL(maximo);
ESCREVA("minimo: ");
ESCREVAL(minimo);
ESCREVAL("Rodada 2");
qtd = 0;
SE NAO LEIA_INTEIRO(valor) ENTAO
Linhas 53–56 · abrir contexto
FIM_ENQUANTO
ESCREVA("quantidade: ");
ESCREVAL(qtd);
FIM
tests/casos/03_controle/c37_laco_interno_vazio/programa.c
Contexto: c37_laco_interno_vazio. Linhas: 10, 13, 15. Tipo de evidência: código; via ESCREVAL.
Linhas 8–17 · abrir contexto
PARA (i, 1, 3) {
PARA (j, 5, 4) { // vazio
ESCREVAL("nunca");
}
PARA_PASSO (j, 1, 3, -1) { // vazio por passo negativo
ESCREVAL("nunca");
}
ESCREVAL(i);
}
FIM
tests/casos/03_controle/c38_virgula_em_enquanto/programa.c
Contexto: c38_virgula_em_enquanto. Linhas: 12, 13. Tipo de evidência: código; via ESCREVAL.
Linhas 10–14 · abrir contexto
n = n + 1;
FIM_ENQUANTO
ESCREVAL(n); // 3
ESCREVAL(i); // 4
FIM
tests/casos/03_controle/c39_senao_com_se_aninhado/programa.c
Contexto: c39_senao_com_se_aninhado. Linhas: 9, 11, 13. Tipo de evidência: código; via ESCREVAL.
Linhas 7–15 · abrir contexto
INTEIRO b = 1;
SE a > 0 ENTAO
ESCREVAL("pos");
SENAO
ESCREVAL("nao positivo");
SE b > 0 ENTAO
ESCREVAL("b positivo");
FIM_SE
FIM_SE
tests/casos/03_controle/c40_passo_sem_sinal/programa.c
Contexto: c40_passo_sem_sinal. Linhas: 13, 15. Tipo de evidência: código; via ESCREVAL.
Linhas 11–16 · abrir contexto
ESCREVA_LINHA();
PARA_PASSO (i, 6, 0, passo) { // passo positivo sem alcançar o fim: vazio
ESCREVAL("nunca");
}
ESCREVAL("fim");
FIM
tests/casos/04_estruturas/e01_vetor_basico/programa.c
Contexto: e01_vetor_basico. Linhas: 16, 17, 18. Tipo de evidência: código; via ESCREVAL.
Linhas 14–19 · abrir contexto
}
ESCREVAL(v[0]); // 0
ESCREVAL(v[4]); // 16
ESCREVAL(soma); // 0+1+4+9+16 = 30
FIM
tests/casos/04_estruturas/e02_tamanho_vetor/programa.c
Contexto: e02_tamanho_vetor. Linhas: 9. Tipo de evidência: código; via ESCREVAL.
Linhas 7–11 · abrir contexto
VETOR(TEXTO, c, 2);
ESCREVAL(TAMANHO_VETOR(a));
ESCREVAL(TAMANHO_VETOR(b));
ESCREVAL(TAMANHO_VETOR(c));
tests/casos/04_estruturas/e03_texto_buffer/programa.c
Contexto: e03_texto_buffer. Linhas: 9, 12, 13. Tipo de evidência: código; via ESCREVAL.
Linhas 7–14 · abrir contexto
COPIA_TEXTO(nome, (INTEIRO) sizeof nome, "mundo");
ESCREVAL(nome);
JUNTA_TEXTO(saudacao, (INTEIRO) sizeof saudacao, "ola, ", nome);
ESCREVAL(saudacao);
ESCREVAL(TAMANHO_TEXTO(saudacao));
FIM
tests/casos/04_estruturas/e04_registro/programa.c
Contexto: e04_registro. Linhas: 14. Tipo de evidência: código; via ESCREVAL.
Linhas 12–16 · abrir contexto
ESCREVA(", ");
ESCREVA_FMT("%.1f", p.y);
ESCREVAL(")");
}
tests/casos/04_estruturas/e05_registro_aninhado/programa.c
Contexto: e05_registro_aninhado. Linhas: 24. Tipo de evidência: código; via ESCREVAL.
Linhas 22–25 · abrir contexto
ESCREVA_TEXTO(p.onde.rua);
ESCREVA(", ");
ESCREVAL(p.onde.numero);
FIM
tests/casos/04_estruturas/e07_enumeracao/programa.c
Contexto: e07_enumeracao. Linhas: 26, 27, 28, 29. Tipo de evidência: código; via ESCREVAL.
Linhas 24–30 · abrir contexto
INICIO
Cor c = VERDE;
ESCREVAL((INTEIRO) c);
ESCREVAL(nome_da(c));
ESCREVAL(nome_da(VERMELHO));
ESCREVAL(nome_da((Cor) 99));
FIM
tests/casos/04_estruturas/e08_recursao/programa.c
Contexto: e08_recursao. Linhas: 19, 20, 21, 22. Tipo de evidência: código; via ESCREVAL.
Linhas 17–23 · abrir contexto
INICIO
ESCREVAL((long long) fatorial(5));
ESCREVAL((long long) fatorial(10));
ESCREVAL(fib(10));
ESCREVAL(fib(15));
FIM
tests/casos/04_estruturas/e09_funcao_vetor/programa.c
Contexto: e09_funcao_vetor. Linhas: 28, 29, 30. Tipo de evidência: código; via ESCREVAL.
Linhas 26–31 · abrir contexto
}
dobra(v, (INTEIRO) TAMANHO_VETOR(v));
ESCREVAL(v[0]);
ESCREVAL(v[3]);
ESCREVAL(soma(v, (INTEIRO) TAMANHO_VETOR(v)));
FIM
tests/casos/04_estruturas/e10_registro_por_valor/programa.c
Contexto: e10_registro_por_valor. Linhas: 11, 18. Tipo de evidência: código; via ESCREVAL.
Linhas 9–13 · abrir contexto
PROCEDIMENTO deposita(Conta c, INTEIRO valor) {
c.saldo = c.saldo + valor;
ESCREVAL(c.saldo);
}
Linhas 16–19 · abrir contexto
minha.saldo = 100;
deposita(minha, 50);
ESCREVAL(minha.saldo); // continua 100
FIM
tests/casos/04_estruturas/e11_procedimento_vazio/programa.c
Contexto: e11_procedimento_vazio. Linhas: 15. Tipo de evidência: código; via ESCREVAL.
Linhas 13–16 · abrir contexto
nada();
nada2();
ESCREVAL("ok");
FIM
tests/casos/05_entrada_saida/i01_formatos/programa.c
Contexto: i01_formatos. Linhas: 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27. Tipo de evidência: código; via ESCREVAL.
Linhas 15–28 · abrir contexto
TEXTO s = "texto";
ESCREVAL(b);
ESCREVAL(c);
ESCREVAL(i);
ESCREVAL(u);
ESCREVAL(l);
ESCREVAL(g);
ESCREVAL(f);
ESCREVAL(d);
ESCREVAL(ld);
ESCREVAL(s);
ESCREVAL(TAMANHO_VETOR("abcd") - 1); /* so para exercitar size_t */
FIM
tests/casos/05_entrada_saida/i02_escreval_linha_texto/programa.c
Contexto: i02_escreval_linha_texto. Linhas: 8. Tipo de evidência: código; via ESCREVAL.
Linhas 6–10 · abrir contexto
ESCREVA("b");
ESCREVA_LINHA();
ESCREVAL("c");
ESCREVA_TEXTO("d");
ESCREVA_TEXTO("e");
tests/casos/05_entrada_saida/i04_leia_tipos/programa.c
Contexto: i04_leia_tipos. Linhas: 11. Tipo de evidência: código; via ESCREVAL.
Linhas 9–13 · abrir contexto
SE LEIA_OK(n) ENTAO
ESCREVA("int ");
ESCREVAL(n);
FIM_SE
SE LEIA_OK(r) ENTAO
tests/casos/05_entrada_saida/i05_leia_falha/programa.c
Contexto: i05_leia_falha. Linhas: 8, 10, 12. Tipo de evidência: código; via ESCREVAL.
Linhas 6–13 · abrir contexto
INTEIRO n = -1;
SE LEIA_OK(n) ENTAO
ESCREVAL("leu");
SENAO
ESCREVAL("falhou");
FIM_SE
ESCREVAL(n); // continua -1: scanf nao escreveu nada
FIM
tests/casos/05_entrada_saida/i06_leia_texto_apos_leia/programa.c
Contexto: i06_leia_texto_apos_leia. Linhas: 16. Tipo de evidência: código; via ESCREVAL.
Linhas 14–18 · abrir contexto
ESCREVA("nome [");
ESCREVA_TEXTO(nome);
ESCREVAL("]");
FIM_SE
FIM
tests/casos/05_entrada_saida/i07_leia_texto_limpo/programa.c
Contexto: i07_leia_texto_limpo. Linhas: 10. Tipo de evidência: código; via ESCREVAL.
Linhas 8–12 · abrir contexto
ESCREVA("[");
ESCREVA_TEXTO(linha);
ESCREVAL("]");
FIM_SE
FIM
tests/casos/05_entrada_saida/i08_leia_texto_truncamento/programa.c
Contexto: i08_leia_texto_truncamento. Linhas: 10, 12, 18. Tipo de evidência: código; via ESCREVAL.
Linhas 8–14 · abrir contexto
SE LEIA_TEXTO(pequeno, (INTEIRO) sizeof pequeno) ENTAO
ESCREVAL("coube");
SENAO
ESCREVAL("truncou");
FIM_SE
Linhas 16–20 · abrir contexto
ESCREVA("proxima [");
ESCREVA_TEXTO(depois);
ESCREVAL("]");
FIM_SE
FIM
tests/casos/05_entrada_saida/i09_texto_truncamento/programa.c
Contexto: i09_texto_truncamento. Linhas: 11, 12, 15, 16, 19, 21, 22. Tipo de evidência: código; via ESCREVAL.
Linhas 9–23 · abrir contexto
ok = COPIA_TEXTO(a, (INTEIRO) sizeof a, "abcdef");
ESCREVAL(ok); // 0
ESCREVAL(TAMANHO_TEXTO(a)); // 0 (destino vazio)
ok = COPIA_TEXTO(a, (INTEIRO) sizeof a, "abc");
ESCREVAL(ok); // 1
ESCREVAL(a);
ok = JUNTA_TEXTO(b, (INTEIRO) sizeof b, "abcd", "efgh");
ESCREVAL(ok); // 0
ok = JUNTA_TEXTO(b, (INTEIRO) sizeof b, "abc", "de");
ESCREVAL(ok); // 1
ESCREVAL(b);
FIM
tests/casos/05_entrada_saida/i10_conversoes/programa.c
Contexto: i10_conversoes. Linhas: 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 21, 22. Tipo de evidência: código; via ESCREVAL.
Linhas 7–24 · abrir contexto
REAL r = 0.0;
ESCREVAL(TEXTO_PARA_INTEIRO("42", &n)); // 1
ESCREVAL(n);
ESCREVAL(TEXTO_PARA_INTEIRO("-7", &n)); // 1
ESCREVAL(n);
ESCREVAL(TEXTO_PARA_INTEIRO(" 13 ", &n)); // 1
ESCREVAL(n);
ESCREVAL(TEXTO_PARA_INTEIRO("4x2", &n)); // 0
ESCREVAL(TEXTO_PARA_INTEIRO("", &n)); // 0
ESCREVAL(TEXTO_PARA_INTEIRO("abc", &n)); // 0
ESCREVAL(TEXTO_PARA_REAL("2.75", &r)); // 1
ESCREVA_FMT("%.2f\n", r);
ESCREVAL(TEXTO_PARA_REAL("2,75", &r)); // 0 (locale C)
ESCREVAL(TEXTO_PARA_REAL("1e3", &r)); // 1
ESCREVA_FMT("%.0f\n", r);
FIM
tests/casos/05_entrada_saida/i11_tamanho_texto_acentos/programa.c
Contexto: i11_tamanho_texto_acentos. Linhas: 5, 6, 7, 8. Tipo de evidência: código; via ESCREVAL.
Linhas 3–9 · abrir contexto
INICIO
ESCREVAL(TAMANHO_TEXTO("abc")); // 3
ESCREVAL(TAMANHO_TEXTO("")); // 0
ESCREVAL(TAMANHO_TEXTO("ação")); // 6 bytes: a + ç(2) + ã(2) + o
ESCREVAL(TAMANHO_TEXTO(NULL)); // 0 (robusto)
FIM
tests/casos/05_entrada_saida/i12_erro_fatal/programa.c
Contexto: i12_erro_fatal. Linhas: 8. Tipo de evidência: código; via ESCREVAL.
Linhas 6–9 · abrir contexto
ESCREVA_LINHA();
ERRO("divisao por zero");
ESCREVAL("nunca");
FIM
tests/casos/05_entrada_saida/i13_afirme_ok/programa.c
Contexto: i13_afirme_ok. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–8 · abrir contexto
INTEIRO total = 10;
AFIRME(total > 0, "total deve ser positivo");
ESCREVAL("contrato ok");
FIM
tests/casos/05_entrada_saida/i14_afirme_dispara/programa.c
Contexto: i14_afirme_dispara. Linhas: 6, 8. Tipo de evidência: código; via ESCREVAL.
Linhas 4–9 · abrir contexto
INICIO
INTEIRO total = -1;
ESCREVAL("comecando");
AFIRME(total > 0, "total deve ser positivo");
ESCREVAL("nunca");
FIM
tests/casos/05_entrada_saida/i15_leia_caractere_apos_numero/programa.c
Contexto: i15_leia_caractere_apos_numero. Linhas: 14, 17. Tipo de evidência: código; via ESCREVAL.
Linhas 12–19 · abrir contexto
ESCREVA_FMT("lido %d e '%c'\n", n, c);
SENAO
ESCREVAL("sem letra");
FIM_SE
SENAO
ESCREVAL("sem numero");
FIM_SE
FIM
tests/casos/06_negativos/n01_se_sem_fim_se/programa.c
Contexto: n01_se_sem_fim_se. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–7 · abrir contexto
INICIO
SE 1 ENTAO
ESCREVAL("x");
FIM
tests/casos/06_negativos/n02_se_com_chaves_c/programa.c
Contexto: n02_se_com_chaves_c. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–8 · abrir contexto
INICIO
SE (1) {
ESCREVAL("x");
}
FIM
tests/casos/06_negativos/n03_senao_se/programa.c
Contexto: n03_senao_se. Linhas: 6, 8. Tipo de evidência: código; via ESCREVAL.
Linhas 4–10 · abrir contexto
INICIO
SE 1 ENTAO
ESCREVAL("a");
SENAO SE 2 ENTAO
ESCREVAL("b");
FIM_SE
FIM
tests/casos/06_negativos/n04_escreval_dois_valores/programa.c
Contexto: n04_escreval_dois_valores. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–6 · abrir contexto
// ESCREVA/ESCREVAL recebem UM valor; use ESCREVA_FMT para varios
INICIO
ESCREVAL("a", "b");
FIM
tests/casos/06_negativos/n05_texto_e_imutavel/programa.c
Contexto: n05_texto_e_imutavel. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–8 · abrir contexto
TEXTO s = "abc";
s[0] = 'x';
ESCREVAL(s);
FIM
tests/casos/06_negativos/n07_mod_igual/programa.c
Contexto: n07_mod_igual. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–8 · abrir contexto
INTEIRO x = 10;
x MOD= 3;
ESCREVAL(x);
FIM
tests/casos/06_negativos/n08_variavel_com_nome_de_palavra/programa.c
Contexto: n08_variavel_com_nome_de_palavra. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–7 · abrir contexto
INICIO
INTEIRO SE = 1;
ESCREVAL(SE);
FIM
tests/casos/06_negativos/n09_dois_inicio/programa.c
Contexto: n09_dois_inicio. Linhas: 5, 8. Tipo de evidência: código; via ESCREVAL.
Linhas 3–9 · abrir contexto
// um programa = um INICIO
INICIO
ESCREVAL("a");
FIM
INICIO
ESCREVAL("b");
FIM
tests/casos/06_negativos/n10_falta_entao/programa.c
Contexto: n10_falta_entao. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–8 · abrir contexto
INICIO
SE 1
ESCREVAL("sem entao");
FIM_SE
FIM
tests/casos/06_negativos/n11_fim_a_mais/programa.c
Contexto: n11_fim_a_mais. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–7 · abrir contexto
// um FIM sobrando
INICIO
ESCREVAL("a");
FIM
FIM
tests/casos/06_negativos/n12_texto_para_caractere/programa.c
Contexto: n12_texto_para_caractere. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–7 · abrir contexto
INICIO
CARACTERE c = "A";
ESCREVAL(c);
FIM
tests/casos/06_negativos/n13_texto_para_inteiro/programa.c
Contexto: n13_texto_para_inteiro. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–7 · abrir contexto
INICIO
INTEIRO n = "42";
ESCREVAL(n);
FIM
tests/casos/06_negativos/n14_mod_com_real/programa.c
Contexto: n14_mod_com_real. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–7 · abrir contexto
INICIO
INTEIRO resto = 7 MOD 2.5;
ESCREVAL(resto);
FIM
tests/casos/06_negativos/n15_resto_com_real/programa.c
Contexto: n15_resto_com_real. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–7 · abrir contexto
INICIO
INTEIRO resto = RESTO(7, 2.5);
ESCREVAL(resto);
FIM
tests/casos/06_negativos/n16_leia_logico/programa.c
Contexto: n16_leia_logico. Linhas: 24. Tipo de evidência: código; via ESCREVAL.
Linhas 22–26 · abrir contexto
SE ligado
ENTAO
ESCREVAL("ligado");
FIM_SE
FIM
tests/casos/06_negativos/n17_pare_fora_de_laco/programa.c
Contexto: n17_pare_fora_de_laco. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–7 · abrir contexto
// PARE só existe dentro de laço ou ESCOLHA
INICIO
ESCREVAL("x");
PARE;
FIM
tests/casos/06_negativos/n20_escolha_com_virgula/programa.c
Contexto: n20_escolha_com_virgula. Linhas: 9. Tipo de evidência: código; via ESCREVAL.
Linhas 7–11 · abrir contexto
ESCOLHA (a, b)
CASO 1:
ESCREVAL("um");
PARE;
FIM_ESCOLHA
tests/casos/06_negativos/n21_leia_texto/programa.c
Contexto: n21_leia_texto. Linhas: 16. Tipo de evidência: código; via ESCREVAL.
Linhas 14–17 · abrir contexto
LEIA(nome);
ESCREVAL(nome);
FIM
tests/casos/06_negativos/n22_leia_texto_fixo/programa.c
Contexto: n22_leia_texto_fixo. Linhas: 16. Tipo de evidência: código; via ESCREVAL.
Linhas 14–17 · abrir contexto
LEIA(buf);
ESCREVAL(buf);
FIM
tests/casos/06_negativos/n23_tamanho_de_ponteiro/programa.c
Contexto: n23_tamanho_de_ponteiro. Linhas: 21. Tipo de evidência: código; via ESCREVAL.
Linhas 19–22 · abrir contexto
v[0] = 1;
ESCREVAL(TAMANHO_VETOR(p));
FIM
tests/casos/07_multiarquivo/m01_modulos/principal.c
Contexto: m01_modulos. Linhas: 5, 6, 7, 8, 9, 10. Tipo de evidência: código; via ESCREVAL.
Linhas 3–12 · abrir contexto
INICIO
ESCREVAL(mdc(48, 18)); // 6
ESCREVAL(mmc(4, 6)); // 12
ESCREVAL(mmc(0, 7)); // 0
ESCREVAL(eh_primo(97)); // 1
ESCREVAL(eh_primo(1)); // 0
ESCREVAL(eh_primo(91)); // 0
tabuada(3);
FIM
tests/casos/07_multiarquivo/m02_estatico_misto/principal.c
Contexto: m02_estatico_misto. Linhas: 5, 6, 7. Tipo de evidência: código; via ESCREVAL.
Linhas 3–8 · abrir contexto
INICIO
ESCREVAL(contador_global()); // 3 * 2 = 6
ESCREVAL(contador_global()); // total 6 -> 12
ESCREVAL(ajuda_c()); // 42
FIM
tests/casos/08_aplicacao/app_acervo/relatorio.c
Contexto: app_acervo. Linhas: 47, 49. Tipo de evidência: código; via ESCREVAL.
Linhas 45–51 · abrir contexto
COPIA_TEXTO(situacao_txt, 16, nome_situacao(acervo_situacao(0)));
SE TEXTOS_IGUAIS(situacao_txt, "disponivel") ENTAO
ESCREVAL("o primeiro livro esta livre");
SENAO
ESCREVAL("o primeiro livro esta emprestado");
FIM_SE
}
tests/casos/09_tipos_expr/t01_inteiros/programa.c
Contexto: t01_inteiros. Linhas: 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 33, 34, 35, 36, 37, 38, 39, 48, 49, 50, 53. Tipo de evidência: código; via ESCREVAL.
Linhas 13–41 · abrir contexto
NATURAL_LONGO nlongo = 4000000000UL;
ESCREVAL(BITS_DE(INTEIRO8) == 8);
ESCREVAL(BITS_DE(INTEIRO16) == 16);
ESCREVAL(BITS_DE(INTEIRO32) == 32);
ESCREVAL(BITS_DE(INTEIRO64) == 64);
ESCREVAL(TAMANHO_DE(CARACTERE) == 1);
ESCREVAL(sizeof(INTEIRO_CURTO) <= sizeof(INTEIRO));
ESCREVAL(sizeof(INTEIRO) <= sizeof(INTEIRO_LONGO));
ESCREVAL(i8);
ESCREVAL(i16);
ESCREVAL(i32);
ESCREVAL(i64);
ESCREVAL(curto);
ESCREVAL(longo);
ESCREVAL(ncurto);
ESCREVAL(nlongo);
// --- divisão inteira trunca em direção a zero; o resto segue o dividendo
ESCREVAL(7 / 2);
ESCREVAL(-7 / 2);
ESCREVAL(7 / -2);
ESCREVAL(-8 / 2);
ESCREVAL(7 MOD 2);
ESCREVAL(-7 MOD 2);
ESCREVAL(7 MOD -2);
// --- natural estoura em módulo 2^N, o que C define (não é indefinido)
Linhas 46–54 · abrir contexto
n16 = n16 + 1;
n32 = n32 + 1u;
ESCREVAL(n8);
ESCREVAL(n16);
ESCREVAL(n32);
// conversão de negativo para natural é módulo 2^N, também definida
ESCREVAL((NATURAL) -1 == MAXIMO_NATURAL);
FIM
tests/casos/09_tipos_expr/t02_reais/programa.c
Contexto: t02_reais. Linhas: 9, 10, 11, 15, 16, 24, 25, 26, 29, 30, 31, 32, 33, 36, 37. Tipo de evidência: código; via ESCREVAL.
Linhas 7–18 · abrir contexto
REAL_LONGO ld = 1.5L;
ESCREVAL(sizeof(REAL) >= sizeof(REAL_CURTO));
ESCREVAL(sizeof(REAL_LONGO) >= sizeof(REAL));
ESCREVAL(TAMANHO_DE(REAL) >= 4);
// 0.1 + 0.2 nao e 0.3 em binario: comparar com tolerancia, nao com ==
REAL soma = 0.1 + 0.2;
ESCREVAL(soma == 0.3);
ESCREVAL(ABS(soma - 0.3) < EPSILON_REAL);
ESCREVA_FMT("%.2f\n", soma);
Linhas 22–39 · abrir contexto
ESCREVA_FMT("%.0f\n", -2.6);
ESCREVAL(f);
ESCREVAL(d);
ESCREVAL(ld);
// NaN nao e igual a nada, nem a si mesmo; infinito e maior que tudo
ESCREVAL(NAN == NAN);
ESCREVAL(NAN != NAN);
ESCREVAL(INFINITY > MAXIMO_REAL);
ESCREVAL(isnan(NAN));
ESCREVAL(isinf(INFINITY));
// conversão explícita para inteiro trunca em direção a zero
ESCREVAL((INTEIRO) 3.9);
ESCREVAL((INTEIRO) -3.9);
// ABS/MINIMO/MAXIMO preservam o tipo real
tests/casos/09_tipos_expr/t03_caractere/programa.c
Contexto: t03_caractere. Linhas: 8, 9, 10, 12, 13, 16, 17, 18, 19, 20, 21, 22, 25, 26, 27, 28, 34. Tipo de evidência: código; via ESCREVAL.
Linhas 6–30 · abrir contexto
CARACTERE z = 'Z';
ESCREVAL(a);
ESCREVAL(z);
ESCREVAL(a + 1); // promoção: 66, e não o caractere 'B'
ESCREVA(a + 2); ESCREVA_LINHA(); // 67 -> 'C'
ESCREVAL((CARACTERE) (a + 1) == 'B');
ESCREVAL(z - a); // distância na tabela: 25
// escapes de C
ESCREVAL('\n' == 10);
ESCREVAL('\t' == 9);
ESCREVAL('\'' == 39);
ESCREVAL('\\' == 92);
ESCREVAL('\0' == 0);
ESCREVAL('\x41' == 'A');
ESCREVAL('\101' == 'A');
// helpers ASCII: exatos e independentes de locale
ESCREVAL(E_DIGITO('7'));
ESCREVAL(E_DIGITO('a'));
ESCREVAL(E_LETRA('a'));
ESCREVAL(E_LETRA('_'));
ESCREVA(CARACTERE_MAIUSCULO('q')); ESCREVA_LINHA();
ESCREVA(CARACTERE_MINUSCULO('Q')); ESCREVA_LINHA();
Linhas 32–35 · abrir contexto
// CARACTERE ocupa exatamente 1 byte; o sinal é o da plataforma (PT-4)
ESCREVAL(sizeof(CARACTERE) == 1);
FIM
tests/casos/09_tipos_expr/t04_logico/programa.c
Contexto: t04_logico. Linhas: 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 22, 23, 24, 25, 30, 33, 35, 38, 39, 42. Tipo de evidência: código; via ESCREVAL.
Linhas 6–43 · abrir contexto
LOGICO f = FALSO;
ESCREVAL(v);
ESCREVAL(f);
ESCREVAL(sizeof(LOGICO) >= 1);
// conversão para LOGICO: zero é falso, qualquer outra coisa é verdadeira
ESCREVAL(LOGICO_DE(0));
ESCREVAL(LOGICO_DE(2));
ESCREVAL(LOGICO_DE(-1));
ESCREVAL(LOGICO_DE(0.0));
ESCREVAL(LOGICO_DE(0.5));
ESCREVAL(LOGICO_DE(NAN)); // NaN é diferente de zero -> verdadeiro
ESCREVAL(LOGICO_DE("x")); // ponteiro não nulo -> verdadeiro
// OU_EXCLUSIVO normaliza os operandos e avalia cada um uma vez
ESCREVAL(OU_EXCLUSIVO(v, f));
ESCREVAL(OU_EXCLUSIVO(v, v));
ESCREVAL(OU_EXCLUSIVO(f, f));
ESCREVAL(OU_EXCLUSIVO(1, 2)); // 1 != 1 -> falso
// E / OU têm curto-circuito: o lado direito não roda quando não precisa
INTEIRO n = 0;
SE f E (++n > 0) ENTAO
ESCREVAL("nao deveria");
FIM_SE
SE v OU (++n > 0) ENTAO
ESCREVAL("curto-circuito ok");
FIM_SE
ESCREVAL(n);
// NAO tem precedência de unário: NAO a E b = (!a) && b
ESCREVAL(NAO f E v);
ESCREVAL(NAO (f E v));
// LOGICO é um inteiro em expressão aritmética (promoção de C)
ESCREVAL(v + v);
FIM
tests/casos/09_tipos_expr/t05_precedencia/programa.c
Contexto: t05_precedencia. Linhas: 6, 7, 8, 9, 10, 11, 12, 13, 17, 18, 19, 20, 21, 22, 23, 28, 30, 33, 34, 35. Tipo de evidência: código; via ESCREVAL.
Linhas 4–36 · abrir contexto
INICIO
ESCREVAL(2 + 3 * 4); // 14 = 2 + (3*4)
ESCREVAL((2 + 3) * 4); // 20
ESCREVAL(10 - 2 - 3); // 5 = (10-2)-3
ESCREVAL(100 / 10 / 2); // 5 = (100/10)/2
ESCREVAL(7 MOD 2 + 1); // 2 = (7%2)+1
ESCREVAL(1 + 2 * 3 MOD 4); // 3 = 1+((2*3)%4)
ESCREVAL(-7 / 2 + 1); // -2 = (-7/2)+1
ESCREVAL(2 + 3 < 6); // 1 = (2+3) < 6
// E liga mais forte que OU. O compilador exige os parênteses (-Wparentheses),
// que é a recomendação R-6 da especificação: escrever 1 E 0 OU 1 é a mesma
// expressão, mas a suíte compila com -Werror e ensina a forma explícita.
ESCREVAL((1 E 0) OU 1); // 1
ESCREVAL(1 OU (0 E 0)); // 1
ESCREVAL(NAO 0 E 0); // 0 = (!0) && 0
ESCREVAL(NAO (0 E 0)); // 1
ESCREVAL(1 << 3); // 8 (bit a bit é C nativo)
ESCREVAL(1 + 1 == 2); // 1 = (1+1) == 2
ESCREVAL((1 + 2) * (3 + 4)); // 21
// atribuição é a mais fraca: comparação acontece antes
INTEIRO x = 5;
LOGICO igual = x == 5;
ESCREVAL(igual);
x = 5 + 1;
ESCREVAL(x);
// parênteses mudam o resultado, não a regra
ESCREVAL(-(2 + 3));
ESCREVAL((INTEIRO) 2.9 + 1);
ESCREVAL((INTEIRO) (2.9 + 1));
FIM
tests/casos/09_tipos_expr/t06_conversoes/programa.c
Contexto: t06_conversoes. Linhas: 7, 8, 10, 11, 12, 14, 15, 16, 17, 22, 26, 27, 28, 29, 30, 31, 32, 33, 37, 38, 39, 43, 44, 45, 46, 51, 53, 54, 57, 58, 59, 60, 61, 62. Tipo de evidência: código; via ESCREVAL.
Linhas 5–63 · abrir contexto
// promoções e casts explícitos
CARACTERE c = 'A';
ESCREVAL(c + 1); // 66 (promoção para INTEIRO)
ESCREVAL((CARACTERE) (c + 1)); // B
INTEIRO i = 7;
ESCREVAL(i / 2); // 3 divisão inteira
ESCREVAL((REAL) i / 2); // 3.5 cast antes da divisão
ESCREVAL((REAL) (i / 2)); // 3 cast depois da divisão
REAL r = 3.99;
ESCREVAL((INTEIRO) r); // 3 truncamento
ESCREVAL((INTEIRO) -3.99); // -3
ESCREVAL((LOGICO) 0); // 0
ESCREVAL((LOGICO) 3); // 1
// atribuição estreita converte em módulo 2^N para tipo sem sinal (definido)
INTEIRO largo = 300;
NATURAL8 um_byte = (NATURAL8) largo;
ESCREVAL(um_byte); // 300 - 256 = 44
// texto -> INTEIRO: aceita o texto inteiro, recusa sobra e estouro
INTEIRO n = 0;
ESCREVAL(TEXTO_PARA_INTEIRO(" 42 ", &n));
ESCREVAL(n);
ESCREVAL(TEXTO_PARA_INTEIRO("42x", &n)); // 0: sobra
ESCREVAL(n); // 42: falha não altera o destino
ESCREVAL(TEXTO_PARA_INTEIRO("2147483648", &n)); // 0: > MAXIMO_INTEIRO
ESCREVAL(n);
ESCREVAL(TEXTO_PARA_INTEIRO("-2147483648", &n));
ESCREVAL(n);
// texto -> NATURAL: "-1" é recusado (viraria ULONG_MAX em strtoul)
NATURAL u = 0;
ESCREVAL(TEXTO_PARA_NATURAL("-1", &u));
ESCREVAL(TEXTO_PARA_NATURAL("42", &u));
ESCREVAL(u);
// texto -> REAL: locale C, sem vírgula decimal, sem estouro nem underflow
REAL d = 0.0;
ESCREVAL(TEXTO_PARA_REAL("2.5", &d));
ESCREVAL(TEXTO_PARA_REAL("2,5", &d));
ESCREVAL(TEXTO_PARA_REAL("1e999", &d));
ESCREVAL(TEXTO_PARA_REAL("1e-999", &d));
ESCREVA_FMT("%.1f\n", d);
// texto -> REAL aceita o que o strtod aceita: "inf" e "nan" são valores
// representáveis (não são erro de faixa); "%f" imprime o que veio
ESCREVAL(TEXTO_PARA_REAL("inf", &d));
ESCREVA_FMT("%.1f\n", d);
ESCREVAL(TEXTO_PARA_REAL("nan", &d));
ESCREVAL(d == d); // 0: NaN não é igual a si mesmo
// REAL -> INTEIRO verificado: NaN, infinito e fora de faixa devolvem falso
ESCREVAL(REAL_PARA_INTEIRO(2.9, &n));
ESCREVAL(n); // 2
ESCREVAL(REAL_PARA_INTEIRO(1e300, &n));
ESCREVAL(REAL_PARA_INTEIRO(NAN, &n));
ESCREVAL(REAL_PARA_INTEIRO(INFINITY, &n));
ESCREVAL(n); // 2 (não alterado quando falha)
FIM
tests/casos/09_tipos_expr/t07_divisao/programa.c
Contexto: t07_divisao. Linhas: 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 21, 22, 26. Tipo de evidência: código; via ESCREVAL.
Linhas 3–27 · abrir contexto
INICIO
ESCREVAL(DIVIDE(7, 2));
ESCREVAL(DIVIDE(-7, 2));
ESCREVAL(DIVIDE(7, -2));
ESCREVAL(RESTO(7, 2));
ESCREVAL(RESTO(-7, 2));
ESCREVAL(RESTO(7, -2));
// o tipo do resultado é o tipo promovido dos operandos
ESCREVAL(DIVIDE(7L, 2L));
ESCREVAL(DIVIDE(7u, 2u));
ESCREVAL(DIVIDE(7LL, 2LL));
ESCREVAL(RESTO(7u, 2u));
ESCREVA_FMT("%.2f\n", DIVIDE(7.0, 2.0));
ESCREVA_FMT("%.2f\n", DIVIDE(-7.0, 2.0));
// MINIMO_INTEIRO / 1 é válido; / -1 é indefinido se o quociente não couber (caso t10)
ESCREVAL(DIVIDE(MINIMO_INTEIRO, 1) == MINIMO_INTEIRO);
ESCREVAL(RESTO(MINIMO_INTEIRO, 2) == 0);
// misturar sinal e natural converte para natural, como em C:
// DIVIDE(-1, 1u) é (NATURAL)-1 / 1, não -1. É o preço de ser C.
ESCREVAL(DIVIDE(-1, 1u) == MAXIMO_NATURAL);
FIM
tests/casos/09_tipos_expr/t08_divisao_por_zero/programa.c
Contexto: t08_divisao_por_zero. Linhas: 8, 9. Tipo de evidência: código; via ESCREVAL.
Linhas 6–10 · abrir contexto
INTEIRO b = 0;
INTEIRO c = DIVIDE(a, b);
ESCREVAL("nao deveria aparecer");
ESCREVAL(c);
FIM
tests/casos/09_tipos_expr/t09_resto_por_zero/programa.c
Contexto: t09_resto_por_zero. Linhas: 7, 8. Tipo de evidência: código; via ESCREVAL.
Linhas 5–9 · abrir contexto
INTEIRO a = 10;
INTEIRO b = 0;
ESCREVAL(RESTO(a, b));
ESCREVAL("nao deveria aparecer");
FIM
tests/casos/09_tipos_expr/t10_estouro_divisao/programa.c
Contexto: t10_estouro_divisao. Linhas: 19. Tipo de evidência: código; via ESCREVAL.
Linhas 17–20 · abrir contexto
}
ESCREVA("MIN/-1: representavel: ");
ESCREVAL("ok");
FIM
tests/casos/09_tipos_expr/t11_texto_seguro/programa.c
Contexto: t11_texto_seguro. Linhas: 9, 11, 13, 14, 17, 19, 20, 23, 24, 26, 27, 30, 32, 34, 35, 36, 39, 41, 42, 44, 48, 49, 50, 51, 52, 53, 54, 57, 58, 62, 64, 66, 67. Tipo de evidência: código; via ESCREVAL.
Linhas 7–68 · abrir contexto
// --- cópia: 7 caracteres + NUL cabem em 8; 8 não cabem
ESCREVAL(COPIA_TEXTO(buf, TAMANHO_VETOR(buf), "abc"));
ESCREVA_TEXTO(buf); ESCREVA_LINHA();
ESCREVAL(COPIA_TEXTO(buf, TAMANHO_VETOR(buf), "1234567"));
ESCREVA_TEXTO(buf); ESCREVA_LINHA();
ESCREVAL(COPIA_TEXTO(buf, TAMANHO_VETOR(buf), "12345678"));
ESCREVAL(TAMANHO_TEXTO(buf)); // 0: falha limpa o destino
// --- junção de dois textos
ESCREVAL(JUNTA_TEXTO(buf, TAMANHO_VETOR(buf), "ab", "cd"));
ESCREVA_TEXTO(buf); ESCREVA_LINHA();
ESCREVAL(JUNTA_TEXTO(buf, TAMANHO_VETOR(buf), "abcd", "efgh"));
ESCREVAL(TAMANHO_TEXTO(buf)); // 0
// --- acréscimo ao que já existe (o strncat seguro)
ESCREVAL(COPIA_TEXTO(buf, TAMANHO_VETOR(buf), "ab"));
ESCREVAL(ACRESCENTA_TEXTO(buf, TAMANHO_VETOR(buf), "cd"));
ESCREVA_TEXTO(buf); ESCREVA_LINHA();
ESCREVAL(ACRESCENTA_TEXTO(buf, TAMANHO_VETOR(buf), "efgh"));
ESCREVAL(TAMANHO_TEXTO(buf)); // 0: 6 caracteres não caberiam
// --- trecho: quantidade limitada ao que existe, início além do fim = vazio
ESCREVAL(TRECHO_TEXTO(buf, TAMANHO_VETOR(buf), "abcdef", 2, 3));
ESCREVA_TEXTO(buf); ESCREVA_LINHA();
ESCREVAL(TRECHO_TEXTO(buf, TAMANHO_VETOR(buf), "abcdef", 4, 99));
ESCREVA_TEXTO(buf); ESCREVA_LINHA();
ESCREVAL(TRECHO_TEXTO(buf, TAMANHO_VETOR(buf), "abcdef", 99, 1));
ESCREVAL(TAMANHO_TEXTO(buf));
ESCREVAL(TRECHO_TEXTO(buf, TAMANHO_VETOR(buf), NULL, 0, 1));
// --- formatação verificável (sem inspeção de formato pelo compilador)
ESCREVAL(FORMATA_TEXTO(buf, TAMANHO_VETOR(buf), "%d-%s", 42, "xy"));
ESCREVA_TEXTO(buf); ESCREVA_LINHA();
ESCREVAL(FORMATA_TEXTO(dest, TAMANHO_VETOR(dest), "%s", "longo"));
ESCREVAL(TAMANHO_TEXTO(dest));
TEXTO formato = "<%d>";
ESCREVAL(FORMATA_TEXTO(dest, TAMANHO_VETOR(dest), formato, 7));
ESCREVA_TEXTO(dest); ESCREVA_LINHA();
// --- comparação normalizada e texto vazio (NULL conta como vazio)
ESCREVAL(COMPARA_TEXTO("a", "b"));
ESCREVAL(COMPARA_TEXTO("b", "a"));
ESCREVAL(COMPARA_TEXTO("a", "a"));
ESCREVAL(COMPARA_TEXTO(NULL, ""));
ESCREVAL(TEXTO_VAZIO(""));
ESCREVAL(TEXTO_VAZIO(NULL));
ESCREVAL(TEXTO_VAZIO("x"));
// --- origem NULL nunca é desreferenciada
ESCREVAL(COPIA_TEXTO(buf, TAMANHO_VETOR(buf), NULL));
ESCREVAL(TAMANHO_TEXTO(buf));
// --- origem e destino podem ser o mesmo buffer (as cópias usam memmove)
COPIA_TEXTO(buf, TAMANHO_VETOR(buf), "abcdef");
ESCREVAL(TRECHO_TEXTO(buf, TAMANHO_VETOR(buf), buf, 2, 3));
ESCREVA_TEXTO(buf); ESCREVA_LINHA(); // cde
ESCREVAL(ACRESCENTA_TEXTO(buf, TAMANHO_VETOR(buf), buf)); // "cde"+"cde"
ESCREVA_TEXTO(buf); ESCREVA_LINHA(); // cdecde
ESCREVAL(ACRESCENTA_TEXTO(buf, 6, buf)); // nao cabe em 6: falha
ESCREVAL(TAMANHO_TEXTO(buf));
FIM
tests/casos/09_tipos_expr/t12_leia_numeros/programa.c
Contexto: t12_leia_numeros. Linhas: 9, 11, 16, 18, 22, 24, 30, 36, 42, 46, 48. Tipo de evidência: código; via ESCREVAL.
Linhas 7–26 · abrir contexto
SE LEIA_INTEIRO(n) ENTAO
ESCREVAL(n);
SENAO
ESCREVAL("inteiro 1 falhou");
FIM_SE
// a linha inválida é consumida: a próxima leitura começa na linha seguinte
SE LEIA_INTEIRO(n) ENTAO
ESCREVAL(n);
SENAO
ESCREVAL("inteiro 2 falhou");
FIM_SE
SE LEIA_INTEIRO(n) ENTAO
ESCREVAL(n);
SENAO
ESCREVAL("inteiro 3 falhou");
FIM_SE
Linhas 28–32 · abrir contexto
ESCREVA_FMT("%.1f\n", r);
SENAO
ESCREVAL("real 1 falhou");
FIM_SE
Linhas 34–38 · abrir contexto
ESCREVA_FMT("%.1f\n", r);
SENAO
ESCREVAL("real 2 falhou");
FIM_SE
Linhas 40–50 · abrir contexto
ESCREVA_FMT("%.1f\n", r);
SENAO
ESCREVAL("real 3 falhou");
FIM_SE
SE LEIA_INTEIRO(n) ENTAO
ESCREVAL(n);
SENAO
ESCREVAL("inteiro 4 falhou");
FIM_SE
FIM
tests/casos/09_tipos_expr/t13_extensoes/programa.c
Contexto: t13_extensoes. Linhas: 12, 13, 14, 15, 18, 19, 20, 21, 22. Tipo de evidência: código; via ESCREVAL.
Linhas 10–23 · abrir contexto
INTEIRO r = 0;
ESCREVAL(SOMA_SEGURA(2, 3, &r));
ESCREVAL(r);
ESCREVAL(SUBTRAI_SEGURA(2, 3, &r));
ESCREVAL(r);
// estouro: devolve FALSO e o resultado não deve ser usado
ESCREVAL(SOMA_SEGURA(MAXIMO_INTEIRO, 1, &r));
ESCREVAL(SUBTRAI_SEGURA(MINIMO_INTEIRO, 1, &r));
ESCREVAL(MULTIPLICA_SEGURA(1000000, 1000000, &r));
ESCREVAL(MULTIPLICA_SEGURA(3, 4, &r));
ESCREVAL(r);
FIM
tests/casos/09_tipos_expr/t14_propriedades/programa.c
Contexto: t14_propriedades. Linhas: 32, 33, 34, 35, 36, 37, 38, 41, 42, 45, 46, 48. Tipo de evidência: código; via ESCREVAL.
Linhas 30–49 · abrir contexto
INICIO
// larguras observáveis (imprimem 1)
ESCREVAL(BITS_DE(INTEIRO) >= 16);
ESCREVAL(BITS_DE(NATURAL) == BITS_DE(INTEIRO));
ESCREVAL(BITS_DE(REAL) >= 32);
ESCREVAL(sizeof(INTEIRO_CURTO) <= sizeof(INTEIRO));
ESCREVAL(sizeof(INTEIRO) <= sizeof(INTEIRO_LONGO));
ESCREVAL(sizeof(REAL_CURTO) <= sizeof(REAL));
ESCREVAL(sizeof(REAL) <= sizeof(REAL_LONGO));
// o sinal vem do tipo: tipos com sinal têm negativos, naturais não
ESCREVAL((INTEIRO) -1 < 0);
ESCREVAL((NATURAL) -1 > 0);
// a promoção existe: CARACTERE e LOGICO viram INTEIRO em aritmética
ESCREVAL(_Generic((CARACTERE) 'a' + 1, int: 1, default: 0));
ESCREVAL(_Generic((LOGICO) 1 + 1, int: 1, default: 0));
ESCREVAL("propriedades ok");
FIM
tests/casos/09_tipos_expr/t15_leia_tipos/programa.c
Contexto: t15_leia_tipos. Linhas: 28, 29, 30, 31, 32, 33. Tipo de evidência: código; via ESCREVAL.
Linhas 26–34 · abrir contexto
LEIA(f);
ESCREVA("NATURAL8 "); ESCREVAL(a);
ESCREVA("NATURAL16 "); ESCREVAL(b);
ESCREVA("NATURAL_CURTO "); ESCREVAL(c);
ESCREVA("REAL_CURTO "); ESCREVAL(d);
ESCREVA("REAL_LONGO "); ESCREVAL(e);
ESCREVA("CARACTERE "); ESCREVAL(f);
FIM
tests/casos/12_negativos_m1/t01_se_com_chaves/programa.c
Contexto: t01_se_com_chaves. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–7 · abrir contexto
INICIO
SE (1) {
ESCREVAL("x");
}
FIM
tests/casos/12_negativos_m1/t02_senao_se/programa.c
Contexto: t02_senao_se. Linhas: 5, 7. Tipo de evidência: código; via ESCREVAL.
Linhas 3–9 · abrir contexto
INICIO
SE 1 ENTAO
ESCREVAL("a");
SENAO SE 2 ENTAO
ESCREVAL("b");
FIM_SE
FIM
tests/casos/12_negativos_m1/t03_bloco_sem_fim/programa.c
Contexto: t03_bloco_sem_fim. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–6 · abrir contexto
INICIO
SE 1 ENTAO
ESCREVAL("a");
FIM
tests/casos/12_negativos_m1/t04_fim_trocado/programa.c
Contexto: t04_fim_trocado. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–7 · abrir contexto
INICIO
ENQUANTO 1 FACA
ESCREVAL("a");
FIM_SE
FIM
tests/casos/12_negativos_m1/t05_para_sem_de/programa.c
Contexto: t05_para_sem_de. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–7 · abrir contexto
INICIO
PARA i ATE 10 FACA
ESCREVAL(i);
FIM_PARA
FIM
tests/casos/12_negativos_m1/t06_para_sem_ate/programa.c
Contexto: t06_para_sem_ate. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–7 · abrir contexto
INICIO
PARA i DE 1 FACA
ESCREVAL(i);
FIM_PARA
FIM
tests/casos/12_negativos_m1/t08_par_unico/programa.c
Contexto: t08_par_unico. Linhas: 5. Tipo de evidência: código; via ESCREVAL.
Linhas 3–6 · abrir contexto
INICIO
SE 1 ENTAO
ESCREVAL("a");
FIM_SE
tests/casos/12_negativos_m1/t09_registro_com_chaves/programa.c
Contexto: t09_registro_com_chaves. Linhas: 10. Tipo de evidência: código; via ESCREVAL.
Linhas 8–11 · abrir contexto
INICIO
ESCREVAL(1);
FIM
tests/casos/12_negativos_m1/t10_enumeracao_com_chaves/programa.c
Contexto: t10_enumeracao_com_chaves. Linhas: 9. Tipo de evidência: código; via ESCREVAL.
Linhas 7–10 · abrir contexto
INICIO
ESCREVAL(VERMELHO);
FIM
tests/casos/12_negativos_m1/t11_igual_infixo/programa.c
Contexto: t11_igual_infixo. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–9 · abrir contexto
INTEIRO x = 2;
SE x IGUAL 2 ENTAO
ESCREVAL("dois");
FIM_SE
FIM
tests/casos/12_negativos_m1/t12_passo_zero_literal/programa.c
Contexto: t12_passo_zero_literal. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–9 · abrir contexto
INTEIRO i = 0;
PARA i DE 1 ATE 3 PASSO 0 FACA
ESCREVAL(i);
FIM_PARA
FIM
tests/casos/12_negativos_m1/t13_senao_sem_se/programa.c
Contexto: t13_senao_sem_se. Linhas: 5, 7. Tipo de evidência: código; via ESCREVAL.
Linhas 3–9 · abrir contexto
// SENAO precisa de um SE aberto logo antes do bloco.
INICIO
ESCREVAL("x");
SENAO
ESCREVAL("y");
FIM_SE
FIM
tests/casos/12_negativos_m1/t14_ate_que_sem_ponto_e_virgula/programa.c
Contexto: t14_ate_que_sem_ponto_e_virgula. Linhas: 9. Tipo de evidência: código; via ESCREVAL.
Linhas 7–10 · abrir contexto
a = a + 1;
ATE_QUE(a > 3)
ESCREVAL(a);
FIM
tests/casos/13_avisos/w01_atribuicao_em_condicao/programa.c
Contexto: w01_atribuicao_em_condicao. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–9 · abrir contexto
INTEIRO x = 0;
SE x = 1 ENTAO
ESCREVAL("um");
FIM_SE
FIM
tests/casos/13_avisos/w02_sem_inicializador/programa.c
Contexto: w02_sem_inicializador. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–8 · abrir contexto
INTEIRO contador;
contador = 0;
ESCREVAL(contador);
FIM
tests/casos/13_avisos/w03_condicao_literal/programa.c
Contexto: w03_condicao_literal. Linhas: 6. Tipo de evidência: código; via ESCREVAL.
Linhas 4–8 · abrir contexto
INICIO
SE 1 ENTAO
ESCREVAL("sempre");
FIM_SE
FIM
tests/casos/13_avisos/w05_nome_todo_maiusculo/programa.c
Contexto: w05_nome_todo_maiusculo. Linhas: 7. Tipo de evidência: código; via ESCREVAL.
Linhas 5–8 · abrir contexto
INTEIRO TOTAL = 0;
TOTAL = TOTAL + 1;
ESCREVAL(TOTAL);
FIM
tests/casos/13_avisos/w06_tamanho_de_parametro/programa.c
Contexto: w06_tamanho_de_parametro. Linhas: 5, 6. Tipo de evidência: código; via ESCREVAL.
Linhas 3–8 · abrir contexto
// W-06: TAMANHO_VETOR de parametro mede o ponteiro, nao o vetor (C-18)
PROCEDIMENTO mostra(INTEIRO v[], INTEIRO n) {
ESCREVAL(TAMANHO_VETOR(v));
ESCREVAL(n);
}
tests/casos/13_avisos/w07_tamanho_constante/programa.c
Contexto: w07_tamanho_constante. Linhas: 9. Tipo de evidência: código; via ESCREVAL.
Linhas 7–10 · abrir contexto
VETOR(INTEIRO, v, k_n);
v[0] = 1;
ESCREVAL(v[0]);
FIM
tests/portabilidade/cabecalhos_tu3.c
Contexto: cabecalhos_tu3.c. Linhas: 14. Tipo de evidência: condicional; via ESCREVAL.
Linhas 12–16 · abrir contexto
# error "nome curto SE nao deveria existir com BG_SEM_APELIDOS"
#endif
#ifdef ESCREVAL
# error "nome curto ESCREVAL nao deveria existir com BG_SEM_APELIDOS"
#endif
tests/portabilidade/controle.c
Contexto: controle.c. Linhas: 209. Tipo de evidência: código; via ESCREVAL.
Linhas 207–210 · abrir contexto
AFIRME(total == 63, "dois ENQUANTO com SE/SENAO");
ESCREVAL("controle: ok");
FIM
tests/portabilidade/entrada.c
Contexto: entrada.c. Linhas: 77. Tipo de evidência: código; via ESCREVAL.
Linhas 75–78 · abrir contexto
ESCREVA_FMT("14 n=%d\n", n);
ESCREVAL("entrada: ok");
FIM
tests/portabilidade/precedencia.c
Contexto: precedencia.c. Linhas: 76, 79, 98. Tipo de evidência: código; via ESCREVAL.
Linhas 74–81 · abrir contexto
chamadas = 0;
SE FALSO E sempre_verdadeiro() ENTAO
ESCREVAL("nunca");
FIM_SE
SE VERDADEIRO OU sempre_verdadeiro() ENTAO
ESCREVAL("");
FIM_SE
AFIRME(chamadas == 0, "E/OU fazem curto-circuito");
Linhas 96–99 · abrir contexto
AFIRME((x E y) == FALSO, "E devolve 0/1");
ESCREVAL("precedencia: ok");
FIM
tests/run.sh
Contexto: run.sh. Linhas: 160, 162, 205, 221. Tipo de evidência: código; via BG_ESCREVAL, ESCREVAL.
Linhas 158–164 · abrir contexto
#include <basicgol.h>
BG_INICIO
BG_ESCREVAL("prefixado ok");
BG_SE 1 BG_ENTAO
BG_ESCREVAL("se ok");
BG_FIM_SE
BG_FIM
Linhas 203–207 · abrir contexto
#ifdef BG_TEM_EXTENSOES
#error "BG_TEM_EXTENSOES nao deveria existir sem BG_USAR_EXTENSOES"
#endif
#ifdef SOMA_SEGURA
#error "SOMA_SEGURA nao deveria existir sem BG_USAR_EXTENSOES"
Linhas 219–223 · abrir contexto
#include <basicgol.h>
_Static_assert(BG_VERSAO_MINIMA(1, 0), "exige 1.0");
INICIO
ESCREVA(BG_VERSAO_MAIOR); ESCREVA("."); ESCREVA(BG_VERSAO_MENOR);
ESCREVA("."); ESCREVAL(BG_VERSAO_CORRECAO);
tests/run.sh · heredoc na linha 157
Contexto: C incorporado no runner (linha 157). Linhas: 160, 162. Tipo de evidência: código; via BG_ESCREVAL.
Linhas 158–164 · abrir contexto
#include <basicgol.h>
BG_INICIO
BG_ESCREVAL("prefixado ok");
BG_SE 1 BG_ENTAO
BG_ESCREVAL("se ok");
BG_FIM_SE
BG_FIM
tests/run.sh · heredoc na linha 174
Contexto: C incorporado no runner (linha 174). Linhas: 179. Tipo de evidência: condicional; via ESCREVAL.
Linhas 177–181 · abrir contexto
#error "nome curto SE nao deveria existir"
#endif
#ifdef ESCREVAL
#error "nome curto ESCREVAL nao deveria existir"
#endif
tests/run.sh · heredoc na linha 219
Contexto: C incorporado no runner (linha 219). Linhas: 223. Tipo de evidência: código; via ESCREVAL.
Linhas 221–224 · abrir contexto
INICIO
ESCREVA(BG_VERSAO_MAIOR); ESCREVA("."); ESCREVA(BG_VERSAO_MENOR);
ESCREVA("."); ESCREVAL(BG_VERSAO_CORRECAO);
FIM
tests/run.sh · heredoc na linha 235
Contexto: C incorporado no runner (linha 235). Linhas: 242, 244. Tipo de evidência: código; via ESCREVAL.
Linhas 240–245 · abrir contexto
a = ABS(++i); /* uma avaliacao: i=1, a=1 */
b = MINIMO(++i, 100); /* uma avaliacao: i=2, b=2 */
ESCREVA(i); ESCREVA(" "); ESCREVA(a); ESCREVA(" "); ESCREVAL(b);
i = 0;
ESCREVA(i++); ESCREVA(" "); ESCREVAL(i); /* imprime 0 e depois 1 */
FIM
tests/run.sh · heredoc na linha 256
Contexto: C incorporado no runner (linha 256). Linhas: 264. Tipo de evidência: código; via ESCREVAL.
Linhas 262–265 · abrir contexto
x = OU_EXCLUSIVO(++i, 0); /* uma avaliacao: i=2 */
ESCREVA(i); ESCREVA(" "); ESCREVA(q); ESCREVA(" ");
ESCREVAL(x);
FIM
tests/run.sh · heredoc na linha 385
Contexto: C incorporado no runner (linha 385). Linhas: 397. Tipo de evidência: código; via ESCREVAL.
Linhas 395–398 · abrir contexto
FIM_SE
FIM_ENQUANTO
ESCREVAL(n);
FIM
tests/run.sh · heredoc na linha 423
Contexto: C incorporado no runner (linha 423). Linhas: 426. Tipo de evidência: código; via ESCREVAL.
Linhas 424–426 · abrir contexto
INICIO
SE 1 ENTAO
ESCREVAL("sem fim");
tests/run.sh · heredoc na linha 482
Contexto: C incorporado no runner (linha 482). Linhas: 486. Tipo de evidência: código; via ESCREVAL.
Linhas 484–488 · abrir contexto
INTEIRO x = 0;
SE x = 1 ENTAO
ESCREVAL("a");
FIM_SE
FIM
tests/run.sh · heredoc na linha 505
Contexto: C incorporado no runner (linha 505). Linhas: 510. Tipo de evidência: código; via ESCREVAL.
Linhas 508–511 · abrir contexto
VETOR(INTEIRO, v, k_n);
v[0] = 1;
ESCREVAL(v[0]);
FIM
tests/run_portabilidade.sh
Contexto: run_portabilidade.sh. Linhas: 187, 192, 193. Tipo de evidência: código; via ESCREVAL.
Linhas 185–195 · abrir contexto
/* uso real: uma macro de cada família, para o compilador analisar de verdade */
INICIO
INTEIRO i = 0;
LOGICO b = VERDADEIRO;
TEXTO_FIXO(buf, 16);
SE b E (i < 1) ENTAO
ESCREVAL("x");
FIM_SE
PARA (i, 0, 1) {
ESCREVA(i);
tests/run_portabilidade.sh · heredoc na linha 183
Contexto: C incorporado no runner (linha 183). Linhas: 192, 197, 198. Tipo de evidência: código; via ESCREVAL.
Linhas 190–199 · abrir contexto
SE b E (i < 1) ENTAO
ESCREVAL("x");
FIM_SE
PARA (i, 0, 1) {
ESCREVA(i);
}
ESCREVAL(ABS(-1) + MINIMO(1, 2) + DIVIDE(4, 2));
ESCREVAL(LEIA_TEXTO(buf, TAMANHO_DE(buf)));
FIM
Evidência indireta
Estes símbolos chamam/encaminham para este nome. As referências deles ajudam a rastrear o caminho, mas não substituem um teste específico deste símbolo.
ESCREVAL→ tests/casos/02_basico/b01_ola/programa.c, tests/casos/02_basico/b02_aritmetica/programa.c, tests/casos/02_basico/b03_real/programa.c, tests/casos/02_basico/b04_tipos/programa.c, tests/casos/02_basico/b05_caractere/programa.c …
Compiladores, padrão C e sistema operacional
Condições que envolvem a definição:
defined(BASICGOL_H)(fonte)
A matriz histórica distingue executado, compilado, avaliado e não testado. Consulte a matriz, os compiladores e os logs atuais dos workflows antes de chamar um alvo de suportado.
Checklist de integração
- Compile com C11: o cabeçalho seleciona formatos e divisões com
_Generic, e C99/C89 são recusados com mensagem explícita. - A forma curta
ESCREVALe a forma canônicaBG_ESCREVALsão a mesma macro; escolha uma por arquivo para não misturar estilos. - Rode
make test(oumake test-bibliotecapara a biblioteca) antes de integrar.
make
cc -std=c11 -Wall -Wextra -Wformat=2 -I include programa.c \
build/libbasicgol.a -lm -o programa
Perguntas frequentes
Perguntas reunidas a partir da definição, do contrato editorial e dos testes de BG_ESCREVAL. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.
Em uma frase, o que BG_ESCREVAL faz?
Imprime um valor e acrescenta newline.
Para que exatamente BG_ESCREVAL expande?
O pré-processador substitui BG_ESCREVAL pelo texto abaixo, sem criar função nem avaliar argumentos por conta própria.
Parâmetros formais: x.
(printf(BG_FMT(x), (x)), fputc('\n', stdout))
Como BG_ESCREVAL aparece em código real deste repositório?
Uso extraído de tests/casos/02_basico/b01_ola/programa.c:3, com as linhas vizinhas preservadas:
INICIO
ESCREVAL("Ola, mundo!");
FIM
Onde BG_ESCREVAL é exercitado nos testes?
Há 502 ocorrência(s) em 137 arquivo(s): tests/casos/02_basico/b01_ola/programa.c, tests/casos/02_basico/b02_aritmetica/programa.c, tests/casos/02_basico/b03_real/programa.c, tests/casos/02_basico/b04_tipos/programa.c, tests/casos/02_basico/b05_caractere/programa.c …. Os links da seção de evidência apontam para a linha exata; uma menção não prova que todos os ramos foram executados.
BG_ESCREVAL depende de compilador, padrão C ou sistema operacional?
BG_ESCREVAL exige C11 como o restante da linguagem; largura de tipo, libc e CRT continuam sendo os do alvo.
Quais armadilhas preciso evitar ao usar BG_ESCREVAL?
O contrato editorial registra: “Windows pode representar LF como CRLF no stdout em modo texto.”