adapt to BinaryOperator enum changes add operators to unary and binary

2006-05-18  Jürg Billeter  <j@bitron.ch>

	* vala/parser.y: adapt to BinaryOperator enum changes
	* vala/valacodegenerator.vala: add operators to unary and binary
	  expressions
	* vala/valabinaryexpression.vala: correct enum value names
	* ccode/valaccodebinaryexpression.vala: add operator
	* ccode/valaccodeunaryexpression.vala

svn path=/trunk/; revision=25

diff --git a/vala/ChangeLog b/vala/ChangeLog
index 0d357ba666184509a3f3602393934609a160a2d6..c7099112badc4e75d6fcf1b56ab1602e21dc15c9 100644 (file)
--- a/vala/ChangeLog
+++ b/vala/ChangeLog
@@ -1,3 +1,12 @@
+2006-05-18  Jürg Billeter  <j@bitron.ch>
+
+       * vala/parser.y: adapt to BinaryOperator enum changes
+       * vala/valacodegenerator.vala: add operators to unary and binary
+         expressions
+       * vala/valabinaryexpression.vala: correct enum value names
+       * ccode/valaccodebinaryexpression.vala: add operator
+       * ccode/valaccodeunaryexpression.vala
+
 2006-05-18  Jürg Billeter  <j@bitron.ch>
 
        * vala/parser.y: support namespace attributes

diff --git a/vala/ccode/valaccodebinaryexpression.vala b/vala/ccode/valaccodebinaryexpression.vala
index 0667e8508b5c114dfa24129ed37793d349737f54..a733abfe9a05fb868d6a20f9a5a293438e461234 100644 (file)
--- a/vala/ccode/valaccodebinaryexpression.vala
+++ b/vala/ccode/valaccodebinaryexpression.vala
@@ -24,6 +24,7 @@ using GLib;
 
 namespace Vala {
        public class CCodeBinaryExpression : CCodeExpression {
+               public CCodeBinaryOperator operator { get; construct; }
                public CCodeExpression left { get; construct; }
                public CCodeExpression right { get; construct; }
                
@@ -31,9 +32,69 @@ namespace Vala {
                        if (left != null) {
                                left.write (writer);
                        }
+                       writer.write_string (" ");
+                       if (operator == CCodeBinaryOperator.PLUS) {
+                               writer.write_string ("+");
+                       } else if (operator == CCodeBinaryOperator.MINUS) {
+                               writer.write_string ("-");
+                       } else if (operator == CCodeBinaryOperator.MUL) {
+                               writer.write_string ("*");
+                       } else if (operator == CCodeBinaryOperator.DIV) {
+                               writer.write_string ("/");
+                       } else if (operator == CCodeBinaryOperator.MOD) {
+                               writer.write_string ("%");
+                       } else if (operator == CCodeBinaryOperator.SHIFT_LEFT) {
+                               writer.write_string ("<<");
+                       } else if (operator == CCodeBinaryOperator.SHIFT_RIGHT) {
+                               writer.write_string (">>");
+                       } else if (operator == CCodeBinaryOperator.LESS_THAN) {
+                               writer.write_string ("<");
+                       } else if (operator == CCodeBinaryOperator.GREATER_THAN) {
+                               writer.write_string (">");
+                       } else if (operator == CCodeBinaryOperator.LESS_THAN_OR_EQUAL) {
+                               writer.write_string ("<=");
+                       } else if (operator == CCodeBinaryOperator.GREATER_THAN_OR_EQUAL) {
+                               writer.write_string (">=");
+                       } else if (operator == CCodeBinaryOperator.EQUALITY) {
+                               writer.write_string ("==");
+                       } else if (operator == CCodeBinaryOperator.INEQUALITY) {
+                               writer.write_string ("!=");
+                       } else if (operator == CCodeBinaryOperator.BITWISE_AND) {
+                               writer.write_string ("&");
+                       } else if (operator == CCodeBinaryOperator.BITWISE_OR) {
+                               writer.write_string ("|");
+                       } else if (operator == CCodeBinaryOperator.BITWISE_XOR) {
+                               writer.write_string ("^");
+                       } else if (operator == CCodeBinaryOperator.AND) {
+                               writer.write_string ("&&");
+                       } else if (operator == CCodeBinaryOperator.OR) {
+                               writer.write_string ("||");
+                       }
+                       writer.write_string (" ");
                        if (right != null) {
                                right.write (writer);
                        }
                }
        }
+       
+       public enum CCodeBinaryOperator {
+               PLUS,
+               MINUS,
+               MUL,
+               DIV,
+               MOD,
+               SHIFT_LEFT,
+               SHIFT_RIGHT,
+               LESS_THAN,
+               GREATER_THAN,
+               LESS_THAN_OR_EQUAL,
+               GREATER_THAN_OR_EQUAL,
+               EQUALITY,
+               INEQUALITY,
+               BITWISE_AND,
+               BITWISE_OR,
+               BITWISE_XOR,
+               AND,
+               OR
+       }
 }

diff --git a/vala/ccode/valaccodeunaryexpression.vala b/vala/ccode/valaccodeunaryexpression.vala
new file mode 100644 (file)
index 0000000..df25949
--- /dev/null
+++ b/vala/ccode/valaccodeunaryexpression.vala
@@ -0,0 +1,54 @@
+/* valaccodeunaryexpression.vala
+ *
+ * Copyright (C) 2006  Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ *     Jürg Billeter <j@bitron.ch>
+ */
+
+using GLib;
+
+namespace Vala {
+       public class CCodeUnaryExpression : CCodeExpression {
+               public CCodeUnaryOperator operator { get; construct; }
+               public CCodeExpression inner { get; construct; }
+               
+               public override void write (CCodeWriter writer) {
+                       if (operator == CCodeUnaryOperator.PLUS) {
+                               writer.write_string ("+");
+                       } else if (operator == CCodeUnaryOperator.MINUS) {
+                               writer.write_string ("-");
+                       } else if (operator == CCodeUnaryOperator.LOGICAL_NEGATION) {
+                               writer.write_string ("!");
+                       } else if (operator == CCodeUnaryOperator.BITWISE_COMPLEMENT) {
+                               writer.write_string ("~");
+                       } else if (operator == CCodeUnaryOperator.ADDRESS_OF) {
+                               writer.write_string ("&");
+                       }
+
+                       inner.write (writer);
+               }
+       }
+       
+       public enum CCodeUnaryOperator {
+               PLUS,
+               MINUS,
+               LOGICAL_NEGATION,
+               BITWISE_COMPLEMENT,
+               ADDRESS_OF
+       }
+}

diff --git a/vala/vala/parser.y b/vala/vala/parser.y
index ed10b46147e623d99f0683deb125eda68679f5b9..8325bddea6768b37186742e685bb97a8c341e3f2 100644 (file)
--- a/vala/vala/parser.y
+++ b/vala/vala/parser.y
@@ -546,11 +546,11 @@ relational_expression
          }
        | relational_expression OP_LE shift_expression
          {
-               $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_LESS, $1, $3, src (@2)));
+               $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL, $1, $3, src (@2)));
          }
        | relational_expression OP_GE shift_expression
          {
-               $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_GREATER, $1, $3, src (@2)));
+               $$ = VALA_EXPRESSION (vala_binary_expression_new (VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL, $1, $3, src (@2)));
          }
        | relational_expression IS type
        ;

diff --git a/vala/vala/valabinaryexpression.vala b/vala/vala/valabinaryexpression.vala
index ff5821e840c74faf1b1a015c51e62b2d48e6cd90..8037d633e928faff949a2d23c414c1c0552df638 100644 (file)
--- a/vala/vala/valabinaryexpression.vala
+++ b/vala/vala/valabinaryexpression.vala
@@ -51,8 +51,8 @@ namespace Vala {
                SHIFT_RIGHT,
                LESS_THAN,
                GREATER_THAN,
-               LESS,
-               GREATER,
+               LESS_THAN_OR_EQUAL,
+               GREATER_THAN_OR_EQUAL,
                EQUALITY,
                INEQUALITY,
                BITWISE_AND,

diff --git a/vala/vala/valacodegenerator.vala b/vala/vala/valacodegenerator.vala
index 4b0e03c82077f168332eb21e791d921996acc2ea..1806b767d5504bd0c70c176ab7795c47953f7b51 100644 (file)
--- a/vala/vala/valacodegenerator.vala
+++ b/vala/vala/valacodegenerator.vala
@@ -293,7 +293,21 @@ namespace Vala {
                }
 
                public override void visit_unary_expression (UnaryExpression expr) {
-                       expr.ccodenode = expr.inner.ccodenode;
+                       CCodeUnaryOperator op;
+                       if (expr.operator == UnaryOperator.PLUS) {
+                               op = CCodeUnaryOperator.PLUS;
+                       } else if (expr.operator == UnaryOperator.MINUS) {
+                               op = CCodeUnaryOperator.MINUS;
+                       } else if (expr.operator == UnaryOperator.LOGICAL_NEGATION) {
+                               op = CCodeUnaryOperator.LOGICAL_NEGATION;
+                       } else if (expr.operator == UnaryOperator.BITWISE_COMPLEMENT) {
+                               op = CCodeUnaryOperator.BITWISE_COMPLEMENT;
+                       } else if (expr.operator == UnaryOperator.REF) {
+                               op = CCodeUnaryOperator.ADDRESS_OF;
+                       } else if (expr.operator == UnaryOperator.OUT) {
+                               op = CCodeUnaryOperator.ADDRESS_OF;
+                       }
+                       expr.ccodenode = new CCodeUnaryExpression (operator = op, inner = expr.inner.ccodenode);
                }
 
                public override void visit_cast_expression (CastExpression expr) {
@@ -301,7 +315,7 @@ namespace Vala {
                }
 
                public override void visit_binary_expression (BinaryExpression expr) {
-                       expr.ccodenode = new CCodeBinaryExpression (left = expr.left.ccodenode, right = expr.right.ccodenode);
+                       expr.ccodenode = new CCodeBinaryExpression (operator = expr.operator, left = expr.left.ccodenode, right = expr.right.ccodenode);
                }
 
                public override void visit_assignment (Assignment a) {