TransitionLexer.hxx

Go to the documentation of this file.

#ifndef TRANSITIONLEXER_HXX
#define TRANSITIONLEXER_HXX

/**************************************************************************
 *
 * Copyright (C) 2010, Jonathan S. Shapiro
 * Portions Copyright (C) 2008, Johns Hopkins University
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 *   - Redistributions of source code must contain the above 
 *     copyright notice, this list of conditions, and the following
 *     disclaimer. 
 *
 *   - Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions, and the following
 *     disclaimer in the documentation and/or other materials 
 *     provided with the distribution.
 *
 *   - Neither the names of the copyright holders nor the names of any
 *     of any contributors may be used to endorse or promote products
 *     derived from this software without specific prior written
 *     permission. 
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 **************************************************************************/

#include <iostream>

#include "ParseType.hxx"
#include "libsherpa/EnumSet.hxx"

typedef long ucs4_t;

class PushBack {
  // Needs to be the size of the largest token that we might have to
  // push back due to layout, but not less than four.
  std::vector<ucs4_t> stack;

public:
  inline void push(ucs4_t c) {
    stack.push_back(c);
  }

  inline long pop() {
    if (stack.size() == 0)
      return -1;
    ucs4_t c = stack[stack.size()-1];
    stack.pop_back();
    return c;
  }

  PushBack() {
  }
};

enum LayoutFlagValues {
  CHECK_FIRST_TOKEN = 0x1u,
};
typedef sherpa::EnumSet<LayoutFlagValues> LayoutFlags;


struct LayoutFrame : public boost::enable_shared_from_this<LayoutFrame> {
  bool inserted;              // true IFF left curly was inserted
  unsigned column;            // column of first token after '{'
  int precedingToken;         // token that preceded this '{'
  sherpa::LToken tok;         // copy of opening { token, for location

  boost::shared_ptr<LayoutFrame> next;

  static inline boost::shared_ptr<LayoutFrame>
  make(int _precedingToken, bool _inserted, unsigned _column, 
       const sherpa::LToken& tok) {
    LayoutFrame *lf = new LayoutFrame;

    lf->inserted = _inserted;
    lf->precedingToken = _precedingToken;
    lf->column = _column;
    lf->tok = tok;

    return boost::shared_ptr<LayoutFrame>(lf);
  }
};

struct TransitionLexer {
private:
  int lastTokType;

  sherpa::LToken lastToken;
public:
  sherpa::LToken getLastToken()
  { return lastToken; }

  // Hack to work around crappy Bison/Yacc error handling strategy:
  bool showNextError;

  boost::shared_ptr<LayoutFrame> layoutStack;
  bool atBeginningOfLine;

  void beginBlock(const sherpa::LToken& tok);
  void endBlock(const sherpa::LToken& tok);

private:
  bool closeToOffset(unsigned offset);
  bool conditionallyInsertSemicolon(unsigned offset);


public:
  enum LangFlagsValues {
    lf_block = 0x1u,
    lf_version = 0x2u
  };

  typedef sherpa::EnumSet<LangFlagsValues> LangFlags;

  LangFlags currentLang;

  sherpa::LexLoc here;

  int num_errors;
  bool debug;
  bool isRuntimeUoc;
  bool ifIdentMode;
  bool isCommandLineInput;
  std::istream& inStream;
  std::ostream& errStream;

  unsigned nModules;

private:
  std::string thisToken;

  PushBack pushBackStack;

  ucs4_t getChar();
  void ungetChar(ucs4_t);
  void ungetThisToken();

  bool valid_ascii_symbol(ucs4_t ucs4);

  bool valid_operator_start(ucs4_t ucs4);
  bool valid_operator_continue(ucs4_t ucs4);

  bool valid_ident_start(ucs4_t ucs4);
  bool valid_ident_continue(ucs4_t ucs4);
  bool valid_ifident_start(ucs4_t ucs4);
  bool valid_ifident_continue(ucs4_t ucs4);
  bool valid_tv_ident_start(ucs4_t ucs4);
  bool valid_tv_ident_continue(ucs4_t ucs4);
public:

  TransitionLexer(std::ostream& errStream, std::istream& inStream, 
             const std::string& origin,
             bool commandLineInput);

  void ReportParseError(const sherpa::LexLoc& loc, std::string  msg);
  void ReportParseWarning(const sherpa::LexLoc& loc, std::string msg);

  void ReportParseError();
  void ReportParseError(std::string msg)
  {
    ReportParseError(lastToken.loc, msg);
  }
  inline void ReportParseWarning(std::string msg)
  {
    ReportParseWarning(lastToken.loc, msg);
  }

  inline void setDebug(bool showlex)
  {
    debug = (showlex ? true : false);
  }

  inline void setIfIdentMode(bool arg)
  {
    ifIdentMode = arg;
  }

  int lex(ParseType *yylvalp);

  ~TransitionLexer() {}

  struct KeyWord {
    const char *nm;
    LangFlags whichLang;
    int tokValue;

    KeyWord(const char *_nm, LangFlags _whichLang, int _tokValue);
  };

private:
  static KeyWord keywords[];

  int kwCheck(const char *s, int identType);

  sherpa::LexLoc skipWhiteSpaceAndComments();

  sherpa::LToken getNextToken();

  void showToken(std::ostream& errStream, const sherpa::LToken& tok);

  std::vector<sherpa::LToken> pushbackTokens;
  inline bool havePushbackToken()
  {
    return (pushbackTokens.size() != 0);
  }

public:
  void pushTokenBack(const sherpa::LToken& tok, bool verbose = false);

private:
  sherpa::LToken popToken();

  sherpa::LToken getNextInputToken();
};

#endif /* TRANSITIONLEXER_HXX */

---