AL-IV:    Versions history


December, 30, 2018 - version: 0.92.6

  • Changes:
    • The method {Form}.Set_column_font added to set default font for all the controls on a column;
    • Delphi+Free Pascal: {System_functions}.Platform_info now returns Free Pascal (FPC) under Windows too, and can now detect Win 8 / 10 versions (though Win10 only for an application with manifest);
    • C# {Form} - wider margins and spaces between controls on form;
  • Fixes:


    • Delphi: compiling visual project not using the 'accept' event to accept files dropping on a form (v 0.92.5a);
    • C#: compiling a compound byte expressions used as byte parameters for functions (v 0.92.5a);
    • Delphi/VCL: setting {Font}.Size (via Font.Size rather then via Font.Height);
    • Delphi/VCL: handling drop files event (call of DragAcceptFiles moved to the CreateWnd, providing restoring ready-to-drop flag in cases when the form handle is re-created together with changing its properties);
    • Free Pascal/LCL: handling arrow keys in a {Form}, HOME/END, PAGEUP/PAGEDOWN, TAB, BACKSPACE;
    • Delphi/KOL: propagation of the {Form}.Any_change event after the {Form}.value_change (for a {Checkbox});
    • Delphi/KOL: {Label} - font color is not changing now when the state is changed to "disabled" (only font style is changed);
    • C#: the event {Form}.Any_change did not call after form creation / showing (and the {Form}.column_hidden did not call too), a call added in the {Form}.shown event;

December, 22, 2018 - version: 0.92.5

  • Changes:
    • The method {Form}.command and the class {Single_instance} are added. The {Single_instance} is an inheritance from the {Screen} class. Using it instead of the {Screen} allows handling events of launching secondary instances of the application receiving its parameters in the {Form}.command method, via usual Count_param and Parameter functions from the class {System_functions}, see demo in Test_visual_projects\Test_paint_lines;
    • The method {Form}.accept ==> BOOL was added which been overridden allows to handle dropping files on the form (e.g. from the Explorer). To do so, override the method {Form}.command (a list of files is accessible via {System_functions}.Count_param and Parameter again), see demo in Test_visual_projects\Test_paint_lines;
    • C#: optional parameters added: $Title, $Description, $Configuration, $Company, $ProductName, $Copyright, $Trademark, $Version, $FileVersion; a file AssemblyInfo.cs is created and added to the project, using such parameters. In result when an application is selected in the dialog "Open with..." or in properties of the application, properties specified are shown there;
    • C#: the parameter is added $Visual, if it is set, the application is compiled for the target WinExe (otherwise target is Exe as earlier);

December, 16, 2018 - version: 0.92.4

  • Changes:
    • To make BEAK or CONTINUE through several nesting FOR loops, it is necessary now to specify all the nesting FOR statements which are breaking first, in BREAK statements sequence:
    • A read only field {Form}.Closed added (a closed form can not be shown on the screen but it can still exist as an object of the class {Form}, and its fields and methods still are available until all references to it become erased or rewritten);
  • Fixes:


    • Delphi: a lot of fixed in code generation for fixed arrays;
    • INLINE optimization was fixed for case of multiple inlining of a function having a parameter which is a dynamic array;
    • exceptions on accessing closed forms and its controls are prevented;

December, 8, 2018 - version: 0.92.3

  • Changes:
    • {Form}: the enumeration {reason_closing} added and the field reason_closing which can be analyzed in the event closing;
    • C#: the option added /$FRAMEWORK= (values 3.5 and 4.0 are supported);
    • For the LIKE statement it is now possible to exclude several nesting blocks:
      LIKE foo ............ 'label1', EXCEPT 'label2', 'label3'
  • Fixes:


    • C#: byte_array[].Extend(value, count);
    • C#: all the records are now working via classes;

December, 02, 2018 - version: 0.92.2

  • Changes:
    • A modifier UNROLL / UNROLL(n) has added for the FOR statement;
    • Compiler options !autoinline and !unroll are added;
    • Messages added about unused private functions, methods, class fields;
  • Fixes:


    • It is disabled to inline functions containing statements ==>, CONTINUE, BREAK;
    • C#: code generation for /debug mode ({ } brackets balanced);
    • Delphi/VCL, C#: generating code for unroll FOR loops;
    • Delphi: generating inline insertion of code in case of call a function, which result ig ignored (NONE = foo(...));
    • Delphi: generating call of an embedded function Fill for a fixed array which is a part of a RECORD;
    • C#: in the {Canvas}, property Quality now is taking into account while drawing a {Bitmap} on it;

November, 24, 2018 - version: 0.92.1

  • Changes:
    • Delphi/FPC: caching of temp fixed arrays added (this speeds up code a lot in cases when array ranges are used, or fixed arrays are passed as parameters, or operations IN/!IN are used to check a value presence in an array of constant values etc.);
    • The optimization V5 added - uniting local variables of the same type not intersecting on its usage areas in the function (what is most important for including bodies of functions with INLINE and auto-inline);

November, 18, 2018 - version: 0.92.0

  • Changes:
    • Syntax/symantics of the language: a modifier CLAMP was added for fixed arrays which size is equal to a power of 2 (in result checking if an index is in bounds is replaced by AND-masking it with 2^N-1, which also does not allow to violate bounds but may lead to work with undesired indexes in the array. But faster);
    • A class {OpenAL} added (implemented for Delphi and C#);
    • Block comments are allowed in a RECORD;
    • For arrays, embedded functions added:
      • A[].Copy(To, B[*])
      • A[].Fill(To, Value, Count)
      • A[].Repeat(To, Source[], Count)
      • A[].Extend(Value, Count)
      • A[].Append(Source[*], Count)
      • A[].Withdraw(From, Count)
    • {Timer}.Begin_precision / End_precision added (to set multimedia precision timer latency);
    • The modifier INLINE added for functions;
    • Delphi/FPC: entire arrays handling of all the types has reworked;
    • Delphi/KOL: minimal application size reduced to 10K bytes (Test_date_time);
  • Fixes:


    • C#: generating an assignment of a record having array and string fields, to another such variable (is replacing to a call for the method copy());
    • FPC: {Bitmap_direct} lock/unlock fixed (implemented via TLazIntfImage);
    • Delphi/FPC: Divide oration with BYTE operands;
    • Delphi/FPC: memory leaks are fixed on temporary fixed arrays of bytes;
    • Code optimization (inline isertion, removing unused variables);
    • Delphi/FPC: {File_path}.Exists|_file (a file Path + '*' was checking rather then Path);

October, 28, 2018 - version: 0.91.9

  • Changes:
    • Automatic conversion from BYTE to INT (when passed as a function parameter);
    • C#: to represent in memory structures containing strings and arrays, classes are used. For source code on AL-IV there are no consequences, records are assigned as simple variables, assigning each its fields (as these should);
    • Delphi/KOL: an option added /$KEY_PREVIEW;
    • An event added: {Form}.scrolled (to handle scrolling events in controls like {Paint_lines});
    • A method added: {Form}.Set_column_width;
  • Fixes:


    • the operation '~' (bitwise negation) could not be applied to the BYTE type;
    • the logical operations (&, |, ^) are allowed between two BYTEs and between BYTE and INT operands;
    • a block comment is allowed between a CASE header and the first CASE branch;
    • C#: generating code for the operation '~' (bitwise negation);
    • C#: generating an assignment to the NONE an expression which is not just a function call;
    • DelphiVCL/FPC: using a sub-array of the DATA[];
    • Delphi/KOL: key_down event for a form;
    • Merging consistent assignments into a single assignment is not applied in case when the second assignment has function calls;
    • Generating a code for an assignment to a variable of some class a new object constructor of type which is derived from that base class (assigning values to fields not defined in the base class was leading to error);
    • Delphi/KOL: creating a label {Label} via the direct constructor (not calling New_label);

October, 12, 2018 - version: 0.91.8

  • Changes:
    • Delphi/FPC: Small optimization done for code while accessing methods of THIS object;
    • An instrumental application Pascal2AL4Class was added (to generate automatically a wrapper unit, when a project is partially converted to the AL-IV);
  • Fixes:


    • C#: generating code for an assignment of a value to an item of a fixed array which is a field of a local variable record;
    • Delphi/VCL,KOL: running compiled application under elder Windows versions (NT4);
    • Delphi/KOL, VCL, Free Pascal: the event selection_change was not calling;
    • Delphi/VCL: the event key_up was not compiling;
    • FPC: assigning a value to a short string (been a field of a record), when UTF8 characters are in the source string;
    • C#: possible error (floating overflow?) was suppressed in the drawing line function;

October, 9, 2018 - version: 0.91.7

  • Changes:
    • Added: {Screen}.Bounds (entire desktop rectangle);
    • Added: {Form}.Mouse_cur (current mouse cursor position, not only at mouse events handling routines, coordinates are returned relatively to the screen rather then to the form);
    • Added: {Bitmap}.Capture_screen({point}) (capturing a screen rectangle);
    • Added: demo-application Lupa;
    • Added: {Form}.Set_no_frame, {Form}.Set_no_borders;
    • Added: {Form}.Start_move; - dragging a form on screen with mouse after a click on any part of a screen;
    • Added: {Form}.Set_alpha (semi-transparency for a form);
    • Added: demo-application Clock;
    • Added: {System_functions}.Get_drives, Get_drive_type, Eject_drive;
  • Fixes:


    • C#: including a file to a project fixed, which were decided not to be copied due to an optimization (this was not affecting separate compiling with cs.exe but there were problems with such files in the MSVC);
    • C# an internal flag Application_running is set also on showing a form, allowing to handle events and to adjust columns just at the start application moment;
    • C#: generating code for an assignment of a value to an item of a fixed array which is a field of a record;
    • Delphi/KOL, C#: {Form}.Close calling had no effect without the "closed"  event set for the form;
    • Delphi/VCL: drawing a bitmap on a canvas was not working correctly in case when the canvas of the source bitmap itself was transformed before while drawing on it;
    • Delphi/VCL: {Form}.Set_position did not work without setting an event "moved";
    • Delphi/KOL: size of font on canvas was smaller;
    • Delphi/VCL, FPC/Windows: {Form}.Stay_on_top fixed;
    • Delphi/VCL, KOL: copying national text into clipboard independent of an active keyboard layout;
    • Delphi/VCL: a message about an absent disk firing on call of Directory_exists was eliminiated;
    • C#: for the {Form}, handling keyboard events added (without focusable controls);
    • FPC: generating an assignment the NONE to a record variable;

September, 28, 2018 - version: 0.91.6

  • Changes:
    • Free Pascal + LINUX:


      • IDE AL4 now compiling and working under Linux (tested in Linux Mint 18.3 running under Oracle Virtual Box)


  • Fixes:


    • FPC: {Dialog_dir} could not compile (FPC requires a typed pointer in -MObjFPC mode) ;
    • FPC: generating a statement CASE on the STR expression with national characters first in values did not work for UTF-8;
    • C#: generating assigning to a field of a record of type STR (short string), the fixed operator was requiring for non-local variables;
    • An optimization of an inline code insertion fixed, containing a comparison of an object with the NONE value;
    • An optimization of an inline code insertion fixed for case of calling method having calls of methods in parameters;
    • FPC/Linux: STR.Find(pattern) fixed for national characters in utf-8;
    • FPC/Linux: keyboard input was not accessible from {Paint_lines} (solved by redirecting keyboard input from a form with KeyPreview set to true);
    • FPC/Windows: {Form}.ask fixed for national symbols in a question (utf-8);
    • Delphi / FPC: Setting font size for controls (was set in pixels rather then in points becaming smaller);
    • Delphi / VCL + FPC: graphical resources leak was fixed;
    • FPC/Linux: {Canvas}.Text - always was painting black;

September, 21, 2018 - version: 0.91.5

  • Changes:
    • Free Pascal + LINUX:
      • LINUX: now visual projects can be compiled and run;
      • LINUX: {Canvas} works, including transformations.
      • LINUX: {Paint_lijnes} - simulated caret provided  (in Linux, there is no caret functionality).
      • LINUX: {Tray_icon} works.
      • LINUX: {OpenGL} - works.
    • {Tray_icon}: in the click event it is possible now to get states Key.Shift, Key.Control, Key.Alt, not only Mouse.Button.
  • Fixes:


    • Delphi / Free Pascal: checking exe-file created in result of compiling done for a several attempts separated by a small timeout (total timeout about 1 second) - otherwise too early check could fail;

September, 14, 2018 - version: 0.91.4

  • Changes:
    • Free Pascal + LINUX:
      • The compiler can now be compiled for the LINUX;
      • And it allows compiling from AL-IV code in LINUX using fpc compiler;
      • For this moment the most of console test projects are working well. Except Test_db. And also a simpiles windowed application Test_empty_form;
      • Successfully switched from -MDelphi compiling mode to -MObjFPC;
    • Documentation: syntax diagrams and RBNF forms are extended and fixed.
  • Fixes:


    • C#: generating code for CASE ? statement without a condition in the CASE header (sequential CASE) - in case when short strings were used in conditions, incorrect code was creating;
    • C#, Delphi, FPC: all the calls to trap functions are not generated in case when option /debug is not set;
    • Delphi / Free Pascal: pseudo-function TEST was not returning TRUE on the test stage;

September, 4, 2018 - version: 0.91.3

  • Changes:
    • {Bitmap}.Save_bmp, Save_jpg, Save_gif, Save_png, Can_save_fmt; C#: all formats, Delphi/KOL: bmp+jpg+png, Delphi/VCL: bmp+jpg, FPC: bmp+jpg+png;
    • An application added Tools\Diagram_draw;
  • Fixes:


    • C#: generating code for assigning a string field of a record to another string field;
  • The site:


    • language diagrams are renewed;



August, 30, 2018 - version: 0.91.2

  • Changes:


    • C#/Delphi/FPC: A trap added for Clear operation (the same TRAP method is used as for operations <<, Insert, Delete, but with parameters FALSE, -1);
    • {Paint_turtle}: commands F, N added to control filling a shape drawing;
    • {Canvas}: ENUM {quality}, field Quality, method Set_quality;
    • The language syntax:
      • the directive HISTORY added;
      • the statement UNCOOKED is added which can be used in place of any not yet written block or simple statement (the function where such statements present should also be marked as UNCOOKED);
      • it is disabled to assign a value to a field of a record stored in an array of records;
    • C#: implementation of RECORDs changed - now these are always implemented as simple structures (for arrays / short strings correspondently fixed arrays / fixed arrays of char are used);
  • Fixes:


    • Traps for fields of the object THIS did not work;
    • Traps for records was generating incorrect;
    • C#: event selection_change did not fired in application compiled with optimization turned on;
    • {Form}.Set_position(x,y,'KEEP_ON_SCREEN') fixed;
    • Optimization for an expression is disabled for case when the expression accesses THIS variable (code could not be created successfully);
    • Delphi: code generating for the operation value IN int_array[];
    • Delphi: generating (nested) access to RECORD fields at the left side of an assignment statement;
    • C#: {Canvas}.Arc now works exactly as in Delphi: two angles specify two points on the circle, and the line is drawing from the first to the last, in clockwise direction;
    • C#: {Canvas}.Arc was crashing on a zero size of an ellipse;
    • Delphi: accessing an outbound item of a dynamic array of records;


August, 10, 2018 - version: 0.91.1

  • Free Pascal progress:


    • Self-compiling is working: Delphi_build\AL4DelphiCompiler.exe -> FPC_build\AL4FPCCompiler.exe -> $By_FPC_build\AL4FPCCompiler.exe, resulting .pas files in folders FPC_build and $By_FPC_build are identical.
  • Changes:


    • C#/Delphi/FPC: When compiling in /debug mode, an information storing in memory is providing about a stack of called functions and its individual counters on the moment when these are called; Such information is available using system functions Trace_fun|ction(level), Trace_counter(level), Trace_levels или может быть "распечатана" в строку: Trace_stack(max_levels);
    • C#/Delphi/FPC: a modifier TRAP was added for class fields which allows to set up trapping methods on operations of read, write (and add/insert/delete for dynamic array fields). This can be useful for debugging purposes.
  • Fixes:


    • Since the Delphi can not go to through the end of the try-finally block, in case of intersecting FOR ... PUSH ... CONTINUE/BREAK the PUSH statement is implemented without try-finally; in functions having such intersections of BREAK/CONTINUE through the PUSH statements, to implement EXIT statement, the GOTO fin label is used;


August, 07, 2018 - version: 0.91.0

  • Free Pascal progress:


    • Console apps (in Windows), OEM text in console - OK;


    • Working with clipboard in a console app - OK;


    • Working with DB (MS Access) - OK (there were problems with ODBC, but these are solved);
    • Speed on numbers array sort - about twice worst then in Delphi7, on arrays of strings - about 4th times slower. This therefore better then C++ (and it is very great that compiling speed is much faster then for C++, almost near Delphi);
    • Pascal/FPC: an option /$NOINTERFACES added which allows not to add the Interfaces unit (this makes the FreePascal+Lazarus-made application size much smaller (140-200 Kbytes vs 1700Kbytes) but not appropriate in some cases e.g. to compile a GUI application);
    • Running an empty form GUI application - OK (the size therefore is about 1.84 Mbytes, with turned off debug information, and strip.exe can not already reduce the size);
    • OpenGL - OK (size 1.91Mb);
    • {Date_picker} - OK (in the project Test_visual_projects\Test_project);
    • {Tray_icon} - OK;


  • Code size / performance (Delphi/KOL):


    • Delphi/FPC: for STR / RECORD parameters, these are passed by reference (using const prefix);
    • Delphi/FPC: base types ArrayNNNN are removed, ambiguous virtual qualifier removed for some methods in DynANNNN like Add, Insert, Delete, Clear whenever possible (this allows to compiler to use smart linking);
    • Delphi/KOL: direct read and write from/to console used via functions FileRead / FileWrite;
    • Delphi/KOL: when the option #SMALLEST_CODE is added, tabulating between controls is not supported;
    • Delphi/KOL: After a lot of changes in code generation and in library functions, starting code for GUI application (Test_empty_form) was reduced to 36Kbytes, starting non-GUI application with console input/output (Hello_world) to 13Kbytes, without read/write (Test_date_time) size is about 11.5Kbytes.
  • Fixes:


    • overridden methods were not adding to a list of functions calling, so in result some functions could be removed while optimizing code;
    • it is disabled to remove methods if there are references to them from not yet deleted code (problems are possible with accounting of real functions usage);
    • it is allowed to access private fields of a class declaring an accessing class as a friend (FRIENDS directive);
    • a problem fixed with incorrect removing a class which is a prototype of a used localized class;
    • FPC generated code is stored in UTF-8 encoding;


July, 30, 2018 - version: 0.90.9

  • Changes:


    • Platforms / languages:


      • Supporting programming languages C++, Java, Python is stopped. The previous version 0.90.8 is still available to download;
      • A support for compiling Pascal code with Free Pascal added (console applications + utf-8 output to console).
    • Syntax:


      • It is allowed to call CALLBACK functions from CALLBACK functions without warnings about that;
      • It is not now required for CALLBACK functions to be not public  (a warning was firing earlier);
    • Optimizations (in code size):


      • For the compiler, an analyze added if event handlers were not created / methods were not overridden, to allow removing redundant native code responsible for calling them / preparing data for calling them (brackets in form //?{class} ... //. or //{class}.function ... //. in a target language code which is copied from low level units);
      • Records {rect}, {point} + correspondent functions are moved from the class {Canvas} to the separate class {Geometry}; the record {from_to} moved from {Memo} to {Control};
      • the class {Long_operation} file was moved to a separate folder Long_operation, and a fake mirror class is created in a separate folder Long_operation dummy;
      • all the code to work with the tray icon was moved from {AL4_form} to new class {AL4_tray}; code to work with fonts also moved from {AL4_drawing} to {AL4_font};
      • Delphi: an option $NOLONGOP added (preventing adding code for checking for long operations);
      • Delphi/KOL: option $NOERR adds also the option MATH_NOERR to the project options (and also NOERR as earlier);
      • In a generated code a method is not marked as "virtual/override" if it was found that it is not called;
      • Calling initializations procedures for unused classes is turned off (though classes itself were could left in code still its declarations are necessary e.g. its RECORD declarations);
      • An algorithm of finding unused classes/method is improved;
      • after a lot of changes on the code and in the compiler a simplest GUI application having a single form on Delphi/KOL occupies 38 KBytes (earlier it had about 160+ Kbytes); A minimal application without GUI has about 10.5 KB (w/o compressors, compressing allows decrease size to about 6.5 KB). In comparison to about 11.5 Kbytes for C#.NET empty form application, the minimal visual KOL application size 38 KBytes can seem too large, but do not forget that:


        1. a C# application binary can be running not on each PC: it requires certain .Net Framework to be installed. A KOL application can be run on any PC having Windows/Linux+WinE (even on Windows NT4/98);
        2. C# do not use static linking by default since its libraries are in Windows. At that time KOL application need nothing except that it have;
        3. This can seems strange but for not exactly empty application (when there are some controls on a form and the application do something like accessing files), the KOL application becomes about twice smaller then the C#NET application with the same functionality. An exclusion is for a starting DB application where C#NET initially has an allowence.
      • A modifier IMPORT, ANYWAY: {class} . is introduced temporary. When the optimization is on, it prevents removing classes imported with such flag. Also, native methods never removed;
      • The modifier NATIVE for functions is extended: now it can contain a list of dependences in form NATIVE({class}, {class}.function, ...). Such list allows to prevent removing necessary classes and its method in result of optimizations;
      • Also, native methods are not removed (in contrast to native functions);
    • Compiling:


      • C#: cs files are removed in the target folder automatically so it is not necessary to clear it manually in case of changing optimizations options;
      • Delphi: similarly, pas files in a target directory are removed just before compiling.
  • Fixes:


    • Delphi: generating of fields initialization in case of type {Object} was skipped due to ambiguous optimization;
    • Delphi: in the class {Paintbox}, the caret was not scrolling together with the box;


July, 20, 2018 - version: 0.90.8

  • Site:
    • The main site address now is kolmck.000webhostapp.com (and for the AL-IV, correspondingly, kolmck.000webhostapp.com/AL4/index.html). Yes, this is a free of charge hosting, and it shows a banner in a corner of the web-site but this is just hummer [Powered by 000webhost]. Also I hope that the site will not be deleted in case of my long absence.
  • Fixes:


    • Declaration of a variable provides now the left target for a repeating assignment / append statement starting from '..'.
    • C#: {Memo}.Set_range_sel ?
    • C++: {Clipboard}.Set_text fixed;
    • Compiler: array[].Count was always 0 in the PUSH block assigning temporary a value to the array item (still the array is marked as "fixed" for entire PUSH statement).
  • Changes:
    • For all overridden methods, a control of recursion deep level restriction is adding. This does not stop totally possible infinitive recursion but allows to prevent a crash in such case by a proclaimed earlier way (ignoring an incorrect functions);
    • Visual library: the method {Screen}.Run now has a parameter in which a main form should be passed to it on call (it is possible to create several forms, and the main form is not necessary to be created the first);
    • C#/C++(MSBuild)/Delphi: An option added /$ICON=path, which installs an icon for a compiled application (and for its application button);
    • C++: when a compiler is generating NATIVE functions, a warning can be obtained if 'return' statements are used there (still it is possible that a recursion counter will not count properly and in result an exception of type TooDeepRecuirsion will be fired);
    • Syntax:
      • string literals '"..."' abandoned;
      • instead, literals ''...'' are introduced (double apostrophes bounding lines). As in the previous experiment, such strings also must be placed in separate lines of code. For such strings balancing of quotations '"' is not checked. It is possible to place any characters in such string literals except symbols [''] at its bounds.


June, 29, 2018 - version: 0.90.7

  • Changes:


    • Syntax (sugar): if a statement is starting from two dots, those are replaced with (usually) the left expression of a previous assignment. This rule can be used to short and decorate e.g. code of a form CONSTRUCT function (such continuation assignments are not accounting as standalone statements forming a single statement together with its base statement):
      Memo = New_memo(THIS, "MEMO", 0)
    • In Delphi/KOL the most of defines are moved to EXTERNAL_DEFINES.inc (to prevent compiler error "Too many conditional symbols");
    • In Delphi/VCL for columns on form aligned 'TOP'/'BOTTOM', both scrollbars are disabled;




June, 7, 2018 - version: 0.90.6

  • Changes:
    • Some progress in compiling to the Python of GUI application, problems which were solved:
      • 2D transformations (including text rotations);
      • Scrolling in the {Paintbox}.


May, 26, 2018 - version: 0.90.5

  • Changes:
    • Some progress in compiling to the Python of GUI application, problems which were solved:
      • correct controls placing in columns, columns placing on form;
      • handling mouse events, change size event, closing form event, timer event;
      • entering password for {Edit};
      • creating and showing a popup menu at a click point;
      • calling a file open dialog, a yes/no dialog;
      • transforming a canvas during painting (for an ellipse and an arc this was implemented via polygons).


May, 20, 2018 - version: 0.90.4

  • Changes:
    • Great progress in compiling to the Python of GUI application (though there are not finished things there - events, classes - but work is continuing);


May, 7, 2018 - version: 0.90.3

  • Changes:
    • Great progress in compiling to the Python: simplest GUI applications are compiling and working;
    • Python: {Clipboard} works now via tkinter (GUI library for the Python), so it is not necessary to install additionally (pyperclip);
    • {Paint_turtle}: sinse in Windows 8 incorrect colors can be returned by system functions, the 'BUTTON_TEXT' color is now used as a default normal color, and the method Set_normal_color added to set a desired normal color;
    • All visual tests are moved from AL4\Library\Visual to AL4\Test_visual_projects; OTLv4.h now is searching in %OTL% directory (%OTL% environment variable is required);
  • Fixes:
    • {Stream}.Get_line ==> can now load lines from unix text files (#LF - ended);
    • C#: {Button} autosized height was too low in systems with large font set, now recalculated on base of default font;
    • C++: {Random}.Probable ==> returned 0.0 always;
    • C++: analyzing errors was too suspicious: for case of any word "error" in an output it decided that it is not necessary to run compiled tests/application.


April, 12, 2018 - version: 0.90.2

  • Changes:
    • It is disabled to use ++/-- operations in expressions containing also && / || operations;
    • Good progress in compiling to the Python: console applications are compiling and working (under Windows and Linux);
  • Fixes:
    • Operations IN/!IN are disabled for case of checking a real number value inclusion into an array of real numbers.


April, 12, 2018 - version: 0.90.1

  • Changes:
    • {Stream}: faster loading strings in ANSI encoding;
    • C++: compiler option $SSTRINGS abandoned;
  • Fixes:
    • Delphi/KOL: Write_file_stream did not write any;
    • C#: loading text in an ANSI encoding;
    • Delphi/VCL: it was running 100% one processor core always;
    • Optimization with "inlining" a function body is not accepted if an "inlined" function itself calls functions from the classe which is not importing in the target function (otherwise there are problems in a target compiler).
  • IDE AL4:
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).
    • Pascal (partial) syntax highlighting added;
    • Painting speed increased.


April, 8, 2018 - version: 0.90.0

  • Added:
    • Compiling the AL-IV project to a Python program. For now, for console applications only. (The test project Hello_world is compiling and working).
  • Changes:
    • Unbalanced quotations errors is replaced by a warning after the END.
  • Fixes:
    • Using '" ... "' not in the first line of a multi-line string;
    • Delphi/KOL: Running compiled application in earlier OS (Windows NT4);
  • IDE AL4:
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).
    • syntax highlighting added for other programming languages (now, implemented for Python and FoxPro).


March, 21, 2018 - version: 0.89.3

  • Changes:
    • A semantics of the modifier TESTED was changed: a construction TESTED(nn) now means that class is tested at least on nn%. The TESTED modifier without parameters as well as for case when UNTESTED is not specified means that the class is proclaimed to be tested on 100%. Too strong proclaiming (with a gap more then 5%) is accounting as an error;
    • The language syntax: A special string literal format is added:
      '"..."' - such string constants can be placed only in separate lines of code, restricting it using mainly with long (multi-line) string constants; such strings allows to write any quotations to be written in a string except the ("') pare of quotations used only at the end of such triple-quoted string; therefore the way to check balancing quotes is still working for all other lines of code;
    • The language syntax:: Multi-line comments format is changed. Comments should start with the symbol */ and ended with /*. AL-IV code always should be located between symbols /* and */ as it would be comments for another language even if only AL-IV code is found in a file;
    • The DEBUG statement now can be written only in uppercase, the debug variant is no more supporting.
  • IDE AL4:
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


March, 16, 2018 - new version: 0.89.2

  • Changes:
    • Compiling of the compiler with C++ (code of AL4.h, AL4.cpp was moved to separate files from the compiler code, so its final adoption to a final project string options became possible);
    • C++ applications for Linux can now be built in Linux with the AL-IV-to-C++ compiler prepared to work in Linux;
  • Fixes:
    • C++: array[].Insert(At, Value);
    • C++: {System_functions}.Parameter(i) ;
    • C++, Delphi, Java: {System_functions}.MIN_INT (typo FFFF_FFFF instead of 8FFF_FFFF);


March, 11, 2018 - version: 0.89.1a

  • Fixes:
    • Compiling C++ visual projects;
    • C++: {Canvas}.Offset (previous change was incorrect);
    • C++(GCC): assigning records, assigning to an item of an array of records;
    • C++ (MSBuild): target DC transformations are off


March, 10, 2018 - version: 0.89.1

  • Changes:
    • A capability added to compile C++ visual projects with GCC (for Linux);
    • {Bitmap} is drawn without any transformations set to the destination {Canvas} by Draw and Stretch_draw methods: destination point specified is always assumed relative to the top-left corner of the canvas - the reason is that not all platform support such bitmap draw operation natively and sufficiently fast, at least in Linux X this can be a problem;
  • Fixes:
    • Compiling C++ visual projects;
    • Building C++ projects via MSBuild;
    • C++: {Canvas}.Offset (ambiguous conversion to pixels before the translation);
    • C#: {Canvas}.Arc(...., FALSE);


March, 5, 2018 - version: 0.89.0

  • Changes:
    • A capability added to compile C++ console projects with GCC (for Linux); For now, compiling of the test code and running it are processing in the Windows. Then, final c++ project is created together with a command file _call_gcc.cmd to run in Linux. After compiling/building in the Linux, the executable is created and can be launched there.
  • Fixes:
    • Creating a console with keyboard input capability in a windowed project for C++ (MS Windows);


February, 26, 2018 - version: 0.88.0

  • Changes:
    • A capability added to compile C++ projects with GCC (for Windows) (with the key /$GCC);
  • Fixes:
    • compiling generic functions (see AL4\Test_projects\_Test_sort and class {Sorting});
  • IDE AL4:
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


February, 18, 2018 - version: 0.87.4

  • Fixed:
    • better scrolling in classes {Paintbox}, {Paint_lines} (C#);
    • C++, Delphi: saving compiler messages to Compiler_messages.html on a test stage was prevented (in case when the compiler is a part of a compiled application);
  • IDE AL4:
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


February, 14, 2018 - version: 0.87.3

  • IDE AL4:
    • showing localized errors and warnings;
    • showing/editing localized source code;
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


February, 12, 2018 - version: 0.87.2

  • Changes:
    • tests in a class are not performed again if the class was not changed and there were no changes in classes on which it depends on (all the target languages/platforms);
    • Tests for the class {Form};
  • Fixes:
    • C++: visual application with {Paintbox} descendants could crash on form create (too early calling paint event);
    • all the warnings/errors now are written to the Compiler_messages.html (some messages were not stored there);
    • compiling a function call from a TEST function could lead to creating an incorrect (non-compilable) code;
    • compiling the ending TEST block could be interrupted earlier because of too optimistic prediction of iterations amount;
    • {Form}.Set_left (C++, Java);
    • C++: tests for GUI-applicationa are compiled for and executed in a GUI mode (rather then in console mode) - otherwise it is not possible to test GUI applications;
  • IDE AL4:
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


February, 7, 2018 - version: 0.87.1

  • Changes:
    • Added: {Screen}.Default_font_size (default value is 10 pt);
    • automatic sizes for buttons, labels, check boxes in columns aligned 'TOP' and 'BOTTOM' - by text size in those controls (C#);
    • C#: tests in a class are not performed again if the class was not changed and there were no changes in classes on which it depends on (current version does not take into account changes in TEST  functions though);
  • Fixes:
    • Delphi/KOL: the option NIL_EVENTS is added now (without it, problems while executing) ;
    • Java: automatic sizing of {Label};
    • Java: setting custom font size for controls;
    • Tools\Test_report updated (to work in any directory where AL-IV is installed);
  • IDE AL4:
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


February, 04, 2018 - version: 0.87.0

  • Changes:
    • Delphi/KOL, C++: implementation of dynamic string arrays was changed;
    • C#: {System_functions}.Platform_info contains Windows version and .NET version;
    • Pseudo-array DATA[] is accessible now in static functions too, not only in methods of a class;
    • Reading of text files in UTF-8 encoding became faster (C++, Delphi);
  • Fixes:
    • Creating fixed arrays of Boolean (Delphi/KOL);
    • Generating a DEBUG block having variable declarations (Java, Delphi);
    • Ending modal dialog (C++);
    • c++: compiling visual projects with the option /$NOSSTRINGS;
    • C++: comparing SString strings;


January, 29, 2018 - version: 0.86.9a

  • Fixes:
    • Returning modal dialog answer;
    • Calculating {Control}.Bounds (Delphi/VCL);


January, 29, 2018 - version: 0.86.9

  • Changes:
    • AL-IV can now be installed on any disk (a path to the installed folder should be stored in the environment variable "AL4");
  • Fixes:
    • For the {Dialog}: calling Hide now can also be used to end a modal dialog; other fixes (Delphi/VCL, Delphi/KOL, C#, Java);
    • Generating Report_leaks (C++, for options /$Strings==std and /$SSTRINGS);
    • Dynamic arrays of Boolean (Delphi);


January, 26, 2018 - new version: 0.86.8

  • Fixed:
    • capturing mouse for a {Paint_tabs} (Delphi/VCL);
  • IDE AL4:
    • Fixed: incorrect positioning in text by mouse click;
    • Fixed: deleting text from memory together with closing tab;
    • Fixed: auto-completion after '.' (suggesting fields, methods, etc.);
    • Improved: taking into account (()) nesting hinting function parameters;
    • Added: hints on class/record constructors {Type}(... by CTRL-SPACE;


January, 24, 2018 - version: 0.86.7

  • Fixes:
    • {Control}.Set_foreground / Set_background;
    • {Bitmap}.Load (C#);
  • Added:
    • {Paint_turtle} - a button with a glyph drawn by a "turtle";
    • An application Tools\Turtle_image to prepare turtle images (supports underlying images);
  • IDE AL4:
    • tool buttons added for some often operations: save, find, undo, compile);
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


January, 23, 2018 - version: 0.86.6

  • Fixes:
    • Compiling {OpenGL} projects;
  • Changes:
    • {Paint_tabs} - animation with auto-scroll is not now started by clicking a tab with a left mouse button (only with a right mouse button);
  • IDE AL4:
    • localization, translation to Russian;
    • fixes and improvements (see in Ide_al4.al4 at the end of source file).


January, 19, 2018 - version: 0.86.5

  • Fixes:
    • Assigning an object in a dynamic objects array (Delphi);
  • Changes:
    • {Long_operation} - finished for C++, Delphi/KOl, Delphi/VCL.
  • IDE AL4:
    • fixes (see in Ide_al4.al4 at the end of source file).


January, 19, 2018 - version: 0.86.4

  • Fixes:
    • {Canvas}.Reset_transorm -> ResetTransform;
    • MIN_INT = 0xFFF_FFFFF -> 0x8FFF_FFFF;
    • Code generating to work with fixed arrays in some cases;
  • Changes:
    • FOR loops ...TO MAX_INT] and DOWNTO MIN_INT] are disabled. In case of non-constant to-value equal such value, the loop can be not executed at all (C#, C++) since actually a for (...; < to_value; ...) is used where to_value = value+1 (and in case of MAX_VALUE+1 it becomes equal to MIN_VALUE);
  • Added:
    • {{Long_operation}, automatic showing a progress long operation dialog with a capability to cancel the operation (changes are in {Screen}, {Form}, {AL4_form} and in the core: for C#, C++);
  • Changes:
    • Some improvements, better navigation on symbols (CTRL-ENTER);
    • Other improvements and fixes (see in Ide_al4.al4 at the end of source file).


January, 12, 2018 - version: 0.86.3

  • Fixes:
    • Trim, TrimL, TrimR (C#: C# native Trim does not remove '\0' chracter);
    • Code generation to work with fixed arrays (C#, Delphi, C++);
  • Added:
    • option key /norun (compatible with /run, but only the last is applied);
    • the rest of options following /@ path-of-configuration also is handled, at the end of options in a configuration file;
  • Changes:
    • It is now possible to compile project from the IDE, and to list errors/warnings from a special window, including compiling without running;
    • Other improvements and fixes (see in Ide_al4.al4 at the end of source file).


January, 7, 2018 - version: 0.86.2

  • Changes:
    • It is now possible to compile project from the IDE, and to list errors/warnings from a special window.


January, 4, 2018 - version: 0.86.1

  • Changes:
    • {Form}.Set_column_auto_arrange(BOOL) - allows to turn off automatic placing controls on the column and to place and size it by your own code (e.g. in the form event "resize").
    • a compiler outputs all the errors and warnings to Compiler_messages.html also.
  • Fixed:
    • {Form}.activated event;
    • Platform_info (Delphi/KOL);
    • {Form}.key_press (Key.Alt, Shift, Control, Win did not set - Delphi KOL, VCL);
    • function TEST returned FALSE in a test mode;
  • A documentation is completed in part:
    • AL-IV: How to start programming


December, 29, 2017 - version: 0.86.0

  • Changes:
    • Additional optimizations in C++ code:
      • SString class to optimize strings manipulations;
      • graphics output in classes {Canvas}, {Bitmap}, {Paintbox} ... made via Windows GDI;
  • Fixed:
    • optimization of CASE could form an erroneous code.
  • The first time the editor Ide AL4 is published, version 0.86 (betha).


December, 17, 2017 - version: 0.85.9

  • Changes:
    • A function added {Font}.List_fonts(Options, Names[]);
    • Optimization is turned on for a C++ when building with the /final option (can be off by the option /$NOOPTIMIZE);
    • Additional optimizations in C++ code;
  • Fixed:
    • cursor shape for {Paintbox} is set only for its box not affecting its scroll bars (C#, Java);
    • Optimization errors (replacing a method call with its body);
    • Generating unique method names in class descendants (for names not matching by registry case only - Delphi);
    • Checking for a necessity of import of classes used implicitly (in FOR/PUSH statements);
    • Working of a file filter in Java (in Windows addFilenameFilter is not working but there is a non-documented "feature" with setFile method);
    • Fonts anti-aliasing (Java);


December, 11, 2017 - version: 0.85.8

  • Changes:
    • Friends of a class can access its non-public methods.
  • Fixed:
    • key_press event was firing for the key DELETE  thereas the DELTE key was not received in key_down/key_up events(Java);
    • setting cursor shape in {Paintbox}, beam shape cursor in {Paint_lines} (Delphi/VCL); also for Java-implementation cursor showing changed to prevent instant window repainting.


December, 7, 2017 - version: 0.85.7

  • Changes:
    • A statement
      FRIENDS: {class1}, ... {classN} . added. Friends of a class can access its non-public fields and (later) methods.
  • Added:
    • Attributes "disabled", "checked" for menu items;
    • Encoded symbol #ESC added;
  • Fixed:
    • {Paint_tabs}: highlighting did not work for tabs left to the current;
    • {Form}.mouse_move - coordinates in the mouse field (Delphi/KOL);
    • Focusing {Paintbox} and its descendats by mouse click (Java);
    • {Listbox}.Clear; selection_changed event for {Listbox} ;
    • a method for array of STR: Remove(STR) (Delphi, Java);
    • Double destroying controls on closing form (C++/wx);
    • {Paint_tab} .Move_tab(From, To);


December, 2, 2017 - version: 0.85.6

  • Changes:
    • Comparing for equality (==) and inequality (!=) is not allowed for REAL values;
    • For {Form} columns in Java implementation only vertical scroll bars left;
  • Added:
    • {Sorting} .Data_sort(Count) - to sort arbitrary data (methods data_compare and data_swap should be overridden in the same object);
  • Fixed:
    • {Listbox}.Insert_item in the Count position;
    • code generation for assigning a record to an array of such type records (Delphi);
    • event click firing on right mouse button (Delphi/VCL,KOL, C++);
    • {Text_file}.Save: saving text in 'UTF8' format (Delphi, C++);
    • inserting an item to a dynamic array of BOOL or BYTE (Delphi);
    • size of the first label in a column (for columns aligned 'LEFT', 'RIGHT' or 'CLIENT') is set to column.Label_width value (Java);
    • pop-up menu coordinates when a control is clicked (Java);
    • {Dialog_file}.Select_file (Java: bug in Java 7 & 8);
    • flickering is removed in {Paintbox} and its descendants (Java: Jpanel from swing was used instead of Canvas from awt);


November, 27, 2017 - version: 0.85.5

  • Added:
    • {File_path}.File_info(Path) ==> {file_info} (dates, attributes, size);
    • In addition to a symbol @, which turns on mode in which new line symbols are added in a multiline string constant automatically, a symbol @@ added which allows to turn such mode off (to the end of a constant or to the next symbol @);
    • {Form}.shown event;
    • Methods of {Edit} class: Set_selection_range(Start, Length), Select_all, Get_selection_start, Get_selection_length;
    • Method {Control} .Set_selection is abandoned and replaced to Replace_selection;
  • Fixed:
    • event mouse_double_click (Delphi/VCL), - sequence of calls was DOWN-UP-DBLCLICK-DOWN-UP instead of normal DOWN-UP-DOWN-UP-DBLCLICK;
    • code generation for case of creating a structure containing a fixed array (C#);
    • code generation for assigning a value to a record field if a record is from an array (C++);
    • On press Ctrl+[, ] and some other keys a field Key.Char was not assigned to a correspondent character;
    • event click firing for default and cancel button when Enter/Escape is pressed (Java, C++);
    • preserving the Screen object on all the time while an application is running, closing all the forms at the moment when the main form is closed (Java, C++);
    • still now for C++ all the resulting sources are united into one big cpp-file to speed up project compiling. The problem is that after 65536 lines it is not possible to make breakpoints. Now, for very large resulting projects in C++, large output source files are splitting onto enough small ones.


November, 22, 2017 - version: 0.85.4

  • Changes:
    • A requirement added on code structure: block statements (CASE, FOR, FOREVER, PUSH, DEBUG, debug) must always start from a new line (i.e. it is not allowed to write those in the same line following ELSE or in CASE branches follwing ':' or '?').
    • While calling a Str|ing embedded function to convert value to string, its name can be reduced to S.
  • Fixed:
    • direction in vertical_wheel (Java, Delphi/KOL);
    • Setting {Paintbox}.Set_content_size less then current Visible_area_size (by width, height - Delphi/VCL);
    • Setting modifiers Ctrl, Alt, Shift in the field {Form}.Key for all the mouse and keyboard events (Java);
    • {Paint_lines} always stores values set by the method Move_top_left_to (for both vertical and horizontal directions) and returns it in case when a difference between that value and a correspondent scrollbar position is less then 1 in absolute value (this fixes rounding problem which occur in result of rounding to nearest integer of a value assigned to a scrollbar current position property);
    • C# compiler errors analyzing: not only word "error" is checking but its neighboring characters to ensure that error is not a part of longer word (i.e. a class name);
    •  code generation for STORED parameters (C++);
    • generating [].Delete(index++) (in case when index is auto-decremented or auto-incremented).
  • A small present to myself for anniversary a year from the first publication: an own code editor for AL-IV started (and sufficiently progressed). It is planned to finish its developing up to the end of the year.


November, 15, 2017 - version: 0.85.3

  • Added:
    • {Control}.Location ==> {rect} - control coordinates in a parent form rather then (Left, Top returning coordinates relatively to a parent column).
  • Fixed::
    • Generating code for NATIVE directives not starting from "using" (C#): moved into a resulting class;
    • Optimization in case of inlining of a function containing in an expression a type cast of class: RESULT = x.y.z.{Some_class};
    • {Control}.Top (Delphi/KOL);


November, 12, 2017 - version: 0.85.2

  • Changes:
    • on C++ code generation, in function Main following code is added: _CrtSetDbgFlag(0); (to prevent very long delay while reporting about memory leaks, on the application end - though these are not memory leaks actually but results of STL working).
  • Added:
    • A enumeration {Paintbox}.{cursor}, a field Cursor|_shape, a method Set_cursor(New_c|ursor_shape)
      -- it seems does not work for Delphi VCL (VCL bug?);
  • Fixed:
    • Generating code for NATIVE directives not starting from "using" (C#): moved into a resulting class;
    • {Canvas}.Measure (C# incorrectly calculates size for a string having trailing spaces);
    • special key codes handling (C++/wx);
    • code generation  for PUSH statements in CASE branches (C++ compiler can not initialize local variables);
    • For the {Paintbox} (and its descendant {Paint_lines}) when the option "F" is set (focusable), then all the navigation keys are handled in the control itself (all the languages/frameworks);
    • {Localize_str} for Java - in case when Set_directory_lang was not called;
    • {Paint_lines}.provide_caret (Java) - removing old caret before setting new one.


November, 9, 2017 - version: 0.85.1

  • A capability provided to use variables of class {Object} (and assigning NONE to them).
  • Added:
    • {Canvas}.System_color({system_color}, enumeration {system_color};
    • A capability to add a timer for any control for animation purposes (mainly), methods {Control}.animate(Count, Interval) and animation(Tick) (a callback event);
    • Own mouse events handlers for {Control} class: mouse_move, mouse_down, mouse_up, mouse_wheel;;
    • A visual component {Paint_tabs}:
  • Fixed:
    • {Canvas}.Offset , Measure - pixels were used, now current units of the canvas are used (default are points);
    • mouse coordinates {point} mouse for all the mouse events (in Java & C++);
    • pop-up menu coordinates for {Tray_icon} (C++);


November, 5, 2017 - version: 0.85.0

  • A capability added to specify parameters restrictions in form of comparison relations, e.g.:
    , IF P1 IS CONST, THEN P1 >= 0 ...
  • Fixed:
    • {Canvas}.Offset, Rotate - made the same for all the frameworks.
    • calling {Form}.resize event provided on form maximize / restore (Java).
  • A control {Paintbox} with content scroll is finished.
  • A visual control {Paint_lines} (based on {Painbox}) added with support of blinking caret and specific methods to handle lines.



Previous versions history (2016-2017)

See here