#ifndef SASS_AST_H

#define SASS_AST_H

#include "sass.hpp"

#include <set>

#include <deque>

#include <vector>

#include <string>

#include <sstream>

#include <iostream>

#include <typeinfo>

#include <algorithm>

#include "sass/base.h"

#include "ast_fwd_decl.hpp"

#ifdef DEBUG_SHARED_PTR

#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \

  virtual klass##_Ptr copy(std::string, size_t) const = 0; \

  virtual klass##_Ptr clone(std::string, size_t) const = 0; \

#define ATTACH_AST_OPERATIONS(klass) \

  virtual klass##_Ptr copy(std::string, size_t) const; \

  virtual klass##_Ptr clone(std::string, size_t) const; \

#else

#define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \

  virtual klass##_Ptr copy() const = 0; \

  virtual klass##_Ptr clone() const = 0; \

#define ATTACH_AST_OPERATIONS(klass) \

  virtual klass##_Ptr copy() const; \

  virtual klass##_Ptr clone() const; \

#endif

#ifdef __clang__

/*

 * There are some overloads used here that trigger the clang overload

 * hiding warning. Specifically:

 *

 * Type type() which hides string type() from Expression

 *

 */

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Woverloaded-virtual"

#endif

#include "util.hpp"

#include "units.hpp"

#include "context.hpp"

#include "position.hpp"

#include "constants.hpp"

#include "operation.hpp"

#include "position.hpp"

#include "inspect.hpp"

#include "source_map.hpp"

#include "environment.hpp"

#include "error_handling.hpp"

#include "ast_def_macros.hpp"

#include "ast_fwd_decl.hpp"

#include "source_map.hpp"

#include "sass.h"

namespace Sass {

  // easier to search with name

  const bool DELAYED = true;

  // ToDo: should this really be hardcoded

  // Note: most methods follow precision option

  const double NUMBER_EPSILON = 0.00000000000001;

  // ToDo: where does this fit best?

  // We don't share this with C-API?

  class Operand {

    public:

      Operand(Sass_OP operand, bool ws_before = false, bool ws_after = false)

      : operand(operand), ws_before(ws_before), ws_after(ws_after)

      { }

    public:

      enum Sass_OP operand;

      bool ws_before;

      bool ws_after;

  };

  //////////////////////////////////////////////////////////

  // `hash_combine` comes from boost (functional/hash):

  // http://www.boost.org/doc/libs/1_35_0/doc/html/hash/combine.html

  // Boost Software License - Version 1.0

  // http://www.boost.org/users/license.html

  template <typename T>

  void hash_combine (std::size_t& seed, const T& val)

  {

    seed ^= std::hash<T>()(val) + 0x9e3779b9

             + (seed<<6) + (seed>>2);

  }

  //////////////////////////////////////////////////////////

  //////////////////////////////////////////////////////////

  // Abstract base class for all abstract syntax tree nodes.

  //////////////////////////////////////////////////////////

  class AST_Node : public SharedObj {

    ADD_PROPERTY(ParserState, pstate)

  public:

    AST_Node(ParserState pstate)

    : pstate_(pstate)

    { }

    AST_Node(const AST_Node* ptr)

    : pstate_(ptr->pstate_)

    { }

    // AST_Node(AST_Node& ptr) = delete;

    virtual ~AST_Node() = 0;

    virtual size_t hash() { return 0; }

    ATTACH_VIRTUAL_AST_OPERATIONS(AST_Node);

    virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }

    virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }

    virtual const std::string to_string(Sass_Inspect_Options opt) const;

    virtual const std::string to_string() const;

    virtual void cloneChildren() {};

    // generic find function (not fully implemented yet)

    // ToDo: add specific implementions to all children

    virtual bool find ( bool (*f)(AST_Node_Obj) ) { return f(this); };

  public:

    void update_pstate(const ParserState& pstate);

  public:

    Offset off() { return pstate(); }

    Position pos() { return pstate(); }

    ATTACH_OPERATIONS()

  };

  inline AST_Node::~AST_Node() { }

  //////////////////////////////////////////////////////////////////////

  // define cast template now (need complete type)

  //////////////////////////////////////////////////////////////////////

  template<class T>

  T* Cast(AST_Node* ptr) {

    return ptr && typeid(T) == typeid(*ptr) ?

           static_cast<T*>(ptr) : NULL;

  };

  template<class T>

  const T* Cast(const AST_Node* ptr) {

    return ptr && typeid(T) == typeid(*ptr) ?

           static_cast<const T*>(ptr) : NULL;

  };

  //////////////////////////////////////////////////////////////////////

  // Abstract base class for expressions. This side of the AST hierarchy

  // represents elements in value contexts, which exist primarily to be

  // evaluated and returned.

  //////////////////////////////////////////////////////////////////////

  class Expression : public AST_Node {

  public:

    enum Concrete_Type {

      NONE,

      BOOLEAN,

      NUMBER,

      COLOR,

      STRING,

      LIST,

      MAP,

      SELECTOR,

      NULL_VAL,

      C_WARNING,

      C_ERROR,

      FUNCTION,

      VARIABLE,

      NUM_TYPES

    };

    enum Simple_Type {

      SIMPLE,

      ATTR_SEL,

      PSEUDO_SEL,

      WRAPPED_SEL,

    };

  private:

    // expressions in some contexts shouldn't be evaluated

    ADD_PROPERTY(bool, is_delayed)

    ADD_PROPERTY(bool, is_expanded)

    ADD_PROPERTY(bool, is_interpolant)

    ADD_PROPERTY(Concrete_Type, concrete_type)

  public:

    Expression(ParserState pstate,

               bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)

    : AST_Node(pstate),

      is_delayed_(d),

      is_expanded_(e),

      is_interpolant_(i),

      concrete_type_(ct)

    { }

    Expression(const Expression* ptr)

    : AST_Node(ptr),

      is_delayed_(ptr->is_delayed_),

      is_expanded_(ptr->is_expanded_),

      is_interpolant_(ptr->is_interpolant_),

      concrete_type_(ptr->concrete_type_)

    { }

    virtual operator bool() { return true; }

    virtual ~Expression() { }

    virtual std::string type() const { return ""; /* TODO: raise an error? */ }

    virtual bool is_invisible() const { return false; }

    static std::string type_name() { return ""; }

    virtual bool is_false() { return false; }

    // virtual bool is_true() { return !is_false(); }

    virtual bool operator== (const Expression& rhs) const { return false; }

    virtual bool eq(const Expression& rhs) const { return *this == rhs; };

    virtual void set_delayed(bool delayed) { is_delayed(delayed); }

    virtual bool has_interpolant() const { return is_interpolant(); }

    virtual bool is_left_interpolant() const { return is_interpolant(); }

    virtual bool is_right_interpolant() const { return is_interpolant(); }

    virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }

    virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }

    ATTACH_VIRTUAL_AST_OPERATIONS(Expression);

    virtual size_t hash() { return 0; }

  };

  //////////////////////////////////////////////////////////////////////

  // Still just an expression, but with a to_string method

  //////////////////////////////////////////////////////////////////////

  class PreValue : public Expression {

  public:

    PreValue(ParserState pstate,

               bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)

    : Expression(pstate, d, e, i, ct)

    { }

    PreValue(const PreValue* ptr)

    : Expression(ptr)

    { }

    ATTACH_VIRTUAL_AST_OPERATIONS(PreValue);

    virtual ~PreValue() { }

  };

  //////////////////////////////////////////////////////////////////////

  // base class for values that support operations

  //////////////////////////////////////////////////////////////////////

  class Value : public Expression {

  public:

    Value(ParserState pstate,

          bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)

    : Expression(pstate, d, e, i, ct)

    { }

    Value(const Value* ptr)

    : Expression(ptr)

    { }

    ATTACH_VIRTUAL_AST_OPERATIONS(Value);

    virtual bool operator== (const Expression& rhs) const = 0;

  };

}

/////////////////////////////////////////////////////////////////////////////////////

// Hash method specializations for std::unordered_map to work with Sass::Expression

/////////////////////////////////////////////////////////////////////////////////////

namespace std {

  template<>

  struct hash<Sass::Expression_Obj>

  {

    size_t operator()(Sass::Expression_Obj s) const

    {

      return s->hash();

    }

  };

  template<>

  struct equal_to<Sass::Expression_Obj>

  {

    bool operator()( Sass::Expression_Obj lhs,  Sass::Expression_Obj rhs) const

    {

      return lhs->hash() == rhs->hash();

    }

  };

}

namespace Sass {

  /////////////////////////////////////////////////////////////////////////////

  // Mixin class for AST nodes that should behave like vectors. Uses the

  // "Template Method" design pattern to allow subclasses to adjust their flags

  // when certain objects are pushed.

  /////////////////////////////////////////////////////////////////////////////

  template <typename T>

  class Vectorized {

    std::vector<T> elements_;

  protected:

    size_t hash_;

    void reset_hash() { hash_ = 0; }

    virtual void adjust_after_pushing(T element) { }

  public:

    Vectorized(size_t s = 0) : elements_(std::vector<T>()), hash_(0)

    { elements_.reserve(s); }

    virtual ~Vectorized() = 0;

    size_t length() const   { return elements_.size(); }

    bool empty() const      { return elements_.empty(); }

    void clear()            { return elements_.clear(); }

    T last() const          { return elements_.back(); }

    T first() const         { return elements_.front(); }

    T& operator[](size_t i) { return elements_[i]; }

    virtual const T& at(size_t i) const { return elements_.at(i); }

    virtual T& at(size_t i) { return elements_.at(i); }

    const T& operator[](size_t i) const { return elements_[i]; }

    virtual void append(T element)

    {

      if (element) {

        reset_hash();

        elements_.push_back(element);

        adjust_after_pushing(element);

      }

    }

    virtual void concat(Vectorized* v)

    {

      for (size_t i = 0, L = v->length(); i < L; ++i) this->append((*v)[i]);

    }

    Vectorized& unshift(T element)

    {

      elements_.insert(elements_.begin(), element);

      return *this;

    }

    std::vector<T>& elements() { return elements_; }

    const std::vector<T>& elements() const { return elements_; }

    std::vector<T>& elements(std::vector<T>& e) { elements_ = e; return elements_; }

    virtual size_t hash()

    {

      if (hash_ == 0) {

        for (T& el : elements_) {

          hash_combine(hash_, el->hash());

        }

      }

      return hash_;

    }

    typename std::vector<T>::iterator end() { return elements_.end(); }

    typename std::vector<T>::iterator begin() { return elements_.begin(); }

    typename std::vector<T>::const_iterator end() const { return elements_.end(); }

    typename std::vector<T>::const_iterator begin() const { return elements_.begin(); }

    typename std::vector<T>::iterator erase(typename std::vector<T>::iterator el) { return elements_.erase(el); }

    typename std::vector<T>::const_iterator erase(typename std::vector<T>::const_iterator el) { return elements_.erase(el); }

  };

  template <typename T>

  inline Vectorized<T>::~Vectorized() { }

  /////////////////////////////////////////////////////////////////////////////

  // Mixin class for AST nodes that should behave like a hash table. Uses an

  // extra <std::vector> internally to maintain insertion order for interation.

  /////////////////////////////////////////////////////////////////////////////

  class Hashed {

  private:

    ExpressionMap elements_;

    std::vector<Expression_Obj> list_;

  protected:

    size_t hash_;

    Expression_Obj duplicate_key_;

    void reset_hash() { hash_ = 0; }

    void reset_duplicate_key() { duplicate_key_ = 0; }

    virtual void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) { }

  public:

    Hashed(size_t s = 0)

    : elements_(ExpressionMap(s)),

      list_(std::vector<Expression_Obj>()),

      hash_(0), duplicate_key_(NULL)

    { elements_.reserve(s); list_.reserve(s); }

    virtual ~Hashed();

    size_t length() const                  { return list_.size(); }

    bool empty() const                     { return list_.empty(); }

    bool has(Expression_Obj k) const          { return elements_.count(k) == 1; }

    Expression_Obj at(Expression_Obj k) const;

    bool has_duplicate_key() const         { return duplicate_key_ != 0; }

    Expression_Obj get_duplicate_key() const  { return duplicate_key_; }

    const ExpressionMap elements() { return elements_; }

    Hashed& operator<<(std::pair<Expression_Obj, Expression_Obj> p)

    {

      reset_hash();

      if (!has(p.first)) list_.push_back(p.first);

      else if (!duplicate_key_) duplicate_key_ = p.first;

      elements_[p.first] = p.second;

      adjust_after_pushing(p);

      return *this;

    }

    Hashed& operator+=(Hashed* h)

    {

      if (length() == 0) {

        this->elements_ = h->elements_;

        this->list_ = h->list_;

        return *this;

      }

      for (auto key : h->keys()) {

        *this << std::make_pair(key, h->at(key));

      }

      reset_duplicate_key();

      return *this;

    }

    const ExpressionMap& pairs() const { return elements_; }

    const std::vector<Expression_Obj>& keys() const { return list_; }

//    std::unordered_map<Expression_Obj, Expression_Obj>::iterator end() { return elements_.end(); }

//    std::unordered_map<Expression_Obj, Expression_Obj>::iterator begin() { return elements_.begin(); }

//    std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator end() const { return elements_.end(); }

//    std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator begin() const { return elements_.begin(); }

  };

  inline Hashed::~Hashed() { }

  /////////////////////////////////////////////////////////////////////////

  // Abstract base class for statements. This side of the AST hierarchy

  // represents elements in expansion contexts, which exist primarily to be

  // rewritten and macro-expanded.

  /////////////////////////////////////////////////////////////////////////

  class Statement : public AST_Node {

  public:

    enum Statement_Type {

      NONE,

      RULESET,

      MEDIA,

      DIRECTIVE,

      SUPPORTS,

      ATROOT,

      BUBBLE,

      CONTENT,

      KEYFRAMERULE,

      DECLARATION,

      ASSIGNMENT,

      IMPORT_STUB,

      IMPORT,

      COMMENT,

      WARNING,

      RETURN,

      EXTEND,

      ERROR,

      DEBUGSTMT,

      WHILE,

      EACH,

      FOR,

      IF

    };

  private:

    ADD_PROPERTY(Statement_Type, statement_type)

    ADD_PROPERTY(size_t, tabs)

    ADD_PROPERTY(bool, group_end)

  public:

    Statement(ParserState pstate, Statement_Type st = NONE, size_t t = 0)

    : AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)

     { }

    Statement(const Statement* ptr)

    : AST_Node(ptr),

      statement_type_(ptr->statement_type_),

      tabs_(ptr->tabs_),

      group_end_(ptr->group_end_)

     { }

    virtual ~Statement() = 0;

    // needed for rearranging nested rulesets during CSS emission

    virtual bool   is_invisible() const { return false; }

    virtual bool   bubbles() { return false; }

    virtual bool has_content()

    {

      return statement_type_ == CONTENT;

    }

  };

  inline Statement::~Statement() { }

  ////////////////////////

  // Blocks of statements.

  ////////////////////////

  class Block : public Statement, public Vectorized<Statement_Obj> {

    ADD_PROPERTY(bool, is_root)

    // needed for properly formatted CSS emission

  protected:

    void adjust_after_pushing(Statement_Obj s)

    {

    }

  public:

    Block(ParserState pstate, size_t s = 0, bool r = false)

    : Statement(pstate),

      Vectorized<Statement_Obj>(s),

      is_root_(r)

    { }

    Block(const Block* ptr)

    : Statement(ptr),

      Vectorized<Statement_Obj>(*ptr),

      is_root_(ptr->is_root_)

    { }

    virtual bool has_content()

    {

      for (size_t i = 0, L = elements().size(); i < L; ++i) {

        if (elements()[i]->has_content()) return true;

      }

      return Statement::has_content();

    }

    ATTACH_AST_OPERATIONS(Block)

    ATTACH_OPERATIONS()

  };

  ////////////////////////////////////////////////////////////////////////

  // Abstract base class for statements that contain blocks of statements.

  ////////////////////////////////////////////////////////////////////////

  class Has_Block : public Statement {

    ADD_PROPERTY(Block_Obj, block)

  public:

    Has_Block(ParserState pstate, Block_Obj b)

    : Statement(pstate), block_(b)

    { }

    Has_Block(const Has_Block* ptr)

    : Statement(ptr), block_(ptr->block_)

    { }

    virtual bool has_content()

    {

      return (block_ && block_->has_content()) || Statement::has_content();

    }

    virtual ~Has_Block() = 0;

  };

  inline Has_Block::~Has_Block() { }

  /////////////////////////////////////////////////////////////////////////////

  // Rulesets (i.e., sets of styles headed by a selector and containing a block

  // of style declarations.

  /////////////////////////////////////////////////////////////////////////////

  class Ruleset : public Has_Block {

    ADD_PROPERTY(Selector_List_Obj, selector)

    ADD_PROPERTY(bool, is_root);

  public:

    Ruleset(ParserState pstate, Selector_List_Obj s = 0, Block_Obj b = 0)

    : Has_Block(pstate, b), selector_(s), is_root_(false)

    { statement_type(RULESET); }

    Ruleset(const Ruleset* ptr)

    : Has_Block(ptr),

      selector_(ptr->selector_),

      is_root_(ptr->is_root_)

    { statement_type(RULESET); }

    bool is_invisible() const;

    ATTACH_AST_OPERATIONS(Ruleset)

    ATTACH_OPERATIONS()

  };

  /////////////////

  // Bubble.

  /////////////////

  class Bubble : public Statement {

    ADD_PROPERTY(Statement_Obj, node)

    ADD_PROPERTY(bool, group_end)

  public:

    Bubble(ParserState pstate, Statement_Obj n, Statement_Obj g = 0, size_t t = 0)

    : Statement(pstate, Statement::BUBBLE, t), node_(n), group_end_(g == 0)

    { }

    Bubble(const Bubble* ptr)

    : Statement(ptr),

      node_(ptr->node_),

      group_end_(ptr->group_end_)

    { }

    bool bubbles() { return true; }

    ATTACH_AST_OPERATIONS(Bubble)

    ATTACH_OPERATIONS()

  };

  /////////////////

  // Trace.

  /////////////////

  class Trace : public Has_Block {

    ADD_CONSTREF(std::string, name)

  public:

    Trace(ParserState pstate, std::string n, Block_Obj b = 0)

    : Has_Block(pstate, b), name_(n)

    { }

    Trace(const Trace* ptr)

    : Has_Block(ptr),

      name_(ptr->name_)

    { }

    ATTACH_AST_OPERATIONS(Trace)

    ATTACH_OPERATIONS()

  };

  /////////////////

  // Media queries.

  /////////////////

  class Media_Block : public Has_Block {

    ADD_PROPERTY(List_Obj, media_queries)

  public:

    Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b)

    : Has_Block(pstate, b), media_queries_(mqs)

    { statement_type(MEDIA); }

    Media_Block(const Media_Block* ptr)

    : Has_Block(ptr), media_queries_(ptr->media_queries_)

    { statement_type(MEDIA); }

    bool bubbles() { return true; }

    bool is_invisible() const;

    ATTACH_AST_OPERATIONS(Media_Block)

    ATTACH_OPERATIONS()

  };

  ///////////////////////////////////////////////////////////////////////

  // At-rules -- arbitrary directives beginning with "@" that may have an

  // optional statement block.

  ///////////////////////////////////////////////////////////////////////

  class Directive : public Has_Block {

    ADD_CONSTREF(std::string, keyword)

    ADD_PROPERTY(Selector_List_Obj, selector)

    ADD_PROPERTY(Expression_Obj, value)

  public:

    Directive(ParserState pstate, std::string kwd, Selector_List_Obj sel = 0, Block_Obj b = 0, Expression_Obj val = 0)

    : Has_Block(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed

    { statement_type(DIRECTIVE); }

    Directive(const Directive* ptr)

    : Has_Block(ptr),

      keyword_(ptr->keyword_),

      selector_(ptr->selector_),

      value_(ptr->value_) // set value manually if needed

    { statement_type(DIRECTIVE); }

    bool bubbles() { return is_keyframes() || is_media(); }

    bool is_media() {

      return keyword_.compare("@-webkit-media") == 0 ||

             keyword_.compare("@-moz-media") == 0 ||

             keyword_.compare("@-o-media") == 0 ||

             keyword_.compare("@media") == 0;

    }

    bool is_keyframes() {

      return keyword_.compare("@-webkit-keyframes") == 0 ||

             keyword_.compare("@-moz-keyframes") == 0 ||

             keyword_.compare("@-o-keyframes") == 0 ||

             keyword_.compare("@keyframes") == 0;

    }

    ATTACH_AST_OPERATIONS(Directive)

    ATTACH_OPERATIONS()

  };

  ///////////////////////////////////////////////////////////////////////

  // Keyframe-rules -- the child blocks of "@keyframes" nodes.

  ///////////////////////////////////////////////////////////////////////

  class Keyframe_Rule : public Has_Block {

    // according to css spec, this should be <keyframes-name>

    // <keyframes-name> = <custom-ident> | <string>

    ADD_PROPERTY(Selector_List_Obj, name)

  public:

    Keyframe_Rule(ParserState pstate, Block_Obj b)

    : Has_Block(pstate, b), name_()

    { statement_type(KEYFRAMERULE); }

    Keyframe_Rule(const Keyframe_Rule* ptr)

    : Has_Block(ptr), name_(ptr->name_)

    { statement_type(KEYFRAMERULE); }

    ATTACH_AST_OPERATIONS(Keyframe_Rule)

    ATTACH_OPERATIONS()

  };

  ////////////////////////////////////////////////////////////////////////

  // Declarations -- style rules consisting of a property name and values.

  ////////////////////////////////////////////////////////////////////////

  class Declaration : public Has_Block {

    ADD_PROPERTY(String_Obj, property)

    ADD_PROPERTY(Expression_Obj, value)

    ADD_PROPERTY(bool, is_important)

    ADD_PROPERTY(bool, is_indented)

  public:

    Declaration(ParserState pstate,

                String_Obj prop, Expression_Obj val, bool i = false, Block_Obj b = 0)

    : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_indented_(false)

    { statement_type(DECLARATION); }

    Declaration(const Declaration* ptr)

    : Has_Block(ptr),

      property_(ptr->property_),

      value_(ptr->value_),

      is_important_(ptr->is_important_),

      is_indented_(ptr->is_indented_)

    { statement_type(DECLARATION); }

    ATTACH_AST_OPERATIONS(Declaration)

    ATTACH_OPERATIONS()

  };

  /////////////////////////////////////

  // Assignments -- variable and value.

  /////////////////////////////////////

  class Assignment : public Statement {

    ADD_CONSTREF(std::string, variable)

    ADD_PROPERTY(Expression_Obj, value)

    ADD_PROPERTY(bool, is_default)

    ADD_PROPERTY(bool, is_global)

  public:

    Assignment(ParserState pstate,

               std::string var, Expression_Obj val,

               bool is_default = false,

               bool is_global = false)

    : Statement(pstate), variable_(var), value_(val), is_default_(is_default), is_global_(is_global)

    { statement_type(ASSIGNMENT); }

    Assignment(const Assignment* ptr)

    : Statement(ptr),

      variable_(ptr->variable_),

      value_(ptr->value_),

      is_default_(ptr->is_default_),

      is_global_(ptr->is_global_)

    { statement_type(ASSIGNMENT); }

    ATTACH_AST_OPERATIONS(Assignment)

    ATTACH_OPERATIONS()

  };

  ////////////////////////////////////////////////////////////////////////////

  // Import directives. CSS and Sass import lists can be intermingled, so it's

  // necessary to store a list of each in an Import node.

  ////////////////////////////////////////////////////////////////////////////

  class Import : public Statement {

    std::vector<Expression_Obj> urls_;

    std::vector<Include>     incs_;

    ADD_PROPERTY(List_Obj,      import_queries);

  public:

    Import(ParserState pstate)

    : Statement(pstate),

      urls_(std::vector<Expression_Obj>()),

      incs_(std::vector<Include>()),

      import_queries_()

    { statement_type(IMPORT); }

    Import(const Import* ptr)

    : Statement(ptr),

      urls_(ptr->urls_),

      incs_(ptr->incs_),

      import_queries_(ptr->import_queries_)

    { statement_type(IMPORT); }

    std::vector<Expression_Obj>& urls() { return urls_; }

    std::vector<Include>& incs() { return incs_; }

    ATTACH_AST_OPERATIONS(Import)

    ATTACH_OPERATIONS()

  };

  // not yet resolved single import

  // so far we only know requested name

  class Import_Stub : public Statement {

    Include resource_;

  public:

    std::string abs_path() { return resource_.abs_path; };

    std::string imp_path() { return resource_.imp_path; };

    Include resource() { return resource_; };

    Import_Stub(ParserState pstate, Include res)

    : Statement(pstate), resource_(res)

    { statement_type(IMPORT_STUB); }

    Import_Stub(const Import_Stub* ptr)

    : Statement(ptr), resource_(ptr->resource_)

    { statement_type(IMPORT_STUB); }

    ATTACH_AST_OPERATIONS(Import_Stub)

    ATTACH_OPERATIONS()

  };

  //////////////////////////////

  // The Sass `@warn` directive.

  //////////////////////////////

  class Warning : public Statement {

    ADD_PROPERTY(Expression_Obj, message)

  public:

    Warning(ParserState pstate, Expression_Obj msg)

    : Statement(pstate), message_(msg)

    { statement_type(WARNING); }

    Warning(const Warning* ptr)

    : Statement(ptr), message_(ptr->message_)

    { statement_type(WARNING); }

    ATTACH_AST_OPERATIONS(Warning)

    ATTACH_OPERATIONS()

  };

  ///////////////////////////////

  // The Sass `@error` directive.

  ///////////////////////////////

  class Error : public Statement {

    ADD_PROPERTY(Expression_Obj, message)

  public:

    Error(ParserState pstate, Expression_Obj msg)

    : Statement(pstate), message_(msg)

    { statement_type(ERROR); }

    Error(const Error* ptr)

    : Statement(ptr), message_(ptr->message_)

    { statement_type(ERROR); }

    ATTACH_AST_OPERATIONS(Error)

    ATTACH_OPERATIONS()

  };

  ///////////////////////////////

  // The Sass `@debug` directive.

  ///////////////////////////////

  class Debug : public Statement {

    ADD_PROPERTY(Expression_Obj, value)

  public:

    Debug(ParserState pstate, Expression_Obj val)

    : Statement(pstate), value_(val)

    { statement_type(DEBUGSTMT); }

    Debug(const Debug* ptr)

    : Statement(ptr), value_(ptr->value_)

    { statement_type(DEBUGSTMT); }

    ATTACH_AST_OPERATIONS(Debug)

    ATTACH_OPERATIONS()

  };

  ///////////////////////////////////////////

  // CSS comments. These may be interpolated.

  ///////////////////////////////////////////

  class Comment : public Statement {

    ADD_PROPERTY(String_Obj, text)

    ADD_PROPERTY(bool, is_important)

  public:

    Comment(ParserState pstate, String_Obj txt, bool is_important)

    : Statement(pstate), text_(txt), is_important_(is_important)

    { statement_type(COMMENT); }

    Comment(const Comment* ptr)

    : Statement(ptr),

      text_(ptr->text_),

      is_important_(ptr->is_important_)

    { statement_type(COMMENT); }

    virtual bool is_invisible() const

    { return /* is_important() == */ false; }

    ATTACH_AST_OPERATIONS(Comment)

    ATTACH_OPERATIONS()

  };

  ////////////////////////////////////

  // The Sass `@if` control directive.

  ////////////////////////////////////

  class If : public Has_Block {

    ADD_PROPERTY(Expression_Obj, predicate)

    ADD_PROPERTY(Block_Obj, alternative)

  public:

    If(ParserState pstate, Expression_Obj pred, Block_Obj con, Block_Obj alt = 0)

    : Has_Block(pstate, con), predicate_(pred), alternative_(alt)

    { statement_type(IF); }

    If(const If* ptr)

    : Has_Block(ptr),

      predicate_(ptr->predicate_),

      alternative_(ptr->alternative_)

    { statement_type(IF); }

    virtual bool has_content()

    {

      return Has_Block::has_content() || (alternative_ && alternative_->has_content());

    }

    ATTACH_AST_OPERATIONS(If)

    ATTACH_OPERATIONS()

  };

  /////////////////////////////////////

  // The Sass `@for` control directive.

  /////////////////////////////////////

  class For : public Has_Block {

    ADD_CONSTREF(std::string, variable)

    ADD_PROPERTY(Expression_Obj, lower_bound)

    ADD_PROPERTY(Expression_Obj, upper_bound)

    ADD_PROPERTY(bool, is_inclusive)

  public:

    For(ParserState pstate,

        std::string var, Expression_Obj lo, Expression_Obj hi, Block_Obj b, bool inc)

    : Has_Block(pstate, b),

      variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)

    { statement_type(FOR); }

    For(const For* ptr)

    : Has_Block(ptr),

      variable_(ptr->variable_),

      lower_bound_(ptr->lower_bound_),

      upper_bound_(ptr->upper_bound_),

      is_inclusive_(ptr->is_inclusive_)

    { statement_type(FOR); }

    ATTACH_AST_OPERATIONS(For)

    ATTACH_OPERATIONS()

  };

  //////////////////////////////////////

  // The Sass `@each` control directive.

  //////////////////////////////////////

  class Each : public Has_Block {

    ADD_PROPERTY(std::vector<std::string>, variables)

    ADD_PROPERTY(Expression_Obj, list)

  public:

    Each(ParserState pstate, std::vector<std::string> vars, Expression_Obj lst, Block_Obj b)

    : Has_Block(pstate, b), variables_(vars), list_(lst)

    { statement_type(EACH); }

    Each(const Each* ptr)

    : Has_Block(ptr), variables_(ptr->variables_), list_(ptr->list_)

    { statement_type(EACH); }