ENGLISH

 

RUSSIAN(Русский)

 

 

AL-IV:    Versions history

 

August, 13, 2017 - new 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.

 

Home