Fix infinite loop in bsort.dana

dana/programs/N_Queens.dana

@@ -1,101 +1,110 @@
 def main
 
-    def printBoard: board as byte[][], n as int
-        var i j is int
-        i := 0
+    var size_main is int
+
+    def printBoard: board_param as byte[][], n_param as int
+        var i_pb j_pb is int
+        i_pb := 0
         loop:
-            if i >= n : 
+            if i_pb >= n_param :
                 break
-            j := 0
+            j_pb := 0
             loop:
-                if j >= n :  
+                if j_pb >= n_param :
                     break
-                if board[i][j] = 1 :  
+                if board_param[i_pb][j_pb] = true :
                     writeString: "Q "
                 else :
                     writeString: ". "
-                j := j + 1
+                j_pb := j_pb + 1
             writeString: "\n"
-            i := i + 1
+            i_pb := i_pb + 1
         writeString: "\n"
 
-    def isSafe is byte: board as byte[][], row col n as int
-        var i j is int
+    def isSafe is byte: board_param as byte[][], row_param col_param n_param as int
+        var i_is j_is is int
 
-        # check columns
-        i := 0
+        i_is := 0
         loop:
-            if i >= row :  
+            if i_is >= row_param :
                 break
-            if board[i][col] = 1 :  
-                return : 0  
-            i := i + 1
+            if board_param[i_is][col_param] = true :
+                return : false
+            i_is := i_is + 1
 
-        # check left diagonal
-        i := row - 1
-        j := col - 1
+        i_is := row_param - 1
+        j_is := col_param - 1
         loop:
-            if i < 0 or j < 0 :  
+            if i_is < 0 or j_is < 0 :
                 break
-            if board[i][j] = 1 :  
-                return : 0
-            i := i - 1
-            j := j - 1
-
-        # check right diagonal
-        i := row - 1
-        j := col + 1
+            if board_param[i_is][j_is] = true :
+                return : false
+            i_is := i_is - 1
+            j_is := j_is - 1
+
+        i_is := row_param - 1
+        j_is := col_param + 1
         loop:
-            if i < 0 or j >= n :  
+            if i_is < 0 or j_is >= n_param :
                 break
-            if board[i][j] = 1 :  
-                return : 0
-            i := i - 1
-            j := j + 1
+            if board_param[i_is][j_is] = true :
+                return : false
+            i_is := i_is - 1
+            j_is := j_is + 1
 
-        return : 1  
+        return : true
 
-    def solveNQueensUtil is byte: board as byte[][], row n as int
-        if row = n :  
-            printBoard: board, n
-            return : 1   
+    def solveNQueensUtil is byte: board_param as byte[][], row_param n_param as int
+        var col_util is int
 
-        var col is int
-        col := 0
+        if row_param = n_param :
+            printBoard: board_param, n_param
+            return : true
+
+        col_util := 0
         loop:
-            if col >= n :  
+            if col_util >= n_param :
                 break
-            if isSafe: board, row, col, n :  
-                board[row][col] := 1  
-                if solveNQueensUtil: board, row + 1, n :  
-                    return : 1  
-                board[row][col] := 0  
-            col := col + 1  
+            if isSafe(board_param, row_param, col_util, n_param) :
+                if row_param < 20 and col_util < 20 : board_param[row_param][col_util] := true
+
+                if solveNQueensUtil(board_param, row_param + 1, n_param) :
+                    return : true
+
+                if row_param < 20 and col_util < 20 : board_param[row_param][col_util] := false
+            col_util := col_util + 1
 
-        return : 0   
+        return : false
 
-    def solveNQueens: n as int
-        var board is byte[n][n]
-        var i j is int
+    def solveNQueens: n_param as int
+        var board_snq is byte[20][20]
+        var i_snq j_snq is int
 
-        i := 0
+        i_snq := 0
         loop:
-            if i >= n :  
+            if i_snq >= n_param :
                 break
-            j := 0
+            j_snq := 0
             loop:
-                if j >= n :  
+                if j_snq >= n_param :
                     break
-                board[i][j] := 0  
-                j := j + 1  
-            i := i + 1  
+                if i_snq < 20 and j_snq < 20 : board_snq[i_snq][j_snq] := false
+                j_snq := j_snq + 1
+            i_snq := i_snq + 1
 
-        if solveNQueensUtil: board, 0, n :  
-            writeString: "Solution found.\n"
+        if solveNQueensUtil(board_snq, 0, n_param) :
+            skip
         else :
             writeString: "No solution exists.\n"
 
-    var size is int
     writeString: "Enter board size: "
-    size := readInteger()  
-    solveNQueens: size  
+    size_main := readInteger()
+    if size_main > 20 :
+        writeString: "Warning: Board size capped at 20 due to program limits.\n"
+        size_main := 20
+    if size_main < 1 :
+        writeString: "Info: Board size must be at least 1. Setting to 1.\n"
+        size_main := 1
+
+    if size_main > 0 : solveNQueens: size_main
+    else: writeString: "No solution exists for non-positive size.\n"

dana/programs/bsort.dana

@@ -1,27 +1,28 @@
 def main
 
   def bsort: n as int, x as int []
-
-    def swap: x y as ref int
-      var t is int
-      t := x
-      x := y
-      y := t
-
     var changed is byte
     var i is int
 
-    loop:
+    loop outer_loop_label:
       changed := false
       i := 0
-      loop:
+      loop inner_loop_label:
         if i < n-1:
           if x[i] > x[i+1]:
             swap: x[i], x[i+1]
             changed := true
           i := i+1
-        else: break
-        if not changed: break
+        else:
+          break : inner_loop_label
+      if not changed:
+        break : outer_loop_label
+
+  def swap: x y as ref int
+    var t is int
+    t := x
+    x := y
+    y := t
 
   def writeArray: msg as byte [], n as int, x as int []
     var i is int
@@ -37,16 +38,17 @@ def main
     writeString: "\n"
 
   var seed i is int
-  var x      is int [16]
+  var x is int [16]
 
   seed := 65
   i := 0
-  loop:
+  loop init_loop:
     if i < 16:
       seed := (seed * 137 + 220 + i) % 101
       x[i] := seed
       i := i+1
-    else: break
+    else:
+      break : init_loop
   writeArray: "Initial array: ", 16, x
   bsort: 16, x
   writeArray: "Sorted array: ", 16, x

dana/programs/calculator.dana

@@ -1,3 +1,4 @@
+(* calculator.dana *)
 def main
     # Helper Function
 
@@ -11,10 +12,8 @@ def main
         else:
             return: false
 
-    (*
-        Conversion from part of a string to an int
-        [from, to)
-    *)
+    # Conversion from part of a string to an int
+    # [from, to)
     def string_to_int is int: s as byte[], from to as int
         var i res pow is int
 
@@ -30,18 +29,16 @@ def main
 
         return: res
 
-    (*
-        Simple Calculator
-
-        Input: lines of the following form:
-        <Num1> <Op> <Num2>
-        where <NumX> is a positive integer
-        and <Op> is one of +, -, *, /
-        Any other characters among them get ignored.
-
-        Output: lines with the results
-        or a message "Invalid" in case of failure
-    *)
+    # Simple Calculator
+    #
+    # Input: lines of the following form:
+    # <Num1> <Op> <Num2>
+    # where <NumX> is a positive integer
+    # and <Op> is one of +, -, *, /
+    # Any other characters among them get ignored.
+    #
+    # Output: lines with the results
+    # or a message "Invalid" in case of failure
 
     var buf is byte[256]
     var idx len start p_end a b is int
@@ -60,60 +57,84 @@ def main
             if idx = len:
                 writeString: "Invalid\n"
                 continue: lines
-            elif is_number(buf[idx]):
+            elif is_digit(buf[idx]):
                 break: a_start
             idx := idx + 1
         start := idx
 
         loop a_end:
             if idx = len:
-                writeString: "Invalid\n"
-                continue: lines
-            elif not is_number(buf[idx]):
+                p_end := idx
+                break: a_end
+            elif not is_digit(buf[idx]):
+                p_end := idx
                 break: a_end
             idx := idx + 1
-        p_end := idx
+            if idx = len:
+                p_end := idx
+                break: a_end
+
+        if start = p_end:
+             writeString: "Invalid\n"
+             continue: lines
 
-        a := string_to_int(buff, start, p_end)
+        a := string_to_int(buf, start, p_end)
 
         loop op_detect:
             if idx = len:
                 writeString: "Invalid\n"
                 continue: lines
             elif is_operator(buf[idx]):
+                op := buf[idx]
+                idx := idx + 1
                 break: op_detect
             idx := idx + 1
-        op := buf[idx]
+
+        if idx = start:
+            writeString: "Invalid\n"
+            continue: lines
 
         loop b_start:
             if idx = len:
                 writeString: "Invalid\n"
                 continue: lines
-            elif is_number(buf[idx]):
+            elif is_digit(buf[idx]):
                 break: b_start
             idx := idx + 1
         start := idx
 
         loop b_end:
-            if idx = len or not is_number(buf[idx]):
+            if idx = len:
+                p_end := idx
+                break: b_end
+            elif not is_digit(buf[idx]):
+                p_end := idx
                 break: b_end
             idx := idx + 1
-        p_end := idx
+            if idx = len:
+                p_end := idx
+                break: b_end
 
-        b := string_to_int(buff, start, p_end)
+        if start = p_end: # No digits were found for the second number
+            writeString: "Invalid\n"
+            continue: lines
 
-        # We have finished parsing now we can calculate
+        b := string_to_int(buf, start, p_end) # Corrected buff to buf
 
+        # We have finished parsing now we can calculate
         if op = '+':
             writeInteger: a + b
         elif op = '-':
             writeInteger: a - b
         elif op = '*':
             writeInteger: a * b
         elif op = '/':
-            writeInteger: a / b
+            if b = 0:
+                writeString: "Invalid\n" # Division by zero
+            else:
+                writeInteger: a / b
         else:
             writeString: "Invalid\n"
+        writeString: "\n"
 
     exit
-