1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#include <interface99.h>
#include "common.h"
#include "util.h"
#include <assert.h>
// Interfaces {
#define FooExtendsMarker_IFACE Foo_IFACE
#define FooExtendsMarker_EXTENDS (Marker)
#define FooExtendsMany_IFACE Foo_IFACE
#define FooExtendsMany_EXTENDS (Foo, Bar)
#define MarkerExtendsMarker_IFACE Marker_IFACE
#define MarkerExtendsMarker_EXTENDS (Marker)
#define MarkerExtendsMany_IFACE Marker_IFACE
#define MarkerExtendsMany_EXTENDS (Foo, Bar)
interface(FooExtendsMarker);
interface(FooExtendsMany);
interface(MarkerExtendsMarker);
interface(MarkerExtendsMany);
// } (Interfaces)
// FooExtendsMarker {
typedef struct {
char dummy;
} A;
impl(Marker, A);
#define A_foo foo1_impl
impl(FooExtendsMarker, A);
// } (FooExtendsMarker)
// FooExtendsMany {
typedef struct {
char dummy;
} B;
#define B_foo foo1_impl
impl(Foo, B);
#undef B_foo
#define B_foo foo1_impl
#define B_bar bar1_impl
impl(Bar, B);
#undef B_foo
#undef B_bar
#define B_foo foo1_impl
impl(FooExtendsMany, B);
#undef B_foo
// } (FooExtendsMany)
// MarkerExtendsMarker {
typedef struct {
char dummy;
} C;
impl(Marker, C);
impl(MarkerExtendsMarker, C);
// } (MarkerExtendsMarker)
// MarkerExtendsMany {
typedef struct {
char dummy;
} D;
#define D_foo foo1_impl
impl(Foo, D);
#undef D_foo
#define D_foo foo1_impl
#define D_bar bar1_impl
impl(Bar, D);
#undef D_foo
#undef D_bar
impl(MarkerExtendsMany, D);
// } (MarkerExtendsMany)
int main(void) {
// Ensure `interface`-generated data.
{
ENSURE_VTABLE_FIELD_TYPE(FooExtendsMarkerVTable, foo, FooOpType);
ENSURE_DYN_OBJ_TYPE(FooExtendsMarker);
ENSURE_VTABLE_FIELD_TYPE(FooExtendsManyVTable, foo, FooOpType);
ENSURE_DYN_OBJ_TYPE(FooExtendsMany);
ENSURE_DYN_OBJ_TYPE(MarkerExtendsMarker);
ENSURE_DYN_OBJ_TYPE(MarkerExtendsMany);
}
// Ensure `impl`-generated data.
{
assert(VTABLE(A, FooExtendsMarker).Marker == &VTABLE(A, Marker));
assert(VTABLE(B, FooExtendsMany).Foo == &VTABLE(B, Foo));
assert(VTABLE(B, FooExtendsMany).Bar == &VTABLE(B, Bar));
assert(VTABLE(C, MarkerExtendsMarker).Marker == &VTABLE(C, Marker));
assert(VTABLE(D, MarkerExtendsMany).Foo == &VTABLE(D, Foo));
assert(VTABLE(D, MarkerExtendsMany).Bar == &VTABLE(D, Bar));
}
ENSURE_DYN_OBJ(A, FooExtendsMarker);
ENSURE_DYN_OBJ(B, FooExtendsMany);
ENSURE_DYN_OBJ(C, MarkerExtendsMarker);
ENSURE_DYN_OBJ(D, MarkerExtendsMany);
// Ensure that dynamic objects of superinterfaces still work.
{
ENSURE_DYN_OBJ(A, Marker);
ENSURE_DYN_OBJ(B, Foo);
ENSURE_DYN_OBJ(B, Bar);
ENSURE_DYN_OBJ(C, Marker);
ENSURE_DYN_OBJ(D, Foo);
ENSURE_DYN_OBJ(D, Bar);
}
return 0;
}
|
