---

parser_spec.cc

Go to the documentation of this file.

/*
 *  File:       parser_spec.cc
 *              $Id: parser_spec.cc,v 1.7 2002/06/13 11:39:54 alec Exp $
 *
 *  Author:     Alec Panoviciu (alecu@email.com)
 * 
 *  Comments:
 *
 *  Revision history:
 *
 *  $Log: parser_spec.cc,v $
 *  Revision 1.7  2002/06/13 11:39:54  alec
 *  added #line stuff
 *
 *  Revision 1.6  2002/05/16 22:10:35  alec
 *  sync
 *
 *  Revision 1.5  2002/05/10 07:15:10  alec
 *  parser parse tree ok
 *
 *  Revision 1.4  2002/05/08 18:20:17  alec
 *  *** empty log message ***
 *
 *  Revision 1.3  2002/04/29 09:34:10  alec
 *  scanner ptree building compiles
 *
 */

/*
  Copyright (C) 2002 Alexandru Panoviciu (alecu@email.com)

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include <algorithm>

#include "debug.h"
#include "parser_spec.hh"
#include "itoken_spec.hh"
#include "ebnf_la_node.hh"
#include "ebnf_node_builder.hh"

ParserSpec::ParserSpec (PropRegistry &registry_, ITokenSpec &tokens_) :
  tokens(tokens_),
  nodeBuilder(*new EbnfNodeBuilder(registry_, tokens_))
{}


IEbnfNodeBuilder& ParserSpec::getEbnfNodeBuilder()
{
  return nodeBuilder;
}


void ParserSpec::addProduction (const string &name,
                                const string &retTypeName,
                                const Position &retTypePos,
                                const string &formalArgs,
                                const Position &formalArgsPos,
                                const string &exceptList,
                                const Position &exceptListPos,
                                const string &preambleCode,
                                const Position &preambleCodePos,
                                EbnfNode *expansion,
                                const Position &pos)
  throw (ParseException)
{
  if (isProduction(name))
    throw ParseException(pos, string("Duplicate production name ") +
                         name + ".");
  productions.push_back(ProductionSpec(name, retTypeName, retTypePos,
                                       formalArgs, formalArgsPos,
                                       exceptList, exceptListPos,
                                       preambleCode, preambleCodePos,
                                       dynamic_cast<EbnfLaNode*>(expansion),
                                       pos));
}


void ParserSpec::setPreambleCode (const string &block, const Position &pos)
{
  preambleCode.set(block, pos);
}


void ParserSpec::setClassName (const string &className_)
{
  className = className_;
}


void ParserSpec::setInheritance (const string &inheritance_,
                                 const Position &pos)
{
  inheritance.set(inheritance_, pos);
}


void ParserSpec::addCodeBlock (const string &block, const Position &pos)
{
  userCode.push_back(CodeChunk(pos, block));
}


bool operator == (ProductionSpec &p, const string &prodName)
{
  return p.name == prodName;
}


bool ParserSpec::isProduction (const string &name)
{
  return(find(productions.begin(), productions.end(), name) !=
                                                  productions.end());
}


ProductionSpec& ParserSpec::getProduction (const string &name)
  throw (ParseException)
{
  vector<ProductionSpec>::iterator i = find(productions.begin(),
                                            productions.end(),
                                            name);
  if (i == productions.end())
    throw ParseException(string("Production \"") + name + "\" not found");

  return *i;
}

#ifdef DEBUG
void ParserSpec::dump (ostream &os) const
{
    os << "ParseSpec dump: " << endl
       << "className: " << className << endl
       << "inheritance: " << inheritance.code << endl
       << "preambleCode:" << endl
       << preambleCode.code << endl
       << "----------------------------------------------------------" << endl
       << "userCode:" << endl;
    for (int i = 0; i < userCode.size(); i++)
      os << userCode[i].code << endl;
    os << "----------------------------------------------------------" << endl
       << "Productions: " << endl;
    for (int i = 0; i < productions.size(); i++) {
      productions[i].dump(os);
      os << endl;
    }
    os << "----------------------------------------------------------" << endl;
}
#endif

---