Implement case modifier for attribute selector

Author: mgreter

src/ast.hpp

@@ -2532,14 +2532,16 @@ namespace Sass {
     ADD_CONSTREF(std::string, matcher)
     // this cannot be changed to obj atm!!!!!!????!!!!!!!
     ADD_PROPERTY(String_Obj, value) // might be interpolated
+    ADD_PROPERTY(char, modifier);
   public:
-    Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v)
-    : Simple_Selector(pstate, n), matcher_(m), value_(v)
+    Attribute_Selector(ParserState pstate, std::string n, std::string m, String_Obj v, char o = 0)
+    : Simple_Selector(pstate, n), matcher_(m), value_(v), modifier_(o)
     { simple_type(ATTR_SEL); }
     Attribute_Selector(const Attribute_Selector* ptr)
     : Simple_Selector(ptr),
       matcher_(ptr->matcher_),
-      value_(ptr->value_)
+      value_(ptr->value_),
+      modifier_(ptr->modifier_)
     { simple_type(ATTR_SEL); }
     virtual size_t hash()
     {

src/emitter.cpp

@@ -105,6 +105,17 @@ namespace Sass {
     wbuf.buffer = text + wbuf.buffer;
   }
 
+  // append a single char to the buffer
+  void Emitter::append_char(const char chr)
+  {
+    // write space/lf
+    flush_schedules();
+    // add to buffer
+    wbuf.buffer += chr;
+    // account for data in source-maps
+    wbuf.smap.append(Offset(chr));
+  }
+
   // append some text or token to the buffer
   void Emitter::append_string(const std::string& text)
   {

src/emitter.hpp

@@ -66,6 +66,8 @@ namespace Sass {
       void prepend_output(const OutputBuffer& out);
       // append some text or token to the buffer
       void append_string(const std::string& text);
+      // append a single character to buffer
+      void append_char(const char chr);
       // append some white-space only text
       void append_wspace(const std::string& text);
       // append some text or token to the buffer

src/inspect.cpp

@@ -935,6 +935,10 @@ namespace Sass {
       }
     }
     add_close_mapping(s);
+    if (s->modifier() != 0) {
+      append_mandatory_space();
+      append_char(s->modifier());
+    }
     append_string("]");
   }
 

src/lexer.hpp

@@ -110,6 +110,14 @@ namespace Sass {
     }
 
 
+    // Match a single character literal.
+    // Regex equivalent: /(?:x)/i
+    // only define lower case alpha chars
+    template <char chr>
+    const char* insensitive(const char* src) {
+      return *src == chr || *src+32 == chr ? src + 1 : 0;
+    }
+
     // Match the full string literal.
     // Regex equivalent: /(?:literal)/i
     // only define lower case alpha chars

src/parser.cpp

@@ -944,12 +944,28 @@ namespace Sass {
     return 0;
   }
 
+  const char* Parser::re_attr_sensitive_close(const char* src)
+  {
+    return alternatives < exactly<']'>, exactly<'/'> >(src);
+  }
+
+  const char* Parser::re_attr_insensitive_close(const char* src)
+  {
+    return sequence < insensitive<'i'>, re_attr_sensitive_close >(src);
+  }
+
   Attribute_Selector_Obj Parser::parse_attribute_selector()
   {
     ParserState p = pstate;
     if (!lex_css< attribute_name >()) error("invalid attribute name in attribute selector", pstate);
     std::string name(lexed);
-    if (lex_css< alternatives < exactly<']'>, exactly<'/'> > >()) return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", 0);
+    if (lex_css< re_attr_sensitive_close >()) {
+      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", 0, 0);
+    }
+    else if (lex_css< re_attr_insensitive_close >()) {
+      char modifier = lexed.begin[0];
+      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", 0, modifier);
+    }
     if (!lex_css< alternatives< exact_match, class_match, dash_match,
                                 prefix_match, suffix_match, substring_match > >()) {
       error("invalid operator in attribute selector for " + name, pstate);
@@ -967,8 +983,15 @@ namespace Sass {
       error("expected a string constant or identifier in attribute selector for " + name, pstate);
     }
 
-    if (!lex_css< alternatives < exactly<']'>, exactly<'/'> > >()) error("unterminated attribute selector for " + name, pstate);
-    return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value);
+    if (lex_css< re_attr_sensitive_close >()) {
+      return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value, 0);
+    }
+    else if (lex_css< re_attr_insensitive_close >()) {
+      char modifier = lexed.begin[0];
+      return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value, modifier);
+    }
+    error("unterminated attribute selector for " + name, pstate);
+    return NULL; // to satisfy compilers (error must not return)
   }
 
   /* parse block comment and add to block */

src/parser.hpp

@@ -379,6 +379,9 @@ namespace Sass {
     Number_Ptr lexed_percentage(const std::string& parsed) { return lexed_percentage(pstate, parsed); };
     Expression_Ptr lexed_hex_color(const std::string& parsed) { return lexed_hex_color(pstate, parsed); };
 
+    static const char* re_attr_sensitive_close(const char* src);
+    static const char* re_attr_insensitive_close(const char* src);
+
   };
 
   size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);

src/position.cpp

@@ -4,6 +4,11 @@
 namespace Sass {
 
 
+  Offset::Offset(const char chr)
+  : line(chr == '\n' ? 1 : 0),
+    column(chr == '\n' ? 0 : 1)
+  {}
+
   Offset::Offset(const char* string)
   : line(0), column(0)
   {

src/position.hpp

@@ -11,6 +11,7 @@ namespace Sass {
   class Offset {
 
     public: // c-tor
+      Offset(const char chr);
       Offset(const char* string);
       Offset(const std::string& text);
       Offset(const size_t line, const size_t column);