cog_gen_rust/

lib.rs

mod format;

use std::fmt::Write;

use {
    heck::CamelCase,
    proc_macro2::{Ident, Span, TokenStream},
    quote::quote,
};

use cog_idl::{Function, Interface, Module, Parameter, Type, TypeModifier, TypeName};

use crate::format::format;

pub fn write_generated_header(code: &mut String) {
    writeln!(
        code,
        "// This file is automatically generated by cog-gen-c."
    )
    .unwrap();
    writeln!(code, "// It is not intended for manual editing.").unwrap();
    writeln!(code).unwrap();
}

/// Generates an unformatted rust module string.
pub fn generate_module(module: &Module) -> String {
    let tokens = generate_module_tokens(module);

    let mut code = String::new();
    write_generated_header(&mut code);
    write!(code, "{}", tokens).unwrap();

    code
}

/// Generates a rust module string formatted with a flawed internal formatter.
/// This function is meant for platforms without rustfmt, or if rustfmt isn't installed.
pub fn generate_module_formatted(module: &Module) -> String {
    let tokens = generate_module_tokens(module);

    let mut code = String::new();
    write_generated_header(&mut code);

    format(&mut code, tokens, 0);

    code
}

fn generate_module_tokens(module: &Module) -> TokenStream {
    let doc_code = if let Some(doc) = &module.documentation {
        quote! { #![doc = #doc] }
    } else {
        quote! {}
    };

    let interfaces_code: Vec<_> = module
        .interfaces
        .iter()
        .map(|i| generate_interface(i))
        .collect();

    quote! {
        #doc_code
        #(#interfaces_code)*
    }
}

fn generate_interface(interface: &Interface) -> TokenStream {
    let ident = Ident::new(&interface.name.to_camel_case(), Span::call_site());
    let doc_code = generate_doc(&interface.documentation);

    let function_fields_code: Vec<_> = interface
        .functions
        .iter()
        .map(|f| generate_function_field(f))
        .collect();

    let function_helpers_code: Vec<_> = interface
        .functions
        .iter()
        .map(|f| generate_function_helper(f))
        .collect();

    quote! {
        #[repr(C)]
        #doc_code
        pub struct #ident {
            #(#function_fields_code),*
        }

        impl #ident {
            #(#function_helpers_code)*
        }
    }
}

fn generate_function_field(function: &Function) -> TokenStream {
    let ident = Ident::new(&function.name, Span::call_site());

    let parameters_code: Vec<_> = function
        .parameters
        .iter()
        .map(|p| generate_function_field_parameter(p))
        .collect();

    let return_code = function
        .return_type
        .as_ref()
        .map(|r| {
            let return_type = generate_c_type(r);
            quote! { -> #return_type }
        })
        .unwrap_or(TokenStream::new());

    quote! {
        pub #ident: unsafe extern "C" fn( #(#parameters_code),* ) #return_code
    }
}

fn generate_function_field_parameter(parameter: &Parameter) -> TokenStream {
    let ident = Ident::new(&parameter.name, Span::call_site());
    let type_ = generate_c_type(&parameter.type_);

    quote! { #ident: #type_ }
}

fn generate_c_type(type_: &Type) -> TokenStream {
    // C types don't technically know about references, so use a pointer just to be sure
    let modifier = match type_.modifier {
        TypeModifier::None => unimplemented!(),
        TypeModifier::Pointer => quote! { *const },
        TypeModifier::Reference => quote! { *const },
    };

    match type_.type_name {
        TypeName::CString => quote! { #modifier std::os::raw::c_char },
        TypeName::Any => quote! { #modifier std::ffi::c_void },
    }
}

fn generate_function_helper(function: &Function) -> TokenStream {
    let ident = Ident::new(&function.name, Span::call_site());
    let doc_code = generate_doc(&function.documentation);

    let parameters_code: Vec<_> = function
        .parameters
        .iter()
        .map(|p| generate_function_helper_parameter(p))
        .collect();

    let return_code = function
        .return_type
        .as_ref()
        .map(|r| {
            let return_type = generate_rust_type(r);
            quote! { -> #return_type }
        })
        .unwrap_or(TokenStream::new());

    let conversions_code: Vec<_> = function
        .parameters
        .iter()
        .filter_map(|p| generate_conversion(p))
        .collect();

    let arguments_code: Vec<_> = function
        .parameters
        .iter()
        .map(|p| Ident::new(&p.name, Span::call_site()))
        .collect();

    quote! {
        #doc_code
        pub fn #ident(&self, #(#parameters_code),*) #return_code {
            unsafe {
                #(#conversions_code)*

                (self.#ident)(#(#arguments_code),*)
            }
        }
    }
}
fn generate_function_helper_parameter(parameter: &Parameter) -> TokenStream {
    let ident = Ident::new(&parameter.name, Span::call_site());
    let type_ = generate_rust_type(&parameter.type_);

    quote! { #ident: #type_ }
}

fn generate_rust_type(type_: &Type) -> TokenStream {
    let modifier = match type_.modifier {
        TypeModifier::None => unimplemented!(),
        TypeModifier::Pointer => quote! { *const },
        TypeModifier::Reference => quote! { & },
    };

    match type_.type_name {
        TypeName::CString => quote! { #modifier std::ffi::CStr },
        TypeName::Any => quote! { #modifier std::ffi::c_void },
    }
}

fn generate_conversion(parameter: &Parameter) -> Option<TokenStream> {
    let ident = Ident::new(&parameter.name, Span::call_site());

    if parameter.type_.type_name == TypeName::CString {
        Some(quote! { let #ident = #ident.as_ptr(); })
    } else {
        None
    }
}

fn generate_doc(doc: &Option<String>) -> TokenStream {
    if let Some(doc) = doc {
        quote! { #[doc = #doc] }
    } else {
        quote! {}
    }
}