Skip to content

N
node-sass
Commit 7eb9753c by Aaron Leung
Options

Const correctness!

parent 193110d6
Showing with 215 additions and 171 deletions
prelexer.cpp
......@@ -5,74 +5,74 @@ namespace Sass {
namespace Prelexer {
// Matches zero characters (always succeeds without consuming input).
char *epsilon(char *src) {
const char* epsilon(char *src) {
return src;
}
// Matches the empty string.
char *empty(char *src) {
const char* empty(char *src) {
return *src ? 0 : src;
}
// Match any single character.
char *any_char(char* src) { return *src ? src++ : src; }
const char* any_char(const char* src) { return *src ? src++ : src; }
// Match a single character satisfying the ctype predicates.
char* space(char* src) { return std::isspace(*src) ? src+1 : 0; }
char* alpha(char* src) { return std::isalpha(*src) ? src+1 : 0; }
char* digit(char* src) { return std::isdigit(*src) ? src+1 : 0; }
char* xdigit(char* src) { return std::isxdigit(*src) ? src+1 : 0; }
char* alnum(char* src) { return std::isalnum(*src) ? src+1 : 0; }
char* punct(char* src) { return std::ispunct(*src) ? src+1 : 0; }
const char* space(const char* src) { return std::isspace(*src) ? src+1 : 0; }
const char* alpha(const char* src) { return std::isalpha(*src) ? src+1 : 0; }
const char* digit(const char* src) { return std::isdigit(*src) ? src+1 : 0; }
const char* xdigit(const char* src) { return std::isxdigit(*src) ? src+1 : 0; }
const char* alnum(const char* src) { return std::isalnum(*src) ? src+1 : 0; }
const char* punct(const char* src) { return std::ispunct(*src) ? src+1 : 0; }
// Match multiple ctype characters.
char* spaces(char* src) { return one_plus<space>(src); }
char* alphas(char* src) { return one_plus<alpha>(src); }
char* digits(char* src) { return one_plus<digit>(src); }
char* xdigits(char* src) { return one_plus<xdigit>(src); }
char* alnums(char* src) { return one_plus<alnum>(src); }
char* puncts(char* src) { return one_plus<punct>(src); }
const char* spaces(const char* src) { return one_plus<space>(src); }
const char* alphas(const char* src) { return one_plus<alpha>(src); }
const char* digits(const char* src) { return one_plus<digit>(src); }
const char* xdigits(const char* src) { return one_plus<xdigit>(src); }
const char* alnums(const char* src) { return one_plus<alnum>(src); }
const char* puncts(const char* src) { return one_plus<punct>(src); }
// Match a line comment.
extern const char slash_slash[] = "//";
char* line_comment(char* src) { return to_endl<slash_slash>(src); }
const char* line_comment(const char* src) { return to_endl<slash_slash>(src); }
// Match a block comment.
extern const char slash_star[] = "/*";
extern const char star_slash[] = "*/";
char* block_comment(char* src) {
const char* block_comment(const char* src) {
return delimited_by<slash_star, star_slash, false>(src);
}
// Match either comment.
char* comment(char* src) {
const char* comment(const char* src) {
return alternatives<block_comment, line_comment>(src);
}
// Match double- and single-quoted strings.
char* double_quoted_string(char* src) {
const char* double_quoted_string(const char* src) {
return delimited_by<'"', '"', true>(src);
}
char* single_quoted_string(char* src) {
const char* single_quoted_string(const char* src) {
return delimited_by<'\'', '\'', true>(src);
}
char* string_constant(char* src) {
const char* string_constant(const char* src) {
return alternatives<double_quoted_string, single_quoted_string>(src);
}
// Match interpolants.
extern const char hash_lbrace[] = "#{";
extern const char rbrace[] = "}";
char* interpolant(char* src) {
const char* interpolant(const char* src) {
return delimited_by<hash_lbrace, rbrace, false>(src);
}
// Whitespace handling.
char* optional_spaces(char* src) { return optional<spaces>(src); }
char* optional_comment(char* src) { return optional<comment>(src); }
char* spaces_and_comments(char* src) {
const char* optional_spaces(const char* src) { return optional<spaces>(src); }
const char* optional_comment(const char* src) { return optional<comment>(src); }
const char* spaces_and_comments(const char* src) {
return zero_plus< alternatives<spaces, comment> >(src);
}
char* no_spaces(char *src) {
const char* no_spaces(const char* src) {
return negate< spaces >(src);
}
// Match CSS identifiers.
char* identifier(char* src) {
const char* identifier(const char* src) {
return sequence< optional< exactly<'-'> >,
alternatives< alpha, exactly<'_'> >,
zero_plus< alternatives< alnum,
......@@ -80,72 +80,77 @@ namespace Sass {
exactly<'_'> > > >(src);
}
// Match CSS '@' keywords.
char* at_keyword(char* src) {
const char* at_keyword(const char* src) {
return sequence<exactly<'@'>, identifier>(src);
}
char* name(char* src) {
extern const char import_kwd[] = "@import";
const char* import(const char* src) {
return exactly<import_kwd>(src);
}
const char* name(const char* src) {
return one_plus< alternatives< alnum,
exactly<'-'>,
exactly<'_'> > >(src);
}
// Match CSS type selectors
char* namespace_prefix(char* src) {
const char* namespace_prefix(const char* src) {
return sequence< optional< alternatives< identifier, exactly<'*'> > >,
exactly<'|'> >(src);
}
char* type_selector(char* src) {
const char* type_selector(const char* src) {
return sequence< optional<namespace_prefix>, identifier>(src);
}
char* universal(char* src) {
const char* universal(const char* src) {
return sequence< optional<namespace_prefix>, exactly<'*'> >(src);
}
// Match CSS id names.
char* id_name(char* src) {
const char* id_name(const char* src) {
return sequence<exactly<'#'>, name>(src);
}
// Match CSS class names.
char* class_name(char* src) {
const char* class_name(const char* src) {
return sequence<exactly<'.'>, identifier>(src);
}
// Match CSS numeric constants.
extern const char sign_chars[] = "-+";
char* sign(char* src) {
const char* sign(const char* src) {
return class_char<sign_chars>(src);
}
char* unsigned_number(char* src) {
const char* unsigned_number(const char* src) {
return alternatives<sequence< zero_plus<digits>,
exactly<'.'>,
one_plus<digits> >,
digits>(src);
}
char* number(char* src) {
const char* number(const char* src) {
return sequence< optional<sign>, unsigned_number>(src);
}
char* coefficient(char* src) {
const char* coefficient(const char* src) {
return alternatives< sequence< optional<sign>, digits >,
sign >(src);
}
char* binomial(char* src) {
const char* binomial(const char* src) {
return sequence< optional<sign>,
optional<digits>,
exactly<'n'>, optional_spaces,
sign, optional_spaces,
digits >(src);
}
char* percentage(char* src) {
const char* percentage(const char* src) {
return sequence< number, exactly<'%'> >(src);
}
char* dimension(char* src) {
const char* dimension(const char* src) {
return sequence<number, identifier>(src);
}
char* hex(char* src) {
char* p = sequence< exactly<'#'>, one_plus<xdigit> >(src);
const char* hex(const char* src) {
const char* p = sequence< exactly<'#'>, one_plus<xdigit> >(src);
int len = p - src;
return (len != 4 && len != 7) ? 0 : p;
}
// Match CSS uri specifiers.
extern const char url_call[] = "url(";
char* uri(char* src) {
const char* uri(const char* src) {
return sequence< exactly<url_call>,
optional<spaces>,
string_constant,
......@@ -153,20 +158,20 @@ namespace Sass {
exactly<')'> >(src);
}
// Match CSS pseudo-class/element prefixes.
char* pseudo_prefix(char* src) {
const char* pseudo_prefix(const char* src) {
return sequence< exactly<':'>, optional< exactly<':'> > >(src);
}
// Match CSS function call openers.
char* functional(char* src) {
const char* functional(const char* src) {
return sequence< identifier, exactly<'('> >(src);
}
// Match CSS 'odd' and 'even' keywords for functional pseudo-classes.
extern const char even_chars[] = "even";
extern const char odd_chars[] = "odd";
char* even(char* src) {
const char* even(const char* src) {
return exactly<even_chars>(src);
}
char* odd(char* src) {
const char* odd(const char* src) {
return exactly<odd_chars>(src);
}
// Match CSS attribute-matching operators.
......@@ -175,37 +180,37 @@ namespace Sass {
extern const char caret_equal[] = "^=";
extern const char dollar_equal[] = "$=";
extern const char star_equal[] = "*=";
char* exact_match(char* src) { return exactly<'='>(src); }
char* class_match(char* src) { return exactly<tilde_equal>(src); }
char* dash_match(char* src) { return exactly<pipe_equal>(src); }
char* prefix_match(char* src) { return exactly<caret_equal>(src); }
char* suffix_match(char* src) { return exactly<dollar_equal>(src); }
char* substring_match(char* src) { return exactly<star_equal>(src); }
const char* exact_match(const char* src) { return exactly<'='>(src); }
const char* class_match(const char* src) { return exactly<tilde_equal>(src); }
const char* dash_match(const char* src) { return exactly<pipe_equal>(src); }
const char* prefix_match(const char* src) { return exactly<caret_equal>(src); }
const char* suffix_match(const char* src) { return exactly<dollar_equal>(src); }
const char* substring_match(const char* src) { return exactly<star_equal>(src); }
// Match CSS combinators.
char* adjacent_to(char* src) {
const char* adjacent_to(const char* src) {
return sequence< optional_spaces, exactly<'+'> >(src);
}
char* precedes(char* src) {
const char* precedes(const char* src) {
return sequence< optional_spaces, exactly<'~'> >(src);
}
char* parent_of(char* src) {
const char* parent_of(const char* src) {
return sequence< optional_spaces, exactly<'>'> >(src);
}
char* ancestor_of(char* src) {
const char* ancestor_of(const char* src) {
return sequence< spaces, negate< exactly<'{'> > >(src);
}
// Match SCSS variable names.
char* variable(char* src) {
const char* variable(const char* src) {
return sequence<exactly<'$'>, name>(src);
}
// Path matching functions.
char* folder(char* src) {
const char* folder(const char* src) {
return sequence< zero_plus< any_char_except<'/'> >,
exactly<'/'> >(src);
}
char* folders(char* src) {
const char* folders(const char* src) {
return zero_plus< folder >(src);
}
}
......
prelexer.hpp
......@@ -2,17 +2,17 @@ namespace Sass {
namespace Prelexer {
typedef int (*ctype_predicate)(int);
typedef char* (*prelexer)(char*);
typedef const char* (*prelexer)(const char*);
// Match a single character literal.
template <char pre>
char* exactly(char* src) {
const char* exactly(const char* src) {
return *src == pre ? src + 1 : 0;
}
// Match a string constant.
template <const char* prefix>
char* exactly(char* src) {
const char* exactly(const char* src) {
const char* pre = prefix;
while (*pre && *src == *pre) ++src, ++pre;
return *pre ? 0 : src;
......@@ -20,13 +20,13 @@ namespace Sass {
// Match a single character that satifies the supplied ctype predicate.
template <ctype_predicate pred>
char* class_char(char* src) {
const char* class_char(const char* src) {
return pred(*src) ? src + 1 : 0;
}
// Match a single character that is a member of the supplied class.
template <const char* char_class>
char* class_char(char* src) {
const char* class_char(const char* src) {
const char* cc = char_class;
while (*cc && *src != *cc) ++cc;
return *cc ? src + 1 : 0;
......@@ -34,23 +34,23 @@ namespace Sass {
// Match a sequence of characters that all satisfy the supplied ctype predicate.
template <ctype_predicate pred>
char* class_chars(char* src) {
char* p = src;
const char* class_chars(const char* src) {
const char* p = src;
while (pred(*p)) ++p;
return p == src ? 0 : p;
}
// Match a sequence of characters that are all members of the supplied class.
template <const char* char_class>
char* class_chars(char* src) {
char* p = src;
const char* class_chars(const char* src) {
const char* p = src;
while (class_char<char_class>(p)) ++p;
return p == src ? 0 : p;
}
// Match a sequence of characters up to the next newline.
template <const char* prefix>
char* to_endl(char* src) {
const char* to_endl(const char* src) {
if (!(src = exactly<prefix>(src))) return 0;
while (*src && *src != '\n') ++src;
return src;
......@@ -58,10 +58,10 @@ namespace Sass {
// Match a sequence of characters delimited by the supplied chars.
template <char beg, char end, bool esc>
char* delimited_by(char* src) {
const char* delimited_by(const char* src) {
src = exactly<beg>(src);
if (!src) return 0;
char* stop;
const char* stop;
while (1) {
if (!*src) return 0;
stop = exactly<end>(src);
......@@ -72,10 +72,10 @@ namespace Sass {
// Match a sequence of characters delimited by the supplied strings.
template <const char* beg, const char* end, bool esc>
char* delimited_by(char* src) {
const char* delimited_by(const char* src) {
src = exactly<beg>(src);
if (!src) return 0;
char* stop;
const char* stop;
while (1) {
if (!*src) return 0;
stop = exactly<end>(src);
......@@ -85,45 +85,45 @@ namespace Sass {
}
// Match any single character.
char* any_char(char* src);
const char* any_char(const char* src);
// Match any single character except the supplied one.
template <char c>
char* any_char_except(char* src) {
const char* any_char_except(const char* src) {
return (*src && *src != c) ? src+1 : 0;
}
// Matches zero characters (always succeeds without consuming input).
char* epsilon(char*);
const char* epsilon(const char*);
// Matches the empty string.
char* empty(char*);
const char* empty(const char*);
// Succeeds of the supplied matcher fails, and vice versa.
template <prelexer mx>
char* negate(char* src) {
const char* negate(const char* src) {
return mx(src) ? 0 : src;
}
// Tries the matchers in sequence and returns the first match (or none)
template <prelexer mx1, prelexer mx2>
char* alternatives(char* src) {
char* rslt;
const char* alternatives(const char* src) {
const char* rslt;
(rslt = mx1(src)) || (rslt = mx2(src));
return rslt;
}
// Same as above, but with 3 arguments.
template <prelexer mx1, prelexer mx2, prelexer mx3>
char* alternatives(char* src) {
char* rslt;
const char* alternatives(const char* src) {
const char* rslt;
(rslt = mx1(src)) || (rslt = mx2(src)) || (rslt = mx3(src));
return rslt;
}
// Same as above, but with 4 arguments.
template <prelexer mx1, prelexer mx2, prelexer mx3, prelexer mx4>
char* alternatives(char* src) {
char* rslt;
const char* alternatives(const char* src) {
const char* rslt;
(rslt = mx1(src)) || (rslt = mx2(src)) ||
(rslt = mx3(src)) || (rslt = mx4(src));
return rslt;
......@@ -132,8 +132,8 @@ namespace Sass {
// Same as above, but with 5 arguments.
template <prelexer mx1, prelexer mx2, prelexer mx3,
prelexer mx4, prelexer mx5>
char* alternatives(char* src) {
char* rslt;
const char* alternatives(const char* src) {
const char* rslt;
(rslt = mx1(src)) || (rslt = mx2(src)) || (rslt = mx3(src)) ||
(rslt = mx4(src)) || (rslt = mx5(src));
return rslt;
......@@ -142,8 +142,8 @@ namespace Sass {
// Same as above, but with 6 arguments.
template <prelexer mx1, prelexer mx2, prelexer mx3,
prelexer mx4, prelexer mx5, prelexer mx6>
char* alternatives(char* src) {
char* rslt;
const char* alternatives(const char* src) {
const char* rslt;
(rslt = mx1(src)) || (rslt = mx2(src)) || (rslt = mx3(src)) ||
(rslt = mx4(src)) || (rslt = mx5(src)) || (rslt = mx6(src));
return rslt;
......@@ -151,24 +151,24 @@ namespace Sass {
// Tries the matchers in sequence and succeeds if they all succeed.
template <prelexer mx1, prelexer mx2>
char* sequence(char* src) {
char* rslt = src;
const char* sequence(const char* src) {
const char* rslt = src;
(rslt = mx1(rslt)) && (rslt = mx2(rslt));
return rslt;
}
// Same as above, but with 3 arguments.
template <prelexer mx1, prelexer mx2, prelexer mx3>
char* sequence(char* src) {
char* rslt = src;
const char* sequence(const char* src) {
const char* rslt = src;
(rslt = mx1(rslt)) && (rslt = mx2(rslt)) && (rslt = mx3(rslt));
return rslt;
}
// Same as above, but with 4 arguments.
template <prelexer mx1, prelexer mx2, prelexer mx3, prelexer mx4>
char* sequence(char* src) {
char* rslt = src;
const char* sequence(const char* src) {
const char* rslt = src;
(rslt = mx1(rslt)) && (rslt = mx2(rslt)) &&
(rslt = mx3(rslt)) && (rslt = mx4(rslt));
return rslt;
......@@ -178,8 +178,8 @@ namespace Sass {
template <prelexer mx1, prelexer mx2,
prelexer mx3, prelexer mx4,
prelexer mx5>
char* sequence(char* src) {
char* rslt = src;
const char* sequence(const char* src) {
const char* rslt = src;
(rslt = mx1(rslt)) && (rslt = mx2(rslt)) &&
(rslt = mx3(rslt)) && (rslt = mx4(rslt)) &&
(rslt = mx5(rslt));
......@@ -190,8 +190,8 @@ namespace Sass {
template <prelexer mx1, prelexer mx2,
prelexer mx3, prelexer mx4,
prelexer mx5, prelexer mx6>
char* sequence(char* src) {
char* rslt = src;
const char* sequence(const char* src) {
const char* rslt = src;
(rslt = mx1(rslt)) && (rslt = mx2(rslt)) &&
(rslt = mx3(rslt)) && (rslt = mx4(rslt)) &&
(rslt = mx5(rslt)) && (rslt = mx6(rslt));
......@@ -203,8 +203,8 @@ namespace Sass {
prelexer mx3, prelexer mx4,
prelexer mx5, prelexer mx6,
prelexer mx7>
char* sequence(char* src) {
char* rslt = src;
const char* sequence(const char* src) {
const char* rslt = src;
(rslt = mx1(rslt)) && (rslt = mx2(rslt)) &&
(rslt = mx3(rslt)) && (rslt = mx4(rslt)) &&
(rslt = mx5(rslt)) && (rslt = mx6(rslt)) &&
......@@ -214,125 +214,126 @@ namespace Sass {
// Match a pattern or not. Always succeeds.
template <prelexer mx>
char* optional(char* src) {
char* p = mx(src);
const char* optional(const char* src) {
const char* p = mx(src);
return p ? p : src;
}
// Match zero or more of the supplied pattern
template <prelexer mx>
char* zero_plus(char* src) {
char* p = mx(src);
const char* zero_plus(const char* src) {
const char* p = mx(src);
while (p) src = p, p = mx(src);
return src;
}
// Match one or more of the supplied pattern
template <prelexer mx>
char* one_plus(char* src) {
char* p = mx(src);
const char* one_plus(const char* src) {
const char* p = mx(src);
if (!p) return 0;
while (p) src = p, p = mx(src);
return src;
}
// Match a single character satisfying the ctype predicates.
char *space(char *src);
char *alpha(char *src);
char *digit(char *src);
char *xdigit(char *src);
char *alnum(char *src);
char *punct(char *src);
const char* space(const char* src);
const char* alpha(const char* src);
const char* digit(const char* src);
const char* xdigit(const char* src);
const char* alnum(const char* src);
const char* punct(const char* src);
// Match multiple ctype characters.
char* spaces(char* src);
char* alphas(char* src);
char* digits(char* src);
char* xdigits(char* src);
char* alnums(char* src);
char* puncts(char* src);
const char* spaces(const char* src);
const char* alphas(const char* src);
const char* digits(const char* src);
const char* xdigits(const char* src);
const char* alnums(const char* src);
const char* puncts(const char* src);
// Match a line comment.
char* line_comment(char* src);
const char* line_comment(const char* src);
// Match a block comment.
char* block_comment(char* src);
const char* block_comment(const char* src);
// Match either.
char* comment(char* src);
const char* comment(const char* src);
// Match double- and single-quoted strings.
char* double_quoted_string(char* src);
char* single_quoted_string(char* src);
char* string_constant(char* src);
const char* double_quoted_string(const char* src);
const char* single_quoted_string(const char* src);
const char* string_constant(const char* src);
// Match interpolants.
char* interpolant(char* src);
const char* interpolant(const char* src);
// Whitespace handling.
char* optional_spaces(char* src);
char* optional_comment(char* src);
char* spaces_and_comments(char* src);
char* no_spaces(char *src);
const char* optional_spaces(const char* src);
const char* optional_comment(const char* src);
const char* spaces_and_comments(const char* src);
const char* no_spaces(const char* src);
// Match a CSS identifier.
char* identifier(char* src);
const char* identifier(const char* src);
// Match CSS '@' keywords.
char* at_keyword(char* src);
const char* at_keyword(const char* src);
const char* import(const char* src);
// Match CSS type selectors
char* namespace_prefix(char* src);
char* type_selector(char* src);
char* universal(char* src);
const char* namespace_prefix(const char* src);
const char* type_selector(const char* src);
const char* universal(const char* src);
// Match CSS id names.
char* id_name(char* src);
const char* id_name(const char* src);
// Match CSS class names.
char* class_name(char* src);
const char* class_name(const char* src);
// Match CSS numeric constants.
char* sign(char* src);
char* unsigned_number(char* src);
char* number(char* src);
char* coefficient(char* src);
char* binomial(char* src);
char* percentage(char* src);
char* dimension(char* src);
char* hex(char* src);
const char* sign(const char* src);
const char* unsigned_number(const char* src);
const char* number(const char* src);
const char* coefficient(const char* src);
const char* binomial(const char* src);
const char* percentage(const char* src);
const char* dimension(const char* src);
const char* hex(const char* src);
// Match CSS uri specifiers.
char* uri(char* src);
const char* uri(const char* src);
// Match CSS pseudo-class/element prefixes
char* pseudo_prefix(char* src);
const char* pseudo_prefix(const char* src);
// Match CSS function call openers.
char* functional(char* src);
const char* functional(const char* src);
// Match CSS 'odd' and 'even' keywords for functional pseudo-classes.
char* even(char* src);
char* odd(char* src);
const char* even(const char* src);
const char* odd(const char* src);
// Match CSS attribute-matching operators.
char* exact_match(char* src);
char* class_match(char* src);
char* dash_match(char* src);
char* prefix_match(char* src);
char* suffix_match(char* src);
char* substring_match(char* src);
const char* exact_match(const char* src);
const char* class_match(const char* src);
const char* dash_match(const char* src);
const char* prefix_match(const char* src);
const char* suffix_match(const char* src);
const char* substring_match(const char* src);
// Match CSS combinators.
char* adjacent_to(char* src);
char* precedes(char* src);
char* parent_of(char* src);
char* ancestor_of(char* src);
const char* adjacent_to(const char* src);
const char* precedes(const char* src);
const char* parent_of(const char* src);
const char* ancestor_of(const char* src);
// Match SCSS variable names.
char* variable(char* src);
const char* variable(const char* src);
// Path matching functions.
char* folder(char* src);
char* folders(char* src);
const char* folder(const char* src);
const char* folders(const char* src);
// Utility functions for finding and counting characters in a string.
template<char c>
char* find_first(char* src) {
const char* find_first(const char* src) {
while (*src && *src != c) ++src;
return *src ? src : 0;
}
template<prelexer mx>
char* find_first(char* src) {
const char* find_first(const char* src) {
while (*src && !mx(src)) ++src;
return *src ? src : 0;
}
template <char c>
unsigned int count_interval(char* beg, char* end) {
unsigned int count_interval(const char* beg, const char* end) {
unsigned int counter = 0;
while (beg < end && *beg) {
if (*beg == c) ++counter;
......@@ -341,10 +342,10 @@ namespace Sass {
return counter;
}
template <prelexer mx>
unsigned int count_interval(char* beg, char* end) {
unsigned int count_interval(const char* beg, const char* end) {
unsigned int counter = 0;
while (beg < end && *beg) {
char* p;
const char* p;
if (p = mx(beg)) {
++counter;
beg = p;
......
token.cpp
......@@ -5,7 +5,44 @@ namespace Sass {
Token::Token(const char* begin, const char* end)
: begin(begin), end(end) { }
void Token::stream_unquoted(std::stringstream& buf) const {
string Token::unquote() const {
string result;
const char* p = begin;
if (*begin == '\'' || *begin == '"') {
++p;
while (p < end) {
if (*p == '\\') {
switch (*(++p)) {
case 'n': result += '\n'; break;
case 't': result += '\t'; break;
case 'b': result += '\b'; break;
case 'r': result += '\r'; break;
case 'f': result += '\f'; break;
case 'v': result += '\v'; break;
case 'a': result += '\a'; break;
case '\\': result += '\\'; break;
default: result += *p; break;
}
}
else if (p == end - 1) {
return result;
}
else {
result += *p;
}
++p;
}
return result;
}
else {
while (p < end) {
result += *(p++);
}
return result;
}
}
void Token::unquote_to_stream(std::stringstream& buf) const {
const char* p = begin;
if (*begin == '\'' || *begin == '"') {
++p;
......
token.hpp
......@@ -15,7 +15,8 @@ namespace Sass {
inline operator string() const
{ return string(begin, end - begin); }
void stream_unquoted(std::stringstream& buf) const;
string unquote() const;
void unquote_to_stream(std::stringstream& buf) const;
bool operator<(const Token& rhs) const;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment