Release 3.3.0

Author: cardillan

CHANGELOG.markdown

@@ -4,24 +4,28 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project now adheres to [Semantic Versioning](https://semver.org/).
 
-## 3.3.0 - Future release
+## 3.3.0 - 2025-04-11
 
 ### Fixed
 
 * Fixed some command-line options not having an effect in the command-line tool ([#231](https://github.com/cardillan/mindcode/issues/231)).
 * Fixed wrong handling or hoisted set instruction setting up return address in subsequent loop unrolling ([#234](https://github.com/cardillan/mindcode/issues/234)).
 * Fixed optimizations removing the `spawn` instruction when the output value was not used ([#236](https://github.com/cardillan/mindcode/issues/236)).
 * Fixed Jump Optimization not performing the optimization in unrolled loops.
+* Fixed error in compile-time evaluation of an expression involving a character literal ([#240](https://github.com/cardillan/mindcode/issues/240)).
+* Fixed incorrect compile-time evaluation of some logic IDs ([#242](https://github.com/cardillan/mindcode/issues/242)).
+* Fixed possible incorrect handling of arguments passed to the `print()` and other output functions ([#243](https://github.com/cardillan/mindcode/issues/243)).
 
 ### Added
 
 * **Breaking:** new `ref` keyword was added to the language. Code that uses this keyword as a function or variable name will not compile and the variable or function will have to be renamed.
 * Added the [`char()` function](doc/syntax/SYNTAX-4-FUNCTIONS.markdown#the-char-function). The function returns the ASCII value of a character at given index from a string value using the `read` instruction, as supported in latest BE version.
 * Added support for invoking properties and the `sensor` functions on string values to support latest BE Enhancement of sensing string lengths using `@size`. 
+* Added the [`strlen()` function](doc/syntax/SYNTAX-4-FUNCTIONS.markdown#the-strlen-function) returning the length of a string determined at runtime.
 * Added support for compile-time evaluation of the `length()` function, allowing to specify offsets relative to the end of the array in subarrays (e.g. `array[0 ... length(array) - 1]`).
 * Added compile-time evaluation of either stable, or all built-in numerical variables (such as `@pi` or `@unitCount`).
 * Added a new remarks mode, `comments`, to compile remarks as mlog comments (`# comment`).
-* Added support for generating boundary checks for explicitly declared external arrays.
+* Added support for generating runtime boundary checks for explicitly declared external arrays.
 * Added new `printLines()` function to the `printing` library. The function prints each of its arguments on a new line. 
 * Loop Hoisting optimizer enhanced with an ability to optimize instructions setting up return addresses of function calls. 
 * Added handling of numerical literal values unsupported by Mindustry Logic version 7 and earlier (namely, `-2147483648`).
@@ -44,6 +48,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 
 * **Breaking**: underscores in multi-word command-line options were changed to hyphens.
 * The metadata used by Mindcode compiler and processor emulator now correspond to the compilation target. Schemacode still uses the latest version of the metadata for both building and decompiling schematics.
+* Compile-time evaluation cache is cleared when exiting function context. This forces primarily the `length()` function to be reevaluated in each call to an inline function, as its value depends on the actual arguments passed to the function. 
 * Improved optimization of jumps by making multiple passes over jumps-related optimizers, up to the optimization passes limit.
 * Volatile built-in variables used an upper or lower bound in a ranged for-loop statement are used directly in the condition, without storing them in a temporary variable.
 * Stripped unnecessary `.0` distinctions from local variable prefix.

README.markdown

@@ -18,10 +18,10 @@
 
 **Schemacode**, an extension built over Mindcode, is a specialized definition language designed for creating a complete Mindustry schematic from a text file. [Schematics builder](doc/syntax/SCHEMACODE.markdown) compiles these definition files directly into Mindustry schematics, either into binary `.msch` file, or into the text representation. Processors can be included in these schematics, complete with the code (specified either in Mindcode or mlog) and linked blocks.
 
-## Mindcode Syntax
-
 > [!NOTE]
-> To use new Mindustry Logic capabilities from the new [Mindustry 8 pre-release](https://github.com/Anuken/Mindustry/releases/tag/v147), use `#set target = 8;` in your code. 
+> To use new Mindustry Logic capabilities from the new [Mindustry 8 pre-release](https://github.com/Anuken/Mindustry/releases/tag/v147), use `#set target = 8;` in your code. [Here](/doc/syntax/MINDUSTRY-8.markdown#new-functionality-in-mindustry-8) is a summary of the new Logic content and corresponding Mindcode functionality.
+
+## Mindcode Syntax
 
 Please refer to the [documentation](doc/syntax/SYNTAX.markdown) for a complete description of Mindcode syntax. You can also use the code examples in the web application to get familiar with Mindcode.  
 
@@ -34,16 +34,18 @@ See [issues](https://github.com/cardillan/mindcode/issues?q=is%3Aissue%20state%3
 The most important recent changes to Mindcode include:
 
 * Language features
-  * Support for [symbolic labels in generated mlog code](/doc/syntax/SYNTAX-5-OTHER.markdown#option-symbolic-labels).
+  * Passing arguments (including arrays) to inline functions by reference.
   * Specific syntax for [mlog keywords](doc/syntax/SYNTAX.markdown#mlog-keywords).
   * Support for passing mlog keywords as arguments to inline functions.
-  * External and internal arrays (`@counter` arrays).
+  * External and internal arrays (`@counter` arrays), including basic array optimizations.
   * Expressions in string interpolation: `print($"Sum: ${a + b}.")`.
   * Support for color literals: `%00ffff80`.
   * Prefix/postfix increment/decrement operators: `i++`, `--j`.
   * Redefined [strict and relaxed syntax modes](/doc/syntax/SYNTAX.markdown#strict-syntax).
   * Variable declaration (optional in relaxed syntax, compulsory in strict syntax).
 * Basic functionality
+  * Support for [symbolic labels and indentation in generated mlog code](/doc/syntax/SYNTAX-5-OTHER.markdown#option-symbolic-labels).
+  * Using Mindustry Logic metadata corresponding to the target selected for compilation.  
   * Significant improvement in reporting error messages generated during compilation.
   * A built-in [library of system functions](doc/syntax/SYSTEM-LIBRARY.markdown).
   * Ability to inject the mlog code to Mindustry processors via the [Mlog Watcher mod](doc/syntax/TOOLS-MLOG-WATCHER.markdown).
@@ -52,7 +54,7 @@ The most important recent changes to Mindcode include:
 * Mindustry Logic 8
   * Complete support for the Mindustry Logic in the latest [Mindustry BE version](/doc/syntax/MINDUSTRY-8.markdown).
   * Full support for [remote functions and variables](doc/syntax/REMOTE-CALLS.markdown).
-  * New `printchar` instruction and character literals.
+  * New string/character based instructions and character literals.
 
 See [changelog](CHANGELOG.markdown) for a comprehensive list of changes.
 

compiler/src/test/resources/info/teksol/mc/mindcode/tests/processor/executes-sort-variables.log

@@ -1,7 +1,7 @@
     29 instructions before optimizations.
      1 instructions eliminated by Dead Code Elimination (4 iterations).
      1 instructions eliminated by Single Step Elimination (6 iterations).
-    14 instructions eliminated by Data Flow Optimization (3 passes, 12 iterations).
+    14 instructions eliminated by Data Flow Optimization (3 passes, 13 iterations).
      2 instructions eliminated by Loop Unrolling (4 iterations).
      1 loops unrolled by Loop Unrolling.
     11 instructions after optimizations.
@@ -212,28 +212,38 @@ Modifications by Iterated phase, Data Flow Optimization, pass 1, iteration 5 (-1
     16 label *label3
 
 Modifications by Iterated phase, Data Flow Optimization, pass 2, iteration 1 (-1 instructions):
- 
-     3 op mul :test:step p 2
+     0 set p 1
+     1 assertflush
+     2 label *label8
+-    * op mul :test:step p 2
++    3 op mul :test:i p 2
      4 label *label9
      5 label *label12
 -    * set :test:i :test:step
-+    6 set :test:b :test:step
-     7 op mul :test:step p 4
-     8 label *label13
--    * set :test:b :test:i
-     9 label *label16
-    10 set :test:i :test:step
-    11 op mul :test:step p 8
+     6 op mul :test:step p 4
+     7 label *label13
+     8 set :test:b :test:i
 
-Modifications by Iterated phase, Data Flow Optimization, pass 2, iteration 2 (-2 instructions):
+Modifications by Iterated phase, Data Flow Optimization, pass 2, iteration 2 (-1 instructions):
      0 set p 1
      1 assertflush
      2 label *label8
--    * op mul :test:step p 2
+-    * op mul :test:i p 2
 +    3 op mul :test:b p 2
      4 label *label9
      5 label *label12
--    * set :test:b :test:step
+     6 op mul :test:step p 4
+     7 label *label13
+-    * set :test:b :test:i
+     8 label *label16
+     9 set :test:i :test:step
+    10 op mul :test:step p 8
+
+Modifications by Iterated phase, Data Flow Optimization, pass 2, iteration 3 (-1 instructions):
+ 
+     3 op mul :test:b p 2
+     4 label *label9
+     5 label *label12
 -    * op mul :test:step p 4
 +    6 op mul :test:i p 4
      7 label *label13

compiler/src/test/resources/library/outputs/arrays-experimental.log

@@ -5,7 +5,7 @@
      9 instructions eliminated by Jump Optimization (2 passes, 7 iterations).
     19 instructions eliminated by Single Step Elimination (4 passes, 11 iterations).
   1729 instructions eliminated by Expression Optimization (3 passes, 5 iterations).
-   209 instructions eliminated by Data Flow Optimization (11 passes, 56 iterations).
+   209 instructions eliminated by Data Flow Optimization (11 passes, 55 iterations).
      7 instructions eliminated by Loop Optimization (5 iterations).
      7 loops improved by Loop Optimization.
   1972 instructions added by Loop Unrolling (19 iterations).