Crate repr_c_pub_struct 

This is a library that is meant to help exporting Rust code to other languages by providing a parse_for_repr_c_pub_structs function. This function accepts a path to the crate root and recursively traverses all directories in src/** returning Vec<ParsedFile>.

Hierarchy of structs

Example

src/main.rs

use repr_c_pub_struct::parse_for_repr_c_pub_structs;

fn main() {
    let crate_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
    let repr_c_structs = parse_for_repr_c_pub_structs(crate_root.as_str());
    println!("{:#?}", repr_c_structs);
}

src/unused.rs

#[repr(C)]
pub struct Unused {
   // Test
}

Output on Windows

[
    ParsedFile {
        path: "...\\repr_c_pub_struct\\src\\lib.rs",
        repr_c_pub_structs: ReprCPubStructs(
            [],
        ),
    },
    ParsedFile {
        path: "...\\repr_c_pub_struct\\src\\main.rs",
        repr_c_pub_structs: ReprCPubStructs(
            [],
        ),
    },
    ParsedFile {
        path: "...\\repr_c_pub_struct\\src\\unused.rs",
        repr_c_pub_structs: ReprCPubStructs(
            [
                LineColumnEnds {
                    start_line: 1,
                    start_column: 0,
                    end_line: 4,
                    end_column: 1,
                },
            ],
        ),
    },
]

Note

The paths will be absolute. The prefixes have been deleted intentionally.

Integration with serde

Serde is an amazing framework for serializing and deserializing Rust data structures efficiently and generically. The following is a partial list of data formats that have been implemented for Serde by the community.

• JSON, the ubiquitous JavaScript Object Notation used by many HTTP APIs.
• Bincode, a compact binary format used for IPC within the Servo rendering engine.
• CBOR, a Concise Binary Object Representation designed for small message size without the need for version negotiation.
• YAML, a self-proclaimed human-friendly configuration language that ain’t markup language.
• MessagePack, an efficient binary format that resembles a compact JSON.
• TOML, a minimal configuration format used by Cargo.
• Pickle, a format common in the Python world.
• RON, a Rusty Object Notation.
• BSON, the data storage and network transfer format used by MongoDB.
• Avro, a binary format used within Apache Hadoop, with support for schema definition.
• JSON5, a superset of JSON including some productions from ES5.
• Postcard, a no_std and embedded-systems friendly compact binary format.
• URL query strings, in the x-www-form-urlencoded format.
• Envy, a way to deserialize environment variables into Rust structs. (deserialization only)
• Envy Store, a way to deserialize AWS Parameter Store parameters into Rust structs. (deserialization only)
• S-expressions, the textual representation of code and data used by the Lisp language family.
• D-Bus’s binary wire format.
• FlexBuffers, the schemaless cousin of Google’s FlatBuffers zero-copy serialization format.
• DynamoDB Items, the format used by rusoto_dynamodb to transfer data to and from DynamoDB.

F.A.Q.

• What are repr C pub structs? They are public structures that have #[repr(C)] outer attribute.
• Will this crate support other reprs (such as #[repr(Rust)])? No but some other crate might.

Structs

LineColumnEnds

The location information of an individual #[repr(C)] pub structure.

ParsedFile

ReprCPubStructs

Functions

is_repr_c_and_public

Checks if the given syn::ItemStruct is a #[repr(C)] pub structure.

parse_for_repr_c_pub_structs

Traverses all directories in crate_root/src/** filtering Rust source files, parsing them and returning a collection of location information of #[repc(C)] pub structures in each file.