Welltype changelog

2024.01.29. (r7255)

Towards Tomb2/WTB4:
- Allocate WTB3 objects in a forward-compatible way with WTB4: introducing symtabs, and remove the memory-wasting separate lists for function/type/etc; thus the program loader is WTB4-ready
- Progress with the headers to prefix WTB3 constants, i.e. WTBST_CODE -> WTB3ST_CODE
- Split wtruntime.h into smaller pieces: add wtb3.h, is-tomb.h, sym.h, hashalg.h
- Add wtb4.h, although the WTB4 ABI is not 100% completed yet
API changes:
- VM-internal type info storage is changed, it is now independent from the WTB3's representation -- note that, this does not affect the user code, except that WTT_VOID is removed
- VM-internal type info is stored in wt_typeid types instead of plain wt_uint32_t/wt_u32, and this should be used in user codes as well
- wt_function is removed, and replaced by struct wtr_function, which is a user-allocatable structure, and this spares memory in the VM and on the user-side as well -- despite of this, the API remains the same
- The old wt_u8, wt_i8, ... wt_f64 types are considered obsolete, and they are replaced by wt_uint8_t, wt_int8_t, .. wt_float64_t -- however the old names are still available, but will be removed from the API after further notice
- Add wtrVMLoadProgramVM() function, which is the same as wtrVMLoadProgram(), except this new function loads program data from VM memory instead of system memory -- this allows more flexibility on system with small amount of RAM
  - Note that, WTB3 does not support in-place execution, thus the program code still need to be loaded into the VM memory
  - WTB4 will overcome on this restriction
- Add wtrVMSeedRNG() function to seed the VM's internal Pseudorandom Number Generator, because on embedded systems it is not possible to seed the PRNG in a good and portable way
Remove shebang support: it was not widely used, and it conflicts with the embedded use
VM memory usage optimization (especially for systems with small amount of RAM): allocate VM routines in a single block, which can use significantly less VM memory
Store external function info outside the VM addressable space, thus sparing some VM memory, and avoiding conflicts with function-pointer size differences and with symtab implementation
Increase robustness by checking whether VMMU acquire was successful or not, and returning an error if not
The program loader refuse to load programs that have one or more symbols with name longer than WTR_MAX_SYMNAME_LEN (63 characters, excluding the terminating zero) -- this is a mandatory change for the smaller VM memory footprint and simpler/faster program loader
wtc: limit identifier length to WTR_MAX_SYMNAME_LEN

Changes in v0.11.0

2023.05.13. (r6849)

VMMA (which was designed for memory-rich systems) has been replaced with VMMU (which is designed for small-memory systems)
- Added the API-only xstring pseudo-type to improve performance (some strings are not needed to be read through VMMU)
- Strings and sequences in wt_value are now passed via VMA (virtual memory address)
- Notable API change: "profile" has been renamed to "VM", thus numerous API functions has different name
Documentation improvement: configure options are now summarized in doc/INSTALL
API change: register hash functions externally (defaults are in libwtref); this spares 16 KiB of code flash on MCU
Install headers into welltype/ instead of wtruntime/
Remove UTF-8 conversion microprograms, these had no actual use, since character type is 8-bit (and ASCII-only); removed microprograms will raise BadProgramAccessException
It is now possible to allocate stack externally (a user-defined VMA can be passed as stack, thus, a fixed VM accessible area can be assigned without heap management)
VM code size improvements: numerous instructions and microprograms are compacted to decrease the compiled code size, sparing 6 KiB of code flash on MCU
Bugfix: behavior of SARL instruction was incorrect, it behaved like SHRL

Changes in v0.10.5

2023.03.19. (r6489)

Bugfixes:
- Fix a bug in the loader: number of "user threads" was not checked, although the wtc did not generated other type of binary
- Fix a bug in the runtime: when the context's value array was resized to 0, a false positive error was reported -- only runtime library users could experience this
Runtime library improvements:
- Introduce the wtrContextCleanup() function, which purpose is to clean up the context: any remaining object in TOS will be purged
- Allocate type info structures from system memory instead of VM memory
- Refine loader's error codes: use more specific error code where reasonable
- Split wtruntime/error.c: this can be useful for much smaller binary output in some cases
Towards Tomb2/WTB4: Tomb opcodes in wtruntime.h got a prefix
Cleanup: file2src is not used anywhere, it has been removed

Changes in v0.10.3

2023.02.10. (r6433)

Efforts to make the runtime more compact and more portable:
- Allocate internal objects with alloc_func() instead of with VMMA -- this is also a security improvement, because the Welltype program can no longer modify those objects
- Keep internal objects in lists instead of complex tree structures, thus the runtime uses much less memory and requires less code to execute
- 32-bit and 64-bit float can be individually disabled at configure-time, thus the VM will be much smaller -- disabled opcodes and microprograms will raise exception
- Remove explicit printf()s from the program loader, and replace it with an ops structure -- this allows the runtime to be smaller, and even more portable
- As a result, the VM was able to load and execute a 17 KiB large Welltype program on an STM32F411CEU6 microcontroller
Runtime library improvements:
- New functions: wtrContextSetUserPointer(), wtrContextGetUserPointer() and wtrProgramGetMetadata()
- Add missing documentation comments to the context API
It is now configurable what to build (using the With), and what to not build (using the Without)
- Possible values are: ALL, wtc, wt, wtparser, readwtb, libwtref, wtruntime
- Example: ./configure Without=ALL With=wtruntime -- this will disable all components, then enable wtruntime and its dependencies
Manual improvements:
- Add missing stat() and fstat() functions
- The access() function was mistakenly displayed as faccess()
Fix crashes in wtc caused by C++ exceptions

Changes in v0.10.0

2023.01.13. (r6261)

Concept change: Welltype now targets small runtime footprint and small virtual machine size -- small enough to fit in an MCU.
Introduce context in the C API, which replaces the former threads mechanism.
Runtime environment does not require OS thread and semaphore support.
Introduce libwtref, which replaces the default I/O behavior that was embedded into the runtime. This is required to be able to use it in embedded environment. This new library also offers a virtual machine running function which deals all return values.
Started to use 3-component version numbers instead of 4-component version numbers.
Read functions (i.e. freadchar()) will raise EndOfFileException rather than IOException when EOF is reached. Note that, freadln() can also raise this new exception.

Changes in v0.9.5

Changes in v0.9.4.1

Changes in v0.9.4

Changes in v0.9.3.2

2017.03.12. (r5451)

Fixed a compiler error: full path names were handled incorrectly.
Fixed an error in the readwtb: the mutable seq types were displayed incorrectly.
Added new functions to classify characters:
- function iscntrl(char) : bool;
- function isprint(char) : bool;
- function isspace(char) : bool;
- function isblank(char) : bool;
- function isgraph(char) : bool;
- function ispunct(char) : bool;
- function isalnum(char) : bool;
- function isalpha(char) : bool;
- function isupper(char) : bool;
- function islower(char) : bool;
- function isdigit(char) : bool;
- function isxdigit(char) : bool;
New compiler options were introduced:
- -signed-index: enable the usage of signed integers as indices
- -no-signed-index: disable the usage of signed integers as indices (default)
- -large-index: enable the usage of 64-bit integers as indices
- -no-large-index: disable the usage of 64-bit integers as indices (default)
Indexing sequences and strings is now supported with all integer types (there an automatic conversion will take place to u32):
- u8
- i8 (with -signed-index; may cause ConstraintErrorException)
- u16
- i16 (with -signed-index; may cause ConstraintErrorException)
- u32 (original indexing type)
- i32 (with -signed-index; may cause ConstraintErrorException)
- u64 (with -large-index; may cause ConstraintErrorException)
- i64 (with -signed-index and -large-index; may cause ConstraintErrorException)

Changes in v0.9.3

Changes in v0.9.2.9

2016.12.27. (r5148)

Fixed a compiler error: there was a glitch in the return coverage checker, and it missed the if statements without an else branch.
Fixed a compiler error: nested function calls were not tested, which was a problem i.e. in case of succ().
Fixed a compiler error: the generated code for the functions succ(), pred(), tos(enum) and toenum() has been fixed.
Fixed a compiler error: the compiler crashed if a function with no return type used in assignment.
Fixed a compiler error: impure functions given as argument were callable from a pure function. The compiler now displays an error for this.
Fixed a runtime error: simultaneously started wt instances are no longer exit with LFAIL on Linux.
Fixed a runtime error: there was a glitch in the cleanup code, causing an infinite loop in the wtgl program (the wtgl is not released yet).
Added new functions:
- impure function freadstr(file, char) : string;
- impure function fread(file, seq<i8>) : u32;
- impure function fread(file, seq<u8>) : u32;
- impure function fwrite(file, seq<i8>);
- impure function fwrite(file, seq<u8>);

Changes in v0.9.2.8

2016.11.27. (r5082)

Introduced new built-in types:
- i8 / byte
- u8 / ubyte
- i16 / short
- u16 / ushort
Numerous new functions introduced for the new built-in types.
Fixed a compiler error: the compiler crashed when a datatype contained a sequence of the same datatype that is in.
Fixed a compiler error: fixed an infinite loop when computing attributes of a datatype.
Fixed a compiler error: due to an errorneous condition sequences formed from 64-bit wide type were unusable in foreach.
Fixed the f32atan2, the f64atan2, the f32pow and the f64pow microprograms.
New compiler option to disable the effect of -labels-top and -labels-all: -labels-none.
Added new functions:
- function "+"(char, i8) : char;
- function "+"(char, u8) : char;
- function "+"(char, i16) : char;
- function "+"(char, u16) : char;
- function "+"(char, u32) : char;

Changes in v0.9.2.5

Changes in v0.9.2.3

2016.03.06. (r4908)

Added enumeration type support.
The syntax of the data type literal modified. Its syntax is now clear, and not confusing. The rule DATACONS expression changed to DATACONS { expression } (like the record literal).
Performance improvement in the virtual machine: some parts are rearranged; new instruction has introduced; a frequently used instruction has optimized.
Resource safety was not guaranteed in some cases.
Fixed an indeterminism in the compiler: occasionally AST nodes were ordered by its addresses, and caused invalid sequences in the binary.
Fixed a compiler error: Wrong destructor code were generated for the file and dir types.

Changes in v0.9.2

2015.12.27. (r4735)

Data type optimization: A reference counter is stored in the data type instances, and this counter is incremented when it is copied, and decremented when deleted. The actual delete is performed when the counter reached zero.
The parser recognizes the UTF-8 BOM at the beginning of the file.
Fixed a compiler error: Invalid code was generated for the data type default constructor.
Fixed a compiler error: The compiler crashed when parsed a data type constructor with invalid initialization expression.
Fixed a compiler error: The compiler generated invalid code for deleting incomplete data types and records.
Fixed a compiler error: Compiler forbid indexing, copying and returning mutable strings.
All other discovered minor bugs was fixed in the parser and in the compiler.
Fixed a bug in the virtual machine: Sometimes the string length was incorrect, and caused unexpected strings during the runtime.
Fixed a bug in the virtual machine: On 64-bit systems, the data types could be loaded onto unaligned area, and it is corrupted the representation.
Fixed a bug in the virtual machine: There was a defect in the memory manager that caused memory leak and resource leak.
A compile error will be raised when a variable initialization contains self-reference. Previous compilers accepted this, and caused runtime anomalies.
New implementation for the function sqrt(u32) : u32; function. In order to make things deterministic, the function sqrt(i32) : i32; also uses the new implementation.
The function strcpy(mutable string, u32, string, u32, u32); is no longer impure, the first parameter is mutable, and handles overlapped operations correctly.
Fixed a compiler error: The compiler merged import and export sections too aggressively. This caused inconsistent Welltype Binaries in some extraordinary cases. The compiler now keeps the original import and export order, and merges sections much less aggressively.
New flag in the wtc program: -add-hash ALGNAME. This flag adds INTEGRITY sections based on the ALGNAME hash algorithm. Duplicate algorithms are ignored.
The compiler inlines 32-bit and 64-bit constants by default. But it can be overridden with the new -no-inline-32 and with the -no-inline-64 flags.
New flag in the wt program: -i to verify integrity sections on loading binaries.
Added optional (or not so optional) integrity sections into the Welltype Binary.
Added new string functions:
- function strstr(string, u32, string) : u32;
- function strrstr(string, u32, string) : u32;
- function fromutf8(string) : string; (converts UTF-8 string to ANSI code page; can raise UnicodeErrorException exception)
- function toutf8(string) : string; (converts ANSI string to UTF-8 string; affects only code points above 127)
Added new file handler function: impure function faccess(string, i32) : bool; to check access rights.

Changes in v0.9.1.7

2015.11.09. (r4458)

Limited records are no longer copyable when imported. However, make a copy from a limited record is still possible, but must be done on the exporter side. This gives more control over the limited records. Note that, all types encapsulates an imported limited record (or just an uncopyable type) will be uncopyable as well.
Fixed a compiler error: wrong code were generated for copying file and dir type.
Fixed a compiler error: functions were not collected when forward declared and used only in global initialization before defined.
Added new string functions:
- function chars(char, u32) : string;
- function chars(char, u32, string) : string;
- function copies(string, u32) : string;
- function copies(string, u32, string) : string;
- impure function strcpy(string, u32, string, u32, u32);
- function strstr(string, string) : u32;
- function strrstr(string, string) : u32;
- function strchr(string, char) : u32;
- function strchr(string, u32, char) : u32;
- function strrchr(string, char) : u32;
- function strrchr(string, u32, char) : u32;
- function strspn(string, string) : u32;
- function strspn(string, u32, string) : u32;
- function strcspn(string, string) : u32;
- function strcspn(string, u32, string) : u32;
- function strtok(string, string) : seq<string>;

Changes in v0.9.1.5

2015.10.22. (r4289)

Added limited record support. Limited records are basically the same as private records, but they are not default constructible when imported.
The file and the dir types are now not default constructible objects. The function fclose(file); and the function closedir(dir); are no longer available, since the files and directories are closed automatically. Furthermore, they can be copied, and the copy will refer to exactly the same file and directory handle.
Exception handlers and finally blocks can no longer access to local variables.
Fixed a bug in the runtime. This bug occured rarely, and caused misinterpreted object references. Thus, this bug can cause a segfault.
Fixed the function pointer call. Empty parameter list were always accepted as valid argument.
The version of the compiler suite is now in the binary, thus the loader and the readwtb can verify it.
The compiler now validates the mutable property when creating a function pointer.
Fixed a compiler error: calling operators and functions with the string syntax was not recognized (e.g. the "+"(3, 4) expression caused compilation error).
Fixed a compiler error: not default constructible types were not always detected in the global block.
Added a new conversion function (the other conversion functions have similar identity conversion as well): function tochar(char) : char;.
Added a new sequence function: function empty(seq<T>) : bool;.
Added pseudorandom number generator functions: impure function rand() : u32;, impure function randf() : f32;, and impure function srand(u32);.
Added new string functions: function substr(string, u32) : string;, function empty(string) : bool;, function startswith(string, string) : bool;, and function endswith(string, string) : bool;.
Change builtin behavior of function trim(string) : string;. Now trims all characters with code below or equal to the code of the space character.

Changes in v0.9.1.4

2015.10.11. (r4165)

Function types are introduced. These types can be imported and exported, and this type is not default constructible. The syntax is the following: type FUNCTIONSIGNATURE ;, where the FUNCTIONSIGNAURE is the usual function signature syntax. The function type expression syntax is: FUNCTIONTYPENAME ( IDENTIFIER ) or FUNCTIONTYPENAME ( STRINGLITERAL ), where
- FUNCTIONTYPENAME is a name of a function type;
- IDENTIFIER is a name of a function;
- STRINGLITERAL is an operator symbol.
This expression is called function pointer. Calling a function pointer is the same as calling a regular function. A function type cannot be assigned when formal parameters are involved. A global data, or part of it cannot be passed to a function pointer which is originated from a formal parameter. Finally, function pointer what is originated from a formal parameter cannot be stored to any local variable.
Data types are not require default constructor anymore, but a data type without default constructor cannot be automatically initialized. These new data types are not default constructible, otherwise there are default constructible. This property is inherited by records.
Fixed a compile error which occured when switch-case was used.
Added eight conversion functions: function tochar(i32) : char;, function tochar(u32) : char;, function tochar(i64) : char;, and function tochar(u64) : char; -- and the reverse direction: function toi32(char) : i32;, function tou32(char) : u32;, function toi64(char) : i64;, and function tou64(char) : u64;.

Changes in v0.9.1.3

Changes in v0.9.1.2

2015.08.31. (r3983)

The parser did not handled correctly the '\b' character, and did not support the '\v' character.
Added two string functions: function trim(string s) : string; and function trim(string s, string ignore_set) : string;.
Added string comparison operators: <, <=, ==, !=, >=, >
Data type constructor names can be used in different data types without compile error. But the ambiguous data type constructors must be qualified with the data type name.
The readwtb raw data display is now 80 characters wide.
Fixed a compiler error. When user ctor block and data types were created in the global block, the user ctor block did not executed.
The loader matches the name of the data type constructors.

Changes in v0.9.1

2015.05.01. (r3931)

Added data type support with data type literals.
Added endianness query and conversion functions.
New boolean funcion pure function "^"(bool, bool) : bool.
New character functions: pure function tolower(char) : char and pure function toupper(char) : char.
Fixed a critical error in the loader (return value types were not matched).
The --version option added to the compiler.
The wt program will now set the exit code when the executed program generated an error.
Unused global variables are ignored by the compiler.
Some corrections in the data sheet.

Changes in v0.9.0.7

2015.02.02. (r3714)

Added record literal support.
Fixed a problem when executing the runtime on Linux with single-processor systems.
Fixed identifier resolution (an identifier can be a type name, an operator, or a simple identifier).
Improved integer literal validation.
Fixed an allocation error in readwtb.
Fixed a critical error in the runtime.
Unary "+" and unary "-" for f32 and f64 types.
The unhandled exceptions were not reraised.
Fixed the import include generator. Written function declarations were incomplete.
The unresolved externals will be displayed in the error log, instead of terminating the compiler without any details.
Fixed a compiler error. When the return value contained object and scalar, then the compiler reached an internal error.

Changes in v0.9.0.4

2014.11.30. (r3269)

Added sequence literal support.
Import include generation is available again (-gen-import and -impinc-name options).
Shebang support in .wtb binaries. The compiler can place the shebang line with the -shebang option.
Some improvements in the runtime API.
Some compiler improvements when processing pre and post.
The AssertionFailedException, the PreconditionViolationException, and the PostconditionViolationException exceptions will not be included in the binary when the related features are disabled (-disable-asserts -disable-precond -disable-postcond).
The raise statement is counted in the return coverage.
The compiler crashed when invalid expressions are used with and-then and or-else. (Reported by Tibor Brunner)
Fixed the help screen of the compiler and the runtime.

Welltype

Changes in v0.12.0