tokeniza
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
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.
main→ tests/auditar_exemplos.py, tests/documentacao/check_llms_build.py, tests/documentacao/test_gerador.py, tests/fuzz_basicgolc.py, tests/portabilidade/cpp_inclusao.cpp …
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.
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.