Changes in src/Parser/ExpressionNode.cc [db70fe4:beec62c]

File:

• src/Parser/ExpressionNode.cc (modified) (6 diffs)

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Sep 14 23:09:34 2017
-// Update Count     : 690
+// Last Modified On : Tue Sep 12 10:00:29 2017
+// Update Count     : 672
 //
 
@@ -250 +250 @@
         sepString( str, units, '"' );                                           // separate constant from units
 
-        Type * strtype;
-        switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string "" => safe to look at subscripts 0/1
+        BasicType::Kind strtype = BasicType::Char;                      // default string type
+        switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string ""
           case 'u':
-                if ( str[1] == '8' ) goto Default;                              // utf-8 characters => array of char
-                // lookup type of associated typedef
-                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char16_t", false );
+                if ( str[1] == '8' ) break;                                             // utf-8 characters
+                strtype = BasicType::ShortUnsignedInt;
                 break;
           case 'U':
-                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char32_t", false );
+                strtype = BasicType::UnsignedInt;
                 break;
           case 'L':
-                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "wchar_t", false );
+                strtype = BasicType::SignedInt;
                 break;
-          Default:                                                                                      // char default string type
-          default:
-                strtype = new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char );
         } // switch
-        ArrayType * at = new ArrayType( noQualifiers, strtype,
+        ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), strtype ),
                                                                         new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
                                                                         false, false );
@@ -348 +344 @@
 
 Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
-        return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );
+        Type * targetType = maybeMoveBuildType( decl_node );
+        Expression * castArg = maybeMoveBuild< Expression >( expr_node );
+        return new VirtualCastExpr( castArg, targetType );
 } // build_virtual_cast
 
 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
-        return new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+        UntypedMemberExpr * ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+        return ret;
 } // build_fieldSel
 
@@ -362 +361 @@
         return ret;
 } // build_pfieldSel
+
+Expression * build_addressOf( ExpressionNode * expr_node ) {
+                return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
+} // build_addressOf
+
+Expression * build_sizeOfexpr( ExpressionNode * expr_node ) {
+        return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
+} // build_sizeOfexpr
+
+Expression * build_sizeOftype( DeclarationNode * decl_node ) {
+        return new SizeofExpr( maybeMoveBuildType( decl_node ) );
+} // build_sizeOftype
+
+Expression * build_alignOfexpr( ExpressionNode * expr_node ) {
+        return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
+} // build_alignOfexpr
+
+Expression * build_alignOftype( DeclarationNode * decl_node ) {
+        return new AlignofExpr( maybeMoveBuildType( decl_node) );
+} // build_alignOftype
 
 Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
@@ -403 +422 @@
 } // build_cond
 
+Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
+        return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) );
+} // build_comma
+
+Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ) {
+        return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
+} // build_attrexpr
+
+Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ) {
+        return new AttrExpr( var, maybeMoveBuildType( decl_node ) );
+} // build_attrtype
+
 Expression * build_tuple( ExpressionNode * expr_node ) {
         list< Expression * > exprs;
@@ -414 +445 @@
         return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
 } // build_func
+
+Expression * build_range( ExpressionNode * low, ExpressionNode * high ) {
+        return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
+} // build_range
+
+Expression * build_asmexpr( ExpressionNode * inout, Expression * constraint, ExpressionNode * operand ) {
+        return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) );
+} // build_asmexpr
+
+Expression * build_valexpr( StatementNode * s ) {
+        return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) );
+} // build_valexpr
+
+Expression * build_typevalue( DeclarationNode * decl ) {
+        return new TypeExpr( maybeMoveBuildType( decl ) );
+} // build_typevalue
 
 Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {