Main
News
Commands
Documentation
Examples
Forum
Links
Download

Effectus 0.3.1 (Version date 2.11.2019)

New features
  • Better file handling operations on reading and saving source code listing files
  • New features via -i flag (output information about variables, struktures, procedures and functions
    • Variables, arrays, pointers and types grouped together in table list
    • Variable indication of TYPE declaration
    • Not showing of local variables (they are shown in procedure and function calls anyway)
  • Win32 and Win64 platform binaries
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • Log file is back (saving compilation progress succession to existing log file)
  • Code refactoring and small optimizations
Bug fixes
  • Basic support for pointers and records is back
  • Basic support for INCLUDE files is back

Effectus 0.3 (Version date 21.5.2019)

New features
  • Mad-Assembler (MADS) integrated into Effectus program (version used is 2.0.8)
  • Program source code revision and refactoring
  • Program parameter changes

Effectus 0.2.3 (Version date 23.2.2016)

New features and fixes
  • Console option -i additional features:
    - showing a note about variables declared as memory addresses
    - variable var19750412 (Effectus temporary variable) hidden from the list of user-defined variables
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • Fixed assigning custom routine names in strings as normal text. For example: Print("ADD8(100,50) = ")
  • Fixed handling of ELSE statement not at the beginning of the line
  • Fixed PrintF function handling of BYTE values using %U option
  • Fixed assigning a value to a variable defined as pointer to specific memory address

Effectus 0.2.2 (Version date 24.1.2016)

New features and updates
  • equates include statement moved to common library, eliminating additional code in every Effectus MADS source code listing
  • Effectus and MADS library source code listing description and comment changes
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
Fixes
  • Fixed handling of machine language routine parameters:
    • Y register is back
    • Parameter list handling and support of all 16 parameters like in Action! is implemented:
      Parameter order: A, X, Y registers, then using memory addressess from A3 to AF
  • Proper handling of routines which have space caharacter between routine name and parameters. For example:
    SOUND (0,30,10,8) is the same as SOUND(0,30,10,8)

Effectus 0.2.1 (Version date 12.10.2015)

New features and updates
  • Improved handling of comments
  • Memory locations $A0 - $A3 used as function return values instead of STORE1 - STORE3 labels (which are commented out in lib\equates.asm)
  • Custom functions: returned value stored in memory locations $A0 and $A1 instead of STORE1 label
  • Custom ASM functions: register y removed from the parameter list
  • Proper atascii conversion of the value assigned as uppercase or lowercase character, preceeded with punctuation mark. For example:
    IF FLAGS(I)='T THEN // Different as FLAGS(I)='t
    IF FLAGS(I)='t THEN // Different as FLAGS(I)='T
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum

Effectus 0.2 (Version date 23.8.2015)

New features and updates
  • Better handling of conditional and branching expressions:
    - Functions are allowed in conditional expressions. For example:
    • WHILE Peek(764)=255 DO OD
    • WHILE Strig(0)=1 DO OD
    • IF Mult2(y1,y2)<>x2 THEN ; Custom function
    - Array elements can be used as part of conditional expression. For example:
    • IF arr(1)=5 THEN
  • Improved support for DEFINE command (completely rewritten code)
  • Added support for expressing ASCII representation of a character in a way:
    • a='A
    • arr(3)='C
    • IF FLAGS(I)='T THEN
  • Some updates in multi-line department:
    - Branching starting and ending pair can be put in code more freely. For example:
    • FOR n=10 TO 14 DO
    • WHILE Peek(555)=0 DO OD
    - One command on the same line is allowed in IF/THEN conditional statement. For example:
    • IF I<>2 THEN PutE() FI
  • Console and option updates:
    • New option added (-dl) for deleting log file before compiling new code
    • -i option fixed with some layout changes to show variable info in tabular fashion
    • .eff extension added to Effectus source code listing automatically if not present
    • Informing with message in case false option is typed or numeric value is needed
Bug fixes
  • Fixed error declaring variable with assigned memory location and putting some comments on the end
    BYTE RTCLOK=20 ; addr of sys timer
    BYTE SDMCTL=559 ; DMA control

Effectus 0.1.8 (Version date 10.8.2015)

New features and updates
  • Arrays
    • Decimal value for memory address of ARRAY variable can be assigned
      Example: BYTE ARRAY arr=28000
    • Better handling of ARRAY variables of type BYTE, INT and CARD
    • Array variable can be passed as argument to routine
      Example: Graphics(num(3))
  • Configuration file
    • A new parameter for declaring maximum number of ARRAY elements (ARRAY_MAX) added
    • A new console option added (-i), which shows all used variables in the Effectus listing
  • Effectus source code listing output
    • Removed empty lines above and below link libraries
    • Removed space before some arithmetic operations
  • Effectus code revision and optimization
Site update
  • Menu and text layout changes
  • Forum updates
  • HTML code revised

Effectus 0.1.7 (Version date 27.7.2014)

New features and updates
  • Declared ARRAY variables can be assigned to memory address
    Examples:
      BYTE ARRAY arr(4)=$8000
      CARD ARRAY arr=$8000
  • UPX used for compressing Effectus binary file (approximatelly 3x smaller)
  • SCompare very basic functionality implemented (support for comparing two strings), function added to common.asm library file.
    Currently, there are some restrictions:
    - Value=255 instead of Value<0 when checking for string 2 greater than string 1
    - Fuction must be assigned outside branch statement:
       value=SCompare(str1,str2) -> OK
       IF SCompare(str1,str)>0 THEN -> NOT OK
  • InputB, InputI and InputC basic functionality implemented (numeric input support, currently only valus 0 to 9 applicable, other values, including characters, equal to zero)
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • FOR loop: no extra incrementing of a number to count to (for example, BYTE variable with value 255 can be declared and no error will show up, prior to that value 256 resulted in fatal error)
  • Linux: Default value of ./lib/ for Effectus library directory set in case it doesn't exist in config file
  • Mads source code listing output updates and fixes:
    • Label LabelUntil removed when not needed (it is used in case actual UNTIL loop exists)
    • Labels loop_jump and jump_from_for_loop removed when not needed (it is only used with EXIT command)
    • StrB, StrI, StrC: Removed last iny command as offset from converted number (no need for additional increment, because last element of array is reached)
    • Removed unnecessary code for array string manipulation, because string assignment of array element is straighforward by declaring string at the bottom (for example, .array items_eff_array_str_0 [40] .byte = $ff at the top removed from the code)
    • ARRAY declaration does not produce empty line if there are no predeclared values
    • DO OD infinite dummy variable set to 1 (previously 10) - mva #1 loop_var
  • Effectus code revision and optimization
Bug fixes
  • Fixed usage of BYTE ARRAY elements
  • PeekC function fixed
  • ELSE and ELSEIF bug fix, which was introduced again in previous version

Effectus 0.1.6 (Version date 18.7.2014)

New features and updates
  • Mixed types (BYTE, CHAR, INT, CARD) allowed for routine parameters
  • Custom routines can have the same names as equates
  • BYTE value returned for Locate and GetD functions
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • GetD function moved from runtime.asm to io.asm library
  • Effectus code revision and optimization
Bug fixes
  • GetD function usage fixed (it can be used in loops such as FOR, WHILE, etc.)
  • The order, in which routine parameters with different types are declared, does not change
  • Fixed output of space character " " using statement Put(' )

Effectus 0.1.5 (Version date 13.7.2014)

New features and updates
  • Procedures can be mapped (vectored) to OS routines
    Examples:
      PROC CLICK=$F983()
      PROC BEEPWAIT = $FDFC (BYTE times)
    The parameters used can be CPU registers a, x and y in the same order. This functionality will be expanded further with other features in the future.
  • PrintF routine improved
    • Minimal hexadecimal number support (currenly only numbers from 0 to 15 supported)
    • Minimal '%' sign support. Using string format option %% in the middle of string, that part is replaced with ':'. Used as lone string format option '%%' (PrintF("%%"), the output results to '%' as expected.
  • Machine code inside routine is laid out as inline code inside this routine, so no more jump and memory assignment is needed (jsr, org)
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • Additional empty line removed after compilation information in the console
Bug fixes
  • Fixed usage of %E (new line) string format parameter in PrintF routine
  • Fixed problem using one parameter in the routine

Effectus 0.1.4 (Version date 4.7.2014)

New features and updates
  • Routines and arrays can be assigned to vectors (for example: VVBLKD=Scroll, where vvblkd is a vector and scroll is a routine)
  • Improved support for assigning array variables
  • Multiple operands allowed in function variable assignments for Rand, Peek, PeekC, Stick, Strig, Paddle and Ptrig.
    Example: X=Rand(70)+1
  • Some changes in using inline machine language code (no overhead of jsr and org command)
  • Direct parameter name assignments in routine calls in MADS code (no need for special variables like b_param1 and w_param1)
  • Added very poor support for direct memory address pointers in variable assignment expressions for functions listed above. Currently only one '+' offset operand is allowed in such expression.
    Example: SM=PEEKC(DL+4)
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • Effectus code revision and optimization, including better memory usage in some parts of the code
  • Program compiled with Free Pascal 2.6.4
Bug fixes
  • PrintF routine: parameters can be lowercase or uppercase!
    Example: PrintF("i=%i and j=%i%e%E", i, j)

Effectus 0.1.3 (Version date 27.6.2014)

New features and updates
  • If conditions: hashtag sign (#) implemented as alternative for <> conditional expression
  • InputMD string device routine implemented
  • InputSD string routine buffer increased from 120 to 255 characters
  • Filename added to the header files (adviced by greblus)
  • Effectus code revision and optimization
  • Unneccessary code removed from .proc procedure block of generated MADS source code (for example: mva b_param1 N1_eff_)
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
Examples updates:
  • New ATR image file uploaded (IO.ATR), which includes string device routines and test files
  • MODULE statement removed (It is not required for proper functioning of the programs)
  • New examples files: if_diff.eff, inputsd.eff, inputmd.eff
  • rand_game.eff program example optimized thanks to ELSEIF conditional statement

Effectus 0.1.2 (Version date 23.6.2014)

New features and updates
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • Output of compilation status is appended to the file (by default to the output.txt, which can be set in config.ini configuration file). New file, efflog.txt, is introduced, which holds last compilation status
  • "Compiling was successful!" message is removed (adviced by greblus).
  • Effectus code revision and optimization
Bug fixes
  • Linux environment: Fixed issues with some routines using string parameters (fixed core string manipulation code, bug found by greblus)
  • Fixed multiplicated parameters passed to main program (bug found by greblus)
  • Error messages are not duplicated any more (issue found by greblus)

Effectus 0.1.1 (Version date 18.6.2014)

New features and updates:
  • Effectus code revision and optimization (better usage of custom and core string manipulation routines)
  • Only one OR and one AND logical operators can be in the same conditional expression statement, besides other rules, which allow one logical operator many times in the same conditional expression statement. Some valid examples:
     IF (i > 21 AND j < 10) OR i>36 THEN
     IF i > 1 AND j < 21 AND i>3 AND i>60 THEN
     IF i > 4 OR j < 41 OR i>7 OR i>99 THEN
Bug fixes
  • Proper handling of include files with INCLUDE directive in Linux environment (bug found by greblus)
  • Random number generator issue solved by properly used Effectus code. You are adviced to perform any random number generator routine after some user input, so Atari system can serve with more randomly choosen generated number. Check rand.eff and rand_game.eff examples for more information.
  • Optional condition statement brackets "(" and ")" are ignored for proper assembling

Effectus 0.1 (Version date 12.6.2014)

New features and updates:
  • Linux version of Effectus package compiled and arranged by greblus from AtariAge forum
  • More versatile usage of parameters of system global variables COLOR and DEVICE.
    For example: color=i+3
  • equates.asm (in lib directory) updated by including labels compiled by JAC!
  • Output log file enabled in Linux version
  • Removal of unnecessary variables generated in resulting Mads assembly source code
  • Effectus code revision and optimization, plus added more descriptive comments for core procedures and functions
  • First subversion for easier maintaining and versioning
  • Some more examples added
  • readme.txt file documentation updated
  • Removed ASM command for writing inline assembly language code (Currently the main goal is to emulate Action! syntax, add-on features will probably be included in some other version in the future)
Bug fixes
  • Fill routine updated and fixed for proper functioning
  • Program parameter passing correction in Linux version (bug found by Greblus from AtariAge forum)
  • No more conflicts when using system variable names (the labels in equates.asm) for your own variables (Effectus appends _eff_ suffix to every user defined variable generated in Mads source code

Effectus 0.0.18 (Version date 31.5.2014)

New features:
  • Any number of operands allowed in parameters
    Example: DrawTo(x+r-10,y+r)
  • ELSEIF conditional statement implementation - finally :)

Effectus 0.0.17 (Version date 27.2.2014)

  • Program compiled with Free Pascal 2.6.2
  • MADS 1.9.8 used as the basis for assembler code compilation and linking
New features:
  • Mixed operators with any number of operands allowed in one statement
    (two problems remain: parenthesses do not apply and precedence is not implemented yet)

    Examples:
    D=A+B-C
    D=A+B-C+D-E
    F=A-B-C*D/E
  • Effectus program changes
    • Amended code for executing binary files (TProcess.CommandLine, a method for running external program, is deprecated in Free Pascal 2.6.2.) Instead, Executable method is used.
    • Message "There were some warnings found!" is displayed only when actual warning is raised by MADS program
Bug fixes
  • Correct output of byte values in PRINTB and PRINTBE procedures

    MADS printf function outputs word values only, so new version of Effectus deals with individual byte values differently in MADS code by storing them in memory address $c0. For example:

     .var j .byte

    Main
     mva #40 j

     mva j $c0
     jsr printf
     dta c'%',$9b,0
     dta a($c0)
  • Blank elements in array set assignment ignored

    CARD ARRAY values2=[100 2000 30000  40 5 6235 700]
  • Statement names PROC, FUNC and UNTIL allowed in PRINT procedures

    PrintE("UNTIL loop demonstration")
    PrintE("PROC loop demonstration")
    PrintE("FUNC loop demonstration")
  • MADS code corrections
    • Fixed string variable dimension assignment syntax

      Correct (tested on MADS 1.9.8):
      .array str1 [8] .byte = $ff
      (could also be: str1 .array [8] .byte = $ff)

      Wrong (but runs ok on MADS 1.9.3):
      .array str1 8 .byte = $ff
    • Element plus 1 must be added in array declaration, avoiding this error message (new in MADS 1.9.8?):
      ERROR: Constant expression violates subrange bounds for items(5), so element plus 1 must be added in declaration
  • MADS code changes
    • $9b added to conclude the string (for example: [0] = 'Memorable text',$9b)
    • c attribute added in dta string assignment (for example: dta c'#',$9b,0)
    • ARRAY closing tag .enda changed to .end
    • .array and .end shifted to the right for one character

Effectus 0.0.16 (Version date 8.2.2012)

New features:
  • Declaring machine language code in FUNC statements (currently two byte parameters supported, passed through accumulator and x register)
  • UNTIL loop implemented
  • Math operators + and - can have multiple operands on the same line (but of same type for now)
Misc:
  • Sub8, Sub16, Add16, Add8 removed from math library (Effectus now uses MADS commands adb, adw, sbb and sbw)
  • MADS -x Exclude unreferenced procedures function used in compilation stage
  • Revised Effectus source code and its optimization
Fixes:
  • PROC and FUNC statements are now case insensitive
  • Message File does not exists! renamed to File does not exist! when program does not find the program to compile :)

Effectus 0.0.15

New features:
  • Machine language code blocks between [ and ] characters allowed anywhere in the body of PROC or FUNC statements
  • ARRAY statement:
    • Multi-line support (values freely typed across the lines)
    • Array elements allowed as variables to commands (currently it is suggested to declare arrays as CARD or INT)
    • Optional dimensioning of set allowed (optional)
  • Arithmetic 16-bit addition and subtraction operations allowed (only CARD and INT values suggested as operands for proper operation)
  • FOR loop iterations up to 65535 allowed
  • Misc:
    • Better usage of comments (No more problems with putting statements and commands in comments)
    • Correct rendering of one space character for Print(" ") command
    • Literal value of ELSE directive allowed as part of a string between "" characters
Misc:
  • Revised code and optimization
  • Site updates:
    • My main website logo added in the header
    • Examples section changed layout
    • Some HTML code revision

Effectus 0.0.14

New features:
  • Declaring machine language code in PROC statements:
    • Hexadecimal and decimal numbers allowed (hex format is required when no spaces are used)
    • Can be individual byte or address (e.g. $02C6 - parsed as low/high pair of address)
    • Only necessary bytes of RAM consumed
    • Example:

      PROC PokeTest=*() [
      $A9 $90
      $8D $02C6
      $0 $60
      ]

      PROC ParamTest=*(BYTE a)[$8D$02C6$0$60]
    • Limitations
      • Currently one BYTE parameter allowed (I will expand the functionality in future versions)
      • Direct calls to other procedures and functions not yet implemented
  • New ARRAY functionality:
    • INT and CARD ARRAY string assignments
      • Example:

        CARD ARRAY item(2)
        item(0)="String in CARD ARRAY"
        item(1)="Additional string"
    • BYTE and CHAR ARRAY string initialization
      • Example:

        BYTE ARRAY str1="Text"
        BYTE ARRAY str2(20)="New text"
Fixed issues:
  • Fixed record pointer variable handling
  • SCopy, SCopy and SAssign procedures:
    • String code handling optimization (strings instead of individual characters)
    • Variables allowed as parameters
  • Proper compilation of lowercase / uppercase code
Misc:
  • New configuration parameter: ML_ORG - Machine language starting address (-sm switch in program parameter list)
  • Revised and optimized code
  • Revised source code examples

Effectus 0.0.13

New features:
  • DO OD loops implemented (issue found by ascrnet). DO OD on single line deprecated (loop directives must be on separate line to work properly)
  • EXIT directive implemented (this uncoditional command works in all implemented branch and loop statements: FOR, WHILE and DO OD loops)
  • String commands
    • SCopyS command implemented
    • SCopy implementation optimized (handling characters with x register, additional variable removed)
    • SAssign implemented, but currently with the functionality same as SCopyS
Fixed issues:
  • Comma sign allowed in PrintD strings (issue found by ascrnet)

Effectus 0.0.12

  • Source code released
  • Better usage of comments at the end of the statements
  • Fixed usage of FOR loop case-sensitiveness (bug found by Cosi)
  • equates.asm back in main program (wrong full qualified pathname problem found by Cosi)
  • PrintF
    • Comma (,) allowed in string format parameter
    • C option added as parameter for converting ATASCII to character representation (need additional revision for proper handling of ATASCII characters)
    • Sole parameters without any additional text
  • Checking for the non-existing file and putting appropriate message for the user
  • Major code revision and optimization
  • Graphics example by w1k added to Example section page

Effectus 0.0.11

  • STEP directive for FOR command added (bug found by w1k)
  • Added support for IF and WHILE conditional expressions with OR and AND logical operators (Currently one of them can be repeated several times in one statement)
  • IF condition statement:
    • Allowed comments after FI statements
    • Fixed problem with placing FI statement
  • Allowed comments after WHILE OD statements
  • Eliminated support for only 255 procedures and functions (PROC and FUNC)
  • DEFINE declaration statement:
    • Eliminated support for only 255 possible DEFINE declarations
    • The variable's type generated in assembler code depends of the value used in Effectus code (.byte or .word)
  • Fixed problem with using of three or more parameters in PROC and FUNC commands. This issue is resolved with placing new public variables in common.asm library and not relying on runtime.asm variables anymore

  • Code revision and optimization

Effectus 0.0.10

- PrintF procedure support (currently only %I, %U and %E options supported)! Some examples:

  PrintF("The integer number is %I.%E%E", n)
  PrintF("The n=%I and i=%U.%E", n, i)

- Bitwise operators LSH, RSH, XOR, !, & supported. Some examples:

  n==!2
  n=n XOR 2
  n==!n
  n=n&40
  n==&2
  b=a LSH 1
  b=a RSH 1

- MOD (modulus) arithmetics operation support. Example:

  n = 10 MOD 4

- Fixed usage of PrintE(""), which works properly as empty string with new line (carriage return) character at the end of string. Print("") assembles and compiles to nothing.

- Additional ARRAY declaration syntax support (experimental for now) for predeclared variables. Example:

  BYTE ARRAY values=[1 2 3 4 5 6 7]

Currently only one line declaration apply as correct syntax

- Fixed printing to the screen with PrintD and PrintDE procedure. It happened that comma character "," was not handled properly in string and resulted in
splited string, which showed only characters before "," character - Bug found by ascrnet, a member of AtariAge portal. Thank you!

- Fixed usage of INCLUDE statement. Main program and the included source file will be assembled in the directory where Effectus is run. The resulting assembled main code will not contain absolute path of the included file, because both files are generated in the same directory.

Some examples:

INCLUDE "lib_test1.eff"
INCLUDE "c:\projects\lib_test2.eff"

- Additional freedom in typing commands. Some example:

  PrintE ("")
  Position  ( 1, 3 )
  Graphics  (8)

- Printfg runtime library procedure usage removed from assembling and compiling, because Printf procedure should have all of the needed functionality for printing to the screen, including text windows in graphics modes.

- Removal of unnecessary assembler code for TYPE declaration, if it is not used

; Handling TYPE variables
 .var struct_ptr_var .word

- readme.txt documentation file updated

- Added examples showing new features


Effectus 0.0.9

- Linux version of the program (compiled on Ubuntu Linux platform - i386)

- TYPE declaration is one of the Effectus statements, which allow code to be freely placed on multiple lines. The only restriction is having only one variable type on single line. Some examples: 

    TYPE rec=[INT a, b
              CARD calc1, calc2
              INT c]
              
    TYPE rec2 = [INT a,b
                 BYTE c
                ]
  
    TYPE rec3=[
               BYTE a, b
               CARD c
               INT k, m, p
               BYTE value
              ]

- Improved support for ARRAY variables used in FOR loops. Some examples:

    FOR i=0 TO 2
    DO
      Print("Element ")
      PrintCE(item(i))
    OD
  
    FOR i = 0 TO 2
    DO
      data(i) = 1
      PrintBE(data(i))
    OD
  
    FOR i = 0 TO 2
    DO
      j = data(i)
      PrintCE(j)
    OD
- Arithmetics:

- Increment, decrement, multiplication and division expression syntax
Some examples:

    x==+1
    x==-2
    x==/3
    x==*4
- Aritmetics is viable on two operands (numbers or variables, also mixed)
Some examples:
 
    n1=13+76
    n1=100-n2
    m = n * t
    u = v / 10
- Pre-declared variables allowed, for example: 

  BYTE i=[3]

- Improved ARRAY declaration and manipulation

- Fixed procedures SCopy and InputS. Strings are handled using the actual ARRAY variables.
SCopy also allows copying one Array variable parameter to another, as in the following example: 

  SCopy(Str1, Str2)

- No space dependency on one line for most of the code, for example:

    n=10
    n = 10
    n=n+1
    n = n + 1

- Fixed issue in FOR loop syntax (if last argument was variable, the loop ended with iteration minus one)

- New core routines implemented for more robust, optimized and organized code, which will help in
faster development of new features of Action! programming language

- Configuration file Config.ini is not needed anymore. Program can work without it, but with care taken.
In this case default values are set. That is, MADS cross-assembler is searched from system path configuration.
If it isn't there, an error is raised. The best way is setting its path with -md: parameter, like this:

effectus examples\poke.eff -md:c:\atari\utils\mads\

Effectus runtime library is automatically searched in lib directory in the root directory where Effectus is run.
If you want to read runtime library from another location, set it with -rl parameter, like this:

effectus examples\poke.eff -md:c:\atari\utils\mads\ -rl:c:\projects\effectus\lib\

Of course, you can still use config.ini file. If so, parameter values from that file are used by Effectus.

- Colored presentation of console program, with some description changes

- Revised examples showing new features


Effectus 0.0.8

- Improved support for ARRAY, POINTER declaration and manipulation (not all features implemented yet)

- Support for arrays of TYPE records (not all features implemented yet)

- TYPE declaration and manipulation

- Some code optimization and reorganization


Effectus 0.0.7

- 8-bit multiplication and division (allowed math on two numbers, same applies to addition and subtraction)
- ValB, ValI and ValC Action! functions implemented (current restriction is that you cannot pass variable strings as parameter, just literal numbers in double quotation marks are allowed)
- Fixed printing of text in graphic mode text window (No more need for extra routines PrintG and PrintGE, which are deprecated. For now, for empty lines, use PrintE(" "). For this, modified PrintF library was added, called PrintFG
- Most routines commented (description, parameters, results) in all runtime libraries
- INCLUDE statement bug fixes:
  - Comments allowed with this directive
  - No more searching for non-existing INCLUDE directive file in root directory. Instead, by referencing the filename without a pathname, program automatically searches for current location set in configuration file, pointed to Effectus source code directory. You can also state the folder of that directory inside brackets
- Correctly parsed blank lines in assembly code (to match Effectus source code layout)
- device ( Effectus global variable) correctly treated and referenced as device.devscr in MADS code to allow its proper internal handling
- Up to five parameters are allowed to be passed to procedures and functions
- InputS and InputSD allowed maximum string size is 120 bytes
- Rand routine optimized
- Fixed Locate routine (a problem which remains is extra keypress of return key - yet to be fixed (any advice?))
- IF condition and WHILE branch variable type checking (if any of the numbers is of type .word, the resulting code is also of type .word)
- Game controllers library added
- Default device applied to routines GetLine, Put, PutE
- CHAR ARRAY handled as BYTE ARRAY (check scopy.eff example)
- Eliminated variable expression duplication (IF, FOR, WHILE statement conditions/expressions are threated differently)
- New generated program layout:
  - common.asm (macro routines Poke, Peek, PokeC, PeekC, XIO, MoveBlock)
  - runtime.asm library as object code library
- All runtime libaries optimised and revised
- MADS conditions and branches #if, #else, #while and #end (with MADS 1.8.0 and higher)
- I/O error checking (program automatically closes a device and program execution)
- Syntax typing freedom (variable declarations and expressions, routine parameters... Some examples: n =    1, k  =Sum(n1, n2), BYTE jx,   jn,jy...)
- PutD and PutDE routines modified and moved from runtime.asm to io.asm, obsolete ReadByte removed
- I/O checking code segment tya jmi stop changed to jmi stop
- Any appearance of hexadecimal number for new line ($9B) changed to lowercase letter ($9b)
- Effectus code revision and optimization


Effectus 0.0.6

- Console version of the program
- Functions
- Procedure and function parameter handling
- Many new Action! routines included
- I/O support
- 8-bit math support (addition - sum up to 500, substraction - from 0 to 255)
- Common equates included in one file
- Declaration of any variable type can be repeated throughout the program
- Three new libraries added: math.asm, io.asm and printfd.asm
- New examples
- Program code optimised and factorized for usage with GUI and console version of the Effectus