emite_identificador
Gerada por tools/gerar_documentacao.py. Definição: tools/basicgolc.c:1431.
Núcleo de tradução de palavras-chave, blocos e açúcar sintático M1.
Tipo: função C · Visibilidade: interna (static) · Arquivo: tools/basicgolc.c.
Assinatura e expansão
static void emite_identificador(Estado *e, const Lista *l, int *pi)
Parâmetros formais: Estado *e, const Lista *l, int *pi.
Como funciona
Despacha o token conforme a tabela e o contexto de pilha; emite C para blocos, coleta cabeçalhos/argumentos, converte PARA e ATE e registra diagnósticos. Construtores de valor permanecem prefixados para o cabeçalho.
- Não faz análise de tipos C; erros semânticos continuam com o compilador C.
- A função é extensa: a fonte completa abaixo é a referência normativa desta página.
Comentário do fonte
Emissão de identificador
Implementação completa · 308 linhas
{
const Token *t = &l->itens[*pi];
const char *nome = t->texto;
const Traducao *tr;
int i = *pi;
int prox_token = proximo_significativo(l, i);
/* nome de macro de funcao sem '(' depois: quase sempre "x IGUAL 3" */
if (exige_parenteses(nome)
&& !(prox_token >= 0 && l->itens[prox_token].tipo == TK_PONT
&& strcmp(l->itens[prox_token].texto, "(") == 0)) {
/* ATE, PARA e PARA_PASSO tem formas alternativas (acucar) — ja tratadas acima */
if (!(strcmp(nome, "PARA") == 0 || strcmp(nome, "PARA_PASSO") == 0
|| strcmp(nome, "ATE_QUE") == 0)) {
erro(e, t->linha,
"'%s' e prefixado e exige parenteses: use %s(...) "
"(ou o operador de C equivalente)", nome, nome);
*pi = i;
return;
}
}
/* --- laço contado açucarado: PARA <var> DE <ini> ATE <fim> [PASSO <p>] FACA */
if (strcmp(nome, "PARA") == 0) {
int prox = proximo_significativo(l, i);
if (prox >= 0 && !(l->itens[prox].tipo == TK_PONT
&& strcmp(l->itens[prox].texto, "(") == 0)) {
static const char *fins_ate[] = { "ATE", NULL };
static const char *fins_passo[] = { "PASSO", "FACA", NULL };
Buf var, ini, fim, passo;
int j;
buf_ini(&var); buf_ini(&ini); buf_ini(&fim); buf_ini(&passo);
if (prox < 0 || l->itens[prox].tipo != TK_IDENT) {
erro(e, t->linha, "esperado o nome da variavel de controle depois de PARA");
*pi = i;
return;
}
buf_adiciona(&var, l->itens[prox].texto);
j = proximo_significativo(l, prox);
if (j < 0 || l->itens[j].tipo != TK_IDENT || strcmp(l->itens[j].texto, "DE") != 0) {
erro(e, l->itens[prox].linha,
"esperado 'DE' depois da variavel de controle em 'PARA %s DE ...'",
l->itens[prox].texto);
*pi = i;
return;
}
j = coleta_ate(e, l, j + 1, fins_ate, &ini);
if (j >= l->qtd) {
erro(e, t->linha, "faltou 'ATE' no laco 'PARA %s DE ... ATE ...'", var.dados);
} else {
j = coleta_ate(e, l, j + 1, fins_passo, &fim);
}
if (j < l->qtd && l->itens[j].tipo == TK_IDENT
&& strcmp(l->itens[j].texto, "PASSO") == 0) {
j = coleta_ate(e, l, j + 1, fins_passo, &passo);
}
if (j >= l->qtd || !(l->itens[j].tipo == TK_IDENT
&& strcmp(l->itens[j].texto, "FACA") == 0)) {
erro(e, t->linha, "faltou 'FACA' no fim do cabecalho do 'PARA ... DE ...'");
}
buf_limpa_espacos(&ini);
buf_limpa_espacos(&fim);
buf_limpa_espacos(&passo);
if (passo.tam == 0) {
buf_adiciona(&passo, "1");
}
/* Fase 3: passo literal zero nunca avanca o laco. Com passo
* variavel a mesma situacao vira erro de execucao (bg_passo_zero). */
if (strcmp(passo.dados, "0") == 0) {
erro(e, t->linha,
"'PASSO 0' nunca avanca o laco: use um passo diferente de zero");
}
buf_adiciona(&e->saida, "for (");
buf_adiciona(&e->saida, var.dados);
buf_adiciona(&e->saida, " = (");
buf_adiciona(&e->saida, ini.dados);
buf_adiciona(&e->saida, "); (");
buf_adiciona(&e->saida, passo.dados);
buf_adiciona(&e->saida, ") > 0 ? (");
buf_adiciona(&e->saida, var.dados);
buf_adiciona(&e->saida, " <= (");
buf_adiciona(&e->saida, fim.dados);
buf_adiciona(&e->saida, ")) : ((");
buf_adiciona(&e->saida, passo.dados);
buf_adiciona(&e->saida, ") == 0 ? bg_passo_zero(__FILE__, __LINE__) : (");
buf_adiciona(&e->saida, var.dados);
buf_adiciona(&e->saida, " >= (");
buf_adiciona(&e->saida, fim.dados);
buf_adiciona(&e->saida, "))); ");
buf_adiciona(&e->saida, var.dados);
buf_adiciona(&e->saida, " += (");
buf_adiciona(&e->saida, passo.dados);
buf_adiciona(&e->saida, ")) { ");
empilha(e, BLOCO_PARA, t->linha);
free(var.dados); free(ini.dados); free(fim.dados); free(passo.dados);
*pi = (j < l->qtd) ? j : l->qtd - 1; /* consome FACA */
return;
}
}
/* --- ATE <expr> ; (açúcar do REPITA) --- */
if (strcmp(nome, "ATE") == 0) {
Buf expr;
int k;
int prof = 0;
if (e->topo == 0 || e->pilha[e->topo - 1] != BLOCO_REPITA) {
erro(e, t->linha,
"'ATE' sem 'REPITA': use 'REPITA ... ATE_QUE(cond);' ou abra um REPITA");
*pi = i;
return;
}
buf_ini(&expr);
k = i + 1;
while (k < l->qtd) {
const Token *tk = &l->itens[k];
if (tk->tipo == TK_PONT && strcmp(tk->texto, ";") == 0 && prof == 0) {
break;
}
if (significado(tk->tipo)) {
ajusta_profundidade(tk->texto, &prof);
}
buf_adiciona(&expr, tk->texto);
k++;
}
buf_limpa_espacos(&expr);
buf_adiciona(&e->saida, "} while (!(");
buf_adiciona(&e->saida, expr.dados);
buf_adiciona(&e->saida, "))");
desempilha(e, BLOCO_REPITA, t->linha);
free(expr.dados);
*pi = (k < l->qtd) ? k - 1 : l->qtd - 1; /* o ';' e emitido normal */
return;
}
/* --- palavras-chave de bloco/estrutura --- */
tr = busca_traducao(nome);
if (tr != NULL) {
/* 'SENAO SE' e o erro classico de encadeamento (C-05) */
if (strcmp(nome, "SENAO") == 0) {
int prox = proximo_significativo(l, i);
if (prox >= 0 && l->itens[prox].tipo == TK_IDENT
&& strcmp(l->itens[prox].texto, "SE") == 0) {
/* Regra C-05: o par de palavras e sempre recusado, mesmo quando
* se quer um SE aninhado dentro do SENAO (que o C aceitaria).
* A mensagem diz o que fazer nos dois casos. */
erro(e, t->linha,
"'SENAO SE' nao encadeia: use SENAO_SE (C-05 da especificacao); "
"para um SE dentro do SENAO, escreva antes dele um comando do bloco");
}
}
emite_seguro(&e->saida, tr->c);
if (tr->abre == BLOCO_SE || tr->abre == BLOCO_ENQUANTO) {
static const char *fins_se[] = { "ENTAO", NULL };
static const char *fins_enq[] = { "FACA", NULL };
verifica_cabecalho(e, l, i, (tr->abre == BLOCO_SE)
? (const char *const *) fins_se
: (const char *const *) fins_enq);
} else if (strcmp(nome, "SENAO_SE") == 0) {
static const char *fins[] = { "ENTAO", NULL };
verifica_cabecalho(e, l, i, (const char *const *) fins);
}
if (tr->abre != BLOCO_NENHUM) {
empilha(e, tr->abre, t->linha);
}
if (tr->fecha != BLOCO_NENHUM) {
if (tr->fecha == BLOCO_ENUMERACAO) {
e->dentro_enumeracao = false;
}
desempilha(e, tr->fecha, t->linha);
}
if (em_lista(nome, TIPOS) && tr->abre == BLOCO_NENHUM) {
verifica_w02(e, l, i);
}
if (strcmp(nome, "SENAO") == 0 || strcmp(nome, "SENAO_SE") == 0) {
if (e->topo == 0 || e->pilha[e->topo - 1] != BLOCO_SE) {
erro(e, t->linha, "'%s' sem 'SE' correspondente", nome);
}
}
*pi = i;
return;
}
/* --- blocos que recebem um nome/expressao entre parenteses --- */
if (strcmp(nome, "ESCOLHA") == 0 || strcmp(nome, "REGISTRO") == 0
|| strcmp(nome, "ENUMERACAO") == 0 || strcmp(nome, "FIM_REGISTRO") == 0
|| strcmp(nome, "FIM_ENUMERACAO") == 0) {
Buf dentro;
int fim;
int chave;
buf_ini(&dentro);
fim = captura_parenteses(e, l, i, &dentro);
/* REGISTRO/ENUMERACAO ja emitem as chaves pela macro: um '{' explicito e
* erro, mas e engolido para nao gerar uma cascata de mensagens. */
chave = -1;
if (strcmp(nome, "REGISTRO") == 0 || strcmp(nome, "ENUMERACAO") == 0) {
int depois = proximo_significativo(l, fim);
if (depois >= 0 && l->itens[depois].tipo == TK_PONT
&& strcmp(l->itens[depois].texto, "{") == 0) {
erro(e, l->itens[depois].linha,
"'%s' ja abre o bloco: nao use '{' (va direto para os campos)",
nome);
chave = depois;
}
}
if (strcmp(nome, "ESCOLHA") == 0) {
buf_adiciona(&e->saida, "switch (");
buf_adiciona(&e->saida, dentro.dados);
buf_adiciona(&e->saida, ") {");
empilha(e, BLOCO_ESCOLHA, t->linha);
} else if (strcmp(nome, "REGISTRO") == 0) {
buf_adiciona(&e->saida, "typedef struct ");
buf_adiciona(&e->saida, dentro.dados);
buf_adiciona(&e->saida, " {");
empilha(e, BLOCO_REGISTRO, t->linha);
} else if (strcmp(nome, "ENUMERACAO") == 0) {
buf_adiciona(&e->saida, "typedef enum ");
buf_adiciona(&e->saida, dentro.dados);
buf_adiciona(&e->saida, " {");
empilha(e, BLOCO_ENUMERACAO, t->linha);
e->dentro_enumeracao = true;
} else if (strcmp(nome, "FIM_REGISTRO") == 0) {
buf_adiciona(&e->saida, "} ");
buf_adiciona(&e->saida, dentro.dados);
desempilha(e, BLOCO_REGISTRO, t->linha);
} else {
buf_adiciona(&e->saida, "} ");
buf_adiciona(&e->saida, dentro.dados);
desempilha(e, BLOCO_ENUMERACAO, t->linha);
e->dentro_enumeracao = false;
}
free(dentro.dados);
*pi = (chave >= 0) ? chave : ((fim < l->qtd) ? fim : l->qtd - 1);
return;
}
/* --- construtores de valor: forma prefixada do cabecalho --- */
if (em_lista(nome, VALORES)) {
buf_adiciona(&e->saida, "BG_");
buf_adiciona(&e->saida, nome);
if (strcmp(nome, "VETOR") == 0) {
verifica_w07(e, l, i, "VETOR");
} else if (strcmp(nome, "TEXTO_FIXO") == 0) {
verifica_w07(e, l, i, "TEXTO_FIXO");
} else if (strcmp(nome, "TAMANHO_VETOR") == 0) {
verifica_w06(e, l, i);
} else if (strcmp(nome, "PARA") == 0 || strcmp(nome, "PARA_PASSO") == 0) {
verifica_w04(e, l, i);
}
if (strcmp(nome, "ATE_QUE") == 0) {
desempilha(e, BLOCO_REPITA, t->linha);
/* ATE_QUE(c) expande para "} while (!(c))": sem ';' logo depois
* do ')', o erro so apareceria longe, no compilador C. Fase 3. */
{
Buf cond;
int fim;
int depois;
buf_ini(&cond);
fim = captura_parenteses(e, l, i, &cond);
if (fim < l->qtd) {
depois = proximo_significativo(l, fim);
if (depois < 0 || !(l->itens[depois].tipo == TK_PONT
&& strcmp(l->itens[depois].texto, ";") == 0)) {
erro(e, t->linha,
"'ATE_QUE(cond)' exige ';' depois do ')' (e um do/while)");
}
}
free(cond.dados);
}
}
*pi = i;
return;
}
/* --- identificador comum --- */
if (e->dentro_enumeracao && e->qtd_enumeradores < 256 && !ja_avisado(e, nome)) {
size_t n = strlen(nome);
e->enumeradores[e->qtd_enumeradores] = (char *) malloc(n + 1);
if (e->enumeradores[e->qtd_enumeradores] == NULL) {
bg_morte("sem memoria");
}
memcpy(e->enumeradores[e->qtd_enumeradores], nome, n + 1);
e->qtd_enumeradores++;
}
verifica_w05(e, t);
buf_adiciona(&e->saida, nome);
*pi = i;
}
Nomes internos referenciados: ajusta_profundidade, bg_morte, buf_adiciona, buf_ini, buf_limpa_espacos, busca_traducao, captura_parenteses, coleta_ate, desempilha, em_lista, emite_seguro, empilha, erro, exige_parenteses, ja_avisado, proximo_significativo, significado, verifica_cabecalho, verifica_w02, verifica_w04, verifica_w05, verifica_w06, verifica_w07.
Como este símbolo aparece nos testes
Nenhuma referência direta a este nome foi encontrada nos arquivos de teste. Isso pode ser esperado para guardas de inclusão, configuração ou código exercitado indiretamente; não é uma afirmação de cobertura zero.
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.
Nenhum arquivo de teste foi localizado para os chamadores diretos.
O transpilador é exercitado pela CLI em tests/run.sh, tests/run_portabilidade.sh e tests/fuzz_basicgolc.py. Uma ligação no grafo de chamadores não prova que cada ramo desta função foi coberto.
Compiladores, padrão C e sistema operacional
Nenhum ramo condicional externo foi detectado para este símbolo. A implementação é compartilhada no fonte; isso não certifica compiladores ou sistemas não executados.
- O transpilador abre entrada/saída em modo binário; BG_FORMATO só adiciona atributo printf em GCC/Clang.
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.
Perguntas frequentes
Perguntas reunidas a partir da definição, do contrato editorial e dos testes de emite_identificador. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.
Em uma frase, o que emite_identificador faz?
Núcleo de tradução de palavras-chave, blocos e açúcar sintático M1.
Qual é a assinatura e o tipo de retorno de emite_identificador?
Assinatura extraída de tools/basicgolc.c; visibilidade interna (static).
static void emite_identificador(Estado *e, const Lista *l, int *pi)
Como chamar emite_identificador corretamente?
Nenhum exemplo editorial nem chamada direta em teste foi localizada. A forma de uso é a assinatura acima; os chamadores aparecem na seção de evidência indireta quando existem.
static void emite_identificador(Estado *e, const Lista *l, int *pi)
Por que não há teste direto para emite_identificador?
A busca estática não encontrou o identificador nos arquivos de teste. Isso é esperado para guardas de inclusão, configuração de build e nomes alcançados apenas por chamadores internos. O JSON de cobertura registra a lacuna em vez de convertê-la em aprovação.
emite_identificador depende de compilador, padrão C ou sistema operacional?
emite_identificador é código interno em C: compila com C11 nos alvos exercitados, mas não faz parte da API pública nem da matriz de portabilidade da linguagem.
Quais armadilhas preciso evitar ao usar emite_identificador?
O contrato editorial registra: “Não faz análise de tipos C; erros semânticos continuam com o compilador C.” “A função é extensa: a fonte completa abaixo é a referência normativa desta página.”