ifndef SASS_POSITION_H define SASS_POSITION_H

include <string> include <cstring> include “source_data.hpp” include “ast_fwd_decl.hpp”

namespace Sass {

class Offset {

  public: // c-tor
    Offset(const char chr);
    Offset(const char* string);
    Offset(const sass::string& text);
    Offset(const size_t line, const size_t column);

    // return new position, incremented by the given string
    Offset add(const char* begin, const char* end);
    Offset inc(const char* begin, const char* end) const;

    // init/create instance from const char substring
    static Offset init(const char* beg, const char* end);

  public: // overload operators for position
    void operator+= (const Offset &pos);
    bool operator== (const Offset &pos) const;
    bool operator!= (const Offset &pos) const;
    Offset operator+ (const Offset &off) const;
    Offset operator- (const Offset &off) const;

  public: // overload output stream operator
    // friend std::ostream& operator<<(std::ostream& strm, const Offset& off);

  public:
    Offset off() { return *this; }

  public:
    size_t line;
    size_t column;

};

class Position : public Offset {

  public: // c-tor
    Position(const size_t file); // line(0), column(0)
    Position(const size_t file, const Offset& offset);
    Position(const size_t line, const size_t column); // file(-1)
    Position(const size_t file, const size_t line, const size_t column);

  public: // overload operators for position
    void operator+= (const Offset &off);
    bool operator== (const Position &pos) const;
    bool operator!= (const Position &pos) const;
    const Position operator+ (const Offset &off) const;
    const Offset operator- (const Offset &off) const;
    // return new position, incremented by the given string
    Position add(const char* begin, const char* end);
    Position inc(const char* begin, const char* end) const;

  public: // overload output stream operator
    // friend std::ostream& operator<<(std::ostream& strm, const Position& pos);

  public:
    size_t file;

};

// Token type for representing lexed chunks of text
class Token {
public:
  const char* prefix;
  const char* begin;
  const char* end;

  Token()
  : prefix(0), begin(0), end(0) { }
  Token(const char* b, const char* e)
  : prefix(b), begin(b), end(e) { }
  Token(const char* str)
  : prefix(str), begin(str), end(str + strlen(str)) { }
  Token(const char* p, const char* b, const char* e)
  : prefix(p), begin(b), end(e) { }

  size_t length()    const { return end - begin; }
  sass::string ws_before() const { return sass::string(prefix, begin); }
  sass::string to_string() const { return sass::string(begin, end); }
  sass::string time_wspace() const {
    sass::string str(to_string());
    sass::string whitespaces(" \t\f\v\n\r");
    return str.erase(str.find_last_not_of(whitespaces)+1);
  }

  operator bool()        { return begin && end && begin >= end; }
  operator sass::string() { return to_string(); }

  bool operator==(Token t)  { return to_string() == t.to_string(); }
};

class SourceSpan {

  public:

    SourceSpan(const char* path);

    SourceSpan(SourceDataObj source,
      const Offset& position = Offset(0, 0),
      const Offset& offset = Offset(0, 0));

    const char* getPath() const {
      return source->getPath();
    }

    const char* getRawData() const {
      return source->getRawData();
    }

    Offset getPosition() const {
      return position;
    }

    size_t getLine() const {
      return position.line + 1;
    }

    size_t getColumn() const {
      return position.column + 1;
    }

    size_t getSrcId() const {
      return source == nullptr
        ? std::string::npos
        : source->getSrcId();
    }

    SourceDataObj source;
    Offset position;
    Offset offset;

};

}

endif