Changeset 97f65d5 for src/Common

Timestamp:

Feb 15, 2017, 8:13:49 AM (9 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, stuck-waitfor-destruct, with_gc

Children:

e6512c8

Parents:

aa9ee19 (diff), 3149e7e (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:/u/cforall/software/cfa/cfa-cc

Location:

src/Common

Files:

• ScopedMap.h (modified) (1 diff)
• SemanticError.cc (modified) (2 diffs)
• SemanticError.h (modified) (2 diffs)
• VectorMap.h (modified) (4 diffs)
• utility.h (modified) (2 diffs)

src/Common/ScopedMap.h

@@ -230 +230 @@
         }
 
+        /// Finds the given key in the provided scope; returns end() for none such
+        iterator findAt( size_type scope, const Key& key ) {
+                typename Scope::iterator val = scopes[scope].find( key );
+                if ( val != scopes[scope].end() ) return iterator( scopes, val, scope );
+                return end();
+        }
+        const_iterator findAt( size_type scope, const Key& key ) const {
+                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findAt( scope, key ) );
+        }
+
         /// Finds the given key in the outermost scope inside the given scope where it occurs
         iterator findNext( const_iterator &it, const Key &key ) {

src/Common/SemanticError.cc

@@ -22 +22 @@
 #include "SemanticError.h"
 
+#include <unistd.h>
+
+inline const std::string& error_str() {
+        static std::string str = isatty( fileno(stderr) ) ? "\e[31merror:\e[39m " : "error: ";
+        return str;
+}
+
 SemanticError::SemanticError() {
 }
 
 SemanticError::SemanticError( std::string error ) {
-  append( error );
+        append( error );
 }
 
 void SemanticError::append( SemanticError &other ) {
-  errors.splice( errors.end(), other.errors );
+        errors.splice( errors.end(), other.errors );
 }
 
 void SemanticError::append( const std::string & msg ) {
-  errors.push_back( std::string( "Error: ") + msg );
+        errors.emplace_back( error_str() + msg );
 }
 
@@ -42 +49 @@
 
 void SemanticError::print( std::ostream &os ) {
-        std::copy( errors.begin(), errors.end(), std::ostream_iterator< std::string >( os, "\n" ) );
+        using std::to_string;
+        for(auto err : errors) {
+                os << to_string( err.location ) << err.description << '\n';
+        }
+}
+
+void SemanticError::set_location( const CodeLocation& location ) {
+        errors.begin()->maybeSet( location );
 }
 

src/Common/SemanticError.h

@@ -23 +23 @@
 #include <iostream>
 
+#include "utility.h"
+
+struct error {
+        std::string description;
+        CodeLocation location;
+
+        error() = default;
+        error( const std::string& str ) : description( str ) {}
+
+        void maybeSet( const CodeLocation& location ) {
+                if( this->location.linenumber < 0 ) {
+                        this->location = location;
+                }
+        }
+};
+
 class SemanticError : public std::exception {
   public:
@@ -35 +51 @@
         void print( std::ostream &os );
 
+        void set_location( const CodeLocation& location );
         // constructs an exception using the given message and the printed
         // representation of the obj (T must have a print method)
   private:
-        std::list< std::string > errors;
+        std::list< error > errors;
 };
 

src/Common/VectorMap.h

@@ -38 +38 @@
         typedef const const_value_type* const_pointer;
         
-        class iterator : public std::iterator< std::bidirectional_iterator_tag,
+        class iterator : public std::iterator< std::random_access_iterator_tag,
                                                value_type,
-                                                                                    difference_type,
-                                                                                        pointer,
-                                                                                        reference > {
+                                                                                   difference_type,
+                                                                                   pointer,
+                                                                                   reference > {
         friend class VectorMap;
         friend class const_iterator;
@@ -74 +74 @@
                 iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
 
+                iterator& operator+= (difference_type i) {
+                        // SHENANIGANS: same reasons as operator++
+                        new(&data) value_type{ (data.first + i), *(&data.second + i) };
+                        return *this;
+                }
+
+                iterator operator+ (difference_type i) const { iterator tmp = *this; return tmp += i; }
+
+                iterator& operator-= (difference_type i) {
+                        // SHENANIGANS: same reasons as operator++
+                        new(&data) value_type{ (data.first - i), *(&data.second - i) };
+                        return *this;
+                }
+
+                iterator operator- (difference_type i) const { iterator tmp = *this; return tmp -= i; }
+
+                difference_type operator- (const iterator& o) const { return data.first - o.data.first; }
+
+                value_type operator[] (difference_type i) const {
+                        // SHENANIGANS: same reasons as operator++
+                        return value_type{ (data.first + i), *(&data.second + i) };
+                }
+
                 bool operator== (const iterator& o) const {
                         return data.first == o.data.first && &data.second == &o.data.second;
                 }
+                
                 bool operator!= (const iterator& that) const { return !(*this == that); }
+
+                bool operator< (const iterator& o) const { return data.first < o.data.first; }
+
+                bool operator> (const iterator& o) const { return data.first > o.data.first; }
+
+                bool operator<= (const iterator& o) const { return data.first <= o.data.first; }
+
+                bool operator>= (const iterator& o) const { return data.first >= o.data.first; }
         };
 
@@ -118 +150 @@
                 const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
 
+                const_iterator& operator+= (difference_type i) {
+                        // SHENANIGANS: same reasons as iterator::operator++
+                        new(&data) const_value_type{ (data.first + i), *(&data.second + i) };
+                        return *this;
+                }
+
+                const_iterator operator+ (difference_type i) const {
+                        const_iterator tmp = *this; return tmp += i;
+                }
+
+                const_iterator& operator-= (difference_type i) {
+                        // SHENANIGANS: same reasons as iterator::operator++
+                        new(&data) const_value_type{ (data.first - i), *(&data.second - i) };
+                        return *this;
+                }
+
+                const_iterator operator- (difference_type i) const {
+                        const_iterator tmp = *this; return tmp -= i;
+                }
+
+                difference_type operator- (const const_iterator& o) const {
+                        return data.first - o.data.first;
+                }
+
+                const_value_type operator[] (difference_type i) const {
+                        // SHENANIGANS: same reasons as iterator::operator++
+                        return const_value_type{ (data.first + i), *(&data.second + i) };
+                }
+
                 bool operator== (const const_iterator& o) const {
                         return data.first == o.data.first && &data.second == &o.data.second;
                 }
+                
                 bool operator!= (const const_iterator& that) const { return !(*this == that); }
+
+                bool operator< (const const_iterator& o) const { return data.first < o.data.first; }
+
+                bool operator> (const const_iterator& o) const { return data.first > o.data.first; }
+
+                bool operator<= (const const_iterator& o) const { return data.first <= o.data.first; }
+
+                bool operator>= (const const_iterator& o) const { return data.first >= o.data.first; }
         };
 
@@ -163 +233 @@
 };
 
+template<typename T>
+typename VectorMap<T>::iterator operator+ (typename VectorMap<T>::difference_type i, 
+                                           const typename VectorMap<T>::iterator& it) {
+        return it + i;
+}
+
+template<typename T>
+typename VectorMap<T>::const_iterator operator+ (typename VectorMap<T>::difference_type i, 
+                                                 const typename VectorMap<T>::const_iterator& it) {
+        return it + i;
+}
+
 #endif // _VECTORMAP_H
 

src/Common/utility.h

@@ -25 +25 @@
 #include <sstream>
 #include <string>
+
 #include <cassert>
-
 template< typename T >
 static inline T * maybeClone( const T *orig ) {
@@ -303 +303 @@
         return group_iterate_t<Args...>(args...);
 }
+
+struct CodeLocation {
+        int linenumber;
+        std::string filename;
+
+        CodeLocation() 
+                : linenumber( -1 )
+                , filename("")
+        {}
+
+        CodeLocation( const char* filename, int lineno )
+                : linenumber( lineno )
+                , filename(filename ? filename : "")
+        {}
+};
+
+inline std::string to_string( const CodeLocation& location ) {
+        return location.linenumber >= 0 ? location.filename + ":" + std::to_string(location.linenumber) + " " : "";
+}
 #endif // _UTILITY_H