tesla::internal::NFAParser Class Reference

Detailed Description

Definition at line 78 of file Automaton.cpp.

Public Member Functions
	NFAParser (const AutomatonDescription &A, const Usage *Use, const AutomataMap *Descriptions=NULL)
NFAParser &	AllowSubAutomata (bool Allow)
void	Parse (OwningPtr< NFA > &Out, unsigned int id)
	Parse the NFA, assign it ID id and put it in Out. More...

Constructor & Destructor Documentation

tesla::internal::NFAParser::NFAParser ( const AutomatonDescription &  A, const Usage *  Use, const AutomataMap *  Descriptions = NULL  )

inline

Definition at line 80 of file Automaton.cpp.

    : Automaton(A), Use(Use), Descriptions(Descriptions),
      SubAutomataAllowed(true)
  {
  }

Member Function Documentation

NFAParser & tesla::internal::NFAParser::AllowSubAutomata

(

bool

Allow

)

Definition at line 260 of file Automaton.cpp.

Referenced by tesla::NFA::Link().

                                                 {
  assert(Allow || Descriptions != NULL && "need a source of subautomata");
  SubAutomataAllowed = Allow;

  return *this;
}

Here is the caller graph for this function:

void tesla::internal::NFAParser::Parse	(	OwningPtr< NFA > &	Out,
		unsigned int	id
	)

Parse the NFA, assign it ID id and put it in Out.

Parameters

[out]	Out	where to store the NFA
[in]	id	an integer ID for the resulting NFA

Definition at line 267 of file Automaton.cpp.

References tesla::Usage::beginning, tesla::State::Builder::Build(), tesla::Transition::Copy(), tesla::debugs(), tesla::Usage::end, tesla::Transition::FieldAssign, tesla::Transition::Fn, tesla::Transition::GroupClasses(), tesla::State::NewBuilder(), tesla::Transition::Now, tesla::Transition::Null, tesla::panic(), tesla::State::Builder::SetRefCount(), tesla::State::Builder::SetStartState(), tesla::ShortName(), and tesla::Transition::SubAutomaton.

Referenced by tesla::NFA::Link(), and tesla::NFA::Parse().

                                                          {
  debugs("tesla.automata.parsing")
    << "Parsing '" << ShortName(Automaton.identifier()) << "'...\n";

  size_t VariableRefs = 0;
  for (auto A : Automaton.argument())
    if (A.type() == Argument::Variable)
      VariableRefs++;

  Start = State::NewBuilder(States)
    .SetStartState()
    .SetRefCount(VariableRefs)
    .Build();

  // Parse the automaton entry point, if provided...
  if (Use && Use->has_beginning()) {
    Start = Parse(Use->beginning(), *Start, true);
    if (!Start) {
      string Str;
      TextFormat::PrintToString(Use->beginning(), &Str);
      panic("failed to parse automaton 'beginning' event: " + Str);
    }
  }

  // Parse the main automaton itself.
  State *End = Parse(Automaton.expression(), *Start);
  if (!End)
    panic("failed to parse automaton '" + ShortName(Automaton.identifier()));

  // Parse the automaton finalisation point, if provided...
  if (Use && Use->has_end()) {
    End = Parse(Use->end(), *End, false, true);
    if (!End) {
      string Str;
      TextFormat::PrintToString(Use->end(), &Str);
      panic("failed to parse automaton 'end' event: " + Str);
    }
  }

  // Handle out-of-scope events: if we observe one, we it should cause us to
  // stay in the post-initialisation state.
  debugs("tesla.automata.parsing.out-of-scope") << "out-of-scope events:\n";
  vector<const Transition*> OutOfScope;
  for (const Transition *T : Transitions) {
    // Have we already noted an equivalent out-of-scope transition?
    //
    // This check is subtly different from looping over the equivalence
    // classes created below: that equivalence is based on the transition's
    // input event only, so transitions in the same equivalence class can have
    // different in-scope vs out-of-scope characteristics.
    bool AlreadyHave = false;
    for (const Transition *Existing : OutOfScope)
      if (Existing->EquivalentTo(*T)) {
        AlreadyHave = true;
        break;
      }

    if (!AlreadyHave && !T->IsStrict() && !T->RequiresInit()) {
      OutOfScope.push_back(T);
      debugs("tesla.automata.parsing.out-of-scope")
        << "  " << T->String() << "\n";
    }
  }

  for (auto *T : OutOfScope) {
    State& Destination = *(T->RequiresCleanup() ? End : Start);

    switch (T->getKind()) {
    case Transition::Now:   // fall through
    case Transition::Null:  // fall through
    case Transition::SubAutomaton:
      break;

    case Transition::FieldAssign:   // fall through
    case Transition::Fn:
      Transition::Copy(*Start, Destination, T, Transitions, true);
      break;
    }
  }

  const Identifier &ID = Automaton.identifier();

  string Description;
  TextFormat::PrintToString(Automaton, &Description);

  TransitionSets TEquivClasses;
  Transition::GroupClasses(Transitions, TEquivClasses);

  Out.reset(new NFA(id, Automaton, Use, ShortName(ID), States, TEquivClasses));

  debugs("tesla.automata.parsing") << "parsed '" << Out->Name() << "'.\n\n";
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• tesla/common/Automaton.cpp