Pular para o conteúdo principal

tokeniza

Página gerada do fonte

Gerada por tools/gerar_documentacao.py. Definição: tools/basicgolc.c:247.

Separa a fonte em identificadores, números, literais, pontuação, espaço, comentários e diretivas, preservando linhas.

Tipo: função C · Visibilidade: interna (static) · Arquivo: tools/basicgolc.c.

Assinatura e expansão​

static void tokeniza(const char *src, Lista *l)

Parâmetros formais: const char *src, Lista *l.

Como funciona​

Percorre bytes sem reordenar tokens, trata escapes e delimitadores, acumula texto em tokens alocados e preserva newlines. É a base comum de --checar e da tradução.

Implementação completa · 155 linhas
{
size_t i = 0;
int linha = 1;

while (src[i] != '\0') {
unsigned char c = (unsigned char) src[i];

/* espaços */
if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
size_t ini = i;
while (src[i] == ' ' || src[i] == '\t' || src[i] == '\r' || src[i] == '\n') {
if (src[i] == '\n') {
linha++;
}
i++;
}
lista_adiciona(l, TK_ESPACO, src + ini, i - ini, linha);
continue;
}

/* comentário de linha */
if (src[i] == '/' && src[i + 1] == '/') {
size_t ini = i;
while (src[i] != '\0' && src[i] != '\n') {
i++;
}
lista_adiciona(l, TK_COMENTARIO, src + ini, i - ini, linha);
continue;
}

/* comentário de bloco */
if (src[i] == '/' && src[i + 1] == '*') {
size_t ini = i;
int linha_ini = linha;
i += 2;
while (src[i] != '\0' && !(src[i] == '*' && src[i + 1] == '/')) {
if (src[i] == '\n') {
linha++;
}
i++;
}
if (src[i] != '\0') {
i += 2;
}
lista_adiciona(l, TK_COMENTARIO, src + ini, i - ini, linha_ini);
continue;
}

/* diretiva de pre-processador: vai até o fim da linha lógica */
if (src[i] == '#' && (i == 0 || src[i - 1] == '\n')) {
size_t ini = i;
int linha_ini = linha;
while (src[i] != '\0') {
if (src[i] == '\\' && src[i + 1] == '\n') {
i += 2;
linha++;
continue;
}
if (src[i] == '\n') {
break;
}
i++;
}
lista_adiciona(l, TK_DIRETIVA, src + ini, i - ini, linha_ini);
continue;
}

/* literal de texto */
if (src[i] == '"') {
size_t ini = i;
int linha_ini = linha;
i++;
while (src[i] != '\0' && src[i] != '"') {
if (src[i] == '\\' && src[i + 1] != '\0') {
i += 2;
continue;
}
if (src[i] == '\n') {
linha++;
}
i++;
}
if (src[i] == '"') {
i++;
}
lista_adiciona(l, TK_TEXTO, src + ini, i - ini, linha_ini);
continue;
}

/* literal de caractere */
if (src[i] == '\'') {
size_t ini = i;
i++;
while (src[i] != '\0' && src[i] != '\'') {
if (src[i] == '\\' && src[i + 1] != '\0') {
i += 2;
continue;
}
i++;
}
if (src[i] == '\'') {
i++;
}
lista_adiciona(l, TK_CARACTERE, src + ini, i - ini, linha);
continue;
}

/* identificador */
if (inicio_ident(c)) {
size_t ini = i;
while (src[i] != '\0' && byte_ident((unsigned char) src[i])) {
i++;
}
lista_adiciona(l, TK_IDENT, src + ini, i - ini, linha);
continue;
}

/* número */
if (isdigit(c)) {
size_t ini = i;
while (src[i] != '\0') {
unsigned char d = (unsigned char) src[i];
if (isalnum(d) || d == '.' || d == '_' || d == '\'') {
i++;
continue;
}
break;
}
lista_adiciona(l, TK_NUM, src + ini, i - ini, linha);
continue;
}

/* operadores de vários caracteres */
{
size_t k;
bool achou = false;
for (k = 0; OPERADORES[k] != NULL; k++) {
size_t n = strlen(OPERADORES[k]);
if (strncmp(src + i, OPERADORES[k], n) == 0) {
lista_adiciona(l, TK_PONT, src + i, n, linha);
i += n;
achou = true;
break;
}
}
if (achou) {
continue;
}
}

/* pontuação de um caractere */
lista_adiciona(l, TK_PONT, src + i, 1, linha);
i++;
}
}

Nomes internos referenciados: byte_ident, inicio_ident, lista_adiciona.

Como este símbolo aparece nos testes​

Sem uso direto localizado

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.

Testes de caixa-preta

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.

  • Opera byte a byte; aceita CRLF e preserva BOM, conforme os testes de portabilidade.
  • Não é um pré-processador C completo nem um analisador de tipos.
  • O transpilador abre entrada/saída em modo binário; BG_FORMATO só adiciona atributo printf em GCC/Clang.
Não confunda implementação com certificação

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 tokeniza. As respostas repetem apenas o que o repositório mostra; quando não há evidência, isso é dito.

Em uma frase, o que tokeniza faz?​

Separa a fonte em identificadores, números, literais, pontuação, espaço, comentários e diretivas, preservando linhas.

Qual é a assinatura e o tipo de retorno de tokeniza?​

Assinatura extraída de tools/basicgolc.c; visibilidade interna (static).

static void tokeniza(const char *src, Lista *l)

Como chamar tokeniza 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 tokeniza(const char *src, Lista *l)

Por que não há teste direto para tokeniza?​

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.

tokeniza depende de compilador, padrão C ou sistema operacional?​

tokeniza é 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.

Ressalvas registradas: Opera byte a byte; aceita CRLF e preserva BOM, conforme os testes de portabilidade. Não é um pré-processador C completo nem um analisador de tipos.

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.