Changes in / [3e135c8:76b507d]

Files:

• libcfa/src/enum.cfa (modified) (1 diff)
• libcfa/src/enum.hfa (modified) (3 diffs)
• src/AST/Expr.cpp (modified) (1 diff)
• src/AST/Expr.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Print.cpp (modified) (1 diff)
• src/ControlStruct/TranslateEnumRange.cpp (modified) (1 diff)
• src/Parser/parser.yy (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (1 diff)
• src/Validate/ImplementEnumFunc.cpp (modified) (2 diffs)

libcfa/src/enum.cfa

@@ -5 +5 @@
 
 #pragma GCC visibility push(default)
+
+forall( E | Serial( E ) ) {
+    E fromInt( unsigned i ) {
+        E upper = upperBound();
+        E lower = lowerBound();
+        // It is okay to overflow as overflow will be theoretically caught by the other bound
+        assert( i <= fromInstance(upper) && i >= fromInstance(lower) 
+            &&  "Not a valid value");
+        return fromInt_unsafe( i );
+    }
+
+    E succ( E e ) {
+        E upper = upperBound();
+        assert( (fromInstance(e) < fromInstance(upper)) 
+            && "Calling succ() on the last" );
+        return succ_unsafe(e);
+    }
+
+    E pred( E e ) {
+        E lower = lowerBound();
+        assert( (fromInstance(e) > fromInstance(lower)) 
+            && "Calling pred() on the first" );
+        return pred_unsafe(e);
+    }
+
+    int Countof( __attribute__((unused)) E e ) {
+        E upper = upperBound();
+        E lower = lowerBound();
+                return fromInstance( upper ) + fromInstance( lower ) + 1;
+    }
+}
 
 int scmp( const void * str1, const void * str2 ) {

libcfa/src/enum.hfa

@@ -1 +1 @@
 #pragma once
 
+#include <assert.h>
 #include "iostream.hfa"
 
@@ -10 +11 @@
 forall( E | Bounded( E ) ) trait Serial {
     unsigned fromInstance( E e );
+    E fromInt_unsafe( unsigned i );
+    E succ_unsafe( E e );
+    E pred_unsafe( E e );
+};
+
+forall( E | Serial( E ) ) {
     E fromInt( unsigned i );
     E succ( E e );
     E pred( E e );
-};
+    int Countof( E e );
+}
+
+// forall( E | Bounded(E) ) trait SafeSerial {
+//     // unsigned fromInstance( E e );
+//     E fromInt_unsafe( unsigned i );
+//     // E succ_unsafe( E e );
+//     //E pred_unsafe( E e );
+
+//     unsigned fromInstance( E e );
+//     E fromInt( unsigned i );
+//     E succ( E e );
+//     E pred( E e );
+// };
 
 forall( E | Serial( E ) ) trait CfaEnum {
@@ -33 +53 @@
         OSTYPE_VOID( E );
 }
-
-// forall( ostype & | ostream( ostype ), E | CfaEnum( E, quasi_void ) ) {
-//      ostype & ?|?( ostype &, E );
-//      OSTYPE_VOID( E );
-// }
-
-// Design two <- should go for this if we have change the cost model
-// forall( E | Serial( E ) ) trait CfaEnum {
-//     char * label( E e );
-//     unsigned int posn( E e );
-// };
-
-// forall( E, V| CfaEnum( E)) trait TypedEnum {
-//     V value( E e);
-// };
 
 static inline

src/AST/Expr.cpp

@@ -284 +284 @@
 // --- CountExpr
 
+CountExpr::CountExpr( const CodeLocation & loc, const Expr * e )
+: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(e), type( nullptr ) {}
+
 CountExpr::CountExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), type( t ) {}
+: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(nullptr), type( t ) {}
 
 // --- AlignofExpr

src/AST/Expr.hpp

@@ -496 +496 @@
 class CountExpr final : public Expr {
 public:
+        ptr<Expr> expr;
         ptr<Type> type;
 
+        CountExpr( const CodeLocation & loc, const Expr * t );
         CountExpr( const CodeLocation & loc, const Type * t );
 

src/AST/Pass.impl.hpp

@@ -1339 +1339 @@
                         maybe_accept( node, &CountExpr::result );
                 }
-                maybe_accept( node, &CountExpr::type );
+                if ( node->type ) {
+                        maybe_accept( node, &CountExpr::type );
+                } else {
+                        maybe_accept( node, &CountExpr::expr );
+                }
         }
         VISIT_END( Expr, node );

src/AST/Print.cpp

@@ -1146 +1146 @@
                 os << "Count Expression on: ";
                 ++indent;
-                node->type->accept( *this );
+                if ( node->type ) node->type->accept( *this );
+                else safe_print( node->expr );
                 --indent;
                 postprint( node );

src/ControlStruct/TranslateEnumRange.cpp

@@ -81 +81 @@
             ast::UntypedExpr::createCall( location, "upperBound", {} )  });
     auto increment = ast::UntypedExpr::createCall( location, 
-        stmt->is_inc? "succ": "pred",
+        stmt->is_inc? "succ_unsafe": "pred_unsafe",
         { new ast::NameExpr( location, indexName ) });
     auto assig = ast::UntypedExpr::createAssign( location, new ast::NameExpr( location, indexName ), increment );

src/Parser/parser.yy

@@ -970 +970 @@
                         // $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) );
                 }
+        | COUNTOF unary_expression
+                {  $$ = new ExpressionNode( new ast::CountExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
         | COUNTOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( new ast::CountExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
-        | COUNTOF unary_expression
-                { SemanticError( yylloc, "countof for expressions is currently unimplemented. "); $$ = nullptr; }
         ;
 

src/ResolvExpr/CandidateFinder.cpp

@@ -1485 +1485 @@
 
         void Finder::postvisit( const ast::CountExpr * countExpr ) {
-                assert( countExpr->type );
-                auto enumInst = countExpr->type.as<ast::EnumInstType>();
-                if ( !enumInst ) {
-                        SemanticError( countExpr, "Count Expression only supports Enum Type as operand: ");
-                }
-                addCandidate( ast::ConstantExpr::from_ulong(countExpr->location, enumInst->base->members.size()), tenv );
+                const ast::UntypedExpr * untyped;
+                if ( countExpr->type ) {
+                        auto enumInst = countExpr->type.as<ast::EnumInstType>();
+                        if ( enumInst ) {
+                                addCandidate( ast::ConstantExpr::from_ulong(countExpr->location, enumInst->base->members.size()), tenv );
+                                return;
+                        }
+                        auto untypedFirst = ast::UntypedExpr::createCall( countExpr->location, "lowerBound", {} );
+                        auto castFirst = new ast::CastExpr( countExpr->location, untypedFirst , countExpr->type );
+                        untyped = ast::UntypedExpr::createCall(
+                                countExpr->location, "Countof", { castFirst }
+                        );
+                }
+                if (!untyped) untyped = ast::UntypedExpr::createCall(
+                                countExpr->location, "Countof", { countExpr->expr }
+                );
+                CandidateFinder finder( context, tenv );
+                finder.find( untyped );
+                CandidateList winners = findMinCost( finder.candidates );
+                if ( winners.size() == 0 ) {
+                        SemanticError( countExpr->expr, "Countof is not implemented for operand: " );
+                }
+                if ( winners.size() !=  1 ) {
+                        SemanticError( countExpr->expr, "Ambiguous expression in countof operand: " );
+                }
+                CandidateRef & choice = winners.front();
+                choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
+                addCandidate( *choice, choice->expr );
         }
 

src/Validate/ImplementEnumFunc.cpp

@@ -228 +228 @@
 ast::FunctionDecl* EnumAttrFuncGenerator::genFromIntProto() const {
         return genProto(
-                "fromInt",
+                "fromInt_unsafe",
                 {new ast::ObjectDecl(getLocation(), "_i", new ast::BasicType(ast::BasicKind::UnsignedInt))},
                 {new ast::ObjectDecl(getLocation(), "_ret", new ast::EnumInstType(decl))}
@@ -313 +313 @@
                 genFromIntProto(),
                 genFromInstanceProto(),
-                genInstToInstFuncProto("succ"),
-                genInstToInstFuncProto("pred")
+                genInstToInstFuncProto("succ_unsafe"),
+                genInstToInstFuncProto("pred_unsafe")
         };
         for (auto& proto: protos) produceForwardDecl(proto);