sassc 1.1.2 → 1.2.0

data/ext/libsass/functions.hpp

@@ -101,6 +101,7 @@ namespace Sass {
     extern Signature keywords_sig;
     extern Signature set_nth_sig;
     extern Signature unique_id_sig;
+    extern Signature is_superselector_sig;
 
     BUILT_IN(rgb);
     BUILT_IN(rgba_4);
@@ -175,6 +176,7 @@ namespace Sass {
     BUILT_IN(keywords);
     BUILT_IN(set_nth);
     BUILT_IN(unique_id);
+    BUILT_IN(is_superselector);
 
   }
 }

data/ext/libsass/inspect.cpp

@@ -1,7 +1,3 @@
-#include "inspect.hpp"
-#include "ast.hpp"
-#include "context.hpp"
-#include "utf8/checked.h"
 #include <cmath>
 #include <string>
 #include <iostream>
@@ -9,6 +5,11 @@
 #include <stdint.h>
 #include <stdint.h>
 
+#include "ast.hpp"
+#include "inspect.hpp"
+#include "context.hpp"
+#include "utf8/checked.h"
+
 namespace Sass {
   using namespace std;
 
@@ -99,9 +100,10 @@ namespace Sass {
     append_token(at_rule->keyword(), at_rule);
     if (at_rule->selector()) {
       append_mandatory_space();
+      bool was_wrapped = in_wrapped;
       in_wrapped = true;
       at_rule->selector()->perform(this);
-      in_wrapped = false;
+      in_wrapped = was_wrapped;
     }
     if (at_rule->block()) {
       at_rule->block()->perform(this);
@@ -114,6 +116,7 @@ namespace Sass {
   void Inspect::operator()(Declaration* dec)
   {
     if (dec->value()->concrete_type() == Expression::NULL_VAL) return;
+    bool was_decl = in_declaration;
     in_declaration = true;
     if (output_style() == NESTED)
       indentation += dec->tabs();
@@ -128,7 +131,7 @@ namespace Sass {
     append_delimiter();
     if (output_style() == NESTED)
       indentation -= dec->tabs();
-    in_declaration = false;
+    in_declaration = was_decl;
   }
 
   void Inspect::operator()(Assignment* assn)
@@ -346,8 +349,20 @@ namespace Sass {
     else if (in_media_block && sep != " ") sep += " "; // verified
     if (list->empty()) return;
     bool items_output = false;
-    in_declaration_list = in_declaration;
-    for (size_t i = 0, L = list->length(); i < L; ++i) {
+
+    bool was_space_array = in_space_array;
+    bool was_comma_array = in_comma_array;
+    if (!in_declaration && (
+        (list->separator() == List::SPACE && in_space_array) ||
+        (list->separator() == List::COMMA && in_comma_array)
+    )) {
+      append_string("(");
+    }
+
+    if (list->separator() == List::SPACE) in_space_array = true;
+    else if (list->separator() == List::COMMA) in_comma_array = true;
+
+    for (size_t i = 0, L = list->size(); i < L; ++i) {
       Expression* list_item = (*list)[i];
       if (list_item->is_invisible()) {
         continue;
@@ -360,7 +375,16 @@ namespace Sass {
       list_item->perform(this);
       items_output = true;
     }
-    in_declaration_list = false;
+
+    in_comma_array = was_comma_array;
+    in_space_array = was_space_array;
+    if (!in_declaration && (
+        (list->separator() == List::SPACE && in_space_array) ||
+        (list->separator() == List::COMMA && in_comma_array)
+    )) {
+      append_string(")");
+    }
+
   }
 
   void Inspect::operator()(Binary_Expression* expr)
@@ -416,43 +440,91 @@ namespace Sass {
 
   void Inspect::operator()(Number* n)
   {
+
+    string res;
+
+    // init stuff
     n->normalize();
+    int precision = 5;
+    double value = n->value();
+    // get option from optional context
+    if (ctx) precision = ctx->precision;
+
+    // check if the fractional part of the value equals to zero
+    // neat trick from http://stackoverflow.com/a/1521682/1550314
+    // double int_part; bool is_int = modf(value, &int_part) == 0.0;
+
+    // this all cannot be done with one run only, since fixed
+    // output differs from normal output and regular output
+    // can contain scientific notation which we do not want!
+
+    // first sample
     stringstream ss;
-    ss.precision(ctx ? ctx->precision : 5);
-    ss << fixed << n->value();
-    string d(ss.str());
-    // store if the value did not equal zero
-    // if after applying precsision, the value gets
-    // truncated to zero, sass emits 0.0 instead of 0
-    bool nonzero = n->value() != 0;
-    size_t decimal = d.find('.');
-    if (decimal != string::npos) {
-      for (size_t i = d.length()-1; d[i] == '0' && i >= decimal; --i) {
-        d.resize(d.length()-1);
-      }
-    }
-    if (d[d.length()-1] == '.') d.resize(d.length()-1);
+    ss.precision(12);
+    ss << value;
+
+    // check if we got scientific notation in result
+    if (ss.str().find_first_of("e") != string::npos) {
+      ss.clear(); ss.str(string());
+      ss.precision(max(12, precision));
+      ss << fixed << value;
+    }
+
+    string tmp = ss.str();
+    size_t pos_point = tmp.find_first_of(".,");
+    size_t pos_fract = tmp.find_last_not_of("0");
+    bool is_int = pos_point == pos_fract ||
+                  pos_point == string::npos;
+
+    // reset stream for another run
+    ss.clear(); ss.str(string());
+
+    // take a shortcut for integers
+    if (is_int)
+    {
+      ss.precision(0);
+      ss << fixed << value;
+      res = string(ss.str());
+    }
+    // process floats
+    else
+    {
+      // do we have have too much precision?
+      if (pos_fract < precision + pos_point)
+      { precision = pos_fract - pos_point; }
+      // round value again
+      ss.precision(precision);
+      ss << fixed << value;
+      res = string(ss.str());
+      // maybe we truncated up to decimal point
+      size_t pos = res.find_last_not_of("0");
+      bool at_dec_point = res[pos] == '.' ||
+                          res[pos] == ',';
+      // don't leave a blank point
+      if (at_dec_point) ++ pos;
+      res.resize (pos + 1);
+    }
+
+    // some final cosmetics
+    if (res == "-0.0") res.erase(0, 1);
+    else if (res == "-0") res.erase(0, 1);
+
+    // add unit now
+    res += n->unit();
+
+    // check for a valid unit here
+    // includes result for reporting
     if (n->numerator_units().size() > 1 ||
         n->denominator_units().size() > 0 ||
         (n->numerator_units().size() && n->numerator_units()[0].find_first_of('/') != string::npos) ||
         (n->numerator_units().size() && n->numerator_units()[0].find_first_of('*') != string::npos)
     ) {
-      error(d + n->unit() + " isn't a valid CSS value.", n->pstate());
+      error(res + " isn't a valid CSS value.", n->pstate());
     }
-    if (!n->zero() && !in_declaration_list) {
-      if (d.substr(0, 3) == "-0.") d.erase(1, 1);
-      if (d.substr(0, 2) == "0.") d.erase(0, 1);
-    }
-    // remove the leading minus
-    if (d == "-0") d.erase(0, 1);
-    // use fractional output if we had
-    // a value before it got truncated
-    if (d == "0" && nonzero) d = "0.0";
-    // if the precision is 0 sass cast
-    // casts to a float with precision 1
-    if (ctx->precision == 0) d += ".0";
-    // append number and unit
-    append_token(d + n->unit(), n);
+
+    // output the final token
+    append_token(res, n);
+
   }
 
   // helper function for serializing colors
@@ -569,7 +641,7 @@ namespace Sass {
   void Inspect::operator()(String_Quoted* s)
   {
     if (s->quote_mark()) {
-      append_token(quote(s->value(), s->quote_mark()), s);
+      append_token(quote(s->value(), s->quote_mark(), true), s);
     } else {
       append_token(s->value(), s);
     }

data/ext/libsass/lexer.cpp

@@ -31,25 +31,25 @@ namespace Sass {
     // this even seems to improve performance by quite a bit
     //####################################
 
-    const bool is_alpha(const char& chr)
+    bool is_alpha(const char& chr)
     {
       return unsigned(chr - 'A') <= 'Z' - 'A' ||
              unsigned(chr - 'a') <= 'z' - 'a';
     }
 
-    const bool is_space(const char& chr)
+    bool is_space(const char& chr)
     {
       // adapted the technique from is_alpha
       return chr == ' ' || unsigned(chr - '\t') <= '\r' - '\t';
     }
 
-    const bool is_digit(const char& chr)
+    bool is_digit(const char& chr)
     {
       // adapted the technique from is_alpha
       return unsigned(chr - '0') <= '9' - '0';
     }
 
-    const bool is_xdigit(const char& chr)
+    bool is_xdigit(const char& chr)
     {
       // adapted the technique from is_alpha
       return unsigned(chr - '0') <= '9' - '0' ||
@@ -57,26 +57,26 @@ namespace Sass {
              unsigned(chr - 'A') <= 'F' - 'A';
     }
 
-    const bool is_punct(const char& chr)
+    bool is_punct(const char& chr)
     {
       // locale independent
       return chr == '.';
     }
 
-    const bool is_alnum(const char& chr)
+    bool is_alnum(const char& chr)
     {
       return is_alpha(chr) || is_digit(chr);
     }
 
     // check if char is outside ascii range
-    const bool is_unicode(const char& chr)
+    bool is_unicode(const char& chr)
     {
       // check for unicode range
       return unsigned(chr) > 127;
     }
 
     // Match word character (look ahead)
-    const bool is_character(const char& chr)
+    bool is_character(const char& chr)
     {
       // valid alpha, numeric or unicode char (plus hyphen)
       return is_alnum(chr) || is_unicode(chr) || chr == '-';

data/ext/libsass/lexer.hpp

@@ -25,14 +25,14 @@ namespace Sass {
     //####################################
 
     // These are locale independant
-    const bool is_space(const char& src);
-    const bool is_alpha(const char& src);
-    const bool is_punct(const char& src);
-    const bool is_digit(const char& src);
-    const bool is_alnum(const char& src);
-    const bool is_xdigit(const char& src);
-    const bool is_unicode(const char& src);
-    const bool is_character(const char& src);
+    bool is_space(const char& src);
+    bool is_alpha(const char& src);
+    bool is_punct(const char& src);
+    bool is_digit(const char& src);
+    bool is_alnum(const char& src);
+    bool is_xdigit(const char& src);
+    bool is_unicode(const char& src);
+    bool is_character(const char& src);
 
     // Match a single ctype predicate.
     const char* space(const char* src);

data/ext/libsass/output.cpp

@@ -349,11 +349,13 @@ namespace Sass {
 
     append_scope_opener();
 
+    bool format = kwd != "@font-face";;
+
     for (size_t i = 0, L = b->length(); i < L; ++i) {
       Statement* stm = (*b)[i];
       if (!stm->is_hoistable()) {
         stm->perform(this);
-        if (i < L - 1) append_special_linefeed();
+        if (i < L - 1 && format) append_special_linefeed();
       }
     }
 
@@ -361,7 +363,7 @@ namespace Sass {
       Statement* stm = (*b)[i];
       if (stm->is_hoistable()) {
         stm->perform(this);
-        if (i < L - 1) append_special_linefeed();
+        if (i < L - 1 && format) append_special_linefeed();
       }
     }
 
@@ -383,10 +385,16 @@ namespace Sass {
   {
     if (String_Quoted* quoted = dynamic_cast<String_Quoted*>(s)) {
       return Output::operator()(quoted);
-    } else if (!in_comment) {
-      append_token(string_to_output(s->value()), s);
     } else {
-      append_token(s->value(), s);
+      string value(s->value());
+      if (s->can_compress_whitespace() && output_style() == COMPRESSED) {
+        value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
+      }
+      if (!in_comment) {
+        append_token(string_to_output(value), s);
+      } else {
+        append_token(value, s);
+      }
     }
   }
 

data/ext/libsass/parser.cpp

@@ -40,6 +40,14 @@ namespace Sass {
     return p;
   }
 
+  Selector_List* Parser::parse_selector(const char* src, Context& ctx, ParserState pstate)
+  {
+    Parser p = Parser::from_c_str(src, ctx, pstate);
+    // ToDo: ruby sass errors on parent references
+    // ToDo: remap the source-map entries somehow
+    return p.parse_selector_group();
+  }
+
   bool Parser::peek_newline(const char* start)
   {
     return peek_linefeed(start ? start : position);
@@ -269,10 +277,18 @@ namespace Sass {
       else if (lex< uri_prefix >()) {
         Arguments* args = new (ctx.mem) Arguments(pstate);
         Function_Call* result = new (ctx.mem) Function_Call(pstate, "url", args);
-        if (lex < uri_value >()) { // chunk seems to work too!
+        if (lex< quoted_string >()) {
+          Expression* the_url = parse_string();
+          *args << new (ctx.mem) Argument(the_url->pstate(), the_url);
+        }
+        else if (lex < uri_value >(position)) { // chunk seems to work too!
           String* the_url = parse_interpolated_chunk(lexed);
           *args << new (ctx.mem) Argument(the_url->pstate(), the_url);
         }
+        else if (peek < skip_over_scopes < exactly < '(' >, exactly < ')' > > >(position)) {
+          Expression* the_url = parse_list(); // parse_interpolated_chunk(lexed);
+          *args << new (ctx.mem) Argument(the_url->pstate(), the_url);
+        }
         else {
           error("malformed URL", pstate);
         }
@@ -415,7 +431,13 @@ namespace Sass {
     string name(Util::normalize_underscores(lexed));
     ParserState var_source_position = pstate;
     if (!lex< exactly<':'> >()) error("expected ':' after " + name + " in assignment statement", pstate);
-    Expression* val = parse_list();
+    Expression* val;
+    Selector_Lookahead lookahead = lookahead_for_value(position);
+    if (lookahead.has_interpolants && lookahead.found) {
+      val = parse_value_schema(lookahead.found);
+    } else {
+      val = parse_list();
+    }
     val->is_delayed(false);
     bool is_default = false;
     bool is_global = false;
@@ -482,6 +504,9 @@ namespace Sass {
         // 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
+        if (peek < sequence < optional_spaces, exactly<rbrace> > >(p+2)) { position = p+2;
+          css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+        }
         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);
@@ -707,18 +732,9 @@ namespace Sass {
       if (lex< alternatives< even, odd > >()) {
         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_Quoted(p, lexed);
-        lex< sign >();
-        String_Constant* op = new (ctx.mem) String_Quoted(p, lexed);
-        // Binary_Expression::Type op = (lexed == "+" ? Binary_Expression::ADD : Binary_Expression::SUB);
-        lex< one_plus < digit > >();
-        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 (lex< binomial >(position)) {
+        expr = new (ctx.mem) String_Constant(p, lexed);
+        ((String_Constant*)expr)->can_compress_whitespace(true);
       }
       else if (peek< sequence< optional<sign>,
                                zero_plus<digit>,
@@ -980,13 +996,25 @@ namespace Sass {
       return new (ctx.mem) Declaration(prop->pstate(), prop, parse_static_value()/*, lex<important>()*/);
     }
     else {
-      Expression* list_ex = parse_list();
-      if (List* list = dynamic_cast<List*>(list_ex)) {
-        if (list->length() == 0 && !peek< exactly <'{'> >()) {
-          css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+      Expression* value;
+      Selector_Lookahead lookahead = lookahead_for_value(position);
+      if (lookahead.found) {
+        if (lookahead.has_interpolants) {
+          value = parse_value_schema(lookahead.found);
+        } else {
+          value = parse_list();
+        }
+      }
+      else {
+        value = parse_list();
+        if (List* list = dynamic_cast<List*>(value)) {
+          if (list->length() == 0 && !peek< exactly <'{'> >()) {
+            css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+          }
         }
       }
-      return new (ctx.mem) Declaration(prop->pstate(), prop, list_ex/*, lex<important>()*/);
+
+      return new (ctx.mem) Declaration(prop->pstate(), prop, value/*, lex<important>()*/);
     }
   }
 
@@ -1008,8 +1036,18 @@ namespace Sass {
 
   Expression* Parser::parse_map()
   {
-    To_String to_string(&ctx);
+    ParserState opstate = pstate;
     Expression* key = parse_list();
+    if (String_Quoted* str = dynamic_cast<String_Quoted*>(key)) {
+      if (!str->quote_mark() && !str->is_delayed()) {
+        if (ctx.names_to_colors.count(str->value())) {
+          Color* c = new (ctx.mem) Color(*ctx.names_to_colors[str->value()]);
+          c->pstate(str->pstate());
+          c->disp(str->value());
+          key = c;
+        }
+      }
+    }
 
     // it's not a map so return the lexed value as a list value
     if (!peek< exactly<':'> >())
@@ -1019,7 +1057,7 @@ namespace Sass {
 
     Expression* value = parse_space_list();
 
-    Map* map = new (ctx.mem) Map(pstate, 1);
+    Map* map = new (ctx.mem) Map(opstate, 1);
     (*map) << make_pair(key, value);
 
     while (lex_css< exactly<','> >())
@@ -1029,6 +1067,16 @@ namespace Sass {
       { break; }
 
       Expression* key = parse_list();
+      if (String_Quoted* str = dynamic_cast<String_Quoted*>(key)) {
+        if (!str->quote_mark() && !str->is_delayed()) {
+          if (ctx.names_to_colors.count(str->value())) {
+            Color* c = new (ctx.mem) Color(*ctx.names_to_colors[str->value()]);
+            c->pstate(str->pstate());
+            c->disp(str->value());
+            key = c;
+          }
+        }
+      }
 
       if (!(lex< exactly<':'> >()))
       { error("invalid syntax", pstate); }
@@ -1038,8 +1086,15 @@ namespace Sass {
       (*map) << make_pair(key, value);
     }
 
-    if (map->has_duplicate_key())
-    { error("Duplicate key \"" + map->get_duplicate_key()->perform(&to_string) + "\" in map " + map->perform(&to_string) + ".", pstate); }
+    // Check was moved to eval step
+    // if (map->has_duplicate_key()) {
+    //   To_String to_string(&ctx);
+    //   error("Duplicate key \"" + map->get_duplicate_key()->perform(&to_string) + "\" in map " + map->perform(&to_string) + ".", pstate);
+    // }
+
+    ParserState ps = map->pstate();
+    ps.offset = pstate - ps + pstate.offset;
+    map->pstate(ps);
 
     return map;
   }
@@ -1211,6 +1266,11 @@ namespace Sass {
     }
     // if it's a singleton, return it directly; don't wrap it
     if (!peek< class_char< static_ops > >(position)) return factor;
+    return parse_operators(factor);
+  }
+
+  Expression* Parser::parse_operators(Expression* factor)
+  {
     // parse more factors and operators
     vector<Expression*> operands; // factors
     vector<Binary_Expression::Type> operators; // ops
@@ -1367,6 +1427,9 @@ namespace Sass {
         }
         // we need to skip anything inside strings
         // create a new target in parser/prelexer
+        if (peek < sequence < optional_spaces, exactly<rbrace> > >(p+2)) { position = p+2;
+          css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+        }
         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
@@ -1415,28 +1478,26 @@ namespace Sass {
     Token str(lexed);
     const char* i = str.begin;
     // see if there any interpolants
-    const char* q;
     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(pstate, normalize_wspace(string(str.begin, str.end)));
       str_node->is_delayed(true);
+      str_node->quote_mark('*');
       return str_node;
     }
 
     String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     while (i < str.end) {
-      q = find_first_in_interval< alternatives< exactly<'"'>, exactly<'\''> > >(i, str.end);
       p = find_first_in_interval< exactly<hash_lbrace> >(i, str.end);
-      if (q && (!p || p > q)) {
-        if (i < q) {
-          (*schema) << new (ctx.mem) String_Constant(pstate, string(i, q)); // accumulate the preceding segment if it's nonempty
-        }
-        (*schema) << new (ctx.mem) String_Constant(pstate, string(q, q+1)); // capture the quote mark separately
-        i = q+1;
-      }
-      else if (p) {
+      if (p) {
         if (i < p) {
-          (*schema) << new (ctx.mem) String_Constant(pstate, string(i, p)); // accumulate the preceding segment if it's nonempty
+          String_Constant* part = new (ctx.mem) String_Constant(pstate, normalize_wspace(string(i, p))); // accumulate the preceding segment if it's nonempty
+          part->is_delayed(true);
+          part->quote_mark('*'); // avoid unquote in interpolation
+          (*schema) << part;
+        }
+        if (peek < sequence < optional_spaces, exactly<rbrace> > >(p+2)) { position = p+2;
+          css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
         }
         const char* j = skip_over_scopes< exactly<hash_lbrace>, exactly<rbrace> >(p+2, str.end); // find the closing brace
         if (j) {
@@ -1452,7 +1513,12 @@ namespace Sass {
         }
       }
       else { // no interpolants left; add the last segment if nonempty
-        if (i < str.end) (*schema) << new (ctx.mem) String_Constant(pstate, string(i, str.end));
+        if (i < str.end) {
+          String_Constant* part = new (ctx.mem) String_Constant(pstate, normalize_wspace(string(i, str.end)));
+          part->is_delayed(true);
+          part->quote_mark('*'); // avoid unquote in interpolation
+          (*schema) << part;
+        }
         break;
       }
     }
@@ -1466,15 +1532,13 @@ namespace Sass {
       *kwd_arg << new (ctx.mem) Variable(pstate, Util::normalize_underscores(lexed));
     } else {
       lex< alternatives< identifier_schema, identifier > >();
-      *kwd_arg << new (ctx.mem) String_Quoted(pstate, lexed);
+      *kwd_arg << new (ctx.mem) String_Constant(pstate, lexed);
     }
     lex< exactly<'='> >();
-    *kwd_arg << new (ctx.mem) String_Quoted(pstate, lexed);
+    *kwd_arg << new (ctx.mem) String_Constant(pstate, lexed);
     if (peek< variable >()) *kwd_arg << parse_list();
     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);
-    }
+    else if (peek < ie_keyword_arg_value >()) { *kwd_arg << parse_list(); }
     return kwd_arg;
   }
 
@@ -1482,8 +1546,14 @@ namespace Sass {
   {
     String_Schema* schema = new (ctx.mem) String_Schema(pstate);
     size_t num_items = 0;
+    if (peek<exactly<'}'>>()) {
+      css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+    }
     while (position < stop) {
-      if (lex< interpolant >()) {
+      if (lex< spaces >() && num_items) {
+        (*schema) << new (ctx.mem) String_Constant(pstate, " ");
+      }
+      else if (lex< interpolant >()) {
         Token insides(Token(lexed.begin + 2, lexed.end - 1));
         Expression* interp_node = Parser::from_token(insides, ctx, pstate).parse_list();
         interp_node->is_interpolant(true);
@@ -1502,17 +1572,28 @@ namespace Sass {
         (*schema) << new (ctx.mem) Textual(pstate, Textual::DIMENSION, lexed);
       }
       else if (lex< number >()) {
-        (*schema) << new (ctx.mem) Textual(pstate, Textual::NUMBER, lexed);
+        Expression* factor = new (ctx.mem) Textual(pstate, Textual::NUMBER, lexed);
+        if (peek< class_char< static_ops > >()) {
+          (*schema) << parse_operators(factor);
+        } else {
+          (*schema) << factor;
+        }
       }
       else if (lex< hex >()) {
         (*schema) << new (ctx.mem) Textual(pstate, Textual::HEX, unquote(lexed));
       }
+      else if (lex < exactly < '-' > >()) {
+        (*schema) << new (ctx.mem) String_Constant(pstate, lexed);
+      }
       else if (lex< quoted_string >()) {
         (*schema) << new (ctx.mem) String_Quoted(pstate, lexed);
       }
       else if (lex< variable >()) {
         (*schema) << new (ctx.mem) Variable(pstate, Util::normalize_underscores(lexed));
       }
+      else if (peek< parenthese_scope >()) {
+        (*schema) << parse_factor();
+      }
       else {
         error("error parsing interpolated value", pstate);
       }
@@ -1575,6 +1656,9 @@ namespace Sass {
         }
         // we need to skip anything inside strings
         // create a new target in parser/prelexer
+        if (peek < sequence < optional_spaces, exactly<rbrace> > >(p+2)) { position = p+2;
+          css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
+        }
         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
@@ -1988,6 +2072,7 @@ namespace Sass {
            (q = peek< class_name >(p))                             ||
            (q = peek< sequence< pseudo_prefix, identifier > >(p))  ||
            (q = peek< percentage >(p))                             ||
+           (q = peek< variable >(p))                            ||
            (q = peek< dimension >(p))                              ||
            (q = peek< quoted_string >(p))                          ||
            (q = peek< exactly<'*'> >(p))                           ||
@@ -2050,6 +2135,7 @@ namespace Sass {
            (q = peek< sequence< pseudo_prefix, identifier > >(p))  ||
            (q = peek< percentage >(p))                             ||
            (q = peek< dimension >(p))                              ||
+           (q = peek< variable >(p))                            ||
            (q = peek< quoted_string >(p))                          ||
            (q = peek< exactly<'*'> >(p))                           ||
            (q = peek< exactly<'('> >(p))                           ||
@@ -2097,6 +2183,56 @@ namespace Sass {
     return result;
   }
 
+
+  Selector_Lookahead Parser::lookahead_for_value(const char* start)
+  {
+    const char* p = start ? start : position;
+    const char* q;
+    bool saw_interpolant = false;
+    bool saw_stuff = false;
+
+    while ((q = peek< identifier >(p))                             ||
+           (q = peek< percentage >(p))                             ||
+           (q = peek< dimension >(p))                              ||
+           (q = peek< quoted_string >(p))                          ||
+           (q = peek< variable >(p))                               ||
+           (q = peek< exactly<'*'> >(p))                           ||
+           (q = peek< exactly<'+'> >(p))                           ||
+           (q = peek< exactly<'~'> >(p))                           ||
+           (q = peek< exactly<'>'> >(p))                           ||
+           (q = peek< exactly<','> >(p))                           ||
+           (q = peek< sequence<parenthese_scope, interpolant>>(p)) ||
+           (saw_stuff && (q = peek< exactly<'-'> >(p)))            ||
+           (q = peek< binomial >(p))                               ||
+           (q = peek< block_comment >(p))                          ||
+           (q = peek< sequence< optional<sign>,
+                                zero_plus<digit>,
+                                exactly<'n'> > >(p))               ||
+           (q = peek< sequence< optional<sign>,
+                                one_plus<digit> > >(p))            ||
+           (q = peek< number >(p))                                 ||
+           (q = peek< sequence< exactly<'&'>,
+                                identifier_alnums > >(p))          ||
+           (q = peek< exactly<'&'> >(p))                           ||
+           (q = peek< exactly<'%'> >(p))                           ||
+           (q = peek< sequence< exactly<'.'>, interpolant > >(p))  ||
+           (q = peek< sequence< exactly<'#'>, interpolant > >(p))  ||
+           (q = peek< sequence< one_plus< exactly<'-'> >, interpolant > >(p))  ||
+           (q = peek< sequence< pseudo_prefix, interpolant > >(p)) ||
+           (q = peek< interpolant >(p))                            ||
+           (q = peek< optional >(p))) {
+      p = q;
+      if (*(p - 1) == '}') saw_interpolant = true;
+      saw_stuff = true;
+    }
+
+    Selector_Lookahead result;
+    result.found            = peek< alternatives< exactly<';'>, exactly<'}'>, exactly<'{'> > >(p) && saw_stuff ? p : 0;
+    result.has_interpolants = saw_interpolant;
+
+    return result;
+  }
+
   void Parser::read_bom()
   {
     size_t skip = 0;
@@ -2209,14 +2345,16 @@ namespace Sass {
     const char* pos = peek < optional_spaces >();
     bool ellipsis_left = false;
     const char* pos_left(pos);
-    while (*pos_left && pos_left >= source) {
+    while (*pos_left && pos_left > source) {
       if (pos - pos_left > max_len) {
         ellipsis_left = true;
         break;
       }
-      if (*pos_left == '\r') break;
-      if (*pos_left == '\n') break;
-      -- pos_left;
+      const char* prev = pos_left - 1;
+      if (*prev == '\r') break;
+      if (*prev == '\n') break;
+      if (*prev == 10) break;
+      pos_left = prev;
     }
     bool ellipsis_right = false;
     const char* pos_right(pos);
@@ -2227,6 +2365,7 @@ namespace Sass {
       }
       if (*pos_right == '\r') break;
       if (*pos_right == '\n') break;
+      if (*pos_left == 10) break;
       ++ pos_right;
     }
     string left(pos_left, pos);