zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ENH: robuster lemon parsing

Browse Source 
- previously simply reused the scan token, which works fine for
  non-nested tokenizations but becomes too fragile with nesting.

  Now changed to use tagged unions that can be copied about
  and still retain some rudimentary knowledge of their types,
  which can be manually triggered with a destroy() call.

- provide an 'identifier' non-terminal as an additional catch
  to avoid potential leakage on parsing failure.

- adjust lemon rules and infrastructure:

  - use %token to predefine standard tokens.
    Will reduce some noise on the generated headers by retaining the
    order on the initial token names.

  - Define BIT_NOT, internal token rename NOT -> LNOT

- handle non-terminal vector values.
  Support vector::x, vector::y and vector::z constants

- permit fieldExpr access to time().
  Probably not usable or useful for an '#eval' expression,
  but useful for a Function1.

- provisioning for hooks into function calls. Establishes token
  names for next commit(s).
This commit is contained in:
Mark Olesen
2021-11-19 12:06:32 +01:00
parent adbcd3a19f
commit e6697edb52
38 changed files with 6819 additions and 5812 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
applications/test/exprTraits/Test-exprTraits.C
View File

@ -21,6 +21,7 @@ Description
#include "uLabel.H"
#include "error.H"
#include "stringList.H"
#include "exprScanToken.H"
using namespace Foam;
@ -71,6 +72,34 @@ int main()
<< getName(expressions::valueTypeCode::type_bool) << nl;
{
expressions::scanToken tok;
expressions::scanToken tok2;
Info<< nl << "sizeof(scanToken): "
<< sizeof(tok) << nl;
Info<< " type:" << int(tok.type_) << nl;
Info<< " ptr:" << Foam::name(tok.name_) << nl;
Info<< " type:" << int(tok2.type_) << nl;
Info<< " ptr:" << Foam::name(tok2.name_) << nl;
tok.setWord("hello");
Info<< " type:" << int(tok.type_) << nl;
Info<< " ptr:" << Foam::name(tok.name_) << nl;
tok2 = tok;
Info<< " type:" << int(tok2.type_) << nl;
Info<< " ptr:" << Foam::name(tok2.name_) << nl;
tok2.destroy();
Info<< " type:" << int(tok2.type_) << nl;
Info<< " ptr:" << Foam::name(tok2.name_) << nl;
}
Info<< nl << "Done" << nl;
return 0;
}

1
src/OpenFOAM/Make/files
View File

@ -162,6 +162,7 @@ $(expr)/exprResult/exprResultStored.C
$(expr)/exprResult/exprResultStoredStack.C
$(expr)/exprString/exprString.C
$(expr)/exprTools/exprTools.C
$(expr)/scanToken/exprScanToken.C
$(expr)/traits/exprTraits.C

3
src/OpenFOAM/expressions/fields/fieldExprFwd.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -47,7 +47,6 @@ namespace fieldExpr
class parser;
class scanner;
class parseDriver;
union scanToken;
//- Static debugging option
extern int debug;

192
src/OpenFOAM/expressions/fields/fieldExprLemonParser.h
View File

@ -1,93 +1,99 @@
#define TOK_QUESTION 1
#define TOK_COLON 2
#define TOK_LOR 3
#define TOK_LAND 4
#define TOK_BIT_XOR 5
#define TOK_BIT_AND 6
#define TOK_EQUAL 7
#define TOK_NOT_EQUAL 8
#define TOK_LESS_EQ 9
#define TOK_GREATER_EQ 10
#define TOK_LESS 11
#define TOK_GREATER 12
#define TOK_PLUS 13
#define TOK_MINUS 14
#define TOK_TIMES 15
#define TOK_DIVIDE 16
#define TOK_PERCENT 17
#define TOK_NEGATE 18
#define TOK_NOT 19
#define TOK_DOT 20
#define TOK_NUMBER 21
#define TOK_ZERO 22
#define TOK_PI 23
#define TOK_LPAREN 24
#define TOK_RPAREN 25
#define TOK_DEG_TO_RAD 26
#define TOK_RAD_TO_DEG 27
#define TOK_ARG 28
#define TOK_TIME 29
#define TOK_DELTA_T 30
#define TOK_SCALAR_ID 31
#define TOK_MIN 32
#define TOK_COMMA 33
#define TOK_MAX 34
#define TOK_SUM 35
#define TOK_AVERAGE 36
#define TOK_EXP 37
#define TOK_LOG 38
#define TOK_LOG10 39
#define TOK_SQR 40
#define TOK_SQRT 41
#define TOK_CBRT 42
#define TOK_SIN 43
#define TOK_COS 44
#define TOK_TAN 45
#define TOK_ASIN 46
#define TOK_ACOS 47
#define TOK_ATAN 48
#define TOK_SINH 49
#define TOK_COSH 50
#define TOK_TANH 51
#define TOK_POW 52
#define TOK_ATAN2 53
#define TOK_POS 54
#define TOK_NEG 55
#define TOK_POS0 56
#define TOK_NEG0 57
#define TOK_SIGN 58
#define TOK_FLOOR 59
#define TOK_CEIL 60
#define TOK_ROUND 61
#define TOK_HYPOT 62
#define TOK_RAND 63
#define TOK_VECTOR_ID 64
#define TOK_SPH_TENSOR_ID 65
#define TOK_SYM_TENSOR_ID 66
#define TOK_IDENTITY_TENSOR 67
#define TOK_TENSOR_ID 68
#define TOK_LTRUE 69
#define TOK_LFALSE 70
#define TOK_BOOL 71
#define TOK_BOOL_ID 72
#define TOK_MAG 73
#define TOK_MAGSQR 74
#define TOK_VECTOR 75
#define TOK_TENSOR 76
#define TOK_SYM_TENSOR 77
#define TOK_SPH_TENSOR 78
#define TOK_CMPT_X 79
#define TOK_CMPT_Y 80
#define TOK_CMPT_Z 81
#define TOK_CMPT_XX 82
#define TOK_CMPT_XY 83
#define TOK_CMPT_XZ 84
#define TOK_CMPT_YX 85
#define TOK_CMPT_YY 86
#define TOK_CMPT_YZ 87
#define TOK_CMPT_ZX 88
#define TOK_CMPT_ZY 89
#define TOK_CMPT_ZZ 90
#define TOK_CMPT_II 91
#define TOK_TRANSPOSE 92
#define TOK_DIAG 93
#define TOK_LPAREN 1
#define TOK_RPAREN 2
#define TOK_COMMA 3
#define TOK_QUESTION 4
#define TOK_COLON 5
#define TOK_LOR 6
#define TOK_LAND 7
#define TOK_LNOT 8
#define TOK_BIT_OR 9
#define TOK_BIT_XOR 10
#define TOK_BIT_AND 11
#define TOK_BIT_NOT 12
#define TOK_EQUAL 13
#define TOK_NOT_EQUAL 14
#define TOK_LESS 15
#define TOK_LESS_EQ 16
#define TOK_GREATER 17
#define TOK_GREATER_EQ 18
#define TOK_PLUS 19
#define TOK_MINUS 20
#define TOK_TIMES 21
#define TOK_DIVIDE 22
#define TOK_PERCENT 23
#define TOK_NEGATE 24
#define TOK_DOT 25
#define TOK_BOOL 26
#define TOK_LTRUE 27
#define TOK_LFALSE 28
#define TOK_NUMBER 29
#define TOK_ZERO 30
#define TOK_IDENTIFIER 31
#define TOK_PI 32
#define TOK_DEG_TO_RAD 33
#define TOK_RAD_TO_DEG 34
#define TOK_ARG 35
#define TOK_TIME 36
#define TOK_DELTA_T 37
#define TOK_SCALAR_FUNCTION_ID 38
#define TOK_VECTOR_VALUE 39
#define TOK_VECTOR_FUNCTION_ID 40
#define TOK_SCALAR_ID 41
#define TOK_MIN 42
#define TOK_MAX 43
#define TOK_SUM 44
#define TOK_AVERAGE 45
#define TOK_EXP 46
#define TOK_LOG 47
#define TOK_LOG10 48
#define TOK_SQR 49
#define TOK_SQRT 50
#define TOK_CBRT 51
#define TOK_SIN 52
#define TOK_COS 53
#define TOK_TAN 54
#define TOK_ASIN 55
#define TOK_ACOS 56
#define TOK_ATAN 57
#define TOK_SINH 58
#define TOK_COSH 59
#define TOK_TANH 60
#define TOK_POW 61
#define TOK_ATAN2 62
#define TOK_POS 63
#define TOK_NEG 64
#define TOK_POS0 65
#define TOK_NEG0 66
#define TOK_SIGN 67
#define TOK_FLOOR 68
#define TOK_CEIL 69
#define TOK_ROUND 70
#define TOK_HYPOT 71
#define TOK_RAND 72
#define TOK_VECTOR_ID 73
#define TOK_SPH_TENSOR_ID 74
#define TOK_SYM_TENSOR_ID 75
#define TOK_IDENTITY_TENSOR 76
#define TOK_TENSOR_ID 77
#define TOK_BOOL_ID 78
#define TOK_MAG 79
#define TOK_MAGSQR 80
#define TOK_VECTOR 81
#define TOK_TENSOR 82
#define TOK_SYM_TENSOR 83
#define TOK_SPH_TENSOR 84
#define TOK_CMPT_X 85
#define TOK_CMPT_Y 86
#define TOK_CMPT_Z 87
#define TOK_CMPT_XX 88
#define TOK_CMPT_XY 89
#define TOK_CMPT_XZ 90
#define TOK_CMPT_YX 91
#define TOK_CMPT_YY 92
#define TOK_CMPT_YZ 93
#define TOK_CMPT_ZX 94
#define TOK_CMPT_ZY 95
#define TOK_CMPT_ZZ 96
#define TOK_CMPT_II 97
#define TOK_TRANSPOSE 98
#define TOK_DIAG 99

90
src/OpenFOAM/expressions/fields/fieldExprLemonParser.lyy-m4
View File

@ -98,6 +98,7 @@ TBD
*/
%include
{
#include "exprScanToken.H"
#include "fieldExprDriver.H"
#include "fieldExprParser.H"
#include "fieldExprScanner.H"
@ -131,11 +132,8 @@ tmp_management()
%token_prefix TOK_
// Terminals
%token_type {Foam::expressions::fieldExpr::scanToken*}
// Non-terminals
%type ivalue { Foam::label }
%type svalue { Foam::scalar }
%type ident { Foam::word* }
%token_type {Foam::expressions::scanToken}
%token_destructor { ($$).destroy(); }
// Fields
declare_field(lfield, Foam::boolField, bool, newField, getField)
@ -150,6 +148,7 @@ declare_field(tfield, Foam::tensorField, Foam::tensor, newField, getField)
// Lemon does not generate a destructor for that.
// So do not use Lemon destructors for anything.
standard_tokens()
operator_precedence()
%start_symbol evaluate
@ -160,7 +159,10 @@ operator_precedence()
* Productions (scalar)
\*---------------------------------------------------------------------------*/
svalue (lhs) ::= NUMBER (a) . { lhs = (a)->svalue; } // From scanToken
%type svalue { Foam::scalar }
svalue (lhs) ::= NUMBER (tok) . { lhs = (tok).scalarValue; } // scanToken
svalue (lhs) ::= ZERO . { lhs = Foam::Zero; }
svalue (lhs) ::= PI LPAREN RPAREN . { lhs = Foam::constant::mathematical::pi; }
svalue (lhs) ::= DEG_TO_RAD LPAREN RPAREN . { lhs = Foam::degToRad(); }
@ -169,6 +171,32 @@ svalue (lhs) ::= ARG LPAREN RPAREN . { lhs = driver->argValue(); }
svalue (lhs) ::= TIME LPAREN RPAREN . { lhs = driver->timeValue(); }
svalue (lhs) ::= DELTA_T LPAREN RPAREN . { lhs = driver->deltaT(); }
svalue (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN RPAREN .
{
driver->reportFatal("Not implemented: " + make_obj(name.name_));
lhs = 0;
}
/*---------------------------------------------------------------------------*\
* Productions (vector)
\*---------------------------------------------------------------------------*/
%type vvalue { Foam::vector* }
%destructor vvalue { delete($$); $$ = nullptr; }
vvalue (lhs) ::= VECTOR_VALUE (tok) .
{
// Take ownership of pointer from scan token
lhs = tok.vectorPtr; tok.vectorPtr = nullptr;
}
vvalue (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN RPAREN .
{
driver->reportFatal("Not implemented: " + make_obj(name.name_));
lhs = new Foam::vector(0,0,0);
}
/* * * * * * * * * * * * * * * * * * Fields * * * * * * * * * * * * * * * * *\
dnl
@ -184,7 +212,9 @@ dnl
/*---------------------------------------------------------------------------*\
* Productions (scalarField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [sfield])dnl
define([_new_target_], [_new_sfield])dnl
define([_value_type_], [Foam::scalar])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -200,9 +230,9 @@ rules_scalar_operations()
rules_scalar_functions()
// Non-standard but manage via FieldOps::assign
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<_value_type_>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<_value_type_>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<_value_type_>())
// Non-standard but works directly for scalarField
rule_binary_func(_target_, _target_, _target_, HYPOT, Foam::hypot)
@ -217,20 +247,30 @@ _target_ (lhs) ::= RAND LPAREN RPAREN.
_target_ (lhs) ::= RAND LPAREN NUMBER (seed) RPAREN.
{
lhs = driver->field_rand(std::round((seed)->svalue)).ptr();
lhs = driver->field_rand(std::round((seed).scalarValue)).ptr();
}
_target_ (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (vectorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [vfield])dnl
define([_new_target_], [_new_vfield])dnl
define([_value_type_], [Foam::vector])dnl
dnl
\*---------------------------------------------------------------------------*/
evaluate ::= _target_ (a) . { driver->setResult(a); }
rule_field_from_value(_target_, vvalue)
rule_get_field(_target_, VECTOR_ID)
rules_standard(_target_, _value_type_, _logic_)
@ -238,11 +278,22 @@ rules_inplace_gUnary(_target_)
rules_vector_operations()
rules_vector_functions()
// Other functions
_target_ (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (sphericalTensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [hfield])dnl
define([_new_target_], [_new_hfield])dnl
define([_value_type_], [Foam::sphericalTensor])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -260,7 +311,9 @@ rules_sphTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (symmTensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [yfield])dnl
define([_new_target_], [_new_yfield])dnl
define([_value_type_], [Foam::symmTensor])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -278,7 +331,9 @@ rules_symTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (tensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [tfield])dnl
define([_new_target_], [_new_tfield])dnl
define([_value_type_], [Foam::tensor])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -300,6 +355,7 @@ rules_tensor_functions()
* Logic field productions (boolField)
dnl
define([_target_], [lfield])dnl
define([_new_target_], [_new_lfield])dnl
define([_value_type_], [bool])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -393,13 +449,15 @@ void Foam::expressions::fieldExpr::parser::start(parseDriver& driver_)
}
void Foam::expressions::fieldExpr::parser::parse
(
int tokenId,
scanToken* tokenVal
)
void Foam::expressions::fieldExpr::parser::parse(int tokenId)
{
Parse(lemon_, tokenId, tokenVal);
Parse(lemon_, tokenId, scanToken::null());
}
void Foam::expressions::fieldExpr::parser::parse(int tokenId, scanToken tok)
{
Parse(lemon_, tokenId, tok);
}

11
src/OpenFOAM/expressions/fields/fieldExprParser.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -34,6 +34,7 @@ Description
#ifndef expressions_fieldExprParser_H
#define expressions_fieldExprParser_H
#include "exprScanToken.H"
#include "fieldExprFwd.H"
namespace Foam
@ -97,10 +98,14 @@ public:
//- Stop parsing, freeing the allocated parser
void stop();
//- Push token/value to parser
void parse(int tokenId, scanToken* tokenVal);
//- Push token type to parser with default token
void parse(int tokenId);
//- Push token type/value to parser
void parse(int tokenId, scanToken tok);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace fieldExpr

24
src/OpenFOAM/expressions/fields/fieldExprScanner.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -38,7 +38,6 @@ Note
#define expressions_fieldExprScanner_H
#include "fieldExprFwd.H"
#include "scalar.H"
namespace Foam
{
@ -47,21 +46,6 @@ namespace expressions
namespace fieldExpr
{
/*---------------------------------------------------------------------------*\
Class scanToken Declaration
\*---------------------------------------------------------------------------*/
union scanToken
{
Foam::label ivalue;
Foam::scalar svalue;
Foam::word* name;
//- Default construct, bit-wise zero for union content
scanToken() : ivalue(0) {}
};
/*---------------------------------------------------------------------------*\
Class scanner Declaration
\*---------------------------------------------------------------------------*/
@ -83,16 +67,14 @@ class scanner
bool dispatch_method
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident // Receives a copy
) const;
//- Dispatch identifier to parser (if possible) or Fatal
bool dispatch_ident
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident // Receives a copy
) const;

3179
src/OpenFOAM/expressions/fields/fieldExprScanner.cc
View File

File diff suppressed because it is too large Load Diff

111
src/OpenFOAM/expressions/fields/fieldExprScanner.rl
View File

@ -28,6 +28,7 @@ Description
\*---------------------------------------------------------------------------*/
#include "exprScanToken.H"
#include "fieldExprScanner.H"
#include "fieldExprDriver.H"
#include "fieldExprLemonParser.h"
@ -42,7 +43,6 @@ Description
#undef DebugInfo
#define DebugInfo if (debug & 0x2) InfoErr
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
@ -57,6 +57,7 @@ namespace Foam
//- An {int, c_str} enum pairing for field types
#define FIELD_PAIR(Fld,T) { TOKEN_OF(T), Fld::typeName.c_str() }
// No known look-back types
#undef HAS_LOOKBEHIND_TOKENS
// Special handling of predefined method types. Eg, .x(), .y(), ...
@ -121,22 +122,27 @@ static int driverTokenType
const word& ident
)
{
#ifdef HAS_LOOKBEHIND_TOKENS
// Get stashed "look-behind" to decide what type of identifier we expect
#endif
// Field variables
#ifdef TOK_SCALAR_ID
{
#undef checkFieldToken
#define checkFieldToken(TokType, Type) \
#undef doLocalCode
#define doLocalCode(TokType, Type) \
if (driver_.isLocalVariable<Type>(ident, false)) \
{ \
return TokType; \
}
checkFieldToken(TOK_SCALAR_ID, scalar);
checkFieldToken(TOK_VECTOR_ID, vector);
checkFieldToken(TOK_SYM_TENSOR_ID, symmTensor);
checkFieldToken(TOK_SPH_TENSOR_ID, sphericalTensor);
checkFieldToken(TOK_TENSOR_ID, tensor);
// Not tested: checkFieldToken(TOK_BOOL_ID, bool);
doLocalCode(TOK_SCALAR_ID, scalar);
doLocalCode(TOK_VECTOR_ID, vector);
doLocalCode(TOK_SYM_TENSOR_ID, symmTensor);
doLocalCode(TOK_SPH_TENSOR_ID, sphericalTensor);
doLocalCode(TOK_TENSOR_ID, tensor);
// Not tested: doLocalCode(TOK_BOOL_ID, bool);
#undef doLocalCode
}
#endif
@ -156,7 +162,15 @@ static int driverTokenType
#define EMIT_TOKEN(T) \
driver_.parsePosition() = (ts-buf); \
DebugInfo<< STRINGIFY(T) << " at " << driver_.parsePosition() << nl; \
parser_->parse(TOKEN_OF(T), nullptr); \
parser_->parse(TOKEN_OF(T)); \
driver_.parsePosition() = (p-buf);
#define EMIT_VECTOR_TOKEN(X, Y, Z) \
driver_.parsePosition() = (ts-buf); \
DebugInfo<< "VECTOR at " << driver_.parsePosition() << nl; \
scanToken scanTok; \
scanTok.setVector(X,Y,Z); \
parser_->parse(TOK_VECTOR_VALUE, scanTok); \
driver_.parsePosition() = (p-buf);
@ -165,15 +179,18 @@ static int driverTokenType
write data;
action emit_number {
// Emit number
driver_.parsePosition() = (ts-buf);
DebugInfo
<< "Number:" << std::string(ts, te-ts).c_str()
<< " at " << driver_.parsePosition() << nl;
if (readScalar(std::string(ts, te-ts), scanTok.svalue))
scanToken scanTok;
scanTok.setScalar(0);
if (readScalar(std::string(ts, te-ts), scanTok.scalarValue))
{
parser_->parse(TOKEN_OF(NUMBER), &scanTok);
parser_->parse(TOKEN_OF(NUMBER), scanTok);
}
else
{
@ -187,15 +204,16 @@ static int driverTokenType
}
action emit_ident {
// Emit identifier
driver_.parsePosition() = (ts-buf);
dispatch_ident(driver_, scanTok, word(ts, te-ts, false));
dispatch_ident(driver_, word(ts, te-ts, false));
driver_.parsePosition() = (p-buf);
}
action emit_method {
// Tokenized ".method" - dispatch '.' and "method" separately
driver_.parsePosition() = (ts-buf);
dispatch_method(driver_, scanTok, word(ts+1, te-ts-1, false));
dispatch_method(driver_, word(ts+1, te-ts-1, false));
driver_.parsePosition() = (p-buf);
}
@ -213,7 +231,7 @@ static int driverTokenType
number => emit_number;
## Operators
'!' =>{ EMIT_TOKEN(NOT); };
'!' =>{ EMIT_TOKEN(LNOT); };
'%' =>{ EMIT_TOKEN(PERCENT); };
'(' =>{ EMIT_TOKEN(LPAREN); };
')' =>{ EMIT_TOKEN(RPAREN); };
@ -234,7 +252,7 @@ static int driverTokenType
'&&' =>{ EMIT_TOKEN(LAND); };
'||' =>{ EMIT_TOKEN(LOR); };
'&' =>{ EMIT_TOKEN(BIT_AND); };
## Not needed? '|' =>{ EMIT_TOKEN(BIT_OK); };
## Not needed? '|' =>{ EMIT_TOKEN(BIT_OR); };
'^' =>{ EMIT_TOKEN(BIT_XOR); };
## Some '.method' - Error if unknown
@ -286,13 +304,16 @@ static int driverTokenType
"sphericalTensor" =>{ EMIT_TOKEN(SPH_TENSOR); };
## Single value (constants, etc)
"Zero" =>{ EMIT_TOKEN(ZERO); };
"true" =>{ EMIT_TOKEN(LTRUE); };
"false" =>{ EMIT_TOKEN(LFALSE); };
"Zero" =>{ EMIT_TOKEN(ZERO); };
"vector::x" =>{ EMIT_VECTOR_TOKEN(1,0,0); };
"vector::y" =>{ EMIT_VECTOR_TOKEN(0,1,0); };
"vector::z" =>{ EMIT_VECTOR_TOKEN(0,0,1); };
"tensor::I" =>{ EMIT_TOKEN(IDENTITY_TENSOR); };
"arg" =>{ EMIT_TOKEN(ARG); };
## "time" =>{ EMIT_TOKEN(TIME); };
## "deltaT" =>{ EMIT_TOKEN(DELTA_T); };
"time" =>{ EMIT_TOKEN(TIME); };
"deltaT" =>{ EMIT_TOKEN(DELTA_T); };
## Identifier (field, etc - error if unknown)
## Handle 'bare' names and single/double quoted ones
@ -321,8 +342,7 @@ Foam::expressions::fieldExpr::scanner::~scanner()
bool Foam::expressions::fieldExpr::scanner::dispatch_method
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident
) const
{
if (ident[0] == '.')
@ -339,8 +359,8 @@ bool Foam::expressions::fieldExpr::scanner::dispatch_method
if (methType > 0)
{
// Dispatch '.' and "method" separately
parser_->parse(TOK_DOT, nullptr);
parser_->parse(methType, nullptr);
parser_->parse(TOK_DOT);
parser_->parse(methType);
return true;
}
@ -353,10 +373,11 @@ bool Foam::expressions::fieldExpr::scanner::dispatch_method
bool Foam::expressions::fieldExpr::scanner::dispatch_ident
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident
) const
{
// Peek at stashed "look-behind". It may influence decisions
int lookBehindTok = driver_.stashedTokenId();
int tokType = -1;
const bool quoted =
@ -381,12 +402,12 @@ bool Foam::expressions::fieldExpr::scanner::dispatch_ident
<< "Emit:" << ident << " function:"
<< parser_->tokenName(tokType) << nl;
parser_->parse(tokType, nullptr);
parser_->parse(tokType);
return true;
}
#ifdef HAS_LOOKBEHIND_TOKENS
// Specials such "cset" also reset the look-behind
// Specials such "cellSet" etc also reset the look-behind
tokType = lookBehindTokenEnums.lookup(ident, -1);
if (tokType > 0)
@ -396,17 +417,28 @@ bool Foam::expressions::fieldExpr::scanner::dispatch_ident
<< parser_->tokenName(tokType) << nl;
driver_.resetStashedTokenId(tokType);
parser_->parse(tokType, nullptr);
parser_->parse(tokType);
return true;
}
#endif
}
// Functions: scalar, vector, probably don't need others
// - "fn:" prefix to avoid any ambiguities
if (lookBehindTok <= 0 && ident.starts_with("fn:"))
{
word funcName(ident.substr(3)); // strip prefix
// Can also peek at stashed "look-behind"
// const int lookBehind = driver_.stashedTokenId();
do
{
}
while (false);
}
if (tokType <= 0)
{
tokType = driverTokenType(driver_, ident);
}
if (tokType > 0)
{
@ -414,8 +446,9 @@ bool Foam::expressions::fieldExpr::scanner::dispatch_ident
<< "Emit:" << ident << " token:"
<< parser_->tokenName(tokType) << nl;
scanTok.name = new Foam::word(std::move(ident));
parser_->parse(tokType, &scanTok);
scanToken scanTok;
scanTok.setWord(ident);
parser_->parse(tokType, scanTok);
return true;
}
@ -447,12 +480,13 @@ bool Foam::expressions::fieldExpr::scanner::dispatch_ident
// The field (before the ".")
ident.erase(dot);
scanTok.name = new Foam::word(std::move(ident));
parser_->parse(tokType, &scanTok);
scanToken scanTok;
scanTok.setWord(ident);
parser_->parse(tokType, scanTok);
// Dispatch '.' and "method" separately
parser_->parse(TOK_DOT, nullptr);
parser_->parse(methType, nullptr);
parser_->parse(TOK_DOT);
parser_->parse(methType);
return true;
}
@ -515,9 +549,6 @@ bool Foam::expressions::fieldExpr::scanner::process
parser_->start(driver_);
// Scan token type
scanToken scanTok;
// Token start/end (Ragel naming)
const char* ts;
const char* te;
@ -547,7 +578,7 @@ bool Foam::expressions::fieldExpr::scanner::process
}
// Terminate parser execution
parser_->parse(0, nullptr);
parser_->parse(0);
parser_->stop();
if (debug & 0x6)

92
src/OpenFOAM/expressions/scanToken/exprScanToken.C Normal file
View File

@ -0,0 +1,92 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021 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/>.
\*---------------------------------------------------------------------------*/
#include "exprScanToken.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::expressions::scanToken Foam::expressions::scanToken::null()
{
scanToken tok;
tok.type_ = LABEL;
tok.labelValue = 0;
return tok;
}
void Foam::expressions::scanToken::destroy()
{
if (type_ == VECTOR)
{
delete vectorPtr;
vectorPtr = nullptr;
}
else if (type_ == WORD)
{
delete wordPtr;
wordPtr = nullptr;
}
}
void Foam::expressions::scanToken::setLabel(label val)
{
type_ = LABEL;
labelValue = val;
}
void Foam::expressions::scanToken::setScalar(scalar val)
{
type_ = SCALAR;
scalarValue = val;
}
void Foam::expressions::scanToken::setVector(scalar x, scalar y, scalar z)
{
type_ = VECTOR;
vectorPtr = new Foam::vector(x, y, z);
}
void Foam::expressions::scanToken::setVector(const vector& val)
{
type_ = VECTOR;
vectorPtr = new Foam::vector(val);
}
void Foam::expressions::scanToken::setWord(const word& val)
{
type_ = WORD;
wordPtr = new Foam::word(val);
}
// ************************************************************************* //

116
src/OpenFOAM/expressions/scanToken/exprScanToken.H Normal file
View File

@ -0,0 +1,116 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019-2021 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/>.
Class
Foam::expressions::scanToken
Description
A low-level input/scan token content.
No defined constructors/destructors.
All memory management is manual!
\*---------------------------------------------------------------------------*/
#ifndef expressions_scanToken_H
#define expressions_scanToken_H
#include "scalar.H"
#include "vector.H"
#include "word.H"
namespace Foam
{
namespace expressions
{
/*---------------------------------------------------------------------------*\
Class scanToken Declaration
\*---------------------------------------------------------------------------*/
struct scanToken
{
//- Tagged union types
enum tokenType : unsigned char
{
LABEL = 0,
SCALAR,
VECTOR,
WORD
};
// Data
//- The data content (as a union).
// For memory alignment have this appear as the first member.
union
{
Foam::label labelValue;
Foam::scalar scalarValue;
Foam::vector* vectorPtr;
Foam::word* wordPtr;
Foam::word* name_;
};
//- The token type
tokenType type_;
// Member Functions
//- Return a null token - in lieu of a default constructor
static scanToken null();
//- Assign type/value to be LABEL. Does not call destroy().
void setLabel(label val);
//- Assign type/value to be SCALAR. Does not call destroy().
void setScalar(scalar val);
//- Assign type/value to be VECTOR. Does not call destroy().
void setVector(scalar x, scalar y, scalar z);
//- Assign type/value to be VECTOR. Does not call destroy().
void setVector(const vector& val);
//- Assign type/value to be WORD (name). Does not call destroy().
void setWord(const word& val);
//- Manual deletion of pointer types
void destroy();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace expressions
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

3
src/OpenFOAM/include/m4/bison/named-characters.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Named versions (as m4 macros) of single quoted characters to avoid

19
src/OpenFOAM/include/m4/lemon/base-setup.m4
View File

@ -6,11 +6,10 @@ divert(-1)dnl
# \\ / A nd | www.openfoam.com
# \\/ M anipulation |
#------------------------------------------------------------------------------
# Copyright (C) 2019 OpenCFD Ltd.
# Copyright (C) 2019-2021 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# A collection of 'base' setup of m4 macros for lemon, and setup
@ -34,7 +33,7 @@ divert(-1)dnl
# _sphTensor_, _symTensor_, _tensor_
#
# Values for the currently targeted rule
# _target_, _value_type_
# _target_, _value_type_, _scalar_arg_
#
# Note
# The `undefine' occur immediately upon inclusion of this file.
@ -109,18 +108,19 @@ Foam::tmp<T> make_tmp(T* p)
//- Default [make_obj] is pass-through
template<class T>
const T& make_obj(const T& obj)
const T& make_obj(const T& o) noexcept
{
return obj;
return o;
}
//- Move construct an object from a pointer and destroy the pointer
template<class T>
T make_obj(T* p)
T make_obj(T*& p)
{
T obj(std::move(*p));
T o(std::move(*p));
delete p;
return obj;
p = nullptr; // Prevent caller from deleting too
return o;
}]
)
@ -149,6 +149,7 @@ undefine([_tensor_])
undefine([_target_])
undefine([_value_type_])
undefine([_scalar_arg_])
#------------------------------------------------------------------------------
divert(0)dnl

45
src/OpenFOAM/include/m4/lemon/operator-precedence.m4
View File

@ -6,11 +6,10 @@ divert(-1)dnl
# \\ / A nd | www.openfoam.com
# \\/ M anipulation |
#------------------------------------------------------------------------------
# Copyright (C) 2019 OpenCFD Ltd.
# Copyright (C) 2019-2021 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Defines standard operator precedence macro for lemon grammar.
@ -20,18 +19,34 @@ divert(-1)dnl
define([operator_precedence],
[// [https://en.cppreference.com/w/cpp/language/operator_precedence]
%right QUESTION COLON . // 16: right-to-left
%left LOR . // 15:
%left LAND . // 14:
// %left BIT_OR . // 13 (unused)
%left BIT_XOR . // 12
%left BIT_AND . // 11
%left EQUAL NOT_EQUAL . // 10
%left LESS_EQ GREATER_EQ LESS GREATER . // 9
%left PLUS MINUS . // 6
%left TIMES DIVIDE PERCENT . // 5
%right NEGATE NOT . // 3: right-to-left
%left DOT . // 2: (method)]
%right QUESTION COLON . // 13: right-to-left
%left LOR . // 12:
%left LAND . // 11:
%left BIT_OR . // 10 (unused)
%left BIT_XOR . // 9
%left BIT_AND . // 8
%left EQUAL NOT_EQUAL . // 7
%left LESS LESS_EQ GREATER GREATER_EQ . // 6
%left PLUS MINUS . // 4
%left TIMES DIVIDE PERCENT . // 3
%right NEGATE LNOT BIT_NOT . // 2: right-to-left
%left DOT . // 1: (method)]
)
define([standard_tokens],
[// Standard tokens for operators, constants and common types]
%token
LPAREN RPAREN COMMA
QUESTION COLON LOR LAND LNOT
BIT_OR BIT_XOR BIT_AND BIT_NOT
EQUAL NOT_EQUAL
LESS LESS_EQ GREATER GREATER_EQ
PLUS MINUS TIMES DIVIDE PERCENT
NEGATE DOT
BOOL LTRUE LFALSE
NUMBER ZERO IDENTIFIER
.
)
#------------------------------------------------------------------------------

3
src/OpenFOAM/include/m4/lemon/parser-methods.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Various "boilerplate" parser methods (C++)

3
src/OpenFOAM/include/m4/lemon/rules-components.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Collection of VectorSpace `component' functions

3
src/OpenFOAM/include/m4/lemon/rules-fields-components.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Rules for vector/tensor `zip' functions, which are used to combine

35
src/OpenFOAM/include/m4/lemon/rules-fields.m4
View File

@ -62,39 +62,20 @@ define([_get_]$1, [driver->$5<$3>($][1).ptr()])dnl
# Example
# rule_get_field(sfield, SCALAR_ID)
#
# sfield (lhs) ::= SCALAR_ID (ident) .
# sfield (lhs) ::= SCALAR_ID (name) .
# {
# lhs = driver->getVolField<Foam::scalar>(make_obj(ident->name)).ptr();
# lhs = driver->getVolField<Foam::scalar>(make_obj(name.name_)).ptr();
# }
#------------------------------------------------------------------------------
define([rule_get_field],
[$1 (lhs) ::= $2 (ident) .
[$1 (lhs) ::= $2 (name) .
{
lhs = _get_$1(make_obj(ident->name));
lhs = _get_$1(make_obj(name.name_));
}]
)
#------------------------------------------------------------------------------
# rule_driver_select(out, tok, method)
#
# Description
# Production rule for driver get cell/face/point selection methods
#
# Example
# rule_driver_select(sfield, CSET, field_cellSet)
#
# sfield (lhs) ::= CSET LPAREN IDENTIFIER (ident) RPAREN .
# {
# lhs = driver->field_cellSet(make_obj(ident->name)).ptr();
# }
#------------------------------------------------------------------------------
define([rule_driver_select],
[rule_driver_unary_named($1, $2, IDENTIFIER, $3)])
#------------------------------------------------------------------------------
# rule_field_from_value(out, in, [prefix])
#
@ -454,19 +435,19 @@ ifelse($5,[],[],[<$5>])dnl # Optional template parameter (value_type)
# Foam::scalar
# )
#
# sfield(lhs) ::= SN_GRAD LPAREN SCALAR_ID (ident) RPAREN .
# sfield(lhs) ::= SN_GRAD LPAREN SCALAR_ID (name) RPAREN .
# {
# lhs = driver->patchNormalField<Foam::scalar>(make_obj(ident->name)).ptr();
# lhs = driver->patchNormalField<Foam::scalar>(make_obj(name.name_)).ptr();
# }
#
#------------------------------------------------------------------------------
define([rule_driver_unary_named],
[$1 (lhs) ::= $2 LPAREN $3 (ident) RPAREN .
[$1 (lhs) ::= $2 LPAREN $3 (name) RPAREN .
{
lhs = driver->$4[]dnl # The method call
ifelse($5,[],[],[<$5>])dnl # Optional template parameter (value_type)
(make_obj(ident->name)).ptr();
(make_obj(name.name_)).ptr();
}]
)

3
src/OpenFOAM/include/m4/lemon/rules-functions.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Collection of `standard' functions and type-specific ones.

3
src/OpenFOAM/include/m4/lemon/rules-operations.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Collection of `standard' operations and type-specific ones.

5
src/OpenFOAM/include/m4/lemon/rules-scalar-logic.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Logic rules, using bool or Foam::scalar for its storage.
@ -98,7 +97,7 @@ define([rule_logical_or],
)
define([rule_logical_negate],
[$1 (lhs) ::= NOT $1 (a). _lemon_precedence(NEGATE)
[$1 (lhs) ::= LNOT $1 (a). _lemon_precedence(NEGATE)
{
lhs = a;
Foam::FieldOps::assign

3
src/OpenFOAM/include/m4/lemon/rules-standard.m4
View File

@ -9,8 +9,7 @@ divert(-1)dnl
# Copyright (C) 2019 OpenCFD Ltd.
#------------------------------------------------------------------------------
# License
# This file is part of OpenFOAM, distributed under GNU General Public
# License GPL-3.0 or later <https://www.gnu.org/licenses/gpl-3.0>
# This file is part of OpenFOAM, distributed under GPL-3.0-or-later.
#
# Description
# Collection of common functions that should work on all (non-logical)

1
src/finiteVolume/expressions/patch/patchExprFwd.H
View File

@ -47,7 +47,6 @@ namespace patchExpr
class parser;
class scanner;
class parseDriver;
union scanToken;
//- Static debugging option
extern int debug;

240
src/finiteVolume/expressions/patch/patchExprLemonParser.h
View File

@ -1,115 +1,125 @@
#define TOK_QUESTION 1
#define TOK_COLON 2
#define TOK_LOR 3
#define TOK_LAND 4
#define TOK_BIT_XOR 5
#define TOK_BIT_AND 6
#define TOK_EQUAL 7
#define TOK_NOT_EQUAL 8
#define TOK_LESS_EQ 9
#define TOK_GREATER_EQ 10
#define TOK_LESS 11
#define TOK_GREATER 12
#define TOK_PLUS 13
#define TOK_MINUS 14
#define TOK_TIMES 15
#define TOK_DIVIDE 16
#define TOK_PERCENT 17
#define TOK_NEGATE 18
#define TOK_NOT 19
#define TOK_DOT 20
#define TOK_NUMBER 21
#define TOK_ZERO 22
#define TOK_PI 23
#define TOK_LPAREN 24
#define TOK_RPAREN 25
#define TOK_DEG_TO_RAD 26
#define TOK_RAD_TO_DEG 27
#define TOK_ARG 28
#define TOK_TIME 29
#define TOK_DELTA_T 30
#define TOK_SCALAR_ID 31
#define TOK_SSCALAR_ID 32
#define TOK_INTERNAL_FIELD 33
#define TOK_NEIGHBOUR_FIELD 34
#define TOK_SN_GRAD 35
#define TOK_MIN 36
#define TOK_COMMA 37
#define TOK_MAX 38
#define TOK_SUM 39
#define TOK_AVERAGE 40
#define TOK_EXP 41
#define TOK_LOG 42
#define TOK_LOG10 43
#define TOK_SQR 44
#define TOK_SQRT 45
#define TOK_CBRT 46
#define TOK_SIN 47
#define TOK_COS 48
#define TOK_TAN 49
#define TOK_ASIN 50
#define TOK_ACOS 51
#define TOK_ATAN 52
#define TOK_SINH 53
#define TOK_COSH 54
#define TOK_TANH 55
#define TOK_POW 56
#define TOK_ATAN2 57
#define TOK_POS 58
#define TOK_NEG 59
#define TOK_POS0 60
#define TOK_NEG0 61
#define TOK_SIGN 62
#define TOK_FLOOR 63
#define TOK_CEIL 64
#define TOK_ROUND 65
#define TOK_HYPOT 66
#define TOK_RAND 67
#define TOK_VECTOR_ID 68
#define TOK_SVECTOR_ID 69
#define TOK_SPH_TENSOR_ID 70
#define TOK_SSPH_TENSOR_ID 71
#define TOK_SYM_TENSOR_ID 72
#define TOK_SSYM_TENSOR_ID 73
#define TOK_IDENTITY_TENSOR 74
#define TOK_TENSOR_ID 75
#define TOK_STENSOR_ID 76
#define TOK_LTRUE 77
#define TOK_LFALSE 78
#define TOK_BOOL 79
#define TOK_SBOOL_ID 80
#define TOK_FACE_AREA 81
#define TOK_FACE_EXPR 82
#define TOK_WEIGHT_AVERAGE 83
#define TOK_WEIGHT_SUM 84
#define TOK_POINT_EXPR 85
#define TOK_PSCALAR_ID 86
#define TOK_PVECTOR_ID 87
#define TOK_PSPH_TENSOR_ID 88
#define TOK_PSYM_TENSOR_ID 89
#define TOK_PTENSOR_ID 90
#define TOK_PBOOL_ID 91
#define TOK_POINTS 92
#define TOK_MAG 93
#define TOK_MAGSQR 94
#define TOK_VECTOR 95
#define TOK_TENSOR 96
#define TOK_SYM_TENSOR 97
#define TOK_SPH_TENSOR 98
#define TOK_CMPT_X 99
#define TOK_CMPT_Y 100
#define TOK_CMPT_Z 101
#define TOK_CMPT_XX 102
#define TOK_CMPT_XY 103
#define TOK_CMPT_XZ 104
#define TOK_CMPT_YX 105
#define TOK_CMPT_YY 106
#define TOK_CMPT_YZ 107
#define TOK_CMPT_ZX 108
#define TOK_CMPT_ZY 109
#define TOK_CMPT_ZZ 110
#define TOK_CMPT_II 111
#define TOK_TRANSPOSE 112
#define TOK_DIAG 113
#define TOK_POINT_TO_FACE 114
#define TOK_FACE_TO_POINT 115
#define TOK_LPAREN 1
#define TOK_RPAREN 2
#define TOK_COMMA 3
#define TOK_QUESTION 4
#define TOK_COLON 5
#define TOK_LOR 6
#define TOK_LAND 7
#define TOK_LNOT 8
#define TOK_BIT_OR 9
#define TOK_BIT_XOR 10
#define TOK_BIT_AND 11
#define TOK_BIT_NOT 12
#define TOK_EQUAL 13
#define TOK_NOT_EQUAL 14
#define TOK_LESS 15
#define TOK_LESS_EQ 16
#define TOK_GREATER 17
#define TOK_GREATER_EQ 18
#define TOK_PLUS 19
#define TOK_MINUS 20
#define TOK_TIMES 21
#define TOK_DIVIDE 22
#define TOK_PERCENT 23
#define TOK_NEGATE 24
#define TOK_DOT 25
#define TOK_BOOL 26
#define TOK_LTRUE 27
#define TOK_LFALSE 28
#define TOK_NUMBER 29
#define TOK_ZERO 30
#define TOK_IDENTIFIER 31
#define TOK_PI 32
#define TOK_DEG_TO_RAD 33
#define TOK_RAD_TO_DEG 34
#define TOK_ARG 35
#define TOK_TIME 36
#define TOK_DELTA_T 37
#define TOK_SCALAR_FUNCTION_ID 38
#define TOK_VECTOR_VALUE 39
#define TOK_VECTOR_FUNCTION_ID 40
#define TOK_SCALAR_ID 41
#define TOK_SSCALAR_ID 42
#define TOK_INTERNAL_FIELD 43
#define TOK_NEIGHBOUR_FIELD 44
#define TOK_SN_GRAD 45
#define TOK_MIN 46
#define TOK_MAX 47
#define TOK_SUM 48
#define TOK_AVERAGE 49
#define TOK_EXP 50
#define TOK_LOG 51
#define TOK_LOG10 52
#define TOK_SQR 53
#define TOK_SQRT 54
#define TOK_CBRT 55
#define TOK_SIN 56
#define TOK_COS 57
#define TOK_TAN 58
#define TOK_ASIN 59
#define TOK_ACOS 60
#define TOK_ATAN 61
#define TOK_SINH 62
#define TOK_COSH 63
#define TOK_TANH 64
#define TOK_POW 65
#define TOK_ATAN2 66
#define TOK_POS 67
#define TOK_NEG 68
#define TOK_POS0 69
#define TOK_NEG0 70
#define TOK_SIGN 71
#define TOK_FLOOR 72
#define TOK_CEIL 73
#define TOK_ROUND 74
#define TOK_HYPOT 75
#define TOK_RAND 76
#define TOK_VECTOR_ID 77
#define TOK_SVECTOR_ID 78
#define TOK_SPH_TENSOR_ID 79
#define TOK_SSPH_TENSOR_ID 80
#define TOK_SYM_TENSOR_ID 81
#define TOK_SSYM_TENSOR_ID 82
#define TOK_IDENTITY_TENSOR 83
#define TOK_TENSOR_ID 84
#define TOK_STENSOR_ID 85
#define TOK_SBOOL_ID 86
#define TOK_CELL_SET 87
#define TOK_CELL_ZONE 88
#define TOK_FACE_SET 89
#define TOK_FACE_ZONE 90
#define TOK_FACE_AREA 91
#define TOK_FACE_EXPR 92
#define TOK_WEIGHT_AVERAGE 93
#define TOK_WEIGHT_SUM 94
#define TOK_POINT_EXPR 95
#define TOK_PSCALAR_ID 96
#define TOK_PVECTOR_ID 97
#define TOK_PSPH_TENSOR_ID 98
#define TOK_PSYM_TENSOR_ID 99
#define TOK_PTENSOR_ID 100
#define TOK_PBOOL_ID 101
#define TOK_POINTS 102
#define TOK_MAG 103
#define TOK_MAGSQR 104
#define TOK_VECTOR 105
#define TOK_TENSOR 106
#define TOK_SYM_TENSOR 107
#define TOK_SPH_TENSOR 108
#define TOK_CMPT_X 109
#define TOK_CMPT_Y 110
#define TOK_CMPT_Z 111
#define TOK_CMPT_XX 112
#define TOK_CMPT_XY 113
#define TOK_CMPT_XZ 114
#define TOK_CMPT_YX 115
#define TOK_CMPT_YY 116
#define TOK_CMPT_YZ 117
#define TOK_CMPT_ZX 118
#define TOK_CMPT_ZY 119
#define TOK_CMPT_ZZ 120
#define TOK_CMPT_II 121
#define TOK_TRANSPOSE 122
#define TOK_DIAG 123
#define TOK_POINT_TO_FACE 124
#define TOK_FACE_TO_POINT 125

128
src/finiteVolume/expressions/patch/patchExprLemonParser.lyy-m4
View File

@ -42,6 +42,7 @@ Description
*/
%include
{
#include "exprScanToken.H"
#include "patchExprDriver.H"
#include "patchExprParser.H"
#include "patchExprScanner.H"
@ -77,11 +78,8 @@ tmp_management()
%token_prefix TOK_
// Terminals
%token_type {Foam::expressions::patchExpr::scanToken*}
// Non-terminals
%type ivalue { Foam::label }
%type svalue { Foam::scalar }
%type ident { Foam::word* }
%token_type {Foam::expressions::scanToken}
%token_destructor { ($$).destroy(); }
// Face fields
declare_field(lfield, Foam::boolField, bool, newField, getSurfaceField)
@ -104,17 +102,33 @@ declare_field(ptfield, Foam::tensorField, Foam::tensor, newPointField, getPointF
// Lemon does not generate a destructor for that.
// So do not use Lemon destructors for anything.
standard_tokens()
operator_precedence()
%start_symbol evaluate
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
/*---------------------------------------------------------------------------*\
* General Productions
\*---------------------------------------------------------------------------*/
%type identifier { Foam::word* }
%destructor identifier { delete($$); $$ = nullptr; }
identifier (lhs) ::= IDENTIFIER (tok) .
{
// Take ownership of pointer from scan token
lhs = tok.name_; tok.name_ = nullptr;
}
/*---------------------------------------------------------------------------*\
* Productions (scalar)
\*---------------------------------------------------------------------------*/
svalue (lhs) ::= NUMBER (a) . { lhs = (a)->svalue; } // From scanToken
%type svalue { Foam::scalar }
svalue (lhs) ::= NUMBER (tok) . { lhs = (tok).scalarValue; } // scanToken
svalue (lhs) ::= ZERO . { lhs = Foam::Zero; }
svalue (lhs) ::= PI LPAREN RPAREN . { lhs = Foam::constant::mathematical::pi; }
svalue (lhs) ::= DEG_TO_RAD LPAREN RPAREN . { lhs = Foam::degToRad(); }
@ -123,6 +137,31 @@ svalue (lhs) ::= ARG LPAREN RPAREN . { lhs = driver->argValue(); }
svalue (lhs) ::= TIME LPAREN RPAREN . { lhs = driver->timeValue(); }
svalue (lhs) ::= DELTA_T LPAREN RPAREN . { lhs = driver->deltaT(); }
svalue (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN RPAREN .
{
driver->reportFatal("Not implemented: " + make_obj(name.name_));
lhs = 0;
}
/*---------------------------------------------------------------------------*\
* Productions (vector)
\*---------------------------------------------------------------------------*/
%type vvalue { Foam::vector* }
%destructor vvalue { delete($$); $$ = nullptr; }
vvalue (lhs) ::= VECTOR_VALUE (tok) .
{
// Take ownership of pointer from scan token
lhs = tok.vectorPtr; tok.vectorPtr = nullptr;
}
vvalue (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN RPAREN .
{
driver->reportFatal("Not implemented: " + make_obj(name.name_));
lhs = new Foam::vector(0,0,0);
}
/* * * * * * * * * * * * * * * * * Face Fields * * * * * * * * * * * * * * * *\
dnl
@ -138,7 +177,9 @@ dnl
/*---------------------------------------------------------------------------*\
* Productions (scalarField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [sfield])dnl
define([_new_target_], [_new_sfield])dnl
define([_value_type_], [Foam::scalar])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -156,9 +197,9 @@ rules_scalar_operations()
rules_scalar_functions()
// Non-standard but manage via FieldOps::assign
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<_value_type_>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<_value_type_>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<_value_type_>())
// Non-standard but works directly for scalarField
rule_binary_func(_target_, _target_, _target_, HYPOT, Foam::hypot)
@ -174,20 +215,30 @@ _target_ (lhs) ::= RAND LPAREN RPAREN.
_target_ (lhs) ::= RAND LPAREN NUMBER (seed) RPAREN.
{
// Call with -ve seed to signal use of time index as seed
lhs = driver->field_rand(std::round(-(seed)->svalue)).ptr();
lhs = driver->field_rand(std::round(-(seed).scalarValue)).ptr();
}
_target_ (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (vectorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [vfield])dnl
define([_new_target_], [_new_vfield])dnl
define([_value_type_], [Foam::vector])dnl
dnl
\*---------------------------------------------------------------------------*/
evaluate ::= _target_ (a) . { driver->setResult(a); }
rule_field_from_value(_target_, vvalue)
rule_get_field(_target_, VECTOR_ID)
rule_get_field(_target_, SVECTOR_ID)
rule_get_patchfields(_target_, _value_type_, VECTOR_ID)
@ -197,11 +248,22 @@ rules_inplace_gUnary(_target_)
rules_vector_operations()
rules_vector_functions()
// Other functions
_target_ (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (sphericalTensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [hfield])dnl
define([_new_target_], [_new_hfield])dnl
define([_value_type_], [Foam::sphericalTensor])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -221,7 +283,9 @@ rules_sphTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (symmTensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [yfield])dnl
define([_new_target_], [_new_yfield])dnl
define([_value_type_], [Foam::symmTensor])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -241,7 +305,9 @@ rules_symTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (tensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [tfield])dnl
define([_new_target_], [_new_tfield])dnl
define([_value_type_], [Foam::tensor])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -303,7 +369,9 @@ dnl
/*---------------------------------------------------------------------------*\
* Productions (point scalarField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [psfield])dnl
define([_new_target_], [_new_psfield])dnl
define([_value_type_], [Foam::scalar])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -319,24 +387,34 @@ rules_scalar_operations()
rules_scalar_functions()
// Non-standard but manage via FieldOps::assign
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<_value_type_>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<_value_type_>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<_value_type_>())
// Non-standard but works directly for scalarField
rule_binary_func(_target_, _target_, _target_, HYPOT, Foam::hypot)
_target_ (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (point vectorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [pvfield])dnl
define([_new_target_], [_new_pvfield])dnl
define([_value_type_], [Foam::vector])dnl
dnl
\*---------------------------------------------------------------------------*/
evaluate ::= _target_ (a) . { driver->setResult(a, true); /* Point */ }
rule_field_from_value(_target_, vvalue, POINT_EXPR)
rule_get_field(_target_, PVECTOR_ID)
rules_standard(_target_, _value_type_, _logic_)
@ -344,10 +422,18 @@ rules_inplace_gUnary(_target_)
rules_vector_operations()
rules_vector_functions()
_target_ (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (point sphericalTensorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [phfield])dnl
define([_value_type_], [Foam::sphericalTensor])dnl
dnl
@ -366,6 +452,7 @@ rules_sphTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (point symmTensorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [pyfield])dnl
define([_value_type_], [Foam::symmTensor])dnl
dnl
@ -384,6 +471,7 @@ rules_symTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (point tensorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [ptfield])dnl
define([_value_type_], [Foam::tensor])dnl
dnl
@ -544,13 +632,15 @@ void Foam::expressions::patchExpr::parser::start(parseDriver& driver_)
}
void Foam::expressions::patchExpr::parser::parse
(
int tokenId,
scanToken* tokenVal
)
void Foam::expressions::patchExpr::parser::parse(int tokenId)
{
Parse(lemon_, tokenId, tokenVal);
Parse(lemon_, tokenId, scanToken::null());
}
void Foam::expressions::patchExpr::parser::parse(int tokenId, scanToken tok)
{
Parse(lemon_, tokenId, tok);
}

21
src/finiteVolume/expressions/patch/patchExprLemonParserMacros.m4
View File

@ -59,6 +59,27 @@ rule_driver_unary_named($1, SN_GRAD, $3, patchNormalField, $2)dnl
define([rules_driver_surface_functions],
[dnl
_logic_ (lhs) ::= CELL_SET LPAREN identifier (name) RPAREN .dnl
{dnl
driver->reportFatal("Not implemented: " + make_obj(name));
lhs = nullptr;dnl
}dnl
_logic_ (lhs) ::= CELL_ZONE LPAREN identifier (name) RPAREN .dnl
{dnl
driver->reportFatal("Not implemented: " + make_obj(name));
lhs = nullptr;dnl
}dnl
_logic_ (lhs) ::= FACE_SET LPAREN identifier (name) RPAREN .dnl
{dnl
driver->reportFatal("Not implemented: " + make_obj(name));
lhs = nullptr;dnl
}dnl
_logic_ (lhs) ::= FACE_ZONE LPAREN identifier (name) RPAREN .dnl
{dnl
driver->reportFatal("Not implemented: " + make_obj(name));
lhs = nullptr;dnl
}dnl
dnl
rule_driver_nullary(_scalar_, FACE_AREA, field_faceArea)dnl
rule_driver_nullary(_vector_, POS, field_faceCentre)dnl FACE_CENTRE
rule_driver_nullary(_vector_, FACE_EXPR, field_areaNormal)dnl

10
src/finiteVolume/expressions/patch/patchExprParser.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -34,6 +34,7 @@ Description
#ifndef expressions_patchExprParser_H
#define expressions_patchExprParser_H
#include "exprScanToken.H"
#include "patchExprFwd.H"
namespace Foam
@ -97,8 +98,11 @@ public:
//- Stop parsing, freeing the allocated parser
void stop();
//- Push token/value to parser
void parse(int tokenId, scanToken* tokenVal);
//- Push token type to parser with default token
void parse(int tokenId);
//- Push token type/value to parser
void parse(int tokenId, scanToken tok);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

25
src/finiteVolume/expressions/patch/patchExprScanner.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -37,8 +37,8 @@ Note
#ifndef expressions_patchExprScanner_H
#define expressions_patchExprScanner_H
#include "exprScanToken.H"
#include "patchExprFwd.H"
#include "scalar.H"
namespace Foam
{
@ -47,21 +47,6 @@ namespace expressions
namespace patchExpr
{
/*---------------------------------------------------------------------------*\
Class scanToken Declaration
\*---------------------------------------------------------------------------*/
union scanToken
{
Foam::label ivalue;
Foam::scalar svalue;
Foam::word* name;
//- Default construct, bit-wise zero for union content
scanToken() : ivalue(0) {}
};
/*---------------------------------------------------------------------------*\
Class scanner Declaration
\*---------------------------------------------------------------------------*/
@ -83,16 +68,14 @@ class scanner
bool dispatch_method
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident // Receives a copy
) const;
//- Dispatch identifier to parser (if possible) or Fatal
bool dispatch_ident
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident // Receives a copy
) const;

3902
src/finiteVolume/expressions/patch/patchExprScanner.cc
View File

File diff suppressed because it is too large Load Diff

154
src/finiteVolume/expressions/patch/patchExprScanner.rl
View File

@ -28,6 +28,7 @@ Description
\*---------------------------------------------------------------------------*/
#include "exprScanToken.H"
#include "patchExprScanner.H"
#include "patchExprDriver.H"
#include "patchExprLemonParser.h"
@ -42,7 +43,6 @@ Description
#undef DebugInfo
#define DebugInfo if (debug & 0x2) InfoErr
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
@ -58,6 +58,18 @@ namespace Foam
#define FIELD_PAIR(Fld,T) { TOKEN_OF(T), Fld::typeName.c_str() }
#undef HAS_LOOKBEHIND_TOKENS
#ifdef HAS_LOOKBEHIND_TOKENS
// Special handling for these known (stashed) look-back types
static const Enum<int> lookBehindTokenEnums
({
TOKEN_PAIR("cellZone", CELL_ZONE), TOKEN_PAIR("cellSet", CELL_SET),
TOKEN_PAIR("faceZone", FACE_ZONE), TOKEN_PAIR("faceSet", FACE_SET),
#ifdef TOK_POINT_ZONE
TOKEN_PAIR("pointZone", POINT_ZONE), TOKEN_PAIR("pointSet", POINT_SET),
#endif
});
#endif
// Special handling of predefined method types. Eg, .x(), .y(), ...
static const Enum<int> fieldMethodEnums
@ -176,7 +188,7 @@ static int driverTokenType
const word& ident
)
{
#if 0
#if 0
// Get stashed "look-behind" to decide what type of identifier we expect
const int lookBehind = driver_.resetStashedTokenId();
@ -186,12 +198,17 @@ static int driverTokenType
switch (lookBehind)
{
case TOK_CELL_SET : good = driver_.isCellSet(ident); break;
case TOK_FACE_SET : good = driver_.isFaceSet(ident); break;
case TOK_POINT_SET : good = driver_.isPointSet(ident); break;
case TOK_CELL_ZONE : good = driver_.isCellZone(ident); break;
case TOK_CELL_SET : good = driver_.isCellSet(ident); break;
case TOK_FACE_ZONE : good = driver_.isFaceZone(ident); break;
case TOK_FACE_SET : good = driver_.isFaceSet(ident); break;
#ifdef TOK_POINT_ZONE
// Not yet ready or particularly useful it seems
case TOK_POINT_ZONE : good = driver_.isPointZone(ident); break;
case TOK_POINT_SET : good = driver_.isPointSet(ident); break;
#endif
}
if (good)
@ -207,51 +224,49 @@ static int driverTokenType
return -2; // Extra safety
}
#endif
#endif
// Face variables
#ifdef TOK_SSCALAR_ID
{
#undef checkFieldToken
#define checkFieldToken(TokType, Type) \
#undef doLocalCode
#define doLocalCode(TokType, Type) \
if (driver_.isVariable<Type>(ident, false)) \
{ \
return TokType; \
}
checkFieldToken(TOK_SSCALAR_ID, scalar);
checkFieldToken(TOK_SVECTOR_ID, vector);
checkFieldToken(TOK_SSYM_TENSOR_ID, symmTensor);
checkFieldToken(TOK_SSPH_TENSOR_ID, sphericalTensor);
checkFieldToken(TOK_STENSOR_ID, tensor);
// Not tested: checkFieldToken(TOK_SBOOL_ID, bool);
doLocalCode(TOK_SSCALAR_ID, scalar);
doLocalCode(TOK_SVECTOR_ID, vector);
doLocalCode(TOK_SSYM_TENSOR_ID, symmTensor);
doLocalCode(TOK_SSPH_TENSOR_ID, sphericalTensor);
doLocalCode(TOK_STENSOR_ID, tensor);
// Untested: doLocalCode(TOK_SBOOL_ID, bool);
#undef doLocalCode
}
#endif
// Point variables
#ifdef TOK_PSCALAR_ID
{
#undef checkFieldToken
#define checkFieldToken(TokType, Type) \
#undef doLocalCode
#define doLocalCode(TokType, Type) \
if (driver_.isVariable<Type>(ident, true)) \
{ \
return TokType; \
}
checkFieldToken(TOK_PSCALAR_ID, scalar);
checkFieldToken(TOK_PVECTOR_ID, vector);
checkFieldToken(TOK_PTENSOR_ID, tensor);
checkFieldToken(TOK_PTENSOR_ID, tensor);
checkFieldToken(TOK_PSYM_TENSOR_ID, symmTensor);
checkFieldToken(TOK_PSPH_TENSOR_ID, sphericalTensor);
// Not tested: checkFieldToken(TOK_PBOOL_ID, bool);
doLocalCode(TOK_PSCALAR_ID, scalar);
doLocalCode(TOK_PVECTOR_ID, vector);
doLocalCode(TOK_PTENSOR_ID, tensor);
doLocalCode(TOK_PTENSOR_ID, tensor);
doLocalCode(TOK_PSYM_TENSOR_ID, symmTensor);
doLocalCode(TOK_PSPH_TENSOR_ID, sphericalTensor);
// Untested: doLocalCode(TOK_SBOOL_ID, bool);
#undef doLocalCode
}
#endif
#undef checkFieldToken
// Check registered fields and/or disk-files
{
const word fieldType(driver_.getFieldClassName(ident));
@ -267,7 +282,7 @@ static int driverTokenType
return -1;
}
} // End anonymous namespace
} // End namespace Foam
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@ -280,7 +295,15 @@ static int driverTokenType
#define EMIT_TOKEN(T) \
driver_.parsePosition() = (ts-buf); \
DebugInfo<< STRINGIFY(T) << " at " << driver_.parsePosition() << nl; \
parser_->parse(TOKEN_OF(T), nullptr); \
parser_->parse(TOKEN_OF(T)); \
driver_.parsePosition() = (p-buf);
#define EMIT_VECTOR_TOKEN(X, Y, Z) \
driver_.parsePosition() = (ts-buf); \
DebugInfo<< "VECTOR at " << driver_.parsePosition() << nl; \
scanToken scanTok; \
scanTok.setVector(X,Y,Z); \
parser_->parse(TOK_VECTOR_VALUE, scanTok); \
driver_.parsePosition() = (p-buf);
@ -289,15 +312,18 @@ static int driverTokenType
write data;
action emit_number {
// Emit number
driver_.parsePosition() = (ts-buf);
DebugInfo
<< "Number:" << std::string(ts, te-ts).c_str()
<< " at " << driver_.parsePosition() << nl;
if (readScalar(std::string(ts, te-ts), scanTok.svalue))
scanToken scanTok;
scanTok.setScalar(0);
if (readScalar(std::string(ts, te-ts), scanTok.scalarValue))
{
parser_->parse(TOKEN_OF(NUMBER), &scanTok);
parser_->parse(TOKEN_OF(NUMBER), scanTok);
}
else
{
@ -311,15 +337,16 @@ static int driverTokenType
}
action emit_ident {
// Emit identifier
driver_.parsePosition() = (ts-buf);
dispatch_ident(driver_, scanTok, word(ts, te-ts, false));
dispatch_ident(driver_, word(ts, te-ts, false));
driver_.parsePosition() = (p-buf);
}
action emit_method {
// Tokenized ".method" - dispatch '.' and "method" separately
driver_.parsePosition() = (ts-buf);
dispatch_method(driver_, scanTok, word(ts+1, te-ts-1, false));
dispatch_method(driver_, word(ts+1, te-ts-1, false));
driver_.parsePosition() = (p-buf);
}
@ -337,7 +364,7 @@ static int driverTokenType
number => emit_number;
## Operators
'!' =>{ EMIT_TOKEN(NOT); };
'!' =>{ EMIT_TOKEN(LNOT); };
'%' =>{ EMIT_TOKEN(PERCENT); };
'(' =>{ EMIT_TOKEN(LPAREN); };
')' =>{ EMIT_TOKEN(RPAREN); };
@ -358,7 +385,7 @@ static int driverTokenType
'&&' =>{ EMIT_TOKEN(LAND); };
'||' =>{ EMIT_TOKEN(LOR); };
'&' =>{ EMIT_TOKEN(BIT_AND); };
## Not needed? '|' =>{ EMIT_TOKEN(BIT_OK); };
## Not needed? '|' =>{ EMIT_TOKEN(BIT_OR); };
'^' =>{ EMIT_TOKEN(BIT_XOR); };
## Some '.method' - Error if unknown
@ -417,9 +444,12 @@ static int driverTokenType
"sphericalTensor" =>{ EMIT_TOKEN(SPH_TENSOR); };
## Single value (constants, etc)
"Zero" =>{ EMIT_TOKEN(ZERO); };
"true" =>{ EMIT_TOKEN(LTRUE); };
"false" =>{ EMIT_TOKEN(LFALSE); };
"Zero" =>{ EMIT_TOKEN(ZERO); };
"vector::x" =>{ EMIT_VECTOR_TOKEN(1,0,0); };
"vector::y" =>{ EMIT_VECTOR_TOKEN(0,1,0); };
"vector::z" =>{ EMIT_VECTOR_TOKEN(0,0,1); };
"tensor::I" =>{ EMIT_TOKEN(IDENTITY_TENSOR); };
"arg" =>{ EMIT_TOKEN(ARG); };
"time" =>{ EMIT_TOKEN(TIME); };
@ -452,8 +482,7 @@ Foam::expressions::patchExpr::scanner::~scanner()
bool Foam::expressions::patchExpr::scanner::dispatch_method
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident
) const
{
if (ident[0] == '.')
@ -470,8 +499,8 @@ bool Foam::expressions::patchExpr::scanner::dispatch_method
if (methType > 0)
{
// Dispatch '.' and "method" separately
parser_->parse(TOK_DOT, nullptr);
parser_->parse(methType, nullptr);
parser_->parse(TOK_DOT);
parser_->parse(methType);
return true;
}
@ -484,10 +513,11 @@ bool Foam::expressions::patchExpr::scanner::dispatch_method
bool Foam::expressions::patchExpr::scanner::dispatch_ident
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident
) const
{
// Peek at stashed "look-behind". It may influence decisions
int lookBehindTok = driver_.stashedTokenId();
int tokType = -1;
const bool quoted =
@ -512,12 +542,12 @@ bool Foam::expressions::patchExpr::scanner::dispatch_ident
<< "Emit:" << ident << " function:"
<< parser_->tokenName(tokType) << nl;
parser_->parse(tokType, nullptr);
parser_->parse(tokType);
return true;
}
#ifdef HAS_LOOKBEHIND_TOKENS
// Specials such "cset" also reset the look-behind
// Specials such "cellSet" etc also reset the look-behind
tokType = lookBehindTokenEnums.lookup(ident, -1);
if (tokType > 0)
@ -527,17 +557,28 @@ bool Foam::expressions::patchExpr::scanner::dispatch_ident
<< parser_->tokenName(tokType) << nl;
driver_.resetStashedTokenId(tokType);
parser_->parse(tokType, nullptr);
parser_->parse(tokType);
return true;
}
#endif
}
// Functions: scalar, vector, probably don't need others
// - "fn:" prefix to avoid any ambiguities
if (lookBehindTok <= 0 && ident.starts_with("fn:"))
{
word funcName(ident.substr(3)); // strip prefix
// Can also peek at stashed "look-behind"
// const int lookBehind = driver_.stashedTokenId();
do
{
}
while (false);
}
if (tokType <= 0)
{
tokType = driverTokenType(driver_, ident);
}
if (tokType > 0)
{
@ -545,8 +586,9 @@ bool Foam::expressions::patchExpr::scanner::dispatch_ident
<< "Emit:" << ident << " token:"
<< parser_->tokenName(tokType) << nl;
scanTok.name = new Foam::word(std::move(ident));
parser_->parse(tokType, &scanTok);
scanToken scanTok;
scanTok.setWord(ident);
parser_->parse(tokType, scanTok);
return true;
}
@ -578,12 +620,13 @@ bool Foam::expressions::patchExpr::scanner::dispatch_ident
// The field (before the ".")
ident.erase(dot);
scanTok.name = new Foam::word(std::move(ident));
parser_->parse(tokType, &scanTok);
scanToken scanTok;
scanTok.setWord(ident);
parser_->parse(tokType, scanTok);
// Dispatch '.' and "method" separately
parser_->parse(TOK_DOT, nullptr);
parser_->parse(methType, nullptr);
parser_->parse(TOK_DOT);
parser_->parse(methType);
return true;
}
@ -646,9 +689,6 @@ bool Foam::expressions::patchExpr::scanner::process
parser_->start(driver_);
// Scan token type
scanToken scanTok;
// Token start/end (Ragel naming)
const char* ts;
const char* te;
@ -678,7 +718,7 @@ bool Foam::expressions::patchExpr::scanner::process
}
// Terminate parser execution
parser_->parse(0, nullptr);
parser_->parse(0);
parser_->stop();
if (debug & 0x6)

1
src/finiteVolume/expressions/volume/volumeExprFwd.H
View File

@ -47,7 +47,6 @@ namespace volumeExpr
class parser;
class scanner;
class parseDriver;
union scanToken;
//- Static debugging option
extern int debug;

247
src/finiteVolume/expressions/volume/volumeExprLemonParser.h
View File

@ -1,121 +1,126 @@
#define TOK_QUESTION 1
#define TOK_COLON 2
#define TOK_LOR 3
#define TOK_LAND 4
#define TOK_BIT_XOR 5
#define TOK_BIT_AND 6
#define TOK_EQUAL 7
#define TOK_NOT_EQUAL 8
#define TOK_LESS_EQ 9
#define TOK_GREATER_EQ 10
#define TOK_LESS 11
#define TOK_GREATER 12
#define TOK_PLUS 13
#define TOK_MINUS 14
#define TOK_TIMES 15
#define TOK_DIVIDE 16
#define TOK_PERCENT 17
#define TOK_NEGATE 18
#define TOK_NOT 19
#define TOK_DOT 20
#define TOK_NUMBER 21
#define TOK_ZERO 22
#define TOK_PI 23
#define TOK_LPAREN 24
#define TOK_RPAREN 25
#define TOK_DEG_TO_RAD 26
#define TOK_RAD_TO_DEG 27
#define TOK_ARG 28
#define TOK_TIME 29
#define TOK_DELTA_T 30
#define TOK_SCALAR_ID 31
#define TOK_MIN 32
#define TOK_COMMA 33
#define TOK_MAX 34
#define TOK_SUM 35
#define TOK_AVERAGE 36
#define TOK_EXP 37
#define TOK_LOG 38
#define TOK_LOG10 39
#define TOK_SQR 40
#define TOK_SQRT 41
#define TOK_CBRT 42
#define TOK_SIN 43
#define TOK_COS 44
#define TOK_TAN 45
#define TOK_ASIN 46
#define TOK_ACOS 47
#define TOK_ATAN 48
#define TOK_SINH 49
#define TOK_COSH 50
#define TOK_TANH 51
#define TOK_POW 52
#define TOK_ATAN2 53
#define TOK_POS 54
#define TOK_NEG 55
#define TOK_POS0 56
#define TOK_NEG0 57
#define TOK_SIGN 58
#define TOK_FLOOR 59
#define TOK_CEIL 60
#define TOK_ROUND 61
#define TOK_HYPOT 62
#define TOK_RAND 63
#define TOK_VECTOR_ID 64
#define TOK_SPH_TENSOR_ID 65
#define TOK_SYM_TENSOR_ID 66
#define TOK_IDENTITY_TENSOR 67
#define TOK_TENSOR_ID 68
#define TOK_LTRUE 69
#define TOK_LFALSE 70
#define TOK_BOOL 71
#define TOK_CELL_SET 72
#define TOK_IDENTIFIER 73
#define TOK_CELL_ZONE 74
#define TOK_CELL_VOLUME 75
#define TOK_WEIGHT_AVERAGE 76
#define TOK_WEIGHT_SUM 77
#define TOK_FACE_EXPR 78
#define TOK_SSCALAR_ID 79
#define TOK_SVECTOR_ID 80
#define TOK_SSPH_TENSOR_ID 81
#define TOK_SSYM_TENSOR_ID 82
#define TOK_STENSOR_ID 83
#define TOK_FACE_SET 84
#define TOK_FACE_ZONE 85
#define TOK_FACE_AREA 86
#define TOK_FACE_CENTRE 87
#define TOK_POINT_EXPR 88
#define TOK_PSCALAR_ID 89
#define TOK_PVECTOR_ID 90
#define TOK_PSPH_TENSOR_ID 91
#define TOK_PSYM_TENSOR_ID 92
#define TOK_PTENSOR_ID 93
#define TOK_POINT_SET 94
#define TOK_POINT_ZONE 95
#define TOK_POINTS 96
#define TOK_MAG 97
#define TOK_MAGSQR 98
#define TOK_VECTOR 99
#define TOK_TENSOR 100
#define TOK_SYM_TENSOR 101
#define TOK_SPH_TENSOR 102
#define TOK_CMPT_X 103
#define TOK_CMPT_Y 104
#define TOK_CMPT_Z 105
#define TOK_CMPT_XX 106
#define TOK_CMPT_XY 107
#define TOK_CMPT_XZ 108
#define TOK_CMPT_YX 109
#define TOK_CMPT_YY 110
#define TOK_CMPT_YZ 111
#define TOK_CMPT_ZX 112
#define TOK_CMPT_ZY 113
#define TOK_CMPT_ZZ 114
#define TOK_CMPT_II 115
#define TOK_TRANSPOSE 116
#define TOK_DIAG 117
#define TOK_POINT_TO_CELL 118
#define TOK_RECONSTRUCT 119
#define TOK_CELL_TO_FACE 120
#define TOK_CELL_TO_POINT 121
#define TOK_LPAREN 1
#define TOK_RPAREN 2
#define TOK_COMMA 3
#define TOK_QUESTION 4
#define TOK_COLON 5
#define TOK_LOR 6
#define TOK_LAND 7
#define TOK_LNOT 8
#define TOK_BIT_OR 9
#define TOK_BIT_XOR 10
#define TOK_BIT_AND 11
#define TOK_BIT_NOT 12
#define TOK_EQUAL 13
#define TOK_NOT_EQUAL 14
#define TOK_LESS 15
#define TOK_LESS_EQ 16
#define TOK_GREATER 17
#define TOK_GREATER_EQ 18
#define TOK_PLUS 19
#define TOK_MINUS 20
#define TOK_TIMES 21
#define TOK_DIVIDE 22
#define TOK_PERCENT 23
#define TOK_NEGATE 24
#define TOK_DOT 25
#define TOK_BOOL 26
#define TOK_LTRUE 27
#define TOK_LFALSE 28
#define TOK_NUMBER 29
#define TOK_ZERO 30
#define TOK_IDENTIFIER 31
#define TOK_PI 32
#define TOK_DEG_TO_RAD 33
#define TOK_RAD_TO_DEG 34
#define TOK_ARG 35
#define TOK_TIME 36
#define TOK_DELTA_T 37
#define TOK_SCALAR_FUNCTION_ID 38
#define TOK_VECTOR_VALUE 39
#define TOK_VECTOR_FUNCTION_ID 40
#define TOK_SCALAR_ID 41
#define TOK_MIN 42
#define TOK_MAX 43
#define TOK_SUM 44
#define TOK_AVERAGE 45
#define TOK_EXP 46
#define TOK_LOG 47
#define TOK_LOG10 48
#define TOK_SQR 49
#define TOK_SQRT 50
#define TOK_CBRT 51
#define TOK_SIN 52
#define TOK_COS 53
#define TOK_TAN 54
#define TOK_ASIN 55
#define TOK_ACOS 56
#define TOK_ATAN 57
#define TOK_SINH 58
#define TOK_COSH 59
#define TOK_TANH 60
#define TOK_POW 61
#define TOK_ATAN2 62
#define TOK_POS 63
#define TOK_NEG 64
#define TOK_POS0 65
#define TOK_NEG0 66
#define TOK_SIGN 67
#define TOK_FLOOR 68
#define TOK_CEIL 69
#define TOK_ROUND 70
#define TOK_HYPOT 71
#define TOK_RAND 72
#define TOK_VECTOR_ID 73
#define TOK_SPH_TENSOR_ID 74
#define TOK_SYM_TENSOR_ID 75
#define TOK_IDENTITY_TENSOR 76
#define TOK_TENSOR_ID 77
#define TOK_CELL_SET 78
#define TOK_CELL_ZONE 79
#define TOK_CELL_VOLUME 80
#define TOK_WEIGHT_AVERAGE 81
#define TOK_WEIGHT_SUM 82
#define TOK_FACE_EXPR 83
#define TOK_SSCALAR_ID 84
#define TOK_SVECTOR_ID 85
#define TOK_SSPH_TENSOR_ID 86
#define TOK_SSYM_TENSOR_ID 87
#define TOK_STENSOR_ID 88
#define TOK_FACE_SET 89
#define TOK_FACE_ZONE 90
#define TOK_FACE_AREA 91
#define TOK_FACE_CENTRE 92
#define TOK_POINT_EXPR 93
#define TOK_PSCALAR_ID 94
#define TOK_PVECTOR_ID 95
#define TOK_PSPH_TENSOR_ID 96
#define TOK_PSYM_TENSOR_ID 97
#define TOK_PTENSOR_ID 98
#define TOK_POINT_SET 99
#define TOK_POINT_ZONE 100
#define TOK_POINTS 101
#define TOK_MAG 102
#define TOK_MAGSQR 103
#define TOK_VECTOR 104
#define TOK_TENSOR 105
#define TOK_SYM_TENSOR 106
#define TOK_SPH_TENSOR 107
#define TOK_CMPT_X 108
#define TOK_CMPT_Y 109
#define TOK_CMPT_Z 110
#define TOK_CMPT_XX 111
#define TOK_CMPT_XY 112
#define TOK_CMPT_XZ 113
#define TOK_CMPT_YX 114
#define TOK_CMPT_YY 115
#define TOK_CMPT_YZ 116
#define TOK_CMPT_ZX 117
#define TOK_CMPT_ZY 118
#define TOK_CMPT_ZZ 119
#define TOK_CMPT_II 120
#define TOK_TRANSPOSE 121
#define TOK_DIAG 122
#define TOK_POINT_TO_CELL 123
#define TOK_RECONSTRUCT 124
#define TOK_CELL_TO_FACE 125
#define TOK_CELL_TO_POINT 126

162
src/finiteVolume/expressions/volume/volumeExprLemonParser.lyy-m4
View File

@ -42,6 +42,7 @@ Description
*/
%include
{
#include "exprScanToken.H"
#include "volumeExprDriver.H"
#include "volumeExprParser.H"
#include "volumeExprScanner.H"
@ -110,11 +111,8 @@ dnl
%token_prefix TOK_
// Terminals
%token_type {Foam::expressions::volumeExpr::scanToken*}
// Non-terminals
%type ivalue { Foam::label }
%type svalue { Foam::scalar }
%type ident { Foam::word* }
%token_type {Foam::expressions::scanToken}
%token_destructor { ($$).destroy(); }
// Volume fields
declare_field(lfield, Foam::volScalarField, Foam::scalar, newVolField, getVolField)
@ -144,17 +142,34 @@ declare_field(ptfield, Foam::pointTensorField, Foam::tensor, newPointField, getP
// Lemon does not generate a destructor for that.
// So do not use Lemon destructors for anything.
standard_tokens()
operator_precedence()
%start_symbol evaluate
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
/*---------------------------------------------------------------------------*\
* General Productions
\*---------------------------------------------------------------------------*/
%type identifier { Foam::word* }
%destructor identifier { delete($$); $$ = nullptr; }
identifier (lhs) ::= IDENTIFIER (tok) .
{
// Take ownership of pointer from scan token
lhs = tok.name_; tok.name_ = nullptr;
}
/*---------------------------------------------------------------------------*\
* Productions (scalar)
\*---------------------------------------------------------------------------*/
svalue (lhs) ::= NUMBER (a) . { lhs = (a)->svalue; } // From scanToken
%type svalue { Foam::scalar }
svalue (lhs) ::= NUMBER (tok) . { lhs = (tok).scalarValue; } // scanToken
svalue (lhs) ::= ZERO . { lhs = Foam::Zero; }
svalue (lhs) ::= PI LPAREN RPAREN . { lhs = Foam::constant::mathematical::pi; }
svalue (lhs) ::= DEG_TO_RAD LPAREN RPAREN . { lhs = Foam::degToRad(); }
@ -163,6 +178,32 @@ svalue (lhs) ::= ARG LPAREN RPAREN . { lhs = driver->argValue(); }
svalue (lhs) ::= TIME LPAREN RPAREN . { lhs = driver->timeValue(); }
svalue (lhs) ::= DELTA_T LPAREN RPAREN . { lhs = driver->deltaT(); }
svalue (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN RPAREN .
{
driver->reportFatal("Not implemented: " + make_obj(name.name_));
lhs = 0;
}
/*---------------------------------------------------------------------------*\
* Productions (vector)
\*---------------------------------------------------------------------------*/
%type vvalue { Foam::vector* }
%destructor vvalue { delete($$); $$ = nullptr; }
vvalue (lhs) ::= VECTOR_VALUE (tok) .
{
// Take ownership of pointer from scan token
lhs = tok.vectorPtr; tok.vectorPtr = nullptr;
}
vvalue (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN RPAREN .
{
driver->reportFatal("Not implemented: " + make_obj(name.name_));
lhs = new Foam::vector(0,0,0);
}
/* * * * * * * * * * * * * * * * Volume Fields * * * * * * * * * * * * * * * *\
dnl
@ -178,7 +219,9 @@ dnl
/*---------------------------------------------------------------------------*\
* Productions (volScalarField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [sfield])dnl
define([_new_target_], [_new_sfield])dnl
define([_value_type_], [Foam::scalar])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -194,12 +237,12 @@ rules_scalar_operations()
rules_scalar_functions()
// Non-standard but manage via FieldOps::assign
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<_value_type_>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<_value_type_>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<_value_type_>())
// Non-standard but manage via FieldOps::assign
rule_binary_assign(_target_, _target_, _target_, HYPOT, Foam::hypotOp<Foam::scalar>())
rule_binary_assign(_target_, _target_, _target_, HYPOT, Foam::hypotOp<_value_type_>())
// Other functions
@ -212,20 +255,30 @@ _target_ (lhs) ::= RAND LPAREN RPAREN .
_target_ (lhs) ::= RAND LPAREN NUMBER (seed) RPAREN .
{
// Call with -ve seed to signal use of time index as seed
lhs = driver->field_rand(std::round(-(seed)->svalue)).ptr();
lhs = driver->field_rand(std::round(-(seed).scalarValue)).ptr();
}
_target_ (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (volVectorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [vfield])dnl
define([_new_target_], [_new_vfield])dnl
define([_value_type_], [Foam::vector])dnl
dnl
\*---------------------------------------------------------------------------*/
evaluate ::= _target_ (a) . { driver->setResult(a); }
rule_field_from_value(_target_, vvalue)
rule_get_field(_target_, VECTOR_ID)
rules_standard(_target_, _value_type_, _logic_)
@ -233,9 +286,20 @@ rules_inplace_gUnary(_target_)
rules_vector_operations()
rules_vector_functions()
// Other functions
_target_ (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (volSphericalTensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [hfield])dnl
define([_value_type_], [Foam::sphericalTensor])dnl
dnl
@ -253,6 +317,7 @@ rules_sphTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (volSymmTensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [yfield])dnl
define([_value_type_], [Foam::symmTensor])dnl
dnl
@ -269,6 +334,7 @@ rules_symTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (volTensorField)
dnl
define([_scalar_arg_], [sfield])dnl
define([_target_], [tfield])dnl
define([_value_type_], [Foam::tensor])dnl
dnl
@ -326,7 +392,9 @@ dnl> %ifndef disable_surface_fields
/*---------------------------------------------------------------------------*\
* Productions (surfaceScalarField)
dnl
define([_scalar_arg_], [ssfield])dnl
define([_target_], [ssfield])dnl
define([_new_target_], [_new_ssfield])dnl
define([_value_type_], [Foam::scalar])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -342,24 +410,34 @@ rules_scalar_operations()
rules_scalar_functions()
// Non-standard but manage via FieldOps::assign
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<_value_type_>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<_value_type_>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<_value_type_>())
// Non-standard but manage via FieldOps::assign
rule_binary_assign(_target_, _target_, _target_, HYPOT, Foam::hypotOp<Foam::scalar>())
rule_binary_assign(_target_, _target_, _target_, HYPOT, Foam::hypotOp<_value_type_>())
_target_ (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (surfaceVectorField)
dnl
define([_scalar_arg_], [ssfield])dnl
define([_target_], [svfield])dnl
define([_new_target_], [_new_svfield])dnl
define([_value_type_], [Foam::vector])dnl
dnl
\*---------------------------------------------------------------------------*/
evaluate ::= _target_ (a) . { driver->setResult(a); }
rule_field_from_value(_target_, vvalue, FACE_EXPR)
rule_get_field(_target_, SVECTOR_ID)
rules_standard(_target_, _value_type_, _logic_)
@ -367,10 +445,18 @@ rules_inplace_gUnary(_target_)
rules_vector_operations()
rules_vector_functions()
_target_ (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (surfaceSphericalTensorField)
dnl
define([_scalar_arg_], [ssfield])dnl
define([_target_], [shfield])dnl
define([_value_type_], [Foam::sphericalTensor])dnl
dnl
@ -388,6 +474,7 @@ rules_sphTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (surfaceSymmTensorField)
dnl
define([_scalar_arg_], [ssfield])dnl
define([_target_], [syfield])dnl
define([_value_type_], [Foam::symmTensor])dnl
dnl
@ -406,6 +493,7 @@ rules_symTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (surfaceTensorField)
dnl
define([_scalar_arg_], [ssfield])dnl
define([_target_], [stfield])dnl
define([_value_type_], [Foam::tensor])dnl
dnl
@ -470,7 +558,9 @@ dnl> %ifndef disable_point_fields
/*---------------------------------------------------------------------------*\
* Productions (pointScalarField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [psfield])dnl
define([_new_target_], [_new_psfield])dnl
define([_value_type_], [Foam::scalar])dnl
dnl
\*---------------------------------------------------------------------------*/
@ -484,12 +574,19 @@ rules_standard(_target_, _value_type_, _logic_)
rules_inplace_gUnary(_target_)
// Non-standard but manage via FieldOps::assign
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<Foam::scalar>())
rule_unary_assign(_target_, _target_, FLOOR, Foam::floorOp<_value_type_>())
rule_unary_assign(_target_, _target_, CEIL, Foam::ceilOp<_value_type_>())
rule_unary_assign(_target_, _target_, ROUND, Foam::roundOp<_value_type_>())
// Non-standard but manage via FieldOps::assign
rule_binary_assign(_target_, _target_, _target_, HYPOT, Foam::hypotOp<Foam::scalar>())
rule_binary_assign(_target_, _target_, _target_, HYPOT, Foam::hypotOp<_value_type_>())
_target_ (lhs) ::= SCALAR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
@ -542,13 +639,16 @@ dnl*/
/*---------------------------------------------------------------------------*\
* Productions (pointVectorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [pvfield])dnl
define([_new_target_], [_new_pvfield])dnl
define([_value_type_], [Foam::vector])dnl
dnl
\*---------------------------------------------------------------------------*/
evaluate ::= _target_ (a) . { driver->setResult(a); }
rule_field_from_value(_target_, vvalue, POINT_EXPR)
rule_get_field(_target_, PVECTOR_ID)
rules_standard(_target_, _value_type_, _logic_)
@ -556,9 +656,17 @@ rules_inplace_gUnary(_target_)
rules_vector_operations()
rules_vector_functions()
_target_ (lhs) ::= VECTOR_FUNCTION_ID (name) LPAREN _scalar_arg_ (values) RPAREN.
{
lhs = _new_target_;
(void) make_obj(values);
driver->reportFatal("Not implemented: " + make_obj(name.name_));
}
/*---------------------------------------------------------------------------*\
* Productions (pointSphericalTensorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [phfield])dnl
define([_value_type_], [Foam::sphericalTensor])dnl
dnl
@ -577,6 +685,7 @@ rules_sphTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (pointSymmTensorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [pyfield])dnl
define([_value_type_], [Foam::symmTensor])dnl
dnl
@ -595,6 +704,7 @@ rules_symTensor_functions()
/*---------------------------------------------------------------------------*\
* Productions (pointTensorField)
dnl
define([_scalar_arg_], [psfield])dnl
define([_target_], [ptfield])dnl
define([_value_type_], [Foam::tensor])dnl
dnl
@ -802,13 +912,15 @@ void Foam::expressions::volumeExpr::parser::start(parseDriver& driver_)
}
void Foam::expressions::volumeExpr::parser::parse
(
int tokenId,
scanToken* tokenVal
)
void Foam::expressions::volumeExpr::parser::parse(int tokenId)
{
Parse(lemon_, tokenId, tokenVal);
Parse(lemon_, tokenId, scanToken::null());
}
void Foam::expressions::volumeExpr::parser::parse(int tokenId, scanToken tok)
{
Parse(lemon_, tokenId, tok);
}

30
src/finiteVolume/expressions/volume/volumeExprLemonParserMacros.m4
View File

@ -34,8 +34,14 @@ divert(-1)dnl
define([rules_driver_volume_functions],
[dnl
rule_driver_select(_logic_, CELL_SET, field_cellSet)dnl
rule_driver_select(_logic_, CELL_ZONE, field_cellZone)dnl
_logic_ (lhs) ::= CELL_SET LPAREN identifier (name) RPAREN .dnl
{dnl
lhs = driver->field_cellSet(make_obj(name)).ptr();dnl
}dnl
_logic_ (lhs) ::= CELL_ZONE LPAREN identifier (name) RPAREN .dnl
{
lhs = driver->field_cellZone(make_obj(name)).ptr();dnl
}dnl
dnl
rule_driver_nullary(_scalar_, CELL_VOLUME, field_cellVolume)dnl
rule_driver_nullary(_vector_, POS, field_cellCentre)dnl CELL_CENTRE
@ -56,8 +62,14 @@ dnl
define([rules_driver_surface_functions],
[dnl
rule_driver_select(_logic_, FACE_SET, field_faceSet)dnl
rule_driver_select(_logic_, FACE_ZONE, field_faceZone)dnl
_logic_ (lhs) ::= FACE_SET LPAREN identifier (name) RPAREN .dnl
{dnl
lhs = driver->field_faceSet(make_obj(name)).ptr();dnl
}dnl
_logic_ (lhs) ::= FACE_ZONE LPAREN identifier (name) RPAREN .dnl
{dnl
lhs = driver->field_faceZone(make_obj(name)).ptr();dnl
}dnl
dnl
rule_driver_nullary(_scalar_, FACE_AREA, field_faceArea)dnl
rule_driver_nullary(_vector_, FACE_CENTRE, field_faceCentre)dnl
@ -79,8 +91,14 @@ dnl
define([rules_driver_point_functions],
[dnl
rule_driver_select(_logic_, POINT_SET, field_pointSet)dnl
rule_driver_select(_logic_, POINT_ZONE, field_pointZone)dnl
_logic_ (lhs) ::= POINT_SET LPAREN identifier (name) RPAREN .dnl
{dnl
lhs = driver->field_pointSet(make_obj(*name)).ptr();dnl
}dnl
_logic_ (lhs) ::= POINT_ZONE LPAREN identifier (name) RPAREN .dnl
{dnl
lhs = driver->field_pointZone(make_obj(*name)).ptr();dnl
}dnl
dnl
rule_driver_nullary(_vector_, POINTS, field_pointField)dnl
dnl

10
src/finiteVolume/expressions/volume/volumeExprParser.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -34,6 +34,7 @@ Description
#ifndef expressions_volumeExprParser_H
#define expressions_volumeExprParser_H
#include "exprScanToken.H"
#include "volumeExprFwd.H"
namespace Foam
@ -97,8 +98,11 @@ public:
//- Stop parsing, freeing the allocated parser
void stop();
//- Push token/value to parser
void parse(int tokenId, scanToken* tokenVal);
//- Push token type to parser with default token
void parse(int tokenId);
//- Push token type/value to parser
void parse(int tokenId, scanToken tok);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

25
src/finiteVolume/expressions/volume/volumeExprScanner.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -37,8 +37,8 @@ Note
#ifndef expressions_volumeExprScanner_H
#define expressions_volumeExprScanner_H
#include "exprScanToken.H"
#include "volumeExprFwd.H"
#include "scalar.H"
namespace Foam
{
@ -47,21 +47,6 @@ namespace expressions
namespace volumeExpr
{
/*---------------------------------------------------------------------------*\
Class scanToken Declaration
\*---------------------------------------------------------------------------*/
union scanToken
{
Foam::label ivalue;
Foam::scalar svalue;
Foam::word* name;
//- Default construct, bit-wise zero for union content
scanToken() : ivalue(0) {}
};
/*---------------------------------------------------------------------------*\
Class scanner Declaration
\*---------------------------------------------------------------------------*/
@ -83,16 +68,14 @@ class scanner
bool dispatch_method
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident // Receives a copy
) const;
//- Dispatch identifier to parser (if possible) or Fatal
bool dispatch_ident
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident // Receives a copy
) const;

3446
src/finiteVolume/expressions/volume/volumeExprScanner.cc
View File

File diff suppressed because it is too large Load Diff

160
src/finiteVolume/expressions/volume/volumeExprScanner.rl
View File

@ -42,7 +42,6 @@ Description
#undef DebugInfo
#define DebugInfo if (debug & 0x2) InfoErr
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
@ -59,18 +58,16 @@ namespace Foam
// Special handling for these known (stashed) look-back types
#define HAS_LOOKBEHIND_TOKENS
static const Enum<int> lookBehindTokenEnums
({
TOKEN_PAIR("cellSet", CELL_SET),
TOKEN_PAIR("faceSet", FACE_SET),
TOKEN_PAIR("pointSet", POINT_SET),
TOKEN_PAIR("cellZone", CELL_ZONE),
TOKEN_PAIR("faceZone", FACE_ZONE),
TOKEN_PAIR("pointZone", POINT_ZONE),
TOKEN_PAIR("cellZone", CELL_ZONE), TOKEN_PAIR("cellSet", CELL_SET),
TOKEN_PAIR("faceZone", FACE_ZONE), TOKEN_PAIR("faceSet", FACE_SET),
#ifdef TOK_POINT_ZONE
TOKEN_PAIR("pointZone", POINT_ZONE), TOKEN_PAIR("pointSet", POINT_SET),
#endif
});
#define HAS_LOOKBEHIND_TOKENS
// Special handling of predefined method types. Eg, .x(), .y(), ...
static const Enum<int> fieldMethodEnums
@ -192,6 +189,7 @@ static int driverTokenType
const word& ident
)
{
#ifdef HAS_LOOKBEHIND_TOKENS
// Get stashed "look-behind" to decide what type of identifier we expect
const int lookBehind = driver_.resetStashedTokenId();
@ -201,12 +199,16 @@ static int driverTokenType
switch (lookBehind)
{
case TOK_CELL_SET : good = driver_.isCellSet(ident); break;
case TOK_FACE_SET : good = driver_.isFaceSet(ident); break;
case TOK_POINT_SET : good = driver_.isPointSet(ident); break;
case TOK_CELL_ZONE : good = driver_.isCellZone(ident); break;
case TOK_CELL_SET : good = driver_.isCellSet(ident); break;
case TOK_FACE_ZONE : good = driver_.isFaceZone(ident); break;
case TOK_FACE_SET : good = driver_.isFaceSet(ident); break;
#ifdef TOK_POINT_ZONE
case TOK_POINT_ZONE : good = driver_.isPointZone(ident); break;
case TOK_POINT_SET : good = driver_.isPointSet(ident); break;
#endif
}
if (good)
@ -222,65 +224,67 @@ static int driverTokenType
return -2; // Extra safety
}
#endif
// Surface variables - distinguish from volume by size
#ifdef TOK_SSCALAR_ID
{
const label len = driver_.mesh().nInternalFaces();
#undef checkFieldToken
#define checkFieldToken(TokType, Type) \
#undef doLocalCode
#define doLocalCode(TokType, Type) \
if (driver_.isVariable<Type>(ident, false, len)) \
{ \
return TokType; \
}
checkFieldToken(TOK_SSCALAR_ID, scalar);
checkFieldToken(TOK_SVECTOR_ID, vector);
checkFieldToken(TOK_SSYM_TENSOR_ID, symmTensor);
checkFieldToken(TOK_SSPH_TENSOR_ID, sphericalTensor);
checkFieldToken(TOK_STENSOR_ID, tensor);
doLocalCode(TOK_SSCALAR_ID, scalar);
doLocalCode(TOK_SVECTOR_ID, vector);
doLocalCode(TOK_SSYM_TENSOR_ID, symmTensor);
doLocalCode(TOK_SSPH_TENSOR_ID, sphericalTensor);
doLocalCode(TOK_STENSOR_ID, tensor);
#undef doLocalCode
}
#endif
// Point variables
#ifdef TOK_PSCALAR_ID
{
#undef checkFieldToken
#define checkFieldToken(TokType, Type) \
#undef doLocalCode
#define doLocalCode(TokType, Type) \
if (driver_.isVariable<Type>(ident, true)) \
{ \
return TokType; \
}
checkFieldToken(TOK_PSCALAR_ID, scalar);
checkFieldToken(TOK_PVECTOR_ID, vector);
checkFieldToken(TOK_PSPH_TENSOR_ID, sphericalTensor);
checkFieldToken(TOK_PSYM_TENSOR_ID, symmTensor);
checkFieldToken(TOK_PTENSOR_ID, tensor);
doLocalCode(TOK_PSCALAR_ID, scalar);
doLocalCode(TOK_PVECTOR_ID, vector);
doLocalCode(TOK_PSPH_TENSOR_ID, sphericalTensor);
doLocalCode(TOK_PSYM_TENSOR_ID, symmTensor);
doLocalCode(TOK_PTENSOR_ID, tensor);
#undef doLocalCode
}
#endif
// Volume variables
#ifdef TOK_SCALAR_ID
{
#undef checkFieldToken
#define checkFieldToken(TokType, Type) \
#undef doLocalCode
#define doLocalCode(TokType, Type) \
if (driver_.isVariable<Type>(ident, false)) \
{ \
return TokType; \
}
checkFieldToken(TOK_SCALAR_ID, scalar);
checkFieldToken(TOK_VECTOR_ID, vector);
checkFieldToken(TOK_SPH_TENSOR_ID, sphericalTensor);
checkFieldToken(TOK_SYM_TENSOR_ID, symmTensor);
checkFieldToken(TOK_TENSOR_ID, tensor);
doLocalCode(TOK_SCALAR_ID, scalar);
doLocalCode(TOK_VECTOR_ID, vector);
doLocalCode(TOK_SPH_TENSOR_ID, sphericalTensor);
doLocalCode(TOK_SYM_TENSOR_ID, symmTensor);
doLocalCode(TOK_TENSOR_ID, tensor);
#undef doLocalCode
}
#endif
#undef checkFieldToken
// Check registered fields and/or disk-files
{
const word fieldType(driver_.getFieldClassName(ident));
@ -296,7 +300,7 @@ static int driverTokenType
return -1;
}
} // End anonymous namespace
} // End namespace Foam
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@ -309,7 +313,16 @@ static int driverTokenType
#define EMIT_TOKEN(T) \
driver_.parsePosition() = (ts-buf); \
DebugInfo<< STRINGIFY(T) << " at " << driver_.parsePosition() << nl; \
parser_->parse(TOKEN_OF(T), nullptr); \
parser_->parse(TOKEN_OF(T)); \
driver_.parsePosition() = (p-buf);
#define EMIT_VECTOR_TOKEN(X, Y, Z) \
driver_.parsePosition() = (ts-buf); \
DebugInfo<< "VECTOR at " << driver_.parsePosition() << nl; \
scanToken scanTok; \
scanTok.setVector(X,Y,Z); \
parser_->parse(TOK_VECTOR_VALUE, scanTok); \
driver_.parsePosition() = (p-buf);
@ -318,15 +331,18 @@ static int driverTokenType
write data;
action emit_number {
// Emit number
driver_.parsePosition() = (ts-buf);
DebugInfo
<< "Number:" << std::string(ts, te-ts).c_str()
<< " at " << driver_.parsePosition() << nl;
if (readScalar(std::string(ts, te-ts), scanTok.svalue))
scanToken scanTok;
scanTok.setScalar(0);
if (readScalar(std::string(ts, te-ts), scanTok.scalarValue))
{
parser_->parse(TOKEN_OF(NUMBER), &scanTok);
parser_->parse(TOKEN_OF(NUMBER), scanTok);
}
else
{
@ -340,15 +356,16 @@ static int driverTokenType
}
action emit_ident {
// Emit identifier
driver_.parsePosition() = (ts-buf);
dispatch_ident(driver_, scanTok, word(ts, te-ts, false));
dispatch_ident(driver_, word(ts, te-ts, false));
driver_.parsePosition() = (p-buf);
}
action emit_method {
// Tokenized ".method" - dispatch '.' and "method" separately
driver_.parsePosition() = (ts-buf);
dispatch_method(driver_, scanTok, word(ts+1, te-ts-1, false));
dispatch_method(driver_, word(ts+1, te-ts-1, false));
driver_.parsePosition() = (p-buf);
}
@ -366,7 +383,7 @@ static int driverTokenType
number => emit_number;
## Operators
'!' =>{ EMIT_TOKEN(NOT); };
'!' =>{ EMIT_TOKEN(LNOT); };
'%' =>{ EMIT_TOKEN(PERCENT); };
'(' =>{ EMIT_TOKEN(LPAREN); };
')' =>{ EMIT_TOKEN(RPAREN); };
@ -387,7 +404,7 @@ static int driverTokenType
'&&' =>{ EMIT_TOKEN(LAND); };
'||' =>{ EMIT_TOKEN(LOR); };
'&' =>{ EMIT_TOKEN(BIT_AND); };
## Not needed? '|' =>{ EMIT_TOKEN(BIT_OK); };
## Not needed? '|' =>{ EMIT_TOKEN(BIT_OR); };
'^' =>{ EMIT_TOKEN(BIT_XOR); };
## Some '.method' - Error if unknown
@ -441,9 +458,12 @@ static int driverTokenType
"sphericalTensor" =>{ EMIT_TOKEN(SPH_TENSOR); };
## Single value (constants, etc)
"Zero" =>{ EMIT_TOKEN(ZERO); };
"true" =>{ EMIT_TOKEN(LTRUE); };
"false" =>{ EMIT_TOKEN(LFALSE); };
"Zero" =>{ EMIT_TOKEN(ZERO); };
"vector::x" =>{ EMIT_VECTOR_TOKEN(1,0,0); };
"vector::y" =>{ EMIT_VECTOR_TOKEN(0,1,0); };
"vector::z" =>{ EMIT_VECTOR_TOKEN(0,0,1); };
"tensor::I" =>{ EMIT_TOKEN(IDENTITY_TENSOR); };
"arg" =>{ EMIT_TOKEN(ARG); };
"time" =>{ EMIT_TOKEN(TIME); };
@ -476,8 +496,7 @@ Foam::expressions::volumeExpr::scanner::~scanner()
bool Foam::expressions::volumeExpr::scanner::dispatch_method
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident
) const
{
if (ident[0] == '.')
@ -494,8 +513,8 @@ bool Foam::expressions::volumeExpr::scanner::dispatch_method
if (methType > 0)
{
// Dispatch '.' and "method" separately
parser_->parse(TOK_DOT, nullptr);
parser_->parse(methType, nullptr);
parser_->parse(TOK_DOT);
parser_->parse(methType);
return true;
}
@ -508,10 +527,11 @@ bool Foam::expressions::volumeExpr::scanner::dispatch_method
bool Foam::expressions::volumeExpr::scanner::dispatch_ident
(
const parseDriver& driver_,
scanToken& scanTok,
word&& ident
word ident
) const
{
// Peek at stashed "look-behind". It may influence decisions
int lookBehindTok = driver_.stashedTokenId();
int tokType = -1;
const bool quoted =
@ -536,12 +556,12 @@ bool Foam::expressions::volumeExpr::scanner::dispatch_ident
<< "Emit:" << ident << " function:"
<< parser_->tokenName(tokType) << nl;
parser_->parse(tokType, nullptr);
parser_->parse(tokType);
return true;
}
#ifdef HAS_LOOKBEHIND_TOKENS
// Specials such "cset" also reset the look-behind
// Specials such "cellSet" etc also reset the look-behind
tokType = lookBehindTokenEnums.lookup(ident, -1);
if (tokType > 0)
@ -551,17 +571,28 @@ bool Foam::expressions::volumeExpr::scanner::dispatch_ident
<< parser_->tokenName(tokType) << nl;
driver_.resetStashedTokenId(tokType);
parser_->parse(tokType, nullptr);
parser_->parse(tokType);
return true;
}
#endif
}
// Functions: scalar, vector, probably don't need others
// - "fn:" prefix to avoid any ambiguities
if (lookBehindTok <= 0 && ident.starts_with("fn:"))
{
word funcName(ident.substr(3)); // strip prefix
// Can also peek at stashed "look-behind"
// const int lookBehind = driver_.stashedTokenId();
do
{
}
while (false);
}
if (tokType <= 0)
{
tokType = driverTokenType(driver_, ident);
}
if (tokType > 0)
{
@ -569,8 +600,9 @@ bool Foam::expressions::volumeExpr::scanner::dispatch_ident
<< "Emit:" << ident << " token:"
<< parser_->tokenName(tokType) << nl;
scanTok.name = new Foam::word(std::move(ident));
parser_->parse(tokType, &scanTok);
scanToken scanTok;
scanTok.setWord(ident);
parser_->parse(tokType, scanTok);
return true;
}
@ -602,12 +634,13 @@ bool Foam::expressions::volumeExpr::scanner::dispatch_ident
// The field (before the ".")
ident.erase(dot);
scanTok.name = new Foam::word(std::move(ident));
parser_->parse(tokType, &scanTok);
scanToken scanTok;
scanTok.setWord(ident);
parser_->parse(tokType, scanTok);
// Dispatch '.' and "method" separately
parser_->parse(TOK_DOT, nullptr);
parser_->parse(methType, nullptr);
parser_->parse(TOK_DOT);
parser_->parse(methType);
return true;
}
@ -670,9 +703,6 @@ bool Foam::expressions::volumeExpr::scanner::process
parser_->start(driver_);
// Scan token type
scanToken scanTok;
// Token start/end (Ragel naming)
const char* ts;
const char* te;
@ -702,7 +732,7 @@ bool Foam::expressions::volumeExpr::scanner::process
}
// Terminate parser execution
parser_->parse(0, nullptr);
parser_->parse(0);
parser_->stop();
if (debug & 0x6)