source: src/prelude/prelude-gen.cc @ 1d386a7

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprno_listpersistent-indexer
Last change on this file since 1d386a7 was 1d386a7, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Prelude is now generated

  • Property mode set to 100644
File size: 15.8 KB
Line 
1#include <algorithm>
2#include <array>
3#include <iostream>
4#include <string>
5#include <vector>
6using namespace std;
7
8static struct{
9        const string name;
10        bool isFloat;
11        bool hasComparison;
12} basicTypes[] = {
13        // { "char"                  , false, true , },
14        // { "signed char"           , false, true , },
15        // { "unsigned char"         , false, true , },
16        { "signed short"          , false, true , },
17        { "unsigned short"        , false, true , },
18        { "signed int"            , false, true , },
19        { "unsigned int"          , false, true , },
20        { "signed long int"       , false, true , },
21        { "unsigned long int"     , false, true , },
22        { "signed long long int"  , false, true , },
23        { "unsigned long long int", false, true , },
24        { "float"                 , true , true , },
25        { "double"                , true , true , },
26        { "long double"           , true , true , },
27        { "float _Complex"        , true , false, },
28        { "double _Complex"       , true , false, },
29        { "long double _Complex"  , true , false, },
30#if defined(__SIZEOF_INT128__)
31        { "__int128"              , false, true , },
32        { "unsigned __int128"     , false, true , },
33#endif
34#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
35        { "__float80"             , true , true , },
36        { "_Float128"             , true , true , },
37#endif
38};
39
40struct {
41        const string name;
42        bool assignment = false;
43        bool floatCompat = true;
44        bool isComparison = false;
45        bool isEqual = false;
46} arithmeticOperators[] = {
47        { "?++"  , true , true, false, false },
48        { "?--"  , true , true, false, false },
49        { "++?"  , true , true, false, false },
50        { "--?"  , true , true, false, false },
51        { "+?"   , false, true , false, false },
52        { "-?"   , false, true , false, false },
53        { "~?"   , false, false, false, false },
54        { "!?"   , false, true , false, true  },
55        { "?*?"  , false, true , false, false },
56        { "?/?"  , false, true , false, false },
57        { "?%?"  , false, false, false, false },
58        { "?+?"  , false, true , false, false },
59        { "?-?"  , false, true , false, false },
60        { "?<<?" , false, false, false, false },
61        { "?>>?" , false, false, false, false },
62        { "?<?"  , false, true , true , false },
63        { "?<=?" , false, true , true , true  },
64        { "?>?"  , false, true , true , false },
65        { "?>=?" , false, true , true , true  },
66        { "?==?" , false, true , false, true  },
67        { "?!=?" , false, true , false, true  },
68        { "?&?"  , false, false, false, false },
69        { "?^?"  , false, false, false, false },
70        { "?|?"  , false, false, false, false },
71        { "?=?"  , true , true , false, false },
72        { "?+=?" , true , true , false, false },
73        { "?-=?" , true , true , false, false },
74        { "?*=?" , true , true , false, false },
75        { "?/=?" , true , true , false, false },
76        { "?%=?" , true , false, false, false },
77        { "?<<=?", true , false, false, false },
78        { "?>>=?", true , false, false, false },
79        { "?&=?" , true , false, false, false },
80        { "?|=?" , true , false, false, false },
81        { "?^=?" , true , false, false, false },
82};
83
84enum ArgType { Normal, PtrDiff, CommPtrDiff };
85
86struct {
87        const string name;
88        bool assignment = false;
89        string diffReturn;
90        ArgType diffArg2 = Normal;
91        string sized;
92} pointerOperators[] = {
93        { "?++", true, "", Normal, " | sized(DT)" },
94        { "?--", true, "", Normal, " | sized(DT)" },
95        { "++?", true, "", Normal, " | sized(DT)" },
96        { "--?", true, "", Normal, " | sized(DT)" },
97        { "!?" , false, "int", Normal, "" },
98        { "?<?", false, "signed int", Normal, "" },
99        { "?<=?", false, "signed int", Normal, "" },
100        { "?>?", false, "signed int", Normal, "" },
101        { "?>=?", false, "signed int", Normal, "" },
102        { "?==?", false, "signed int", Normal, "" },
103        { "?!=?", false, "signed int", Normal, "" },
104        { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ???
105        { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
106
107        { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" },
108        { "?-?", false, "", PtrDiff, " | sized(DT)" },
109        { "?-=?", true, "", PtrDiff, " | sized(DT)" },
110
111        { "?+?", false, "", CommPtrDiff, " | sized(DT)" },
112        { "?[?]", false, "&", CommPtrDiff, " | sized(DT)" }, // & ???
113        { "?+=?" , true, "", PtrDiff, " | sized(DT)" },
114};
115
116template<size_t N>
117string mask2string(unsigned int mask, array<string, N> names) {
118        string result = "";
119        int i = 0;
120        for(auto name : names) {
121                if(mask & (1 << i)) {
122                        result += name;
123                }
124                i++;
125        }
126        return result;
127}
128
129template <typename... T>
130constexpr auto make_array(T&&... values) ->
131    std::array<
132        typename std::decay<typename std::common_type<T...>::type>::type,
133        sizeof...(T)>
134{
135    return std::array<
136        typename std::decay<
137            typename std::common_type<T...>::type>::type,
138        sizeof...(T)>{{std::forward<T>(values)...}};
139}
140
141int main() {
142        cout << "# 2 \"prelude.cf\"  // needed for error messages from this file" << endl;
143        cout << "trait sized(dtype T) {};" << endl;
144
145        cout << "//////////////////////////" << endl;
146        cout << "// Arithmetic Operators //" << endl;
147        cout << "//////////////////////////" << endl;
148        cout << endl;
149
150        cout << "void   ?{}( zero_t & );" << endl;
151        cout << "void   ?{}( one_t & );" << endl;
152        cout << "void   ?{}( zero_t &, zero_t );" << endl;
153        cout << "void   ?{}( one_t &, one_t );" << endl;
154        cout << "void   ^?{}( zero_t & );" << endl;
155        cout << "void   ^?{}( one_t & );" << endl;
156        cout << "zero_t                 ?=?( zero_t &, zero_t );" << endl;
157        cout << "one_t                  ?=?( one_t &, one_t );" << endl;
158        cout << "signed int ?==?( zero_t, zero_t ),                                                     ?!=?( zero_t, zero_t );" << endl;
159        cout << "signed int ?==?( one_t, one_t ),                                                       ?!=?( one_t, one_t );" << endl;
160
161        cout << "signed int ?==?( _Bool, _Bool ),                                                       ?!=?( _Bool, _Bool );" << endl;
162        cout << "void   ?{}( _Bool & );" << endl;
163        cout << "void   ?{}( _Bool &, _Bool );" << endl;
164        cout << "void   ^?{}( _Bool & );" << endl;
165        cout << "_Bool                  ?=?( _Bool &, _Bool ),                                  ?=?( volatile _Bool &, _Bool );" << endl;
166        cout << "signed int     !?( _Bool );" << endl;
167
168        cout << "void   ^?{}( char & );" << endl;
169        cout << "void   ^?{}( char unsigned & );" << endl;
170        cout << "void   ^?{}( char signed & );" << endl;
171        cout << "void   ?{}( char &, char );" << endl;
172        cout << "void   ?{}( unsigned char &, unsigned char );" << endl;
173        cout << "void   ?{}( char signed &, char signed );" << endl;
174        cout << "void   ?{}( char & );" << endl;
175        cout << "void   ?{}( unsigned char & );" << endl;
176        cout << "void   ?{}( char signed & );" << endl;
177        cout << "char                   ?=?( char &, char ),                                    ?=?( volatile char &, char );" << endl;
178        cout << "char signed            ?=?( char signed &, char signed ),                      ?=?( volatile char signed &, char signed );" << endl;
179        cout << "char unsigned          ?=?( char unsigned &, char unsigned ),                  ?=?( volatile char unsigned &, char unsigned );" << endl;
180
181
182        for (auto op : arithmeticOperators) {
183                for (auto type : basicTypes ) {
184                        auto operands = count(op.name.begin(), op.name.end(), '?');
185                        if (! op.floatCompat && type.isFloat) continue;
186                        if (op.isComparison && ! type.hasComparison) continue;
187                        if (op.assignment) {
188                                const char * qualifiers[] = { "", "volatile " };
189                                for (auto q : qualifiers){
190                                        cout << type.name << " " << op.name << "(";
191                                        cout << q << type.name << " &";
192                                        for (int i = 1; i < operands; ++i) {
193                                                cout << ", " << type.name;
194                                        }
195                                        cout << ");" << endl;
196                                }
197                        } else {
198                                if (op.isComparison || op.isEqual) cout << "signed int";
199                                else cout << type.name;
200                                cout << " " << op.name << "(";
201                                for (int i = 0; i < operands; ++i) {
202                                        cout << type.name;
203                                        if ((i+1) != operands) cout << ", ";
204                                }
205                                cout << ");" << endl;
206                        }
207                }
208                cout << endl;
209        }
210        cout << endl;
211
212        cout << "/////////////////////////////" << endl;
213        cout << "// Arithmetic Constructors //" << endl;
214        cout << "/////////////////////////////" << endl;
215        for (auto type : basicTypes) {
216                cout << "void  ?{}(" << type.name << " &);" << endl;
217                cout << "void  ?{}(" << type.name << " &, " << type.name << ");" << endl;
218                cout << "void ^?{}(" << type.name << " &);" << endl;
219                cout << endl;
220        }
221        cout << endl;
222
223        cout << "//////////////////////////" << endl;
224        cout << "// Pointer Constructors //" << endl;
225        cout << "//////////////////////////" << endl;
226        cout << "forall(ftype FT) void  ?{}( FT *&, FT * );" << endl;
227        cout << "forall(ftype FT) void  ?{}( FT * volatile &, FT * );" << endl;
228
229        // generate qualifiers for first and second parameters of copy constructors
230        vector<pair<const string, const string>> qualifiersPair;
231        const unsigned int NQ = 2;
232        for(unsigned int lhs = 0; lhs < (1<<NQ); lhs++) {
233                for(unsigned int rhs = 0; rhs < (1<<NQ); rhs++) {
234                        if((lhs & rhs) == rhs) {
235                                qualifiersPair.push_back({
236                                        mask2string(lhs, make_array("const "s, "volatile "s)),
237                                        mask2string(rhs, make_array("const "s, "volatile "s))
238                                });
239                        }
240                }
241        }
242
243        for (auto type : { "DT", "void" }) {
244                for (auto q : qualifiersPair) {
245                        cout << "forall(dtype DT) void  ?{}(" << q.first << type << " *&, " << q.second << "DT *);" << endl;
246                }
247        }
248
249
250        // generate qualifiers for parameter of default constructor and destructor
251        vector<string> qualifiersSingle;
252        for (unsigned int lhs = 0; lhs < (1<<NQ); lhs++) {
253                qualifiersSingle.push_back(mask2string(lhs, make_array("const "s, "volatile "s)));
254        }
255
256        for (auto type : { "DT", "void" }) {
257                for (auto q : qualifiersSingle) {
258                        cout << "forall(dtype DT) void  ?{}(" << q << type << " *&);" << endl;
259                        cout << "forall(dtype DT) void ^?{}(" << q << type << " *&);" << endl;
260                }
261        }
262        cout << endl;
263
264        cout << "forall(dtype DT) void ?{}(                 DT *          &, zero_t );" << endl;
265        cout << "forall(dtype DT) void ?{}(                 DT * volatile &, zero_t );" << endl;
266        cout << "forall(dtype DT) void ?{}( const           DT *          &, zero_t );" << endl;
267        cout << "forall(dtype DT) void ?{}( volatile        DT *          &, zero_t );" << endl;
268        cout << "forall(dtype DT) void ?{}( volatile        DT * volatile &, zero_t );" << endl;
269        cout << "forall(dtype DT) void ?{}( const volatile DT *   &, zero_t );" << endl;
270        cout << "forall(ftype FT) void  ?{}( FT *          &, zero_t ); " << endl;
271        cout << "forall( ftype FT ) void        ?{}( FT *          & );" << endl;
272        cout << "forall( ftype FT ) void        ^?{}( FT *         & );" << endl;
273        cout << endl;
274
275        cout << "///////////////////////" << endl;
276        cout << "// Pointer Operators //" << endl;
277        cout << "///////////////////////" << endl;
278
279        cout << "forall( ftype FT ) FT *                        ?=?( FT *&, FT * );" << endl;
280        cout << "forall( ftype FT ) FT *                        ?=?( FT * volatile &, FT * );" << endl;
281        cout << "forall( ftype FT ) int !?( FT * );" << endl;
282        cout << "forall( ftype FT ) signed int ?==?( FT *, FT * );" << endl;
283        cout << "forall( ftype FT ) signed int ?!=?( FT *, FT * );" << endl;
284        cout << "forall( ftype FT ) FT &                 *?( FT * );" << endl;
285
286
287        cout << "forall( dtype DT ) void *               ?=?(                void *          &,                 DT * );" << endl;
288        cout << "forall( dtype DT ) void *               ?=?(                void * volatile &,                 DT * );" << endl;
289        cout << "forall( dtype DT ) const void *                 ?=?( const          void *          &,                 DT * );" << endl;
290        cout << "forall( dtype DT ) const void *                 ?=?( const          void * volatile &,                 DT * );" << endl;
291        cout << "forall( dtype DT ) const void *                 ?=?( const          void *          &, const           DT * );" << endl;
292        cout << "forall( dtype DT ) const void *                 ?=?( const          void * volatile &, const           DT * );" << endl;
293        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void *          &,                 DT * );" << endl;
294        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void * volatile &,                 DT * );" << endl;
295        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void *          &,       volatile  DT * );" << endl;
296        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void * volatile &,       volatile  DT * );" << endl;
297        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &,                 DT * );" << endl;
298        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &,                        DT * );" << endl;
299        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &, const           DT * );" << endl;
300        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const          DT * );" << endl;
301        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &,       volatile  DT * );" << endl;
302        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &,              volatile  DT * );" << endl;
303        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &, const volatile  DT * );" << endl;
304        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile DT * );" << endl;
305
306        for (auto op : pointerOperators) {
307                for (auto type : { "DT"/*, "void"*/ } ) {
308                        auto operands = count(op.name.begin(), op.name.end(), '?');
309                        if (op.assignment) {
310                                // const char * qualifiers[] = { "", "volatile ", "const ", "const volatile " };
311                                switch(op.diffArg2) {
312                                        case Normal:
313                                                if (operands == 1) {
314                                                        for (auto q : qualifiersSingle){
315                                                                for (auto q2 : { " ", " volatile " }) {
316                                                                        cout << "forall(dtype DT" << op.sized <<  ") ";
317                                                                        cout << q << type << " * " << op.name << "(";
318                                                                        cout << q << type << " *" << q2 << "&";
319                                                                        cout << ");" << endl;
320                                                                }
321                                                        }
322                                                } else {
323                                                        for (auto q : qualifiersPair){
324                                                                for (auto q2 : { " ", " volatile " }) {
325                                                                        cout << "forall(dtype DT" << op.sized <<  ") ";
326                                                                        cout << q.first << type << " * " << op.name << "(";
327                                                                        cout << q.first << type << " *" << q2 << "&";
328
329                                                                        for (int i = 1; i < operands; ++i) {
330                                                                                cout << ", " << q.second << type << " *";
331                                                                        }
332                                                                        cout << ");" << endl;
333                                                                }
334                                                        }
335                                                }
336                                                break;
337                                        case PtrDiff:
338                                                for (auto q : qualifiersSingle){
339                                                        for (auto q2 : { " ", " volatile " }) {
340                                                                cout << "forall(dtype DT" << op.sized << ") ";
341                                                                cout << q << type << " * " << op.name << "(";
342                                                                cout << q << type << " *" << q2 << "&";
343
344                                                                for (int i = 1; i < operands; ++i) {
345                                                                        cout << ", ptrdiff_t";
346                                                                }
347                                                                cout << ");" << endl;
348                                                        }
349                                                }
350                                                break;
351                                        default:
352                                                abort();
353                                        }
354                        } else {
355                                switch(op.diffArg2) {
356                                        case Normal:
357                                                for (auto q : qualifiersSingle) {
358                                                        cout << "forall(dtype DT" << op.sized << ") ";
359                                                        if (op.diffReturn == "&") cout << q << type << " &"; // -- qualifiers
360                                                        else if (op.diffReturn != "") cout << op.diffReturn;
361                                                        else cout << q << type << " *";
362                                                        cout << " " << op.name << "(";
363                                                        for (int i = 0; i < operands; ++i) {
364                                                                cout << q << type << " *";
365                                                                if ((i+1) != operands) cout << ", ";
366                                                        }
367                                                        cout << ");" << endl;
368                                                }
369                                                break;
370                                        case CommPtrDiff:
371                                                for (auto q : qualifiersSingle) {
372                                                        cout << "forall(dtype DT" << op.sized << ") ";
373                                                        if (op.diffReturn == "&") cout << q << type << " &"; // -- qualifiers
374                                                        else if (op.diffReturn != "") cout << op.diffReturn;
375                                                        else cout << q << type << " *";
376                                                        cout << " " << op.name << "(ptrdiff_t, " << q << type << " *);" << endl;
377                                                }
378                                                // fallthrough
379                                        case PtrDiff:
380                                                for (auto q : qualifiersSingle) {
381                                                        cout << "forall(dtype DT" << op.sized << ") ";
382                                                        if (op.diffReturn == "&") cout << q << type << " &"; // -- qualifiers
383                                                        else if (op.diffReturn != "") cout << op.diffReturn;
384                                                        else cout << q << type << " *";
385                                                        cout << " " << op.name << "(" << q << type << " *, ptrdiff_t);" << endl;
386                                                }
387                                                break;
388                                }
389                        }
390                }
391                cout << endl;
392        }
393        cout << endl;
394
395        cout << "forall(dtype DT) DT *                  ?=?(                DT *          &, zero_t );" << endl;
396        cout << "forall(dtype DT) DT *                  ?=?(                DT * volatile &, zero_t );" << endl;
397        cout << "forall(dtype DT) const DT *            ?=?( const          DT *          &, zero_t );" << endl;
398        cout << "forall(dtype DT) const DT *            ?=?( const          DT * volatile &, zero_t );" << endl;
399        cout << "forall(dtype DT) volatile DT * ?=?( volatile       DT *          &, zero_t );" << endl;
400        cout << "forall(dtype DT) volatile DT * ?=?( volatile       DT * volatile &, zero_t );" << endl;
401        cout << "forall(dtype DT) const volatile DT *   ?=?( const volatile DT *          &, zero_t );" << endl;
402        cout << "forall(dtype DT) const volatile DT *   ?=?( const volatile DT * volatile &, zero_t );" << endl;
403        cout << "forall(ftype FT) FT *                  ?=?( FT *          &, zero_t );" << endl;
404        cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, zero_t );" << endl;
405}
406
Note: See TracBrowser for help on using the repository browser.