Return true if the env is set to a value other than `0`.

Return the file extension of the programming language.

Search for the target to build for, specified manually or through an environment variable. This function will check the following places for the targ

Add a header to be included as part of the generated C file, as well as defines for it. The generated C test will be compiled by a C compiler, and th

True if this type is added to the RHS in a cdecl (arrays, function pointers).

Executes a command, returning stdout and stderr combined and it's status.

Configures the name of a function in the generated C code. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(); cfg.r

Run `rustc --version` and capture the output, adjusting arguments as needed if `clippy-driver` is used instead.

Configures whether tests for a C enum are generated. A C enum consists of a type alias, as well as constants that have the same type. Tests for both

Non public items are not tested if `skip` is `true`. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(); cfg.skip_pr

Configures the target to compile C code for. Note that for Cargo builds this defaults to `$TARGET` and it's not necessary to call. # Examples ```no

This also covers the L4Re targets since they have a similar API surface

This function tests APIs that are incompatible to test when other APIs are included (e.g. because including both sets of headers clashes)

Attempt to execute a command and collect its output, If the command fails for whatever reason, return `None`.

Indicate that a function argument should be marked `volatile`. # Examples ```no_run use ctest::{TestGenerator, VolatileItemKind}; let mut cfg = Tes

Indicate that a function's return type should be marked `volatile`. # Examples ```no_run use ctest::{TestGenerator, VolatileItemKind}; let mut cfg

Indicate that a static should be marked `volatile`. # Examples ```no_run use ctest::{TestGenerator, VolatileItemKind}; let mut cfg = TestGenerator:

Print commands before running them.

Define a function that returns a pointer to the value of the constant to test. This will later be called on the Rust side via FFI.

Indicate that a function pointer argument is an array. This closure should return true if a pointer argument to a function should be generated with `

C declarations are read from the declaration out, left to right, switching directions when a `)` is hit. So, to reverse this, we build from the declar

Ensure there are no duplicate targets in the list.

Reads and parses the file at the given path and checks for any style violations.

Validate that we aren't returning an array or a function without indirection, which isn't allowed in C.

Check that the value returned from the Rust and C side in a certain test is equivalent. Internally it will remember which checks failed and how many

Test that the string constant is the same in both Rust and C. While fat pointers can't be translated, we instead of * const c_char.

Return a list of all constants found.

Return whether the type has parsed a struct with the given identifier.

Return whether the type has parsed a union with the given identifier.