bindgen 0.20.5

Automatically generates Rust FFI bindings to C and C++ libraries.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Common traits and types related to parsing our IR from Clang cursors.

use clang;
use ir::context::{BindgenContext, ItemId};
use ir::ty::TypeKind;

/// Not so much an error in the traditional sense, but a control flow message
/// when walking over Clang's AST with a cursor.
#[derive(Debug)]
pub enum ParseError {
    /// Recurse down the current AST node's children.
    Recurse,
    /// Continue on to the next sibling AST node, or back up to the parent's
    /// siblings if we've exhausted all of this node's siblings (and so on).
    Continue,
}

/// The result of parsing a Clang AST node.
#[derive(Debug)]
pub enum ParseResult<T> {
    /// We've already resolved this item before, here is the extant `ItemId` for
    /// it.
    AlreadyResolved(ItemId),

    /// This is a newly parsed item. If the cursor is `Some`, it points to the
    /// AST node where the new `T` was declared.
    New(T, Option<clang::Cursor>),
}

/// An intermediate representation "sub-item" (i.e. one of the types contained
/// inside an `ItemKind` variant) that can be parsed from a Clang cursor.
pub trait ClangSubItemParser: Sized {
    /// Attempt to parse this type from the given cursor.
    ///
    /// The fact that is a reference guarantees it's held by the context, and
    /// allow returning already existing types.
    fn parse(cursor: clang::Cursor,
             context: &mut BindgenContext)
             -> Result<ParseResult<Self>, ParseError>;
}

/// An intermediate representation item that can be parsed from a Clang cursor.
pub trait ClangItemParser: Sized {
    /// Parse this item from the given Clang cursor.
    fn parse(cursor: clang::Cursor,
             parent: Option<ItemId>,
             context: &mut BindgenContext)
             -> Result<ItemId, ParseError>;

    /// Parse this item from the given Clang type.
    fn from_ty(ty: &clang::Type,
               location: Option<clang::Cursor>,
               parent: Option<ItemId>,
               ctx: &mut BindgenContext)
               -> Result<ItemId, ParseError>;

    /// Identical to `from_ty`, but use the given `id` as the `ItemId` for the
    /// newly parsed item.
    fn from_ty_with_id(id: ItemId,
                       ty: &clang::Type,
                       location: Option<clang::Cursor>,
                       parent: Option<ItemId>,
                       ctx: &mut BindgenContext)
                       -> Result<ItemId, ParseError>;

    /// Parse this item from the given Clang type, or if we haven't resolved all
    /// the other items this one depends on, an unresolved reference.
    fn from_ty_or_ref(ty: clang::Type,
                      location: Option<clang::Cursor>,
                      parent_id: Option<ItemId>,
                      context: &mut BindgenContext)
                      -> ItemId;

    /// Identical to `from_ty_or_ref`, but use the given `potential_id` as the
    /// `ItemId` for the newly parsed item.
    fn from_ty_or_ref_with_id(potential_id: ItemId,
                              ty: clang::Type,
                              location: Option<clang::Cursor>,
                              parent_id: Option<ItemId>,
                              context: &mut BindgenContext)
                              -> ItemId;

    /// Create a named template type.
    fn named_type<S>(name: S,
                     parent: ItemId,
                     context: &mut BindgenContext)
                     -> ItemId
        where S: Into<String>;

    /// Identical to `named_type`, but use `id` as the resulting item's
    /// `ItemId`.
    fn named_type_with_id<S>(id: ItemId,
                             name: S,
                             parent: ItemId,
                             context: &mut BindgenContext)
                             -> ItemId
        where S: Into<String>;

    /// Create a builtin type.
    fn builtin_type(kind: TypeKind,
                    is_const: bool,
                    context: &mut BindgenContext)
                    -> ItemId;
}