More binary operators

Sources/rxcc/rxcc.swift

@@ -187,6 +187,10 @@ struct rxcc {
         case EqualTo
         case NotEqualTo
 
+        case BitwiseAnd
+        case BitwiseXOR
+        case BitwiseOr
+
         case LogicalAnd
         case LogicalOr
 
@@ -201,6 +205,9 @@ struct rxcc {
         case BitwiseShiftExpressionSequence
         case RelationalExpressionSequence
         case EqualityExpressionSequence
+        case BitwiseAndExpressionSequence
+        case BitwiseXORExpressionSequence
+        case BitwiseOrExpressionSequence
         case LogicalAndExpressionSequence
         case LogicalOrExpressionSequence
         case VariableExpression
@@ -243,6 +250,9 @@ struct rxcc {
         case BitwiseShiftPriorityOperator
         case InequalityPriorityOperator
         case EqualityPriorityOperator
+        case BitwiseAndPriorityOperator
+        case BitwiseXORPriorityOperator
+        case BitwiseOrPriorityOperator
         case LogicalAndPriorityOperator
         case LogicalOrPriorityOperator
 
@@ -253,9 +263,12 @@ struct rxcc {
         case Expression
         case LogicalOrExpression
         case LogicalAndExpression
-        case BitwiseShiftExpression
+        case BitwiseOrExpression
+        case BitwiseXORExpression
+        case BitwiseAndExpression
         case EqualityExpression
         case RelationalExpression
+        case BitwiseShiftExpression
         case AdditiveExpression
         case Term
         case Factor
@@ -353,6 +366,24 @@ struct rxcc {
             ],
         ],
 
+        .BitwiseAndPriorityOperator: [
+            .BitwiseAnd: [
+                .Token(type: .BITWISE_AND),
+            ],
+        ],
+
+        .BitwiseXORPriorityOperator: [
+            .BitwiseXOR: [
+                .Token(type: .BITWISE_XOR),
+            ],
+        ],
+
+        .BitwiseOrPriorityOperator: [
+            .BitwiseOr: [
+                .Token(type: .BITWISE_OR),
+            ],
+        ],
+
         .LogicalAndPriorityOperator: [
             .LogicalAnd: [
                 .Token(type: .LOGICAL_AND),
@@ -383,12 +414,39 @@ struct rxcc {
         ],
 
         .LogicalAndExpression: [
-            .EqualityExpressionSequence: [
+            .BitwiseOrExpressionSequence: [
-                .Construct(type: .EqualityExpression),
+                .Construct(type: .BitwiseOrExpression),
                 .OperatorLoop(type: .LogicalAndPriorityOperator),
             ]
         ],
 
+//////////////////////////////////////////////////////
+
+
+        .BitwiseOrExpression: [
+            .BitwiseXORExpressionSequence: [
+                .Construct(type: .BitwiseXORExpression),
+                .OperatorLoop(type: .BitwiseOrPriorityOperator)
+            ]
+        ],
+
+        .BitwiseXORExpression: [
+            .BitwiseAndExpressionSequence: [
+                .Construct(type: .BitwiseAndExpression),
+                .OperatorLoop(type: .BitwiseXORPriorityOperator)
+            ]
+        ],
+
+        .BitwiseAndExpression: [
+            .EqualityExpressionSequence: [
+                .Construct(type: .EqualityExpression),
+                .OperatorLoop(type: .BitwiseAndPriorityOperator)
+            ]
+        ],
+
+
+//////////////////////////////////////////////////////
+
         .EqualityExpression: [
             .RelationalExpressionSequence: [
                 .Construct(type: .RelationalExpression),
@@ -737,7 +795,7 @@ struct rxcc {
             }
             break
 
-        case .EqualityExpressionSequence:
+        case .BitwiseOrExpressionSequence:
             var operation: ConstructVariant = .Error
             let count = node.children.count
             if count == 0 {
@@ -783,6 +841,114 @@ struct rxcc {
             }
             break
 
+        case .BitwiseXORExpressionSequence:
+            var operation: ConstructVariant = .Error
+            let count = node.children.count
+            if count == 0 {
+                print("ERROR: \(node.variant) with no children")
+                break
+            }
+            for i in 0...count - 1 {
+                let child: SyntaxTreeNode = node.children[i]
+
+                // Operation
+                if i % 2 == 1 {
+                    operation = child.variant
+                    continue
+                }
+
+                text += generateOutput(child)
+
+                switch operation {
+                case .BitwiseOr:
+                    text += "    pop \t%ecx\n"              // Put e1 in ecx and e2 is in eax
+                    text += "    or  \t%ecx, %eax\n"        // Perform e1 | e2; result in eax
+                    
+                default:
+                    if i != 0 {
+                        print("Unknown operation \"\(operation)\" in \(node.variant)")
+                    }
+                    break
+                }
+
+                if i != node.children.count - 1 {
+                    text += "    push\t%eax\n"
+                }
+            }
+            break
+
+        case .BitwiseAndExpressionSequence:
+            var operation: ConstructVariant = .Error
+            let count = node.children.count
+            if count == 0 {
+                print("ERROR: \(node.variant) with no children")
+                break
+            }
+            for i in 0...count - 1 {
+                let child: SyntaxTreeNode = node.children[i]
+
+                // Operation
+                if i % 2 == 1 {
+                    operation = child.variant
+                    continue
+                }
+
+                text += generateOutput(child)
+
+                switch operation {
+                case .BitwiseXOR:
+                    text += "    pop \t%ecx\n"              // Put e1 in ecx and e2 is in eax
+                    text += "    xor \t%ecx, %eax\n"        // Perform e1 ^ e2; result in eax
+                    
+                default:
+                    if i != 0 {
+                        print("Unknown operation \"\(operation)\" in \(node.variant)")
+                    }
+                    break
+                }
+
+                if i != node.children.count - 1 {
+                    text += "    push\t%eax\n"
+                }
+            }
+            break
+
+        case .EqualityExpressionSequence:
+            var operation: ConstructVariant = .Error
+            let count = node.children.count
+            if count == 0 {
+                print("ERROR: \(node.variant) with no children")
+                break
+            }
+            for i in 0...count - 1 {
+                let child: SyntaxTreeNode = node.children[i]
+
+                // Operation
+                if i % 2 == 1 {
+                    operation = child.variant
+                    continue
+                }
+
+                text += generateOutput(child)
+
+                switch operation {
+                case .BitwiseAnd:
+                    text += "    pop \t%ecx\n"              // Put e1 in ecx and e2 is in eax
+                    text += "    and \t%ecx, %eax\n"        // Perform e1 & e2; result in eax
+                    
+                default:
+                    if i != 0 {
+                        print("Unknown operation \"\(operation)\" in \(node.variant)")
+                    }
+                    break
+                }
+
+                if i != node.children.count - 1 {
+                    text += "    push\t%eax\n"
+                }
+            }
+            break
+
         case .RelationalExpressionSequence:
             var operation: ConstructVariant = .Error
             let count = node.children.count

test.c

@@ -1,4 +1,4 @@
 int main() {
-    return 3 % 2 / 29 % 23 + 9 % 2 % 3 % 4 % 5;
+    return 4 ^ 2 | 34 & 20 | (3 & 4) & ~1;
 }