source: src/AST/Node.hpp @ 76ed81f

ADTarm-ehast-experimentalcleanup-dtorsenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 76ed81f was 76ed81f, checked in by Aaron Moss <a3moss@…>, 5 years ago

Broken stuff pre-Pass fix

  • Property mode set to 100644
File size: 4.7 KB
RevLine 
[2bb4a01]1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Node.hpp --
8//
9// Author           : Thierry Delisle
10// Created On       : Wed May 8 10:27:04 2019
[1e97287]11// Last Modified By : Andrew Beach
12// Last Modified On : Wed May 15 16:02:00 2019
13// Update Count     : 3
[2bb4a01]14//
15
[cedb545]16#pragma once
17
[2bb4a01]18#include <cassert>
19#include <iosfwd>
[cedb545]20
21namespace ast {
[2bb4a01]22
23class Visitor;
24
25/// Base class for all AST nodes.
26/// Keeps both strong and weak reference counts.
[f47f887]27class Node {
28public:
[14cebb7a]29        // override defaults to ensure assignment doesn't
[2bb4a01]30        // change/share reference counts
31        Node() = default;
[6d51bd7]32        Node(const Node&) : strong_count(0), weak_count(0) {}
33        Node(Node&&) : strong_count(0), weak_count(0) {}
[2bb4a01]34        Node& operator= (const Node&) = delete;
35        Node& operator= (Node&&) = delete;
[f47f887]36        virtual ~Node() = default;
[cedb545]37
[6d51bd7]38        virtual const Node * accept( Visitor & v ) const = 0;
[2bb4a01]39
40        /// Types of node references
[f47f887]41        enum class ref_type {
42                strong,
43                weak
44        };
[cedb545]45
[87701b6]46private:
47        /// Make a copy of this node; should be overridden in subclass with more precise return type
48        virtual Node * clone() const = 0;
49
50        /// Must be copied in ALL derived classes
51        template<typename node_t>
52        friend node_t * mutate(const node_t * node);
53
54        mutable size_t strong_count = 0;
55        mutable size_t weak_count = 0;
56
57        void increment(ref_type ref) const {
[f47f887]58                switch (ref) {
[6d51bd7]59                        case ref_type::strong: strong_count++; break;
60                        case ref_type::weak  : weak_count  ++; break;
[cedb545]61                }
[f47f887]62        }
[cedb545]63
[87701b6]64        void decrement(ast::Node::ref_type ref) const {
[f47f887]65                switch (ref) {
[6d51bd7]66                        case ref_type::strong: strong_count--; break;
67                        case ref_type::weak  : weak_count  --; break;
[cedb545]68                }
69
[6d51bd7]70                if(!strong_count && !weak_count) {
[f47f887]71                        delete this;
[6a625de]72                }
[f47f887]73        }
[6a625de]74
[87701b6]75        template< typename node_t, enum Node::ref_type ref_t >
76        friend class ptr_base;
[f47f887]77};
78
79// Mutate a node, non-member function to avoid static type
80// problems and be able to use auto return
81template<typename node_t>
[87701b6]82node_t * mutate( const node_t * node ) {
83        if (node->strong_count <= 1) {
[f47f887]84                return const_cast<node_t *>(node);
[6a625de]85        }
86
[f47f887]87        assertf(
88                node->weak_count == 0,
89                "Error: mutating node with weak references to it will invalided some references"
90        );
91        return node->clone();
92}
93
[54e41b3]94std::ostream& operator<< ( std::ostream& out, const Node * node );
[2bb4a01]95
[d8938622]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
[9e1d485]102/// Base class for the smart pointer types
103/// should never really be used.
104template< typename node_t, enum Node::ref_type ref_t >
[f47f887]105class ptr_base {
106public:
107        ptr_base() : node(nullptr) {}
[87701b6]108        ptr_base( const node_t * n ) : node(n) { if( node ) _inc(node); }
109        ~ptr_base() { if( node ) _dec(node); }
[f47f887]110
[9e1d485]111        template< enum Node::ref_type o_ref_t >
[f47f887]112        ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.node) {
[87701b6]113                if( node ) _inc(node);
[6a625de]114        }
115
[9e1d485]116        template< enum Node::ref_type o_ref_t >
[f47f887]117        ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.node) {
[87701b6]118                if( node ) _inc(node);
[6d51bd7]119        }
120
121        template<typename o_node_t>
122        ptr_base & operator=( const o_node_t * node ) {
123                assign(strict_dynamic_cast<const node_t *>(node));
124                return *this;
[f47f887]125        }
[cedb545]126
[9e1d485]127        template< enum Node::ref_type o_ref_t >
[f47f887]128        ptr_base & operator=( const ptr_base<node_t, o_ref_t> & o ) {
129                assign(o.node);
130                return *this;
131        }
[cedb545]132
[9e1d485]133        template< enum Node::ref_type o_ref_t >
[f47f887]134        ptr_base & operator=( ptr_base<node_t, o_ref_t> && o ) {
135                assign(o.node);
136                return *this;
137        }
[cedb545]138
[f47f887]139        const node_t * get() const { return  node; }
140        const node_t * operator->() const { return  node; }
141        const node_t & operator* () const { return *node; }
142        explicit operator bool() const { return node; }
[3648d98]143        operator const node_t * () const { return node; }
[cedb545]144
[54e41b3]145        /// wrapper for convenient access to dynamic_cast
[fdbd4fd]146        template<typename o_node_t>
[9e1d485]147        const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
[fdbd4fd]148
[76ed81f]149        /// Returns a mutable version of the pointer in this node.
150        node_t * get_and_mutate();
151
[54e41b3]152        /// Sets this pointer to a mutated version of a pointer (possibly) owned elsehere.
153        /// Returns a mutable version of the pointer in this node.
[10a1225]154        node_t * set_and_mutate( const node_t * n );
[54e41b3]155
[f47f887]156        using ptr = const node_t *;
[cedb545]157
[f47f887]158private:
[9e1d485]159        void assign( const node_t * other ) {
[87701b6]160                if( other ) _inc(other);
161                if( node  ) _dec(node );
[f47f887]162                node = other;
163        }
[cedb545]164
[87701b6]165        void _inc( const node_t * other );
166        void _dec( const node_t * other );
167
[f47f887]168protected:
[9e1d485]169        const node_t * node;
[f47f887]170};
[cedb545]171
[2bb4a01]172/// Owning pointer to node
[f47f887]173template< typename node_t >
174using ptr = ptr_base< node_t, Node::ref_type::strong >;
[cedb545]175
[2bb4a01]176/// Observing pointer to node
[f47f887]177template< typename node_t >
178using readonly = ptr_base< node_t, Node::ref_type::weak >;
[2bb4a01]179}
180
181// Local Variables: //
182// tab-width: 4 //
183// mode: c++ //
184// compile-command: "make install" //
[1e97287]185// End: //
Note: See TracBrowser for help on using the repository browser.