Separating all of the simple binary expression nodes into multiple classes
authoroliver <oliver@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 23 Oct 2007 21:25:44 +0000 (21:25 +0000)
committeroliver <oliver@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 23 Oct 2007 21:25:44 +0000 (21:25 +0000)
Reviewed by Maciej

Separating all of the simple (eg. non-read-modify-write) binary operators into separate classes in preparation for further JS optimisations.

Happily this produces a 0.8% to 1.0% performance increase in SunSpider with no further work.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@26925 268f45cc-cd09-0410-ab3c-d52691b4dbfc

JavaScriptCore/ChangeLog
JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
JavaScriptCore/kjs/grammar.y
JavaScriptCore/kjs/nodes.cpp
JavaScriptCore/kjs/nodes.h
JavaScriptCore/kjs/nodes2string.cpp

index d1e1770f34562eacfa323c0d0902949cd0753201..3c0ce9b394cb195a886fcc73ddf69d5174dd14ee 100644 (file)
@@ -1,3 +1,87 @@
+2007-10-23  Oliver Hunt  <oliver@apple.com>
+
+        Reviewed by Maciej.
+
+        Separating all of the simple (eg. non-read-modify-write) binary operators
+        into separate classes in preparation for further JS optimisations.
+        
+        Happily this produces a 0.8% to 1.0% performance increase in SunSpider with
+        no further work.
+
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * kjs/grammar.y:
+        * kjs/nodes.cpp:
+        (KJS::MultNode::evaluate):
+        (KJS::DivNode::evaluate):
+        (KJS::ModNode::evaluate):
+        (KJS::AddNode::evaluate):
+        (KJS::SubNode::evaluate):
+        (KJS::LeftShiftNode::evaluate):
+        (KJS::RightShiftNode::evaluate):
+        (KJS::UnsignedRightShiftNode::evaluate):
+        (KJS::LessNode::evaluate):
+        (KJS::GreaterNode::evaluate):
+        (KJS::LessEqNode::evaluate):
+        (KJS::GreaterEqNode::evaluate):
+        (KJS::InstanceOfNode::evaluate):
+        (KJS::InNode::evaluate):
+        (KJS::EqualNode::evaluate):
+        (KJS::NotEqualNode::evaluate):
+        (KJS::StrictEqualNode::evaluate):
+        (KJS::NotStrictEqualNode::evaluate):
+        (KJS::BitAndNode::evaluate):
+        (KJS::BitXOrNode::evaluate):
+        (KJS::BitOrNode::evaluate):
+        (KJS::LogicalAndNode::evaluate):
+        (KJS::LogicalOrNode::evaluate):
+        * kjs/nodes.h:
+        (KJS::MultNode::):
+        (KJS::DivNode::):
+        (KJS::ModNode::):
+        (KJS::AddNode::):
+        (KJS::SubNode::):
+        (KJS::LeftShiftNode::):
+        (KJS::RightShiftNode::):
+        (KJS::UnsignedRightShiftNode::):
+        (KJS::LessNode::):
+        (KJS::GreaterNode::):
+        (KJS::LessEqNode::):
+        (KJS::GreaterEqNode::):
+        (KJS::InstanceOfNode::):
+        (KJS::InNode::):
+        (KJS::EqualNode::):
+        (KJS::NotEqualNode::):
+        (KJS::StrictEqualNode::):
+        (KJS::NotStrictEqualNode::):
+        (KJS::BitAndNode::):
+        (KJS::BitOrNode::):
+        (KJS::BitXOrNode::):
+        (KJS::LogicalAndNode::):
+        (KJS::LogicalOrNode::):
+        * kjs/nodes2string.cpp:
+        (MultNode::streamTo):
+        (DivNode::streamTo):
+        (ModNode::streamTo):
+        (AddNode::streamTo):
+        (SubNode::streamTo):
+        (LeftShiftNode::streamTo):
+        (RightShiftNode::streamTo):
+        (UnsignedRightShiftNode::streamTo):
+        (LessNode::streamTo):
+        (GreaterNode::streamTo):
+        (LessEqNode::streamTo):
+        (GreaterEqNode::streamTo):
+        (InstanceOfNode::streamTo):
+        (InNode::streamTo):
+        (EqualNode::streamTo):
+        (NotEqualNode::streamTo):
+        (StrictEqualNode::streamTo):
+        (NotStrictEqualNode::streamTo):
+        (BitAndNode::streamTo):
+        (BitXOrNode::streamTo):
+        (BitOrNode::streamTo):
+        (LogicalAndNode::streamTo):
+
 2007-10-23  Darin Adler  <darin@apple.com>
 
         Reviewed by Maciej.
 2007-10-23  Darin Adler  <darin@apple.com>
 
         Reviewed by Maciej.
index 30e1201608cb2a1a04ab7786afda307ba4d77dc2..97fd45510dd72ccdb1e637969d26338a5133bd6f 100644 (file)
                0867D690FE84028FC02AAC07 /* Project object */ = {
                        isa = PBXProject;
                        buildConfigurationList = 149C277108902AFE008A9EFC /* Build configuration list for PBXProject "JavaScriptCore" */;
                0867D690FE84028FC02AAC07 /* Project object */ = {
                        isa = PBXProject;
                        buildConfigurationList = 149C277108902AFE008A9EFC /* Build configuration list for PBXProject "JavaScriptCore" */;
-                       compatibilityVersion = "Xcode 2.4";
                        hasScannedForEncodings = 1;
                        mainGroup = 0867D691FE84028FC02AAC07 /* JavaScriptCore */;
                        productRefGroup = 034768DFFF38A50411DB9C8B /* Products */;
                        projectDirPath = "";
                        hasScannedForEncodings = 1;
                        mainGroup = 0867D691FE84028FC02AAC07 /* JavaScriptCore */;
                        productRefGroup = 034768DFFF38A50411DB9C8B /* Products */;
                        projectDirPath = "";
-                       projectRoot = "";
                        targets = (
                                932F5BE30822A1C700736975 /* All */,
                                932F5B3E0822A1C700736975 /* JavaScriptCore */,
                        targets = (
                                932F5BE30822A1C700736975 /* All */,
                                932F5B3E0822A1C700736975 /* JavaScriptCore */,
index ecda56c808ae7626e98673ea2ad12ae921eaaa45..fa0011ca0fde3282f1b661eadc1fd4dd5b4e4bc6 100644 (file)
@@ -377,192 +377,192 @@ UnaryExprNoBF:
 
 MultiplicativeExpr:
     UnaryExpr
 
 MultiplicativeExpr:
     UnaryExpr
-  | MultiplicativeExpr '*' UnaryExpr    { $$ = new MultNode($1, $3, '*'); }
-  | MultiplicativeExpr '/' UnaryExpr    { $$ = new MultNode($1, $3, '/'); }
-  | MultiplicativeExpr '%' UnaryExpr    { $$ = new MultNode($1, $3,'%'); }
+  | MultiplicativeExpr '*' UnaryExpr    { $$ = new MultNode($1, $3); }
+  | MultiplicativeExpr '/' UnaryExpr    { $$ = new DivNode($1, $3); }
+  | MultiplicativeExpr '%' UnaryExpr    { $$ = new ModNode($1, $3); }
 ;
 
 MultiplicativeExprNoBF:
     UnaryExprNoBF
   | MultiplicativeExprNoBF '*' UnaryExpr
 ;
 
 MultiplicativeExprNoBF:
     UnaryExprNoBF
   | MultiplicativeExprNoBF '*' UnaryExpr
-                                        { $$ = new MultNode($1, $3, '*'); }
+                                        { $$ = new MultNode($1, $3); }
   | MultiplicativeExprNoBF '/' UnaryExpr
   | MultiplicativeExprNoBF '/' UnaryExpr
-                                        { $$ = new MultNode($1, $3, '/'); }
+                                        { $$ = new DivNode($1, $3); }
   | MultiplicativeExprNoBF '%' UnaryExpr
   | MultiplicativeExprNoBF '%' UnaryExpr
-                                        { $$ = new MultNode($1, $3,'%'); }
+                                        { $$ = new ModNode($1, $3); }
 ;
 
 AdditiveExpr:
     MultiplicativeExpr
 ;
 
 AdditiveExpr:
     MultiplicativeExpr
-  | AdditiveExpr '+' MultiplicativeExpr { $$ = new AddNode($1, $3, '+'); }
-  | AdditiveExpr '-' MultiplicativeExpr { $$ = new AddNode($1, $3, '-'); }
+  | AdditiveExpr '+' MultiplicativeExpr { $$ = new AddNode($1, $3); }
+  | AdditiveExpr '-' MultiplicativeExpr { $$ = new SubNode($1, $3); }
 ;
 
 AdditiveExprNoBF:
     MultiplicativeExprNoBF
   | AdditiveExprNoBF '+' MultiplicativeExpr
 ;
 
 AdditiveExprNoBF:
     MultiplicativeExprNoBF
   | AdditiveExprNoBF '+' MultiplicativeExpr
-                                        { $$ = new AddNode($1, $3, '+'); }
+                                        { $$ = new AddNode($1, $3); }
   | AdditiveExprNoBF '-' MultiplicativeExpr
   | AdditiveExprNoBF '-' MultiplicativeExpr
-                                        { $$ = new AddNode($1, $3, '-'); }
+                                        { $$ = new SubNode($1, $3); }
 ;
 
 ShiftExpr:
     AdditiveExpr
 ;
 
 ShiftExpr:
     AdditiveExpr
-  | ShiftExpr LSHIFT AdditiveExpr       { $$ = new ShiftNode($1, OpLShift, $3); }
-  | ShiftExpr RSHIFT AdditiveExpr       { $$ = new ShiftNode($1, OpRShift, $3); }
-  | ShiftExpr URSHIFT AdditiveExpr      { $$ = new ShiftNode($1, OpURShift, $3); }
+  | ShiftExpr LSHIFT AdditiveExpr       { $$ = new LeftShiftNode($1, $3); }
+  | ShiftExpr RSHIFT AdditiveExpr       { $$ = new RightShiftNode($1, $3); }
+  | ShiftExpr URSHIFT AdditiveExpr      { $$ = new UnsignedRightShiftNode($1, $3); }
 ;
 
 ShiftExprNoBF:
     AdditiveExprNoBF
 ;
 
 ShiftExprNoBF:
     AdditiveExprNoBF
-  | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = new ShiftNode($1, OpLShift, $3); }
-  | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = new ShiftNode($1, OpRShift, $3); }
-  | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = new ShiftNode($1, OpURShift, $3); }
+  | ShiftExprNoBF LSHIFT AdditiveExpr   { $$ = new LeftShiftNode($1, $3); }
+  | ShiftExprNoBF RSHIFT AdditiveExpr   { $$ = new RightShiftNode($1, $3); }
+  | ShiftExprNoBF URSHIFT AdditiveExpr  { $$ = new UnsignedRightShiftNode($1, $3); }
 ;
 
 RelationalExpr:
     ShiftExpr
 ;
 
 RelationalExpr:
     ShiftExpr
-  | RelationalExpr '<' ShiftExpr        { $$ = new RelationalNode($1, OpLess, $3); }
-  | RelationalExpr '>' ShiftExpr        { $$ = new RelationalNode($1, OpGreater, $3); }
-  | RelationalExpr LE ShiftExpr         { $$ = new RelationalNode($1, OpLessEq, $3); }
-  | RelationalExpr GE ShiftExpr         { $$ = new RelationalNode($1, OpGreaterEq, $3); }
-  | RelationalExpr INSTANCEOF ShiftExpr { $$ = new RelationalNode($1, OpInstanceOf, $3); }
-  | RelationalExpr INTOKEN ShiftExpr    { $$ = new RelationalNode($1, OpIn, $3); }
+  | RelationalExpr '<' ShiftExpr        { $$ = new LessNode($1, $3); }
+  | RelationalExpr '>' ShiftExpr        { $$ = new GreaterNode($1, $3); }
+  | RelationalExpr LE ShiftExpr         { $$ = new LessEqNode($1, $3); }
+  | RelationalExpr GE ShiftExpr         { $$ = new GreaterEqNode($1, $3); }
+  | RelationalExpr INSTANCEOF ShiftExpr { $$ = new InstanceOfNode($1, $3); }
+  | RelationalExpr INTOKEN ShiftExpr    { $$ = new InNode($1, $3); }
 ;
 
 RelationalExprNoIn:
     ShiftExpr
 ;
 
 RelationalExprNoIn:
     ShiftExpr
-  | RelationalExprNoIn '<' ShiftExpr    { $$ = new RelationalNode($1, OpLess, $3); }
-  | RelationalExprNoIn '>' ShiftExpr    { $$ = new RelationalNode($1, OpGreater, $3); }
-  | RelationalExprNoIn LE ShiftExpr     { $$ = new RelationalNode($1, OpLessEq, $3); }
-  | RelationalExprNoIn GE ShiftExpr     { $$ = new RelationalNode($1, OpGreaterEq, $3); }
+  | RelationalExprNoIn '<' ShiftExpr    { $$ = new LessNode($1, $3); }
+  | RelationalExprNoIn '>' ShiftExpr    { $$ = new GreaterNode($1, $3); }
+  | RelationalExprNoIn LE ShiftExpr     { $$ = new LessEqNode($1, $3); }
+  | RelationalExprNoIn GE ShiftExpr     { $$ = new GreaterEqNode($1, $3); }
   | RelationalExprNoIn INSTANCEOF ShiftExpr
   | RelationalExprNoIn INSTANCEOF ShiftExpr
-                                        { $$ = new RelationalNode($1, OpInstanceOf, $3); }
+                                        { $$ = new InstanceOfNode($1, $3); }
 ;
 
 RelationalExprNoBF:
     ShiftExprNoBF
 ;
 
 RelationalExprNoBF:
     ShiftExprNoBF
-  | RelationalExprNoBF '<' ShiftExpr    { $$ = new RelationalNode($1, OpLess, $3); }
-  | RelationalExprNoBF '>' ShiftExpr    { $$ = new RelationalNode($1, OpGreater, $3); }
-  | RelationalExprNoBF LE ShiftExpr     { $$ = new RelationalNode($1, OpLessEq, $3); }
-  | RelationalExprNoBF GE ShiftExpr     { $$ = new RelationalNode($1, OpGreaterEq, $3); }
+  | RelationalExprNoBF '<' ShiftExpr    { $$ = new LessNode($1, $3); }
+  | RelationalExprNoBF '>' ShiftExpr    { $$ = new GreaterNode($1, $3); }
+  | RelationalExprNoBF LE ShiftExpr     { $$ = new LessEqNode($1, $3); }
+  | RelationalExprNoBF GE ShiftExpr     { $$ = new GreaterEqNode($1, $3); }
   | RelationalExprNoBF INSTANCEOF ShiftExpr
   | RelationalExprNoBF INSTANCEOF ShiftExpr
-                                        { $$ = new RelationalNode($1, OpInstanceOf, $3); }
-  | RelationalExprNoBF INTOKEN ShiftExpr     { $$ = new RelationalNode($1, OpIn, $3); }
+                                        { $$ = new InstanceOfNode($1, $3); }
+  | RelationalExprNoBF INTOKEN ShiftExpr     { $$ = new InNode($1, $3); }
 ;
 
 EqualityExpr:
     RelationalExpr
 ;
 
 EqualityExpr:
     RelationalExpr
-  | EqualityExpr EQEQ RelationalExpr    { $$ = new EqualNode($1, OpEqEq, $3); }
-  | EqualityExpr NE RelationalExpr      { $$ = new EqualNode($1, OpNotEq, $3); }
-  | EqualityExpr STREQ RelationalExpr   { $$ = new EqualNode($1, OpStrEq, $3); }
-  | EqualityExpr STRNEQ RelationalExpr  { $$ = new EqualNode($1, OpStrNEq, $3);}
+  | EqualityExpr EQEQ RelationalExpr    { $$ = new EqualNode($1, $3); }
+  | EqualityExpr NE RelationalExpr      { $$ = new NotEqualNode($1, $3); }
+  | EqualityExpr STREQ RelationalExpr   { $$ = new StrictEqualNode($1, $3); }
+  | EqualityExpr STRNEQ RelationalExpr  { $$ = new NotStrictEqualNode($1, $3); }
 ;
 
 EqualityExprNoIn:
     RelationalExprNoIn
   | EqualityExprNoIn EQEQ RelationalExprNoIn
 ;
 
 EqualityExprNoIn:
     RelationalExprNoIn
   | EqualityExprNoIn EQEQ RelationalExprNoIn
-                                        { $$ = new EqualNode($1, OpEqEq, $3); }
+                                        { $$ = new EqualNode($1, $3); }
   | EqualityExprNoIn NE RelationalExprNoIn
   | EqualityExprNoIn NE RelationalExprNoIn
-                                        { $$ = new EqualNode($1, OpNotEq, $3); }
+                                        { $$ = new NotEqualNode($1, $3); }
   | EqualityExprNoIn STREQ RelationalExprNoIn
   | EqualityExprNoIn STREQ RelationalExprNoIn
-                                        { $$ = new EqualNode($1, OpStrEq, $3); }
+                                        { $$ = new StrictEqualNode($1, $3); }
   | EqualityExprNoIn STRNEQ RelationalExprNoIn
   | EqualityExprNoIn STRNEQ RelationalExprNoIn
-                                        { $$ = new EqualNode($1, OpStrNEq, $3);}
+                                        { $$ = new NotStrictEqualNode($1, $3); }
 ;
 
 EqualityExprNoBF:
     RelationalExprNoBF
   | EqualityExprNoBF EQEQ RelationalExpr
 ;
 
 EqualityExprNoBF:
     RelationalExprNoBF
   | EqualityExprNoBF EQEQ RelationalExpr
-                                        { $$ = new EqualNode($1, OpEqEq, $3); }
-  | EqualityExprNoBF NE RelationalExpr  { $$ = new EqualNode($1, OpNotEq, $3); }
+                                        { $$ = new EqualNode($1, $3); }
+  | EqualityExprNoBF NE RelationalExpr  { $$ = new NotEqualNode($1, $3); }
   | EqualityExprNoBF STREQ RelationalExpr
   | EqualityExprNoBF STREQ RelationalExpr
-                                        { $$ = new EqualNode($1, OpStrEq, $3); }
+                                        { $$ = new StrictEqualNode($1, $3); }
   | EqualityExprNoBF STRNEQ RelationalExpr
   | EqualityExprNoBF STRNEQ RelationalExpr
-                                        { $$ = new EqualNode($1, OpStrNEq, $3);}
+                                        { $$ = new NotStrictEqualNode($1, $3); }
 ;
 
 BitwiseANDExpr:
     EqualityExpr
 ;
 
 BitwiseANDExpr:
     EqualityExpr
-  | BitwiseANDExpr '&' EqualityExpr     { $$ = new BitOperNode($1, OpBitAnd, $3); }
+  | BitwiseANDExpr '&' EqualityExpr     { $$ = new BitAndNode($1, $3); }
 ;
 
 BitwiseANDExprNoIn:
     EqualityExprNoIn
   | BitwiseANDExprNoIn '&' EqualityExprNoIn
 ;
 
 BitwiseANDExprNoIn:
     EqualityExprNoIn
   | BitwiseANDExprNoIn '&' EqualityExprNoIn
-                                        { $$ = new BitOperNode($1, OpBitAnd, $3); }
+                                        { $$ = new BitAndNode($1, $3); }
 ;
 
 BitwiseANDExprNoBF:
     EqualityExprNoBF
 ;
 
 BitwiseANDExprNoBF:
     EqualityExprNoBF
-  | BitwiseANDExprNoBF '&' EqualityExpr { $$ = new BitOperNode($1, OpBitAnd, $3); }
+  | BitwiseANDExprNoBF '&' EqualityExpr { $$ = new BitAndNode($1, $3); }
 ;
 
 BitwiseXORExpr:
     BitwiseANDExpr
 ;
 
 BitwiseXORExpr:
     BitwiseANDExpr
-  | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = new BitOperNode($1, OpBitXOr, $3); }
+  | BitwiseXORExpr '^' BitwiseANDExpr   { $$ = new BitXOrNode($1, $3); }
 ;
 
 BitwiseXORExprNoIn:
     BitwiseANDExprNoIn
   | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
 ;
 
 BitwiseXORExprNoIn:
     BitwiseANDExprNoIn
   | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
-                                        { $$ = new BitOperNode($1, OpBitXOr, $3); }
+                                        { $$ = new BitXOrNode($1, $3); }
 ;
 
 BitwiseXORExprNoBF:
     BitwiseANDExprNoBF
   | BitwiseXORExprNoBF '^' BitwiseANDExpr
 ;
 
 BitwiseXORExprNoBF:
     BitwiseANDExprNoBF
   | BitwiseXORExprNoBF '^' BitwiseANDExpr
-                                        { $$ = new BitOperNode($1, OpBitXOr, $3); }
+                                        { $$ = new BitXOrNode($1, $3); }
 ;
 
 BitwiseORExpr:
     BitwiseXORExpr
 ;
 
 BitwiseORExpr:
     BitwiseXORExpr
-  | BitwiseORExpr '|' BitwiseXORExpr    { $$ = new BitOperNode($1, OpBitOr, $3); }
+  | BitwiseORExpr '|' BitwiseXORExpr    { $$ = new BitOrNode($1, $3); }
 ;
 
 BitwiseORExprNoIn:
     BitwiseXORExprNoIn
   | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
 ;
 
 BitwiseORExprNoIn:
     BitwiseXORExprNoIn
   | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
-                                        { $$ = new BitOperNode($1, OpBitOr, $3); }
+                                        { $$ = new BitOrNode($1, $3); }
 ;
 
 BitwiseORExprNoBF:
     BitwiseXORExprNoBF
   | BitwiseORExprNoBF '|' BitwiseXORExpr
 ;
 
 BitwiseORExprNoBF:
     BitwiseXORExprNoBF
   | BitwiseORExprNoBF '|' BitwiseXORExpr
-                                        { $$ = new BitOperNode($1, OpBitOr, $3); }
+                                        { $$ = new BitOrNode($1, $3); }
 ;
 
 LogicalANDExpr:
     BitwiseORExpr
 ;
 
 LogicalANDExpr:
     BitwiseORExpr
-  | LogicalANDExpr AND BitwiseORExpr    { $$ = new BinaryLogicalNode($1, OpAnd, $3); }
+  | LogicalANDExpr AND BitwiseORExpr    { $$ = new LogicalAndNode($1, $3); }
 ;
 
 LogicalANDExprNoIn:
     BitwiseORExprNoIn
   | LogicalANDExprNoIn AND BitwiseORExprNoIn
 ;
 
 LogicalANDExprNoIn:
     BitwiseORExprNoIn
   | LogicalANDExprNoIn AND BitwiseORExprNoIn
-                                        { $$ = new BinaryLogicalNode($1, OpAnd, $3); }
+                                        { $$ = new LogicalAndNode($1, $3); }
 ;
 
 LogicalANDExprNoBF:
     BitwiseORExprNoBF
   | LogicalANDExprNoBF AND BitwiseORExpr
 ;
 
 LogicalANDExprNoBF:
     BitwiseORExprNoBF
   | LogicalANDExprNoBF AND BitwiseORExpr
-                                        { $$ = new BinaryLogicalNode($1, OpAnd, $3); }
+                                        { $$ = new LogicalAndNode($1, $3); }
 ;
 
 LogicalORExpr:
     LogicalANDExpr
 ;
 
 LogicalORExpr:
     LogicalANDExpr
-  | LogicalORExpr OR LogicalANDExpr     { $$ = new BinaryLogicalNode($1, OpOr, $3); }
+  | LogicalORExpr OR LogicalANDExpr     { $$ = new LogicalOrNode($1, $3); }
 ;
 
 LogicalORExprNoIn:
     LogicalANDExprNoIn
   | LogicalORExprNoIn OR LogicalANDExprNoIn
 ;
 
 LogicalORExprNoIn:
     LogicalANDExprNoIn
   | LogicalORExprNoIn OR LogicalANDExprNoIn
-                                        { $$ = new BinaryLogicalNode($1, OpOr, $3); }
+                                        { $$ = new LogicalOrNode($1, $3); }
 ;
 
 LogicalORExprNoBF:
     LogicalANDExprNoBF
 ;
 
 LogicalORExprNoBF:
     LogicalANDExprNoBF
-  | LogicalORExprNoBF OR LogicalANDExpr { $$ = new BinaryLogicalNode($1, OpOr, $3); }
+  | LogicalORExprNoBF OR LogicalANDExpr { $$ = new LogicalOrNode($1, $3); }
 ;
 
 ConditionalExpr:
 ;
 
 ConditionalExpr:
index a840d9a29d943d0a368f8ef1777b7080ef7a0137..5847900ddfb71918718de633f816e51de37923da 100644 (file)
@@ -1183,10 +1183,48 @@ JSValue *LogicalNotNode::evaluate(ExecState *exec)
   return jsBoolean(!v->toBoolean(exec));
 }
 
   return jsBoolean(!v->toBoolean(exec));
 }
 
-// ------------------------------ MultNode -------------------------------------
+// ------------------------------ Multiplicative Nodes -----------------------------------
 
 
-// ECMA 11.5
+// ECMA 11.5.1
 JSValue *MultNode::evaluate(ExecState *exec)
 JSValue *MultNode::evaluate(ExecState *exec)
+{
+    JSValue *v1 = term1->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    JSValue *v2 = term2->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    return mult(exec, v1, v2, '*');
+}
+
+// ECMA 11.5.2
+JSValue *DivNode::evaluate(ExecState *exec)
+{
+    JSValue *v1 = term1->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    JSValue *v2 = term2->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    return mult(exec, v1, v2, '/');
+}
+
+// ECMA 11.5.3
+JSValue *ModNode::evaluate(ExecState *exec)
+{
+    JSValue *v1 = term1->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    JSValue *v2 = term2->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    return mult(exec, v1, v2, '%');
+}
+
+// ------------------------------ Additive Nodes --------------------------------------
+
+// ECMA 11.6.1
+JSValue *AddNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = term1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 {
   JSValue *v1 = term1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
@@ -1194,27 +1232,52 @@ JSValue *MultNode::evaluate(ExecState *exec)
   JSValue *v2 = term2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
   JSValue *v2 = term2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
-  return mult(exec, v1, v2, oper);
+  return add(exec, v1, v2, '+');
 }
 
 }
 
-// ------------------------------ AddNode --------------------------------------
 
 
-// ECMA 11.6
-JSValue *AddNode::evaluate(ExecState *exec)
+// ECMA 11.6.2
+JSValue *SubNode::evaluate(ExecState *exec)
+{
+    JSValue *v1 = term1->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    JSValue *v2 = term2->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+        
+    return add(exec, v1, v2, '-');
+}
+
+// ------------------------------ Shift Nodes ------------------------------------
+
+// ECMA 11.7.1
+JSValue *LeftShiftNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = term1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 {
   JSValue *v1 = term1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
-
   JSValue *v2 = term2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   JSValue *v2 = term2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
+  unsigned int i2 = v2->toUInt32(exec);
+  i2 &= 0x1f;
 
 
-  return add(exec, v1, v2, oper);
+  return jsNumber(v1->toInt32(exec) << i2);
 }
 
 }
 
-// ------------------------------ ShiftNode ------------------------------------
+// ECMA 11.7.2
+JSValue *RightShiftNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = term1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = term2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  unsigned int i2 = v2->toUInt32(exec);
+  i2 &= 0x1f;
+
+  return jsNumber(v1->toInt32(exec) >> i2);
+}
 
 
-// ECMA 11.7
-JSValue *ShiftNode::evaluate(ExecState *exec)
+// ECMA 11.7.3
+JSValue *UnsignedRightShiftNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = term1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 {
   JSValue *v1 = term1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
@@ -1223,70 +1286,104 @@ JSValue *ShiftNode::evaluate(ExecState *exec)
   unsigned int i2 = v2->toUInt32(exec);
   i2 &= 0x1f;
 
   unsigned int i2 = v2->toUInt32(exec);
   i2 &= 0x1f;
 
-  switch (oper) {
-  case OpLShift:
-    return jsNumber(v1->toInt32(exec) << i2);
-  case OpRShift:
-    return jsNumber(v1->toInt32(exec) >> i2);
-  case OpURShift:
-    return jsNumber(v1->toUInt32(exec) >> i2);
-  default:
-    ASSERT(!"ShiftNode: unhandled switch case");
-    return jsUndefined();
-  }
+  return jsNumber(v1->toUInt32(exec) >> i2);
 }
 
 }
 
-// ------------------------------ RelationalNode -------------------------------
+// ------------------------------ Relational Nodes -------------------------------
 
 
-// ECMA 11.8
-JSValue *RelationalNode::evaluate(ExecState *exec)
+// ECMA 11.8.1
+JSValue *LessNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = expr1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   JSValue *v2 = expr2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 {
   JSValue *v1 = expr1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   JSValue *v2 = expr2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
+  int r = relation(exec, v1, v2);
+  if (r < 0)
+      return jsBoolean(false);
+  return jsBoolean(r == 1);
+}
 
 
-  bool b;
-  if (oper == OpLess || oper == OpGreaterEq) {
-    int r = relation(exec, v1, v2);
-    if (r < 0)
-      b = false;
-    else
-      b = (oper == OpLess) ? (r == 1) : (r == 0);
-  } else if (oper == OpGreater || oper == OpLessEq) {
-    int r = relation(exec, v2, v1);
-    if (r < 0)
-      b = false;
-    else
-      b = (oper == OpGreater) ? (r == 1) : (r == 0);
-  } else if (oper == OpIn) {
-      // Is all of this OK for host objects?
-      if (!v2->isObject())
-          return throwError(exec,  TypeError,
-                             "Value %s (result of expression %s) is not an object. Cannot be used with IN expression.", v2, expr2.get());
-      JSObject *o2(static_cast<JSObject*>(v2));
-      b = o2->hasProperty(exec, Identifier(v1->toString(exec)));
-  } else {
-    if (!v2->isObject())
-        return throwError(exec,  TypeError,
-                           "Value %s (result of expression %s) is not an object. Cannot be used with instanceof operator.", v2, expr2.get());
+// ECMA 11.8.2
+JSValue *GreaterNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  int r = relation(exec, v2, v1);
+  if (r < 0)
+      return jsBoolean(false);
+  return jsBoolean(r == 1);
+}
+
+// ECMA 11.8.3
+JSValue *LessEqNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  int r = relation(exec, v2, v1);
+  if (r < 0)
+      return jsBoolean(false);
+  return jsBoolean(r == 0);
+}
 
 
-    JSObject *o2(static_cast<JSObject*>(v2));
-    if (!o2->implementsHasInstance())
+// ECMA 11.8.4
+JSValue *GreaterEqNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  int r = relation(exec, v1, v2);
+  if (r < 0)
+      return jsBoolean(false);
+  return jsBoolean(r == 0);
+}
+
+// ECMA 11.8.6
+JSValue *InstanceOfNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  if (!v2->isObject())
+      return throwError(exec,  TypeError,
+                          "Value %s (result of expression %s) is not an object. Cannot be used with instanceof operator.", v2, expr2.get());
+
+  JSObject *o2(static_cast<JSObject*>(v2));
+  if (!o2->implementsHasInstance())
       // According to the spec, only some types of objects "implement" the [[HasInstance]] property.
       // But we are supposed to throw an exception where the object does not "have" the [[HasInstance]]
       // property. It seems that all object have the property, but not all implement it, so in this
       // case we return false (consistent with mozilla)
       return jsBoolean(false);
       // According to the spec, only some types of objects "implement" the [[HasInstance]] property.
       // But we are supposed to throw an exception where the object does not "have" the [[HasInstance]]
       // property. It seems that all object have the property, but not all implement it, so in this
       // case we return false (consistent with mozilla)
       return jsBoolean(false);
-    return jsBoolean(o2->hasInstance(exec, v1));
-  }
+  return jsBoolean(o2->hasInstance(exec, v1));
+}
+
+// ECMA 11.8.7
+JSValue *InNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
 
 
-  return jsBoolean(b);
+  // Is all of this OK for host objects?
+  if (!v2->isObject())
+      return throwError(exec,  TypeError,
+                         "Value %s (result of expression %s) is not an object. Cannot be used with IN expression.", v2, expr2.get());
+  JSObject *o2(static_cast<JSObject*>(v2));
+  return jsBoolean(o2->hasProperty(exec, Identifier(v1->toString(exec))));
 }
 
 }
 
-// ------------------------------ EqualNode ------------------------------------
+// ------------------------------ Equality Nodes ------------------------------------
 
 
-// ECMA 11.9
+// ECMA 11.9.1
 JSValue *EqualNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = expr1->evaluate(exec);
 JSValue *EqualNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = expr1->evaluate(exec);
@@ -1294,50 +1391,98 @@ JSValue *EqualNode::evaluate(ExecState *exec)
   JSValue *v2 = expr2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
   JSValue *v2 = expr2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
-  bool result;
-  if (oper == OpEqEq || oper == OpNotEq) {
-    // == and !=
-    bool eq = equal(exec,v1, v2);
-    result = oper == OpEqEq ? eq : !eq;
-  } else {
-    // === and !==
-    bool eq = strictEqual(exec,v1, v2);
-    result = oper == OpStrEq ? eq : !eq;
-  }
-  return jsBoolean(result);
+  return jsBoolean(equal(exec,v1, v2));
+}
+
+// ECMA 11.9.2
+JSValue *NotEqualNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  return jsBoolean(!equal(exec,v1, v2));
+}
+
+// ECMA 11.9.4
+JSValue *StrictEqualNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  return jsBoolean(strictEqual(exec,v1, v2));
 }
 
 }
 
-// ------------------------------ BitOperNode ----------------------------------
+// ECMA 11.9.5
+JSValue *NotStrictEqualNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  return jsBoolean(!strictEqual(exec,v1, v2));
+}
+
+// ------------------------------ Bit Operation Nodes ----------------------------------
 
 // ECMA 11.10
 
 // ECMA 11.10
-JSValue *BitOperNode::evaluate(ExecState *exec)
+JSValue *BitAndNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = expr1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   JSValue *v2 = expr2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 {
   JSValue *v1 = expr1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   JSValue *v2 = expr2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
-  int i1 = v1->toInt32(exec);
-  int i2 = v2->toInt32(exec);
-  int result;
-  if (oper == OpBitAnd)
-    result = i1 & i2;
-  else if (oper == OpBitXOr)
-    result = i1 ^ i2;
-  else
-    result = i1 | i2;
+  
+  return jsNumber(v1->toInt32(exec) & v2->toInt32(exec));
+}
 
 
-  return jsNumber(result);
+JSValue *BitXOrNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  
+  return jsNumber(v1->toInt32(exec) ^ v2->toInt32(exec));
 }
 
 }
 
-// ------------------------------ BinaryLogicalNode ----------------------------
+JSValue *BitOrNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  
+  return jsNumber(v1->toInt32(exec) | v2->toInt32(exec));
+}
+
+// ------------------------------ Binary Logical Nodes ----------------------------
 
 // ECMA 11.11
 
 // ECMA 11.11
-JSValue *BinaryLogicalNode::evaluate(ExecState *exec)
+JSValue *LogicalAndNode::evaluate(ExecState *exec)
+{
+  JSValue *v1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  bool b1 = v1->toBoolean(exec);
+  if (!b1)
+    return v1;
+
+  JSValue *v2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  return v2;
+}
+
+JSValue *LogicalOrNode::evaluate(ExecState *exec)
 {
   JSValue *v1 = expr1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   bool b1 = v1->toBoolean(exec);
 {
   JSValue *v1 = expr1->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   bool b1 = v1->toBoolean(exec);
-  if ((!b1 && oper == OpAnd) || (b1 && oper == OpOr))
+  if (b1)
     return v1;
 
   JSValue *v2 = expr2->evaluate(exec);
     return v1;
 
   JSValue *v2 = expr2->evaluate(exec);
index d0f0dc1e6f4fe25e0d14198d6160502f8038beca..ad3fa45436ad3a508344250d4abdfd1c96eaef55 100644 (file)
@@ -646,90 +646,256 @@ namespace KJS {
   private:
     RefPtr<Node> expr;
   };
   private:
     RefPtr<Node> expr;
   };
-
+  
   class MultNode : public Node {
   public:
   class MultNode : public Node {
   public:
-    MultNode(Node *t1, Node *t2, char op) KJS_FAST_CALL : term1(t1), term2(t2), oper(op) {}
+      MultNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
+      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+      RefPtr<Node> term1;
+      RefPtr<Node> term2;
+  };
+  
+  class DivNode : public Node {
+  public:
+      DivNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
+      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+      RefPtr<Node> term1;
+      RefPtr<Node> term2;
+  };
+  
+  class ModNode : public Node {
+  public:
+      ModNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
+      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+      RefPtr<Node> term1;
+      RefPtr<Node> term2;
+  };
+
+  class AddNode : public Node {
+  public:
+    AddNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> term1;
     RefPtr<Node> term2;
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> term1;
     RefPtr<Node> term2;
-    char oper;
+  };
+  
+  class SubNode : public Node {
+  public:
+      SubNode(Node *t1, Node *t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
+      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+      RefPtr<Node> term1;
+      RefPtr<Node> term2;
   };
 
   };
 
-  class AddNode : public Node {
+  class LeftShiftNode : public Node {
+  public:
+    LeftShiftNode(Node *t1, Node *t2) KJS_FAST_CALL
+      : term1(t1), term2(t2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> term1;
+    RefPtr<Node> term2;
+  };
+
+  class RightShiftNode : public Node {
   public:
   public:
-    AddNode(Node *t1, Node *t2, char op) KJS_FAST_CALL : term1(t1), term2(t2), oper(op) {}
+    RightShiftNode(Node *t1, Node *t2) KJS_FAST_CALL
+      : term1(t1), term2(t2) {}
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> term1;
     RefPtr<Node> term2;
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> term1;
     RefPtr<Node> term2;
-    char oper;
   };
 
   };
 
-  class ShiftNode : public Node {
+  class UnsignedRightShiftNode : public Node {
   public:
   public:
-    ShiftNode(Node *t1, Operator o, Node *t2) KJS_FAST_CALL
-      : term1(t1), term2(t2), oper(o) {}
+    UnsignedRightShiftNode(Node *t1, Node *t2) KJS_FAST_CALL
+      : term1(t1), term2(t2) {}
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> term1;
     RefPtr<Node> term2;
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> term1;
     RefPtr<Node> term2;
-    Operator oper;
   };
 
   };
 
-  class RelationalNode : public Node {
+  class LessNode : public Node {
+  public:
+    LessNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class GreaterNode : public Node {
+  public:
+    GreaterNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class LessEqNode : public Node {
+  public:
+    LessEqNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class GreaterEqNode : public Node {
+  public:
+    GreaterEqNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class InstanceOfNode : public Node {
+  public:
+    InstanceOfNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class InNode : public Node {
   public:
   public:
-    RelationalNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL :
-      expr1(e1), expr2(e2), oper(o) {}
+    InNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
-    Operator oper;
   };
 
   class EqualNode : public Node {
   public:
   };
 
   class EqualNode : public Node {
   public:
-    EqualNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL
-      : expr1(e1), expr2(e2), oper(o) {}
+    EqualNode(Node *e1, Node *e2) KJS_FAST_CALL
+      : expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class NotEqualNode : public Node {
+  public:
+    NotEqualNode(Node *e1, Node *e2) KJS_FAST_CALL
+      : expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class StrictEqualNode : public Node {
+  public:
+    StrictEqualNode(Node *e1, Node *e2) KJS_FAST_CALL
+      : expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class NotStrictEqualNode : public Node {
+  public:
+    NotStrictEqualNode(Node *e1, Node *e2) KJS_FAST_CALL
+      : expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class BitAndNode : public Node {
+  public:
+    BitAndNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
-    Operator oper;
   };
 
   };
 
-  class BitOperNode : public Node {
+  class BitOrNode : public Node {
   public:
   public:
-    BitOperNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL :
-      expr1(e1), expr2(e2), oper(o) {}
+    BitOrNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+
+  class BitXOrNode : public Node {
+  public:
+    BitXOrNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
-    Operator oper;
   };
 
   /**
    * expr1 && expr2, expr1 || expr2
    */
   };
 
   /**
    * expr1 && expr2, expr1 || expr2
    */
-  class BinaryLogicalNode : public Node {
+  class LogicalAndNode : public Node {
+  public:
+    LogicalAndNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
+    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+  private:
+    RefPtr<Node> expr1;
+    RefPtr<Node> expr2;
+  };
+  
+  class LogicalOrNode : public Node {
   public:
   public:
-    BinaryLogicalNode(Node *e1, Operator o, Node *e2) KJS_FAST_CALL :
-      expr1(e1), expr2(e2), oper(o) {}
+    LogicalOrNode(Node *e1, Node *e2) KJS_FAST_CALL :
+      expr1(e1), expr2(e2) {}
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
     RefPtr<Node> expr1;
     RefPtr<Node> expr2;
-    Operator oper;
   };
 
   /**
   };
 
   /**
index aec5836f8b8de0481731cfdfabcec75b8af3a382..5465e458cecedeeaabe5d7d6d0e6657ce03b415f 100644 (file)
@@ -414,91 +414,117 @@ void LogicalNotNode::streamTo(SourceStream &s) const
 
 void MultNode::streamTo(SourceStream &s) const
 {
 
 void MultNode::streamTo(SourceStream &s) const
 {
-  s << term1 << " " << oper << " " << term2;
+    s << term1 << " * " << term2;
+}
+
+void DivNode::streamTo(SourceStream &s) const
+{
+    s << term1 << " / " << term2;
+}
+
+void ModNode::streamTo(SourceStream &s) const
+{
+    s << term1 << " % " << term2;
 }
 
 void AddNode::streamTo(SourceStream &s) const
 {
 }
 
 void AddNode::streamTo(SourceStream &s) const
 {
-  s << term1 << " " << oper << " " << term2;
+    s << term1 << " + " << term2;
 }
 
 }
 
-void ShiftNode::streamTo(SourceStream &s) const
+void SubNode::streamTo(SourceStream &s) const
 {
 {
-  s << term1;
-  if (oper == OpLShift)
-    s << "<<";
-  else if (oper == OpRShift)
-    s << ">>";
-  else
-    s << ">>>";
-  s << term2;
+    s << term1 << " - " << term2;
 }
 
 }
 
-void RelationalNode::streamTo(SourceStream &s) const
+void LeftShiftNode::streamTo(SourceStream &s) const
 {
 {
-  s << expr1;
-  switch (oper) {
-  case OpLess:
-    s << " < ";
-    break;
-  case OpGreater:
-    s << " > ";
-    break;
-  case OpLessEq:
-    s << " <= ";
-    break;
-  case OpGreaterEq:
-    s << " >= ";
-    break;
-  case OpInstanceOf:
-    s << " instanceof ";
-    break;
-  case OpIn:
-    s << " in ";
-    break;
-  default:
-    ;
-  }
-  s << expr2;
+  s << term1 << "<<" << term2;
+}
+
+void RightShiftNode::streamTo(SourceStream &s) const
+{
+  s << term1 << ">>" << term2;
+}
+
+void UnsignedRightShiftNode::streamTo(SourceStream &s) const
+{
+  s << term1 << ">>>" << term2;
+}
+
+void LessNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " < " << expr2;
+}
+
+void GreaterNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " > " << expr2;
+}
+
+void LessEqNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " <= " << expr2;
+}
+
+void GreaterEqNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " >= " << expr2;
+}
+
+void InstanceOfNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " instanceof " << expr2;
+}
+
+void InNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " in " << expr2;
 }
 
 void EqualNode::streamTo(SourceStream &s) const
 {
 }
 
 void EqualNode::streamTo(SourceStream &s) const
 {
-  s << expr1;
- switch (oper) {
- case OpEqEq:
-   s << " == ";
-   break;
- case OpNotEq:
-   s << " != ";
-   break;
- case OpStrEq:
-   s << " === ";
-   break;
- case OpStrNEq:
-   s << " !== ";
-   break;
- default:
-   ;
- }
-  s << expr2;
-}
-
-void BitOperNode::streamTo(SourceStream &s) const
-{
-  s << expr1;
-  if (oper == OpBitAnd)
-    s << " & ";
-  else if (oper == OpBitXOr)
-    s << " ^ ";
-  else
-    s << " | ";
-  s << expr2;
+  s << expr1 << " == " << expr2;
+}
+
+void NotEqualNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " == " << expr2;
+}
+
+void StrictEqualNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " === " << expr2;
+}
+
+void NotStrictEqualNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " !== " << expr2;
+}
+
+void BitAndNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " & " << expr2;
+}
+
+void BitXOrNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " ^ " << expr2;
+}
+
+void BitOrNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " | " << expr2;
+}
+
+void LogicalAndNode::streamTo(SourceStream &s) const
+{
+  s << expr1 << " && " << expr2;
 }
 
 }
 
-void BinaryLogicalNode::streamTo(SourceStream &s) const
+void LogicalOrNode::streamTo(SourceStream &s) const
 {
 {
-  s << expr1 << (oper == OpAnd ? " && " : " || ") << expr2;
+  s << expr1 << " || " << expr2;
 }
 
 void ConditionalNode::streamTo(SourceStream &s) const
 }
 
 void ConditionalNode::streamTo(SourceStream &s) const