sassc 1.11.1 → 1.11.2

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