From 2e3dd130095c0ed5e635b79be2480355039e1587 Mon Sep 17 00:00:00 2001
From: Trevor Maze <rochesterx@rochesterx.dev>
Date: Sat, 31 Jan 2026 15:07:04 -0500
Subject: [PATCH] ! Breaking

---
 Sources/rxcc/rxcc.swift |  40 ++++++++++++++++++++++++----------------
 a.out                   | Bin 15712 -> 15704 bytes
 bitwise.s               |  21 ---------------------
 my.out                  | Bin 15680 -> 0 bytes
 test.c                  |   3 +++
 test.s                  |   0
 test2.c                 |   3 +++
 test2.s                 |   0
 8 files changed, 30 insertions(+), 37 deletions(-)
 delete mode 100644 bitwise.s
 delete mode 100755 my.out
 create mode 100644 test.c
 create mode 100644 test.s
 create mode 100644 test2.c
 create mode 100644 test2.s

diff --git a/Sources/rxcc/rxcc.swift b/Sources/rxcc/rxcc.swift
index cc8c866..6a9a458 100644
--- a/Sources/rxcc/rxcc.swift
+++ b/Sources/rxcc/rxcc.swift
@@ -451,27 +451,37 @@ enum Validity {
 }
 
 func validateConstruct(_ construct: Construct, tokens: inout [Token], node: SyntaxTreeNode) -> Validity {
+    var indent: String {
+        var count: Int = 0
+        var child: SyntaxTreeNode = node
+        while child.parent != nil {
+            count += 1
+            child = child.parent!
+        }
+        return String(repeating: "  ", count: count)
+    }
+
     var loop: Bool = false
     repeat {
         for element in construct {
             switch element {
             case .Construct(let type):
-                print("Begin validate subconstruct (type \"\(type)\")")
+                print("\(indent)Begin validate subconstruct (type \"\(type)\")")
 
                 var valid: Validity = .Invalid
                 var validVariant: ConstructVariant = .Error
                 let tokenBackup: [Token] = tokens
                 for key in constructDefinitions[type]!.keys {
                     let childNode = node.addChild(value: key)
-                    print("Testing variant \(key) (Loop = \(loop))")
+                    print("\(indent)Testing variant \(key) (Loop = \(loop))")
                     valid = validateConstruct(constructDefinitions[type]![key]!, tokens: &tokens, node: childNode)
                     if valid == .Invalid {
-                        print("Fail")
+                        print("\(indent)Fail")
                         tokens = tokenBackup
                         _ = node.popLastChild()
                         continue
                     }
-                    print("Success")
+                    print("\(indent)Success")
                     validVariant = key
 
                     break
@@ -484,10 +494,10 @@ func validateConstruct(_ construct: Construct, tokens: inout [Token], node: Synt
                 if type == .Factor {
                     let nextToken: Token = tokens[tokens.count - 1]
                     if nextToken.type == .MULTIPLICATION || nextToken.type == .DIVISION {
-                        print("Looping due to factor")
+                        print("\(indent)Looping due to factor")
                         loop = true
                     } else {
-                        print("Breaking out of factor loop")
+                        print("\(indent)Breaking out of factor loop")
                         loop = false
                         return .Break
                     }
@@ -497,10 +507,10 @@ func validateConstruct(_ construct: Construct, tokens: inout [Token], node: Synt
                 else if type == .Term {
                     let nextToken: Token = tokens[tokens.count - 1]
                     if nextToken.type == .ADDITION || nextToken.type == .NEGATION {
-                        print("Looping due to term")
+                        print("\(indent)Looping due to term")
                         loop = true
                     } else {
-                        print("Breaking out of term loop")
+                        print("\(indent)Breaking out of term loop")
                         loop = false
                         return .Break
                     }
@@ -510,26 +520,24 @@ func validateConstruct(_ construct: Construct, tokens: inout [Token], node: Synt
 
 
                 if valid == .Invalid {
-                    print("Subconstruct validation failed")
+                    print("\(indent)Subconstruct validation failed")
                     return .Invalid
                 } else if valid == .Break {
-                    print("End validate subconstruct (variant \"\(validVariant) by breaking\")")
+                    print("\(indent)End validate subconstruct (variant \"\(validVariant) by breaking\")")
                     print(type)
                     break
                 }
 
-                print("End validate subconstruct (variant \"\(validVariant)\")")
-                print(type)
-
+                print("\(indent)End validate subconstruct (variant \"\(validVariant)\")")
                 continue
 
             case .Token(let type):
                 if let token: Token = tokens.popLast() {
                     if type != token.type {
-                        print("VALIDATION FAILED FOR TOKEN \"\(token.content)\"")
+                        print("\(indent)VALIDATION FAILED FOR TOKEN \"\(token.content)\"")
                         return .Invalid
                     }
-                    print("Validated token \"\(token.content)\"")
+                    print("\(indent)Validated token \"\(token.content)\"")
 
                     if token.type == .LITERAL_INTEGER {
                         node.value = String(token.content)
@@ -541,7 +549,7 @@ func validateConstruct(_ construct: Construct, tokens: inout [Token], node: Synt
                     continue
 
                 } else {
-                    print("RAN OUT OF TOKENS")
+                    print("\(indent)RAN OUT OF TOKENS")
                     return .Invalid
                 }
             }
diff --git a/a.out b/a.out
index cda0f91488304458c8544eaf2be067b4d1b1054d..ffc6a385fd7cc3725b2124653f7bfc19b0c0ea6d 100755
GIT binary patch
delta 363
zcmaD*b)#y624loV&2nZD%L}V#{8i$59;2iu-8sLBD|e43!{#l_S-dQv=l}oTtR$$X
zz_@;LprJV9&dHgE`jW>P7#J8Cgc%g<fD9yXVe&>pammL(5k>}4h8OloQb6X<$q#`h
zh)pgu5@&RrENCPyX~f9DAiyBTAmD(i(sHsRP}UwQ%YY{912RD}8YnBsB*wsjCYv#N
zAyBp)tXG^t0!`L+@<pI*4OAB0-j2zP#^RE_P?OPRXM*fy-3*jfn*5PTnDN}?MC1J|
iC8@<Fn>9>Im^LpkOJHNXGMUlVoYTh?;vpU&PaXj0)IcQw

delta 362
zcmcan^`L5k24liT&2nau&#PIc@4fr@(+MxhhsHmrluokjQr*0TIg6Kt0SGoL3F;{@
zZk`-yD9*Tda;Bla<Y}NNBZDx5f*nX60j^BmXeciE94NrZAj<H<9w7r_{hj;}XoA$_
zLL+fT*U5rL;*w^J3=9GcVhjQfs48tII|5~$p|T8UvH>6yB;$dyf=prz9B8sRlNSPI
ztHFB386?nTJttoT$~Hh{(e3S-%xEkwIT30yy6jw#y{y}TvPzRbG6^$Ynw)67pCd27
kBt9*(EOoPrNeR;=W|qw}%o5lbZ%qDaW6l^b+0a%U0B1i#wg3PC

diff --git a/bitwise.s b/bitwise.s
deleted file mode 100644
index e04fa70..0000000
--- a/bitwise.s
+++ /dev/null
@@ -1,21 +0,0 @@
-	.file	"bitwise.c"
-	.text
-	.globl	main
-	.type	main, @function
-main:
-.LFB0:
-	.cfi_startproc
-	pushq	%rbp
-	.cfi_def_cfa_offset 16
-	.cfi_offset 6, -16
-	movq	%rsp, %rbp
-	.cfi_def_cfa_register 6
-	movl	$-13, %eax
-	popq	%rbp
-	.cfi_def_cfa 7, 8
-	ret
-	.cfi_endproc
-.LFE0:
-	.size	main, .-main
-	.ident	"GCC: (GNU) 15.2.1 20260103"
-	.section	.note.GNU-stack,"",@progbits
diff --git a/my.out b/my.out
deleted file mode 100755
index f8d436ef167ea75487e632c1ea5ce49db506f283..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15680
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

diff --git a/test.c b/test.c
new file mode 100644
index 0000000..554c254
--- /dev/null
+++ b/test.c
@@ -0,0 +1,3 @@
+int main() {
+    return !1 * 1;
+}
diff --git a/test.s b/test.s
new file mode 100644
index 0000000..e69de29
diff --git a/test2.c b/test2.c
new file mode 100644
index 0000000..08e20b8
--- /dev/null
+++ b/test2.c
@@ -0,0 +1,3 @@
+int main() {
+    return (~2 + !(4 - 2) / 9 - -9) + 90 * 8 - 2 - 33 * (400 - 1) - !~-9;
+}
diff --git a/test2.s b/test2.s
new file mode 100644
index 0000000..e69de29