Release Notes

The Storm executable is now lowercase on Linux as indicated in the documentation and in scripts.
Fixed a crash in the parser that might occur during error recovery.
Changed how exports are handled to avoid surprises. Previously, exported packages would be imported into the package they were exported from. This is no longer the case.
Experimental libraries for algebraic effects and templates in Basic Storm, as well as an experimental library that allows writing transform functions in Basic Storm.
Added a few extension points to make it easier to write extensions to Basic Storm and the Syntax Language.

0.6.21 (2024-02-24)

Skia rendering is enabled on Linux again after having been accidentally disabled previously.
The Progvis launcher no longer asks Storm to fall back to software rendering since previous cleanup in the UI library made hardware rendering reliable enough. The fallback can still be enabled manually by setting GUI_RENDER_BACKEND=gtk when launching Progvis.

0.6.20 (2024-02-22)

Revised the documentation of Storm. It is now rendered by Storm itself.
Added a new library for parsing markdown-formatted text.
Added support for passing command-line arguments to programs written in Storm.
Added support for character literals to Basic Storm.

0.6.19 (2023-09-17)

Support for MariaDB and MySQL in the database library.
The database library now handles nested identifiers (e.g. table.column) differently, so that the same syntax can be used in Storm. This also allows conveniently handling cases where entire tables are null (e.g. in LEFT, RIGHT, or FULL JOINS).

0.6.18 (2023-09-01)

Changed license of Storm to the BSD license.
Added automatic layout to the tree tool.

0.6.17 (2023-08-11)

Support for 64-bit Windows.
Updated MPS to version 1.118. The new version allows exception handling for 64-bit Windows, and solves potentially degraded performance when working with large hash tables containing pointers.
Improved exception handling for the 64-bit backends.
Minor robustness enhancements in the x64 backend.

0.6.16 (2023-06-22)

Improvements to the C frontend in Progvis:

Support for global arrays.
Better handling of constant variables.
The sizeof operator supports expressions, and not only names of types. It is, however, not possible to use the idiom: int *x = malloc(sizeof(*x)).

General improvements:

Fixed crash when using Variant in the REPL.
Renamed Value::canStore to Value::mayReferTo and introduced Value::mayStore to differentiate related, but distinct, concepts.
Fixed a bug in Basic Storm related to slicing of value types.

0.6.15 (2023-06-11)

Renamed IStream::readAll to IStream::fill to make it more logical.
Removed forgotten sleep statement in Progvis' online UI.
Re-factored the SQL library to ensure that queries are finalized even if not all rows are extracted.
Fixed minor issues in the Emacs plugin file related to computation of column offsets.
SQLite updated to version 3.42.0. The database library uses STRICT tables when using SQLite.

0.6.14 (2023-05-20)

Made the Windows SSL implementation handle zero-sized reads properly. They would previously try to read from the underlying stream if no data was available, which could cause the thread to be blocked due to a lack of data on the network, for example.
Eliminate situations where IO routines erroneously concluded that the end of stream was reached whenever IStream.read() would not return enough data as it is allowed to. Instead, IStream.readAll is used instead.
Fixed a bug in the presentation library when computing bounding boxes for edges.
Fixed scoping issue in the picture environment in the presentation syntax. It was previously not possible to use local variables declared inside the picture as parameters to elements in some situations.

0.6.13 (2023-05-03)

The way global variables are shown in Progvis has been made more compact and hopefully more intuitive.
The SQL library detects and properly handles cases where all results from a query are not needed. This avoids lingering locks and/or memory allocations in the underlying database.

0.6.12 (2023-05-02)

The serialization library is more robust in handling members that exist in the stream, but not in the class.

0.6.11 (2023-04-30)

Fixed a number of bugs in the hash table used to keep track of file descriptors on Linux. This could cause crashes, and lost events from files (sockets, in particular).

0.6.10 (2023-04-27)

Support initializers for member variables, both in the Storm core, and in Basic Storm.
The serialization library utilizes initializers to deserialize members that are missing from the stream. This allows loading older versions of classes, provided any new fields have default values.
Fixed a minor layout issue in the layout code in Progvis.
Fixed an issue with the model checking, when checking programs that contain multiple calls to the same function.

Default initialization of member variables in Basic Storm are

0.6.9 (2023-04-12)

Storm now works properly on systems that use the SEHOP mitigation on Windows. This does seem to be the case on, server editions, and some enterprise setups, for example.

0.6.8 (2023-04-08)

Progvis:

Fixed a bug that caused Progvis to freeze when launching a NO_STEP function as the top-level function in a thread.

Storm:

The releases now support both OpenSSL version 1.1 and Version 3.x. This means that the binary releases work on newer Ubuntu versions as well.
The bat files on Windows now support pathnames that contain whitespace.
Name resolution in Basic Storm has been altered slightly to remove some surprises. The name lookup rules are now documented on the webpage.
Fixed a bug that allowed an empty array to be converted to non-array types.

0.6.7 (2023-04-05)

Added the ability to limit the size of unserialized data in ObjIStream. Useful for limiting the impact of garbage/malicious data being deserialized.

0.6.6 (2023-04-03)

Layout library:

Moved the Cardinal class from presentation to layout along with the Anchor layout.

UI library:

Implemented a ListView control.
Support basic headless operations on Linux (i.e. starting the UI library without an X or Wayland server running).

Core language:

Enums are now serializable.

Basic Storm:

The function-pointer syntax (&a.b) can now auto-deduce parameters when assigned to a Maybe-type.

Progvis:

New online system.
Updated examples.

0.6.5 (2023-03-22)

Fixed a bug in the division and modulo instructions on X86 (both 32- and 64-bit) that caused the /= and %= operators to crash the system.
Division and modulo of bytes are now properly handled as unsigned values.
Fixed a bug in the model checker in Progvis that caused it to fail if a function called the same function multiple times in some situations.
Various improvements to the presentation library.

0.6.4 (2023-01-12)

Fixed a bug in code generation on Windows that would cause programs in Progvis to not compile properly.

0.6.3 (2023-01-09)

Added support for Storm strings in Progvis.
Better location metadata in Basic Storm to improve the visualizations in Progvis.
Fixed a bug in the penalty function in the GLR parser when doing error correction (e.g. during syntax highlighting of incorrect inputs).

0.6.2 (2023-01-04)

Fixed an issue where Progvis did not track writes correctly on Arm.
New instruction in the intermediate representation: test

0.6.1 (2023-01-02)

Fixed bug that made it impossible to step threads in Progvis.

0.6.0 (2023-01-01)

Storm now works on 64-bit ARM systems.
Refactoring of the X64 backend to improve robustness and fix bugs discovered while developing the ARM backend.
The operations for floating-point operations in the IR have been generalized to support ARM64. They were previously modeled after the X87 floating point stack.
Storm now throws exceptions on integer division by zero and invalid memory accesses. Previously, it would just crash.
Added conversions between unsigned integers and floating point types.
Better error messages for cases where a default constructor is missing.
The auto-grader in Progvis now detects livelocks as well.

0.5.21 (2022-11-13)

Fixed a bug in Progvis that would cause threads to step too far in some cases.
Exposed more functionality in the Progvis painter to allow embedding it into other applications.
Made the repaint function in Painter virtual to allow embedding painters into other applications.
Fixed DPI scaling bug of the default font on Windows.
Disallow recursive repaints in the graphics API, which could lead to crashes or strange behavior.
Improved the presentation library to allow interactive components.
Improved the Geometry API.

0.5.20 (2022-07-30)

Support static in front of global variables in Progvis.

0.5.19 (2022-05-05)

Fixed a bug in the C/C++ frontend for Progvis that caused programs without spaces after keywords to fail to compile.

0.5.18 (2022-05-01)

Allow running code from files without the -f flag.
Fixed an issue in the model checher that caused it to merge incompatible states.

0.5.17 (2022-04-30)

Fixed an issue with the model checker in Progvis.
Properly support DPI scaling on Linux in the UI library.

0.5.16 (2022-04-23)

Fixed a bug in Progvis causing some problems found by the model checker to not be displayed properly.

0.5.15 (2022-04-20)

Throw errors from the garbage collector as Storm exceptions most of the time. This allows catching "out of memory" errors, for example.
Fixed a rare crash that could occur when a large amount of memory is allocated on the heap (around 1GB or so).
Protect against integer overflows when allocating data on the heap. Previously, a well-selected size could cause a too small allocation and subsequent crashes/buffer overflows.
Improved the representation of uninitialized synchronization primitives in Progvis.

0.5.14 (2022-04-13)

Fixed two issues when running UI applications on Wayland:

Rendering did not work reliably on Wayland (probably EGL in general) since it is not possible to bind the same context to two threads simultaneously.
Mouse positions were computed incorrectly due to improper handling of coordinate transformations. This bug was only visible on Wayland.

0.5.13 (2022-03-25)

Fixed a bug in the "track errors for statements" in Progvis. Reads were not cleared as expected.
Added sleep functions to Progvis.

0.5.12 (2022-03-21)

Improvements to Storm:

Fixed issue when calling join with lambdas multiple times.
SQL library supports ORDER BY and table aliases.
Lambdas never try to return a reference, which previously caused an error.

Improvements to Progvis (0.5.8):

New version of the online problems. They are now based on separate test- and implementation code.

0.5.11 (2022-01-29)

Improvements to Storm:

Error message when using the Basic Storm syntax (a:b) instead of the Storm syntax (a.b) on the command line.
Fixed a bug when the PinnedSet class had to resize its internal storage.
Added iterators to the Queue class.
Implemented progress bars in the UI library.
Added maps and sets that operate on object identity for class types.

Improvements to Progvis (0.5.7):

New internal data model that allows for more control of the visualization. For example, better layout of objects.
Model checker that automatically finds problematic interleavings.
Organized the progvis_demo directory, and included a button for accessing it in the menu.
Fixed a bug where some memory accesses would sometimes not be displayed properly.

0.5.10 (2021-10-01)

Improvements to Progvis:

Allow moving and resizing the threads, much like regular data.
Added syntax highlighting.

0.5.9 (2021-08-27)

Added a new parser library. This allows pre-compiling fast (but weak) parsers to parse things outside the compiler, for example JSON, HTTP, etc.
Improved the unit testing library. Type conversions in tests now work as in Basic Storm. It is also no longer necessary to have an operator in a test, and to test for exceptions.
Support for package exports. This allows dependencies of a package to be automatically included (e.g. the ui library requires syntax from layout to be visible).
Added shift operators to unsigned integer types.
New name for Str.substr: Str.cut for interoperability with Buffer.
The Regex class can parse Buffer types.
Cleaned up the interface for the Regex class so that it no longer contains any state (match returns Maybe<Str.Iter>).
Maybe<T> is now properly cloned on thread calls.
Support for Maybe<Maybe<T>> for consistency.
Support for Maybe<T> for value types in C++ (with some restrictions).
On Linux, the Cairo GL backend is no longer built by default. The Skia backend is mature enough, and shipping a custom libcairo.so could cause problems on systems with a different version of Cairo.

0.5.8 (2021-06-27)

Added the ability to get a user-local configuration directory for an application. See io.userConfigUrl.
Support for mnemonics and accelerators in the UI library. These are used in Progvis.
Improved how the screen is updated when rendering on Gtk. This hopefully improves stability and the interaction with the Gtk frame clock.
Minor bugfixes when rendering UI with the Skia backend.

0.5.7 (2021-05-21)

Fixed a problem in Progvis when recording solutions.

0.5.6 (2021-05-18)

Improved how Progvis handles globals. Now the values of global variables are restored when the program is restarted. This avoids problems with double initialization of global locks, etc.
Better deadlock detection in Progvis.
Expanded interface of RawPtr to allow better interoperability with Variants.

0.5.5 (2021-04-26)

Added two more atomic operations to Progvis: atomic_read and atomic_write.

0.5.4 (2021-04-23)

Fixed a bug in the Skia backend to ensure that the transform is reset properly on new frames.
Added atomic operations to the C/C++ backend of Progvis (and updated Progvis version to 0.5.2)

0.5.3 (2021-04-12)

Improved pointer-checking in the C standard library inside Progvis.
Improved handling of this parameters in Basic Storm. Since it is possible to create variables and parameters with the name this in Basic Storm, the system needs to keep track of whether such variables are generated by the system or not. Otherwise, it would not be safe to call members on actors through the this parameter without a thread switch in all situations. This changes the API of ValParam inside BasicStorm. See commit 2f06868cf8b5fe3fa591408e55146c00854d432a for details.

0.5.2 (2021-04-10)

Fixed issues with the serialization of Version and how arrays are serialized in C++.
Updated Progvis to version 0.5.0, which includes online features.

0.5.1 (2021-04-08)

The file picker now respects the start path on Linux as well as on Windows. If a non-existing path is specified, some other path is selected (previously the Windows implementation would fail).
Added a new relativeIfBelow function to the Url class, and exposed some previously C++ only members (such as relative).
Added a new function, intersects, to Rect.
Fixed a bug in the serialization of Url (it did not call end when being deserialized).
Fixed a bug causing multiple JOIN clauses to not be recognized by the SQL library.

0.5.0 (2021-04-02)

Fixed a critical bug in os::Sema (central synchronization primitive in the system). If the semaphore was deallocated right after Sema::down returned, the thread running Sema::up might crash when releasing an internal lock. This seems to be readily visible in single processor systems as crashes during repaints in the Ui library. A similar issue was fixed in os::Event.
The Ui thread does not stall when opening dialogs on Linux anymore. Previously, any threads on the Ui thread would be entirely blocked while a dialog was shown.
Allow replacing the contents of a ScrollWindow.
Added RadioButton and CheckButton to the Gui library.
Unnamed UI elements in a layout are now properly added to the window.
The Grid layout now behaves better with elements spanning multiple columns.
General improvements to Progvis.
Reworked the command line interface to be more convenient to use for small projects or testing.
The "async" keyword now does not attempt to copy parameters when it can spawn a new UThread on the same OS thread.

0.4.20 (2021-03-04)

Minor improvements to Progvis.

0.4.19 (2021-02-25)

Major improvements:

Added a join function usable in Storm. For example: StrBuf to; to << join(x, "a"); where x is an array.
Basic Storm automatically casts from T to Maybe<T> when looking for cast constructors. This makes it possible for it to pick cases where both an implicit cast and a cast to maybe are required. This simplifies some cases in C++, where it is not possible to have functions taking both T and Maybe<T> (they are the same in C++).
Improved the SQL library. It is not possible to have queries type checked at compile time.
Added a new SSL library to allow encrypted communications from Storm (for example HTTPS).

Bugfixes:

Don't crash when copying empty StrBuf (see a8322aa401b65c3915886e255e32a015b01d1682)
Fixed a crash when throwing exceptions from dll:s on Windows (see 37ff2cda00d0f23dda86b3913f5e69616f3588f1)
Fixed a problem in the MPS integration (see 6cbf90fb8c32f7ef8c9fa1d48dea6615dac4ffb2)
Fixed a crash when returning (reference) local variables in Basic Storm.

0.4.18 (2021-01-12)

A new rendering backend is available on Linux: Skia. This backend preforms better than the previous Cairo GL backend. If the new backend causes problems for some reason, see the documentation for the UI library on how to select which backend is used.
The MPS garbage collector was updated to the latest version. It is now covered by a more liberal, BSD-style license.

0.4.17 (2021-01-04)

Fixed a minor issue when using the Cairo OpenGL rendering on Linux.

In some cases (for example in the image viewer), images would disappear after resizing the window. Commit 3cf4a95505e82f063fad66edf7733458bfb05ba1 fixes this.

0.4.16 (2020-12-22)

Fixed a bug in the stack workaround that caused crashes in rare cases. See commit e5bc0de85eb30ba53e50fda9dc28d21ecb76abdc for details. This only affects the Linux builds.

0.4.15 (2020-12-20)

Fixed a bug in the GUI library. Changing properties of a brush would not be reflected if the brush had been used at some point earlier.

0.4.14 (2020-12-14)

Major cleanup in the GUI library. Now, the rendering is able to support different backends more easily (not only Direct 2D and Cairo). Added a workaround for a bug in a graphics driver on Linux that caused Storm to crash when using hardware accelerated rendering. See the documentation on the GUI library for more details.

0.4.13 (2020-09-04)

Updated the rendering system on Linux to allow selecting between different backends.

By default, Storm now utilizes the same background that Gtk+ uses, which is usually hardware accelerated in some way (for example, on X11, the Cairo manual states that the XRender extension is used if it is available). This has the benefit of improving the copying from the rendering buffer to the window, as the buffers usually reside in the same location. It also avoid crashes when running OpenGL against certain drivers. A software fallback is also available.

It is possible to select which backend to use by setting an environment variable, as described in the documentation for the GUI library, if OpenGL rendering is still desired.

0.4.12 (2020-09-04)

Fixed a bug that caused a resource leak when spawning UThreads in certain circumstances.

0.4.11 (2020-07-05)

The GUI library is DPI-aware on Windows.

0.4.10 (2020-06-28)

Progvis is now able to track reads and writes to memory to detect data races.
Improved the C++ front-end used by Progvis.
Performance improvements in the parser, mainly the creation of parse tables is faster.
break and continue may be used to end a unless block inside a loop.

0.4.9 (2020-04-27)

All named objects may now contain a reference to the source where that entity is defined.
All entities defined in C++ contain a reference to where they are declared.
The help text shows the source location of the entity.
Nested types declared as private in C++ are private in Storm as well.
The system attempts to print a stack trace before crashing due to a segmentation fault.

0.4.8 (2020-04-22)

Added default constructor to Bool for consistency with other built-in types.
Improved pointer visualizations in the program visualization tool.
Allow NO_STEP in the C/C++ visualization to control what the visualization shows.

0.4.7 (2020-04-20)

break and continue works inside for-each loops in Basic Storm.
unsafe:RawPtr:asObject now returns Maybe<Object>.
Improvements to the program visualization.

0.4.6 (2020-04-16)

Fixed a bug in the queue implementation that could cause out of bounds writes.

0.4.5 (2020-04-15)

Minor improvement in the program visualization tool.
Added createDir to the Url class.
Disallow creating "void" variables in Basic Storm. This would previously crash the system. Now an error is generated instead.

0.4.4 (2020-04-05)

Added a ~ separator to the syntax language.
Improvied the documentation on the syntax language and syntax transformations.
Robustness improvements to substr inside String.
Made sure that the parent window gains focus after a modal child is closed on Windows.
Improvements to the program visualization framework.

0.4.3 (2020-03-08)

Improvements to the UI library:

Support for adding menus to windows.
Support for modal dialog boxes.
Support scrolling window contents.
Implemented standard file picker interfaces.
Implemented a standard "about" dialog in the UI library.
Minor bugfixes.

Improvements to Basic Storm:

Allow using absolute names inside the named{} syntax. E.g. named{:foo}
Implemented the continue and break keywords.

Improvements in the core:

Fixed a bug where accessing the Compiler thread from other libraries could cause crashes.
Allow static member functions to use the EnginePtr interface, just as free functions are able to do.
Cleanup of local variables in generated code is the same during normal termination as during exception cleanup.

0.4.2 (2020-02-08)

Re-worked how the code generation backend handles cleanup. Now, each variable may be activated at any point in the listing, even if it is not in the topmost block, which greatly simplifies some aspects of code generation on higher levels.
Basic Storm now encloses each statement in its own block. This means that temporaries created by one statement are destroyed before the next statement is executed rather than at the end of the block.
Added support for declaring enums in Basic Storm.
Previously, when using the assignment syntax for variable initialization in Basic Storm, regular constructors could be used to perform the initialization, even if not marked as "cast constructors", which is required for other cases of type conversion. Now, assignment initialization follows the same rules as for regular assignments and type conversions as expected.
Support chaining saveTrace for exceptions, so that it is possible to do throw SyntaxError(...).saveTrace to add a stack trace to exceptions that don't normally capture a trace.
Improved error reporting for the syntax language.

0.4.1 (2020-01-28)

Added named{} as a way to refer to the current package using the lang.bs.macro extensions to Basic Storm.
Improved error reporting for the built-in regex engine. Previously, errors were silently ignored which sometimes resulted in surprising behavior.
Fixed a bug causing Array.insert to misbehave when working with arrays of class- or actor types.

0.4.0 (2020-01-27)

Added support for exceptions in the code generation backend. Pointers to Storm objects can be caught regardless of whether they were thrown from C++ or not.
Added support for exceptions in the Basic Storm frontend.
Small improvements to the inline-asm language (memory references and lea were added).

0.3.0 (2020-01-05)

Added another experimental GC, the Storm Memory Manager, SMM.
Separated the GC part of the compiler out to a separate library to improve modularity. This also helps in the future when generating stand-alone binaries.

0.2.39 (2019-12-30)

Fixed an issue causing finalizers to not be executed properly.

0.2.38 (2019-12-28)

Implemented a small unit-testing framework for Basic Storm. See the "Libraries" section of the documentation for details.
Fixed a bug where unused results from calls to other threads would cause an assertion.
Added an experimental SQL library and language extension by David Ångström, Markus Larsson, Mohammed Hamade, Oscar Falk, Robin Gustavsson, Saima Akhter. See the "Libraries" section of the documentation for details.

0.2.37 (2019-11-07)

It is now possible to use abstract functions in C++ classes exposed to Storm.
Fixed a potential issue when thread objects were copied before they were properly initialized. This could fix some seemingly random crashes when working with the UI library.

0.2.36 (2019-08-01)

Finalizers are not always executed on new UThreads, which could cause out of memory conditions in some cases. Now finalizer execution is batched, drastically reducing the risk for running out of memory. See commit 14946bf17b5fd74b62fd5b561a133042dbfb861b for details.
New debug call: debug.threadSummary that shows a stack trace of all running threads in the syste.
New graph library for the presentation library.

0.2.35 (2019-06-06)

Exposed more of the interface of the newly introduced Condition class to Storm, and merged the concept of Condition with WeakCast.
unless in Basic Storm now supports arbitrary conditions, just like the if statement. Previously, only weak casts were supported.

0.2.34 (2019-06-05)

The iter member of WeakSet<T> now returns a proper iterator instead of void.
The range-based for loop in Basic Storm supports iterators from WeakSet<T> as well.
Weak casts are allowed in the while statement. Previously, only the if statement supported weak casts.

0.2.33 (2019-02-06)

The GUI library supports Wayland. There may still be some quirks and inefficiencies left.

0.2.32 (2019-01-17)

Added serialization to Storm, explained in detail in the documentation.
Streamlined the handling of decorators in Basic Storm, and added the ability to define custom decorators for types.
Fixed a bug that caused memory corruption in rare cases. See commit 926d4251b211a846bb20064fc221979b979454ad and 517fe86e3ebdf8aca92679998646cda8ead0c402 for details.

0.2.31 (2018-12-23)

Initialization order inside init blocks in Basic Storm now initialize members in the order specified inside the init block rather than the order they appear in the class.
Initialization of inherited classes can be performed in two separate steps, first calling the constructor of the super class and then initializing the current class. This allows accessing this to access the parent class after the constructor of the superclass is called but before the object is fully initialized.

0.2.30 (2018-12-09)

StrBuf supports formatting floating point numbers.

0.2.29 (2018-12-06)

Fixed an issue where using a locale with a comma as a decimal separator would cause compilation errors for float literals on Linux (which could happen after initializing Gtk+).

0.2.28 (2018-12-03)

Added support a limited form of context-dependent grammars to the parser. See the documentation on the syntax language for details.
Make sure that Storm does not crash when trying to create a global variable with the type void.

0.2.27 (2018-11-10)

Added mouse support to the Gui library.
Improved key handling in the Gui library.
Fixed string escaping in Basic Storm. Previously, " and $ were not unescaped properly.
Unary - has lower priority than literals in Basic Storm, meaning that -1 is auto-convertible to a Float for example.
Replaced the old presentation library with a new one.

0.2.26 (2018-10-14)

Calling randomAccess on a IStream that is not an RIStream provides a LazyMemIStream which buffers the original stream as needed in order to provide random access.
Fixed an issue where elements returned from a WeakSet iterator could refer to finalized objects. See commit 0e813305ad89890a53af931482b06e29a5fd46f7 for details.
Better error messages when a function attempts to override another function with an incompatible return type. Previously, this was silently ignored, and the functions were not considered compatible. Now, an error message is emitted instead, which makes it easier to spot mistakes.
Packages now look for a file named README that is expected to provide an overview for the entire package. The contents of this file are shown in the help for the package, just like comments before functions and types.
A library for generating PDF files was added as ui.pdf. The library provides a Graphics object that draws to a PDF page in the same manner graphics is drawn to the screen.

0.2.25 (2018-10-08)

Expressions with unary operators in Basic Storm now work as expected. Previously -x + y would not compile.
Iterators for the core.Map class are now working again. Previously, begin and end did not return an iterator, but returned void instead.
Functions taking an EnginePtr as their first parameter in C++ would sometimes cause the system to crash on X86-64.

0.2.24 (2018-09-29)

Bugfixes in the code generation:

An error in the size of a function's stack frame caused the X64 backend to corrupt variables from time to time.
Small structures of sizes not natively supported by the CPU (eg. 2 bytes) are now handled properly.

0.2.23 (2018-09-26)

Basic Storm now supports numeric literals in hexadecimal and bitwise operators on unsigned types. Fixed a bug that caused a crash when the neg op-code was used with a 64-bit operand.

Proper support for static functions, both inside Storm, in C++ and in Basic Storm.
More consistent naming of streams in core.io.

0.2.22 (2018-08-31)

Improved message when the user types help in the Basic Storm repl.
Minor cleanups of the implementation of pattern blocks.
When using the language server for syntax highlighting, importing non-existing packages with use statements no longer confuses the highlighting of the rest of the file.
Made Frame.size assignable.

0.2.21 (2018-08-01)

Moved the flag used for marking constructors usable for automatic type casts from Named into Function.
Added missing functionality regarding Double in the standard library and improved the support for doubles in Basic Storm.
Added the ability to suffix numeric literals with a letter in Basic Storm to indicate the desired type of the literal. For example 10i is always an Int, while 10n is always a Nat.

0.2.20 (2018-07-30)

Global variables are initialized lazily by default. Initialization in Basic Storm is still eager, but delayed until after all functions are loaded, so that initialization may use functions declared in the same package without issues.
Improved robustness of the pattern syntax. Previously, the pattern syntax assumed that the parse tree would be evaluated in the same order as syntax transformations would evaluate all nodes. However, for more complex constructs (such as lambda functions) that is not the case. Therefore, the pattern syntax now keeps track of which nodes corresponds to which parameters to eliminate the issue.

0.2.19 (2018-07-30)

The REPL in Basic Storm now supports creating variables interactively. Variables are either declared as regular variables at the top-level, or using assignment. Variables can be listed using variables and deleted using del <x>.
The REPL in Basic Storm has a new command help that lists some important commands in the REPL.
The function pointer syntax in Basic Storm (&foo(X, Y)) now evaluates to a function pointer taking the exact types specified rather than the types in the declaration of the function. This means that the type of such expressions is much easier to reason about. This also allows creating function pointers with more restricted types than the original function, which is sometimes necessary since the function pointer type is not implicitly convertible in any way, even though such conversions would be legal.
The function pointer syntax in Basic Storm supports automatic deduction of parameter types in some cases, just like lambda functions. This makes it possible to omit the parameter list in many cases, for example x.sort(&compare).
Fixed a bug in the allocation of type descriptors in the GC. This bug caused too much memory to be initialized, which in some cases corrupted important data structures used by the GC.

0.2.18 (2018-07-19)

Added support for global variables.

0.2.17 (2018-07-11)

Added tests for inspecting the raw parse tree from Storm. This was previously used in libraries (such as patterns), but not tested in the test suite.
Improved the benchmarks in the benchmark package.

0.2.16 (2018-06-19)

Basic Storm now resolves parameters and return types to free functions properly. Previously, free functions were unable to use types declared as file private for parameters or return types since the wrong scope was used during resolution of these types.
The type lang.bnf.CustomDecl is now recognized as a possible subclass of lang.bnf.FileItem. The CustomDecl itself is just a hook that allows arbitrary code to be executed when it is added to a lang.bnf.FileItem, but this allows more complex extensions to be written for the syntax language, for example the one found in test.bnf.

0.2.15 (2018-06-13)

Revised visibility of members in BSFunction and BSCtor, which caused the layout extension to not compile.

0.2.14 (2018-06-08)

Robustness improvements for hash tables containing actors (where hashes depend on the object identity). Previously, some object identities were cleared from the location dependency object even if they were still needed.

0.2.13 (2018-06-08)

The lambda functions in Basic Storm now supports capturing variables from the surrounding scope.
Memory usage should be reduced slightly, as the syntax trees for compiled functions in Basic Storm are no longer kept around after they have been used.
Iterators for core.Set<T> were broken. Now they are working properly.

0.2.12 (2018-06-06)

Basic Storm now supports lambda functions. Lambda functions are not yet able to carry any state.
Improved robustness of parameter handling in inlined functions (see commit 2f27e60a2dcc6a36302850f55b15d247f1982bcc for details).
Slight performance improvements, mainly during compiler startup.

0.2.11 (2018-05-07)

The type Maybe<T> (used for T? in Basic Storm) is now extended to support T being a value type in addition to T being a class or an actor. For example, it is now possible to use Maybe<Int>.

0.2.10 (2018-04-29)

Basic Storm supports the keywords abstract, final and override in order to provide additional help to programmers. Corresponding support is also present in Storm itself in the form of flags that can be set on specific functions.

0.2.9 (2018-04-16)

Support for TCP sockets is added to the standard library in the package core.net. The IO system is also improved to properly handle the asynchronous nature of sockets (eg. closing a socket while a read operation is in progress). Furthermore, it is no longer possible to copy streams based on handles from the operating system, as that would cause race conditions and possibly break the IO system.

0.2.8 (2018-03-31)

It is now possible to create syntax extensions to the syntax language itself.
Improved the formatting options for the StrBuf class. It now supports both left and right alignment of output with a specified width.
Basic Storm supports interpolated strings, such as "Hello ${name}". These expand to regular string concatenation using the # operator.

0.2.7 (2018-03-25)

A library for layout is now included with Storm, including a small domain specific language for specifying layouts. The library is integrated with the UI library to simplify creation of user interfaces.

In addition, the following improvements are included:

Allow nested type definitions in Basic Storm.
Updated the semantics of function overloading to reduce ambiguity. See the documentation on "function overloading" for more details.
The help command in the Storm REPL will load any entity inspected so that all members are listed.

0.2.6 (2018-03-09)

It is no longer possible to accidentally share data between threads by reading/writing variables inside actors. Previously, Basic Storm allowed this without proper synchronization and copying, which made it possible to accidentally create shared data structures (of non-actor types), which in turn broke assumptions made by the threading system. From now on, such accesses are synchronized as if they were done by calling a member function, and thus copies are being made. This does, however, mean that it is no longer possible to assign directly to these variables. Assignment functions can be used to circumvent the problem. See the documentation for further details.

On Linux: the GUI library uses a different approach when displaying content rendered using OpenGL. This approach is more cooperative towards Gtk+, but is slightly more demanding. The problem with the old approach was that some configurations experienced regular freezes of up to 0.5 s. This seems to be resolved now.

0.2.5 (2018-03-07)

Added assignment functions to Basic Storm (including some support in Storm itself).
Updated the documentation system to support DocNotes without types (used for displaying which functions are assignment functions).
Allow clicking on visibility modifiers in the Emacs documentation viewer to go to the documentation for the corresponding type.

0.2.4 (2018-03-03)

Storm includes a built-in help system. All objects in the name tree can refer to their documentation. The documentation is loaded from disk when it is required rather than being kept in memory all the time. In Basic Storm and C++, documentation is generated from the source code by examining the comment directly preceding the corresponding declaration, much like Doxygen and Javadoc. However, no special comment syntax is needed at the moment.

The documentation can be accessed from the Basic Storm REPL using help core:Str, or from the Emacs plugin using M-x storm-doc. The Emacs plugin also works properly on Linux now.

0.2.3 (2018-02-04)

Improved handling of comparisons throughout Storm and added new functionality to the standard library.

The equals function in Object and TObject is removed. Implement == for the relevant classes instead. This means it is no longer possible to compare two unrelated objects (eg. Str and Map<Str>) for equality since the operation itself does not make sense.
The hash function is no longer present in Object and TObject, in order to be consistent with the behavior ==.
Array<T>.sort() and Array<T>.sorted() were added. These functions are only present when T contains the function Bool <(T, T), which is used to compare elements. Optionally, a Fn<Bool, T, T> can be provided to the functions to specify the desired ordering.
A priority queue core.PQueue<T> was added to the standard library. Similarly, the priority queue uses Bool <(T, T) for comparisons.
Basic Storm allows operator names for function definitions in order to allow operator overloading.
Basic Storm automatically falls back on defined operators in case the desired operator is missing. Eg. if a > b is not present, b < a is called instead.
Basic Storm properly resolves expressions like 1 + 0.3.

0.2.2 (2018-01-27)

All named objects are not always public. It is now possible to associate a Visibility object with each named object to restrict access to them. This is used to implement the keywords public, protected, package and private in Basic Storm.

0.2.1 (2018-01-18)

Improved stack traces and stack handling on Windows. Previously, only functions that used exception handling were shown properly in stack traces (by core:debug:stackTrace). This release fixes that issue by making stack unwinding more similar to the table-based approach used in the Linux version.

The Linux release now includes libpng and libjpeg, so that a system with incompatible versions do not cause the graphics or the ui module to fail to load.

0.2.0 (2018-01-15)

The GUI and Sound libraries are now available for Linux as well as Windows. Code using these libraries should behave mostly the same between the two platforms, even though there are still differences between the platforms. Some functionality is not yet complete, and some parts could use some refactoring.

In addition to porting the libraries to Linux, support for more file formats have been added to the Sound and Graphics libraries. Now, mp3 and ppm files are supported in addition to ogg, flac, wav, png, jpeg and bmp.

0.1.3 (2017-12-08)

Stability improvements in the threading system for all platforms.

During the initialization of a user level thread, the garbage collector could erroneously try to access the not yet initialized thread which caused a crash.
During user level thread setup (during what is called detours in Storm), the garbage collector could erroneously believe that two user level threads were active at the same time, leading to crashes or unexpected behaviors.

0.1.2 (2017-12-06)

Stability improvements for Linux.

Fixed a threading issue in the IOCondition implementation on Linux. Previously, there was a small window right after a thread woke from sleep where the IOCondition could enter a state where it ignored 'signal' notifications but always blocked any threads calling 'wait'. Since this primitive is used by the threading system in Storm, this could cause deadlocks any time threads communicated with each other.

0.1.1 (2017-12-02)

Creating and using a core:lang:Parser does not crash anymore. See commit 985481df2253eb1d18506c515875e5908bc95273 for details.
Shared libraries on Linux does not crash when using the C++ streams (cout etc.). See commit 822e7d092ce96ac472aaffdd526d5450c6bb39b4 for details.
More bullet-proof handling of user thread startups (the mechanism called detours). Previously, this could have been an issue when using types with complex copy-constructors. See commit c06071ba0e322bb9dfb4f985cf6be87a17ceadcf for details.

0.1.0 (2017-11-14)

First release with a version number!

Note that the Linux version of Storm does not yet include the sound and gui libraries available on Windows.