cbindgen 0.29.2

A tool for generating C bindings to Rust code.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

#include <cstdarg>
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <new>

enum class C : uint32_t {
  X = 2,
  Y,
};

inline std::ostream& operator<<(std::ostream& stream, const C& instance) {
  switch (instance) {
    case C::X: stream << "X"; break;
    case C::Y: stream << "Y"; break;
  }
  return stream;
}

struct A {
  int32_t _0;

  friend std::ostream& operator<<(std::ostream& stream, const A& instance) {
    return stream << "{ " << "_0=" << instance._0 << " }";
  }
};

struct B {
  int32_t x;
  float y;

  friend std::ostream& operator<<(std::ostream& stream, const B& instance) {
    return stream << "{ " << "x=" << instance.x << ", "
                          << "y=" << instance.y << " }";
  }
};

struct D {
  uint8_t List;
  uintptr_t Of;
  B Things;

  friend std::ostream& operator<<(std::ostream& stream, const D& instance) {
    return stream << "{ " << "List=" << instance.List << ", "
                          << "Of=" << instance.Of << ", "
                          << "Things=" << instance.Things << " }";
  }
};

union F {
  enum class Tag : uint8_t {
    Foo,
    Bar,
    Baz,
  };

  friend std::ostream& operator<<(std::ostream& stream, const Tag& instance) {
    using Tag = F::Tag;
    switch (instance) {
      case Tag::Foo: stream << "Foo"; break;
      case Tag::Bar: stream << "Bar"; break;
      case Tag::Baz: stream << "Baz"; break;
    }
    return stream;
  }

  friend std::ostream& operator<<(std::ostream& stream, const F& instance) {
    using Tag = F::Tag;
    switch (instance.tag) {
      case Tag::Foo: stream << instance.foo; break;
      case Tag::Bar: stream << instance.bar; break;
      case Tag::Baz: stream << "Baz"; break;
    }
    return stream;
  }

  struct Foo_Body {
    Tag tag;
    int16_t _0;

    friend std::ostream& operator<<(std::ostream& stream, const Foo_Body& instance) {
      return stream << "{ " << "tag=" << instance.tag << ", "
                            << "_0=" << instance._0 << " }";
    }
  };

  struct Bar_Body {
    Tag tag;
    uint8_t x;
    int16_t y;

    friend std::ostream& operator<<(std::ostream& stream, const Bar_Body& instance) {
      return stream << "{ " << "tag=" << instance.tag << ", "
                            << "x=" << instance.x << ", "
                            << "y=" << instance.y << " }";
    }
  };

  struct {
    Tag tag;
  };
  Foo_Body foo;
  Bar_Body bar;
};

struct H {
  enum class Tag : uint8_t {
    Hello,
    There,
    Everyone,
  };

  friend std::ostream& operator<<(std::ostream& stream, const Tag& instance) {
    using Tag = H::Tag;
    switch (instance) {
      case Tag::Hello: stream << "Hello"; break;
      case Tag::There: stream << "There"; break;
      case Tag::Everyone: stream << "Everyone"; break;
    }
    return stream;
  }

  friend std::ostream& operator<<(std::ostream& stream, const H& instance) {
    using Tag = H::Tag;
    switch (instance.tag) {
      case Tag::Hello: stream << "Hello" << instance.hello; break;
      case Tag::There: stream << "There" << instance.there; break;
      case Tag::Everyone: stream << "Everyone"; break;
    }
    return stream;
  }

  struct Hello_Body {
    int16_t _0;

    friend std::ostream& operator<<(std::ostream& stream, const Hello_Body& instance) {
      return stream << "{ " << "_0=" << instance._0 << " }";
    }
  };

  struct There_Body {
    uint8_t x;
    int16_t y;

    friend std::ostream& operator<<(std::ostream& stream, const There_Body& instance) {
      return stream << "{ " << "x=" << instance.x << ", "
                            << "y=" << instance.y << " }";
    }
  };

  Tag tag;
  union {
    Hello_Body hello;
    There_Body there;
  };
};

struct I {
  enum class Tag : uint8_t {
    ThereAgain,
    SomethingElse,
  };

  struct ThereAgain_Body {
    uint8_t x;
    int16_t y;

    friend std::ostream& operator<<(std::ostream& stream, const ThereAgain_Body& instance) {
      return stream << "{ " << "x=" << instance.x << ", "
                            << "y=" << instance.y << " }";
    }
  };

  Tag tag;
  union {
    ThereAgain_Body there_again;
  };
};

extern "C" {

void root(A a, B b, C c, D d, F f, H h, I i);

}  // extern "C"