Lines Matching full:state
19 // returns {} to signify failure. On failure, the state cannot be assumed
30 #include "flang/Parser/parse-state.h"
32 #include "flang/Parser/user-state.h"
48 // the type checker. The state remains valid.
54 std::optional<A> Parse(ParseState &state) const {
55 state.Say(text_);
106 std::optional<resultType> Parse(ParseState &state) const {
107 Messages messages{std::move(state.messages())};
108 ParseState backtrack{state};
109 std::optional<resultType> result{parser_.Parse(state)};
111 state.messages().Annex(std::move(messages));
113 state = std::move(backtrack);
114 state.messages() = std::move(messages);
134 std::optional<Success> Parse(ParseState &state) const {
135 ParseState forked{state};
153 // or fails if x does, but the state is not modified.
159 std::optional<Success> Parse(ParseState &state) const {
160 ParseState forked{state};
184 std::optional<resultType> Parse(ParseState &state) const {
185 state.PushContext(text_);
186 std::optional<resultType> result{parser_.Parse(state)};
187 state.PopContext();
210 std::optional<resultType> Parse(ParseState &state) const {
211 if (state.deferMessages()) { // fast path
212 std::optional<resultType> result{parser_.Parse(state)};
214 state.set_anyDeferredMessages();
218 Messages messages{std::move(state.messages())};
219 bool hadAnyTokenMatched{state.anyTokenMatched()};
220 state.set_anyTokenMatched(false);
221 std::optional<resultType> result{parser_.Parse(state)};
224 messages.Annex(std::move(state.messages()));
226 state.set_anyTokenMatched();
228 } else if (state.anyTokenMatched()) {
229 emitMessage = state.messages().empty();
230 messages.Annex(std::move(state.messages()));
234 state.set_anyTokenMatched();
237 state.messages() = std::move(messages);
239 state.Say(text_);
263 std::optional<resultType> Parse(ParseState &state) const {
264 if (pa_.Parse(state)) {
265 return pb2_.Parse(state);
286 std::optional<resultType> Parse(ParseState &state) const {
287 if (std::optional<resultType> ax{pa_.Parse(state)}) {
288 if (pb_.Parse(state)) {
310 std::optional<resultType> Parse(ParseState &state) const {
311 Messages messages{std::move(state.messages())};
312 ParseState backtrack{state};
313 std::optional<resultType> result{std::get<0>(ps_).Parse(state)};
316 ParseRest<1>(result, state, backtrack);
319 state.messages().Annex(std::move(messages));
325 void ParseRest(std::optional<resultType> &result, ParseState &state,
327 ParseState prevState{std::move(state)};
328 state = backtrack;
329 result = std::get<J>(ps_).Parse(state);
331 state.CombineFailedParses(std::move(prevState));
333 ParseRest<J + 1>(result, state, backtrack);
360 std::optional<resultType> Parse(ParseState &state) const {
361 bool originallyDeferred{state.deferMessages()};
362 ParseState backtrack{state};
363 if (!originallyDeferred && state.messages().empty() &&
364 !state.anyErrorRecovery()) {
366 // state. Attempt to parse with messages deferred, expecting that the
368 state.set_deferMessages(true);
369 if (std::optional<resultType> ax{pa_.Parse(state)}) {
370 if (!state.anyDeferredMessages() && !state.anyErrorRecovery()) {
371 state.set_deferMessages(false);
375 state = backtrack;
377 Messages messages{std::move(state.messages())};
378 if (std::optional<resultType> ax{pa_.Parse(state)}) {
379 state.messages().Annex(std::move(messages));
382 messages.Annex(std::move(state.messages()));
383 bool hadDeferredMessages{state.anyDeferredMessages()};
384 bool anyTokenMatched{state.anyTokenMatched()};
385 state = std::move(backtrack);
386 state.set_deferMessages(true);
387 std::optional<resultType> bx{pb_.Parse(state)};
388 state.messages() = std::move(messages);
389 state.set_deferMessages(originallyDeferred);
391 state.set_anyTokenMatched();
394 state.set_anyDeferredMessages();
398 CHECK(state.anyDeferredMessages() || state.messages().AnyFatalError());
399 state.set_anyErrorRecovery();
424 std::optional<resultType> Parse(ParseState &state) const {
426 auto at{state.GetLocation()};
427 while (std::optional<paType> x{parser_.Parse(state)}) {
429 if (state.GetLocation() <= at) {
432 at = state.GetLocation();
456 std::optional<resultType> Parse(ParseState &state) const {
457 auto start{state.GetLocation()};
458 if (std::optional<paType> first{parser_.Parse(state)}) {
461 if (state.GetLocation() > start) {
462 result.splice(result.end(), many(parser_).Parse(state).value());
483 std::optional<Success> Parse(ParseState &state) const {
484 for (auto at{state.GetLocation()};
485 parser_.Parse(state) && state.GetLocation() > at;
486 at = state.GetLocation()) {
501 // state on failure.
507 std::optional<Success> Parse(ParseState &state) const {
508 while (parser_.Parse(state)) {
530 std::optional<resultType> Parse(ParseState &state) const {
531 if (resultType result{parser_.Parse(state)}) {
554 std::optional<resultType> Parse(ParseState &state) const {
555 std::optional<std::optional<resultType>> ax{maybe(parser_).Parse(state)};
596 ApplyArgs<PARSER...> &args, ParseState &state, std::index_sequence<J...>) {
598 (std::get<J>(args) = std::get<J>(parsers).Parse(state),
626 std::optional<resultType> Parse(ParseState &state) const {
629 if (ApplyHelperArgs(parsers_, results, state, Sequence{})) {
676 std::optional<resultType> Parse(ParseState &state) const {
680 if (ApplyHelperArgs(parsers_, results, state, Sequence1{})) {
724 std::optional<resultType> Parse(ParseState &state) const {
729 return ParseOne(state);
733 if (ApplyHelperArgs(parsers_, results, state, Sequence{})) {
743 std::optional<resultType> ParseOne(ParseState &state) const {
745 if (std::get<0>(parsers_).Parse(state)) {
748 } else if (auto arg{std::get<0>(parsers_).Parse(state)}) {
786 std::optional<resultType> Parse(ParseState &state) const {
789 .Parse(state);
821 // nextCh is a parser that succeeds if the parsing state is not
827 std::optional<const char *> Parse(ParseState &state) const {
828 if (std::optional<const char *> result{state.GetNextChar()}) {
831 state.Say("end of file"_err_en_US);
848 std::optional<resultType> Parse(ParseState &state) const {
849 if (UserState * ustate{state.userState()}) {
854 auto at{state.GetLocation()};
855 auto result{parser_.Parse(state)};
857 state.Nonstandard(
858 CharBlock{at, std::max(state.GetLocation(), at + 1)}, LF, message_);
886 std::optional<resultType> Parse(ParseState &state) const {
887 if (UserState * ustate{state.userState()}) {
892 auto at{state.GetLocation()};
893 auto result{parser_.Parse(state)};
895 state.Nonstandard(CharBlock{at, state.GetLocation()}, LF,
916 std::optional<resultType> Parse(ParseState &state) const {
917 const char *start{state.GetLocation()};
918 auto result{parser_.Parse(state)};
920 const char *end{state.GetLocation()};