sassc 2.3.0 → 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 +1 -0
- data/CHANGELOG.md +5 -0
- data/ext/libsass/VERSION +1 -1
- data/ext/libsass/include/sass/context.h +3 -0
- data/ext/libsass/src/MurmurHash2.hpp +91 -0
- data/ext/libsass/src/ast.cpp +117 -117
- data/ext/libsass/src/ast.hpp +160 -162
- data/ext/libsass/src/ast_def_macros.hpp +10 -10
- data/ext/libsass/src/ast_fwd_decl.cpp +2 -2
- data/ext/libsass/src/ast_fwd_decl.hpp +61 -52
- data/ext/libsass/src/ast_helpers.hpp +5 -5
- data/ext/libsass/src/ast_sel_cmp.cpp +18 -18
- data/ext/libsass/src/ast_sel_super.cpp +52 -52
- data/ext/libsass/src/ast_sel_unify.cpp +16 -16
- data/ext/libsass/src/ast_sel_weave.cpp +62 -62
- data/ext/libsass/src/ast_selectors.cpp +87 -77
- data/ext/libsass/src/ast_selectors.hpp +72 -62
- data/ext/libsass/src/ast_supports.cpp +35 -35
- data/ext/libsass/src/ast_supports.hpp +29 -29
- data/ext/libsass/src/ast_values.cpp +58 -58
- data/ext/libsass/src/ast_values.hpp +75 -75
- 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 +17 -17
- 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/check_nesting.cpp +36 -36
- data/ext/libsass/src/check_nesting.hpp +2 -2
- data/ext/libsass/src/color_maps.cpp +5 -5
- data/ext/libsass/src/color_maps.hpp +1 -1
- data/ext/libsass/src/context.cpp +63 -60
- data/ext/libsass/src/context.hpp +33 -33
- data/ext/libsass/src/cssize.cpp +30 -29
- data/ext/libsass/src/cssize.hpp +13 -13
- data/ext/libsass/src/dart_helpers.hpp +5 -5
- data/ext/libsass/src/debugger.hpp +127 -128
- data/ext/libsass/src/emitter.cpp +12 -12
- data/ext/libsass/src/emitter.hpp +10 -10
- data/ext/libsass/src/environment.cpp +27 -27
- data/ext/libsass/src/environment.hpp +24 -24
- data/ext/libsass/src/error_handling.cpp +42 -42
- data/ext/libsass/src/error_handling.hpp +38 -50
- data/ext/libsass/src/eval.cpp +138 -132
- data/ext/libsass/src/eval.hpp +17 -17
- data/ext/libsass/src/eval_selectors.cpp +3 -3
- data/ext/libsass/src/expand.cpp +70 -64
- data/ext/libsass/src/expand.hpp +12 -12
- data/ext/libsass/src/extender.cpp +55 -53
- data/ext/libsass/src/extender.hpp +14 -14
- data/ext/libsass/src/file.cpp +66 -58
- data/ext/libsass/src/file.hpp +23 -25
- data/ext/libsass/src/fn_colors.cpp +9 -9
- data/ext/libsass/src/fn_lists.cpp +18 -18
- data/ext/libsass/src/fn_maps.cpp +3 -3
- data/ext/libsass/src/fn_miscs.cpp +15 -15
- data/ext/libsass/src/fn_numbers.cpp +7 -7
- data/ext/libsass/src/fn_selectors.cpp +8 -8
- data/ext/libsass/src/fn_strings.cpp +34 -22
- data/ext/libsass/src/fn_utils.cpp +29 -26
- data/ext/libsass/src/fn_utils.hpp +10 -10
- data/ext/libsass/src/inspect.cpp +35 -34
- data/ext/libsass/src/inspect.hpp +21 -21
- data/ext/libsass/src/lexer.cpp +3 -1
- data/ext/libsass/src/listize.cpp +2 -2
- 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} +18 -6
- data/ext/libsass/src/operation.hpp +44 -44
- data/ext/libsass/src/operators.cpp +18 -18
- data/ext/libsass/src/operators.hpp +11 -11
- data/ext/libsass/src/ordered_map.hpp +18 -18
- data/ext/libsass/src/output.cpp +16 -16
- data/ext/libsass/src/output.hpp +5 -5
- data/ext/libsass/src/parser.cpp +327 -345
- data/ext/libsass/src/parser.hpp +77 -87
- data/ext/libsass/src/parser_selectors.cpp +6 -6
- data/ext/libsass/src/permutate.hpp +39 -15
- 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/remove_placeholders.cpp +4 -4
- data/ext/libsass/src/remove_placeholders.hpp +3 -3
- data/ext/libsass/src/sass.cpp +16 -15
- data/ext/libsass/src/sass.hpp +9 -5
- data/ext/libsass/src/sass_context.cpp +52 -34
- data/ext/libsass/src/sass_values.cpp +8 -10
- 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/units.cpp +19 -19
- 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 +38 -38
- data/ext/libsass/src/util.hpp +18 -18
- data/ext/libsass/src/util_string.cpp +13 -13
- data/ext/libsass/src/util_string.hpp +9 -8
- data/ext/libsass/src/values.cpp +12 -12
- data/lib/sassc/native.rb +3 -5
- data/lib/sassc/version.rb +1 -1
- data/test/native_test.rb +4 -4
- metadata +14 -5
- data/lib/sassc/native/lib_c.rb +0 -21
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA256:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: 75155de90eb3449ed2a1214ca6ab2b82ffe69b144c2a8eaf8a6a4fd522b58ea4
|
4
|
+
data.tar.gz: 8575ebe24a2d56a9bea0e4574ebd23753e283d3b34bf571489f318a357bce2b9
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: ae3eb9431fb5d9de9e1c1759844e1144aba73f59b7de40e1b06d77ba5567bc894a2f0a4ef2d3b6dcce9226044d52de5eeacb7759e715f3eb1bd4818b56b9876c
|
7
|
+
data.tar.gz: e4a07f5789ec2d9f4dbf04bfaf13b5d12224cf4ffd9f72721fac8edfd10eb2b7085af53d70248ce78112ee7af0ea06fb5e452388997eab810d07bd5a7de08a5c
|
data/.travis.yml
CHANGED
data/CHANGELOG.md
CHANGED
@@ -1,3 +1,8 @@
|
|
1
|
+
- **2.4.0**
|
2
|
+
- [Update libsass to 3.6.4](https://github.com/sass/sassc-ruby/pull/199)
|
3
|
+
- [Use FFI::MemoryPointer instead of libc's malloc()](https://github.com/sass/sassc-ruby/pull/205)
|
4
|
+
- [Test against Ruby 2.7.0](https://github.com/sass/sassc-ruby/pull/193)
|
5
|
+
|
1
6
|
- **2.3.0**
|
2
7
|
- [Fix rake gem:native task](https://github.com/sass/sassc-ruby/pull/196)
|
3
8
|
- [disable lto flag for darwin + nix](https://github.com/sass/sassc-ruby/pull/166)
|
data/ext/libsass/VERSION
CHANGED
@@ -1 +1 @@
|
|
1
|
-
3.6.
|
1
|
+
3.6.4
|
@@ -125,6 +125,9 @@ ADDAPI char** ADDCALL sass_context_get_included_files (struct Sass_Context* ctx)
|
|
125
125
|
// Getters for options include path array
|
126
126
|
ADDAPI size_t ADDCALL sass_option_get_include_path_size(struct Sass_Options* options);
|
127
127
|
ADDAPI const char* ADDCALL sass_option_get_include_path(struct Sass_Options* options, size_t i);
|
128
|
+
// Plugin paths to load dynamic libraries work the same
|
129
|
+
ADDAPI size_t ADDCALL sass_option_get_plugin_path_size(struct Sass_Options* options);
|
130
|
+
ADDAPI const char* ADDCALL sass_option_get_plugin_path(struct Sass_Options* options, size_t i);
|
128
131
|
|
129
132
|
// Calculate the size of the stored null terminated array
|
130
133
|
ADDAPI size_t ADDCALL sass_context_get_included_files_size (struct Sass_Context* ctx);
|
@@ -0,0 +1,91 @@
|
|
1
|
+
//-----------------------------------------------------------------------------
|
2
|
+
// MurmurHash2 was written by Austin Appleby, and is placed in the public
|
3
|
+
// domain. The author hereby disclaims copyright to this source code.
|
4
|
+
//-----------------------------------------------------------------------------
|
5
|
+
// LibSass only needs MurmurHash2, so we made this header only
|
6
|
+
//-----------------------------------------------------------------------------
|
7
|
+
|
8
|
+
#ifndef _MURMURHASH2_H_
|
9
|
+
#define _MURMURHASH2_H_
|
10
|
+
|
11
|
+
//-----------------------------------------------------------------------------
|
12
|
+
// Platform-specific functions and macros
|
13
|
+
|
14
|
+
// Microsoft Visual Studio
|
15
|
+
|
16
|
+
#if defined(_MSC_VER) && (_MSC_VER < 1600)
|
17
|
+
|
18
|
+
typedef unsigned char uint8_t;
|
19
|
+
typedef unsigned int uint32_t;
|
20
|
+
typedef unsigned __int64 uint64_t;
|
21
|
+
|
22
|
+
// Other compilers
|
23
|
+
|
24
|
+
#else // defined(_MSC_VER)
|
25
|
+
|
26
|
+
#include <stdint.h>
|
27
|
+
|
28
|
+
#endif // !defined(_MSC_VER)
|
29
|
+
|
30
|
+
//-----------------------------------------------------------------------------
|
31
|
+
|
32
|
+
inline uint32_t MurmurHash2 ( const void * key, int len, uint32_t seed )
|
33
|
+
{
|
34
|
+
// 'm' and 'r' are mixing constants generated offline.
|
35
|
+
// They're not really 'magic', they just happen to work well.
|
36
|
+
|
37
|
+
const uint32_t m = 0x5bd1e995;
|
38
|
+
const int r = 24;
|
39
|
+
|
40
|
+
// Initialize the hash to a 'random' value
|
41
|
+
|
42
|
+
uint32_t h = seed ^ len;
|
43
|
+
|
44
|
+
// Mix 4 bytes at a time into the hash
|
45
|
+
|
46
|
+
const unsigned char * data = (const unsigned char *)key;
|
47
|
+
|
48
|
+
while(len >= 4)
|
49
|
+
{
|
50
|
+
uint32_t k = *(uint32_t*)data;
|
51
|
+
|
52
|
+
k *= m;
|
53
|
+
k ^= k >> r;
|
54
|
+
k *= m;
|
55
|
+
|
56
|
+
h *= m;
|
57
|
+
h ^= k;
|
58
|
+
|
59
|
+
data += 4;
|
60
|
+
len -= 4;
|
61
|
+
}
|
62
|
+
|
63
|
+
// Handle the last few bytes of the input array
|
64
|
+
|
65
|
+
switch(len)
|
66
|
+
{
|
67
|
+
case 3:
|
68
|
+
h ^= data[2] << 16;
|
69
|
+
/* fall through */
|
70
|
+
case 2:
|
71
|
+
h ^= data[1] << 8;
|
72
|
+
/* fall through */
|
73
|
+
case 1:
|
74
|
+
h ^= data[0];
|
75
|
+
h *= m;
|
76
|
+
};
|
77
|
+
|
78
|
+
// Do a few final mixes of the hash to ensure the last few
|
79
|
+
// bytes are well-incorporated.
|
80
|
+
|
81
|
+
h ^= h >> 13;
|
82
|
+
h *= m;
|
83
|
+
h ^= h >> 15;
|
84
|
+
|
85
|
+
return h;
|
86
|
+
}
|
87
|
+
|
88
|
+
//-----------------------------------------------------------------------------
|
89
|
+
|
90
|
+
#endif // _MURMURHASH2_H_
|
91
|
+
|
data/ext/libsass/src/ast.cpp
CHANGED
@@ -6,7 +6,7 @@
|
|
6
6
|
|
7
7
|
namespace Sass {
|
8
8
|
|
9
|
-
static Null sass_null(
|
9
|
+
static Null sass_null(SourceSpan("null"));
|
10
10
|
|
11
11
|
const char* sass_op_to_name(enum Sass_OP op) {
|
12
12
|
switch (op) {
|
@@ -53,12 +53,12 @@ namespace Sass {
|
|
53
53
|
/////////////////////////////////////////////////////////////////////////
|
54
54
|
/////////////////////////////////////////////////////////////////////////
|
55
55
|
|
56
|
-
void AST_Node::update_pstate(const
|
56
|
+
void AST_Node::update_pstate(const SourceSpan& pstate)
|
57
57
|
{
|
58
|
-
pstate_.offset += pstate - pstate_ + pstate.offset;
|
58
|
+
pstate_.offset += pstate.position - pstate_.position + pstate.offset;
|
59
59
|
}
|
60
60
|
|
61
|
-
|
61
|
+
sass::string AST_Node::to_string(Sass_Inspect_Options opt) const
|
62
62
|
{
|
63
63
|
Sass_Output_Options out(opt);
|
64
64
|
Emitter emitter(out);
|
@@ -69,7 +69,7 @@ namespace Sass {
|
|
69
69
|
return i.get_buffer();
|
70
70
|
}
|
71
71
|
|
72
|
-
|
72
|
+
sass::string AST_Node::to_css(Sass_Inspect_Options opt) const
|
73
73
|
{
|
74
74
|
opt.output_style = TO_CSS;
|
75
75
|
Sass_Output_Options out(opt);
|
@@ -81,7 +81,7 @@ namespace Sass {
|
|
81
81
|
return i.get_buffer();
|
82
82
|
}
|
83
83
|
|
84
|
-
|
84
|
+
sass::string AST_Node::to_string() const
|
85
85
|
{
|
86
86
|
return to_string({ NESTED, 5 });
|
87
87
|
}
|
@@ -89,7 +89,7 @@ namespace Sass {
|
|
89
89
|
/////////////////////////////////////////////////////////////////////////
|
90
90
|
/////////////////////////////////////////////////////////////////////////
|
91
91
|
|
92
|
-
Statement::Statement(
|
92
|
+
Statement::Statement(SourceSpan pstate, Type st, size_t t)
|
93
93
|
: AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)
|
94
94
|
{ }
|
95
95
|
Statement::Statement(const Statement* ptr)
|
@@ -117,7 +117,7 @@ namespace Sass {
|
|
117
117
|
/////////////////////////////////////////////////////////////////////////
|
118
118
|
/////////////////////////////////////////////////////////////////////////
|
119
119
|
|
120
|
-
Block::Block(
|
120
|
+
Block::Block(SourceSpan pstate, size_t s, bool r)
|
121
121
|
: Statement(pstate),
|
122
122
|
Vectorized<Statement_Obj>(s),
|
123
123
|
is_root_(r)
|
@@ -147,14 +147,14 @@ namespace Sass {
|
|
147
147
|
/////////////////////////////////////////////////////////////////////////
|
148
148
|
/////////////////////////////////////////////////////////////////////////
|
149
149
|
|
150
|
-
|
150
|
+
ParentStatement::ParentStatement(SourceSpan pstate, Block_Obj b)
|
151
151
|
: Statement(pstate), block_(b)
|
152
152
|
{ }
|
153
|
-
|
153
|
+
ParentStatement::ParentStatement(const ParentStatement* ptr)
|
154
154
|
: Statement(ptr), block_(ptr->block_)
|
155
155
|
{ }
|
156
156
|
|
157
|
-
bool
|
157
|
+
bool ParentStatement::has_content()
|
158
158
|
{
|
159
159
|
return (block_ && block_->has_content()) || Statement::has_content();
|
160
160
|
}
|
@@ -162,17 +162,17 @@ namespace Sass {
|
|
162
162
|
/////////////////////////////////////////////////////////////////////////
|
163
163
|
/////////////////////////////////////////////////////////////////////////
|
164
164
|
|
165
|
-
|
166
|
-
:
|
165
|
+
StyleRule::StyleRule(SourceSpan pstate, SelectorListObj s, Block_Obj b)
|
166
|
+
: ParentStatement(pstate, b), selector_(s), schema_(), is_root_(false)
|
167
167
|
{ statement_type(RULESET); }
|
168
|
-
|
169
|
-
:
|
168
|
+
StyleRule::StyleRule(const StyleRule* ptr)
|
169
|
+
: ParentStatement(ptr),
|
170
170
|
selector_(ptr->selector_),
|
171
171
|
schema_(ptr->schema_),
|
172
172
|
is_root_(ptr->is_root_)
|
173
173
|
{ statement_type(RULESET); }
|
174
174
|
|
175
|
-
bool
|
175
|
+
bool StyleRule::is_invisible() const {
|
176
176
|
if (const SelectorList * sl = Cast<SelectorList>(selector())) {
|
177
177
|
for (size_t i = 0, L = sl->length(); i < L; i += 1)
|
178
178
|
if (!(*sl)[i]->isInvisible()) return false;
|
@@ -183,7 +183,7 @@ namespace Sass {
|
|
183
183
|
/////////////////////////////////////////////////////////////////////////
|
184
184
|
/////////////////////////////////////////////////////////////////////////
|
185
185
|
|
186
|
-
Bubble::Bubble(
|
186
|
+
Bubble::Bubble(SourceSpan pstate, Statement_Obj n, Statement_Obj g, size_t t)
|
187
187
|
: Statement(pstate, Statement::BUBBLE, t), node_(n), group_end_(g == nullptr)
|
188
188
|
{ }
|
189
189
|
Bubble::Bubble(const Bubble* ptr)
|
@@ -200,11 +200,11 @@ namespace Sass {
|
|
200
200
|
/////////////////////////////////////////////////////////////////////////
|
201
201
|
/////////////////////////////////////////////////////////////////////////
|
202
202
|
|
203
|
-
Trace::Trace(
|
204
|
-
:
|
203
|
+
Trace::Trace(SourceSpan pstate, sass::string n, Block_Obj b, char type)
|
204
|
+
: ParentStatement(pstate, b), type_(type), name_(n)
|
205
205
|
{ }
|
206
206
|
Trace::Trace(const Trace* ptr)
|
207
|
-
:
|
207
|
+
: ParentStatement(ptr),
|
208
208
|
type_(ptr->type_),
|
209
209
|
name_(ptr->name_)
|
210
210
|
{ }
|
@@ -212,25 +212,25 @@ namespace Sass {
|
|
212
212
|
/////////////////////////////////////////////////////////////////////////
|
213
213
|
/////////////////////////////////////////////////////////////////////////
|
214
214
|
|
215
|
-
|
216
|
-
:
|
215
|
+
AtRule::AtRule(SourceSpan pstate, sass::string kwd, SelectorListObj sel, Block_Obj b, ExpressionObj val)
|
216
|
+
: ParentStatement(pstate, b), keyword_(kwd), selector_(sel), value_(val) // set value manually if needed
|
217
217
|
{ statement_type(DIRECTIVE); }
|
218
|
-
|
219
|
-
:
|
218
|
+
AtRule::AtRule(const AtRule* ptr)
|
219
|
+
: ParentStatement(ptr),
|
220
220
|
keyword_(ptr->keyword_),
|
221
221
|
selector_(ptr->selector_),
|
222
222
|
value_(ptr->value_) // set value manually if needed
|
223
223
|
{ statement_type(DIRECTIVE); }
|
224
224
|
|
225
|
-
bool
|
225
|
+
bool AtRule::bubbles() { return is_keyframes() || is_media(); }
|
226
226
|
|
227
|
-
bool
|
227
|
+
bool AtRule::is_media() {
|
228
228
|
return keyword_.compare("@-webkit-media") == 0 ||
|
229
229
|
keyword_.compare("@-moz-media") == 0 ||
|
230
230
|
keyword_.compare("@-o-media") == 0 ||
|
231
231
|
keyword_.compare("@media") == 0;
|
232
232
|
}
|
233
|
-
bool
|
233
|
+
bool AtRule::is_keyframes() {
|
234
234
|
return keyword_.compare("@-webkit-keyframes") == 0 ||
|
235
235
|
keyword_.compare("@-moz-keyframes") == 0 ||
|
236
236
|
keyword_.compare("@-o-keyframes") == 0 ||
|
@@ -240,21 +240,21 @@ namespace Sass {
|
|
240
240
|
/////////////////////////////////////////////////////////////////////////
|
241
241
|
/////////////////////////////////////////////////////////////////////////
|
242
242
|
|
243
|
-
Keyframe_Rule::Keyframe_Rule(
|
244
|
-
:
|
243
|
+
Keyframe_Rule::Keyframe_Rule(SourceSpan pstate, Block_Obj b)
|
244
|
+
: ParentStatement(pstate, b), name_()
|
245
245
|
{ statement_type(KEYFRAMERULE); }
|
246
246
|
Keyframe_Rule::Keyframe_Rule(const Keyframe_Rule* ptr)
|
247
|
-
:
|
247
|
+
: ParentStatement(ptr), name_(ptr->name_)
|
248
248
|
{ statement_type(KEYFRAMERULE); }
|
249
249
|
|
250
250
|
/////////////////////////////////////////////////////////////////////////
|
251
251
|
/////////////////////////////////////////////////////////////////////////
|
252
252
|
|
253
|
-
Declaration::Declaration(
|
254
|
-
:
|
253
|
+
Declaration::Declaration(SourceSpan pstate, String_Obj prop, ExpressionObj val, bool i, bool c, Block_Obj b)
|
254
|
+
: ParentStatement(pstate, b), property_(prop), value_(val), is_important_(i), is_custom_property_(c), is_indented_(false)
|
255
255
|
{ statement_type(DECLARATION); }
|
256
256
|
Declaration::Declaration(const Declaration* ptr)
|
257
|
-
:
|
257
|
+
: ParentStatement(ptr),
|
258
258
|
property_(ptr->property_),
|
259
259
|
value_(ptr->value_),
|
260
260
|
is_important_(ptr->is_important_),
|
@@ -271,7 +271,7 @@ namespace Sass {
|
|
271
271
|
/////////////////////////////////////////////////////////////////////////
|
272
272
|
/////////////////////////////////////////////////////////////////////////
|
273
273
|
|
274
|
-
Assignment::Assignment(
|
274
|
+
Assignment::Assignment(SourceSpan pstate, sass::string var, ExpressionObj val, bool is_default, bool is_global)
|
275
275
|
: Statement(pstate), variable_(var), value_(val), is_default_(is_default), is_global_(is_global)
|
276
276
|
{ statement_type(ASSIGNMENT); }
|
277
277
|
Assignment::Assignment(const Assignment* ptr)
|
@@ -285,10 +285,10 @@ namespace Sass {
|
|
285
285
|
/////////////////////////////////////////////////////////////////////////
|
286
286
|
/////////////////////////////////////////////////////////////////////////
|
287
287
|
|
288
|
-
Import::Import(
|
288
|
+
Import::Import(SourceSpan pstate)
|
289
289
|
: Statement(pstate),
|
290
|
-
urls_(
|
291
|
-
incs_(
|
290
|
+
urls_(sass::vector<ExpressionObj>()),
|
291
|
+
incs_(sass::vector<Include>()),
|
292
292
|
import_queries_()
|
293
293
|
{ statement_type(IMPORT); }
|
294
294
|
Import::Import(const Import* ptr)
|
@@ -298,56 +298,56 @@ namespace Sass {
|
|
298
298
|
import_queries_(ptr->import_queries_)
|
299
299
|
{ statement_type(IMPORT); }
|
300
300
|
|
301
|
-
|
302
|
-
|
301
|
+
sass::vector<Include>& Import::incs() { return incs_; }
|
302
|
+
sass::vector<ExpressionObj>& Import::urls() { return urls_; }
|
303
303
|
|
304
304
|
/////////////////////////////////////////////////////////////////////////
|
305
305
|
/////////////////////////////////////////////////////////////////////////
|
306
306
|
|
307
|
-
Import_Stub::Import_Stub(
|
307
|
+
Import_Stub::Import_Stub(SourceSpan pstate, Include res)
|
308
308
|
: Statement(pstate), resource_(res)
|
309
309
|
{ statement_type(IMPORT_STUB); }
|
310
310
|
Import_Stub::Import_Stub(const Import_Stub* ptr)
|
311
311
|
: Statement(ptr), resource_(ptr->resource_)
|
312
312
|
{ statement_type(IMPORT_STUB); }
|
313
313
|
Include Import_Stub::resource() { return resource_; };
|
314
|
-
|
315
|
-
|
314
|
+
sass::string Import_Stub::imp_path() { return resource_.imp_path; };
|
315
|
+
sass::string Import_Stub::abs_path() { return resource_.abs_path; };
|
316
316
|
|
317
317
|
/////////////////////////////////////////////////////////////////////////
|
318
318
|
/////////////////////////////////////////////////////////////////////////
|
319
319
|
|
320
|
-
|
320
|
+
WarningRule::WarningRule(SourceSpan pstate, ExpressionObj msg)
|
321
321
|
: Statement(pstate), message_(msg)
|
322
322
|
{ statement_type(WARNING); }
|
323
|
-
|
323
|
+
WarningRule::WarningRule(const WarningRule* ptr)
|
324
324
|
: Statement(ptr), message_(ptr->message_)
|
325
325
|
{ statement_type(WARNING); }
|
326
326
|
|
327
327
|
/////////////////////////////////////////////////////////////////////////
|
328
328
|
/////////////////////////////////////////////////////////////////////////
|
329
329
|
|
330
|
-
|
330
|
+
ErrorRule::ErrorRule(SourceSpan pstate, ExpressionObj msg)
|
331
331
|
: Statement(pstate), message_(msg)
|
332
332
|
{ statement_type(ERROR); }
|
333
|
-
|
333
|
+
ErrorRule::ErrorRule(const ErrorRule* ptr)
|
334
334
|
: Statement(ptr), message_(ptr->message_)
|
335
335
|
{ statement_type(ERROR); }
|
336
336
|
|
337
337
|
/////////////////////////////////////////////////////////////////////////
|
338
338
|
/////////////////////////////////////////////////////////////////////////
|
339
339
|
|
340
|
-
|
340
|
+
DebugRule::DebugRule(SourceSpan pstate, ExpressionObj val)
|
341
341
|
: Statement(pstate), value_(val)
|
342
342
|
{ statement_type(DEBUGSTMT); }
|
343
|
-
|
343
|
+
DebugRule::DebugRule(const DebugRule* ptr)
|
344
344
|
: Statement(ptr), value_(ptr->value_)
|
345
345
|
{ statement_type(DEBUGSTMT); }
|
346
346
|
|
347
347
|
/////////////////////////////////////////////////////////////////////////
|
348
348
|
/////////////////////////////////////////////////////////////////////////
|
349
349
|
|
350
|
-
Comment::Comment(
|
350
|
+
Comment::Comment(SourceSpan pstate, String_Obj txt, bool is_important)
|
351
351
|
: Statement(pstate), text_(txt), is_important_(is_important)
|
352
352
|
{ statement_type(COMMENT); }
|
353
353
|
Comment::Comment(const Comment* ptr)
|
@@ -364,30 +364,30 @@ namespace Sass {
|
|
364
364
|
/////////////////////////////////////////////////////////////////////////
|
365
365
|
/////////////////////////////////////////////////////////////////////////
|
366
366
|
|
367
|
-
If::If(
|
368
|
-
:
|
367
|
+
If::If(SourceSpan pstate, ExpressionObj pred, Block_Obj con, Block_Obj alt)
|
368
|
+
: ParentStatement(pstate, con), predicate_(pred), alternative_(alt)
|
369
369
|
{ statement_type(IF); }
|
370
370
|
If::If(const If* ptr)
|
371
|
-
:
|
371
|
+
: ParentStatement(ptr),
|
372
372
|
predicate_(ptr->predicate_),
|
373
373
|
alternative_(ptr->alternative_)
|
374
374
|
{ statement_type(IF); }
|
375
375
|
|
376
376
|
bool If::has_content()
|
377
377
|
{
|
378
|
-
return
|
378
|
+
return ParentStatement::has_content() || (alternative_ && alternative_->has_content());
|
379
379
|
}
|
380
380
|
|
381
381
|
/////////////////////////////////////////////////////////////////////////
|
382
382
|
/////////////////////////////////////////////////////////////////////////
|
383
383
|
|
384
|
-
|
385
|
-
|
386
|
-
:
|
384
|
+
ForRule::ForRule(SourceSpan pstate,
|
385
|
+
sass::string var, ExpressionObj lo, ExpressionObj hi, Block_Obj b, bool inc)
|
386
|
+
: ParentStatement(pstate, b),
|
387
387
|
variable_(var), lower_bound_(lo), upper_bound_(hi), is_inclusive_(inc)
|
388
388
|
{ statement_type(FOR); }
|
389
|
-
|
390
|
-
:
|
389
|
+
ForRule::ForRule(const ForRule* ptr)
|
390
|
+
: ParentStatement(ptr),
|
391
391
|
variable_(ptr->variable_),
|
392
392
|
lower_bound_(ptr->lower_bound_),
|
393
393
|
upper_bound_(ptr->upper_bound_),
|
@@ -397,27 +397,27 @@ namespace Sass {
|
|
397
397
|
/////////////////////////////////////////////////////////////////////////
|
398
398
|
/////////////////////////////////////////////////////////////////////////
|
399
399
|
|
400
|
-
|
401
|
-
:
|
400
|
+
EachRule::EachRule(SourceSpan pstate, sass::vector<sass::string> vars, ExpressionObj lst, Block_Obj b)
|
401
|
+
: ParentStatement(pstate, b), variables_(vars), list_(lst)
|
402
402
|
{ statement_type(EACH); }
|
403
|
-
|
404
|
-
:
|
403
|
+
EachRule::EachRule(const EachRule* ptr)
|
404
|
+
: ParentStatement(ptr), variables_(ptr->variables_), list_(ptr->list_)
|
405
405
|
{ statement_type(EACH); }
|
406
406
|
|
407
407
|
/////////////////////////////////////////////////////////////////////////
|
408
408
|
/////////////////////////////////////////////////////////////////////////
|
409
409
|
|
410
|
-
|
411
|
-
:
|
410
|
+
WhileRule::WhileRule(SourceSpan pstate, ExpressionObj pred, Block_Obj b)
|
411
|
+
: ParentStatement(pstate, b), predicate_(pred)
|
412
412
|
{ statement_type(WHILE); }
|
413
|
-
|
414
|
-
:
|
413
|
+
WhileRule::WhileRule(const WhileRule* ptr)
|
414
|
+
: ParentStatement(ptr), predicate_(ptr->predicate_)
|
415
415
|
{ statement_type(WHILE); }
|
416
416
|
|
417
417
|
/////////////////////////////////////////////////////////////////////////
|
418
418
|
/////////////////////////////////////////////////////////////////////////
|
419
419
|
|
420
|
-
Return::Return(
|
420
|
+
Return::Return(SourceSpan pstate, ExpressionObj val)
|
421
421
|
: Statement(pstate), value_(val)
|
422
422
|
{ statement_type(RETURN); }
|
423
423
|
Return::Return(const Return* ptr)
|
@@ -427,10 +427,10 @@ namespace Sass {
|
|
427
427
|
/////////////////////////////////////////////////////////////////////////
|
428
428
|
/////////////////////////////////////////////////////////////////////////
|
429
429
|
|
430
|
-
ExtendRule::ExtendRule(
|
430
|
+
ExtendRule::ExtendRule(SourceSpan pstate, SelectorListObj s)
|
431
431
|
: Statement(pstate), isOptional_(false), selector_(s), schema_()
|
432
432
|
{ statement_type(EXTEND); }
|
433
|
-
ExtendRule::ExtendRule(
|
433
|
+
ExtendRule::ExtendRule(SourceSpan pstate, Selector_Schema_Obj s)
|
434
434
|
: Statement(pstate), isOptional_(false), selector_(), schema_(s)
|
435
435
|
{
|
436
436
|
statement_type(EXTEND);
|
@@ -446,7 +446,7 @@ namespace Sass {
|
|
446
446
|
/////////////////////////////////////////////////////////////////////////
|
447
447
|
|
448
448
|
Definition::Definition(const Definition* ptr)
|
449
|
-
:
|
449
|
+
: ParentStatement(ptr),
|
450
450
|
name_(ptr->name_),
|
451
451
|
parameters_(ptr->parameters_),
|
452
452
|
environment_(ptr->environment_),
|
@@ -458,12 +458,12 @@ namespace Sass {
|
|
458
458
|
signature_(ptr->signature_)
|
459
459
|
{ }
|
460
460
|
|
461
|
-
Definition::Definition(
|
462
|
-
|
461
|
+
Definition::Definition(SourceSpan pstate,
|
462
|
+
sass::string n,
|
463
463
|
Parameters_Obj params,
|
464
464
|
Block_Obj b,
|
465
465
|
Type t)
|
466
|
-
:
|
466
|
+
: ParentStatement(pstate, b),
|
467
467
|
name_(n),
|
468
468
|
parameters_(params),
|
469
469
|
environment_(0),
|
@@ -475,13 +475,13 @@ namespace Sass {
|
|
475
475
|
signature_(0)
|
476
476
|
{ }
|
477
477
|
|
478
|
-
Definition::Definition(
|
478
|
+
Definition::Definition(SourceSpan pstate,
|
479
479
|
Signature sig,
|
480
|
-
|
480
|
+
sass::string n,
|
481
481
|
Parameters_Obj params,
|
482
482
|
Native_Function func_ptr,
|
483
483
|
bool overload_stub)
|
484
|
-
:
|
484
|
+
: ParentStatement(pstate, {}),
|
485
485
|
name_(n),
|
486
486
|
parameters_(params),
|
487
487
|
environment_(0),
|
@@ -493,12 +493,12 @@ namespace Sass {
|
|
493
493
|
signature_(sig)
|
494
494
|
{ }
|
495
495
|
|
496
|
-
Definition::Definition(
|
496
|
+
Definition::Definition(SourceSpan pstate,
|
497
497
|
Signature sig,
|
498
|
-
|
498
|
+
sass::string n,
|
499
499
|
Parameters_Obj params,
|
500
500
|
Sass_Function_Entry c_func)
|
501
|
-
:
|
501
|
+
: ParentStatement(pstate, {}),
|
502
502
|
name_(n),
|
503
503
|
parameters_(params),
|
504
504
|
environment_(0),
|
@@ -513,11 +513,11 @@ namespace Sass {
|
|
513
513
|
/////////////////////////////////////////////////////////////////////////
|
514
514
|
/////////////////////////////////////////////////////////////////////////
|
515
515
|
|
516
|
-
Mixin_Call::Mixin_Call(
|
517
|
-
:
|
516
|
+
Mixin_Call::Mixin_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Parameters_Obj b_params, Block_Obj b)
|
517
|
+
: ParentStatement(pstate, b), name_(n), arguments_(args), block_parameters_(b_params)
|
518
518
|
{ }
|
519
519
|
Mixin_Call::Mixin_Call(const Mixin_Call* ptr)
|
520
|
-
:
|
520
|
+
: ParentStatement(ptr),
|
521
521
|
name_(ptr->name_),
|
522
522
|
arguments_(ptr->arguments_),
|
523
523
|
block_parameters_(ptr->block_parameters_)
|
@@ -526,7 +526,7 @@ namespace Sass {
|
|
526
526
|
/////////////////////////////////////////////////////////////////////////
|
527
527
|
/////////////////////////////////////////////////////////////////////////
|
528
528
|
|
529
|
-
Content::Content(
|
529
|
+
Content::Content(SourceSpan pstate, Arguments_Obj args)
|
530
530
|
: Statement(pstate),
|
531
531
|
arguments_(args)
|
532
532
|
{ statement_type(CONTENT); }
|
@@ -538,7 +538,7 @@ namespace Sass {
|
|
538
538
|
/////////////////////////////////////////////////////////////////////////
|
539
539
|
/////////////////////////////////////////////////////////////////////////
|
540
540
|
|
541
|
-
Expression::Expression(
|
541
|
+
Expression::Expression(SourceSpan pstate, bool d, bool e, bool i, Type ct)
|
542
542
|
: AST_Node(pstate),
|
543
543
|
is_delayed_(d),
|
544
544
|
is_expanded_(e),
|
@@ -557,7 +557,7 @@ namespace Sass {
|
|
557
557
|
/////////////////////////////////////////////////////////////////////////
|
558
558
|
/////////////////////////////////////////////////////////////////////////
|
559
559
|
|
560
|
-
Unary_Expression::Unary_Expression(
|
560
|
+
Unary_Expression::Unary_Expression(SourceSpan pstate, Type t, ExpressionObj o)
|
561
561
|
: Expression(pstate), optype_(t), operand_(o), hash_(0)
|
562
562
|
{ }
|
563
563
|
Unary_Expression::Unary_Expression(const Unary_Expression* ptr)
|
@@ -566,7 +566,7 @@ namespace Sass {
|
|
566
566
|
operand_(ptr->operand_),
|
567
567
|
hash_(ptr->hash_)
|
568
568
|
{ }
|
569
|
-
const
|
569
|
+
const sass::string Unary_Expression::type_name() {
|
570
570
|
switch (optype_) {
|
571
571
|
case PLUS: return "plus";
|
572
572
|
case MINUS: return "minus";
|
@@ -602,7 +602,7 @@ namespace Sass {
|
|
602
602
|
/////////////////////////////////////////////////////////////////////////
|
603
603
|
/////////////////////////////////////////////////////////////////////////
|
604
604
|
|
605
|
-
Argument::Argument(
|
605
|
+
Argument::Argument(SourceSpan pstate, ExpressionObj val, sass::string n, bool rest, bool keyword)
|
606
606
|
: Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
|
607
607
|
{
|
608
608
|
if (!name_.empty() && is_rest_argument_) {
|
@@ -646,7 +646,7 @@ namespace Sass {
|
|
646
646
|
size_t Argument::hash() const
|
647
647
|
{
|
648
648
|
if (hash_ == 0) {
|
649
|
-
hash_ = std::hash<
|
649
|
+
hash_ = std::hash<sass::string>()(name());
|
650
650
|
hash_combine(hash_, value()->hash());
|
651
651
|
}
|
652
652
|
return hash_;
|
@@ -655,7 +655,7 @@ namespace Sass {
|
|
655
655
|
/////////////////////////////////////////////////////////////////////////
|
656
656
|
/////////////////////////////////////////////////////////////////////////
|
657
657
|
|
658
|
-
Arguments::Arguments(
|
658
|
+
Arguments::Arguments(SourceSpan pstate)
|
659
659
|
: Expression(pstate),
|
660
660
|
Vectorized<Argument_Obj>(),
|
661
661
|
has_named_arguments_(false),
|
@@ -738,13 +738,13 @@ namespace Sass {
|
|
738
738
|
/////////////////////////////////////////////////////////////////////////
|
739
739
|
/////////////////////////////////////////////////////////////////////////
|
740
740
|
|
741
|
-
Media_Query::Media_Query(
|
742
|
-
: Expression(pstate), Vectorized<
|
741
|
+
Media_Query::Media_Query(SourceSpan pstate, String_Obj t, size_t s, bool n, bool r)
|
742
|
+
: Expression(pstate), Vectorized<Media_Query_ExpressionObj>(s),
|
743
743
|
media_type_(t), is_negated_(n), is_restricted_(r)
|
744
744
|
{ }
|
745
745
|
Media_Query::Media_Query(const Media_Query* ptr)
|
746
746
|
: Expression(ptr),
|
747
|
-
Vectorized<
|
747
|
+
Vectorized<Media_Query_ExpressionObj>(*ptr),
|
748
748
|
media_type_(ptr->media_type_),
|
749
749
|
is_negated_(ptr->is_negated_),
|
750
750
|
is_restricted_(ptr->is_restricted_)
|
@@ -753,8 +753,8 @@ namespace Sass {
|
|
753
753
|
/////////////////////////////////////////////////////////////////////////
|
754
754
|
/////////////////////////////////////////////////////////////////////////
|
755
755
|
|
756
|
-
Media_Query_Expression::Media_Query_Expression(
|
757
|
-
|
756
|
+
Media_Query_Expression::Media_Query_Expression(SourceSpan pstate,
|
757
|
+
ExpressionObj f, ExpressionObj v, bool i)
|
758
758
|
: Expression(pstate), feature_(f), value_(v), is_interpolated_(i)
|
759
759
|
{ }
|
760
760
|
Media_Query_Expression::Media_Query_Expression(const Media_Query_Expression* ptr)
|
@@ -767,7 +767,7 @@ namespace Sass {
|
|
767
767
|
/////////////////////////////////////////////////////////////////////////
|
768
768
|
/////////////////////////////////////////////////////////////////////////
|
769
769
|
|
770
|
-
At_Root_Query::At_Root_Query(
|
770
|
+
At_Root_Query::At_Root_Query(SourceSpan pstate, ExpressionObj f, ExpressionObj v, bool i)
|
771
771
|
: Expression(pstate), feature_(f), value_(v)
|
772
772
|
{ }
|
773
773
|
At_Root_Query::At_Root_Query(const At_Root_Query* ptr)
|
@@ -776,11 +776,11 @@ namespace Sass {
|
|
776
776
|
value_(ptr->value_)
|
777
777
|
{ }
|
778
778
|
|
779
|
-
bool At_Root_Query::exclude(
|
779
|
+
bool At_Root_Query::exclude(sass::string str)
|
780
780
|
{
|
781
781
|
bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;
|
782
782
|
List* l = static_cast<List*>(value().ptr());
|
783
|
-
|
783
|
+
sass::string v;
|
784
784
|
|
785
785
|
if (with)
|
786
786
|
{
|
@@ -807,18 +807,18 @@ namespace Sass {
|
|
807
807
|
/////////////////////////////////////////////////////////////////////////
|
808
808
|
/////////////////////////////////////////////////////////////////////////
|
809
809
|
|
810
|
-
|
811
|
-
:
|
810
|
+
AtRootRule::AtRootRule(SourceSpan pstate, Block_Obj b, At_Root_Query_Obj e)
|
811
|
+
: ParentStatement(pstate, b), expression_(e)
|
812
812
|
{ statement_type(ATROOT); }
|
813
|
-
|
814
|
-
:
|
813
|
+
AtRootRule::AtRootRule(const AtRootRule* ptr)
|
814
|
+
: ParentStatement(ptr), expression_(ptr->expression_)
|
815
815
|
{ statement_type(ATROOT); }
|
816
816
|
|
817
|
-
bool
|
817
|
+
bool AtRootRule::bubbles() {
|
818
818
|
return true;
|
819
819
|
}
|
820
820
|
|
821
|
-
bool
|
821
|
+
bool AtRootRule::exclude_node(Statement_Obj s) {
|
822
822
|
if (expression() == nullptr)
|
823
823
|
{
|
824
824
|
return s->statement_type() == Statement::RULESET;
|
@@ -826,9 +826,9 @@ namespace Sass {
|
|
826
826
|
|
827
827
|
if (s->statement_type() == Statement::DIRECTIVE)
|
828
828
|
{
|
829
|
-
if (
|
829
|
+
if (AtRuleObj dir = Cast<AtRule>(s))
|
830
830
|
{
|
831
|
-
|
831
|
+
sass::string keyword(dir->keyword());
|
832
832
|
if (keyword.length() > 0) keyword.erase(0, 1);
|
833
833
|
return expression()->exclude(keyword);
|
834
834
|
}
|
@@ -845,7 +845,7 @@ namespace Sass {
|
|
845
845
|
{
|
846
846
|
return expression()->exclude("supports");
|
847
847
|
}
|
848
|
-
if (
|
848
|
+
if (AtRuleObj dir = Cast<AtRule>(s))
|
849
849
|
{
|
850
850
|
if (dir->is_keyframes()) return expression()->exclude("keyframes");
|
851
851
|
}
|
@@ -855,7 +855,7 @@ namespace Sass {
|
|
855
855
|
/////////////////////////////////////////////////////////////////////////
|
856
856
|
/////////////////////////////////////////////////////////////////////////
|
857
857
|
|
858
|
-
Parameter::Parameter(
|
858
|
+
Parameter::Parameter(SourceSpan pstate, sass::string n, ExpressionObj def, bool rest)
|
859
859
|
: AST_Node(pstate), name_(n), default_value_(def), is_rest_parameter_(rest)
|
860
860
|
{ }
|
861
861
|
Parameter::Parameter(const Parameter* ptr)
|
@@ -868,7 +868,7 @@ namespace Sass {
|
|
868
868
|
/////////////////////////////////////////////////////////////////////////
|
869
869
|
/////////////////////////////////////////////////////////////////////////
|
870
870
|
|
871
|
-
Parameters::Parameters(
|
871
|
+
Parameters::Parameters(SourceSpan pstate)
|
872
872
|
: AST_Node(pstate),
|
873
873
|
Vectorized<Parameter_Obj>(),
|
874
874
|
has_optional_parameters_(false),
|
@@ -911,25 +911,25 @@ namespace Sass {
|
|
911
911
|
// If you forget to add a class here you will get
|
912
912
|
// undefined reference to `vtable for Sass::Class'
|
913
913
|
|
914
|
-
IMPLEMENT_AST_OPERATORS(
|
914
|
+
IMPLEMENT_AST_OPERATORS(StyleRule);
|
915
915
|
IMPLEMENT_AST_OPERATORS(MediaRule);
|
916
916
|
IMPLEMENT_AST_OPERATORS(CssMediaRule);
|
917
917
|
IMPLEMENT_AST_OPERATORS(CssMediaQuery);
|
918
918
|
IMPLEMENT_AST_OPERATORS(Import);
|
919
919
|
IMPLEMENT_AST_OPERATORS(Import_Stub);
|
920
|
-
IMPLEMENT_AST_OPERATORS(
|
921
|
-
IMPLEMENT_AST_OPERATORS(
|
922
|
-
IMPLEMENT_AST_OPERATORS(
|
923
|
-
IMPLEMENT_AST_OPERATORS(
|
924
|
-
IMPLEMENT_AST_OPERATORS(
|
920
|
+
IMPLEMENT_AST_OPERATORS(AtRule);
|
921
|
+
IMPLEMENT_AST_OPERATORS(AtRootRule);
|
922
|
+
IMPLEMENT_AST_OPERATORS(WhileRule);
|
923
|
+
IMPLEMENT_AST_OPERATORS(EachRule);
|
924
|
+
IMPLEMENT_AST_OPERATORS(ForRule);
|
925
925
|
IMPLEMENT_AST_OPERATORS(If);
|
926
926
|
IMPLEMENT_AST_OPERATORS(Mixin_Call);
|
927
927
|
IMPLEMENT_AST_OPERATORS(ExtendRule);
|
928
928
|
IMPLEMENT_AST_OPERATORS(Media_Query);
|
929
929
|
IMPLEMENT_AST_OPERATORS(Media_Query_Expression);
|
930
|
-
IMPLEMENT_AST_OPERATORS(
|
931
|
-
IMPLEMENT_AST_OPERATORS(
|
932
|
-
IMPLEMENT_AST_OPERATORS(
|
930
|
+
IMPLEMENT_AST_OPERATORS(DebugRule);
|
931
|
+
IMPLEMENT_AST_OPERATORS(ErrorRule);
|
932
|
+
IMPLEMENT_AST_OPERATORS(WarningRule);
|
933
933
|
IMPLEMENT_AST_OPERATORS(Assignment);
|
934
934
|
IMPLEMENT_AST_OPERATORS(Return);
|
935
935
|
IMPLEMENT_AST_OPERATORS(At_Root_Query);
|