CHANGELOG OF TEASCRIPT
=======================
This changelog is for the TasScript Host Application as well as the TeaScript C++ Library.

NOTE: The dates are not the release dates, but a last commit date.


================
VERSION 0.14.0, Wed May 08 17:41:05 2024
================
    VERSION: 0.14.0 - TeaStackVM, Compiler, (Dis)Assembler, Suspend + Continue, Yield, improved debugging.

    DIST: Syntax highlighting for dark mode notepad++
    DIST: removed mentioning libfmt 9.1.0, it must be 10.1.1 or newer.
    DIST: updated instructions.txt
    DIST: updated Deprecated_ and KnownIssues.txt
    DOCU: added comments to class Constraints.
    ENGINE: added CallFunc/CallFuncEx for a handy way to call TeaScript functions.
    STACKVM: fixed instr. MakeTuple with payload 0 (issuable only via ASM)
    EXAMPLE: added example_0.14.tea for try debugging.
    HOST: added possibility to print a range of instructions only via :disasm start,end

    TEASCRIPT: removed EXPERIMENTAL state from ...
    - Const concept for checking constness of a variable.
    - class ASTNode_FilePart
    - PassthroughData interfaces and usage.
    - Get[Final]PartialParsedASTNodes of class Parser.

    LINUX: fixed compile with g++11 and clang 14.
    STACKVM: added initial reserved size for the call stack.
    CORO: protect RunFor()/ChangeCoroutine() for called more than once the same time!
    BUILD: opt-out for libfmt header only.
    ENGINE: refactored class to be used as not header only!
    - This breaks the mParser member is now only available via mBuildTools->
    - added ContextFactory class for prepare a Context via arbitrary code.
    - added more comments.
    CORO: added SetInpuParameters, Reset and Suspend. bg task and co-op demo.
    PARSER: fixed yield and calling function.
    TEASCRIPT: New form of passing arguments to script via ...
    - ... a Tuple "args" with all arguments as elements. argN still indicates amount.
    - HOST: legacy args available via --legacy-args.
    - ENGINE: legacy args available via TEASCRIPT_ENGINE_USE_LEGACY_ARGS=1
    - EXAMPLES: handle new and legacy form of arguments.
    FIX: Stack too small if suspend/yield was last stmt of loop
    ENGINE: improved comments.
    CORO: Implemented first version of CoroutineScriptEngine!
    - LIB: added opt-out for header only usage. User can pick one TU which must set
      TEASCRIPT_INCLUDE_DEFINITIONS to 1 and TEASCRIPT_DISABLE_HEADER_ONLY to 1
      and include CoroutineScriptEngine.hpp there (Engine.hpp will follow).
      All other TUs with teascript includes must set TEASCRIPT_DISABLE_HEADER_ONLY to 1.
    - DEMO: changed project to opt-out header only for demonstration.
      This saves a lot of includes, esp. CoreLibrary, Parser, StackMachine and ASTNode.
    - PROJ: distinct ConfigEnums.hpp for eOptimize and config::eConfig.
    BUILD: get rid of _SILENCE_CXX20_U8PATH_DEPRECATION_WARNING as well.
    BUILD: dont need _CRT_SECURE_NO_WARNINGS for MSVC.
    DEMO: added thread suspend demo.
    DEMO: added test_code10() which will explicit compile and execute code with class Engine.
    TEST: changed corelibrary to compile for StackVM test (except basic).
    HOST: added dumping variables/functions of all present scopes intead only ...
    - ... the global one. With this all variables/functions of a suspended
      or halted program can be inspected with :ls vars or :search
    - HOST: added :dbinfo <n> where n is the instruction index for which
      the debug shall be obtained for.
    TEST: added release_test and extended_test script.
    TEST: added some basic, a mixed call + adopted Tuple Subscript tests.
    STACKVM|HOST: improved current index handling and showing debug info.
    HOST: fixed line numbers are off by one when use :parse <n>
    STACKVM: added exception handling and injection of source location for ...
    - ... all exceptions thrown actively by TeaScript during evaluation.
    - COMPILER: added distinct compile_error exception.
    - COMPILER: carry over more SourceLocations to instructions and fixed some.
    - STACKVM: finding correct source location of the caller for too less and
      too many arguments for a function call.
    CLEAN: removed deprecated ApplyUnOp|ApplyBinOp
    DIST: updated Known_Issues.txt
    SHELL: added :callstack (showing callstack) and :pc (showing current instruction)
    HOST|SHELL: updated help messages.
    STACKVM: added FunctionPtr to CallStackEntry (makes parameter info available).
    HOST: added a few ways for implicit launch interactve shell (e.g., --no-eval).
    HOST: implemented showing best matching debug info of current program position.
    - this only works if program is suspended or halted.
    - COMPILER: filling most useful debug infos in Debug mode.
    - PROGRAM: Query debug info and best matching debug info for a position.
    STACKVM: implemented constant evaluation for unary and most binary operators ...
    - ... for optimization >= O1. logical binary ops are missing as well as is/as.
    STACKVM: implemented scope optimization for O2. Removes unnecessary scopes, except ...
    - ... for early returns or loop related jumps (this still has to be done later.)
    - This gives a great speedup for e.g., fib.tea, since variable searches are one
      of the biggest performance bottlenecks actually. Each removed scope during
      a (recursive) function call chain will reduce the time until the script finishes.
    STACKVM: added timed and instruction count based constraint for exec.
    - with this the script can be suspended at any amount of executed
      instructions (one will be single step debugging).
    - ... or after any amount of passed time
      (currently in milliseconds with granularity of 10 instructions).
    STACKVM: implemented yield instruction, now scripts can yield values lika a coroutine!
    - AST: added ASTNode_Yield_Statement for have a layer from Parser to Compiler.
    - SHELL: print yielded values of suspended scripts.
    TEASCRIPT: added possibility to program in TeaScript Assembler directly for TSVM.
    - PARSER: added ##tsvm_mode and ##tsvm INSTR CONSTANT for parse TeaScript asm code.
    - ASTNODE: added ASTNode_TSVM for have a AstNode layer between Parser and Compiler.
    - COMPILER: added handling for ASTNode_TSVM which directly contains the instruction.
    HOST: added print TSVM instructions for .tsb files, added --info for ...
    - ... print the header infos (compiler version, optimization level, name)
      of a TeaScript binary file (.tsb)
    - STACKVM: load header of program does not read the whole file content anymore.
    STACKVM: implemented Save and Load of StackVM Programs (TeaScript Binary (.tsb))
    - HOST: added --compile for compile+save a <file>.tea as <file>.tea.tsb
    - HOST: added executing of .tsb files.
    FIX: reject utf8 string if first char is a follow char.
    ENGINE: added ExecuteProgram(), CompileScript|Content|Code, streamlined ...
    - ... read script file a little by using CoreLibrary::ReadTextFile[Ex] and
      util::utf8_path_to_str()
    - CORELIB: added ReadTextFileEx/WriteTextFileEx with std::filesystem::path.
    - added util::utf8_path_to_str, needed on windows to convert filesystem::path
      back to utf8 string instead of code page string.
    VALUE: made FunctionPtr and IntegerSequence first class citizen, ...
    - ... avoid usage of GetValuePtr() in favor of InternalType() and GetTypeInfo()
    - made ValueObject with Buffer always a shared one.
    - fixed constructor with FunctionPtr for the case it shall not be shared.
    ENGINE: using TeaStackVM now for execute scripts, changeble during ...
    ... construction to Eval mode, which will still evaluate the AST.
    - added script args can be passed as real ValueObjects instead of strings only.
    HOST: use MoveResult() from StackMachine.
    STACKVM: implemented subroutine execution. This enables to enter the ...
    - ... compiled land from the eval world. Not only from the interactive
      shell but also from, e.g., eval( "compiled_func()" ) it is possible
      now to execute code of compiled TeaScript functions from any eval point.
    - implemented ParamCount() and ParameterInfoStr() in CompiledFunc.
    - had to introduce CompiledFuncBase as well as CompiledFuncFactory
      in order to resolve mutual dependency between CompiledFunc and StackMachine.
    - VALUE: slightly optimized move operations.
    STACKVM: added subprogram/module like feature. A CompiledFunc may come from ...
    - ... any program. Each callstack entry saves its program source as well.
    - The program can be switched for every function call and back for every Ret.
    - This enables to use a compiled CoreLibrary (and more) in (compiled) scripts.
    - CORELIB: Bootstrap now compiles the core library (default), can be switched to eval.
    - HOST: use compiled core library for Exec, and ast eval for Shell.
    - HOST: added --no-eval for optionally use compiled core library in interactive shell.
    - HOST: added --shell for explicit launch interactive shell together with other parameters.
    - HOST: cleanup: use Config (parsed parameters) also in interactive shell, removed bools.
    - STACKVM: fixed nested loops with same lables! :-O
    - STACKVM: handle control::Exit_Script from function calls.
    HOST: added :debug ast|tsvm and separated it from :debug, updated help message.
    STACKVM: added Debug as NoOp in debug mode (debugging only)
    DIST: added suspend + yield keywords to syntax highligthing.
    STACKVM: added SubscriptGet/Set, fixed nested dot ops, fixed CallFunc with 0 params.
    STACKVM: added SetElement, DefElement, ConstElement, IsDefElement
    ... for manipulate Tuple elements.
    STACKVM: added DotOp and Undef(Tuple)Element.
    STACKVM: added and implemented MakeTuple instruction.
    LINUX: full support of gcc 13 (no limitations left).
    TEASCRIPT: added suspend and continue of scripts!
    - added suspend keyword, ASTNode_Suspend_Statement + Suspend instruction.
    - STACKVM: Suspend instruction will enter Suspended state of TeaStackVM.
    - in eval mode suspend is not supported and will just throw.
    - HOST: will auto continue suspended scripts if not launched with --interactive / -i,
      otherwise the first reached suspend will launch interactive mode.
    - SHELL: added :compile for compile a parsed script.
    - SHELL: old :exec is :eval now (evaluates parsed ast).
    - SHELL: new :exec will execute compiled script in TeaStackVM.
    - SHELL: added :continue for continue a suspended script.
    - SHELL: added :disasm for print TeaStackVM instructions of the script.
    - HOST: refactored host to use PartialParseState when entering --interactive.
    TEASCRIPT: added _Exit statement, Exit ASTNode and ExitProgram StackVM instruction.
    - made ExitScript() and exit() deprecated, _exit accepts now any value.
    - needed a distinct Exit ASTNode for easily create a compiled ExitProgram instruction.
      (detect every _exit call and replace it is too dirty.)
    - ExitProgram will exit the program from any point with scope cleanup.
    - _Exit accepts any value. A script always has a result.
      A separated exit code will not exist anymore.
    STACKVM: added return statement (also from toplevel 'main') + Unittest
    STACKVM: added default parameters for function definitions.
    - If a parameter is on the stack it will be used and jumped over the default code.
      Otherwise the default code will be executed.
    - nested default parameters are possible, e.g. when using a lambda with default params
      as default param:
      func calc( a, b := func ( x := 1 ) { x * x } ) { a + b(a) + b() }
    - added Unittest for function definitions and default parameters for StackVM.
    STACKVM: added function definition with ParamSpec and FromParam, ...
    - ... added ParamSpecClean and Ret instructions.
    - added (not implemented yet) FromParam_Or instr.
    - added CompiledFunc which actually just stores the jump address.
    - Compiled TeaScript functions are actually working without frames,
      they are just jumps and jump backs (ret).
    - using a separate 'callstack' for save the return addresses (and function name).
    TEST: added StackMachine Func Call Unittest.
    STACKVM: added if with scoped conditions and implemented correct handling ...
    - ... of comma operator (Expressions with more than one element) in if conditions.
    - added StackVM Unittest for if conditions with scope, e.g. if( def a := 10, a > 9 ) { a }
    STACKVM: slightly optimize by replacing consecutive Replace with NoOp
    TEST: added basic, if and loop stack machine tests.
    STACKVM: added forall loop (with help of ForallHead and ForallNext instr.)
    - forall loop has full support for 'stop', 'loop' and lables.
    - forall loop is more special than expected. It needs 2 entries on the stack
      for the idx variable and the IntegerSequence. This actually requires
      special stack cleanup for a result can be carried over to the caller
      without let the stack in dirty state.
      loop and stop statements must respect this as well.
    STACKVM: added Repeat loop w. loop/stop "label" (incl. scope cleanup), ...
    - ... detecting wrong labeled (not matching) stop/loop and produce a compile error.
    - a 'stop' outside of a loop is a HALT (mimic intended behavior of old scripts)
      (but with statement behavior is unspecified in such cases, means:
      don't carry a result with a top-level stop! use return)
    - a 'loop' outside of a loop is a compile error.
    HOST: added --printTSVM mode for print compiled instructions, ...
    - ... added -O0, -O1, -O2 option for specify compiler optimization mode.
      (debug mode for compiler will be also set with --debug)
    STACKVM: Instruction ToString/FromString, added threshold to DumpInstrTimes().
    STACKVM: added compiler version to program.
    STACKVM: introduced Replace for combine Pop+Push, introduced ...
    - ... TestAndJumpRel_If[Not] for combine Test and JumpRel_If[Not]
    - slightly optimized Push/Pop combinations.
    STACKVM: optimized by using in-place operations for the stack.
    - means that instead of pop + push there is a stack[s-1] = val.
    STACKVM: removed exceptions from main loop, introduced mException and mError ...
    - ... which can be obtained after Exec() if in Halted state with
      ThrowPossibleErrorException() / HasError()
    - the goal is that all eval and runtime exceptions are propagated
      via this new mechanism.
    VALUEOBJ: reduced overhead of move cosntr/assign.
    STACKVM: added Test instruction setting current stack value to Bool, ...
    - ... made logical expressions and if conditions clean (Test, Pop)
    - added optional time measurement of last 256 executed instructions.
    FIX: caught wrong exception in ASTNode_If.
    HOST: added using of StackMachine (default), eval mode available with ...    
    ... --eval or --no-compile
    - added measurement of compile time for -T flag
    STACKVM: experimental Suspend Request support from other threads, but ...
    ... unfortunately this is not possible for clang since it does not
        support std::stop_source/std::stop_request yet.
        clang 18 has it as experimental feature, must be activated via
        -fexperimental-library
    - Stack Machine can now be configured with and without thread support
      via template< bool >
      If without thread support the used mutex is a no-op one.
    - Suspend function is only callable if thread support is enabled.
    - fixed compile for gcc / clang, removed new warnings.
    STACKVM: created StackMachine, Compiler and Program classes from prototype, ...
    - added StackVMInstructions, StackVMCompiler, StackVMProgram, StackMachine
      headers and implementations.
    - StackMachine is prepared from being suspended from a different thread!
    - actually usable via the :compile command in interactive shell
      (will be splitted to :compile and :exec)
    ASTNODE: don't create a useless std::vector for ASTNode_ParamSpec.
    VALUEOBJ: improved default constructor, fixed and improved move.
    STACKVM: prototype of calling cpp and AstNode based functions.
    - fixed Check overload for ParamList and Return
    - use default ValueObejct constructor in NoOp ASTNode.
    ASTNODE: refactored Unary_ and Binary_Operator ASTNode:
    - added Operation enum and StringToEnum/EnumToString conversion.
    - added StaticExec which will do a big switch.
    - made a switch in Precedence as well.
    - streamlined Typeof_Typename with Unary_Operator ASTNode
    - added a StaticExec to Bit_Operator, Is_Type and As_Type as well.
    - added BitOp, As, Is as instructions to TeaStackVM prototype.
    - use StaticExec in TeaStackVM prototype for all binary and unary operators.
    PROJECT: adoptions after VS update to 17.9.3
    TEST: added Shared Return test.
    CLEAN: Removed deprecated functions...
    - Engine::ActivateDeprecatedDefaultMutableParameters()
    - CoreLibrary::DoubleToLongLong()
    CLEAN: Removed old storage layout from Context, ...
    - ... removed deprecated BulkAdd + Context constructor
    - removed old pre UTF-8 fix code path in CoreLibrary.
    - use a lambda instead of macro for tea_add_var()
    SHELL: fixed initial debug and 'mutable parameter' mode for all scenarios.
    DEMO: added bigobj flag to VS compile.props.
    DIST: added readme for Host source.


================
VERSION 0.13.0, Mon Feb 26 12:19:18 2024
================
    VERSION: 0.13.0 - Buffer, U8, U64, bit ops, UTF-8 Iterator, hex integrals, MPL-2.0

    LICENSE: The TeaScript C++ Library is now licensed under the MPL-2.0
    
    The Mozilla Public License is available here also https://www.mozilla.org/en-US/MPL/2.0/
    
    The MPL-2.0 License has following advantages for TeaScript:
    - it can be linked statically (if all conditions are fulfilled).
      (that is why LGPL was not choosen. TeaScript is not available as DLL.)
    - it is explicit compatible with AGPL, GPL and LGPL.
    - it is compatible with Apache, MIT, BSD, Boost license (and others).
    - Larger works (means Applications using TeaScript) can be distributed
      closed source (or under a compatible license) as long as the conditions are fulfilled.
    - For the upcoming module system it means that a new first- or third-party
      module for TeaScript may use any compatible license like
      MPL-2.0, (A)GPL, MIT, Apache and so on.
    LICENSE: added MPL-2.0, cleaned up some files.
    FIX: fixed a bug where a new defined variable (with def :=) was const ... 
    ... when a const value was returned from a function.
    DEMO: fixed test_code8() (Tuple is first class citizen).
    DIST: added bit ops to SyntaxHighlighting.xml for Notepad++
    HOST: adjust help message for :stmt 0
    DEMO: added example_v0.13.tea
    CORE/SCRIPTS: use new bit operators for make_rgb().
    DEMO: added test_code9() for demonstrate Buffer usage.
    ENGINE: added AddVar|Const overloads for U8, U64 and added AddSharedValueObject, ...    
    - ... changed AddVar|Const for unsigned int adding an U64 instead of I64.
    - added overload taking a rvalue string for can move in a string object.
    SHELL: added #echo off|on to --batch processing mode.
    LINUX: fixed compile with libc++14
    TEST/MISC: added corelibrary_test04 for new string/utf-8 functions, ...
    - changed _strfromascii taking any Number type as argument.
    - optimized finding internal names in global namespace.
    - fixed some core library functions to be invocable with const objects.
    - made Buffer to string convertable (NOTE: Carefull when printing!)
    - finished work on write_image.tea
    TEST: added v0.13 to corelibrary_test01.tea.
    CORELIB: ReadTextFile now uses complete utf-8 validation.
    SHELL: added :search <str> command, lists all variables/functions containing <str>.
    CORELIB: added _buf_copy, _buf_resize, _buf_get_ascii, _strfromascii
    TEASCRIPT: added binary bit operators bit_and|or|xor, bit_lsh|rsh and unary bit_not
    - added ArithmeticFactory::ApplyBitNot, ApplyBitOp, ApplyBitshift
    - added ASTNode_Bit_Operator
    - made ApplyBinOp and ApplyUnOp deprecated in favor of ApplyBinaryOp|ApplyUnaryOp
    - the bit operators are available for U8, U64 and I64.
    - thanks to the underlying C++20 bit shift with I64 is possible as well.
    - the rhs operand for shift will be casted to U8, detection is done for too big values.
    - fixed format() with U8/U64
    UNITTEST: added Buffer CoreLibrary tests.
    FIX: warnings in Sequence<unsigned>::Next()
    CORELIB: added _buf_get_u8|i8|u16|i16|u32|i32|u64|i64|string and ...
    - ... implemented util::is_valid_utf8 as template taking a std::span<CharT>
    TEASCRIPT: added subscript operator for Buffer, made bad_value_cast ...
    - ... inherit by runtime_error (with SourceLocation!).
    - added SourceLocation to some bad_value_cast occurences in Subscript Operator.
    TEASCRIPT: added parameter info to debug print functions.
    DIST: Added SyntaxHighlighting for Notepad++
    VALUE: AssignValue for U64 and U8.
    CORELIB: added read/writefile for binary data, _buf_fill[32], buf_zero, ...
    ... fixed _buf_set functions writing in host byte order instead of big endian ;-O
    - added write_image.tea for show TeaScript can write BMP files.
    CORELIB: added _buf_set_u8|i8|u16|i16|u32|i32|u64|i64|string and allowing ...
    - ... to append data if position is either last valid index + 1 or
      the size of data exceeds the current size as long as enough capacity is available.
    - removed _buf_append as it is _buf_set_u8( buf, _buf_size(buf), val )
    TEASCRIPT: added Buffer, added _buf[|_at|_size|_capacity|_append|_set]
    TEST: added Unittest for as operator, Sequence<signed|unsigned>
    TEASCRIPT: added U8 and U64, Arithmetic::Compare/Convert, hex parsing, ...    
    - improved Arithmetic BinOp (support 2 different types as operands)
    - improved as operator by using new Arithmetic::Convert
    - cast to unsigned has defined overflow, signed will throw.
    - allow suffix f64, i64, u8 and u64 for number literals.
    - integer literals can be in hex notation (upper or lower), must start w. [-/+]0x
    - Unittest for integer parsing.
    OPTIMIZE: Introduced InternalType() in ValueObject and ...    
    ... use it in ArithmetikHelper as well as in FormatString.    
    FIX: HasPrintableValue() in ValueObject for Sequence/TypeInfo.
    VALUE: made Tuple a first class citizen.
    PARSER: added ##enable[_if]/disable[_if], SetEnabled()/SetDisabled().
    CORELIB: added utf8_iterator functions.
    TEASCRIPT: added As Operator for explicit cast.
    ASTNODE: Added Append + AddPart + new constructor to ASTNode_File
    ASTNODE: merged in small changes (public getter) from branch 'exp'.
    ASTNODE: added virtual Check() for validation.
    ASTNODE: changed Eval() to const.
    VALUE: added convenience AssignValue() overloads.
    CLEAN: Removed deprecated eval() and Parser::Int(). Made ...    
    ... Engine::ActivateDeprecatedDefaultMutableParameters() deprecated.
    LIB: Split Util.hpp into Util.hpp, UtilContent.hpp and UtilInternal.hpp
    TYPES/LIB: Split Type.hpp into Types.hpp and TypeSystem.hpp. With this ...    
    ... IntegerSequence was added as a static TypeInfo instance in TypeSystem.
    CONTEXT: Use Collection with unordered_map, added policy to Collection, and ...
    ... optionally use boost container instead of the std containers.
    This is disabled by default for now because benchmark shows a performance penalty.
    HOST: count total lines when load=file
    HOST: stmt 0 shows amount of remaining statements.
    HOST: added --batch for batch processing (before the shell).
    CORELIB: fixed broken UTF-8 behavior for _strat!
    - now _strat always returns a valid complete UTF-8 code point.
      If the wanted pos does not point at a start of an UTF-8 code point,
      the last valid start will be used.
      This is a breaking change since the length of the returned string
      is not always 1 (or 0) but between 0 and 4 now.
    - reject invalid (not complete) UTF-8 ranges for _strfind and _strreplacepos
    - added StrUTF8GlyphToBytePos() / _strglyphtobytepos()
    - added strsplit() (into Tuple)
    - added strjoin() (from Tuple)
    DOCU: added _seq() documentation.
    BUILD: add bigobj to VS settings.
    CONTEXT: made BulkAdd deprecated, introduced InjectVars with std::move    
    - refactored BuildInternal to add to Collection instead of tmp vector.
    - ... add the end the values are moved into the Context (InjectVars)
    - added default move constructor/assignment to Collection
    - speedup boostrap LevelCore ca. 0.00009480s (before) to 0.00008440s (now)
    CONTEXT: Refactored storage layout and use Collection now.    
    - with this the ValueObject is now only stored once and not twice anymore!
    - added Collection::RemoveValueByKeyWithPlaceholder(). With this ...
    - ... undefing will be super fast due to the vector stays stable ...
    - ... and the indices in the map don't need to be touched as well.
    - Also, SetValue via SharedAssign is now straight forward as it should be.
    - added npos to Collection.
    - reduced complexity of Collection::AppendKeyValue to one lookup, so that ...
    - ... BulkAdd can be made obsolete soon.
    
    - This is only one little refactoring step. More are required for ...
    - a) multithreaded contexts.
    - b) faster lookup
    - c) and eventually different scoping behavior.

================
Version 0.12.0, Tue Jan 16 14:42:09 2024
================
    VERSION: 0.12.0 - Colored Output, Format String, Forall Loop, Sequences, interactive debugging.
    
    TEST: forall test, const param check, v12 example, improvements.
    TEST: added v0.12 tests to core_test01 + checking optional features + ...
    - ... added colorful output to all core tests if available.
    DIST: added changelog.txt based on git commit messages.
    VALUEOBJ: made Sequence + TypeInfo printable / String convertible.
    VALUE: Visit function for obtaining the inner value. (+ demo test code)
    FIX: invoking function right after subscript operator.
    FIX: fixed trunc with real f64 _trunc supporting full range of f64.
    CORELIB: moved floor,ceil,trunc,sqrt to LevelFull
    FIX: ValueObject::GetAsInteger(): throws wrong exception if String cannot be converted.
    CORELIB: added features tuple and moved most file-io to LevelFull
    - features tuple with .color, .format, .toml
      reflecting if feature was available during compile
    - added inc/dec functions for LevelUtil.
    - moved read/writetextfile, file_copy, path_delete, etc. to LevelFull.
    TESTSCRIPTS: added format_string.tea
    DIST: Copyright year 2024
    HOST/DEMO: colorized support of old conhost.exe (windows).
    TEASCRIPT: added forall loop and Sequences.
    - forall loop with 'in' keyword iterating ...
    - ... over valid indices of a given tuple as well as ...
    - ... over integer sequences with build with _seq()
    - introduced Sequence and IntegerSequence classes
    - introduced _seq function (for creating an IntegerSequence)
    - bunch of colorful test scripts using forall loop.
    ENGINE: added new protected constructor for prevent bootstrapping.
    CLEAN: Removed deprecated variant of Context::Bootstrap().
    TEASCRIPT: !!! _BREAKING_ !!! copy assigned function parameters are now const by default.
    - only shared assigned parameters are still mutable by default.
    - added Dialect.hpp and class for defining a TeaScript dialect.
    - the unmodified default values are forming the TeaScript standard language.
    - moved the old dialect defines from Context and ParsingState to Dialect.
    - added temporary interface in Engine for activate old behavior (for transition)
    - added temporary parameter --old-mutable-parameters to the Host Application for
      activate old behavior when executing standalone scripts (for transition).
    - changed Unittest for testing both behaviors.
    CORELIB: added format() for string formatting as via {fmt}.
    DEPRECATED: made eval and Int() deprecated, 
    - added Num()/Integer()
    CORELIB: added colored print as cprint/cprinln.
    PRINT: colorized pretty print.
    PRINT: Made libfmt preferred over std23 (most features).
    FIX: double to string conversion lose precision after the 6th position.
    - using fmt::to_string if available, otherwise std::format
    - fixed parsing of 123.456e-12  (dot and e same time)
    - fixed parsing optional + sign for exponent 1e+4
    HOST: new commands for manually load,parse,exec,show file
    - HOST: added :load=file, :show/:parse n lines, :exec n statements
    - HOST: :goto line,col command
    - HOST: show AST of a parsed statement (of loaded file)
    - HOST: some colorized output.
    3RDPARTY: updated to fmt 10.1.1

================
Version 0.11.0,   Thu Dec 7 10:20:52 2023
================
    VERSION: 0.11.0 - TOML Support, Subscript Operator, Raw String Literals.

    FIX: debug operator: name for tuple elements.
    FIX: Start call was applied for incomplete Dot Ops.
    HOST: added config=|reset= for CoreLibrary config, bug fixes.
    DEMO: added TOML test code, better readable script code.
    VALUEOBJECT: implemented forwarding subscript operator [].
    FIX/ENGINE: Don't use terminating 0 of a char[] as string content.
    TUPLE: Implemented [] operator in class Collection.
    TEASCRIPT: experimental activation of 'is Const'.
    TEASCRIPT: added (optionally) TOML Support (read into Tuple) via toml++
    CLEANUP: removed crt secure warning suppress from header.
    PARSER: added ##minimum_version required option.
    TEASCRIPT: added Raw String support.
    CLEANUP: merged ASTNode ParamSpec with ParamList.
    TUPLE: added subscript operator [] for access by index and key.
    TUPLE: added dot access with strings, streamlined dot op code.
    FIX: compatibility with newer VS2022 versions.
    HOST: changed license to AGPL-3.0
    HOST: added optional GNU Readline support (Linux).

================
Version 0.10.0    Thu Mar 9 20:01:47 2023
================
    VERSION: 0.10.0 - Tuples/Named Tuples, Passthrough Type, CoreLib config, license.

    TEASCRIPT LIB: changed license to AGPLv3.
    FIX: prevent endless recursion if tuple build cyclic references
    DEMO: added double linked list and tuple demo scripts!
    CORELIB: path_delete, file_copy/_newer
    CORELIB: added change_cwd, create_dir, path_exists, readdirfirst/next, last_modified
    - readdirfirst/next returns a Tuple for the direntry and a handle
      to the directory iterator which will be used in follow up call.
    - added experimental variant of LibrartFunction1 template.
      It can optionally add the Context as first argument to the call.
      Needed for can build a Tuple (needs TypeSystem/Info).
    TEASCRIPT: added passthrough data + demo code for it.
    PARSER: experimental interface for partial evaluation.
    CORELIB: added fine grained loading level and feature opt-out configuration.
    - split hardcoded core lib TeaScript code in several parts.
    - convenience functions for build the core lib config.
    - new Engine constructors with Core Lib config.
    TEASCRIPT: Tuple, Named Tuple, Dot Operator support.    
    - can create tuple via parenthesis
    - ... via Uniform definition syntax
    - tuples can have named elements
    - tuple elements can be removed, inserted, changed and swapped.
    - tuple element index to name and name to index.
    - added Collection class providing stable storage order and access by index or key
    - huge collection of tuple support functions.
    - Tuples can be used as dictionaries, lists, stacks.
    - printing of Tuples.
    - dot operator for access by index or name.
    - tuples are const correct
    - single elements of tuples can be defined const.
    - Unittest for Collection and Tuples.

================
Version 0.9.0,    Mon Jan 30 12:43:36 2023
================
    VERSION: 0.9.0 - Linux g++/clang port, C++ Highlevel API, enhanced Parser

    DIST: added Known_Issues.txt
    ENGINE: added method for toggle debug mode.
    PARSER: Precedence with deep lifting is always enabled.
    ASTNODE: made many methods noexcept.
    LINUX: compile with -O2 as default.
    LINUX: fixed all warnings for Wall (clang and gcc).
    WARNINGS: raised to W4 on Windows and fixed all warnings.
    VALUEOBJECT: GetAsInteger() supersedes GetAsLongLong().
    - use I64/F64/Integer/Decimal rather then long long/double
    TEASCRIPT: added Engine class with public user level API and great way for callback functions
    - added demo project teascript_demo for show Engine API.
    - user callbacks can be invoked as normal TeaScript functions.
    PARSER: Support direct parsing -/+ sign for integer/decimal constants
    - unary -/+ Operator only created in front of a constant if there is whitespace in between.
    PARSER: Full Line-By-Line parsing supported.
    - new Symbol() makes Operator, Expression, Block,... obsolete!
    - new implementation of ParseStatements() and Comment().
    - added ParsePartial()/ParsePartialEnd() for line-by-line parsing.
    - streamlined old (block/file) Parse() to use the 2 new methods.
    - added line offset to Content for partial parsing.
    - detect incomplete ASTNodes during parse time now (throw parse_error instead of eval_error).
    LINUX: fixed impl of CoreLibrary::GetLocalTimeInsSecs()
    LINUX: clang compile and run with libstdc++ and libc++
    LINUX: compile and run on Ubuntu 22.04 g++11
    HOST: added -T|--time option for time measurement.
    IMPROVED: changed unordered_map to map in TypeSystem (performance).
    TEST: added bench_fib.tea with 3 alternatives of fib code.

================
Version 0.8.0 (first public release!), Thu Dec 8 11:20:03 2022 
================
    VERSION: 0.8.0 - SourceLocation, pretty print, Unicode, Core Lib Ext2, Host modes, ...

    BUGFIX: if( def a := 4, true ) { a } not evals!
    CORELIB: added build date time.
    TEASCRIPT: allow top-level return statement.
    BUGFIX: not not random(0,1) is eval error! (deep lifting startcall)
    TEST: added file io test, extended double test.
    UNITTEST: added corelib test 02.
    CORELIB: extended Core Library with abs, round, ceil, floor, pow AND ...
    - added PI
    - added _f64toi64, trunc
    CORELIB: added _strtonumex using Parser and yield i64|f64|Bool, added _sqrt/sqrt, to_f64/i64    
    CORELIB: added clock[_utc], _timestamp, timetostr, sleep, random, rolldice, ...
    CORELIB: added cwd and readtextfile for UTF-8 text processing.    
    CORELIB: added tempdir, file_[size|exists], writetextfile.
    CORELIB: added strreplace[pos|first|last], _strglyphs.
    HOST: full Unicode support from shell input / CoreLibrary ReadLine.
    - internally read new data from ReadConsoleW as UTF-16 and convert to UTF-8.
    HOST: Finally have full Uincode support for command line/script arguments!
    - use wmain on Windows and convert UTF-16 to UTF-8
    - can test with argout_test.tea (and proper font in Console!)
    TEASCRIPT: Proper handling of UTF-8 strings from within the script.
    - shorten utf8 strings correctly for debug prints.
    - count utf8 glyphs for the string length.
    HOST: support current ANSI/OEM code page for keyboard input / params.
    HOST: optionally run interactive shell after exec. added version and help params.    
    - HOST: proper convert program arguments for script to utf-8 string (Windows mess!)
    - HOST: added program argument parser and Config struct.
    - HOST: help text for all valid modes/program arguments.
    - HOST: print version command.
    HOST: added silent mode.
    HOST: extract source line on eval_error when exec script.
    TEASCRIPT: changed std::runtime_error to exception::runtime_error.
    EXAMPLES: added fib.tea for calc fibonacci.
    PARSER: optimized SkipWhiteSpaceFast by remove bad conditional jump.
    ASTNODE: added SourceLocation to every node type.
    HOST: pretty print of parsing error :-)
    PARSER: added distinct lhs_missing exception.
    EXAMPLES: added helloworld.tea (as public domain)

================
Version 0.7.0 (unreleased, Release Prototype), Tue Oct 25 15:42:06 2022
================
    VERSION: 0.7.0 - Default parameters, TypeSystem, shared assign, const, double, ...
    
    HOST: portable distribution (Windows)    
    3RDPARTY: updated libfmt to 9.1.0
    TEST: Added a huge bunch of UnitTests for the last added features...
    TEASCRIPT: added passing parameters via shared assign.
    - brilliant solution for passing parameter as shared. We specify the assignment operator explicit!
      Then, if we omit the default value/expression a dummy is added to signal that pass a parameter
      is mandatory. With this we easily have shared assign for function parameters with and without
      default value/expression.
    - also can specify optionally const to parameter definition.
    - added swap function to CoreLibrary which is now possible via shared assign.
    TEASCRIPT: added typeof and typename unary operators.
    TEASCRIPT: added Types as Values, added is operator    
    - TypeInfos now have a name and can be set as value in ValueObject.
    - CoreLibrary creates variables for all basic types.
    - fake concept 'Number' for check if type is arithmetic (should probably being made clean later)
    IMPROVE: return statement will move the value instead of copy it.
    PARSER: stop at the first NUL encountered.
    IMPROVE: added error handling to _strtonum (return Bool(false))
    TEASCRIPT: Added TypeSystem and const variables!    
    - ValueObject now has a mpType member.
    - Types are stored in TypeSystem class
    - Allow ValueObject becomes NaV without losing original Type.
    TEASCRIPT: added double as type and ArithmeticHelper functions for be able to support more types!
    TEASPCRIPT: added shared assign which will share the value between both operands.
    - share assign operator is @=
    - test if 2 variables are shared with @@
    - get (internal) share_count with @? (unary op)
    - refactored assign and def, now all is streamlined clean in assign operator.
    TEASCRIPT: added default parameter for functions and improved parameter handling
    - ParamList is now provided per Context in current scope.
    - added FromParamList[_Or] which consumes one value from current param list in scope.


================
Version 0.6.0 (unreleased), Tue Oct 4 13:29:25 2022
================
    VERSION: 0.6.0 - Functions, Lambdas, CoreLibrary and Strings + In-String-Eval
    
    UNITTEST: added tests for strings, funcs, eval (and comma)
    UNITTEST: added UnitTest for Core Library written in TeaScript.
    HOST: added --printAST for print AST only.
    SHELL: added ls vars, help and quit command
    - :ls vars will list all variables in global scope.
    - :help will show help message with all commands.
    - :q, :quit will exit the shell.
    TEASCRIPT: added initial CoreLibrary + exit the script from any place.
    - CoreLibrary with 2 phases: BuildInternals and Bootstrap.
    - BuildInternals will add all underscore variables and functions.
    - the whole Bootstrap will add the rest of the Core Lib (also written in TeaScript)
    - have print to stdout/stderr, exit, min/max/clamp, number/string conversion and a minimal string support lib.
    - variables for version, etc.
    - can exit the script with exit code from any point by calling _exit(code)
    - CORELIB: added eval, eval_file and readline
    ASTNODE/PARSER: added Return Statement
    TEASCRIPT: added function def, function call and lambdas!
    - func def with func name( paramspec ) {}
    - or def name := func ( paramspec ) {}
    - the latter is also a lambda
    - added ASTNode_ParamSpec and ASTNode_ParamList, where the first creates new vars in the context,
      and the latter evals a list of statements to the parameter list.
    - added ASTNode_Func and ASTNode_CallFunc, where the first is a func definition and will create a Func Object on Eval
      and the latter will get the Func object from the context and call it.
    - added parsing of comma , for build a list of statements.
    TEASCRIPT/PARSER: added String as value type and in-string evaluation.    
    - string literals are normal used with enclosing double quotes "
    - escape sequence for tab, cr, nl, \, ", %
    - string concatenation operator is %
    - auto to string for string concat.
    - auto to number for arithmetic works as expected.
    - in-string eval is done with %(expr) (including inner strings without extra quoting!)
    UTIL: added TEASCRIPT_PRINT macro in new header Print.hpp

================
Version 0.5.0 (unreleased), Wed Sep 7 16:09:35 2022
================
    VERSION: 0.5.0 - repeat loop with labels and with clause.
    - repeat can have optional label as simple string for be addressable.
    - stop and loop can have optional label as simple string for address the repeat loop
    - optional with clause followed by a statement for stop to return a value from the loop.
    - repeat loops can be assigned.
    - UnitTest for repeat loop.
    - added gcd.tea script for compute the gcd with a repeat loop.
    ASTNODE/PARSER: added first version of repeat loop with stop and loop statement.

================
Version 0.4.0 (unreleased), Mon Aug 1 13:12:51 2022
================
    VERSION: 0.4.0 - If statements, assigning of if statements, blocks with scope, ...
    - UnitTest for if statements
    - added (temporarily?) debug operator which prints the name and value of identifier.
    TEASCRIPT: added if, else (and else if)
    TEASCRIPT/PARSERSTATE/ASTNODE: added first version of blocks with scope.
    TEASCRIPT: added comparison operators (relational and equality)    
    - eq, ne, gt, lt, ge and le are available as well.
    - using C++20 spaceship operator <=> for implement the comparison.
    - UnitTest for test comparison operators
    PARSER/AST: added the modulo operator 'mod'.

================
Version 0.3.0 (unreleased), Wed Jun 1 16:07:33 2022
================
    VERSION: 0.3.0 - def and undef variables, check with is_defined, assign, script arguments
    
    This milestone release contains
    - defining variables with keyword 'def'
    - undefine variables with keyword 'undef' (returns true if a variable existed and was undefined.)
    - check if a variable is defined with keyword 'is_defined'
    - assign new values to existing variables.
    - also the script can access the script arguments as global variables with arg1 ... argN
    - number of passed arguments can be queried with argN global variable.
    - with all of that a logical branching is already possible but unnatural (see example script).

    CONTENT: added [] operator for faster accessing character at offset position
    TEASCRIPT: passing command arguments to the script.
    TEASCRIPT/PARSER: added is_defined operator for variables.
    - this is valid code: is_defined a or (def a := 1)
    TEASCRIPT: define und undefine variables, assign and use them!    
    - added Context with Scopes for store, find and set values of variables.
    - ASTNode_Assign as binary operator for assign values to variables.
    - ASTNode_Var_Def_Undef for define and undefine variables (currently as unary operator).
    - Operator Precedence: deep lifting of inserted ASTNodes for complex operator and precedence combinations!
    - Unittest for variables.
    VALUE: ValueObject can now have either a shared or a unshared value!

================
Version 0.2.0 (unreleased), Tue May 24 22:22:03 2022
================
    VERSION: 0.2.0 - boolean constants, logical operators, operator precedence, mul/div, ...
    - added boolean true / false constants
    - added logical operators and, or (binary) and not (unary)
    - added real Unary_Operator ASTNode.
    - added integer mul and div.
    - operator precedence (and binds stronger as or, mul/div stronger as plus/minus)
    - added ASTNode_Identifier skeleton
    - convert to long long for arithmetic and to bool for logical operators.
    - throw division by zero when rhs is 0 for integer div.
    - Unittest for eval arithmetic and logical expressions.

================
Version 0.1.0 (unreleased), Mon May 23 16:05:03 2022
================
    VERSION: 0.1.0 - binary (+ simulated unary) Operators +/- for Integers and ...
    ... creating subexpressions with parentheses (grouping).
    ATSNODE: added IsDummy() for avoid casting + convenience IsIncomplete()
    PARSER: added (Sub-/Nested-)Expression parsing
    - added ASTNode_Expression for sub expressions.
    - added debug mode for print the AST to interactive shell (use :debug)
    TEASCRIPT/PARSER: added binary operator + and - for Integers (and simulate unary +/- as well)    
    - actually an iterative approach is chosen for parsing (instead of a recursive one).
    - ASTNode_Binary_Operator for + and - (applied to a lhs and rhs node)
    - Parser will fake an unary +/- by building a Binary Operator with a 0 as lhs value

================
Version 0.0.1 (unreleased), Fri May 13 12:23:58 2022
================
    VERSION: 0.0.1 - Parsing and evaluate integer constants (+ add versioning at all)
    
    - added version.h with version information.
    - note: this is the first and (probably) also the last .h file (instead of .hpp)
      which can be included also in plain C source code. The Version C MACROS can be used.
      This enables a future Wrapper C API (if needed/wanted).
    PARSER: fixed more than one integer constants can occur at same line


================
Unreleased, Milestone 2 (without version number), Thu May 12 23:17:14 2022
================
    MILESTONE 2: Have working Int parser for a Constant AST Node!    
    - added ASTNode_File for the node for a complete file / eval call.
    - added ASTNode_Child_Capable for all ASTNode which may have (generic) children.

================
Unreleased, Milestone 1 (without version number),  Thu May 12 12:30:26 2022
================
    PARSER/TEASCRIPT: MILESTONE 1: Eval of returned AST from Parser in all modes.
    - Parser returns No-Op AST now if no error occurred.
    - TeaScript prints the value of the ValueObject returned from the AST eval if it is printable.
    AST: first interface and implementation of the AST. Starting with No-Op and Constant.
    VALUE: added first version of class ValueObject, representing all values in TeaScript.
    PARSER: added parsing_error exception with current position.
    UNITTEST: added Unittest based on Boost Test
    

================
Unreleased, first documented version (without version number), Fri Apr 29 21:41:18 2022
================    
    Initial commit of TeaScript.
    
    Includes the TeaScript command line program (the script host) which comes with an interactive shell to parse (and later eval)
    TeaScript code as well as the functionality to pass script files or a TeasScript code string via command line parameter.
    The intend is to parse and execute generic TeaScript code, either interactive or more likely by running a script file.
    The interactive shell supports multi line inputs (via backslash at end of line).
    The TeaScript engine (the parsing and eval mechanism) will be developed as an include only library.
    The engine will be designed to run inside a C++ environment and shall be able to interact with the host environment
    in both directions (from host to script (e.g. make classes, variables, functions available) and
    from script to host (e.g. get return values back to C++ code, throw catchable std exceptions, etc. )).
    The Parser recognizes already hash lines, single line comments and multi line comments and is able to handle
    whitespace and EOLs as well.
    The Content class for keep track of the parsable input content has a lot of handy operators for moving the current
    parsing position, get the content and query and calculate extra information like line and column position as well as
    remaining and processed characters information.
    The Content class can be used with strings, static string literals and also for string_views and archaic raw pointers.
    This commit also includes some handy debug_print functions as well as the skeletons for class State and ASTNode.
    Future features of the TeaScript language and its engine might be (but are not limited to):
    support functions with pre-condition and post-condition code blocks, interactive script files, parallel keyword/code blocks,
    easy network / HTTP ReST support, easy and/or advance file io and multithreading support, batch jobs,
    image/memory processing abstraction, ...

