redscript-mc 1.2.9 → 1.2.11

package/dist/lowering/index.js

@@ -209,6 +209,8 @@ class Lowering {
         this.floatVars = new Set();
         // World object counter for unique tags
         this.worldObjCounter = 0;
+        // Loop context stack for break/continue
+        this.loopStack = [];
         this.namespace = namespace;
         this.sourceRanges = sourceRanges;
         LoweringBuilder.resetTempCounter();
@@ -462,6 +464,12 @@ class Lowering {
             case 'return':
                 this.lowerReturnStmt(stmt);
                 break;
+            case 'break':
+                this.lowerBreakStmt();
+                break;
+            case 'continue':
+                this.lowerContinueStmt();
+                break;
             case 'if':
                 this.lowerIfStmt(stmt);
                 break;
@@ -599,6 +607,20 @@ class Lowering {
             this.builder.emitReturn();
         }
     }
+    lowerBreakStmt() {
+        if (this.loopStack.length === 0) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', 'break statement outside of loop', { line: 1, col: 1 });
+        }
+        const loop = this.loopStack[this.loopStack.length - 1];
+        this.builder.emitJump(loop.breakLabel);
+    }
+    lowerContinueStmt() {
+        if (this.loopStack.length === 0) {
+            throw new diagnostics_1.DiagnosticError('LoweringError', 'continue statement outside of loop', { line: 1, col: 1 });
+        }
+        const loop = this.loopStack[this.loopStack.length - 1];
+        this.builder.emitJump(loop.continueLabel);
+    }
     lowerIfStmt(stmt) {
         if (stmt.cond.kind === 'is_check') {
             this.lowerIsCheckIfStmt(stmt);
@@ -671,12 +693,16 @@ class Lowering {
         const condVar = this.lowerExpr(stmt.cond);
         const condName = this.operandToVar(condVar);
         this.builder.emitJumpIf(condName, bodyLabel, exitLabel);
+        // Push loop context for break/continue (while has no step, so continue goes to check)
+        this.loopStack.push({ breakLabel: exitLabel, continueLabel: checkLabel });
         // Body block
         this.builder.startBlock(bodyLabel);
         this.lowerBlock(stmt.body);
         if (!this.builder.isBlockSealed()) {
             this.builder.emitJump(checkLabel);
         }
+        // Pop loop context
+        this.loopStack.pop();
         // Exit block
         this.builder.startBlock(exitLabel);
     }
@@ -688,6 +714,7 @@ class Lowering {
         }
         const checkLabel = this.builder.freshLabel('for_check');
         const bodyLabel = this.builder.freshLabel('for_body');
+        const continueLabel = this.builder.freshLabel('for_continue');
         const exitLabel = this.builder.freshLabel('for_exit');
         this.builder.emitJump(checkLabel);
         // Check block
@@ -695,14 +722,20 @@ class Lowering {
         const condVar = this.lowerExpr(stmt.cond);
         const condName = this.operandToVar(condVar);
         this.builder.emitJumpIf(condName, bodyLabel, exitLabel);
+        // Push loop context for break/continue
+        this.loopStack.push({ breakLabel: exitLabel, continueLabel });
         // Body block
         this.builder.startBlock(bodyLabel);
         this.lowerBlock(stmt.body);
-        // Step expression
-        this.lowerExpr(stmt.step);
         if (!this.builder.isBlockSealed()) {
-            this.builder.emitJump(checkLabel);
+            this.builder.emitJump(continueLabel);
         }
+        // Continue block (step + loop back)
+        this.builder.startBlock(continueLabel);
+        this.lowerExpr(stmt.step);
+        this.builder.emitJump(checkLabel);
+        // Pop loop context
+        this.loopStack.pop();
         // Exit block
         this.builder.startBlock(exitLabel);
     }
@@ -794,12 +827,32 @@ class Lowering {
                 defaultArm = arm;
                 continue;
             }
-            const patternValue = this.lowerExpr(arm.pattern);
-            if (patternValue.kind !== 'const') {
-                throw new Error('Match patterns must lower to compile-time constants');
+            // Handle range patterns specially
+            let matchCondition;
+            if (arm.pattern.kind === 'range_lit') {
+                const range = arm.pattern.range;
+                if (range.min !== undefined && range.max !== undefined) {
+                    matchCondition = `${range.min}..${range.max}`;
+                }
+                else if (range.min !== undefined) {
+                    matchCondition = `${range.min}..`;
+                }
+                else if (range.max !== undefined) {
+                    matchCondition = `..${range.max}`;
+                }
+                else {
+                    matchCondition = '0..'; // Match any
+                }
+            }
+            else {
+                const patternValue = this.lowerExpr(arm.pattern);
+                if (patternValue.kind !== 'const') {
+                    throw new Error('Match patterns must lower to compile-time constants');
+                }
+                matchCondition = String(patternValue.value);
             }
             const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`;
-            this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 if score ${subject} rs matches ${patternValue.value} run function ${this.namespace}:${subFnName}`);
+            this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 if score ${subject} rs matches ${matchCondition} run function ${this.namespace}:${subFnName}`);
             this.emitMatchArmSubFunction(subFnName, matchedVar, arm.body, true);
         }
         if (defaultArm) {
@@ -953,18 +1006,52 @@ class Lowering {
         const parts = ['execute'];
         for (const sub of stmt.subcommands) {
             switch (sub.kind) {
+                // Context modifiers
                 case 'as':
                     parts.push(`as ${this.selectorToString(sub.selector)}`);
                     break;
                 case 'at':
                     parts.push(`at ${this.selectorToString(sub.selector)}`);
                     break;
+                case 'positioned':
+                    parts.push(`positioned ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'positioned_as':
+                    parts.push(`positioned as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'rotated':
+                    parts.push(`rotated ${sub.yaw} ${sub.pitch}`);
+                    break;
+                case 'rotated_as':
+                    parts.push(`rotated as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'facing':
+                    parts.push(`facing ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'facing_entity':
+                    parts.push(`facing entity ${this.selectorToString(sub.selector)} ${sub.anchor}`);
+                    break;
+                case 'anchored':
+                    parts.push(`anchored ${sub.anchor}`);
+                    break;
+                case 'align':
+                    parts.push(`align ${sub.axes}`);
+                    break;
+                case 'in':
+                    parts.push(`in ${sub.dimension}`);
+                    break;
+                case 'on':
+                    parts.push(`on ${sub.relation}`);
+                    break;
+                case 'summon':
+                    parts.push(`summon ${sub.entity}`);
+                    break;
+                // Conditions
                 case 'if_entity':
                     if (sub.selector) {
                         parts.push(`if entity ${this.selectorToString(sub.selector)}`);
                     }
                     else if (sub.varName) {
-                        // Variable with filters - substitute with @s and apply filters
                         const sel = { kind: '@s', filters: sub.filters };
                         parts.push(`if entity ${this.selectorToString(sel)}`);
                     }
@@ -974,13 +1061,34 @@ class Lowering {
                         parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
                     }
                     else if (sub.varName) {
-                        // Variable with filters - substitute with @s and apply filters
                         const sel = { kind: '@s', filters: sub.filters };
                         parts.push(`unless entity ${this.selectorToString(sel)}`);
                     }
                     break;
-                case 'in':
-                    parts.push(`in ${sub.dimension}`);
+                case 'if_block':
+                    parts.push(`if block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'unless_block':
+                    parts.push(`unless block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'if_score':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'unless_score':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'if_score_range':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                case 'unless_score_range':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                // Store
+                case 'store_result':
+                    parts.push(`store result score ${sub.target} ${sub.targetObj}`);
+                    break;
+                case 'store_success':
+                    parts.push(`store success score ${sub.target} ${sub.targetObj}`);
                     break;
             }
         }

package/dist/optimizer/dce.js

@@ -241,6 +241,8 @@ class DeadCodeEliminator {
                 this.collectNestedStmtRefs(stmt, scope);
                 break;
             case 'raw':
+            case 'break':
+            case 'continue':
                 break;
         }
     }
@@ -508,6 +510,10 @@ class DeadCodeEliminator {
                 return [copySpan({ ...stmt, body: this.transformBlock(stmt.body, scope) }, stmt)];
             case 'raw':
                 return [stmt];
+            case 'break':
+                return [stmt];
+            case 'continue':
+                return [stmt];
         }
     }
     transformExpr(expr, scope) {

package/dist/parser/index.d.ts

@@ -45,6 +45,10 @@ export declare class Parser {
     private parseAsStmt;
     private parseAtStmt;
     private parseExecuteStmt;
+    private parseExecuteCondition;
+    private parseCoordToken;
+    private parseBlockId;
+    private checkIdent;
     private parseExprStmt;
     private parseExpr;
     private parseAssignment;

package/dist/parser/index.js

@@ -397,6 +397,18 @@ class Parser {
         if (this.check('return')) {
             return this.parseReturnStmt();
         }
+        // Break statement
+        if (this.check('break')) {
+            const token = this.advance();
+            this.match(';');
+            return this.withLoc({ kind: 'break' }, token);
+        }
+        // Continue statement
+        if (this.check('continue')) {
+            const token = this.advance();
+            this.match(';');
+            return this.withLoc({ kind: 'continue' }, token);
+        }
         // If statement
         if (this.check('if')) {
             return this.parseIfStmt();
@@ -534,11 +546,11 @@ class Parser {
         this.expect('in');
         const iterable = this.parseExpr();
         this.expect(')');
-        // Parse optional execute context modifiers (at, positioned, rotated, facing, etc.)
+        // Parse optional execute context modifiers (as, at, positioned, rotated, facing, etc.)
         let executeContext;
-        // Check for 'at' keyword or identifiers like 'positioned', 'rotated', 'facing', 'anchored', 'align'
-        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align'];
-        if (this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
+        // Check for execute subcommand keywords
+        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align', 'on', 'summon'];
+        if (this.check('as') || this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
             // Collect everything until we hit '{'
             let context = '';
             while (!this.check('{') && !this.check('eof')) {
@@ -603,34 +615,175 @@ class Parser {
                 const selector = this.parseSelector();
                 subcommands.push({ kind: 'at', selector });
             }
-            else if (this.match('if')) {
-                // Expect 'entity' keyword (as ident) or just parse selector directly
-                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-                    this.advance(); // consume 'entity'
+            else if (this.checkIdent('positioned')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'positioned_as', selector });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'positioned', x, y, z });
                 }
-                const selectorOrVar = this.parseSelectorOrVarSelector();
-                subcommands.push({ kind: 'if_entity', ...selectorOrVar });
             }
-            else if (this.match('unless')) {
-                // Expect 'entity' keyword (as ident) or just parse selector directly  
-                if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
-                    this.advance(); // consume 'entity'
+            else if (this.checkIdent('rotated')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'rotated_as', selector });
+                }
+                else {
+                    const yaw = this.parseCoordToken();
+                    const pitch = this.parseCoordToken();
+                    subcommands.push({ kind: 'rotated', yaw, pitch });
+                }
+            }
+            else if (this.checkIdent('facing')) {
+                this.advance();
+                if (this.checkIdent('entity')) {
+                    this.advance();
+                    const selector = this.parseSelector();
+                    const anchor = this.checkIdent('eyes') || this.checkIdent('feet') ? this.advance().value : 'feet';
+                    subcommands.push({ kind: 'facing_entity', selector, anchor });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'facing', x, y, z });
+                }
+            }
+            else if (this.checkIdent('anchored')) {
+                this.advance();
+                const anchor = this.advance().value;
+                subcommands.push({ kind: 'anchored', anchor });
+            }
+            else if (this.checkIdent('align')) {
+                this.advance();
+                const axes = this.advance().value;
+                subcommands.push({ kind: 'align', axes });
+            }
+            else if (this.checkIdent('on')) {
+                this.advance();
+                const relation = this.advance().value;
+                subcommands.push({ kind: 'on', relation });
+            }
+            else if (this.checkIdent('summon')) {
+                this.advance();
+                const entity = this.advance().value;
+                subcommands.push({ kind: 'summon', entity });
+            }
+            else if (this.checkIdent('store')) {
+                this.advance();
+                const storeType = this.advance().value; // 'result' or 'success'
+                if (this.checkIdent('score')) {
+                    this.advance();
+                    const target = this.advance().value;
+                    const targetObj = this.advance().value;
+                    if (storeType === 'result') {
+                        subcommands.push({ kind: 'store_result', target, targetObj });
+                    }
+                    else {
+                        subcommands.push({ kind: 'store_success', target, targetObj });
+                    }
+                }
+                else {
+                    this.error('store currently only supports score target');
                 }
-                const selectorOrVar = this.parseSelectorOrVarSelector();
-                subcommands.push({ kind: 'unless_entity', ...selectorOrVar });
+            }
+            else if (this.match('if')) {
+                this.parseExecuteCondition(subcommands, 'if');
+            }
+            else if (this.match('unless')) {
+                this.parseExecuteCondition(subcommands, 'unless');
             }
             else if (this.match('in')) {
-                const dim = this.expect('ident').value;
+                // Dimension can be namespaced: minecraft:the_nether
+                let dim = this.advance().value;
+                if (this.match(':')) {
+                    dim += ':' + this.advance().value;
+                }
                 subcommands.push({ kind: 'in', dimension: dim });
             }
             else {
-                this.error(`Unexpected token in execute statement: ${this.peek().kind}`);
+                this.error(`Unexpected token in execute statement: ${this.peek().kind} (${this.peek().value})`);
             }
         }
         this.expect('run');
         const body = this.parseBlock();
         return this.withLoc({ kind: 'execute', subcommands, body }, executeToken);
     }
+    parseExecuteCondition(subcommands, type) {
+        if (this.checkIdent('entity') || this.check('selector')) {
+            if (this.checkIdent('entity'))
+                this.advance();
+            const selectorOrVar = this.parseSelectorOrVarSelector();
+            subcommands.push({ kind: type === 'if' ? 'if_entity' : 'unless_entity', ...selectorOrVar });
+        }
+        else if (this.checkIdent('block')) {
+            this.advance();
+            const x = this.parseCoordToken();
+            const y = this.parseCoordToken();
+            const z = this.parseCoordToken();
+            const block = this.parseBlockId();
+            subcommands.push({ kind: type === 'if' ? 'if_block' : 'unless_block', pos: [x, y, z], block });
+        }
+        else if (this.checkIdent('score')) {
+            this.advance();
+            const target = this.advance().value;
+            const targetObj = this.advance().value;
+            // Check for range or comparison
+            if (this.checkIdent('matches')) {
+                this.advance();
+                const range = this.advance().value;
+                subcommands.push({ kind: type === 'if' ? 'if_score_range' : 'unless_score_range', target, targetObj, range });
+            }
+            else {
+                const op = this.advance().value; // <, <=, =, >=, >
+                const source = this.advance().value;
+                const sourceObj = this.advance().value;
+                subcommands.push({
+                    kind: type === 'if' ? 'if_score' : 'unless_score',
+                    target, targetObj, op, source, sourceObj
+                });
+            }
+        }
+        else {
+            this.error(`Unknown condition type after ${type}`);
+        }
+    }
+    parseCoordToken() {
+        // Handle ~, ^, numbers, relative coords like ~5, ^-3
+        const token = this.peek();
+        if (token.kind === 'rel_coord' || token.kind === 'local_coord' ||
+            token.kind === 'int_lit' || token.kind === 'float_lit' ||
+            token.kind === '-' || token.kind === 'ident') {
+            return this.advance().value;
+        }
+        this.error(`Expected coordinate, got ${token.kind}`);
+        return '~';
+    }
+    parseBlockId() {
+        // Parse block ID like minecraft:stone or stone
+        let id = this.advance().value;
+        if (this.match(':')) {
+            id += ':' + this.advance().value;
+        }
+        // Handle block states [facing=north]
+        if (this.check('[')) {
+            id += this.advance().value; // [
+            while (!this.check(']') && !this.check('eof')) {
+                id += this.advance().value;
+            }
+            id += this.advance().value; // ]
+        }
+        return id;
+    }
+    checkIdent(value) {
+        return this.check('ident') && this.peek().value === value;
+    }
     parseExprStmt() {
         const expr = this.parseExpr();
         this.expect(';');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/fixtures/array-test.mcrs

@@ -0,0 +1,30 @@
+// Array operations test
+
+@keep fn test_array() {
+    // Array initialization
+    let nums: int[] = [10, 20, 30, 40, 50];
+    
+    // Array access
+    scoreboard_set("#arr_0", #rs, nums[0]);
+    scoreboard_set("#arr_2", #rs, nums[2]);
+    scoreboard_set("#arr_4", #rs, nums[4]);
+    
+    // Array length via .len property
+    scoreboard_set("#arr_len", #rs, nums.len);
+    
+    // Sum via foreach
+    let sum: int = 0;
+    foreach (n in nums) {
+        sum = sum + n;
+    }
+    scoreboard_set("#arr_sum", #rs, sum);
+    
+    // Push operation
+    let arr2: int[] = [1, 2, 3];
+    arr2.push(4);
+    scoreboard_set("#arr_push", #rs, arr2.len);
+    
+    // Pop operation
+    let popped: int = arr2.pop();
+    scoreboard_set("#arr_pop", #rs, popped);
+}

package/src/__tests__/fixtures/break-continue-test.mcrs

@@ -0,0 +1,46 @@
+// Break and continue statements test
+
+@keep fn test_break_continue() {
+    // Test break - should stop at i=5
+    let break_at: int = -1;
+    for (let i: int = 0; i < 10; i = i + 1) {
+        if (i == 5) {
+            break_at = i;
+            break;
+        }
+    }
+    scoreboard_set("#break_at", #rs, break_at);
+    
+    // Test continue - sum only even numbers
+    let sum_evens: int = 0;
+    for (let i: int = 0; i < 10; i = i + 1) {
+        if (i % 2 != 0) {
+            continue;
+        }
+        sum_evens = sum_evens + i;
+    }
+    // 0+2+4+6+8 = 20
+    scoreboard_set("#sum_evens", #rs, sum_evens);
+    
+    // While with break
+    let count: int = 0;
+    while (true) {
+        count = count + 1;
+        if (count >= 7) {
+            break;
+        }
+    }
+    scoreboard_set("#while_break", #rs, count);
+    
+    // Nested loop break (breaks inner only)
+    let outer_count: int = 0;
+    for (let a: int = 0; a < 3; a = a + 1) {
+        for (let b: int = 0; b < 10; b = b + 1) {
+            if (b == 2) {
+                break;
+            }
+        }
+        outer_count = outer_count + 1;
+    }
+    scoreboard_set("#nested_break", #rs, outer_count);
+}

package/src/__tests__/fixtures/enum-test.mcrs

@@ -0,0 +1,37 @@
+// Enum definition and matching test
+
+enum GamePhase {
+    Lobby,      // 0
+    Starting,   // 1
+    Playing,    // 2
+    Ended       // 3
+}
+
+enum Rank {
+    Bronze = 1,
+    Silver = 2,
+    Gold = 3,
+    Diamond = 10
+}
+
+@keep fn test_enum() {
+    // Basic enum value (use . not ::)
+    let phase: int = GamePhase.Playing;
+    scoreboard_set("#enum_phase", #rs, phase);
+    
+    // Match on enum
+    match (phase) {
+        GamePhase.Lobby => { scoreboard_set("#enum_match", #rs, 0); }
+        GamePhase.Playing => { scoreboard_set("#enum_match", #rs, 2); }
+        _ => { scoreboard_set("#enum_match", #rs, -1); }
+    }
+    
+    // Custom values
+    let rank: int = Rank.Diamond;
+    scoreboard_set("#enum_rank", #rs, rank);
+    
+    // Comparison
+    if (rank > Rank.Gold) {
+        scoreboard_set("#enum_high", #rs, 1);
+    }
+}

package/src/__tests__/fixtures/foreach-at-test.mcrs

@@ -0,0 +1,33 @@
+// Foreach with execute context modifiers test
+
+@load fn setup() {
+    scoreboard_add("rs");
+    scoreboard_set("#foreach_count", #rs, 0);
+    scoreboard_set("#foreach_at_count", #rs, 0);
+}
+
+@keep fn test_foreach_at() {
+    // Spawn test entities
+    raw("summon minecraft:armor_stand ~ ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    raw("summon minecraft:armor_stand ~2 ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    raw("summon minecraft:armor_stand ~4 ~ ~ {Tags:[\"test_foreach\"],NoGravity:1b}");
+    
+    // Basic foreach
+    let count: int = 0;
+    foreach (e in @e[type=armor_stand,tag=test_foreach]) {
+        count = count + 1;
+    }
+    scoreboard_set("#foreach_count", #rs, count);
+    
+    // Foreach with at @s (execute at entity position)
+    let at_count: int = 0;
+    foreach (e in @e[type=armor_stand,tag=test_foreach]) at @s {
+        // This runs at each entity's position
+        at_count = at_count + 1;
+        raw("particle minecraft:heart ~ ~1 ~ 0 0 0 0 1");
+    }
+    scoreboard_set("#foreach_at_count", #rs, at_count);
+    
+    // Cleanup
+    raw("kill @e[type=armor_stand,tag=test_foreach]");
+}

package/src/__tests__/fixtures/match-range-test.mcrs

@@ -0,0 +1,45 @@
+// Match with range patterns test
+
+@keep fn test_match_range() {
+    // Test score grading
+    let score: int = 85;
+    let grade: int = 0;
+    
+    match (score) {
+        0..59 => { grade = 1; }    // F
+        60..69 => { grade = 2; }   // D
+        70..79 => { grade = 3; }   // C
+        80..89 => { grade = 4; }   // B
+        90..100 => { grade = 5; }  // A
+        _ => { grade = 0; }
+    }
+    scoreboard_set("#grade", #rs, grade);
+    
+    // Test boundary values
+    let val1: int = 59;
+    let result1: int = 0;
+    match (val1) {
+        0..59 => { result1 = 1; }
+        60..100 => { result1 = 2; }
+        _ => { result1 = 0; }
+    }
+    scoreboard_set("#boundary_59", #rs, result1);
+    
+    let val2: int = 60;
+    let result2: int = 0;
+    match (val2) {
+        0..59 => { result2 = 1; }
+        60..100 => { result2 = 2; }
+        _ => { result2 = 0; }
+    }
+    scoreboard_set("#boundary_60", #rs, result2);
+    
+    // Open-ended ranges
+    let neg: int = -5;
+    let neg_result: int = 0;
+    match (neg) {
+        ..0 => { neg_result = 1; }
+        0.. => { neg_result = 2; }
+    }
+    scoreboard_set("#neg_range", #rs, neg_result);
+}