0.3 - many fixes, add support for Perl and Ruby

Author: zdimension

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "inline-vbs"
-version = "0.2.1"
+version = "0.3.0"
 authors = ["Tom Niget <niget.tom@gmail.com>"]
 description = "Embed VBScript code inside Rust"
 homepage = "https://github.com/zdimension/inline-vbs"
@@ -15,13 +15,13 @@ exclude = [
 ]
 
 [dependencies]
-inline-vbs-macros = { version = "0.2", path = "./macros" }
-cxx = "1.0.65"
-winapi = { version = "0.3.9", features = ["oaidl", "wtypes", "oleauto"] }
-widestring = "0.5.1"
-enumn = "0.1.3"
+inline-vbs-macros = { version = "0.3", path = "./macros" }
+variant-rs = { version = "0.2.1" }
+windows = { version = "0.43.0", features = ["Win32_System_Com", "Win32_System_Ole", "Win32_Foundation"] }
+cxx = "1.0.85"
+widestring = "1.0.2"
+enumn = "0.1.6"
 dep_doc = "0.1.1"
-variant-rs = "0.1"
 
 [build-dependencies]
 cxx-build = "1.0"
@@ -33,4 +33,4 @@ members = [
 
 [package.metadata.docs.rs]
 default-target = "x86_64-pc-windows-msvc"
-targets = ["x86_64-pc-windows-msvc"]
+targets = ["x86_64-pc-windows-msvc"]

README.md

@@ -1,6 +1,6 @@
 # inline-vbs
 
-`inline-vbs` is a crate that allows you to embed VBScript code inside Rust code files. It uses
+`inline-vbs` is a crate that allows you to embed VBScript, JScript and many other languages inside Rust code files. It uses
 the [Active Scripting](https://docs.microsoft.com/en-us/archive/msdn-magazine/2000/december/active-scripting-apis-add-powerful-custom-debugging-to-your-script-hosting-app) COM APIs to dynamically parse and execute (optionally, evaluate) code.
 
 ## Basic usage
@@ -18,20 +18,32 @@ Macros:
 * `vbs!` - Executes a statement or evaluates an expression (depending on context)
 * `vbs_!` - Evaluates an expression
 * `vbs_raw!` - Executes a statement (string input instead of tokens, use for multiline code)
-  See more examples in [tests/tests.rs](tests/tests.rs)
+  See more examples in [tests/tests.rs](tests/tests.rs).
 
 ## Installation
 Add this to your `Cargo.toml`:
 ```toml
 [dependencies]
-inline-vbs = "0.2.1"
+inline-vbs = "0.3.0"
 ```
 
 **Important:** You need to have the MSVC Build Tools installed on your computer, as required by [cc](https://github.com/rust-lang/cc-rs).
 
+### Language support
+
+VBScript (`vbs!`) and JScript (`js!`) are available out of the box on 32-bit and 64-bit.
+
+Other Active Scripting engines exist:
+- Ruby (`ruby!`): ActiveScriptRuby [1.8 (tested, 32-bit only)](https://www.artonx.org/data/asr/ActiveRuby.msi)
+  - [2.4 (32 or 64-bit) (untested!)](https://www.artonx.org/data/asr/), you need to change the CLSID in [src/vbs.cpp](src/vbs.cpp)
+- Perl (`perl!`): [ActivePerl 5.20 (32-bit)](https://raw.githubusercontent.com/PengjieRen/LibSum/master/ActivePerl-5.20.2.2002-MSWin32-x86-64int-299195.msi)
+
+Note: install an engine matching the bitness of your program; by default Rust on Windows builds 
+64-bit programs, which can only use 64-bit libraries. If you want to use a 32-bit library, you
+need to build your program with `--target i686-pc-windows-msvc`.
+
 ## Limitations
-Many. Most notably, `IDispatch` objects (i.e. what `CreateObject` returns) can't be passed to
-the engine (`let x = vbs! { CreateObject("WScript.Shell") }; vbs! { y = 'x }` won't work).
+Many. 
 
 ## Motivation
 N/A

include/vbs.h

@@ -1,9 +1,13 @@
 #pragma once
 
+//#include <stdint.h>
+
 #include "rust/cxx.h"
 #include <Windows.h>
 
+enum class ScriptLang : uint8_t;
+
 int init();
-int parse_wrapper(rust::Str code, char* output);
+int parse_wrapper(rust::Str code, char* output, ScriptLang lang);
 rust::String error_to_string(int hr);
-int set_variable(rust::Str name, char* val);
+int set_variable(rust::Str name, char* val, ScriptLang lang);

macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "inline-vbs-macros"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Tom Niget <niget.tom@gmail.com>"]
 description = "Macros for the `inline-vbs` crate"
 homepage = "https://github.com/zdimension/inline-vbs"
@@ -16,5 +16,6 @@ proc-macro = true
 
 [dependencies]
 litrs = "0.2.3"
+paste = "1.0.11"
 proc-macro2 = "1.0"
 quote = "1.0.15"

macros/src/lib.rs

@@ -28,18 +28,41 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #![feature(proc_macro_span)]
 
 use litrs::StringLit;
+use paste::paste;
 use proc_macro::LineColumn;
 use proc_macro::Span;
-use proc_macro2::TokenStream;
 use proc_macro2::{Delimiter, Ident, Spacing, TokenTree};
-use quote::quote;
+use proc_macro2::{Punct, TokenStream};
 use quote::quote_spanned;
+use quote::{quote, ToTokens, TokenStreamExt};
 use std::collections::BTreeMap;
 use std::fmt::Write;
 
+#[derive(Copy, Clone, Debug)]
+#[repr(C)]
+enum ScriptLang {
+    VBScript,
+    JScript,
+    Perl,
+    Ruby,
+}
+
+impl ToTokens for ScriptLang {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.append(Ident::new("inline_vbs", proc_macro2::Span::call_site()));
+        tokens.append(Punct::new(':', Spacing::Joint));
+        tokens.append(Punct::new(':', Spacing::Alone));
+        tokens.append(Ident::new("ScriptLang", proc_macro2::Span::call_site()));
+        tokens.append(Punct::new(':', Spacing::Joint));
+        tokens.append(Punct::new(':', Spacing::Alone));
+        let lang = format!("{:?}", self);
+        tokens.append(Ident::new(&lang, proc_macro2::Span::call_site()));
+    }
+}
+
 extern crate proc_macro;
 
-fn macro_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
+fn macro_impl(input: TokenStream, lang: ScriptLang) -> Result<TokenStream, TokenStream> {
     let mut x = EmbedVbs::new();
 
     x.add(input)?;
@@ -53,53 +76,60 @@ fn macro_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 
     Ok(quote! {
         {
-            #(::inline_vbs::set_variable(#varname, #var).unwrap();)*
-            ::inline_vbs::Runner::run_code(#code)
+            #(::inline_vbs::set_variable(#varname, #var, #lang).expect("Couldn't set variable");)*
+            ::inline_vbs::Runner::run_code(#code, #lang)
         }
     })
 }
 
-#[proc_macro]
-pub fn vbs(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    proc_macro::TokenStream::from(process_tokens(input))
-}
+macro_rules! lang {
+    ($name:ident, $val:ident) => {
+        #[proc_macro]
+        pub fn $name(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+            proc_macro::TokenStream::from(process_tokens(input, ScriptLang::$val))
+        }
 
-fn process_tokens(input: proc_macro::TokenStream) -> TokenStream {
-    match macro_impl(TokenStream::from(input)) {
-        Ok(tokens) => tokens,
-        Err(tokens) => tokens,
-    }
-}
+        paste! {
+            #[proc_macro]
+            pub fn [< $name _ >](input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+                let call = process_tokens(input, ScriptLang::$val);
+                (quote! {
+                    {
+                        let res: Variant = #call;
+                        res
+                    }
+                })
+                    .into()
+            }
 
-#[proc_macro]
-pub fn vbs_(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let call = process_tokens(input);
-    (quote! {
-        {
-            let res: Variant = #call;
-            res
+            #[proc_macro]
+            pub fn [< $name _raw >](input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+                let input = input.into_iter().collect::<Vec<_>>();
+                if input.len() != 1 {
+                    let msg = format!("expected exactly one input token, got {}", input.len());
+                    return quote! { compile_error!(#msg) }.into();
+                }
+                let string_lit = match StringLit::try_from(&input[0]) {
+                    Err(e) => return e.to_compile_error(),
+                    Ok(lit) => lit,
+                };
+                let code = string_lit.value();
+                quote! [::inline_vbs::run_code(#code, ScriptLang::$val)].into()
+            }
         }
-    })
-    .into()
+    };
 }
 
-#[proc_macro]
-pub fn vbs_raw(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let input = input.into_iter().collect::<Vec<_>>();
+lang!(vbs, VBScript);
+lang!(js, JScript);
+lang!(perl, Perl);
+lang!(ruby, Ruby);
 
-    if input.len() != 1 {
-        let msg = format!("expected exactly one input token, got {}", input.len());
-        return quote! { compile_error!(#msg) }.into();
+fn process_tokens(input: proc_macro::TokenStream, lang: ScriptLang) -> TokenStream {
+    match macro_impl(TokenStream::from(input), lang) {
+        Ok(tokens) => tokens,
+        Err(tokens) => tokens,
     }
-
-    let string_lit = match StringLit::try_from(&input[0]) {
-        Err(e) => return e.to_compile_error(),
-        Ok(lit) => lit,
-    };
-
-    let code = string_lit.value();
-
-    quote! [::inline_vbs::run_code(#code)].into()
 }
 
 struct EmbedVbs {

src/lib.rs

@@ -41,28 +41,39 @@ use std::os::raw::c_char;
 pub use variant_rs::variant::ToVariant;
 pub use variant_rs::variant::Variant;
 
-pub use winapi::um::oaidl::VARIANT;
-use winapi::um::oleauto::VariantInit;
+use windows::Win32::System::Com::VARIANT;
+use windows::Win32::System::Ole::VariantInit;
 
-pub use inline_vbs_macros::{vbs, vbs_, vbs_raw};
+pub use inline_vbs_macros::*;
 
 #[allow(clippy::upper_case_acronyms)]
 type HRESULT = i32;
 
 #[cxx::bridge]
 mod ffi {
+    enum ScriptLang {
+        VBScript,
+        JScript,
+        Perl,
+        Ruby,
+        Last,
+    }
+
     unsafe extern "C++" {
         include!("inline-vbs/include/vbs.h");
 
         pub fn init() -> i32;
-        pub unsafe fn parse_wrapper(str: &str, output: *mut c_char) -> i32;
+        pub unsafe fn parse_wrapper(str: &str, output: *mut c_char, lang: ScriptLang) -> i32;
         pub fn error_to_string(error: i32) -> String;
-        pub unsafe fn set_variable(name: &str, val: *mut c_char) -> i32;
+        pub unsafe fn set_variable(name: &str, val: *mut c_char, lang: ScriptLang) -> i32;
     }
 }
 
+pub use ffi::ScriptLang;
+
 fn decode_hr<T>(hr: i32, val: T) -> Result<T, String> {
     if hr != 0 {
+        print!("Error: 0x{:08x}\n", hr);
         Err(ffi::error_to_string(hr))
     } else {
         Ok(val)
@@ -76,41 +87,45 @@ fn or_die(hr: HRESULT) {
 }
 
 pub trait Runner {
-    fn run_code(code: &str) -> Self;
+    fn run_code(code: &str, lang: ScriptLang) -> Self;
 }
 
 impl Runner for Variant {
-    fn run_code(code: &str) -> Self {
+    fn run_code(code: &str, lang: ScriptLang) -> Self {
         unsafe {
             or_die(ffi::init());
             let mut variant: VARIANT = std::mem::zeroed();
             VariantInit(&mut variant);
-            let result =
-                ffi::parse_wrapper(code.trim(), (&mut variant) as *mut VARIANT as *mut c_char);
-            decode_hr(result, ()).unwrap();
-            variant.try_into().unwrap()
+            let result = ffi::parse_wrapper(
+                code.trim(),
+                (&mut variant) as *mut VARIANT as *mut c_char,
+                lang,
+            );
+            decode_hr(result, ()).expect("Non-success HRESULT");
+            variant.try_into().expect("Can't decode VARIANT")
         }
     }
 }
 
 impl Runner for () {
-    fn run_code(code: &str) -> Self {
+    fn run_code(code: &str, lang: ffi::ScriptLang) -> Self {
         unsafe {
             or_die(ffi::init());
-            let result = ffi::parse_wrapper(code, std::ptr::null_mut());
-            decode_hr(result, ()).unwrap();
+            let result = ffi::parse_wrapper(code, std::ptr::null_mut(), lang);
+            decode_hr(result, ()).expect("Non-success HRESULT");
         }
     }
 }
 
-pub fn set_variable(name: &str, val: impl ToVariant) -> Result<(), String> {
+pub fn set_variable(name: &str, val: impl ToVariant, lang: ScriptLang) -> Result<(), String> {
     unsafe {
-        let _: () = Runner::run_code(format!("Dim {}", name).as_str());
+        //let _: () = Runner::run_code(format!("Dim {}", name).as_str());
+        or_die(ffi::init());
         let var = val.to_variant();
         let ptr: VARIANT = var
             .try_into()
             .map_err(|e| format!("Variant conversion error: {:?}", e))?;
-        let result = ffi::set_variable(name, &ptr as *const VARIANT as *mut _);
+        let result = ffi::set_variable(name, &ptr as *const VARIANT as *mut _, lang);
         decode_hr(result, ())
     }
 }