generate assignment with appropriate operator use implicit namespace

2006-07-04  Jürg Billeter  <j@bitron.ch>

	* vala/valacodegenerator.vala: generate assignment with appropriate
	  operator
	* vala/valaassignment.vala: use implicit namespace specification
	* ccode/valaccodeassignment.vala: support assignment operators , add
	  interface documentation, use implicit namespace specification
	* tests/test-010.vala: test assignments

svn path=/trunk/; revision=61

diff --git a/vala/ChangeLog b/vala/ChangeLog
index 2810b04390068b1f38fb4b88c1f3a8c0f64a6fb6..8fde26a25ecb640c54552ae012d4726b1d8aadff 100644 (file)
--- a/vala/ChangeLog
+++ b/vala/ChangeLog
@@ -1,3 +1,12 @@
+2006-07-04  Jürg Billeter  <j@bitron.ch>
+
+       * vala/valacodegenerator.vala: generate assignment with appropriate
+         operator
+       * vala/valaassignment.vala: use implicit namespace specification
+       * ccode/valaccodeassignment.vala: support assignment operators , add
+         interface documentation, use implicit namespace specification
+       * tests/test-010.vala: test assignments
+
 2006-07-03  Jürg Billeter  <j@bitron.ch>
 
        * vala/parser.y: support implicit namespace specification in struct,

diff --git a/vala/ccode/valaccodeassignment.vala b/vala/ccode/valaccodeassignment.vala
index 7a2ba20d561a9bb92ee710523541162f48b3c97b..702c3cd2041a5e6894c6ac68d09a8da3515f7f19 100644 (file)
--- a/vala/ccode/valaccodeassignment.vala
+++ b/vala/ccode/valaccodeassignment.vala
@@ -22,19 +22,70 @@
 
 using GLib;
 
-namespace Vala {
-       public class CCodeAssignment : CCodeExpression {
-               public CCodeExpression left { get; construct; }
-               public CCodeExpression right { get; construct; }
+/**
+ * Represents an assignment expression in the C code.
+ */
+public class Vala.CCodeAssignment : CCodeExpression {
+       /**
+        * Left hand side of the assignment.
+        */
+       public CCodeExpression left { get; construct; }
+       
+       /**
+        * Assignment operator.
+        */
+       public CCodeAssignmentOperator operator { get; set; }
+
+       /**
+        * Right hand side of the assignment.
+        */
+       public CCodeExpression right { get; construct; }
+       
+       public override void write (CCodeWriter writer) {
+               if (left != null) {
+                       left.write (writer);
+               }
+               writer.write_string (" ");
                
-               public override void write (CCodeWriter writer) {
-                       if (left != null) {
-                               left.write (writer);
-                       }
-                       writer.write_string (" = ");
-                       if (right != null) {
-                               right.write (writer);
-                       }
+               if (operator == CCodeAssignmentOperator.BITWISE_OR) {
+                       writer.write_string ("|");
+               } else if (operator == CCodeAssignmentOperator.BITWISE_AND) {
+                       writer.write_string ("&");
+               } else if (operator == CCodeAssignmentOperator.BITWISE_XOR) {
+                       writer.write_string ("^");
+               } else if (operator == CCodeAssignmentOperator.ADD) {
+                       writer.write_string ("+");
+               } else if (operator == CCodeAssignmentOperator.SUB) {
+                       writer.write_string ("-");
+               } else if (operator == CCodeAssignmentOperator.MUL) {
+                       writer.write_string ("*");
+               } else if (operator == CCodeAssignmentOperator.DIV) {
+                       writer.write_string ("/");
+               } else if (operator == CCodeAssignmentOperator.PERCENT) {
+                       writer.write_string ("%");
+               } else if (operator == CCodeAssignmentOperator.SHIFT_LEFT) {
+                       writer.write_string ("<<");
+               } else if (operator == CCodeAssignmentOperator.SHIFT_RIGHT) {
+                       writer.write_string (">>");
+               }
+               
+               writer.write_string ("= ");
+               if (right != null) {
+                       right.write (writer);
                }
        }
 }
+       
+public enum Vala.CCodeAssignmentOperator {
+       SIMPLE,
+       BITWISE_OR,
+       BITWISE_AND,
+       BITWISE_XOR,
+       ADD,
+       SUB,
+       MUL,
+       DIV,
+       PERCENT,
+       SHIFT_LEFT,
+       SHIFT_RIGHT
+}

diff --git a/vala/tests/test-010.vala b/vala/tests/test-010.vala
new file mode 100644 (file)
index 0000000..e3b1eb6
--- /dev/null
+++ b/vala/tests/test-010.vala
@@ -0,0 +1,52 @@
+using GLib;
+
+class Maman.Bar {
+       static int main (int argc, string[] argv) {
+               stdout.printf ("Assignment Test: 1");
+               
+               int i;
+               
+               i = 2;
+               stdout.printf (" %d", i);
+               
+               i |= 1;
+               stdout.printf (" %d", i);
+               
+               i = 5;
+               i &= 6;
+               stdout.printf (" %d", i);
+               
+               i ^= 1;
+               stdout.printf (" %d", i);
+               
+               i += 1;
+               stdout.printf (" %d", i);
+               
+               i -= -1;
+               stdout.printf (" %d", i);
+               
+               i = 2;
+               i *= 4;
+               stdout.printf (" %d", i);
+               
+               i = 18;
+               i /= 2;
+               stdout.printf (" %d", i);
+               
+               i = 21;
+               i %= 11;
+               stdout.printf (" %d", i);
+               
+               i = 6;
+               i <<= 1;
+               stdout.printf (" %d", i - 1);
+               
+               i = 25;
+               i >>= 1;
+               stdout.printf (" %d", i);
+               
+               stdout.printf (" 13\n");
+               
+               return 0;
+       }
+}

diff --git a/vala/vala/valaassignment.vala b/vala/vala/valaassignment.vala
index b09f38d57df43fb4a9acd08e9e1ad847f430294e..4bb58f6dd860d38ef4f32f9460f6e0d801aaa94c 100644 (file)
--- a/vala/vala/valaassignment.vala
+++ b/vala/vala/valaassignment.vala
@@ -34,7 +34,7 @@ public class Vala.Assignment : Expression {
        /**
         * Assignment operator.
         */
-       public AssignmentOperator operator { get; set construct; }
+       public AssignmentOperator operator { get; set; }
        
        /**
         * Right hand side of the assignment.
@@ -61,18 +61,16 @@ public class Vala.Assignment : Expression {
        }
 }
        
-namespace Vala {
-       public enum AssignmentOperator {
-               SIMPLE,
-               BITWISE_OR,
-               BITWISE_AND,
-               BITWISE_XOR,
-               ADD,
-               SUB,
-               MUL,
-               DIV,
-               PERCENT,
-               SHIFT_LEFT,
-               SHIFT_RIGHT
-       }
+public enum Vala.AssignmentOperator {
+       SIMPLE,
+       BITWISE_OR,
+       BITWISE_AND,
+       BITWISE_XOR,
+       ADD,
+       SUB,
+       MUL,
+       DIV,
+       PERCENT,
+       SHIFT_LEFT,
+       SHIFT_RIGHT
 }

diff --git a/vala/vala/valacodegenerator.vala b/vala/vala/valacodegenerator.vala
index 275fb3aa77e311f7d227df7647711be0313575b0..426b22297f5afbf3484b8327d48fd83e262d7551 100644 (file)
--- a/vala/vala/valacodegenerator.vala
+++ b/vala/vala/valacodegenerator.vala
@@ -1911,7 +1911,30 @@ namespace Vala {
                                        rhs = ccomma;
                                }
                                
-                               a.ccodenode = new CCodeAssignment (left = (CCodeExpression) a.left.ccodenode, right = rhs);
+                               var cop = CCodeAssignmentOperator.SIMPLE;
+                               if (a.operator == AssignmentOperator.BITWISE_OR) {
+                                       cop = CCodeAssignmentOperator.BITWISE_OR;
+                               } else if (a.operator == AssignmentOperator.BITWISE_AND) {
+                                       cop = CCodeAssignmentOperator.BITWISE_AND;
+                               } else if (a.operator == AssignmentOperator.BITWISE_XOR) {
+                                       cop = CCodeAssignmentOperator.BITWISE_XOR;
+                               } else if (a.operator == AssignmentOperator.ADD) {
+                                       cop = CCodeAssignmentOperator.ADD;
+                               } else if (a.operator == AssignmentOperator.SUB) {
+                                       cop = CCodeAssignmentOperator.SUB;
+                               } else if (a.operator == AssignmentOperator.MUL) {
+                                       cop = CCodeAssignmentOperator.MUL;
+                               } else if (a.operator == AssignmentOperator.DIV) {
+                                       cop = CCodeAssignmentOperator.DIV;
+                               } else if (a.operator == AssignmentOperator.PERCENT) {
+                                       cop = CCodeAssignmentOperator.PERCENT;
+                               } else if (a.operator == AssignmentOperator.SHIFT_LEFT) {
+                                       cop = CCodeAssignmentOperator.SHIFT_LEFT;
+                               } else if (a.operator == AssignmentOperator.SHIFT_RIGHT) {
+                                       cop = CCodeAssignmentOperator.SHIFT_RIGHT;
+                               }
+                       
+                               a.ccodenode = new CCodeAssignment (left = (CCodeExpression) a.left.ccodenode, right = rhs, operator = cop);
                        }
                }
        }