github/extism
1
1
Fork 0
mirror of https://github.com/extism/extism.git synced 2026-01-09 13:57:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

chore: remove wasm dir with old pdks

Browse Source
This commit is contained in:
Steve Manuel
2022-08-30 13:58:35 -06:00
parent a023369637
commit 64fe58f7d7
8 changed files with 0 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
wasm/Makefile
View File

@@ -1,8 +1,5 @@
SRC=count_vowels.c
PROJECT=code
rust:
cd rust-pdk && $(MAKE)
c:
emcc -o code.wasm count_vowels.c --no-entry -Wl,--export-all -sERROR_ON_UNDEFINED_SYMBOLS=0

84
wasm/c-pdk/extism-pdk.h
View File

@@ -1,84 +0,0 @@
#pragma once
#include <stdint.h>
typedef unsigned long size_t;
#define IMPORT(a, b) __attribute__((import_module(a), import_name(b)))
IMPORT("env", "extism_input_offset") extern uint64_t extism_input_offset();
IMPORT("env", "extism_length") extern uint64_t extism_length(uint64_t);
IMPORT("env", "extism_alloc") extern uint64_t extism_alloc(uint64_t);
IMPORT("env", "extism_free") extern void extism_free(uint64_t);
IMPORT("env", "extism_output_set")
extern void extism_output_set(uint64_t, uint64_t);
IMPORT("env", "extism_error_set")
extern void extism_error_set(uint64_t);
IMPORT("env", "extism_config_get")
extern uint64_t extism_config_get(uint64_t);
IMPORT("env", "extism_kv_get")
extern uint64_t extism_kv_get(uint64_t);
IMPORT("env", "extism_kv_set")
extern void extism_kv_set(uint64_t, uint64_t);
IMPORT("env", "extism_store_u8")
extern void extism_store_u8(uint64_t, uint8_t);
IMPORT("env", "extism_load_u8")
extern uint8_t extism_load_u8(uint64_t);
IMPORT("env", "extism_store_u32")
extern void extism_store_u32(uint64_t, uint32_t);
IMPORT("env", "extism_load_u32")
extern uint32_t extism_load_u32(uint64_t);
IMPORT("env", "extism_store_u64")
extern void extism_store_u64(uint64_t, uint64_t);
IMPORT("env", "extism_load_u64")
extern uint64_t extism_load_u64(uint64_t);
IMPORT("env", "extism_file_read")
extern uint64_t extism_file_read(int32_t);
IMPORT("env", "extism_file_write")
extern void extism_file_write(int32_t, uint64_t);
static void extism_load(uint64_t offs, uint8_t *buffer, size_t length) {
uint64_t n;
size_t left = 0;
for (size_t i = 0; i < length; i += 1) {
left = length - i;
if (left < 8) {
buffer[i] = extism_load_u8(offs + i);
continue;
}
n = extism_load_u64(offs + i);
*((uint64_t *)buffer + (i / 8)) = n;
i += 7;
}
}
static void extism_store(uint64_t offs, const uint8_t *buffer, size_t length) {
uint64_t n;
size_t left = 0;
for (size_t i = 0; i < length; i++) {
left = length - i;
if (left < 8) {
extism_store_u8(offs + i, buffer[i]);
continue;
}
n = *((uint64_t *)buffer + (i / 8));
extism_store_u64(offs + i, n);
i += 7;
}
}

2
wasm/rust-pdk/.cargo/config
View File

@@ -1,2 +0,0 @@
[build]
target = "wasm32-unknown-unknown"

14
wasm/rust-pdk/Cargo.toml
View File

@@ -1,14 +0,0 @@
[package]
name = "extism-pdk"
version = "0.0.1-alpha"
edition = "2021"
authors = ["The Extism Authors", "oss@extism.org"]
license = "BSD-3-Clause"
homepage = "https://extism.org"
repository = "https://github.com/extism/extism"
description = "Extism Plug-in Development Kit (PDK) for Rust"
[dependencies]
extism-manifest = {path = "../../manifest"}
serde_json = "1"

3
wasm/rust-pdk/Makefile
View File

@@ -1,3 +0,0 @@
count_vowels:
cargo build --release --example count_vowels
cp target/wasm32-unknown-unknown/release/examples/count_vowels.wasm ../code.wasm

21
wasm/rust-pdk/examples/count_vowels.rs
View File

@@ -1,21 +0,0 @@
#![no_main]
use extism_pdk::*;
const VOWELS: &[char] = &['a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U'];
#[no_mangle]
unsafe fn count_vowels() -> i32 {
let host = Host::new();
let s = host.input_str();
let mut count = 0;
for ch in s.chars() {
if VOWELS.contains(&ch) {
count += 1;
}
}
host.output(&format!(r#"{{"count": {count}}}"#));
0
}

68
wasm/rust-pdk/src/bindings.rs
View File

@@ -1,68 +0,0 @@
extern "C" {
pub fn extism_input_offset() -> u64;
pub fn extism_length(offs: u64) -> u64;
pub fn extism_alloc(length: u64) -> u64;
pub fn extism_free(offs: u64);
pub fn extism_output_set(offs: u64, length: u64);
pub fn extism_error_set(offs: u64);
pub fn extism_store_u8(offs: u64, data: u8);
pub fn extism_load_u8(offs: u64) -> u8;
pub fn extism_store_u32(offs: u64, data: u32);
pub fn extism_load_u32(offs: u64) -> u32;
pub fn extism_store_u64(offs: u64, data: u64);
pub fn extism_load_u64(offs: u64) -> u64;
pub fn extism_file_read(fd: i32) -> u64;
pub fn extism_file_write(fd: i32, offs: u64);
pub fn extism_config_get(offs: u64) -> u64;
pub fn extism_kv_get(offs: u64) -> u64;
pub fn extism_kv_set(offs: u64, offs1: u64);
pub fn extism_http_request(req: u64, body: u64) -> u64;
}
/// # Safety
///
/// This function is used to access WASM memory
pub unsafe fn extism_load(offs: u64, data: &mut [u8]) {
let ptr = data.as_mut_ptr();
let mut index = 0;
let mut left;
let len = data.len();
while index < len {
left = len - index;
if left < 8 {
data[index] = extism_load_u8(offs + index as u64);
index += 1;
continue;
}
let x = extism_load_u64(offs + index as u64);
(ptr as *mut u64).add(index / 8).write(x);
index += 8;
}
}
/// # Safety
///
/// This function is used to access WASM memory
pub unsafe fn extism_store(offs: u64, data: &[u8]) {
let ptr = data.as_ptr();
let mut index = 0;
let mut left;
let len = data.len();
while index < len {
left = len - index;
if left < 8 {
extism_store_u8(offs + index as u64, data[index]);
index += 1;
continue;
}
extism_store_u64(
offs + index as u64,
(ptr as *const u64).add(index / 8).read(),
);
index += 8;
}
}

153
wasm/rust-pdk/src/lib.rs
View File

@@ -1,153 +0,0 @@
pub mod bindings;
use bindings::*;
pub struct Host {
input: Vec<u8>,
}
impl Default for Host {
fn default() -> Self {
Host::new()
}
}
pub struct Vars<'a>(&'a Host);
pub struct Memory {
pub offset: u64,
pub length: u64,
}
impl Memory {
pub fn load(&self, mut buf: impl AsMut<[u8]>) {
let buf = buf.as_mut();
unsafe { extism_load(self.offset, &mut buf[0..self.length as usize]) }
}
pub fn store(&mut self, buf: impl AsRef<[u8]>) {
let buf = buf.as_ref();
unsafe { extism_store(self.offset, &buf[0..self.length as usize]) }
}
}
impl Drop for Memory {
fn drop(&mut self) {
unsafe { extism_free(self.offset) }
}
}
impl<'a> Vars<'a> {
pub fn new(host: &'a Host) -> Self {
Vars(host)
}
pub fn get(&self, key: impl AsRef<str>) -> Option<Vec<u8>> {
let mem = self.0.alloc_bytes(key.as_ref().as_bytes());
let offset = unsafe { extism_kv_get(mem.offset) };
let len = unsafe { extism_length(offset) };
if offset == 0 || len == 0 {
return None;
}
let mut buf = vec![0; len as usize];
unsafe {
extism_load(offset, &mut buf);
}
Some(buf)
}
pub fn set(&mut self, key: impl AsRef<str>, val: impl AsRef<[u8]>) {
let key = self.0.alloc_bytes(key.as_ref().as_bytes());
let val = self.0.alloc_bytes(val.as_ref());
unsafe { extism_kv_set(key.offset, val.offset) }
}
pub fn remove(&mut self, key: impl AsRef<str>) {
let key = self.0.alloc_bytes(key.as_ref().as_bytes());
unsafe { extism_kv_set(key.offset, 0) }
}
}
impl Host {
pub fn new() -> Host {
unsafe {
let input_offset = extism_input_offset();
let input_length = extism_length(input_offset);
let mut input = vec![0; input_length as usize];
extism_load(input_offset, &mut input);
Host { input }
}
}
pub fn alloc(&self, length: usize) -> Memory {
let length = length as u64;
let offset = unsafe { extism_alloc(length) };
Memory { offset, length }
}
pub fn alloc_bytes(&self, data: impl AsRef<[u8]>) -> Memory {
let data = data.as_ref();
let length = data.len() as u64;
let offset = unsafe { extism_alloc(length) };
Memory { offset, length }
}
pub fn input(&self) -> &[u8] {
self.input.as_slice()
}
pub fn input_str(&self) -> &str {
unsafe { std::str::from_utf8_unchecked(self.input.as_slice()) }
}
pub fn http_request(
&self,
req: &extism_manifest::HttpRequest,
body: Option<&[u8]>,
) -> Result<Vec<u8>, serde_json::Error> {
let enc = serde_json::to_vec(req)?;
let req = self.alloc_bytes(&enc);
let body = match body {
Some(b) => self.alloc_bytes(b).offset,
None => 0,
};
let res = unsafe { extism_http_request(req.offset, body) };
let len = unsafe { extism_length(res) };
let mut dest = vec![0; len as usize];
unsafe { bindings::extism_load(res, &mut dest) };
Ok(dest)
}
pub fn output(&self, data: impl AsRef<[u8]>) {
let len = data.as_ref().len();
unsafe {
let offs = extism_alloc(len as u64);
extism_store(offs, data.as_ref());
extism_output_set(offs, len as u64);
}
}
pub fn config(&self, key: impl AsRef<str>) -> String {
let mem = self.alloc_bytes(key.as_ref().as_bytes());
let offset = unsafe { extism_config_get(mem.offset) };
let len = unsafe { extism_length(offset) };
if offset == 0 || len == 0 {
return String::new();
}
let mut buf = vec![0; len as usize];
unsafe {
extism_load(offset, &mut buf);
String::from_utf8_unchecked(buf)
}
}
pub fn vars(&self) -> Vars {
Vars::new(self)
}
}