--- linuxsampler/trunk/ChangeLog	2019/08/29 13:44:35	3580
+++ linuxsampler/trunk/ChangeLog	2019/08/30 11:40:25	3581
@@ -2,11 +2,11 @@
 
   * general changes:
     - Fixed compiler error in Pool.h.
-    - Require C++11 compiler support.
+    - Require C++14 compiler support.
     - Autoconf: Added m4/ax_cxx_compile_stdcxx.m4 macro which is used
-      for checking in configure for C++11 support (as mandatory
+      for checking in configure for C++14 support (as mandatory
       requirement) and automatically adds compiler argument if required
-      (e.g. -std=C++11).
+      (e.g. -std=C++14).
     - RTMath: Implemented floating point comparison methods
       fEqual32(float,float) and fEqual64(double,double) which take the
       expected floating point tolerances into account.
@@ -58,6 +58,66 @@
       number.
     - Built-in script functions "min()" and "max()" optionally accept real
       number arguments and return real number as result in that case.
+    - NKSP VM API: Allow units and 'final'ness to be returned as result from
+      built-in functions (added methods VMFunction::returnUnitType() and
+      VMFunction::returnsFinal() for that purpose which must be implemented by
+      built-in function implementations).
+    - NKSP language: Allow metric unit prefixes of numeric scalar and array
+      variables to be changed freely at runtime (unlike unit types like Hz etc.
+      which are still sticky, parse-time features of variables which cannot be
+      changed at runtime for the intentional sake of determinism).
+    - NKSP language: 'final' values are prohibited for array variables for now
+      (attempt causes a parsers error).
+    - NKSP language: expressions with unit types (e.g. Hz) are prohibited for
+      conditions of runtime control structures like if(), while(), select()
+      (attempt causes a parser error).
+    - NKSP VM API: Allow built-in functions to perform their own, individual
+      parse time checks of arguments going to be passed to the function at
+      runtime (added method VMFunction::checkArgs() for that purpose).
+    - NKSP language: raise parser warning if only one operand of binary
+      operators (like logical 'or' comparison) contain a 'final' value (because
+      it would always yield in a 'final' result in such cases).
+    - NKSP language: Allow comparison (=, #, <, >, <=, >=) of values with
+      different metric unit prefixes, which will behave as expected (e.g.
+      result of expression '1000us < 2ms' is true).
+    - NKSP language: Allow adding values with different metric unit prefixes
+      (e.g. result of expression '100Hz + 5kHz' is '5100Hz').
+    - NKSP language: Allow subtracting values with different metric unit
+      prefixes (e.g. result of expression '1ms - 20us' is '980us').
+    - NKSP language: Allow multiplying with any metric unit prefixes
+      (e.g. result of expression '2k * 3ms' is '6s'), however multiplications
+      with unit types on both sides (e.g. '2s * 2s') is still prohibited since
+      we don't have any considerable practical use for a term like '4s^2'
+      (hence any attempt multiplying two unit types still causes parser error).
+    - NKSP language: Allow dividing by any metric unit prefixes and allow
+      division of same unit type on both sides (e.g. expression '8kHz / 1000Hz'
+      yields in unit free result '8'). So this is now a way to cast units away
+      e.g. for passing the result to other expressions, certain function calls
+      or variables which are not accepting any units (or that specific unit).
+    - NKSP language: integer arrays and real number arrays can now be converted
+      to strings (e.g. for dumping their content with message() calls for
+      script debugging purposes).
+    - NKSP language: expressions and variables with units are now correctly
+      casted to strings (e.g. with message() calls).
+    - NKSP language: comparing real numbers for equalness (e.g. '~foo = 3.1') or
+      unequalness (e.g. '~foo # 3.1') is now less strict and takes the expected
+      floating point tolerances into account.
+    - NKSP VM API: Added methods VMScalarNumberExpr::evalCastInt() and
+      VMScalarNumberExpr::evalCastReal().
+    - NKSP VM API: Added base class 'VMNumberArrayExpr' for classes
+      'VMIntArrayExpr' and 'VMRealArrayExpr'.
+    - NKSP VM API: replaced all unitPrefix() (parse time) methods by
+      unitFactor() (runtime) methods.
+    - Built-in function "exit()" supports now returning units and 'final'ness
+      for test cases.
+    - The following built-in functions support now units as well: "abs()",
+      "random()", "inc()", "dec()", "in_range()", "min()", "max()",
+      "real_to_int()", "int()", "int_to_real()" and "real()".
+    - Built-in functions "array_equal()", "search()" and "sort()" support now
+      real number arrays (correctly) as well.
+    - Added individual parse time checks of arguments to be passed to built-in
+      functions "random()", "inc()", "dec()", "in_range()", "min()", "max()",
+      "array_equal()" and "search()" specific for their individual purposes.
 
   * test cases:
     - Fixed compiler errors in test cases.
@@ -72,6 +132,10 @@
     - NKSP: Added real number test cases for built-in functions exit(),
       int_to_real(), real(), real_to_int() and int(), as well as for the
       plus, minus and negate language operators.
+    - Added massive amount of NKSP test cases for standard measuring units and
+      'final' operator usage cases.
+    - Added NKSP test cases for (floating point tolerance aware) real number
+      equalness / unequalness comparison.
 
 Version 2.1.1 (27 Jul 2019)