ENH: improve expression string expansions

- reuse more of stringOps expansions to reduce code and improve the
  syntax flexiblity.

  We can now embed "pre-calculated" values into an expression.
  For example,

       angle       35;
       valueExpr   "vector(${{cos(degToRad($angle))}}, 2, 3)";

  and the ${{..}} will be evaluated with the regular string evaluation
  and used to build the entire expression for boundary condition
  evaluation.

  Could also use for fairly wild indirect referencing:

       axis1   (1 0 0);
       axis2   (0 1 0);
       axis3   (0 0 1);
       index   100;
       expr   "$[(vector) axis${{ ($index % 3) +1 }}] / ${{max(1,$index)}}";

applications/test/exprEntry/Make/files

@@ -0,0 +1,3 @@
+Test-exprEntry.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-exprEntry

applications/test/exprEntry/Make/options

@@ -0,0 +1 @@
+EXE_INC =

applications/test/exprEntry/Test-exprEntry.C

@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2019 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-exprEntry
+
+Description
+    Read in the given dictionaries and attempt to use exprEntry expansion
+    on any strings.
+
+Note
+   Since this is only for testing purposes, only handles simple dictionary
+   entries without attempting to descend into sub-dicts.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "IOstreams.H"
+#include "IOobject.H"
+#include "IFstream.H"
+#include "dictionary.H"
+#include "stringOps.H"
+#include "exprString.H"
+
+using namespace Foam;
+
+bool hasStrings(const primitiveEntry& e)
+{
+    for (const token& tok : e.stream())
+    {
+        if (tok.isString())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::noBanner();
+    argList::noParallel();
+    argList::addArgument("dict .. dictN");
+    argList args(argc, argv, false, true);
+
+    if (args.size() <= 1)
+    {
+        Info<< "Must supply a dictionary name!" << nl;
+    }
+
+    for (label argi=1; argi < args.size(); ++argi)
+    {
+        IOobject::writeDivider(Info);
+
+        IFstream is(args[argi]);
+
+        const dictionary dict(is);
+
+        Info<< "Input dictionary:" << dict << nl
+            << "With any expansions" << nl << endl;
+
+        for (const entry& dEntry : dict)
+        {
+            const auto* eptr = isA<primitiveEntry>(dEntry);
+            if (!eptr || !hasStrings(*eptr))
+            {
+                continue;
+            }
+
+            const primitiveEntry& e = *eptr;
+            Info<< e << endl;
+
+            for (const token& t : e.stream())
+            {
+                if (t.isString())
+                {
+                    string str(t.stringToken());
+
+                    const bool throwingErr = FatalError.throwExceptions();
+                    const bool throwingIOErr = FatalIOError.throwExceptions();
+
+                    try
+                    {
+                        // Can get an error if we have things like
+                        // ${{ ... $[...] }}
+                        Info<< "str : " << stringOps::expand(str, dict) << nl;
+                    }
+                    catch (const Foam::error& err)
+                    {
+                        Info<< err.message().c_str() << nl;
+                    }
+
+                    try
+                    {
+                        // Should not trigger any errors
+                        expressions::exprString expr(str, dict, false);
+                        Info<< "expr: " << expr << nl;
+                    }
+                    catch (const Foam::error& err)
+                    {
+                        Info<< err.message().c_str() << nl;
+                    }
+
+                    FatalError.throwExceptions(throwingErr);
+                    FatalIOError.throwExceptions(throwingIOErr);
+                    Info<< nl;
+                }
+            }
+        }
+    }
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/test/exprEntry/testDict1

@@ -0,0 +1,69 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      testDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+scalar1  10;
+
+scalar2  20;
+
+vector1  (1 2 3);
+
+vector2  (2 3 4);
+
+aVector  1;
+bVector  2;
+
+string1  "This is a scalar $scalar1, or $[   scalar1   ]";
+
+string2  "This is a vector $vector1, or $[vector1]";
+
+string3  "This is a vector $vector1, or $[(vector)vector1]";
+
+string3b "This is a vector ${vector1}, or $[(vector)vector1]";
+
+string4 "This is a vector ${{ 5 * 12 }} or $[(vector)vector1]";
+
+string5 "This is a vector ${{ 5 * 12 }} or $[(vector)vector1]";
+
+string8 "This is a vector ${{ 5 * 12 * $[(vector)vector1] }}";
+
+// These actually work
+string10 #{
+    Cond is ${{ ${{ sin(degToRad(4*$scalar1)) }} * $[(vector) vector${aVector}] }}
+#};
+
+// These actually work
+string10b #{
+    Cond is ${{ ${{ sin(degToRad(4*$scalar1)) }} * $[(vector) vector$bVector] }}
+#};
+
+
+// Fairly simple idea
+angle        35;
+valueExpr1   "vector(${{cos(degToRad($angle))}}, 2, 3)";
+
+
+// Slightly stranger ideas:
+
+axis1   (1 0 0);
+axis2   (0 1 0);
+axis3   (0 0 1);
+
+index   100;
+
+valueExpr2   "$[(vector) axis${{ ($index % 3) +1 }}] / ${{max(1, $index)}}";
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //