Changeset 24d6572 for src/Common

Timestamp:

Jun 12, 2023, 2:45:32 PM (3 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ast-experimental, master, stuck-waitfor-destruct

Children:

62d62db

Parents:

34b4268 (diff), 251ce80 (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' into ast-experimental

Location:

src/Common

Files:

• CodeLocationTools.cpp (modified) (3 diffs)
• CompilerError.h (deleted)
• Debug.h (deleted)
• DeclStats.cpp (modified) (1 diff)
• Eval.cc (modified) (2 diffs)
• Eval.h (added)
• Iterate.hpp (added)
• ResolvProtoDump.cpp (modified) (2 diffs)
• ScopedMap.h (modified) (6 diffs)
• SemanticError.h (modified) (3 diffs)
• ToString.hpp (added)
• UnimplementedError.h (deleted)
• module.mk (modified) (3 diffs)
• utility.h (modified) (7 diffs)

src/Common/CodeLocationTools.cpp

@@ -128 +128 @@
     macro(FinallyClause, FinallyClause) \
     macro(SuspendStmt, Stmt) \
+    macro(WhenClause, WhenClause) \
     macro(WaitForStmt, Stmt) \
     macro(WaitForClause, WaitForClause) \
+    macro(WaitUntilStmt, Stmt) \
     macro(WithStmt, Decl) \
     macro(NullStmt, NullStmt) \
@@ -208 +210 @@
 
 struct LeafKindVisitor : public ast::Visitor {
-        LeafKind kind;
+        LeafKind result;
 
 #define VISIT(node_type, return_type) \
         const ast::return_type * visit( const ast::node_type * ) final { \
-                kind = LeafKind::node_type; \
+                result = LeafKind::node_type; \
                 return nullptr; \
         }
@@ -222 +224 @@
 
 LeafKind get_leaf_kind( ast::Node const * node ) {
-        LeafKindVisitor visitor;
-        node->accept( visitor );
-        return visitor.kind;
+        return ast::Pass<LeafKindVisitor>::read( node );
 }
 

src/Common/DeclStats.cpp

@@ -23 +23 @@
 #include <iostream>
 #include <map>
+#include <sstream>
 #include <unordered_map>
 #include <unordered_set>

src/Common/Eval.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// utility.h --
+// Eval.cc -- Evaluate parts of the ast at compile time.
 //
 // Author           : Richard C. Bilson
@@ -13 +13 @@
 // Update Count     : 119
 //
+
+#include "Eval.h"
 
 #include <utility> // for pair

src/Common/ResolvProtoDump.cpp

@@ -19 +19 @@
 #include <iostream>
 #include <set>
+#include <sstream>
 #include <unordered_set>
 
@@ -26 +27 @@
 #include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
-#include "Common/utility.h"
 
 namespace {

src/Common/ScopedMap.h

@@ -37 +37 @@
                 template<typename N>
                 Scope(N && n) : map(), note(std::forward<N>(n)) {}
-                
+
                 Scope() = default;
                 Scope(const Scope &) = default;
@@ -46 +46 @@
         typedef std::vector< Scope > ScopeList;
 
-        ScopeList scopes; ///< scoped list of maps
+        /// Scoped list of maps.
+        ScopeList scopes;
 public:
         typedef typename MapType::key_type key_type;
@@ -58 +59 @@
         typedef typename MapType::const_pointer const_pointer;
 
-        class iterator : public std::iterator< std::bidirectional_iterator_tag, value_type > {
-        friend class ScopedMap;
-        friend class const_iterator;
-                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
-                typedef typename ScopedMap::ScopeList scope_list;
-                typedef typename scope_list::size_type size_type;
-
-                /// Checks if this iterator points to a valid item
-                bool is_valid() const {
-                        return it != (*scopes)[level].map.end();
-                }
-
-                /// Increments on invalid
-                iterator & next_valid() {
-                        if ( ! is_valid() ) { ++(*this); }
-                        return *this;
-                }
-
-                /// Decrements on invalid
-                iterator & prev_valid() {
-                        if ( ! is_valid() ) { --(*this); }
-                        return *this;
-                }
-
-                iterator(scope_list & _scopes, const wrapped_iterator & _it, size_type inLevel)
-                        : scopes(&_scopes), it(_it), level(inLevel) {}
-        public:
-                iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
-                iterator & operator= (const iterator & that) {
-                        scopes = that.scopes; level = that.level; it = that.it;
-                        return *this;
-                }
-
-                reference operator* () { return *it; }
-                pointer operator-> () const { return it.operator->(); }
-
-                iterator & operator++ () {
-                        if ( it == (*scopes)[level].map.end() ) {
-                                if ( level == 0 ) return *this;
-                                --level;
-                                it = (*scopes)[level].map.begin();
-                        } else {
-                                ++it;
-                        }
-                        return next_valid();
-                }
-                iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
-
-                iterator & operator-- () {
-                        // may fail if this is the begin iterator; allowed by STL spec
-                        if ( it == (*scopes)[level].map.begin() ) {
-                                ++level;
-                                it = (*scopes)[level].map.end();
-                        }
-                        --it;
-                        return prev_valid();
-                }
-                iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
-
-                bool operator== (const iterator & that) const {
-                        return scopes == that.scopes && level == that.level && it == that.it;
-                }
-                bool operator!= (const iterator & that) const { return !( *this == that ); }
-
-                size_type get_level() const { return level; }
-
-                Note & get_note() { return (*scopes)[level].note; }
-                const Note & get_note() const { return (*scopes)[level].note; }
-
-        private:
-                scope_list *scopes;
-                wrapped_iterator it;
-                size_type level;
-        };
-
-        class const_iterator : public std::iterator< std::bidirectional_iterator_tag,
-                                                     value_type > {
-        friend class ScopedMap;
-                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
-                typedef typename ScopedMap::MapType::const_iterator wrapped_const_iterator;
-                typedef typename ScopedMap::ScopeList scope_list;
-                typedef typename scope_list::size_type size_type;
-
-                /// Checks if this iterator points to a valid item
-                bool is_valid() const {
-                        return it != (*scopes)[level].map.end();
-                }
-
-                /// Increments on invalid
-                const_iterator & next_valid() {
-                        if ( ! is_valid() ) { ++(*this); }
-                        return *this;
-                }
-
-                /// Decrements on invalid
-                const_iterator & prev_valid() {
-                        if ( ! is_valid() ) { --(*this); }
-                        return *this;
-                }
-
-                const_iterator(scope_list const & _scopes, const wrapped_const_iterator & _it, size_type inLevel)
-                        : scopes(&_scopes), it(_it), level(inLevel) {}
-        public:
-                const_iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
-                const_iterator(const const_iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
-                const_iterator & operator= (const iterator & that) {
-                        scopes = that.scopes; level = that.level; it = that.it;
-                        return *this;
-                }
-                const_iterator & operator= (const const_iterator & that) {
-                        scopes = that.scopes; level = that.level; it = that.it;
-                        return *this;
-                }
-
-                const_reference operator* () { return *it; }
-                const_pointer operator-> () { return it.operator->(); }
-
-                const_iterator & operator++ () {
-                        if ( it == (*scopes)[level].map.end() ) {
-                                if ( level == 0 ) return *this;
-                                --level;
-                                it = (*scopes)[level].map.begin();
-                        } else {
-                                ++it;
-                        }
-                        return next_valid();
-                }
-                const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
-
-                const_iterator & operator-- () {
-                        // may fail if this is the begin iterator; allowed by STL spec
-                        if ( it == (*scopes)[level].map.begin() ) {
-                                ++level;
-                                it = (*scopes)[level].map.end();
-                        }
-                        --it;
-                        return prev_valid();
-                }
-                const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
-
-                bool operator== (const const_iterator & that) const {
-                        return scopes == that.scopes && level == that.level && it == that.it;
-                }
-                bool operator!= (const const_iterator & that) const { return !( *this == that ); }
-
-                size_type get_level() const { return level; }
-
-                const Note & get_note() const { return (*scopes)[level].note; }
-
-        private:
-                scope_list const *scopes;
-                wrapped_const_iterator it;
-                size_type level;
-        };
+        // Both iterator types are complete bidrectional iterators, see below.
+        class iterator;
+        class const_iterator;
 
         /// Starts a new scope
@@ -297 +147 @@
         }
 
-        template< typename value_type_t >
-        std::pair< iterator, bool > insert( iterator at, value_type_t && value ) {
-                MapType & scope = (*at.scopes)[ at.level ].map;
-                std::pair< typename MapType::iterator, bool > res = scope.insert( std::forward<value_type_t>( value ) );
-                return std::make_pair( iterator(scopes, std::move( res.first ), at.level), std::move( res.second ) );
-        }
-
         template< typename value_t >
         std::pair< iterator, bool > insert( const Key & key, value_t && value ) { return insert( std::make_pair( key, std::forward<value_t>( value ) ) ); }
@@ -324 +167 @@
         }
 
-        iterator erase( iterator pos ) {
-                MapType & scope = (*pos.scopes)[ pos.level ].map;
-                const typename iterator::wrapped_iterator & new_it = scope.erase( pos.it );
-                iterator it( *pos.scopes, new_it, pos.level );
-                return it.next_valid();
+        /// Erases element with key in the innermost scope that has it.
+        size_type erase( const Key & key ) {
+                for ( auto it = scopes.rbegin() ; it != scopes.rend() ; ++it ) {
+                        size_type i = it->map.erase( key );
+                        if ( 0 != i ) return i;
+                }
+                return 0;
         }
 
@@ -343 +188 @@
                 return c;
         }
+
+        bool contains( const Key & key ) const {
+                return find( key ) != cend();
+        }
+};
+
+template<typename Key, typename Value, typename Note>
+class ScopedMap<Key, Value, Note>::iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedMap;
+        friend class const_iterator;
+        typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+        typedef typename ScopedMap::ScopeList scope_list;
+        typedef typename scope_list::size_type size_type;
+
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[level].map.end();
+        }
+
+        /// Increments on invalid
+        iterator & next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+
+        /// Decrements on invalid
+        iterator & prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+
+        iterator(scope_list & _scopes, const wrapped_iterator & _it, size_type inLevel)
+                : scopes(&_scopes), it(_it), level(inLevel) {}
+public:
+        iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        iterator & operator= (const iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+
+        reference operator* () { return *it; }
+        pointer operator-> () const { return it.operator->(); }
+
+        iterator & operator++ () {
+                if ( it == (*scopes)[level].map.end() ) {
+                        if ( level == 0 ) return *this;
+                        --level;
+                        it = (*scopes)[level].map.begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
+
+        iterator & operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[level].map.begin() ) {
+                        ++level;
+                        it = (*scopes)[level].map.end();
+                }
+                --it;
+                return prev_valid();
+        }
+        iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
+
+        bool operator== (const iterator & that) const {
+                return scopes == that.scopes && level == that.level && it == that.it;
+        }
+        bool operator!= (const iterator & that) const { return !( *this == that ); }
+
+        size_type get_level() const { return level; }
+
+        Note & get_note() { return (*scopes)[level].note; }
+        const Note & get_note() const { return (*scopes)[level].note; }
+
+private:
+        scope_list *scopes;
+        wrapped_iterator it;
+        size_type level;
+};
+
+template<typename Key, typename Value, typename Note>
+class ScopedMap<Key, Value, Note>::const_iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedMap;
+        typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+        typedef typename ScopedMap::MapType::const_iterator wrapped_const_iterator;
+        typedef typename ScopedMap::ScopeList scope_list;
+        typedef typename scope_list::size_type size_type;
+
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[level].map.end();
+        }
+
+        /// Increments on invalid
+        const_iterator & next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+
+        /// Decrements on invalid
+        const_iterator & prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+
+        const_iterator(scope_list const & _scopes, const wrapped_const_iterator & _it, size_type inLevel)
+                : scopes(&_scopes), it(_it), level(inLevel) {}
+public:
+        const_iterator(const iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        const_iterator(const const_iterator & that) : scopes(that.scopes), it(that.it), level(that.level) {}
+        const_iterator & operator= (const iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+        const_iterator & operator= (const const_iterator & that) {
+                scopes = that.scopes; level = that.level; it = that.it;
+                return *this;
+        }
+
+        const_reference operator* () { return *it; }
+        const_pointer operator-> () { return it.operator->(); }
+
+        const_iterator & operator++ () {
+                if ( it == (*scopes)[level].map.end() ) {
+                        if ( level == 0 ) return *this;
+                        --level;
+                        it = (*scopes)[level].map.begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
+
+        const_iterator & operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[level].map.begin() ) {
+                        ++level;
+                        it = (*scopes)[level].map.end();
+                }
+                --it;
+                return prev_valid();
+        }
+        const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
+
+        bool operator== (const const_iterator & that) const {
+                return scopes == that.scopes && level == that.level && it == that.it;
+        }
+        bool operator!= (const const_iterator & that) const { return !( *this == that ); }
+
+        size_type get_level() const { return level; }
+
+        const Note & get_note() const { return (*scopes)[level].note; }
+
+private:
+        scope_list const *scopes;
+        wrapped_const_iterator it;
+        size_type level;
 };
 

src/Common/SemanticError.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May  4 14:08:26 2022
-// Update Count     : 35
+// Last Modified On : Sat Feb 25 12:01:31 2023
+// Update Count     : 37
 //
 
@@ -54 +54 @@
 
 constexpr WarningData WarningFormats[] = {
-        {"self-assign"            , Severity::Warn    , "self assignment of expression: %s"                          },
-        {"reference-conversion"   , Severity::Warn    , "rvalue to reference conversion of rvalue: %s"               },
-        {"qualifiers-zero_t-one_t", Severity::Warn    , "questionable use of type qualifier %s with %s"              },
-        {"aggregate-forward-decl" , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
-        {"superfluous-decl"       , Severity::Warn    , "declaration does not allocate storage: %s"                  },
-        {"superfluous-else"       , Severity::Warn    , "else clause never executed for empty loop conditional"      },
-        {"gcc-attributes"         , Severity::Warn    , "invalid attribute: %s"                                      },
-        {"c++-like-copy"          , Severity::Warn    , "Constructor from reference is not a valid copy constructor" },
+        {"self-assign"              , Severity::Warn    , "self assignment of expression: %s"                          },
+        {"reference-conversion"     , Severity::Warn    , "rvalue to reference conversion of rvalue: %s"               },
+        {"qualifiers-zero_t-one_t"  , Severity::Warn    , "questionable use of type qualifier(s) with %s"              },
+        {"aggregate-forward-decl"   , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
+        {"superfluous-decl"         , Severity::Warn    , "declaration does not allocate storage: %s"                  },
+        {"superfluous-else"         , Severity::Warn    , "else clause never executed for empty loop conditional"      },
+        {"gcc-attributes"           , Severity::Warn    , "invalid attribute: %s"                                      },
+        {"c++-like-copy"            , Severity::Warn    , "Constructor from reference is not a valid copy constructor" },
+        {"depreciated-trait-syntax" , Severity::Warn    , "trait type-parameters are now specified using the forall clause" },
 };
 
@@ -73 +74 @@
         GccAttributes,
         CppCopy,
+        DeprecTraitSyntax,
         NUMBER_OF_WARNINGS, // This MUST be the last warning
 };

src/Common/module.mk

@@ -20 +20 @@
         Common/CodeLocationTools.hpp \
         Common/CodeLocationTools.cpp \
-        Common/CompilerError.h \
-        Common/Debug.h \
         Common/DeclStats.hpp \
         Common/DeclStats.cpp \
         Common/ErrorObjects.h \
         Common/Eval.cc \
+        Common/Eval.h \
         Common/Examine.cc \
         Common/Examine.h \
@@ -31 +30 @@
         Common/Indenter.h \
         Common/Indenter.cc \
+        Common/Iterate.hpp \
         Common/PassVisitor.cc \
         Common/PassVisitor.h \
@@ -52 +52 @@
         Common/Stats/Time.cc \
         Common/Stats/Time.h \
-        Common/UnimplementedError.h \
+        Common/ToString.hpp \
         Common/UniqueName.cc \
         Common/UniqueName.h \

src/Common/utility.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// utility.h --
+// utility.h -- General utilities used across the compiler.
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Apr 25 14:26:00 2022
-// Update Count     : 51
+// Last Modified On : Fri Feb 17 15:25:00 2023
+// Update Count     : 53
 //
 
@@ -19 +19 @@
 #include <cctype>
 #include <algorithm>
-#include <functional>
 #include <iostream>
-#include <iterator>
 #include <list>
 #include <memory>
-#include <sstream>
 #include <string>
 #include <type_traits>
-#include <utility>
 #include <vector>
 #include <cstring>                                                                              // memcmp
@@ -49 +45 @@
                 return 0;
         } // if
-}
-
-template< typename T, typename U >
-struct maybeBuild_t {
-        static T * doit( const U *orig ) {
-                if ( orig ) {
-                        return orig->build();
-                } else {
-                        return 0;
-                } // if
-        }
-};
-
-template< typename T, typename U >
-static inline T * maybeBuild( const U *orig ) {
-        return maybeBuild_t<T,U>::doit(orig);
-}
-
-template< typename T, typename U >
-static inline T * maybeMoveBuild( const U *orig ) {
-        T* ret = maybeBuild<T>(orig);
-        delete orig;
-        return ret;
 }
 
@@ -168 +141 @@
         splice( src, dst );
         dst.swap( src );
-}
-
-template < typename T >
-void toString_single( std::ostream & os, const T & value ) {
-        os << value;
-}
-
-template < typename T, typename... Params >
-void toString_single( std::ostream & os, const T & value, const Params & ... params ) {
-        os << value;
-        toString_single( os, params ... );
-}
-
-template < typename ... Params >
-std::string toString( const Params & ... params ) {
-        std::ostringstream os;
-        toString_single( os, params... );
-        return os.str();
-}
-
-#define toCString( ... ) toString( __VA_ARGS__ ).c_str()
-
-// replace element of list with all elements of another list
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
-        typename std::list< T >::iterator next = pos; advance( next, 1 );
-
-        //if ( next != org.end() ) {
-        org.erase( pos );
-        org.splice( next, with );
-        //}
-
-        return;
-}
-
-// replace range of a list with a single element
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
-        org.insert( begin, with );
-        org.erase( begin, end );
 }
 
@@ -236 +169 @@
 }
 
-template< typename... Args >
-auto zip(Args&&... args) -> decltype(zipWith(std::forward<Args>(args)..., std::make_pair)) {
-  return zipWith(std::forward<Args>(args)..., std::make_pair);
-}
-
-template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction >
-void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) {
-        while ( b1 != e1 && b2 != e2 )
-                *out++ = func(*b1++, *b2++);
-}
-
-// it's nice to actually be able to increment iterators by an arbitrary amount
-template< class InputIt, class Distance >
-InputIt operator+( InputIt it, Distance n ) {
-        advance(it, n);
-        return it;
-}
-
-template< typename T >
-void warn_single( const T & arg ) {
-        std::cerr << arg << std::endl;
-}
-
-template< typename T, typename... Params >
-void warn_single(const T & arg, const Params & ... params ) {
-        std::cerr << arg;
-        warn_single( params... );
-}
-
-template< typename... Params >
-void warn( const Params & ... params ) {
-        std::cerr << "Warning: ";
-        warn_single( params... );
-}
-
 // determines if pref is a prefix of str
 static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {
         if ( pref.size() > str.size() ) return false;
-    return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() );
-        // return prefix == full.substr(0, prefix.size()); // for future, requires c++17
-}
-
-// -----------------------------------------------------------------------------
-// Ref Counted Singleton class
-// Objects that inherit from this class will have at most one reference to it
-// but if all references die, the object will be deleted.
-
-template< typename ThisType >
-class RefCountSingleton {
-  public:
-        static std::shared_ptr<ThisType> get() {
-                if( global_instance.expired() ) {
-                        std::shared_ptr<ThisType> new_instance = std::make_shared<ThisType>();
-                        global_instance = new_instance;
-                        return std::move(new_instance);
-                }
-                return global_instance.lock();
-        }
-  private:
-        static std::weak_ptr<ThisType> global_instance;
-};
-
-template< typename ThisType >
-std::weak_ptr<ThisType> RefCountSingleton<ThisType>::global_instance;
+        return pref == str.substr(start, pref.size());
+}
 
 // -----------------------------------------------------------------------------
@@ -356 +230 @@
         ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } }
 };
-
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : reverseIterate( container ) ) {}
-// syntax to have a for each that iterates backwards
-
-template< typename T >
-struct reverse_iterate_t {
-        T& ref;
-
-        reverse_iterate_t( T & ref ) : ref(ref) {}
-
-        // this does NOT work on const T!!!
-        // typedef typename T::reverse_iterator iterator;
-        auto begin() { return ref.rbegin(); }
-        auto end() { return ref.rend(); }
-};
-
-template< typename T >
-reverse_iterate_t< T > reverseIterate( T & ref ) {
-        return reverse_iterate_t< T >( ref );
-}
-
-template< typename T >
-struct enumerate_t {
-        template<typename val_t>
-        struct value_t {
-                val_t & val;
-                size_t idx;
-        };
-
-        template< typename iter_t, typename val_t >
-        struct iterator_t {
-                iter_t it;
-                size_t idx;
-
-                iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {}
-
-                value_t<val_t> operator*() const { return value_t<val_t>{ *it, idx }; }
-
-                bool operator==(const iterator_t & o) const { return o.it == it; }
-                bool operator!=(const iterator_t & o) const { return o.it != it; }
-
-                iterator_t & operator++() {
-                        it++;
-                        idx++;
-                        return *this;
-                }
-
-                using difference_type   = typename std::iterator_traits< iter_t >::difference_type;
-                using value_type        = value_t<val_t>;
-                using pointer           = value_t<val_t> *;
-                using reference         = value_t<val_t> &;
-                using iterator_category = std::forward_iterator_tag;
-        };
-
-        T & ref;
-
-        using iterator = iterator_t< typename T::iterator, typename T::value_type >;
-        using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >;
-
-        iterator begin() { return iterator( ref.begin(), 0 ); }
-        iterator end()   { return iterator( ref.end(), ref.size() ); }
-
-        const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator end()   const { return const_iterator( ref.cend(), ref.size() ); }
-
-        const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator cend()   const { return const_iterator( ref.cend(), ref.size() ); }
-};
-
-template< typename T >
-enumerate_t<T> enumerate( T & ref ) {
-        return enumerate_t< T >{ ref };
-}
-
-template< typename T >
-const enumerate_t< const T > enumerate( const T & ref ) {
-        return enumerate_t< const T >{ ref };
-}
-
-template< typename OutType, typename Range, typename Functor >
-OutType map_range( const Range& range, Functor&& functor ) {
-        OutType out;
-
-        std::transform(
-                begin( range ),
-                end( range ),
-                std::back_inserter( out ),
-                std::forward< Functor >( functor )
-        );
-
-        return out;
-}
-
-// -----------------------------------------------------------------------------
-// Helper struct and function to support:
-// for ( auto val : group_iterate( container1, container2, ... ) ) { ... }
-// This iteraters through multiple containers of the same size.
-
-template<typename... Args>
-class group_iterate_t {
-        using Iterables = std::tuple<Args...>;
-        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;
-
-        // 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<Indices>( iterators )... );
-                }
-                bool operator!=( const base_iterator& other ) const {
-                        return iterators != other.iterators;
-                }
-                value_type operator*() const {
-                        return std::tie( *std::get<Indices>( iterators )... );
-                }
-
-                static base_iterator make_begin( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).begin()... );
-                }
-                static base_iterator make_end( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).end()... );
-                }
-        };
-
-public:
-        group_iterate_t( const Args &... args ) : iterables( args... ) {}
-
-        using iterator = base_iterator<decltype(
-                std::make_integer_sequence<std::size_t, sizeof...(Args)>())>;
-
-        iterator begin() { return iterator::make_begin( iterables ); }
-        iterator end() { return iterator::make_end( iterables ); }
-};
-
-// Helpers for the bounds checks (the non-varatic part of group_iterate):
-static inline void runGroupBoundsCheck(size_t size0, size_t size1) {
-        assertf( size0 == size1,
-                "group iteration requires containers of the same size: <%zd, %zd>.",
-                size0, size1 );
-}
-
-static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) {
-        assertf( size0 == size1 && size1 == size2,
-                "group iteration requires containers of the same size: <%zd, %zd, %zd>.",
-                size0, size1, size2 );
-}
-
-/// Performs bounds check to ensure that all arguments are of the same length.
-template< typename... Args >
-group_iterate_t<Args...> group_iterate( Args &&... args ) {
-        runGroupBoundsCheck( args.size()... );
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
-}
-
-/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
-template< typename... Args >
-group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
-}
-
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : lazy_map( container1, f ) ) {}
-// syntax to have a for each that iterates a container, mapping each element by applying f
-template< typename T, typename Func >
-struct lambda_iterate_t {
-        const T & ref;
-        std::function<Func> f;
-
-        struct iterator {
-                typedef decltype(begin(ref)) Iter;
-                Iter it;
-                std::function<Func> f;
-                iterator( Iter it, std::function<Func> f ) : it(it), f(f) {}
-                iterator & operator++() {
-                        ++it; return *this;
-                }
-                bool operator!=( const iterator &other ) const { return it != other.it; }
-                auto operator*() const -> decltype(f(*it)) { return f(*it); }
-        };
-
-        lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {}
-
-        auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); }
-        auto end() const   -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); }
-};
-
-template< typename... Args >
-lambda_iterate_t<Args...> lazy_map( const Args &... args ) {
-        return lambda_iterate_t<Args...>( args...);
-}
 
 // -----------------------------------------------------------------------------
@@ -583 +251 @@
 } // ilog2
 
-// -----------------------------------------------------------------------------
-/// evaluates expr as a long long int. If second is false, expr could not be evaluated
-std::pair<long long int, bool> eval(const Expression * expr);
-
-namespace ast {
-        class Expr;
-}
-
-std::pair<long long int, bool> eval(const ast::Expr * expr);
-
-// -----------------------------------------------------------------------------
-/// Reorders the input range in-place so that the minimal-value elements according to the
-/// comparator are in front;
-/// returns the iterator after the last minimal-value element.
-template<typename Iter, typename Compare>
-Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
-        if ( begin == end ) return end;
-
-        Iter min_pos = begin;
-        for ( Iter i = begin + 1; i != end; ++i ) {
-                if ( lt( *i, *min_pos ) ) {
-                        // new minimum cost; swap into first position
-                        min_pos = begin;
-                        std::iter_swap( min_pos, i );
-                } else if ( ! lt( *min_pos, *i ) ) {
-                        // duplicate minimum cost; swap into next minimum position
-                        ++min_pos;
-                        std::iter_swap( min_pos, i );
-                }
-        }
-        return ++min_pos;
-}
-
-template<typename Iter, typename Compare>
-inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) {
-        return sort_mins( begin, end, lt );
-}
-
-/// sort_mins defaulted to use std::less
-template<typename Iter>
-inline Iter sort_mins( Iter begin, Iter end ) {
-        return sort_mins( begin, end, std::less<typename std::iterator_traits<Iter>::value_type>{} );
-}
-
 // Local Variables: //
 // tab-width: 4 //