sassc 1.11.1 → 1.11.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (85) hide show
  1. checksums.yaml +4 -4
  2. data/.travis.yml +2 -2
  3. data/README.md +3 -2
  4. data/ext/libsass/Makefile.conf +2 -1
  5. data/ext/libsass/appveyor.yml +10 -5
  6. data/ext/libsass/docs/dev-ast-memory.md +223 -0
  7. data/ext/libsass/include/sass/base.h +2 -0
  8. data/ext/libsass/script/bootstrap +7 -4
  9. data/ext/libsass/script/ci-build-libsass +3 -3
  10. data/ext/libsass/script/ci-install-compiler +2 -0
  11. data/ext/libsass/script/ci-report-coverage +2 -1
  12. data/ext/libsass/script/test-leaks.pl +103 -0
  13. data/ext/libsass/src/ast.cpp +621 -495
  14. data/ext/libsass/src/ast.hpp +801 -367
  15. data/ext/libsass/src/ast_def_macros.hpp +5 -5
  16. data/ext/libsass/src/ast_fwd_decl.hpp +312 -14
  17. data/ext/libsass/src/bind.cpp +54 -51
  18. data/ext/libsass/src/bind.hpp +3 -7
  19. data/ext/libsass/src/check_nesting.cpp +117 -120
  20. data/ext/libsass/src/check_nesting.hpp +38 -34
  21. data/ext/libsass/src/color_maps.cpp +3 -3
  22. data/ext/libsass/src/color_maps.hpp +3 -3
  23. data/ext/libsass/src/context.cpp +33 -34
  24. data/ext/libsass/src/context.hpp +12 -14
  25. data/ext/libsass/src/cssize.cpp +200 -228
  26. data/ext/libsass/src/cssize.hpp +49 -49
  27. data/ext/libsass/src/debugger.hpp +260 -241
  28. data/ext/libsass/src/emitter.cpp +6 -6
  29. data/ext/libsass/src/emitter.hpp +7 -7
  30. data/ext/libsass/src/environment.cpp +2 -2
  31. data/ext/libsass/src/environment.hpp +0 -2
  32. data/ext/libsass/src/error_handling.cpp +5 -5
  33. data/ext/libsass/src/error_handling.hpp +12 -12
  34. data/ext/libsass/src/eval.cpp +412 -401
  35. data/ext/libsass/src/eval.hpp +61 -62
  36. data/ext/libsass/src/expand.cpp +223 -204
  37. data/ext/libsass/src/expand.hpp +42 -42
  38. data/ext/libsass/src/extend.cpp +198 -201
  39. data/ext/libsass/src/extend.hpp +12 -14
  40. data/ext/libsass/src/file.hpp +4 -5
  41. data/ext/libsass/src/functions.cpp +413 -418
  42. data/ext/libsass/src/functions.hpp +7 -10
  43. data/ext/libsass/src/inspect.cpp +115 -109
  44. data/ext/libsass/src/inspect.hpp +69 -69
  45. data/ext/libsass/src/listize.cpp +31 -33
  46. data/ext/libsass/src/listize.hpp +8 -10
  47. data/ext/libsass/src/memory/SharedPtr.cpp +116 -0
  48. data/ext/libsass/src/memory/SharedPtr.hpp +202 -0
  49. data/ext/libsass/src/node.cpp +45 -43
  50. data/ext/libsass/src/node.hpp +15 -15
  51. data/ext/libsass/src/operation.hpp +136 -136
  52. data/ext/libsass/src/output.cpp +48 -49
  53. data/ext/libsass/src/output.hpp +14 -14
  54. data/ext/libsass/src/parser.cpp +530 -554
  55. data/ext/libsass/src/parser.hpp +91 -96
  56. data/ext/libsass/src/prelexer.cpp +13 -10
  57. data/ext/libsass/src/remove_placeholders.cpp +25 -21
  58. data/ext/libsass/src/remove_placeholders.hpp +7 -7
  59. data/ext/libsass/src/sass2scss.cpp +2 -1
  60. data/ext/libsass/src/sass_context.cpp +125 -107
  61. data/ext/libsass/src/sass_context.hpp +1 -1
  62. data/ext/libsass/src/sass_util.hpp +5 -5
  63. data/ext/libsass/src/sass_values.cpp +27 -27
  64. data/ext/libsass/src/source_map.cpp +2 -2
  65. data/ext/libsass/src/source_map.hpp +2 -2
  66. data/ext/libsass/src/subset_map.cpp +57 -0
  67. data/ext/libsass/src/subset_map.hpp +8 -76
  68. data/ext/libsass/src/to_c.cpp +13 -13
  69. data/ext/libsass/src/to_c.hpp +14 -14
  70. data/ext/libsass/src/to_value.cpp +20 -20
  71. data/ext/libsass/src/to_value.hpp +20 -21
  72. data/ext/libsass/src/util.cpp +55 -88
  73. data/ext/libsass/src/util.hpp +9 -13
  74. data/ext/libsass/src/values.cpp +27 -26
  75. data/ext/libsass/src/values.hpp +2 -2
  76. data/ext/libsass/test/test_subset_map.cpp +69 -69
  77. data/ext/libsass/win/libsass.targets +3 -2
  78. data/ext/libsass/win/libsass.vcxproj.filters +9 -6
  79. data/lib/sassc/version.rb +1 -1
  80. data/sassc.gemspec +0 -1
  81. data/test/native_test.rb +1 -1
  82. metadata +7 -5
  83. data/ext/libsass/src/ast_factory.hpp +0 -92
  84. data/ext/libsass/src/memory_manager.cpp +0 -77
  85. data/ext/libsass/src/memory_manager.hpp +0 -48
data/ext/libsass/src/cssize.hpp CHANGED
@@ -8,69 +8,69 @@
8
8
 
9
9
  namespace Sass {
10
10
 
11
- typedef Environment<AST_Node*> Env;
11
+ typedef Environment<AST_Node_Obj> Env;
12
12
  struct Backtrace;
13
13
 
14
- class Cssize : public Operation_CRTP<Statement*, Cssize> {
14
+ class Cssize : public Operation_CRTP<Statement_Ptr, Cssize> {
15
15
 
16
16
  Context& ctx;
17
- std::vector<Block*> block_stack;
18
- std::vector<Statement*> p_stack;
17
+ std::vector<Block_Ptr> block_stack;
18
+ std::vector<Statement_Ptr> p_stack;
19
19
  Backtrace* backtrace;
20
20
 
21
- Statement* fallback_impl(AST_Node* n);
21
+ Statement_Ptr fallback_impl(AST_Node_Ptr n);
22
22
 
23
23
  public:
24
24
  Cssize(Context&, Backtrace*);
25
25
  ~Cssize() { }
26
26
 
27
- CommaSequence_Selector* selector();
28
-
29
- Statement* operator()(Block*);
30
- Statement* operator()(Ruleset*);
31
- // Statement* operator()(Bubble*);
32
- Statement* operator()(Media_Block*);
33
- Statement* operator()(Supports_Block*);
34
- Statement* operator()(At_Root_Block*);
35
- Statement* operator()(Directive*);
36
- Statement* operator()(Keyframe_Rule*);
37
- Statement* operator()(Trace*);
38
- Statement* operator()(Declaration*);
39
- // Statement* operator()(Assignment*);
40
- // Statement* operator()(Import*);
41
- // Statement* operator()(Import_Stub*);
42
- // Statement* operator()(Warning*);
43
- // Statement* operator()(Error*);
44
- // Statement* operator()(Comment*);
45
- // Statement* operator()(If*);
46
- // Statement* operator()(For*);
47
- // Statement* operator()(Each*);
48
- // Statement* operator()(While*);
49
- // Statement* operator()(Return*);
50
- // Statement* operator()(Extension*);
51
- // Statement* operator()(Definition*);
52
- // Statement* operator()(Mixin_Call*);
53
- // Statement* operator()(Content*);
54
- Statement* operator()(Null*);
55
-
56
- Statement* parent();
57
- std::vector<std::pair<bool, Block*>> slice_by_bubble(Statement*);
58
- Statement* bubble(Directive*);
59
- Statement* bubble(At_Root_Block*);
60
- Statement* bubble(Media_Block*);
61
- Statement* bubble(Supports_Block*);
62
- Statement* shallow_copy(Statement*);
63
- Statement* debubble(Block* children, Statement* parent = 0);
64
- Statement* flatten(Statement*);
65
- bool bubblable(Statement*);
66
-
67
- List* merge_media_queries(Media_Block*, Media_Block*);
68
- Media_Query* merge_media_query(Media_Query*, Media_Query*);
27
+ Selector_List_Ptr selector();
28
+
29
+ Block_Ptr operator()(Block_Ptr);
30
+ Statement_Ptr operator()(Ruleset_Ptr);
31
+ // Statement_Ptr operator()(Bubble_Ptr);
32
+ Statement_Ptr operator()(Media_Block_Ptr);
33
+ Statement_Ptr operator()(Supports_Block_Ptr);
34
+ Statement_Ptr operator()(At_Root_Block_Ptr);
35
+ Statement_Ptr operator()(Directive_Ptr);
36
+ Statement_Ptr operator()(Keyframe_Rule_Ptr);
37
+ Statement_Ptr operator()(Trace_Ptr);
38
+ Statement_Ptr operator()(Declaration_Ptr);
39
+ // Statement_Ptr operator()(Assignment_Ptr);
40
+ // Statement_Ptr operator()(Import_Ptr);
41
+ // Statement_Ptr operator()(Import_Stub_Ptr);
42
+ // Statement_Ptr operator()(Warning_Ptr);
43
+ // Statement_Ptr operator()(Error_Ptr);
44
+ // Statement_Ptr operator()(Comment_Ptr);
45
+ // Statement_Ptr operator()(If_Ptr);
46
+ // Statement_Ptr operator()(For_Ptr);
47
+ // Statement_Ptr operator()(Each_Ptr);
48
+ // Statement_Ptr operator()(While_Ptr);
49
+ // Statement_Ptr operator()(Return_Ptr);
50
+ // Statement_Ptr operator()(Extension_Ptr);
51
+ // Statement_Ptr operator()(Definition_Ptr);
52
+ // Statement_Ptr operator()(Mixin_Call_Ptr);
53
+ // Statement_Ptr operator()(Content_Ptr);
54
+ Statement_Ptr operator()(Null_Ptr);
55
+
56
+ Statement_Ptr parent();
57
+ std::vector<std::pair<bool, Block_Obj>> slice_by_bubble(Block_Ptr);
58
+ Statement_Ptr bubble(Directive_Ptr);
59
+ Statement_Ptr bubble(At_Root_Block_Ptr);
60
+ Statement_Ptr bubble(Media_Block_Ptr);
61
+ Statement_Ptr bubble(Supports_Block_Ptr);
62
+
63
+ Block_Ptr debubble(Block_Ptr children, Statement_Ptr parent = 0);
64
+ Block_Ptr flatten(Block_Ptr);
65
+ bool bubblable(Statement_Ptr);
66
+
67
+ List_Ptr merge_media_queries(Media_Block_Ptr, Media_Block_Ptr);
68
+ Media_Query_Ptr merge_media_query(Media_Query_Ptr, Media_Query_Ptr);
69
69
 
70
70
  template <typename U>
71
- Statement* fallback(U x) { return fallback_impl(x); }
71
+ Statement_Ptr fallback(U x) { return fallback_impl(x); }
72
72
 
73
- void append_block(Block*);
73
+ void append_block(Block_Ptr, Block_Ptr);
74
74
  };
75
75
 
76
76
  }
data/ext/libsass/src/debugger.hpp CHANGED
@@ -8,13 +8,13 @@
8
8
 
9
9
  using namespace Sass;
10
10
 
11
- inline void debug_ast(AST_Node* node, std::string ind = "", Env* env = 0);
11
+ inline void debug_ast(AST_Node_Ptr node, std::string ind = "", Env* env = 0);
12
12
 
13
13
  inline void debug_sources_set(SourcesSet& set, std::string ind = "")
14
14
  {
15
15
  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
16
16
  for(auto const &pair : set) {
17
- debug_ast(pair, ind + "");
17
+ debug_ast(&pair, ind + "");
18
18
  // debug_ast(set[pair], ind + "first: ");
19
19
  }
20
20
  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
@@ -44,7 +44,7 @@ inline std::string longToHex(long long t) {
44
44
  return is.str();
45
45
  }
46
46
 
47
- inline std::string pstate_source_position(AST_Node* node)
47
+ inline std::string pstate_source_position(AST_Node_Ptr node)
48
48
  {
49
49
  std::stringstream str;
50
50
  Position start(node->pstate());
@@ -52,38 +52,43 @@ inline std::string pstate_source_position(AST_Node* node)
52
52
  str << (start.file == std::string::npos ? -1 : start.file)
53
53
  << "@[" << start.line << ":" << start.column << "]"
54
54
  << "-[" << end.line << ":" << end.column << "]";
55
+ #ifdef DEBUG_SHARED_PTR
56
+ str << "x" << node->getRefCount() << ""
57
+ << " " << node->getDbgFile()
58
+ << "@" << node->getDbgLine();
59
+ #endif
55
60
  return str.str();
56
61
  }
57
62
 
58
- inline void debug_ast(AST_Node* node, std::string ind, Env* env)
63
+ inline void debug_ast(AST_Node_Ptr node, std::string ind, Env* env)
59
64
  {
60
65
  if (node == 0) return;
61
66
  if (ind == "") std::cerr << "####################################################################\n";
62
- if (dynamic_cast<Bubble*>(node)) {
63
- Bubble* bubble = dynamic_cast<Bubble*>(node);
67
+ if (dynamic_cast<Bubble_Ptr>(node)) {
68
+ Bubble_Ptr bubble = dynamic_cast<Bubble_Ptr>(node);
64
69
  std::cerr << ind << "Bubble " << bubble;
65
70
  std::cerr << " (" << pstate_source_position(node) << ")";
66
71
  std::cerr << " " << bubble->tabs();
67
72
  std::cerr << std::endl;
68
- debug_ast(bubble->node(), ind + " ", env);
69
- } else if (dynamic_cast<Trace*>(node)) {
70
- Trace* trace = dynamic_cast<Trace*>(node);
73
+ debug_ast(&bubble->node(), ind + " ", env);
74
+ } else if (dynamic_cast<Trace_Ptr>(node)) {
75
+ Trace_Ptr trace = dynamic_cast<Trace_Ptr>(node);
71
76
  std::cerr << ind << "Trace " << trace;
72
77
  std::cerr << " (" << pstate_source_position(node) << ")"
73
78
  << " [name:" << trace->name() << "]"
74
79
  << std::endl;
75
- debug_ast(trace->block(), ind + " ", env);
76
- } else if (dynamic_cast<At_Root_Block*>(node)) {
77
- At_Root_Block* root_block = dynamic_cast<At_Root_Block*>(node);
80
+ debug_ast(&trace->block(), ind + " ", env);
81
+ } else if (dynamic_cast<At_Root_Block_Ptr>(node)) {
82
+ At_Root_Block_Ptr root_block = dynamic_cast<At_Root_Block_Ptr>(node);
78
83
  std::cerr << ind << "At_Root_Block " << root_block;
79
84
  std::cerr << " (" << pstate_source_position(node) << ")";
80
85
  std::cerr << " " << root_block->tabs();
81
86
  std::cerr << std::endl;
82
- debug_ast(root_block->expression(), ind + ":", env);
83
- debug_ast(root_block->block(), ind + " ", env);
84
- } else if (dynamic_cast<CommaSequence_Selector*>(node)) {
85
- CommaSequence_Selector* selector = dynamic_cast<CommaSequence_Selector*>(node);
86
- std::cerr << ind << "CommaSequence_Selector " << selector;
87
+ debug_ast(&root_block->expression(), ind + ":", env);
88
+ debug_ast(&root_block->block(), ind + " ", env);
89
+ } else if (dynamic_cast<Selector_List_Ptr>(node)) {
90
+ Selector_List_Ptr selector = dynamic_cast<Selector_List_Ptr>(node);
91
+ std::cerr << ind << "Selector_List " << selector;
87
92
  std::cerr << " (" << pstate_source_position(node) << ")";
88
93
  std::cerr << " <" << selector->hash() << ">";
89
94
  std::cerr << " [@media:" << selector->media_block() << "]";
@@ -95,14 +100,14 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
95
100
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
96
101
  std::cerr << std::endl;
97
102
 
98
- for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
103
+ for(const Complex_Selector_Obj& i : selector->elements()) { debug_ast(&i, ind + " ", env); }
99
104
 
100
- // } else if (dynamic_cast<Expression*>(node)) {
101
- // Expression* expression = dynamic_cast<Expression*>(node);
105
+ // } else if (dynamic_cast<Expression_Ptr>(node)) {
106
+ // Expression_Ptr expression = dynamic_cast<Expression_Ptr>(node);
102
107
  // std::cerr << ind << "Expression " << expression << " " << expression->concrete_type() << std::endl;
103
108
 
104
- } else if (dynamic_cast<Parent_Selector*>(node)) {
105
- Parent_Selector* selector = dynamic_cast<Parent_Selector*>(node);
109
+ } else if (dynamic_cast<Parent_Selector_Ptr>(node)) {
110
+ Parent_Selector_Ptr selector = dynamic_cast<Parent_Selector_Ptr>(node);
106
111
  std::cerr << ind << "Parent_Selector " << selector;
107
112
  // if (selector->not_selector()) cerr << " [in_declaration]";
108
113
  std::cerr << " (" << pstate_source_position(node) << ")";
@@ -111,9 +116,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
111
116
  std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
112
117
  // debug_ast(selector->selector(), ind + "->", env);
113
118
 
114
- } else if (dynamic_cast<Sequence_Selector*>(node)) {
115
- Sequence_Selector* selector = dynamic_cast<Sequence_Selector*>(node);
116
- std::cerr << ind << "Sequence_Selector " << selector
119
+ } else if (dynamic_cast<Complex_Selector_Ptr>(node)) {
120
+ Complex_Selector_Ptr selector = dynamic_cast<Complex_Selector_Ptr>(node);
121
+ std::cerr << ind << "Complex_Selector " << selector
117
122
  << " (" << pstate_source_position(node) << ")"
118
123
  << " <" << selector->hash() << ">"
119
124
  << " [length:" << longToHex(selector->length()) << "]"
@@ -128,25 +133,25 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
128
133
  << " -- ";
129
134
  std::string del;
130
135
  switch (selector->combinator()) {
131
- case Sequence_Selector::PARENT_OF: del = ">"; break;
132
- case Sequence_Selector::PRECEDES: del = "~"; break;
133
- case Sequence_Selector::ADJACENT_TO: del = "+"; break;
134
- case Sequence_Selector::ANCESTOR_OF: del = " "; break;
135
- case Sequence_Selector::REFERENCE: del = "//"; break;
136
+ case Complex_Selector::PARENT_OF: del = ">"; break;
137
+ case Complex_Selector::PRECEDES: del = "~"; break;
138
+ case Complex_Selector::ADJACENT_TO: del = "+"; break;
139
+ case Complex_Selector::ANCESTOR_OF: del = " "; break;
140
+ case Complex_Selector::REFERENCE: del = "//"; break;
136
141
  }
137
142
  // if (del = "/") del += selector->reference()->perform(&to_string) + "/";
138
143
  std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
139
- debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
144
+ debug_ast(&selector->head(), ind + " " /* + "[" + del + "]" */, env);
140
145
  if (selector->tail()) {
141
- debug_ast(selector->tail(), ind + "{" + del + "}", env);
146
+ debug_ast(&selector->tail(), ind + "{" + del + "}", env);
142
147
  } else if(del != " ") {
143
148
  std::cerr << ind << " |" << del << "| {trailing op}" << std::endl;
144
149
  }
145
150
  SourcesSet set = selector->sources();
146
151
  // debug_sources_set(set, ind + " @--> ");
147
- } else if (dynamic_cast<SimpleSequence_Selector*>(node)) {
148
- SimpleSequence_Selector* selector = dynamic_cast<SimpleSequence_Selector*>(node);
149
- std::cerr << ind << "SimpleSequence_Selector " << selector;
152
+ } else if (dynamic_cast<Compound_Selector_Ptr>(node)) {
153
+ Compound_Selector_Ptr selector = dynamic_cast<Compound_Selector_Ptr>(node);
154
+ std::cerr << ind << "Compound_Selector " << selector;
150
155
  std::cerr << " (" << pstate_source_position(node) << ")";
151
156
  std::cerr << " <" << selector->hash() << ">";
152
157
  std::cerr << " [weight:" << longToHex(selector->specificity()) << "]";
@@ -157,9 +162,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
157
162
  std::cerr << (selector->has_line_break() ? " [line-break]": " -");
158
163
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
159
164
  std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
160
- for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
161
- } else if (dynamic_cast<Wrapped_Selector*>(node)) {
162
- Wrapped_Selector* selector = dynamic_cast<Wrapped_Selector*>(node);
165
+ for(const Simple_Selector_Obj& i : selector->elements()) { debug_ast(&i, ind + " ", env); }
166
+ } else if (dynamic_cast<Wrapped_Selector_Ptr>(node)) {
167
+ Wrapped_Selector_Ptr selector = dynamic_cast<Wrapped_Selector_Ptr>(node);
163
168
  std::cerr << ind << "Wrapped_Selector " << selector;
164
169
  std::cerr << " (" << pstate_source_position(node) << ")";
165
170
  std::cerr << " <" << selector->hash() << ">";
@@ -169,9 +174,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
169
174
  std::cerr << (selector->has_line_break() ? " [line-break]": " -");
170
175
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
171
176
  std::cerr << std::endl;
172
- debug_ast(selector->selector(), ind + " () ", env);
173
- } else if (dynamic_cast<Pseudo_Selector*>(node)) {
174
- Pseudo_Selector* selector = dynamic_cast<Pseudo_Selector*>(node);
177
+ debug_ast(&selector->selector(), ind + " () ", env);
178
+ } else if (dynamic_cast<Pseudo_Selector_Ptr>(node)) {
179
+ Pseudo_Selector_Ptr selector = dynamic_cast<Pseudo_Selector_Ptr>(node);
175
180
  std::cerr << ind << "Pseudo_Selector " << selector;
176
181
  std::cerr << " (" << pstate_source_position(node) << ")";
177
182
  std::cerr << " <" << selector->hash() << ">";
@@ -181,9 +186,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
181
186
  std::cerr << (selector->has_line_break() ? " [line-break]": " -");
182
187
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
183
188
  std::cerr << std::endl;
184
- debug_ast(selector->expression(), ind + " <= ", env);
185
- } else if (dynamic_cast<Attribute_Selector*>(node)) {
186
- Attribute_Selector* selector = dynamic_cast<Attribute_Selector*>(node);
189
+ debug_ast(&selector->expression(), ind + " <= ", env);
190
+ } else if (dynamic_cast<Attribute_Selector_Ptr>(node)) {
191
+ Attribute_Selector_Ptr selector = dynamic_cast<Attribute_Selector_Ptr>(node);
187
192
  std::cerr << ind << "Attribute_Selector " << selector;
188
193
  std::cerr << " (" << pstate_source_position(node) << ")";
189
194
  std::cerr << " <" << selector->hash() << ">";
@@ -193,9 +198,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
193
198
  std::cerr << (selector->has_line_break() ? " [line-break]": " -");
194
199
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
195
200
  std::cerr << std::endl;
196
- debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
197
- } else if (dynamic_cast<Class_Selector*>(node)) {
198
- Class_Selector* selector = dynamic_cast<Class_Selector*>(node);
201
+ debug_ast(&selector->value(), ind + "[" + selector->matcher() + "] ", env);
202
+ } else if (dynamic_cast<Class_Selector_Ptr>(node)) {
203
+ Class_Selector_Ptr selector = dynamic_cast<Class_Selector_Ptr>(node);
199
204
  std::cerr << ind << "Class_Selector " << selector;
200
205
  std::cerr << " (" << pstate_source_position(node) << ")";
201
206
  std::cerr << " <" << selector->hash() << ">";
@@ -205,8 +210,8 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
205
210
  std::cerr << (selector->has_line_break() ? " [line-break]": " -");
206
211
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
207
212
  std::cerr << std::endl;
208
- } else if (dynamic_cast<Id_Selector*>(node)) {
209
- Id_Selector* selector = dynamic_cast<Id_Selector*>(node);
213
+ } else if (dynamic_cast<Id_Selector_Ptr>(node)) {
214
+ Id_Selector_Ptr selector = dynamic_cast<Id_Selector_Ptr>(node);
210
215
  std::cerr << ind << "Id_Selector " << selector;
211
216
  std::cerr << " (" << pstate_source_position(node) << ")";
212
217
  std::cerr << " <" << selector->hash() << ">";
@@ -216,8 +221,8 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
216
221
  std::cerr << (selector->has_line_break() ? " [line-break]": " -");
217
222
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
218
223
  std::cerr << std::endl;
219
- } else if (dynamic_cast<Element_Selector*>(node)) {
220
- Element_Selector* selector = dynamic_cast<Element_Selector*>(node);
224
+ } else if (dynamic_cast<Element_Selector_Ptr>(node)) {
225
+ Element_Selector_Ptr selector = dynamic_cast<Element_Selector_Ptr>(node);
221
226
  std::cerr << ind << "Element_Selector " << selector;
222
227
  std::cerr << " (" << pstate_source_position(node) << ")";
223
228
  std::cerr << " <" << selector->hash() << ">";
@@ -228,10 +233,11 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
228
233
  std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
229
234
  std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">";
230
235
  std::cerr << std::endl;
231
- } else if (dynamic_cast<Placeholder_Selector*>(node)) {
236
+ } else if (dynamic_cast<Placeholder_Selector_Ptr>(node)) {
232
237
 
233
- Placeholder_Selector* selector = dynamic_cast<Placeholder_Selector*>(node);
234
- std::cerr << ind << "Placeholder_Selector [" << selector->ns_name() << "] " << selector
238
+ Placeholder_Selector_Ptr selector = dynamic_cast<Placeholder_Selector_Ptr>(node);
239
+ std::cerr << ind << "Placeholder_Selector [" << selector->ns_name() << "] " << selector;
240
+ std::cerr << " (" << pstate_source_position(selector) << ")"
235
241
  << " <" << selector->hash() << ">"
236
242
  << " [@media:" << selector->media_block() << "]"
237
243
  << (selector->is_optional() ? " [is_optional]": " -")
@@ -245,8 +251,8 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
245
251
  std::cerr << " (" << pstate_source_position(node) << ")";
246
252
  std::cerr << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << std::endl;
247
253
 
248
- } else if (dynamic_cast<Selector_Schema*>(node)) {
249
- Selector_Schema* selector = dynamic_cast<Selector_Schema*>(node);
254
+ } else if (dynamic_cast<Selector_Schema_Ptr>(node)) {
255
+ Selector_Schema_Ptr selector = dynamic_cast<Selector_Schema_Ptr>(node);
250
256
  std::cerr << ind << "Selector_Schema " << selector;
251
257
  std::cerr << " (" << pstate_source_position(node) << ")"
252
258
  << (selector->at_root() && selector->at_root() ? " [@ROOT]" : "")
@@ -255,196 +261,196 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
255
261
  << (selector->has_line_feed() ? " [line-feed]": " -")
256
262
  << std::endl;
257
263
 
258
- debug_ast(selector->contents(), ind + " ");
264
+ debug_ast(&selector->contents(), ind + " ");
259
265
  // for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
260
266
 
261
- } else if (dynamic_cast<Selector*>(node)) {
262
- Selector* selector = dynamic_cast<Selector*>(node);
267
+ } else if (dynamic_cast<Selector_Ptr>(node)) {
268
+ Selector_Ptr selector = dynamic_cast<Selector_Ptr>(node);
263
269
  std::cerr << ind << "Selector " << selector;
264
270
  std::cerr << " (" << pstate_source_position(node) << ")";
265
271
  std::cerr << (selector->has_line_break() ? " [line-break]": " -")
266
272
  << (selector->has_line_feed() ? " [line-feed]": " -")
267
273
  << std::endl;
268
274
 
269
- } else if (dynamic_cast<Media_Query_Expression*>(node)) {
270
- Media_Query_Expression* block = dynamic_cast<Media_Query_Expression*>(node);
275
+ } else if (dynamic_cast<Media_Query_Expression_Ptr>(node)) {
276
+ Media_Query_Expression_Ptr block = dynamic_cast<Media_Query_Expression_Ptr>(node);
271
277
  std::cerr << ind << "Media_Query_Expression " << block;
272
278
  std::cerr << " (" << pstate_source_position(node) << ")";
273
279
  std::cerr << (block->is_interpolated() ? " [is_interpolated]": " -")
274
280
  << std::endl;
275
- debug_ast(block->feature(), ind + " feature) ");
276
- debug_ast(block->value(), ind + " value) ");
281
+ debug_ast(&block->feature(), ind + " feature) ");
282
+ debug_ast(&block->value(), ind + " value) ");
277
283
 
278
- } else if (dynamic_cast<Media_Query*>(node)) {
279
- Media_Query* block = dynamic_cast<Media_Query*>(node);
284
+ } else if (dynamic_cast<Media_Query_Ptr>(node)) {
285
+ Media_Query_Ptr block = dynamic_cast<Media_Query_Ptr>(node);
280
286
  std::cerr << ind << "Media_Query " << block;
281
287
  std::cerr << " (" << pstate_source_position(node) << ")";
282
288
  std::cerr << (block->is_negated() ? " [is_negated]": " -")
283
289
  << (block->is_restricted() ? " [is_restricted]": " -")
284
290
  << std::endl;
285
- debug_ast(block->media_type(), ind + " ");
286
- for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
291
+ debug_ast(&block->media_type(), ind + " ");
292
+ for(const auto& i : block->elements()) { debug_ast(&i, ind + " ", env); }
287
293
 
288
- } else if (dynamic_cast<Media_Block*>(node)) {
289
- Media_Block* block = dynamic_cast<Media_Block*>(node);
294
+ } else if (dynamic_cast<Media_Block_Ptr>(node)) {
295
+ Media_Block_Ptr block = dynamic_cast<Media_Block_Ptr>(node);
290
296
  std::cerr << ind << "Media_Block " << block;
291
297
  std::cerr << " (" << pstate_source_position(node) << ")";
292
298
  std::cerr << " " << block->tabs() << std::endl;
293
- debug_ast(block->media_queries(), ind + " =@ ");
294
- if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
295
- } else if (dynamic_cast<Supports_Block*>(node)) {
296
- Supports_Block* block = dynamic_cast<Supports_Block*>(node);
299
+ debug_ast(&block->media_queries(), ind + " =@ ");
300
+ if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(&i, ind + " ", env); }
301
+ } else if (dynamic_cast<Supports_Block_Ptr>(node)) {
302
+ Supports_Block_Ptr block = dynamic_cast<Supports_Block_Ptr>(node);
297
303
  std::cerr << ind << "Supports_Block " << block;
298
304
  std::cerr << " (" << pstate_source_position(node) << ")";
299
305
  std::cerr << " " << block->tabs() << std::endl;
300
- debug_ast(block->condition(), ind + " =@ ");
301
- debug_ast(block->block(), ind + " <>");
302
- } else if (dynamic_cast<Supports_Operator*>(node)) {
303
- Supports_Operator* block = dynamic_cast<Supports_Operator*>(node);
306
+ debug_ast(&block->condition(), ind + " =@ ");
307
+ debug_ast(&block->block(), ind + " <>");
308
+ } else if (dynamic_cast<Supports_Operator_Ptr>(node)) {
309
+ Supports_Operator_Ptr block = dynamic_cast<Supports_Operator_Ptr>(node);
304
310
  std::cerr << ind << "Supports_Operator " << block;
305
311
  std::cerr << " (" << pstate_source_position(node) << ")"
306
312
  << std::endl;
307
- debug_ast(block->left(), ind + " left) ");
308
- debug_ast(block->right(), ind + " right) ");
309
- } else if (dynamic_cast<Supports_Negation*>(node)) {
310
- Supports_Negation* block = dynamic_cast<Supports_Negation*>(node);
313
+ debug_ast(&block->left(), ind + " left) ");
314
+ debug_ast(&block->right(), ind + " right) ");
315
+ } else if (dynamic_cast<Supports_Negation_Ptr>(node)) {
316
+ Supports_Negation_Ptr block = dynamic_cast<Supports_Negation_Ptr>(node);
311
317
  std::cerr << ind << "Supports_Negation " << block;
312
318
  std::cerr << " (" << pstate_source_position(node) << ")"
313
319
  << std::endl;
314
- debug_ast(block->condition(), ind + " condition) ");
315
- } else if (dynamic_cast<At_Root_Query*>(node)) {
316
- At_Root_Query* block = dynamic_cast<At_Root_Query*>(node);
320
+ debug_ast(&block->condition(), ind + " condition) ");
321
+ } else if (dynamic_cast<At_Root_Query_Ptr>(node)) {
322
+ At_Root_Query_Ptr block = dynamic_cast<At_Root_Query_Ptr>(node);
317
323
  std::cerr << ind << "At_Root_Query " << block;
318
324
  std::cerr << " (" << pstate_source_position(node) << ")"
319
325
  << std::endl;
320
- debug_ast(block->feature(), ind + " feature) ");
321
- debug_ast(block->value(), ind + " value) ");
322
- } else if (dynamic_cast<Supports_Declaration*>(node)) {
323
- Supports_Declaration* block = dynamic_cast<Supports_Declaration*>(node);
326
+ debug_ast(&block->feature(), ind + " feature) ");
327
+ debug_ast(&block->value(), ind + " value) ");
328
+ } else if (dynamic_cast<Supports_Declaration_Ptr>(node)) {
329
+ Supports_Declaration_Ptr block = dynamic_cast<Supports_Declaration_Ptr>(node);
324
330
  std::cerr << ind << "Supports_Declaration " << block;
325
331
  std::cerr << " (" << pstate_source_position(node) << ")"
326
332
  << std::endl;
327
- debug_ast(block->feature(), ind + " feature) ");
328
- debug_ast(block->value(), ind + " value) ");
329
- } else if (dynamic_cast<Block*>(node)) {
330
- Block* root_block = dynamic_cast<Block*>(node);
333
+ debug_ast(&block->feature(), ind + " feature) ");
334
+ debug_ast(&block->value(), ind + " value) ");
335
+ } else if (dynamic_cast<Block_Ptr>(node)) {
336
+ Block_Ptr root_block = dynamic_cast<Block_Ptr>(node);
331
337
  std::cerr << ind << "Block " << root_block;
332
338
  std::cerr << " (" << pstate_source_position(node) << ")";
333
339
  if (root_block->is_root()) std::cerr << " [root]";
334
340
  std::cerr << " " << root_block->tabs() << std::endl;
335
- if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
336
- } else if (dynamic_cast<Warning*>(node)) {
337
- Warning* block = dynamic_cast<Warning*>(node);
341
+ for(const Statement_Obj& i : root_block->elements()) { debug_ast(&i, ind + " ", env); }
342
+ } else if (dynamic_cast<Warning_Ptr>(node)) {
343
+ Warning_Ptr block = dynamic_cast<Warning_Ptr>(node);
338
344
  std::cerr << ind << "Warning " << block;
339
345
  std::cerr << " (" << pstate_source_position(node) << ")";
340
346
  std::cerr << " " << block->tabs() << std::endl;
341
- debug_ast(block->message(), ind + " : ");
342
- } else if (dynamic_cast<Error*>(node)) {
343
- Error* block = dynamic_cast<Error*>(node);
347
+ debug_ast(&block->message(), ind + " : ");
348
+ } else if (dynamic_cast<Error_Ptr>(node)) {
349
+ Error_Ptr block = dynamic_cast<Error_Ptr>(node);
344
350
  std::cerr << ind << "Error " << block;
345
351
  std::cerr << " (" << pstate_source_position(node) << ")";
346
352
  std::cerr << " " << block->tabs() << std::endl;
347
- } else if (dynamic_cast<Debug*>(node)) {
348
- Debug* block = dynamic_cast<Debug*>(node);
353
+ } else if (dynamic_cast<Debug_Ptr>(node)) {
354
+ Debug_Ptr block = dynamic_cast<Debug_Ptr>(node);
349
355
  std::cerr << ind << "Debug " << block;
350
356
  std::cerr << " (" << pstate_source_position(node) << ")";
351
357
  std::cerr << " " << block->tabs() << std::endl;
352
- debug_ast(block->value(), ind + " ");
353
- } else if (dynamic_cast<Comment*>(node)) {
354
- Comment* block = dynamic_cast<Comment*>(node);
358
+ debug_ast(&block->value(), ind + " ");
359
+ } else if (dynamic_cast<Comment_Ptr>(node)) {
360
+ Comment_Ptr block = dynamic_cast<Comment_Ptr>(node);
355
361
  std::cerr << ind << "Comment " << block;
356
362
  std::cerr << " (" << pstate_source_position(node) << ")";
357
363
  std::cerr << " " << block->tabs() <<
358
364
  " <" << prettyprint(block->pstate().token.ws_before()) << ">" << std::endl;
359
- debug_ast(block->text(), ind + "// ", env);
360
- } else if (dynamic_cast<If*>(node)) {
361
- If* block = dynamic_cast<If*>(node);
365
+ debug_ast(&block->text(), ind + "// ", env);
366
+ } else if (dynamic_cast<If_Ptr>(node)) {
367
+ If_Ptr block = dynamic_cast<If_Ptr>(node);
362
368
  std::cerr << ind << "If " << block;
363
369
  std::cerr << " (" << pstate_source_position(node) << ")";
364
370
  std::cerr << " " << block->tabs() << std::endl;
365
- debug_ast(block->predicate(), ind + " = ");
366
- debug_ast(block->block(), ind + " <>");
367
- debug_ast(block->alternative(), ind + " ><");
368
- } else if (dynamic_cast<Return*>(node)) {
369
- Return* block = dynamic_cast<Return*>(node);
371
+ debug_ast(&block->predicate(), ind + " = ");
372
+ debug_ast(&block->block(), ind + " <>");
373
+ debug_ast(&block->alternative(), ind + " ><");
374
+ } else if (dynamic_cast<Return_Ptr>(node)) {
375
+ Return_Ptr block = dynamic_cast<Return_Ptr>(node);
370
376
  std::cerr << ind << "Return " << block;
371
377
  std::cerr << " (" << pstate_source_position(node) << ")";
372
378
  std::cerr << " " << block->tabs() << std::endl;
373
- } else if (dynamic_cast<Extension*>(node)) {
374
- Extension* block = dynamic_cast<Extension*>(node);
379
+ } else if (dynamic_cast<Extension_Ptr>(node)) {
380
+ Extension_Ptr block = dynamic_cast<Extension_Ptr>(node);
375
381
  std::cerr << ind << "Extension " << block;
376
382
  std::cerr << " (" << pstate_source_position(node) << ")";
377
383
  std::cerr << " " << block->tabs() << std::endl;
378
- debug_ast(block->selector(), ind + "-> ", env);
379
- } else if (dynamic_cast<Content*>(node)) {
380
- Content* block = dynamic_cast<Content*>(node);
384
+ debug_ast(&block->selector(), ind + "-> ", env);
385
+ } else if (dynamic_cast<Content_Ptr>(node)) {
386
+ Content_Ptr block = dynamic_cast<Content_Ptr>(node);
381
387
  std::cerr << ind << "Content " << block;
382
388
  std::cerr << " (" << pstate_source_position(node) << ")";
383
389
  std::cerr << " [@media:" << block->media_block() << "]";
384
390
  std::cerr << " " << block->tabs() << std::endl;
385
- } else if (dynamic_cast<Import_Stub*>(node)) {
386
- Import_Stub* block = dynamic_cast<Import_Stub*>(node);
391
+ } else if (dynamic_cast<Import_Stub_Ptr>(node)) {
392
+ Import_Stub_Ptr block = dynamic_cast<Import_Stub_Ptr>(node);
387
393
  std::cerr << ind << "Import_Stub " << block;
388
394
  std::cerr << " (" << pstate_source_position(node) << ")";
389
395
  std::cerr << " [" << block->imp_path() << "] ";
390
396
  std::cerr << " " << block->tabs() << std::endl;
391
- } else if (dynamic_cast<Import*>(node)) {
392
- Import* block = dynamic_cast<Import*>(node);
397
+ } else if (dynamic_cast<Import_Ptr>(node)) {
398
+ Import_Ptr block = dynamic_cast<Import_Ptr>(node);
393
399
  std::cerr << ind << "Import " << block;
394
400
  std::cerr << " (" << pstate_source_position(node) << ")";
395
401
  std::cerr << " " << block->tabs() << std::endl;
396
402
  // std::vector<std::string> files_;
397
- for (auto imp : block->urls()) debug_ast(imp, ind + "@: ", env);
398
- debug_ast(block->media_queries(), ind + "@@ ");
399
- } else if (dynamic_cast<Assignment*>(node)) {
400
- Assignment* block = dynamic_cast<Assignment*>(node);
403
+ for (auto imp : block->urls()) debug_ast(&imp, ind + "@: ", env);
404
+ debug_ast(&block->import_queries(), ind + "@@ ");
405
+ } else if (dynamic_cast<Assignment_Ptr>(node)) {
406
+ Assignment_Ptr block = dynamic_cast<Assignment_Ptr>(node);
401
407
  std::cerr << ind << "Assignment " << block;
402
408
  std::cerr << " (" << pstate_source_position(node) << ")";
403
409
  std::cerr << " <<" << block->variable() << ">> " << block->tabs() << std::endl;
404
- debug_ast(block->value(), ind + "=", env);
405
- } else if (dynamic_cast<Declaration*>(node)) {
406
- Declaration* block = dynamic_cast<Declaration*>(node);
410
+ debug_ast(&block->value(), ind + "=", env);
411
+ } else if (dynamic_cast<Declaration_Ptr>(node)) {
412
+ Declaration_Ptr block = dynamic_cast<Declaration_Ptr>(node);
407
413
  std::cerr << ind << "Declaration " << block;
408
414
  std::cerr << " (" << pstate_source_position(node) << ")";
409
415
  std::cerr << " " << block->tabs() << std::endl;
410
- debug_ast(block->property(), ind + " prop: ", env);
411
- debug_ast(block->value(), ind + " value: ", env);
412
- debug_ast(block->block(), ind + " ", env);
413
- } else if (dynamic_cast<Keyframe_Rule*>(node)) {
414
- Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
416
+ debug_ast(&block->property(), ind + " prop: ", env);
417
+ debug_ast(&block->value(), ind + " value: ", env);
418
+ debug_ast(&block->block(), ind + " ", env);
419
+ } else if (dynamic_cast<Keyframe_Rule_Ptr>(node)) {
420
+ Keyframe_Rule_Ptr has_block = dynamic_cast<Keyframe_Rule_Ptr>(node);
415
421
  std::cerr << ind << "Keyframe_Rule " << has_block;
416
422
  std::cerr << " (" << pstate_source_position(node) << ")";
417
423
  std::cerr << " " << has_block->tabs() << std::endl;
418
- if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
419
- if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
420
- } else if (dynamic_cast<Directive*>(node)) {
421
- Directive* block = dynamic_cast<Directive*>(node);
424
+ if (has_block->name()) debug_ast(&has_block->name(), ind + "@");
425
+ if (has_block->block()) for(const Statement_Obj& i : has_block->block()->elements()) { debug_ast(&i, ind + " ", env); }
426
+ } else if (dynamic_cast<Directive_Ptr>(node)) {
427
+ Directive_Ptr block = dynamic_cast<Directive_Ptr>(node);
422
428
  std::cerr << ind << "Directive " << block;
423
429
  std::cerr << " (" << pstate_source_position(node) << ")";
424
430
  std::cerr << " [" << block->keyword() << "] " << block->tabs() << std::endl;
425
- debug_ast(block->selector(), ind + "~", env);
426
- debug_ast(block->value(), ind + "+", env);
427
- if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
428
- } else if (dynamic_cast<Each*>(node)) {
429
- Each* block = dynamic_cast<Each*>(node);
431
+ debug_ast(&block->selector(), ind + "~", env);
432
+ debug_ast(&block->value(), ind + "+", env);
433
+ if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(&i, ind + " ", env); }
434
+ } else if (dynamic_cast<Each_Ptr>(node)) {
435
+ Each_Ptr block = dynamic_cast<Each_Ptr>(node);
430
436
  std::cerr << ind << "Each " << block;
431
437
  std::cerr << " (" << pstate_source_position(node) << ")";
432
438
  std::cerr << " " << block->tabs() << std::endl;
433
- if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
434
- } else if (dynamic_cast<For*>(node)) {
435
- For* block = dynamic_cast<For*>(node);
439
+ if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(&i, ind + " ", env); }
440
+ } else if (dynamic_cast<For_Ptr>(node)) {
441
+ For_Ptr block = dynamic_cast<For_Ptr>(node);
436
442
  std::cerr << ind << "For " << block;
437
443
  std::cerr << " (" << pstate_source_position(node) << ")";
438
444
  std::cerr << " " << block->tabs() << std::endl;
439
- if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
440
- } else if (dynamic_cast<While*>(node)) {
441
- While* block = dynamic_cast<While*>(node);
445
+ if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(&i, ind + " ", env); }
446
+ } else if (dynamic_cast<While_Ptr>(node)) {
447
+ While_Ptr block = dynamic_cast<While_Ptr>(node);
442
448
  std::cerr << ind << "While " << block;
443
449
  std::cerr << " (" << pstate_source_position(node) << ")";
444
450
  std::cerr << " " << block->tabs() << std::endl;
445
- if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
446
- } else if (dynamic_cast<Definition*>(node)) {
447
- Definition* block = dynamic_cast<Definition*>(node);
451
+ if (block->block()) for(const Statement_Obj& i : block->block()->elements()) { debug_ast(&i, ind + " ", env); }
452
+ } else if (dynamic_cast<Definition_Ptr>(node)) {
453
+ Definition_Ptr block = dynamic_cast<Definition_Ptr>(node);
448
454
  std::cerr << ind << "Definition " << block;
449
455
  std::cerr << " (" << pstate_source_position(node) << ")";
450
456
  std::cerr << " [name: " << block->name() << "] ";
@@ -453,16 +459,17 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
453
459
  // std::cerr << " [signature: " << block->signature() << "] ";
454
460
  std::cerr << " [native: " << block->native_function() << "] ";
455
461
  std::cerr << " " << block->tabs() << std::endl;
456
- debug_ast(block->parameters(), ind + " params: ", env);
457
- if (block->block()) debug_ast(block->block(), ind + " ", env);
458
- } else if (dynamic_cast<Mixin_Call*>(node)) {
459
- Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
462
+ debug_ast(&block->parameters(), ind + " params: ", env);
463
+ if (block->block()) debug_ast(&block->block(), ind + " ", env);
464
+ } else if (dynamic_cast<Mixin_Call_Ptr>(node)) {
465
+ Mixin_Call_Ptr block = dynamic_cast<Mixin_Call_Ptr>(node);
460
466
  std::cerr << ind << "Mixin_Call " << block << " " << block->tabs();
467
+ std::cerr << " (" << pstate_source_position(block) << ")";
461
468
  std::cerr << " [" << block->name() << "]";
462
469
  std::cerr << " [has_content: " << block->has_content() << "] " << std::endl;
463
- debug_ast(block->arguments(), ind + " args: ");
464
- if (block->block()) debug_ast(block->block(), ind + " ", env);
465
- } else if (Ruleset* ruleset = dynamic_cast<Ruleset*>(node)) {
470
+ debug_ast(&block->arguments(), ind + " args: ");
471
+ if (block->block()) debug_ast(&block->block(), ind + " ", env);
472
+ } else if (Ruleset_Ptr ruleset = dynamic_cast<Ruleset_Ptr>(node)) {
466
473
  std::cerr << ind << "Ruleset " << ruleset;
467
474
  std::cerr << " (" << pstate_source_position(node) << ")";
468
475
  std::cerr << " [indent: " << ruleset->tabs() << "]";
@@ -470,44 +477,45 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
470
477
  std::cerr << (ruleset->at_root() ? " [@ROOT]" : "");
471
478
  std::cerr << (ruleset->is_root() ? " [root]" : "");
472
479
  std::cerr << std::endl;
473
- debug_ast(ruleset->selector(), ind + ">");
474
- debug_ast(ruleset->block(), ind + " ");
475
- } else if (dynamic_cast<Block*>(node)) {
476
- Block* block = dynamic_cast<Block*>(node);
480
+ debug_ast(&ruleset->selector(), ind + ">");
481
+ debug_ast(&ruleset->block(), ind + " ");
482
+ } else if (dynamic_cast<Block_Ptr>(node)) {
483
+ Block_Ptr block = dynamic_cast<Block_Ptr>(node);
477
484
  std::cerr << ind << "Block " << block;
478
485
  std::cerr << " (" << pstate_source_position(node) << ")";
479
486
  std::cerr << (block->is_invisible() ? " [INVISIBLE]" : "");
480
487
  std::cerr << " [indent: " << block->tabs() << "]" << std::endl;
481
- for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
482
- } else if (dynamic_cast<Textual*>(node)) {
483
- Textual* expression = dynamic_cast<Textual*>(node);
484
- std::cerr << ind << "Textual ";
488
+ for(const Statement_Obj& i : block->elements()) { debug_ast(&i, ind + " ", env); }
489
+ } else if (dynamic_cast<Textual_Ptr>(node)) {
490
+ Textual_Ptr expression = dynamic_cast<Textual_Ptr>(node);
491
+ std::cerr << ind << "Textual " << expression;
492
+ std::cerr << " (" << pstate_source_position(node) << ")";
485
493
  if (expression->type() == Textual::NUMBER) std::cerr << " [NUMBER]";
486
494
  else if (expression->type() == Textual::PERCENTAGE) std::cerr << " [PERCENTAGE]";
487
495
  else if (expression->type() == Textual::DIMENSION) std::cerr << " [DIMENSION]";
488
496
  else if (expression->type() == Textual::HEX) std::cerr << " [HEX]";
489
- std::cerr << expression << " [" << expression->value() << "]";
497
+ std::cerr << " [" << expression->value() << "]";
490
498
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
491
499
  if (expression->is_delayed()) std::cerr << " [delayed]";
492
500
  std::cerr << std::endl;
493
- } else if (dynamic_cast<Variable*>(node)) {
494
- Variable* expression = dynamic_cast<Variable*>(node);
501
+ } else if (dynamic_cast<Variable_Ptr>(node)) {
502
+ Variable_Ptr expression = dynamic_cast<Variable_Ptr>(node);
495
503
  std::cerr << ind << "Variable " << expression;
496
504
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
497
505
  std::cerr << " (" << pstate_source_position(node) << ")";
498
506
  std::cerr << " [" << expression->name() << "]" << std::endl;
499
507
  std::string name(expression->name());
500
- if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
501
- } else if (dynamic_cast<Function_Call_Schema*>(node)) {
502
- Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
508
+ if (env && env->has(name)) debug_ast(SASS_MEMORY_CAST(Expression, (*env)[name]), ind + " -> ", env);
509
+ } else if (dynamic_cast<Function_Call_Schema_Ptr>(node)) {
510
+ Function_Call_Schema_Ptr expression = dynamic_cast<Function_Call_Schema_Ptr>(node);
503
511
  std::cerr << ind << "Function_Call_Schema " << expression;
504
512
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
505
513
  std::cerr << " (" << pstate_source_position(node) << ")";
506
514
  std::cerr << "" << std::endl;
507
- debug_ast(expression->name(), ind + "name: ", env);
508
- debug_ast(expression->arguments(), ind + " args: ", env);
509
- } else if (dynamic_cast<Function_Call*>(node)) {
510
- Function_Call* expression = dynamic_cast<Function_Call*>(node);
515
+ debug_ast(&expression->name(), ind + "name: ", env);
516
+ debug_ast(&expression->arguments(), ind + " args: ", env);
517
+ } else if (dynamic_cast<Function_Call_Ptr>(node)) {
518
+ Function_Call_Ptr expression = dynamic_cast<Function_Call_Ptr>(node);
511
519
  std::cerr << ind << "Function_Call " << expression;
512
520
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
513
521
  std::cerr << " (" << pstate_source_position(node) << ")";
@@ -515,9 +523,9 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
515
523
  if (expression->is_delayed()) std::cerr << " [delayed]";
516
524
  if (expression->is_interpolant()) std::cerr << " [interpolant]";
517
525
  std::cerr << std::endl;
518
- debug_ast(expression->arguments(), ind + " args: ", env);
519
- } else if (dynamic_cast<Arguments*>(node)) {
520
- Arguments* expression = dynamic_cast<Arguments*>(node);
526
+ debug_ast(&expression->arguments(), ind + " args: ", env);
527
+ } else if (dynamic_cast<Arguments_Ptr>(node)) {
528
+ Arguments_Ptr expression = dynamic_cast<Arguments_Ptr>(node);
521
529
  std::cerr << ind << "Arguments " << expression;
522
530
  if (expression->is_delayed()) std::cerr << " [delayed]";
523
531
  std::cerr << " (" << pstate_source_position(node) << ")";
@@ -525,41 +533,41 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
525
533
  if (expression->has_rest_argument()) std::cerr << " [has_rest_argument]";
526
534
  if (expression->has_keyword_argument()) std::cerr << " [has_keyword_argument]";
527
535
  std::cerr << std::endl;
528
- for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
529
- } else if (dynamic_cast<Argument*>(node)) {
530
- Argument* expression = dynamic_cast<Argument*>(node);
536
+ for(const Argument_Obj& i : expression->elements()) { debug_ast(&i, ind + " ", env); }
537
+ } else if (dynamic_cast<Argument_Ptr>(node)) {
538
+ Argument_Ptr expression = dynamic_cast<Argument_Ptr>(node);
531
539
  std::cerr << ind << "Argument " << expression;
532
540
  std::cerr << " (" << pstate_source_position(node) << ")";
533
541
  std::cerr << " [" << expression->value() << "]";
534
542
  std::cerr << " [name: " << expression->name() << "] ";
535
543
  std::cerr << " [rest: " << expression->is_rest_argument() << "] ";
536
544
  std::cerr << " [keyword: " << expression->is_keyword_argument() << "] " << std::endl;
537
- debug_ast(expression->value(), ind + " value: ", env);
538
- } else if (dynamic_cast<Parameters*>(node)) {
539
- Parameters* expression = dynamic_cast<Parameters*>(node);
545
+ debug_ast(&expression->value(), ind + " value: ", env);
546
+ } else if (dynamic_cast<Parameters_Ptr>(node)) {
547
+ Parameters_Ptr expression = dynamic_cast<Parameters_Ptr>(node);
540
548
  std::cerr << ind << "Parameters " << expression;
541
549
  std::cerr << " (" << pstate_source_position(node) << ")";
542
550
  std::cerr << " [has_optional: " << expression->has_optional_parameters() << "] ";
543
551
  std::cerr << " [has_rest: " << expression->has_rest_parameter() << "] ";
544
552
  std::cerr << std::endl;
545
- for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
546
- } else if (dynamic_cast<Parameter*>(node)) {
547
- Parameter* expression = dynamic_cast<Parameter*>(node);
553
+ for(const Parameter_Obj& i : expression->elements()) { debug_ast(&i, ind + " ", env); }
554
+ } else if (dynamic_cast<Parameter_Ptr>(node)) {
555
+ Parameter_Ptr expression = dynamic_cast<Parameter_Ptr>(node);
548
556
  std::cerr << ind << "Parameter " << expression;
549
557
  std::cerr << " (" << pstate_source_position(node) << ")";
550
558
  std::cerr << " [name: " << expression->name() << "] ";
551
559
  std::cerr << " [default: " << expression->default_value() << "] ";
552
560
  std::cerr << " [rest: " << expression->is_rest_parameter() << "] " << std::endl;
553
- } else if (dynamic_cast<Unary_Expression*>(node)) {
554
- Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
561
+ } else if (dynamic_cast<Unary_Expression_Ptr>(node)) {
562
+ Unary_Expression_Ptr expression = dynamic_cast<Unary_Expression_Ptr>(node);
555
563
  std::cerr << ind << "Unary_Expression " << expression;
556
564
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
557
565
  std::cerr << " [delayed: " << expression->is_delayed() << "] ";
558
566
  std::cerr << " (" << pstate_source_position(node) << ")";
559
567
  std::cerr << " [" << expression->type() << "]" << std::endl;
560
- debug_ast(expression->operand(), ind + " operand: ", env);
561
- } else if (dynamic_cast<Binary_Expression*>(node)) {
562
- Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
568
+ debug_ast(&expression->operand(), ind + " operand: ", env);
569
+ } else if (dynamic_cast<Binary_Expression_Ptr>(node)) {
570
+ Binary_Expression_Ptr expression = dynamic_cast<Binary_Expression_Ptr>(node);
563
571
  std::cerr << ind << "Binary_Expression " << expression;
564
572
  if (expression->is_interpolant()) std::cerr << " [is interpolant] ";
565
573
  if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
@@ -569,20 +577,20 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
569
577
  std::cerr << " [ws_after: " << expression->op().ws_after << "] ";
570
578
  std::cerr << " (" << pstate_source_position(node) << ")";
571
579
  std::cerr << " [" << expression->type_name() << "]" << std::endl;
572
- debug_ast(expression->left(), ind + " left: ", env);
573
- debug_ast(expression->right(), ind + " right: ", env);
574
- } else if (dynamic_cast<Map*>(node)) {
575
- Map* expression = dynamic_cast<Map*>(node);
580
+ debug_ast(&expression->left(), ind + " left: ", env);
581
+ debug_ast(&expression->right(), ind + " right: ", env);
582
+ } else if (dynamic_cast<Map_Ptr>(node)) {
583
+ Map_Ptr expression = dynamic_cast<Map_Ptr>(node);
576
584
  std::cerr << ind << "Map " << expression;
577
585
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
578
586
  std::cerr << " (" << pstate_source_position(node) << ")";
579
587
  std::cerr << " [Hashed]" << std::endl;
580
- for (auto i : expression->elements()) {
581
- debug_ast(i.first, ind + " key: ");
582
- debug_ast(i.second, ind + " val: ");
588
+ for (const auto& i : expression->elements()) {
589
+ debug_ast(&i.first, ind + " key: ");
590
+ debug_ast(&i.second, ind + " val: ");
583
591
  }
584
- } else if (dynamic_cast<List*>(node)) {
585
- List* expression = dynamic_cast<List*>(node);
592
+ } else if (dynamic_cast<List_Ptr>(node)) {
593
+ List_Ptr expression = dynamic_cast<List_Ptr>(node);
586
594
  std::cerr << ind << "List " << expression;
587
595
  std::cerr << " (" << pstate_source_position(node) << ")";
588
596
  std::cerr << " (" << expression->length() << ") " <<
@@ -593,36 +601,43 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
593
601
  " [arglist: " << expression->is_arglist() << "] " <<
594
602
  " [hash: " << expression->hash() << "] " <<
595
603
  std::endl;
596
- for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
597
- } else if (dynamic_cast<Content*>(node)) {
598
- Content* expression = dynamic_cast<Content*>(node);
604
+ for(const auto& i : expression->elements()) { debug_ast(&i, ind + " ", env); }
605
+ } else if (dynamic_cast<Content_Ptr>(node)) {
606
+ Content_Ptr expression = dynamic_cast<Content_Ptr>(node);
599
607
  std::cerr << ind << "Content " << expression;
600
608
  std::cerr << " (" << pstate_source_position(node) << ")";
601
609
  std::cerr << " [@media:" << expression->media_block() << "]";
602
610
  std::cerr << " [Statement]" << std::endl;
603
- } else if (dynamic_cast<Boolean*>(node)) {
604
- Boolean* expression = dynamic_cast<Boolean*>(node);
611
+ } else if (dynamic_cast<Boolean_Ptr>(node)) {
612
+ Boolean_Ptr expression = dynamic_cast<Boolean_Ptr>(node);
605
613
  std::cerr << ind << "Boolean " << expression;
606
614
  std::cerr << " (" << pstate_source_position(node) << ")";
607
615
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
608
616
  std::cerr << " [" << expression->value() << "]" << std::endl;
609
- } else if (dynamic_cast<Color*>(node)) {
610
- Color* expression = dynamic_cast<Color*>(node);
617
+ } else if (dynamic_cast<Color_Ptr>(node)) {
618
+ Color_Ptr expression = dynamic_cast<Color_Ptr>(node);
611
619
  std::cerr << ind << "Color " << expression;
612
620
  std::cerr << " (" << pstate_source_position(node) << ")";
613
621
  std::cerr << " [delayed: " << expression->is_delayed() << "] ";
614
622
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
615
623
  std::cerr << " [" << expression->r() << ":" << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << std::endl;
616
- } else if (dynamic_cast<Number*>(node)) {
617
- Number* expression = dynamic_cast<Number*>(node);
624
+ } else if (dynamic_cast<Number_Ptr>(node)) {
625
+ Number_Ptr expression = dynamic_cast<Number_Ptr>(node);
618
626
  std::cerr << ind << "Number " << expression;
619
627
  std::cerr << " (" << pstate_source_position(node) << ")";
620
628
  std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
621
629
  std::cerr << " [" << expression->value() << expression->unit() << "]" <<
622
630
  " [hash: " << expression->hash() << "] " <<
623
631
  std::endl;
624
- } else if (dynamic_cast<String_Quoted*>(node)) {
625
- String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
632
+ } else if (dynamic_cast<Null_Ptr>(node)) {
633
+ Null_Ptr expression = dynamic_cast<Null_Ptr>(node);
634
+ std::cerr << ind << "Null " << expression;
635
+ std::cerr << " (" << pstate_source_position(node) << ")";
636
+ std::cerr << " [interpolant: " << expression->is_interpolant() << "] "
637
+ // " [hash: " << expression->hash() << "] "
638
+ << std::endl;
639
+ } else if (dynamic_cast<String_Quoted_Ptr>(node)) {
640
+ String_Quoted_Ptr expression = dynamic_cast<String_Quoted_Ptr>(node);
626
641
  std::cerr << ind << "String_Quoted " << expression;
627
642
  std::cerr << " (" << pstate_source_position(node) << ")";
628
643
  std::cerr << " [" << prettyprint(expression->value()) << "]";
@@ -630,8 +645,8 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
630
645
  if (expression->is_interpolant()) std::cerr << " [interpolant]";
631
646
  if (expression->quote_mark()) std::cerr << " [quote_mark: " << expression->quote_mark() << "]";
632
647
  std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
633
- } else if (dynamic_cast<String_Constant*>(node)) {
634
- String_Constant* expression = dynamic_cast<String_Constant*>(node);
648
+ } else if (dynamic_cast<String_Constant_Ptr>(node)) {
649
+ String_Constant_Ptr expression = dynamic_cast<String_Constant_Ptr>(node);
635
650
  std::cerr << ind << "String_Constant " << expression;
636
651
  if (expression->concrete_type()) {
637
652
  std::cerr << " " << expression->concrete_type();
@@ -641,26 +656,28 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
641
656
  if (expression->is_delayed()) std::cerr << " [delayed]";
642
657
  if (expression->is_interpolant()) std::cerr << " [interpolant]";
643
658
  std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
644
- } else if (dynamic_cast<String_Schema*>(node)) {
645
- String_Schema* expression = dynamic_cast<String_Schema*>(node);
659
+ } else if (dynamic_cast<String_Schema_Ptr>(node)) {
660
+ String_Schema_Ptr expression = dynamic_cast<String_Schema_Ptr>(node);
646
661
  std::cerr << ind << "String_Schema " << expression;
662
+ std::cerr << " (" << pstate_source_position(expression) << ")";
647
663
  std::cerr << " " << expression->concrete_type();
664
+ std::cerr << " (" << pstate_source_position(node) << ")";
648
665
  if (expression->is_delayed()) std::cerr << " [delayed]";
649
666
  if (expression->is_interpolant()) std::cerr << " [is interpolant]";
650
667
  if (expression->has_interpolant()) std::cerr << " [has interpolant]";
651
668
  if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
652
669
  if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
653
670
  std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
654
- for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
655
- } else if (dynamic_cast<String*>(node)) {
656
- String* expression = dynamic_cast<String*>(node);
671
+ for(const auto& i : expression->elements()) { debug_ast(&i, ind + " ", env); }
672
+ } else if (dynamic_cast<String_Ptr>(node)) {
673
+ String_Ptr expression = dynamic_cast<String_Ptr>(node);
657
674
  std::cerr << ind << "String " << expression;
658
675
  std::cerr << " " << expression->concrete_type();
659
676
  std::cerr << " (" << pstate_source_position(node) << ")";
660
677
  if (expression->is_interpolant()) std::cerr << " [interpolant]";
661
678
  std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
662
- } else if (dynamic_cast<Expression*>(node)) {
663
- Expression* expression = dynamic_cast<Expression*>(node);
679
+ } else if (dynamic_cast<Expression_Ptr>(node)) {
680
+ Expression_Ptr expression = dynamic_cast<Expression_Ptr>(node);
664
681
  std::cerr << ind << "Expression " << expression;
665
682
  std::cerr << " (" << pstate_source_position(node) << ")";
666
683
  switch (expression->concrete_type()) {
@@ -675,17 +692,18 @@ inline void debug_ast(AST_Node* node, std::string ind, Env* env)
675
692
  case Expression::Concrete_Type::NULL_VAL: std::cerr << " [NULL_VAL]"; break;
676
693
  case Expression::Concrete_Type::C_WARNING: std::cerr << " [C_WARNING]"; break;
677
694
  case Expression::Concrete_Type::C_ERROR: std::cerr << " [C_ERROR]"; break;
695
+ case Expression::Concrete_Type::FUNCTION: std::cerr << " [FUNCTION]"; break;
678
696
  case Expression::Concrete_Type::NUM_TYPES: std::cerr << " [NUM_TYPES]"; break;
679
697
  }
680
698
  std::cerr << std::endl;
681
- } else if (dynamic_cast<Has_Block*>(node)) {
682
- Has_Block* has_block = dynamic_cast<Has_Block*>(node);
699
+ } else if (dynamic_cast<Has_Block_Ptr>(node)) {
700
+ Has_Block_Ptr has_block = dynamic_cast<Has_Block_Ptr>(node);
683
701
  std::cerr << ind << "Has_Block " << has_block;
684
702
  std::cerr << " (" << pstate_source_position(node) << ")";
685
703
  std::cerr << " " << has_block->tabs() << std::endl;
686
- if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
687
- } else if (dynamic_cast<Statement*>(node)) {
688
- Statement* statement = dynamic_cast<Statement*>(node);
704
+ if (has_block->block()) for(const Statement_Obj& i : has_block->block()->elements()) { debug_ast(&i, ind + " ", env); }
705
+ } else if (dynamic_cast<Statement_Ptr>(node)) {
706
+ Statement_Ptr statement = dynamic_cast<Statement_Ptr>(node);
689
707
  std::cerr << ind << "Statement " << statement;
690
708
  std::cerr << " (" << pstate_source_position(node) << ")";
691
709
  std::cerr << " " << statement->tabs() << std::endl;
@@ -703,11 +721,11 @@ inline void debug_node(Node* node, std::string ind = "")
703
721
  std::cerr << node << " ";
704
722
  if (node->got_line_feed) std::cerr << "[LF] ";
705
723
  switch (node->combinator()) {
706
- case Sequence_Selector::ADJACENT_TO: std::cerr << "{+} "; break;
707
- case Sequence_Selector::PARENT_OF: std::cerr << "{>} "; break;
708
- case Sequence_Selector::PRECEDES: std::cerr << "{~} "; break;
709
- case Sequence_Selector::REFERENCE: std::cerr << "{@} "; break;
710
- case Sequence_Selector::ANCESTOR_OF: std::cerr << "{ } "; break;
724
+ case Complex_Selector::ADJACENT_TO: std::cerr << "{+} "; break;
725
+ case Complex_Selector::PARENT_OF: std::cerr << "{>} "; break;
726
+ case Complex_Selector::PRECEDES: std::cerr << "{~} "; break;
727
+ case Complex_Selector::REFERENCE: std::cerr << "{@} "; break;
728
+ case Complex_Selector::ANCESTOR_OF: std::cerr << "{ } "; break;
711
729
  }
712
730
  std::cerr << std::endl;
713
731
  // debug_ast(node->combinator(), ind + " ");
@@ -717,7 +735,7 @@ inline void debug_node(Node* node, std::string ind = "")
717
735
  std::cerr << node << " ";
718
736
  if (node->got_line_feed) std::cerr << "[LF] ";
719
737
  std::cerr << std::endl;
720
- debug_ast(node->selector(), ind + " ");
738
+ debug_ast(&node->selector(), ind + " ");
721
739
  } else if (node->isCollection()) {
722
740
  std::cerr << ind;
723
741
  std::cerr << "Collection ";
@@ -743,35 +761,36 @@ inline void debug_node(Node* node, std::string ind = "")
743
761
  if (ind == "") std::cerr << "#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n";
744
762
  }
745
763
 
746
- inline void debug_ast(const AST_Node* node, std::string ind = "", Env* env = 0)
764
+ /*
765
+ inline void debug_ast(const AST_Node_Ptr node, std::string ind = "", Env* env = 0)
747
766
  {
748
- debug_ast(const_cast<AST_Node*>(node), ind, env);
767
+ debug_ast(const_cast<AST_Node_Ptr>(node), ind, env);
749
768
  }
750
-
769
+ */
751
770
  inline void debug_node(const Node* node, std::string ind = "")
752
771
  {
753
772
  debug_node(const_cast<Node*>(node), ind);
754
773
  }
755
774
 
756
- inline void debug_subset_map(Sass::ExtensionSubsetMap& map, std::string ind = "")
775
+ inline void debug_subset_map(Sass::Subset_Map& map, std::string ind = "")
757
776
  {
758
777
  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
759
778
  for(auto const &it : map.values()) {
760
- debug_ast(it.first, ind + "first: ");
761
- debug_ast(it.second, ind + "second: ");
779
+ debug_ast(&it.first, ind + "first: ");
780
+ debug_ast(&it.second, ind + "second: ");
762
781
  }
763
782
  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
764
783
  }
765
784
 
766
- typedef std::pair<Sequence_Selector*, SimpleSequence_Selector*> ExtensionPair;
785
+ typedef std::pair<Complex_Selector_Obj, Compound_Selector_Obj> ExtensionPair;
767
786
  typedef std::vector<ExtensionPair> SubsetMapEntries;
768
787
 
769
788
  inline void debug_subset_entries(SubsetMapEntries* entries, std::string ind = "")
770
789
  {
771
790
  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
772
791
  for(auto const &pair : *entries) {
773
- debug_ast(pair.first, ind + "first: ");
774
- debug_ast(pair.second, ind + "second: ");
792
+ debug_ast(&pair.first, ind + "first: ");
793
+ debug_ast(&pair.second, ind + "second: ");
775
794
  }
776
795
  if (ind == "") std::cerr << "#%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
777
796
  }