sassc 2.3.0 → 2.4.0

data/ext/libsass/src/emitter.cpp

@@ -26,7 +26,7 @@ namespace Sass {
   { }
 
   // return buffer as string
-  std::string Emitter::get_buffer(void)
+  sass::string Emitter::get_buffer(void)
   {
     return wbuf.buffer;
   }
@@ -41,10 +41,10 @@ namespace Sass {
   void Emitter::add_source_index(size_t idx)
   { wbuf.smap.source_index.push_back(idx); }
 
-  std::string Emitter::render_srcmap(Context &ctx)
+  sass::string Emitter::render_srcmap(Context &ctx)
   { return wbuf.smap.render_srcmap(ctx); }
 
-  void Emitter::set_filename(const std::string& str)
+  void Emitter::set_filename(const sass::string& str)
   { wbuf.smap.file = str; }
 
   void Emitter::schedule_mapping(const AST_Node* node)
@@ -53,7 +53,7 @@ namespace Sass {
   { wbuf.smap.add_open_mapping(node); }
   void Emitter::add_close_mapping(const AST_Node* node)
   { wbuf.smap.add_close_mapping(node); }
-  ParserState Emitter::remap(const ParserState& pstate)
+  SourceSpan Emitter::remap(const SourceSpan& pstate)
   { return wbuf.smap.remap(pstate); }
 
   // MAIN BUFFER MANIPULATION
@@ -74,7 +74,7 @@ namespace Sass {
   {
     // check the schedule
     if (scheduled_linefeed) {
-      std::string linefeeds = "";
+      sass::string linefeeds = "";
 
       for (size_t i = 0; i < scheduled_linefeed; i++)
         linefeeds += opt.linefeed;
@@ -83,7 +83,7 @@ namespace Sass {
       append_string(linefeeds);
 
     } else if (scheduled_space) {
-      std::string spaces(scheduled_space, ' ');
+      sass::string spaces(scheduled_space, ' ');
       scheduled_space = 0;
       append_string(spaces);
     }
@@ -101,7 +101,7 @@ namespace Sass {
   }
 
   // prepend some text or token to the buffer
-  void Emitter::prepend_string(const std::string& text)
+  void Emitter::prepend_string(const sass::string& text)
   {
     // do not adjust mappings for utf8 bom
     // seems they are not counted in any UA
@@ -128,14 +128,14 @@ namespace Sass {
   }
 
   // append some text or token to the buffer
-  void Emitter::append_string(const std::string& text)
+  void Emitter::append_string(const sass::string& text)
   {
 
     // write space/lf
     flush_schedules();
 
     if (in_comment) {
-      std::string out = Util::normalize_newlines(text);
+      sass::string out = Util::normalize_newlines(text);
       if (output_style() == COMPACT) {
         out = comment_to_compact_string(out);
       }
@@ -150,7 +150,7 @@ namespace Sass {
   }
 
   // append some white-space only text
-  void Emitter::append_wspace(const std::string& text)
+  void Emitter::append_wspace(const sass::string& text)
   {
     if (text.empty()) return;
     if (peek_linefeed(text.c_str())) {
@@ -161,7 +161,7 @@ namespace Sass {
 
   // append some text or token to the buffer
   // this adds source-mappings for node start and end
-  void Emitter::append_token(const std::string& text, const AST_Node* node)
+  void Emitter::append_token(const sass::string& text, const AST_Node* node)
   {
     flush_schedules();
     add_open_mapping(node);
@@ -184,7 +184,7 @@ namespace Sass {
     if (in_declaration && in_comma_array) return;
     if (scheduled_linefeed && indentation)
       scheduled_linefeed = 1;
-    std::string indent = "";
+    sass::string indent = "";
     for (size_t i = 0; i < indentation; i++)
       indent += opt.indent;
     append_string(indent);

data/ext/libsass/src/emitter.hpp

@@ -21,17 +21,17 @@ namespace Sass {
     protected:
       OutputBuffer wbuf;
     public:
-      const std::string& buffer(void) { return wbuf.buffer; }
+      const sass::string& buffer(void) { return wbuf.buffer; }
       const SourceMap smap(void) { return wbuf.smap; }
       const OutputBuffer output(void) { return wbuf; }
       // proxy methods for source maps
       void add_source_index(size_t idx);
-      void set_filename(const std::string& str);
+      void set_filename(const sass::string& str);
       void add_open_mapping(const AST_Node* node);
       void add_close_mapping(const AST_Node* node);
       void schedule_mapping(const AST_Node* node);
-      std::string render_srcmap(Context &ctx);
-      ParserState remap(const ParserState& pstate);
+      sass::string render_srcmap(Context &ctx);
+      SourceSpan remap(const SourceSpan& pstate);
 
     public:
       struct Sass_Output_Options& opt;
@@ -58,8 +58,8 @@ namespace Sass {
       bool in_comma_array;
 
     public:
-      // return buffer as std::string
-      std::string get_buffer(void);
+      // return buffer as sass::string
+      sass::string get_buffer(void);
       // flush scheduled space/linefeed
       Sass_Output_Style output_style(void) const;
       // add outstanding linefeed
@@ -67,17 +67,17 @@ namespace Sass {
       // flush scheduled space/linefeed
       void flush_schedules(void);
       // prepend some text or token to the buffer
-      void prepend_string(const std::string& text);
+      void prepend_string(const sass::string& text);
       void prepend_output(const OutputBuffer& out);
       // append some text or token to the buffer
-      void append_string(const std::string& text);
+      void append_string(const sass::string& text);
       // append a single character to buffer
       void append_char(const char chr);
       // append some white-space only text
-      void append_wspace(const std::string& text);
+      void append_wspace(const sass::string& text);
       // append some text or token to the buffer
       // this adds source-mappings for node start and end
-      void append_token(const std::string& text, const AST_Node* node);
+      void append_token(const sass::string& text, const AST_Node* node);
       // query last appended character
       char last_char();
 

data/ext/libsass/src/environment.cpp

@@ -6,17 +6,17 @@ namespace Sass {
 
   template <typename T>
   Environment<T>::Environment(bool is_shadow)
-  : local_frame_(environment_map<std::string, T>()),
+  : local_frame_(environment_map<sass::string, T>()),
     parent_(0), is_shadow_(false)
   { }
   template <typename T>
   Environment<T>::Environment(Environment<T>* env, bool is_shadow)
-  : local_frame_(environment_map<std::string, T>()),
+  : local_frame_(environment_map<sass::string, T>()),
     parent_(env), is_shadow_(is_shadow)
   { }
   template <typename T>
   Environment<T>::Environment(Environment<T>& env, bool is_shadow)
-  : local_frame_(environment_map<std::string, T>()),
+  : local_frame_(environment_map<sass::string, T>()),
     parent_(&env), is_shadow_(is_shadow)
   { }
 
@@ -45,16 +45,16 @@ namespace Sass {
   }
 
   template <typename T>
-  environment_map<std::string, T>& Environment<T>::local_frame() {
+  environment_map<sass::string, T>& Environment<T>::local_frame() {
     return local_frame_;
   }
 
   template <typename T>
-  bool Environment<T>::has_local(const std::string& key) const
+  bool Environment<T>::has_local(const sass::string& key) const
   { return local_frame_.find(key) != local_frame_.end(); }
 
   template <typename T> EnvResult
-  Environment<T>::find_local(const std::string& key)
+  Environment<T>::find_local(const sass::string& key)
   {
     auto end = local_frame_.end();
     auto it = local_frame_.find(key);
@@ -62,22 +62,22 @@ namespace Sass {
   }
 
   template <typename T>
-  T& Environment<T>::get_local(const std::string& key)
+  T& Environment<T>::get_local(const sass::string& key)
   { return local_frame_[key]; }
 
   template <typename T>
-  void Environment<T>::set_local(const std::string& key, const T& val)
+  void Environment<T>::set_local(const sass::string& key, const T& val)
   {
     local_frame_[key] = val;
   }
   template <typename T>
-  void Environment<T>::set_local(const std::string& key, T&& val)
+  void Environment<T>::set_local(const sass::string& key, T&& val)
   {
     local_frame_[key] = val;
   }
 
   template <typename T>
-  void Environment<T>::del_local(const std::string& key)
+  void Environment<T>::del_local(const sass::string& key)
   { local_frame_.erase(key); }
 
   template <typename T>
@@ -91,30 +91,30 @@ namespace Sass {
   }
 
   template <typename T>
-  bool Environment<T>::has_global(const std::string& key)
+  bool Environment<T>::has_global(const sass::string& key)
   { return global_env()->has(key); }
 
   template <typename T>
-  T& Environment<T>::get_global(const std::string& key)
+  T& Environment<T>::get_global(const sass::string& key)
   { return (*global_env())[key]; }
 
   template <typename T>
-  void Environment<T>::set_global(const std::string& key, const T& val)
+  void Environment<T>::set_global(const sass::string& key, const T& val)
   {
     global_env()->local_frame_[key] = val;
   }
   template <typename T>
-  void Environment<T>::set_global(const std::string& key, T&& val)
+  void Environment<T>::set_global(const sass::string& key, T&& val)
   {
     global_env()->local_frame_[key] = val;
   }
 
   template <typename T>
-  void Environment<T>::del_global(const std::string& key)
+  void Environment<T>::del_global(const sass::string& key)
   { global_env()->local_frame_.erase(key); }
 
   template <typename T>
-  Environment<T>* Environment<T>::lexical_env(const std::string& key)
+  Environment<T>* Environment<T>::lexical_env(const sass::string& key)
   {
     Environment* cur = this;
     while (cur) {
@@ -130,7 +130,7 @@ namespace Sass {
   // move down the stack but stop before we
   // reach the global frame (is not included)
   template <typename T>
-  bool Environment<T>::has_lexical(const std::string& key) const
+  bool Environment<T>::has_lexical(const sass::string& key) const
   {
     auto cur = this;
     while (cur->is_lexical()) {
@@ -144,7 +144,7 @@ namespace Sass {
   // either update already existing lexical value
   // or if flag is set, we create one if no lexical found
   template <typename T>
-  void Environment<T>::set_lexical(const std::string& key, const T& val)
+  void Environment<T>::set_lexical(const sass::string& key, const T& val)
   {
     Environment<T>* cur = this;
     bool shadow = false;
@@ -161,7 +161,7 @@ namespace Sass {
   }
   // this one moves the value
   template <typename T>
-  void Environment<T>::set_lexical(const std::string& key, T&& val)
+  void Environment<T>::set_lexical(const sass::string& key, T&& val)
   {
     Environment<T>* cur = this;
     bool shadow = false;
@@ -180,7 +180,7 @@ namespace Sass {
   // look on the full stack for key
   // include all scopes available
   template <typename T>
-  bool Environment<T>::has(const std::string& key) const
+  bool Environment<T>::has(const sass::string& key) const
   {
     auto cur = this;
     while (cur) {
@@ -195,7 +195,7 @@ namespace Sass {
   // look on the full stack for key
   // include all scopes available
   template <typename T> EnvResult
-  Environment<T>::find(const std::string& key)
+  Environment<T>::find(const sass::string& key)
   {
     auto cur = this;
     while (true) {
@@ -208,7 +208,7 @@ namespace Sass {
 
   // use array access for getter and setter functions
   template <typename T>
-  T& Environment<T>::get(const std::string& key)
+  T& Environment<T>::get(const sass::string& key)
   {
     auto cur = this;
     while (cur) {
@@ -222,7 +222,7 @@ namespace Sass {
 
   // use array access for getter and setter functions
   template <typename T>
-  T& Environment<T>::operator[](const std::string& key)
+  T& Environment<T>::operator[](const sass::string& key)
   {
     auto cur = this;
     while (cur) {
@@ -236,14 +236,14 @@ namespace Sass {
 /*
   #ifdef DEBUG
   template <typename T>
-  size_t Environment<T>::print(std::string prefix)
+  size_t Environment<T>::print(sass::string prefix)
   {
     size_t indent = 0;
     if (parent_) indent = parent_->print(prefix) + 1;
-    std::cerr << prefix << std::string(indent, ' ') << "== " << this << std::endl;
-    for (typename environment_map<std::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
+    std::cerr << prefix << sass::string(indent, ' ') << "== " << this << std::endl;
+    for (typename environment_map<sass::string, T>::iterator i = local_frame_.begin(); i != local_frame_.end(); ++i) {
       if (!ends_with(i->first, "[f]") && !ends_with(i->first, "[f]4") && !ends_with(i->first, "[f]2")) {
-        std::cerr << prefix << std::string(indent, ' ') << i->first << " " << i->second;
+        std::cerr << prefix << sass::string(indent, ' ') << i->first << " " << i->second;
         if (Value* val = Cast<Value>(i->second))
         { std::cerr << " : " << val->to_string(); }
         std::cerr << std::endl;

data/ext/libsass/src/environment.hpp

@@ -13,7 +13,7 @@
 namespace Sass {
 
   // this defeats the whole purpose of environment being templatable!!
-  typedef environment_map<std::string, AST_Node_Obj>::iterator EnvIter;
+  typedef environment_map<sass::string, AST_Node_Obj>::iterator EnvIter;
 
   class EnvResult {
     public:
@@ -27,7 +27,7 @@ namespace Sass {
   template <typename T>
   class Environment {
     // TODO: test with map
-    environment_map<std::string, T> local_frame_;
+    environment_map<sass::string, T> local_frame_;
     ADD_PROPERTY(Environment*, parent)
     ADD_PROPERTY(bool, is_shadow)
 
@@ -52,72 +52,72 @@ namespace Sass {
 
     // scope operates on the current frame
 
-    environment_map<std::string, T>& local_frame();
+    environment_map<sass::string, T>& local_frame();
 
-    bool has_local(const std::string& key) const;
+    bool has_local(const sass::string& key) const;
 
-    EnvResult find_local(const std::string& key);
+    EnvResult find_local(const sass::string& key);
 
-    T& get_local(const std::string& key);
+    T& get_local(const sass::string& key);
 
     // set variable on the current frame
-    void set_local(const std::string& key, const T& val);
-    void set_local(const std::string& key, T&& val);
+    void set_local(const sass::string& key, const T& val);
+    void set_local(const sass::string& key, T&& val);
 
-    void del_local(const std::string& key);
+    void del_local(const sass::string& key);
 
     // global operates on the global frame
     // which is the second last on the stack
     Environment* global_env();
     // get the env where the variable already exists
     // if it does not yet exist, we return current env
-    Environment* lexical_env(const std::string& key);
+    Environment* lexical_env(const sass::string& key);
 
-    bool has_global(const std::string& key);
+    bool has_global(const sass::string& key);
 
-    T& get_global(const std::string& key);
+    T& get_global(const sass::string& key);
 
     // set a variable on the global frame
-    void set_global(const std::string& key, const T& val);
-    void set_global(const std::string& key, T&& val);
+    void set_global(const sass::string& key, const T& val);
+    void set_global(const sass::string& key, T&& val);
 
-    void del_global(const std::string& key);
+    void del_global(const sass::string& key);
 
     // see if we have a lexical variable
     // move down the stack but stop before we
     // reach the global frame (is not included)
-    bool has_lexical(const std::string& key) const;
+    bool has_lexical(const sass::string& key) const;
 
     // see if we have a lexical we could update
     // either update already existing lexical value
     // or we create a new one on the current frame
-    void set_lexical(const std::string& key, T&& val);
-    void set_lexical(const std::string& key, const T& val);
+    void set_lexical(const sass::string& key, T&& val);
+    void set_lexical(const sass::string& key, const T& val);
 
     // look on the full stack for key
     // include all scopes available
-    bool has(const std::string& key) const;
+    bool has(const sass::string& key) const;
 
     // look on the full stack for key
     // include all scopes available
-    T& get(const std::string& key);
+    T& get(const sass::string& key);
 
     // look on the full stack for key
     // include all scopes available
-    EnvResult find(const std::string& key);
+    EnvResult find(const sass::string& key);
 
     // use array access for getter and setter functions
-    T& operator[](const std::string& key);
+    T& operator[](const sass::string& key);
 
     #ifdef DEBUG
-    size_t print(std::string prefix = "");
+    size_t print(sass::string prefix = "");
     #endif
 
   };
 
   // define typedef for our use case
   typedef Environment<AST_Node_Obj> Env;
-  typedef std::vector<Env*> EnvStack;
+  typedef sass::vector<Env*> EnvStack;
 
 }
 

data/ext/libsass/src/error_handling.cpp

@@ -13,13 +13,13 @@ namespace Sass {
 
   namespace Exception {
 
-    Base::Base(ParserState pstate, std::string msg, Backtraces traces)
-    : std::runtime_error(msg), msg(msg),
+    Base::Base(SourceSpan pstate, sass::string msg, Backtraces traces)
+    : std::runtime_error(msg.c_str()), msg(msg),
       prefix("Error"), pstate(pstate), traces(traces)
     { }
 
-    InvalidSass::InvalidSass(ParserState pstate, Backtraces traces, std::string msg, char* owned_src)
-    : Base(pstate, msg, traces), owned_src(owned_src)
+    InvalidSass::InvalidSass(SourceSpan pstate, Backtraces traces, sass::string msg)
+    : Base(pstate, msg, traces)
     { }
 
 
@@ -31,14 +31,14 @@ namespace Sass {
         "\"" + parent->to_string(Sass_Inspect_Options()) + "\"";
     }
 
-    InvalidVarKwdType::InvalidVarKwdType(ParserState pstate, Backtraces traces, std::string name, const Argument* arg)
+    InvalidVarKwdType::InvalidVarKwdType(SourceSpan pstate, Backtraces traces, sass::string name, const Argument* arg)
     : Base(pstate, def_msg, traces), name(name), arg(arg)
     {
       msg = "Variable keyword argument map must have string keys.\n" +
         name + " is not a string in " + arg->to_string() + ".";
     }
 
-    InvalidArgumentType::InvalidArgumentType(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string type, const Value* value)
+    InvalidArgumentType::InvalidArgumentType(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string type, const Value* value)
     : Base(pstate, def_msg, traces), fn(fn), arg(arg), type(type), value(value)
     {
       msg = arg + ": \"";
@@ -46,17 +46,17 @@ namespace Sass {
       msg += "\" is not a " + type + " for `" + fn + "'";
     }
 
-    MissingArgument::MissingArgument(ParserState pstate, Backtraces traces, std::string fn, std::string arg, std::string fntype)
+    MissingArgument::MissingArgument(SourceSpan pstate, Backtraces traces, sass::string fn, sass::string arg, sass::string fntype)
     : Base(pstate, def_msg, traces), fn(fn), arg(arg), fntype(fntype)
     {
       msg = fntype + " " + fn + " is missing argument " + arg + ".";
     }
 
-    InvalidSyntax::InvalidSyntax(ParserState pstate, Backtraces traces, std::string msg)
+    InvalidSyntax::InvalidSyntax(SourceSpan pstate, Backtraces traces, sass::string msg)
     : Base(pstate, msg, traces)
     { }
 
-    NestingLimitError::NestingLimitError(ParserState pstate, Backtraces traces, std::string msg)
+    NestingLimitError::NestingLimitError(SourceSpan pstate, Backtraces traces, sass::string msg)
     : Base(pstate, msg, traces)
     { }
 
@@ -66,7 +66,7 @@ namespace Sass {
       msg = "Duplicate key " + dup.get_duplicate_key()->inspect() + " in map (" + org.inspect() + ").";
     }
 
-    TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const std::string type)
+    TypeMismatch::TypeMismatch(Backtraces traces, const Expression& var, const sass::string type)
     : Base(var.pstate(), def_msg, traces), var(var), type(type)
     {
       msg = var.to_string() + " is not an " + type + ".";
@@ -91,7 +91,7 @@ namespace Sass {
 
     IncompatibleUnits::IncompatibleUnits(const UnitType lhs, const UnitType rhs)
     {
-      msg = std::string("Incompatible units: '") + unit_to_string(rhs) + "' and '" + unit_to_string(lhs) + "'.";
+      msg = sass::string("Incompatible units: '") + unit_to_string(rhs) + "' and '" + unit_to_string(lhs) + "'.";
     }
 
     AlphaChannelsNotEqual::AlphaChannelsNotEqual(const Expression* lhs, const Expression* rhs, enum Sass_OP op)
@@ -125,14 +125,14 @@ namespace Sass {
       msg = def_op_null_msg + ": \"" + lhs->inspect() + " " + sass_op_to_name(op) + " " + rhs->inspect() + "\".";
     }
 
-    SassValueError::SassValueError(Backtraces traces, ParserState pstate, OperationError& err)
+    SassValueError::SassValueError(Backtraces traces, SourceSpan pstate, OperationError& err)
     : Base(pstate, err.what(), traces)
     {
       msg = err.what();
       prefix = err.errtype();
     }
 
-    TopLevelParent::TopLevelParent(Backtraces traces, ParserState pstate)
+    TopLevelParent::TopLevelParent(Backtraces traces, SourceSpan pstate)
       : Base(pstate, "Top-level selectors may not contain the parent selector \"&\".", traces)
     {
 
@@ -156,48 +156,48 @@ namespace Sass {
   }
 
 
-  void warn(std::string msg, ParserState pstate)
+  void warn(sass::string msg, SourceSpan pstate)
   {
     std::cerr << "Warning: " << msg << std::endl;
   }
 
-  void warning(std::string msg, ParserState pstate)
+  void warning(sass::string msg, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
 
-    std::cerr << "WARNING on line " << pstate.line+1 << ", column " << pstate.column+1 << " of " << output_path << ":" << std::endl;
+    std::cerr << "WARNING on line " << pstate.getLine() << ", column " << pstate.getColumn() << " of " << output_path << ":" << std::endl;
     std::cerr << msg << std::endl << std::endl;
   }
 
-  void warn(std::string msg, ParserState pstate, Backtrace* bt)
+  void warn(sass::string msg, SourceSpan pstate, Backtrace* bt)
   {
     warn(msg, pstate);
   }
 
-  void deprecated_function(std::string msg, ParserState pstate)
+  void deprecated_function(sass::string msg, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
 
     std::cerr << "DEPRECATION WARNING: " << msg << std::endl;
     std::cerr << "will be an error in future versions of Sass." << std::endl;
-    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+    std::cerr << "        on line " << pstate.getLine() << " of " << output_path << std::endl;
   }
 
-  void deprecated(std::string msg, std::string msg2, bool with_column, ParserState pstate)
+  void deprecated(sass::string msg, sass::string msg2, bool with_column, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, pstate.path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, pstate.getPath(), pstate.getPath()));
 
-    std::cerr << "DEPRECATION WARNING on line " << pstate.line + 1;
-    if (with_column) std::cerr << ", column " << pstate.column + pstate.offset.column + 1;
+    std::cerr << "DEPRECATION WARNING on line " << pstate.getLine();
+    // if (with_column) std::cerr << ", column " << pstate.column + pstate.offset.column + 1;
     if (output_path.length()) std::cerr << " of " << output_path;
     std::cerr << ":" << std::endl;
     std::cerr << msg << std::endl;
@@ -205,26 +205,26 @@ namespace Sass {
     std::cerr << std::endl;
   }
 
-  void deprecated_bind(std::string msg, ParserState pstate)
+  void deprecated_bind(sass::string msg, SourceSpan pstate)
   {
-    std::string cwd(Sass::File::get_cwd());
-    std::string abs_path(Sass::File::rel2abs(pstate.path, cwd, cwd));
-    std::string rel_path(Sass::File::abs2rel(pstate.path, cwd, cwd));
-    std::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.path));
+    sass::string cwd(Sass::File::get_cwd());
+    sass::string abs_path(Sass::File::rel2abs(pstate.getPath(), cwd, cwd));
+    sass::string rel_path(Sass::File::abs2rel(pstate.getPath(), cwd, cwd));
+    sass::string output_path(Sass::File::path_for_console(rel_path, abs_path, pstate.getPath()));
 
     std::cerr << "WARNING: " << msg << std::endl;
-    std::cerr << "        on line " << pstate.line+1 << " of " << output_path << std::endl;
+    std::cerr << "        on line " << pstate.getLine() << " of " << output_path << std::endl;
     std::cerr << "This will be an error in future versions of Sass." << std::endl;
   }
 
   // should be replaced with error with backtraces
-  void coreError(std::string msg, ParserState pstate)
+  void coreError(sass::string msg, SourceSpan pstate)
   {
     Backtraces traces;
     throw Exception::InvalidSyntax(pstate, traces, msg);
   }
 
-  void error(std::string msg, ParserState pstate, Backtraces& traces)
+  void error(sass::string msg, SourceSpan pstate, Backtraces& traces)
   {
     traces.push_back(Backtrace(pstate));
     throw Exception::InvalidSyntax(pstate, traces, msg);