Changes in src/AST/Convert.cpp [6f4b7f2:f685679]

File:

• src/AST/Convert.cpp (modified) (5 diffs)

src/AST/Convert.cpp

@@ -397 +397 @@
                 ThrowStmt::Kind kind;
                 switch (node->kind) {
-                case ast::ExceptionKind::Terminate:
+                case ast::ThrowStmt::Terminate:
                         kind = ThrowStmt::Terminate;
                         break;
-                case ast::ExceptionKind::Resume:
+                case ast::ThrowStmt::Resume:
                         kind = ThrowStmt::Resume;
                         break;
@@ -429 +429 @@
                 CatchStmt::Kind kind;
                 switch (node->kind) {
-                case ast::ExceptionKind::Terminate:
+                case ast::CatchStmt::Terminate:
                         kind = CatchStmt::Terminate;
                         break;
-                case ast::ExceptionKind::Resume:
+                case ast::CatchStmt::Resume:
                         kind = CatchStmt::Resume;
                         break;
@@ -704 +704 @@
         }
 
+        bool isIntlikeConstantType(const ast::Type *t) {
+                if ( const ast::BasicType * basicType = dynamic_cast< const ast::BasicType * >( t ) ) {
+                        if ( basicType->isInteger() ) {
+                                return true;
+                        }
+                } else if ( dynamic_cast< const ast::OneType * >( t ) ) {
+                        return true;
+                } else if ( dynamic_cast< const ast::ZeroType * >( t ) ) {
+                        return true;
+                } else if ( dynamic_cast< const ast::PointerType * >( t ) ) {
+                        // null pointer constants, with zero int-values
+                        return true;
+                }
+                return false;
+        }
+
+        bool isFloatlikeConstantType(const ast::Type *t) {
+                if ( const ast::BasicType * bty = dynamic_cast< const ast::BasicType * >( t ) ) {
+                        if ( ! bty->isInteger() ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        bool isStringlikeConstantType(const ast::Type *t) {
+                if ( const ast::ArrayType * aty = dynamic_cast< const ast::ArrayType * >( t ) ) {
+                        if ( const ast::BasicType * bty = aty->base.as<ast::BasicType>() ) {
+                           if ( bty->kind == ast::BasicType::Kind::Char ) {
+                                   return true;
+                           }
+                        }
+                }
+                return false;
+        }
+
         const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
                 ConstantExpr *rslt = nullptr;
-                switch ( node->kind ) {
-                case ast::ConstantExpr::Integer:
-                        rslt = new ConstantExpr{Constant{
-                                get<Type>().accept1( node->result ),
+                if (isIntlikeConstantType(node->result)) {
+                        rslt = new ConstantExpr(Constant(
+                                get<Type>().accept1(node->result),
                                 node->rep,
                                 (unsigned long long) node->intValue()
-                        }};
-                        break;
-                case ast::ConstantExpr::FloatingPoint:
-                        rslt = new ConstantExpr{Constant{
+                        ));
+                } else if (isFloatlikeConstantType(node->result)) {
+                        rslt = new ConstantExpr(Constant(
                                 get<Type>().accept1(node->result),
                                 node->rep,
                                 (double) node->floatValue()
-                        }};
-                        break;
-                case ast::ConstantExpr::String:
-                        rslt = new ConstantExpr{Constant::from_string( node->rep )};
-                        break;
+                        ));
+                } else if (isStringlikeConstantType(node->result)) {
+                        rslt = new ConstantExpr(Constant::from_string(
+                                node->rep
+                        ));
                 }
                 assert(rslt);
@@ -1739 +1773 @@
         virtual void visit( ThrowStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                ast::ExceptionKind kind;
+                ast::ThrowStmt::Kind kind;
                 switch (old->kind) {
                 case ThrowStmt::Terminate:
-                        kind = ast::ExceptionKind::Terminate;
+                        kind = ast::ThrowStmt::Terminate;
                         break;
                 case ThrowStmt::Resume:
-                        kind = ast::ExceptionKind::Resume;
+                        kind = ast::ThrowStmt::Resume;
                         break;
                 default:
@@ -1775 +1809 @@
         virtual void visit( CatchStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                ast::ExceptionKind kind;
+                ast::CatchStmt::Kind kind;
                 switch (old->kind) {
                 case CatchStmt::Terminate:
-                        kind = ast::ExceptionKind::Terminate;
+                        kind = ast::CatchStmt::Terminate;
                         break;
                 case CatchStmt::Resume:
-                        kind = ast::ExceptionKind::Resume;
+                        kind = ast::CatchStmt::Resume;
                         break;
                 default: