source: src/BasicTypes-gen.cpp@ 17fdf6f

Last change on this file since 17fdf6f was c5f69fd, checked in by Peter A. Buhr <pabuhr@…>, 12 months ago

clean up naming of float-point types, and start to add new ARM floating-point types
  • Property mode set to 100644
File size: 18.5 KB
Line 
1#include <algorithm>
2#include <queue>
3#include <iostream>
4#include <iomanip>
5#include <fstream>
6#include <utility>
7#include <string>
8using namespace std;
9#include <assert.h>
10#include <string.h> // strlen
11#include "config.h" // configure info
12
13enum Kind {
14 Bool,
15 Char,
16 SignedChar,
17 UnsignedChar,
18 ShortSignedInt,
19 ShortUnsignedInt,
20 SignedInt,
21 UnsignedInt,
22 LongSignedInt,
23 LongUnsignedInt,
24 LongLongSignedInt,
25 LongLongUnsignedInt,
26 SignedInt128,
27 UnsignedInt128,
28 Float16,
29 Float16Complex,
30 Float32,
31 Float32Complex,
32 Float,
33 FloatComplex,
34 // FloatImaginary,
35 Float32x,
36 Float32xComplex,
37 Float64,
38 Float64Complex,
39 Double,
40 DoubleComplex,
41 // DoubleImaginary,
42 Float64x,
43 Float64xComplex,
44 Float80,
45 Float128,
46 Float128Complex,
47 uuFloat128,
48 LongDouble,
49 LongDoubleComplex,
50 // LongDoubleImaginary,
51 Float128x,
52 Float128xComplex,
53 NUMBER_OF_BASIC_TYPES,
54
55 Float32x4, // ARM, gcc-14
56 Float64x2,
57 Svfloat32,
58 Svfloat64,
59 Svbool,
60};
61
62enum NumSort { // floating point types act as both signed and unsigned
63 Signed = 0x1,
64 Unsigned = 0x2,
65 Floating = 0x3
66};
67
68struct Node {
69 Kind basicType; // basic type
70 const char * name; // basic-type name
71 const char * abbrev; // internal abbreviation (documentation only)
72 const char * type; // actual type name
73 const char * mangled; // mangled abbreviation
74 NumSort sign; // is this a signed integral type?
75 int left, middle, right; // 3-ary tree, -1 => nullptr
76 int rank; // integral rank (C standard 6.3.1.1.1, extended)
77} graph[NUMBER_OF_BASIC_TYPES] = {
78 { Bool, "Bool", "B", "_Bool", "b", Signed, Char, SignedChar, -1, 0 }, // root
79
80 { Char, "Char", "C", "char", "c", Signed, SignedChar, UnsignedChar, ShortSignedInt, 1 },
81 { SignedChar, "SignedChar", "SC", "signed char", "a", Signed, UnsignedChar, ShortSignedInt, -1, 1 },
82 { UnsignedChar, "UnsignedChar", "UC", "unsigned char", "h", Unsigned, ShortUnsignedInt, ShortSignedInt, -1, 1 },
83
84 { ShortSignedInt, "ShortSignedInt", "SI", "signed short int", "s", Signed, ShortUnsignedInt, SignedInt, -1, 2 },
85 { ShortUnsignedInt, "ShortUnsignedInt", "SUI", "unsigned short int", "t", Unsigned, UnsignedInt, SignedInt, -1, 2 },
86
87 { SignedInt, "SignedInt", "I", "signed int", "i", Signed, UnsignedInt, LongSignedInt, -1, 3 },
88 { UnsignedInt, "UnsignedInt", "UI", "unsigned int", "j", Unsigned, LongUnsignedInt, LongSignedInt, -1, 3 },
89
90 { LongSignedInt, "LongSignedInt", "LI", "signed long int", "l", Signed, LongUnsignedInt, LongLongSignedInt, -1, 4 },
91 { LongUnsignedInt, "LongUnsignedInt", "LUI", "unsigned long int", "m", Unsigned, LongLongSignedInt, LongLongUnsignedInt, -1, 4 },
92
93 { LongLongSignedInt, "LongLongSignedInt", "LLI", "signed long long int", "x", Signed, LongLongUnsignedInt, SignedInt128, -1, 5 },
94 { LongLongUnsignedInt, "LongLongUnsignedInt", "LLUI", "unsigned long long int", "y", Unsigned, SignedInt128, UnsignedInt128, -1, 5 },
95
96 { SignedInt128, "SignedInt128", "IB", "__int128", "n", Signed, UnsignedInt128, Float16, -1, 6 },
97 { UnsignedInt128, "UnsignedInt128", "UIB", "unsigned __int128", "o", Unsigned, Float16, -1, -1, 6 },
98
99 { Float16, "Float16", "_FH", "_Float16", "DF16_", Floating, Float32, Float16Complex, -1, 7 },
100 { Float16Complex, "Float16Complex", "_FH", "_Float16 _Complex", "CDF16_", Floating, Float32Complex, -1, -1, 7 },
101 { Float32, "Float32", "_F", "_Float32", "DF32_", Floating, Float, Float32Complex, -1, 8 },
102 { Float32Complex, "Float32Complex", "_FC", "_Float32 _Complex", "CDF32_", Floating, FloatComplex, -1, -1, 8 },
103 { Float, "Float", "F", "float", "f", Floating, Float32x, FloatComplex, -1, 9 },
104 { FloatComplex, "FloatComplex", "FC", "float _Complex", "Cf", Floating, Float32xComplex, -1, -1, 9 },
105 // { FloatImaginary, "FloatImaginary", "FI", "float _Imaginary", "If", false, DoubleImaginary, FloatComplex, -1, 9 },
106
107 { Float32x, "Float32x", "_FX", "_Float32x", "DF32x_", Floating, Float64, Float32xComplex, -1, 10 },
108 { Float32xComplex, "Float32xComplex", "_FXC", "_Float32x _Complex", "CDF32x_", Floating, Float64Complex, -1, -1, 10 },
109 { Float64, "Float64", "FD", "_Float64", "DF64_", Floating, Double, Float64Complex, -1, 11 },
110 { Float64Complex, "Float64Complex", "_FDC", "_Float64 _Complex", "CDF64_", Floating, DoubleComplex, -1, -1, 11 },
111 { Double, "Double", "D", "double", "d", Floating, Float64x, DoubleComplex, -1, 12 },
112 { DoubleComplex, "DoubleComplex", "DC", "double _Complex", "Cd", Floating, Float64xComplex, -1, -1, 12 },
113 // { DoubleImaginary, "DoubleImaginary", "DI", "double _Imaginary", "Id", false, LongDoubleImaginary, DoubleComplex, -1, 12 },
114
115 { Float64x, "Float64x", "F80X", "_Float64x", "DF64x_", Floating, Float80, Float64xComplex, -1, 13 },
116 { Float64xComplex, "Float64xComplex", "_FDXC", "_Float64x _Complex", "CDF64x_", Floating, Float128Complex, -1, -1, 13 },
117 { Float80, "Float80", "F80", "__float80", "Dq", Floating, Float128, Float64xComplex, -1, 14 },
118 { Float128, "Float128", "_FB", "_Float128", "DF128_", Floating, uuFloat128, Float128Complex, -1, 15 },
119 { Float128Complex, "Float128Complex", "_FLDC", "_Float128 _Complex", "CDF128_", Floating, LongDoubleComplex, -1, -1, 15 },
120 { uuFloat128, "uuFloat128", "FB", "__float128", "g", Floating, LongDouble, Float128Complex, -1, 16 },
121 { LongDouble, "LongDouble", "LD", "long double", "e", Floating, Float128x, LongDoubleComplex, -1, 17 },
122 { LongDoubleComplex, "LongDoubleComplex", "LDC", "long double _Complex", "Ce", Floating, Float128xComplex, -1, -1, 17 },
123 // { LongDoubleImaginary, "LongDoubleImaginary", "LDI", "long double _Imaginary", "Ie", false, LongDoubleComplex, -1, -1, 17 },
124
125 { Float128x, "Float128x", "_FBX", "_Float128x", "DF128x_", Floating, Float128xComplex, -1, -1, 18 },
126 { Float128xComplex, "Float128xComplex", "_FLDXC", "_Float128x _Complex", "CDF128x_", Floating, -1, -1, -1, 18 }
127}; // graph
128
129static int costMatrix[NUMBER_OF_BASIC_TYPES][NUMBER_OF_BASIC_TYPES];
130static int signMatrix[NUMBER_OF_BASIC_TYPES][NUMBER_OF_BASIC_TYPES];
131static Kind commonTypeMatrix[NUMBER_OF_BASIC_TYPES][NUMBER_OF_BASIC_TYPES];
132
133void generateCosts( int row ) {
134 bool seen[NUMBER_OF_BASIC_TYPES] = { false /*, ... */ };
135
136 struct el_cost {
137 int i;
138 int path;
139 int sign;
140
141 el_cost( int i = 0, int p = 0, int s = 0 ) : i(i), path(p), sign(s) {}
142
143 // reverse the sense for use in largest-on-top priority queue
144 bool operator< (const el_cost& o) const {
145 return path > o.path || (path == o.path && sign > o.sign);
146 }
147 };
148
149 // initialize BFS queue with root of traversal
150 priority_queue< el_cost > q;
151 q.emplace( row, 0, 0 );
152
153 // BFS costs
154 do {
155 // visit cost element
156 int col = q.top().i;
157 // skip if already set
158 if ( seen[col] ) {
159 q.pop();
160 continue;
161 } else {
162 seen[col] = true;
163 } // if
164
165 // otherwise set min-costs into matrix
166 int cost = q.top().path;
167 int scost = q.top().sign;
168 costMatrix[row][col] = cost;
169 signMatrix[row][col] = scost;
170 q.pop();
171
172 // traverse children
173 int i = graph[col].left;
174 if ( i == -1 ) continue;
175 q.emplace( i, cost + 1, scost + ! (graph[col].sign & graph[i].sign) );
176
177 i = graph[col].middle;
178 if ( i == -1 ) continue;
179 q.emplace( i, cost + 1, scost + !(graph[col].sign & graph[i].sign) );
180
181 i = graph[col].right;
182 if ( i == -1 ) continue;
183 q.emplace( i, cost + 1, scost + !(graph[col].sign & graph[i].sign) );
184 } while ( ! q.empty() );
185} // generateCosts
186
187void generateCommonType( int row, int col ) { // row <= col
188 if ( costMatrix[row][col] >= 0 ) {
189 // safe conversion from row => col
190 commonTypeMatrix[row][col] = commonTypeMatrix[col][row] = graph[col].basicType;
191 } else if ( costMatrix[col][row] >= 0 ) {
192 // safe conversion from col => row
193 commonTypeMatrix[row][col] = commonTypeMatrix[col][row] = graph[row].basicType;
194 } else {
195 // need to find least common ancestor
196 // can cheat a bit here, in that there is always a direct ancestor of the later (col) element
197 int i = graph[col].left;
198 if ( i == -1 ) assert("invalid ancestor assumption");
199 if ( costMatrix[row][i] >= 0 ) {
200 commonTypeMatrix[row][col] = commonTypeMatrix[col][row] = graph[i].basicType;
201 return;
202 } // if
203
204 i = graph[col].middle;
205 if ( i == -1 ) assert("invalid ancestor assumption");
206 if ( costMatrix[row][i] >= 0 ) {
207 commonTypeMatrix[row][col] = commonTypeMatrix[col][row] = graph[i].basicType;
208 return;
209 } // if
210
211 i = graph[col].right;
212 if ( i == -1 ) assert("invalid ancestor assumption");
213 if ( costMatrix[row][i] >= 0 ) {
214 commonTypeMatrix[row][col] = commonTypeMatrix[col][row] = graph[i].basicType;
215 return;
216 } // if
217
218 assert("invalid ancestor assumption");
219 } // if
220} // generateCommonType
221
222void resetInput( fstream & file, const char * filename, stringstream & buffer, stringstream & code, string & str ) {
223 file.close();
224 buffer.str( "" );
225 code.str( "" );
226 file.open( filename, fstream::in );
227 if ( file.fail() ) {
228 cout << "Internal error, could not open " << filename << " for input." << endl;
229 abort();
230 } // if
231 buffer << file.rdbuf();
232 str = buffer.str();
233} // resetInput
234
235void output( fstream & file, const char * filename, stringstream & code ) {
236 file.close();
237 file.open( filename, fstream::out );
238 if ( file.fail() ) {
239 cout << "Internal error, could not open " << filename << " for output." << endl;
240 abort();
241 } // if
242 file << code.rdbuf(); // overwrite file
243} // output
244
245void Abort( const char * kind, const char * file ) {
246 cerr << "Internal error, could not find " << kind << " of generated code for " << file << endl;
247} // Abort
248
249int main() {
250 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // initialization
251 for ( int c = 0; c < NUMBER_OF_BASIC_TYPES; c += 1 ) {
252 costMatrix[r][c] = -1;
253 signMatrix[r][c] = -1;
254 commonTypeMatrix[r][c] = NUMBER_OF_BASIC_TYPES;
255 } // for
256 } // for
257 int lastInteger = NUMBER_OF_BASIC_TYPES;
258
259 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // perform breath-first traversal to generate cost graph
260 generateCosts(r);
261 } // for
262
263 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // use cost graph to find nearest-common-ancestor
264 for (int c = r; c < NUMBER_OF_BASIC_TYPES; c += 1 ) {
265 generateCommonType(r, c);
266 } // for
267 } // for
268
269 // Find the last integer type.
270 // Assumes at least 1, and all come before the floating types.
271 for ( int i = 1 ; i < NUMBER_OF_BASIC_TYPES ; i += 1 ) {
272 if ( Floating == graph[i].sign ) {
273 lastInteger = (i - 1);
274 break;
275 }
276 }
277
278 #define STARTMK "// GENERATED START, DO NOT EDIT"
279 #define ENDMK "// GENERATED END"
280 string BYMK( __FILE__ );
281 string::size_type posn = BYMK.find_last_of( "/" );
282 if ( posn != string::npos ) BYMK.erase( 0, posn - 1); // remove directories
283 BYMK = "// GENERATED BY " + BYMK;
284
285 fstream file;
286 stringstream buffer, code;
287 string str;
288 size_t start, end;
289
290 #define TypeH_AST TOP_SRCDIR "src/AST/BasicKind.hpp"
291 resetInput( file, TypeH_AST, buffer, code, str );
292
293 if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH_AST );
294 start += sizeof( STARTMK ); // includes newline
295 code << str.substr( 0, start );
296
297 code << BYMK << endl;
298 code << "enum BasicKind {" << endl;
299 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
300 code << "\t" << graph[r].name << "," << endl;
301 } // for
302 code << "\tNUMBER_OF_BASIC_TYPES," << endl;
303 code << "\tMAX_INTEGER_TYPE = " << graph[lastInteger].name << "," << endl;
304 code << "};" << endl;
305
306 if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH_AST );
307 code << str.substr( start );
308
309 output( file, TypeH_AST, code );
310 // cout << code.str();
311
312
313 #define TypeC_AST TOP_SRCDIR "src/AST/Type.cpp"
314 resetInput( file, TypeC_AST, buffer, code, str );
315
316 if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC_AST );
317 start += sizeof( STARTMK ); // includes newline
318 code << str.substr( 0, start );
319
320 code << BYMK << endl;
321 code << "const char * BasicType::typeNames[] = {" << endl;
322 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
323 code << "\t\"" << graph[r].type << "\"," << endl;
324 } // for
325 code << "};" << endl;
326
327 if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeC_AST );
328 code << str.substr( start );
329
330 output( file, TypeC_AST, code );
331 // cout << code.str();
332
333
334 #define ConversionCost TOP_SRCDIR "src/ResolvExpr/ConversionCost.cpp"
335 resetInput( file, ConversionCost, buffer, code, str );
336
337 if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", ConversionCost );
338 start += sizeof( STARTMK ); // includes newline
339 code << str.substr( 0, start );
340
341 code << "\t" << BYMK << endl;
342 code << "\t/* EXTENDED INTEGRAL RANK HIERARCHY (root to leaves)" << endl;
343 for ( int c = 0; c < NUMBER_OF_BASIC_TYPES; c += 1 ) {
344 code << '\t' << left;
345 if ( graph[c].rank != graph[c + 1].rank ) {
346 code << right << setw(30) << graph[c].type << left;
347 } else if ( graph[c].rank != graph[c + 2].rank ) {
348 code << string( 10, ' ' ) << setw(25) << graph[c].type << graph[c + 1].type;
349 c += 1;
350 } else {
351 code << setw(20) << graph[c].type << setw(20) << graph[c + 1].type << graph[c + 2].type;
352 c += 2;
353 } // if
354 code << endl;
355 } // for
356 code << right << "\t*/" << endl;
357 code << "\t"; // indentation for end marker
358
359 if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", ConversionCost );
360 if ( (end = str.find( STARTMK, start + 1 )) == string::npos ) Abort( "start", ConversionCost );
361 end += sizeof( STARTMK );
362 code << str.substr( start, end - start );
363
364 code << "\t" << BYMK << endl;
365 code << "\tstatic const int costMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // path length from root to node" << endl
366 << "\t\t/* ";
367 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
368 code << setw(5) << graph[r].abbrev;
369 } // for
370 code << " */" << endl;
371 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // costs
372 code << "\t\t/* " << setw(6) << graph[r].abbrev << " */ {";
373 for ( int c = 0; c < NUMBER_OF_BASIC_TYPES; c += 1 ) {
374 code << setw(4) << costMatrix[r][c] << ",";
375 } // for
376 code << " }," << endl;
377 } // for
378 code << "\t}; // costMatrix" << endl;
379
380 // maximum conversion cost from int
381 code << "\tstatic const int maxIntCost = " << *max_element(costMatrix[SignedInt], costMatrix[SignedInt] + NUMBER_OF_BASIC_TYPES) << ";" << endl;
382 code << "\t"; // indentation for end marker
383
384 if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", ConversionCost );
385 if ( (end = str.find( STARTMK, start + 1 )) == string::npos ) Abort( "start", ConversionCost );
386 end += sizeof( STARTMK );
387 code << str.substr( start, end - start );
388
389 code << "\t" << BYMK << endl;
390 code << "\tstatic const int signMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion" << endl
391 << "\t\t/* ";
392 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
393 code << setw(5) << graph[r].abbrev;
394 } // for
395 code << " */" << endl;
396 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // costs
397 code << "\t\t/* " << setw(6) << graph[r].abbrev << " */ {";
398 for ( int c = 0; c < NUMBER_OF_BASIC_TYPES; c += 1 ) {
399 code << setw(4) << signMatrix[r][c] << ",";
400 } // for
401 code << " }," << endl;
402 } // for
403 code << "\t}; // signMatrix" << endl;
404 code << "\t"; // indentation for end marker
405
406 if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", ConversionCost );
407 code << str.substr( start );
408
409 output( file, ConversionCost, code );
410 // cout << code.str();
411
412
413 #define CommonType TOP_SRCDIR "src/ResolvExpr/CommonType.cpp"
414 resetInput( file, CommonType, buffer, code, str );
415
416 if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", CommonType );
417 start += sizeof( STARTMK ); // includes newline
418 code << str.substr( 0, start );
419
420 enum { PER_ROW = 6 };
421 code << "\t" << BYMK << endl;
422 code << "\t#define BT ast::BasicKind::" << endl;
423 code << "\tstatic const ast::BasicKind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor" << endl
424 << "\t\t/*\t\t ";
425 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
426 code << setw(24) << graph[r].abbrev;
427 if ( (r+1) % PER_ROW == 0 ) {
428 code << endl << "\t\t\t\t ";
429 } // if
430 } // for
431 code << "*/" << endl;
432 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // costs
433 code << "\t\t\t\t {\n\t\t/* " << setw(6) << graph[r].abbrev << " */";
434 for ( int c = 0; c < NUMBER_OF_BASIC_TYPES; c += 1 ) {
435 string s = string{"BT "} + graph[commonTypeMatrix[r][c]].name;
436 code << setw(23) << s << ",";
437 if ( (c+1) % PER_ROW == 0 ) {
438 code << endl << "\t\t\t\t ";
439 } // if
440 } // for
441 code << "}," << endl;
442 } // for
443 code << "\t}; // commonTypes" << endl;
444 code << "\t#undef BT" << endl;
445 code << "\t"; // indentation for end marker
446
447 if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", CommonType );
448 code << str.substr( start );
449
450 output( file, CommonType, code );
451 // cout << code.str();
452
453
454 #define ManglerCommon TOP_SRCDIR "src/SymTab/ManglerCommon.cpp"
455 resetInput( file, ManglerCommon, buffer, code, str );
456
457 if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", ManglerCommon );
458 start += sizeof( STARTMK ); // includes newline
459 code << str.substr( 0, start );
460
461 code <<
462 "// GENERATED BY " __FILE__ "\n"
463 "// NOTES ON MANGLING:\n"
464 "// * Itanium spec says that Float80 encodes to \"e\" (like LongDouble), but the distinct lengths cause resolution problems.\n"
465 "// * Float128 is supposed to encode to \"g\", but I wanted it to mangle equal to LongDouble.\n"
466 "// * Mangling for non-standard complex types is by best guess\n"
467 "// * _FloatN is supposed to encode as \"DF\"N\"_\"; modified for same reason as above.\n"
468 "// * unused mangling identifiers:\n"
469 "// - \"z\" ellipsis\n"
470 "// - \"Dd\" IEEE 754r 64-bit decimal floating point (borrowed for _Float32x)\n"
471 "// - \"De\" IEEE 754r 128-bit decimal floating point\n"
472 "// - \"Df\" IEEE 754r 32-bit decimal floating point\n"
473 "// - \"Dh\" IEEE 754r 16-bit decimal floating point (borrowed for _Float16)\n"
474 "// - \"DF\"N\"_\" ISO/IEC TS 18661 N-bit binary floating point (_FloatN)\n"
475 "// - \"Di\" char32_t\n"
476 "// - \"Ds\" char16_t\n";
477
478 code << "const std::string basicTypes[ast::BasicKind::NUMBER_OF_BASIC_TYPES] = {" << endl;
479 for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
480 code << "\t\"" << graph[r].mangled << "\"," << setw(9 - strlen(graph[r].mangled)) << ' ' << "// " << graph[r].type << endl;
481 } // for
482 code << "}; // basicTypes" << endl;
483
484 if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", ManglerCommon );
485 code << str.substr( start );
486
487 output( file, ManglerCommon, code );
488 // cout << code.str();
489} // main
490
491// Local Variables: //
492// tab-width: 4 //
493// mode: c++ //
494// compile-command: "g++-8 -Wall -Wextra BasicTypes-gen.cpp" //
495// End: //
Note: See TracBrowser for help on using the repository browser.