---

la_parser_writer.cc

Go to the documentation of this file.

/*
 *  File:       la_parser_writer.cc
 *              $Id: la_parser_writer.cc,v 1.7 2002/06/26 20:48:28 alec Exp $
 *
 *  Author:     Alec Panoviciu (alecu@email.com)
 *
 *  Comments:
 *
 *  Revision history:
 *
 *  $Log: la_parser_writer.cc,v $
 *  Revision 1.7  2002/06/26 20:48:28  alec
 *  g++ 3.x happy
 *
 *  Revision 1.6  2002/06/23 23:32:49  alec
 *  la-time usercode (force)
 *
 *  Revision 1.5  2002/06/13 11:38:51  alec
 *  added #line stuff
 *
 *  Revision 1.4  2002/05/31 12:11:08  alec
 *  *** empty log message ***
 *
 *  Revision 1.3  2002/05/27 03:01:37  alec
 *  doc update
 *
 *  Revision 1.2  2002/05/22 01:37:05  alec
 *  LOOKAHEAD fixes
 *
 *  Revision 1.1  2002/05/16 22:04:46  alec
 *  parser generation done
 *
 */

/* 
  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 "la_parser_writer.hh"
#include "prop_registry.hh"
#include "parser_spec.hh"
#include "itoken_spec.hh"
#include "ebnf_node_algo.hh"
#include "ebnf_la_node.hh"
#include "token_spec.hh"

void LaParserWriter::writeParser (ParserSpec &pSpec, ITokenSpec &tSpec,
                                  const string &scannerClass)
{
  string throwClause;
  string includeMacro = className2macro(pSpec.className);
  
  if (registry["USE_EXCEPTIONS"]) throwClause = " throw (ScanException, ParseException)";

  // parser's .hh

  openStream(fullPath(className2hh(pSpec.className)));
  line() << "#ifndef " << includeMacro;
  line() << "#define " << includeMacro;
  line();
  line() << "#include <string>";
  line() << "#include <exception>";
  line() << "using namespace std;";
  line();
  line() << "#include \"" << className2hh(tSpec.className) << "\"";
  line() << "#include \"" << className2hh(scannerClass) << "\"";
  if (!pSpec.preambleCode.empty())
    writeChunk(pSpec.preambleCode);
  line() << "namespace cppcc";
  line() << "{";
  line();
  line() << "class ParseException : public exception";
  line() << "{";
  indent();
  line() << "public:";
  indent();
  line();
  line() << "ParseException (const string &message_ = \"Parse exception\") :";
  line() << "  message(message_)";
  line() << "{}";
  line();
  line() << "ParseException (const Position &pos_,";
  line() << "               const string &message_ = \"Parse exception\") :";
  line() << "  message(message_), pos(pos_)";
  line() << "{}";
  line();
  line() << "~ParseException () throw ()";
  line() << "{}";
  line();
  line() << "virtual operator string () const";
  line() << "{";
  indent();
  line() << "return string(pos) + \": \" + message;";
  unindent();
  line() << "}";
  line();
  line() << "virtual const char* what () throw ()";
  line() << "{";
  indent();
  line() << "return message.c_str();";
  unindent();
  line() << "}";
  line();
  line() << "virtual Position& where () throw ()";
  line() << "{";
  indent();
  line() << "return pos;";
  unindent();
  line() << "}";
  line();
  unindent();
  line() << "private:";
  line();
  indent();
  line() << "Position pos;";
  line() << "string message;";
  unindent();
  unindent();
  line() << "}; // end class PasreException";
  line();
  line();
  line() << "class " << pSpec.className << "_base";
  line() << "{";
  indent();
  line() << "protected:";
  indent();
  line() << "bool onParseError (ParseException &pex) { return false; }";
  unindent();
  unindent();
  line() << "};";
  line();
  line();
  line() << "class " << pSpec.className << " : public "
         << pSpec.className << "_base";
  if (!pSpec.inheritance.empty()) {
    ofs << ", ";
    writeChunk(pSpec.inheritance);
  }
  line() << "{";
  indent();
  line() << "public: // methods";
  indent();
  line();
  line() << pSpec.className << " (istream *in_ = NULL)" << throwClause << " :";
  line() << "   scanner(in_), _la(0)";
  line() << "{}";
  line();
  line() << "// productions entry points:";
  line();
  writeProductionDecls(pSpec.productions);
  line();
  line() << "// productions LA methods:";
  line();
  writeProductionLaDecls(pSpec.productions);
  line();
  line() << "// lookahead entry points:";
  line();
  writeLaEpDecls(pSpec.productions);
  line();
  unindent();
  line() << "private: // methods";
  indent();
  line();
  line() << "void consumeToken (int tId) " << throwClause;
  line() << "{";
  indent();
  if (registry["DEBUG_PARSER"])
    line() << "cerr << \"trying to match a \" << "
           << tSpec.className
           << "::tokenNames[tId] << \"(\" << tId << \") token with "
              " the current la which is \" << "
           << tSpec.className
           << "::tokenNames[scanner.la()->id] << \"(\" << scanner.la()->id << \")\" << endl;";
  line() << "if ((token = scanner.la())->id != tId)";
  line() << "{";
  indent();
  line() << "ParseException pex(scanner.la()->bPos, \"Parse error.\");";
  line() << "if (!onParseError(pex)) throw pex;";
  unindent();
  line() << "}";
  line() << "scanner.unchecked_consume();";
  unindent();
  line() << "}";
  line();
  line() << "bool laConsumeToken (int tId) " << throwClause;
  line() << "{";
  indent();
  if (registry["DEBUG_PARSER"])
    line() << "cerr << \"looking ahead for a \" << "
           << tSpec.className
           << "::tokenNames[tId] << \"(\" << tId << \") token; "
              "the current la is \" << "
           << tSpec.className
           << "::tokenNames[scanner.la()->id] << \"(\" << scanner.la()->id << \") @ \" << (string) scanner.la()->bPos << endl;";
  /*

    line() << "cerr << \"looking ahead for a \" << tId << \" token; "
      " the current la is \" << scanner.la()->id << endl;";
  */
  line() << "if (scanner.la()->id != tId) return false;";
  line() << "scanner.unchecked_consume();";
  line() << "return true;";
  unindent();
  line() << "}";
  line();
  
  unindent();
  line() << "public: // data";
  indent();
  line();
  line() << scannerClass << " scanner;";
  line() << "int _la;";
  line() << tSpec.className << " *token;";
  line();
  unindent();
  if (!pSpec.userCode.empty()) {
    line() << "private: // user code";
    line();
    for (int i = 0; i < pSpec.userCode.size(); i++)
      writeChunk(pSpec.userCode[i]);
    line();
  }
  unindent();
  line() << "}; //end class " << pSpec.className;
  line();
  line();
  line() << "} //end namespace cppcc";
  line();
  line();
  line() << "#endif // ifndef " << includeMacro;
  closeStream();
  
  // parser's .cc

  openStream(fullPath(className2cc(pSpec.className)));
  line();
  line() << "#include \"" << className2hh(pSpec.className) << "\"";
  line();
  writeProductionDefs(pSpec.productions, pSpec.className, tSpec);
  writeLaDefs(pSpec.productions, pSpec.className, tSpec, registry);
  line();
  closeStream();
  
}


void LaParserWriter::writeProductionDecls (vector<ProductionSpec> &prods)
{
  string throwXtra;
  bool useExcepts = false;
  
  if (registry["USE_EXCEPTIONS"]) {
    throwXtra = "ScanException, ParseException";
    useExcepts = true;
  }

  for (int i = 0; i < prods.size(); i++)
  {
    ProductionSpec &p = prods[i];
    line();
    if (p.retType.empty()) ofs << "void";
    else writeChunk(p.retType);
    line() << " " << p.name << " (";
    if (p.formalArgs.empty()) ofs << ")";
    else writeChunk(p.formalArgs, ")");
    if (!p.exceptList.empty() || useExcepts) {
      line() << "   throw (";
      if (!p.exceptList.empty()) {
        if (useExcepts) 
          writeChunk(p.exceptList, ", ") << throwXtra << ")";
        else 
          writeChunk(p.exceptList, ")");
      } else
        ofs << throwXtra << ")";
    }
    ofs << ";";
  }

}


void LaParserWriter::writeProductionLaDecls (vector<ProductionSpec> &prods)
{
  string throwClause;
  
  if (registry["USE_EXCEPTIONS"])
    throwClause = " throw (ScanException)";

  for (int i = 0; i < prods.size(); i++)
  {
    ProductionSpec &p = prods[i];
    if (p.expansion == NULL) {
      cerr << formatWarning(p.pos, string("Assuming lookahead for user-code production ") + p.name + " to be always true.") << endl;;
      line()  << "bool __la_" << p.name << "_ ()" << throwClause << "{ return true; };";
    } else
      line() << "bool __la_" << p.name << "_ ()" << throwClause << ";";
  }

}


class LaEpDeclWriter : public EbnfNodeAlgo
{
public:

  LaEpDeclWriter (LaParserWriter &pw_, const string throwClause_) :
    pw(pw_), throwClause(throwClause_)
  {}

  virtual bool operator() (EbnfNode &n) throw (EbnfNodeAlgoException)
  {
    EbnfLaNode &nn = dynamic_cast<EbnfLaNode&>(n);

    if ((nn.laSpec != NULL)  && (nn.laSpec->synLa != NULL))
    {
      if (nn.laSpec->ignore) {
        cerr << formatWarning(nn.getPos(), "Local lookahead at non-ambiguous choice point will be ignored.") << endl;
        return true;
      }
      NumberedLaSpec &la = dynamic_cast<NumberedLaSpec&>(*nn.laSpec);
      pw.line() << "bool __la_" << la.id << "_ (int depth)"
         << throwClause << ";";
    }
    return true;
  }
  
private:

  LaParserWriter &pw;
  const string &throwClause;
};


void LaParserWriter::writeLaEpDecls(vector<ProductionSpec> &prods)
{
  string throwClause;
  if (registry["USE_EXCEPTIONS"])
    throwClause = " throw (ScanException)";
  
  LaEpDeclWriter x(*this, throwClause);
  for (int i = 0; i < prods.size(); i++)
  {
    if (prods[i].expansion != NULL) {
      line() << "// LA entry points for " << prods[i].name;
      line();
      prods[i].expansion->dfTraverse(x);
    }
  }
  line();
}


ostream& LaParserWriter::makeLaCondition (vBitset &tMask,
                                          NumberedLaSpec *la,
                                          ITokenSpec &tokens)
{
  if (la != NULL && !la->ignore) {
    if (!la->semLa.empty()) {
      ofs << "(";
      writeChunk(la->semLa, ")") << " &&";
    }
    if (la->synLa != NULL) {
      ofs << "__la_" << la->id << "_(" << la->fixedLa << ")";
    }
  } else {
    if ((la != NULL) && !la->semLa.empty()) {
      // semantic la is always considered.
      ofs << "(";
      writeChunk(la->semLa, ")") << " && (";
    }
    vBitset::reference ti = tMask.begin();
    bool first = true;
    for (int tid = 0; ti.neq(tMask.end()); ti.next(), tid++)
      if (ti.get()) {
        if (!first) ofs << " || ";
        else first = false;
        ofs << "(scanner.la()->id == "
            << tokens.className << "::" << tokens[tid].name()
            << ")";
      }
    if ((la != NULL) && !la->semLa.empty())
      ofs << ")";
  }
  return ofs;
}
                                          


void LaParserWriter::writeEbnf (EbnfLaNode &n, ITokenSpec &tokens)
{
  if (!n.startCode.empty()) {
    line() << "{";
    writeChunk(n.startCode, "}");
  }
  
  if (n.catchList.size() != 0) {
    line() << "try {";
    indent();
  }
  
  if (typeid(n) == typeid(EbnfOrNode)) {
    EbnfOrNode &nn = dynamic_cast<EbnfOrNode&>(n);
    line() << "if (";
    makeLaCondition(nn.pre->first, nn.pre->laSpec, tokens) << ") {";
    indent();
    writeEbnf(*nn.pre, tokens);
    unindent();
    line() << "} else { ";
    indent();
    writeEbnf(*nn.post, tokens);
    unindent();
    line() << "}";
  } else if (typeid(n) == typeid(EbnfCatNode)) {
      EbnfCatNode &nn = dynamic_cast<EbnfCatNode&>(n);
      writeEbnf(*nn.pre, tokens);
      writeEbnf(*nn.post, tokens);
  } else if (typeid(n) == typeid(EbnfStarNode)) {
    EbnfStarNode &nn = dynamic_cast<EbnfStarNode&>(n);
    line() << "while (";
    makeLaCondition(nn.in->first, nn.in->laSpec, tokens) << ") {";
    indent();
    writeEbnf(*nn.in, tokens);
    unindent();
    line() << "}";
  } else if (typeid(n) == typeid(EbnfTerminalNode)) {
    EbnfTerminalNode &nn = dynamic_cast<EbnfTerminalNode&>(n);
    line() << "consumeToken(" << tokens.className << "::" << nn.terminal.name()
           << ");";
  } else if (typeid(n) == typeid(EbnfNonterminalNode)) {
    EbnfNonterminalNode &nn = dynamic_cast<EbnfNonterminalNode&>(n);
    line();
    if (!nn.targetVar.empty()) writeChunk(nn.targetVar, " = ");
    ofs << nn.nontermName << "(";
    if (nn.actualArgs.empty()) ofs << ");";
    else writeChunk(nn.actualArgs, ");");
  } else if (typeid(n) == typeid(EbnfLambdaNode)) {
    line() << " /* lambda */";
  } else ASSERT(0, "Bad typeid in LaParserWriter::writeEbnf !");

  if (n.catchList.size() != 0) {
    unindent();
    for (int i = 0; i < n.catchList.size(); i++) {
      if (i == 0) line () << "}";
      ofs << " catch (";
      writeChunk(n.catchList[i].exceptionDecl, ")") << " {";
      indent();
      writeChunk(n.catchList[i].code, ";");
      unindent();
      line() << "}";
    }
  }
  
  if (!n.endCode.empty()) {
    line() << "{";
    writeChunk(n.endCode, "}");
  }
}


void LaParserWriter::writeProductionDefs (vector<ProductionSpec> &prods,
                                          const string &parserClass,
                                          ITokenSpec &tokens)
{
  string throwXtra;
  bool useExcepts = false;
  
  if (registry["USE_EXCEPTIONS"]) {
    throwXtra = "ScanException, ParseException";
    useExcepts = true;
  }

  for (int i = 0; i < prods.size(); i++)
  {
    ProductionSpec &p = prods[i];
    line();
    if (p.retType.empty()) ofs << "void cppcc::";
    else writeChunk(p.retType, " cppcc::");
    ofs << parserClass << "::"
        << p.name << " (";
    if (p.formalArgs.empty()) ofs << ")";
    else writeChunk(p.formalArgs, ")");
    if (!p.exceptList.empty() || useExcepts) {
      line() << "    ";
      ofs << " throw (";
      if (!p.exceptList.empty()) {
        if (useExcepts) writeChunk(p.exceptList, ",") << throwXtra << ")";
        else writeChunk(p.exceptList, ")");
      } else
        ofs << throwXtra << ")";
    }
    line() << "{";
    indent();
    if (registry["DEBUG_PARSER"])
      line() << "cerr << \"Entering " << p.name << ".\" << endl;";
    if (!p.preambleCode.empty()) writeChunk(p.preambleCode, ";");
    if (p.expansion != NULL)
      writeEbnf(dynamic_cast<EbnfLaNode&>(*p.expansion), tokens);
    if (registry["DEBUG_PARSER"])
      line() << "cerr << \"Leaving " << p.name << ".\" << endl;";
    unindent();
    line() << "}";
    line();
    line();
  }
}


void LaParserWriter::writeEbnfLa (EbnfLaNode &n, ITokenSpec &tokens)
{
  if (n.forceStartCode && !n.startCode.empty()) {
    line() << "{";
    writeChunk(n.startCode, "}");
  }
  
  if (typeid(n) == typeid(EbnfOrNode)) {
    EbnfOrNode &nn = dynamic_cast<EbnfOrNode&>(n);
    line() << "if (";
    makeLaCondition(nn.pre->first, nn.pre->laSpec, tokens) << ") {";
    indent();
    writeEbnfLa(*nn.pre, tokens);
    unindent();
    line() << "} else { ";
    indent();
    writeEbnfLa(*nn.post, tokens);
    unindent();
    line() << "}";    
  } else if (typeid(n) == typeid(EbnfCatNode)) {
    EbnfCatNode &nn = dynamic_cast<EbnfCatNode&>(n);
    writeEbnfLa(*nn.pre, tokens);
    writeEbnfLa(*nn.post, tokens);
  } else if (typeid(n) == typeid(EbnfStarNode)) {
    EbnfStarNode &nn = dynamic_cast<EbnfStarNode&>(n);
    line() << "while (";
    makeLaCondition(nn.in->first, nn.in->laSpec, tokens) << ") {";
    indent();
    writeEbnfLa(*nn.in, tokens);
    unindent();
    line() << "}";
  } else if (typeid(n) == typeid(EbnfTerminalNode)) {
    EbnfTerminalNode &nn = dynamic_cast<EbnfTerminalNode&>(n);
    line() << "if (!laConsumeToken(" << tokens.className << "::"
           << nn.terminal.name() << ")) ";
    ofs << "goto __lookahead_fail_;";
    line() << "if (_la == 0) ";
    ofs << "goto __lookahead_succeed_;";
  } else if (typeid(n) == typeid(EbnfNonterminalNode)) {
    EbnfNonterminalNode &nn = dynamic_cast<EbnfNonterminalNode&>(n);
    line() << "if (!__la_" << nn.nontermName << "_()) ";
    ofs << "goto __lookahead_fail_;";
    line() << "if (_la == 0) ";
    ofs << "goto __lookahead_succeed_;";
  } else if (typeid(n) == typeid(EbnfLambdaNode)) {
    line() << " /* lambda */";
  } else ASSERT(0, "Bad typeid in LaParserWriter::writeEbnfLa !");

  if (n.forceEndCode && !n.endCode.empty()) {
    line() << "{";
    writeChunk(n.endCode, "}");
  }
}


class LaEpDefWriter : public EbnfNodeAlgo
{
public:

  LaEpDefWriter (const string &parserClass_, const string &throwClause_,
                 ITokenSpec &tokens_, LaParserWriter &pw_,
                 PropRegistry &registry_) :
    parserClass(parserClass_), throwClause(throwClause_), tokens(tokens_),
    pw(pw_), registry(registry_)
  {}

  virtual bool operator() (EbnfNode &n) throw (EbnfNodeAlgoException)
  {
    EbnfLaNode &nn = dynamic_cast<EbnfLaNode&>(n);

    if ((nn.laSpec != NULL)  && (nn.laSpec->synLa != NULL))
    {
      if (nn.laSpec->ignore)
        return true;

      NumberedLaSpec &la = dynamic_cast<NumberedLaSpec&>(*nn.laSpec);
      pw.line() << "bool cppcc::" << parserClass << "::__la_" << la.id
         << "_ (int depth)" << throwClause;
      pw.line() << "{";
      pw.indent();
      if (registry["DEBUG_PARSER"])
        pw.line() << "cerr << \"LOOKAHEAD#" << la.id
                  << "(\" << depth << \") ...\" << endl;";
      pw.line() << "int _laSave = _la;";
      pw.line() << "_la = depth;";
      pw.line() << "scanner.setMarker();";
      pw.line();
      pw.writeEbnfLa(dynamic_cast<EbnfLaNode&>(*nn.laSpec->synLa),
                     tokens);
      pw.line() << "goto __lookahead_succeed_;";
      pw.line();
      pw.unindent();
      pw.line() << "__lookahead_fail_:";
      pw.indent();
      if (registry["DEBUG_PARSER"])
        pw.line() << "cerr << \"LOOKAHEAD#" << la.id
                  << "(\" << depth << \") FAILED\" << endl;";
      pw.line() << "_la = _laSave;";
      pw.line() << "scanner.rewindToMarker();";
      if (registry["DEBUG_PARSER"])
        pw.line() << "if (_la == 0) cerr << \"Back in parsing mode.\" << endl;";
      pw.line() << "return false;";
      pw.unindent();
      pw.line();
      pw.line() << "__lookahead_succeed_:";
      pw.indent();
      if (registry["DEBUG_PARSER"])
        pw.line() << "cerr << \"LOOKAHEAD#" << la.id
                  << "(\" << depth << \") SUCCEEDED\" << endl;";
      pw.line() << "_la = _laSave;";
      pw.line() << "scanner.rewindToMarker();";
      if (registry["DEBUG_PARSER"])
        pw.line() << "if (_la == 0) cerr << \"Back in parsing mode.\" << endl;";
      pw.line() << "return true;";
      pw.unindent();
      pw.line() << "}";
      pw.line();
      pw.line();
    }
    return true;
  }

private:

  PropRegistry &registry;
  string parserClass;
  string throwClause;
  ITokenSpec &tokens;
  LaParserWriter &pw;
};


void LaParserWriter::writeLaDefs (vector<ProductionSpec> &prods,
                                  const string &parserClass,
                                  ITokenSpec &tokens, PropRegistry &registry)
{
  string throwClause;
  
  if (registry["USE_EXCEPTIONS"])
    throwClause = " throw (ScanException)";

  LaEpDefWriter x(parserClass, throwClause, tokens, *this, registry);

  for (int i = 0; i < prods.size(); i++)
  {
    ProductionSpec &p = prods[i];
    if (p.expansion == NULL) continue;
    
    line() << "bool cppcc::" << parserClass << "::__la_" << p.name
           << "_ ()" << throwClause;
    line() << "{";
    indent();
    if (registry["DEBUG_PARSER"])
      line() << "cerr << \"Looking ahead for a " << p.name << ".\" << endl;";
    writeEbnfLa(*p.expansion, tokens);
    line();
    line() << "__lookahead_succeed_:";
    indent();
    if (registry["DEBUG_PARSER"])
      line() << "cerr << \"Lookahead for " << p.name << " succeeded.\" << endl;";
    line() << "return true;";
    line();
    unindent();
    line() << "__lookahead_fail_:";
    indent();
    if (registry["DEBUG_PARSER"])
      line() << "cerr << \"Lookahead for " << p.name << " failed.\" << endl;";
    line() << "return false;";
    unindent();
    unindent();
    line() << "}";
    line();
    line();
    p.expansion->dfTraverse(x);
  }
}

---