sassc 0.0.9 → 0.0.10

data/ext/libsass/output.hpp

@@ -0,0 +1,56 @@
+#ifndef SASS_OUTPUT_H
+#define SASS_OUTPUT_H
+
+#include <string>
+#include <vector>
+
+#include "util.hpp"
+#include "inspect.hpp"
+#include "operation.hpp"
+
+namespace Sass {
+  class Context;
+  using namespace std;
+
+  // Refactor to make it generic to find linefeed (look behind)
+  inline bool ends_with(std::string const & value, std::string const & ending)
+  {
+    if (ending.size() > value.size()) return false;
+    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
+  }
+
+  class Output : public Inspect {
+  protected:
+    using Inspect::operator();
+
+  public:
+    // change to Emitter
+    Output(Context* ctx);
+    virtual ~Output();
+
+  protected:
+    string charset;
+    vector<Import*> top_imports;
+    vector<Comment*> top_comments;
+
+  public:
+    OutputBuffer get_buffer(void);
+
+    virtual void operator()(Ruleset*);
+    // virtual void operator()(Propset*);
+    virtual void operator()(Feature_Block*);
+    virtual void operator()(Media_Block*);
+    virtual void operator()(At_Rule*);
+    virtual void operator()(Keyframe_Rule*);
+    virtual void operator()(Import*);
+    virtual void operator()(Comment*);
+    virtual void operator()(String_Quoted*);
+    virtual void operator()(String_Constant*);
+
+    void fallback_impl(AST_Node* n);
+
+  };
+
+}
+
+#endif

data/ext/libsass/parser.cpp

@@ -7,11 +7,7 @@
 #include "to_string.hpp"
 #include "constants.hpp"
 #include "util.hpp"
-
-#ifndef SASS_PRELEXER
 #include "prelexer.hpp"
-#endif
-
 #include "sass_functions.h"
 
 #include <typeinfo>
@@ -20,36 +16,60 @@ namespace Sass {
   using namespace std;
   using namespace Constants;
 
-  Parser Parser::from_c_str(const char* str, Context& ctx, string path, Position source_position)
+  Parser Parser::from_c_str(const char* str, Context& ctx, ParserState pstate)
   {
-    Parser p(ctx, path, source_position);
+    Parser p(ctx, pstate);
     p.source   = str;
     p.position = p.source;
     p.end      = str + strlen(str);
+    Block* root = new (ctx.mem) Block(pstate);
+    p.block_stack.push_back(root);
+    root->is_root(true);
+    return p;
+  }
+
+  Parser Parser::from_c_str(const char* beg, const char* end, Context& ctx, ParserState pstate)
+  {
+    Parser p(ctx, pstate);
+    p.source   = beg;
+    p.position = p.source;
+    p.end      = end;
+    Block* root = new (ctx.mem) Block(pstate);
+    p.block_stack.push_back(root);
+    root->is_root(true);
     return p;
   }
 
-  Parser Parser::from_token(Token t, Context& ctx, string path, Position source_position)
+  bool Parser::peek_newline(const char* start)
+  {
+    return peek_linefeed(start ? start : position);
+  }
+
+  Parser Parser::from_token(Token t, Context& ctx, ParserState pstate)
   {
-    Parser p(ctx, path, source_position);
+    Parser p(ctx, pstate);
     p.source   = t.begin;
     p.position = p.source;
     p.end      = t.end;
-    p.dequote  = true;
+    Block* root = new (ctx.mem) Block(pstate);
+    p.block_stack.push_back(root);
+    root->is_root(true);
     return p;
   }
 
   Block* Parser::parse()
   {
-    Block* root = new (ctx.mem) Block(path, source_position);
+    Block* root = new (ctx.mem) Block(pstate);
+    block_stack.push_back(root);
     root->is_root(true);
     read_bom();
     lex< optional_spaces >();
     Selector_Lookahead lookahead_result;
     while (position < end) {
       if (lex< block_comment >()) {
+        bool is_important = lexed.begin[2] == '!';
         String*  contents = parse_interpolated_chunk(lexed);
-        Comment* comment  = new (ctx.mem) Comment(path, source_position, contents);
+        Comment* comment  = new (ctx.mem) Comment(pstate, contents, is_important);
         (*root) << comment;
       }
       else if (peek< import >()) {
@@ -57,25 +77,25 @@ namespace Sass {
         if (!imp->urls().empty()) (*root) << imp;
         if (!imp->files().empty()) {
           for (size_t i = 0, S = imp->files().size(); i < S; ++i) {
-            (*root) << new (ctx.mem) Import_Stub(path, source_position, imp->files()[i]);
+            (*root) << new (ctx.mem) Import_Stub(pstate, imp->files()[i]);
           }
         }
-        if (!lex< one_plus< exactly<';'> > >()) error("top-level @import directive must be terminated by ';'");
+        if (!lex< one_plus< exactly<';'> > >()) error("top-level @import directive must be terminated by ';'", pstate);
       }
       else if (peek< mixin >() || peek< function >()) {
         (*root) << parse_definition();
       }
       else if (peek< variable >()) {
         (*root) << parse_assignment();
-        if (!lex< one_plus< exactly<';'> > >()) error("top-level variable binding must be terminated by ';'");
+        if (!lex< one_plus< exactly<';'> > >()) error("top-level variable binding must be terminated by ';'", pstate);
       }
-      else if (peek< sequence< optional< exactly<'*'> >, alternatives< identifier_schema, identifier >, optional_spaces, exactly<':'>, optional_spaces, exactly<'{'> > >(position)) {
+      /*else if (peek< sequence< optional< exactly<'*'> >, alternatives< identifier_schema, identifier >, optional_spaces, exactly<':'>, optional_spaces, exactly<'{'> > >(position)) {
         (*root) << parse_propset();
-      }
+      }*/
       else if (peek< include >() /* || peek< exactly<'+'> >() */) {
         Mixin_Call* mixin_call = parse_mixin_call();
         (*root) << mixin_call;
-        if (!mixin_call->block() && !lex< one_plus< exactly<';'> > >()) error("top-level @include directive must be terminated by ';'");
+        if (!mixin_call->block() && !lex< one_plus< exactly<';'> > >()) error("top-level @include directive must be terminated by ';'", pstate);
       }
       else if (peek< if_directive >()) {
         (*root) << parse_if_directive();
@@ -92,30 +112,33 @@ namespace Sass {
       else if (peek< media >()) {
         (*root) << parse_media_block();
       }
+      else if (peek< at_root >()) {
+        (*root) << parse_at_root_block();
+      }
       else if (peek< supports >()) {
         (*root) << parse_feature_block();
       }
       else if (peek< warn >()) {
         (*root) << parse_warning();
-        if (!lex< one_plus< exactly<';'> > >()) error("top-level @warn directive must be terminated by ';'");
+        if (!lex< one_plus< exactly<';'> > >()) error("top-level @warn directive must be terminated by ';'", pstate);
       }
       else if (peek< err >()) {
         (*root) << parse_error();
-        if (!lex< one_plus< exactly<';'> > >()) error("top-level @error directive must be terminated by ';'");
+        if (!lex< one_plus< exactly<';'> > >()) error("top-level @error directive must be terminated by ';'", pstate);
       }
       else if (peek< dbg >()) {
         (*root) << parse_debug();
-        if (!lex< one_plus< exactly<';'> > >()) error("top-level @debug directive must be terminated by ';'");
+        if (!lex< one_plus< exactly<';'> > >()) error("top-level @debug directive must be terminated by ';'", pstate);
       }
       // ignore the @charset directive for now
       else if (lex< exactly< charset_kwd > >()) {
-        lex< string_constant >();
+        lex< quoted_string >();
         lex< one_plus< exactly<';'> > >();
       }
       else if (peek< at_keyword >()) {
         At_Rule* at_rule = parse_at_rule();
         (*root) << at_rule;
-        if (!at_rule->block() && !lex< one_plus< exactly<';'> > >()) error("top-level directive must be terminated by ';'");
+        if (!at_rule->block() && !lex< one_plus< exactly<';'> > >()) error("top-level directive must be terminated by ';'", pstate);
       }
       else if ((lookahead_result = lookahead_for_selector(position)).found) {
         (*root) << parse_ruleset(lookahead_result);
@@ -124,12 +147,13 @@ namespace Sass {
         lex< one_plus< exactly<';'> > >();
       }
       else {
-        lex< spaces_and_comments >();
+        lex< optional_spaces_and_comments >();
         if (position >= end) break;
-        error("invalid top-level expression");
+        error("invalid top-level expression", pstate);
       }
       lex< optional_spaces >();
     }
+    block_stack.pop_back();
     return root;
   }
 
@@ -143,17 +167,17 @@ namespace Sass {
     }
 
     if (extension == ".css") {
-      String_Constant* loc = new (ctx.mem) String_Constant(path, source_position, import_path, true);
-      Argument* loc_arg = new (ctx.mem) Argument(path, source_position, loc);
-      Arguments* loc_args = new (ctx.mem) Arguments(path, source_position);
+      String_Constant* loc = new (ctx.mem) String_Constant(pstate, unquote(import_path));
+      Argument* loc_arg = new (ctx.mem) Argument(pstate, loc);
+      Arguments* loc_args = new (ctx.mem) Arguments(pstate);
       (*loc_args) << loc_arg;
-      Function_Call* new_url = new (ctx.mem) Function_Call(path, source_position, "url", loc_args);
+      Function_Call* new_url = new (ctx.mem) Function_Call(pstate, "url", loc_args);
       imp->urls().push_back(new_url);
     }
     else {
       string current_dir = File::dir_name(path);
       string resolved(ctx.add_file(current_dir, unquoted));
-      if (resolved.empty()) error("file to import not found or unreadable: " + unquoted + "\nCurrent dir: " + current_dir);
+      if (resolved.empty()) error("file to import not found or unreadable: " + unquoted + "\nCurrent dir: " + current_dir, pstate);
       imp->files().push_back(resolved);
     }
 
@@ -162,10 +186,11 @@ namespace Sass {
   Import* Parser::parse_import()
   {
     lex< import >();
-    Import* imp = new (ctx.mem) Import(path, source_position);
+    Import* imp = new (ctx.mem) Import(pstate);
     bool first = true;
     do {
-      if (lex< string_constant >()) {
+      while (lex< block_comment >());
+      if (lex< quoted_string >()) {
         string import_path(lexed);
 
         // struct Sass_Options opt = sass_context_get_options(ctx)
@@ -186,9 +211,15 @@ namespace Sass {
             while (*includes) {
               struct Sass_Import* include = *includes;
               const char *file = sass_import_get_path(include);
-              char *source = sass_import_take_source(include);
+              char* source = sass_import_take_source(include);
+              size_t line = sass_import_get_error_line(include);
+              size_t column = sass_import_get_error_column(include);
+              const char* message = sass_import_get_error_message(include);
               // char *srcmap = sass_import_take_srcmap(include);
-              if (source) {
+              if (message) {
+                if (line == string::npos && column == string::npos) error(message, pstate);
+                else error(message, ParserState(message, Position(line, column)));
+              } else if (source) {
                 if (file) {
                   ctx.add_source(file, inc_path, source);
                   imp->files().push_back(file);
@@ -208,15 +239,23 @@ namespace Sass {
           }
         }
 
-        add_single_file(imp, import_path);
+        if (!unquote(import_path).substr(0, 7).compare("http://") ||
+            !unquote(import_path).substr(0, 8).compare("https://") ||
+            !unquote(import_path).substr(0, 2).compare("//"))
+        {
+          imp->urls().push_back(new (ctx.mem) String_Quoted(pstate, import_path));
+        }
+        else {
+          add_single_file(imp, import_path);
+        }
 
       }
       else if (peek< uri_prefix >()) {
         imp->urls().push_back(parse_value());
       }
       else {
-        if (first) error("@import directive requires a url or quoted path");
-        else error("expecting another url or quoted path in @import list");
+        if (first) error("@import directive requires a url or quoted path", pstate);
+        else error("expecting another url or quoted path in @import list", pstate);
       }
       first = false;
     } while (lex< exactly<','> >());
@@ -229,81 +268,86 @@ namespace Sass {
     if      (lex< mixin >())    which_type = Definition::MIXIN;
     else if (lex< function >()) which_type = Definition::FUNCTION;
     string which_str(lexed);
-    if (!lex< identifier >()) error("invalid name in " + which_str + " definition");
+    if (!lex< identifier >()) error("invalid name in " + which_str + " definition", pstate);
     string name(Util::normalize_underscores(lexed));
     if (which_type == Definition::FUNCTION && (name == "and" || name == "or" || name == "not"))
-    { error("Invalid function name \"" + name + "\"."); }
-    Position source_position_of_def = source_position;
+    { error("Invalid function name \"" + name + "\".", pstate); }
+    ParserState source_position_of_def = pstate;
     Parameters* params = parse_parameters();
-    if (!peek< exactly<'{'> >()) error("body for " + which_str + " " + name + " must begin with a '{'");
+    if (!peek< exactly<'{'> >()) error("body for " + which_str + " " + name + " must begin with a '{'", pstate);
     if (which_type == Definition::MIXIN) stack.push_back(mixin_def);
     else stack.push_back(function_def);
     Block* body = parse_block();
     stack.pop_back();
-    Definition* def = new (ctx.mem) Definition(path, source_position_of_def, name, params, body, which_type);
+    Definition* def = new (ctx.mem) Definition(source_position_of_def, name, params, body, which_type);
     return def;
   }
 
   Parameters* Parser::parse_parameters()
   {
     string name(lexed); // for the error message
-    Parameters* params = new (ctx.mem) Parameters(path, source_position);
+    Parameters* params = new (ctx.mem) Parameters(pstate);
     if (lex< exactly<'('> >()) {
       // if there's anything there at all
       if (!peek< exactly<')'> >()) {
         do (*params) << parse_parameter();
-        while (lex< exactly<','> >());
+        while (lex< alternatives < spaces,block_comment, exactly<','> > >());
       }
-      if (!lex< exactly<')'> >()) error("expected a variable name (e.g. $x) or ')' for the parameter list for " + name);
+      while (lex< alternatives < spaces, block_comment > >()) {};
+      if (!lex< exactly<')'> >()) error("expected a variable name (e.g. $x) or ')' for the parameter list for " + name, pstate);
     }
     return params;
   }
 
   Parameter* Parser::parse_parameter()
   {
+    while (lex< alternatives < spaces, block_comment > >());
     lex< variable >();
     string name(Util::normalize_underscores(lexed));
-    Position pos = source_position;
+    ParserState pos = pstate;
     Expression* val = 0;
     bool is_rest = false;
+    while (lex< alternatives < spaces, block_comment > >());
     if (lex< exactly<':'> >()) { // there's a default value
+      while (lex< block_comment >());
       val = parse_space_list();
       val->is_delayed(false);
     }
     else if (lex< exactly< ellipsis > >()) {
       is_rest = true;
     }
-    Parameter* p = new (ctx.mem) Parameter(path, pos, name, val, is_rest);
+    Parameter* p = new (ctx.mem) Parameter(pos, name, val, is_rest);
     return p;
   }
 
   Mixin_Call* Parser::parse_mixin_call()
   {
     lex< include >() /* || lex< exactly<'+'> >() */;
-    if (!lex< identifier >()) error("invalid name in @include directive");
-    Position source_position_of_call = source_position;
+    if (!lex< identifier >()) error("invalid name in @include directive", pstate);
+    ParserState source_position_of_call = pstate;
     string name(Util::normalize_underscores(lexed));
     Arguments* args = parse_arguments();
     Block* content = 0;
     if (peek< exactly<'{'> >()) {
       content = parse_block();
     }
-    Mixin_Call* the_call = new (ctx.mem) Mixin_Call(path, source_position_of_call, name, args, content);
+    Mixin_Call* the_call = new (ctx.mem) Mixin_Call(source_position_of_call, name, args, content);
     return the_call;
   }
 
   Arguments* Parser::parse_arguments()
   {
     string name(lexed);
-    Arguments* args = new (ctx.mem) Arguments(path, source_position);
+    Arguments* args = new (ctx.mem) Arguments(pstate);
 
     if (lex< exactly<'('> >()) {
       // if there's anything there at all
       if (!peek< exactly<')'> >()) {
         do (*args) << parse_argument();
-        while (lex< exactly<','> >());
+        while (lex< alternatives < block_comment, exactly<','> > >());
       }
-      if (!lex< exactly<')'> >()) error("expected a variable name (e.g. $x) or ')' for the parameter list for " + name);
+      while (lex< block_comment >());
+      if (!lex< exactly<')'> >()) error("expected a variable name (e.g. $x) or ')' for the parameter list for " + name, pstate);
     }
 
     return args;
@@ -312,14 +356,16 @@ namespace Sass {
   Argument* Parser::parse_argument()
   {
     Argument* arg;
-    if (peek< sequence < variable, spaces_and_comments, exactly<':'> > >()) {
+    while (lex< alternatives < spaces, block_comment > >());
+    if (peek< sequence < variable, zero_plus < alternatives < spaces, line_comment, block_comment > >, exactly<':'> > >()) {
       lex< variable >();
       string name(Util::normalize_underscores(lexed));
-      Position p = source_position;
+      ParserState p = pstate;
+      while (lex< alternatives < spaces, block_comment > >()) {};
       lex< exactly<':'> >();
       Expression* val = parse_space_list();
       val->is_delayed(false);
-      arg = new (ctx.mem) Argument(path, p, val, name);
+      arg = new (ctx.mem) Argument(p, val, name);
     }
     else {
       bool is_arglist = false;
@@ -330,7 +376,7 @@ namespace Sass {
         if (val->concrete_type() == Expression::MAP) is_keyword = true;
         else is_arglist = true;
       }
-      arg = new (ctx.mem) Argument(path, source_position, val, "", is_arglist, is_keyword);
+      arg = new (ctx.mem) Argument(pstate, val, "", is_arglist, is_keyword);
     }
     return arg;
   }
@@ -339,8 +385,8 @@ namespace Sass {
   {
     lex< variable >();
     string name(Util::normalize_underscores(lexed));
-    Position var_source_position = source_position;
-    if (!lex< exactly<':'> >()) error("expected ':' after " + name + " in assignment statement");
+    ParserState var_source_position = pstate;
+    if (!lex< exactly<':'> >()) error("expected ':' after " + name + " in assignment statement", pstate);
     Expression* val = parse_list();
     val->is_delayed(false);
     bool is_guarded = false;
@@ -349,10 +395,11 @@ namespace Sass {
       is_guarded = lex< default_flag >() || is_guarded;
       is_global = lex< global_flag >() || is_global;
     }
-    Assignment* var = new (ctx.mem) Assignment(path, var_source_position, name, val, is_guarded, is_global);
+    Assignment* var = new (ctx.mem) Assignment(var_source_position, name, val, is_guarded, is_global);
     return var;
   }
 
+  /* not used anymore - remove?
   Propset* Parser::parse_propset()
   {
     String* property_segment;
@@ -361,17 +408,19 @@ namespace Sass {
     }
     else {
       lex< sequence< optional< exactly<'*'> >, identifier > >();
-      property_segment = new (ctx.mem) String_Constant(path, source_position, lexed);
+      property_segment = new (ctx.mem) String_Quoted(pstate, lexed);
     }
-    Propset* propset = new (ctx.mem) Propset(path, source_position, property_segment);
+    Propset* propset = new (ctx.mem) Propset(pstate, property_segment);
     lex< exactly<':'> >();
 
-    if (!peek< exactly<'{'> >()) error("expected a '{' after namespaced property");
+    if (!peek< exactly<'{'> >()) error("expected a '{' after namespaced property", pstate);
 
     propset->block(parse_block());
 
+    propset->tabs(indentation);
+
     return propset;
-  }
+  } */
 
   Ruleset* Parser::parse_ruleset(Selector_Lookahead lookahead)
   {
@@ -382,10 +431,14 @@ namespace Sass {
     else {
       sel = parse_selector_group();
     }
-    Position r_source_position = source_position;
-    if (!peek< exactly<'{'> >()) error("expected a '{' after the selector");
+    bool old_in_at_root = in_at_root;
+    in_at_root = false;
+    ParserState r_source_position = pstate;
+    if (!peek< exactly<'{'> >()) error("expected a '{' after the selector", pstate);
     Block* block = parse_block();
-    Ruleset* ruleset = new (ctx.mem) Ruleset(path, r_source_position, sel, block);
+    in_at_root = old_in_at_root;
+    old_in_at_root = false;
+    Ruleset* ruleset = new (ctx.mem) Ruleset(r_source_position, sel, block);
     return ruleset;
   }
 
@@ -393,66 +446,91 @@ namespace Sass {
   {
     lex< optional_spaces >();
     const char* i = position;
-    const char* p;
-    String_Schema* schema = new (ctx.mem) String_Schema(path, source_position);
-
+    String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     while (i < end_of_selector) {
-      p = find_first_in_interval< exactly<hash_lbrace> >(i, end_of_selector);
-      if (p) {
-        // accumulate the preceding segment if there is one
-        if (i < p) (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, p));
-        // find the end of the interpolant and parse it
-        const char* j = find_first_in_interval< exactly<rbrace> >(p, end_of_selector);
-        Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, path, source_position).parse_list();
-        interp_node->is_interpolant(true);
-        (*schema) << interp_node;
-        i = j + 1;
-      }
-      else { // no interpolants left; add the last segment if there is one
-        if (i < end_of_selector) (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, end_of_selector));
+      // try to parse mutliple interpolants
+      if (const char* p = find_first_in_interval< exactly<hash_lbrace> >(i, end_of_selector)) {
+        // accumulate the preceding segment if the position has advanced
+        if (i < p) (*schema) << new (ctx.mem) String_Quoted(pstate, string(i, p));
+        // skip to the delimiter by skipping occurences in quoted strings
+        const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p + 2, end_of_selector);
+        Expression* interpolant = Parser::from_c_str(p+2, j, ctx, pstate).parse_list();
+        interpolant->is_interpolant(true);
+        (*schema) << interpolant;
+        i = j;
+      }
+      // no more interpolants have been found
+      // add the last segment if there is one
+      else {
+        if (i < end_of_selector) (*schema) << new (ctx.mem) String_Quoted(pstate, string(i, end_of_selector));
         break;
       }
     }
     position = end_of_selector;
-    return new (ctx.mem) Selector_Schema(path, source_position, schema);
+    Selector_Schema* selector_schema = new (ctx.mem) Selector_Schema(pstate, schema);
+    selector_schema->media_block(last_media_block);
+    selector_schema->last_block(block_stack.back());
+    return selector_schema;
   }
 
   Selector_List* Parser::parse_selector_group()
   {
-    To_String to_string;
-    lex< spaces_and_comments >();
-    Selector_List* group = new (ctx.mem) Selector_List(path, source_position);
+    bool reloop = true;
+    To_String to_string(&ctx);
+    lex< optional_spaces_and_comments >();
+    Selector_List* group = new (ctx.mem) Selector_List(pstate);
+    group->media_block(last_media_block);
+    group->last_block(block_stack.back());
     do {
+      reloop = false;
       if (peek< exactly<'{'> >() ||
           peek< exactly<'}'> >() ||
           peek< exactly<')'> >() ||
           peek< exactly<';'> >())
         break; // in case there are superfluous commas at the end
       Complex_Selector* comb = parse_selector_combination();
-      if (!comb->has_reference()) {
-        Position sel_source_position = source_position;
-        Selector_Reference* ref = new (ctx.mem) Selector_Reference(path, sel_source_position);
-        Compound_Selector* ref_wrap = new (ctx.mem) Compound_Selector(path, sel_source_position);
+      if (!comb->has_reference() && !in_at_root) {
+        ParserState sel_source_position = pstate;
+        Selector_Reference* ref = new (ctx.mem) Selector_Reference(sel_source_position);
+        Compound_Selector* ref_wrap = new (ctx.mem) Compound_Selector(sel_source_position);
+        ref_wrap->media_block(last_media_block);
+        ref_wrap->last_block(block_stack.back());
         (*ref_wrap) << ref;
         if (!comb->head()) {
           comb->head(ref_wrap);
           comb->has_reference(true);
         }
         else {
-          comb = new (ctx.mem) Complex_Selector(path, sel_source_position, Complex_Selector::ANCESTOR_OF, ref_wrap, comb);
+          comb = new (ctx.mem) Complex_Selector(sel_source_position, Complex_Selector::ANCESTOR_OF, ref_wrap, comb);
+          comb->media_block(last_media_block);
+          comb->last_block(block_stack.back());
           comb->has_reference(true);
         }
+        if (peek_newline()) ref_wrap->has_line_break(true);
+      }
+      while (peek< sequence< optional_spaces_and_comments, exactly<','> > >())
+      {
+        // consume everything up and including the comma speparator
+        reloop = lex< sequence< optional_spaces_and_comments, exactly<','> > >() != 0;
+        // remember line break (also between some commas)
+        if (peek_newline()) comb->has_line_feed(true);
+        if (comb->tail() && peek_newline()) comb->tail()->has_line_feed(true);
+        if (comb->tail() && comb->tail()->head() && peek_newline()) comb->tail()->head()->has_line_feed(true);
+        // remember line break (also between some commas)
       }
       (*group) << comb;
     }
-    while (lex< one_plus< sequence< spaces_and_comments, exactly<','> > > >());
-    while (lex< optional >());    // JMA - ignore optional flag if it follows the selector group
+    while (reloop);
+    while (lex< optional >()) {
+      group->is_optional(true);
+    }
     return group;
   }
 
   Complex_Selector* Parser::parse_selector_combination()
   {
-    Position sel_source_position = Position();
+    // lex< optional_spaces_and_comments >();
+    Position sel_source_position(-1);
     Compound_Selector* lhs;
     if (peek< exactly<'+'> >() ||
         peek< exactly<'~'> >() ||
@@ -462,7 +540,8 @@ namespace Sass {
     }
     else {
       lhs = parse_simple_selector_sequence();
-      sel_source_position = source_position;
+      sel_source_position = before_token;
+      lhs->has_line_break(peek_newline());
     }
 
     Complex_Selector::Combinator cmb;
@@ -470,6 +549,7 @@ namespace Sass {
     else if (lex< exactly<'~'> >()) cmb = Complex_Selector::PRECEDES;
     else if (lex< exactly<'>'> >()) cmb = Complex_Selector::PARENT_OF;
     else                            cmb = Complex_Selector::ANCESTOR_OF;
+    bool cpx_lf = peek_newline();
 
     Complex_Selector* rhs;
     if (peek< exactly<','> >() ||
@@ -483,31 +563,40 @@ namespace Sass {
     }
     else {
       rhs = parse_selector_combination();
-      sel_source_position = source_position;
+      sel_source_position = before_token;
     }
-    if (!sel_source_position.line) sel_source_position = source_position;
-    return new (ctx.mem) Complex_Selector(path, sel_source_position, cmb, lhs, rhs);
+    if (!sel_source_position.line) sel_source_position = before_token;
+    Complex_Selector* cpx = new (ctx.mem) Complex_Selector(ParserState(path, sel_source_position), cmb, lhs, rhs);
+    cpx->media_block(last_media_block);
+    cpx->last_block(block_stack.back());
+    if (cpx_lf) cpx->has_line_break(cpx_lf);
+    return cpx;
   }
 
   Compound_Selector* Parser::parse_simple_selector_sequence()
   {
-    Compound_Selector* seq = new (ctx.mem) Compound_Selector(path, source_position);
+    Compound_Selector* seq = new (ctx.mem) Compound_Selector(pstate);
+    seq->media_block(last_media_block);
+    seq->last_block(block_stack.back());
     bool sawsomething = false;
     if (lex< exactly<'&'> >()) {
-      // if you see a &
-      (*seq) << new (ctx.mem) Selector_Reference(path, source_position);
+      // check if we have a parent selector on the root level block
+      if (block_stack.back() && block_stack.back()->is_root()) {
+        error("Base-level rules cannot contain the parent-selector-referencing character '&'.", pstate);
+      }
+      (*seq) << new (ctx.mem) Selector_Reference(pstate);
       sawsomething = true;
       // if you see a space after a &, then you're done
-      if(lex< spaces >()) {
+      if(peek< spaces >()) {
         return seq;
       }
     }
-    if (sawsomething && lex< sequence< negate< functional >, alternatives< identifier_fragment, universal, string_constant, dimension, percentage, number > > >()) {
+    if (sawsomething && lex< sequence< negate< functional >, alternatives< identifier_fragment, universal, quoted_string, dimension, percentage, number > > >()) {
       // saw an ampersand, then allow type selectors with arbitrary number of hyphens at the beginning
-      (*seq) << new (ctx.mem) Type_Selector(path, source_position, lexed);
-    } else if (lex< sequence< negate< functional >, alternatives< type_selector, universal, string_constant, dimension, percentage, number > > >()) {
+      (*seq) << new (ctx.mem) Type_Selector(pstate, unquote(lexed));
+    } else if (lex< sequence< negate< functional >, alternatives< type_selector, universal, quoted_string, dimension, percentage, number > > >()) {
       // if you see a type selector
-      (*seq) << new (ctx.mem) Type_Selector(path, source_position, lexed);
+      (*seq) << new (ctx.mem) Type_Selector(pstate, lexed);
       sawsomething = true;
     }
     if (!sawsomething) {
@@ -532,10 +621,10 @@ namespace Sass {
   Simple_Selector* Parser::parse_simple_selector()
   {
     if (lex< id_name >() || lex< class_name >()) {
-      return new (ctx.mem) Selector_Qualifier(path, source_position, lexed);
+      return new (ctx.mem) Selector_Qualifier(pstate, unquote(lexed));
     }
-    else if (lex< string_constant >() || lex< number >()) {
-      return new (ctx.mem) Type_Selector(path, source_position, lexed);
+    else if (lex< quoted_string >() || lex< number >()) {
+      return new (ctx.mem) Type_Selector(pstate, unquote(lexed));
     }
     else if (peek< pseudo_not >()) {
       return parse_negated_selector();
@@ -547,10 +636,13 @@ namespace Sass {
       return parse_attribute_selector();
     }
     else if (lex< placeholder >()) {
-      return new (ctx.mem) Selector_Placeholder(path, source_position, lexed);
+      Selector_Placeholder* sel = new (ctx.mem) Selector_Placeholder(pstate, unquote(lexed));
+      sel->media_block(last_media_block);
+      sel->last_block(block_stack.back());
+      return sel;
     }
     else {
-      error("invalid selector after " + lexed.to_string());
+      error("invalid selector after " + lexed.to_string(), pstate);
     }
     // unreachable statement
     return 0;
@@ -560,73 +652,73 @@ namespace Sass {
   {
     lex< pseudo_not >();
     string name(lexed);
-    Position nsource_position = source_position;
+    ParserState nsource_position = pstate;
     Selector* negated = parse_selector_group();
     if (!lex< exactly<')'> >()) {
-      error("negated selector is missing ')'");
+      error("negated selector is missing ')'", pstate);
     }
-    return new (ctx.mem) Wrapped_Selector(path, nsource_position, name, negated);
+    return new (ctx.mem) Wrapped_Selector(nsource_position, name, negated);
   }
 
   Simple_Selector* Parser::parse_pseudo_selector() {
     if (lex< sequence< pseudo_prefix, functional > >() || lex< functional >()) {
       string name(lexed);
       String* expr = 0;
-      Position p = source_position;
+      ParserState p = pstate;
       Selector* wrapped = 0;
       if (lex< alternatives< even, odd > >()) {
-        expr = new (ctx.mem) String_Constant(path, p, lexed);
+        expr = new (ctx.mem) String_Quoted(p, lexed);
       }
       else if (peek< binomial >(position)) {
         lex< sequence< optional< coefficient >, exactly<'n'> > >();
-        String_Constant* var_coef = new (ctx.mem) String_Constant(path, p, lexed);
+        String_Constant* var_coef = new (ctx.mem) String_Quoted(p, lexed);
         lex< sign >();
-        String_Constant* op = new (ctx.mem) String_Constant(path, p, lexed);
+        String_Constant* op = new (ctx.mem) String_Quoted(p, lexed);
         // Binary_Expression::Type op = (lexed == "+" ? Binary_Expression::ADD : Binary_Expression::SUB);
         lex< digits >();
-        String_Constant* constant = new (ctx.mem) String_Constant(path, p, lexed);
-        // expr = new (ctx.mem) Binary_Expression(path, p, op, var_coef, constant);
-        String_Schema* schema = new (ctx.mem) String_Schema(path, p, 3);
+        String_Constant* constant = new (ctx.mem) String_Quoted(p, lexed);
+        // expr = new (ctx.mem) Binary_Expression(p, op, var_coef, constant);
+        String_Schema* schema = new (ctx.mem) String_Schema(p, 3);
         *schema << var_coef << op << constant;
         expr = schema;
       }
       else if (peek< sequence< optional<sign>,
                                optional<digits>,
                                exactly<'n'>,
-                               spaces_and_comments,
+                               optional_spaces_and_comments,
                                exactly<')'> > >()) {
         lex< sequence< optional<sign>,
                        optional<digits>,
                        exactly<'n'> > >();
-        expr = new (ctx.mem) String_Constant(path, p, lexed);
+        expr = new (ctx.mem) String_Quoted(p, lexed);
       }
       else if (lex< sequence< optional<sign>, digits > >()) {
-        expr = new (ctx.mem) String_Constant(path, p, lexed);
+        expr = new (ctx.mem) String_Quoted(p, lexed);
       }
-      else if (peek< sequence< identifier, spaces_and_comments, exactly<')'> > >()) {
+      else if (peek< sequence< identifier, optional_spaces_and_comments, exactly<')'> > >()) {
         lex< identifier >();
-        expr = new (ctx.mem) String_Constant(path, p, lexed);
+        expr = new (ctx.mem) String_Quoted(p, lexed);
       }
-      else if (lex< string_constant >()) {
-        expr = new (ctx.mem) String_Constant(path, p, lexed);
+      else if (lex< quoted_string >()) {
+        expr = new (ctx.mem) String_Quoted(p, lexed);
       }
       else if (peek< exactly<')'> >()) {
-        expr = new (ctx.mem) String_Constant(path, p, "");
+        expr = new (ctx.mem) String_Constant(p, "");
       }
       else {
         wrapped = parse_selector_group();
       }
-      if (!lex< exactly<')'> >()) error("unterminated argument to " + name + "...)");
+      if (!lex< exactly<')'> >()) error("unterminated argument to " + name + "...)", pstate);
       if (wrapped) {
-        return new (ctx.mem) Wrapped_Selector(path, p, name, wrapped);
+        return new (ctx.mem) Wrapped_Selector(p, name, wrapped);
       }
-      return new (ctx.mem) Pseudo_Selector(path, p, name, expr);
+      return new (ctx.mem) Pseudo_Selector(p, name, expr);
     }
     else if (lex < sequence< pseudo_prefix, identifier > >()) {
-      return new (ctx.mem) Pseudo_Selector(path, source_position, lexed);
+      return new (ctx.mem) Pseudo_Selector(pstate, unquote(lexed));
     }
     else {
-      error("unrecognized pseudo-class or pseudo-element");
+      error("unrecognized pseudo-class or pseudo-element", pstate);
     }
     // unreachable statement
     return 0;
@@ -635,29 +727,29 @@ namespace Sass {
   Attribute_Selector* Parser::parse_attribute_selector()
   {
     lex< exactly<'['> >();
-    Position p = source_position;
-    if (!lex< attribute_name >()) error("invalid attribute name in attribute selector");
+    ParserState p = pstate;
+    if (!lex< attribute_name >()) error("invalid attribute name in attribute selector", pstate);
     string name(lexed);
-    if (lex< exactly<']'> >()) return new (ctx.mem) Attribute_Selector(path, p, name, "", 0);
+    if (lex< exactly<']'> >()) return new (ctx.mem) Attribute_Selector(p, name, "", 0);
     if (!lex< alternatives< exact_match, class_match, dash_match,
                             prefix_match, suffix_match, substring_match > >()) {
-      error("invalid operator in attribute selector for " + name);
+      error("invalid operator in attribute selector for " + name, pstate);
     }
     string matcher(lexed);
 
     String* value = 0;
     if (lex< identifier >()) {
-      value = new (ctx.mem) String_Constant(path, p, lexed, true);
+      value = new (ctx.mem) String_Constant(p, lexed);
     }
-    else if (lex< string_constant >()) {
-      value = parse_interpolated_chunk(lexed);
+    else if (lex< quoted_string >()) {
+      value = parse_interpolated_chunk(lexed, true); // needed!
     }
     else {
-      error("expected a string constant or identifier in attribute selector for " + name);
+      error("expected a string constant or identifier in attribute selector for " + name, pstate);
     }
 
-    if (!lex< exactly<']'> >()) error("unterminated attribute selector for " + name);
-    return new (ctx.mem) Attribute_Selector(path, p, name, matcher, value);
+    if (!lex< exactly<']'> >()) error("unterminated attribute selector for " + name, pstate);
+    return new (ctx.mem) Attribute_Selector(p, name, matcher, value);
   }
 
   Block* Parser::parse_block()
@@ -665,43 +757,47 @@ namespace Sass {
     lex< exactly<'{'> >();
     bool semicolon = false;
     Selector_Lookahead lookahead_result;
-    Block* block = new (ctx.mem) Block(path, source_position);
-
+    Block* block = new (ctx.mem) Block(pstate);
+    block_stack.push_back(block);
+    lex< zero_plus < alternatives < space, line_comment > > >();
     // JMA - ensure that a block containing only block_comments is parsed
     while (lex< block_comment >()) {
+      bool is_important = lexed.begin[2] == '!';
       String*  contents = parse_interpolated_chunk(lexed);
-      Comment* comment  = new (ctx.mem) Comment(path, source_position, contents);
+      Comment* comment  = new (ctx.mem) Comment(pstate, contents, is_important);
       (*block) << comment;
     }
 
     while (!lex< exactly<'}'> >()) {
       if (semicolon) {
         if (!lex< one_plus< exactly<';'> > >()) {
-          error("non-terminal statement or declaration must end with ';'");
+          error("non-terminal statement or declaration must end with ';'", pstate);
         }
         semicolon = false;
         while (lex< block_comment >()) {
+          bool is_important = lexed.begin[2] == '!';
           String*  contents = parse_interpolated_chunk(lexed);
-          Comment* comment  = new (ctx.mem) Comment(path, source_position, contents);
+          Comment* comment  = new (ctx.mem) Comment(pstate, contents, is_important);
           (*block) << comment;
         }
         if (lex< sequence< exactly<'}'>, zero_plus< exactly<';'> > > >()) break;
       }
       if (lex< block_comment >()) {
+        bool is_important = lexed.begin[2] == '!';
         String*  contents = parse_interpolated_chunk(lexed);
-        Comment* comment  = new (ctx.mem) Comment(path, source_position, contents);
+        Comment* comment  = new (ctx.mem) Comment(pstate, contents, is_important);
         (*block) << comment;
       }
       else if (peek< import >(position)) {
         if (stack.back() == mixin_def || stack.back() == function_def) {
-          lex< import >(); // to adjust the source_position number
-          error("@import directives are not allowed inside mixins and functions");
+          lex< import >(); // to adjust the before_token number
+          error("@import directives are not allowed inside mixins and functions", pstate);
         }
         Import* imp = parse_import();
         if (!imp->urls().empty()) (*block) << imp;
         if (!imp->files().empty()) {
           for (size_t i = 0, S = imp->files().size(); i < S; ++i) {
-            (*block) << new (ctx.mem) Import_Stub(path, source_position, imp->files()[i]);
+            (*block) << new (ctx.mem) Import_Stub(pstate, imp->files()[i]);
           }
         }
         semicolon = true;
@@ -710,6 +806,9 @@ namespace Sass {
         (*block) << parse_assignment();
         semicolon = true;
       }
+      else if (lex< line_comment >()) {
+        // throw line comments away
+      }
       else if (peek< if_directive >()) {
         (*block) << parse_if_directive();
       }
@@ -723,7 +822,7 @@ namespace Sass {
         (*block) << parse_while_directive();
       }
       else if (lex < return_directive >()) {
-        (*block) << new (ctx.mem) Return(path, source_position, parse_list());
+        (*block) << new (ctx.mem) Return(pstate, parse_list());
         semicolon = true;
       }
       else if (peek< warn >()) {
@@ -739,7 +838,7 @@ namespace Sass {
         semicolon = true;
       }
       else if (stack.back() == function_def) {
-        error("only variable declarations and control directives are allowed inside functions");
+        error("only variable declarations and control directives are allowed inside functions", pstate);
       }
       else if (peek< mixin >() || peek< function >()) {
         (*block) << parse_definition();
@@ -752,9 +851,9 @@ namespace Sass {
       }
       else if (lex< content >()) {
         if (stack.back() != mixin_def) {
-          error("@content may only be used within a mixin");
+          error("@content may only be used within a mixin", pstate);
         }
-        (*block) << new (ctx.mem) Content(path, source_position);
+        (*block) << new (ctx.mem) Content(pstate);
         semicolon = true;
       }
       /*
@@ -765,11 +864,11 @@ namespace Sass {
       */
       else if (lex< extend >()) {
         Selector_Lookahead lookahead = lookahead_for_extension_target(position);
-        if (!lookahead.found) error("invalid selector for @extend");
+        if (!lookahead.found) error("invalid selector for @extend", pstate);
         Selector* target;
         if (lookahead.has_interpolants) target = parse_selector_schema(lookahead.found);
         else                            target = parse_selector_group();
-        (*block) << new (ctx.mem) Extension(path, source_position, target);
+        (*block) << new (ctx.mem) Extension(pstate, target);
         semicolon = true;
       }
       else if (peek< media >()) {
@@ -778,9 +877,12 @@ namespace Sass {
       else if (peek< supports >()) {
         (*block) << parse_feature_block();
       }
+      else if (peek< at_root >()) {
+        (*block) << parse_at_root_block();
+      }
       // ignore the @charset directive for now
       else if (lex< exactly< charset_kwd > >()) {
-        lex< string_constant >();
+        lex< quoted_string >();
         lex< one_plus< exactly<';'> > >();
       }
       else if (peek< at_keyword >()) {
@@ -790,23 +892,28 @@ namespace Sass {
       }
       else if ((lookahead_result = lookahead_for_selector(position)).found) {
         (*block) << parse_ruleset(lookahead_result);
-      }
+      }/* not used anymore - remove?
       else if (peek< sequence< optional< exactly<'*'> >, alternatives< identifier_schema, identifier >, optional_spaces, exactly<':'>, optional_spaces, exactly<'{'> > >(position)) {
         (*block) << parse_propset();
-      }
+      }*/
       else if (!peek< exactly<';'> >()) {
+        bool indent = ! peek< sequence< optional< exactly<'*'> >, alternatives< identifier_schema, identifier >, optional_spaces, exactly<':'>, optional_spaces, exactly<'{'> > >(position);
+        /* not used anymore - remove?
         if (peek< sequence< optional< exactly<'*'> >, identifier_schema, exactly<':'>, exactly<'{'> > >()) {
           (*block) << parse_propset();
         }
         else if (peek< sequence< optional< exactly<'*'> >, identifier, exactly<':'>, exactly<'{'> > >()) {
           (*block) << parse_propset();
         }
-        else {
+        else */ {
           Declaration* decl = parse_declaration();
+          decl->tabs(indentation);
           (*block) << decl;
           if (peek< exactly<'{'> >()) {
             // parse a propset that rides on the declaration's property
-            Propset* ps = new (ctx.mem) Propset(path, source_position, decl->property(), parse_block());
+            if (indent) indentation++;
+            Propset* ps = new (ctx.mem) Propset(pstate, decl->property(), parse_block());
+            if (indent) indentation--;
             (*block) << ps;
           }
           else {
@@ -817,11 +924,13 @@ namespace Sass {
       }
       else lex< one_plus< exactly<';'> > >();
       while (lex< block_comment >()) {
+        bool is_important = lexed.begin[2] == '!';
         String*  contents = parse_interpolated_chunk(lexed);
-        Comment* comment  = new (ctx.mem) Comment(path, source_position, contents);
+        Comment* comment  = new (ctx.mem) Comment(pstate, contents, is_important);
         (*block) << comment;
       }
     }
+    block_stack.pop_back();
     return block;
   }
 
@@ -831,27 +940,43 @@ namespace Sass {
       prop = parse_identifier_schema();
     }
     else if (lex< sequence< optional< exactly<'*'> >, identifier > >()) {
-      prop = new (ctx.mem) String_Constant(path, source_position, lexed);
+      prop = new (ctx.mem) String_Quoted(pstate, lexed);
     }
     else if (lex< custom_property_name >()) {
-      prop = new (ctx.mem) String_Constant(path, source_position, lexed);
+      prop = new (ctx.mem) String_Quoted(pstate, lexed);
     }
     else {
-      error("invalid property name");
+      error("invalid property name", pstate);
     }
-    if (!lex< one_plus< exactly<':'> > >()) error("property \"" + string(lexed) + "\" must be followed by a ':'");
-    if (peek< exactly<';'> >()) error("style declaration must contain a value");
+    if (!lex< one_plus< exactly<':'> > >()) error("property \"" + string(lexed) + "\" must be followed by a ':'", pstate);
+    if (peek< exactly<';'> >()) error("style declaration must contain a value", pstate);
     if (peek< static_value >()) {
-      return new (ctx.mem) Declaration(path, prop->position(), prop, parse_static_value()/*, lex<important>()*/);
+      return new (ctx.mem) Declaration(prop->pstate(), prop, parse_static_value()/*, lex<important>()*/);
     }
     else {
-      return new (ctx.mem) Declaration(path, prop->position(), prop, parse_list()/*, lex<important>()*/);
+      return new (ctx.mem) Declaration(prop->pstate(), prop, parse_list()/*, lex<important>()*/);
+    }
+  }
+
+  // parse +/- and return false if negative
+  bool Parser::parse_number_prefix()
+  {
+    bool positive = true;
+    while(true) {
+      if (lex < block_comment >()) continue;
+      if (lex < number_prefix >()) continue;
+      if (lex < exactly < '-' > >()) {
+        positive = !positive;
+        continue;
+      }
+      break;
     }
+    return positive;
   }
 
   Expression* Parser::parse_map()
   {
-    To_String to_string;
+    To_String to_string(&ctx);
     Expression* key = parse_list();
 
     // it's not a map so return the lexed value as a list value
@@ -862,7 +987,7 @@ namespace Sass {
 
     Expression* value = parse_space_list();
 
-    Map* map = new (ctx.mem) Map(path, source_position, 1);
+    Map* map = new (ctx.mem) Map(pstate, 1);
     (*map) << make_pair(key, value);
 
     while (lex< exactly<','> >())
@@ -874,7 +999,7 @@ namespace Sass {
       Expression* key = parse_list();
 
       if (!(lex< exactly<':'> >()))
-      { error("invalid syntax"); }
+      { error("invalid syntax", pstate); }
 
       Expression* value = parse_space_list();
 
@@ -882,7 +1007,7 @@ namespace Sass {
     }
 
     if (map->has_duplicate_key())
-    { error("Duplicate key \"" + map->get_duplicate_key()->perform(&to_string) + "\" in map " + map->perform(&to_string) + "."); }
+    { error("Duplicate key \"" + map->get_duplicate_key()->perform(&to_string) + "\" in map " + map->perform(&to_string) + ".", pstate); }
 
     return map;
   }
@@ -901,12 +1026,12 @@ namespace Sass {
         peek< exactly<')'> >(position) ||
         //peek< exactly<':'> >(position) ||
         peek< exactly<ellipsis> >(position))
-    { return new (ctx.mem) List(path, source_position, 0); }
+    { return new (ctx.mem) List(pstate, 0); }
     Expression* list1 = parse_space_list();
     // if it's a singleton, return it directly; don't wrap it
     if (!peek< exactly<','> >(position)) return list1;
 
-    List* comma_list = new (ctx.mem) List(path, source_position, 2, List::COMMA);
+    List* comma_list = new (ctx.mem) List(pstate, 2, List::COMMA);
     (*comma_list) << list1;
 
     while (lex< exactly<','> >())
@@ -943,7 +1068,7 @@ namespace Sass {
         peek< global_flag >(position))
     { return disj1; }
 
-    List* space_list = new (ctx.mem) List(path, source_position, 2, List::SPACE);
+    List* space_list = new (ctx.mem) List(pstate, 2, List::SPACE);
     (*space_list) << disj1;
 
     while (!(//peek< exactly<'!'> >(position) ||
@@ -1012,7 +1137,7 @@ namespace Sass {
 
     Expression* expr2 = parse_expression();
 
-    return new (ctx.mem) Binary_Expression(path, expr1->position(), op, expr1, expr2);
+    return new (ctx.mem) Binary_Expression(expr1->pstate(), op, expr1, expr2);
   }
 
   Expression* Parser::parse_expression()
@@ -1020,14 +1145,15 @@ namespace Sass {
     Expression* term1 = parse_term();
     // if it's a singleton, return it directly; don't wrap it
     if (!(peek< exactly<'+'> >(position) ||
-          peek< sequence< negate< number >, exactly<'-'> > >(position)) ||
+          (peek< no_spaces >(position) && peek< sequence< negate< unsigned_number >, exactly<'-'>, negate< space > > >(position)) ||
+          (peek< sequence< negate< unsigned_number >, exactly<'-'>, negate< unsigned_number > > >(position))) ||
           peek< identifier >(position))
     { return term1; }
 
     vector<Expression*> operands;
     vector<Binary_Expression::Type> operators;
-    while (lex< exactly<'+'> >() || lex< sequence< negate< number >, exactly<'-'> > >()) {
-      operators.push_back(lexed == "+" ? Binary_Expression::ADD : Binary_Expression::SUB);
+    while (lex< exactly<'+'> >() || lex< sequence< negate< digits >, exactly<'-'> > >()) {
+      operators.push_back(lexed.to_string() == "+" ? Binary_Expression::ADD : Binary_Expression::SUB);
       operands.push_back(parse_term());
     }
 
@@ -1040,12 +1166,8 @@ namespace Sass {
 
     // Special case: Ruby sass never tries to modulo if the lhs contains an interpolant
     if (peek< exactly<'%'> >(position) && fact1->concrete_type() == Expression::STRING) {
-      try {
-        String_Schema* ss = dynamic_cast<String_Schema*>(fact1);
-        if (ss->has_interpolants()) return fact1;
-      }
-      catch (bad_cast&) {}
-      catch (...) { throw; }
+      String_Schema* ss = dynamic_cast<String_Schema*>(fact1);
+      if (ss && ss->has_interpolants()) return fact1;
     }
 
     // if it's a singleton, return it directly; don't wrap it
@@ -1054,11 +1176,12 @@ namespace Sass {
           peek< exactly<'%'> >(position)))
     { return fact1; }
 
+    while (lex< block_comment >());
     vector<Expression*> operands;
     vector<Binary_Expression::Type> operators;
     while (lex< exactly<'*'> >() || lex< exactly<'/'> >() || lex< exactly<'%'> >()) {
-      if      (lexed == "*") operators.push_back(Binary_Expression::MUL);
-      else if (lexed == "/") operators.push_back(Binary_Expression::DIV);
+      if      (lexed.to_string() == "*") operators.push_back(Binary_Expression::MUL);
+      else if (lexed.to_string() == "/") operators.push_back(Binary_Expression::DIV);
       else                   operators.push_back(Binary_Expression::MOD);
       operands.push_back(parse_factor());
     }
@@ -1070,7 +1193,7 @@ namespace Sass {
   {
     if (lex< exactly<'('> >()) {
       Expression* value = parse_map();
-      if (!lex< exactly<')'> >()) error("unclosed parenthesis");
+      if (!lex< exactly<')'> >()) error("unclosed parenthesis", pstate);
       value->is_delayed(false);
       // make sure wrapped lists and division expressions are non-delayed within parentheses
       if (value->concrete_type() == Expression::LIST) {
@@ -1091,6 +1214,7 @@ namespace Sass {
     }
     else if (peek< exactly< calc_kwd > >() ||
              peek< exactly< moz_calc_kwd > >() ||
+             peek< exactly< ms_calc_kwd > >() ||
              peek< exactly< webkit_calc_kwd > >()) {
       return parse_calc_function();
     }
@@ -1103,14 +1227,18 @@ namespace Sass {
     else if (peek< functional >() && !peek< uri_prefix >()) {
       return parse_function_call();
     }
-    else if (lex< sequence< exactly<'+'>, spaces_and_comments, negate< number > > >()) {
-      return new (ctx.mem) Unary_Expression(path, source_position, Unary_Expression::PLUS, parse_factor());
+    else if (lex< sequence< exactly<'+'>, optional_spaces_and_comments, negate< number > > >()) {
+      return new (ctx.mem) Unary_Expression(pstate, Unary_Expression::PLUS, parse_factor());
     }
-    else if (lex< sequence< exactly<'-'>, spaces_and_comments, negate< number> > >()) {
-      return new (ctx.mem) Unary_Expression(path, source_position, Unary_Expression::MINUS, parse_factor());
+    else if (lex< sequence< exactly<'-'>, optional_spaces_and_comments, negate< number> > >()) {
+      return new (ctx.mem) Unary_Expression(pstate, Unary_Expression::MINUS, parse_factor());
     }
     else if (lex< sequence< not_op, spaces_and_comments > >()) {
-      return new (ctx.mem) Unary_Expression(path, source_position, Unary_Expression::NOT, parse_factor());
+      return new (ctx.mem) Unary_Expression(pstate, Unary_Expression::NOT, parse_factor());
+    }
+    else if (peek < sequence < one_plus < alternatives < spaces_and_comments, exactly<'-'>, exactly<'+'> > >, number > >()) {
+      if (parse_number_prefix()) return parse_value(); // prefix is positive
+      return new (ctx.mem) Unary_Expression(pstate, Unary_Expression::MINUS, parse_value());
     }
     else {
       return parse_value();
@@ -1119,11 +1247,12 @@ namespace Sass {
 
   Expression* Parser::parse_value()
   {
+    while (lex< block_comment >());
     if (lex< uri_prefix >()) {
-      Arguments* args = new (ctx.mem) Arguments(path, source_position);
-      Function_Call* result = new (ctx.mem) Function_Call(path, source_position, "url", args);
+      Arguments* args = new (ctx.mem) Arguments(pstate);
+      Function_Call* result = new (ctx.mem) Function_Call(pstate, "url", args);
       const char* here = position;
-      Position here_p = source_position;
+      Position here_p = before_token;
       // Try to parse a SassScript expression. If it succeeds and we can munch
       // a matching rparen, then that's our url. If we can't munch a matching
       // rparen, or if the attempt to parse an expression fails, then try to
@@ -1131,118 +1260,128 @@ namespace Sass {
       try {
         // special case -- if there's a comment, treat it as part of a URL
         lex<spaces>();
-        if (peek<line_comment_prefix>() || peek<block_comment_prefix>()) error("comment in URL"); // doesn't really matter what we throw
+        if (peek<line_comment_prefix>() || peek<block_comment_prefix>()) error("comment in URL", pstate); // doesn't really matter what we throw
         Expression* expr = parse_list();
-        if (!lex< exactly<')'> >()) error("dangling expression in URL"); // doesn't really matter what we throw
-        Argument* arg = new (ctx.mem) Argument(path, expr->position(), expr);
+        if (!lex< exactly<')'> >()) error("dangling expression in URL", pstate); // doesn't really matter what we throw
+        Argument* arg = new (ctx.mem) Argument(expr->pstate(), expr);
         *args << arg;
         return result;
       }
       catch (Sass_Error&) {
         // back up so we can try again
         position = here;
-        source_position = here_p;
+        before_token = here_p;
       }
       catch (...) { throw; }
       lex< spaces >();
       if (lex< url >()) {
         String* the_url = parse_interpolated_chunk(lexed);
-        Argument* arg = new (ctx.mem) Argument(path, the_url->position(), the_url);
+        Argument* arg = new (ctx.mem) Argument(the_url->pstate(), the_url);
         *args << arg;
       }
       else {
-        error("malformed URL");
+        error("malformed URL", pstate);
       }
-      if (!lex< exactly<')'> >()) error("URI is missing ')'");
+      if (!lex< exactly<')'> >()) error("URI is missing ')'", pstate);
       return result;
     }
 
     if (lex< important >())
-    { return new (ctx.mem) String_Constant(path, source_position, "!important"); }
+    { return new (ctx.mem) String_Constant(pstate, "!important"); }
 
-    if (lex< value_schema >())
-    { return Parser::from_token(lexed, ctx, path, source_position).parse_value_schema(); }
+    const char* stop;
+    if ((stop = peek< value_schema >()))
+    { return parse_value_schema(stop); }
 
     if (lex< sequence< true_val, negate< identifier > > >())
-    { return new (ctx.mem) Boolean(path, source_position, true); }
+    { return new (ctx.mem) Boolean(pstate, true); }
 
     if (lex< sequence< false_val, negate< identifier > > >())
-    { return new (ctx.mem) Boolean(path, source_position, false); }
+    { return new (ctx.mem) Boolean(pstate, false); }
 
     if (lex< sequence< null, negate< identifier > > >())
-    { return new (ctx.mem) Null(path, source_position); }
+    { return new (ctx.mem) Null(pstate); }
 
     if (lex< identifier >()) {
-      String_Constant* str = new (ctx.mem) String_Constant(path, source_position, lexed);
+      String_Constant* str = new (ctx.mem) String_Quoted(pstate, lexed);
       // Dont' delay this string if it is a name color. Fixes #652.
-      str->is_delayed(ctx.names_to_colors.count(lexed) == 0);
+      str->is_delayed(ctx.names_to_colors.count(unquote(lexed)) == 0);
       return str;
     }
 
     if (lex< percentage >())
-    { return new (ctx.mem) Textual(path, source_position, Textual::PERCENTAGE, lexed); }
+    { return new (ctx.mem) Textual(pstate, Textual::PERCENTAGE, lexed); }
 
-    if (lex< dimension >())
-    { return new (ctx.mem) Textual(path, source_position, Textual::DIMENSION, lexed); }
+    // match hex number first because 0x000 looks like a number followed by an indentifier
+    if (lex< alternatives< hex, hex0 > >())
+    { return new (ctx.mem) Textual(pstate, Textual::HEX, lexed); }
 
-    if (lex< number >())
-    { return new (ctx.mem) Textual(path, source_position, Textual::NUMBER, lexed); }
+    // also handle the 10em- foo special case
+    if (lex< sequence< dimension, optional< sequence< exactly<'-'>, negate< digit > > > > >())
+    { return new (ctx.mem) Textual(pstate, Textual::DIMENSION, lexed); }
 
-    if (lex< hex >())
-    { return new (ctx.mem) Textual(path, source_position, Textual::HEX, lexed); }
+    if (lex< number >())
+    { return new (ctx.mem) Textual(pstate, Textual::NUMBER, lexed); }
 
-    if (peek< string_constant >())
+    if (peek< quoted_string >())
     { return parse_string(); }
 
     if (lex< variable >())
-    { return new (ctx.mem) Variable(path, source_position, Util::normalize_underscores(lexed)); }
+    { return new (ctx.mem) Variable(pstate, Util::normalize_underscores(lexed)); }
 
     // Special case handling for `%` proceeding an interpolant.
     if (lex< sequence< exactly<'%'>, optional< percentage > > >())
-    { return new (ctx.mem) String_Constant(path, source_position, lexed); }
+    { return new (ctx.mem) String_Quoted(pstate, lexed); }
 
-    error("error reading values after " + lexed.to_string());
+    error("error reading values after " + lexed.to_string(), pstate);
 
     // unreachable statement
     return 0;
   }
 
-  String* Parser::parse_interpolated_chunk(Token chunk)
+  // this parses interpolation inside other strings
+  // means the result should later be quoted again
+  String* Parser::parse_interpolated_chunk(Token chunk, bool constant)
   {
     const char* i = chunk.begin;
     // see if there any interpolants
-    const char* p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(chunk.begin, chunk.end);
+    const char* p = find_first_in_interval< exactly<hash_lbrace> >(i, chunk.end);
     if (!p) {
-      String_Constant* str_node = new (ctx.mem) String_Constant(path, source_position, chunk, dequote);
-      str_node->is_delayed(true);
-      return str_node;
+      String_Quoted* str_quoted = new (ctx.mem) String_Quoted(pstate, string(i, chunk.end));
+      if (!constant && str_quoted->quote_mark()) str_quoted->quote_mark('*');
+      str_quoted->is_delayed(true);
+      return str_quoted;
     }
 
-    String_Schema* schema = new (ctx.mem) String_Schema(path, source_position);
-    schema->quote_mark(*chunk.begin);
+    String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     while (i < chunk.end) {
-      p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(i, chunk.end);
+      p = find_first_in_interval< exactly<hash_lbrace> >(i, chunk.end);
       if (p) {
         if (i < p) {
-          (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, p)); // accumulate the preceding segment if it's nonempty
+          // accumulate the preceding segment if it's nonempty
+          (*schema) << new (ctx.mem) String_Quoted(pstate, string(i, p));
         }
-        const char* j = find_first_in_interval< exactly<rbrace> >(p, chunk.end); // find the closing brace
-        if (j) {
+        // we need to skip anything inside strings
+        // create a new target in parser/prelexer
+        const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p + 2, chunk.end); // find the closing brace
+        if (j) { --j;
           // parse the interpolant and accumulate it
-          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, path, source_position).parse_list();
+          Expression* interp_node = Parser::from_token(Token(p+2, j, before_token), ctx, pstate).parse_list();
           interp_node->is_interpolant(true);
           (*schema) << interp_node;
-          i = j+1;
+          i = j;
         }
         else {
           // throw an error if the interpolant is unterminated
-          error("unterminated interpolant inside string constant " + chunk.to_string());
+          error("unterminated interpolant inside string constant " + chunk.to_string(), pstate);
         }
       }
       else { // no interpolants left; add the last segment if nonempty
-        if (i < chunk.end) (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, chunk.end));
+        // check if we need quotes here (was not sure after merge)
+        if (i < chunk.end) (*schema) << new (ctx.mem) String_Quoted(pstate, string(i, chunk.end));
         break;
       }
+      ++ i;
     }
     return schema;
   }
@@ -1253,52 +1392,16 @@ namespace Sass {
     Token str(lexed);
     --str.end;
     --position;
-    String_Constant* str_node = new (ctx.mem) String_Constant(path, source_position, str);
-    str_node->is_delayed(true);
+    String_Constant* str_node = new (ctx.mem) String_Constant(pstate, str);
+    // str_node->is_delayed(true);
     return str_node;
   }
 
   String* Parser::parse_string()
   {
-    lex< string_constant >();
-    Token str(lexed);
-    return parse_interpolated_chunk(str);
-    // const char* i = str.begin;
-    // // see if there any interpolants
-    // const char* p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(str.begin, str.end);
-    // if (!p) {
-    //   String_Constant* str_node = new (ctx.mem) String_Constant(path, source_position, str);
-    //   str_node->is_delayed(true);
-    //   return str_node;
-    // }
-
-    // String_Schema* schema = new (ctx.mem) String_Schema(path, source_position);
-    // schema->quote_mark(*str.begin);
-    // while (i < str.end) {
-    //   p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(i, str.end);
-    //   if (p) {
-    //     if (i < p) {
-    //       (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, p)); // accumulate the preceding segment if it's nonempty
-    //     }
-    //     const char* j = find_first_in_interval< exactly<rbrace> >(p, str.end); // find the closing brace
-    //     if (j) {
-    //       // parse the interpolant and accumulate it
-    //       Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, path, source_position).parse_list();
-    //       interp_node->is_interpolant(true);
-    //       (*schema) << interp_node;
-    //       i = j+1;
-    //     }
-    //     else {
-    //       // throw an error if the interpolant is unterminated
-    //       error("unterminated interpolant inside string constant " + str.to_string());
-    //     }
-    //   }
-    //   else { // no interpolants left; add the last segment if nonempty
-    //     if (i < str.end) (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, str.end));
-    //     break;
-    //   }
-    // }
-    // return schema;
+    lex< quoted_string >();
+    Token token(lexed);
+    return parse_interpolated_chunk(token);
   }
 
   String* Parser::parse_ie_property()
@@ -1307,35 +1410,35 @@ namespace Sass {
     Token str(lexed);
     const char* i = str.begin;
     // see if there any interpolants
-    const char* p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(str.begin, str.end);
+    const char* p = find_first_in_interval< exactly<hash_lbrace> >(str.begin, str.end);
     if (!p) {
-      String_Constant* str_node = new (ctx.mem) String_Constant(path, source_position, str);
+      String_Constant* str_node = new (ctx.mem) String_Constant(pstate, normalize_wspace(string(str.begin, str.end)));
       str_node->is_delayed(true);
       return str_node;
     }
 
-    String_Schema* schema = new (ctx.mem) String_Schema(path, source_position);
+    String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     while (i < str.end) {
-      p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(i, str.end);
+      p = find_first_in_interval< exactly<hash_lbrace> >(i, str.end);
       if (p) {
         if (i < p) {
-          (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, p)); // accumulate the preceding segment if it's nonempty
+          (*schema) << new (ctx.mem) String_Constant(pstate, string(i, p)); // accumulate the preceding segment if it's nonempty
         }
-        const char* j = find_first_in_interval< exactly<rbrace> >(p, str.end); // find the closing brace
+        const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p+2, str.end); // find the closing brace
         if (j) {
           // parse the interpolant and accumulate it
-          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, path, source_position).parse_list();
+          Expression* interp_node = Parser::from_token(Token(p+2, j, before_token), ctx, pstate).parse_list();
           interp_node->is_interpolant(true);
           (*schema) << interp_node;
-          i = j+1;
+          i = j;
         }
         else {
           // throw an error if the interpolant is unterminated
-          error("unterminated interpolant inside IE function " + str.to_string());
+          error("unterminated interpolant inside IE function " + str.to_string(), pstate);
         }
       }
       else { // no interpolants left; add the last segment if nonempty
-        if (i < str.end) (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, str.end));
+        if (i < str.end) (*schema) << new (ctx.mem) String_Constant(pstate, string(i, str.end));
         break;
       }
     }
@@ -1344,130 +1447,136 @@ namespace Sass {
 
   String* Parser::parse_ie_keyword_arg()
   {
-    String_Schema* kwd_arg = new (ctx.mem) String_Schema(path, source_position, 3);
-    if (lex< variable >()) *kwd_arg << new (ctx.mem) Variable(path, source_position, Util::normalize_underscores(lexed));
-    else {
+    String_Schema* kwd_arg = new (ctx.mem) String_Schema(pstate, 3);
+    if (lex< variable >()) {
+      *kwd_arg << new (ctx.mem) Variable(pstate, Util::normalize_underscores(lexed));
+    } else {
       lex< alternatives< identifier_schema, identifier > >();
-      *kwd_arg << new (ctx.mem) String_Constant(path, source_position, lexed);
+      *kwd_arg << new (ctx.mem) String_Quoted(pstate, lexed);
     }
     lex< exactly<'='> >();
-    *kwd_arg << new (ctx.mem) String_Constant(path, source_position, lexed);
+    *kwd_arg << new (ctx.mem) String_Quoted(pstate, lexed);
     if (peek< variable >()) *kwd_arg << parse_list();
-    else if (lex< number >()) *kwd_arg << new (ctx.mem) Textual(path, source_position, Textual::NUMBER, Util::normalize_decimals(lexed));
-    else {
-      lex< alternatives< identifier_schema, identifier, number, hex > >();
-      *kwd_arg << new (ctx.mem) String_Constant(path, source_position, lexed);
+    else if (lex< number >()) *kwd_arg << new (ctx.mem) Textual(pstate, Textual::NUMBER, Util::normalize_decimals(lexed));
+    else if (lex< alternatives< identifier_schema, identifier, number, hexa, hex > >()) {
+      *kwd_arg << new (ctx.mem) String_Quoted(pstate, lexed);
     }
     return kwd_arg;
   }
 
-  String_Schema* Parser::parse_value_schema()
+  String_Schema* Parser::parse_value_schema(const char* stop)
   {
-    String_Schema* schema = new (ctx.mem) String_Schema(path, source_position);
+    String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     size_t num_items = 0;
-    while (position < end) {
+    while (position < stop) {
       if (lex< interpolant >()) {
-        Token insides(Token(lexed.begin + 2, lexed.end - 1));
-        Expression* interp_node = Parser::from_token(insides, ctx, path, source_position).parse_list();
+        Token insides(Token(lexed.begin + 2, lexed.end - 1, before_token));
+        Expression* interp_node = Parser::from_token(insides, ctx, pstate).parse_list();
         interp_node->is_interpolant(true);
         (*schema) << interp_node;
       }
       else if (lex< exactly<'%'> >()) {
-        (*schema) << new (ctx.mem) String_Constant(path, source_position, lexed);
+        (*schema) << new (ctx.mem) String_Constant(pstate, lexed);
       }
       else if (lex< identifier >()) {
-        (*schema) << new (ctx.mem) String_Constant(path, source_position, lexed);
+        (*schema) << new (ctx.mem) String_Quoted(pstate, lexed);
       }
       else if (lex< percentage >()) {
-        (*schema) << new (ctx.mem) Textual(path, source_position, Textual::PERCENTAGE, lexed);
+        (*schema) << new (ctx.mem) Textual(pstate, Textual::PERCENTAGE, lexed);
       }
       else if (lex< dimension >()) {
-        (*schema) << new (ctx.mem) Textual(path, source_position, Textual::DIMENSION, lexed);
+        (*schema) << new (ctx.mem) Textual(pstate, Textual::DIMENSION, lexed);
       }
       else if (lex< number >()) {
-        (*schema) << new (ctx.mem) Textual(path, source_position, Textual::NUMBER, lexed);
+        (*schema) << new (ctx.mem) Textual(pstate, Textual::NUMBER, lexed);
       }
       else if (lex< hex >()) {
-        (*schema) << new (ctx.mem) Textual(path, source_position, Textual::HEX, lexed);
+        (*schema) << new (ctx.mem) Textual(pstate, Textual::HEX, unquote(lexed));
       }
-      else if (lex< string_constant >()) {
-        (*schema) << new (ctx.mem) String_Constant(path, source_position, lexed);
-        if (!num_items) schema->quote_mark(*lexed.begin);
+      else if (lex< quoted_string >()) {
+        (*schema) << new (ctx.mem) String_Constant(pstate, lexed);
       }
       else if (lex< variable >()) {
-        (*schema) << new (ctx.mem) Variable(path, source_position, Util::normalize_underscores(lexed));
+        (*schema) << new (ctx.mem) Variable(pstate, Util::normalize_underscores(lexed));
       }
       else {
-        error("error parsing interpolated value");
+        error("error parsing interpolated value", pstate);
       }
       ++num_items;
     }
     return schema;
   }
 
+  /* not used anymore - remove?
   String_Schema* Parser::parse_url_schema()
   {
-    String_Schema* schema = new (ctx.mem) String_Schema(path, source_position);
+    String_Schema* schema = new (ctx.mem) String_Schema(pstate);
 
     while (position < end) {
       if (position[0] == '/') {
-        lexed = Token(position, position+1);
-        (*schema) << new (ctx.mem) String_Constant(path, source_position, lexed);
+        lexed = Token(position, position+1, before_token);
+        (*schema) << new (ctx.mem) String_Quoted(pstate, lexed);
         ++position;
       }
       else if (lex< interpolant >()) {
-        Token insides(Token(lexed.begin + 2, lexed.end - 1));
-        Expression* interp_node = Parser::from_token(insides, ctx, path, source_position).parse_list();
+        Token insides(Token(lexed.begin + 2, lexed.end - 1, before_token));
+        Expression* interp_node = Parser::from_token(insides, ctx, pstate).parse_list();
         interp_node->is_interpolant(true);
         (*schema) << interp_node;
       }
       else if (lex< sequence< identifier, exactly<':'> > >()) {
-        (*schema) << new (ctx.mem) String_Constant(path, source_position, lexed);
+        (*schema) << new (ctx.mem) String_Quoted(pstate, lexed);
       }
       else if (lex< filename >()) {
-        (*schema) << new (ctx.mem) String_Constant(path, source_position, lexed);
+        (*schema) << new (ctx.mem) String_Quoted(pstate, lexed);
       }
       else {
-        error("error parsing interpolated url");
+        error("error parsing interpolated url", pstate);
       }
     }
     return schema;
-  }
+  } */
 
+  // this parses interpolation outside other strings
+  // means the result must not be quoted again later
   String* Parser::parse_identifier_schema()
   {
+    // first lex away whatever we have found
     lex< sequence< optional< exactly<'*'> >, identifier_schema > >();
     Token id(lexed);
     const char* i = id.begin;
     // see if there any interpolants
-    const char* p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(id.begin, id.end);
+    const char* p = find_first_in_interval< exactly<hash_lbrace> >(id.begin, id.end);
     if (!p) {
-      return new (ctx.mem) String_Constant(path, source_position, id);
+      return new (ctx.mem) String_Quoted(pstate, string(id.begin, id.end));
     }
 
-    String_Schema* schema = new (ctx.mem) String_Schema(path, source_position);
+    String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     while (i < id.end) {
-      p = find_first_in_interval< sequence< negate< exactly<'\\'> >, exactly<hash_lbrace> > >(i, id.end);
+      p = find_first_in_interval< exactly<hash_lbrace> >(i, id.end);
       if (p) {
         if (i < p) {
-          (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, p)); // accumulate the preceding segment if it's nonempty
+          // accumulate the preceding segment if it's nonempty
+          (*schema) << new (ctx.mem) String_Constant(pstate, string(i, p));
         }
-        const char* j = find_first_in_interval< exactly<rbrace> >(p, id.end); // find the closing brace
+        // we need to skip anything inside strings
+        // create a new target in parser/prelexer
+        const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p+2, id.end); // find the closing brace
         if (j) {
           // parse the interpolant and accumulate it
-          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, path, source_position).parse_list();
+          Expression* interp_node = Parser::from_token(Token(p+2, j, before_token), ctx, pstate).parse_list();
           interp_node->is_interpolant(true);
           (*schema) << interp_node;
           schema->has_interpolants(true);
-          i = j+1;
+          i = j;
         }
         else {
           // throw an error if the interpolant is unterminated
-          error("unterminated interpolant inside interpolated identifier " + id.to_string());
+          error("unterminated interpolant inside interpolated identifier " + id.to_string(), pstate);
         }
       }
       else { // no interpolants left; add the last segment if nonempty
-        if (i < id.end) (*schema) << new (ctx.mem) String_Constant(path, source_position, Token(i, id.end));
+        if (i < end) (*schema) << new (ctx.mem) String_Quoted(pstate, string(i, id.end));
         break;
       }
     }
@@ -1478,95 +1587,95 @@ namespace Sass {
   {
     lex< identifier >();
     string name(lexed);
-    Position call_pos = source_position;
+    ParserState call_pos = pstate;
     lex< exactly<'('> >();
-    Position arg_pos = source_position;
+    ParserState arg_pos = pstate;
     const char* arg_beg = position;
     parse_list();
     const char* arg_end = position;
     lex< exactly<')'> >();
 
-    Argument* arg = new (ctx.mem) Argument(path, arg_pos, parse_interpolated_chunk(Token(arg_beg, arg_end)));
-    Arguments* args = new (ctx.mem) Arguments(path, arg_pos);
+    Argument* arg = new (ctx.mem) Argument(arg_pos, parse_interpolated_chunk(Token(arg_beg, arg_end, before_token)));
+    Arguments* args = new (ctx.mem) Arguments(arg_pos);
     *args << arg;
-    return new (ctx.mem) Function_Call(path, call_pos, name, args);
+    return new (ctx.mem) Function_Call(call_pos, name, args);
   }
 
   Function_Call* Parser::parse_function_call()
   {
     lex< identifier >();
     string name(Util::normalize_underscores(lexed));
-    Position source_position_of_call = source_position;
+    ParserState source_position_of_call = pstate;
 
-    Function_Call* the_call = new (ctx.mem) Function_Call(path, source_position_of_call, name, parse_arguments());
+    Function_Call* the_call = new (ctx.mem) Function_Call(source_position_of_call, name, parse_arguments());
     return the_call;
   }
 
   Function_Call_Schema* Parser::parse_function_call_schema()
   {
     String* name = parse_identifier_schema();
-    Position source_position_of_call = source_position;
+    ParserState source_position_of_call = pstate;
 
-    Function_Call_Schema* the_call = new (ctx.mem) Function_Call_Schema(path, source_position_of_call, name, parse_arguments());
+    Function_Call_Schema* the_call = new (ctx.mem) Function_Call_Schema(source_position_of_call, name, parse_arguments());
     return the_call;
   }
 
   If* Parser::parse_if_directive(bool else_if)
   {
     lex< if_directive >() || (else_if && lex< exactly<if_after_else_kwd> >());
-    Position if_source_position = source_position;
+    ParserState if_source_position = pstate;
     Expression* predicate = parse_list();
     predicate->is_delayed(false);
-    if (!peek< exactly<'{'> >()) error("expected '{' after the predicate for @if");
+    if (!peek< exactly<'{'> >()) error("expected '{' after the predicate for @if", pstate);
     Block* consequent = parse_block();
     Block* alternative = 0;
     if (lex< else_directive >()) {
       if (peek< exactly<if_after_else_kwd> >()) {
-        alternative = new (ctx.mem) Block(path, source_position);
+        alternative = new (ctx.mem) Block(pstate);
         (*alternative) << parse_if_directive(true);
       }
       else if (!peek< exactly<'{'> >()) {
-        error("expected '{' after @else");
+        error("expected '{' after @else", pstate);
       }
       else {
         alternative = parse_block();
       }
     }
-    return new (ctx.mem) If(path, if_source_position, predicate, consequent, alternative);
+    return new (ctx.mem) If(if_source_position, predicate, consequent, alternative);
   }
 
   For* Parser::parse_for_directive()
   {
     lex< for_directive >();
-    Position for_source_position = source_position;
-    if (!lex< variable >()) error("@for directive requires an iteration variable");
+    ParserState for_source_position = pstate;
+    if (!lex< variable >()) error("@for directive requires an iteration variable", pstate);
     string var(Util::normalize_underscores(lexed));
-    if (!lex< from >()) error("expected 'from' keyword in @for directive");
+    if (!lex< from >()) error("expected 'from' keyword in @for directive", pstate);
     Expression* lower_bound = parse_expression();
     lower_bound->is_delayed(false);
     bool inclusive = false;
     if (lex< through >()) inclusive = true;
     else if (lex< to >()) inclusive = false;
-    else                  error("expected 'through' or 'to' keyword in @for directive");
+    else                  error("expected 'through' or 'to' keyword in @for directive", pstate);
     Expression* upper_bound = parse_expression();
     upper_bound->is_delayed(false);
-    if (!peek< exactly<'{'> >()) error("expected '{' after the upper bound in @for directive");
+    if (!peek< exactly<'{'> >()) error("expected '{' after the upper bound in @for directive", pstate);
     Block* body = parse_block();
-    return new (ctx.mem) For(path, for_source_position, var, lower_bound, upper_bound, body, inclusive);
+    return new (ctx.mem) For(for_source_position, var, lower_bound, upper_bound, body, inclusive);
   }
 
   Each* Parser::parse_each_directive()
   {
     lex < each_directive >();
-    Position each_source_position = source_position;
-    if (!lex< variable >()) error("@each directive requires an iteration variable");
+    ParserState each_source_position = pstate;
+    if (!lex< variable >()) error("@each directive requires an iteration variable", pstate);
     vector<string> vars;
     vars.push_back(Util::normalize_underscores(lexed));
     while (peek< exactly<','> >() && lex< exactly<','> >()) {
-      if (!lex< variable >()) error("@each directive requires an iteration variable");
+      if (!lex< variable >()) error("@each directive requires an iteration variable", pstate);
       vars.push_back(Util::normalize_underscores(lexed));
     }
-    if (!lex< in >()) error("expected 'in' keyword in @each directive");
+    if (!lex< in >()) error("expected 'in' keyword in @each directive", pstate);
     Expression* list = parse_list();
     list->is_delayed(false);
     if (list->concrete_type() == Expression::LIST) {
@@ -1575,39 +1684,43 @@ namespace Sass {
         (*l)[i]->is_delayed(false);
       }
     }
-    if (!peek< exactly<'{'> >()) error("expected '{' after the upper bound in @each directive");
+    if (!peek< exactly<'{'> >()) error("expected '{' after the upper bound in @each directive", pstate);
     Block* body = parse_block();
-    return new (ctx.mem) Each(path, each_source_position, vars, list, body);
+    return new (ctx.mem) Each(each_source_position, vars, list, body);
   }
 
   While* Parser::parse_while_directive()
   {
     lex< while_directive >();
-    Position while_source_position = source_position;
+    ParserState while_source_position = pstate;
     Expression* predicate = parse_list();
     predicate->is_delayed(false);
     Block* body = parse_block();
-    return new (ctx.mem) While(path, while_source_position, predicate, body);
+    return new (ctx.mem) While(while_source_position, predicate, body);
   }
 
   Media_Block* Parser::parse_media_block()
   {
     lex< media >();
-    Position media_source_position = source_position;
+    ParserState media_source_position = pstate;
 
     List* media_queries = parse_media_queries();
 
     if (!peek< exactly<'{'> >()) {
-      error("expected '{' in media query");
+      error("expected '{' in media query", pstate);
     }
-    Block* block = parse_block();
+    Media_Block* media_block = new (ctx.mem) Media_Block(media_source_position, media_queries, 0);
+    Media_Block* prev_media_block = last_media_block;
+    last_media_block = media_block;
+    media_block->block(parse_block());
+    last_media_block = prev_media_block;
 
-    return new (ctx.mem) Media_Block(path, media_source_position, media_queries, block);
+    return media_block;
   }
 
   List* Parser::parse_media_queries()
   {
-    List* media_queries = new (ctx.mem) List(path, source_position, 0, List::COMMA);
+    List* media_queries = new (ctx.mem) List(pstate, 0, List::COMMA);
     if (!peek< exactly<'{'> >()) (*media_queries) << parse_media_query();
     while (lex< exactly<','> >()) (*media_queries) << parse_media_query();
     return media_queries;
@@ -1616,17 +1729,24 @@ namespace Sass {
   // Expression* Parser::parse_media_query()
   Media_Query* Parser::parse_media_query()
   {
-    Media_Query* media_query = new (ctx.mem) Media_Query(path, source_position);
+    Media_Query* media_query = new (ctx.mem) Media_Query(pstate);
 
     if (lex< exactly< not_kwd > >()) media_query->is_negated(true);
     else if (lex< exactly< only_kwd > >()) media_query->is_restricted(true);
 
     if (peek< identifier_schema >()) media_query->media_type(parse_identifier_schema());
-    else if (lex< identifier >())    media_query->media_type(new (ctx.mem) String_Constant(path, source_position, lexed));
+    else if (lex< identifier >())    media_query->media_type(parse_interpolated_chunk(lexed));
     else                             (*media_query) << parse_media_expression();
 
     while (lex< exactly< and_kwd > >()) (*media_query) << parse_media_expression();
-
+    if (peek< identifier_schema >()) {
+      String_Schema* schema = new (ctx.mem) String_Schema(pstate);
+      *schema << media_query->media_type();
+      *schema << new (ctx.mem) String_Constant(pstate, " ");
+      *schema << parse_identifier_schema();
+      media_query->media_type(schema);
+    }
+    while (lex< exactly< and_kwd > >()) (*media_query) << parse_media_expression();
     return media_query;
   }
 
@@ -1634,14 +1754,14 @@ namespace Sass {
   {
     if (peek< identifier_schema >()) {
       String* ss = parse_identifier_schema();
-      return new (ctx.mem) Media_Query_Expression(path, source_position, ss, 0, true);
+      return new (ctx.mem) Media_Query_Expression(pstate, ss, 0, true);
     }
     if (!lex< exactly<'('> >()) {
-      error("media query expression must begin with '('");
+      error("media query expression must begin with '('", pstate);
     }
     Expression* feature = 0;
     if (peek< exactly<')'> >()) {
-      error("media feature required in media query expression");
+      error("media feature required in media query expression", pstate);
     }
     feature = parse_expression();
     Expression* expression = 0;
@@ -1649,36 +1769,36 @@ namespace Sass {
       expression = parse_list();
     }
     if (!lex< exactly<')'> >()) {
-      error("unclosed parenthesis in media query expression");
+      error("unclosed parenthesis in media query expression", pstate);
     }
-    return new (ctx.mem) Media_Query_Expression(path, feature->position(), feature, expression);
+    return new (ctx.mem) Media_Query_Expression(feature->pstate(), feature, expression);
   }
 
   Feature_Block* Parser::parse_feature_block()
   {
     lex< supports >();
-    Position supports_source_position = source_position;
+    ParserState supports_source_position = pstate;
 
     Feature_Query* feature_queries = parse_feature_queries();
 
     if (!peek< exactly<'{'> >()) {
-      error("expected '{' in feature query");
+      error("expected '{' in feature query", pstate);
     }
     Block* block = parse_block();
 
-    return new (ctx.mem) Feature_Block(path, supports_source_position, feature_queries, block);
+    return new (ctx.mem) Feature_Block(supports_source_position, feature_queries, block);
   }
 
   Feature_Query* Parser::parse_feature_queries()
   {
-    Feature_Query* fq = new (ctx.mem) Feature_Query(path, source_position);
-    Feature_Query_Condition* cond = new (ctx.mem) Feature_Query_Condition(path, source_position);
+    Feature_Query* fq = new (ctx.mem) Feature_Query(pstate);
+    Feature_Query_Condition* cond = new (ctx.mem) Feature_Query_Condition(pstate);
     cond->is_root(true);
     while (!peek< exactly<')'> >(position) && !peek< exactly<'{'> >(position))
       (*cond) << parse_feature_query();
     (*fq) << cond;
 
-    if (fq->empty()) error("expected @supports condition (e.g. (display: flexbox))");
+    if (fq->empty()) error("expected @supports condition (e.g. (display: flexbox))", pstate);
 
     return fq;
   }
@@ -1694,12 +1814,12 @@ namespace Sass {
 
   Feature_Query_Condition* Parser::parse_feature_query_in_parens()
   {
-    Feature_Query_Condition* cond = new (ctx.mem) Feature_Query_Condition(path, source_position);
+    Feature_Query_Condition* cond = new (ctx.mem) Feature_Query_Condition(pstate);
 
-    if (!lex< exactly<'('> >()) error("@supports declaration expected '('");
+    if (!lex< exactly<'('> >()) error("@supports declaration expected '('", pstate);
     while (!peek< exactly<')'> >(position) && !peek< exactly<'{'> >(position))
       (*cond) << parse_feature_query();
-    if (!lex< exactly<')'> >()) error("unclosed parenthesis in @supports declaration");
+    if (!lex< exactly<')'> >()) error("unclosed parenthesis in @supports declaration", pstate);
 
     return (cond->length() == 1) ? (*cond)[0] : cond;
   }
@@ -1737,19 +1857,71 @@ namespace Sass {
   Feature_Query_Condition* Parser::parse_supports_declaration()
   {
     Declaration* declaration = parse_declaration();
-    Feature_Query_Condition* cond = new (ctx.mem) Feature_Query_Condition(declaration->path(),
-                                                                          declaration->position(),
+    Feature_Query_Condition* cond = new (ctx.mem) Feature_Query_Condition(declaration->pstate(),
                                                                           1,
                                                                           declaration->property(),
                                                                           declaration->value());
     return cond;
   }
 
+  At_Root_Block* Parser::parse_at_root_block()
+  {
+    lex<at_root>();
+    ParserState at_source_position = pstate;
+    Block* body = 0;
+    At_Root_Expression* expr = 0;
+    Selector_Lookahead lookahead_result;
+    in_at_root = true;
+    if (peek< exactly<'('> >()) {
+      expr = parse_at_root_expression();
+      body = parse_block();
+    }
+    else if (peek< exactly<'{'> >()) {
+      body = parse_block();
+    }
+    else if ((lookahead_result = lookahead_for_selector(position)).found) {
+      Ruleset* r = parse_ruleset(lookahead_result);
+      body = new (ctx.mem) Block(r->pstate(), 1);
+      *body << r;
+    }
+    in_at_root = false;
+    At_Root_Block* at_root = new (ctx.mem) At_Root_Block(at_source_position, body);
+    if (expr) at_root->expression(expr);
+    return at_root;
+  }
+
+  At_Root_Expression* Parser::parse_at_root_expression()
+  {
+    lex< exactly<'('> >();
+    if (peek< exactly<')'> >()) error("at-root feature required in at-root expression", pstate);
+
+    if (!peek< alternatives< with_directive, without_directive > >()) {
+      const char* i = position;
+      const char* p = peek< until<')'> >(i);
+      Token* t = new Token(i, p, Position(0, 0));
+      error("Invalid CSS after \"(\": expected \"with\" or \"without\", was \""+t->to_string()+"\"", pstate);
+    }
+
+    Declaration* declaration = parse_declaration();
+    List* value = new (ctx.mem) List(declaration->value()->pstate(), 1);
+
+    if (declaration->value()->concrete_type() == Expression::LIST) {
+        value = static_cast<List*>(declaration->value());
+    }
+    else *value << declaration->value();
+
+    At_Root_Expression* cond = new (ctx.mem) At_Root_Expression(declaration->pstate(),
+                                                                declaration->property(),
+                                                                value);
+    if (!lex< exactly<')'> >()) error("unclosed parenthesis in @at-root expression", pstate);
+    return cond;
+  }
+
   At_Rule* Parser::parse_at_rule()
   {
     lex<at_keyword>();
     string kwd(lexed);
-    Position at_source_position = source_position;
+    ParserState at_source_position = pstate;
     Selector* sel = 0;
     Expression* val = 0;
     Selector_Lookahead lookahead = lookahead_for_extension_target(position);
@@ -1766,7 +1938,7 @@ namespace Sass {
     }
     Block* body = 0;
     if (peek< exactly<'{'> >()) body = parse_block();
-    At_Rule* rule = new (ctx.mem) At_Rule(path, at_source_position, kwd, sel, body);
+    At_Rule* rule = new (ctx.mem) At_Rule(at_source_position, kwd, sel, body);
     if (!sel) rule->value(val);
     return rule;
   }
@@ -1774,19 +1946,19 @@ namespace Sass {
   Warning* Parser::parse_warning()
   {
     lex< warn >();
-    return new (ctx.mem) Warning(path, source_position, parse_list());
+    return new (ctx.mem) Warning(pstate, parse_list());
   }
 
   Error* Parser::parse_error()
   {
     lex< err >();
-    return new (ctx.mem) Error(path, source_position, parse_list());
+    return new (ctx.mem) Error(pstate, parse_list());
   }
 
   Debug* Parser::parse_debug()
   {
     lex< dbg >();
-    return new (ctx.mem) Debug(path, source_position, parse_list());
+    return new (ctx.mem) Debug(pstate, parse_list());
   }
 
   Selector_Lookahead Parser::lookahead_for_selector(const char* start)
@@ -1805,7 +1977,7 @@ namespace Sass {
            (q = peek< sequence< pseudo_prefix, identifier > >(p))  ||
            (q = peek< percentage >(p))                             ||
            (q = peek< dimension >(p))                              ||
-           (q = peek< string_constant >(p))                        ||
+           (q = peek< quoted_string >(p))                        ||
            (q = peek< exactly<'*'> >(p))                           ||
            (q = peek< exactly<'('> >(p))                           ||
            (q = peek< exactly<')'> >(p))                           ||
@@ -1815,6 +1987,7 @@ namespace Sass {
            (q = peek< exactly<'~'> >(p))                           ||
            (q = peek< exactly<'>'> >(p))                           ||
            (q = peek< exactly<','> >(p))                           ||
+           (saw_stuff && (q = peek< exactly<'-'> >(p)))            ||
            (q = peek< binomial >(p))                               ||
            (q = peek< sequence< optional<sign>,
                                 optional<digits>,
@@ -1863,7 +2036,7 @@ namespace Sass {
            (q = peek< sequence< pseudo_prefix, identifier > >(p))  ||
            (q = peek< percentage >(p))                             ||
            (q = peek< dimension >(p))                              ||
-           (q = peek< string_constant >(p))                        ||
+           (q = peek< quoted_string >(p))                        ||
            (q = peek< exactly<'*'> >(p))                           ||
            (q = peek< exactly<'('> >(p))                           ||
            (q = peek< exactly<')'> >(p))                           ||
@@ -1873,6 +2046,7 @@ namespace Sass {
            (q = peek< exactly<'~'> >(p))                           ||
            (q = peek< exactly<'>'> >(p))                           ||
            (q = peek< exactly<','> >(p))                           ||
+           (saw_stuff && (q = peek< exactly<'-'> >(p)))            ||
            (q = peek< binomial >(p))                               ||
            (q = peek< sequence< optional<sign>,
                                 optional<digits>,
@@ -1961,7 +2135,7 @@ namespace Sass {
       encoding = "GB-18030";
       break;
     }
-    if (skip > 0 && !utf_8) error("only UTF-8 documents are currently supported; your document appears to be " + encoding);
+    if (skip > 0 && !utf_8) error("only UTF-8 documents are currently supported; your document appears to be " + encoding, pstate);
     position += skip;
   }
 
@@ -1979,7 +2153,7 @@ namespace Sass {
   Expression* Parser::fold_operands(Expression* base, vector<Expression*>& operands, Binary_Expression::Type op)
   {
     for (size_t i = 0, S = operands.size(); i < S; ++i) {
-      base = new (ctx.mem) Binary_Expression(path, source_position, op, base, operands[i]);
+      base = new (ctx.mem) Binary_Expression(pstate, op, base, operands[i]);
       Binary_Expression* b = static_cast<Binary_Expression*>(base);
       if (op == Binary_Expression::DIV && b->left()->is_delayed() && b->right()->is_delayed()) {
         base->is_delayed(true);
@@ -1995,7 +2169,7 @@ namespace Sass {
   Expression* Parser::fold_operands(Expression* base, vector<Expression*>& operands, vector<Binary_Expression::Type>& ops)
   {
     for (size_t i = 0, S = operands.size(); i < S; ++i) {
-      base = new (ctx.mem) Binary_Expression(path, base->position(), ops[i], base, operands[i]);
+      base = new (ctx.mem) Binary_Expression(base->pstate(), ops[i], base, operands[i]);
       Binary_Expression* b = static_cast<Binary_Expression*>(base);
       if (ops[i] == Binary_Expression::DIV && b->left()->is_delayed() && b->right()->is_delayed()) {
         base->is_delayed(true);
@@ -2010,7 +2184,7 @@ namespace Sass {
 
   void Parser::error(string msg, Position pos)
   {
-    throw Sass_Error(Sass_Error::syntax, path, pos.line ? pos : source_position, msg);
+    throw Sass_Error(Sass_Error::syntax, ParserState(path, pos.line ? pos : before_token, Offset(0, 0)), msg);
   }
 
 }