te.py 12.5 KB
Newer Older
Paul's avatar
Paul committed
1
2
import string, sys, re, os

kahmed10's avatar
kahmed10 committed
3
trivial = ['std::size_t', 'instruction_ref']
Paul's avatar
Paul committed
4

Paul's avatar
Paul committed
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
headers = '''
#include <algorithm>
#include <cassert>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
'''

form = string.Template('''

/*
* Type-erased interface for:
* 
* struct ${struct_name}
* {
${comment_members}
* };
* 
*/

struct ${struct_name}
{
    // Constructors
    ${struct_name} () = default;

    template <typename PrivateDetailTypeErasedT>
    ${struct_name} (PrivateDetailTypeErasedT value) :
        private_detail_te_handle_mem_var (
            std::make_shared<
                private_detail_te_handle_type<typename std::remove_reference<PrivateDetailTypeErasedT>::type>
            >(std::forward<PrivateDetailTypeErasedT>(value))
        )
    {}

    // Assignment
    template <typename PrivateDetailTypeErasedT>
    ${struct_name} & operator= (PrivateDetailTypeErasedT value)
    {
        if (private_detail_te_handle_mem_var.unique())
            *private_detail_te_handle_mem_var = std::forward<PrivateDetailTypeErasedT>(value);
        else if (!private_detail_te_handle_mem_var)
            private_detail_te_handle_mem_var = std::make_shared<PrivateDetailTypeErasedT>(std::forward<PrivateDetailTypeErasedT>(value));
        return *this;
    }

    // Cast
    template<typename PrivateDetailTypeErasedT>
    PrivateDetailTypeErasedT * any_cast()
    {
        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT) ?
        std::addressof(static_cast<private_detail_te_handle_type<typename std::remove_cv<PrivateDetailTypeErasedT>::type> &>(private_detail_te_get_handle()).private_detail_te_value) :
        nullptr;
    }

    template<typename PrivateDetailTypeErasedT>
    const typename std::remove_cv<PrivateDetailTypeErasedT>::type * any_cast() const
    {
        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT) ?
        std::addressof(static_cast<const private_detail_te_handle_type<typename std::remove_cv<PrivateDetailTypeErasedT>::type> &>(private_detail_te_get_handle()).private_detail_te_value) :
        nullptr;
    }

Paul's avatar
Paul committed
68
69
70
71
72
73
    const std::type_info& type_id() const
    {
        if(private_detail_te_handle_empty()) return typeid(std::nullptr_t);
        else return private_detail_te_get_handle().type();
    }

Paul's avatar
Paul committed
74
75
    ${nonvirtual_members}

Paul's avatar
Paul committed
76
77
78
79
80
    friend bool is_shared(const ${struct_name} & private_detail_x, const ${struct_name} & private_detail_y)
    {
        return private_detail_x.private_detail_te_handle_mem_var == private_detail_y.private_detail_te_handle_mem_var;
    }

Paul's avatar
Paul committed
81
82
83
84
85
86
87
88
89
90
private:
    struct private_detail_te_handle_base_type
    {
        virtual ~private_detail_te_handle_base_type () {}
        virtual std::shared_ptr<private_detail_te_handle_base_type> clone () const = 0;
        virtual const std::type_info& type() const = 0;

        ${pure_virtual_members}
    };

91
92
    ${default_members}

Paul's avatar
Paul committed
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
    template <typename PrivateDetailTypeErasedT>
    struct private_detail_te_handle_type :
        private_detail_te_handle_base_type
    {
        template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
        private_detail_te_handle_type (PrivateDetailTypeErasedT value,
                typename std::enable_if<
                    std::is_reference<PrivateDetailTypeErasedU>::value
                >::type * = nullptr) :
            private_detail_te_value (value)
        {}

        template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
        private_detail_te_handle_type (PrivateDetailTypeErasedT value,
                typename std::enable_if<
                    !std::is_reference<PrivateDetailTypeErasedU>::value,
                    int
                >::type * = nullptr) noexcept :
            private_detail_te_value (std::move(value))
        {}

        std::shared_ptr<private_detail_te_handle_base_type> clone () const override
        { return std::make_shared<private_detail_te_handle_type>(private_detail_te_value); }

        const std::type_info& type() const override
        {
            return typeid(private_detail_te_value);
        }

        ${virtual_members}

        PrivateDetailTypeErasedT private_detail_te_value;
    };

    template <typename PrivateDetailTypeErasedT>
    struct private_detail_te_handle_type<std::reference_wrapper<PrivateDetailTypeErasedT>> :
        private_detail_te_handle_type<PrivateDetailTypeErasedT &>
    {
        private_detail_te_handle_type (std::reference_wrapper<PrivateDetailTypeErasedT> ref) :
            private_detail_te_handle_type<PrivateDetailTypeErasedT &> (ref.get())
        {}
    };

Paul's avatar
Paul committed
136
137
138
139
140
    bool private_detail_te_handle_empty() const
    {
        return private_detail_te_handle_mem_var == nullptr;
    }

Paul's avatar
Paul committed
141
    const private_detail_te_handle_base_type & private_detail_te_get_handle () const
Paul's avatar
Paul committed
142
143
144
145
    {
        assert(private_detail_te_handle_mem_var != nullptr); 
        return *private_detail_te_handle_mem_var; 
    }
Paul's avatar
Paul committed
146
147
148

    private_detail_te_handle_base_type & private_detail_te_get_handle ()
    {
Paul's avatar
Paul committed
149
        assert(private_detail_te_handle_mem_var != nullptr); 
Paul's avatar
Paul committed
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
        if (!private_detail_te_handle_mem_var.unique())
            private_detail_te_handle_mem_var = private_detail_te_handle_mem_var->clone();
        return *private_detail_te_handle_mem_var;
    }

    std::shared_ptr<private_detail_te_handle_base_type> private_detail_te_handle_mem_var;
};

template<typename ValueType>
inline const ValueType * any_cast(const ${struct_name} * x)
{
    return x->any_cast<ValueType>();
}

template<typename ValueType>
inline ValueType * any_cast(${struct_name} * x)
{
    return x->any_cast<ValueType>();
}

template<typename ValueType>
inline ValueType & any_cast(${struct_name} & x)
{
    auto * y = x.any_cast<typename std::remove_reference<ValueType>::type>();
    if (y == nullptr) throw std::bad_cast();
    return *y;
}

template<typename ValueType>
inline const ValueType & any_cast(const ${struct_name} & x)
{
    const auto * y = x.any_cast<typename std::remove_reference<ValueType>::type>();
    if (y == nullptr) throw std::bad_cast();
    return *y;
}
''')

nonvirtual_member = string.Template('''
Paul's avatar
Paul committed
188
${friend} ${return_type} ${name}(${params}) ${const}
Paul's avatar
Paul committed
189
{
Paul's avatar
Paul committed
190
    assert(${this}.private_detail_te_handle_mem_var);
Paul's avatar
Paul committed
191
    ${return_} ${this}.private_detail_te_get_handle().${internal_name}(${member_args});
Paul's avatar
Paul committed
192
193
194
}
''')

kahmed10's avatar
kahmed10 committed
195
196
197
pure_virtual_member = string.Template(
    "virtual ${return_type} ${internal_name}(${member_params}) ${member_const} = 0;\n"
)
Paul's avatar
Paul committed
198
199

virtual_member = string.Template('''
Paul's avatar
Paul committed
200
${return_type} ${internal_name}(${member_params}) ${member_const} override
Paul's avatar
Paul committed
201
{
Paul's avatar
Paul committed
202
    ${using}
Paul's avatar
Paul committed
203
    ${return_} ${call};
Paul's avatar
Paul committed
204
205
206
}
''')

kahmed10's avatar
kahmed10 committed
207
208
209
comment_member = string.Template(
    '''*     ${friend} ${return_type} ${name}(${params}) ${const};''')

210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
default_member = string.Template('''
template<class T>
static auto private_detail_te_default_${name}(char, T&& private_detail_te_self ${comma} ${member_params})
-> decltype(private_detail_te_self.${name}(${args}))
{
    ${return_} private_detail_te_self.${name}(${args});
}

template<class T>
static ${return_type} private_detail_te_default_${internal_name}(float, T&& private_detail_te_self ${comma} ${member_params})
{
    ${return_} ${default}(private_detail_te_self ${comma} ${args});
}
''')

Paul's avatar
Paul committed
225

Paul's avatar
Paul committed
226
227
228
229
230
231
232
233
def trim_type_name(name):
    n = name.strip()
    if n.startswith('const'):
        return trim_type_name(n[5:])
    if n.endswith(('&', '*')):
        return trim_type_name(n[0:-1])
    return n

kahmed10's avatar
kahmed10 committed
234

Paul's avatar
Paul committed
235
236
237
238
239
240
241
242
243
244
def internal_name(name):
    internal_names = {
        'operator<<': 'operator_shift_left',
        'operator>>': 'operator_shift_right',
    }
    if name in internal_names:
        return internal_names[name]
    else:
        return name

kahmed10's avatar
kahmed10 committed
245

Paul's avatar
Paul committed
246
def generate_call(m, friend, indirect):
Paul's avatar
Paul committed
247
248
249
    if m['name'].startswith('operator'):
        op = m['name'][8:]
        args = m['args']
Paul's avatar
Paul committed
250
251
        if ',' in args:
            return args.replace(',', op)
Paul's avatar
Paul committed
252
        else:
Paul's avatar
Paul committed
253
            return string.Template('${op}${args}').substitute(op=op, args=args)
Paul's avatar
Paul committed
254
255
    if friend:
        return string.Template('${name}(${args})').substitute(m)
Paul's avatar
Paul committed
256
    if indirect:
257
        return string.Template(
Paul's avatar
Paul committed
258
259
            'private_detail_te_default_${internal_name}(char(0), private_detail_te_value ${comma} ${args})'
        ).substitute(m)
kahmed10's avatar
kahmed10 committed
260
261
262
    return string.Template(
        'private_detail_te_value.${name}(${args})').substitute(m)

Paul's avatar
Paul committed
263
264

def convert_member(d, struct_name):
Paul's avatar
Paul committed
265
    for name in d:
kahmed10's avatar
kahmed10 committed
266
        member = {
Paul's avatar
Paul committed
267
268
269
270
271
            'name': name,
            'internal_name': internal_name(name),
            'const': '',
            'member_const': '',
            'friend': '',
Paul's avatar
Paul committed
272
            'this': '(*this)',
Paul's avatar
Paul committed
273
            'using': '',
Paul's avatar
Paul committed
274
275
            'brief': '',
            'return_': ''
Paul's avatar
Paul committed
276
        }
Paul's avatar
Paul committed
277
278
        args = []
        params = []
Paul's avatar
Paul committed
279
280
281
282
        member_args = []
        member_params = []
        skip = False
        friend = False
Paul's avatar
Paul committed
283
        indirect = False
Paul's avatar
Paul committed
284
285
286
        if 'friend' in d[name]:
            friend = True
            skip = True
Paul's avatar
Paul committed
287
288
        if 'default' in d[name]:
            indirect = True
Paul's avatar
Paul committed
289
290
291
        for x in d[name]:
            t = d[name][x]
            if x == 'return':
Paul's avatar
Paul committed
292
                member['return_type'] = t if t else 'void'
kahmed10's avatar
kahmed10 committed
293
294
                if member['return_type'] != 'void':
                    member['return_'] = 'return'
Paul's avatar
Paul committed
295
296
            elif x == 'const':
                member['const'] = 'const'
Paul's avatar
Paul committed
297
                member['member_const'] = 'const'
Paul's avatar
Paul committed
298
299
            elif x == 'friend':
                member['friend'] = 'friend'
Paul's avatar
Paul committed
300
301
            elif x == 'default':
                member['default'] = t
Paul's avatar
Paul committed
302
303
            elif x == 'using':
                member['using'] = 'using {};'.format(d[name]['using'])
Paul's avatar
Paul committed
304
305
            elif x == '__brief__':
                member['doc'] = '/// ' + t
Paul's avatar
Paul committed
306
307
            elif x.startswith('__') and x.endswith('__'):
                continue
Paul's avatar
Paul committed
308
            else:
kahmed10's avatar
kahmed10 committed
309
                use_member = not (skip and struct_name == trim_type_name(t))
Paul's avatar
Paul committed
310
                arg_name = x
kahmed10's avatar
kahmed10 committed
311
                if not use_member:
Paul's avatar
Paul committed
312
313
314
315
                    arg_name = 'private_detail_te_value'
                    member['this'] = x
                    if 'const' in t:
                        member['member_const'] = 'const'
Paul's avatar
Paul committed
316
                if t.endswith(('&', '*')) or t in trivial:
Paul's avatar
Paul committed
317
318
                    if use_member: member_args.append(x)
                    args.append(arg_name)
Paul's avatar
Paul committed
319
                else:
kahmed10's avatar
kahmed10 committed
320
321
                    if use_member:
                        member_args.append('std::move({})'.format(x))
Paul's avatar
Paul committed
322
                    args.append('std::move({})'.format(arg_name))
kahmed10's avatar
kahmed10 committed
323
324
                params.append(t + ' ' + x)
                if use_member: member_params.append(t + ' ' + x)
Paul's avatar
Paul committed
325
                else: skip = False
Paul's avatar
Paul committed
326
        member['args'] = ','.join(args)
Paul's avatar
Paul committed
327
        member['member_args'] = ','.join(member_args)
Paul's avatar
Paul committed
328
        member['params'] = ','.join(params)
Paul's avatar
Paul committed
329
330
        member['params'] = ','.join(params)
        member['member_params'] = ','.join(member_params)
331
        member['comma'] = ',' if len(args) > 0 else ''
Paul's avatar
Paul committed
332
        member['call'] = generate_call(member, friend, indirect)
Paul's avatar
Paul committed
333
334
335
336
337
338
339
340
341
        return member
    return None


def generate_form(name, members):
    nonvirtual_members = []
    pure_virtual_members = []
    virtual_members = []
    comment_members = []
342
    default_members = []
Paul's avatar
Paul committed
343
    for member in members:
Paul's avatar
Paul committed
344
        m = convert_member(member, name)
Paul's avatar
Paul committed
345
346
347
348
        nonvirtual_members.append(nonvirtual_member.substitute(m))
        pure_virtual_members.append(pure_virtual_member.substitute(m))
        virtual_members.append(virtual_member.substitute(m))
        comment_members.append(comment_member.substitute(m))
349
350
        if 'default' in m:
            default_members.append(default_member.substitute(m))
kahmed10's avatar
kahmed10 committed
351
352
353
    return form.substitute(nonvirtual_members=''.join(nonvirtual_members),
                           pure_virtual_members=''.join(pure_virtual_members),
                           virtual_members=''.join(virtual_members),
354
                           default_members=''.join(default_members),
kahmed10's avatar
kahmed10 committed
355
356
357
                           comment_members='\n'.join(comment_members),
                           struct_name=name)

Paul's avatar
Paul committed
358
359
360
361

def virtual(name, returns=None, **kwargs):
    args = kwargs
    args['return'] = returns
kahmed10's avatar
kahmed10 committed
362
363
    return {name: args}

Paul's avatar
Paul committed
364

Paul's avatar
Paul committed
365
366
367
368
def friend(name, returns=None, **kwargs):
    args = kwargs
    args['return'] = returns
    args['friend'] = 'friend'
kahmed10's avatar
kahmed10 committed
369
    return {name: args}
Paul's avatar
Paul committed
370

Paul's avatar
Paul committed
371
372
373
374

def interface(name, *members):
    return generate_form(name, members)

kahmed10's avatar
kahmed10 committed
375
376

def template_eval(template, **kwargs):
377
378
    start = '<%'
    end = '%>'
Paul's avatar
Paul committed
379
380
381
    escaped = (re.escape(start), re.escape(end))
    mark = re.compile('%s(.*?)%s' % escaped, re.DOTALL)
    for key in kwargs:
kahmed10's avatar
kahmed10 committed
382
        exec ('%s = %s' % (key, kwargs[key]))
Paul's avatar
Paul committed
383
    for item in mark.findall(template):
kahmed10's avatar
kahmed10 committed
384
385
        template = template.replace(start + item + end,
                                    str(eval(item.strip())))
Paul's avatar
Paul committed
386
387
    return template

kahmed10's avatar
kahmed10 committed
388

Paul's avatar
Paul committed
389
390
391
f = open(sys.argv[1]).read()
r = template_eval(f)
sys.stdout.write(r)