Changeset 000b914 for src/SynTree

Timestamp:

Dec 7, 2015, 11:31:53 AM (10 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

baf7fee

Parents:

e58be8e (diff), 47534159 (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/SynTree

Files:

• Expression.cc (modified) (1 diff)
• Expression.h (modified) (21 diffs)
• Mutator.cc (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• SynTree.h (modified) (1 diff)
• Visitor.cc (modified) (1 diff)
• Visitor.h (modified) (1 diff)

src/SynTree/Expression.cc

@@ -122 +122 @@
 void SizeofExpr::print( std::ostream &os, int indent) const {
         os << std::string( indent, ' ' ) << "Sizeof Expression on: ";
+
+        if (isType)
+                type->print(os, indent + 2);
+        else
+                expr->print(os, indent + 2);
+
+        os << std::endl;
+        Expression::print( os, indent );
+}
+
+AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+}
+
+AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
+                Expression( _aname ), expr(0), type(type_), isType(true) {
+        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+}
+
+AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
+        Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
+
+AlignofExpr::~AlignofExpr() {
+        delete expr;
+        delete type;
+}
+
+void AlignofExpr::print( std::ostream &os, int indent) const {
+        os << std::string( indent, ' ' ) << "Alignof Expression on: ";
 
         if (isType)

src/SynTree/Expression.h

@@ -23 +23 @@
 #include "Constant.h"
 
+/// Expression is the root type for all expressions
 class Expression {
   public:
@@ -47 +48 @@
 };
 
-// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
-// but subject to decay-to-pointer and type parameter renaming
-
+/// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
+/// but subject to decay-to-pointer and type parameter renaming
 struct ParamEntry {
         ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
@@ -65 +65 @@
 typedef std::map< UniqueId, ParamEntry > InferredParams;
 
-// ApplicationExpr represents the application of a function to a set of parameters.  This is the
-// result of running an UntypedExpr through the expression analyzer.
-
+/// ApplicationExpr represents the application of a function to a set of parameters.  This is the
+/// result of running an UntypedExpr through the expression analyzer.
 class ApplicationExpr : public Expression {
   public:
@@ -89 +88 @@
 };
 
-// UntypedExpr represents the application of a function to a set of parameters, but where the
-// particular overload for the function name has not yet been determined.  Most operators are
-// converted into functional form automatically, to permit operator overloading.
-
+/// UntypedExpr represents the application of a function to a set of parameters, but where the
+/// particular overload for the function name has not yet been determined.  Most operators are
+/// converted into functional form automatically, to permit operator overloading.
 class UntypedExpr : public Expression {
   public:
@@ -118 +116 @@
 };
 
-// this class contains a name whose meaning is still not determined
+/// NameExpr contains a name whose meaning is still not determined
 class NameExpr : public Expression {
   public:
@@ -139 +137 @@
 // function-call format.
 
-// AddressExpr represents a address-of expression, e.g. &e
+/// AddressExpr represents a address-of expression, e.g. &e
 class AddressExpr : public Expression {
   public:
@@ -174 +172 @@
 };
 
-// CastExpr represents a type cast expression, e.g. (int)e
+/// CastExpr represents a type cast expression, e.g. (int)e
 class CastExpr : public Expression {
   public:
@@ -193 +191 @@
 };
 
-// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
+/// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
 class UntypedMemberExpr : public Expression {
   public:
@@ -214 +212 @@
 };
 
-// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
+/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
 class MemberExpr : public Expression {
   public:
@@ -235 +233 @@
 };
 
-// VariableExpr represents an expression that simply refers to the value of a named variable
+/// VariableExpr represents an expression that simply refers to the value of a named variable
 class VariableExpr : public Expression {
   public:
@@ -253 +251 @@
 };
 
-// ConstantExpr represents an expression that simply refers to the value of a constant 
+/// ConstantExpr represents an expression that simply refers to the value of a constant 
 class ConstantExpr : public Expression {
   public:
@@ -271 +269 @@
 };
 
-// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
+/// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
 class SizeofExpr : public Expression {
   public:
@@ -296 +294 @@
 };
 
-// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
+/// AlignofExpr represents an alignof expression
+class AlignofExpr : public Expression {
+  public:
+        AlignofExpr( Expression *expr, Expression *_aname = 0 );
+        AlignofExpr( const AlignofExpr &other );
+        AlignofExpr( Type *type, Expression *_aname = 0 );
+        virtual ~AlignofExpr();
+
+        Expression *get_expr() const { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        Type *get_type() const { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        bool get_isType() const { return isType; }
+        void set_isType( bool newValue ) { isType = newValue; }
+
+        virtual AlignofExpr *clone() const { return new AlignofExpr( *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 *expr;
+        Type *type;
+        bool isType;
+};
+
+/// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
 class AttrExpr : public Expression {
   public:
@@ -324 +347 @@
 };
 
-// LogicalExpr represents a short-circuit boolean expression (&& or ||)
+/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
 class LogicalExpr : public Expression {
   public:
@@ -347 +370 @@
 };
 
-// ConditionalExpr represents the three-argument conditional ( p ? a : b )
+/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
 class ConditionalExpr : public Expression {
   public:
@@ -371 +394 @@
 };
 
-// CommaExpr represents the sequence operator ( a, b )
+/// CommaExpr represents the sequence operator ( a, b )
 class CommaExpr : public Expression {
   public:
@@ -392 +415 @@
 };
 
-// TupleExpr represents a tuple expression ( [a, b, c] )
+/// TupleExpr represents a tuple expression ( [a, b, c] )
 class TupleExpr : public Expression {
   public:
@@ -410 +433 @@
 };
 
-// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
+/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
 class SolvedTupleExpr : public Expression {
   public:
@@ -428 +451 @@
 };
 
-// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
+/// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
 class TypeExpr : public Expression {
   public:
@@ -446 +469 @@
 };
 
-// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
+/// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
 class AsmExpr : public Expression {
   public:
@@ -472 +495 @@
 };
 
-// ValofExpr represents a GCC 'lambda expression'
+/// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {
   public:

src/SynTree/Mutator.cc

@@ -251 +251 @@
 }
 
+Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
+        mutateAll( alignofExpr->get_results(), *this );
+        if ( alignofExpr->get_isType() ) {
+                alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
+        } else {
+                alignofExpr->set_expr( maybeMutate( alignofExpr->get_expr(), *this ) );
+        }
+        return alignofExpr;
+}
+
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
         mutateAll( attrExpr->get_results(), *this );

src/SynTree/Mutator.h

@@ -64 +64 @@
         virtual Expression* mutate( ConstantExpr *constantExpr ); 
         virtual Expression* mutate( SizeofExpr *sizeofExpr );
+        virtual Expression* mutate( AlignofExpr *alignofExpr );
         virtual Expression* mutate( AttrExpr *attrExpr );
         virtual Expression* mutate( LogicalExpr *logicalExpr );

src/SynTree/SynTree.h

@@ -69 +69 @@
 class ConstantExpr;
 class SizeofExpr;
+class AlignofExpr;
 class AttrExpr;
 class LogicalExpr;

src/SynTree/Visitor.cc

@@ -210 +210 @@
 }
 
+void Visitor::visit( AlignofExpr *alignofExpr ) {
+        acceptAll( alignofExpr->get_results(), *this );
+        if ( alignofExpr->get_isType() ) {
+                maybeAccept( alignofExpr->get_type(), *this );
+        } else {
+                maybeAccept( alignofExpr->get_expr(), *this );
+        }
+}
+
 void Visitor::visit( AttrExpr *attrExpr ) {
         acceptAll( attrExpr->get_results(), *this );

src/SynTree/Visitor.h

@@ -64 +64 @@
         virtual void visit( ConstantExpr *constantExpr ); 
         virtual void visit( SizeofExpr *sizeofExpr );
+        virtual void visit( AlignofExpr *alignofExpr );
         virtual void visit( AttrExpr *attrExpr );
         virtual void visit( LogicalExpr *logicalExpr );