---

parser.C

Go to the documentation of this file.

// $Id: parser.C,v 1.5 2001/08/19 11:03:45 dvermeir Exp $

#include "parser.h"

Parser::Parser(istream& is): is_(is) {
}
 
ref<Fsm>
Parser::parse() {
// Will return 0 if there is a syntax error.

// Parse initial state: just read the string.

Fsm::State      initial_state;
if (!(is_ >> initial_state))
  return ref<Fsm>();

ref<Fsm>        fsm = Fsm::create(initial_state);

// Parse set of final states and add them to fsm.

Fsm::STATES     final_states;
if (parse_states(final_states))
  for (Fsm::STATES::const_iterator i= final_states.begin();
       i != final_states.end(); ++i) 
    fsm->add_final_state(*i);
else 
  return ref<Fsm>();
  
// Parse transitions until eof.

while (is_) {
  Fsm::STATES   from;
  Fsm::STATES   to;
  Fsm::SYMBOLS  syms;

  if (parse_transition(from,syms,to)) {
    // Insert all single transitions from the sets from, syms, to.
    for (Fsm::STATES::const_iterator i=from.begin(); i!=from.end(); ++i)
      for (Fsm::SYMBOLS::const_iterator j=syms.begin(); j!=syms.end(); ++j)
        for (Fsm::STATES::const_iterator k=to.begin(); k!=to.end(); ++k)
          fsm->add_transition(*i,*j,*k);
    }
  else 
    return ref<Fsm>();
  }
return fsm;
}

bool
Parser::parse_states(Fsm::STATES& states) {
string s;
if (is_ >> s) {
  if (s == "{") {
    while ( (is_ >> s) && ( s != "}" ) && ( s != "{" ) )
      states.insert(s);
    if (s != "}" ) // syntax error: eof while reading states..
      return false;
    else
      return true;
    }
  else 
    if ( s != "}" ) {
      states.insert(s);
      return true;
      }
    else
      return false;
  }
return true;
}

bool
Parser::parse_syms(Fsm::SYMBOLS& syms) {
// Almost identical fo parse_states.
string s;
if (is_ >> s) {
  if (s == "{") {
    while ( (is_ >> s) && ( s != "}" ) && ( s != "{" ) )
      syms.insert(s);
    if (s != "}" ) // syntax error: eof while reading syms..
      return false;
    else
      return true;
    }
  else 
    if ( s != "{") {
      syms.insert(s);
      return true;
      }
    else
      return false;
  }
return true;
}

bool
Parser::parse_transition(Fsm::STATES& from, Fsm::SYMBOLS& syms, Fsm::STATES& to) {
return parse_states(from) && parse_syms(syms) && parse_states(to);
}

---

FSM [ August, 2001]