Context Navigation

-                      rf8b961b
+                      r47534159
                 output << ")";
+        }
+        void CodeGenerator::visit( AlignofExpr *sizeofExpr ) {
+                // use GCC extension to avoid bumping std to C11
+                output << "__alignof__(";
+                if ( sizeofExpr->get_isType() ) {
+                        output << genType( sizeofExpr->get_type(), "" );
+                } else {
+                        sizeofExpr->get_expr()->accept( *this );
+                } // if
+                output << ")";
+        }
         void CodeGenerator::visit( LogicalExpr *logicalExpr ) {

src/CodeGen/CodeGenerator.h

rf8b961b	r47534159
60	60	virtual void visit( ConstantExpr *constantExpr );
61	61	virtual void visit( SizeofExpr *sizeofExpr );
	62	virtual void visit( AlignofExpr *alignofExpr );
62	63	virtual void visit( LogicalExpr *logicalExpr );
63	64	virtual void visit( ConditionalExpr *conditionalExpr );

src/InitTweak/InitModel.h

rf8b961b	r47534159
72	72	void visit( ConstantExpr * );
73	73	void visit( SizeofExpr * ) { throw 0; }
	74	void visit( AlignofExpr * ) { throw 0; }
74	75	void visit( AttrExpr * ) { throw 0; }
75	76	void visit( LogicalExpr * ) { throw 0; }

src/Parser/ExpressionNode.cc

-                      rf8b961b
+                      r47534159
+                }
           case OperatorNode::AlignOf:
+                {
+                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+                                return new AlignofExpr( arg->get_decl()->buildType());
+                        } else {
+                                return new AlignofExpr( args.front());
+                        } // if
+                }
           case OperatorNode::SizeOf:
+                {
-///     bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
                         if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
                                 return new SizeofExpr( arg->get_decl()->buildType());

src/ResolvExpr/AlternativeFinder.cc

-                      rf8b961b
+                      r47534159
+        }
+        void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
+                if ( alignofExpr->get_isType() ) {
+                        alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
+                } else {
+                        // find all alternatives for the argument to sizeof
+                        AlternativeFinder finder( indexer, env );
+                        finder.find( alignofExpr->get_expr() );
+                        // find the lowest cost alternative among the alternatives, otherwise ambiguous
+                        AltList winners;
+                        findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
+                        if ( winners.size() != 1 ) {
+                                throw SemanticError( "Ambiguous expression in alignof operand: ", alignofExpr->get_expr() );
+                        } // if
+                        // return the lowest cost alternative for the argument
+                        Alternative &choice = winners.front();
+                        alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
+                } // if
+        }
         void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
                 // assume no polymorphism

src/ResolvExpr/AlternativeFinder.h

rf8b961b	r47534159
56	56	virtual void visit( ConstantExpr *constantExpr );
57	57	virtual void visit( SizeofExpr *sizeofExpr );
	58	virtual void visit( AlignofExpr *sizeofExpr );
58	59	virtual void visit( AttrExpr *attrExpr );
59	60	virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/Indexer.cc

-                      rf8b961b
+                      r47534159
                 } else {
                         maybeAccept( sizeofExpr->get_expr(), *this );
+                }
+        }
+        void Indexer::visit( AlignofExpr *alignofExpr ) {
+                acceptAllNewScope( alignofExpr->get_results(), *this );
+                if ( alignofExpr->get_isType() ) {
+                        maybeAccept( alignofExpr->get_type(), *this );
+                } else {
+                        maybeAccept( alignofExpr->get_expr(), *this );
+                }
+        }

src/SymTab/Indexer.h

rf8b961b	r47534159
54	54	virtual void visit( ConstantExpr *constantExpr );
55	55	virtual void visit( SizeofExpr *sizeofExpr );
	56	virtual void visit( AlignofExpr *alignofExpr );
56	57	virtual void visit( AttrExpr *attrExpr );
57	58	virtual void visit( LogicalExpr *logicalExpr );

src/SynTree/Expression.cc

-                      rf8b961b
+                      r47534159
 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

-                      rf8b961b
+                      r47534159
 #include "Constant.h"
+/// Expression is the root type for all expressions
 class Expression {
   public:
 …
 };
+// 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 ) {}
 …
 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:
 …
 };
+// 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:
 …
 };
 // 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:
 …
 // 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:
 …
 };
 // 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:
 …
 };
 // 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:
 …
 };
 // 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:
 …
 };
 // 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:
 …
 };
 // 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:
 …
 };
 // 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:
 …
 };
+// 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:
 …
 };
 // LogicalExpr represents a short-circuit boolean expression (&& or ||)
+/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
 class LogicalExpr : public Expression {
   public:
 …
 };
 // ConditionalExpr represents the three-argument conditional ( p ? a : b )
+/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
 class ConditionalExpr : public Expression {
   public:
 …
 };
 // CommaExpr represents the sequence operator ( a, b )
+/// CommaExpr represents the sequence operator ( a, b )
 class CommaExpr : public Expression {
   public:
 …
 };
 // TupleExpr represents a tuple expression ( [a, b, c] )
+/// TupleExpr represents a tuple expression ( [a, b, c] )
 class TupleExpr : public Expression {
   public:
 …
 };
 // 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:
 …
 };
 // 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:
 …
 };
 // 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:
 …
 };
 // ValofExpr represents a GCC 'lambda expression'
+/// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {
   public:

src/SynTree/Mutator.cc

-                      rf8b961b
+                      r47534159
+}
+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

rf8b961b	r47534159
64	64	virtual Expression* mutate( ConstantExpr *constantExpr );
65	65	virtual Expression* mutate( SizeofExpr *sizeofExpr );
	66	virtual Expression* mutate( AlignofExpr *alignofExpr );
66	67	virtual Expression* mutate( AttrExpr *attrExpr );
67	68	virtual Expression* mutate( LogicalExpr *logicalExpr );

src/SynTree/SynTree.h

rf8b961b	r47534159
69	69	class ConstantExpr;
70	70	class SizeofExpr;
	71	class AlignofExpr;
71	72	class AttrExpr;
72	73	class LogicalExpr;

src/SynTree/Visitor.cc

-                      rf8b961b
+                      r47534159
+}
+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

rf8b961b	r47534159
64	64	virtual void visit( ConstantExpr *constantExpr );
65	65	virtual void visit( SizeofExpr *sizeofExpr );
	66	virtual void visit( AlignofExpr *alignofExpr );
66	67	virtual void visit( AttrExpr *attrExpr );
67	68	virtual void visit( LogicalExpr *logicalExpr );

src/Tuples/FlattenTuple.cc

rf8b961b	r47534159
46	46	void FlattenTuple::CollectArgs::visit( ConstantExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
47	47	void FlattenTuple::CollectArgs::visit( SizeofExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
	48	void FlattenTuple::CollectArgs::visit( AlignofExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
48	49	void FlattenTuple::CollectArgs::visit( AttrExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }
49	50	void FlattenTuple::CollectArgs::visit( LogicalExpr *expr ) { currentArgs.insert( currentArgs.end(), expr ); }

src/Tuples/FlattenTuple.h

rf8b961b	r47534159
42	42	virtual void visit( ConstantExpr * );
43	43	virtual void visit( SizeofExpr * );
	44	virtual void visit( AlignofExpr * );
44	45	virtual void visit( AttrExpr * );
45	46	virtual void visit( LogicalExpr * );

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 47534159

Legend:

Download in other formats: