Changeset c5f3c68

Timestamp:

Dec 1, 2017, 10:08:37 AM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

027c496

Parents:

0a6aad4

git-author:

Rob Schluntz <rschlunt@…> (11/30/17 17:42:47)

git-committer:

Rob Schluntz <rschlunt@…> (12/01/17 10:08:37)

Message:

Convert ConstExprChecker? to PassVisitor?

File:

• src/InitTweak/InitTweak.cc (modified) (2 diffs)

src/InitTweak/InitTweak.cc

@@ -539 +539 @@
         }
 
-        class ConstExprChecker : public Visitor {
-        public:
-                ConstExprChecker() : isConstExpr( true ) {}
-
-                using Visitor::visit;
-
-                virtual void visit( ApplicationExpr * ) { isConstExpr = false; }
-                virtual void visit( UntypedExpr * ) { isConstExpr = false; }
-                virtual void visit( NameExpr * ) { isConstExpr = false; }
-                // virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
-                virtual void visit( AddressExpr *addressExpr ) {
+        struct ConstExprChecker : public WithShortCircuiting {
+                // most expressions are not const expr
+                void previsit( Expression * ) { isConstExpr = false; visit_children = false; }
+
+                void previsit( AddressExpr *addressExpr ) {
+                        visit_children = false;
+
                         // address of a variable or member expression is constexpr
                         Expression * arg = addressExpr->get_arg();
                         if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
                 }
-                virtual void visit( UntypedMemberExpr * ) { isConstExpr = false; }
-                virtual void visit( MemberExpr * ) { isConstExpr = false; }
-                virtual void visit( VariableExpr * ) { isConstExpr = false; }
-                // these might be okay?
-                // virtual void visit( SizeofExpr *sizeofExpr );
-                // virtual void visit( AlignofExpr *alignofExpr );
-                // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
-                // virtual void visit( OffsetofExpr *offsetofExpr );
-                // virtual void visit( OffsetPackExpr *offsetPackExpr );
-                // virtual void visit( AttrExpr *attrExpr );
-                // virtual void visit( CommaExpr *commaExpr );
-                // virtual void visit( LogicalExpr *logicalExpr );
-                // virtual void visit( ConditionalExpr *conditionalExpr );
-                virtual void visit( TypeExpr * ) { isConstExpr = false; }
-                virtual void visit( AsmExpr * ) { isConstExpr = false; }
-                virtual void visit( UntypedValofExpr * ) { isConstExpr = false; }
-                virtual void visit( CompoundLiteralExpr * ) { isConstExpr = false; }
-                virtual void visit( UntypedTupleExpr * ) { isConstExpr = false; }
-                virtual void visit( TupleExpr * ) { isConstExpr = false; }
-                virtual void visit( TupleAssignExpr * ) { isConstExpr = false; }
-
-                bool isConstExpr;
+
+                // these expressions may be const expr, depending on their children
+                void previsit( SizeofExpr * ) {}
+                void previsit( AlignofExpr * ) {}
+                void previsit( UntypedOffsetofExpr * ) {}
+                void previsit( OffsetofExpr * ) {}
+                void previsit( OffsetPackExpr * ) {}
+                void previsit( AttrExpr * ) {}
+                void previsit( CommaExpr * ) {}
+                void previsit( LogicalExpr * ) {}
+                void previsit( ConditionalExpr * ) {}
+                void previsit( CastExpr * ) {}
+                void previsit( ConstantExpr * ) {}
+
+                bool isConstExpr = true;
         };
 
         bool isConstExpr( Expression * expr ) {
                 if ( expr ) {
-                        ConstExprChecker checker;
+                        PassVisitor<ConstExprChecker> checker;
                         expr->accept( checker );
-                        return checker.isConstExpr;
+                        return checker.pass.isConstExpr;
                 }
                 return true;
@@ -589 +578 @@
         bool isConstExpr( Initializer * init ) {
                 if ( init ) {
-                        ConstExprChecker checker;
+                        PassVisitor<ConstExprChecker> checker;
                         init->accept( checker );
-                        return checker.isConstExpr;
+                        return checker.pass.isConstExpr;
                 } // if
                 // for all intents and purposes, no initializer means const expr