Minor re-factoring on ParserState and Token

Remove obsolete code, arguments and members

Author: mgreter

error_handling.cpp

@@ -13,8 +13,6 @@ namespace Sass {
 
   void error(string msg, ParserState pstate, Backtrace* bt)
   {
-    if (!pstate.path.empty() && Prelexer::quoted_string(pstate.path.c_str()))
-      pstate.path = pstate.path.substr(1, pstate.path.size() - 1);
 
     Backtrace top(bt, pstate, "");
     msg += top.to_string();

error_handling.hpp

@@ -14,7 +14,6 @@ namespace Sass {
     enum Type { read, write, syntax, evaluation };
 
     Type type;
-    string path;
     ParserState pstate;
     string message;
 

eval.cpp

@@ -671,7 +671,7 @@ namespace Sass {
       case Textual::DIMENSION:
         result = new (ctx.mem) Number(t->pstate(),
                                       sass_atof(num.c_str()),
-                                      Token(number(text.c_str()), t->pstate()),
+                                      Token(number(text.c_str())),
                                       zero);
         break;
       case Textual::HEX: {

parser.cpp

@@ -505,10 +505,10 @@ namespace Sass {
         }
         if (peek_newline()) ref_wrap->has_line_break(true);
       }
-      while (peek< sequence< optional_css_whitespace, optional < block_comment >, exactly<','> > >())
+      while (peek< sequence < optional_css_whitespace, optional < block_comment >, exactly<','> > >())
       {
         // consume everything up and including the comma speparator
-        reloop = lex< sequence< optional_css_comments, exactly<','> > >() != 0;
+        reloop = lex< sequence < optional_css_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);
@@ -1114,12 +1114,13 @@ namespace Sass {
   {
     Expression* expr1 = parse_expression();
     // if it's a singleton, return it directly; don't wrap it
-    if (!(peek< alternatives < eq_op,
-                               neq_op,
-                               gte_op,
-                               gt_op,
-                               lte_op,
-                               lt_op
+    if (!(peek< alternatives <
+            eq_op,
+            neq_op,
+            gte_op,
+            gt_op,
+            lte_op,
+            lt_op
           > >(position)))
     { return expr1; }
 
@@ -1363,7 +1364,7 @@ namespace Sass {
         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, before_token), ctx, pstate).parse_list();
+          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, pstate).parse_list();
           interp_node->is_interpolant(true);
           (*schema) << interp_node;
           i = j;
@@ -1424,7 +1425,7 @@ namespace Sass {
         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, before_token), ctx, pstate).parse_list();
+          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, pstate).parse_list();
           interp_node->is_interpolant(true);
           (*schema) << interp_node;
           i = j;
@@ -1467,7 +1468,7 @@ namespace Sass {
     size_t num_items = 0;
     while (position < stop) {
       if (lex< interpolant >()) {
-        Token insides(Token(lexed.begin + 2, lexed.end - 1, before_token));
+        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);
         (*schema) << interp_node;
@@ -1561,7 +1562,7 @@ namespace Sass {
         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, before_token), ctx, pstate).parse_list();
+          Expression* interp_node = Parser::from_token(Token(p+2, j), ctx, pstate).parse_list();
           interp_node->is_interpolant(true);
           (*schema) << interp_node;
           schema->has_interpolants(true);
@@ -1592,7 +1593,7 @@ namespace Sass {
     const char* arg_end = position;
     lex< exactly<')'> >();
 
-    Argument* arg = new (ctx.mem) Argument(arg_pos, parse_interpolated_chunk(Token(arg_beg, arg_end, before_token)));
+    Argument* arg = new (ctx.mem) Argument(arg_pos, parse_interpolated_chunk(Token(arg_beg, arg_end)));
     Arguments* args = new (ctx.mem) Arguments(arg_pos);
     *args << arg;
     return new (ctx.mem) Function_Call(call_pos, name, args);
@@ -1895,7 +1896,7 @@ namespace Sass {
     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));
+      Token* t = new Token(i, p);
       error("Invalid CSS after \"(\": expected \"with\" or \"without\", was \""+t->to_string()+"\"", pstate);
     }
 

parser.hpp

@@ -197,7 +197,7 @@ namespace Sass {
       after_token = after_token + size;
 
       // create parsed token string (public member)
-      lexed = Token(wspace_start, it_before_token, it_after_token, optional_css_whitespace(it_after_token) ? optional_css_whitespace(it_after_token) : it_after_token, before_token);
+      lexed = Token(wspace_start, it_before_token, it_after_token);
       Position pos(before_token.file, before_token.line, before_token.column);
       pstate = ParserState(path, lexed, pos, size);
 

position.cpp

@@ -19,20 +19,40 @@ namespace Sass {
   Offset::Offset(const size_t line, const size_t column)
   : line(line), column(column) { }
 
+  // init/create instance from const char substring
+  Offset Offset::init(const char* beg, const char* end)
+  {
+    Offset offset(0, 0);
+    if (end == 0) {
+      end += strlen(beg);
+    }
+    offset.add(beg, end);
+    return offset;
+  }
+
   // increase offset by given string (mostly called by lexer)
   // increase line counter and count columns on the last line
-  Offset Offset::inc(const char* begin, const char* end) const
+  // ToDo: make the col count utf8 aware
+  void Offset::add(const char* begin, const char* end)
   {
-    Offset offset(line, column);
     while (begin < end && *begin) {
       if (*begin == '\n') {
-        ++ offset.line;
-        offset.column = 0;
+        ++ line;
+        // start new line
+        column = 0;
       } else {
-        ++ offset.column;
+        ++ column;
       }
       ++begin;
     }
+  }
+
+  // increase offset by given string (mostly called by lexer)
+  // increase line counter and count columns on the last line
+  Offset Offset::inc(const char* begin, const char* end) const
+  {
+    Offset offset(line, column);
+    offset.add(begin, end);
     return offset;
   }
 
@@ -48,12 +68,17 @@ namespace Sass {
 
   void Offset::operator+= (const Offset &off)
   {
-    *this = Offset(line + off.line, off.line > 0 ? off.column : off.column + column);
+    *this = Offset(line + off.line, off.line > 0 ? off.column : column + off.column);
   }
 
   Offset Offset::operator+ (const Offset &off) const
   {
-    return Offset(line + off.line, off.line > 0 ? off.column : off.column + column);
+    return Offset(line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  Offset Offset::operator- (const Offset &off) const
+  {
+    return Offset(line - off.line, off.line == line ? column - off.column : column);
   }
 
   Position::Position(const size_t file)
@@ -69,9 +94,6 @@ namespace Sass {
   : Offset(line, column), file(file) { }
 
 
-  ParserState::ParserState(string path)
-  : Position(-1, 0, 0), path(path), offset(0, 0), token() { }
-
   ParserState::ParserState(string path, const size_t file)
   : Position(file, 0, 0), path(path), offset(0, 0), token() { }
 
@@ -81,6 +103,11 @@ namespace Sass {
   ParserState::ParserState(string path, Token token, Position position, Offset offset)
   : Position(position), path(path), offset(offset), token(token) { }
 
+  void Position::add(const char* begin, const char* end)
+  {
+    Offset::add(begin, end);
+  }
+
   Position Position::inc(const char* begin, const char* end) const
   {
     Offset offset(line, column);
@@ -100,12 +127,17 @@ namespace Sass {
 
   void Position::operator+= (const Offset &off)
   {
-    *this = Position(file, line + off.line, off.line > 0 ? off.column : off.column + column);
+    *this = Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);
   }
 
   const Position Position::operator+ (const Offset &off) const
   {
-    return Position(file, line + off.line, off.line > 0 ? off.column : off.column + column);
+    return Position(file, line + off.line, off.line > 0 ? off.column : column + off.column);
+  }
+
+  const Offset Position::operator- (const Offset &off) const
+  {
+    return Offset(line - off.line, off.line == line ? column - off.column : column);
   }
 
   /* not used anymore - remove?

position.hpp

@@ -19,13 +19,18 @@ namespace Sass {
       Offset(const size_t line, const size_t column);
 
       // return new position, incremented by the given string
+      void add(const char* begin, const char* end);
       Offset inc(const char* begin, const char* end) const;
 
+      // init/create instance from const char substring
+      static Offset init(const char* beg, const char* end);
+
     public: // overload operators for position
       void operator+= (const Offset &pos);
       bool operator== (const Offset &pos) const;
       bool operator!= (const Offset &pos) const;
       Offset operator+ (const Offset &off) const;
+      Offset operator- (const Offset &off) const;
 
     public: // overload output stream operator
       // friend ostream& operator<<(ostream& strm, const Offset& off);
@@ -52,7 +57,9 @@ namespace Sass {
       bool operator== (const Position &pos) const;
       bool operator!= (const Position &pos) const;
       const Position operator+ (const Offset &off) const;
+      const Offset operator- (const Offset &off) const;
       // return new position, incremented by the given string
+      void add(const char* begin, const char* end);
       Position inc(const char* begin, const char* end) const;
 
     public: // overload output stream operator
@@ -69,25 +76,19 @@ namespace Sass {
     const char* prefix;
     const char* begin;
     const char* end;
-    const char* suffix;
-    Position start;
-    Position stop;
 
     Token()
-    : prefix(0), begin(0), end(0), suffix(0), start(0), stop(0) { }
-    Token(const char* b, const char* e, const Position pos)
-    : prefix(b), begin(b), end(e), suffix(e), start(pos), stop(pos.inc(b, e)) { }
-    Token(const char* s, const Position pos)
-    : prefix(s), begin(s), end(s + strlen(s)), suffix(end), start(pos), stop(pos.inc(s, s + strlen(s))) { }
-    Token(const char* p, const char* b, const char* e, const char* s, const Position pos)
-    : prefix(p), begin(b), end(e), suffix(s), start(pos), stop(pos.inc(b, e)) { }
+    : prefix(0), begin(0), end(0) { }
+    Token(const char* b, const char* e)
+    : prefix(b), begin(b), end(e) { }
+    Token(const char* str)
+    : prefix(str), begin(str), end(str + strlen(str)) { }
+    Token(const char* p, const char* b, const char* e)
+    : prefix(p), begin(b), end(e) { }
 
     size_t length()    const { return end - begin; }
     string ws_before() const { return string(prefix, begin); }
     string to_string() const { return string(begin, end); }
-    string ws_after() const { return string(end, suffix); }
-
-    // string unquote() const;
 
     operator bool()   { return begin && end && begin >= end; }
     operator string() { return to_string(); }
@@ -98,8 +99,7 @@ namespace Sass {
   class ParserState : public Position {
 
     public: // c-tor
-      ParserState(string path);
-      ParserState(string path, const size_t file);
+      ParserState(string path, const size_t file = string::npos);
       ParserState(string path, Position position, Offset offset = Offset(0, 0));
       ParserState(string path, Token token, Position position, Offset offset = Offset(0, 0));
 

prelexer.cpp

@@ -734,7 +734,7 @@ namespace Sass {
     const char* static_string(const char* src) {
       const char* pos = src;
       const char * s = quoted_string(pos);
-      Token t(pos, s, Position(0, 0));
+      Token t(pos, s);
       const unsigned int p = count_interval< interpolant >(t.begin, t.end);
       return (p == 0) ? t.end : 0;
     }

sass_context.cpp

@@ -407,8 +407,8 @@ extern "C" {
       c_ctx->error_status = 0;
       // reset error position
       c_ctx->error_file = 0;
-      c_ctx->error_line = -1;
-      c_ctx->error_column = -1;
+      c_ctx->error_line = string::npos;
+      c_ctx->error_column = string::npos;
 
       // use to parse block
       return cpp_ctx;

sass_interface.cpp

@@ -236,7 +236,7 @@ extern "C" {
     }
     catch (Sass_Error& e) {
       stringstream msg_stream;
-      msg_stream << e.path << ":" << e.pstate.line << ": " << e.message << endl;
+      msg_stream << e.pstate.path << ":" << e.pstate.line << ": " << e.message << endl;
       c_ctx->error_message = sass_strdup(msg_stream.str().c_str());
       c_ctx->error_status = 1;
       c_ctx->output_string = 0;