te.py 14.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#####################################################################################
# The MIT License (MIT)
#
# Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#####################################################################################
24
import string, sys, re
Paul's avatar
Paul committed
25

26
trivial = ['std::size_t', 'instruction_ref', 'support_metric']
Paul's avatar
Paul committed
27

Paul's avatar
Paul committed
28
29
30
31
32
33
34
35
36
37
headers = '''
#include <algorithm>
#include <cassert>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
'''

form = string.Template('''
38
#ifdef TYPE_ERASED_DECLARATION
Paul's avatar
Paul committed
39

40
41
42
43
44
45
46
// Type-erased interface for:
struct ${struct_name}
{
${decl_members}
};

#else
Paul's avatar
Paul committed
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

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)
    {
Paul Fultz II's avatar
Paul Fultz II committed
66
67
68
69
70
71
72
73
74
75
76
        using std::swap;
        auto * derived = this->any_cast<PrivateDetailTypeErasedT>();
        if(derived and private_detail_te_handle_mem_var.unique())
        {
            *derived = std::forward<PrivateDetailTypeErasedT>(value);
        }
        else 
        {
            ${struct_name} rhs(value);
            swap(private_detail_te_handle_mem_var, rhs.private_detail_te_handle_mem_var); 
        }
Paul's avatar
Paul committed
77
78
79
80
81
82
83
        return *this;
    }

    // Cast
    template<typename PrivateDetailTypeErasedT>
    PrivateDetailTypeErasedT * any_cast()
    {
Paul Fultz II's avatar
Paul Fultz II committed
84
        return this->type_id() == typeid(PrivateDetailTypeErasedT) ?
Paul's avatar
Paul committed
85
86
87
88
89
90
91
        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
    {
Paul Fultz II's avatar
Paul Fultz II committed
92
        return this->type_id() == typeid(PrivateDetailTypeErasedT) ?
Paul's avatar
Paul committed
93
94
95
96
        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
97
98
99
100
101
102
    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
103
104
    ${nonvirtual_members}

Paul's avatar
Paul committed
105
106
107
108
109
    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
110
111
112
113
114
115
116
117
118
119
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}
    };

120
121
    ${default_members}

Paul's avatar
Paul committed
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
    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
165
166
167
168
169
    bool private_detail_te_handle_empty() const
    {
        return private_detail_te_handle_mem_var == nullptr;
    }

Paul's avatar
Paul committed
170
    const private_detail_te_handle_base_type & private_detail_te_get_handle () const
Paul's avatar
Paul committed
171
172
173
174
    {
        assert(private_detail_te_handle_mem_var != nullptr); 
        return *private_detail_te_handle_mem_var; 
    }
Paul's avatar
Paul committed
175
176
177

    private_detail_te_handle_base_type & private_detail_te_get_handle ()
    {
Paul's avatar
Paul committed
178
        assert(private_detail_te_handle_mem_var != nullptr); 
Paul's avatar
Paul committed
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
        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;
}
214
#endif
Paul's avatar
Paul committed
215
216
217
''')

nonvirtual_member = string.Template('''
Paul's avatar
Paul committed
218
${friend} ${return_type} ${name}(${params}) ${const}
Paul's avatar
Paul committed
219
{
Paul's avatar
Paul committed
220
    assert(${this}.private_detail_te_handle_mem_var);
Paul's avatar
Paul committed
221
    ${return_} ${this}.private_detail_te_get_handle().${internal_name}(${member_args});
Paul's avatar
Paul committed
222
223
224
}
''')

kahmed10's avatar
kahmed10 committed
225
226
227
pure_virtual_member = string.Template(
    "virtual ${return_type} ${internal_name}(${member_params}) ${member_const} = 0;\n"
)
Paul's avatar
Paul committed
228
229

virtual_member = string.Template('''
Paul's avatar
Paul committed
230
${return_type} ${internal_name}(${member_params}) ${member_const} override
Paul's avatar
Paul committed
231
{
Paul's avatar
Paul committed
232
    ${using}
Paul's avatar
Paul committed
233
    ${return_} ${call};
Paul's avatar
Paul committed
234
235
236
}
''')

kahmed10's avatar
kahmed10 committed
237
238
239
comment_member = string.Template(
    '''*     ${friend} ${return_type} ${name}(${params}) ${const};''')

240
241
242
243
decl_member = string.Template('''    ${comment}
    ${friend} ${return_type} ${name}(${params}) ${const};
''')

244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
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
259

Paul's avatar
Paul committed
260
261
262
263
264
265
266
267
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
268

Paul's avatar
Paul committed
269
270
271
272
273
274
275
276
277
278
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
279

Paul's avatar
Paul committed
280
def generate_call(m, friend, indirect):
Paul's avatar
Paul committed
281
282
283
    if m['name'].startswith('operator'):
        op = m['name'][8:]
        args = m['args']
Paul's avatar
Paul committed
284
285
        if ',' in args:
            return args.replace(',', op)
Paul's avatar
Paul committed
286
        else:
Paul's avatar
Paul committed
287
            return string.Template('${op}${args}').substitute(op=op, args=args)
Paul's avatar
Paul committed
288
289
    if friend:
        return string.Template('${name}(${args})').substitute(m)
Paul's avatar
Paul committed
290
    if indirect:
291
        return string.Template(
Paul's avatar
Paul committed
292
293
            'private_detail_te_default_${internal_name}(char(0), private_detail_te_value ${comma} ${args})'
        ).substitute(m)
kahmed10's avatar
kahmed10 committed
294
295
296
    return string.Template(
        'private_detail_te_value.${name}(${args})').substitute(m)

Paul's avatar
Paul committed
297
298

def convert_member(d, struct_name):
Paul's avatar
Paul committed
299
    for name in d:
kahmed10's avatar
kahmed10 committed
300
        member = {
Paul's avatar
Paul committed
301
302
303
304
305
            'name': name,
            'internal_name': internal_name(name),
            'const': '',
            'member_const': '',
            'friend': '',
Paul's avatar
Paul committed
306
            'this': '(*this)',
Paul's avatar
Paul committed
307
            'using': '',
Paul's avatar
Paul committed
308
            'brief': '',
309
310
            'return_': '',
            'comment': '// '
Paul's avatar
Paul committed
311
        }
Paul's avatar
Paul committed
312
313
        args = []
        params = []
Paul's avatar
Paul committed
314
315
316
317
        member_args = []
        member_params = []
        skip = False
        friend = False
Paul's avatar
Paul committed
318
        indirect = False
Paul's avatar
Paul committed
319
320
321
        if 'friend' in d[name]:
            friend = True
            skip = True
Paul's avatar
Paul committed
322
323
        if 'default' in d[name]:
            indirect = True
Paul's avatar
Paul committed
324
325
326
        for x in d[name]:
            t = d[name][x]
            if x == 'return':
Paul's avatar
Paul committed
327
                member['return_type'] = t if t else 'void'
kahmed10's avatar
kahmed10 committed
328
329
                if member['return_type'] != 'void':
                    member['return_'] = 'return'
Paul's avatar
Paul committed
330
331
            elif x == 'const':
                member['const'] = 'const'
Paul's avatar
Paul committed
332
                member['member_const'] = 'const'
Paul's avatar
Paul committed
333
334
            elif x == 'friend':
                member['friend'] = 'friend'
Paul's avatar
Paul committed
335
336
            elif x == 'default':
                member['default'] = t
337
                member['comment'] = member['comment'] + '(optional)'
Paul's avatar
Paul committed
338
339
            elif x == 'using':
                member['using'] = 'using {};'.format(d[name]['using'])
Paul's avatar
Paul committed
340
341
            elif x == '__brief__':
                member['doc'] = '/// ' + t
Paul's avatar
Paul committed
342
343
            elif x.startswith('__') and x.endswith('__'):
                continue
Paul's avatar
Paul committed
344
            else:
kahmed10's avatar
kahmed10 committed
345
                use_member = not (skip and struct_name == trim_type_name(t))
Paul's avatar
Paul committed
346
                arg_name = x
kahmed10's avatar
kahmed10 committed
347
                if not use_member:
Paul's avatar
Paul committed
348
349
350
351
                    arg_name = 'private_detail_te_value'
                    member['this'] = x
                    if 'const' in t:
                        member['member_const'] = 'const'
Paul's avatar
Paul committed
352
                if t.endswith(('&', '*')) or t in trivial:
Paul's avatar
Paul committed
353
354
                    if use_member: member_args.append(x)
                    args.append(arg_name)
Paul's avatar
Paul committed
355
                else:
kahmed10's avatar
kahmed10 committed
356
357
                    if use_member:
                        member_args.append('std::move({})'.format(x))
Paul's avatar
Paul committed
358
                    args.append('std::move({})'.format(arg_name))
kahmed10's avatar
kahmed10 committed
359
360
                params.append(t + ' ' + x)
                if use_member: member_params.append(t + ' ' + x)
Paul's avatar
Paul committed
361
                else: skip = False
Paul's avatar
Paul committed
362
        member['args'] = ','.join(args)
Paul's avatar
Paul committed
363
        member['member_args'] = ','.join(member_args)
Paul's avatar
Paul committed
364
        member['params'] = ','.join(params)
Paul's avatar
Paul committed
365
366
        member['params'] = ','.join(params)
        member['member_params'] = ','.join(member_params)
367
        member['comma'] = ',' if len(args) > 0 else ''
Paul's avatar
Paul committed
368
        member['call'] = generate_call(member, friend, indirect)
Paul's avatar
Paul committed
369
370
371
372
373
374
375
376
377
        return member
    return None


def generate_form(name, members):
    nonvirtual_members = []
    pure_virtual_members = []
    virtual_members = []
    comment_members = []
378
    default_members = []
379
    decl_members = []
Paul's avatar
Paul committed
380
    for member in members:
Paul's avatar
Paul committed
381
        m = convert_member(member, name)
Paul's avatar
Paul committed
382
383
384
385
        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))
386
        decl_members.append(decl_member.substitute(m))
387
388
        if 'default' in m:
            default_members.append(default_member.substitute(m))
kahmed10's avatar
kahmed10 committed
389
390
391
    return form.substitute(nonvirtual_members=''.join(nonvirtual_members),
                           pure_virtual_members=''.join(pure_virtual_members),
                           virtual_members=''.join(virtual_members),
392
                           default_members=''.join(default_members),
393
                           decl_members=''.join(decl_members),
kahmed10's avatar
kahmed10 committed
394
395
396
                           comment_members='\n'.join(comment_members),
                           struct_name=name)

Paul's avatar
Paul committed
397
398
399
400

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

Paul's avatar
Paul committed
403

Paul's avatar
Paul committed
404
405
406
407
def friend(name, returns=None, **kwargs):
    args = kwargs
    args['return'] = returns
    args['friend'] = 'friend'
kahmed10's avatar
kahmed10 committed
408
    return {name: args}
Paul's avatar
Paul committed
409

Paul's avatar
Paul committed
410
411
412
413

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

kahmed10's avatar
kahmed10 committed
414
415

def template_eval(template, **kwargs):
416
417
    start = '<%'
    end = '%>'
Paul's avatar
Paul committed
418
419
420
    escaped = (re.escape(start), re.escape(end))
    mark = re.compile('%s(.*?)%s' % escaped, re.DOTALL)
    for key in kwargs:
kahmed10's avatar
kahmed10 committed
421
        exec('%s = %s' % (key, kwargs[key]))
Paul's avatar
Paul committed
422
    for item in mark.findall(template):
kahmed10's avatar
kahmed10 committed
423
424
        template = template.replace(start + item + end,
                                    str(eval(item.strip())))
Paul's avatar
Paul committed
425
426
    return template

kahmed10's avatar
kahmed10 committed
427

Paul's avatar
Paul committed
428
429
430
f = open(sys.argv[1]).read()
r = template_eval(f)
sys.stdout.write(r)