C e C++ com extern

Importe a linguagem do plugin native. A assinatura usa tipos Zolo e o corpo usa C17 ou C++17. Estes programas executam pelo CLI com o plugin instalado.

use plugin native::{c}

extern c fn exact(value: int) -> int {
    return value;
}

extern c fn length(value: str) -> int {
    #include <string.h>
    return (int64_t)strlen(value);
}

extern c fn bytes_length(value: bytes) -> int {
    return (int64_t)value.len;
}

extern c fn data() -> bytes {
    static const unsigned char raw[] = {0, 127, 255};
    zolo_bytes value = {raw, sizeof(raw)};
    return value;
}

extern c fn call(callback: fn(int) -> int) -> int {
    zolo_value input = zolo_i64(40), output = zolo_nil();
    int status = zolo_callback_call(callback, &input, 1, &output);
    int64_t value = output.integer;
    zolo_callback_release(callback, &output);
    return status == 0 ? value : -1;
}

print(exact(9007199254740993)) // expected: 9007199254740993
print(length("hello C")) // expected: 7
print(bytes_length(data())) // expected: 3
print(call(|value| value + 2)) // expected: 42

use plugin native::{cpp}

extern cpp from "./native_fixtures/Person.cpp" use {Person}

extern cpp fn greet(name: str) -> str {
    return "Hello " + name;
}

extern cpp async fn later(value: int) -> int {
    #include <chrono>
    #include <thread>
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    return value + 1;
}

extern cpp fn call(callback: fn(int) -> int) -> int {
    return callback(40);
}

let person = Person.new(name: "Ana", age: 30)
print(person.greet()) // expected: Hello Ana
print(person.birthday()) // expected: 31
person.age = 32
print(person.age) // expected: 32
print(Person.twice(21)) // expected: 42
print(greet("C++")) // expected: Hello C++
print(await later(41)) // expected: 42
print(call(|value| value + 2)) // expected: 42

int corresponde a um inteiro de 64 bits com sinal, float a double e str a um adaptador UTF-8 com tamanho explícito em C ou std::string em C++. Conversões para inteiros menores verificam o intervalo. Strings C rejeitam NUL interno. Coleções e records copiados usam o adaptador explícito zolo_value descrito no guia do plugin. Ponteiros, APIs que dependem de ownership, varargs e templates abertos precisam de um wrapper com assinatura concreta suportada.

Caminhos partem do arquivo Zolo que faz o import: extern cpp from "./Person.cpp" use {Person}. Construtores, métodos, campos públicos e métodos estáticos C++ ficam disponíveis em chamadas Zolo comuns. Os objetos mantêm estado e identidade no módulo compilado.

Callbacks e async

Um parâmetro C++ fn(int) -> int vira um adaptador chamável: o corpo pode usar callback(41). Em C, use zolo_callback_call e zolo_callback_release do header da ponte. O callback vale durante a invocação atual e permite novas chamadas Zolo dentro dele. Não o armazene nem o chame de uma thread nativa independente.

extern cpp async fn executa o trabalho em uma thread de invocação. await entrega o resultado enquanto os callbacks executam no runtime Zolo de origem. Cancelar fecha a entrega de resultados e callbacks; o código nativo pode continuar até que seu próprio mecanismo de cancelamento o interrompa. Futures C++ arbitrários precisam de um adaptador explícito.

Bibliotecas e distribuição

Declare os ports vcpkg uma vez para o provider:

use plugin native::{cpp}

// zolo install prepares the pinned vcpkg library once; auto policy may prepare
// it at the first run. Prepared executables reuse sealed library bytes.
extern cpp deps {
    fmt = { version = "11.0.2", default_features = true }
}

extern cpp fn formatted(value: int) -> str {
    #include <fmt/format.h>
    return fmt::format("exact {}", value);
}

print(formatted(9007199254740993)) // expected: exact 9007199254740993

use plugin native::{cpp}

extern cpp deps {
    "fmt" = "11.0.2"
}

extern cpp fn message(value: int) -> str {
    #include <fmt/format.h>
    return fmt::format("answer: {}", value);
}

print(message(42))

Prepare com zolo install main.zolo e execute com zolo run main.zolo --offline --frozen. Em projetos, use [foreign.native.dependencies] no zolo.toml. O baseline vcpkg, triplet, features e CRT selecionados integram o ambiente travado. No Windows, o padrão é x64-windows-static; escolha deliberadamente um triplet compatível.

A preparação precisa de Clang e dos headers/linker da plataforma. ZOLO_CLANG seleciona o Clang. Consultas do editor também usam clangd e não carregam código autoral nem executam inicializadores. O artefato compilado mantém a biblioteca nativa, assets das dependências e snapshots do fonte. VM, native e LLVM usam o mesmo artefato com plugins dinâmicos, embutidos ou estáticos, sem depender do fonte ou do compilador na execução distribuída.

Exceções C++ viram erros Zolo com o frame da função autoral. A linha exata do throw interno depende de informações de debug nativas. Crashes e comportamento indefinido continuam sujeitos à execução nativa. A execução hospedada não está disponível em wasm-aot. A validação de runtime atual cobre Windows x64; outras plataformas precisam de validação independente.