更新libclamav库1.0.0版本

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.both.c

@@ -0,0 +1,37 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Status {
+  Ok,
+  Err,
+};
+typedef uint32_t Status;
+
+typedef struct Dep {
+  int32_t a;
+  float b;
+} Dep;
+
+typedef struct Foo_i32 {
+  int32_t a;
+  int32_t b;
+  struct Dep c;
+} Foo_i32;
+
+typedef struct Foo_i32 IntFoo;
+
+typedef struct Foo_f64 {
+  double a;
+  double b;
+  struct Dep c;
+} Foo_f64;
+
+typedef struct Foo_f64 DoubleFoo;
+
+typedef int32_t Unit;
+
+typedef Status SpecialStatus;
+
+void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.both.compat.c

@@ -0,0 +1,51 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Status
+#ifdef __cplusplus
+  : uint32_t
+#endif // __cplusplus
+ {
+  Ok,
+  Err,
+};
+#ifndef __cplusplus
+typedef uint32_t Status;
+#endif // __cplusplus
+
+typedef struct Dep {
+  int32_t a;
+  float b;
+} Dep;
+
+typedef struct Foo_i32 {
+  int32_t a;
+  int32_t b;
+  struct Dep c;
+} Foo_i32;
+
+typedef struct Foo_i32 IntFoo;
+
+typedef struct Foo_f64 {
+  double a;
+  double b;
+  struct Dep c;
+} Foo_f64;
+
+typedef struct Foo_f64 DoubleFoo;
+
+typedef int32_t Unit;
+
+typedef Status SpecialStatus;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.c

@@ -0,0 +1,37 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Status {
+  Ok,
+  Err,
+};
+typedef uint32_t Status;
+
+typedef struct {
+  int32_t a;
+  float b;
+} Dep;
+
+typedef struct {
+  int32_t a;
+  int32_t b;
+  Dep c;
+} Foo_i32;
+
+typedef Foo_i32 IntFoo;
+
+typedef struct {
+  double a;
+  double b;
+  Dep c;
+} Foo_f64;
+
+typedef Foo_f64 DoubleFoo;
+
+typedef int32_t Unit;
+
+typedef Status SpecialStatus;
+
+void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.compat.c

@@ -0,0 +1,51 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Status
+#ifdef __cplusplus
+  : uint32_t
+#endif // __cplusplus
+ {
+  Ok,
+  Err,
+};
+#ifndef __cplusplus
+typedef uint32_t Status;
+#endif // __cplusplus
+
+typedef struct {
+  int32_t a;
+  float b;
+} Dep;
+
+typedef struct {
+  int32_t a;
+  int32_t b;
+  Dep c;
+} Foo_i32;
+
+typedef Foo_i32 IntFoo;
+
+typedef struct {
+  double a;
+  double b;
+  Dep c;
+} Foo_f64;
+
+typedef Foo_f64 DoubleFoo;
+
+typedef int32_t Unit;
+
+typedef Status SpecialStatus;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.cpp

@@ -0,0 +1,36 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+enum class Status : uint32_t {
+  Ok,
+  Err,
+};
+
+struct Dep {
+  int32_t a;
+  float b;
+};
+
+template<typename X>
+struct Foo {
+  X a;
+  X b;
+  Dep c;
+};
+
+using IntFoo = Foo<int32_t>;
+
+using DoubleFoo = Foo<double>;
+
+using Unit = int32_t;
+
+using SpecialStatus = Status;
+
+extern "C" {
+
+void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.pyx

@@ -0,0 +1,36 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef enum:
+    Ok,
+    Err,
+  ctypedef uint32_t Status;
+
+  ctypedef struct Dep:
+    int32_t a;
+    float b;
+
+  ctypedef struct Foo_i32:
+    int32_t a;
+    int32_t b;
+    Dep c;
+
+  ctypedef Foo_i32 IntFoo;
+
+  ctypedef struct Foo_f64:
+    double a;
+    double b;
+    Dep c;
+
+  ctypedef Foo_f64 DoubleFoo;
+
+  ctypedef int32_t Unit;
+
+  ctypedef Status SpecialStatus;
+
+  void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.tag.c

@@ -0,0 +1,37 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Status {
+  Ok,
+  Err,
+};
+typedef uint32_t Status;
+
+struct Dep {
+  int32_t a;
+  float b;
+};
+
+struct Foo_i32 {
+  int32_t a;
+  int32_t b;
+  struct Dep c;
+};
+
+typedef struct Foo_i32 IntFoo;
+
+struct Foo_f64 {
+  double a;
+  double b;
+  struct Dep c;
+};
+
+typedef struct Foo_f64 DoubleFoo;
+
+typedef int32_t Unit;
+
+typedef Status SpecialStatus;
+
+void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.tag.compat.c

@@ -0,0 +1,51 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Status
+#ifdef __cplusplus
+  : uint32_t
+#endif // __cplusplus
+ {
+  Ok,
+  Err,
+};
+#ifndef __cplusplus
+typedef uint32_t Status;
+#endif // __cplusplus
+
+struct Dep {
+  int32_t a;
+  float b;
+};
+
+struct Foo_i32 {
+  int32_t a;
+  int32_t b;
+  struct Dep c;
+};
+
+typedef struct Foo_i32 IntFoo;
+
+struct Foo_f64 {
+  double a;
+  double b;
+  struct Dep c;
+};
+
+typedef struct Foo_f64 DoubleFoo;
+
+typedef int32_t Unit;
+
+typedef Status SpecialStatus;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/alias.tag.pyx

@@ -0,0 +1,36 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef enum:
+    Ok,
+    Err,
+  ctypedef uint32_t Status;
+
+  cdef struct Dep:
+    int32_t a;
+    float b;
+
+  cdef struct Foo_i32:
+    int32_t a;
+    int32_t b;
+    Dep c;
+
+  ctypedef Foo_i32 IntFoo;
+
+  cdef struct Foo_f64:
+    double a;
+    double b;
+    Dep c;
+
+  ctypedef Foo_f64 DoubleFoo;
+
+  ctypedef int32_t Unit;
+
+  ctypedef Status SpecialStatus;
+
+  void root(IntFoo x, DoubleFoo y, Unit z, SpecialStatus w);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.both.c

@@ -0,0 +1,65 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum C {
+  X = 2,
+  Y,
+};
+typedef uint32_t C;
+
+typedef struct A {
+  int32_t m0;
+} A;
+
+typedef struct B {
+  int32_t x;
+  float y;
+} B;
+
+enum F_Tag {
+  Foo,
+  Bar,
+  Baz,
+};
+typedef uint8_t F_Tag;
+
+typedef struct Bar_Body {
+  F_Tag tag;
+  uint8_t x;
+  int16_t y;
+} Bar_Body;
+
+typedef union F {
+  F_Tag tag;
+  struct {
+    F_Tag foo_tag;
+    int16_t foo;
+  };
+  Bar_Body bar;
+} F;
+
+enum H_Tag {
+  Hello,
+  There,
+  Everyone,
+};
+typedef uint8_t H_Tag;
+
+typedef struct There_Body {
+  uint8_t x;
+  int16_t y;
+} There_Body;
+
+typedef struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t hello;
+    };
+    There_Body there;
+  };
+} H;
+
+void root(struct A x, struct B y, C z, union F f, struct H h);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.both.compat.c

@@ -0,0 +1,91 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum C
+#ifdef __cplusplus
+  : uint32_t
+#endif // __cplusplus
+ {
+  X = 2,
+  Y,
+};
+#ifndef __cplusplus
+typedef uint32_t C;
+#endif // __cplusplus
+
+typedef struct A {
+  int32_t m0;
+} A;
+
+typedef struct B {
+  int32_t x;
+  float y;
+} B;
+
+enum F_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  Foo,
+  Bar,
+  Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t F_Tag;
+#endif // __cplusplus
+
+typedef struct Bar_Body {
+  F_Tag tag;
+  uint8_t x;
+  int16_t y;
+} Bar_Body;
+
+typedef union F {
+  F_Tag tag;
+  struct {
+    F_Tag foo_tag;
+    int16_t foo;
+  };
+  Bar_Body bar;
+} F;
+
+enum H_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  Hello,
+  There,
+  Everyone,
+};
+#ifndef __cplusplus
+typedef uint8_t H_Tag;
+#endif // __cplusplus
+
+typedef struct There_Body {
+  uint8_t x;
+  int16_t y;
+} There_Body;
+
+typedef struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t hello;
+    };
+    There_Body there;
+  };
+} H;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct A x, struct B y, C z, union F f, struct H h);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.c

@@ -0,0 +1,65 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum C {
+  X = 2,
+  Y,
+};
+typedef uint32_t C;
+
+typedef struct {
+  int32_t m0;
+} A;
+
+typedef struct {
+  int32_t x;
+  float y;
+} B;
+
+enum F_Tag {
+  Foo,
+  Bar,
+  Baz,
+};
+typedef uint8_t F_Tag;
+
+typedef struct {
+  F_Tag tag;
+  uint8_t x;
+  int16_t y;
+} Bar_Body;
+
+typedef union {
+  F_Tag tag;
+  struct {
+    F_Tag foo_tag;
+    int16_t foo;
+  };
+  Bar_Body bar;
+} F;
+
+enum H_Tag {
+  Hello,
+  There,
+  Everyone,
+};
+typedef uint8_t H_Tag;
+
+typedef struct {
+  uint8_t x;
+  int16_t y;
+} There_Body;
+
+typedef struct {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t hello;
+    };
+    There_Body there;
+  };
+} H;
+
+void root(A x, B y, C z, F f, H h);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.compat.c

@@ -0,0 +1,91 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum C
+#ifdef __cplusplus
+  : uint32_t
+#endif // __cplusplus
+ {
+  X = 2,
+  Y,
+};
+#ifndef __cplusplus
+typedef uint32_t C;
+#endif // __cplusplus
+
+typedef struct {
+  int32_t m0;
+} A;
+
+typedef struct {
+  int32_t x;
+  float y;
+} B;
+
+enum F_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  Foo,
+  Bar,
+  Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t F_Tag;
+#endif // __cplusplus
+
+typedef struct {
+  F_Tag tag;
+  uint8_t x;
+  int16_t y;
+} Bar_Body;
+
+typedef union {
+  F_Tag tag;
+  struct {
+    F_Tag foo_tag;
+    int16_t foo;
+  };
+  Bar_Body bar;
+} F;
+
+enum H_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  Hello,
+  There,
+  Everyone,
+};
+#ifndef __cplusplus
+typedef uint8_t H_Tag;
+#endif // __cplusplus
+
+typedef struct {
+  uint8_t x;
+  int16_t y;
+} There_Body;
+
+typedef struct {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t hello;
+    };
+    There_Body there;
+  };
+} H;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(A x, B y, C z, F f, H h);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.cpp

@@ -0,0 +1,152 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+enum class C : uint32_t {
+  X = 2,
+  Y,
+};
+
+struct A {
+  int32_t m0;
+
+  A(int32_t const& m0)
+    : m0(m0)
+  {}
+
+  bool operator<(const A& other) const {
+    return m0 < other.m0;
+  }
+  bool operator<=(const A& other) const {
+    return m0 <= other.m0;
+  }
+};
+
+struct B {
+  int32_t x;
+  float y;
+};
+
+union F {
+  enum class Tag : uint8_t {
+    Foo,
+    Bar,
+    Baz,
+  };
+
+  struct Foo_Body {
+    Tag tag;
+    int16_t _0;
+  };
+
+  struct Bar_Body {
+    Tag tag;
+    uint8_t x;
+    int16_t y;
+  };
+
+  struct {
+    Tag tag;
+  };
+  Foo_Body foo;
+  Bar_Body bar;
+
+  static F Foo(const int16_t &_0) {
+    F result;
+    ::new (&result.foo._0) (int16_t)(_0);
+    result.tag = Tag::Foo;
+    return result;
+  }
+
+  bool IsFoo() const {
+    return tag == Tag::Foo;
+  }
+
+  static F Bar(const uint8_t &x,
+               const int16_t &y) {
+    F result;
+    ::new (&result.bar.x) (uint8_t)(x);
+    ::new (&result.bar.y) (int16_t)(y);
+    result.tag = Tag::Bar;
+    return result;
+  }
+
+  bool IsBar() const {
+    return tag == Tag::Bar;
+  }
+
+  static F Baz() {
+    F result;
+    result.tag = Tag::Baz;
+    return result;
+  }
+
+  bool IsBaz() const {
+    return tag == Tag::Baz;
+  }
+};
+
+struct H {
+  enum class Tag : uint8_t {
+    Hello,
+    There,
+    Everyone,
+  };
+
+  struct Hello_Body {
+    int16_t _0;
+  };
+
+  struct There_Body {
+    uint8_t x;
+    int16_t y;
+  };
+
+  Tag tag;
+  union {
+    Hello_Body hello;
+    There_Body there;
+  };
+
+  static H Hello(const int16_t &_0) {
+    H result;
+    ::new (&result.hello._0) (int16_t)(_0);
+    result.tag = Tag::Hello;
+    return result;
+  }
+
+  bool IsHello() const {
+    return tag == Tag::Hello;
+  }
+
+  static H There(const uint8_t &x,
+                 const int16_t &y) {
+    H result;
+    ::new (&result.there.x) (uint8_t)(x);
+    ::new (&result.there.y) (int16_t)(y);
+    result.tag = Tag::There;
+    return result;
+  }
+
+  bool IsThere() const {
+    return tag == Tag::There;
+  }
+
+  static H Everyone() {
+    H result;
+    result.tag = Tag::Everyone;
+    return result;
+  }
+
+  bool IsEveryone() const {
+    return tag == Tag::Everyone;
+  }
+};
+
+extern "C" {
+
+void root(A x, B y, C z, F f, H h);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.pyx

@@ -0,0 +1,53 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef enum:
+    X # = 2,
+    Y,
+  ctypedef uint32_t C;
+
+  ctypedef struct A:
+    int32_t m0;
+
+  ctypedef struct B:
+    int32_t x;
+    float y;
+
+  cdef enum:
+    Foo,
+    Bar,
+    Baz,
+  ctypedef uint8_t F_Tag;
+
+  ctypedef struct Bar_Body:
+    F_Tag tag;
+    uint8_t x;
+    int16_t y;
+
+  ctypedef union F:
+    F_Tag tag;
+    F_Tag foo_tag;
+    int16_t foo;
+    Bar_Body bar;
+
+  cdef enum:
+    Hello,
+    There,
+    Everyone,
+  ctypedef uint8_t H_Tag;
+
+  ctypedef struct There_Body:
+    uint8_t x;
+    int16_t y;
+
+  ctypedef struct H:
+    H_Tag tag;
+    int16_t hello;
+    There_Body there;
+
+  void root(A x, B y, C z, F f, H h);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.tag.c

@@ -0,0 +1,65 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum C {
+  X = 2,
+  Y,
+};
+typedef uint32_t C;
+
+struct A {
+  int32_t m0;
+};
+
+struct B {
+  int32_t x;
+  float y;
+};
+
+enum F_Tag {
+  Foo,
+  Bar,
+  Baz,
+};
+typedef uint8_t F_Tag;
+
+struct Bar_Body {
+  F_Tag tag;
+  uint8_t x;
+  int16_t y;
+};
+
+union F {
+  F_Tag tag;
+  struct {
+    F_Tag foo_tag;
+    int16_t foo;
+  };
+  struct Bar_Body bar;
+};
+
+enum H_Tag {
+  Hello,
+  There,
+  Everyone,
+};
+typedef uint8_t H_Tag;
+
+struct There_Body {
+  uint8_t x;
+  int16_t y;
+};
+
+struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t hello;
+    };
+    struct There_Body there;
+  };
+};
+
+void root(struct A x, struct B y, C z, union F f, struct H h);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.tag.compat.c

@@ -0,0 +1,91 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum C
+#ifdef __cplusplus
+  : uint32_t
+#endif // __cplusplus
+ {
+  X = 2,
+  Y,
+};
+#ifndef __cplusplus
+typedef uint32_t C;
+#endif // __cplusplus
+
+struct A {
+  int32_t m0;
+};
+
+struct B {
+  int32_t x;
+  float y;
+};
+
+enum F_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  Foo,
+  Bar,
+  Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t F_Tag;
+#endif // __cplusplus
+
+struct Bar_Body {
+  F_Tag tag;
+  uint8_t x;
+  int16_t y;
+};
+
+union F {
+  F_Tag tag;
+  struct {
+    F_Tag foo_tag;
+    int16_t foo;
+  };
+  struct Bar_Body bar;
+};
+
+enum H_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  Hello,
+  There,
+  Everyone,
+};
+#ifndef __cplusplus
+typedef uint8_t H_Tag;
+#endif // __cplusplus
+
+struct There_Body {
+  uint8_t x;
+  int16_t y;
+};
+
+struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t hello;
+    };
+    struct There_Body there;
+  };
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct A x, struct B y, C z, union F f, struct H h);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/annotation.tag.pyx

@@ -0,0 +1,53 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef enum:
+    X # = 2,
+    Y,
+  ctypedef uint32_t C;
+
+  cdef struct A:
+    int32_t m0;
+
+  cdef struct B:
+    int32_t x;
+    float y;
+
+  cdef enum:
+    Foo,
+    Bar,
+    Baz,
+  ctypedef uint8_t F_Tag;
+
+  cdef struct Bar_Body:
+    F_Tag tag;
+    uint8_t x;
+    int16_t y;
+
+  cdef union F:
+    F_Tag tag;
+    F_Tag foo_tag;
+    int16_t foo;
+    Bar_Body bar;
+
+  cdef enum:
+    Hello,
+    There,
+    Everyone,
+  ctypedef uint8_t H_Tag;
+
+  cdef struct There_Body:
+    uint8_t x;
+    int16_t y;
+
+  cdef struct H:
+    H_Tag tag;
+    int16_t hello;
+    There_Body there;
+
+  void root(A x, B y, C z, F f, H h);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.both.c

@@ -0,0 +1,19 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum Foo_Tag {
+  A,
+} Foo_Tag;
+
+typedef struct Foo {
+  Foo_Tag tag;
+  union {
+    struct {
+      float a[20];
+    };
+  };
+} Foo;
+
+void root(struct Foo a);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.both.compat.c

@@ -0,0 +1,27 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum Foo_Tag {
+  A,
+} Foo_Tag;
+
+typedef struct Foo {
+  Foo_Tag tag;
+  union {
+    struct {
+      float a[20];
+    };
+  };
+} Foo;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct Foo a);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.c

@@ -0,0 +1,19 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum {
+  A,
+} Foo_Tag;
+
+typedef struct {
+  Foo_Tag tag;
+  union {
+    struct {
+      float a[20];
+    };
+  };
+} Foo;
+
+void root(Foo a);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.compat.c

@@ -0,0 +1,27 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum {
+  A,
+} Foo_Tag;
+
+typedef struct {
+  Foo_Tag tag;
+  union {
+    struct {
+      float a[20];
+    };
+  };
+} Foo;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(Foo a);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.cpp

@@ -0,0 +1,39 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+struct Foo {
+  enum class Tag {
+    A,
+  };
+
+  struct A_Body {
+    float _0[20];
+  };
+
+  Tag tag;
+  union {
+    A_Body a;
+  };
+
+  static Foo A(const float (&_0)[20]) {
+    Foo result;
+    for (int i = 0; i < 20; i++) {
+      ::new (&result.a._0[i]) (float)(_0[i]);
+    }
+    result.tag = Tag::A;
+    return result;
+  }
+
+  bool IsA() const {
+    return tag == Tag::A;
+  }
+};
+
+extern "C" {
+
+void root(Foo a);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.pyx

@@ -0,0 +1,16 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef enum Foo_Tag:
+    A,
+
+  ctypedef struct Foo:
+    Foo_Tag tag;
+    float a[20];
+
+  void root(Foo a);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.tag.c

@@ -0,0 +1,19 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Foo_Tag {
+  A,
+};
+
+struct Foo {
+  enum Foo_Tag tag;
+  union {
+    struct {
+      float a[20];
+    };
+  };
+};
+
+void root(struct Foo a);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.tag.compat.c

@@ -0,0 +1,27 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum Foo_Tag {
+  A,
+};
+
+struct Foo {
+  enum Foo_Tag tag;
+  union {
+    struct {
+      float a[20];
+    };
+  };
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct Foo a);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/array.tag.pyx

@@ -0,0 +1,16 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef enum Foo_Tag:
+    A,
+
+  cdef struct Foo:
+    Foo_Tag tag;
+    float a[20];
+
+  void root(Foo a);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.both.c

@@ -0,0 +1,78 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct I I;
+
+enum H_Tag {
+  H_Foo,
+  H_Bar,
+  H_Baz,
+};
+typedef uint8_t H_Tag;
+
+typedef struct H_Bar_Body {
+  uint8_t x;
+  int16_t y;
+} H_Bar_Body;
+
+typedef struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    H_Bar_Body bar;
+  };
+} H;
+
+enum J_Tag {
+  J_Foo,
+  J_Bar,
+  J_Baz,
+};
+typedef uint8_t J_Tag;
+
+typedef struct J_Bar_Body {
+  uint8_t x;
+  int16_t y;
+} J_Bar_Body;
+
+typedef struct J {
+  J_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    J_Bar_Body bar;
+  };
+} J;
+
+enum K_Tag {
+  K_Foo,
+  K_Bar,
+  K_Baz,
+};
+typedef uint8_t K_Tag;
+
+typedef struct K_Bar_Body {
+  K_Tag tag;
+  uint8_t x;
+  int16_t y;
+} K_Bar_Body;
+
+typedef union K {
+  K_Tag tag;
+  struct {
+    K_Tag foo_tag;
+    int16_t foo;
+  };
+  K_Bar_Body bar;
+} K;
+
+void foo(struct H h, struct I i, struct J j, union K k);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.both.compat.c

@@ -0,0 +1,104 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct I I;
+
+enum H_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  H_Foo,
+  H_Bar,
+  H_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t H_Tag;
+#endif // __cplusplus
+
+typedef struct H_Bar_Body {
+  uint8_t x;
+  int16_t y;
+} H_Bar_Body;
+
+typedef struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    H_Bar_Body bar;
+  };
+} H;
+
+enum J_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  J_Foo,
+  J_Bar,
+  J_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t J_Tag;
+#endif // __cplusplus
+
+typedef struct J_Bar_Body {
+  uint8_t x;
+  int16_t y;
+} J_Bar_Body;
+
+typedef struct J {
+  J_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    J_Bar_Body bar;
+  };
+} J;
+
+enum K_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  K_Foo,
+  K_Bar,
+  K_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t K_Tag;
+#endif // __cplusplus
+
+typedef struct K_Bar_Body {
+  K_Tag tag;
+  uint8_t x;
+  int16_t y;
+} K_Bar_Body;
+
+typedef union K {
+  K_Tag tag;
+  struct {
+    K_Tag foo_tag;
+    int16_t foo;
+  };
+  K_Bar_Body bar;
+} K;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void foo(struct H h, struct I i, struct J j, union K k);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.c

@@ -0,0 +1,78 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct I I;
+
+enum H_Tag {
+  H_Foo,
+  H_Bar,
+  H_Baz,
+};
+typedef uint8_t H_Tag;
+
+typedef struct {
+  uint8_t x;
+  int16_t y;
+} H_Bar_Body;
+
+typedef struct {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    H_Bar_Body bar;
+  };
+} H;
+
+enum J_Tag {
+  J_Foo,
+  J_Bar,
+  J_Baz,
+};
+typedef uint8_t J_Tag;
+
+typedef struct {
+  uint8_t x;
+  int16_t y;
+} J_Bar_Body;
+
+typedef struct {
+  J_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    J_Bar_Body bar;
+  };
+} J;
+
+enum K_Tag {
+  K_Foo,
+  K_Bar,
+  K_Baz,
+};
+typedef uint8_t K_Tag;
+
+typedef struct {
+  K_Tag tag;
+  uint8_t x;
+  int16_t y;
+} K_Bar_Body;
+
+typedef union {
+  K_Tag tag;
+  struct {
+    K_Tag foo_tag;
+    int16_t foo;
+  };
+  K_Bar_Body bar;
+} K;
+
+void foo(H h, I i, J j, K k);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.compat.c

@@ -0,0 +1,104 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct I I;
+
+enum H_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  H_Foo,
+  H_Bar,
+  H_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t H_Tag;
+#endif // __cplusplus
+
+typedef struct {
+  uint8_t x;
+  int16_t y;
+} H_Bar_Body;
+
+typedef struct {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    H_Bar_Body bar;
+  };
+} H;
+
+enum J_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  J_Foo,
+  J_Bar,
+  J_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t J_Tag;
+#endif // __cplusplus
+
+typedef struct {
+  uint8_t x;
+  int16_t y;
+} J_Bar_Body;
+
+typedef struct {
+  J_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    J_Bar_Body bar;
+  };
+} J;
+
+enum K_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  K_Foo,
+  K_Bar,
+  K_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t K_Tag;
+#endif // __cplusplus
+
+typedef struct {
+  K_Tag tag;
+  uint8_t x;
+  int16_t y;
+} K_Bar_Body;
+
+typedef union {
+  K_Tag tag;
+  struct {
+    K_Tag foo_tag;
+    int16_t foo;
+  };
+  K_Bar_Body bar;
+} K;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void foo(H h, I i, J j, K k);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.cpp

@@ -0,0 +1,250 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+struct I;
+
+struct H {
+  enum class Tag : uint8_t {
+    H_Foo,
+    H_Bar,
+    H_Baz,
+  };
+
+  struct H_Foo_Body {
+    int16_t _0;
+  };
+
+  struct H_Bar_Body {
+    uint8_t x;
+    int16_t y;
+  };
+
+  Tag tag;
+  union {
+    H_Foo_Body foo;
+    H_Bar_Body bar;
+  };
+
+  static H H_Foo(const int16_t &_0) {
+    H result;
+    ::new (&result.foo._0) (int16_t)(_0);
+    result.tag = Tag::H_Foo;
+    return result;
+  }
+
+  bool IsH_Foo() const {
+    return tag == Tag::H_Foo;
+  }
+
+  const int16_t& AsH_Foo() const {
+    MY_ASSERT(IsH_Foo());
+    return foo._0;
+  }
+
+  MY_ATTRS int16_t& AsH_Foo() {
+    MY_ASSERT(IsH_Foo());
+    return foo._0;
+  }
+
+  static H H_Bar(const uint8_t &x,
+                 const int16_t &y) {
+    H result;
+    ::new (&result.bar.x) (uint8_t)(x);
+    ::new (&result.bar.y) (int16_t)(y);
+    result.tag = Tag::H_Bar;
+    return result;
+  }
+
+  bool IsH_Bar() const {
+    return tag == Tag::H_Bar;
+  }
+
+  MY_ATTRS const H_Bar_Body& AsH_Bar() const {
+    MY_ASSERT(IsH_Bar());
+    return bar;
+  }
+
+  H_Bar_Body& AsH_Bar() {
+    MY_ASSERT(IsH_Bar());
+    return bar;
+  }
+
+  static H H_Baz() {
+    H result;
+    result.tag = Tag::H_Baz;
+    return result;
+  }
+
+  MY_ATTRS bool IsH_Baz() const {
+    return tag == Tag::H_Baz;
+  }
+};
+
+struct J {
+  enum class Tag : uint8_t {
+    J_Foo,
+    J_Bar,
+    J_Baz,
+  };
+
+  struct J_Foo_Body {
+    int16_t _0;
+  };
+
+  struct J_Bar_Body {
+    uint8_t x;
+    int16_t y;
+  };
+
+  Tag tag;
+  union {
+    J_Foo_Body foo;
+    J_Bar_Body bar;
+  };
+
+  static J J_Foo(const int16_t &_0) {
+    J result;
+    ::new (&result.foo._0) (int16_t)(_0);
+    result.tag = Tag::J_Foo;
+    return result;
+  }
+
+  bool IsJ_Foo() const {
+    return tag == Tag::J_Foo;
+  }
+
+  const int16_t& AsJ_Foo() const {
+    MY_ASSERT(IsJ_Foo());
+    return foo._0;
+  }
+
+  int16_t& AsJ_Foo() {
+    MY_ASSERT(IsJ_Foo());
+    return foo._0;
+  }
+
+  static J J_Bar(const uint8_t &x,
+                 const int16_t &y) {
+    J result;
+    ::new (&result.bar.x) (uint8_t)(x);
+    ::new (&result.bar.y) (int16_t)(y);
+    result.tag = Tag::J_Bar;
+    return result;
+  }
+
+  bool IsJ_Bar() const {
+    return tag == Tag::J_Bar;
+  }
+
+  const J_Bar_Body& AsJ_Bar() const {
+    MY_ASSERT(IsJ_Bar());
+    return bar;
+  }
+
+  J_Bar_Body& AsJ_Bar() {
+    MY_ASSERT(IsJ_Bar());
+    return bar;
+  }
+
+  static J J_Baz() {
+    J result;
+    result.tag = Tag::J_Baz;
+    return result;
+  }
+
+  bool IsJ_Baz() const {
+    return tag == Tag::J_Baz;
+  }
+};
+
+union K {
+  enum class Tag : uint8_t {
+    K_Foo,
+    K_Bar,
+    K_Baz,
+  };
+
+  struct K_Foo_Body {
+    Tag tag;
+    int16_t _0;
+  };
+
+  struct K_Bar_Body {
+    Tag tag;
+    uint8_t x;
+    int16_t y;
+  };
+
+  struct {
+    Tag tag;
+  };
+  K_Foo_Body foo;
+  K_Bar_Body bar;
+
+  static K K_Foo(const int16_t &_0) {
+    K result;
+    ::new (&result.foo._0) (int16_t)(_0);
+    result.tag = Tag::K_Foo;
+    return result;
+  }
+
+  bool IsK_Foo() const {
+    return tag == Tag::K_Foo;
+  }
+
+  const int16_t& AsK_Foo() const {
+    MY_ASSERT(IsK_Foo());
+    return foo._0;
+  }
+
+  int16_t& AsK_Foo() {
+    MY_ASSERT(IsK_Foo());
+    return foo._0;
+  }
+
+  static K K_Bar(const uint8_t &x,
+                 const int16_t &y) {
+    K result;
+    ::new (&result.bar.x) (uint8_t)(x);
+    ::new (&result.bar.y) (int16_t)(y);
+    result.tag = Tag::K_Bar;
+    return result;
+  }
+
+  bool IsK_Bar() const {
+    return tag == Tag::K_Bar;
+  }
+
+  const K_Bar_Body& AsK_Bar() const {
+    MY_ASSERT(IsK_Bar());
+    return bar;
+  }
+
+  K_Bar_Body& AsK_Bar() {
+    MY_ASSERT(IsK_Bar());
+    return bar;
+  }
+
+  static K K_Baz() {
+    K result;
+    result.tag = Tag::K_Baz;
+    return result;
+  }
+
+  bool IsK_Baz() const {
+    return tag == Tag::K_Baz;
+  }
+};
+
+extern "C" {
+
+void foo(H h, I i, J j, K k);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.pyx

@@ -0,0 +1,63 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef struct I:
+    pass
+
+  cdef enum:
+    H_Foo,
+    H_Bar,
+    H_Baz,
+  ctypedef uint8_t H_Tag;
+
+  ctypedef struct H_Bar_Body:
+    uint8_t x;
+    int16_t y;
+
+  ctypedef struct H:
+    H_Tag tag;
+    int16_t foo;
+    H_Bar_Body bar;
+
+  cdef enum:
+    J_Foo,
+    J_Bar,
+    J_Baz,
+  ctypedef uint8_t J_Tag;
+
+  ctypedef struct J_Bar_Body:
+    uint8_t x;
+    int16_t y;
+
+  ctypedef struct J:
+    J_Tag tag;
+    int16_t foo;
+    J_Bar_Body bar;
+
+  cdef enum:
+    K_Foo,
+    K_Bar,
+    K_Baz,
+  ctypedef uint8_t K_Tag;
+
+  ctypedef struct K_Bar_Body:
+    K_Tag tag;
+    uint8_t x;
+    int16_t y;
+
+  ctypedef union K:
+    K_Tag tag;
+    K_Tag foo_tag;
+    int16_t foo;
+    K_Bar_Body bar;
+
+  void foo(H h, I i, J j, K k);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.tag.c

@@ -0,0 +1,78 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct I;
+
+enum H_Tag {
+  H_Foo,
+  H_Bar,
+  H_Baz,
+};
+typedef uint8_t H_Tag;
+
+struct H_Bar_Body {
+  uint8_t x;
+  int16_t y;
+};
+
+struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    struct H_Bar_Body bar;
+  };
+};
+
+enum J_Tag {
+  J_Foo,
+  J_Bar,
+  J_Baz,
+};
+typedef uint8_t J_Tag;
+
+struct J_Bar_Body {
+  uint8_t x;
+  int16_t y;
+};
+
+struct J {
+  J_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    struct J_Bar_Body bar;
+  };
+};
+
+enum K_Tag {
+  K_Foo,
+  K_Bar,
+  K_Baz,
+};
+typedef uint8_t K_Tag;
+
+struct K_Bar_Body {
+  K_Tag tag;
+  uint8_t x;
+  int16_t y;
+};
+
+union K {
+  K_Tag tag;
+  struct {
+    K_Tag foo_tag;
+    int16_t foo;
+  };
+  struct K_Bar_Body bar;
+};
+
+void foo(struct H h, struct I i, struct J j, union K k);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.tag.compat.c

@@ -0,0 +1,104 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct I;
+
+enum H_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  H_Foo,
+  H_Bar,
+  H_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t H_Tag;
+#endif // __cplusplus
+
+struct H_Bar_Body {
+  uint8_t x;
+  int16_t y;
+};
+
+struct H {
+  H_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    struct H_Bar_Body bar;
+  };
+};
+
+enum J_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  J_Foo,
+  J_Bar,
+  J_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t J_Tag;
+#endif // __cplusplus
+
+struct J_Bar_Body {
+  uint8_t x;
+  int16_t y;
+};
+
+struct J {
+  J_Tag tag;
+  union {
+    struct {
+      int16_t foo;
+    };
+    struct J_Bar_Body bar;
+  };
+};
+
+enum K_Tag
+#ifdef __cplusplus
+  : uint8_t
+#endif // __cplusplus
+ {
+  K_Foo,
+  K_Bar,
+  K_Baz,
+};
+#ifndef __cplusplus
+typedef uint8_t K_Tag;
+#endif // __cplusplus
+
+struct K_Bar_Body {
+  K_Tag tag;
+  uint8_t x;
+  int16_t y;
+};
+
+union K {
+  K_Tag tag;
+  struct {
+    K_Tag foo_tag;
+    int16_t foo;
+  };
+  struct K_Bar_Body bar;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void foo(struct H h, struct I i, struct J j, union K k);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/asserted_cast.tag.pyx

@@ -0,0 +1,63 @@
+#define MY_ASSERT(...) do { } while (0)
+#define MY_ATTRS __attribute((noinline))
+
+
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef struct I:
+    pass
+
+  cdef enum:
+    H_Foo,
+    H_Bar,
+    H_Baz,
+  ctypedef uint8_t H_Tag;
+
+  cdef struct H_Bar_Body:
+    uint8_t x;
+    int16_t y;
+
+  cdef struct H:
+    H_Tag tag;
+    int16_t foo;
+    H_Bar_Body bar;
+
+  cdef enum:
+    J_Foo,
+    J_Bar,
+    J_Baz,
+  ctypedef uint8_t J_Tag;
+
+  cdef struct J_Bar_Body:
+    uint8_t x;
+    int16_t y;
+
+  cdef struct J:
+    J_Tag tag;
+    int16_t foo;
+    J_Bar_Body bar;
+
+  cdef enum:
+    K_Foo,
+    K_Bar,
+    K_Baz,
+  ctypedef uint8_t K_Tag;
+
+  cdef struct K_Bar_Body:
+    K_Tag tag;
+    uint8_t x;
+    int16_t y;
+
+  cdef union K:
+    K_Tag tag;
+    K_Tag foo_tag;
+    int16_t foo;
+    K_Bar_Body bar;
+
+  void foo(H h, I i, J j, K k);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_const_conflict.compat.c

@@ -0,0 +1,6 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define Foo_FOO 42

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_const_conflict.cpp

@@ -0,0 +1,7 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+static const uint32_t Foo_FOO = 42;

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_const_conflict.pyx

@@ -0,0 +1,9 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  const uint32_t Foo_FOO # = 42

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.both.c

@@ -0,0 +1,12 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct Foo {
+
+} Foo;
+#define Foo_GA 10
+#define Foo_ZO 3.14
+
+void root(struct Foo x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.both.compat.c

@@ -0,0 +1,20 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct Foo {
+
+} Foo;
+#define Foo_GA 10
+#define Foo_ZO 3.14
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct Foo x);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.c

@@ -0,0 +1,12 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+
+} Foo;
+#define Foo_GA 10
+#define Foo_ZO 3.14
+
+void root(Foo x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.compat.c

@@ -0,0 +1,20 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+
+} Foo;
+#define Foo_GA 10
+#define Foo_ZO 3.14
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(Foo x);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.cpp

@@ -0,0 +1,17 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+struct Foo {
+
+};
+static const int32_t Foo_GA = 10;
+static const float Foo_ZO = 3.14;
+
+extern "C" {
+
+void root(Foo x);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.pyx

@@ -0,0 +1,14 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef struct Foo:
+    pass
+  const int32_t Foo_GA # = 10
+  const float Foo_ZO # = 3.14
+
+  void root(Foo x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.tag.c

@@ -0,0 +1,12 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct Foo {
+
+};
+#define Foo_GA 10
+#define Foo_ZO 3.14
+
+void root(struct Foo x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.tag.compat.c

@@ -0,0 +1,20 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct Foo {
+
+};
+#define Foo_GA 10
+#define Foo_ZO 3.14
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct Foo x);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/assoc_constant.tag.pyx

@@ -0,0 +1,14 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef struct Foo:
+    pass
+  const int32_t Foo_GA # = 10
+  const float Foo_ZO # = 3.14
+
+  void root(Foo x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_constant_panic.compat.c

@@ -0,0 +1,4 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_constant_panic.cpp

@@ -0,0 +1,5 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_constant_panic.pyx

@@ -0,0 +1,8 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+  pass

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.both.c

@@ -0,0 +1,35 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct StyleAlignFlags {
+  uint8_t bits;
+} StyleAlignFlags;
+/**
+ * 'auto'
+ */
+#define StyleAlignFlags_AUTO (StyleAlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define StyleAlignFlags_NORMAL (StyleAlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define StyleAlignFlags_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+void root(struct StyleAlignFlags flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.both.compat.c

@@ -0,0 +1,43 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct StyleAlignFlags {
+  uint8_t bits;
+} StyleAlignFlags;
+/**
+ * 'auto'
+ */
+#define StyleAlignFlags_AUTO (StyleAlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define StyleAlignFlags_NORMAL (StyleAlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define StyleAlignFlags_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct StyleAlignFlags flags);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.c

@@ -0,0 +1,35 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct {
+  uint8_t bits;
+} StyleAlignFlags;
+/**
+ * 'auto'
+ */
+#define StyleAlignFlags_AUTO (StyleAlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define StyleAlignFlags_NORMAL (StyleAlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define StyleAlignFlags_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+void root(StyleAlignFlags flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.compat.c

@@ -0,0 +1,43 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct {
+  uint8_t bits;
+} StyleAlignFlags;
+/**
+ * 'auto'
+ */
+#define StyleAlignFlags_AUTO (StyleAlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define StyleAlignFlags_NORMAL (StyleAlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define StyleAlignFlags_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(StyleAlignFlags flags);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.cpp

@@ -0,0 +1,61 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+/// Constants shared by multiple CSS Box Alignment properties
+///
+/// These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+struct StyleAlignFlags {
+  uint8_t bits;
+
+  explicit operator bool() const {
+    return !!bits;
+  }
+  StyleAlignFlags operator~() const {
+    return {static_cast<decltype(bits)>(~bits)};
+  }
+  StyleAlignFlags operator|(const StyleAlignFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits | other.bits)};
+  }
+  StyleAlignFlags& operator|=(const StyleAlignFlags& other) {
+    *this = (*this | other);
+    return *this;
+  }
+  StyleAlignFlags operator&(const StyleAlignFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits & other.bits)};
+  }
+  StyleAlignFlags& operator&=(const StyleAlignFlags& other) {
+    *this = (*this & other);
+    return *this;
+  }
+  StyleAlignFlags operator^(const StyleAlignFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits ^ other.bits)};
+  }
+  StyleAlignFlags& operator^=(const StyleAlignFlags& other) {
+    *this = (*this ^ other);
+    return *this;
+  }
+  static const StyleAlignFlags AUTO;
+  static const StyleAlignFlags NORMAL;
+  static const StyleAlignFlags START;
+  static const StyleAlignFlags END;
+  static const StyleAlignFlags FLEX_START;
+};
+/// 'auto'
+inline const StyleAlignFlags StyleAlignFlags::AUTO = StyleAlignFlags{ /* .bits = */ (uint8_t)0 };
+/// 'normal'
+inline const StyleAlignFlags StyleAlignFlags::NORMAL = StyleAlignFlags{ /* .bits = */ (uint8_t)1 };
+/// 'start'
+inline const StyleAlignFlags StyleAlignFlags::START = StyleAlignFlags{ /* .bits = */ (uint8_t)(1 << 1) };
+/// 'end'
+inline const StyleAlignFlags StyleAlignFlags::END = StyleAlignFlags{ /* .bits = */ (uint8_t)(1 << 2) };
+/// 'flex-start'
+inline const StyleAlignFlags StyleAlignFlags::FLEX_START = StyleAlignFlags{ /* .bits = */ (uint8_t)(1 << 3) };
+
+extern "C" {
+
+void root(StyleAlignFlags flags);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.pyx

@@ -0,0 +1,25 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  # Constants shared by multiple CSS Box Alignment properties
+  #
+  # These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+  ctypedef struct StyleAlignFlags:
+    uint8_t bits;
+  # 'auto'
+  const StyleAlignFlags StyleAlignFlags_AUTO # = <StyleAlignFlags>{ <uint8_t>0 }
+  # 'normal'
+  const StyleAlignFlags StyleAlignFlags_NORMAL # = <StyleAlignFlags>{ <uint8_t>1 }
+  # 'start'
+  const StyleAlignFlags StyleAlignFlags_START # = <StyleAlignFlags>{ <uint8_t>(1 << 1) }
+  # 'end'
+  const StyleAlignFlags StyleAlignFlags_END # = <StyleAlignFlags>{ <uint8_t>(1 << 2) }
+  # 'flex-start'
+  const StyleAlignFlags StyleAlignFlags_FLEX_START # = <StyleAlignFlags>{ <uint8_t>(1 << 3) }
+
+  void root(StyleAlignFlags flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.tag.c

@@ -0,0 +1,35 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+struct StyleAlignFlags {
+  uint8_t bits;
+};
+/**
+ * 'auto'
+ */
+#define StyleAlignFlags_AUTO (StyleAlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define StyleAlignFlags_NORMAL (StyleAlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define StyleAlignFlags_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+void root(struct StyleAlignFlags flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.tag.compat.c

@@ -0,0 +1,43 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+struct StyleAlignFlags {
+  uint8_t bits;
+};
+/**
+ * 'auto'
+ */
+#define StyleAlignFlags_AUTO (StyleAlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define StyleAlignFlags_NORMAL (StyleAlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define StyleAlignFlags_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define StyleAlignFlags_END (StyleAlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define StyleAlignFlags_FLEX_START (StyleAlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct StyleAlignFlags flags);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/associated_in_body.tag.pyx

@@ -0,0 +1,25 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  # Constants shared by multiple CSS Box Alignment properties
+  #
+  # These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+  cdef struct StyleAlignFlags:
+    uint8_t bits;
+  # 'auto'
+  const StyleAlignFlags StyleAlignFlags_AUTO # = <StyleAlignFlags>{ <uint8_t>0 }
+  # 'normal'
+  const StyleAlignFlags StyleAlignFlags_NORMAL # = <StyleAlignFlags>{ <uint8_t>1 }
+  # 'start'
+  const StyleAlignFlags StyleAlignFlags_START # = <StyleAlignFlags>{ <uint8_t>(1 << 1) }
+  # 'end'
+  const StyleAlignFlags StyleAlignFlags_END # = <StyleAlignFlags>{ <uint8_t>(1 << 2) }
+  # 'flex-start'
+  const StyleAlignFlags StyleAlignFlags_FLEX_START # = <StyleAlignFlags>{ <uint8_t>(1 << 3) }
+
+  void root(StyleAlignFlags flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.both.c

@@ -0,0 +1,11 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct HasBitfields {
+  uint64_t foo: 8;
+  uint64_t bar: 56;
+} HasBitfields;
+
+void root(const struct HasBitfields*);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.both.compat.c

@@ -0,0 +1,19 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct HasBitfields {
+  uint64_t foo: 8;
+  uint64_t bar: 56;
+} HasBitfields;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const struct HasBitfields*);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.c

@@ -0,0 +1,11 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+  uint64_t foo: 8;
+  uint64_t bar: 56;
+} HasBitfields;
+
+void root(const HasBitfields*);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.compat.c

@@ -0,0 +1,19 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+  uint64_t foo: 8;
+  uint64_t bar: 56;
+} HasBitfields;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const HasBitfields*);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.cpp

@@ -0,0 +1,16 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+struct HasBitfields {
+  uint64_t foo: 8;
+  uint64_t bar: 56;
+};
+
+extern "C" {
+
+void root(const HasBitfields*);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.pyx

@@ -0,0 +1,13 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef struct HasBitfields:
+    uint64_t foo;
+    uint64_t bar;
+
+  void root(const HasBitfields*);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.tag.c

@@ -0,0 +1,11 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct HasBitfields {
+  uint64_t foo: 8;
+  uint64_t bar: 56;
+};
+
+void root(const struct HasBitfields*);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.tag.compat.c

@@ -0,0 +1,19 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct HasBitfields {
+  uint64_t foo: 8;
+  uint64_t bar: 56;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const struct HasBitfields*);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitfield.tag.pyx

@@ -0,0 +1,13 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef struct HasBitfields:
+    uint64_t foo;
+    uint64_t bar;
+
+  void root(const HasBitfields*);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.both.c

@@ -0,0 +1,43 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct AlignFlags {
+  uint8_t bits;
+} AlignFlags;
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (AlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (AlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define AlignFlags_START (AlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+typedef struct DebugFlags {
+  uint32_t bits;
+} DebugFlags;
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (DebugFlags){ .bits = (uint32_t)(1 << 31) }
+
+void root(struct AlignFlags flags, struct DebugFlags bigger_flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.both.compat.c

@@ -0,0 +1,51 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct AlignFlags {
+  uint8_t bits;
+} AlignFlags;
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (AlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (AlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define AlignFlags_START (AlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+typedef struct DebugFlags {
+  uint32_t bits;
+} DebugFlags;
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (DebugFlags){ .bits = (uint32_t)(1 << 31) }
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct AlignFlags flags, struct DebugFlags bigger_flags);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.c

@@ -0,0 +1,43 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct {
+  uint8_t bits;
+} AlignFlags;
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (AlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (AlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define AlignFlags_START (AlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+typedef struct {
+  uint32_t bits;
+} DebugFlags;
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (DebugFlags){ .bits = (uint32_t)(1 << 31) }
+
+void root(AlignFlags flags, DebugFlags bigger_flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.compat.c

@@ -0,0 +1,51 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+typedef struct {
+  uint8_t bits;
+} AlignFlags;
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (AlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (AlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define AlignFlags_START (AlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+typedef struct {
+  uint32_t bits;
+} DebugFlags;
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (DebugFlags){ .bits = (uint32_t)(1 << 31) }
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(AlignFlags flags, DebugFlags bigger_flags);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.cpp

@@ -0,0 +1,90 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+/// Constants shared by multiple CSS Box Alignment properties
+///
+/// These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+struct AlignFlags {
+  uint8_t bits;
+
+  explicit operator bool() const {
+    return !!bits;
+  }
+  AlignFlags operator~() const {
+    return {static_cast<decltype(bits)>(~bits)};
+  }
+  AlignFlags operator|(const AlignFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits | other.bits)};
+  }
+  AlignFlags& operator|=(const AlignFlags& other) {
+    *this = (*this | other);
+    return *this;
+  }
+  AlignFlags operator&(const AlignFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits & other.bits)};
+  }
+  AlignFlags& operator&=(const AlignFlags& other) {
+    *this = (*this & other);
+    return *this;
+  }
+  AlignFlags operator^(const AlignFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits ^ other.bits)};
+  }
+  AlignFlags& operator^=(const AlignFlags& other) {
+    *this = (*this ^ other);
+    return *this;
+  }
+};
+/// 'auto'
+static const AlignFlags AlignFlags_AUTO = AlignFlags{ /* .bits = */ (uint8_t)0 };
+/// 'normal'
+static const AlignFlags AlignFlags_NORMAL = AlignFlags{ /* .bits = */ (uint8_t)1 };
+/// 'start'
+static const AlignFlags AlignFlags_START = AlignFlags{ /* .bits = */ (uint8_t)(1 << 1) };
+/// 'end'
+static const AlignFlags AlignFlags_END = AlignFlags{ /* .bits = */ (uint8_t)(1 << 2) };
+/// 'flex-start'
+static const AlignFlags AlignFlags_FLEX_START = AlignFlags{ /* .bits = */ (uint8_t)(1 << 3) };
+
+struct DebugFlags {
+  uint32_t bits;
+
+  explicit operator bool() const {
+    return !!bits;
+  }
+  DebugFlags operator~() const {
+    return {static_cast<decltype(bits)>(~bits)};
+  }
+  DebugFlags operator|(const DebugFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits | other.bits)};
+  }
+  DebugFlags& operator|=(const DebugFlags& other) {
+    *this = (*this | other);
+    return *this;
+  }
+  DebugFlags operator&(const DebugFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits & other.bits)};
+  }
+  DebugFlags& operator&=(const DebugFlags& other) {
+    *this = (*this & other);
+    return *this;
+  }
+  DebugFlags operator^(const DebugFlags& other) const {
+    return {static_cast<decltype(bits)>(this->bits ^ other.bits)};
+  }
+  DebugFlags& operator^=(const DebugFlags& other) {
+    *this = (*this ^ other);
+    return *this;
+  }
+};
+/// Flag with the topmost bit set of the u32
+static const DebugFlags DebugFlags_BIGGEST_ALLOWED = DebugFlags{ /* .bits = */ (uint32_t)(1 << 31) };
+
+extern "C" {
+
+void root(AlignFlags flags, DebugFlags bigger_flags);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.pyx

@@ -0,0 +1,30 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  # Constants shared by multiple CSS Box Alignment properties
+  #
+  # These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+  ctypedef struct AlignFlags:
+    uint8_t bits;
+  # 'auto'
+  const AlignFlags AlignFlags_AUTO # = <AlignFlags>{ <uint8_t>0 }
+  # 'normal'
+  const AlignFlags AlignFlags_NORMAL # = <AlignFlags>{ <uint8_t>1 }
+  # 'start'
+  const AlignFlags AlignFlags_START # = <AlignFlags>{ <uint8_t>(1 << 1) }
+  # 'end'
+  const AlignFlags AlignFlags_END # = <AlignFlags>{ <uint8_t>(1 << 2) }
+  # 'flex-start'
+  const AlignFlags AlignFlags_FLEX_START # = <AlignFlags>{ <uint8_t>(1 << 3) }
+
+  ctypedef struct DebugFlags:
+    uint32_t bits;
+  # Flag with the topmost bit set of the u32
+  const DebugFlags DebugFlags_BIGGEST_ALLOWED # = <DebugFlags>{ <uint32_t>(1 << 31) }
+
+  void root(AlignFlags flags, DebugFlags bigger_flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.tag.c

@@ -0,0 +1,43 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+struct AlignFlags {
+  uint8_t bits;
+};
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (AlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (AlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define AlignFlags_START (AlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+struct DebugFlags {
+  uint32_t bits;
+};
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (DebugFlags){ .bits = (uint32_t)(1 << 31) }
+
+void root(struct AlignFlags flags, struct DebugFlags bigger_flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.tag.compat.c

@@ -0,0 +1,51 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Constants shared by multiple CSS Box Alignment properties
+ *
+ * These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+ */
+struct AlignFlags {
+  uint8_t bits;
+};
+/**
+ * 'auto'
+ */
+#define AlignFlags_AUTO (AlignFlags){ .bits = (uint8_t)0 }
+/**
+ * 'normal'
+ */
+#define AlignFlags_NORMAL (AlignFlags){ .bits = (uint8_t)1 }
+/**
+ * 'start'
+ */
+#define AlignFlags_START (AlignFlags){ .bits = (uint8_t)(1 << 1) }
+/**
+ * 'end'
+ */
+#define AlignFlags_END (AlignFlags){ .bits = (uint8_t)(1 << 2) }
+/**
+ * 'flex-start'
+ */
+#define AlignFlags_FLEX_START (AlignFlags){ .bits = (uint8_t)(1 << 3) }
+
+struct DebugFlags {
+  uint32_t bits;
+};
+/**
+ * Flag with the topmost bit set of the u32
+ */
+#define DebugFlags_BIGGEST_ALLOWED (DebugFlags){ .bits = (uint32_t)(1 << 31) }
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct AlignFlags flags, struct DebugFlags bigger_flags);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/bitflags.tag.pyx

@@ -0,0 +1,30 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  # Constants shared by multiple CSS Box Alignment properties
+  #
+  # These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
+  cdef struct AlignFlags:
+    uint8_t bits;
+  # 'auto'
+  const AlignFlags AlignFlags_AUTO # = <AlignFlags>{ <uint8_t>0 }
+  # 'normal'
+  const AlignFlags AlignFlags_NORMAL # = <AlignFlags>{ <uint8_t>1 }
+  # 'start'
+  const AlignFlags AlignFlags_START # = <AlignFlags>{ <uint8_t>(1 << 1) }
+  # 'end'
+  const AlignFlags AlignFlags_END # = <AlignFlags>{ <uint8_t>(1 << 2) }
+  # 'flex-start'
+  const AlignFlags AlignFlags_FLEX_START # = <AlignFlags>{ <uint8_t>(1 << 3) }
+
+  cdef struct DebugFlags:
+    uint32_t bits;
+  # Flag with the topmost bit set of the u32
+  const DebugFlags DebugFlags_BIGGEST_ALLOWED # = <DebugFlags>{ <uint32_t>(1 << 31) }
+
+  void root(AlignFlags flags, DebugFlags bigger_flags);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.both.c

@@ -0,0 +1,93 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum MyCLikeEnum {
+  Foo1,
+  Bar1,
+  Baz1,
+} MyCLikeEnum;
+
+typedef enum MyCLikeEnum_Prepended {
+  Foo1_Prepended,
+  Bar1_Prepended,
+  Baz1_Prepended,
+} MyCLikeEnum_Prepended;
+
+typedef struct MyFancyStruct {
+  int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+} MyFancyStruct;
+
+typedef enum MyFancyEnum_Tag {
+  Foo,
+  Bar,
+  Baz,
+} MyFancyEnum_Tag;
+
+typedef struct MyFancyEnum {
+  MyFancyEnum_Tag tag;
+  union {
+    struct {
+      int32_t bar;
+    };
+    struct {
+      int32_t baz;
+    };
+  };
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+} MyFancyEnum;
+
+typedef union MyUnion {
+  float f;
+  uint32_t u;
+  int32_t extra_member;
+} MyUnion;
+
+typedef struct MyFancyStruct_Prepended {
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+  int32_t i;
+} MyFancyStruct_Prepended;
+
+typedef enum MyFancyEnum_Prepended_Tag {
+  Foo_Prepended,
+  Bar_Prepended,
+  Baz_Prepended,
+} MyFancyEnum_Prepended_Tag;
+
+typedef struct MyFancyEnum_Prepended {
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+  MyFancyEnum_Prepended_Tag tag;
+  union {
+    struct {
+      int32_t bar_prepended;
+    };
+    struct {
+      int32_t baz_prepended;
+    };
+  };
+} MyFancyEnum_Prepended;
+
+typedef union MyUnion_Prepended {
+    int32_t extra_member;
+  float f;
+  uint32_t u;
+} MyUnion_Prepended;
+
+void root(struct MyFancyStruct s,
+          struct MyFancyEnum e,
+          enum MyCLikeEnum c,
+          union MyUnion u,
+          struct MyFancyStruct_Prepended sp,
+          struct MyFancyEnum_Prepended ep,
+          enum MyCLikeEnum_Prepended cp,
+          union MyUnion_Prepended up);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.both.compat.c

@@ -0,0 +1,101 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum MyCLikeEnum {
+  Foo1,
+  Bar1,
+  Baz1,
+} MyCLikeEnum;
+
+typedef enum MyCLikeEnum_Prepended {
+  Foo1_Prepended,
+  Bar1_Prepended,
+  Baz1_Prepended,
+} MyCLikeEnum_Prepended;
+
+typedef struct MyFancyStruct {
+  int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+} MyFancyStruct;
+
+typedef enum MyFancyEnum_Tag {
+  Foo,
+  Bar,
+  Baz,
+} MyFancyEnum_Tag;
+
+typedef struct MyFancyEnum {
+  MyFancyEnum_Tag tag;
+  union {
+    struct {
+      int32_t bar;
+    };
+    struct {
+      int32_t baz;
+    };
+  };
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+} MyFancyEnum;
+
+typedef union MyUnion {
+  float f;
+  uint32_t u;
+  int32_t extra_member;
+} MyUnion;
+
+typedef struct MyFancyStruct_Prepended {
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+  int32_t i;
+} MyFancyStruct_Prepended;
+
+typedef enum MyFancyEnum_Prepended_Tag {
+  Foo_Prepended,
+  Bar_Prepended,
+  Baz_Prepended,
+} MyFancyEnum_Prepended_Tag;
+
+typedef struct MyFancyEnum_Prepended {
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+  MyFancyEnum_Prepended_Tag tag;
+  union {
+    struct {
+      int32_t bar_prepended;
+    };
+    struct {
+      int32_t baz_prepended;
+    };
+  };
+} MyFancyEnum_Prepended;
+
+typedef union MyUnion_Prepended {
+    int32_t extra_member;
+  float f;
+  uint32_t u;
+} MyUnion_Prepended;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct MyFancyStruct s,
+          struct MyFancyEnum e,
+          enum MyCLikeEnum c,
+          union MyUnion u,
+          struct MyFancyStruct_Prepended sp,
+          struct MyFancyEnum_Prepended ep,
+          enum MyCLikeEnum_Prepended cp,
+          union MyUnion_Prepended up);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.c

@@ -0,0 +1,93 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum {
+  Foo1,
+  Bar1,
+  Baz1,
+} MyCLikeEnum;
+
+typedef enum {
+  Foo1_Prepended,
+  Bar1_Prepended,
+  Baz1_Prepended,
+} MyCLikeEnum_Prepended;
+
+typedef struct {
+  int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+} MyFancyStruct;
+
+typedef enum {
+  Foo,
+  Bar,
+  Baz,
+} MyFancyEnum_Tag;
+
+typedef struct {
+  MyFancyEnum_Tag tag;
+  union {
+    struct {
+      int32_t bar;
+    };
+    struct {
+      int32_t baz;
+    };
+  };
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+} MyFancyEnum;
+
+typedef union {
+  float f;
+  uint32_t u;
+  int32_t extra_member;
+} MyUnion;
+
+typedef struct {
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+  int32_t i;
+} MyFancyStruct_Prepended;
+
+typedef enum {
+  Foo_Prepended,
+  Bar_Prepended,
+  Baz_Prepended,
+} MyFancyEnum_Prepended_Tag;
+
+typedef struct {
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+  MyFancyEnum_Prepended_Tag tag;
+  union {
+    struct {
+      int32_t bar_prepended;
+    };
+    struct {
+      int32_t baz_prepended;
+    };
+  };
+} MyFancyEnum_Prepended;
+
+typedef union {
+    int32_t extra_member;
+  float f;
+  uint32_t u;
+} MyUnion_Prepended;
+
+void root(MyFancyStruct s,
+          MyFancyEnum e,
+          MyCLikeEnum c,
+          MyUnion u,
+          MyFancyStruct_Prepended sp,
+          MyFancyEnum_Prepended ep,
+          MyCLikeEnum_Prepended cp,
+          MyUnion_Prepended up);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.compat.c

@@ -0,0 +1,101 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum {
+  Foo1,
+  Bar1,
+  Baz1,
+} MyCLikeEnum;
+
+typedef enum {
+  Foo1_Prepended,
+  Bar1_Prepended,
+  Baz1_Prepended,
+} MyCLikeEnum_Prepended;
+
+typedef struct {
+  int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+} MyFancyStruct;
+
+typedef enum {
+  Foo,
+  Bar,
+  Baz,
+} MyFancyEnum_Tag;
+
+typedef struct {
+  MyFancyEnum_Tag tag;
+  union {
+    struct {
+      int32_t bar;
+    };
+    struct {
+      int32_t baz;
+    };
+  };
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+} MyFancyEnum;
+
+typedef union {
+  float f;
+  uint32_t u;
+  int32_t extra_member;
+} MyUnion;
+
+typedef struct {
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+  int32_t i;
+} MyFancyStruct_Prepended;
+
+typedef enum {
+  Foo_Prepended,
+  Bar_Prepended,
+  Baz_Prepended,
+} MyFancyEnum_Prepended_Tag;
+
+typedef struct {
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+  MyFancyEnum_Prepended_Tag tag;
+  union {
+    struct {
+      int32_t bar_prepended;
+    };
+    struct {
+      int32_t baz_prepended;
+    };
+  };
+} MyFancyEnum_Prepended;
+
+typedef union {
+    int32_t extra_member;
+  float f;
+  uint32_t u;
+} MyUnion_Prepended;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(MyFancyStruct s,
+          MyFancyEnum e,
+          MyCLikeEnum c,
+          MyUnion u,
+          MyFancyStruct_Prepended sp,
+          MyFancyEnum_Prepended ep,
+          MyCLikeEnum_Prepended cp,
+          MyUnion_Prepended up);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.cpp

@@ -0,0 +1,106 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+enum class MyCLikeEnum {
+  Foo1,
+  Bar1,
+  Baz1,
+};
+
+enum class MyCLikeEnum_Prepended {
+  Foo1_Prepended,
+  Bar1_Prepended,
+  Baz1_Prepended,
+};
+
+struct MyFancyStruct {
+  int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+};
+
+struct MyFancyEnum {
+  enum class Tag {
+    Foo,
+    Bar,
+    Baz,
+  };
+
+  struct Bar_Body {
+    int32_t _0;
+  };
+
+  struct Baz_Body {
+    int32_t _0;
+  };
+
+  Tag tag;
+  union {
+    Bar_Body bar;
+    Baz_Body baz;
+  };
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+};
+
+union MyUnion {
+  float f;
+  uint32_t u;
+  int32_t extra_member;
+};
+
+struct MyFancyStruct_Prepended {
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+  int32_t i;
+};
+
+struct MyFancyEnum_Prepended {
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+  enum class Tag {
+    Foo_Prepended,
+    Bar_Prepended,
+    Baz_Prepended,
+  };
+
+  struct Bar_Prepended_Body {
+    int32_t _0;
+  };
+
+  struct Baz_Prepended_Body {
+    int32_t _0;
+  };
+
+  Tag tag;
+  union {
+    Bar_Prepended_Body bar_prepended;
+    Baz_Prepended_Body baz_prepended;
+  };
+};
+
+union MyUnion_Prepended {
+    int32_t extra_member;
+  float f;
+  uint32_t u;
+};
+
+extern "C" {
+
+void root(MyFancyStruct s,
+          MyFancyEnum e,
+          MyCLikeEnum c,
+          MyUnion u,
+          MyFancyStruct_Prepended sp,
+          MyFancyEnum_Prepended ep,
+          MyCLikeEnum_Prepended cp,
+          MyUnion_Prepended up);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.pyx

@@ -0,0 +1,74 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef enum MyCLikeEnum:
+    Foo1,
+    Bar1,
+    Baz1,
+
+  ctypedef enum MyCLikeEnum_Prepended:
+    Foo1_Prepended,
+    Bar1_Prepended,
+    Baz1_Prepended,
+
+  ctypedef struct MyFancyStruct:
+    int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+
+  ctypedef enum MyFancyEnum_Tag:
+    Foo,
+    Bar,
+    Baz,
+
+  ctypedef struct MyFancyEnum:
+    MyFancyEnum_Tag tag;
+    int32_t bar;
+    int32_t baz;
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+
+  ctypedef union MyUnion:
+    float f;
+    uint32_t u;
+  int32_t extra_member;
+
+  ctypedef struct MyFancyStruct_Prepended:
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+    int32_t i;
+
+  ctypedef enum MyFancyEnum_Prepended_Tag:
+    Foo_Prepended,
+    Bar_Prepended,
+    Baz_Prepended,
+
+  ctypedef struct MyFancyEnum_Prepended:
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+    MyFancyEnum_Prepended_Tag tag;
+    int32_t bar_prepended;
+    int32_t baz_prepended;
+
+  ctypedef union MyUnion_Prepended:
+    int32_t extra_member;
+    float f;
+    uint32_t u;
+
+  void root(MyFancyStruct s,
+            MyFancyEnum e,
+            MyCLikeEnum c,
+            MyUnion u,
+            MyFancyStruct_Prepended sp,
+            MyFancyEnum_Prepended ep,
+            MyCLikeEnum_Prepended cp,
+            MyUnion_Prepended up);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.tag.c

@@ -0,0 +1,93 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum MyCLikeEnum {
+  Foo1,
+  Bar1,
+  Baz1,
+};
+
+enum MyCLikeEnum_Prepended {
+  Foo1_Prepended,
+  Bar1_Prepended,
+  Baz1_Prepended,
+};
+
+struct MyFancyStruct {
+  int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+};
+
+enum MyFancyEnum_Tag {
+  Foo,
+  Bar,
+  Baz,
+};
+
+struct MyFancyEnum {
+  enum MyFancyEnum_Tag tag;
+  union {
+    struct {
+      int32_t bar;
+    };
+    struct {
+      int32_t baz;
+    };
+  };
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+};
+
+union MyUnion {
+  float f;
+  uint32_t u;
+  int32_t extra_member;
+};
+
+struct MyFancyStruct_Prepended {
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+  int32_t i;
+};
+
+enum MyFancyEnum_Prepended_Tag {
+  Foo_Prepended,
+  Bar_Prepended,
+  Baz_Prepended,
+};
+
+struct MyFancyEnum_Prepended {
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+  enum MyFancyEnum_Prepended_Tag tag;
+  union {
+    struct {
+      int32_t bar_prepended;
+    };
+    struct {
+      int32_t baz_prepended;
+    };
+  };
+};
+
+union MyUnion_Prepended {
+    int32_t extra_member;
+  float f;
+  uint32_t u;
+};
+
+void root(struct MyFancyStruct s,
+          struct MyFancyEnum e,
+          enum MyCLikeEnum c,
+          union MyUnion u,
+          struct MyFancyStruct_Prepended sp,
+          struct MyFancyEnum_Prepended ep,
+          enum MyCLikeEnum_Prepended cp,
+          union MyUnion_Prepended up);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.tag.compat.c

@@ -0,0 +1,101 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum MyCLikeEnum {
+  Foo1,
+  Bar1,
+  Baz1,
+};
+
+enum MyCLikeEnum_Prepended {
+  Foo1_Prepended,
+  Bar1_Prepended,
+  Baz1_Prepended,
+};
+
+struct MyFancyStruct {
+  int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+};
+
+enum MyFancyEnum_Tag {
+  Foo,
+  Bar,
+  Baz,
+};
+
+struct MyFancyEnum {
+  enum MyFancyEnum_Tag tag;
+  union {
+    struct {
+      int32_t bar;
+    };
+    struct {
+      int32_t baz;
+    };
+  };
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+};
+
+union MyUnion {
+  float f;
+  uint32_t u;
+  int32_t extra_member;
+};
+
+struct MyFancyStruct_Prepended {
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+  int32_t i;
+};
+
+enum MyFancyEnum_Prepended_Tag {
+  Foo_Prepended,
+  Bar_Prepended,
+  Baz_Prepended,
+};
+
+struct MyFancyEnum_Prepended {
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+  enum MyFancyEnum_Prepended_Tag tag;
+  union {
+    struct {
+      int32_t bar_prepended;
+    };
+    struct {
+      int32_t baz_prepended;
+    };
+  };
+};
+
+union MyUnion_Prepended {
+    int32_t extra_member;
+  float f;
+  uint32_t u;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct MyFancyStruct s,
+          struct MyFancyEnum e,
+          enum MyCLikeEnum c,
+          union MyUnion u,
+          struct MyFancyStruct_Prepended sp,
+          struct MyFancyEnum_Prepended ep,
+          enum MyCLikeEnum_Prepended cp,
+          union MyUnion_Prepended up);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/body.tag.pyx

@@ -0,0 +1,74 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef enum MyCLikeEnum:
+    Foo1,
+    Bar1,
+    Baz1,
+
+  cdef enum MyCLikeEnum_Prepended:
+    Foo1_Prepended,
+    Bar1_Prepended,
+    Baz1_Prepended,
+
+  cdef struct MyFancyStruct:
+    int32_t i;
+#ifdef __cplusplus
+    inline void foo();
+#endif
+
+  cdef enum MyFancyEnum_Tag:
+    Foo,
+    Bar,
+    Baz,
+
+  cdef struct MyFancyEnum:
+    MyFancyEnum_Tag tag;
+    int32_t bar;
+    int32_t baz;
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+
+  cdef union MyUnion:
+    float f;
+    uint32_t u;
+  int32_t extra_member;
+
+  cdef struct MyFancyStruct_Prepended:
+#ifdef __cplusplus
+    inline void prepended_wohoo();
+#endif
+    int32_t i;
+
+  cdef enum MyFancyEnum_Prepended_Tag:
+    Foo_Prepended,
+    Bar_Prepended,
+    Baz_Prepended,
+
+  cdef struct MyFancyEnum_Prepended:
+#ifdef __cplusplus
+    inline void wohoo();
+#endif
+    MyFancyEnum_Prepended_Tag tag;
+    int32_t bar_prepended;
+    int32_t baz_prepended;
+
+  cdef union MyUnion_Prepended:
+    int32_t extra_member;
+    float f;
+    uint32_t u;
+
+  void root(MyFancyStruct s,
+            MyFancyEnum e,
+            MyCLikeEnum c,
+            MyUnion u,
+            MyFancyStruct_Prepended sp,
+            MyFancyEnum_Prepended ep,
+            MyCLikeEnum_Prepended cp,
+            MyUnion_Prepended up);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.both.c

@@ -0,0 +1,32 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_____i32 NotReprC_____i32;
+
+typedef struct NotReprC_____i32 Foo;
+
+typedef struct MyStruct {
+  int32_t *number;
+} MyStruct;
+
+void root(const Foo *a, const struct MyStruct *with_box);
+
+void drop_box(int32_t *x);
+
+void drop_box_opt(int32_t *x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.both.compat.c

@@ -0,0 +1,40 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_____i32 NotReprC_____i32;
+
+typedef struct NotReprC_____i32 Foo;
+
+typedef struct MyStruct {
+  int32_t *number;
+} MyStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const struct MyStruct *with_box);
+
+void drop_box(int32_t *x);
+
+void drop_box_opt(int32_t *x);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.c

@@ -0,0 +1,32 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_____i32 NotReprC_____i32;
+
+typedef NotReprC_____i32 Foo;
+
+typedef struct {
+  int32_t *number;
+} MyStruct;
+
+void root(const Foo *a, const MyStruct *with_box);
+
+void drop_box(int32_t *x);
+
+void drop_box_opt(int32_t *x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.compat.c

@@ -0,0 +1,40 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct NotReprC_____i32 NotReprC_____i32;
+
+typedef NotReprC_____i32 Foo;
+
+typedef struct {
+  int32_t *number;
+} MyStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const MyStruct *with_box);
+
+void drop_box(int32_t *x);
+
+void drop_box_opt(int32_t *x);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.cpp

@@ -0,0 +1,41 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+template<typename T = void>
+struct NotReprC;
+
+template<typename T = void>
+struct Option;
+
+using Foo = NotReprC<Box<int32_t>>;
+
+struct MyStruct {
+  Box<int32_t> number;
+};
+
+extern "C" {
+
+void root(const Foo *a, const MyStruct *with_box);
+
+void drop_box(Box<int32_t> x);
+
+void drop_box_opt(Option<Box<int32_t>> x);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.pyx

@@ -0,0 +1,35 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef struct NotReprC_____i32:
+    pass
+
+  ctypedef NotReprC_____i32 Foo;
+
+  ctypedef struct MyStruct:
+    int32_t *number;
+
+  void root(const Foo *a, const MyStruct *with_box);
+
+  void drop_box(int32_t *x);
+
+  void drop_box_opt(int32_t *x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.tag.c

@@ -0,0 +1,32 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct NotReprC_____i32;
+
+typedef struct NotReprC_____i32 Foo;
+
+struct MyStruct {
+  int32_t *number;
+};
+
+void root(const Foo *a, const struct MyStruct *with_box);
+
+void drop_box(int32_t *x);
+
+void drop_box_opt(int32_t *x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.tag.compat.c

@@ -0,0 +1,40 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct NotReprC_____i32;
+
+typedef struct NotReprC_____i32 Foo;
+
+struct MyStruct {
+  int32_t *number;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(const Foo *a, const struct MyStruct *with_box);
+
+void drop_box(int32_t *x);
+
+void drop_box_opt(int32_t *x);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/box.tag.pyx

@@ -0,0 +1,35 @@
+#if 0
+''' '
+#endif
+
+#ifdef __cplusplus
+template <typename T>
+using Box = T*;
+#endif
+
+#if 0
+' '''
+#endif
+
+
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef struct NotReprC_____i32:
+    pass
+
+  ctypedef NotReprC_____i32 Foo;
+
+  cdef struct MyStruct:
+    int32_t *number;
+
+  void root(const Foo *a, const MyStruct *with_box);
+
+  void drop_box(int32_t *x);
+
+  void drop_box_opt(int32_t *x);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/cdecl.c

@@ -0,0 +1,38 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef void (*A)(void);
+
+typedef void (*B)(void);
+
+typedef bool (*C)(int32_t, int32_t);
+
+typedef bool (*(*D)(int32_t))(float);
+
+typedef const int32_t (*(*E)(void))[16];
+
+typedef const int32_t *F;
+
+typedef const int32_t *const *G;
+
+typedef int32_t *const *H;
+
+typedef const int32_t (*I)[16];
+
+typedef double (**J)(float);
+
+typedef int32_t K[16];
+
+typedef const int32_t *L[16];
+
+typedef bool (*M[16])(int32_t, int32_t);
+
+typedef void (*N[16])(int32_t, int32_t);
+
+typedef void (*P)(int32_t named1st, bool, bool named3rd, int32_t _);
+
+void (*O(void))(void);
+
+void root(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, P p);

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/cdecl.compat.c

@@ -0,0 +1,46 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef void (*A)(void);
+
+typedef void (*B)(void);
+
+typedef bool (*C)(int32_t, int32_t);
+
+typedef bool (*(*D)(int32_t))(float);
+
+typedef const int32_t (*(*E)(void))[16];
+
+typedef const int32_t *F;
+
+typedef const int32_t *const *G;
+
+typedef int32_t *const *H;
+
+typedef const int32_t (*I)[16];
+
+typedef double (**J)(float);
+
+typedef int32_t K[16];
+
+typedef const int32_t *L[16];
+
+typedef bool (*M[16])(int32_t, int32_t);
+
+typedef void (*N[16])(int32_t, int32_t);
+
+typedef void (*P)(int32_t named1st, bool, bool named3rd, int32_t _);
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void (*O(void))(void);
+
+void root(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, P p);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/cdecl.cpp

@@ -0,0 +1,43 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+using A = void(*)();
+
+using B = void(*)();
+
+using C = bool(*)(int32_t, int32_t);
+
+using D = bool(*(*)(int32_t))(float);
+
+using E = const int32_t(*(*)())[16];
+
+using F = const int32_t*;
+
+using G = const int32_t*const *;
+
+using H = int32_t*const *;
+
+using I = const int32_t(*)[16];
+
+using J = double(**)(float);
+
+using K = int32_t[16];
+
+using L = const int32_t*[16];
+
+using M = bool(*[16])(int32_t, int32_t);
+
+using N = void(*[16])(int32_t, int32_t);
+
+using P = void(*)(int32_t named1st, bool, bool named3rd, int32_t _);
+
+extern "C" {
+
+void (*O())();
+
+void root(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, P p);
+
+} // extern "C"

clamav/libclamav_rust/.cargo/vendor/cbindgen/tests/expectations/cdecl.pyx

@@ -0,0 +1,41 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef void (*A)();
+
+  ctypedef void (*B)();
+
+  ctypedef bool (*C)(int32_t, int32_t);
+
+  ctypedef bool (*(*D)(int32_t))(float);
+
+  ctypedef const int32_t (*(*E)())[16];
+
+  ctypedef const int32_t *F;
+
+  ctypedef const int32_t *const *G;
+
+  ctypedef int32_t *const *H;
+
+  ctypedef const int32_t (*I)[16];
+
+  ctypedef double (**J)(float);
+
+  ctypedef int32_t K[16];
+
+  ctypedef const int32_t *L[16];
+
+  ctypedef bool (*M[16])(int32_t, int32_t);
+
+  ctypedef void (*N[16])(int32_t, int32_t);
+
+  ctypedef void (*P)(int32_t named1st, bool, bool named3rd, int32_t _);
+
+  void (*O())();
+
+  void root(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, P p);