| Age | Commit message (Collapse) | Author |
|---|
|
Automatically detect libclang version when testing
Automatically detect libclang version when testing and use approppriate
expectation files.
Ref to issue #794.
|
|
Automatically detect libclang version when testing and use approppriate
expectation files. Ref issue #794.
|
|
Convenience to help developers catch this earlier, rather than only after
pushing a pull request.
|
|
- changing the Builder::no_unstable_rust method to the Builder::unstable_rust method
- changing the --no-unstable-rust flag to a --unstable-rust flag in src/options.rs
- changing bindgen-flags header in the test headers to remove the --no-unstable-rust flag
Fixes #757
|
|
Rather than having a tests that we only run if libclang >= 3.9, this makes the
test suite dynamically detect when we have different expectations for different
libclang versions. It does this by adding `tests/expectations/tests/libclang-$VERSION`
directories, and `testing_only_libclang_$VERSION` features that are consulted
when the usual expectation file does not exist.
Fixes #697
|
|
|
|
We should take any number of `// bindgen-$whatever` flags at the top of the
file. Only considering the first three lines of the file was confusing when I
tried adding new pragmas with an empty line between the new ones and old ones.
|
|
This is a temporary work around for issue #593 and this test failing on MacOS
because we don't currently handle when bindgen's target OS is not the same as
the emitted bindings' target OS.
|
|
The previous behavior was that it would reconfigure the builder to generate
bindings to the last header `Builder::header` was invoked with. This was not
what people would expect: they expected it to generate bindings for all of the
headers, and were accidentally misconfiguring their builders.
This is a breaking change, but moves us inline with users' expectations.
|
|
Signed-off-by: Emilio Cobos Álvarez <emilio@crisal.io>
|
|
string to a Builder
Currently the Builder API requires input as header files on disk. This allows
passing C source directly to clang using the existing UnsavedFile struct.
|
|
|
|
|
|
Implement `Default` trait
We need `Default` trait to handle so many auto generated fields when create new structure.
|
|
Added catch_unwind to catch panic at generator
Fixes #50
- Adds a `catch_unwind` to catch panic at binding generation.
- Prints out a more detailed message that points to the potential misuse of flags, when `generate()` fails.
- Added false-by-default `verbose` option flag to specify whether detailed message should be printed for the time being
- [x] Ran all test cases
- [x] Verified that correct error messages appear when bindings fail to generate
- [x] Verified use of verbose flag
- [x] Considered changes made by `cargo fmt`
r? @emilio
|
|
|
|
|
|
|
|
It parses interfaces and protocol but ignores base classes, and their
methods which don’t have arguments, the method signature is currently
ignored. Also you can pass objc class instances to C functions.
Next steps are inheritance/base classes, method signatures, properties,
categories. Then check with system headers what is missing.
|
|
|
|
- The root crate is the `bindgen` binary
- Rust-ify the test suite, no more subprocesses!
- Update Travis config to test both crates
|
|
Speed up running 'cargo test':
-Before: 2'17s
-After: 30s
Update to use new path:
Makefile, .travis.yml, CONTRIBUTING.md, tests/tests.rs
Delete unused expectation that fail to compile:
tests/expectations/moar_bitfields.rs
tests/expectations/variadic_template_args.rs
For every 'cargo test' run, the bindgen output where built.
We already test that the bindgen output match expectations/*.rs,
so there is no need to check it build unless the expectation is updated.
Move tests/expectations/*.rs to tests/expectations/tests/*.rs and make
tests/expectations a new dev-dependency package. This allow running:
- cargo test -p tests_expectations
In addition to the speed up, we also get a clean output for the build
and test run. In particular, a number of warnings are generated that should
probably be silenced, and eventually enforced modifying travis to build:
- RUSTFLAGS='-D warnings' cargo test -p tests_expectations
The benefit of having it as a new package is that it avoid polluting
the 'cargo test' output that should focus on bindgen.
|
|
This extends the test runner to generate dummy C/C++ uses of the whitelisted
types in a test header in the tests/uses/ directory. It does not yet compile the
dummy uses into an object file whose DWARF debug info can be compared against
our Rust bindings' DWARF debug info.
Part of #151.
|
|
Run tests on release builds
This makes `cargo test` test the appropriate release/debug bindgen binary and extends Travis CI testing to also test release builds.
r? @emilio
|
|
|
|
|
|
Follow review suggestion to use chunks to run test in parallel.
Set default to 16 which works well even on my limited laptop,
and which should benefit better machine.
To run with a different batch size:
BINDGEN_TEST_BATCH_SIZE=32 cargo test
On my machine:
1 parallel test takes 3'53
2 parallel test takes 2'10
8 parallel test takes 2'08
32 parallel test takes 2'07
|
|
When running all the test in parallel, all the memory on my laptop
is consumed by rustc processes, my machine become unusable and the
tests do not make progress.
It seems to make sense to have serial by default, as the number of
process depends on the number of test files.
|
|
|
|
This adds the ability for tests to supply required features, and if the
bindgen we're testing was not built with those features, then the test
will be skipped. The syntax used to require features is like this:
// bindgen-features: llvm_stable some_experiment another
|
|
Fixes #51
|
|
|
|
Generate better enums
Squash of...
Disable prefixing
Default to failing on unknown types
Add support for Char16
Emit errors for unknown cursor kinds
Hack in support for classes
Recurse into unexposed decls
This fixes functions that use extern "C".
Add support for generating unmangled functions
Prefix unnamed data structures with the file name
Recurse into namespaced things
Avoid rust reserved keywords in unmangle func args
Don't create variadic unmangled funcs
Don't translate typedefs to the same name
Ignore operator overloads
Avoid templates
Handle class declarations
Number duplicate demangle functions
Implement copy on enums
Translate stdint types into standard rust int types
Switch enums to i32 for better compatibility
Correctly deal with mangled functions with unnamed args
Mark unmangling functions as unsafe
Attempt to produce structs for C++ classes
Convert references
Generate better func decls for void returns
Make every function callback unsafe
Add support for generics in typedefs
Add support for class templates
Aggressively trim duplicates
Don't generate default impl for templates
Improve handling of templates
Fix function numbering
Fix deduplication
Make unmangling functions extern "C"
Convert all int/float typedefs to standard rust ints/floats
This also gives better information to the bitfield parsing and allows uint32_t and other stdint bitfields to be processed properly
Add support for wchar
Add support for bitfield setter generation
Fix floats
Squash of...
Shorten generated bitfield names
Add support for generating whole bitfields
Add support for enums nested inside structs/classes
Rustup
Fixes #184.
Rustup to b301e02f3 2015-05-19
Inline demangling functions
Add support for base classes/types
Generate bindings for methods
Make duplicate detection less aggressive
Avoid converting long/unsigned longs to rust types.
This fixes 64/32bit issues in structs.
Generate bitfields correctly for typedefs
Convert stdint types to rust types
Derive Debug on BindgenOptions, Bindings, and LinkType.
Remove +'static when writing bindings
Generate virtual function tables
Resolve some warnings
Add NotConst where Constness params are required
Generate real bools when applicable
Squash of...
Add support for comments
Improve bitfield support using const fn
Add limited support for references
Add comments to fields
Don't generate empty comments
Convert char16_t to u16 rather than i16
Convert signed chars to libc::c_char
Fix Cargo.toml rebasing breakage
Fix compiler errors
This gets bindgen to compile and run again, but all but one `cargo
test` tests fail. Not sure if that’s because of mistakes on my part or
if the sm-hacks branch never passed those tests.
Fix build warnings
Use link_name attr for mangled function names
Handle mangled global vars
Only generate bindings for visible symbols
Don't generate arrays for blobs when the length is 1
Name enums inside classes better
Handle template args inside typedefs better
Filter out duplicate decls better
Generate correctly sized enums
Squash of...
Fix bitfield accessor method generation for bools
Insert phantom fields in empty structs
Don't mark unmangling methods as extern "C"
Add back comment support for functions
Add basic annotation support
Don't generate univariant enums
Add support for hide annotation and adjust syntax
Don't generate unsupported structs
Don't parse hidden fields
Don't derive Copy for structs with destructors
Don't implement Clone or Default
Derive Clone when deriving Copy
Bypass single member unions
Disable references in function args for now
Remove extra underscore in mangled names on OSX
Don't translate private methods
Support generating consts from macros that are defined as integer literals.
Handle mangling better
Squash of...
Update README.md for fork
Generate docs for enum items
Generate docs for typedefs
Generate docs for enums
Update syntex_syntax to 0.24.*
Update clang info in README.md
Spit errors and warnings to stdout.
The correct thing to do here is to use env_logger, but that was causing cargo
troubles for me, and this is preferable to swallowing them.
Add the -ignore-functions argument.
Handle 1 << 63 as enum value.
Don't try to convert standard int types in rust_type_id.
It looks like mwu added this, but I'm pretty sure it's a category error. This
function appears to be designed to reproducibly permute C identifiers so that
they don't conflict with builtin rust types. It's specifically _not_ a type
translator (which would happen at the type level, rather than the string
level), and using it as such with callers like ctypedef_to_rs causes us to
generate things like:
type u64 = u64;
While processing stdint.h, which is clearly wrong.
Stop patching in placeholder names for CompInfo and EnumInfo instances during code generator.
As best as I can tell, it's done this way (rather than my way) because bindgen tries
to recognize struct and enums typedefs of the form:
/* This is a common idiom in C, not so much in C++ */
typdef struct {
...
} Foo;
The intention, I think, is to avoid generating rust code for a struct with a placeholder
name followed by a typedef, and just give the struct the right name initially.
This seems like a reasonable goal, though not a particularly important one. However, in
my testing this never actually happens, because we end up calling unnamed_name anyway
during the GComp(ci) case of gen_mod before we get to evaluting the typedef.
So let's just remove that stuff and simplify the code. This lets us remove all the
borrow_mut calls during code generation, which seems necessary for soundness.
gen: Allow empty union members
Use full paths in generation.
Fix test compilation
parser: Add support for parsing namespaces
Partial C++ namespaces support
We currently generate the modules as expected, but we don't resolve the
names from external namespaces well.
Remove unnecesary return statements
Put namespaces behind a flag
Overall now that they aren't complete still.
Moar refactoring
Finally take rid of all the warnings
Even moar
gen: Avoid so much cloning
parser: Refactor the way submodules are stored
This way we can share the global map, while having each module custom
globals.
gen: Checkpoint before the refactoring
This actually keeps working as before.
gen: Make modules (almost) work for typedef'd types
We generate almost valid code, we just have to add some use statements.
Or maybe is a better idea to add an unintelligible name to the root
mod, and actually output a root mod plus a use root::* before.
gen: Document the current submodule approach and some desirable
alternative
gen: Make it actually compilable \o/
gen: Make the code generation usable for every type.
There's just an edge case I've detected, and it's when we remove the
instantiation of C<int>, and another module uses it, because that means
we only know of its existance in that other module.
Probably we might want to use cursor_getSemanticParent to get the real
class instead of the instantiated, but I'm not too confident about that.
Fix a corner case when a template was instantiated in another module.
Added an example of the namespace resolution.
Don't panic when not finding the specialised template
This can be annoying if filtering files out.
Straight rebase completed, let's fix that build errors
wip
Pair up with master
nits
Update AST
Add -no-rename-fields option
This is for compatibility between C bindings and C++ bindings (in C
`struct Foo` and `enum Foo`, are different, while in C++ they aren't).
wip
Add enum tests pass, and add C++ tests
Make a few more struct-related tests pass
|
|
|
|
Recurse into unexposed decls
|
|
This fixes functions that use extern "C".
|
|
Duplicate values end up as constants of the same enum type. Most enums
are repr(u32) as they should, except for those with attribute((packed)),
which are of the smallest representation possible.
|
|
|
|
|
|
|
|
Fixes #184.
|
|
clang.rs
- Remove Box<_> from the signature of Cursor.visit. This makes the
implementation a little noisier, but makes calling easier.
tests
- Updated for recent changes to rustc and std.
|
|
|
|
Conflicts:
src/parser.rs
tests/forward_declared_struct.rs
tests/test_struct.rs
|
|
Fixes #79. Fixes #100.
Cargo.toml
- Adds `[[test]]` section pointing to tests.rs, where all former tests are
now imported as modules (cf Servo's tests).
gen.rs
- Breaks up `TFunc` handling into `TFuncPtr` and `TFuncProto`.
- Eliminates empty `extern "C" { }` block that was sometimes generated.
lib.rs
- Eliminates `dead_code` warnings and one about `LinkType` being able to
implement `Copy`.
parser.rs
- Breaks up function handling into `TFuncPtr` and `TFuncProto`.
- Uses the `FuncSig` type to capture information about function
signatures.
- Adds support for pointers to arrays at the global scope.
types.rs
- Adds types related to function prototype and pointer handling:
`FuncSig`, `TFuncPtr` and `TFuncProto`.
tests
- Adds quote-based testing. Using the `assert_bind_eq!` macro, it is
now possible--without too much ceremony--to test bindgen output of an
input file against inline source created with the `quote_item!` (and
other `quote_*` macros).
- Removes stringify-based testing.
- Combines test running into a single entry point, `test.rs`.
- Shortens test names where possible without losing context.
|
