AL-IV:    Versions history (2016-2017)


New versions

See here


October, 31, 2017 - version: 0.84

  • Fixed:
    • Passing a fixed array, which is a field of a record, as a function parameter (C++)
    • Passing NONE as a parameter (C++)
    • {System_functions}.Detailed_catalog (C++/std::strings version)
  • A bit optimizing code size and speed for C++ (with the option /final a Release version is built).


October, 25, 2017 - version: 0.83

  • Fixed:
    • {Listview}.Clear(C#, C++), Set_item (C++/wx)
    • {String_functions}.Upper/Lower (C++)
    • {File_path}.Catalog (C++/std)
    • {Text_file}.Load (C++/wx - for national filenames)
    • {Date_time}.Str (C++ - uses now current user locale)
    • {System_functions}.Start_program (C++/wx, Delphi)
    • {Form}.resize - prevented for case when Handle is (already) 0 (otherwise we have a crash).
  • Optimizing code size for Delphi (especially for KOL version).


October, 22, 2017 - version: 0.82

  • It is allowed to use also '\' as a separator between two parts of a long name (additionally to '|').
  • Translation of code from national languages:
    • a translation for encoded characters added (#NL, #SP, #CR etc.);
    • a transliteration or a final coded provided to make it human-readable;
    • a translation for rare keywords provided, and for parts of words (DUMMY, TEMP).
    • Entire classes can now be easy translated using special class modifier TRANSLATION. Such translation classes contains just translations for functions, methods, fields etc. in a special format.
  • Fixed:
    • {Configuration}.Value_s (Delphi/KOL), .Delete_value (c++/wx);
    • {Configuration} - all functions (Java);


October, 19, 2017 - version: 0.81

  • Translation of code written using national keywords is implemented. A localized class should start from a language specification in form ['LL'] or [Language='LL'] (immediately before the CLASS keyword, or its national equivalent). It is allowed to mix in a project classes written using different national languages. Russian translation is already available.
  • Classes {Tray|_icon}, {Icon} are implemented for Java (with some restrictions though: there are no icon transparency, not supporting .ICO, it is necessary to show parent form before pop up a menu on tray icon).
  • For C++ implementation, records are always implemented as simple structures (struct).
  • A compiler now requires importing all the classes which methods are called in current class (earlier, classes could be not imported if its methods were called though its descendant class objects).
  • Added:
    • a function {File_path}.Detailed_catalog(STR Path, STR Catalog[], {file_info} Details[]);
    • a method {Control}.Clear;
  • Fixed:
    • {Form}.Visible for Java;
    • generating of a field of a record which is a fixed array with size defined by a enumeration type (Delphi);
    • creating a record instance for record type containing arrays (C#, C++);
    • setting {Listview} fields (C#, Subitems);
    • generation of passing a native array parameter (which is a field of a record) to a function as a fixed array: Delphi.


October, 14, 2017 - version: 0.80

  • It is allowed in a method/function header declare return value style in formm
    ==> {type} RESULT|identifier, just to add some comments on a returning value.
  • A BASE method call implemented for methods with parameters. It is disabled to use return statements (==>) in methods calling the BASE method not in its first line.
  • Methods added:
    • to draw bitmaps: {Bitmap}.Draw(Canvas, Pt), Stretch_draw(Canvas, Rect); Automatic drawing implemented of an image assigned to {Picture}.
    • {Listview}.Prevent_update, Column_width(Index_col)==> REAL, Set_column_width(Index_col, Value).
    • a callback method added: {{Form}.moved.
  • Fixed::
    • set a date in {Date_picker} .Set_date in C++ version (wx);
    • positioning on screen of a pop-up menu under {Tray|_icon} in C++ version (wx);
    • an exception while handling (resize) event for already closed form in C# version;
    • calling form destructors for case when the main form is hidden or there are several forms on screen (c++, wx; Delphi, VCL);
    • correct access to a dynamic array of real values out of range bounds of the array, for Delphi;
    • correct assigning a sender before calling event methods of a form (C++(wx), C#, Delphi(KOL));
    • {Screen}.List_monitors for Delphi, KOL and VCL;
    • Changes to correct work with modal dialogs in some environments:
      • when the the second modal dialog is opened for the same parent form, the previos modal dialog is closed automatically (answering an empty string);
      • Method {Form}.Close is ignored until the form has an active modal child dialog.
  • Documentation has moved to another site:
    http://kolmck.ru/AL4 (the domen clavier.link is no more required still its name has no correlations with the language name).



October, 10, 2017 - version: 0.79

  • A class {Color_console} added.
  • Changes in a PUSH with method:
    • PUSH and POP methods are declared sequentially,
    • PUSH-method has a modifier PUSH,
    • POP-method has a modifier POP(name of PUSH-method).
  • PUSH with method now is generated by all the language compilers.
  • The IMPORT statement can be separated onto several standalone IMPORT statements. It is allowed to place block comments ( ----------- 'text') before IMPORT statements and between them.
    • REVERT fixed for case of setter/getter with several parameters;
    • requirement not to use local variables in a reverting code from another method is replaced with a requirement to have identical local variables (by names and types);
    • removing methods used only in reverts on optimization fixed.
    • A function added New_memo(Form, Alias, Flags) with a capability to create memo only for read and to control its scrollbars on a memo create.
    • A function added New_read_only_edit(Form, Alias) to create one-string field to show only (not edit) single line of text.



October, 7, 2017 - version: 0.78

  • An essential change in the AL-IV language syntax: methods should be started with the keyword METHOD, the keyword STATIC no more needed (it is sufficiently to start a function with the keyword FUNCTION or FUN). Also, for overridden methods, now the keyword OVERRIDE is used along, and the method name is following it immediately.
  • It is not more necessary to add a block comment at the start of a function having a header from several lines.
  • It is now necessary to place a colon ending a function header in a separate line in cases then the function header consists of several lines..
  • A function added {Screen}.List_monitors, functions {Form}.Set_position, {Form}.Set_size are changed (parameters added to control placing a form on display monitors).
  • Functions added in class {Form}: Set_default|_button, Set_cancel|_button, Stay_on_top, Get_window_handle (for Java returns 0).
  • Localization functions are translated to C# version (primary compiler), so the compiler itself can now be localized.
  • Compiler messages are localized for Russian (and can now be localized for any other language). To switch between languages, run cmd-files use_language_XX.cmd (in the folder AL4).



October, 1, 2017 - version: 0.77

  • A rule of concatenating of source lines is extended from "...or the next line is starting from a double quote character..." to "...the next line is not starting from a letter or one of symbols '--',  '{', '<', '[', '(', '.', ';', '==>' ...". Such variant allows to simplify lines separating: it is sufficient to start a continued line from an arithmetic or a logical or another operation symbol (except <, <=), which does not start from a letter.
  • A requirement added to a code writing: if a condition in a CASE statement consists of two lines or more, then the question mark '?' should be placed in a separate line of code.
  • A block comment ------------ 'text' should have a modifier REUSED in case if it is used in other statements (LIKE, REVERT).
  • A method modifier SETTER FOR fld/fun added. It allows to define for a field/method how it should be reverted (with REVERT).
  • The REVERT statement is implemented (allows to revert a block of assignments).
  • Visual components:
    • getting/setting font, color for controls is implemented (some problems with Java though: there are no direct support of Underline / Strikeout).
    • A class {Dialog} is added (a descendant of the {Form}, to descend your own dialogs). Modality is implemented like in Java: a dialog is shown (by the function Show_modal) and a portion of code is ended. An answer is receiving in the form event answer (via the field Answer, containing a string set in the method ready(Answer) of a dialog form).


September, 23, 2017 - version: 0.76

  • A class {Alien_windows} added to work with external windows and application (in Windows / XWindows).
  • A class {Shortcut_info} to work with file shortcuts (Windows).
  • A class {Icon} added to load / draw icons. In the visual class {Tray_icon} the {Icon} class is now used to keep an icon and it can be changed at run time.
  • It is now possible to specify low-level source files via a directory
    NATIVE "///copy file" .
    rather then by a command /copy file in a configuration file of a project (and for case of different source file extension, an asterisk can be specified ".*")
  • Visual forms:
    • An automatic size adjustment added for buttons and labels (on its text length - C#/C++/DelphiVCL/DelphiKOL).
    • A fix provided: placing controls horizontally on columns aligned top/bottom.
    • Calling an auto-adjustment of columns sizes on each call of Any_change form event removes ambiguous scroll bars.


September, 14, 2017 - version: 0.75a

  • Minimal changes in code to beautify a help on classes and functions.
  • New version of the help on classes is published: the most of classes now have annotations in cases when this is necessary.


September, 12, 2017 - version: 0.75

  • Optimization of passing a fixed array as a parameter is implemented.
  • Problems with localization and printing in console using OEM encoding fixed for C++, Delphi.
  • A tool Dok_sources is added to generate a help on base of sources. Such help is added on classes of AL-IV. It is available now a zip archive containing documentation on AL-IV language and a help on classes.


September, 3, 2017 - version: 0.74

  • For operators SELECT / DELETE / UPDATE : in clause JOIN ... ON now it is possible any correct SQL-like expression similar to WHERE clause (the only requirements is that a field from a joined table should be used there)
  • Inserting data to a BLOB field is implemented (though only for C# version). BLOB-field is declared in a RECORD correspondent to a TABLE as byte array, e.g.
    BYTE Blob_field[1], and in a query it is set as a result of a function Blob_param({Stream}), e.g.:
    stream = Read_file_stream(Photo_path)
    db << UPDATE Table,
          SET Blob_field = {db.Blob(stream)},
          WHERE ID = {Id_row}

  • A modifier added for functions: UNSUPPORTED('text'), to generate an error while compiling a code which requires this function to be called. (If used classes contain functions which can call this function but themselves are not called, then there are no errors fired).
  • Generic functions now can return a result of generic type {?} (but these should have at least one parameter of type {?}). E.g. functions are added: Max|imum_of_two_values({?}, {?}) ==> {?} and similar (see in class {Sorting}).
  • A documentation added on SQL queries (see section Additional).


August, 28, 2017 - version: 0.73

  • A function modifier WAIT(method1, method2, ...) is implemented and working. The modifier WAIT requires calling one of methods listed below in code (following the method having such WAIT modifier).
  • Section WHERE for queries SELECT, UPDATE, DELETE is implemented as an SQL-like expression, including checks of field names, table aliases etc. on a compile stage.
  • C++ implementation of {DB} also now works (with OTLv4).


August, 25, 2017 - version: 0.72

  • A statement
    LIKE function ...........'comment label' added (it allows to make a portion of code between two operator comments in form --------- 'label' common for several methods without moving it to a separate function. LIKE statements can not be nested (called fragment should not contain other LIKEs), and it is allowed to use portions of code only from the same class.
  • It is allowed to use operator << for left objects of classes (actually a method Write is called from a correspondent class, which should accept a STRING parameter).
  • A function modifier WAIT(method1, method2, ...) is added which requires calling one of methods listed below in code (following the method having such WAIT modifier).
  • A table declaration on base of a record was added
    TABLE name|s: {record} ... .
  • Embedded operations added: INSERT, DELETE, UPDATE, SELECT, which create SQL statements (syntax used is a bit different then in T-SQL, but near). These operations allows to check SQL code correctness at compile time.



August, 13, 2017 - version: 0.71

  • Class {Clipboard} added (to work with text).
  • Class {Configuration} added to store and restore applications settings. For C++, it is supported only for wxWidgets now.
  • Class {Errors} added to access text messages generated in code in cases of exceptions caught.
  • Class {DB} added to work with databases (except for C++, still there are no actual multi-platform db library for wxWidgets).
  • The PUSH statement can be used to call a pare of methods: a method calling in the PUSH, should have a modifier POP(name2), specifying a method (not having parameters) which is called at the end of the PUSH block.
  • A modifier STORE(Parameter=value) for a function creates a hidden automatic integer parameter which is cached (separately for each function call). A parameter specified in parenthesizes is passes by reference. Another function modifier FORGET (used in another method) allows to reset all cached parameters to its initial values (specified by ...=value). These two modifiers are providing an efficient access to named values such as fields of a query result, columns of a list view etc.



July, 28, 2017 - version: 0.70

  • Generic functions added (static only, accepting parameters of type {?} meaning "any type" and function parameters).
  • A class {Sorting} added to sort arrays of any types (via generic functions). The qsort algorithm is used (but without a recursion, converted to loops).
  • It is not allowed to check a presence of a string in an array having a single item (e.g. s IN ["0123456789"])
  • A visual class {Tray_icon} added - for C#, Delphi, C++.
  • It is allowed to launch a single invisible form application.
  • Some problems fixed with ambiguous optimizations (undesired functions remove or inlining in some cases).
  • In a visual library explicit parameters Sender / Alias are removed from event callback functions (moved to form fields sender / sender_alias correspondingly).
  • The keyword DEBUG written in a lower case (debug) also defines a debug block but its code is never injected into final code (this can be used to turn off certain debug blocks).
  • A statement DEBUG IMPORT added (written after the IMPORT statement), to specify classes required for DEBUG/debug statements only.



June, 9, 2017 - version: 0.63

  • Full support for a platform Win32/Delphi/KOL added (KOL version 3.23) including OpenGL.
  • Comparing sizes of executables for a visual test application (Library\Visual\Test_project):
    Target platform Size, Kbytes After UPX apply
    C# 152 (not applicable)
    C++ (wxWidgets) 6130 (not applicable)
    Delphi (VCL) 652 239
    Delphi (KOL) 166 64
    Java (awt) 209 (jar) (not applicable)

    The same for test OpenGL-приложения:

    Target platform Size, Kbytes After UPX apply
    C# 1280  
    C++ (wxWidgets) 6050  
    Delphi (VCL) 508 197
    Delphi (KOL) 143 58
    Java (awt) 188 (jar)  

    The same comparison for a non-visual test application (Test_projects\Complex test):

    Target platform Size, Kbytes After UPX apply
    C# 103  
    C++ (wxWidgets) 1850  
    C++ (stdStrings) 313  
    Delphi (VCL) 139 57
    Delphi (KOL) 70 31
    Java (awt) 67 (jar)  



May, 18, 2017 - version: 0.62

  • It is not allowed to reuse in methods of classes identifiers already used as names of class fields.
  • A support for a platform Win32/Delphi/KOL added (KOL version 3.23). For this moment, only non-visual part of KOL is supported but working on its visual part is on progress.



May, 09, 2017 - version: 0.61

  • A special localization support added via pseudo-functions _id(string) or sring._id, and a class {Localize_str} to handle language resources in text files.
  • In all cases now function value not assigned is accounting as an error, not a warning.



April, 28, 2017 - version: 0.60

  • A tool application Test_report can show automatically created html-reports on test results (compiling option /t SHOW).
  • A form of CASE statement added:
    CASE ? [expression1] ? ...
           [expression2] ? ...
           ELSE ... ;

    - with a sequential calculation of Boolean expressions until the first TRUE, for which a correspondent branch is executed. It is corresponding to a classic form (if ... else if ... else if ... ...).



April, 25, 2017 - version: 0.59

  • Function Platform_info added: it returns information on target language, framework and OS where the application is running
    (like "Java;AWT;Windows" or "C++;wxWidgets;Linux")
  • Changes in RESTRICTtions (to parameters) syntax:
    • a form added IF x IN ..., AND y IN ..., AND z IN ..., THEN ... (when an arbitrary number of ANDs is allowed).
    • a form THEN x IN {a, b, c} is replaced with more common THEN x IN {a}, OR IN [b TO c], OR IN [d, e, f], OR IN {g}, ... (in any possible combinations).
  • Incremental assignments to the same variables (R = ... R+= ... R *= ...) are not accounted now in blocks, to encourage separating too complex expressions onto several simple expressions.
  • An option added /op|timizations +/-/flags, a number of optimizations are implemented.
  • A tool application Test_report is created to simplify analyzing test results.



April, 09, 2017 - version: 0.58

  • Java: form resizing fixed, flickering and slow handling of the resize event is eliminated.
  • {Form}: method Close added to close form programmatically.
  • {OpenGL}:
    • lighting, material, fog, glu-functions, quadrics, accum, draw modes, hints,  etc.
    • a method Processing added to redraw scene with a maximum speed without a timer (but in such case the Java can not catch keyboard events, only mouse clicks).
    • a class {Font2D} added to draw text in the {OpenGL} component.
  • A block statement DEBUG: ... ; is added, for which:
    • always a warning is created about its presence;
    • amount of statements in a block is not counted (and it itself is not counted in a parent block);
    • declared in such block variables can not be used out of DEBUG-code;
    • such code is not compiled while a compiler is called with a key /f|inal.
  • {Canvas}: supporting pen styles is reduced to only 'SOLID_PEN' and 'CLEAR_PEN', pen modes are totally removed and commented.



April, 4, 2017 - version: 0.57

  • It is allowed to declare a fixed array of an undefined (zero) initial size on a class level:
    {type} Name|_long_name[*]
    Actually such array can be formed only in a native code but in an AL4 it is accessed as an array.
  • OpenGL - continued (call lists, textures, blending).
  • Alpha-channel working was added in Delphi and C++/wx version.
  • A class was added to work with bitmap pixels directly: {Bitmap_direct} (inherited from {Bitmap}).
  • A statement added: TODO: "text" . It raises a warning with the text specified while compiling.



March, 29, 2017 - version: 0.56

  • Changes in parameter restrictions syntax:
    • a form
      RESTRICT x IN [a TO b] is added for integer / byte parameters.
    • it is possible now to specify several constant sets in a restriction referring to such sets:
      ... x IN {set1, set2, ... }
  • Checking constant duplication added. It is allowed to duplicate a constant with the same value if its new instance has a substring AGAIN in its name (in any case). This allows using the same constant in several different names of constants (for RESTRICT purposes).
  • OpenGL - working is continuing (a rotating cube is ready for all four target platforms).


March, 25, 2017 - version: 0.55

  • It is allowed not to initialize part of fields of a record in its constructor {record_name}(Field1=Value1, ...)
  • A modifier PUBLIC is added for a method, allowing to declare a function as PUBLIC independently on its first letter case (by default an upper case is used to declare a function PUBLIC only).
  • Changes in parameter restrictions syntax:
    • a form
      RESTRICT x IN FLAGS[a, b, ...] is added which allows to restrict an integer or byte parameter with a '|'-combination of flags.
    • For integer/byte parameters it is allowed to use named constants including a case of flags combined.
    • A form
      IF x IS CONST, THEN y ... is implemented also, allowing to check a restriction for a case when a parameter is given by a constant (x can be the same as y).
  • For a set of constant (of simple data types INT, BYTE, STR) it is allowed to define a name of a set, which can be used to refer to the set in a restriction definition (RESTRICT x IN {name-of-set}).
  • Changes in NATIVE functions support:
    • now a native function can consist of either from a string constant (starting from a quotation or '@'), or it can start as a usual AL-IV function and to have as the last statement a directive
      NATIVE string-expression
    • As a result, creating wrapper functions which should do something before calling a target function become more simple.
    • Also, a code generated for a native function is changed a bit: there is a prologue is created and if necessary a return statement returning the RESULT variable.
  • It is allowed to have 4 or more parameters for native functions (NATIVE attribute) without necessity to have the attribute BAD for entire class.
  • A structure of an information stored in .test-files is changed:
    • now for executed lines of code numbers of lines in test functions where from a function testing was called last time is stored.
    • For methods of an abstract class, also number of lines of a calling class is stored in lower digits.
    • A tool is planning to generate an interactive html-report on base of test files.
  • For the AL4toJava compiler, options are added:
    • $PAUSE - to pause after each important stage (compiling/running tests/running a compiled application);
    • $CP - to specify the option -classpath;
    • $TRACE - to trace (in the console) execution on functions (and on the function lines, if a function is set in the option).
  • OpenGL support is started:
    • for C#, the CSGL12 library is used (but without necessity of external DLLs);
    • for C++ with wxWidgets, its wxGLCanvas,
    • for Delphi - standard OpenGL12,
    • for Java- JOGL (additionally to jars it requires native DLLs from the JOGL package).


March, 19, 2017 - version: 0.54

  • Recursive test functions are disabled. It is disabled to use ASSERTs in FOR loops. It is disabled to use FOREVER loops in test functions.
  • Additional string parameter of an ASSERT is supported in all the compilers (in the previous version it was just ignored and not shown in compilers to Delphi and Java).
  • Visual AL4's mini-library (in its current state) is implemented for C++/wxWidgets (under Windows) environment (including events, graphics, working with forms and controls, menu etc.)
  • A {Listbox} added (for all target platforms).


March, 16, 2017 - version: 0.53

  • Speed of compiling to C++ drastically improved in result of uniting all the h-files into a single h-file and all the cpp-files into a single cpp-file in an output project generated.
  • Component {Canvas} now works very similar for all four environments (picture draw is almost the same).
  • The {Menu} class removed: menu is created dynamically from a list of strings, main menu is not planned to implement.
  • C++: a lot of fixes, leaks of memory, objects, GDI handles, etc. are removed. But not yet all though.
  • An ASSERT statement is extended with an optional string parameter (text expression which is shown together with an assertion fail message and is stored in a test log).
  • Visual components for C++/wxWidgets: there is a progress there though not yet all events are implemented.
  • Java: better compiling. Stopping a console provided to view errors, waiting launched tests/compiler/application provided.


March, 8, 2017 - version: 0.52

  • Increment / decrement (++/--) is applicable only to variables and fields (fields are also should belong to variables or fields - recursively). In part, it is not allowed to increment an array item or a field of an object returned by a function.
  • A complex test added (in Test_projectrs) which includes all the previous and new tests.
  • Version for Java (AL4JavaCompiler), including jar-variant, can be used for compiling AL4 to Java, but only in Windows (there are problems running javac and java from a jar-program in other environments).
  • A full cycle for all four languages is working: the primary compiler on C#(sources of the compiler) -> secondary compiler on a language X (where X=C#,Delphi,Java,C++). Then the secondary(sources of the compiler) -> the next derivative compiler. Then, the first derivative compiler ($By_X) and the second derivative compiler ($By_X2) are compared by its texts (as sources generated on a language X to compile it), and these are identical (except a small set of insignificant differences such as paths of own files or real number formatting). And these can be used to compile programs (this is tested using the complex test).


February, 26, 2017 - version: 0.51

  • Code optimizations: faster comparing substrings, faster checking if an item is contained in an array of items (operation IN / !IN).
  • For the compiler to C++, options are added: $UI and $String to control which type of a string and which UI library is used to build graphic interface.
  • Plans about using Qt as the primary visual library are abandoned. The first, the library wxWidgets will be adopted, still it is simple and sufficiently power (it also supports several target platforms such as Windows, Linux and Mac OS X, and it has better licensing conditions). Now we are ready to use wxWidgets: when the option /$String=wxString, all the classes prepared (except visual) are compiled and tested.
  • For wxWidgets, also an option $WXLIBS is added (or an environment variable WXLIBS can be used instead), which allows to define a list of libraries to use with a linker (names of wx libraries can differ from version to version and also can depend on UNICODE aware or other conditions while configuring libraries). And also, it is possible to add here other libraries if necessary.
  • Most of Visual library was ported for C++/wxWidgets. At least this part of work is very close to be finished. Some features were lost on this way (for a {Progress} class, a property Minimal|_value was abandoned, for {Edit}} and {Listview} its styles can now be set only on creation, not dynamically).
  • An option $REPORT_LEAKS ws added to allow object leakage report generating. Leaking of objects are fixed for C#, Delphi, C++.
  • Important rule added: it is not allowed to pass a weak array as a parameter to a function where such parameter can be used to add newly created objects (via ",>>" operation) or to be passed to other such functions.


January, 31, 2017 - version: 0.5

  • A compiler option added /$Name="Value" to define constants $Name, which can be used in a program code as string constants.
  • A compiler from AL4 to C++ added. Visual library is not yet supported for C++ (Qt is planned).


January, 8, 2017 - version: 0.43

  • It is possible now to use concatenations of string literals and named string constants as string constants including constant strings representing NATIVE functions code and NATIVE directives. This makes it possible to move platform dependent code to {NATIVE_NNN} classes (for correspondent {NNN} classes) as sets of string constants, leaving common (for all platforms) part in {NNN} classes.
    This way several classes are already remade: {File_stream}, {Random}, {Mathematics}, {Date_time} - for all three supported languages (C#, Delphi and Java).
  • Methods Str and Format are added to {Date_time}.
  • Method Rome added to {Mathematics}.


January, 5, 2017 - version: 0.42

  • Class added: {Mathematics}. Functions Power, Is_NAN, Abs - moved there.
  • Class added: {Date_time} (to manipulate under a RECORD {date_time}). For a {Datepicker} control now functions Date and Set_date work through this new data type.
  • Class added: {Random} - to generate pseudo-random numbers.
  • A class modifier 'TESTED' added. It is contra versa to 'UNTESTED' and additionally requires for a compiler to take into account calls to native functions while testing a class.


January, 3, 2017 - version: 0.41

  • Streams are added: {Stream}, {File_stream}.
  • A restriction removed to call any static function in a prefix style: x.foo(y, z) vs. foo(x, y, z).
  • Working with bytes fixed in Java (bytes there are signed though in all other supported languages and in the AL-IV - not). Some fixes are for all target platforms.
  • TEST functions with parameters are added, to call those only from other TEST functions.
  • While testing a class derived from an abstract, the abstract class should be tested always (an abstract class can not be tested itself by its design).


December, 22, 2016 - version: 0.4

  • Java (awt): most of visual controls (except listview) are ready.
  • Fixes in code generation for Java (RECORD, array of RECORDs).
  • Fixing calling base method (BASE) of an ancestor class.
  • A modifier CALLBACK is added for functions (disabling calling from other classes and even from descendant classes, just to override in the custom code).
  • A modifier UNCOOKED added for functions, which is used to warn about using not ready or not fully supported or not finished methods.
  • Using block comments -------- 'text' now should start a function body if the function header has two or more lines, or the function body already contains other block comments. This requirements is added to make code more readable and self-documenting.
  • Code generation for C# was totally reworked to provide correct behavior or NONE objects.
  • In Java code generation throwing all the exceptions is allowed.
  • Some changes in form event handling. Working with menu moved from a modal mode to a classic version (popup a menu, then ended current event handler; when a menu item was clicked - a menu form handler is fired).
  • A small help on programming GUI applications is added as a second part of an article "AL-IV: How to start programming".


December, 12, 2016 - version: 0.3

  • Renaming in visual classes ({Windows_AL4_forms} -> {AL4_form|...} etc.)
  • A check added to the compiler if an import was ambiguous (there were no things used from the imported class).
  • All the launched compilers messages are redirected now to the console.
  • Modifiers DEPRECATED('...') and ABANDONED('...') are added to types, fields and functions.
  • Modifiers RESTRICT for functions (to restrict parameter values by certain constant values) and IF/THEN (to provide a conditional restriction of one parameter value depending on a value of another parameter; both parameters have to be specified by a constant while calling the function).
  • An article added "AL-IV: How to start programming".
  • A visual library for a Java (awt) platform is in progress: a test project is already compiled OK and a form is shown with a label and a button. Unfortunately, too deep distinctions of the Java (awt) from other platforms lead to serious changes in code for other targets to achieve a purpose "one source code - all the platforms". E.g. for a combobox it is not allowed editing a text (it is just for a section of an item from a list provided).


December, 4, 2016 - version: 0.2

  • Renaming of classes using a single naming style (class name consist of identifiers separated by an underscore symbol). A class {StringFunctions} was renamed to {String_functions}. Main compiler class file was renamed from Program to AL4_compiler.
  • A check was added that a short class name matches the class file name (without figure brackets, certainly). I.e. class {AL4_form|Delphi} can be located in a file AL4_form.pas and imported as {AL4_form} in such case.
  • A compiler added to the Java. For that moment, the compiler itself can cross-compile itself into Java code, and obtained such way Java coded compiler can run and with the same input sources generate exactly the same output Java code.
    Note: this is not enough to compile visual classes, and supporting of some features (RECORDs, short strings) is luck yet.


November, 28, 2016 - version 0.1a (the first publication)

  • A documentation on the AL-IV language is completed.
  • An article about RECORDs was added.


November, 22, 2016 - version 0.1 (the first publication)

  • The first publication under the new name AL-IV.
  • A working compiler is already exists from AL-IV to C# and Delphi32.
  • It is already possible to create a simple application (independent on a target platform, C# or Delphi). A set of visual components is mainly ready.