lr_parser_base.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <iostream>

#include <archon/util/unicode.H>

#include <archon/util/lr_parser_base.H>

using namespace std;

namespace Archon
{
  namespace Utilities
  {
    LrParserBase::LrParserBase(CFG &g, const ActorBase *actor,
                               const Printer *printer):
      grammar(g), actor(actor), printer(printer)
    {
      grammar.eliminateMidRuleActions();

      const int numberOfRules = grammar.getNumberOfRules();
      for(int i=0; i<numberOfRules; ++i)
      {
        const CFG::Rule &r = grammar.getRule(i);
        const int numberOfProductions = r.getNumberOfProductions();
        for(int j=0; j<numberOfProductions; ++j)
        {
          const CFG::Production &p = r.getProduction(j);
          const int numberOfSymbols = p.getNumberOfSymbols();
          Production q(i, j);
          if(numberOfSymbols)
          {
            const CFG::Symbol &s = p.getSymbol(numberOfSymbols-1);
            if(s.getType() == CFG::Symbol::action)
            {
              q.right.resize(numberOfSymbols-1);
              q.method = s.getIndex();
              q.args = s.getArgs();
            }
            else q.right.resize(numberOfSymbols);
          }
          for(unsigned k=0; k<q.right.size(); ++k)
          {
            const CFG::Symbol &s = p.getSymbol(k);
            switch(s.getType())
            {
            case CFG::Symbol::terminal:
              q.right[k] = s.getIndex();
              break;
            case CFG::Symbol::nonterminal:
              q.right[k] = -1-s.getIndex();
              break;
            case CFG::Symbol::action:
              ARCHON_THROW1(InternalException, "No actions should appear here");
            case CFG::Symbol::nil:
              ARCHON_THROW1(InternalException, "Nil-symbols should not appear here");       
            }
          }

          productions.push_back(q);
        }
      }
    }

    LrParserBase::~LrParserBase()
    {{ // The extra scope is needed to work around gcc3.2 bug #8287
    }}

    void LrParserBase::attrTypeError(int arg, int rule, int production,
                                     const type_info &actual,
                                     const type_info &expected) const
    {
      ARCHON_THROW1(AttributeTypeException,
                    "Argument " + Text::toString(arg) + " of " +
                    grammar.printProduction(rule, production) + " had type " +
                    actual.name() + " and should have type " + expected.name());
    }

    RefAnyConst LrParserBase::parse(LexerBase &lexer, Context *context, Logger *logger) const
    {
      if(actor && context && !actor->verifyContext(*context))
        ARCHON_THROW1(ArgumentException, "Invalid context type");

      vector<pair<int, RefAnyConst> > stateStack;
      pair<int, RefAnyConst> stackTop = make_pair(0, RefAnyConst(0));
      stateStack.push_back(stackTop);

      LexerBase::Lexeme lexeme;
      lexer.getNext(lexeme);
      for(;;)
      {
        const int action = getAction(stackTop.first, lexeme.type);
        if(action > -1)
        {
          // Shift
          if(logger) logger->log("Shift: " + grammar.printTerminal(lexeme.type));

          stackTop = make_pair(action, lexeme.value);
          stateStack.push_back(stackTop);
          lexer.getNext(lexeme);
        }
        else if(action < -2)
        {
          // Reduce
          const Production &p = productions[-3-action];

          if(logger) logger->log("Reduce: " + grammar.printProduction(p.rule, p.production));

          if(p.method > -4 && actor && context)
          {
            vector<RefAnyConst> args(p.args.size());
            for(unsigned i=0; i<p.args.size(); ++i)
              if(p.args[i]>=0) args[i] = (stateStack.end()-p.args[i]-1)->second;
            stateStack.resize(stateStack.size()-p.right.size()+1);
            try
            {
              if(p.method == -3)
              {
                // Concat
                const RefObject<ustring> *a1 =
                  dynamic_cast<const RefObject<ustring> *>(args[0].get());
                const RefObject<ustring> *a2 =
                  dynamic_cast<const RefObject<ustring> *>(args[1].get());
                if(!a1 && args[0])
                  ARCHON_THROW2(CallException, 0, typeid(RefObject<ustring>));
                if(!a2 && args[1])
                  ARCHON_THROW2(CallException, 1, typeid(RefObject<ustring>));
                stateStack.back().second =
                  !a1 ? a2 :
                  !a2 ? a1 : new RefObject<ustring>(a1->value + a2->value);
              }
              else if(p.method == -2)
              {
                // Copy
                stateStack.back().second = args[0];
              }
              else if(p.method == -1)
              {
                // Null
                stateStack.back().second = 0;
              }
              else
              {
                // User defined
                stateStack.back().second = actor->call(p.method, args, *context);
              }
            }
            catch(CallException &e)
            {
              attrTypeError(e.arg+1, p.rule, p.production,
                            typeid(*args[e.arg].get()), e.t);
            }

            if(logger && printer)
            {
              string s = "Action: " + actor->getMethodName(p.method) + "(";
              for(unsigned i=0; i<args.size(); ++i)
              {
                if(i) s += ", ";
                s += printer->print(args[i]);
              }
              s += ") = " + printer->print(stateStack.back().second);
              logger->log(s);
            }
          }
          else stateStack.resize(stateStack.size()-p.right.size()+1);

          stateStack.back().first = getGoto((stateStack.end()-2)->first, p.rule);
          stackTop = stateStack.back();
        }
        else if(action == -2)
        {
          // Accept
          if(logger && printer) logger->log("Accept: " + printer->print(stackTop.second));
          return stackTop.second;
        }
        else
        {
          // Error
          if(context) context->parserError();
          else if(logger)
          {
            if(lexeme.type == -1)
              logger->log("Syntax error. Unexpected end of input.");
            else
              logger->log("Syntax error. Unexpected symbol " +
                          Text::toString(Text::escapeNonprintable(lexer.getText())) +
                          ".");
          }
          return 0;
        }

        if(logger && printer)
        {
          string s = "Stack:";
          for(unsigned i=0; i<stateStack.size(); ++i)
            s += " " + printer->print(stateStack[i].second);
          logger->log(s);
        }
      }
    }
  }
}

---