BG_E · E
Gerada por tools/gerar_documentacao.py. Definição: include/basicgol.h:163.
--- operadores por palavra ---
Tipo: macro de objeto · Módulo/categoria: Operadores e lógica.
Nomes equivalentes: E. Os testes de qualquer um desses nomes são reunidos nesta página.
Assinatura e expansão
#define BG_E &&
Corpo da macro:
&&
Como funciona
--- operadores por palavra ---
Como este símbolo aparece nos testes
70 ocorrência(s) em 14 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/b07_tipos_e_utilitarios/programa.c
Contexto: b07_tipos_e_utilitarios. Linhas: 30. Tipo de evidência: código; via E.
Linhas 28–32 · abrir contexto
INICIA_SORTEIO(7);
INTEIRO s = SORTEIA(100);
SE s >= 0 E s < 100 ENTAO
ESCREVAL("sorteio na faixa");
SENAO
tests/casos/03_controle/c21_laco_com_condicoes/programa.c
Contexto: c21_laco_com_condicoes. Linhas: 13. Tipo de evidência: código; via E.
Linhas 11–15 · abrir contexto
PARE;
FIM_SE
SE i MOD 7 == 0 E i > 10 ENTAO
achados = achados + 1;
FIM_SE
tests/casos/08_aplicacao/app_acervo/acervo.c
Contexto: app_acervo. Linhas: 139, 144, 149, 154, 159. Tipo de evidência: código; via E.
Linhas 137–161 · abrir contexto
FUNCAO INTEIRO acervo_id(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].id;
}
FUNCAO TEXTO acervo_titulo(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].titulo;
}
FUNCAO TEXTO acervo_autor(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].autor;
}
FUNCAO INTEIRO acervo_ano(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].ano;
}
FUNCAO Situacao acervo_situacao(INTEIRO i) {
AFIRME(i >= 0 E i < total, "indice fora do acervo");
RETORNE acervo[i].situacao;
}
tests/casos/08_aplicacao/app_acervo/principal.c
Contexto: app_acervo. Linhas: 11. Tipo de evidência: código; via E.
Linhas 9–13 · abrir contexto
INTEIRO valor = -1;
ENQUANTO i < TAMANHO_TEXTO(s) FACA
SE s[i] >= '0' E s[i] <= '9' ENTAO
SE valor < 0 ENTAO
valor = 0;
tests/casos/08_aplicacao/app_acervo/relatorio.c
Contexto: app_acervo. Linhas: 38. Tipo de evidência: código; via E.
Linhas 36–40 · abrir contexto
TEXTO_FIXO(parcial, 64);
TEXTO_FIXO(rotulo, 64);
SE JUNTA_TEXTO(parcial, 64, acervo_titulo(0), " - ") E
JUNTA_TEXTO(rotulo, 64, parcial, acervo_autor(0)) ENTAO
ESCREVA_FMT("primeiro da lista: %s\n", rotulo);
tests/casos/09_tipos_expr/t04_logico/programa.c
Contexto: t04_logico. Linhas: 29, 38, 39. Tipo de evidência: código; via E.
Linhas 27–31 · abrir contexto
// 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
Linhas 36–41 · abrir contexto
// 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)
tests/casos/09_tipos_expr/t05_precedencia/programa.c
Contexto: t05_precedencia. Linhas: 17, 18, 19, 20. Tipo de evidência: código; via E.
Linhas 15–22 · abrir contexto
// 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
tests/portabilidade/controle.c
Contexto: controle.c. Linhas: 96, 180. Tipo de evidência: código; via E.
Linhas 94–98 · abrir contexto
total = total + i;
ATE_QUE(NAO (i < 3));
AFIRME(total == 6 E i == 3, "ATE_QUE com NAO");
/* ------------------------------------------- ESCOLHA e PARE */
Linhas 178–182 · abrir contexto
FIM_SE
}
AFIRME(achou E alvo == 11, "saída de dois laços com bandeira");
/* ------------------------------------ PROSSIGA em PARA (avança i) */
tests/portabilidade/fronteira.c
Contexto: fronteira.c. Linhas: 41, 137, 138, 139, 140, 147, 151, 152, 160, 161, 164, 172, 173, 174, 187, 188, 189, 193, 226, 227, 228, 229, 232, 237, 238, 240, 241, 244, 245, 247, 248, 255, 256, 265, 283. Tipo de evidência: código; via E.
Linhas 39–43 · abrir contexto
dst[0] = 'x'; dst[1] = 'x'; dst[2] = 'x'; dst[3] = 'x';
EXIGE(bg_copia_texto(dst, 4, "abc") == true); /* 3 + NUL = 4: cabe */
EXIGE(dst[0] == 'a' E dst[1] == 'b' E dst[2] == 'c' E dst[3] == '\0');
EXIGE(bg_copia_texto(dst, 3, "abc") == false); /* 1 byte a menos */
EXIGE(dst[0] == '\0');
Linhas 135–142 · abrir contexto
int i = 999;
EXIGE(bg_texto_para_inteiro("42", &i) == true E i == 42);
EXIGE(bg_texto_para_inteiro(" -42 ", &i) == true E i == -42);
EXIGE(bg_texto_para_inteiro("+42", &i) == true E i == 42);
EXIGE(bg_texto_para_inteiro("0", &i) == true E i == 0);
EXIGE(bg_texto_para_inteiro("", &i) == false);
EXIGE(bg_texto_para_inteiro(" ", &i) == false);
Linhas 145–154 · abrir contexto
EXIGE(bg_texto_para_inteiro("1e3", &i) == false);
i = 7;
EXIGE(bg_texto_para_inteiro("nao", &i) == false E i == 7);
EXIGE(bg_texto_para_inteiro(NULL, &i) == false);
EXIGE(bg_texto_para_inteiro("1", NULL) == false);
EXIGE(bg_texto_para_inteiro("2147483647", &i) == true E i == 2147483647);
EXIGE(bg_texto_para_inteiro("-2147483648", &i) == true E i == -2147483647 - 1);
EXIGE(bg_texto_para_inteiro("2147483648", &i) == false); /* +1 */
EXIGE(bg_texto_para_inteiro("-2147483649", &i) == false); /* -1 */
Linhas 158–166 · abrir contexto
unsigned u = 999u;
EXIGE(bg_texto_para_natural("0", &u) == true E u == 0u);
EXIGE(bg_texto_para_natural("4294967295", &u) == true E u == 4294967295u);
EXIGE(bg_texto_para_natural("4294967296", &u) == false); /* +1 */
EXIGE(bg_texto_para_natural("-1", &u) == false); /* sinal */
EXIGE(bg_texto_para_natural(" 7 ", &u) == true E u == 7u);
EXIGE(bg_texto_para_natural("7.0", &u) == false);
}
Linhas 170–176 · abrir contexto
double d = -1.0;
EXIGE(bg_texto_para_real("3.5", &d) == true E d == 3.5);
EXIGE(bg_texto_para_real(" 3.5 ", &d) == true E d == 3.5);
EXIGE(bg_texto_para_real("-0.25", &d) == true E d == -0.25);
EXIGE(bg_texto_para_real("abc", &d) == false);
EXIGE(bg_texto_para_real("3,5", &d) == false); /* locale C (D-17) */
Linhas 185–195 · abrir contexto
int i = 0;
EXIGE(bg_numero_para_inteiro(3.7, &i) == true E i == 3);
EXIGE(bg_numero_para_inteiro(-3.7, &i) == true E i == -3); /* trunca */
EXIGE(bg_numero_para_inteiro(2147483647.0, &i) == true E i == 2147483647);
EXIGE(bg_numero_para_inteiro(2147483648.0, &i) == false); /* +1 */
EXIGE(bg_numero_para_inteiro(-2147483649.0, &i) == false);
EXIGE(bg_numero_para_inteiro(1.0 / 0.0 * 0.0, &i) == false); /* NaN */
EXIGE(bg_numero_para_inteiro(0.0, &i) == true E i == 0);
EXIGE(bg_numero_para_inteiro(1.0, NULL) == false);
}
4 outros blocos de contexto: use os links de linha e o JSON de inventário.
tests/portabilidade/precedencia.c
Contexto: precedencia.c. Linhas: 44, 45, 46, 47, 48, 49, 70, 84, 85, 86, 87, 91, 96. Tipo de evidência: código; via E.
Linhas 42–51 · abrir contexto
/* -------------------------------------------------------- lógica */
AFIRME((NAO x E y) == FALSO, "NAO liga mais forte que E");
AFIRME((NAO (x E y)) == VERDADEIRO, "NAO (x E y)");
AFIRME((x OU (y E y)) == VERDADEIRO, "E liga mais forte que OU");
AFIRME(((x E y) OU x) == VERDADEIRO, "(x E y) OU x");
AFIRME((((NAO y) E x) OU y) == VERDADEIRO, "((NAO y) E x) OU y");
AFIRME(((a < b) E (b < c)) == VERDADEIRO, "comparações com E");
AFIRME((IGUAL(a + b, 5)) == VERDADEIRO, "IGUAL com expressão");
AFIRME((DIFERENTE(soma(a, b), a + b)) == FALSO, "DIFERENTE com chamada");
Linhas 68–72 · abrir contexto
AFIRME(BITS_DE(CARACTERE) == 8, "BITS_DE(CARACTERE)");
AFIRME(TAMANHO_DE(INTEIRO8) == 1, "TAMANHO_DE(INTEIRO8)");
AFIRME(TEXTOS_IGUAIS("ab", "ab") E (NAO TEXTOS_DIFERENTES("ab", "ab")),
"TEXTOS_IGUAIS/DIFERENTES");
Linhas 82–98 · abrir contexto
i = 0;
AFIRME((ABS(++i) == 1) E (i == 1), "ABS avalia o argumento uma vez");
AFIRME((MINIMO(++i, 100) == 2) E (i == 2), "MINIMO avalia cada argumento uma vez");
AFIRME((MAXIMO(++i, 0) == 3) E (i == 3), "MAXIMO avalia cada argumento uma vez");
AFIRME((DIVIDE(++i, 1) == 4) E (i == 4), "DIVIDE avalia cada argumento uma vez");
/* ------------------------------- atribuição e precedência mista */
a = b = 3;
AFIRME((a == 3) E (b == 3), "atribuição encadeada associa à direita");
a += 2 * 3;
AFIRME(a == 9, "+= com produto à direita");
a = (b > 2) ? 10 : 20;
AFIRME(a == 10, "ternário");
AFIRME((x E y) == FALSO, "E devolve 0/1");
ESCREVAL("precedencia: ok");
tests/run.sh
Contexto: run.sh. Linhas: 99. Tipo de evidência: código; via E.
Linhas 97–101 · abrir contexto
# -dM -E normaliza espaços, então a comparação é textual e estável.
printf '#include <basicgol.h>\n' > "$T_TMP/dm.c"
if $T_CC -std=c11 -I "$T_INCLUDE" -dM -E "$T_TMP/dm.c" > "$T_TMP/dm.txt" 2> "$T_TMP/e"; then
divergentes=""
while IFS= read -r linha; do
tests/run_msvc.sh
Contexto: confere_saida. Linhas: 99. Tipo de evidência: código; via E.
Linhas 97–101 · abrir contexto
# so as linhas que mudaram: GitHub exibe ~10 annotations por
# passo; um dump inteiro esconde o diff de verdade
grep -E '^[+-]' "$TMP/diff" | grep -v -E '^(\+\+\+|---)' \
| while IFS= read -r linha; do
printf '::error::%s\n' "$linha"
tests/run_portabilidade.sh
Contexto: run_portabilidade.sh. Linhas: 186. Tipo de evidência: código; via E.
Linhas 184–188 · abrir contexto
/* uso real: uma macro de cada família, para o compilador analisar de verdade */
INICIO
INTEIRO i = 0;
LOGICO b = VERDADEIRO;
tests/run_portabilidade.sh · heredoc na linha 183
Contexto: C incorporado no runner (linha 183). Linhas: 191. Tipo de evidência: código; via E.
Linhas 189–193 · abrir contexto
TEXTO_FIXO(buf, 16);
SE b E (i < 1) ENTAO
ESCREVAL("x");
FIM_SE
Também aparece na tabela de expansão conferida por cc -E -dM: L35.
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.
E→ tests/casos/02_basico/b07_tipos_e_utilitarios/programa.c, tests/casos/03_controle/c21_laco_com_condicoes/programa.c, tests/casos/08_aplicacao/app_acervo/acervo.c, tests/casos/08_aplicacao/app_acervo/principal.c, tests/casos/08_aplicacao/app_acervo/relatorio.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
Ee a forma canônicaBG_Esã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_E. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.
Em uma frase, o que BG_E faz?
--- operadores por palavra ---
Para que exatamente BG_E expande?
O pré-processador substitui BG_E pelo texto abaixo, sem criar função nem avaliar argumentos por conta própria.
&&
Como BG_E aparece em código real deste repositório?
Uso extraído de tests/casos/02_basico/b07_tipos_e_utilitarios/programa.c:28, com as linhas vizinhas preservadas:
INICIA_SORTEIO(7);
INTEIRO s = SORTEIA(100);
SE s >= 0 E s < 100 ENTAO
ESCREVAL("sorteio na faixa");
SENAO
Onde BG_E é exercitado nos testes?
Há 70 ocorrência(s) em 14 arquivo(s): tests/casos/02_basico/b07_tipos_e_utilitarios/programa.c, tests/casos/03_controle/c21_laco_com_condicoes/programa.c, tests/casos/08_aplicacao/app_acervo/acervo.c, tests/casos/08_aplicacao/app_acervo/principal.c, tests/casos/08_aplicacao/app_acervo/relatorio.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_E depende de compilador, padrão C ou sistema operacional?
BG_E exige C11 como o restante da linguagem; largura de tipo, libc e CRT continuam sendo os do alvo.
O que acontece em caso de falha ou uso inválido?
Não há ressalva editorial específica para este nome. O comportamento em falha é o do corpo/expansão mostrado acima; não invente validação que o fonte não faz.