Changeset 9c23f31 for src/SynTree

Timestamp:

Sep 24, 2016, 12:19:33 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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, with_gc

Children:

3b5e3aa

Parents:

2298f728 (diff), 7ae930a (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:

fix conflicts

Location:

src/SynTree

Files:

• Expression.cc (modified) (4 diffs)
• Expression.h (modified) (2 diffs)
• Mutator.cc (modified) (3 diffs)
• Mutator.h (modified) (2 diffs)
• SynTree.h (modified) (2 diffs)
• Type.h (modified) (1 diff)
• TypeSubstitution.cc (modified) (2 diffs)
• TypeSubstitution.h (modified) (1 diff)
• Visitor.cc (modified) (3 diffs)
• Visitor.h (modified) (2 diffs)
• ZeroOneType.cc (added)
• module.mk (modified) (1 diff)

src/SynTree/Expression.cc

@@ -28 +28 @@
 #include "TypeSubstitution.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 
@@ -493 +494 @@
 
 void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) <<  "Implicit Copy Constructor Expression: " << std::endl;
+        os <<  "Implicit Copy Constructor Expression: " << std::endl;
         assert( callExpr );
         callExpr->print( os, indent + 2 );
@@ -503 +504 @@
 }
 
+
+ConstructorExpr::ConstructorExpr( Expression * callExpr ) : callExpr( callExpr ) {
+        // allow resolver to type a constructor used as an expression as if it has the same type as its first argument
+        assert( callExpr );
+        Expression * arg = InitTweak::getCallArg( callExpr, 0 );
+        assert( arg );
+        cloneAll( arg->get_results(), results );
+}
+
+ConstructorExpr::ConstructorExpr( const ConstructorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
+}
+
+ConstructorExpr::~ConstructorExpr() {
+        delete callExpr;
+}
+
+void ConstructorExpr::print( std::ostream &os, int indent ) const {
+        os <<  "Constructor Expression: " << std::endl;
+        assert( callExpr );
+        os << std::string( indent+2, ' ' );
+        callExpr->print( os, indent + 2 );
+        Expression::print( os, indent );
+}
+
+
+CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
+        add_result( type->clone() );
+}
+
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
+
+CompoundLiteralExpr::~CompoundLiteralExpr() {
+        delete initializer;
+        delete type;
+}
+
+void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
+        os << "Compound Literal Expression: " << std::endl;
+        if ( type ) type->print( os, indent + 2 );
+        if ( initializer ) initializer->print( os, indent + 2 );
+}
+
 UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {}
 
@@ -511 +554 @@
         if ( get_body() != 0 )
                 get_body()->print( os, indent + 2 );
-}
-
-
-CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        add_result( type->clone() );
-}
-
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
-
-CompoundLiteralExpr::~CompoundLiteralExpr() {
-        delete initializer;
-        delete type;
-}
-
-void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
-        os << "Compound Literal Expression: " << std::endl;
-        if ( type ) type->print( os, indent + 2 );
-        if ( initializer ) initializer->print( os, indent + 2 );
 }
 

src/SynTree/Expression.h

@@ -595 +595 @@
 };
 
+/// ConstructorExpr represents the use of a constructor in an expression context, e.g. int * x = malloc() { 5 };
+class ConstructorExpr : public Expression {
+public:
+        ConstructorExpr( Expression * callExpr );
+        ConstructorExpr( const ConstructorExpr & other );
+        ~ConstructorExpr();
+
+        Expression *get_callExpr() const { return callExpr; }
+        void set_callExpr( Expression *newValue ) { callExpr = newValue; }
+
+        virtual ConstructorExpr *clone() const { return new ConstructorExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+        Expression * callExpr;
+};
+
+/// CompoundLiteralExpr represents a C99 'compound literal'
+class CompoundLiteralExpr : public Expression {
+  public:
+        CompoundLiteralExpr( Type * type, Initializer * initializer );
+        CompoundLiteralExpr( const CompoundLiteralExpr &other );
+        ~CompoundLiteralExpr();
+
+        Type * get_type() const { return type; }
+        void set_type( Type * t ) { type = t; }
+
+        Initializer * get_initializer() const { return initializer; }
+        void set_initializer( Initializer * i ) { initializer = i; }
+
+        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type * type;
+        Initializer * initializer;
+};
+
 /// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {
@@ -613 +653 @@
 };
 
-/// CompoundLiteralExpr represents a C99 'compound literal'
-class CompoundLiteralExpr : public Expression {
-  public:
-        CompoundLiteralExpr( Type * type, Initializer * initializer );
-        CompoundLiteralExpr( const CompoundLiteralExpr &other );
-        ~CompoundLiteralExpr();
-
-        Type * get_type() const { return type; }
-        void set_type( Type * t ) { type = t; }
-
-        Initializer * get_initializer() const { return initializer; }
-        void set_initializer( Initializer * i ) { initializer = i; }
-
-        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Type * type;
-        Initializer * initializer;
-};
-
+/// RangeExpr represents a range e.g. '3 ... 5' or '1~10'
 class RangeExpr : public Expression {
   public:

src/SynTree/Mutator.cc

@@ -339 +339 @@
 }
 
-Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
-        mutateAll( valofExpr->get_results(), *this );
-        return valofExpr;
+Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
+        mutateAll( ctorExpr->get_results(), *this );
+        ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
+        return ctorExpr;
 }
 
@@ -349 +350 @@
         compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
         return compLitExpr;
+}
+
+Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
+        mutateAll( valofExpr->get_results(), *this );
+        return valofExpr;
 }
 
@@ -447 +453 @@
 }
 
+Type *Mutator::mutate( ZeroType *zeroType ) {
+        mutateAll( zeroType->get_forall(), *this );
+        return zeroType;
+}
+
+Type *Mutator::mutate( OneType *oneType ) {
+        mutateAll( oneType->get_forall(), *this );
+        return oneType;
+}
+
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
         singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );

src/SynTree/Mutator.h

@@ -76 +76 @@
         virtual Expression* mutate( AsmExpr *asmExpr );
         virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr );
+        virtual Expression* mutate( ConstructorExpr *ctorExpr );
+        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
-        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
         virtual Expression* mutate( RangeExpr *rangeExpr );
 
@@ -94 +95 @@
         virtual Type* mutate( AttrType *attrType );
         virtual Type* mutate( VarArgsType *varArgsType );
+        virtual Type* mutate( ZeroType *zeroType );
+        virtual Type* mutate( OneType *oneType );
 
         virtual Initializer* mutate( SingleInit *singleInit );

src/SynTree/SynTree.h

@@ -81 +81 @@
 class AsmExpr;
 class ImplicitCopyCtorExpr;
+class ConstructorExpr;
+class CompoundLiteralExpr;
 class UntypedValofExpr;
-class CompoundLiteralExpr;
 class RangeExpr;
 
@@ -101 +102 @@
 class AttrType;
 class VarArgsType;
+class ZeroType;
+class OneType;
 
 class Initializer;

src/SynTree/Type.h

@@ -418 +418 @@
 };
 
+/// Represents a zero constant
+class ZeroType : public Type {
+  public:
+        ZeroType();
+        ZeroType( Type::Qualifiers tq );
+
+        virtual ZeroType *clone() const { return new ZeroType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+
+/// Represents a one constant
+class OneType : public Type {
+  public:
+        OneType();
+        OneType( Type::Qualifiers tq );
+
+        virtual OneType *clone() const { return new OneType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+
 inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
         isConst |= other.isConst;

src/SynTree/TypeSubstitution.cc

@@ -179 +179 @@
 }
 
-Type * TypeSubstitution::mutate( VoidType *basicType ) {
-        return handleType( basicType );
+Type * TypeSubstitution::mutate( VoidType *voidType ) {
+        return handleType( voidType );
 }
 
@@ -221 +221 @@
 Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
         return handleType( varArgsType );
+}
+
+Type * TypeSubstitution::mutate( ZeroType *zeroType ) {
+        return handleType( zeroType );
+}
+
+Type * TypeSubstitution::mutate( OneType *oneType ) {
+        return handleType( oneType );
 }
 

src/SynTree/TypeSubstitution.h

@@ -76 +76 @@
         virtual Type* mutate(TupleType *tupleType);
         virtual Type* mutate(VarArgsType *varArgsType);
+        virtual Type* mutate(ZeroType *zeroType);
+        virtual Type* mutate(OneType *oneType);
 
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions

src/SynTree/Visitor.cc

@@ -287 +287 @@
 }
 
-void Visitor::visit( UntypedValofExpr *valofExpr ) {
-        acceptAll( valofExpr->get_results(), *this );
-        maybeAccept( valofExpr->get_body(), *this );
+void Visitor::visit( ConstructorExpr * ctorExpr ) {
+        acceptAll( ctorExpr->get_results(), *this );
+        maybeAccept( ctorExpr->get_callExpr(), *this );
 }
 
@@ -296 +296 @@
         maybeAccept( compLitExpr->get_type(), *this );
         maybeAccept( compLitExpr->get_initializer(), *this );
+}
+
+void Visitor::visit( UntypedValofExpr *valofExpr ) {
+        acceptAll( valofExpr->get_results(), *this );
+        maybeAccept( valofExpr->get_body(), *this );
 }
 
@@ -378 +383 @@
 }
 
+void Visitor::visit( ZeroType *zeroType ) {
+        acceptAll( zeroType->get_forall(), *this );
+}
+
+void Visitor::visit( OneType *oneType ) {
+        acceptAll( oneType->get_forall(), *this );
+}
+
 void Visitor::visit( SingleInit *singleInit ) {
         singleInit->get_value()->accept( *this );

src/SynTree/Visitor.h

@@ -76 +76 @@
         virtual void visit( AsmExpr *asmExpr );
         virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
+        virtual void visit( ConstructorExpr * ctorExpr );
+        virtual void visit( CompoundLiteralExpr *compLitExpr );
         virtual void visit( UntypedValofExpr *valofExpr );
-        virtual void visit( CompoundLiteralExpr *compLitExpr );
         virtual void visit( RangeExpr *rangeExpr );
 
@@ -94 +95 @@
         virtual void visit( AttrType *attrType );
         virtual void visit( VarArgsType *varArgsType );
+        virtual void visit( ZeroType *zeroType );
+        virtual void visit( OneType *oneType );
 
         virtual void visit( SingleInit *singleInit );

src/SynTree/module.mk

@@ -26 +26 @@
        SynTree/AttrType.cc \
        SynTree/VarArgsType.cc \
+       SynTree/ZeroOneType.cc \
        SynTree/Constant.cc \
        SynTree/Expression.cc \