j2scc statements

1. expressions
    1.1. literal expressions
        1.1.1. decimal literal ("([0-9]+)")
        1.1.2. hex literal ("0x([0-9a-fA-F]+)")
        1.1.3. binary literal ("0b([01]+)")
        1.1.4. octal literal ("0o?([0-7]+)")
        1.1.5. string literal ("(?<qout>[\"']).+\\<quot>")
    1.2. initialization expressions
        1.2.1. struct initialization ("new (\\w+)\\(((?:.+?, )*.+)?\\)")
    1.3. named data expressions
        1.3.1. field reference ("(\\w+)")
        1.3.2. struct member reference ("(.+)\\.(\\w+)")
    1.4. unary expressions
        1.4.1. prefix increment ("++(.+)")
        1.4.2. postfix increment ("(.+)++")
        1.4.3. prefix decrement ("--(.+)")
        1.4.4. postfix decrement ("(.+)--")
        1.4.5. inversion ("!(.+)")
    1.5. binary expressions
        1.5.1. relational comparison ("(.+) ?((?:[!=\\<\\>]=)|(?:[\\<\\>])) ?(.+)")
        1.5.2. arithmetic / bitwise operation ("(.+) ?([+-*/%&|^]) ?(.+)")
        1.5.3. shift operation (".+ ?((?:\\<\\<)|(?:\\>\\>)) ?.+")
        1.5.4. assignment ("(.+) ?= ?.+")
        1.5.5. arithmetic / bitwise operative assignment ("(.+) ?([+-*/%&|^])= ?(.+)")
        1.5.6. shift operative assignment ("(.+) ?((?:\\<\\<)|(?:\\>\\>))= ?(.+)")
    1.6. ternary expressions
        1.6.1. conditional expression ("(.+) ?\\? ?(.+) ?\\: ?(.+)")
    1.7. parenthesized expressions
        1.7.1. type cast expression ("\\((\\w+)\\) ?(.+)")
        1.7.2. method invocation expression ("(\\w+)\\(((?:.+?, )*.+)?\\)")
2. statements
    2.1. expression statements
        2.1.1. expression evaluation
    2.2. flow control statements
        2.2.1. if statement ("if ?\\((.+)\\)(?: ?\\{)?")
        2.2.2. for statement ("for ?\\((.+), (.+), (.+)\\)(?: ?\\{)?")
        2.2.3. while statement ("while ?\\((.+)\\)(?: ?\\{)?")
        2.2.4. label statement ("(\\w+): ?\\{")
        2.2.5. switch statement ("switch ?\\((.+)\\) ?\\{")
    2.3. labeled statements
        2.3.1. return statement ("return(?: (.+))?(?: if (.+))?")
        2.3.2. exit statement ("exit(?: if (.+))?")
        2.3.3. wait statement ("wait(?: if (.+))?")
        2.3.4. jump statement ("jump (\\w+)(?: if (.+))?")
        2.3.5. break statement ("break(?: (\\w+))(?: if (.+))?")
        2.3.6. continue statement ("continue(?: (\\w+))(?: if (.+))?")
        2.3.7. case statement ("case (.+)\\: ?\\{")