Context Navigation

-                      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:

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

Context Navigation

Changeset 47534159 for src/SynTree/Expression.h

Legend:

src/SynTree/Expression.h

Download in other formats: