source: libcfa/prelude/prelude-gen.cc@ 8f74a6a

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr persistent-indexer pthread-emulation qualifiedEnum
Last change on this file since 8f74a6a was ee06e41b, checked in by Peter A. Buhr <pabuhr@…>, 7 years ago

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