Fix infinite loop in bsort.dana (#75)

* Fix syntax of powint.dana

Use"=" instead of "==" for equality and moved "var temp is int"
declaration to the beginning of the block. The program still contains a
semantic error so I copied it to the dana/programs-erroneous directory.

* Fix syntax in binarysearch program

Adjusted the bAdded a missing comma in a procedure call, changed
function calls to use () instead of :, specifed a fixed size for the
local array variable declaration, and corrected the assignment operator
from "=" to ":=".

* Fix powint-erroneous.dana

Add actual semantic error in powint-erroneous.dana and highlighted it
with a comment.

* Fix syntax of calculator.dana

Fixed various lexical and syntax errors found in the program.

* Fix syntax of dot_produnct.dana

The nested dot_product function definition was moved before the main
execution statements within main. The equality comparison was changed
from == to =. The begin/end keywords were removed from the bodies of
main and dot_product because they contained declarations, requiring
layout-based blocks instead. Finally, the call dot_product : ... was
changed to dot_product(...) to use the correct function call syntax
within an expression.

* Fix syntax of evenChecker.dana

Use "=" instead of "=="

* Fix syntax of factorial.dana

* Fix syntax of fibonacci.dana

Variable declarations for a and b were moved from inside the else block
to the beginning of the fib function's body.

* Fix syntax of gcd.dana

The 'var s' declaration was moved to the start of gcd, the else block's
begin/end was removed, the equality operator was changed from == to =,
and function calls were updated to use parenthesis () syntax.

* Fix syntax of IntXor.dana

The colon after main was removed, assignment operators were changed from
'=' to ':=', 'return n' became 'return : n', parameter types were defined using 'as'
instead of 'is', and the final 'writeString' call was corrected.

* Fix syntax of knapsack.dana

* Fix semantics of binarysearch.dana

Added return types to the declerations of 'partition' and 'binarySearch'
function definitions. Corrected a type mismatch in the array population
loop by changing the termination assignment from the byte literal '\0'
to the integer 0.

* Fix infinite loop in bsort.dana

The 'if not changed: break' condition was previously inside the
inner loop. This meant it only broke the inner loop, causing the
outer loop to repeat indefinitely if the array was sorted, as
'changed' would be reset at each outer iteration.

* Fix linemarket

Author: orestis42

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
-