Differences From Artifact [79741a3186611288]:
- File        
polemy/ast.d
- 2010-11-08 11:42:14 - part of checkin [5e407d7cf8] on branch trunk - Lexer Refactored so that it can accpet multi-symbol token (user: kinaba) [annotate]
 
To Artifact [9b22488b3393157f]:
- File        
polemy/ast.d
- 2010-11-08 11:57:48 - part of checkin [077506b38c] on branch trunk - Generic toString utility added. (user: kinaba) [annotate]
 
   17  }                                                                                     17  }
   18                                                                                        18  
   19  class DeclStatement : Statement                                                       19  class DeclStatement : Statement
   20  {                                                                                     20  {
   21          string     var;                                                               21          string     var;
   22          Expression expr;                                                              22          Expression expr;
   23          mixin SimpleConstructor;                                                      23          mixin SimpleConstructor;
   24          mixin SimpleCompare; // do not take "pos" into account                   |    24          mixin SimpleCompare;
   25  }                                                                                     25  }
   26                                                                                        26  
   27  class ExprStatement : Statement                                                       27  class ExprStatement : Statement
   28  {                                                                                     28  {
   29          Expression expr;                                                              29          Expression expr;
   30          mixin SimpleConstructor;                                                      30          mixin SimpleConstructor;
   31          mixin SimpleCompare; // do not take "pos" into account                   |    31          mixin SimpleCompare;
   32  }                                                                                     32  }
   33                                                                                        33  
   34  abstract class Expression                                                             34  abstract class Expression
   35  {                                                                                     35  {
   36          immutable LexPosition pos;                                                    36          immutable LexPosition pos;
   37          mixin SimpleConstructor;                                                      37          mixin SimpleConstructor;
   38          mixin SimpleCompare; // do not take "pos" into account                   |    38          mixin SimpleCompare;
   39  }                                                                                     39  }
   40                                                                                        40  
   41  class StrLiteralExpression : Expression                                               41  class StrLiteralExpression : Expression
   42  {                                                                                     42  {
   43          string data;                                                                  43          string data;
   44          mixin SimpleConstructor;                                                      44          mixin SimpleConstructor;
   45          mixin SimpleCompare; // do not take "pos" into account                   |    45          mixin SimpleCompare;
   46  }                                                                                     46  }
   47                                                                                        47  
   48  class IntLiteralExpression : Expression                                               48  class IntLiteralExpression : Expression
   49  {                                                                                     49  {
   50          BigInt data;                                                                  50          BigInt data;
   51          mixin SimpleConstructor;                                                      51          mixin SimpleConstructor;
   52          mixin SimpleCompare; // do not take "pos" into account                   |    52          mixin SimpleCompare;
   53  }                                                                                     53  }
   54                                                                                        54  
   55  class VarExpression : Expression                                                      55  class VarExpression : Expression
   56  {                                                                                     56  {
   57          string var;                                                                   57          string var;
   58          mixin SimpleConstructor;                                                      58          mixin SimpleConstructor;
   59          mixin SimpleCompare; // do not take "pos" into account                   |    59          mixin SimpleCompare;
   60  }                                                                                     60  }
   61                                                                                        61  
   62  class AssignExpression : Expression                                                   62  class AssignExpression : Expression
   63  {                                                                                     63  {
   64          Expression lhs;                                                               64          Expression lhs;
   65          Expression rhs;                                                               65          Expression rhs;
   66          mixin SimpleConstructor;                                                      66          mixin SimpleConstructor;
   67          mixin SimpleCompare; // do not take "pos" into account                   |    67          mixin SimpleCompare;
   68  }                                                                                     68  }
   69                                                                                        69  
   70  class FuncallExpression : Expression                                                  70  class FuncallExpression : Expression
   71  {                                                                                     71  {
   72          Expression   fun;                                                             72          Expression   fun;
   73          Expression[] args;                                                            73          Expression[] args;
   74          this(immutable LexPosition pos, Expression fun, Expression[] args...)         74          this(immutable LexPosition pos, Expression fun, Expression[] args...)
   75                  { super(pos); this.fun=fun; this.args=args.dup; }                     75                  { super(pos); this.fun=fun; this.args=args.dup; }
   76          mixin SimpleCompare; // do not take "pos" into account                   |    76          mixin SimpleCompare;
   77  }                                                                                     77  }
   78                                                                                        78  
   79  class FunLiteralExpression : Expression                                               79  class FunLiteralExpression : Expression
   80  {                                                                                     80  {
   81          string[] params;                                                              81          string[] params;
   82          Program  funbody;                                                             82          Program  funbody;
   83          mixin SimpleConstructor;                                                      83          mixin SimpleConstructor;
   84          mixin SimpleCompare; // do not take "pos" into account                   |    84          mixin SimpleCompare;
   85  }                                                                                     85  }