---

ebnf_node_builder.cc

Go to the documentation of this file.

/*
 *  File:       ebnf_node_builder.cc
 *              $Id: ebnf_node_builder.cc,v 1.5 2002/06/23 23:32:11 alec Exp $
 *
 *  Author:     Alec Panoviciu (alecu@email.com)
 * 
 *  Comments:
 *
 *  Revision history:
 *
 *  $Log: ebnf_node_builder.cc,v $
 *  Revision 1.5  2002/06/23 23:32:11  alec
 *  la-time usercode (force)
 *
 *  Revision 1.4  2002/06/13 11:37:08  alec
 *  added #line stuff
 *
 *  Revision 1.3  2002/05/16 21:35:13  alec
 *  parser generation done
 *
 *  Revision 1.2  2002/05/10 07:15:10  alec
 *  parser parse tree ok
 *
 *  Revision 1.1  2002/05/08 18:17:37  alec
 *  *** empty log message ***
 *
 */

/*
  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 <vector>

#include "ebnf_node_builder.hh"
#include "ebnf_la_node.hh"
#include "catch_clause.hh"


EbnfNode* EbnfNodeBuilder::createOrNode (EbnfNode *pre, EbnfNode *post,
                                         const Position &pos)
{
  return new EbnfOrNode(dynamic_cast<EbnfLaNode*>(pre),
                        dynamic_cast<EbnfLaNode*>(post),
                        pos);
}


EbnfNode* EbnfNodeBuilder::createCatNode (EbnfNode *pre, EbnfNode *post,
                                          const Position &pos)
{
  return new EbnfCatNode(dynamic_cast<EbnfLaNode*>(pre),
                         dynamic_cast<EbnfLaNode*>(post),
                         pos);
}


EbnfNode* EbnfNodeBuilder::createPlusNode (EbnfNode *in,
                                           const Position &pos)
{
  return new EbnfCatNode(dynamic_cast<EbnfLaNode*>(in->clone()),
                         new EbnfStarNode(dynamic_cast<EbnfLaNode*>(in),
                                          pos),
                         pos);
}


EbnfNode* EbnfNodeBuilder::createStarNode (EbnfNode *in,
                                           const Position &pos)
{
  return new EbnfStarNode(dynamic_cast<EbnfLaNode*>(in),
                          pos);
}


EbnfNode* EbnfNodeBuilder::createOptionalNode (EbnfNode *in,
                                               const Position &pos)
{
  return new EbnfOrNode(dynamic_cast<EbnfLaNode*>(in),
                        new EbnfLambdaNode(pos),
                        pos);
}


EbnfNode* EbnfNodeBuilder::createNonterminalNode (const string &targetVar,
                                                  const Position &targetVarPos,
                                                  const string &nontermId,
                                                  const string &actualArgs,
                                                 const Position &actualArgsPos,
                                                  const Position &pos)
{
  return new EbnfNonterminalNode(targetVar, targetVarPos, nontermId,
                                 actualArgs, actualArgsPos, pos);
}


EbnfNode* EbnfNodeBuilder::createTerminalNode (const string &termId,
                                               const Position &pos)
  throw (ParseException)
{
  if (!tokens.isToken(termId))
    throw ParseException(pos, string("Token \"") + termId + "\" was not declared in the lexical section.");
  return new EbnfTerminalNode(dynamic_cast<TokenDesc&>(tokens[termId]),
                              pos);
}


LaSpec* EbnfNodeBuilder::createLaSpec (int fixedLa, EbnfNode *synLa,
                                       const string &semLa,
                                       const Position &pos)
{
  return new NumberedLaSpec(fixedLa, synLa, semLa, pos);
}


CatchClause* EbnfNodeBuilder::createCatchClause (const string &exceptionDecl,
                                                 const Position &edPos,
                                                 const string &code,
                                                 const Position &codePos)
{
  return new CatchClause(exceptionDecl, edPos, code, codePos);
}


void EbnfNodeBuilder::setLookahead (EbnfNode* node, LaSpec* la)
{
  dynamic_cast<EbnfLaNode*>(node)->laSpec = dynamic_cast<NumberedLaSpec*>(la);
}

void EbnfNodeBuilder::setStartCode (EbnfNode *node, const string &code,
                                    bool force, const Position &pos)
{
  dynamic_cast<EbnfLaNode*>(node)->startCode.set(code, pos);
  dynamic_cast<EbnfLaNode*>(node)->forceStartCode = force;
}

void EbnfNodeBuilder::setEndCode (EbnfNode *node, const string &code,
                                  bool force, const Position &pos)
{
  dynamic_cast<EbnfLaNode*>(node)->endCode.set(code, pos);
  dynamic_cast<EbnfLaNode*>(node)->forceEndCode = force;
}

void EbnfNodeBuilder::setCatchClauses (EbnfNode *node,
                                vector<CatchClause> &catchList)
{
  dynamic_cast<EbnfLaNode*>(node)->catchList = catchList;
}

---