Use std::os::raw::c_char for cross-platform compat (#169)

* use libc::c_char for cross-platform compat

* use standard library instead of libc crate

Author: jmcphers

extensions/positron-r/amalthea/crates/ark/src/lsp/browser.rs

@@ -11,37 +11,32 @@ use harp::exec::RFunction;
 use harp::object::RObject;
 use libR_sys::*;
 use log::info;
+use std::os::raw::c_char;
 
 use crate::interface::KERNEL;
 
 pub static mut PORT: u16 = 0;
 
 #[harp::register]
 pub unsafe extern "C" fn ps_browse_url(url: SEXP) -> SEXP {
-
     match ps_browse_url_impl(url) {
         Ok(_) => Rf_ScalarLogical(1),
         Err(error) => {
             log::error!("{}", error);
             Rf_ScalarLogical(0)
         }
     }
-
 }
 
 unsafe fn ps_browse_url_impl(url: SEXP) -> anyhow::Result<()> {
-
     // Extract URL
     let url = RObject::view(url).to::<String>()?;
 
     // Check for help requests
-    let port = RFunction::new("tools", "httpdPort")
-        .call()?
-        .to::<i32>()?;
+    let port = RFunction::new("tools", "httpdPort").call()?.to::<i32>()?;
 
     let prefix = format!("http://127.0.0.1:{}/", port);
     if url.starts_with(&prefix) {
-
         let replacement = format!("http://127.0.0.1:{}/", PORT);
         let url = url.replace(prefix.as_str(), replacement.as_str());
         let event = PositronEvent::ShowHelp(ShowHelpEvent {
@@ -53,9 +48,7 @@ unsafe fn ps_browse_url_impl(url: SEXP) -> anyhow::Result<()> {
         info!("Sending ShowHelp event: {:#?}", event);
         let kernel = KERNEL.as_ref().unwrap().lock().unwrap();
         kernel.send_event(event);
-
     }
 
     Ok(())
-
 }

extensions/positron-r/amalthea/crates/ark/src/lsp/show_message.rs

@@ -5,9 +5,10 @@
 //
 //
 
-use amalthea::events::{ShowMessageEvent, PositronEvent};
+use amalthea::events::{PositronEvent, ShowMessageEvent};
 use harp::object::RObject;
 use libR_sys::*;
+use std::os::raw::c_char;
 use stdext::local;
 
 use crate::request::Request;
@@ -17,8 +18,7 @@ use super::global::INSTANCE;
 /// Shows a message in the Positron frontend
 #[harp::register]
 pub unsafe extern "C" fn ps_show_message(message: SEXP) -> SEXP {
-
-    let result : anyhow::Result<()> = local! {
+    let result: anyhow::Result<()> = local! {
         // Convert message to a string
         let msg = RObject::view(message).to::<String>()?;
 

extensions/positron-r/amalthea/crates/harp/harp-macros/src/lib.rs

@@ -6,29 +6,37 @@
 //
 
 use proc_macro::TokenStream;
-use quote::ToTokens;
 use quote::format_ident;
 use quote::quote;
+use quote::ToTokens;
 
 extern crate proc_macro;
 
 fn invalid_parameter(stream: impl ToTokens) -> ! {
-    panic!("Invalid parameter `{}`: registered routines can only accept SEXP parameters.", stream.to_token_stream());
+    panic!(
+        "Invalid parameter `{}`: registered routines can only accept SEXP parameters.",
+        stream.to_token_stream()
+    );
 }
 
 fn invalid_return_type(stream: impl ToTokens) -> ! {
-    panic!("Invalid return type `{}`: registered routines must return a SEXP.", stream.to_token_stream());
+    panic!(
+        "Invalid return type `{}`: registered routines must return a SEXP.",
+        stream.to_token_stream()
+    );
 }
 
 fn invalid_extern(stream: impl ToTokens) -> ! {
-    panic!("Invalid signature `{}`: registered routines must be 'extern \"C\"'.", stream.to_token_stream());
+    panic!(
+        "Invalid signature `{}`: registered routines must be 'extern \"C\"'.",
+        stream.to_token_stream()
+    );
 }
 
 #[proc_macro_attribute]
 pub fn register(_attr: TokenStream, item: TokenStream) -> TokenStream {
-
     // Get metadata about the function being registered.
-    let function : syn::ItemFn = syn::parse(item).unwrap();
+    let function: syn::ItemFn = syn::parse(item).unwrap();
 
     // Make sure the function is 'extern "C"'.
     let abi = match function.sig.abi {
@@ -48,7 +56,6 @@ pub fn register(_attr: TokenStream, item: TokenStream) -> TokenStream {
 
     // Make sure that the function only accepts SEXPs.
     for input in function.sig.inputs.iter() {
-
         let pattern = match input {
             syn::FnArg::Typed(pattern) => pattern,
             syn::FnArg::Receiver(receiver) => invalid_parameter(receiver),
@@ -63,13 +70,12 @@ pub fn register(_attr: TokenStream, item: TokenStream) -> TokenStream {
         if value != "SEXP" {
             invalid_parameter(pattern);
         }
-
     }
 
     // Make sure that the function returns a SEXP.
     let ty = match function.sig.output {
         syn::ReturnType::Type(_, ref ty) => ty,
-        _ => invalid_return_type(function.sig.output)
+        _ => invalid_return_type(function.sig.output),
     };
 
     let stream = ty.into_token_stream();
@@ -97,7 +103,7 @@ pub fn register(_attr: TokenStream, item: TokenStream) -> TokenStream {
 
             unsafe {
                 harp::routines::add(R_CallMethodDef {
-                    name: (#name).as_ptr() as *const i8,
+                    name: (#name).as_ptr() as *const c_char,
                     fun: Some(::std::mem::transmute(#ident as *const ())),
                     numArgs: #nargs
                 });
@@ -110,5 +116,4 @@ pub fn register(_attr: TokenStream, item: TokenStream) -> TokenStream {
     // Put everything together.
     let all = quote! { #function #registration };
     all.into()
-
 }