// delégua → c99 → executável nativo

Compilador Geral Delégua

Escreva em português. Compile para código nativo. O CGD combina um frontend em D com um runtime gerenciado em C, verificações de tipos e limites explícitos para recursos inseguros.

branch dev · Linux x86_64 · DMD e LDC2

bash — cgd

$ cgd ola.delegua -o

Fonte → análise → C99 → binário

$ ./ola

Olá, Delégua!

$ ▌

// 01 — preparar, compilar, usar

Do checkout ao primeiro programa.

Você precisa de Git, DUB, DMD ou LDC2, um compilador C99, pkg-config, Boehm GC e libcurl >=7.86 com headers. Python 3 é usado no build do runtime e nos testes.

Dependências

terminal
sudo apt-get update
sudo apt-get install git build-essential clang pkg-config libgc-dev libcurl4-openssl-dev ldc dub python3

Para DMD, use os downloads oficiais de D. Os nomes dos pacotes variam por distribuição.

Build do zero

com submódulos
git clone --branch dev --recurse-submodules https://github.com/FernandoTheDev/cgd.git
cd cgd
./build-runtime
dub build --compiler=ldc2 --build=release

# Alternativa com DMD:
dub build --compiler=dmd --build=release

O runtime é um submódulo separado. build-runtime compila seu estado local; não executa pulls silenciosos.

Instalar no usuário

O executável, o objeto do runtime e os headers ficam em ~/.local/share/cgd. Um link em ~/.local/bin permite chamar o compilador fora do checkout, sem sudo.

instalação
./instalar --compiler ldc2 --release
export PATH="$HOME/.local/bin:$PATH"
cgd ola.delegua -s ola
./ola

Atenção às opções: -o ativa otimizações. Para escolher o nome do executável, use -s caminho. O C intermediário é gravado ao lado do binário.

Opção Uso
-a / --ajuda Ajuda da CLI.
-s / --saida Caminho do executável.
-o / --otimizar Otimizações do CGD e -O2 no compilador C.
-d / --depurar AST, C gerado e comando de compilação.
-t / --tempo Tempo dos passes.
--verificar Analisa sem gerar binário ou exigir toolchain C.
--emitir-c Emite C99 sem vincular runtime.
--diagnosticos=json Diagnósticos JSON Lines em stderr.
--target / --sysroot Configura alvo e SDK; exige runtime e bibliotecas do alvo.
CC=gcc Seleciona o executável do compilador C; sem concatenar opções.
// 02 — o caminho da compilação

Um pipeline que você pode inspecionar.

O pipeline inclui limites estruturais, segurança estática e análise de fluxo. Falhas comprovadas são antecipadas; os diagnósticos possuem códigos consultáveis com cgd --explicar E3101. A localização de execução usa metadados estáticos, sem chamada de debug por linha.

O frontend não vira um interpretador embutido no programa. Ele valida a fonte e gera C99; o compilador C produz o executável ligado ao runtime, ao GC e à libcurl.

  1. 01Tokens e ASTLexer, escapes, posições e estruturas da linguagem.
  2. 02Módulos e semânticaSímbolos, tipos, herança, aridade e capturas proibidas.
  3. 03CTFE e loweringOtimização opcional e operações explícitas do runtime.
  4. 04C99 e vínculoClang, GCC ou TCC, com runtime, Boehm GC e libcurl.

Frontend em D

DMD e LDC2 compilam a mesma base. Os passes ficam em src/frontend, src/ctfe, src/middle e src/backend/c.

Runtime gerenciado

Valores carregam seus tipos. Chamadas indiretas, acesso a membros e coleções têm verificações em execução. Funções não guardam endereços de variáveis locais encerradas.

A VM de CTFE funciona durante a compilação de funções //>puro, com limites de trabalho. Ao atingir esses limites, a chamada é preservada para execução nativa.

Ler a arquitetura e a ABI em detalhes →
// 03 — perfil compilado de delégua

Recursos, com exemplos verificáveis.

Abra a referência completa da linguagem: sintaxe, exemplos executáveis e situação de cada recurso, incluindo limites e exclusões.

Área O que está disponível Exemplo
Tipos e variáveis Nulo, lógicos, números, anotações, constantes, múltipla atribuição e escopos. tipos →
Controle de fluxo Se, ternário, escolha/caso, laços, sustar, continua e laços como expressões. laços →
Funções como valores Nomeadas e anônimas sem captura, callbacks, padrões, espalhamento e parâmetros variáveis. funções →
Coleções Vetores, tuplas imutáveis, dicionários, compreensão, desestruturação e fatias com passo. coleções →
Texto e Unicode Interpolação, escapes, pontos de código, busca, conversão de caixa e métodos de texto. Unicode →
Classes Construtores, herança, isto, super, métodos ligados e identidade nominal. herança →
Privacidade e acessores Público, privado, protegido, obter/definir e validação de campos tipados. acessores →
Exceções Tente, pegue tipado, finalmente, falhar e subclasses de Excecao. exceções →
Módulos Fontes locais, caminhos literais, cache, ciclos diagnosticados e inicialização única. módulos →
Biblioteca nativa Entrada/saída, conversões, mapear, filtrar, ordenar, clonagem profunda e aleatoriedade. biblioteca →
Metadados e asserções Decoradores de dados, envelopes de funções livres sem captura e asserções tratáveis. metadados →
Consultar a matriz completa de compatibilidade →
// 04 — código que faz parte dos testes

Aprenda pelo executável.

Classes e interpolação

ola.delegua
classe Pessoa {
    nome: texto
    construtor(nome) { isto.nome = nome }
    apresentar() {
        retorna "Olá, ${isto.nome}!"
    }
}
escreva(Pessoa("Delégua").apresentar())

Exceções com limpeza

excecoes.delegua
tente {
    falhar "erro proposital"
} pegue (erro: Excecao) {
    escreva(erro.mensagem)
} finalmente {
    escreva("limpeza executada")
}

O catálogo inclui exemplos históricos, tutoriais de linguagem, módulos e falhas esperadas. Entrada padrão e diagnósticos também têm contratos de teste.

Abrir o catálogo de exemplos →
// 05 — limites explícitos

Segurança faz parte do perfil.

bloqueado por decisão de segurança

Sem captura implícita

Upvalues, capturas de parâmetros/locais/globais e de isto por funções internas recebem aviso e erro. Passe o estado por parâmetros ou por uma instância explícita.

funcao criar(valor) {
    retorna funcao() {
        retorna valor // bloqueado: captura
    }
}
bloqueado por decisão de segurança

Sem código nativo arbitrário

FFI na linguagem, classes estrangeiras, ponteiros arbitrários, NPM, importação calculada e avaliação dinâmica não são expostos. Módulos aceitos são fontes .delegua conhecidas na compilação.

limites atuais, distintos de insegurança

O que ainda exige atenção

  • Linux x86_64 é o ambiente validado; Windows, macOS e cross-compilation não são garantidos.
  • Inteiros e longo usam 64 bits verificados; não há precisão arbitrária. Reais usam precisão dupla.
  • Envelopes de decoradores em métodos e herança por alias dinâmico importado ainda não são resolvidos.
  • A CTFE aceita um subconjunto da linguagem. Não há backend próprio LLVM/assembly nem dialetos adicionais.
  • O runtime usa uma thread; dicionários não prometem ordem de inserção.

Aridade, tipos, identidade de classes, privacidade e contratos de coleções também são verificados em execução. Isso não equivale a uma prova formal de segurança ou a um sandbox para programas não confiáveis.

Ler o contrato de segurança →
// 06 — verificar, não presumir

A mesma fonte em DMD e LDC2.

A matriz compila o frontend em debug e release, gera programas com Clang e GCC e executa integração, exemplos e instalação isolada. Uma dependência ausente falha explicitamente.

validação reproduzível
dub test --compiler=dmd
dub test --compiler=ldc2
python3 testes/integracao.py
python3 testes/exemplos.py
python3 scripts/validar.py

Contratos dos exemplos

//! define a saída. //# define o status. //? fixa entrada, fase e mensagem do diagnóstico. Nenhum arquivo do catálogo é ignorado pelo runner Python.

Verificações do runtime

Os testes C também podem rodar com NDEBUG, AddressSanitizer e UndefinedBehaviorSanitizer. As opções necessárias para o GC estão documentadas no vendor.

Consultar o registro de validação →