sassc 2.1.0.pre3 → 2.4.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/.travis.yml +2 -0
- data/CHANGELOG.md +24 -0
- data/Rakefile +2 -4
- data/ext/extconf.rb +13 -5
- data/ext/libsass/VERSION +1 -1
- data/ext/libsass/include/sass/base.h +2 -1
- data/ext/libsass/include/sass/context.h +4 -0
- data/ext/libsass/src/MurmurHash2.hpp +91 -0
- data/ext/libsass/src/ast.cpp +158 -168
- data/ext/libsass/src/ast.hpp +389 -230
- data/ext/libsass/src/ast_def_macros.hpp +18 -10
- data/ext/libsass/src/ast_fwd_decl.cpp +4 -3
- data/ext/libsass/src/ast_fwd_decl.hpp +98 -165
- data/ext/libsass/src/ast_helpers.hpp +292 -0
- data/ext/libsass/src/ast_sel_cmp.cpp +219 -732
- data/ext/libsass/src/ast_sel_super.cpp +539 -0
- data/ext/libsass/src/ast_sel_unify.cpp +207 -212
- data/ext/libsass/src/ast_sel_weave.cpp +616 -0
- data/ext/libsass/src/ast_selectors.cpp +594 -1026
- data/ext/libsass/src/ast_selectors.hpp +339 -385
- data/ext/libsass/src/ast_supports.cpp +36 -52
- data/ext/libsass/src/ast_supports.hpp +29 -29
- data/ext/libsass/src/ast_values.cpp +271 -84
- data/ext/libsass/src/ast_values.hpp +116 -107
- data/ext/libsass/src/backtrace.cpp +9 -9
- data/ext/libsass/src/backtrace.hpp +5 -5
- data/ext/libsass/src/base64vlq.cpp +2 -2
- data/ext/libsass/src/base64vlq.hpp +1 -1
- data/ext/libsass/src/bind.cpp +18 -18
- data/ext/libsass/src/bind.hpp +1 -1
- data/ext/libsass/src/c2ast.cpp +3 -3
- data/ext/libsass/src/c2ast.hpp +1 -1
- data/ext/libsass/src/cencode.c +4 -6
- data/ext/libsass/src/check_nesting.cpp +40 -41
- data/ext/libsass/src/check_nesting.hpp +6 -2
- data/ext/libsass/src/color_maps.cpp +14 -13
- data/ext/libsass/src/color_maps.hpp +1 -9
- data/ext/libsass/src/constants.cpp +5 -0
- data/ext/libsass/src/constants.hpp +6 -0
- data/ext/libsass/src/context.cpp +92 -119
- data/ext/libsass/src/context.hpp +41 -53
- data/ext/libsass/src/cssize.cpp +66 -149
- data/ext/libsass/src/cssize.hpp +17 -23
- data/ext/libsass/src/dart_helpers.hpp +199 -0
- data/ext/libsass/src/debugger.hpp +451 -295
- data/ext/libsass/src/emitter.cpp +15 -16
- data/ext/libsass/src/emitter.hpp +10 -12
- data/ext/libsass/src/environment.cpp +27 -27
- data/ext/libsass/src/environment.hpp +29 -24
- data/ext/libsass/src/error_handling.cpp +62 -41
- data/ext/libsass/src/error_handling.hpp +61 -51
- data/ext/libsass/src/eval.cpp +167 -281
- data/ext/libsass/src/eval.hpp +27 -29
- data/ext/libsass/src/eval_selectors.cpp +75 -0
- data/ext/libsass/src/expand.cpp +275 -222
- data/ext/libsass/src/expand.hpp +36 -16
- data/ext/libsass/src/extender.cpp +1188 -0
- data/ext/libsass/src/extender.hpp +399 -0
- data/ext/libsass/src/extension.cpp +43 -0
- data/ext/libsass/src/extension.hpp +89 -0
- data/ext/libsass/src/file.cpp +81 -72
- data/ext/libsass/src/file.hpp +28 -37
- data/ext/libsass/src/fn_colors.cpp +20 -18
- data/ext/libsass/src/fn_lists.cpp +30 -29
- data/ext/libsass/src/fn_maps.cpp +3 -3
- data/ext/libsass/src/fn_miscs.cpp +34 -46
- data/ext/libsass/src/fn_numbers.cpp +20 -13
- data/ext/libsass/src/fn_selectors.cpp +98 -128
- data/ext/libsass/src/fn_strings.cpp +47 -33
- data/ext/libsass/src/fn_utils.cpp +31 -29
- data/ext/libsass/src/fn_utils.hpp +17 -11
- data/ext/libsass/src/inspect.cpp +186 -148
- data/ext/libsass/src/inspect.hpp +31 -29
- data/ext/libsass/src/lexer.cpp +20 -82
- data/ext/libsass/src/lexer.hpp +5 -16
- data/ext/libsass/src/listize.cpp +23 -37
- data/ext/libsass/src/listize.hpp +8 -9
- data/ext/libsass/src/mapping.hpp +1 -0
- data/ext/libsass/src/memory.hpp +12 -0
- data/ext/libsass/src/memory/allocator.cpp +48 -0
- data/ext/libsass/src/memory/allocator.hpp +138 -0
- data/ext/libsass/src/memory/config.hpp +20 -0
- data/ext/libsass/src/memory/memory_pool.hpp +186 -0
- data/ext/libsass/src/memory/{SharedPtr.cpp → shared_ptr.cpp} +2 -2
- data/ext/libsass/src/memory/{SharedPtr.hpp → shared_ptr.hpp} +55 -9
- data/ext/libsass/src/operation.hpp +71 -61
- data/ext/libsass/src/operators.cpp +19 -18
- data/ext/libsass/src/operators.hpp +11 -11
- data/ext/libsass/src/ordered_map.hpp +112 -0
- data/ext/libsass/src/output.cpp +45 -64
- data/ext/libsass/src/output.hpp +6 -6
- data/ext/libsass/src/parser.cpp +512 -700
- data/ext/libsass/src/parser.hpp +89 -97
- data/ext/libsass/src/parser_selectors.cpp +189 -0
- data/ext/libsass/src/permutate.hpp +164 -0
- data/ext/libsass/src/plugins.cpp +7 -7
- data/ext/libsass/src/plugins.hpp +8 -8
- data/ext/libsass/src/position.cpp +7 -26
- data/ext/libsass/src/position.hpp +44 -21
- data/ext/libsass/src/prelexer.cpp +6 -6
- data/ext/libsass/src/remove_placeholders.cpp +55 -56
- data/ext/libsass/src/remove_placeholders.hpp +21 -18
- data/ext/libsass/src/sass.cpp +16 -15
- data/ext/libsass/src/sass.hpp +10 -5
- data/ext/libsass/src/sass2scss.cpp +4 -4
- data/ext/libsass/src/sass_context.cpp +91 -122
- data/ext/libsass/src/sass_context.hpp +2 -2
- data/ext/libsass/src/sass_functions.cpp +1 -1
- data/ext/libsass/src/sass_values.cpp +8 -11
- data/ext/libsass/src/settings.hpp +19 -0
- data/ext/libsass/src/source.cpp +69 -0
- data/ext/libsass/src/source.hpp +95 -0
- data/ext/libsass/src/source_data.hpp +32 -0
- data/ext/libsass/src/source_map.cpp +22 -18
- data/ext/libsass/src/source_map.hpp +12 -9
- data/ext/libsass/src/stylesheet.cpp +22 -0
- data/ext/libsass/src/stylesheet.hpp +57 -0
- data/ext/libsass/src/to_value.cpp +2 -2
- data/ext/libsass/src/to_value.hpp +1 -1
- data/ext/libsass/src/units.cpp +24 -22
- data/ext/libsass/src/units.hpp +8 -8
- data/ext/libsass/src/utf8_string.cpp +9 -10
- data/ext/libsass/src/utf8_string.hpp +7 -6
- data/ext/libsass/src/util.cpp +48 -50
- data/ext/libsass/src/util.hpp +20 -21
- data/ext/libsass/src/util_string.cpp +111 -61
- data/ext/libsass/src/util_string.hpp +62 -8
- data/ext/libsass/src/values.cpp +12 -12
- data/lib/sassc/engine.rb +5 -3
- data/lib/sassc/functions_handler.rb +11 -13
- data/lib/sassc/native.rb +9 -7
- data/lib/sassc/script.rb +4 -6
- data/lib/sassc/version.rb +1 -1
- data/test/functions_test.rb +38 -1
- data/test/native_test.rb +4 -4
- metadata +31 -18
- data/ext/libsass/src/extend.cpp +0 -2132
- data/ext/libsass/src/extend.hpp +0 -86
- data/ext/libsass/src/node.cpp +0 -322
- data/ext/libsass/src/node.hpp +0 -118
- data/ext/libsass/src/paths.hpp +0 -71
- data/ext/libsass/src/sass_util.cpp +0 -152
- data/ext/libsass/src/sass_util.hpp +0 -256
- data/ext/libsass/src/subset_map.cpp +0 -58
- data/ext/libsass/src/subset_map.hpp +0 -76
- data/lib/sassc/native/lib_c.rb +0 -21
data/ext/libsass/src/ast.hpp
CHANGED
@@ -5,47 +5,22 @@
|
|
5
5
|
// __EXTENSIONS__ fix on Solaris.
|
6
6
|
#include "sass.hpp"
|
7
7
|
|
8
|
-
#include <set>
|
9
|
-
#include <deque>
|
10
|
-
#include <vector>
|
11
|
-
#include <string>
|
12
|
-
#include <sstream>
|
13
|
-
#include <iostream>
|
14
8
|
#include <typeinfo>
|
15
|
-
#include <
|
9
|
+
#include <unordered_map>
|
10
|
+
|
16
11
|
#include "sass/base.h"
|
12
|
+
#include "ast_helpers.hpp"
|
17
13
|
#include "ast_fwd_decl.hpp"
|
14
|
+
#include "ast_def_macros.hpp"
|
18
15
|
|
19
|
-
#include "
|
20
|
-
#include "units.hpp"
|
21
|
-
#include "context.hpp"
|
16
|
+
#include "file.hpp"
|
22
17
|
#include "position.hpp"
|
23
|
-
#include "constants.hpp"
|
24
18
|
#include "operation.hpp"
|
25
|
-
#include "position.hpp"
|
26
|
-
#include "inspect.hpp"
|
27
|
-
#include "source_map.hpp"
|
28
19
|
#include "environment.hpp"
|
29
|
-
#include "error_handling.hpp"
|
30
|
-
#include "ast_def_macros.hpp"
|
31
|
-
#include "ast_fwd_decl.hpp"
|
32
|
-
#include "source_map.hpp"
|
33
20
|
#include "fn_utils.hpp"
|
34
21
|
|
35
|
-
#include "sass.h"
|
36
|
-
|
37
22
|
namespace Sass {
|
38
23
|
|
39
|
-
// easier to search with name
|
40
|
-
const bool DELAYED = true;
|
41
|
-
|
42
|
-
// ToDo: should this really be hardcoded
|
43
|
-
// Note: most methods follow precision option
|
44
|
-
const double NUMBER_EPSILON = 1e-12;
|
45
|
-
|
46
|
-
// macro to test if numbers are equal within a small error margin
|
47
|
-
#define NEAR_EQUAL(lhs, rhs) std::fabs(lhs - rhs) < NUMBER_EPSILON
|
48
|
-
|
49
24
|
// ToDo: where does this fit best?
|
50
25
|
// We don't share this with C-API?
|
51
26
|
class Operand {
|
@@ -80,9 +55,9 @@ namespace Sass {
|
|
80
55
|
// Abstract base class for all abstract syntax tree nodes.
|
81
56
|
//////////////////////////////////////////////////////////
|
82
57
|
class AST_Node : public SharedObj {
|
83
|
-
ADD_PROPERTY(
|
58
|
+
ADD_PROPERTY(SourceSpan, pstate)
|
84
59
|
public:
|
85
|
-
AST_Node(
|
60
|
+
AST_Node(SourceSpan pstate)
|
86
61
|
: pstate_(pstate)
|
87
62
|
{ }
|
88
63
|
AST_Node(const AST_Node* ptr)
|
@@ -91,7 +66,7 @@ namespace Sass {
|
|
91
66
|
|
92
67
|
// allow implicit conversion to string
|
93
68
|
// needed for by SharedPtr implementation
|
94
|
-
operator
|
69
|
+
operator sass::string() {
|
95
70
|
return to_string();
|
96
71
|
}
|
97
72
|
|
@@ -99,17 +74,30 @@ namespace Sass {
|
|
99
74
|
|
100
75
|
virtual ~AST_Node() = 0;
|
101
76
|
virtual size_t hash() const { return 0; }
|
102
|
-
virtual
|
103
|
-
virtual
|
104
|
-
virtual
|
105
|
-
virtual
|
77
|
+
virtual sass::string inspect() const { return to_string({ INSPECT, 5 }); }
|
78
|
+
virtual sass::string to_sass() const { return to_string({ TO_SASS, 5 }); }
|
79
|
+
virtual sass::string to_string(Sass_Inspect_Options opt) const;
|
80
|
+
virtual sass::string to_css(Sass_Inspect_Options opt) const;
|
81
|
+
virtual sass::string to_string() const;
|
106
82
|
virtual void cloneChildren() {};
|
107
83
|
// generic find function (not fully implemented yet)
|
108
|
-
// ToDo: add specific
|
84
|
+
// ToDo: add specific implementations to all children
|
109
85
|
virtual bool find ( bool (*f)(AST_Node_Obj) ) { return f(this); };
|
110
|
-
void update_pstate(const
|
111
|
-
|
112
|
-
|
86
|
+
void update_pstate(const SourceSpan& pstate);
|
87
|
+
|
88
|
+
// Some objects are not meant to be compared
|
89
|
+
// ToDo: maybe fall-back to pointer comparison?
|
90
|
+
virtual bool operator== (const AST_Node& rhs) const {
|
91
|
+
throw std::runtime_error("operator== not implemented");
|
92
|
+
}
|
93
|
+
|
94
|
+
// We can give some reasonable implementations by using
|
95
|
+
// invert operators on the specialized implementations
|
96
|
+
virtual bool operator!= (const AST_Node& rhs) const {
|
97
|
+
// Unequal if not equal
|
98
|
+
return !(*this == rhs);
|
99
|
+
}
|
100
|
+
|
113
101
|
ATTACH_ABSTRACT_AST_OPERATIONS(AST_Node);
|
114
102
|
ATTACH_ABSTRACT_CRTP_PERFORM_METHODS()
|
115
103
|
};
|
@@ -163,13 +151,13 @@ namespace Sass {
|
|
163
151
|
ADD_PROPERTY(bool, is_interpolant)
|
164
152
|
ADD_PROPERTY(Type, concrete_type)
|
165
153
|
public:
|
166
|
-
Expression(
|
154
|
+
Expression(SourceSpan pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
|
167
155
|
virtual operator bool() { return true; }
|
168
156
|
virtual ~Expression() { }
|
169
157
|
virtual bool is_invisible() const { return false; }
|
170
158
|
|
171
|
-
virtual
|
172
|
-
static
|
159
|
+
virtual sass::string type() const { return ""; }
|
160
|
+
static sass::string type_name() { return ""; }
|
173
161
|
|
174
162
|
virtual bool is_false() { return false; }
|
175
163
|
// virtual bool is_true() { return !is_false(); }
|
@@ -194,17 +182,17 @@ namespace Sass {
|
|
194
182
|
|
195
183
|
namespace std {
|
196
184
|
template<>
|
197
|
-
struct hash<Sass::
|
185
|
+
struct hash<Sass::ExpressionObj>
|
198
186
|
{
|
199
|
-
size_t operator()(Sass::
|
187
|
+
size_t operator()(Sass::ExpressionObj s) const
|
200
188
|
{
|
201
189
|
return s->hash();
|
202
190
|
}
|
203
191
|
};
|
204
192
|
template<>
|
205
|
-
struct equal_to<Sass::
|
193
|
+
struct equal_to<Sass::ExpressionObj>
|
206
194
|
{
|
207
|
-
bool operator()( Sass::
|
195
|
+
bool operator()( Sass::ExpressionObj lhs, Sass::ExpressionObj rhs) const
|
208
196
|
{
|
209
197
|
return lhs->hash() == rhs->hash();
|
210
198
|
}
|
@@ -220,7 +208,7 @@ namespace Sass {
|
|
220
208
|
/////////////////////////////////////////////////////////////////////////////
|
221
209
|
template <typename T>
|
222
210
|
class Vectorized {
|
223
|
-
|
211
|
+
sass::vector<T> elements_;
|
224
212
|
protected:
|
225
213
|
mutable size_t hash_;
|
226
214
|
void reset_hash() { hash_ = 0; }
|
@@ -228,37 +216,112 @@ namespace Sass {
|
|
228
216
|
public:
|
229
217
|
Vectorized(size_t s = 0) : hash_(0)
|
230
218
|
{ elements_.reserve(s); }
|
219
|
+
Vectorized(sass::vector<T> vec) :
|
220
|
+
elements_(std::move(vec)),
|
221
|
+
hash_(0)
|
222
|
+
{}
|
231
223
|
virtual ~Vectorized() = 0;
|
232
224
|
size_t length() const { return elements_.size(); }
|
233
225
|
bool empty() const { return elements_.empty(); }
|
234
226
|
void clear() { return elements_.clear(); }
|
235
|
-
T last()
|
236
|
-
T first()
|
227
|
+
T& last() { return elements_.back(); }
|
228
|
+
T& first() { return elements_.front(); }
|
229
|
+
const T& last() const { return elements_.back(); }
|
230
|
+
const T& first() const { return elements_.front(); }
|
231
|
+
|
232
|
+
bool operator== (const Vectorized<T>& rhs) const {
|
233
|
+
// Abort early if sizes do not match
|
234
|
+
if (length() != rhs.length()) return false;
|
235
|
+
// Otherwise test each node for object equalicy in order
|
236
|
+
return std::equal(begin(), end(), rhs.begin(), ObjEqualityFn<T>);
|
237
|
+
}
|
238
|
+
|
239
|
+
bool operator!= (const Vectorized<T>& rhs) const {
|
240
|
+
return !(*this == rhs);
|
241
|
+
}
|
242
|
+
|
237
243
|
T& operator[](size_t i) { return elements_[i]; }
|
238
244
|
virtual const T& at(size_t i) const { return elements_.at(i); }
|
239
245
|
virtual T& at(size_t i) { return elements_.at(i); }
|
240
246
|
const T& get(size_t i) const { return elements_[i]; }
|
241
247
|
const T& operator[](size_t i) const { return elements_[i]; }
|
242
|
-
|
248
|
+
|
249
|
+
// Implicitly get the sass::vector from our object
|
250
|
+
// Makes the Vector directly assignable to sass::vector
|
251
|
+
// You are responsible to make a copy if needed
|
252
|
+
// Note: since this returns the real object, we can't
|
253
|
+
// Note: guarantee that the hash will not get out of sync
|
254
|
+
operator sass::vector<T>&() { return elements_; }
|
255
|
+
operator const sass::vector<T>&() const { return elements_; }
|
256
|
+
|
257
|
+
// Explicitly request all elements as a real sass::vector
|
258
|
+
// You are responsible to make a copy if needed
|
259
|
+
// Note: since this returns the real object, we can't
|
260
|
+
// Note: guarantee that the hash will not get out of sync
|
261
|
+
sass::vector<T>& elements() { return elements_; }
|
262
|
+
const sass::vector<T>& elements() const { return elements_; }
|
263
|
+
|
264
|
+
// Insert all items from compatible vector
|
265
|
+
void concat(const sass::vector<T>& v)
|
266
|
+
{
|
267
|
+
if (!v.empty()) reset_hash();
|
268
|
+
elements().insert(end(), v.begin(), v.end());
|
269
|
+
}
|
270
|
+
|
271
|
+
// Syntatic sugar for pointers
|
272
|
+
void concat(const Vectorized<T>* v)
|
243
273
|
{
|
244
|
-
if (
|
245
|
-
|
246
|
-
elements_.push_back(element);
|
247
|
-
adjust_after_pushing(element);
|
274
|
+
if (v != nullptr) {
|
275
|
+
return concat(*v);
|
248
276
|
}
|
249
277
|
}
|
250
|
-
|
278
|
+
|
279
|
+
// Insert one item on the front
|
280
|
+
void unshift(T element)
|
251
281
|
{
|
252
|
-
|
282
|
+
reset_hash();
|
283
|
+
elements_.insert(begin(), element);
|
253
284
|
}
|
254
|
-
|
285
|
+
|
286
|
+
// Remove and return item on the front
|
287
|
+
// ToDo: handle empty vectors
|
288
|
+
T shift() {
|
289
|
+
reset_hash();
|
290
|
+
T first = get(0);
|
291
|
+
elements_.erase(begin());
|
292
|
+
return first;
|
293
|
+
}
|
294
|
+
|
295
|
+
// Insert one item on the back
|
296
|
+
// ToDo: rename this to push
|
297
|
+
void append(T element)
|
255
298
|
{
|
256
|
-
|
257
|
-
|
299
|
+
reset_hash();
|
300
|
+
elements_.insert(end(), element);
|
301
|
+
// ToDo: Mostly used by parameters and arguments
|
302
|
+
// ToDo: Find a more elegant way to support this
|
303
|
+
adjust_after_pushing(element);
|
304
|
+
}
|
305
|
+
|
306
|
+
// Check if an item already exists
|
307
|
+
// Uses underlying object `operator==`
|
308
|
+
// E.g. compares the actual objects
|
309
|
+
bool contains(const T& el) const {
|
310
|
+
for (const T& rhs : elements_) {
|
311
|
+
// Test the underlying objects for equality
|
312
|
+
// A std::find checks for pointer equality
|
313
|
+
if (ObjEqualityFn(el, rhs)) {
|
314
|
+
return true;
|
315
|
+
}
|
316
|
+
}
|
317
|
+
return false;
|
318
|
+
}
|
319
|
+
|
320
|
+
// This might be better implemented as `operator=`?
|
321
|
+
void elements(sass::vector<T> e) {
|
322
|
+
reset_hash();
|
323
|
+
elements_ = std::move(e);
|
258
324
|
}
|
259
|
-
std::vector<T>& elements() { return elements_; }
|
260
|
-
const std::vector<T>& elements() const { return elements_; }
|
261
|
-
std::vector<T>& elements(std::vector<T>& e) { elements_ = e; return elements_; }
|
262
325
|
|
263
326
|
virtual size_t hash() const
|
264
327
|
{
|
@@ -271,17 +334,17 @@ namespace Sass {
|
|
271
334
|
}
|
272
335
|
|
273
336
|
template <typename P, typename V>
|
274
|
-
typename
|
337
|
+
typename sass::vector<T>::iterator insert(P position, const V& val) {
|
275
338
|
reset_hash();
|
276
339
|
return elements_.insert(position, val);
|
277
340
|
}
|
278
341
|
|
279
|
-
typename
|
280
|
-
typename
|
281
|
-
typename
|
282
|
-
typename
|
283
|
-
typename
|
284
|
-
typename
|
342
|
+
typename sass::vector<T>::iterator end() { return elements_.end(); }
|
343
|
+
typename sass::vector<T>::iterator begin() { return elements_.begin(); }
|
344
|
+
typename sass::vector<T>::const_iterator end() const { return elements_.end(); }
|
345
|
+
typename sass::vector<T>::const_iterator begin() const { return elements_.begin(); }
|
346
|
+
typename sass::vector<T>::iterator erase(typename sass::vector<T>::iterator el) { reset_hash(); return elements_.erase(el); }
|
347
|
+
typename sass::vector<T>::const_iterator erase(typename sass::vector<T>::const_iterator el) { reset_hash(); return elements_.erase(el); }
|
285
348
|
|
286
349
|
};
|
287
350
|
template <typename T>
|
@@ -289,38 +352,63 @@ namespace Sass {
|
|
289
352
|
|
290
353
|
/////////////////////////////////////////////////////////////////////////////
|
291
354
|
// Mixin class for AST nodes that should behave like a hash table. Uses an
|
292
|
-
// extra <
|
355
|
+
// extra <sass::vector> internally to maintain insertion order for interation.
|
293
356
|
/////////////////////////////////////////////////////////////////////////////
|
357
|
+
template <typename K, typename T, typename U>
|
294
358
|
class Hashed {
|
295
359
|
private:
|
296
|
-
|
297
|
-
|
360
|
+
std::unordered_map<
|
361
|
+
K, T, ObjHash, ObjEquality
|
362
|
+
> elements_;
|
363
|
+
|
364
|
+
sass::vector<K> _keys;
|
365
|
+
sass::vector<T> _values;
|
298
366
|
protected:
|
299
367
|
mutable size_t hash_;
|
300
|
-
|
368
|
+
K duplicate_key_;
|
301
369
|
void reset_hash() { hash_ = 0; }
|
302
370
|
void reset_duplicate_key() { duplicate_key_ = {}; }
|
303
|
-
virtual void adjust_after_pushing(std::pair<
|
371
|
+
virtual void adjust_after_pushing(std::pair<K, T> p) { }
|
304
372
|
public:
|
305
373
|
Hashed(size_t s = 0)
|
306
|
-
: elements_(
|
307
|
-
|
374
|
+
: elements_(),
|
375
|
+
_keys(),
|
376
|
+
_values(),
|
308
377
|
hash_(0), duplicate_key_({})
|
309
|
-
{
|
378
|
+
{
|
379
|
+
_keys.reserve(s);
|
380
|
+
_values.reserve(s);
|
381
|
+
elements_.reserve(s);
|
382
|
+
}
|
310
383
|
virtual ~Hashed();
|
311
|
-
size_t length() const { return
|
312
|
-
bool empty() const { return
|
313
|
-
bool has(
|
314
|
-
|
384
|
+
size_t length() const { return _keys.size(); }
|
385
|
+
bool empty() const { return _keys.empty(); }
|
386
|
+
bool has(K k) const {
|
387
|
+
return elements_.find(k) != elements_.end();
|
388
|
+
}
|
389
|
+
T at(K k) const {
|
390
|
+
if (elements_.count(k))
|
391
|
+
{
|
392
|
+
return elements_.at(k);
|
393
|
+
}
|
394
|
+
else { return {}; }
|
395
|
+
}
|
315
396
|
bool has_duplicate_key() const { return duplicate_key_ != nullptr; }
|
316
|
-
|
317
|
-
const
|
318
|
-
|
397
|
+
K get_duplicate_key() const { return duplicate_key_; }
|
398
|
+
const std::unordered_map<
|
399
|
+
K, T, ObjHash, ObjEquality
|
400
|
+
>& elements() { return elements_; }
|
401
|
+
Hashed& operator<<(std::pair<K, T> p)
|
319
402
|
{
|
320
403
|
reset_hash();
|
321
404
|
|
322
|
-
if (!has(p.first))
|
323
|
-
|
405
|
+
if (!has(p.first)) {
|
406
|
+
_keys.push_back(p.first);
|
407
|
+
_values.push_back(p.second);
|
408
|
+
}
|
409
|
+
else if (!duplicate_key_) {
|
410
|
+
duplicate_key_ = p.first;
|
411
|
+
}
|
324
412
|
|
325
413
|
elements_[p.first] = p.second;
|
326
414
|
|
@@ -331,7 +419,8 @@ namespace Sass {
|
|
331
419
|
{
|
332
420
|
if (length() == 0) {
|
333
421
|
this->elements_ = h->elements_;
|
334
|
-
this->
|
422
|
+
this->_values = h->_values;
|
423
|
+
this->_keys = h->_keys;
|
335
424
|
return *this;
|
336
425
|
}
|
337
426
|
|
@@ -342,17 +431,21 @@ namespace Sass {
|
|
342
431
|
reset_duplicate_key();
|
343
432
|
return *this;
|
344
433
|
}
|
345
|
-
const
|
346
|
-
|
434
|
+
const std::unordered_map<
|
435
|
+
K, T, ObjHash, ObjEquality
|
436
|
+
>& pairs() const { return elements_; }
|
347
437
|
|
348
|
-
|
349
|
-
|
350
|
-
// std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator end() const { return elements_.end(); }
|
351
|
-
// std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator begin() const { return elements_.begin(); }
|
438
|
+
const sass::vector<K>& keys() const { return _keys; }
|
439
|
+
const sass::vector<T>& values() const { return _values; }
|
352
440
|
|
353
|
-
|
354
|
-
|
441
|
+
// std::unordered_map<ExpressionObj, ExpressionObj>::iterator end() { return elements_.end(); }
|
442
|
+
// std::unordered_map<ExpressionObj, ExpressionObj>::iterator begin() { return elements_.begin(); }
|
443
|
+
// std::unordered_map<ExpressionObj, ExpressionObj>::const_iterator end() const { return elements_.end(); }
|
444
|
+
// std::unordered_map<ExpressionObj, ExpressionObj>::const_iterator begin() const { return elements_.begin(); }
|
355
445
|
|
446
|
+
};
|
447
|
+
template <typename K, typename T, typename U>
|
448
|
+
inline Hashed<K, T, U>::~Hashed() { }
|
356
449
|
|
357
450
|
/////////////////////////////////////////////////////////////////////////
|
358
451
|
// Abstract base class for statements. This side of the AST hierarchy
|
@@ -391,7 +484,7 @@ namespace Sass {
|
|
391
484
|
ADD_PROPERTY(size_t, tabs)
|
392
485
|
ADD_PROPERTY(bool, group_end)
|
393
486
|
public:
|
394
|
-
Statement(
|
487
|
+
Statement(SourceSpan pstate, Type st = NONE, size_t t = 0);
|
395
488
|
virtual ~Statement() = 0; // virtual destructor
|
396
489
|
// needed for rearranging nested rulesets during CSS emission
|
397
490
|
virtual bool bubbles();
|
@@ -410,7 +503,8 @@ namespace Sass {
|
|
410
503
|
protected:
|
411
504
|
void adjust_after_pushing(Statement_Obj s) override {}
|
412
505
|
public:
|
413
|
-
Block(
|
506
|
+
Block(SourceSpan pstate, size_t s = 0, bool r = false);
|
507
|
+
bool isInvisible() const;
|
414
508
|
bool has_content() override;
|
415
509
|
ATTACH_AST_OPERATIONS(Block)
|
416
510
|
ATTACH_CRTP_PERFORM_METHODS()
|
@@ -419,27 +513,28 @@ namespace Sass {
|
|
419
513
|
////////////////////////////////////////////////////////////////////////
|
420
514
|
// Abstract base class for statements that contain blocks of statements.
|
421
515
|
////////////////////////////////////////////////////////////////////////
|
422
|
-
class
|
516
|
+
class ParentStatement : public Statement {
|
423
517
|
ADD_PROPERTY(Block_Obj, block)
|
424
518
|
public:
|
425
|
-
|
426
|
-
|
427
|
-
virtual ~
|
519
|
+
ParentStatement(SourceSpan pstate, Block_Obj b);
|
520
|
+
ParentStatement(const ParentStatement* ptr); // copy constructor
|
521
|
+
virtual ~ParentStatement() = 0; // virtual destructor
|
428
522
|
virtual bool has_content() override;
|
429
523
|
};
|
430
|
-
inline
|
524
|
+
inline ParentStatement::~ParentStatement() { }
|
431
525
|
|
432
526
|
/////////////////////////////////////////////////////////////////////////////
|
433
527
|
// Rulesets (i.e., sets of styles headed by a selector and containing a block
|
434
528
|
// of style declarations.
|
435
529
|
/////////////////////////////////////////////////////////////////////////////
|
436
|
-
class
|
437
|
-
ADD_PROPERTY(
|
530
|
+
class StyleRule final : public ParentStatement {
|
531
|
+
ADD_PROPERTY(SelectorListObj, selector)
|
532
|
+
ADD_PROPERTY(Selector_Schema_Obj, schema)
|
438
533
|
ADD_PROPERTY(bool, is_root);
|
439
534
|
public:
|
440
|
-
|
535
|
+
StyleRule(SourceSpan pstate, SelectorListObj s = {}, Block_Obj b = {});
|
441
536
|
bool is_invisible() const override;
|
442
|
-
ATTACH_AST_OPERATIONS(
|
537
|
+
ATTACH_AST_OPERATIONS(StyleRule)
|
443
538
|
ATTACH_CRTP_PERFORM_METHODS()
|
444
539
|
};
|
445
540
|
|
@@ -450,7 +545,7 @@ namespace Sass {
|
|
450
545
|
ADD_PROPERTY(Statement_Obj, node)
|
451
546
|
ADD_PROPERTY(bool, group_end)
|
452
547
|
public:
|
453
|
-
Bubble(
|
548
|
+
Bubble(SourceSpan pstate, Statement_Obj n, Statement_Obj g = {}, size_t t = 0);
|
454
549
|
bool bubbles() override;
|
455
550
|
ATTACH_AST_OPERATIONS(Bubble)
|
456
551
|
ATTACH_CRTP_PERFORM_METHODS()
|
@@ -459,54 +554,41 @@ namespace Sass {
|
|
459
554
|
/////////////////
|
460
555
|
// Trace.
|
461
556
|
/////////////////
|
462
|
-
class Trace final : public
|
557
|
+
class Trace final : public ParentStatement {
|
463
558
|
ADD_CONSTREF(char, type)
|
464
|
-
ADD_CONSTREF(
|
559
|
+
ADD_CONSTREF(sass::string, name)
|
465
560
|
public:
|
466
|
-
Trace(
|
561
|
+
Trace(SourceSpan pstate, sass::string n, Block_Obj b = {}, char type = 'm');
|
467
562
|
ATTACH_AST_OPERATIONS(Trace)
|
468
563
|
ATTACH_CRTP_PERFORM_METHODS()
|
469
564
|
};
|
470
565
|
|
471
|
-
/////////////////
|
472
|
-
// Media queries.
|
473
|
-
/////////////////
|
474
|
-
class Media_Block final : public Has_Block {
|
475
|
-
ADD_PROPERTY(List_Obj, media_queries)
|
476
|
-
public:
|
477
|
-
Media_Block(ParserState pstate, List_Obj mqs, Block_Obj b);
|
478
|
-
bool bubbles() override;
|
479
|
-
bool is_invisible() const override;
|
480
|
-
ATTACH_AST_OPERATIONS(Media_Block)
|
481
|
-
ATTACH_CRTP_PERFORM_METHODS()
|
482
|
-
};
|
483
|
-
|
484
566
|
///////////////////////////////////////////////////////////////////////
|
485
567
|
// At-rules -- arbitrary directives beginning with "@" that may have an
|
486
568
|
// optional statement block.
|
487
569
|
///////////////////////////////////////////////////////////////////////
|
488
|
-
class
|
489
|
-
ADD_CONSTREF(
|
490
|
-
ADD_PROPERTY(
|
491
|
-
ADD_PROPERTY(
|
570
|
+
class AtRule final : public ParentStatement {
|
571
|
+
ADD_CONSTREF(sass::string, keyword)
|
572
|
+
ADD_PROPERTY(SelectorListObj, selector)
|
573
|
+
ADD_PROPERTY(ExpressionObj, value)
|
492
574
|
public:
|
493
|
-
|
575
|
+
AtRule(SourceSpan pstate, sass::string kwd, SelectorListObj sel = {}, Block_Obj b = {}, ExpressionObj val = {});
|
494
576
|
bool bubbles() override;
|
495
577
|
bool is_media();
|
496
578
|
bool is_keyframes();
|
497
|
-
ATTACH_AST_OPERATIONS(
|
579
|
+
ATTACH_AST_OPERATIONS(AtRule)
|
498
580
|
ATTACH_CRTP_PERFORM_METHODS()
|
499
581
|
};
|
500
582
|
|
501
583
|
///////////////////////////////////////////////////////////////////////
|
502
584
|
// Keyframe-rules -- the child blocks of "@keyframes" nodes.
|
503
585
|
///////////////////////////////////////////////////////////////////////
|
504
|
-
class Keyframe_Rule final : public
|
586
|
+
class Keyframe_Rule final : public ParentStatement {
|
505
587
|
// according to css spec, this should be <keyframes-name>
|
506
588
|
// <keyframes-name> = <custom-ident> | <string>
|
507
|
-
ADD_PROPERTY(
|
589
|
+
ADD_PROPERTY(SelectorListObj, name)
|
508
590
|
public:
|
509
|
-
Keyframe_Rule(
|
591
|
+
Keyframe_Rule(SourceSpan pstate, Block_Obj b);
|
510
592
|
ATTACH_AST_OPERATIONS(Keyframe_Rule)
|
511
593
|
ATTACH_CRTP_PERFORM_METHODS()
|
512
594
|
};
|
@@ -514,14 +596,14 @@ namespace Sass {
|
|
514
596
|
////////////////////////////////////////////////////////////////////////
|
515
597
|
// Declarations -- style rules consisting of a property name and values.
|
516
598
|
////////////////////////////////////////////////////////////////////////
|
517
|
-
class Declaration final : public
|
599
|
+
class Declaration final : public ParentStatement {
|
518
600
|
ADD_PROPERTY(String_Obj, property)
|
519
|
-
ADD_PROPERTY(
|
601
|
+
ADD_PROPERTY(ExpressionObj, value)
|
520
602
|
ADD_PROPERTY(bool, is_important)
|
521
603
|
ADD_PROPERTY(bool, is_custom_property)
|
522
604
|
ADD_PROPERTY(bool, is_indented)
|
523
605
|
public:
|
524
|
-
Declaration(
|
606
|
+
Declaration(SourceSpan pstate, String_Obj prop, ExpressionObj val, bool i = false, bool c = false, Block_Obj b = {});
|
525
607
|
bool is_invisible() const override;
|
526
608
|
ATTACH_AST_OPERATIONS(Declaration)
|
527
609
|
ATTACH_CRTP_PERFORM_METHODS()
|
@@ -531,12 +613,12 @@ namespace Sass {
|
|
531
613
|
// Assignments -- variable and value.
|
532
614
|
/////////////////////////////////////
|
533
615
|
class Assignment final : public Statement {
|
534
|
-
ADD_CONSTREF(
|
535
|
-
ADD_PROPERTY(
|
616
|
+
ADD_CONSTREF(sass::string, variable)
|
617
|
+
ADD_PROPERTY(ExpressionObj, value)
|
536
618
|
ADD_PROPERTY(bool, is_default)
|
537
619
|
ADD_PROPERTY(bool, is_global)
|
538
620
|
public:
|
539
|
-
Assignment(
|
621
|
+
Assignment(SourceSpan pstate, sass::string var, ExpressionObj val, bool is_default = false, bool is_global = false);
|
540
622
|
ATTACH_AST_OPERATIONS(Assignment)
|
541
623
|
ATTACH_CRTP_PERFORM_METHODS()
|
542
624
|
};
|
@@ -546,13 +628,13 @@ namespace Sass {
|
|
546
628
|
// necessary to store a list of each in an Import node.
|
547
629
|
////////////////////////////////////////////////////////////////////////////
|
548
630
|
class Import final : public Statement {
|
549
|
-
|
550
|
-
|
631
|
+
sass::vector<ExpressionObj> urls_;
|
632
|
+
sass::vector<Include> incs_;
|
551
633
|
ADD_PROPERTY(List_Obj, import_queries);
|
552
634
|
public:
|
553
|
-
Import(
|
554
|
-
|
555
|
-
|
635
|
+
Import(SourceSpan pstate);
|
636
|
+
sass::vector<Include>& incs();
|
637
|
+
sass::vector<ExpressionObj>& urls();
|
556
638
|
ATTACH_AST_OPERATIONS(Import)
|
557
639
|
ATTACH_CRTP_PERFORM_METHODS()
|
558
640
|
};
|
@@ -562,10 +644,10 @@ namespace Sass {
|
|
562
644
|
class Import_Stub final : public Statement {
|
563
645
|
Include resource_;
|
564
646
|
public:
|
565
|
-
Import_Stub(
|
647
|
+
Import_Stub(SourceSpan pstate, Include res);
|
566
648
|
Include resource();
|
567
|
-
|
568
|
-
|
649
|
+
sass::string imp_path();
|
650
|
+
sass::string abs_path();
|
569
651
|
ATTACH_AST_OPERATIONS(Import_Stub)
|
570
652
|
ATTACH_CRTP_PERFORM_METHODS()
|
571
653
|
};
|
@@ -573,33 +655,33 @@ namespace Sass {
|
|
573
655
|
//////////////////////////////
|
574
656
|
// The Sass `@warn` directive.
|
575
657
|
//////////////////////////////
|
576
|
-
class
|
577
|
-
ADD_PROPERTY(
|
658
|
+
class WarningRule final : public Statement {
|
659
|
+
ADD_PROPERTY(ExpressionObj, message)
|
578
660
|
public:
|
579
|
-
|
580
|
-
ATTACH_AST_OPERATIONS(
|
661
|
+
WarningRule(SourceSpan pstate, ExpressionObj msg);
|
662
|
+
ATTACH_AST_OPERATIONS(WarningRule)
|
581
663
|
ATTACH_CRTP_PERFORM_METHODS()
|
582
664
|
};
|
583
665
|
|
584
666
|
///////////////////////////////
|
585
667
|
// The Sass `@error` directive.
|
586
668
|
///////////////////////////////
|
587
|
-
class
|
588
|
-
ADD_PROPERTY(
|
669
|
+
class ErrorRule final : public Statement {
|
670
|
+
ADD_PROPERTY(ExpressionObj, message)
|
589
671
|
public:
|
590
|
-
|
591
|
-
ATTACH_AST_OPERATIONS(
|
672
|
+
ErrorRule(SourceSpan pstate, ExpressionObj msg);
|
673
|
+
ATTACH_AST_OPERATIONS(ErrorRule)
|
592
674
|
ATTACH_CRTP_PERFORM_METHODS()
|
593
675
|
};
|
594
676
|
|
595
677
|
///////////////////////////////
|
596
678
|
// The Sass `@debug` directive.
|
597
679
|
///////////////////////////////
|
598
|
-
class
|
599
|
-
ADD_PROPERTY(
|
680
|
+
class DebugRule final : public Statement {
|
681
|
+
ADD_PROPERTY(ExpressionObj, value)
|
600
682
|
public:
|
601
|
-
|
602
|
-
ATTACH_AST_OPERATIONS(
|
683
|
+
DebugRule(SourceSpan pstate, ExpressionObj val);
|
684
|
+
ATTACH_AST_OPERATIONS(DebugRule)
|
603
685
|
ATTACH_CRTP_PERFORM_METHODS()
|
604
686
|
};
|
605
687
|
|
@@ -610,7 +692,7 @@ namespace Sass {
|
|
610
692
|
ADD_PROPERTY(String_Obj, text)
|
611
693
|
ADD_PROPERTY(bool, is_important)
|
612
694
|
public:
|
613
|
-
Comment(
|
695
|
+
Comment(SourceSpan pstate, String_Obj txt, bool is_important);
|
614
696
|
virtual bool is_invisible() const override;
|
615
697
|
ATTACH_AST_OPERATIONS(Comment)
|
616
698
|
ATTACH_CRTP_PERFORM_METHODS()
|
@@ -619,11 +701,11 @@ namespace Sass {
|
|
619
701
|
////////////////////////////////////
|
620
702
|
// The Sass `@if` control directive.
|
621
703
|
////////////////////////////////////
|
622
|
-
class If final : public
|
623
|
-
ADD_PROPERTY(
|
704
|
+
class If final : public ParentStatement {
|
705
|
+
ADD_PROPERTY(ExpressionObj, predicate)
|
624
706
|
ADD_PROPERTY(Block_Obj, alternative)
|
625
707
|
public:
|
626
|
-
If(
|
708
|
+
If(SourceSpan pstate, ExpressionObj pred, Block_Obj con, Block_Obj alt = {});
|
627
709
|
virtual bool has_content() override;
|
628
710
|
ATTACH_AST_OPERATIONS(If)
|
629
711
|
ATTACH_CRTP_PERFORM_METHODS()
|
@@ -632,37 +714,37 @@ namespace Sass {
|
|
632
714
|
/////////////////////////////////////
|
633
715
|
// The Sass `@for` control directive.
|
634
716
|
/////////////////////////////////////
|
635
|
-
class
|
636
|
-
ADD_CONSTREF(
|
637
|
-
ADD_PROPERTY(
|
638
|
-
ADD_PROPERTY(
|
717
|
+
class ForRule final : public ParentStatement {
|
718
|
+
ADD_CONSTREF(sass::string, variable)
|
719
|
+
ADD_PROPERTY(ExpressionObj, lower_bound)
|
720
|
+
ADD_PROPERTY(ExpressionObj, upper_bound)
|
639
721
|
ADD_PROPERTY(bool, is_inclusive)
|
640
722
|
public:
|
641
|
-
|
642
|
-
ATTACH_AST_OPERATIONS(
|
723
|
+
ForRule(SourceSpan pstate, sass::string var, ExpressionObj lo, ExpressionObj hi, Block_Obj b, bool inc);
|
724
|
+
ATTACH_AST_OPERATIONS(ForRule)
|
643
725
|
ATTACH_CRTP_PERFORM_METHODS()
|
644
726
|
};
|
645
727
|
|
646
728
|
//////////////////////////////////////
|
647
729
|
// The Sass `@each` control directive.
|
648
730
|
//////////////////////////////////////
|
649
|
-
class
|
650
|
-
ADD_PROPERTY(
|
651
|
-
ADD_PROPERTY(
|
731
|
+
class EachRule final : public ParentStatement {
|
732
|
+
ADD_PROPERTY(sass::vector<sass::string>, variables)
|
733
|
+
ADD_PROPERTY(ExpressionObj, list)
|
652
734
|
public:
|
653
|
-
|
654
|
-
ATTACH_AST_OPERATIONS(
|
735
|
+
EachRule(SourceSpan pstate, sass::vector<sass::string> vars, ExpressionObj lst, Block_Obj b);
|
736
|
+
ATTACH_AST_OPERATIONS(EachRule)
|
655
737
|
ATTACH_CRTP_PERFORM_METHODS()
|
656
738
|
};
|
657
739
|
|
658
740
|
///////////////////////////////////////
|
659
741
|
// The Sass `@while` control directive.
|
660
742
|
///////////////////////////////////////
|
661
|
-
class
|
662
|
-
ADD_PROPERTY(
|
743
|
+
class WhileRule final : public ParentStatement {
|
744
|
+
ADD_PROPERTY(ExpressionObj, predicate)
|
663
745
|
public:
|
664
|
-
|
665
|
-
ATTACH_AST_OPERATIONS(
|
746
|
+
WhileRule(SourceSpan pstate, ExpressionObj pred, Block_Obj b);
|
747
|
+
ATTACH_AST_OPERATIONS(WhileRule)
|
666
748
|
ATTACH_CRTP_PERFORM_METHODS()
|
667
749
|
};
|
668
750
|
|
@@ -670,32 +752,21 @@ namespace Sass {
|
|
670
752
|
// The @return directive for use inside SassScript functions.
|
671
753
|
/////////////////////////////////////////////////////////////
|
672
754
|
class Return final : public Statement {
|
673
|
-
ADD_PROPERTY(
|
755
|
+
ADD_PROPERTY(ExpressionObj, value)
|
674
756
|
public:
|
675
|
-
Return(
|
757
|
+
Return(SourceSpan pstate, ExpressionObj val);
|
676
758
|
ATTACH_AST_OPERATIONS(Return)
|
677
759
|
ATTACH_CRTP_PERFORM_METHODS()
|
678
760
|
};
|
679
761
|
|
680
|
-
////////////////////////////////
|
681
|
-
// The Sass `@extend` directive.
|
682
|
-
////////////////////////////////
|
683
|
-
class Extension final : public Statement {
|
684
|
-
ADD_PROPERTY(Selector_List_Obj, selector)
|
685
|
-
public:
|
686
|
-
Extension(ParserState pstate, Selector_List_Obj s);
|
687
|
-
ATTACH_AST_OPERATIONS(Extension)
|
688
|
-
ATTACH_CRTP_PERFORM_METHODS()
|
689
|
-
};
|
690
|
-
|
691
762
|
/////////////////////////////////////////////////////////////////////////////
|
692
763
|
// Definitions for both mixins and functions. The two cases are distinguished
|
693
764
|
// by a type tag.
|
694
765
|
/////////////////////////////////////////////////////////////////////////////
|
695
|
-
class Definition final : public
|
766
|
+
class Definition final : public ParentStatement {
|
696
767
|
public:
|
697
768
|
enum Type { MIXIN, FUNCTION };
|
698
|
-
ADD_CONSTREF(
|
769
|
+
ADD_CONSTREF(sass::string, name)
|
699
770
|
ADD_PROPERTY(Parameters_Obj, parameters)
|
700
771
|
ADD_PROPERTY(Env*, environment)
|
701
772
|
ADD_PROPERTY(Type, type)
|
@@ -705,20 +776,20 @@ namespace Sass {
|
|
705
776
|
ADD_PROPERTY(bool, is_overload_stub)
|
706
777
|
ADD_PROPERTY(Signature, signature)
|
707
778
|
public:
|
708
|
-
Definition(
|
709
|
-
|
779
|
+
Definition(SourceSpan pstate,
|
780
|
+
sass::string n,
|
710
781
|
Parameters_Obj params,
|
711
782
|
Block_Obj b,
|
712
783
|
Type t);
|
713
|
-
Definition(
|
784
|
+
Definition(SourceSpan pstate,
|
714
785
|
Signature sig,
|
715
|
-
|
786
|
+
sass::string n,
|
716
787
|
Parameters_Obj params,
|
717
788
|
Native_Function func_ptr,
|
718
789
|
bool overload_stub = false);
|
719
|
-
Definition(
|
790
|
+
Definition(SourceSpan pstate,
|
720
791
|
Signature sig,
|
721
|
-
|
792
|
+
sass::string n,
|
722
793
|
Parameters_Obj params,
|
723
794
|
Sass_Function_Entry c_func);
|
724
795
|
ATTACH_AST_OPERATIONS(Definition)
|
@@ -728,12 +799,12 @@ namespace Sass {
|
|
728
799
|
//////////////////////////////////////
|
729
800
|
// Mixin calls (i.e., `@include ...`).
|
730
801
|
//////////////////////////////////////
|
731
|
-
class Mixin_Call final : public
|
732
|
-
ADD_CONSTREF(
|
802
|
+
class Mixin_Call final : public ParentStatement {
|
803
|
+
ADD_CONSTREF(sass::string, name)
|
733
804
|
ADD_PROPERTY(Arguments_Obj, arguments)
|
734
805
|
ADD_PROPERTY(Parameters_Obj, block_parameters)
|
735
806
|
public:
|
736
|
-
Mixin_Call(
|
807
|
+
Mixin_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Parameters_Obj b_params = {}, Block_Obj b = {});
|
737
808
|
ATTACH_AST_OPERATIONS(Mixin_Call)
|
738
809
|
ATTACH_CRTP_PERFORM_METHODS()
|
739
810
|
};
|
@@ -744,7 +815,7 @@ namespace Sass {
|
|
744
815
|
class Content final : public Statement {
|
745
816
|
ADD_PROPERTY(Arguments_Obj, arguments)
|
746
817
|
public:
|
747
|
-
Content(
|
818
|
+
Content(SourceSpan pstate, Arguments_Obj args);
|
748
819
|
ATTACH_AST_OPERATIONS(Content)
|
749
820
|
ATTACH_CRTP_PERFORM_METHODS()
|
750
821
|
};
|
@@ -757,11 +828,11 @@ namespace Sass {
|
|
757
828
|
enum Type { PLUS, MINUS, NOT, SLASH };
|
758
829
|
private:
|
759
830
|
HASH_PROPERTY(Type, optype)
|
760
|
-
HASH_PROPERTY(
|
831
|
+
HASH_PROPERTY(ExpressionObj, operand)
|
761
832
|
mutable size_t hash_;
|
762
833
|
public:
|
763
|
-
Unary_Expression(
|
764
|
-
const
|
834
|
+
Unary_Expression(SourceSpan pstate, Type t, ExpressionObj o);
|
835
|
+
const sass::string type_name();
|
765
836
|
virtual bool operator==(const Expression& rhs) const override;
|
766
837
|
size_t hash() const override;
|
767
838
|
ATTACH_AST_OPERATIONS(Unary_Expression)
|
@@ -772,13 +843,13 @@ namespace Sass {
|
|
772
843
|
// Individual argument objects for mixin and function calls.
|
773
844
|
////////////////////////////////////////////////////////////
|
774
845
|
class Argument final : public Expression {
|
775
|
-
HASH_PROPERTY(
|
776
|
-
HASH_CONSTREF(
|
846
|
+
HASH_PROPERTY(ExpressionObj, value)
|
847
|
+
HASH_CONSTREF(sass::string, name)
|
777
848
|
ADD_PROPERTY(bool, is_rest_argument)
|
778
849
|
ADD_PROPERTY(bool, is_keyword_argument)
|
779
850
|
mutable size_t hash_;
|
780
851
|
public:
|
781
|
-
Argument(
|
852
|
+
Argument(SourceSpan pstate, ExpressionObj val, sass::string n = "", bool rest = false, bool keyword = false);
|
782
853
|
void set_delayed(bool delayed) override;
|
783
854
|
bool operator==(const Expression& rhs) const override;
|
784
855
|
size_t hash() const override;
|
@@ -798,7 +869,7 @@ namespace Sass {
|
|
798
869
|
protected:
|
799
870
|
void adjust_after_pushing(Argument_Obj a) override;
|
800
871
|
public:
|
801
|
-
Arguments(
|
872
|
+
Arguments(SourceSpan pstate);
|
802
873
|
void set_delayed(bool delayed) override;
|
803
874
|
Argument_Obj get_rest_argument();
|
804
875
|
Argument_Obj get_keyword_argument();
|
@@ -806,29 +877,117 @@ namespace Sass {
|
|
806
877
|
ATTACH_CRTP_PERFORM_METHODS()
|
807
878
|
};
|
808
879
|
|
809
|
-
|
810
|
-
// Media
|
811
|
-
|
880
|
+
|
881
|
+
// A Media StyleRule before it has been evaluated
|
882
|
+
// Could be already final or an interpolation
|
883
|
+
class MediaRule final : public ParentStatement {
|
884
|
+
ADD_PROPERTY(List_Obj, schema)
|
885
|
+
public:
|
886
|
+
MediaRule(SourceSpan pstate, Block_Obj block = {});
|
887
|
+
|
888
|
+
bool bubbles() override { return true; };
|
889
|
+
bool is_invisible() const override { return false; };
|
890
|
+
ATTACH_AST_OPERATIONS(MediaRule)
|
891
|
+
ATTACH_CRTP_PERFORM_METHODS()
|
892
|
+
};
|
893
|
+
|
894
|
+
// A Media StyleRule after it has been evaluated
|
895
|
+
// Representing the static or resulting css
|
896
|
+
class CssMediaRule final : public ParentStatement,
|
897
|
+
public Vectorized<CssMediaQuery_Obj> {
|
898
|
+
public:
|
899
|
+
CssMediaRule(SourceSpan pstate, Block_Obj b);
|
900
|
+
bool bubbles() override { return true; };
|
901
|
+
bool isInvisible() const { return empty(); }
|
902
|
+
bool is_invisible() const override { return false; };
|
903
|
+
|
904
|
+
public:
|
905
|
+
// Hash and equality implemtation from vector
|
906
|
+
size_t hash() const override { return Vectorized::hash(); }
|
907
|
+
// Check if two instances are considered equal
|
908
|
+
bool operator== (const CssMediaRule& rhs) const {
|
909
|
+
return Vectorized::operator== (rhs);
|
910
|
+
}
|
911
|
+
bool operator!=(const CssMediaRule& rhs) const {
|
912
|
+
// Invert from equality
|
913
|
+
return !(*this == rhs);
|
914
|
+
}
|
915
|
+
|
916
|
+
ATTACH_AST_OPERATIONS(CssMediaRule)
|
917
|
+
ATTACH_CRTP_PERFORM_METHODS()
|
918
|
+
};
|
919
|
+
|
920
|
+
// Media Queries after they have been evaluated
|
921
|
+
// Representing the static or resulting css
|
922
|
+
class CssMediaQuery final : public AST_Node {
|
923
|
+
|
924
|
+
// The modifier, probably either "not" or "only".
|
925
|
+
// This may be `null` if no modifier is in use.
|
926
|
+
ADD_PROPERTY(sass::string, modifier);
|
927
|
+
|
928
|
+
// The media type, for example "screen" or "print".
|
929
|
+
// This may be `null`. If so, [features] will not be empty.
|
930
|
+
ADD_PROPERTY(sass::string, type);
|
931
|
+
|
932
|
+
// Feature queries, including parentheses.
|
933
|
+
ADD_PROPERTY(sass::vector<sass::string>, features);
|
934
|
+
|
935
|
+
public:
|
936
|
+
CssMediaQuery(SourceSpan pstate);
|
937
|
+
|
938
|
+
// Check if two instances are considered equal
|
939
|
+
bool operator== (const CssMediaQuery& rhs) const;
|
940
|
+
bool operator!=(const CssMediaQuery& rhs) const {
|
941
|
+
// Invert from equality
|
942
|
+
return !(*this == rhs);
|
943
|
+
}
|
944
|
+
|
945
|
+
// Returns true if this query is empty
|
946
|
+
// Meaning it has no type and features
|
947
|
+
bool empty() const {
|
948
|
+
return type_.empty()
|
949
|
+
&& modifier_.empty()
|
950
|
+
&& features_.empty();
|
951
|
+
}
|
952
|
+
|
953
|
+
// Whether this media query matches all media types.
|
954
|
+
bool matchesAllTypes() const {
|
955
|
+
return type_.empty() || Util::equalsLiteral("all", type_);
|
956
|
+
}
|
957
|
+
|
958
|
+
// Merges this with [other] and adds a query that matches the intersection
|
959
|
+
// of both inputs to [result]. Returns false if the result is unrepresentable
|
960
|
+
CssMediaQuery_Obj merge(CssMediaQuery_Obj& other);
|
961
|
+
|
962
|
+
ATTACH_AST_OPERATIONS(CssMediaQuery)
|
963
|
+
ATTACH_CRTP_PERFORM_METHODS()
|
964
|
+
};
|
965
|
+
|
966
|
+
////////////////////////////////////////////////////
|
967
|
+
// Media queries (replaced by MediaRule at al).
|
968
|
+
// ToDo: only used for interpolation case
|
969
|
+
////////////////////////////////////////////////////
|
812
970
|
class Media_Query final : public Expression,
|
813
|
-
public Vectorized<
|
971
|
+
public Vectorized<Media_Query_ExpressionObj> {
|
814
972
|
ADD_PROPERTY(String_Obj, media_type)
|
815
973
|
ADD_PROPERTY(bool, is_negated)
|
816
974
|
ADD_PROPERTY(bool, is_restricted)
|
817
975
|
public:
|
818
|
-
Media_Query(
|
976
|
+
Media_Query(SourceSpan pstate, String_Obj t = {}, size_t s = 0, bool n = false, bool r = false);
|
819
977
|
ATTACH_AST_OPERATIONS(Media_Query)
|
820
978
|
ATTACH_CRTP_PERFORM_METHODS()
|
821
979
|
};
|
822
980
|
|
823
981
|
////////////////////////////////////////////////////
|
824
982
|
// Media expressions (for use inside media queries).
|
983
|
+
// ToDo: only used for interpolation case
|
825
984
|
////////////////////////////////////////////////////
|
826
985
|
class Media_Query_Expression final : public Expression {
|
827
|
-
ADD_PROPERTY(
|
828
|
-
ADD_PROPERTY(
|
986
|
+
ADD_PROPERTY(ExpressionObj, feature)
|
987
|
+
ADD_PROPERTY(ExpressionObj, value)
|
829
988
|
ADD_PROPERTY(bool, is_interpolated)
|
830
989
|
public:
|
831
|
-
Media_Query_Expression(
|
990
|
+
Media_Query_Expression(SourceSpan pstate, ExpressionObj f, ExpressionObj v, bool i = false);
|
832
991
|
ATTACH_AST_OPERATIONS(Media_Query_Expression)
|
833
992
|
ATTACH_CRTP_PERFORM_METHODS()
|
834
993
|
};
|
@@ -838,11 +997,11 @@ namespace Sass {
|
|
838
997
|
/////////////////////////////////////////////////
|
839
998
|
class At_Root_Query final : public Expression {
|
840
999
|
private:
|
841
|
-
ADD_PROPERTY(
|
842
|
-
ADD_PROPERTY(
|
1000
|
+
ADD_PROPERTY(ExpressionObj, feature)
|
1001
|
+
ADD_PROPERTY(ExpressionObj, value)
|
843
1002
|
public:
|
844
|
-
At_Root_Query(
|
845
|
-
bool exclude(
|
1003
|
+
At_Root_Query(SourceSpan pstate, ExpressionObj f = {}, ExpressionObj v = {}, bool i = false);
|
1004
|
+
bool exclude(sass::string str);
|
846
1005
|
ATTACH_AST_OPERATIONS(At_Root_Query)
|
847
1006
|
ATTACH_CRTP_PERFORM_METHODS()
|
848
1007
|
};
|
@@ -850,13 +1009,13 @@ namespace Sass {
|
|
850
1009
|
///////////
|
851
1010
|
// At-root.
|
852
1011
|
///////////
|
853
|
-
class
|
1012
|
+
class AtRootRule final : public ParentStatement {
|
854
1013
|
ADD_PROPERTY(At_Root_Query_Obj, expression)
|
855
1014
|
public:
|
856
|
-
|
1015
|
+
AtRootRule(SourceSpan pstate, Block_Obj b = {}, At_Root_Query_Obj e = {});
|
857
1016
|
bool bubbles() override;
|
858
1017
|
bool exclude_node(Statement_Obj s);
|
859
|
-
ATTACH_AST_OPERATIONS(
|
1018
|
+
ATTACH_AST_OPERATIONS(AtRootRule)
|
860
1019
|
ATTACH_CRTP_PERFORM_METHODS()
|
861
1020
|
};
|
862
1021
|
|
@@ -864,11 +1023,11 @@ namespace Sass {
|
|
864
1023
|
// Individual parameter objects for mixins and functions.
|
865
1024
|
/////////////////////////////////////////////////////////
|
866
1025
|
class Parameter final : public AST_Node {
|
867
|
-
ADD_CONSTREF(
|
868
|
-
ADD_PROPERTY(
|
1026
|
+
ADD_CONSTREF(sass::string, name)
|
1027
|
+
ADD_PROPERTY(ExpressionObj, default_value)
|
869
1028
|
ADD_PROPERTY(bool, is_rest_parameter)
|
870
1029
|
public:
|
871
|
-
Parameter(
|
1030
|
+
Parameter(SourceSpan pstate, sass::string n, ExpressionObj def = {}, bool rest = false);
|
872
1031
|
ATTACH_AST_OPERATIONS(Parameter)
|
873
1032
|
ATTACH_CRTP_PERFORM_METHODS()
|
874
1033
|
};
|
@@ -884,7 +1043,7 @@ namespace Sass {
|
|
884
1043
|
protected:
|
885
1044
|
void adjust_after_pushing(Parameter_Obj p) override;
|
886
1045
|
public:
|
887
|
-
Parameters(
|
1046
|
+
Parameters(SourceSpan pstate);
|
888
1047
|
ATTACH_AST_OPERATIONS(Parameters)
|
889
1048
|
ATTACH_CRTP_PERFORM_METHODS()
|
890
1049
|
};
|