sassc 0.0.9 → 0.0.10

data/ext/libsass/emitter.cpp

@@ -0,0 +1,255 @@
+#include "util.hpp"
+#include "context.hpp"
+#include "output.hpp"
+#include "emitter.hpp"
+#include "utf8_string.hpp"
+
+namespace Sass {
+  using namespace std;
+
+  Emitter::Emitter(Context* ctx)
+  : wbuf(),
+    ctx(ctx),
+    indentation(0),
+    scheduled_space(0),
+    scheduled_linefeed(0),
+    scheduled_delimiter(false),
+    in_comment(false),
+    in_at_rule(false),
+    in_media_block(false),
+    in_declaration(false),
+    in_declaration_list(false)
+  { }
+
+  // return buffer as string
+  string Emitter::get_buffer(void)
+  {
+    return wbuf.buffer;
+  }
+
+  Output_Style Emitter::output_style(void)
+  {
+    return ctx ? ctx->output_style : COMPRESSED;
+  }
+
+  // PROXY METHODS FOR SOURCE MAPS
+
+  void Emitter::add_source_index(size_t idx)
+  { wbuf.smap.source_index.push_back(idx); }
+
+  string Emitter::generate_source_map(Context &ctx)
+  { return wbuf.smap.generate_source_map(ctx); }
+
+  void Emitter::set_filename(const string& str)
+  { wbuf.smap.file = str; }
+
+  void Emitter::add_open_mapping(AST_Node* node)
+  { wbuf.smap.add_open_mapping(node); }
+  void Emitter::add_close_mapping(AST_Node* node)
+  { wbuf.smap.add_close_mapping(node); }
+  ParserState Emitter::remap(const ParserState& pstate)
+  { return wbuf.smap.remap(pstate); }
+
+  // MAIN BUFFER MANIPULATION
+
+  // add outstanding delimiter
+  void Emitter::finalize(void)
+  {
+    scheduled_space = 0;
+    if (scheduled_linefeed)
+      scheduled_linefeed = 1;
+    flush_schedules();
+  }
+
+  // flush scheduled space/linefeed
+  void Emitter::flush_schedules(void)
+  {
+    // check the schedule
+    if (scheduled_linefeed) {
+      string linefeeds = "";
+
+      for (size_t i = 0; i < scheduled_linefeed; i++)
+        linefeeds += ctx ? ctx->linefeed : "\n";
+      scheduled_space = 0;
+      scheduled_linefeed = 0;
+      append_string(linefeeds);
+
+    } else if (scheduled_space) {
+      string spaces(scheduled_space, ' ');
+      scheduled_space = 0;
+      append_string(spaces);
+    }
+    if (scheduled_delimiter) {
+      scheduled_delimiter = false;
+      append_string(";");
+    }
+  }
+
+  // prepend some text or token to the buffer
+  void Emitter::prepend_output(const OutputBuffer& output)
+  {
+    wbuf.smap.prepend(output);
+    wbuf.buffer = output.buffer + wbuf.buffer;
+  }
+
+  // prepend some text or token to the buffer
+  void Emitter::prepend_string(const string& text)
+  {
+    wbuf.smap.prepend(Offset(text));
+    wbuf.buffer = text + wbuf.buffer;
+  }
+
+  // append some text or token to the buffer
+  void Emitter::append_string(const string& text)
+  {
+    // write space/lf
+    flush_schedules();
+
+    if (in_comment && output_style() == COMPACT) {
+      // unescape comment nodes
+      string out = comment_to_string(text);
+      // add to buffer
+      wbuf.buffer += out;
+      // account for data in source-maps
+      wbuf.smap.append(Offset(out));
+    } else {
+      // add to buffer
+      wbuf.buffer += text;
+      // account for data in source-maps
+      wbuf.smap.append(Offset(text));
+    }
+  }
+
+  // append some white-space only text
+  void Emitter::append_wspace(const string& text)
+  {
+    if (text.empty()) return;
+    if (peek_linefeed(text.c_str())) {
+      scheduled_space = 0;
+      append_mandatory_linefeed();
+    }
+  }
+
+  // append some text or token to the buffer
+  // this adds source-mappings for node start and end
+  void Emitter::append_token(const string& text, AST_Node* node)
+  {
+    flush_schedules();
+    add_open_mapping(node);
+    append_string(text);
+    add_close_mapping(node);
+  }
+
+  // HELPER METHODS
+
+  void Emitter::append_indentation()
+  {
+    if (output_style() == COMPRESSED) return;
+    if (output_style() == COMPACT) return;
+    if (scheduled_linefeed && indentation)
+      scheduled_linefeed = 1;
+    string indent = "";
+    for (size_t i = 0; i < indentation; i++)
+      indent += ctx ? ctx->indent : "  ";
+    append_string(indent);
+  }
+
+  void Emitter::append_delimiter()
+  {
+    scheduled_delimiter = true;
+    if (output_style() == COMPACT) {
+      if (indentation == 0) {
+        append_mandatory_linefeed();
+      } else {
+        append_mandatory_space();
+      }
+    } else if (output_style() != COMPRESSED) {
+      append_optional_linefeed();
+    }
+  }
+
+  void Emitter::append_comma_separator()
+  {
+    scheduled_space = 0;
+    append_string(",");
+    append_optional_space();
+  }
+
+  void Emitter::append_colon_separator()
+  {
+    scheduled_space = 0;
+    append_string(":");
+    append_optional_space();
+  }
+
+  void Emitter::append_mandatory_space()
+  {
+    scheduled_space = 1;
+  }
+
+  void Emitter::append_optional_space()
+  {
+    if (output_style() != COMPRESSED && buffer().size()) {
+      char lst = buffer().at(buffer().length() - 1);
+      if (!isspace(lst)) append_mandatory_space();
+    }
+  }
+
+  void Emitter::append_special_linefeed()
+  {
+    if (output_style() == COMPACT) {
+      append_mandatory_linefeed();
+      for (size_t p = 0; p < indentation; p++)
+        append_string(ctx ? ctx->indent : "  ");
+    }
+  }
+
+  void Emitter::append_optional_linefeed()
+  {
+    if (output_style() == COMPACT) {
+      append_mandatory_space();
+    } else {
+      append_mandatory_linefeed();
+    }
+  }
+
+  void Emitter::append_mandatory_linefeed()
+  {
+    if (output_style() != COMPRESSED) {
+      scheduled_linefeed = 1;
+      scheduled_space = 0;
+      // flush_schedules();
+    }
+  }
+
+  void Emitter::append_scope_opener(AST_Node* node)
+  {
+    append_optional_space();
+    flush_schedules();
+    if (node) add_open_mapping(node);
+    append_string("{");
+    append_optional_linefeed();
+    // append_optional_space();
+    ++ indentation;
+  }
+  void Emitter::append_scope_closer(AST_Node* node)
+  {
+    -- indentation;
+    scheduled_linefeed = 0;
+    if (output_style() == COMPRESSED)
+      scheduled_delimiter = false;
+    if (output_style() == EXPANDED) {
+      append_optional_linefeed();
+      append_indentation();
+    } else {
+      append_optional_space();
+    }
+    append_string("}");
+    if (node) add_close_mapping(node);
+    append_optional_linefeed();
+    if (indentation != 0) return;
+    if (output_style() != COMPRESSED)
+      scheduled_linefeed = 2;
+  }
+
+}

data/ext/libsass/emitter.hpp

@@ -0,0 +1,83 @@
+#ifndef SASS_EMITTER_H
+#define SASS_EMITTER_H
+
+#include <string>
+#include "source_map.hpp"
+#include "ast_fwd_decl.hpp"
+
+namespace Sass {
+  class Context;
+  using namespace std;
+
+  class Emitter {
+
+    public:
+      Emitter(Context* ctx);
+      virtual ~Emitter() { };
+
+    protected:
+      OutputBuffer wbuf;
+    public:
+      const 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 string& str);
+      void add_open_mapping(AST_Node* node);
+      void add_close_mapping(AST_Node* node);
+      string generate_source_map(Context &ctx);
+      ParserState remap(const ParserState& pstate);
+
+    public:
+      Context* ctx;
+      size_t indentation;
+      size_t scheduled_space;
+      size_t scheduled_linefeed;
+      bool scheduled_delimiter;
+
+    public:
+      bool in_comment;
+      bool in_at_rule;
+      bool in_media_block;
+      bool in_declaration;
+      bool in_declaration_list;
+
+    public:
+      // return buffer as string
+      string get_buffer(void);
+      // flush scheduled space/linefeed
+      Output_Style output_style(void);
+      // add outstanding linefeed
+      void finalize(void);
+      // flush scheduled space/linefeed
+      void flush_schedules(void);
+      // prepend some text or token to the buffer
+      void prepend_string(const string& text);
+      void prepend_output(const OutputBuffer& out);
+      // append some text or token to the buffer
+      void append_string(const string& text);
+      // append some white-space only text
+      void append_wspace(const string& text);
+      // append some text or token to the buffer
+      // this adds source-mappings for node start and end
+      void append_token(const string& text, AST_Node* node);
+
+    public: // syntax sugar
+      void append_indentation();
+      void append_optional_space(void);
+      void append_mandatory_space(void);
+      void append_special_linefeed(void);
+      void append_optional_linefeed(void);
+      void append_mandatory_linefeed(void);
+      void append_scope_opener(AST_Node* node = 0);
+      void append_scope_closer(AST_Node* node = 0);
+      void append_comma_separator(void);
+      void append_colon_separator(void);
+      void append_delimiter(void);
+
+  };
+
+}
+
+#endif

data/ext/libsass/environment.hpp

@@ -1,10 +1,12 @@
-#define SASS_ENVIRONMENT
+#ifndef SASS_ENVIRONMENT_H
+#define SASS_ENVIRONMENT_H
 
-#include <string>
 #include <map>
-#include "ast_def_macros.hpp"
+#include <string>
 #include <iostream>
 
+#include "ast_def_macros.hpp"
+
 namespace Sass {
   using std::string;
   using std::map;
@@ -73,3 +75,5 @@ namespace Sass {
     }
   };
 }
+
+#endif

data/ext/libsass/error_handling.cpp

@@ -1,28 +1,25 @@
-#ifndef SASS_ERROR_HANDLING
-#include "error_handling.hpp"
-#endif
-
-#include "backtrace.hpp"
 #include "prelexer.hpp"
+#include "backtrace.hpp"
+#include "error_handling.hpp"
 
 namespace Sass {
 
-  Sass_Error::Sass_Error(Type type, string path, Position position, string message)
-  : type(type), path(path), position(position), message(message)
+  Sass_Error::Sass_Error(Type type, ParserState pstate, string message)
+  : type(type), pstate(pstate), message(message)
   { }
 
-  void error(string msg, string path, Position position)
-  { throw Sass_Error(Sass_Error::syntax, path, position, msg); }
+  void error(string msg, ParserState pstate)
+  { throw Sass_Error(Sass_Error::syntax, pstate, msg); }
 
-  void error(string msg, string path, Position position, Backtrace* bt)
+  void error(string msg, ParserState pstate, Backtrace* bt)
   {
-    if (!path.empty() && Prelexer::string_constant(path.c_str()))
-      path = path.substr(1, path.size() - 1);
+    if (!pstate.path.empty() && Prelexer::quoted_string(pstate.path.c_str()))
+      pstate.path = pstate.path.substr(1, pstate.path.size() - 1);
 
-    Backtrace top(bt, path, position, "");
+    Backtrace top(bt, pstate, "");
     msg += top.to_string();
 
-    throw Sass_Error(Sass_Error::syntax, path, position, msg);
+    throw Sass_Error(Sass_Error::syntax, pstate, msg);
   }
 
 }

data/ext/libsass/error_handling.hpp

@@ -1,9 +1,9 @@
-#define SASS_ERROR_HANDLING
+#ifndef SASS_ERROR_HANDLING_H
+#define SASS_ERROR_HANDLING_H
+
 #include <string>
 
-#ifndef SASS_POSITION
 #include "position.hpp"
-#endif
 
 namespace Sass {
   using namespace std;
@@ -15,14 +15,16 @@ namespace Sass {
 
     Type type;
     string path;
-    Position position;
+    ParserState pstate;
     string message;
 
-    Sass_Error(Type type, string path, Position position, string message);
+    Sass_Error(Type type, ParserState pstate, string message);
 
   };
 
-  void error(string msg, string path, Position position);
-  void error(string msg, string path, Position position, Backtrace* bt);
+  void error(string msg, ParserState pstate);
+  void error(string msg, ParserState pstate, Backtrace* bt);
 
 }
+
+#endif

data/ext/libsass/eval.cpp

@@ -9,6 +9,7 @@
 #include "context.hpp"
 #include "backtrace.hpp"
 #include "prelexer.hpp"
+#include "parser.hpp"
 
 #include <cstdlib>
 #include <cmath>
@@ -81,16 +82,16 @@ namespace Sass {
     string variable(f->variable());
     Expression* low = f->lower_bound()->perform(this);
     if (low->concrete_type() != Expression::NUMBER) {
-      error("lower bound of `@for` directive must be numeric", low->path(), low->position());
+      error("lower bound of `@for` directive must be numeric", low->pstate());
     }
     Expression* high = f->upper_bound()->perform(this);
     if (high->concrete_type() != Expression::NUMBER) {
-      error("upper bound of `@for` directive must be numeric", high->path(), high->position());
+      error("upper bound of `@for` directive must be numeric", high->pstate());
     }
     double start = static_cast<Number*>(low)->value();
     double end = static_cast<Number*>(high)->value();
     Env new_env;
-    new_env[variable] = new (ctx.mem) Number(low->path(), low->position(), start);
+    new_env[variable] = new (ctx.mem) Number(low->pstate(), start);
     new_env.link(env);
     env = &new_env;
     Block* body = f->block();
@@ -99,7 +100,7 @@ namespace Sass {
       if (f->is_inclusive()) ++end;
       for (double i = start;
            i < end;
-           (*env)[variable] = new (ctx.mem) Number(low->path(), low->position(), ++i)) {
+           (*env)[variable] = new (ctx.mem) Number(low->pstate(), ++i)) {
         val = body->perform(this);
         if (val) break;
       }
@@ -107,7 +108,7 @@ namespace Sass {
       if (f->is_inclusive()) --end;
       for (double i = start;
            i > end;
-           (*env)[variable] = new (ctx.mem) Number(low->path(), low->position(), --i)) {
+           (*env)[variable] = new (ctx.mem) Number(low->pstate(), --i)) {
         val = body->perform(this);
         if (val) break;
       }
@@ -126,7 +127,7 @@ namespace Sass {
       map = static_cast<Map*>(expr);
     }
     else if (expr->concrete_type() != Expression::LIST) {
-      list = new (ctx.mem) List(expr->path(), expr->position(), 1, List::COMMA);
+      list = new (ctx.mem) List(expr->pstate(), 1, List::COMMA);
       *list << expr;
     }
     else {
@@ -144,7 +145,7 @@ namespace Sass {
         Expression* value = map->at(key);
 
         if (variables.size() == 1) {
-          List* variable = new (ctx.mem) List(map->path(), map->position(), 2, List::SPACE);
+          List* variable = new (ctx.mem) List(map->pstate(), 2, List::SPACE);
           *variable << key;
           *variable << value;
           (*env)[variables[0]] = variable;
@@ -161,7 +162,7 @@ namespace Sass {
       for (size_t i = 0, L = list->length(); i < L; ++i) {
         List* variable = 0;
         if ((*list)[i]->concrete_type() != Expression::LIST || variables.size() == 1) {
-          variable = new (ctx.mem) List((*list)[i]->path(), (*list)[i]->position(), 1, List::COMMA);
+          variable = new (ctx.mem) List((*list)[i]->pstate(), 1, List::COMMA);
           *variable << (*list)[i];
         }
         else {
@@ -172,7 +173,7 @@ namespace Sass {
             (*env)[variables[j]] = (*variable)[j];
           }
           else {
-            (*env)[variables[j]] = new (ctx.mem) Null(expr->path(), expr->position());
+            (*env)[variables[j]] = new (ctx.mem) Null(expr->pstate());
           }
           val = body->perform(this);
           if (val) break;
@@ -203,7 +204,7 @@ namespace Sass {
   Expression* Eval::operator()(Warning* w)
   {
     Expression* message = w->message()->perform(this);
-    To_String to_string;
+    To_String to_string(&ctx);
 
     // try to use generic function
     if (env->has("@warn[f]")) {
@@ -224,7 +225,7 @@ namespace Sass {
     }
 
     string result(unquote(message->perform(&to_string)));
-    Backtrace top(backtrace, w->path(), w->position(), "");
+    Backtrace top(backtrace, w->pstate(), "");
     cerr << "WARNING: " << result;
     cerr << top.to_string(true);
     cerr << endl << endl;
@@ -234,7 +235,7 @@ namespace Sass {
   Expression* Eval::operator()(Error* e)
   {
     Expression* message = e->message()->perform(this);
-    To_String to_string;
+    To_String to_string(&ctx);
 
     // try to use generic function
     if (env->has("@error[f]")) {
@@ -255,7 +256,7 @@ namespace Sass {
     }
 
     string result(unquote(message->perform(&to_string)));
-    Backtrace top(backtrace, e->path(), e->position(), "");
+    Backtrace top(backtrace, e->pstate(), "");
     cerr << "Error: " << result;
     cerr << top.to_string(true);
     cerr << endl << endl;
@@ -265,7 +266,7 @@ namespace Sass {
   Expression* Eval::operator()(Debug* d)
   {
     Expression* message = d->value()->perform(this);
-    To_String to_string;
+    To_String to_string(&ctx);
 
     // try to use generic function
     if (env->has("@debug[f]")) {
@@ -287,8 +288,8 @@ namespace Sass {
 
     string cwd(ctx.get_cwd());
     string result(unquote(message->perform(&to_string)));
-    string rel_path(Sass::File::resolve_relative_path(d->path(), cwd, cwd));
-    cerr << rel_path << ":" << d->position().line << ":" << " DEBUG: " << result;
+    string rel_path(Sass::File::resolve_relative_path(d->pstate().path, cwd, cwd));
+    cerr << rel_path << ":" << d->pstate().line << ":" << " DEBUG: " << result;
     cerr << endl;
     return 0;
   }
@@ -296,8 +297,7 @@ namespace Sass {
   Expression* Eval::operator()(List* l)
   {
     if (l->is_expanded()) return l;
-    List* ll = new (ctx.mem) List(l->path(),
-                                  l->position(),
+    List* ll = new (ctx.mem) List(l->pstate(),
                                   l->length(),
                                   l->separator(),
                                   l->is_arglist());
@@ -311,8 +311,7 @@ namespace Sass {
   Expression* Eval::operator()(Map* m)
   {
     if (m->is_expanded()) return m;
-    Map* mm = new (ctx.mem) Map(m->path(),
-                                  m->position(),
+    Map* mm = new (ctx.mem) Map(m->pstate(),
                                   m->length());
     for (auto key : m->keys()) {
       *mm << std::make_pair(key->perform(this), m->at(key)->perform(this));
@@ -337,9 +336,10 @@ namespace Sass {
     // don't eval delayed expressions (the '/' when used as a separator)
     if (op_type == Binary_Expression::DIV && b->is_delayed()) return b;
     // if one of the operands is a '/' then make sure it's evaluated
-    if (typeid(*b->left()) == typeid(Binary_Expression)) b->left()->is_delayed(false);
-    // the logical connectives need to short-circuit
     Expression* lhs = b->left()->perform(this);
+    lhs->is_delayed(false);
+    while (typeid(*lhs) == typeid(Binary_Expression)) lhs = lhs->perform(this);
+
     switch (op_type) {
       case Binary_Expression::AND:
         return *lhs ? b->right()->perform(this) : lhs;
@@ -354,15 +354,17 @@ namespace Sass {
     }
     // not a logical connective, so go ahead and eval the rhs
     Expression* rhs = b->right()->perform(this);
+    rhs->is_delayed(false);
+    while (typeid(*rhs) == typeid(Binary_Expression)) rhs = rhs->perform(this);
 
     // see if it's a relational expression
     switch(op_type) {
-      case Binary_Expression::EQ:  return new (ctx.mem) Boolean(b->path(), b->position(), eq(lhs, rhs, ctx));
-      case Binary_Expression::NEQ: return new (ctx.mem) Boolean(b->path(), b->position(), !eq(lhs, rhs, ctx));
-      case Binary_Expression::GT:  return new (ctx.mem) Boolean(b->path(), b->position(), !lt(lhs, rhs, ctx) && !eq(lhs, rhs, ctx));
-      case Binary_Expression::GTE: return new (ctx.mem) Boolean(b->path(), b->position(), !lt(lhs, rhs, ctx));
-      case Binary_Expression::LT:  return new (ctx.mem) Boolean(b->path(), b->position(), lt(lhs, rhs, ctx));
-      case Binary_Expression::LTE: return new (ctx.mem) Boolean(b->path(), b->position(), lt(lhs, rhs, ctx) || eq(lhs, rhs, ctx));
+      case Binary_Expression::EQ:  return new (ctx.mem) Boolean(b->pstate(), eq(lhs, rhs, ctx));
+      case Binary_Expression::NEQ: return new (ctx.mem) Boolean(b->pstate(), !eq(lhs, rhs, ctx));
+      case Binary_Expression::GT:  return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx) && !eq(lhs, rhs, ctx));
+      case Binary_Expression::GTE: return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx));
+      case Binary_Expression::LT:  return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx));
+      case Binary_Expression::LTE: return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx) || eq(lhs, rhs, ctx));
 
       default:                     break;
     }
@@ -382,14 +384,25 @@ namespace Sass {
     if (l_type == Expression::COLOR && r_type == Expression::COLOR) {
       return op_colors(ctx, op_type, lhs, rhs);
     }
-    return op_strings(ctx, op_type, lhs, rhs);
+
+    Expression* ex = op_strings(ctx, op_type, lhs, rhs);
+    if (String_Constant* str = (String_Constant*) ex)
+    {
+      if (str->concrete_type() != Expression::STRING) return ex;
+      String_Constant* lstr = dynamic_cast<String_Constant*>(lhs);
+      String_Constant* rstr = dynamic_cast<String_Constant*>(rhs);
+      if (String_Constant* org = lstr ? lstr : rstr)
+      { str->quote_mark(org->quote_mark()); }
+    }
+    return ex;
+
   }
 
   Expression* Eval::operator()(Unary_Expression* u)
   {
     Expression* operand = u->operand()->perform(this);
     if (u->type() == Unary_Expression::NOT) {
-      Boolean* result = new (ctx.mem) Boolean(u->path(), u->position(), (bool)*operand);
+      Boolean* result = new (ctx.mem) Boolean(u->pstate(), (bool)*operand);
       result->value(!result->value());
       return result;
     }
@@ -401,15 +414,14 @@ namespace Sass {
       return result;
     }
     else {
-      To_String to_string;
+      To_String to_string(&ctx);
       // Special cases: +/- variables which evaluate to null ouput just +/-,
       // but +/- null itself outputs the string
       if (operand->concrete_type() == Expression::NULL_VAL && typeid(*(u->operand())) == typeid(Variable)) {
-        u->operand(new (ctx.mem) String_Constant(u->path(), u->position(), ""));
+        u->operand(new (ctx.mem) String_Constant(u->pstate(), ""));
       }
       else u->operand(operand);
-      String_Constant* result = new (ctx.mem) String_Constant(u->path(),
-                                                              u->position(),
+      String_Constant* result = new (ctx.mem) String_Constant(u->pstate(),
                                                               u->perform(&to_string));
       return result;
     }
@@ -434,13 +446,11 @@ namespace Sass {
 
     // if it doesn't exist, just pass it through as a literal
     if (!env->has(full_name)) {
-      Function_Call* lit = new (ctx.mem) Function_Call(c->path(),
-                                                       c->position(),
+      Function_Call* lit = new (ctx.mem) Function_Call(c->pstate(),
                                                        c->name(),
                                                        args);
-      To_String to_string;
-      return new (ctx.mem) String_Constant(c->path(),
-                                           c->position(),
+      To_String to_string(&ctx);
+      return new (ctx.mem) String_Constant(c->pstate(),
                                            lit->perform(&to_string));
     }
 
@@ -473,12 +483,12 @@ namespace Sass {
       Env* old_env = env;
       env = &new_env;
 
-      Backtrace here(backtrace, c->path(), c->position(), ", in function `" + c->name() + "`");
+      Backtrace here(backtrace, c->pstate(), ", in function `" + c->name() + "`");
       backtrace = &here;
 
       result = body->perform(this);
       if (!result) {
-        error(string("function ") + c->name() + " did not return a value", c->path(), c->position());
+        error(string("function ") + c->name() + " did not return a value", c->pstate());
       }
       backtrace = here.parent;
       env = old_env;
@@ -490,10 +500,10 @@ namespace Sass {
       Env* old_env = env;
       env = &new_env;
 
-      Backtrace here(backtrace, c->path(), c->position(), ", in function `" + c->name() + "`");
+      Backtrace here(backtrace, c->pstate(), ", in function `" + c->name() + "`");
       backtrace = &here;
 
-      result = func(*env, *old_env, ctx, def->signature(), c->path(), c->position(), backtrace);
+      result = func(*env, *old_env, ctx, def->signature(), c->pstate(), backtrace);
 
       backtrace = here.parent;
       env = old_env;
@@ -502,9 +512,9 @@ namespace Sass {
     else if (c_func) {
 
       if (full_name == "*[f]") {
-        String_Constant *str = new (ctx.mem) String_Constant(c->path(), c->position(), c->name());
-        Arguments* new_args = new (ctx.mem) Arguments(c->path(), c->position());
-        *new_args << new (ctx.mem) Argument(c->path(), c->position(), str);
+        String_Constant *str = new (ctx.mem) String_Constant(c->pstate(), c->name());
+        Arguments* new_args = new (ctx.mem) Arguments(c->pstate());
+        *new_args << new (ctx.mem) Argument(c->pstate(), str);
         *new_args += args;
         args = new_args;
       }
@@ -514,7 +524,7 @@ namespace Sass {
       Env* old_env = env;
       env = &new_env;
 
-      Backtrace here(backtrace, c->path(), c->position(), ", in function `" + c->name() + "`");
+      Backtrace here(backtrace, c->pstate(), ", in function `" + c->name() + "`");
       backtrace = &here;
 
       To_C to_c;
@@ -527,11 +537,11 @@ namespace Sass {
       }
       Sass_Value* c_val = c_func(c_args, def->cookie());
       if (sass_value_get_tag(c_val) == SASS_ERROR) {
-        error("error in C function " + c->name() + ": " + sass_error_get_message(c_val), c->path(), c->position(), backtrace);
+        error("error in C function " + c->name() + ": " + sass_error_get_message(c_val), c->pstate(), backtrace);
       } else if (sass_value_get_tag(c_val) == SASS_WARNING) {
-        error("warning in C function " + c->name() + ": " + sass_warning_get_message(c_val), c->path(), c->position(), backtrace);
+        error("warning in C function " + c->name() + ": " + sass_warning_get_message(c_val), c->pstate(), backtrace);
       }
-      result = cval_to_astnode(c_val, ctx, backtrace, c->path(), c->position());
+      result = cval_to_astnode(c_val, ctx, backtrace, c->pstate());
 
       backtrace = here.parent;
       sass_delete_value(c_args);
@@ -545,7 +555,7 @@ namespace Sass {
       stringstream ss;
       ss << full_name << arity;
       string resolved_name(ss.str());
-      if (!env->has(resolved_name)) error("overloaded function `" + string(c->name()) + "` given wrong number of arguments", c->path(), c->position());
+      if (!env->has(resolved_name)) error("overloaded function `" + string(c->name()) + "` given wrong number of arguments", c->pstate());
       Definition* resolved_def = static_cast<Definition*>((*env)[resolved_name]);
       params = resolved_def->parameters();
       Env newer_env;
@@ -554,10 +564,10 @@ namespace Sass {
       Env* old_env = env;
       env = &newer_env;
 
-      Backtrace here(backtrace, c->path(), c->position(), ", in function `" + c->name() + "`");
+      Backtrace here(backtrace, c->pstate(), ", in function `" + c->name() + "`");
       backtrace = &here;
 
-      result = resolved_def->native_function()(*env, *old_env, ctx, resolved_def->signature(), c->path(), c->position(), backtrace);
+      result = resolved_def->native_function()(*env, *old_env, ctx, resolved_def->signature(), c->pstate(), backtrace);
 
       backtrace = here.parent;
       env = old_env;
@@ -565,7 +575,17 @@ namespace Sass {
 
     // backtrace = here.parent;
     // env = old_env;
-    result->position(c->position());
+
+
+    // link back to function definition
+    // only do this for custom functions
+    if (result->pstate().file == string::npos)
+      result->pstate(c->pstate());
+
+    do {
+      result->is_delayed(result->concrete_type() == Expression::STRING);
+      result = result->perform(this);
+    } while (result->concrete_type() == Expression::NONE);
     return result;
   }
 
@@ -573,35 +593,47 @@ namespace Sass {
   {
     Expression* evaluated_name = s->name()->perform(this);
     Expression* evaluated_args = s->arguments()->perform(this);
-    String_Schema* ss = new (ctx.mem) String_Schema(s->path(), s->position(), 2);
+    String_Schema* ss = new (ctx.mem) String_Schema(s->pstate(), 2);
     (*ss) << evaluated_name << evaluated_args;
     return ss->perform(this);
   }
 
   Expression* Eval::operator()(Variable* v)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     string name(v->name());
     Expression* value = 0;
     if (env->has(name)) value = static_cast<Expression*>((*env)[name]);
-    else error("unbound variable " + v->name(), v->path(), v->position());
+    else error("Undefined variable: \"" + v->name() + "\".", v->pstate());
     // cerr << "name: " << v->name() << "; type: " << typeid(*value).name() << "; value: " << value->perform(&to_string) << endl;
     if (typeid(*value) == typeid(Argument)) value = static_cast<Argument*>(value)->value();
 
     // behave according to as ruby sass (add leading zero)
     if (value->concrete_type() == Expression::NUMBER) {
-      Number* n = static_cast<Number*>(value);
-      value = new (ctx.mem) Number(n->path(),
-                                   n->position(),
-                                   n->value(),
-                                   n->unit(),
-                                   true);
+      value = new (ctx.mem) Number(*static_cast<Number*>(value));
+      static_cast<Number*>(value)->zero(true);
     }
     else if (value->concrete_type() == Expression::STRING) {
-      String_Constant* s = static_cast<String_Constant*>(value);
-      value = new (ctx.mem) String_Constant(s->path(),
-                                            s->position(),
-                                            s->value());
+      if (auto str = dynamic_cast<String_Quoted*>(value)) {
+        value = new (ctx.mem) String_Quoted(*str);
+      } else if (auto str = dynamic_cast<String_Constant*>(value)) {
+        value = new (ctx.mem) String_Constant(*str);
+      }
+    }
+    else if (value->concrete_type() == Expression::LIST) {
+      value = new (ctx.mem) List(*static_cast<List*>(value));
+    }
+    else if (value->concrete_type() == Expression::MAP) {
+      value = new (ctx.mem) Map(*static_cast<Map*>(value));
+    }
+    else if (value->concrete_type() == Expression::BOOLEAN) {
+      value = new (ctx.mem) Boolean(*static_cast<Boolean*>(value));
+    }
+    else if (value->concrete_type() == Expression::COLOR) {
+      value = new (ctx.mem) Color(*static_cast<Color*>(value));
+    }
+    else if (value->concrete_type() == Expression::NULL_VAL) {
+      value = new (ctx.mem) Null(value->pstate());
     }
 
     // cerr << "\ttype is now: " << typeid(*value).name() << endl << endl;
@@ -625,24 +657,21 @@ namespace Sass {
     switch (t->type())
     {
       case Textual::NUMBER:
-        result = new (ctx.mem) Number(t->path(),
-                                      t->position(),
-                                      atof(num.c_str()),
+        result = new (ctx.mem) Number(t->pstate(),
+                                      sass_atof(num.c_str()),
                                       "",
                                       zero);
         break;
       case Textual::PERCENTAGE:
-        result = new (ctx.mem) Number(t->path(),
-                                      t->position(),
-                                      atof(num.c_str()),
+        result = new (ctx.mem) Number(t->pstate(),
+                                      sass_atof(num.c_str()),
                                       "%",
                                       zero);
         break;
       case Textual::DIMENSION:
-        result = new (ctx.mem) Number(t->path(),
-                                      t->position(),
-                                      atof(num.c_str()),
-                                      Token(number(text.c_str())),
+        result = new (ctx.mem) Number(t->pstate(),
+                                      sass_atof(num.c_str()),
+                                      Token(number(text.c_str()), t->pstate()),
                                       zero);
         break;
       case Textual::HEX: {
@@ -651,8 +680,7 @@ namespace Sass {
           string r(hext.substr(0,2));
           string g(hext.substr(2,2));
           string b(hext.substr(4,2));
-          result = new (ctx.mem) Color(t->path(),
-                                       t->position(),
+          result = new (ctx.mem) Color(t->pstate(),
                                        static_cast<double>(strtol(r.c_str(), NULL, 16)),
                                        static_cast<double>(strtol(g.c_str(), NULL, 16)),
                                        static_cast<double>(strtol(b.c_str(), NULL, 16)),
@@ -660,8 +688,7 @@ namespace Sass {
                                        t->value());
         }
         else {
-          result = new (ctx.mem) Color(t->path(),
-                                       t->position(),
+          result = new (ctx.mem) Color(t->pstate(),
                                        static_cast<double>(strtol(string(2,hext[0]).c_str(), NULL, 16)),
                                        static_cast<double>(strtol(string(2,hext[1]).c_str(), NULL, 16)),
                                        static_cast<double>(strtol(string(2,hext[2]).c_str(), NULL, 16)),
@@ -676,8 +703,7 @@ namespace Sass {
   Expression* Eval::operator()(Number* n)
   {
     // behave according to as ruby sass (add leading zero)
-    return new (ctx.mem) Number(n->path(),
-                                n->position(),
+    return new (ctx.mem) Number(n->pstate(),
                                 n->value(),
                                 n->unit(),
                                 true);
@@ -700,32 +726,93 @@ namespace Sass {
     }
   }
 
+  string Eval::interpolation(Expression* s) {
+
+    if (String_Quoted* str_quoted = dynamic_cast<String_Quoted*>(s)) {
+
+      if (str_quoted->quote_mark()) {
+        return string_escape(str_quoted->value());
+      } else {
+        return evacuate_escapes(str_quoted->value());
+      }
+
+    } else if (String_Constant* str_constant = dynamic_cast<String_Constant*>(s)) {
+
+      return evacuate_escapes(str_constant->value());
+
+    } else if (String_Schema* str_schema = dynamic_cast<String_Schema*>(s)) {
+
+      string res = "";
+      for(auto i : str_schema->elements())
+        res += (interpolation(i));
+      //ToDo: do this in one step
+      auto esc = evacuate_escapes(res);
+      auto unq = unquote(esc);
+      if (unq == esc) {
+        return string_to_output(res);
+      } else {
+        return evacuate_quotes(unq);
+      }
+
+    } else if (List* list = dynamic_cast<List*>(s)) {
+
+      string acc = ""; // ToDo: different output styles
+      string sep = list->separator() == List::Separator::COMMA ? "," : " ";
+      if (ctx.output_style != COMPRESSED && sep == ",") sep += " ";
+      bool initial = false;
+      for(auto item : list->elements()) {
+        if (initial) acc += sep;
+        acc += interpolation(item);
+        initial = true;
+      }
+      return evacuate_quotes(acc);
+
+    } else if (Variable* var = dynamic_cast<Variable*>(s)) {
+
+      string name(var->name());
+      if (!env->has(name)) error("Undefined variable: \"" + var->name() + "\".", var->pstate());
+      Expression* value = static_cast<Expression*>((*env)[name]);
+      return evacuate_quotes(interpolation(value));
+
+    } else if (Binary_Expression* var = dynamic_cast<Binary_Expression*>(s)) {
+
+      Expression* ex = operator()(var);
+      return evacuate_quotes(interpolation(ex));
+
+    } else if (Function_Call* var = dynamic_cast<Function_Call*>(s)) {
+
+      Expression* ex = operator()(var);
+      return evacuate_quotes(interpolation(ex));
+
+    } else {
+
+      To_String to_string(&ctx);
+      // to_string.in_decl_list = true;
+      return evacuate_quotes(s->perform(&to_string));
+
+    }
+  }
+
   Expression* Eval::operator()(String_Schema* s)
   {
     string acc;
-    ctx._skip_source_map_update = true;
-    To_String to_string(&ctx);
-    ctx._skip_source_map_update = false;
     for (size_t i = 0, L = s->length(); i < L; ++i) {
-      string chunk((*s)[i]->perform(this)->perform(&to_string));
-      if (((s->quote_mark() && is_quoted(chunk)) || !s->quote_mark()) && (*s)[i]->is_interpolant()) { // some redundancy in that test
-        acc += unquote(chunk);
-      }
-      else {
-        acc += chunk;
-      }
+      acc += interpolation((*s)[i]);
     }
-    return new (ctx.mem) String_Constant(s->path(),
-                                         s->position(),
-                                         acc);
+    String_Quoted* str = new (ctx.mem) String_Quoted(s->pstate(), acc);
+    if (!str->quote_mark()) {
+      str->value(string_unescape(str->value()));
+    } else if (str->quote_mark()) {
+      str->quote_mark('*');
+    }
+    return str;
   }
 
   Expression* Eval::operator()(String_Constant* s)
   {
-    if (!s->is_delayed() && ctx.names_to_colors.count(s->value())) {
+    if (!s->quote_mark() && !s->is_delayed() && ctx.names_to_colors.count(s->value())) {
       Color* c = new (ctx.mem) Color(*ctx.names_to_colors[s->value()]);
-      c->path(s->path());
-      c->position(s->position());
+      c->pstate(s->pstate());
       c->disp(s->value());
       return c;
     }
@@ -734,8 +821,7 @@ namespace Sass {
 
   Expression* Eval::operator()(Feature_Query* q)
   {
-    Feature_Query* qq = new (ctx.mem) Feature_Query(q->path(),
-                                                    q->position(),
+    Feature_Query* qq = new (ctx.mem) Feature_Query(q->pstate(),
                                                     q->length());
     for (size_t i = 0, L = q->length(); i < L; ++i) {
       *qq << static_cast<Feature_Query_Condition*>((*q)[i]->perform(this));
@@ -748,8 +834,7 @@ namespace Sass {
     String* feature = c->feature();
     Expression* value = c->value();
     value = (value ? value->perform(this) : 0);
-    Feature_Query_Condition* cc = new (ctx.mem) Feature_Query_Condition(c->path(),
-                                                 c->position(),
+    Feature_Query_Condition* cc = new (ctx.mem) Feature_Query_Condition(c->pstate(),
                                                  c->length(),
                                                  feature,
                                                  value,
@@ -761,12 +846,25 @@ namespace Sass {
     return cc;
   }
 
+  Expression* Eval::operator()(At_Root_Expression* e)
+  {
+    Expression* feature = e->feature();
+    feature = (feature ? feature->perform(this) : 0);
+    Expression* value = e->value();
+    value = (value ? value->perform(this) : 0);
+    Expression* ee = new (ctx.mem) At_Root_Expression(e->pstate(),
+                                                      static_cast<String*>(feature),
+                                                      value,
+                                                      e->is_interpolated());
+    return ee;
+  }
+
   Expression* Eval::operator()(Media_Query* q)
   {
+    To_String to_string(&ctx);
     String* t = q->media_type();
     t = static_cast<String*>(t ? t->perform(this) : 0);
-    Media_Query* qq = new (ctx.mem) Media_Query(q->path(),
-                                                q->position(),
+    Media_Query* qq = new (ctx.mem) Media_Query(q->pstate(),
                                                 t,
                                                 q->length(),
                                                 q->is_negated(),
@@ -783,8 +881,7 @@ namespace Sass {
     feature = (feature ? feature->perform(this) : 0);
     Expression* value = e->value();
     value = (value ? value->perform(this) : 0);
-    return new (ctx.mem) Media_Query_Expression(e->path(),
-                                                e->position(),
+    return new (ctx.mem) Media_Query_Expression(e->pstate(),
                                                 feature,
                                                 value,
                                                 e->is_interpolated());
@@ -812,8 +909,7 @@ namespace Sass {
       }
       else
       if(val->concrete_type() != Expression::LIST) {
-        List* wrapper = new (ctx.mem) List(val->path(),
-                                           val->position(),
+        List* wrapper = new (ctx.mem) List(val->pstate(),
                                            0,
                                            List::COMMA,
                                            true);
@@ -821,8 +917,7 @@ namespace Sass {
         val = wrapper;
       }
     }
-    return new (ctx.mem) Argument(a->path(),
-                                  a->position(),
+    return new (ctx.mem) Argument(a->pstate(),
                                   val,
                                   a->name(),
                                   is_rest_argument,
@@ -831,13 +926,18 @@ namespace Sass {
 
   Expression* Eval::operator()(Arguments* a)
   {
-    Arguments* aa = new (ctx.mem) Arguments(a->path(), a->position());
+    Arguments* aa = new (ctx.mem) Arguments(a->pstate());
     for (size_t i = 0, L = a->length(); i < L; ++i) {
       *aa << static_cast<Argument*>((*a)[i]->perform(this));
     }
     return aa;
   }
 
+  Expression* Eval::operator()(Comment* c)
+  {
+    return 0;
+  }
+
   inline Expression* Eval::fallback_impl(AST_Node* n)
   {
     return static_cast<Expression*>(n);
@@ -913,7 +1013,7 @@ namespace Sass {
   {
     if (lhs->concrete_type() != Expression::NUMBER ||
         rhs->concrete_type() != Expression::NUMBER)
-      error("may only compare numbers", lhs->path(), lhs->position());
+      error("may only compare numbers", lhs->pstate());
     Number* l = static_cast<Number*>(lhs);
     Number* r = static_cast<Number*>(rhs);
     Number tmp_r(*r);
@@ -921,7 +1021,7 @@ namespace Sass {
     string l_unit(l->unit());
     string r_unit(tmp_r.unit());
     if (!l_unit.empty() && !r_unit.empty() && l->unit() != tmp_r.unit()) {
-      error("cannot compare numbers with incompatible units", l->path(), l->position());
+      error("cannot compare numbers with incompatible units", l->pstate());
     }
     return l->value() < tmp_r.value();
   }
@@ -934,10 +1034,10 @@ namespace Sass {
     double rv = r->value();
     Binary_Expression::Type op = b->type();
     if (op == Binary_Expression::DIV && !rv) {
-      return new (ctx.mem) String_Constant(l->path(), b->position(), "Infinity");
+      return new (ctx.mem) String_Constant(l->pstate(), "Infinity");
     }
     if (op == Binary_Expression::MOD && !rv) {
-      error("division by zero", r->path(), r->position());
+      error("division by zero", r->pstate());
     }
 
     Number tmp(*r);
@@ -946,10 +1046,10 @@ namespace Sass {
     string r_unit(tmp.unit());
     if (l_unit != r_unit && !l_unit.empty() && !r_unit.empty() &&
         (op == Binary_Expression::ADD || op == Binary_Expression::SUB)) {
-      error("cannot add or subtract numbers with incompatible units", l->path(), l->position());
+      error("Incompatible units: '"+r_unit+"' and '"+l_unit+"'.", l->pstate());
     }
     Number* v = new (ctx.mem) Number(*l);
-    v->position(b->position());
+    v->pstate(b->pstate());
     if (l_unit.empty() && (op == Binary_Expression::ADD || op == Binary_Expression::SUB || op == Binary_Expression::MOD)) {
       v->numerator_units() = r->numerator_units();
       v->denominator_units() = r->denominator_units();
@@ -988,8 +1088,7 @@ namespace Sass {
     switch (op) {
       case Binary_Expression::ADD:
       case Binary_Expression::MUL: {
-        return new (ctx.mem) Color(l->path(),
-                                   l->position(),
+        return new (ctx.mem) Color(l->pstate(),
                                    ops[op](lv, r->r()),
                                    ops[op](lv, r->g()),
                                    ops[op](lv, r->b()),
@@ -998,17 +1097,17 @@ namespace Sass {
       case Binary_Expression::SUB:
       case Binary_Expression::DIV: {
         string sep(op == Binary_Expression::SUB ? "-" : "/");
-        To_String to_string;
-        string color(r->sixtuplet() ? r->perform(&to_string) :
+        To_String to_string(&ctx);
+        string color(r->sixtuplet() && (ctx.output_style != COMPRESSED) ?
+                     r->perform(&to_string) :
                      Util::normalize_sixtuplet(r->perform(&to_string)));
-        return new (ctx.mem) String_Constant(l->path(),
-                                             l->position(),
+        return new (ctx.mem) String_Constant(l->pstate(),
                                              l->perform(&to_string)
                                              + sep
                                              + color);
       } break;
       case Binary_Expression::MOD: {
-        error("cannot divide a number by a color", r->path(), r->position());
+        error("cannot divide a number by a color", r->pstate());
       } break;
       default: break; // caller should ensure that we don't get here
     }
@@ -1021,9 +1120,8 @@ namespace Sass {
     Color* l = static_cast<Color*>(lhs);
     Number* r = static_cast<Number*>(rhs);
     double rv = r->value();
-    if (op == Binary_Expression::DIV && !rv) error("division by zero", r->path(), r->position());
-    return new (ctx.mem) Color(l->path(),
-                               l->position(),
+    if (op == Binary_Expression::DIV && !rv) error("division by zero", r->pstate());
+    return new (ctx.mem) Color(l->pstate(),
                                ops[op](l->r(), rv),
                                ops[op](l->g(), rv),
                                ops[op](l->b(), rv),
@@ -1035,14 +1133,13 @@ namespace Sass {
     Color* l = static_cast<Color*>(lhs);
     Color* r = static_cast<Color*>(rhs);
     if (l->a() != r->a()) {
-      error("alpha channels must be equal when combining colors", r->path(), r->position());
+      error("alpha channels must be equal when combining colors", r->pstate());
     }
     if ((op == Binary_Expression::DIV || op == Binary_Expression::MOD) &&
         (!r->r() || !r->g() ||!r->b())) {
-      error("division by zero", r->path(), r->position());
+      error("division by zero", r->pstate());
     }
-    return new (ctx.mem) Color(l->path(),
-                               l->position(),
+    return new (ctx.mem) Color(l->pstate(),
                                ops[op](l->r(), r->r()),
                                ops[op](l->g(), r->g()),
                                ops[op](l->b(), r->b()),
@@ -1051,20 +1148,18 @@ namespace Sass {
 
   Expression* op_strings(Context& ctx, Binary_Expression::Type op, Expression* lhs, Expression*rhs)
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     Expression::Concrete_Type ltype = lhs->concrete_type();
     Expression::Concrete_Type rtype = rhs->concrete_type();
 
     string lstr(lhs->perform(&to_string));
     string rstr(rhs->perform(&to_string));
 
-    bool l_str_quoted = ((Sass::String*)lhs) && ((Sass::String*)lhs)->needs_unquoting();
-    bool r_str_quoted = ((Sass::String*)rhs) && ((Sass::String*)rhs)->needs_unquoting();
+    bool l_str_quoted = ((Sass::String*)lhs) && ((Sass::String*)lhs)->sass_fix_1291();
+    bool r_str_quoted = ((Sass::String*)rhs) && ((Sass::String*)rhs)->sass_fix_1291();
     bool l_str_color = ltype == Expression::STRING && ctx.names_to_colors.count(lstr) && !l_str_quoted;
     bool r_str_color = rtype == Expression::STRING && ctx.names_to_colors.count(rstr) && !r_str_quoted;
 
-    bool unquoted = false;
-    if (ltype == Expression::STRING && lstr[0] != '"' && lstr[0] != '\'') unquoted = true;
     if (l_str_color && r_str_color) {
       return op_colors(ctx, op, ctx.names_to_colors[lstr], ctx.names_to_colors[rstr]);
     }
@@ -1080,67 +1175,64 @@ namespace Sass {
     else if (ltype == Expression::NUMBER && r_str_color) {
       return op_number_color(ctx, op, lhs, ctx.names_to_colors[rstr]);
     }
-    if (op == Binary_Expression::MUL) error("invalid operands for multiplication", lhs->path(), lhs->position());
-    if (op == Binary_Expression::MOD) error("invalid operands for modulo", lhs->path(), lhs->position());
+    if (op == Binary_Expression::MUL) error("invalid operands for multiplication", lhs->pstate());
+    if (op == Binary_Expression::MOD) error("invalid operands for modulo", lhs->pstate());
     string sep;
     switch (op) {
       case Binary_Expression::SUB: sep = "-"; break;
       case Binary_Expression::DIV: sep = "/"; break;
       default:                         break;
     }
-    if (ltype == Expression::NULL_VAL) error("invalid null operation: \"null plus "+quote(unquote(rstr), '"')+"\".", lhs->path(), lhs->position());
-    if (rtype == Expression::NULL_VAL) error("invalid null operation: \""+quote(unquote(lstr), '"')+" plus null\".", lhs->path(), lhs->position());
-    char q = '\0';
-    if (lstr[0] == '"' || lstr[0] == '\'') q = lstr[0];
-    else if (rstr[0] == '"' || rstr[0] == '\'') q = rstr[0];
-    string result(unquote(lstr) + sep + unquote(rstr));
-    return new (ctx.mem) String_Constant(lhs->path(),
-                               lhs->position(),
-                               unquoted ? result : quote(result, q));
+    if (ltype == Expression::NULL_VAL) error("invalid null operation: \"null plus "+quote(unquote(rstr), '"')+"\".", lhs->pstate());
+    if (rtype == Expression::NULL_VAL) error("invalid null operation: \""+quote(unquote(lstr), '"')+" plus null\".", lhs->pstate());
+    string result((lstr) + sep + (rstr));
+    String_Quoted* str = new (ctx.mem) String_Quoted(lhs->pstate(), result);
+    str->quote_mark(0);
+    return str;
   }
 
-  Expression* cval_to_astnode(Sass_Value* v, Context& ctx, Backtrace* backtrace, string path, Position position)
+  Expression* cval_to_astnode(Sass_Value* v, Context& ctx, Backtrace* backtrace, ParserState pstate)
   {
     using std::strlen;
     using std::strcpy;
     Expression* e = 0;
     switch (sass_value_get_tag(v)) {
       case SASS_BOOLEAN: {
-        e = new (ctx.mem) Boolean(path, position, !!sass_boolean_get_value(v));
+        e = new (ctx.mem) Boolean(pstate, !!sass_boolean_get_value(v));
       } break;
       case SASS_NUMBER: {
-        e = new (ctx.mem) Number(path, position, sass_number_get_value(v), sass_number_get_unit(v));
+        e = new (ctx.mem) Number(pstate, sass_number_get_value(v), sass_number_get_unit(v));
       } break;
       case SASS_COLOR: {
-        e = new (ctx.mem) Color(path, position, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
+        e = new (ctx.mem) Color(pstate, sass_color_get_r(v), sass_color_get_g(v), sass_color_get_b(v), sass_color_get_a(v));
       } break;
       case SASS_STRING: {
-        e = new (ctx.mem) String_Constant(path, position, sass_string_get_value(v));
+        e = new (ctx.mem) String_Constant(pstate, sass_string_get_value(v));
       } break;
       case SASS_LIST: {
-        List* l = new (ctx.mem) List(path, position, sass_list_get_length(v), sass_list_get_separator(v) == SASS_COMMA ? List::COMMA : List::SPACE);
+        List* l = new (ctx.mem) List(pstate, sass_list_get_length(v), sass_list_get_separator(v) == SASS_COMMA ? List::COMMA : List::SPACE);
         for (size_t i = 0, L = sass_list_get_length(v); i < L; ++i) {
-          *l << cval_to_astnode(sass_list_get_value(v, i), ctx, backtrace, path, position);
+          *l << cval_to_astnode(sass_list_get_value(v, i), ctx, backtrace, pstate);
         }
         e = l;
       } break;
       case SASS_MAP: {
-        Map* m = new (ctx.mem) Map(path, position);
+        Map* m = new (ctx.mem) Map(pstate);
         for (size_t i = 0, L = sass_map_get_length(v); i < L; ++i) {
           *m << std::make_pair(
-            cval_to_astnode(sass_map_get_key(v, i), ctx, backtrace, path, position),
-            cval_to_astnode(sass_map_get_value(v, i), ctx, backtrace, path, position));
+            cval_to_astnode(sass_map_get_key(v, i), ctx, backtrace, pstate),
+            cval_to_astnode(sass_map_get_value(v, i), ctx, backtrace, pstate));
         }
         e = m;
       } break;
       case SASS_NULL: {
-        e = new (ctx.mem) Null(path, position);
+        e = new (ctx.mem) Null(pstate);
       } break;
       case SASS_ERROR: {
-        error("Error in C function: " + string(sass_error_get_message(v)), path, position, backtrace);
+        error("Error in C function: " + string(sass_error_get_message(v)), pstate, backtrace);
       } break;
       case SASS_WARNING: {
-        error("Warning in C function: " + string(sass_warning_get_message(v)), path, position, backtrace);
+        error("Warning in C function: " + string(sass_warning_get_message(v)), pstate, backtrace);
       } break;
     }
     return e;