source: src/BasicTypes-gen.cpp@ 9a01745

Last change on this file since 9a01745 was 0185b68, checked in by Andrew Beach <ajbeach@…>, 12 months ago

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