Changes in / [39cf5cc:793eb2f]

Files:

• libcfa/src/enum.cfa (modified) (2 diffs)
• src/ControlStruct/TranslateEnumRange.cpp (modified) (6 diffs)
• src/Parser/StatementNode.cpp (modified) (1 diff)
• src/Parser/parser.yy (modified) (4 diffs)

libcfa/src/enum.cfa

@@ -1 +1 @@
 #include "enum.hfa"
 #include "fstream.hfa"
-#include <string.h>
 
 #pragma GCC visibility push(default)
@@ -11 +10 @@
         int args = fmt( is, "%255s", val );
         if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
-        for ( s; E ) {
-                if ( strcmp(val, label( s )) == 0 ) { e = s; break; }
-        } else {
-                fprintf( stderr, "invalid enumeration constant\n" );
-                abort();                                                                        // cannot use abort stream
-        } // for
+        // for ( s; E ) {
+        //      if ( val == label( s ) ) { e = s; break; }
+        // } else {
+        //      fprintf( stderr, "invalid enumeration constant\n" );
+        //      abort();                                                                        // cannot use abort stream
+        // } // for
         return is;
 }

src/ControlStruct/TranslateEnumRange.cpp

@@ -22 +22 @@
         auto typeExpr = stmt->range_over.strict_as<ast::TypeExpr>();
         auto type = typeExpr->type;
+        auto inits = stmt->inits;
+        auto enumInst = type.strict_as<ast::EnumInstType>();
+        auto enumDecl = enumInst->base;
 
         auto objInit = stmt->inits.front();
+        auto initLocation = objInit->location;
+        auto rangeLocation = stmt->range_over->location;
         assert( stmt->inits.size() == 1 );
 
@@ -42 +47 @@
 const ast::Stmt* addInit::postvisit( const ast::ForStmt * stmt ) {
     if ( stmt->range_over ) {
+        auto typeExpr = stmt->range_over.strict_as<ast::TypeExpr>();
+        auto type = typeExpr->type;
         auto inits = stmt->inits;
+        auto enumInst = type.strict_as<ast::EnumInstType>();
+        auto enumDecl = enumInst->base;
+
         auto init = stmt->inits.front();
 
@@ -50 +60 @@
                 if ( !objDecl->init ) {
                     auto location = stmt->location;
+                    // auto newInit = new ast::SingleInit( location, new ast::NameExpr( location, enumDecl->members.front()->name ) );
                     ast::SingleInit * newInit = new ast::SingleInit( location, 
-                        stmt->is_inc?
-                        ast::UntypedExpr::createCall( location, "lowerBound", {} ):
-                        ast::UntypedExpr::createCall( location, "upperBound", {} ),
-                        ast::ConstructFlag::MaybeConstruct
-                    );
+                        new ast::NameExpr( location, 
+                           stmt->is_inc? enumDecl->members.front()->name: enumDecl->members.back()->name ) );
                     auto objDeclWithInit = ast::mutate_field( objDecl, &ast::ObjectDecl::init, newInit );
                     auto declWithInit = ast::mutate_field( declStmt, &ast::DeclStmt::decl, objDeclWithInit );
@@ -72 +80 @@
     auto initDecl = declStmt->decl.strict_as<ast::ObjectDecl>();
     auto indexName = initDecl->name;
+    
+    auto typeExpr = stmt->range_over.strict_as<ast::TypeExpr>();
+    auto enumInst = typeExpr->type.strict_as<ast::EnumInstType>();
+    auto enumDecl = enumInst->base;
 
     // Both inc and dec check if the current posn less than the number of enumerator
@@ -78 +90 @@
     ast::UntypedExpr * condition = ast::UntypedExpr::createCall( location,
         "?<=?",
-        {   new ast::NameExpr( location, indexName ),
-            ast::UntypedExpr::createCall( location, "upperBound", {} )  });
+        {new ast::CastExpr(location,
+            new ast::NameExpr( location, indexName ),
+            new ast::BasicType( ast::BasicKind::UnsignedInt 
+        ),ast::GeneratedFlag::ExplicitCast),
+        ast::ConstantExpr::from_ulong( location, enumDecl->members.size()-1 ) });
     auto increment = ast::UntypedExpr::createCall( location, 
-        stmt->is_inc? "succ": "pred",
-        { new ast::NameExpr( location, indexName ) });
+        stmt->is_inc? "succ": "pred",{
+        new ast::NameExpr( location, indexName )
+    });
     auto assig = ast::UntypedExpr::createAssign( location, new ast::NameExpr( location, indexName ), increment );
     auto mut = ast::mutate_field( stmt, &ast::ForStmt::cond, condition );
@@ -90 +106 @@
 
 void translateEnumRange( ast::TranslationUnit & translationUnit ) {
+    ast::Pass<addInitType>::run( translationUnit );
     ast::Pass<addInit>::run( translationUnit );
     ast::Pass<translateEnumRangeCore>::run( translationUnit );

src/Parser/StatementNode.cpp

@@ -216 +216 @@
                 return new ast::ForStmt( location,
                         std::move( astinit ),
-                        range_over, forctl->kind == OperKinds::LEThan,
+                        range_over, forctl->kind == OperKinds::LThan,
                         buildMoveSingle( stmt ),
                         buildMoveOptional( else_ )

src/Parser/parser.yy

@@ -275 +275 @@
 } // forCtrl
 
-ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, OperKinds compop, ExpressionNode * range_over_expr, DeclarationNode * type ) {
-        assert( compop == OperKinds::LEThan || compop == OperKinds::GEThan );
+ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, __attribute__((unused)) OperKinds compop, ExpressionNode * range_over_expr ) {
         if ( auto identifier = dynamic_cast<ast::NameExpr *>(index_expr->expr.get()) ) {
-                DeclarationNode * indexDecl =
-                        DeclarationNode::newName( new std::string(identifier->name) )->addType( type );
+                DeclarationNode * indexDecl = DeclarationNode::newName( new std::string(identifier->name) );
+                assert( range_over_expr );
                 return new ForCtrl( new StatementNode( indexDecl ), range_over_expr, compop );
         } else {
@@ -1606 +1605 @@
                 { SemanticError( yylloc, "illegal syntax, missing low/high value for ascending/descending range so index is uninitialized." ); $$ = nullptr; }
 
-        | comma_expression ';' type_type_specifier                                              // CFA, enum type
-                {
-                        $$ = enumRangeCtrl( $1, OperKinds::LEThan, new ExpressionNode( new ast::TypeExpr( yylloc, $3->clone()->buildType() ) ), $3 );
+        | comma_expression ';' enum_key                                         // CFA, enum type
+                {
+                        $$ = enumRangeCtrl( $1, OperKinds::LEThan, new ExpressionNode( new ast::TypeExpr( yylloc, $3->buildType() ) ) );
                 }
         | comma_expression ';' downupdowneq enum_key            // CFA, enum type, reverse direction
@@ -1616 +1615 @@
                                 $3 = OperKinds::GEThan;
                         } // if
-                        $$ = enumRangeCtrl( $1, $3, new ExpressionNode( new ast::TypeExpr( yylloc, $4->clone()->buildType() ) ), $4 );
+                        $$ = enumRangeCtrl( $1, $3, new ExpressionNode( new ast::TypeExpr( yylloc, $4->buildType() ) ) );
                 }
         ;
@@ -1622 +1621 @@
 enum_key:
         type_name
-                {       typedefTable.makeTypedef( *$1->symbolic.name, "enum_type_nobody 1" );
-                        $$ = DeclarationNode::newEnum( $1->symbolic.name, nullptr, false, false ); }
+                { $$ = DeclarationNode::newEnum( $1->symbolic.name, nullptr, false, false ); }
         | ENUM identifier
-                {       typedefTable.makeTypedef( *$2, "enum_type_nobody 2" );
-                        $$ = DeclarationNode::newEnum( $2, nullptr, false, false ); }
+                { $$ = DeclarationNode::newEnum( $2, nullptr, false, false ); }
         | ENUM type_name
-                {       typedefTable.makeTypedef( *$2->symbolic.name, "enum_type_nobody 3" );
-                        $$ = DeclarationNode::newEnum( $2->symbolic.name, nullptr, false, false ); }
+                { $$ = DeclarationNode::newEnum( $2->symbolic.name, nullptr, false, false ); }
         ;