Changeset 525f7ad for src

Timestamp:

Jun 19, 2024, 3:20:39 PM (6 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

57e43cd

Parents:

1725989

Message:

1. Add count_e( enum_name ), a pseudo function that return the number of element in an enum; 2. Implementation of enum range loop.

Location:

src

Files:

• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (1 diff)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (2 diffs)
• AST/Print.cpp (modified) (1 diff)
• AST/Stmt.hpp (modified) (2 diffs)
• AST/Visitor.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• ControlStruct/module.mk (modified) (1 diff)
• Parser/StatementNode.cpp (modified) (1 diff)
• Parser/StatementNode.hpp (modified) (1 diff)
• Parser/lex.ll (modified) (1 diff)
• Parser/parser.yy (modified) (5 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• main.cpp (modified) (2 diffs)

src/AST/Expr.cpp

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

src/AST/Expr.hpp

@@ -494 +494 @@
 };
 
+class CountExpr final : public Expr {
+public:
+        ptr<Type> type;
+
+        CountExpr( const CodeLocation & loc, const Type * t );
+
+        const Expr * accept( Visitor & v )const override { return v.visit( this ); }
+private:
+        CountExpr * clone() const override { return new CountExpr( *this ); }
+        MUTATE_FRIEND
+};
+
 /// alignof expression, e.g. `alignof(int)`, `alignof 3+4`
 class AlignofExpr final : public Expr {

src/AST/Fwd.hpp

@@ -85 +85 @@
 class ConstantExpr;
 class SizeofExpr;
+class CountExpr;
 class AlignofExpr;
 class UntypedOffsetofExpr;

src/AST/Pass.hpp

@@ -172 +172 @@
         const ast::Expr *             visit( const ast::ConstantExpr         * ) override final;
         const ast::Expr *             visit( const ast::SizeofExpr           * ) override final;
+        const ast::Expr *             visit( const ast::CountExpr            * ) override final;
         const ast::Expr *             visit( const ast::AlignofExpr          * ) override final;
         const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) override final;

src/AST/Pass.impl.hpp

@@ -802 +802 @@
                 maybe_accept_top( node, &ForStmt::cond  );
                 maybe_accept_top( node, &ForStmt::inc   );
+                maybe_accept_top( node, &ForStmt::range_over );
                 maybe_accept_as_compound( node, &ForStmt::body  );
         }
@@ -1323 +1324 @@
         }
 
+        VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
+// CountExpr
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CountExpr * node ) {
+        VISIT_START( node );
+        if ( __visit_children() ) {
+                {
+                        guard_symtab guard { *this };
+                        maybe_accept( node, &CountExpr::result );
+                }
+                maybe_accept( node, &CountExpr::type );
+        }
         VISIT_END( Expr, node );
 }

src/AST/Print.cpp

@@ -1143 +1143 @@
         }
 
+        virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
+                os << "Count Expression on: ";
+                ++indent;
+                node->type->accept( *this );
+                --indent;
+                postprint( node );
+                return node;
+        }
+
         virtual const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
                 os << "Alignof Expression on: ";

src/AST/Stmt.hpp

@@ -237 +237 @@
         ptr<Expr> cond;
         ptr<Expr> inc;
+        ptr<Expr> range_over;
         ptr<Stmt> body;
         ptr<Stmt> else_;
@@ -242 +243 @@
         ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
                          const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
-                : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(nullptr) {}
+                : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc),
+                        range_over(nullptr), body(body), else_(nullptr) {}
 
         ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
                          const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(else_) {}
+                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
+                        range_over(nullptr), body(body), else_(else_) {}
+
+        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * range_over, 
+                         const Stmt * body, const Stmt * else_ )
+                : Stmt(loc, std::move(labels)), inits(std::move(inits)), range_over(range_over), body(body), else_(else_) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Visitor.hpp

@@ -75 +75 @@
     virtual const ast::Expr *             visit( const ast::ConstantExpr         * ) = 0;
     virtual const ast::Expr *             visit( const ast::SizeofExpr           * ) = 0;
+    virtual const ast::Expr *             visit( const ast::CountExpr            * ) = 0;
     virtual const ast::Expr *             visit( const ast::AlignofExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) = 0;

src/Common/CodeLocationTools.cpp

@@ -153 +153 @@
     macro(ConstantExpr, Expr) \
     macro(SizeofExpr, Expr) \
+    macro(CountExpr, Expr ) \
     macro(AlignofExpr, Expr) \
     macro(UntypedOffsetofExpr, Expr) \

src/ControlStruct/module.mk

@@ -27 +27 @@
         ControlStruct/LabelGenerator.hpp \
         ControlStruct/MultiLevelExit.cpp \
-        ControlStruct/MultiLevelExit.hpp
+        ControlStruct/MultiLevelExit.hpp \
+        ControlStruct/TranslateEnumRange.cpp \
+        ControlStruct/TranslateEnumRange.hpp
 

src/Parser/StatementNode.cpp

@@ -211 +211 @@
         buildMoveList( forctl->init, astinit );
 
+        if ( forctl->range_over ) {
+                ast::Expr * range_over = maybeMoveBuild( forctl->range_over );
+                delete forctl;
+                return new ast::ForStmt( location,
+                        std::move( astinit ),
+                        range_over,
+                        buildMoveSingle( stmt ),
+                        buildMoveOptional( else_ )
+                );
+        }
+
         ast::Expr * astcond = nullptr;                                          // maybe empty
         astcond = maybeMoveBuild( forctl->condition );

src/Parser/StatementNode.hpp

@@ -63 +63 @@
 struct ForCtrl {
         ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) :
-                init( stmt ), condition( condition ), change( change ) {}
+                init( stmt ), condition( condition ), change( change ), range_over( nullptr ) {}
+        ForCtrl( StatementNode * decl, ExpressionNode * _range_over) :
+                init( decl ), condition( nullptr ), change( nullptr ),  range_over( _range_over ) {}
 
         StatementNode * init;
         ExpressionNode * condition;
         ExpressionNode * change;
+        ExpressionNode * range_over;
 };
 

src/Parser/lex.ll

@@ -321 +321 @@
 __signed__              { KEYWORD_RETURN(SIGNED); }                             // GCC
 sizeof                  { KEYWORD_RETURN(SIZEOF); }
+__count_e__             { KEYWORD_RETURN(COUNT); }                              // GCC
 static                  { KEYWORD_RETURN(STATIC); }
 _Static_assert  { KEYWORD_RETURN(STATICASSERT); }               // C11

src/Parser/parser.yy

@@ -284 +284 @@
 } // forCtrl
 
+ForCtrl * enumRangeCtrl( ExpressionNode * index_expr, ExpressionNode * range_over_expr ) {
+        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index_expr->expr.get()) ) {
+                DeclarationNode * indexDecl =
+                        DeclarationNode::newName( new std::string(identifier->name) );
+                assert( range_over_expr );
+                auto node = new StatementNode( indexDecl ); // <- this cause this error
+                return new ForCtrl( node, range_over_expr );
+        } else if (auto commaExpr = dynamic_cast<ast::CommaExpr *>( index_expr->expr.get() )) {
+                if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
+                        assert( range_over_expr );
+                        DeclarationNode * indexDecl = distAttr(
+                                DeclarationNode::newTypeof( range_over_expr, true ),
+                                DeclarationNode::newName( new std::string( identifier->name) ) );
+                        return new ForCtrl( new StatementNode( indexDecl ), range_over_expr );
+                } else {
+                        SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed." ); return nullptr;
+                } // if
+        } else {
+                SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed." ); return nullptr;
+        } // if
+} // enumRangeCtrl
+
 static void IdentifierBeforeIdentifier( string & identifier1, string & identifier2, const char * kind ) {
         SemanticError( yylloc, "syntax error, adjacent identifiers \"%s\" and \"%s\" are not meaningful in an %s.\n"
@@ -368 +390 @@
 %token DECIMAL32 DECIMAL64 DECIMAL128                                   // GCC
 %token ZERO_T ONE_T                                                                             // CFA
-%token SIZEOF TYPEOF VA_LIST VA_ARG AUTO_TYPE                   // GCC
+%token SIZEOF TYPEOF VA_LIST VA_ARG AUTO_TYPE COUNT             // GCC
 %token OFFSETOF BASETYPEOF TYPEID                                               // CFA
 %token ENUM STRUCT UNION
@@ -968 +990 @@
                         // $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) );
                 }
+        | COUNT '(' type ')'
+                {
+                        // SemanticError( yylloc, "Count is currently unimplemented. "); $$ = nullptr;
+                        $$ = new ExpressionNode( new ast::CountExpr( yylloc, maybeMoveBuildType( $3 ) ) );
+                }
         ;
 
@@ -1599 +1626 @@
                 { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
-        | comma_expression ';' enum_key                                         // CFA, enum type
-                {
-                        SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
-                        //$$ = forCtrl( new ExpressionNode( build_varref( $3 ) ), $1, nullptr, OperKinds::Range, nullptr, nullptr );
-                }
-        | comma_expression ';' downupdowneq enum_key            // CFA, enum type, reverse direction
+        | comma_expression ';' enum_type                                        // CFA, enum type
+                {
+                        $$ = enumRangeCtrl( $1, new ExpressionNode( new ast::TypeExpr(yylloc, $3->buildType() ) ) );
+                }
+        | comma_expression ';' downupdowneq enum_type           // CFA, enum type, reverse direction
                 {
                         if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) {
@@ -1611 +1637 @@
                         SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
                 }
-        ;
-
-enum_key:
-        TYPEDEFname
-        | ENUM identifier_or_type_name
         ;
 

src/ResolvExpr/CandidateFinder.cpp

@@ -696 +696 @@
                 void postvisit( const ast::UntypedInitExpr * initExpr );
                 void postvisit( const ast::QualifiedNameExpr * qualifiedExpr );
+                void postvisit( const ast::CountExpr * countExpr );
 
                 const ast::Expr * makeEnumOffsetCast( const ast::EnumInstType * src, 
@@ -1527 +1528 @@
                         addCandidate( *choice, new ast::SizeofExpr{ sizeofExpr->location, choice->expr } );
                 }
+        }
+
+        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 );
         }
 

src/main.cpp

@@ -53 +53 @@
 #include "ControlStruct/FixLabels.hpp"      // for fixLabels
 #include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
+#include "ControlStruct/TrasnlateEnumRange.hpp" // translateEnumRange
 #include "GenPoly/Box.hpp"                  // for box
 #include "GenPoly/InstantiateGeneric.hpp"   // for instantiateGeneric
@@ -323 +324 @@
                 PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
                 PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
+                PASS( "Translate Enum Range Expression", ControlStruct::translateEnumRange, transUnit );
                 PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );
                 // Need to happen before fixing returns because implementEnumFunc has ReturnStmt