Changeset f23de79


Ignore:
Timestamp:
May 22, 2019, 5:34:17 PM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
0b8bf27
Parents:
5902625 (diff), 722c4831 (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/AST
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Expr.cpp

    r5902625 rf23de79  
    2020#include <vector>
    2121
     22#include "GenericSubstitution.hpp"
    2223#include "Stmt.hpp"
    2324#include "Type.hpp"
     25#include "TypeSubstitution.hpp"
    2426#include "Common/utility.h"
    2527#include "Common/SemanticError.h"
     
    157159        assert( aggregate->result );
    158160
    159 //      assert(!"unimplemented; need TypeSubstitution, genericSubstitution");
     161        #warning Needs GenericSubsitution.cpp building to work correctly
     162        result.set_and_mutate( mem->get_type() )->qualifiers |= aggregate->result->qualifiers | CV::Lvalue;  // FIXME temporary patch
     163
     164        // // take ownership of member type
     165        // result = mem->get_type();
     166        // // substitute aggregate generic parameters into member type
     167        // genericSubsitution( aggregate->result ).apply( result );
     168        // // ensure lvalue and appropriate restrictions from aggregate type
     169        // result.get_and_mutate()->qualifiers |= aggregate->result->qualifiers | CV::Lvalue;
    160170}
    161171
  • src/AST/Node.cpp

    r5902625 rf23de79  
    3535void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node ) { node->decrement(ref_t); }
    3636
    37 /// Sets this pointer to a mutated version of a pointer (possibly) owned elsehere.
    38 /// Returns a mutable version of the pointer in this node.
    39 template< typename node_t, enum ast::Node::ref_type ref_t >
    40 node_t * ast::ptr_base<node_t, ref_t>::set_and_mutate( const node_t * n ) {
    41         // ensure ownership of `n` by this node to avoid spurious single-owner mutates
    42         assign( n );
     37template< typename node_t, enum ast::Node::ref_type ref_t >
     38node_t * ast::ptr_base<node_t, ref_t>::get_and_mutate() {
    4339        // get mutable version of `n`
    4440        auto r = mutate( node );
     
    4642        assign( r );
    4743        return r;
     44}
     45
     46template< typename node_t, enum ast::Node::ref_type ref_t >
     47node_t * ast::ptr_base<node_t, ref_t>::set_and_mutate( const node_t * n ) {
     48        // ensure ownership of `n` by this node to avoid spurious single-owner mutates
     49        assign( n );
     50        // return mutable version
     51        return get_and_mutate();
    4852}
    4953
  • src/AST/Node.hpp

    r5902625 rf23de79  
    9494std::ostream& operator<< ( std::ostream& out, const Node * node );
    9595
     96/// Call a visitor on a possibly-null node
     97template<typename node_t>
     98auto maybe_accept( const node_t * n, Visitor & v ) -> decltype( n->accept(v) ) {
     99        return n ? n->accept( v ) : nullptr;
     100}
     101
    96102/// Base class for the smart pointer types
    97103/// should never really be used.
     
    141147        const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
    142148
     149        /// Returns a mutable version of the pointer in this node.
     150        node_t * get_and_mutate();
     151
    143152        /// Sets this pointer to a mutated version of a pointer (possibly) owned elsehere.
    144153        /// Returns a mutable version of the pointer in this node.
  • src/AST/Pass.hpp

    r5902625 rf23de79  
    223223};
    224224
     225/// Apply a pass to an entire translation unit
    225226template<typename pass_t>
    226227void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor );
  • src/AST/Print.cpp

    r5902625 rf23de79  
    656656
    657657        virtual const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) {
     658                os << indent << "Types:" << std::endl;
     659                for ( const auto& i : *node ) {
     660                        os << indent+1 << i.first << " -> ";
     661                        indent += 2;
     662                        i.second->accept( *this );
     663                        indent -= 2;
     664                        os << std::endl;
     665                }
     666                os << indent << "Non-types:" << std::endl;
     667                for ( auto i = node->beginVar(); i != node->endVar(); ++i ) {
     668                        os << indent+1 << i->first << " -> ";
     669                        indent += 2;
     670                        i->second->accept( *this );
     671                        indent -= 2;
     672                        os << std::endl;
     673                }
    658674                return node;
    659675        }
  • src/AST/Type.hpp

    r5902625 rf23de79  
    4747        bool is_atomic() const { return qualifiers.is_atomic; }
    4848
    49         void set_const( bool v ) { qualifiers.is_const = v; }
    50         void set_restrict( bool v ) { qualifiers.is_restrict = v; }
    51         void set_lvalue( bool v ) { qualifiers.is_lvalue = v; }
    52         void set_mutex( bool v ) { qualifiers.is_mutex = v; }
    53         void set_atomic( bool v ) { qualifiers.is_atomic = v; }
     49        Type * set_const( bool v ) { qualifiers.is_const = v; return this; }
     50        Type * set_restrict( bool v ) { qualifiers.is_restrict = v; return this; }
     51        Type * set_lvalue( bool v ) { qualifiers.is_lvalue = v; return this; }
     52        Type * set_mutex( bool v ) { qualifiers.is_mutex = v; return this; }
     53        Type * set_atomic( bool v ) { qualifiers.is_atomic = v; return this; }
    5454
    5555        /// How many elemental types are represented by this type
  • src/AST/TypeSubstitution.hpp

    r5902625 rf23de79  
    2525#include "Fwd.hpp"        // for UniqueId
    2626#include "ParseNode.hpp"
    27 #include "Type.hpp"       // for ptr<Type>
     27#include "Type.hpp"       
    2828#include "Common/SemanticError.h"  // for SemanticError
    2929#include "Visitor.hpp"
    3030#include "Decl.hpp"
    3131#include "Expr.hpp"
     32#include "Node.hpp"
    3233
    3334namespace ast {
     
    4344        TypeSubstitution &operator=( const TypeSubstitution &other );
    4445
    45         template< typename SynTreeClass > int apply( SynTreeClass *&input ) const;
    46         template< typename SynTreeClass > int applyFree( SynTreeClass *&input ) const;
     46        template< typename SynTreeClass > int apply( const SynTreeClass *& input ) const;
     47        template< typename SynTreeClass > int applyFree( const SynTreeClass *& input ) const;
     48
     49        template< typename node_t, enum Node::ref_type ref_t >
     50        int apply( ptr_base< node_t, ref_t > & input ) const {
     51                const node_t * p = input.get();
     52                int ret = apply(p);
     53                input = p;
     54                return ret;
     55        }
     56
     57        template< typename node_t, enum Node::ref_type ref_t >
     58        int applyFree( ptr_base< node_t, ref_t > & input ) const {
     59                const node_t * p = input.get();
     60                int ret = applyFree(p);
     61                input = p;
     62                return ret;
     63        }
    4764
    4865        void add( std::string formalType, const Type *actualType );
     
    162179
    163180template< typename SynTreeClass >
    164 int TypeSubstitution::apply( SynTreeClass *&input ) const {
     181int TypeSubstitution::apply( const SynTreeClass *& input ) const {
    165182        assert( input );
    166183        Pass<Substituter> sub( *this, false );
    167         input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
    168         assert( input );
     184        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
    169185///     std::cerr << "substitution result is: ";
    170186///     newType->print( std::cerr );
     
    174190
    175191template< typename SynTreeClass >
    176 int TypeSubstitution::applyFree( SynTreeClass *&input ) const {
     192int TypeSubstitution::applyFree( const SynTreeClass *& input ) const {
    177193        assert( input );
    178194        Pass<Substituter> sub( *this, true );
    179         input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
    180         assert( input );
     195        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
    181196///     std::cerr << "substitution result is: ";
    182197///     newType->print( std::cerr );
  • src/AST/porting.md

    r5902625 rf23de79  
    3838
    3939`N->print(std::ostream&)` is a visitor now, port these methods to `ast::Print` class
    40 * **TODO** write this visitor
    41 * **TODO** write `std::ostream& operator<< ( std::ostream& out, const Node* node )` in `Node.hpp` in terms of `ast::Print`
    42 * `Declaration::printShort` should also be integrated
     40* **TODO** `Declaration::printShort` should also be integrated
    4341
    4442`clone` is private to `Node` now
     
    208206
    209207`CompoundStmt`
    210 * **TODO** port copy operator
    211   * Needs to be an almost-shallow clone, where the declarations are cloned only if needed
    212   * **TODO** port `DeclReplacer`
    213208* Still a `std::list` for children, rather than `std::vector`
    214209  * allows more-efficient splicing for purposes of later code generation
     
    229224  * `getAggr()` => `aggr()`
    230225    * also now returns `const AggregateDecl *`
    231 * `genericSubstitution()` moved to own visitor in `AST/GenericSubstitution.hpp` **TODO** write
     226* `genericSubstitution()` moved to own visitor in `AST/GenericSubstitution.hpp`
    232227
    233228`BasicType`
Note: See TracChangeset for help on using the changeset viewer.