Mercurial > projects > dil

changeset 71:b3777cca323c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- Added Identity and NotIdentity tokens. - Added constructor to Parser. Added error method and parseCondExpression(). - Added parseAssignExpression() method. - Moved arguments() function from error() method of Lexer to module Information. - Added members and constructor to BinaryExpression. - Added XYZAssignExpression classes. - Added calls to super() to classes that inherit from BinaryExpression.
author aziz
date Sun, 01 Jul 2007 16:16:05 +0000
parents 0d3ef6daec04
children f75e359f939f
files trunk/src/Expressions.d trunk/src/Information.d trunk/src/Lexer.d trunk/src/Parser.d trunk/src/Token.d
diffstat 5 files changed, 194 insertions(+), 46 deletions(-) [+]
line wrap: on
line diff
--- a/trunk/src/Expressions.d	Sun Jul 01 14:49:05 2007 +0000
+++ b/trunk/src/Expressions.d	Sun Jul 01 16:16:05 2007 +0000
@@ -3,6 +3,7 @@
   License: GPL2
 +/
 module Expressions;
+import Token;
 
 class Expression
 {
@@ -16,12 +17,14 @@
 
 class BinaryExpression : Expression
 {
-
-}
-
-class AssignExpression : Expression
-{
-
+  Expression left, right;
+  TOK tok;
+  this(Expression left, Expression right, TOK tok)
+  {
+    this.left = left;
+    this.right = right;
+    this.tok = tok;
+  }
 }
 
 class CondExpression : Expression
@@ -31,72 +34,146 @@
 
 class OrOrExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right)
+  { super(left, right, TOK.OrLogical); }
 }
 
 class AndAndExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right)
+  { super(left, right, TOK.AndLogical); }
 }
 
 class OrExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right)
+  { super(left, right, TOK.OrBinary); }
 }
 
 class XorExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right)
+  { super(left, right, TOK.Xor); }
 }
 
 class AndExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right)
+  { super(left, right, TOK.AndBinary); }
 }
 
 class CmpExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, tok); }
 }
 
-class EqualExpression : BinaryExpression
+class EqualExpression : CmpExpression
 {
-
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, TOK.Equal); }
 }
 
-class IdentExpression
+class IdentExpression : CmpExpression
 {
-
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, tok); }
 }
 
-class RelExpression : BinaryExpression
+class RelExpression : CmpExpression
 {
-
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, tok); }
 }
 
 class InExpression : BinaryExpression
 {
-
-}
-
-class ShiftExpression : BinaryExpression
-{
-
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, TOK.In); }
 }
 
 class AddExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, tok); }
 }
 
 class MulExpression : BinaryExpression
 {
-
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, tok); }
 }
 
 class CatExpression : BinaryExpression
 {
+  this(Expression left, Expression right, TOK tok)
+  { super(left, right, TOK.Catenate); }
+}
 
+class AssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.Assign); }
+}
+class LShiftAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.LShiftAssign); }
+}
+class RShiftAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.RShiftAssign); }
+}
+class URShiftAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.URShiftAssign); }
+}
+class OrAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.OrAssign); }
+}
+class AndAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.AndAssign); }
+}
+class PlusAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.PlusAssign); }
+}
+class MinusAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.MinusAssign); }
+}
+class DivAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.DivAssign); }
+}
+class MulAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.MulAssign); }
+}
+class ModAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.ModAssign); }
+}
+class XorAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.XorAssign); }
+}
+class CatAssignExpression : BinaryExpression
+{
+  this(Expression left, Expression right)
+  { super(left, right, TOK.CatAssign); }
 }
 
 class PostfixExpression : UnaryExpression
--- a/trunk/src/Information.d	Sun Jul 01 14:49:05 2007 +0000
+++ b/trunk/src/Information.d	Sun Jul 01 16:16:05 2007 +0000
@@ -5,6 +5,7 @@
 module Information;
 import Messages;
 import std.string;
+import std.stdarg;
 
 enum Type
 {
@@ -42,3 +43,19 @@
   }
 }
 
+char[][] arguments(TypeInfo[] tinfos, void* argptr)
+{
+  char[][] args;
+  foreach (ti; tinfos)
+  {
+    if (ti == typeid(char[]))
+      args ~= format(va_arg!(char[])(argptr));
+    else if (ti == typeid(int))
+      args ~= format(va_arg!(int)(argptr));
+    else if (ti == typeid(dchar))
+      args ~= format(va_arg!(dchar)(argptr));
+    else
+      assert(0, "argument type not supported yet.");
+  }
+  return args;
+}
--- a/trunk/src/Lexer.d	Sun Jul 01 14:49:05 2007 +0000
+++ b/trunk/src/Lexer.d	Sun Jul 01 16:16:05 2007 +0000
@@ -12,7 +12,6 @@
 import std.utf;
 import std.uni;
 import std.c.stdlib;
-import std.stdarg;
 import std.string;
 
 const char[3] LS = \u2028;
@@ -1423,23 +1422,6 @@
 
   void error(MID id, ...)
   {
-    char[][] arguments(TypeInfo[] tinfos, void* argptr)
-    {
-      char[][] args;
-      foreach (ti; tinfos)
-      {
-        if (ti == typeid(char[]))
-          args ~= format(va_arg!(char[])(argptr));
-        else if (ti == typeid(int))
-          args ~= format(va_arg!(int)(argptr));
-        else if (ti == typeid(dchar))
-          args ~= format(va_arg!(dchar)(argptr));
-        else
-          assert(0, "argument type not supported yet.");
-      }
-      return args;
-    }
-
     errors ~= new Information(Information.Type.Lexer, id, loc, arguments(_arguments, _argptr));
   }
 
--- a/trunk/src/Parser.d	Sun Jul 01 14:49:05 2007 +0000
+++ b/trunk/src/Parser.d	Sun Jul 01 16:16:05 2007 +0000
@@ -4,6 +4,9 @@
 +/
 module Parser;
 import Lexer;
+import Token;
+import Messages;
+import Information;
 import Expressions;
 
 enum STC
@@ -21,9 +24,77 @@
   Synchronized
 }
 
+private alias TOK T;
+
 class Parser
 {
-  private Lexer lx;
-  alias lx.nextToken nextToken;
+  Lexer lx;
+  TOK delegate() nT;
+
+  Information[] errors;
+
+  this(char[] srcText, string fileName)
+  {
+    lx = new Lexer(srcText, fileName);
+    nT = &lx.nextToken;
+  }
 
+  Expression parseAssignExpression()
+  {
+    auto e = parseCondExpression();
+    switch (lx.token.type)
+    {
+    case T.Assign:
+      nT(); e = new AssignExpression(e, parseAssignExpression());
+      break;
+    case T.LShiftAssign:
+      nT(); e = new LShiftAssignExpression(e, parseAssignExpression());
+      break;
+    case T.RShiftAssign:
+      nT(); e = new RShiftAssignExpression(e, parseAssignExpression());
+      break;
+    case T.URShiftAssign:
+      nT(); e = new URShiftAssignExpression(e, parseAssignExpression());
+      break;
+    case T.OrAssign:
+      nT(); e = new OrAssignExpression(e, parseAssignExpression());
+      break;
+    case T.AndAssign:
+      nT(); e = new AndAssignExpression(e, parseAssignExpression());
+      break;
+    case T.PlusAssign:
+      nT(); e = new PlusAssignExpression(e, parseAssignExpression());
+      break;
+    case T.MinusAssign:
+      nT(); e = new MinusAssignExpression(e, parseAssignExpression());
+      break;
+    case T.DivAssign:
+      nT(); e = new DivAssignExpression(e, parseAssignExpression());
+      break;
+    case T.MulAssign:
+      nT(); e = new MulAssignExpression(e, parseAssignExpression());
+      break;
+    case T.ModAssign:
+      nT(); e = new ModAssignExpression(e, parseAssignExpression());
+      break;
+    case T.XorAssign:
+      nT(); e = new XorAssignExpression(e, parseAssignExpression());
+      break;
+    case T.CatAssign:
+      nT(); e = new CatAssignExpression(e, parseAssignExpression());
+      break;
+    default:
+      break;
+    }
+    return e;
+  }
+  Expression parseCondExpression()
+  {
+    return new Expression();
+  }
+
+  void error(MID id, ...)
+  {
+    errors ~= new Information(Information.Type.Parser, id, lx.loc, arguments(_arguments, _argptr));
+  }
 }
--- a/trunk/src/Token.d	Sun Jul 01 14:49:05 2007 +0000
+++ b/trunk/src/Token.d	Sun Jul 01 16:16:05 2007 +0000
@@ -62,6 +62,7 @@
   XorAssign, Xor,
   CatAssign, Catenate,
   Tilde,
+  Identity, NotIdentity,
 
   Colon,
   Semicolon,