te.py 14.3 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

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

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

form = string.Template('''
40
#ifdef TYPE_ERASED_DECLARATION
Paul's avatar
Paul committed
41

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

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

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
68
69
70
71
72
73
74
75
76
77
78
        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
79
80
81
82
83
84
85
        return *this;
    }

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

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

122
123
    ${default_members}

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

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

    private_detail_te_handle_base_type & private_detail_te_get_handle ()
    {
Paul's avatar
Paul committed
180
        assert(private_detail_te_handle_mem_var != nullptr); 
181
        if (not private_detail_te_handle_mem_var.unique())
Paul's avatar
Paul committed
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
214
215
            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;
}
216
#endif
Paul's avatar
Paul committed
217
218
219
''')

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

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

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

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

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

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

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

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

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

Paul's avatar
Paul committed
299
300

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


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

Paul's avatar
Paul committed
399
400
401
402

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

Paul's avatar
Paul committed
405

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

Paul's avatar
Paul committed
412
413
414
415

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

kahmed10's avatar
kahmed10 committed
416
417

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

kahmed10's avatar
kahmed10 committed
429

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