From 10023cae869271f2571e8973f8ff346f7a432b57 Mon Sep 17 00:00:00 2001 From: Trevor Maze Date: Wed, 11 Feb 2026 16:56:47 -0500 Subject: [PATCH] More binary operators --- Sources/rxcc/rxcc.swift | 174 +++++++++++++++++++++++++++++++++++++++- test.c | 2 +- 2 files changed, 171 insertions(+), 5 deletions(-) diff --git a/Sources/rxcc/rxcc.swift b/Sources/rxcc/rxcc.swift index 6366923..d20a5ab 100644 --- a/Sources/rxcc/rxcc.swift +++ b/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: [ - .Construct(type: .EqualityExpression), + .BitwiseOrExpressionSequence: [ + .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 diff --git a/test.c b/test.c index 2a5963e..af90d6e 100644 --- a/test.c +++ b/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; }