source: src/SynTree/Initializer.h

Last change on this file was 7870799, checked in by Thierry Delisle <tdelisle@…>, 2 years ago

Cast cost and conversion cost now take constant parameters.
This required supporting visiting const node.
The PassVisitor? can now visit const nodes but not when using the Indexer

  • Property mode set to 100644
File size: 5.9 KB
Line 
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// Initializer.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed Aug  9 10:19:00 2017
13// Update Count     : 22
14//
15
16#pragma once
17
18#include <iosfwd>            // for ostream
19#include <list>              // for list, list<>::const_iterator, list<>::it...
20
21#include "BaseSyntaxNode.h"  // for BaseSyntaxNode
22#include "Mutator.h"         // for Mutator
23#include "Visitor.h"         // for Visitor
24
25class Expression;
26class Statement;
27
28// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized.
29class Designation : public BaseSyntaxNode {
30public:
31        std::list< Expression * > designators;
32
33        Designation( const std::list< Expression * > & designators );
34        Designation( const Designation & other );
35        virtual ~Designation();
36
37        std::list< Expression * > & get_designators() { return designators; }
38
39        virtual Designation * clone() const override { return new Designation( *this ); };
40        virtual void accept( Visitor & v ) override { v.visit( this ); }
41        virtual void accept( Visitor & v ) const override { v.visit( this ); }
42        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
43        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
44};
45
46const std::list<Designation *> noDesignators;
47
48// Initializer: base class for object initializers (provide default values)
49class Initializer : public BaseSyntaxNode {
50  public:
51        Initializer( bool maybeConstructed );
52        Initializer( const Initializer & other );
53        virtual ~Initializer();
54
55        bool get_maybeConstructed() const { return maybeConstructed; }
56
57        virtual Initializer *clone() const override = 0;
58        virtual void accept( Visitor & v ) override = 0;
59        virtual void accept( Visitor & v ) const override = 0;
60        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
61        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
62  private:
63        bool maybeConstructed;
64};
65
66// SingleInit represents an initializer for a common object (e.g., int x = 4)
67class SingleInit : public Initializer {
68  public:
69        //Constant *value;
70        Expression *value;      // has to be a compile-time constant
71
72        SingleInit( Expression *value, bool maybeConstructed = false );
73        SingleInit( const SingleInit &other );
74        virtual ~SingleInit();
75
76        Expression *get_value() { return value; }
77        void set_value( Expression *newValue ) { value = newValue; }
78
79        virtual SingleInit *clone() const override { return new SingleInit( *this); }
80        virtual void accept( Visitor & v ) override { v.visit( this ); }
81        virtual void accept( Visitor & v ) const override { v.visit( this ); }
82        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
83        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
84};
85
86// ListInit represents an initializer that is composed recursively of a list of initializers; this is used to initialize
87// an array or aggregate
88class ListInit : public Initializer {
89  public:
90        std::list<Initializer *> initializers;  // order *is* important
91        std::list<Designation *> designations;  // order/length is consistent with initializers
92
93        ListInit( const std::list<Initializer*> &initializers,
94                          const std::list<Designation *> &designators = {}, bool maybeConstructed = false );
95        ListInit( const ListInit & other );
96        virtual ~ListInit();
97
98        std::list<Designation *> & get_designations() { return designations; }
99        std::list<Initializer *> & get_initializers() { return initializers; }
100
101        typedef std::list<Initializer*>::iterator iterator;
102        typedef std::list<Initializer*>::const_iterator const_iterator;
103        iterator begin() { return initializers.begin(); }
104        iterator end() { return initializers.end(); }
105        const_iterator begin() const { return initializers.begin(); }
106        const_iterator end() const { return initializers.end(); }
107
108        virtual ListInit *clone() const override { return new ListInit( *this ); }
109        virtual void accept( Visitor & v ) override { v.visit( this ); }
110        virtual void accept( Visitor & v ) const override { v.visit( this ); }
111        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
112        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
113};
114
115// ConstructorInit represents an initializer that is either a constructor expression or
116// a C-style initializer.
117// It should not be necessary to create ConstructorInit nodes manually. Instead, set maybeConstructed
118// to true on SingleInit or ListInit constructors if object should be constructed.
119class ConstructorInit : public Initializer {
120  public:
121        Statement * ctor;
122        Statement * dtor;
123        // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
124        // if an appropriate constructor definition is not found by the resolver
125        Initializer * init;
126
127        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
128        ConstructorInit( const ConstructorInit &other );
129        virtual ~ConstructorInit();
130
131        void set_ctor( Statement * newValue ) { ctor = newValue; }
132        Statement * get_ctor() const { return ctor; }
133        void set_dtor( Statement * newValue ) { dtor = newValue; }
134        Statement * get_dtor() const { return dtor; }
135        void set_init( Initializer * newValue ) { init = newValue; }
136        Initializer * get_init() const { return init; }
137
138        ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
139        virtual void accept( Visitor & v ) override { v.visit( this ); }
140        virtual void accept( Visitor & v ) const override { v.visit( this ); }
141        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
142        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
143
144  private:
145};
146
147// Local Variables: //
148// tab-width: 4 //
149// mode: c++ //
150// compile-command: "make install" //
151// End: //
Note: See TracBrowser for help on using the repository browser.