sassc 2.3.0 → 2.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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].