Context Navigation

source: src/Parser/ExpressionNode.cc @ 513e165

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc

Last change on this file since 513e165 was 513e165, checked in by Peter A. Buhr <pabuhr@…>, 7 years ago
generalize types for encoded strings, and fold simple ExpressionNode? build routines into parser
Property mode set to `100644`
File size: 19.6 KB

Line
1	//
2	// Cforall Version 1.0.0 Copyright (C) 2015 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	// ExpressionNode.cc --
8	//
9	// Author : Peter A. Buhr
10	// Created On : Sat May 16 13:17:07 2015
11	// Last Modified By : Peter A. Buhr
12	// Last Modified On : Wed Sep 13 14:54:19 2017
13	// Update Count : 683
14	//
15
16	#include <cassert> // for assert
17	#include <stdio.h> // for sscanf, size_t
18	#include <climits> // for LLONG_MAX, LONG_MAX, INT_MAX, UINT...
19	#include <list> // for list
20	#include <sstream> // for basic_istream::operator>>, basic_i...
21	#include <string> // for string, operator+, operator==
22
23	#include "Common/SemanticError.h" // for SemanticError
24	#include "Common/utility.h" // for maybeMoveBuild, maybeBuild, CodeLo...
25	#include "ParseNode.h" // for ExpressionNode, maybeMoveBuildType
26	#include "SynTree/Constant.h" // for Constant
27	#include "SynTree/Declaration.h" // for EnumDecl, StructDecl, UnionDecl
28	#include "SynTree/Expression.h" // for Expression, ConstantExpr, NameExpr
29	#include "SynTree/Statement.h" // for CompoundStmt, Statement
30	#include "SynTree/Type.h" // for BasicType, Type, Type::Qualifiers
31	#include "parserutility.h" // for notZeroExpr
32
33	class Initializer;
34
35	using namespace std;
36
37	//##############################################################################
38
39	// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
40	//
41	// prefix action constant action suffix
42	//
43	// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
44	//
45	// constant BEGIN CONT ...
46	// <CONT>(...)? BEGIN 0 ... // possible empty suffix
47	//
48	// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
49	// type.
50
51	extern const Type::Qualifiers noQualifiers; // no qualifiers on constants
52
53	static inline bool checkH( char c ) { return c == 'h' \|\| c == 'H'; }
54	static inline bool checkL( char c ) { return c == 'l' \|\| c == 'L'; }
55	static inline bool checkZ( char c ) { return c == 'z' \|\| c == 'Z'; }
56	static inline bool checkU( char c ) { return c == 'u' \|\| c == 'U'; }
57	static inline bool checkF( char c ) { return c == 'f' \|\| c == 'F'; }
58	static inline bool checkD( char c ) { return c == 'd' \|\| c == 'D'; }
59	static inline bool checkI( char c ) { return c == 'i' \|\| c == 'I'; }
60	static inline bool checkX( char c ) { return c == 'x' \|\| c == 'X'; }
61
62	static void sepNumeric( string & str, string & units ) {
63	string::size_type posn = str.find_first_of( "`" );
64	if ( posn != string::npos ) {
65	units = "?" + str.substr( posn ); // extract units
66	str.erase( posn ); // remove units
67	} // if
68	} // sepNumeric
69
70	Expression * build_constantInteger( string & str ) {
71	static const BasicType::Kind kind[2][5] = {
72	// short (h) must be before char (hh)
73	{ BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
74	{ BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
75	};
76
77	string units; // units
78	sepNumeric( str, units ); // separate constant from units
79
80	bool dec = true, Unsigned = false; // decimal, unsigned constant
81	int size; // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t
82	unsigned long long int v; // converted integral value
83	size_t last = str.length() - 1; // last character of constant
84	Expression * ret;
85
86	// special constants
87	if ( str == "0" ) {
88	ret = new ConstantExpr( Constant( (Type *)new ZeroType( noQualifiers ), str, (unsigned long long int)0 ) );
89	goto CLEANUP;
90	} // if
91	if ( str == "1" ) {
92	ret = new ConstantExpr( Constant( (Type *)new OneType( noQualifiers ), str, (unsigned long long int)1 ) );
93	goto CLEANUP;
94	} // if
95
96	if ( str[0] == '0' ) { // octal/hex constant ?
97	dec = false;
98	if ( last != 0 && checkX( str[1] ) ) { // hex constant ?
99	sscanf( (char *)str.c_str(), "%llx", &v );
100	//printf( "%llx %llu\n", v, v );
101	} else { // octal constant
102	sscanf( (char *)str.c_str(), "%llo", &v );
103	//printf( "%llo %llu\n", v, v );
104	} // if
105	} else { // decimal constant ?
106	sscanf( (char *)str.c_str(), "%llu", &v );
107	//printf( "%llu %llu\n", v, v );
108	} // if
109
110	if ( v <= INT_MAX ) { // signed int
111	size = 2;
112	} else if ( v <= UINT_MAX && ! dec ) { // unsigned int
113	size = 2;
114	Unsigned = true; // unsigned
115	} else if ( v <= LONG_MAX ) { // signed long int
116	size = 3;
117	} else if ( v <= ULONG_MAX && ( ! dec \|\| LONG_MAX == LLONG_MAX ) ) { // signed long int
118	size = 3;
119	Unsigned = true; // unsigned long int
120	} else if ( v <= LLONG_MAX ) { // signed long long int
121	size = 4;
122	} else { // unsigned long long int
123	size = 4;
124	Unsigned = true; // unsigned long long int
125	} // if
126
127	// At least one digit in integer constant, so safe to backup while looking for suffix.
128
129	if ( checkU( str[last] ) ) { // suffix 'u' ?
130	Unsigned = true;
131	if ( checkL( str[last - 1] ) ) { // suffix 'l' ?
132	size = 3;
133	if ( checkL( str[last - 2] ) ) { // suffix "ll" ?
134	size = 4;
135	} // if
136	} else if ( checkH( str[last - 1] ) ) { // suffix 'h' ?
137	size = 0;
138	if ( checkH( str[last - 2] ) ) { // suffix "hh" ?
139	size = 1;
140	} // if
141	str.erase( last - size - 1, size + 1 ); // remove 'h'/"hh"
142	} // if
143	} else if ( checkL( str[ last ] ) ) { // suffix 'l' ?
144	size = 3;
145	if ( checkL( str[last - 1] ) ) { // suffix 'll' ?
146	size = 4;
147	if ( checkU( str[last - 2] ) ) { // suffix 'u' ?
148	Unsigned = true;
149	} // if
150	} else if ( checkU( str[last - 1] ) ) { // suffix 'u' ?
151	Unsigned = true;
152	} // if
153	} else if ( checkH( str[ last ] ) ) { // suffix 'h' ?
154	size = 0;
155	if ( checkH( str[last - 1] ) ) { // suffix "hh" ?
156	size = 1;
157	if ( checkU( str[last - 2] ) ) { // suffix 'u' ?
158	Unsigned = true;
159	} // if
160	} else if ( checkU( str[last - 1] ) ) { // suffix 'u' ?
161	Unsigned = true;
162	} // if
163	str.erase( last - size, size + 1 ); // remove 'h'/"hh"
164	} else if ( checkZ( str[last] ) ) { // suffix 'z' ?
165	size = 5;
166	str.erase( last, 1 ); // remove 'z'
167	} // if
168
169	ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
170	if ( Unsigned && size < 2 ) { // less than int ?
171	// int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values.
172	ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
173	} else if ( size == 5 ) { // explicit cast to size_t
174	ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) );
175	} // if
176	CLEANUP:
177	if ( units.length() != 0 ) {
178	ret = new UntypedExpr( new NameExpr( units ), { ret } );
179	} // if
180
181	delete &str; // created by lex
182	return ret;
183	} // build_constantInteger
184
185	Expression * build_constantFloat( string & str ) {
186	static const BasicType::Kind kind[2][3] = {
187	{ BasicType::Float, BasicType::Double, BasicType::LongDouble },
188	{ BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
189	};
190
191	string units; // units
192	sepNumeric( str, units ); // separate constant from units
193
194	bool complx = false; // real, complex
195	int size = 1; // 0 => float, 1 => double (default), 2 => long double
196	// floating-point constant has minimum of 2 characters: 1. or .1
197	size_t last = str.length() - 1;
198	double v;
199
200	sscanf( str.c_str(), "%lg", &v );
201
202	if ( checkI( str[last] ) ) { // imaginary ?
203	complx = true;
204	last -= 1; // backup one character
205	} // if
206
207	if ( checkF( str[last] ) ) { // float ?
208	size = 0;
209	} else if ( checkD( str[last] ) ) { // double ?
210	size = 1;
211	} else if ( checkL( str[last] ) ) { // long double ?
212	size = 2;
213	} // if
214	if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ?
215	complx = true;
216	} // if
217
218	Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
219	if ( units.length() != 0 ) {
220	ret = new UntypedExpr( new NameExpr( units ), { ret } );
221	} // if
222
223	delete &str; // created by lex
224	return ret;
225	} // build_constantFloat
226
227	static void sepString( string & str, string & units, char delimit ) {
228	string::size_type posn = str.find_last_of( delimit ) + 1;
229	if ( posn != str.length() ) {
230	units = "?" + str.substr( posn ); // extract units
231	str.erase( posn ); // remove units
232	} // if
233	} // sepString
234
235	Expression * build_constantChar( string & str ) {
236	string units; // units
237	sepString( str, units, '\'' ); // separate constant from units
238
239	Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
240	if ( units.length() != 0 ) {
241	ret = new UntypedExpr( new NameExpr( units ), { ret } );
242	} // if
243
244	delete &str; // created by lex
245	return ret;
246	} // build_constantChar
247
248	Expression * build_constantStr( string & str ) {
249	string units; // units
250	sepString( str, units, '"' ); // separate constant from units
251
252	Type * strtype;
253	switch ( str[0] ) { // str has >= 2 characters, i.e, null string "" => safe to look at subscripts 0/1
254	case 'u':
255	if ( str[1] == '8' ) goto Default; // utf-8 characters => array of char
256	// lookup type of associated typedef
257	strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char16_t", false );
258	break;
259	case 'U':
260	strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char32_t", false );
261	break;
262	case 'L':
263	strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "wchar_t", false );
264	break;
265	Default: // char default string type
266	default:
267	strtype = new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char );
268	} // switch
269	ArrayType * at = new ArrayType( noQualifiers, strtype,
270	new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
271	false, false );
272	Expression * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value
273	if ( units.length() != 0 ) {
274	ret = new UntypedExpr( new NameExpr( units ), { ret } );
275	} // if
276
277	delete &str; // created by lex
278	return ret;
279	} // build_constantStr
280
281	Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
282	if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
283	Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
284	delete &str;
285	return ret;
286	} // build_field_name_FLOATING_FRACTIONconstant
287
288	Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
289	if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
290	Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
291	delete &str;
292	return ret;
293	} // build_field_name_FLOATING_DECIMALconstant
294
295	Expression * build_field_name_FLOATINGconstant( const string & str ) {
296	// str is of the form A.B -> separate at the . and return member expression
297	int a, b;
298	char dot;
299	stringstream ss( str );
300	ss >> a >> dot >> b;
301	UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
302	delete &str;
303	return ret;
304	} // build_field_name_FLOATINGconstant
305
306	Expression * make_field_name_fraction_constants( Expression * fieldName, Expression * fracts ) {
307	if ( fracts ) {
308	if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( fracts ) ) {
309	memberExpr->set_member( make_field_name_fraction_constants( fieldName, memberExpr->get_aggregate() ) );
310	return memberExpr;
311	} else {
312	return new UntypedMemberExpr( fracts, fieldName );
313	} // if
314	} // if
315	return fieldName;
316	} // make_field_name_fraction_constants
317
318	Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) {
319	return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
320	} // build_field_name_fraction_constants
321
322	NameExpr * build_varref( const string * name ) {
323	NameExpr * expr = new NameExpr( *name, nullptr );
324	delete name;
325	return expr;
326	} // build_varref
327
328	// TODO: get rid of this and OperKinds and reuse code from OperatorTable
329	static const char * OperName[] = { // must harmonize with OperKinds
330	// diadic
331	"SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?\\?", "?*?", "?/?", "?%?", "\|\|", "&&",
332	"?\|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
333	"?=?", "?@=?", "?\\=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?\|=?",
334	"?[?]", "...",
335	// monadic
336	"+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--",
337	}; // OperName
338
339	Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
340	Type * targetType = maybeMoveBuildType( decl_node );
341	if ( dynamic_cast< VoidType * >( targetType ) ) {
342	delete targetType;
343	return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
344	} else {
345	return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
346	} // if
347	} // build_cast
348
349	Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
350	return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );
351	} // build_virtual_cast
352
353	Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
354	return new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
355	} // build_fieldSel
356
357	Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member ) {
358	UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
359	deref->location = expr_node->location;
360	deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
361	UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );
362	return ret;
363	} // build_pfieldSel
364
365	Expression * build_addressOf( ExpressionNode * expr_node ) {
366	return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
367	} // build_addressOf
368
369	Expression * build_sizeOfexpr( ExpressionNode * expr_node ) {
370	return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
371	} // build_sizeOfexpr
372
373	Expression * build_sizeOftype( DeclarationNode * decl_node ) {
374	return new SizeofExpr( maybeMoveBuildType( decl_node ) );
375	} // build_sizeOftype
376
377	Expression * build_alignOfexpr( ExpressionNode * expr_node ) {
378	return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
379	} // build_alignOfexpr
380
381	Expression * build_alignOftype( DeclarationNode * decl_node ) {
382	return new AlignofExpr( maybeMoveBuildType( decl_node) );
383	} // build_alignOftype
384
385	Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
386	Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
387	delete member;
388	return ret;
389	} // build_offsetOf
390
391	Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) {
392	return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
393	} // build_and_or
394
395	Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
396	list< Expression * > args;
397	args.push_back( maybeMoveBuild< Expression >(expr_node) );
398	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
399	} // build_unary_val
400
401	Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
402	list< Expression * > args;
403	args.push_back( maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
404	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
405	} // build_unary_ptr
406
407	Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
408	list< Expression * > args;
409	args.push_back( maybeMoveBuild< Expression >(expr_node1) );
410	args.push_back( maybeMoveBuild< Expression >(expr_node2) );
411	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
412	} // build_binary_val
413
414	Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
415	list< Expression * > args;
416	args.push_back( maybeMoveBuild< Expression >(expr_node1) );
417	args.push_back( maybeMoveBuild< Expression >(expr_node2) );
418	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
419	} // build_binary_ptr
420
421	Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) {
422	return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
423	} // build_cond
424
425	Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ) {
426	return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
427	} // build_attrexpr
428
429	Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ) {
430	return new AttrExpr( var, maybeMoveBuildType( decl_node ) );
431	} // build_attrtype
432
433	Expression * build_tuple( ExpressionNode * expr_node ) {
434	list< Expression * > exprs;
435	buildMoveList( expr_node, exprs );
436	return new UntypedTupleExpr( exprs );;
437	} // build_tuple
438
439	Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
440	list< Expression * > args;
441	buildMoveList( expr_node, args );
442	return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
443	} // build_func
444
445	Expression * build_range( ExpressionNode * low, ExpressionNode * high ) {
446	return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
447	} // build_range
448
449	Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
450	Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
451	if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
452	return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) );
453	// these types do not have associated type information
454	} else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl ) ) {
455	if ( newDeclStructDecl->has_body() ) {
456	return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) );
457	} else {
458	return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
459	} // if
460	} else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl ) ) {
461	if ( newDeclUnionDecl->has_body() ) {
462	return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) );
463	} else {
464	return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
465	} // if
466	} else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl ) ) {
467	if ( newDeclEnumDecl->has_body() ) {
468	return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) );
469	} else {
470	return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
471	} // if
472	} else {
473	assert( false );
474	} // if
475	} // build_compoundLiteral
476
477	// Local Variables: //
478	// tab-width: 4 //
479	// mode: c++ //
480	// compile-command: "make install" //
481	// End: //

Note: See TracBrowser for help on using the repository browser.

Download in other formats: