Changes in / [000b914:e58be8e]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• GenPoly/Box.cc (modified) (6 diffs)
• GenPoly/FindFunction.h (modified) (1 diff)
• GenPoly/GenPoly.cc (modified) (1 diff)
• GenPoly/Lvalue.cc (modified) (2 diffs)
• GenPoly/ScrubTyVars.h (modified) (1 diff)
• InitTweak/InitModel.h (modified) (1 diff)
• Parser/ExpressionNode.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• SymTab/Indexer.cc (modified) (1 diff)
• SymTab/Indexer.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (21 diffs)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• Tuples/FlattenTuple.cc (modified) (1 diff)
• Tuples/FlattenTuple.h (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -442 +442 @@
                 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

@@ -60 +60 @@
                 virtual void visit( ConstantExpr *constantExpr ); 
                 virtual void visit( SizeofExpr *sizeofExpr );
-                virtual void visit( AlignofExpr *alignofExpr );
                 virtual void visit( LogicalExpr *logicalExpr );
                 virtual void visit( ConditionalExpr *conditionalExpr );

src/GenPoly/Box.cc

@@ -50 +50 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 : public PolyMutator {
                   public:
@@ -89 +88 @@
                 };
 
-                /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well
                 class Pass2 : public PolyMutator {
                   public:
@@ -107 +105 @@
                 };
 
-                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
                 class Pass3 : public PolyMutator {
                   public:
@@ -1012 +1009 @@
                         std::list< DeclarationWithType *> inferredParams;
                         ObjectDecl *newObj = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
-//   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
+///   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
                         for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
                                 ObjectDecl *thisParm;
@@ -1024 +1021 @@
                                 // move all assertions into parameter list
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
-//      *assert = (*assert)->acceptMutator( *this );
+///      *assert = (*assert)->acceptMutator( *this );
                                         inferredParams.push_back( *assert );
                                 }
@@ -1066 +1063 @@
 
                 TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
-//   Initializer *init = 0;
-//   std::list< Expression *> designators;
-//   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-//   if ( typeDecl->get_base() ) {
-//     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
-//   }
-//   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
+///   Initializer *init = 0;
+///   std::list< Expression *> designators;
+///   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
+///   if ( typeDecl->get_base() ) {
+///     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
+///   }
+///   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
 
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();

src/GenPoly/FindFunction.h

@@ -23 +23 @@
         typedef bool (*FindFunctionPredicate)( FunctionType*, const TyVarMap& );
 
-        /// recursively walk `type`, placing all functions that match `predicate` under `tyVars` into `functions`
         void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
-        /// like `findFunction`, but also replaces the function type with void ()(void)
         void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
 } // namespace GenPoly

src/GenPoly/GenPoly.cc

@@ -21 +21 @@
 
 namespace GenPoly {
-        /// A function needs an adapter if it returns a polymorphic value or if any of its
-        /// parameters have polymorphic type
+        // A function needs an adapter if it returns a polymorphic value or if any of its
+        // parameters have polymorphic type
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
                 if ( ! adaptee->get_returnVals().empty() && isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {

src/GenPoly/Lvalue.cc

@@ -35 +35 @@
                 const std::list<Label> noLabels;
 
-                /// Replace uses of lvalue returns with appropriate pointers
                 class Pass1 : public Mutator {
                   public:
@@ -47 +46 @@
                 };
 
-                /// Replace declarations of lvalue returns with appropriate pointers
                 class Pass2 : public Visitor {
                   public:

src/GenPoly/ScrubTyVars.h

@@ -26 +26 @@
           public:
                 ScrubTyVars( bool doAll, const TyVarMap &tyVars ): doAll( doAll ), tyVars( tyVars ) {}
-
-                /// Like scrub( SynTreeClass* ), but only applies to type variables in `tyVars`
+  
                 template< typename SynTreeClass >
                 static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars );
-                /// Replaces dtypes and ftypes with the appropriate void type, and sizeof expressions of polymorphic types with the proper variable
                 template< typename SynTreeClass >
                 static SynTreeClass *scrub( SynTreeClass *target );

src/InitTweak/InitModel.h

@@ -72 +72 @@
                         void visit( ConstantExpr * );
                         void visit( SizeofExpr * ) { throw 0; }
-                        void visit( AlignofExpr * ) { throw 0; }
                         void visit( AttrExpr * ) { throw 0; }
                         void visit( LogicalExpr * ) { throw 0; }

src/Parser/ExpressionNode.cc

@@ -586 +586 @@
                 }
           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

@@ -792 +792 @@
         }
 
-        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

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

src/SymTab/Indexer.cc

@@ -215 +215 @@
                 } 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

@@ -54 +54 @@
                 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 );

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:
@@ -48 +47 @@
 };
 
-/// 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:
@@ -88 +89 @@
 };
 
-/// 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:
@@ -116 +118 @@
 };
 
-/// NameExpr contains a name whose meaning is still not determined
+// this class contains a name whose meaning is still not determined
 class NameExpr : public Expression {
   public:
@@ -137 +139 @@
 // 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:
@@ -172 +174 @@
 };
 
-/// 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:
@@ -191 +193 @@
 };
 
-/// 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:
@@ -212 +214 @@
 };
 
-/// 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:
@@ -233 +235 @@
 };
 
-/// 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:
@@ -251 +253 @@
 };
 
-/// 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:
@@ -269 +271 @@
 };
 
-/// 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:
@@ -294 +296 @@
 };
 
-/// 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)
+// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
 class AttrExpr : public Expression {
   public:
@@ -347 +324 @@
 };
 
-/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
+// LogicalExpr represents a short-circuit boolean expression (&& or ||)
 class LogicalExpr : public Expression {
   public:
@@ -370 +347 @@
 };
 
-/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
+// ConditionalExpr represents the three-argument conditional ( p ? a : b )
 class ConditionalExpr : public Expression {
   public:
@@ -394 +371 @@
 };
 
-/// CommaExpr represents the sequence operator ( a, b )
+// CommaExpr represents the sequence operator ( a, b )
 class CommaExpr : public Expression {
   public:
@@ -415 +392 @@
 };
 
-/// TupleExpr represents a tuple expression ( [a, b, c] )
+// TupleExpr represents a tuple expression ( [a, b, c] )
 class TupleExpr : public Expression {
   public:
@@ -433 +410 @@
 };
 
-/// 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:
@@ -451 +428 @@
 };
 
-/// 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:
@@ -469 +446 @@
 };
 
-/// 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:
@@ -495 +472 @@
 };
 
-/// 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 );

src/Tuples/FlattenTuple.cc

@@ -46 +46 @@
         void FlattenTuple::CollectArgs::visit( ConstantExpr      *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( SizeofExpr        *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
-        void FlattenTuple::CollectArgs::visit( AlignofExpr       *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( AttrExpr          *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( LogicalExpr       *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }

src/Tuples/FlattenTuple.h

@@ -42 +42 @@
                         virtual void visit( ConstantExpr * ); 
                         virtual void visit( SizeofExpr * );
-                        virtual void visit( AlignofExpr * );
                         virtual void visit( AttrExpr * );
                         virtual void visit( LogicalExpr * );