Author Topic: VRCalc++ Object Oriented Scripting Language by Adrix.NT  (Read 1659 times)


  • New member
  • *
  • Posts: 9
VRCalc++ Object Oriented Scripting Language by Adrix.NT
« on: February 19, 2017, 03:18:02 pm »
born as a programmable calculator, VRCalc++ features the same operators as C++ and Java and more extra objects related operators implemented using object interfaces
as well as a complete set of procedural flow control structures including
- selection statements,
- loops control statements,
- labelled statements,
- exceptions control statements
and so on ...

VRCalc++ includes support for
- access the RTL package data, funcs and procs
- run-time exceptions handling
- multi threaded functions and objects
- Windows DLL access (Win32 version)
and more ...

VRCalc++ is embeddable in any application using Delphi packages
because its scripting run-time code and other environment support
exported functions are also contained in Delphi packages

VRCalc++ is extensible
by object oriented scripted class modules
or by external packages
implementing and exporting the required functions and interfaces

VRCalc++ Scripted Class Modules usually define and export functions as well as properties

modifications history

  • the first (non object oriented) prototype version (derived from tinycalc and xcalc) was started on March 2006 featuring many characters of the final version including proc flow control structs although it was non object oriented and capable only to handle floating point numeric data, also the console was initially integrated with the runtime engine and to add a feature you had to recompile all
  • the final object oriented version 2.0 was started on March 2009 and completed at end of 2009 (including proceduiral flow control script parsers) after having rewritten most of the Delphi code of the 2006 version to adapt it to Reference Counted Interfaced Objects (* see Inside VRCalc++ docs, COM Interfaces) and after having isolated the VRCalc++ Engine Code in their proper packages.

also note that, because the use of object interfaces on which VRCalc++ symbolic operators are based on, support for operators overloading is also available and it will be extended in future releases.

  • partial support for many RTL objects and functions [Math, DateTime, and so on …] was added to final version in 2010 as long as support to access many Engine features [VRCalcEngineExtension]
  • the Inside VRCalc++ documentation was started on Feb 2015 as a set of RTF docs
  • many built in Engine Classes were improved on March 2015 including the EngineThread Class that now supports Runnable Objects as well as Runnable Scripted Module Instances and some generic interfaces were added to support Scripted Modules
  • support for runtime Required Scripted Modules Loading Optimization was also added on March 2015 using module dependencies list files with a generic load modules engine and a couple of applets to smart edit the deps list files thus preventing loading required modules 2 or more times in a row and also resolving any circular refs among modules
  • although the VRCalc++ Engine was designed to work mainly with Reference Counted Interfaced Objects (* see COM Interfaces, Inside VRCalc++ docs), support for using simple not ref counted objects (such as RTL TList objects) is also provided from April 2015 and support for optional module termination callback scripted methods was added, it is needed in the case you work with these objects to perform the required clean up (* see Inside VRCalc++ docs for details). pluggable functions to work with some RTL System Classes (TList, TStrings, and so on …) were also added
  • as a result of the above, from April 2015 the list of VRCalc++ Engine Built in functions and script parsers was enlarged and improved by including many of the most important proc flow control structs and functions to access the runtime environment (before from 2009 they were defined only into an external package to plug in separately, now they are part of the Base Engine Module Package). support for global vars was also added along with some improvements of the VRCalc++ Engine Thread Execution Global Environment
  • on April 2015 a pair of expressions operators and engine properties were added to optimize expressions evaluations in both time & space. one of the most important optimization is the one that allow us to eval an expression using flat operators with no implicit precedence among them, it is up to the programmer to set operators precedence in expressions by using the required blocks enclosing here the expressions with higher eval precedence. this option allow us to save evaluation time & stack space
  • on Aug 2015 format of Deps List Files was improved to support relative pathnames, include files, env vars expansion, directories and sub-folders recursion and user comments by modifying the relative sintax. also their use has been extended to plugglabe (BPL) modules used to extend the language functions.
  • on Nov 2015 the basic math operators functions were upgraded to support integer math operations side by side to floating point math with automatic convertions, that is all basic math is performed at highest precision for both unsigned and signed integral numbers and extended floating point numbers. format of numeric costants was extended to support unsigned and signed integrals and floating point numeric constants using type suffixes while remaining backward compatible.
  • also the VRCalc++ Console (* see below) was improved from Feb 2015 and a new console only executor of VRCalc++ scripts was created on Feb 2015 [VRCalcSX]
  • on Sep 2016 a simple Test Applic Delphi Project embedding the VRCalc++ Engine was created to demonstrate Scripted Object of a Class Module Creation and Method Invocation (it uses a scripted RandomObject to generate Random Values).
  • on Dec 2016 some non-interfaced objects with copy semantics (not reference counted) were created and added to the main library of live objects along with support functions to store simple data types without computing interfaces to save memory space (by default a simple data type (string, integer, float, …) is created for computing purposes so it implements all the required interfaces to make computations and its size is very large). you cannot perform computations on simple storage objects of this type, you have to convert them to computing object implementing required interfaces to perform computations. their purpose is only to save space for storage.
  • on Feb 2017 functions and properties declarations were improved by introducing new keywords (“public”, “private”, “pure”). VRCalc++ Console now shows error line & col.

the VRCalc++ base independant script Engine code
can also be recompiled and run under Linux and MacOS

VRCalc++ Console is a Windows Application
using the VRCalc++ Scripting Engine Package.
it can also be used as a simple, immediate and fast calculator
by executing simple scripts or scratch code

VRCalcSX is a Console Program that only executes VRCalc++ main scripts

both of them are extensible by pluggable modules (*) see above

  • porting of VRCalc++ (and other software from Adrix (Paged Lists & Iterators, VRAstroVision, VRLazyCodeEditor …)) to Free Pascal (fpc) using the Lazarus IDE is also planned as next step

VRCalc++ source code and Build Packages is available for free at

you can find VRCalc++ source code and Delphi Build Packages, VRCalc++ Console, VRCalcSX, and other software from Vincent Radio {Adrix.NT} (Paged Lists & Iterators for Object-Pascal, Code to Handle and Interpret VRDepListFiles along with the RTLib & VCL Utils Extension, Test Applications, VRAstroVision (Astrology Software) and so on …) on

please, send your comments and feedbacks on VRCalc++ and other shared software to


TinyPortal © 2005-2018