tokenlist.hpp

/*
 * tokenlist.hpp
 *
 * Created on: 11 Jan 2011
 * Author: Holger Schmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek 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 3 of the License, or
 * (at your option) any later version.
 *
 * Schnek 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 Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_TOKENLIST_HPP_
#define SCHNEK_TOKENLIST_HPP_

#include <memory>
#include <list>
#include <string>
#include <iostream>
#include "deckgrammar.hpp"

namespace schnek {

/* Stores an individual token.
 *
 * Along with the token id and a string value (for identifiers of string literals)
 * the location of the token is also stored by filename and line.
 */
class Token
{
  public:
    // default constructor
    Token() {}

    Token(std::string filename_, int line_, int token_, std::string str_ = "")
        : filename(filename_), line(line_), token(token_), str(str_) {
      // std::cerr << "Creating token " << token << " in line " << line << " ("<<str<<")\n";
      if (token==PATHIDENTIFIER) token = IDENTIFIER;
    }

    Token(const Token &t)
      : filename(t.filename), line(t.line), token(t.token), str(t.str) {}

    Token& operator=(const Token &t)
    {
      filename = t.filename;
      line = t.line;
      token = t.token;
      str = t.str;
      return *this;
    }

    std::string getFilename() const
    {
        return filename;
    }

    int getLine() const
    {
        return line;
    }

    int getToken() const
    {
        return token;
    }

    std::string getString() const
    {
        return str;
    }

private:
    std::string filename;
    int line;
    int token;
    std::string str;
};

typedef std::shared_ptr<Token> pToken;

/* Contains a list of parser tokens.
 *
 * The list is filled by the scanner i.e. DeckScanner and then read by the
 * parser, i.e. DeckParser
 *
 * Tokens are stored together with the line numbers to allow user friendly
 * error messages.
 */
class TokenList
{
  private:
    std::list<Token> tlist;
    std::string filename;
  public:
    typedef std::list<Token>::const_iterator const_iterator;

    TokenList(std::string filename_) : filename(filename_) {}


    void reset(std::string filename_)
    {
      tlist.clear();
      filename = filename_;
    }


    void reset()
    {
      tlist.clear();
    }

    void insert(int line, int token)
    {
      tlist.push_back(Token(filename, line, token));
    }

    /* Insert a token that is associated with a string onto the list.
     *
     * This stores tokens such as identifiers or string literals.
     */
    void insert(int line, int token, char *str, size_t len)
    {
      tlist.push_back(Token(filename, line, token, std::string(str,len)));
    }

    /* Insert another list of tokens in front of the current one.
     *
     * This is used when encountering include statements
     */
    void insert(const TokenList &tokens)
    {
      tlist.insert(tlist.begin(), tokens.begin(), tokens.end());
    }

    const_iterator begin() const
    {
      return tlist.begin();
    }

    const_iterator end() const
    {
      return tlist.end();
    }
};

} // namespace

#endif // SCHNEK_TOKENLIST_HPP_