Coverage Report

Created: 2025-11-24 06:27

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libsass/src/parser.hpp
Line
Count
Source
1
#ifndef SASS_PARSER_H
2
#define SASS_PARSER_H
3
4
// sass.hpp must go before all system headers to get the
5
// __EXTENSIONS__ fix on Solaris.
6
#include "sass.hpp"
7
8
#include <string>
9
#include <vector>
10
11
#include "ast.hpp"
12
#include "position.hpp"
13
#include "context.hpp"
14
#include "position.hpp"
15
#include "prelexer.hpp"
16
#include "source.hpp"
17
18
#ifndef MAX_NESTING
19
// Note that this limit is not an exact science
20
// it depends on various factors, which some are
21
// not under our control (compile time or even OS
22
// dependent settings on the available stack size)
23
// It should fix most common segfault cases though.
24
688k
#define MAX_NESTING 512
25
#endif
26
27
struct Lookahead {
28
  const char* found;
29
  const char* error;
30
  const char* position;
31
  bool parsable;
32
  bool has_interpolants;
33
  bool is_custom_property;
34
};
35
36
namespace Sass {
37
38
  class Parser : public SourceSpan {
39
  public:
40
41
    enum Scope { Root, Mixin, Function, Media, Control, Properties, Rules, AtRoot };
42
43
    Context& ctx;
44
    sass::vector<Block_Obj> block_stack;
45
    sass::vector<Scope> stack;
46
    SourceDataObj source;
47
    const char* begin;
48
    const char* position;
49
    const char* end;
50
    Offset before_token;
51
    Offset after_token;
52
    SourceSpan pstate;
53
    Backtraces traces;
54
    size_t indentation;
55
    size_t nestings;
56
    bool allow_parent;
57
    Token lexed;
58
59
    Parser(SourceData* source, Context& ctx, Backtraces, bool allow_parent = true);
60
61
    // special static parsers to convert strings into certain selectors
62
    static SelectorListObj parse_selector(SourceData* source, Context& ctx, Backtraces, bool allow_parent = true);
63
64
#ifdef __clang__
65
66
    // lex and peak uses the template parameter to branch on the action, which
67
    // triggers clangs tautological comparison on the single-comparison
68
    // branches. This is not a bug, just a merging of behaviour into
69
    // one function
70
71
#pragma clang diagnostic push
72
#pragma clang diagnostic ignored "-Wtautological-compare"
73
74
#endif
75
76
77
    // skip current token and next whitespace
78
    // moves SourceSpan right before next token
79
    void advanceToNextToken();
80
81
    bool peek_newline(const char* start = 0);
82
83
    // skip over spaces, tabs and line comments
84
    template <Prelexer::prelexer mx>
85
    const char* sneak(const char* start = 0)
86
4.93M
    {
87
4.93M
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4.93M
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4.93M
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4.93M
      ) {
101
981k
        return it_position;
102
981k
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3.95M
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3.95M
      return pos ? pos : it_position;
108
109
4.93M
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::identifier>(char const*)
Line
Count
Source
86
130k
    {
87
130k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
130k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
130k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
130k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
130k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
130k
      return pos ? pos : it_position;
108
109
130k
    }
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_10identifierEPKcEEXadL_ZNS2_7exactlyILc42EEES5_S5_EEJXadL_ZNS2_7exactlyIXadsoS4_L_ZNS_9Constants8warn_kwdEEEEEES5_S5_EEXadL_ZNS7_IXadsoS4_L_ZNS8_9error_kwdEEEEEES5_S5_EEXadL_ZNS7_IXadsoS4_L_ZNS8_9debug_kwdEEEEEES5_S5_EEEEES5_S5_EEEES5_S5_
char const* Sass::Parser::sneak<&Sass::Prelexer::css_comments>(char const*)
Line
Count
Source
86
920k
    {
87
920k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
920k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
920k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
920k
      ) {
101
920k
        return it_position;
102
920k
      }
103
104
      // skip over spaces, tabs and sass line comments
105
0
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
0
      return pos ? pos : it_position;
108
109
920k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)123>(char const*))>(char const*)
Line
Count
Source
86
7
    {
87
7
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
7
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
7
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
7
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
7
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
7
      return pos ? pos : it_position;
108
109
7
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)125>(char const*))>(char const*)
Line
Count
Source
86
5.38k
    {
87
5.38k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5.38k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5.38k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5.38k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5.38k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5.38k
      return pos ? pos : it_position;
108
109
5.38k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::css_whitespace>(char const*)
Line
Count
Source
86
31
    {
87
31
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
31
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
31
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
31
      ) {
101
31
        return it_position;
102
31
      }
103
104
      // skip over spaces, tabs and sass line comments
105
0
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
0
      return pos ? pos : it_position;
108
109
31
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)59>(char const*))>(char const*)
Line
Count
Source
86
16
    {
87
16
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
16
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
16
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
16
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
16
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
16
      return pos ? pos : it_position;
108
109
16
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::end_of_file>(char const*)
Line
Count
Source
86
22
    {
87
22
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
22
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
22
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
22
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
22
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
22
      return pos ? pos : it_position;
108
109
22
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::variable>(char const*)
Line
Count
Source
86
3.63k
    {
87
3.63k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3.63k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3.63k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3.63k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3.63k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3.63k
      return pos ? pos : it_position;
108
109
3.63k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_err>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_dbg>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_warn>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_if_directive>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_for_directive>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_each_directive>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_while_directive>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_return_directive>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_import>(char const*)
Line
Count
Source
86
11
    {
87
11
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11
      return pos ? pos : it_position;
108
109
11
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::uri_prefix>(char const*)
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_extend>(char const*)
Line
Count
Source
86
5
    {
87
5
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5
      return pos ? pos : it_position;
108
109
5
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_media>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_at_root>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_include_directive>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_content_directive>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_supports_directive>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_mixin>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_function>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_charset_directive>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants8else_kwdEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::at_keyword>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::block_comment>(char const*)
Line
Count
Source
86
172
    {
87
172
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
172
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
172
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
172
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
172
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
172
      return pos ? pos : it_position;
108
109
172
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::quoted_string>(char const*)
Line
Count
Source
86
128k
    {
87
128k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
128k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
128k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
128k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
128k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
128k
      return pos ? pos : it_position;
108
109
128k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::skip_over_scopes<&(char const* Sass::Prelexer::exactly<(char)40>(char const*)), &(char const* Sass::Prelexer::exactly<(char)41>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
390
    {
87
390
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
390
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
390
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
390
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
390
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
390
      return pos ? pos : it_position;
108
109
390
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)41>(char const*))>(char const*)
Line
Count
Source
86
6.09k
    {
87
6.09k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
6.09k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
6.09k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
6.09k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
6.09k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
6.09k
      return pos ? pos : it_position;
108
109
6.09k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)59>(char const*)), &(char const* Sass::Prelexer::exactly<(char)125>(char const*)), &Sass::Prelexer::end_of_file>(char const*))>(char const*)
Line
Count
Source
86
6
    {
87
6
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
6
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
6
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
6
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
6
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
6
      return pos ? pos : it_position;
108
109
6
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)44>(char const*)), &(char const* Sass::Prelexer::exactly<(char)123>(char const*)), &(char const* Sass::Prelexer::exactly<(char)59>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
2.42k
    {
87
2.42k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2.42k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2.42k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2.42k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2.42k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2.42k
      return pos ? pos : it_position;
108
109
2.42k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_6spacesEPKcEEXadL_ZNS2_13block_commentES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
1.25k
    {
87
1.25k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1.25k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1.25k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1.25k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1.25k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1.25k
      return pos ? pos : it_position;
108
109
1.25k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*)
Line
Count
Source
86
1.80k
    {
87
1.80k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1.80k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1.80k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1.80k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1.80k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1.80k
      return pos ? pos : it_position;
108
109
1.80k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants8ellipsisEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
2.30k
    {
87
2.30k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2.30k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2.30k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2.30k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2.30k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2.30k
      return pos ? pos : it_position;
108
109
2.30k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyIXadsoKcL_ZNS_9Constants11hash_lbraceEEEEEEPS5_S7_EEXadL_ZNS4_IXadsoS5_L_ZNS6_6rbraceEEEEEES7_S7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_S7_
Line
Count
Source
86
1.80k
    {
87
1.80k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1.80k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1.80k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1.80k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1.80k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1.80k
      return pos ? pos : it_position;
108
109
1.80k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::variable, &Sass::Prelexer::optional_css_comments, &(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
1.80k
    {
87
1.80k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1.80k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1.80k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1.80k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1.80k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1.80k
      return pos ? pos : it_position;
108
109
1.80k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_7exactlyILc59EEEPKcS6_EEXadL_ZNS2_11end_of_fileES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Line
Count
Source
86
3
    {
87
3
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3
      return pos ? pos : it_position;
108
109
3
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_12default_flagEPKcEEXadL_ZNS2_11global_flagES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
3
    {
87
3
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3
      return pos ? pos : it_position;
108
109
3
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::default_flag>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::global_flag>(char const*)
char const* Sass::Parser::sneak<&Sass::Prelexer::optional_css_whitespace>(char const*)
Line
Count
Source
86
19.4k
    {
87
19.4k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
19.4k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
19.4k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
19.4k
      ) {
101
19.4k
        return it_position;
102
19.4k
      }
103
104
      // skip over spaces, tabs and sass line comments
105
0
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
0
      return pos ? pos : it_position;
108
109
19.4k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::optional_spaces>(char const*)
Line
Count
Source
86
3
    {
87
3
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3
      ) {
101
3
        return it_position;
102
3
      }
103
104
      // skip over spaces, tabs and sass line comments
105
0
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
0
      return pos ? pos : it_position;
108
109
3
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_15optional_spacesEPKcEEXadL_ZNS2_7exactlyIXadsoS4_L_ZNS_9Constants6rbraceEEEEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
4.28k
    {
87
4.28k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4.28k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4.28k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4.28k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4.28k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4.28k
      return pos ? pos : it_position;
108
109
4.28k
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::quoted_string, &Sass::Prelexer::optional_spaces, &(char const* Sass::Prelexer::exactly<(char)59>(char const*))>(char const*))>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_using>(char const*)
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)40>(char const*))>(char const*)
Line
Count
Source
86
162k
    {
87
162k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
162k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
162k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
162k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
162k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
162k
      return pos ? pos : it_position;
108
109
162k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::class_name>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::id_name>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::variable, &Sass::Prelexer::number, &Sass::Prelexer::static_reference_combinator>(char const*))>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::pseudo_not>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::re_pseudo_selector>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)91>(char const*))>(char const*)
Line
Count
Source
86
157k
    {
87
157k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
157k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
157k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
157k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
157k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
157k
      return pos ? pos : it_position;
108
109
157k
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::placeholder>(char const*)
char const* Sass::Parser::sneak<&Sass::Prelexer::pseudo_prefix>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::identifier, &(char const* Sass::Prelexer::optional<&Sass::Prelexer::block_comment>(char const*)), &(char const* Sass::Prelexer::exactly<(char)40>(char const*))>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_8binomialEPKcEEXadL_ZNS2_13word_boundaryES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_14css_whitespaceEPKcEEXadL_ZNS2_11insensitiveIXadsoS4_L_ZNS_9Constants6of_kwdEEEEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_8optionalIXadL_ZNS2_13pseudo_prefixEPKcEEEES6_S6_EEXadL_ZNS2_10identifierES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::attribute_name>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Parser::re_attr_sensitive_close>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Parser::re_attr_insensitive_close>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::exact_match, &Sass::Prelexer::class_match, &Sass::Prelexer::dash_match, &Sass::Prelexer::prefix_match, &Sass::Prelexer::suffix_match, &Sass::Prelexer::substring_match>(char const*))>(char const*)
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_8optionalIXadL_ZNS2_7exactlyILc42EEEPKcS7_EEEES7_S7_EEXadL_ZNS2_17identifier_schemaES7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_S7_
Line
Count
Source
86
1
    {
87
1
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1
      return pos ? pos : it_position;
108
109
1
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::optional<&(char const* Sass::Prelexer::exactly<(char)42>(char const*))>(char const*)), &Sass::Prelexer::identifier, &(char const* Sass::Prelexer::zero_plus<&Sass::Prelexer::block_comment>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
1
    {
87
1
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1
      return pos ? pos : it_position;
108
109
1
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::one_plus<&(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
1
    {
87
1
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1
      return pos ? pos : it_position;
108
109
1
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::static_value>(char const*)
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::list_terminator>(char const*)
Line
Count
Source
86
9.51k
    {
87
9.51k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
9.51k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
9.51k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
9.51k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
9.51k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
9.51k
      return pos ? pos : it_position;
108
109
9.51k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)44>(char const*))>(char const*)
Line
Count
Source
86
11.2k
    {
87
11.2k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
11.2k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
11.2k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
11.2k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
11.2k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
11.2k
      return pos ? pos : it_position;
108
109
11.2k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::space_list_terminator>(char const*)
Line
Count
Source
86
31.6k
    {
87
31.6k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
31.6k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
31.6k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
31.6k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
31.6k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
31.6k
      return pos ? pos : it_position;
108
109
31.6k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::kwd_eq, &Sass::Prelexer::kwd_neq, &Sass::Prelexer::kwd_gte, &Sass::Prelexer::kwd_gt, &Sass::Prelexer::kwd_lte, &Sass::Prelexer::kwd_lt>(char const*))>(char const*)
Line
Count
Source
86
34.8k
    {
87
34.8k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
34.8k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
34.8k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
34.8k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
34.8k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
34.8k
      return pos ? pos : it_position;
108
109
34.8k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_eq>(char const*)
Line
Count
Source
86
7.15k
    {
87
7.15k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
7.15k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
7.15k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
7.15k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
7.15k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
7.15k
      return pos ? pos : it_position;
108
109
7.15k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_neq>(char const*)
Line
Count
Source
86
5.35k
    {
87
5.35k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5.35k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5.35k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5.35k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5.35k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5.35k
      return pos ? pos : it_position;
108
109
5.35k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_gte>(char const*)
Line
Count
Source
86
5.35k
    {
87
5.35k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5.35k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5.35k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5.35k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5.35k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5.35k
      return pos ? pos : it_position;
108
109
5.35k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_lte>(char const*)
Line
Count
Source
86
5.35k
    {
87
5.35k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5.35k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5.35k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5.35k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5.35k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5.35k
      return pos ? pos : it_position;
108
109
5.35k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_gt>(char const*)
Line
Count
Source
86
5.35k
    {
87
5.35k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5.35k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5.35k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5.35k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5.35k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5.35k
      return pos ? pos : it_position;
108
109
5.35k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_lt>(char const*)
Line
Count
Source
86
4.44k
    {
87
4.44k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4.44k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4.44k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4.44k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4.44k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4.44k
      return pos ? pos : it_position;
108
109
4.44k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)43>(char const*))>(char const*)
Line
Count
Source
86
195k
    {
87
195k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
195k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
195k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
195k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
195k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
195k
      return pos ? pos : it_position;
108
109
195k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::no_spaces>(char const*)
Line
Count
Source
86
31.6k
    {
87
31.6k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
31.6k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
31.6k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
31.6k
      ) {
101
31.6k
        return it_position;
102
31.6k
      }
103
104
      // skip over spaces, tabs and sass line comments
105
0
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
0
      return pos ? pos : it_position;
108
109
31.6k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::negate<&Sass::Prelexer::unsigned_number>(char const*)), &(char const* Sass::Prelexer::exactly<(char)45>(char const*)), &(char const* Sass::Prelexer::negate<&Sass::Prelexer::space>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
31.6k
    {
87
31.6k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
31.6k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
31.6k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
31.6k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
31.6k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
31.6k
      return pos ? pos : it_position;
108
109
31.6k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::negate<&Sass::Prelexer::unsigned_number>(char const*)), &(char const* Sass::Prelexer::exactly<(char)45>(char const*)), &(char const* Sass::Prelexer::negate<&Sass::Prelexer::unsigned_number>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
31.6k
    {
87
31.6k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
31.6k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
31.6k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
31.6k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
31.6k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
31.6k
      return pos ? pos : it_position;
108
109
31.6k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_9zero_plusIXadL_ZNS2_7exactlyILc45EEEPKcS7_EEEES7_S7_EEXadL_ZNS2_10identifierES7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_S7_
Line
Count
Source
86
6.32k
    {
87
6.32k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
6.32k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
6.32k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
6.32k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
6.32k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
6.32k
      return pos ? pos : it_position;
108
109
6.32k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_6negateIXadL_ZNS2_5digitEPKcEEEES6_S6_EEXadL_ZNS2_7exactlyILc45EEES6_S6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Line
Count
Source
86
3.16k
    {
87
3.16k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3.16k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3.16k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3.16k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3.16k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3.16k
      return pos ? pos : it_position;
108
109
3.16k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants10static_opsEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
143k
    {
87
143k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
143k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
143k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
143k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
143k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
143k
      return pos ? pos : it_position;
108
109
143k
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)93>(char const*))>(char const*)
char const* Sass::Parser::sneak<&Sass::Prelexer::ie_property>(char const*)
Line
Count
Source
86
157k
    {
87
157k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
157k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
157k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
157k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
157k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
157k
      return pos ? pos : it_position;
108
109
157k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::ie_keyword_arg>(char const*)
Line
Count
Source
86
157k
    {
87
157k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
157k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
157k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
157k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
157k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
157k
      return pos ? pos : it_position;
108
109
157k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_12calc_fn_callEPKcEEXadL_ZNS2_7exactlyILc40EEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
157k
    {
87
157k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
157k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
157k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
157k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
157k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
157k
      return pos ? pos : it_position;
108
109
157k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::functional_schema>(char const*)
Line
Count
Source
86
157k
    {
87
157k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
157k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
157k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
157k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
157k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
157k
      return pos ? pos : it_position;
108
109
157k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::identifier_schema>(char const*)
Line
Count
Source
86
157k
    {
87
157k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
157k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
157k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
157k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
157k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
157k
      return pos ? pos : it_position;
108
109
157k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::uri_prefix, &Sass::Prelexer::W, &Sass::Prelexer::real_uri_value>(char const*))>(char const*)
Line
Count
Source
86
155k
    {
87
155k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
155k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
155k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
155k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
155k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
155k
      return pos ? pos : it_position;
108
109
155k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::re_functional>(char const*)
Line
Count
Source
86
165k
    {
87
165k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
165k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
165k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
165k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
165k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
165k
      return pos ? pos : it_position;
108
109
165k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)45>(char const*))>(char const*)
Line
Count
Source
86
153k
    {
87
153k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
153k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
153k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
153k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
153k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
153k
      return pos ? pos : it_position;
108
109
153k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)47>(char const*))>(char const*)
Line
Count
Source
86
140k
    {
87
140k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
140k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
140k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
140k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
140k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
140k
      return pos ? pos : it_position;
108
109
140k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::kwd_not>(char const*))>(char const*)
Line
Count
Source
86
139k
    {
87
139k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
139k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
139k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
139k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
139k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
139k
      return pos ? pos : it_position;
108
109
139k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::ampersand>(char const*)
Line
Count
Source
86
139k
    {
87
139k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
139k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
139k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
139k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
139k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
139k
      return pos ? pos : it_position;
108
109
139k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_important>(char const*)
Line
Count
Source
86
125k
    {
87
125k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
125k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
125k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
125k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
125k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
125k
      return pos ? pos : it_position;
108
109
125k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_10percentageEPKcEEXadL_ZNS2_9lookaheadIXadL_ZNS2_6numberES5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
125k
    {
87
125k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
125k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
125k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
125k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
125k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
125k
      return pos ? pos : it_position;
108
109
125k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_6numberEPKcEEXadL_ZNS2_9lookaheadIXadL_ZNS3_IXadL_ZNS2_2opES5_EEXadL_ZNS2_6numberES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_EETpTnS8_JEEES5_S5_EEEES5_S5_
Line
Count
Source
86
125k
    {
87
125k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
125k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
125k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
125k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
125k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
125k
      return pos ? pos : it_position;
108
109
125k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_13quoted_stringEPKcEEXadL_ZNS2_9lookaheadIXadL_ZNS2_7exactlyILc45EEES5_S5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
125k
    {
87
125k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
125k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
125k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
125k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
125k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
125k
      return pos ? pos : it_position;
108
109
125k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::value_schema>(char const*)
Line
Count
Source
86
125k
    {
87
125k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
125k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
125k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
125k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
125k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
125k
      return pos ? pos : it_position;
108
109
125k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_true>(char const*)
Line
Count
Source
86
121k
    {
87
121k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
121k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
121k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
121k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
121k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
121k
      return pos ? pos : it_position;
108
109
121k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_false>(char const*)
Line
Count
Source
86
121k
    {
87
121k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
121k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
121k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
121k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
121k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
121k
      return pos ? pos : it_position;
108
109
121k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_null>(char const*)
Line
Count
Source
86
121k
    {
87
121k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
121k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
121k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
121k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
121k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
121k
      return pos ? pos : it_position;
108
109
121k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::percentage>(char const*)
Line
Count
Source
86
10.5k
    {
87
10.5k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
10.5k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
10.5k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
10.5k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
10.5k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
10.5k
      return pos ? pos : it_position;
108
109
10.5k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_12alternativesIXadL_ZNS2_3hexEPKcEEXadL_ZNS2_4hex0ES6_EETpTnPFS6_S6_EJEEES6_S6_EEXadL_ZNS2_6negateIXadL_ZNS2_7exactlyILc45EEES6_S6_EEEES6_S6_EETpTnS8_JEEES6_S6_EEEES6_S6_
Line
Count
Source
86
8.45k
    {
87
8.45k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
8.45k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
8.45k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
8.45k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
8.45k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
8.45k
      return pos ? pos : it_position;
108
109
8.45k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::hexa>(char const*)
Line
Count
Source
86
8.45k
    {
87
8.45k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
8.45k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
8.45k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
8.45k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
8.45k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
8.45k
      return pos ? pos : it_position;
108
109
8.45k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyILc35EEEPKcS6_EEXadL_ZNS2_10identifierES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Line
Count
Source
86
8.45k
    {
87
8.45k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
8.45k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
8.45k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
8.45k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
8.45k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
8.45k
      return pos ? pos : it_position;
108
109
8.45k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_9dimensionEPKcEEXadL_ZNS2_8optionalIXadL_ZNS3_IXadL_ZNS2_7exactlyILc45EEES5_S5_EEXadL_ZNS2_9lookaheadIXadL_ZNS2_12alternativesIXadL_ZNS2_5spaceES5_EEEES5_S5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_EETpTnSB_JEEES5_S5_EEEES5_S5_
Line
Count
Source
86
8.44k
    {
87
8.44k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
8.44k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
8.44k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
8.44k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
8.44k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
8.44k
      return pos ? pos : it_position;
108
109
8.44k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_16static_componentEPKcEEXadL_ZNS2_8one_plusIXadL_ZNS2_17strict_identifierES5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
3.52k
    {
87
3.52k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3.52k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3.52k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3.52k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3.52k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3.52k
      return pos ? pos : it_position;
108
109
3.52k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::number>(char const*)
Line
Count
Source
86
3.78k
    {
87
3.78k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3.78k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3.78k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3.78k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3.78k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3.78k
      return pos ? pos : it_position;
108
109
3.78k
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::css_variable_top_level_value>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::css_variable_value>(char const*)
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)40>(char const*)), &(char const* Sass::Prelexer::exactly<(char)91>(char const*)), &(char const* Sass::Prelexer::exactly<(char)123>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
10
    {
87
10
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
10
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
10
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
10
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
10
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
10
      return pos ? pos : it_position;
108
109
10
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)41>(char const*)), &(char const* Sass::Prelexer::exactly<(char)93>(char const*)), &(char const* Sass::Prelexer::exactly<(char)125>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
10
    {
87
10
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
10
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
10
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
10
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
10
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
10
      return pos ? pos : it_position;
108
109
10
    }
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_17identifier_schemaEPKcEEXadL_ZNS2_10identifierES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Unexecuted instantiation: char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)61>(char const*))>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::ie_keyword_arg_value>(char const*)
char const* Sass::Parser::sneak<&Sass::Prelexer::spaces>(char const*)
Line
Count
Source
86
9.95k
    {
87
9.95k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
9.95k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
9.95k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
9.95k
      ) {
101
9.95k
        return it_position;
102
9.95k
      }
103
104
      // skip over spaces, tabs and sass line comments
105
0
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
0
      return pos ? pos : it_position;
108
109
9.95k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants11hash_lbraceEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
9.94k
    {
87
9.94k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
9.94k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
9.94k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
9.94k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
9.94k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
9.94k
      return pos ? pos : it_position;
108
109
9.94k
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants6rbraceEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
6.30k
    {
87
6.30k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
6.30k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
6.30k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
6.30k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
6.30k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
6.30k
      return pos ? pos : it_position;
108
109
6.30k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::re_static_expression>(char const*)
Line
Count
Source
86
3.15k
    {
87
3.15k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3.15k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3.15k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3.15k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3.15k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3.15k
      return pos ? pos : it_position;
108
109
3.15k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)37>(char const*)), &(char const* Sass::Prelexer::exactly<(char)45>(char const*)), &(char const* Sass::Prelexer::exactly<(char)43>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
6.79k
    {
87
6.79k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
6.79k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
6.79k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
6.79k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
6.79k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
6.79k
      return pos ? pos : it_position;
108
109
6.79k
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::alpha>(char const*))>(char const*)
Line
Count
Source
86
4.70k
    {
87
4.70k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4.70k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4.70k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4.70k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4.70k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4.70k
      return pos ? pos : it_position;
108
109
4.70k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::dimension>(char const*)
Line
Count
Source
86
2.08k
    {
87
2.08k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2.08k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2.08k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2.08k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2.08k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2.08k
      return pos ? pos : it_position;
108
109
2.08k
    }
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_3hexEPKcEEXadL_ZNS2_6negateIXadL_ZNS2_7exactlyILc45EEES5_S5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::parenthese_scope>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::real_uri_suffix>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::real_uri_value>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::elseif_directive>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_else_directive>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_from>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_through>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_to>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)36>(char const*))>(char const*)
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyILc36EEEPKcS6_EEXadL_ZNS2_10identifierES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_in>(char const*)
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_and>(char const*)
Line
Count
Source
86
27.6k
    {
87
27.6k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
27.6k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
27.6k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
27.6k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
27.6k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
27.6k
      return pos ? pos : it_position;
108
109
27.6k
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_not>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_only>(char const*)
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_or>(char const*)
Line
Count
Source
86
27.6k
    {
87
27.6k
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
27.6k
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
27.6k
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
27.6k
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
27.6k
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
27.6k
      return pos ? pos : it_position;
108
109
27.6k
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::interpolant>(char const*)
Line
Count
Source
86
14
    {
87
14
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
14
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
14
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
14
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
14
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
14
      return pos ? pos : it_position;
108
109
14
    }
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_18kwd_with_directiveEPKcEEXadL_ZNS2_21kwd_without_directiveES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::re_string_uri_open>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::re_string_uri_close>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::re_string_double_open>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::re_string_double_close>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::re_string_single_open>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::re_string_single_close>(char const*)
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8one_plusIXadL_ZNS2_12alternativesIXadL_ZNS2_7exactlyILc62EEEPKcS7_EEXadL_ZNS2_8sequenceIXadL_ZNS5_ILc92EEES7_S7_EEXadL_ZNS2_8any_charES7_EETpTnPFS7_S7_EJEEES7_S7_EEJXadL_ZNS8_IXadL_ZNS2_6negateIXadL_ZNS8_IXadL_ZNS2_7exactlyIXadsoS6_L_ZNS_9Constants7url_kwdEEEEEES7_S7_EEXadL_ZNS5_ILc40EEES7_S7_EETpTnSA_JEEES7_S7_EEEES7_S7_EEXadL_ZNS2_14neg_class_charIXadsoS6_L_ZNSD_22almost_any_value_classEEEEEES7_S7_EETpTnSA_JEEES7_S7_EEXadL_ZNS8_IXadL_ZNS5_ILc47EEES7_S7_EEXadL_ZNSB_IXadL_ZNS4_IXadL_ZNS5_ILc47EEES7_S7_EEXadL_ZNS5_ILc42EEES7_S7_EETpTnSA_JEEES7_S7_EEEES7_S7_EETpTnSA_JEEES7_S7_EEXadL_ZNS8_IXadL_ZNS5_ILc92EEES7_S7_EEXadL_ZNS5_ILc35EEES7_S7_EEJXadL_ZNSB_IXadL_ZNS5_ILc123EEES7_S7_EEEES7_S7_EEEEES7_S7_EEXadL_ZNS8_IXadL_ZNS5_ILc33EEES7_S7_EEXadL_ZNSB_IXadL_ZNS2_5alphaES7_EEEES7_S7_EETpTnSA_JEEES7_S7_EEEEES7_S7_EEEES7_S7_EEEES7_S7_
Unexecuted instantiation: _ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_3hexEPKcEEXadL_ZNS2_4hex0ES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
char const* Sass::Parser::sneak<&Sass::Prelexer::re_selector_list>(char const*)
Line
Count
Source
86
5
    {
87
5
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5
      return pos ? pos : it_position;
108
109
5
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyILc45EEEPKcS6_EEXadL_ZNS4_ILc45EEES6_S6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Line
Count
Source
86
5
    {
87
5
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
5
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
5
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
5
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
5
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
5
      return pos ? pos : it_position;
108
109
5
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::space>(char const*)
Line
Count
Source
86
852
    {
87
852
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
852
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
852
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
852
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
852
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
852
      return pos ? pos : it_position;
108
109
852
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer10non_greedyIXadL_ZNS2_12alternativesIXadL_ZNS2_13block_commentEPKcEEXadL_ZNS2_8sequenceIXadL_ZNS2_11interpolantES6_EEXadL_ZNS2_8optionalIXadL_ZNS2_13quoted_stringES6_EEEES6_S6_EETpTnPFS6_S6_EJEEES6_S6_EEJXadL_ZNS2_10identifierES6_EEXadL_ZNS2_8variableES6_EEXadL_ZNS7_IXadL_ZNS2_16parenthese_scopeES6_EEXadL_ZNS2_11interpolantES6_EEJXadL_ZNS8_IXadL_ZNS2_13quoted_stringES6_EEEES6_S6_EEEEES6_S6_EEEEES6_S6_EEXadL_ZNS2_8sequenceIXadL_ZNS4_IXadL_ZNS2_7exactlyILc123EEES6_S6_EEXadL_ZNSC_ILc125EEES6_S6_EEJXadL_ZNSC_ILc59EEES6_S6_EEEEES6_S6_EEEES6_S6_EEEES6_S6_EEEES6_S6_
Line
Count
Source
86
3
    {
87
3
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3
      return pos ? pos : it_position;
108
109
3
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants25selector_combinator_childEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
4
    {
87
4
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4
      return pos ? pos : it_position;
108
109
4
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants27selector_combinator_generalEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
4
    {
87
4
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4
      return pos ? pos : it_position;
108
109
4
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants28selector_combinator_adjacentEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
4
    {
87
4
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4
      return pos ? pos : it_position;
108
109
4
    }
char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::end_of_file, &(char const* Sass::Prelexer::exactly<(char)123>(char const*)), &(char const* Sass::Prelexer::exactly<(char)44>(char const*))>(char const*))>(char const*)
Line
Count
Source
86
3
    {
87
3
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3
      return pos ? pos : it_position;
108
109
3
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_10class_charIXadsoKcL_ZNS_9Constants20selector_list_delimsEEEEEEPS5_S7_EEEES7_S7_EEEES7_S7_
Line
Count
Source
86
3
    {
87
3
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
3
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
3
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
3
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
3
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
3
      return pos ? pos : it_position;
108
109
3
    }
char const* Sass::Parser::sneak<&Sass::Prelexer::kwd_optional>(char const*)
Line
Count
Source
86
1
    {
87
1
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
1
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
1
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
1
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
1
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
1
      return pos ? pos : it_position;
108
109
1
    }
Unexecuted instantiation: char const* Sass::Parser::sneak<&(char const* Sass::Prelexer::exactly<(char)38>(char const*))>(char const*)
Unexecuted instantiation: char const* Sass::Parser::sneak<&Sass::Prelexer::re_type_selector>(char const*)
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants23selector_combinator_opsEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
4
    {
87
4
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4
      return pos ? pos : it_position;
108
109
4
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants23complex_selector_delimsEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
86
4
    {
87
4
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
4
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
4
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
4
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
4
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
4
      return pos ? pos : it_position;
108
109
4
    }
_ZN4Sass6Parser5sneakIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_11end_of_fileEPKcEEXadL_ZNS2_7exactlyILc123EEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
86
2
    {
87
2
      using namespace Prelexer;
88
89
      // maybe use optional start position from arguments?
90
2
      const char* it_position = start ? start : position;
91
92
      // skip white-space?
93
2
      if (mx == spaces ||
94
0
          mx == no_spaces ||
95
0
          mx == css_comments ||
96
0
          mx == css_whitespace ||
97
0
          mx == optional_spaces ||
98
0
          mx == optional_css_comments ||
99
0
          mx == optional_css_whitespace
100
2
      ) {
101
0
        return it_position;
102
0
      }
103
104
      // skip over spaces, tabs and sass line comments
105
2
      const char* pos = optional_css_whitespace(it_position);
106
      // always return a valid position
107
2
      return pos ? pos : it_position;
108
109
2
    }
110
111
    // match will not skip over space, tabs and line comment
112
    // return the position where the lexer match will occur
113
    template <Prelexer::prelexer mx>
114
    const char* match(const char* start = 0)
115
14.1k
    {
116
      // match the given prelexer
117
14.1k
      return mx(position);
118
14.1k
    }
_ZN4Sass6Parser5matchIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_21optional_css_commentsEPKcEEXadL_ZNS2_7exactlyILc59EEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
115
1
    {
116
      // match the given prelexer
117
1
      return mx(position);
118
1
    }
_ZN4Sass6Parser5matchIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_21optional_css_commentsEPKcEEXadL_ZNS2_7exactlyILc123EEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
115
1
    {
116
      // match the given prelexer
117
1
      return mx(position);
118
1
    }
char const* Sass::Parser::match<&Sass::Prelexer::ampersand>(char const*)
Line
Count
Source
115
14.1k
    {
116
      // match the given prelexer
117
14.1k
      return mx(position);
118
14.1k
    }
char const* Sass::Parser::match<&Sass::Prelexer::re_functional>(char const*)
Line
Count
Source
115
5
    {
116
      // match the given prelexer
117
5
      return mx(position);
118
5
    }
119
120
    // peek will only skip over space, tabs and line comment
121
    // return the position where the lexer match will occur
122
    template <Prelexer::prelexer mx>
123
    const char* peek(const char* start = 0)
124
1.57M
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
1.57M
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
1.57M
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
1.57M
      return match <= end ? match : 0;
135
136
1.57M
    }
char const* Sass::Parser::peek<&Sass::Prelexer::end_of_file>(char const*)
Line
Count
Source
124
22
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
22
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
22
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
22
      return match <= end ? match : 0;
135
136
22
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)125>(char const*))>(char const*)
Line
Count
Source
124
5.38k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
5.38k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
5.38k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
5.38k
      return match <= end ? match : 0;
135
136
5.38k
    }
Unexecuted instantiation: char const* Sass::Parser::peek<&Sass::Prelexer::uri_prefix>(char const*)
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)123>(char const*))>(char const*)
Line
Count
Source
124
6
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
6
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
6
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
6
      return match <= end ? match : 0;
135
136
6
    }
Unexecuted instantiation: char const* Sass::Parser::peek<&(char const* Sass::Prelexer::skip_over_scopes<&(char const* Sass::Prelexer::exactly<(char)40>(char const*)), &(char const* Sass::Prelexer::exactly<(char)41>(char const*))>(char const*))>(char const*)
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)59>(char const*)), &(char const* Sass::Prelexer::exactly<(char)125>(char const*)), &Sass::Prelexer::end_of_file>(char const*))>(char const*)
Line
Count
Source
124
6
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
6
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
6
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
6
      return match <= end ? match : 0;
135
136
6
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)41>(char const*))>(char const*)
Line
Count
Source
124
3.67k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3.67k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3.67k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3.67k
      return match <= end ? match : 0;
135
136
3.67k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)44>(char const*)), &(char const* Sass::Prelexer::exactly<(char)123>(char const*)), &(char const* Sass::Prelexer::exactly<(char)59>(char const*))>(char const*))>(char const*)
Line
Count
Source
124
2.42k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
2.42k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
2.42k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
2.42k
      return match <= end ? match : 0;
135
136
2.42k
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyIXadsoKcL_ZNS_9Constants11hash_lbraceEEEEEEPS5_S7_EEXadL_ZNS4_IXadsoS5_L_ZNS6_6rbraceEEEEEES7_S7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_S7_
Line
Count
Source
124
1.80k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
1.80k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
1.80k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
1.80k
      return match <= end ? match : 0;
135
136
1.80k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::variable, &Sass::Prelexer::optional_css_comments, &(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*))>(char const*)
Line
Count
Source
124
1.80k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
1.80k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
1.80k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
1.80k
      return match <= end ? match : 0;
135
136
1.80k
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_7exactlyILc59EEEPKcS6_EEXadL_ZNS2_11end_of_fileES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Line
Count
Source
124
3
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3
      return match <= end ? match : 0;
135
136
3
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_12default_flagEPKcEEXadL_ZNS2_11global_flagES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
124
3
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3
      return match <= end ? match : 0;
135
136
3
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_15optional_spacesEPKcEEXadL_ZNS2_7exactlyIXadsoS4_L_ZNS_9Constants6rbraceEEEEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
124
4.28k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
4.28k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
4.28k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
4.28k
      return match <= end ? match : 0;
135
136
4.28k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)40>(char const*))>(char const*)
Line
Count
Source
124
2
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
2
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
2
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
2
      return match <= end ? match : 0;
135
136
2
    }
char const* Sass::Parser::peek<&Sass::Prelexer::pseudo_not>(char const*)
Line
Count
Source
124
2
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
2
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
2
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
2
      return match <= end ? match : 0;
135
136
2
    }
char const* Sass::Parser::peek<&Sass::Prelexer::re_pseudo_selector>(char const*)
Line
Count
Source
124
2
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
2
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
2
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
2
      return match <= end ? match : 0;
135
136
2
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*)
Line
Count
Source
124
2
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
2
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
2
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
2
      return match <= end ? match : 0;
135
136
2
    }
char const* Sass::Parser::peek<&Sass::Prelexer::static_value>(char const*)
Line
Count
Source
124
1
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
1
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
1
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
1
      return match <= end ? match : 0;
135
136
1
    }
char const* Sass::Parser::peek<&Sass::Prelexer::list_terminator>(char const*)
Line
Count
Source
124
9.51k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
9.51k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
9.51k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
9.51k
      return match <= end ? match : 0;
135
136
9.51k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)44>(char const*))>(char const*)
Line
Count
Source
124
7.82k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
7.82k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
7.82k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
7.82k
      return match <= end ? match : 0;
135
136
7.82k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::space_list_terminator>(char const*)
Line
Count
Source
124
31.6k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
31.6k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
31.6k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
31.6k
      return match <= end ? match : 0;
135
136
31.6k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::optional_css_whitespace>(char const*)
Line
Count
Source
124
19.4k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
19.4k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
19.4k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
19.4k
      return match <= end ? match : 0;
135
136
19.4k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::kwd_eq, &Sass::Prelexer::kwd_neq, &Sass::Prelexer::kwd_gte, &Sass::Prelexer::kwd_gt, &Sass::Prelexer::kwd_lte, &Sass::Prelexer::kwd_lt>(char const*))>(char const*)
Line
Count
Source
124
34.8k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
34.8k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
34.8k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
34.8k
      return match <= end ? match : 0;
135
136
34.8k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::css_comments>(char const*)
Line
Count
Source
124
384k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
384k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
384k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
384k
      return match <= end ? match : 0;
135
136
384k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)43>(char const*))>(char const*)
Line
Count
Source
124
34.8k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
34.8k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
34.8k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
34.8k
      return match <= end ? match : 0;
135
136
34.8k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::no_spaces>(char const*)
Line
Count
Source
124
31.6k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
31.6k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
31.6k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
31.6k
      return match <= end ? match : 0;
135
136
31.6k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::negate<&Sass::Prelexer::unsigned_number>(char const*)), &(char const* Sass::Prelexer::exactly<(char)45>(char const*)), &(char const* Sass::Prelexer::negate<&Sass::Prelexer::space>(char const*))>(char const*))>(char const*)
Line
Count
Source
124
31.6k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
31.6k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
31.6k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
31.6k
      return match <= end ? match : 0;
135
136
31.6k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::negate<&Sass::Prelexer::unsigned_number>(char const*)), &(char const* Sass::Prelexer::exactly<(char)45>(char const*)), &(char const* Sass::Prelexer::negate<&Sass::Prelexer::unsigned_number>(char const*))>(char const*))>(char const*)
Line
Count
Source
124
31.6k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
31.6k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
31.6k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
31.6k
      return match <= end ? match : 0;
135
136
31.6k
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_9zero_plusIXadL_ZNS2_7exactlyILc45EEEPKcS7_EEEES7_S7_EEXadL_ZNS2_10identifierES7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_S7_
Line
Count
Source
124
6.32k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
6.32k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
6.32k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
6.32k
      return match <= end ? match : 0;
135
136
6.32k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::ie_property>(char const*)
Line
Count
Source
124
157k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
157k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
157k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
157k
      return match <= end ? match : 0;
135
136
157k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::ie_keyword_arg>(char const*)
Line
Count
Source
124
157k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
157k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
157k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
157k
      return match <= end ? match : 0;
135
136
157k
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_12calc_fn_callEPKcEEXadL_ZNS2_7exactlyILc40EEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
124
157k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
157k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
157k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
157k
      return match <= end ? match : 0;
135
136
157k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::uri_prefix, &Sass::Prelexer::W, &Sass::Prelexer::real_uri_value>(char const*))>(char const*)
Line
Count
Source
124
155k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
155k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
155k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
155k
      return match <= end ? match : 0;
135
136
155k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::re_functional>(char const*)
Line
Count
Source
124
165k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
165k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
165k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
165k
      return match <= end ? match : 0;
135
136
165k
    }
char const* Sass::Parser::peek<&Sass::Prelexer::value_schema>(char const*)
Line
Count
Source
124
125k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
125k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
125k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
125k
      return match <= end ? match : 0;
135
136
125k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)41>(char const*)), &(char const* Sass::Prelexer::exactly<(char)93>(char const*)), &(char const* Sass::Prelexer::exactly<(char)125>(char const*))>(char const*))>(char const*)
Line
Count
Source
124
6
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
6
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
6
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
6
      return match <= end ? match : 0;
135
136
6
    }
Unexecuted instantiation: char const* Sass::Parser::peek<&Sass::Prelexer::variable>(char const*)
Unexecuted instantiation: char const* Sass::Parser::peek<&Sass::Prelexer::ie_keyword_arg_value>(char const*)
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants6rbraceEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
124
3.15k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3.15k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3.15k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3.15k
      return match <= end ? match : 0;
135
136
3.15k
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::alpha>(char const*))>(char const*)
Line
Count
Source
124
4.70k
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
4.70k
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
4.70k
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
4.70k
      return match <= end ? match : 0;
135
136
4.70k
    }
Unexecuted instantiation: char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)45>(char const*))>(char const*)
Unexecuted instantiation: char const* Sass::Parser::peek<&Sass::Prelexer::parenthese_scope>(char const*)
Unexecuted instantiation: _ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants11hash_lbraceEEEEEEPS4_S6_EEEES6_S6_
Unexecuted instantiation: char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)36>(char const*))>(char const*)
Unexecuted instantiation: _ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_18kwd_with_directiveEPKcEEXadL_ZNS2_21kwd_without_directiveES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
char const* Sass::Parser::peek<&Sass::Prelexer::re_selector_list>(char const*)
Line
Count
Source
124
5
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
5
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
5
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
5
      return match <= end ? match : 0;
135
136
5
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyILc45EEEPKcS6_EEXadL_ZNS4_ILc45EEES6_S6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Line
Count
Source
124
5
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
5
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
5
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
5
      return match <= end ? match : 0;
135
136
5
    }
char const* Sass::Parser::peek<&Sass::Prelexer::space>(char const*)
Line
Count
Source
124
852
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
852
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
852
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
852
      return match <= end ? match : 0;
135
136
852
    }
Unexecuted instantiation: char const* Sass::Parser::peek<&(char const* Sass::Prelexer::exactly<(char)59>(char const*))>(char const*)
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer10non_greedyIXadL_ZNS2_12alternativesIXadL_ZNS2_13block_commentEPKcEEXadL_ZNS2_8sequenceIXadL_ZNS2_11interpolantES6_EEXadL_ZNS2_8optionalIXadL_ZNS2_13quoted_stringES6_EEEES6_S6_EETpTnPFS6_S6_EJEEES6_S6_EEJXadL_ZNS2_10identifierES6_EEXadL_ZNS2_8variableES6_EEXadL_ZNS7_IXadL_ZNS2_16parenthese_scopeES6_EEXadL_ZNS2_11interpolantES6_EEJXadL_ZNS8_IXadL_ZNS2_13quoted_stringES6_EEEES6_S6_EEEEES6_S6_EEEEES6_S6_EEXadL_ZNS2_8sequenceIXadL_ZNS4_IXadL_ZNS2_7exactlyILc123EEES6_S6_EEXadL_ZNSC_ILc125EEES6_S6_EEJXadL_ZNSC_ILc59EEES6_S6_EEEEES6_S6_EEEES6_S6_EEEES6_S6_EEEES6_S6_
Line
Count
Source
124
3
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3
      return match <= end ? match : 0;
135
136
3
    }
char const* Sass::Parser::peek<&Sass::Prelexer::optional_spaces>(char const*)
Line
Count
Source
124
3
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3
      return match <= end ? match : 0;
135
136
3
    }
char const* Sass::Parser::peek<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::end_of_file, &(char const* Sass::Prelexer::exactly<(char)123>(char const*)), &(char const* Sass::Prelexer::exactly<(char)44>(char const*))>(char const*))>(char const*)
Line
Count
Source
124
3
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3
      return match <= end ? match : 0;
135
136
3
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_10class_charIXadsoKcL_ZNS_9Constants20selector_list_delimsEEEEEEPS5_S7_EEEES7_S7_EEEES7_S7_
Line
Count
Source
124
3
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
3
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
3
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
3
      return match <= end ? match : 0;
135
136
3
    }
char const* Sass::Parser::peek<&Sass::Prelexer::spaces>(char const*)
Line
Count
Source
124
4
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
4
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
4
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
4
      return match <= end ? match : 0;
135
136
4
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants23selector_combinator_opsEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
124
4
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
4
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
4
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
4
      return match <= end ? match : 0;
135
136
4
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants23complex_selector_delimsEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
124
4
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
4
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
4
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
4
      return match <= end ? match : 0;
135
136
4
    }
_ZN4Sass6Parser4peekIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_11end_of_fileEPKcEEXadL_ZNS2_7exactlyILc123EEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
124
2
    {
125
126
      // sneak up to the actual token we want to lex
127
      // this should skip over white-space if desired
128
2
      const char* it_before_token = sneak < mx >(start);
129
130
      // match the given prelexer
131
2
      const char* match = mx(it_before_token);
132
133
      // check if match is in valid range
134
2
      return match <= end ? match : 0;
135
136
2
    }
137
138
    // white-space handling is built into the lexer
139
    // this way you do not need to parse it yourself
140
    // some matchers don't accept certain white-space
141
    // we do not support start arg, since we manipulate
142
    // sourcemap offset and we modify the position pointer!
143
    // lex will only skip over space, tabs and line comment
144
    template <Prelexer::prelexer mx>
145
    const char* lex(bool lazy = true, bool force = false)
146
3.82M
    {
147
148
3.82M
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.82M
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.82M
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.82M
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.82M
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.82M
      if (force == false) {
167
        // assertion that we got a valid match
168
3.82M
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
292k
        if (it_after_token == it_before_token) return 0;
171
292k
      }
172
173
      // create new lexed token object (holds the parse results)
174
292k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
292k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
292k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
292k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
292k
      return position = it_after_token;
187
188
3.82M
    }
char const* Sass::Parser::lex<&Sass::Prelexer::identifier>(bool, bool)
Line
Count
Source
146
130k
    {
147
148
130k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
130k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
130k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
130k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
130k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
130k
      if (force == false) {
167
        // assertion that we got a valid match
168
130k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
119k
        if (it_after_token == it_before_token) return 0;
171
119k
      }
172
173
      // create new lexed token object (holds the parse results)
174
119k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
119k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
119k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
119k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
119k
      return position = it_after_token;
187
188
130k
    }
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_10identifierEPKcEEXadL_ZNS2_7exactlyILc42EEES5_S5_EEJXadL_ZNS2_7exactlyIXadsoS4_L_ZNS_9Constants8warn_kwdEEEEEES5_S5_EEXadL_ZNS7_IXadsoS4_L_ZNS8_9error_kwdEEEEEES5_S5_EEXadL_ZNS7_IXadsoS4_L_ZNS8_9debug_kwdEEEEEES5_S5_EEEEES5_S5_EEEES5_bb
char const* Sass::Parser::lex<&Sass::Prelexer::css_comments>(bool, bool)
Line
Count
Source
146
989k
    {
147
148
989k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
989k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
989k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
989k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
989k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
989k
      if (force == false) {
167
        // assertion that we got a valid match
168
989k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
122
        if (it_after_token == it_before_token) return 0;
171
122
      }
172
173
      // create new lexed token object (holds the parse results)
174
122
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
122
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
122
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
122
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
122
      return position = it_after_token;
187
188
989k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)123>(char const*))>(bool, bool)
Line
Count
Source
146
1
    {
147
148
1
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1
      if (force == false) {
167
        // assertion that we got a valid match
168
1
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1
        if (it_after_token == it_before_token) return 0;
171
1
      }
172
173
      // create new lexed token object (holds the parse results)
174
1
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1
      return position = it_after_token;
187
188
1
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)125>(char const*))>(bool, bool)
Line
Count
Source
146
1
    {
147
148
1
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1
      if (force == false) {
167
        // assertion that we got a valid match
168
1
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1
        if (it_after_token == it_before_token) return 0;
171
1
      }
172
173
      // create new lexed token object (holds the parse results)
174
1
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1
      return position = it_after_token;
187
188
1
    }
char const* Sass::Parser::lex<&Sass::Prelexer::css_whitespace>(bool, bool)
Line
Count
Source
146
31
    {
147
148
31
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
31
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
31
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
31
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
31
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
31
      if (force == false) {
167
        // assertion that we got a valid match
168
31
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
3
        if (it_after_token == it_before_token) return 0;
171
3
      }
172
173
      // create new lexed token object (holds the parse results)
174
3
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
3
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
3
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
3
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
3
      return position = it_after_token;
187
188
31
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)59>(char const*))>(bool, bool)
Line
Count
Source
146
16
    {
147
148
16
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
16
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
16
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
16
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
16
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
16
      if (force == false) {
167
        // assertion that we got a valid match
168
16
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1
        if (it_after_token == it_before_token) return 0;
171
1
      }
172
173
      // create new lexed token object (holds the parse results)
174
1
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1
      return position = it_after_token;
187
188
16
    }
char const* Sass::Parser::lex<&Sass::Prelexer::variable>(bool, bool)
Line
Count
Source
146
3.63k
    {
147
148
3.63k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.63k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.63k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.63k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.63k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.63k
      if (force == false) {
167
        // assertion that we got a valid match
168
3.63k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1.54k
        if (it_after_token == it_before_token) return 0;
171
1.54k
      }
172
173
      // create new lexed token object (holds the parse results)
174
1.54k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1.54k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1.54k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1.54k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1.54k
      return position = it_after_token;
187
188
3.63k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_err>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_dbg>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_warn>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_if_directive>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_for_directive>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_each_directive>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_while_directive>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_return_directive>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_import>(bool, bool)
Line
Count
Source
146
11
    {
147
148
11
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
11
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
11
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
11
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
11
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
11
      if (force == false) {
167
        // assertion that we got a valid match
168
11
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
6
        if (it_after_token == it_before_token) return 0;
171
6
      }
172
173
      // create new lexed token object (holds the parse results)
174
6
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
6
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
6
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
6
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
6
      return position = it_after_token;
187
188
11
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_extend>(bool, bool)
Line
Count
Source
146
5
    {
147
148
5
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
5
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
5
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
5
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
5
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
5
      if (force == false) {
167
        // assertion that we got a valid match
168
5
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
5
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_media>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_at_root>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_include_directive>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_content_directive>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_supports_directive>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_mixin>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_function>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_charset_directive>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants8else_kwdEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::at_keyword>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::block_comment>(bool, bool)
Line
Count
Source
146
172
    {
147
148
172
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
172
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
172
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
172
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
172
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
172
      if (force == false) {
167
        // assertion that we got a valid match
168
172
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
172
    }
char const* Sass::Parser::lex<&Sass::Prelexer::quoted_string>(bool, bool)
Line
Count
Source
146
128k
    {
147
148
128k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
128k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
128k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
128k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
128k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
128k
      if (force == false) {
167
        // assertion that we got a valid match
168
128k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
8
        if (it_after_token == it_before_token) return 0;
171
8
      }
172
173
      // create new lexed token object (holds the parse results)
174
8
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
8
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
8
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
8
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
8
      return position = it_after_token;
187
188
128k
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::uri_prefix>(bool, bool)
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)41>(char const*))>(bool, bool)
Line
Count
Source
146
2.41k
    {
147
148
2.41k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2.41k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2.41k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2.41k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2.41k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2.41k
      if (force == false) {
167
        // assertion that we got a valid match
168
2.41k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2.41k
        if (it_after_token == it_before_token) return 0;
171
2.41k
      }
172
173
      // create new lexed token object (holds the parse results)
174
2.41k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2.41k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2.41k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2.41k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2.41k
      return position = it_after_token;
187
188
2.41k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_6spacesEPKcEEXadL_ZNS2_13block_commentES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
Line
Count
Source
146
1.25k
    {
147
148
1.25k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1.25k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1.25k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1.25k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1.25k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1.25k
      if (force == false) {
167
        // assertion that we got a valid match
168
1.25k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
1.25k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(bool, bool)
Line
Count
Source
146
1.80k
    {
147
148
1.80k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1.80k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1.80k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1.80k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1.80k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1.80k
      if (force == false) {
167
        // assertion that we got a valid match
168
1.80k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
123
        if (it_after_token == it_before_token) return 0;
171
123
      }
172
173
      // create new lexed token object (holds the parse results)
174
123
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
123
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
123
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
123
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
123
      return position = it_after_token;
187
188
1.80k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants8ellipsisEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
2.30k
    {
147
148
2.30k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2.30k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2.30k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2.30k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2.30k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2.30k
      if (force == false) {
167
        // assertion that we got a valid match
168
2.30k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
28
        if (it_after_token == it_before_token) return 0;
171
28
      }
172
173
      // create new lexed token object (holds the parse results)
174
28
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
28
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
28
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
28
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
28
      return position = it_after_token;
187
188
2.30k
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::default_flag>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::global_flag>(bool, bool)
char const* Sass::Parser::lex<&Sass::Prelexer::optional_css_whitespace>(bool, bool)
Line
Count
Source
146
3
    {
147
148
3
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3
      if (force == false) {
167
        // assertion that we got a valid match
168
0
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
3
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
3
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
3
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
3
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
3
      return position = it_after_token;
187
188
3
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::optional_spaces>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::quoted_string, &Sass::Prelexer::optional_spaces, &(char const* Sass::Prelexer::exactly<(char)59>(char const*))>(char const*))>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_using>(bool, bool)
char const* Sass::Parser::lex<&Sass::Prelexer::class_name>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&Sass::Prelexer::id_name>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::variable, &Sass::Prelexer::number, &Sass::Prelexer::static_reference_combinator>(char const*))>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)91>(char const*))>(bool, bool)
Line
Count
Source
146
157k
    {
147
148
157k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
157k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
157k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
157k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
157k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
157k
      if (force == false) {
167
        // assertion that we got a valid match
168
157k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
157k
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::placeholder>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::pseudo_not>(bool, bool)
char const* Sass::Parser::lex<&Sass::Prelexer::pseudo_prefix>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2
        if (it_after_token == it_before_token) return 0;
171
2
      }
172
173
      // create new lexed token object (holds the parse results)
174
2
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2
      return position = it_after_token;
187
188
2
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::identifier, &(char const* Sass::Prelexer::optional<&Sass::Prelexer::block_comment>(char const*)), &(char const* Sass::Prelexer::exactly<(char)40>(char const*))>(char const*))>(char const*))>(bool, bool)
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2
        if (it_after_token == it_before_token) return 0;
171
2
      }
172
173
      // create new lexed token object (holds the parse results)
174
2
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2
      return position = it_after_token;
187
188
2
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_8binomialEPKcEEXadL_ZNS2_13word_boundaryES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
Line
Count
Source
146
2
    {
147
148
2
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2
      if (force == false) {
167
        // assertion that we got a valid match
168
2
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
2
    }
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_14css_whitespaceEPKcEEXadL_ZNS2_11insensitiveIXadsoS4_L_ZNS_9Constants6of_kwdEEEEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_8optionalIXadL_ZNS2_13pseudo_prefixEPKcEEEES6_S6_EEXadL_ZNS2_10identifierES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_bb
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::attribute_name>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Parser::re_attr_sensitive_close>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Parser::re_attr_insensitive_close>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::exact_match, &Sass::Prelexer::class_match, &Sass::Prelexer::dash_match, &Sass::Prelexer::prefix_match, &Sass::Prelexer::suffix_match, &Sass::Prelexer::substring_match>(char const*))>(bool, bool)
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_8optionalIXadL_ZNS2_7exactlyILc42EEEPKcS7_EEEES7_S7_EEXadL_ZNS2_17identifier_schemaES7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_bb
Line
Count
Source
146
1
    {
147
148
1
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1
      if (force == false) {
167
        // assertion that we got a valid match
168
1
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
1
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::sequence<&(char const* Sass::Prelexer::optional<&(char const* Sass::Prelexer::exactly<(char)42>(char const*))>(char const*)), &Sass::Prelexer::identifier, &(char const* Sass::Prelexer::zero_plus<&Sass::Prelexer::block_comment>(char const*))>(char const*))>(bool, bool)
Line
Count
Source
146
1
    {
147
148
1
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1
      if (force == false) {
167
        // assertion that we got a valid match
168
1
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1
        if (it_after_token == it_before_token) return 0;
171
1
      }
172
173
      // create new lexed token object (holds the parse results)
174
1
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1
      return position = it_after_token;
187
188
1
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::one_plus<&(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*))>(bool, bool)
Line
Count
Source
146
1
    {
147
148
1
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1
      if (force == false) {
167
        // assertion that we got a valid match
168
1
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1
        if (it_after_token == it_before_token) return 0;
171
1
      }
172
173
      // create new lexed token object (holds the parse results)
174
1
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1
      return position = it_after_token;
187
188
1
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_eq>(bool, bool)
Line
Count
Source
146
7.15k
    {
147
148
7.15k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
7.15k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
7.15k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
7.15k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
7.15k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
7.15k
      if (force == false) {
167
        // assertion that we got a valid match
168
7.15k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1.80k
        if (it_after_token == it_before_token) return 0;
171
1.80k
      }
172
173
      // create new lexed token object (holds the parse results)
174
1.80k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1.80k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1.80k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1.80k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1.80k
      return position = it_after_token;
187
188
7.15k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_neq>(bool, bool)
Line
Count
Source
146
5.35k
    {
147
148
5.35k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
5.35k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
5.35k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
5.35k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
5.35k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
5.35k
      if (force == false) {
167
        // assertion that we got a valid match
168
5.35k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
5.35k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_gte>(bool, bool)
Line
Count
Source
146
5.35k
    {
147
148
5.35k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
5.35k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
5.35k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
5.35k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
5.35k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
5.35k
      if (force == false) {
167
        // assertion that we got a valid match
168
5.35k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
5.35k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_lte>(bool, bool)
Line
Count
Source
146
5.35k
    {
147
148
5.35k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
5.35k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
5.35k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
5.35k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
5.35k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
5.35k
      if (force == false) {
167
        // assertion that we got a valid match
168
5.35k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
5.35k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_gt>(bool, bool)
Line
Count
Source
146
5.35k
    {
147
148
5.35k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
5.35k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
5.35k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
5.35k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
5.35k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
5.35k
      if (force == false) {
167
        // assertion that we got a valid match
168
5.35k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
910
        if (it_after_token == it_before_token) return 0;
171
910
      }
172
173
      // create new lexed token object (holds the parse results)
174
910
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
910
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
910
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
910
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
910
      return position = it_after_token;
187
188
5.35k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_lt>(bool, bool)
Line
Count
Source
146
4.44k
    {
147
148
4.44k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
4.44k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
4.44k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
4.44k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
4.44k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
4.44k
      if (force == false) {
167
        // assertion that we got a valid match
168
4.44k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
4.44k
        if (it_after_token == it_before_token) return 0;
171
4.44k
      }
172
173
      // create new lexed token object (holds the parse results)
174
4.44k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
4.44k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
4.44k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
4.44k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
4.44k
      return position = it_after_token;
187
188
4.44k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_6negateIXadL_ZNS2_5digitEPKcEEEES6_S6_EEXadL_ZNS2_7exactlyILc45EEES6_S6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_bb
Line
Count
Source
146
3.16k
    {
147
148
3.16k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.16k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.16k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.16k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.16k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.16k
      if (force == false) {
167
        // assertion that we got a valid match
168
3.16k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
10
        if (it_after_token == it_before_token) return 0;
171
10
      }
172
173
      // create new lexed token object (holds the parse results)
174
10
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
10
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
10
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
10
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
10
      return position = it_after_token;
187
188
3.16k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants10static_opsEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
143k
    {
147
148
143k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
143k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
143k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
143k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
143k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
143k
      if (force == false) {
167
        // assertion that we got a valid match
168
143k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
105k
        if (it_after_token == it_before_token) return 0;
171
105k
      }
172
173
      // create new lexed token object (holds the parse results)
174
105k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
105k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
105k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
105k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
105k
      return position = it_after_token;
187
188
143k
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)93>(char const*))>(bool, bool)
char const* Sass::Parser::lex<&Sass::Prelexer::functional_schema>(bool, bool)
Line
Count
Source
146
157k
    {
147
148
157k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
157k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
157k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
157k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
157k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
157k
      if (force == false) {
167
        // assertion that we got a valid match
168
157k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
157k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::identifier_schema>(bool, bool)
Line
Count
Source
146
157k
    {
147
148
157k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
157k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
157k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
157k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
157k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
157k
      if (force == false) {
167
        // assertion that we got a valid match
168
157k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2.20k
        if (it_after_token == it_before_token) return 0;
171
2.20k
      }
172
173
      // create new lexed token object (holds the parse results)
174
2.20k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2.20k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2.20k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2.20k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2.20k
      return position = it_after_token;
187
188
157k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)40>(char const*))>(bool, bool)
Line
Count
Source
146
162k
    {
147
148
162k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
162k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
162k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
162k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
162k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
162k
      if (force == false) {
167
        // assertion that we got a valid match
168
162k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2.80k
        if (it_after_token == it_before_token) return 0;
171
2.80k
      }
172
173
      // create new lexed token object (holds the parse results)
174
2.80k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2.80k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2.80k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2.80k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2.80k
      return position = it_after_token;
187
188
162k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)43>(char const*))>(bool, bool)
Line
Count
Source
146
160k
    {
147
148
160k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
160k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
160k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
160k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
160k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
160k
      if (force == false) {
167
        // assertion that we got a valid match
168
160k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
4.05k
        if (it_after_token == it_before_token) return 0;
171
4.05k
      }
172
173
      // create new lexed token object (holds the parse results)
174
4.05k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
4.05k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
4.05k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
4.05k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
4.05k
      return position = it_after_token;
187
188
160k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)45>(char const*))>(bool, bool)
Line
Count
Source
146
153k
    {
147
148
153k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
153k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
153k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
153k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
153k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
153k
      if (force == false) {
167
        // assertion that we got a valid match
168
153k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
13.2k
        if (it_after_token == it_before_token) return 0;
171
13.2k
      }
172
173
      // create new lexed token object (holds the parse results)
174
13.2k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
13.2k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
13.2k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
13.2k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
13.2k
      return position = it_after_token;
187
188
153k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)47>(char const*))>(bool, bool)
Line
Count
Source
146
140k
    {
147
148
140k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
140k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
140k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
140k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
140k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
140k
      if (force == false) {
167
        // assertion that we got a valid match
168
140k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
904
        if (it_after_token == it_before_token) return 0;
171
904
      }
172
173
      // create new lexed token object (holds the parse results)
174
904
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
904
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
904
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
904
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
904
      return position = it_after_token;
187
188
140k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::kwd_not>(char const*))>(bool, bool)
Line
Count
Source
146
139k
    {
147
148
139k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
139k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
139k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
139k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
139k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
139k
      if (force == false) {
167
        // assertion that we got a valid match
168
139k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
139k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::ampersand>(bool, bool)
Line
Count
Source
146
139k
    {
147
148
139k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
139k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
139k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
139k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
139k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
139k
      if (force == false) {
167
        // assertion that we got a valid match
168
139k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
14.1k
        if (it_after_token == it_before_token) return 0;
171
14.1k
      }
172
173
      // create new lexed token object (holds the parse results)
174
14.1k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
14.1k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
14.1k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
14.1k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
14.1k
      return position = it_after_token;
187
188
139k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_important>(bool, bool)
Line
Count
Source
146
125k
    {
147
148
125k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
125k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
125k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
125k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
125k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
125k
      if (force == false) {
167
        // assertion that we got a valid match
168
125k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
125k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_10percentageEPKcEEXadL_ZNS2_9lookaheadIXadL_ZNS2_6numberES5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
Line
Count
Source
146
125k
    {
147
148
125k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
125k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
125k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
125k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
125k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
125k
      if (force == false) {
167
        // assertion that we got a valid match
168
125k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
125k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_6numberEPKcEEXadL_ZNS2_9lookaheadIXadL_ZNS3_IXadL_ZNS2_2opES5_EEXadL_ZNS2_6numberES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_EETpTnS8_JEEES5_S5_EEEES5_bb
Line
Count
Source
146
125k
    {
147
148
125k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
125k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
125k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
125k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
125k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
125k
      if (force == false) {
167
        // assertion that we got a valid match
168
125k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
125k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_13quoted_stringEPKcEEXadL_ZNS2_9lookaheadIXadL_ZNS2_7exactlyILc45EEES5_S5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
Line
Count
Source
146
125k
    {
147
148
125k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
125k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
125k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
125k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
125k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
125k
      if (force == false) {
167
        // assertion that we got a valid match
168
125k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
125k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_true>(bool, bool)
Line
Count
Source
146
121k
    {
147
148
121k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
121k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
121k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
121k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
121k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
121k
      if (force == false) {
167
        // assertion that we got a valid match
168
121k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
121k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_false>(bool, bool)
Line
Count
Source
146
121k
    {
147
148
121k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
121k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
121k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
121k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
121k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
121k
      if (force == false) {
167
        // assertion that we got a valid match
168
121k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
96
        if (it_after_token == it_before_token) return 0;
171
96
      }
172
173
      // create new lexed token object (holds the parse results)
174
96
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
96
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
96
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
96
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
96
      return position = it_after_token;
187
188
121k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_null>(bool, bool)
Line
Count
Source
146
121k
    {
147
148
121k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
121k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
121k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
121k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
121k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
121k
      if (force == false) {
167
        // assertion that we got a valid match
168
121k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
121k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::percentage>(bool, bool)
Line
Count
Source
146
10.5k
    {
147
148
10.5k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
10.5k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
10.5k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
10.5k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
10.5k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
10.5k
      if (force == false) {
167
        // assertion that we got a valid match
168
10.5k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
8
        if (it_after_token == it_before_token) return 0;
171
8
      }
172
173
      // create new lexed token object (holds the parse results)
174
8
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
8
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
8
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
8
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
8
      return position = it_after_token;
187
188
10.5k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_12alternativesIXadL_ZNS2_3hexEPKcEEXadL_ZNS2_4hex0ES6_EETpTnPFS6_S6_EJEEES6_S6_EEXadL_ZNS2_6negateIXadL_ZNS2_7exactlyILc45EEES6_S6_EEEES6_S6_EETpTnS8_JEEES6_S6_EEEES6_bb
Line
Count
Source
146
8.45k
    {
147
148
8.45k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
8.45k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
8.45k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
8.45k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
8.45k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
8.45k
      if (force == false) {
167
        // assertion that we got a valid match
168
8.45k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
8.45k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::hexa>(bool, bool)
Line
Count
Source
146
8.45k
    {
147
148
8.45k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
8.45k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
8.45k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
8.45k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
8.45k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
8.45k
      if (force == false) {
167
        // assertion that we got a valid match
168
8.45k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
8.45k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyILc35EEEPKcS6_EEXadL_ZNS2_10identifierES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_bb
Line
Count
Source
146
8.45k
    {
147
148
8.45k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
8.45k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
8.45k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
8.45k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
8.45k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
8.45k
      if (force == false) {
167
        // assertion that we got a valid match
168
8.45k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2
        if (it_after_token == it_before_token) return 0;
171
2
      }
172
173
      // create new lexed token object (holds the parse results)
174
2
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2
      return position = it_after_token;
187
188
8.45k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_9dimensionEPKcEEXadL_ZNS2_8optionalIXadL_ZNS3_IXadL_ZNS2_7exactlyILc45EEES5_S5_EEXadL_ZNS2_9lookaheadIXadL_ZNS2_12alternativesIXadL_ZNS2_5spaceES5_EEEES5_S5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_EETpTnSB_JEEES5_S5_EEEES5_bb
Line
Count
Source
146
8.44k
    {
147
148
8.44k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
8.44k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
8.44k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
8.44k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
8.44k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
8.44k
      if (force == false) {
167
        // assertion that we got a valid match
168
8.44k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
4.92k
        if (it_after_token == it_before_token) return 0;
171
4.92k
      }
172
173
      // create new lexed token object (holds the parse results)
174
4.92k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
4.92k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
4.92k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
4.92k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
4.92k
      return position = it_after_token;
187
188
8.44k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_16static_componentEPKcEEXadL_ZNS2_8one_plusIXadL_ZNS2_17strict_identifierES5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
Line
Count
Source
146
3.52k
    {
147
148
3.52k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.52k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.52k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.52k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.52k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.52k
      if (force == false) {
167
        // assertion that we got a valid match
168
3.52k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
3.52k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::number>(bool, bool)
Line
Count
Source
146
3.78k
    {
147
148
3.78k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.78k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.78k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.78k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.78k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.78k
      if (force == false) {
167
        // assertion that we got a valid match
168
3.78k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2.87k
        if (it_after_token == it_before_token) return 0;
171
2.87k
      }
172
173
      // create new lexed token object (holds the parse results)
174
2.87k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2.87k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2.87k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2.87k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2.87k
      return position = it_after_token;
187
188
3.78k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::css_variable_top_level_value>(bool, bool)
Line
Count
Source
146
24
    {
147
148
24
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
24
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
24
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
24
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
24
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
24
      if (force == false) {
167
        // assertion that we got a valid match
168
24
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
16
        if (it_after_token == it_before_token) return 0;
171
16
      }
172
173
      // create new lexed token object (holds the parse results)
174
16
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
16
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
16
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
16
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
16
      return position = it_after_token;
187
188
24
    }
char const* Sass::Parser::lex<&Sass::Prelexer::css_variable_value>(bool, bool)
Line
Count
Source
146
26
    {
147
148
26
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
26
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
26
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
26
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
26
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
26
      if (force == false) {
167
        // assertion that we got a valid match
168
26
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
20
        if (it_after_token == it_before_token) return 0;
171
20
      }
172
173
      // create new lexed token object (holds the parse results)
174
20
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
20
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
20
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
20
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
20
      return position = it_after_token;
187
188
26
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)40>(char const*)), &(char const* Sass::Prelexer::exactly<(char)91>(char const*)), &(char const* Sass::Prelexer::exactly<(char)123>(char const*))>(char const*))>(bool, bool)
Line
Count
Source
146
10
    {
147
148
10
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
10
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
10
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
10
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
10
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
10
      if (force == false) {
167
        // assertion that we got a valid match
168
10
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
4
        if (it_after_token == it_before_token) return 0;
171
4
      }
172
173
      // create new lexed token object (holds the parse results)
174
4
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
4
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
4
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
4
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
4
      return position = it_after_token;
187
188
10
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)41>(char const*)), &(char const* Sass::Prelexer::exactly<(char)93>(char const*)), &(char const* Sass::Prelexer::exactly<(char)125>(char const*))>(char const*))>(bool, bool)
Line
Count
Source
146
4
    {
147
148
4
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
4
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
4
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
4
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
4
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
4
      if (force == false) {
167
        // assertion that we got a valid match
168
4
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
4
        if (it_after_token == it_before_token) return 0;
171
4
      }
172
173
      // create new lexed token object (holds the parse results)
174
4
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
4
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
4
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
4
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
4
      return position = it_after_token;
187
188
4
    }
char const* Sass::Parser::lex<&Sass::Prelexer::static_value>(bool, bool)
Line
Count
Source
146
1
    {
147
148
1
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1
      if (force == false) {
167
        // assertion that we got a valid match
168
1
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1
        if (it_after_token == it_before_token) return 0;
171
1
      }
172
173
      // create new lexed token object (holds the parse results)
174
1
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1
      return position = it_after_token;
187
188
1
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::ie_property>(bool, bool)
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_17identifier_schemaEPKcEEXadL_ZNS2_10identifierES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
Unexecuted instantiation: char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)61>(char const*))>(bool, bool)
char const* Sass::Parser::lex<&Sass::Prelexer::spaces>(bool, bool)
Line
Count
Source
146
9.94k
    {
147
148
9.94k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
9.94k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
9.94k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
9.94k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
9.94k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
9.94k
      if (force == false) {
167
        // assertion that we got a valid match
168
9.94k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
9.94k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants11hash_lbraceEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
9.94k
    {
147
148
9.94k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
9.94k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
9.94k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
9.94k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
9.94k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
9.94k
      if (force == false) {
167
        // assertion that we got a valid match
168
9.94k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
3.15k
        if (it_after_token == it_before_token) return 0;
171
3.15k
      }
172
173
      // create new lexed token object (holds the parse results)
174
3.15k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
3.15k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
3.15k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
3.15k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
3.15k
      return position = it_after_token;
187
188
9.94k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::re_static_expression>(bool, bool)
Line
Count
Source
146
3.15k
    {
147
148
3.15k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.15k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.15k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.15k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.15k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.15k
      if (force == false) {
167
        // assertion that we got a valid match
168
3.15k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
3.15k
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants6rbraceEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
3.15k
    {
147
148
3.15k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.15k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.15k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.15k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.15k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.15k
      if (force == false) {
167
        // assertion that we got a valid match
168
3.15k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
3.15k
        if (it_after_token == it_before_token) return 0;
171
3.15k
      }
172
173
      // create new lexed token object (holds the parse results)
174
3.15k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
3.15k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
3.15k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
3.15k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
3.15k
      return position = it_after_token;
187
188
3.15k
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)37>(char const*)), &(char const* Sass::Prelexer::exactly<(char)45>(char const*)), &(char const* Sass::Prelexer::exactly<(char)43>(char const*))>(char const*))>(bool, bool)
Line
Count
Source
146
6.79k
    {
147
148
6.79k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
6.79k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
6.79k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
6.79k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
6.79k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
6.79k
      if (force == false) {
167
        // assertion that we got a valid match
168
6.79k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
6
        if (it_after_token == it_before_token) return 0;
171
6
      }
172
173
      // create new lexed token object (holds the parse results)
174
6
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
6
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
6
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
6
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
6
      return position = it_after_token;
187
188
6.79k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::dimension>(bool, bool)
Line
Count
Source
146
2.08k
    {
147
148
2.08k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
2.08k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
2.08k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
2.08k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
2.08k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
2.08k
      if (force == false) {
167
        // assertion that we got a valid match
168
2.08k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1.82k
        if (it_after_token == it_before_token) return 0;
171
1.82k
      }
172
173
      // create new lexed token object (holds the parse results)
174
1.82k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1.82k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1.82k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1.82k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1.82k
      return position = it_after_token;
187
188
2.08k
    }
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_3hexEPKcEEXadL_ZNS2_6negateIXadL_ZNS2_7exactlyILc45EEES5_S5_EEEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::skip_over_scopes<&(char const* Sass::Prelexer::exactly<(char)40>(char const*)), &(char const* Sass::Prelexer::exactly<(char)41>(char const*))>(char const*))>(bool, bool)
Line
Count
Source
146
390
    {
147
148
390
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
390
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
390
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
390
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
390
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
390
      if (force == false) {
167
        // assertion that we got a valid match
168
390
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
390
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::real_uri_suffix>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::real_uri_value>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::elseif_directive>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_else_directive>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_from>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_through>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_to>(bool, bool)
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyILc36EEEPKcS6_EEXadL_ZNS2_10identifierES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_bb
Unexecuted instantiation: char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)36>(char const*))>(bool, bool)
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)44>(char const*))>(bool, bool)
Line
Count
Source
146
3.47k
    {
147
148
3.47k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
3.46k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
3.46k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
3.46k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
3.46k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
3.46k
      if (force == false) {
167
        // assertion that we got a valid match
168
3.46k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1.71k
        if (it_after_token == it_before_token) return 0;
171
1.71k
      }
172
173
      // create new lexed token object (holds the parse results)
174
1.71k
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1.71k
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1.71k
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1.71k
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1.71k
      return position = it_after_token;
187
188
3.46k
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_in>(bool, bool)
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_and>(bool, bool)
Line
Count
Source
146
27.6k
    {
147
148
27.6k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
27.6k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
27.6k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
27.6k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
27.6k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
27.6k
      if (force == false) {
167
        // assertion that we got a valid match
168
27.6k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
27.6k
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_not>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::kwd_only>(bool, bool)
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_or>(bool, bool)
Line
Count
Source
146
27.6k
    {
147
148
27.6k
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
27.6k
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
27.6k
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
27.6k
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
27.6k
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
27.6k
      if (force == false) {
167
        // assertion that we got a valid match
168
27.6k
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
27.6k
    }
char const* Sass::Parser::lex<&Sass::Prelexer::interpolant>(bool, bool)
Line
Count
Source
146
14
    {
147
148
14
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
14
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
14
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
14
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
14
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
14
      if (force == false) {
167
        // assertion that we got a valid match
168
14
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
2
        if (it_after_token == it_before_token) return 0;
171
2
      }
172
173
      // create new lexed token object (holds the parse results)
174
2
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
2
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
2
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
2
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
2
      return position = it_after_token;
187
188
14
    }
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::re_string_uri_open>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::re_string_uri_close>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::re_string_double_open>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::re_string_double_close>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::re_string_single_open>(bool, bool)
Unexecuted instantiation: char const* Sass::Parser::lex<&Sass::Prelexer::re_string_single_close>(bool, bool)
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer8one_plusIXadL_ZNS2_12alternativesIXadL_ZNS2_7exactlyILc62EEEPKcS7_EEXadL_ZNS2_8sequenceIXadL_ZNS5_ILc92EEES7_S7_EEXadL_ZNS2_8any_charES7_EETpTnPFS7_S7_EJEEES7_S7_EEJXadL_ZNS8_IXadL_ZNS2_6negateIXadL_ZNS8_IXadL_ZNS2_7exactlyIXadsoS6_L_ZNS_9Constants7url_kwdEEEEEES7_S7_EEXadL_ZNS5_ILc40EEES7_S7_EETpTnSA_JEEES7_S7_EEEES7_S7_EEXadL_ZNS2_14neg_class_charIXadsoS6_L_ZNSD_22almost_any_value_classEEEEEES7_S7_EETpTnSA_JEEES7_S7_EEXadL_ZNS8_IXadL_ZNS5_ILc47EEES7_S7_EEXadL_ZNSB_IXadL_ZNS4_IXadL_ZNS5_ILc47EEES7_S7_EEXadL_ZNS5_ILc42EEES7_S7_EETpTnSA_JEEES7_S7_EEEES7_S7_EETpTnSA_JEEES7_S7_EEXadL_ZNS8_IXadL_ZNS5_ILc92EEES7_S7_EEXadL_ZNS5_ILc35EEES7_S7_EEJXadL_ZNSB_IXadL_ZNS5_ILc123EEES7_S7_EEEES7_S7_EEEEES7_S7_EEXadL_ZNS8_IXadL_ZNS5_ILc33EEES7_S7_EEXadL_ZNSB_IXadL_ZNS2_5alphaES7_EEEES7_S7_EETpTnSA_JEEES7_S7_EEEEES7_S7_EEEES7_S7_EEEES7_bb
Unexecuted instantiation: _ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_3hexEPKcEEXadL_ZNS2_4hex0ES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_bb
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants25selector_combinator_childEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
4
    {
147
148
4
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
4
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
4
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
4
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
4
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
4
      if (force == false) {
167
        // assertion that we got a valid match
168
4
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
4
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants27selector_combinator_generalEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
4
    {
147
148
4
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
4
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
4
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
4
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
4
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
4
      if (force == false) {
167
        // assertion that we got a valid match
168
4
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
4
    }
_ZN4Sass6Parser3lexIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants28selector_combinator_adjacentEEEEEEPS4_S6_EEEES6_bb
Line
Count
Source
146
4
    {
147
148
4
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
4
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
4
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
4
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
4
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
4
      if (force == false) {
167
        // assertion that we got a valid match
168
4
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
4
    }
char const* Sass::Parser::lex<&Sass::Prelexer::kwd_optional>(bool, bool)
Line
Count
Source
146
1
    {
147
148
1
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
1
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
1
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
1
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
1
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
1
      if (force == false) {
167
        // assertion that we got a valid match
168
1
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
1
    }
char const* Sass::Parser::lex<&(char const* Sass::Prelexer::exactly<(char)38>(char const*))>(bool, bool)
Line
Count
Source
146
9
    {
147
148
9
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
9
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
9
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
9
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
9
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
9
      if (force == false) {
167
        // assertion that we got a valid match
168
9
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
0
        if (it_after_token == it_before_token) return 0;
171
0
      }
172
173
      // create new lexed token object (holds the parse results)
174
0
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
0
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
0
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
0
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
0
      return position = it_after_token;
187
188
9
    }
char const* Sass::Parser::lex<&Sass::Prelexer::re_type_selector>(bool, bool)
Line
Count
Source
146
5
    {
147
148
5
      if (*position == 0) return 0;
149
150
      // position considered before lexed token
151
      // we can skip whitespace or comments for
152
      // lazy developers (but we need control)
153
5
      const char* it_before_token = position;
154
155
      // sneak up to the actual token we want to lex
156
      // this should skip over white-space if desired
157
5
      if (lazy) it_before_token = sneak < mx >(position);
158
159
      // now call matcher to get position after token
160
5
      const char* it_after_token = mx(it_before_token);
161
162
      // check if match is in valid range
163
5
      if (it_after_token > end) return 0;
164
165
      // maybe we want to update the parser state anyway?
166
5
      if (force == false) {
167
        // assertion that we got a valid match
168
5
        if (it_after_token == 0) return 0;
169
        // assertion that we actually lexed something
170
1
        if (it_after_token == it_before_token) return 0;
171
1
      }
172
173
      // create new lexed token object (holds the parse results)
174
1
      lexed = Token(position, it_before_token, it_after_token);
175
176
      // advance position (add whitespace before current token)
177
1
      before_token = after_token.add(position, it_before_token);
178
179
      // update after_token position for current token
180
1
      after_token.add(it_before_token, it_after_token);
181
182
      // ToDo: could probably do this incremental on original object (API wants offset?)
183
1
      pstate = SourceSpan(source, before_token, after_token - before_token);
184
185
      // advance internal char iterator
186
1
      return position = it_after_token;
187
188
5
    }
189
190
    // lex_css skips over space, tabs, line and block comment
191
    // all block comments will be consumed and thrown away
192
    // source-map position will point to token after the comment
193
    template <Prelexer::prelexer mx>
194
    const char* lex_css()
195
535k
    {
196
      // copy old token
197
535k
      Token prev = lexed;
198
      // store previous pointer
199
535k
      const char* oldpos = position;
200
535k
      Offset bt = before_token;
201
535k
      Offset at = after_token;
202
535k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
535k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
535k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
535k
      if (pos == 0) {
210
419k
        pstate = op;
211
419k
        lexed = prev;
212
419k
        position = oldpos;
213
419k
        after_token = at;
214
419k
        before_token = bt;
215
419k
      }
216
      // return match
217
535k
      return pos;
218
535k
    }
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)123>(char const*))>()
Line
Count
Source
195
1
    {
196
      // copy old token
197
1
      Token prev = lexed;
198
      // store previous pointer
199
1
      const char* oldpos = position;
200
1
      Offset bt = before_token;
201
1
      Offset at = after_token;
202
1
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
1
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
1
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
1
      if (pos == 0) {
210
0
        pstate = op;
211
0
        lexed = prev;
212
0
        position = oldpos;
213
0
        after_token = at;
214
0
        before_token = bt;
215
0
      }
216
      // return match
217
1
      return pos;
218
1
    }
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)125>(char const*))>()
Line
Count
Source
195
1
    {
196
      // copy old token
197
1
      Token prev = lexed;
198
      // store previous pointer
199
1
      const char* oldpos = position;
200
1
      Offset bt = before_token;
201
1
      Offset at = after_token;
202
1
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
1
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
1
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
1
      if (pos == 0) {
210
0
        pstate = op;
211
0
        lexed = prev;
212
0
        position = oldpos;
213
0
        after_token = at;
214
0
        before_token = bt;
215
0
      }
216
      // return match
217
1
      return pos;
218
1
    }
Unexecuted instantiation: char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)59>(char const*))>()
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)44>(char const*))>()
Line
Count
Source
195
3.47k
    {
196
      // copy old token
197
3.47k
      Token prev = lexed;
198
      // store previous pointer
199
3.47k
      const char* oldpos = position;
200
3.47k
      Offset bt = before_token;
201
3.47k
      Offset at = after_token;
202
3.47k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
3.47k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
3.47k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
3.47k
      if (pos == 0) {
210
1.76k
        pstate = op;
211
1.76k
        lexed = prev;
212
1.76k
        position = oldpos;
213
1.76k
        after_token = at;
214
1.76k
        before_token = bt;
215
1.76k
      }
216
      // return match
217
3.47k
      return pos;
218
3.47k
    }
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)40>(char const*))>()
Line
Count
Source
195
160k
    {
196
      // copy old token
197
160k
      Token prev = lexed;
198
      // store previous pointer
199
160k
      const char* oldpos = position;
200
160k
      Offset bt = before_token;
201
160k
      Offset at = after_token;
202
160k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
160k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
160k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
160k
      if (pos == 0) {
210
157k
        pstate = op;
211
157k
        lexed = prev;
212
157k
        position = oldpos;
213
157k
        after_token = at;
214
157k
        before_token = bt;
215
157k
      }
216
      // return match
217
160k
      return pos;
218
160k
    }
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)41>(char const*))>()
Line
Count
Source
195
2.41k
    {
196
      // copy old token
197
2.41k
      Token prev = lexed;
198
      // store previous pointer
199
2.41k
      const char* oldpos = position;
200
2.41k
      Offset bt = before_token;
201
2.41k
      Offset at = after_token;
202
2.41k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
2.41k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
2.41k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
2.41k
      if (pos == 0) {
210
2
        pstate = op;
211
2
        lexed = prev;
212
2
        position = oldpos;
213
2
        after_token = at;
214
2
        before_token = bt;
215
2
      }
216
      // return match
217
2.41k
      return pos;
218
2.41k
    }
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Prelexer::variable>()
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)58>(char const*))>()
Line
Count
Source
195
1.17k
    {
196
      // copy old token
197
1.17k
      Token prev = lexed;
198
      // store previous pointer
199
1.17k
      const char* oldpos = position;
200
1.17k
      Offset bt = before_token;
201
1.17k
      Offset at = after_token;
202
1.17k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
1.17k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
1.17k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
1.17k
      if (pos == 0) {
210
1.17k
        pstate = op;
211
1.17k
        lexed = prev;
212
1.17k
        position = oldpos;
213
1.17k
        after_token = at;
214
1.17k
        before_token = bt;
215
1.17k
      }
216
      // return match
217
1.17k
      return pos;
218
1.17k
    }
_ZN4Sass6Parser7lex_cssIXadL_ZNS_8Prelexer7exactlyIXadsoKcL_ZNS_9Constants8ellipsisEEEEEEPS4_S6_EEEES6_v
Line
Count
Source
195
1.80k
    {
196
      // copy old token
197
1.80k
      Token prev = lexed;
198
      // store previous pointer
199
1.80k
      const char* oldpos = position;
200
1.80k
      Offset bt = before_token;
201
1.80k
      Offset at = after_token;
202
1.80k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
1.80k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
1.80k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
1.80k
      if (pos == 0) {
210
1.80k
        pstate = op;
211
1.80k
        lexed = prev;
212
1.80k
        position = oldpos;
213
1.80k
        after_token = at;
214
1.80k
        before_token = bt;
215
1.80k
      }
216
      // return match
217
1.80k
      return pos;
218
1.80k
    }
_ZN4Sass6Parser7lex_cssIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_8binomialEPKcEEXadL_ZNS2_13word_boundaryES5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_v
Line
Count
Source
195
2
    {
196
      // copy old token
197
2
      Token prev = lexed;
198
      // store previous pointer
199
2
      const char* oldpos = position;
200
2
      Offset bt = before_token;
201
2
      Offset at = after_token;
202
2
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
2
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
2
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
2
      if (pos == 0) {
210
2
        pstate = op;
211
2
        lexed = prev;
212
2
        position = oldpos;
213
2
        after_token = at;
214
2
        before_token = bt;
215
2
      }
216
      // return match
217
2
      return pos;
218
2
    }
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Prelexer::attribute_name>()
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Parser::re_attr_sensitive_close>()
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Parser::re_attr_insensitive_close>()
Unexecuted instantiation: char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::exact_match, &Sass::Prelexer::class_match, &Sass::Prelexer::dash_match, &Sass::Prelexer::prefix_match, &Sass::Prelexer::suffix_match, &Sass::Prelexer::substring_match>(char const*))>()
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Prelexer::identifier>()
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Prelexer::quoted_string>()
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::one_plus<&(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*))>()
Line
Count
Source
195
1
    {
196
      // copy old token
197
1
      Token prev = lexed;
198
      // store previous pointer
199
1
      const char* oldpos = position;
200
1
      Offset bt = before_token;
201
1
      Offset at = after_token;
202
1
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
1
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
1
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
1
      if (pos == 0) {
210
0
        pstate = op;
211
0
        lexed = prev;
212
0
        position = oldpos;
213
0
        after_token = at;
214
0
        before_token = bt;
215
0
      }
216
      // return match
217
1
      return pos;
218
1
    }
char const* Sass::Parser::lex_css<&Sass::Prelexer::kwd_or>()
Line
Count
Source
195
27.6k
    {
196
      // copy old token
197
27.6k
      Token prev = lexed;
198
      // store previous pointer
199
27.6k
      const char* oldpos = position;
200
27.6k
      Offset bt = before_token;
201
27.6k
      Offset at = after_token;
202
27.6k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
27.6k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
27.6k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
27.6k
      if (pos == 0) {
210
27.6k
        pstate = op;
211
27.6k
        lexed = prev;
212
27.6k
        position = oldpos;
213
27.6k
        after_token = at;
214
27.6k
        before_token = bt;
215
27.6k
      }
216
      // return match
217
27.6k
      return pos;
218
27.6k
    }
char const* Sass::Parser::lex_css<&Sass::Prelexer::kwd_and>()
Line
Count
Source
195
27.6k
    {
196
      // copy old token
197
27.6k
      Token prev = lexed;
198
      // store previous pointer
199
27.6k
      const char* oldpos = position;
200
27.6k
      Offset bt = before_token;
201
27.6k
      Offset at = after_token;
202
27.6k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
27.6k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
27.6k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
27.6k
      if (pos == 0) {
210
27.6k
        pstate = op;
211
27.6k
        lexed = prev;
212
27.6k
        position = oldpos;
213
27.6k
        after_token = at;
214
27.6k
        before_token = bt;
215
27.6k
      }
216
      // return match
217
27.6k
      return pos;
218
27.6k
    }
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)43>(char const*))>()
Line
Count
Source
195
6.31k
    {
196
      // copy old token
197
6.31k
      Token prev = lexed;
198
      // store previous pointer
199
6.31k
      const char* oldpos = position;
200
6.31k
      Offset bt = before_token;
201
6.31k
      Offset at = after_token;
202
6.31k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
6.31k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
6.31k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
6.31k
      if (pos == 0) {
210
3.16k
        pstate = op;
211
3.16k
        lexed = prev;
212
3.16k
        position = oldpos;
213
3.16k
        after_token = at;
214
3.16k
        before_token = bt;
215
3.16k
      }
216
      // return match
217
6.31k
      return pos;
218
6.31k
    }
_ZN4Sass6Parser7lex_cssIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_6negateIXadL_ZNS2_5digitEPKcEEEES6_S6_EEXadL_ZNS2_7exactlyILc45EEES6_S6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_v
Line
Count
Source
195
3.16k
    {
196
      // copy old token
197
3.16k
      Token prev = lexed;
198
      // store previous pointer
199
3.16k
      const char* oldpos = position;
200
3.16k
      Offset bt = before_token;
201
3.16k
      Offset at = after_token;
202
3.16k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
3.16k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
3.16k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
3.16k
      if (pos == 0) {
210
3.15k
        pstate = op;
211
3.15k
        lexed = prev;
212
3.15k
        position = oldpos;
213
3.15k
        after_token = at;
214
3.15k
        before_token = bt;
215
3.15k
      }
216
      // return match
217
3.16k
      return pos;
218
3.16k
    }
_ZN4Sass6Parser7lex_cssIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants10static_opsEEEEEEPS4_S6_EEEES6_v
Line
Count
Source
195
143k
    {
196
      // copy old token
197
143k
      Token prev = lexed;
198
      // store previous pointer
199
143k
      const char* oldpos = position;
200
143k
      Offset bt = before_token;
201
143k
      Offset at = after_token;
202
143k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
143k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
143k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
143k
      if (pos == 0) {
210
37.9k
        pstate = op;
211
37.9k
        lexed = prev;
212
37.9k
        position = oldpos;
213
37.9k
        after_token = at;
214
37.9k
        before_token = bt;
215
37.9k
      }
216
      // return match
217
143k
      return pos;
218
143k
    }
char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)91>(char const*))>()
Line
Count
Source
195
157k
    {
196
      // copy old token
197
157k
      Token prev = lexed;
198
      // store previous pointer
199
157k
      const char* oldpos = position;
200
157k
      Offset bt = before_token;
201
157k
      Offset at = after_token;
202
157k
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
157k
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
157k
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
157k
      if (pos == 0) {
210
157k
        pstate = op;
211
157k
        lexed = prev;
212
157k
        position = oldpos;
213
157k
        after_token = at;
214
157k
        before_token = bt;
215
157k
      }
216
      // return match
217
157k
      return pos;
218
157k
    }
Unexecuted instantiation: char const* Sass::Parser::lex_css<&(char const* Sass::Prelexer::exactly<(char)93>(char const*))>()
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Prelexer::elseif_directive>()
Unexecuted instantiation: char const* Sass::Parser::lex_css<&Sass::Prelexer::kwd_else_directive>()
char const* Sass::Parser::lex_css<&Sass::Prelexer::kwd_optional>()
Line
Count
Source
195
1
    {
196
      // copy old token
197
1
      Token prev = lexed;
198
      // store previous pointer
199
1
      const char* oldpos = position;
200
1
      Offset bt = before_token;
201
1
      Offset at = after_token;
202
1
      SourceSpan op = pstate;
203
      // throw away comments
204
      // update srcmap position
205
1
      lex < Prelexer::css_comments >();
206
      // now lex a new token
207
1
      const char* pos = lex< mx >();
208
      // maybe restore prev state
209
1
      if (pos == 0) {
210
1
        pstate = op;
211
1
        lexed = prev;
212
1
        position = oldpos;
213
1
        after_token = at;
214
1
        before_token = bt;
215
1
      }
216
      // return match
217
1
      return pos;
218
1
    }
219
220
    // all block comments will be skipped and thrown away
221
    template <Prelexer::prelexer mx>
222
    const char* peek_css(const char* start = 0)
223
111k
    {
224
      // now peek a token (skip comments first)
225
111k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
111k
    }
Unexecuted instantiation: char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::exactly<(char)123>(char const*))>(char const*)
Unexecuted instantiation: char const* Sass::Parser::peek_css<&Sass::Prelexer::end_of_file>(char const*)
Unexecuted instantiation: char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::exactly<(char)125>(char const*))>(char const*)
Unexecuted instantiation: char const* Sass::Parser::peek_css<&Sass::Prelexer::uri_prefix>(char const*)
char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::alternatives<&(char const* Sass::Prelexer::exactly<(char)59>(char const*)), &(char const* Sass::Prelexer::exactly<(char)125>(char const*)), &Sass::Prelexer::end_of_file>(char const*))>(char const*)
Line
Count
Source
223
6
    {
224
      // now peek a token (skip comments first)
225
6
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
6
    }
char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::exactly<(char)41>(char const*))>(char const*)
Line
Count
Source
223
1.24k
    {
224
      // now peek a token (skip comments first)
225
1.24k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
1.24k
    }
_ZN4Sass6Parser8peek_cssIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_7exactlyIXadsoKcL_ZNS_9Constants11hash_lbraceEEEEEEPS5_S7_EEXadL_ZNS4_IXadsoS5_L_ZNS6_6rbraceEEEEEES7_S7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_S7_
Line
Count
Source
223
1.80k
    {
224
      // now peek a token (skip comments first)
225
1.80k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
1.80k
    }
char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::sequence<&Sass::Prelexer::variable, &Sass::Prelexer::optional_css_comments, &(char const* Sass::Prelexer::exactly<(char)58>(char const*))>(char const*))>(char const*)
Line
Count
Source
223
1.80k
    {
224
      // now peek a token (skip comments first)
225
1.80k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
1.80k
    }
_ZN4Sass6Parser8peek_cssIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_7exactlyILc59EEEPKcS6_EEXadL_ZNS2_11end_of_fileES6_EETpTnPFS6_S6_EJEEES6_S6_EEEES6_S6_
Line
Count
Source
223
3
    {
224
      // now peek a token (skip comments first)
225
3
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
3
    }
char const* Sass::Parser::peek_css<&Sass::Prelexer::static_value>(char const*)
Line
Count
Source
223
1
    {
224
      // now peek a token (skip comments first)
225
1
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
1
    }
char const* Sass::Parser::peek_css<&Sass::Prelexer::list_terminator>(char const*)
Line
Count
Source
223
9.51k
    {
224
      // now peek a token (skip comments first)
225
9.51k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
9.51k
    }
Unexecuted instantiation: char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::exactly<(char)40>(char const*))>(char const*)
char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::exactly<(char)44>(char const*))>(char const*)
Line
Count
Source
223
7.82k
    {
224
      // now peek a token (skip comments first)
225
7.82k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
7.82k
    }
char const* Sass::Parser::peek_css<&Sass::Prelexer::space_list_terminator>(char const*)
Line
Count
Source
223
31.6k
    {
224
      // now peek a token (skip comments first)
225
31.6k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
31.6k
    }
char const* Sass::Parser::peek_css<&Sass::Prelexer::optional_css_whitespace>(char const*)
Line
Count
Source
223
19.4k
    {
224
      // now peek a token (skip comments first)
225
19.4k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
19.4k
    }
char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::exactly<(char)43>(char const*))>(char const*)
Line
Count
Source
223
34.8k
    {
224
      // now peek a token (skip comments first)
225
34.8k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
34.8k
    }
_ZN4Sass6Parser8peek_cssIXadL_ZNS_8Prelexer8sequenceIXadL_ZNS2_9zero_plusIXadL_ZNS2_7exactlyILc45EEEPKcS7_EEEES7_S7_EEXadL_ZNS2_10identifierES7_EETpTnPFS7_S7_EJEEES7_S7_EEEES7_S7_
Line
Count
Source
223
3.16k
    {
224
      // now peek a token (skip comments first)
225
3.16k
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
3.16k
    }
char const* Sass::Parser::peek_css<&(char const* Sass::Prelexer::alternatives<&Sass::Prelexer::end_of_file, &(char const* Sass::Prelexer::exactly<(char)123>(char const*)), &(char const* Sass::Prelexer::exactly<(char)44>(char const*))>(char const*))>(char const*)
Line
Count
Source
223
3
    {
224
      // now peek a token (skip comments first)
225
3
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
3
    }
_ZN4Sass6Parser8peek_cssIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_10class_charIXadsoKcL_ZNS_9Constants20selector_list_delimsEEEEEEPS5_S7_EEEES7_S7_EEEES7_S7_
Line
Count
Source
223
3
    {
224
      // now peek a token (skip comments first)
225
3
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
3
    }
_ZN4Sass6Parser8peek_cssIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants23selector_combinator_opsEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
223
4
    {
224
      // now peek a token (skip comments first)
225
4
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
4
    }
_ZN4Sass6Parser8peek_cssIXadL_ZNS_8Prelexer10class_charIXadsoKcL_ZNS_9Constants23complex_selector_delimsEEEEEEPS4_S6_EEEES6_S6_
Line
Count
Source
223
4
    {
224
      // now peek a token (skip comments first)
225
4
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
4
    }
_ZN4Sass6Parser8peek_cssIXadL_ZNS_8Prelexer12alternativesIXadL_ZNS2_11end_of_fileEPKcEEXadL_ZNS2_7exactlyILc123EEES5_S5_EETpTnPFS5_S5_EJEEES5_S5_EEEES5_S5_
Line
Count
Source
223
2
    {
224
      // now peek a token (skip comments first)
225
2
      return peek< mx >(peek < Prelexer::css_comments >(start));
226
2
    }
227
228
#ifdef __clang__
229
230
#pragma clang diagnostic pop
231
232
#endif
233
234
    void error(sass::string msg);
235
    // generate message with given and expected sample
236
    // text before and in the middle are configurable
237
    void css_error(const sass::string& msg,
238
                   const sass::string& prefix = " after ",
239
                   const sass::string& middle = ", was: ",
240
                   const bool trim = true);
241
    void read_bom();
242
243
    Block_Obj parse();
244
    Import_Obj parse_import();
245
    Definition_Obj parse_definition(Definition::Type which_type);
246
    Parameters_Obj parse_parameters();
247
    Parameter_Obj parse_parameter();
248
    Mixin_Call_Obj parse_include_directive();
249
    Arguments_Obj parse_arguments();
250
    Argument_Obj parse_argument();
251
    Assignment_Obj parse_assignment();
252
    StyleRuleObj parse_ruleset(Lookahead lookahead);
253
    SelectorListObj parseSelectorList(bool chroot);
254
    ComplexSelectorObj parseComplexSelector(bool chroot);
255
    Selector_Schema_Obj parse_selector_schema(const char* end_of_selector, bool chroot);
256
    CompoundSelectorObj parseCompoundSelector();
257
    SimpleSelectorObj parse_simple_selector();
258
    PseudoSelectorObj parse_negated_selector2();
259
    Expression* parse_binominal();
260
    SimpleSelectorObj parse_pseudo_selector();
261
    AttributeSelectorObj parse_attribute_selector();
262
    Block_Obj parse_block(bool is_root = false);
263
    Block_Obj parse_css_block(bool is_root = false);
264
    bool parse_block_nodes(bool is_root = false);
265
    bool parse_block_node(bool is_root = false);
266
267
    Declaration_Obj parse_declaration();
268
    ExpressionObj parse_map();
269
    ExpressionObj parse_bracket_list();
270
    ExpressionObj parse_list(bool delayed = false);
271
    ExpressionObj parse_comma_list(bool delayed = false);
272
    ExpressionObj parse_space_list();
273
    ExpressionObj parse_disjunction();
274
    ExpressionObj parse_conjunction();
275
    ExpressionObj parse_relation();
276
    ExpressionObj parse_expression();
277
    ExpressionObj parse_operators();
278
    ExpressionObj parse_factor();
279
    ExpressionObj parse_value();
280
    Function_Call_Obj parse_calc_function();
281
    Function_Call_Obj parse_function_call();
282
    Function_Call_Obj parse_function_call_schema();
283
    String_Obj parse_url_function_string();
284
    String_Obj parse_url_function_argument();
285
    String_Obj parse_interpolated_chunk(Token, bool constant = false, bool css = true);
286
    String_Obj parse_string();
287
    ValueObj parse_static_value();
288
    String_Schema_Obj parse_css_variable_value();
289
    String_Obj parse_ie_property();
290
    String_Obj parse_ie_keyword_arg();
291
    String_Schema_Obj parse_value_schema(const char* stop);
292
    String_Obj parse_identifier_schema();
293
    If_Obj parse_if_directive(bool else_if = false);
294
    ForRuleObj parse_for_directive();
295
    EachRuleObj parse_each_directive();
296
    WhileRuleObj parse_while_directive();
297
    MediaRule_Obj parseMediaRule();
298
    sass::vector<CssMediaQuery_Obj> parseCssMediaQueries();
299
    sass::string parseIdentifier();
300
    CssMediaQuery_Obj parseCssMediaQuery();
301
    Return_Obj parse_return_directive();
302
    Content_Obj parse_content_directive();
303
    void parse_charset_directive();
304
    List_Obj parse_media_queries();
305
    Media_Query_Obj parse_media_query();
306
    Media_Query_ExpressionObj parse_media_expression();
307
    SupportsRuleObj parse_supports_directive();
308
    SupportsConditionObj parse_supports_condition(bool top_level);
309
    SupportsConditionObj parse_supports_negation();
310
    SupportsConditionObj parse_supports_operator(bool top_level);
311
    SupportsConditionObj parse_supports_interpolation();
312
    SupportsConditionObj parse_supports_declaration();
313
    SupportsConditionObj parse_supports_condition_in_parens(bool parens_required);
314
    AtRootRuleObj parse_at_root_block();
315
    At_Root_Query_Obj parse_at_root_query();
316
    String_Schema_Obj parse_almost_any_value();
317
    AtRuleObj parse_directive();
318
    WarningRuleObj parse_warning();
319
    ErrorRuleObj parse_error();
320
    DebugRuleObj parse_debug();
321
322
    Value* color_or_string(const sass::string& lexed) const;
323
324
    // be more like ruby sass
325
    ExpressionObj lex_almost_any_value_token();
326
    ExpressionObj lex_almost_any_value_chars();
327
    ExpressionObj lex_interp_string();
328
    ExpressionObj lex_interp_uri();
329
    ExpressionObj lex_interpolation();
330
331
    // these will throw errors
332
    Token lex_variable();
333
    Token lex_identifier();
334
335
    void parse_block_comments(bool store = true);
336
337
    Lookahead lookahead_for_value(const char* start = 0);
338
    Lookahead lookahead_for_selector(const char* start = 0);
339
    Lookahead lookahead_for_include(const char* start = 0);
340
341
    ExpressionObj fold_operands(ExpressionObj base, sass::vector<ExpressionObj>& operands, Operand op);
342
    ExpressionObj fold_operands(ExpressionObj base, sass::vector<ExpressionObj>& operands, sass::vector<Operand>& ops, size_t i = 0);
343
344
    void throw_syntax_error(sass::string message, size_t ln = 0);
345
    void throw_read_error(sass::string message, size_t ln = 0);
346
347
348
    template <Prelexer::prelexer open, Prelexer::prelexer close>
349
    ExpressionObj lex_interp()
350
0
    {
351
0
      if (lex < open >(false)) {
352
0
        String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);
353
        // std::cerr << "LEX [[" << sass::string(lexed) << "]]\n";
354
0
        schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
355
0
        if (position[0] == '#' && position[1] == '{') {
356
0
          ExpressionObj itpl = lex_interpolation();
357
0
          if (!itpl.isNull()) schema->append(itpl);
358
0
          while (lex < close >(false)) {
359
            // std::cerr << "LEX [[" << sass::string(lexed) << "]]\n";
360
0
            schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
361
0
            if (position[0] == '#' && position[1] == '{') {
362
0
              ExpressionObj itpl = lex_interpolation();
363
0
              if (!itpl.isNull()) schema->append(itpl);
364
0
            } else {
365
0
              return schema;
366
0
            }
367
0
          }
368
0
        } else {
369
0
          return SASS_MEMORY_NEW(String_Constant, pstate, lexed);
370
0
        }
371
0
      }
372
0
      return {};
373
0
    }
Unexecuted instantiation: Sass::SharedImpl<Sass::Expression> Sass::Parser::lex_interp<&Sass::Prelexer::re_string_uri_open, &Sass::Prelexer::re_string_uri_close>()
Unexecuted instantiation: Sass::SharedImpl<Sass::Expression> Sass::Parser::lex_interp<&Sass::Prelexer::re_string_double_open, &Sass::Prelexer::re_string_double_close>()
Unexecuted instantiation: Sass::SharedImpl<Sass::Expression> Sass::Parser::lex_interp<&Sass::Prelexer::re_string_single_open, &Sass::Prelexer::re_string_single_close>()
374
375
  public:
376
    static Number* lexed_number(const SourceSpan& pstate, const sass::string& parsed);
377
    static Number* lexed_dimension(const SourceSpan& pstate, const sass::string& parsed);
378
    static Number* lexed_percentage(const SourceSpan& pstate, const sass::string& parsed);
379
    static Value* lexed_hex_color(const SourceSpan& pstate, const sass::string& parsed);
380
  private:
381
2.87k
    Number* lexed_number(const sass::string& parsed) { return lexed_number(pstate, parsed); };
382
6.74k
    Number* lexed_dimension(const sass::string& parsed) { return lexed_dimension(pstate, parsed); };
383
8
    Number* lexed_percentage(const sass::string& parsed) { return lexed_percentage(pstate, parsed); };
384
0
    Value* lexed_hex_color(const sass::string& parsed) { return lexed_hex_color(pstate, parsed); };
385
386
    static const char* re_attr_sensitive_close(const char* src);
387
    static const char* re_attr_insensitive_close(const char* src);
388
389
  };
390
391
  size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);
392
}
393
394
#endif