Lines Matching refs:Expr
72 first(construct<Expr>(indirect(Parser<CharLiteralConstantSubstring>{})),
73 construct<Expr>(literalConstant),
74 construct<Expr>(construct<Expr::Parentheses>(parenthesized(expr))),
75 construct<Expr>(indirect(functionReference) / !"("_tok / !"%"_tok),
76 construct<Expr>(designator / !"("_tok / !"%"_tok),
77 construct<Expr>(indirect(Parser<SubstringInquiry>{})), // %LEN or %KIND
78 construct<Expr>(Parser<StructureConstructor>{}),
79 construct<Expr>(Parser<ArrayConstructor>{}),
83 construct<Expr>(parenthesized(
84 construct<Expr::ComplexConstructor>(expr, "," >> expr)))),
87 construct<Expr>("%LOC" >> parenthesized(construct<Expr::PercentLoc>(
94 construct<Expr>(construct<Expr::DefinedUnary>(definedOpName, primary)),
97 construct<Expr>(construct<Expr::UnaryPlus>("+" >> primary))),
100 construct<Expr>(construct<Expr::Negate>("-" >> primary)))))};
106 using resultType = Expr;
108 static inline std::optional<Expr> Parse(ParseState &);
113 inline std::optional<Expr> MultOperand::Parse(ParseState &state) { in Parse()
114 std::optional<Expr> result{level1Expr.Parse(state)}; in Parse()
118 std::function<Expr(Expr &&)> power{[&result](Expr &&right) { in Parse()
119 return Expr{Expr::Power(std::move(result).value(), std::move(right))}; in Parse()
131 using resultType = Expr;
133 static inline std::optional<Expr> Parse(ParseState &state) { in Parse()
134 std::optional<Expr> result{multOperand.Parse(state)}; in Parse()
137 std::function<Expr(Expr &&)> multiply{[&result](Expr &&right) { in Parse()
138 return Expr{ in Parse()
139 Expr::Multiply(std::move(result).value(), std::move(right))}; in Parse()
141 std::function<Expr(Expr &&)> divide{[&result](Expr &&right) { in Parse()
142 return Expr{Expr::Divide(std::move(result).value(), std::move(right))}; in Parse()
146 while (std::optional<Expr> next{more.Parse(state)}) { in Parse()
164 using resultType = Expr;
166 static inline std::optional<Expr> Parse(ParseState &state) { in Parse()
169 construct<Expr>(construct<Expr::UnaryPlus>("+" >> addOperand)) || in Parse()
170 construct<Expr>(construct<Expr::Negate>("-" >> addOperand))) || in Parse()
172 std::optional<Expr> result{unary.Parse(state)}; in Parse()
175 std::function<Expr(Expr &&)> add{[&result](Expr &&right) { in Parse()
176 return Expr{Expr::Add(std::move(result).value(), std::move(right))}; in Parse()
178 std::function<Expr(Expr &&)> subtract{[&result](Expr &&right) { in Parse()
179 return Expr{ in Parse()
180 Expr::Subtract(std::move(result).value(), std::move(right))}; in Parse()
184 while (std::optional<Expr> next{more.Parse(state)}) { in Parse()
199 using resultType = Expr;
201 static inline std::optional<Expr> Parse(ParseState &state) { in Parse()
202 std::optional<Expr> result{level2Expr.Parse(state)}; in Parse()
205 std::function<Expr(Expr &&)> concat{[&result](Expr &&right) { in Parse()
206 return Expr{Expr::Concat(std::move(result).value(), std::move(right))}; in Parse()
209 while (std::optional<Expr> next{more.Parse(state)}) { in Parse()
225 using resultType = Expr;
227 static inline std::optional<Expr> Parse(ParseState &state) { in Parse()
228 std::optional<Expr> result{level3Expr.Parse(state)}; in Parse()
231 std::function<Expr(Expr &&)> lt{[&result](Expr &&right) { in Parse()
232 return Expr{Expr::LT(std::move(result).value(), std::move(right))}; in Parse()
234 std::function<Expr(Expr &&)> le{[&result](Expr &&right) { in Parse()
235 return Expr{Expr::LE(std::move(result).value(), std::move(right))}; in Parse()
237 std::function<Expr(Expr &&)> eq{[&result](Expr &&right) { in Parse()
238 return Expr{Expr::EQ(std::move(result).value(), std::move(right))}; in Parse()
240 std::function<Expr(Expr &&)> ne{[&result](Expr &&right) { in Parse()
241 return Expr{Expr::NE(std::move(result).value(), std::move(right))}; in Parse()
243 std::function<Expr(Expr &&)> ge{[&result](Expr &&right) { in Parse()
244 return Expr{Expr::GE(std::move(result).value(), std::move(right))}; in Parse()
246 std::function<Expr(Expr &&)> gt{[&result](Expr &&right) { in Parse()
247 return Expr{Expr::GT(std::move(result).value(), std::move(right))}; in Parse()
260 if (std::optional<Expr> next{more.Parse(state)}) { in Parse()
275 using resultType = Expr;
277 static inline std::optional<Expr> Parse(ParseState &);
289 inline std::optional<Expr> AndOperand::Parse(ParseState &state) { in Parse()
291 if (std::optional<Expr> negation{notOp.Parse(state)}) { in Parse()
292 return Expr{Expr::NOT{std::move(*negation)}}; in Parse()
302 using resultType = Expr;
304 static inline std::optional<Expr> Parse(ParseState &state) { in Parse()
306 std::optional<Expr> result{operand.Parse(state)}; in Parse()
309 std::function<Expr(Expr &&)> logicalAnd{[&result](Expr &&right) { in Parse()
310 return Expr{Expr::AND(std::move(result).value(), std::move(right))}; in Parse()
314 while (std::optional<Expr> next{more.Parse(state)}) { in Parse()
328 using resultType = Expr;
330 static inline std::optional<Expr> Parse(ParseState &state) { in Parse()
331 std::optional<Expr> result{orOperand.Parse(state)}; in Parse()
334 std::function<Expr(Expr &&)> logicalOr{[&result](Expr &&right) { in Parse()
335 return Expr{Expr::OR(std::move(result).value(), std::move(right))}; in Parse()
339 while (std::optional<Expr> next{more.Parse(state)}) { in Parse()
354 using resultType = Expr;
356 static inline std::optional<Expr> Parse(ParseState &state) { in Parse()
357 std::optional<Expr> result{equivOperand.Parse(state)}; in Parse()
360 std::function<Expr(Expr &&)> eqv{[&result](Expr &&right) { in Parse()
361 return Expr{Expr::EQV(std::move(result).value(), std::move(right))}; in Parse()
363 std::function<Expr(Expr &&)> neqv{[&result](Expr &&right) { in Parse()
364 return Expr{Expr::NEQV(std::move(result).value(), std::move(right))}; in Parse()
372 while (std::optional<Expr> next{more.Parse(state)}) { in Parse()
384 template <> std::optional<Expr> Parser<Expr>::Parse(ParseState &state) { in Parse()
385 std::optional<Expr> result{level5Expr.Parse(state)}; in Parse()
388 std::function<Expr(DefinedOpName &&, Expr &&)> defBinOp{ in Parse()
389 [&result](DefinedOpName &&op, Expr &&right) { in Parse()
390 return Expr{Expr::DefinedBinary( in Parse()
394 sourced(applyLambda<Expr>(defBinOp, definedOpName, level5Expr)))}; in Parse()
395 while (std::optional<Expr> next{more.Parse(state)}) { in Parse()