Changeset 29702ad for src/Common

Timestamp:

Nov 22, 2022, 10:18:04 AM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master, stuck-waitfor-destruct

Children:

20cf96d

Parents:

1553a55 (diff), d41735a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/Common

Files:

• CodeLocationTools.cpp (modified) (1 diff)
• PassVisitor.h (modified) (2 diffs)
• PassVisitor.impl.h (modified) (3 diffs)
• utility.h (modified) (2 diffs)

src/Common/CodeLocationTools.cpp

@@ -111 +111 @@
     macro(DirectiveDecl, DirectiveDecl) \
     macro(StaticAssertDecl, StaticAssertDecl) \
-    macro(InlineValueDecl, DeclWithType) \
+    macro(InlineMemberDecl, DeclWithType) \
     macro(CompoundStmt, CompoundStmt) \
     macro(ExprStmt, Stmt) \

src/Common/PassVisitor.h

@@ -81 +81 @@
         virtual void visit( StaticAssertDecl * assertDecl ) override final;
         virtual void visit( const StaticAssertDecl * assertDecl ) override final;
-        virtual void visit( InlineValueDecl * valueDecl ) override final;
-        virtual void visit( const InlineValueDecl * valueDecl ) override final;
+        virtual void visit( InlineMemberDecl * valueDecl ) override final;
+        virtual void visit( const InlineMemberDecl * valueDecl ) override final;
 
         virtual void visit( CompoundStmt * compoundStmt ) override final;
@@ -275 +275 @@
         virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) override final;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
-        virtual DeclarationWithType * mutate( InlineValueDecl * valueDecl ) override final;
+        virtual DeclarationWithType * mutate( InlineMemberDecl * valueDecl ) override final;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -1047 +1047 @@
 
 //--------------------------------------------------------------------------
-// InlineValueDecl
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( InlineValueDecl * node ) {
+// InlineMemberDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( InlineMemberDecl * node ) {
         VISIT_START( node );
 
@@ -1058 +1058 @@
 
 template< typename pass_type >
-void PassVisitor< pass_type >::visit( const InlineValueDecl * node ) {
+void PassVisitor< pass_type >::visit( const InlineMemberDecl * node ) {
         VISIT_START( node );
 
@@ -1067 +1067 @@
 
 template< typename pass_type >
-DeclarationWithType * PassVisitor< pass_type >::mutate( InlineValueDecl * node ) {
+DeclarationWithType * PassVisitor< pass_type >::mutate( InlineMemberDecl * node ) {
         MUTATE_START( node );
 

src/Common/utility.h

@@ -461 +461 @@
         Iterables iterables;
 
+        // Getting the iterator and value types this way preserves const.
         template<size_t I> using Iter = decltype(std::get<I>(iterables).begin());
         template<size_t I> using Data = decltype(*std::get<I>(iterables).begin());
         template<typename> struct base_iterator;
 
-        template<std::size_t... Is>
-        struct base_iterator<std::integer_sequence<std::size_t, Is...>> {
-                using value_type = std::tuple< Data<Is>... >;
-                std::tuple<Iter<Is>...> iterators;
-
-                base_iterator( Iter<Is>... is ) : iterators( is... ) {}
+        // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1`
+        // into a pack. These are the indexes into the tuples, so unpacking can
+        // go over each element of the tuple.
+        // The std::integer_sequence is just used to build that sequence.
+        // A library reference will probably explain it better than I can.
+        template<std::size_t... Indices>
+        struct base_iterator<std::integer_sequence<std::size_t, Indices...>> {
+                using value_type = std::tuple< Data<Indices>... >;
+                std::tuple<Iter<Indices>...> iterators;
+
+                base_iterator( Iter<Indices>... is ) : iterators( is... ) {}
                 base_iterator operator++() {
-                        return base_iterator( ++std::get<Is>( iterators )... );
+                        return base_iterator( ++std::get<Indices>( iterators )... );
                 }
                 bool operator!=( const base_iterator& other ) const {
@@ -478 +484 @@
                 }
                 value_type operator*() const {
-                        return std::tie( *std::get<Is>( iterators )... );
+                        return std::tie( *std::get<Indices>( iterators )... );
                 }
 
                 static base_iterator make_begin( Iterables & data ) {
-                        return base_iterator( std::get<Is>( data ).begin()... );
+                        return base_iterator( std::get<Indices>( data ).begin()... );
                 }
                 static base_iterator make_end( Iterables & data ) {
-                        return base_iterator( std::get<Is>( data ).end()... );
+                        return base_iterator( std::get<Indices>( data ).end()... );
                 }
         };