sassc 2.3.0 → 2.4.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (116) hide show
  1. checksums.yaml +4 -4
  2. data/.travis.yml +1 -0
  3. data/CHANGELOG.md +5 -0
  4. data/ext/libsass/VERSION +1 -1
  5. data/ext/libsass/include/sass/context.h +3 -0
  6. data/ext/libsass/src/MurmurHash2.hpp +91 -0
  7. data/ext/libsass/src/ast.cpp +117 -117
  8. data/ext/libsass/src/ast.hpp +160 -162
  9. data/ext/libsass/src/ast_def_macros.hpp +10 -10
  10. data/ext/libsass/src/ast_fwd_decl.cpp +2 -2
  11. data/ext/libsass/src/ast_fwd_decl.hpp +61 -52
  12. data/ext/libsass/src/ast_helpers.hpp +5 -5
  13. data/ext/libsass/src/ast_sel_cmp.cpp +18 -18
  14. data/ext/libsass/src/ast_sel_super.cpp +52 -52
  15. data/ext/libsass/src/ast_sel_unify.cpp +16 -16
  16. data/ext/libsass/src/ast_sel_weave.cpp +62 -62
  17. data/ext/libsass/src/ast_selectors.cpp +87 -77
  18. data/ext/libsass/src/ast_selectors.hpp +72 -62
  19. data/ext/libsass/src/ast_supports.cpp +35 -35
  20. data/ext/libsass/src/ast_supports.hpp +29 -29
  21. data/ext/libsass/src/ast_values.cpp +58 -58
  22. data/ext/libsass/src/ast_values.hpp +75 -75
  23. data/ext/libsass/src/backtrace.cpp +9 -9
  24. data/ext/libsass/src/backtrace.hpp +5 -5
  25. data/ext/libsass/src/base64vlq.cpp +2 -2
  26. data/ext/libsass/src/base64vlq.hpp +1 -1
  27. data/ext/libsass/src/bind.cpp +17 -17
  28. data/ext/libsass/src/bind.hpp +1 -1
  29. data/ext/libsass/src/c2ast.cpp +3 -3
  30. data/ext/libsass/src/c2ast.hpp +1 -1
  31. data/ext/libsass/src/check_nesting.cpp +36 -36
  32. data/ext/libsass/src/check_nesting.hpp +2 -2
  33. data/ext/libsass/src/color_maps.cpp +5 -5
  34. data/ext/libsass/src/color_maps.hpp +1 -1
  35. data/ext/libsass/src/context.cpp +63 -60
  36. data/ext/libsass/src/context.hpp +33 -33
  37. data/ext/libsass/src/cssize.cpp +30 -29
  38. data/ext/libsass/src/cssize.hpp +13 -13
  39. data/ext/libsass/src/dart_helpers.hpp +5 -5
  40. data/ext/libsass/src/debugger.hpp +127 -128
  41. data/ext/libsass/src/emitter.cpp +12 -12
  42. data/ext/libsass/src/emitter.hpp +10 -10
  43. data/ext/libsass/src/environment.cpp +27 -27
  44. data/ext/libsass/src/environment.hpp +24 -24
  45. data/ext/libsass/src/error_handling.cpp +42 -42
  46. data/ext/libsass/src/error_handling.hpp +38 -50
  47. data/ext/libsass/src/eval.cpp +138 -132
  48. data/ext/libsass/src/eval.hpp +17 -17
  49. data/ext/libsass/src/eval_selectors.cpp +3 -3
  50. data/ext/libsass/src/expand.cpp +70 -64
  51. data/ext/libsass/src/expand.hpp +12 -12
  52. data/ext/libsass/src/extender.cpp +55 -53
  53. data/ext/libsass/src/extender.hpp +14 -14
  54. data/ext/libsass/src/file.cpp +66 -58
  55. data/ext/libsass/src/file.hpp +23 -25
  56. data/ext/libsass/src/fn_colors.cpp +9 -9
  57. data/ext/libsass/src/fn_lists.cpp +18 -18
  58. data/ext/libsass/src/fn_maps.cpp +3 -3
  59. data/ext/libsass/src/fn_miscs.cpp +15 -15
  60. data/ext/libsass/src/fn_numbers.cpp +7 -7
  61. data/ext/libsass/src/fn_selectors.cpp +8 -8
  62. data/ext/libsass/src/fn_strings.cpp +34 -22
  63. data/ext/libsass/src/fn_utils.cpp +29 -26
  64. data/ext/libsass/src/fn_utils.hpp +10 -10
  65. data/ext/libsass/src/inspect.cpp +35 -34
  66. data/ext/libsass/src/inspect.hpp +21 -21
  67. data/ext/libsass/src/lexer.cpp +3 -1
  68. data/ext/libsass/src/listize.cpp +2 -2
  69. data/ext/libsass/src/mapping.hpp +1 -0
  70. data/ext/libsass/src/memory.hpp +12 -0
  71. data/ext/libsass/src/memory/allocator.cpp +48 -0
  72. data/ext/libsass/src/memory/allocator.hpp +138 -0
  73. data/ext/libsass/src/memory/config.hpp +20 -0
  74. data/ext/libsass/src/memory/memory_pool.hpp +186 -0
  75. data/ext/libsass/src/memory/{SharedPtr.cpp → shared_ptr.cpp} +2 -2
  76. data/ext/libsass/src/memory/{SharedPtr.hpp → shared_ptr.hpp} +18 -6
  77. data/ext/libsass/src/operation.hpp +44 -44
  78. data/ext/libsass/src/operators.cpp +18 -18
  79. data/ext/libsass/src/operators.hpp +11 -11
  80. data/ext/libsass/src/ordered_map.hpp +18 -18
  81. data/ext/libsass/src/output.cpp +16 -16
  82. data/ext/libsass/src/output.hpp +5 -5
  83. data/ext/libsass/src/parser.cpp +327 -345
  84. data/ext/libsass/src/parser.hpp +77 -87
  85. data/ext/libsass/src/parser_selectors.cpp +6 -6
  86. data/ext/libsass/src/permutate.hpp +39 -15
  87. data/ext/libsass/src/plugins.cpp +7 -7
  88. data/ext/libsass/src/plugins.hpp +8 -8
  89. data/ext/libsass/src/position.cpp +7 -26
  90. data/ext/libsass/src/position.hpp +44 -21
  91. data/ext/libsass/src/remove_placeholders.cpp +4 -4
  92. data/ext/libsass/src/remove_placeholders.hpp +3 -3
  93. data/ext/libsass/src/sass.cpp +16 -15
  94. data/ext/libsass/src/sass.hpp +9 -5
  95. data/ext/libsass/src/sass_context.cpp +52 -34
  96. data/ext/libsass/src/sass_values.cpp +8 -10
  97. data/ext/libsass/src/settings.hpp +19 -0
  98. data/ext/libsass/src/source.cpp +69 -0
  99. data/ext/libsass/src/source.hpp +95 -0
  100. data/ext/libsass/src/source_data.hpp +32 -0
  101. data/ext/libsass/src/source_map.cpp +22 -18
  102. data/ext/libsass/src/source_map.hpp +12 -9
  103. data/ext/libsass/src/units.cpp +19 -19
  104. data/ext/libsass/src/units.hpp +8 -8
  105. data/ext/libsass/src/utf8_string.cpp +9 -10
  106. data/ext/libsass/src/utf8_string.hpp +7 -6
  107. data/ext/libsass/src/util.cpp +38 -38
  108. data/ext/libsass/src/util.hpp +18 -18
  109. data/ext/libsass/src/util_string.cpp +13 -13
  110. data/ext/libsass/src/util_string.hpp +9 -8
  111. data/ext/libsass/src/values.cpp +12 -12
  112. data/lib/sassc/native.rb +3 -5
  113. data/lib/sassc/version.rb +1 -1
  114. data/test/native_test.rb +4 -4
  115. metadata +14 -5
  116. data/lib/sassc/native/lib_c.rb +0 -21
@@ -70,18 +70,18 @@ private:
70
70
  #ifdef DEBUG_SHARED_PTR
71
71
 
72
72
  #define ATTACH_ABSTRACT_AST_OPERATIONS(klass) \
73
- virtual klass* copy(std::string, size_t) const = 0; \
74
- virtual klass* clone(std::string, size_t) const = 0; \
73
+ virtual klass* copy(sass::string, size_t) const = 0; \
74
+ virtual klass* clone(sass::string, size_t) const = 0; \
75
75
 
76
76
  #define ATTACH_VIRTUAL_AST_OPERATIONS(klass) \
77
77
  klass(const klass* ptr); \
78
- virtual klass* copy(std::string, size_t) const override = 0; \
79
- virtual klass* clone(std::string, size_t) const override = 0; \
78
+ virtual klass* copy(sass::string, size_t) const override = 0; \
79
+ virtual klass* clone(sass::string, size_t) const override = 0; \
80
80
 
81
81
  #define ATTACH_AST_OPERATIONS(klass) \
82
82
  klass(const klass* ptr); \
83
- virtual klass* copy(std::string, size_t) const override; \
84
- virtual klass* clone(std::string, size_t) const override; \
83
+ virtual klass* copy(sass::string, size_t) const override; \
84
+ virtual klass* clone(sass::string, size_t) const override; \
85
85
 
86
86
  #else
87
87
 
@@ -112,12 +112,12 @@ private:
112
112
  #ifdef DEBUG_SHARED_PTR
113
113
 
114
114
  #define IMPLEMENT_AST_OPERATORS(klass) \
115
- klass* klass::copy(std::string file, size_t line) const { \
116
- klass* cpy = new klass(this); \
115
+ klass* klass::copy(sass::string file, size_t line) const { \
116
+ klass* cpy = SASS_MEMORY_NEW(klass, this); \
117
117
  cpy->trace(file, line); \
118
118
  return cpy; \
119
119
  } \
120
- klass* klass::clone(std::string file, size_t line) const { \
120
+ klass* klass::clone(sass::string file, size_t line) const { \
121
121
  klass* cpy = copy(file, line); \
122
122
  cpy->cloneChildren(); \
123
123
  return cpy; \
@@ -127,7 +127,7 @@ private:
127
127
 
128
128
  #define IMPLEMENT_AST_OPERATORS(klass) \
129
129
  klass* klass::copy() const { \
130
- return new klass(this); \
130
+ return SASS_MEMORY_NEW(klass, this); \
131
131
  } \
132
132
  klass* klass::clone() const { \
133
133
  klass* cpy = copy(); \
@@ -16,14 +16,14 @@ namespace Sass {
16
16
  IMPLEMENT_BASE_CAST(AST_Node)
17
17
  IMPLEMENT_BASE_CAST(Expression)
18
18
  IMPLEMENT_BASE_CAST(Statement)
19
- IMPLEMENT_BASE_CAST(Has_Block)
19
+ IMPLEMENT_BASE_CAST(ParentStatement)
20
20
  IMPLEMENT_BASE_CAST(PreValue)
21
21
  IMPLEMENT_BASE_CAST(Value)
22
22
  IMPLEMENT_BASE_CAST(Color)
23
23
  IMPLEMENT_BASE_CAST(List)
24
24
  IMPLEMENT_BASE_CAST(String)
25
25
  IMPLEMENT_BASE_CAST(String_Constant)
26
- IMPLEMENT_BASE_CAST(Supports_Condition)
26
+ IMPLEMENT_BASE_CAST(SupportsCondition)
27
27
  IMPLEMENT_BASE_CAST(Selector)
28
28
  IMPLEMENT_BASE_CAST(SelectorComponent)
29
29
  IMPLEMENT_BASE_CAST(SimpleSelector)
@@ -4,18 +4,22 @@
4
4
  // sass.hpp must go before all system headers to get the
5
5
  // __EXTENSIONS__ fix on Solaris.
6
6
  #include "sass.hpp"
7
-
7
+ #include "memory.hpp"
8
8
  #include "sass/functions.h"
9
- #include "memory/SharedPtr.hpp"
10
9
 
11
10
  /////////////////////////////////////////////
12
11
  // Forward declarations for the AST visitors.
13
12
  /////////////////////////////////////////////
14
13
  namespace Sass {
15
14
 
15
+ class SourceData;
16
+ class SourceFile;
17
+ class SynthFile;
18
+ class ItplFile;
19
+
16
20
  class AST_Node;
17
21
 
18
- class Has_Block;
22
+ class ParentStatement;
19
23
 
20
24
  class SimpleSelector;
21
25
 
@@ -27,7 +31,7 @@ namespace Sass {
27
31
  class Statement;
28
32
  class Value;
29
33
  class Declaration;
30
- class Ruleset;
34
+ class StyleRule;
31
35
  class Bubble;
32
36
  class Trace;
33
37
 
@@ -35,25 +39,25 @@ namespace Sass {
35
39
  class CssMediaRule;
36
40
  class CssMediaQuery;
37
41
 
38
- class Supports_Block;
39
- class Directive;
42
+ class SupportsRule;
43
+ class AtRule;
40
44
 
41
45
  class Keyframe_Rule;
42
- class At_Root_Block;
46
+ class AtRootRule;
43
47
  class Assignment;
44
48
 
45
49
  class Import;
46
50
  class Import_Stub;
47
- class Warning;
51
+ class WarningRule;
48
52
 
49
- class Error;
50
- class Debug;
53
+ class ErrorRule;
54
+ class DebugRule;
51
55
  class Comment;
52
56
 
53
57
  class If;
54
- class For;
55
- class Each;
56
- class While;
58
+ class ForRule;
59
+ class EachRule;
60
+ class WhileRule;
57
61
  class Return;
58
62
  class Content;
59
63
  class ExtendRule;
@@ -85,10 +89,10 @@ namespace Sass {
85
89
 
86
90
  class Media_Query;
87
91
  class Media_Query_Expression;
88
- class Supports_Condition;
89
- class Supports_Operator;
90
- class Supports_Negation;
91
- class Supports_Declaration;
92
+ class SupportsCondition;
93
+ class SupportsOperation;
94
+ class SupportsNegation;
95
+ class SupportsDeclaration;
92
96
  class Supports_Interpolation;
93
97
 
94
98
  class At_Root_Query;
@@ -100,13 +104,13 @@ namespace Sass {
100
104
 
101
105
 
102
106
  class Selector_Schema;
103
- class Placeholder_Selector;
104
- class Type_Selector;
105
- class Class_Selector;
106
- class Id_Selector;
107
- class Attribute_Selector;
107
+ class PlaceholderSelector;
108
+ class TypeSelector;
109
+ class ClassSelector;
110
+ class IDSelector;
111
+ class AttributeSelector;
108
112
 
109
- class Pseudo_Selector;
113
+ class PseudoSelector;
110
114
 
111
115
  class SelectorComponent;
112
116
  class SelectorCombinator;
@@ -128,33 +132,38 @@ namespace Sass {
128
132
  typedef SharedImpl<type> type##Obj; \
129
133
  typedef SharedImpl<type> type##_Obj; \
130
134
 
135
+ IMPL_MEM_OBJ(SourceData);
136
+ IMPL_MEM_OBJ(SourceFile);
137
+ IMPL_MEM_OBJ(SynthFile);
138
+ IMPL_MEM_OBJ(ItplFile);
139
+
131
140
  IMPL_MEM_OBJ(AST_Node);
132
141
  IMPL_MEM_OBJ(Statement);
133
142
  IMPL_MEM_OBJ(Block);
134
- IMPL_MEM_OBJ(Ruleset);
143
+ IMPL_MEM_OBJ(StyleRule);
135
144
  IMPL_MEM_OBJ(Bubble);
136
145
  IMPL_MEM_OBJ(Trace);
137
146
  IMPL_MEM_OBJ(MediaRule);
138
147
  IMPL_MEM_OBJ(CssMediaRule);
139
148
  IMPL_MEM_OBJ(CssMediaQuery);
140
- IMPL_MEM_OBJ(Supports_Block);
141
- IMPL_MEM_OBJ(Directive);
149
+ IMPL_MEM_OBJ(SupportsRule);
150
+ IMPL_MEM_OBJ(AtRule);
142
151
  IMPL_MEM_OBJ(Keyframe_Rule);
143
- IMPL_MEM_OBJ(At_Root_Block);
152
+ IMPL_MEM_OBJ(AtRootRule);
144
153
  IMPL_MEM_OBJ(Declaration);
145
154
  IMPL_MEM_OBJ(Assignment);
146
155
  IMPL_MEM_OBJ(Import);
147
156
  IMPL_MEM_OBJ(Import_Stub);
148
- IMPL_MEM_OBJ(Warning);
149
- IMPL_MEM_OBJ(Error);
150
- IMPL_MEM_OBJ(Debug);
157
+ IMPL_MEM_OBJ(WarningRule);
158
+ IMPL_MEM_OBJ(ErrorRule);
159
+ IMPL_MEM_OBJ(DebugRule);
151
160
  IMPL_MEM_OBJ(Comment);
152
161
  IMPL_MEM_OBJ(PreValue);
153
- IMPL_MEM_OBJ(Has_Block);
162
+ IMPL_MEM_OBJ(ParentStatement);
154
163
  IMPL_MEM_OBJ(If);
155
- IMPL_MEM_OBJ(For);
156
- IMPL_MEM_OBJ(Each);
157
- IMPL_MEM_OBJ(While);
164
+ IMPL_MEM_OBJ(ForRule);
165
+ IMPL_MEM_OBJ(EachRule);
166
+ IMPL_MEM_OBJ(WhileRule);
158
167
  IMPL_MEM_OBJ(Return);
159
168
  IMPL_MEM_OBJ(Content);
160
169
  IMPL_MEM_OBJ(ExtendRule);
@@ -182,10 +191,10 @@ namespace Sass {
182
191
  IMPL_MEM_OBJ(String_Quoted);
183
192
  IMPL_MEM_OBJ(Media_Query);
184
193
  IMPL_MEM_OBJ(Media_Query_Expression);
185
- IMPL_MEM_OBJ(Supports_Condition);
186
- IMPL_MEM_OBJ(Supports_Operator);
187
- IMPL_MEM_OBJ(Supports_Negation);
188
- IMPL_MEM_OBJ(Supports_Declaration);
194
+ IMPL_MEM_OBJ(SupportsCondition);
195
+ IMPL_MEM_OBJ(SupportsOperation);
196
+ IMPL_MEM_OBJ(SupportsNegation);
197
+ IMPL_MEM_OBJ(SupportsDeclaration);
189
198
  IMPL_MEM_OBJ(Supports_Interpolation);
190
199
  IMPL_MEM_OBJ(At_Root_Query);
191
200
  IMPL_MEM_OBJ(Null);
@@ -197,12 +206,12 @@ namespace Sass {
197
206
  IMPL_MEM_OBJ(Selector);
198
207
  IMPL_MEM_OBJ(Selector_Schema);
199
208
  IMPL_MEM_OBJ(SimpleSelector);
200
- IMPL_MEM_OBJ(Placeholder_Selector);
201
- IMPL_MEM_OBJ(Type_Selector);
202
- IMPL_MEM_OBJ(Class_Selector);
203
- IMPL_MEM_OBJ(Id_Selector);
204
- IMPL_MEM_OBJ(Attribute_Selector);
205
- IMPL_MEM_OBJ(Pseudo_Selector);
209
+ IMPL_MEM_OBJ(PlaceholderSelector);
210
+ IMPL_MEM_OBJ(TypeSelector);
211
+ IMPL_MEM_OBJ(ClassSelector);
212
+ IMPL_MEM_OBJ(IDSelector);
213
+ IMPL_MEM_OBJ(AttributeSelector);
214
+ IMPL_MEM_OBJ(PseudoSelector);
206
215
 
207
216
  IMPL_MEM_OBJ(SelectorComponent);
208
217
  IMPL_MEM_OBJ(SelectorCombinator);
@@ -214,12 +223,12 @@ namespace Sass {
214
223
  // some often used typedefs
215
224
  // ###########################################################################
216
225
 
217
- typedef std::vector<Block*> BlockStack;
218
- typedef std::vector<Sass_Callee> CalleeStack;
219
- typedef std::vector<AST_Node_Obj> CallStack;
220
- typedef std::vector<CssMediaRuleObj> MediaStack;
221
- typedef std::vector<SelectorListObj> SelectorStack;
222
- typedef std::vector<Sass_Import_Entry> ImporterStack;
226
+ typedef sass::vector<Block*> BlockStack;
227
+ typedef sass::vector<Sass_Callee> CalleeStack;
228
+ typedef sass::vector<AST_Node_Obj> CallStack;
229
+ typedef sass::vector<CssMediaRuleObj> MediaStack;
230
+ typedef sass::vector<SelectorListObj> SelectorStack;
231
+ typedef sass::vector<Sass_Import_Entry> ImporterStack;
223
232
 
224
233
  // only to switch implementations for testing
225
234
  #define environment_map std::map
@@ -248,14 +257,14 @@ namespace Sass {
248
257
  DECLARE_BASE_CAST(AST_Node)
249
258
  DECLARE_BASE_CAST(Expression)
250
259
  DECLARE_BASE_CAST(Statement)
251
- DECLARE_BASE_CAST(Has_Block)
260
+ DECLARE_BASE_CAST(ParentStatement)
252
261
  DECLARE_BASE_CAST(PreValue)
253
262
  DECLARE_BASE_CAST(Value)
254
263
  DECLARE_BASE_CAST(List)
255
264
  DECLARE_BASE_CAST(Color)
256
265
  DECLARE_BASE_CAST(String)
257
266
  DECLARE_BASE_CAST(String_Constant)
258
- DECLARE_BASE_CAST(Supports_Condition)
267
+ DECLARE_BASE_CAST(SupportsCondition)
259
268
  DECLARE_BASE_CAST(Selector)
260
269
  DECLARE_BASE_CAST(SimpleSelector)
261
270
  DECLARE_BASE_CAST(SelectorComponent)
@@ -228,7 +228,7 @@ namespace Sass {
228
228
  // that can be written with pseudo-class syntax (CSS2 vs CSS3):
229
229
  // `:before`, `:after`, `:first-line`, or `:first-letter`
230
230
  // ##########################################################################
231
- inline bool isFakePseudoElement(const std::string& name)
231
+ inline bool isFakePseudoElement(const sass::string& name)
232
232
  {
233
233
  return Util::equalsLiteral("after", name)
234
234
  || Util::equalsLiteral("before", name)
@@ -241,7 +241,7 @@ namespace Sass {
241
241
  // and that are subselectors of their arguments.
242
242
  // For example, `.foo` is a superselector of `:matches(.foo)`.
243
243
  // ##########################################################################
244
- inline bool isSubselectorPseudo(const std::string& norm)
244
+ inline bool isSubselectorPseudo(const sass::string& norm)
245
245
  {
246
246
  return Util::equalsLiteral("any", norm)
247
247
  || Util::equalsLiteral("matches", norm)
@@ -253,7 +253,7 @@ namespace Sass {
253
253
  // ###########################################################################
254
254
  // Pseudo-class selectors that take unadorned selectors as arguments.
255
255
  // ###########################################################################
256
- inline bool isSelectorPseudoClass(const std::string& test)
256
+ inline bool isSelectorPseudoClass(const sass::string& test)
257
257
  {
258
258
  return Util::equalsLiteral("not", test)
259
259
  || Util::equalsLiteral("matches", test)
@@ -268,7 +268,7 @@ namespace Sass {
268
268
  // ###########################################################################
269
269
  // Pseudo-element selectors that take unadorned selectors as arguments.
270
270
  // ###########################################################################
271
- inline bool isSelectorPseudoElement(const std::string& test)
271
+ inline bool isSelectorPseudoElement(const sass::string& test)
272
272
  {
273
273
  return Util::equalsLiteral("slotted", test);
274
274
  }
@@ -277,7 +277,7 @@ namespace Sass {
277
277
  // ###########################################################################
278
278
  // Pseudo-element selectors that has binominals
279
279
  // ###########################################################################
280
- inline bool isSelectorPseudoBinominal(const std::string& test)
280
+ inline bool isSelectorPseudoBinominal(const sass::string& test)
281
281
  {
282
282
  return Util::equalsLiteral("nth-child", test)
283
283
  || Util::equalsLiteral("nth-last-child", test);
@@ -299,69 +299,69 @@ namespace Sass {
299
299
  /*#########################################################################*/
300
300
  /*#########################################################################*/
301
301
 
302
- bool Id_Selector::operator== (const SimpleSelector& rhs) const
302
+ bool IDSelector::operator== (const SimpleSelector& rhs) const
303
303
  {
304
- auto sel = Cast<Id_Selector>(&rhs);
304
+ auto sel = Cast<IDSelector>(&rhs);
305
305
  return sel ? *this == *sel : false;
306
306
  }
307
307
 
308
- bool Type_Selector::operator== (const SimpleSelector& rhs) const
308
+ bool TypeSelector::operator== (const SimpleSelector& rhs) const
309
309
  {
310
- auto sel = Cast<Type_Selector>(&rhs);
310
+ auto sel = Cast<TypeSelector>(&rhs);
311
311
  return sel ? *this == *sel : false;
312
312
  }
313
313
 
314
- bool Class_Selector::operator== (const SimpleSelector& rhs) const
314
+ bool ClassSelector::operator== (const SimpleSelector& rhs) const
315
315
  {
316
- auto sel = Cast<Class_Selector>(&rhs);
316
+ auto sel = Cast<ClassSelector>(&rhs);
317
317
  return sel ? *this == *sel : false;
318
318
  }
319
319
 
320
- bool Pseudo_Selector::operator== (const SimpleSelector& rhs) const
320
+ bool PseudoSelector::operator== (const SimpleSelector& rhs) const
321
321
  {
322
- auto sel = Cast<Pseudo_Selector>(&rhs);
322
+ auto sel = Cast<PseudoSelector>(&rhs);
323
323
  return sel ? *this == *sel : false;
324
324
  }
325
325
 
326
- bool Attribute_Selector::operator== (const SimpleSelector& rhs) const
326
+ bool AttributeSelector::operator== (const SimpleSelector& rhs) const
327
327
  {
328
- auto sel = Cast<Attribute_Selector>(&rhs);
328
+ auto sel = Cast<AttributeSelector>(&rhs);
329
329
  return sel ? *this == *sel : false;
330
330
  }
331
331
 
332
- bool Placeholder_Selector::operator== (const SimpleSelector& rhs) const
332
+ bool PlaceholderSelector::operator== (const SimpleSelector& rhs) const
333
333
  {
334
- auto sel = Cast<Placeholder_Selector>(&rhs);
334
+ auto sel = Cast<PlaceholderSelector>(&rhs);
335
335
  return sel ? *this == *sel : false;
336
336
  }
337
337
 
338
338
  /*#########################################################################*/
339
339
  /*#########################################################################*/
340
340
 
341
- bool Id_Selector::operator== (const Id_Selector& rhs) const
341
+ bool IDSelector::operator== (const IDSelector& rhs) const
342
342
  {
343
343
  // ID has no namespacing
344
344
  return name() == rhs.name();
345
345
  }
346
346
 
347
- bool Type_Selector::operator== (const Type_Selector& rhs) const
347
+ bool TypeSelector::operator== (const TypeSelector& rhs) const
348
348
  {
349
349
  return is_ns_eq(rhs) && name() == rhs.name();
350
350
  }
351
351
 
352
- bool Class_Selector::operator== (const Class_Selector& rhs) const
352
+ bool ClassSelector::operator== (const ClassSelector& rhs) const
353
353
  {
354
354
  // Class has no namespacing
355
355
  return name() == rhs.name();
356
356
  }
357
357
 
358
- bool Placeholder_Selector::operator== (const Placeholder_Selector& rhs) const
358
+ bool PlaceholderSelector::operator== (const PlaceholderSelector& rhs) const
359
359
  {
360
360
  // Placeholder has no namespacing
361
361
  return name() == rhs.name();
362
362
  }
363
363
 
364
- bool Attribute_Selector::operator== (const Attribute_Selector& rhs) const
364
+ bool AttributeSelector::operator== (const AttributeSelector& rhs) const
365
365
  {
366
366
  // smaller return, equal go on, bigger abort
367
367
  if (is_ns_eq(rhs)) {
@@ -375,7 +375,7 @@ namespace Sass {
375
375
  else { return false; }
376
376
  }
377
377
 
378
- bool Pseudo_Selector::operator== (const Pseudo_Selector& rhs) const
378
+ bool PseudoSelector::operator== (const PseudoSelector& rhs) const
379
379
  {
380
380
  if (is_ns_eq(rhs)) {
381
381
  if (name() != rhs.name()) return false;
@@ -19,8 +19,8 @@ namespace Sass {
19
19
  // [list2] matches, as well as possibly additional elements.
20
20
  // ##########################################################################
21
21
  bool listIsSuperslector(
22
- const std::vector<ComplexSelectorObj>& list1,
23
- const std::vector<ComplexSelectorObj>& list2);
22
+ const sass::vector<ComplexSelectorObj>& list1,
23
+ const sass::vector<ComplexSelectorObj>& list2);
24
24
 
25
25
  // ##########################################################################
26
26
  // Returns whether [complex1] is a superselector of [complex2].
@@ -28,19 +28,19 @@ namespace Sass {
28
28
  // [complex2] matches, as well as possibly additional elements.
29
29
  // ##########################################################################
30
30
  bool complexIsSuperselector(
31
- const std::vector<SelectorComponentObj>& complex1,
32
- const std::vector<SelectorComponentObj>& complex2);
31
+ const sass::vector<SelectorComponentObj>& complex1,
32
+ const sass::vector<SelectorComponentObj>& complex2);
33
33
 
34
34
  // ##########################################################################
35
35
  // Returns all pseudo selectors in [compound] that have
36
36
  // a selector argument, and that have the given [name].
37
37
  // ##########################################################################
38
- std::vector<Pseudo_Selector_Obj> selectorPseudoNamed(
39
- CompoundSelectorObj compound, std::string name)
38
+ sass::vector<PseudoSelectorObj> selectorPseudoNamed(
39
+ CompoundSelectorObj compound, sass::string name)
40
40
  {
41
- std::vector<Pseudo_Selector_Obj> rv;
41
+ sass::vector<PseudoSelectorObj> rv;
42
42
  for (SimpleSelectorObj sel : compound->elements()) {
43
- if (Pseudo_Selector_Obj pseudo = Cast<Pseudo_Selector>(sel)) {
43
+ if (PseudoSelectorObj pseudo = Cast<PseudoSelector>(sel)) {
44
44
  if (pseudo->isClass() && pseudo->selector()) {
45
45
  if (sel->name() == name) {
46
46
  rv.push_back(sel);
@@ -66,7 +66,7 @@ namespace Sass {
66
66
  return true;
67
67
  }
68
68
  // Some selector pseudoclasses can match normal selectors.
69
- if (const Pseudo_Selector* pseudo = Cast<Pseudo_Selector>(simple2)) {
69
+ if (const PseudoSelector* pseudo = Cast<PseudoSelector>(simple2)) {
70
70
  if (pseudo->selector() && isSubselectorPseudo(pseudo->normalized())) {
71
71
  for (auto complex : pseudo->selector()->elements()) {
72
72
  // Make sure we have exacly one items
@@ -109,11 +109,11 @@ namespace Sass {
109
109
  // ##########################################################################
110
110
  // ##########################################################################
111
111
  bool typeIsSuperselectorOfCompound(
112
- const Type_Selector_Obj& type,
112
+ const TypeSelectorObj& type,
113
113
  const CompoundSelectorObj& compound)
114
114
  {
115
115
  for (const SimpleSelectorObj& simple : compound->elements()) {
116
- if (const Type_Selector_Obj& rhs = Cast<Type_Selector>(simple)) {
116
+ if (const TypeSelectorObj& rhs = Cast<TypeSelector>(simple)) {
117
117
  if (*type != *rhs) return true;
118
118
  }
119
119
  }
@@ -124,11 +124,11 @@ namespace Sass {
124
124
  // ##########################################################################
125
125
  // ##########################################################################
126
126
  bool idIsSuperselectorOfCompound(
127
- const Id_Selector_Obj& id,
127
+ const IDSelectorObj& id,
128
128
  const CompoundSelectorObj& compound)
129
129
  {
130
130
  for (const SimpleSelectorObj& simple : compound->elements()) {
131
- if (const Id_Selector_Obj& rhs = Cast<Id_Selector>(simple)) {
131
+ if (const IDSelectorObj& rhs = Cast<IDSelector>(simple)) {
132
132
  if (*id != *rhs) return true;
133
133
  }
134
134
  }
@@ -139,8 +139,8 @@ namespace Sass {
139
139
  // ##########################################################################
140
140
  // ##########################################################################
141
141
  bool pseudoIsSuperselectorOfPseudo(
142
- const Pseudo_Selector_Obj& pseudo1,
143
- const Pseudo_Selector_Obj& pseudo2,
142
+ const PseudoSelectorObj& pseudo1,
143
+ const PseudoSelectorObj& pseudo2,
144
144
  const ComplexSelectorObj& parent
145
145
  )
146
146
  {
@@ -156,22 +156,22 @@ namespace Sass {
156
156
  // ##########################################################################
157
157
  // ##########################################################################
158
158
  bool pseudoNotIsSuperselectorOfCompound(
159
- const Pseudo_Selector_Obj& pseudo1,
159
+ const PseudoSelectorObj& pseudo1,
160
160
  const CompoundSelectorObj& compound2,
161
161
  const ComplexSelectorObj& parent)
162
162
  {
163
163
  for (const SimpleSelectorObj& simple2 : compound2->elements()) {
164
- if (const Type_Selector_Obj& type2 = Cast<Type_Selector>(simple2)) {
164
+ if (const TypeSelectorObj& type2 = Cast<TypeSelector>(simple2)) {
165
165
  if (const CompoundSelectorObj& compound1 = Cast<CompoundSelector>(parent->last())) {
166
166
  if (typeIsSuperselectorOfCompound(type2, compound1)) return true;
167
167
  }
168
168
  }
169
- else if (const Id_Selector_Obj& id2 = Cast<Id_Selector>(simple2)) {
169
+ else if (const IDSelectorObj& id2 = Cast<IDSelector>(simple2)) {
170
170
  if (const CompoundSelectorObj& compound1 = Cast<CompoundSelector>(parent->last())) {
171
171
  if (idIsSuperselectorOfCompound(id2, compound1)) return true;
172
172
  }
173
173
  }
174
- else if (const Pseudo_Selector_Obj& pseudo2 = Cast<Pseudo_Selector>(simple2)) {
174
+ else if (const PseudoSelectorObj& pseudo2 = Cast<PseudoSelector>(simple2)) {
175
175
  if (pseudoIsSuperselectorOfPseudo(pseudo1, pseudo2, parent)) return true;
176
176
  }
177
177
  }
@@ -189,21 +189,21 @@ namespace Sass {
189
189
  // parent selectors in the selector argument match [parents].
190
190
  // ##########################################################################
191
191
  bool selectorPseudoIsSuperselector(
192
- const Pseudo_Selector_Obj& pseudo1,
192
+ const PseudoSelectorObj& pseudo1,
193
193
  const CompoundSelectorObj& compound2,
194
194
  // ToDo: is this really the most convenient way to do this?
195
- std::vector<SelectorComponentObj>::const_iterator parents_from,
196
- std::vector<SelectorComponentObj>::const_iterator parents_to)
195
+ sass::vector<SelectorComponentObj>::const_iterator parents_from,
196
+ sass::vector<SelectorComponentObj>::const_iterator parents_to)
197
197
  {
198
198
 
199
199
  // ToDo: move normalization function
200
- std::string name(Util::unvendor(pseudo1->name()));
200
+ sass::string name(Util::unvendor(pseudo1->name()));
201
201
 
202
202
  if (name == "matches" || name == "any") {
203
- std::vector<Pseudo_Selector_Obj> pseudos =
203
+ sass::vector<PseudoSelectorObj> pseudos =
204
204
  selectorPseudoNamed(compound2, pseudo1->name());
205
205
  SelectorListObj selector1 = pseudo1->selector();
206
- for (Pseudo_Selector_Obj pseudo2 : pseudos) {
206
+ for (PseudoSelectorObj pseudo2 : pseudos) {
207
207
  SelectorListObj selector = pseudo2->selector();
208
208
  if (selector1->isSuperselectorOf(selector)) {
209
209
  return true;
@@ -211,7 +211,7 @@ namespace Sass {
211
211
  }
212
212
 
213
213
  for (ComplexSelectorObj complex1 : selector1->elements()) {
214
- std::vector<SelectorComponentObj> parents;
214
+ sass::vector<SelectorComponentObj> parents;
215
215
  for (auto cur = parents_from; cur != parents_to; cur++) {
216
216
  parents.push_back(*cur);
217
217
  }
@@ -223,10 +223,10 @@ namespace Sass {
223
223
 
224
224
  }
225
225
  else if (name == "has" || name == "host" || name == "host-context" || name == "slotted") {
226
- std::vector<Pseudo_Selector_Obj> pseudos =
226
+ sass::vector<PseudoSelectorObj> pseudos =
227
227
  selectorPseudoNamed(compound2, pseudo1->name());
228
228
  SelectorListObj selector1 = pseudo1->selector();
229
- for (Pseudo_Selector_Obj pseudo2 : pseudos) {
229
+ for (PseudoSelectorObj pseudo2 : pseudos) {
230
230
  SelectorListObj selector = pseudo2->selector();
231
231
  if (selector1->isSuperselectorOf(selector)) {
232
232
  return true;
@@ -241,16 +241,16 @@ namespace Sass {
241
241
  return true;
242
242
  }
243
243
  else if (name == "current") {
244
- std::vector<Pseudo_Selector_Obj> pseudos =
244
+ sass::vector<PseudoSelectorObj> pseudos =
245
245
  selectorPseudoNamed(compound2, "current");
246
- for (Pseudo_Selector_Obj pseudo2 : pseudos) {
246
+ for (PseudoSelectorObj pseudo2 : pseudos) {
247
247
  if (ObjEqualityFn(pseudo1, pseudo2)) return true;
248
248
  }
249
249
 
250
250
  }
251
251
  else if (name == "nth-child" || name == "nth-last-child") {
252
252
  for (auto simple2 : compound2->elements()) {
253
- if (Pseudo_Selector_Obj pseudo2 = simple2->getPseudoSelector()) {
253
+ if (PseudoSelectorObj pseudo2 = simple2->getPseudoSelector()) {
254
254
  if (pseudo1->name() != pseudo2->name()) continue;
255
255
  if (!ObjEqualityFn(pseudo1->argument(), pseudo2->argument())) continue;
256
256
  if (pseudo1->selector()->isSuperselectorOf(pseudo2->selector())) return true;
@@ -276,13 +276,13 @@ namespace Sass {
276
276
  const CompoundSelectorObj& compound1,
277
277
  const CompoundSelectorObj& compound2,
278
278
  // ToDo: is this really the most convenient way to do this?
279
- const std::vector<SelectorComponentObj>::const_iterator parents_from,
280
- const std::vector<SelectorComponentObj>::const_iterator parents_to)
279
+ const sass::vector<SelectorComponentObj>::const_iterator parents_from,
280
+ const sass::vector<SelectorComponentObj>::const_iterator parents_to)
281
281
  {
282
282
  // Every selector in [compound1.components] must have
283
283
  // a matching selector in [compound2.components].
284
284
  for (SimpleSelectorObj simple1 : compound1->elements()) {
285
- Pseudo_Selector_Obj pseudo1 = Cast<Pseudo_Selector>(simple1);
285
+ PseudoSelectorObj pseudo1 = Cast<PseudoSelector>(simple1);
286
286
  if (pseudo1 && pseudo1->selector()) {
287
287
  if (!selectorPseudoIsSuperselector(pseudo1, compound2, parents_from, parents_to)) {
288
288
  return false;
@@ -295,7 +295,7 @@ namespace Sass {
295
295
  // [compound1] can't be a superselector of a selector
296
296
  // with pseudo-elements that [compound2] doesn't share.
297
297
  for (SimpleSelectorObj simple2 : compound2->elements()) {
298
- Pseudo_Selector_Obj pseudo2 = Cast<Pseudo_Selector>(simple2);
298
+ PseudoSelectorObj pseudo2 = Cast<PseudoSelector>(simple2);
299
299
  if (pseudo2 && pseudo2->isElement()) {
300
300
  if (!simpleIsSuperselectorOfCompound(pseudo2, compound1)) {
301
301
  return false;
@@ -317,7 +317,7 @@ namespace Sass {
317
317
  bool compoundIsSuperselector(
318
318
  const CompoundSelectorObj& compound1,
319
319
  const CompoundSelectorObj& compound2,
320
- const std::vector<SelectorComponentObj>& parents)
320
+ const sass::vector<SelectorComponentObj>& parents)
321
321
  {
322
322
  return compoundIsSuperselector(
323
323
  compound1, compound2,
@@ -332,8 +332,8 @@ namespace Sass {
332
332
  // [complex2] matches, as well as possibly additional elements.
333
333
  // ##########################################################################
334
334
  bool complexIsSuperselector(
335
- const std::vector<SelectorComponentObj>& complex1,
336
- const std::vector<SelectorComponentObj>& complex2)
335
+ const sass::vector<SelectorComponentObj>& complex1,
336
+ const sass::vector<SelectorComponentObj>& complex2)
337
337
  {
338
338
 
339
339
  // Selectors with trailing operators are neither superselectors nor subselectors.
@@ -368,14 +368,14 @@ namespace Sass {
368
368
  CompoundSelectorObj compound2 = Cast<CompoundSelector>(complex2.back());
369
369
 
370
370
  if (remaining1 == 1) {
371
- std::vector<SelectorComponentObj>::const_iterator parents_to = complex2.end();
372
- std::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
371
+ sass::vector<SelectorComponentObj>::const_iterator parents_to = complex2.end();
372
+ sass::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
373
373
  std::advance(parents_from, i2 + 1); // equivalent to dart `.skip(i2 + 1)`
374
374
  bool rv = compoundIsSuperselector(compound1, compound2, parents_from, parents_to);
375
- std::vector<SelectorComponentObj> pp;
375
+ sass::vector<SelectorComponentObj> pp;
376
376
 
377
- std::vector<SelectorComponentObj>::const_iterator end = parents_to;
378
- std::vector<SelectorComponentObj>::const_iterator beg = parents_from;
377
+ sass::vector<SelectorComponentObj>::const_iterator end = parents_to;
378
+ sass::vector<SelectorComponentObj>::const_iterator beg = parents_from;
379
379
  while (beg != end) {
380
380
  pp.push_back(*beg);
381
381
  beg++;
@@ -393,8 +393,8 @@ namespace Sass {
393
393
  for (; afterSuperselector < complex2.size(); afterSuperselector++) {
394
394
  SelectorComponentObj component2 = complex2[afterSuperselector - 1];
395
395
  if (CompoundSelectorObj compound2 = Cast<CompoundSelector>(component2)) {
396
- std::vector<SelectorComponentObj>::const_iterator parents_to = complex2.begin();
397
- std::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
396
+ sass::vector<SelectorComponentObj>::const_iterator parents_to = complex2.begin();
397
+ sass::vector<SelectorComponentObj>::const_iterator parents_from = complex2.begin();
398
398
  // complex2.take(afterSuperselector - 1).skip(i2 + 1)
399
399
  std::advance(parents_from, i2 + 1); // equivalent to dart `.skip`
400
400
  std::advance(parents_to, afterSuperselector); // equivalent to dart `.take`
@@ -464,8 +464,8 @@ namespace Sass {
464
464
  // since `B X` is a superselector of `B A X`.
465
465
  // ##########################################################################
466
466
  bool complexIsParentSuperselector(
467
- const std::vector<SelectorComponentObj>& complex1,
468
- const std::vector<SelectorComponentObj>& complex2)
467
+ const sass::vector<SelectorComponentObj>& complex1,
468
+ const sass::vector<SelectorComponentObj>& complex2)
469
469
  {
470
470
  // Try some simple heuristics to see if we can avoid allocations.
471
471
  if (complex1.empty() && complex2.empty()) return false;
@@ -473,8 +473,8 @@ namespace Sass {
473
473
  if (Cast<SelectorCombinator>(complex2.front())) return false;
474
474
  if (complex1.size() > complex2.size()) return false;
475
475
  // TODO(nweiz): There's got to be a way to do this without a bunch of extra allocations...
476
- std::vector<SelectorComponentObj> cplx1(complex1);
477
- std::vector<SelectorComponentObj> cplx2(complex2);
476
+ sass::vector<SelectorComponentObj> cplx1(complex1);
477
+ sass::vector<SelectorComponentObj> cplx2(complex2);
478
478
  CompoundSelectorObj base = SASS_MEMORY_NEW(CompoundSelector, "[tmp]");
479
479
  cplx1.push_back(base); cplx2.push_back(base);
480
480
  return complexIsSuperselector(cplx1, cplx2);
@@ -487,7 +487,7 @@ namespace Sass {
487
487
  // [complex] matches, as well as possibly additional elements.
488
488
  // ##########################################################################
489
489
  bool listHasSuperslectorForComplex(
490
- std::vector<ComplexSelectorObj> list,
490
+ sass::vector<ComplexSelectorObj> list,
491
491
  ComplexSelectorObj complex)
492
492
  {
493
493
  // Return true if every [complex] selector on [list2]
@@ -507,8 +507,8 @@ namespace Sass {
507
507
  // [list2] matches, as well as possibly additional elements.
508
508
  // ##########################################################################
509
509
  bool listIsSuperslector(
510
- const std::vector<ComplexSelectorObj>& list1,
511
- const std::vector<ComplexSelectorObj>& list2)
510
+ const sass::vector<ComplexSelectorObj>& list1,
511
+ const sass::vector<ComplexSelectorObj>& list2)
512
512
  {
513
513
  // Return true if every [complex] selector on [list2]
514
514
  // is a super selector of the full selector [list1].