{

"name": "Existing Dockerfile",

"build": {

// Sets the run context to one level up instead of the .devcontainer folder.

"context": "..",

// Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.

"dockerfile": "../Dockerfile"

},

// Features to add to the dev container. More info: https://containers.dev/features.

// "features": {},

// Use 'forwardPorts' to make a list of ports inside the container available locally.

// "forwardPorts": [],

// Uncomment the next line to run commands after the container is created.

// "postCreateCommand": "cat /etc/os-release",

// Configure tool-specific properties.

// "customizations": {},

// Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root.

"remoteUser": "root"

}

version = "0.3.1"

concat-idents = "1.1.4"

metacall-inline = { path = "./inline", version = "0.1.1" }

[build-dependencies]

bindgen = { version = "0.64.0", default-features = false, features = ["runtime", "logging", "which-rustfmt"]}

git2 = { version = "0.16.1", default-features = false, features = ["https"] }

tempfile = { version = "3.4.0", default-features = false }

FROM devraymondsh/ubuntu-docker-rust

RUN apt-get update \

&& apt-get install -y --no-install-recommends build-essential cmake ca-certificates git nodejs npm pkg-config clang-11 clang-format-11 libclang-11-dev cmake valgrind libdw-dev libbfd-dev libdwarf-dev libffi-dev

WORKDIR /root/metacall-polyglot

RUN git clone --branch v0.7.3 https://github.com/metacall/core

RUN mkdir core/build

WORKDIR /root/metacall-polyglot/core/build

RUN cmake \

-DOPTION_BUILD_DETOURS=Off \

-DOPTION_BUILD_EXAMPLES=Off \

-DOPTION_BUILD_LOADERS_C=On \

-DOPTION_BUILD_LOADERS_NODE=On \

-DOPTION_BUILD_SANITIZER=ON \

-DOPTION_BUILD_SCRIPTS=Off \

-DOPTION_BUILD_SERIALS_RAPID_JSON=On \

-DOPTION_BUILD_TESTS=Off \

..

RUN cmake --build . --target install

RUN cd /usr/local/lib && ldconfig

RUN rustup component add rustfmt

RUN rustup toolchain add nightly

RUN cargo install cargo-valgrind

WORKDIR /root/metacall-polyglot

CMD ["cargo", "test"]

use metacall::{hooks, loaders, structs::Any, metacall};

// Metacall automatically shuts down when it goes out of scope

let _ = hooks::initialize().unwrap();

loaders::from_file("ts", ["sum.ts"]).unwrap();

let sum = metacall("sum", [Any::Double(1.0), Any::Double(2.0)]).unwrap();

println!("sum: {:?}", sum);

use bindgen::builder;

use git2::Repository;

use std::{

env, fs, io,

path::{Path, PathBuf},

const METACALL_CORE_REPO: &str = "https://github.com/metacall/core.git#v0.7.3";

pub fn copy_recursively(source: impl AsRef<Path>, destination: impl AsRef<Path>) -> io::Result<()> {

fs::create_dir_all(&destination)?;

for entry in fs::read_dir(source)? {

let entry = entry?;

let filetype = entry.file_type()?;

if filetype.is_dir() {

copy_recursively(entry.path(), destination.as_ref().join(entry.file_name()))?;

} else {

fs::copy(entry.path(), destination.as_ref().join(entry.file_name()))?;

}

}

Ok(())

fn get_bindings_dir() -> PathBuf {

let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());

let bindings_dir = out_dir.join("bindings");

fs::create_dir_all(&bindings_dir).unwrap();

bindings_dir.canonicalize().unwrap()

fn download_the_headers<T: ToString>(bindings_dir: &PathBuf, headers: &[T]) {

let mut need_for_clone = false;

let bindings_str = bindings_dir.to_str().unwrap();

for header in headers {

let path = PathBuf::from(format!("{}/{}", bindings_str, header.to_string()));

if !path.exists() && !need_for_clone {

need_for_clone = true;

}

}

if need_for_clone {

let temp_dir = tempfile::tempdir().unwrap();

Repository::clone(METACALL_CORE_REPO, &temp_dir).unwrap();

let tmp_dir = temp_dir.path().to_str().unwrap();

let source = format!("{}/source/metacall", tmp_dir);

let destination = bindings_dir.join("metacall");

copy_recursively(source, destination).unwrap();

}

fn generate_bindings<T: ToString>(bindings_dir: &PathBuf, headers: &[T]) {

let bindings_dir_str = bindings_dir.to_str().unwrap();

let mut builder = builder();

for header in headers {

builder = builder.header(format!("{}/{}", bindings_dir_str, header.to_string()));

}

builder = builder

.detect_include_paths(true)

.size_t_is_usize(true)

.rustfmt_bindings(true)

.generate_comments(true)

.derive_hash(true);

let bindings = builder.generate().unwrap();

bindings

.write_to_file(bindings_dir.join("bindings.rs"))

.unwrap();

const HEADERS: [&str; 3] = [

"metacall/include/metacall/metacall.h",

"metacall/include/metacall/metacall_value.h",

"metacall/include/metacall/metacall_error.h",

];

let bindings_dir = get_bindings_dir();

download_the_headers(&bindings_dir, &HEADERS);

generate_bindings(&bindings_dir, &HEADERS);

for header in HEADERS {

println!(

"{}",

format!(

"cargo:rerun-if-changed={}/{}",

bindings_dir.to_str().unwrap(),

header

)

);

}

version = "0.1.1"

use std::env;

::metacall::loaders::from_memory(stringify!($name), #buffer.to_string()).unwrap()

pub fn include_bindings(_input: TokenStream) -> TokenStream {

let out_dir = env::var("OUT_DIR").unwrap();

let path = format!("{}/bindings/bindings.rs", out_dir);

let result = quote! {

#[path = #path]

#[allow(warnings)]

mod generated_bindings;

};

result.into()

use crate::{

bindings::{metacall_destroy, metacall_initialize},

prelude::MetacallInitError,

use std::ffi::c_int;

pub fn destroy_manually() -> c_int {

unsafe { metacall_destroy() }

pub fn initialize_manually() -> c_int {

unsafe { metacall_initialize() }

pub struct MetacallAutoDestroy(pub fn() -> c_int);

impl Drop for MetacallAutoDestroy {

fn drop(&mut self) {

self.0();

}

pub fn initialize() -> Result<MetacallAutoDestroy, MetacallInitError> {

if initialize_manually() != 0 {

return Err(MetacallInitError::new());

}

Ok(MetacallAutoDestroy(destroy_manually))