25#ifndef PXR_USD_SDF_PREDICATE_EXPRESSION_PARSER_H
26#define PXR_USD_SDF_PREDICATE_EXPRESSION_PARSER_H
29#include "pxr/usd/sdf/api.h"
32#include "pxr/base/vt/value.h"
34#include "pxr/base/pegtl/pegtl.hpp"
38PXR_NAMESPACE_OPEN_SCOPE
42Sdf_EvalQuotedString(
const char* x,
size_t n,
43 size_t trimBothSides,
unsigned int* numLines=NULL);
45struct SdfPredicateExprBuilder
47 SdfPredicateExprBuilder() { OpenGroup(); }
52 _stacks.back().PushCall(
53 kind, std::move(_funcName), std::move(_funcArgs));
58 void SetFuncName(std::string
const &name) {
62 void AddFuncArg(
VtValue const &val) {
63 _funcArgs.push_back({ std::move(_funcKwArgName), val });
64 _funcKwArgName.clear();
67 void SetFuncArgKWName(std::string
const &kw) {
71 void OpenGroup() { _stacks.emplace_back(); }
76 _stacks.back().PushExpr(std::move(innerExpr));
92 auto higherPrec = [](Op left, Op right) {
93 return (left < right) || (left == right && left != Op::Not);
96 while (!opStack.empty() && higherPrec(opStack.back(), op)) {
99 opStack.push_back(op);
104 std::vector<SdfPredicateExpression::FnArg> &&args) {
107 kind, std::move(name), std::move(args) }));
111 exprStack.push_back(std::move(expr));
115 while (!opStack.empty()) {
128 exprStack.pop_back();
130 if (op == SdfPredicateExpression::Not) {
138 exprStack.pop_back();
141 op, std::move(left), std::move(right))
147 std::vector<SdfPredicateExpression::Op> opStack;
148 std::vector<SdfPredicateExpression> exprStack;
151 std::vector<_Stack> _stacks;
153 std::string _funcName;
154 std::string _funcKwArgName;
155 std::vector<SdfPredicateExpression::FnArg> _funcArgs;
165using namespace PXR_PEGTL_NAMESPACE;
167template <
class Rule,
class Sep>
168using LookaheadList = seq<Rule, star<at<Sep, Rule>, Sep, Rule>>;
170template <
class Rule>
using OptSpaced = pad<Rule, blank>;
172using OptSpacedComma = OptSpaced<one<
','>>;
177struct NotKW : keyword<'n','o','t'> {};
178struct AndKW : keyword<'a','n','d'> {};
179struct OrKW : keyword<'o','r'> {};
180struct Inf : keyword<'i','n','f'> {};
181struct True : keyword<'t','r','u','e'> {};
182struct False : keyword<'f','a','l','s','e'> {};
183struct ImpliedAnd : plus<blank> {};
185struct ReservedWord : sor<
186 NotKW, AndKW, OrKW, Inf, True, False> {};
188struct Digits : plus<range<'0','9'>> {};
190struct Exp : seq<one<'e','E'>, opt<one<'-','+'>>, must<Digits>> {};
191struct Frac : if_must<one<'.'>, Digits> {};
192struct PredArgFloat : seq<
193 opt<one<'-'>>, sor<Inf, seq<Digits, if_then_else<Frac, opt<Exp>, Exp>>>
195struct PredArgInt : seq<opt<one<'-'>>, Digits> {};
197struct PredArgBool : sor<True, False> {};
199template <
class Quote>
200struct Escaped : sor<Quote, one<'\\', 'b', 'f', 'n', 'r', 't'>> {};
201template <
class Quote>
202struct Unescaped : minus<utf8::range<0x20, 0x10FFFF>, Quote> {};
204template <
class Quote>
205struct StringChar : if_then_else<
206 one<'\\'>, must<Escaped<Quote>>, Unescaped<Quote>> {};
208struct QuotedString : sor<
209 if_must<one<'"'>, until<one<'"'>, StringChar<one<'"'>>>>,
210 if_must<one<'\''>, until<one<'\''>, StringChar<one<'\''>>>>
213struct UnquotedStringChar
214 : sor<identifier_other,
215 one<'~', '!', '@', '#', '$', '%', '^', '&', '*', '-', '+', '=',
216 '|', '\\', '.', '?', '/'>> {};
218struct UnquotedString : star<UnquotedStringChar> {};
220struct PredArgString : sor<QuotedString, UnquotedString> {};
222struct PredArgVal : sor<
223 PredArgFloat, PredArgInt, PredArgBool, PredArgString> {};
225struct PredKWArgName : minus<identifier, ReservedWord> {};
227struct PredKWArgPrefix : seq<PredKWArgName, OptSpaced<one<'='>>> {};
228struct PredKWArg : if_must<PredKWArgPrefix, PredArgVal> {};
230struct PredParenPosArg : seq<not_at<PredKWArgPrefix>, PredArgVal> {};
232struct PredFuncName : minus<identifier, ReservedWord> {};
235 : if_then_else<list<PredParenPosArg, OptSpacedComma>,
236 opt<OptSpacedComma, list<PredKWArg, OptSpacedComma>>,
237 opt<list<PredKWArg, OptSpacedComma>>>
240struct PredColonArgs : list<PredArgVal, one<','>> {};
241struct PredColonCall : if_must<seq<PredFuncName, one<':'>>, PredColonArgs> {};
242struct PredParenCall : seq<
243 PredFuncName, OptSpaced<one<'('>>,
244 must<PredParenArgs, star<blank>, one<')'>>
248struct PredBareCall : PredFuncName {};
252struct PredOpenGroup : one<'('> {};
253struct PredCloseGroup : one<')'> {};
260 if_must<PredOpenGroup, OptSpaced<PredExpr>, PredCloseGroup>
264struct PredFactor : seq<opt<OptSpaced<list<NotKW, plus<blank>>>>, PredAtom> {};
265struct PredOperator : sor<OptSpaced<AndKW>, OptSpaced<OrKW>, ImpliedAnd> {};
266struct PredExpr : LookaheadList<PredFactor, PredOperator> {};
271struct PredAction : nothing<Rule> {};
273template <SdfPredicateExpression::Op op>
276 template <
class Input>
277 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
282template <>
struct PredAction<NotKW>
283 : PredOpAction<SdfPredicateExpression::Not> {};
284template <>
struct PredAction<AndKW>
285 : PredOpAction<SdfPredicateExpression::And> {};
286template <>
struct PredAction<OrKW>
287 : PredOpAction<SdfPredicateExpression::Or> {};
288template <>
struct PredAction<ImpliedAnd>
289 : PredOpAction<SdfPredicateExpression::ImpliedAnd> {};
292struct PredAction<PredOpenGroup>
294 template <
class Input>
295 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
301struct PredAction<PredCloseGroup>
303 template <
class Input>
304 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
305 builder.CloseGroup();
310struct PredAction<PredFuncName>
312 template <
class Input>
313 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
314 builder.SetFuncName(in.string());
319struct PredAction<PredArgInt>
321 template <
class Input>
322 static bool apply(Input
const &in, SdfPredicateExprBuilder &builder) {
323 bool outOfRange =
false;
328 builder.AddFuncArg(
VtValue(ival));
334struct PredAction<PredArgBool>
336 template <
class Input>
337 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
338 builder.AddFuncArg(
VtValue(in.string()[0] ==
't'));
343struct PredAction<PredArgFloat>
345 template <
class Input>
346 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
347 std::string
const &instr = in.string();
349 if (instr ==
"inf") {
350 fval = std::numeric_limits<double>::infinity();
352 else if (instr ==
"-inf") {
353 fval = -std::numeric_limits<double>::infinity();
358 builder.AddFuncArg(
VtValue(fval));
363struct PredAction<PredArgString>
365 template <
class Input>
366 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
367 std::string
const &instr = in.string();
368 size_t trimAmount = 0;
369 if (instr.size() >= 2 &&
370 ((instr.front() ==
'"' && instr.back() ==
'"') ||
371 (instr.front() ==
'\'' && instr.back() ==
'\''))) {
376 instr.c_str(), instr.size(), trimAmount)));
381struct PredAction<PredKWArgName>
383 template <
class Input>
384 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
385 builder.SetFuncArgKWName(in.string());
389template <SdfPredicateExpression::FnCall::Kind callKind>
392 template <
class Input>
393 static void apply(Input
const &in, SdfPredicateExprBuilder &builder) {
394 builder.PushCall(callKind);
397template <>
struct PredAction<PredBareCall>
398 : PredCallAction<SdfPredicateExpression::FnCall::BareCall> {};
399template <>
struct PredAction<PredParenCall>
400 : PredCallAction<SdfPredicateExpression::FnCall::ParenCall> {};
401template <>
struct PredAction<PredColonCall>
402 : PredCallAction<SdfPredicateExpression::FnCall::ColonCall> {};
406PXR_NAMESPACE_CLOSE_SCOPE
Low-level utilities for informing users of various internal and external diagnostic conditions.
Represents a logical expression syntax tree consisting of predicate function calls joined by the logi...
Op
Enumerant describing a subexpression operation.
static SDF_API SdfPredicateExpression MakeOp(Op op, SdfPredicateExpression &&left, SdfPredicateExpression &&right)
Produce a new expression by combining left and right with the operator op.
static SDF_API SdfPredicateExpression MakeNot(SdfPredicateExpression &&right)
Produce a new expression by prepending the 'not' operator onto right.
static SDF_API SdfPredicateExpression MakeCall(FnCall &&call)
Produce a new expression containing just a the function call call.
Provides a container which may hold any type, and provides introspection and iteration over array typ...
TF_API int64_t TfStringToInt64(const std::string &txt, bool *outOfRange=NULL)
Convert a sequence of digits in txt to an int64_t value.
TF_API double TfStringToDouble(const std::string &txt)
Converts text string to double.